SpringCloud组件4值zuul网关

1. 在SpringCloud中有一个属于自己的网关，我们可以通过zuul网关作为我的权限控制中心，在zuul网关中配置拦截器进行拦截用户的请求，然后在进行分配指定的资源访问
2. 下面我们就进行一下对zuul网关的配置
3. 首先需要创建一个zuul网关服务项目，作为我们的zuul网关，对我们的请求进行拦截和权限认证分配
   
   这就是我们的zuul网关的服务目录
4. 然后我们需要添加一些zuul网关的依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zuul</artifactId>
            <version>1.3.5.RELEASE</version>
        </dependency>

我的SpringCloud版本是1.5.9的，如果需要使用更高版本的SpringCloud，这里的版本也可能需要改变
5. 接下来我们就对请进行书写yml文件了
这里需要两yml文件（也可以使用一个进行设置，将第二个yml文件的内容移入到第一个中即可），一个是对项目的基础进行配置的，另外一个是对zuul网关进行配置的

第一个yml文件（application.yml）

eureka:
  client:
    service-url:
      defaultZone: http://root:root@192.168.159.123:8081/eureka
  instance:
    lease-renewal-interval-in-seconds: 2
    lease-expiration-duration-in-seconds: 2
    instance-id: ${spring.cloud.client.ipAddress}:${server.port}
server:
  port: 8085
zuul:
  routes:           #springCloud-eureka-consumer为consumer的服务名，可配置多个
    dm-user-consumer: /user/**
    dm-item-consumer: /item/**
  strip-prefix: false
management:
  cloudfoundry:
    enabled: false
spring:
  redis:
    database: 0
    host: 192.168.159.123
    port: 6379
    user: root
    password: 123456
    jedis:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0
    timeout: 3000

这里对我们进行用户权限进行认证的时候需要使用的redis配置和我们的zuul网关的一些链接请求名字（对徐亚进行拦截的连接，比如，访问dm-user-consumer项目时，我们就对路径为/user/**的请求进行拦截）
第二个yml文件

spring:
  application:
    name: dm-zuul-server
  cloud:
    config:
      label: spring2.0_dev
      uri: http://localhost:7876/
      profile: dev

这里就配置了zuul网关的访问链接已经服务名称
7. 现在我们就需要进行书写我们的filter拦截器了
下面是本人写的一个案例，也有一些注解，可以当做参考

package com.kgc.filte;

import com.kgc.dto.Dto;
import com.kgc.dto.Token;
import com.kgc.service.TokenService;
import com.kgc.utils.RedisUtils;
import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class UserTestFilte extends ZuulFilter {
    @Resource
    private RedisUtils redisUtils;
    @Resource
    private TokenService tokenService;
    @Override
    /*过滤类型*/
    public String filterType() {
        return FilterConstants.PRE_TYPE;/*过滤前拦截*/
    }

    @Override
    /*过滤顺序*/
    public int filterOrder() {
        return 0;
    }

    @Override
    /*是否进行拦截*/
    public boolean shouldFilter() {
        return true;/*默认为false，true为拦截*/
    }

    @Override
    /*拦截后执行的方法*/
    public Object run() {
        /*生成返回数据对象*/
        Dto dto=new Dto();
        Token tokenDto=new Token();
        /*获取请求头信息*/
        RequestContext context = RequestContext.getCurrentContext();
        HttpServletRequest request = context.getRequest();
        String agent = request.getHeader("user-agent");
        String requestUrl = request.getRequestURI();
        /*判断请求是否要进行过滤*/
        if (requestUrl.split("/")[2].equals("p")) {
            //此接口不需要 token 验证，直接通行
            return "pass";
        }
        /*获取到token*/
        String token = request.getHeader("token");
        String redisToken = (String) redisUtils.get(token);
        /*判断token是否存在，存在进行判断token是否要进行替换*/
        if(redisToken!=null){/*token存在*/
            try {
                /*验证token并对其进行判断是否进行替换*/
                String replaceToken = tokenService.replaceToken(agent, token);
                /*设置返回数据*/
                dto.setMsg("token已经验证！");
                List list=new ArrayList();
                tokenDto.setToken(replaceToken);
                tokenDto.setExtTime(TokenService.SESSION_TIMEOUT);
                String[] tokenDetials = replaceToken.split("-");//拆分token为tokenDetials数组
                SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");//获取当前时间
                Date tokenGenTime = format.parse(tokenDetials[2]);//获取token中的token生成的时间
                long passed = tokenGenTime.getTime();
                tokenDto.setGenTime(passed);
                list.add(tokenDto);
                dto.setData(list);
                return dto;
            } catch (Exception e) {
                e.printStackTrace();
            }
                return "pass";
        }else{/*token不存在*/
            /*设置返回结果*/
            context.setSendZuulResponse(false);
            context.setResponseStatusCode(401);
            /*设置返回给用户页面的数据*/
            context.setResponseBody("token is not 401！");
            return "token is not 401！";
        }
    }
}

在写filter的时候，我们必须继承ZuulFilter类，并且实现其方法才能进行数据的拦截
9. 最后，我们就需要去我们的启动类中添加一些注解，进行开起我们的zuul网关，并使用我们的filter拦截器了

package com.kgc;

import com.kgc.filte.UserTestFilte;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
@EnableZuulProxy    /*开启网关的注解*/
public class DmZuulServerApplication {
    @Bean   /*使用过滤器的必须方法，固定写法*/
    public UserTestFilte userTestFilte(){
        return new UserTestFilte();
    }
    public static void main(String[] args) {
        SpringApplication.run(DmZuulServerApplication.class, args);
    }

}

zuul网关的使用就已经说明完了，要是有不对的地方，欢迎各位大牛指正！