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.


热爱生活,热爱程序