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 还需自己实现负载均衡

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

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

posted @ 2021-03-04 19:54 LeeHua 阅读(166) 评论(0) 编辑收藏举报

刷新页面返回顶部

Lee Hua's Blog

热爱编程 -- 写Bug

SpringCloud 学习笔记2

Http客户端工具

HttpClient

介绍

使用

Json转换工具

对象转json

json转普通对象

json转集合

json转任意复杂类型

Spring的RestTemplate

初始SpringCloud

SpringCloud 简介

SpringCloud 版本

服务提供者

创建父工程

创建一个 Module

编写代码

启动并测试

服务器调用者

创建工程

编写代码

启动测试

项目目录

有没有问题？

公告