个人中心
gpt4 book ai didi

SpringCloud通用请求字段拦截处理方法

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章SpringCloud通用请求字段拦截处理方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

背景 。

以SpringCloud构建的微服务系统为例，使用前后端分离的架构，每个系统都会提供一些通用的请求参数，例如移动端的系统版本信息、IMEI信息，Web端的IP信息，浏览器版本信息等，这些参数可能放在header里，也可以放在参数里，如果这些参数需要在每个方法内声明定义，一来工作量太大，二是这些通用参数与业务接口方法耦合过紧，本身就是一个不好的设计.

这个问题该如何优雅地解决呢?

最佳实践 。

  • 利用SpringMVC提供拦截器，对匹配的请求，抽取通用的header信息（假设通用字段全部放在header里）
  • 将每个请求的信息单独隔离开，互不干扰。
  • Controller层使用时，可以将在该请求线程(http线程)里将通用的header信息提取出来使用。
  • 请求线程完成时，相应的header头信息对象需要回收销毁。
  • 实现方式SpringMVA提供的HandlerInterceptorAdapter可以拿来使用，继承实现即可。
  • 使用ThreadLocal记录每个请求的信息，ThreadLocal有隔离线程变量的作用。

HandlerInterceptorAdapter的源码实现及注释 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
 
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
             throws Exception {
     // 在业务接口方法处理之前被调用，可以在这里对通用的header信息进行提取
         return true ;
     }
 
     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
             @Nullable ModelAndView modelAndView) throws Exception {
         // 这个方法在业务接口方法执行完成后，生成SpringMVC ModelAndView之前被调用
         // 今天这个案例我们不用此方法，故可以不实现。
     }
    
     @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
             @Nullable Exception ex) throws Exception {
         // 这个方法在DispatcherServlet完全处理完成后被调用，可以在这里对ThreadLocal的内容进行释放
     }
 
     @Override
     public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response,
             Object handler) throws Exception {
         // 这个方法用来处理异步主动，但也会先行调用preHandle，然后执行此方法，异步线程完成后会执行postHandle和afterCompletion两方法，这里暂时用不上。
     }
}

ThreadLocal的源码主要实现及注释 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class ThreadLocal<T> {
  
   protected T initialValue() {
     return null ;
   }
 
   public T get() {
         // 获取当前的线程
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     if (map != null ) {
       ThreadLocalMap.Entry e = map.getEntry( this );
       if (e != null ) {
         @SuppressWarnings ( "unchecked" )
         T result = (T)e.value;
         return result;
       }
     }
     return setInitialValue();
   }
 
   private T setInitialValue() {
     T value = initialValue();
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     if (map != null )
       map.set( this , value);
     else
       createMap(t, value);
     return value;
   }
 
   public void set(T value) {
         // 获取当前的线程
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     if (map != null )
       map.set( this , value);
     else
       createMap(t, value);
   }
 
    public void remove() {
      ThreadLocalMap m = getMap(Thread.currentThread());
      if (m != null )
        m.remove( this );
    }
 
   ThreadLocalMap getMap(Thread t) {
     return t.threadLocals;
   }
 
   void createMap(Thread t, T firstValue) {
     t.threadLocals = new ThreadLocalMap( this , firstValue);
   }
}

简单来说，ThreadLocal最关键的get()和set()方法，都是针对当前线程来操作的，调用set()方法时把值放到ThreadMap(Map的一种实现)中，以当前线程的hash值为key，get()方法则对应以当前线程作为key来取值，从而实现每个线程的数据是隔离的效果.

另附上ThreadLocal类源码解读的导图，仅供参考 。

SpringCloud通用请求字段拦截处理方法

案例实战 。

我们对实际业务系统进行简化处理，假定header信息固定有ip，uid，deviceId三个信息，按照上文的实现思路，开始案例演示.

DTO定义 。

通用的header信息，使用Dto对象进行封装:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Data
public class CommonHeader implements Serializable {
 
     private static final long serialVersionUID = -3949488282201167943L;
    
     /**
      * 真实ip
      */
     private String ip;
 
     /**
      * 设备id
      */
     private String deviceId;
 
     /**
      * 用户uid
      */
     private Long uid;
    
     // 省略getter/setter/构造器
}

定义Request请求的封装类Dto，并引入ThreadLocal:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
  * 将公共请求头信息放在ThreadLocal中去
  */
public class RequestWrap {
 
     private static ThreadLocal<CommonHeader> current = new ThreadLocal<>();
 
   /**
      * 获取静态的ThreadLocal对象
      * @return
      */
     public static ThreadLocal<CommonHeader> getCurrent() {
         return current;
     }
    
     /**
      * 获取ip
      * @return
      */
     public static String getIp() {
         CommonHeader request = current.get();
         if (request == null ) {
             return StringUtils.EMPTY;
         }
         return request.getIp();
     }
 
     /**
      * 获取uid
      * @return
      */
     public static Long getUid() {
         CommonHeader request = current.get();
         if (request == null ) {
             return null ;
         }
         return request.getUid();
     }
 
     /**
      * 获取封装对象
      * @return
      */
     public static CommonHeader getCommonReq() {
         CommonHeader request = current.get();
         if (request == null ) {
             return new CommonHeader(StringUtils.EMPTY, StringUtils.EMPTY,0L);
         }
         return request;
     }
}

工具类 。

这里添加一个简单的工具类，将HttpServletRequest通过getHeader方法，生成CommonHeader类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class HttpUtil {
     /**
      * 获取请求头信息
      *
      * @param request
      * @return
      */
     public static CommonHeader getCommonHeader(HttpServletRequest request) {
         String UID = request.getHeader( "uid" );
         Long uid = null ;
         if (StringUtils.isNotBlank(UID)) {
             uid = Long.parseLong(UID);
         }
         return new CommonHeader(HttpUtil.getIp(request), request.getHeader( "deviceId" ), uid);
     }
 
     /**
      * 获取IP
      *
      * @param request
      * @return
      */
     public static String getIp(HttpServletRequest request) {
         String ip = request.getHeader( "X-Forwarded-For" );
 
         if ( null != ip && ! "" .equals(ip.trim()) && ! "unknown" .equalsIgnoreCase(ip)) {
             int index = ip.indexOf( ',' );
             if (index != - 1 ) {
                 return ip.substring( 0 , index);
             } else {
                 return ip;
             }
         }
         ip = request.getHeader( "X-Real-IP" );
         if ( null != ip && ! "" .equals(ip.trim()) && ! "unknown" .equalsIgnoreCase(ip)) {
             return ip;
         }
         return request.getRemoteAddr();
     }
}

拦截器类实现 。

最核心的实现终于出场了，这里继承HandlerInterceptorAdapter，这里作了简化处理:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
  * 请求头处理
  *
  * @author yangfei
  */
@Component
public class BaseInterceptor extends HandlerInterceptorAdapter {
 
     private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(BaseInterceptor. class );
 
 
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
             throws Exception {
         RequestWrap.getThreadLocal().set(HttpUtil.getCommonHeader(request));
         return true ;
     }
 
     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
             ModelAndView modelAndView) throws Exception {
     }
 
     @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
             throws Exception {
         RequestWrap.getThreadLocal().remove();
     }
 
     @Override
     public void afterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response, Object handler)
             throws Exception {
     }
}

如上一章节描述的逻辑，在preHandle方法内将request中的ip,uid,deviceId封装到RequestWrap对象里，在afterCompletion中对该线程的ThreadLocal值进行释放.

业务接口方法的使用 。

在Controller类的接口方法中，如要获取uid信息，只需要调用RequestWrap.getUid()方法即可，再也不需要在每个接口上声明uid参数了，如下示例:

?
1
2
3
4
5
6
7
/**
  * 获取用户基础信息
  */
@PostMapping (value = "/user/info" )
public Response<UserInfo> getUserInfo() {
     return userManager.getUserInfo(RequestWrap.getUid());
}

总结 。

这个实战的目标是解决通用header信息的在接口的重复定义问题，基于HandlerInterceptorAdapter拦截器的实现，ThreadLocal对线程访问数据的隔离来实现的，在实际生产项目应用中有很好的借鉴意义，希望对你有帮助.

到此这篇关于SpringCloud通用请求字段拦截处理方法的文章就介绍到这了,更多相关SpringCloud请求字段拦截内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://www.cnblogs.com/huangying2124/p/13264753.html 。

最后此篇关于SpringCloud通用请求字段拦截处理方法的文章就讲到这里了,如果你想了解更多关于SpringCloud通用请求字段拦截处理方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： Spring Boot Admin 进行项目监控管理的方法
文章推荐： IOS10 远程推送适配详细介绍
文章推荐： IOS Swift3 四种单例模式详解及实例
文章推荐： IOS 创建彩色二维码实例详解
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com