Shulou(Shulou.com)06/03 Report--

This article mainly introduces the example analysis of webflux custom netty parameters in spring, which is very detailed and has certain reference value. Friends who are interested must read it!

Customize webflux container configuration

Configuration code

@ Componentpublic class ContainerConfig extends ReactiveWebServerFactoryCustomizer {public ContainerConfig (ServerProperties serverProperties) {super (serverProperties);} @ Override public void customize (ConfigurableReactiveWebServerFactory factory) {super.customize (factory); NettyReactiveWebServerFactory nettyFactory = (NettyReactiveWebServerFactory) factory; nettyFactory.setResourceFactory (null) NettyFactory.addServerCustomizers (server-> server.tcpConfiguration (tcpServer-> tcpServer.runOn (LoopResources.create ("mfilesvc", Runtime.getRuntime (). AvailableProcessors () * 4, Runtime.getRuntime (). AvailableProcessors () * 8, true)) .selectorOption (CONNECT_TIMEOUT_MILLIS, 200)) .channelGroup (new ChannelGroup () } @ Override public int getOrder () {return-10;}}

An error was reported during service restart

SpringContextShutdownHook Socket couldn't be stopped within 3000ms

Solution

First acquaintance of Spring WebFlux

In my knowledge, most people use SpringMVC (including myself). In the recent study, I found that there is a thing equal to SpringMVC in spring5, Spring WebFlux, and then have a preliminary understanding of what this is?

New changes in Spring Web

It is well known that Spring MVC is a synchronous blocking IO model. When we are dealing with a time-consuming task, such as uploading a file, the processing thread of the server will always be in a waiting state, waiting for the file to be uploaded. During this period, there is nothing we can do. After the file is uploaded, it may need to be written, and the thread of the writing process can only wait there, which is a waste of resources. In order to avoid the waste of this kind of resources, Spring WebFlux arises at the historic moment. In Spring WebFlux, if the file has not been uploaded, the thread can do other things first. When the file is uploaded, the thread will be notified, and then the thread will deal with it. The subsequent writing is also similar. The asynchronous non-blocking mechanism saves system resources and greatly improves the concurrency of the system. Are these two forms very much like BIO and NIO? in fact, SpringMVC and Spring WebFlux are the embodiment of these two kinds of IO characteristics.

The following is an introduction to the official website:

The characteristics of Spring WebFlux 1. Asynchronous non-blocking

As mentioned above, threads do not need to wait all the time, and Spring WebFlux is a good embodiment of NIO's idea of asynchronous non-blocking.

two。 Responsive (reactive) programming

Responsive programming is a new programming style, which is characterized by asynchronous and concurrent, event-driven, push PUSH mechanism-level observer pattern. Reactive references allow developers to build event-driven, scalable, flexible response systems: provide highly sensitive real-time user experience, scalable and flexible reference stack support, ready to deploy in multi-core and cloud computing architectures.

The main interfaces of Reactive:

Publisher: publisher, production side of data

Subscriber: consumer, where you can define the action to respond after getting the data

Processor: data processing between consumers and publishers

Back pressure: back pressure, where consumers tell publishers how much data they can handle

Callback method for consumers:

OnSubscribe: subscription relationship processing, which is used to respond to publishers

OnNext: the method that responds when data is received

OnError: how to handle errors when they occur

OnComplete: the method to respond after a task is completed

3. Adapt to multiple web containers

Since Spring WebFlux well embodies the asynchronous non-blocking idea of NIO. As the leading NIO framework, netty is the default running container for Spring WebFlux. In addition, familiar Servlet containers such as Tomcat and Jetty can also run Spring WebFlux, as long as the container supports Servlet3.1, because non-blocking IO uses the features of Servlet3.1.

Simple practice of Spring WebFlux

The default development environment for this article is JDK8, and the development tool is IDEA. The practice is divided into two parts: the first part compares the differences in development with SpringMVC; the second part is the simple practice of responsive programming unique to Spring WebFlux.

In webflux, Mono represents a return of 0 or 1 element (equivalent to an object). The Flux representative returns 0murn elements (equivalent to a collection)

1. Project creation

Create a new springboot project.

Select Web-> Spring Reactive Web to create

Or add dependencies to the pom file in the springboot project

Comparison between org.springframework.boot spring-boot-starter-webflux2.Controller and SpringMVC

In controller, webflux can be written in a similar way to springMVC

@ RestController@Slf4jpublic class UserController {@ RequestMapping ("/ index") public String index () {log.info ("springmvc index begin"); String result= "cc666"; log.info ("springmvc index end"); return result;} @ RequestMapping ("/ index2") public Mono index2 () {log.info ("webflux index begin"); Mono result=Mono.just ("666cc") Log.info ("webflux index end"); return result;} 3. The embodiment of asynchronous non-blocking

The preliminary data return has been implemented above, but for now there is no difference between webflux and springmvc. Springmvc threads are known to block when they execute, and webflux threads are asynchronous and non-blocking. Let's modify the code to add some extra time-consuming operations when getting the data to see if webflux is really asynchronous and non-blocking.

@ RestController@Slf4j@AllArgsConstructorpublic class UserController {/ * simulate time-consuming query operations * / public String createStr () {try {Thread.sleep (3000L);} catch (InterruptedException e) {e.printStackTrace ();} return "cc666cc" } @ RequestMapping ("/ index") public String index () {log.info ("springmvc index begin"); String result=this.createStr (); log.info ("springmvc index end"); return result;} @ RequestMapping ("/ index2") public Mono index2 () {log.info ("webflux index begin"); Mono result=Mono.fromSupplier ()-> this.createStr ()) Log.info ("webflux index end"); return result;}}

Through the log results, it is obvious that although the effect shown on the front-end page is the same, springmvc waits and returns the result, while webflux executes first and returns the result after there is a result. This reflects the asynchronous and non-blocking characteristics of webflux.

Springmvc

2020-08-04 21 c.w.webflux.controller.UserController 28 INFO 57.430 14156-[ctor-http-nio-2] c.w.webflux.controller.UserController: springmvc index begin

2020-08-04 21 c.w.webflux.controller.UserController 2914 00.430 INFO 14156-[ctor-http-nio-2] c.w.webflux.controller.UserController: springmvc index end

Webflux

2020-08-04 21 c.w.webflux.controller.UserController 2914 09.640 INFO 14156-[ctor-http-nio-2] c.w.webflux.controller.UserController: webflux index begin

2020-08-04 21 c.w.webflux.controller.UserController 2914 09.641 INFO 14156-[ctor-http-nio-2] c.w.webflux.controller.UserController: webflux index end

4. Add database support

For database support, webflux uses something like r2dbc.

R2DBC (Reactive Relational Database Connectivity) is an incubator that uses reactive drivers to integrate relational databases. Spring Data R2DBC supports R2DBC using familiar Spring abstractions and repository. Based on this, using relational data access technology on the responsive program stack, it will be very easy to build Spring-driven programs.

Introduce dependencies in pom:

Org.springframework.boot spring-boot-starter-data-r2dbc com.github.jasync-sql jasync-r2dbc-mysql 1.1.3

Add a data source to application.yml:

Compilation of spring: r2dbc: url: r2dbc:mysql://127.0.0.1:3306/study username: xxx password: xxx5.Dao

The writing of Dao is similar to that of springmvc. This article inherits the ReactiveCrudRepository class, which is an implementation class of Repository, which implements simple crud operations and the implementation of model and dao:

@ Table ("user") @ Data@AllArgsConstructor@NoArgsConstructorpublic class User {@ Id private Long id; private String username; private String password;} public interface UserDao extends ReactiveCrudRepository {} 6.Controller

The writing of controller is still similar to that of springmvc, which is in the way of RESTful.

RestController@AllArgsConstructorpublic class UserController {private final UserDao userDao; @ GetMapping ("/ findAll") public Flux findAll () {return userDao.findAll ();} @ PostMapping ("/ save") public Mono save (@ RequestBody User user) {return this.userDao.save (user);} @ DeleteMapping ("/ delete/ {id}") public Mono delete (@ PathVariable Long id) {return this.userDao.deleteById (id) } @ GetMapping ("/ get/ {id}") public Mono get (@ PathVariable Long id) {return this.userDao.findById (id);}} 7. The programming of responsive programming Handler

In use, webflux can be similar to springmvc, but webflux also has its own set of responsive programming. First, it defines handler, which is similar to controller, but only has the code for business processing, in which request (ServerRequest) and response (ServerResponse) simulated by reactive are used. The same simple crud function is implemented:

@ Component@AllArgsConstructorpublic class UserHandler {private final UserDao userDao; public Mono saveUser (ServerRequest request) {Mono mono=request.bodyToMono (User.class); User user = mono.block (); return ServerResponse.ok () .build (this.userDao.save (user). Then ());} public Mono deleteById (ServerRequest request) {Long id=Long.parseLong (request.pathVariable ("id")) Return ServerResponse.ok (). Build (this.userDao.deleteById (id). Then ());} public Mono getByid (ServerRequest request) {Long id=Long.parseLong (request.pathVariable ("id")); Mono mono = this.userDao.findById (id); return ServerResponse.ok (). ContentType (MediaType.APPLICATION_JSON) .body (mono,User.class);} public Mono findAll (ServerRequest request) {Flux all = this.userDao.findAll () Return ServerResponse.ok (). ContentType (MediaType.APPLICATION_JSON) .body (all,User.class);}} 8. The programming of responsive programming Route

We write processing code in handler, but how do we access it through the request address?

Brothers who have studied vue should know that vue defines the correspondence between addresses and pages through routing, and vue is also an embodiment of responsive programming. Webflux is implemented in a similar way, defining rules in Route:

@ Configurationpublic class UserRoute {@ Bean public RouterFunction routeUser (UserHandler userHandler) {return RouterFunctions .route (RequestPredicates.GET ("findAll2") .and (RequestPredicates.accept (MediaType.APPLICATION_JSON)), userHandler::findAll) .and Route (RequestPredicates.GET ("/ get2/ {id}") .and (RequestPredicates.accept (MediaType.APPLICATION_JSON)) UserHandler::getByid) .andRoute (RequestPredicates.DELETE ("/ delete2/ {id}") .and (RequestPredicates.accept (MediaType.APPLICATION_JSON)), userHandler::deleteById) .andRoute (RequestPredicates.POST ("/ save2") .and (RequestPredicates.accept (MediaType.APPLICATION_JSON)), userHandler::saveUser) }} the above is all the contents of the article "sample Analysis of webflux Custom netty parameters in spring". Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.