Spring Cloud项目
Spring Cloud项目
- （一）Spring Cloud Eureka:服务注册与发现
-
- 一：新建父项目
- 二：搭建Eureka注册中心
-
- 1、创建一个eureka-server模块，并使用Spring Initializer初始化一个SpringBoot项目
- 2、填写应用信息
- 3、选择你需要的SpringCloud组件进行创建
- 4、在启动类上添加@EnableEurekaServer注解来启用Eureka注册中心功能
- 5、在配置文件application.yml中添加Eureka注册中心的配置
- 6、运行SpringCloud应用，运行完成后访问地址http://localhost:8001/可以看到Eureka注册中心的界面
- 三、搭建Eureka客户端
-
- 1、创建一个eureka-client模块，并使用Spring Intializer初始化一个SpringBoot项目
- 2、填写应用信息
- 3、选择你需要的SpringCloud组件进行创建
- 4、在启动类上添加@EnableDiscoveryClient注解表明是一个Eureka客户端
- 5、在配置文件application.yml中添加Eureka客户端的配置
- 6、运行eureka-client
- 7、查看注册中心http://localhost:8001/发现Eureka客户端已经成功注册
- 四、按照步骤三创建Eureka客户端eureka-client1
- (二、服务之间的调用)
-
- 一、Spring Cloud OpenFeign：基于Ribbon和Hystrix的声明式服务调用
- 二、案例
-
- 请求服务eureka-client1 test()方法调用服务eureka-client hello()方法
- 1、在pom.xml中添加相关依赖
- 2、在客户端application.yml中添加配置数据库的连接信息
- 3、在启动类上添加@EnableFeignClients注解来启用Feign的客户端功能
- 4、eureka-client服务
-
- 1）在包controller下，新建HelloController类
- 5、eureka-client1服务
-
- 1）在包controller下，新建UserController类
- 2)在包service下，新建UserService接口和UserServiceImpl类
- 3)在包domain下，新建UserMapper
- 4）测试
- 案例二-提供User对象
-
- eureka-client服务
-
- 1）在包pojo下，新建User实体类
- 2）在HelloController.java增加getUser
- eureka-client1服务
-
- 1）在包domain下，新建User实体类
- 2）UserMapper.java
- 3）在包service下,UserService添加getClientUser方法和方法实现类UserServiceImpl
- 4）UserController.java
- 5）测试
- 三（Spring Cloud Gateway：新一代API网关服务）
- 被调用服务中是User对象
-
- 一、创建一个eureka-gateway模块
-
- 1、创建一个eureka-gateway模块，并使用Spring Initializer初始化一个SpringBoot项目
- 2、填写应用信息
- 3、勾选Gateway依赖
- 4、新建application.yml，并在在application.yml配置路由
- 二、创建一个spring-cloud-api公共模块
-
- Eureka-client1与Eureka-client都包含实体类User,把实体类抽取到公共模块
- 1、创建一个eureka-gateway模块，并使用Spring Initializer初始化一个SpringBoot项目
- 2、填写应用信息
- 3、选择你需要的SpringCloud组件进行创建
- 4、新建包pojo，创建实体类User
- 三、eureka-client1模块
-
- 1、模块eureka-client1中导入依赖，删除pojo
- 2、UserController.java
- 3、UserService.java
- 4、UserServiceImpl.java
- 5、UserMapper.java
- 四、eureka-client模块
-
- 1、模块eureka-client中导入依赖,删除pojo
- 2、导入实体类包可以更改
- 3、HelloController.java添加restful风格的方法
- 4、启动eureka-server,eureka-client和eureka-gateway服务，并调用该地址测试：http://localhost:9201/user/1
（一）Spring Cloud Eureka:服务注册与发现
学习链接：
Spring Cloud构建微服务架构：服务注册与发现（Eureka、Consul）【Dalston版】：https://blog.didispace.com/spring-cloud-starter-dalston-1/
Spring Cloud微服务简介：https://blog.csdn.net/cjtxzg/article/details/80535685
一：新建父项目
二：搭建Eureka注册中心
1、创建一个eureka-server模块，并使用Spring Initializer初始化一个SpringBoot项目
2、填写应用信息
3、选择你需要的SpringCloud组件进行创建
4、在启动类上添加@EnableEurekaServer注解来启用Eureka注册中心功能
5、在配置文件application.yml中添加Eureka注册中心的配置
application.yml
server:
port: 8001 #指定运行端口
spring:
application:
name: eureka-server #指定服务名称
eureka:
instance:
hostname: localhost #指定主机地址
client:
fetch-registry: false #指定是否从注册中心获取服务(注册中心不需要开启)
register-with-eureka: false #指定是否要注册到注册中心(注册中心不需要开启)
server:
enable-self-preservation: false #关闭保护模式
6、运行SpringCloud应用，运行完成后访问地址http://localhost:8001/可以看到Eureka注册中心的界面
三、搭建Eureka客户端
1、创建一个eureka-client模块，并使用Spring Intializer初始化一个SpringBoot项目
2、填写应用信息
3、选择你需要的SpringCloud组件进行创建
4、在启动类上添加@EnableDiscoveryClient注解表明是一个Eureka客户端
5、在配置文件application.yml中添加Eureka客户端的配置
application.yml
server:
port: 8101 #运行端口号
spring:
application:
name: eureka-client #服务名称
eureka:
client:
register-with-eureka: true #注册到Eureka的注册中心
fetch-registry: true #获取注册实例列表
service-url:
defaultZone: http://localhost:8001/eureka/ #配置注册中心地址
6、运行eureka-client
7、查看注册中心http://localhost:8001/发现Eureka客户端已经成功注册
四、按照步骤三创建Eureka客户端eureka-client1
(二、服务之间的调用)
一、Spring Cloud OpenFeign：基于Ribbon和Hystrix的声明式服务调用
Spring Cloud OpenFeign 是声明式的服务调用工具，它整合了Ribbon和Hystrix，拥有负载均衡和服务容错功能。
Feign是声明式的服务调用工具，我们只需创建一个接口并用注解的方式来配置它，就可以实现对某个服务接口的调用，简化了直接使用RestTemplate来调用服务接口的开发量。
Feign具备可插拔的注解支持，同时支持Feign注解、JAX-RS注解及SpringMvc注解。
当使用Feign时，Spring Cloud集成了Ribbon和Eureka以提供负载均衡的服务调用及基于Hystrix的服务容错保护功能。
二、案例
请求服务eureka-client1 test()方法调用服务eureka-client hello()方法
目录文件：
1、在pom.xml中添加相关依赖
在eureka-client客户端的pom.xml导入
如果创建项目之前勾选了相关组建，部分包就不需要再次引入
<!--导入Feign的依赖包-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!--MyBatis 整合 SpringBoot 的起步依赖-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.0</version>
</dependency>
<!--MySQL 的驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--jdbc 的驱动依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
2、在客户端application.yml中添加配置数据库的连接信息
application.yml
spring:
#配置数据库的连接信息
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/newsdata?serverTimezone=UTC
username: root
password: 123456
eureka-client完整的application.yml：
server:
port: 8101 #运行端口号
spring:
application:
name: eureka-client #服务名称
#配置数据库的连接信息
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/newsdata?serverTimezone=UTC
username: root
password: 123456
eureka:
client:
register-with-eureka: true #注册到Eureka的注册中心
fetch-registry: true #获取注册实例列表
service-url:
defaultZone: http://localhost:8001/eureka/ #配置注册中心地址
eureka-client1完整的application.yml：
server:
port: 8108 #运行端口号
spring:
application:
name: eureka-client1 #服务名称
#配置数据库的连接信息
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/newsdata?serverTimezone=UTC
username: root
password: 123456
eureka:
client:
register-with-eureka: true #注册到Eureka的注册中心
fetch-registry: true #获取注册实例列表
service-url:
defaultZone: http://localhost:8001/eureka/ #配置注册中心地址
3、在启动类上添加@EnableFeignClients注解来启用Feign的客户端功能
eureka-client和eureka-client1客户端
@EnableFeignClients//Feign客户端
@EnableDiscoveryClient//Eureka客户端
@SpringBootApplication
public class EurekaClient1Application {
public static void main(String[] args) {
SpringApplication.run(EurekaClient1Application.class, args);
}
}
4、eureka-client服务
1）在包controller下，新建HelloController类
@Controller
public class HelloController {
@ResponseBody
@RequestMapping("/hello")
public String hello(){
return "Hello world!";
}
}
5、eureka-client1服务
1）在包controller下，新建UserController类
@Controller
public class UserController {//服务的消费者(取消费者)
@Resource
UserService userService;
@ResponseBody
@RequestMapping("/test")
public String test(){
//业务逻辑层
String s=userService.test();
return s;
}
}
2)在包service下，新建UserService接口和UserServiceImpl类
UserService.java
public interface UserService {
public String test();
}
UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
@Resource
UserMapper userMapper;
@Override
public String test() {
//调用数据访问层
return userMapper.test();
}
}
3)在包domain下，新建UserMapper
@FeignClient("eureka-client")//调用哪个服务器
@ResponseBody
public interface UserMapper {
@RequestMapping("/hello")
public String test();
}
4）测试
案例二-提供User对象
eureka-client服务
1）在包pojo下，新建User实体类
public class User {
private Integer uid;
private String uname;
private String upwd;
public User() {
}
public User(Integer uid, String uname, String upwd) {
this.uid = uid;
this.uname = uname;
this.upwd = upwd;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
}
2）在HelloController.java增加getUser
@Controller
public class HelloController {//服务的提供方
//返回字符串
@ResponseBody
@RequestMapping("/hello")
public String hello(){
return "Hello world!";
}
//返回对象
@ResponseBody
@RequestMapping("/getUser")//提供User对象
public User getUser(){
User user=new User(1,"admin","admin");
return user;
}
}
eureka-client1服务
1）在包domain下，新建User实体类
public class User {
private Integer uid;
private String uname;
private String upwd;
public User() {
}
public User(Integer uid, String uname, String upwd) {
this.uid = uid;
this.uname = uname;
this.upwd = upwd;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
}
2）UserMapper.java
@FeignClient("eureka-client")//调用哪个服务器
@ResponseBody
public interface UserMapper {
@RequestMapping("/hello")
public String test();
@RequestMapping("/getUser")
public User getClientUser();
}
3）在包service下,UserService添加getClientUser方法和方法实现类UserServiceImpl
UserService.java
public interface UserService {
public String test();
//得到提供方的User对象
public User getClientUser();
}
UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
@Resource
UserMapper userMapper;
@Override
public String test() {
//调用数据访问层
return userMapper.test();
}
@Override
public User getClientUser() {
//调用数据访问层
return userMapper.getClientUser();
}
}
4）UserController.java
@Controller
public class UserController {//服务的消费者(取消费者)
@Resource
UserService userService;
@ResponseBody
@RequestMapping("/test")
public String test(){
//业务逻辑层
String s=userService.test();
return s;
}
@ResponseBody
@RequestMapping("/getUser")
public User getClientUser(){
//业务逻辑层
User user = userService.getClientUser();
return user;
}
}
5）测试
三（Spring Cloud Gateway：新一代API网关服务）
被调用服务中是User对象
Spring Cloud Gateway 为 SpringBoot 应用提供了API网关支持，具有强大的智能路由与过滤器功能，例如：熔断、限流、重试等。
Spring Cloud Gateway 具有如下特性：
基于Spring Framework 5, Project Reactor 和 Spring Boot 2.0 进行构建；
动态路由：能够匹配任何请求属性；
可以对路由指定 Predicate（断言）和 Filter（过滤器）；
集成Hystrix的断路器功能；
集成 Spring Cloud 服务发现功能；
易于编写的 Predicate（断言）和 Filter（过滤器）；
请求限流功能；
支持路径重写。
相关概念
Route（路由）：路由是构建网关的基本模块，它由ID，目标URI，一系列的断言和过滤器组成，如果断言为true则匹配该路由；
Predicate（断言）：指的是Java 8 的 Function Predicate。 输入类型是Spring框架中的ServerWebExchange。
这使开发人员可以匹配HTTP请求中的所有内容，例如请求头或请求参数。如果请求与断言相匹配，则进行路由；
Filter（过滤器）：指的是Spring框架中GatewayFilter的实例，使用过滤器，可以在请求被路由前后对请求进行修改。
一、创建一个eureka-gateway模块
1、创建一个eureka-gateway模块，并使用Spring Initializer初始化一个SpringBoot项目
2、填写应用信息
3、勾选Gateway依赖
4、新建application.yml，并在在application.yml配置路由
application.yml
#端口号
server:
port: 9201
#客户端eureka-client服务地址
service-url:
eureka-client: http://localhost:8101
#配置路由
spring:
cloud:
gateway:
routes:
- id: path_route #路由的ID
uri: ${service-url.eureka-client}/hello #匹配后路由地址
predicates:
- Path=/user/{uid} #断言，路径相匹配的进行路由
二、创建一个spring-cloud-api公共模块
Eureka-client1与Eureka-client都包含实体类User,把实体类抽取到公共模块
1、创建一个eureka-gateway模块，并使用Spring Initializer初始化一个SpringBoot项目
2、填写应用信息
3、选择你需要的SpringCloud组件进行创建
4、新建包pojo，创建实体类User
User.java
public class User {
private Integer uid;
private String uname;
private String upwd;
public User() {
}
public User(Integer uid, String uname, String upwd) {
this.uid = uid;
this.uname = uname;
this.upwd = upwd;
}
public Integer getUid() {
return uid;
}
public void setUid(Integer uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpwd() {
return upwd;
}
public void setUpwd(String upwd) {
this.upwd = upwd;
}
}
三、eureka-client1模块
1、模块eureka-client1中导入依赖，删除pojo
<!--导入spring-cloud-api依赖-->
<dependency>
<groupId>com.macro.cloud</groupId>
<artifactId>spring-cloud-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
2、UserController.java
@Controller
public class UserController {//服务的消费者(取消费者)
@Resource
UserService userService;
@ResponseBody
@RequestMapping("/test")
public String test(){
//业务逻辑层
String s=userService.test();
return s;
}
@ResponseBody
@RequestMapping("/getUser")
public User getClientUser(){
//业务逻辑层
User user = userService.getClientUser();
return user;
}
@ResponseBody
//@RequestMapping("/getUser")
@GetMapping("/user/{uid}")
public User getUser(@PathVariable Integer uid){
return userService.getUser(uid);
}
}
3、UserService.java
public interface UserService {
public String test();
//得到提供方的User对象
public User getClientUser();
public User getUser(Integer uid);
}
4、UserServiceImpl.java
@Service
public class UserServiceImpl implements UserService {
@Resource
UserMapper userMapper;
@Override
public String test() {
//调用数据访问层
return userMapper.test();
}
@Override
public User getClientUser() {
//调用数据访问层
return userMapper.getClientUser();
}
@Override
public User getUser(Integer uid) {
return userMapper.getUser(uid);
}
}
5、UserMapper.java
@FeignClient("eureka-client")//调用哪个服务器
@ResponseBody
public interface UserMapper {
@RequestMapping("/hello") //被调服务的方法
public String test();
@RequestMapping("/getUser")
public User getClientUser();
//restful风格
@GetMapping("/user/{uid}")
public User getUser(@PathVariable Integer uid);
}
四、eureka-client模块
1、模块eureka-client中导入依赖,删除pojo
<!--导入spring-cloud-api依赖-->
<dependency>
<groupId>com.macro.cloud</groupId>
<artifactId>spring-cloud-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
</dependency>
2、导入实体类包可以更改
原来
import com.micro.client.pojo.User;
更改后
import com.macro.cloud.pojo.User;
3、HelloController.java添加restful风格的方法
@Controller
public class HelloController {//服务的提供方
//返回字符串
@ResponseBody
@RequestMapping("/hello")
public String hello(){
return "hello world!";
}
//返回对象
@ResponseBody
@RequestMapping("/getUser")
public User getUser(){
User user=new User(1,"admin","admin");
return user;
}
//返回对象,restful风格
@ResponseBody
@GetMapping("/user/{uid}")
public User getUserById(@PathVariable("uid") Integer uid){
User user=new User(1,"admin","admin");
return user;
}
}
4、启动eureka-server,eureka-client和eureka-gateway服务，并调用该地址测试：http://localhost:9201/user/1
发现该请求被路由到了eureka-client的路径上
