Spring Cloud Gateway 具有如下特性：
基于Spring Framework 5, Project Reactor 和 Spring Boot 2.0 进行构建；
动态路由：能够匹配任何请求属性； 可以对路由指定 Predicate（断言）和 Filter（过滤器）；
集成Hystrix的断路器功能；
集成 Spring Cloud 服务发现功能；
易于编写的 Predicate（断言）和 Filter（过滤器）；
请求限流功能；
支持路径重写。
项目搭建
1.引入jar包
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<!-- Maven整个生命周期内排除内置容器，排除内置容器导出成war包可以让外部容器运行spring-boot项目-->
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</exclusion>
</exclusions>
</dependency>
2.修改配置文件application.yml 注：使用时请删除注释
#端口号
server:
port: 5055
spring:
application:
#项目名称
name: jq-gateway
cloud:
gateway:
discovery:
locator:
#开启从注册中心动态创建路由的功能
enabled: true
#使用小写服务名，默认是大写
lower-case-service-id: true
#连接redis
redis:
host: localhost
port: 6379
timeout: 10000
database: 0
lettuce:
pool:
max-active: 8
max-wait: -1
max-idle: 8
min-idle: 0
#连接eureka
eureka:
client:
register-with-eureka: true
service-url:
defaultZone: http://localhost:5051/eureka
registry-fetch-interval-seconds: 30
fetch-registry: true
instance:
lease-expiration-duration-in-seconds: 90
lease-renewal-interval-in-seconds: 30
#需要释放的请求
filter:
ignore:
urls:
- /jq-member/**
- /fh-product/**
- /jq-search/**
创建FiterIgnoreUrl类
package com.jq.filter;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
@Data
@EqualsAndHashCode(callSuper = false)
@Component//交给spring管理
@ConfigurationProperties(prefix = "filter.ignore")//获取yml配置文件中的数据
public class FiterIgnoreUrl {
private List<String> urls;
}
创建MyGatewayFilter类
package com.jq.filter;
import cn.hutool.json.JSONUtil;
import com.jq.jwt.JWTUtil;
import com.jq.msg.RedisKeyUtils;
import com.jq.result.ResultCode;
import com.jq.result.ResultObj;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.TimeUnit;
@Component
public class MyGatewayFilter implements GlobalFilter, Ordered {
@Autowired
private FiterIgnoreUrl fiterIgnoreUrl;
@Autowired
private JWTUtil jwtUtil;
@Autowired
private RedisTemplate redisTemplate;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
AntPathMatcher antPathMatcher = new AntPathMatcher();
//判断哪些请求需要拦截，哪些需要释放
String path = request.getURI().getPath();
for (String url:fiterIgnoreUrl.getUrls()){
if(antPathMatcher.match(url,path)){
System.out.println("请求为:"+path+"放过拦截");
return chain.filter(exchange);
}
}
String token = request.getHeaders().getFirst("Authorization-token");
if (StringUtils.isEmpty(token)){
//登录失败重新登录
return responseData(exchange, ResultObj.error(ResultCode.LOGIN_ERROR));
}
//验证token
ResultObj resultObj = jwtUtil.verifyToken(token);
if(resultObj.getCode()!=200) {
//登录失败
return responseData(exchange,resultObj);
}
//token续签
String phone = jwtUtil.getPhone(token);
Boolean hasKey = redisTemplate.hasKey(RedisKeyUtils.getTokenKey(phone));
if (hasKey==false){
//登录失败重新登录
return responseData(exchange,ResultObj.error(ResultCode.LOGIN_ERROR));
}
redisTemplate.expire(ResultObj.error(ResultCode.LOGIN_ERROR),3, TimeUnit.HOURS);
//往redis中存放唯一值
request.mutate().headers(httpHeaders -> {
httpHeaders.add("phone",phone);
});
return chain.filter(exchange);
}
private Mono responseData(ServerWebExchange exchange, ResultObj resultObj){
ServerHttpResponse response=exchange.getResponse();
String data= JSONUtil.toJsonStr(resultObj);
DataBuffer dataBuffer=response.bufferFactory().allocateBuffer()
.write(data.getBytes(StandardCharsets.UTF_8));
return response.writeWith(Mono.just(dataBuffer));
}
@Override
public int getOrder() {
return 0;
}
}
创建JWTUtil工具类
package com.jq.jwt;
import com.jq.result.ResultCode;
import com.jq.result.ResultObj;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@Component
@PropertySource({"classpath:jwt.properties"})
public class JWTUtil {
@Value("{user.jwtset.type}")
private String type;
@Value("{user.jwtset.alg}")
private String alg;
@Value("{user.jwtset.signing}")
private String signing;
public String createToken(String phone){
// token由三部分组成：头部、有效负载，签名
// 1.头部信息
Map<String,Object> headerMap = new HashMap<String,Object>();
headerMap.put("type",type);
headerMap.put("alg",alg);
// 2.有效负载
Map<String,Object> payload = new HashMap<>();
payload.put("phone",phone);
payload.put("date",new Date());
// 有效时间
long timeMillis = System.currentTimeMillis();
long endTime = timeMillis+6000000;
// 3.签名
String token = Jwts.builder().setHeader(headerMap)
.setClaims(payload)
.setExpiration(new Date(endTime))
.signWith(SignatureAlgorithm.HS256, "signing")
.compact();
return token;
}
public ResultObj verifyToken(String token) {
try {
Claims claims = Jwts.parser().setSigningKey("signing")
.parseClaimsJws(token)
.getBody();
return ResultObj.success(claims);
} catch (Exception e) {
return ResultObj.error(ResultCode.TOKEN_ERROR);
}
}
public String getPhone(String token){
try {
Claims claims = Jwts.parser().setSigningKey("signing")
.parseClaimsJws(token)
.getBody();
return (String) claims.get("phone");
} catch (Exception e) {
return null;
}
}
}
jwt.properties文件代码：
user.jwtset.type=JWT
user.jwtset.alg=HS256
user.jwtset.signing=jq1223
启动类代码：
@SpringBootApplication(exclude= {DataSourceAutoConfiguration.class})
@EnableEurekaClient
public class JqGatewayApplication {
public static void main(String[] args) {
SpringApplication.run(JqGatewayApplication.class, args);
}
}
创建Code码枚举类
package com.jq.result;
public enum ResultCode {
SUCCESS(200,"操作成功"),
ERROR(500,"操作失败"),
USERNAME_PASSWORD_ISNULL(1001,"用户名或密码为空"),
USER_NOEXIST(1002,"用户不存在"),
PASSWORD_ERROR(1003,"密码错误"),
TOKEN_ERROR(1004,"身份过期，请重新登录"),
NO_PERMISSION(403,"没有权限访问该方法"),
PHONE_NULL(1005,"手机号为空"),
GET_CODE_ERROR(1006,"获取验证码失败"),
PHONE_CODE_ISBULL(1007,"手机号码或验证码不能为空"),
CODE_ERROR(1008,"验证码错误"),
PHONE_CODE_TIMEOUT(1009,"手机号码不正确或验证码过期"),
LOGIN_ERROR(1010,"登录失败请重新登录")
;
private Integer code;
private String msg;
ResultCode(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
创建统一返回值类：
package com.jq.result;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ResultObj {
// 状态码
private Integer code;
// 信息
private String msg;
// 数据
private Object data;
public ResultObj(Integer code, String msg) {
this.code = code;
this.msg = msg;
}
public static ResultObj success(){
return new ResultObj(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMsg());
}
public static ResultObj success(Object data){
return new ResultObj(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMsg(), data);
}
public static ResultObj error(ResultCode resultCode){
return new ResultObj(resultCode.getCode(), resultCode.getMsg(),null);
}
}
创建RedisKeyUtils类：
private static final String codeKey = "code:";
private static final String tokenKey = "token:";
public static String getCodeKey(String phone){
return codeKey + phone;
}
public static String getTokenKey(String phone){
return tokenKey + phone;
}
vue前端
