SpringCloud微服务
1.认识微服务
1）微服务架构
微服务的架构图：
微服务技术完整：
2）单体架构与分布式架构
单体架构：
概念：
将业务的所有功能集中再一个项目中开发，打包成一个包进行部署。
优点：
a.架构简单
b.部署成本低
缺点：
c.耦合度高
分布式架构 ：
概念：根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，成为一个服务。
优点：
a.降低服务耦合
b.有利于服务升级拓展
缺点：
c.架构非常复杂
d.运维，监控，部署难度提高
待解决的问题：
c.服务拆分粒度如何处理？
d.服务集群地址如何维护？
e.服务之间如何实现远程调用？
f.服务健康状态如何感知？
3）微服务概述
概念：
微服务是一种经过良好架构设计的分布式架构方案。
特征：
a.单一职责：微服务拆分粒度更小，每一个服务都对应唯一的的业务能力，做到单一职责，避免重复开发。
b.面向服务：微服务对外暴露业务接口。
c.自治：团队独立，技术独立，数据独立，部署独立。
d.隔离性强：服务调用做好隔离，容错，降级，避免出现级联问题。
4）SpringCloud框架概述
概念：
SpringCloud是目前国内最广泛的服务框架，其官网地址： https://spring.io/projects/spring-cloud
springcloud与springboot版本兼容：
5）服务拆分和远程调用
服务拆分：
实际案例：
订单信息和用户信息 服务拆分。
a.不同微服务，不要重复开发相同业务。
b.微服务数据独立，不要访问其他微服务的数据库。
c.微服务可以将自己的业务暴露成接口，供其他微服务调用。
拆分实例demo问题解决：
Q：导入项目时遇到 java发行版本错误5？
A：解决方案1：添加以下内容
<properties>
<java.version>1.8</java.version>
</properties>
解决方案2：添加以下内容：
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler>
</properties>
远程调控
实际案例：根据订单id查询订单的同时，吧订单所属用户信息一起返回。
RestTemplate的使用
使用条件：
①基于RestTemplate发起的http请求实现远程调用。
②http请求做远程调用是与语言无关的调用，只有知道对方的ip，端口，接口路径，请求参数即可。
使用示例：
1.在 主启动类（配置类） 下注入RestTemplate对象：
@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
//将RestTemplate注入容器
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
2.在orderService中发起http请求：
@Service
public class OrderService{
@Autowired
private OrderMapper orderMapper;
//自动注入restTemplate对象
private RestTemplate restTemplate;
public Order queryOrderById(Long orderId){
//查询订单
Order order = orderMapper.findById(orderId);
//利用RestTemplate发起http请求，查询用户
String url = "http://localhost:8081/user/"+order.getUserId();
//GET方式访问
User user = restTemplate.getForObject(url,User.class);
order.setUser(user);
}
}
@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
//将RestTemplate注入容器
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
测试问题：
跨服务器的远程调用需要双开服务器，否则会报 Connection refused:connect错误。
6）Eureka注册中心
提出问题：
①服务消费者该如何获取服务提供者的地址信息？
答：服务提供者启动时向eureka注册自己的信息。euraka保存这些信息。消费者根据服务名向eureka拉去提供者信息。
②如果有多个服务提供者，消费者如何选择？
答：负载均衡算法选择其中一个。
③消费者如何得知服务提供者的健康状态？
答：服务提供者每隔30s向EurakaServer发起心跳，报告健康状态。eureka会更新记录服务列表信息，心跳不正常会被剔除。消费者就可以拉渠道最新的信息。
总结：
在Euraka架构中，微服务角色有两类：
1.EurakaServer：服务端，注册中心。其包含功能：
①记录服务信息。
②心跳监控（轮询机制）。
2.EurakaClient：客户端。其包含功能：
①Provider：服务提供者，其需要做两件事：
Ⅰ.注册自己信息到EurakaServer
Ⅱ.每隔30s向EurakaServer发送心跳。
② consumer：服务消费者。其需要做两件事：
Ⅰ.根据服务名称从EurakaServer拉取服务列表。
Ⅱ.基于服务列表做负载均衡，选一个微服务后发起远程调用。
搭建EurakaServer
1.引入euraka-server依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
<version>2.2.7.RELEASE</version>
</dependency>
2.添加@EnableEurakaServer注解
@SpringBootApplication
@EnableEurekaServer
public class EurakaApplication {
public static void main(String[] args) {
SpringApplication.run(EurakaApplication.class,args);
}
}
3.在application.yml中配置euraka地址信息。
server:
port: 10086
spring:
application:
name: eurekaserver
eureka:
client:
service-url:
defaultZone: http://localhost:10086/eureka
注册user-server
操作步骤：
1.引入eureka-client依赖。
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-netflix-eureka-client</artifactId>
<version>2.2.7.RELEASE</version>
</dependency>
2.在application.yml配置以下内容。
spring:
application:
name: xxxserver
eureka:
client:
service-url:
defaultZone: http://localhost:10086/eureka
多次启动相同服务
采用改端口拷贝方式解决端口冲突问题。
选中 服务栏的要双开的服务 Ctrl+D 复制项目，修改端口（在environment中的VM options输入-Dserver.port=8082）。
服务拉取
概念：基于服务名称获取服务列表，然后再对服务列表做负载均衡。
步骤：
1.修改OrderService的代码，修改访问的url路径，用服务名称代替IP，端口：
String url = "http://userservice/user/"+order.getUserId();
2.再order-service项目的启动类OrderApplication中的RestTemplate添加 负载均衡 注解：
@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
※切记勿忘添加注解，第一次测试无法访问原因是未加注解，根据名称无法访问到。
Ribbon负载均衡
流程图：
细则流程图：
IRure中的策略：
默认策略：(ZoneAvoidanceRule)：在一个区域Zone的服务进行轮询。
主观修改轮询规则的方法：
1.再服务启动类中定义一个新的IRule：（作用于全局，所有服务均为随机）
@Bean
public IRule randomRule(){
//返回值可以是IRule中的任意一种Rule
return new RandomRule();
//样例写法即为随机选择服务
}
2.在yml文件中配置轮询规则：（作用于局部，仅作用域服务名称对应服务）
userservice:
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule #负载均衡规则
饥饿加载
概念：默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：
ribbon:
eager-load:
enabled: true #开启饥饿加载
clients: #指定饥饿加载的名称
-orderservice
-xxx
※ 通过实例测试，饥饿加载的网页运行效率是之前的十倍有余。
7）Nacos注册中心
Nacos简介：阿里巴巴的产品，是SpringCloud中一个组件，相比eureka功能更加丰富，在国内受欢迎程度更高。
下载与安装
主页地址：https://github.com/Netflix/eureka
下载页：https://github.com/alibaba/nacos/releases
执行命令：
startup.cmd -m standalone
# 单机模式启动
进入弹出网址，登录。（初始用户名和密码均为nacos）
服务注册
步骤：
1.添加依赖
<!--springcloudalibaba的依赖-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.2.5.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
2.去掉eureka的依赖
3.去掉yml文件中eureka的配置。
4.添加nacos的配置信息：
cloud:
nacos:
server-addr: localhost:8848
nacos服务的分级存储模型
内容：
①一级是服务，例如userservice
②二级是集群，例如杭州or上海集群
③三级是实例，例如杭州机房的某台部署了userservice的服务器
设置步骤：
修改application.yml文件，做以下修改：
spring:
cloud:
nacos:
discovery:
cluster-name: com.alibaba.cloud.nacos.ribbon.NacosRule #集群名
NacosRule和权重负载均衡
NacosRule负载均衡规则：
①优先选择同集群服务实例列表
②本地集群找不到提供者，才回去其他集群寻找，并且会报错警告
③确定了可用实例列表后，再采用随机负载均衡挑选实例
根据权重负载均衡：
内容：Nacos提供权重控制负载均衡规则。
步骤：再nacos界面中设置服务权重（0~1），权重大的服务实例更容易被访问到。比如，权重为0.1与1的服务实例，1的访问概率约为0.1的十倍。权重为0时服务不会被访问到。
Nacos环境隔离
内容：
①namespace来做环境隔离
②每个namespace都要唯一id
③不同namespace下的服务不可见。
使用步骤：
再yml配置文件中做以下配置：
spring:
cloud:
nacos:
discovery:
namespace: xxx #此处填写命名空间的uid
eureka和nacos对比
共同点：
①都支持服务注册和服务拉取
②都支持服务提供者心跳方式做健康检测
不同点：
①Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时模式采用主动检测模式。
设置非临时实例的方法，再yml配置文件中修改以下内容：
spring:
cloud:
nacos:
discovery:
ephemeral: false #是否为临时文件
②临时实例心跳不正常会被剔除，非临时实例不会被剔除。
③Nacos支持服务列表变更的推送模式，服务列表更新及时。
④Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式，Eureka采用AP模式。
统一配置管理
进入 nacos->配置中心->新建配置->命名配置名为 【服务名-开发模式.yaml】->补充配置内容 步骤即可。
命名模式样例：userservice-dev.yaml -> 用户服务的开发者模式
配置内容样例：
patterns:
dateformat: yyyy-MM-dd HH-mm-ss
由于项目启动时会优先访问 nacos 的共有配置文件，故需提前得知nacos的内存地址，其存储在服务的bootstrap.yaml（该文件优先级远高于服务的配置文件）中。
步骤：
①引入Nacos的配置管理客户端依赖：
<!--nocos的配置管理依赖-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
②在userservice中的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml:
spring:
application:
name: userservice #服务名称
profile:
active: dev #开发环境
cloud:
nacos:
server-addr: localhost:8848 #Nacos地址
config:
file-extension: yaml #文件名后缀
样例测试展示：
在nacos中新建一个统一配置管理。
按照以上配置依次配。
最后在userservice服务中进行测试:
@RestController
@RequestMapping("/user")
public class UserController {
//注入nacos的配置属性
//此处@Value可换为nacosValue
//@Value(${key})注解可以获取到 配置文件中的属性值
@NacosValue("${pattern.dateformat}")
private String dateformat;
//编写controller，通过日期格式化器格式化现在时间并返回
@GetMapping("now")
public String now(){
return LocalDate.now().format(
DateTimeFormatterl.ofPattern(dateformat,Locale.China))
}
}
配置热更新：
方法一：在服务的Controller类上加 @RefreshScope 注解实现热刷新。
@RefreshScope 注解需配合 @Value注解一同使用。
方法二：创建一个专门的配置类实现热刷新：（加入@ConfigurationProperties注解）
@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
private String dateformat;
}
多环境共享配置
优先级排序：服务名-profile.yaml > 服务名.yaml > 本地配置。
Nacos集群的搭建
P29详细讲解
认识集群（结构图）：
数据库集群的作用是同步Nacos注册中心的数据。
搭建步骤：
1）搭建数据库集群，初始化数据库表结构
2）配置nacos
集群配置，数据库配置…
3）启动nacos集群（多个nacos节点）
4）使用nginx实现反向代理
8）Http客户端Feign
RestTemplate存在的问题
之前利用RestTemplate发起远程调用的代码：
String url = "http://userservice/user/"+order.getUserId();
User user = restTemplate.getForObject(url,User.class);
分析问题：
1.代码可读性差。
2.参数复杂URL难以维护。
Feigh的概述
概念：Feigh是一个声明式的http客户端。
地址：https://github.com/OpenFeigh/feigh
使用步骤：
①在使用者上引入依赖：
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
②加Feigh的注解：
@EnableFeighClients
@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args){
SpringApplication.run(OrderApplication.class,args);
}
}
③编写Feigh客户端：
首先明确发起请求的五个必要信息：
服务名称：userservice
请求方式：GET
请求路径：/user/{id}
请求参数：Long id
返回值类型：User
使用Feigh仅需要将以上信息交给Feigh即可：
@FeighClient("userservice")
public interface UserClient {
@GetMapping
User findById(@PathVariable("id") Long id);
}
※测试时注意去掉有关于RestTemplate的配置：包括yml中的namespace和
在Order的service层进行测试：
@Service
public class OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private UserClient userClient;
public Order queryOrderById (Long orderId){
Order order = orderMapper.findById(orderId);
User user = userClient.findById(order.getUserId());
order.setUser(user);
return order;
}
}
自定义Feign的配置
自定义设置Feign的日志：
方式一（配置文件yml）：
① 全局生效
feign:
client:
config:
default: #全局配置
loggerLevel: FULL #日志级别
② 局部生效：
feign:
client:
config:
userservice: #局部配置
loggerLevel: FULL
方式二（java代码）：
声明一个配置类：
public class FeignClientConfiguration {
@Bean
public Logger.Level feignLogLevel(){
return Logger.Level.BASIC;
}
}
全局配置：将以下注解放在启动类上：
@EnableFeignClients(defaultConfiguration = FeignClientConfiguration.class)
局部配置，将以下注解放在配置类上：
@FeignClient(value = "userservice",configuration = FeignClientConfiguration.class)
Feign的性能优化
Feign的底层客户端实现：
1.URLConnection：默认实现，不支持连接池。
2.Apache HttpClient：支持连接池。
3.OKHttp：支持连接池。
优化方式：
①使用连接池代替默认的URLConnection。
②日志级别，最好使用basic或者none。
优化步骤：
①引入依赖：
<!--引入httpClient依赖-->
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-httpclient</artifactId>
</dependency>
②修改配置文件
feign:
httpclient:
enabled: true #开启HttpClient开关
max-connection: 200 #最大连接数
max-connections-per-route: 50 #单个路径的最大连接数
Feign的最佳实践
方式一（继承）：
给消费者的FeignClient和 提供者的controller 定义统一的父接口作为标准。
public interface UserAPI {
@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
}
但该方案也有一定缺点：
①由于二者的API完全吻合，从而造成了服务紧耦合，不宜维护和修改。
②父接口参数列表中的映射（即@PathVariable）不会被继承。
方式二（抽取）：
将FeignClient抽取为独立模块，并且吧接口有关的POJO，默认的Feign配置都放在该模块中，提供所有消费者使用。
实现步骤：
①创建一个module，命名为feign-api，然后引入feign的starter依赖。
②将order-service中编写的UserClient，User，DefaultFeignConfiguration都复制到feign-api项目中。
③在order-service中引入feign-api的依赖。
④修改order-service中的所有与上述三个组件有关的import导包部分，改成导入feign-api中的包。
⑤重启测试即可。
缺点：
该方案客户在引入依赖时，会引入许多多余的方法，造成内存的膨胀。
值得注意的一点：
当定义的FeignClient不在SpringBootApplication的扫描包范围时，这些FeignClient无法使用（即无法自动注入，spring容器中没有对应类创建号的对象），采用以下方法解决：
方式一：指定FeignClient所在的包
@EnableFeignClients(basePackages = "cn.itcast.feign.clients")
方式二：指定FeignClient字节码
@EnableFeignClients(clients = {
UserClient.class})
9）统一网关Gateway
网关的概述
网关的功能：
①身份认证和权限校验
②服务路由，负载均衡
③请求限流
网关的技术实现：
步骤：
1.创建新的module，引入SpringCloudGateway的依赖和nacos的服务发现依赖：
<!--nacos的服务注册发现依赖-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--网关gateway的依赖-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
2.编写路由配置及nacos地址
server:
port: 10010 # 网关端口
spring:
application:
name: gateway #服务名称
cloud:
nacos:
server-addr: localhost:8848 # nacos地址
gateway:
routes: #网关路由配置
- id: user-service #路由id，只要唯一即可
uri: lb://userservice #路由的目标地址，lb是负载均衡，后面是服务名称
predicates: #路由断言，就是判断请求是否符合路由规则的条件
- Path=/user/** # 只要以/user开头就符合要求
路由断言工厂：
读取断言规则，从而对用户发起的路由做判断。
路由过滤器GatewayFilter
作用：可以对网关的请求和微服务返回的响应做处理：
案例：给所有进入userservice的请求添加一个请求头：Truth=NB
实现方式：在gateway中修改application.yml文件，给userservice的路由添加过滤器：
spring:
cloud:
gateway:
routes: #网关路由配置
- id: user-service
uri: lb://userservice
predicates:
- Path:/user/**
filters: #过滤器
- AddRequestHeader=Truth,NB # 添加请求头
default-filters: #给所有服务增加请求头
- AddRequestHeader=Truth,NB
全局过滤器GlobalFilter
概述：其处理一切进入网关的请求和微服务响应，与GatewayFilter作用一样。区别在于前者通过配置定义，处理逻辑固定，而后者逻辑需要自己写代码实现。定义方式是 实现GlobalFilter接口。
接口源码：
public interface GlobalFilter {
/**
* @param exchange 请求上下文，可获取到Request，Response等信息
* @param chain 用来吧请求委托给下一个过滤器
* @return 返回标识当前业务结束
*/
Mono<void> filter(ServerWebExchange,Gateway);
}
案例：定义全局过滤器，拦截请求，判断参数是否满足：
①参数中是否含有 authorization
②authorization参数值是否为admin
如果同时满足①②，则放行。
自定义过滤器：
@Order(-1) //排序，该组件的优先级（-1较高）
@Component //组件，将过滤器注入spring容器
public class AuthorizeFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange,GatewayFilterChain chain){
//获取请求参数
MultiValueMap<String,String> params = exchange.getRequest().getQueryParams();
//获取参数
String auth = params.getFirst("authorization");
//校验
if("admin".equals(auth)){
//放行
return chain.filter(exchange);
}
//拦截
exchange.getResponse().setStatusCode(HttpStatus.FORBIDDEN);
return exchange.getResponse().setComplete();
}
}
过滤器执行顺序法则：
①order值越小，优先级越高。
②当order值一样时，顺序是defaultFilter优先，然后是局部的路由过滤器，最后是全局过滤器。
跨域问题处理
跨域的概念：
①域名不同：www.taobao.com & www.taobao.org
②域名相同，端口不同。
跨域问题：浏览器 禁止请求发起者和服务端发生跨域 ajax 请求，请求被浏览器拦截的问题。
配置信息展示：
spring:
cloud:
gateway:
globalcors:
add-to-simple-url-handler-mapping: true #解决options请求被拦截问题
corsConfigurations:
'[/**]':
allowedOrigins: #允许哪些网站的跨域请求
- "http://localhost:8090"
- "http://www.leyou.com"
allowedMethods: #允许跨越ajax的请求方式
- "GET"
- "POST"
- "DELETE"
- "PUT"
- "OPTIONS"
allowedHeaders: "*" #允许在请求中携带的头信息
allowCredentials: true #是否允许携带Cookie
maxAge: 360000 #跨域检测的有效期
2.Docker
1）认识docker
为什么要使用docker？
①依赖关系复杂，容易出现兼容性问题。
②开发测试生产环境有差异。
docker如何解决依赖的兼容问题？
①将应用的函数库，依赖，配置与应用一起打包，形成 可移植镜像。
②将每个应用放到一个隔离容器去运行（沙箱机制），避免互相干扰。
Docker如何解决不同系统环境的问题？
①Docker将用户程序与所需要调用的系统（Ubuntu，CentOS）函数库一起打包。
②Docker运行到不同操作系统时，直接基于打包的库函数，借助于操作系统的Linux内核来运行。
Docker与虚拟机
虚拟机（virtual machine）是在操作系统中模拟硬件设备，然后运行另一个操作系统，比如在Windows上运行Ubuntu系统。使用了 Hypervisor 技术
对比：
①性能：Docker更接近原生，而虚拟机性能较差。
②硬盘占用：Docker一般为MB，虚拟机一般为GB。
③启动速度：Docker以秒为单位，虚拟机以分钟级为单位。
④本质：Docker是一个系统进程，虚拟机是在操作系统中的另一套操作系统。
镜像和容器
镜像（Image）：
镜像是只读的！！！Docker将应用程序及其所需的依赖，函数库，环境，配置等文件打包在一起。
容器（Container）：
镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外部可见。
DockerHub
DockerHub：是一个Docker镜像的托管平台。这样的平台叫做Docker Registry。
栗子：网易云镜像服务，阿里云镜像服务…
Docker架构
Docker是一个 C/S架构 的程序，由两部分组成：
♦ 服务端（server）：Docker守护进程，负责处理Docker指令，管理镜像，容器等
♦ 客户端（client）：通过命令或RestAPI向Docker服务端发送指令。可在本地或远程向服务端发送指令。
2）使用Docker
安装Docker
必须是在64位的CentOS7系统下，内核不能低于3.10，CentOS 7 满足最低内核要求。
卸载Docker：执行以下命令
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine \
docker-ce
安装yum工具：
yum install -y yum-utils \
device-mapper-persistent-data \
lvm2 --skip-broken
更新本地镜像源：
# 设置docker镜像源
yum-config-manager \
--add-repo \
https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g'
/etc/yum/repos.d/docker-ce.repo
yum makecache fast
安装Docker：(ce为社区版)
yum install -y docker-ce
启动Docker前一定要关闭防火墙！！！
启动Docker前一定要关闭防火墙！！！
启动Docker前一定要关闭防火墙！！！
关闭命令：
# 关闭防火墙
systemctl stop firewalld
# 防止开机自启
启动docker：
sudo systemctl start docker
查看启动是否成功：
docker info
Docker镜像操作
镜像的命名：
由两部分组成：[repository]:[tag]
栗子：mysql:5.7
tag的默认值是latest，代表最新版本。
样例1：从DockerHub上拉取一个nginx镜像并查看。
1.访问hub.docker.com页面，搜索nginx关键字。
2.拉取自己需要的镜像即可，通过命令docker pull nginx)(默认最新版)（sudo？）
3.通过命令 docker images 查看镜像。
样例2：
1.通过命令 将nginx:lastest镜像导出到nginx.tar包中。
docker save -o nginx.tar nginx:lastest
2.删除本地的nginx镜像 命令 。
docker rmi nginx:lastest
3.重新将nginx镜像加载到本地镜像 命令 。
docker load -i nginx.tar
不要死记命令，学习查询帮助文档！！！
docker xxx --help。
Docker容器基本操作
额外命令：
docker exec:进入容器执行命令
docker logs:查看容器运行日志
docker ps:查看所有运行的容器及状态
docker rm:删除指定容器
样例1：创建运行一个nginx容器
1.使用Docker Hub查询Nginx容器的运行命令 。
docker run --name containrName -p 80:80 -d nginx
docker run:创建并运行一个容器
参数解读：
–name:给容器起一个名字，比如叫做mn
-p:将宿主机端口与容器端口映射，冒号左侧是宿主机端口。
-d:后台运行容器。
样例2：进入Nginx容器，修改HTML文件内容，添加“hello world”。
1.进入容器，命令
docker exec -it mn bash
参数解读：
docker exec:进入容器内部，执行一个命令
-it:给当前进入的容器创建一个标准输入输出终端，允许我们与容器交互。
mn:要进入容器的名称。
bash:进入容器后执行的命令，bash是一个linux终端交互命令。
2.进入nginx的HTML所在目录 /usr/share/nginx/html。(可在DockerHub上查看位置)
cd /usr/share/nginx/html
3.修改index.html的内容（无vim命令）
不推荐在容器内修改文件
4.停止容器运行
docker stop mn # 停止容器
docker ps #默认查看运行时容器
docker ps -a #查看所有的容器
5.重启容器
docker start mn # 重新开始容器运行
6.删除容器
# 方案1
docker stop nm # 先暂停容器
docker rm mn # 删除容器
# 方案2
docker rm -f mn # 强制删除mn容器
数据卷
数据卷操作语句
docker volume [COMMAND]:
create:创建一个volume。
inspect:显示一个或多个volume的信息。
ls:列出所有的volume。
prune:删除未使用的volume。
rm:删除一个或多个指定的volume。
数据卷的挂载
案例：
docker run \
--name mn \
-v html:/root/html \ # 把html数据卷挂载在容器内对应目录中。
-p 8080:80
nginx \
样例：创建一个nginx容器，修改容器内的html目录内的index.html内容
在上个案例中，我们进入nginx内部，以及知道nginx的html目录所在位置/usr/share/nginx/html，我们需要把这个目录挂载到html这个数据卷上，方便操作其中的内容。
1.创建容器并挂在数据卷到容器内的HTML目录。
docker run --name mn -p 80:80 -v html:/usr/share/nginx/html -d nginx
2.查看当前容器
docker ps
3.查看数据卷html信息
docker inspect html
4.找到对应路径下的index.html文件直接进入修改即可。
该种方式进入修改无需进入容器，直接数据卷同步修改。
样例2：创建并运行一个MYSQL容器，将宿主机目录直接挂载到容器。
-v [宿主机目录]:[容器内目录]
-v [宿主机文件]:[容器内文件]
实现思路：
1.将mysql.tar文件上传到虚拟机，通过load命令加载为镜像
docker load -i mysql.tar # 加载镜像
docker images # 查看镜像是否导入成功
2.创建目录/tmp/mysql/data
mkdir -p mysql/data
mkdir -p mysql/conf
cd mysql/conf
3.创建目录/tmp/mysql/conf，将课前资料提供的hmy.cnf文件上传到/tmp/mysql/conf
4.去DockerHub查阅资料，创建并运行MYSQL容器，要求：
①挂载/tmp/mysql/data到mysql容器内数据存储目录
②挂载/tmp/mysql/conf/hmy.cnf到mysql容器的配置文件
③设置MYSQL密码
难点※：
docker run \
--name mysql \
-e MYSQL_ROOT_PASSWORD=123 \
-p 3306:3306\
-v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
-v /tmp/mysql/data:/var/lib/mysql \
-d \
mysql:5.7.25
3）自定义镜像
镜像结构
定义复习：镜像是将应用程序及其需要的 系统函数库，环境，配置，依赖打包而成。
镜像是一个分层结构，每一层是一个Layer。
BaseImage层：包含基本的系统函数库，环境变量。文件系统。
Entrypoint：入口，是镜像中应用启动的命令。
其他：再BaseImage基础上添加依赖，安装程序，完成整个应用的安装和配置。
Dockerfile
定义：是一个文本文件，包含一个个的指令，用指令来说明要执行什么操作来构建镜像。每个指令都会形成一层Layer。
※不会多查文档！！！
官方文档：https://docs.docker.com/engine/reference/builder
样例1：基于Ubuntu镜像构建一个新镜像，运行一个java项目。
①准备一个空文件夹docker-demo
# 切换目录，新建文件夹
cd /tmp/
mkdir docker-demo
ll
②将事先准备好的docker-demo.jar，jdk8.tar.gz，Dockerfile拷贝到docker-demo中。
③进入docker-demo，运行命令：
# -t == tag 版本
# 空格之后加“.”代表当前目录下
docker build -t javaweb:1.0 .
④检查是否操作成功
docker images # 查看所有镜像
docker run --name web -p 8090:8090 -d javaweb:1.0
# 让名为javaweb 1.0版本的镜像以8090端口在容器8090下并且可以后台运行
Dockerfile的写法案例：
# 指定基础镜像（基于ubuntu）
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local
# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar
# 安装JDK
RUN cd $JAVA_DIR \
&& tar -xf ./jdk8.tar.gz \
&& mv ./jdk1.8.0_144 ./java8
# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin
# 暴露端口(如果需要改端口需要在boot中去修改port)
EXPOSE 8090
# 入口 java的启动命令
ENTRYPOINT java -jar /tmp/app.jar
样例2：基于java:8-alpine镜像，将java项目部署到容器
Dockerfile：
#指定基础镜像（基于java:8-alpine）
FROM java:8-alpine
COPY ./docker-demo.jar /tmp/app.jar
# 暴露端口(如果需要改端口需要在boot中去修改port)
EXPOSE 8090
# 入口 java的启动命令
ENTRYPOINT java -jar /tmp/app.jar
DockerCompose
定义：是一个基于Compose文件帮我们快速部署分布式应用，无需手动创建和运行容器！其是一个文本文件，通过定义集群中的每个容器如何运行。
安装：
curl -L http://github.com/docker/compose/releases/download/1.29.1/docker-compose-'uname -s'-'uname-m' > /usr/local/bin/docker-compose
上传到/usr/local/bin/目录也可以。
修改文件权限：
chmod +x /usr/local/bin/docker-compose
自动补全命令：
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose
# 如果出错，执行以下命令
echo ""
样例：将之前学习的cloud-demo微服务集群利用docker-compose构建集群。
3.RabbitMQ
1）同步通信和异步通信
同步通信和异步通信：与生活中的视频电话与聊天相似。
同步通信存在的问题：
①耦合度高。每次加入新的请求，都需要修改原代码。
②性能下降。调用者需要等待服务提供者响应，调用链过长响应时间等于每次调用时间之和。
③资源浪费。调用链中每个服务在等待响应的过程中，不能释放请求占用的资源，高并发下会浪费系统资源。
④级联失败。如果服务提供者出现问题，所有调用方法都会出问题。
优点：时效性较强。
异步通信：
特点：事件驱动优势：
①流量削峰：高并发流量发起请求时，Broker缓存请求信息。微服务依次去取请求。
②耦合度低。
③吞吐量提升。
④故障隔离。
缺点：
①依赖于Broker的可靠性，安全性和吞吐能力。
②架构复杂了，业务没有明显的流程线，不好追踪管理。
2）MQ消息队列
定义：英文名MessageQueue，事件驱动架构中的Broker，表面上看就是存放消息的队列。
RabbitMQ安装
概念：RabbitMQ是基于Erlang语言开发的开源消息通信中间件，官网地址为：https://www.rabbitmq.com/
安装：
环境：在CentOS7的虚拟机下用Docker来安装。
下载镜像：
方式一：在线拉取
# 从镜像服务器中拉取rabbitmq镜像
docker pull rabbitmq:3-management
# 将其导入到系统本地
docker save -o rabbitmq.tar rabbitmq:3-management
方式二：从本地拉取
上传到虚拟机后，使用命令加载镜像即可：
docker load -i mq.tar
安装MQ：
# 创建MQ容器
docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123321 \
--name mq \
--hostname mql \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3-management
# 查看是否创建成功
docker ps
RabbitMQ中的几个概念：
①channel：操作MQ的工具（通道）
②exchange：路由消息到队列中
③queue：缓存消息
④virtual host：虚拟主机，是对queue，exchange等的资源逻辑分组。
HelloWorld消息模型
HelloWorld：
概述：官方的HelloWorld是基于最基础的消息队列模型来实现的，其中包括三个角色：
① publisher：消息发布者，将消息发送到队列queue
② queue：消息队列，负责接受并缓存消息
③ consumer：订阅队列，处理队列中的消息
publisher----->queue----->consumer
基本消息队列的消息发送流程：
1.建立connection
2.创建channel
3.利用channel声明队列queue
4.利用channel向队列发送消息
基本消息队列的消息接收流程：
1.建立connection
2.创建channel
3.利用channel声明队列queue
4.定义consumer的消费行为handleDelivery()
5.利用channel将消费者与队列绑定
SpringAMQP
AMQP(Advanced Message Queuing Protocal)：用于在应用程序或之间传递业务消息的开放标准，该协议与语言和平台无关，更符合微服务中独立性的要求。
Spring AMQP：基于AMQP协议定义的一套API规范，提供模板来发送和接收消息，包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。
案例1： 利用Spring AMQP实现HelloWorld中的基础消息队列功能。
流程如下：
1.在父工程中引入spring-amqp的依赖。
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2.在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列。
配置mq的连接信息：
spring:
rabbitmq:
host: (主机名)
port: 5672
virtual-host: / # 虚拟主机
username: itcast # 用户名
password: 123321 #密码
在publisher服务中新建一个测试类，编写测试方法：
@Runwith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSimpleQueue(){
String queueName = "simple.queue";
String message = "hello,spring amqp!";
rabbitTemplate.convertAndSend(queueName,message);
}
}
3.在consumer服务中编写消费逻辑，绑定simple.queue这个队列。
配置consumer信息，添加mq连接信息：
spring:
rabbitmq:
host: (主机名)
port: 5672
virtual-host: /
username: itcast
password: 123321
在consumer服务中新建一个类，编写消费逻辑：
@Component
public class SpringRabbitListener {
@RabbitListener(queues="simple.queue")
public void ListenSimpleQueueMessage(String msg) throws InterruptedException {
System.out.println("spring消费者接收到消息："+msg);
}
}
WorkQueue工作队列
定义：一个队列绑定多个消费者。
作用：有效防止了消息队列的阻塞。
样例1：模拟WorkQueue，实现一个队列绑定多个消费者。
基本思路：
1.在publisher中服务定义测试方法，每秒产生50条消息，发送到simple.queue。
2.在consumer服务中定义两个消息监听者，都监听simple.queue队列。
3.消费者1每秒处理50条信息，消费者2每秒处理10条信息。
消费预取机制：
修改application.yml文件，设置preFetch这个值，可以控制预取消息的上限：
spring:
rabbitmq:
host: (主机名)
port: 5672 # 端口
virtual-host: /
username: itcast
password: 123321
listener:
simple:
prefetch: 1 # 每次只能获取一条消息，处理完了才能接取下一个消息
发布订阅模型
定义：与之前案例的区别是允许将同意消息发送给多个消费者。实现方式是加入了exchange(交换机)。常见的exchange包括：Fanout 广播， Direct 路由， Topic 话题。exhcange负责消息路由，路由失效则消息丢失。
FanoutExchange
定义：会接收到消息路由到每一个跟其绑定的queue。
案例1：实现FanoutExchange。
在配置类中声明FanoutExchange,Queue和绑定关系对象Binding，代码如下：
@Configuration
public class FanoutConfig {
//声明交换机
@Bean
public FanoutExchange fanoutExchange(){
return new FanoutExchange("itcast.fanout");
}
//声明队列
//注意Queue的包：org.springframework.amqp.core.Queue;
@Bean
public Queue fanoutQueue1(){
return new Queue("fanout.queue1");
}
//绑定队列1和交换机
@Bean
public Binding bindingQueue1(Queue q,FanoutExchange fe){
return BindingBuilder.bind(q).to(fe);
}
}
使用RabbitMQ的方式：
@Component
public class SpringRabbitListener {
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
,,,
}
}
DirectExchange
定义：会将接收到的消息规则路由到指定的Queue，因此成为路由模式(routes)。
①每一个Queue都与Exchange设置一个BindingKey。
②发布者发送消息时，指定消息的RoutingKey。
③Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。
案例：利用SpringAMQP演示DirectExchange。
实现思路如下：
1.在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2。
2.利用@RabbitListen声明Exchange，Queue，RoutingKey。
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "itcast.direct" , type = ExchangeTypes.DIRECT),
key = {
"red","yellow"}
))
public void listenDirectQueue2(String msg){
System.out.println("消费者2接收到消息："+msg);
}
TopicExchange
定义：与上者类似，区别在于routingKey必须是多个单词的列表，并且以.分割。
Queue与Exchange指定key时可以使用通配符：
#：代指0或多个单词
*：代指一个单词
key的命名案例：china.news，china.weather，japan.news，japan.weather。
样例：利用SpringAMQP演示TopicExchange使用。
声明思路：
①利用@RabbitListener声明交换机，队列和RoutingKey
②在消费者服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2。
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue1"),
exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
key = "china.#"
))
③在publisher中编写测试方法，向itcast.topic发送消息。
消息转换器
定义：Spring的对消息对象处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。推荐使用JSON方式序列化。
实现步骤：
①引入依赖
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.10</version>
</dependency>
②在publisher服务声明MessageConverter:
@Bean
public MessageConverter jsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}
③然后定义一个消费者，监听object.queue队列并消费消息：
@RabbitListener(queues = "object.queue")
public void ListenObjectQueue(Map<String,Object> msg){
sout("...")
}