一、Spring5框架新功能
1、整个Spring5框架的代码基于Java8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除。
2、Sping5框架自带了通用的日志封装。
（1）Spring5已经移除Log4jConfigListener，官方建议使用Log4j2
（2）Spring5框架整合Log4j2
①引入jar包
②创建Log4j2.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序：OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL-->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以部设置，当设置成trace时，可以看到lof4j2内部各种详细输出 -->
<Configuration status="INFO">
<!--Appenders:定义日志输出目的地，内容和格式等 -->
<!--现定于所有的appender-->
<Appenders>
<!--Console:输出日志信息到控制台、标准输出 -->
<Console name="Console" target="SYSTEM_OUT">
<!--pattern:控制日志输出格式：日期,线程名,日志级别,日志名称,日志信息,换行 -->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level [%L] - %msg%n" />
</Console>
</Appenders>
<!--定于Loggers，只有定义了logeers并引入的appender，appender才会生效-->
<!--root 用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
<Loggers>
<Root level="info">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>3、Spring5框架核心容器支持@Nullable注解
（1）@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空。
（2）注解用在方法上面，方法返回值可以为空
@Nullable
String getId();（3）注解使用在方法参数里面，方法参数可以为空
public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier, BeanDefinitionCustomizer... customizers) {
this.reader.registerBean(beanClass, beanName, supplier, customizers);
}（4）注解使用在属性上面，属性值可以为空
@Nullablee
private String BookName4、Spring5核心容器支持函数式风格Generic Application
//函数式风格创建对象，交给Spriing进行管理
@Test
public void testGenericApplicationContext(){
// 1、创建GenericApplicationContext对象
GenericApplicationContext context = new GenericApplicationContext();
// 2、调用context的方法对象注册
context.refresh();
context.registerBean("user1",User.class,() -> new User());
// context.registerBean(User.class,() -> new User());
// 3、获取在spring注册的对象
/* User user = (User) context.getBean("com.oykq.test.User");*/
User user = (User) context.getBean("user1");
System.out.println(user);
}5、Spring5支持整合JUnit5
（1）整合Junit4
①引入Spring相关针对测试依赖
②创建测试类，使用注解方式完成
@RunWith(SpringJUnit4ClassRunner.class)//单元测试版本
@ContextConfiguration("classpath:bean1.xml")//加载配置文件
public class Jtest4 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.acountMoney();
}
}（2）Spring整合JUnit5
①引入JUnit5的jar包
②创建测试类，使用注解完成
@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:bean1.xml")//加载配置文件
public class Jtest5 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.acountMoney();
}
}③使用一个复合注解代替上面两个注解完成整合
@SpringJUnitConfig(locations = "classpath:bean1.xml")
public class Jtest5 {
@Autowired
private UserService userService;
@Test
public void test1(){
userService.acountMoney();
}
}
二、Spring5框架新功能（Webflux）
1、SpringWebflux介绍
（1）式spring添加的新模块，用于web开发的，功能SpringMVC类似的，Webflux使用当前一种比较流行的响应式编程出现的框架。
（2）使用传统web框架没比如SpringMVC，这些基于Servlet容器，Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactorr的相关API实现的。
（3）解释什么是异步非阻
①异步和同步
②非阻塞和阻塞
③上面都是针对对象不一样
④异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步如果发送请求之后不等着对方回应就去做其他事情就是异步。
⑤阻塞和非阻塞针对被调用者，被调用者收到请求之后，昨晚请求任务之后才给出反馈就是阻塞，收到请求之后马上给出反馈然后再去做事情就是非阻塞。
（4）Webflux特点
①非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程
②函数式编程：在Spring5框架基于Java6，Webflux使用Java8函数式编程实现路由请求。
（5）比较SpringMVC
①里昂个框架都可以使用注解方式，都运行在Tomcat等容器中
②SpringMVC采用命令式编程，Webflux采用异步响应式编程
2、响应式编程
（1）什么是响应式编程
响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。
（2）Java8及其之前版本
①提供的观测者模式两个类Observer和Observable
public class ObserverDemo extends Observable {
public static void main(String[] args) {
ObserverDemo observerDemo = new ObserverDemo();
//添加观察者
observerDemo.addObserver((o,arg)->{
System.out.println("发生变化");
});
observerDemo.addObserver((o,arg)->{
System.out.println("手动被观察者通知，准备改变");
});
observerDemo.setChanged();//数据变化
observerDemo.notifyObservers();//通知
}
}3、响应式编程（Reactor实现）
（1）响应式编程操作中，满足Reactive规范框架
（2）Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，提供丰富操作符。Flux对象实现发布者，返回N个元素；Mono实现翻发布者，返回0或者1个元素。
（3）Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：
元素值，错误信号，完成信号，错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者
（4）代码演示
导入依赖
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-core</artifactId>
<version>3.1.5.RELEASE</version>
</dependency>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);
}
}（5）三种信号特点
①错误信号和完成信号都是终止信号，不能共存
②如果没有发送任何元素值，二十直接发送错误或者完成信号，表示空数据流
③如果没有错误信号，没有完成信号，表示是无线数据流
（6）调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生
ublic class TestReactor {
public static void main(String[] args) {
//just方法直接声明
Flux.just(1,2,3,4).subscribe(System.out::print);
Mono.just(1).subscribe(System.out::print);
}
}（7）操作符
①对数据流进行一道道操作，称为操作符，比如工厂流水
②map元素映射为新元素
③flatMap元素映射为流
把每个元素转换流，把转换之后多个流合并大的流
4、SpringWebflux执行流程和核心API
SpringWebflux基于Reactor，默认容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架
（1）Netty
①BIO
②NIO
（2）SpringWebflux执行过程和SpringMVC相似
①SpringWebflux核心控制器DispatchHandler,实现接口WebHandler
②接口WebHandler有一个方法
public interface WebHandler {
Mono<Void> handle(ServerWebExchange exchange);
}
（3）SpringWebflux里面DispatcherHandler，负责请求的处理
①HandlerMapping：请求查询到处理的方法
②HandlerAdapter：真正负责请求处理
③HandlerResultHandler：响应结果出来
（4）SpringWebflux实现函数式编程，连个接口：RouterFunction（路由处理）和HandlerFunction（处理函数）
5、SpringWebflux（基于注解编程模型）
SpringWebFlux实现方式有两种：注解编程模型和函数式编程模型
使用注解编程模型方式，和之前SpringMVC使用相似的，只需要把相关依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器
（1）创建SpringBoot工程，引入Webflux依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-webflux</artifactId>
<version>2.5.7</version>
</dependency>（4）配置启动端口号
（3）创建包和相关类
//实体类
public class User {
private String name;
private String gender;
private Integer age;
public User(String name, String gender, Integer age) {
this.name = name;
this.gender = gender;
this.age = age;
}
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;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}（4）创建接口定义操作的方法
//用户操作接口
public interface UserService {
//根据id查询用户
Mono<User> getUserById(int id);
//查询所有用户
Flux<User> getAllUser();
//添加用户
Mono<Void> saveUserInfo(Mono<User> user);
}（5）接口实现类
public class UserServiceImpl implements UserService {
//创建map集合存储数据
private final Map<Integer,User> users = new HashMap<>();
public UserServiceImpl(){
this.users.put(1,new User("lucy","nan",20));
this.users.put(2,new User("mary", "nv", 30));
this.users.put(3,new User("jack", "nv", 50));
}
//根据id查询
@Override
public Mono<User> getUserById(int id) {
return Mono.justOrEmpty(this.users.get(id));
}
//查询多个用户
@Override
public Flux<User> getAllUser() {
return Flux.fromIterable(this.users.values());
}
//添加用户
@Override
public Mono<Void> saveUserInfo(Mono<User> userMono) {
return userMono.doOnNext(person ->{
//向map集合里面放值
int id = users.size()+1;
users.put(id,person);
}).thenEmpty(Mono.empty());
}
}（6）创建controller
@RestController
public class UserController {
//注入service
@Autowired
private UserService userService;
//id查询
@GetMapping("/user/{id}")
public Mono<User> geetUserId(@PathVariable int id){
return userService.getUserById(id);
}
//查询所有
@GetMapping("/user")
public Flux<User> getUsers(){
return userService.getAllUser();
}
//添加
@PostMapping("/saveuser")
public Mono<Void> saveUser(@RequestBody User user){
Mono<User> userMono =Mono.just(user);
return userService.saveUserInfo(userMono);
}
}（7）网页上测试
http://localhost:8081/user
http://localhost:8081/user/1
http://localhost:8081/user/2
http://localhost:8081/user/3（8）说明
SpringMVC方式实现，同步阻塞的方法，基于SpringMVC+Servlet+Tomcat
SpringWebflux方式实现，异步还诸塞方法，基于SpringWebflux+Reactor+Netty
6、SpringWebFlux（基础函数式编程模型）
（1）在使用函数式编程模型操作时候，需要自己初始化服务器
（2）基于函数式编程模型时候，有两个核心接口：RouterFunction（实现路由功能，请求转发给对应的handler）和HandlerFunction（处理请求生成想要的函数）。核心任务做定义两个函数式节后的实现并启动需要的服务器。
（3）SpringWebflux请求和相应不再是ServletRequest和ServletResponse，而是ServerRequerst
和ServerResponse
①把注解编程模型工程复制一份
②创建Handler（具体实现方法）
public class UserHandler {
public final UserService userService;
public UserHandler(UserService userService){
this.userService =userService;
}
//根据id查询
public Mono<ServerResponse> getUserById(ServerRequest request){
//获取id值
int userId = Integer.valueOf(request.pathVariable("id"));
//空值处理
Mono<ServerResponse> notFound =ServerResponse.notFound().build();
//调用service方法得到数据
Mono<User> userMono =this.userService.getUserById(userId);
//把userMono进行转换返回
//使用Reactor操作符flatMap
return
userMono.
flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
.body(fromObject(person)))
.switchIfEmpty(notFound);
}
//查询所有
public Mono<ServerResponse> getAllUsers(){
//调用service得到结果
Flux<User> users =this.userService.getAllUser();
return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users, User.class)
}
//添加
public Mono<ServerResponse> savaUser(ServerRequest request){
//得到User对象
Mono<User> userMono = request.bodyToMono(User.class);
return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
}
}③初始化服务器，编写Router
④创建路由的方法
public class Server {
// 1、创建Router路由
public RouterFunction<ServerResponse> routerFunction(){
//创建handler对象
UserService userService = new UserServiceImpl();
UserHandler handler = new UserHandler(userService);
//设置路由
return RouterFunctions.route(
GET("/users/{id}").and(accept(APPLICATION_JSON)),handler::getUserById)
.andRoute(GET("/user").and(accept(APPLICATION_JSON)),handler::getAllUsers);
}
}⑤创建服务器完成适配
// 2、创建服务器完成适配
public void creatReactorServer(){
//路由和handler适配
RouterFunction<ServerResponse> route = routerFunction();
HttpHandler httpHandler = toHttpHandler(route);
ReactorHttpHandlerAdapter adapter= new ReactorHttpHandlerAdapter(httpHandler);
//创建服务器
HttpServer httpServer = HttpServer.create();
httpServer.handle(adapter).bindNow();
}⑥最终调用
public static void main(String[] args) throws IOException {
Server server = new Server();
server.creatReactorServer();
System.out.println("enter to exit");
System.in.read();
}⑦最终测试
(4)使用WebClient调用
public class Client {
public static void main(String[] args) {
//调用服务器地址
WebClient webClient = WebClient.create("http://127.0.0.1:52600");
//根据id查询
String id ="1";
User usersult1 = webClient.get().uri("/user/{id}",id)
.accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class)
.block();
System.out.println(usersult1.getName());
//查询所有
Flux<User> results = webClient.get().uri("/user")
.accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
results.map(stu ->stu.getName()).buffer().doOnNext(System.out::println).blockFirst();
}
}
课堂总结
一、Spring框架概述
1、轻量级开源JavaEE框架，为了解决企业复杂性，两个核心组成：IOC和AOP 2、Spring5.2.6版本
二、IOC容器
1、IOC底层原理（工厂、反射等）
2、IOC接口（BeanFactory）
3、IOC操作Bean管理（基于xml）
4、IOC操作Bean管理（基于注解）
三、AOP
1、AOP底层原理：动态代理，有接口（JDK动态代理），没有接口（CGLB动态代理） 2、术语：切入点、增强（通知）、切面 3、基于Aspect J实现AOP操作
四、JdbcTemplate
1、使用JdbcTemplate实现数据库curd操作 2、使用JdbcTemplate实现数据库批量操作
五、事务管理
1、事物概念 2、重要概念（传播行为和隔离级别）
六、Spring5新特性
1、整合日志框架 2、@Nullable注解 3、函数式注册对象 4、增和JUnit5单元测试框架 5、SpringWebflux使用
快速跳转
一、Spring入门了解和安装
二、Spring——IOC容器
三、Spring——AOP
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
