青涩知夏->优化SPI

src/main/java/cn/nosum/NoSumGateWayStart.java

@@ -1,7 +1,7 @@
 package cn.nosum;
 
 import cn.nosum.common.extension.ExtensionLoader;
-import cn.nosum.gateway.container.spi.GateWayContainer;
+import cn.nosum.gateway.container.GateWayContainer;
 
 public class NoSumGateWayStart {
     public static void main(String[] args) {

src/main/java/cn/nosum/common/extension/ExtensionLoader.java

@@ -246,20 +246,25 @@ public class ExtensionLoader<T> {
      * 如果存在默认扩展名，提取并且缓存
      */
     private void cacheDefaultExtensionName() {
-        final SPI defaultAnnotation = type.getAnnotation(SPI.class);
-        if (defaultAnnotation != null) {
-            String value = defaultAnnotation.value();
-            if ((value = value.trim()).length() > 0) {
-                String[] names = NAME_SEPARATOR.split(value);
-                if (names.length > 1) {
-                    throw new IllegalStateException("More than 1 default extension name on extension "
-                            + type.getName() + ": "
-                            + Arrays.toString(names));
-                }
-                if (names.length == 1) {
-                    cachedDefaultName = names[0];
+        String value;
+        if (StringUtils.isEmpty(value=PropertiesUtil.getProperty(type.getName()))){
+            final SPI defaultAnnotation = type.getAnnotation(SPI.class);
+            if (defaultAnnotation != null) {
+                value = defaultAnnotation.value();
+                if ((value = value.trim()).length() > 0) {
+                    String[] names = NAME_SEPARATOR.split(value);
+                    if (names.length > 1) {
+                        throw new IllegalStateException("More than 1 default extension name on extension "
+                                + type.getName() + ": "
+                                + Arrays.toString(names));
+                    }
+                    if (names.length == 1) {
+                        cachedDefaultName = names[0];
+                    }
                 }
             }
+        }else{
+            cachedDefaultName=value;
         }
     }
 

src/main/java/cn/nosum/common/extension/factory/SpiExtensionFactory.java

@@ -1,9 +1,11 @@
 package cn.nosum.common.extension.factory;
 
+import cn.nosum.common.annotation.Adaptive;
 import cn.nosum.common.annotation.SPI;
 import cn.nosum.common.extension.ExtensionFactory;
 import cn.nosum.common.extension.ExtensionLoader;
 
+@Adaptive
 public class SpiExtensionFactory implements ExtensionFactory {
 
     @Override

src/main/java/cn/nosum/common/util/Convert.java

@@ -0,0 +1,569 @@
+package cn.nosum.common.util;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+
+/**
+ * 类型转换器
+ */
+public class Convert {
+
+    /**
+     * 转换为字符串<br>
+     * 如果给定的值为null，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static String toStr(Object value, String defaultValue) {
+        if (null == value) {
+            return defaultValue;
+        }
+        if (value instanceof String) {
+            return (String) value;
+        }
+        return value.toString();
+    }
+
+    /**
+     * 转换为字符串<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static String toStr(Object value) {
+        return toStr(value, null);
+    }
+
+
+    /**
+     * 转换为byte<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Byte toByte(Object value, Byte defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Byte) {
+            return (Byte) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).byteValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Byte.parseByte(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为byte<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Byte toByte(Object value) {
+        return toByte(value, null);
+    }
+
+    /**
+     * 转换为Short<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Short toShort(Object value, Short defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Short) {
+            return (Short) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).shortValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Short.parseShort(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Short<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Short toShort(Object value) {
+        return toShort(value, null);
+    }
+
+
+    /**
+     * 转换为int<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Integer toInt(Object value, Integer defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Integer) {
+            return (Integer) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).intValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Integer.parseInt(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为int<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Integer toInt(Object value) {
+        return toInt(value, null);
+    }
+
+    /**
+     * 转换为Integer数组<br>
+     *
+     * @param str 被转换的值
+     * @return 结果
+     */
+    public static Integer[] toIntArray(String str) {
+        return toIntArray(",", str);
+    }
+
+    /**
+     * 转换为Long数组<br>
+     *
+     * @param str 被转换的值
+     * @return 结果
+     */
+    public static Long[] toLongArray(String str) {
+        return toLongArray(",", str);
+    }
+
+    /**
+     * 转换为Integer数组<br>
+     *
+     * @param split 分隔符
+     * @param split 被转换的值
+     * @return 结果
+     */
+    public static Integer[] toIntArray(String split, String str) {
+        if (StringUtils.isEmpty(str)) {
+            return new Integer[]{};
+        }
+        String[] arr = str.split(split);
+        final Integer[] ints = new Integer[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            final Integer v = toInt(arr[i], 0);
+            ints[i] = v;
+        }
+        return ints;
+    }
+
+    /**
+     * 转换为Long数组<br>
+     *
+     * @param split 分隔符
+     * @param str   被转换的值
+     * @return 结果
+     */
+    public static Long[] toLongArray(String split, String str) {
+        if (StringUtils.isEmpty(str)) {
+            return new Long[]{};
+        }
+        String[] arr = str.split(split);
+        final Long[] longs = new Long[arr.length];
+        for (int i = 0; i < arr.length; i++) {
+            final Long v = toLong(arr[i], null);
+            longs[i] = v;
+        }
+        return longs;
+    }
+
+    /**
+     * 转换为String数组<br>
+     *
+     * @param str 被转换的值
+     * @return 结果
+     */
+    public static String[] toStrArray(String str) {
+        return toStrArray(",", str);
+    }
+
+    /**
+     * 转换为String数组<br>
+     *
+     * @param split 分隔符
+     * @param split 被转换的值
+     * @return 结果
+     */
+    public static String[] toStrArray(String split, String str) {
+        return str.split(split);
+    }
+
+    /**
+     * 转换为long<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Long toLong(Object value, Long defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Long) {
+            return (Long) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).longValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            // 支持科学计数法
+            return new BigDecimal(valueStr.trim()).longValue();
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为long<br>
+     * 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Long toLong(Object value) {
+        return toLong(value, null);
+    }
+
+    /**
+     * 转换为double<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Double toDouble(Object value, Double defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Double) {
+            return (Double) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).doubleValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            // 支持科学计数法
+            return new BigDecimal(valueStr.trim()).doubleValue();
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为double<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Double toDouble(Object value) {
+        return toDouble(value, null);
+    }
+
+    /**
+     * 转换为Float<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Float toFloat(Object value, Float defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Float) {
+            return (Float) value;
+        }
+        if (value instanceof Number) {
+            return ((Number) value).floatValue();
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return Float.parseFloat(valueStr.trim());
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为Float<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Float toFloat(Object value) {
+        return toFloat(value, null);
+    }
+
+    /**
+     * 转换为boolean<br>
+     * String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static Boolean toBoolean(Object value, Boolean defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof Boolean) {
+            return (Boolean) value;
+        }
+        String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        valueStr = valueStr.trim().toLowerCase();
+        switch (valueStr) {
+            case "true":
+            case "yes":
+            case "ok":
+            case "1":
+                return true;
+            case "false":
+            case "no":
+            case "0":
+                return false;
+            default:
+                return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为boolean<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static Boolean toBoolean(Object value) {
+        return toBoolean(value, false);
+    }
+
+    /**
+     * 转换为BigInteger<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static BigInteger toBigInteger(Object value, BigInteger defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof BigInteger) {
+            return (BigInteger) value;
+        }
+        if (value instanceof Long) {
+            return BigInteger.valueOf((Long) value);
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return new BigInteger(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为BigInteger<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static BigInteger toBigInteger(Object value) {
+        return toBigInteger(value, null);
+    }
+
+    /**
+     * 转换为BigDecimal<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value        被转换的值
+     * @param defaultValue 转换错误时的默认值
+     * @return 结果
+     */
+    public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue) {
+        if (value == null) {
+            return defaultValue;
+        }
+        if (value instanceof BigDecimal) {
+            return (BigDecimal) value;
+        }
+        if (value instanceof Long) {
+            return new BigDecimal((Long) value);
+        }
+        if (value instanceof Double) {
+            return new BigDecimal((Double) value);
+        }
+        if (value instanceof Integer) {
+            return new BigDecimal((Integer) value);
+        }
+        final String valueStr = toStr(value, null);
+        if (StringUtils.isEmpty(valueStr)) {
+            return defaultValue;
+        }
+        try {
+            return new BigDecimal(valueStr);
+        } catch (Exception e) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 转换为BigDecimal<br>
+     * 如果给定的值为空，或者转换失败，返回默认值<br>
+     * 转换失败不会报错
+     *
+     * @param value 被转换的值
+     * @return 结果
+     */
+    public static BigDecimal toBigDecimal(Object value) {
+        return toBigDecimal(value, null);
+    }
+
+
+    /**
+     * 将对象转为字符串<br>
+     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组
+     * 2、对象数组会调用Arrays.toString方法
+     *
+     * @param obj         对象
+     * @param charsetName 字符集
+     * @return 字符串
+     */
+    public static String objectToStr(Object obj, String charsetName) {
+        return objectToStr(obj, Charset.forName(charsetName));
+    }
+
+    /**
+     * 将对象转为字符串<br>
+     * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组
+     * 2、对象数组会调用Arrays.toString方法
+     *
+     * @param obj     对象
+     * @param charset 字符集
+     * @return 字符串
+     */
+    public static String objectToStr(Object obj, Charset charset) {
+        if (null == obj) {
+            return null;
+        }
+
+        if (obj instanceof String) {
+            return (String) obj;
+        } else if (obj instanceof byte[] || obj instanceof Byte[]) {
+            return objectToStr(obj, charset);
+        } else if (obj instanceof ByteBuffer) {
+            return objectToStr(obj, charset);
+        }
+        return obj.toString();
+    }
+
+    /**
+     * 将byte数组转为字符串
+     *
+     * @param bytes   byte数组
+     * @param charset 字符集
+     * @return 字符串
+     */
+    public static String byteToStr(byte[] bytes, String charset) {
+        return objectToStr(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
+    }
+
+}
+

src/main/java/cn/nosum/common/util/LinuxCmd.java

@@ -11,6 +11,7 @@ public class LinuxCmd {
     public static Logger logger= LoggerFactory.getLogger(LinuxCmd.class);
 
     public static String executeLinuxCmd(String cmd) {
+        if (!isLinux()){return null;}
         logger.debug("执行命令:{}",cmd);
         Runtime run = Runtime.getRuntime();
         try {
@@ -33,4 +34,8 @@ public class LinuxCmd {
         }
         return null;
     }
+
+    public static boolean isLinux() {
+        return System.getProperty("os.name").toLowerCase().contains("linux");
+    }
 }

src/main/java/cn/nosum/common/util/PropertiesUtil.java

@@ -0,0 +1,59 @@
+package cn.nosum.common.util;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.*;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class PropertiesUtil {
+	private final static Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
+
+	private static Map<String,String> propertiesMap= new ConcurrentHashMap<String,String>();
+	private static String fileName="/application.properties";
+
+	private PropertiesUtil(){}
+	public PropertiesUtil(String fileName){
+		setFileName(fileName);
+	}
+
+	static {
+		loadFile();
+	}
+
+	/**
+	 * 加载配置文件，并且将其转换为Map
+	 */
+	private static void loadFile(){
+		InputStream inputStream = PropertiesUtil.class.getResourceAsStream(fileName);
+		try {
+			Properties properties = new Properties();
+			properties.load(inputStream);
+			Set<Map.Entry<Object, Object>> entrySet = properties.entrySet();
+			for (Map.Entry<Object, Object> entry : entrySet) {
+				if (!entry.getKey().toString().startsWith("#")) {
+					propertiesMap.put(((String) entry.getKey()).trim(), ((String) entry.getValue()).trim());
+				}
+			}
+		} catch (IOException e) {
+			logger.debug("application.properties file read exception");
+		}
+	}
+
+	public static void setFileName(String fileName) {
+		PropertiesUtil.fileName = fileName;
+		loadFile();
+	}
+
+	public static String getProperty(String name,String defaultValue){
+		String value=getProperty(name);
+		return StringUtils.isEmpty(value)?defaultValue:value;
+	}
+
+	public static String getProperty(String name){
+		return propertiesMap.get(name);
+	}
+}

src/main/java/cn/nosum/gateway/container/spi/GateWayContainer.java

@@ -1,4 +1,4 @@
-package cn.nosum.gateway.container.spi;
+package cn.nosum.gateway.container;
 
 
 import cn.nosum.common.annotation.SPI;

src/main/java/cn/nosum/gateway/container/NettyGateWayContainer.java

@@ -1,7 +1,8 @@
 package cn.nosum.gateway.container;
 
 import cn.nosum.common.annotation.Adaptive;
-import cn.nosum.gateway.container.spi.GateWayContainer;
+import cn.nosum.common.util.Convert;
+import cn.nosum.common.util.PropertiesUtil;
 import cn.nosum.gateway.handler.FinalProcessHandler;
 import cn.nosum.gateway.handler.FullHttpRequestHandler;
 import cn.nosum.gateway.handler.PreProcessHandler;
@@ -21,7 +22,7 @@ import org.slf4j.LoggerFactory;
 @Adaptive
 public class NettyGateWayContainer implements GateWayContainer {
 	Logger logger= LoggerFactory.getLogger(NettyGateWayContainer.class);
-	private int port = 8888;
+	private int port = Convert.toInt(PropertiesUtil.getProperty("container.port"));
 	public void start(){
 		// Boss线程
 		EventLoopGroup bossGroup = new NioEventLoopGroup();

src/main/java/cn/nosum/gateway/entity/FileInfo.java

@@ -1,5 +0,0 @@
-package cn.nosum.gateway.entity;
-
-public class FileInfo {
-
-}

src/main/java/cn/nosum/gateway/handler/SlotProcessHandler.java

@@ -4,8 +4,8 @@ import cn.nosum.common.dto.ResultInfo;
 import cn.nosum.common.enums.ResultEnum;
 import cn.nosum.common.exception.ExcludeException;
 import cn.nosum.common.http.entity.Context;
-import cn.nosum.gateway.chain.ProcessorSlot;
-import cn.nosum.gateway.chain.SlotChainProvider;
+import cn.nosum.gateway.slot.ProcessorSlot;
+import cn.nosum.gateway.slot.SlotChainProvider;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 

src/main/java/cn/nosum/gateway/chain/AbstractLinkedProcessorSlot.java

@@ -1,4 +1,5 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot;
+
 
 public abstract class AbstractLinkedProcessorSlot<T> implements ProcessorSlot<T> {
 

src/main/java/cn/nosum/gateway/chain/DefaultProcessorSlotChain.java

@@ -1,4 +1,4 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot;
 
 import cn.nosum.common.http.entity.Context;
 

src/main/java/cn/nosum/gateway/chain/ProcessorSlot.java

@@ -1,4 +1,5 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot;
+
 
 
 /**

src/main/java/cn/nosum/gateway/chain/ProcessorSlotChain.java

@@ -1,4 +1,4 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot;
 
 import cn.nosum.common.http.entity.Context;
 

src/main/java/cn/nosum/gateway/chain/SlotChainProvider.java

@@ -1,6 +1,10 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot;
 
 
+import cn.nosum.common.extension.ExtensionLoader;
+import cn.nosum.gateway.slot.build.DefaultSlotChainBuilder;
+import cn.nosum.gateway.slot.build.SlotChainBuilder;
+
 public final class SlotChainProvider {
     private SlotChainProvider() {}
     private static volatile SlotChainBuilder builder = null;
@@ -9,9 +13,8 @@ public final class SlotChainProvider {
         if (builder != null) {
             return builder.build();
         }
-        // TODO 使用 SPI 与静态扩展点优化
         if (builder == null) {
-            builder = new DefaultSlotChainBuilder();
+            builder = ExtensionLoader.getExtensionLoader(SlotChainBuilder.class).getAdaptiveExtension();
         }
         return builder.build();
     }

src/main/java/cn/nosum/gateway/chain/DefaultSlotChainBuilder.java

@@ -1,9 +1,13 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot.build;
 
-import cn.nosum.gateway.slot.FileProcessorSlotChain;
-import cn.nosum.gateway.slot.LogProcessorSlotChain;
-import cn.nosum.gateway.slot.UrlProcessorSlotChain;
+import cn.nosum.common.annotation.Adaptive;
+import cn.nosum.gateway.slot.DefaultProcessorSlotChain;
+import cn.nosum.gateway.slot.ProcessorSlotChain;
+import cn.nosum.gateway.slot.impl.FileProcessorSlotChain;
+import cn.nosum.gateway.slot.impl.LogProcessorSlotChain;
+import cn.nosum.gateway.slot.impl.UrlProcessorSlotChain;
 
+@Adaptive
 public class DefaultSlotChainBuilder implements SlotChainBuilder {
     @Override
     public ProcessorSlotChain build() {

src/main/java/cn/nosum/gateway/chain/SlotChainBuilder.java

@@ -1,9 +1,13 @@
-package cn.nosum.gateway.chain;
+package cn.nosum.gateway.slot.build;
 
 
+import cn.nosum.common.annotation.SPI;
+import cn.nosum.gateway.slot.ProcessorSlotChain;
+
 /**
  * 处理槽构建器顶层接口
  */
+@SPI("link")
 public interface SlotChainBuilder {
 
     /**

src/main/java/cn/nosum/gateway/slot/FileProcessorSlotChain.java

@@ -1,9 +1,9 @@
-package cn.nosum.gateway.slot;
+package cn.nosum.gateway.slot.impl;
 
 import cn.nosum.common.http.entity.Context;
 import cn.nosum.common.util.LinuxCmd;
 import cn.nosum.common.util.NettyFileUtil;
-import cn.nosum.gateway.chain.AbstractLinkedProcessorSlot;
+import cn.nosum.gateway.slot.AbstractLinkedProcessorSlot;
 import com.alibaba.fastjson.JSON;
 
 /**

src/main/java/cn/nosum/gateway/slot/LogProcessorSlotChain.java

@@ -1,7 +1,7 @@
-package cn.nosum.gateway.slot;
+package cn.nosum.gateway.slot.impl;
 
 import cn.nosum.common.http.entity.Context;
-import cn.nosum.gateway.chain.AbstractLinkedProcessorSlot;
+import cn.nosum.gateway.slot.AbstractLinkedProcessorSlot;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 

src/main/java/cn/nosum/gateway/slot/UrlProcessorSlotChain.java

@@ -1,7 +1,7 @@
-package cn.nosum.gateway.slot;
+package cn.nosum.gateway.slot.impl;
 
 import cn.nosum.common.exception.ExcludeException;
-import cn.nosum.gateway.chain.AbstractLinkedProcessorSlot;
+import cn.nosum.gateway.slot.AbstractLinkedProcessorSlot;
 import cn.nosum.common.constant.Constants;
 import cn.nosum.common.http.entity.Context;
 

src/main/resources/META-INF/gateway/cn.nosum.gateway.slot.build.SlotChainBuilder

@@ -0,0 +1 @@
+link=cn.nosum.gateway.slot.build.DefaultSlotChainBuilder

src/main/resources/application.properties

@@ -1 +1,3 @@
-port=8888
+container.port = 8888
+cn.nosum.common.extension.ExtensionFactory = adaptive
+cn.nosum.gateway.container.GateWayContainer = netty