'commit'

dsBase/src/main/java/com/dsideal/dsBase/Index/Controller/IndexController.java

@@ -8,6 +8,6 @@ import com.jfinal.kit.PropKit;
 public class IndexController extends Controller {
     @Before({GET.class})
     public void index() {
-        renderText("Welcome to dsBase World!");
+        renderText("Welcome to The dsBase World  (^_^)");
     }
 }

dsGw/src/main/java/com/dsideal/gw/Config/GatewayConfig.java

@@ -0,0 +1,21 @@
+package com.dsideal.gw.Config;
+
+import com.jfinal.kit.Prop;
+import com.jfinal.kit.PropKit;
+
+public class GatewayConfig {
+    private static final Prop prop = PropKit.use("gateway-config.txt");
+
+    // 超时配置
+    public static final int CONNECT_TIMEOUT = prop.getInt("gateway.timeout.connect", 10000);
+    public static final int READ_TIMEOUT = prop.getInt("gateway.timeout.read", 30000);
+    public static final int WRITE_TIMEOUT = prop.getInt("gateway.timeout.write", 30000);
+
+    // 连接池配置
+    public static final int MAX_CONNECTIONS = prop.getInt("gateway.connection.max", 5);
+    public static final int KEEP_ALIVE_DURATION = prop.getInt("gateway.connection.keep-alive", 300);
+
+    // 安全配置
+    public static final String[] ALLOWED_ORIGINS = prop.get("gateway.security.cors.allowed-origins", "*").split(",");
+    public static final String[] ALLOWED_METHODS = prop.get("gateway.security.cors.allowed-methods", "GET,POST").split(",");
+}

dsGw/src/main/java/com/dsideal/gw/Handler/RouterHandler.java

@@ -3,6 +3,7 @@ package com.dsideal.gw.Handler;
 import com.dsideal.gw.Bean.RetBean;
 import com.dsideal.gw.GwApplication;
 import com.dsideal.gw.Util.JwtUtil;
+import com.dsideal.gw.Config.GatewayConfig;
 import com.jfinal.handler.Handler;
 import com.jfinal.kit.StrKit;
 import com.jfinal.upload.MultipartRequest;
@@ -11,61 +12,233 @@ import com.jfinal.plugin.activerecord.Record;
 import io.jsonwebtoken.Claims;
 import okhttp3.*;
 import org.apache.commons.io.IOUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 import java.io.*;
 import java.util.*;
-
-/**
- * 测试用例：
- * GET
- * http://10.10.21.20:8000/dsBase/dm/getDmSchoolProperty
- * http://10.10.21.20:8000/dsBase/global/getGlobalList?page=1&limit=10
- * POST
- * http://10.10.21.20:8000/dsBase/global/testPost?a=100
- * 上传文件
- * http://10.10.21.20:8000/dsBase/global/testUpload
- * form-data
- * upfile --->参数值：选择一个文件 类型：file
- */
+import java.util.concurrent.TimeUnit;
 
 public class RouterHandler extends Handler {
-    //OkHttp的实例，单例模式
-    private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient();
-
-    /**
-     * 功能：输出JSON文本串
-     *
-     * @param res
-     */
-    public void renderJson(HttpServletResponse res, String body) {
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Cache-Control", "no-cache");
-        res.setCharacterEncoding("UTF-8");
-        res.setContentType("application/json");
+    private static final Logger logger = LoggerFactory.getLogger(RouterHandler.class);
+
+    // 常量定义
+    private static final class Constants {
+        static final String CONTENT_TYPE_JSON = "application/json";
+        static final String CONTENT_TYPE_MULTIPART = "multipart/form-data";
+        static final String HEADER_AUTHORIZATION = "Authorization";
+        static final String HEADER_COOKIE = "Cookie";
+        static final String HEADER_ACCEPT = "Accept";
+        static final String HEADER_CONTENT_TYPE = "Content-Type";
+    }
+
+    // 静态资源扩展名
+    private static final Set<String> STATIC_EXTENSIONS = new HashSet<>(Arrays.asList(
+            "html", "js", "css", "png", "jpg", "jpeg", "gif", "ico", "svg",
+            "woff", "woff2", "ttf", "eot", "map", "json", "xml", "txt"
+    ));
+
+    // OkHttp客户端配置
+    private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient.Builder()
+            .connectTimeout(GatewayConfig.CONNECT_TIMEOUT, TimeUnit.MILLISECONDS)
+            .readTimeout(GatewayConfig.READ_TIMEOUT, TimeUnit.MILLISECONDS)
+            .writeTimeout(GatewayConfig.WRITE_TIMEOUT, TimeUnit.MILLISECONDS)
+            .connectionPool(new ConnectionPool(GatewayConfig.MAX_CONNECTIONS,
+                    GatewayConfig.KEEP_ALIVE_DURATION,
+                    TimeUnit.SECONDS))
+            .build();
+
+    @Override
+    public void handle(String target, HttpServletRequest req, HttpServletResponse res, boolean[] isHandled) {
         try {
-            res.getWriter().println(body);
-            res.getWriter().flush();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
+            String servletPath = req.getServletPath();
+            String queryString = req.getQueryString();
+
+            // 处理静态资源
+            if (isStaticResource(servletPath)) {
+                next.handle(target, req, res, isHandled);
+                return;
+            }
+
+            // 处理内部调用
+            if (isInternalCall(servletPath, res, isHandled)) {
+                return;
+            }
+
+            // 处理认证
+            if (!isAuthenticated(req, res, isHandled)) {
+                return;
+            }
+
+            // 获取转发URL
+            String forwardUrl = getForwardUrl(servletPath);
+            if (forwardUrl == null) {
+                handleError(res, isHandled, "无效的请求路径", null);
+                return;
+            }
+
+            // 记录请求日志
+            logRequest(req, forwardUrl);
+
+            // 根据请求方法处理
+            switch (req.getMethod()) {
+                case "GET":
+                    handleGetRequest(req, res, isHandled, forwardUrl, queryString);
+                    break;
+                case "POST":
+                    if (isMultipartRequest(req)) {
+                        handleFileUpload(req, res, isHandled, forwardUrl);
+                    } else {
+                        handlePostRequest(req, res, isHandled, forwardUrl, queryString);
+                    }
+                    break;
+                default:
+                    handleError(res, isHandled, "不支持的请求方法: " + req.getMethod(), null);
+            }
+        } catch (Exception e) {
+            logger.error("请求处理异常", e);
+            handleError(res, isHandled, "系统异常", e);
+        }
+    }
+
+    // 处理GET请求
+    private void handleGetRequest(HttpServletRequest req, HttpServletResponse res,
+                                  boolean[] isHandled, String forwardUrl, String queryString) {
+        try {
+            Request request = buildGetRequest(req, forwardUrl, queryString);
+            executeRequest(request, res);
+            isHandled[0] = true;
+        } catch (Exception e) {
+            handleError(res, isHandled, "GET请求处理失败", e);
+        }
+    }
+
+    // 处理POST请求
+    private void handlePostRequest(HttpServletRequest req, HttpServletResponse res,
+                                   boolean[] isHandled, String forwardUrl, String queryString) {
+        try {
+            Request request = buildPostRequest(req, forwardUrl, queryString);
+            executeRequest(request, res);
+            isHandled[0] = true;
+        } catch (Exception e) {
+            handleError(res, isHandled, "POST请求处理失败", e);
+        }
+    }
+
+    // 处理文件上传
+    private void handleFileUpload(HttpServletRequest req, HttpServletResponse res,
+                                  boolean[] isHandled, String forwardUrl) {
+        try {
+            MultipartRequest mp = new MultipartRequest(req);
+            List<UploadFile> files = mp.getFiles();
+
+            if (files.isEmpty()) {
+                handleError(res, isHandled, "没有上传文件", null);
+                return;
+            }
+
+            Request request = buildFileUploadRequest(files.getFirst(), forwardUrl);
+            executeRequest(request, res);
+            isHandled[0] = true;
+        } catch (Exception e) {
+            handleError(res, isHandled, "文件上传失败", e);
+        }
+    }
+
+    // 构建GET请求
+    private Request buildGetRequest(HttpServletRequest req, String forwardUrl, String queryString) {
+        Request.Builder builder = new Request.Builder()
+                .url(buildUrl(forwardUrl, queryString));
+        addCommonHeaders(req, builder);
+        return builder.build();
+    }
+
+    // 构建POST请求
+    private Request buildPostRequest(HttpServletRequest req, String forwardUrl, String queryString) {
+        Request.Builder builder = new Request.Builder()
+                .url(buildUrl(forwardUrl, queryString));
+        addCommonHeaders(req, builder);
+        return builder.post(createRequestBody(req)).build();
+    }
+
+    // 构建文件上传请求
+    private Request buildFileUploadRequest(UploadFile uploadFile, String forwardUrl) {
+        MediaType mediaType = MediaType.parse(Constants.CONTENT_TYPE_MULTIPART);
+        RequestBody requestBody = RequestBody.create(uploadFile.getFile(), mediaType);
+
+        MultipartBody body = new MultipartBody.Builder()
+                .setType(MultipartBody.FORM)
+                .addFormDataPart("file", uploadFile.getFileName(), requestBody)
+                .build();
+
+        return new Request.Builder()
+                .url(forwardUrl)
+                .post(body)
+                .build();
+    }
+
+    // 添加通用头信息
+    private void addCommonHeaders(HttpServletRequest req, Request.Builder builder) {
+        // 处理Authorization头
+        String authHeader = req.getHeader(Constants.HEADER_AUTHORIZATION);
+        if (!StrKit.isBlank(authHeader)) {
+            builder.addHeader(Constants.HEADER_AUTHORIZATION, authHeader);
+            builder.addHeader(Constants.HEADER_ACCEPT, "application/json;odata=verbose");
         }
+
+        // 处理Cookie
+        String cookie = req.getHeader(Constants.HEADER_COOKIE);
+        if (!StrKit.isBlank(cookie)) {
+            builder.addHeader(Constants.HEADER_COOKIE, cookie);
+        }
+
+        // 添加其他重要头信息
+        addImportantHeaders(req, builder);
     }
 
-    //OkHttp的回调函数，同步执行
+    // 添加重要头信息
+    private void addImportantHeaders(HttpServletRequest req, Request.Builder builder) {
+        String[] importantHeaders = {
+                Constants.HEADER_ACCEPT,
+                Constants.HEADER_CONTENT_TYPE,
+                "User-Agent",
+                "Referer",
+                "Origin",
+                "Host"
+        };
+
+        for (String header : importantHeaders) {
+            String value = req.getHeader(header);
+            if (!StrKit.isBlank(value)) {
+                builder.addHeader(header, value);
+            }
+        }
+    }
+
+    // 创建请求体
+    private RequestBody createRequestBody(HttpServletRequest req) {
+        FormBody.Builder formBodyBuilder = new FormBody.Builder();
+        Enumeration<String> parameterNames = req.getParameterNames();
+        while (parameterNames.hasMoreElements()) {
+            String paramName = parameterNames.nextElement();
+            String paramValue = req.getParameter(paramName);
+            formBodyBuilder.add(paramName, paramValue);
+        }
+        return formBodyBuilder.build();
+    }
+
+    // 执行请求
     private void executeRequest(Request request, HttpServletResponse res) throws IOException {
         Response response = OK_HTTP_CLIENT.newCall(request).execute();
         if (response.isSuccessful()) {
             ResponseBody body = response.body();
             if (body != null) {
-                // 获取Content-Type
-                String contentType = response.header("Content-Type");
-
+                String contentType = response.header(Constants.HEADER_CONTENT_TYPE);
                 if (contentType != null && contentType.startsWith("image/")) {
-                    // 处理图片响应
                     handleImageResponse(res, body, contentType);
                 } else {
-                    // 处理文本响应
                     handleTextResponse(res, body);
                 }
             } else {
@@ -78,13 +251,11 @@ public class RouterHandler extends Handler {
 
     // 处理图片响应
     private void handleImageResponse(HttpServletResponse res, ResponseBody body, String contentType) throws IOException {
-        // 设置响应头
         res.setContentType(contentType);
         res.setHeader("Cache-Control", "no-store");
         res.setHeader("Pragma", "no-cache");
         res.setDateHeader("Expires", 0);
 
-        // 将图片数据写入响应
         try (InputStream inputStream = body.byteStream()) {
             IOUtils.copy(inputStream, res.getOutputStream());
         }
@@ -96,214 +267,114 @@ public class RouterHandler extends Handler {
         renderJson(res, responseBody);
     }
 
-    public static RequestBody createRequestBody(HttpServletRequest req) {
-        FormBody.Builder formBodyBuilder = new FormBody.Builder();
-        // 遍历请求中的参数
-        Enumeration<String> parameterNames = req.getParameterNames();
-        while (parameterNames.hasMoreElements()) {
-            String paramName = parameterNames.nextElement();
-            String paramValue = req.getParameter(paramName);
-            formBodyBuilder.add(paramName, paramValue);
+    // 渲染JSON响应
+    private void renderJson(HttpServletResponse res, String body) {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setCharacterEncoding("UTF-8");
+        res.setContentType(Constants.CONTENT_TYPE_JSON);
+        try {
+            res.getWriter().println(body);
+            res.getWriter().flush();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
         }
-        // 构建RequestBody
-        return formBodyBuilder.build();
     }
 
-
-    // 使用Set集合（推荐，性能更好）
-    private static final Set<String> STATIC_EXTENSIONS = new HashSet<>(Arrays.asList(
-            "html", "js", "css", "png", "jpg", "jpeg", "gif", "ico", "svg",
-            "woff", "woff2", "ttf", "eot", "map", "json", "xml", "txt"
-    ));
-
-
-    // 判断是否为静态资源的方法
-    private boolean isStaticResource(String servletPath) {
-        int lastDotIndex = servletPath.lastIndexOf('.');
-        if (lastDotIndex == -1) {
-            return false;
-        }
-        String extension = servletPath.substring(lastDotIndex + 1).toLowerCase();
-        return STATIC_EXTENSIONS.contains(extension);
+    // 处理错误
+    private void handleError(HttpServletResponse res, boolean[] isHandled, String message, Exception e) {
+        String errorMessage = e != null ? message + ": " + e.getMessage() : message;
+        renderJson(res, new RetBean(RetBean.ERROR, errorMessage).toString());
+        isHandled[0] = true;
     }
 
-    @Override
-    public void handle(String target, HttpServletRequest req, HttpServletResponse res, boolean[] isHandled) {
-        //可以正确获取到URL的完整路径
+    // 检查认证
+    private boolean isAuthenticated(HttpServletRequest req, HttpServletResponse res, boolean[] isHandled) {
         String servletPath = req.getServletPath();
-        String queryString = req.getQueryString();
-        //对于根目录的访问，放行
-        if (servletPath.equals("/") || isStaticResource(servletPath)) {
-            next.handle(target, req, res, isHandled);
-            return;
+        if (GwApplication.whiteSet.contains(servletPath)) {
+            return true;
         }
-        //微服务间的调用视为内部调用
-        if (req.getServletPath().endsWith("_Internal")) {
-            renderJson(res, new RetBean(RetBean.ERROR, "微服务间内部接口调用，是不需要走网关的！").toString());
-            isHandled[0] = true; //停止filter
-            return;
+
+        // 检查Session
+        Record rPerson = JwtUtil.getPersonInfo(req);
+        if (isValidPersonInfo(rPerson)) {
+            return true;
         }
 
-        //如果是白名单，不检查jwt,否则需要检查jwt
-        if (!GwApplication.whiteSet.contains(servletPath)) {
-            //是不是通过了登录检查？
-            boolean canPass = true;
-            //1、存在Session,检查是不是正确的Session
-            Record rPerson= JwtUtil.getPersonInfo(req);
-            String identity_id = rPerson.getStr("identity_id");
-            String person_id = rPerson.getStr("person_id");
-            String bureau_id = rPerson.getStr("bureau_id");
-
-            //如果没有找到Session，那么直接不通过
-            if (StrKit.isBlank(bureau_id) || StrKit.isBlank(identity_id) || StrKit.isBlank(person_id)) {
-                canPass = false;
-            }
-
-            if (!canPass) {
-                //如果不存在Session,那么检查是不是存在JWT,并且JWT是不是正确的
-                if (req.getHeader("Authorization") != null) {
-                    String jwtToken = req.getHeader("Authorization");
-                    Claims claims = JwtUtil.getClaims(jwtToken);
-                    if (claims != null) {
-                        canPass = true;
-                    }
-                }
-            }
-            if (!canPass) {
-                renderJson(res, new RetBean(RetBean.ERROR, "登录已过期，请重新登录！").toString());
-                isHandled[0] = true; //停止filter
-                return;
+        // 检查JWT
+        String jwtToken = req.getHeader(Constants.HEADER_AUTHORIZATION);
+        if (!StrKit.isBlank(jwtToken)) {
+            Claims claims = JwtUtil.getClaims(jwtToken);
+            if (claims != null) {
+                return true;
             }
         }
-        //路由到哪个微服务
-        int xie1 = servletPath.indexOf('/'); // 找到第一个 '/' 的索引
-        int xie2 = servletPath.indexOf('/', xie1 + 1); // 从第一个 '/' 之后开始找第二个 '/' 的索引
 
-        //action名称
-        String action = servletPath.substring(xie2 + 1);
+        handleError(res, isHandled, "登录已过期，请重新登录！", null);
+        return false;
+    }
+
+    // 验证人员信息
+    private boolean isValidPersonInfo(Record rPerson) {
+        return rPerson != null &&
+                !StrKit.isBlank(rPerson.getStr("bureau_id")) &&
+                !StrKit.isBlank(rPerson.getStr("identity_id")) &&
+                !StrKit.isBlank(rPerson.getStr("person_id"));
+    }
+
+    // 获取转发URL
+    private String getForwardUrl(String servletPath) {
+        int xie1 = servletPath.indexOf('/');
+        int xie2 = servletPath.indexOf('/', xie1 + 1);
         if (xie1 == -1 || xie2 == -1) {
-            renderJson(res, new RetBean(RetBean.ERROR, "输入的字符串格式不正确，没有找到两个 '/'。").toString());
-            isHandled[0] = true; //停止filter
-            return;
+            return null;
         }
 
-        String prefix = servletPath.substring(xie1 + 1, xie2); // 截取两个 '/' 之间的内容
+        String prefix = servletPath.substring(xie1 + 1, xie2);
+        String action = servletPath.substring(xie2 + 1);
+
         if (!GwApplication.routeList.containsKey(prefix)) {
-            renderJson(res, new RetBean(RetBean.ERROR, prefix + "前缀没有找到合适的路由表，请检查是否请求正确！").toString());
-            isHandled[0] = true; //停止filter
-            return;
+            return null;
         }
 
-        //路由到哪个微服务
-        String FORWARD_URL = GwApplication.routeList.get(prefix) + "/" + prefix + "/" + action;
+        return GwApplication.routeList.get(prefix) + "/" + prefix + "/" + action;
+    }
 
-        //1、如果是上传文件
-        if (req.getMethod().equals("POST") && req.getContentType() != null && req.getContentType().startsWith("multipart/form-data")) {
-            // 指定文件类型
-            MediaType mediaType = MediaType.parse("multipart/form-data");
-            MultipartRequest mp = new MultipartRequest(req);
-            List<UploadFile> files = mp.getFiles();
-            if (files.isEmpty()) {
-                renderJson(res, new RetBean(RetBean.ERROR, "没有上传文件！").toString());
-                isHandled[0] = true;//停止filter
-                return;
-            }
-            UploadFile uploadFile = files.getFirst();
-
-            // 获取文件流
-            RequestBody requestBody = RequestBody.create(uploadFile.getFile(), mediaType);
-            // 构建MultipartBody
-            MultipartBody body = new MultipartBody.Builder()
-                    .setType(MultipartBody.FORM)
-                    .addFormDataPart("file", uploadFile.getFileName(), requestBody)
-                    .build();
-            // 构建Request
-            Request request = new Request.Builder()
-                    .url(FORWARD_URL)
-                    .post(body)
-                    .build();
-            try {
-                executeRequest(request, res);
-                isHandled[0] = true;//停止filter
-                return;
-            } catch (Exception e) {
-                renderJson(res, new RetBean(RetBean.ERROR, "请求失败！" + e).toString());
-                isHandled[0] = true;//停止filter
-                return;
-            }
+    // 检查是否为静态资源
+    private boolean isStaticResource(String servletPath) {
+        if (servletPath.equals("/")) {
+            return true;
         }
-
-        //2、处理GET请求
-        if (req.getMethod().equals("GET")) {
-            //参数:queryString
-            Request.Builder builder;
-            if (queryString != null) {
-                builder = new Request.Builder().url(FORWARD_URL + "?" + queryString);
-            } else {
-                builder = new Request.Builder().url(FORWARD_URL);
-            }
-
-            // 处理Authorization头
-            if (!StrKit.isBlank(req.getHeader("Authorization"))) {
-                builder.addHeader("Authorization", req.getHeader("Authorization"));
-                builder.addHeader("Accept", "application/json;odata=verbose");
-            }
-
-            // 处理Cookie
-            String cookie = req.getHeader("Cookie");
-            if (!StrKit.isBlank(cookie)) {
-                builder.addHeader("Cookie", cookie);
-            }
-
-            Request request = builder.build();
-            try {
-                executeRequest(request, res);
-                isHandled[0] = true;//停止filter
-                return;
-            } catch (IOException e) {
-                renderJson(res, new RetBean(RetBean.ERROR, "请求失败！" + e).toString());
-                isHandled[0] = true;//停止filter
-                return;
-            }
+        int lastDotIndex = servletPath.lastIndexOf('.');
+        if (lastDotIndex == -1) {
+            return false;
         }
+        String extension = servletPath.substring(lastDotIndex + 1).toLowerCase();
+        return STATIC_EXTENSIONS.contains(extension);
+    }
 
-//3、处理POST请求
-        if (req.getMethod().equals("POST")) {
-            RequestBody body = createRequestBody(req);
-            Request.Builder builder;
-            if (queryString != null) {
-                builder = new Request.Builder().url(FORWARD_URL + "?" + queryString);
-            } else {
-                builder = new Request.Builder().url(FORWARD_URL);
-            }
+    // 检查是否为内部调用
+    private boolean isInternalCall(String servletPath, HttpServletResponse res, boolean[] isHandled) {
+        if (servletPath.endsWith("_Internal")) {
+            handleError(res, isHandled, "微服务间内部接口调用，是不需要走网关的！", null);
+            return true;
+        }
+        return false;
+    }
 
-            // 处理Authorization头
-            if (!StrKit.isBlank(req.getHeader("Authorization"))) {
-                builder.addHeader("Authorization", req.getHeader("Authorization"));
-                builder.addHeader("Accept", "application/json;odata=verbose");
-            }
+    // 检查是否为multipart请求
+    private boolean isMultipartRequest(HttpServletRequest req) {
+        String contentType = req.getContentType();
+        return contentType != null && contentType.startsWith(Constants.CONTENT_TYPE_MULTIPART);
+    }
 
-            // 处理Cookie
-            String cookie = req.getHeader("Cookie");
-            if (!StrKit.isBlank(cookie)) {
-                builder.addHeader("Cookie", cookie);
-            }
+    // 构建URL
+    private String buildUrl(String baseUrl, String queryString) {
+        return queryString != null ? baseUrl + "?" + queryString : baseUrl;
+    }
 
-            builder.post(body);
-            Request request = builder.build();
-            try {
-                executeRequest(request, res);
-                isHandled[0] = true;//停止filter
-                return;
-            } catch (IOException e) {
-                renderJson(res, new RetBean(RetBean.ERROR, "请求失败！" + e).toString());
-                isHandled[0] = true;//停止filter
-                return;
-            }
-        }
-        //4、其它的OPTIONS
-        renderJson(res, new RetBean(RetBean.ERROR, "系统只支持GET,POST，其它的OPTIONS不支持！文件上传请使用S3协议进行直传，不通过JAVA处理，JAVA只处理授权！").toString());
-        //停止filter
-        isHandled[0] = true;
+    // 记录请求日志
+    private void logRequest(HttpServletRequest req, String forwardUrl) {
+        logger.info("Request: {} {} -> {}", req.getMethod(), req.getRequestURI(), forwardUrl);
     }
-}
+}

dsGw/src/main/resources/gateway-config.txt

@@ -0,0 +1,12 @@
+# 超时配置
+gateway.timeout.connect=10000
+gateway.timeout.read=30000
+gateway.timeout.write=30000
+
+# 连接池配置
+gateway.connection.max=5
+gateway.connection.keep-alive=300
+
+# 安全配置
+gateway.security.cors.allowed-origins=*
+gateway.security.cors.allowed-methods=GET,POST

dsGw/src/main/resources/package.xml

@@ -1,67 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<assembly>
-    <!-- 最终打包文件的后缀，格式为 ${fileName}-bin -->
-    <id>bin</id>
-    <!-- 最终打包成一个用于发布的zip文件 -->
-    <formats>
-        <format>zip</format>
-    </formats>
-
-    <!-- 把依赖的jar包打包进zip的lib目录下-->
-    <dependencySets>
-        <dependencySet>
-            <!-- 不使用项目的artifact -->
-            <useProjectArtifact>false</useProjectArtifact>
-            <!-- 打包进zip文件下的lib目录中  -->
-            <outputDirectory>lib</outputDirectory>
-            <!-- 第三方jar不要解压 -->
-            <unpack>false</unpack>
-        </dependencySet>
-    </dependencySets>
-
-    <!-- 文件配置 -->
-    <fileSets>
-        <!-- 把项目的配置文件，打包进zip包的config目录下    -->
-        <fileSet>
-            <!-- 配置项目中需要被打包的文件的存储路径 -->
-            <directory>${project.basedir}/src/main/resources/${env}</directory>
-            <outputDirectory>/config</outputDirectory>
-            <includes>
-                <!-- 可以指定单个文件 -->
-                <!--<include>project.config</include>-->
-                <!-- 可以直接指定所有文件 -->
-                <include>*.*</include>
-            </includes>
-        </fileSet>
-
-        <!-- 把项目的配置文件，打包进zip包的根目录下    -->
-        <fileSet>
-            <directory>${project.basedir}/src/main/resources/${env}</directory>
-            <outputDirectory></outputDirectory>
-            <includes>
-                <include>scf*.xml</include>
-            </includes>
-        </fileSet>
-
-        <!-- 把项目自己编译出来根目录下的jar文件，打包进zip文件的根目录 -->
-        <fileSet>
-            <directory>${project.build.directory}</directory>
-            <outputDirectory></outputDirectory>
-            <includes>
-                <include>*.jar</include>
-            </includes>
-        </fileSet>
-
-        <!-- 把项目自己编译出来的jar文件夹下的jar文件，去除第三方jar，打包进zip文件的根目录 -->
-        <fileSet>
-            <directory>${project.build.directory}/jar</directory>
-            <outputDirectory></outputDirectory>
-            <excludes>
-                <exclude>lib/*.jar</exclude>
-            </excludes>
-            <includes>
-                <include>*.jar</include>
-            </includes>
-        </fileSet>
-    </fileSets>
-</assembly>