SpringCloud-网关ZUUL

项目结构

父工程(每一个服务都是一个子工程)

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>com.xiaoge.demo</groupId>
    <artifactId>zuul-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>user-service</module>
        <module>consumer-demo</module>
        <module>eureka-server</module>
        <module>gateway</module>
    </modules>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

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

    <dependencyManagement> <!-- 所有子工程, 必须引下面的依赖才会有 -->
        <dependencies>
            <!-- spring cloud 引用了它, 以后cloud依赖版本就不用写了 -->
            <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.starter.version}</version>
            </dependency>

            <!-- mysql驱动 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <dependencies> <!-- 因为不会再dependencyManagement标签里, 所以所有的子工程都可以用 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

</project>

consumer-demo服务

配置文件

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>zuul-demo</artifactId>
        <groupId>com.xiaoge.demo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer-demo</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 引入eureka客户端依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- 导入hystrix依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>

        <!-- 引入feign依赖 里面自带hystrix熔断器基本依赖(所以我这里还是需要导入hystrix-SpringCloud相关的依赖)和ribbon负载均衡依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

    </dependencies>

</project>

application.yml

server:
  port: 8088
spring:
  # 在eureka中注册的服务名称
  application:
    name: consumer-service

# 注册方
# eureka配置 因为它要去注册中心注册, 所以要配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka, http://127.0.0.1:10087/eureka # 配置所有的eureka地址, 防止其中一个eureka挂掉
    registry-fetch-interval-seconds: 3 # 设置拉取服务列表的周期 为3秒
    fetch-registry: true # 默认为true 拉取列表, 改为false 不拉取
  instance:
    prefer-ip-address: true # 我希望使用ip地址
    ip-address: 127.0.0.1 # 设置ip地址

# 开启feign里面的hystrix
feign:
  hystrix:
    enabled: true

# feign里面的ribbon配置
ribbon:
  # 连接超时时长 500毫秒, 500毫秒没建立连接, 抛出异常
  ConnectionTimeOut: 500
  # 读取超时时长 2秒, 2秒没有读取到数据, 抛出异常
  ReadTimeOut: 2000

# 设置 hystrix默认指令
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000  # 设置全局方法 的 超时 时间 为 3秒  超过  3秒  执行错误方法

启动类

ConsumerApplication

package com.xiaoge;

import org.springframework.boot.SpringApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

/**
 * @program: cloud-demo
 * @description: 服务调用方
 * @author: Mr.Xiao
 * @create: 2020-05-04 16:04
 **/
// @EnableCircuitBreaker // hystrix注解
// @EnableDiscoveryClient // 它也是客户端, 它捷能兼容eureka 又能consul、zookeeper等等, 更通用, 更广泛
// @SpringBootApplication

@EnableFeignClients  // feign注解-开启feign功能
@SpringCloudApplication // 它的功能就是上面三个注解的功能
public class ConsumerApplication {

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

}

实体类

User

package com.xiaoge.Consumer.pojo;

import lombok.Data;

import java.io.Serializable;
import java.util.Date;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 16:06
 **/
@Data
public class User implements Serializable {
    // 主键
    private Long id;

    // 用户名
    private String username;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;

}

Feign客户端

UserClient接口

package com.xiaoge.Consumer.client;

import com.xiaoge.Consumer.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @program: feign_demo
 * @description: 告诉feign 请求服务 请求方式 请求路径 请求参数 返回结果
 * @author: Mr.Xiao
 * @create: 2020-05-18 20:43
 **/
@FeignClient(value = "user-service", fallback = UserClientFallback.class) // 告诉feign服务名称, 告诉feign方法异常要执行的类
public interface UserClient {

    @GetMapping("user/{id}")
    User queryById(@PathVariable("id") Long id);

}

UserClientFallback实现类

package com.xiaoge.Consumer.client;

import com.xiaoge.Consumer.pojo.User;
import org.springframework.stereotype.Component;

/**
 * @program: feign_demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-18 21:07
 **/
@Component
public class UserClientFallback implements UserClient {

    /**
     * 写熔断的业务逻辑
     * @param id
     * @return
     */
    @Override
    public User queryById(Long id) {
        User user = new User();
        user.setUsername("未知用户!");
        return user;
    }
}

表现层

ConsumerController

package com.xiaoge.Consumer.controller;

import com.xiaoge.Consumer.client.UserClient;
import com.xiaoge.Consumer.pojo.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;


/**
 * @program: cloud-demo
 * @description: 动态拉取服务列表
 * @author: Mr.Xiao
 * @create: 2020-05-04 16:08
 **/
@RestController
@RequestMapping("/consumer")
public class ConsumerController {

    @Autowired
    private UserClient userClient;

    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id){
        // 1. 引入feign依赖

        // 2. 在启动器上加上feign注解 @EnableFeignClients

        // 3. 编写UserClient接口, 用spring mvc的注解方式告诉feign 请求服务 请求方式 请求路径 请求参数 返回结果

        // 4. 调用
        return userClient.queryById(id);
    }

}

eureka-server服务

配置文件

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>zuul-demo</artifactId>
        <groupId>com.xiaoge.demo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eureka-server</artifactId>

    <dependencies>
        <!-- springcloud 注册中心 eureka -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

application.yml

# 这是eureka的默认端口号
server:
  port: 10086

# 配置eureka服务名称
spring:
  application:
    name: eureka-server

# 注册方
# 告诉eureka要注册的地址在哪里 (这样eureka就不会报一个com.sun.jersey.api.client.ClientHandlerException异常)
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka # 配置所有的eureka地址, 防止其中一个eureka挂掉
    register-with-eureka: false  # 默认为true 注册自己, 改为false 不 注册自己
  instance:
    prefer-ip-address: true # 我希望使用ip地址
    ip-address: 127.0.0.1 # 设置ip地址
  server:
    eviction-interval-timer-in-ms: 60000 # 设置eureka失效剔除时长, 每隔60秒失效剔除一次, 失效剔除挂掉的eureka

启动类

EurekaServer

package com.xiaoge;

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

/**
 * @program: cloud-demo
 * @description: EurekaServer端
 * @author: Mr.Xiao
 * @create: 2020-05-04 16:34
 **/
@EnableEurekaServer // 启动Eureka服务
@SpringBootApplication
public class EurekaServer {

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

}

user-service服务

配置文件

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>zuul-demo</artifactId>
        <groupId>com.xiaoge.demo</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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>

        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>

        <!-- 引入eureka(注册中心)-客户端 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

</project>

application.yml

server:
  port: 9090
spring:
  # 在eureka中注册的服务名称
  application:
    name: user-service
  # 数据库连接信息配置
  datasource:
    url: jdbc:mysql://localhost:3306/yun6
    username: root
    password: 123456
    hikari:
      maximum-pool-size: 20
      minimum-idle: 10
# 别名包
mybatis:
  type-aliases-package: com.xiaoge.user.pojo

# 注册方
# eureka配置 因为它要去注册中心注册, 所以要配置
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka, http://127.0.0.1:10087/eureka # 配置所有的eureka地址, 防止其中一个eureka挂掉
  instance:
    prefer-ip-address: true # 我希望使用ip地址
    ip-address: 127.0.0.1 # 设置ip地址
    lease-renewal-interval-in-seconds: 30 # 每隔30秒发一次心跳
    lease-expiration-duration-in-seconds: 90 # 每隔30秒发一次心跳, 如果隔了90秒都没发, 那就证明挂了

启动类

UserApplication

package com.xiaoge;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import tk.mybatis.spring.annotation.MapperScan;

/**
 * @program: cloud-demo
 * @description: 服务的提供方
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:43
 **/
@EnableDiscoveryClient // 它也是客户端, 它捷能兼容eureka 又能consul、zookeeper等等, 更通用, 更广泛
@SpringBootApplication
@MapperScan("com.xiaoge.user.mapper")
public class UserApplication {

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

}

实体类

User

package com.xiaoge.user.pojo;

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

import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:46
 **/
@Table(name = "tb_user")
@Data
public class User implements Serializable {

    @Id
    @KeySql(useGeneratedKeys = true) // id自动增长
    private Long id;

    // 用户名
    private String username;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;

}

表现层

UserController

package com.xiaoge.user.controller;

import com.xiaoge.user.pojo.User;
import com.xiaoge.user.service.UserService;
import org.apache.tomcat.jni.Time;
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;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:51
 **/
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        User user = userService.queryById(id);
        return user;
    }

}

业务层

UserService接口

package com.xiaoge.user.service;

import com.xiaoge.user.pojo.User;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:50
 **/
public interface UserService {

    public User queryById(Long id);

}

UserServiceImpl实体类

package com.xiaoge.user.service.impl;

import com.xiaoge.user.mapper.UserMapper;
import com.xiaoge.user.pojo.User;
import com.xiaoge.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:51
 **/
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public User queryById(Long id) {
        return userMapper.selectByPrimaryKey(id);
    }
}

Mapper

UserMapper

package com.xiaoge.user.mapper;


import com.xiaoge.user.pojo.User;
import tk.mybatis.mapper.common.Mapper;

/**
 * @program: cloud-demo
 * @description:
 * @author: Mr.Xiao
 * @create: 2020-05-04 15:49
 **/

public interface UserMapper extends Mapper<User> {
}

gateway网关

配置文件

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>zuul-demo</artifactId>
        <groupId>com.xiaoge.demo</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>gateway</artifactId>

    <dependencies>

        <!-- 引入eureka依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <!-- 引入zuul依赖 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
    </dependencies>


</project>

application.yml

server:
  port: 10010
spring:
  # 在eureka中注册的服务名称
  application:
    name: gateway

# 从eureka中拉取服务列表
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

# 配置路由规则
# zuul:
#   routes:
#     user-service: # 是个map结构, 键是个字符串可以随便写, 不重复就行, 所以我这里写了个hehe, 值是路由规则
#       path: /user-server/** # 路由规则
#       serviceId: user-service  # 应用id
# 当用户请求到达, 首先匹配路径, 匹配成功转发到user-service服务,
# 底层调用eureka拉去服务列表, 然后利用负载均衡算法, 动态从里面获取一个地址


# 简化写法
# zuul:
#   routes:
#     user-service: /user-service/** # key是服务的id, value是这个服务的映射路径



# 重点: 但是zuul 默认是把每一个微服务都是这样配置的, 你不配置, 默认这样的路径, 也是可以访问到每一个微服务的(但是这样每一个微服务都对外暴露了)

# zuul:
#   routes:
#     user-service:
#       path: /user/** # 服务映射路径
#       serviceId: user-service # 服务名称
#       strip-prefix: false # 忽略前缀, 默认为true 忽略前缀以后就不用写重复的了 列(/user/9, 不忽略, 你访问要/user/user/9, 忽略, user/9)
  # 配置忽略的服务(不对外暴露的服务) 是一个集合, 可以把不想暴露的微服务都这样配置下去
#   ignored-services:
#     - consumer-service # consumer-service不对外暴露


zuul:
  prefix: /api # 配置全局前缀, 访问时必须携带前缀
  routes:
    user-service:
      path: /user/** # 服务映射路径
      serviceId: user-service # 服务名称
      strip-prefix: false
  # 配置忽略的服务(不对外暴露的服务) 是一个集合, 可以把不想暴露的微服务都这样配置下去
  ignored-services:
    - consumer-service # consumer-service不对外暴露

# 设置熔断超时时间, 访问时超过6秒没反应, 直接报错
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 6000


ribbon:
  # 请求连接的超时时间
  ConnectTimeout: 500
  # 读取超时时长
  ReadTimeout: 2000
  # 设置从新访问次数为0, 这样连接不上时, 不会重新发起连接(不重试)
  MaxAutoRetriesNextServer: 0


# 注意: ribbon的超时时长, 真实值(read + connect) * 2, 必须小于hystrix时长.

# 源码: 计算公式  ribbonTimeout = (ribbonReadTimeout + ribbonConnectTimeout) * (maxAutoRetries + 1) * (maxAutoRetriesNextServer + 1);

启动类

GatewayApplication

package com.xiaoge;

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

/**
 * @Author: 潇哥
 * @DateTime: 2020/5/19 下午8:58
 * @Description: zuul启动器
 */
@EnableZuulProxy // 引入zuul注解
@SpringBootApplication
public class GatewayApplication {

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

}

自定义过滤器

LoginFilter

package com.xiaoge.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.commons.lang.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;

/**
 * @Author: 潇哥
 * @DateTime: 2020/5/21 下午8:22
 * @Description: 自定义过滤器
 */
@Component
public class LoginFilter extends ZuulFilter {
    /**
     * 过滤器类型
     * pre: 请求在被路由之前执行
     * routing: 在路由请求时调用
     * post: 在routing和error过滤器之后调用
     * error: 处理请求时发生错误调用
     * @return
     */
    @Override
    public String filterType() {
        return FilterConstants.PRE_TYPE; // 设置为前置 pre 这是个常量
    }

    /**
     * 过滤器顺序
     * 通过返回的int值来定义过滤器的执行顺序, 数字越小优先级越高
     * @return
     */
    @Override
    public int filterOrder() {
        return FilterConstants.PRE_DECORATION_FILTER_ORDER - 1; // 请求参数处理完, 然后拦截
    }

    /**
     * 要不要过滤
     * 返回一个boolean值, 判断该过滤器是否需要执行. 返回true执行, 返回false不执行.
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 过滤逻辑
     * 过滤器的具体业务逻辑
     * @return
     * @throws ZuulException
     */
    @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); // 为true放行, 为false拦截, 默认为true
            ctx.setResponseStatusCode(HttpStatus.FORBIDDEN.value()); // 状态码, 设置为403
        }

        return null;
    }
}

SpringCloud-网关ZUUL

SpringCloud-网关ZUUL

项目结构

父工程(每一个服务都是一个子工程)

consumer-demo服务

eureka-server服务

user-service服务

gateway网关

关于接口协议，你必须要知道这些！

一键自动化博客发布工具,用过的人都说好(头条篇)

01 稳定性（一）如何应对事故并做好覆盘？

美团一面：项目中有 10000 个 if else 如何优化？想了半天，被问懵了！

京东面试：如何进行JVM调优？

线程池那些坑爹的参数-核心线程数&最大线程数&工作队列

Stream流常用方法总结

Spring核心容器及兩個核心容器引發的問題

Spring三種創建bean對象的方式/作用範圍/生命週期

Spring使用XML+註解實現的小案例+Spring-Junit整合

模仿spring的核心容器創建單例對象

Spring常用註解(註解對應的XML標籤)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結