Calling client in call end serviceImpl

1. Basic concepts

(1) Spring Cloud call interface procedure

Spring Cloud   In terms of interface calls, the following components will be used:

Feign  -----> Hystrix  —> Ribbon  —> Http Client(apache http components   perhaps   Okhttp)   The specific interaction process is shown in the figure below:

•   Interfaced request call when calling the interface modified by @ FeignClient annotation, convert the request into Feign's request instance feign.Request within the framework and submit it to the Feign framework for processing
• Feign  : Transformation request feign is a lightweight framework for HTTP request invocation. It can invoke HTTP requests in the way of Java interface annotation, encapsulating the HTTP invocation process.
• Hystrix: fuse handling mechanism   The call relationship of Feign will be intercepted by the hystrix agent. For each Feign call request, hystrix will package it as HystrixCommand and participate in the flow control and fusing rules of hystrix. If the request determines that the fuse needs to be blown, hystrix will blow directly, throw an exception, or use FallbackFactory to return the fuse Fallback result; If passed, the call request is passed to the Ribbon component.
• Ribbon: service address selection   After the request is delivered to the ribbon, the ribbon will select the appropriate service instance from the list according to the service list maintained by itself and the service quality of the service, such as average response time and Load, combined with specific rules, select the machine, and then deliver the information request of the machine instance to the Http Client, HttpClient client to execute the real Http interface call;
• HttpClient  : The Http client actually executes the Http call. If the service address has been specified according to the request passed by the upper Ribbon, the Http client starts to execute the real Http request

(2) Hystrix concept

Hystrix   It is used by distributed systems to provide delay and fault tolerance functions to ensure that complex distributed systems can still have their elasticity in the face of inevitable failure.

For example, there are many services in the system. When some services are unstable, the user threads using these services will be blocked. If there is no isolation mechanism, the system may hang up at any time, resulting in great risks. Spring cloud uses Hystrix components to provide circuit breaker, resource isolation and self-healing functions. The following figure shows that service B triggered the circuit breaker to prevent cascading failure

  2.feign is used in combination with Hystrix

(1) Add dependency in pom

    <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <!--hystrix Dependency, mainly with  @HystrixCommand -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <!--Service registration-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--Service call-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

(2)   Add a hystrix configuration to the configuration file

#Turn on the fuse mechanism
feign.hystrix.enabled=true
# Set the hystrix timeout, which is 1000ms by default
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=6000

(3) Create the implementation class of fuse in the client package

@Component
public class VodFileDegradeFeignClient implements VodClient {
    @Override
    public R removeVideo(String videoId) {
        return R.error().message("time out");
    }

    @Override
    public R removeVideoList(List videoIdList) {
       return R.error().message("time out");
    }
}

(4) Add annotation

@FeignClient(name = "service-vod", fallback = VodFileDegradeFeignClient.class)

5, Gateway gateway

1. Introduction to API gateway

API   The reason for the emergence of the gateway is the emergence of the microservice architecture. Different microservices generally have different network addresses, and external clients may need to call the interfaces of multiple services to complete a business requirement. If the client is allowed to communicate directly with each microservice, there will be the following problems:

(1) The client will request different microservices many times, which increases the complexity of the client.

(2) There are cross domain requests, which are relatively complex to process in certain scenarios.

(3) Authentication is complex, and each service needs independent authentication.

(4) It is difficult to refactor. With the iteration of the project, it may be necessary to re divide the microservices. For example, you might merge multiple services into one or split a service into multiple. If the client communicates directly with the microservice, the refactoring will be difficult to implement.

(5) Some microservices may use firewalls  /  Browser unfriendly protocol, direct access will be difficult.

These problems can be solved with the help of   API   Gateway solution. API   The gateway is an intermediate layer between the client and the server. All external requests go through the gateway first   API   Gateway layer. That is, API   In terms of implementation, business logic is more considered, while security, performance and monitoring can be entrusted to   API   Gateway, which not only improves business flexibility, but also does not lack security

2.Spring Cloud Gateway

Spring Cloud gateway is a gateway officially developed by spring based on Spring 5.0, Spring Boot2.0, Project Reactor and other technologies. Spring Cloud gateway aims to provide a simple, effective and unified API routing management method for microservice architecture. As a gateway in Spring Cloud ecosystem, Spring Cloud gateway aims to replace Netflix Zuul, which not only provides a unified routing method, It also provides the basic functions of the gateway based on the Filer chain, such as security, monitoring / embedding point, current limiting, etc

  3. Core concepts of spring cloud gateway

The gateway provides API full hosting services and rich API management functions to assist enterprises in managing large-scale APIs to reduce management costs and security risks, including protocol adaptation, protocol forwarding, security policies, anti brushing, traffic, monitoring logs, etc. Generally speaking, the URL or interface information exposed by the gateway is collectively referred to as routing information. If you have developed gateway middleware or used Zuul, you will know that the core of the gateway is Filter and Filter Chain (Filter responsibility chain). Sprig Cloud Gateway also has the concepts of routing and Filter. Here are some important concepts in Spring Cloud Gateway.

(1) Routing. Routing is the most basic part of the gateway. The routing information consists of an ID, a destination URL, a set of assertions and a set of filters. If the asserted route is true, the requested URL and configuration match

(2) Assertions. Assertion function in Java 8. The input type of the assertion function in the Spring Cloud Gateway is ServerWebExchange in the spring 5.0 framework. The assertion function in Spring Cloud Gateway allows developers to define and match any information from http request, such as request header and parameters.

(3) Filter. A standard Spring webFilter. There are two types of filters in Spring cloud gateway: Gateway Filter and Global Filter. The filter will modify the request and response

  As shown in the figure above, the Spring cloud Gateway sends a request. Then, find the route matching the request in the Gateway Handler Mapping and send it to the Gateway web handler. The Handler sends the request to our actual service through the specified filter chain, executes the business logic, and then returns.

4. Use

(1) Introducing dependencies in pom.xml

<dependencies>
    <dependency>
        <groupId>com.atguigu</groupId>
        <artifactId>common_utils</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <!--gson-->
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
    </dependency>
    <!--Service call-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>

(2) Write the application.properties configuration file

# Service port
server.port=8222
# service name
spring.application.name=service-gateway
# nacos service address
spring.cloud.nacos.discovery.server-addr=127.0.0.1:8848
#Using service discovery routing
spring.cloud.gateway.discovery.locator.enabled=true
#Service route name lowercase
#spring.cloud.gateway.discovery.locator.lower-case-service-id=true
#Set routing id
spring.cloud.gateway.routes[0].id=service-acl
#Set the uri of the route
spring.cloud.gateway.routes[0].uri=lb://service-acl
#Set the route assertion. The agent servicerId is the / auth / path of auth service
spring.cloud.gateway.routes[0].predicates= Path=/*/acl/**
#Configure service edu service
spring.cloud.gateway.routes[1].id=service-edu
spring.cloud.gateway.routes[1].uri=lb://service-edu
spring.cloud.gateway.routes[1].predicates= Path=/eduservice/**
#Configuring the service UCenter service
spring.cloud.gateway.routes[2].id=service-ucenter
spring.cloud.gateway.routes[2].uri=lb://service-ucenter
spring.cloud.gateway.routes[2].predicates= Path=/ucenterservice/**
#Configuring the service UCenter service
spring.cloud.gateway.routes[3].id=service-cms
spring.cloud.gateway.routes[3].uri=lb://service-cms
spring.cloud.gateway.routes[3].predicates= Path=/cmsservice/**
spring.cloud.gateway.routes[4].id=service-msm
spring.cloud.gateway.routes[4].uri=lb://service-msm
spring.cloud.gateway.routes[4].predicates= Path=/edumsm/**
spring.cloud.gateway.routes[5].id=service-order
spring.cloud.gateway.routes[5].uri=lb://service-order
spring.cloud.gateway.routes[5].predicates= Path=/orderservice/**
spring.cloud.gateway.routes[6].id=service-order
spring.cloud.gateway.routes[6].uri=lb://service-order
spring.cloud.gateway.routes[6].predicates= Path=/orderservice/**
spring.cloud.gateway.routes[7].id=service-oss
spring.cloud.gateway.routes[7].uri=lb://service-oss
spring.cloud.gateway.routes[7].predicates= Path=/eduoss/**
spring.cloud.gateway.routes[8].id=service-statistic
spring.cloud.gateway.routes[8].uri=lb://service-statistic
spring.cloud.gateway.routes[8].predicates= Path=/staservice/**
spring.cloud.gateway.routes[9].id=service-vod
spring.cloud.gateway.routes[9].uri=lb://service-vod
spring.cloud.gateway.routes[9].predicates= Path=/eduvod/**
spring.cloud.gateway.routes[10].id=service-edu
spring.cloud.gateway.routes[10].uri=lb://service-edu
spring.cloud.gateway.routes[10].predicates= Path=/eduuser/**

yml file

server:
  port: 8222
spring:
  application:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: SERVICE-ACL
        uri: lb://SERVICE-ACL
        predicates:
        - Path=/*/acl/** # Path matching
      - id: SERVICE-EDU
        uri: lb://SERVICE-EDU
        predicates:
        - Path=/eduservice/** # Path matching
      - id: SERVICE-UCENTER
        uri: lb://SERVICE-UCENTER
        predicates:
        - Path=/ucenter/** # Path matching
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

(3) Gateway related configuration

① Gateway solves cross domain problems

@Configuration
public class CorsConfig {
    @Bean
    public CorsWebFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }
}

② Global Filter

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {
    private AntPathMatcher antPathMatcher = new AntPathMatcher();
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String path = request.getURI().getPath();
        //The api interface of grain college, the verification user must log in
        if(antPathMatcher.match("/api/**/auth/**", path)) {
            List<String> tokenList = request.getHeaders().get("token");
            if(null == tokenList) {
                ServerHttpResponse response = exchange.getResponse();
                return out(response);
            } else {
//                Boolean isCheck = JwtUtils.checkToken(tokenList.get(0));
//                if(!isCheck) {
                    ServerHttpResponse response = exchange.getResponse();
                    return out(response);
//                }
            }
        }
        //Internal service interface, external access is not allowed
        if(antPathMatcher.match("/**/inner/**", path)) {
            ServerHttpResponse response = exchange.getResponse();
            return out(response);
        }
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 0;
    }
    private Mono<Void> out(ServerHttpResponse response) {
        JsonObject message = new JsonObject();
        message.addProperty("success", false);
        message.addProperty("code", 28004);
        message.addProperty("data", "Authentication failed");
        byte[] bits = message.toString().getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = response.bufferFactory().wrap(bits);
        //response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //Specify the code, otherwise Chinese garbled code will appear in the browser
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(buffer));
    }
}

6, Introduction to configuration center

Spring Cloud Config   It provides the support scheme of server and client for the external configuration of distributed system. On the configured server side, you can manage the central location of external properties for applications in all environments. Spring Environment in client and server concepts   and   PropertySource   Keep abstractions synchronized,   They are ideal for spring applications, but can be used with applications running in any language. As applications move from development to testing through production in the deployment pipeline, you can manage the configuration between these environments and ensure that applications have everything they need to run when migrating. The default implementation of the server storage back-end uses git, so it can easily support the configuration environment of marked version, and can be accessed by various tools for managing content. It's easy to add alternative implementations and plug them in with spring configuration.

Spring Cloud Config   It includes two parts: client and server. The server provides the storage of configuration files and provides the contents of configuration files in the form of interface. The client obtains data through the interface and initializes its own application according to this data. Spring cloud uses git or svn to store configuration files. Git is used by default.

2. Replace Config with Nacos

Nacos   Can be with   Spring, Spring Boot, Spring Cloud   Integrated and can replace   Spring Cloud Eureka, Spring Cloud Config. adopt   Nacos Server   and   spring-cloud-starter-alibaba-nacos-config   Realize the dynamic change of configuration.

(1) Application scenario

In the process of system development, developers usually separate some parameters and variables that need to be changed from the code for independent management and exist in the form of independent configuration files. The purpose is to make static system artifacts or deliverables (such as   WAR，JAR   Package, etc.) better adapt to the actual physical operating environment. Configuration management is generally included in the process of system deployment and is completed by the system administrator or operation and maintenance personnel. Configuration change is an effective means to adjust the behavior of the system during operation.

If the unified configuration center is not used in the microservice architecture, the following problems exist:

-   The configuration files are scattered in various projects, which is inconvenient to maintain

-   Configure content security and permissions

-   After updating the configuration, the project needs to be restarted

nacos configuration center: centralized management of system configuration (editing, storage and distribution), dynamic update without restart, rollback of configuration (change management, historical version management, change audit) and other configuration related activities.

3. Read the configuration file of the Nacos configuration center

① Create unified profile in Nacos

Click the Create button

  Enter configuration information

 

 

Data ID   The complete rule format is as follows

${prefix}-${spring.profile.active}.${file-extension}

- prefix   spring.application.name is configured for the project by default   The value of (i.e. Nacos provider) can also be configured through the configuration item   spring.cloud.nacos.config.prefix.

-   spring.profiles.active=dev   It is the corresponding to the current environment   profile.   Note: when spring.profiles.active   When null, the corresponding connector  -  Will not exist, dataId   The splicing format of becomes ${prefix}. ${file extension}

- file-exetension   To configure the data format of the content, you can use the configuration item spring.cloud.nacos.config.file-extension   To configure. Currently only supported   properties   and   yaml   Type.

Take the service statistics module as an example

(1) Introduce dependency in service

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

  (2) Create the bootstrap.properties configuration file

#Configuration center address
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
#spring.profiles.active=dev
# This configuration affects the dataId in the unified configuration center
spring.application.name=service-statistics

 

Supplement: loading order of springboot configuration file

In fact, yml and properties files have the same principle, and either yml or properties exist in a project. yml is recommended, which is more concise.

bootstrap and application
(1) Loading order
This mainly describes the loading sequence of application and bootstrap.

bootstrap.yml (bootstrap.properties) is loaded first
Load after application.yml (application.properties)
bootstrap.yml is used for the boot phase of the application context.

bootstrap.yml is loaded by the parent Spring ApplicationContext.

The parent ApplicationContext is loaded before using application.yml.

(2) Configuration difference
Both bootstrap.yml and application.yml can be used to configure parameters.

bootstrap.yml can be understood as some system level parameter configurations, which are generally unchanged.
application.yml can be used to define the application level.

Namespace switching environment

In actual development, there are usually multiple sets of different environments (only public by default). At this time, different environments can be created according to the specified environment   namespce, for example, three different environments: development, test and production, use one set   nacos   The following three different clusters can be built   namespace. In order to achieve multi environment isolation.

Create namespace

 

  By default, there is only public, and the dev, test, and prod namespaces are created

 

 

 

You can find that there are four namespaces: public (default) and three namespaces (prod, dev and test) added by ourselves. You can click to view the configuration file under each namespace. Of course, there is only one configuration under public.

By default, the project will be found in public   Service name. properties file.

Next, also add a nacos-provider.properties configuration in the dev namespace. There are two ways:

First, switch to the dev namespace and add a new configuration file. Disadvantages: similar items need to be configured repeatedly in each environment

Second, add and modify the configuration directly through clone. recommend

 

  Click Edit: modify the configuration content and change the port number to 8013 for differentiation

 

  In the project module, modify bootstrap.properties and add the following configuration

spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.profiles.active=dev
# This configuration affects the dataId in the unified configuration center, which has been configured before
spring.application.name=service-statistics
spring.cloud.nacos.config.namespace=13b5c197-de5b-47e7-9903-ec0538c9db01

  The value of namespace is:

 

Multi profile loading

In some cases, multiple configuration files need to be loaded. Suppose there are three configuration files under the dev namespace: service-statistics.properties, redis.properties and jdbc.properties

 

  Add configuration, load multiple configuration files