Mysql Diff Java 面向对象总结

MySQLDiff 总结 :

1.在处理问题时，采取面向对象的方法 ，将这个问题或者实例中存在的对象抽离出来。

2.抽离对象时候，尽量考虑齐全，将问题的一个个特征分离为对象的一个个属性。

3.对象抽离好，考虑建模，数据模型的建立至关重要，模型的优良决定代码编写的复杂程度。在设计时，先找到要处理的各个对象，再找到各个对象共同点祖先，逐层抽象，最后确立各个类之间的继承关系。

4.对象抽离要细致，从整体出发，到每一个细分部分，从而问题能够交给一级一级往下处理。

5.对象的属性类型做出周到的考虑，不能全由字符串来处理，并且对属性的命名要规范，采用驼峰式，命名要有意义，含有隐喻义。

6.定义的数据结构要便于处理，不能过于复杂从而加大程序编写难度。

public class Field {
    private String ColumnName;
    private String TableName;
    private Boolean IsNull;
    private FieldType fieldType;
    private String Default;
    private boolean IsExistField;
    private boolean IsPrimaryKey;
    private boolean IsUnique;
    private boolean IsAutoIncreament;
}

public class Index {
    private String TableName;
    private String IndexName;
    private List<String> ColumnName;
    private boolean IsExistIndex;
}

public class Table {
    private String TableName;
    private HashMap<String,Field> fieldHashMap;
    private HashMap<String,Index> indexHashMap;
}

public class DataBase {
    private String name;
    private HashMap<String, Table> tableHashMap;
    private HashMap<String,TableDiff> tableDiffHashMap;
}

public class TableDiff {
    private String TableName;
    private HashMap<String,FieldDiff> fieldDiffMap;
    private HashMap<String,Index> indexDiffMap;
    private boolean IsExistTable;
}

public class FieldDiff {
    private String TableName;
    private String ColumnName;
    private Boolean IsNull;
    private FieldType fieldType;
    private String Default;
    private String Extra;
    private boolean IsExistField;
    private boolean IsPrimaryKey;
    private boolean IsUnique;
    private boolean IsAutoIncreament;
}

7.定义数据类型时，一定要考虑这个类型以后可能参与的算法，若有比较，更改等需求，尽量不使用List来存放，多使用Hash Map，可以大幅度优化算法复杂度从而减少循环的出现，尤其是双重循环或多重循环，采用Map即可根据 键 直接获取 值，不需继续循环寻找。

for (Map.Entry<String, Table> entry : SecTableMap.entrySet()) {
            Table MainTable = MainTableMap.get(entry.getKey());
            Table SecTable = entry.getValue();
            if (MainTable!=null) {
                TableDiff tableDiff = MainTable.diffHashMap(SecTable);
                tableDiff.setExistTable(true);
                diffHashMap.put(MainTable.getTableName(),tableDiff);
            }
            else
            {
                TableDiff tableDiff = new TableDiff();
                tableDiff.setTableName(entry.getKey());
                tableDiff.setExistTable(false);
                diffHashMap.put(entry.getKey(), tableDiff);
            }
        }

8.代码编写要考虑到模块化处理，分工处理，某个任务由某个类完成，分级处理，绝不能将问题的解决方法堆叠在一层处理。

    public HashMap<String,TableDiff> diffHashMap(DataBase target)
    {
        HashMap<String,TableDiff> diffHashMap = new HashMap<>();

        HashMap<String,Table> MainTableMap = this.getTableHashMap();

        HashMap<String,Table> SecTableMap = target.getTableHashMap();
        
        for (Map.Entry<String, Table> entry : SecTableMap.entrySet()) {

            Table MainTable = MainTableMap.get(entry.getKey());
            Table SecTable = entry.getValue();

            if (MainTable!=null) {
                TableDiff tableDiff = MainTable.diffHashMap(SecTable);
                tableDiff.setExistTable(true);
                diffHashMap.put(MainTable.getTableName(),tableDiff);
            }
            else
            {
                TableDiff tableDiff = new TableDiff();
                tableDiff.setTableName(entry.getKey());
                tableDiff.setExistTable(false);
                diffHashMap.put(entry.getKey(), tableDiff);
            }
        }
        return diffHashMap;
    }

   public TableDiff diffHashMap(Table second)
    {
        HashMap<String,Field> MainField = this.getFieldHashMap();
        HashMap<String,Field> SecField = second.getFieldHashMap();
        TableDiff tableDiff = new TableDiff();
        HashMap<String,FieldDiff> fieldDiffMap = new HashMap<>();
        for (Map.Entry<String, Field> entry : MainField.entrySet())
        {
            Field main = entry.getValue();
            Field sec = SecField.get(entry.getKey());

            if (sec!=null) {
                FieldDiff fieldDiff = main.FieldDiff(sec);
                fieldDiff.setExistField(true);
                fieldDiffMap.put(main.getColumnName(),fieldDiff);
            }
            else
            {
                FieldDiff fieldDiff = new FieldDiff();
                fieldDiff.setExistField(false);
                fieldDiff.setColumnName(entry.getKey());
                fieldDiffMap.put(entry.getKey(),fieldDiff);
            }
        }
        HashMap<String,Index> MainIndex = this.getIndexHashMap();
        HashMap<String,Index> SecIndex = second.getIndexHashMap();
        HashMap<String,Index> IndexDiffMap = new HashMap<>();
        for (Map.Entry<String,Index> entry : MainIndex.entrySet())
        {
            Index main = entry.getValue();

            Index sec = SecIndex.get(entry.getKey());

            if (sec!=null) {
                Index index = main.Diff(sec);
                index.setExistIndex(true);
                IndexDiffMap.put(main.getIndexName(),index);
            }
            else
            {
                Index index = new Index();
                index.setIndexName(entry.getKey());
                index.setExistIndex(false);
                IndexDiffMap.put(entry.getKey(),index);
            }
        }
        tableDiff.setIndexDiffMap(IndexDiffMap);
        tableDiff.setFieldDiffMap(fieldDiffMap);
        tableDiff.setTableName(this.getTableName());
        return tableDiff;
    }

 public Index Diff(Index Sec)
    {
        Index diff = new Index();
        if (this.getColumnName()!=Sec.getColumnName())
        {
            diff.setTableName(Sec.getTableName());
            diff.setColumnName(Sec.getColumnName());
            diff.setIndexName(Sec.getIndexName());
        }
        return diff;
    }

public  FieldDiff FieldDiff(Field second)
    {
        HashMap<String,FieldDiff> fieldDiffMap = new HashMap<>();
        if(this.isNull()!=second.isNull()||this.getFieldType()!=second.getFieldType()||this.getExtra()!=second.getExtra()||this.getDefault()!=second.getDefault()) {
            FieldDiff fieldDiff = new FieldDiff();
            fieldDiff.setTableName(second.getTableName());
            fieldDiff.setColumnName(second.getColumnName());
            if (!this.isNull().equals(second.isNull())) {
                fieldDiff.setNull(second.isNull());
            }
            if (!this.getFieldType().equals( second.getFieldType())) {
                fieldDiff.setFieldType(second.getFieldType());
            }
            if (!this.getExtra() .equals(second.getExtra()) ) {
                fieldDiff.setExtra(second.getExtra());
            }
            if (!this.getDefault() .equals(second.getDefault())) {
                fieldDiff.setDefault(second.getDefault());
            }
            if (!this.getExtraType().equals(second.getExtraType()))
            {
                fieldDiff.setExtraType(ExtraType.AUTOINCREMENT);
            }
            return fieldDiff;
        }
        return null;
    }

9.每一个类尽量做到独立功能，体现单一职责，能使得系统具有较好的可复用性。

10.采用组合方法解决问题，减少程序的耦合度。

11.要习惯于用单元测试，测试每个类实例化后，这个类所拥有方法是否满足需求。

12.对接口编程而不是对实现编程。优先使用对象组合而不是继承。