《编织消息框架》

为什么要分离？

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

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

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

需要分离什么类型数值？

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

分离技术实现有很多

如使用数据库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;
    }
}

/***
 * 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;

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

}

源码解读

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编程艺术

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