反射及动态代理

反射

动态构建，操作类的一种手段，重要！
比如，bean的加载，初始化。销毁，就是用反射实现

https://blog.csdn.net/weixin_42724467/article/details/84311385?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.control

helloword 反射调用实例

         Class<?> aClass = Class.forName("security.Children",false, ClassUtils.getDefaultClassLoader());
        Method helloword = aClass.getDeclaredMethod("helloword",null);
        System.out.println(helloword);
        helloword.invoke(aClass.newInstance(),null); // 调用成员无参数方法
        Method main = aClass.getDeclaredMethod("main",String[].class);
        System.out.println(main);
        main.invoke(null,new Object[]{new String[]{}}); // 调用静态有参数方法

动态代理

jdk动态代理，，只能代理接口 Proxy.newProxyInstance 只能强转成接口类型
下面的demo会报错，强转类型改成接口OK

demo

代理类

public class InvocetionHandler implements InvocationHandler {
    private Object target;
    public void setTarget(Object target)
    {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("befpre");
        Object invoke = method.invoke(target, args);
        System.out.println("after");
        return invoke;
    }
    // 生成代理类
    public Object CreatProxyedObj()
    {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

功能类

public class HelloImpl implements Hello{
    @Override
    public String sayHello() {
        System.out.println("hello");
        return "hello";
    }
    public String sayHello1() {
        System.out.println("hello1");
        return "hello";
    }
}

功能接口

public interface Hello {
    String sayHello();
}

源码

重点在 Proxy.newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h) 方法

这个方法返回代理类，如果不存在就新建一个，核心方法

proxyClassCache 是缓存的重要结构，后面介绍

KeyFactory 简单工厂，实现函数式接口就是根据接口长度实现包装

就看 key1 实现key的弱引用

重点1 ProxyClassFactory 就是这里动态生成了代理类，后面用到再看

先了解几个变量

开始看get方法

重点2：

看上面的get方法

此时已经拿到了代理类

结束

调用接口方法会直接调用 h的invoke方法
怎么实现的？？
理论上可以代理任何接口，像这样
是不是有点注入的味道？

        Class<?>[] a = {Hello.class,Pole.class};
        Class<?> helloImpl = Class.forName("entry.HelloImpl");
        // 用默认的类加载器
        Object o1 = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), a, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return method.invoke(BeanUtils.instantiateClass(helloImpl), args);
            }
        });
        ((Hello) o1).sayHello();
        ((Pole) o1).syaBey();