2024年Android最全Android 相关源码分析，2024年最新阿里巴巴的面试题

最新推荐文章于 2024-09-16 11:16:40 发布

2401_84123357

最新推荐文章于 2024-09-16 11:16:40 发布

阅读量849

点赞数 30

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

本文链接：https://blog.csdn.net/2401_84123357/article/details/138820800

版权

程序员专栏收录该内容

470 篇文章 0 订阅

订阅专栏

最后我还整理了很多Android中高级的PDF技术文档。以及一些大厂面试真题解析文档。

Android高级架构师之路很漫长，一起共勉吧！

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

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

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

}

比如根据上面的接口生成一个这样的实现类：

public class OkHttpUserService implements UserService {

@Override

Call getASingleUser(String username) {

String url = buildUrl(annotations, username);

okhttp3.Call okHttpCall = new OkHttpClient().newCall(new Request.Builder().url(url).get().build());

return new Call(okHttpCall);

}

也就是说生成一个实现类，实现每个 API 方法，每个方法的内部实现 okhttp3.Call 的组装和调用，完成请求的执行以及结果的解析和封装

实现这样的代码生成有两种方式，一种是利用编译时注解和 APT 技术在编译时自动生成这样的实现类然后手动创建对象，一种是利用运行时注解和动态代理技术在运行时动态生成代理对象。Retrofit 选择了后者，即在运行时通过反射解析接口并生成代理对象

对于开发者，尤其是 Android 开发者，对性能的要求甚至到了苛刻的地步，对于枚举和反射等技术的使用更是敏感。传统方式虽然也能完成枚举和反射的工作，也会比枚举和反射更快一点，但是复杂度要更高，直观性不好。而枚举反射虽然性能差了一些但是要更加的简单直观，我觉得这是一个权衡问题（Trade off）。很多时候总是要做取舍的，就像有人花费了大量的时间、精力和资源把性能提升了一二十，可能在我看来不值得也没有必要。我用简单的方式实现了一个功能，可能在他人看来不够完美精致。所以我觉得以包容的态度看待技术还是很重要的

create

Retrofit 的 create 就是用来创建代理对象的，这个代理对象封装并实现了具体的网络请求逻辑。通过设计模式：代理模式一文我们已经知道，动态代理会把代理对象的 hashCode(), equals(), toString(), getASingleUser() 方法的调用都转发给 InvocationHandler 的 invoke 处理，所以只需要在 invoke 完成对 API 的解析和请求逻辑的封装即可，而 hashCode(), equals(), toString() 这些方法不需要特别处理：

if (method.getDeclaringClass() == Object.class) {

return method.invoke(this, args);

}

对于 getASingleUser() 方法，只需要把这个方法封装为 ServiceMethod 并调用它的 invoke 实现

loadServiceMethod(method).invoke(args);

HttpServiceMethod 或它的子类 CallAdapted 会利用 RequestFactory 完成对方法注解的解析以及请求 URL、Header 等的拼装，最终和 okhttp3.Call.Factory 一起完成对 okhttp3.Call 的组装

RequestFactory requestFactory = RequestFactory.parseAnnotations(retrofit, method);

…

for (Annotation annotation : method.getAnnotations()) {

parseMethodAnnotation(annotation);

}

…

private void parseMethodAnnotation(Annotation annotation) {

…

if (annotation instanceof GET) {

parseHttpMethodAndPath(“GET”, ((GET) annotation).value(), false);

}

…

}

…

RequestBuilder requestBuilder =

new RequestBuilder(

httpMethod,

baseUrl,

relativeUrl,

headers,

contentType,

hasBody,

isFormEncoded,

isMultipart);

…

return requestBuilder.get().tag(Invocation.class, new Invocation(method, argumentList)).build();

…

if (callFactory == null) {

callFactory = new OkHttpClient();

}

…

okhttp3.Call call = callFactory.newCall(requestFactory.create(args));

至此 Retrofit 已经组装好 okhttp3.Call 了，已经可以用了

而 Retrofit 灵活的一点是可以对这个 okhttp3.Call 进行封装，如封装成 retrofit2.Call、CompletableFuture、io.reactivex.Observable 等，这样你就可以随意选择自己喜欢的异步技术进行网络请求了

Retrofit 利用 CallAdapter.Factory 完成对 okhttp3.Call 的封装，利用 Converter.Factory 完成对请求响应的解析

Retrofit 默认有两个 CallAdapter.Factory，一个可以把 okhttp3.Call 封装成 CompletableFuture，一个可以把 okhttp3.Call 封装成 retrofit2.Call

List<CallAdapter.Factory> callAdapterFactories = new ArrayList<>(this.callAdapterFactories);

callAdapterFactories.addAll(platform.defaultCallAdapterFactories(callbackExecutor));

List<? extends CallAdapter.Factory> defaultCallAdapterFactories(

@Nullable Executor callbackExecutor) {

DefaultCallAdapterFactory executorFactory = new DefaultCallAdapterFactory(callbackExecutor);

return hasJava8Types

? asList(CompletableFutureCallAdapterFactory.INSTANCE, executorFactory)

singletonList(executorFactory);

}

Retrofit 默认有两个转换器，一个可以把响应转成 ResponseBody，一个可以把响应转成 Optional

converterFactories.add(new BuiltInConverters());

converterFactories.addAll(this.converterFactories);

converterFactories.addAll(platform.defaultConverterFactories());

…

List<? extends Converter.Factory> defaultConverterFactories() {

return hasJava8Types ? singletonList(OptionalConverterFactory.INSTANCE) : emptyList();

}

Retrofit 分析

Retrofit 最大个贡献是改变了描述 API 的方式，尤其是描述 RESTful API 的方式，让客户端对 API 的调用更加的简单、直观、安全

Retrofit 这种 “ 接口 + 抽象方法 + 注解 ” 的方式虽然可以实现 API 的描述，但是不能可视化，不能结构化，不能文档化，不能直接 mock，不能自动化测试，不能指定公共参数。所以我觉得换成 “ 配置文件(JSON?) + GUI 插件 ” 等其它方式要更好一点

ViewStub 29

只是一个占位，继承 View，不绘制（setWillNotDraw(true)），且宽高为 0（setMeasuredDimension(0, 0)），inflate() 就是从父容器中移除自己并 inflate 给定的 view 到自己的本来的位置（index 和 layoutParams），由于移除后就不知道自己的父容器了所以 inflate() 只能调用一次。ViewStub 的 setVisibility() 方法一般不建议使用，如果用，那么在没 inflate() 的情况下会自动调用 inflate()

Handler 29

Looper.prepare(); 可以给一个普通线程关联一个消息队列，Looper.loop(); 开始循环处理消息队列中的消息，new 一个 Handler 可以发送和处理消息，创建 Handler 需要指定 Looper，如果不指定那么表明是针对当前线程的 Looper 的，主线程有个创建好的 Looper.getMainLooper() 单例可以直接用

Looper.loop(); 是个死循环，循环获取队列中的消息，转发给消息的 target 去处理，也就是当初发送它的 Handler 去处理

而 Handler 处理消息的线程就是它关联的 Looper 所在的线程，也就是说创建 Handler 时传的 Looper 在哪个线程调用了 Looper.loop();，那么就在哪个线程回调 handleMessage()

for (;😉 {

Message msg = queue.next(); // might block

…

msg.target.dispatchMessage(msg);

}

queue.next() 最终调用的是名为 nativePollOnce() 的 native 方法，而该方法使用的是 epoll_wait 系统调用，表示自己在等待 I/O 事件，线程可以让出 CPU，等到 I/O 事件来了才可以进入 CPU 执行

而每次有新消息来的时候 enqueueMessage()，最终都会调用名为 nativeWake() 的 native 方法，该方法会产生 I/O 事件唤醒等待的线程

所以 nativePollOnce() / nativeWake() 就像对象的 wait() / notify() 一样，死循环并不会一直占用 CPU，如果没有消息要处理，就让出 CPU 进入休眠，只有被唤醒的时候才会进入 CPU 处理工作

IdleHandler 可以在消息队列中的消息都处理完了，进入休眠之前做一些工作，所以可以利用 Looper.myQueue().addIdleHandler() 做一些延迟任务，如在主线程中延迟初始化一些大对象或做一些可能耗时的操作

Handler 的延迟发消息功能如 sendMessageDelayed()，postDelayed() 是通过延迟唤醒实现的，在消息入队的时候就确定好消息要唤醒的时间，即 msg.when = SystemClock.uptimeMillis() + delayMillis，插入自己在队列中应该出现的位置，在取下一个消息时延迟 nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE) 时间去取即可

线程池技术保持线程活跃也是通过 epoll 机制实现的，死循环中阻塞地从队列中取消息，利用 LockSupport.park() 或 Condition 的 await() 就能让线程保持活跃的同时让出 CPU 等待事件

RecyclerView 1.1.0

术语

目的: 在有限的窗口中显示大量的数据

Adapter: 为数据集中的数据项提供对应的 View

Position: 数据项在数据集中的位置

Index: View 在容器中的位置

Binding: 为 position 位置的数据准备对应 View 的过程

Recycle (view): 之前使用过的 View 可能会被放到缓存中，之后在显示相同类型数据时可以直接拿出来重用

Scrap (view): 进入临时 detached 状态的 View，不用完全 detached 就能重用

Dirty (view): 在被显示前必须重新绑定的 View

LayoutManager 维护的 LayoutPosition 理论上和 Adapter 维护的 AdapterPosition 是一样的，但是对数据集 position 的修改是马上就起效的，而修改布局的 position 需要一定时间。所以最好在写 LayoutManager 的时候用 LayoutPosition，写 Adapter 的时候用 AdapterPosition

如果数据集发生了变化，而你想通过 Diff 算法提升性能（只刷新必要的 View），那么可以直接使用 ListAdapter 这个 Adapter，它会在后台线程中比较新 List 和旧 List 从而自动完成局部更新。或者在自己的 Adapter 中直接使用 AsyncListDiffer 实现。再或者直接使用 DiffUtil 工具比较列表也可以，更灵活，但也更繁琐

如果列表是有序的，那么使用 SortedList 可能比使用 List 要更好一些

onMeasure

作为容器，RecyclerView 要干两件事，在 onMeasure() 中确定自己和孩子的尺寸，在 onLayout() 中布局孩子的位置

如果没指定 LayoutManager 或者它的宽高都是 MeasureSpec.EXACTLY 的，那么就跟普通 View 一样默认测量就行了

if (mLayout == null) {

defaultOnMeasure(widthSpec, heightSpec);

return;

}

if (mLayout.isAutoMeasureEnabled()) {

final int widthMode = MeasureSpec.getMode(widthSpec);

final int heightMode = MeasureSpec.getMode(heightSpec);

mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);

final boolean measureSpecModeIsExactly =

widthMode == MeasureSpec.EXACTLY && heightMode == MeasureSpec.EXACTLY;

if (measureSpecModeIsExactly || mAdapter == null) {

return;

}

if (mState.mLayoutStep == State.STEP_START) {

dispatchLayoutStep1();

}

mLayout.setMeasureSpecs(widthSpec, heightSpec);

mState.mIsMeasuring = true;

dispatchLayoutStep2();

mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);

if (mLayout.shouldMeasureTwice()) {

mLayout.setMeasureSpecs(

MeasureSpec.makeMeasureSpec(getMeasuredWidth(), MeasureSpec.EXACTLY),

MeasureSpec.makeMeasureSpec(getMeasuredHeight(), MeasureSpec.EXACTLY));

mState.mIsMeasuring = true;

dispatchLayoutStep2();

mLayout.setMeasuredDimensionFromChildren(widthSpec, heightSpec);

}

} else {

if (mHasFixedSize) {

mLayout.onMeasure(mRecycler, mState, widthSpec, heightSpec);

return;

}

…

}

大部分 LayoutManager 的 isAutoMeasureEnabled() 都是 true，表示使用 RecyclerView 的 自动测量机制 进行测量，此时，LayoutManager#onMeasure(Recycler, State, int, int) 内部只是调用了 defaultOnMeasure()，不要重写这个方法。false 的话就得重写

第一步 dispatchLayoutStep1() 主要处理 Adapter 的更新和动画运行 processAdapterUpdatesAndSetAnimationFlags();，保存动画过程中的 View 状态 mViewInfoStore.addToPreLayout(holder, animationInfo);，必要的话还会预布局并保存信息 recordPreLayoutInformation()

第二步 dispatchLayoutStep2() 对孩子进行真正的测量和布局 mLayout.onLayoutChildren(mRecycler, mState);

你会发现 dispatchLayoutStep2() 可能被调用多次，你也会发现 dispatchLayoutStep1() 和 dispatchLayoutStep2() 既有测量的功能也有布局的功能，虽然在 measure 里布局有点奇怪，但是在真正 layout 的时候能省这两步时间

onLayout

onLayout() 中只是调用 dispatchLayout() 方法真正开始对子 View 进行布局

void dispatchLayout() {

if (mAdapter == null) {

Log.e(TAG, “No adapter attached; skipping layout”);

return;

}

if (mLayout == null) {

Log.e(TAG, “No layout manager attached; skipping layout”);

return;

}

mState.mIsMeasuring = false;

if (mState.mLayoutStep == State.STEP_START) {

dispatchLayoutStep1();

mLayout.setExactMeasureSpecsFrom(this);

dispatchLayoutStep2();

} else if (mAdapterHelper.hasUpdates() || mLayout.getWidth() != getWidth()

|| mLayout.getHeight() != getHeight()) {

// First 2 steps are done in onMeasure but looks like we have to run again due to

// changed size.

mLayout.setExactMeasureSpecsFrom(this);

dispatchLayoutStep2();

} else {

// always make sure we sync them (to ensure mode is exact)

mLayout.setExactMeasureSpecsFrom(this);

}

dispatchLayoutStep3();

}

最后一步 dispatchLayoutStep3(); 记录并开始 View 动画 mViewInfoStore.process(mViewInfoProcessCallback);，然后做一些必要的清理工作

onDraw

onDraw() 中只需要绘制 ItemDecoration 即可：

mItemDecorations.get(i).onDraw(c, this, mState);

但是对于边界装饰的绘制或者 ItemDecoration#onDrawOver() 的实现就要重写 draw() 方法了

mItemDecorations.get(i).onDrawOver(c, this, mState);

缓存

在第二步布局时 dispatchLayoutStep2() 会调用 mLayout.onLayoutChildren(mRecycler, mState);，所以在 onLayoutChildren() 中完成 View 的获取

以 LinearLayoutManager 的 onLayoutChildren() 为例，它的布局算法就是先检查孩子和其它变量，寻找锚点坐标，然后从尾到头的方向填充以及从头到尾的方向填充（fill()），然后滚动以满足需要

fill() 是一个神奇的方法，它可以在指定方向上填充满子 View

int fill(RecyclerView.Recycler recycler, LayoutState layoutState,

RecyclerView.State state, boolean stopOnFocusable) {

…

while ((layoutState.mInfinite || remainingSpace > 0) && layoutState.hasMore(state)) {

…

layoutChunk(recycler, state, layoutState, layoutChunkResult);

…

}

…

}

layoutChunk() 中就是取 View 的过程 View view = layoutState.next(recycler);

View next(RecyclerView.Recycler recycler) {

if (mScrapList != null) {

return nextViewFromScrapList();

}

final View view = recycler.getViewForPosition(mCurrentPosition);

mCurrentPosition += mItemDirection;

return view;

}

ViewHolder tryGetViewHolderForPositionByDeadline(int position,

boolean dryRun, long deadlineNs) {

…

if (mState.isPreLayout()) {

holder = getChangedScrapViewForPosition(position);

}

if (holder == null) {

holder = getScrapOrHiddenOrCachedHolderForPosition(position, dryRun);

}

if (holder == null) {

if (mAdapter.hasStableIds()) {

holder = getScrapOrCachedViewForId(mAdapter.getItemId(offsetPosition),

type, dryRun);

}

if (holder == null && mViewCacheExtension != null) {

final View view = mViewCacheExtension

.getViewForPositionAndType(this, position, type);

if (view != null) {

holder = getChildViewHolder(view);

}

if (holder == null) {

holder = getRecycledViewPool().getRecycledView(type);

}

if (holder == null) {

holder = mAdapter.createViewHolder(RecyclerView.this, type);

}

…

return holder;

}

ViewHolder getScrapOrHiddenOrCachedHolderForPosition(int position, boolean dryRun) {

final int scrapCount = mAttachedScrap.size();

for (int i = 0; i < scrapCount; i++) {

final ViewHolder holder = mAttachedScrap.get(i);

if (!holder.wasReturnedFromScrap() && holder.getLayoutPosition() == position

&& !holder.isInvalid() && (mState.mInPreLayout || !holder.isRemoved())) {

return holder;

}

if (!dryRun) {

View view = mChildHelper.findHiddenNonRemovedView(position);

if (view != null) {

final ViewHolder vh = getChildViewHolderInt(view);

mChildHelper.unhide(view);

mChildHelper.detachViewFromParent(layoutIndex);

scrapView(view);

return vh;

}

final int cacheSize = mCachedViews.size();

for (int i = 0; i < cacheSize; i++) {

final ViewHolder holder = mCachedViews.get(i);

if (!holder.isInvalid() && holder.getLayoutPosition() == position

&& !holder.isAttachedToTransitionOverlay()) {

if (!dryRun) {

mCachedViews.remove(i);

}

return holder;

}

return null;

}

所以取 ViewHolder(View) 的过程大体是这样的

总结：

各行各样都会淘汰一些能力差的，不仅仅是IT这个行业，所以，不要被程序猿是吃青春饭等等这类话题所吓倒，也不要觉得，找到一份工作，就享受安逸的生活，你在安逸的同时，别人正在奋力的向前跑，这样与别人的差距也就会越来越遥远，加油，希望，我们每一个人，成为更好的自己。

BAT大厂面试题、独家面试工具包,
资料包括数据结构、Kotlin、计算机网络、Framework源码、数据结构与算法、小程序、NDK、Flutter，

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

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

tachedToTransitionOverlay()) {

if (!dryRun) {

mCachedViews.remove(i);

}

return holder;

}

return null;

}

所以取 ViewHolder(View) 的过程大体是这样的

总结：

BAT大厂面试题、独家面试工具包,
资料包括数据结构、Kotlin、计算机网络、Framework源码、数据结构与算法、小程序、NDK、Flutter，

[外链图片转存中…(img-mO4HD7Tf-1715607357024)]
[外链图片转存中…(img-WC1SEWru-1715607357024)]

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

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