静态代理和动态代理

代理模式主要有两种：静态代理和动态代理

 

一、静态代理

1、先定义一个接口类

2、定义一个该接口的实现类

3、定义一个静态代理类

可以看出静态代理类有一个很不爽的缺点：

当如果接口加一个方法(把上面所有的代码的注释给去掉),所有的实现类和代理类里都需要做个实现。

这就增加了代码的复杂度。动态代理就可以避免这个缺点

 

二、动态代理

 

动态代理与普通的代理相比较，最大的好处是接口中声明的所有方法都被转移到一个集中的方法中处理（invoke），这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

 

动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类

注意：

动态代理类都需要实现InvocationHandler类,需要java.lang.reflect.InvocationHandler 接口和 java.lang.reflect.Proxy 类的支持

java.lang.reflect.InvocationHandler接口的定义如下：

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

 java.lang.reflect.Proxy类的定义如下：

/**	CLassLoader loader:类的加载器
	Class<?> interfaces:得到全部的接口
	InvocationHandler h:得到InvocationHandler接口的子类的实例**/
	public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException;

 代码：

一、

1)、先定义一个接口类

	package ttitfly.proxy;    
   
	public interface HelloWorld {    
	    public void print();    
	//  public void say();    
	}

 2)、定义一个该接口的实现类

	package ttitfly.proxy;    
   
	public class HelloWorldImpl implements HelloWorld{    
	   
	    public void print(){    
	        System.out.println("HelloWorld");    
	    }    
	//  public void say(){    
	//      System.out.println("Say Hello!");    
	//  }    
	}    

 3)、定义一个静态代理类

	package ttitfly.proxy;    
   
	public class StaticProxy implements HelloWorld{    
	   
	    public HelloWorld helloWorld ;    
	    public StaticProxy(HelloWorld helloWorld){    
	        this.helloWorld = helloWorld;    
	    }    
	        
	    public void print(){    
	        System.out.println("Welcome");    
	        //相当于回调    
	        helloWorld.print();    
	    }    
	        
	//  public void say(){    
	//      //相当于回调    
	//      helloWorld.say();    
	//  }    
	}      

 4) 一个测试类:

	package ttitfly.proxy;    
	   
	public class TestStaticProxy {    
	   
	    public static void main(String[] args){    
	        HelloWorld helloWorld = new HelloWorldImpl();    
	        StaticProxy staticProxy = new StaticProxy(helloWorld);    
	        staticProxy.print();    
	            
	//      staticProxy.say();    
	    }    
	}   

 二、

代理类:

	package ttitfly.proxy;        
       
	import java.lang.reflect.InvocationHandler;        
	import java.lang.reflect.Method;        
	import java.lang.reflect.Proxy;        
	//动态代理类只能代理接口，代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类        
	public class DynamicProxy implements InvocationHandler{        
	            
	    private Object object;         
	    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。    
	    //Proxy.newProxyInstance的第三个参数是表明这些被拦截的方法执行时需要执行哪个InvocationHandler的invoke方法    
	    public Object bindRelation(Object object){         
	        this.object = object;        
	        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(),this);         
	    }         
	    //拦截关联的这个实现类的方法被调用时将被执行        
	    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         
	        System.out.println("Welcome");        
	        Object result = method.invoke(object, args);         
	        return result;        
	    }        
	       
	}

 测试类：

	package ttitfly.proxy;        
       
	public class TestDynamicProxy {        
	    public static void main(String[] args){        
	        HelloWorld helloWorld = new HelloWorldImpl();        
	        DynamicProxy dp = new DynamicProxy();        
	        //在这里绑定的是HelloWorld,也就是HelloWorld是被代理接口。所以绑定关系时，需要传递一个HelloWorld的实现类的实例化对象。        
	        HelloWorld helloWorld1 = (HelloWorld)dp.bindRelation(helloWorld);         
	        helloWorld1.print();         
	        helloWorld1.say();        
	            
	        //helloWorld2将不被拦截    
	        HelloWorld helloWorld2 = new HelloWorldImpl();    
	        helloWorld2.print();         
	        helloWorld2.say();    
	            
	    }        
	}

 -----------------------------------

 

public Filter getFilter(Class<? extends Filter> clazz) {

if(filters.isEmpty()){

return null;

}

for(Filter filter:filters){

if(clazz.isInstance(filter)){

return filter;

} 

}

return null;

}