spring5学习笔记

Spring5框架

* Spring5框架概述

• Spring 是轻量级的开源的 JavaEE 框架
• Spring 可以解决企业应用开发的复杂性
• Spring 有两个核心部分：IOC 和 Aop
  • IOC：控制反转，把创建对象过程交给 Spring 进行管理
  • Aop：面向切面，不修改源代码进行功能增强
• Spring 特点
  • 方便解耦，简化开发
  • Aop 编程支持
  • 方便程序测试
  • 方便和其他框架进行整合
  • 方便进行事务操作
  • 降低 API 开发难度

* IOC概念和原理

- 什么是IOC

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

- IOC底层原理

xml 解析、工厂模式、反射

- BeanFactory 接口

* IOC操作Bean管理

• 什么是 Bean 管理

  • Bean 管理指的是两个操作
  • Spring 创建对象
  • Spirng 注入属性

• Bean 管理操作有两种方式

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

* IOC操作bean管理（基于xml）

- 基于XML创建对象

<bean id="Book" class="spring5_demo.Book">

• 在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

• 在 bean 标签有很多属性，介绍常用的属性

  • id 属性：唯一标识
  • class 属性：类全路径（包类路径）

• 创建对象时候，默认也是执行无参数构造方法完成对象创建

- 基于XML注入属性

DI：依赖注入，就是注入属性

+ 注入方式一:set方法注入

步骤：

• 创建类，定义属性和对应的 set 方法
  

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

+ 注入方式二：使用有参数构造进行注入

步骤：

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

• 在 spring 配置文件中进行配置

注意：使用构造函数进行注入时默认调用的是无参构造器，因为我们重写了构造器，所以覆盖了无参构造器，所以在还没有写constructor-arg等时会报错，只有通过constructor-arg这个标签对每一个属性进行赋值才不会报错

+ 注入方式三：p名称空间注入（了解）

下方第一步中即为在配置文件中加上灰色的那一行文字：xmlns:p=“http://www.springframework.org/schema/p”

第二部即为直接在class后方添加属性p:bname等

* 注入属性

- 注入空值和特殊符号

+ set方法注入空值

通过set方法注入空值：

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

即为在property标签内加上

+ set方法注入特殊符号

首先在value=""内大于号小于号的转义仍然可用，即为：

小于号为<
大于号为>

如果不想转义还要写入特殊符号，就需要如下：

要传入的value值为 <<南京>>
就需要如下的写法：<![CDATA[    ]]>
< property  name= "address">
< value><![CDATA[<<南京>>]]></ value>
</ property>

- 注入属性-外部Bean

步骤：

• 创建两个类 service 类和 dao 类
• 在 service 调用 dao 里面的方法
• 在 spring 配置文件中进行配置

- 注入属性-内部Bean

以下是以员工和部门进行举例

（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
部门是一，员工是多
（2）在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示

- 注入属性-级联赋值

+ 写法1

+ 写法2

* IOC操作Bean管理（XML注入集合属性）

- 注入数组类型属性

<!--        数组类型注入-->
        <property name="courses">
<!--            在下方可用list标签或者array标签-->
            <array>
            <value>java课程</value>
            <value>javaWeb课程</value>
            <value>mysql课程</value>
            <value>Linux课程</value>
            </array>
        </property>

- 注入List类型属性

<!--        List类型注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王五</value>
                <value>小桑</value>
            </list>
        </property>

- 注入Map类型属性

<!--        Map类型注入-->
        <property name="maps">
            <map>
                <entry key="Java" value="java"/>
                <entry key="C++" value="c++"/>
                <entry key="JavaWeb" value="jw"/>
                <entry key="Mysql" value="mysql"/>
            </map>
        </property>

- 注入Set类型属性

<!--        set类型注入-->
        <property name="set">
            <set>
                <value>java</value>
                <value>javaWeb</value>
                <value>mysql</value>
                <value>c++</value>
            </set>
        </property>

- 在集合中注入对象类型值

<!--        要注入List集合类型，其中的值为对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"/>
                <ref bean="course2"/>
                <ref bean="course3"/>
            </list>
        </property>
    </bean>
    <bean id="course1" class="collectiontype.Course">
        <property name="cname" value="课程1"/>
    </bean>
    <bean id="course2" class="collectiontype.Course">
        <property name="cname" value="课程1"/>
    </bean>
    <bean id="course3" class="collectiontype.Course">
        <property name="cname" value="课程1"/>
    </bean>

- 将集合注入部分提取出来

+ 在 spring 配置文件中引入名称空间 util

+ 使用 util 标签完成 list 集合注入提取

<util:list id="bookList">
    <value>哇咔咔</value>
    <value>呜啦啦</value>
    <value>欸嘿嘿</value>
</util:list>
<bean id="book" class="collectiontype.Book">
    <property name="list" ref="bookList">
    </property>
</bean>

- FactoryBean

• Spring 有两种类型 bean ，一种普通 bean ，另外一种工厂 bean （FactoryBean)
• 普通 bean ：在配置文件中定义 bean
• 工厂 bean ：在配置文件定义 bean类型可以和返回类型不一样
  • 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
  • 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

//定义的类型为MyBean类型，返回的为Course类型
public class MyBean implements FactoryBean<Course> {
    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
}

要注意，如果要返回与定义类型不同的类型时，需要注意修改Course course = context.getBean(“myBean”, Course.class);

//测试代码
public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean7.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

- bean作用域

+ bean默认为单实例

Spring中默认情况下bean为单实例对象

+ 设置单或多实例（scope属性）

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

• scope 属性值

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

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

• singleton 和 prototype 区别
  • 第一 singleton 单实例，prototype 多实例
  • 第二 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建 对象，在调用getBean 方法时候创建多实例对象

- bean生命周期

生命周期即为从对象创建到销毁的过程

+ 生命周期

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

代码演示：

//设置的实例对象
public class Orders {
    private String oname;
    public Orders() {
        System.out.println("第一步调用Orders内的无参构造器");
    }
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二部调用oname的set方法设置属性的值");
    }
    //创建执行初始化方法
    public void initMethod(){
        System.out.println("第三步执行初始化方法");
    }
    //销毁方法
    public void destroyMethod(){
        System.out.println("第五步执行销毁的方法");
    }
}

//测试代码
public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean8.xml");
        Orders orders = context.getBean("orders",Orders.class);
        System.out.println("第四步获取创建bean实例对象");
        System.out.println(orders);
        //销毁bean实例对象，调用close方法
        orders.destroyMethod();
        context.close();
    }

- bean的后置处理器（七步生命周期）

• 通过构造器创建 bean 实例（无参数构造）

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

• 把 n bean 实例传递 n bean 后置处理器的方法 postProcessBeforeInitialization

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

• 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

• bean 可以使用了（对象获取到了）

• 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
  

- 演示添加后置处理器效果

创建类，实现接口 BeanPostProcessor，创建后置处理器

//后置处理器在初始化前后要执行的代码
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("插入在第二部和第三步之间 ：在初始化开始之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("插入在第三部和第四步之间 ：在初始化结束之前执行的方法");
        return bean;
    }
}

<!--    配置后置处理器-->
    <bean id="myBeanPost" class="bean.MyBeanPost"/>

- XML自动装配

• 手动装配即为手动设置哪个属性有什么值，如在标签property中手动装配name属性和对于的value值

• 自动装配不需要写property这一行，根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

+ 自动装配分为byName与byType

bean标签属性autowire，配置自动装配

autowire属性常用两个值，一个是byName，即为按照属性名称注入，一个是byType，即为按照属性类型注入

代码演示：

//根据属性名称自动装配
<bean id="emp" class="Spring_learning_package.autoWire.Emp" autowire="byName">
<property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="Spring_learning_package.autoWire.Dept"></bean>

//根据属性类型自动装配
<bean id="emp" class="Spring_learning_package.autoWire.Emp" autowire="byType">
<property name="dept" ref="dept"/>
</bean>
<bean id="dept" class="Spring_learning_package.autoWire.Dept"></bean>

* 外部属性文件

<!--    引入-->
<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"
       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/util
http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

- 直接配置数据库信息

• 配置德鲁伊连接池
• 引入德鲁伊连接池依赖 jar

<!--    最基本的配置方式直接配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"/>
        <property name="username" value="root"/>
        <property name="password" value="hd200308041410"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>

- 引入外部属性文件配置数据库连接池

• 创建外部属性文件，properties 格式文件，写数据库信息
• 把外部 properties 属性文件引入到 spring 配置文件中，引入 context 名称空间

<!--    引入外部属性文件-->
    <context:property-placeholder location="jdbc.properties"/>
<!--    配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"/>
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.userName}"/>
        <property name="password" value="${prop.password}"/>
    </bean>

* 注解（@）

- 什么是注解

• 注解是代码特殊标记，格式：

  @注解名称(属性名称=属性值, 属性名称=属性值…)

• 使用注解，注解作用在类上面，方法上面，属性上面

• 使用注解目的：简化 xml 配置

- Spring针对Bean管理中创建对象提供注解

• @Component
• @Service
• @Controller
• @Repository

上面四个注解功能相同，都可以创建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:p="http://www.springframework.org/schema/p"
         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 http://www.springframework.org/schema/context/spring-context.xsd">
  

• 开启组件扫描

  <!--    开启组件扫描-->
      <!--    扫描多个包的写法,即为多个包的路径使用逗号隔开-->
      <!--    如果要扫描的包都在一个包下，那么可以扫描上层的包-->
      <context:component-scan base-package="Spring_learning_package"/>
  

• 创建类，在类上添加创建对象注解

//Component后跟上的value可以不写，如果不写的话值默认为类名称的首字母小写
@Component(value = "userService") //实际上与<bean id="userService" class="XXXXXX>
public class UserService {
    public void add(){
        System.out.println("service add.....");
    }
}

- 开启组件扫描细节配置

• use-default-filters=“false” 表示现在不使用默认 filter，自己配置 filter
• context:include-filter ，设置扫描哪些内容

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

• 下面配置扫描包所有内容
• context:exclude-filter： 设置哪些内容不进行扫描

<context:component-scan base-package="Spring_learning_package">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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

+ @Autowired 根据属性类型自动装配

• 第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
• 第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

//Component后跟上的value可以不写，如果不写的话值默认为类名称的首字母小写
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    publi,c void add(){
        System.out.println("service add.....");
        userDao.add();
    }
}

+ @Qualifier：根据名称进行注入

这个@Qualifier 注解的使用，和上面@Autowired 一起使用

如下案例，其中@Qualifier(value = “userDaoImpl1”)中的值要与@Repository(value = “userDaoImpl1”)相同才能匹配上

@Service
public class UserService {
    @Autowired
    //通过名称进行注入
    @Qualifier(value = "userDaoImpl1")
    private UserDao userDao;
    public void add(){
        System.out.println("service add.....");
        userDao.add();
    }
}

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

+ @Resource 根据类型注入或名称注入

通过该标签指定实现类，指定依据可以自行选择，但是需要在两个类中均相同

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

+ @Value：注入普通类型属性

可以在该标签的下方直接设置一个值，默认标签内的value值会赋值给该设置的值

注意：只能传入一个String值，但是会自动转化为你需要的类型，如int，char,boolean等，但是传入的数据要复合类型值规范，否则会报错

@Value(value = "abcde")
    private String name;
@Value(value = "3")
    private int name;
@Value(value = "a")
    private char name;
@Value(value = "true")
    private boolean name;

- 完全注解开发

• 创建配置类，替代 xml 配置文件

  @Configuration//将当前类作为一个配置类
  //下面一行与bean文件中的<context:component-scan base-package="Spring_learning_package"/>是等价的
  @ComponentScan(basePackages = "Spring_learning_package")
  public class SpringConfig {
      
  }
  

• 编写测试类(除了上方的修改外只有测试类不同其他不变)

  //使用完全注解开发时的测试方法
      @Test
      public void testService2() {
          ApplicationContext context
                  =  new AnnotationConfigApplicationContext(SpringConfig. class);
          UserService userService = context.getBean( "userService",
                  UserService. class);
          System. out .println(userService);
          userService.add();
      }
  

* AOP概念

• AOP即为面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得
  业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
• 通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
• 使用登录例子说明 AOP
  

* AOP底层原理

- AOP使用动态代理

AOP有两种动态代理模式

+ 有接口采用JDK动态代理

创建接口实现类代理对象，增强类的方法

+ 无接口采用CGLIB动态代理

创建子类的代理对象，增强类的方法

- AOP（JDK动态代理）

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

+ 调用 newProxyInstance 方法

方法有三个参数：

• 第一参数，类加载器
• 第二参数，增强方法所在的类，这个类实现的接口，支持多个接口
• 第三参数，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

- 编写JDK动态代理代码

• 创建接口，定义方法

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

• 创建接口实现类，实现方法

  public class UserDaoImpl2 implements UserDao2{
      @Override
      public int add(int a, int b) {
          return a+b;
      }
      @Override
      public String update(String id) {
          return id;
      }
  }
  

• 使用 Proxy 类创建接口代理对象

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao2.class};
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        UserDaoImpl2 userDaoImpl2 = new UserDaoImpl2();
        UserDao2 userDao2 = (UserDao2) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new UserDaoProxy(userDaoImpl2));
        int result = userDao2.add(1,2);
        System.out.println("result:"+result);
    }
}
//创建代理对象代码
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()+"：传递的参数"+ Arrays.toString(args));
        Object res = method.invoke(obj,args);
        System.out.println("方法之后执行..."+obj);
        return res;
    }
}

- AOP术语

+ 连接点

+ 切入点

+ 通知（增强）

+ 切面

- AOP操作

• Spring 框架一般都是基于 AspectJ 实现 AOP 操作
  • AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使用，进行 AOP 操作
• 基于 AspectJ 实现 AOP 操作
  • 基于 xml 配置文件实现
  • 基于注解方式实现（使用）
• 在项目工程里面引入 AOP
  

- 切入点表达式

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

• 语法结构：

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

//举例 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.*.* (..))

- AOP 操作（AspectJ 注解)

• 在增强类中创建方法

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

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

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

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

  //增强的类
  @Component
  @Aspect //生成代理对象
  public class UserProxy {}
  

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

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

• 配置不同类型的通知

  //增强的类
  @Component
  @Aspect //生成代理对象
  public class UserProxy {
      //前置通知
  //@Before 注解表示作为前置通知
      @Before(value = "execution(* Spring_learning_package.aopanno.User.add(..))")
      public void before() {
          System.out.println("before.........");
      }
  
      //后置通知（返回通知）
      @AfterReturning(value = "execution(* Spring_learning_package.aopanno.User.add(..))")
      public void afterReturning() {
          System.out.println("afterReturning.........");
      }
  
      //最终通知
      @After(value = "execution(* Spring_learning_package.aopanno.User.add(..))")
      public void after() {
          System.out.println("after.........");
      }
  
      //异常通知
      @AfterThrowing(value = "execution(* Spring_learning_package.aopanno.User.add(..))")
      public void afterThrowing() {
          System.out.println("afterThrowing.........");
      }
  
      //环绕通知
      @Around(value = "execution(* Spring_learning_package.aopanno.User.add(..))")
      public void around(ProceedingJoinPoint proceedingJoinPoint) throws
              Throwable {
          System.out.println("环绕之前 .........");
  //被增强的方法执行
          proceedingJoinPoint.proceed();
          System.out.println("环绕之后 .........");
      }
  }
  

• 测试输出

+ 增强类优先级

如果有多个增强类对同一个方法进行增强，设置增强类优先级

注意：设置优先级需要使用到@Order注解，在其后括号内填入从1开始得到数字，数字越小优先级越高

+ 完全注解开发

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

- AOP 操作（AspectJ 配置文件)

• 创建两个类，增强类和被增强类，创建方法
• 在 spring 配置文件中创建两个类对象

<!--    创建对象-->
    <bean id="book" class="Spring_learning_package.aopT.Book"/>
    <bean id="bookProxy" class="Spring_learning_package.aopT.BookProxy"/>

• 在 spring 配置文件中配置切入点

<!--    配置aop增强-->
    <aop:config>
<!--        切入点-->
        <aop:pointcut id="p" expression="execution(* Spring_learning_package.aopT.Book.buy(..))"/>
<!--        配置切面-->
        <aop:aspect ref="bookProxy">
<!--            增强作用在具体的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

* JdbcTemplate对数据库增删改查

- 什么是JdbcTemplate

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

- 进行对数据库表的添加操作

• 配置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"
         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 http://www.springframework.org/schema/context/spring-context.xsd
                             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  <!--    开启组件扫描-->
      <context:component-scan base-package="Spring_learning_package"/>
      <!-- 数据库连接池 -->
      <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
            destroy-method="close">
          <property name="url" value="jdbc:mysql:///user_db?serverTimezone=UTC" />
          <property name="username" value="root" />
          <property name="password" value="hd200308041410" />
          <property name="driverClassName" value="com.mysql.jdbc.Driver" />
      </bean>
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
          <property name="dataSource" ref="dataSource"/>
      </bean>
  </beans>
  

• 创建实体类
  

• 编写Dao,BookDaoImpl

  @Repository
  public class BookDaoImpl implements BookDao{
  @Autowired
      private JdbcTemplate jdbcTemplate;
  
      @Override
      public void add(Book book) {
          String sql = "insert into t_book values(?,?,?)";
  
          int update = jdbcTemplate.update(sql,book.getUserId(),book.getUsername(),book.getUstatus());
          System.out.println(update);
      }
  }
  

  @Service
  public class BookService {
  @Autowired
      private BookDao bookDao;
  public void addBook(Book book){
  bookDao.add(book);
  }
  }
  

  • 编写测试类

    public class TestBook {
        @Test
        public void testJdbcTemplate(){
            ApplicationContext context = new ClassPathXmlApplicationContext("mysqlTest.xml");
            BookService bookService = context.getBean("bookService",BookService.class);
            Book book = new Book();
            book.setUserId("123");
            book.setUsername("老港吗");
            book.setUstatus("1241wdqw12e");
            bookService.addBook(book);
        }
    }
    
    

  • 检查输出，输出为1，说明添加成功

    
    

- 查询表中数据条数

public int selectCount() {
        String sql = "select count(*) from t_book";
        return jdbcTemplate.queryForObject(sql,Integer.class);
    }

 public int findCount(){
        return bookDao.selectCount();
    }

//查询返回的一个数
        int count = bookService.findCount();
        System.out.println(count);

- 查询指定id的对象数据

调用 **jdbcTemplate.queryForObject()**方法实现查询对象

//接口中编写查询方法
Book findBookInfo(String id);

//实现方法
@Override
    public Book findBookInfo(String id) {
        String sql = "select * from t_book where user_id=?";
        return jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);

//创建service内方法
public List<Book> findAll(){
        return bookDao.findAllBook();
    }

//测试
//返回指定id的对象
        Book book = bookService.findOne("1");
        System.out.println(book);

- JdbcTemplate批量操作mysql数据库

+ 批量添加

//接口中编写查询方法
void batchAddBook(List<Object[]> batchArgs);

//实现方法
@Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql = "insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }

List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3","java","dasdq"};
        Object[] o2 = {"4","vaskdv","aver"};
        Object[] o3 = {"5","1231dq","dcase"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchAdd(batchArgs);

//创建service内方法
public void batchAdd(List<Object[]> batchArgs){
        bookDao.batchAddBook(batchArgs);
    }

+ 批量修改

//接口方法
void batchUpdateBook(List<Object[]> batchArgs);
//实现接口方法
@Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set username=?,ustatus=? where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }
//service类内方法
public void batchUpdate(List<Object[]> batchArgs){
        bookDao.batchUpdateBook(batchArgs);
    }
//测试方法
List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"java","dasdq","3"};
        Object[] o2 = {"vaskdv","aver","4"};
        Object[] o3 = {"1231dq","dcase","5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchUpdate(batchArgs);

+ 批量删除

//接口方法
void batchDeleteBook(List<Object[]> batchArgs);
//实现接口方法
@Override
    public void batchDeleteBook(List<Object[]> batchArgs) {
        String sql = "delete from t_book where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }
//service类内方法
public void batchDelete(List<Object[]> batchArgs){
        bookDao.batchDeleteBook(batchArgs);
    }
//测试方法
List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"3"};
        Object[] o2 = {"4"};
        Object[] o3 = {"5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        bookService.batchDelete(batchArgs);

* 事务

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操
作都失败

- 事务四个特性(ACID)

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

- 事务例子：银行转账

//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 http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    开启组件扫描-->
    <context:component-scan base-package="Spring_learning_package"/>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db?serverTimezone=UTC" />
        <property name="username" value="root" />
        <property name="password" value="hd200308041410" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

//接口
public interface UserDao1 {
    void addMoney();
    void reduceMoney();
}

//接口实现类
@Repository
public class UserDao1Impl1 implements UserDao1 {
@Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void reduceMoney() {
        String sql = "update t_account set money=money-? where username=?";
        jdbcTemplate.update(sql, 100, "lucy");

    }

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

//service类
@Service
public class UserService1 {
    @Autowired
    private UserDao1 userDao1;

    public void accountMoney() {
        userDao1.reduceMoney();
        userDao1.addMoney();
    }
}

注意，测试类中getBean方法获取的类不能与其他类的获取冲突，即不能获取同一个类

//测试类
public class TestBook {
    @Test
    public void testAccount(){
        ApplicationContext context = new ClassPathXmlApplicationContext("ShiWu.xml");
        UserService1 userService = context.getBean("userService1", UserService1.class);
        userService.accountMoney();
    }
}

- 异常情况

如果上方的代码遇到异常，就会导致可能一部分代码成功执行，剩下的没有成功执行，就会形成数据错误，因此需要在service类内进行一次异常检测与捕捉

- Spring事务操作介绍

• 事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
• 在 Spring 进行事务管理操作
  • 有两种方式：编程式事务管理和声明式事务管理（一般使用声明式管理）
• 声明式事务管理
  • 基于注解方式（使用）
  • 基于 xml 配置文件方式
• 在 Spring 进行声明式事务管理，底层使用 AOP 原理
• Spring 事务管理 API
  • 提供一个接口，代表事务管理器，这个接口针对不同的框架提供不同的实现类

- 声明式事务操作参数配置

+ 注解@Transactional

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

+ propagation 事务传播行为

多事务方法直接进行调用

+ 七大事务传播行为及其传播属性

+ ioslation ：事务隔离级别

• 事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
• 有三个读问题：脏读、不可重复读、虚（幻）读
• 脏读：一个未提交事务读取到另一个未提交事务的数据

• 不可重复读：一个未提交事务读取到另一提交事务修改数据

• 虚读：一个未提交事务读取到另一提交事务添加数据

• 通过设置事务隔离级别解决读的问题
  

  

+ timeout ：超时时间

• 事务需要在一定时间内进行提交，如果不提交进行回滚
• 默认值是 -1 ，设置时间以秒为单位进行计算
• 需要在 @Transactional 内添加 timeout 属性,在其后添加属性值

+ readOnly：是否只读

• 读：查询操作，写：添加修改删除操作
• readOnly 默认值 false，表示可以查询，可以添加修改删除操作
• 设置 readOnly 值是 true，设置成 true 之后，只能查询

+ rollbackFor ：回滚

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

+ noRollbackFor ：不回滚

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

- XML 声明式事务管理

• 在spring 配置文件中进行配置
  第一步 配置事务管理器
  第二步 配置通知
  第三步 配置切入点和切面

<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"
       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 http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--    开启组件扫描-->
    <context:component-scan base-package="Spring_learning_package"/>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="hd200308041410"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--    创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--        注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    配置通知-->
    <tx:advice id = "txadvice">
        <tx:attributes>
<!--            指定在哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney1" propagation="REQUIRED"/>
<!--            <tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
<!--    配置切入点和切面-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pt" expression="execution(* Spring_learning_package.TestDemo.TestShiWu.*(..))"/>
<!--        配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>
</beans>

- 完全注解开发（完全注解声明式事务管理）

@Configuration//配置类
@ComponentScan(basePackages = "Spring_learning_package")//开启组件扫描
@EnableTransactionManagement//开启事务
public class TxConfig {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql:///user_db?serverTimezone=UTC");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("hd200308041410");
        return druidDataSource;
    }
    //创建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 dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }
}

此时在xml文件中的配置是：

<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"
       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 http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--    开启组件扫描-->
    <context:component-scan base-package="Spring_learning_package"/>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="hd200308041410"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--    创建事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--        注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
<!--    配置通知-->
    <tx:advice id = "txadvice">
        <tx:attributes>
<!--            指定在哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney1" propagation="REQUIRED"/>
<!--            <tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
<!--    配置切入点和切面-->
    <aop:config>
<!--        配置切入点-->
        <aop:pointcut id="pt" expression="execution(* Spring_learning_package.TestDemo.TestShiWu.*(..))"/>
<!--        配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>
</beans>

- spring框架新功能

+ 日志功能

日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL

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

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

  • Spring5 已经移除 Log4jConfigListener，官方建议使用 Log4j2

  • Spring5 框架整合 Log4j2

    • 第一步 引入 jar 包
      

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

<!-- 日志级别以及优先级排序: 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>

可以手动调节优先级以输出更多详细信息

日志信息如下：

2022-07-22 18:37:50.073 [main] INFO  Spring_learning_package.TestDemo.TestShiWu.UserLog - Hello

+ @Nullable 可以为空注解

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

• 注解用在方法上面，方法返回值可以为空

  

• 注解使用在方法参数里面，方法参数可以为空
  

• 注解使用在属性上面，属性值可以为空

+ 支持函数式风格GenericApplicationContex

+ 支持整合 JUnit5

• 整合 JUnit4

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

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

• Spring5 整合 JUnit5

  • 第一步 引入 JUnit5 的 jar 包

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

• 使用一个复合注解替代上面两个注解完成整合

+ Webflux介绍

• SpringWebflux是 Spring5 添加新的模块，用于 web 开发的，功能和 SpringMVC 类似的，Webflux 使用当前一种比较流程响应式编程出现的框架。
  

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

` 什么是异步非阻塞

• 异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同
  步，如果发送请求之后不等着对方回应就去做其他事情就是异步
• 阻塞和非阻塞针对被调用者 阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞

` Webflux 特点

• 第一 非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以 Reactor 为基础实现响应式编程
• 第二 函数式编程：Spring5 框架基于 java8，Webflux 使用 Java8 函数式编程方式实现路由请求

` 比较SpringMvc

• 第一 两个框架都可以使用注解方式，都运行在 Tomet 等容器中
• 第二 SpringMVC 采用命令式编程，Webflux 采用异步响应式编程

- 响应式编程(Java实现)

• 响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
  电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公
  式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

+ java8及之前版本

提供的 观察者模式两个类 Observer 和 Observable

- 响应式编程(Reactor实现)

• 响应式编程操作中，Reactor 是满足 Reactive 规范框架
• Reactor 有两个核心类，Mono 和 和 Flux ，这两个类实现接口 Publisher，提供丰富操作
  符。Flux 对象实现发布者，返回 N 个元素；Mono 实现发布者，返回 0 或者 1 个元素
• Flux 和 Mono 都是数据流的发布者，使用 Flux 和 Mono 都可以发出三种数据信号：
  元素值，错误信号，完成信号，错误信号和完成信号都代表终止信号，终止信号用于告诉
  订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者

+ 代码演示 Flux 和 和 Mono

+ 三种信号特点

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

注意：调用 just 或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的

+ 操作符

• 对数据流进行一道道操作，成为操作符，比如工厂流水线
• 第一 map 元素映射为新元素

• 第二 flatMap 元素映射为流
  把每个元素转换流，把转换之后多个流合并大的流

- SpringWebflux执行流程和核心API

SpringWebflux 基于 Reactor，默认使用容器是 Netty，Netty 是高性能的 NIO 框架，异步非阻
塞的框架

+ Netty

` BIO

` NIO

+ SpringWebflux 执行过程

SpringWebflux 执行过程和 SpringMVC 相似的

• SpringWebflux 核心控制器 DispatchHandler，实现接口 WebHandler
• 接口 WebHandler 有一个方法

+ SpringWebflux 中的 DispatcherHandler

SpringWebflux 里面 DispatcherHandler，负责请求的处理

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

+ SpringWebflux 函数式编程的两接口

SpringWebflux 实现函数式编程，两个接口：RouterFunction（路由处理）
和 HandlerFunction（处理函数）

- SpringWebflux(基于注解编程模型)

SpringWebflux 实现方式有两种：注解编程模型和函数式编程模型
使用注解编程模型方式，和之前 SpringMVC 使用相似的，只需要把相关依赖配置到项目中，
SpringBoot 自动配置相关运行容器，默认情况下使用 Netty 服务器

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

• 第二步 配置启动端口号

  

• 第三步 创建包和相关类

  实体类
  

• 创建接口定义操作的方法

• 接口实现类

• 创建 controller

• 说明

  SpringMVC 方式实现，同步阻塞的方式，基于 SpringMVC+Servlet+Tomcat
  SpringWebflux 方式实现，异步非阻塞 方式，基于 SpringWebflux+Reactor+Netty

- SpringWebflux (基于函数式编程模型)

• 在使用函数式编程模型操作时候，需要自己初始化服务器

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

• SpringWebflux 请 求 和 响 应 不 再 是 ServletRequest 和 ServletResponse ， 而 是
  ServerRequest 和 ServerResponse

• 第一步 把注解编程模型工程复制一份 ，保留 entity 和 service 内容

• 第二步 创建 Handler（具体实现方法）

• 
  

• 第三步 初始化服务器，编写 Router

  • 创建路由的方法

• 创建服务器完成适配

• 最终调用
  

• 第四步使用 WebClient 调用

总结

rMapping：请求查询到处理的方法

• HandlerAdapter：真正负责请求处理
• HandlerResultHandler：响应结果处理

+ SpringWebflux 函数式编程的两接口

SpringWebflux 实现函数式编程，两个接口：RouterFunction（路由处理）
和 HandlerFunction（处理函数）

- SpringWebflux(基于注解编程模型)

SpringWebflux 实现方式有两种：注解编程模型和函数式编程模型
使用注解编程模型方式，和之前 SpringMVC 使用相似的，只需要把相关依赖配置到项目中，
SpringBoot 自动配置相关运行容器，默认情况下使用 Netty 服务器

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

• 第二步 配置启动端口号

• 第三步 创建包和相关类

  实体类

• 创建接口定义操作的方法
  

• 接口实现类

• 创建 controller
  

• 说明

  SpringMVC 方式实现，同步阻塞的方式，基于 SpringMVC+Servlet+Tomcat
  SpringWebflux 方式实现，异步非阻塞 方式，基于 SpringWebflux+Reactor+Netty

- SpringWebflux (基于函数式编程模型)

• 在使用函数式编程模型操作时候，需要自己初始化服务器

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

• SpringWebflux 请 求 和 响 应 不 再 是 ServletRequest 和 ServletResponse ， 而 是
  ServerRequest 和 ServerResponse

• 第一步 把注解编程模型工程复制一份 ，保留 entity 和 service 内容

• 第二步 创建 Handler（具体实现方法）
  

• 第三步 初始化服务器，编写 Router

  • 创建路由的方法
    

  • 创建服务器完成适配

    

  • 最终调用

    

• 第四步使用 WebClient 调用

课程总结