引言

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

如图所示，在不使用网关的情况下，我们的服务是直接暴露给服务调用方。当调用方增多，势必需要添加定制化访问权限、校验等逻辑。当添加API网关后，再第三方调用端和服务提供方之间就创建了一面墙，这面墙直接与调用方通信进行权限控制。

本文所实现的网关源码抄袭了---Oh,不对，是借鉴。借鉴了Zuul网关的源码，提炼出其核心思路，实现了一套简单的网关源码，博主将其改名为Eatuul。

题外话

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

正文

设计思路

先大致说一下，就是定义一个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> hashFiltersByType = new ConcurrentHashMap>(){{

put("pre",new ArrayList(){{

add(new RequestWrapperFilter());

}});

put("route",new ArrayList(){{

add(new RoutingFilter());

}});

put("post",new ArrayList(){{

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 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";

RequestContext ctx =RequestContext.getCurrentContext();

HttpServletRequest servletRequest = ctx.getRequest();

String targetURL = rootURL + servletRequest.getRequestURI();

RequestEntity 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 headers =createRequestHeaders(request);

//2、封装请求体

byte[] body = createRequestBody(request);

//3、构造出RestTemplate能识别的RequestEntity

RequestEntity requestEntity = new RequestEntity(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 createRequestHeaders(HttpServletRequest request) {

HttpHeaders headers = new HttpHeaders();

List headerNames = Collections.list(request.getHeaderNames());

for(String headerName:headerNames) {

List 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> entry:httpHeaders.entrySet()) {

String headerName = entry.getKey();

List 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 {

protected static Class extends RequestContext> contextClass = RequestContext.class;

protected static final ThreadLocal extends RequestContext> threadLocal = new ThreadLocal() {

@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进行跳转访问了

结论

本文模拟了一下zuul网关的源码，借鉴了一下其精髓的部分。希望大家能有所收获

断网啊，对于这种情况大家肯定紧张了，马上想解决问题。

(自媒体www.777n.com)

冷静下来想一下，碰到以上故障，一定是先Ping网关，如果能Ping通，那么问题就发生在网关到网络运营商，这种情况就赶紧报故障给运营商吧；但如果Ping不通，问题就发生在企业内部网络了，怎么定位这类故障呢？不急，先让我介绍下ping吧。 (原创文章www.777n.com)

Ping的作用是测试主机/交换机到某一个IP地址的网络是否通畅。Ping基于ICMP协议实现的。通过从源端向目的端发送ICMP回显请求(Echo Request)报文后，根据是否收到目的端的ICMP回显应答(Echo Reply)报文来判断目的端是否可达。

(原文来自www.777n.com)

即源端在一个有效时间内(等待回显应答报文超时时间之前)收到目的端返回的ICMP回显应答报文，则说明目的端可达。如果在有效时间内，没有收到应答报文，则说明目的端不可达。对于可达的目的端，根据发送报文个数、接收到响应报文个数来判断链路的质量，根据Ping报文的往返时间来判断源端与目的端之间的“距离”。

一、故障定位流程

◀

从PC到企业网关之间的设备如果不止一台，那么建议分段执行Ping命令，找出故障大概位置再进行详细定位。检查配置——如果是配置问题，修改配置后看故障是否恢复。

检查链路——如果是链路问题，排查故障后看故障是否恢复。

检查路由——如果没有到目的IP的路由，排查路由故障。

检查ARP——直连链路，查看是否学习到ARP表项。没有学习到，要先排除ARP学习故障。

检查报文收发情况——有很多种方式可以检查，包括：ICMP统计、IP层调试、

CPCAR统计、流量统计、镜像…….二、故障解决思路◀1、检查配置检查交换机上端口配置、VLAN配置、VLANIF接口配置、IP地址配置是否正确，首先排除配置问题；确认两端端口的端口类型，两端VLAN的封装方式是否一致，VLANIF接口下IP地址配置的网段是否存在问题。2、检测链路

三、检测链路

◀

A、物理链路

1. 光纤或网线连接的端口需要和网络要求的部署一致。

2. 光纤所带的光模块波长参数需要一致，光模块建议使用华为认证光模块。

3. 如果是通过Eth-Trunk接口连接，两端设备上Eth-Trunk中加入的物理成员端口

数量需要保持一致；若Eth-Trunk启用LACP协议，需要保证LACP协议状态稳

定。

4. 检查两端设备之间是否有传输设备，两端的物理端口是否处于UP状态。

5. 确认Ping业务经过的物理端口是否存在CRC校验错误，且错误计数是否在不

断增长。

6. 检查物理端口是否存在阻塞现象。检查设备上是否运行了STP、RRPP或

SMART LINK等二层协议，确认Ping业务经过的物理端口是否被阻塞。

B、路由检测

检查设备上是否存在到Ping目的地址的路由。参考命令：display ip routing-table 如果和交换机连接的是终端设备，检查终端设备上是否配置了正确的网关地址。如果和交换机连接的是交换机或路由设备，检查对端设备上是有正确的回程路由。如果路由不正常，检查接口协议状态是否UP，设备上运行的路由协议是否正常，排查路由故障。

四、检查 ARP 表项

◀

1、检查直连地址的ARP是否学习正常。相关命令：

display arp

display arp interface vlanif vlanif-id

2、如果ARP学习正确，查看MAC表项，确认MAC地址的出端口和ARP的物理

出端口是否一致。相关命令：

display mac-address mac-address

display mac-address mac-address vlan vlan-id

3、查看是否能学习到arp，如不能请排错

a、是否配置了严格使能学习arp，有请去掉再试

b、通过ping操作重新学习arp

五、检查报文收发情况

◀

(有点难，有需要的可自行研究)

Ping不通问题或Ping有丢包问题的定位关键主要是确认报文丢在哪里了，可以通过如下几个方式进行确认。

1、ICMP统计

2、CPCAR统计

3、流量统计

网关是什么？对于普通的用户来说，电脑网关不是很明白的，不过接触电脑多了之后，大家也会常常会听到“网关”这个词，那么问题就来了，这个网关是什么意思呢？它又有哪些作用呢？今晚，智能手机网就来为各位详细讲一讲网关的意思与作用，赶紧来了解一下！

网关是什么_网关的作用与设置方法介绍 一看就明白

网关是什么？

其实，网关英文名称为Gateway，又称网间连接器、协议转换器。网关在网络层以上实现网络互连，是最复杂的网络互连设备，仅用于两个高层协议不同的网络互连。

网关既可以用于广域网互连，也可以用于局域网互连。 网关是一种充当转换重任的计算机系统或设备。使用在不同的通信协议、数据格式或语言，甚至体系结构完全不同的两种系统之间，网关是一个翻译器，与网桥只是容易地传达信息不同，网关对收到的信息要重新打包，以适应目的系统的需求。

比如，我们从一个房间走到另一个房间，必然要经过一扇门。同样，从一个网络向另一个网络发送信息，也必需经过一道“关口”，这道关口就是网关。顾名思义，网关(Gateway)就是一个网络连接到另一个网络的“关口”。也就是网络关卡。

其实，许多有关TCP/IP的文献曾经把网络层使用的路由器称为网关，而在今天不少局域网中，采用都是路由来接入网络，所以通常指的网关就是路由器的默认IP地址。

一般来说，路由器的LAN接口的IP地址就是你所在局域网中的网关。当你所在的局域网的计算机需要和其它局域网中的计算机，或者需要访问互联网的时候，你所在局域网的计算机会先把数据包传输到网关(路由器的LAN接口)，然后再由网关进行转发。

网关的作用是什么？

网关是一种充当转换重任的计算机系统或设备，在使用不同的通信协议，数据格式或语言,甚至体系结构完全不同的两种系统时，网关是一个翻译器。与网桥只是容易地传送信息不同，网关对收到的信息要重新打包，以适应目的系统的需求。同时，网关也可以提供过滤和安全功能。

这就是为什么我们在有路由器上网的时候，必需要把计算机中的默认网关地址设置成路由器LAN接口的地址的原因，因为路由器的LAN接口就是你所在网络的网关，你的电脑要上网，数据包必需要经过网关转发出去。现在家用路由器一般使用192.168.1.1和192.168.0.1作为LAN接口的地址，这两个地址也是最常见的网关地址。

容易来说，网关是设备与路由器之间的桥梁，正确的网关配置才能保证用户可以正常上网。

默认网关如何设置？

在一般的路由器网络中，默认网关最常见的一般是：192.168.1.1和192.168.0.1，也就是路由器LAN接口的默认IP地址。固然，也有一些智能路由器会使用其它IP地址作为默认网关，这个主要是路由器厂商出厂前设定的。

想要查看电脑的默认网关，大家可以使用下面的方法：

1、打开开始运行对话框，也可以直接使用 Win + R 组合快捷键打开，然后在打开后面键入 cmd 并点击“确定”进入，如下图所示。

2、打开运行对话框后，然后键入命名：ipconfig /all 完成后，按回车键运行，之后就可以查看到电脑所连接网络的默认网关了，如下图所示。

用户可以进入路由器设置中进行更改即可，具体方法是进入路由器设置，然后选择LAN口设置，之后更改右侧的IP默认网关IP地址即可，如下图所示。

更改完默认网关IP地址，重启一下路由器即可生效。

网关和路由器的区别有哪些？

1、本质的区别

网关这种设备它主要是用来连接两种不同的网络，同时，网关它还能够同时与两边的主机之间进行通信。但是两边的主机是不能够直接进行通信，是必须要经过网关才能进行通信。网关的工作是在应用层当中。

路由器它是属于网络层设备，通常是以包为单位进行数据的发送。在路由器的子接口，是有分割广播域的作用，所以当我们用交换机做VLAN以后，都是要在路由器上做一个三层的路由。

2、使用方式的区别

网关它可以是路由器，交换机或者是PC。在同一网段之内进行通信，是不需要将网关介入其中，只有当主机个非本网段设备进行通信的时候，才需要将数据包全部发给网关设备，再经由网关设备进行转发或者是有路由处理等。

路由器它是一个网络层系统，路由器在现在市场上一般是被分成了两大类，一类是单协议路由器，另一类是多协议路由器。路由器它可以进行数据格式的转换，成为不同于协议之间的网络互连的必要设备。

3、功能上的区别

网关可以分为传输型网关和应用型网关，它的功能是充当转换重任，实质上就是一个网络通向其他网络的IP地址。路由器的功能主要有：连通不同的网络和信息传输作用。按照使用可分为：接入、企业级、骨干级、太比特、多WAN以及3G无线等。

上述关于网关的作用与设置方法介绍大家都看明白了吧，了解更多，可以看看相关文章!

文章来源：https://www.znsjw.com/pc/8853.html