SpringCloud学习记录（二）—— Spring Cloud入门（模拟服务之间的调用）

---

前言

本篇文章，记录的是Spring Cloud 的入门案例。这并不是一个微服务，只是模拟服务之间的调用。
文章代码路径

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、简介

1.1 介绍

• Spring Cloud是Spring旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/
• Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。
• Spring Cloud将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路
  由，负载均衡，熔断器，控制总线，集群状态等等功能。
• 主要组件包括（部分）：
  • Netflix
    1. Eureka：注册中心
    2. Zuul：服务网关
    3. Ribbon：负载均衡
    4. Feign：服务调用
    5. Hystrix：熔断器

1.2 版本

Spring Cloud的版本命名比较特殊，它不是一个组件，而是许多组件的集合，它的命名是以A到Z为首字母的一些单词组成(其实是伦敦地铁站的名字)：

1.3 SpringCloud和SpringBoot版本对应关系

SpringCloud版本	SpringBoot版本
Hoxton	2.2.x
Greenwich	2.1.x
Finchley	2.0.x
Edgware	1.5.x
Dalston	1.5.x

二、入门案例

入门案例模拟一个服务调用的场景，帮助后面的理解

2.1 父工程

微服务中需要同时创建多个项目，为了方便课堂演示，先创建一个父工程，后续的工程都以这个工程为父，使用Maven的聚合和继承。统一管理子工程的版本和配置。

2.1.1 建立工程

点击“File–>new–>project”，创建项目：

然后选自Maven项目，点击下一步（Next）

然后填写项目名、检查存储位置、填写坐标信息；

创建的项目如下，其中的src目录，我们不会使用。具体的代码编写方式，会在后面介绍；

2.1.2 pom.xml文件

• 因为我的代码，服务的提供者和消费者都创建好了，所以我的父工程里面有modules，新建的项目是没有的，当你的子工程创建好，并且设置成父工程的子工程之后，就会有了。
• 父工程的依赖通过dependencyManagement管理，表示，依赖已经存在，但是并不会直接导入，需要在使用的子项目中按照正常方式导入，项目才会引入。采用的版本，就是父工程设定的版本。

<?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.kaikeba</groupId>
    <artifactId>spring-cloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
        <module>consumer-service</module>
    </modules>
    <packaging>pom</packaging>
    <!-- springboot -->
    <parent>
        <artifactId>spring-boot-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.5.RELEASE</version>
        <relativePath/>
    </parent>
    
    <!-- 版本管理 -->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud-version>Greenwich.SR1</spring-cloud-version>
        <tk-mybatis.version>2.1.5</tk-mybatis.version>
        <mysql-connection-version>8.0.25</mysql-connection-version>
    </properties>

   <dependencyManagement>
       <dependencies>
           <!-- spring cloud-->
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>${spring-cloud-version}</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <!-- tk mybatis -->
           <dependency>
               <groupId>tk.mybatis</groupId>
               <artifactId>mapper-spring-boot-starter</artifactId>
               <version>2.1.5</version>
           </dependency>

           <!-- mysql驱动 -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>${mysql-connection-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 服务提供者

我们通过一个user当做服务的提供者

2.2.1 数据库表

我们新建一个tb_user表，

DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `user_name` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  `age` int DEFAULT NULL,
  `sex` int DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  `created` date DEFAULT NULL,
  `updated` date DEFAULT NULL,
  `note` varchar(2000) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

2.2.2 java代码

Bean：User.java

package com.kaikeba.entity;

import lombok.Data;

import javax.persistence.*;
import java.util.Date;

@Data
@Table(name = "tb_user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    // 用户名
    @Column(name = "user_name")
    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;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", created=" + created +
                ", updated=" + updated +
                ", note='" + note + '\'' +
                '}';
    }
}

UserMapper：使用tk-mybatis的内置查询语句

package com.kaikeba.mapper;

import com.kaikeba.entity.User;
import org.apache.ibatis.annotations.Mapper;

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

UserService

package com.kaikeba.service;

import com.kaikeba.entity.User;

import java.util.List;

public interface UserService {
    /**
     * 查询全部
     */
    List<User> findAll();
}

UserServiceImpl

package com.kaikeba.service.impl;

import com.kaikeba.entity.User;
import com.kaikeba.mapper.UserMapper;
import com.kaikeba.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;

    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

UserController

package com.kaikeba.contoroller;

import com.kaikeba.entity.User;
import com.kaikeba.service.UserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

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

    @Resource
    private UserService userService;

    @GetMapping("/all")
    public List<User> searchAll() {
        return userService.findAll();
    }
}

启动类UserServiceApplication

package com.kaikeba;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

/**
 * 模拟服务的调用
 */
@SpringBootApplication
@MapperScan("com.kaikeba.mapper")
public class UserServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class);
    }
}

配置文件application.yml

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/springcloud
    username: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    password: root

mybatis:
  type-aliases-package: com.kaikeba.entity

2.3 服务调用者

2.3.1 pom文件

<?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>spring-cloud</artifactId>
        <groupId>com.kaikeba</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>
    </dependencies>

</project>

application.yml

server:
  port: 8081

User.java
调用者这里的User是为了接收转换远程调用结果数据的。

package com.kaikeba.entity;

import lombok.Data;

import java.util.Date;

@Data
public class User {
    private Integer 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;

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                ", birthday=" + birthday +
                ", created=" + created +
                ", updated=" + updated +
                ", note='" + note + '\'' +
                '}';
    }
}

调用者的UserController

package com.kaikeba.controller;

import com.kaikeba.entity.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.List;

@RestController
@RequestMapping("/con")
public class UserController {

    @Resource
    private RestTemplate restTemplate;

    @RequestMapping("/batch")
    public List<User> searchAll() {
        String url = "http://localhost:8080/user/all";
        List<User> userList = restTemplate.getForObject(url, List.class);
        return userList;
    }
}

启动器ConsumerServiceApplication

package com.kaikeba;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

    /**
     * 用来进行远程调用的结果处理
     */
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

2.4 结果调用

2.4.1 UserService结果

这是通过UserService自己对外开放的接口访问到的数据：

2.4.1 ConsumerService结果

代码如下，

2.4 总结

1. 这里的项目不是微服务，只是利用Spring提供的RestTemplate模拟了服务之间的远程调用；
2. 关于RestTemplatee模板工具类，对基于HTTP的客户端进行了封装，并且实现了对象与json的序列化和反序列化，非常方便。RestTemplate并没有限定HTTP的客户端类型，而是进行了抽象，目前常用的3种都有支持：HttpClient、OkHttp和DK原生的URLConnection（默认的）。

2.5 当前模式的问题

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

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

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

因此我们在SpringCloud中会学习如何改进上书问题。