Spring5

Spring5

声明：本文是Spring5课程所作的笔记。

 

尚硅谷-Spring5框架最新版教程（idea版）

1、Spring框架概述

（1）Spring是轻量级的开源的Java EE框架

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

（3）Spring有两个核心部分：IOC和Aop

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

　　　　Aop：面向切面编程，不修改源代码进行功能增强

（4）Spring特点

　　①方便解耦，简化开发

　　②Aop编程支持

　　③方便程序测试

　　④方便和其他框架进行整合

　　⑤方便进行事务操作

　　⑥降低API开发难度

 

2、使用Spring

（1）下载Spring框架

Spring框架下载教程_

 

（2）导入Spring5相关jar包

　　①ioc基本包，放入项目的lib文件

　　②导入jar包

　　　　File → Project Structure → Modules → Ddependencies

 

（3）创建普通对象类，例如User

（4）创建Spring配置文件，在配置文件中配置创建的对象

　　①创建一个xml格式的文件，在文件中加上以下语句

<!--配置User对象创建-->
<bean id="user" class="com.my.spring5.User"></bean>

 

（5）使用

@Test
public void testAdd(){
    //1、加载spring的配置文件
    ApplicationContext context =
      new ClassPathXmlApplicationContext("bean1.xml");
​
    //2、获取配置创建的对象
    User user = context.getBean("user",User.class);
    System.out.println(user);
    user.add();
}

 

3、IOC容器

（1）IOC含义

　　①控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理

　　②使用IOC目的：降低耦合度

　　③IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

 

（2）原始模式和工厂模式

 

（3）IOC底层原理

//1、xml配置文件，配置创建的对象
<bean id="dao" class="com.my.spring5.UserDao"></bean>
    
//2、创建工厂类
class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值；//xml解析
        Class c = Class.forName(classValue);//通过反射创建对象
        return (UserDao)c.newInstance();
    }
}    

 

（4）IOC接口

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

　　　　i.BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供给开发人员使用

　　　　　　　　　　    加载配置文件时，不会创建对象，在获取对象（使用）才去创建对象

　　　　ii.ApplicationContext：BeanFactory接口的子接口，一般由开发人员使用

　　　　　　　　　　      　　 加载配置文件时，就会把配置文件中的对象进行创建

　　②ApplicationContext实现类

　　　　i.FileSystemXmlApplicationContext—可以加载在其他磁盘上的配置文件

　　　　ii.ClassPathXmlApplicationContext—只能加载在src文件夹目录下的配置文件

 

4、ICO操作Bean管理

（1）Bean管理

　　①Spring创建对象

　　②Spring注入属性

 

（2）Bean管理方式

　　①基于xml配置文件方式实现

　　②基于注解方式实现

 

5、ICO操作Bean管理—基于xml方式

（1）基于xml方式创建对象

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

　　②在bean标签有很多属性

　　　　*id属性：唯一标识，不能包含特殊字符

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

　　　　*name属性：功能和id一样，但可以包含特殊字符（基本不用，为了满足struts1遗留问题）

　　　　*scope属性：Bean的作用范围

　　③创建对象时候，默认是执行无参构造方法

 

（2）基于xml方式注入属性

　　①IOC与DI区别：DI是IOC中的一种具体实现，DI表示依赖注入，就是注入属性，需要在创建对象的基础之上去完成

　　②第一种注入方式：使用setter。首先创建属性和对应的set()方法。再在Spring配置文件中配置属性注入。

<bean id="book" class="com.my.spring5.Book">
    <!--name是属性名,value是属性值-->
    <property name="bname" value="China"></property>
    <property name="price" value="200"></property>
</bean>

　　③第二种方式：通过有参构造进行注入。首先创建属性和对应的有参构造方法。再在Spring配置文件中配置属性注入。

<bean id="order" class="com.my.spring5.Order">
    <constructor-arg name="oname" value="食品"></constructor-arg>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

 

（3）p名称空间注入，可以简化基于xml配置方式

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

　　②进行属性注入

<bean id="book" class="com.my.spring5.Book" p:bname="算法" p:price="20"></bean>

 

（4）xml注入其他类型属性

　　①字面量

<!-- 1、null值 -->
<property name="bname"> <null/> </property>
​
<!-- 2、属性值包含特殊字符 
        ①把<>进行转义，&lt; &gt;
        ②把带特殊符号内容写到CDATA
-->
<property name="bname">
    <value> <![CDATA[<中国>]]></value>
</property>

 

（5）注入属性—外部Bean

　　①创建两个类：service类和dao类

　　②在service中设置dao类属性，并调用dao类的方法

　　③在Spring配置文件中进行配置

<!-- service和dao对象创建 -->
<!-- ref属性：创建userDao对象bean标签id值 -->
<bean id="userService" class="com.my.spring5.service.UserService">
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.my.spring5.dao.impl.UserDaoImpl"></bean>

 

（6）注入属性—内部Bean

　　①创建Dept类(部门类)和Emp类(员工类)

　　②在Emp类中有Dept类属性

　　③在Spring配置文件中进行配置

<!-- 内部bean -->
<bean id="emp" class="com.my.spring5.bean.Emp">
    <property name="ename" value="ww"></property>
    <property name="gender" value="man"></property>
    <property name="dept">
        <bean id="dept" class="com.my.spring5.bean.Dept">
            <property name="dname" value="学科部"></property>
        </bean>
    </property>
</bean>

 

（7）注入属性—级联赋值

在Spring配置文件中进行配置。

　　①第一种写法

<!-- 级联赋值 -->
<bean id="emp" class="com.my.spring5.bean.Emp">
    <property name="ename" value="ww"></property>
    <property name="gender" value="man"></property>
    <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.my.spring5.bean.Dept">
    <property name="dname" value="学科部"></property>
</bean>

 

　　②第二种写法

<!-- 级联赋值 -->
<bean id="emp" class="com.my.spring5.bean.Emp">
    <property name="ename" value="ww"></property>
    <property name="gender" value="man"></property>
    <property name="dept" ref="dept"></property>
    <!-- 需要设置dept的get()方法 -->
    <property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.my.spring5.bean.Dept"></bean>

 

（8）注入属性—集合属性

　　①创建类，定义数组、List、Map、Set类型属性，生成对应set()方法

　　②在Spring配置文件中进行配置

<bean id="school" class="com.collectionType.School">
    <!-- 数组类型属性注入（使用array和list标签都可以）-->
    <property name="courses">
        <array>
            <value>English</value>
            <value>Math</value>
         </array>
    </property>
    <!-- List类型属性注入-->
    <property name="teachers">
        <list>
            <value>Yu</value>
            <value>Wang</value>
        </list>
    </property>
    <!-- Map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="English" value="Yu"></entry>
            <entry key="Math" value="Wang"></entry>
        </map>
    </property>
    <!-- Set类型属性注入-->
    <property name="set">
        <set>
            <value>001</value>
            <value>002</value>
        </set>
    </property>
</bean>

 

　　③在集合中保存对象

<!-- List类型属性注入，值是对象-->
<property name="courseList">
    <list>
        <ref bean="course"></ref>
        <ref bean="course2"></ref>
    </list>
</property>

<!--创建多个bean对象-->
<bean id="course" class="com.collectionType.Course">
    <property name="cname" value="生物"></property>
</bean>
<bean id="course2" class="com.collectionType.Course">
    <property name="cname" value="奥数"></property>
</bean>

 

（9）把集合部分提取出来

　　①在Spring配置文件中引入名称空间util

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     
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">

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

<util:list id="bookList">
    <value>计算机理论</value>
    <value>概率论</value>
</util:list>
    
<bean id="book" class="comcollectionType.BookList">
    <property name="bookList" ref="bookList"></property>
</bean>

 

（10）FactoryBean

　　①Spring有两种类型bean：普通bean和工厂bean（FactoryBean）

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

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

//类
public class Mybean implements FactoryBean<Course> {

    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

//Spring配置文件
<bean id="myBean" class="com.factoryBean.Mybean"></bean>

//使用
Course course = context.getBean("myBean", Course.class);

 

（11）bean作用域

　　①在Spring里面，设置创建bean实例是单实例还是多实例

　　②在Spring里面，默认情况是bean是单实例对象

　　③设置

<!-- 单实例 -->
<bean id="userDao" class="com.dao.impl.UserDaoImpl" scope="singleton"></bean>
<!-- 多实例 -->
<bean id="userDao" class="com.dao.impl.UserDaoImpl" scope="prototype"></bean>

　　④singleton和prototype区别

　　　　设置scope值是singleton时，加载Spring配置文件时就会创建单实例对象

　　　　设置scope值是prototype时，不是在加载Spring配置文件时创建对象，而是在调用getBean()方法时创建多实例对象

　　⑤request和session

　　　　scope值还可以是request和session。当是request时，每次创建对象都会放到request中；当是session时，每次创建对象都会放到session中。

 

（12）普通bean的生命周期

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

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

　　③调用bean的初始化方法（需要配置初始化方法，init-method属性）

　　④bean可以使用了（已获取对象）

　　⑤当容器关闭时，调用bean的销毁方法（需要配置销毁方法，destroy-method属性）

//手动让实例销毁
((ClassPathXmlApplicationContext) context).close();

 

（13）带有bean后置处理器的生命周期

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

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

　　③调用把bean实例传递给bean后置处理器的方法（postProcessBeforeInitialization）

　　④调用bean的初始化方法

　　⑤调用把bean实例传递给bean后置处理器的方法（postProcessAfterInitialization）

　　⑥bean可以使用了（已获取对象）

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

//1、创建类，实现BeanPostProcessor
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; }
​
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; }
}
​
//2、在配置文件中配置
//当存在后置处理器后，在该配置文件中的所有bean都会经过后置处理器处理
<bean id="myBeanPost" class="com.bean.MyBeanPost"></bean>

 

（14）xml方式自动装配

　　①自动装配是根据指定装配规则（属性名称或属性类型），Spring自动将匹配的属性值进行注入

　　②自动装配过程

<!-- 实现自动装配
        bean标签属性autowire，配置自动装配
        autowire属性常用两个值：
            byName根据属性名称注入：注入值bean的id值和类属性名称一样
            byType根据属性类型注入：只能写一个Dept类的bean标签  -->
<bean id="emp" class="com.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.autowire.Dept">
        <property name="dname" value="学科部"></property>
</bean>

 

（15）引入外部属性文件

　　①直接配置数据库信息

　　　　i.引入德鲁伊连接池依赖jar包，druid-1.2.21.jar

　　　　ii.配置数据库信息

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

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

　　　　i.创建外部属性文件，properties格式文件

　　　　ii.在Spring配置文件中引入context名称空间

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

　　iii.把外部properties文件引入到Spring配置文件中

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

 

6、ICO操作Bean管理—基于注解方式

（1）注解

　　①注解时代码特殊标记，格式：@注解名称（属性名称=属性值）

　　②注解作用在类、方法、属性上

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

 

（2）Spring针对Bean管理中创建对象提供注解

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

　　①@Component

　　②@Service

　　③@Controller

　　④@Repository

 

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

　　①引入依赖，spring-aop-5.2.16.RELEASE.jar

　　②开启组件扫描

　　　　i.在配置文件中引入context名称空间

　　　　ii.开启扫描组件

<!-- 开启组件扫描
        1.如果扫描多个包，多个包使用逗号隔开
        2.扫描包上层目录-->
<context:component-scan base-package="com.my.spring5.service,com.my.spring5.dao" />

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

//在注解里面value属性可以省略，省略后默认值时类名称，首字母小写
@Component(value = "studentService")  //<bean id="studentService" class="..." />
public class StudentService {
    public void add(){
        System.out.println("service add...");
    }
}

 

（4）开启组件扫描细节

<!-- 示例1
    use-default-filters="false"：表示现在不使用默认filter，自己配置filter
    context:include-filter：设置扫描哪些内容
-->
<context:component-scan base-package="com.my" use-default-filters="false">
    <context:include-filter type="annotation"
                                expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

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

 

（5）实现属性注入

　　①@Autowired—根据属性类型进行自动装配

//定义dao类型属性，不需要添加set()方法
//添加注入属性注解
@Autowired
private StudentDao studentDao;

 

　　②@Qualifier—根据属性名称进行注入

//@Qualifier需要与@Autowired一起使用
@Autowired
@Qualifier(value = "studentDaoImpl")
private StudentDao studentDao;

 

　　③@Resource—可以根据类型或名称注入

//@Resource     //根据类型注入
@Resource(name = "studentDaoImpl")   //根据名称注入
private StudentDao studentDao;

 

　　④@Value—注入普通类型属性

@Value(value = "Yu")
private String name;

 

（6）完全注解开发

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

@Configuration  //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.my.spring5"})
public class SpringConfig {  }

　　②编写测试类

@Test
public void testService(){
    //1、加载配置类
    ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);

    //2、获取配置创建的对象
    StudentService studentService = context.getBean("studentService", StudentService.class);
    System.out.println(studentService);
    studentService.add();
}

 

7、AOP基本概念

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

（2）通俗的描述：不通过修改源代码方式，在主干功能里面添加新功能

 

8、AOP底层原理

（1）AOP底层使用动态代理

　　①有接口情况，使用JDK动态代理

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

　　②没有接口情况，使用CGLIB动态代理

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

（2）JDK动态代理实现

　　①创建接口，定义方法

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

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

public class OperateDaoImpl implements OperateDao {

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

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

　　③使用Proxy类里面的方法创建代理对象

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {OperateDao.class};
        OperateDaoImpl operateDao = new OperateDaoImpl();
        //第一参数：类加载器
        //第二参数：增强方法所在的类，这个类实现的接口，支持多个接口
        //第三参数：实现InvocationHandler接口，创建代理对象，写增强部分
        OperateDao dao = (OperateDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
            //增强的逻辑
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法之前执行：" + method.getName() + "; 参数：" + Arrays.toString(args));
​
                Object res = method.invoke(operateDao,args);
​
                System.out.println("方法执行之后：" + operateDao);
                return res;
            }
        });
        int result = dao.add(2,3);
        System.out.println(result);
    }
}

 

9、AOP术语

（1）连接点

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

（2）切入点

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

（3）通知（增强）

　　①切入点中实际增强的逻辑部分称为通知

　　②通知有多种类型

　　　　前置通知、后置通知、环绕通知、异常通知、最终通知

（4）切面

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

 

10、AOP操作—准备工作

（1）Spring框架一般都是基于AspectJ实现AOP操作。

（2）AspectJ不是Spring的组成部分，是独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

（3）基于AspectJ实现AOP操作方法

　　　　①基于xml配置文件方式实现

　　　　②基于注解方式实现

（4）引入相关依赖

（5）切入点表达式

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

　　②语法结构：

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

 

11、AOP操作—AspectJ注解

（1）操作的步骤

　　①创建类，在类里面定义方法

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

　　②创建增强类，编写增强逻辑

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

　　③进行通知配置

//1、在Spring配置文件中，开启注解扫描
<!--开启组件扫描-->
<context:component-scan base-package="com.aopanno"></context:component-scan>
​
//2、使用注解创建User和UserProxy对象
@Component
public class User {}
​
@Component
public class UserProxy {}
​
//3、在增强类上面添加注解@AspectJ
@Component
@Aspect  //开启代理对象
public class UserProxy {}
​
//4、在Spring配置文件中开启生成代理对象
<!--开启Aspect生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

　　④配置不同类型的通知

//1、在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
//前置通知：被增强方法执行前
@Before(value = "execution(* com.aopanno.User.add(..))")
public void before(){
    System.out.println("before...");
}

//环绕通知：在被增强方法的执行前和执行后进行操作
@Around(value = "execution(* com.my.spring5.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
    System.out.println("环绕之前...");
    //被增强的方法执行
    proceedingJoinPoint.proceed();
    System.out.println("环绕之后...");
}

//@After：最终通知，被增强方法执行后执行，相当于finally
//@AfterReturning：后置通知，被增强方法返回值之后执行
//@AfterThrowing：异常通知，被增强方法抛出异常时执行

/*
环绕之前...
before...
add...
afterReturning...
after...
环绕之后...
*/

 

（2）相同的切入点抽取

//相同切入点抽取
@Pointcut(value = "execution(* com.aopanno.User.add(..))")
public void point(){}

//前置通知
@Before(value = "point()")
public void before(){
    System.out.println("before...");
}

 

（3）有多个增强类对同一个方法进行增强，可以设置增强类优先级

//在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高
@Component
@Aspect
@Order(2)
public class PersonProxy {}

 

（4）完全使用注解开发

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

 

12、AOP操作—AspectJ配置文件

在Spring配置文件中配置。

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

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

 

13、JdbcTemplate概述

（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便对数据库进行操作

（2）准备工作

　　①引入相关jar包

　　②在Spring配置文件中配置连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/jsppro"></property>
    <property name="username" value="root"></property>
    <property name="password" value="12345678"></property>
</bean>

　　③配置JdbcTemplate对象，注入DataSource

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

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

@Service
public class BookService {
    @Autowired
    private BookDao bookDao;
}
​
@Repository
public class BookDaoImpl implements BookDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

 

14、JdbcTemplate操作数据库

（1）添加

　　①对应数据库创建实体类

　　②编写service和dao类

//service类
public void addBook(Book book){
    int count = bookDao.add(book);
    if(count>0){
        System.out.println("添加成功！");
    }else{
        System.out.println("添加失败！");
    }
}
​
//dao类
@Override
public int add(Book book) {
    String sql = "insert into book values(?,?,?)";
    int count = jdbcTemplate.update(sql,book.getBookId(),book.getName(),book.getPrice());
    return count;
}

 

（2）更新

//service类
public void updateBookById(Book book){
    int count = bookDao.updateById(book);
    if(count>0){
        System.out.println("更新成功！");
    }else{
        System.out.println("更新失败！");
    }
}
​
//dao类
@Override
public int updateById(Book book) {
    String sql = "update book set name=?,price=? where bookId=?";
    Object[] args = {book.getName(),book.getPrice(),book.getBookId()};
    int count = jdbcTemplate.update(sql,args);
    return count;
}

 

（3）删除

//service类
public void deleteBookById(int id){
    int count = bookDao.deleteById(id);
    if(count>0){
        System.out.println("删除成功！");
    }else{
        System.out.println("删除失败！");
    }
}

//dao类
@Override
public int deleteById(int id) {
    String sql = "delete from book where bookId=?";
    int count = jdbcTemplate.update(sql,id);
    return count;
}

 

（4）查询表中记录数

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

//dao类
@Override
public int selectCount() {
    String sql = "select count(*) from book";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}

 

（5）查询返回对象

//service类
public Book findOneBook(int id){
    Book book = bookDao.findBookById(id);
    return book;
}
​
//dao类
@Override
public Book findBookById(int id) {
    String sql = "select * from book where bookId=?";
    //第一个参数：sql语句
    //第二个参数：RowMapper是接口，返回不同类型的数据，使用该接口实现类可以完成数据封装
    //第三个参数：sql参数
    Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
    return book;
}

 

（6）查询返回集合

//service类
public List<Book> findAllBook(){
    return bookDao.findAll();
}
​
//dao类
@Override
public List<Book> findAll() {
    String sql = "select * from book";
    List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
    return bookList;
}

 

（7）批量添加

//service类
public void batchAdd(List<Object[]> batchArgs){
    bookDao.batchAdd(batchArgs);
}
​
//dao类
@Override
public void batchAdd(List<Object[]> batchArgs) {
    String sql = "insert into book values(?,?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(ints);
}

 

（8）批量修改

//service类
public void batchUpdate(List<Object[]> batchArgs){
    bookDao.batchUpdate(batchArgs);
}
​
//dao类
@Override
public void batchUpdate(List<Object[]> batchArgs) {
    String sql = "update book set name=?,price=? where bookId=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

 

（9）批量删除

//service类
public void batchDelete(List<Object[]> batchArgs){
    bookDao.batchDelete(batchArgs);
}
​
//dao类
@Override
public void batchDelete(List<Object[]> batchArgs) {
    String sql = "delete from book where bookId=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
    System.out.println(Arrays.toString(ints));
}

 

15、事务操作—事务概念

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

（2）事务四个特性(ACID)

　　①原子性—要么都成功，存在一个失败就失败

　　②一致性—数据保持一致，例如A向B转账，转账后A和B的钱总和不变

　　③隔离性—多个事物之间互不影响

　　④持久性—一旦提交，数据库就发生改变

 

16、事务操作—搭建事务操作环境

（1）创建数据库和表，添加相应记录

（2）新建service和dao类，完成对象创建和注入关系

（3）在dao类创建少钱和多钱的方法，service类创建转账方法

//service类
public void accountMoney(int fromCardId,int toCardId,int money){
    accountDao.reduceMoney(money,fromCardId);
    accountDao.addMoney(money,toCardId);
}
​
//dao类
@Override
public int reduceMoney(int money, int cardId) {
    String sql = "update account set balance=balance-? where cardid=?";
    int count = jdbcTemplate.update(sql,money,cardId);
    return count;
}
​
@Override
public int addMoney(int money, int cardId) {
    String sql = "update account set balance=balance+? where cardid=?";
    int count = jdbcTemplate.update(sql,money,cardId);
    return count;
}

 

（4）上面的service方法中，如果reduceMoney()执行完后发生异常，则addMoney()不会执行，产生操作错误，因此需要通过事务来解决该问题。

 

17、事务操作—Spring事务管理介绍

（1）事务添加到JavaEE三层结构里面Service层（业务逻辑层）。

（2）在Spring进行事务管理操作，有两种方式：

　　①编程式事务管理

　　②声明式事务管理（推荐）

（3）声明式事务管理有两种方式：

　　①基于注解方式（推荐）

　　②基于xml配置文件方式

（4）在 Spring进行声明式事务管理，底层使用AOP原理。

（5）Spring事务管理API

　　①PlatformTransactionManager，代表事务管理器，针对不同的框架提供不同的实现类。

 

18、事务操作—Spring声明式事务管理（注解方式）

（1）在Spring配置文件中配置事务管理器

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

 

（2）在Spring配置文件中开启事务注解

　　①引入tx名称空间

xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"

　　②开启事务注解

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

 

（3）在service类上面（或service类里面方法上）添加事务注解

　　①如果把注解添加到类上面，代表类里面的所有方法都添加事务

　　②如果把注解添加到方法上面，为该方法添加事务

@Service
@Transactional
public class AccountService {}

 

19、事务操作—Spring声明式事务管理参数配置

（1）@Transactional，在这个注解里面可以配置事务相关参数

　　①propagation—事务传播行为

　　　　i.事务方法—对数据库表数据进行变化的操作

　　　　  事务传播行为—多事务方法之间进行调用

事务传播行为类型	说明
REQUIRED	如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
REQUIRES_NEW	当前方法必须启动新事务，并运行。如果当前有事务在运行，把当前事务挂起。
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中。
NOT_SUPPORTED	当前方法不应该运行在事务中。如果当前存在事务，就把当前事务挂起。
MANDATORY	当前方法必须运行在事务内。如果当前没有正在运行的事务，就抛出异常。
NEVER	当前的方法不应该运行在事务内。如果有运行的事务，就抛出异常。
NESTED	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则启动一个新的事务并运行。

　　　　ii.图示

　　　　iii.配置

@Service
@Transactional(propagation = Propagation.REQUIRED )
public class AccountService {}

 

　　②isolation—事务隔离级别

　　　　i.事务有特性成为隔离性，多事务操作之间不会产生影响。

　　　　ii.不考虑隔离性产生三个读问题:脏读、不可重复读、虚（幻)读

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

　　　　　　不可重复读：一个未提交事务读取到另一提交事务修改的数据，导致两次读取到的结果不一致

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

大白话讲解脏写、脏读、不可重复读和幻读

　　　　iii.设置事务隔离级别

	脏读	不可重复读	虚读
READ_UNCOMMITTED（读未提交）	有	有	有
READ_COMMITTED（读已提交）	无	有	有
REPEATABLE_READ（可重复读）	无	无	有
SERIALIZABLE（串行化）	无	无	无

@Service
@Transactional(isolation = Isolation.REPEATABLE_READ)
public class AccountService {}

 

　　③timeout—超时时间

　　　　i.事务需要在一定时间内进行提交，如果超时就回滚

　　　　ii.默认值是-1，设置时间以秒为单位计算

@Service
@Transactional(timeout = -1)
public class AccountService {}

 

　　④readOnly—是否只读

　　　　i.读：查询操作；写：添加删除修改操作

　　　　ii.readOnly默认值false，表示即可以写操作，也可以读操作

　　　　iii.设置为true，表示只能查询

@Service
@Transactional(readOnly = true)
public class AccountService {}

 

　　⑤rollbackFor—回滚

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

　　⑥noRollbackFor—不回滚

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

 

20、事务操作—Spring声明式事务管理（xml方式）

（1）在Spring配置文件中进行配置

<!-- 1、创建事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入数据源 -->
    <property name="dataSource" ref="dataSource"></property>
</bean>
​
<!-- 2、配置通知 -->
<tx:advice id="txadvice">
    <!-- 配置事务参数 -->
    <tx:attributes>
        <tx:method name="accountMoney" propagation="REQUIRED"/>
        <!--<tx:method name="account*" />-->
    </tx:attributes>
</tx:advice>
​
<!-- 3、配置切入点和切面 -->
<aop:config>
    <!-- 配置切入点 -->
    <aop:pointcut id="pt" expression="execution(* com.service.AccountService.*(..))"/>
    <!-- 配置切面 -->
    <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
</aop:config>

 

21、事务操作—Spring声明式事务管理（完全注解方式）

（1）创建配置类，使用配置类代替xml配置文件

@Configuration //配置类
@ComponentScan(basePackages = {"com.dao","com.service"})  //组件扫描
@EnableTransactionManagement  //开启事务
public class TxConfig {
​
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/jsppro");
        dataSource.setUsername("root");
        dataSource.setPassword("12345678");
        return dataSource;
    }
​
    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //到ioc容器中根据类型找到dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
​
    //创建事务管理器对象
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

 

22、Spring5新功能

（1）Spring 5.0框架自带了通用的日志封装。

　　① Spring5 已经移除Log4jConfigListener,官方建议使用Log4j2

　　②Spring5 框架整合Log4j2 i.引入jar包

　　③创建log4j2.xml

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

 

（2）Nullable注解

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

//方法，返回可以为空
@Nullable
String getId();

//属性，属性值可以为空
@Nullable
private String bookName;

//参数，参数值可以为空
public <T> void registerBean(@Nullable String beanName){}

 

（3）支持函数式风格GenericApplicationContext

public void testGenericApplicationContext(){
    //函数式风格创建对象，交给Spring管理
    //1、创建GenericApplicationContext对象
    GenericApplicationContext context = new GenericApplicationContext();
    //2、调用context的方法对象注册
    context.refresh();
    //context.registerBean(User.class,() -> new User());
    context.registerBean("user",User.class,() -> new User());
    //3、获取在Spring注册的对象
    //User user = (User) context.getBean("com.my.spring5.User");
    User user = (User) context.getBean("user");
    System.out.println(user);
}

 

（4）整合JUint5单元测试框架

　　①整合JUnit4

　　　　i.引入相关的依赖

　　　　ii.创建测试类，使用注解方式完成

@RunWith(SpringJUnit4ClassRunner.class)  //单元测试框架
@ContextConfiguration("classpath:bean1.xml")  //加载配置文件
public class JTest4 {
​
    @Autowired
    private Book book;
​
    @Test
    public void test(){
        book.testDemo();
    }
}

 

　　②整合JUnit5

　　　　i.引入相关的依赖

　　　　ii.创建测试类，使用注解方式完成

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")
//@SpringJUnitConfig(locations = "classpath:bean1.xml")   //复合的注解，替代上面两个注解
public class JTest5 {
​
    @Autowired
    private Book book;
​
    @Test
    public void test(){
        book.testDemo();
    }
}

 

23、Spirng5新功能—SpringWebflux

（1）Webflux是Spring5添加的新的模块，用于 web 开发的，功能和SpringMVC类似的，Webflux使用当前一种比较流行的响应式编程。

 

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

 

（3）异步非阻塞

　　①异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步。

　　②阻塞和非阻塞针对被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞。

 

（4）Webflux特点

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

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

 

（5）响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

　　①例如，对于 a=b+c 这个表达式的处理，在命令式编程中，会先计算 b+c 的结果，再把此结果赋值给 变量a，因此 b，c 两值的变化不会对 变量a 产生影响。但在响应式编程中，变量a 的值会随时跟随 b，c 的变化而变化。

　　②Java8及其之前版本

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

public class ObserverDemo extends Observable {
    public static void main(String[] args) {
        ObserverDemo observer = new ObserverDemo();
        //添加观察者
        observer.addObserver((o,arg)->{
            System.out.println("发生了变化");
        });
        observer.addObserver((o,arg)->{
            System.out.println("手动被观察者通知，准备变化");
        });
        observer.setChanged();  //数据变化
        observer.notifyObservers();  //通知
    }
}

 

（6）响应式编程（Reactor 实现）

　　①响应式编程操作中，Reactor满足Reactive规范框架

　　②Reactor 有两个核心类，Mono和Flux， 这两个类实现接口Publisher，提供丰富操作符。Flux 对象实现发布者，返回N个元素； Mono 实现发布者，返回0或者1个元素。

　　③Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：元素值，错误信号，完成信号，错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者。

　　④代码演示Flux和Mono

//1、引入依赖
<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.1.5.RELEASE</version>
</dependency>
​
//2、编写代码
public class TestReactor {
    public static void main(String[] args) {
        //just方法直接声明
        Flux.just(1,2,3,4);
        Mono.just(1);
​
        //其他方法
        Integer[] array = {1,2,3,4};
        Flux.fromArray(array);
​
        List<Integer> list = Arrays.asList(array);
        Flux.fromIterable(list);
​
        Stream<Integer> stream = list.stream();
        Flux.fromStream(stream);
    }
}

 

　　⑤三种信号特点

　　　　i.错误信号和完成信号都是终止信号，不能共存的。

　　　　ii.如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流

　　　　iii.如果没有错误信号，没有完成信号，表示是无限数据流。

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

Flux.just(1,2,3,4).subscribe(System.out::print);
Mono.just(1).subscribe(System.out::print);

 

　　⑦操作符—对数据流进行一道道操作，成为操作符，比如工厂流水线

　　　　i.map—元素映射为新元素

　　　　ii.flatMap—元素映射为流；把每个元素转换为流，把转换之后多个流合并大的流

 

（7）Webflux执行流程和核心API

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

　　②SpringWebflux执行过程和 SpringMVC相似的。

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

 

　　③SpringWebflux里面Dispatchertandler,，负责请求的处理。

　　　　i.HandlerMapping:请求查询到处理的方法。

　　　　ii.HandlerAdapter:真正负责请求处理

　　　　iii.HandlerResultHandler:响应结果处理

　　④SpringWebflux实现函数式编程，两个接口：RouterFuntion(路由处理)和HandlerFunction(处理函数)。

 

（8）SpringWebflux和SpringMVC区别

　　①SpringMVC方式实现，同步阻塞的方式，基于SpringMMC+Servlet+Tomcat

　　②SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty

 

（9）基于注解编程模型实现

　　①创建SpringBoot工程，引入Webflux依赖

　　②配置启动的端口号

　　③创建包和相关类

//entity包，实体类
public class User {
    private String name;
    private String gender;
​
    public User(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
​
    public String getName() { return name; }
​
    public void setName(String name) { this.name = name; }
​
    public String getGender() { return gender; }
​
    public void setGender(String gender) { this.gender = gender; }
}
​
//service包，用户操作接口
public interface UserService {
    //根据id查询用户
    Mono<User> getUserById(int id);
​
    //查询所有用户
    Flux<User> getAllUsers();
​
    //添加用户
    Mono<Void> saveUserInfo(Mono<User> user);
}
​
//service.Impl包，用户操作接口实现类
@Service
public class UserServiceImpl implements UserService {
​
    //创建map集合存储数据
    private final Map<Integer,User> users = new HashMap<>();
​
    public UserServiceImpl(){
        this.users.put(1,new User("Yu","man"));
        this.users.put(2,new User("Wang","man"));
    }
​
    @Override
    public Mono<User> getUserById(int id) {
        return Mono.justOrEmpty(this.users.get(id));
    }
​
    @Override
    public Flux<User> getAllUsers() {
        return Flux.fromIterable(this.users.values());
    }
​
    @Override
    public Mono<Void> saveUserInfo(Mono<User> user) {
        return user.doOnNext(person -> {
            //向map集合里面放值
            int id = users.size() + 1;
            users.put(id,person);
        }).thenEmpty(Mono.empty());
    }
}
​
//controller包，控制器
@RestController
public class UserController {
​
    //注入service
    @Autowired
    private UserService userService;
​
    //id查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserById(@PathVariable int id){
        return userService.getUserById(id);
    }
​
    //查询所有
    @GetMapping("user")
    public Flux<User> getUsers(){
        return userService.getAllUsers();
    }
​
    //添加
    @PostMapping("/saveuser")
    public Mono<Void> saveUser(@RequestBody User user){
        Mono<User> userMono = Mono.just(user);
        return userService.saveUserInfo(userMono);
    }
}
​
//测试
//访问：http://localhost:8081/user
//显示：[{"name":"Yu","gender":"man"},{"name":"Wang","gender":"man"}]

 

（10）基于函数式编程模型实现

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

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

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

　　④步骤

　　　　i.把注解编程模型工程复制一份

　　　　ii.创建Handler

public class UserHandler {
​
    private final UserService userService;
    public UserHandler(UserService userService){
        this.userService = userService;
    }
​
    //根据id查询
    public Mono<ServerResponse> getUserById(ServerRequest serverRequest){
        int userId = Integer.valueOf(serverRequest.pathVariable("id"));
​
        //空值处理
        Mono<ServerResponse> notFound = ServerResponse.notFound().build();
​
        Mono<User> userMono = this.userService.getUserById(userId);
        //把userMono进行转换并返回
        return
                userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                        .body(fromObject(person)))
                        .switchIfEmpty(notFound);
    }
​
    //查询所有
    public Mono<ServerResponse> getAllUsers(ServerRequest request){
        Flux<User> users = this.userService.getAllUsers();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }
​
    //添加
    public Mono<ServerResponse> saveUser(ServerRequest request){
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
    }
}

　　　　iii.初始化服务器，编写Router

public class Server {
​
    //1、创建Router路由
    public RouterFunction<ServerResponse> routingFunction(){
        //设置handler对象
        UserService userService = new UserServiceImpl();
        UserHandler handler = new UserHandler(userService);
        //设置路由
        return RouterFunctions.route(
                GET("/users/{id}").and(accept(MediaType.APPLICATION_JSON)), handler::getUserById)
                .andRoute(GET("/users").and(accept(MediaType.APPLICATION_JSON)),handler::getAllUsers);
    }
​
    //2、创建服务器完成适配
    public void createReactorServer(){
        //路由和handler适配
        RouterFunction<ServerResponse> route = routingFunction();
        HttpHandler httpHandler = toHttpHandler(route);
        ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
​
        //创建服务器
        HttpServer httpServer = HttpServer.create();
        httpServer.handle(adapter).bindNow();
    }
​
    //3、最终调用
    public static void main(String[] args) throws Exception{
        Server server = new Server();
        server.createReactorServer();
        System.out.println("enter to exit");
        System.in.read();
    }
}

 

　　⑤使用Webclient调用

public class Client {
    public static void main(String[] args) {
        //调用服务器地址
        WebClient webClient = WebClient.create("http://127.0.0.1:55047");
​
        //根据id查询
        String id = "1";
        User user = 
　　　　　　　　　　　　　　webClient.get().uri("/users/{id}", id)
　　　　　　　　　　　　　　　　　　　　.accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class).block();
        System.out.println(user.getName());
​
        //查询所有用户
        Flux<User> userFlux = 
　　　　　　　　　　　　　　webClient.get().uri("/users")
　　　　　　　　　　　　　　　　　　　　.accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
        userFlux.map(person -> person.getName()).buffer().doOnNext(System.out::println).blockFirst();
    }
}