利用动态代理实现简单的代理工厂

向右看齐 2021-06-22 15:37 381阅读 0赞

## 代码： ##

BeforeAdvice接口：

/** * 前置增强 * * @author Veeja.Liu * @emial veejaliu@gmail.com * */
    public interface BeforeAdvice { 
    	public void before();
    }

AfterAdvice接口：

/** * 后置增强 * * @author Veeja.Liu * @emial veejaliu@gmail.com * */
    public interface AfterAdvice { 
    	public void after();
    }

ProxyFactory（代理工厂类）：

/** * 代理工厂类 * * 它用来生成代理对象。它需要所有的参数。 * * 1. 创建代理工厂 * 2. 给工厂设置三样参数 * * 目标增强：setTargetObject(xxx); * * 前置增强：setBeforeAdvice(该接口的实现) * * 后置增强：setAfterAdvice(该接口的实现) * 3. 调用createProxy()得到对象 * * 执行代理对象方法时， * > 执行BeforeAdvice的before * > 执行目标对象的目标方法 * > 执行AfterAdvice的after() * @author Veeja.Liu * @emial veejaliu@gmail.com * */
    public class ProxyFactory { 
    	private Object targetObject;// 目标对象
    	private BeforeAdvice beforeAdvice;// 前置增强
    	private AfterAdvice afterAdvice;// 后置增强
    
    	/* * 用来生成代理对象 */
    	public Object createProxy() { 
    		/* * 1. 给出三大参数 */
    		ClassLoader classLoader = this.getClass().getClassLoader();
    		Class[] interfaces = targetObject.getClass().getInterfaces();
    		InvocationHandler h = new InvocationHandler() { 
    
    			public Object invoke(Object proxy, Method method,
    					Object[] args) throws Throwable { 
    				/* * 在调用代理对象的方法时会执行这个方法。 */
    				// 执行前置增强
    				if (beforeAdvice != null) { 
    					beforeAdvice.before();
    				}
    				
    				// 执行目标对象的目标方法
    				Object result = method.invoke(targetObject, args);
    				
    				// 执行后置增强
    				if (afterAdvice != null) { 
    					afterAdvice.after();
    				}
    				
    				// 返回目标对象的返回值
    				return result;
    			}
    		};
    		// 得到代理对象
    		Object proxyObject = Proxy.newProxyInstance(classLoader, interfaces, h);
    		return proxyObject;
    	}
    
    	/* * get、set方法 */
    
    	public Object getTargetObject() { 
    		return targetObject;
    	}
    
    	public void setTargetObject(Object targetObject) { 
    		this.targetObject = targetObject;
    	}
    
    	public BeforeAdvice getBeforeAdvice() { 
    		return beforeAdvice;
    	}
    
    	public void setBeforeAdvice(BeforeAdvice beforeAdvice) { 
    		this.beforeAdvice = beforeAdvice;
    	}
    
    	public AfterAdvice getAfterAdvice() { 
    		return afterAdvice;
    	}
    
    	public void setAfterAdvice(AfterAdvice afterAdvice) { 
    		this.afterAdvice = afterAdvice;
    	}
    
    }

## 使用方法： ##

我们假设，有一个服务员接口。里面有两个方法，一个是serve()服务，另一个是cash()收钱。

/* * 服务员接口 */
    public interface Waiter { 
    	// 服务方法
    	public void serve();
    	//收钱方法
    	public void cash();
    
    }

我们用一个ManWaiter类实现这个接口。

public class ManWaiter implements Waiter { 
    
    	public void serve() { 
    		System.out.println("服务中...这是您的柠檬水...");
    	}
    
    	public void cash() { 
    		System.out.println("您消费了$186000,请您付款！");
    	}
    
    }

我们怎么样增强这个类呢？  
请看示例，然后自行感悟。

public class Demo3 { 
    	public void fun1() { 
    		ProxyFactory factory = new ProxyFactory();
    		factory.setTargetObject(new ManWaiter());
    		factory.setBeforeAdvice(new BeforeAdvice() { 
    
    			public void before() { 
    				System.out.println("你好，欢迎光临！！！");
    			}
    		});
    		factory.setAfterAdvice(new AfterAdvice() { 
    
    			public void after() { 
    				System.out.println("再见，下次再来！！！");
    			}
    		});
    		Waiter waiter = (Waiter) factory.createProxy();
    		waiter.serve();
    
    	}
    }

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

END.