一、Spring概念
1、Spring概述
- Spring是轻量级的开源的JavaEE框架
- Spring可以解决企业应用开发的复杂性
- Spring的两个核心部分：IOC和Aop
- IOC：控制反转，把创建对象的过程交给Spring进行管理
- Aop：面向切面，不修改源代码进行功能增强
- 特点
- 方便解耦
- Aop编程支持
- 方便程序测试
- 方便和其他框架进行整合
- 方便进行事务操作
- 降低API开发难度
- 源码是经典的学习案例
2、开发步骤
- 下载Spring的jar包
- 创建java工程，导入Spring的基础jar包
- 创建xml配置文件
- 创建主程序
- 加载Spring配置文件
- 获取配置创建的对象
- 调用方法
二、IOC容器
0、IOC概念
- 什么是IOC
- 控制反转，把对象创建和对象之前的调用过程，交给Spring进行管理
- 使用IOC目的
- 降低耦合度
1、IOC底层原理
- xml解析、工厂模式、反射
- 实现方式
- 原始方式
- 工厂模式
- Ioc方式
- xml配置文件，配置创建的对象
- 使用工厂模式，创建工厂类，使用工厂类进行生产对象
- 解析xml配置文件，拿到全类名
- 通过Class.forName()加载类的字节码文件
- 通过反射创建对象
2、IOC接口（BeanFactory)
- IOC思想基于IOC容器完成，IOC容器底层就是对象工厂
- Spring提供IOC窗口实现两种方式(两个接口):
- BeanFactory：
- ioc容器基本实现，是Spring内部使用接口，不提供开发人员使用
- 区别：加载配置文件时候不会创建对象，在使用对象的时候，才会创建对象
- ApplicationContext
- BeanFactory接口的子接口，提供了更多更强大的功能，一般由开发人员进行使用
- 区别：加载配置文件时候就会把配置文件中的对象进行创建
- ApplicationContext实现类
- FileSystemXmlApplicationContext：系统下的绝对路径
- ClassPathXmlApplicationContext：类路径
- BeanFactory：
3、IOC操作Bean管理（基于xml)
基于xml方式创建对象
<bean id="user" class="online.iluo.User"></bean>(1) 在spring配置文件中，使用bean标签，标签里添加对应的属性就可以实现对象创建
(2)在bean标签有很多属性，常用的属性：
- id:唯一标识
- class：类全路径（包路径）
(3)创建对象的时候，默认执行无参构造器完成对象创建
基于xml方式注入属性
(1)DI:依赖注入，就是注入属性，需要在创建对象的基础之上完成
(2)注入的方式：
- 第一种方式，通过set方式注入
//online.iluo.Book public class Book { private String bname; public void setBname(String bname) { this.bname = bname; } }<!-- application.xml--> <!-- set方式注入属性--> <bean id="book" class="online.iluo.Book"> <!-- 使用property完成属性注入 name:类里面的属性名称 value:向属性注入的值 --> <property name="bname" value="《java 编程思想》"></property> </bean>- 第二种方式，通过有参构造注入
public class Orders { private String orderNo; public Orders(String orderNo) { this.orderNo = orderNo; } }<!-- 使用构造器注入 --> <bean id="orders" class="online.iluo.Orders"> <!-- name: 构造器中的属性 value: 属性中的值 --> <constructor-arg name="orderNo" value="adb"></constructor-arg> </bean>- 第三种注入方式，p名称空间注入，简化基于set方法的xml配置方式（了解）
(3)注入的类型
字面量
null值
<!--null值注入--> <bean id="book" class="online.iluo.Book"> <property name="bname"> <null/> </property> </bean>属性值中包含特殊符号
<bean id="book" class="online.iluo.Book"> <!-- 两种方式 1 把<>进行转义< > 2 把特殊符号内容写到CDATA --> <property name="bname"> <value> <![CDATA[<<南京>>]]> </value> </property> </bean>
外部bean
（1）创建两个类service类和dao类
（2）在service调用dao里面的类
//online.iluo.service.UserService public class UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } public void add(){ System.out.println("userService"); userDao.add(); } }//online.iluo.dao.UserDao public class UserDao { public void add(){ System.out.println("UserDao..."); } }<bean id="userDao" class="online.iluo.dao.UserDao"></bean> <bean id="userService" class="online.iluo.service.UserService"> <!-- name：类的属性名称 ref: 创建userDao对象bean标签的id值 --> <property name="userDao" ref="userDao"></property> </bean>内部bean
（1）一对多关系：部门和员工，一个部门有多个员工，一个员工属于一个部门，部门是一，员工是多
（2）在实体类之前表示一对多关系
//部门类 public class Dept { private String dname; public void setDname(String dname) { this.dname = dname; } }//员式类 public class Emp { private String ename; private String gender; //员工属于某一个部门，使用对象形式表示 private Dept dept; public void setDept(Dept dept) { this.dept = dept; } public void setEname(String ename) { this.ename = ename; } public void setGender(String gender) { this.gender = gender; } }<bean id="emp" class="online.iluo.Emp"> <property name="ename" value="lucy"/> <property name="gender" value="女"/> <!-- 设置对象类型属性--> <property name="dept"> <bean id="dept" class="online.iluo.Dept"> <property name="dname" value="保安部"/> </bean> </property> </bean>级联赋值
第一种写法：
<bean id="emp" class="online.iluo.Emp"> <property name="ename" value="lucy"/> <property name="gender" value="女"/> <!-- 级联赋值 设置对象类型属性--> <property name="dept" ref="dept"/> </bean> <bean id="dept" class="online.iluo.Dept"> <property name="dname" value="财务"/> </bean>第二种写法
//员式类 public class Emp { private String ename; private String gender; //员工属于某一个部门，使用对象形式表示 private Dept dept; public Dept getDept() { return dept; } public void setDept(Dept dept) { this.dept = dept; } public void setEname(String ename) { this.ename = ename; } public void setGender(String gender) { this.gender = gender; } }<bean id="emp" class="online.iluo.Emp"> <property name="ename" value="lucy"/> <property name="gender" value="女"/> <!-- 级联赋值 设置对象类型属性--> <property name="dept" ref="dept"/> <!-- 需要生成dept的get方法，才能使用，参数上面代码--> <property name="dept.dname" value="生产部"/> </bean> <bean id="dept" class="online.iluo.Dept"> <property name="dname" value="财务部"/> </bean>集合类型
public class Stu { //1数组类型属性 private String[] courses; //2List类型属性 private List<String> lists; //3Map类型属性 private Map<String, String> maps; //4Set类型属性 private Set<String> sets; //放对象 private List<Course> courseList; public void setCourseList(List<Course> courseList) { this.courseList = courseList; } public void setCourses(String[] courses) { this.courses = courses; } public void setLists(List<String> lists) { this.lists = lists; } public void setMaps(Map<String, String> maps) { this.maps = maps; } public void setSets(Set<String> sets) { this.sets = sets; } }<bean id="stu" class="online.iluo.collectionType.Stu"> <!--注入数组类型属性 --> <property name="courses"> <array> <value>java</value> <value>数据库</value> </array> </property> <!--注入List集合类型属性 --> <property name="lists"> <list> <value>李四</value> <value>张三</value> </list> </property> <!--注入Map集合类型属性 --> <property name="maps"> <map> <entry key="Java" value="java"></entry> <entry key="PHP" value="php"></entry> </map> </property> <!--注入Set集合类型属性 --> <property name="sets"> <set> <value>Mysql</value> <value>Redis</value> </set> </property> </bean>集合里面设置对象类型值
<!--注入对象--> <property name="courseList"> <list> <ref bean="course1"></ref> </list> </property> <bean id="course1" class="online.iluo.collectionType.Course"> <property name="course" value="Spring"/> </bean>把集合注入部分提取出来
在spring配置文件中引入名称空间util
4、IOC操作Bean管理（FactoryBean)
spring有两种类型bean，一种是普通bean，另外一种是工厂bean
普通的bean：在配置文件中定义bean类型就是返回类型
工厂bean：在配置文件定义bean类型可以和返回类型不一样
第一步创建类，让该类作为工厂bean，实现接口FactoryBean public class Mybean implements FactoryBean<Course> { //第二步实现接口里面的方法，在实现方法中定义返回的bean类型 @Override public Course getObject() throws Exception { Course course = new Course(); course.setCourse("test"); return course; } @Override public Class<?> getObjectType() { return null; } @Override public boolean isSingleton() { return false; } }
5、IOC操作Bean管理（Bean的作用域）
（1）在Spring里面，设置创建bean实例是单例还是多例
（2）默认情况下是单例模式
（3）在Spring配置文件bean标签里面有scope属性用于设置单例或多例
（4）scope属性值：
singleton：默认值，表示单实例
prototype：表示多实例
request:
session：
（5）区别
第一：singleton单实例，prototype多实例
第二：设置scope值是singleton时候，加载Spring配置文件时就会创建单实例对象，设置prototype时只有用getBean()才会创建
6、IOC操作Bean管理（bean生命周期)
（1）什么是生命周期：从对象创建到对象销毁的过程
（2）bean生命周期：
* 通过构造器创建bean实例（无参数构造器）
* 为bean的属性设置值和对其他bean引用（调用set方法）
* 把bean实例传递给bean后置处理器的方法
* 调用bean的初始化的方法（需要进行配置，bean标签中的init-method属性）
* 把bean实例传递给bean后置处理器的方法
* bean可以使用了（对象获取到了）
* 当容器关闭时候（applicationContext.close()），调用bean的销毁的方法（需要进行配置，bean标签中的destroy-method属性
（3）后置处理器：当配置了后置处理器后，所有的bean在初始化前后都会被传递到这个后置处理器
- 创建一个类，实现BeanPostProcessor
- 实现方法
- postProcessBeforeInitialization() 初始化之前调用
- postProcessAfterInitialization() 初始化之后调用
7、IOC操作Bean管理（自动装配)
（1）什么是自动装配
根据指定装配规则（属性名称或者属性值类型），Spring自动将匹配的属性值进行注入
（2）自动装配过程
bean标签属性autowire，配置自动装配
属性值：
byName：根据属性名称注入
byType：根据属性类型注入：相同类型不能有多个
8、IOC操作Bean管理（外部属性文件)
（1）场景：读取数据库配置信息
（2）直接配置连接池
（3）引入外部属性文件配置数据库信息
第一步：创建配置文件jdbc.properties
#jdbc.properties
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/userDb
jdbc.UserName=root
jdbc.password
第二步：引入context名称空间
第三步：在Spring配置文件中使用
第四步：使用表达式取出数据库配置文件的值 ${jdbc.driverClass}
9、IOC操作Bean管理（基于注解)
（1）什么是注解
（2）Spring针对Bean管理中创建对象提供注解
@Component
@Service
@Controller
@Repository
上面四个注解功能是一样的，都可以用来创建bean实例
@Bean 需要在配置类中使用，第三方类库无法添加以上四个注解时，可以用该注解或xml添加到容器
（3）基于注解方式创建对象
引入依赖，需要引入aop依赖
开启组件扫描
<!-- use-default-filters="false" 表示不使用默认filter进行扫描，自己配置 context:include-filter 设置扫描哪些内容 --> <context:component-scan base-package="包名，包名" use-default-filters="false"> <!-- 只扫描注解为 Controller --> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> <!-- 不进行扫描，注解为 Controller --> <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> </context:component-scan>创建类，在类上添加创建对象的注解
（4）属性的注入
- @AutoWired：根据属性类型进行自动注入，不需要set方法
- @Qualifier：根据属性名称进行注入，要和@AutoWired一起使用，当属性类型有两个时，可以通过此注解指定名称注入属性
- @Resource：可以根据类型注入，可以根据名称注入，
- @Value：注入普通类型属性
（5）纯注解开发
- 创建一个配置类
- 添加@Configuration注解做为配置类
- 添加@ComponentScan注解扫描组件
三、Aop
1、什么是Aop
- 面向切面（方面）编程，利用Aop可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低
- 不改变源代码的情况下，在原功能上添加新的功能，这个过程就是aop
2、AOP底层原理
- AOP底层使用动态代理
- 两种情况的动态代理
第一种：有接口情况，使用JDK动态代理
创建接口实现类代理对象，增强类的方法
java.lang.reflect.Proxy static Object newProxyInstance (ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 第一个参数，类加载器 第二个参数，增强方法所有的类，这个类实现的接口，支持多个接口 第三个参数，实现这个接口，创建代理对象代码实现
//创建接口，定义方法 public interface UserDao { public int add(int a, int b); public String update(String id); } //创建实现类，实现方法 public class UserDaoImpl implements UserDao { public int add(int a, int b) { return a + b; } public String update(String id) { return id; } } //创建接口实现类代理对象 public static void main(String[] args) { //需要被代理的类 UserDao userdao = new UserDaoImpl(); //返回代理类 UserDao userProxy = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), new Class[]{UserDao.class}, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("方法之前执行"); //把需要代理的类传过来 Object obj = method.invoke(userdao, args); System.out.println(method.getName()); System.out.println("方法之后执行"); return obj; } }); userProxy.add(1,2); }
第二种：没有接口情况，使用CGLIB动态代理
- 创建当前类子类的代理对象
3、AOP术语
1、连接点
在一个类中，那些方法可以被增强，这些方法就叫做连接点2、切入点
实际被真正增强的方法就被称为切入点；那个连接点被增强那个就是切入点3、通知（增强）
(1)、实际增强的逻辑部分就称为通知（增强） (2)、通知有多种类型 *前置通知: *后置通知: *环绕通知: *异常通知: *最终通知:4、切面
指的是一个动作，把通知应用到切入点的过程
4、Aop操作
1）、Spring框架一般都是基于AspectJ实现Aop操作
2）、AspectJ不是Spring组成部分，一般把AspectJ和Spring框架一起使用，进行Aop操作
3）、基于AspectJ实现Aop操作
（1）基于xml配置文件
（2）基于注解方式（常用）
4）、在项目工程中导入Aop依赖、AspectJ相关依赖
5）、切入点表达式
（1）切入 点表达式作用：知道对哪个类里面的哪个方法进行增强
（2）语法结构 ：
execution([权限修饰符] [返回类型] [类全路径][方法名称]([参数列表]))
举例1：对online.iluo.dao.BookDao类里面的add方法进行增强
execution(* online.iluo.dao.BookDao.add(..))
举例2：对online.iluo.dao.BookDao类里面的所以方法进行增强
execution(* online.iluo.dao.BookDao.*(..))
举例3：对online.iluo.dao包里面所有类，类里面所有方法进行增强
execution(* online.iluo.dao.*.*(..))
5、AOP操作（AspectJ注解）
1）、创建类，在类里面定义方法
@Component
public class User {
public void add(){
System.out.println("add......");
}
}
2）、创建增强类（编写增强逻辑）
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
@Pointcut(value = "execution(* online.iluo.aopanno.User.add(..))")
public void pointCut(){
}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointCut()")
public void before(){
System.out.println("before...");
}
//方法执行之后执行（总是会执行）最终通知
@After(value = "execution(* online.iluo.aopanno.User.add(..))")
public void after(){
System.out.println("after...");
}
//方法返结果后执行（出现异常不会执行）后置通知
@AfterReturning(value = "execution(* online.iluo.aopanno.User.add(..))")
public void afterReturning(){
System.out.println("AfterReturning...");
}
//出现异常时执行（没有异常不会执行）异常通知
@AfterThrowing(value = "execution(* online.iluo.aopanno.User.add(..))")
public void afterThrowing(){
System.out.println("AfterThrowing...");
}
//环绕通知
@Around(value = "execution(* online.iluo.aopanno.User.add(..))")
public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕之前 ...");
proceedingJoinPoint.proceed();
System.out.println("环绕之后 。。。");
}
}
3）、进行通知的配置
//1、在Spring配置文件中，开启注解扫描
//2、使用注解创建增强类和被增强类
//3、在增强类上面添加注解@Aspect
//4、在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">
<!-- 开启注解扫描 -->
<context:component-scan base-package="online.iluo"/>
<!-- 开启Aspect生成对象 -->
<aop:aspectj-autoproxy/>
<!-- 纯注解开发，配置类上使用注解代替xml配置：aop:aspectj-autoproxy-->
<!-- @EnableAspectJAutoProxy(proxyTargetClass = true)-->
</beans>
4）、配置不同类型的通知
- 在增强类的里面，在作为通知方法上面添加通知类型注解，使用切入点表达式配置
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
//前置通知
//@Before注解表示作为前置通知
@Before(value = "execution(* online.iluo.aopanno.User.add(..))")
public void before(){
System.out.println("before...");
}
}
5）、对相同切入点表达式进行抽取
//增强的类
@Component
@Aspect //生成代理对象
public class UserProxy {
@Pointcut(value = "execution(* online.iluo.aopanno.User.add(..))")
public void pointCut(){
}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointCut()")
public void before(){
System.out.println("before...");
}
}
6）、有多个增强类对同一个方法进行增强，设置增强类优先级
//1、增强类上面添加注解@Order(1)，数值越小，级别越高
@Component
@Aspect //生成代理对象
//有多个增强类对同一个方法进行增强，设置增强类优先级
@Order(1)
public class UserProxy {
@Pointcut(value = "execution(* online.iluo.aopanno.User.add(..))")
public void pointCut(){
}
//前置通知
//@Before注解表示作为前置通知
@Before(value = "pointCut()")
public void before(){
System.out.println("before...");
}
}
6、AOP操作（AspectJ配置文件）
1）、创建两个类，增强类和被增强类，创建方法
2）、在Spring配置文件中创建两个类的对象
3）、在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">
<!-- 创建对象 -->
<bean id="book" class="online.iluo.aopxml.Book"></bean>
<bean id="bookProxy" class="online.iluo.aopxml.BookProxy"></bean>
<!--配置aop增强-->
<aop:config>
<!-- 切入点表达式 -->
<aop:pointcut id="p" expression="execution(* online.iluo.aopxml.Book.add(..))"/>
<!-- 配置切面 -->
<aop:aspect ref="bookProxy">
<!-- 增强作用在具体的方法上-->
<aop:before method="before" pointcut-ref="p"></aop:before>
</aop:aspect>
</aop:config>
</beans>
四、JdbcTemplate
五、事务管理
六、Spring5新特性
1、整个Spring5框架代码基于Java8,运行时兼容JDK9,许多不建议使用的方法和类删除
2、Spring5框架自带了通用的日志封装
* Spring5已经移除了Log4jConfigListener,官方建议使用Log4j2 * Spring5框架整合Log4j
* 第一部分需要引入相关依赖
* 第二部分创建Log4j2.xml配置文件，（名字固定）
3、Spring5框架支持@Nullable注解
@Nullable注解可以使用在方法上面，表示方法返回可以为空；属性上面，属性值可以为空；参数上面，参数值可以为空；
4、Spring5支持函数式风格编程，GenericApplicaionContext/
5、整合JUnit5进行单元测试
整合Junit4
引入Spring5相关针对测试依赖（spring-test.jar,JUnit4)
创建测试类，使用注解完成
@RunWith(SpringJUnit4ClassRunner.class) //指定单元测试框架版本 @ContextConfiguration("classpath:bean.xml") //加载配置类 public class JTest4{ @AutoWired private UserService userService; }
Spring5整合JUnit5
引入Junit5.jar包
创建测试类，使用注解完成
//@ExtendWith(SpringExtension.class) //指定单元测试框架版本 //@ContextConfiguration("classpath:bean.xml") //加载配置类 @SpringJUnitConfig(locations="classpath:bean.xml") //相当于上面两个注解 public class JTest4{ @AutoWired private UserService userService; }
6、SpringWebFlux
1）、SpringWebFlux介绍
1）、是Spring5添加新的模块，用于web开发的，功能SpringMVC类似的，WebFlux使用当前 一种比较流行的响应式编程出现的框架
2）、使用传统web框架，比如SpringMVC,这些基于Servlet容器，webFlux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持的，核心是基于Reactor的相关API实现的，
3）、什么是异步非阻塞
*异步同步
*非阻塞和阻塞
上面都是针对对象不一样
异步和同步针对调用者，调用者发送请求，如果等着对方回应之后再才去做其他事件，表示同步，如果发送请求之后，不等着对方回应就去做其他事件就是异步
阻塞和非阻塞针对被调用者，被调用者收到请求之后 ，做完请求任务之后才给出反馈就是阻塞，收到请求之后马上给出反馈然后再去做事件就是非阻塞
4）webFlux特点：
非阻塞式：在有限的资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程
函数式编程：Spring5框架基于Java8,WebFlux使用Java8函数式编程实现路由请求
5）、比较SpringMvc
两个框架都可以使用注解方式，都运行在Tomcat等容器中
SpringMVC采用命令式编程，webFlux采用异步响应式编程
SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat
SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty
2）、响应式编程
- 什么是响应式编程 * 响应式编程是一种面向数据流和变化传播的编程范式，这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值 通过数据流进行传播 * 电子表格 = c1 + b1
- Java8及其之前的版本 * 观察者模式两个类，Observer和Observable
- 响应式编程（Reactor实现）
- 响应式编程操作中，Reactor满足Reactive规范
- Reactor有两个核心类，Mono和Flux,这两个类都实现了接口Publisher(发布者)，提供了丰富的操作符Flux对象实现发布者，返回N个元素，Mono也可以实现发布者，返回0或1个元素
- Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发送三种数据信号：
- 元素值
- 错误信号：代表终止信号（告诉订阅者数据流结束了）
- 完成信号：代表终止信号（终止数据流同时把错误信息传给订阅者）
- 代码演示Flux和Mono
- 三种信号特点
- 错误信息和完成信号都是终止信号，不能供存
- 如果没有发送任何元素值，而是直接发送错误或者完成信息，表示空数据流
- 如果没有错误信息，没有完成信号，表示无限数据流
- 调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流
- 操作符
- 对数据流进行各种处理，这种就叫做操作符：
- 第一个 map:元素映射为新元素
- 第二个 flatMap:元素映射为流
3）、WebFlux执行流程和核心API
- SpringWebFlux基于Reactor，默认容器是Netty，Netty是高性能，NIO（异步非阻塞）框架
- Netty
- BIO 阻塞
- NIO 非阻塞
- SpringWebFlux执行过程和SpringMVC相似
- SpringWebFlux核心控制器DispatchHandler,实现接口WebHandler
- SpringWebFlux里面DispatcheHandler，负责请求的处理
- HandllerMapper:请求查询到处理的方法
- HandlerAdapter：真正负责请求处理
- HandlerResultHandler：响应结果处理
- SpringWebFlux实现函数式编程，两个接口，RouterFunction(路由处理)和HandlerFunction（函数处理）
4）、SpringWebFlux(基于注解编程模型)
创建SpringBoot工程，导入依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency>配置启动的端口号
- 创建相关的包和类
5）、SpringWebFlux(基于函数式编程模型)
- 在使用函数式编程模型操作的时候，需要自己初始化服务器
- 基于函数式编程模型时，有两个核心接口，RouterFunction(实现路由功能，请求转发)和HandlerFunction(处理请求生成响应的函数 )，核心任务就是定义这两个函数式接口的实现，并且启动需要的服务器
- SpringWebFlux请求和响应不再是ServletRequest和ServletResponse,而是ServerRequest和ServerResponse
- 步骤：
- 创建Handler（具体实现方法）
文档信息
- 本文作者：clsnull
- 本文链接：https://clsnull.github.io/2020/08/31/Spring5%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/
- 版权声明：自由转载-非商用-非衍生-保持署名（创意共享3.0许可证）