服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - SpringBoot整合SpringCloud的过程详解

SpringBoot整合SpringCloud的过程详解

2022-01-05 10:40Tttori Java教程

SpringCloud专注于为典型的用例和扩展机制提供良好的开箱即用体验，在介绍SpringCloud默认使用的注册中心前，先给大家介绍下分布式系统的三个指标，具体内容详情跟随小编一起看看吧

1. SpringCloud特点

SpringCloud专注于为典型的用例和扩展机制提供良好的开箱即用体验，以涵盖其他情况：

  • 分布式/版本化配置
  • 服务注册和发现 Eureka
  • 路由 Zuul
  • 服务到服务的呼叫
  • 负载均衡 Ribbon
  • 断路器 Hystrix
  • 分布式消息传递

2. 分布式系统的三个指标CAP

在介绍SpringCloud默认使用的注册中心前，先介绍分布式系统的三个指标，分别是：

  • Consistency：一致性，在分布式系统中，更新操作执行成功后所有的用户的读操作必须返回最新值；client写入，server同步至整个系统；
  • Availability：可用性，只要收到用户的请求，在一定的时间内服务器就必须给出回应，回应的结果可以是成功或是失败；
  • Partition tolerance：分区容错，即区间通信可能失败，在网络中断，消息丢失的情况下，仍对外提供服务；一般无法避免，可以认为CAP中的P总是成立

SpringBoot整合SpringCloud的过程详解

CAP定律说的是，在一个分布式计算机系统中，一致性C，可用性A，分区容错性P这三种保证无法同时得到满足，最多满足两个：

1.放弃P

为了避免分区容错性问题的发生，一种做法是将所有与事务相关的数据都放在一台服务器上，虽然不能保证100%系统不会出错，但是不会碰到由分区带来的负面效果，这样的做法会严重影响系统的扩展性。

2.放弃A

放弃可用性，一旦遇到分区容错故障，受到影响的服务器需要等待一定的时间，因此会导致在等待期间系统无法对外提供服务。

3.放弃C

这儿说的放弃一致性，并不是完全放弃数据的一致性，而是放弃数据的强一致性，而保留数据的最终一致性。以网络购物为例，对只剩下一件库存的商品，如果同时接受到了两份订单，那么较晚的订单将被告知商品告罄。

文中部分CAP理论摘自：https://www.cnblogs.com/hxsyl/p/4381980.html

3. Eureka

基本介绍

Eureka是SpringCloud官方推荐用于服务注册和发现，一个基于REST的服务

SpringBoot实现了Netflix OSS的集成，使用Eureka的原因之一是因为其可以利用Spring Cloud Netflix的其他组件：智能路由(Zuul)、客户端负载均衡(Ribbon)等

基本组成

Eureka由多个Instance(服务实例)组成，分为Eureka Server和Eureka Client

其中Eureka Client又可细分为：Service Provider、Service Consumer

  • Eureka Server：服务端，提供服务的注册和发现；
  • Eureka Client：客户端

Service Provider：服务提供方，将自身服务注册到Eureka，让消费方找到Service Consumer：服务消费方，从Eureka获取注册服务列表，从而消费服务

Eureka和Zookeeper

1）由CAP理论的角度来看

Zookeeper：ZK保证CP，突出强一致性，但无法保证每次访问服务可用性，比如ZK会出现这样一种情况：当master节点因为网络故障与其他节点失去联系时，剩余节点会重新进行leader选举，在ZK选举leader期间整个ZK集群都是不可用的，这就导致了在选举期间注册服务瘫痪。在云部署的环境下，因网络问题使得ZK集群失去master节点是较大概率会发生的事儿，虽然服务最终会恢复，但是漫长的选举时间导致的注册长期不可用是难以容忍的。

Eureka：Eureka保证AP，Eureka在设计时就优先保证可用性。对于Eureka中的节点，每个节点都是平等的，几个节点挂掉也不会影响正常节点的工作，剩余的节点依然可以提供注册和查询服务。但Eureka不保证强一致性，即查到的信息可能不是最新的。此外Eureka还有一种自我保护机制，如果在15分钟内超过85%的节点都没有正常的心跳，那么Eureka就会认为客户端和注册中心出现了网络故障，但会保证当前节点依然可用，不会像ZK导致整个注册服务瘫痪。

2）由节点分工的角度来看

Zookeeper：ZK集群中节点分为三类，承担不同的任务

  • Leader：事务请求唯一的调度者和处理者（除了查询请求）
  • Follower：处理非事务请求，参与Leader选举投票
  • Observer：处理非事务请求，但不参与Leader选举投票

Eureka：在Eureka集群中每个节点都是平等的，每个节点扮演相同的角色，它们通过相互注册的方式来感知对方的存在，当由注册消息时，它们会同步给集群内的其他节点

中文文档：https://www.springcloud.cc/spring-cloud-greenwich.html

4. SpringCloud Demo

Demo整体结构(父子项目)

SpringBoot整合SpringCloud的过程详解

  • api：Bean、DTO、POJO等以及Service接口
  • controller：服务消费方，前端交互
  • provider：服务提供方，服务实现
  • registry：服务注册中心

4.1 registry

SpringBoot整合SpringCloud的过程详解

1）pom.xml

关键点在于导入eureka服务端依赖以及SpringCloud依赖

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-server -->
        <!-- eureka服务端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
 
    </dependencies>
 
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2）application.properties

进行Eureka服务端的相关配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
spring.application.name=SpringCloudDemoRegistry
 
# server端口，自己喜欢
server.port=8888
 
# Eureka Server服务url以及默认zone，结尾必须eureka
eureka.client.service-url.defaultZone= http://127.0.0.1:8888/eureka/
 
# eureka的自我保护机制，k8s环境下建议false
eureka.server.enable-self-preservation=false
 
# false表示自己端就是注册中心，我的功能就是维护服务实例，不需要从server获取注册的服务信息
eureka.client.fetch-registry=false
 
# false表示不将自己注册到Eureka Server
eureka.client.register-with-eureka=false

3）EurekaregistryApplication

使用@EnableEurekaServer激活相关配置，使registry模块作为注册中心Server

?
1
2
3
4
5
6
7
@EnableEurekaServer //声明为注册中心服务端
@SpringBootApplication
public class EurekaregistryApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaregistryApplication.class, args);
    }
}

4.2 api

SpringBoot整合SpringCloud的过程详解

1）entity

实体类以部门和用户信息为例，由于演示使用了Lombok省点代码，用于实现基本的CRUD

Department.class

?
1
2
3
4
5
6
7
8
9
10
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Department {
    private Long id;
    private Integer dId;
    private String dName;
    private Date updateTime;
}

UserInfo.class

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class UserInfo {
    private Long id;
    private Integer uId;
    private Integer dId;
    private String uName;
    private String uPhone;
    @Email(message = "非法邮件格式") //Validator格式校验
    private String uEmail;
    private String uAddress;
    private Date updateTime;
    private Department department;
}

2）UserService

UserService为服务接口，声明需要提供和消费的方法，写了几个简单查询

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public interface UserService {
 
    /**
     * 判断用户是否存在，0为不存在，返回值与uId相等则存在
     * @param uId
     * @return
     */
    Integer userExist(Integer uId);
 
    /**
     * 获取用户个人基本信息
     * @param uId
     * @return
     */
    UserInfo getUserInfo(Integer uId);
 
    /**
     * 获取用户个人详情信息
     * @param uId
     * @return
     */
    UserInfo getUserDetailsInfo(Integer uId);
}

4.3 provider

SpringBoot整合SpringCloud的过程详解

1）pom.xml

关键点是引入eureka客户端依赖、openfeign依赖、SpringCloud依赖

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<dependencies>
        <!-- Springboot的依赖省略... -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
</dependencies>
 
<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
</dependencyManagement>

2）application.properties

配置Eureka、Mybatis以及DataSource数据源等信息

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
spring.application.name=SpringCloudDemoProvider
 
# Server端口
server.port=9999
 
# Eureka服务url
eureka.client.service-url.defaultZone= http://127.0.0.1:8888/eureka/
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
 
# Mybatis
mybatis.mapper-locations= classpath:com.maziyao.provider.mapper/*.xml
mybatis.type-aliases-package= com.maziyao.common.entity
 
# DataSource数据源配置
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
 
# DataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/boot-demo?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

3）EurekaproviderApplication

provider启动类使用@EnableEurekaClient声明为EurekaClient客户端，作为ServiceProvider

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@EnableEurekaClient
@SpringBootApplication
@EnableAspectJAutoProxy
@MapperScan("com.maziyao.provider.mapper")
@ComponentScan(basePackages = {
        "com.maziyao.provider.rest",
        "com.maziyao.provider.redis",
        "com.maziyao.provider.service",
        "com.maziyao.provider.config"
})
public class EurekaproviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaproviderApplication.class, args);
    }
}

4）service

UserServiceImpl作为UserService接口实现类，@Service用于标注业务层组件

自动注入mapper层的mapper接口并调用，mapper的SQL语句下面就略了，很简单

需要注意的是，对于数据访问层组件mapper，使用@Repository进行标注

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Service("userService")
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserMapper userMapper;
 
    @Override
    public Integer userExist(Integer uId) {
        return userMapper.userExist(uId);
    }
 
    @Override
    public UserInfo getUserInfo(Integer uId) {
        return userMapper.getUserInfo(uId);
    }
 
    @Override
    public UserInfo getUserDetailsInfo(Integer uId) {
        return userMapper.getUserDetailsInfo(uId);
    }
}

5）rest

重点是rest包下的UserServer，要知道Eureka是一个基于REST的服务

使用@RestController标注并声明为userServer，这个是SpringBoot注解，用于标注控制层组件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@RestController("userServer")
public class UserServer {
 
    public static final Logger logger = LoggerFactory.getLogger(UserServer.class);
 
    @Autowired
    private UserService userService;
 
    @ResponseBody
    @RequestMapping(value = "/exist",method = RequestMethod.GET)
    public Integer existUserByUid(@RequestParam("uId")Integer uId){
        return userService.userExist(uId);
    }
 
    @ResponseBody
    @RequestMapping(value = "/userInfo",method = RequestMethod.GET)
    public UserInfo getUserInfo(@RequestParam("uId")Integer uId){
        return userService.getUserInfo(uId);
    }
 
    @ResponseBody
    @RequestMapping(value="/userDetailsInfo",method = RequestMethod.GET)
    public UserInfo getUserDetailsInfo(@RequestParam("uId")Integer uId){
        return userService.getUserDetailsInfo(uId);
    }
}

4.4 consumer

SpringBoot整合SpringCloud的过程详解

1）pom.xml

在Controller的pom.xml中也需要导入EurekaClient的依赖，对于Provider和Controller都为Client

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<dependencies>
        <!-- SpringBoot依赖省略... -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
            <version>2.2.5.RELEASE</version>
        </dependency>
</dependencies>

2）application.properties

在application.properties中配置Eureka相关信息

?
1
2
3
4
5
6
7
8
9
spring.application.name=springCloudDemoController
 
# Server端口
server.port=8899
 
# 注册中心url
eureka.client.service-url.defaultZone= http://127.0.0.1:8888/eureka/
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

3）EurekacontrollerApplication

与Provider的启动类一致，声明启动类为Eureka的客户端

并使用@EnableFeignClients开启Feign，声明性的web服务客户端

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@EnableEurekaClient
@EnableFeignClients
@SpringBootApplication
@EnableAspectJAutoProxy
@ComponentScan({
        "com.maziyao.controller.config",
        "com.maziyao.controller.controller",
        "com.maziyao.controller.rest"
})
public class EurekacontrollerApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(EurekacontrollerApplication.class, args);
    }
 
}

4）rest

controller作为前端交互层，即控制层，此处UserClient声明调用方法

使用@FeignClient声明服务提供方在application.properties中配置的spring.application.name

以及绑定服务提供方对应rest包下的UserServer类的@RestController("userServer")

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@FeignClient(name = "springCloudDemoProvider",contextId = "userServer")
public interface UserClient {
 
    @ResponseBody
    @RequestMapping(value = "/exist",method = RequestMethod.GET)
    public Integer existUserByUid(@RequestParam("uId")Integer uId);
 
    @ResponseBody
    @RequestMapping(value = "/userInfo",method = RequestMethod.GET)
    public UserInfo getUserInfo(@RequestParam("uId")Integer uId);
 
    @ResponseBody
    @RequestMapping(value="/userDetailsInfo",method = RequestMethod.GET)
    public UserInfo getUserDetailsInfo(@RequestParam("uId")Integer uId);
 
}

5）UserController

控制层，使用@RestController标注，并注入UserClient进行调用

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@RestController
public class UserController {
 
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
 
    @Autowired
    private UserClient userClient;
 
    @ResponseBody
    @RequestMapping(value = "/exist",method = RequestMethod.GET)
    public Integer existUserByUid(@RequestParam("uId") Integer uId){
        return userClient.existUserByUid(uId);
    }
 
    @ResponseBody
    @RequestMapping(value = "/userInfo",method = RequestMethod.GET)
    public UserInfo getUserInfoByUid(@RequestParam("uId")Integer uId){
        return userClient.getUserInfo(uId);
    }
 
    @ResponseBody
    @RequestMapping(value = "/userDetailsInfo",method = RequestMethod.GET)
    public UserInfo getUserDetailsInfoByUid(@RequestParam("uId")Integer uId){
        return userClient.getUserDetailsInfo(uId);
    }
 
}

4.5 POSTMAN一下

注意：最后记得mvn install，需要先将registry运行起来，再分别运行provider和controller

启动registry：

SpringBoot整合SpringCloud的过程详解

启动provider：

SpringBoot整合SpringCloud的过程详解

启动consumer：

SpringBoot整合SpringCloud的过程详解

result：

SpringBoot整合SpringCloud的过程详解

到此这篇关于SpringBoot整合SpringCloud的文章就介绍到这了,更多相关SpringBoot整合SpringCloud内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/torima/p/15277106.html

原文链接：https://www.cnblogs.com/torima/p/15277106.html

  • springboot
  • 整合
  • SpringCloud

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 2000 　 1433 　 401 　 330 　 htmlparser 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 对象池模式 　 子线程 　 支票 　 金额大写转换 　 空心菱形 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 TransactionalEventListener 　
    © 2019-2022 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图