JavaWeb学习-动态代理-3-代理工厂实现

ゝ一纸荒年。 2024-04-18 09:54 75阅读 0赞

前面做了一个Waiter的动态代理的练习，这篇继续来写一个练习，一个动态代理工厂的例子，这个例子在以后学习Spring的时候会有帮助。这个动态工厂的主要作用就是包装了下目标对象和前置增强和后置增强。

**工厂类的使用步骤**

我们要设计一个动态代理工厂类，以下是使用这个工程类的步骤。

1.  创建代理工厂
2.  给工厂设置三样东西

*  目标对象，调用方法setTargetObject()
 *  前置增强，调用setBeforeAdvice(该接口的具体实现)
 *  后置增强，调用setAfterAdvice(该接口的具体实现)

3.调用createProxy方法得到代理对象

执行代理对象方法时，按照以下顺序执行。

*  执行BeforeAdvice的before方法
 *  执行目标对象的目标方法
 *  执行AfterAdvice的after方法

**前提准备**

新建一个包，把前面的Waiter.java 和ManWaiter.java拷贝过来。

**创建动态代理工厂类**

这里我们的代理工厂类，先给出目标对象，前置增强和后置增强，然后创建set和get方法。

下面是前置增强接口代码

package demo1;
    
    /**
     * 	前置增强   
     * @author anthony
     *
     */
    public interface BeforeAdvice {
    	
    	public void before();
    }

下面是后置增强接口代码

package demo1;
    
    /**
     *	后置增强
     * @author anthony
     *
     */
    public interface AfterAdvice {
    	public void after();
    }

这里面，我们暂时不知道程序员会在前置增强和后置增强写什么具体代码，所以这里我们利用接口来实现，程序员到时候写代码的时候，前置增强必须要实现前置增强接口中的before方法，后置增强必须实现后置增强接口中的after方法。

下面是代理工厂类的代码

package demo1;
    
    /**
     * 	这个类用来生成代理对象
     * 	需要所有参数
     * 	*目标对象
     * 	*增强
     * @author anthony
     *
     */
    public class ProxyFactory {
    	
    	private Object targetObject; // 目标对象
    	private BeforeAdvice beforeAdvice; // 前置增强
    	private AfterAdvice afterAdvice; // 后置增强
    	
    	
    	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;
    	}
    }

这里三个对象都给生成set和get方法，方便调用。

**创建代理对象**

前面代码都不是重点，我们代理工厂重点部分来了，就是如何创建代理对象。这部分是在工厂类中，实现createProxy()方法，是本篇的重点内容，代码如下。

package demo1;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    import org.omg.CORBA.portable.InvokeHandler;
    
    /**
     * 	这个类用来生成代理对象
     * 	需要所有参数
     * 	*目标对象
     * 	*增强
     * @author anthony
     *
     */
    public class ProxyFactory {
    	
    	private Object targetObject; // 目标对象
    	private BeforeAdvice beforeAdvice; // 前置增强
    	private AfterAdvice afterAdvice; // 后置增强
    	
    	/**
    	 *	生成代理对象
    	 * @return
    	 */
    	public Object createProxy() {
    		// 1. 给出三大参数
    		ClassLoader loader = 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;
    			}
    		};
    		
    		// 2. 得到代理对象
    		Object proxyObject = Proxy.newProxyInstance(loader, interfaces, h);
    		return proxyObject;
    	}
    	
    	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;
    	}
    }

上面代码就是在createProxy()方法的时候，把目标对象和增强给做了以下组装。接下来，看看如何代码使用这个工厂类。

**测试工厂类的使用**

新建一个Demo1.java文件，写代码来使用ProxyFactory这个动态代理工厂类。

package demo1;
    
    import org.junit.Test;
    
    public class Demo1 {
    	
    	@Test
    	public void fun1() {
    		// 1. 创建工厂类对象
    		ProxyFactory factory = new ProxyFactory();
    		// 2.设置目标对象
    		factory.setTargetObject(new ManWaiter());
    		// 3.设置前置增强
    		factory.setBeforeAdvice(new BeforeAdvice() {
    			public void before() {
    				System.out.println("你好，欢迎光临！");
    			}
    		});
    		// 4.设置后置增强
    		factory.setAfterAdvice(new AfterAdvice() {
    			public void after() {
    				System.out.println("再见，欢迎下次再来！");
    			}
    		});
    		
    		// 5. 获取代理对象, 执行增强代码
    		Waiter waiter = (Waiter)factory.createProxy();
    		waiter.serve();
    	}
    
    }

运行单元测试，得到如下输出。

你好，欢迎光临！
    服务中...
    再见，欢迎下次再来！