SpringCloud利用网关拦截做Token验证（JWT方式）

2023-11-10

关于JWT的内容，请看以下链接，主要看它的原理，以及缺点！

https://blog.csdn.net/memmsc/article/details/78122931

步骤1：前端传userName+password到后端，后端为springcloud架构，经过网关的拦截器拦截请求，拦截器在项目启动的时候@Component进行加载。

步骤2：如果是第一次登陆，放行，进入JWT的加密生成Token阶段（还可以写入登陆用户的其他信息放在JWTmap中，之后可以利用Token来获取该用户信息），加密token需要一个随机数作为加密字段，将token的失效时间设置为一天，并且放到reids里面，设置该redis里面的token过期时间为30分钟，最后将Token返回给前端。

步骤3：以后任何的请求都带Token到后端去请求。

步骤4：拦截到非登陆请求，进行解密，鉴权，如果鉴权通过，更新redis里面token字段的失效时间，如果还有5分钟失效，再设置还有30分钟，目的就是让密码的过期时间变的活跃。

大致就是以上的过程，核心代码主要在网关拦截器解密鉴权和登陆接口的加密两部分

0，controller层的将得到的token做保存redis和设置过期时间的操作


 
 

   
   
   
   
    
    
     
      compactJws = authService.generateJwt(username, password, userBean);
    
    
   
   


   
   
   
   
    
     
     
     //将token存在redis里
    
    
   
   


   
   
   
   
    
    
     
      stringRedisTemplate.opsForValue().
     
     set(
     
     "token", compactJws);
    
    
   
   


   
   
   
   
    
     
     
     //设置redis里面的数据失效时间为半小时
    
    
   
   


   
   
   
   
    
    
     
      stringRedisTemplate.expire(
     
     "token",
     
     1800,
     
     TimeUnit.
     
     SECONDS);

1，登陆接口的加密：


 
 

   
   
   
   
    
    
     
     package com.movitech.user.service.imp;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.entity.UserBean;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.utils.CommonConstants;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.user.service.AuthService;
    
    
   
   


   
   
   
   
    
    
     
     import io.jsonwebtoken.Jwts;
    
    
   
   


   
   
   
   
    
    
     
     import io.jsonwebtoken.SignatureAlgorithm;
    
    
   
   


   
   
   
   
    
    
     
     import org.joda.time.DateTime;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.stereotype.Service;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import java.util.Base64;
    
    
   
   


   
   
   
   
    
    
     
     import java.util.HashMap;
    
    
   
   


   
   
   
   
    
    
     
     import java.util.Map;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     /**
    
    
   
   


   
   
   
   
    
    
     
      * 用户身份验证Service
    
    
   
   


   
   
   
   
    
    
     
      */
    
    
   
   


   
   
   
   
    
    
     
     @
     
     Service(value = 
     
     "authService")
    
    
   
   


   
   
   
   
    
    
     
     public 
     
     class AuthServiceImpl implements AuthService {
    
    
   
   


   
   
   
   
    
    
     
         @
     
     Override
    
    
   
   


   
   
   
   
    
            
     
     public 
     
     String generateJwt(
     
     String userName, 
     
     String userPassword, 
     
     UserBean userBean) {
    
    
   
   


   
   
   
   
    
            
     
     // Base64编码后的secretKey
    
    
   
   


   
   
   
   
    
    
     
             byte[] secretKey = 
     
     Base64.getEncoder().encode(
     
     CommonConstants.
     
     SECURITY_KEY.getBytes());
    
    
   
   


   
   
   
   
    
            
     
     // 设置失效时间
    
    
   
   


   
   
   
   
    
            
     
     DateTime expirationDate = new 
     
     DateTime().plusDays(
     
     1);
    
    
   
   


   
   
   
   
    
            
     
     //DateTime expirationDate = new DateTime().plusMinutes(30);
    
    
   
   


   
   
   
   
    
            
     
     // Claims是需要保存到token中的信息，可以自定义，需要存什么就放什么，会保存到token的payload中
    
    
   
   


   
   
   
   
    
            
     
     Map<
     
     String, 
     
     Object> claims = new 
     
     HashMap<>();
    
    
   
   


   
   
   
   
    
            
     
     // 用户角色
    
    
   
   


   
   
   
   
    
    
     
             claims.put(
     
     "role", 
     
     "user");
    
    
   
   


   
   
   
   
    
            
     
     // 用户名
    
    
   
   


   
   
   
   
    
    
     
             claims.put(
     
     "userName", userName);
    
    
   
   


   
   
   
   
    
    
     
             claims.put(
     
     CommonConstants.
     
     USER_ID, userBean.getId());
    
    
   
   


   
   
   
   
    
    
     
             claims.put(
     
     "uuid",
     
     UUID.randomUUID().
     
     toString());
    
    
   
   


   
   
   
   
    
            
     
     String compactJws = 
     
     Jwts.builder()
    
    
   
   


   
   
   
   
    
                    
     
     // 设置subject，一般是用户的唯一标识，比如用户对象的ID，用户名等，目前设置的是userCode
    
    
   
   


   
   
   
   
    
    
     
                     .setSubject(userName)
    
    
   
   


   
   
   
   
    
                    
     
     // 设置失效时间
    
    
   
   


   
   
   
   
    
    
     
                     .setExpiration(expirationDate.toDate())
    
    
   
   


   
   
   
   
    
    
     
                     .addClaims(claims)
    
    
   
   


   
   
   
   
    
                    
     
     // 加密算法是HS512，加密解密统一就可以
    
    
   
   


   
   
   
   
    
    
     
                     .signWith(
     
     SignatureAlgorithm.
     
     HS512, secretKey)
    
    
   
   


   
   
   
   
    
    
     
                     .compact();
    
    
   
   


   
   
   
   
    
            
     
     return compactJws;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     }

以上常量类和pojo此处省略。。。。

2，网关拦截器解密鉴权：


 
 

   
   
   
   
    
    
     
     package com.movitech.gateway.filter;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.dto.ErrorResponseMap;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.enums.ErrorCode;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.utils.CommonConstants;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.utils.JsonUtil;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.utils.ResponseUtil;
    
    
   
   


   
   
   
   
    
    
     
     import com.netflix.zuul.ZuulFilter;
    
    
   
   


   
   
   
   
    
    
     
     import com.netflix.zuul.context.RequestContext;
    
    
   
   


   
   
   
   
    
    
     
     import io.jsonwebtoken.*;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.http.HttpHeaders;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.http.HttpMethod;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.stereotype.Component;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.util.StringUtils;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import javax.servlet.http.HttpServletRequest;
    
    
   
   


   
   
   
   
    
    
     
     import java.util.Base64;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     @Component
    
    
   
   


   
   
   
   
    
    
     
     public 
     
     class SecurityFilter 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() {
    
    
   
   


   
   
   
   
    
    
     
             RequestContext ctx = RequestContext.getCurrentContext();
    
    
   
   


   
   
   
   
    
    
     
             HttpServletRequest request = ctx.getRequest();
    
    
   
   


   
   
   
   
    
            
     
     if (request.getRequestURL().toString().contains(
     
     "loginInfo") || request.getRequestURL().toString().contains(
     
     "info")) {
    
    
   
   


   
   
   
   
    
                
     
     return 
     
     false;
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     // TODO
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     true;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     @Override
    
    
   
   


   
   
   
   
    
        
     
     public Object run() {
    
    
   
   


   
   
   
   
    
    
     
             RequestContext ctx = RequestContext.getCurrentContext();
    
    
   
   


   
   
   
   
    
    
     
             HttpServletRequest request = ctx.getRequest();
    
    
   
   


   
   
   
   
    
            
     
     final String authorizationHeader = request.getHeader(HttpHeaders.AUTHORIZATION);
    
    
   
   


   
   
   
   


   
   
   
   
    
            
     
     if (HttpMethod.OPTIONS.name().equals(request.getMethod())) {
    
    
   
   


   
   
   
   
    
                
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
             } 
     
     else {
    
    
   
   


   
   
   
   
    
                
     
     if (StringUtils.isEmpty(authorizationHeader) || !authorizationHeader.startsWith(CommonConstants.BEARER)) {
    
    
   
   


   
   
   
   
    
                    
     
     // Missing or invalid Authorization header
    
    
   
   


   
   
   
   
    
    
     
                     ErrorResponseMap errorResponseMap = ResponseUtil.createErrorResponse(
     
     null, 
     
     "Missing or invalid Authorization header!",
    
    
   
   


   
   
   
   
    
    
     
                             ErrorCode.INVALID_AUTHORIZATION_HEADER, request, 
     
     null);
    
    
   
   


   
   
   
   
    
    
     
                     denyAccess(ctx,errorResponseMap);
    
    
   
   


   
   
   
   
    
                    
     
     return JsonUtil.serializeToString(errorResponseMap);
    
    
   
   


   
   
   
   
    
    
     
                 }
    
    
   
   


   
   
   
   
    
                
     
     final String token = authorizationHeader.substring(
     
     7);
    
    
   
   


   
   
   
   
    
                
     
     try {
    
    
   
   


   
   
   
   
    
    
     
                     byte[] secretKey = Base64.getEncoder().encode(CommonConstants.SECURITY_KEY.getBytes());
    
    
   
   


   
   
   
   
    
    
     
                     Claims claims = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody();
    
    
   
   


   
   
   
   
    
                    
     
     if (claims != 
     
     null) {
    
    
   
   


   
   
   
   
    
    
     
     //获取redis里面数据的存活时间
    
    
   
   


   
   
   
   
    
                        
     
     Long expirationDate = stringRedisTemplate.getExpire(
     
     "token",TimeUnit.SECONDS);
    
    
   
   


   
   
   
   
    
                        
     
     //如果还剩余5分钟，重置redis里面数据的存活时间
    
    
   
   


   
   
   
   
    
                        
     
     if(expirationDate > 
     
     300){
    
    
   
   


   
   
   
   
    
    
     
                             stringRedisTemplate.expire(
     
     "token",
     
     1800,TimeUnit.SECONDS);
    
    
   
   


   
   
   
   
    
    
     
                         }
     
     else {
    
    
   
   


   
   
   
   
    
    
     
                             ErrorResponseMap errorResponseMap = new ErrorResponseMap();
    
    
   
   


   
   
   
   
    
    
     
                             Error error = new Error(
     
     null, 
     
     "Token expired!",  
     
     "", 
     
     1003,
     
     "");
    
    
   
   


   
   
   
   
    
    
     
                             errorResponseMap.setSuccess(
     
     false);
    
    
   
   


   
   
   
   
    
    
     
                             errorResponseMap.setMessage(
     
     null);
    
    
   
   


   
   
   
   
    
    
     
                             errorResponseMap.setError(error);
    
    
   
   


   
   
   
   
    
    
     
                             denyAccess(ctx,errorResponseMap);
    
    
   
   


   
   
   
   
    
                            
     
     return JsonUtil.serializeToString(errorResponseMap);
    
    
   
   


   
   
   
   
    
    
     
                         }
    
    
   
   


   
   
   
   
    
    
     
                         String userName = (String) claims.
     
     get(CommonConstants.USER_CODE);
    
    
   
   


   
   
   
   
    
    
     
                         Integer userId = (Integer) claims.
     
     get(CommonConstants.USER_ID);
    
    
   
   


   
   
   
   
    
    
     
                         ctx.addZuulRequestHeader(CommonConstants.USER_CODE, userName);
    
    
   
   


   
   
   
   
    
    
     
                         ctx.addZuulRequestHeader(CommonConstants.USER_ID, String.valueOf(userId));
    
    
   
   


   
   
   
   
    
    
     
                     }
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     catch (MalformedJwtException ex) {
    
    
   
   


   
   
   
   
    
    
     
                     ErrorResponseMap errorResponseMap = ResponseUtil.createErrorResponse(
     
     null, 
     
     "Invalid token!",
    
    
   
   


   
   
   
   
    
    
     
                             ErrorCode.INVALID_AUTHORIZATION_HEADER, request, ex);
    
    
   
   


   
   
   
   
    
    
     
                     denyAccess(ctx,errorResponseMap);
    
    
   
   


   
   
   
   
    
                    
     
     return JsonUtil.serializeToString(errorResponseMap);
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     catch (SignatureException ex) {
    
    
   
   


   
   
   
   
    
    
     
                     ErrorResponseMap errorResponseMap = ResponseUtil.createErrorResponse(
     
     null, 
     
     "Token Signature error!",
    
    
   
   


   
   
   
   
    
    
     
                             ErrorCode.SIGNATURE_EXCEPTION, request, ex);
    
    
   
   


   
   
   
   
    
    
     
                     denyAccess(ctx,errorResponseMap);
    
    
   
   


   
   
   
   
    
                    
     
     return JsonUtil.serializeToString(errorResponseMap);
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     catch (ExpiredJwtException ex) {
    
    
   
   


   
   
   
   
    
    
     
                     ErrorResponseMap errorResponseMap = ResponseUtil.createErrorResponse(
     
     null, 
     
     "Token expired!",
    
    
   
   


   
   
   
   
    
    
     
                             ErrorCode.EXPIRED_JWT_EXCEPTION, request, ex);
    
    
   
   


   
   
   
   
    
    
     
                     denyAccess(ctx,errorResponseMap);
    
    
   
   


   
   
   
   
    
                    
     
     return JsonUtil.serializeToString(errorResponseMap);
    
    
   
   


   
   
   
   
    
    
     
                 }
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     private void denyAccess(RequestContext ctx, ErrorResponseMap authResult) {
    
    
   
   


   
   
   
   
    
    
     
             String result = JsonUtil.serializeToString(authResult);
    
    
   
   


   
   
   
   
    
    
     
             ctx.setSendZuulResponse(
     
     false);
    
    
   
   


   
   
   
   
    
    
     
             ctx.setResponseStatusCode(
     
     401);
    
    
   
   


   
   
   
   
    
            
     
     try {
    
    
   
   


   
   
   
   
    
    
     
                 ctx.getResponse().getWriter().write(result);
    
    
   
   


   
   
   
   
    
    
     
             }
     
     catch (Exception e){}
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   
    
    
     
     }

以上代码是核心代码，下面是自己项目中涉及到的异常包装类，以及util类，可以不管下面的，直接去封装

以上涉及到的类：

（1）ErrorResponseMap


 
 

   
   
   
   
    
    
     
     package 
     
     com
     
     .movitech
     
     .commons
     
     .dto;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import 
     
     com
     
     .fasterxml
     
     .jackson
     
     .annotation
     
     .JsonProperty;
    
    
   
   


   
   
   
   
    
    
     
     import 
     
     com
     
     .movitech
     
     .commons
     
     .exception
     
     .Error;
    
    
   
   


   
   
   
   
    
    
     
     import 
     
     lombok
     
     .Getter;
    
    
   
   


   
   
   
   
    
    
     
     import 
     
     lombok
     
     .Setter;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     @
     
     Getter
    
    
   
   


   
   
   
   
    
    
     
     @Setter
    
    
   
   


   
   
   
   
    
    
     
     public class ErrorResponseMap extends ResponseMap {
    
    
   
   


   
   
   
   
    
    
     
         @
     
     JsonProperty(
     
     value = 
     
     "error")
    
    
   
   


   
   
   
   
    
    
     
         private Error error;
    
    
   
   


   
   
   
   
    
    
     
         @
     
     JsonProperty(
     
     value = 
     
     "stackTrace")
    
    
   
   


   
   
   
   
    
    
     
         private String stackTrace;
    
    
   
   


   
   
   
   
    
    
     
     }

（1.1）Error


 
 

   
   
   
   
    
    
     
     package com.movitech.commons.exception;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import lombok.AllArgsConstructor;
    
    
   
   


   
   
   
   
    
    
     
     import lombok.Getter;
    
    
   
   


   
   
   
   
    
    
     
     import lombok.NoArgsConstructor;
    
    
   
   


   
   
   
   
    
    
     
     import lombok.Setter;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     @Getter
    
    
   
   


   
   
   
   
    
    
     
     @Setter
    
    
   
   


   
   
   
   
    
    
     
     @NoArgsConstructor
    
    
   
   


   
   
   
   
    
    
     
     @AllArgsConstructor
    
    
   
   


   
   
   
   
    
    
     
     public 
     
     class Error {
    
    
   
   


   
   
   
   
    
        
     
     // 标准的 Http status code
    
    
   
   


   
   
   
   
    
        
     
     private Integer httpStatusCode;
    
    
   
   


   
   
   
   
    
        
     
     // 自定义的错误说明
    
    
   
   


   
   
   
   
    
        
     
     private String errorMsg;
    
    
   
   


   
   
   
   
    
        
     
     // 异常信息
    
    
   
   


   
   
   
   
    
        
     
     private String exceptionMsg;
    
    
   
   


   
   
   
   
    
        
     
     // 自定义的错误代码
    
    
   
   


   
   
   
   
    
        
     
     private Integer errorCode;
    
    
   
   


   
   
   
   
    
        
     
     // 异常的类名
    
    
   
   


   
   
   
   
    
        
     
     private String exceptionClassName;
    
    
   
   


   
   
   
   
    
    
     
     }

（2）ErrorCode


 
 

   
   
   
   
    
    
     
     package com.movitech.commons.enums;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     /**
    
    
   
   


   
   
   
   
    
    
     
      * 自定义的错误代码的枚举
    
    
   
   


   
   
   
   
    
    
     
      */
    
    
   
   


   
   
   
   
    
    
     
     public 
     
     enum ErrorCode {
    
    
   
   


   
   
   
   
    
        
     
     // Token 签名错误
    
    
   
   


   
   
   
   
    
    
     
         SIGNATURE_EXCEPTION(
     
     1000),
    
    
   
   


   
   
   
   
    
        
     
     // Token 过期
    
    
   
   


   
   
   
   
    
    
     
         EXPIRED_JWT_EXCEPTION(
     
     1001),
    
    
   
   


   
   
   
   
    
        
     
     // 无效的Authorization header
    
    
   
   


   
   
   
   
    
    
     
         INVALID_AUTHORIZATION_HEADER(
     
     1002);
    
    
   
   


   
   
   
   
    
        
     
     private Integer errorCode;
    
    
   
   


   
   
   
   
    
    
     
         ErrorCode(Integer errorCode) {
    
    
   
   


   
   
   
   
    
            
     
     this.errorCode = errorCode;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     @Override
    
    
   
   


   
   
   
   
    
        
     
     public String toString() {
    
    
   
   


   
   
   
   
    
            
     
     return errorCode.toString();
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public Integer value() {
    
    
   
   


   
   
   
   
    
            
     
     return errorCode;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   
    
    
     
     }

（3）JsonUtil


 
 

   
   
   
   
    
    
     
     package com.movitech.commons.utils;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import com.fasterxml.jackson.core.JsonProcessingException;
    
    
   
   


   
   
   
   
    
    
     
     import com.fasterxml.jackson.databind.*;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.stereotype.Component;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.util.StringUtils;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import java.io.IOException;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     /**
    
    
   
   


   
   
   
   
    
    
     
      * Json序列化和反序列化
    
    
   
   


   
   
   
   
    
    
     
      */
    
    
   
   


   
   
   
   
    
    
     
     @Component
    
    
   
   


   
   
   
   
    
    
     
     public 
     
     class JsonUtil
    
    
   
   


   
   
   
   
    
    
     
     {
    
    
   
   


   
   
   
   
    
        
     
     public static ObjectMapper mapper;
    
    
   
   


   
   
   
   
    
    
     
     /* static {
    
    
   
   


   
   
   
   
    
    
     
             dao = new ObjectMapper();
    
    
   
   


   
   
   
   
    
    
     
             dao.configure(SerializationFeature.WRAP_ROOT_VALUE,true);
    
    
   
   


   
   
   
   
    
    
     
             dao.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
    
    
   
   


   
   
   
   
    
    
     
         }*/
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public JsonUtil(Jackson2ObjectMapperBuilder jackson2ObjectMapperBuilder) {
    
    
   
   


   
   
   
   
    
    
     
             mapper = jackson2ObjectMapperBuilder.build();
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static String serializeToString(Object 
     
     object) {
    
    
   
   


   
   
   
   
    
            
     
     return serializeToString(
     
     object,
     
     false);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static String serializeToString(Object 
     
     object,
     
     Boolean rootValueState) {
    
    
   
   


   
   
   
   
    
    
     
             SerializationConfig serializationConfig = mapper.getSerializationConfig();
    
    
   
   


   
   
   
   
    
    
     
             mapper.configure(SerializationFeature.WRAP_ROOT_VALUE,rootValueState);
    
    
   
   


   
   
   
   
    
            
     
     if (
     
     object != 
     
     null) {
    
    
   
   


   
   
   
   
    
                
     
     try {
    
    
   
   


   
   
   
   
    
                    
     
     return mapper.writeValueAsString(
     
     object);
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     catch (JsonProcessingException e) {
    
    
   
   


   
   
   
   
    
    
     
                     e.printStackTrace();
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     finally {
    
    
   
   


   
   
   
   
    
    
     
                     mapper.setConfig(serializationConfig);
    
    
   
   


   
   
   
   
    
    
     
                 }
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     "";
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static byte[] serializeToBytes(Object 
     
     object) {
    
    
   
   


   
   
   
   
    
            
     
     if (
     
     object != 
     
     null) {
    
    
   
   


   
   
   
   
    
                
     
     try {
    
    
   
   


   
   
   
   
    
                    
     
     return mapper.writeValueAsBytes(
     
     object);
    
    
   
   


   
   
   
   
    
    
     
                 } 
     
     catch (JsonProcessingException e) {
    
    
   
   


   
   
   
   
    
    
     
                     e.printStackTrace();
    
    
   
   


   
   
   
   
    
    
     
                 }
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     /**
    
    
   
   


   
   
   
   
    
    
     
          * 反序列化Json数据
    
    
   
   


   
   
   
   
    
    
     
          * @param jsonData Json数据字符串
    
    
   
   


   
   
   
   
    
    
     
          * @param valueType 反序列化的类型
    
    
   
   


   
   
   
   
    
    
     
          * @param rootValueState 是否解析Json root name
    
    
   
   


   
   
   
   
    
    
     
          * @param <T>
    
    
   
   


   
   
   
   
    
    
     
          * @return 反序列化后的POJO
    
    
   
   


   
   
   
   
    
    
     
          */
    
    
   
   


   
   
   
   
    
        
     
     public static <T> T deserialize(String jsonData,Class<T> valueType,
     
     Boolean rootValueState) {
    
    
   
   


   
   
   
   
    
            
     
     if (StringUtils.isEmpty(jsonData) || rootValueState == 
     
     null) {
    
    
   
   


   
   
   
   
    
                
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
    
     
             DeserializationConfig deserializationConfig = mapper.getDeserializationConfig();
    
    
   
   


   
   
   
   
    
    
     
             mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE,rootValueState);
    
    
   
   


   
   
   
   
    
            
     
     try {
    
    
   
   


   
   
   
   
    
                
     
     return mapper.readValue(jsonData, valueType);
    
    
   
   


   
   
   
   
    
    
     
             } 
     
     catch (IOException e) {
    
    
   
   


   
   
   
   
    
    
     
                 e.printStackTrace();
    
    
   
   


   
   
   
   
    
    
     
             } 
     
     finally {
    
    
   
   


   
   
   
   
    
    
     
                 mapper.setConfig(deserializationConfig);
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     /**
    
    
   
   


   
   
   
   
    
    
     
          * 反序列化Json数据,默认解析Json root name
    
    
   
   


   
   
   
   
    
    
     
          * @param jsonData Json数据字符串
    
    
   
   


   
   
   
   
    
    
     
          * @param valueType 反序列化的类型
    
    
   
   


   
   
   
   
    
    
     
          * @param <T>
    
    
   
   


   
   
   
   
    
    
     
          * @return 反序列化后的POJO
    
    
   
   


   
   
   
   
    
    
     
          */
    
    
   
   


   
   
   
   
    
        
     
     public static <T> T deserialize(String jsonData,Class<T> valueType) {
    
    
   
   


   
   
   
   
    
            
     
     return deserialize(jsonData, valueType, 
     
     true);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) {
    
    
   
   


   
   
   
   
    
            
     
     return mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     /**
    
    
   
   


   
   
   
   
    
    
     
          * 用Json数据中的key获取对应的value
    
    
   
   


   
   
   
   
    
    
     
          * @param jsonString json数据字符串
    
    
   
   


   
   
   
   
    
    
     
          * @param field 需要取值的字段
    
    
   
   


   
   
   
   
    
    
     
          * @param rootValueState 是否解析Json root name
    
    
   
   


   
   
   
   
    
    
     
          * @return 字段对应的值
    
    
   
   


   
   
   
   
    
    
     
          */
    
    
   
   


   
   
   
   
    
        
     
     public static String getValue(String jsonString,String field,
     
     Boolean rootValueState) {
    
    
   
   


   
   
   
   
    
    
     
             JsonNode node = getJsonNode(jsonString,field,rootValueState);
    
    
   
   


   
   
   
   
    
            
     
     return node == 
     
     null ? 
     
     "" : node.toString();
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     /**
    
    
   
   


   
   
   
   
    
    
     
          * 用Json数据中的key获取对应的value, 默认解析Json root name
    
    
   
   


   
   
   
   
    
    
     
          * @param jsonString json数据字符串
    
    
   
   


   
   
   
   
    
    
     
          * @param field 需要取值的字段
    
    
   
   


   
   
   
   
    
    
     
          * @return 字段对应的值
    
    
   
   


   
   
   
   
    
    
     
          */
    
    
   
   


   
   
   
   
    
        
     
     public static String getValue(String jsonString,String field) {
    
    
   
   


   
   
   
   
    
            
     
     return getValue(jsonString,field,
     
     true);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     /**
    
    
   
   


   
   
   
   
    
    
     
          * 用Json数据中的key获取对应的value
    
    
   
   


   
   
   
   
    
    
     
          * @param jsonString json数据字符串
    
    
   
   


   
   
   
   
    
    
     
          * @param field 需要取值的字段
    
    
   
   


   
   
   
   
    
    
     
          * @param rootValueState 是否解析Json root name
    
    
   
   


   
   
   
   
    
    
     
          * @return 字段对应的值
    
    
   
   


   
   
   
   
    
    
     
          */
    
    
   
   


   
   
   
   
    
        
     
     public static JsonNode getJsonNode(String jsonString, String field, 
     
     Boolean rootValueState) {
    
    
   
   


   
   
   
   
    
            
     
     if (StringUtils.isEmpty(jsonString) || StringUtils.isEmpty(field) || rootValueState == 
     
     null) {
    
    
   
   


   
   
   
   
    
                
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     // 准备工作 传入vo请参照第一篇里面的实体。此处不再重新贴上代码 浪费大家时间
    
    
   
   


   
   
   
   
    
    
     
             JsonNode node = 
     
     null;
     
     // 这里的JsonNode和XML里面的Node很像
    
    
   
   


   
   
   
   
    
            
     
     // 默认的反序列化配置
    
    
   
   


   
   
   
   
    
    
     
             DeserializationConfig deserializationConfig = mapper.getDeserializationConfig();
    
    
   
   


   
   
   
   
    
    
     
             mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE,rootValueState);
    
    
   
   


   
   
   
   
    
            
     
     try {
    
    
   
   


   
   
   
   
    
    
     
                 node = mapper.readTree(jsonString);
    
    
   
   


   
   
   
   
    
    
     
             } 
     
     catch (IOException e) {
    
    
   
   


   
   
   
   
    
    
     
                 e.printStackTrace();
    
    
   
   


   
   
   
   
    
                
     
     return 
     
     null;
    
    
   
   


   
   
   
   
    
    
     
             } 
     
     finally {
    
    
   
   


   
   
   
   
    
    
     
                 mapper.setConfig(deserializationConfig);
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return node.
     
     get(field) == 
     
     null ? 
     
     null : node.
     
     get(field);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   
    
    
     
     }

（4）ResponseUtil


 
 

   
   
   
   
    
    
     
     package com.movitech.commons.utils;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.dto.ErrorResponseMap;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.enums.ErrorCode;
    
    
   
   


   
   
   
   
    
    
     
     import com.movitech.commons.exception.Error;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.http.HttpStatus;
    
    
   
   


   
   
   
   
    
    
     
     import org.springframework.http.ResponseEntity;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     import javax.servlet.http.HttpServletRequest;
    
    
   
   


   
   
   
   


   
   
   
   
    
    
     
     public 
     
     class ResponseUtil {
    
    
   
   


   
   
   
   
    
        
     
     public static ResponseEntity createResponseEntity(String errorMsg, ErrorCode errorCode, HttpServletRequest request, Throwable ex) {
    
    
   
   


   
   
   
   
    
    
     
             HttpStatus status = getStatus(request);
    
    
   
   


   
   
   
   
    
    
     
             ErrorResponseMap errorResponseMap = createErrorResponse(status, errorMsg, errorCode, request, ex);
    
    
   
   


   
   
   
   
    
            
     
     return 
     
     new ResponseEntity<>(errorResponseMap, status);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static ErrorResponseMap createErrorResponse(HttpStatus status, String errorMsg, ErrorCode errorCode, HttpServletRequest request, Throwable ex) {
    
    
   
   


   
   
   
   
    
            
     
     if (status == 
     
     null) {
    
    
   
   


   
   
   
   
    
    
     
                 status = getStatus(request);
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
    
     
             ErrorResponseMap errorResponseMap = 
     
     new ErrorResponseMap();
    
    
   
   


   
   
   
   
    
    
     
             Error error = 
     
     new Error(status.value(), errorMsg, ex == 
     
     null ? 
     
     "" : ex.getMessage(),
    
    
   
   


   
   
   
   
    
    
     
                     errorCode == 
     
     null ? HttpStatus.INTERNAL_SERVER_ERROR.value() : errorCode.value(), ex == 
     
     null ? 
     
     "" : ex.getClass().getCanonicalName());
    
    
   
   


   
   
   
   
    
    
     
             errorResponseMap.setSuccess(
     
     false);
    
    
   
   


   
   
   
   
    
    
     
             errorResponseMap.setMessage(ex.getMessage());
    
    
   
   


   
   
   
   
    
    
     
             errorResponseMap.setError(error);
    
    
   
   


   
   
   
   
    
    
     
     //        String stackTrace = StringUtils.arrayToDelimitedString(ex.getStackTrace(), "hahaha");
    
    
   
   


   
   
   
   
    
    
     
     //        errorResponseMap.setStackTrace(stackTrace);
    
    
   
   


   
   
   
   
    
            
     
     return errorResponseMap;
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   


   
   
   
   
    
        
     
     public static HttpStatus getStatus(HttpServletRequest request) {
    
    
   
   


   
   
   
   
    
    
     
             Integer statusCode = (Integer) request.getAttribute(
     
     "javax.servlet.error.status_code");
    
    
   
   


   
   
   
   
    
            
     
     if (statusCode == 
     
     null) {
    
    
   
   


   
   
   
   
    
                
     
     return HttpStatus.INTERNAL_SERVER_ERROR;
    
    
   
   


   
   
   
   
    
    
     
             }
    
    
   
   


   
   
   
   
    
            
     
     return HttpStatus.valueOf(statusCode);
    
    
   
   


   
   
   
   
    
    
     
         }
    
    
   
   


   
   
   
   
    
    
     
     }

文章转载自：https://blog.csdn.net/qq_34707991/article/details/82898187

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

javaWeb项目笔记

springcloud系列

springCloud

token验证

SpringCloud利用网关拦截做Token验证（JWT方式）的相关文章

如果测试用例失败，Selenium Web 驱动程序无法关闭 Firefox 实例

我各位我正在使用 junit 和 selenium web 驱动程序 2 28 问题是如果我运行成功的测试用例 Web 驱动器能够关闭 Firefox 实例但是当测试用例失败时 Selenium Web 驱动器无法关闭 Firefox
如何将 Java 赋值表达式转换为 Kotlin

java中的一些东西就像 int a 1 b 2 c 1 if a b c System out print true 现在它应该转换为 kotlin 就像 var a Int 1 var b Int 2 var c Int 1 if a
JNI 不满意链接错误

我想创建一个简单的 JNI 层我使用Visual studio 2008创建了一个dll Win 32控制台应用程序项目类型带有DLL作为选项当我调用本机方法时出现此异常 Exception occurred during even
如何查找 Android 设备中的所有文件并将它们放入列表中？

我正在寻求帮助来列出 Android 外部存储设备中的所有文件我想查找所有文件夹包括主文件夹的子文件夹有办法吗我已经做了一个基本的工作但我仍然没有得到想要的结果这不起作用这是我的代码 File files array file
在数据流模板中调用 waitUntilFinish() 后可以运行代码吗？

我有一个批处理 Apache Beam 作业它从 GCS 获取文件作为输入我的目标是根据执行后管道的状态将文件移动到两个 GCS 存储桶之一如果管道执行成功则将文件移动到存储桶 A 否则如果管道在执行过程中出现任何未处理的异常则
使用 ANTLR 为 java 源代码生成抽象语法树

如何使用 ANTLR 从 java src 代码生成 AST 有什么帮助吗好的步骤如下前往ANTLR站点 http www antlr org 并下载最新版本下载Java g和JavaTreeParser g文件来自here htt
Convert.FromBase64String 方法的 Java 等效项

Java 中是否有相当于Convert FromBase64String http msdn microsoft com en us library system convert frombase64string aspx which 将指
如何为 Gson 编写自定义 JSON 反序列化器？

我有一个 Java 类用户 public class User int id String name Timestamp updateDate 我收到一个包含来自 Web 服务的用户对象的 JSON 列表 id 1 name Jonas
一种使用 Java Robot API 和 Selenium WebDriver by Java 进行文件上传的解决方案

我看到很多人在使用 Selenium WebDriver 的测试环境中上传文件时遇到问题我使用 selenium WebDriver 和 java 也遇到了同样的问题我终于找到了解决方案所以我将其发布在这里希望对其他人有所帮助当我需
OnClick 事件中的 finish() 如何工作？

我有一个Activity一键退出Activity 通过layout xml我必须设置OnClick事件至cmd exit调用 this finish 效果很好 public void cmd exit View editLayout thi
检查 Android 手机上的方向

如何查看Android手机是横屏还是竖屏当前配置用于确定要检索的资源可从资源中获取Configuration object getResources getConfiguration orientation 您可以通过查看其值来检查方向
检查 protobuf 消息 - 如何按名称获取字段值？

我似乎无法找到一种方法来验证 protobuf 消息中字段的值而无需显式调用其 getter 我看到周围的例子使用Descriptors FieldDescriptor实例到达消息映射内部但它们要么基于迭代器要么由字段号驱动一旦我有
org.jdesktop.application 包不存在

几天以来我一直在构建一个 Java 桌面应用程序一切都很顺利但是今天当我打开Netbeans并编译文件时出现以下编译错误 Compiling 9 source files to C Documents and Settings Ad
使用 Flyway 和 Hibernate 的 hbm2ddl 在应用程序的生命周期中管理数据库模式

我正在开发 Spring Hibernate MySql 应用程序该应用程序尚未投入生产我目前使用 Hibernatehbm2ddl该功能对于管理域上的更改非常方便我也打算用Flyway用于数据库迁移在未来的某个时候该应用程序将首
应用程序关闭时的倒计时问题

我制作了一个 CountDownTimer 代码我希望 CountDownTimer 在完成时重新启动即使应用程序已关闭但它仅在应用程序正在运行或重新启动应用程序时重新启动因此如果我在倒计时为 00 10 分钟秒时关闭应用程序
使用 SAX 进行 XML 解析 |如何处理特殊字符？

我们有一个 JAVA 应用程序可以从 SAP 系统中提取数据解析数据并呈现给用户使用 SAP JCo 连接器提取数据最近我们抛出了一个异常 org xml sax SAXParseException 字符引用是无效的 XML 字符
Keycloak - 自定义 SPI 未出现在列表中

我为我的 keycloak 服务器制作了一个自定义 SPI 现在我必须在管理控制台上配置它我将 SPI 添加为模块并手动安装因此我将其放在 module package name main 中并包含 module xml 我还将其放
android Accessibility-service 突然停止触发事件

我有一个 AccessibilityService 工作正常但由于开发过程中的某些原因它停止工作我似乎找不到这个原因请看一下我的代码并告诉我为什么它不起作用 public class MyServicee extends Access
java迭代器内部是如何工作的？ [关闭]

Closed 这个问题需要多问focused help closed questions 目前不接受答案我有一个员工列表 List
中断连接套接字

我有一个 GUI 其中包含要连接的服务器列表如果用户单击服务器则会连接到该服务器如果用户单击第二个服务器它将断开第一个服务器的连接并连接到第二个服务器每个新连接都在一个新线程中运行以便程序可以执行其他任务但是如果用户在第一个

随机推荐

记一次容器环境下出现 Address not available

困惑的源地址 pod 创建后一段时间一直是正常运行突然有一天发现没有新的连接创建了业务上是通过 pod A 访问 svc B 的 svc name 的方式进入 pod 手动去 wget 一下发现报错了 Address not ava
思科计算机网络第2章测试&考试答案

拓展思科交换机常用命令及配置测验当通过 Cisco CLI 配置主机名时哪三项命名约定将作为指南的一部分选择三项 A 主机名的长度应少于 64 个字符 B 主机名应全部用小写字符表示 C 主机名应不包含空格 D 主机名应该以一个特
球面如何切分成多个扇面？

近期在研究使用D3D开发三维显示场景发现D3D支持的纹理图的大小有限制这种限制一般由D3D引擎显卡驱动和显卡硬件共同决定使用如下代码可以获取当前系统能支持最大纹理大小 D3DCAPS9 caps m pd3dDevice gt Ge
Linux 下计算圆周率

转自 http blog csdn net zhuying linux article details 7298465 oracle sor sys time echo scale 5000 4 a 1 bc l q 输出的是小数点后位的
防治交换机窃听技术_等保2.0建设基本要求（技术部分）解读（下）

网御星云对等保2 0基本要求技术部分以四级为例对安全计算环境安全管理中心的控制点逐项解读内容如下 01 安全计算环境 1 1 身份鉴别 a 应对登录的用户进行身份标识和鉴别身份标识具有唯一性身份鉴别信息具有复杂度要求并定期更换 b
rpgmv存档修改html_使用HTML5存档网站内容更改

rpgmv存档修改html The majority of web content today exists in a state of retrograde amnesia Created in a moment content is c
从GAN到WGAN及WGAN-GP

20200910 0 引言最近看了PassGAN的代码他是使用了WGAN GP的代码作为GAN的框架来进行密码生成由此引出了对GAN的学习在GAN的研究中有一个方向就是研究如何使GAN更加稳定的训练在此之中 WGAN和WGAN
多维时序

多维时序 Matlab实现LSTM Adaboost和LSTM多变量时间序列预测对比目录多维时序 Matlab实现LSTM Adaboost和LSTM多变量时间序列预测对比预测效果基本介绍模型描述程序设计参考资料预测效果基
【linux线程（壹）】——初识线程（区分线程和进程，线程创建的基本操作）

作者努力学习的少年个人简介双非大二一个正在自学c 和linux操作系统写博客是总结知识方便复习目标进大厂如果你觉得文章可以的话麻烦你给我点个赞和关注感谢你的关注目录 1 线程和进程 1 1 进程的基本概念 1 2 线
JAVA多线程的三种创建方式

一概述在JAVA中用Thread类代表线程所有线程对象都必须是Thread类或者Thread类子类的实例每个线程的任务就是执行一段顺序执行的代码 JAVA使用线程执行体来容纳这段代码所以我们创建线程时主要是根据实际需求编
FPGA设计：如何用半加器和全加器构成四位全加器

今天来分享一下关于FPGA设计的文章如何用半加器和全加器构成四位全加器首先我们看一位半加器的代码 1 一位半加器的程序代码及图 library ieee use ieee std logic 1164 all entity half
linux串口编程 gsm,linux 中用n_gsm实现3gpp MUX协议

n gsm 是一种tty设备上的线路规程 line discipline 来实现3gpp MUX协议 n gsm 实现方法如下 1 kernel配置文件中打开 CONFIG N GSM y 编译内核 2 cat proc device g
KMP算法中next数组的理解

下面我们对着严老师的代码来一步步分析 next 数组理解 void creat next sstring T int next i 1 next 1 0 j 0 while i
MySQL SHOW命令

文章目录 SHOW命令介绍 SHOW命令用法常用SHOW命令汇总常用命令汇总表服务器运行状态信息支持的字符集信息支持的校对规则信息上一个执行语句的告警信息上一个执行语句的错误信息服务器线程信息用户权限信息支持的权限列表
Android疑难解决-Duplicate class xxx.xxx.xxx found in modules xxx.xxx.xxx

Duplicate class top zibin luban BuildConfig found in modules jetified Luban 1 1 8 runtime top zibin Luban 1 1 8 and jeti
System.Text.Encoding不同字符编码之间进行转换

System Text Encoding 是 C 中用于处理字符编码和字符串与字节之间转换的类它提供了各种静态方法和属性用于在不同字符编码之间进行转换以及将字符串转换为字节数组或反之在处理多语言文本文件网络通信以及其他字符数据的
每日一道算法题(3)--戳气球问题

题目戳气球问题输入一个包含非负数整数的数组nums代表一排气球 nums i 代表第i个气球的分数现在你要戳破所有的气球请计算出最高的分数分数的计算规则比较特别当戳破第i个气球时可以获得nums left nums righ
Python自定义函数的综合应用

第1关求最大值函数编写程序利用可变长度参数定义一个求任意个数数值的最大值的函数max n a b c 并进行测试例如当传入6 9时输出两个数的最大值当传入3 9 5 1 12 33 2 10时输出多个数的最大值输入任意若干
【经典】环境切换——SpringBoot配置不同环境启用不同的配置文件

不同环境下切换数据库配置文件环境切换配置一般在数据库存储等需要在开发环境和正式环境中进行切换时避免出错而常用的方式以下内容以yml文件来举例我们需要创建两个application文件 application dev yml app
SpringCloud利用网关拦截做Token验证（JWT方式）

关于JWT的内容请看以下链接主要看它的原理以及缺点 https blog csdn net memmsc article details 78122931 步骤1 前端传userName password到后端后端为springcl

SpringCloud利用网关拦截做Token验证（JWT方式）

SpringCloud利用网关拦截做Token验证（JWT方式） 的相关文章

随机推荐

热门标签

SpringCloud利用网关拦截做Token验证（JWT方式）的相关文章