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 }
启动你的高可用Eureka Server,启动你的服务提供方Provider,启动你的服务消费方Consumer。
然后你发现服务提供方的返回信息,在服务消费方也可以完全访问到,从而实现服务的远程调用。