Bootstrap

AOP-动态代理-反射

1、什么是反射机制呢？

2、什么是代理模式呢？

3、静态代理和动态代理的区别是什么呢？

java面试常问：AOP 如何实现？动态代理是基于什么原理实现的？

简单回答：AOP通过动态代理实现，动态代理基于反射机制实现。

既然要搞清楚AOP的实现，那么我们就搞清楚动态代理的具体原理。要了解动态代理，那我们必须要谈的就是java的反射机制。

1、什么是反射机制呢？

反射机制是Java语言提供的一种基础功能，赋予程序在运行时自省（introspect，官方用语）的能力。通过反射我们可以直接操作类或者对象，比如获取某个对象的类定义，获取类声明的属性和方法，调用方法或者构造对象，甚至可以运行时修改类定义。

2、什么是代理模式呢？

代理模式 可以详细控制访问某个(某类）对象的方法，在调用这个方法前做前置处理或者调用这个方法后做一些后置处理。从而实现将统一流程代码放到代理类中处理。代理模式又分为静态代理和动态代理

简单来说就是在你主要的业务功能实现前、后帮你做一些事情。

例如：

1、你写了一个方法a去查询数据库数据，在你的方法a执行前需要进行数据库连接操作，在执行后需要关闭数据库连接。在你使用mybatis的时候mybatis会帮你去进行连接和关闭连接的操作。而你只需要写查询数据库数据的方法，这就是代理

2、rpc调用的时候，代理类会帮我们寻找下游服务器并建立连接，并且调用结束后帮我们关闭连接。

3、静态代理和动态代理的区别是什么呢？

  • 静态代理：自己写代理类，去实现某个指定的类的某个方法的代理，没有任何扩展性。
  • 动态代理：动态代理是一种方便运行时动态构建代理、动态处理代理方法调用的机制。一个代理类可以服务于所有的业务对象。

4、动态代理主要的实现方式和区别？

  • 实现动态代理的方式很多，比如JDK自身提供的动态代理，就是主要利用了反射机制。还有其他的实现方式，比如利用传说中更高性能的字节码操作机制，类似ASM、cglib（基于ASM）、Javassist等。
  • JDK和cglib实现动态代理的区别
    • JDK实现动态代理主要是以接口为中心。JDK提供的代理类，会实现被代理对象的接口。
    • cglib主要原理是为被代理类生成子类，通过继承被代理对象的方法去实现动态代理
    • 如果对象有接口实现，选择JDK代理，如果没有接口实现选择CGILB代理
  • JDK和cglib实现动态代理的各自优势
    • JDK：
      • 最小化依赖关系，减少依赖意味着简化开发和维护，JDK本身的支持，可能比cglib更加可靠。
      • 平滑进行JDK版本升级，而字节码类库通常需要进行更新以保证在新版Java上能够使用。
      • 代码实现简单。
    • cglib：
      • 有的时候调用目标可能不便实现额外接口，从某种角度看，限定调用者实现接口是有些侵入性的实践，类似cglib动态代理就没有这种限制。
      • 只操作我们关心的类，而不必为其他相关类增加工作量。
      • cglib性能高于JDK。
      • 被final修饰的方法，无法通过cglib实现动态代理

5、AOP的动态代理是怎么实现的？

6、知识扩展1-JDK实现动态代理基本代码：

  1. 声明一个被代理接口以及被代理的方法 
    public interface Hello { //被代理接口
    void sayHello();//被代理方法
}
  2. 实现被代理接口，实现被代理方法 
    public class HelloImpl implements  Hello { // 实现接口
    @Override
    public void sayHello() {
        // 你要写的业务代码
        System.out.println("Hello World");
    }
}
  3. 实现InvocationHandler接口，写你要做的代理操作 
    public class MyInvocationHandler implements InvocationHandler { 
    private Object target;
    public MyInvocationHandler(Object target) { //暂时存放target
        this.target = target;
    }

    // 实现InvocationHandler中的invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // method就是被代理对象的被代理方法 args是执行被代理方法所需的参数
        // proxy
        System.out.println("Invoking sayHello");
        Object result = method.invoke(target, args);// 这里的target就是被代理对象
        return result;
    }
}
  4. 使用动态代理 
    public class AA {
    public static  void main (String[] args) {
        //创建被代理对象
        HelloImpl hello = new HelloImpl();
        // 创建代理（hello就是步骤3中的target）
        MyInvocationHandler handler = new MyInvocationHandler(hello);

        // 构造代码实例
        Hello proxyHello = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(), HelloImpl.class.getInterfaces(), handler);
        // 调用代理方法
        proxyHello.sayHello();
    }
}
  5. 步骤3和4还可以合成一步（使用lamda表达式） 
    public class AA {

    public static void main(String[] args) {
        // 创建被代理对象
        HelloImpl hello = new HelloImpl();
        
        // 构造代码实例
        Hello proxyHello = (Hello) Proxy.newProxyInstance(HelloImpl.class.getClassLoader(), HelloImpl.class.getInterfaces(),(p,method,param)->{
                    System.out.println("Invoking sayHello");
                    Object result = method.invoke(target,param);
                    return result;
                });
        // 调用代理方法
        proxyHello.sayHello();
    }
}

7、知识扩展2-cglib实现动态代理基本代码：

  1.  声明一个被代理接口以及被代理的方法 
    public interface Hello { //被代理接口
    void sayHello();//被代理方法
}
  2. 实现被代理接口，实现被代理方法 
    public class HelloImpl implements  Hello { // 实现接口
    @Override
    public void sayHello() {
        // 你要写的业务代码
        System.out.println("Hello World");
    }
}
  3. 实现MethodInterceptor接口，写你要做的代理操作 
    public class MyMethodInterceptor implements MethodInterceptor { 
    private Object target;
    public MyMethodInterceptor(Object target) { //暂时存放target
        this.target = target;
    }

    /**
     * 实现MethodInterceptor中的intercept方法
     * 参数 o: cglib 动态生成的代理类的实例
     * method:实体类所调用的都被代理的方法的引用
     * objects 参数列表
     * methodProxy:生成的代理类对方法的代理引用
     **/
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("Invoking sayHello");
        Object object=  methodProxy.invoke(target,objects);
        System.out.println("Destory sayHello");
        return object;
    }
}
  4. 使用动态代理 
    public class AA {
    public static void main(String[] args) {
        //创建被代理对象
        HelloImpl hello = new HelloImpl();
        //创建代理类
        Cglib cglib=new Cglib(hello);

        //可以通过Enhancer对象中的create()方法可以去生成一个类，用于生成代理对象
        Enhancer enhancer=new Enhancer();
        
        enhancer.setSuperclass(hello.getClass());//设置父类(将被代理类作为代理类的父类)
        enhancer.setCallback(cglib);//设置拦截器(代理类中的intercept就是)

        Hello proxyHello = (Hello) enhancer.create();//生成一个被代理类的子类对象
        
        // 调用代理方法
        proxyHello.sayHello();
    }
}

8、知识扩展3-反射机制及其演进

反射提供的AccessibleObject.setAccessible(boolean flag)。它的子类也大都重写了这个方法，这里的所谓accessible可以理解成修饰成员的public、protected、private，这意味着我们可以在运行时修改成员访问限制！

setAccessible的应用场景非常普遍，遍布我们的日常开发、测试、依赖注入等各种框架中。比如，在O/R Mapping框架中，我们为一个Java实体对象，运行时自动生成setter、getter的逻辑，这是加载或者持久化数据非常必要的，框架通常可以利用反射做这个事情，而不需要开发者手动写类似的重复代码。

另一个典型场景就是绕过API访问控制。我们日常开发时可能被迫要调用内部API去做些事情，比如，自定义的高性能NIO框架需要显式地释放DirectBuffer，使用反射绕开限制是一种常见办法。

但是，在Java 9以后，这个方法的使用可能会存在一些争议，因为Jigsaw项目新增的模块化系统，出于强封装性的考虑，对反射访问进行了限制。Jigsaw引入了所谓Open的概念，只有当被反射操作的模块和指定的包对反射调用者模块Open，才能使用setAccessible；否则，被认为是不合法（illegal）操作。如果我们的实体类是定义在模块里面，我们需要在模块描述符中明确声明：
module MyEntities {
    // Open for reflection
    opens com.mycorp to java.persistence;
}
因为反射机制使用广泛，根据社区讨论，目前，Java 9仍然保留了兼容Java 8的行为，但是很有可能在未来版本，完全启用前面提到的针对setAccessible的限制，即只有当被反射操作的模块和指定的包对反射调用者模块Open，才能使用setAccessible，我们可以使用下面参数显式设置。
--illegal-access={ permit | warn | deny }

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
Java:数据结构-排序
ncnn模型部署——yolov5-6.0Pyotorch模型转onxx模型再转ncnn模型部署
html select 的 multiple 使用
数据结构——堆排序（向上调整构建大根堆，向下调整排序）
Centos7.9安装docker实记
HTML5+规范：barcode(条码扫描)
书生浦语第二期第二节课作业
Jenkins配置linux节点
MongoDB中游标的使用
反向代理与 Real-IP 和 X-Forwarded-For
;