PLTWEB.git - Gitblit

package com.vci.server.common;
 
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
 
import freemarker.core.TemplateElement;
import freemarker.template.Configuration;
import freemarker.template.Template;
 
public class FreeMarkerCommon {
    /**
     * 根据模板属性配置的规则获取解析后的值
     * <p>Description: </p>
     * @author ligang
     * @time 2012-11-27
     * @param rootMap 属性值的组合
     * @param ruleInfo 规则
     * @return
     * @throws Exception
     * @throws IOException
     */
    static String CLASS_NAME="";
    static String METHOD_NAME ="";
    static String PARAMATER_VALUE = "";
    private final static String PACKAGENAME= "com.vci.freemaker";
    public final static String SPLIT_PARAMERS="&";
    public static final String SPLIT_TODO = "#";
    /**
     * ${attrName}-${attrName?className&methodName&param1,param2....}
     * ${身份证号}-${学历列表}-${加工方法#className&methodName&车,铣}
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static String getValueByTempRule(Map<String, FreemarkerParamObject> rootMap,String attrRule) {
        List<String> keys = getFreemarkExpressionKey(attrRule);
        Map<String, String> map = constructExpressionMap(keys);
        for (String key : keys) {
            if (map.keySet().contains(key)) {
                attrRule = attrRule.replaceAll(key, map.get(key));
            }
        }
        map.keySet();
        String formateAttrRule = checkDataParamers(rootMap,attrRule);
        if(formateAttrRule.length()<attrRule.length()){//表示存在需要被处理的数据信息
            attrRule = formateAttrRule;
            Object obj = getDateDetail(rootMap);
            if(obj!=null){
                if(obj instanceof Map){
                    rootMap = (Map)obj;
                }
            }
        }
        String fremakerValue = new FreeMarkerCommon().getRusultByTempRule(rootMap,attrRule);
        keys = getFreemarkExpressionKey(fremakerValue);
        for (String key : keys) {
            if (map.keySet().contains(key)) {
                fremakerValue = fremakerValue.replaceAll(key, map.get(key));
            }
        }
        return fremakerValue;
    }
    
    public static boolean isFreemarkExpression(String expression){
        try {
            boolean res = true;
            String field = expression;
            int begin = field.indexOf("${");
            int end = field.indexOf("}");
            int len = field.length();
            String key = null;
            while(!"".equals(field) && begin >= 0 && end < len){
                key = field.substring(begin + 2, end);
                if (key == null || key.trim().equals("")) {
                    return false;
                }
                field = field.substring(end + 1);
                begin = field.indexOf("${");
                end = field.indexOf("}");
                len = field.length();
                res = true;
            }
            if (key == null || key.trim().equals("")) {
                return false;
            }
            return res;
        } catch (Exception e) {
            return false;
        }
    }
    
    public static List<String> getFreemarkExpressionKey(String expression) {
        List<String> list = new ArrayList<String>();
        try {
            String field = expression;
            int begin = field.indexOf("${");
            int end = field.indexOf("}");
            int len = field.length();
            String key = null;
            while(!"".equals(field) && begin >= 0 && end < len){
                key = field.substring(begin + 2, end);
                if (key != null && !key.trim().equals("")) {
                    list.add(key);
                }
                field = field.substring(end + 1);
                begin = field.indexOf("${");
                end = field.indexOf("}");
                len = field.length();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        return list;
    }
    
    public static Map<String, String> constructExpressionMap(List<String> list) {
        Map<String, String> map = new HashMap<String, String>();
        for (String key : list) {
            if (key.indexOf(".") < 0) {
                continue;
            }
            map.put(key.replace(".", "_"), key);
            map.put(key, key.replace(".", "_"));
        }
        
        return map;
    }
    
    public static Map<String, FreemarkerParamObject> convertValueMapToFPOMap(Map<String, String> map){
        Map<String, FreemarkerParamObject> rootMap = new LinkedHashMap<String, FreemarkerParamObject>();
        Iterator<String> it = map.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            if(value == null){
                value = "";
            }
            String newKey = key.replace(".", "_");
            FreemarkerParamObject fpo = new FreemarkerParamObject(newKey, value);
            rootMap.put(newKey, fpo);
        }
        return rootMap;
    }
    
    public String getValByRule(Template t,Map<String, FreemarkerParamObject> rootMap,String attrRule,Configuration cfg) {
        Writer out = new StringWriter();
        try {
            t = new Template("name", new StringReader(attrRule),cfg);
            t.process(rootMap, out);
        } catch(Exception ex){
            out = new StringWriter();
            ((StringWriter)out).write(attrRule);
            //((StringWriter)out).write("");
            ex.printStackTrace();
        }
        return out.toString();
    }
    
    private void checkAllKeyInMap(Map<String, FreemarkerParamObject> rootMap,String attrRule){
        String field = attrRule;
        int begin = field.indexOf("${");
        int end = field.indexOf("}");
        int len = field.length();
        String key = "";
        while(!"".equals(field) && begin >= 0 && end < len){
            key = field.substring(begin + 2, end);
            if(!rootMap.containsKey(key)){
                rootMap.put(key, new FreemarkerParamObject(key, "${"+key+"}"));
                //rootMap.put(key, new FreemarkerParamObject(key, ""));
            }
            field = field.substring(end + 1);
            begin = field.indexOf("${");
            end = field.indexOf("}");
            len = field.length();
        }
    }
    
    public String getRusultByTempRule(Map<String, FreemarkerParamObject> rootMap,String attrRule) {
        checkAllKeyInMap(rootMap, attrRule);
        Configuration cfg = new Configuration();
        Template t;
        String ruleVal = "";
        try {
            String result = "";//组合规则的结果
            t = new Template("name", new StringReader(attrRule),cfg);
            TemplateElement templateElement = t.getRootTreeNode();
            String[] elementValue = new String[templateElement.getChildCount()];//组合规则中各元素的值
            int index = 0;
            String a = "";
            Map<Integer, String> connMap = new HashMap<Integer, String>();//存储连接符的对象
            for (@SuppressWarnings("rawtypes")
            Enumeration children = templateElement.children(); children.hasMoreElements();) {
                Object object = children.nextElement();
                String realVal = object.toString();
                String str = getValByRule(t,rootMap, realVal,cfg);//获取组合规则对应的值
                if (str.equals("")) {
                    a = "str";
                }
                //如果是模板属性规则
                if(realVal.contains("${")) {
                    result += str;
                    elementValue[index] = str;
                } else {//连接符的处理
                    if (a.equals("")) {
                        result += realVal;
                        elementValue[index] = realVal;
                        connMap.put(index, realVal);
                        
                    }else {
                        a = "";
                        result += realVal;
                        elementValue[index] = realVal;
                        connMap.put(index, realVal);
                    }
                    
                }
                
                index++;
            }
            
            if(elementValue.length <= 0) {
                result = getValByRule(t,rootMap, attrRule,cfg);//获取组合规则对应的值
                return result;
            }
            
            ruleVal = getResult(elementValue,result,connMap);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        return ruleVal;
    }
    
    private String getResult(String[] elementValue,String result,Map<Integer, String> connMap) {
        //获取需要过滤掉的关键字
        String filetVal = "";//ConfigUtils.getConfigValue("Special.data.filter");
        String ruleVal = "";
        //对根据组合规则获取的值进行处理，过滤掉值为无的数据
        for(int k = 0;k < elementValue.length;k++) {
            if(k == 0 && !elementValue[k].equals("") && filetVal.contains(elementValue[k])) {
                result = connMap.containsKey(k+1) ? result.replaceFirst(elementValue[k], "").replaceFirst(connMap.get(k+1), "") : result.replaceFirst(elementValue[k], "");
            } else if(k != elementValue.length - 1 && !elementValue[k].equals("") && filetVal.contains(elementValue[k])) {
                int index = result.indexOf(elementValue[k]);
                String newResult = result.replaceFirst(elementValue[k], "");
                if(index == 0 && connMap.containsKey(k-1)) {//如果为0，标示第一个节点是无
                    index = connMap.get(k-1).length();
                }
                result = newResult.length() > 0 && connMap.containsKey(k-1) ? newResult.substring(0,index - connMap.get(k-1).length()) + newResult.substring(index)
                        :newResult ;
            } else if(k == elementValue.length - 1 && !elementValue[k].equals("") && filetVal.contains(elementValue[k])) {
                result = result.replaceFirst(elementValue[k], "");
                result = result.length() > 0 && connMap.containsKey(k-1) ? result.substring(0,result.length() - (connMap.get(k-1).length()))
                        :result.replaceFirst(elementValue[k], "") ;
            }
        }
        
        ruleVal = result;
        return ruleVal;
    }
 
    /**
     * 检查是否存在需要被特殊处理的属性信息
     * <p>Description: </p>
     * @time 2013-7-17
     * @param attrRuleParamers：纯文本组合： ${attrName}-${attrName#className&methodName&param1,param2....}
     *            取子串处理：${attrName}-${attrName?subString(0,1)#className&methodName&param1,param2....}
     * @return  组合规则信息
     */
    private static String checkDataParamers(Map<String, FreemarkerParamObject> rootMap,String attrRuleParamers){
        StringBuilder result = new StringBuilder();
        StringBuilder atrrValue= new StringBuilder();
        String[] attrArrays = attrRuleParamers.split("-");
        for(int i = 0 ; i<attrArrays.length;i++){
            String[] ontAttrArray = attrArrays[i].split(SPLIT_TODO);
            if(ontAttrArray.length>1){
                String attrAllName = ontAttrArray[0];
                int start = attrAllName.indexOf("${");
                int end = attrAllName.length();
                if(attrAllName.contains("?")){
                    end = attrAllName.lastIndexOf("?");
                }
                String attrName = attrAllName.substring(start+2,end);
                String[] classMthodPara = ontAttrArray[1].split("&");
                if(classMthodPara.length>2){// 包含类，方法，参数信息
                    CLASS_NAME = classMthodPara[0];
                    METHOD_NAME = classMthodPara[1];
                    String[] attrVal = classMthodPara[2].split("}");
                    boolean isShowSubString = true;
                    atrrValue.append(attrName).append("=").append(attrVal[0]);
                    //处理含有截取子串的规则中，如果输入的数据值在该属性不需要显示的属性值范围内，则是组合规则编程纯文本的组合方式
                    if(attrAllName.contains("?")){
                        String attrValInput = rootMap.get(attrName).getValue();
                        String[] methodParams = attrVal[0].split(",");
                        for(String notShowAttr:methodParams){
                            if(attrValInput.equals(notShowAttr) ||attrValInput.equals("")){
                                String rightAttr = attrAllName.substring(0, attrAllName.lastIndexOf("?"));
                                isShowSubString = false;
                                attrArrays[i] = rightAttr+"}";
                                break;
                            }
                        }
                    }
                    if(isShowSubString){
                        attrArrays[i]  = attrAllName+"}";
                    }
                    atrrValue.append("&");
                }
            }
            result.append(attrArrays[i]).append("-");
        }
        if(atrrValue.length()>1){
            PARAMATER_VALUE =    atrrValue.substring(0,atrrValue.lastIndexOf("&"));
        }
        if(result.length()>1){
            return result.substring(0,result.lastIndexOf("-"));
        }
        return "";
    }
    
    private static Object getDateDetail(Map<String, FreemarkerParamObject> rootMap){
        Object result = new Object();
        try {
            Class<?> className = Class.forName(PACKAGENAME+"."+CLASS_NAME);
            Object object = className.newInstance();
            Method method = getMethod(className);
            if(method != null){
                 result = method.invoke(object, rootMap,PARAMATER_VALUE);
            }
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        return result;
    }
    
    private static Method getMethod(Class<?> className){
        Method method = null;
        ArrayList<Class<?>> paramerClass = new ArrayList<Class<?>>();
        paramerClass.add(Map.class);
        paramerClass.add(String.class);
        try {
             method = className.getMethod(METHOD_NAME, paramerClass.toArray(new Class[]{}));
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
         return method;
    }
    
    
    public static void main(String[] args){
//        Map<String, FreemarkerParamObject> rootMap = new HashMap<String, FreemarkerParamObject>();
//        rootMap.put("a", new FreemarkerParamObject("a","a"));
//        rootMap.put("b", new FreemarkerParamObject("b","b"));
//        rootMap.put("c", new FreemarkerParamObject("c","c"));
//        rootMap.put("d", new FreemarkerParamObject("d","d"));
//        rootMap.put("a.b.c.d", new FreemarkerParamObject("a.b.c.d","a.b.c.dval"));
//        String rule = "${a} ${b} ${c} ${d} ${e} ${x.y.z} xxx ${a.b.c.d}";
//        String res = new FreeMarkerCommon().getRusultByTempRule(rootMap, rule);
//        System.out.println("rule:" + rule);
//        System.out.println(" res:" + res);
        
        String abc = "${t_oid_a}(${t_oid_b})${c}";
        Map<String, String> map = new HashMap<String, String>();
        map.put("t_oid.a", "eddie");
        map.put("t_oid.b", "1972");
        map.put("c", "c");
        
        boolean is = FreeMarkerCommon.isFreemarkExpression(abc);
        if (is) {
             Map<String, FreemarkerParamObject>  ff = FreeMarkerCommon.convertValueMapToFPOMap(map);
             String value = FreeMarkerCommon.getValueByTempRule(ff, abc);
             
             //System.out.println(value);
        }
    }
    
}