珞泽珈群
珞泽珈群

从Room源码看抽象与封装——数据流

目录

源码解析目录
从Room源码看抽象与封装——SQLite的抽象
从Room源码看抽象与封装——数据库的创建
从Room源码看抽象与封装——数据库的升降级
从Room源码看抽象与封装——Dao
从Room源码看抽象与封装——数据流

前言

之前关于Room源码分析的四篇文章基本上涵盖了Room使用的全流程，从抽象基础到数据库创建再到增删改查的实现，可谓很全面了。你以为这就完了吗？Too young！如果Room只是这些内容的话，那只能说它是个还不错的ORM框架，对SQLite进行了良好的抽象，并且效率也很高。Room最大的不同在于它是Jetpack包的一部分，它与Jetpack包中其它部分有着非常好的配合，尤其是LiveData。以之前定义的Dao为例：

@Dao
interface UserDao {
    @Query("SELECT * FROM user WHERE uid = :userId")
    fun getUserById(userId: Int): User?

    @Query("SELECT * FROM user WHERE uid = :userId")
    fun getUserLiveDataById(userId: Int): LiveData
    
    @Query("SELECT * FROM user WHERE uid = :userId")
    fun getUserObservableById(userId: Int): Observable
    
    @Query("SELECT * FROM user WHERE uid = :userId")
    fun getUserFlowableById(userId: Int): Flowable
}

如上所示，Dao中的查询不仅可以返回Entity对象User，还可以以数据流的形式返回LiveData或者是RxJava中的Observable，Flowable。当我们“增删改”User表时，如果在此之前以如上形式获取到了User数据流，那么该User数据流就会“更新”，即相应查询会重新执行一遍，以把最新的User数据传递出去，至于User是否真的有变化，这需要我们自行判断。
这篇文章会介绍Room是如何实现数据流的。

1. 概述

如果说之前对Room方方面面的解析只是“繁”的话，那么Room对于数据流的实现真的是有点“难”了。整个流程比较复杂，为了防止你看的云里雾里，我先大致描述一下整个流程，然后再对各个部分进行详细讲解。
Room实现数据流大致包含如下几个步骤：

  1. 创建一个数据库临时表（表名为room_table_modification_log，保存在内存中，非本地存储），表中包含两列table_id和invalidated，这个表记录了当前数据库哪个Table被修改了（“增删改”都属于修改）。
  2. 如果Dao中的查询涉及到了数据流返回，那么生成代码就会帮我们向数据库中添加一个关于当前被查询表（对于上面的例子来说就是User这个表，可能会涉及到多个表）的TRIGGER（触发器），这个触发器的主要任务是当有操作修改了被查询表中的数据时，就把room_table_modification_log表中对应的table_id的invalidated置为1，表示“失效”了。
  3. Room中所有“增删改”都是放在Transaction中的，在endTransaction时，Room都会查看room_table_modification_log表中是否有invalidated为1的，如果有，再次执行相应查询（invalidated会被重置为0），并把查询的数据通过相应数据流传递出去。
  4. 在数据流不再使用时（例如Observable被dispose），相应触发器也会被丢弃，这样就不会再对这个表进行“追踪”了。

2. 创建临时表

Room中关于数据流的实现几乎全部包含在InvalidationTracker类中，这个类是在RoomDatabase中被创建的，只是在之前的分析中被刻意忽略了。

public abstract class RoomDatabase {
    private final InvalidationTracker mInvalidationTracker;
    
    public RoomDatabase() {
        mInvalidationTracker = createInvalidationTracker();
    }
    
    /**
     * 由生成代码实现
     */
    @NonNull
    protected abstract InvalidationTracker createInvalidationTracker();
    
    /**
     * 由生成代码调用，初始化 InvalidationTracker
     */
    protected void internalInitInvalidationTracker(@NonNull SupportSQLiteDatabase db) {
        mInvalidationTracker.internalInit(db);
    }

    @NonNull
    public InvalidationTracker getInvalidationTracker() {
        return mInvalidationTracker;
    }
}

public final class AppDatabase_Impl extends AppDatabase {
    @Override
    protected SupportSQLiteOpenHelper createOpenHelper(DatabaseConfiguration configuration) {
        final SupportSQLiteOpenHelper.Callback _openCallback = new RoomOpenHelper(configuration, new RoomOpenHelper.Delegate(1) {
            @Override
            public void onOpen(SupportSQLiteDatabase _db) {
                mDatabase = _db;
                _db.execSQL("PRAGMA foreign_keys = ON");
                //数据库打开时初始化 InvalidationTracker
                internalInitInvalidationTracker(_db);
                //...
            }
            //...
        });
        //...
    }
      
    @Override
    protected InvalidationTracker createInvalidationTracker() {
        //...
        return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "User"); //User表示要观察的表名，可能包含很多个
    }
}

注解处理器生成了AppDatabase_Impl，其中不仅实现了createOpenHelper，还实现了createInvalidationTracker，并且在数据库打开时（onOpen回调被调用），InvalidationTracker被初始化，也是在初始化时，临时表被创建，踏出万里长征第一步。

public class InvalidationTracker {

    private static final String UPDATE_TABLE_NAME = "room_table_modification_log";

    private static final String TABLE_ID_COLUMN_NAME = "table_id";

    private static final String INVALIDATED_COLUMN_NAME = "invalidated";

    //建表
    private static final String CREATE_TRACKING_TABLE_SQL = "CREATE TEMP TABLE " + UPDATE_TABLE_NAME
            + "(" + TABLE_ID_COLUMN_NAME + " INTEGER PRIMARY KEY, "
            + INVALIDATED_COLUMN_NAME + " INTEGER NOT NULL DEFAULT 0)";

    //重置
    static final String RESET_UPDATED_TABLES_SQL = "UPDATE " + UPDATE_TABLE_NAME
            + " SET " + INVALIDATED_COLUMN_NAME + " = 0 WHERE " + INVALIDATED_COLUMN_NAME + " = 1 ";

    //找出哪个表改变了
    static final String SELECT_UPDATED_TABLES_SQL = "SELECT * FROM " + UPDATE_TABLE_NAME
            + " WHERE " + INVALIDATED_COLUMN_NAME + " = 1;";
            
    //根据表名找表名对应的ID
    final ArrayMap mTableIdLookup;
    //哪些表需要被观察
    final String[] mTableNames;
    
    //tableNames是可变参数，表示可能有多个要被“追踪”的表
    public InvalidationTracker(RoomDatabase database, Map shadowTablesMap,
            Map> viewTables, String... tableNames) {
        //shadowTablesMap, viewTables可以忽略，一般都为空
        final int size = tableNames.length;
        mTableNames = new String[size];
        for (int id = 0; id < size; id++) {
            final String tableName = tableNames[id].toLowerCase(Locale.US);
            //表对应的ID其实就是它的位置，因为是临时表存储在内存中，所以这个ID只需要能分别谁是谁就可以了
            mTableIdLookup.put(tableName, id);
            mTableNames[id] = tableName;
        }
        //...
    }
    
    /**
     * 初始化临时表
     */
    void internalInit(SupportSQLiteDatabase database) {
        synchronized (this) {
            database.execSQL("PRAGMA temp_store = MEMORY;"); //临时表保存在内存中
            database.execSQL("PRAGMA recursive_triggers='ON';");
            //创建临时表
            database.execSQL(CREATE_TRACKING_TABLE_SQL);
            syncTriggers(database);
            //重置临时表是需要经常执行的，把它编译成SQLiteStatement方便执行
            mCleanupStatement = database.compileStatement(RESET_UPDATED_TABLES_SQL);
        }
    }
}

临时表的表名是room_table_modification_log，创建它的目的是追踪我们需要观察的那些表中（例如User表）数据是否发生了变化。把建表的SQL翻译以下就是

CREATE TEMP TABLE room_table_modification_log
    (table_id INTEGER PRIMARY KEY,  invalidated INTEGER NOT NULL DEFAULT 0)

就像下面这样

table_id invalidated
0 0

创建表之后不会有数据，数据(0,0)只是方便你理解。

因为这个表是临时表，并且在创建它之前设置了PRAGMA temp_store = MEMORY，因此room_table_modification_log表被放在了内存中，并不会被保存在本地文件中（当然也没有必要）。因为要放在内存中，所以说room_table_modification_log选择使用把要追踪的表名转成ID进行存储，这样节省内存，而这个ID并没有什么特殊含义，只需要跟要追踪的表名一一对应就可以，所以使用0,1,2这样的位置作为ID就可以。
需要明确一点，room_table_modification_log创建后，其中是没有数据的。创建InvalidationTracker时传入的tableNames参数只是表明，返回数据流的查询涉及到了这些表，但是在数据库使用过程中，可能根本就没有执行相关查询，所以也就不需要追踪。也就是说room_table_modification_log的追踪是“懒”的，直到返回数据流的查询方法被调用时，相应数据才会被插入到room_table_modification_log表中，开启追踪。至于数据是如何被插入的，invalidated又是如何在01之间翻转的，下面会介绍。

3. 添加/移除触发器

触发器是数据库中的一个概念，你可以把它简单理解为在特定条件下“触发”的一系列行为，这种特定条件在我们这里就是UPDATE, DELETE, INSERT这三种操作，而“一系列行为”就是把room_table_modification_log表中的invalidated置为1。看来触发器的确非常适合于追踪表中数据被修改这种情形。
那么触发器是由谁添加的呢？源头就是返回数据流的查询方法，当这些方法被调用时，触发器就会被添加。然后，从Dao中查询方法被调用，到触发器被添加，这中间又经历了很多转换，我们暂且把这流程省略直接看触发器相关的内容。

public class InvalidationTracker {
    /**
     * An observer that can listen for changes in the database.
     */
    public abstract static class Observer {
        final String[] mTables;

        public Observer(@NonNull String[] tables) {
            mTables = Arrays.copyOf(tables, tables.length);
        }

        public abstract void onInvalidated(@NonNull Set tables);
    }
}

别管我们查询是以怎样的数据流返回，最终都是向数据库添加了一个观察者，这个观察者的onInvalidated会在我们观察的Table“失效”时被回调，因此，我们可以再次进行查询，进而把最新的数据传递出去，形成数据流。而onInvalidated之所以被回调，依赖的就是room_table_modification_log表。
当向数据库添加一个观察者时（其实是向InvalidationTracker添加），就会看要观察者提供的mTables中是否还存在没有被“追踪”的Table，如果有则会向room_table_modification_log表中插入一条数据，以开启对该Table的“追踪”，另外还会添加一个触发器，在UPDATE, DELETE, INSERT时设置对应table_id的invalidated为1。

public class InvalidationTracker {
    //主要职责是记录哪些 Table 已经被“追踪”了
    private ObservedTableTracker mObservedTableTracker;

    final SafeIterableMap mObserverMap = new SafeIterableMap<>();

    //添加观察者
    @WorkerThread
    public void addObserver(@NonNull Observer observer) {
        //一般情况下，与 mTables一致
        final String[] tableNames = resolveViews(observer.mTables);
        int[] tableIds = new int[tableNames.length];
        final int size = tableNames.length;

        for (int i = 0; i < size; i++) {
            //查找 Table对应的ID
            Integer tableId = mTableIdLookup.get(tableNames[i].toLowerCase(Locale.US));
            if (tableId == null) {
                throw new IllegalArgumentException("There is no table with name " + tableNames[i]);
            }
            tableIds[i] = tableId;
        }
        //会进行一下包装
        ObserverWrapper wrapper = new ObserverWrapper(observer, tableIds, tableNames);
        ObserverWrapper currentObserver;
        synchronized (mObserverMap) {
            //保存下来，如果之前添加过，啥也不干
            currentObserver = mObserverMap.putIfAbsent(observer, wrapper);
        }
        //如果之前没有添加过该观察者，并且 tableId之前没有添加过，就会添加触发器
        if (currentObserver == null && mObservedTableTracker.onAdded(tableIds)) {
            //需要“同步”
            syncTriggers();
        }
    }
    
    //移除观察者，在Observable dispose，LiveData被回收时调用
    @WorkerThread
    public void removeObserver(@NonNull final Observer observer) {
        ObserverWrapper wrapper;
        synchronized (mObserverMap) {
            wrapper = mObserverMap.remove(observer);
        }
        if (wrapper != null && mObservedTableTracker.onRemoved(wrapper.mTableIds)) {
            //需要“同步”
            syncTriggers();
        }
    }
}

向InvalidationTracker添加观察者的主要流程是，根据Observer要观察的mTables，转换成对应的tableIds，之后把Observer包装成ObserverWrapper，ObserverWrapper的主要作用是记录下被观察表的信息，诸如tableIds, tableNames。最后，把观察者保存下来，并且在必要时syncTriggers，顾名思义就是同步触发器的意思（可能添加也可能移除触发器）。
之前说过，只有在被观察的表还未被“追踪”时，才会添加触发器，如果某个表在之前就已经被“追踪”了，那自然不需要重复添加触发器。而哪些表已经被“追踪”，是否需要停止追踪，这些信息保存在ObservedTableTracker中，这里就不展开其代码了。
移除观察者就更简单了，一目了然，就不废话了。
我接着来看主线流程syncTriggers：

public class InvalidationTracker {
    void syncTriggers() {
        if (!mDatabase.isOpen()) {
            return;
        }
        syncTriggers(mDatabase.getOpenHelper().getWritableDatabase());
    }
    
    void syncTriggers(SupportSQLiteDatabase database) {
        if (database.inTransaction()) {
            return;
        }
        try {
            // This method runs in a while loop because while changes are synced to db, another
            // runnable may be skipped. If we cause it to skip, we need to do its work.
            while (true) {
                Lock closeLock = mDatabase.getCloseLock();
                closeLock.lock();
                try {
                    //上文提到的 ObservedTableTracker
                    //返回为null，证明没有要同步的，否则就是“有活要干”
                    final int[] tablesToSync = mObservedTableTracker.getTablesToSync();
                    if (tablesToSync == null) {
                        return;
                    }
                    final int limit = tablesToSync.length;
                    database.beginTransaction();
                    try {
                        for (int tableId = 0; tableId < limit; tableId++) {
                            switch (tablesToSync[tableId]) {
                                //活来了，可能是开始追踪表
                                case ObservedTableTracker.ADD:
                                    startTrackingTable(database, tableId);
                                    break;
                                //也可能是停止追踪表
                                case ObservedTableTracker.REMOVE:
                                    stopTrackingTable(database, tableId);
                                    break;
                            }
                        }
                        database.setTransactionSuccessful();
                    } finally {
                        database.endTransaction();
                    }
                    mObservedTableTracker.onSyncCompleted();
                } finally {
                    closeLock.unlock();
                }
            }
        } catch (IllegalStateException | SQLiteException exception) {
            Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?",
                    exception);
        }
    }
}

其实Room实现数据流的整体流程并不复杂，关键就是其中需要处理非常多的线程安全的问题，导致源码很复杂。syncTriggers就是这样的，其主干就是startTrackingTable或者stopTrackingTable或者啥也不干，但是考虑到线程安全的问题，就需要加锁，循环查询等等。总之，开启追踪是在startTrackingTable，停止追踪是在stopTrackingTable。

public class InvalidationTracker {
    private static final String[] TRIGGERS = new String[]{"UPDATE", "DELETE", "INSERT"};
    
    //开启追踪，向room_table_modification_log插入数据，并添加触发器
    private void startTrackingTable(SupportSQLiteDatabase writableDb, int tableId) {
        writableDb.execSQL(
                "INSERT OR IGNORE INTO " + UPDATE_TABLE_NAME + " VALUES(" + tableId + ", 0)");
        final String tableName = mTableNames[tableId];
        StringBuilder stringBuilder = new StringBuilder();
        for (String trigger : TRIGGERS) {
            stringBuilder.setLength(0);
            stringBuilder.append("CREATE TEMP TRIGGER IF NOT EXISTS ");
            appendTriggerName(stringBuilder, tableName, trigger);
            stringBuilder.append(" AFTER ")
                    .append(trigger)
                    .append(" ON `")
                    .append(tableName)
                    .append("` BEGIN UPDATE ")
                    .append(UPDATE_TABLE_NAME)
                    .append(" SET ").append(INVALIDATED_COLUMN_NAME).append(" = 1")
                    .append(" WHERE ").append(TABLE_ID_COLUMN_NAME).append(" = ").append(tableId)
                    .append(" AND ").append(INVALIDATED_COLUMN_NAME).append(" = 0")
                    .append("; END");
            writableDb.execSQL(stringBuilder.toString());
        }
    }
    
    //停止追踪，只是丢弃触发器，并不会删除room_table_modification_log中的数据
    private void stopTrackingTable(SupportSQLiteDatabase writableDb, int tableId) {
        final String tableName = mTableNames[tableId];
        StringBuilder stringBuilder = new StringBuilder();
        for (String trigger : TRIGGERS) {
            stringBuilder.setLength(0);
            stringBuilder.append("DROP TRIGGER IF EXISTS ");
            appendTriggerName(stringBuilder, tableName, trigger);
            writableDb.execSQL(stringBuilder.toString());
        }
    }
    
    //触发器的名称
    private static void appendTriggerName(StringBuilder builder, String tableName,
            String triggerType) {
        builder.append("`")
                .append("room_table_modification_trigger_")
                .append(tableName)
                .append("_")
                .append(triggerType)
                .append("`");
    }
}

以User表为例（其table_id为0），那么开启“追踪”：

INSERT OR IGNORE INTO room_table_modification_log VALUES(0, 0)

CREATE TEMP TRIGGER IF NOT EXISTS `room_table_modification_trigger_user_UPDATE`
AFTER UPDATE ON `user`
BEGIN
UPDATE room_table_modification_log
SET invalidated = 1 WHERE table_id = 0 AND invalidated = 0;
END

会为UPDATE, DELETE, INSERT分别创建TRIGGER，TIRGGER中的内容都是一样的。

停止“追踪”：

DROP TRIGGER IF EXISTS `room_table_modification_trigger_user_UPDATE`
DROP TRIGGER IF EXISTS `room_table_modification_trigger_user_DELETE`
DROP TRIGGER IF EXISTS `room_table_modification_trigger_user_INSERT`

并不会把room_table_modification_log中相应的数据也删了，说不定下次还能用到，只是不再更新invalidated。

4. 数据流

有了上面这些基础，在看数据流的实现就比较简单了。下面会以RxJava Observable数据流为例，看看数据流究竟是如何实现的。

@Dao
interface UserDao {
    @Query("SELECT * FROM user WHERE uid = :userId")
    fun getUserObservableById(userId: Int): Observable
}

会生成如下代码：

public final class UserDao_Impl implements UserDao {
  @Override
  public Observable getUserObservableById(final int userId) {
    final String _sql = "SELECT * FROM user WHERE uid = ?";
    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 1);
    int _argIndex = 1;
    _statement.bindLong(_argIndex, userId);
    //这里是关键
    return RxRoom.createObservable(__db, false, new String[]{"user"}, new Callable() {
      @Override
      public User call() throws Exception {
        //以下是正常的数据库查询流程
        final Cursor _cursor = DBUtil.query(__db, _statement, false);
        try {
          final int _cursorIndexOfUid = CursorUtil.getColumnIndexOrThrow(_cursor, "uid");
          final int _cursorIndexOfFirstName = CursorUtil.getColumnIndexOrThrow(_cursor, "first_name");
          final int _cursorIndexOfLastName = CursorUtil.getColumnIndexOrThrow(_cursor, "last_name");
          final User _result;
          if(_cursor.moveToFirst()) {
            final int _tmpUid;
            _tmpUid = _cursor.getInt(_cursorIndexOfUid);
            final String _tmpFirstName;
            _tmpFirstName = _cursor.getString(_cursorIndexOfFirstName);
            final String _tmpLastName;
            _tmpLastName = _cursor.getString(_cursorIndexOfLastName);
            _result = new User(_tmpUid,_tmpFirstName,_tmpLastName);
          } else {
            _result = null;
          }
          return _result;
        } finally {
          _cursor.close();
        }
      }

      @Override
      protected void finalize() {
        _statement.release();
      }
    });
  }
}

跟普通查询最大的不同就是以RxRoom.createObservable创建了Observable。来看一下RxRoom：

public class RxRoom {
    //其中参数callable就是要进行的查询
    public static  Observable createObservable(final RoomDatabase database,
            final boolean inTransaction, final String[] tableNames, final Callable callable) {
        //不用太在意这个scheduler，就是一个线程池，不同情况下用不同的线程池
        Scheduler scheduler = Schedulers.from(getExecutor(database, inTransaction));
        //fromCallable会天然地阻止 null，如果callable返回null会被过滤掉
        final Maybe maybe = Maybe.fromCallable(callable);
        return createObservable(database, tableNames)
                .subscribeOn(scheduler)
                .unsubscribeOn(scheduler)
                .observeOn(scheduler)
                .flatMapMaybe(new Function>() {
                    @Override
                    public MaybeSource apply(Object o) throws Exception {
                        return maybe;
                    }
                });
    }
    
    public static Observable createObservable(final RoomDatabase database,
            final String... tableNames) {
        return Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(final ObservableEmitter emitter) throws Exception {
                //新建一个InvalidationTracker.Observer
                final InvalidationTracker.Observer observer = new InvalidationTracker.Observer(
                        tableNames) {
                    //在观察的表“失效”时回调
                    @Override
                    public void onInvalidated(@androidx.annotation.NonNull Set tables) {
                        //只是发射一个“信号”，表明需要重新查询
                        emitter.onNext(NOTHING);
                    }
                };
                //向InvalidationTracker添加观察者
                database.getInvalidationTracker().addObserver(observer);
                emitter.setDisposable(Disposables.fromAction(new Action() {
                    @Override
                    public void run() throws Exception {
                        //dispose时移除观察者
                        database.getInvalidationTracker().removeObserver(observer);
                    }
                }));

                // emit once to avoid missing any data and also easy chaining
                emitter.onNext(NOTHING);
            }
        });
    }
}
 
 
很简单，就是向InvalidationTracker添加观察者，在Observable被dispose的时候移除观察者。因为RxJava 2不喜欢null，所以RxRoom的做法是仅仅发送数据“失效”的信号，然后使用flatMapMaybe操作符结合Maybe.fromCallable天然地过滤掉了null，很巧妙（巧妙也不是一天达成的，在之前的版本中没有使用这个操作符，还是使用我们总是用的那种“笨拙”的方法过滤null）。
 
 
 
 
还差最后一个环节就能形成闭环了，那就是啥时候去查询room_table_modification_log表，看看哪个被“追踪”的表“失效”了。最合适的时机就是“增删改”结束的时候：
 
 
public abstract class RoomDatabase {
    public void beginTransaction() {
        assertNotMainThread();
        SupportSQLiteDatabase database = mOpenHelper.getWritableDatabase();
        //Transaction开始时“同步”Trigger
        mInvalidationTracker.syncTriggers(database);
        database.beginTransaction();
    }

    //Transaction结束时refreshVersionsAsync
    public void endTransaction() {
        mOpenHelper.getWritableDatabase().endTransaction();
        if (!inTransaction()) {
            // enqueue refresh only if we are NOT in a transaction. Otherwise, wait for the last
            // endTransaction call to do it.
            mInvalidationTracker.refreshVersionsAsync();
        }
    }
}


public class InvalidationTracker {
    public void refreshVersionsAsync() {
        if (mPendingRefresh.compareAndSet(false, true)) {
            mDatabase.getQueryExecutor().execute(mRefreshRunnable);
        }
    }
    
    Runnable mRefreshRunnable = new Runnable() {
        @Override
        public void run() {
            final Lock closeLock = mDatabase.getCloseLock();
            Set invalidatedTableIds = null;
            try {
                closeLock.lock();

                if (!ensureInitialization()) {
                    return;
                }

                if (!mPendingRefresh.compareAndSet(true, false)) {
                    // no pending refresh
                    return;
                }

                if (mDatabase.inTransaction()) {
                    // current thread is in a transaction. when it ends, it will invoke
                    // refreshRunnable again. mPendingRefresh is left as false on purpose
                    // so that the last transaction can flip it on again.
                    return;
                }

                //查询room_table_modification_log，获取“失效”的表
                invalidatedTableIds = checkUpdatedTable();
            } catch (IllegalStateException | SQLiteException exception) {
                // may happen if db is closed. just log.
                Log.e(Room.LOG_TAG, "Cannot run invalidation tracker. Is the db closed?",
                        exception);
            } finally {
                closeLock.unlock();
            }
            //如果有“失效”的表
            if (invalidatedTableIds != null && !invalidatedTableIds.isEmpty()) {
                synchronized (mObserverMap) {
                    for (Map.Entry entry : mObserverMap) {
                        //通知观察者，如果是观察者“关心”的表，就会回调 onInvalidated
                        entry.getValue().notifyByTableInvalidStatus(invalidatedTableIds);
                    }
                }
            }
        }

        //查询出room_table_modification_log中invalidated为1的，然后把它重置为0；返回的是 table_id的集合
        private Set checkUpdatedTable() {
            //主要就是执行下面SQL
            //SELECT * FROM room_table_modification_log WHERE invalidated = 1
            //UPDATE room_table_modification_log SET invalidated = 0 WHERE invalidated = 1
        }
    };

}

 
 
“增删改”都是放在Transaction中的，因此endTransaction是个查询room_table_modification_log的好时机。通过room_table_modification_log获取“失效”的表，如果InvalidationTracker的观察者观察的是“失效”表中的某一个或几个，就会回调观察者的onInvalidated方法。onInvalidated方法正如前面展示的那样，会发送一个信号，然后相应查询就会被再次执行，最新的数据就会被传递出去。至此，整个流程完整地闭合。
 
 
 
  
某个数据表“失效”仅仅是说这个表中的数据被修改了，但是，是不是修改的我们查询关心的部分，其实并不知道，有可能重新查询的结果跟之前是一样的。如果不想接收到重复的数据，对于RxJava而言可以使用distinctUntilChanged来进行过滤，对于LiveData而言可以使用Transformations.distinctUntilChanged来过滤。
 
 
 
 
以上仅以RxJava Observable为例展示了数据流是如何实现的，对于Flowable而言是类似的。但是对于LiveData而言，跟Observable就不太一样了，中间多了很多处理（主要是防止在我们没有保存LiveData的情况下，LiveData被意外回收），整个流程下来比较繁琐，但是思路是一样的，这里就省略了。
 
 
5. 总结
 
 
 
  
 
   
 
    从Room源码看抽象与封装——数据流_第1张图片 
   
 
  
 
  

    Room实现数据流的流程 
  
 
 
 
 
图中有一些不合适的地方，removeObserver并不是有Dao调用的，而是查询返回的RaJava Observable或者LiveData“不再用”了的时候被各自调用的。其中，“重新查询”的意思就是数据流被更新，数据流相关的RaJava Observable或者LiveData都没有在包含在图中。
 能从Room分析的第一篇文章看到这里的，应该颁发一个最佳坚持奖，请留言或者点赞让我看见你们的双手。这是这一系列文章的最后一篇，文章题目叫“从Room源码看抽象与封装”，主要是因为写第一篇文章的时候，想从“抽象与封装”作为切入点去分析Room的源码，没有想到会写这么长。前面几篇文章还是比较符合题目的，后面的文章基本上就剩源码解析了，不是说这里面不包含抽象封装的内容，而是源码已经比较复杂了，再去谈抽象封装只会更加混乱。总之，希望你有所收获，欢迎留言与我交流。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(从Room源码看抽象与封装——数据流)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 三大师传
                        beca酱

                        
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 活给自己看，笑容才灿烂
                        听着了么

                        
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
    
                    
    • 
                    
  • 每日一题——第九十题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                                
  • Java常用排序算法/程序员必须掌握的8大排序算法
                                    cugfy
java
                                    
    分类： 
 
1）插入排序（直接插入排序、希尔排序） 
2）交换排序（冒泡排序、快速排序） 
3）选择排序（直接选择排序、堆排序） 
4）归并排序 
5）分配排序（基数排序） 
 
所需辅助空间最多：归并排序 
所需辅助空间最少：堆排序 
平均速度最快：快速排序 
 
不稳定：快速排序，希尔排序，堆排序。 
 
先来看看8种排序之间的关系： 
 
  
 
 1.直接插入排序 
 
（1
    
                                
    • 
                                
  • 【Spark102】Spark存储模块BlockManager剖析
                                    bit1129
manager
                                    
    Spark围绕着BlockManager构建了存储模块，包括RDD，Shuffle，Broadcast的存储都使用了BlockManager。而BlockManager在实现上是一个针对每个应用的Master/Executor结构，即Driver上BlockManager充当了Master角色，而各个Slave上(具体到应用范围，就是Executor)的BlockManager充当了Slave角色
    
                                
    • 
                                
  • linux 查看端口被占用情况详解
                                    daizj
linux端口占用netstatlsof
                                    
    经常在启动一个程序会碰到端口被占用，这里讲一下怎么查看端口是否被占用，及哪个程序占用，怎么Kill掉已占用端口的程序 
  
1、lsof -i:port 
port为端口号 
  
[root@slave /data/spark-1.4.0-bin-cdh4]# lsof -i:8080 
COMMAND   PID USER   FD   TY
    
                                
    • 
                                
  • Hosts文件使用
                                    周凡杨
hostslocahost
                                    
         一切都要从localhost说起，经常在tomcat容器起动后，访问页面时输入http://localhost:8088/index.jsp，大家都知道localhost代表本机地址，如果本机IP是10.10.134.21，那就相当于http://10.10.134.21:8088/index.jsp，有时候也会看到http: 127.0.0.1:
    
                                
    • 
                                
  • java excel工具
                                    g21121
Java excel
                                    
    直接上代码，一看就懂，利用的是jxl： 
import java.io.File;
import java.io.IOException;
import jxl.Cell;
import jxl.Sheet;
import jxl.Workbook;
import jxl.read.biff.BiffException;
import jxl.write.Label;
import 
    
                                
    • 
                                
  • web报表工具finereport常用函数的用法总结（数组函数）
                                    老A不折腾
finereportweb报表函数总结
                                    
    ADD2ARRAY 
ADDARRAY(array,insertArray, start):在数组第start个位置插入insertArray中的所有元素，再返回该数组。 
示例： 
ADDARRAY([3,4, 1, 5, 7], [23, 43, 22], 3)返回[3, 4, 23, 43, 22, 1, 5, 7]. 
ADDARRAY([3,4, 1, 5, 7], "测试&q
    
                                
    • 
                                
  • 游戏服务器网络带宽负载计算
                                    墙头上一根草
服务器
                                    
    家庭所安装的4M，8M宽带。其中M是指，Mbits/S 
其中要提前说明的是： 
8bits = 1Byte 
即8位等于1字节。我们硬盘大小50G。意思是50*1024M字节，约为 50000多字节。但是网宽是以“位”为单位的，所以，8Mbits就是1M字节。是容积体积的单位。 
8Mbits/s后面的S是秒。8Mbits/s意思是 每秒8M位，即每秒1M字节。 
我是在计算我们网络流量时想到的
    
                                
    • 
                                
  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
Spring 3 系列
                                    
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    
                                
    • 
                                
  • 高性能mysql 之 选择存储引擎(一)
                                    annan211
mysqlInnoDBMySQL引擎存储引擎
                                    
      1 没有特殊情况，应尽可能使用InnoDB存储引擎。   原因：InnoDB 和 MYIsAM 是mysql 最常用、使用最普遍的存储引擎。其中InnoDB是最重要、最广泛的存储引擎。她   被设计用来处理大量的短期事务。短期事务大部分情况下是正常提交的，很少有回滚的情况。InnoDB的性能和自动崩溃   恢复特性使得她在非事务型存储的需求中也非常流行，除非有非常
    
                                
    • 
                                
  • UDP网络编程
                                    百合不是茶
UDP编程局域网组播
                                    
      
UDP是基于无连接的,不可靠的传输   与TCP/IP相反 
  
  
  
UDP实现私聊,发送方式客户端,接受方式服务器 
package netUDP_sc;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Ine
    
                                
    • 
                                
  • JQuery对象的val()方法执行结果分析
                                    bijian1013
JavaScriptjsjquery
                                    
            JavaScript中，如果id对应的标签不存在（同理JAVA中，如果对象不存在），则调用它的方法会报错或抛异常。在实际开发中，发现JQuery在id对应的标签不存在时，调其val()方法不会报错，结果是undefined。 
        
    
                                
    • 
                                
  • http请求测试实例（采用json-lib解析）
                                    bijian1013
jsonhttp
                                    
            由于fastjson只支持JDK1.5版本，因些对于JDK1.4的项目，可以采用json-lib来解析JSON数据。如下是http请求的另外一种写法，仅供参考。 
package com;

import java.util.HashMap;
import java.util.Map;

import 
    
                                
    • 
                                
  • 【RPC框架Hessian四】Hessian与Spring集成
                                    bit1129
hessian
                                    
    在【RPC框架Hessian二】Hessian 对象序列化和反序列化一文中介绍了基于Hessian的RPC服务的实现步骤，在那里使用Hessian提供的API完成基于Hessian的RPC服务开发和客户端调用，本文使用Spring对Hessian的集成来实现Hessian的RPC调用。 
  定义模型、接口和服务器端代码 
|---Model 
   &nb
    
                                
    • 
                                
  • 【Mahout三】基于Mahout CBayes算法的20newsgroup流程分析
                                    bit1129
Mahout
                                    
    1.Mahout环境搭建 
 1.下载Mahout 
http://mirror.bit.edu.cn/apache/mahout/0.10.0/mahout-distribution-0.10.0.tar.gz 
  
 2.解压Mahout 
 3. 配置环境变量 
vim /etc/profile

export HADOOP_HOME=/home
    
                                
    • 
                                
  • nginx负载tomcat遇非80时的转发问题
                                    ronin47

                                    
    　　nginx负载后端容器是tomcat（其它容器如WAS,JBOSS暂没发现这个问题）非８０端口，遇到跳转异常问题。解决的思路是：$host:port 
       详细如下： 
　　  
该问题是最先发现的，由于之前对nginx不是特别的熟悉所以该问题是个入门级别的：    
?       1   2   3   4   5   
    
                                
    • 
                                
  • java-17-在一个字符串中找到第一个只出现一次的字符
                                    bylijinnan
java
                                    
    

public class FirstShowOnlyOnceElement {

	/**Q17.在一个字符串中找到第一个只出现一次的字符。如输入abaccdeff，则输出b
	 * 1.int[] count:count[i]表示i对应字符出现的次数
	 * 2.将26个英文字母映射：a-z <--> 0-25
	 * 3.假设全部字母都是小写
	 */
	pu
    
                                
    • 
                                
  • mongoDB 复制集
                                    开窍的石头
mongodb
                                    
    mongo的复制集就像mysql的主从数据库，当你往其中的主复制集(primary)写数据的时候，副复制集(secondary)会自动同步主复制集(Primary)的数据,当主复制集挂掉以后其中的一个副复制集会自动成为主复制集。提供服务器的可用性。和防止当机问题 
       
 
     mo
    
                                
    • 
                                
  • [宇宙与天文]宇宙时代的经济学
                                    comsci
经济
                                    
     
    宇宙尺度的交通工具一般都体型巨大，造价高昂。。。。。 
 
     在宇宙中进行航行，近程采用反作用力类型的发动机，需要消耗少量矿石燃料，中远程航行要采用量子或者聚变反应堆发动机，进行超空间跳跃，要消耗大量高纯度水晶体能源 
 
     以目前地球上国家的经济发展水平来讲，
    
                                
    • 
                                
  • Git忽略文件
                                    Cwind
git
                                    
         有很多文件不必使用git管理。例如Eclipse或其他IDE生成的项目文件，编译生成的各种目标或临时文件等。使用git status时，会在Untracked files里面看到这些文件列表，在一次需要添加的文件比较多时（使用git add . / git add -u），会把这些所有的未跟踪文件添加进索引。  
   ==== ==== ==== 一些牢骚
    
                                
    • 
                                
  • MySQL连接数据库的必须配置
                                    dashuaifu
mysql连接数据库配置
                                    
    MySQL连接数据库的必须配置 
  
1.driverClass：com.mysql.jdbc.Driver 
  
2.jdbcUrl：jdbc:mysql://localhost:3306/dbname 
  
3.user：username 
  
4.password：password 
  
其中1是驱动名；2是url，这里的‘dbna
    
                                
    • 
                                
  • 一生要养成的60个习惯
                                    dcj3sjt126com
习惯
                                    
    一生要养成的60个习惯 
第1篇 让你更受大家欢迎的习惯 
1 守时，不准时赴约,让别人等,会失去很多机会。 
如何做到： 
①该起床时就起床， 
②养成任何事情都提前15分钟的习惯。 
③带本可以随时阅读的书，如果早了就拿出来读读。 
④有条理，生活没条理最容易耽误时间。 
⑤提前计划：将重要和不重要的事情岔开。 
⑥今天就准备好明天要穿的衣服。 
⑦按时睡觉，这会让按时起床更容易。 
2 注重
    
                                
    • 
                                
  • [介绍]Yii 是什么
                                    dcj3sjt126com
PHPyii2
                                    
    Yii 是一个高性能，基于组件的 PHP 框架，用于快速开发现代 Web 应用程序。名字 Yii （读作 易）在中文里有“极致简单与不断演变”两重含义，也可看作 Yes It Is! 的缩写。  
Yii 最适合做什么？ 
Yii 是一个通用的 Web 编程框架，即可以用于开发各种用 PHP 构建的 Web 应用。因为基于组件的框架结构和设计精巧的缓存支持，它特别适合开发大型应
    
                                
    • 
                                
  • Linux SSH常用总结
                                    eksliang
linux sshSSHD
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2186931 一、连接到远程主机 
  
格式：
ssh name@remoteserver
例如：
ssh [email protected] 
  二、连接到远程主机指定的端口 
  
格式：
ssh name@remoteserver -p 22
例如：
ssh i
    
                                
    • 
                                
  • 快速上传头像到服务端工具类FaceUtil
                                    gundumw100
android
                                    
    快速迭代用 
 
 

import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOExceptio
    
                                
    • 
                                
  • jQuery入门之怎么使用
                                    ini
JavaScripthtmljqueryWebcss
                                    
    jQuery的强大我何问起（个人主页：hovertree.com）就不用多说了，那么怎么使用jQuery呢？ 
  
首先，下载jquery。下载地址：http://hovertree.com/hvtart/bjae/b8627323101a4994.htm，一个是压缩版本，一个是未压缩版本，如果在开发测试阶段，可以使用未压缩版本，实际应用一般使用压缩版本(min)。然后就在页面上引用。
    
                                
    • 
                                
  • 带filter的hbase查询优化
                                    kane_xie
查询优化hbaseRandomRowFilter
                                    
     
 问题描述 
 
hbase scan数据缓慢，server端出现LeaseException。hbase写入缓慢。     
 
 问题原因 
 
直接原因是：  hbase client端每次和regionserver交互的时候，都会在服务器端生成一个Lease,Lease的有效期由参数hbase.regionserver.lease.period确定。如果hbase scan需
    
                                
    • 
                                
  • java设计模式-单例模式
                                    men4661273
java单例枚举反射IOC
                                    
             单例模式1，饿汉模式 
//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
    //私有的默认构造函数
    private Singleton1() {}
    //已经自行实例化
    private static final Singleton1 singl
    
                                
    • 
                                
  • mongodb 查询某一天所有信息的3种方法，根据日期查询
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    // mongodb的查询真让人难以琢磨，就查询单天信息，都需要花费一番功夫才行。

// 第一种方式：
coll.aggregate([
          {$project:{sendDate: {$substr: ['$sendTime', 0, 10]}, sendTime: 1, content:1}},
          {$match:{sendDate: '2015-
    
                                
    • 
                                
  • 二维数组转换成JSON
                                    tangqi609567707
java二维数组json
                                    
    原文出处：http://blog.csdn.net/springsen/article/details/7833596 
public class Demo { 
    public static void main(String[] args) {        String[][] blogL
    
                                
    • 
                                
  • erlang supervisor
                                    wudixiaotie
erlang
                                    
    定义supervisor时，如果是监控celuesimple_one_for_one则删除children的时候就用supervisor:terminate_child (SupModuleName, ChildPid)，如果shutdown策略选择的是brutal_kill，那么supervisor会调用exit(ChildPid, kill)，这样的话如果Child的behavior是gen_
    
                                
    •