尚硅谷_Spring5

周巴帝

已于 2023-05-06 23:24:24 修改

阅读量545

点赞数 3

分类专栏： Spring 文章标签： spring java

于 2022-08-01 22:41:53 首次发布

本文链接：https://blog.csdn.net/Hello_super/article/details/126111592

版权

Spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Spring5

中文文档：https://cntofu.com/book/95/index.html

课程内容介绍：

Spring框架概述，IOC容器，AOP，JDBCTemplate，事务管理，Spring5新特性。

1. Spring框架概述

详细的信息直接看百度百科即可：https://baike.baidu.com/item/spring/85061?fr=aladdin

Spring 是轻量级（体积小，jar包少）的开源的 JavaEE 框架；
Spring 可以解决企业应用开发的复杂性；
Spring 有两个核心部分：IOC 和 Aop：
- IOC，控制反转，即把创建对象的过程交给Spring进行管理；
- AOP，面向切面，即在不修改源代码进行功能增强；
Spring特点：
- 方便解耦（IOC），简化开发；
- AOP编程支持，可以理解为程序的扩展；
- 方便程序测试（Junit）；
- 方便和其他框架进行整合（如，mybatis）；
- 方便进行事务操作；
- 降低 API 开发难度；
- 在课程中，选取 Spring 版本 5.x

2. Spring5入门案例

2.1 下载Spring5

注：GA表示长期支持，SNAPSHOT表示快照。

下载地址：https://repo.spring.io/ui/native/release/org/springframework/spring/ ，这里下载5.2.6版本进行学习。

2.2 打开IDEA新建一个空工程，然后在里面添加module

2.3 导入相关的依赖包

那么我们需要导入那些jar包呢？

从上面的图中可以看出，其中Core Container中所需要的jar包是一定要导入的，所以在这里我们先暂时导入Beans、Core、Context、Expression这些jar包。此外，还需要导入一个日志的jar包，否则会报错！

在module中添加类路径：

2.4 创建普通类，在这个类创建普通方法

package com.atguigu.spring;

public class User {
    // 创建普通方法
    public void add(){
        System.out.println("add...");
    }
}

2.5 创建 Spring 配置文件，在配置文件配置创建的对象

Spring配置文件是xml格式，在src类资源目录下新建一个bean1.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">

    <!--配置并创建User对象-->
    <bean id="user" class="com.atguigu.spring.User"></bean>
</beans>

3. IOC

3.1 什么是IOC

控制反转：把对象创建和对象之间的调用过程交给Spring进行管理；
使用IOC的目的：为了降低耦合度；
做入门案例就是IOC实现；

原始service调用dao层，耦合度太高：

使用工厂模式实现，工厂模式可以降低程序的耦合度：

3.2 IOC底层原理

xml文件解析、工厂模式、反射。

3.3 画图讲解IOC底层原理

3.4 IOC接口

IOC 思想是基于 IOC 容器完成，IOC 容器底层就是对象工厂；
Spring 提供 IOC 容器实现两种方式：（两个接口）
- BeanFactory：由IOC 容器基础实现，是 Spring 内部的使用接口，不提供给开发人员进行使用，BeanFactory加载配置文件时候不会创建对象，只有在获取（使用）对象才去创建对象；
```
// 加载配置文件，使用BeanFactory时在这里不会创建对象
BeanFactory context = new ClassPathXmlApplicationContext("bean1.xml");

// BeanFactory只有在获取或者使用对象的时候才会创建对象
User user = context.getBean("user", User.class);
```
- ApplicationContext：推荐使用，它是BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用， 加载配置文件（只要在xml文件中配置了bean）时候就会把在配置文件对象进行创建；

在IDEA中使用ctrl+H即可看见当前类的实现接口：

4. IOC 操作 Bean 管理

什么是bean管理？

Bean 管理指的是两个操作：Spring 创建对象、Spring 注入属性；

Bean 管理操作有两种方式：

基于 xml 配置文件方式实现；
基于注解方式实现；

4.1 基于xml方式实现bean管理

4.1.1 基于xml方式创建对象；

<!--
    配置并创建User对象

    在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建。在 bean 标签有很多属性，介绍常用的属性：
        id : 相当于给当前的bean对象设置一个唯一的标识，在创建对象的时候就是通过这个表示来区分不同的bean；
        class : 类的全路径，包括包名；
    
    创建对象时候，默认也是执行无参数构造方法完成对象创建；
    -->
    <bean id="user" class="com.atguigu.spring.User"></bean>

4.1.2 基于 xml 方式注入属性

DI：依赖注入，就是注入属性，注意：注入属性要在创建对象的基础之上来完成。

4.1.3 属性注入的几种方式：

使用set()方法进行注入：

第一步，创建类，定义属性和对应的 set 方法

package com.atguigu.spring;

/**
 * 演示使用set()方法进行属性的注入。
 */
public class Book {
    // 定义属性
    private String bname;
    private String bauthor;

    // 为属性创建对象的set()方法

    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    public static void main(String[] args) {
        // 创建对象
        Book book = new Book();
        // 通过set()方法为属性赋值
        book.setBname("abc");
    }

    public void testDemo(){
        System.out.println("book name:" + bname + ", book author:" + bauthor);
    }
}

第二步，在 spring 配置文件配置并创建对象，配置属性注入；

<!--set()方法注入属性-->
<!--1. 配置并创建book对象-->
<bean id="book" class="com.atguigu.spring.Book">
    <!--
        2. 使用property完成属性注入：
            name：类里面的属性名称；
            value：向属性注入的值；
     -->
    <property name="bname" value="易筋经"/>
    <property name="bauthor" value="达摩老祖"/>
</bean>

第三步，测试

@Test
public void testBook1(){
    // 1. 加载配置文件
    BeanFactory beanFactory = new ClassPathXmlApplicationContext("bean1.xml");
    // 2. 获取配置并创建对象
    Book book = beanFactory.getBean("book", Book.class);
    book.testDemo();
}

使用有参数构造进行注入：

创建类，定义属性，创建属性对应有参数构造方法；

package com.atguigu.spring;

public class Order {
    // 属性
    private String oname;
    private String address;

    // 在有参数构造构造方法时，不需要提供无参构造也能创建对象（使用有参构造创建）
    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }

    public void testOrder(){
        System.out.println("oname: " + oname + ", address: " + address);
    }
}

配置xml文件

<!--
使用有参数构造方法实现依赖注入，使用这种方式可以不提供无参构造方法。值得注意的是，通过这种方式并不是通过无参构造方法创建对象，而是通过有参构造方法创建对象。
-->
<bean id="order" class="com.atguigu.spring.Order">
    <constructor-arg name="oname" value="computer"/>
    <constructor-arg name="address" value="China" />
    <!--注意：这里还可以使用index进行设置，但是这种使用的很少。
		比如：index=0表示有参构造函数的第一个形参，1表示第二个...
	-->
<!--        <constructor-arg index="0" value="computer"/>-->
</bean>

测试

@Test
public void testOrder(){
    // 1. 加载配置文件
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
    // 2. 获取配置并创建对象
    Order order = applicationContext.getBean("order", Order.class);
    order.testOrder();
}

p 名称空间注入：（了解）

使用 p 名称空间注入，可以简化基于 xml 配置方式，实现步骤如下：

第一步，添加 p 名称空间在配置文件中：

第二步，进行属性注入，在 bean 标签里面进行操作：

<!--使用p命名空间进行依赖的注入-->
<bean id="book2" class="com.atguigu.spring.Book" p:bname="Java核心卷二" p:bauthor="动力节点"/>

5.4 xml 注入其他类型属性

字面量： 类似常量。

null注入

<!--将address属性的值设置为null值。-->
<property name="address">
    <null />
</property>

属性值包含特殊符号

<!--
    属性值（<<南京>>）包含特殊符号的情况：
       方案二，把 < > 符号进行转义为：&lt;  &gt;
       方案一，把带有特殊符号的内容写到<![CDATA[value]]>中
-->
<property name="address">
    <value>
        <![CDATA[<<南京>>]]>
    </value>
</property>

4.1.4 注入外部bean

UserDao:

package com.atguigu.spring.dao;

public interface UserDao {
    void update();
}

UserDaoImpl:

package com.atguigu.spring.dao;

public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("userDao update...");
    }
}

UserService:

package com.atguigu.spring.service;

import com.atguigu.spring.dao.UserDao;

public class UserService {
    // UserDao类型的属性
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("userService add...");
        // 调用userDao中的update()方法
        userDao.update();
    }
}

xml配置文件:

<!--注册UserService对象和UserDao对象-->
<bean id="userService" class="com.atguigu.spring.service.UserService">
    <!--注入UserDao类型的属性-->
    <!--
        name: UserService类的属性名；
        ref: 通过ref属性可以将id为userDao的bean对象与userService对象的userDao属性关联起来。
    -->
    <property name="userDao" ref="userDao"/>
</bean>
<!--用于接口不能实例化对象，所在在这里指向它的子类UserDaoImpl-->
<bean id="userDao" class="com.atguigu.spring.dao.UserDaoImpl"/>

测试：

package com.atguigu.spring.test;

import com.atguigu.spring.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test02 {
    // 测试ref属性
    @Test
    public void t1(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean2_ref属性.xml");
        // 获取bean
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.add();
    }
}

4.1.5 注入内部bean

一对多的关系，如部门和员工之间的关系就是一个部门有多个员工；

在实体类之间表示一对多关系，为了表示员工所属的部门，使用对象类型属性进行表示；

package com.atguigu.spring.bean;

/**
 * 部门类
 */
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

package com.atguigu.spring.bean;

/**
 * 员工类
 */
public class Emp {
    private String ename;
    private String gender;

    // 员工属于部门（一对多的关系），这里使用对象的形式进行表示
    private Dept dept;

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    // 用于测试是否注入成功
    public void add(){
        System.out.println("ename: " + ename + ", gender: " + gender + ", dept: " + dept);
    }
}

在Spring中进行配置

<!--Emp类-->
<bean id="emp" class="com.atguigu.spring.bean.Emp">
    <!--ename、gender都是普通属性，直接使用property标签进行设置-->
    <property name="ename" value="zhangsan"/>
    <property name="gender" value="man"/>
    <!--dept属于对象类型，这里使用内部类-->
    <property name="dept">
        <bean id="dept" class="com.atguigu.spring.bean.Dept">
            <property name="dname" value="销售部"/>
        </bean>
    </property>
</bean>

4.1.6 注入属性-级联赋值

第一种写法：

<!--Emp类-->
<bean id="emp" class="com.atguigu.spring.bean.Emp">
    <!--ename、gender都是普通属性，直接使用property标签进行设置-->
    <property name="ename" value="曹操"/>
    <property name="gender" value="男"/>

    <!--这里使用级联注入实现，与外部注入类似-->
    <property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="com.atguigu.spring.bean.Dept">
    <property name="dname" value="武装部"/>
</bean>

第二种写法：需要为在Emp中给dept对象设置getDept()方法：

<!--Emp类-->
<bean id="emp" class="com.atguigu.spring.bean.Emp">
    <!--ename、gender都是普通属性，直接使用property标签进行设置-->
    <property name="ename" value="曹操"/>
    <property name="gender" value="男"/>
    <property name="dept" ref="dept"/>
    <!--级联注入的第二种写法，这种写法要求dept对象提供get方法，这种写法比上面那种的优先级高。-->
    <property name="dept.dname" value="军事部"/>
</bean>
<bean id="dept" class="com.atguigu.spring.bean.Dept"/>

4.1.7 xml注入集合属性

包括：数组、list、map、set属性。

第一步，创建类

package com.xuan.bean;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {
    // 1. 数组类型属性
    private String[] courses;
    // 2. list集合类型属性
    private List<String> list;
    // map集合类型属性
    private Map<String, String> map;
    // 4. set集合类型属性
    private Set<String> set;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    // 打印信息
    public void printInfo(){
        System.out.println("courses: " + Arrays.toString(courses));
        System.out.println("list: " + list);
        System.out.println("map: " + map);
        System.out.println("set: " + set);
    }
}

第二步，在Spring配置文件中进行配置。

<!--注册Stu类-->
<bean id="stu" class="com.xuan.bean.Stu">
    <!--注入数组类型属性-->
    <property name="courses">
        <array>
            <value>JavaSE</value>
            <value>JavaWeb</value>
        </array>
    </property>
    <!--注入list类型属性-->
    <property name="list">
        <list>
            <value>张三</value>
            <value>小张</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="课程名称" value="mysql"/>
            <entry key="课时" value="20"/>
        </map>
    </property>
    <!--注入set集合-->
    <property name="set">
        <set>
            <value>Spring</value>
            <value>SpringMVC</value>
        </set>
    </property>
</bean>

测试

@Test
public void t1(){
    // 读取配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    // 获取对象
    Stu stu = context.getBean("stu", Stu.class);
    stu.printInfo();
}

[补充] 在集合里面设置对象类型的值：

<bean id="stu" class="com.xuan.bean.Stu">
    <!--注入对象类型-->
    <property name="phones">
        <list>
            <ref bean="p1"/>
            <ref bean="p2"/>
        </list>
    </property>
</bean>
<!--创建多个phone-->
<bean id="p1" class="com.xuan.bean.Phone">
    <property name="markCode" value="huawei23323"/>
</bean>
<bean id="p2" class="com.xuan.bean.Phone">
    <property name="markCode" value="huaweiAL2000"/>
</bean>

[补充] 把集合注入部分提取出来：

第一步，在 spring 配置文件中引入名称空间 util

<?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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
</beans>

第二步，使用 util 标签完成 list 集合注入提取出来

<!-- 提取 list 集合类型属性注入，这样可以使用list集合的复用。 -->
<util:list id="bookList">
    <value>第一章</value>
    <value>第二章</value>
    <value>第三章</value>
</util:list>
<!--使用提取的集合类型属性-->
<bean id="book" class="com.xuan.bean.Book">
    <property name="chapter" ref="bookList"/>
</bean>

4.1.8 FactoryBean

在Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）；

普通 bean：在配置文件中定义 bean 类型就是返回类型，以下这种就是普通的bean；

<bean id="p1" class="com.xuan.bean.Phone">
    <property name="markCode" value="huawei23323"/>
</bean>

工厂 bean：在配置文件定义 bean的类型可以和返回的类型不一样；

工厂bean的实现步骤如下：

第一步，创建类，如果这个类作为工厂 bean，则必须要实现接口 FactoryBean，实现接口里面的方法，在实现的方法中定义返回的 bean 类型；

package com.xuan.factoryBean;

import com.xuan.bean.Phone;
import org.springframework.beans.factory.FactoryBean;

/**
 * 定义一个工厂类。
 */
public class FactoryBeanTest implements FactoryBean {
    // 定义工厂bean的返回对象类型
    @Override
    public Phone getObject() throws Exception {
        Phone phone = new Phone();
        phone.setMarkCode("huawei p30 pro");
        return phone;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

第二步，配置xml配置文件

<bean id="factoryBeanTest" class="com.xuan.factoryBean.FactoryBeanTest" />

第三步，测试：

// 测试工厂bean
@Test
public void t3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("factoryBean.xml");
    // 由于FactoryBeanTest实现了FactoryBean接口，在其中定义了返回类型为：Phone
    Phone phone = context.getBean("factoryBeanTest", Phone.class);
    System.out.println(phone); // Phone{markCode='huawei p30 pro'}
}

4.1.9 bean的作用域

在 Spring 里面，设置创建 bean 实例是单实例还是多实例。单实例，即对象只创建一次，多个程序之间共用一个对象；多实例，每次需要的时候都创建一个单独对象；在 Spring 里面，默认情况下，bean是单实例对象。

<bean id="book" class="com.xuan.bean.Book">
    <property name="chapter" ref="bookList"/>
</bean>

@Test
public void t2(){
    // 读取配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    // 获取对象
    Book book1 = context.getBean("book", Book.class);
    Book book2 = context.getBean("book", Book.class);
    System.out.println(book1);
    System.out.println(book2);
}

在Spring中如何设置多实例：

在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例，scope 属性值如下：

singleton，表示是单实例对象，是默认值；
prototype，表示是多实例对象；

<bean id="book" class="com.xuan.bean.Book" scope="prototype">
    <property name="chapter" ref="bookList"/>
</bean>

singleton 和 prototype 区别：

singleton 单实例，prototype 多实例；
设置 scope 的值是 singleton 时候， spring在加载xml配置文件时候就会创建单实例对象；当设置为prototype 时候，spring加载xml配置文件时候并不会创建对象，而是在调用getBean()方法的时候创建多实例对象；

补充，scope的值并不只是singleton与prototype，还有两个使用较少的request与session；

4.1.10 bean的生命周期

什么是bean的生命周期？即bean对象从创建到销毁的过程。

bean的有以下的生命周期：

通过构造器创建 bean 实例（无参数构造）；
为 bean 的属性设置值或对其他 bean 引用（调用对应的set 方法）；
调用 bean 的初始化的方法（需要进行配置初始化的方法）；
使用bean对象（对象获取到了）；
当容器关闭时候，调用 bean 对象的销毁方法（需要进行配置销毁的方法）；

具体实现如下：

第一步，定义类：

package com.xuan.bean;

public class Orders {
    // 订单名称
    private String oname;

    public Orders() {
        System.out.println("bean生命周期：");
        System.out.println("第一步，执行无参构造创建bean实例！");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，调用set方法设置属性的值！");
    }

    // 创建初始化方法，该方法名随意，这里必须要在xml文件的bean标签中使用initMethod参数进行指定后该方法才生效。
    public void init(){
        System.out.println("第三步，执行初始化的方法！");
    }

    /*
     创建销毁方法方法名随意，也需要在xml文件的bean标签中使用destroyMethod参数进行指定后生效。
     但是必须要要手动配置让对象销毁该方法才会被执行。
     */
    public void destroy(){
        System.out.println("第五部，执行销毁的方法！");
    }
}

第二步，编写xml配置文件：

<!--
init-method参数指定bean对象初始化的时执行的方法；
destroy-method参数指定bean对象销毁时执行的方法；
-->
<bean id="orders" class="com.xuan.bean.Orders" init-method="init" destroy-method="destroy">
    <property name="oname" value="huawei phone"/>
</bean>

第三步，测试：

// 测试bean生命周期
@Test
public void t4(){
    // 获取配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean生命周期.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步，获取bean实例对象：" + orders);

    /*
    手动让bean实例销毁，注意这里是必须的，不然在xml配置文件中destroy-method参数指定的方法不会被执行。
    注意，这里的context是ApplicationContext引用类型，其中并没有close()方法。但是在ApplicationContext的子类中扩展了close()方法。
    所以这里要转为它的子类型。
     */
    ((ClassPathXmlApplicationContext) context).close();
}

补充：bean有后置处理器，如果加上bean的后置处理，那么bean生命周期有七步：

1.  通过构造器创建 bean 实例（无参数构造）；
2.  为 bean 的属性设置值或对其他 bean 引用（调用 对应的set 方法）；
3.  把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization； 
4.  调用 bean 的初始化的方法（需要进行配置初始化的方法）；
5.  把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
6.  使用bean对象 （对象获取到了）；
7.  当容器关闭时候，调用 bean 对象的销毁方法（需要进行配置销毁的方法）；

具体实现：

第一步，编写后置类：

package com.xuan.bean;

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

/**
 * bean的后置处理器。
 * 该后置处理器需要在配置文件中使用bean标签进行注册（与普通的bean注册没区别），之后在xml配置文件中所有的bean对象在初始化之前和之后都会调用这个后置处理器中所编写的方法。
 */
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean对象初始化之后调用postProcessBeforeInitialization()");
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean对象初始化之前调用postProcessAfterInitialization()");
        return bean;
    }
}

第二步，注册后置类：

<!--
注册后置处理器（通常指的是实现了BeanPostProcessor接口的类）。
在这里注册后，在该配置文件中所有的bean在初始化前后都会调用该后置处理器。
-->
<bean id="myBeanPostProcessor" class="com.xuan.bean.MyBeanPostProcessor"/>

第三步，测试：

4.1.11 自动装配

什么是自动装配？即根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入，而不需要像property标签那样进行手动的配置。

实现步骤如下：

package com.xuan.自动装配;

/**
 * 部门类。
 */
public class Dept {
    @Override
    public String toString() {
        return "Dept{}";
    }
}

package com.xuan.自动装配;

/**
 * 员工类。
 */
public class Emp {
    // 多个员工属于一个部门
    private Dept dept;
    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "dept=" + dept +
                '}';
    }

    public void printInfo(){
        System.out.println(dept);
    }
}

xml配置文件，根据属性名称进行注入：

<!--
    bean标签的autowire可以做自动装配。
    autowire 属性常用两个值：
        byName 根据属性名称注入 ，被注入的bean的id值和注入类属性名称需要一样，否则会自动装配失败；
        byType 根据属性类型注入，被注入的类型的bean只能出现一次，否则会报错；
-->
<bean id="emp" class="com.xuan.自动装配.Emp" autowire="byName">
    <!--以下方式就是手动装配-->
<!--        <property name="dept" ref="dept"/>-->
</bean>
<bean id="dept" class="com.xuan.自动装配.Dept"/>

// 测试自动装配
@Test
public void t5(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean5_自动装配.xml");
    Emp emp = context.getBean("emp", Emp.class);
    System.out.println(emp);
}

4.1.12 引入外部属性文件

比如连接数据库的配置信息，引入德鲁伊jar包之后，可以直接编写在xml文件中，也可以定义在外部的properties文件中进行引入。

直接编写在xml文件中：

<!--直接编写连接池配置文件-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/userDb"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
</bean>

编写在外部properties文件中（使用较多）：

jdbc.propertes文件：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/userDb
username=root
password=root

编写xml配置文件，注需要在配置文件中引入context命名空间。

<!--引入外部属性文件-->
<context:property-placeholder location="jdbc.properties"/>
<!--获取配置文件中的信息-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${driverClassName}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</bean>

4.2 基于注解方式实现bean管理

什么是注解？ 注解是代码中的一种特殊标记，格式如下：

权限修饰符 @interface 注解名称(属性名=属性值,属性名=属性值...){
    ...
}

注解可以作用在类上面，方法上面，属性上面；使用注解的目的就是为了简化xml配置文件。

Spring针对Bean管理中创建对象提供了以下的注解：

@Componect；
@Service；
@Controller；
@Repository；

这四个注解的功能是一样的，都可以用来创建bean实例。只是按照习惯通常将它们放在不同的层级上面，如@Controller一般放在控制层的类上。

4.2.1 基于注解方式创建对象

第一步，引入依赖：

第二步，开启组件扫描

<!--
开启组件扫描。
如何一次扫描多个包？
    方式一，如果扫描多个包，多个包之间使用逗号隔开；
    方式二，扫描包的上一层目录；
-->
<context:component-scan base-package="com.xuanfeng"/>

第三步，创建类，在类上面添加Spring创建对象的注解

package com.xuanfeng.service;

import org.springframework.stereotype.Component;

/**
 * 这里注解里面的value属性值可以不写，默认值是类的首字母小写。即UserService -> userService。
 * @Component(value = "userService") 注意，这句话与：<bean id="userService" class="..."/>本质上是一样。
 */
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("userService add...");
    }
}

测试：

// 测试使用注解创建对象
@Test
public void t1(){
    // 加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

补充，开启组件扫描细节配置

<!--开启组件扫描细节配置-->
<!--
实例一：
    use-default-filters="false" 表示现在不使用默认 filter，而是使用自己配置的filter。
    context:include-filter ，设置扫描哪些内容。
-->
<context:component-scan base-package="com.xuanfeng" use-default-filters="false">
    <context:include-filter type="annotation"
                            expression="org.springframework.stereotype.Component"/>
</context:component-scan>

<!--
实例二：
    下面配置扫描指定包所有内容。context:exclude-filter设置哪些内容不进行扫描。
-->
<context:component-scan base-package="com.xuanfeng">
    <context:exclude-filter type="annotation" 
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

4.2.2 基于注解方式实现属性注入

Spring提供了以下的注解进行属性的注入：

**@Autowired，**根据属性类型进行自动装配；
**@Qualifier，**根据名称进行自动装配，需要与@Autowired属性一起使用；
**@Resource，**即可以根据类型注入，也可以根据名称进行注入；
**@Value，**注入普通类型的属性；

@Autowired注解的使用：

package com.xuanfeng.dao;

public interface UserDao {
    void add();
}

package com.xuanfeng.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("user dao add method...");
    }
}

package com.xuanfeng.service;

import com.xuanfeng.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    /*
    注入userDao属性，注意，这里不需要为userDao属性提供set方法，因为@Autowired注解已经进行了实现。
     */
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("user service add method...");
        // 调用userDao中的方法
        userDao.add();
    }
}

// 测试使用注解创建对象
@Test
public void t1(){
    // 加载配置文件
    ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

@Qualifiter注解的使用：

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("user dao add method...");
    }
}

@Service
public class UserService {
    /*
    注入userDao属性，注意，这里不需要为userDao属性提供set方法，因为@Autowired注解已经进行了实现。
     */
    @Autowired // 根据属性类型进行注入
    @Qualifier("userDao") // 根据属性名称进行注入
    private UserDao userDao;

    public void add(){
        System.out.println("user service add method...");
        userDao.add();
    }
}

@Resource注解的使用：

// @Resource  // 根据类型进行注入
@Resource(name = "userDao") // 根据名称进行注入
private UserDao userDao;

需要注意的是：@Resource注解是在javax.annotation.Resource;这个包下，而不是Spring官方提供的。

@Value注解：

// 用户名
@Value("Spring5")
private String username;

4.2.3 完全注解开发

第一步，创建配置类，用于替换xml配置文件

package com.xuanfeng.config;

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

/**
 * 将该类标识为Spring的配置类，所以需要@Configuration注解进行标识。
 */
@Configuration
// 指定扫描的组件包
@ComponentScan({"com.xuanfeng"})
public class SpringConfig {
}

第二步，测试，其他的配置与xml文件的使用是一样的，这里只是加载配置信息的方式变了

// 测试完全使用注解开发
@Test
public void t2(){
    // 加载配置类
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

5. AOP

5.1 什么是AOP

AOP（Aspect Oriented Programming，面向切面/方面编程），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

通俗描述：不通过修改源代码方式，在主干功能里面添加新功能；使用登录例子说明AOP：

5.2 AOP底层原理

AOP底层使用动态代理机制来实现，分为两种情况的代理：

有接口时，使用JDK动态代理；
没有接口时，使用GCLIB动态代理；

使用JDK动态代理：

主要是“创建接口实现类代理对象”，从而增强类的方法。

使用CGLIB动态代理：

主要是“创建子类的代理对象”，从而增强类的方法。

5.3 JDK动态代理

1. JDK动态代理，使用 Proxy 类里面的方法创建代理对象；

调用newProxyInstance()方法：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException

参数说明：

loader，类加载器；
interfaces，增强方法所在的类，这个类实现的接口，支持多个接口；
InvocationHandler，实现这个接口 InvocationHandler，创建代理对象，写增强的部分；

2. 编写JDK动态代理代码

步骤一，创建接口，定义方法

package com.xuan.dao;

public interface UserDao {
    int add(int a, int b);
    String update(String id);
}

步骤二，创建接口实现类，实现方法

package com.xuan.dao;

public class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

步骤三，使用 Proxy 类创建接口代理对象

package com.xuan.dao;

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

/**
 * UserDao的接口代理类。
 */
public class JDKProxy {
    public static void main(String[] args) {
        // 创建接口代理实现对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDaoImpl = new UserDaoImpl();
        UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDaoImpl));
        System.out.println(userDao.add(1, 2));
    }
}

// 创建代理对象
class UserDaoProxy implements InvocationHandler{

    /*
    创建的是谁的代理对象，就把谁传递过来。
    通过有参数构造方法进行传递。
     */
    private Object obj;
    public UserDaoProxy(Object obj){
        this.obj = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前
        System.out.println("即将执行的方法："+method.getName()+
                "\n该方法所传递的参数："+ Arrays.toString(args));

        // 被增强的方法执行
        Object result = method.invoke(obj, args);

        // 方法执行之后
        System.out.println("方法执行之后");
        return result;
    }
}

5.4 AOP术语

连接点
切入点
通知（也叫增强）
切面

5.5 AOP操作（准备工作）

Spring框架一般都是基于AspectJ实现AOP操作，AspectJ 不是 Spring 组成部分，而是独立的 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，从而进行AOP操作。

基于AspectJ实现AOP操作，有两种方式：

基于xml配置文件实现；
基于注解的方式实现（推荐使用）；

在项目中引入AOP相关依赖：

切入点表达式：

切入点表达式作用，知道对哪个类里面的哪个方法进行增强；

语法结构：

execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]))

注意：
	权限修饰符一般可以使用*代替，表示任意权限（通常指的是public|protected|private）；
	返回类型一般可以省略，直接使用空格即可；
	参数列表一般使用两个..代替；

举例 1：对 com.atguigu.dao.BookDao 类里面的 add方法进行增强

execution(* com.atguigu.dao.BookDao.add(..))

举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强

execution(* com.atguigu.dao.BookDao.* (..))

举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强

execution(* com.atguigu.dao.*.* (..))

5.6 AOP操作（AspectJ注解）

第一步，创建类，在类里面定义方法；

package com.xuan.aopannotation;

/**
 * 被增强的类。
 */
public class User {
    public void add(){
        System.out.println("add...");
    }
}

第二步，创建增强类（编写增强逻辑）

在增强类里面，创建方法，让不同方法代表不同通知类型。

package com.xuan.aopannotation;

/**
 * 增强类。
 */
public class UserProxy {
    // 代表前置通知
    public void before(){
        System.out.println("before...");
    }
}

第三步，进行通知的配置

引入命名空间；

使用注解创建User和UserProxy对象；

@Component
public class User {}

@Component
public class UserProxy {}

在增强类上面添加@Aspect注解；

@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 代表前置通知，结合切入点表达式进行使用
    @Before("execution(* com.xuan.aopannotation.User.add(..))")
    public void before(){
        System.out.println("before...");
    }
}

在 spring 配置文件中开启生成代理对象；

<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy/>

第四步，测试

配置不同类型的通知

在增强类里面，在作为通知方法上面添加响应的通知类型的注解，再使用切入点表达式配置。

@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 代表前置通知
    @Before("execution(* com.xuan.aopannotation.User.add(..))")
    public void before(){
        System.out.println("before...");
    }

    /*
     后置通知（也叫返回通知）在返回值之后执行，当遇到异常时不会执行。
     */
    @AfterReturning("execution(* com.xuan.aopannotation.User.add(..))")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    /*
    最终通知，在被增强的方法执行之后执行，遇到异常时同样会执行。
     */
    @After("execution(* com.xuan.aopannotation.User.add(..))")
    public void after(){
        System.out.println("after...");
    }

    // 异常通知
    @AfterThrowing("execution(* com.xuan.aopannotation.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }

    // 环绕通知
    @Around("execution(* com.xuan.aopannotation.User.add(..))")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕之前...");
        // 执行被增强的方法
        pjp.proceed();
        System.out.println("环绕之后...");
    }
}

抽取相同切入点：

public class UserProxy {

    // 相同切入点抽取
    @Pointcut("execution(* com.xuan.aopannotation.User.add(..))")
    public void pointCut(){
    }

    // 代表前置通知
    @Before("pointCut()")
    public void before(){
        System.out.println("before...");
    }
}

多个增强类同时对一个方法进行增强，设置增强类优先级：

在增强类上面添加 @Order(数字类型值)注解，数字类型值越小优先级越高。

@Component
@Aspect
@Order(1)
public class PersonProxy{}

完全使用注解开发：

创建配置类，不需要创建 xml 配置文件。

@Configuration
@ComponentScan({"com.xuan.aopannotation"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

5.7 AOP操作（AspectJ配置文件）

创建两个类，即增强类和被增强类，创建方法；

package com.xuan.aopxml;

/**
 * 被增强类。
 */
public class Book {
    public void buy(){
        System.out.println("buy...");
    }
}

package com.xuan.aopxml;

/**
 * 增强类。
 */
public class BookProxy {
    public void before(){
        System.out.println("before...");
    }
}

在Spring配置文件中创建两个对象；

<!--创建增强类与被增强类的对象-->
<bean id="book" class="com.xuan.aopxml.Book"/>
<bean id="bookProxy" class="com.xuan.aopxml.BookProxy"/>

在Spring配置文件中配置切入点；

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="p" expression="execution(* com.xuan.aopxml.Book.buy(..))"/>

    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--增强放在具体的方法上-->
        <!--前置通知-->
        <aop:before method="before" pointcut-ref="p"/>
    </aop:aspect>
</aop:config>

测试

// 测试配置文件
@Test
public void t2(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    // 增强的是User中的方法，所以这里获取的是user
    Book book = context.getBean("book", Book.class);
    book.buy();
}

6. JdbcTemplate

6.1 概念及准备工作

什么是JdbcTemplate？

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 更加方便实现对数据库操作。

准备工作：

相关jar包：

在Spring配置文件中配置数据库连接池：

<!--数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql:///user_db" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

配置JdbcTemplate对象，注入DataSource

<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"/>
</bean>

创建 service 类，创建 dao 类，在 dao 注入 jdbcTemplate 对象

首先在配置文件中开启组件扫描：

<context:component-scan base-package="com.xuan"/>

然后创建类：

package com.xuan.dao;

public interface BookDao {
}

package com.xuan.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao{
    // 注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

package com.xuan.service;

import com.xuan.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    // 注入dao层
    @Autowired
    private BookDao bookDao;
}

6.2 JdbcTemplate操作数据库

entity，Book类

6.2.1 增、删、改

编写service与dao，在dao进行数据库添加操作；调用JdbcTemplate对象里面update()方法法实现添加操作。更新、修改都差不多，这里不进行演示。

@Override
    public void addBook(Book book) {
        String sql = "insert into t_book values(?, ?, ?)";
        int affectRow = jdbcTemplate.update(sql, book.getBookId(), book.getBookName(), book.getBookStatus());
        System.out.println(affectRow);
    }

    @Override
    public void delBook(String bookId) {
        String sql = "delete from t_book where book_id = ?";
        int update = jdbcTemplate.update(sql, bookId);
        System.out.println(update);
    }

    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set book_name = ?, boo_status = ? where book_id = ?";
        int update = jdbcTemplate.update(sql, book.getBookName(), book.getBookStatus(), book.getBookId());
        System.out.println(update);
    }

测试：

@Test
public void updateBook(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    BookService bookService = context.getBean("bookService", BookService.class);
    // 添加数据
    //        bookService.addBook(new Book("tushu550", "Java核心卷1", 1));

    // 修改数据
    //        bookService.updateBook(new Book("tushu550", "Java核心卷2", 2));

    // 删除数据
    bookService.delBook("tushu550");
}

6.2.2 查询返回某个特定类型的值

如，select count(*) from t_book;查询图书数量；

函数，queryForObject(String sql, Class requiredType);

sql, 表示执行的sql；
requiredType，表示返回类型的Class，如返回整型，Integer.class；

public void NumberOfBook() {
    String sql = "SELECT COUNT(*) FROM t_book";
    Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
    System.out.println(integer);
}

6.2.3 查询返回对象

通常用在查询图书详细信息的时候。

函数，queryForObject(String sql, RowMapper rowMapper, Object… args);

sql，要执行的sql语句；
RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成

数据封装；
args，可变参数，通常用为sql语句中的 ? 号指定值；

public Book queryBookInfo(String bookId) {
    String sql = "select * from t_book where book_id = ?";
    return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), bookId);
}

6.2.4 查询返回集合

通常用在查询图书列表、分页的场景。

函数，query(String sql, RowMapper rowMapper, Object… args);

sql，要执行的sql语句；
RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成

数据封装；
可变参数，通常用为sql语句中的 ? 号指定值；

public List<Book> allBookInfo() {
    String sql = "select * from t_book";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class));
}

6.3 批量操作

批量操作，即操作表里面多条记录；这里使用批量添加操作演示；

函数，batchUpdate(String sql, List<Object[]> batchArgs);

sql，要执行的sql语句；
batchArgs，List 集合，添加多条记录数据；

public void batchUpdate(List<Object[]> batchArgs) {
    String sql = "insert into t_book values(?, ?, ?)";
    int[] batchUpdate = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(batchUpdate));;
}

测试，

// 批量插入图书
List<Object[]> bookList = new ArrayList<>();
Object[] o1 = {"tushu5510", "Python数据可视化实战", "2"};
Object[] o2 = {"tushu5511", "Python Django开发", "2"};
Object[] o3 = {"tushu5512", "Python Flask Web开发", "2"};
bookList.add(o1);
bookList.add(o2);
bookList.add(o3);
bookService.batchUpdate(bookList);

6.4 事务控制

什么是事务？

事务是数据库操作最基本单元，逻辑上属于一组操作，要么都成功，如果有一个失败则所有操作都失败；典型的应用场景就是转账：

 lucy 转账 100 元 给 mary
 lucy 少 100，mary 多 100

事务的四大特性（ACID）：

原子性；
一致性；
隔离性；
持久性；

6.4.1 环境搭建

在数据库中添加两条记录；

INSERT INTO t_user(username, money) VALUES('Lucy', 1000),('Mary', 1000);

创建service，dao，完成对象的创建与注入关系；即在service中注入dao，在dao中注入JdbcTemplate，在JdbcTemplate中注入DataSource；

package com.xuan.dao;

public interface UserDao {

    /**
     * 少钱的方法；
     */
    void reduceMoney();

    /**
     * 多钱的方法；
     */
    void addMoney();
}

package com.xuan.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao {
    // 注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    /*
    模拟 Lucy 给 Mary 转一百块钱。
     */
    @Override
    public void reduceMoney() {
        String sql = "update t_user set money = money - ? where username = ?";
        jdbcTemplate.update(sql, 100, "Lucy");
    }

    @Override
    public void addMoney() {
        String sql = "update t_user set money = money + ? where username = ?";
        jdbcTemplate.update(sql, 100, "Mary");
    }
}

package com.xuan.service;

import com.xuan.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    // 注入UserDao
    @Autowired
    private UserDao userDao;

    public void accountTest(){
        // Lucy 给 Mary 转 100
        userDao.reduceMoney();

        // Mary 收到 Lucy 的 100
        userDao.addMoney();
    }
}

<!--开启组件扫描-->
<context:component-scan base-package="com.xuan"/>

<!--数据库连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql:///guigu_bookdb" />
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
</bean>

<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入dataSource-->
    <property name="dataSource" ref="dataSource"/>
</bean>

测试

@Test
public void t1(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
    UserService userService = context.getBean("userService", UserService.class);
    userService.accountTest();
}

上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，则会出现问题。

public void accountTest(){
    // Lucy 给 Mary 转 100
    userDao.reduceMoney();
    
    // 模拟网络异常
    int i = 1/0;

    // Mary 收到 Lucy 的 100
    userDao.addMoney();
}

上面的问题如何解决呢？

这里使用事务控制进行解决。

6.4.2 Spring事务管理介绍

在JavaEE三层结构中，事务一般是添加在Service层（业务逻辑层）；
在Spring中进行事务管理操作，有两种方式：
- 编程式事务管理，如上面那种图，就是编程式管理的典型例子；
- 声明式事务管理（推荐使用）；

声明式事务管理：

基于注解方法（推荐使用）；
基于xml配置文件方式；

在Spring中进行声明式事务管理的底层使用了AOP原理。

Spring事务管理API，这个AIP提供了一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类。

6.2.3 声明式事务管理（注解）

在Spring配置文件中配置事务管理器；

<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

在配置文件中开启事务注解；

引入名称空间：

开启事务注解：

<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"/>

在Service类上面（或者Service类里面的方法上）添加事务注解；
- @Transactional，这个注解可以添加到类上面，也可以添加到方法上面；
- 如果把这个注解添加类上面，则这个类里面所有的方法都会被添加事务；
- 如果把这个注解添加方法上面，则这个方法会被添加事务；
```
@Service
@Transactional  // 使用声明式注解
public class UserService {}
```

补充：这里使用事务管理后，当模拟网络的异常时，如果事务不能进行回滚，解决思路是去看一下数据库中对应表的索引。如果对应表使用的索引是MyISM，则应该换成InnoDB，详细请看：连接.

6.2.4 声明式事务管理参数配置

在Service类上面添加注解@Transactional，在这个注解里面可以配置相关的参数。

**1. propagation：**事务传播行为，当一个事务的方法被另外一个事务的方法调用时候，这个事务方法如何进行。

事务传播行为

REQUIRED:

REQUIRED_NEW:

SUPPORTS:

@Transactional(propagation = Propagation.REQUIRED)

2. ioslation： 事务隔离级别

事务中有一个特性，这个特性交隔离级别，多事务操作之间不会产生影响。如果不考虑事务的隔离性，则会产生很多的问题。主要有三大问题：

脏读：一个未提交事务读取到另一个未提交事务的数据，通常都与事务的回滚有关；
不可重复读：一个未提交事务读取到另一提交事务修改的数据；
幻读；一个未提交事务读取到另一提交事务添加的数据；

通过设置事务的隔离级别可以解决以上的问题。

	脏读	不可重复读	幻读
READ UNCOMMITTED（读未提交）	有	有	有
READ COMMITTED（读已提交）	无	有	有
REPEATABLE READ（可重复读）	无	无	有
SERIALIABLE（串行化）	无	无	无

@Transactional(isolation = Isolation.READ_COMMITTED)

3. timeout： 超时时间

事务需要在一定的时间内进行提交，如果不提交该事务则会回滚。timeout的默认值是 -1 ，设置时间以秒单位进行计算。

5. readOnly： 是否只读

读通常对应于数据库的查询操作，写对应于数据库的添加、修改、删除操作。readOnly 默认值 false，表示可以进行CRUD操作，如果设置 readOnly 值为 true，则只能进行查询。

6. rollbackFor： 回滚

设置当程序出现哪些异常时，进行事务的回滚。

7. noRollbackFor： 不回滚

设置当程序出现哪些异常时，不进行事务的回滚。

6.2.5 XML声明式事务管理

在Spring配置文件中进行声明式事务管理配置。

配置事务管理器；
配置通知；
配置切入点和切面；

<!--1. 创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"/>
</bean>

<!--2. 配置通知-->
<tx:advice id="txAdvise">
    <!--配置事务参数-->
    <tx:attributes>
        <!--
        指定在那些方法上面添加事务（支持模糊匹配）；
        如：name="account*"表示所有以account开头的方法；
        -->
        <tx:method name="accountTest" propagation="REQUIRED" timeout="20" rollback-for="java.lang.Exception"/>
    </tx:attributes>
</tx:advice>

<!--3. 配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="p" expression="execution(* com.xuan.service.UserService.*(..))"/>
    <!--配置切面-->
    <aop:advisor advice-ref="txAdvise" pointcut-ref="p"/>
</aop:config>

6.2.6 完全注解实现声明式事务管理

package com.xuan.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration // 标记为配置类
@ComponentScan("com.xuan") // 组件扫描
@EnableTransactionManagement // 开启事务
public class TxConfig {
    // 创建数据库连接池
    @Bean  // 这个注解对应于配置文件中的bean标签
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///guigu_bookdb");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }


    /**
     * 创建JdbcTemplate对象
     * @param dataSource DataSource源，巧妙思想：直接让Spring到ioc容器中去寻找对应的类型。
     * @return JdbcTemplate对象。
     */
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        // 到ioc容器中根据类型找到dataSource进行注入
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        // 注入dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    // 创建事务管理器
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

7. Spring5框架新特性

整个 Spring5 框架的代码都是基于 Java8，运行时兼容 JDK9**，**许多不建议使用的类和方法在代码库中删除。

7.1 核心特性

7.1.1 日志

Spring 5.0 框架自带了通用的日志封装：

Spring5 已经移除 Log4jConfigListener，官方建议使用 Log4j2；
Spring5 框架整合 Log4j2；

第一步，引入jar包

第二步创建 log4j2.xml 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

7.2 核心容器

7.2.1 @Nullable注解

@Nullable 注解可以使用在方法 / 属性 / 参数上面，表示方法的返回值 / 属性值 / 参数值可以为空；

7.2.2 函数式风格

分别有这两个：GenericApplicationContext/AnnotationConfigApplicationContext，下面使用GenericApplicationContext进行演示。

/*
 函数式风格，可以理解为λ表达式。
 函数式风格创建的对象，可以交给 spring 进行管理。
 */
@Test
public void testGenericApplicationContext(){
    // 1. 创建GenericApplicationContext对象
    GenericApplicationContext context = new GenericApplicationContext();
    // 2. 调用context的方法去注册对象
    context.refresh();
    context.registerBean("u1", User.class, () -> new User());

    // 3. 获取在Spring中注册的u1对象
    /*
    第一种，如果在registerBean中没有指定beanName的值。则使用包类全名；
    第二种，如果指定了beanName的值，则使用指定的值进行获取；
     */
    User u1 = context.getBean("u1", User.class);
    System.out.println(u1);
}

7.2.3 整合JUnit5

整合Junit4：

第一步，引入Spring相关针对测试的依赖

如果是整合Junit4，则Junit4的相关依赖也要进行引入：

第二步，创建测试类，使用注解方式完成

package com.xuan.test;

import com.xuan.service.UserService;
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;

/**
 * Spring整合Junit4.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:bean1.xml") // 相当于是加载配置文件
public class JTest4 {
    // 自动注入UserService类
    @Autowired
    private UserService userService;

    @Test
    public void jT1(){
        userService.accountTest();
    }
}

整合Junit5：

第一步，引入 JUnit5 的 jar 包

第二步，创建测试类，使用注解完成


package com.xuan.test;


import com.xuan.service.UserService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;

/**
 * 整合Junit5.
 */
@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
public class JTest5 {
    @Autowired
    private UserService userService;

    @Test
    public void t1(){
        userService.accountTest();
    }
}

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
// 也使用复合注解代替上面的两个注解
@SpringJUnitConfig(locations = "classpath:bean1.xml")

            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>