Android 輕量級ORM資料庫開源框架ActiveAndroid 原始碼分析

希爾瓦娜斯女神發表於2015-08-28

AndroidORM資料庫框架原始碼

ActiveAndroid 專案地址在https://github.com/pardom/ActiveAndroid

關於他的詳細介紹和使用步驟可以看下面兩篇文章：

https://github.com/pardom/ActiveAndroid/wiki

http://www.future-processing.pl/blog/persist-your-data-activeandroid-and-parse/

請確保你在閱讀本文下面的內容之前熟讀上面的2篇文章。我不會再講一遍如何使用這個框架。

另外由於這個專案的作者已經多時不更新，所以在android studio 裡直接引用的話會有些麻煩

請確保使用我的程式碼保證你可以正常引用並使用這個框架。

 1 repositories {
 2     mavenCentral()
 3     maven { url "https://oss.sonatype.org/content/repositories/snapshots/" }
 4 }
 5 
 6 
 7 dependencies {
 8     compile fileTree(dir: 'libs', include: ['*.jar'])
 9     compile 'com.android.support:appcompat-v7:22.2.1'
10     compile 'com.michaelpardo:activeandroid:3.1.0-SNAPSHOT'
11     //compile ':ActiveAndroid'
12 }

然後我們來剖析他的原始碼，看看他的工作機理是什麼。

首先看資料庫是如何建立的？

 1 public static void initialize(Context context) {
 2         initialize(new Configuration.Builder(context).create());
 3     }
 4 
 5     public static void initialize(Configuration configuration) {
 6         initialize(configuration, true);
 7     }
 8 
 9     public static void initialize(Context context, boolean loggingEnabled) {
10         initialize(new Configuration.Builder(context).create(), loggingEnabled);
11     }
12 
13     public static void initialize(Configuration configuration, boolean loggingEnabled) {
14         // Set logging enabled first
15         setLoggingEnabled(loggingEnabled);
16         Cache.initialize(configuration);
17     }

看第10行，這個地方有一個Configuration的類還有個create方法。

我們貼以下create方法

 1   public Configuration create() {
 2             Configuration configuration = new Configuration(mContext);
 3             configuration.mCacheSize = mCacheSize;
 4 
 5             // Get database name from meta-data
 6             if (mDatabaseName != null) {
 7                 configuration.mDatabaseName = mDatabaseName;
 8             } else {
 9                 configuration.mDatabaseName = getMetaDataDatabaseNameOrDefault();
10             }
12 
13             // Get database version from meta-data
14             if (mDatabaseVersion != null) {
15                 configuration.mDatabaseVersion = mDatabaseVersion;
16             } else {
17                 configuration.mDatabaseVersion = getMetaDataDatabaseVersionOrDefault();
18             }
20 
21             // Get SQL parser from meta-data
22             if (mSqlParser != null) {
23                 configuration.mSqlParser = mSqlParser;
24             } else {
25                 configuration.mSqlParser = getMetaDataSqlParserOrDefault();
26             }
27 
28             // Get model classes from meta-data
29             if (mModelClasses != null) {
30                 configuration.mModelClasses = mModelClasses;
31             } else {
32                 final String modelList = ReflectionUtils.getMetaData(mContext, AA_MODELS);
34                 if (modelList != null) {
35                     configuration.mModelClasses = loadModelList(modelList.split(","));
36                 }
37             }
38 
39             // Get type serializer classes from meta-data
40             if (mTypeSerializers != null) {
41                 configuration.mTypeSerializers = mTypeSerializers;
42             } else {
43                 final String serializerList = ReflectionUtils.getMetaData(mContext, AA_SERIALIZERS);
44                 if (serializerList != null) {
45                     configuration.mTypeSerializers = loadSerializerList(serializerList.split(","));
46                 }
47             }
48 
49             return configuration;
50         }

所以就能看出來這個create方法就是去讀取我們的配置檔案裡的內容的。比如

但實際上個人認為這樣做並不是特別好的方案，比如AA_MODELS，如果你的app 需要的表比較多，那這裡android:value那邊裡面因為要寫model的全名就是包名+類名

這麼做會導致這個value裡的字串非常的長，而且難以維護，比較好的寫法我認為是要把這個配置檔案單獨放在assets目錄下面新建一個xml檔案，去讀取比較好。

有興趣的讀者可以嘗試修改一下這邊的邏輯。

當我們讀取結束配置檔案以後我們會繼續呼叫cache.init這個方法

 1  public static synchronized void initialize(Configuration configuration) {
 2         if (sIsInitialized) {
 3             return;
 4         }
 5         sContext = configuration.getContext();
 6         sModelInfo = new ModelInfo(configuration);
 7         sDatabaseHelper = new DatabaseHelper(configuration);
 8 
 9         // TODO: It would be nice to override sizeOf here and calculate the memory
10         // actually used, however at this point it seems like the reflection
11         // required would be too costly to be of any benefit. We'll just set a max
12         // object size instead.
13         sEntities = new LruCache<String, Model>(configuration.getCacheSize());
14 
15         openDatabase();
16 
17         sIsInitialized = true;
18 
19         Log.v("ActiveAndroid initialized successfully.");
20     }

在這個裡面我們找到了databaseHelper。看來建立資料庫和表的關鍵部分就在這裡面了。而且要注意databasehelper是用config 我們讀取出來的那些配置資料來初始化的。

1  @Override
2     public void onCreate(SQLiteDatabase db) {
3         executePragmas(db);
4         executeCreate(db);
5         executeMigrations(db, -1, db.getVersion());
6         executeCreateIndex(db);
7     }

private void executeCreate(SQLiteDatabase db) {
        db.beginTransaction();
        try {
            for (TableInfo tableInfo : Cache.getTableInfos()) {
                String sql = SQLiteUtils.createTableDefinition(tableInfo);
                db.execSQL(sql);
            }
            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
    }

實際上在這個地方就已經把我們取得的config資料遍歷以後組成我們的sql語句去初始化我們的資料庫以及表了。

除此之外，我們當然也可以用sql指令碼的方式來建表，尤其是在資料庫升級的時候，直接匯入指令碼來升級也是非常簡便的。

此框架，也要求我們將sql指令碼放在app assets migrations 目錄下.此指令碼必須.sql為結尾。字首可以用阿拉伯數字

還表示指令碼的版本號。

我們來走一遍資料庫升級時的指令碼流程。

 1 private boolean executeMigrations(SQLiteDatabase db, int oldVersion, int newVersion) {
 2         boolean migrationExecuted = false;
 3         try {
 4             final List<String> files = Arrays.asList(Cache.getContext().getAssets().list(MIGRATION_PATH));
 5             Collections.sort(files, new NaturalOrderComparator());
 6 
 7             db.beginTransaction();
 8             try {
 9                 for (String file : files) {
10                     try {
11                         final int version = Integer.valueOf(file.replace(".sql", ""));
12                         if (version > oldVersion && version <= newVersion) {
13                             executeSqlScript(db, file);
14                             migrationExecuted = true;
15 
16                             Log.i(file + " executed succesfully.");
17                         }
18                     } catch (NumberFormatException e) {
19                         Log.w("Skipping invalidly named file: " + file, e);
20                     }
21                 }
22                 db.setTransactionSuccessful();
23             } finally {
24                 db.endTransaction();
25             }
26         } catch (IOException e) {
27             Log.e("Failed to execute migrations.", e);
28         }
29 
30         return migrationExecuted;
31     }

4行拿到assets下mig路徑下的所有檔案並且排序以後進行遍歷符合條件的會在13行執行指令碼。

12行就是判斷是否需要進行資料庫升級指令碼操作的判斷條件。可以自己體會下為什麼要這麼寫，

當然我個人意見是你在使用此框架的時候關於資料庫升級的部分可以自定義。尤其是在做一些

複雜的電商，聊天之類的app時候，表關係複雜，並且時有升級。

到目前為止，我們已經過了一遍此框架建立資料庫建立升級表的過程。

然後我們來看一下這個框架是如何執行crud 操作的。我們只分析add和selet操作。其他操作留給讀者自己分析。

一般我們建立的model都如下

1     public Model() {
2         mTableInfo = Cache.getTableInfo(getClass());
3         idName = mTableInfo.getIdName();
4     }

實際上我們的model 在初始化的時候會把自己的class 在建構函式裡面傳到cache裡，這樣我們在model裡面就能拿到我們對應的表的資訊了。

這個model的建構函式就是做這件事的。那拿到這個表資訊以後進行save操作就是非常簡單的了。

 1  public final Long save() {
 2         final SQLiteDatabase db = Cache.openDatabase();
 3         final ContentValues values = new ContentValues();
 4 
 5         for (Field field : mTableInfo.getFields()) {
 6             final String fieldName = mTableInfo.getColumnName(field);
 7             Class<?> fieldType = field.getType();
 8             field.setAccessible(true);
 9 
10             try {
11                 Object value = field.get(this);
12 
13                 if (value != null) {
14                     final TypeSerializer typeSerializer = Cache.getParserForType(fieldType);
15                     if (typeSerializer != null) {
16                         // serialize data
17                         value = typeSerializer.serialize(value);
18                         // set new object type
19                         if (value != null) {
20                             fieldType = value.getClass();
21                             // check that the serializer returned what it promised
22                             if (!fieldType.equals(typeSerializer.getSerializedType())) {
23                                 Log.w(String.format("TypeSerializer returned wrong type: expected a %s but got a %s",
24                                         typeSerializer.getSerializedType(), fieldType));
25                             }
26                         }
27                     }
28                 }
29 
30                 // TODO: Find a smarter way to do this? This if block is necessary because we
31                 // can't know the type until runtime.
32                 if (value == null) {
33                     values.putNull(fieldName);
34                 } else if (fieldType.equals(Byte.class) || fieldType.equals(byte.class)) {
35                     values.put(fieldName, (Byte) value);
36                 } else if (fieldType.equals(Short.class) || fieldType.equals(short.class)) {
37                     values.put(fieldName, (Short) value);
38                 } else if (fieldType.equals(Integer.class) || fieldType.equals(int.class)) {
39                     values.put(fieldName, (Integer) value);
40                 } else if (fieldType.equals(Long.class) || fieldType.equals(long.class)) {
41                     values.put(fieldName, (Long) value);
42                 } else if (fieldType.equals(Float.class) || fieldType.equals(float.class)) {
43                     values.put(fieldName, (Float) value);
44                 } else if (fieldType.equals(Double.class) || fieldType.equals(double.class)) {
45                     values.put(fieldName, (Double) value);
46                 } else if (fieldType.equals(Boolean.class) || fieldType.equals(boolean.class)) {
47                     values.put(fieldName, (Boolean) value);
48                 } else if (fieldType.equals(Character.class) || fieldType.equals(char.class)) {
49                     values.put(fieldName, value.toString());
50                 } else if (fieldType.equals(String.class)) {
51                     values.put(fieldName, value.toString());
52                 } else if (fieldType.equals(Byte[].class) || fieldType.equals(byte[].class)) {
53                     values.put(fieldName, (byte[]) value);
54                 } else if (ReflectionUtils.isModel(fieldType)) {
55                     values.put(fieldName, ((Model) value).getId());
56                 } else if (ReflectionUtils.isSubclassOf(fieldType, Enum.class)) {
57                     values.put(fieldName, ((Enum<?>) value).name());
58                 }
59             } catch (IllegalArgumentException e) {
60                 Log.e(e.getClass().getName(), e);
61             } catch (IllegalAccessException e) {
62                 Log.e(e.getClass().getName(), e);
63             }
64         }
65 
66         if (mId == null) {
67             mId = db.insert(mTableInfo.getTableName(), null, values);
68         } else {
69             db.update(mTableInfo.getTableName(), values, idName + "=" + mId, null);
70         }
71 
72         Cache.getContext().getContentResolver()
73                 .notifyChange(ContentProvider.createUri(mTableInfo.getType(), mId), null);
74         return mId;
75     }

思路就是利用反射來拿到值以後進行資料庫操作，10-29行有一段關於序列化的程式碼我放在後面再講。先繼續看select操作吧。

比如說我們一般的select操作都是這樣的

來看一下select的from方法。

public From from(Class<? extends Model> table) {
        return new From(table, this);
    }

原來是利用我們傳進去的class名字來構造真正的查詢物件。

 1 public final class From implements Sqlable {
 2     private Sqlable mQueryBase;
 3 
 4     private Class<? extends Model> mType;
 5     private String mAlias;
 6     private List<Join> mJoins;
 7     private final StringBuilder mWhere = new StringBuilder();
 8     private String mGroupBy;
 9     private String mHaving;
10     private String mOrderBy;
11     private String mLimit;
12     private String mOffset;
13 
14     private List<Object> mArguments;
15 
16     public From(Class<? extends Model> table, Sqlable queryBase) {
17         mType = table;
18         mJoins = new ArrayList<Join>();
19         mQueryBase = queryBase;
20 
21         mJoins = new ArrayList<Join>();
22         mArguments = new ArrayList<Object>();
23     }

最終的excute方法

 1 public <T extends Model> List<T> execute() {
 2         if (mQueryBase instanceof Select) {
 3             return SQLiteUtils.rawQuery(mType, toSql(), getArguments());
 4             
 5         } else {
 6             SQLiteUtils.execSql(toSql(), getArguments());
 7             Cache.getContext().getContentResolver().notifyChange(ContentProvider.createUri(mType, null), null);
 8             return null;
 9             
10         }
11     }

query這邊的程式碼我認為寫的非常巧妙清晰，篇幅所限我無法講的太細，你們可以觀察下程式碼結構自己回去多翻翻

回到我們剛才講save操作時候看到有幾行序列化的程式碼，實際上那邊的程式碼是用來建立物件和資料庫原始資料關係的。

比如我們有個學生model，我們希望有個欄位來存放這個學生的手機 pad以及電腦的品牌，當然為了表示簡潔，我們這個欄位

可以用一段json String來表示。但是我們在model裡又不希望直接用string，我們希望用一個物件來表示。就可以用

“序列化” 和“反序列化” 來表示他們之間的關係。

我們首先來建立一個學生物品類

 1 package com.example.administrator.myapplication5;
 2 
 3 import org.json.JSONException;
 4 import org.json.JSONObject;
 5 
 6 /**
 7  * Created by Administrator on 2015/8/28.
 8  */
 9 public class PersonalItems {
10     private String computerBand;
11     private String phoneBand;
12     private String padBand;
13 
14     public String getComputerBand() {
15         return computerBand;
16     }
17 
18     public void setComputerBand(String computerBand) {
19         this.computerBand = computerBand;
20     }
21 
22     public String getPhoneBand() {
23         return phoneBand;
24     }
25 
26     public void setPhoneBand(String phoneBand) {
27         this.phoneBand = phoneBand;
28     }
29 
30     public String getPadBand() {
31         return padBand;
32     }
33 
34     public void setPadBand(String padBand) {
35         this.padBand = padBand;
36     }
37 
38     @Override
39     public String toString() {
40 
41         JSONObject jsonObject = new JSONObject();
42         try {
43             jsonObject.put("computerBand", computerBand);
44             jsonObject.put("padBand", padBand);
45             jsonObject.put("phoneBand", phoneBand);
46 
47         } catch (JSONException e) {
48             e.printStackTrace();
49         }
50 
51 
52         return jsonObject.toString();
53     }
54 }

然後我們在model裡也建立這個物件。

 1 package com.example.administrator.myapplication5;
 2 
 3 import com.activeandroid.Model;
 4 import com.activeandroid.annotation.Column;
 5 import com.activeandroid.annotation.Table;
 6 
 7 import java.util.Date;
 8 
 9 /**
10  * Created by Administrator on 2015/8/27.
11  */
12 @Table(name = "Student")
13 public class Student extends Model {
14     @Column(name = "Name")
15     public String name;
16     @Column(name = "No")
17     public String no;
18     @Column(name = "sex")
19     public int sex;
20     @Column(name = "date")
21     public Date date;
22 
23     @Column(name = "personalItems")
24     public PersonalItems personalItems;
25 
26     @Override
27     public String toString() {
28         return "Student{" +
29                 "name='" + name + '\'' +
30                 ", no='" + no + '\'' +
31                 ", sex=" + sex +
32                 ", date=" + date +
33                 ", personalItems=" + personalItems +
34                 '}';
35     }
36 }

然後我們來建立兩者之間的關係類！這個是核心。

 1 package com.activeandroid.serializer;
 2 
 3 import com.example.administrator.myapplication5.PersonalItems;
 4 
 5 import org.json.JSONException;
 6 import org.json.JSONObject;
 7 
 8 /**
 9  * Created by Administrator on 2015/8/28.
10  */
11 public class PersonalItemsSerializer extends TypeSerializer {
12 
13     @Override
14     public Class<?> getDeserializedType() {
15         return PersonalItems.class;
16     }
17 
18     @Override
19     public Class<?> getSerializedType() {
20         return String.class;
21     }
22 
23     @Override
24     public String serialize(Object data) {
25         if (data == null) {
26             return null;
27         }
28         String str = data.toString();
29 
30         return str;
31     }
32 
33     @Override
34     public PersonalItems deserialize(Object data) {
35         if (data == null) {
36             return null;
37         }
38         PersonalItems personalItems = new PersonalItems();
39         try {
40             JSONObject dataJson = new JSONObject(data.toString());
41             personalItems.setComputerBand(dataJson.getString("computerBand"));
42             personalItems.setPadBand(dataJson.getString("padBand"));
43             personalItems.setPhoneBand(dataJson.getString("phoneBand"));
44         } catch (JSONException e) {
45             e.printStackTrace();
46         }
47         return personalItems;
48     }
49 }

程式碼還是很清楚的，複寫的幾個方法就是要求你寫一下序列和反序列化的過程罷了。（物件----資料庫欄位的關係就是在這建立的）

當然你寫完了還要在配置檔案裡配置一下。不然系統會找不到這個序列化類的。這個過程我就不分析了，留著大家有興趣可以自己寫一個。

我們主要看一下那個save操作裡的過程

 1 for (Field field : mTableInfo.getFields()) {
 2             final String fieldName = mTableInfo.getColumnName(field);
 3             Class<?> fieldType = field.getType();
 4             field.setAccessible(true);
 5 
 6             try {
 7                 Object value = field.get(this);
 8 
 9                 if (value != null) {
10                     final TypeSerializer typeSerializer = Cache.getParserForType(fieldType);
11                     if (typeSerializer != null) {
12                         // serialize data
13                         value = typeSerializer.serialize(value);
14                         // set new object type
15                         if (value != null) {
16                             fieldType = value.getClass();
17                             // check that the serializer returned what it promised
18                             if (!fieldType.equals(typeSerializer.getSerializedType())) {
19                                 Log.w(String.format("TypeSerializer returned wrong type: expected a %s but got a %s",
20                                         typeSerializer.getSerializedType(), fieldType));
21                             }
22                         }
23                     }
24                 }

第三行我們拿到了 fieldType 注意此時他的值實際上就是我們物件所屬的類的名字！

第10行去cache裡找對應關係類，看看有沒有對應的這個類的序列化工作器。

第13行表明如果找到這個序列化工作器的話就用他把這個value的值轉換成資料庫能接受的值！

第15行表明如果序列化成功的話，fieldType的值也要改成資料庫也就是sqlite能接受的型別！

然後才能用下面的程式碼進行插入操作！

 1 if (value == null) {
 2                     values.putNull(fieldName);
 3                 } else if (fieldType.equals(Byte.class) || fieldType.equals(byte.class)) {
 4                     values.put(fieldName, (Byte) value);
 5                 } else if (fieldType.equals(Short.class) || fieldType.equals(short.class)) {
 6                     values.put(fieldName, (Short) value);
 7                 } else if (fieldType.equals(Integer.class) || fieldType.equals(int.class)) {
 8                     values.put(fieldName, (Integer) value);
 9                 } else if (fieldType.equals(Long.class) || fieldType.equals(long.class)) {
10                     values.put(fieldName, (Long) value);
11                 } else if (fieldType.equals(Float.class) || fieldType.equals(float.class)) {
12                     values.put(fieldName, (Float) value);
13                 } else if (fieldType.equals(Double.class) || fieldType.equals(double.class)) {
14                     values.put(fieldName, (Double) value);
15                 } else if (fieldType.equals(Boolean.class) || fieldType.equals(boolean.class)) {
16                     values.put(fieldName, (Boolean) value);
17                 } else if (fieldType.equals(Character.class) || fieldType.equals(char.class)) {
18                     values.put(fieldName, value.toString());
19                 } else if (fieldType.equals(String.class)) {
20                     values.put(fieldName, value.toString());
21                 } else if (fieldType.equals(Byte[].class) || fieldType.equals(byte[].class)) {
22                     values.put(fieldName, (byte[]) value);
23                 } else if (ReflectionUtils.isModel(fieldType)) {
24                     values.put(fieldName, ((Model) value).getId());
25                 } else if (ReflectionUtils.isSubclassOf(fieldType, Enum.class)) {
26                     values.put(fieldName, ((Enum<?>) value).name());
27                 }

至於selcet操作時反序列化的操作就留給讀者自己分析了。

其實這個框架本身已經提供了不少好用的工作器給我們使用了(第四個是我剛才定義的請大家忽略掉哈哈)。

最後由於這個框架大量使用的註解反射導致效率肯定比不上自己直接寫sql，不過可以接受，儘管如此還是請儘量在子執行緒裡去運算元據庫！重要的話只說一遍！

【Android開源專案分析】android輕量級開源快取框架——ASimpleCache（ACache）原始碼分析
2017-11-03
Android快取框架原始碼
輕量級orm框架——gzero指南
2022-01-22
ORM框架
開源輕量級 PHP 資料庫 ORM 框架 ycdb (高階) : 構建穩定的資料庫 / 快取連線池
2018-12-28
PHP資料庫ORM框架快取
Android ORM 框架：GreenDao 資料庫升級
2017-07-04
AndroidORM框架資料庫
PhalApi(π框架) - PHP輕量級開源介面框架
2017-05-04
API框架PHP
LambdaToSql(輕量級ORM) 入門篇開源專案
2021-09-09
SQLORM
輕量級.NET ORM、高效能.NET ORM 之 SqlSugar 開源ORM - ASP.NET
2015-07-22
ORMSqlSugarASP.NET
Spring 5| 輕量級的開源JavaEE框架
2021-12-20
SpringJava框架
58同城開源其輕量級Web框架Argo
2013-03-21
Web框架Go
開源一個基於dotnet standard的輕量級的ORM框架-Light.Data
2019-05-22
ORM框架
一個輕量級,0配置orm框架 sharkchili-feifei
2019-02-28
ORM框架
python輕量級orm框架 peewee常用功能速查
2021-09-12
PythonORM框架
Android開源原始碼分析
2018-04-28
Android原始碼
不想寫sql？試試這款輕量級JAVA ORM框架!
2021-03-02
SQLJavaORM框架
Room ORM 資料庫框架
2017-05-18
OOMORM資料庫框架
輕量級Android快取框架ASimpleCache
2014-11-08
Android快取框架
開源輕量級 IM 框架 MobileIMSDK v6.1.2 釋出！
2021-12-22
框架
輕量級 Web 框架 Gin 結構分析
2019-03-04
Web框架
sal原始碼解析-輕量級的滾動動畫庫
2019-01-07
原始碼動畫
Android開源資料庫框架-LitePal的使用
2017-03-29
Android資料庫框架
[開源] .Net ORM 訪問 Firebird 資料庫
2022-07-07
ORM資料庫
滴滴開源 DroidAssist : 輕量級 Android 位元組碼編輯外掛
2019-05-16
Android
larvael 引入第三方輕量級 PHP 資料庫框架 Medoo
2018-12-29
PHP資料庫框架
輕量級ORM框架——第一篇：Dapper快速學習
2018-12-02
ORM框架APP
Android開源框架原始碼鑑賞：VirtualAPK
2019-03-04
Android框架原始碼APK
android面試——開源框架的原始碼解析
2018-06-01
Android面試框架原始碼
Android開源框架原始碼鑑賞：Fresco
2018-02-03
Android框架原始碼
Android開源框架原始碼鑑賞：Okhttp
2018-01-30
Android框架原始碼HTTP
Android開源框架原始碼鑑賞：EventBus
2018-03-27
Android框架原始碼
桌面輕量級資料處理指令碼
2020-12-03
指令碼
Android資料庫一些原始碼分析
2015-05-21
Android資料庫原始碼
Oracle釋出開源的輕量級 Java 微服務框架 Helidon
2019-01-19
OracleJava微服務框架
Android開源庫——EventBus原始碼解析
2017-12-26
Android原始碼
一種輕量級的NoSQL資料庫PouchDB
2012-06-16
SQL資料庫
OracleSugar ORM框架的誕生，程式碼開源
2016-09-14
OracleORM框架
Python：輕量級 ORM 框架 peewee 用法詳解之——增刪改查
2019-02-27
PythonORM框架
Python：輕量級 ORM 框架 peewee 用法詳解（二）——增刪改查
2019-02-15
PythonORM框架
輕量級IOC框架：Ninject
2012-04-27
框架

Android 輕量級ORM資料庫開源框架ActiveAndroid 原始碼分析

相關文章