使用cglib和JAVA反射实现AOP操作数据库增删改查的简单功能

对mybatis理解的还不是特别深刻，只会简单的使用，实现这个功能跟平常使用spring+mybatis时的DAO操作有点类似，spring+mybatis具体内部实现还不清楚，后续要继续学习

代码：

1. 实体类：

 1 package com.mrlu.concurrency.domain;
 2 
 3 /**
 4  * Created by stefan on 15-12-19.
 5  */
 6 public class Goods {
 7     private Integer id;
 8     private Integer count;
 9 
10     public Integer getId() {
11         return id;
12     }
13 
14     public void setId(Integer id) {
15         this.id = id;
16     }
17 
18     public Integer getCount() {
19         return count;
20     }
21 
22     public void setCount(Integer count) {
23         this.count = count;
24     }
25 
26     @Override
27     public String toString() {
28         return "Goods{" +
29                 "id=" + id +
30                 ", count=" + count +
31                 '}';
32     }
33 }

2. DAO：

 1 package com.mrlu.concurrency.dao;
 2 
 3 import com.mrlu.concurrency.domain.Goods;
 4 import com.mrlu.concurrency.sqloperation.SQLSessionFactory;
 5 import java.util.List;
 6 
 7 /**
 8  * Created by stefan on 15-12-19.
 9  */
10 public class GoodsDao {
11     private SQLSessionFactory sqlSessionFactory;
12 
13     public void insert(Goods goods){
14         System.out.println("insert into table goods....");
15         String sql = "insert into goods(count) values(?)";
16         sqlSessionFactory.insert(sql, new Object[]{goods.getCount()});
17     }
18 
19     public void update(Goods goods){
20         System.out.println("update table goods....");
21         String sql = "UPDATE goods SET count =? WHERE id = ?";
22         sqlSessionFactory.update(sql, new Object[]{goods.getCount(), goods.getId()});
23     }
24 
25     public List<Goods> select(){
26         System.out.println("select table goods....");
27         String sql = "SELECT * FROM goods";
28         List<Goods> resultList = sqlSessionFactory.select(sql, new Object[]{}, Goods.class);
29         System.out.println("select count:  " + resultList.size());
30         return resultList;
31     }
32 
33     public SQLSessionFactory getSqlSessionFactory() {
34         return sqlSessionFactory;
35     }
36 
37     public void setSqlSessionFactory(SQLSessionFactory sqlSessionFactory) {
38         this.sqlSessionFactory = sqlSessionFactory;
39     }
40 }

 

3. 提供代理操作方法的类，并提供创建代理类对象：

  1 package com.mrlu.concurrency.daoProxy;
  2 
  3 import org.springframework.cglib.proxy.Enhancer;
  4 import org.springframework.cglib.proxy.MethodInterceptor;
  5 import org.springframework.cglib.proxy.MethodProxy;
  6 
  7 import java.lang.reflect.Field;
  8 import java.lang.reflect.Method;
  9 import java.sql.*;
 10 import java.util.LinkedList;
 11 import java.util.List;
 12 
 13 /**
 14  * Created by stefan on 15-12-21.
 15  */
 16 public class SQLSessionProxy implements MethodInterceptor{
 17     private Enhancer enhancer = new Enhancer();
 18     private static List<Connection> connectionPool = new LinkedList<>();
 19 
 20     public Object getProxy(Class clazz){
 21         enhancer.setSuperclass(clazz);
 22         enhancer.setCallback(this);
 23         return enhancer.create();
 24     }
 25 
 26     static{
 27         try {
 28             Class.forName("com.mysql.jdbc.Driver");
 29             String url = "jdbc:mysql://127.0.0.1:3306/concurrency";
 30             String userName = "root";
 31             String password = "123456a";
 32             for(int i=0; i<10; i++){
 33                 Connection connection = DriverManager.getConnection(url, userName, password);
 34                 connectionPool.add(connection);
 35             }
 36         }catch (Exception e){
 37             e.printStackTrace();
 38         }
 39 
 40     }
 41 
 42     public void init(Object o){ //注意操作的都是代理对象，不能使用this，this不代表代理对象
 43         System.out.println("init......."+ o);
 44         if(connectionPool.isEmpty()){
 45             return;
 46         }
 47         System.out.println("class: " + o);
 48         System.out.println("class: " + o.getClass().getSuperclass());
 49         Field[] fields = o.getClass().getSuperclass().getDeclaredFields();  //避免private，protected修饰的属性拿不到
 50         Connection connection = connectionPool.get(0);
 51         connectionPool.remove(0);
 52         for(Field field: fields){
 53             field.setAccessible(true); //此处设置任何属性都能拿到
 54             if(field.getName().equals("connection")){
 55                 try {
 56                     field.set(o, connection);
 57                 } catch (IllegalAccessException e) {
 58                     e.printStackTrace();
 59                 }
 60                 break;
 61             }
 62         }
 63     }
 64 
 65     public void destory(Object o){
 66         System.out.println("destory......." + o);
 67         Field[] fields = o.getClass().getSuperclass().getDeclaredFields();
 68         try {
 69             for(Field field: fields){
 70                 field.setAccessible(true);
 71                 if(field.getName().equals("connection")){
 72                     Connection connection = (Connection) field.get(o);
 73                     if(connection != null){
 74                         connectionPool.add(connection);
 75                     }
 76                 }else if(field.getName().equals("preparedStatement")){
 77                     PreparedStatement preparedStatement = (PreparedStatement) field.get(o);
 78                     if(preparedStatement != null) {
 79                         preparedStatement.close();
 80                     }
 81                 }else if(field.getName().equals("resultSet")){
 82                     ResultSet resultSet = (ResultSet) field.get(o);
 83                     if(resultSet != null) {
 84                         resultSet.close();
 85                     }
 86                 }
 87             }
 88         } catch (Exception e) {
 89             e.printStackTrace();
 90         }
 91     }
 92 
 93     @Override
 94     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
 95         if(method.getName().equals("insert") || method.getName().equals("update") || method.getName().equals("select")) {  //注意此处的校验是特别有必要的，为了避免陷入无限递归循环中，因为不论调用代理对象的哪个方法都会交给代理方法来处理　　　　　　
 96             Object result = null;
　　　　　　　　　 init(o);
 97             if (method.getName().equals("select")) {
 98                 result = methodProxy.invokeSuper(o, objects); //select需返回查询结果
 99             }
100             methodProxy.invokeSuper(o, objects);
101             destory(o); //此处很重要，需要回收链接
　　　　　　　　   return result;
102         }
103         return null;
104     }
105 }

 

 4. 封装的SQLSessionFactory

  1 package com.mrlu.concurrency.sqloperation;
  2 
  3 import java.lang.reflect.Field;
  4 import java.sql.*;
  5 import java.util.HashMap;
  6 import java.util.LinkedList;
  7 import java.util.List;
  8 import java.util.Map;
  9 
 10 /**
 11  * Created by stefan on 15-12-21.
　　　* 内部处理异常，无须抛到DAO去，DAO也不关心数据库操作异常
 12  */
 13 public class SQLSessionFactory{
 14     private Connection connection = null;
 15     private PreparedStatement preparedStatement = null;
 16     private ResultSet resultSet = null;
 17 
 18     public void insert(String sql, Object[] args){
 19         System.out.println("[SQLSessionFactory] insert into table goods....");
 20         try {
 21             preparedStatement = connection.prepareStatement(sql);
 22             for(int i=0; i < args.length;){
 23                 Object object = args[i];
 24                 preparedStatement.setObject(++i, object);
 25             }
 26             int updateCount = preparedStatement.executeUpdate();
 27             System.out.println("[SQLSessionFactory] updateCount:  " + updateCount);
 28         }catch (SQLException e){
 29             e.printStackTrace();
 30         }
 31     }
 32 
 33     public void update(String sql, Object[] args){
 34         try {
 35             System.out.println("[SQLSessionFactory] update table goods....");
 36             preparedStatement = connection.prepareStatement(sql);
 37             for(int i=0; i < args.length;){
 38                 Object object = args[i];
 39                 preparedStatement.setObject(++i, object);
 40             }
 41             int updateCount = preparedStatement.executeUpdate();
 42             System.out.println("[SQLSessionFactory] updateCount:  " + updateCount);
 43         }catch (SQLException e){
 44             e.printStackTrace();
 45         }
 46     }
 47 
 48     public <T> List<T> select(String sql, Object[] args, Class returnType){
 49         List<T> list = null;
 50         try {
 51             System.out.println("[SQLSessionFactory] select table goods....");
 52             preparedStatement = connection.prepareStatement(sql);
 53             for (int i = 0; i < args.length; ) {
 54                 Object object = args[i];
 55                 preparedStatement.setObject(++i, object);
 56             }
 57             resultSet = preparedStatement.executeQuery();
 58 
 59             List<Map<String, Object>> result = new LinkedList<>();
 60             ResultSetMetaData metaData = resultSet.getMetaData();
 61             int columnCount = metaData.getColumnCount();
 62             while (resultSet.next()) {
 63                 Map<String, Object> maps = new HashMap<>();
 64                 for (int i = 0; i < columnCount; ) {
 65                     maps.put(metaData.getColumnName(++i), resultSet.getObject(i));
 66                 }
 67                 result.add(maps);
 68             }
 69             System.out.println("[SQLSessionFactory] select:  " + result.size());
 70             list = transferResultToObject(result, returnType);
 71         }catch (SQLException e){
 72             e.printStackTrace();
 73         }
 74         return list;
 75     }
 76 
 77     private <T> List<T> transferResultToObject(List<Map<String, Object>> result, Class returnType) { //此处用到了泛型(方法返回值泛型)和反射， 泛型需要注意类型擦除
 78         Field[] fields = returnType.getDeclaredFields();
 79         List resultObject = new LinkedList<>();
 80         try {
 81             for (Map<String, Object> map: result) {
 82                 Object eachResult = returnType.newInstance();
 83                 for (Field field : fields) {
 84                     field.setAccessible(true);
 85                     Object object = map.get(field.getName());
 86                     field.set(eachResult, object);
 87                 }
 88                 resultObject.add(eachResult);
 89             }
 90         }catch (Exception e){
 91             e.printStackTrace();
 92         }
 93         return resultObject;
 94     }
 95 
 96     public Connection getConnection() {
 97         return connection;
 98     }
 99 
100     public void setConnection(Connection connection) {
101         this.connection = connection;
102     }
103 
104     public PreparedStatement getPreparedStatement() {
105         return preparedStatement;
106     }
107 
108     public void setPreparedStatement(PreparedStatement preparedStatement) {
109         this.preparedStatement = preparedStatement;
110     }
111 
112     public ResultSet getResultSet() {
113         return resultSet;
114     }
115 
116     public void setResultSet(ResultSet resultSet) {
117         this.resultSet = resultSet;
118     }
119 }

 

5. 测试：

 1 package com.mrlu.concurrency;
 2 
 3 import com.mrlu.concurrency.dao.GoodsDao;
 4 import com.mrlu.concurrency.daoProxy.DaoProxy;
 5 import com.mrlu.concurrency.daoProxy.SQLSessionProxy;
 6 import com.mrlu.concurrency.domain.Goods;
 7 import com.mrlu.concurrency.sqloperation.SQLSessionFactory;
 8 
 9 import java.util.List;
10 
11 /**
12  * Created by stefan on 15-12-17.
13  */
14 public class Main {
15     public static void main(String[] args){
16         SQLSessionProxy proxy = new SQLSessionProxy();
17         SQLSessionFactory sqlSessionFactory = (SQLSessionFactory) proxy.getProxy(SQLSessionFactory.class); //创建SQLSessionFactory,注意若在多线程中使用sqlSessionFactory，则需为每个线程创建一个sqlSessionFactory对象，因为sqlSessionFactory是有状态的(和PrepareStatement，Connection，ResultSet有关联)，无法保证线程之间互不影响(一个线程关闭了PrepareStatement，另一个在用的时候就会出错，或其中一个线程通过反射修改了connection对象的引用，导致原来的connection对象永远不能关闭，内存泄露)，这就说明了为什么单例对象都是无状态的
18 
19         GoodsDao goodsDao = new GoodsDao();
20         goodsDao.setSqlSessionFactory(sqlSessionFactory);  //注入依赖
21 
22         Goods goods = new Goods();
23         goods.setCount(30);
24         goodsDao.insert(goods); //执行数据库操作
25 
26         List<Goods> list = goodsDao.select(); //拿到返回值结果,完全利用泛型的在必要的时候类型转换的特性
27         for (Goods goods1: list){
28             System.out.println(goods1);
29         }
30         System.out.println(list);
31     }
32 }

 

转载于:https://www.cnblogs.com/stefanking/articles/5064846.html