• 近期将进行后台系统升级,如有访问不畅,请稍后再试!
  • 极客文库-知识库上线!
  • 极客文库小编@勤劳的小蚂蚁,为您推荐每日资讯,欢迎关注!
  • 每日更新优质编程文章!
  • 更多功能模块开发中。。。

如何从0写一个服务网关?


0 引言

什么是网关?为什么需要使用网关?

如图所示,在不使用网关的情况下,我们的服务是直接暴露给服务调用方。当调用方增多,势必需要添加定制化访问权限、校验等逻辑。当添加 API 网关后,再第三方调用端和服务提供方之间就创建了一面墙,这面墙直接与调用方通信进行权限控制。
本文所实现的网关源码抄袭了—Oh,不对,是借鉴。借鉴了 Zuul 网关的源码,提炼出其核心思路,实现了一套简单的网关源码,博主将其改名为 Eatuul。

题外话

本文是业内能搜到的第一篇自己动手实现网关的文章。博主写的手把手系列的文章,目的是在以最简单的方式,揭露出中间件的核心原理,让读者能够迅速了解实现的核心。需要说明的是,这不是源码分析系列的文章,因此写出来的代码,省去了一些复杂的内容,毕竟大家能理解到该中间件的核心原理即可。如果想看源码分析系列的,请关注博主,后期会将 spring、spring boot、dubbo、mybatis 等开源框架一一揭示。

1 正文

设计思路

先大致说一下,就是定义一个 Servlet 接收请求。然后经过 preFilter(封装请求参数),routeFilter(转发请求),postFilter(输出内容)。三个过滤器之间,共享 request、response 以及其他的一些全局变量。如下图所示
和真正的 Zuul 的区别?
主要区别有如下几点
(1)Zuul 中在异常处理模块,有一个 ErrorFilter 来处理,博主在实现的时候偷懒了,略去。
(2)Zuul 中 PreFilters,RoutingFilters,PostFilters 默认都实现了一组,具体如下表所示
博主总不可能每一个都给你们实现一遍吧。所以偷懒了,每种只实现一个。但是调用顺序还是不变,按照 PreFilters->RoutingFilters->PostFilters 的顺序调用
(3)在 routeFilters 确实有转发请求的 Filter,然而博主偷天换日了,改用 RestTemplate 实现.

代码结构

大家去 spring 官网上搭建一套 springboot 的项目,博主就不展示 pom 的代码了。直接将项目结构展示一下,如下图所示
EatuulServlet.java
这个是网关的入口,逻辑也十分简单,分为三步
(1)将 request,response 放入 threadlocal 中
(2)执行三组过滤器
(3)清除 threadlocal 中的的环境变量
源码如下
package com.rjzheng.eatuul.http;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(name = “eatuul”, urlPatterns = “/*”)
public class EatuulServlet extends HttpServlet {

    private EatRunner eatRunner = new EatRunner();

    @Override
    public void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        //将 request,和 response 放入上下文对象中
        eatRunner.init(req, resp);
        try {
            //执行前置过滤
            eatRunner.preRoute();
            //执行过滤
            eatRunner.route();
            //执行后置过滤
            eatRunner.postRoute();
        } catch (Throwable e) {
            RequestContext.getCurrentContext().getResponse()
                          .sendError(HttpServletResponse.SC_NOT_FOUND, e.getMessage());
        } finally {
            //清除变量
            RequestContext.getCurrentContext().unset();
        }
    }

}
EatuulRunner.java
这个是具体的执行器。需要说明一下,在 Zuul 中,ZuulRunner 在获取具体有哪些过滤器的时候,有一个 FileLoader 可以动态读取配置加载。博主在实现我们自己的 EatuulRunner 时候,略去动态读取的过程,直接静态写死。
源码如下
package com.rjzheng.eatuul.http;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.rjzheng.eatuul.filter.EatuulFilter;
import com.rjzheng.eatuul.filter.post.SendResponseFilter;
import com.rjzheng.eatuul.filter.pre.RequestWrapperFilter;
import com.rjzheng.eatuul.filter.route.RoutingFilter;

public class EatRunner {
    //静态写死过滤器
    private ConcurrentHashMap<String, List<EatuulFilter>> hashFiltersByType = new ConcurrentHashMap<String, List<EatuulFilter>>(){{  
        put(“pre”,new ArrayList<EatuulFilter>(){{
            add(new RequestWrapperFilter());
        }});
        put(“route”,new ArrayList<EatuulFilter>(){{
            add(new RoutingFilter());
        }});
        put(“post”,new ArrayList<EatuulFilter>(){{
            add(new SendResponseFilter());
        }});
     }};

    public void init(HttpServletRequest req, HttpServletResponse resp) {
        RequestContext ctx = RequestContext.getCurrentContext();
        ctx.setRequest(req);
        ctx.setResponse(resp);
    }

    public void preRoute() throws Throwable {
        runFilters(“pre”);  
    }

    public void route() throws Throwable{
        runFilters(“route”);    
    }

    public void postRoute() throws Throwable{
        runFilters(“post”);
    }

     public void runFilters(String sType) throws Throwable {
            List<EatuulFilter> list = this.hashFiltersByType.get(sType);
            if (list != null) {
                for (int i = 0; i < list.size(); i++) {
                    EatuulFilter zuulFilter = list.get(i);
                    zuulFilter.run();
                }
            }
     }

}

EatuulFilter.java
接下来就是一系列 Filter 的代码了,先上父类 EatuulFilter 的源码
package com.rjzheng.eatuul.filter;

public abstract class EatuulFilter {

    abstract public String filterType();

    abstract public int filterOrder();

    abstract public void run();

}

RequestWrapperFilter.java
这个是 PreFilter,前置执行过滤器,负责封装请求。步骤如下所示
(1)封装请求头
(2)封装请求体
(3)构造出 RestTemplate 能识别的 RequestEntity
(4)将 RequestEntity 放入全局 threadlocal 之中
代码如下所示
package com.rjzheng.eatuul.filter.pre;

import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.RequestEntity;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StreamUtils;

import com.rjzheng.eatuul.filter.EatuulFilter;
import com.rjzheng.eatuul.http.RequestContext;

public class RequestWrapperFilter extends EatuulFilter{

    @Override
    public String filterType() {
        // TODO Auto-generated method stub
        return “pre”;
    }

    @Override
    public int filterOrder() {
        // TODO Auto-generated method stub
        return –1;
    }

    @Override
    public void run() {
        String rootURL = http://localhost:9090&#8221;;
        RequestContext ctx =RequestContext.getCurrentContext();
        HttpServletRequest servletRequest = ctx.getRequest();
        String targetURL = rootURL + servletRequest.getRequestURI();
        RequestEntity<byte[]> requestEntity = null;
        try {
            requestEntity = createRequestEntity(servletRequest, targetURL);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //4、将 requestEntity 放入全局 threadlocal 之中
        ctx.setRequestEntity(requestEntity);
    }

    private RequestEntity createRequestEntity(HttpServletRequest request,String url) throws URISyntaxException, IOException {
        String method = request.getMethod();
        HttpMethod httpMethod = HttpMethod.resolve(method);
        //1、封装请求头
        MultiValueMap<String, String> headers =createRequestHeaders(request);
        //2、封装请求体
        byte[] body = createRequestBody(request);
        //3、构造出 RestTemplate 能识别的 RequestEntity
        RequestEntity requestEntity = new RequestEntity<byte[]>(body,headers,httpMethod, new URI(url));
        return requestEntity;
    }


    private byte[] createRequestBody(HttpServletRequest request) throws IOException {
        InputStream inputStream = request.getInputStream();
        return StreamUtils.copyToByteArray(inputStream);
    }

    private MultiValueMap<String, String> createRequestHeaders(HttpServletRequest request) {
        HttpHeaders headers = new HttpHeaders();
        List<String> headerNames = Collections.list(request.getHeaderNames());
        for(String headerName:headerNames) {
            List<String> headerValues = Collections.list(request.getHeaders(headerName));
            for(String headerValue:headerValues) {
                headers.add(headerName, headerValue);
            }
        }
        return headers;
    }
}
RoutingFilter.java
这个是 routeFilter,这里我偷懒了,直接做转发请求,并且将返回值 ResponseEntity 放入全局 threadlocal 中
package com.rjzheng.eatuul.filter.route;

import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;

import com.rjzheng.eatuul.filter.EatuulFilter;
import com.rjzheng.eatuul.http.RequestContext;

public class RoutingFilter extends EatuulFilter{

    @Override
    public String filterType() {
        // TODO Auto-generated method stub
        return “route”;
    }

    @Override
    public int filterOrder() {
        // TODO Auto-generated method stub
        return 0;
    }

    @Override
    public void run(){
        RequestContext ctx = RequestContext.getCurrentContext();
        RequestEntity requestEntity = ctx.getRequestEntity();
        RestTemplate restTemplate = new RestTemplate();
        ResponseEntity responseEntity = restTemplate.exchange(requestEntity,byte[].class);
        ctx.setResponseEntity(responseEntity);
    }


}

SendResponseFilter.java
这个是 postFilters,将 ResponseEntity 输出即可
package com.rjzheng.eatuul.filter.post;

import java.util.List;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;

import com.rjzheng.eatuul.filter.EatuulFilter;
import com.rjzheng.eatuul.http.RequestContext;

public class SendResponseFilter extends EatuulFilter{

    @Override
    public String filterType() {
        return “post”;
    }

    @Override
    public int filterOrder() {
        return 1000;
    }

    @Override
    public void run() {
        try {
            addResponseHeaders();
            writeResponse();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void addResponseHeaders() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletResponse servletResponse = ctx.getResponse();
        ResponseEntity responseEntity = ctx.getResponseEntity();
        HttpHeaders httpHeaders = responseEntity.getHeaders();
        for(Map.Entry<String, List<String>> entry:httpHeaders.entrySet()) {
            String headerName = entry.getKey();
            List<String> headerValues = entry.getValue();
            for(String headerValue:headerValues) {
                servletResponse.addHeader(headerName, headerValue);
            }
        }
    }

    private void writeResponse()throws Exception {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletResponse servletResponse = ctx.getResponse();
        if (servletResponse.getCharacterEncoding() == null) { // only set if not set
            servletResponse.setCharacterEncoding(“UTF-8”);
        }
        ResponseEntity responseEntity = ctx.getResponseEntity();
        if(responseEntity.hasBody()) {
            byte[] body = (byte[]) responseEntity.getBody();
            ServletOutputStream outputStream = servletResponse.getOutputStream();
            outputStream.write(body);
            outputStream.flush();
        }
    }

}

RequestContext.java
最后是一直在说的全局 threadlocal 变量
package com.rjzheng.eatuul.http;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;

public class RequestContext extends ConcurrentHashMap<StringObject{
    protected static Class<? extends RequestContext> contextClass = RequestContext.class;
    protected static final ThreadLocal<? extends RequestContext> threadLocal = new ThreadLocal<RequestContext>() {
        @Override
        protected RequestContext initialValue() {
            try {
                return contextClass.newInstance();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }
    };

    public static RequestContext getCurrentContext() {
        RequestContext context = threadLocal.get();
        return context;
    }

    public HttpServletRequest getRequest() {
        return (HttpServletRequest) get(“request”);
    }

    public void setRequest(HttpServletRequest request) {
        put(“request”, request);
    }

    public HttpServletResponse getResponse() {
        return (HttpServletResponse) get(“response”);
    }

    public void setResponse(HttpServletResponse response) {
        set(“response”, response);
    }


    public void setRequestEntity(RequestEntity requestEntity){
        set(“requestEntity”,requestEntity);
    }

    public RequestEntity getRequestEntity() {
        return (RequestEntity) get(“requestEntity”);
    }

    public void setResponseEntity(ResponseEntity responseEntity){
        set(“responseEntity”,responseEntity);
    }

    public ResponseEntity getResponseEntity() {
        return (ResponseEntity) get(“responseEntity”);
    }

    public void set(String key, Object value) {
        if (value != null)
            put(key, value);
        else
            remove(key);
    }

    public void unset() {
        threadLocal.remove();
    }

}

如何测试?

自己另外起一个 server 端口为 9090 如下所示
package com.rjzheng.eatservice;

import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.ServletComponentScan;

import com.rjzheng.eatservice.controller.IndexController;

@SpringBootApplication
@ServletComponentScan(basePackageClasses = IndexController.class)
public class Application {

    public static void main(String[] args) {
        new SpringApplicationBuilder(Application.class).properties(“server.port=9090”).run(args);
    }

}

再来一个 controller
package com.rjzheng.eatservice.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class IndexController {

    @RequestMapping(“/index“)
    public String index() {
        return “hello!world“;
    }
}
然后,你就发现可以从 localhost:8080/index 进行跳转访问了
3 结论
本文模拟了一下 zuul 网关的源码,借鉴了一下其精髓的部分。希望大家能有所收获

丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:如何从 0 写一个服务网关?
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

欢迎 注册账号 登录 发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00