43、Java动态代理一——动态类Proxy的使用

1.什么是动态代理?

答：动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。
2.为什么使用动态代理?

答：因为动态代理可以对请求进行任何处理

3.使用它有哪些好处?

答：因为动态代理可以对请求进行任何处理
4.哪些地方需要动态代理?

答：不允许直接访问某些类；对访问要做特殊处理等

目前Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现

以下为模拟案例，通过动态代理实现在方法调用前后向控制台输出两句字符串

目录结构

<br/>

定义一个HelloWorld接口

 package com.ljq.test;

  /**
  * 定义一个HelloWorld接口
  *
  * @author jiqinlin
  *
 */
  publicinterface HelloWorld {
 publicvoid sayHelloWorld();
 }

<br/>

类HelloWorldImpl是HelloWorld接口的实现

 package com.ljq.test;

  /**
  * 类HelloWorldImpl是HelloWorld接口的实现
  *
  * @author jiqinlin
  *
 */
  publicclass HelloWorldImpl implements HelloWorld{

 publicvoid sayHelloWorld() {
         System.out.println("HelloWorld!");
     }

 }

HelloWorldHandler是 InvocationHandler接口实现

 package com.ljq.test;

  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;

  /**
  * 实现在方法调用前后向控制台输出两句字符串
  *
  * @author jiqinlin
  *
 */
  publicclass HelloWorldHandler implements InvocationHandler{
 //要代理的原始对象
  private Object obj;

 public HelloWorldHandler(Object obj) {
 super();
 this.obj = obj;
     }

 /**
      * 在代理实例上处理方法调用并返回结果
      *
      * @param proxy 代理类
      * @param method 被代理的方法
      * @param args 该方法的参数数组
 */
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         Object result =null;
 //调用之前
          doBefore();
 //调用原始对象的方法
         result=method.invoke(obj, args);
 //调用之后
         doAfter();
 return result;
     }

 privatevoid doBefore(){
         System.out.println("before method invoke");
     }

 privatevoid doAfter(){
         System.out.println("after method invoke");
     }

 }

测试类

package com.ljq.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

publicclass HelloWorldTest {

    publicstaticvoid main(String[] args) {
        HelloWorld helloWorld=new HelloWorldImpl();
        InvocationHandler handler=new HelloWorldHandler(helloWorld);

        //创建动态代理对象
        HelloWorld proxy=(HelloWorld)Proxy.newProxyInstance(
                helloWorld.getClass().getClassLoader(),
                helloWorld.getClass().getInterfaces(),
                handler);
        proxy.sayHelloWorld();
    }
}

运行结果为：

 

 

案例二

Calculator.java

 import java.math.BigDecimal;

 public interface Calculator {

     //加法
     BigDecimal add(String a,String b);

     //减法
     BigDecimal sub(String a,String b);

     //乘法
     BigDecimal mul(String a,String b);

     //除法
     BigDecimal div(String a,String b);
 }

SimpleCalculator.java

 import java.math.BigDecimal;

 public class SimpleCalculator  implements Calculator{

     @Override
     public BigDecimal add(String a, String b) {

         BigDecimal n1=new BigDecimal(a);
         BigDecimal n2=new BigDecimal(b);

         return n1.add(n2);
     }

     @Override
     public BigDecimal sub(String a, String b) {
         BigDecimal n1=new BigDecimal(a);
         BigDecimal n2=new BigDecimal(b);

         return n1.subtract(n2);
     }

     @Override
     public BigDecimal mul(String a, String b) {
         BigDecimal n1=new BigDecimal(a);
         BigDecimal n2=new BigDecimal(b);

         return n1.multiply(n2);
     }

     @Override
     public BigDecimal div(String a, String b) {
         BigDecimal n1=new BigDecimal(a);
         BigDecimal n2=new BigDecimal(b);

         return n1.divide(n2);
     }

 }

SimpleCalculatorLoggingProxy.java

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 public class SimpleCalculatorLoggingProxy {

     private Calculator target;

     public SimpleCalculatorLoggingProxy(Calculator target){
         this.target=target;
     }

     public Calculator getProxy(){
         Calculator proxy=null;

         //
         ClassLoader loader=target.getClass().getClassLoader();

         Class[] interfaces=new Class[]{Calculator.class};

         InvocationHandler handle=new InvocationHandler() {

             @Override
             public Object invoke(Object proxy, Method method, Object[] args)
                     throws Throwable {
                 System.out.println("正在执行"+method.getName()+"方法,参数为"+args[0]+","+args[1]);
                 return method.invoke(target, args);
             }
         };

         proxy= (Calculator) Proxy.newProxyInstance(loader, interfaces, handle);
         return proxy;
     }

 }

测试代码：

 Calculator target=new SimpleCalculator();

 Calculator proxy=new SimpleCalculatorLoggingProxy(target).getProxy();

 System.out.println(proxy.add("1", "2")); 

 System.out.println(proxy.div("3", "2")); 

输出结果：

正在执行add方法,参数为1,2
3
正在执行div方法,参数为3,2
1.5