反射

Java 反射，可以获取任意类的名称、package 信息、所有属性、方法、注解、类型、类加载器、现实接口等，并且可以调用任意方法和实例化任意一个类的对象，通过反射我们可以实现动态装配，降低代码的耦合度、实现动态代理等，不过反射的过度使用会严重消耗系统资源。
image.png

  1. 反射的优缺点
    1. 可以动态执行，在运行期间根据业务功能动态执行方法、访问属性，最大限度发挥了java的灵活性。
    2. 缺点：对性能有影响，这类操作总是慢于直接执行java代码。
  2. 如何解决反射的性能问题
  • 聊到性能，记得想好怎么回答优化方面的问题，否则就是自己搬起石头砸自己的脚。

  • image.png

    静态代理

    想对方法进行一个增强, 需要修改源代码. 假如有100个方法, 我们需要修改100个方法的源代码来实现方法增强.

    1. /**
    2. * 增删改查方法增强例子
    3. * @author : Shen Hanbo
    4. * @date : 2020/11/9 16:01
    5. */
    6. public class CrudServiceImpl implements CrudService {
    8.   public void insert() {
    9.       System.out.println("增强新增前置处理");
    10.       System.out.println("新增");
    11.       System.out.println("增强新增后置处理");
    12.   }
    14.   public void delete() {
    15.       System.out.println("增强删除前置处理");
    16.       System.out.println("删除");
    17.       System.out.println("增强删除后置处理");
    18.   }
    20.   public void update() {
    21.       System.out.println("增强更新前置处理");
    22.       System.out.println("更新");
    23.       System.out.println("增强更新后置处理");
    24.   }
    26.   public void query() {
    27.       System.out.println("增强查询前置处理");
    28.       System.out.println("查询");
    29.       System.out.println("增强查询后置处理");
    30.   }
    32.   //...假如下面还有一堆方法的话, 每个方法都需要去手动改源代码
    33. }

    解决思路
    生成一个代理类, 代理类要和被代理类拥有一样方法(实现同一个接口), 然后调用方直接调用代理类的方法, 而非被代理类的方法. 在代理类的实现方法中, 增强被代理类的方法, 然后客户端请求代理类.

  • 代码

用房东/中介/租客

  1. 首先房东和中介都需要有”租房”这个方法, 中介来增强房东的”租房”方法,因此需要定义一个租房接口. ```java /**

    • 租房接口
    • @author : Shen Hanbo

    • @date : 2020/11/9 15:52 */ public interface ZuFang {

      /**

      • 房东和中介都需要实现租房接口,因为他们都有租房的功能 */ void zuFang();

}

  2. 2. 房东的"租房"方法, 即被代理的方法
  3. ```java
  4. /**
  5.  * 房东类
  6.  * @author : Shen Hanbo
  7.  * @date : 2020/11/9 15:54
  8.  */
  9. public class FangDong implements ZuFang {
  11.     /**
  12.      * 房东出租房子(被代理方法)
  13.      */
  14.     public void zuFang() {
  15.         System.out.println("房东出租房子");
  16.     }
  17. }

  1. 中介的”租房”方法, 即代理方法, 在代理方法中对原方法进行增强 ```java /**

    • 中介(代理类)
    • @author : Shen Hanbo

    • @date : 2020/11/9 16:10 */ public class ZhongJie implements ZuFang {

      /**

      • 需要一个房东 */ private FangDong fangDong;

      public ZhongJie(FangDong fangDong) { this.fangDong = fangDong; }

      /**

      • 中介代理房东出租房子(代理方法) */ public void zuFang() { //前置增强 System.out.println(“前置增强”); //原方法 fangDong.zuFang(); //后置增强 System.out.println(“后置增强”); } }
  2. 4. main
  3. ```java
  4. public static void main(String[] args) {
  5.     //房东
  6.     FangDong fangDong = new FangDong();
  7.     //中介代理房东
  8.     ZhongJie zhongJie = new ZhongJie(fangDong);
  9.     //调用中介的租房方法
  10.     zhongJie.zuFang();
  11. }
  12.  /*
  13.     打印结果:
  14.         前置增强
  15.         房东出租房子
  16.         后置增强
  17. */

动态代理

  • 痛点
    • 静态代理需要手动编写代理类, 比如上个例子中的ZhongJie类.
    • 静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类, **每个接口都需要自己的代理类**.
  • 解决思路

在上面的示例中**，一个代理只能代理一种类型，而且是在编译期就已经确定被代理的对象。
而动态代理是在运行时**，通过反射机制实现动态代理，并且能够代理各种类型的对象

  1. 使用InvocationHandler接口

    1. //Object proxy:被代理的对象  
    2. //Method method:要调用的方法  
    3. //Object[] args:方法调用时所需要参数  
    4. public interface InvocationHandler {
    5.  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    6. }

  2. Proxy类 ```java //用于获取代理类 //CLassLoader loader:类的加载器
    //Class<?> interfaces:得到全部的接口
    //InvocationHandler h:得到InvocationHandler接口的子类的实例

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h);

  1.     final Class<?>[] intfs = interfaces.clone();
  2.     final SecurityManager sm = System.getSecurityManager();
  3.     if (sm != null) {
  4.         checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  5.     }
  7.     /*
  8.      * Look up or generate the designated proxy class.
  9.      */
  10.     Class<?> cl = getProxyClass0(loader, intfs);
  12.     /*
  13.      * Invoke its constructor with the designated invocation handler.
  14.      */
  15.     try {
  16.         if (sm != null) {
  17.             checkNewProxyPermission(Reflection.getCallerClass(), cl);
  18.         }
  20.         final Constructor<?> cons = cl.getConstructor(constructorParams);
  21.         final InvocationHandler ih = h;
  22.         if (!Modifier.isPublic(cl.getModifiers())) {
  23.             AccessController.doPrivileged(new PrivilegedAction<Void>() {
  24.                 public Void run() {
  25.                     cons.setAccessible(true);
  26.                     return null;
  27.                 }
  28.             });
  29.         }
  30.         return cons.newInstance(new Object[]{h});
  31.     } catch (IllegalAccessException|InstantiationException e) {
  32.         throw new InternalError(e.toString(), e);
  33.     } catch (InvocationTargetException e) {
  34.         Throwable t = e.getCause();
  35.         if (t instanceof RuntimeException) {
  36.             throw (RuntimeException) t;
  37.         } else {
  38.             throw new InternalError(t.toString(), t);
  39.         }
  40.     } catch (NoSuchMethodException e) {
  41.         throw new InternalError(e.toString(), e);
  42.     }
  43. }
  2. 3. 实现
  4. 目前动态代理可以提供两种，分为
  6. - JDK 原生动态代理
  7.    - 基于接口实现
  8.    - 当目标类有接口的时候才会使用JDK动态代理，其实是因为JDK动态代理无法代理一个没有接口的类，因为JDK动态代理是利用反射机制生成一个实现代理接口的匿名类
  10. ![](https://cdn.nlark.com/yuque/0/2021/webp/8429887/1610976255297-e2844563-5896-4616-a624-efe3f51ba990.webp#align=left&display=inline&height=280&margin=%5Bobject%20Object%5D&originHeight=280&originWidth=455&size=0&status=done&style=none&width=455)
  11. ```java
  12. public interface Target {
  13.     public String execute();
  14. }
  16. ========================
  17. public class TargetImpl implements Target {
  19.     @Override
  20.     public String execute() {
  21.         System.out.println("TargetImpl execute！");
  22.         return "execute";
  23.     }
  24. }
  26. =======================
  27. public class DynamicProxyHandler  implements InvocationHandler{
  29.     private Target target;
  31.     public DynamicProxyHandler(Target target) {
  32.         this.target = target;
  33.     }
  35.     @Override
  36.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  37.         System.out.println("========before==========");
  38.         Object result = method.invoke(target,args);
  39.         System.out.println("========after===========");
  40.         return result;
  41.     }
  42. }
  44. ============================
  45. public class DynamicProxyTest {
  47.     public static void main(String[] args) {
  48.         Target target = new TargetImpl();
  49.         DynamicProxyHandler handler = new DynamicProxyHandler(target);
  50.         Target proxySubject = (Target) Proxy.newProxyInstance(
  51.                                         TargetImpl.class.getClassLoader(),
  52.                                         TargetImpl.class.getInterfaces(),
  53.                                         handler);
  54.         // 通过原来的方法名调用
  55.         String result = proxySubject.execute(); // 返回被代理对象的方法返回值
  56.         System.out.println(result);
  57.     }
  59. }
  61. 结果:
  62. ========before==========
  63. TargetImpl execute！
  64. ========after===========
  65. execute


  • CGLIB动态代理
    • 基于继承当前类的子类实现的
    • CGLIB是针对类实现代理，主要是对指定的类生成一个子类，并且覆盖其中的方法。

Spring中默认使用的是JDK动态代理，除非目标类没有实现接口，才会转为CGLIB代理，如果想要强行使用CGLIB代理免责需要在Spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true" />，
然而在SpringBoot中，从2.0开始就默认使用CGLIB代理。
4反射（不常问） - 图3

CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用(当方法为final修饰时 无法实现代理)，顺势织入横切逻辑。

  1. 目标类 是一个类而不是接口了 ```java package com.test.cglib;

public class Target {

  1. public String execute() {
  2.     String message = "-----------test------------";
  3.     System.out.println(message);
  4.     return message;
  5. }

}

  2. 2. 代理类
  4.    代理对象的生成过程由Enhancer类实现，大概步骤如下：<br />    1、生成代理类Class的二进制字节码；<br />    2、通过Class.forName加载二进制字节码，生成Class对象；<br />    3、通过反射机制获取实例构造，并初始化代理类对象。
  5. ```java
  6. package com.test.cglib;
  8. import net.sf.cglib.proxy.MethodInterceptor;
  9. import net.sf.cglib.proxy.MethodProxy;
  11. import java.lang.reflect.Method;
  13. public class MyMethodInterceptor implements MethodInterceptor{
  14.     @Override
  15.     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
  16.         System.out.println(">>>>MethodInterceptor start...");
  17.         Object result = proxy.invokeSuper(obj,args);
  18.         System.out.println(">>>>MethodInterceptor ending...");
  19.         return "result";
  20.     }
  21. }
  1. 测试类 ```java package com.test.cglib;

import net.sf.cglib.proxy.Enhancer;

public class CglibTest {

  1. public static void  main(String ... args) {
  2.     System.out.println("***************");
  3.     Target target = new Target();
  4.     CglibTest test = new CglibTest();
  5.     Target proxyTarget = (Target) test.createProxy(Target.class);
  6.     String res = proxyTarget.execute();
  7.     System.out.println(res);
  8. }
  10. /**
  11. 代理对象的生成过程由Enhancer类实现，大概步骤如下：
  12. 1、生成代理类Class的二进制字节码；
  13. 2、通过Class.forName加载二进制字节码，生成Class对象；
  14. 3、通过反射机制获取实例构造，并初始化代理类对象。

作者：冬天里的懒喵 链接：https://www.jianshu.com/p/37d0ac9233b9 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 **/

  1. public Object createProxy(Class targetClass) {
  2.     Enhancer enhancer = new Enhancer();
  3.     enhancer.setSuperclass(targetClass);
  4.     enhancer.setCallback(new MyMethodInterceptor());
  5.     return enhancer.create();
  6. }

} ```