Java实战（二）—代理模式

一、背景

   当我们系统中每个方法都需要相同的功能时，比如日志、事务……；我们之前一直就是将相应都重新写一遍。如果我们共同的方法出现了问题，所有用到它的方法都必须进行修改，系统维护起来困难，并且不符合OCP原则。那该怎样去做？

   常规编程：重复代码写到每个方法中

   

二、学习轨迹

   第一次学习：设计模式（九）-代理模式（结构型）  懵懂中继续学习，理解的比较浅显

   第二次学习：重温设计模式（一）—代理模式   现在看来有些理解的或是浅显，或是真的错了；但没之前的糊里糊涂，哪有现在的清晰思路

   第三次学习：项目实战（二）—代理模式 结合项目发现了原来代理是这么回事，了解了动态代理是AOP的实现原理，其中invoke相当于filter（统一进行控制）

 

三、定义

   代理模式给某个对象提供了一个代理对象，并由代理对象控制对原有对象的引用    

          

注：

客户端不再操作真实对象，直接与代理交互

代理与真实对象接口一致，代理类控制真实对象的访问

实例：

   厂家、代理商、客户（代理商只负责卖东西，不负责生产）

四、静态代理  

     将相同代码转移到代理上，易维护，不需要修改真实对象（代理类进行控制）

           

     调用过程:

 

2、优缺点：

   优点：将相同代码转移到代理上，修改共同代码时，不需要修改真实对象，复合OCP原则；系统更加灵活

   缺点：未解决代码重复问题，代理上每个方法依旧有相同代码

3、代码实例

/**
 * 接口UserManager
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:09:33 
 */
public interface UserManager {
	public void addUser(String userId,String userName);
	
	public void delUser(String userId);
	
	public String ModifyUser(String userId,String userName);
	
	public void findUser(String userId);
	
}
（2）具体实现累
package com.bjpowernode.pattern;
/**
 * 
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:11:55 
 */
public class UserManagerImpl implements UserManager {

	public void addUser(String userId, String userName) {
		System.out.println("UserManagerImpl.addUser() userId-->"+userId);
	}

	public void delUser(String userId) {
		System.out.println("UserManagerImpl.delUser() userId-->"+userId);
	}

	public String ModifyUser(String userId, String userName) {
		System.out.println("UserManagerImpl.ModifyUser() userId-->"+userId);
		return "张三";
	}

	public void findUser(String userId) {
		System.out.println("UserManagerImpl.findUser() userId-->"+userId);
	}
}

（3）代理类
package com.bjpowernode.pattern;
/**
 * 代理类
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:21:34 
 */
public class UserManagerImplProxy implements UserManager {
	private UserManager userManager;
	
	//对真实对象的引用
	public UserManagerImplProxy(UserManager userManager) {
		this.userManager=userManager;
	}

	public void addUser(String userId, String userName) {
		try {
			//重复的代码
			System.out.println("Start-->>addUser() useId-->>"+userId );
			//调用真实对象的方法
			userManager.addUser(userId, userName);
			//重复的代码
			System.out.println("success-->>addUser()");
			
		} catch (Exception e) {
			e.printStackTrace();
			//重复的代码
			System.out.println("error-->>addUser()");
		}
	}

	public void delUser(String userId) {
		// TODO Auto-generated method stub

	}

	public String ModifyUser(String userId, String userName) {
		// TODO Auto-generated method stub
		return null;
	}

	public void findUser(String userId) {
		// TODO Auto-generated method stub

	}
}
（4）客户端
package com.bjpowernode.pattern;

public class Client {
	/**
	 * 客户端
	 * @param args
	 */
	public static void main(String[] args) {
		//客户端只与代理联系
		UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
		userManager.addUser("0001", "张三");
	}

}

五、动态代理

   解决了代码重复问题

 

前提：代理类与普通类实现相同的接口

1、优缺点

     优点：消除了重复代码

     不足：使用了反射，损耗效率

2、代码实例

     JDK动态代理只能对实现了接口的类进行代理，采用JDK动态代理必须实现InvocationHanlder接口，采用Proxy类创建相应的代理类

     <1 invoke方法：在代理实例上处理方法调用并返回结果

   public Object invoke(Object proxy, Method method,Object[] arguments)

   Extract the appropriate property value from the eventand pass it to the action associated with this EventHandler.

     <2 Proxy类：用来创建冬天代理类和实例的静态方法，会根据接口在内存中建立类

<span style="font-family:KaiTi_GB2312;font-size:14px;"><span style="background-color: rgb(255, 255, 255);">    </span></span><pre name="code" class="csharp">（1）接口UserManager
package com.bjpowernode.pattern;
/**
 * 接口UserManager
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:09:33 
 */
public interface UserManager {
	public void addUser(String userId,String userName);
	
	public void delUser(String userId);
	
	public String ModifyUser(String userId,String userName);
	
	public void findUser(String userId);
	
}
（2）具体实现累
package com.bjpowernode.pattern;
/**
 * 
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:11:55 
 */
public class UserManagerImpl implements UserManager {

	public void addUser(String userId, String userName) {
		System.out.println("UserManagerImpl.addUser() userId-->"+userId);
	}

	public void delUser(String userId) {
		System.out.println("UserManagerImpl.delUser() userId-->"+userId);
	}

	public String ModifyUser(String userId, String userName) {
		System.out.println("UserManagerImpl.ModifyUser() userId-->"+userId);
		return "张三";
	}

	public void findUser(String userId) {
		System.out.println("UserManagerImpl.findUser() userId-->"+userId);
	}
}
（3）代理类
package com.bjpowernode.pattern;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class LogHandler implements InvocationHandler {
	
	private Object targetObject;
	
	//对谁生成代理，将相应的目标传入，返回Object
	public Object newProxyInstance(Object targetObject) {
		this.targetObject = targetObject;
		//根据传入对象，生成代理对象
		//getClassLoader()与目标使用加载器一致
		//interface获得对象实现的接口，根据接口创建代理类，但方法为空 
		//this：实现invocationhandler类，指现在这个类
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
	<span style="white-space:pre">	</span> targetObject.getClass().getInterfaces(), this);
	}
	
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		//公共方法
		System.out.println("start-->>" + method.getName());
		
		//获得目标方法的参数
		for (int i=0; i<args.length; i++) {
			System.out.println(args[i]);
		}
		
		Object ret = null;
		try {
			//调用目标方法
			ret = method.invoke(targetObject, args);
			
			//公共方法
			System.out.println("success-->>" + method.getName()); 
		}catch(Exception e) {
			e.printStackTrace();
			
			//公共方法
			System.out.println("error-->>" + method.getName());
			throw e;
		}
		return ret;
	}
}
（4）客户端
package com.bjpowernode.pattern;
/**
 * 
 *@author 高晓青  
 * @date 创建时间：2015-3-6 下午8:15:25 
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {		
		LogHanlder logHanlder=new LogHanlder();
		UserManager userManager=(UserManager)logHanlder.newProxyInstance(new UserManagerImpl());
		
		//调用代理上的方法（内存中）调用invoke方法
		userManager.addUser("0001", "张三");		
	}
}

          代理模式的引入，使系统更加灵活。 Spring AOP 的实现原理是动态代理，具体 AOP 究竟是什么样的！接下来的学习中再深入。