Spring5
1、Spring框架概述
(1)Spring是轻量级的开源的Java EE框架
(2)Spring可以解决企业应用开发的复杂性
(3)Spring有两个核心部分:IOC和Aop
IOC:控制反转,把创建对象过程交给Spring进行管理
Aop:面向切面编程,不修改源代码进行功能增强
(4)Spring特点
①方便解耦,简化开发
②Aop编程支持
③方便程序测试
④方便和其他框架进行整合
⑤方便进行事务操作
⑥降低API开发难度
2、使用Spring
(1)下载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)使用
1 @Test
2 public void testAdd(){
3 //1、加载spring的配置文件
4 ApplicationContext context =
5 new ClassPathXmlApplicationContext("bean1.xml");
6
7 //2、获取配置创建的对象
8 User user = context.getBean("user",User.class);
9 System.out.println(user);
10 user.add();
11 }
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、属性值包含特殊字符
①把<>进行转义,< >
②把带特殊符号内容写到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类型可以和返回类型不一样
1 //类
2 public class Mybean implements FactoryBean<Course> {
3
4 //定义返回bean
5 @Override
6 public Course getObject() throws Exception {
7 Course course = new Course();
8 return course;
9 }
10
11 @Override
12 public Class<?> getObjectType() { return null; }
13
14 @Override
15 public boolean isSingleton() {
16 return FactoryBean.super.isSingleton();
17 }
18 }
19
20 //Spring配置文件
21 <bean id="myBean" class="com.factoryBean.Mybean"></bean>
22
23 //使用
24 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 //1、创建类,实现BeanPostProcessor
2 public class MyBeanPost implements BeanPostProcessor {
3 @Override
4 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; }
5
6 @Override
7 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; }
8 }
9
10 //2、在配置文件中配置
11 //当存在后置处理器后,在该配置文件中的所有bean都会经过后置处理器处理
12 <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" />
③创建类,在类上面添加对象注解
1 //在注解里面value属性可以省略,省略后默认值时类名称,首字母小写
2 @Component(value = "studentService") //<bean id="studentService" class="..." />
3 public class StudentService {
4 public void add(){
5 System.out.println("service add...");
6 }
7 }
(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—根据属性类型进行自动装配
1 //定义dao类型属性,不需要添加set()方法
2 //添加注入属性注解
3 @Autowired
4 private StudentDao studentDao;
②@Qualifier—根据属性名称进行注入
1 //@Qualifier需要与@Autowired一起使用
2 @Autowired
3 @Qualifier(value = "studentDaoImpl")
4 private StudentDao studentDao;
③@Resource—可以根据类型或名称注入
1 //@Resource //根据类型注入
2 @Resource(name = "studentDaoImpl") //根据名称注入
3 private StudentDao studentDao;
④@Value—注入普通类型属性
1 @Value(value = "Yu")
2 private String name;
(6)完全注解开发
①创建配置类,替代xml配置文件
1 @Configuration //作为配置类,替代xml配置文件
2 @ComponentScan(basePackages = {"com.my.spring5"})
3 public class SpringConfig { }
②编写测试类
1 @Test
2 public void testService(){
3 //1、加载配置类
4 ApplicationContext context =
5 new AnnotationConfigApplicationContext(SpringConfig.class);
6
7 //2、获取配置创建的对象
8 StudentService studentService = context.getBean("studentService", StudentService.class);
9 System.out.println(studentService);
10 studentService.add();
11 }
7、AOP基本概念
(1)面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。
(2)通俗的描述:不通过修改源代码方式,在主干功能里面添加新功能
8、AOP底层原理
(1)AOP底层使用动态代理
①有接口情况,使用JDK动态代理
创建接口实现类代理对象,增强类的方法
②没有接口情况,使用CGLIB动态代理
创建子类的代理对象,增强类的方法
(2)JDK动态代理实现
①创建接口,定义方法
1 public interface OperateDao {
2 public int add(int a,int b);
3 public String update(String id);
4 }
②创建接口实现类,实现方法
1 public class OperateDaoImpl implements OperateDao {
2
3 @Override
4 public int add(int a, int b) { return a+b; }
5
6 @Override
7 public String update(String id) { return "update " + id; }
8 }
③使用Proxy类里面的方法创建代理对象
1 public class JDKProxy {
2 public static void main(String[] args) {
3 Class[] interfaces = {OperateDao.class};
4 OperateDaoImpl operateDao = new OperateDaoImpl();
5 //第一参数:类加载器
6 //第二参数:增强方法所在的类,这个类实现的接口,支持多个接口
7 //第三参数:实现InvocationHandler接口,创建代理对象,写增强部分
8 OperateDao dao = (OperateDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
9 //增强的逻辑
10 @Override
11 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
12 System.out.println("方法之前执行:" + method.getName() + "; 参数:" + Arrays.toString(args));
13
14 Object res = method.invoke(operateDao,args);
15
16 System.out.println("方法执行之后:" + operateDao);
17 return res;
18 }
19 });
20 int result = dao.add(2,3);
21 System.out.println(result);
22 }
23 }
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)操作的步骤
①创建类,在类里面定义方法
1 //被增强的类
2 public class User {
3 public void add(){
4 System.out.println("add...");
5 }
6 }
②创建增强类,编写增强逻辑
//增强的类
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 //1、在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置
2 //前置通知:被增强方法执行前
3 @Before(value = "execution(* com.aopanno.User.add(..))")
4 public void before(){
5 System.out.println("before...");
6 }
7
8 //环绕通知:在被增强方法的执行前和执行后进行操作
9 @Around(value = "execution(* com.my.spring5.aopanno.User.add(..))")
10 public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
11 System.out.println("环绕之前...");
12 //被增强的方法执行
13 proceedingJoinPoint.proceed();
14 System.out.println("环绕之后...");
15 }
16
17 //@After:最终通知,被增强方法执行后执行,相当于finally
18 //@AfterReturning:后置通知,被增强方法返回值之后执行
19 //@AfterThrowing:异常通知,被增强方法抛出异常时执行
20
21 /*
22 环绕之前...
23 before...
24 add...
25 afterReturning...
26 after...
27 环绕之后...
28 */
(2)相同的切入点抽取
1 //相同切入点抽取
2 @Pointcut(value = "execution(* com.aopanno.User.add(..))")
3 public void point(){}
4
5 //前置通知
6 @Before(value = "point()")
7 public void before(){
8 System.out.println("before...");
9 }
(3)有多个增强类对同一个方法进行增强,可以设置增强类优先级
1 //在增强类上面添加注解@Order(数字类型值),数字类型值越小优先级越高
2 @Component
3 @Aspect
4 @Order(2)
5 public class PersonProxy {}
(4)完全使用注解开发
1 @Configuration
2 @ComponentScan(basePackages = {"com.aopanno"})
3 @EnableAspectJAutoProxy(proxyTargetClass = true)
4 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对象
1 @Service
2 public class BookService {
3 @Autowired
4 private BookDao bookDao;
5 }
6
7 @Repository
8 public class BookDaoImpl implements BookDao {
9 @Autowired
10 private JdbcTemplate jdbcTemplate;
11 }
14、JdbcTemplate操作数据库
(1)添加
①对应数据库创建实体类
②编写service和dao类
1 //service类
2 public void addBook(Book book){
3 int count = bookDao.add(book);
4 if(count>0){
5 System.out.println("添加成功!");
6 }else{
7 System.out.println("添加失败!");
8 }
9 }
10
11 //dao类
12 @Override
13 public int add(Book book) {
14 String sql = "insert into book values(?,?,?)";
15 int count = jdbcTemplate.update(sql,book.getBookId(),book.getName(),book.getPrice());
16 return count;
17 }
(2)更新
1 //service类
2 public void updateBookById(Book book){
3 int count = bookDao.updateById(book);
4 if(count>0){
5 System.out.println("更新成功!");
6 }else{
7 System.out.println("更新失败!");
8 }
9 }
10
11 //dao类
12 @Override
13 public int updateById(Book book) {
14 String sql = "update book set name=?,price=? where bookId=?";
15 Object[] args = {book.getName(),book.getPrice(),book.getBookId()};
16 int count = jdbcTemplate.update(sql,args);
17 return count;
18 }
(3)删除
1 //service类
2 public void deleteBookById(int id){
3 int count = bookDao.deleteById(id);
4 if(count>0){
5 System.out.println("删除成功!");
6 }else{
7 System.out.println("删除失败!");
8 }
9 }
10
11 //dao类
12 @Override
13 public int deleteById(int id) {
14 String sql = "delete from book where bookId=?";
15 int count = jdbcTemplate.update(sql,id);
16 return count;
17 }
(4)查询表中记录数
1 //service类
2 public int findCount(){
3 return bookDao.selectCount();
4 }
5
6 //dao类
7 @Override
8 public int selectCount() {
9 String sql = "select count(*) from book";
10 Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
11 return count;
12 }
(5)查询返回对象
1 //service类
2 public Book findOneBook(int id){
3 Book book = bookDao.findBookById(id);
4 return book;
5 }
6
7 //dao类
8 @Override
9 public Book findBookById(int id) {
10 String sql = "select * from book where bookId=?";
11 //第一个参数:sql语句
12 //第二个参数:RowMapper是接口,返回不同类型的数据,使用该接口实现类可以完成数据封装
13 //第三个参数:sql参数
14 Book book = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<Book>(Book.class),id);
15 return book;
16 }
(6)查询返回集合
1 //service类
2 public List<Book> findAllBook(){
3 return bookDao.findAll();
4 }
5
6 //dao类
7 @Override
8 public List<Book> findAll() {
9 String sql = "select * from book";
10 List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
11 return bookList;
12 }
(7)批量添加
1 //service类
2 public void batchAdd(List<Object[]> batchArgs){
3 bookDao.batchAdd(batchArgs);
4 }
5
6 //dao类
7 @Override
8 public void batchAdd(List<Object[]> batchArgs) {
9 String sql = "insert into book values(?,?,?)";
10 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
11 System.out.println(ints);
12 }
(8)批量修改
1 //service类
2 public void batchUpdate(List<Object[]> batchArgs){
3 bookDao.batchUpdate(batchArgs);
4 }
5
6 //dao类
7 @Override
8 public void batchUpdate(List<Object[]> batchArgs) {
9 String sql = "update book set name=?,price=? where bookId=?";
10 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
11 System.out.println(Arrays.toString(ints));
12 }
(9)批量删除
1 //service类
2 public void batchDelete(List<Object[]> batchArgs){
3 bookDao.batchDelete(batchArgs);
4 }
5
6 //dao类
7 @Override
8 public void batchDelete(List<Object[]> batchArgs) {
9 String sql = "delete from book where bookId=?";
10 int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
11 System.out.println(Arrays.toString(ints));
12 }
15、事务操作—事务概念
(1)事务是数据库操作最基本单元,逻辑上一组操作,要么都成功,如果有一个失败所有操作都失败。
(2)事务四个特性(ACID)
①原子性—要么都成功,存在一个失败就失败
②一致性—数据保持一致,例如A向B转账,转账后A和B的钱总和不变
③隔离性—多个事物之间互不影响
④持久性—一旦提交,数据库就发生改变
16、事务操作—搭建事务操作环境
(1)创建数据库和表,添加相应记录
(2)新建service和dao类,完成对象创建和注入关系
(3)在dao类创建少钱和多钱的方法,service类创建转账方法
1 //service类
2 public void accountMoney(int fromCardId,int toCardId,int money){
3 accountDao.reduceMoney(money,fromCardId);
4 accountDao.addMoney(money,toCardId);
5 }
6
7 //dao类
8 @Override
9 public int reduceMoney(int money, int cardId) {
10 String sql = "update account set balance=balance-? where cardid=?";
11 int count = jdbcTemplate.update(sql,money,cardId);
12 return count;
13 }
14
15 @Override
16 public int addMoney(int money, int cardId) {
17 String sql = "update account set balance=balance+? where cardid=?";
18 int count = jdbcTemplate.update(sql,money,cardId);
19 return count;
20 }
(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类里面方法上)添加事务注解
①如果把注解添加到类上面,代表类里面的所有方法都添加事务
②如果把注解添加到方法上面,为该方法添加事务
1 @Service
2 @Transactional
3 public class AccountService {}
19、事务操作—Spring声明式事务管理参数配置
(1)@Transactional,在这个注解里面可以配置事务相关参数
①propagation—事务传播行为
i.事务方法—对数据库表数据进行变化的操作
事务传播行为—多事务方法之间进行调用
事务传播行为类型 | 说明 |
---|---|
REQUIRED | 如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择。 |
REQUIRES_NEW | 当前方法必须启动新事务,并运行。如果当前有事务在运行,把当前事务挂起。 |
SUPPORTS | 如果有事务在运行,当前的方法就在这个事务内运行,否则它可以不运行在事务中。 |
NOT_SUPPORTED | 当前方法不应该运行在事务中。如果当前存在事务,就把当前事务挂起。 |
MANDATORY | 当前方法必须运行在事务内。如果当前没有正在运行的事务,就抛出异常。 |
NEVER | 当前的方法不应该运行在事务内。如果有运行的事务,就抛出异常。 |
NESTED | 如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则启动一个新的事务并运行。 |
ii.图示
iii.配置
1 @Service
2 @Transactional(propagation = Propagation.REQUIRED )
3 public class AccountService {}
②isolation—事务隔离级别
i.事务有特性成为隔离性,多事务操作之间不会产生影响。
ii.不考虑隔离性产生三个读问题:脏读、不可重复读、虚(幻)读
脏读:一个未提交事务读取到另一个未提交事务的数据
不可重复读:一个未提交事务读取到另一提交事务修改的数据,导致两次读取到的结果不一致
虚读:一个未提交事务读取到另一提交事务添加的数据
iii.设置事务隔离级别
脏读 | 不可重复读 | 虚读 | |
---|---|---|---|
READ_UNCOMMITTED(读未提交) | 有 | 有 | 有 |
READ_COMMITTED(读已提交) | 无 | 有 | 有 |
REPEATABLE_READ(可重复读) | 无 | 无 | 有 |
SERIALIZABLE(串行化) | 无 | 无 | 无 |
1 @Service
2 @Transactional(isolation = Isolation.REPEATABLE_READ)
3 public class AccountService {}
③timeout—超时时间
i.事务需要在一定时间内进行提交,如果超时就回滚
ii.默认值是-1,设置时间以秒为单位计算
1 @Service
2 @Transactional(timeout = -1)
3 public class AccountService {}
④readOnly—是否只读
i.读:查询操作;写:添加删除修改操作
ii.readOnly默认值false,表示即可以写操作,也可以读操作
iii.设置为true,表示只能查询
1 @Service
2 @Transactional(readOnly = true)
3 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配置文件
1 @Configuration //配置类
2 @ComponentScan(basePackages = {"com.dao","com.service"}) //组件扫描
3 @EnableTransactionManagement //开启事务
4 public class TxConfig {
5
6 //创建数据库连接池
7 @Bean
8 public DruidDataSource getDruidDataSource(){
9 DruidDataSource dataSource = new DruidDataSource();
10 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
11 dataSource.setUrl("jdbc:mysql://localhost:3306/jsppro");
12 dataSource.setUsername("root");
13 dataSource.setPassword("12345678");
14 return dataSource;
15 }
16
17 //创建JdbcTemplate对象
18 @Bean
19 public JdbcTemplate getJdbcTemplate(DataSource dataSource){
20 //到ioc容器中根据类型找到dataSource
21 JdbcTemplate jdbcTemplate = new JdbcTemplate();
22 jdbcTemplate.setDataSource(dataSource);
23 return jdbcTemplate;
24 }
25
26 //创建事务管理器对象
27 @Bean
28 public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
29 DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
30 transactionManager.setDataSource(dataSource);
31 return transactionManager;
32 }
33 }
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 注解可以使用在方法上面,属性上面,参数上面,表示方法返回可以为空,属性值可以为空,参数值可以为空
1 //方法,返回可以为空
2 @Nullable
3 String getId();
4
5 //属性,属性值可以为空
6 @Nullable
7 private String bookName;
8
9 //参数,参数值可以为空
10 public <T> void registerBean(@Nullable String beanName){}
(3)支持函数式风格GenericApplicationContext
1 public void testGenericApplicationContext(){
2 //函数式风格创建对象,交给Spring管理
3 //1、创建GenericApplicationContext对象
4 GenericApplicationContext context = new GenericApplicationContext();
5 //2、调用context的方法对象注册
6 context.refresh();
7 //context.registerBean(User.class,() -> new User());
8 context.registerBean("user",User.class,() -> new User());
9 //3、获取在Spring注册的对象
10 //User user = (User) context.getBean("com.my.spring5.User");
11 User user = (User) context.getBean("user");
12 System.out.println(user);
13 }
(4)整合JUint5单元测试框架
①整合JUnit4
i.引入相关的依赖
ii.创建测试类,使用注解方式完成
1 @RunWith(SpringJUnit4ClassRunner.class) //单元测试框架
2 @ContextConfiguration("classpath:bean1.xml") //加载配置文件
3 public class JTest4 {
4
5 @Autowired
6 private Book book;
7
8 @Test
9 public void test(){
10 book.testDemo();
11 }
12 }
②整合JUnit5
i.引入相关的依赖
ii.创建测试类,使用注解方式完成
1 @ExtendWith(SpringExtension.class)
2 @ContextConfiguration("classpath:bean1.xml")
3 //@SpringJUnitConfig(locations = "classpath:bean1.xml") //复合的注解,替代上面两个注解
4 public class JTest5 {
5
6 @Autowired
7 private Book book;
8
9 @Test
10 public void test(){
11 book.testDemo();
12 }
13 }
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。
1 public class ObserverDemo extends Observable {
2 public static void main(String[] args) {
3 ObserverDemo observer = new ObserverDemo();
4 //添加观察者
5 observer.addObserver((o,arg)->{
6 System.out.println("发生了变化");
7 });
8 observer.addObserver((o,arg)->{
9 System.out.println("手动被观察者通知,准备变化");
10 });
11 observer.setChanged(); //数据变化
12 observer.notifyObservers(); //通知
13 }
14 }
(6)响应式编程(Reactor 实现)
①响应式编程操作中,Reactor满足Reactive规范框架
②Reactor 有两个核心类,Mono和Flux, 这两个类实现接口Publisher,提供丰富操作符。Flux 对象实现发布者,返回N个元素; Mono 实现发布者,返回0或者1个元素。
③Flux和Mono都是数据流的发布者,使用Flux和Mono都可以发出三种数据信号:元素值,错误信号,完成信号,错误信号和完成信号都代表终止信号,终止信号用于告诉订阅者数据流结束了,错误信号终止数据流同时把错误信息传递给订阅者。
④代码演示Flux和Mono
1 //1、引入依赖
2 <dependency>
3 <groupId>io.projectreactor</groupId>
4 <artifactId>reactor-core</artifactId>
5 <version>3.1.5.RELEASE</version>
6 </dependency>
7
8 //2、编写代码
9 public class TestReactor {
10 public static void main(String[] args) {
11 //just方法直接声明
12 Flux.just(1,2,3,4);
13 Mono.just(1);
14
15 //其他方法
16 Integer[] array = {1,2,3,4};
17 Flux.fromArray(array);
18
19 List<Integer> list = Arrays.asList(array);
20 Flux.fromIterable(list);
21
22 Stream<Integer> stream = list.stream();
23 Flux.fromStream(stream);
24 }
25 }
⑤三种信号特点
i.错误信号和完成信号都是终止信号,不能共存的。
ii.如果没有发送任何元素值,而是直接发送错误或者完成信号,表示是空数据流
iii.如果没有错误信号,没有完成信号,表示是无限数据流。
⑥调用just或者其他方法只是声明数据流,数据流并没有发出,只有进行订阅之后才会触发数据流,不订阅什么都不会发生的。
1 Flux.just(1,2,3,4).subscribe(System.out::print);
2 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依赖
②配置启动的端口号
③创建包和相关类
1 //entity包,实体类
2 public class User {
3 private String name;
4 private String gender;
5
6 public User(String name, String gender) {
7 this.name = name;
8 this.gender = gender;
9 }
10
11 public String getName() { return name; }
12
13 public void setName(String name) { this.name = name; }
14
15 public String getGender() { return gender; }
16
17 public void setGender(String gender) { this.gender = gender; }
18 }
19
20 //service包,用户操作接口
21 public interface UserService {
22 //根据id查询用户
23 Mono<User> getUserById(int id);
24
25 //查询所有用户
26 Flux<User> getAllUsers();
27
28 //添加用户
29 Mono<Void> saveUserInfo(Mono<User> user);
30 }
31
32 //service.Impl包,用户操作接口实现类
33 @Service
34 public class UserServiceImpl implements UserService {
35
36 //创建map集合存储数据
37 private final Map<Integer,User> users = new HashMap<>();
38
39 public UserServiceImpl(){
40 this.users.put(1,new User("Yu","man"));
41 this.users.put(2,new User("Wang","man"));
42 }
43
44 @Override
45 public Mono<User> getUserById(int id) {
46 return Mono.justOrEmpty(this.users.get(id));
47 }
48
49 @Override
50 public Flux<User> getAllUsers() {
51 return Flux.fromIterable(this.users.values());
52 }
53
54 @Override
55 public Mono<Void> saveUserInfo(Mono<User> user) {
56 return user.doOnNext(person -> {
57 //向map集合里面放值
58 int id = users.size() + 1;
59 users.put(id,person);
60 }).thenEmpty(Mono.empty());
61 }
62 }
63
64 //controller包,控制器
65 @RestController
66 public class UserController {
67
68 //注入service
69 @Autowired
70 private UserService userService;
71
72 //id查询
73 @GetMapping("/user/{id}")
74 public Mono<User> getUserById(@PathVariable int id){
75 return userService.getUserById(id);
76 }
77
78 //查询所有
79 @GetMapping("user")
80 public Flux<User> getUsers(){
81 return userService.getAllUsers();
82 }
83
84 //添加
85 @PostMapping("/saveuser")
86 public Mono<Void> saveUser(@RequestBody User user){
87 Mono<User> userMono = Mono.just(user);
88 return userService.saveUserInfo(userMono);
89 }
90 }
91
92 //测试
93 //访问:http://localhost:8081/user
94 //显示:[{"name":"Yu","gender":"man"},{"name":"Wang","gender":"man"}]
(10)基于函数式编程模型实现
①在使用函数式编程模型操作时候,需要自己初始化服务器
②基于函数式编程模型时候,有两个核心接口:RouterFunction(实现路由功能,请求转发给对应的handler)和HandlerFunction(处理请求并生成响应的函数)。核心任务是定义两个函数式接口的实现并且启动需要的服务器。
③ SpringWebflux的请求和响应不再是ServletRequest和 ServletResponse,而是ServerRequest和ServerResponse。
④步骤
i.把注解编程模型工程复制一份
ii.创建Handler
1 public class UserHandler {
2
3 private final UserService userService;
4 public UserHandler(UserService userService){
5 this.userService = userService;
6 }
7
8 //根据id查询
9 public Mono<ServerResponse> getUserById(ServerRequest serverRequest){
10 int userId = Integer.valueOf(serverRequest.pathVariable("id"));
11
12 //空值处理
13 Mono<ServerResponse> notFound = ServerResponse.notFound().build();
14
15 Mono<User> userMono = this.userService.getUserById(userId);
16 //把userMono进行转换并返回
17 return
18 userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
19 .body(fromObject(person)))
20 .switchIfEmpty(notFound);
21 }
22
23 //查询所有
24 public Mono<ServerResponse> getAllUsers(ServerRequest request){
25 Flux<User> users = this.userService.getAllUsers();
26 return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
27 }
28
29 //添加
30 public Mono<ServerResponse> saveUser(ServerRequest request){
31 Mono<User> userMono = request.bodyToMono(User.class);
32 return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
33 }
34 }
iii.初始化服务器,编写Router
1 public class Server {
2
3 //1、创建Router路由
4 public RouterFunction<ServerResponse> routingFunction(){
5 //设置handler对象
6 UserService userService = new UserServiceImpl();
7 UserHandler handler = new UserHandler(userService);
8 //设置路由
9 return RouterFunctions.route(
10 GET("/users/{id}").and(accept(MediaType.APPLICATION_JSON)), handler::getUserById)
11 .andRoute(GET("/users").and(accept(MediaType.APPLICATION_JSON)),handler::getAllUsers);
12 }
13
14 //2、创建服务器完成适配
15 public void createReactorServer(){
16 //路由和handler适配
17 RouterFunction<ServerResponse> route = routingFunction();
18 HttpHandler httpHandler = toHttpHandler(route);
19 ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
20
21 //创建服务器
22 HttpServer httpServer = HttpServer.create();
23 httpServer.handle(adapter).bindNow();
24 }
25
26 //3、最终调用
27 public static void main(String[] args) throws Exception{
28 Server server = new Server();
29 server.createReactorServer();
30 System.out.println("enter to exit");
31 System.in.read();
32 }
33 }
⑤使用Webclient调用
1 public class Client {
2 public static void main(String[] args) {
3 //调用服务器地址
4 WebClient webClient = WebClient.create("http://127.0.0.1:55047");
5
6 //根据id查询
7 String id = "1";
8 User user =
webClient.get().uri("/users/{id}", id)
.accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class).block();
9 System.out.println(user.getName());
10
11 //查询所有用户
12 Flux<User> userFlux =
webClient.get().uri("/users")
.accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
13 userFlux.map(person -> person.getName()).buffer().doOnNext(System.out::println).blockFirst();
14 }
15 }