搭建微服务:搭建父项目，生产模块，消费模块，Eureka客户端，服务端集群
概述：
下面是搭建了父工程，父工程fengmingmen下面搭建了 A服务提供者模块userService，B服务消费者模块userConsumer。
B使用redisTemplate调用A的方法，
因为存在 1.对外暴露自己的地址 2.将来地址出现变更，还需要及时更新 等问题，
而使用 eureka注册中心解决这一系列问题。
一.创建项目
1.创建核心父工程
2.配置pom.xml
<?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>fengmingmen</groupId>
<artifactId>fengmingmen</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<modules>
<module>user-service</module>
</modules>
<!-- 配置父级 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.6.RELEASE</version>
</parent>
<!-- 配置全局属性 -->
<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Greenwich.SR2</spring-cloud.version>
<mapper.version>2.1.5</mapper.version>
<mysql.version>5.1.47</mysql.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- spring-cloud (导入pom文件)
scope: import 只能在<dependencyManagement>元素里面配置
-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- 通用mapper启动器 -->
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>${mapper.version}</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 配置spring-boot的maven插件 -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
二.服务提供者
1.创建user模块
2.pom.xml:
<?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>springcloud-demo</artifactId>
<groupId>cn.itcast</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>user-service</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>
</project>
3.模块结构
4.配置文件（application.yml）
配置数据库信息
建表语句(自己随便加点数据进去查询)
CREATE TABLE `user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`username` varchar(50) NOT NULL COMMENT '用户名',
`password` varchar(32) NOT NULL COMMENT '密码，加密存储',
`name` varchar(50) DEFAULT NULL COMMENT '真实姓名',
`age` int(11) NOT NULL COMMENT '年龄',
`sex` int(11) DEFAULT '1' COMMENT '性别，1男，2女',
`birthday` datetime DEFAULT NULL COMMENT '生日',
`created` datetime NOT NULL COMMENT '创建时间',
`updated` datetime NOT NULL COMMENT '修改时间',
PRIMARY KEY (`id`),
UNIQUE KEY `username` (`username`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COMMENT='用户表';
5.启动类
package user;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;
@SpringBootApplication//启动类注解
@MapperScan("user.mapper")//扫描的mapper路径
public class UserApplication {
public static void main(String[] args) {
SpringApplication.run(UserApplication.class, args);
}
}
6.实体类：
package user.entity;
import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
/**
* 实体类
*/
@Table(name = "user")
@Data
public class User {
//useGeneratedKeys = true 允许JDBC支持自动生成主键，需要驱动兼容
@Id
@KeySql(useGeneratedKeys = true)
private Long id;
// 账号
private String username;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别
private Integer sex;
// 生日
private Date birthday;
// 创建日期
private Date created;
// 修改日期
private Date updated;
}
7.mapper：
package user.mapper;
import tk.mybatis.mapper.common.Mapper;
import user.entity.User;
/**
* 数据访问接口
*/
public interface UserMapper extends Mapper<User> {
}
8.service：
package user.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import user.mapper.UserMapper;
import user.entity.User;
/**
* 业务层
*/
@Service
@Transactional
public class UserService {
@Autowired
private UserMapper userMapper;
/**
* 根据主键id查询用户
*/
public User findOne(Long id) {
return userMapper.selectByPrimaryKey(id);
}
}
9.controller：
package user.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import user.entity.User;
import user.service.UserService;
@RestController
@RequestMapping("/user")
public class UserController {
//用于检查数据库配置账号密码是否有误
@Value("${spring.datasource.username}")
private String userNme;
//密码的配置如果有特殊符号需要在yaml文件加引号
@Value("${spring.datasource.password}")
private String password;
@Autowired
private UserService userService;
/**
* 根据主键id查询用户
*/
@GetMapping("/{id}")
public User findOne(@PathVariable("id") Long id) {
return userService.findOne(id);
}
}
10. 启动测试
启动项目，访问接口：http://localhost:9001/user/1
三.服务消费者
1.创建user消费者模块
2.pom.xml:
<?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>fengmingmen</artifactId>
<groupId>fengmingmen</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>user-consumer</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
3.模块结构
4.配置文件(application.yml)
server:
port: 9002
5.启动类（注册 RestTemplate）
package consumer;
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 ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class, args);
}
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
6.实体类
package consumer.entity;
import lombok.Data;
import java.util.Date;
@Data
public class User {
private Long id;
// 账号
private String username;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别
private Integer sex;
// 生日
private Date birthday;
// 创建日期
private Date created;
// 修改日期
private Date updated;
}
}
7.controller（user-consumer跨项目调用user-service）
package consumer.controller;
import consumer.entity.User;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
@RequestMapping("/consumer")
public class ConsumerController {
@Autowired
private RestTemplate restTemplate;
/**
* 根据主键id查询用户
*/
@GetMapping("/{id}")
public User findOne(@PathVariable("id") Long id) {
String url = "http://localhost:9001/user/" + id;
return restTemplate.getForObject(url, User.class);
}
}
8.分别启动userService跟userConsumer测试
四.Eureka（注册中心）
1.搭建eureka模块
2.pom.xml
<?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>fengmingmen</artifactId>
<groupId>fengmingmen</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>eureka-service</artifactId>
<dependencies>
<!-- 配置eureka服务端启动器(集成了web启动器) -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
</dependencies>
</project>
3.模块结构
4.启动类
package fengmingmen;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@EnableEurekaServer // 声明当前应用为eureka服务(启用eureka服务)
@SpringBootApplication
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class, args);
}
}
5.配置文件
server:
port: 8761 # eureka服务端，默认端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中作为服务的id标识（serviceId）
eureka:
client:
service-url: # Eureka服务的地址，现在是自己的地址，如果集群，需要写其它服务的地址。
defaultZone: http://localhost:8761/eureka
fetch-registry: false #不拉取服务(自已拉取自己的服务没有必要)
register-with-eureka: false # 不注册自己(自已注册到自己没有必要)
6.访问 localhost:8761
存在问题：
- 在user-consumer中，我们把url地址硬编码到了代码中，不方便后期维护
- user-consumer需要记忆user-service的地址，如果出现变更，可能得不到通知，地址将失效
- user-consumer不清楚user-service的状态，服务宕机也不知道
- user-service只有1台服务，不具备高可用性
- 即便user-service形成集群，user-consumer还需自己实现负载均衡
生产模块，消费模块，eruka服务搭建完毕，使用eureka
- eureka实现了服务的自动注册、发现、状态监控
- Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
- 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
- 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
- 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态
- Eureka分两个部分： Eureka服务端 + Eureka客户端(服务提供者或服务消费者)
五.eureka客户端
5.1首先对于user-service模块，做注册
1.在user-service模块中添加eureka客户端启动器依赖
pom.xml
<!-- 配置eureka客户端启动器 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
2.在启动类上开启Eureka客户端，添加 @EnableDiscoveryClient 来开启Eureka客户端
3.修改application.yml，添加eureka客户端配置
# 配置eureka
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
4.配置指定应用名称，作为服务的id使用。
5.重启user-service，访问Eureka
发现已经自动注册进去注册中心了，而且名字是我们配置中命名的user-service
，端口为9001
5.2然后对于user-consumer模块，做服务发现 (通过服务id发现服务)
1.在user-consumer模块中添加eureka客户端启动器依赖
pom.xml
<!-- 配置eureka客户端启动器 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
2.在启动类上开启Eureka客户端，添加 @EnableDiscoveryClient 来开启Eureka客户端
3.application.yml
server:
port: 9002
spring:
application:
name: user-consumer # 应用名称
eureka:
client:
service-url: # eurekaServer地址
defaultZone: http://localhost:8761/eureka
4.修改代码，用DiscoveryClient类的方法，根据服务id，获取服务实例
package consumer.controller;
import consumer.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@RestController
@RequestMapping("/consumer")
public class ConsumerController {
/**
* 注入发现者
*/
@Autowired
private DiscoveryClient discoveryClient;
@Autowired
private RestTemplate restTemplate;
/**
* 根据主键id查询用户
*/
@GetMapping("/{id}")
public User findOne(@PathVariable("id") Long id) {
// 根据服务id获取该服务的全部服务实例
List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
// 获取第一个服务实例(因为目前我们只有一个服务实例)
ServiceInstance serviceInstance = instances.get(0);
// 获取服务实例所在的主机
String host = serviceInstance.getHost();
// 获取服务实例所在的端口
int port = serviceInstance.getPort();
// 定义服务实例访问URL
String url = "http://" + host + ":" + port + "/user/" + id;
System.out.println("服务实例访问URL: " + url);
return restTemplate.getForObject(url, User.class);
}
}
5.Debug重启user-consumer
6.项目断点，postman请求
六.eureka服务端(高可用)
Eureka架构中的三个核心角色：
- 服务注册中心(Eureka服务端)
Eureka的服务端应用，提供服务注册和发现功能，就是刚刚我们建立的eureka-server- 服务提供者(Eureka客户端)
提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即可。本例中就是我们实现的user-service- 服务消费者(Eureka客户端)
消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。本例中就是我们实现的user-consumer
1.高可用（介绍）
- Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实上EurekaServer也可以是一个集群，形成高可用的Eureka注册中心。
服务同步
多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。
而作为客户端，需要把信息注册到每个Eureka中：
如果有三个Eureka，则每一个EurekaServer都需要注册到其它几个Eureka服务中，例如：有三个分别为8761、8762、8763，则：
- 8761要注册到8762和8763上
- 8762要注册到8761和8763上
- 8763要注册到8761和8762上
2. 高可用配置（实施）
(搭建三个EurekaServer的集群，端口分别为：8761和8762,8763)
2.1 修改eureka-server的配置(application.yml)
server:
port: ${port:8761} # eureka服务端，默认端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中作为服务的id标识（serviceId）
eureka:
client:
service-url: # Eureka服务地址；如果是集群则是其它服务地址，后面要加/eureka
defaultZone: ${defaultZone:http://localhost:8761/eureka}
# 把fetch-registry和register-with-eureka修改为true或者注释掉(默认为true)
fetch-registry: true # 拉取服务(自已拉取对方的服务)
register-with-eureka: true # 注册自己(自已注册到对方)
# 在上述配置文件中的${}表示在jvm启动时候若能找到对应port或者defaultZone参数则使用，若无则使用后面的默认值。
- 所谓的高可用注册中心，其实就是把EurekaServer自己也作为一个服务，注册到其它EurekaServer上，这样多个EurekaServer之间就能互相发现对方，从而形成集群。
2.2同一套eureka server 模块代码，启动三个eureka，形成集群
8761：
8762：
8763：
2.3启动三个eureka
3.客户端注册服务到集群
因为EurekaServer不止一个，因此user-service项目注册服务或者user-consumer获取服务的时候，service-url参数需要变化：
# 配置eureka
eureka:
client:
service-url: # EurekaServer地址,多个地址以','隔开
defaultZone: http://localhost:8761/eureka,http://localhost:8762/eureka
七.eureka服务提供者的其他配置
服务注册
服务提供者在启动时，会检测配置属性中的： eureka.client.register-with-eureka=true
参数是否正确，事实上默认就是true。如果值确实为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，Eureka
Server会把这些信息保存到一个双层Map结构中。
- 第一层Map的Key就是服务id，一般是配置中的 spring.application.name 属性
- 第二层Map的key是服务的实例id。一般host+ serviceId + port，例如：locahost:user-service:9001
值则是服务的实例对象，也就是说一个服务，可以同时启动多个不同实例，形成集群。
默认注册时使用的是主机名，如果想用ip进行注册，可以在user-service中添加配置：
# 配置eureka
eureka:
instance:
ip-address: 127.0.0.1 # ip地址
prefer-ip-address: true # 更倾向于使用ip，而不是host名称
服务续约
在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉EurekaServer：“我还活着”。这个我们称为服务的续约（renew）
有两个重要参数可以修改服务续约的行为：
# 配置eureka
#默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会从服务列表中移除，这两个值在生产环境不要修改，默认即可。
eureka:
instance:
lease-renewal-interval-in-seconds: 30 # 服务续约(renew)的间隔时间，默认为30秒
lease-expiration-duration-in-seconds: 90 # 服务失效时间，默认值90秒
八.Eureka客户端：服务消费者的其他配置
获取服务列表
当服务消费者启动时，会检测 eureka.client.fetch-registry=true 参数的值，如果为true，则会从Eureka Server服务的列表只读备份，然后缓存在本地。并且 每隔30秒 会重新获取并更新数据。可以通过下面的参数来修改：
eureka:
client:
registry-fetch-interval-seconds: 30 # 获取服务间隔时间(默认30秒)
九.Eureka服务端：失效剔除、自我保护
- 服务下线
当服务进行正常关闭操作时，它会触发一个服务下线的REST请求给Eureka Server，告诉服务注册中心：“我要下线了”。服务中心接受到请求之后，将该服务置为下线状态。- 失效剔除
有时我们的服务可能由于内存溢出或网络故障等原因使得服务不能正常的工作，而服务注册中心并未收到“服务下线”的请求。相对于服务提供者的“服务续约”操作，服务注册中心在启动时会创建一个定时任务，默认每隔一段时间（默认为60秒）将当前清单中超时（默认为90秒）没有续约的服务剔除，这个操作被称为失效剔除。
可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒。- 自我保护
我们关停一个服务，就会在Eureka面板看到一条警告
这是触发了Eureka的自我保护机制。当服务未按时进行心跳续约时，Eureka会统计服务实例最近5分钟心跳续约的比例是否低于了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka在这段时间内不会剔除任何服务实例，直到网络恢复正常。生产环境下这很有效，保证了大多数服务依然可用，不过也有可能获取到失败的服务实例，因此服务调用者必须做好服务的失败容错。
可以通过下面的配置来关停自我保护：
eureka:
server:
enable-self-preservation: false # 关闭自我保护模式（缺省为打开）
