标签：
在JDBC访问数据库时，增删改的方法可谓都要进行手动事务处理，所以在每一个方法执行的时候，就都要写事务处理的代码。当敲起代码来不舒服的时候，我们就要想想面向对象的思想，这么多次重复写相同的代码是不对的，所以就要进行抽象和封装，于是就有了设计模式。
代理模式（Proxy）：为其他对象提供一种代理，以控制对这个对象的访问。举一个生活中的例子，如果我们买什么东西，我们并不会去工厂直接购买，而是去商场进行选购，这时的商场也就是工厂的代理类。在类的单一职责原则中，一个类应该只做一件事，所以工厂类不应该做销售的工作，商场类也不做制作的工作。
从上图可以看出，代理模式有三种角色：
Subject：抽象的主题接口，是代理角色和真实角色共同实现的接口，表明在任何使用真实角色的地方，都可以使用代理角色。
RealSubject：真实角色，代理角色所代表的真实对象，代理所做的一切事情其实都是真实角色做的。
Proxy：代理角色，代替真实角色和用到真实角色的对象打交道，当然它的工作只有“谈判”，至于具体执行还是要靠真实角色。
代理模式有很多适用的地方，常见的远程代理代理模式的运用之一，另外也可以用在较大资源加载时，或者创建时间比较长的对象上面。
静态代理类其实就是程序员编写的，在程序运行前就已经存在的代理类。只需要让代理类和委托类同时实现一个接口，代理类就可以为委托类做事了。
代理接口（Subject）：
public interface UserManager {
public void addUser(String userId, String userName);
}
public class UserManagerImpl implements UserManager {
public void addUser(String userId, String userName) {
try {
System.out.println("UserManagerImpl.addUser() userId-->>" + userId);
}catch(Exception e) {
e.printStackTrace();
throw new RuntimeException();
}
}
}
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() userId-->>" + userId);
userManager.addUser(userId, userName);
System.out.println("success-->>addUser()");
}catch(Exception e) {
e.printStackTrace();
System.out.println("error-->>addUser()");
}
}
}
public class Client {
public static void main(String[] args) {
UserManager userManager = new UserManagerImplProxy(new UserManagerImpl());
userManager.addUser("0001", "张三");
}
}
在Java中有一个InvocationHandler接口，它采用的就是动态代理的机制，代理类实现这个接口中的newProxyInstance(Object targetObject)方法和invoke(Object proxy, Method method, Object[] args)方法，就可以分别实现代理类的实例化和代理事件的执行。动态代理相对于静态代理来说，代理接口、客户端和委托类的代码并没有变化，只是代理类的代码有所改变。
代理类（Proxy）：
public class LogHandler implements InvocationHandler {
private Object targetObject;
//创建代理类实例，传入一个对象，无论什么对象
public Object newProxyInstance(Object targetObject) {
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
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;
}
}
public class Client {
public static void main(String[] args) {
LogHandler logHandler = new LogHandler();
UserManager userManager = (UserManager)logHandler.newProxyInstance(new UserManagerImpl());
userManager.addUser("0001", "张三");
userManager.delUser("0001");
}
}动态代理相对于静态代理的好处就是，代理类只是在需要的时候创建，而不是上来不管用不用都创建好。
在DRP中，动态代理被用在了封装事务，每个访问数据库的方法都执行动态代理类的方法，如果是增删改方法，就为其开启、提交事务，如果有异常就回滚事务；如果是查询的方法，便不执行事务。其实查询最好也放到事务里面，只是这里没有做。
public class TransactionHandler implements InvocationHandler {
private Object targetObject;
public Object newProxyInstance(Object targetObject) {
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Connection conn = null;
Object ret = null;
try {
//从ThreadLocal中取得Connection
conn = ConnectionManager.getConnection();
if (method.getName().startsWith("add") ||
method.getName().startsWith("del") ||
method.getName().startsWith("modify")) {
//手动控制事务提交
ConnectionManager.beginTransaction(conn);
}
//调用目标对象的业务逻辑方法
ret = method.invoke(targetObject, args);
if (!conn.getAutoCommit()) {
//提交事务
ConnectionManager.commitTransaction(conn);
}
}catch(ApplicationException e) {
//回滚事务
ConnectionManager.rollbackTransaction(conn);
throw e;
}catch(Exception e) {
e.printStackTrace();
if (e instanceof InvocationTargetException) {
InvocationTargetException ete = (InvocationTargetException)e;
throw ete.getTargetException();
}
//回滚事务
ConnectionManager.rollbackTransaction(conn);
throw new ApplicationException("操作失败！");
}finally {
ConnectionManager.closeConnection();
}
return ret;
}
}
不管是动态代理还是静态代理，总是会为委托类建立各种代理类，类多了自然也不容易管理，这也是代理模式的缺点之一。动态代理和静态代理的区别，在于二者执行过程中，代理类的创建时间不同，静态代理是程序运行前就要把类写好，动态代理是在执行过程中动态创建。这里的动态代理的执行，很像是面向切面的编程，它在程序执行过程中，横向切入进去进行检查，如果是增删改的方法，则为其执行手动事务的处理。
标签：
原文地址：http://blog.csdn.net/fengyao1995/article/details/51315896
