Spring Cloud微服务架构基础内容？看这一篇就够啦！

Spring Cloud微服务架构基础内容？看这一篇就够啦！

昨天讲完架构的演变迭代，以及微服务的各种服务传输发送的方式，由于个人的学习因素，我还是主要介绍微服务中使用Spring家族的内容。

1、Spring Cloud简介

Spring Cloud是Spring旗下的项目，其中Spring最擅长的就是集成，即一系列框架的有序结合。它会将很多非常棒的框架拿过来进行集成到自身的项目中去。

所以同理，Spring Cloud就是这样，将现在非常流行的技术整合到一起，实现了诸如：配置管理，服务发现，智能路 由，负载均衡，熔断器，控制总线，集群状态等等功能。

当然这些内容都是微服务后续内容所要提及的内容，所以这篇内容算是总的集合，为后续的内容打下理论基础。

1.1 组件架构

在这里我以个人的认识来展示Spring Cloud所要表达的基础架构部分，如下图：

附加(个人理解)：首先用户将请求转发到网关通过调用网关传达服务，通过其中负载均衡方法(Ribbon)，较为均衡的调用项目服务。在项目重构或者构建微服务时，势必要先到Eureka注册以完成——“什么样的服务需求来找什么样的服务”，并且后续进行服务调用。项目的配置服务甚至可以以远程Git创建仓库放置配置文件的方式，来完成项目的配置。

当然后面具体开发才能更详细的说明，这里不多啰嗦呵呵。

1.2 Spring Cloud版本

由于作者更加喜欢使用IDEA创建Maven项目开发，这势必要考虑打包依赖的管理部分。

有意思的是，Spring Cloud是以伦敦地铁站名字命名，这里网站找到的对应表整理如下：

rELEASE tRAIN	Boot Version
Hoxton	2.2.x
Greenwich	2.1.x
Finchley	2.0.x
Edgware	1.5.x
Dalston	1.5.x

2、微服务场景模拟

这里是微服务场景的模拟，并不真正涉及到微服务本身的整体内容，所以看客老爷们就稍微浏览即可。

2.1 创建父工程

如果按照上图架构所表示微服务模拟，那么就要创建若干个微服务。这时候就要先创建父工程打包统一管理子模块的依赖版本

如下展示我的pom文件

<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.0modelVersion>

    <groupId>com.xafgroupId>
    <artifactId>spring-cloud-projectartifactId>
    <version>1.0-SNAPSHOTversion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.5.RELEASEversion>
        <relativePath/>
    parent>
    <properties>
        <java.version>1.8java.version>
        <spring-cloud.version>Greenwich.SR1spring-cloud.version>
        <mapper.starter.version>2.1.5mapper.starter.version>
        <mysql.version>5.1.46mysql.version>
    properties>
    <dependencyManagement>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-dependenciesartifactId>
            <version>${spring-cloud.version}version>
            <type>pomtype>
            <scope>importscope>
        dependency>
        
        <dependency>
            <groupId>tk.mybatisgroupId>
            <artifactId>mapper-spring-boot-starterartifactId>
            <version>${mapper.starter.version}version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>${mysql.version}version>
        dependency>
    dependencies>
    dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

首先，我使用的是spring boot的2.1.x版本，就要使用greenwich(格林威治)版本的spring cloud。

其次，使用pom进行聚合打包。

2.2 创建数据库

这里我创建的数据表如下：

2.3 服务提供者(user-service)

在父工程选中创建模块后，添加依赖如下：

    
        spring-cloud-project
        com.xaf
        1.0-SNAPSHOT
    
    4.0.0

    user-service
    
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            tk.mybatis
            mapper-spring-boot-starter
        
        
        
            mysql
            mysql-connector-java
        
    

然后进行配置文件：

server:
  port: 9000
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/user
    username: root
    password: root
mybatis:
  type-aliases-package: com.xaf.pojo

启动类：

@SpringBootApplication
@MapperScan("com.xaf.mapper")
public class UserApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserApplication.class,args);
    }
}

实体类：

@Data
@Table(name = "tb_user")
public class User{
     
    // id
    @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接口：

public interface UserMapper extends Mapper<User> {
     
}

service层：

@Service
public class UserService {
     
    @Autowired
    private UserMapper userMapper;
    public User queryById(long id){
     
        return  this.userMapper.selectByPrimaryKey(id);
    }
}

controller层：

@RestController
@RequestMapping("/user")
public class UserController {
     
    @Autowired
    private UserService userService;
    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
     
        return userService.queryById(id);
    }
}

自此所有的内容目录应该如下所示：

最后的网页呈现效果如下：

2.4 服务调用者(consumer)

在完成了服务创建者的内容后，我们来尝试创建服务的调用者。这里具体的话就是指的是消费者或者客户了。

pom文件打包：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
dependencies>

实体类如下：

@Data
public class User {
     
	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层如下：

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
     
	@Autowired
	private RestTemplate restTemplate;
	@GetMapping("/{id}")
	public User queryById(@PathVariable Long id){
     
		String url = "HTTP://localhost:9000/user/" + id;
		return restTemplate.getForObject(url, User.class);
	}
}

到这里整个微服务模拟已经写完了。

然后服务调用者启动时应该同时打开服务提供者，后续模拟展示如下：

3、Spring Cloud模拟总结

简单回顾前面的模拟过程：

user-service(服务提供者)：对外提供了查询用户的接口。

consumer(服务调用者):：通过RestTemplate访问提供者的接口，完成通过id查询用户数据。

所以在基于spring boot构建的项目中，模拟过程存在很多问题：

1. 首先在consumer很直接的进行硬编码，在真正开发上肯定不利于代码维护。
2. 硬编码后，还要记住服务提供方，即user-service的接口地址，如果有出现端口变更等情况还要对consumer进行变更，否则地址会失效。
3. 而服务提供者user-service在进行服务时，只能出现1台服务；即使能够形成集群结构，也要通过自己实现负载均衡算法完成高可用性的目标。
4. consumer完全不知道user-service的当前状态(除了user-service未启动拒绝连接以外)，完全没有服务提供方的详情。

所以基于以上内容，我们来讲一下面向服务架构(分布式架构)所要面临的问题，在如下都要完成实现：

• 服务的基本管理

  1、自动发现——即自动的注册服务

  2、实现动态的状态管理

  3、实现动态路由——不产生硬编码

• 服务器实现负载均衡——完成高可用

• 服务器解决统一配置问题

• 服务器解决…

当然换句话说，也就是我后续会讲到spring cloud如何实现以上问题。后续的部分我会继续基于这些问题完成笔记的内容和分享。谢谢大家的阅读，还请大佬批评指正！