SpringCloud-demo案例 个人学习体会（非教程）

SpringCould简介

SpringCloud是Spring旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/

Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。

SpringCloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：
netflix

• Eureka：注册中心
• Zuul：服务网关
• Ribbon：负载均衡
• Feign：服务调用
• Hystix：熔断器
  

SpringCloud-demo

数据库情况：

1.创建父工程（cloud-demo）

首先先引入需要的依赖：

pom文件：

<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.0modelVersion>

    <groupId>cn.itcast.demogroupId>
    <artifactId>cloud-demoartifactId>
    <version>1.0.0-SNAPSHOTversion>
    <modules>
        <module>user-servicemodule>
        <module>consumer-demomodule>
        <module>eureka-servicemodule>
        <module>gatewaymodule>
    modules>
    <packaging>pompackaging>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.4.RELEASEversion>
        <relativePath/> 
    parent>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <java.version>1.8java.version>
        <spring-cloud.version>Finchley.SR1spring-cloud.version>
        <mapper.starter.version>2.0.3mapper.starter.version>
    properties>

<dependencyManagement>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-dependenciesartifactId>
            <version>${spring-cloud.version}version>
            <type>pomtype>
            <scope>importscope>
        dependency>
        
        <dependency>
            <groupId>tk.mybatisgroupId>
            <artifactId>mapper-spring-boot-starterartifactId>
            <version>${mapper.starter.version}version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.32version>
        dependency>
    dependencies>
dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
    dependency>
dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>


project>

上面是所需要的全部依赖

1.1部分解析：

创建聚合工程
	<packaging>pompackaging>
各种版本	
    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <java.version>1.8java.version>
        <spring-cloud.version>Finchley.SR1spring-cloud.version>
        <mapper.starter.version>2.0.3mapper.starter.version>
    properties>
提供SpringBoot的Maven插件
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

2.demo中的微服务：

在创建了父工程之后我们在这里列举一下我们在这个demo中会创建的微服务：
1.user-service
2.consumer-demo
3.eureka-service
4.gageway
上面这四个就是这次demo案例中我们要学习的4个微服务，我们将通过他们来了解SpringCloud。
其中user-service 是服务的提供者，consumer-demo是服务的调用者,eureka-service是一个注册中心，gageway是网关提供一些保护机制。

2.1 user-service

这是一个提供服务的微服务。

2.1.1首先我们先创建出这个服务：

1.右键单击父工程cloud-demo =>选择New=>选择Model:

2.然后进行工程的创建：
创建一个Maven工程，点击Next

写名称，点击Next

修改一下名称,点击Finish

2.1.2 引入依赖：

在pom文件中引入需要的依赖：

<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>cloud-demoartifactId>
        <groupId>cn.itcast.demogroupId>
        <version>1.0.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>user-serviceartifactId>
<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
    dependency>
    <dependency>
        <groupId>tk.mybatisgroupId>
        <artifactId>mapper-spring-boot-starterartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
dependencies>

project>

2.1.3 创建user-service微服务的整体结构

这是user-service的整体结构：

2.1.4 代码的编写：

a. 启动类UserApplication

在user-service => src => main => java 中创建包cn.itcast，并在其中创建UserApplication类


在UserApplication中编写代码：

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import tk.mybatis.spring.annotation.MapperScan;
@EnableDiscoveryClient//让这个服务被注册中心知道
@SpringBootApplication
@MapperScan("cn.itcast.user.mapper")//配置要扫描的mapper
public class UserApplication {
     
    public static void main(String[] args) {
     
        SpringApplication.run(UserApplication.class);//启动的方法
    }
}

b. 创建UserMapper接口

在user-service => src => main => java =>cn.itcast 中创建包user，在user包下创建mapper包，在mapper包中创建接口UserMapper。

注意： 这里的UserMapper接口所在包一定要与启动类中扫描的路径相同。

因为使用了通用Mapper因此接口代码如下：

package cn.itcast.user.mapper;

import cn.itcast.user.pojo.User;
import tk.mybatis.mapper.common.Mapper;//注意引用的包

public interface UserMapper extends Mapper<User> {
     
}

c. 编写实体类User

在user-service => src => main => java => cn.itcast => user 中创建pojo包，在pojo包中创建类User。

在实体类中编写代码：

package cn.itcast.user.pojo;


import lombok.Data;
import tk.mybatis.mapper.annotation.KeySql;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;
@Table(name = "db_user")//连接的数据库中的表的名字
@Data//使用lombok插件，因此不需要写get/set等方法
public class User {
     
    @Id//指定主键
    @KeySql(useGeneratedKeys = true)//主键是否自增
    private Integer id;
    private  String username;
    private Date birthday;
    private String sex;
    private String address;

}

d. 创建服务类UserService

在user-service => src => main => java => cn.itcast => user 中创建service包，在service包中创建类UserService。

编写代码：

package cn.itcast.user.service;

import cn.itcast.user.mapper.UserMapper;
import cn.itcast.user.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service//让Spring知道它
public class UserService {
     
    @Autowired//自动注入UserMapper 
    private UserMapper userMapper;
    public User queryById(Integer id){
     
     /*   try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/
        return userMapper.selectByPrimaryKey(id);//调用通用Mapper中方法根据主键查询
    }
}

e. 创建调用类UserController:

在user-service => src => main => java => cn.itcast => user 中创建web包，在web包中创建类UserController。

编写代码：

package cn.itcast.user.web;

import cn.itcast.user.pojo.User;
import cn.itcast.user.service.UserService;
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;

@RestController
/*
@RestController注解，相当于@Controller+@ResponseBody两个注解的结合，返回json数据不需要在方法前面加@ResponseBody注解了，但使用@RestController这个注解，就不能返回jsp,html页面，视图解析器无法解析jsp,html页面
*/
@RequestMapping("user")//表示类中的所有响应请求的方法都是以该地址作为父路径
public class UserController {
     
    @Autowired//自动注入UserService 
    private UserService userService;
    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Integer id){
     
    /*
    通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中:URL 中的 {xxx} 占位符可以通过@PathVariable("xxx") 绑定到操作方法的入参中。
    */
        return  userService.queryById(id);//调用UserService中方法
    }
}

f. 创建配置文件application.yml

在user-service => src => main => resources 中创建application.yml


编写配置：

#配置端口
server:
  port: 8081
#配置扫描包
mybatis:
  type-aliases-package: cn.itcast.user.pojo
#配置数据库链接
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis
    username: root
    password: abc
  #配置在eureka中服务名
  application:
    name: user-service
#配置eureka
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
#配置全局的超时时长
#hystrix:
  #command:
    #default:
      #execution:
        #isolation:
          #thread:
            #timeoutInMilliseconds: 3000

注意： 一定要注意编写规范，注意空格

2.1.5 user-service 测试：

2.2 consumer-demo:

这是一个调用服务的微服务

2.2.1 创建consumer-demo

创建方法同创建 user-service,在cloud-demo下 New 一个 Module 选择Maven工程，输入名称。

2.2.2 引入依赖

在pom中引入依赖：（注意是consumer-demo这个微服务的pom文件）

<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>cloud-demoartifactId>
        <groupId>cn.itcast.demogroupId>
        <version>1.0.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>consumer-demoartifactId>
<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>


    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
        <version>2.0.1.RELEASEversion>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-openfeignartifactId>
    dependency>
dependencies>

project>

2.2.3 创建consumer-demo微服务整体结构

这是consume-demo的整体结构

2.2.4 编写代码

a.consumer-demo的启动类

在consumer-demo => src => main => java 中创建包cn.itcast，并在其中创建ConsumerApplication类

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
//@EnableCircuitBreaker
//@EnableDiscoveryClient
//@SpringBootApplication
@SpringCloudApplication//是上面三个注解的集合，需要引入上面三个注解的对应依赖
@EnableFeignClients
public class ConsumerApplication {
     
    //在使用Feign之后可以不用写了,使用之前需要写
//    @Bean
//    //负载均衡注解，加在restTemplate
//    @LoadBalanced
//    public RestTemplate restTemplate(){
     
//        return new RestTemplate();
//    }

    public static void main(String[] args) {
     
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

b. 用户实体类User

在包 cn.itcast 中创建包 consumer 并在其中创建pojo包，然后在pojo包中创建User实体类。

和user-service有一些区别：

package cn.itcast.consumer.pojo;

import lombok.Data;

import java.util.Date;
@Data
public class User {
     

    private Integer id;
    private  String username;
    private Date birthday;
    private String sex;
    private String address;

}

c. 创建ConsumerController控制类

在包 consumer 中创建web包，然后在web包中创建ConsumerController类。

package cn.itcast.consumer.web;

import cn.itcast.consumer.client.UserClient;
import cn.itcast.consumer.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.netflix.ribbon.RibbonLoadBalancerClient;
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")
//@DefaultProperties(defaultFallback = "queryByIdFallback")
public class ConsumerController {
     

    /* @Autowired
     private RestTemplate restTemplate;
 */
    /*    @Autowired
        private RibbonLoadBalancerClient client;*/

    //远程调用，也是最终形态
    @Autowired
    private UserClient userClient;

    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Integer id) {
     
        return userClient.queryById(id);

    }
    // @GetMapping("{id}")
    //开启服务降级,设置熔断或者其他的
    //  @HystrixCommand

    /*(commandProperties = {
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60")
    })*/
    //设置超时时长(commandProperties =
    // {@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "2000")
    // })

    //(fallbackMethod = "queryByIdFallback")
    //两个方法的返回值类型和参数列表必须完全相同

/*    public String queryById(@PathVariable("id") Integer id) {

        if (id % 2 == 0) {
            throw new RuntimeException("");
        }
        String url = "http://user-service/user/" + id;
        String user = restTemplate.getForObject(url, String.class);
        return user;
    }*/

    /*   public String queryByIdFallback(Integer id) {

           return "服务器拥挤";
       }*/
/*    public String queryByIdFallback() {
        return "服务器拥挤";
    }*/

/*    @GetMapping("{id}")
    public User queryById(@PathVariable("id") Integer id) {
        //根据服务ID获取实例
        //  List instances = discoveryClient.getInstances("user-service");
        //从实例中取出ip和端口
        // ServiceInstance serviceInstance = instances.get(0);
        //默认轮询
        *//*ServiceInstance serviceInstance = client.choose("user-service");
        String url = "http://" + serviceInstance.getHost() + ":" + serviceInstance.getPort() + "/user/" + id;*//*
       //使用负载均衡之后
        String url = "http://user-service/user/" + id;
        User user = restTemplate.getForObject(url, User.class);
        return user;
    }*/
}

注意： 这里面注释的代码是在从最一开始最基本的到相对完整的一个过渡，可以理解的看一看，从一开始只是单纯的远程调用 user-service ，到加入eureka,负载均衡(Ribbon)，熔断(Hystix)，Feign等等，大家可以根据需要去设置超时时长等参数。

d.创建 UserClient 接口和 UserClientImpl 类

在包 consumer 中创建 client 包，然后在 client 包中创建 UserClient 接口和 UserClientImpl 类。

使用 Feign 的时候 需要写一个接口，要想使用 Feign 的负载均衡什么的需要写一个接口的实现类。
在使用 Feign 的时候，Controller 中的方法也要注意变化。而且还要注意在启动类中加入启动注解。

接口代码：

package cn.itcast.consumer.client;

        import cn.itcast.consumer.pojo.User;
        import org.springframework.cloud.openfeign.FeignClient;
        import org.springframework.web.bind.annotation.GetMapping;
        import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "user-service",fallback = UserClientImpl.class)//开启Feign功能和使用熔断
public interface UserClient {
     
    @GetMapping("user/{id}")
    User queryById(@PathVariable("id") Integer id);
}

实现类代码：

package cn.itcast.consumer.client;

import cn.itcast.consumer.pojo.User;
import org.springframework.stereotype.Component;
//Feign里配置熔断
@Component//注入进Spring容器
public class UserClientImpl implements UserClient {
     
    @Override
    public User queryById(Integer id) {
     
        User user = new User();
        user.setUsername("未查询到");
        return user;
    }
}

e.配置文件application.yml

这个配置文件创造和 user-service 相同：

server:
  port: 8082
spring:
  application:
    name: consumer-service
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
#在Feign中需要配置超时时长，开启hystrix
ribbon:
  ConnectionTimeOut: 500
  ReadTimeOut: 2000
feign:
  hystrix:
    enabled: true

2.2.5 consumer-demo测试：

2.3 eureka-service

这是一个注册中心，Eureka就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。

同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。

这就实现了服务的自动注册、发现、状态监控。

• Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
• 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
• 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
• 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

2.3.1 创建eureka-service

创建方法同创建 user-service,在cloud-demo下 New 一个 Module 选择Maven工程，输入名称。

2.3.2 eureka-service整体结构

2.3.3 引入依赖

在 eureka-service 的 pom 中引入依赖：

<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>cloud-demoartifactId>
        <groupId>cn.itcast.demogroupId>
        <version>1.0.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>eureka-serviceartifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
        dependency>
    dependencies>
project>

2.3.4 编写代码：

a.创建启动类EurekaService

在 eureka-service => src => main => java 中创建包cn.itcast，并在其中创建EurekaService类

启动类代码：

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer//启动eureka
@SpringBootApplication
public class EurekaService {
     
    public static void main(String[] args) {
     
        SpringApplication.run(EurekaService.class);
    }
}

b.创建配置文件application.yml

方法同前

server:
  port: 10087
#需要给服务起一个名字
spring:
  application:
    name: eurrka-server
#MAP集合的配置需要在下面配置，前面是键后面是值，这里是另外一个eureka的地址
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

2.3.5 eureka-service测试：

2.4 gateway

不管是来自于客户端（PC或移动端）的请求，还是服务内部调用。一切对服务的请求都会经过Zuul这个网关，然后再由网关来实现 鉴权、动态路由等等操作。Zuul就是我们服务的统一入口。

2.4.1 创建gateway

方法同上。

2.4.2 gateway 整体结构

2.4.3 导入依赖

在pom中导入：

<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>cloud-demoartifactId>
        <groupId>cn.itcast.demogroupId>
        <version>1.0.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>gatewayartifactId>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-zuulartifactId>
    dependency>
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
    dependency>
    <dependency>
        <groupId>org.apache.commonsgroupId>
        <artifactId>commons-lang3artifactId>
    dependency>
dependencies>
project>

2.4.4 编写代码：

a.启动类GatewayApplication

在 gateway => src => main => java 中创建包cn.itcast，并在其中创建GatewayApplication类

GatewayApplication代码：

package cn.itcast;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@EnableZuulProxy
@SpringBootApplication
public class GatewayApplication {
     
    public static void main(String[] args) {
     
        SpringApplication.run(GatewayApplication.class);
    }
}

b.创建一个测试LoginFliter:

在包 cn.itcast 中创建 filter 包并在 filter 包中创建 LoginFliter 类

编写代码：

package cn.itcast.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Component
public class LoginFilter extends ZuulFilter {
     
    @Override
    //类型
    public String filterType() {
     
        return FilterConstants.PRE_TYPE;
    }

    @Override
    //顺序
    public int filterOrder() {
     
        return FilterConstants.PRE_DECORATION_FILTER_ORDER - 1;
    }

    @Override
    //要不要过滤
    public boolean shouldFilter() {
     
        return true;
    }

    @Override
    //业务逻辑
    public Object run() throws ZuulException {
     
        //获取请求上下文
        RequestContext ctx = RequestContext.getCurrentContext();
        //获取request
        HttpServletRequest request = ctx.getRequest();
        //获取请求参数access-token
        String token = request.getParameter("access-token");
        //判断是否存在
        if(StringUtils.isBlank(token)){
     
            //不存在，未登录,则拦截，不管的话默认放行
            ctx.setSendZuulResponse(false);
            //返回403
            ctx.setResponseStatusCode(HttpStatus.FORBIDDEN.value());
        }


        return null;
    }
}

c.配置文件application.yml

创建方法同上。

server:
  port: 10010
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10087/eureka
#路由功能:
zuul:
  prefix: /api #添加前缀，访问的时候也要添加前缀，http://localhost:10010/api/user/user/1
  routes:
    #路由id
    user-service: /user/**
  #最终简化版，key（路由id）是服务的id，值是服务的映射（/user/**），有默认的 user-service: /user-service/**可以不用写，它自动从eureka上获取
     # path: /user/** #访问以user打头的所有路径,用户请求到达，首先匹配路径，在转发到serviceID那个服务，访问的时候是http://localhost:10010/user/user/1，两个user
    # url: http://127.0.0.1:8081 #转发到这个地址
      #serviceId: user-service
  ignored-services:
    - consumer-service
#不想被访问到的服务，集合形式配置方式
    # - consumer-service ，后面可以这样罗列
spring:
  application:
    name: gateway
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 6000
ribbon: #这个时长相加*2不要超过hystrix的时长
  Connectionyimeout: 500
  ReadTimeout: 2000

2.4.5 整体测试：

至此，全部结束

这是第一次写博客，也是自己第一次进行学习记录，希望大家可以指出一些不足，大家一起进步。文章是个人的学习笔记，记录，不是教程，毕竟我只是一个刚学java的小菜鸟，所以这个文章仅供参考，要是能帮助到别人就更好啦~QWQ