JAVA设计模式之代理模式

简介

1.定义

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

属于结构型模式的一种。

在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用， 其特征是代理类与委托类有同样的接口。
代理模式是常用的java设计模式。

代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

代理的分类

根据以上对代理的理解，对于代理的具体实现，我们有不同的方式，如果按照代理的创建时期，代理类可以分为两种。：静态代理、动态代理。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而程。

1、静态代理

需要定义业务接口，业务接口实现类

//定义一个业务接口
public interface Account {    
        // 查询   
    public void queryAccount ();    
        // 修改    
    public void updateAccount ();      
}    
  
 // 接口实现类(包含业务逻辑)  即：委托类    
public class AccountImpl implements Account{    
        
      @Override    
      public void queryAccount() {    
          System.out.println("查询方法...");          
      } 
         
     @Override    
      public void updateAccount() {    
        System.out.println("修改方法...");          
    }    
        
} 

定义代理类，实现业务接口

/**  
 * 代理类（增强AccountImpl的功能） 
 */    
public class AccountProxy implements Account{    
    private AccountImpl accountImpl;    
    
    /**  
     * 重写默认构造函数 
     * @param accountImpl :真正要执行业务的对象 
     */    
    public AccountProxy(AccountImpl accountImpl) {    
        this.accountImpl =accountImpl;    
    }    
    
    @Override    
    public void queryAccount() {    
        System.out.println("业务处理之前...");    
        // 调用委托类的方法，这是具体的业务方法    
       accountImpl.queryAcount();    
        System.out.println("业务处理之后...");    
    }    
    
    @Override    
    public void updateAccount() {    
        System.out.println("业务处理之前...");    
        // 调用委托类的方法;    
        accountImpl.updateAccount();    
        System.out.println("业务处理之后...");      
    }      
} 

客户端

public class TestAccount {    
    public static void main(String[] args) {    
        AccountImpl accountImpl = new AccountImpl();    
        //在这里传入要调用的业务对象  
        AccountProxy accountProxy = new AccountProxy(accountImpl);    
       //开始调用业务对象的方法，这两个方法都被增强了。  
        accountProxy.updateAccount();    
        accountProxy.queryAccount();    
    }    
} 

测试结果

业务处理之前...
修改方法...
业务处理之后...
业务处理之前...
查询方法...
业务处理之后...

观察代码可以发现每一个代理类只能为一个接口服务，一个AccountProxy 类实现了一个Account接口，那么我要是有多个接口，是不是要写多个Proxy类与之对应。这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那就引入了我们的动态代理了

动态代理

静态代理需要在运行之前就写好代理类，这样就造成了代码的大量重复，所以我们通过动态代理在运行时期动态生成业务类的代理类，那么动态代理类是如何实现的呢？

好处：

1. 动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。
2. 动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。
3. java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 利用反射的机制来实现。

JDK动态代理中包含一个类和一个接口： InvocationHandler接口，和我们定义的一个实现类“Proxy“，这是一个万能的代理类，我们就是通过这个代理类来动态代理的。

InvocationHandler接口：

/**
 * Object proxy：指被代理的对象。
 * Method method：要调用的方法 
 * Object[] args：方法调用时所需要的参数 
 */
public interface InvocationHandler { 
      public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
}

Proxy类：
Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类，此类提供了如下的操作方法：

/**
 *  参数说明： 
 *  ClassLoader loader：类加载器 
 *  Class<?>[] interfaces：得到全部的接口 
 *  InvocationHandler h：得到InvocationHandler接口的子类实例 
 */
public static Object newProxyInstance(ClassLoader loader, 
		Class<?>[] interfaces, 
		InvocationHandler h) throws IllegalArgumentException {
	...
}

// 在Proxy类中的newProxyInstance（）方法中需要一个ClassLoader类的实例，ClassLoader实际上对应的是
// 类加载器，在Java中主要有一下三种类加载器; 
// Booststrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的； 
// Extendsion ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类; 
// AppClassLoader：(默认)加载classpath指定的类，是最常使用的是一种加载器。

该处的代理类Proxy 不去实现具体的某个业务接口，而是实现了JDK提供的InvocationHander类。在Proxy中我们不需要知道具体的业务类，即委托类，在运行之前，讲委托类和代理类进行解耦，在运行期才发生的联系，是通过这句话实现的：private object target。然后在调用的时候通过getInstance 在确定谁是委托对象。

/**  
 * JDK动态代理代理类    
 */    
public class Proxy implements InvocationHandler {    
    private Object target;    
    /**  
     * 绑定委托对象并返回一个代理类  
     * @param target  
     * @return  
     */    
    public Object getInstance(Object target) {    
        this.target = target;    
        //取得代理对象    
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);     
    }    
    
    @Override    
    /**  
     * 调用方法  
     */    
    public Object invoke(Object proxy, Method method, Object[] args)    
            throws Throwable {    
        Object result=null;    
        System.out.println("before");    
        //执行方法    
        result=method.invoke(target, args);    
        System.out.println("after");    
        return result;    
    }    
}

测试

public class TestProxy {    
    
    public static void main(String[] args) {    
        Proxy proxy = new Proxy();    
    // 在这里进行真正的对象传入  
        Account account= (Account )proxy.getInstance(new AccountImpl());    
        proxy.queryAccount();    
    }    
    
}

测试结果

before
查询方法...
after