简介

一般来说，Spring指的是SpringFramework，它提供了很多功能，例如：控制反转（IOC）、依赖注入

（DI）、切面编程（AOP）、事务管理（TX）

主要 jar 包

• org.springframework.core：Spring的核心工具包，其他包依赖此包
• org.springframework.beans：所有应用都用到，包含访问配置文件，创建和管理bean等
• org.springframework.aop：Spring的面向切面编程，提供AOP的实现
• org.springframework.context：提供在基础IOC功能上的扩展服务，此外还提供许多企业级服务的支持（邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存等）
• org.springframework.web.mvc：包含SpringMVC应用开发时所需的核心类
• org.springframework.transaction：为JDBC、Hibernate、JPA提供一致的声明式和编程式事务管理
• org.springframework.web：包含web应用开发时，用到的Spring框架时所需的核心类
• org.springframework.aspect：Spring提供的对Aspect框架的整合
• org.springframework.test：对JUNIT等测试框架的简单封装
• org.springframework.context.support：Spring context的扩展支持，用于MVC方面
• org.springframework.expression：Spring表达式语言
• org.springframework.jdbc：对JDBC的简单封装
• org.springframework.web.servlet：对J2EE6.0 servlet3.0的支持

IOC（控制反转）

组件和组件管理

整个项目由各种组件搭建而成

在Spring中，组件交给Spring容器进行管理，代替程序员之前new对象的操作，控制对象的创建，管理对象的生命周期

优势

• 降低了组件之间的耦合性：Spring IoC容器通过依赖注入机制，将组件之间的依赖关系削弱，减少了程序组件之间的耦合性
• 提高了代码的可重用性和可维护性：将组件的实例化过程、依赖关系的管理等功能交给Spring IoC容器处理，使得组件代码更加模块化、可重用、更易于维护。
• 方便了配置和管理：Spring IoC容器通过XML文件或者注解，轻松的对组件进行配置和管理，使得组件的切换、替换等操作更加的方便和快捷

容器管理配置方式

• XML配置文件：在XML文件中定义Bean及其依赖关系、Bean的作用域等信息，让Spring IoC容器来管理Bean之间的依赖关系
• 注解方式配置：通过在Bean类上使用注解来代替XML配置文件中的配置信息。通过在Bean类上加上相应的注解（如@Component, @Service, @Autowired等），将Bean注册到Spring IoC容器中
• Java配置类配置：通过Java类来定义Bean、Bean之间的依赖关系和配置信息，通过@Configuration、@Bean等注解来实现Bean和依赖关系的配置

实例化方式

• 构造器实例化
• 在配置文件中定义bean（对应bean中要有空参构造）
• <bean id="" class=""> <property name="" value=""/> </bean>
• 编写构造器
• 获取实例化对象
• public void test1(){ ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = context.getBean(UserService.class); }
• 静态工厂实例化
• <bean id="user4" class="com.sxny.pojo.User" factory-method="createInstance"/>
• 实例化工厂实例化
• <bean id="userFactory" class="com.sxny.pojo.UserFactory"></bean> <bean id="user5" factory-bean="userFactory" factory-method="createUser"/> <bean id="book2" name="book3,book4" class="com.sxny.pojo.Book">

Spring Bean

指被Spring容器管理的对象

将一个类声明为Bean的注解

• @Component：通用的注解，可标记任何类为Spring组件
• @Service：对应服务层，主要涉及一些复杂的逻辑
• @Repository：对应持久层，主要用于数据库相关操作
• @Controller：对应SpringMVC控制层，主要用于接收用户请求，并调用Service层，返回数据给前端
• @Component和@Bean
• @Component 作用于类，@Bean作用于方法
• @Bean 比 @Component 的自定义性更强，有些地方只能用 @Bean 注解来注册bean，如：当我们需要引用第三方库中的类，需要装配到Spring容器中时，只能通过 @Bean 注解实现

Bean 的作用域

• singleton：容器中只有唯一的bean实例，Spring中bean默认都是单例的（默认）
• prototype：每次获取bean时都会创建一个新的bean实例
• request（仅web应用可用）：每次http请求都会产生一个新的bean，仅在该HTTP Request内生效
• session（仅web应用可用）：每一次来自新 session 的 HTTP 请求都会产生一个新的 bean，仅在当前 HTTP session 内有效

Bean 的生命周期

实例化 -> 属性赋值 -> 初始化 -> 销毁

在实例化阶段，Spring容器通过反射机制创建Bean，然后进行依赖注入，如果Bean实现了BeanNameAware等接口，容器会调用相应方法

在初始化阶段，BeanPostProcessor会在前后进行拦截处理，最后调用初始化方法，例如@PostConstruct或afterPropertiesSet

销毁时则会调用DisposeableBean.destory()或自定义的销毁方法

DI（依赖注入）

在组件之间传递依赖关系的过程中，将依赖关系放入容器内部进行处理，降低依赖关系，实现了对象间的解耦合

实现方式

1. 通过构造器注入（对应类中必须有对应的构造函数）
2. <bean id="user" class="com.pojo.User"> <constructor-arg name="id" value="1"/> <constructor-arg name="name" value="张三"/> <constructor-arg name="sex" value="18"/> </bean>
3. 通过setter方法注入
4. <bean id="book" class="com.pojo.Book"> <property name="name" value="1"/> <property name="bid" value="2"/> </bean>
5. 通过字段注入
6. 通过字段注入，也就是通过注解进行注入（@Autowired、@Resource）

@Autowired 和 @Resource 的区别

• @Autowired是 Spring 提供的注解，默认的注入方式是按照类型进行匹配，也就是说会优先通过接口类型去匹配并注入bean，当接口存在多个实现类时，byType这种方式就无法正确注入对象了，可以通过结合@Qualifier注解来显式指定名称
• @Resource是JDK提供的注解，默认注入方式是按照名称进行匹配，如果无法通过名称匹配到对应的bean，就会按照类型来匹配
• @Autowired支持在构造方法、方法、字段、参数上使用，@Resource用于字段和方法上的使用，不支持在构造方法和参数使用

AOP（面向切面编程）

横向编程，在不改变核心业务逻辑的情况下，对一些功能进行增强（常用在日志管理、权限控制、事务处理、安全控制）

Spring AOP的底层原理

基于JDK的动态代理实现、基于cglib的字节码生成实现

AOP 的底层是两种动态代理都有，默认情况下，如果目标类实现了一个或多个接口，AOP自动采用的是JDK动态代理进行增强，如果目标类没有实现接口，AOP采用cglib字节码生成的方式来增强，当然，也可用强制使用cglib字节码生成的方式进行增强，这样就不用考虑目标类是否实现了接口

基本概念

• join point（连接点）：目标类中的所有方法
• pointcut（切点）：对哪些方法进行拦截
• advice（通知）：拦截到方法要干什么
• aspect（切面）：通知和切点的结合
• target（目标）：被代理的目标对象

Spring AOP 和AspectJ AOP

Spring AOP属于运行时增强，AspectJAOP属于编译时增强，SpringAOP是基于代理，AspectJAOP是基于字节码操作，切面比较少时，没有太大区别，切面较多时，建议使用AspectJAOP

通知类型

• 前置通知：在被代理的目标方法前执行
• 后置通知：在被代理的目标方法最终结束后执行
• 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置
• 异常通知：在被代理的目标方法异常结束后执行
• 返回通知：在被代理的目标方法成功结束后执行

可以通过XML配置或者注解的方式实现

实现

1. 导包（添加依赖）
2. 通过注解或者XML配置
3. // 通过注解方式 // @Aspect表示这个类是一个切面类 @Aspect // @Component注解保证这个切面类能够放入IOC容器 @Component public class LogAspect { // @Before注解：声明当前方法是前置通知方法 // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上 @Before(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))") public void printLogBeforeCore() { System.out.println("[AOP前置通知] 方法开始了"); } @AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))") public void printLogAfterSuccess() { System.out.println("[AOP返回通知] 方法成功返回了"); } @AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))") public void printLogAfterException() { System.out.println("[AOP异常通知] 方法抛异常了"); } @After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))") public void printLogFinallyEnd() { System.out.println("[AOP后置通知] 方法最终结束了"); } }
4. 开启aspectj注解支持
5. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 进行包扫描--> <context:component-scan base-package="com.atguigu" /> <!-- 开启aspectj框架注解支持--> <aop:aspectj-autoproxy /> </beans>

TX（事务）

一系列动作中，只要有一个出现问题，所有动作全部回滚到事务开始的状态，避免了数据不一致导致的错误

对应依赖

• spring-tx：包含声明式事务实现的基本规范（事务管理器规范接口和事务增强等等）
• spring-jdbc：包含DataSource方式事务管理器实现类DataSourceTransactionManager
• spring-orm：包含其他持久层框架的事务管理器实现类例如：Hibernate/Jpa等

底层原理

对事务的操作本来是由数据库进行的，但是为了方便用户进行业务逻辑的控制，Spring对事务进行了扩展实现； 在Spring中，事务是通过AOP代理实现的，对被代理对象的每个方法进行拦截，在方法执行前启动事务，在方法执行完成后根据是否有异常及异常的类型进行提交或回滚。

核心接口：
PlatFormTransactionManager

编程式事务和声明式事务

• 编程式事务：在代码中硬编码，通过TransactionTemplate或者TransactionManager手动管理事务
• 声明式事务：在XML文件中进行配置或通过注解实现

四个特性

• 原子性：事务包含的所有数据库操作，要么全部成功，要么失败全部回滚
• 一致性：事务必须使数据库从一个一致性状态转换为另一个一致性状态
• 持久性：事务一旦提交，对数据的改变是永久性的
• 隔离性：当多个用户并发访问数据库时，多个并发事务之间要相互隔离，不被其他事务操作所干扰

事务属性

只读（readonly）

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。

// readOnly = true把当前事务设置为只读 默认是false!
@Transactional(readOnly = true)

超时（timeout）

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。设置超时属性，超时回滚，释放资源

@Service
public class StudentService {

    @Autowired
    private StudentDao studentDao;

    /**
     * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
     */
    @Transactional(readOnly = false,timeout = 3)
    public void changeInfo(){
        studentDao.updateAgeById(100,1);
        //休眠4秒,等待方法超时!
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        studentDao.updateNameById("test1",1);
    }
}

事务异常（rollbackFor）

默认只针对运行时异常，编译时异常不回滚

• 设置回滚异常（rollbackFor）
• /** * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间! * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚! * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内! */ @Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class) public void changeInfo() throws FileNotFoundException { studentDao.updateAgeById(100,1); //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内! new FileInputStream("xxxx"); studentDao.updateNameById("test1",1); }
• 设置不回滚的异常（norollbackFor）
• @Service public class StudentService { @Autowired private StudentDao studentDao; /** * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间! * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚! * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内! */ @Transactional(readOnly = false,timeout = 3,rollbackFor = Exception.class,noRollbackFor = FileNotFoundException.class) public void changeInfo() throws FileNotFoundException { studentDao.updateAgeById(100,1); //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内! new FileInputStream("xxxx"); studentDao.updateNameById("test1",1); } }

事务隔离级别

• 读未提交：事务可以读取未被提交的数据，容易产生脏读、不可重复读和幻读等问题。实现简单但不太安全，一般不用。
• 读已提交：事务只能读取已经提交的数据，可以避免脏读问题，但可能引发不可重复读和幻读。
• 可重复读：在一个事务中，相同的查询将返回相同的结果集，不管其他事务对数据做了什么修改。可以避免脏读和不可重复读，但仍有幻读的问题。
• 可串行化：最高的隔离级别，完全禁止了并发，只允许一个事务执行完毕之后才能执行另一个事务。可以避免以上所有问题，但效率较低，不适用于高并发场景。
  
  

隔离级别的设置（isolation）

@Service
public class StudentService {

    @Autowired
    private StudentDao studentDao;

    /**
     * timeout设置事务超时时间,单位秒! 默认: -1 永不超时,不限制事务时间!
     * rollbackFor = 指定哪些异常才会回滚,默认是 RuntimeException and Error 异常方可回滚!
     * noRollbackFor = 指定哪些异常不会回滚, 默认没有指定,如果指定,应该在rollbackFor的范围内!
     * isolation = 设置事务的隔离级别,mysql默认是repeatable read!
     */
    @Transactional(readOnly = false,
                   timeout = 3,
                   rollbackFor = Exception.class,
                   noRollbackFor = FileNotFoundException.class,
                   isolation = Isolation.REPEATABLE_READ)
    public void changeInfo() throws FileNotFoundException {
        studentDao.updateAgeById(100,1);
        //主动抛出一个检查异常,测试! 发现不会回滚,因为不在rollbackFor的默认范围内!
        new FileInputStream("xxxx");
        studentDao.updateNameById("test1",1);
    }
}

事务传播行为

• REQUIRED：如果存在一个事务，则支持当前事务，不存在，则创建一个新事务
• REQUIRED_NEW：开启一个新事务，如果已存在事务，则挂起当前事务
• SUPPORTS：如果当前存在事务，则支持当前事务，不存在，则以非事务的方式执行
• NOT_SUPPORTED：总是以非事务的方式执行，并挂起任何已存在的事务
• NAVER：总是以非事务的方式执行，若已存在事务，则抛出异常
• NESTED：如果一个事务已存在，则运行在一个嵌套事务中
• MANDATORY：如果已存在事务，则支持当前事务，如果不存在，则抛出异常

通过XML进行配置

<!--    配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    <tx:annotation-driven transaction-manager="transactionManager"/>-->
    <tx:advice id="interceptor" transaction-manager="transactionManager">
        <tx:attributes>
<!--            精确-->
            <tx:method name="addUser" propagation="MANDATORY"/>
<!--            半模糊-->
            <tx:method name="update" propagation="REQUIRES_NEW"/>
<!--            全模糊-->
            <tx:method name="*" read-only="true"/>
        </tx:attributes>
    </tx:advice>

通过注解实现

@Transactional(rollbackFor = Exception.class,propagation = Propagation.NESTED)
@Override
public void updateBook() {
    bookMapper.updateBook();
}

懒加载

默认为false，Spring会在容器初始化时，解析XML或注解，创建配置为单例的Bean并放入map中，懒加载可以使bean在被调用时才被创建（只对单例的生效，因为多例的bean本来就是在被调用时才会创建）