SpringCloud的入门学习之Eureka（高可用注册中心HA）构建Provider服务、Consumer服务

1、在高可用的Eureka注册中心中构建provider服务。

　　使用springboot的多环境配置，来搭建Eureka的高可用集群式部署。由于使用的是maven构建的springboot项目，所以首先引入pom.xml配置文件，这里需要注意的是springboot的版本、springcloud的版本对应，不然会出现一个版本不对应错误，稍后可以贴一下错误。我使用的springboot版本是2.2.0的，springcloud版本是Hoxton.RC1。

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <project xmlns="http://maven.apache.org/POM/4.0.0"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 5     https://maven.apache.org/xsd/maven-4.0.0.xsd">
 6     <modelVersion>4.0.0</modelVersion>
 7     <parent>
 8         <groupId>org.springframework.boot</groupId>
 9         <artifactId>spring-boot-starter-parent</artifactId>
10         <version>2.2.0.RELEASE</version>
11         <relativePath />
12         <!-- lookup parent from repository -->
13     </parent>
14     <groupId>com.bie</groupId>
15     <artifactId>springcloud-eureka-provider</artifactId>
16     <version>0.0.1-SNAPSHOT</version>
17     <name>springcloud-eureka-provider</name>
18     <description>Demo project for Spring Boot</description>
19 
20     <properties>
21         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
22         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
23         <java.version>1.8</java.version>
24         <spring-cloud.version>Hoxton.RC1</spring-cloud.version>
25         <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
26     </properties>
27 
28     <dependencies>
29         <dependency>
30             <groupId>org.springframework.boot</groupId>
31             <artifactId>spring-boot-starter-web</artifactId>
32         </dependency>
33         <!-- springcloud eureka 客户端 -->
34         <dependency>
35             <groupId>org.springframework.cloud</groupId>
36             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
37         </dependency>
38         <dependency>
39             <groupId>org.springframework.boot</groupId>
40             <artifactId>spring-boot-starter-test</artifactId>
41             <scope>test</scope>
42             <exclusions>
43                 <exclusion>
44                     <groupId>org.junit.vintage</groupId>
45                     <artifactId>junit-vintage-engine</artifactId>
46                 </exclusion>
47             </exclusions>
48         </dependency>
49     </dependencies>
50 
51     <dependencyManagement>
52         <dependencies>
53             <dependency>
54                 <groupId>org.springframework.cloud</groupId>
55                 <artifactId>spring-cloud-dependencies</artifactId>
56                 <version>${spring-cloud.version}</version>
57                 <type>pom</type>
58                 <scope>import</scope>
59             </dependency>
60         </dependencies>
61     </dependencyManagement>
62 
63     <build>
64         <plugins>
65             <plugin>
66                 <groupId>org.springframework.boot</groupId>
67                 <artifactId>spring-boot-maven-plugin</artifactId>
68             </plugin>
69         </plugins>
70     </build>
71 
72     <repositories>
73         <repository>
74             <id>spring-milestones</id>
75             <name>Spring Milestones</name>
76             <url>https://repo.spring.io/milestone</url>
77         </repository>
78     </repositories>
79 
80 </project>

修改配置文件application.properties。内容如下所示：

1 # 配置项目名称
2 spring.application.name=springcloud-eureka-provider
3 
4 # 配置端口号
5 spring.port=8080
6 
7 # 客户端需要向服务端进行注册,必须配置服务端的地址。知道服务端在那里。
8 #设置服务注册中心地址,可以将集群中的所有节点列处理。 
9 eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/,http://eureka2:8761/eureka/

将Eureka客户端的的注解加到启动类上面。

 1 package com.bie;
 2 
 3 import org.springframework.boot.SpringApplication;
 4 import org.springframework.boot.autoconfigure.SpringBootApplication;
 5 import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
 6 
 7 @EnableEurekaClient // Eureka客户端
 8 @SpringBootApplication
 9 public class SpringCloudApplication {
10 
11     public static void main(String[] args) {
12         SpringApplication.run(SpringCloudApplication.class, args);
13     }
14 
15 }

注意，需要将服务器ip地址和别称映射加到hosts配置文件里面的。C:\Windows\System32\drivers\etc\hosts。

1 192.168.110.133 eureka1
2 192.168.110.134 eureka2

将配置日志管理的配置文件，logback.xml。如下所示。

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <configuration>
 3     <!--定义日志文件的存储地址 勿在 LogBack 的配置中使用相对路径 -->
 4     <property name="LOG_HOME" value="${catalina.base}/logs/" />
 5     <!-- 控制台输出 -->
 6     <appender name="Stdout"
 7         class="ch.qos.logback.core.ConsoleAppender">
 8         <!-- 日志输出编码 -->
 9         <layout class="ch.qos.logback.classic.PatternLayout">
10             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
11             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
12                 %msg%n
13             </pattern>
14         </layout>
15     </appender>
16     <!-- 按照每天生成日志文件 -->
17     <appender name="RollingFile"
18         class="ch.qos.logback.core.rolling.RollingFileAppender">
19         <rollingPolicy
20             class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
21             <!--日志文件输出的文件名 -->
22             <FileNamePattern>${LOG_HOME}/server.%d{yyyy-MM-dd}.log
23             </FileNamePattern>
24             <MaxHistory>30</MaxHistory>
25         </rollingPolicy>
26         <layout class="ch.qos.logback.classic.PatternLayout">
27             <!--格式化输出：%d表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：日志消息，%n是换行符 -->
28             <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -
29                 %msg%n
30             </pattern>
31         </layout>
32         <!--日志文件最大的大小 -->
33         <triggeringPolicy
34             class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
35             <MaxFileSize>10MB</MaxFileSize>
36         </triggeringPolicy>
37     </appender>
38 
39     <!-- 日志输出级别 -->
40     <root level="DEBUG">
41         <appender-ref ref="Stdout" />
42         <appender-ref ref="RollingFile" />
43     </root>
44 
45 </configuration>

2、开始开发服务，向Eureka Server注册中心服务端进行服务的注册。

首先，启动主启动类，可以看到已经将服务注册到Eureka Server注册中心。如下所示：

首先，配置一个实体类，然后开发一个控制层接口方法。

 1 package com.bie.po;
 2 
 3 /**
 4  * 
 5  * @author biehl
 6  *
 7  */
 8 public class User {
 9 
10     private int id;
11     private String username;
12     private int age;
13 
14     public int getId() {
15         return id;
16     }
17 
18     public void setId(int id) {
19         this.id = id;
20     }
21 
22     public String getUsername() {
23         return username;
24     }
25 
26     public void setUsername(String username) {
27         this.username = username;
28     }
29 
30     public int getAge() {
31         return age;
32     }
33 
34     public void setAge(int age) {
35         this.age = age;
36     }
37 
38     public User(int id, String username, int age) {
39         super();
40         this.id = id;
41         this.username = username;
42         this.age = age;
43     }
44 
45     public User() {
46         super();
47     }
48 
49     @Override
50     public String toString() {
51         return "User [id=" + id + ", username=" + username + ", age=" + age + "]";
52     }
53 
54 }

 1 package com.bie.controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.RestController;
 8 
 9 import com.bie.po.User;
10 
11 /**
12  * 
13  * @author biehl
14  *
15  */
16 @RestController
17 public class UserController {
18 
19     @RequestMapping(value = "/showUser")
20     public List<User> getListUser() {
21         List<User> list = new ArrayList<User>();
22 
23         User user = new User();
24         user.setId(1008611);
25         user.setUsername("zhangsan");
26         user.setAge(25);
27         list.add(user);
28 
29         User user2 = new User();
30         user2.setId(1008612);
31         user2.setUsername("lisi");
32         user2.setAge(24);
33         list.add(user2);
34 
35         User user3 = new User();
36         user3.setId(1008613);
37         user3.setUsername("wangwu");
38         user3.setAge(23);
39         list.add(user3);
40 
41         return list;
42     }
43 }

最后，开发完服务中的接口以后，启动主启动类，将服务注册到注册中心当中去。查看演示效果，如下所示：

开发服务提供者，通过浏览器访问接口成功，代表成功将服务注册到Eureka Server注册中心。

3、在高可用的Eureka注册中心中构建consumer服务。由于consumer服务也是Eureka的客户端，所以pom.xml配置文件这里省略了。logback.xml配置文件一致即可，这里省略了。启动主类一致，这里也省略了，都需要加上@EnableEurekaClient，代表Eureka的客户端。

注意：服务的消费者与提供者都需要在Eureka注册中心注册。consumer服务也需要去Eureka Server服务端进行注册，这样才可以去消费Eureka Server注册中心的服务。

修改配置文件application.properties。内容如下所示：

1 # 配置项目名称
2 spring.application.name=springcloud-eureka-consumer
3 
4 # 配置端口号
5 spring.port=8081
6 
7 # 客户端需要向服务端进行注册,必须配置服务端的地址。知道服务端在那里。
8 #设置服务注册中心地址,可以将集群中的所有节点列处理。 
9 eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/,http://eureka2:8761/eureka/

consumer服务调用provider服务，需要知道provider服务的基本信息，比如ip地址、端口等等。SpringCloud微服务中如何知道调用服务的基本信息呢？人家封装好了类让你用啦，抓紧学吧，孩子。

通过LoadBalancerClient 获取到服务提供方的ip地址和端口号，拼接出URL，进行方法的调用。

 1 package com.bie.service;
 2 
 3 import java.util.List;
 4 
 5 import org.springframework.beans.factory.annotation.Autowired;
 6 import org.springframework.cloud.client.ServiceInstance;
 7 import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
 8 import org.springframework.core.ParameterizedTypeReference;
 9 import org.springframework.http.HttpMethod;
10 import org.springframework.http.ResponseEntity;
11 import org.springframework.stereotype.Service;
12 import org.springframework.web.client.RestTemplate;
13 
14 import com.bie.po.User;
15 
16 /**
17  * 
18  * @author biehl
19  *
20  */
21 @Service
22 public class UserService {
23 
24     // SpringCloud提供的负载均衡的对象。
25     // ribbon的负载均衡器。通过该对象可以获取调用服务的ip地址、端口号等等信息。
26     // 通过服务的名称获取到调用服务的ip地址、端口号等等信息。
27     @Autowired
28     private LoadBalancerClient loadBalancerClient;
29 
30     public List<User> getListUser() {
31         // 1、选择调用的服务的名称
32         // 注意,ServiceInstance封装了服务的基本信息,包含ip地址、端口号
33         ServiceInstance serviceInstance = this.loadBalancerClient.choose("springcloud-eureka-provider");
34         // 2、拼接访问服务的URL。StringBuffer线程安全的,StringBuilder线程不安全,效率高
35         StringBuilder sb = new StringBuilder();
36         // 访问地址,http://127.0.0.1:8080/showUser
37         sb.append("http://").append(serviceInstance.getHost()).append(":").append(serviceInstance.getPort())
38                 .append("showUser");
39 
40         // 3、向URL发送请求。SpringMVC RestTemplate
41         RestTemplate restTemplate = new RestTemplate();
42         // 处理接口的返回值,参数类型的定义
43         ParameterizedTypeReference<List<User>> parameterizedTypeReference = new ParameterizedTypeReference<List<User>>() {
44         };
45 
46         // 4、封装了返回值信息。
47         // 参数1是URL。
48         // 参数2是http请求类型。
49         // 参数3是参数的传递。
50         // 参数3是返回值类型的封装。
51         ResponseEntity<List<User>> responseEntity = restTemplate.exchange(sb.toString(), HttpMethod.GET, null,
52                 parameterizedTypeReference);
53 
54         // 5、返回调用成功以后的返回值。
55         List<User> list = responseEntity.getBody();
56         return list;
57     }
58 
59 }

开发消费端的控制层，可以调用消费端的业务service层。

 1 package com.bie.controller;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 import org.springframework.beans.factory.annotation.Autowired;
 7 import org.springframework.web.bind.annotation.RequestMapping;
 8 import org.springframework.web.bind.annotation.RestController;
 9 
10 import com.bie.po.User;
11 import com.bie.service.UserService;
12 
13 /**
14  * 
15  * @author biehl
16  *
17  */
18 @RestController
19 public class UserController {
20 
21     @Autowired
22     private UserService userService;
23 
24     @RequestMapping(value = "/consumer")
25     public List<User> getListUser() {
26         List<User> list = new ArrayList<User>();
27         list = userService.getListUser();
28         return list;
29     }
30 }