上面的图画的比较乱，流程是：当activity要请求数据时

1、先检查内存中缓存数据如果内存中有数据并且数据不脏时直接返回内存中的数据。
2、如果内存中无数据并且数据不为脏时向本地数据库中请求数据，并且将请求的数据写入到内存中，再将内存中的数据返回。
3、如果内存和本地数据库中都没有数据返回，也就是内存中无数据并且数据为脏时，向服务器请求数据，服务器返回的数据，保存到本地数据库并且保存一份到内存，最后将内存中的数据返回。

三级缓存实现

由三级缓存的原理可以实现三级缓存的框架，数据的来源有三个地方，内存，本地数据库，服务器，但是应用层并不关心数据来自哪里，所以要定义一个数据仓库，里面处理数据逻辑，当activity请求数据时直接由数据仓库来返回数据。定义数据仓库之前可以定义一个数据来源接口，这个接口定义数据的操作，比如插入数据，删除数据，返回数据等。类图：

数据来源接口：TasksDataSource

public interface TasksDataSource {

interface LoadTasksCallback {

void onTasksLoaded(List tasks);//获取数据成功

void onDataNotAvailable();//无数据或者获取数据失败
}//多个任务获取数据回调

interface GetTaskCallback {

void onTaskLoaded(Task task);//获取数据成功

void onDataNotAvailable();//无数据或者获取数据失败
}//获取单个任务回调

void getTasks(@NonNull LoadTasksCallback callback);

void getTask(@NonNull String taskId, @NonNull GetTaskCallback callback);

void saveTask(@NonNull Task task);//保存数据

void refreshTasks();//刷新数据

void deleteAllTasks();//删除全部数据

void deleteTask(@NonNull String taskId);//删除单个任务数据
}

上面定义了数据源类TasksDataSource在这个类中定义了获取任务或者任务组的回调，已经获取任务，存储任务，删除任务，刷新任务的方法。其中的task是自定义的应用中要用到的数据类型，这里定义的比较简单：

public final class Task {

@PrimaryKey
@NonNull
@ColumnInfo(name = “entryid”)
private final String mId;//任务Id也是唯一键

@Nullable
@ColumnInfo(name = “title”)
private final String mTitle;//任务标题

@Nullable
@ColumnInfo(name = “description”)
private final String mDescription;//任务描述

public Task(@Nullable String title, @Nullable String description,
@NonNull String id) {
mId = id;
mTitle = title;
mDescription = description;
}

}

因为Task要写入到本地数据库，所以mId作为唯一键。有了数据来源再定义本地数据仓库，数据仓库向activity提供数据，并且实现上面的三级缓存原理。数据仓库中处理三种来源的数据，并将最后的结果返回。 数据仓库TasksRepository

public class

TasksRepository implements TasksDataSource {

private static TasksRepository INSTANCE = null;

private final TasksDataSource mTasksRemoteDataSource;//服务器数据来源

private final TasksDataSource mTasksLocalDataSource;//本地数据库数据源

Map<String, Task> mCachedTasks;//内存缓存

boolean mCacheIsDirty = false;//标记缓存数据是否脏

// Prevent direct instantiation.
private TasksRepository(@NonNull TasksDataSource tasksRemoteDataSource,
@NonNull TasksDataSource tasksLocalDataSource) {
mTasksRemoteDataSource = checkNotNull(tasksRemoteDataSource);
mTasksLocalDataSource = checkNotNull(tasksLocalDataSource);
}

public static TasksRepository getInstance(TasksDataSource tasksRemoteDataSource,
TasksDataSource tasksLocalDataSource) {
if (INSTANCE == null) {
INSTANCE = new TasksRepository(tasksRemoteDataSource, tasksLocalDataSource);
}
return INSTANCE;
}

public static void destroyInstance() {
INSTANCE = null;
}
//获取任务
@Override
public void getTasks(@NonNull final LoadTasksCallback callback) {
checkNotNull(callback);

// Respond immediately with cache if available and not dirty
if (mCachedTasks != null && !mCacheIsDirty) {
callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
return;
}

if (mCacheIsDirty) {
// If the cache is dirty we need to fetch new data from the network.
getTasksFromRemoteDataSource(callback);
} else {
// Query the local storage if available. If not, query the network.
mTasksLocalDataSource.getTasks(new LoadTasksCallback() {
@Override
public void onTasksLoaded(List tasks) {
refreshCache(tasks);
callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
}

@Override
public void onDataNotAvailable() {
getTasksFromRemoteDataSource(callback);
}
});
}
}
//保存任务
@Override
public void saveTask(@NonNull Task task) {
checkNotNull(task);
mTasksRemoteDataSource.saveTask(task);
mTasksLocalDataSource.saveTask(task);

// Do in memory cache update to keep the app UI up to date
if (mCachedTasks == null) {
mCachedTasks = new LinkedHashMap<>();
}
mCachedTasks.put(task.getId(), task);
}
//通过taskid获取任务
@Override
public void getTask(@NonNull final String taskId, @NonNull final GetTaskCallback callback) {
checkNotNull(taskId);
checkNotNull(callback);

Task cachedTask = getTaskWithId(taskId);

// Respond immediately with cache if available
if (cachedTask != null) {
callback.onTaskLoaded(cachedTask);
return;
}

// Load from server/persisted if needed.

// Is the task in the local data source? If not, query the network.
mTasksLocalDataSource.getTask(taskId, new GetTaskCallback() {
@Override
public void onTaskLoaded(Task task) {
// Do in memory cache update to keep the app UI up to date
if (mCachedTasks == null) {
mCachedTasks = new LinkedHashMap<>();
}
mCachedTasks.put(task.getId(), task);
callback.onTaskLoaded(task);
}

@Override
public void onDataNotAvailable() {
mTasksRemoteDataSource.getTask(taskId, new GetTaskCallback() {
@Override
public void onTaskLoaded(Task task) {
// Do in memory cache update to keep the app UI up to date
if (mCachedTasks == null) {
mCachedTasks = new LinkedHashMap<>();
}
mCachedTasks.put(task.getId(), task);
callback.onTaskLoaded(task);
}

@Override
public void onDataNotAvailable() {
callback.onDataNotAvailable();
}
});
}
});
}
//刷新任务
@Override
public void refreshTasks() {
mCacheIsDirty = true;
}
//删除全部任务
@Override
public void deleteAllTasks() {
mTasksRemoteDataSource.deleteAllTasks();
mTasksLocalDataSource.deleteAllTasks();

if (mCachedTasks == null) {
mCachedTasks = new LinkedHashMap<>();
}
mCachedTasks.clear();
}
//删除任务
@Override
public void deleteTask(@NonNull String taskId) {
mTasksRemoteDataSource.deleteTask(checkNotNull(taskId));
mTasksLocalDataSource.deleteTask(checkNotNull(taskId));

mCachedTasks.remove(taskId);
}
//从服务器获取数据
private void getTasksFromRemoteDataSource(@NonNull final LoadTasksCallback callback) {
mTasksRemoteDataSource.getTasks(new LoadTasksCallback() {
@Override
public void onTasksLoaded(List tasks) {
refreshCache(tasks);
refreshLocalDataSource(tasks);
callback.onTasksLoaded(new ArrayList<>(mCachedTasks.values()));
}

@Override
public void onDataNotAvailable() {
callback.onDataNotAvailable();
}
});
}
//刷新缓存数据
private void refreshCache(List tasks) {
if (mCachedTasks == null) {
mCachedTasks = new LinkedHashMap<>();
}
mCachedTasks.clear();
for (Task task : tasks) {
mCachedTasks.put(task.getId(), task);
}
mCacheIsDirty = false;
}
//刷新本地数据库
private void refreshLocalDataSource(List tasks) {
mTasksLocalDataSource.deleteAllTasks();
for (Task task : tasks) {
mTasksLocalDataSource.saveTask(task);
}
}

}

本地数据来源类TasksLocalDataSource

public class TasksLocalDataSource implements TasksDataSource {

private static volatile TasksLocalDataSource INSTANCE;

private TasksDao mTasksDao;

private AppExecutors mAppExecutors;

// Prevent direct instantiation.
private TasksLocalDataSource(@NonNull AppExecutors appExecutors,
@NonNull TasksDao tasksDao) {
mAppExecutors = appExecutors;
mTasksDao = tasksDao;
}

public static TasksLocalDataSource getInstance(@NonNull AppExecutors appExecutors,
@NonNull TasksDao tasksDao) {
if (INSTANCE == null) {
synchronized (TasksLocalDataSource.class) {
if (INSTANCE == null) {
INSTANCE = new TasksLocalDataSource(appExecutors, tasksDao);
}
}
}
return INSTANCE;
}

/**

• Note: {@link LoadTasksCallback#onDataNotAvailable()} is fired if the database doesn’t exist
• or the table is empty.
  */
  @Override
  public void getTasks(@NonNull final LoadTasksCallback callback) {
  Runnable runnable = new Runnable() {
  @Override
  public void run() {
  final List tasks = mTasksDao.getTasks();
  mAppExecutors.mainThread().execute(new Runnable() {
  @Override
  public void run() {
  if (tasks.isEmpty()) {
  // This will be called if the table is new or just empty.
  callback.onDataNotAvailable();
  } else {
  callback.onTasksLoaded(tasks);
  }
  }
  });
  }
  };

mAppExecutors.diskIO().execute(runnable);
}

/**

• Note: {@link GetTaskCallback#onDataNotAvailable()} is fired if the {@link Task} isn’t
• found.
  */
  @Override
  public void getTask(@NonNull final String taskId, @NonNull final GetTaskCallback callback) {
  Runnable runnable = new Runnable() {
  @Override
  public void run() {
  final Task task = mTasksDao.getTaskById(taskId);

mAppExecutors.mainThread().execute(new Runnable() {
@Override
public void run() {
if (task != null) {
callback.onTaskLoaded(task);
} else {
callback.onDataNotAvailable();
}
}
});
}
};

mAppExecutors.diskIO().execute(runnable);
}

@Override
public void saveTask(@NonNull final Task task) {
checkNotNull(task);
Runnable saveRunnable = new Runnable() {
@Override
public void run() {
mTasksDao.insertTask(task);

总结

最后对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！

这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司20年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。

相信它会给大家带来很多收获：

当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向，才能在工作和能力提升中甩开同龄人。

环境，而不是环境来适应我们！**

这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司20年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。

相信它会给大家带来很多收获：
[外链图片转存中…(img-R29DV6E2-1643887051433)]

[外链图片转存中…(img-bjAMdMeG-1643887051433)]

当程序员容易，当一个优秀的程序员是需要不断学习的，从初级程序员到高级程序员，从初级架构师到资深架构师，或者走向管理，从技术经理到技术总监，每个阶段都需要掌握不同的能力。早早确定自己的职业方向，才能在工作和能力提升中甩开同龄人。

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录