2024年Android Architecture Components 只看这一篇就够了(1)，2024年最新面试的总结怎么写

最新推荐文章于 2024-11-12 10:38:58 发布

2401_84563987

最新推荐文章于 2024-11-12 10:38:58 发布

阅读量746

点赞数 21

分类专栏：程序员文章标签： android 面试学习

本文链接：https://blog.csdn.net/2401_84563987/article/details/138799911

版权

程序员专栏收录该内容

186 篇文章

订阅专栏

最后

总而言之，Android开发行业变化太快，作为技术人员就要保持终生学习的态度，让学习力成为核心竞争力，所谓“活到老学到老”只有不断的学习，不断的提升自己，才能跟紧行业的步伐，才能不被时代所淘汰。

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

还有高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

// 初始化
mLifecycleRegistry = new LifecycleRegistry(this);
mActivityLifeObserver = new ActivityLifeObserver();
// 注册观察者
mLifecycleRegistry.addObserver(mActivityLifeObserver);
mLifecycleRegistry.addObserver(new LocationLifeObserver());
// 移除观察者
mLifecycleRegistry.removeObserver(mActivityLifeObserver);

三、LiveData && ViewModel

3.1、LiveData && ViewModel 介绍

LiveData 是一种持有可被观察数据的类（an observable data holder class）。和其他可被观察的类不同的是，LiveData是有生命周期感知能力的（lifecycle-aware,），这意味着它可以在 activities, fragments, 或者 services 生命周期是活跃状态时更新这些组件。

ViewModel 与 LiveData 之间的关系图如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.2、LiveData && ViewModel 使用

在 Activity 页面有一 TextView，需要展示用户 User 的信息，User 类定义：

public class User {

public String userId;

public String name;

public String phone;

@Override
public String toString() {
return “User{” +
“userId='” + userId + ‘’’ +
“, name='” + name + ‘’’ +
“, phone='” + phone + ‘’’ +
‘}’;
}
}

常规的做法：

// 获取 User 的数据后
mTvUser.setText(user.toString());

这样做的一个问题，如果获取或者修改 User 的来源不止一处，那么需要在多个地方更新 TextView，并且如果在多处 UI 用到了 User，那么也需要在多处更新。

使用 LiveData 与 ViewModel 的组合，将LiveData 持有 User 实体，作为一个被观察者，当 User 改变时，所有使用 User 的地方自动 change。构建一个 UserViewModel 如下：

public class UserViewModel extends ViewModel
implements BaseViewModel {

private String TAG = UserViewModel.class.getSimpleName();

private MutableLiveData liveUser;

public MutableLiveData getData(){
if(liveUser == null){
liveUser = new MutableLiveData();
}

liveUser.setValue(loadData());
return this.liveUser;
}

public void changeData(){
if(liveUser != null){
liveUser.setValue(loadData());
}
}

@Override
public User loadData() {
User user = new User();
user.userId = RandomUtil.getRandomNumber();
user.name = RandomUtil.getChineseName();
user.phone = RandomUtil.getRandomPhone();
LogUtil.i(TAG, "loadData(): " + user.toString());
return user;
}

@Override
public void clearData() {

}
}

自定义的UserViewModel 继承系统的 ViewModel，将 User 封装成 MutableLiveData： if(liveUser == null){ liveUser = new MutableLiveData<User>(); }

在使用User 的地方增加观察：

// view model.observe
mUserViewModel = ViewModelProviders.of(this).get(UserViewModel.class);
mUserViewModel.getData().observe(this, new Observer() {
@Override
public void onChanged(@Nullable User user) {
if(user != null){
mTvUser.setText(user.toString());
}
}
});

数据源发送改变的时候：

// 改变 User 内容
mButtonUser.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if(mUserViewModel != null && mUserViewModel.getData() != null){
mUserViewModel.changeData();
}
}
});

// setValue
public void changeData(){
if(liveUser != null){
liveUser.setValue(loadData());
}
}

这样使用到 User 的地方，UI 会自动更新，日志如下：

com.troy.androidrc I/DetailActivity:
User{userId=‘9372622’, name=‘邓楠’, phone=‘15607043749’}

com.troy.androidrc I/DetailActivity:
User{userId=‘6099877’, name=‘文瑾慧’, phone=‘13005794027’}

四、Room

4.1、Room 介绍

Room 持久层库提供了一个方便我们访问 SQLite 数据库的抽象层(an abstraction layer )，帮助我们更好的在 APP 上创建我们的数据缓存，能够让 APP 即使在没有网络的情况也能正常使用。

Room 的架构如下：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.2、Room 使用与主要注解

创建包含订单表的数据库如下步骤：

1、创建 Order.java:

@Entity(tableName = “orders”)
public class Order {

@PrimaryKey
@ColumnInfo(name = “order_id”)
public long orderId;

@ColumnInfo(name = “address”)
public String address;

@ColumnInfo(name = “owner_name”)
public String ownerName;

@ColumnInfo(name = “owner_phone”)
public String ownerPhone;

// 指示 Room 需要忽略的字段或方法
@Ignore
public String ignoreText;

@Embedded
public OwnerAddress ownerAddress;
}

2、创建 OrderDao：

@Dao
public interface OrderDao {

@Query(“SELECT * FROM orders”)
List loadAllOrders();

@Insert
void insertAll(Order… orders);

@Query(“SELECT * FROM orders WHERE order_id IN (:orderIds)”)
List queryOrderById(long[] orderIds);

@Delete
void deleteOrder(Order… orders);

@Update
void updateOrder(Order… orders);
}

3、创建数据库

@Database(entities = {Order.class, AddressInfo.class}, version = 2)
public abstract class AppDatabase extends RoomDatabase{

public abstract OrderDao getOrderDao();

}

// 实现类
public static void buildDb(){
DB_INSTANCE = Room.
databaseBuilder(TroyApplication.getInstance(), AppDatabase.class, “troy_db”) // 指定数据库名称
.addCallback(new RoomDatabase.Callback() {
@Override
public void onCreate(@NonNull SupportSQLiteDatabase db) {
super.onCreate(db); // 数据库创建回调；
LogUtil.i(TAG, “onCreate”);
}

@Override
public void onOpen(@NonNull SupportSQLiteDatabase db) {
super.onOpen(db); // 数据库使用回调；
LogUtil.i(TAG, “onOpen”);
}
})
.allowMainThreadQueries() // 数据库操作可运行在主线程
.build();

}

使用到的主要注解：

@Entity(tableName = “orders”) // 定义表名；
@PrimaryKey // 定义主键；
@ColumnInfo(name = “order_id”) // 定义数据表中的字段名；
@Ignore // 指示 Room 需要忽略的字段或方法；
@Embedded // 指定嵌入实体
@Query(“SELECT * FROM orders”) // 定义查询数据接口；
@Insert // 定义增加数据接口；
@Delete // 定义删除数据接口；
@Update // 定义更新数据接口；
@Database // 定义数据库信息，表信息，数据库版本

3.3、增删改查实现

增：

// 1、插入接口声明
@Insert
void insertAll(Order… orders);

// 2、插入接口实现
@Override
public void insertAll(Order… orders) {
__db.beginTransaction();
try {
__insertionAdapterOfOrder.insert(orders);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}

// 3、插入接口调用
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
Order order = Order.createNewOrder();
orderDao.insertAll(order);

删：

// 1、删除接口声明
@Delete
void deleteOrder(Order… orders);

// 2、删除接口实现
@Override
public void deleteOrder(Order… orders) {
__db.beginTransaction();
try {
__deletionAdapterOfOrder.handleMultiple(orders);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}

// 3、删除接口调用
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
orderDao.deleteOrder(orderList.get(orderList.size() - 1));

改：

// 1、修改接口声明
@Update
void updateOrder(Order… orders);

// 2、修改接口实现
@Override
public void updateOrder(Order… orders) {
__db.beginTransaction();
try {
__updateAdapterOfOrder.handleMultiple(orders);
__db.setTransactionSuccessful();
} finally {
__db.endTransaction();
}
}

// 3、修改接口调用
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
Order order = orderList.get(orderList.size() - 1);
order.ownerName = "update - " + RandomUtil.getChineseName();
orderDao.updateOrder(order);

查：

// 1、查询接口声明
@Query(“SELECT * FROM orders”)
List loadAllOrders();

// 2、查询接口实现
@Override
public List loadAllOrders() {
final String _sql = “SELECT * FROM orders”;
final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
final Cursor _cursor = __db.query(_statement);
try {
final int _cursorIndexOfOrderId = _cursor.getColumnIndexOrThrow(“order_id”);
final int _cursorIndexOfAddress = _cursor.getColumnIndexOrThrow(“address”);
final int _cursorIndexOfOwnerName = _cursor.getColumnIndexOrThrow(“owner_name”);
final int _cursorIndexOfOwnerPhone = _cursor.getColumnIndexOrThrow(“owner_phone”);
final int _cursorIndexOfStreet = _cursor.getColumnIndexOrThrow(“street”);
final int _cursorIndexOfState = _cursor.getColumnIndexOrThrow(“state”);
final int _cursorIndexOfCity = _cursor.getColumnIndexOrThrow(“city”);
final int _cursorIndexOfPostCode = _cursor.getColumnIndexOrThrow(“post_code”);
final List _result = new ArrayList(_cursor.getCount());
while(_cursor.moveToNext()) {
final Order _item;
final Order.OwnerAddress _tmpOwnerAddress;
if (! (_cursor.isNull(_cursorIndexOfStreet) && _cursor.isNull(_cursorIndexOfState) && _cursor.isNull(_cursorIndexOfCity) && _cursor.isNull(_cursorIndexOfPostCode))) {
_tmpOwnerAddress = new Order.OwnerAddress();
_tmpOwnerAddress.street = _cursor.getString(_cursorIndexOfStreet);
_tmpOwnerAddress.state = _cursor.getString(_cursorIndexOfState);
_tmpOwnerAddress.city = _cursor.getString(_cursorIndexOfCity);
_tmpOwnerAddress.postCode = _cursor.getInt(_cursorIndexOfPostCode);
} else {
_tmpOwnerAddress = null;
}
_item = new Order();
_item.orderId = _cursor.getLong(_cursorIndexOfOrderId);
_item.address = _cursor.getString(_cursorIndexOfAddress);
_item.ownerName = _cursor.getString(_cursorIndexOfOwnerName);
_item.ownerPhone = _cursor.getString(_cursorIndexOfOwnerPhone);
_item.ownerAddress = _tmpOwnerAddress;
_result.add(_item);
}
return _result;
} finally {
_cursor.close();
_statement.release();
}
}

// 3、查询接口调用
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
return orderDao.loadAllOrders();

3.4、内嵌实体

如果实体 Order 内部包含地址信息，地址信息分别包含城市，邮政等信息，可以这样写，使用@Embedded 注解：

static class OwnerAddress {

public String street;
public String state;
public String city;

@ColumnInfo(name = “post_code”)
public int postCode;
}

@Embedded
public OwnerAddress ownerAddress;

3.5、配合 LiveData

数据查询可以返回 LiveData 数据：

@Query(“SELECT * FROM orders”)
LiveData<List> loadAllOrderData();

3.6、配合 RxJava

通过 query 查询返回的实体，可以封装成对应RxJava 的操作符封装对象，例如 Flowable，Maybe 等：

// 接口声明
@Query(“SELECT * from orders where order_id = :id LIMIT 1”)
Flowable queryOrderByIdV2(long id);

@Query(“SELECT * from orders where order_id = :id LIMIT 1”)
Maybe queryOrderByIdV3(long id);

// 接口调用
private Maybe queryOrderV3(){
AppDatabase db = DbManager.getDbInstance();
OrderDao orderDao = db.getOrderDao();
return orderDao.queryOrderByIdV3(10001);
}

Maybe orderMaybe = queryOrderV3();
orderMaybe.subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Order order) throws Exception {

}
});

以上代码Demo 实现：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传