Spring 框架总结笔记

第一章初识Spring

1.1 Spring简介

Spring是一个为简化企业级开发而生的开源框架。
Spring是一个IOC(DI)和AOP容器框架。
IOC全称：Inversion of Control【控制反转】
- 将对象【万物皆对象】控制权交个Spring
DI全称：(Dependency Injection)：依赖注入
AOP全称：Aspect-Oriented Programming，面向切面编程
官网：https://spring.io/

1.2 搭建Spring框架步骤

导入spring的jar包

<!--导入spring-context-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>
<!--导入junit4.12-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

编写spring核心配置文件

配置文件的名称：applicationContext.xml【beans.xml或spring.xml】
配置文件的路径：src/main/resources

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!-- 将对象装配到IOC容器中-->
    <bean id="stu01" class="com.atguigu.pojo.Student">
        <!--给对象的属性赋值-->
        <property name="stuId" value="101"></property>
        <property name="stuName" value="zhangsan"></property>
    </bean>
</beans>

使用核心类库

//测试
import com.atguigu.pojo.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring {
    @Test
    public void test01(){
        //使用Spring之前
        //Student student = new Student();
        //使用Spring之后
        //创建容器对象
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //通过容器对象，获取需要的对象
        Student stu01 = (Student)ioc.getBean("stu01");
        System.out.println("stu01 = " + stu01);
    }
}

注意：xml的两种约束，dtd和xsd格式

1.3 Spring特性

非侵入性：基于Spring开发的应用中的对象可以不依赖于Spring的API。
- 侵入性：例如Servlet，一个Java类想成为Servlet，必须实现或继承Servlet API，这些代码不能直接脱离框架使用，不利于代码的复用。
控制反转：IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建。
依赖注入：DI——Dependency Injection，指依赖的对象不需要手动调用set方法去设置，而是通过配置赋值。
面向切面编程：AOP——Aspect Oriented Programming，在不修改源代码的基础上进行功能扩展。
容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期。
组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。
一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的JDBCTemplate）。

1.4 Spring中getBean()三种方式

getBean(String beanId)：通过bean的Id获取对象

不足之处：需要强制类型转换，不灵活

//通过bean的Id获取需要的对象
Student stu01 = (Student)ioc.getBean("stu01");
System.out.println("stu01 = " + stu01);

getBean(Class clazz)：通过Class方式获取对象
- 不足之处：容器中有多个相同类型bean的时候，会报如下错误：
  
  expected single matching bean but found 2: stu01,stu02
```
//通过Class方式获取对象
Student bean = ioc.getBean(Student.class);
System.out.println("bean = " + bean);
```
getBean(String beanId,Clazz clazz)：通过beanId和Class获取对象(主要使用的方法)
```
//通过bean的id和Class获取对象
Student stu02 = ioc.getBean("stu02", Student.class);
System.out.println("stu02 = " + stu02);
```
注意：在框架中默认都是通过无参构造器帮助我们创建对象，所以在提供对象时一定需要注意添加无参构造器

1.5 bean标签详解

属性
- id：bean的唯一标识
- class：定义bean的类型【class全类名】

子标签

property：为对象中属性赋值【set注入】
- name属性：设置属性名称
- value属性：设置属性数值

<bean id="stu01" class="com.atguigu.pojo.Student">
    <property name="stuId" value="101"></property>
    <property name="stuName" value="zhangsan"></property>
</bean>

第二章 Spring IOC底层实现

IOC：将对象的控制器反转给Spring

2.1 BeanFactory与ApplicationContexet接口

BeanFactory：IOC容器的基本实现，是Spring内部的使用接口，是面向Spring本身的，不是提供给开发人员使用的。
ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。

2.2 图解IOC类的结构

BeanFactory：Spring底层IOC实现【面向Spring框架】
- ...
  - ApplicationContext：面向程序员
    - ConfigurableApplicationContext：提供关闭或刷新容器对象方法
      - ...
        
        ClassPathXmlApplicationContext：基于类路径检索xml文件
        
        AnnotationConfigApplicationContext：基于注解创建容器对象
        
        FileSystemXmlApplicationContext：基于文件系统检索xml文件

第三章 Spring依赖注入数值问题【重点】

3.1 字面量数值

字面量是用于表达源代码中一个固定值的表示法。
基本数据类型及其包装类型、String等类型都可以采取字面值注入的方式。

语法：value属性或value标签解决的都是字面量数值

<bean id="stu01" class="com.atguigu.pojo.Student">
    <property name="stuId" value="101"></property>
    <property name="stuName">
        <value>zhangsan</value>
    </property>
</bean>

3.2 CDATA区

语法：<![CDATA[]]>

作用：在xml中定义特殊字符时，使用CDATA区

<bean id="stu02" class="com.atguigu.pojo.Student">
    <property name="stuId" value="102"></property>
    <property name="stuName">
        <value><![CDATA[<<lisi>>]]></value>
    </property>
</bean>

3.3 外部已声明bean及级联属性赋值

注意：级联属性更改数值会影响外部声明bean【ref赋值的是引用，用的是同一地址】

<!--外部已声明bean-->
<bean id="dept1" class="com.atguigu.pojo.Dept">
    <property name="deptId" value="1"></property>
    <property name="deptName" value="研发部门"></property>
</bean>
<bean id="empLi" class="com.atguigu.pojo.Employee">
    <property name="id" value="101"></property>
    <property name="lastName" value="li"></property>
    <property name="email" value="li@163.com"></property>
    <property name="salary" value="50.5"></property>
    <!--使用ref属性引用外部bean-->
    <property name="dept" ref="dept1"></property>
    <!--在级联属性中修改数值会影响外部声明的bean的值-->
    <property name="dept.deptName" value="财务部门"></property>
</bean>

3.4 内部bean

概述
- 内部类：在一个类中完整定义另一个类，当前类称之为内部类
- 内部bean：
  - 在一个bean中完整定义另一个bean，当前bean称之为内部bean
  - 修改内部bean的值不会影响到已声明的外部bean的值

注意：内部bean是不会直接装配到IOC容器中，所以为内部bean指定id属性也无意义，也无法直接通过内部bean的id获取，但可先获取到外部bean，再通过外部bean来获取内部

<!--测试内部bean-->
<bean id="empXin" class="com.atguigu.pojo.Employee">
    <property name="id" value="102"></property>
    <property name="lastName" value="xx"></property>
    <property name="email" value="xx@163.com"></property>
    <property name="salary" value="51.5"></property>
    <property name="dept">
        <bean class="com.atguigu.pojo.Dept">
            <property name="deptId" value="2"></property>
            <property name="deptName" value="人事部门"></property>
        </bean>
    </property>
</bean>

测试代码：

//测试内部bean
@Test
public void test01(){
    //创建容器对象
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //通过容器对象，获取需要的对象
   
    Employee empXin = ioc.getBean("empXin", Employee.class);
    System.out.println("empXin = " + empXin);
}

3.5 集合

List

<!--在Dept对象中添加成员属性：private List<Employee> empList;  -->
<!--方式一-->
<!--测试List集合-->
<bean id="dept3" class="com.atguigu.pojo.Dept">
    <property name="deptId" value="3"></property>
    <property name="deptName" value="程序员鼓励师"></property>
    <property name="empList">
        <list>
            <!--引用外部已声明的bean-->
            <ref bean="empLi"></ref>
            <ref bean="empXin"></ref>
        </list>
    </property>
</bean>

<!--方式二-->
<!--测试提取List-->
<!--使用util标签时需要导入相关的命名空间和约束，在IDEA中可使用ALT+Enter快捷键-->
<util:list id="empList">
    <ref bean="empLi"></ref>
    <ref bean="empXin"></ref>
</util:list>
<bean id="dept4" class="com.atguigu.pojo.Dept">
    <property name="deptId" value="4"></property>
    <property name="deptName" value="运营部门"></property>
    <!--引用外部提取的List-->
    <property name="empList" ref="empList"></property>
</bean>

测试代码：

@Test
public void test01(){
    //创建容器对象
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
    //通过容器对象，获取需要的对象
    //测试List集合
    Dept dept3 = ioc.getBean("dept3", Dept.class);
    System.out.println("dept3 = " + dept3);
	//测试引用外部提取的List集合
    Dept dept4 = ioc.getBean("dept4", Dept.class);
    System.out.println("dept4 = " + dept4);
}

Map

<!--在Dept对象中添加成员属性：private Map<Integer,Employee> empMap;  -->
<!--方式一-->
<!--测试Map-->
<bean id="dept5" class="com.atguigu.pojo.Dept">
    <property name="deptId" value="5"></property>
    <property name="deptName" value="采购部门"></property>
    <property name="empMap">
        <map>
            <!--赋值方式一 ，因为引用的是一个对象所以使用value-ref属性-->
            <entry key="101" value-ref="empLi"></entry>
            <!--赋值方式二-->
            <entry>
                <key><value>103</value></key>
                <ref bean="empLi"></ref>
            </entry>
            <entry>
                <key><value>102</value></key>
                <ref bean="empXin"></ref>
            </entry>
        </map>
    </property>
</bean>

<!--方式二-->
<!--提取Map集合-->
<util:map id="empMap">
    <entry key="101" value-ref="empLi"></entry>
    <entry>
        <key><value>103</value></key>
        <ref bean="empLi"></ref>
    </entry>
    <entry>
        <key><value>102</value></key>
        <ref bean="empXin"></ref>
    </entry>
</util:map>
<bean id="dept6" class="com.atguigu.pojo.Dept">
    <property name="deptId" value="106"></property>
    <property name="deptName" value="后勤部门"></property>
    <!--引用外部Map集合-->
    <property name="empMap" ref="empMap"></property>
</bean>

第四章 Spring依赖注入方式【基于XML】

为属性赋值的方式：

通过set()方法
通过构造器
通过反射

4.1 set注入

使用<property></property>标签时调用的是对象的set方法来赋值

<bean id="stu03" class="com.atguigu.pojo.Student">
    <!--set注入-->
    <property name="stuId" value="103"></property>
    <property name="stuName" value="wangwu"></property>
</bean>

4.2 构造器注入

使用<constructor-arg></constructor-arg>标签时调用的是对象的构造器来赋值

若没有相对应的构造器，则会报错

<bean id="stu03" class="com.atguigu.pojo.Student">
    <!--构造器注入-->
    <constructor-arg name="stuId" value="103"></constructor-arg>
    <constructor-arg name="stuName" value="wangwu"></constructor-arg>
</bean>

4.3 p名称空间注入

需要 xml文件中先导入名称空间：xmlns:p="http://www.springframework.org/schema/p"

p名称空间注入调用的是对象的有参构造方法

<!--构造器注入-->
<bean id="stu04" class="com.atguigu.pojo.Student" p:stuId="104" p:stuName="zhaoliu"></bean>

第五章 Spring管理第三方bean【druid】

5.1 Spring管理druid的步骤

导入druid的jar包

<!--导入druid的jar包-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>
<!--导入mysql的jar包-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.37</version>
    <!--mysql8驱动的jar包-->
    <!--<version>8.0.26</version>-->
</dependency>

编写db.properties配置文件

#key=value
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3307/mybatis
db.username=root
db.password=root

编写applicationContext_druid.xml（自定义文件名）配置文件

<?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"
       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">
    <!--加载外部属性文件db.properties-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--装配数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driverClassName}"/>
        <property name="url" value="${db.url}"/>
        <property name="username" value="${db.username}"/>
        <property name="password" value="${db.password}"/>
    </bean>
</beans>

测试

    @Test
    public void testDruidDataSource() throws Exception{
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_druid.xml");
        //获取容器对象（数据库密码错误等也可获取容器对象）
        DruidDataSource dataSource = ioc.getBean("dataSource", DruidDataSource.class);
        //获取连接成功才算连接上数据库
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
    }

第六章 Spring中的FactoryBean

6.1 Spring中的两种bean

一种是普通的bean
- 返回类型：普通bean设置的类型就是返回的类型
另一种是工厂bean【FactoryBean】
- 作用：如需程序员参与到bean的创建时，可使用FactoryBean工厂bean
- 返回类型：返回的类型通过该工厂bean的getObject方法指定

6.2 FactoryBean使用步骤

实现FactoryBean接口

重写FactoryBean的方法【三个】

package com.atguigu.factory;

import com.atguigu.pojo.Dept;
import org.springframework.beans.factory.FactoryBean;

//实现FactoryBean接口并重写三个方法
//以Dept对象为例
public class MyFactoryBean implements FactoryBean<Dept> {
    /**
     * getObject():参与对象创建的方法
     * @return
     * @throws Exception
     */
    @Override
    public Dept getObject() throws Exception {
        Dept dept = new Dept(101, "研发部门");
        return dept;
    }

    /**
     * 设置返回的参与对象Class
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return Dept.class;
    }

    /**
     * 设置当前对象是否为单例
     * @return
     */
    @Override
    public boolean isSingleton() {
        return true;
    }
}

装配工厂bean

创建并编写applicationContext_fatorybean.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!--装配工厂bean-->
    <bean id="myFactoryBean" class="com.atguigu.factory.MyFactoryBean"></bean>
</beans>

测试

@Test
public void testFactoryBean(){
    ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_fatorybean.xml");
    Dept myFactoryBean = ioc.getBean("myFactoryBean", Dept.class);
    System.out.println("myFactoryBean = " + myFactoryBean);
}

第七章 Spring中bean的作用域

7.1 语法

在bean标签中添加属性：scope属性即可

7.2 四个作用域

singleton【默认值】：单例【在容器中只有一个对象】
- 在Spring的IOC容器中仅存在一个Bean实例
- 对象创建时机：创建容器对象时就创建了bean实例对象
prototype：多例【在容器中有多个对象】
- 每次调用getBean方法时都会返回一个新的Bean实例
- 对象创建时机：使用getBean()方法获取实例时创建对象
request：请求域
- 每次HTTP请求都会创建一个新的Bean实例
session：会话域
- 同一个Session会话共享一个Bean实例

测试：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="stu01" class="com.atguigu.pojo.Student" scope="prototype">
        <property name="stuId" value="101"></property>
        <property name="stuName" value="zhangsan"></property>
    </bean>
</beans>

    @Test
    public void test01(){
        //单例模式时，在创建容器对象时创建实例
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_scope.xml");
        //多例模式时，在getBean时创建实例
        Student stu01 = ioc.getBean("stu01", Student.class);
        Student stu02 = ioc.getBean("stu01",Student.class);
        //使用==来对比地址，确定是否为同一对象
        //模式为单例时，结果为true
        //模式为多例时，结果为false
        System.out.println("是否为同一对象：" + (stu01==stu02));
    }

第八章 Spring中bean的生命周期

8.1 bean的生命周期

① 通过构造器或工厂方法创建bean实例

② 为bean的属性设置值和对其他bean的引用

③ 调用bean的初始化方法

④ bean可以使用了

⑤ 当容器关闭时，调用bean的销毁方法

Student对象

package com.atguigu.pojo;

public class Student {
    private Integer stuId;
    private String stuName;
	//手动添加的对象初始化方法
    public void initStudent(){
        System.out.println("3.初始化方法！！！");
    }
	//手动添加的对象销毁方法
    public void destoryStudent(){
        System.out.println("5.bean的销毁方法！！！");
    }
    public Student(Integer stuId, String stuName) {
        this.stuId = stuId;
        this.stuName = stuName;
    }

    public Student() {
        System.out.println("1.无参构造器创建实例");
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuId=" + stuId +
                ", stuName='" + stuName + '\'' +
                '}';
    }

    public Integer getStuId() {
        return stuId;
    }

    public void setStuId(Integer stuId) {
        System.out.println("2.set方法为bean的属性设置值");
        this.stuId = stuId;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
}

applicationContext_lifeCycle.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
	<!--init-method指定bean的初始化方法-->
    <!--destroy-method指定bean的销毁方法-->
    <bean id="student"
          class="com.atguigu.pojo.Student"
            init-method="initStudent"
            destroy-method="destoryStudent">
        <property name="stuId" value="101"/>
        <property name="stuName" value="zhangsan"/>
    </bean>
</beans>

测试代码

@Test
public void test02(){
    //ConfigurableApplicationContext提供了关闭或刷新容器对象的方法
    ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_lifeCycle.xml");
    Student student = ioc.getBean("student", Student.class);
    System.out.println("4.使用bean：" + student);
    //关闭对象容器，调用销毁方法
    ioc.close();
}

8.2 bean的后置处理器

作用：在调用初始化方法前后对bean进行额外的处理。
实现：
- 实现BeanPostProcessor接口
- 重写方法
  - postProcessBeforeInitialization(Object, String)：在bean的初始化之前执行
  - postProcessAfterInitialization(Object, String)：在bean的初始化之后执行
- 在容器中装配后置处理器
注意：装配后置处理器会为当前容器中每个bean均装配，不能为局部bean装配后置处理器

实现BeanPostProcessor接口并重写方法

package com.atguigu.processor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.lang.Nullable;

public class MyPostProcessor implements BeanPostProcessor {
    /**
     * bean的初始化之前执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("==>Bean的初始化之前执行！！！");
        return bean;
    }

    /**
     * bean的初始化之后执行
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    @Nullable
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("==>Bean的初始化之后执行！！！");
        return bean;
    }
}

装配后置处理器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--bean的生命周期-->
    <bean id="student"
          class="com.atguigu.pojo.Student"
            init-method="initStudent"
            destroy-method="destoryStudent">
        <property name="stuId" value="101"/>
        <property name="stuName" value="zhangsan"/>
    </bean>
    <!--装配后置处理器-->
    <bean id="myPostProcessor" class="com.atguigu.processor.MyPostProcessor">
    </bean>
</beans>

测试代码

    @Test
    public void test02(){
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_lifeCycle.xml");
        Student student = ioc.getBean("student", Student.class);
        System.out.println("4.使用bean：" + student);
        ioc.close();
    }

8.3 添加后置处理器后bean的生命周期

① 通过构造器或工厂方法创建bean实例

② 为bean的属性设置值和对其他bean的引用

postProcessBeforeInitialization(Object, String)：在bean的初始化之前执行

③ 调用bean的初始化方法

postProcessAfterInitialization(Object, String)：在bean的初始化之后执行

④ bean可以使用了

⑤ 当容器关闭时，调用bean的销毁方法

第九章 Spring中自动装配【基于XML】

9.1 Spring中提供两种装配方式

手动装配
自动装配

9.2 Spring自动装配语法及规则

在bean标签中添加属性：Autowire即可
- byName：对象中属性名称与容器中bean的Id属性值进行匹配，如果属性名与beanId数值一致，则自动装配成功
- byType：对象中属性类型与容器中bean的class属性值进行匹配，如果唯一匹配则自动装配成功
  - 匹配0个：未装配
  - 匹配多个，会报错
    
    expected single matching bean but found 2: deptDao,deptDao2
注意：基于XML方式的自动装配，只能装配非字面量数值

9.3 总结

基于xml自动装配，底层使用set注入
最终：不建议使用byName、byType，建议使用注解方式自动装配

第十章 Spring中注解【非常重要】

10.1 使用注解将对象装配到IOC容器中

约定：约束>配置【注解>XML】>代码

位置：在类上面标识

注意：

Spring本身不区分四个注解【四个注解本质是一样的@Component】，提供四个注解的目的只有一个：提高代码的可读性

只用注解装配对象，默认将类名首字母小写作为beanId

可以使用value属性，设置beanId；当注解中只使用一个value属性时，value关键字可省略

装配对象的四个注解
- @Component：装配普通组件到IOC容器
- @Repository：装配持久化层组件到IOC容器
- @Service：装配业务逻辑层组件到IOC容器
- @Controller：装配控制层|表示层组件到IOC容器

使用注解步骤

导入相关jar包【已导入】

开启组件扫描

<!--    开启组件扫描
        base-package：设置扫描注解包名【当前包及其子包】
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

使用注解标识组件

10.2 使用注解装配对象中属性【自动装配】

@Autowired注解
- 作用：自动装配对象中属性
- 装配原理：反射机制
- 装配方式
  - 先按照byType进行匹配
    - 匹配1个：匹配成功，正常使用
    - 匹配0个：
      - 默认【@Autowired(required=true)】报错
        
        /*expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)} */
      - @Autowired(required=false)，不会报错
    - 匹配多个
      - 再按照byName进行唯一筛选
        
        筛选成功【对象中属性名称==beanId】，正常使用
        
        筛选失败【对象中属性名称!=beanId】，报如下错误：
        
        //expected single matching bean but found 2: deptDao,deptDao2
- @Autowired中required属性
  - true【默认值】：表示被标识的属性必须装配数值，如未装配，会报错。
  - false：表示被标识的属性不必须装配数值，如未装配，不会报错。

@Qualifier注解

作用：配合@Autowired一起使用，将设置beanId名称装配到属性中

注意：

不能单独使用，需要与@Autowired一起使用
当容器中有多个不同beanid但类型相同的实例时，可通过使用Qualifier注解来指定获取哪个bean实例

@Service(value = "deptServiceImpl")
public class DeptServiceImpl implements DeptService {
    //使用Autowired注解自动装配deptDao，不装配则会报空指针异常
    @Autowired
    @Qualifier("deptDaoImpl")
    //@Qualifier("deptDaoImpl2")
    private DeptDao deptDao;
    @Override
    public void saveDept(Dept dept) {
        deptDao.insertDept(dept);
    }
}

@Value注解

作用：装配对象中属性【字面量数值】

@Component(value = "dept")
public class Dept {
    @Value("101")
    private Integer deptId;
    @Value("zhangsan")
    private String deptName;
}

第十一章 Spring中组件扫描

11.1 默认使用情况

<!--    开启组件扫描
        base-package：设置扫描注解包名【当前包及其子包】
-->
<context:component-scan base-package="com.atguigu"></context:component-scan>

11.2 包含扫描

注意：
- 使用包含扫描之前，必须设置use-default-filters="false"【关闭当前包及其子包的扫描】
- type属性：
  - annotation：设置被扫描注解的全类名
  - assignable：设置被扫描实现类的全类名

<!--开启组件扫描-->
<!--base-package:设置扫描注解包名【当前包及其子包】-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
    <!--开启包含扫描-->
    <!--扫描所有Repository注解-->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
    <!--根据实现类的全类名扫描-->
    <context:include-filter type="assignable" expression="com.atguigu.controller.DeptController"/>
</context:component-scan>

11.3 排除扫描

<!--开启组件扫描-->
<!--base-package:设置扫描注解包名【当前包及其子包】-->
<context:component-scan base-package="com.atguigu" use-default-filters="false">
<!--排除扫描-->
<!--排除扫描所有的Repository-->
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
<!--排除扫描单个类时可使用assignable模式-->
<context:exclude-filter type="assignable" expression="com.atguigu.controller.DeptController"/>
</context:component-scan>

第十二章 Spring完全注解开发【基于类对象】

12.1 完全注解开发步骤

创建配置类

在class上面添加注解

@Configuration：标识当前类是一个配置类，作用：代替XML配置文件
@ComponentScan：设置组件扫描当前包及其子包

package com.atguigu.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages = "com.atguigu")
public class SpringConfig {
}

使用AnnotationConfigApplicationContext容器对象

    @Test
    public void test01(){
        //使用AnnotationConfigApplicationContext创建容器对象
        ApplicationContext ioc = new AnnotationConfigApplicationContext(SpringConfig.class);
        DeptDaoImpl deptDaoImpl = ioc.getBean("deptDaoImpl", DeptDaoImpl.class);
        System.out.println("deptDaoImpl = " + deptDaoImpl);
    }

第十三章 Spring集成Junit4

13.1 集成步骤

导入jar包【spring-test-5.3.1.jar】

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <!--注意spring-test的版本要和spring-context的版本一致-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.1</version>
            <scope>test</scope>
        </dependency>

指定Spring的配置文件的路径【使用@ContextConfiguration注解】

指定Spring环境下运行Junit4的运行器【使用@RunWith注解】

import com.atguigu.pojo.Dept;
import com.atguigu.service.DeptService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//@ContextConfiguration注解等价于new ClassPathXmlApplicationContext
@ContextConfiguration(locations = "classpath:applicationContext_annotation.xml")
//RunWith注解等价于getBean方法
@RunWith(SpringJUnit4ClassRunner.class)
public class TestSpringJunit4 {
    @Autowired
    private DeptService deptService;
    @Test
    public void testService(){
        //使用注解后可替代下面的两行代码的功能
/*        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext_annotation.xml");
        DeptServiceImpl deptServiceImpl = ioc.getBean("deptServiceImpl", DeptServiceImpl.class);*/
        deptService.saveDept(new Dept());
    }
}

第十四章 AOP前奏

14.1 代理模式

作用：
- 代理对象可以扩展目标对象的功能
- 代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用

14.2 手动实现动态代理环境搭建

实现方式
- 基于接口实现动态代理： JDK动态代理
- 基于继承实现动态代理： Cglib、Javassist动态代理
实现动态代理关键步骤
- 一个类：Proxy
  - 概述：Proxy代理类的基类【类似Object】
  - 作用：newProxyInstance()：创建代理对象
- 一个接口：InvocationHandler
  - 概述：实现【动态织入效果】关键接口
  - 作用：invoke()，执行invoke()实现动态织入效果

14.3 手动实现动态代理关键步骤

注意：代理对象与实现类【目标对象】是"兄弟"关系，不能相互转换

创建类【为了实现创建代理对象工具类】
提供属性【目标对象：实现类】
提供方法【创建代理对象】
提供有参构造器【避免目标对为空】

测试代码：

//Calc接口
package com.atguigu.beforeaop;

public interface Calc {
    public int add(int a, int b);

    public int sub(int a, int b);
}

//Calc接口实现类
package com.atguigu.beforeaop;


public class CalcImpl implements Calc {

    @Override
    public int add(int a, int b) {
        System.out.println("计算中...");
        int result = a+b;
        return result;
    }

    @Override
    public int sub(int a, int b) {
        int result = a-b;
        return result;
    }
}

//自定义类
package com.atguigu.beforeaop;

import java.util.Arrays;

public class MyLogging {

    public static void beforeMethod(String methodName, Object[] args) {
        System.out.println("==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
    }

    public static void afterMethod(String methodName,Object rs){
        System.out.println("==>Calc中" + methodName + "方法(),结果：" + rs);
    }
}

//代理工具类
package com.atguigu.beforeaop;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//代理工具类
public class MyProxy {
    //成员属性，目标对象
    private Object target;
    //有参构造，确保target不为空
    public MyProxy(Object target) {
        this.target = target;
    }

    /**
     * 获取目标对象的代理对象
     * @return
     */
    public Object getProxyObject(){
        Object proxyObj = null;

        /**
         *  类加载器【ClassLoader loader】,目标对象类加载器
         *  目标对象实现接口：Class<?>[] interfaces,
         */
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //创建代理对象，使用匿名类实现InvocationHandler接口
        proxyObj = Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            @Override
            //执行invoke()实现动态带入效果
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //获取方法名【目标对象】
                String methodName = method.getName();
                //执行目标方法之前，执行指定的方法
                MyLogging.beforeMethod(methodName,args);
                //触发目标对象目标方法
                Object rs = method.invoke(target, args);
                //执行目标方法之后，执行指定的方法
                MyLogging.afterMethod(methodName,rs);
                return rs;
            }
        });
        return proxyObj;
    }
}

//测试实现动态代理
import com.atguigu.beforeaop.Calc;
import com.atguigu.beforeaop.CalcImpl;
import com.atguigu.beforeaop.MyProxy;
import org.junit.Test;

public class TestProxy {

    @Test
    public void testBeforeAop(){
        //目标对象
        CalcImpl calc = new CalcImpl();
        //代理工具类
        MyProxy myProxy = new MyProxy(calc);
        //获取代理对象
        Calc calcProxy = (Calc)myProxy.getProxyObject();
        System.out.println(calcProxy.getClass().getName());
        //测试方法
        int div = calcProxy.add(1, 2);
    }
}

第十五章 Spring中的AOP

15.1 AspectJ框架【AOP框架】

Java社区里最完整最流行的AOP框架。
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

15.2 使用AspectJ的步骤

添加jar包

pom.xml配置文件

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<!--导入AspectJ框架的jar包-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.3.1</version>
</dependency>

配置文件

开启组件扫描
开启AspectJ注解支持

applicationContext_aop.xml配置文件


<!--开启组件扫描-->
<context:component-scan base-package="com.atguigu"></context:component-scan>
<!--开启AspectJ注解支持-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

将自定义类上面添加注解
- @Component：将当前类标识为一个组件
- @Aspect：将当前类标识为切面类【非核心业务提取类】

将自定义类中的方法中添加通知注解【@Before注解】

自定义类 MyLogging.java


package com.atguigu.beforeaop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

import java.util.Arrays;
@Component  //将当前类标识为一个组件
@Aspect     //将当前类标识为【切面类】【非核心业务提取类】
public class MyLogging {
    /**
     * 在方法之前执行
     */
    //指定在执行com.atguigu.beforeaop.CalcImpl类的add方法之前执行beforeMethod方法
    @Before(value = "execution(public int com.atguigu.beforeaop.CalcImpl.add(int, int))")
    public void beforeMethod(JoinPoint joinPoint) {
        //获取方法名称
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
    }
}

测试

@Test
public void testAseptic(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext_aop.xml");
    Calc calc = context.getBean("calc", Calc.class);
    int add = calc.add(1, 2);
}

Calc 接口


package com.atguigu.beforeaop;

import org.springframework.stereotype.Repository;

@Repository
public interface Calc {
    /**
     * 加法运算
     * @param a
     * @param b
     * @return
     */
    public int add(int a, int b);
}

Calc 接口实现类 CalcImpl

package com.atguigu.beforeaop;

import org.springframework.stereotype.Component;

@Component("calc")
public class CalcImpl implements Calc {

    @Override
    public int add(int a, int b) {
        System.out.println("计算中...");
        int result = a+b;
        return result;
    }
}

15.3 Spring中AOP概述

AOP：Aspect-Oriented Programming，面向切面编程【面向对象的一种补充】
- 优势：
  - 解决代码分散问题
  - 解决代码混乱问题
OOP：Object-Oriented Programming，面向对象编程

15.4 Spring中AOP的相关术语

横切关注点：非核心业务代码，称之为横切关注点
切面(Aspect)：将横切关注点提取到类中，这个类称之为切面类
通知(Advice)：将横切关注点提取到类中之后，横切关注点更名为：通知
目标(Target)：目标对象，指的是需要被代理的对象【实现类(CalcImpl)】
代理(Proxy)：代理对象可以理解为中介
连接点(Joinpoint)：通知方法需要指定通知位置，这个位置称之为：连接点【通知之前】
切入点(pointcut)：通知方法需要指定通知位置，这个位置称之为：切入点【通知之后】

第十六章 AspectJ【AOP框架】详解

16.1 AspectJ 中切入点表达式

语法：@Before(value="execution(权限修饰符返回值类型包名.类名.方法名(参数类型))")
通配符
- 【*】
  - 可以代表任意权限修饰符&返回值类型
  - 可以代表任意包名、任意类名、任意方法名
- 【..】
  - 代表任意参数类型及参数个数

重用切入点表达式

使用@PointCut注解，提取可重用的切入点表达式

使用方法名()引入切入点表达式

package com.atguigu.beforeaop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

import java.util.Arrays;
@Component  //将当前类标识为一个组件
@Aspect     //将当前类标识为【切面类】【非核心业务提取类】
public class MyLogging {
    //提取重用的切入点表达式
    @Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
    public void myPointCut(){}
    /**
     * 前置通知
     */
    //使用方法名引入切入点表达式
    @Before(value = "myPointCut()")
    public void beforeMethod(JoinPoint joinPoint) {
        //获取方法名称
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
    }

    /**
     * 后置通知
     */
    //使用方法名引入切入点表达式
    //value参数可省略
    @After("myPointCut()")
    public static void afterMethod(JoinPoint joinPoint){
        //获取方法名称
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] rs = joinPoint.getArgs();
        System.out.println("==>Calc中" + methodName + "方法(),结果：" + rs);
    }
}

16.2 AspectJ【AOP框架】中的JoinPoint对象

JoinPont【切入点对象】

作用：

获取方法名称

//获取方法签名【方法签名=方法名+参数列表】
joinPoint.getSignature();
//获取方法名称
String methodName = joinPoint.getSignature().getName();

获取参数
```
Object[] args = joinPoint.getArgs();
```

16.3 ASpectJ中的通知

前置通知【@Before注解】

执行实际：指定方法执行之前执行【若目标方法中有异常，也会执行】

指定方法：切入点表达式设置位置

//重用切入点表达式
@Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
public void myPointCut(){}
/**
* 前置通知
*/
//使用方法名引入切入点表达式
@Before(value = "myPointCut()")
public void beforeMethod(JoinPoint joinPoint) {
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();
    System.out.println("【前置通知】==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
}

后置通知【@After】

执行时机：指定方法所有通知执行之后执行【若目标方法中有异常，也会执行】

//重用切入点表达式
@Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
public void myPointCut(){}
/**
* 后置通知
*/
@After(value = "myPointCut()")
public static void afterMethod(JoinPoint joinPoint){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] rs = joinPoint.getArgs();
    System.out.println("【后置通知】==>Calc中" + methodName + "方法(),结果：" + Arrays.toString(rs));
}

返回通知【@AfterReturnning】

执行时机：指定方法返回结果时执行【若目标方法中有异常，不执行】

注意事项：@AfterReturnning中的returning属性与入参中参数名一致

//重用切入点表达式
@Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
public void myPointCut(){}
/**
* 返回通知
*/
//pointcut属性的作用与value的作用一致
@AfterReturning(value = "myPointCut()",returning = "rs")
public void afterReturnning(JoinPoint joinPoint,Object rs){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();
    System.out.println("【返回通知】==>Calc中" + methodName + "方法(),结果：" +rs);
}

异常通知【@AfterThrowing】

执行时机：指定方法出现异常时执行，【若目标方法阿忠没有异常，不执行】

注意事项：@AfterThrowing中的throwing属性值与入参参数名一致

//重用切入点表达式
@Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
public void myPointCut(){}
/**
* 异常通知
*/
@AfterThrowing(value = "myPointCut()",throwing = "ex")
public void afterThrowing(JoinPoint joinPoint,Exception ex){
    //获取方法名称
    String methodName = joinPoint.getSignature().getName();
    //获取参数
    Object[] args = joinPoint.getArgs();
    System.out.println("【异常通知】==>Calc中" + methodName + "方法(),出现异常时执行！异常：" +ex);
}

总结：
- 有异常时的执行顺序：前置通知 => 异常通知 => 后置通知
- 无异常时的执行顺序：前置通知 => 返回通知 => 后置通知

环绕通知【前四个通知的整合】

注意：

参数类型中必须使用ProceedingJoinPoint，它是JoinPoint的子接口。
环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。若不调用则会导致通知被执行，但目标方法没有被执行。
环绕通知需要返回目标方法执行之后的结果，即调用ProceedingJoinPoint.proceed()的返回值，否则会出现异常

//重用切入点表达式
@Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
public void myPointCut(){}
/**
* 环绕通知
*/
@Around(value = "myPointCut()")
public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint){
    //获取方法名称
    String methodName = proceedingJoinPoint.getSignature().getName();
    //获取参数
    Object[] args = proceedingJoinPoint.getArgs();
    //定义返回值
    Object result = null;
    try {
        //前置通知
        System.out.println("【环绕通知中的前置通知】==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
        //触发目标对象的目标方法
        result = proceedingJoinPoint.proceed();
        //返回通知【有异常不执行】
        System.out.println("【环绕通知中的返回通知】==>Calc中" + methodName + "方法(),结果：" +result);
    } catch (Throwable throwable) {
        System.out.println("【环绕通知中的异常通知】==>Calc中" + methodName + "方法(),出现异常时执行！异常：" +throwable);
    } finally {
        System.out.println("【环绕通知中的后置通知】==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
    }
    //将目标方法的执行结果返回
    return result;
}

16.4 定义切面的优先级

作用：当有多个切面类时，可通过定义切面的优先级来决定类的执行顺序

语法：@Order(value=index)

index是int类型，默认值是 2147483647
设置的数值越小，优先级越高

MyValidate 切面类

package com.atguigu.beforeaop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Aspect
@Order(value = 1)   //设置优先级为1
public class MyValidate {
    /**
     * 添加数据验证功能
     */
    //不同类中也可引用提取的切入点表达式
    //引用时同目录下的类可省略包名路径
    @Before(value = "com.atguigu.beforeaop.MyLogging.myPointCut()")
    public void methodBefore(JoinPoint joinPoint) {
        //获取方法名称
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置通知】==>数据验证切面");
    }
}

MyLogging 切面类

package com.atguigu.beforeaop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.Arrays;
@Component  //将当前类标识为一个组件
@Aspect     //将当前类标识为【切面类】【非核心业务提取类】
@Order(value = 2)   //设置切面优先级为2
public class MyLogging {
    //重用切入点表达式
    @Pointcut("execution(* com.atguigu.beforeaop.CalcImpl.*(..))")
    public void myPointCut(){}
    /**
     * 前置通知
     */
    //使用方法名引入切入点表达式
    @Before(value = "myPointCut()")
    public void beforeMethod(JoinPoint joinPoint) {
        //获取方法名称
        String methodName = joinPoint.getSignature().getName();
        //获取参数
        Object[] args = joinPoint.getArgs();
        System.out.println("【前置通知】==>Calc中" + methodName + "方法(),参数：" + Arrays.toString(args));
    }
}

测试代码

@Test
public void testAseptic(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext_aop.xml");
    Calc calc = context.getBean("calc", Calc.class);
    int add = calc.add(1, 2);
}

16.5 基于XML文件方式配置AOP

除了使用AspectJ注解声明切面，Spring也支持在bean配置文件中声明切面。这种声明是通过aop名称空间中的XML元素完成的。
基于注解的声明优先于基于XML的声明。

配置细节
- 在bean配置文件中所有Spring AOP配置都必须定义在<aop:config></aop:config>元素内部
- 每一切面都要创建一个<aop:aspect>元素来为具体的切面实现引用后端bean实例
- 切面bean必须设置id属性值，供<aop:aspect>元素引用
声明切入点
- 切入点使用<aop:pointcut>元素声明
- 切入点必须定义在<aop:aspect>元素下，或者直接定义在<aop:config>元素下
  - 定义在<aop:aspect>元素下：只对当前切面有效
  - 定义在<aop:config>元素下：对所有切面都有效
- 基于XML的AOP配置不允许在切入点表达式中用名称引用其它切入点
声明通知
- 在aop名称空间中，每种通知类型都对应一个特定的XML元素
- 通知元素使用<pointcut-ref>来引入切入点，或用<pointcut>直接嵌入切入点表达式
- method属性指定切面类中通知方法的名称

applicationContext_aop.xml

<?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"></context:component-scan>
    <!--开启AspectJ注解支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    <!--装配CalcImpl类到IOC容器中-->
    <bean id="calc" class="com.atguigu.beforeaop.CalcImpl"></bean>
    <!--装配切面类到IOC容器中-->
    <bean id="myLogging2" class="com.atguigu.beforeaop.MyLogging"></bean>
    <bean id="myValidate2" class="com.atguigu.beforeaop.MyValidate"></bean>

    <!--基于XML方式配置AOP-->
    <aop:config>
        <!--配置切入点表达式-->
        <aop:pointcut id="myPointCut" expression="execution(* *.*(..))"/>
        <!--配置通知-->
        <aop:aspect ref="myLogging2">
            <!--前置通知-->
            <aop:before method="beforeMethod" pointcut-ref="myPointCut"></aop:before>
            <!--返回通知-->
            <aop:after-returning method="afterReturnning" pointcut-ref="myPointCut" returning="rs"></aop:after-returning>
            <!--异常通知-->
            <aop:after-throwing method="afterThrowing" pointcut-ref="myPointCut" throwing="ex"></aop:after-throwing>
            <!--后置通知-->
            <aop:after method="afterMethod" pointcut-ref="myPointCut"></aop:after>
            <!--环绕通知-->
            <aop:around method="aroundMethod" pointcut-ref="myPointCut"></aop:around>
        </aop:aspect>
    </aop:config>
</beans>

第十七章 Spring中的JdbcTemplate

17.1 JdbcTemplate简介

Spring提供的JdbcTemplate是一个小型持久化层框架，简介Jdbc代码
- Mybatis是一个半自动化的ORM持久化层框架

17.2 JdbcTemplate基本使用

导入JdbcTemplate的相关jar包

<!--导入Spring框架spring-context-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.1</version>
</dependency>
<!--导入druid的jar包-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>
<!--导入mysql的jar包-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.37</version>
    <!--mysql8驱动的jar包-->
    <!--<version>8.0.26</version>-->
</dependency>
<!--导入junit4.12-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<!--导入jdbcTemplate的jar包-->
<!--基于Maven工程搭建时，可不导入spring-jdbc，导入spring-orm包时也会自动导入spring-jdbc-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.1</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
    <version>5.3.1</version>
</dependency>

编写配置文件

db.properties：设置连接数据库属性

#key=value
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3307/mybatis
db.username=root
db.password=root

applicationContext.xml【Spring配置文件】

加载外部属性文件
装配数据源【DataSource】
装配JdbcTemplate

applicationContext_jdbcTemplate.xml 配置文件

<?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"
       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">
    <!--加载外部属性文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--装配数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driverClassName}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>
    <!--装配JdbcTemplate到IOC容器中-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

使用核心类库

//测试代码
@Test
public void testJdbcTemplate(){
    //创建容器对象
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext_jdbcTemplate.xml");
    //获取JdbcTemplate对象
    JdbcTemplate jdbcTemplate = context.getBean("jdbcTemplate", JdbcTemplate.class);
    System.out.println("jdbcTemplate = " + jdbcTemplate);
}

17.3 JdbcTemplate的常用API

JdbcTemplate 是自动提交事务的

JdbcTemplate.update(String sql, Object... args)：通用的增删改方法
JdbcTemplate.batchUpdate(String sql, Object... args)：通用批处理增删改方法
JdbcTemplate.queryForObject(String sql, Class clazz, Object... args)：查询单个数值
JdbcTemplate.queryForObject(String sql, RowMapper rm, Object... args)：查询单个对象
JdbcTemplate.query(String sql, RowMapper rm, Object... args)：查询多个对象

增、删、改操作

//增
String sql = "insert into dept(dept_name) values(?)";
jdbcTemplate.update(sql, "人事部门");

//删
String sql = "delete from dept where dept_id = ?";
jdbcTemplate.update(sql, 4);

//改
String sql = "update dept set dept_name = ? where dept_id = ?";
jdbcTemplate.update(sql, "人事部门");

//批量增
String sql = "insert into employee(last_name,email,salary,dept_id) values(?,?,?,?)";
List<Object[]> empList = new ArrayList<>();
empList.add(new Object[]{"zhangsan", "zhangsan@163.com", 100.0, 1});
empList.add(new Object[]{"lisi", "lisi@163.com", 100.0, 2});
empList.add(new Object[]{"wangwu", "wangwu@163.com", 100.0, 1});
jdbcTemplate.batchUpdate(sql, empList);

查询操作

//查询单个数值【查询员工人数】
String sql = "select count(1) from empliyee";
Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("员工数量：" + count);

//查询单个对象【通过员工id获取员工信息】
String sql = "select id,last_name,email,salary,dept_id from employee where id = ?";
//创建RowMapper<T>，代码底层要求，不创建直接执行queryForObject会报错
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
Employee employee = jdbcTemplate.queryForObject(sql, Employee.class, 1);
System.out.println("employee = " + employee);

//查询多个对象
String sql = "select id,last_name,email,salary from employee";
//创建RowMapper
RowMapper<Employee> rowMapper = new BeanPropertyRowMapper<>(Employee.class);
//测试
List<Employee> empList = jdbcTemplate.query(sql, rowMapper);
for (Employee employee : empList) {
    System.out.println("employee = " + employee);
}

17.4 使用JdbcTemplate 搭建Dao&Service层

Service层依赖Dao层
Dao层依赖JdbcTemplate

pojo层源代码

package com.atguigu.JdbcTemplate.pojo;

public class Department {
    private Integer departmentId;
    private String departmentName;
    private Integer managerId;
    private Integer locationId;

    public Integer getDepartmentId() {
        return departmentId;
    }

    public Department() {
    }

    public Department(Integer departmentId, String departmentName, Integer managerId, Integer locationId) {
        this.departmentId = departmentId;
        this.departmentName = departmentName;
        this.managerId = managerId;
        this.locationId = locationId;
    }

    public void setDepartmentId(Integer departmentId) {
        this.departmentId = departmentId;
    }

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }

    public Integer getManagerId() {
        return managerId;
    }

    public void setManagerId(Integer managerId) {
        this.managerId = managerId;
    }

    public Integer getLocationId() {
        return locationId;
    }

    public void setLocationId(Integer locationId) {
        this.locationId = locationId;
    }

    @Override
    public String toString() {
        return "Department{" +
                "departmentId=" + departmentId +
                ", departmentName='" + departmentName + '\'' +
                ", managerId=" + managerId +
                ", locationId=" + locationId +
                '}';
    }
}

Dao层源代码

DepartmentDao接口

package com.atguigu.JdbcTemplate.dao;

import com.atguigu.JdbcTemplate.pojo.Department;

import java.util.List;

public interface DepartmentDao {
    /**
     * 查询所有部门信息
     * @return
     */
    public List<Department> selectAllDepartments();
}

DepartmentDaoImpl实现类

package com.atguigu.JdbcTemplate.dao.Impl;

import com.atguigu.JdbcTemplate.dao.DepartmentDao;
import com.atguigu.JdbcTemplate.pojo.Department;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;


import java.util.List;
@Repository("departmentDaoImpl")
public class DepartmentDaoImpl implements DepartmentDao {
    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    @Override
    public List<Department> selectAllDepartments() {
        String sql = "select department_id,department_name from departments";
        RowMapper<Department> rowMapper = new BeanPropertyRowMapper<>(Department.class);
        List<Department> list = jdbcTemplate.query(sql, rowMapper);
        return list;
    }
}

service层源代码

DepartmentService接口

package com.atguigu.JdbcTemplate.service;

import com.atguigu.JdbcTemplate.pojo.Department;

import java.util.List;

public interface DepartmentService {
    /**
     * 查询所有部门信息
     * @return
     */
    public List<Department> getAllDepartments();
}

DepartmentServiceImpl实现类

package com.atguigu.JdbcTemplate.service.Impl;

import com.atguigu.JdbcTemplate.dao.DepartmentDao;
import com.atguigu.JdbcTemplate.pojo.Department;
import com.atguigu.JdbcTemplate.service.DepartmentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("departmentServiceImpl")
public class DepartmentServiceImpl implements DepartmentService {
    @Autowired
    @Qualifier("departmentDaoImpl")
    private DepartmentDao departmentDao;
    @Override
    public List<Department> getAllDepartments() {
        List<Department> list = departmentDao.selectAllDepartments();
        return list;
    }
}

使用Junit4进行测试【需导入spring-test 的jar包】

import com.atguigu.JdbcTemplate.pojo.Department;
import com.atguigu.JdbcTemplate.service.DepartmentService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(locations = "classpath:applicationContext_jdbcTemplate.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class TestJdbcTemplateService {
    @Autowired
    private DepartmentService departmentService;

    @Test
    public void TestService(){
        for (Department allDepartment : departmentService.getAllDepartments()) {
            System.out.println("allDepartment = " + allDepartment);
        }
    }
}

总结
- 自定义bean时使用注解的方式装配，第三方bean使用XML配置文件的方式装配
- 使用注解时需要在XML配置文件中配置开启组件扫描，并指定扫描的包路径
```

<context:component-scan base-package="com.atguigu.JdbcTemplate"></context:component-scan>
```

第十八章 Spring声明式事务管理

事务四大特征【ACID】

原子性

一致性

隔离性

持久性

事务三种行为

开启事务：connection.setAutoCommit(false)

提交事务：connection.commit()

回滚事务：connection.rollback()

18.1 Spring中支持事务管理

编程式事务管理【传统事务管理】
1. 获取数据库连接Connection对象
2. 取消事务的自动提交【开启事务】
3. 执行操作
4. 正常完成操作时手动提交事务
5. 执行失败时回滚事务
6. 关闭相关资源
  - 不足：事务管理代码【非核心业务】与核心业务代码相耦合
    - 事务管理代码分散
    - 事务管理代码混乱
声明式事务管理【使用AOP管理事务】
- 先横向提取【事务管理代码】，再动态织入

18.2 基于注解的声明式事务管理

总结：不用事务管理代码，会发现在同一个业务中出现局部成功及局部失败的现象

1、搭建环境

导入相关依赖的jar包

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- Spring 持久化层支持jar包 -->
    <!-- Spring 在执行持久化层操作、与持久化层技术进行整合过程中，需要使用orm、jdbc、tx三个
    jar包 -->
    <!-- 导入 orm 包就可以通过 Maven 的依赖传递性把其他两个也导入 -->
    <!--导入JdbcTemplate的jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!--导入AspectJ框架的jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- Spring 测试相关 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.3.1</version></dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.37</version>
        <!-- <version>8.0.16</version> -->
    </dependency>
    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
</dependencies>

创建db.properties配置文件

#key=value
db.driverClassName=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3307/mybatis
db.username=root
db.password=root

配置Sprig的配置文件

<?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"
       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">

    <!--开启组件扫描-->
    <context:component-scan base-package="com.atguigu.transaction"></context:component-scan>
    <!--加载外部属性文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--装配数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driverClassName}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>
    <!--装配JdbcTemplate到IOC容器中-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

创建数据库表

CREATE TABLE `t_book` (
    `book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `book_name` varchar(20) DEFAULT NULL COMMENT '图书名称',
    `price` int(11) DEFAULT NULL COMMENT '价格',
    `stock` int(10) unsigned DEFAULT NULL COMMENT '库存（无符号）',
    PRIMARY KEY (`book_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,'斗破苍
穹',80,100),(2,'斗罗大陆',50,100);
CREATE TABLE `t_user` (
    `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
    `username` varchar(20) DEFAULT NULL COMMENT '用户名',
    `balance` int(10) unsigned DEFAULT NULL COMMENT '余额（无符号）',
    PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
insert into `t_user`(`user_id`,`username`,`balance`) values (1,'admin',50);

创建组件

BookDao 接口类

package com.atguigu.transaction.dao;

public interface BookDao {
    Integer getPriceByBookId(Integer bookId);
    void updateStock(Integer bookId);
    void updateBalance(Integer userId, Integer price);
}

BookDaoImpl 接口实现类

package com.atguigu.transaction.dao.Impl;

import com.atguigu.transaction.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("bookDao")
public class BookDaoImpl implements BookDao {

    @Autowired
    @Qualifier("jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    @Override
    public Integer getPriceByBookId(Integer bookId) {
        String sql = "select price from t_book where book_id = ?";
        return jdbcTemplate.queryForObject(sql, Integer.class, bookId);
    }
    @Override
    public void updateStock(Integer bookId) {
        String sql = "update t_book set stock = stock - 1 where book_id = ?";
        jdbcTemplate.update(sql, bookId);
    }
    @Override
    public void updateBalance(Integer userId, Integer price) {
        String sql = "update t_user set balance = balance - ? where user_id =?";
        jdbcTemplate.update(sql, price, userId);
    }
}

BookService 接口类

package com.atguigu.transaction.service;

public interface BookService {
    void buyBook(Integer bookId, Integer userId);
}

BookServiceImpl 接口实现类

package com.atguigu.transaction.service.Impl;

import com.atguigu.transaction.dao.BookDao;
import com.atguigu.transaction.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service("bookService")
public class BookServiceImpl implements BookService {

    @Autowired
    @Qualifier("bookDao")
    private BookDao bookDao;

    @Override
    public void buyBook(Integer bookId, Integer userId) {
        //查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}

测试代码

import com.atguigu.transaction.service.BookService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@ContextConfiguration(locations = "classpath:applicationContext_transactionmanager.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class TestTransactionManager {

    @Autowired
    @Qualifier("bookService")
    private BookService bookService;

    @Test
    public void testNoTran(){
        //报错，因为用户余额50小于书本的价格80
        bookService.buyBook(1,1);
    }
}

2、加入事务

在Spring配置文件添加以下语句

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--transaction-manager属性的默认值为transactionManager
        若事务管理器id为transactionManager则可省略不设置transaction-manager属性
        -->
    <!--开启事务注解支持-->
    <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

注意：使用的annotation-drive是以tx结尾的

使用@Transaction注解标识

位置：
- @Transactional 标识在方法上，则只会影响该方法
- @Transactional 标识在类上，则会影响类中所有的方法

@Service("bookService")
public class BookServiceImpl implements BookService {

    @Autowired
    @Qualifier("bookDao")
    private BookDao bookDao;
    
    @Transactional
    @Override
    public void buyBook(Integer bookId, Integer userId) {
        //查询图书的价格
        Integer price = bookDao.getPriceByBookId(bookId);
        //更新图书的库存
        bookDao.updateStock(bookId);
        //更新用户的余额
        bookDao.updateBalance(userId, price);
    }
}

3、总结

service层标识业务逻辑层，处理事务一般都在service层，所以在service层的类或类中的方法中添加@Transactional注解
添加声明式事务管理之后，获取的是代理对象，代理对象不能转换为目标对象【实现类】

18.3 Spring声明式事务管理属性

@Transactional 注解属性

事务传播行为【Propagation】

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播
- 如：执行事务方法method()1 【事务x】之后，调用事务方法method2 【事务y】，此时需要设置method()2方法的事务传播行为

Spring 的7种传播行为

传播属性	描述
REQUIRED	如果有事务在运行，当前的方法就在这个事务内运行；否则就启动一个新的事务并在自己的事务内运行。
REQUIRES_NEW	当前的方法必须启动新事务，并在自己的食物内运行；如果有事务正在运行，应该将它挂起。
SUPPORTS	如果有事务在运行，当前的方法就在这个食物内运行，否则可以不运行在事务中。
NOT_SUPPORTED	当前的方法不应该运行在事务中，如果有运行的事务就将它挂起。
MANDATORY	当前的方法必须运行在事务中，如果没有正在运行的事务就抛出异常。
NEVER	当前的方法不应该运行在事务中，如果有正在运行的事务就抛出异常。
NESTED	如果有事务正在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在它自己的事务内运行。

图解事务传播行为

REQUIRED
REQUIRES_NEW

使用场景

//1.购买两本书时去结账，判断余额是否充足，余额不足则一本书都不能卖
@Transactional(propagation = Propagation.REQUIRED)
//2.购买两本书时去结账，判断余额是否充足，余额不足则最后余额不足的那本书不能卖
@Transactional(propagation = Propagation.REQUIRES_NEW)

事务隔离级别【Isolation】
- 隔离级别概述：一个事务与其它事务之间的隔离等级【1，2，4，8】
- 隔离等级
  - 读未提交【1】：READ UNCOMMITTED
    - 存在问题：脏读【读取到了未提交数据】
  - 读已提交【2】：READ COMMITTED
    - 存在问题：可能出现不可重复读
  - 可重复读【4】：REPEATABLE READ
    - 存在问题：可能出现幻读
  - 串行化【8】：SERIALIZABLE
- 数据库产品对事务隔离级别的支持程度
  
  隔离级别 Oracle MySQL
  
  READ UNCOMMITTED x √
  
  READ COMMITTED √（默认） √
  
  REPEATABLE READ x √（默认）
  
  SERIALIZABLE √ √
```
@Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.REPEATABLE_READ)
```

事务超时【timeout】
- 设置事务超时时间，到大指定时间后会强制回滚
- 类型：int
- 单位：秒
```
@Transactional(timeout = 3)
```
事务只读【readonly]
- 一般事务方法中只有查询操作时，才将事务设置为只读
- 默认值：false
```
@Transactional(readOnly = true)
```
事务回滚【不回滚】
- 声明式事务默认只针对运行时异常回滚，编译时异常不回滚
- rollbackFor：设置回滚的异常Class
- noRollbackFor：设置不回滚的异常Class
- rollbackForClassName：设置回滚的异常Class，需要设置一个字符串类型的全类名
```
//设置发生 ArithmeticException 数学运算异常时不回滚
@Transactional(noRollbackFor = ArithmeticException.class)
//@Transactional(noRollbackForClassName = "java.lang.ArithmeticException")
```

隔离级别	Oracle	MySQL
READ UNCOMMITTED	x	√
READ COMMITTED	√（默认）	√
REPEATABLE READ	x	√（默认）
SERIALIZABLE	√	√

18.4 基于XML配置文件方式，配置声明式事务管理

<?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:tx="http://www.springframework.org/schema/tx"
       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/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="com.atguigu.transaction"></context:component-scan>
    <!--加载外部属性文件-->
    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    <!--装配数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${db.driverClassName}"></property>
        <property name="url" value="${db.url}"></property>
        <property name="username" value="${db.username}"></property>
        <property name="password" value="${db.password}"></property>
    </bean>
    <!--配置JdbcTemplate到IOC容器中-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--配置数据源属性-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置BookDaoImpl-->
    <bean id="bookDao" class="com.atguigu.transaction.dao.Impl.BookDaoImpl">
        <!--property标签是基于set方法注入的，对象内该属性要有set方法，没有则会报错-->
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
    <!--配置BookServiceImpl-->
    <bean id="bookService" class="com.atguigu.transaction.service.Impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"></property>
    </bean>

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--配置数据源属性-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置声明式事务-->
    <tx:advice id="tx" transaction-manager="transactionManager">
        <!--设置添加事务的方法-->
        <tx:attributes>
            <!--设置查询的方法的只读属性为true-->
            <tx:method name="find*" read-only="true"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="buyBook" propagation="REQUIRES_NEW" isolation="REPEATABLE_READ"/>
        </tx:attributes>
    </tx:advice>
        <!--AOP配置-->
    <aop:config>
        <!--配置切入点表达式-->
        <aop:pointcut id="pointCut" expression="execution(* com.atguigu.transaction.service.Impl.BookServiceImpl.buyBook(..))"/>
        <!--将事务方法和切入点表达式关联起来-->
        <aop:advisor advice-ref="tx" pointcut-ref="pointCut"/>
    </aop:config>
</beans>

第十九章 Spring5新特性

19.1 添加新注解

名称	含义	可标注位置
@NUllable	可以为空	@Target({ElementType.METHOD，ElementType.PARAMETER，ElementType.FIELD})
@NonNull	不应为空	@Target({ElementType.METHOD，ElementType.PARAMETER，ElementType.FIELD})
@NonNullFields	在特定包下的字段不应为空	@Target({ElementType.PARAMETER}) @TypeQualifierDefault(ElementType.FIELD)
@NonNullApi	参数和方法返回值不应为空	@Target({ElementType.PARAMETER}) @TypeQualifierDefault(ElementType.METHOD，ElementType.PARAMETER)

@Nullable的作用
- 位置：可以书写在方法&属性上面&参数前面
- 作用：表示当前方法或属性可以为空，当前属性为空时，消除空指针异常。

19.2 Spring5整合Log4j2

导入相关的jar包

<!--导入log4j2的jar包-->
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.11.2</version>
    <scope>test</scope>
</dependency>

编写配置文件【log4j2.xml】

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序：OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时可以看到log4j2内部各种详细输出
    status设置优先级为INFO时，则比它优先级低的DEBUG等信息也会输出
-->
<Configuration status="INFO">
    <!--properties:设置全局变量 -->
    <properties>
        <!--LOG_HOME:指定当前日志存放的目录 -->
        <property name="LOG_HOME">logs</property>
        <!--FILE_NAME:指定日志文件的名称 -->
        <property name="FILE_NAME">test</property>
    </properties>
    <!--appenders:定义日志输出目的地，内容和格式等 -->
    <Appenders>
        <!--Console:日志输出到控制台标准输出 -->
        <Console name="Console" target="SYSTEM_OUT">
            <!--pattern:日期,线程名,日志级别,日志名称,日志信息,换行 -->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </Console>
    </Appenders>
    <!--Loggers:定义日志级别和使用的Appenders -->
<!--    只有定义Loggers并引入Appenders，Appenders才会生效-->
    <Loggers>
        <!--Root:日志默认打印到控制台，Root用于指定项目的根日志，如果没有单独指定Loggers，则会使用Root作为默认的日志输出-->
        <!--level日志级别: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
        <Root level="DEBUG">
            <AppenderRef ref="Console" />
        </Root>
    </Loggers>
</Configuration>

19.3 Spring5整合Junit5

导入Junit5的jar包【注意：将Junit4的jar包删除】

<!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
<!--注意spring-test的版本要和spring-context的版本一致-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.3.1</version>
    <scope>test</scope>
</dependency>

使用注解整合即可

方式一

@ContextConfiguration(locations = "classpath:applicationContext_transactionmanager.xml")
@ExtendWith(SpringExtension.class)
public class TestTransactionManager {}

方式二

@SpringJUnitConfig(locations = "classpath:applicationContext_transactionmanager.xml")
public class TestTransactionManager {}

区别：@SpringJUnitConfig 相当于@ContextConfiguration 和@ExtendWith 的整合

posted @ 2023-04-20 23:58 Cray0ns 阅读(41) 评论(0) 收藏举报

刷新页面返回顶部

safety-index

Spring 框架总结笔记

第一章 初识Spring

1.1 Spring简介

1.2 搭建Spring框架步骤

1.3 Spring特性

1.4 Spring中getBean()三种方式

1.5 bean标签详解

第二章 Spring IOC底层实现

2.1 BeanFactory与ApplicationContexet接口

2.2 图解IOC类的结构

第三章 Spring依赖注入数值问题【重点】

3.1 字面量数值

3.2 CDATA区

3.3 外部已声明bean及级联属性赋值

3.4 内部bean

3.5 集合

第四章 Spring依赖注入方式【基于XML】

4.1 set注入

4.2 构造器注入

4.3 p名称空间注入

第五章 Spring管理第三方bean【druid】

第六章 Spring中的FactoryBean

6.1 Spring中的两种bean

6.2 FactoryBean使用步骤

第七章 Spring中bean的作用域

7.1 语法

7.2 四个作用域

第八章 Spring中bean的生命周期

8.1 bean的生命周期

8.2 bean的后置处理器

8.3 添加后置处理器后bean的生命周期

第九章 Spring中自动装配【基于XML】

9.1 Spring中提供两种装配方式

9.2 Spring自动装配语法及规则

9.3 总结

第十章 Spring中注解【非常重要】

10.1 使用注解将对象装配到IOC容器中

10.2 使用注解装配对象中属性【自动装配】

第十一章 Spring中组件扫描

11.1 默认使用情况

11.2 包含扫描

11.3 排除扫描

第十二章 Spring完全注解开发【基于类对象】

12.1 完全注解开发步骤

第十三章 Spring集成Junit4

13.1 集成步骤

第十四章 AOP前奏

14.1 代理模式

14.2 手动实现动态代理环境搭建

14.3 手动实现动态代理关键步骤

第十五章 Spring中的AOP

15.1 AspectJ框架【AOP框架】

15.2 使用AspectJ的步骤

15.3 Spring中AOP概述

15.4 Spring中AOP的相关术语

第十六章 AspectJ【AOP框架】详解

16.1 AspectJ 中切入点表达式

16.2 AspectJ【AOP框架】中的JoinPoint对象

16.3 ASpectJ中的通知

16.4 定义切面的优先级

16.5 基于XML文件方式配置AOP

第十七章 Spring中的JdbcTemplate

17.1 JdbcTemplate简介

17.2 JdbcTemplate基本使用

17.3 JdbcTemplate的常用API

17.4 使用JdbcTemplate 搭建Dao&Service层

总结

第十八章 Spring声明式事务管理

18.1 Spring中支持事务管理

18.2 基于注解的声明式事务管理

1、搭建环境

2、加入事务

3、总结

18.3 Spring声明式事务管理属性

18.4 基于XML配置文件方式，配置声明式事务管理

第十九章 Spring5新特性

19.1 添加新注解

19.2 Spring5整合Log4j2

19.3 Spring5整合Junit5

第一章初识Spring