zoukankan      html  css  js  c++  java
  • SpringCloud 学习笔记2

    Http客户端工具

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

    • HttpClient
    • OKHttp
    • URLConnection

    HttpClient

    介绍

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

    20200818133827

    特点:

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

    使用

    创建一个工程,名字为:http-demo

    20200818140918

    配置 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);
    }
    

    结果:

    20200818174002

    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);
        }
    }
    

    结果:

    20200818174002

    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会自动发起请求,接收响应,并且帮我们对响应结果进行反序列化。

    20200818201556

    学习完了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:熔断器

    以上只是其中一部分,架构图:

    20200818203547

    SpringCloud 版本

    SpringCloud的版本命名比较特殊,因为它不是一个组件,而是许多组件的集合,它的命名是以A到Z的为首字母的一些单词组成:

    20200818203937

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


    # 微服务场景模拟

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


    服务提供者

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


    创建父工程

    20200818213939 20200818214042

    父工程中引入依赖:

    <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

    进入父工程,创建一个子工程:

    20200818214801

    选择 Maven 工程:

    20200818214920

    填写 Module 信息:

    20200818215045

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


    这个时候父工程 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);
        }
    }
    

    项目结构:

    20200818224337

    启动并测试

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

    20200818231149

    服务器调用者

    创建工程

    与上面创建子工程类似,这里也创建一个 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

    20200818234442

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


    项目目录

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

    20200819002012

    有没有问题?

    简单回顾一下,刚才我们写了什么:

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

    流程如下
    存在什么问题?

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

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

    • 服务管理
      • 如何自动注册和发现
      • 如何实现状态监管
      • 如何实现动态路由
    • 服务如何实现负载均衡
    • 服务如何解决容灾问题
    • 服务如何实现统一配置
    Good Good Write Bug, Day Day Up
  • 相关阅读:
    Multipatch的Z值单位问题(三维坐标系和三维坐标转换,极坐标)
    ArcGIS城市地下管网纵横断面分析设计与实现&三维分析之DEM横断面 纵断面 剖面
    ArcScene按照属性进行拉伸Extrusion
    Python 字符串长度和字符串截取函数
    ArcGIS中Interpolater Polygon to Multipatch(3D)用法及原理——多边形转面片
    arcgis删除重复的线段
    ArcGIS如何判断直线图层的两个端点的编码是否与点图层的Name字段是否相等?
    使用ArcEngine创建Multipatch图形
    ArcGIS和VB联合开发
    ArcGIS根据属性创建3D对象
  • 原文地址:https://www.cnblogs.com/liyihua/p/14482615.html
Copyright © 2011-2022 走看看