TableTranslators.java

package com.taobao.yugong.translator;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringUtils;

import com.taobao.yugong.common.db.meta.ColumnValue;
import com.taobao.yugong.common.model.record.Record;

/**
 * 常见的转换工具类
 * 
 * @author agapple 2016年6月7日 上午12:31:13
 * @since 1.0.3
 */
public class TableTranslators {

    public static ColumnTranslator newColumnTranslator() {
        return new ColumnTranslator();
    }

    public static interface TableTranslator {

        public Record translator(Record record);
    }

    public static class ColumnTranslator implements TableTranslator {

        protected Collection<String>       includeColumns = new HashSet<String>();
        protected Collection<String>       excludeColumns = new HashSet<String>();
        protected Collection<String>       checked        = new HashSet<String>();
        protected Collection<String>       notChecked     = new HashSet<String>();
        protected Map<String, Set<String>> columnAlias    = new HashMap<String, Set<String>>();

        public ColumnTranslator(){

        }

        /**
         * 包含的同步列
         */
        public ColumnTranslator include(String... columns) {
            for (String column : columns) {
                includeColumns.add(StringUtils.upperCase(column));
            }
            return this;
        }

        /**
         * 排除的同步列
         */
        public ColumnTranslator exclude(String... columns) {
            for (String column : columns) {
                excludeColumns.add(StringUtils.upperCase(column));
            }
            return this;
        }

        /**
         * 需要检查的字段
         */
        public ColumnTranslator check(String... columns) {
            for (String column : columns) {
                checked.add(StringUtils.upperCase(column));
            }
            return this;
        }

        /**
         * 不需要检查的字段
         */
        public ColumnTranslator notCheck(String... columns) {
            for (String column : columns) {
                notChecked.add(StringUtils.upperCase(column));
            }
            return this;
        }

        /**
         * 别名定义
         */
        public ColumnTranslator alias(String srcColumn, String targetColumn) {
            String sourceColumn = StringUtils.upperCase(srcColumn);
            Set<String> targetColumnSet = columnAlias.get(sourceColumn);
            if (targetColumnSet == null) {
                targetColumnSet = new HashSet<String>(2);
                columnAlias.put(sourceColumn, targetColumnSet);
            }
            targetColumnSet.add(StringUtils.upperCase(targetColumn));
            return this;
        }

        public Record translator(Record record) {
            if (excludeColumns != null && !excludeColumns.isEmpty()) {
                // 处理列排除
                for (String excludeColumn : excludeColumns) {
                    record.removeColumnByName(excludeColumn);
                }
            }

            if (includeColumns != null && !includeColumns.isEmpty()) {
                // 检查一下所有列是否存在
                for (String name : includeColumns) {
                    record.getColumnByName(name);
                }

                // 删除掉不需要的列
                List<ColumnValue> pks = record.getPrimaryKeys();
                List<ColumnValue> columns = record.getColumns();
                Set<String> allColumns = new HashSet<String>();
                for (ColumnValue pk : pks) {
                    allColumns.add(StringUtils.upperCase(pk.getColumn().getName()));
                }

                for (ColumnValue column : columns) {
                    allColumns.add(StringUtils.upperCase(column.getColumn().getName()));
                }

                allColumns.removeAll(includeColumns);
                for (String name : allColumns) {
                    record.removeColumnByName(name);
                }
            }

            if (notChecked != null && !notChecked.isEmpty()) {
                // 处理不检查列
                for (String notCheckColumn : notChecked) {
                    ColumnValue column = record.getColumnByName(notCheckColumn);
                    if (column != null) {
                        column.setCheck(false);
                    }
                }
            }

            if (checked != null && !checked.isEmpty()) {
                // 处理检查列
                for (String checkColumn : checked) {
                    ColumnValue column = record.getColumnByName(checkColumn);
                    if (column != null) {
                        column.setCheck(true);
                    }
                }
            }

            if (columnAlias != null && !columnAlias.isEmpty()) {
                for (Map.Entry<String, Set<String>> entry : columnAlias.entrySet()) {
                    String srcColumn = entry.getKey();
                    Set<String> targetColumns = entry.getValue();

                    ColumnValue column = record.getColumnByName(srcColumn);
                    if (column != null && targetColumns.size() >= 1) {
                        Iterator<String> iter = targetColumns.iterator();
                        String columnName = iter.next();
                        column.getColumn().setName(columnName);
                        if (iter.hasNext()) {
                            ColumnValue newColumn = column.clone();
                            newColumn.getColumn().setName(iter.next());
                            record.addColumn(newColumn);
                        }
                    }
                }
            }
            return record;
        }
    }
}