springcloud-api-gateway 权限过滤应用案例

原创已于 2022-04-04 19:09:38 修改 · 810 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#过滤器 #网关 #shiro

于 2021-05-13 09:37:14 首次发布

java 专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种基于Spring Cloud Gateway的权限过滤实现方案，通过自定义全局过滤器完成对请求的权限验证工作，并利用Feign客户端拦截器实现跨服务请求头的传递。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

权限过滤器类：

AuthorizationFilter.java

package cn.getech.api.gateway.filter;

import cn.getech.api.gateway.feign.SystemUserFeignApi;
import cn.getech.api.gateway.service.AuthService;
import cn.getech.api.gateway.threadlocal.RequestHeaderThreadLocal;
import cn.getech.data.intelligence.common.utils.R;
import cn.getech.system.center.constant.ApiConstant;
import cn.getech.system.center.entity.SysUserEntity;
import cn.getech.system.center.entity.SysUserTokenEntity;
import cn.hutool.core.util.StrUtil;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Objects;

/**
 * @ClassName AuthorizeFilter
 * @Description TODO
 * @Author Getech
 * @Date 2020/12/22 16:46
 */
@Component
@Slf4j
public class AuthorizationFilter implements GlobalFilter, Ordered {



    @Autowired
    private AuthService authService;



    /**
     * 过滤器
     *
     * @param exchange  链路处理
     * @param chain 拦截或放行
     * @return 鉴权结果
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token=null;
        //获取请求
        ServerHttpRequest serverHttpRequest = exchange.getRequest();
        //把请求设置到本地线程中
        RequestHeaderThreadLocal.set(serverHttpRequest);
        String url = exchange.getRequest().getURI().getPath();
        //去除掉上下文，然后对url进行白名单验证
        ServerHttpResponse resp = exchange.getResponse();
        int fromIndex=url.indexOf("/",1);
        String afterUrl=null;
        if(fromIndex!=-1){
             afterUrl= url.substring(fromIndex);
        }else{
             afterUrl=url;
        }
        log.info("当前请求url={},截取上下文后的url={}",url,afterUrl);
        //跳过不需要验证的路径，该路径写在了配置文件中
        boolean skipAuthFlag=authService.skipAuth(afterUrl);
        if (skipAuthFlag) {
            RequestHeaderThreadLocal.remove();
            return chain.filter(exchange);
        }
        //获取请求token
        token= getRequestToken(exchange);
        if (StringUtils.isBlank(token)) {
            RequestHeaderThreadLocal.remove();
            //没有token
            return authErro(resp, "您没有无权限访问，token为空,请先登录");
        } else {
            //有token
            try {
                SysUserTokenEntity sysUserTokenEntity = this.authService.checkToken(token);
                if (sysUserTokenEntity!=null) {
                    //验证token成功
                    SysUserEntity sysUserEntity= authService.getUserById(sysUserTokenEntity.getUserId());
                    if(sysUserEntity==null){
                        RequestHeaderThreadLocal.remove();
                        return authErro(resp, "用户不存在，请重新登录");
                    }else{
                        //把请求设置到本地线程中
                        RequestHeaderThreadLocal.remove();
                        return chain.filter(exchange);
                    }
                } else {
                    RequestHeaderThreadLocal.remove();
                    return authErro(resp, "您的认证权限已过期，请重新进行认证");
                }
            } catch (Exception e) {
                log.error("校验权限失败：token="+token, e);
                RequestHeaderThreadLocal.remove();
                return authErro(resp, e.getMessage());

            }

        }

    }

    /**
     * 获取请求的token
     */
    private String getRequestToken(ServerWebExchange exchange){
        String newToken=null;
        String token=null;
        try{
            String requestToken=exchange.getRequest().getHeaders().getFirst("token");
            token = requestToken==null?"":requestToken.trim();
            if(StringUtils.isBlank(token)){
                requestToken= exchange.getRequest().getQueryParams().getFirst("token");
                token = requestToken==null?"":requestToken.trim();
            }
            if(StringUtils.isNotBlank(token)) {
                //包含bearer则直接返回
                if (token.contains(ApiConstant.BEARER_HEADER)){
                    newToken=token;
                }else{
                    //否则拼接bearer
                    newToken= ApiConstant.BEARER_HEADER +" "+token;
                }

            }
        }catch (Exception e){
            log.error("获取token异常",e);
        }
        log.info("token={},newToken={}",token,newToken);
        return newToken;
    }

    /**
     * 认证错误输出
     *
     * @param resp 响应对象
     * @param msg 错误信息
     * @return 错误结果
     */
    private Mono<Void> authErro(ServerHttpResponse resp, String msg) {
        Gson gson=new Gson();
        resp.setStatusCode(HttpStatus.UNAUTHORIZED);
        resp.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        R r=R.error(msg);
        String returnStr = "";
        try {
            returnStr = gson.toJson(r);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        DataBuffer buffer = resp.bufferFactory().wrap(returnStr.getBytes(StandardCharsets.UTF_8));
        //把请求到从本地线程中移除
         RequestHeaderThreadLocal.remove();
        return resp.writeWith(Flux.just(buffer));
    }





    @Override
    public int getOrder() {
        return -1;
    }
}

AuthServiceImpl.java

package cn.getech.api.gateway.service.impl;

import cn.getech.api.gateway.feign.SystemUserFeignApi;
import cn.getech.api.gateway.model.dto.ApiGatewayConfig;
import cn.getech.api.gateway.service.AuthService;
import cn.getech.api.gateway.service.PathMatchService;
import cn.getech.system.center.api.SystemUserApi;
import cn.getech.system.center.entity.SysUserEntity;
import cn.getech.system.center.entity.SysUserTokenEntity;
import cn.hutool.core.collection.CollectionUtil;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.LockedAccountException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName AuthServiceImpl
 * @Description TODO
 * @Author Getech
 * @Date 2020/12/23 17:39
 */
@Service
public class AuthServiceImpl implements AuthService {

   @Autowired
   private SystemUserFeignApi systemUserFeignApi;

   @Autowired
   private PathMatchService pathMatchService;

   @Autowired
   private ApiGatewayConfig apiGatewayConfig;

   /**
   * @Description 检查用户token
   * @Author  chengweiping
   * @Date   2020/12/23 18:45
   */
    @Override
    public SysUserTokenEntity checkToken(String token) {
        SysUserTokenEntity sysUserTokenEntity=systemUserFeignApi.queryByToken(token);
        //token失效, 别处登入会更新用户id唯一关联的token造成当前token查询不到
        if(sysUserTokenEntity == null){
            throw new IncorrectCredentialsException("校验token失败,获取token为空");
        }
        if(sysUserTokenEntity.getExpireTime().getTime() < System.currentTimeMillis()){
            throw new IncorrectCredentialsException("登入超时，请重新登录");
        }
        return sysUserTokenEntity;
    }

    /**
    * @Description 获取用户数据
    * @Author  chengweiping
    * @Date   2020/12/23 18:45
    */
    @Override
    public SysUserEntity getUserById(Long  userId) {
        SysUserEntity  sysUserEntity=systemUserFeignApi.queryUserByUserId(userId);
        //账号锁定
        if(sysUserEntity.getStatus() == 0){
            throw new LockedAccountException("账号已被锁定,请联系管理员");
        }
        return sysUserEntity;
    }

    /**
    * @Description
    * @Author  chengweiping
    * @Date   2020/12/25 11:26
    */
    @Override
    public boolean skipAuth(String url){
       List<String> skipAuthUrls =apiGatewayConfig.getSkipUrls();
        boolean flag=false;
        if(CollectionUtil.isNotEmpty(skipAuthUrls)){
           for(String pattern:skipAuthUrls){
               flag = pathMatchService.pathMatches(pattern,url);
               if(flag==true){
                   break;
               }
           }
        }
       return flag;
    }
}

PathMatchServiceImpl.java

package cn.getech.api.gateway.service.impl;

import cn.getech.api.gateway.service.PathMatchService;
import org.apache.shiro.util.AntPathMatcher;
import org.apache.shiro.util.PatternMatcher;
import org.springframework.stereotype.Service;

/**
 * @ClassName PathMatchServiceImpl
 * @Description TODO
 * @Author Getech
 * @Date 2020/12/25 11:17
 */
@Service
public class PathMatchServiceImpl implements PathMatchService {

    private PatternMatcher pathMatcher;

    public PathMatchServiceImpl() {
        this.pathMatcher = new AntPathMatcher();
    }

    @Override
    public boolean pathMatches(String pattern, String path) {
        PatternMatcher pathMatcher = getPathMatcher();
        return pathMatcher.matches(pattern, path);
    }

    public PatternMatcher getPathMatcher() {
        return pathMatcher;
    }
}

RequestHeaderThreadLocal.java

package cn.getech.api.gateway.threadlocal;

import org.springframework.http.server.reactive.ServerHttpRequest;

import java.io.Serializable;

/**
 * @ClassName RequestHeaderThreadLocal
 * @Description TODO
 * @Author Getech
 * @Date 2020/12/23 16:04
 */
public class RequestHeaderThreadLocal {

    private static ThreadLocal<ServerHttpRequest> objectHolder = new ThreadLocal<ServerHttpRequest>();

    public static void set(ServerHttpRequest serverHttpRequest){
        objectHolder.set(serverHttpRequest);
    }

    public static void remove(){
        objectHolder.remove();
    }

    public static ServerHttpRequest get(){
        ServerHttpRequest serverHttpRequest=null;
       Object object= objectHolder.get();
       if(object!=null){
           serverHttpRequest=(ServerHttpRequest)object;
       }
       return serverHttpRequest;
    }

}

ApiFeignConfiguration.java

package cn.getech.api.gateway.config;

import cn.getech.api.gateway.threadlocal.RequestHeaderThreadLocal;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import java.util.Enumeration;

/**
 * @ClassName ApiFeignConfiguration
 * @Description TODO
 * @Author Getech
 * @Date 2021/1/8 18:55
 */
@Configuration
@ConditionalOnBean(value =RequestInterceptor.class)
public class ApiFeignConfiguration implements RequestInterceptor {

    /**
     * @Description 将请求头中的参数，全部作为 feign 请求头参数传递
     * @Author  chengweiping
     * @Date   2020/12/23 15:30
     */
    @Override
    public void apply(RequestTemplate requestTemplate) {

            ServerHttpRequest serverHttpRequest=RequestHeaderThreadLocal.get();
            if(serverHttpRequest==null){
                return;
            }else{
                HttpHeaders httpHeaders= serverHttpRequest.getHeaders();
                httpHeaders.entrySet().stream().forEach(e->{
                    requestTemplate.header(e.getKey(),e.getValue());
                });
            }
        }
}

application.yml

# Tomcat
server:
  tomcat:
    uri-encoding: UTF-8
    max-threads: 1000
    min-spare-threads: 30
  port: 9090
  servlet:
    context-path: /

logging:
  file: api-gateway.log

# 请求feign连接的超时时间 默认的时间为 1 秒, 设置超时时间为70分钟
ribbon:
  ConnectTimeout: 25200000
  # 请求处理的超时时间
  ReadTimeout: 25200000

spring:
  application:
    name: api-gateway
  main:
    allow-bean-definition-overriding: true
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true #让gateway从nacos中获取服务信息
          lowerCaseServiceId: true # 请求服务是小写的时候改成true（默认为false轻微服务必须是大写）
      routes:  #路由数组
        - id: data-manager-web  #  data-manager服务路由
          uri: lb://data-manager-web #转发到的服务 指的是负载均衡 后面是nacos的服务名
          order: 1 #路由优先级  数字越小越大
          predicates:  #断言数组（条件判断，返回值boolean ，转发请求满足条件的）
            - Path=/data-manager/**
            # filters: #过滤器 数组 （在请求传递过程中，对请求做修改）此属性注释不需要
            #  - StripPrefix=1 #在请求转发之前去掉 gateway的一层路径  此属性注释不需要
        - id: system-center-web #  system-center服务路由
          uri: lb://system-center-web
          order: 1
          predicates:
            - Path=/system-center/**
        - id: data-development-web-websocket #  data-development-websocket服务路由
          uri: lb:ws://data-development-web
          order: 1
          predicates:
            - Path=/data-development/ws/**
        - id: data-development-web #  data-development服务路由
          uri: lb://data-development-web
          order: 2
          predicates:
            - Path=/data-development/**
        - id: data-service-web #  data-service服务路由
          uri: lb://data-service-web
          order: 1
          predicates:
            - Path=/data-service/**
        - id: data-service-job-web #   data-service-job服务路由
          uri: lb://data-service-job-web
          order: 1
          predicates:
            - Path=//service-center/**
        - id: job-center-web #  job-center服务路由
          uri: lb://data-service-job
          order: 1
          predicates:
            - Path=/job-center/**
        - id: data-dim-web #   data-dim服务路由
          uri: lb://data-dim-web
          order: 1
          predicates:
            - Path=/data-dim/**
        - id: data-metadata-web #   data-metadata服务路由
          uri: lb://data-metadata-web
          order: 1
          predicates:
            - Path=/data-metadata/**
        - id: data-job-web #   data-job服务路由
          uri: lb://data-job-web
          order: 1
          predicates:
            - Path=/data-job/**
        #将gateway 注册到nacos
  # 环境 dev|prod|csotNew|csotOld
  profiles:
    active: dev
  # jackson时间格式化
  jackson:
    time-zone: GMT+8
    date-format: yyyy-MM-dd HH:mm:ss
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
      enabled: true
  mvc:
    throw-exception-if-no-handler-found: true
#  resources:
#    add-mappings: false


#mybatis
mybatis-plus:
  mapper-locations: classpath*:/mapper/*.xml
  #实体扫描，多个package用逗号或者分号分隔
  typeAliasesPackage: cn.getech.aip.gateway.entity
  global-config:
    #数据库相关配置
    db-config:
      #主键类型  AUTO:"数据库ID自增", INPUT:"用户输入ID", ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
      id-type: AUTO
      #字段策略 IGNORED:"忽略判断",NOT_NULL:"非 NULL 判断"),NOT_EMPTY:"非空判断"
      field-strategy: NOT_NULL
      #驼峰下划线转换
      column-underline: true
      logic-delete-value: -1
      logic-not-delete-value: 0
    banner: false
  #原生配置
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
    call-setters-on-nulls: true
    jdbc-type-for-null: 'null'


feign:
  # 为feign整合sentinel
  sentinel:
    enabled: true

# 暴露所有端点
management:
  endpoints:
    web:
      exposure:
        include: "*"

# 网关相关属性配置
api:
  gateway:
    # 权限验证白名单设置
    skipUrls[0]: /sys/login
    skipUrls[1]: /api/**
    skipUrls[2]: /bdp/dataStandardFile/preview
    skipUrls[3]: /doc.html
    skipUrls[4]: /webjars/**
    skipUrls[5]: /app/**
    skipUrls[6]: /swagger/**
    skipUrls[7]: /v2/api-docs
    skipUrls[8]: /swagger-ui.html
    skipUrls[9]: /swagger-resources/**
    skipUrls[10]: /captcha.jpg
    skipUrls[11]: /bdp/rest/**
    skipUrls[12]: /vm/**
    skipUrls[13]: /report/**
    skipUrls[14]: /bdp/ranger/**
    skipUrls[15]: /bdp/procInfo/deleteProcByUserId/**
    skipUrls[16]: /bdp/tableInfo/cheackTableByUserId/**
    skipUrls[17]: /sys/user/init
    skipUrls[18]: /service/center/call
    skipUrls[19]: /development/realtimeresource/download
    skipUrls[20]: /bdp/workMenu/runSysparams
    skipUrls[21]: /bdp/tableInfo/cheackTableByUserId/**
    skipUrls[22]: /dataAssetsModelList/getModelDetailToBigData/*
    skipUrls[23]: /dataAssetsModelList/saveModelAssessment
    skipUrls[24]: /dataAssetsModelList/getModelDetailToBigData/*
    skipUrls[25]: /dataAssetsModelList/saveModelAssessment
    skipUrls[26]: /report/dataApplicationDetial/changeProgress
    skipUrls[27]: /sys/user/initRole
    skipUrls[28]: /report/dataApplicationDetial/deleteApplicationFromMfa
    skipUrls[29]: /vm/csotModelInfo/save
    skipUrls[30]: /vm/csotSiteInfo/listAllSite
    skipUrls[31]: /vm/csotModelAutoUpdate/syncBack/saveAutoUpdate
    skipUrls[32]: /vm/csotModelInfo/downAndUpAll
    skipUrls[33]: /sync/role
    skipUrls[34]: /sync/org
    skipUrls[35]: /sys/loginUrl
    skipUrls[36]: /sys/index
    skipUrls[37]: /sys/callback
    skipUrls[38]: /sys/oauth/login
    skipUrls[39]: /bdp/tableInfo/hive/warehouse
    skipUrls[40]: /ws/**

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>platform</artifactId>
        <groupId>cn.getech.data.intelligence</groupId>
        <version>micro-ims-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>api-gateway</artifactId>
    <groupId>cn.getech.api.gateway</groupId>



    <distributionManagement>

        <snapshotRepository>
            <id>snapshots</id>
            <name>snapshots repo</name>
            <url>http://10.74.20.125:8081/repository/maven-snapshots/</url>
        </snapshotRepository>

        <repository>
            <id>releases</id>
            <name>releases repo</name>
            <url>http://10.74.20.125:8081/repository/maven-releases/</url>
        </repository>


    </distributionManagement>
    <repositories>

        <repository>
            <id>snapshots</id>
            <url>http://10.74.20.125:8081/repository/maven-snapshots/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>

        <repository>
            <id>releases</id>
            <url>http://10.74.20.125:8081/repository/maven-releases/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>

        </repository>
        <repository>
            <id>central</id>
            <url>http://10.74.20.125:8081/repository/maven-public/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>http://10.74.20.125:8081/repository/cloudera/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>

    </repositories>


    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--   sentinel  -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- gateway -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!-- nacos-discovery -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!-- openfeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <!--  system-center-api 依赖 -->
        <dependency>
            <groupId>cn.getech.data.intelligence</groupId>
            <artifactId>system-center-api</artifactId>
            <version>micro-ims-SNAPSHOT</version>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-web</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>




        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.4</version>
        </dependency>

        <!-- ribbo -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>







        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>

        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

common.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <artifactId>platform</artifactId>
        <groupId>cn.getech.data.intelligence</groupId>
        <version>micro-ims-SNAPSHOT</version>
    </parent>
    <packaging>jar</packaging>

    <groupId>cn.getech.data.intelligence</groupId>
    <artifactId>data-intelligence-common</artifactId>
    <version>micro-ims-SNAPSHOT</version>


    <distributionManagement>

        <snapshotRepository>
            <id>snapshots</id>
            <name>snapshots repo</name>
            <url>http://10.74.20.125:8081/repository/maven-snapshots/</url>
        </snapshotRepository>

        <repository>
            <id>releases</id>
            <name>releases repo</name>
            <url>http://10.74.20.125:8081/repository/maven-releases/</url>
        </repository>


    </distributionManagement>
    <repositories>

        <repository>
            <id>snapshots</id>
            <url>http://10.74.20.125:8081/repository/maven-snapshots/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>

        <repository>
            <id>releases</id>
            <url>http://10.74.20.125:8081/repository/maven-releases/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>

        </repository>
        <repository>
            <id>central</id>
            <url>http://10.74.20.125:8081/repository/maven-public/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>http://10.74.20.125:8081/repository/cloudera/</url>
            <releases>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>true</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </releases>
            <snapshots>
                <!--true或者false表示该仓库是否为下载某种类型构件（发布版，快照版）开启。  -->
                <enabled>false</enabled>
                <!--该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是：always（一直），daily（默认，每日），interval：X（这里X是以分钟为单位的时间间隔），或者never（从不）。 -->
                <updatePolicy>always</updatePolicy>
                <!--当Maven验证构件校验文件失败时该怎么做-ignore（忽略），fail（失败），或者warn（警告）。-->
                <checksumPolicy>warn</checksumPolicy>
            </snapshots>
        </repository>

    </repositories>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- openfeign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
        </dependency>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--PMML start -->
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-evaluator-extension</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jpmml</groupId>
            <artifactId>pmml-model</artifactId>
        </dependency>
        <!--PMML end -->

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
        </dependency>
        <dependency>
            <groupId>com.monitorjbl</groupId>
            <artifactId>xlsx-streamer</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <!--<plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    &lt;!&ndash; execution元素包含了插件执行需要的信息 &ndash;&gt;
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>-->
        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>