Spring Cloud基本介绍，环境搭建

1.微服务基础理论

Spring Cloud中文文档：https://www.springcloud.cc

1.1、什么是微服务?

微服务是一种用于构建应用的架构方案。微服务是松散耦合的分布式架构框架，因此一个团队的更改不会破坏整个应用。使用微服务的好处是，开发团队能够快速构建应用的新组件，以满足不断变化的业务需求

1.2、微服务之间是如何独立通讯的?

同步：RPC ,REST等。

异步：消息队列，要考虑消息的可靠传输、高性能，以及编程模型的变化等

1.3、SpringCloud和 Dubbo有哪些区别?

一.两者的模块组成：

1、Dubbo主要分为服务注册中心，服务提供者，服务消费者，还有管控中心；

2、相比起Dubbo简单的四个模块，SpringCloud则是一个完整的分布式一站式框架，他有着一样的服务注册中心，服务提供者，服务消费者，管控台，断路器，分布式配置服务，消息总线，以及服务追踪等；

二.在性能上来说 由于Dubbo底层是使用Netty这样的NIO框架，是基于TCP协议传输的，配合以Hession序列化完成RPC。而SpringCloud是基于Http协议+rest接口调用远程过程的，相对来说，Http请求会有更大的报文，占的带宽也会更多。

1.4、SpringBoot和SpringCloud，请你谈谈对他们的理解

**SpringCloud是Spring为微服务架构思想做的一个一站式实现。**从某种程度是可以简单的理解为，微服务是一个概念、一个项目开发的架构思想。SpringCloud是微服务架构的一种java实现。 **SpringCloud是基于SpringBoot的一套实现微服务的框架。**它提供了微服务开发所需的配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、决策竞选、分布式会话和集群状态管理等组件。最重要的是，跟SpringBoot框架一起使用的话，会让你开发微服务架构的云服务非常方便。

1.5、什么是服务熔断?什么是服务降级

在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。

这种牺牲局部，保全整体的措施就叫做熔断。

服务降级是指 当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心业务正常运作或高效运作。说白了，就是尽可能的把系统资源让给优先级高的服务。

1.6、微服务的优缺点是分别是什么?说下你在项目开发中遇到的坑

优点:

（1）每个服务直接足够内聚，代码容易理解

（2）开发效率高，一个服务只做一件事，适合小团队开发

（3）松耦合，有功能意义的服务。

（4）可以用不同语言开发，面向接口编程。

（5）易于第三方集成

（6）微服务只是业务逻辑的代码，不会和HTML,CSS或其他界

（7）可以灵活搭配，连接公共库/连接独立库

缺点:

（1）分布式系统的责任性

（2）多服务运维难度加大。

（3）系统部署依赖，服务间通信成本，数据一致 ，系统集成测试，性能监控。

1.7、你所知道的微服务技术栈有哪些?请列举一二

• 维度(springcloud)
• 服务开发：springboot spring springmvc
• 服务配置与管理:Netfix公司的Archaiusm ,阿里的Diamond
• 服务注册与发现:Eureka,Zookeeper
• 服务调用:Rest RPC gRpc
• 服务熔断器:Hystrix
• 服务负载均衡:Ribbon Nginx
• 服务接口调用:Fegin
• 消息队列:Kafka Rabbitmq activemq
• 服务配置中心管理:SpringCloudConfig
• 服务路由（API网关）Zuul
• 服务监控 Zabbix、Nagios、Metrics、Specatator等
• 全链路追踪 zipkin、Brave、Dapper等
• 服务部署 Docker、OpenStack、Kubernetes等
• 数据流操作开发包 SpringCloud Stream(封装与Redis，Rabbit，Kafka等发送接收消息)
• 事件消息总线:SpringCloud Bus

1.8、eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别?

1、ZooKeeper保证的是CP,Eureka保证的是AP ZooKeeper在选举期间注册服务瘫痪,虽然服务最终会恢复,但是选举期间不可用的 Eureka各个节点是平等关系,只要有一台Eureka就可以保证服务可用,而查询到的数据并不是最新的 自我保护机制会导致 Eureka不再从注册列表移除因长时间没收到心跳而应该过期的服务 Eureka仍然能够接受新服务的注册和查询请求,但是不会被同步到其他节点(高可用) 当网络稳定时,当前实例新的注册信息会被同步到其他节点中(最终一致性) Eureka可以很好的应对因网络故障导致部分节点失去联系的情况,而不会像ZooKeeper一样使得整个注册系统瘫痪 2、ZooKeeper有Leader和Follower角色,Eureka各个节点平等 3、ZooKeeper采用过半数存活原则,Eureka采用自我保护机制解决分区问题 4、Eureka本质上是一个工程,而ZooKeeper只是一个进程

1.9，为什么选择Spring Cloud为微服务架构

(1)，选择依据

整体解决方案和框架成熟度

社区热度

可维护信

学习曲线

(2)当前各大IT公司常用的微服务架构有哪些

阿里:dubbo+HFS

京东:JSF

新浪:Motan

当当网DubboXI

.....

2.微服务概述

2.1 什么是微服务？

微服务(Microservice Architecture) 是近几年流行的一种架构思想，关于它的概念很难一言以蔽之。

就目前而言，对于微服务，业界并没有一个统一的，标准的定义。 但通常而言，微服务架构是一种架构模式，或者说是一种架构风格，它体长将单一的应用程序划分成一组小的服务，每个服务运行在其独立的自己的进程内，服务之间互相协调，互相配置，为用户提供最终价值，服务之间采用轻量级的通信机制(HTTP)互相沟通，每个服务都围绕着具体的业务进行构建，并且能狗被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应该根据业务上下文，选择合适的语言，工具(Maven)对其进行构建，可以有一个非常轻量级的集中式管理来协调这些服务，可以使用不同的语言来编写服务，也可以使用不同的数据存储。

从技术维度角度理解：

• 微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。

2.2微服务与微服务架构

微服务：强调的是服务的大小，它关注的是某一个点，是具体解决某一个问题/提供落地对应服务的一个服务应用，狭义的看，可以看作是IDEA中的一个个微服务工程，或者Moudel。IDEA 工具里面使用Maven开发的一个个独立的小Moudel，它具体是使用SpringBoot开发的一个小模块，专业的事情交给专业的模块来做，一个模块就做着一件事情。强调的是一个个的个体，每个个体完成一个具体的任务或者功能。

微服务架构：一种新的架构形式，Martin Fowler 于2014年提出。

微服务架构是一种架构模式，它体长将单一应用程序划分成一组小的服务，服务之间相互协调，互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制**(如HTTP)互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具(如Maven)**对其进行构建

2. 3微服务的优点和缺点

优点：

单一职责原则；

每个服务足够内聚，足够小，代码容易理解，这样能聚焦一个指定的业务功能或业务需求；

开发简单，开发效率高，一个服务可能就是专一的只干一件事；

微服务能够被小团队单独开发，这个团队只需2-5个开发人员组成；

微服务是松耦合的，是有功能意义的服务，无论是在开发阶段或部署阶段都是独立的；

微服务能使用不同的语言开发；

易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如jenkins，Hudson，bamboo；

微服务易于被一个开发人员理解，修改和维护，这样小团队能够更关注自己的工作成果，无需通过合作才能体现价值；

微服务允许利用和融合最新技术；

微服务只是业务逻辑的代码，不会和HTML，CSS，或其他的界面混合;

每个微服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库；

缺点：

• 开发人员要处理分布式系统的复杂性；
• 多服务运维难度，随着服务的增加，运维的压力也在增大；
• 系统部署依赖问题；
• 服务间通信成本问题；
• 数据一致性问题；
• 系统集成测试问题；
• 性能和监控问题；

2.4 微服务技术栈有那些？

微服务技术条目	落地技术
服务开发	SpringBoot、Spring、SpringMVC等
服务配置与管理	Netfix公司的Archaius、阿里的Diamond等
服务注册与发现	Eureka、Consul、Zookeeper等
服务调用	Rest、PRC、gRPC
服务熔断器	Hystrix、Envoy等
负载均衡	Ribbon、Nginx等
服务接口调用(客户端调用服务的简化工具)	Fegin等
消息队列	Kafka、RabbitMQ、ActiveMQ等
服务配置中心管理	SpringCloudConfig、Chef等
服务路由(API网关)	Zuul等
服务监控	Zabbix、Nagios、Metrics、Specatator等
全链路追踪	Zipkin、Brave、Dapper等
数据流操作开发包	SpringCloud Stream(封装与Redis，Rabbit，Kafka等发送接收消息)
时间消息总栈	SpringCloud Bus
服务部署	Docker、OpenStack、Kubernetes等

2.5 为什么选择SpringCloud作为微服务架构

1. 选型依据

   • 整体解决方案和框架成熟度
   • 社区热度
   • 可维护性
   • 学习曲线

2. 当前各大IT公司用的微服务架构有那些？

   • 阿里：dubbo+HFS
   • 京东：JFS
   • 新浪：Motan
   • 当当网：DubboX
   3. 各微服务框架对比

功能点/服务框架	Netflix/SpringCloud	Motan	gRPC	Thrift	Dubbo/DubboX
功能定位	完整的微服务框架	RPC框架，但整合了ZK或Consul，实现集群环境的基本服务注册/发现	RPC框架	RPC框架	服务框架
支持Rest	是，Ribbon支持多种可插拔的序列化选择	否	否	否	否
支持RPC	否	是（Hession2）	是	是	是
支持多语言	是（Rest形式）？	否	是	是	否
负载均衡	是（服务端zuul+客户端Ribbon），zuul-服务，动态路由，云端负载均衡Eureka（针对中间层服务器）	是（客户端）	否	否	是（客户端）
配置服务	Netfix Archaius，Spring Cloud Config Server集中配置	是（zookeeper提供）	否	否	否
服务调用链监控	是（zuul），zuul提供边缘服务，API网关	否	否	否	否
高可用/容错	是（服务端Hystrix+客户端Ribbon）	是（客户端）	否	否	是（客户端）
典型应用案例	Netflix	Sina	Google	Facebook
社区活跃程度	高	一般	高	一般	2017年后重新开始维护，之前中断了5年
学习难度	中等	低	高	高	低
文档丰富程度	高	一般	一般	一般	高
其他	Spring Cloud Bus为我们的应用程序带来了更多管理端点	支持降级	Netflix内部在开发集成gRPC	IDL定义	实践的公司比较多

微服务的4个核心问题

1．服务很多，客户端该怎么访问?

2．这么多服务?服务之间如何通信?

3．这么多服务?如何治理?

4．服务挂了怎么办?

解决方案：

spring cloud生态! springBoot

1. spring cloud NetFlix一站式解决方案!

​ api网关， zuu1组件

​ Feign --- Httpclinet ---- Http通信方式，同步，

​ 阻塞服务注册发现:Eureka

​ 熔断机制:Hystrix

​ .....

2. Apache Dubbo zookeeper 半自动，需要整合别人的!

​ API:没有，找第三方组件，或者自己实现

​ Dubbo

​ zookeeper

​ 没有:借助 Hystrix

Dubbo这个方案并不完善~

3. spring cloud Alibaba一站式解决方案!更简单

3. SpringCloud入门概述

3.1 SpringCloud是什么？

Spring官网：https://spring.io/

3.2 SpringCloud和SpringBoot的关系

SpringBoot专注于开苏方便的开发单个个体微服务；

SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务，整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路

器、路由、为代理、事件总栈、全局锁、决策竞选、分布式会话等等集成服务；

SpringBoot可以离开SpringCloud独立使用，开发项目，但SpringCloud离不开SpringBoot，属于依赖关系；

SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架；

3.3 Dubbo 和 SpringCloud技术选型

. 分布式+服务治理Dubbo 目前成熟的互联网架构，应用服务化拆分 + 消息中间件

2. Dubbo 和 SpringCloud对比 可以看一下社区活跃度：

https://github.com/dubbo

https://github.com/spring-cloud

对比结果：


最大区别: SpringCloud抛弃了Dubbo的RPC通信，采用的是基于HTTP的REST方式。 严格来说，这两种方式各有优劣。虽然从一定程度上来说，后者牺牲了服务调用的性能，但也避免了上面提到的原生RPC带来的问题。而且REST相比RPC更为灵活，服务提供方和调用方的依赖只依靠一纸契约，不存在代码级别的强依赖，这在强调快速演化的微服务环境下，显得更加合适。

品牌机和组装机的区别

很明显，Spring Cloud的功能比DUBBO更加强大，涵盖面更广，而且作为Spring的拳头项目，它也能够与SpringFramework、Spring Boot、Spring Data、Spring Batch等其他Spring项目完美融合，这些对于微服务而言是至关重要的。使用Dubbo构建的微服务架构就像组装电脑，各环节我们的选择自由度很高，但是最终结果很有可能因为一条内存质量不行就点不亮了，总是让人不怎么放心，但是如果你是一名高手，那这些都不是问题;而SpringCloud就像品牌机，在Spring Source的整合下，做了大量的兼容性测试，保证了机器拥有更高的稳定性，但是如果要在使用非原装组件外的东西，就需要对其基础有足够的了解。

社区支持与更新力度的区别

最为重要的是，DUBBO停止了5年左右的更新，虽然2017.7重启了。对于技术发展的新需求，需要由开发者自行拓展升级（比如当当网弄出了DubboX)，这对于很多想要采用微服务架构的中小软件组织，显然是不太合适的，中小公司没有这么强大的技术能力去修改Dubbo源码+周边的一整套解决方案，并不是每一个公司都有阿里的大牛+真实的线上生产环境测试过。

**总结：**二者解决的问题域不一样：Dubbo的定位是一款RPC框架，而SpringCloud的目标是微服务架构下的一站式解决方案。

3.4 SpringCloud能干嘛？

• Distributed/versioned configuration 分布式/版本控制配置
• Service registration and discovery 服务注册与发现
• Routing 路由Service-to-service calls 服务到服务的调用
• Load balancing 负载均衡配置
• Circuit Breakers 断路器
• Distributed messaging 分布式消息管理
• …

3.5 SpringCloud下载

官网：http://projects.spring.io/spring-cloud/

spring cloud是一个由众多独立子项目组成的大型综合项目，每个子项目有不同的发行节奏，都维护着自己的发布版本号。spring cloud通过一个资源清单BOM(Bi11 of Materials）来管理每个版本的子项目清单。为避免与子项目的发布号混淆，所以没有采用版本号的方式，而是通过命名的方式。

SpringCloud没有采用数字编号的方式命名版本号，而是采用了伦敦地铁站的名称，同时根据字母表的顺序来对应版本时间顺序，比如最早的Realse版本：Angel，第二个Realse版本：Brixton，然后是Camden、Dalston、Edgware，目前最新的是Hoxton SR4 CURRENT GA通用稳定版。

自学参考书：

• SpringCloud Netflix 中文文档：https://springcloud.cc/spring-cloud-netflix.html
• SpringCloud 中文API文档(官方文档翻译版)：https://springcloud.cc/spring-cloud-dalston.html
• SpringCloud中国社区：http://springcloud.cn/
• SpringCloud中文网：https://springcloud.cc

4. SpringCloud Rest学习环境搭建：服务提供者

4.1 介绍

• 我们会使用一个Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务。
• 回顾Spring，SpringMVC，Mybatis等以往学习的知识。
• Maven的分包分模块架构复习。

一个简单的Maven模块结构是这样的：

-- app-parent: 一个父项目(app-parent)聚合了很多子项目(app-util\app-dao\app-web...)
  |-- pom.xml
  |
  |-- app-core
  ||---- pom.xml
  |
  |-- app-web
  ||---- pom.xml
  ......

一个父工程带着多个Moudule子模块

MicroServiceCloud父工程(Project)下初次带着3个子模块(Module)

• microservicecloud-api 【封装的整体entity/接口/公共配置等】
• microservicecloud-consumer-dept-80 【服务消费者】
• microservicecloud-provider-dept-8001【服务提供者】

4.2 SpringCloud版本选择

大版本说明

实际开发版本关系

Spring Boot和Spring Cloud的版本依赖关系官网：https://start.spring.io/actuator/info

新建一个在父项目：SpringCloud，导入依赖

  <!--打包方式  pom-->
    <packaging>pom</packaging>
    <!--配置文件-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
    </properties>

    <!--依赖管理-->
    <dependencyManagement>
        <dependencies>
            <!--导入 spring-cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR12</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--SpringBoot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.12.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--连接数据库-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.27</version>
            </dependency>
            <!--数据源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.7</version>
            </dependency>
            <!--spring Boot启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.2.0</version>
            </dependency>
            <!--日志测试~-->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>1.2.3</version>
            </dependency>
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
            <!--导入小辣椒-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
            <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

新建一个子模块：springcloud-api，存放实体类

导入依赖

    <!--当前的Module自己需要的依赖，如果父依赖中已经配置了版本。这里就不用写了-->
    <dependencies>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

Dept

package com.springcloud.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
/**
 * 部门表实体类
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain=true)//链式写法
public class Dpet implements Serializable {
  private long dpetNo;//部门编号
  private String dname;//部门名称
  //这个数据数存在哪个数据库的字段、微服务，一个服务对应一个数据库，同一个信息可能存在不同的数据库
  private String dbSource;

  public Dpet(String dbSource) {
    this.dbSource = dbSource;
  }
}

新建一个模块：springcloud-provider-dept-8001

导入依赖

<!--由于在父类中依赖了，所以子项目直接拿父项目的即可，不需要导入版本-->
<dependencies>
        <!--要拿的实体类配置api的实体类 Module-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <!--spring boot启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <!--web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

application.yml

server:
  port: 8081
#mybatis配置
mybatis:
  type-aliases-package: com.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#spring 配置
spring:
  application:
    name: springcloud-provider-dept #项目的模块起名字
  datasource:
    url: jdbc:mysql://localhost:3306/db01?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

DeptMapper

package com.springcloud.mapper;
import com.springcloud.pojo.Dpet;//需要手动引入
import org.apache.ibatis.annotations.Mapper;
import javax.annotation.Resource;
import java.util.List;

/**
 * 员工接口
 */
@Resource
@Mapper
public interface DeptMapper {
    /**
     * 新增一个员工
      * @param dpet
     * @return
     */
    public int addDept(Dpet dpet);

    /**
     * 查询所有员工
     * @return
     */
    public List<Dpet> allDeptList();

    /**
     * 根据编号查询一个员工
     * @param id
     * @return
     */
     public Dpet deptById(int id);
}

DeptMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.springcloud.mapper.DeptMapper">
<!--新增一个员工-->
<insert id="addDept" parameterType="Dpet">
   INSERT INTO db01.dpet (dname, db_source) VALUES(#{dname},database());
</insert>
<!--查询所有员工-->
<select id="allDeptList" resultType="com.springcloud.pojo.Dpet">
   select  * from dpet
</select>
<!--根据编号查询一个员工-->
<select id="deptById" resultType="com.springcloud.pojo.Dpet">
   select * from dpet where dpetNo=#{id}
</select>
</mapper>

DpetService

package com.springcloud.service;
import com.springcloud.pojo.Dpet;
import java.util.List;
/**
 * 员工业务层
 */
public interface DpetService {
    /**
     * 新增一个员工
     * @param dpet
     * @return
     */
    public int addDept(Dpet dpet);

    /**
     * 查询所有员工
     * @return
     */
    public List<Dpet> allDeptList();

    /**
     * 根据编号查询一个员工
     * @param id
     * @return
     */
    public Dpet deptById(int id);
}

DpetServiceImpl

package com.springcloud.service.impl;
import com.springcloud.mapper.DeptMapper;
import com.springcloud.pojo.Dpet;
import com.springcloud.service.DpetService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
 * 业务实现类
 */
@Service
public class DpetServiceImpl implements DpetService {

    @Autowired
    private DeptMapper deptMapper;
    /**
     * 新增一个员工
     * @param dpet
     * @return
     */
    @Override
    public int addDept(Dpet dpet) {
        return deptMapper.addDept(dpet);
    }

    /**
     * 查询所有员工
     * @return
     */
    @Override
    public List<Dpet> allDeptList() {
        return deptMapper.allDeptList();
    }

    /**
     * 根据编号查询一个员工
     * @param id
     * @return
     */
    @Override
    public Dpet deptById(int id) {
        return deptMapper.deptById(id);
    }
}

DeptController

package com.springcloud.controller;
import com.springcloud.service.DpetService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.springcloud.pojo.Dpet;

import java.util.List;

//提供Restful服务!,服务提供者
@RestController
@RequestMapping("/dept")
public class DeptController {

  @Autowired
  private DpetService dpetService;
    /**
     * 新增一个员工
     * @param dpet 员工对象
     * @return
     */
    @PostMapping("/add")
    public int add(Dpet dpet) {
        return dpetService.addDept(dpet);
    }
    /**
     * 根据编号查询
     * @param id 编号
     * @return
     */
    @RequestMapping("/dpetById/{id}")
    public Dpet dpetById(@PathVariable Integer id) {
        return dpetService.deptById(id);
    }
    /**
     * 查询所有员工
     * @return
     */
    @GetMapping("/allDepet")
    public List<Dpet> getDpetList() {
        return dpetService.allDeptList();
    }
}

DeptProvider_8001

package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DeptProvider_8001 {
    public static void main(String[] args) {
        SpringApplication.run(DeptProvider_8001.class,args);
    }
}

5.SpringCloud Rest学习环境搭建：服务消费者

创建模块springcloud-consumer-dept-80模块

导入依赖

<!--消费者-->
    <dependencies>
        <!--导入springcloud-api的实体类-->
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

application.yml

server:
  port: 80

ConfigBean

package com.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class ConfigBean { //@Configuration -- spring applicationContext.xmL

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

DeptController

package com.springcloud.controller;

import com.springcloud.pojo.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * 消费者
 */
@RestController
public class DeptController {

    //理解:消费者,不应该有service层
    //RestTemplate ....供我们直接调用就可以了!注册到Spring中

    @Autowired
    private RestTemplate template;//提供多种便捷访问远档http服务的方法，简单的estful服务模板~
    //浏览器前缀
    private static String REST_URL_PREFIX = "http://localhost:8081";
    /**
     * 根据编号查询
     * @param id
     * @return
     */
    ///dept/dpetById对应服务提供者的controller
    @GetMapping("/consumer/dpetById/{id}")
    public Dpet consumer(@PathVariable Integer id){
        return template.getForObject(REST_URL_PREFIX+"/dept/dpetById/"+id,Dpet.class);//实体类需要收到导入
    }

    /**
     * 查询所有员工
     * @return
     */
    @GetMapping("/consumer/list")
    public List<Dpet> list() {
        return template.getForObject(REST_URL_PREFIX + "/dept/allDepet/",List.class);
    }

    /**
     * 新增员工信息
     * @param dpet
     * @return
     */
    @PostMapping("/consumer/add")
    public int addDpet(Dpet dpet) {
        return template.postForObject(  REST_URL_PREFIX+" /dept/add/" ,dpet,Integer.class);
    }
}

DeptConsumer_80

package com.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}