参考：https://blog.csdn.net/u014091123/article/details/75433656
https://blog.csdn.net/u013815546/article/details/68944039
Zuul是Netflix开源的微服务网关，他的核心是一系列的过滤器，通过这些过滤器我们可以轻松的实现服务的访问认证、限流、路由、负载、熔断等功能。
基于对已有项目代码零侵入的需求，本文没有将zuul网关项目注册到eureka中心，而是将zuul与springboot结合作为一个独立的项目进行请求转发，因此本项目是非spring cloud架构。
开始编写zuul网关项目
首先，新建一个spring boot项目。加入zuul依赖，开启@EnableZuulProxy注解。
pom.xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zuul</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
application.properties
server.port=8090
eureka.client.enable=false
zuul.ribbon.eager-load.enabled=true zuul.SendErrorFilter.post.disable=true
由于后续会使用到动态路由，所以这里我们并不需要在application.properties中做网关地址转发映射。
SpringBootZuulApplication.java
package com.syher.zuul; import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.syher.zuul.core.zuul.router.PropertiesRouter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.cloud.netflix.zuul.RoutesRefreshedEvent;
import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.ComponentScan; import java.io.File;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; /**
* @author braska
* @date 2018/06/25.
**/
@EnableAutoConfiguration
@EnableZuulProxy
@ComponentScan(basePackages = {
"com.syher.zuul.core",
"com.syher.zuul.service"
})
public class SpringBootZuulApplication implements CommandLineRunner {
@Autowired
ApplicationEventPublisher publisher;
@Autowired
RouteLocator routeLocator; private ScheduledExecutorService executor;
private Long lastModified = 0L;
private boolean instance = true; public static void main(String[] args) {
SpringApplication.run(SpringBootZuulApplication.class, args);
} @Override
public void run(String... args) throws Exception {
executor = Executors.newSingleThreadScheduledExecutor(
new ThreadFactoryBuilder().setNameFormat("properties read.").build()
);
executor.scheduleWithFixedDelay(() -> publish(), 0, 1, TimeUnit.SECONDS);
} private void publish() {
if (isPropertiesModified()) {
publisher.publishEvent(new RoutesRefreshedEvent(routeLocator));
}
} private boolean isPropertiesModified() {
File file = new File(this.getClass().getClassLoader().getResource(PropertiesRouter.PROPERTIES_FILE).getPath());
if (instance) {
instance = false;
return false;
}
if (file.lastModified() > lastModified) {
lastModified = file.lastModified();
return true;
}
return false;
}
}
一、自定义过滤器
自定义zuul过滤器比较简单。我们先讲过滤器。
zuul过滤器分为pre、route、post、error四种类型。作用我就不详细讲了，网上资料一大把。本文主要写路由前的过滤，即pre类型。
要自定义一个过滤器，只需要要继承ZuulFilter，然后指定过滤类型、过滤顺序、是否执行这个过滤器、过滤内容就OK了。
为了便于扩展，这里用到了模板模式。
AbstractZuulFilter.java
package com.syher.zuul.core.zuul.filter; import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.syher.zuul.core.zuul.ContantValue; /**
* @author braska
* @date 2018/06/29.
**/
public abstract class AbstractZuulFilter extends ZuulFilter { protected RequestContext context; @Override
public boolean shouldFilter() {
RequestContext ctx = RequestContext.getCurrentContext();
return (boolean) (ctx.getOrDefault(ContantValue.NEXT_FILTER, true));
} @Override
public Object run() {
context = RequestContext.getCurrentContext();
return doRun();
} public abstract Object doRun(); public Object fail(Integer code, String message) {
context.set(ContantValue.NEXT_FILTER, false);
context.setSendZuulResponse(false);
context.getResponse().setContentType("text/html;charset=UTF-8");
context.setResponseStatusCode(code);
context.setResponseBody(String.format("{\"result\":\"%s!\"}", message));
return null;
} public Object success() {
context.set(ContantValue.NEXT_FILTER, true);
return null;
}
}
定义preFilter的抽象类，继承AbstractZuulFilter。指定pre类型，之后所有的pre过滤器都可以继承这个抽象类。
AbstractPreZuulFilter.java
package com.syher.zuul.core.zuul.filter.pre; import com.syher.zuul.core.zuul.FilterType;
import com.syher.zuul.core.zuul.filter.AbstractZuulFilter; /**
* @author braska
* @date 2018/06/29.
**/
public abstract class AbstractPreZuulFilter extends AbstractZuulFilter {
@Override
public String filterType() {
return FilterType.pre.name();
}
}
接着编写具体一个具体的过滤器，比如限流。
RateLimiterFilter.java
package com.syher.zuul.core.zuul.filter.pre; import com.google.common.util.concurrent.RateLimiter;
import com.syher.zuul.core.zuul.FilterOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import javax.servlet.http.HttpServletRequest; /**
* @author braska
* @date 2018/06/29.
**/
public class RateLimiterFilter extends AbstractPreZuulFilter { private static final Logger LOGGER = LoggerFactory.getLogger(RateLimiterFilter.class); /**
* 每秒允许处理的量是50
*/
RateLimiter rateLimiter = RateLimiter.create(50); @Override
public int filterOrder() {
return FilterOrder.RATE_LIMITER_ORDER;
} @Override
public Object doRun() {
HttpServletRequest request = context.getRequest();
String url = request.getRequestURI();
if (rateLimiter.tryAcquire()) {
return success();
} else {
LOGGER.info("rate limit:{}", url);
return fail(401, String.format("rate limit:{}", url));
}
}
}
其他类型的过滤器也一样。创建不同的抽象类，比如AbstractPostZuulFilter，指定filterType，然后具体的postFilter只要继承该抽象类即可。
最后，将过滤器托管给spring。
ZuulConfigure.java
package com.syher.zuul.core.config; import com.netflix.loadbalancer.IRule;
import com.netflix.zuul.ZuulFilter;
import com.syher.zuul.core.ribbon.ServerLoadBalancerRule;
import com.syher.zuul.core.zuul.filter.pre.RateLimiterFilter;
import com.syher.zuul.core.zuul.filter.pre.TokenAccessFilter;
import com.syher.zuul.core.zuul.filter.pre.UserRightFilter;
import com.syher.zuul.core.zuul.router.PropertiesRouter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.web.ServerProperties;
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; /**
* @author braska
* @date 2018/07/05.
**/
@Configuration
public class ZuulConfigure { @Autowired
ZuulProperties zuulProperties;
@Autowired
ServerProperties server; /**
* 动态路由
* @return
*/
@Bean
public PropertiesRouter propertiesRouter() {
return new PropertiesRouter(this.server.getServletPrefix(), this.zuulProperties);
} /**
* 动态负载
* @return
*/
@Bean
public IRule loadBalance() {
return new ServerLoadBalancerRule();
} /**
* 自定义过滤器
* @return
*/
@Bean
public ZuulFilter rateLimiterFilter() {
return new RateLimiterFilter();
}
}
二、动态路由
接着写动态路由。动态路由需要配置可持久化且能动态刷新。
zuul默认使用的路由是SimpleRouteLocator，不具备动态刷新的效果。DiscoveryClientRouteLocator具备刷新功能，但是需要已有的项目将服务注册到eureka，这不符合已有项目代码零侵入的需求所以排除。那么还有个办法就是自定义路由然后实现RefreshableRouteLocator类。
部分代码如下：
AbstractDynamicRouter.java
package com.syher.zuul.core.zuul.router; import com.syher.zuul.core.zuul.entity.BasicRoute;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.cloud.netflix.zuul.filters.RefreshableRouteLocator;
import org.springframework.cloud.netflix.zuul.filters.SimpleRouteLocator;
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map; /**
* @author braska
* @date 2018/07/02.
**/
public abstract class AbstractDynamicRouter extends SimpleRouteLocator implements RefreshableRouteLocator { private static final Logger LOGGER = LoggerFactory.getLogger(AbstractDynamicRouter.class); public AbstractDynamicRouter(String servletPath, ZuulProperties properties) {
super(servletPath, properties);
} @Override
public void refresh() {
doRefresh();
} @Override
protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {
LinkedHashMap<String, ZuulProperties.ZuulRoute> routes = new LinkedHashMap<String, ZuulProperties.ZuulRoute>();
routes.putAll(super.locateRoutes()); List<BasicRoute> results = readRoutes(); for (BasicRoute result : results) {
if (StringUtils.isEmpty(result.getPath()) ) {
continue;
}
ZuulProperties.ZuulRoute zuulRoute = new ZuulProperties.ZuulRoute();
try {
BeanUtils.copyProperties(result, zuulRoute);
} catch (Exception e) {
LOGGER.error("=============load zuul route info from db with error==============", e);
}
routes.put(zuulRoute.getPath(), zuulRoute);
}
return routes;
} /**
* 读取路由信息
* @return
*/
protected abstract List<BasicRoute> readRoutes();
}
由于本人比较懒。不想每次写个demo都要重新配置一大堆数据库信息。所以本文很多数据比如路由信息、比如负载策略。要么写在文本里面，要么直接java代码构造。
本demo的路由信息就是从properties里面读取。嗯，继承AbstractDynamicRouter即可。
PropertiesRouter.java
package com.syher.zuul.core.zuul.router; import com.google.common.collect.Lists;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.syher.zuul.common.Context;
import com.syher.zuul.core.zuul.entity.BasicRoute;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.netflix.zuul.filters.ZuulProperties; import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.stream.Collectors; /**
* @author braska
* @date 2018/07/02.
**/
public class PropertiesRouter extends AbstractDynamicRouter { private static final Logger LOGGER = LoggerFactory.getLogger(PropertiesRouter.class);
public static final String PROPERTIES_FILE = "router.properties";
private static final String ZUUL_ROUTER_PREFIX = "zuul.routes"; public PropertiesRouter(String servletPath, ZuulProperties properties) {
super(servletPath, properties);
} @Override
protected List<BasicRoute> readRoutes() {
List<BasicRoute> list = Lists.newArrayListWithExpectedSize(3);
try {
Properties prop = new Properties();
prop.load(
this.getClass().getClassLoader().getResourceAsStream(PROPERTIES_FILE)
); Context context = new Context(new HashMap<>((Map) prop));
Map<String, String> data = context.getSubProperties(ZUUL_ROUTER_PREFIX);
List<String> ids = data.keySet().stream().map(s -> s.substring(0, s.indexOf("."))).distinct().collect(Collectors.toList());
ids.stream().forEach(id -> {
Map<String, String> router = context.getSubProperties(String.join(".", ZUUL_ROUTER_PREFIX, id)); String path = router.get("path");
path = path.startsWith("/") ? path : "/" + path; String serviceId = router.getOrDefault("serviceId", null);
String url = router.getOrDefault("url", null); BasicRoute basicRoute = new BasicRoute();
basicRoute.setId(id);
basicRoute.setPath(path);
basicRoute.setUrl(router.getOrDefault("url", null));
basicRoute.setServiceId((StringUtils.isBlank(url) && StringUtils.isBlank(serviceId)) ? id : serviceId);
basicRoute.setRetryable(Boolean.parseBoolean(router.getOrDefault("retry-able", "false")));
basicRoute.setStripPrefix(Boolean.parseBoolean(router.getOrDefault("strip-prefix", "false")));
list.add(basicRoute);
});
} catch (IOException e) {
LOGGER.info("error to read " + PROPERTIES_FILE + " :{}", e);
}
return list;
}
}
既然是动态路由实时刷新，那肯定需要一个定时器定时监控properties文件。所以我在启动类SpringBootZuulApplication加了个定时器监控properties是否发生过变更(之前有疑问的现在可以解惑了）。一旦文件被修改过就重新发布一下， 然后会触发routeLocator的refresh方法。
public void publish() {
if (isPropertiesModified()) {
publisher.publishEvent(new RoutesRefreshedEvent(routeLocator));
}
}
当然，如果是从数据库或者其他地方比如redis读取就不需要用到定时器，只要在增删改的时候直接publish就好了。
最后，记得PropertiesRouter类交由spring托管（在ZuulConfigure类中配置bean）。
router.properties文件：
zuul.routes.dashboard.path=/**
zuul.routes.dashboard.strip-prefix=true ##不使用动态负载需指定url
##zuul.routes.dashboard.url=http://localhost:9000/
##zuul服务部署后，动态增加网关映射，无需重启即可实时路由到新的网关
##zuul.routes.baidu.path=/**
三、动态负载
负载也算比较简单，复杂点的是写负载算法。
动态负载主要分两个步骤：
1、根据网关项目配置的host和port去数据库（我是java直接造的数据）查找负载策略，比如轮询、比如随机、比如iphash等等。
2、根据策略结合每台服务器分配的权重选出合适的服务。
实现动态负载需要自定义rule类然后继承AbstractLoadBalancerRule类。
首先看负载策略的选择：
ServerLoadBalancerRule.java
package com.syher.zuul.core.ribbon; import com.google.common.base.Preconditions;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import com.syher.zuul.common.util.SystemUtil;
import com.syher.zuul.core.ribbon.balancer.LoadBalancer;
import com.syher.zuul.core.ribbon.balancer.RandomLoadBalancer;
import com.syher.zuul.core.ribbon.balancer.RoundLoadBalancer;
import com.syher.zuul.entity.GatewayAddress;
import com.syher.zuul.service.GatewayService;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; /**
* @author braska
* @date 2018/07/05.
**/
public class ServerLoadBalancerRule extends AbstractLoadBalancerRule { private static final Logger LOGGER = LoggerFactory.getLogger(ServerLoadBalancerRule.class); @Value("${server.host:127.0.0.1}")
private String host;
@Value("${server.port:8080}")
private Integer port; @Autowired
private GatewayService gatewayService; @Override
public void initWithNiwsConfig(IClientConfig iClientConfig) {
} @Override
public Server choose(Object key) {
return getServer(getLoadBalancer(), key);
} private Server getServer(ILoadBalancer loadBalancer, Object key) {
if (StringUtils.isBlank(host)) {
host = SystemUtil.ipList().get(0);
}
//Preconditions.checkArgument(host != null, "server.host must be specify.");
//Preconditions.checkArgument(port != null, "server.port must be specify."); GatewayAddress address = gatewayService.getByHostAndPort(host, port);
if (address == null) { //这里的逻辑可以改，找不到网关配置信息可以指定默认的负载策略
LOGGER.error(String.format("must be config a gateway info for the server[%s:%s].", host, String.valueOf(port)));
return null;
} LoadBalancer balancer = LoadBalancerFactory.build(address.getFkStrategyId()); return balancer.chooseServer(loadBalancer);
} static class LoadBalancerFactory { public static LoadBalancer build(String strategy) {
GatewayAddress.StrategyType type = GatewayAddress.StrategyType.of(strategy);
switch (type) {
case ROUND:
return new RoundLoadBalancer();
case RANDOM:
return new RandomLoadBalancer();
default:
return null;
}
}
}
}
然后是负载算法接口代码。
LoadBalancer.java
package com.syher.zuul.core.ribbon.balancer; import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server; /**
* @author braska
* @date 2018/07/06.
**/
public interface LoadBalancer { /**
* choose a loadBalancer
* @param loadBalancer
* @return
*/
Server chooseServer(ILoadBalancer loadBalancer);
}
定义抽象类，实现LoadBalancer接口
AbstractLoadBalancer.java
package com.syher.zuul.core.ribbon.balancer; import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import com.syher.zuul.core.SpringContext;
import com.syher.zuul.service.ServerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory; /**
* @author braska
* @date 2018/07/06.
**/
public abstract class AbstractLoadBalancer implements LoadBalancer {
private static final Logger LOGGER = LoggerFactory.getLogger(AbstractLoadBalancer.class);
protected ServerService serverService; @Override
public Server chooseServer(ILoadBalancer loadBalancer) {
this.serverService = SpringContext.getBean(ServerService.class);
Server server = choose(loadBalancer);
if (server != null) {
LOGGER.info(String.format("the server[%s:%s] has been select.", server.getHost(), server.getPort()));
} else {
LOGGER.error("could not find any server.");
}
return server;
} public abstract Server choose(ILoadBalancer loadBalancer);
}
轮询负载算法
RoundLoadBalancer.java
package com.syher.zuul.core.ribbon.balancer; import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;
import com.syher.zuul.common.Constant;
import com.syher.zuul.core.GlobalCache;
import com.syher.zuul.core.ribbon.LoadBalancerRuleUtil;
import com.syher.zuul.entity.ServerAddress; import java.util.List; /**
* 权重轮询
* 首次使用取最大权重的服务器。而后通过权重的不断递减，寻找适合的服务器。
* @author braska
* @date 2018/07/06.
**/
public class RoundLoadBalancer extends AbstractLoadBalancer { private Integer currentServer;
private Integer currentWeight;
private Integer maxWeight;
private Integer gcdWeight; @Override
public Server choose(ILoadBalancer loadBalancer) {
List<ServerAddress> addressList = serverService.getAvailableServer();
if (addressList != null && !addressList.isEmpty()) {
maxWeight = LoadBalancerRuleUtil.getMaxWeightForServers(addressList);
gcdWeight = LoadBalancerRuleUtil.getGCDForServers(addressList);
currentServer = Integer.parseInt(GlobalCache.instance().getOrDefault(Constant.CURRENT_SERVER_KEY, -1).toString());
currentWeight = Integer.parseInt(GlobalCache.instance().getOrDefault(Constant.CURRENT_WEIGHT_KEY, 0).toString()); Integer serverCount = addressList.size(); if (1 == serverCount) {
return new Server(addressList.get(0).getHost(), addressList.get(0).getPort());
} else {
while (true) {
currentServer = (currentServer + 1) % serverCount;
if (currentServer == 0) {
currentWeight = currentWeight - gcdWeight;
if (currentWeight <= 0) {
currentWeight = maxWeight;
if (currentWeight == 0) {
GlobalCache.instance().put(Constant.CURRENT_SERVER_KEY, currentServer);
GlobalCache.instance().put(Constant.CURRENT_WEIGHT_KEY, currentWeight);
Thread.yield();
return null;
}
}
} ServerAddress address = addressList.get(currentServer);
if (address.getWeight() >= currentWeight) {
GlobalCache.instance().put(Constant.CURRENT_SERVER_KEY, currentServer);
GlobalCache.instance().put(Constant.CURRENT_WEIGHT_KEY, currentWeight);
return new Server(address.getHost(), address.getPort());
}
}
} }
return null;
}
}
最后，ServerLoadBalancerRule交由spring托管。
至此，springboot+zuul实现自定义过滤器、动态路由、动态负载就都完成了。
源码：https://github.com/rxiu/study-on-road/tree/master/trickle-gateway