java 热加载maven java 模块化 热加载

类加载&反射&模块化

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过类的加载，类的连接，类的初始化来对类进行初始化。如果不出意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载或者类初始化

类的加载：

• 就是将class文件读入内存，并为其创建一个java.lang.Class对象
• 任何类被使用时，系统都会为之建立一个java.lang.Class对象

类的连接：

• 验证阶段：用于检验被加载的类是否有正确的内部结构，并和其它类协调一致
• 准备阶段：负责为类的类变量分配内存，并设置默认初始化值
• 解析阶段：将类的二进制数据中的符号引用替换为直接引用

类的初始化：

• 在该阶段，主要是对类变量进行初始化

类加载

类的初始化步骤

• 假如类还未被加载和连接，则程序先加载并连接该类
• 假如该类的直接父类还未被初始化，则先初始化其直接父类
• 假如类中有初始化语句，则系统依次执行这些初始化语句

类的初始化时机：

• 创建类的实例
• 调用类的类方法
• 访问类或者接口的类变量，或者为该类变量赋值
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类
• 直接使用java.exe命令来运行某个主类

类加载器

类加载器的通

• 负责将.class文件加载到内存中，并为之生成对应的java.lang.Class对象

JVM的类加载机制

• 全盘负责
• 父类委托
• 缓存机制

ClassLoader：是负责加载类的对象

Java运行时具有以下内置类加载器

• Bootstrap class loader：是虚拟机的内置类加载器，通常表示为null
• Platform class loader：平台类加载器
• System class loader：应用程序类加载器
• 类加载器的继承关系：System的父加载器为Platform，Platform的父加载器为Bootstrap

ClassLoader中的两个方法

• static ClassLoader getSystemClassLoader()：返回用于委派的系统类加载器
• ClassLoader getParent()：返回父类加载器进行委派

反射

Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍可以扩展

获取Class类的对象

我们要想通过反射区使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class的对象，有三种方法获取Class类型的对象

• 使用类的class属性来获取该类对应的Class对象。Student.class
• 调用对象的getClass()方法返回该对象所属类对应的Class对象，该方法是Object类中的方法，所有的Java对象都可以调用该方法
• 使用CLass类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径

/**
 * @author: 小码农
 * @create: 2021-08-09 10:50
 **/
public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性获取对应的clss对象
        Class<Student> c1 = Student.class;
        Class<Student> c2 = Student.class;
        System.out.println(c1);
        System.out.println(c2==c1);
        System.out.println("---------------");
        //.getClass
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);
        System.out.println("-----------------");
        //forName
        Class<?> c4 = Class.forName("Student");
        System.out.println(c1==c4);
    }
}

反射获取构造方法并使用

Class类中用于获取构造方法的方法

• getConstructors()方法，返回对象的公共构造函数数组
• getDeclaredConstructors()方法，返回对象的所有构造函数数组，公共、私有、默认
• 获取对象单个的构造方法getConstructor，返回单个公共构造方法
• getDeclaredConstructor()方法，返回单个构造方法对象，包含公共、私有默认

Constructor类中用于创建对象的方法

• T newInstance(Object … initargs)：根据指定的构造方法创建对象

练习

练习1：通过反射实现如下操作

• Student s = new Student(“林青霞”,30,“西安”);
• System.out.println(s);
• 基本数据类型可以通过.class得到对应的类型

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author: 小码农
 * @create: 2021-08-09 11:47
 **/
public class Demo4 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Student> s = Student.class;
        Constructor<Student> con = s.getConstructor(String.class, int.class, String.class);
        Student stu = con.newInstance("林青霞", 33, "西安");
        System.out.println(stu);
    }
}

练习2

• Student s = new Student(“林青霞”);
• System.out.println(s);
• public void setAccessible(boolean b)：值为true，取消访问检查

Constructor<Student> de1 = s.getDeclaredConstructor(String.class);
//暴力反射 public void setAccessible(boolean b)：值为true，取消访问检查
de1.setAccessible(true);
Student stu2 = de1.newInstance("林青霞");
System.out.println(stu2);

反射获取成员变量并使用

Class类中用于获取成员变量的方法

• Field[] getFields()：返回所有公共成员变量对象的数组
• Field[] getDeclaredFields()：返回所有成员变量对象的数组
• Field getField(String name)：返回单个公共成员变量对象
• Field getDeclaredField(String name)：返回单个成员变量对象

Field类中用于给成员变量赋值的方法

• void set(Object o,Object value)：给obj对象的成员变量赋值为value
• public void setAccessible(boolean b)：值为true，取消访问检查

import java.io.FileWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Calendar;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:26
 **/
public class Demo5 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class<?> s1 = Class.forName("Student");
        /*
        Field[] getFields()返回一个包含Field对象的数组
        Field[] getDeclaredFields()返回一个包含Field对象的数组，包含私有默认
         */
//        Field[] fields = s1.getFields();
        Field[] fields = s1.getDeclaredFields();
        for (Field f:fields){
            System.out.println(f);
        }
        System.out.println("----------------");
        //Field getField 返回Field对象
        //Field getDeclaredField 返回Field对象
        Field address = s1.getField("address");
        //获取无参构造方法创建对象
        Constructor<?> con = s1.getConstructor();
        Object o = con.newInstance();
        //对成员变量赋值
        address.set(o,"西安");
        System.out.println(o);
    }
}

反射获取成员变量并使用练习

练习：通过反射做到以下操作

• Student s = new Student();
• s.name = “林青霞”;
• s.age = 30;
• s.address = “西安”;
• System.out.println(s);

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:42
 **/
public class Demo6 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<?> stu = Class.forName("Student");
        Field name = stu.getDeclaredField("name");
        Field age = stu.getDeclaredField("age");
        Field address = stu.getField("address");
        name.setAccessible(true);   //私有变量使用setAccessible取消检查


        Constructor<?> con = stu.getConstructor();
        Object obj = con.newInstance();
        name.set(obj,"李红");
        age.set(obj,33);
        address.set(obj,"陕西");
        System.out.println(obj);
    }
}

反射获取成员方法并使用

Class类中用于获取成员方法的方法

• Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
• Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
• Method getMethod(String name)：根据传入的方法名称，返回单个公共成员方法对象
• Method getDeclaredMethod(String name)：返回单个成员方法对象

Method类中用于调用成员方法的方法

• Object invoke(Object obj,Object…args)：调用obj对象的成员方法，参数是args，返回值是Object类型

成员方法对象.invoke(obj);

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author: 小码农
 * @create: 2021-08-09 15:52
 **/
public class Demo7 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //第一步获取Class对象
        Class<?> stu = Class.forName("Student");
        Constructor<?> con = stu.getConstructor();
        Object obj = con.newInstance();

        //返回方法对象数组
        /*Method[] getMethods()返回一个包含方法对象的数组，包含所有公共方法
        Method[] getDeclaredMethods()返回包含所有方法对象的数组，包含私有、默认*/
//        Method[] methods = stu.getMethods();
        Method[] methods = stu.getDeclaredMethods();
        for (Method method:methods){
            System.out.println(method);
        }

        //返回单个方法getMethod
        Method toString = stu.getMethod("toString");

        //返回单个方法，私有方法可以用 getDeclaredMethod()
        Method method2 = stu.getDeclaredMethod("method2", String.class);

        System.out.println("---------------");
        //我们获取方法对象可以使用反射做什么,可以通过对象调方法
        Object invoke = toString.invoke(obj);
        System.out.println(invoke);
        Object ssss = method2.invoke(obj, "ssss");
        System.out.println(ssss);
    }
}

练习：通过反射实现如下操作

• Student s = new Student();
• s.method1();
• s.method2(“林青霞”);
• String ss = s.method3(“林青霞”,30);
• System.out.println(ss);
• s.function();

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:09
 **/
public class Demo8 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //创建Class对象
        Class<?> stu = Class.forName("Student");

        //通过Class对象获取构造方法
        Constructor<?> con = stu.getConstructor();

        //通过构造方法对象创建Student对象
        Object obj = con.newInstance();

        //创建成员方法对象
        Method method1 = stu.getDeclaredMethod("method1");
        method1.setAccessible(true);
        Method method2 = stu.getDeclaredMethod("method2", String.class);
        method2.setAccessible(true);
        Method method3 = stu.getDeclaredMethod("method3", String.class, int.class);
        method3.setAccessible(true);

        Method func = stu.getDeclaredMethod("function");
        func.setAccessible(true);

        //使用成员方法
        method1.invoke(obj);    //没有返回值
        method2.invoke(obj, "李红");  //没有返回值

        Object in3 = method3.invoke(obj, "王伟", 33);
        System.out.println(in3);

        func.invoke(obj);

    }
}

/**
 * @author: 小码农
 * @create: 2021-08-09 11:19
 **/
public class Student {
    private String name;
    int age;
    public String address;
    public Student(){

    }
    private Student(String name){
        this.name=name;
    }
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    private void function(){
        System.out.println("function");
    }
    public void method1(){
        System.out.println("method1");
    }
    public void method2(String s){
        System.out.println("method"+s);

    }
    public String method3(String s,int i){
        return s+","+i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

反射练习

练习1：在一个ArrayList<Integer>集合中添加一个字符串数据

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:30
 * 练习1：在一个ArrayList<Integer>集合中添加一个字符串数据
 **/
public class Demo9 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //创建集合
        ArrayList<Integer> arrayList = new ArrayList<>();

        arrayList.add(10);
        arrayList.add(20);
        //传统的添加方法无法添加字符串元素，我们使用反射越过添加类型检查
        Class<? extends ArrayList> c = arrayList.getClass();
        Method meth = c.getDeclaredMethod("add", Object.class);
        meth.invoke(arrayList,"hello");
        meth.invoke(arrayList,"world");

        System.out.println(arrayList);
    }
}

练习2：通过配置文件运行类中的方法

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @author: 小码农
 * @create: 2021-08-09 16:35
 * 练习2：通过配置文件运行类中的方法
 **/
public class Demo10 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, IOException, ClassNotFoundException, InstantiationException {
        /*Stu stu = new Stu();
        Class<? extends Stu> s = stu.getClass();
        Method study = s.getDeclaredMethod("study");
        study.setAccessible(true);
        study.invoke(stu);*/

        /*  使用配置文件
            class.txt
            className = xxx
            methodName = xxx
         */
        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("E:\\MYZ\\Code\\JAVA\\20210809\\src\\Class.txt");
        prop.load(fr);
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射来使用
        Class<?> c = Class.forName(className);
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getDeclaredMethod(methodName);
        m.invoke(obj);

    }
}

Class.txt

className = Tea
methodName = teach

模块化

概述

如今，java语言过于庞大，无论是运行小程序还是运行一个大型程序，都需要JVM加载整个JRE环境。因此Java 9退出了模块化系统，允许Java程序可以根据需要选择加载必须的Java模块。

模块的基本使用

基本使用步骤

• 创建模块，按照以前的讲解方式创建模块，创建包，创建类，定义方法

• 为了体现模块的使用，我们创建两个模块，一个是myOne，一个是myTwo

• 在模块的src目录下新建一个名为moudule-info.java的描述性文件，该文件专门定义模块名，访问权限，模块依赖等信息。描述性文件中使用模块导出和模块依赖来进行配置并使用（JDK 9以上才有）
• 模块中所有未导出的包都是模块私有的，它们不能在模块之外被访问

• 在myOne这个模块下的描述性文件转给你配置模块导出
• 模块导出格式：exports 包名

• 一个模块要访问其他的模块，必须明确指定依赖哪些模块，未明确指定依赖的模块不能访问。在myTwo这个模块下的描述性文件中配置模块依赖

• 模块依赖格式：requires 模块名;
• 注意：写模块名报错，需要按Alt+Enter提示，然后选择模块依赖

• 现在，在myTwo模块的类中可以使用依赖模块下的内容

总结：

• 简单来说就是在被使用类模块的描述性文件中需要导出包含类的包，exports 包名
• 在使用者模块的描述性文件中要依赖被使用模块，requires 被使用类模块名

模块服务的使用

服务：从Java6开始，Java提供了一种服务机制，允许服务提供者和服务使用者之间完成解耦，简单来说，就是服务使用者只面向接口编程， 但不清楚服务提供者的实现类

Java 9模块化系统进一步简化了Java的服务机制。Java 9允许将服务接口定义在一个模块中，并使用uses语句来声明该服务接口，然后针对该服务接口提供不同的服务实现类，这些服务实现类可以分布在不同的模块中，服务实现模块则使用provides语句为服务接口指定实现类，服务使用者只需要面向接口编程即可

模块服务的使用步骤

• 在myOne模块下创建一个包com.itheima_03，在该包下提供一个接口，接口中定义一个抽象方法

public interface MyServer{
	void service();
}

• 在com.itheima_03包下创建一个包impl，在该包下提供接口的两个实现类Itheima和Czxy
• 在myOne这个模块下的描述性文件中添加配置：

• 模块导出：exports com.itheima_03
• 服务提供：provides MyServer with Itheima; 指定MyServer的服务实现类是Itheima

• 在myTwo这个模块下的描述文件中添加配置

• 声明服务接口：uses MyService;

• 在myTwo模块的类中使用Myservice接口提供的服务

• ServiceLoader：一种加载服务实现的工具

package cn.itcast;
import com.myz03.MyServer;
import java.util.ServiceLoader;

/**
 * @author: 小码农
 * @create: 2021-08-09 18:09
 **/
public class Demo2 {
    public static void main(String[] args) {
        //加载服务
        ServiceLoader<MyServer> load = ServiceLoader.load(MyServer.class);

        //遍历服务
        for (MyServer ser:load){
            ser.service();
        }
    }
}