第二节：Spring Cloud 基础使用

最新推荐文章于 2023-11-03 22:03:55 发布

paynmind

最新推荐文章于 2023-11-03 22:03:55 发布

阅读量178

点赞数 2

分类专栏：项目1——leyou 文章标签： java spring 分布式

本文链接：https://blog.csdn.net/paynmind/article/details/108391460

版权

项目1——leyou 专栏收录该内容

31 篇文章 2 订阅

订阅专栏

此博客用于个人学习，来源于网上，对知识点进行一个整理。

1. 系统架构演变：

随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到 SOA，以及现在火热的微服务架构，还有在 Google 带领下来势汹涌的 Service Mesh。

1.1 集中式架构：

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架（ORM）是影响项目开发的关键。

在这里插入图片描述
存在的问题：

代码耦合，开发维护困难。
无法针对不同模块进行针对性优化。
无法水平扩展。
单点容错率低，并发能力差。

1.2 垂直拆分：

当访问量逐渐增大，单一应用无法满足需求，此时为了应对更高的并发和业务需求，我们根据业务功能对系统进行拆分：

在这里插入图片描述
优点：

系统拆分实现了流量分担，解决了并发问题。
可以针对不同模块进行优化。
方便水平扩展，负载均衡，容错率提高。

缺点：

系统间相互独立，会有很多重复开发工作，影响开发效率。

1.3 分布式服务：

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式调用是关键。

在这里插入图片描述

优点：

将基础服务进行了抽取，系统间相互调用，提高了代码复用和开发效率。

缺点：

系统间耦合度变高，调用关系错综复杂，难以维护。

1.4 流动计算架构（SOA）：

SOA ：面向服务的架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心 (SOA) 是关键。

在这里插入图片描述
以前出现了什么问题？

服务越来越多，需要管理每个服务的地址。
调用关系错综复杂，难以理清依赖关系。
服务过多，服务状态难以管理，无法根据服务情况动态管理。

服务治理要做什么？

服务注册中心，实现服务自动注册和发现，无需人为记录服务地址。
服务自动订阅，服务列表自动推送，服务调用透明化，无需关心依赖关系。
动态监控服务状态监控报告，人为控制服务状态。

缺点：

服务间会有依赖关系，一旦某个环节出错会影响较大。
服务关系复杂，运维、测试部署困难，不符合 DevOps 思想。

1.5 微服务：

前面说的 SOA，就是面向服务。微服务，似乎也是服务，都是对系统进行拆分。因此两者非常容易混淆，但其实却有一些差别：

微服务的特点：

单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责。
微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个服务虽小，但“五脏俱全”。
面向服务：面向服务是说每个服务都要对外暴露 Rest 风格服务接口 API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供 Rest 的接口即可。
自治：自治是说服务间互相独立，互不干扰。
- 团队独立：每个服务都是一个独立的开发团队，人数不能过多。
- 技术独立：因为是面向服务，提供 Rest 接口，使用什么技术没有别人干涉。
- 前后端分离：采用前后端分离开发，提供统一 Rest 接口，后端不用再为 PC、移动段开发不同接口。
- 数据库分离：每个服务都使用自己的数据源。
- 部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦合，易维护。

在这里插入图片描述

2. 服务调用方式：

2.1 RPC 和 HTTP:

无论是微服务还是SOA，都面临着服务间的远程调用。那么服务间的远程调用方式有哪些呢？

常见的远程调用方式有以下2种：

RPC：Remote Produce Call 远程过程调用，类似的还有 RMI。自定义数据格式，基于原生 TCP 通信，速度快，效率高。早期的 webservice，现在热门的 dubbo，都是 RPC 的典型代表。
Http：http 其实是一种网络传输协议，基于 TCP ，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用 Http 协议，也可以用来进行远程服务调用。缺点是消息封装臃肿，优势是对服务的提供和调用方没有任何技术限定，自由灵活，更符合微服务理念。

2.2 Http 客户端工具：

既然微服务选择了 Http，那么我们就需要考虑自己来实现对请求和响应的处理。不过开源世界已经有很多的http客户端工具，能够帮助我们做这些事情，例如：

HttpClient
OKHttp
URLConnection

2.3 Spring 的 RestTemplate：

Spring 提供了一个 RestTemplate 模板工具类，对基于 Http 的客户端进行了封装，并且实现了对象与 json 的序列化和反序列化，非常方便。RestTemplate 并没有限定 Http 的客户端类型，而是进行了抽象，目前常用的3种都有支持：

HttpClient
OkHttp
JDK 原生的 URLConnection（默认的）

简单使用：

首先在项目中注册一个 RestTemplate 对象，可以在启动类位置注册：

@SpringBootApplication
public class HttpDemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(HttpDemoApplication.class, args);
	}

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

在测试类中直接 @Autowired 注入：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = HttpDemoApplication.class)
public class HttpDemoApplicationTests {

	@Autowired
	private RestTemplate restTemplate;

	@Test
	public void httpGet() {
        // 调用springboot案例中的rest接口
		User user = this.restTemplate.getForObject("http://localhost/user/1", User.class);
		System.out.println(user);
	}
}

通过 RestTemplate的getForObject() 方法，传递 url 地址及实体类的字节码，RestTemplate 会自动发起请求，接收响应，并且帮我们对响应结果进行反序列化。

3. SpringCloud 基础：

微服务的实现方式很多，但是最火的莫过于 Spring Cloud 了。为什么？

后台硬：作为 Spring 家族的一员，有整个 Spring 全家桶靠山，背景十分强大。
技术强：Spring 作为 Java 领域的前辈，有强力的技术团队支撑。
使用方便：相信大家都体会到了 SpringBoot 给我们开发带来的便利，而 SpringCloud 完全支持 SpringBoot 的开发，用很少的配置就能完成微服务框架的搭建。

3.1 SpringCloud 核心组件：

Spring 最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。

SpringCloud 也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：

Eureka：服务治理组件，包含服务注册中心，服务注册与发现机制的实现。（服务治理，服务注册/发现）
Zuul：网关组件，提供智能路由，访问过滤功能。
Ribbon：客户端负载均衡的服务调用组件。（客户端负载）
Feign：服务调用，给予 Ribbon 和 Hystrix 的声明式服务调用组件。（声明式服务调用）
Hystrix：容错管理组件，实现断路器模式，帮助服务依赖中出现的延迟和为故障提供强大的容错能力。(熔断、断路器，容错)

4. 微服务场景模拟：

首先，我们需要模拟一个服务调用的场景，搭建两个工程：itcast-service-provider（服务提供方）和 itcast-service-consumer（服务调用方）。

服务提供方：使用 mybatis 操作数据库，实现对数据的增删改查；并对外提供 rest 接口服务。

服务消费方：使用 restTemplate 远程调用服务提供方的 rest 接口服务，获取数据。

4.1 服务提供者：

我们新建一个项目：itcast-service-provider，对外提供根据id查询用户的服务。

4.1.1 创建工程：

通过 spring 快速搭建项目，依赖也已经全部自动引入：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.service</groupId>
    <artifactId>itcast-service-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>itcast-service-provider</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

因为要使用通用 mapper ，所以我们需要手动加一条依赖：

<!-- 需要手动引入通用mapper的启动器，spring没有收录该依赖 -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.4</version>
</dependency>

4.1.2 编写代码：

配置：属性文件,这里我们采用了 yaml 语法，而不是 properties。

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
mybatis:
  type-aliases-package: cn.itcast.service.pojo

实体类：

@Table(name = "tb_user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Date getUpdated() {
        return updated;
    }

    public void setUpdated(Date updated) {
        this.updated = updated;
    }
}

UserMapper：

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

UserService：

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id) {
        return this.userMapper.selectByPrimaryKey(id);
    }
}

UserController：添加一个对外查询的接口

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

    @Autowired
    private UserService userService;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Long id) {
        return this.userService.queryById(id);
    }
}

4.2 服务调用者：

搭建 itcast-service-consumer 服务消费方工程。

4.2.1 创建工程：

通过 spring 快速搭建项目，依赖也已经全部自动引入：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.service</groupId>
    <artifactId>itcast-service-consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>itcast-service-consumer</name>
    <description>Demo project for Spring Boot</description>

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

4.2.2 编写代码：

首先在引导类中注册 RestTemplate ：

@SpringBootApplication
public class ItcastServiceConsumerApplication {

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

    public static void main(String[] args) {
        SpringApplication.run(ItcastServiceConsumerApplication.class, args);
    }
}

编写配置（application.yml）：

server:
  port: 80

编写 UserController：

@Controller
@RequestMapping("consumer/user")
public class UserController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    @ResponseBody
    public User queryUserById(@RequestParam("id") Long id){
        User user = this.restTemplate.getForObject("http://localhost:8081/user/" + id, User.class);
        return user;
    }

}

pojo 对象（User）：

public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Date getCreated() {
        return created;
    }

    public void setCreated(Date created) {
        this.created = created;
    }

    public Date getUpdated() {
        return updated;
    }

    public void setUpdated(Date updated) {
        this.updated = updated;
    }
}

回顾一下定义的工程：

itcast-service-provider：一个提供根据id查询用户的微服务。
itcast-service-consumer：一个服务调用者，通过 RestTemplate 远程调用 itcast-service-provider。

存在什么问题？

在 consumer 中，我们把 url 地址硬编码到了代码中，不方便后期维护。
consumer 需要记忆 provider 的地址，如果出现变更，可能得不到通知，地址将失效。
consumer 不清楚 provider 的状态，服务宕机也不知道。
provider 只有1台服务，不具备高可用性。
即便 provider 形成集群，consumer 还需自己实现负载均衡。

其实上面说的问题，概括一下就是分布式服务必然要面临的问题：

服务管理
- 如何自动注册和发现
- 如何实现状态监管
- 如何实现动态路由
服务如何实现负载均衡
服务如何解决容灾问题
服务如何实现统一配置

paynmind

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
第二节：Spring Cloud 基础使用

此博客用于个人学习，来源于网上，对知识点进行一个整理。1. 系统架构演变：随着互联网的发展，网站应用的规模不断扩大。需求的激增，带来的是技术上的压力。系统架构也因此不断的演进、升级、迭代。从单一应用，到垂直拆分，到分布式服务，到 SOA，以及现在火热的微服务架构，还有在 Google 带领下来势汹涌的 Service Mesh。1.1 集中式架构：当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架（ORM）是影响项目开发的关键。
复制链接

扫一扫

专栏目录