Spring中使用到的设计模式(六)----代理模式

1. 代理模式简介

包括：静态代理、动态代理、Cglib代理

1.1 简介

 代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

1.2 意图

为其他对象提供一种代理以控制对这个对象的访问。

1.3 UML图

我们将创建一个 Image 接口和实现了 Image 接口的实体类。ProxyImage 是一个代理类，减少 RealImage 对象加载的内存占用。

ProxyPatternDemo，我们的演示类使用 ProxyImage 来获取要加载的 Image 对象，并按照需求进行显示。

1.4 优缺点

优点：

1、职责清晰。

2、高扩展性。

3、智能化。

缺点：

1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。

 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

1.5 应用实例

 1、Windows 里面的快捷方式。

2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。

3、买火车票不一定在火车站买，也可以去代售点。

4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。

5、spring aop。

1.6 主要解决的问题

在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

1.7 应用场景

按职责来划分，通常有以下使用场景：

1、远程代理。

2、虚拟代理。

3、Copy-on-Write 代理。

4、保护（Protect or Access）代理。

5、Cache代理。

6、防火墙（Firewall）代理。

7、同步化（Synchronization）代理。

8、智能引用（Smart Reference）代理。

1.8 注意事项

1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。

2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

图解

代理模式的关键点是：代理对象与目标对象。代理对象是对目标对象的扩展，并会调用目标对象。

2. 静态代理模式的实现

定义：静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

实现方式：模拟保存动作，定义一个保存动作的接口：IUserDao.java，然后目标对象实现这个接口的方法UserDao.java，此时如果使用静态代理方式，就需要在代理对象(UserDaoProxy.java)中也实现IUserDao接口。调用的时候通过调用代理对象的方法来调用目标对象。需要注意的是，代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

特点：可以做到在不修改目标对象的功能前提下，对目标功能扩展。

缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，类太多，同时，一旦接口增加方法，目标对象与代理对象都要维护。

/**

 * 接口

 */

public interface IUserDao {

    void save();

}

/**

 * 接口实现

 * 目标对象

 */

public class UserDao implements IUserDao {

    public void save() {

        System.out.println("----已经保存数据!----");

    }

}

/**

 * 代理对象,静态代理

 */

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("提交事务...");

    }

}

/**

 * 客户端

 */

public class MainTest {

public static void main(String[] args) {

        //目标对象

        UserDao target = new UserDao();

        //代理对象，把目标对象传给代理对象，建立代理关系

        UserDaoProxy proxy = new UserDaoProxy(target);

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

    }

}

3. 动态代理模式的实现

定义：解决了静态代理中，因为代理类增加，代码冗余；接口改变而造成维护成本高等缺点。

实现方式：接口类IUserDao.java以及接口实现类，目标对象UserDao是一样的，没有做修改。在这个基础上，增加一个代理工厂类(ProxyFactory.java)，将代理类写在这个地方，然后在测试类(需要使用到代理的代码)中先建立目标对象和代理对象的联系，然后代用代理对象的中同名方法。

特点：

1. 代理对象，不需要实现接口；

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

3. 动态代理也叫做：JDK代理,接口代理。

总结:

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。

/**

 * 接口

 */

public interface IUserDao {

    void save();

}

/**

 * 接口实现

 * 目标对象

 */

public class UserDao implements IUserDao {

    public void save() {

        System.out.println("----已经保存数据!----");

    }

}

/**

 * 创建动态代理对象

 * 动态代理不需要实现接口,但是需要指定接口类型

 */

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() {

                    @Override

                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

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

                        //执行目标对象方法

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

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

                        return returnValue;

                    }

                }

        );

    }

}

/**

 *  客户端

 */

public class MainTest {

public static void main(String[] args) {

        // 目标对象

        IUserDao target = new UserDao();

        // 【原始的类型 class mode5.demo2.UserDao】

        System.out.println(target.getClass());

        // 给目标对象，创建代理对象

        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();

        // class $Proxy0   内存中动态生成的代理对象

        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】

        proxy.save();

    }

}

4. Cglib代理模式的实现

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

介绍：

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

2. AOP的框架使用，例如Spring AOP和synaop，为他们提供方法的interception(拦截)

Cglib子类代理实现方法：

• cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入spring-core-3.2.0.jar即可.
• 不能为final，否则报错
• 方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中：

如果加入容器的目标对象有实现接口,用JDK代理

如果目标对象没有实现接口,用Cglib代理

/**

 * 目标对象,没有实现任何接口

 */

public class UserDao {

    public void save() {

        System.out.println("----已经保存数据!----");

    }

}

/**

 * Cglib子类代理工厂

 * 对UserDao在内存中动态构建一个子类对象

 */

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 MainTest {

public static void main(String[] args) {

//目标对象

        UserDao target = new UserDao();

        //代理对象

        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法

        proxy.save();

}

}