Java代理模式

从UML图中，可以看出代理类ProxySubject和被代理类RealSubject都实现了抽象主题Subject（接口），其中RealSubject是ProxySubject的一个成员属性，ProxySubject调用visit()方法会调用RealSubject的visit()方法，同时会加上自己的一些逻辑，比如before()、after()、权限校验等。

代理模式可以有两种实现的方式，一种是静态代理类，另一种是各大框架都喜欢的动态代理。下面我们主要讲解一下这两种代理模式。

一、静态代理

应用场景举例

通过上面的代理模式描述我们可以知道，其目的就是为了控制对象引用，生活场景中我们以买车为例，如果我们要买一辆轿车必须通过汽车4S店，汽车4s店就是充当代理角色，其目的就是控制买车客户的买车行为，必须通过汽车4S店才能从汽车厂商买一辆车。

（1）首先新建一个买车的接口

public interface IBuyCar {
    //买车
    void buyCar();
}

（2）定义一个要买车的客户，实现买车接口

public class Customer implements IBuyCar {

    private int cash;//购车款

    public int getCash() {
        return cash;
    }

    public void setCash(int cash) {
        this.cash = cash;
    }

    @Override
    public void buyCar() {
        Log.e("buyCar", "买一辆车花费了-->" + cash + "元");
    }
}

（3）声明一个买车代理汽车4S店，同样也实现买车接口

public class BuyCarProxy implements IBuyCar{
    private Customer customer;//接收买车客户

    public BuyCarProxy(Customer customer){
        this.customer=customer;//接收买车客户
    }

    @Override
    public void buyCar() {//实现为客户买车
        customer.buyCar();
    }
}

（4）创建一个客户端，模拟一次买车

  Customer customer=new Customer();
  customer.setCash(120000);
  BuyCarProxy buyCarProxy=new BuyCarProxy(customer);
  buyCarProxy.buyCar();

（5）通过代理模式实现权限控制

通过上面的例子，我们可能有个疑问，难道就不能直接去厂家买车吗？当然可以，如果在使用场景中实现类能满足要求时，我们当然可以直接实现类，但当实现类不能满足要求，要扩展需求，根据开闭原则你又不能修改实现类代码，这时你就用代理类。比如购买一辆车我们要对客户进行一个购车款审核，如果符合条件就买车，不符合要求我们就告知客户购车款不足。

 @Override
    public void buyCar() {//实现为客户买车
        int cash=customer.getCash();
        if(cash<100000){
            Log.e("buyCar","你的钱不够买一辆车");
            return;
        }
        customer.buyCar();
    }

实现场景

Customer customer=new Customer();
customer.setCash(120000);
BuyCarProxy buyCarProxy=new BuyCarProxy(customer);
buyCarProxy.buyCar();

Customer customer1 =new Customer();
customer1.setCash(90000);
BuyCarProxy buyCarProxy1 =new BuyCarProxy(customer1);
buyCarProxy1.buyCar();

二、动态代理

静态代理需要手动编写，在需要添加代理的类数量多的时候就显得繁琐，所以我们可以使用动态代理解决这个问题。

1. JDK的动态代理

JDK提供了一个java.lang.reflect.Proxy动态代理类，Proxy类中提供了一个方便的static方法用来构造proxy对象，Proxy.newProxyInstance(ClassLoader ,Class

package com.app.myinterface;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class ProxyMotion {

    public static void main(String args[]) {

        ArrayList<String> content = new ArrayList<String>();
        MyInvocationHandler handler = new MyInvocationHandler(content);
        Object proxy = Proxy.newProxyInstance(null, new Class[]{List.class}, handler);
        if(proxy instanceof List){  //判断当前的proxy对象是否是List接口
            System.out.println("proxy is list");
            List<String> mlist = (List<String>)proxy;
            mlist.add("one");
            mlist.add("two");
            mlist.add("three");
            mlist.add("apple");
        }
        System.out.println("proxy:"+proxy.toString());
        System.out.println("content:"+content.toString());
    }

}
class MyInvocationHandler implements InvocationHandler {
   //具体的调用类
    Object target;

    public MyInvocationHandler(Object obj) {
        target = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //当前所持有的proxy对象
        //method表示当前别调用的方法
        //args表示方法中传递的参数
        System.out.println("method name:"+method.getName());
        if(method.getName().equals("add")){
            if(args[0].equals("apple")){
                return false;
            }
        }
        return method.invoke(target, args);
    }
}

输出：

proxy is list
method name:add
method name:add
method name:add
method name:add
method name:toString
proxy:[one, two, three]
content:[one, two, three]

2. Cglib代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象,但是有时候目标对象只是一个单独的对象,并没有实现任何的接口,这个时候就可以使用以目标对象子类的方式类实现代理,这种方法就叫做:Cglib代理。

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

• JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现。
• Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)。
• Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

Cglib子类代理实现方法：
（1）需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可。
（2）引入功能包后，就可以在内存中动态构建子类。
（3）代理的类不能为final，否则报错。
（4）目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法。

JDK的代理类需要实现InvocationHandler接口，重写其中的invoke方法；而Cglib代理类需要实现MethodInterceptor接口，重写其中的intercept方法，然后直接调用getProxyInstance()方法获取一个代理类实例。

UserDao.java

public class UserDao {

    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

Cglib代理工厂:ProxyFactory.java

public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}

测试类：

public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}