静态代理

一、概念

  代理模式是常用的Java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。按照代理类的创建时期，代理类可分为两种。

静态代理类：由程序员创建或由特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理类：在程序运行时，运用反射机制动态创建而成。
静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
 静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道。
动态代理是实现JDK里的InvocationHandler接口的invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。
还有一种动态代理CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到修改类的目的。

 

二、静态代理类

 

如下， HelloServiceProxy类是代理类，HelloServiceImpl类是委托类，这两个类都实现了HelloService接口。其中HelloServiceImpl类是HelloService接口的真正实现者，而HelloServiceProxy类是通过调用HelloServiceImpl类的相关方法来提供特定服务的。HelloServiceProxy类的echo()方法和getTime()方法会分别调用被代理的HelloServiceImpl对象的echo()方法和getTime()方法，并且在方法调用前后都会执行一些简单的打印操作。
由此可见，代理类可以为委托类预处理消息、把消息转发给委托类和事后处理消息等。

1.  
   例程1 HelloService.java
2.  
   package proxy;
3.  
   import java.util.Date;
4.  
   public interface HelloService{
5.  
   public String echo(String msg);
6.  
   public Date getTime();
7.  
   }

1.  
   例程2 HelloServiceImpl.java
2.  
   package proxy;
3.  
   import java.util.Date;
4.  
   public class HelloServiceImpl implements HelloService{
5.  
   public String echo(String msg){
6.  
   return "echo:"+msg;
7.  
   }
8.  
   public Date getTime(){
9.  
   return new Date();
10.  
    }
11.  
    }

1.  
   例程3 HelloServiceProxy.java
2.  
   package proxy;
3.  
   import java.util.Date;
4.  
   public class HelloServiceProxy implements HelloService{
5.  
   //表示被代理的HelloService 实例
6.  
   private HelloService helloService;
7.  
   public HelloServiceProxy(HelloService helloService){
8.  
   this.helloService=helloService;
9.  
   }
10.  
    public void setHelloServiceProxy(HelloService helloService){
11.  
    this.helloService=helloService;
12.  
    }
13.  
    public String echo(String msg){
14.  
    //预处理
15.  
    System.out.println("before calling echo()");
16.  
    //调用被代理的HelloService 实例的echo()方法
17.  
    String result=helloService.echo(msg);
18.  
    //事后处理
19.  
    System.out.println("after calling echo()");
20.  
    return result;
21.  
    }
22.  
    public Date getTime(){
23.  
    //预处理
24.  
    System.out.println("before calling getTime()");
25.  
    //调用被代理的HelloService 实例的getTime()方法
26.  
    Date date=helloService.getTime();
27.  
    //事后处理
28.  
    System.out.println("after calling getTime()");
29.  
    return date;
30.  
    }
31.  
    }

在Client1类的main()方法中，先创建了一个HelloServiceImpl对象，又创建了一个HelloServiceProxy对象，最后调用HelloServiceProxy对象的echo()方法。

1.  
   例程4 Client1.java
2.  
   package proxy;
3.  
   public class Client1{
4.  
   public static void main(String args[]){
5.  
   HelloService helloService=new HelloServiceImpl();
6.  
   HelloService helloServiceProxy=new HelloServiceProxy(helloService);
7.  
   System.out.println(helloServiceProxy.echo("hello"));
8.  
   }
9.  
   }

1.  
   运行Client1 类，打印结果如下：
2.  
   before calling echo()
3.  
   after calling echo()
4.  
   echo:hello

例程3 的HelloServiceProxy类的源代码是由程序员编写的，在程序运行前，它的.class文件就已经存在了，这种代理类称为静态代理类。更加像一种装饰者模式