springboot做代理分发服务+代理鉴权的实现过程

还原背景

大家都做过b-s架构的应用，也就是基于浏览器的软件应用。现在呢有个场景就是fe端也就是前端工程是前后端分离的，采用主流的前端框架vue编写。服务端采用的是springboot架构。

现在有另外一个服务也需要与前端页面交互，但是由于之前前端与服务端1交互时有鉴权与登录体系逻辑控制以及分布式session存储逻辑都在服务1中，没有把认证流程放到网关。所以新服务与前端交互则不想再重复编写一套鉴权认证逻辑。最终想通过服务1进行一个代理把前端固定的请求转发到新加的服务2上。

怎么实现

思路：客户端发送请求，由代理服务端通过匹配请求内容，然后在作为代理去访问真实的服务器，最后由真实的服务器将响应返回给代理，代理再返回给浏览器。

技术：说道反向代理，可能首先想到的就是nginx。不过在我们的需求中，对于转发过程有更多需求：

• 需要操作session，根据session的取值决定转发行为
• 需要修改http报文，增加header或是querystring

第一点决定了我们的实现必定是基于servlet的。springboot提供的proxyservlet就可以满足我们的要求，proxyservlet直接继承自httpservlet，采用异步的方式调用内部服务器，因此效率上不会有什么问题，并且各种可重载的函数也提供了比较强大的定制机制。

实现过程

引入依赖

<dependency>
  <groupid>org.mitre.dsmiley.httpproxy</groupid>
  <artifactid>smiley-http-proxy-servlet</artifactid>
  <version>1.11</version>
</dependency>

构建一个配置类

@configuration
public class proxyservletconfiguration {
 
 private final static string report_url = "/newreport_proxy/*";
 
 @bean
 public servletregistrationbean proxyservletregistration() {
  list<string> list = new arraylist<>();
  list.add(report_url); //如果需要匹配多个url则定义好放到list中即可
  servletregistrationbean registrationbean = new servletregistrationbean();
  registrationbean.setservlet(new threeproxyservlet());
  registrationbean.seturlmappings(list);
  //设置默认网址以及参数
  map<string, string> params = immutablemap.of("targeturi", "null", "log", "true");
  registrationbean.setinitparameters(params);
  return registrationbean;
 }
}

编写代理逻辑

public class threeproxyservlet extends proxyservlet {
 
 private static final long serialversionuid = -9125871545605920837l;
 
 private final logger logger = loggerfactory.getlogger(threeproxyservlet.class);
 public string proxyhttpaddr;
 public string proxyname;
 
 private resourcebundle bundle =null;
 @override
 public void init() throws servletexception {
  bundle = resourcebundle.getbundle("prop");
  super.init();
 }
 
 @override
 protected void service(httpservletrequest servletrequest, httpservletresponse servletresponse) throws servletexception, ioexception {
 
  // 初始切换路径
  string requesturi = servletrequest.getrequesturi();
  proxyname = requesturi.split("/")[2];
  //根据name匹配域名到properties文件中获取
  proxyhttpaddr = bundle.getstring(proxyname);
 
  string url = proxyhttpaddr;
  if (servletrequest.getattribute(attr_target_uri) == null) {
   servletrequest.setattribute(attr_target_uri, url);
  }
 
  if (servletrequest.getattribute(attr_target_host) == null) {
   url trueurl = new url(url);
   servletrequest.setattribute(attr_target_host, new httphost(trueurl.gethost(), trueurl.getport(), trueurl.getprotocol()));
  }
 
  string method = servletrequest.getmethod();
  // 替换多余路径
  string proxyrequesturi = this.rewriteurlfromrequest(servletrequest);
 
  object proxyrequest;
  if (servletrequest.getheader("content-length") == null && servletrequest.getheader("transfer-encoding") == null) {
   proxyrequest = new basichttprequest(method, proxyrequesturi);
  } else {
   proxyrequest = this.newproxyrequestwithentity(method, proxyrequesturi, servletrequest);
  }
 
  this.copyrequestheaders(servletrequest, (httprequest)proxyrequest);
  setxforwardedforheader(servletrequest, (httprequest)proxyrequest);
  httpresponse proxyresponse = null;
  try {
   proxyresponse = this.doexecute(servletrequest, servletresponse, (httprequest)proxyrequest);
   int statuscode = proxyresponse.getstatusline().getstatuscode();
   servletresponse.setstatus(statuscode, proxyresponse.getstatusline().getreasonphrase());
   this.copyresponseheaders(proxyresponse, servletrequest, servletresponse);
   if (statuscode == 304) {
    servletresponse.setintheader("content-length", 0);
   } else {
    this.copyresponseentity(proxyresponse, servletresponse, (httprequest)proxyrequest, servletrequest);
   }
  } catch (exception var11) {
   this.handlerequestexception((httprequest)proxyrequest, var11);
  } finally {
   if (proxyresponse != null) {
    entityutils.consumequietly(proxyresponse.getentity());
   }
 
  }
 }
 
 @override
 protected httpresponse doexecute(httpservletrequest servletrequest, httpservletresponse servletresponse, httprequest proxyrequest) throws ioexception {
  httpresponse response = null;
  // 拦截校验 可自定义token过滤
  //string token = servletrequest.getheader("ex_proxy_token");
  // 代理服务鉴权逻辑
  this.getauthstring(proxyname,servletrequest,proxyrequest);
  //执行代理转发
  try {
   response = super.doexecute(servletrequest, servletresponse, proxyrequest);
  } catch (ioexception e) {
   e.printstacktrace();
  }
  return response;
 }
}

增加一个properties配置文件

上边的配置简单介绍一下，对于/newreport_proxy/* 这样的写法，意思就是当你的请求路径以newreport_proxy 开头，比如http://localhost:8080/newreport_proxy/test/get1 这样的路径，它请求的真实路径是https://www.baidu.com/test/get1 。主要就是将newreport_proxy 替换成对应的被代理路径而已，* 的意思就是实际请求代理项目中接口的路径，这种配置对get 、post 请求都有效。

遇到问题

按如上配置，在执行代理转发的时候需要对转发的代理服务器的接口进行鉴权，具体鉴权方案调用就是 "this.getauthstring(proxyname,servletrequest,proxyrequest);”这段代码。代理服务的鉴权逻辑根据入参+token值之后按算法计算一个值，之后进行放到header中传递。那么这就遇到了一个问题，就是当前端采用requestbody的方式进行调用请求时服务1进行代理转发的时候会出现错误：

一直卡在执行 doexecute()方法。一顿操作debug后定位到一个点，也就是最后进行触发进行执行代理服务调用的点：

在上图位置抛了异常，上图中i的值为-1，说明这个sessionbuffer中没有数据了，读取不到了所以返回了-1。那么这个sessionbuffer是个什么东西呢？这个东西翻译过来指的是会话输入缓冲区，会阻塞连接。 与inputstream类相似，也提供读取文本行的方法。也就是通过这个类将对应请求的数据流发送给目标服务。这个位置出错说明这个要发送的数据流没有了，那么在什么时候将请求的数据流信息给弄没了呢？那就是我们加点鉴权逻辑，鉴权逻辑需要获取requestbody中的参数，去该参数是从request对象中通过流读取的。这个问题我们也见过通常情况下，httpservletrequst 中的 body 内容只会读取一次,但是可能某些情境下可能会读取多次,由于 body 内容是以流的形式存在,所以第一次读取完成后,第二次就无法读取了,一个典型的场景就是 filter 在校验完成 body 的内容后,业务方法就无法继续读取流了，导致解析报错。

最终实现

思路：用装饰器来修饰一下 request,使其可以包装读取的内容,供多次读取。其实spring boot提供了一个简单的封装器contentcachingrequestwrapper，从源码上看这个封装器并不实用，没有封装http的底层流servletinputstream信息，所以在这个场景下还是不能重复获取对应的流信息。

参照contentcachingrequestwrapper类实现一个stream缓存

public class cachestreamhttprequest extends httpservletrequestwrapper {
 private static final logger logger = loggerfactory.getlogger(cachestreamhttprequest.class);
 private final bytearrayoutputstream cachedcontent;
 private map<string, string[]> cachedform;
 
 @nullable
 private servletinputstream inputstream;
 
 public cachestreamhttprequest(httpservletrequest request) {
  super(request);
  this.cachedcontent = new bytearrayoutputstream();
  this.cachedform = new hashmap<>();
  cachedata();
 }
 
 @override
 public servletinputstream getinputstream() throws ioexception {
  this.inputstream = new repeatreadinputstream(cachedcontent.tobytearray());
  return this.inputstream;
 }
 
 @override
 public string getcharacterencoding() {
  string enc = super.getcharacterencoding();
  return (enc != null ? enc : webutils.default_character_encoding);
 }
 
 @override
 public bufferedreader getreader() throws ioexception {
   return new bufferedreader(new inputstreamreader(getinputstream(), getcharacterencoding()));
 }
 
 @override
 public string getparameter(string name) {
  string value = null;
  if (isformpost()) {
   string[] values = cachedform.get(name);
   if (null != values && values.length > 0) {
    value = values[0];
   }
  }
 
  if (stringutils.isempty(value)) {
   value = super.getparameter(name);
  }
 
  return value;
 }
 
 @override
 public map<string, string[]> getparametermap() {
  if (isformpost() && !collectionutils.sizeisempty(cachedform)) {
   return cachedform;
  }
 
  return super.getparametermap();
 }
 
 @override
 public enumeration<string> getparameternames() {
  if (isformpost() && !collectionutils.sizeisempty(cachedform)) {
   return collections.enumeration(cachedform.keyset());
  }
 
  return super.getparameternames();
 }
 
 @override
 public string[] getparametervalues(string name) {
  if (isformpost() && !collectionutils.sizeisempty(cachedform)) {
   return cachedform.get(name);
  }
 
  return super.getparametervalues(name);
 }
 
 private void cachedata() {
  try {
   if (isformpost()) {
    this.cachedform = super.getparametermap();
   } else {
    servletinputstream inputstream = super.getinputstream();
    ioutils.copy(inputstream, this.cachedcontent);
   }
  } catch (ioexception e) {
   logger.warn("[repeatreadhttprequest:cachedata], error: {}", e.getmessage());
  }
 
 }
 
 private boolean isformpost() {
  string contenttype = getcontenttype();
  return (contenttype != null &&
    (contenttype.contains(mediatype.application_form_urlencoded_value) ||
      contenttype.contains(mediatype.multipart_form_data_value)) &&
    httpmethod.post.matches(getmethod()));
 }
 
 private static class repeatreadinputstream extends servletinputstream {
  private final bytearrayinputstream inputstream;
 
  public repeatreadinputstream(byte[] bytes) {
   this.inputstream = new bytearrayinputstream(bytes);
  }
 
  @override
  public int read() throws ioexception {
   return this.inputstream.read();
  }
 
  @override
  public int readline(byte[] b, int off, int len) throws ioexception {
   return this.inputstream.read(b, off, len);
  }
 
  @override
  public boolean isfinished() {
   return this.inputstream.available() == 0;
  }
 
  @override
  public boolean isready() {
   return true;
  }
 
  @override
  public void setreadlistener(readlistener listener) {
 
  }
 }
}

如上类核心逻辑是通过cachedata() 方法进行将 request对象缓存，存储到bytearrayoutputstream类中，当在调用request对象获取getinputstream()方法时从bytearrayoutputstream类中写回inputstream核心代码：

 @override
 public servletinputstream getinputstream() throws ioexception {
  this.inputstream = new repeatreadinputstream(cachedcontent.tobytearray());
  return this.inputstream;
 }

使用这个封装后的request时需要配合filter对原有的request进行替换，注册filter并在调用链中将原有的request换成该封装类。代码：

//chain.dofilter(request, response); 
//换掉原来的request对象 用new repeatreadhttprequest((httpservletrequest) request) 因为后者流中由缓存拦截器httprequest替换 可重复获取inputstream
chain.dofilter(new repeatreadhttprequest((httpservletrequest) request), response);

这样就解决了服务代理分发+代理服务鉴权一套逻辑。

到此这篇关于springboot做代理分发服务+代理鉴权的文章就介绍到这了,更多相关springboot服务代理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！