SpringCloud项目Eureka快速入门

一、引言

        在正式开始学习之前我们需要先掌握两个微服务中的概念，服务提供者（Service Provider）和服务消费者（Service Consumer），我们知道在微服项目中，由于服务的职责单一性，数据的独立性，我们需要其他数据库数据时，需要发送HTTP请求跨服务读取另一数据库的内容。此时被请求的一方即提供者，请求方为消费者。

        而面对大量的跨服务请求我们如果手动在各个服务里硬编码HTTP请求路径将非常不利于集群的开发和维护，我们今天将使用Eureka解决这一问题。

 二、Eureka简介

        Spring Cloud Eureka 是 Netflix 开源的一个服务发现框架，它被集成到了 Spring Cloud 中，提供了服务注册与发现的功能。在微服务架构中，服务实例可能会动态地增加或减少，服务发现机制允许各个服务实例能够互相感知对方的存在。Spring Cloud Eureka 提供了一个简单而强大的服务注册与发现机制，使得在微服务架构中管理和调用服务变得更加容易。

 三、入门项目

1.创建Eureka服务端：

  • 创建一个Maven工程，用于搭建Eureka服务端。
  • 在pom.xml文件中导入Eureka Server的依赖。
  1.     <dependencies>
  2.         
  3.         <dependency>
  4.             <groupId>org.springframework.cloudgroupId>
  5.             <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
  6.         dependency>
  7.     dependencies>
  • 在application.yml文件中配置Eureka Server的相关信息。
  1. server:
  2.   port: 7071
  3. #  注册eureka服务
  4. spring:
  5.   application:
  6.     name: eurekaserver #eureka的服务器名称
  7. eureka:
  8.   client:
  9.     service-url: #eureka的地址信息
  10.       defaultZone: http://localhost:10086/eureka
  11.     register-with-eureka: false  # 不向注册中心注册自己
  12.     fetch-registry: false        # 不从注册中心抓取服务
  • 创建主启动类，并在主启动类上添加 @EnableEurekaServer 注解，以启动Eureka Server。
    1. @EnableEurekaServer
    2. @SpringBootApplication
    3. public class EurekaServerApplication {
    4.     public static void main(String[] args) {
    5.         SpringApplication.run(EurekaServerApplication.class, args);
    6.     }
    7. }
  • 启动Eureka注册中心。然后，可以通过浏览器访问 http://localhost:7001/ 来查看Eureka注册中心的界面。

 2.搭建服务提供者：

  • 创建一个新的Maven工程，用于搭建服务提供者。
  • 在pom.xml文件中，导入Eureka Client的依赖和Spring Boot的启动依赖等。
    1.         <dependency>
    2.             <groupId>org.springframework.bootgroupId>
    3.             <artifactId>spring-boot-starter-webartifactId>
    4.         dependency>
    5.         <dependency>
    6.             <groupId>mysqlgroupId>
    7.             <artifactId>mysql-connector-javaartifactId>
    8.         dependency>
    9.         
    10.         <dependency>
    11.             <groupId>org.mybatis.spring.bootgroupId>
    12.             <artifactId>mybatis-spring-boot-starterartifactId>
    13.         dependency>
    14.         
    15.         <dependency>
    16.             <groupId>org.springframework.cloudgroupId>
    17.             <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    18.         dependency>
  • 在application.yml文件中，配置服务提供者的相关信息(主要配置为spring.application.name和eureka）。
    1. server:
    2.   port: 8081
    3. spring:
    4.   datasource:
    5.     url: 
    6.     username: 
    7.     password: 
    8.     driver-class-name: com.mysql.jdbc.Driver
    9.   application:
    10.     name: userservice
    11. mybatis:
    12.   type-aliases-package: cn.cds.user.pojo
    13.   configuration:
    14.     map-underscore-to-camel-case: true
    15. logging:
    16.   level:
    17.     cn.itcast: debug
    18.   pattern:
    19.     dateformat: MM-dd HH:mm:ss:SSS
    20. eureka:
    21.   client:
    22.     service-url: #eureka的地址信息
    23.       defaultZone: http://localhost:7071/eureka
  • 创建Controller，用于对外提供服务。
    1. import cn.cds.user.pojo.User;
    2. import cn.cds.user.service.UserService;
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.web.bind.annotation.*;
    6.  
    7. @Slf4j
    8. @RestController
    9. @RequestMapping("/user")
    10. public class UserController {
    11.  
    12.     @Autowired
    13.     private UserService userService;
    14.  
    15.     /**
    16.      * @param id 用户id
    17.      * @return 用户
    18.      */
    19.     @GetMapping("/{id}")
    20.     public User queryById(@PathVariable("id") Long id) {
    21.         return userService.queryById(id);
    22.     }
    23. }
  •  在主启动类上添加 @EnableEurekaClient 注解，以启用Eureka Client。
    1. import org.springframework.boot.SpringApplication;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.mybatis.spring.annotation.MapperScan;
    4. import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    5.  
    6. @MapperScan("cn.cds.user.mapper")
    7. @SpringBootApplication
    8. @EnableEurekaClient
    9. public class UserApplication {
    10.     public static void main(String[] args) {
    11.         SpringApplication.run(UserApplication.class, args);
    12.     }
    13. }

3.创建服务消费者：

        重复服务提供者搭建的所有操作，做一个用于请求服务提供者的接口，不同的是，为了模拟实际业务场景，我们所配置的数据库和端口皆不同于已创建的其他服务。

  1. import cn.cds.order.pojo.Order;
  2. import cn.cds.order.service.OrderService;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.PathVariable;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8.  
  9. @RestController
  10. @RequestMapping("order")
  11. public class OrderController {
  12.  
  13.    @Autowired
  14.    private OrderService orderService;
  15.  
  16.     @GetMapping("{orderId}")
  17.     public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
  18.         // 根据id查询订单并返回
  19.         return orderService.queryOrderById(orderId);
  20.     }
  21. }

并且在Service层不再需要硬编码请求地址，改为注册中心中的服务器名即可 

  1. import cn.cds.order.mapper.OrderMapper;
  2. import cn.cds.order.pojo.Order;
  3. import cn.cds.order.pojo.User;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import org.springframework.web.client.RestTemplate;
  7.  
  8. @Service
  9. public class OrderService {
  10.  
  11.     @Autowired
  12.     private OrderMapper orderMapper;
  13.     @Autowired
  14.     private RestTemplate restTemplate;
  15.  
  16.     public Order queryOrderById(Long orderId) {
  17.         // 1.查询订单
  18.         Order order = orderMapper.findById(orderId);
  19.         //2.利用RestTemplate发起http请求，查询用户
  20.                 //注意此处url
  21.         String url="http://userservice/user/"+order.getUserId();
  22.         User user = restTemplate.getForObject(url, User.class);
  23.         //3.封装user到Order
  24.         order.setUser(user);
  25.         // 4.返回
  26.         return order;
  27.     }
  28. }

此时我们再通过浏览器访问 http://localhost:7001/ 来查看Eureka注册中心的界面，userservice和orderservice均以注册。

4.Ribbon负载均衡测试

        另外我们再扩展一小部分，我们知道，在真实的业务场景中一个服务可能对应多个实例或服务器，在微服务架构中，负载均衡通常用于服务网关，以分发进入的API请求到后端的微服务实例。

  • 我们再复制一个userservice

  •  启动UserApplication2再去浏览器的注册中心查看，此时列表中有两个userservice
  • 在服务消费者的配置类中为RestTemplate添加@LoadBalanced注解，使拦截器对其拦截并进行IRule规则的负载均衡
    1. /**
    2.      * 创建RestTemplate并注入IOC容器,发送http请求
    3.      */
    4.     @LoadBalanced
    5.     @Bean
    6.     public RestTemplate restTemplate(){
    7.         return new RestTemplate();
    8.     }
  • 负载均衡测试

        我们两次调用服物消费者所在接口，可以看到两次请求分别根据负载均衡规则请求到了8082和8081端口

 

注：本文转载自blog.csdn.net的东山-CDS的文章"https://blog.csdn.net/2301_77251217/article/details/146102761"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！