Java使用JDK与Cglib动态代理技术统一管理日志记录

java中动态代理主要有jdk和cglib两种方式。

区别主要是jdk是代理接口，而cglib是代理类。

• 优点：这种方式已经解决我们前面所有日记需要的问题。非常的灵活。而且可以方便的在后期进行维护和升级。
• 缺点：当然使用jdk动态代理，必需要有接口。如果没有接口。就无法使用jdk动态代理技术。

计算接口 calculate.java

public interface calculate {
 /**
  * 加法运算
  * @param num1 参数 1
  * @param num2 参数 2
  * @return
  */
 public int add(int num1, int num2);

 /**
  * 加法运算
  * @param num1 参数 1
  * @param num2 参数 2
  * @param num3 参数 3
  * @return
  */
 public int add(int num1, int num2, int num3);

 /**
  * 除法运算
  * @param num1 参数 1
  * @param num2 参数 2
  * @return
  */
 public int div(int num1, int num2);
}

实现计算接口中的方法 calculateimpl.java

/**
 * 实现计算接口中的方法
 * created by yongxin xue on 2020/05/05 11:29
 */
public class calculateimpl implements calculate {
 @override
 public int add(int num1, int num2) {
  // 记录当前操作,及运算参数
  logutils.logbefore("add", num1, num2);
  int result = num1 + num2;
  return result;
 }

 @override
 public int add(int num1, int num2, int num3) {
  // 记录当前操作,及运算参数
  logutils.logbefore("add", num1, num2, num3);
  int result = num1 + num2 + num3;
  return result;
 }

 @override
 public int div(int num1, int num2) {
  // 记录当前操作,及运算参数
  logutils.logbefore("div", num1, num2);
  int result = 0;
  try {
   result = num1 / num2;
   // 记录运算结果
   logutils.logafterreturning("div", result);
  }catch (exception e){
   // 记录异常信息
   logutils.logafterthrowing("div", e);
  }
  return result;
 }
}

记录日志工具类 logutils.java

/**
 * 记录日志工具类
 * created by yongxin xue on 2020/05/05 11:38
 */
public class logutils {
 /**
  * 记录前置的日志操作
  * @param method 当前运算操作
  * @param args 当前运算参数
  */
 public static void logbefore(string method, object ... args){
  system.out.println("操作运算是 : " + method + " 参数是 : " + arrays.aslist(args));
 }

 /**
  * 返回日志操作
  * @param method 当前方法
  * @param result 当前操作返回值
  */
 public static void logafterreturning(string method, object result){
  system.out.println("当前操作运算时 : " + method + " 返回值是 : " + result);
 }

 /**
  * 当前操作产生的异常
  * @param method 当前操作
  * @param e 发生的异常
  */
 public static void logafterthrowing(string method, exception e){
  system.out.println("当前运算时 : " + method + " 发生的异常是 : " + e);
 }
}

jdk 动态代理的工厂类 jdkproxyfactory.java

/**
 * jdk 动态代理的工厂
 * created by yongxin xue on 2020/05/05 13:02
 */
public class jdkproxyfactory {

 /**
  * 通过 jdk 底层自带的 jdk 动态代理技术解决日志需求问题
  * @param target
  * @return
  */
 public static object createjdkproxy(object target){
  /**
   * proxy 是jdk中自带的一个工具类(反射包下,属于反射的功能).
   * proxy类的作用: 它可以帮我们创建代理类或实例
   * 方法newproxyinstance()说明: 创建代理对象实例
   * 第一个参数是: 目标对象的类加载器
   * 第二个参数是: 目标对象实现的所有接口
   * 第三个参数是: invocationhandler 接口的实例
   * invocationhandler 接口的实现类可以对代理的目标对象方法进行增强操作.
   * 代理的目标对象 ===>>> 需要额外增加功能的类(对象实例)
   * 增强操作 ===>>> 给原来功能添加的额外功能叫增强操作 ( 日记就是增强操作 )
   */
  return proxy.newproxyinstance(
    target.getclass().getclassloader(),
    target.getclass().getinterfaces(),
    new invocationhandler() { // 匿名内部类
     /**
      * invoke 方法是 invocationhandler 接口中唯一的方法
      * 代理对象每次调用方法时,都会执行 invoke() 方法 , 所有的增强操作都需要在invoke()方法中完成
      * @param proxy  代理对象实例
      * @param method 代理调用的方法的反射 method 对象实例
      * @param args  调用代理方法时传递进来的参数
      * @return
      * @throws throwable
      */
     @override
     public object invoke(object proxy, method method, object[] args) throws throwable {
      system.out.println("代理调用了 invoke 方法 ");
      system.out.println(method);  //打印方法信息
      system.out.println(arrays.aslist(args)); //打印参数信息
      // invoke() 方法执行代理对象的(加法 / 除法 / 增强日志)操作
      object result = null;
      logutils.logbefore(method.getname(), args);
      try {
       // 1. 返回值是 method 方法调用时的返回值
       result = method.invoke(target, args);
       // 2. 增强操作
       logutils.logafterreturning(method.getname(), result);
      }catch (exception e){
       logutils.logafterthrowing(method.getname(), e);
      }
      // invoke() 返回代理方法的返回值
      return result;
     }
    });
 }

 // 测试代码
 public static void main(string[] args) {
  // 目标对象
  calculate target = new calculateimpl();
  // 创建 calculate 的代理对象实例
  calculate calculateproxy = (calculate) createjdkproxy(target );
  // jdk动态代理对象实例和目标对象实例 同宗同族 ( 他们都实现了相同的接口 )
  system.out.println(calculateproxy instanceof calculate);
  system.out.println(target instanceof calculate);

  system.out.println( "代理方法的结果是 :　" + calculateproxy.div(100,20) );

  // jdk动态代理创建出来的代理对象实例 是 目标对象 接口的一个实现类
  // 这个代理对象 和 目标对象类没有父子关系 ( 只能用接口接收代理对象 )
 }
}

使用 cglib 代理

1. jdk动态代理是通过实现目标对象所有接口产生一个代理对象实例从而解决问题.
2. 如果目标对象没有接口.则可以使用cglib动态代理技术.
3. cglib动态代理技术对目标对象有没有实现接口,没有要求.
4. cglib动态代理技术,是通过拷贝然后修改目标对象的类的字节码来产生一个代理对象
5. 而且这个cglib产生的代理对象实例 是 目标对象的一个子类.

ia 接口 ia.java

public interface ia {
 public string show(string start);
}

ia 实现类 iaimpl.java

public class iaimpl implements ia {
 @override
 public string show(string start) {
  system.out.println(start + "开始表演!");
  return start + "表演的不错!!";
 }
}

使用 cglib 代理 cglibproxyfactory.java

/**
 * 使用 cglib 代理
 * created by yongxin xue on 2020/05/05 15:03
 */
public class cglibproxyfactory {

 public static object createcglibproxy(object target){
  // 是 cglib 用于创建代理对象的增强工具类
  enhancer enhancer = new enhancer();
  // cglib需要对目标对象的class字节码进行修改.
  // cglib产生的代理对象实例.是目标对象的子类
  enhancer.setsuperclass(target.getclass());
  // 只要是代理都会对原来的内容进行增强操作 ( 增强就是在原有功能上 额外添加的功能 )
  // setcallback() 设置用于增强 操作的实现类( methodinterceptor对代理方法进行拦截 )
  // 每次只要调用cglib代理的方法,都会执行 methodinterceptor 接口中 intercept() 方法
  enhancer.setcallback(new methodinterceptor() {
   /**
    * intercept() 方法 跟 jdk 代理中的 invocationhandler接口中 invoke() 功能完全一样
    * @param proxy  cglib代理对象实例
    * @param method 调用方法的反射对象实例
    * @param args 调用方法时传递的参数
    * @param methodproxy 代理方法的method代理对象
    * @return  是代理对象方法的返回值.
    * @throws throwable
    */
   @override
   public object intercept(object proxy, method method, object[] args, methodproxy methodproxy) throws throwable {
    object result = null;
    try {
     logutils.logbefore(method.getname(), args);
     // 调用目标方法 [加 / 减 / 乘 / 除 / 或具体方法]
     result = method.invoke(target, args);
     // 执行增强代码
     logutils.logafterreturning(method.getname(), args);
    }catch (exception e){
     e.printstacktrace();
     logutils.logafterthrowing(method.getname(), e);
    }

    return result;
   }
  });
  // 创建 cglib 代理对象实例
  return enhancer.create();
 }
 //测试
 public static void main(string[] args) {
  // 目标对象
  calculate calculate = new calculateimpl();
  // 创建代理对象实例
  calculate cglibproxy = (calculate) createcglibproxy(calculate);
  // 调用代理方法式会执行 methodinterceptor 接口中 intercept() 方法
  int result = cglibproxy.div(120, 0);
  // cglib 代理 是目标子类执行 methodinterceptor 接口中 intercept() 方法
  system.out.println(cglibproxy instanceof calculate);
 }
}

优点：在没有接口的情况下，同样可以实现代理的效果。
缺点：同样需要自己编码实现代理全部过程。

到此这篇关于java使用jdk与cglib动态代理技术统一管理日志记录的文章就介绍到这了,更多相关java动态代理统一管理日志 内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！