Spring5框架核心IOC，AOP，SpringWebFlux等新特性

一、Spring概念

1、Sprig是轻量级，开源的javaEE框架。

2、Spring可以解决企业应用开发的复杂性。

3、IOC：控制反转，把创建对象过程交给Spring进行管理。

4、AOP：面向切面，不修改源码代码的情况下，进行功能增加。

5、方便解耦，简化开发，AOP编码支持，方便程序测试，方便和其他框架整合，方便进行事务操作，降低API开发难度。

二、IOC（控制反转）

1、IOC底层原理

控制反转，把创建对象过程交给Spring进行管理。将对象交给Spring管理，为了降低耦合度。

用到的技术：

• xml解析
• 工厂模式
• 反射

xml配置

class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值;//xml解析
        Class<?> clazz = Class.forName(classValue);
        return (UserDao)clazz.newInstance();
    }
}

1、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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 定义一个Bean -->
<!--    <bean id="..." class="...">-->
<!--        &lt;!&ndash; bean 配置 &ndash;&gt;-->
<!--    </bean>-->

    <!-- App bean -->
    <bean id="user" class="com.company.User" lazy-init="true"></bean>

</beans>

• 获取bean对象代码

public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.test();
    }

2、IOC接口（BeanFactory)

普通Bean：在配置文件中定义bean类型就是返回类型。

工厂Bean：在配置文件中定义bean类型和返回类型不一样。

1、IOC思想基于IOC容器完成，IOC容器底层就是通过工厂实现

2、Spring提供IOC容器实现两种方式（两个接口）

（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用

• 加载配置文件，不会去创建对象，使用对象是才创建对象。

（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般供开发人员进行使用。

• 加载配置文件的同时，创建配置文件。

ApplicationContext接口实现类

3、IOC操作Bean管理（基于xml)

ApplicationContext接口基于BeanFactory接口，比BeanFactory接口更强大，推荐使用

1、基于xml方式创建对象

1、在spring中的xml文件中使用Bean标签，标签里面添加对应属性。就可以实现创建

2、在bean标签中有很多属性，常用的属性。

*id 属性：唯一标识

*class属性：类包全路径（包类路径）

3、创建对象的时候，默认执行无参构造方法。

2、基于xml方式注入对象

1、DI：依赖注入，就是注入属性。（IOC的具体实现）

第一种注入方式：使用set方法注入：

ublic void setId(Integer id) {
    this.id = id;
}

public String getMemo() {
    return memo;
}

在spring配置文件中配置对象创建，配置属性注入。

配置TbTest对象创建

<bean id="tbTest" class="com.gwz.entity.TbTest"></bean>

set方式注入属性

<bean id="tbTest" class="com.gwz.entity.TbTest">
<property name="id" value="12"></property>
<property name="memo" value="2234"></property>
</bean>

第二种注入方式：使用有参构造注入：

1、在类中编写有参构造方法

public TbTest(Integer id) {
        this.id = id;
    }

2、在配置文件中配置有餐构造方式注入

<bean id="tbTest" class="com.gwz.entity.TbTest">
        <constructor-arg name="id" value="12"></constructor-arg>
    </bean>

第三种方式：名称空间

p名称空间方式注入，可以简化xml配置

1、添加p名称空间在配置文件中

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns="http://www.springframework.org/schema/p"
       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">

2、进行属性注入，在bean标签中进行操作。

<bean id="tbTest" class="com.gwz.entity.TbTest" p:id="12" p:memo="gwz"></bean>

3、xml注入其他类型的属性

1、字面量

1、null值

<property name="memo">
<null></null>
</property>

2、属性值中包含特殊字符

1、把<> 使用转移符号&lt, &gt

2、把特殊符号内容写到CDATA中

<property name="memo">
<value><![CDATA[<<南京>>]]></value>
</property>

3、注入外部Bean

1、定义UserDao接口，实现类UserDaoImpl、类UserService

2、在UserServie中定义set方法

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

3、配置文件注入对应的实现类UserDaoImpl

<bean id="userService" class="com.service.Userservice">
        <property name="userDao" ref="userDao"></property>
</bean>
    
<bean id="userDao" class="com.dao.UserDaoImpl"></bean>

4、注入内部bean和级联赋值

5、注入属性-内部bean和级联赋值

（1）一对多关系：部门和员工

一个部门有多个员工，一个员工属于多个部门。

部门 是1 -—— 员工N

6、注入属性-级联赋值

7、注入不用类型的属性

注入数组类型属性

注入List类型属性

注入Map集合类型属性

8、自动装配

根据指定装配规则（属性名和属性值类型），spring自动将属性匹配的值进行注入。

bean标签属性autowire。

autowire=“byName” 根据属性名称进行自动注入。

autowire=“byType” 根据类型进行自动注入。

9、外部属性文件

10、Bean的作用域

在spring里面，默认情况下，bean是单实例对象。

（1）如何设置单实例对象还是多实例对象。

Scope属性，作用域：

第一个值，默认值，singleton，表示单实例对象。

第二个值，prototype，表示多实例对象。

（2）单实例与多实例对比：

singleton与prototype，一个是单实例，一个是多实例

• 设置ingleton时，加载spring配置文件时就会创建单实例对象；

• 设置porotype，在获取bean的时候创建对象。

11、Bean的生命周期

7步操作

1、构造器创建bean实例（无参构造）

2、为bean的属性设置值和对其他的bean引用（调用set方法）

• 把bean实例传递给后置处理器（BeanPostProcessor)

3、调用bean的初始化方法（需要进行配置）

• 把bean实例传递给后置处理器

init-method

4、使用bean

5、当容器关闭是，调用bean的销毁方法（需要进行配置销毁的方法，手动调用销毁方法）

6、IOC操作Bean管理（基于注解)

1、什么是注解

1、注解是代码的特殊标记，

格式：

@注解名（属性名=属性值，属性名=属性值…)

2、使用注解

注解作用在类上，方法上，属性上。

3、使用注解的目的：简化xml配置。

2、创建对象提供注解

@Component
@Controller
@Service
@Repository

• 上面四个注解是一样的，都可以用来创建bean实例。

3、基于注解方式实现对象创建

第一步：引入依赖

spirng-aop-5.2.6RELEASE.jar

第二步：开启组件扫描

配置文件中，配置开启组件扫描

1、如果扫描多个包，多个包使用逗号隔开

2、扫描包上层目录。

<contenxt:component-scan base-package=“com.gwz”></contenxt:component-scan>

第三步：

在类上使用注解创建对象

@Component(value="userService")

在注解里面value属性值可以忽略不写，

默认值是类名称，首字母小写。

4、开启组件扫描细节

context:include-filter：设置扫描哪些内容。

use-default-filters=“false”：不适用默认filter,自己设置filter.

context:exclude-filter：排除要扫描的组件。

<context:component-scan base-package="com.gwz" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

3、属性注入

1、@Autowired：根据属性类型自动装配

第一步：把service 和 dao对象创建；在service 和 dao 类上，使用创建对象注解。

第二步：在service类中注入dao对象；在service中添加dao类型属性，在属性上使用@Autowired注解注入。

代码事例：

@Service
public class UserService {
    
    @Autowired
    UserDao userDao;
    
}

2、@Qualifier：根据属性名称进行注入

需要和@Autowired一起使用。

@Autowired
    @Qualifier(value = "newUserDao")
    UserDao userDao;

3、@Resource：根据类型，也可以根据名称注入。

@Resource：根据类型注入，类似于@Autowired

@Resource(name=“userDao”)：使用名称注入。

4、@Value：注入普通类型属性。

 @Value(value = "张三")
    private String memo;

4、完全注解开发

1、创建配置类，替代xml配置文件。

AnnotationConfigApplicationContext（config.class）这个类，可以加载配置类。

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

   
}

三、AOP（面向切面编程）

面向切面，不修改源码代码的情况下，进行功能增加。

1、AOP底层使用动态代理

有两种情况动态代理

第一种：有接口情况，使用JDK动态代理。

• 这个有接口的是实现接口，创建代理对象。

• 具体实现

  参考我的动态代理

  方法的三个参数

  newProxyInstance（param1, param2, param3）

  第一个：类加载器

  第二个：增强方法所在的类，这个类实现的接口，支持多个

  第三个：实现这个接口IncocatioinHandle,创建代理对象，写增强方法。

第二种： 没有接口情况，使用CGLIB动态代理。

• 这个没有接口的是，创建子类的代理对象实现.
  

2、AOP（术语）

1、连接点、

类里面哪些方法可以被增强，这些方法被称为连接点。

2、切入点

实际被真正增强的方法，被称为切入点。

3、通知（增强）

（1）实际被增强的逻辑部分称为通知（增强）

通知有很多类型：顺序从上到下。

• 前置通知（before）
• 环绕通知（Around )
• 后置通知（After)
• 异常通知（AfterThrow)
• 最终通知（AfterReturning)

4、切面

一个动作。

把通知应用到切入点的过程。

3、AOP操作

1、spring框架一般都是基于AspectJ实现AOP操作。

什么是AspectJ

AspectJ不是spring组成部分，独立于AOP框，一般把AspectJ和Spring框架一起执行AOP操作。

2、基于Aspect实现AOP操作

• 基于xml配置文件实现
• 基于注解方式实现操作。

3、引入相关依赖

4、切入点表达式

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

2、语法结构：

execution【权限修饰符】【返回类型【类全路径】【方法名称】（【参数列表】）

举例说明：

例1：
对com.gew.dao.UserDao类里面的add方法进行增强
execution(* com.gwz.dao.UserDao.add(...))
例2:对com.gew.dao.UserDao类里面的所有方法进行增强
execution(* com.gwz.dao.UserDao.*(...))
例3:对com.gew.dao所有类里面的所有方法进行增强
execution(* com.gwz.dao.*.*(...))

1、注解实现 （AspectJ

1、创建类，在类里面定义方法

public class User{
	public void add(){
		System.out.println("add..");
	}
}

2、创建增强类(编写增强逻辑)

让不同方法代表不同的通知类型。

public class UserProxy{
	public void before(){		System.out.println("add..");
	}
}

3、进行通知的配置

• 1、在spring配置文件中开启注解扫描

• 2、使用注解@Component创建被增强类，增强类 的对象

• 3、在增强类上添加注解@Aspect，

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

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

  @EnableAspectJAutoProxyr注解等同于配置文件。
  

• 4、配置不同类型通知

  1、在增强类里面，在作为通知方法上面添加通知类型注解，使用切入点配置内容。

  @Before(value=“execution(* com.gwz.dao.UserDao.add(…))”)

完全注解开发：

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

@Configuration

@ComponentScan(basePackages={“com.atguigu”})

@EnableAspectJAutoProxy

2、切入点的抽取

@Pointcut("execution(* com.gwz.spring.test.User.add())")
public void pointDemo(){
    
}

@Before(value = "pointDemo()")
public void before(){
    System.out.println("Before....");
}

3、多个增强类如何解决

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

数字类型相同时，按类的名称排列优先级。

4、配置文件实现（AspectJ)

<bean id="userProxy" class="com.gwz.spring.test.UserProxy"></bean>
    
    <!-- 增强aop配置   -->
    <aop:config>
        <!--   配置切入点     -->
        <aop:pointcut id="p" expression="execution(* com.gwz.spring.test.User.add())"/>

        <!--   配置切面     -->
        <aop:aspect ref="userProxy">
        <!--     增强作用在哪个具体的方法上      -->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>

四、事务

JdbcTemplate(概念和准备)

spring对Jdbc进行封装，使用JdbcTemplate简化数据库操作。

1、什么是事务

事务是一组逻辑上的操作单元。事务是数据库最基本的操作单元，要么成功，要么失败。

典型案例：银行转账。

2、事务四个特性（ACID)

1、原子性：要么成功，要么失败

2、一致性：保持总量不变。

3、隔离性：事务之间的操作互不干扰

4、持久性：操作完后，数据库数据才真正改变。

3、事务操作（Spring事务管理介绍）

1、事务添加到JaveEE三层结构里面的Service层（业务逻辑层）

2、在Spring进行事务管理操作

1、有两种方式：编程式事务管理；申明式事务管理（常用）

3、申明式事务管理

（1）基于注解方式（常用）

（2）基于xml配置方式

开发常用逻辑思维。

try{
	//1、开启事务
	
	//2、数据库操作
	
	//3、事务提交

}catch(Exception e){
	//4、事务回滚
}

4、在Spring进行申明式事务管理，底层使用AOP原理

5、Spring事务管理API

（1）提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类。

4、申明式事务管理(注解实现)

1、在spring配置文件配置事务管理

<bean id="datSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc://mysql/user_db"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    </bean>

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

2、在Spring配置文件中，开始事务注解

1、引入名称空间，

2、开启事务注解

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"></tx:annotation-driven>

3、在service类上面（或者servcie类里面的方法上面）

• @Transactional，这个注解添加到类里面，也可以加到方法上面、
• 如果加到类上，就是这个类里的所有方法到添加事务
• 如果这个注解加到方法上，就是这个方法加注解。

5、事务操作（申明式事务管理参数配置）

1、在service类上面添加注解@Transactional,这个注解里面可以配置事务相关参数。

2、propagation：事务传播行为

多事务方法之间进行调用，这个过程是如何管理的。

事务传播行为：

常用的两种传播行为：

3、isolation:事务隔离级别

• 多事务之间操作，不会产生影响，不考虑隔离性产生很多问题。
• 有三个读问题：脏读、不可重复读、虚（幻）读。

**脏读：**一个未提交事务读取到另一个未提交事务的数据。

**不可重复读：**一个未提交的事务读取到了另一个提交事务修改的数据。（两次读取的数据不一样）

**幻读：**一个未提交的事务读到一已提交的事务添加的数据。

**解决：**通过设置事务隔离级别，解决读问题。

@Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.REPEATABLE_READ)

4、timeout：超时时间

• 事务需要在一定的时间只能提交，如果不提交进行回滚

• 默认值是-1，设置时间可以以秒为单位进行计算。

5、readOnly：是否可读

• 读：查询操作，写：添加修改删除操作

• readOnly默认值false，表示可以查询，可以添加修改删除操作

• 设置readOnly值是true,设置成true之后，只能查询

6、rollbackFor：回滚

设置出现哪些异常进行事务回滚

7、noRoollbackFor：不回滚

设置出现哪些异常不回滚。

6、spring事务（xml实现）

1、配置事务管理器

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

2、配置通知

<!-- 配置事务通知   -->
<tx:advice id="txadvice">
    <!--  设置哪种规则的方法上面添加事务      -->
    <tx:attributes>
        <tx:method name="add" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

3、配置切入点和切面

<!--  配置切人点和切面  -->
    <aop:config>
        <!--    配置切入点    -->
        <aop:pointcut id="pt" expression="execution(* com.gwz.spring.test.UserProxy.before())"/>
        <!--   配置切面     -->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

7、Spring事务完全注解开发

1、创建配置类

2、添加配置类注解，添加这几扫描。

3、开始事务

4、创建数据库连接池。

5、创建事务管理器

@Configuration
@ComponentScan(basePackages = {"com.gwz"})
@EnableTransactionManagement
public class TestTransactionConfig {


    /**
     * 创建数据库连接池
     * @return
     */
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl("jdbc:mysql:///user_db");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("root");
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        return druidDataSource;
    }

    /**
     * 创建JdbcTemplate对象
     * @param dataSource
     * @return
     */
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        // 到IOC容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入数据源
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

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

        return dataSourceTransactionManager;
    }

}

五、Spring5新特性

1、日志的使用Log4j2

publi static final Logger logger = LoggerFactory.getLogger();

2、Spring5框架核心容器支持@Nullable注解

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

2、 注解在方法上，方法返回值可以为空。

@Nullable

String getId()

3、注解使用

方法参数可以为空。

public void getinfo（@Nullable String name）

4、函数式编程，创建对象

3、Spring5支持整合Junit5

4、SpringWebflux介绍

1、是spring5添加新的模块，用于web开发，功能SpringMVC类型，Webflux使用当前一种比较流行的响应式编程出现的框架。

2、传统web框架，比如SpringMVC，这些基于Servlet容器，Webflux是一种一部非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。

**异步和同步：**调用者发送请求，如果等到对方回应之后才去做其他事情就是同步。反之亦然。

**阻塞和非阻塞：**被调用者收到请求之后，做完请求任务之后才给出反馈就是阻塞，收到请求之后立马给出反馈，然后去做其他事就是非阻塞。

1、Webflux特点：

第一：非阻塞式：在有限的资源下，提高系统吞吐量和伸缩性。以Reactor为基础，实现响应式编程，

第二：函数式编程：Spring5框架基于java8，Webflux使用java8函数式编程方式实现路由请求。

2、SpringMVC和Webflux比较

第一：两个框架都可以使用注解方式，都运行在Tomcat等容器中

第二：SprignMVC采用命令式编程，Webflux采用异步响应式编程。

3、什么是响应式编程。

响应式编程是一种面向数据量和变化传播的编程式范式。

Observer 和 Observerable

4、响应式编程（Reactor实现）

（1)响应式编程操作中，Reactor是满足Reactive规范的框架

(2) Reactor有两个核心类，Mono和Flux。这个连个类都是实现了Publisher

Flux对象实现发发布者，返回N个元素。

Mono实现发布者，返回0或者1个元素。

（3）Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：

元素值，错误信号，完成信号

，错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者。

（4）引入依赖io.projectreactor

（5）三种信号特点：

• 错误信号和完成信号都是终止信号，不能共存。
• 如果没发送任何元素值，而是直接发送错误或者完成信号，表示空数据流
• 如果没有错误信号，没有完成信号，表示无限数据流

（6）调用just或者其他方法只是申明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生。

（7）操作符

对数据流进行一步步操作，成为操作符，比如工厂流水线。

map：元素映射为新的元素

flatMap:把每个元素转换流，把转换之后多个流合并大的流。

5、SpringWebflus执行流程和核心API

SpringWebflux基于Reactor，默认使用容器是Nettry, Netty是高性能的NIO框架，一部非阻塞的框架

BIO：同步阻塞

（1）Netty：

NIO：同步非阻塞

（2）SpringWebflux执行过程和SpirngMVC相似

• SpringWebflux核心控制器DispatchHandler，实现接口WebHandler

（3）SpringWebflux里面DispatcherHandle，负责请求处理

• HandlerMapping：请求查询到处理的方法
• HandlerAdapter：真正负责请求处理
• HandlerResultHandler：响应结果处理。

（4）SpringWebflux实现函数式编程，两个接口

RouterFunciton（路由处理） HandlerFunction （处理函数）

5、SpringWebflux（基于注解编程模型）

1、注解编程模型

2、函数式编程模型

第一步：创建SpringBoot工程，引入Webflux依赖

第二步：配置端口启动号

第三步：创建实体，创建接口定义操作方法。

Mono：返回零个或一个

Flux：返回一个或多个

第四步：创建实现类，编程具体逻辑

第五步：编写controller

说明：

SpringMVC实现方式实现，同步阻塞BIO：SpringMVC +Servlet+Tomcat

SpringWebflux实现，异步非阻塞方式：SpringWebflux+Reactor+Netty

6、SpringWebflux（基于注解编程模型）

1、在使用函数是编程模型操作时，需要自己初始化服务器。

2、基于函数式编程模型时候，有两个核心接口，RouterFunction（实现路由功能，请求转发给对应的handler）和HandlerFunction(处理请求生成响应函数）核心任务定义两个函数式接口的实现，并启动需要的服务器。

3、SpringWebflux请求和响应不再是ServletRequest和ServletResponse，而是ServerRequest 和 ServerResponse。

参数需要些ServerRequest request

4、路由创建

路由请求方式：

5、创建服务器，完成适配

7、使用WebClient实现调用

六、总结：

1、Spring框架概述

• 轻量开源JaveEE框架，为了解决企业级开发复杂性，两个核心IOC，AOP

• IOC（控制反转）：

  底层（工厂、反射等）

  接口（BeanFactory)

  操作Bean管理（基于xml)

  操作Bean管理（基于注解)

• AOP（面向切面编程）

  AOP底层（不修改源代码的情况，增强逻辑）、动态代理，

  有接口：JDK动态代理

  没有接口：CGLIB动态代理

  术语：接入点，切入点，通知，切面

  xml实现 和 注解实现

• JdbcTemplate实现CRUD

• 事务

  事务特性、事务隔离级别、传播特性，

  基于注解实现声明式事务管理

  完全注解实现申明式事务管理。

• Spring5新特性

  整合日志框架

  @Nullable注解

  函数式注册对象

  整合Junit5单元测试对象

  SpringWebflux使用。