<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.3.RELEASE</version>
</parent>

<dependencies>
	<dependency>
        <groupId>org.springframework.cloud</groupId
 
>
        <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zuul</artifactId>
    </dependency>
</dependencies>

<dependencyManagement>
	<dependencies>
		<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Dalston.RELEASE</version>
<type>pom</type>
<scope>import</scope>
    	</dependency>
    </dependencies>
</dependencyManagement>

@EnableZuulProxy
@SpringCloudApplication
public class GatewayServer
{
    public static void main(String[] args)
{
        SpringApplication.run(GatewayServer.class, args);
    }
}

zuul:
	routes:
		wap:
			path: /wap/**
			url: http://192.168.1.10:8081

zuul:
	routes:
		wap:
			path: /wap/**
			serviceId: wap
ribbon:
	eureka:
		enabled: false
wap:
	ribbon:
		listOfServers: http://192.168.1.10:8081, http://192.168.1.11:8081

zuul:
	routes:
		wap:
			path: /wap/**
			url: forward:/wap

zuul:
	routes:
		activity: /activity/**

zuul:
	routes:
		activity:
			path: /activity/** # 指定
			serviceId: micro-activity # 指定路由的serviceId
			stripPrefix: false

zuul:
	sensitiveHeaders: # 使用空來覆蓋預設值

zuul:
	routes:
		[route]:
			customSensitiveHeaders: true # 對指定路由開啟自定義敏感頭

zuul:
	routes:
		[route]:
			sensitiveHeaders: # 對指定路由的敏感頭設定為空

public class ZuulServletFilter implements Filter {
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
		try {
			init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
			try {
				preRouting();
			} catch (ZuulException e) {
				error(e);
				postRouting();
				return;
			}

			// Only forward onto to the chain if a zuul response is not being sent
			if (!RequestContext.getCurrentContext().sendZuulResponse()) {
				filterChain.doFilter(servletRequest, servletResponse);
				return;
			}

			try {
				routing();
			} catch (ZuulException e) {
				error(e);
				postRouting();
				return;
			}

			try {
				postRouting();
			} catch (ZuulException e) {
				error(e);
				return;
			}
		} catch (Throwable e) {
			error(new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_FROM_FILTER_" + e.getClass().getName()));
		} finally {
			RequestContext.getCurrentContext().unset();
		}
	}
}

zuul:
	FormBodyWrapperFilter:
		pre:
			disable: true

public class CustomerPreFilter extends ZuulFilter {
    @Override
    String filterType() {
        return "pre"; //定義filter的型別，有pre、route、post、error四種
    }

    @Override
    int filterOrder() {
        return 10; //定義filter的順序，數字越小表示順序越高，越先執行
    }

    @Override
    boolean shouldFilter() {
        return true; //表示是否需要執行該filter，true表示執行，false表示不執行
    }

    @Override
    Object run() {
        return null; //filter需要執行的具體操作
    }
}

<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>2.4.9</version>
</dependency>

FilterLoader.getInstance().setCompiler(new GroovyCompiler());
FilterFileManager.setFilenameFilter(new GroovyFileFilter());
FilterFileManager.init(internal, path);

public class FilterFileManager {
    public static void init(int pollingIntervalSeconds, String... directories) throws Exception, IllegalAccessException, InstantiationException {
        if (INSTANCE == null) INSTANCE = new FilterFileManager();
        INSTANCE.aDirectories = directories;
        INSTANCE.pollingIntervalSeconds = pollingIntervalSeconds;
        INSTANCE.manageFiles();
        INSTANCE.startPoller();
    }

    void startPoller() {
        poller = new Thread("GroovyFilterFileManagerPoller") {
            public void run() {
                while (bRunning) {
                    try {
                        sleep(pollingIntervalSeconds * 1000);
                        manageFiles();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        poller.setDaemon(true);
        poller.start();
    }
}

public class FilterLoader {
    public boolean putFilter(File file) throws Exception {
        String sName = file.getAbsolutePath() + file.getName();
        if (filterClassLastModified.get(sName) != null && (file.lastModified() != filterClassLastModified.get(sName))) {
            LOG.debug("reloading filter " + sName);
            filterRegistry.remove(sName);
        }
        ZuulFilter filter = filterRegistry.get(sName);
        if (filter == null) {
            Class clazz = COMPILER.compile(file);
            if (!Modifier.isAbstract(clazz.getModifiers())) {
                filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
                List<ZuulFilter> list = hashFiltersByType.get(filter.filterType());
                if (list != null) {
                    hashFiltersByType.remove(filter.filterType()); //rebuild this list
                }
                filterRegistry.put(file.getAbsolutePath() + file.getName(), filter);
                filterClassLastModified.put(sName, file.lastModified());
                return true;
            }
        }

        return false;
    }
}

class PreFilter extends ZuulFilter {
	@Override
	String filterType() {
		return "pre"
	}

	@Override
	int filterOrder() {
		return 1000
	}

	@Override
	boolean shouldFilter() {
		return true
	}

	@Override
	Object run() {
		return null
	}
}

class ErrorFilter extends ZuulFilter {
	@Override
	String filterType() {
		return FilterConstants.ERROR_TYPE
	}

	@Override
	int filterOrder() {
		return 10
	}

	@Override
	boolean shouldFilter() {
		return true
	}

	@Override
	Object run() {
		RequestContext context = getRequestContext()
		Throwable throwable = context.getThrowable()
		LOGGER.error("[ErrorFilter] error message: {}", throwable.getCause().getMessage())
		ctx.set("error.status_code", HttpServletResponse.SC_INTERNAL_SERVER_ERROR)
		ctx.set("error.exception", throwable.getCause())
		return null
	}
}

server:
	tomcat:
		max-threads: 128 # 最大worker執行緒
		min-spare-threads: 64 # 最小worker執行緒
	undertow:
		io-threads: 8 # IO執行緒數，預設為CPU核心數，最小為2
		worker-threads: 40 # 阻塞任務執行緒池，值設定取決於系統的負載，預設為io-threads * 8
		buffer-size: 512 # 每塊buffer的空間大小
		buffers-per-region: 10 # 每個區分配的buffer數量
		direct-buffers: 512 # 是否分配的直接記憶體