2024年最全Android开发之玩转 Gradle，你可不能不熟悉 Transform，2024年最新2024-2024阿里巴巴Android面试真题解析-CSDN博客

本文链接：https://blog.csdn.net/2401_84520093/article/details/138982290

面试宝典

面试必问知识点、BATJ历年历年面试真题+解析

学习经验总结

（一）调整好心态
心态是一个人能否成功的关键，如果不调整好自己的心态，是很难静下心来学习的，尤其是现在这么浮躁的社会，大部分的程序员的现状就是三点一线，感觉很累，一些大龄的程序员更多的会感到焦虑，而且随着年龄的增长，这种焦虑感会越来越强烈，那么唯一的解决办法就是调整好自己的心态，要做到自信、年轻、勤奋。这样的调整，一方面对自己学习有帮助，另一方面让自己应对面试更从容，更顺利。

（二）时间挤一挤，制定好计划
一旦下定决心要提升自己，那么再忙的情况下也要每天挤一挤时间，切记不可“两天打渔三天晒网”。另外，制定好学习计划也是很有必要的，有逻辑有条理的复习，先查漏补缺，然后再系统复习，这样才能够做到事半功倍，效果才会立竿见影。

（三）不断学习技术知识，更新自己的知识储备
对于一名程序员来说，技术知识方面是非常重要的，可以说是重中之重。**要面试大厂，自己的知识储备一定要非常丰富，若缺胳膊少腿，别说在实际工作当中，光是面试这一关就过不了。**对于技术方面，首先基础知识一定要扎实，包括自己方向的语言基础、计算机基础、算法以及编程等等。

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

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

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

// now add a transform that will take all the native libs and package

// them into an intermediary folder. This processes only the PROJECT

// scope.

final File intermediateJniLibsFolder = new File(jarOutputFolder, FD_JNI);

LibraryJniLibsTransform intermediateJniTransform =

new LibraryJniLibsTransform(

“intermediateJniLibs”,

intermediateJniLibsFolder,

TransformManager.PROJECT_ONLY);

transformManager.addTransform(

taskFactory,

variantScope,

intermediateJniTransform,

taskName -> {

// publish the jni folder as intermediate

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.LIBRARY_JNI,

ImmutableList.of(intermediateJniLibsFolder),

taskName);

null,

null);

// Now go back to fill the pipeline with transforms used when

// publishing the AAR

// first merge the resources. This takes the PROJECT and LOCAL_DEPS

// and merges them together.

createMergeJavaResTransform(variantScope);

// ----- Minify next -----

maybeCreateJavaCodeShrinkerTransform(variantScope);

maybeCreateResourcesShrinkerTransform(variantScope);

// now add a transform that will take all the class/res and package them

// into the main and secondary jar files that goes in the AAR.

// This transform technically does not use its transform output, but that’s

// ok. We use the transform mechanism to get incremental data from

// the streams.

// This is used for building the AAR.

File classesJar = variantScope.getAarClassesJar();

File libsDirectory = variantScope.getAarLibsDirectory();

LibraryAarJarsTransform transform =

new LibraryAarJarsTransform(

classesJar,

libsDirectory,

artifacts.hasArtifact(InternalArtifactType.ANNOTATIONS_TYPEDEF_FILE)

? artifacts.getFinalArtifactFiles(

InternalArtifactType.ANNOTATIONS_TYPEDEF_FILE)

null,

variantConfig::getPackageFromManifest,

extension.getPackageBuildConfig());

excludeDataBindingClassesIfNecessary(variantScope, transform);

transformManager.addTransform(

taskFactory,

variantScope,

transform,

taskName -> {

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.AAR_MAIN_JAR,

ImmutableList.of(classesJar),

taskName);

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.AAR_LIBS_DIRECTORY,

ImmutableList.of(libsDirectory),

taskName);

null,

null);

// now add a transform that will take all the native libs and package

// them into the libs folder of the bundle. This processes both the PROJECT

// and the LOCAL_PROJECT scopes

final File jniLibsFolder =

variantScope.getIntermediateDir(InternalArtifactType.LIBRARY_AND_LOCAL_JARS_JNI);

LibraryJniLibsTransform jniTransform =

new LibraryJniLibsTransform(

“syncJniLibs”,

jniLibsFolder,

TransformManager.SCOPE_FULL_LIBRARY_WITH_LOCAL_JARS);

transformManager.addTransform(

taskFactory,

variantScope,

jniTransform,

taskName ->

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.LIBRARY_AND_LOCAL_JARS_JNI,

ImmutableList.of(jniLibsFolder),

taskName),

null,

null);

createLintTasks(variantScope);

createBundleTask(variantScope);

}

自定义Transform和其他系统Transform执行的顺序

而且上述方法我们可以看出，任务还是会根据DAG（有向无环图）生成Task，其中会包含一些系统的Transform，其顺序有可能会被插入到自定义的Transform之前，而有一些则会被放置在所有的Tranform执行之后。比如LibraryJniLibsTransform。

Transform和Task的关系

从这部分源代码其实我们就可以看出，我们注册到AppExtension里面的Transform,最后会createTasksForVariantScope方法调用到。

@NonNull

public Optional<TaskProvider> addTransform(

@NonNull TaskFactory taskFactory,

@NonNull TransformVariantScope scope,

@NonNull T transform,

@Nullable PreConfigAction preConfigAction,

@Nullable TaskConfigAction configAction,

@Nullable TaskProviderCallback providerCallback) {

if (!validateTransform(transform)) {

// validate either throws an exception, or records the problem during sync

// so it’s safe to just return null here.

return Optional.empty();

}

List inputStreams = Lists.newArrayList();

String taskName = scope.getTaskName(getTaskNamePrefix(transform));

// get referenced-only streams

List referencedStreams = grabReferencedStreams(transform);

// find input streams, and compute output streams for the transform.

IntermediateStream outputStream = findTransformStreams(

transform,

scope,

inputStreams,

taskName,

scope.getGlobalScope().getBuildDir());

if (inputStreams.isEmpty() && referencedStreams.isEmpty()) {

// didn’t find any match. Means there is a broken order somewhere in the streams.

issueReporter.reportError(

Type.GENERIC,

new EvalIssueException(

String.format(

“Unable to add Transform ‘%s’ on variant ‘%s’: requested streams not available: %s+%s / %s”,

transform.getName(),

scope.getFullVariantName(),

transform.getScopes(),

transform.getReferencedScopes(),

transform.getInputTypes())));

return Optional.empty();

}

//noinspection PointlessBooleanExpression

if (DEBUG && logger.isEnabled(LogLevel.DEBUG)) {

logger.debug(“ADDED TRANSFORM(” + scope.getFullVariantName() + “):”);

logger.debug("\tName: " + transform.getName());

logger.debug("\tTask: " + taskName);

for (TransformStream sd : inputStreams) {

logger.debug("\tInputStream: " + sd);

}

for (TransformStream sd : referencedStreams) {

logger.debug("\tRef’edStream: " + sd);

}

if (outputStream != null) {

logger.debug("\tOutputStream: " + outputStream);

}

transforms.add(transform);

// create the task…

return Optional.of(

taskFactory.register(

new TransformTask.CreationAction<>(

scope.getFullVariantName(),

taskName,

transform,

inputStreams,

referencedStreams,

outputStream,

recorder),

preConfigAction,

configAction,

providerCallback));

}

然后我们看transformManager.addTransform,直接观察最后一行代码，发现我们会往taskFactory中直接注册一个TransformTask，那么回答第一个问题，一个Transform就是gradle plugin中的一个原子的Task，所以Transform==Task。

Transform是如何被执行的

当我们知道Transform的本质是Task之后就知道了，他会和一个普通的Task一样被执行，而且会按照特定的依赖顺序执行。