认识微服务（二）之 SpringCloud 微服务的场景模拟
1 初始 SpringCloud
微服务是一种架构方式，最终肯定需要技术架构去实施。
微服务的实现方式很多，但是最火的莫过于 Spring Cloud 了。为什么？
（1）后台硬：作为 Spring 家族的一员，有整个 Spring 全家桶靠山，背景十分强大。
（2）技术强：Spring 作为 Java 领域的前辈，可以说是功力深厚。有强力的技术团队支撑，一般人还真比不了
（3）群众基础好：可以说大多数程序员的成长都伴随着 Spring 框架，试问：现在有几家公司开发不用 Spring？SpringCloud 与 Spring 的各个框架无缝整合，对大家来说一切都是熟悉的配方，熟悉的味道。
（4）使用方便：相信大家都体会到了 SpringBoot 给我们开发带来的便利，而 SpringCloud 完全支持 SpringBoot 的开发，用很少的配置就能完成微服务框架的搭建。
1.1 SpringCloud 简介
SpringCloud 是 Spring 旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/
Spring 最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。
SpringCloud 也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：
netflix (网飞)
A、Eureka：注册中心
B、Zuul：服务网关
C、Ribbon：负载均衡
D、Feign：服务调用
E、Hystix：熔断器
以上只是其中一部分，架构图：
1.2 版本
SpringCloud的版本命名比较特殊，因为它不是一个组件，而是许多组件的集合，它的命名是以A到Z的为首字母的一些单词组成：
我们在项目中，会是以Finchley的版本。
其中包含的组件，也都有各自的版本，如下表：
| Component | Edgware.SR3 | Finchley.RC1 | Finchley.BUILD-SNAPSHOT |
|---|---|---|---|
| spring-cloud-aws | 1.2.2.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-bus | 1.3.2.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-cli | 1.4.1.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-commons | 1.3.3.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-contract | 1.2.4.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-config | 1.4.3.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-netflix | 1.4.4.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-security | 1.2.2.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-cloudfoundry | 1.1.1.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-consul | 1.3.3.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-sleuth | 1.3.3.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-stream | Ditmars.SR3 | Elmhurst.RELEASE | Elmhurst.BUILD-SNAPSHOT |
| spring-cloud-zookeeper | 1.2.1.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-boot | 1.5.10.RELEASE | 2.0.1.RELEASE | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-task | 1.2.2.RELEASE | 2.0.0.RC1 | 2.0.0.RELEASE |
| spring-cloud-vault | 1.1.0.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-gateway | 1.0.1.RELEASE | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
| spring-cloud-openfeign | 2.0.0.RC1 | 2.0.0.BUILD-SNAPSHOT |
接下来，我们就一一学习 SpringCloud 中的重要组件。
2 微服务场景模拟
首先，我们需要模拟一个服务调用的场景。方便后面学习微服务架构。
2.1 创建 springcloud-study 父工程
2.1.1 Spring 工程创建
（1）我们新建一个 maven 的聚合项目: springcloud-study。
（2）填写项目信息：
（3）填写项目位置：
（4）生成的项目结构：
2.1.2 父工程引入依赖：
<?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>com.zc.sc</groupId>
<artifactId>springcloud-study</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.8.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>
<spring-cloud.version>Greenwich.SR2</spring-cloud.version>
<mapper.starter.version>2.0.3</mapper.starter.version>
<mysql.version>5.1.32</mysql.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- 引入sprngcloud的pom -->
<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>
<!-- mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<!---->
<dependencies>
<!--lombok-->
<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>
</project>
这里已经对大部分要用到的依赖进行版本管理，后续使用非常快捷！
2.2 服务提供者
新建一个 module，对外提供查询用户的服务。
2.2.1 创建 user-service module
（1）选中父工程：springcloud-study，
（2）model 选择为 maven 项目：
（3）填写 module 信息：
（4）指定存储位置：
（5）项目结构：
2.2.2 user-service 依赖
<?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">
<parent>
<artifactId>springcloud-study</artifactId>
<groupId>com.zc.sc</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>user-service</artifactId>
<!--添加依赖-->
<dependencies>
<!--web-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mapper启动器 -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
</dependency>
</dependencies>
</project>
2.2.3 编写 user-service 中代码
（1）属性文件，这里我们采用 yaml 语法，而不是 properties：
创建 spring 属性文件 application.yaml ：
server:
port: 8081
servlet:
context-path: /us #上下文的路径
spring:
datasource:
username: root
url: jdbc:mysql://localhost:3306/db_sb?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=false
password: root
driver-class-name: com.mysql.jdbc.Driver
mybatis:
type-aliases-package: com.zc.pojo #扫描实体类包
configuration:
map-underscore-to-camel-case: true #驼峰转换
其中数据库表的创建及测试数据在本人博客：SpringBoot 来玩转以前的 SSM 中。
（2）启动类 com.zc.sc.CloudStudyApplication :
package com.zc.sc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;
/**
* @作者： zc
* @时间： 2021/2/3 10:20
* @描述： 启动类
*/
@SpringBootApplication
@MapperScan(value = {"com.zc.sc.mapper"})
public class CloudStudyApplication {
public static void main(String[] args) {
SpringApplication.run(CloudStudyApplication.class, args);
}
}
（3）实体类 com.zc.sc.pojo.User ：
package com.zc.sc.pojo;
import lombok.Data;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.sql.Date;
/**
* @作者： zc
* @时间： 2021/2/3 10:24
* @描述： 实体类
*/
@Table(name = "user_info")
@Data
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username; // 用户账户名
private String password; // 用户密码
private String realname; // 用户真实名
private String birthday; // 生日
private Long gender; // 性别：0->男，1->女
private String createtime; // 创建时间
private String updatetime; // 更新时间
}
（4）映射接口类 com.zc.sc.mapper.UserMapper ：
package com.zc.sc.mapper;
import com.zc.sc.pojo.User;
import tk.mybatis.mapper.common.Mapper;
/**
* @作者： zc
* @时间： 2021/2/3 10:31
* @描述： 映射接口类
*/
public interface UserMapper extends Mapper<User> {
}
（5）服务接口类 com.zc.sc.service.UserService ：
package com.zc.sc.service;
import com.zc.sc.pojo.User;
/**
* @作者： zc
* @时间： 2021/2/3 10:34
* @描述： 服务层接口类
*/
public interface UserService {
public User queryById(Long id);
}
（5）服务接口实现类 com.zc.sc.service.impl.UserServiceImpl：
package com.zc.sc.service.impl;
import com.zc.sc.mapper.UserMapper;
import com.zc.sc.pojo.User;
import com.zc.sc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @作者： zc
* @时间： 2021/2/3 10:36
* @描述： 服务层接口实现类
*/
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
public User queryById(Long id) {
return userMapper.selectByPrimaryKey(id);
}
}
（6）控制层，添加一个对外查询的接口 com.zc.sc.controller.UserController：
package com.zc.sc.controller;
import com.zc.sc.pojo.User;
import com.zc.sc.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
/**
* @作者： zc
* @时间： 2021/2/3 10:41
* @描述： 控制层，添加一个对外查询的接口
*/
@Controller
@RequestMapping(value = "user")
public class UserController {
@Autowired
private UserService userService;
@RequestMapping("/{id}")
@ResponseBody
public User selectUser(@PathVariable("id") Long id) {
User user = userService.queryById(id);
return user;
}
}
如果 private UserService userService 变红：
（7）项目结构：
2.2.4 启动并测试
启动项目，访问接口：http://localhost:8081/us/user/1
2.3 服务调用者
2.3.1 创建 consumer-service 工程
与上面创建 user-service 类似，这里不再赘述，需要注意的是，我们调用 user-service 的功能，因此 consumer-service 工程不需要 mybatis 相关依赖了。
<?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">
<parent>
<artifactId>springcloud-study</artifactId>
<groupId>com.zc.sc</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>consumer-service</artifactId>
<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>
</dependency>
</dependencies>
</project>
2.3.2 编写 consumer-service 中代码
（1）首先创建一个启动类，在启动类中注册 RestTemplate：
package com.zc.sc;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
/**
* @作者： zc
* @时间： 2021/2/3 11:07
* @描述： 启动类，注册 spring RestTemplate
*/
@SpringBootApplication
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class, args);
}
//使用 HttpClient 或者 urlConnection 进行远程访问
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
（2）再次编写实体类 ConsumerUser ：
package com.zc.sc.pojo;
import lombok.Data;
@Data
public class ConsumerUser {
private Long id;
private String username; // 用户账户名
private String password; // 用户密码
private String realname; // 用户真实名
private String birthday; // 生日
private Long gender; // 性别：0->男，1->女
private String createtime; // 创建时间
private String updatetime; // 更新时间
}
（3）然后编写 ConsumerUserDao ，注意，这里不是调用 mapper 查数据库，而是通过 RestTemplate 远程查询 user-service 中的接口：
package com.zc.sc.dao;
import com.zc.sc.pojo.ConsumerUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
/**
* @作者： zc
* @时间： 2021/2/3 11:14
* @描述： 通过 RestTemplate 远程查询 user-service 中的接口
*/
@Component
public class ConsumerUserDao {
@Autowired
private RestTemplate restTemplate;
public ConsumerUser queryUserByIdOne(Long id){
String url = "http://localhost:8081/us/user/" + id;
return this.restTemplate.getForObject(url, ConsumerUser.class);
}
}
（4）然后编写 ConsumerUserService ，循环查询 ConsumerUserDao 信息：
package com.zc.sc.service;
import com.zc.sc.dao.ConsumerUserDao;
import com.zc.sc.pojo.ConsumerUser;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* @作者： zc
* @时间： 2021/2/3 11:18
* @描述： 循环查询 UserDao 信息
*/
@Service
public class ConsumerUserService {
@Autowired
private ConsumerUserDao consumerUserDao;
public ConsumerUser queryUserByIdAll(Long id){
return this.consumerUserDao.queryUserByIdOne(id);
}
}
（5）编写 controller：
package com.zc.sc.controller;
import com.zc.sc.pojo.ConsumerUser;
import com.zc.sc.service.ConsumerUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* @作者： zc
* @时间： 2021/2/3 11:21
* @描述： Controller
*/
@RestController // 相当于 @Controller 和 @ResponseBody
@RequestMapping("consumer")
public class ConsumerController {
@Autowired
private ConsumerUserService consumerUserService;
@GetMapping("{id}")
public ConsumerUser queryUserById(@PathVariable("id") Long id) {
return this.consumerUserService.queryUserByIdAll(id);
}
}
（6）application.yaml：
server:
port: 8082
servlet:
context-path: /cs
2.3.3 启动测试：
先启动 user-service 工程项目。
因为我们 consumer-service 工程项目配置端口是 8082，我们访问：http://localhost:8082/cs/consumer/1
一个简单的远程服务调用案例就实现了。
2.4 有没有问题？
简单回顾一下，刚才我们写了什么：
A、user-service：一个提供根据 id 查询用户的微服务；
B、consumer-service：一个服务调用者，通过 RestTemplate 远程调用 user-service；
流程如下：
存在什么问题？
A、在 consumer 中，我们把 url 地址硬编码到了代码中，不方便后期维护；
B、consumer 需要记忆 user-service 的地址，如果出现变更，可能得不到通知，地址将失效；
C、consumer 不清楚 user-service 的状态，服务宕机也不知道；
D、user-service 只有 1 台服务，不具备高可用性；
E、即便 user-service 形成集群，consumer 还需自己实现负载均衡。
其实上面说的问题，概括一下就是分布式服务必然要面临的问题：
A、服务管理；
B、如何自动注册和发现；
C、如何实现状态监管；
D、如何实现动态路由；
E、服务如何实现负载均衡；
F、服务如何解决容灾问题；
G、服务如何实现统一配置。
以上的问题，我们都将在 SpringCloud 中得到答案。
3 项目地址
项目后期时常更新内容：
springcloud-study
扫一扫
7225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
