springcloud 实战 springcloud实战项目文档

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微服务简介：

一：新建父项目

二：搭建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的路径上