Spring学习笔记--手写实现 IoC 和 AOP

最新推荐文章于 2023-02-17 15:06:57 发布

痛冕

最新推荐文章于 2023-02-17 15:06:57 发布

阅读量176

点赞数 3

分类专栏： IOC容器设计实现及Spring源码分析文章标签： java spring

本文链接：https://blog.csdn.net/qq_40977467/article/details/116975259

版权

IOC容器设计实现及Spring源码分析专栏收录该内容

12 篇文章 1 订阅

订阅专栏

手写实现 IoC 和 AOP

在手写实现IOC和AOP的案例中，我们使用Servlet接受web项目页面的请求，持久层使用的是JDBC。本章主要是通过手写案例来发现案例中的问题，提出相应的解决思路。

银行转账案例

在这里插入图片描述

案例表结构

在这里插入图片描述

转账案例代码调用关系

在这里插入图片描述

转账案例关键代码

TransferServlet

package com.lagou.edu.servlet;
import com.lagou.edu.service.impl.TransferServiceImpl;
import com.lagou.edu.utils.JsonUtils;
import com.lagou.edu.pojo.Result;
import com.lagou.edu.service.TransferService;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
	 // 1. 实例化service层对象
	 private TransferService transferService = new TransferServiceImpl();
	 @Override
	 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
	throws ServletException, IOException {
	 doPost(req,resp);
	 }
	 @Override
	 protected void doPost(HttpServletRequest req, HttpServletResponse
	resp) throws ServletException, IOException {
		 // 设置请求体的字符编码
		 req.setCharacterEncoding("UTF-8");
		 String fromCardNo = req.getParameter("fromCardNo");
		 String toCardNo = req.getParameter("toCardNo");
		 String moneyStr = req.getParameter("money");
		 int money = Integer.parseInt(moneyStr);
		 Result result = new Result();
		 try {
			 // 2. 调⽤service层⽅法
			 transferService.transfer(fromCardNo,toCardNo,money);
			 result.setStatus("200");
		 } catch (Exception e) {
			 e.printStackTrace();
			 result.setStatus("201");
			 result.setMessage(e.toString());
		 }
		 // 响应
		 resp.setContentType("application/json;charset=utf-8");
		 resp.getWriter().print(JsonUtils.object2Json(result));
 	}
}

TransferService接⼝及实现类

package com.lagou.edu.service;

public interface TransferService {
 	void transfer(String fromCardNo,String toCardNo,int money) throws
Exception;
}

package com.lagou.edu.service.impl;
import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.dao.impl.JdbcAccountDaoImpl;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.service.TransferService;

public class TransferServiceImpl implements TransferService {
 	private AccountDao accountDao = new JdbcAccountDaoImpl();
 	@Override
	 public void transfer(String fromCardNo, String toCardNo, int money)
	throws Exception {
		 Account from = accountDao.queryAccountByCardNo(fromCardNo);
		 Account to = accountDao.queryAccountByCardNo(toCardNo);
		 from.setMoney(from.getMoney()-money);
		 to.setMoney(to.getMoney()+money);
		 accountDao.updateAccountByCardNo(from);
		 accountDao.updateAccountByCardNo(to);
	 }
}

AccountDao层接⼝及基于Jdbc的实现类

package com.lagou.edu.dao;
import com.lagou.edu.pojo.Account;
public interface AccountDao {
 Account queryAccountByCardNo(String cardNo) throws Exception;
 int updateAccountByCardNo(Account account) throws Exception;
}

JdbcAccountDaoImpl（Jdbc技术实现Dao层接⼝）

package com.lagou.edu.dao.impl;
import com.lagou.edu.pojo.Account;
import com.lagou.edu.dao.AccountDao;
import com.lagou.edu.utils.DruidUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
/**
* @author 应癫
*/
public class JdbcAccountDaoImpl implements AccountDao {
	 @Override
	 public Account queryAccountByCardNo(String cardNo) throws Exception {
		 //从连接池获取连接
		 Connection con = DruidUtils.getInstance().getConnection();
		 String sql = "select * from account where cardNo=?";
		 PreparedStatement preparedStatement = con.prepareStatement(sql);
 		 preparedStatement.setString(1,cardNo);
		 ResultSet resultSet = preparedStatement.executeQuery();
		 Account account = new Account();
		 while(resultSet.next()) {
			 account.setCardNo(resultSet.getString("cardNo"));
			 account.setName(resultSet.getString("name"));
			 account.setMoney(resultSet.getInt("money"));
	 	}
		 resultSet.close();
		 preparedStatement.close();
		 con.close();
		 return account;
 	}
 	@Override
	 public int updateAccountByCardNo(Account account) throws Exception {
		 //从连接池获取连接
		 Connection con = DruidUtils.getInstance().getConnection();
		 String sql = "update account set money=? where cardNo=?";
		 PreparedStatement preparedStatement = con.prepareStatement(sql);
		 preparedStatement.setInt(1,account.getMoney());
		 preparedStatement.setString(2,account.getCardNo());
		 int i = preparedStatement.executeUpdate();
		 preparedStatement.close();
		 con.close();
		 return i;
	 }
}

转账案例代码问题分析

在这里插入图片描述
问题⼀：在上述案例实现中，service 层实现类在使⽤ dao 层对象时，直接在
TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl() 获得了 dao层对象，然⽽⼀个 new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类
JdbcAccountDaoImpl 耦合在了⼀起，如果说技术架构发⽣⼀些变动，dao 层的实现要使⽤其它技术，⽐如 Mybatis，思考切换起来的成本？每⼀个 new 的地⽅都需要修改源代码，重新编译，⾯向接⼝开发的意义将⼤打折扣？
问题二：service 层代码没有竟然还没有进⾏事务控制？！如果转账过程中出现异常，将可能导致数据库数据错乱，后果可能会很严重

问题解决思路

**针对问题⼀思考：**实例化对象的⽅式除了 new 之外，还有什么技术？反射 (需要把类的全限定类名配置在xml中)
考虑使⽤设计模式中的⼯⼚模式解耦合，另外项⽬中往往有很多对象需要实例化，那就在⼯⼚中使⽤反射技术实例化对象，⼯⼚模式很合适
更进⼀步，代码中能否只声明所需实例的接⼝类型，不出现 new 也不出现⼯⼚类的字眼？如下,能！声明⼀个变量并提供 set ⽅法，在反射的时候将所需要的对象注⼊进去吧

public class TransferServiceImpl implements TransferService{
	private AccountDao accountDao;
	
	public void setAccountDao(AccountDao accountDao){
		this.accountDao = accountDao;
	}
}

在resources下创建beans.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置-->
<beans>
    <!--id标识对象，class是类的全限定类名-->
    <bean id="accountDao" class="com.lagou.edu.dao.impl.JdbcTemplateDaoImpl">
        <property name="ConnectionUtils" ref="connectionUtils"/>
    </bean>
    <bean id="transferService" class="com.lagou.edu.service.impl.TransferServiceImpl">
        <!--set+ name 之后锁定到传值的set方法了，通过反射技术可以调用该方法传入对应的值-->
        <property name="AccountDao" ref="accountDao"></property>
    </bean>
</beans>

创建工厂类，解析beans.xml中的javabean,并通过反射创建实例化对象

package com.lagou.edu.factory;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author 应癫
 *
 * 工厂类，生产对象（使用反射技术）
 */
public class BeanFactory {

    /**
     * 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
     * 任务二：对外提供获取实例对象的接口（根据id获取）
     */

    private static Map<String,Object> map = new HashMap<>();  // 存储对象


    static {
        // 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
        // 加载xml
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        // 解析xml
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(resourceAsStream);
            Element rootElement = document.getRootElement();
            List<Element> beanList = rootElement.selectNodes("//bean");
            for (int i = 0; i < beanList.size(); i++) {
                Element element =  beanList.get(i);
                // 处理每个bean元素，获取到该元素的id 和 class 属性
                String id = element.attributeValue("id");        // accountDao
                String clazz = element.attributeValue("class");  // com.lagou.edu.dao.impl.JdbcAccountDaoImpl
                // 通过反射技术实例化对象
                Class<?> aClass = Class.forName(clazz);
                Object o = aClass.newInstance();  // 实例化之后的对象

                // 存储到map中待用
                map.put(id,o);

            }

            // 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
            // 有property子元素的bean就有传值需求
            List<Element> propertyList = rootElement.selectNodes("//property");
            // 解析property，获取父元素
            for (int i = 0; i < propertyList.size(); i++) {
                Element element =  propertyList.get(i);   //<property name="AccountDao" ref="accountDao"></property>
                String name = element.attributeValue("name");
                String ref = element.attributeValue("ref");

                // 找到当前需要被处理依赖关系的bean
                Element parent = element.getParent();

                // 调用父元素对象的反射功能
                String parentId = parent.attributeValue("id");
                Object parentObject = map.get(parentId);
                // 遍历父对象中的所有方法，找到"set" + name
                Method[] methods = parentObject.getClass().getMethods();
                for (int j = 0; j < methods.length; j++) {
                    Method method = methods[j];
                    if(method.getName().equalsIgnoreCase("set" + name)) {  // 该方法就是 setAccountDao(AccountDao accountDao)
                        method.invoke(parentObject,map.get(ref));
                    }
                }

                // 把处理之后的parentObject重新放到map中
                map.put(parentId,parentObject);

            }


        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }


    // 任务二：对外提供获取实例对象的接口（根据id获取）
    public static  Object getBean(String id) {
        return map.get(id);
    }

}

使用：

 private ConnectionUtils connectionUtils;

 public void setConnectionUtils(ConnectionUtils connectionUtils) {
      this.connectionUtils = connectionUtils;
  }

问题二
service 层没有添加事务控制，怎么办？没有事务就添加上事务控制，⼿动控制 JDBC 的Connection 事务，但要注意将Connection和当前线程绑定（即保证⼀个线程只有⼀个Connection，这样操作才针对的是同⼀个 Connection，进⽽控制的是同⼀个事务）
在这里插入图片描述

问题解决思路

Connection中的提交默认是自动提交的。AutoCommit默认为true。在上述的代码中两次的update使用的不是同一个Connection所以不属于一个事务控制。

案例代码改造

增加 ConnectionUtils

从连接池获取连接改造为从当前线程中获取绑定的connection连接，判断当前线程中是否已经绑定连接，如果没有绑定连接，需要从链接池中获取一个连接绑定到当前线程。

public class ConnectionUtils {

    /*private ConnectionUtils() {

    }

    private static ConnectionUtils connectionUtils = new ConnectionUtils();

    public static ConnectionUtils getInstance() {
        return connectionUtils;
    }*/


    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); // 存储当前线程的连接

    /**
     * 从当前线程获取连接
     */
    public Connection getCurrentThreadConn() throws SQLException {
        /**
         * 判断当前线程中是否已经绑定连接，如果没有绑定，需要从连接池获取一个连接绑定到当前线程
          */
        Connection connection = threadLocal.get();
        if(connection == null) {
            // 从连接池拿连接并绑定到线程
            connection = DruidUtils.getInstance().getConnection();
            // 绑定到当前线程
            threadLocal.set(connection);
        }
        return connection;

    }
}

增加 TransactionManager 事务管理器类

public class TransactionManager {
 private ConnectionUtils connectionUtils;
 public void setConnectionUtils(ConnectionUtils connectionUtils) {
 this.connectionUtils = connectionUtils;
 }
 // 开启事务
 public void beginTransaction() throws SQLException {
 connectionUtils.getCurrentThreadConn().setAutoCommit(false);
 }
 // 提交事务
 public void commit() throws SQLException {
 connectionUtils.getCurrentThreadConn().commit();
 }
 // 回滚事务
 public void rollback() throws SQLException {
 connectionUtils.getCurrentThreadConn().rollback();
 }
}

使用动态代理改造service事务管理

获取service层的代理对象

增加 ProxyFactory 代理工厂类

public class ProxyFactory {


    private TransactionManager transactionManager;

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /*private ProxyFactory(){

    }

    private static ProxyFactory proxyFactory = new ProxyFactory();

    public static ProxyFactory getInstance() {
        return proxyFactory;
    }*/



    /**
     * Jdk动态代理
     * @param obj  委托对象
     * @return   代理对象
     */
    public Object getJdkProxy(Object obj) {

        // 获取代理对象
        return  Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.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(obj,args);

                            // 提交事务

                            transactionManager.commit();
                        }catch (Exception e) {
                            e.printStackTrace();
                            // 回滚事务
                            transactionManager.rollback();

                            // 抛出异常便于上层servlet捕获
                            throw e;

                        }

                        return result;
                    }
                });

    }


    /**
     * 使用cglib动态代理生成代理对象
     * @param obj 委托对象
     * @return
     */
    public Object getCglibProxy(Object obj) {
        return  Enhancer.create(obj.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                Object result = null;
                try{
                    // 开启事务(关闭事务的自动提交)
                    transactionManager.beginTransaction();

                    result = method.invoke(obj,objects);

                    // 提交事务

                    transactionManager.commit();
                }catch (Exception e) {
                    e.printStackTrace();
                    // 回滚事务
                    transactionManager.rollback();

                    // 抛出异常便于上层servlet捕获
                    throw e;

                }
                return result;
            }
        });
    }
}

修改beans.xml

<!--配置新增的三个Bean-->
 <bean id="connectionUtils"
class="com.lagou.edu.utils.ConnectionUtils"></bean>
 <!--事务管理器-->
 <bean id="transactionManager"
class="com.lagou.edu.utils.TransactionManager">
 <property name="ConnectionUtils" ref="connectionUtils"/>
 </bean>
 <!--代理对象⼯⼚-->
 <bean id="proxyFactory" class="com.lagou.edu.factory.ProxyFactory">
 <property name="TransactionManager" ref="transactionManager"/>
 </bean>

修改Dao层实现方法

主要就是把之前方法的关闭连接注释掉，确保使用一个连接对象。

public class JdbcAccountDaoImpl implements AccountDao {
	 private ConnectionUtils connectionUtils;
	 public void setConnectionUtils(ConnectionUtils connectionUtils) {
	 	this.connectionUtils = connectionUtils;
	 }
	 @Override
	 public Account queryAccountByCardNo(String cardNo) throws Exception {
		 //从连接池获取连接
		 // Connection con = DruidUtils.getInstance().getConnection();
		 Connection con = connectionUtils.getCurrentThreadConn();
		 String sql = "select * from account where cardNo=?";
		 PreparedStatement preparedStatement = con.prepareStatement(sql);
		 preparedStatement.setString(1,cardNo);
		 ResultSet resultSet = preparedStatement.executeQuery();
		 Account account = new Account();
	 	while(resultSet.next()) {
			 account.setCardNo(resultSet.getString("cardNo"));
			 account.setName(resultSet.getString("name"));
			 account.setMoney(resultSet.getInt("money"));
		}
		 resultSet.close();
		 preparedStatement.close();
		 //con.close();
		 return account;
	 }
	 @Override
	 public int updateAccountByCardNo(Account account) throws Exception {
		 // 从连接池获取连接
		 // 改造为：从当前线程当中获取绑定的connection连接
		 //Connection con = DruidUtils.getInstance().getConnection();
		 Connection con = connectionUtils.getCurrentThreadConn();
		 String sql = "update account set money=? where cardNo=?";
		 PreparedStatement preparedStatement = con.prepareStatement(sql);
		 preparedStatement.setInt(1,account.getMoney());
		 preparedStatement.setString(2,account.getCardNo());
		 int i = preparedStatement.executeUpdate();
		 preparedStatement.close();
		 //con.close();
		 return i;
	 }
}

修改 TransferServlet

@WebServlet(name="transferServlet",urlPatterns = "/transferServlet")
public class TransferServlet extends HttpServlet {
		 // 1. 实例化service层对象
		 //private TransferService transferService = new TransferServiceImpl();
		 //private TransferService transferService = (TransferService)
		BeanFactory.getBean("transferService");
		 // 从⼯⼚获取委托对象（委托对象是增强了事务控制的功能）
		 // ⾸先从BeanFactory获取到proxyFactory代理⼯⼚的实例化对象
		 private ProxyFactory proxyFactory = (ProxyFactory)
		BeanFactory.getBean("proxyFactory");
		 private TransferService transferService = (TransferService)
		proxyFactory.getJdkProxy(BeanFactory.getBean("transferService")) ;
		 @Override
		 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
		throws ServletException, IOException {
		 doPost(req,resp);
	 }
 	@Override
	 protected void doPost(HttpServletRequest req, HttpServletResponse
	resp) throws ServletException, IOException {
		 // 设置请求体的字符编码
		 req.setCharacterEncoding("UTF-8");
		 String fromCardNo = req.getParameter("fromCardNo");
		 String toCardNo = req.getParameter("toCardNo");
		 String moneyStr = req.getParameter("money");
		 int money = Integer.parseInt(moneyStr);
		 Result result = new Result();
		 try {
		 // 2. 调⽤service层⽅法
		 transferService.transfer(fromCardNo,toCardNo,money);
		 result.setStatus("200");
		 } catch (Exception e) {
		 e.printStackTrace();
		 result.setStatus("201");
		 result.setMessage(e.toString());
		 }
		 // 响应
		 resp.setContentType("application/json;charset=utf-8");
		 resp.getWriter().print(JsonUtils.object2Json(result));
	 }
}

痛冕

关注

3
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
Spring学习笔记--手写实现 IoC 和 AOP

手写实现 IoC 和 AOP在手写实现IOC和AOP的案例中，我们使用Servlet接受web项目页面的请求，持久层使用的是JDBC。本章主要是通过手写案例来发现案例中的问题，提出相应的解决思路。银行转账案例案例表结构转账案例代码调用关系转账案例关键代码TransferServletpackage com.lagou.edu.servlet;import com.lagou.edu.service.impl.TransferServiceImpl;import com.lagou
复制链接

扫一扫