前言
在JDBC访问数据库时,增删改的方法可谓都要进行手动事务处理,所以在每一个方法执行的时候,就都要写事务处理的代码。当敲起代码来不舒服的时候,我们就要想想面向对象的思想,这么多次重复写相同的代码是不对的,所以就要进行抽象和封装,于是就有了设计模式。
代理模式
代理模式(Proxy):为其他对象提供一种代理,以控制对这个对象的访问。举一个生活中的例子,如果我们买什么东西,我们并不会去工厂直接购买,而是去商场进行选购,这时的商场也就是工厂的代理类。在类的单一职责原则中,一个类应该只做一件事,所以工厂类不应该做销售的工作,商场类也不做制作的工作。
从上图可以看出,代理模式有三种角色:
Subject:抽象的主题接口,是代理角色和真实角色共同实现的接口,表明在任何使用真实角色的地方,都可以使用代理角色。
RealSubject:真实角色,代理角色所代表的真实对象,代理所做的一切事情其实都是真实角色做的。
Proxy:代理角色,代替真实角色和用到真实角色的对象打交道,当然它的工作只有“谈判”,至于具体执行还是要靠真实角色。
代理模式有很多适用的地方,常见的远程代理代理模式的运用之一,另外也可以用在较大资源加载时,或者创建时间比较长的对象上面。
静态代理
静态代理类其实就是程序员编写的,在程序运行前就已经存在的代理类。只需要让代理类和委托类同时实现一个接口,代理类就可以为委托类做事了。
代理接口(Subject):
public interface UserManager {
public void addUser(String userId, String userName);
}
真实角色(RealSubject):
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();
}
}
}
代理角色(Proxy):
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", "张三");
}
}
这样一个静态代理模式就完成了,其实从上面代码可以看出,这个代理类是代理RealSubject处理了类似日志的东西,但是如果委托类需要代理类做其他事情,那么就得重新创建一个新的代理类,这也就是静态代理的缺点,代理的事情多了,需要写很多代理类,不容易维护。这个时候,我们可以采用动态代理的方式。
动态代理
在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;
}
}
总结
不管是动态代理还是静态代理,总是会为委托类建立各种代理类,类多了自然也不容易管理,这也是代理模式的缺点之一。动态代理和静态代理的区别,在于二者执行过程中,代理类的创建时间不同,静态代理是程序运行前就要把类写好,动态代理是在执行过程中动态创建。这里的动态代理的执行,很像是面向切面的编程,它在程序执行过程中,横向切入进去进行检查,如果是增删改的方法,则为其执行手动事务的处理。