Eureka使用小案例

Eureka架构中的三个核心角色：

• 服务注册中心：Eureka的服务端应用，提供服务注册和发现功能
• 服务提供者：提供服务的应用，可以是SpringBoot应用，也可以是其它技术实现，只要对外提供的是Rest风格服务即可。
• 服务消费者：消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。

Eureka就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。Eureka说白了就是一个注册服务中心。

同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。

这就实现了服务的自动注册、发现、状态监控。

原理图

• Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
• 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
• 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
• 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

入门案例
1.编写EurekaServer
接下来我们创建一个项目，启动一个EurekaServer，依然使用spring提供的快速搭建工具：

选择依赖：

完整的Pom文件：

1. <?xml version= "1.0" encoding= "UTF-8"?>
2. <project xmlns= "http://maven.apache.org/POM/4.0.0" 
4. xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
5.     xsi:schemaLocation= "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
6.     <modelVersion> 4.0. 0</modelVersion>
8. <groupId>com.czxy.demo</groupId>
9. <artifactId>eureka-demo</artifactId>
10. <version> 0.0. 1-SNAPSHOT</version>
11. <packaging>jar</packaging>
13. <name>eureka-demo</name>
14. <description>Demo project for Spring Boot</description>
16. <parent>
17.     <groupId>org.springframework.boot</groupId>
18.     <artifactId>spring-boot-starter-parent</artifactId>
19.     <version> 2.0. 1.RELEASE</version>
20.     <relativePath/> <!-- lookup parent from repository -->
21. </parent>
23. <properties>
24.     <project.build.sourceEncoding>UTF- 8</project.build.sourceEncoding>
25.     <project.reporting.outputEncoding>UTF- 8</project.reporting.outputEncoding>
26.     <java.version> 1.8</java.version>
27.     <!-- SpringCloud版本，是最新的F系列 -->
28.     <spring-cloud.version>Finchley.RC1</spring-cloud.version>
29. </properties>
31. <dependencies>
32.     <!-- Eureka服务端 -->
33.     <dependency>
34.         <groupId>org.springframework.cloud</groupId>
35.         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
36.     </dependency>
37. </dependencies>
39. <dependencyManagement>
40.     <dependencies>
41.         <!-- SpringCloud依赖，一定要放到dependencyManagement中，起到管理版本的作用即可 -->
42.         <dependency>
43.             <groupId>org.springframework.cloud</groupId>
44.             <artifactId>spring-cloud-dependencies</artifactId>
45.             <version>${spring-cloud.version}</version>
46.             <type>pom</type>
47.             <scope> import</scope>
48.         </dependency>
49.     </dependencies>
50. </dependencyManagement>
52. <build>
53.     <plugins>
54.         <plugin>
55.             <groupId>org.springframework.boot</groupId>
56.             <artifactId>spring-boot-maven-plugin</artifactId>
57.         </plugin>
58.     </plugins>
59. </build>
61. <repositories>
62.     <repository>
63.         <id>spring-milestones</id>
64.         <name>Spring Milestones</name>
65.         <url>https: //repo.spring.io/milestone</url>
66.         <snapshots>
67.             <enabled> false</enabled>
68.         </snapshots>
69.     </repository>
70. </repositories>
71. </project>

编写启动类：

1. @SpringBootApplication
2. @EnableEurekaServer // 声明这个应用是一个EurekaServer
3. public class EurekaDemoApplication {
5. public static void main(String[] args) {
6.     SpringApplication.run(EurekaDemoApplication.class, args);
7. }
8. }

编写配置application.yml：

1. server:
2.   port: 10086 # 端口
3. spring:
4.   application:
5.     name: eureka-server # 应用名称，会在Eureka中显示
6. eureka:
7.   client:
8.     register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是 true
9.     fetch-registry: false # 是否拉取其它服务的信息，默认是 true
10.     service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
11.       defaultZone: http: //127.0.0.1:${server.port}/eureka

启动服务，并访问：http://127.0.0.1:10086/eureka

 

2.将user-service注册到Eureka

注册服务，就是在服务上添加Eureka的客户端依赖，客户端代码会自动把服务注册到EurekaServer中。
我们在user-service-demo中添加Eureka客户端依赖：

1. <!-- SpringCloud的依赖 -->
3. <dependencyManagement>
4.     <dependencies>
5.         <dependency>
6.             <groupId>org.springframework.cloud</groupId>
7.             <artifactId>spring-cloud-dependencies</artifactId>
8.             <version>Finchley.RC1</version>
9.             <type>pom</type>
10.             <scope> import</scope>
11.         </dependency>
12.     </dependencies>
13. </dependencyManagement>
14. <!-- Spring的仓库地址 -->
15. <repositories>
16.     <repository>
17.         <id>spring-milestones</id>
18.         <name>Spring Milestones</name>
19.         <url>https: //repo.spring.io/milestone</url>
20.         <snapshots>
21.             <enabled> false</enabled>
22.         </snapshots>
23.     </repository>
24. </repositories>

然后是Eureka客户端：

1. <!-- Eureka客户端 -->
2. <dependency>
3.     <groupId>org.springframework.cloud</groupId>
4.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5. </dependency>

通过添加@EnableDiscoveryClient来开启Eureka客户端功能

1. SpringBootApplication
2. @EnableEurekaClient // 开启EurekaClient功能
3. public class UserServiceDemoApplication {
4. public static void main(String[] args) {
5. SpringApplication.run(UserServiceDemoApplication.class, args);
6. }
7. }

编写配置

1. server:
2.   port: 8081
3. spring:
4.   datasource:
5.     url: jdbc:mysql: //localhost:3306/mydb1?useUnicode=true&characterEncoding=utf8
6.     username: root
7.     password: 123456
8.     driver- class-name: com.mysql.jdbc.Driver
9.   application:
10.     name: user- service # 应用名称
11. eureka:
12.   client:
13.     service- url: # EurekaServer地址
14.       defaultZone: http://127.0.0.1:10086/ eureka
15.   instance:
16.     prefer- ip- address: true # 当调用 getHostname获取实例的 hostname时，返回 ip而不是 host名称
17.     ip- address: 127.0.0.1 # 指定自己的 ip信息，不指定的话会自己寻找

注意：

• 这里我们添加了spring.application.name属性来指定应用名称，将来会作为应用的id使用。
• 不用指定register-with-eureka和fetch-registry，因为默认是true

重启项目，报错

解决方案，设置如下：

1. main:
2.     allow-bean-definition-overriding: true #当遇到同样名字的时候，是否允许覆盖注册

再次运行，OK

我们发现user-service服务已经注册成功了

3.消费者从Eureka获取服务
接下来我们修改consumer-demo，尝试从EurekaServer获取服务。

方法与消费者类似，只需要在项目中添加EurekaClient依赖，就可以通过服务名称来获取信息了！

1）添加依赖：

先添加SpringCloud依赖：

1. <!-- SpringCloud的依赖 -->
2. <dependencyManagement>
3.     <dependencies>
4.         <dependency>
5.             <groupId>org.springframework.cloud</groupId>
6.             <artifactId>spring-cloud-dependencies</artifactId>
7.             <version>Finchley.RC1</version>
8.             <type>pom</type>
9.             <scope> import</scope>
10.         </dependency>
11.     </dependencies>
12. </dependencyManagement>
13. <!-- Spring的仓库地址 -->
14. <repositories>
15.     <repository>
16.         <id>spring-milestones</id>
17.         <name>Spring Milestones</name>
18.         <url>https: //repo.spring.io/milestone</url>
19.         <snapshots>
20.             <enabled> false</enabled>
21.         </snapshots>
22.     </repository>
23. </repositories>

然后是Eureka客户端：

1. <!-- Eureka客户端 -->
2. <dependency>
3.     <groupId>org.springframework.cloud</groupId>
4.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
5. </dependency>

再启动类开启Eureka客户端

1. @SpringBootApplication
2. @EnableDiscoveryClient // 开启Eureka客户端
3. public class UserConsumerDemoApplication {
4.     @Bean
5.     public RestTemplate restTemplate() {
6.         return new RestTemplate();
7.     }
8.     public static void main(String[] args) {
9.         SpringApplication.run(UserConsumerDemoApplication.class, args);
10.     }
11. }

修改配置：

1. server:
2.   port: 8080
3. spring:
4.   application:
5.     name: user-consumer # 应用名称
6. eureka:
7.   client:
8.     service-url: # EurekaServer地址
9.       defaultZone: http: //127.0.0.1:10086/eureka
10.   instance:
11.     prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname
12.     ip-address: 127.0. 0.1 # 指定自己的ip信息，不指定的话会自己寻找

修改user-consumer-demo项目中的UserDao代码，用DiscoveryClient类的方法，根据服务名称，获取服务实例：

 

1. // 必须导入org.springframework.cloud.client.discovery.DiscoveryClient
2.     @Autowired
3.     private DiscoveryClient discoveryClient;
4. public User queryUserById(Long id){
5.     //1、 根据user-service获取user-serivce 的集群的信息
6.     List<ServiceInstance> instances = discoveryClient.getInstances( "user-service");
7.     //2、由于我们没有集群，只有一个，所以直接取出第一个
8.     ServiceInstance instance = instances.get( 0);
9.     //3、拼接URL
10.     String url = "http://"+instance.getHost()+ ":"+instance.getPort()+ "/user/"+id;
12.     // 使用restTemplate发起请求
13.     ResponseEntity<User> entity = restTemplate.getForEntity(url, User.class);
14.     // 获取返回对象
15.     User user = entity.getBody();
16.     return user;
17. }

访问结果：