AOP(Aspect Oriented Programming,面向方面编程)是如今比较火的概念之一,再加上Spring框架的流行,很多程序员更是言必称AOP,如果对AOP不了解就像土老帽似的。AOP中的Aspect其实就是程序员关注的某一方面,如某些方法有没有被访问过、某些方法执行时间有多长、把某些方法的执行置于事务之下等等,具体实现方法就是在某些方法执行前后自动执行一些操作,就像拦截器一样。其实一些框架中的拦截器功能正是通过AOP实现的。
Java反射功能中有一项就是动态代理,但代理的对象必须实现了接口,也就是Jdk目前仅支持接口的代理。其原理是首先检索被代理对象的所有接口,然后动态生成一个实现了被代理对象接口的Class(这也是为什么叫动态代理的原因),最后把这个Class的一个实例返回。因为通过Java动态代理之后,您所使用的对象就像狸猫换太子一样被掉包了,执行一个方法时,其实是执行的动态生成实例的方法,里面会有一个地方调用原对象的方法,从而达到在原对象方法执行前后运行特定代码的目的。在Spring中,利用了cglib,如果被代理对象实现了接口,就用Java的动态代理,如果仅仅是一个没有接口的类,则用cglib中继承的方式进行代理。
在Spring中有用Java注解(annotation)的方法实现事务管理的功能,也就是声明式事务,去除了代码中繁琐的事务控制代码。在本文中,利用Java的annotation、dynamic proxy实现一个简单的管理数据库连接与事务的框架,而不使用任何现成的框架。
首先是一个获取数据库连接的工具类,此处是使用的是mysql数据库,运行时需要mysql的jdbc驱动包。代码如下:
package demo.dynamicproxy;
import java.sql.Connection;
import java.sql.DriverManager;
public class DbUtil {
/**
* 获取数据库连接,如果使用其他数据库,修改这里就可以了。
* @return
*/
public static Connection getConnection() {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/st", "root", "");
}
catch(Exception e) {
e.printStackTrace();
}
return conn;
}
}
import java.sql.Connection;
import java.sql.DriverManager;
public class DbUtil {
/**
* 获取数据库连接,如果使用其他数据库,修改这里就可以了。
* @return
*/
public static Connection getConnection() {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/st", "root", "");
}
catch(Exception e) {
e.printStackTrace();
}
return conn;
}
}
对于需要数据库操作的业务类,需要实现IDb接口:
package demo.dynamicproxy;
import java.sql.Connection;
public interface IDb {
/**
* 设置数据库连接
* @param conn
*/
void setConnection(Connection conn);
/**
* 获取数据库连接。
* 如果没有设置返回null。
* @return
* @throws Exception
*/
Connection getConnection();
/**
* 释放数据库连接
* @param conn
* @throws Exception
*/
void closeConnection();
}
import java.sql.Connection;
public interface IDb {
/**
* 设置数据库连接
* @param conn
*/
void setConnection(Connection conn);
/**
* 获取数据库连接。
* 如果没有设置返回null。
* @return
* @throws Exception
*/
Connection getConnection();
/**
* 释放数据库连接
* @param conn
* @throws Exception
*/
void closeConnection();
}
为了使用方便,建立一个IDb接口的默认实现类:
package demo.dynamicproxy;
import java.sql.Connection;
import java.sql.Statement;
public class DbImpl implements IDb {
private Connection conn;
@Override
public void closeConnection() {
try {
if (conn != null) conn.close();
conn = null;
System.out.println("close conn");
}
catch(Exception e) {
e.printStackTrace();
}
}
@Override
public Connection getConnection() {
return conn;
}
@Override
public void setConnection(Connection conn) {
this.conn = conn;
System.out.println("set conn");
}
protected int executeNonQuery(String sql) throws Exception {
System.out.println("executeNonQuery begin:" + sql);
Statement stmt = null;
int result = 0;
try {
stmt = getConnection().createStatement();
result = stmt.executeUpdate(sql);
}
catch(Exception e) {
throw e;
}
finally {
if (stmt != null) stmt.close();
}
System.out.println("executeNonQuery complete:" + sql);
return result;
}
}
import java.sql.Connection;
import java.sql.Statement;
public class DbImpl implements IDb {
private Connection conn;
@Override
public void closeConnection() {
try {
if (conn != null) conn.close();
conn = null;
System.out.println("close conn");
}
catch(Exception e) {
e.printStackTrace();
}
}
@Override
public Connection getConnection() {
return conn;
}
@Override
public void setConnection(Connection conn) {
this.conn = conn;
System.out.println("set conn");
}
protected int executeNonQuery(String sql) throws Exception {
System.out.println("executeNonQuery begin:" + sql);
Statement stmt = null;
int result = 0;
try {
stmt = getConnection().createStatement();
result = stmt.executeUpdate(sql);
}
catch(Exception e) {
throw e;
}
finally {
if (stmt != null) stmt.close();
}
System.out.println("executeNonQuery complete:" + sql);
return result;
}
}
对于需要数据库连接和事务的方法,加上一个注解就可以了,这就是那个注解:
package demo.dynamicproxy.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 被注解的方法可以自动获取数据库连接并开启事务。
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Transactional {
boolean autoCommit() default false;
}
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 被注解的方法可以自动获取数据库连接并开启事务。
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Transactional {
boolean autoCommit() default false;
}
被代理方法执行时的处理器,动态代理的核心就在这里:
package demo.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import demo.dynamicproxy.annotation.Transactional;
/**
* 自动处理数据库连接、事务的调用处理器
*/
public class TransactionalInvocationHandler implements InvocationHandler {
private Object target;
private IDb db;
/**
* 构造方法
* @param target
*/
public TransactionalInvocationHandler(Object target) {
this.target = target;
this.db = (IDb) target;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("method invoke begin:" + method.getName());
Object result = null;
boolean isNeedTransaction = false;
boolean isAutoCommit = false;
if (method.isAnnotationPresent(Transactional.class)) {
isNeedTransaction = true;
isAutoCommit = method.getAnnotation(Transactional.class).autoCommit();
}
boolean isLocalOpen = false;
boolean rollback = false;
Connection conn = db.getConnection();
System.out.println("isNeedTransaction:" + isNeedTransaction);
System.out.println("isAutoCommit:" + isAutoCommit);
System.out.println("isLocalOpen:" + isLocalOpen);
try {
if (isNeedTransaction) {
if (conn == null) {
isLocalOpen = true;
try {
conn = DbUtil.getConnection();
if (conn == null) throw new Exception("数据库连接获取错误");
conn.setAutoCommit(isAutoCommit);
}
catch (Exception e) {
throw e;
}
db.setConnection(conn);
}
}
result = method.invoke(this.target, args);
}
catch(Exception e) {
rollback = true;
e.printStackTrace();
throw e;
}
finally {
if (conn != null && isLocalOpen) {
if (!isAutoCommit) {
if (rollback) conn.rollback();
else conn.commit();
}
db.closeConnection();
}
}
System.out.println("method invoke complete:" + method.getName());
return result;
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import demo.dynamicproxy.annotation.Transactional;
/**
* 自动处理数据库连接、事务的调用处理器
*/
public class TransactionalInvocationHandler implements InvocationHandler {
private Object target;
private IDb db;
/**
* 构造方法
* @param target
*/
public TransactionalInvocationHandler(Object target) {
this.target = target;
this.db = (IDb) target;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("method invoke begin:" + method.getName());
Object result = null;
boolean isNeedTransaction = false;
boolean isAutoCommit = false;
if (method.isAnnotationPresent(Transactional.class)) {
isNeedTransaction = true;
isAutoCommit = method.getAnnotation(Transactional.class).autoCommit();
}
boolean isLocalOpen = false;
boolean rollback = false;
Connection conn = db.getConnection();
System.out.println("isNeedTransaction:" + isNeedTransaction);
System.out.println("isAutoCommit:" + isAutoCommit);
System.out.println("isLocalOpen:" + isLocalOpen);
try {
if (isNeedTransaction) {
if (conn == null) {
isLocalOpen = true;
try {
conn = DbUtil.getConnection();
if (conn == null) throw new Exception("数据库连接获取错误");
conn.setAutoCommit(isAutoCommit);
}
catch (Exception e) {
throw e;
}
db.setConnection(conn);
}
}
result = method.invoke(this.target, args);
}
catch(Exception e) {
rollback = true;
e.printStackTrace();
throw e;
}
finally {
if (conn != null && isLocalOpen) {
if (!isAutoCommit) {
if (rollback) conn.rollback();
else conn.commit();
}
db.closeConnection();
}
}
System.out.println("method invoke complete:" + method.getName());
return result;
}
}
获取代理对象的工厂类:
package demo.dynamicproxy;
import java.lang.reflect.Proxy;
public class DefaultProxyFactory {
@SuppressWarnings("unchecked")
public static <T> T createProxy(T target) throws Exception {
if (!(target instanceof IDb)) throw new Exception("target must be instance of IDb");
ClassLoader classLoader = target.getClass().getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();
TransactionalInvocationHandler handler = new TransactionalInvocationHandler(target);
return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
}
}
import java.lang.reflect.Proxy;
public class DefaultProxyFactory {
@SuppressWarnings("unchecked")
public static <T> T createProxy(T target) throws Exception {
if (!(target instanceof IDb)) throw new Exception("target must be instance of IDb");
ClassLoader classLoader = target.getClass().getClassLoader();
Class<?>[] interfaces = target.getClass().getInterfaces();
TransactionalInvocationHandler handler = new TransactionalInvocationHandler(target);
return (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
}
}
至此,一个简单的框架就完成了。为了测试是否好用,做一个简单的例子,每个访问数据库的业务类都需要一个接口:
package demo.business;
import demo.dynamicproxy.annotation.Transactional;
public interface IDml {
void insert() throws Exception;
void update() throws Exception;
void delete() throws Exception;
void select() throws Exception;
@Transactional(autoCommit=false)
void execute() throws Exception;
}
import demo.dynamicproxy.annotation.Transactional;
public interface IDml {
void insert() throws Exception;
void update() throws Exception;
void delete() throws Exception;
void select() throws Exception;
@Transactional(autoCommit=false)
void execute() throws Exception;
}
业务类既需要实现业务接口,又需要实现IDb接口:
package demo.business;
import java.sql.ResultSet;
import java.sql.Statement;
import demo.dynamicproxy.DbImpl;
import demo.dynamicproxy.DefaultProxyFactory;
public class Dml extends DbImpl implements IDml {
@Override
public void delete() throws Exception{
executeNonQuery("delete from t where id=2");
System.out.println("delete 2");
}
@Override
public void execute() throws Exception{
System.out.println("begin");
insert();
update();
//if (true) throw new Exception("an error"); //此处测试异常
select();
delete();
}
@Override
public void insert() throws Exception{
executeNonQuery("insert into t(id) values(1)");
System.out.println("insert 1");
}
@Override
public void select() throws Exception{
Statement stmt = null;
ResultSet rs = null;
try {
stmt = getConnection().createStatement();
rs = stmt.executeQuery("select id from t");
while (rs.next()) {
System.out.println("select :" + rs.getString("ID"));
}
}
catch(Exception e) {
throw e;
}
finally {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
}
}
@Override
public void update() throws Exception{
executeNonQuery("update t set id=2 where id=1");
System.out.println("update 2");
}
public static void main(String[] args) {
try {
Dml dmlImpl = new Dml();
IDml dml= DefaultProxyFactory.createProxy(dmlImpl);
dml.execute();
Thread.sleep(20000); //延迟程序退出,可以查看数据库连接有没有释放
System.out.println("over");
}
catch(Exception e) {
e.printStackTrace();
}
}
}
import java.sql.ResultSet;
import java.sql.Statement;
import demo.dynamicproxy.DbImpl;
import demo.dynamicproxy.DefaultProxyFactory;
public class Dml extends DbImpl implements IDml {
@Override
public void delete() throws Exception{
executeNonQuery("delete from t where id=2");
System.out.println("delete 2");
}
@Override
public void execute() throws Exception{
System.out.println("begin");
insert();
update();
//if (true) throw new Exception("an error"); //此处测试异常
select();
delete();
}
@Override
public void insert() throws Exception{
executeNonQuery("insert into t(id) values(1)");
System.out.println("insert 1");
}
@Override
public void select() throws Exception{
Statement stmt = null;
ResultSet rs = null;
try {
stmt = getConnection().createStatement();
rs = stmt.executeQuery("select id from t");
while (rs.next()) {
System.out.println("select :" + rs.getString("ID"));
}
}
catch(Exception e) {
throw e;
}
finally {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
}
}
@Override
public void update() throws Exception{
executeNonQuery("update t set id=2 where id=1");
System.out.println("update 2");
}
public static void main(String[] args) {
try {
Dml dmlImpl = new Dml();
IDml dml= DefaultProxyFactory.createProxy(dmlImpl);
dml.execute();
Thread.sleep(20000); //延迟程序退出,可以查看数据库连接有没有释放
System.out.println("over");
}
catch(Exception e) {
e.printStackTrace();
}
}
}
main方法中是一个使用业务对象进行业务处理的例子。这样,程序就可以运行了,在测试时可以在mysql数据库中执行“show full processlist;”查看数据库连接情况。在使用时,主要注意在业务对象的接口方法中加上注解“@Transactional”,获取的业务对象需要从工厂中获得“IDml dml= DefaultProxyFactory.createProxy(dmlImpl);”。
这样一个简单的框架也许没有什么用,在实际项目应用时有现成的开源框架可以用,但可以学习框架实现的原理,对知识有更加深入的了解。
使用动态代理方法可以获得代码上的简洁,缺陷是牺牲了程序执行的效率,在对效率要求不太高的地方可以使用。
参考资料: