spring学习笔记（一）（框架思想以及手写实现IOC和AOP）

最新推荐文章于 2023-12-29 20:44:26 发布

try...catch...

最新推荐文章于 2023-12-29 20:44:26 发布

阅读量202

点赞数

分类专栏： # 常用框架文章标签： java spring 后端

本文链接：https://blog.youkuaiyun.com/weixin_47603407/article/details/118164701

版权

常用框架专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了Spring框架的核心优势，包括IoC（控制反转）和AOP（面向切面编程）特性，以及如何通过这两种技术解决对象耦合和横切逻辑问题。Spring框架提供了方便的依赖注入和声明式事务管理，简化了测试和集成各种框架的工作。此外，通过手写IOC和AOP的示例，展示了如何实现对象的解耦以及事务控制，强调了动态代理在事务管理中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

模块二任务一笔记

1-2.spring框架介绍

Spring 是分层的 full-stack（全栈）轻量级开源框架，以 IoC 和 AOP 为内核，提供了展现层 SpringMVC 和业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，成为使⽤最多的 Java EE 企业应⽤开源框架

Spring的优势:

⽅便解耦，简化开发

通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进⾏控制，避免硬编码所造成的过度程序耦合。⽤户也不必再为单例模式类、属性⽂件解析等这些很底层的需求编写代码，可以更专注于上层的应⽤。

AOP编程的⽀持

通过Spring的AOP功能，⽅便进⾏⾯向切⾯的编程，许多不容易⽤传统OOP实现的功能可以通过AOP轻松应付。

声明式事务的⽀持

@Transactional
可以将我们从单的事务管理代码中解脱出来，通过声明式⽅式灵活的进⾏事务的管理，提⾼开发效率和质量。

⽅便程序的测试

可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作，测试不再是昂贵的操作，⽽是随⼿可做的事情。

⽅便集成各种优秀框架

Spring可以降低各框架的难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接⽀持。

降低JavaEE API的使⽤难度

Spring对JavaEE API（如JDBC、JavaMail、远程调⽤等）进⾏了封装，使这些API的使⽤难度⼤为降低。

源码是经典的 Java 学习范例

Spring的源代码设计精妙、结构清晰、匠⼼独⽤，处处体现着⼤师对Java设计模式灵活运⽤以及对Java技术的⾼深造诣。它的源代码⽆意是Java技术的最佳实践的范例。

核心结构：

Spring是⼀个分层清晰并且依赖关系、职责定位明确的轻量级框架，主要包括⼏个⼤模块：数据处理模块、Web模块、AOP（Aspect Oriented Programming）/Aspects模块、Core Container模块和 Test 模块

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pUaqf7qM-1624461782154)(F:\拉勾\home-work\第一阶段模块二\验证资料\图片\spring架构.jpg)]

Spring核⼼容器（Core Container）

容器是Spring框架最核⼼的部分，它管理着Spring应⽤中bean的创建、配置和管理。在该模块中，包括了Spring bean⼯⼚，它为Spring提供了DI的功能。基于bean⼯⼚，我们还会发现有多种Spring应⽤上下⽂的实现。所有的Spring模块都构建于核⼼容器之上。

⾯向切⾯编程（AOP）/Aspects

Spring对⾯向切⾯编程提供了丰富的⽀持。这个模块是Spring应⽤系统中开发切⾯的基础，与DI⼀样，AOP可以帮助应⽤对象解耦。数据访问与集成（Data Access/Integration）

Spring的JDBC和DAO模块

封装了⼤量样板代码，这样可以使得数据库代码变得简洁，也可以更专注于我们的业务，还可以避免数据库资源释放失败⽽引起的问题。另外，Spring AOP为数据访问提供了事务管理服务，同时Spring还对ORM进⾏了集成，如Hibernate、MyBatis等。该模块由JDBC、Transactions、ORM、OXM 和 JMS 等模块组成。

Web

该模块提供了SpringMVC框架给Web应⽤，还提供了多种构建和其它应⽤交互的远程调⽤⽅案。 SpringMVC框架在Web层提升了应⽤的松耦合⽔平。

Test

为了使得开发者能够很⽅便的进⾏测试，Spring提供了测试模块以致⼒于Spring应⽤的测试。通过该模块，Spring为使⽤Servlet、JNDI等编写单元测试提供了⼀系列的mock对象实现

3-4. IOC编程思想

IOC概念：

IoC Inversion of Control (控制反转/反转控制) 它是⼀个技术思想，不是⼀个技术实现描述的事情：Java开发领域对象的创建，管理的问题，这种思想在Spring之前已经存在

传统开发⽅式：⽐如类A依赖于类B，往往会在类A中new⼀个B的对象

IoC思想下开发⽅式：我们不⽤⾃⼰去new对象了，⽽是由IoC容器（Spring框架）去帮助我们实例化对象并且管理它，我们需要使⽤哪个对象，去问IoC容器要即可

使用IOC我们丧失了⼀个创建、管理对象的权利 , 但是不⽤考虑对象的创建、管理等⼀系列事情

控制：指的是对象创建（实例化、管理）的权利
反转：控制权交给外部环境了（spring框架、IoC容器）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-loaxAsj4-1624461782159)(F:\拉勾\home-work\第一阶段模块二\验证资料\图片\IOC概念图示.jpg)]

IoC解决对象之间的耦合问题

IOC和DI的区别：

**DI：**Dependancy Injection（依赖注⼊）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RClM8oMv-1624461782161)(F:\拉勾\home-work\第一阶段模块二\验证资料\图片\IOC和DI的区别.jpg)]

主要区别：IOC站在对象的角度 DI站在容器的角度

5.AOP 思想

AOP概念:

AOP: Aspect oriented Programming ⾯向切⾯编程/⾯向⽅⾯编程

AOP是OOP的延续

OOP三大特征：：封装、继承和多态（垂直纵向的继承体系）例如：父类-子类-子类（动物-狗-京巴）

oop可以解决大多数的代码重复问题，但是有些无法解决，比如在顶级父类中的多个方法相同位置出现了重复代码，oop无法解决

**横切逻辑代码：**再多个纵向（顺序）流程中出现的相同子流程代码，可以称为横切逻辑代码

	 横切逻辑代码使用场景有限，一般是在事务控制，权限校验，日志等地方

横切逻辑代码问题：代码重复；横切逻辑代码和业务代码混杂在一起，代码臃肿，维护不方便

AOP提出横向抽取机制，将横切逻辑代码和业务逻辑代码分开

AOP解决的问题：

再不改变原有业务逻辑情况下，增强横切逻辑代码，从根本上解耦合，避免横切逻辑代码重复

面向切面编程：

切：指的是横切逻辑，原有业务逻辑代码不动，只能操作横切逻辑代码，所以面向横切逻辑

面：横切逻辑影响的是多个方法，每一个方法如同一个点，多点构成面，存在面的概念

6-14手写IOC和AOP

原始代码存在问题：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V8pKaKcL-1624461782163)(F:\拉勾\home-work\第一阶段模块二\验证资料\图片\原代码存在问题.jpg)]

（1）问题⼀：

在上述案例实现中，service 层实现类在使⽤ dao 层对象时，直接在TransferServiceImpl 中通过 AccountDao accountDao = new JdbcAccountDaoImpl() 获得了 dao层对象，然⽽ new 关键字却将 TransferServiceImpl 和 dao 层具体的⼀个实现类JdbcAccountDaoImpl 耦合在了⼀起，如果技术架构发⽣⼀些变动，dao 层的实现要使⽤其它技术，⽐如 Mybatis，切换起来的成本高，每⼀个 new 的地⽅都需要修改源代码，重新编译，⾯向接⼝开发的意义将⼤打折扣

（2）问题⼆：

service 层代码还没有进⾏事务控制，如果转账过程中出现异常，将可能导致数据库数据错乱，后果可能会很严重，尤其在⾦融业务。

问题解决方案：

针对问题一：

实例化对象的⽅式除了 new 之外，还有什么技术？
反射 (需要把类的全限定类名配置在xml中)
考虑使⽤设计模式中的⼯⼚模式解耦合，另外项⽬中往往有很多对象需要实例化，那就在⼯⼚中使⽤反射技术实例化对象，⼯⼚模式很合适

代码的修改：

XML文件：

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

添加BeanFactory解析xml文件

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

    /**
     * 任务一：读取解析xml文件  通过反射技术实例化对象并且存储待用（map集合）
     *
     * 任务二：对外提供获取实例化对象的接口（根据id获取）
     * */
    private static Map<String,Object> map = new HashMap<>();//存储对象
    //加载时候立即执行
    static{
        //任务一  读取解析xml文件
        InputStream resourceAsStream =BeanFactory.
            				class.getClassLoader().getResourceAsStream("bean.xml");
        SAXReader saxReader = new SAXReader();
        try {
            Document read = saxReader.read(resourceAsStream);
            Element rootElement = read.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");  //  AccountDao
                String ref = element.attributeValue("ref");   //   accountDao

                //找到需要处理依赖关系的bean
                Element parent = element.getParent();  
              // <bean id ="transferService"  class="com.lagou.edu.service.impl.TransferServiceImpl">

                //调用父元素对象的反射功能
                String parentId = parent.attributeValue("id"); //  transferService
                Object parentObject = map.get(parentId);    // TransferServiceImpl
                //遍历父对象中的所有方法  找到 set+name
                Method[] methods = parentObject.getClass().getMethods();  
                // public void setAccountDao
                for (int j = 0; j < methods.length; j++) {
                    Method method = methods[j];
                    if(method.getName().equalsIgnoreCase("set"+name)){
                        //该方法就是setAccountDao
                        method.invoke(parentObject,map.get(ref)); 
                        //TransferServiceImpl  com.lagou.edu.dao.impl.JdbcAccountDaoImpl
                    }
                }
                //处理之后的parentObject重新放到map
                map.put(parentId,parentObject); //transferService    TransferServiceImpl
            }
        } catch (DocumentException | 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 AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

针对问题二：

service 层没有添加事务控制。没有事务就添加上事务控制，⼿动控制 JDBC 的Connection 事务，但要注意将Connection和当前线程绑定（即保证⼀个线程只有⼀个Connection，这样操作才针对的是同⼀个 Connection，进⽽控制的是同⼀个事务）

在这里插入图片描述

代码的修改：

添加工具类：

public class ConnectionsUtils {

    private ConnectionsUtils(){

    }
    private static  ConnectionsUtils connectionsUtils = new ConnectionsUtils();

    public static  ConnectionsUtils getInstance(){
        return  connectionsUtils;
    }

    private ThreadLocal<Connection> threadLocal = new ThreadLocal<>();
    /*从当前线程获取连接*/
    public Connection getCCurrentConn() throws SQLException {
        //判断当前线程池中是否已经绑定连接 如果没有 需要从连接池中获取一个连接绑定到当前线程

        Connection connection = threadLocal.get();
        if (connection == null){
            //从连接池中拿链接并绑定
            connection = DruidUtils.getInstance().getConnection();
            //绑定到当前线程池
            threadLocal.set(connection);
        }
        return connection;
    }
}

修改链接获取方式：

//修改前：
Connection con = DruidUtils.getInstance().getConnection();
//修改后
修改后：Connection cCurrentConn = ConnectionsUtils.getInstance().getCCurrentConn();

将代码提取出来，做出事务管理器

public class TransactionManager {
    private TransactionManager(){

    }

    private  static TransactionManager transactionManager = new TransactionManager();

    public static TransactionManager getInstance(){
        return transactionManager;
    }

    //开启事务
    public void beginTransaction() throws SQLException {
        ConnectionsUtils.getInstance().getCCurrentConn().setAutoCommit(false);
    }
    //提交事务
    public void commitTransaction() throws SQLException {
        ConnectionsUtils.getInstance().getCCurrentConn().commit();
    }
    //回滚事务
    public void rollBackTransaction() throws SQLException {
        ConnectionsUtils.getInstance().getCCurrentConn().rollback();
    }
}

调用方式

public void transfer(String fromCardNo, String toCardNo, int money)
            throws Exception {
        try{
            //开启事务(关闭事务的自动提交)
            TransactionManager.getInstance().beginTransaction();

            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);
            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);
            accountDao.updateAccountByCardNo(from);
            int a = 1/0;
            accountDao.updateAccountByCardNo(to);
            //提交事务
            TransactionManager.getInstance().commitTransaction();
        }catch (Exception e){
            e.printStackTrace();
            //回滚事务
            TransactionManager.getInstance().rollBackTransaction();
            //抛出异常便于上层捕获
            throw e;
        }
    }

  在操作事务的过程中，可以发现，三种操作过程（开启，提交，回滚）可以作为逻辑层代码提取出来，引入一个概念，动态代理。

动态代理概念***：

public class ProxyFactory {
    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;

                        // 写增强逻辑
                        System.out.println("中介（代理）收取服务费3000元");
                        // 调用原有业务逻辑
                        result = method.invoke(obj,args);
                        System.out.println("客户信息卖了3毛钱");
                        return result;
                        //method 方法为增删改查的时候查的时候不用管 删改的时候提交事务
                    }
           });      

    }
    /**
     * 使用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;
                System.out.println("中介（代理）收取服务费3000元");
                result = method.invoke(obj,objects);
                System.out.println("客户信息卖了3毛钱");
                return result;
            }
        });
    }
}

1.jdk动态代理（自带）

public class JdkProxy {

    public static void main(String[] args) {
        IRentingHouse rentingHouse = new RentingHouseImpl();  // 委托对象---委托方
        // 从代理对象工厂获取代理对象
        IRentingHouse jdkProxy = (IRentingHouse)  ProxyFactory.getInstance().
           												 getJdkProxy(rentingHouse);
        jdkProxy.rentHosue();
    }
}

2.cglib动态代理（导包）

public class CglibProxy {

    public static void main(String[] args) {
        RentingHouseImpl rentingHouse = new RentingHouseImpl();  // 委托对象
        // 获取rentingHouse对象的代理对象，
        // Enhancer类似于JDK动态代理中的Proxy
        // 通过实现接口MethodInterceptor能够对各个方法进行拦截增强，类似于JDK动态代理中的InvocationHandler

        // 使用工厂来获取代理对象
        RentingHouseImpl cglibProxy = (RentingHouseImpl)ProxyFactory.getInstance().
           												 getCglibProxy(rentingHouse);
        cglibProxy.rentHosue();
    }
}

动态代理完成对事务控制：

在不改变原有业务代码的前提下增强横切逻辑。

ProxyFactory 代理⼯⼚类

public class ProxyFactory {
    private ProxyFactory(){

    }

    private static ProxyFactory proxyFactory = new ProxyFactory();

    public static ProxyFactory getInstance() {
        return proxyFactory;
    }


    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.getInstance().beginTransaction();
                            result = method.invoke(obj,args);
                            //提交事务
                            TransactionManager.getInstance().commitTransaction();
                        }catch(Exception e){
                            System.out.println("事务回滚");
                            e.printStackTrace();
                            //回滚事务
                            TransactionManager.getInstance().rollBackTransaction();
                            throw e;
                        }
                        return result;
                    }
            });        
    }
}

servlet调用方式修改：

//从工厂获取委托对象（委托对象是增强了事务控制的功能
private TransferService transferService = (TransferService) ProxyFactory.getInstance().
    									getJdkProxy(BeanFactory.getBean("transferService"));

修改完成：

在这里插入图片描述

根据上图，修改bean.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--根标签beans  里面配置一个有一个bean的子标签 每个bean子标签代表一个类的配置-->
<beans>
    <!--id标识对象  class是类的全限定类名-->
    <bean id ="accountDao" class="com.lagou.edu.dao.impl.JdbcAccountDaoImpl">
        <property name="ConnectionsUtils" ref = "connectionsUtils"></property>
    </bean>
    <bean id ="transferService"  class="com.lagou.edu.service.impl.TransferServiceImpl">
        <!--set+name 之后锁定到传值的set方法  通过反射技术调用该方法传入对应的值-->
        <property name="AccountDao" ref = "accountDao"></property>
    </bean>
    <!--配置新增的三个bean-->
    <bean id ="connectionsUtils" class="com.lagou.edu.utils.ConnectionsUtils"></bean>
    <!--事务管理器-->
    <bean id ="transactionManager" class="com.lagou.edu.utils.TransactionManager">
        <property name="ConnectionsUtils" ref = "connectionsUtils"></property>
    </bean>
    <!--代理对象工厂-->
    <bean id ="proxyFactory" class="com.lagou.edu.dao.factory.ProxyFactory">
        <property name="TransactionManager" ref = "transactionManager"></property>
    </bean>
</beans>

servlet获取到peoxyFactory代理工厂的实例化对象

 private ProxyFactory proxyFactory = (ProxyFactory) BeanFactory.getBean("proxyFactory");
 private TransferService transferService = (TransferService) proxyFactory.
    									 getJdkProxy(BeanFactory.getBean("transferService"));