springcloud-搭建微服务（聚合工程）及配置Eureka(搭建Eureka集群)+负载均衡(Ribbon)调用eureka服务

最新推荐文章于 2024-04-30 09:01:19 发布

Jerry_carry

最新推荐文章于 2024-04-30 09:01:19 发布

阅读量672

点赞数

文章标签： springcloud

本文链接：https://blog.csdn.net/qq_28461661/article/details/89228331

版权

这种方式是写死的不是太好，如果提供方宕机获取我们需要配置集群的时候，这样的话就不好弄了。请参考eureka跟牛逼的技术。本机的参考代码。

1.采用maven 的方式去创建工程

在这里插入图片描述

父工程的打包方式是pom所以我们需要在父工程的pom文件中写 <packaging>pom</packaging>
当然父工程里面我们一般的也引用一些公共的依赖方便我们对版本的控制。
当然这里有的东西你可以根据自己的需要去配置例如mysql版本，因为我自己的mysql用的是8的版本，他的配置的url,dirver都和5不一样可以参考mysql的版本及配置所以我这就使用的是8.0.11，还有些不需要的你也可以去掉例如分页助手啊。

   <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR1</spring-cloud.version>
        <mapper.starter.version>2.0.3</mapper.starter.version>
        <mysql.version>8.0.11</mysql.version>
        <pageHelper.starter.version>1.2.5</pageHelper.starter.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--spring-cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--通用Mapper启动器-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!--分页助手启动器-->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pageHelper.starter.version}</version>
            </dependency>
            <!--mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

2 .新建一个Module（user-service)用于被调用

1.右击父工程新建Module user-service
2.在pom文件里面写如相关依赖，不需要管理版本，因为父工程已经管理好了

 <!--这里面不需要写版本，因为在父工程里面已经管理好了-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

3.配置user-service的application.yml

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/yun6?useSSL=false&serverTimezone=UTC
    username: root
    password: 123
mybatis:
  type-aliases-package: cn.itcast.user.pojo

配置他的启动类注意他的扫描包的配置千万不要导错了
1.启动类

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan("cn.itcast.user.mapper")
public class UserApplication {
    public static void main(String[] args) {
       SpringApplication.run(UserApplication.class);
        System.out.println("user-service启动成功");
    }
}

2.mapper

@Repository
public interface UserMapper extends Mapper<User> {
}

3.controller : 注意他是rest风格的

@Slf4j
@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;
    @GetMapping("{id}")
    public User hello(@PathVariable("id") Long id){
       return userService.queryBtyId(id);
    }
}

4.实体类

package cn.itcast.user.pojo;

import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;
import java.util.Date;

@Data
@Table(name ="db_user") //指定表名
public class User {
    @Id //主键
    @KeySql(useGeneratedKeys = true) //自增
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;
    @Transient //设置不需要和持久化数据库
    private String note;
}

3.创建Module（consumer-demo）用来调用user-service

1.创建启动类这里我们在启动的时候我们给spring容器一个RestTemplate去管理，方便我们以后注入该对象方便我们使用。

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
       SpringApplication.run(ConsumerApplication.class);
        System.out.println("consumer-demo启动成功");
    }
    //注册这个对象把他给spring容器管理这样我们以后就可以在其他的方法中调用了控制反转（IOC）
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

2.在controller中调用方法

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojp.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
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;


@RestController
@RequestMapping("consumer")
public class ConsumerController {

    //这是在启动类的时候给spring 容器管理了
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id")Long id){
        String url = "http://localhost:8081/user/"+id;
        User user = restTemplate.getForObject(url,User.class);
        System.out.println(user);
        return user;
    }
}

3.实体类User

package cn.itcast.consumer.pojp;

import lombok.Data;

import java.util.Date;

//因为这边不需要访问数据库就不要设置其他配置了
@Data
public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;
    private String note;
}

4.配置Eureka

因为Eureka也是一个服务，其实他也是注册中心的那种模式。我们就需要给他起一个服务。
其实这里面有很多问题的，他需要注册和获取。如果Eureka宕机怎么办所以我们同样也需要配置Eureka集群的。但是我们这里很简单了都是自己。这个还需要你自己去多了解。
1.新建一个Module叫eureka-server，在这我就不截图了和前面一样的。
2.配置pom文件引入相关依赖

  <dependencies>
   <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
     </dependency>
 </dependencies>

3.配置启动类注意他的注解

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer
@SpringBootApplication
public class EurekaServer {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServer.class);
        System.out.println("EurekaServer 启动成功");
    }
}

4.配置application.yml

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka
  instance:
    prefer-ip-address: true
    ip-address: 127.0.0.1

5.将user-service注册到Eureka注册中心去

1.引入pom依赖

 <!--eureka-->
<dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

2.修改user-service启动类添加一个注解

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import tk.mybatis.spring.annotation.MapperScan;

//推荐使用这个不推荐使用@EnableEurekaClient，因为使用这个不会写死，这样我们还会注册到其他的注册中心
//@EnableDiscoveryClient既能兼容Eureka、zookeeper和consul
@EnableDiscoveryClient
@SpringBootApplication
@MapperScan("cn.itcast.user.mapper")
public class UserApplication {
    public static void main(String[] args) {
       SpringApplication.run(UserApplication.class);
        System.out.println("user-service启动成功");
    }
}

3.修改user-service 的application.yml

给应用一个名字
添加要注册到的服务中心的配置

server:
  port: 8081
spring:
  application:
    name: user-service #起名字
  datasource:
    url: jdbc:mysql://localhost:3306/yun6?useSSL=false&serverTimezone=UTC
    username: root
    password: 123
mybatis:
  type-aliases-package: cn.itcast.user.pojo
#注册到服务中心
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

6.将consumer-service注册到Eureka注册中心去让他可以调用user-service中得方法

1.在pom文件加依赖，必须得依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   </dependency>

2.application.yml配置文件应为不需要访问数据库了所以去掉了数据库得配置

server:
  port: 8088
spring:
  application:
    name: consumer-service #起名字
#注册到服务中心
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

3.同样得再启动配置类上加上注解 @EnableDiscoveryClient

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
       SpringApplication.run(ConsumerApplication.class);
        System.out.println("consumer-demo启动成功");
    }
    //注册这个对象把他给spring容器管理这样我们以后就可以在其他的方法中调用了控制反转（IOC）
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

4.使用方法调用user-service中得方法

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojp.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
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 java.util.List;


@RestController
@RequestMapping("consumer")
public class ConsumerController {

    //这是在启动类的时候给spring 容器管理了
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoverClient;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id")Long id){
        //根据服务id获取实例，因为可能有几台这边用得是list
        List<ServiceInstance> instances = discoverClient.getInstances("user-service");
       // 从实例中取出ip和端口因为我们这只有一个所以取list(0)
        ServiceInstance instance  = instances.get(0);
        String url = "http://"+instance.getHost()+":"+instance.getPort()+"/user/"+id;
        User user = restTemplate.getForObject(url,User.class);
        return user;
    }
}

7.搭建Eureka集群

1.复制服务并启动
在这里插入图片描述

修改之后再启动eureka-service2

此时我们再访问http://127.0.0.1:10086/和http://127.0.0.1:10087/

测试再consumer-service中也注册两个

#注册到服务中心
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka, http://127.0.0.1:10087/eureka

启动测试都可以，即便你停掉一台服务依然可以访问

8.配置Ribbon负载均衡

1.使用负载均衡得背景
在这里插入图片描述
2.使用负载均衡得事例

3.在comsumer-service得pom中导入依赖

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

4.在启动类的restTemplate方法上加上注解@LoadBalanced

 @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

5.在方法上调用方法注意url的参数默认使用的是轮询

package cn.itcast.consumer.web;

import cn.itcast.consumer.pojp.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
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 java.util.List;


@RestController
@RequestMapping("consumer")
public class ConsumerController {

    //这是在启动类的时候给spring 容器管理了
    @Autowired
    private RestTemplate restTemplate;
   // @Autowired
   // private DiscoveryClient discoverClient;
   // private RibbonLoadBalancerClient client;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id")Long id){
        //根据服务id获取实例，因为可能有几台这边用得是list
      //  List<ServiceInstance> instances = discoverClient.getInstances("user-service");
       // 从实例中取出ip和端口因为我们这只有一个所以取list(0)
     //   ServiceInstance instance = client.choose("user-service");
      //  ServiceInstance instance  = instances.get(0);
     //   String url = "http://"+instance.getHost()+":"+instance.getPort()+"/user/"+id;
        String url = "http://user-service/user/"+id;
        User user = restTemplate.getForObject(url,User.class);
        return user;
    }
}

Jerry_carry

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
springcloud-搭建微服务（聚合工程）及配置Eureka(搭建Eureka集群)+负载均衡(Ribbon)调用eureka服务

1.采用maven 的方式去创建工程父工程的打包方式是pom所以我们需要在父工程的pom文件中写 <packaging>pom</packaging>当然父工程里面我们一般的也引用一些公共的依赖方便我们对版本的控制。当然这里有的东西你可以根据自己的需要去配置例如mysql版本，因为我自己的mysql用的是8的版本，他的配置的url,dirver都和5不一样可以参...
复制链接

扫一扫