1. 微服务架构
系统架构的演变从单应用，到根据每个模块垂直拆分，到分布式服务，SOA，到目前进化成了微服务形态。
微服务的特点
- 单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责
- 微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个服务虽小，但“五脏俱全”。
- 面向服务：面向服务是说每个服务都要对外暴露服务接口API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供Rest的接口即可。
- 自治：自治是说服务间互相独立，互不干扰
- 团队独立：每个服务都是一个独立的开发团队，人数不能过多。
- 技术独立：因为是面向服务，提供Rest接口，使用什么技术没有别人干涉
- 前后端分离：采用前后端分离开发，提供统一Rest接口，后端不用再为PC、移动段开发不同接口
- 数据库分离：每个服务都使用自己的数据源
- 部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦合，易维护
2. 远程调用方式
2.1 RPC/RMI
RPC：Remote Produce Call远程过程调用，类似的还有RMI。自定义数据格式，基于原生TCP通信，速度快，效率高。早期的webservice，现在热门的dubbo，都是RPC的典型
2.2 Http
Http：http其实是一种网络传输协议，基于TCP，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用Http协议。也可以用来进行远程服务调用。缺点是消息封装臃肿。
2.3 如何选择
既然两种方式都可以实现远程调用，我们该如何选择呢？
- 速度来看，RPC要比http更快，虽然底层都是TCP，但是http协议的信息往往比较臃肿，不过可以采用gzip压缩。
- 难度来看，RPC实现较为复杂，http相对比较简单
- 灵活性来看，http更胜一筹，因为它不关心实现细节，跨平台、跨语言。RPC方式需要在API层面进行封装，限制了开发的语言环境。
因此，两者都有不同的使用场景：
- 如果对效率要求更高，并且开发过程使用统一的技术栈，那么用RPC还是不错的。
- 如果需要更加灵活，跨语言、跨平台，显然http更合适
微服务，更加强调的是独立、自治、灵活。而RPC方式的限制较多，因此微服务框架中，一般都会采用基于Http的Rest风格服务。
3. Http客户端工具
可以使用一些流行的开源Http客户端工具请求Rest接口
- HttpClient
- OKHttp
- URLConnection
3.1 RestTemplate
使用Http客户端工具请求Rest接口，得到数据后反序列化成对象。这样做比较麻烦，Spring提供了一个RestTemplate模版工具类，对Http客户端进行了封装（默认使用URLConnection），实现了对象和Json的序列化和反序列化，方便得很。下面搭建一个Spring Boot工程，同时演示RestTemplate如何使用。
4. Spring Boot 搭建项目
微服务的一个重要特点是每个服务都是一个可以独立运行的项目，要是按照以前的SSM的搭建方式，无法做到服务的快速搭建和部署。于是Spring Boot应运而生，它的理念就是约定大于配置，你选好模块，自动帮你搭建好环境，非常便捷。
接下来用Spring Boot搭建两个简单的用户微服务：user-service和user-consume，实现的功能是：user-consume使用RestTemplate调用user-service服务。
具体参考这篇笔记(子文章)SPRING BOOT搭建两个微服务模块
5. Spring Cloud简介
Spring Cloud是实现微服务架构的技术。它集成了Netflix公司的一些微服务组件。(如果你不知道这家公司，那你肯定不爱看美剧。)
Netflix微服务架构图
- Eureka：注册中心
- Zuul：服务网关
- Ribbon：负载均衡
- Feign：服务调用
- Hystix：熔断器
6. 微服务场景模拟
在第四节我们已经搭建好了user-service和user-consume两个微服务。
consume使用RestTemplate调用service提供的rest接口，获得json数据，反序列化成User对象返回到前台。其中存在着一些问题：
- consume中调用的rest接口的地址是硬编码的，不方便维护。
- 如果service的rest接口变更或关闭了，consume并不知情，最终什么都得不到。
- service只有1台，一旦宕机，整个服务就不可用了。如果扩展多台，那consume又要自己考虑负载均衡。
接下来介绍的几个组件就是为解决这些问题而生的。
7. Eureka注册中心
7.1 简介
Eureka负责微服务的管理。
如果一个项目有数十个微服务，调用者想要自己找到一个适合的，可用的微服务是很麻烦的一件事。
就比如你想要坐车出门，自己上街拦出租车就很麻烦，要么司机拒载，要么车里已经有人了，要么干脆就没有车来...后来就出现了滴滴，做为一个网约车的“注册中心”，可以为你分配离你最近的空闲出租车。
Eureka就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。
同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。
这就实现了服务的自动注册、发现、状态监控。
7.2 原理图
- EurekaServer：注册中心，可以是多个Eureka的集群，对外暴露自己的地址。
- 服务提供者：启动后在注册中心中注册，成功后定期使用http方法向注册中心发送心跳包，表明自己还活着。
- 客户端消费者：向注册中心订阅服务。注册中心会向消费者发送合适的服务提供者列表，并且定期更新。需要使用某个服务时，可以从列表中找到并调用。
7.3 搭建注册中心
搭建过程和第4节说的一样，注意选择Eureka模块即可。
7.3.1 代码和配置文件
- 启动类
@EnableEurekaServer注解表示这是一个注册中心
@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class, args);
}
}
- 配置文件
现在我们只启动一个eureka作为注册中心。
这是Spring官方文档中的Standalone Eureka Server的建议配置。
注意eureka下的client配置，这个配置意思是eureka应用作为一个客户端，对注册中心的动作。
其中service-url的配置必须要填写，内容是注册中心的地址，如果有多个，逗号隔开。
defaultZone路径后面必须加上/eureka后缀，别问我为啥。
server:
port: 10086 # 端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
fetch-registry: false # 是否拉取服务列表，默认是true
service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
defaultZone: http://127.0.0.1:${server.port}/eureka
访问http://localhost:10086即可看到注册中心的内容，eureka只有一个，服务列表为空：
7.4 将user-service注册到eureka
7.4.1 添加依赖
eureka客户端依赖
<!-- Eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
Spring Cloud的依赖，注意我这里的版本是Greenwich.SR1
<!-- SpringCloud的依赖 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Greenwich.SR1</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!-- Spring的仓库地址 -->
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
7.4.2 开启EurekaClient功能
添加@EnableDiscoveryClient注解
@SpringBootApplication
@EnableDiscoveryClient // 开启EurekaClient功能
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}
7.4.3 配置eureka客户端属性
server:
port: 8081
spring:
datasource:
url: jdbc:mysql://localhost:3306/XXXXX?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username: XXXXX
password: XXXXX
hikari:
maximum-pool-size: 20
minimum-idle: 10
application:
name: user-service # 应用名称
mybatis:
type-aliases-package: com.vplus.demo.userservice.pojo
eureka:
client:
service-url: # EurekaServer地址
defaultZone: http://127.0.0.1:10086/eureka
instance:
prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
7.4.4 效果
7.5 user-consume从eureka中获取服务
7.5.1 添加依赖
同上7.4.1
7.5.2 开启EurekaClient功能
同上7.4.2
7.5.3 配置eureka客户端属性
server:
port: 8082
spring:
application:
name: user-consume # 应用名称
eureka:
client:
service-url: # EurekaServer地址
defaultZone: http://127.0.0.1:10086/eureka
instance:
prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname
ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
7.5.4 修改UserService
- 之前是调用UserDao，UserDao使用
RestTemplate请求远程接口得到数据。 - 现在我们在service层，从eureka中拉取服务列表，得到接口地址后请求数据。
@Service
public class UserService {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;// Eureka客户端，可以获取到服务实例信息
public List<User> queryUserByIds(List<Long> ids) {
List<User> users = new ArrayList<>();
// String baseUrl = "http://localhost:8081/user/";
// 根据服务名称，获取服务实例
List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
// 因为只有一个UserService,因此我们直接get(0)获取
ServiceInstance instance = instances.get(0);
// 获取ip和端口信息
String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/";
ids.forEach(id -> {
// 我们测试多次查询，
users.add(this.restTemplate.getForObject(baseUrl + id, User.class));
// 每次间隔500毫秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
return users;
}
}
7.6 eureka集群
7.6.1 搭建集群
Eureka可以集群搭建形成高可用的注册中心。多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。
我们要两个Eureka，端口号分别是10086、10087
可以使用Idea的启动器复制功能复制eureka的启动器。
将应用A的启动器复制出一个A2，A启动后，修改配置再启动A2，这样我们就可以得到两个配置不同的应用了。
先把原来的eureka配置信息改为
server:
port: 10086 # 端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10087/eureka
启动EurekaApplication，启动起来后再将配置改为
server:
port: 10087 # 端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
再启动EurekaApplication2，此时两个注册中心就形成了集群。
两个eureka相互注册，10086的defaultZone的url地址的端口号为10087，注意这一点。
再将两个客户端的Eureka相关配置改为
defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
访问http://localhost:10086和http://localhost:10087都可以看到效果：
7.7 Eureka相关配置
7.7.1 服务提供者
服务提供者主要做两个动作：服务注册和服务续约
- 服务注册的对应配置,true表示服务启动后会向注册中心发送注册请求，默认就是开着的。
eureka
client
register-with-erueka: true
- 服务续约的对应配置，这些都是默认值
eureka:
instance:
#服务失效时间，默认值90秒
lease-expiration-duration-in-seconds: 90
#服务续约(renew)的间隔，默认为30秒
lease-renewal-interval-in-seconds: 30
默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会从服务列表中移除，注意，这是服务提供者告诉注册中心：我每30秒续约一次，90秒没有续约，就表示我失效了,是配置在服务提供者上的，不是配置在注册中心上的。
我实验的时候，关闭一个服务，eureka几乎是瞬间就知道服务down了
试了好几次都是这样，可能我的关闭动作出发了什么东西吧，时间有限，先不管这个问题，留个坑将来看。
后来我注意到服务关闭后会输出一句：Unregistering ...，推测服务正常关闭时会自己通知注册中心。
- 实例ID名的修改
在页面上，服务提供者实例ID显示为：localhost:user-service:8081，
格式为：${hostname} + ${spring.application.name} + ${server.port}，对应配置为
eureka:
instance:
instance-id: ${spring.application.name}:${server.port}
修改后启动，变成了
7.7.2 服务消费者
消费者需要拉取服务列表，拉取时间间隔默认为30秒1次，对应配置为，如果是开发环境可适当缩小方便开发
eureka:
client:
registry-fetch-interval-seconds: 30
7.7.3 失效剔除和自我保护
-
失效剔除：每个一段时间剔除掉失效的服务，默认为60s，为了方便开发设置为1s。
服务器怎么知道失效了？看看上面服务提供者的配置，注意这几个配置的联系。
-
自我保护：生产环境中，由于网络延迟等原因，失效服务并不一定是真正失效了。如果被标记为失效的服务太多，超过了85%，此时eureka会把这些服务保护起来，先不剔除，保证大多数服务还可用。在开发中将自我保护模式关掉，方便开发。
eureka:
server:
enable-self-preservation: false # 关闭自我保护模式（默认为打开）
eviction-interval-timer-in-ms: 1000 # 扫描失效服务的间隔时间为1s（默认为60s）
8. Robbin负载均衡
8.1 开启两个user-service
具体操作参照7.6.1，这里设置两个service的端口为8080和8081
8.2 开启负载均衡
注意，是在调用端即consume上开启负载均衡，Eureka中已经集成了Ribbon，无需引入新的依赖，只需要在调用端的RestTemplate的注册Bean方法上添加注解：@LoadBalanced即可。这个方法位于UserConsumerApplication里。
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
}
具体的调用方式也需要修改，将UserService中的queryUserByIds方法修改成这样。
public List<User> queryUserByIds(List<Long> ids) {
List<User> users = new ArrayList<>();
// 地址直接写服务名称即可
String baseUrl = "http://user-service/user/";
ids.forEach(id -> {
// 我们测试多次查询，
users.add(this.restTemplate.getForObject(baseUrl + id, User.class));
// 每次间隔500毫秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
return users;
}
}
8.3 默认负载均衡策略分析
在org.springframework.cloud.client.loadbalancer包里面有一个LoadBalancerInterceptor，它就是实现负载均衡的拦截器。
跟踪源码，找到了RibbonLoadBalancerClient,用consume多次请求接口，断点调试
execute(String serviceId, LoadBalancerRequest<T> request, Object hint)方法：
就是轮询。
8.4 修改负载均衡策略
一个配置即可修改，有多种配置规则，这里使用随机规则。
注意格式，是以服务名称开头的。
server:
port: 8082
spring:
application:
name: user-consume # 应用名称
eureka:
client:
service-url: # EurekaServer地址
defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
registry-fetch-interval-seconds: 5
instance:
prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname
ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
###################################负载均衡配置###############################################
user-service:
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
8.5 重试机制
如果有一台服务突然挂掉了，而eureka还来不及将其清除出服务列表，或者消费者拉取的服务列表还有缓存，一旦请求到这台挂掉的服务就会报错。虽然多次请求后结果也能出来，但体验非常不好。
Ribbon的重试机制就是解决这个问题的。
引入依赖
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
开启Spring Cloud的重试机制并配置
server:
port: 8082
spring:
application:
name: user-consume # 应用名称
cloud:
loadbalancer:
retry:
enabled: true # 开启Spring Cloud的重试功能
eureka:
client:
service-url: # EurekaServer地址
defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
registry-fetch-interval-seconds: 5
instance:
prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname
ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
user-service:
ribbon:
ConnectTimeout: 250 # Ribbon的连接超时时间
ReadTimeout: 1000 # Ribbon的数据读取超时时间
OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
MaxAutoRetriesNextServer: 1 # 切换实例的重试次数
MaxAutoRetries: 1 # 对当前实例的重试次数
就好了。