SpringCloud シリーズのデモをビルドする

一般エンジニアリングマイクロサービスの親

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelVersion>4.0.0</modelVersion>
	<groupId>com.lzj.springcloud</groupId>
	<artifactId>microservice-parent</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>pom</packaging>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<junit.version>4.12</junit.version>
		<log4j.version>1.2.17</log4j.version>
		<lombok.version>1.16.18</lombok.version>
	</properties>

	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.SR1</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-dependencies</artifactId>
				<version>1.5.9.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
			<dependency>
			    <groupId>mysql</groupId>
			    <artifactId>mysql-connector-java</artifactId>
			    <version>5.1.46</version>
			</dependency>
			<dependency>
			    <groupId>com.alibaba</groupId>
			    <artifactId>druid</artifactId>
			    <version>1.1.0</version>
			</dependency>
			<dependency>
				<groupId>org.mybatis.spring.boot</groupId>
				<artifactId>mybatis-spring-boot-starter</artifactId>
				<version>1.3.0</version>
			</dependency>
			<dependency>
				<groupId>ch.qos.logback</groupId>
				<artifactId>logback-core</artifactId>
				<version>1.2.3</version>
			</dependency>
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>${
    
    junit.version}</version>
				<scope>test</scope>
			</dependency>
			<dependency>
				<groupId>log4j</groupId>
				<artifactId>log4j</artifactId>
				<version>${
    
    log4j.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>
</project>

microservice-com のパブリックモジュール

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<!-- 继承父工程 -->
	<parent>
		<groupId>com.lzj.springcloud</groupId>
		<artifactId>microservice-parent</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<!-- 当前工程的名字 -->
	<artifactId>microservice-com</artifactId>
	<dependencies><!-- 当前Module需要用到的jar包，按自己需求添加，如果父类已经包含了，可以不用写版本号 -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
	</dependencies>
</project>

このモジュールで User Bean を作成します

package com.lzj.springcloud.entity;
public class User {
    
    
	private int id;
	private String name;
	private int age;
	
	public User() {
    
    
		super();
	}

	public User(int id, String name, int age) {
    
    
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public int getId() {
    
    
		return id;
	}

	public void setId(int id) {
    
    
		this.id = id;
	}

	public String getName() {
    
    
		return name;
	}

	public void setName(String name) {
    
    
		this.name = name;
	}

	public int getAge() {
    
    
		return age;
	}

	public void setAge(int age) {
    
    
		this.age = age;
	}

	@Override
	public String toString() {
    
    
		return "User [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
}

マイクロサービスプロバイダーマイクロサービス

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.lzj.springcloud</groupId>
		<artifactId>microservice-parent</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>

	<artifactId>microservice-provider</artifactId>

	<dependencies>
		<dependency>
			<groupId>com.lzj.springcloud</groupId>
			<artifactId>microservice-com</artifactId>
			<version>${
    
    project.version}</version>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
		</dependency>
		<dependency>
			<groupId>ch.qos.logback</groupId>
			<artifactId>logback-core</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jetty</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
		</dependency>
		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>

</project>

pom ファイルに microservice-com 依存関係が導入されました。

		<dependency>
			<groupId>com.lzj.springcloud</groupId>
			<artifactId>microservice-com</artifactId>
			<version>${
    
    project.version}</version>
		</dependency>

アプリケーション.yml

server: 
  port: 8002

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包

spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

src/main/resources ディレクトリに mybatis フォルダーを作成した後、新しい mybatis.cfg.xml を作成します。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

	<!-- 开启二级缓存 -->
	<settings> 
    	<setting name="cacheEnabled" value="true"/>  
	</settings> 

</configuration>

ユーザーテーブルを操作するためのDaoインターフェースを作成する

package com.lzj.springcloud.dao;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import com.lzj.springcloud.entity.User;

@Mapper
public interface UserDao {
    
    

	public boolean addUser(User user);
	
	public User getUser(int id);
	
	public List<User> getUsers();
}

src/main/resources/mybatis ディレクトリにマッパーディレクトリを作成し、マッパーディレクトリに UserMapper.xml ファイルを作成します。

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lzj.springcloud.dao.UserDao">

    <select id="getUser" resultType="User" parameterType="int">
        select * from user where ID=#{
    
    id}
    </select>
    
    <select id="getUsers" resultType="User">
    	select * from user
    </select>
    
    <insert id="addUser" parameterType="User">
    	insert into user(NAME, AGE) values(#{
    
    name}, #{
    
    age})
    </insert>
    
</mapper>

UserService サービスインターフェイス

package com.lzj.springcloud.service;
import java.util.List;
import com.lzj.springcloud.entity.User;
public interface UserService {
    
    
	
	public boolean addUser(User user);
	
	public User getUser(int id);
	
	public List<User> getUsers();
}

UserServiceImpl インターフェースの実装

package com.lzj.springcloud.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.lzj.springcloud.dao.UserDao;
import com.lzj.springcloud.entity.User;
import com.lzj.springcloud.service.UserService;

@Service
public class UserServiceImpl implements UserService {
    
    

	@Autowired
	private UserDao userDao;
	
	@Override
	public boolean addUser(User user) {
    
    
		boolean flag;
		flag = userDao.addUser(user);
		return flag;
	}

	@Override
	public User getUser(int id) {
    
    
		User user = userDao.getUser(id);
		return user;
	}

	@Override
	public List<User> getUsers() {
    
    
		List<User> users = userDao.getUsers();
		return users;
	}

}

コントローラー層、対応する REST リクエストに使用されます

package com.lzj.springcloud.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.lzj.springcloud.entity.User;
import com.lzj.springcloud.service.UserService;

@RestController
public class UserController {
    
    

	@Autowired
	private UserService service;
	
	@RequestMapping(value="/add", method=RequestMethod.POST)
	public boolean addUser(@RequestBody User user){
    
    
		boolean flag = service.addUser(user);
		return flag;
	}
	
	@RequestMapping(value="/get/{id}", method=RequestMethod.GET)
	public User getUser(@PathVariable("id") int id){
    
    
		User user = service.getUser(id);
		return user;
	}
	
	@RequestMapping(value="/getUser/list", method=RequestMethod.GET)
	public List<User> getUsers(){
    
    
		List<User> users = service.getUsers();
		return users;
	}
}

マイクロサービスプロバイダーのスタートアップクラス

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProviderApplication {
    
    

	public static void main(String[] args) {
    
    

		SpringApplication.run(ProviderApplication.class, args);
	}

}

マイクロサービスプロバイダーのマイクロサービスをテストする

http://localhost:8002/getUser/list

マイクロサービス-コンシューママイクロサービス

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.lzj.springcloud</groupId>
    <artifactId>microservice-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>microservice-consumer</artifactId>
  
	<dependencies>
		<!-- 依赖microservice-com模块 -->
		<dependency>
			<groupId>com.lzj.springcloud</groupId>
			<artifactId>microservice-com</artifactId>
			<version>${
    
    project.version}</version>
		</dependency>
				<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>
</project>

アプリケーション.yml

server: 
  port: 8003

RestTemplate Bean の設定
RestTemplate は、REST を送信するクライアント要求をシミュレートするために使用されます。

package com.lzj.springcloud.configbean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {
    
    
	
	@Bean
	public RestTemplate getRestTemplate(){
    
    
		return new RestTemplate();
	}
}

コントローラ層

package com.lzj.springcloud.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import com.lzj.springcloud.entity.User;

@RestController
public class UserConsumerController {
    
    
	private static String REST_URL_PREFIX = "http://localhost:8002";
	
	@Autowired
	private RestTemplate restTemplate;
	
	@RequestMapping(value="/consumer/add")
	public boolean addUser(User user){
    
    
		Boolean flag = restTemplate.postForObject(REST_URL_PREFIX + "/add", user, Boolean.class);
		return flag;
	}
	
	@RequestMapping(value="/consumer/get/{id}")
	public User get(@PathVariable("id") int id){
    
    
		User user = restTemplate.getForObject(REST_URL_PREFIX + "/get/" + id, User.class);
		return user;
	}
	
	@SuppressWarnings({
    
     "unchecked", "rawtypes" })
	@RequestMapping(value="/consumer/list")
	public List<User> getList(){
    
    
		List list = restTemplate.getForObject(REST_URL_PREFIX + "/getUser/list", List.class);
		return list;
	}
}

スタートアップクラス

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(ConsumerApplication.class, args);
	}

}

テスト

http://localhost:8003/consumer/add?name=lzj5&age=35

microservice-eurake1 microservice
eureka microservice は、サービスの登録と検出に使用されます。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>com.lzj.springcloud</groupId>
		<artifactId>microservice-parent</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	
	<artifactId>microservice-eurake1</artifactId>
  
	<dependencies>
		<!--eureka-server服务端 -->
		<dependency>
    		<groupId>org.springframework.cloud</groupId>
    		<artifactId>spring-cloud-netflix-eureka-server</artifactId>
		</dependency>
		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>
  
</project>

アプリケーション.yml

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${
    
    eureka.instance.hostname}:${
    
    server.port}/eureka/
      
server:
  port: 9001

eureka サーバーをアクティブ化するために使用されるクラス @EnableEurekaServer アノテーションを開始します。

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(EurekaApplication.class, args);
	}

}

eureka マイクロサービスが正しく作成されたら、サービスを登録する必要があります。

サービスを登録し
、microservice-provider マイクロサービスの pom ファイルに次の依存関係を追加します。

		<!-- 将微服务microservice-provider侧注册进eureka -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>

microservice-provider マイクロサービスの application.yml ファイルに次の構成を追加することは、
http://localhost:9001/eureka で示されるサービス、つまり microservice-eureka マイクロサービスに microservice-provider マイクロサービスを登録することを意味します。

application.ymlを変更する

server: 
  port: 8002

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包


spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

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

@EnableEurekaClient アノテーションを microservice-provider マイクロサービスのスタートアップクラスに追加します。microservice-provider マイクロサービスの開始時に eureka クライアントが開始され、クライアントが microservice-provider サービスを microservice-eureka1 に自動的に登録することを示します。

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient  //本服务启动后会自动注册进eureka服务中
public class ProviderApplication {
    
    

	public static void main(String[] args) {
    
    

		SpringApplication.run(ProviderApplication.class, args);
	}

}

テストを開始するだけです

eureka:
  client:
    service-url:
      defaultZone: http://localhost:9001/eureka
  instance:
    instance-id: microservicecloud-provider8002               #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址

ここに画像の説明を挿入します

デフォルトでは、EurekaServer が一定時間内にマイクロサービスインスタンスのハートビートを受信しない場合、EurekaServer はインスタンスからログオフします (デフォルトでは 90 秒)。ただし、ネットワークパーティションの障害が発生すると、マイクロサービスと EurekaServer は正常に通信できなくなり、上記の動作は非常に危険になる可能性があります。これは、マイクロサービス自体は実際には正常であり、現時点ではマイクロサービスをログアウトすべきではないためです。Eureka は、「自己保護モード」によってこの問題を解決します。EurekaServer ノードが短期間に多くのクライアントを失うと (ネットワーク分割障害が発生する可能性があります)、このノードは自己保護モードに入ります。このモードになると、EurekaServer はサービスレジストリ内の情報を保護し、サービスレジストリ内のデータを削除しなくなります (つまり、マイクロサービスをログアウトしません)。ネットワーク障害が復旧すると、Eureka Server ノードは自動的に自己保護モードを終了します。

自己保護モードでは、Eureka Server はサービスレジストリ内の情報を保護し、サービスインスタンスをログアウトしなくなります。受信するハートビートの数がしきい値を超えると、Eureka Server ノードは自動的に自己保護モードを終了します。その設計哲学は、潜在的に健全なサービスインスタンスを盲目的にログアウトするのではなく、誤ったサービス登録情報を保持することです。

要約すると、自己保護モードはネットワークの異常に対処するためのセキュリティ保護手段です。そのアーキテクチャ哲学は、健全なマイクロサービスを盲目的にログオフするのではなく、すべてのマイクロサービスを同時に保持する (健全なマイクロサービスと不健全なマイクロサービスの両方が保持される) ことです。自己保護モードを使用すると、Eureka クラスターをより堅牢で安定させることができます。

Spring Cloud では、eureka.server.enable-self-preservation = false を使用して自己保存モードを無効にできます。

エウレカクラスターの作成

eureka マイクロサービスが確立されています。このマイクロサービスがダウンすると、他のマイクロサービスの登録や検出ができなくなり、システム全体がダウンしてしまいます。そのため、以下に複数の eureka マイクロサービスを作成し、eureka クラスターを構成します。登録が必要です。マイクロサービスはすべての eureka マイクロサービス、つまりクラスター全体に登録する必要があります。1 つの eureka マイクロサービスがハングアップしても、他の eureka マイクロサービスは引き続き動作できます。
まずホストファイルを変更し、127.0.0.1 の複数のドメイン名マッピングを追加して、その後の複数のアドレスに基づく登録サービスのシミュレーションを容易にします。
microservice-eurake1 プロジェクトを microservice-eurake2 と microservice-eurake3 にそれぞれコピーし、
microservice-eurake2 サービスの pom ファイルの artifactId を microservice-eurake2 に変更します (マイクロサービスは以前にコピーされているため、作成された場合は変更されません)変更する必要があります) microservice-eurake2
microservice-eurake3 サービスの pom ファイル内の artifactId を microservice-eurake3 に変更します。

microservice-eureka1 の application.yml ファイルを次のように変更します。

 eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      #defaultZone: http://${
    
    eureka.instance.hostname}:${
    
    server.port}/eureka/        #设置与Eureka Server交互的地址查询服务和注册服务都需要依赖这个地址。
      defaultZone: http://eureka9003.com:9003/eureka/,http://eureka9002.com:9002/eureka/
server:
  port: 9001

microservice-eureka2 の application.yml ファイルを次のように変更します。

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      #defaultZone: http://${
    
    eureka.instance.hostname}:${
    
    server.port}/eureka/
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9003.com:9003/eureka/
server:
  port: 9002

microservice-eureka3 の application.yml ファイルを次のように変更します。

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      #defaultZone: http://${
    
    eureka.instance.hostname}:${
    
    server.port}/eureka/
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9002.com:9002/eureka/
      
server:
  port: 9003

microservice-provider マイクロサービス application.yml の defaultZone 構成を変更し、マイクロサービスを 3 つの eureka マイクロサービス (eureka クラスター) に同時に登録します。

server: 
  port: 8002

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包


spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

eureka:
  client:
    service-url:
      #defaultZone: http://localhost:9001/eureka
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9003.com:9003/eureka/
  instance:
    instance-id: microservicecloud-provider8002               #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
info: 
  app.name: microservicecloud-provider
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

リボンの負荷分散

リボンの負荷分散は、クライアント、つまり呼び出し側に適用されます。この場合は、マイクロサービス - コンシューマーマイクロサービスに適用されます。次に、負荷分散は、マイクロサービス - コンシューマーマイクロサービスに使用されます。
1. マイクロサービスコンシューマーによるリボンの構成
次に、マイクロサービスコンシューマーマイクロサービスの構成 pom ファイルを変更して、
リボンに必要な依存関係を追加します。

		<!-- Ribbon相关 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-ribbon</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>

application.ymlファイルを修正し、eurekaのサービス登録機能を追加する変更後の構成は以下の通り

server: 
  port: 8003

eureka:
  client:
    register-with-eureka: false
    service-url: 
      defaultZone: http://eureka9003.com:9003/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9001.com:9001/eureka/

@LoadBalanced

負荷分散では、実際には、RestTemplate と分散アルゴリズムに基づいて、異なるアドレスで同じマイクロサービスのデプロイをスケジュールします。したがって、ConfigBean を変更し、RestTemplate に @LoadBalanced アノテーションを追加します。

@Configuration
public class ConfigBean {
    
    
	
	@Bean
	@LoadBalanced
	public RestTemplate getRestTemplate(){
    
    
		return new RestTemplate();
	}
}

microservice-consumer を eureka サービスに登録するには、スタートアップクラスに @EnableEurekaClient アノテーションを追加する必要があります。

@SpringBootApplication
@EnableEurekaClient
public class ConsumerApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(ConsumerApplication.class, args);
	}

}

他のマイクロサービスのアプリケーションがアドレスとポートによって呼び出されなくなり、アプリケーションがマイクロサービスの名前に基づいて呼び出されるようにコントローラー層を変更します。次のように修正されました

@RestController
public class UserConsumerController {
    
    
//	private static String REST_URL_PREFIX = "http://localhost:8002";
	/*直接根据微服务名调用，而不再是根据地址和端口了，运用了eureka的发现功能*/
	private static String REST_URL_PREFIX = "http://microservicecloud-provider";
	
	@Autowired
	private RestTemplate restTemplate;
	
	@RequestMapping(value="/consumer/add")
	public boolean addUser(User user){
    
    
		Boolean flag = restTemplate.postForObject(REST_URL_PREFIX + "/add", user, Boolean.class);
		return flag;
	}
	
	@RequestMapping(value="/consumer/get/{id}")
	public User get(@PathVariable("id") int id){
    
    
		User user = restTemplate.getForObject(REST_URL_PREFIX + "/get/" + id, User.class);
		return user;
	}
	
	@SuppressWarnings({
    
     "unchecked", "rawtypes" })
	@RequestMapping(value="/consumer/list")
	public List<User> getList(){
    
    
		List list = restTemplate.getForObject(REST_URL_PREFIX + "/getUser/list", List.class);
		return list;
	}
}

リボンの負荷分散
リボンは上記のコンシューマーマイクロサービスで構成されており、現在プロバイダーマイクロサービスは 1 つだけです。プロバイダーマイクロサービスへの負担を軽減するために、さらに 2 つのプロバイダーマイクロサービスがデプロイされ、クライアントがリクエストを送信すると、3 つのマイクロサービスのうち 1 つがランダムにリクエストに応答します。
マイクロサービスプロバイダープロジェクトをコピーして、マイクロサービスプロバイダー 2 とマイクロサービスプロバイダー 3 を生成します。マイクロサービス
プロバイダー 2 のスタートアップクラスを ProviderApplication2 に変更します。
マイクロサービスプロバイダー 3 のスタートアップクラスを ProviderApplication3 に変更します。マイクロサービス
プロバイダー 2 の application.yml 構成を次のように変更します。

server: 
  port: 8003

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包


spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

eureka:
  client:
    service-url:
      #defaultZone: http://localhost:9001/eureka
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9003.com:9003/eureka/
  instance:
    instance-id: microservicecloud-provider8003               #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
info: 
  app.name: microservicecloud-provider
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

microservice-provider3 の構成を次のように変更します。

server: 
  port: 8004

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包


spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

eureka:
  client:
    service-url:
      #defaultZone: http://localhost:9001/eureka
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9003.com:9003/eureka/
  instance:
    instance-id: microservicecloud-provider8004               #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
info: 
  app.name: microservicecloud-provider
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

どのプロバイダーマイクロサービスがクライアントの要求に応答するかを簡単に観察するために、プロバイダーマイクロサービスで 2 つのログがそれぞれ出力されます。
マイクロサービスプロバイダーマイクロサービスの UserServiceImpl クラスの getUser メソッドは次のように変更されます。

	@Override
	public User getUser(int id) {
    
    
		User user = userDao.getUser(id);
		System.out.println("microservice-provider微服务在响应客户端请求……");
		System.out.println("user : " + user);
		return user;
	}

他の提供者サービスについても同様です

テスト

負荷分散を装う

Feign は宣言型 WebService クライアントです。Feign を使用すると、Web サービスクライアントの作成が容易になります。Feign は、Ribbon のラッパーであり、Feign は、Ribbon を統合します。
以前にRibbon+RestTemplateを使用したときは、RestTemplateを使用してhttpリクエストをカプセル化し、テンプレート化された呼び出しメソッドのセットを形成しました。ただし、実際の開発では、サービスの依存関係への呼び出しが複数ある可能性があるため、インターフェイスが複数の場所から呼び出されることがよくあります。そのため、通常は、これらの依存サービスの呼び出しをラップするために、いくつかのクライアントクラスがマイクロサービスごとにカプセル化されます。したがって、Feign はこれに基づいてそれをさらにカプセル化し、依存するサービスインターフェイスの定義と実装を支援します。Feign の実装では、インターフェイスを作成し、アノテーションを使用してサービスプロバイダーへのインターフェイスバインディングを完了するように構成するだけで済みます。これにより、Spring クラウドリボンを使用するときにサービス呼び出しクライアントを自動的にカプセル化する開発が簡素化されます。
Feign は、Ribbon 用のパッケージであるため、クライアント側、つまりコンシューマー側でも使用されます。次に、Feign を統合するコンシューマエンドを作成します。microservice
-consumer プロジェクトを microservice-consumer-feign にコピーし
、microservice-consumer-feign スタートアップクラスの名前を FeignConsumerApplication に変更します。feign へ
の依存関係を microservice-consumer-feign の pom ファイルに追加します。消費者偽装:

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

ConsumerService インターフェイスを作成して、microservicecloud-provider マイクロサービスをラップします。今後、microservicecloud-provider サービスのメソッドを呼び出すには、インターフェイス内の対応するメソッドを呼び出すだけです。

package com.lzj.springcloud.service;
import java.util.List;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.lzj.springcloud.entity.User;

/*以后调用microservicecloud-provider微服务中的方法，只需要调用下面对应的接口既可以了*/
@FeignClient(value="microservicecloud-provider")
public interface ConsumerService {
    
    

	/*调用接口中的get方法，即可以向microservicecloud-provider微服务发送/get/{id}请求*/
	@RequestMapping(value="/get/{id}", method=RequestMethod.GET)
	public User get(@PathVariable("id") int id);
	
	@RequestMapping(value="/add", method=RequestMethod.POST)
	public boolean add(User user);
	
	@RequestMapping(value="/getUser/list", method=RequestMethod.GET)
	public List<User> getAll();
}

microservice-consumer-feign のコントローラー層を次のように変更します。

package com.lzj.springcloud.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.lzj.springcloud.entity.User;
import com.lzj.springcloud.service.ConsumerService;

@RestController
public class UserConsumerController {
    
    
//	private static String REST_URL_PREFIX = "http://localhost:8002";
	/*直接根据微服务名调用，而不再是根据地址和端口了，运用了eureka的发现功能*/
//	private static String REST_URL_PREFIX = "http://microservicecloud-provider";
//	@Autowired
//	private RestTemplate restTemplate;
	
	@Autowired
	private ConsumerService service;
	
	@RequestMapping(value="/consumer/add")
	public boolean addUser(User user){
    
    
		Boolean flag = service.add(user);
		return flag;
	}
	
	@RequestMapping(value="/consumer/get/{id}")
	public User get(@PathVariable("id") int id){
    
    
		User user = service.get(id);
		return user;
	}
	
	@SuppressWarnings({
    
     "unchecked", "rawtypes" })
	@RequestMapping(value="/consumer/list")
	public List<User> getList(){
    
    
		List list = service.getAll();
		return list;
	}
}

スタートアップクラス FeignConsumerApplication を変更し、アノテーションを追加してスタートアップクラスで Feign を有効にします。

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages="com.lzj.springcloud.service")
public class FeignConsumerApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(FeignConsumerApplication.class, args);
	}

}

テスト

ハイストリックスサーキットブレーカー

リクエストで複数のサービスを呼び出す必要があり、そのうちの 1 つのサービスが失敗したり失敗したりすると、大量のリクエストが発生し、リクエストの遅延とリソースの無駄が発生します。Hystrix は、分散システムの遅延とフォールトトレランスに対処するために使用されるオープンソースライブラリです。分散システムでは、タイムアウトや例外など、多くの依存関係が必然的に呼び出しに失敗します。Hystrix は、依存関係の場合にそれを保証できます。この問題は、サービス全体の障害を引き起こさず、連鎖的な障害を回避して分散システムの回復力を向上させます。
サービスユニットに障害が発生した場合、サーキットブレーカーの障害監視を通じて、長時間待機したり呼び出し元が処理できない例外をスローしたりする代わりに、予期される処理可能な代替応答 (FallBack) を呼び出し元に返します。サービス呼び出し元のスレッドが長時間不必要に占有されることがないため、分散システム内での障害の拡大、さらには雪崩の発生も回避されます。
Hystrix は、サービスサーキットブレーカー、サービス低下、サービス電流制限、その他の機能に使用できます。

1. サービスサーキットブレーカー:
サービスが異常な場合、サービスはサーキットブレーカーとなり、指定されたエラーメッセージを迅速に返します。サービスが正常であれば、サーキットブレーカーは復旧します。
microservice-provider プロジェクトを microservice-provider-hystrix にコピーし、
microservice-provider-hystrix のスタートアップクラスを HystrixProviderApplication に変更し、
hystrix の依存関係を pom ファイルに追加します。

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

アプリケーション.yml

server: 
  port: 8005

mybatis: 
  config-location: "classpath:mybatis/mybatis.cfg.xml"        # mybatis配置文件所在路径
  mapper-locations: 
    - "classpath:mybatis/mapper/**/*.xml"                     # mapper映射文件
  type-aliases-package: com.lzj.springcloud.entity            # 别名类所在包


spring: 
  application: 
    name: microservicecloud-provider                          #微服务的名字
  datasource: 
    driver-class-name: org.gjt.mm.mysql.Driver                # mysql驱动包      
    type: com.alibaba.druid.pool.DruidDataSource              # 当前数据源操作类型
    url: "jdbc:mysql://localhost:3306/lzj"                    # 数据库名称
    username: root
    password: lzjlzj
    dbcp2: 
      initial-size: 5                                         # 初始化连接数
      max-total: 5                                            # 最大连接数
      max-wait-millis: 200                                    # 等待连接获取的最大超时时间
      min-idle: 5                                             # 数据库连接池的最小维持连接数

eureka:
  client:
    service-url:
      #defaultZone: http://localhost:9001/eureka
      defaultZone: http://eureka9001.com:9001/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9003.com:9003/eureka/
  instance:
    instance-id: microservicecloud-provider-hystrix           #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
info: 
  app.name: microservicecloud-provider
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

server.port と eureka.instance.instance-id のみが変更され、
UserController の内容は次のように変更されます。

package com.lzj.springcloud.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.lzj.springcloud.entity.User;
import com.lzj.springcloud.service.UserService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@RestController
public class UserController {
    
    

	@Autowired
	private UserService service;
	
	@RequestMapping(value="/get/{id}", method=RequestMethod.GET)
	@HystrixCommand(fallbackMethod="hystrixGetUser") //一旦服务调用失败，就调用hystrixGetUser方法
	public User getUser(@PathVariable("id") int id){
    
    
		User user = service.getUser(id);
		if(user == null){
    
    
			throw new RuntimeException("不存在id=" + id + "对应的用户信息");
		}
		return user;
	}
	
	public User hystrixGetUser(@PathVariable("id") int id){
    
    
		User user = new User(id, "不存在该用户", 0);
		return user;
	}

}

アノテーション @EnableCircuitBreaker をスタートアップクラス HystrixProviderApplication に追加し、
microservice-eurake1、microservice-eurake2、microservice-eurake3 サービスを開始し、次に microservice-provider-hystrix サービスを開始し、次に microservice-consumer-feign サービスを開始します。

テスト

2. サービスの低下分散
システムでは、アクセスのピーク時やリソースが制限されている場合、サービスをシャットダウンする必要がありますが、サービスへのアクセス要求があった場合、システムのサービスがシャットダウンしたからといって、呼び出し元のサービスでサービスを中断することはできません。 down. の場合は、指定されたエラー情報が返されるように要求する必要があります。たとえば、分散システムに 2 つのサービス A と B があります。リソースが限られているため、サービス B をオフにする必要があります。サービス A がサービス B を呼び出しても、サービス B はオンになりません。このとき、A は指定されたエラーを返します。サービス B ではないことに注意してください。クライアント A から返されるのは、クライアント A から返されるエラーメッセージです。
microservice-consumer-feign サービスを microservice-consumer-feign-hystrix にコピーし、依存
関係を microservice-consumer-feign-hystrix の pom ファイルに追加します。

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

microservice-consumer-feign-hystrix サービスで FallbackFactory を実装する新しい ConsumerServiceFallbackFactory クラスを作成し、クラスに @Component を追加して、ConsumerService インターフェイスに渡します。ConsumerService の対応するメソッドの呼び出しに失敗すると、対応する実装された ConsumerService メソッドが、 ConsumerServiceFallbackFactory が自動的に呼び出され、対応するメソッドでサービスの呼び出しに失敗したときに表示されるエラーメッセージをカスタマイズします。

package com.lzj.springcloud.service;
import java.util.List;
import org.springframework.stereotype.Component;
import com.lzj.springcloud.entity.User;
import feign.hystrix.FallbackFactory;

@Component
public class ConsumerServiceFallbackFactory implements FallbackFactory<ConsumerService> {
    
    

	@Override
	public ConsumerService create(Throwable arg0) {
    
    
		// TODO Auto-generated method stub
		return new ConsumerService() {
    
    
			
			@Override
			public List<User> getAll() {
    
    
				// TODO Auto-generated method stub
				return null;
			}
			
			@Override
			public User get(int id) {
    
    
				User user = new User(id, "该用户不存在", 0);
				return user;
			}
			
			@Override
			public boolean add(User user) {
    
    
				// TODO Auto-generated method stub
				return false;
			}
		};
	}

}

microservice-consumer-feign-hystrix サービスの ConsumerService インターフェイスの @FeignClient に fallbackFactory 属性を追加します。Spring の AOP の側面を使用すると、ConsumerService のメソッドの呼び出しが失敗したときに、fallbackFactory 属性で指定された ConsumerServiceFallbackFactory クラスの対応するメソッドが実行され、ConsumerService が次のように変更されます。

package com.lzj.springcloud.service;
import java.util.List;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.lzj.springcloud.entity.User;

/*以后调用microservicecloud-provider微服务中的方法，只需要调用下面对应的接口既可以了*/
@FeignClient(value="microservicecloud-provider", fallbackFactory=ConsumerServiceFallbackFactory.class)
public interface ConsumerService {
    
    

	/*调用接口中的get方法，即可以向microservicecloud-provider微服务发送/get/{id}请求*/
	@RequestMapping(value="/get/{id}", method=RequestMethod.GET)
	public User get(@PathVariable("id") int id);
	
	@RequestMapping(value="/add", method=RequestMethod.POST)
	public boolean add(User user);
	
	@RequestMapping(value="/getUser/list", method=RequestMethod.GET)
	public List<User> getAll();
}

microservice-consumer-feign-hystrix サービスの application.yml ファイルを次のように変更します。

server: 
  port: 7001

feign: 
  hystrix: 
    enabled: true

eureka:
  client:
    register-with-eureka: false
    service-url: 
      defaultZone: http://eureka9003.com:9003/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9001.com:9001/eureka/

テスト

3. サービスの監視
前述のサービスの融合とダウングレードに加えて、hystrix はサービスのリアルタイム監視にも適用できます。Hystrix は、Hystrix を通じて開始されたすべてのリクエストの実行情報を継続的に記録し、1 秒あたりに実行されたリクエストの数、成功したリクエストの数、失敗したリクエストの数などを含む統計レポートとグラフィックの形式でユーザーに表示します。Netflix は、hystrix-metrics-event-stream プロジェクトを通じて上記の指標の監視を実装しています。Spring Cloud は、監視コンテンツを視覚的なインターフェイスに変換する Hystrix ダッシュボードの統合も提供します。例は次のとおりです。
microservice-consumer-hystrix-dashbord マイクロサービスを作成し、
次のように pom 依存関係を追加します。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.lzj.springcloud</groupId>
    <artifactId>microservice-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>microservice-consumer</artifactId>
  
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-hystrix</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
		</dependency>
		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>
</project>

application.yml 構成ファイルは次のとおりです。

server: 
  port: 7002

スタートアップクラス HystrixDashbordConsumerApplication を作成します。

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashbordConsumerApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(HystrixDashbordConsumerApplication.class, args);
	}

}

テスト

ズールルーティング

Zuul ルーティングには、リクエストのルーティングとフィルタリングという 2 つの機能が含まれています。
ルーティング: ルーティング機能は、外部アクセスの統合入口である特定のマイクロサービスインスタンスに外部リクエストを転送する役割を担います;
フィルタリング: フィルター機能はリクエスト処理プロセスに介入し、リクエストの検証、サービスの集約を実現する役割を担いますおよびその他の機能。
ZuulとEurekaを統合し、Zuul自体をEurekaサービスガバナンスのアプリケーションとして登録し、他のマイクロサービスの情報をEurekaから取得する、つまり今後のマイクロサービスへのアクセスはZuulジャンプを通じて取得することになります。Zuulサービスは最終的にEurekaに登録される予定だ。

1. ルーティング設定
microservice-zull マイクロサービスを作成します;
pom ファイルは次のとおりです。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.lzj.springcloud</groupId>
    <artifactId>microservice-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>microservice-zull</artifactId>
  
	<dependencies>
		<!-- zuul路由网关 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-zuul</artifactId>
		</dependency>
		<!-- 热部署插件 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>
	

</project>

また、Zuul マイクロサービスを Eureaka に登録します。application.yml ファイルは次のように構成されています。

server: 
  port: 6001

spring:
  application:
    name: microservice-zull
eureka:
  client:
    service-url: 
      defaultZone: http://eureka9003.com:9003/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9001.com:9001/eureka/
  instance: 
    instance-id: microservice-zull6001                        #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
info: 
  app.name: microservice-zull
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

ホストファイルに 127.0.0.1 のマッピングを追加します (127.0.0.1 zull6001.com は、zull6001.com を使用して Zuul マイクロサービスのドメイン名を表します)。
次の内容を含む ZullApplication スタートアップクラスを作成します。

package com.lzj.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy //启动Zuul
public class ZullApplication {
    
    

	public static void main(String[] args) {
    
    
		SpringApplication.run(ZullApplication.class, args);
	}

}

テスト

2. サービスエージェント名を変更します。
ルーティングを通じてサービスにアクセスするリクエストは http://zull6001.com:6001/microservicecloud-provider/get/2 です。ここで、microservicecloud-provider は、特定のサービスを公開する呼び出されるサービス名です。発信者の名前に。サービス名を公開したくない場合は、サービスのコードエイリアスを指定できます。たとえば、リクエスト http://zull6001.com:6001/provider/get/ を送信して、microservicecloud-provider サービスにアクセスできます。 2 の場合、プロバイダーは microservicecloud-provider のエイリアスです。application.yml で次のように構成します。

server: 
  port: 6001

spring:
  application:
    name: microservice-zull
eureka:
  client:
    service-url: 
      defaultZone: http://eureka9003.com:9003/eureka/,http://eureka9002.com:9002/eureka/,http://eureka9001.com:9001/eureka/
  instance: 
    instance-id: microservice-zull6001                        #自定义服务名称信息
    prefer-ip-address: true                                   #访问路径可以显示IP地址
    
zuul:
  routes:
    mydept.serviceId: microservicecloud-provider
    mydept.path: /provider/**

info: 
  app.name: microservice-zull
  company.name: www.lzj.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

実際のサービス名のリクエストを無視する

zuul:
  ignored-services: microservicecloud-provider
  routes:
    mydept.serviceId: microservicecloud-provider
    mydept.path: /provider/**

アクセスプレフィックスを設定する

zuul:
  prefix: /MyDemo
  ignored-services: microservicecloud-provider
  routes:
    mydept.serviceId: microservicecloud-provider
    mydept.path: /provider/**

構成設定

分散システムには多数のマイクロサービスが含まれる場合があり、それぞれに独自の構成ファイルがあります。システムが変更されると、多くのサービスの構成ファイルを変更する必要が生じる可能性があり、その結果、運用と保守が煩雑になり、問題が発生しやすくなります。一元化された動的な構成管理機能。Spring Cloud は、この問題を解決するための Config を提供します。

1. Config サーバーを確立し、github と通信します
github 上にリポジトリを作成します、この場所の名前は microservice-config、アドレスは https://github.com/shuniversity/microservice-config.git です
。リポジトリをローカル E:\demo\springcloud-config-repository にコピー

>git clone https://github.com/shuniversity/microservice-config.git

ローカルウェアハウス E:\demo\springcloud-config-repository\microservice-config へのクローンに新しい application.yml ファイルを作成します。内容は次のとおりです。

spring:
  profiles:
    active:
      - dev
---
spring:
  profiles: dev                   #开发环境
  application:
    name: microservice-config-dev
    
---
spring:
  profiles: test                  #测试环境
  application:
    name: microservice-config-test

新しく作成した application.yml ファイルを github の microservice-config ウェアハウスにプッシュします。

    git add .
    git commit -m "init file" 
    git push origin master

新しい microservice-config-server サービスを作成します。pom ファイル構成は次のとおりです。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.lzj.springcloud</groupId>
    <artifactId>microservice-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <artifactId>microservice-config-server</artifactId>
  
	<dependencies>
		<!-- 依赖microservice-com模块 -->
		<dependency>
    		<groupId>org.springframework.cloud</groupId>
    		<artifactId>spring-cloud-config-server</artifactId>
		</dependency>
		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
	</dependencies>
</project>

application.yml は次のように構成されています:
サーバー:
ポート: 4001

spring:
  application:
    name: microservice-config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/shuniversity/microservice-config.git

スタートアップクラス ConfigServerApp を作成する

package com.lzj.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApp {
    
    

	public static void main(String[] args) {
    
    

		SpringApplication.run(ConfigServerApp.class, args);
	}

}

SpringCloud シリーズのデモをビルドする

おすすめ