【手写框架】2. Spring IOC 和 AOP

最新推荐文章于 2024-06-10 17:18:17 发布
最新推荐文章于 2024-06-10 17:18:17 发布
阅读量144 收藏
点赞数 1
分类专栏： 自定义框架 文章标签： spring 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44831431/article/details/108363846
版权

手写spring的IOC 和 AOP框架

我们都知道spring 框架的核心就是IOC 和AOP，但是直接翻阅源码对于刚开始用spring的小伙伴会有些难度，所以这里我们实现一个简单的手写IOC 和 AOP来帮助小伙伴们更好的理解spring的底层实现。
我们使用一个模拟用户转账的场景来实现IOC 和 AOP
我们先来看下项目的整理调用流程图
在这里插入图片描述
我们对这张图来进行一下简单的分析

  • beans.xml 配置我们的bean对象
  • Beanfactory 用来解析beans.xml中需要我们管理的对象，如果有依赖关系通过set方法进行注入。最后存储到一个hashMap中，供调用
  • DruidsUtils 获取druid数据源
  • ConnectionUtils 获取数据库链接,引入ThreadLocal，保证一个线程只有一个数据库连接
  • TransactionManager 管理事务
  • ProxyFactory 用来创建代理对象

准备工作

  • 创建数据 spring
  • 创建表 account
  • 添加至少2条数据

创建maven项目

在这里插入图片描述

项目命名为spring-ioc

在这里插入图片描述

项目结构

在这里插入图片描述

引入项目依赖的jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>spring-ioc</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.26</version>
        </dependency>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

</project>

创建account实体类

@Data
@ToString
public class Account {

    private String cardId;

    private String accountName;

    private Integer money;
}

创建数据库连接池Druid工具类

public class DruidsUtils {

    private DruidsUtils() {
    }

    private static final DruidsUtils instance = new DruidsUtils();

    public static DruidsUtils getInstance() {
        return instance;
    }

    public Connection getConnection() {
        Connection connection = null;
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("root");
        try {
            connection = druidDataSource.getConnection();
        } catch (SQLException e) {
            System.out.println("获取数据库连接异常");
            e.printStackTrace();
        }
        return connection;
    }
}

创建数据库连接工具类

public class ConnectionUtils {

    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();

    public Connection getCurrentThreadConn() {
        Connection connection = threadLocal.get();
        if (connection == null) {
            connection = DruidsUtils.getInstance().getConnection();
            threadLocal.set(connection);
        }
        return connection;
    }
}

接下来我们创建数据库接口层以及实现类

AccountDao接口

public interface AccountDao {

    /**
     * 通过card id获取账户信息
     * @param cardId card id
     * @return 账户信息
     */
    Account getAccountByCartId(String cardId);

    /**
     * 修改账户金额
     * @param account Account
     */
    void updateAccount(Account account);
}

AccountDaoImpl实现类

public class AccountDaoImpl implements AccountDao {

    private ConnectionUtils connectionUtils;

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

    @Override
    public Account getAccountByCartId(String cardId) {
        String sql = "select * from account where card_id = ?";
        try {
            Connection connection = connectionUtils.getCurrentThreadConn();
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, cardId);

            ResultSet resultSet = preparedStatement.executeQuery();
            Account account = new Account();
            while (resultSet.next()) {
                account.setCardId(resultSet.getString("card_id"));
                account.setAccountName(resultSet.getString("account_name"));
                account.setMoney(resultSet.getInt("money"));
            }
            return account;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void updateAccount(Account account) {
        String sql = "update account set money = ? where card_id = ?";
        try {
            Connection connection = connectionUtils.getCurrentThreadConn();
            PreparedStatement preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setInt(1, account.getMoney());
            preparedStatement.setString(2, account.getCardId());
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

服务层接口以及实现类

AccountService接口

public interface AccountService {

    /**
     * 转账
     * @param transferFrom 转账人账户
     * @param transferTo 收款人账户
     * @param money 转账金额
     */
    void transferMoney(String transferFrom, String transferTo, Integer money);
}

AccountServiceImpl实现类

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void transferMoney(String transferFrom, String transferTo, Integer money) {
        Account fromAccount = accountDao.getAccountByCartId(transferFrom);
        Account toAccount = accountDao.getAccountByCartId(transferTo);
        fromAccount.setMoney(fromAccount.getMoney() - money);
        accountDao.updateAccount(fromAccount);
        toAccount.setMoney(toAccount.getMoney() + money);
        accountDao.updateAccount(toAccount);
    }
}

创建beans.xml 来配置我们需要管理的bean对象

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <!--链接工具类-->
    <bean id="connectionUtils" class="com.spring.utils.ConnectionUtils"/>
    <!--事务管理器-->
    <bean id="transactionManager" class="com.spring.utils.TransactionManager">
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>
    <!--代理对象工厂-->
    <bean id="proxyFactory" class="com.spring.factory.ProxyFactory">
        <property name="transactionManager" ref="transactionManager"/>
    </bean>

    <bean id="accountDao" class="com.spring.dao.AccountDaoImpl">
        <property name="connectionUtils" ref="connectionUtils"/>
    </bean>

    <bean id="accountService" class="com.spring.service.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
</beans>

创建BeanFactory来读取解析bean.xml中的bean

public class BeanFactory {

    private static HashMap<String, Object> beanMap = new HashMap<>();

    static {
        try {
            //读取beans xml配置文件
            InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(inputStream);
            Element rootElement = document.getRootElement();
            //解析所有bean标签，并放入map中
            List<Element> beanList = rootElement.selectNodes("//bean");
            for (Element element : beanList) {
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                Class<?> aClass = Class.forName(className);
                Object o = aClass.newInstance();
                beanMap.put(id, o);
            }

            //解析bean的依赖标签property，并通过set方法注入到对应的类中
            List<Element> properties = rootElement.selectNodes("//property");
            for (Element property : properties) {
                Element parent = property.getParent();
                String id = parent.attributeValue("id");
                Object parentObj = beanMap.get(id);
                Method[] methods = parentObj.getClass().getDeclaredMethods();
                //找到set方法，注入
                List<Method> methodList = Arrays.stream(methods).filter(w -> {
                    String methodName = "set" + property.attributeValue("name");
                    return w.getName().equalsIgnoreCase(methodName);
                }).collect(Collectors.toList());
                if (methodList.size() <= 0) {
                    throw new RuntimeException("依赖对象未找到");
                }
                String ref = property.attributeValue("ref");
                Object childObj = beanMap.get(ref);
                methodList.get(0).invoke(parentObj, childObj);
            }
        } catch (DocumentException | InstantiationException | IllegalAccessException | ClassNotFoundException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过bean name获取bean
     *
     * @param name bean name
     * @return bean对象
     */
    public static Object getBean(String name) {
        return beanMap.get(name);
    }
}

创建事务管理类

public class TransactionManager {

    private ConnectionUtils connectionUtils;

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

    /**
     * 开启事务
     *
     * @throws SQLException
     */
    public void beginTransaction() throws SQLException {
        System.out.println("begin transaction");
        connectionUtils.getCurrentThreadConn().setAutoCommit(false);
    }

    /**
     * 提交事务
     *
     * @throws SQLException
     */
    public void commit() throws SQLException {
        System.out.println("commit transaction");
        connectionUtils.getCurrentThreadConn().commit();
    }

    /**
     * 回滚事务
     *
     * @throws SQLException
     */
    public void rollback() throws SQLException {
        System.out.println("rollback transaction");
        connectionUtils.getCurrentThreadConn().rollback();
    }
}

创建代理工厂用于在执行service层方法前后进行事务的处理

public class ProxyFactory {

    private TransactionManager transactionManager;

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

    public Object getProxy(Object o) {
        return Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(),
                (proxy, method, args) -> {
                    Object invoke = null;
                    try {
                        //开启事务
                        transactionManager.beginTransaction();
                        invoke = method.invoke(o, args);
                        //关闭事务
                        transactionManager.commit();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        //回滚事务
                        transactionManager.rollback();
                    }
                    return invoke;
                });
    }
}

接下来我们编写测试类，来看下验证一下我们的项目配置是否正常

先来测试一下dao层，看数据是否可以正常获取

public class AccountDaoImplTest {

    @Test
    public void getAccountByCartId() {
        AccountDao accountDao = (AccountDao) BeanFactory.getBean("accountDao");
        Account account = accountDao.getAccountByCartId("622001");
        System.out.println(account);
    }

    @Test
    public void updateAccount() {
    }
}

看下结果，账户数据可以正常打印，说明我们的bean已经注入成功
在这里插入图片描述

再来看下是否可以转账成功

public class AccountServiceImplTest {

    @Test
    public void transferMoney() {
        ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
        AccountService accountService = (AccountService) proxyFactory.getProxy(BeanFactory.getBean("accountService"));
        accountService.transferMoney("622001", "622002", 100);

    }
}

可以看到已经执行了我们事务中的方法，已经打印出来
在这里插入图片描述
我们再来获取一下账户数据，可以发现钱已经转过去了
在这里插入图片描述
至此我们的项目完整结束

一个快乐小码农
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring1-手写ioc和aop
growing_duck的博客
05-29 237
spring手写ioc和aop
[由零开始] 十、手写实现简易Spring框架IOC和AOP
MrSoon的博客
05-12 397
[由零开始]十 、手写实现Spring框架IOC和AOP深度理解Spring框架Ioc和AopIoc容器什么是Ioc?区别Ioc解决了什么问题IoC和DI的区别Aop思想什么是Aop?AOP解决了什么问题?为什么叫面向切面编程? 深度理解Spring框架Ioc和Aop 注意 Ioc与Aop 这两个概念并不是Spring提出的 只是Spring在技术层面上做了非常好的实现, 后面我们将通过手写来理解...
自定义实现SpringMvc框架，自定义@Controller、@RequestMapping注解，自己也是一步一步的对代码的理解出来的，只是比较简单的例子
you_are_my_life的博客
09-14 2558
1.自定义的DispatcherServlet,就是SpringMvc运行加载类 /*** * 手写SpringMvc框架&lt;br&gt; * 思路：&lt;br&gt; * 1.手动创建一个DispatcherServlet 拦截项目的所有请求 SpringMvc 基于servlet实现&lt;br&gt; * 2.extends HttpHttpServlet 重写init 方...
手写springIOC、AOP
qq_35080214的博客
12-18 1882
手写springIOC、AOP
手写自定义Spring的IOC和AOP
沐晨~的博客
06-20 194
1、IOC和AOP的理解 IOC是控制反转，就是将实例化对象交给Spring进行管理，由Spring容器进行管理，帮忙实现实例化对象，而不需要我们手动new一个对象。 AOP是面向切面编程，就是原有方法的逻辑不变，在调用方法前或者方法后加上自己的处理逻辑，是一种纵向增强 2、自定义Spring的@service，@Autowired、@Transactional注解类 自定义自己的注解： package com.lwq.edu.annotation; import java.lang.annotation
仿 Spring 手写 IoC、AOP 框架.rar
10-23
《仿 Spring 手写 IoC、AOP 框架》博客附件。 博客地址：https://blog.csdn.net/Supreme_Sir/article/details/109100886
手写spring框架ioc+aop+mvc
11-01
手写spring框架ioc+aop+mvc
tiny-spring-practice:实践tiny-spring，手写Spring两大核心功能：IOC和AOP
05-13
然后发现了多年前的一个精简版的Spring学习项目，叫，作者对spring核心的IOC和AOP进行了临摹实现，也很细心的对实现步骤进行了拆分。我看完了tiny-spring收获许多，自己也参考该项目进行了模仿与实践，从我学习的...
手把手教你手写Spring框架(附源码)
06-30
帮助广大学员手把手教学，本课程从无到有，循序渐进的手写mvc框架，由于官方的框架比较复杂，为了让同学们能够学懂，先从简单地IOC框架入手，然后不断地升级和迭代，逐渐成为官方比较接近的Spring框架。希望同学们...
00-myspring-ioc.war
09-04
手写spring ioc（Inversion of Control控制反转，也称依赖倒置（反转））代码的实现
手写一个简单的spring框架
fighting_yifeng的博客
02-10 628
手写一个简单的spring框架 一. 为什么？ ​ 为什么要手写一个spring框架呢，当你把spring代码down到本地你就会发现，spring的核心代码都已经有100w行之多了，他的功能和代码风格都是每个Java程序员所推崇和阅读的。但一个spring框架的核心概念，是可以被抽出来理解和学习的。而且还有什么比手写一个更容易理解一个框架的呢？ ​ 还有就是结合自己的个人经验，无论是当时面试美团，还是实习的时候面浪潮等济南的一些公司，面试官问到spring的细节的时候，总会有一些无力感，随后就是来自面试官
Java 手写 Spring框架 IOC 和 AOP----手写Spring IoC和AOP
殷志鹏的博客
01-23 1691
本文将首先通过手写Spring，了解Spring基本思想，然后介绍Spring的一些高级用法，随后深度剖析其源码，让读者有更深入的了解====本文源码基于5.1.12版本讲解
手把手教你手写Spring框架
weixin_49849351的博客
12-07 5845
手写spring准备工作： 新建一个maven工程： 架构 新建类： package com.spring; public class keweiqinApplicationContext { private Class configClass; public keweiqinApplicationContext(Class configClass) { this.configClass = configClass; } //解析配
手写简易Spring框架
m0_57560984的博客
09-23 443
我们前面分析很多的Spring源码，现在我们来手写一个简易的Spring源码 创建一个maven工程。 public class Test { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); UserService userSe...
手写Spring框架
热门推荐
Tyshawn的博客
01-25 2万+
在学习完Spring框架之后, 我们知道了 Spring容器, IOC, AOP, 事务管理, SpringMVC 这些Spring的核心内容, 也知道了它们底层实现的基本原理, 比如Spring容器就是个Map映射, IOC底层就是反射机制, AOP底层是动态代理, SpringMVC不就是对Servlet进行了下封装嘛! 哈哈, 当然这些只是些皮毛, Spring除此之外还有更加复杂的设计, ...
Spring真的这么难懂吗？还是你没找对方法？
wdj_yyds的博客
05-04 3534
👨‍💻连读同事写的代码都费劲，还读Spring？ 咋的，Spring 很难读！ 这个与我们码农朝夕相处的 Spring，就像睡在你身边的媳妇，你知道找她要吃、要喝、要零花钱、要买皮肤。但你不知道她的仓库共有多少存粮、也不知道她是买了理财还是存了银行。🍑开个玩笑，接下来我要正经了！ 一、为什么Spring难读懂？ 为什么 Spring 天天用，但要想去读一读源码，怎么就那么难！因为由Java和J2EE开发领域的专家 Rod Johnson 于 2002 年提出并随后创建的 Spring 框架，随着 JD
手写spring框架
chenmin_test的博客
10-30 2098
最近我手写了一个spring框架，spring框架主要运用了反射和动态代理的方式，我们都知道spring框架主要的两个功能是IOC和AOP,我今天就说说控制反转IOC。这个项目上我运用了注解，xml文件解析，类的反射机制等技术。 我的手写的spring框架项目架构： 首先，根据spring中的注解创建4个自定义的注解 创建MyAutowired注解，该注解主要用于参数注入，代码如下： ...
我的架构梦：（四）手写Spring中的IoC和AOP
riemann_的博客
06-02 840
手写spring中的IoC和AOP一、核心思想二、手写实现IoC和AOP三、代码仓库 一、核心思想 IoC和AOP不是spring提出来的，在spring之前就已经存在，只不过更偏向理论化，spring在技术层面把这两个思想做了非常好的实现。在手写spring中的IoC和AOP之前，我们先来了解IoC和AOP的思想。 1、IoC 1.1 什么是IoC？ IoC Inversion of Control(控制反转、反转控制)，注意它是一个技术思想，不是技术实现。 描述的事情：Java开发领域对象的创建、管理的
6、Spring之Bean生命周期~创建Bean（2）
最新发布
sproutBoy的博客
06-10 678
【代码】6、Spring之Bean生命周期~创建Bean（2）
java手写spring框架
10-18
好的，关于手写Spring框架，我可以给你一些思路和步骤： 1. 实现IoC容器：IoC容器是Spring框架的核心，它负责管理Bean的生命周期和依赖注入。可以通过反射机制实现Bean的实例化和属性注入。 2. 实现Bean的定义：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值