动态代理的简单实现

对于动态代理的理解

以买房这一事件为例，一般都不会是开发商直接向买家售卖房子。
原因有很多，例如，房子过多，处理不过来；仅有两方面，没有见证者，容易出现谈不拢情况等等。
在这时候，房产中介就应运而生了，可以由房产商将自己手底下的房子的相关信息告诉中介，再由中介帮其推销到市场，买家通过中介了解房子信息。这就是代理的概念由来。
但在实际中，在发生了买卖之后，房产商会修改其房源信息或者增加房子信息，导致买家接收到的信息有差别，或者中介需要不断更改其代理房子的相关信息。如此，静态代理显得弹性不足，依赖性过强。便产生了动态代理的理念。在不修改原来的信息的情况下，可以通过动态代理来实现对其信息的拓展。

以下是我们老师布置的例题，下面通过例题的解决来初步学习理解动态代理的原理。

在不修改Division类的定义前提下，请用动态代理的方式编写一个代理程序对Division的功能进行扩展修改，完成扩展后的除法计算功能。
要求
a、编写一个动态代理处理器类，扩展除法功能如下：
（1）.在除法计算前，可以检验除数是否为0，如果为0，则计算结果为-9999，并输出错误提示：除零错误！
（2）.在除法计算后，可以检查是否有余数，如果有余数，则输出余数提示：余数为xxx
b、编写一个测试类，从键盘输入两个数，生成动态代理对象，通过代理对象进行除法计算，并输出最终结果。
c、编写其他可能需要的接口或类文件。
注意：代理方法有返回值
public class Division {
public int divide(int a, int b){
int result=-1;
try{
System.out.println(“开始计算…”);
result=a/b;
System.out.println(“计算完毕…”);
return result;
}catch(Exception e){ }
return result;
}
}

题目给的 Division.java

public class Division {
    public int divide(int a,int b){
        int result = -1;
        try{
            System.out.println("开始计算====\n");
            result=a/b;
            System.out.println("计算完毕====\n");
            return result;
        }catch(Exception e){
            return result;
        }
    }
}

计算接口类 Calculate.java

/**
 * 计算接口类
 */
public interface Calculate {
    public int divisionBefore(int a,int b);
    public String divisionAfter(int a,int b);
}

Calculate接口的实现类 RealCalculate.java

/**
 * Calculate接口的实现类(对Division的扩展)
 */
public class RealCalculate implements Calculate{
    //创建一个Division对象
    Division division=new Division();
    @Override
    public int divisionBefore(int a, int b) {
        if(b==0) {
            System.out.println("除零错误！\n");
            return -9999;
        }else{
            return division.divide(a,b);
        }
    }

    @Override
    public String divisionAfter(int a, int b) {
        try{
            int c=a%b;
            if(c!=0) return ("余数为"+c+"\n");
            else return ("余数为0\n");
        }catch(Exception e){
            return "";
        }
    }
}

Calculate的动态代理类 DynamicProxy.java

/**
 * Calculate的动态代理类
 */
public class DynamicProxy implements InvocationHandler {
    //代理的真实对象
    private Object calculate;
    //给要代理的对象赋值
    public DynamicProxy(Object calculate){
        this.calculate=calculate;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //代理对象前的提示
        System.out.println("===Before agent===\n");
        //当代理对象调用真实对象的方法时，其会自动跳转到代理对象关联的handler对象的invoke方法进行调用并获取其返回值
        Object object=method.invoke(calculate, args);
        //代理对象后的提示
        System.out.println("===After agent===\n");
        return object;
    }
}

Calculate的动态代理测试 AgentTest.java

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

public class AgentTest {
    public static void main(String[] args) {
        //代理的对象
        Calculate realCalculate=new RealCalculate();
//        Calculate realCalculate=new Real();//无返回值动态代理测试
        //将对象传进InvocationHandler
        InvocationHandler handler = new DynamicProxy(realCalculate);

        /*
         * 通过Proxy的newProxyInstance方法来创建代理对象，其有三个参数
         * 第一个参数 handler.getClass().getClassLoader() ，这里使用handler这个类的ClassLoader对象来加载代理对象
         * 第二个参数realSubject.getClass().getInterfaces()，这里为代理对象提供的接口是真实对象所实行的接口，表示要代理的是该真实对象，这样就能调用这组接口中的方法了
         * 第三个参数handler，这里将这个代理对象关联到了上方的 InvocationHandler 对象
         */
        Calculate calculate= (Calculate) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                realCalculate.getClass().getInterfaces(),handler);

        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入被除数a：");
        int a=scanner.nextInt();
        System.out.print("请输入除数b：");
        int b=scanner.nextInt();
//        int a=101;
//        int b=15;
        int resultBefore = calculate.divisionBefore(a,b);
        String resultAfter=calculate.divisionAfter(a,b);
        System.out.println(a+"/"+b+"="+resultBefore);
        if(!resultAfter.equals("")){
            System.out.println(a+"/"+b+"的"+resultAfter);
        }

    }
}

这样就实现了功能的扩展了。
这里使用的是JDK的动态代理，有其不足之处：JDK动态代理的代理类字节码在创建时，需要实现业务实现类所实现的接口作为参数。如果业务实现类是没有实现接口而是直接定义业务方法的话，就无法使用JDK动态代理了。(JDK动态代理重要特点是代理接口)并且，如果业务实现类中新增了接口中没有的方法，这些方法是无法被代理的（因为无法被调用）。动态代理只能对接口产生代理，不能对类产生代理。

在此之前要对反射的概念有一定的了解，能够更快地掌握动态代理的实现原理。

本次学习笔记就到这啦！愿与诸君共同学习！