下一篇进阶

代理模式_利用CGLIB实现对Class动态代理

定义

代理模式（Proxy）为其他对象提供一种代理以控制对这个对象的访问

当客户端代码需要调用某个对象时，客户端实际上也不关心是否准确得到该对象，它只要一个能提供该功能的对象即可，此时我们就可返回该对象的代理（Proxy）

结构图

代理模式_大话设计模式

Subject类定义了RealSubject和Proxy的共用接口，这样就在使用RealSubject的地方都可以使用Proxy。

使用Proxy

以一个简单的示例来阐述使用代理模式实现延迟加载和面向切面的方法及其意义。

延迟加载

假设某客户端软件有根据用户请求去数据库查询数据的功能。在查询数据前，需要获得数据库连接，软件开启时初始化系统的所有类，此时尝试获得数据库连接。当系统有大量的类似操作存在时 (比如 XML 解析等)，所有这些初始化操作的叠加会使得系统的启动速度变得非常缓慢。为此，使用代理模式的代理类封装对数据库查询中的初始化操作，当系统启动时，初始化这个代理类，而非真实的数据库查询类，而代理类什么都没有做。因此，它的构造是相当迅速的。

在系统启动时，将消耗资源最多的方法都使用代理模式分离，可以加快系统的启动速度，减少用户的等待时间。而在用户真正做查询操作时再由代理类单独去加载真实的数据库查询类，完成用户的请求。这个过程就是使用代理模式实现了延迟加载。

延迟加载的核心思想是：如果当前并没有使用这个组件，则不需要真正地初始化它，使用一个代理对象替代它的原有的位置，只要在真正需要的时候才对它进行加载。使用代理模式的延迟加载是非常有意义的，首先，它可以在时间轴上分散系统压力，尤其在系统启动时，不必完成所有的初始化工作，从而加速启动时间；其次，对很多真实主题而言，在软件启动直到被关闭的整个过程中，可能根本不会被调用，初始化这些数据无疑是一种资源浪费。

面向切面

比如说，有一些用户个性化的需求，在数据查询的时候需要做特殊处理或者打印日志的时候。就可以使用代理类完成这些逻辑。如果不使用面向切面，可能需要在每一个调用真实类的位置都添加一些相同的代码。

结构优雅，拆装容易

那些“形式完全相同的手工代码”，可以封装在代理类中，得到重用

下面代码 IDBQuery是公共接口，定义代理类和真实类需要对外提供的服务，定义了实现数据库查询的公共方法 getUser()和 getAddress()函数。DBQuery是真实实现，负责实际的业务操作，DBQueryProxy是 DBQuery的代理类。

/**
 * 公共接口
 */
public interface IDBQuery {

     String getUser();

     String getAddress();
}

/**
  * 真实的实现类 
 */
public class DBQuery implements IDBQuery{
    public DBQuery(){
       try {
           //这里模仿一个初始化数据库连接的操作 耗时
           Thread.sleep(3000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
    }
    public String getUser() {
       return "this is a user";
    }
    public String getAddress() {
       return"this is aaddress";
    }
}

/**
 * 代理类
 */
public class DBQueryProxy implements IDBQuery{
    private DBQueryreal =null;
    public StringgetUser() {
       //在真正需要的时候才能创建真实对象，创建过程可能很慢
       if(real==null){
         System.out.println("初始化数据库连接");
         real = new DBQuery();
       }

       //在多线程环境下，这里返回一个虚假类，类似多线程的Future模式
       System.out.println("您查询了一个用户");
       returnreal.getUser();
    }
    public String getAddress() {
       //在真正需要的时候才能创建真实对象，创建过程可能很慢
       if(real==null){
         real = new DBQuery();
       }
       //在多线程环境下，这里返回一个虚假类，类似多线程的Future模式
       System.out.println("您查询了一个地址");
       String address = real.getAddress() +"（添加代理类逻辑）";
       return address;
    }
}

public class Main {

    public static void main(String[] args){

        IDBQuery q = new DBQueryProxy();//使用代理
        //IDBQuery q = new DBQuery();  //不使用代理
        q.getUser(); //在真正使用时才创建真实对象
        }
}

可以看到main（客户端）在获取代理对象的时候，并不需要初始化真实的DBQuery对象，而是在真正获取数据的时候才创建了真实对象。
在DBQueryProxy中，也增加了打印日志功能。

关于延迟加载可能会有下面的疑问

程序调用DBQuery对象的getUser () 方法时一样需要初始化 DBQuery对象，系统开销并未真正减少啊？只是这种系统开销延迟了而已啊？

我们可以从如下两个角度来回答这个问题：

把初始化DBQuery对象推迟到真正需要它时才创建，这样能保证前面程序运行的流畅性，而且能减少DBQuery在内存中的存活时间，从宏观上节省了系统的内存开销。

有些情况下，也许程序永远不会真正调用DBQuery对象的getUser () 方法——意味着系统根本无须创建 DBQuery对象。在这种情形下，使用代理模式可以显著地提高系统运行性能。

应用

Hibernate 使用代理模式实现延迟加载

Hibernate 的延迟加载（lazy load）是一个被广泛使用的技术。这种延迟加载保证了应用只有在需要时才去数据库中抓取相应的记录。通过延迟加载技术可以避免过多、过早地加载数据表里的数据，从而降低应用的内存开销。Hibernate的延迟加载本质上就是代理模式的应用，当程序通过 Hibernate装载一个实体时，默认情况下，Hibernate并不会立即抓取它的集合属性、关联实体所以对应的记录，而是通过生成一个代理来表示这些集合属性、关联实体，这就是代理模式应用带来的优势。

Spring基于代理模式（动态代理）实现AOP（Aspect Oriented Programming）面向切面编程

拦截器（Interceptor）是AOP的重要概念，它的作用是：控制当对象的方法执行到某个位置时，插入拦截器中的代码，然后再让原来的方法继续执行。常见AOP框架提供的拦截点包括“方法执行前”、“方法执行后”、“方法抛出错误时”等
切入点（Pointcut）是AOP中的另一个重要概念，它要描述的是：把拦截器插入到哪个对象的哪个方法中
拦截器和切入点共同组成了切面

使用动态代理

动态代理是指在运行时动态生成代理类。即，代理类的字节码将在运行时生成并载入当前代理的 ClassLoader。与静态处理类相比，动态类有诸多好处。首先，不需要为真实主题写一个形式上完全一样的封装类，假如主题接口中的方法很多，为每一个接口写一个代理方法也很麻烦。如果接口有变动，则真实主题和代理类都要修改，不利于系统维护；其次，使用一些动态代理的生成方法甚至可以在运行时制定代理类的执行逻辑，从而大大提升系统的灵活性。

以JDK的动态代理为例，继续使用刚才的接口IDBQuery。

/**
 * 动态代理
 */
public class DBQueryHandler implements InvocationHandler{
    fr.design.proxy.laze.IDBQuery realQuery =null;//定义主题接口
    public Object invoke(Object proxy, Method method, Object[]args)
           throws Throwable {
       //如果第一次调用，生成真实主题
       if(realQuery ==null){
         System.out.println("初始化真实对象");
         realQuery = new DBQuery();
       }
       if(method.getName().equals("getUser")){
           //返回真实主题完成实际的操作
           System.out.println("您查询了用户信息，logged by dynamic proxy");
           return realQuery.getUser();
       }
       else{
           System.out.println("您查询了地址信息，logged by dynamic proxy");
           return realQuery.getAddress();
       }          
    }
    //使用这个 Handler生成动态代理对象
    public static IDBQuery createProxy(){
       IDBQuery proxy = (IDBQuery)Proxy.newProxyInstance( ClassLoader.getSystemClassLoader(), new Class[]{IDBQuery.class},new DBQueryHandler() );
       return proxy;
    }
}

以上代码生成了一个实现了 IDBQuery接口的代理类，代理类的内部逻辑由 DBQueryHandler决定。生成代理类后，由 newProxyInstance()方法返回该代理类的一个实例。至此，一个完整的动态代理完成了。

public class Main {
    public static void main(String[] args){
        IDBQuery q =DBQueryHandler.createProxy();  //使用动态代理
        System.out.println(q.getUser());
        System.out.println(q.getAddress());
        }
}

两个弊端

• 必须保证target类有接口
• 如果想要对target类的方法进行代理拦截，那么就要保证这些方法都要在接口中声明，实现上略微有点限制。