Java 代理

代理模式UML类图

 

代理模式
 

 

 

1. 静态代理

 

/**  
 * 为被代理的类提供一个接口，是为了提高代理的通用性，凡是实现了该接口的类，都可以被代理  
 * 这里其实就是运用了java面向对象的多态性  
 */  
public interface IHello {   
    public void sayHello();   
}   
/**  
 * 被代理的类，最根本的想法就是想用另外一个类来代理这个类，给这个类添加一些额外的东西  
 * 我们只需要创建另外一个类引用这个类就行了  
 */  
public class Hello implements IHello   
{   
    public void sayHello(){   
        System.out.println("被代理的方法");   
    }   
}  
/**  
 * 静态代理类，其实就是(被代理类的)接口的另外一种实现,  
 * 用来代替原来的被代理类  
 * @author qiuxy  
 */  
public class StaticProxy implements IHello { 
    IHello hello;   
    public StaticProxy(IHello hello) {   
        this.hello = hello;   
    }   
    /**  
     * 重新实现了sayHello()方法，这种实现其实就是在被代理类实现该方法中添加一些额外的东西， 以实现代理的作用  
*/  
    public void sayHello() {   
        System.out.println("在被代理的对象之前执行");   
        // 被代理的对象执行方法   
        hello.sayHello();   
        System.out.println("在被代理的对象之前执行");   
    }   
}  
/**  
 * 测试类  
 * @author qiuxy  
 */  
public class Test {   
    public static void main(String[] args) {   
        //产生一个被代理对象，只要实现了Ihello接口的对象，都可以成为被代理对象   
        //这里就是利用接口的好处，但这个也有局限性，就是只限于某种接口   
        IHello hello = new Hello();   
        //产生一个代理对象   
        StaticProxy sp = new StaticProxy(hello);   
        //执行代理对象的sayHello()方法，这个方法在被代理的方法前后添加了其他代码   
        sp.sayHello();   
    }   
}  

 

2. 动态代理

 

import java.lang.reflect.InvocationHandler;   
import java.lang.reflect.Method;   
/**  
 * 代理处理器，这个代理处理器实现了InvocationHandler这个接口，  
 * 这个接口的提供了一个invoke方法,并且传入三个参数(被代理的对象，被代理的方法，方法的参数数组)  
 * 这个invoke方法会在被代理的方法之前被调用  
 */  
public class MyProxyHandler implements InvocationHandler {   
    //被代理的对象   
    Object delegate;    
    //构造函数，在构在这个代理处理器时，传入要被代理的对象   
    public MyProxyHandler(Object delegate) {           this.delegate = delegate;   
    }   
    //被代理的方法之前会调用的方法   
    public Object invoke(Object proxy, Method method, Object[] args)   throws Throwable { 
        System.out.println("我在被代理的方法之前执行");   
        //被代理的方法开始执行   
        method.invoke(delegate, args);   
        System.out.println("我在被代理的方法之后执行");   
        return null;   
    }   
}  
import java.lang.reflect.Proxy;   
/**  
 * 测试类  
 */  
public class Test   
{   
    public static void main(String[] args)   
    {   
        Hello hello = new Hello();   
        //产生一个代理处理器对象   
        MyProxyHandler mph = new MyProxyHandler(hello);   
        //通过反射获得代理类，这里必须转换成代理类的接口类型   
        //这个代理对象其实是java动态生成一个被代理类的接口的另外一个实现类   
        IHello myProxy = (IHello)Proxy.newProxyInstance(hello.getClass().getClassLoader()  , hello.getClass().getInterfaces(), mph);   
        //代理类执行方法   
        myProxy.sayHello();   
    }   
  
}