Class

类加载过程

  1. 程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）。接着我们使用java.exe命令对某个字节码文件进行解析运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
  2. Class的实例对应着一个运行时类。
  3. 加载到内存中的运行时类，会缓存一定时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

获取Class的实例的方式

  1. 方式一：调用运行时类的属性，类.class

    @Test
public void test1() {
    Class clazz1 = Person.class; 
}

  2. 方式二：通过运行时类的对象，调用getClass()

    @Test
public void test2() {
    Person p1 = new Person();
    Class clazz2 = p1.getClass();
}

  3. 方式三：调用Class的静态方法，forName(String classPath)

    Class.forName("top.lukeewin.Person");

  4. 方式四（了解）：使用类的加载器，ClassLoader

    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class class4 = classLoader.loadClass("top.lukeewin.Person");

类的加载过程

Load(类的加载)—>Link(类的链接)—>Initialize(类的初始化)

Load: 将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程有类加载器完成。

Link: 将类的二进制数据合并到JRE中

Initialize: JVM负责对类进行初始化

类的加载与ClassLoader的理解

image-20210604162322660

  • 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

通过ClassLoader加载配置文件

@Test
     public void test3() throws IOException {
          Properties pros = new Properties();
          ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
          //注意：默认的访问路径是src下
          InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
          pros.load(is);

          String user = pros.getProperty("user");
          String password = pros.getProperty("password");
          System.out.println("user=" + user + ", password=" + password);
     }

注意：在src目录下创建配置文件jdbc.properties，不要在module下创建配置文件，因为发布到Tomcat时会丢失配置文件。

调用运行时类中指定的结构：属性、方法、构造器

获取指定属性

  1. 创建运行时类的对象

    Class clazz = Person.class;

    Person p = clazz.newInstance();

  2. 获取运行时类的指定变量名的属性

    Field d = clazz.getDeclaredField(String fieldName);

  3. 保证当前属性是可访问的

    d.setAccessible(true);

  4. 设置指定对象的属性的值

    d.set(p, "abc");

  5. 获取指定对象属性的值

    d.get(p);

获取指定方法

  1. 创建运行时类的对象

    Class clazz = Person.class;

    Person p = (Person) clazz.newInstance();

  2. 获取运行时类的指定方法

    Method method = clazz.getDeclaredMethod("method", String.class);

  3. 保证当前方法是可访问的

    method.setAccessible(true);

  4. 调用invoke()方法，参数1：方法的调用者，参数2：指明实参

    Object hello = method.invoke(p, "hello");

    注意：调用invoke方法返回值类型是你所调用的方法的返回值

注意：静态方法的调用

因为已经知道了所调用的静态方法属于哪个类的，所以在调用invoke方法时，与所传递的第一个参数无关，也可以传递null。

	@Test
    public void testMethod() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        //指明调用哪个方法
        Method showDesc = clazz.getDeclaredMethod("showDesc");
        //设置可以访问
        showDesc.setAccessible(true);
        //Object invoke = showDesc.invoke(Person.class);
        //因为已经知道showDesc是哪个类的静态方法了，所以也可以在invoke()的参数中传递null
        Object invoke = showDesc.invoke(null);
        System.out.println(invoke);
    }

获取指定构造器

	/**
     * 如何调用运行时类中的指定的构造器
     */
    @Test
    public void testConstructor() throws Exception {
        Class<Person> clazz = Person.class;

        // 1. 获取指定的构造器
        Constructor<Person> declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);

        // 2. 保证此构造器是可访问的
        declaredConstructor.setAccessible(true);

        // 3. 调用此构造器创建运行时类的对象
        Person person = declaredConstructor.newInstance("古力娜扎", 18);
        System.out.println(person);
    }

动态代理

package top.lukeewin.demo22;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Human {
    String getBelief();
    void eat(String food);
}

//被代理类
class SuperMan implements Human {

    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

class HumanUtil {
    public void method1() {
        System.out.println("*************通用方法一*************");
    }

    public void method2() {
        System.out.println("*************通用方法二*************");
    }
}

/*
* 要想实现动态代理需要解决的问题？
* 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
* 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法。
* */
class ProxyFactory {
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj) { //obj是被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandler implements InvocationHandler {

    private Object obj; //需要使用被代理的对象进行赋值

    public void bind(Object obj) {
        this.obj = obj;
    }
    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil util = new HumanUtil();
        util.method1();
        //method: 即为代理对象调用的方法，此方法也就作为了被代理对象要调用的方法
        //obj: 被代理类的对象
        Object returnValue = method.invoke(obj, args);
        util.method2();
        //上述方法的返回值就作为当前类中的invoke()的返回值
        return returnValue;
    }
}

/*
* 动态代理
* */
public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance: 代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");

        System.out.println("************************");

        NikeClothFactory nike = new NikeClothFactory();
        ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nike);
        proxyClothFactory.produceCloth();
    }
}

Q.E.D.

热爱生活，热爱程序