[编织消息框架][JAVA核心技术]数值与逻辑分离

为什么要分离？

业务需求是不停地变，如果把条件写进代码里，当用户需求变时要改代码发版本更新才能生效，这过程无疑是漫长的

就算是在开发期，不停的变开发者精力耗光在沟通，小修改上，无法专注逻辑部分

分离的根本目的是让开发者专注写引擎部分，无需关注太多业务上的边界，条件等

需要分离什么类型数值？

如活动开启时间，购买满足条件，购买上限等 这些不确定用户具体需求，全都可以弄成动态获取

分离技术实现有很多

如使用数据库mysql等

linux 常用的配置文本config

表格csv，json文件等

本项目用的是 java Properties 跟单例

 import java.io.FileInputStream;
 import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;

 import javax.script.ScriptEngine;
 import javax.script.ScriptEngineManager;

 import org.apache.commons.lang3.reflect.TypeUtils;

 import com.eyu.onequeue.reflect.anno.FieldValue;
 import com.eyu.onequeue.util.SerialUtil;

 /**
  * @author solq
  */
 public class PropertiesFactory {
     static final ScriptEngine se = new ScriptEngineManager().getEngineByName("JavaScript");

     public static <T> T initField(Class<T> clz, String file) {
     T ret = null;
     try {
         Properties pro = getProperties(file);
         ret = clz.newInstance();
         Field[] fields = clz.getDeclaredFields();
         Set<Method> methods = new HashSet<>();
         Collections.addAll(methods, clz.getDeclaredMethods());
         // Field modifiersField = Field.class.getDeclaredField("modifiers");
         // modifiersField.setAccessible(true);
         for (Field f : fields) {
         FieldValue anno = f.getAnnotation(FieldValue.class);
         if (anno == null) {
             continue;
         }

         String fileName = anno.value();
         String tmp = (String) pro.get(fileName);
         if (tmp == null) {
             continue;
         }
         Object value = tmp;
         Type type = f.getGenericType();
         if (type.equals(Integer.TYPE)) {
             value = se.eval(tmp);
         } else if (type.equals(Double.TYPE)) {
             value = se.eval(tmp);
         } else if (type.equals(Float.TYPE)) {
             value = se.eval(tmp);
         } else if (type.equals(Long.TYPE)) {
             value = se.eval(tmp);
         } else if (type.equals(Short.TYPE)) {
             value = ((Integer) se.eval(tmp)).shortValue();
         } else if (type.equals(Byte.TYPE)) {
             value = ((Integer) se.eval(tmp)).byteValue();
         } else if (type.equals(Boolean.TYPE)) {
             value = se.eval(tmp);
         } else if (TypeUtils.isAssignable(type, Map.class)) {
             value = SerialUtil.readValue(tmp, type);
         }else if (TypeUtils.isAssignable(type, Collection.class)) {
             value = SerialUtil.readValue(tmp, type);
         }else if (TypeUtils.isAssignable(type, Class.class)) {
             value = Class.forName(tmp);
         }else if (TypeUtils.isArrayType(type)) {
             value = SerialUtil.readArray(tmp, type);
         }

         String callMethodName = "set" + f.getName();
         boolean flag = false;
         try {
             for (Method m : methods) {
             if (m.getName().equals(callMethodName)) {
                 m.setAccessible(true);
                 m.invoke(ret, value);
                 flag = true;
                 break;
             }
             }
         } catch (Exception e) {

         }
         if (flag) {
             continue;
         }
         f.setAccessible(true);
         // modifiersField.setInt(f, f.getModifiers() & ~Modifier.FINAL);

         try {
             f.set(ret, value);
         } catch (Exception e1) {
             e1.printStackTrace();
         }
         }
     } catch (Exception e1) {
         e1.printStackTrace();
     }
     return ret;
     }

     public static Properties getProperties(String file) {
     Properties pro = new Properties();
     String path = ClassLoader.getSystemResource(file).getPath();
     try (InputStream fs = new FileInputStream(path);) {
         pro.load(fs);
     } catch (Exception e) {
         e.printStackTrace();
     }
     return pro;
     }
 }

PropertiesFactory

 /***
  * qm config 所有配置 属性不能加 final 否则 jvm 会优化
  *
  * @author solq
  */
 public class QMConfig {
     private static QMConfig instance = null;

     public static QMConfig getInstance() {
     if (instance != null) {
         return instance;
     }
     synchronized (QMConfig.class) {
         if (instance != null) {
         return instance;
         }
         instance = PropertiesFactory.initField(QMConfig.class, "qm.properties");
     }
     return instance;
     }

     // other

     /** 启动服务模式 影响 记录存储目录 **/
     public boolean SERVER_MODEL = true;
     /** 集群服务器 <address> client端不能为NULL **/
     @FieldValue("QM.CLUSTER_LIST")
     /** 本地名称，多应用不能相同，注册时用到 client端不能为NULL **/
     public String LOCALNAME;
     /** 集群服务器 <address> client端不能为NULL **/
     @FieldValue("QM.CLUSTER_LIST")
     public Set<String> CLUSTER_LIST;
     /** 订阅信息 topic : groupId 填写开启 **/
     @FieldValue("QM.TOPIC_INFO")
     public Set<String> TOPIC_INFO;
     /** 日志保存路径 <订阅,路径> consume端不能为NULL **/
     @FieldValue("QM.CONSUME_LOG_SAVE_DIRS")
     public Map<String, String> CONSUME_LOG_SAVE_DIRS = new HashMap<>(1);

     public Collection<QSubscribe> getTopics() {
     Collection<QSubscribe> ret = new HashSet<>();
     if (TOPIC_INFO == null) {
         return ret;
     }
     for (String str : TOPIC_INFO) {
         String[] s = str.split(":");
         ret.add(QSubscribe.of(s[0], s[1]));
     }
     return ret;
     }

     /** rpc param compress **/
     @FieldValue("QM.COMPRESS_SIZE")
     public int COMPRESS_SIZE = 1024;

     // NETTY
     /** server port **/
     @FieldValue("QM.NETTY_SERVER_PORT")
     public int NETTY_SERVER_PORT = 8080;
     /** server bossgroup **/
     @FieldValue("QM.NETTY_SERVER_BOSSGROUP")
     public int NETTY_SERVER_BOSSGROUP = 1;
     /** server workergroup **/
     @FieldValue("QM.NETTY_SERVER_WORKERGROUP")
     public int NETTY_SERVER_WORKERGROUP = 4;
     /** server socket option **/
     @FieldValue("QM.NETTY_SERVER_SESSION_OPTION")
     public Map<String, ?> NETTY_SERVER_SESSION_OPTION;
     /** child socket option **/
     @FieldValue("QM.NETTY_SERVER_CHILD_SESSION_OPTION")
     public Map<String, ?> NETTY_SERVER_CHILD_SESSION_OPTION;
     /** 处理模型实现 **/
     @FieldValue("QM.NETTY_SERVER_ACCEPTOR")
     public Class<? extends ServerSocketChannel> NETTY_SERVER_ACCEPTOR = NioServerSocketChannel.class;

  ..............................

 }

QMConfig

源码解读

PropertiesFactory

25行 用到JavaScript

为什么解释字符串部分用到 ScriptEngine ？

有些配置 如 QM.COMPRESS_SIZE = 1024*2 是个公式运算，要用引擎才能执行

108行通过ClassLoader来定位某个资源文件路径，然后再以文件读取的方式加载，不用ClassLoader加载，原因ClassLoader加载过有缓存，不能在线重载配置

initField整个函数用到java 反射技术，动态生成类，看似很多条件处理，按类型划分其实不多,常用处理五种

1.java基本类型 如int,long,short,byte,double,float,boolean,string等

2.数组同集合 array,collection

3.map字典

4.class类

5.java object

注意：java.lang.reflect.Type 非常重要，能保留泛型信息

处理Type工具 org.apache.commons.lang3.reflect.TypeUtils

QMConfig

17行 是个单例使用时必须初始化配置文件 qm.properties 才能正常使用

@FieldValue 注解的值对应配置文件上的KEY，命名风格 QM.+属性名 保持一致

如果配置文件上没有填写，以属性默认值为准，减少执行期初始化代码

具体每个属性作为在那里，以后分析每个模块会讲到

小结：

使用properties 跟单例可以做出很好的效果，看了大多数框架花大多精力在配置上，有时复杂的不一定是最优

重复一下观点 出自UNIX编程艺术

分离的根本目的是让开发者专注写引擎部分，无需关注太多业务上的边界，条件等