1. 转账案例问题分析

转账案例问题分析.png

2. new关键字耦合分析

new关键字耦合问题分析.png

3. 手写IOC/DI

3.1 编写xml文件

  1. xml文件主要是用来把需要用的类配置成一个个bean，bean的属性有id：唯一标识；有class：类的全限定类名，用来通过反射获取类的实例。property的属性：name是用来匹配TransferServiceImpl这个类中需要注入值的方法，也就是setAccountDao()方法，ref：注入的值，通过这个id获取到JdbcAccountDaoImpl类来注入
  2. 代码如下 ```xml <?xml version=”1.0” encoding=”UTF-8” ?> 

  1. <a name="twtJ6"></a>
  2. ## 3.2 编写BeanFactory
  4. 1. 通过dom4j和xpath来解析xml文件，获取每一个bean，然后再解析bean里的属性，获取id作为唯一标识，获取class的值来通过反射得到类的实例，然后id为key，类实例为value存入到Map中，该Map其实就是相当于IOC容器(准确来说是IOC容器里的单例池)。
  5. 2. 获取到每一个property标签，解析出name和ref，再通过父标签从map中获取到类实例，"set" + name就是类实例中需要注入值的方法，注入的值从map中获取，key就是ref的值。这就是依赖注入。
  6. 3. 在TransferServiceImpl类中注入JdbcAccountDaoImpl，只需要写一个setAccountDao(JdbcAccountDaoImpl accountDao)方法，BeanFactory就会解析到这个方法，然后通过动态代理把配置的ref标识对应的类注入进去。
  7. 4. 代码如下：
  8. ```java
  9. import org.dom4j.Document;
  10. import org.dom4j.DocumentException;
  11. import org.dom4j.Element;
  12. import org.dom4j.io.SAXReader;
  13. import java.io.InputStream;
  14. import java.lang.reflect.InvocationTargetException;
  15. import java.lang.reflect.Method;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;
  20. public class BeanFactory {
  22.   /**
  23.     * ⼯⼚类的两个任务
  24.     * 任务⼀：加载解析xml，读取xml中的bean信息，通过反射技术实例化bean对象，然后放⼊
  25.     * map待⽤
  26.     * 任务⼆：提供接⼝⽅法根据id从map中获取bean（静态⽅法）
  27.     */
  28.   private static Map<String,Object> map = new HashMap<>();
  30.   static {
  31.     InputStream resourceAsStream =
  32.       BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
  33.     SAXReader saxReader = new SAXReader();
  34.     try {
  35.       Document document = saxReader.read(resourceAsStream);
  36.       Element rootElement = document.getRootElement();
  37.       List<Element> list = rootElement.selectNodes("//bean");
  38.       // 实例化bean对象
  39.       for (int i = 0; i < list.size(); i++) {
  40.         Element element = list.get(i);
  41.         String id = element.attributeValue("id");
  42.         String clazz = element.attributeValue("class");
  43.         Class<?> aClass = Class.forName(clazz);
  44.         Object o = aClass.newInstance();
  45.         map.put(id,o);
  46.       }
  47.       // 维护bean之间的依赖关系
  48.       List<Element> propertyNodes = rootElement.selectNodes("//property");
  49.       for (int i = 0; i < propertyNodes.size(); i++) {
  50.         Element element = propertyNodes.get(i);
  51.         // 处理property元素
  52.         String name = element.attributeValue("name");
  53.         String ref = element.attributeValue("ref");
  54.         String parentId = element.getParent().attributeValue("id");
  55.         Object parentObject = map.get(parentId);
  56.         Method[] methods = parentObject.getClass().getMethods();
  57.         for (int j = 0; j < methods.length; j++) {
  58.           Method method = methods[j];
  59.           if(("set" + name).equalsIgnoreCase(method.getName())) {
  60.             // bean之间的依赖关系（注⼊bean）
  61.             Object propertyObject = map.get(ref);
  62.             method.invoke(parentObject,propertyObject);
  63.           }
  64.         }
  65.         // 维护依赖关系后重新将bean放⼊map中
  66.         map.put(parentId,parentObject);
  67.       }
  68.     } catch (DocumentException e) {
  69.       e.printStackTrace();
  70.     } catch (ClassNotFoundException e) {
  71.       e.printStackTrace();
  72.     } catch (IllegalAccessException e) {
  73.       e.printStackTrace();
  74.     } catch (InstantiationException e) {
  75.       e.printStackTrace();
  76.     } catch (InvocationTargetException e) {
  77.       e.printStackTrace();
  78.     }
  79.   }
  81.   public static Object getBean(String id) {
  82.     return map.get(id);
  83.   }
  85. }

4. 事务控制(AOP)

4.1 service层事务问题分析

service层添加事务控制思路分析.png

4.2 解决

  1. 让同个线程的jdbc操作都绑定到同一个connection连接，就可以控制属于同一个事务了，编写ConnectionUtil类，代码如下 ```java import java.sql.Connection; import java.sql.SQLException;

public class ConnectionUtils { //单例模式（懒汉） private volatile static ConnectionUtils INSTANCE;

  1. private ConnectionUtils() {};
  3. public static ConnectionUtils getInstance() {
  4.     if (INSTANCE == null) {
  5.         synchronized (ConnectionUtils.class) {
  6.             if (INSTANCE == null) {
  7.                 INSTANCE = new ConnectionUtils();
  8.             }
  9.         }
  10.     }
  11.     return INSTANCE;
  12. }
  15. // 存储当前线程的连接
  16. private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); 
  18. /**
  19. * 从当前线程获取连接
  20. */
  21. public Connection getCurrentThreadConn() throws SQLException {
  22.     /**
  23.     * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取⼀个连接绑定到
  24.     * 当前线程
  25.     */
  26.     Connection connection = threadLocal.get();
  27.     if(connection == null) {
  28.         // 从连接池拿连接并绑定到线程
  29.         connection = DruidUtils.getInstance().getConnection();
  30.         // 绑定到当前线程
  31.         threadLocal.set(connection);
  32.     }
  33.     return connection;
  34. }

}

  2. 2. 把事务控制在service层，首先在service方法中获取到数据库连接将事务自动提交关闭，等全部执行完成手动提交，如果出现异常则进行事务回滚。
  3. <a name="FiBJk"></a>
  4. ## 4.3 优化
  5. ![使用代理对象进行事务控制.png](https://cdn.nlark.com/yuque/0/2022/png/13010374/1648027364107-2c78606e-b5f4-435f-8027-8b586795425e.png#clientId=u8a3adf87-92b8-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=uf1355267&margin=%5Bobject%20Object%5D&name=%E4%BD%BF%E7%94%A8%E4%BB%A3%E7%90%86%E5%AF%B9%E8%B1%A1%E8%BF%9B%E8%A1%8C%E4%BA%8B%E5%8A%A1%E6%8E%A7%E5%88%B6.png&originHeight=955&originWidth=1694&originalType=binary&ratio=1&rotation=0&showTitle=false&size=172494&status=done&style=none&taskId=u25642cf4-22ad-44e3-b2f2-a596a763caf&title=)
  7. 1. 上一步中事务控制在service层的关闭事务自动提交、手动提交、事务回滚等逻辑在每一个需要控制事务的方法中都要执行，这段代码其实就可以横切出来，可以通过动态代理来实现。
  8. 2. 增加事务管理类TransactionManager
  9. ```java
  10. import java.sql.SQLException;
  12. public class TransactionManager {
  14.     private ConnectionUtils connectionUtils;
  15.     public void setConnectionUtils(ConnectionUtils connectionUtils) {
  16.         this.connectionUtils = connectionUtils;
  17.     }
  19.     // 开启事务
  20.     public void beginTransaction() throws SQLException {
  21.         connectionUtils.getCurrentThreadConn().setAutoCommit(false);
  22.     }
  24.     // 提交事务
  25.     public void commit() throws SQLException {
  26.         connectionUtils.getCurrentThreadConn().commit();
  27.     }
  29.     // 回滚事务
  30.     public void rollback() throws SQLException {
  31.         connectionUtils.getCurrentThreadConn().rollback();
  32.     }
  33. }
  1. 增加 ProxyFactory 代理⼯⼚类，用来获取代理对象 ```java import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy;

public class ProxyFactory { private TransactionManager transactionManager; public void setTransactionManager(TransactionManager transactionManager) { this.transactionManager = transactionManager; } public Object getProxy(Object target) { return Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object result = null; try{ // 开启事务 transactionManager.beginTransaction(); // 调⽤原有业务逻辑 result = method.invoke(target,args); // 提交事务 transactionManager.commit(); }catch(Exception e) { e.printStackTrace(); // 回滚事务 transactionManager.rollback(); // 异常向上抛出,便于servlet中捕获 throw e.getCause(); } return result; } }); } }

  2. 4. 修改beans.xml来管理各个类之间的依赖关系
  3. ```xml
  4. <?xml version="1.0" encoding="UTF-8" ?>
  5. <!--跟标签beans，⾥⾯配置⼀个⼜⼀个的bean⼦标签，每⼀个bean⼦标签都代表⼀个类的配置-->
  6. <beans>
  7.     <!--id标识对象，class是类的全限定类名-->
  8.     <bean id="accountDao"
  9.           class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
  10.         <property name="ConnectionUtils" ref="connectionUtils"/>
  11.     </bean>
  13.     <bean id="transferService"
  14.           class="com.lagou.edu.service.impl.TransferServiceImpl">
  15.         <!--set+ name 之后锁定到传值的set⽅法了，通过反射技术可以调⽤该⽅法传⼊对应的值-->
  16.         <property name="AccountDao" ref="accountDao"></property>
  17.     </bean>
  19.     <!--配置新增的三个Bean-->
  20.     <bean id="connectionUtils"
  21.           class="com.lagou.edu.utils.ConnectionUtils"></bean>
  23.     <!--事务管理器-->
  24.     <bean id="transactionManager"
  25.           class="com.lagou.edu.utils.TransactionManager">
  26.         <property name="ConnectionUtils" ref="connectionUtils"/>
  27.     </bean>
  29.     <!--代理对象⼯⼚-->
  30.     <bean id="proxyFactory" class="com.lagou.edu.factory.ProxyFactory">
  31.         <property name="TransactionManager" ref="transactionManager"/>
  32.     </bean>
  33. </beans>
  1. 如图所示，TransferServlet调用的不再是直接的service实现类，而是调用它的代理类，通过ProxyFactory.getProxy()方法来获取，这样得到的就是方法增强后service，也就是实现了切面逻辑与业务的分离。
    1. public class TransferServlet extends HttpServlet {
    2. // 1. 最初版本是直接new一个service实现类
    3. //private TransferService transferService = new TransferServiceImpl();
    4. // 2. 然后改造成从BeanFactory来获取
    5. //private TransferService transferService = 
    6. //            (TransferService)BeanFactory.getBean("transferService");
    7. // 3.从⼯⼚获取委托对象（委托对象是增强了事务控制的功能）
    8. // ⾸先从BeanFactory获取到proxyFactory代理⼯⼚的实例化对象
    9. private ProxyFactory proxyFactory = (ProxyFactory)BeanFactory.getBean("proxyFactory");
    10. private TransferService transferService = (TransferService)
    11.  proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;
    12. }