SpringCloud 学习笔记2

Http客户端工具

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

• HttpClient
• OKHttp
• URLConnection

HttpClient

介绍

HttpClient是Apache公司的产品，是Http Components下的一个组件。

特点：

• 基于标准、纯净的Java语言。实现了Http1.0和Http1.1
• 以可扩展的面向对象的结构实现了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）
• 支持HTTPS协议。
• 通过Http代理建立透明的连接。
• 自动处理Set-Cookie中的Cookie。

使用

创建一个工程，名字为：http-demo

配置 pom.xml 文件：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.1.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</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.apache.httpcomponents</groupId>
		<artifactId>httpclient</artifactId>
		<version>4.5.1</version>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

编写 SpringBoot 启动类：

@SpringBootApplication
public class HttpDemoApplication {

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

}

发起get请求：

@Test
public void testGet() throws IOException {
    HttpGet request = new HttpGet("http://www.baidu.com");
    String response = this.httpClient.execute(request, new BasicResponseHandler());
    System.out.println(response);
}

发起Post请求：

@Test
public void testPost() throws IOException {
    HttpGet request = new HttpGet("http://www.oschina.net/");
    request.setHeader("User-Agent",
            "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36");
    String response = this.httpClient.execute(request, new BasicResponseHandler());
    System.out.println(response);
}

假如有如下一个链接 http://localhost/hello，即自己的另外一个项目，我们能否通过该链接获取另一个项目的响应结果呢？答案是可以的。如： http://localhost/hello 返回的是一个 User 对象

@Test
public void testGetPojo() throws IOException {
    HttpGet request = new HttpGet("http://localhost/hello");
    String response = this.httpClient.execute(request, new BasicResponseHandler());
    System.out.println(response);
}

我们实际得到的是一个json字符串：

{
  "id":13,
  "userName":"LeeHua",
  "password":"123456",
  "name":"李华",
  "age":21,
  "sex":1,
  "birthday":"1998-10-24T16:00:00.000+0000",
  "created":"2018-08-30T16:00:00.000+0000",
  "updated":"2020-09-03T16:00:00.000+0000",
  "note":"测试"
}

如果想要得到对象，我们还需要手动进行Json反序列化，这一点比较麻烦。

Json转换工具

HttpClient请求数据后是json字符串，需要我们自己把Json字符串反序列化为对象，我们会使用JacksonJson工具来实现。

JacksonJson是SpringMVC内置的json处理工具，其中有一个ObjectMapper类，可以方便的实现对json的处理。

对象转json

将 User 对象 转化为 Json 字符串

// json处理工具
private ObjectMapper mapper = new ObjectMapper();
// User 对象
private User user = new User();
@Test
public void testJson() throws JsonProcessingException {
    User user = new User();
    user.setId(13L);
    user.setAge(21);
    user.setName("李华");
    user.setUserName("LeeHua");
    // 序列化
    String json = mapper.writeValueAsString(user);
    System.out.println("json = " + json);
}

结果：

json = {"id":13,"userName":"LeeHua","password":null,"name":"李华","age":21,"sex":null,"birthday":null,"created":null,"updated":null,"note":null}

json转普通对象

将 Json 字符串 转化为 User 对象

// json处理工具
private ObjectMapper mapper = new ObjectMapper();
// User 对象
private User user = new User();
@Test
public void testJsonToObject() throws IOException {
    user.setId(13L);
    user.setAge(21);
    user.setName("李华");
    user.setUserName("LeeHua");
    // 序列化
    String json = mapper.writeValueAsString(user);
    // 反序列化，接收两个参数：json数据，反序列化的目标类字节码
    User result = mapper.readValue(json, User.class);
    System.out.println("Object = " + result);
}

结果：

Object = User [id=13, userName=LeeHua, password=null, name=李华, age=21, sex=null, birthday=null, created=null, updated=null, note=null]

json转集合

json转集合比较麻烦，因为你无法同时把集合的class和元素的class同时传递到一个参数。

因此Jackson做了一个类型工厂，用来解决这个问题：

// json处理工具
private ObjectMapper mapper = new ObjectMapper();
// User 对象
private User user = new User();
@Test
public void testJson() throws IOException {
    user.setId(13L);
    user.setAge(21);
    user.setName("李华");
    user.setUserName("LeeHua");

    // 序列化,得到对象集合的json字符串
    String json = mapper.writeValueAsString(Arrays.asList(user, user));

    // 反序列化，接收两个参数：json数据，反序列化的目标类字节码
    List<User> users = mapper.readValue(json, mapper.getTypeFactory().constructCollectionType(List.class, User.class));
    for (User u : users) {
        System.out.println("u = " + u);
    }
    System.out.println(users);
}

结果：

json转任意复杂类型

当对象泛型关系复杂时，类型工厂也不好使了。这个时候Jackson提供了TypeReference来接收类型泛型，然后底层通过反射来获取泛型上的具体类型。实现数据转换。

@Test
public void testJsonToType() throws IOException {
    user.setId(13L);
    user.setAge(21);
    user.setName("李华");
    user.setUserName("LeeHua");

    // 序列化,得到对象集合的json字符串
    String json = mapper.writeValueAsString(Arrays.asList(user, user));

    // 反序列化，接收两个参数：json数据，反序列化的目标类字节码
    List<User> users = mapper.readValue(json, new TypeReference<List<User>>(){});
    for (User u : users) {
        System.out.println("u = " + u);
    }
}

结果：

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() {
        // 默认的RestTemplate，底层是走JDK的URLConnection方式。
        return new RestTemplate();
    }
}

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

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

    @Autowired
    private RestTemplate restTemplate;

    @Test
    public void httpGet() {
        User user = this.restTemplate.getForObject("http://localhost/hello", User.class);
        System.out.println(user);
    }

}

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

学习完了Http客户端工具，接下来就可以正式学习微服务了。

初始SpringCloud

微服务是一种架构方式，最终肯定需要技术架构去实施。

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

• 后台硬：作为Spring家族的一员，有整个Spring全家桶靠山，背景十分强大。
• 技术强：Spring作为Java领域的前辈，可以说是功力深厚。有强力的技术团队支撑，一般人还真比不了
• 群众基础好：可以说大多数程序员的成长都伴随着Spring框架，试问：现在有几家公司开发不用Spring？SpringCloud与Spring的各个框架无缝整合，对大家来说一切都是熟悉的配方，熟悉的味道。
• 使用方便：相信大家都体会到了SpringBoot给我们开发带来的便利，而SpringCloud完全支持SpringBoot的开发，用很少的配置就能完成微服务框架的搭建

SpringCloud 简介

SpringCloud是Spring旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/

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

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

netflix

• Eureka：注册中心
• Zuul：服务网关
• Ribbon：负载均衡
• Feign：服务调用
• Hystix：熔断器

以上只是其中一部分，架构图：

SpringCloud 版本

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中的重要组件。

# 微服务场景模拟

首先，我们需要模拟一个服务调用的场景。方便后面学习微服务架构

服务提供者

我们新建一个项目，对外提供查询用户的服务。

创建父工程

父工程中引入依赖：

<packaging>pom</packaging>

<name>SpringCloudDemo</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>
    <spring-cloud.version>Finchley.SR1</spring-cloud.version>
    <mapper.starter.version>2.0.3</mapper.starter.version>
    <mysql.version>5.1.32</mysql.version>
    <pageHelper.starter.version>1.2.5</pageHelper.starter.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- SpringCloud -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
        </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>
    <dependency>
        <artifactId>lombok</artifactId>
        <groupId>org.projectlombok</groupId>
    </dependency>
</dependencies>

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

创建一个 Module

进入父工程，创建一个子工程：

选择 Maven 工程：

填写 Module 信息：

注意：子工程目录在父工程的目录下

这个时候父工程 pom.xml 配置文件会自动引入如下内容：

<modules>
    <module>UserService</module>
</modules>

子工程依赖：

<?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>SpringCloudDemo</artifactId>
        <groupId>pers.stringbug</groupId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>UserService</artifactId>

    <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>
</project>

编写代码

属性文件，采用 yaml 语法，而不是 properties：

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/Test
    username: root
    password: 123456
    hikari:
      maximum-pool-size: 20
      minimum-idle: 10
mybatis:
  type-aliases-package: pers.stringbug.userservice.pojo

启动类：

@SpringBootApplication
@MapperScan(value = "pers.stringbug.userservice.mapper")
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class);
    }
}

User 实体类：

@Table(name = "tb_user")
@Data
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;
    /** 备注 */
    private String note;
}

mapper：

import org.apache.ibatis.annotations.Mapper;
import pers.stringbug.userservice.pojo.User;

@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}

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

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

    @Autowired
    private UserService userService;

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

项目结构：

启动并测试

启动项目，访问接口：http://localhost:8081/user/13

服务器调用者

创建工程

与上面创建子工程类似，这里也创建一个 Maven 工程，名字为 ConsumerDemo

子工程 ConsumerDemo 引入依赖：

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

编写代码

创建启动类，并在启动类中注册 RestTemplate ：

@SpringBootApplication
public class ConsumerApplication {

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

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

User 实体类：

@Data
public class User implements Serializable {
    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;
    /** 备注 */
    private String note;
}

编写 controller，直接在 controller 中调用 RestTemplate，远程访问 UserService 的服务接口：

/** 对外查询的接口 */
@RestController
@RequestMapping(value = "consumer")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

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

启动测试

因为我们没有配置端口，那么默认就是8080，我们访问：http://localhost:8080/consume/13

一个简单的远程服务调用案例就实现了。

项目目录

该子项目的目录结构如下：

有没有问题？

简单回顾一下，刚才我们写了什么：

• UseService：一个提供根据id查询用户的微服务
• ConsumerDemo：一个服务调用者，通过RestTemplate远程调用UseService

流程如下
存在什么问题？

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

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

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