代理模式

概述

代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。

举例：明星（邓紫棋）<—–经纪人 <——-用户
——- —- (目标) — - – —- （代理）

代理模式的关键点： 代理对象与目标对象。

代理模式的三种类型

• 静态代理
• 动态代理
• Cglib代理

---

1. 静态代理

1） 代理对象，要实现与目标对象一样的接口；
2） 举例:
        保存用户(模拟)
            Dao  ,  直接保存
            DaoProxy, 给保存方法添加事务处理

// IUserDao
package proxy.a_static;

public interface IUserDao {

    void save();

}

//UserDao
package proxy.a_static;

public class UserDao implements IUserDao {

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

//UserDaoProxy
package proxy.a_static;

public class UserDaoProxy implements IUserDao {

    //接收保存目标对象
    private IUserDao target;

    public UserDaoProxy(IUserDao target) {
        this.target = target;
    }

    public void save() {
        System.out.println("开始事务...");

        target.save(); //执行目标对象方法

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

//测试类
package proxy.a_static;

public class app {

    public static void main(String[] args) {
        //目标对象
        IUserDao target = new UserDao();

        //代理
        IUserDao proxy = new UserDaoProxy(target);
        proxy.save();   //执行的是代理的方法
    }

}

总结静态代理：
1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
2）缺点：
–》 因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。
–》 一旦接口增加方法，目标对象与代理对象都要维护。

解决：
代理工厂？ 可以使用动态代理。

2. 动态代理

动态代理，
1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);
3) 动态代理， JDK代理， 接口代理；

JDK中生成代理对象的API：

|-- Proxy
    static Object newProxyInstance(
ClassLoader loader,       指定当前目标对象使用类加载器
 Class<?>[] interfaces,     目标对象实现的接口的类型
InvocationHandler h       事件处理器
) 

实现动态代理在静态代理的代码中用ProxyFactory代替UserDaoProxy

package proxy.a_static.b_dynamic;

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

/**
 * 给所有的dao创建代理对象[动态代理]
 *
 * 代理对象不需要实现接口
 * Created by Administrator on 2017/1/30.
 */
public class ProxyFactory {

    //维护一个目标对象
    private Object target;

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

    //给目标对象，生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开启事务");

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

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

//测试类
package proxy.a_static.b_dynamic;

public class app {

    public static void main(String[] args) {
        //目标对象
        IUserDao target = new UserDao();

        //打印原始的类型
        System.out.println(target.getClass());

        //给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();

        //打印代理类型
        System.out.println(proxy.getClass());

        //执行方法
        proxy.save();
    }

}

动态代理总结：

代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(class $Proxy0 implements IuserDao)

思考：
有一个目标对象，想要功能扩展，但目标对象没有实现接口，怎样功能扩展？
Class UserDao{}
// 子类的方式
Class subclass extends UserDao{}

以子类的方式实现(cglib代理)

3. Cglib代理

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

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

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

//UserDao
public class UserDao {

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

//ProxyFactory
package proxy.a_static.c_cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Cglib子类代理工厂
 * （对UserDao在内存中动态创建一个子类对象）
 * Created by Administrator on 2017/1/30.
 */
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();
    }

    public Object intercept(Object o, Method method, Object[] objects,
                            MethodProxy methodProxy) throws Throwable {

        System.out.println("开始事务...");

        Object returnValue = method.invoke(target,objects);

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

//测试类
package proxy.a_static.c_cglib;

import proxy.a_static.UserDao;

public class app {

    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();

        //打印原始的类型
        System.out.println(target.getClass());

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

        //打印代理对象的类型
        System.out.println(proxy.getClass());

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

}