自定义@Service、@Autowired、@Transactional注解类，完成基于注解的IOC容器（Bean对象创建及依赖注入维护）和声明式事务控制

自定义注解

1. 自定义@Service注解

  1. package com.learn.transfer.annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. /**
  9.  * 标注Service
  10.  * @author lijun
  11.  */
  12. @Retention(RetentionPolicy.RUNTIME)
  13. @Target(ElementType.TYPE)
  14. public @interface MyService {
  15.     public String value() default "";
  16. }

2. 自定义Autowired

  1. package com.learn.transfer.annotation;
  3. import java.lang.annotation.*;
  5. /**
  6.  * 自动注入
  7.  * @author lijun
  8.  */
  9. @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. public @interface MyAutowired {
  15.     boolean value() default true;
  16. }

3. 自定义Transactional

  1. package com.learn.transfer.annotation;
  3. import java.lang.annotation.*;
  5. /**
  6.  * @author SCKJ-003
  7.  */
  8. @Target({ElementType.TYPE})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. @Documented
  11. public @interface MyTransactional {
  12.     String value() default "TransactionManager";
  13. }

controller层、service层、dao层 代码

controller层

  1. package com.learn.transfer.servlet;
  4. import com.learn.transfer.annotation.MyAutowired;
  5. import com.learn.transfer.entity.Result;
  6. import com.learn.transfer.factory.BeanFactory;
  7. import com.learn.transfer.service.TransferService;
  8. import com.learn.transfer.utils.JsonUtils;
  9. import org.springframework.context.support.ClassPathXmlApplicationContext;
  11. import javax.servlet.ServletException;
  12. import javax.servlet.annotation.WebServlet;
  13. import javax.servlet.http.HttpServlet;
  14. import javax.servlet.http.HttpServletRequest;
  15. import javax.servlet.http.HttpServletResponse;
  16. import java.io.IOException;
  18. /**
  19.  * @author lijun
  20.  */
  21. @WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
  22. public class TransferServlet extends HttpServlet {
  24.     private TransferService transferService = (TransferService) BeanFactory.getBean("transferService") ;
  26.     @Override
  27.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  28.         doPost(req,resp);
  29.     }
  31.     @Override
  32.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  34.         // 设置请求体的字符编码
  35.         req.setCharacterEncoding("UTF-8");
  37.         String fromCardNo = req.getParameter("fromCardNo");
  38.         String toCardNo = req.getParameter("toCardNo");
  39.         String moneyStr = req.getParameter("money");
  40.         int money = Integer.parseInt(moneyStr);
  42.         Result result = new Result();
  44.         try {
  46.             // 2. 调用service层方法
  47.             transferService.transfer(fromCardNo,toCardNo,money);
  48.             result.setStatus("200");
  49.         } catch (Exception e) {
  50.             e.printStackTrace();
  51.             result.setStatus("201");
  52.             result.setMessage(e.toString());
  53.         }
  55.         // 响应
  56.         resp.setContentType("application/json;charset=utf-8");
  57.         resp.getWriter().print(JsonUtils.object2Json(result));
  58.     }
  59. }

service接口层和实现层

  1. package com.learn.transfer.service;
  3. /**
  4.  * @author 应癫
  5.  */
  6. public interface TransferService {
  8.     void transfer(String fromCardNo,String toCardNo,int money) throws Exception;
  9. }
  1. package com.learn.transfer.service.impl;
  4. import com.learn.transfer.annotation.MyAutowired;
  5. import com.learn.transfer.annotation.MyService;
  6. import com.learn.transfer.annotation.MyTransactional;
  7. import com.learn.transfer.dao.AccountDao;
  8. import com.learn.transfer.entity.Account;
  9. import com.learn.transfer.service.TransferService;
  11. /**
  12.  * @author lijun
  13.  */
  14. @MyService("transferService")
  15. @MyTransactional
  16. public class TransferServiceImpl implements TransferService {
  18.     /**
  19.      * 最佳状态
  20.      *
  21.      * @Description: 最佳状态
  22.      * @Param:
  23.      * @Return:
  24.      * @Author: lijun
  25.      * @Date: 2020/9/11
  26.      **/
  27.     @MyAutowired
  28.     private AccountDao accountDao;
  30.     public void setAccountDao(AccountDao accountDao) {
  31.         this.accountDao = accountDao;
  32.     }
  35.     @Override
  36.     public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {
  38.         try{
  39.             Account from = accountDao.queryAccountByCardNo(fromCardNo);
  40.             Account to = accountDao.queryAccountByCardNo(toCardNo);
  42.             from.setMoney(from.getMoney()-money);
  43.             to.setMoney(to.getMoney()+money);
  44.             accountDao.updateAccountByCardNo(to);
  46.             //测试事务回滚
  47.             int c = 1/0;
  48.             accountDao.updateAccountByCardNo(from);
  50.         }catch (Exception e) {
  51.             e.printStackTrace();
  52.             // 抛出异常便于上层servlet捕获
  53.             throw e;
  54.         }
  56.     }
  57. }

dao接口层和实现层

  1. package com.learn.transfer.dao;
  4. import com.learn.transfer.entity.Account;
  6. /**
  7.  * @author lijun
  8.  */
  9. public interface AccountDao {
  11.     Account queryAccountByCardNo(String cardNo) throws Exception;
  13.     int updateAccountByCardNo(Account account) throws Exception;
  15.     void text();
  16. }
  1. package com.learn.transfer.dao.impl;
  4. import com.learn.transfer.annotation.MyAutowired;
  5. import com.learn.transfer.annotation.MyService;
  6. import com.learn.transfer.dao.AccountDao;
  7. import com.learn.transfer.entity.Account;
  8. import com.learn.transfer.utils.ConnectionUtils;
  9. import org.springframework.stereotype.Service;
  11. import java.sql.Connection;
  12. import java.sql.PreparedStatement;
  13. import java.sql.ResultSet;
  15. /**
  16.  * @author lijun
  17.  */
  18. @MyService("AccountDao")
  19. public class AccountDaoImpl implements AccountDao {
  21.     @MyAutowired
  22.     private ConnectionUtils connectionUtils;
  24.     public void setConnectionUtils(ConnectionUtils connectionUtils) {
  25.         this.connectionUtils = connectionUtils;
  26.     }
  28.     @Override
  29.     public Account queryAccountByCardNo(String cardNo) throws Exception {
  30.         //从连接池获取连接
  31.         // Connection con = DruidUtils.getInstance().getConnection();
  32.         Connection con = connectionUtils.getCurrentThreadConn();
  33.         String sql = "select * from t_account where cardNo=?";
  34.         PreparedStatement preparedStatement = con.prepareStatement(sql);
  35.         preparedStatement.setString(1,cardNo);
  36.         ResultSet resultSet = preparedStatement.executeQuery();
  38.         Account account = new Account();
  39.         while(resultSet.next()) {
  40.             account.setCardNo(resultSet.getString("cardNo"));
  41.             account.setName(resultSet.getString("name"));
  42.             account.setMoney(resultSet.getInt("money"));
  43.         }
  45.         resultSet.close();
  46.         preparedStatement.close();
  47.         //con.close();
  49.         return account;
  50.     }
  52.     @Override
  53.     public int updateAccountByCardNo(Account account) throws Exception {
  55.         // 从连接池获取连接
  56.         // 改造为：从当前线程当中获取绑定的connection连接
  57.         //Connection con = DruidUtils.getInstance().getConnection();
  58.         Connection con = connectionUtils.getCurrentThreadConn();
  59.         String sql = "update t_account set money=? where cardNo=?";
  60.         PreparedStatement preparedStatement = con.prepareStatement(sql);
  61.         preparedStatement.setInt(1,account.getMoney());
  62.         preparedStatement.setString(2,account.getCardNo());
  63.         int i = preparedStatement.executeUpdate();
  65.         preparedStatement.close();
  66.         //con.close();
  67.         return i;
  68.     }
  70.     @Override
  71.     public void text() {
  72.         System.out.println(123);
  73.     }
  74. }

开发中用到的数据库Utils、动态代理Utils等其他相关类

  1. package com.learn.transfer.utils;
  3. import com.learn.transfer.annotation.MyService;
  5. import java.sql.Connection;
  6. import java.sql.SQLException;
  8. /**
  9.  * @author lijun
  10.  */
  11. @MyService
  12. public class ConnectionUtils {
  15.     /**
  16.      * 存储当前线程的连接
  17.      *
  18.      * @Description: TODO
  19.      * @Param:
  20.      * @Return:
  21.      * @Author: lijun
  22.      * @Date: 2020/9/11
  23.      **/
  24.     private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
  26.     /**
  27.      * 从当前线程获取连接
  28.      */
  29.     public Connection getCurrentThreadConn() throws SQLException {
  30.         /**
  31.          * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
  32.           */
  33.         Connection connection = threadLocal.get();
  34.         if(connection == null) {
  35.             // 从连接池拿连接并绑定到线程
  36.             connection = DruidUtils.getInstance().getConnection();
  37.             // 绑定到当前线程
  38.             threadLocal.set(connection);
  39.         }
  40.         return connection;
  42.     }
  43. }
  47. package com.learn.transfer.utils;
  49. import com.alibaba.druid.pool.DruidDataSource;
  51. /**
  52.  * @author lijun
  53.  */
  54. public class DruidUtils {
  56.     private DruidUtils(){
  57.     }
  59.     private static DruidDataSource druidDataSource = new DruidDataSource();
  62.     static {
  63.         druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
  64.         druidDataSource.setDbType("com.alibaba.druid.pool.DruidDataSource");
  65.         druidDataSource.setUrl("jdbc:mysql://xxx.xxx.xxx.xxx:3306/xxxx?useUnicode=true&characterEncoding=utf8&useSSL=true");
  66.         druidDataSource.setUsername("root");
  67.         druidDataSource.setPassword("root");
  68.     }
  70.     public static DruidDataSource getInstance() {
  71.         return druidDataSource;
  72.     }
  74. }
  77. package com.learn.transfer.utils;
  79. import java.util.List;
  81. import com.fasterxml.jackson.core.JsonProcessingException;
  82. import com.fasterxml.jackson.databind.JavaType;
  83. import com.fasterxml.jackson.databind.ObjectMapper;
  85. /**
  86.  * JSON工具类（使用的是jackson实现的）
  87.  * @author lijun
  88.  */
  89. public class JsonUtils {
  91.     private static final ObjectMapper MAPPER = new ObjectMapper();
  93.     /**
  94.      * 将对象转换成json字符串。
  95.      * @param data
  96.      * @return
  97.      */
  98.     public static String object2Json(Object data) {
  99.         try {
  100.             String string = MAPPER.writeValueAsString(data);
  101.             return string;
  102.         } catch (JsonProcessingException e) {
  103.             e.printStackTrace();
  104.         }
  105.         return null;
  106.     }
  108.     /**
  109.      * 将json结果集转化为对象
  110.      * 
  111.      * @param jsonData json数据
  112.      * @param beanType 对象中的object类型
  113.      * @return
  114.      */
  115.     public static <T> T json2Pojo(String jsonData, Class<T> beanType) {
  116.         try {
  117.             T t = MAPPER.readValue(jsonData, beanType);
  118.             return t;
  119.         } catch (Exception e) {
  120.             e.printStackTrace();
  121.         }
  122.         return null;
  123.     }
  125.     /**
  126.      * 将json数据转换成pojo对象list
  127.      * @param jsonData
  128.      * @param beanType
  129.      * @return
  130.      */
  131.     public static <T>List<T> json2List(String jsonData, Class<T> beanType) {
  132.         JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
  133.         try {
  134.             List<T> list = MAPPER.readValue(jsonData, javaType);
  135.             return list;
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.         }
  140.         return null;
  141.     }
  143. }
  145. package com.learn.transfer.utils;
  147. import com.learn.transfer.annotation.MyAutowired;
  148. import com.learn.transfer.annotation.MyService;
  150. import java.sql.SQLException;
  152. /**
  153.  * @author lijun
  154.  *
  155.  * 事务管理器类：负责手动事务的开启、提交、回滚
  156.  */
  157. @MyService
  158. public class TransactionManager {
  160.     @MyAutowired
  161.     private ConnectionUtils connectionUtils;
  163.     public void setConnectionUtils(ConnectionUtils connectionUtils) {
  164.         this.connectionUtils = connectionUtils;
  165.     }
  167.     /*private TransactionManager(){
  169.     }
  171.     private static TransactionManager transactionManager = new TransactionManager();
  173.     public static TransactionManager getInstance() {
  174.         return  transactionManager;
  175.     }*/
  179.     /**
  180.      * 开启手动事务控制
  181.      *
  182.      * @Description: TODO
  183.      * @Param: []
  184.      * @Return: void
  185.      * @Author: lijun
  186.      * @Date: 2020/9/21
  187.      **/
  188.     public void beginTransaction() throws SQLException {
  189.         connectionUtils.getCurrentThreadConn().setAutoCommit(false);
  190.     }
  193.     // 提交事务
  194.     public void commit() throws SQLException {
  195.         connectionUtils.getCurrentThreadConn().commit();
  196.     }
  199.     // 回滚事务
  200.     public void rollback() throws SQLException {
  201.         connectionUtils.getCurrentThreadConn().rollback();
  202.     }
  203. }

实体类

  1. package com.learn.transfer.entity;
  3. /**
  4.  * Account  实体类
  5.  * @author lijun
  6.  */
  7. public class Account {
  9.     private String cardNo;
  10.     private String name;
  11.     private int money;
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public int getMoney() {
  22.         return money;
  23.     }
  25.     public void setMoney(int money) {
  26.         this.money = money;
  27.     }
  29.     public String getCardNo() { return cardNo; }
  31.     public void setCardNo(String cardNo) { this.cardNo = cardNo;}
  32. }
  35. package com.learn.transfer.entity;
  37. /**
  38.  * Result 实体类
  39.  * @author lijun
  40.  */
  41. public class Result{
  43.     private String status;
  44.     private String message;
  46.     public String getStatus() {
  47.         return status;
  48.     }
  50.     public void setStatus(String status) {
  51.         this.status = status;
  52.     }
  54.     public String getMessage() {
  55.         return message;
  56.     }
  58.     public void setMessage(String message) {
  59.         this.message = message;
  60.     }
  62. }

注解解析类BeanFactory

  1. package com.learn.transfer.factory;
  3. import com.alibaba.druid.util.StringUtils;
  4. import com.learn.transfer.annotation.MyAutowired;
  5. import com.learn.transfer.annotation.MyService;
  6. import com.learn.transfer.annotation.MyTransactional;
  7. import org.reflections.Reflections;
  9. import java.lang.reflect.Field;
  10. import java.lang.reflect.InvocationTargetException;
  11. import java.lang.reflect.Method;
  12. import java.util.HashMap;
  13. import java.util.Map;
  14. import java.util.Set;
  16. /**
  17.  * @ClassName BeanFactory
  18.  * @Description TODO
  19.  * @Author lijun
  20.  * @Date 2020/9/29 10:21
  21.  */
  22. public class BeanFactory {
  24.     // 存储对象
  25.     private static Map<String,Object> map = new HashMap<>();
  27.     static{
  28.         try{
  29.             //扫描包，分析需实例化的对象列表（service和事务管理器）,通过反射技术实例化对象并且存储待用（map集合）
  30.             //扫描获取反射对象集合
  31.             Reflections f = new Reflections("com.learn.transfer");
  32.             //获取注解为service的集合
  33.             Set<Class<?>> set = f.getTypesAnnotatedWith(MyService.class);
  34.             for (Class<?> c : set) {
  35.                 // 通过反射技术实例化对象
  36.                 Object bean = c.newInstance();
  37.                 MyService annotation = c.getAnnotation(MyService.class);
  39.                 //对象ID在service注解有value时用value，没有时用类名
  40.                 if(StringUtils.isEmpty(annotation.value())){
  41.                     //由于getName获取的是全限定类名，所以要分割去掉前面包名部分
  42.                     String[] names = c.getName().split("\\.");
  43.                     map.put(names[names.length-1], bean);
  44.                 }else{
  45.                     map.put(annotation.value(), bean);
  46.                 }
  47.             }
  48.             // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
  49.             for(Map.Entry<String, Object> a:map.entrySet()){
  50.                 Object o = a.getValue();
  51.                 Class c = o.getClass();
  52.                 //获取属性集合
  53.                 Field[] fields = c.getDeclaredFields();
  54.                 //遍历属性，若持有Autowired注解则注入
  55.                 for (Field field : fields) {
  56.                     if (field.isAnnotationPresent(MyAutowired.class)
  57.                             &&field.getAnnotation(MyAutowired.class).value()) {
  58.                         String[] names = field.getType().getName().split("\\.");
  59.                         String name = names[names.length-1];
  60.                         Method[] methods = c.getMethods();
  61.                         for (int j = 0; j < methods.length; j++) {
  62.                             Method method = methods[j];
  63.                             // 该方法就是 setAccountDao(AccountDao accountDao)
  64.                             if(method.getName().equalsIgnoreCase("set" + name)) {
  65.                                 method.invoke(o,map.get(name));
  66.                             }
  67.                         }
  68.                     }
  69.                 }
  70.                 //判断对象类是否持有Transactional注解，若有则修改对象为代理对象
  71.                 if(c.isAnnotationPresent(MyTransactional.class)){
  72.                     //获取代理工厂
  73.                     ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
  74.                     //判断对象是否实现接口
  75.                     //获取类c实现的所有接口
  76.                     Class[] face = c.getInterfaces();
  77.                     if(face!=null&&face.length>0){
  78.                         //实现使用JDK
  79.                         o = proxyFactory.getJdkProxy(o);
  80.                     }else{
  81.                         //没实现使用CGLIB
  82.                         o = proxyFactory.getCglibProxy(o);
  83.                     }
  84.                 }
  85.                 // 把处理之后的object重新放到map中
  86.                 map.put(a.getKey(),o);
  87.             }
  88.         } catch (IllegalAccessException e) {
  89.             e.printStackTrace();
  90.         } catch (InstantiationException e) {
  91.             e.printStackTrace();
  92.         } catch (InvocationTargetException e) {
  93.             e.printStackTrace();
  94.         }
  95.     }
  97.     /**
  98.      * 对外提供获取实例对象的接口（根据id获取）
  99.      *
  100.      * @Description: TODO
  101.      * @Param: [id]
  102.      * @Return: java.lang.Object
  103.      * @Author: lijun
  104.      * @Date: 2020/9/29
  105.      **/
  106.     public static  Object getBean(String id) {
  107.         return map.get(id);
  108.     }
  109. }

代理工厂

  1. package com.learn.transfer.factory;
  3. import com.learn.transfer.annotation.MyAutowired;
  4. import com.learn.transfer.annotation.MyService;
  5. import com.learn.transfer.utils.TransactionManager;
  6. import net.sf.cglib.proxy.Enhancer;
  7. import net.sf.cglib.proxy.MethodInterceptor;
  8. import net.sf.cglib.proxy.MethodProxy;
  10. import java.lang.reflect.InvocationHandler;
  11. import java.lang.reflect.Method;
  12. import java.lang.reflect.Proxy;
  14. /**
  15.  * @ClassName ProxyFactory
  16.  * @Description TODO
  17.  * @Author lijun
  18.  * @Date 2020/9/29 10:21
  19.  */
  20. @MyService("proxyFactory")
  21. public class ProxyFactory {
  23.     @MyAutowired
  24.     private TransactionManager transactionManager;
  26.     public void setTransactionManager(TransactionManager transactionManager) {
  27.         this.transactionManager = transactionManager;
  28.     }
  30.     /**
  31.      * Jdk动态代理
  32.      *
  33.      * @Description: TODO
  34.      * @Param: [obj]
  35.      * @Return: java.lang.Object
  36.      * @Author: lijun
  37.      * @Date: 2020/9/29
  38.      **/
  39.     public Object getJdkProxy(Object obj) {
  40.         // 获取代理对象
  41.         return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(),
  42.             new InvocationHandler() {
  43.                 @Override
  44.                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  45.                     Object result = null;
  46.                     try{
  47.                         // 开启事务(关闭事务的自动提交)
  48.                         transactionManager.beginTransaction();
  49.                         result = method.invoke(obj,args);
  50.                         // 提交事务
  51.                         transactionManager.commit();
  52.                     }catch (Exception e) {
  53.                         e.printStackTrace();
  54.                         // 回滚事务
  55.                         transactionManager.rollback();
  56.                         // 抛出异常便于上层servlet捕获
  57.                         throw e;
  58.                     }
  59.                     return result;
  60.                 }
  61.         });
  62.     }
  64.     /**
  65.      * 使用cglib动态代理生成代理对象
  66.      *
  67.      * @Description: TODO
  68.      * @Param: [obj] 委托对象
  69.      * @Return: java.lang.Object
  70.      * @Author: lijun
  71.      * @Date: 2020/9/29
  72.      **/
  73.     public Object getCglibProxy(Object obj) {
  74.         return  Enhancer.create(obj.getClass(), new MethodInterceptor() {
  75.             @Override
  76.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  77.                 Object result = null;
  78.                 try{
  79.                     // 开启事务(关闭事务的自动提交)
  80.                     transactionManager.beginTransaction();
  81.                     result = method.invoke(obj,objects);
  82.                     // 提交事务
  83.                     transactionManager.commit();
  84.                 }catch (Exception e) {
  85.                     e.printStackTrace();
  86.                     // 回滚事务
  87.                     transactionManager.rollback();
  88.                     // 抛出异常便于上层servlet捕获
  89.                     throw e;
  90.                 }
  91.                 return result;
  92.             }
  93.         });
  94.     }
  95. }

时序图

自定义@Service、@Autowired、@Transactional注解类，完成基于注解的IOC容器（Bean对象创建及依赖注入维护）和声明式事务控制 - 图2