Architecture(4)LitePal原始碼分析

public class A extends DataSupport {
    private List<B> list;
}
public class B extends DataSupport {
    private A a;
}
複製程式碼

• 多對多單向關聯

  public class A extends DataSupport {
      private List<B> list;
  }
  public class B extends DataSupport {
      private List<A> list;
  }
  複製程式碼

  ​

• 多對多單向關聯

  public class A extends DataSupport {
      private List<B> list;
  }
  public class B extends DataSupport {
      private List<A> list;
  }
  複製程式碼

  ​

接下來的兩個方法，在理解了上面的概念之後才能更好地理解，不然很難理解

oneToAnyConditions

private void oneToAnyConditions(String className, Field field, int action) throws ClassNotFoundException {
    //獲取成員變數的型別
    Class<?> fieldTypeClass = field.getType();
    // 判斷litepal.xml對映的類中是否包含fieldTypeClass
    if (LitePalAttr.getInstance().getClassNames().contains(fieldTypeClass.getName())) {
      	//通過反射建立對映的關係表的類
        Class<?> reverseDynamicClass = Class.forName(fieldTypeClass.getName());
        //獲取所有的成員變數
        Field[] reverseFields = reverseDynamicClass.getDeclaredFields();
        //是否是雙向關聯的標誌，預設為false
        boolean reverseAssociations = false;
        for (int i = 0; i < reverseFields.length; i++) {
            Field reverseField = reverseFields[i];
            if (!Modifier.isStatic(reverseField.getModifiers())) {
                Class<?> reverseFieldTypeClass = reverseField.getType();
                //B中含有A,關聯關係是一對一
                if (className.equals(reverseFieldTypeClass.getName())) {
                    if (action == GET_ASSOCIATIONS_ACTION) {
                   //將AssociationModel新增進Collection
                    addIntoAssociationModelCollection(className, fieldTypeClass.getName(),
                                fieldTypeClass.getName(), Const.Model.ONE_TO_ONE);
                    } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                   //將AssociationInfo新增進Collection
                   addIntoAssociationInfoCollection(className, fieldTypeClass.getName(),
                  fieldTypeClass.getName(), field, reverseField, Const.Model.ONE_TO_ONE);
                    }
                  //雙向關聯的標誌置為true
                    reverseAssociations = true;
                }
               //如果在B類中含有泛型集合，說明關聯關係是多對一
                else if (isCollection(reverseFieldTypeClass)) {
                    String genericTypeName = getGenericTypeName(reverseField);
                    if (className.equals(genericTypeName)) {
                       if (action == GET_ASSOCIATIONS_ACTION) {
                          //將AssociationModel新增進Collection
                    addIntoAssociationModelCollection(className, fieldTypeClass.getName(), 							className, Const.Model.MANY_TO_ONE);
                        } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                        //將AssociationInfo新增進Collection
                    addIntoAssociationInfoCollection(className, fieldTypeClass.getName(),className, field, reverseField, Const.Model.MANY_TO_ONE);
                        }
                         //雙向關聯的標誌置為true
                        reverseAssociations = true;
                    }
                }
            }
        }
       //reverseAssociations為false，說明是單向關聯
       //單向關聯
        if (!reverseAssociations) {
            if (action == GET_ASSOCIATIONS_ACTION) {
                addIntoAssociationModelCollection(className, fieldTypeClass.getName(),
                        fieldTypeClass.getName(), Const.Model.ONE_TO_ONE);
            } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                addIntoAssociationInfoCollection(className, fieldTypeClass.getName(),
                        fieldTypeClass.getName(), field, null, Const.Model.ONE_TO_ONE);
            }
        }
    }
}

複製程式碼

manyToAnyConditions

private void manyToAnyConditions(String className, Field field, int action) throws ClassNotFoundException {
    //如果A中沒有集合類的成員變數，那麼肯定不是多對多
    if (isCollection(field.getType())) {
        String genericTypeName = getGenericTypeName(field);
        //A類中包含泛型集合類
        if (LitePalAttr.getInstance().getClassNames().contains(genericTypeName)) {
            //通過反射建立一個B類
            Class<?> reverseDynamicClass = Class.forName(genericTypeName);
          	//拿到B類的所有成員變數
            Field[] reverseFields = reverseDynamicClass.getDeclaredFields();
          	//雙向關聯的標誌
            boolean reverseAssociations = false;
            for (int i = 0; i < reverseFields.length; i++) {
                Field reverseField = reverseFields[i];
                // Only map private fields
                if (!Modifier.isStatic(reverseField.getModifiers())) {
                    Class<?> reverseFieldTypeClass = reverseField.getType();
                    //如果B中含有A,說明是多對一
                    if (className.equals(reverseFieldTypeClass.getName())) {
                        if (action == GET_ASSOCIATIONS_ACTION) {
                           //將AssociationModel新增進Collection
                            addIntoAssociationModelCollection(className, genericTypeName,
                                    genericTypeName, Const.Model.MANY_TO_ONE);
                        } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                          //將AssociationInfo新增進Collection
                        addIntoAssociationInfoCollection(className, genericTypeName, genericTypeName,field, reverseField, Const.Model.MANY_TO_ONE);
                        }
                      //雙向關聯的標誌置為true
                        reverseAssociations = true;
                    }
                   //如果B的成員變數有集合類
                    else if (isCollection(reverseFieldTypeClass)) {
                        String reverseGenericTypeName = getGenericTypeName(reverseField);
                       //如果B中的泛型跟A相同，那麼就是多對多
                        if (className.equals(reverseGenericTypeName)) {
                            if (action == GET_ASSOCIATIONS_ACTION) {
                               //將AssociationModel新增進Collection
                   addIntoAssociationModelCollection(className, genericTypeName,  null,Const.Model.MANY_TO_MANY);
                            } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                              //將AssociationInfo新增進Collection
                       addIntoAssociationInfoCollection(className, genericTypeName, null, field,reverseField, Const.Model.MANY_TO_MANY);
                            }
                          //雙向關聯的標誌置為true
                            reverseAssociations = true;
                        }
                    }

                }
            }
           //非雙向關聯，作為多對一處理
            if (!reverseAssociations) {
                if (action == GET_ASSOCIATIONS_ACTION) {
                  //將AssociationModel新增進Collection
                    addIntoAssociationModelCollection(className, genericTypeName,
                            genericTypeName, Const.Model.MANY_TO_ONE);
                } else if (action == GET_ASSOCIATION_INFO_ACTION) {
                   //將AssociationInfo新增進Collection
                    addIntoAssociationInfoCollection(className, genericTypeName, genericTypeName, field, null, Const.Model.MANY_TO_ONE);
                }
            }
        } else if (BaseUtility.isGenericTypeSupported(genericTypeName) && action == GET_ASSOCIATIONS_ACTION) {
           //如果是雙向關聯，並且是獲取關聯關係型別的Action下
            Column annotation = field.getAnnotation(Column.class);
           //變數是有效的
            if (annotation != null && annotation.ignore()) {
                return;
            }
          //建立GenericModel
            GenericModel genericModel = new GenericModel();
            genericModel.setTableName(DBUtility.getGenericTableName(className, field.getName()));
     genericModel.setValueColumnName(DBUtility.convertToValidColumnName(field.getName()));
            genericModel.setValueColumnType(getColumnType(genericTypeName));
            genericModel.setValueIdColumnName(DBUtility.getGenericValueIdColumnName(className));
            mGenericModels.add(genericModel);
        }
    }
}

複製程式碼

Generator

繼承關係

成員變數

private Collection<TableModel> mTableModels;//表的Module集合
private Collection<AssociationsModel> mAllRelationModels;//關係Module集合
複製程式碼

execute

通過SQL語句建表

protected void execute(List<String> sqls, SQLiteDatabase db) {
   String throwSQL = "";
   try {
      if (sqls != null && !sqls.isEmpty()) {
         for (String sql : sqls) {
                   if (!TextUtils.isEmpty(sql)) {
                     //轉換成小寫
                       throwSQL = BaseUtility.changeCase(sql);
                       db.execSQL(throwSQL);
                   }
         }
      }
   } catch (SQLException e) {
      throw new DatabaseGenerateException(DatabaseGenerateException.SQL_ERROR + throwSQL);
   }
}
複製程式碼

create

呼叫Creatord的方法建立或更新表

private static void create(SQLiteDatabase db, boolean force) {
   Creator creator = new Creator();
   creator.createOrUpgradeTable(db, force);
}
複製程式碼

drop

呼叫Dropper的方法刪除表

private static void drop(SQLiteDatabase db) {
   Dropper dropper = new Dropper();
   dropper.createOrUpgradeTable(db, false);
}
複製程式碼

upgrade

呼叫Upgrader的方法

private static void upgradeTables(SQLiteDatabase db) {
   Upgrader upgrader = new Upgrader();
   upgrader.createOrUpgradeTable(db, false);
}

複製程式碼

DataHandler

繼承關係

成員變數

//DB的例項用來進行CRUD操作
SQLiteDatabase mDatabase;
//空的DataSupport例項
private DataSupport tempEmptyModel;
//ModuleA中的AssociationsInfo集合
private List<AssociationsInfo> fkInCurrentModel;
//ModuleB中的AssociationsInfo集合
private List<AssociationsInfo> fkInOtherModel;
複製程式碼

query

protected <T> List<T> query(Class<T> modelClass, String[] columns, String selection,
      String[] selectionArgs, String groupBy, String having, String orderBy, String limit,
      List<AssociationsInfo> foreignKeyAssociations) {
   List<T> dataList = new ArrayList<T>();
   Cursor cursor = null;
   try {
     List<Field> supportedFields = getSupportedFields(modelClass.getName());
     List<Field> supportedGenericFields =getSupportedGenericFields(modelClass.getName());
       String[] customizedColumns = DBUtility.convertSelectClauseToValidNames(getCustomizedColumns(columns, supportedGenericFields, foreignKeyAssociations));
     //拿到table的名字
      String tableName = getTableName(modelClass);
     //通過引數進行查詢
      cursor = mDatabase.query(tableName, customizedColumns, selection, selectionArgs,
            groupBy, having, orderBy, limit);
      if (cursor.moveToFirst()) {
     SparseArray<QueryInfoCache> queryInfoCacheSparseArray = new SparseArray<QueryInfoCache>();
               Map<Field, GenericModel> genericModelMap = new HashMap<Field, GenericModel>();
         do {
           //建立泛型例項
            T modelInstance = (T) createInstanceFromClass(modelClass);
           //進行Id賦值
            giveBaseObjIdValue((DataSupport) modelInstance,
                  cursor.getLong(cursor.getColumnIndexOrThrow("id")));
           //將查詢出來的Value給Module賦值
            setValueToModel(modelInstance, supportedFields, foreignKeyAssociations, cursor, queryInfoCacheSparseArray);
           //將泛型的Value賦值給Module
            setGenericValueToModel((DataSupport) modelInstance, supportedGenericFields, genericModelMap);
           //設定關聯物件的值
            if (foreignKeyAssociations != null) {
               setAssociatedModel((DataSupport) modelInstance);
            }
           //新增元素進集合
            dataList.add(modelInstance);
         } while (cursor.moveToNext());
               queryInfoCacheSparseArray.clear();
               genericModelMap.clear();
      }
      return dataList;
   } catch (Exception e) {
      throw new DataSupportException(e.getMessage(), e);
   } finally {
      if (cursor != null) {
         cursor.close();
      }
   }
}
複製程式碼

analyzeAssociations

對關聯關係進行分析

private void analyzeAssociations(String className) {
   Collection<AssociationsInfo> associationInfos = getAssociationInfo(className);
   if (fkInCurrentModel == null) {
      fkInCurrentModel = new ArrayList<AssociationsInfo>();
   } else {
      fkInCurrentModel.clear();
   }
   if (fkInOtherModel == null) {
      fkInOtherModel = new ArrayList<AssociationsInfo>();
   } else {
      fkInOtherModel.clear();
   }
   for (AssociationsInfo associationInfo : associationInfos) {
     //關聯關係為多對一或者一對一
      if (associationInfo.getAssociationType() == Const.Model.MANY_TO_ONE
            || associationInfo.getAssociationType() == Const.Model.ONE_TO_ONE) {
         if (associationInfo.getClassHoldsForeignKey().equals(className)) {
           //當前module
            fkInCurrentModel.add(associationInfo);
         } else {
           //關聯Module
            fkInOtherModel.add(associationInfo);
         }
      } else if (associationInfo.getAssociationType() == Const.Model.MANY_TO_MANY) {
        //多對多
         fkInOtherModel.add(associationInfo);
      }
   }
}
複製程式碼

analyzeAssociatedModels

protected void analyzeAssociatedModels(DataSupport baseObj, Collection<AssociationsInfo> associationInfos) {
   try {
      for (AssociationsInfo associationInfo : associationInfos) {
        //遍歷associationInfos集合
         if (associationInfo.getAssociationType() == Const.Model.MANY_TO_ONE) {
           //Many2OneAnalyzer處理
            new Many2OneAnalyzer().analyze(baseObj, associationInfo);
         } else if (associationInfo.getAssociationType() == Const.Model.ONE_TO_ONE) {
           //One2OneAnalyzer處理
            new One2OneAnalyzer().analyze(baseObj, associationInfo);
         } else if (associationInfo.getAssociationType() == Const.Model.MANY_TO_MANY) {
           //Many2ManyAnalyzer處理
            new Many2ManyAnalyzer().analyze(baseObj, associationInfo);
         }
      }
   } catch (Exception e) {
      throw new DataSupportException(e.getMessage(), e);
   }
}
複製程式碼

AssociationsAnalyzer的子類實際上是在處理AssociationsInfo，就是將AssociationsInfo分配給當前的Module或者是關聯的Module

encryptValue

LitePal支援MD5加密跟AES加密，但是MD5加密之後是不能解密的，那麼有什麼用，沒明白

protected Object encryptValue(String algorithm, Object fieldValue) {
    if (algorithm != null && fieldValue != null) {
        if (DataSupport.AES.equalsIgnoreCase(algorithm)) {
            fieldValue = CipherUtil.aesEncrypt((String) fieldValue);
        } else if (DataSupport.MD5.equalsIgnoreCase(algorithm)) {
            fieldValue = CipherUtil.md5Encrypt((String) fieldValue);
        }
    }
    return fieldValue;
}
複製程式碼

decryptValue

 */
protected Object decryptValue(String algorithm, Object fieldValue) {
    if (algorithm != null && fieldValue != null) {
        if (DataSupport.AES.equalsIgnoreCase(algorithm)) {
            fieldValue = CipherUtil.aesDecrypt((String) fieldValue);
        }
    }
    return fieldValue;
}
複製程式碼

SaveHandler

方法概覽

onSave

void onSave(DataSupport baseObj) throws SecurityException, IllegalArgumentException,
      NoSuchMethodException, IllegalAccessException, InvocationTargetException {
   //獲取類名
   String className = baseObj.getClassName();
   //獲取DB支援的成員變數
   List<Field> supportedFields = getSupportedFields(className);
   //獲取DB支援的泛型變數
   List<Field> supportedGenericFields = getSupportedGenericFields(className);
   //獲取所有的關聯關係
   Collection<AssociationsInfo> associationInfos = getAssociationInfo(className);
   //是否儲存過
   if (!baseObj.isSaved()) {
           if (!ignoreAssociations) {
               analyzeAssociatedModels(baseObj, associationInfos);
           }
     		//進行資料儲存
            doSaveAction(baseObj, supportedFields, supportedGenericFields);
           if (!ignoreAssociations) {
               analyzeAssociatedModels(baseObj, associationInfos);
           }
   } else {
           if (!ignoreAssociations) {
               analyzeAssociatedModels(baseObj, associationInfos);
           }
       //更新操作
        doUpdateAction(baseObj, supportedFields, supportedGenericFields);
   }
}
複製程式碼

doSaveAction

private void doSaveAction(DataSupport baseObj, List<Field> supportedFields, List<Field> supportedGenericFields)
      throws SecurityException, IllegalArgumentException, NoSuchMethodException,
      IllegalAccessException, InvocationTargetException {
   //清空ContentValues
   values.clear();
   //將成員變數轉化成Values
   beforeSave(baseObj, supportedFields, values);
   //進行插入操作，拿到返回的ID
   long id = saving(baseObj, values);
   //如果有關聯表，則進行關聯表的插入
   afterSave(baseObj, supportedFields, supportedGenericFields, id);
}
複製程式碼

doUpdateAction

private void doUpdateAction(DataSupport baseObj, List<Field> supportedFields, List<Field> supportedGenericFields)
      throws SecurityException, IllegalArgumentException, NoSuchMethodException,
      IllegalAccessException, InvocationTargetException {
  //清空ContentValues
   values.clear();
   //將成員變數轉化成Values
   beforeUpdate(baseObj, supportedFields, values);
   //進行更新操作
   updating(baseObj, values);
   //進行關聯表操作
   afterUpdate(baseObj, supportedGenericFields);
}
複製程式碼

QueryHandler

方法概覽

onFindFirst

找到第一個

<T> T onFindFirst(Class<T> modelClass, boolean isEager) {
   List<T> dataList = query(modelClass, null, null, null, null, null, "id", "1",
         getForeignKeyAssociations(modelClass.getName(), isEager));
   if (dataList.size() > 0) {
      return dataList.get(0);
   }
   return null;
}
複製程式碼

onFindAll

<T> List<T> onFindAll(Class<T> modelClass, boolean isEager, long... ids) {
   List<T> dataList;
   if (isAffectAllLines(ids)) {
      dataList = query(modelClass, null, null, null, null, null, "id", null,
            getForeignKeyAssociations(modelClass.getName(), isEager));
   } else {
      dataList = query(modelClass, null, getWhereOfIdsWithOr(ids), null, null, null, "id",
            null, getForeignKeyAssociations(modelClass.getName(), isEager));
   }
   return dataList;
}
複製程式碼

Query

方法概覽

update

int onUpdate(DataSupport baseObj, long id) throws SecurityException, IllegalArgumentException,
      NoSuchMethodException, IllegalAccessException, InvocationTargetException {
   List<Field> supportedFields = getSupportedFields(baseObj.getClassName());
   List<Field> supportedGenericFields = getSupportedGenericFields(baseObj.getClassName());
       updateGenericTables(baseObj, supportedGenericFields, id);
   ContentValues values = new ContentValues();
   //轉換成員賓亮
   putFieldsValue(baseObj, supportedFields, values);
   //設定預設值
   putFieldsToDefaultValue(baseObj, values, id);
   if (values.size() > 0) {
      return mDatabase.update(baseObj.getTableName(), values, "id = " + id, null);
   }
   return 0;
}
複製程式碼

qanalyzeAssociations

	private void analyzeAssociations(DataSupport baseObj) {
		try {
			Collection<AssociationsInfo> associationInfos = getAssociationInfo(baseObj
					.getClassName());
          //關聯表查詢
			analyzeAssociatedModels(baseObj, associationInfos);
		} catch (Exception e) {
			throw new DataSupportException(e.getMessage(), e);
		}
	}
複製程式碼

DeleteHandler

方法概覽

onDelete

int onDelete(Class<?> modelClass, long id) {
  //獲取泛型變數集合
   List<Field> supportedGenericFields = getSupportedGenericFields(modelClass.getName());
   //刪除關聯表
    deleteGenericData(modelClass, supportedGenericFields, id);
   //分析關聯表
   analyzeAssociations(modelClass);
   int rowsAffected = deleteCascade(modelClass, id);
   rowsAffected += mDatabase.delete(getTableName(modelClass),"id = " + id, null);
  //刪除關聯表中的資料
   getForeignKeyTableToDelete().clear();
   return rowsAffected;
}
複製程式碼

AsyncExecutor

如果只是對少量的資料進行操作，實際上在主執行緒中操作是沒有問題的，但是如果是大量的資料，那麼就會比較耗時，所以就必須在子執行緒中進行，所以LitePal支援在子執行緒中進行DB操作。

繼承關係

AsyncExecutor

public abstract class AsyncExecutor {

    //後臺Runnable
    private Runnable pendingTask;
   //提交一個任務
    public void submit(Runnable task) {
        pendingTask = task;
    }
   //開啟執行緒
    void execute() {
        if (pendingTask != null) {
            new Thread(pendingTask).start();
        }
    }

}
複製程式碼

AverageExecutor

//回撥的介面
public interface AverageCallback {
    void onFinish(double average);
}

public class AverageExecutor extends AsyncExecutor {
    private AverageCallback cb;
   //開啟執行緒
    public void listen(AverageCallback callback) {
        cb = callback;
        execute();
    }
    public AverageCallback getListener() {
        return  cb;
    }

}


複製程式碼

使用方式

public static AverageExecutor averageAsync(final String tableName, final String column) {
    final AverageExecutor executor = new AverageExecutor();
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            synchronized (DataSupport.class) {
                final double average = average(tableName, column);
                if (executor.getListener() != null) {
                    LitePal.getHandler().post(new Runnable() {
                        @Override
                        public void run() {
                           //主執行緒中回撥
                            executor.getListener().onFinish(average);
                        }
                    });
                }
            }
        }
    };
    executor.submit(runnable);
    return executor;
}
複製程式碼

另外幾個Executor實際上也是這麼使用的，也就是在子執行緒中進行查詢完成，然後通過Handler將結果以post Runnable的形式傳遞到主執行緒，通過介面回撥傳遞操作的結果。

DataSupport

註釋

DataSupport connects classes to SQLite database tables to establish an almost zero-configuration persistence layer for applications. In the context of an application, these classes are commonly referred to as models. Models can also be connected to other models.
DataSupport relies heavily on naming in that it uses class and association names to establish mappings between respective database tables and foreign key columns.
Automated mapping between classes and tables, attributes and columns.
複製程式碼

DataSupport將類連線到SQLite資料庫的表以建立一個應用程式幾乎零配置的持久層。在應用的Context中，這些類被定義為Module，Module也可以跟別的Modules產生聯絡。

DataSupport嚴重依賴於它使用類和關聯的命名。在資料庫表和外部表之間建立對映的名稱，外來鍵。

在類和表、屬性和列之間的自動對映。

delete&deleteAsync

public static synchronized int delete(Class<?> modelClass, long id) {
   int rowsAffected = 0;
   SQLiteDatabase db = Connector.getDatabase();
   db.beginTransaction();
   try {
     //呼叫了DeleteHandler
      DeleteHandler deleteHandler = new DeleteHandler(db);
      rowsAffected = deleteHandler.onDelete(modelClass, id);
      db.setTransactionSuccessful();
      return rowsAffected;
   } finally {
      db.endTransaction();
   }
}
複製程式碼

saveAll&saveAllAsync

public static synchronized <T extends DataSupport> void saveAll(Collection<T> collection) {
   SQLiteDatabase db = Connector.getDatabase();
   db.beginTransaction();
   try {
     //呼叫了SaveHandler
      SaveHandler saveHandler = new SaveHandler(db);
      saveHandler.onSaveAll(collection);
      db.setTransactionSuccessful();
   } catch (Exception e) {
      throw new DataSupportException(e.getMessage(), e);
   } finally {
      db.endTransaction();
   }
}
複製程式碼

update&updateAsync

 */
public synchronized int update(long id) {
   try {
     //呼叫了UpdateHandler
      UpdateHandler updateHandler = new UpdateHandler(Connector.getDatabase());
      int rowsAffected = updateHandler.onUpdate(this, id);
      getFieldsToSetToDefault().clear();
      return rowsAffected;
   } catch (Exception e) {
      throw new DataSupportException(e.getMessage(), e);
   }
}
複製程式碼

average&averageAsync

public static synchronized double average(String tableName, String column) {
   ClusterQuery cQuery = new ClusterQuery();
   return cQuery.average(tableName, column);
}
複製程式碼

接著呼叫了ClusterQuery的average方法，ClusterQuery然後呼叫了QueryHandler的方法

public synchronized double average(String tableName, String column) {
   QueryHandler queryHandler = new QueryHandler(Connector.getDatabase());
   return queryHandler.onAverage(tableName, column, mConditions);
}

複製程式碼

max&maxAsync

public static synchronized <T> T max(String tableName, String columnName, Class<T> columnType) {
   ClusterQuery cQuery = new ClusterQuery();
   return cQuery.max(tableName, columnName, columnType);
}
複製程式碼

接著呼叫了ClusterQuery的max方法，ClusterQuery然後呼叫了max的方法

public synchronized <T> T max(String tableName, String columnName, Class<T> columnType) {
   QueryHandler queryHandler = new QueryHandler(Connector.getDatabase());
   return queryHandler.onMax(tableName, columnName, mConditions, columnType);
}
複製程式碼

CRUD操作

DataSupport是所有對映的物件的父類，定義了所有的關於DB的操作方法，並且每個操作都有同步跟非同步方法，非同步方法最終還是會呼叫同步方法，只是在呼叫的時候加了一個同步鎖，有點類似Picasso的單例，可以是單個物件也就是某一列的操作，也可以是對整個DB的操作，如果是基本的CRUD操作，那麼DataSupport會直接呼叫DataHandler的相應的子類的相應的方法去執行。

聚合查詢

如果是聚合查詢，也就是說需要多個條件的查詢，LitePal提供了一個類ClusterQuery，可以設定多個查詢條件，並且採用了Builder設計模式可以動態的設定查詢條件，類似average，count，limit等操作，下面會重點分析一下這個類。

ClusterQuery

註釋

Allows developers to query tables with cluster style.
複製程式碼

讓開發者能夠以聚集的風格進行查詢。

這段確實不知道怎麼翻譯，不過意思就是能夠進行聚合查詢。

成員變數

//查詢的列
String[] mColumns;
//查詢條件
String[] mConditions;
//排序條件
String mOrderBy;
//返回資料的數量
String mLimit;
//偏移量，也就是第幾列開始查詢
String mOffset;
複製程式碼

構造方法

ClusterQuery() {
}
複製程式碼

空方法，可以讓外部例項化

Builder

//設定要查詢的列
public ClusterQuery select(String... columns) {
    mColumns = columns;
    return this;
}
//設定查詢條件
public ClusterQuery where(String... conditions) {
    mConditions = conditions;
    return this;
}

//設定排序準則
public ClusterQuery order(String column) {
    mOrderBy = column;
    return this;
}

//設定返回資料的數量
public ClusterQuery limit(int value) {
    mLimit = String.valueOf(value);
    return this;
}

//設定偏移量
public ClusterQuery offset(int value) {
    mOffset = String.valueOf(value);
    return this;
}

複製程式碼

ClusterQuery採用了Builder模式，可以動態地進行新增引數，也就是實現連綴查詢，查詢起來比較方便。

count&countAsync

public CountExecutor countAsync(final String tableName) {
    final CountExecutor executor = new CountExecutor();
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            synchronized (DataSupport.class) {
              //同步獲取查詢結果
                final int count = count(tableName);
                if (executor.getListener() != null) {
                    LitePal.getHandler().post(new Runnable() {
                        @Override
                        public void run() {
                            executor.getListener().onFinish(count);
                        }
                    });
                }
            }
        }
    };
    executor.submit(runnable);
    return executor;
}
複製程式碼

追一下count方法，呼叫了QueryHandler方法

public synchronized int count(String tableName) {
    QueryHandler queryHandler = new QueryHandler(Connector.getDatabase());
   //然後新增了構造時候的引數
    return queryHandler.onCount(tableName, mConditions);
}

複製程式碼

min&minAsync

public <T> FindExecutor minAsync(final String tableName, final String columnName, final Class<T> columnType) {
    final FindExecutor executor = new FindExecutor();
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            synchronized (DataSupport.class) {
              //同步獲取最小值的查詢結果
                final T t = min(tableName, columnName, columnType);
                if (executor.getListener() != null) {
                    LitePal.getHandler().post(new Runnable() {
                        @Override
                        public void run() {
                          //回撥通知主執行緒
                            executor.getListener().onFinish(t);
                        }
                    });
                }
            }
        }
    };
    executor.submit(runnable);
    return executor;
}

複製程式碼

追一下min方法

public synchronized <T> T min(String tableName, String columnName, Class<T> columnType) {
    QueryHandler queryHandler = new QueryHandler(Connector.getDatabase());
     //然後新增了構造時候的查詢引數
    return queryHandler.onMin(tableName, columnName, mConditions, columnType);
}

複製程式碼

Utils

CipherUtil

這個主要用來進行加解密的，LitePal採用的是AES加密演算法，而且加密的key可以在LitePal中進行動態設定，不過也支援MD5加密，不過MD5無法解密，不過好像可以用來對DB的名稱進行加密。

//AES加密
public static String aesEncrypt(String plainText) {
    if (TextUtils.isEmpty(plainText)) {
        return plainText;
    }
    try {
        return AESCrypt.encrypt(aesKey, plainText);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
//AES解密
public static String aesDecrypt(String encryptedText) {
    if (TextUtils.isEmpty(encryptedText)) {
        return encryptedText;
    }
    try {
        return AESCrypt.decrypt(aesKey, encryptedText);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
//MD5加密
public static String md5Encrypt(String plainText) {
    try {
        MessageDigest digest = MessageDigest.getInstance("MD5");
        digest.update(plainText.getBytes(Charset.defaultCharset()));
        return new String(toHex(digest.digest()));
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return "";
}
複製程式碼

BaseUtility

基本的工具類，封裝了一些最基本的方法

• changeCase：對傳入的String進行大小寫轉換，或者保持不變
• checkConditionsCorrect：檢查查詢條件是否合理
• isFieldTypeSupported：檢查成員變數是否合理

DBUtility

• getTableNameByClassName：通過類名獲取表名
• isTableExists：查詢表是否存在

SharedUtil

• updateVersion：根據Key升級當前版本號
• getLastVersion：根據Key獲取上一個版本
• removeVersion：根據Key移除特定的版本

總結

LitePal利用反射對獲取Model的屬性，然後拼接成SQL語句，對於呼叫者來說減少了很多重複性操作，升級也比較方便，符合Java的物件導向，使用者不用再關心底層的SQL語句，當然LitePal同時也提供了使用SQL語句查詢的功能，使用者可以憑喜好使用，看了SQL的原始碼實現之後，個人覺得有些地方可以改進。

反射優化

LitePal的CRUD操作每次都需要反射，這些在資料量少的時候影響還好，在資料量較大的時候會比較影響效率，可以對已經反射過的Model屬性快取起來，那麼下一次CRUD操作的時候如果是同一個Model，那麼直接從快取中取，那麼效率就會快一些。

同步優化

LitePal的CRUD操作全部都使用了synchronized關鍵字，其實如果我們的操作是單執行緒中進行，沒必要上鎖，可以再提供一個過載的非同步方法，因為很多時候CRUD操作都是在單執行緒中的。

單例優化

LitePal的每一次CRUD操作，都需要對DataHandler的子類SaveHandler、QueryHandler進行一次例項化，如果採用單例結合Builder模式的話可以減少一部分開銷，還有ClusterQuery也是如此。

執行緒池優化

LitePal開啟多執行緒的時候是採用的new Thread方式，如果有多個非同步的DB操作的時候，會建立很多個執行緒，如果使用執行緒池可以減少一部分開銷。

其實上面的一些建議只是我個人的理解，LitePal已經是一款很優秀的框架，希望LitePal越來越好。