Introduction to microservice

First understand a concept —— High availability , namely Ensure the high availability of the server , Reduce downtime ; The original single application has only one server , All services ( function ) All on this server , If something happens , The server is down , The whole system shut down . Microservices ensure that multiple services exist on multiple servers , Or multiple servers jointly maintain a service ( colony ), The failure of a service will not affect the whole , The whole system will not be shut down

Implementation of microservices

Each microservice corresponds to a server , A database ; But it is very troublesome and disorganized for different services to call each other directly , So register all modules in a common place , Every request finds a registry , Then it is sent to each server by the registry

Service registration

Implementation of registry (Netfilx)

1. Create a new one springboot Project modules , Add dependency

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

2. Annotate the entry class @EnableEurekaServer, Represents the server side
3. The configuration file

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false # Whether to register in the Registration Center 
    fetch-registry: false # Whether to call other services 
    service-url:
      defaultZone: http://${
    eureka.instance.hostname}:${
    server.port}/eureka/

After success, you can see the following page ：

Implement service registration

1. Create a service , And introduce dependencies

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

2. Add comments to the entry class @EnableEurekaClient, Represents a client , Will find the server side and register
3. To configure

server:
  port: 9001

spring:
  application:
    name: service-user # The name of the service in the registry 

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

After successful registration, you can see the service in the Registration Center ：

Shared services

For example, the response entity class, so that the same class in each service can be placed in a common service , Instead of writing it once in every service , After the shared service is created, it will be used in other services pom The dependency can be introduced into the file

Implement direct calls between services

User

    @GetMapping("get/{id}")
    public ResponseVO getById(@PathVariable Integer id){
    
        return ResponseVO.FORBIDDEN;
    }

Order

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("getUser/{id}")
    public ResponseVO getById(@PathVariable Integer id){
    
        ResponseEntity<ResponseVO> entity =  restTemplate.getForEntity("http://localhost:9001/user/get/1",ResponseVO.class);
        ResponseVO responseVO = entity.getBody();
        return responseVO;
    }

adopt RestTemplate You can call when a service needs data from another service , But this direct call bypasses the registry , This way will ip It's dead , You have to know each other's ip Or domain name can be called , If the deployed address changes, it needs to be changed at the same time , It is not recommended to use

Ribbon

Use Ribbon Implement service calls

spring-cloud-starter-netflix-eureka-client 3.0 Version already built in ribbon, therefore ribbon Also lost version maintenance , Forced addition will result in jar Packet collision , To report a mistake ——No instances available for XXX; If you use the old version, you need to add spring-cloud-netflix-ribbon rely on

1. stay RestTemplate Of Bean Add comment on @LoadBalanced
2. In the use of restTemplate when ,url Parameters do not use the actual domain name and port , Instead, use the name registered in the registry

ResponseEntity<ResponseVO> entity =  restTemplate.getForEntity("http://service-user/user/get/1",ResponseVO.class);

Load balancing

It refers to assigning tasks to multiple operation units for execution

Server side load balancing

utilize nginx Set up servers for clusters , Maintain a service through a cluster , At this time by nginx Load balance requests on the server side

Client load balancing

When a client needs to call other clients , The callee will run under multiple servers , Divide the task into different operation units
Ribbon It is a tool for client load balancing , Use ribbon The request can be assigned to different operation units through the registry
By setting the running environment, you can configure services to multiple ports ：

-D Indicates passing parameters to the virtual machine , Followed by server.port You can run the service to 9003 port

OpenFeign( Declarative call )

ribbon Calling is not the best way , Recommended OpenFeign Make a declarative call

1. Introduce dependencies

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2. Use annotations at the caller's entry @EnableFeignClients, Indicates that this client enables declarative calls
3. Create a new interface for calling a service , Using annotations @FeignClient(),value Is the name of the called service , The method inside uses springMVC Corresponding to the method path of the callee

@FeignClient("service-user")//value The parameter is the name of the callee 
public interface UserService {
    

    @GetMapping("user/get/{id}")// The path of the method being called 
    ResponseVO getById(@PathVariable Integer id);

}

4. Direct injection when using this interface

    @Autowired
    private UserService userService;

    @GetMapping("getUser2/{id}")
    public ResponseVO get2ById(@PathVariable Integer id){
    
        ResponseVO responseVO = userService.getById(id);
        return responseVO;
    }