前言

上篇是Realm原始碼分析的開篇，是關於Realm資料庫的初始化，關鍵一點是要抓住RealmProxyMediator這個代理中介者的例項化過程。在理解了Realm初始化之後，接下來就可以追蹤Realm資料庫讀寫等操作的原始碼了。因篇幅限制，先分析Writes。

Realm Writes

1. 在基礎篇中提到過凡是繼承RealmObject的物件在Realm中被稱作Model，它對應著Realm資料庫中的一張表，而Model中的屬性對映著Realm資料庫表中的列。

2. 先建立一個的Model類，後面會以這個Model來分析Realm資料庫的讀寫相關的操作，其程式碼如下

   public class
    
    Dog extends RealmObject {
       private String name;
       private int age;
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this
    
   .age = age;
       }
   }

3. 檢視RealmObject原始碼，它的註釋很詳細，就不再贅述。注意到它是個抽象類，並實現了RealmModel與ManagableObject兩個介面。它還提供了不少方法，目前我們先忽略這些細節。另外RealmObject還使用RealmClass註解，推測應該會在自動生成程式碼的過程中被使用。如下縮略程式碼：

   一大堆的註釋
   ... ...
   @RealmClass
   public abstract class RealmObject implements RealmModel, ManagableObject {
       ... ...
   }

4. 再看RealmModel，它是個空介面，註釋說得很明白：實現這個介面的並標註RealmClass註解就能由註解處理器自動生成代理類。因此，我們可以推測自己寫的這個Dog類，應該會被註解處理器自動生成一個代理類。

   /**
   * Note: Object implementing this interface needs also to be annotated with {@link RealmClass}, 
   * so the annotation processor can generate the underlining proxy class.
   */
   public interface RealmModel {
   }

5. 而ManagableObject介面，按註釋的說法是用於判斷RealmObject物件例項的合法性，其程式碼如下：

    /**
    * This internal interface represents a java object that corresponds to data
    * that may be managed in the Realm core. It specifies the operations common to all such objects.
    */
   public interface ManagableObject {
       boolean isManaged();
       boolean isValid();
   }

6. 在瞭解了RealmObject類關係結構之後，再來建立RealmObject例項，程式碼如下：

   public void test() {
       realm.executeTransaction(new Realm.Transaction() {
           @Override
           public void execute(Realm realm) {
               Dog myDog = realm.createObject(Dog.class);
               myDog.setName("Fido");
               myDog.setAge(1);
           }
       });
   }

7. 上面的executeTransaction方法會同步執行事務操作，在回撥方法中就完成了Dog表的建立。先看看createObject方法：

   public <E extends RealmModel> E createObject(Class<E> clazz) {
       checkIfValid();
       return createObjectInternal(clazz, true, Collections.<String>emptyList());
   }

8. createObject做了兩件事：一是Realm執行環境檢查，而是呼叫了createObjectInternal：

   /**
    * Same as {@link #createObject(Class)} but this does not check the thread.
    *
    * @param clazz the Class of the object to create.
    * @param acceptDefaultValue if {@code true}, default value of the object will be applied and
    * if {@code false}, it will be ignored.
    * @return the new object.
    * @throws RealmException if the primary key is defined in the model class or an object cannot be created.
    */
   // Called from proxy classes.
   <E extends RealmModel> E createObjectInternal(
           Class<E> clazz,
           boolean acceptDefaultValue,
           List<String> excludeFields) {
       Table table = schema.getTable(clazz);
       // Checks and throws the exception earlier for a better exception message.
       if (table.hasPrimaryKey()) {
           throw new RealmException(String.format(Locale.US, "'%s' has a primary key, use" +
                   " 'createObject(Class<E>, Object)' instead.", table.getClassName()));
       }
       return configuration.getSchemaMediator().newInstance(clazz, this,
               OsObject.create(table),
               schema.getColumnInfo(clazz),
               acceptDefaultValue, excludeFields);
   }

9. 注意到createObjectInternal方法前面的最後一行註釋，說這個方法會被代理物件呼叫。它主要做了兩件事：一是建立了一張Table，直接呼叫Mediator建立目標物件。先看Table的類繼承關係：

   /**
    * This class is a base class for all Realm tables. The class supports all low level methods
    * (define/insert/delete/update) a table has. All the native communications to the Realm C++ 
    * library are also handled by this class.
    */
   public class Table implements TableSchema, NativeObject {
   ... ...
   }
   
   public interface TableSchema {
       long addColumn(RealmFieldType type, String name);
       void removeColumn(long columnIndex);
       void renameColumn(long columnIndex, String newName);
   }
   
   /**
    * This abstract class represents a native object from core.
    * It specifies the operations common to all such objects.
    * All Java classes wrapping a core class should implement NativeObject.
    */
   public interface NativeObject {
       long NULLPTR = 0L;
       long getNativePtr();
       long getNativeFinalizerPtr();
   }

10. 從上述原始碼與註釋，就可以將Table當作讀寫Realm Native層資料庫的API。繼續看Table的例項化程式碼：

    Table getTable(Class<? extends RealmModel> clazz) {
        //classToTable是個快取，因此首次建立Table是會執行到下面的程式碼。
        Table table = classToTable.get(clazz);
        if (table != null) { 
            return table; 
        }
        //獲取原始的ModelClass，即直接繼承RealmObject的那個model類，這裡的例項是Dog.class
        Class<? extends RealmModel> originalClass = Util.getOriginalModelClass(clazz);
        if (isProxyClass(originalClass, clazz)) {
            // If passed 'clazz' is the proxy, try again with model class.
            table = classToTable.get(originalClass);
        }
        //首次例項化會走到這裡，最終是其實是SharedRealm例項化了Table並快取起來，如下getTable原始碼
        if (table == null) {
            table = realm.getSharedRealm()
            .getTable(realm.getConfiguration().getSchemaMediator().getTableName(originalClass));
            classToTable.put(originalClass, table);
        }
        if (isProxyClass(originalClass, clazz)) {
            // 'clazz' is the proxy class for 'originalClass'.
            classToTable.put(clazz, table);
        }
    
        return table;
    }

    public final class SharedRealm implements Closeable, NativeObject {
       ... ...
       public Table getTable(String name) {
            //至此就Table就與Realm native資料庫關聯起來
            long tablePtr = nativeGetTable(nativePtr, name);
            return new Table(this, tablePtr);
        }
    
        // Throw IAE if the table doesn't exist.
        private static native long nativeGetTable(long nativeSharedRealmPtr, String tableName);
    }

11. Table的建立流程到此為止，回到9再看Mediator是如何建立目標Model物件的。基礎篇已經說過這個Mediator物件其實就是註解處理器知道生成的DefaultRealmModuleMediator，在我的例子中程式碼如下：

    @Override
    public <E extends RealmModel> E newInstance(Class<E> clazz, Object baseRealm, Row row, ColumnInfo columnInfo, boolean acceptDefaultValue, List<String> excludeFields) {
        final BaseRealm.RealmObjectContext objectContext = BaseRealm.objectContext.get();
        try {
            objectContext.set((BaseRealm) baseRealm, row, columnInfo, acceptDefaultValue, excludeFields);
            checkClass(clazz);
    
            if (clazz.equals(com.example.app.org.realm.demo.Dog.class)) {
                return clazz.cast(new io.realm.DogRealmProxy());
            }
            throw getMissingProxyClassException(clazz);
        } finally {
            objectContext.clear();
        }
    }

12. 注意上面方法中的Row例項的是由OsObject.create(table)建立的，看看這個方法的原始碼：

    public static UncheckedRow create(Table table) {
        final SharedRealm sharedRealm = table.getSharedRealm();
        return new UncheckedRow(sharedRealm.context, table,
                nativeCreateNewObject(sharedRealm.getNativePtr(), table.getNativePtr()));
    }

13. 再回到11中的程式碼，newInstance建立的不是Dog例項，而是其子類DogRealmProxy的例項。而DogRealmProxy則是由註解處理器自動生成，如下部分程式碼：

    public class DogRealmProxy extends com.example.app.org.realm.demo.Dog implements RealmObjectProxy, DogRealmProxyInterface {
    
        ... ...
    
        private ProxyState<com.example.app.org.realm.demo.Dog> proxyState;      
        ... ... 
    
        DogRealmProxy() {
            //這裡的寫法比較神奇，realm$injectObjectContext一定是比較早在此直接注入的
            proxyState.setConstructionFinished();
        }
    
            @Override
        public void realm$injectObjectContext() {
            if (this.proxyState != null) {
                return;
            }
            final BaseRealm.RealmObjectContext context = BaseRealm.objectContext.get();
            this.columnInfo = (DogColumnInfo) context.getColumnInfo();
            this.proxyState = new ProxyState<com.example.app.org.realm.demo.Dog>(this);
            proxyState.setRealm$realm(context.getRealm());
            proxyState.setRow$realm(context.getRow());
            proxyState.setAcceptDefaultValue$realm(context.getAcceptDefaultValue());
            proxyState.setExcludeFields$realm(context.getExcludeFields());
        }
    
        ... ...
    
    }

    public interface RealmObjectProxy extends RealmModel {
        void realm$injectObjectContext();
    
        ProxyState realmGet$proxyState();
    
        /**
         * Tuple class for saving meta data about a cached RealmObject.
         */
        class CacheData<E extends RealmModel> {
            public int minDepth;
            public final E object;
    
            public CacheData(int minDepth, E object) {
                this.minDepth = minDepth;
                this.object = object;
            }
        }
    }

    public interface DogRealmProxyInterface {
        public String realmGet$name();
        public void realmSet$name(String value);
        public int realmGet$age();
        public void realmSet$age(int value);
    }

14. 注意在上面的程式碼中，並沒有發現在java程式碼中直接呼叫realm$injectObjectContext()，依據個人經驗推測是在構建過程中注入的。通過搜尋，發現在realm-transformer模組下的BytecodeModifier.groovy中找到了線索，如下兩個方法：

    /**
     * Modifies a class adding its RealmProxy interface.
     *
     * @param clazz The CtClass to modify
     * @param classPool the Javassist class pool
     */
    public static void addRealmProxyInterface(CtClass clazz, ClassPool classPool) {
        def proxyInterface = classPool.get("io.realm.${clazz.getSimpleName()}RealmProxyInterface")
        clazz.addInterface(proxyInterface)
    }
    
    //這就是注入realm$injectObjectContext()方法的地方
    public static void callInjectObjectContextFromConstructors(CtClass clazz) {
        clazz.getConstructors().each {
            it.insertBeforeBody('if ($0 instanceof io.realm.internal.RealmObjectProxy) {' +
                    ' ((io.realm.internal.RealmObjectProxy) $0).realm$injectObjectContext();' +
                    ' }')
        }
    }

15. 上面的程式碼就是往Model的代理類新增RealmProxyInterface以及在構造方法中注入injectObjectContext方法的呼叫。比如Dog類，其代理類是DogRealmProxy，增加的介面是DogRealmProxyInterface。

16. 至此就把6中的realm.createObject(Dog.class)的執行流程追蹤完成了。接著往下看dog的set與get方法，也被BytecodeModifier.groovy修改了。如下程式碼：

    /**
     * Adds Realm specific accessors to a model class.
     * All the declared fields will be associated with a getter and a setter.
     *
     * @param clazz the CtClass to add accessors to.
     */
    public static void addRealmAccessors(CtClass clazz) {
        logger.debug "  Realm: Adding accessors to ${clazz.simpleName}"
        def methods = clazz.getDeclaredMethods()*.name
        clazz.declaredFields.each { CtField field ->
            if (isModelField(field)) {
                if (!methods.contains("realmGet\$${field.name}".toString())) {
                    clazz.addMethod(CtNewMethod.getter("realmGet\$${field.name}", field))
                }
                if (!methods.contains("realmSet\$${field.name}".toString())) {
                    clazz.addMethod(CtNewMethod.setter("realmSet\$${field.name}", field))
                }
            }
        }
    }
    
    /**
     * Modifies a class replacing field accesses with the appropriate Realm accessors.
     *
     * @param clazz The CtClass to modify
     * @param managedFields List of fields whose access should be replaced
     */
    public static void useRealmAccessors(CtClass clazz, List<CtField> managedFields) {
        clazz.getDeclaredBehaviors().each { behavior ->
            logger.debug "    Behavior: ${behavior.name}"
            if (
                (
                    behavior instanceof CtMethod &&
                    !behavior.name.startsWith('realmGet$') &&
                    !behavior.name.startsWith('realmSet$')
                ) || (
                    behavior instanceof CtConstructor
                )
            ) {
                behavior.instrument(new FieldAccessToAccessorConverter(managedFields, clazz, behavior))
            }
        }
    }

17. 在RealmTransformer.groovy中的transform方法中會被呼叫，程式碼如下：

    @Override
    void transform(Context context, Collection<TransformInput> inputs, Collection<TransformInput> referencedInputs,
                   TransformOutputProvider outputProvider, boolean isIncremental)
            throws IOException, TransformException, InterruptedException {
    
        ... ...
    
        // Add accessors to the model classes in the target project
        inputModelClasses.each {
            BytecodeModifier.addRealmAccessors(it)
            BytecodeModifier.addRealmProxyInterface(it, classPool)
            BytecodeModifier.callInjectObjectContextFromConstructors(it)
        }
    
        // Use accessors instead of direct field access
        inputClassNames.each {
            logger.debug "  Modifying class ${it}"
            def ctClass = classPool.getCtClass(it)
            BytecodeModifier.useRealmAccessors(ctClass, allManagedFields)
            ctClass.writeFile(getOutputFile(outputProvider).canonicalPath)
        }
    
        ... ...
    }

18. 由上述轉換程式碼，就把Dog的屬性訪問方式修改了。比如，6中的myDog.setName(“Fido”)方法在構建的時候會被Realm提供的轉換器轉成myDog.realmSet$name(“Fido”)。

19. 至此在6中的Dog建立例項的三行程式碼就追蹤完畢了，這也意味著executeTransaction方法執行完畢執行了資料庫的Write。

20. 總之，Realm的Write操作由事務來提供保證，而Write過程的突破口就是追蹤Model物件建立的過程，在此過程中就會接觸到RealmProxy、Realm的realm-annotations-processor和realm-transformer等工具。