组件通讯设计原理及注入实现原理

最新推荐文章于 2023-10-29 01:54:37 发布
最新推荐文章于 2023-10-29 01:54:37 发布
阅读量223 收藏
点赞数
分类专栏： Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39756073/article/details/115582016
版权

组件通讯设计原理及注入实现原理

主要涉及一下核心知识点

  • 注解
  • 注解处理器
  • 自动生成代码 (javapoet/kotlinpoet)
  • 自定义插件
  • ASM
  • transform

本文主要设计设计和思考实现思路、 解决问题的方式及经验， 至于以上的各个知识点网上一大把， 读者可自行学习， 这里不再陈述。

所有功能已进行实现， 其用方式依赖及实现源码已在 Github 上 ServiceAssistant， 该库不管组件通讯的 Service 还是进行注入操作 Injected 都是懒加载， 而且一步到位， 跟用户直接设计一个单例对象或者 new 一个对象一样， 用户可以直接去依赖使用或者阅读源码。 当然整个库使用和一个组件化的设计思路及写法也可直接阅读 Demo。

以组件通讯开始

Android 项目的组件化的好处不在多提， 我们知道组件之间是单独独立不能相互依赖的， 那么组件化可能遇到的一个很大的阻力就是组件之间怎么通讯呢？ 当然现在也有很好的通讯方式比如 Aroute 等， 但有没有更加灵活和方便的或者说一个新的方式去进行组件通讯或者注入呢， 还有就是解决组件之间设置回调， 这就是我写这个库和文字的初衷。

我们设计组件化， 那么每个组件都是可以单独运行的， 最简单的模型如下:

组件化基本模型

以上可能是最小的一个组件化模型了， 从上面的图设计可以思考如下:

  • 组件 A 和组件 B 之间是没有任何连线也就是没有依赖， 组件 A 和 组件 B 怎么相互调用进行通讯呢？
  • 如果想让组件 A 和 组件 B 单独运行， 当然 App 壳也可以单独运行。 乖乖， 不说组件 A， 组件 B 单独运行了， 当 组件 A 或者 组件 B 设置成单独运行时， App 壳就不能去依赖这个单独运行的组件了， 想让 App 壳也单独运行， 那么 App 壳就不能强依赖于组件了， 这该怎么解决？

当然以上问题都在该库中解决， 还有一个惊喜就是在实现该库时顺便加入了注入的另一个功能， 也方便使用者可以使用该库可以方便使用注入功能。

那么好我们就开始去分析和解决以上问题。

组件之间的通讯

通过上面的组件图可以看出， 组件之间是没有依赖的。 我们思考去想想， 组件 A 想去调用组件 B 的某个功能， 组件 A 必须要知道 组件 B 都提供出来了什么功能吧， 如果组件 A 完全不知道 B 给我们提供出什么的话， 谈什么去调用 组件 B 呢， 就行我们要去调用 Android 系统的服务时， 就比如我们去调用获取图片， 我们总要知道系统给我们提供了什么能力去调用吧， 所以我们设计出一个组件的时候需要设计我们向外部抛出公开什么能力供别人去调用。

大概设计图如下:

组件通讯模型

其中 ApiA 和 ApiB 里都是接口， 也就是组件 A 和组件 B 向外部公开出来的能力， 当然比如组件 A 提供的能力 ApiA 的实现肯定是组件 A 内部去实现， 组件 B 提供出来的能力 ApiB 肯定是 组件 B 内部去实现。 如果组件 A 去调用组件 B 的能力， 只需要知道组件 B 提供出来什么能力， 也就是去依赖 ApiB 即可， 反之 组件 B 去调用组件 A 的能力也是一样。 那么组件去依赖另一个组件提供出来的能力也就是接口， 怎么去调用到对应的实现呢， 这， 这就是该库要做的事情了。

先介绍下库的使用:

比如我们在组件 A 中公开登录的能力 (ApiA)

interface ILoginAbilityApi {

    /**
     * 登录
     */
    fun toLogin(context: Context)

    fun addLoginStateChangedListener(listener: ILoginStateChangedListener)

    fun removeLoginStateChangeListener(listener: ILoginStateChangedListener)

    interface ILoginStateChangedListener {
        fun change(state: Boolean)
    }
}

在组件 A 中去实现该能力

@Service
class LoginAbilityApiImpl : IService<ILoginAbilityApi>, ILoginAbilityApi {

    /**
     * 使用方提供
     */
    override fun getService(): ILoginAbilityApi {
        return LoginAbilityApiImpl()
    }

    /**
     * 登录
     */
    override fun toLogin(context: Context) {
        LoginActivity.showActivity(context)
    }

    override fun addLoginStateChangedListener(listener: ILoginAbilityApi.ILoginStateChangedListener) {
        sLoginStateChangedListener.add(listener)
    }

    override fun removeLoginStateChangeListener(listener: ILoginAbilityApi.ILoginStateChangedListener) {
        sLoginStateChangedListener.remove(listener)
    }

    companion object {
        private val sLoginStateChangedListener =
            mutableListOf<ILoginAbilityApi.ILoginStateChangedListener>()

        fun notifyLoginState(state: Boolean) {
            sLoginStateChangedListener.forEach {
                it.change(state)
            }
        }
    }

}

那么在组件 B 中去依赖 组件 A 提供出来的能力 ApiA, 去调用登录的写法如下:

val service = Service.getService(ILoginAbilityApi::class.java)
if (service == null) {
    Toast.makeText(this, "未发现登录组件", Toast.LENGTH_SHORT).show()
    return
}
    
service.toLogin(this)

在这里请允许我提下注入使用:

定义接口:

interface IAccountRepo {

    fun getAccountData(): String
}

实现接口:

@NeedInjected
class AccountRepoImpl : IAccountRepo {

    override fun getAccountData(): String {
        return "account data"
    }

}

使用:

class MainActivity : AppCompatActivity() {

    @Injected
    private lateinit var mAboutRepo: IAboutRepo

    @Injected
    private lateinit var mSettingRepo: ISettingRepo

    @Injected
    private lateinit var mAccountRepo: IAccountRepo
    
}

那么好， 那我们刚才说的第二个问题不也就迎刃而解了嘛， 请看下图:

上层访问下层

okk， 开始我们的实现思考及原理之旅。

组件化通讯之 Service 的实现原理（注解、 插件、 ASM、 transform）

总体实现思路: 我们把所有 api 及实现服务对应收集起来， 放到一个固定的 map 中， 当然中间要去实现的时候要考虑到其单例和懒加载。 然后我们需要什么服务时直接去从这个 map 拿不就 OK 了吗？ 是的。 如果我们从这个固定 map 中取， 取到了就是找到了该组件， 如果取不到就是没有找到该组件。

map 里我们存什么呢？ 肯定是 api 和实现的对应关系哈。

收集所有的 api 及实现

通过 transfrom 去扫描所有的 api 及实现， 那么最简单的来个注解吧， 然后直接扫描到该注解然后获取该类的信息收集出来就可以， 所以我们加一个 @Service 注解。

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Service

我们扫描搜集的对应关系利用 ASM 合理的保存到一个固定 Service 中， 当然这个也是使用者获取对应服务的一个入口。 其中我们要保存的对应关系合理的写入 getService 方法中。

object Service {

    private val sServiceRelation = mutableMapOf<String, Any?>()
    private val sLock = Any()

    @JvmStatic
    fun <T> getService(clazz: Class<T>): T? {
        return null
    }
}

使用 transform 去扫描 jar 和 dir 类上面有注解的的信息并收集。 其伪代码如下:

  • transfrom:
class ServiceAssistantTransform : Transform() {

    private val mNeedScanClassInfo = mutableListOf<Pair<String, String>>()
    private var mServiceFile: File? = null
    
    override fun transform(transformInvocation: TransformInvocation?) {
    	
    	1. 扫描所有的 dir 中的文件 {
    		ServiceAssistantClassVisitor(去扫描处理) {
    			1.1 把扫描出来的对应关系保存到 mNeedScanClassInfo 中。
    			1.2 把里面处理完的放到到输出文件中。
    		}
    	}
    	
    	2. 扫描所有 jar 中的文件 {
    		ServiceAssistantClassVisitor(去扫描处理) {
	    		2.1 把扫描出来的对应关系保存到 mNeedScanClassInfo 中。
	    		2.2 把里面处理完的放到到输出文件中。
	    		2.3 如果扫描到我们需要的写入对应关系的类的输出文件进行先保存只 mServiceFile 中， 以便后面使用。
	    	}
    	}
    }
    
}
  • ServiceAssistantClassVisitor (去访问类信息)
class ServiceAssistantClassVisitor(
    private val byteArray: ByteArray,
    private val serviceTargetFindBack: () -> Unit,
    private val needScanClassInfoBack: (String, String) -> Unit
) : ClassVisitor(Opcodes.ASM7) {

    private lateinit var mVisitorClassName: String
    private lateinit var mVisitorClassSignature: String

    override fun visit(
        version: Int,
        access: Int,
        name: String?,
        signature: String?,
        superName: String?,
        interfaces: Array<out String>?
    ) {
        super.visit(version, access, name, signature, superName, interfaces)
        this.mVisitorClassName = name ?: ""
        this.mVisitorClassSignature = signature ?: ""
        // 这里就是如果扫描到我们要存放对应关系的 Service 类， 回调出去。
        if (this.mVisitorClassName == ServiceAssistantConstant.PATH_SERVICE_REFERENCE) {
            // is service
            serviceTargetFindBack.invoke()
        }
    }

    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {

        descriptor?.let {
			// 我们只关注的 Service 注解
            if (it.indexOf(ServiceAssistantConstant.SIGNATURE_SERVICE_ANNOTATION) < 0) return@let
            
            // ......
            
            // 获取出来我们加入注解的对应关系并回调出去进行收集
            needScanClassInfoBack.invoke(
                targetInterface.replace("/", "."),
                mVisitorClassName
            )
        }
        return super.visitAnnotation(descriptor, visible)
    }

}

通过我们以上 transform 1 和 2 步我们可以得到所有的服务对应关系及我们需要插入代码的 Service 类所在的文件。

那么好我们现在要做的就是把所收集的对应关系使用 ASM 重新合理的插入目标 Service 类中， 如果我们插入成功了， 那么我们运行的时候直接从 Service 中获取不就完事了嘛。

我们已经有存在目标 Service 类的 jar 文件了， 那么我们直接在此扫描这一个文件即可。 伪代码如下:

  • 扫描存在 Service 目标类的 jar 文件
扫描存在目标 Service 的 jar 文件 {
	1. 找到 Service 类并进行访问处理
	2. 注意注意！！！ 这里是覆盖哈， 把我们处理完后的 jar 直接覆盖之前没有处理的 jar 文件哈， 如果在复制的话就重复了。 
}
  • 访问 Service 类找到我们要插入代码的方法， 并在此访问改方法进行处理
class ServiceClassVisitor(
    private val byteArray: ByteArray,
    private val needInsertInfo: List<Pair<String, String>>
) :
    ClassVisitor(Opcodes.ASM7) {

    override fun visitMethod(
        access: Int,
        name: String?,
        descriptor: String?,
        signature: String?,
        exceptions: Array<out String>?
    ): MethodVisitor {
		if(如果是我们要插入的方法){
			return 处理该方法
		}
		
		super.visitMethod(access, name, descriptor, signature, exceptions)
    }
}
  • 利用 ASM 合理的写入我们的目标 Service 中 getService 方法中
class ServiceClassMethodVisitor(
    private val needInsertInfo: List<Pair<String, String>>,
    methodVisitor: MethodVisitor, access: Int, name: String?, desc: String?
) :
    AdviceAdapter(Opcodes.ASM7, methodVisitor, access, name, desc) {

    override fun onMethodExit(opcode: Int) {
        super.onMethodExit(opcode)

        mv.visitCode()
        val label0 = Label()
        val label1 = Label()
        val label2 = Label()
        mv.visitTryCatchBlock(label0, label1, label2, null)
        val label3 = Label()
        val label4 = Label()
        mv.visitTryCatchBlock(label3, label4, label2, null)
        val label5 = Label()
        mv.visitTryCatchBlock(label2, label5, label2, null)
        val label6 = Label()
        mv.visitLabel(label6)
        mv.visitVarInsn(Opcodes.ALOAD, 0)
        mv.visitMethodInsn(
            Opcodes.INVOKEVIRTUAL,
            ServiceAssistantConstant.PATH_CLASS,
            ServiceAssistantConstant.DESC_GET_NAME,
            ServiceAssistantConstant.DESC_RETURN_STRING_FULL,
            false
        )
        mv.visitVarInsn(Opcodes.ASTORE, 1)
        val label7 = Label()
        mv.visitLabel(label7)
        mv.visitFieldInsn(
            Opcodes.GETSTATIC,
            ServiceAssistantConstant.PATH_SERVICE_REFERENCE,
            ServiceAssistantConstant.DESC_S_SERVICE_RELATION,
            ServiceAssistantConstant.SIGNATURE_MAP
        )
        mv.visitVarInsn(Opcodes.ALOAD, 1)
        mv.visitMethodInsn(
            Opcodes.INVOKEINTERFACE,
            ServiceAssistantConstant.PATH_MAP,
            ServiceAssistantConstant.DESC_GET,
            ServiceAssistantConstant.SIGNATURE_OBJECT_OBJECT,
            true
        )
        mv.visitVarInsn(Opcodes.ASTORE, 2)
        val label8 = Label()
        mv.visitLabel(label8)
        mv.visitVarInsn(Opcodes.ALOAD, 2)
        val label9 = Label()
        mv.visitJumpInsn(Opcodes.IFNULL, label9)
        val label10 = Label()
        mv.visitLabel(label10)
        mv.visitVarInsn(Opcodes.ALOAD, 2)
        mv.visitInsn(Opcodes.ARETURN)
        mv.visitLabel(label9)
        mv.visitFrame(
            Opcodes.F_APPEND,
            2,
            arrayOf<Any>(
                ServiceAssistantConstant.PATH_STRING,
                ServiceAssistantConstant.PATH_OBJECT
            ),
            0,
            null
        )
        mv.visitFieldInsn(
            Opcodes.GETSTATIC,
            ServiceAssistantConstant.PATH_SERVICE_REFERENCE,
            ServiceAssistantConstant.DESC_S_LOCK,
            ServiceAssistantConstant.SIGNATURE_OBJECT
        )
        mv.visitInsn(Opcodes.DUP)
        mv.visitVarInsn(Opcodes.ASTORE, 3)
        mv.visitInsn(Opcodes.MONITORENTER)
        mv.visitLabel(label0)
        mv.visitFieldInsn(
            Opcodes.GETSTATIC,
            ServiceAssistantConstant.PATH_SERVICE_REFERENCE,
            ServiceAssistantConstant.DESC_S_SERVICE_RELATION,
            ServiceAssistantConstant.SIGNATURE_MAP
        )
        mv.visitVarInsn(Opcodes.ALOAD, 1)
        mv.visitMethodInsn(
            Opcodes.INVOKEINTERFACE,
            ServiceAssistantConstant.PATH_MAP,
            ServiceAssistantConstant.DESC_GET,
            ServiceAssistantConstant.SIGNATURE_OBJECT_OBJECT,
            true
        )
        mv.visitVarInsn(Opcodes.ASTORE, 2)
        val label11 = Label()
        mv.visitLabel(label11)
        mv.visitVarInsn(Opcodes.ALOAD, 2)
        mv.visitJumpInsn(Opcodes.IFNULL, label3)
        val label12 = Label()
        mv.visitLabel(label12)
        mv.visitVarInsn(Opcodes.ALOAD, 2)
        mv.visitVarInsn(Opcodes.ALOAD, 3)
        mv.visitInsn(Opcodes.MONITOREXIT)
        mv.visitLabel(label1)
        mv.visitInsn(Opcodes.ARETURN)
        mv.visitLabel(label3)

        needInsertInfo.forEach {
            mv.visitFrame(
                Opcodes.F_APPEND,
                1,
                arrayOf<Any>(ServiceAssistantConstant.PATH_OBJECT),
                0,
                null
            )
            mv.visitLdcInsn(it.first)
            mv.visitVarInsn(Opcodes.ALOAD, 1)
            mv.visitMethodInsn(
                Opcodes.INVOKEVIRTUAL,
                ServiceAssistantConstant.PATH_STRING,
                ServiceAssistantConstant.DESC_EQUALS,
                ServiceAssistantConstant.SIGNATURE_OBJECT_BOOLEAN,
                false
            )
            val label13 = Label()
            mv.visitJumpInsn(Opcodes.IFEQ, label13)
            val label14 = Label()
            mv.visitLabel(label14)
            mv.visitTypeInsn(
                Opcodes.NEW,
                it.second.replace(".", "/")
            )
            mv.visitInsn(Opcodes.DUP)
            mv.visitMethodInsn(
                Opcodes.INVOKESPECIAL,
                it.second.replace(".", "/"),
                ServiceAssistantConstant.DESC_INIT,
                ServiceAssistantConstant.DESC_SIGNATURE_CONSTRUCTORS,
                false
            )
            mv.visitVarInsn(Opcodes.ASTORE, 2)
            val label15 = Label()
            mv.visitLabel(label15)
            mv.visitFieldInsn(
                Opcodes.GETSTATIC,
                ServiceAssistantConstant.PATH_SERVICE_REFERENCE,
                ServiceAssistantConstant.DESC_S_SERVICE_RELATION,
                ServiceAssistantConstant.SIGNATURE_MAP
            )
            mv.visitVarInsn(Opcodes.ALOAD, 1)
            mv.visitVarInsn(Opcodes.ALOAD, 2)
            mv.visitMethodInsn(
                Opcodes.INVOKEINTERFACE,
                ServiceAssistantConstant.PATH_MAP,
                ServiceAssistantConstant.DESC_PUT,
                ServiceAssistantConstant.SIGNATURE_OBJECT_OBJECT_OBJECT,
                true
            )
            mv.visitInsn(Opcodes.POP)
            mv.visitLabel(label13)
        }

        mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null)
        mv.visitVarInsn(Opcodes.ALOAD, 2)
        mv.visitVarInsn(Opcodes.ALOAD, 3)
        mv.visitInsn(Opcodes.MONITOREXIT)
        mv.visitLabel(label4)
        mv.visitInsn(Opcodes.ARETURN)
        mv.visitLabel(label2)
        mv.visitFrame(
            Opcodes.F_SAME1,
            0,
            null,
            1,
            arrayOf<Any>(ServiceAssistantConstant.PATH_THROWABLE)
        )
        mv.visitVarInsn(Opcodes.ASTORE, 4)
        mv.visitVarInsn(Opcodes.ALOAD, 3)
        mv.visitInsn(Opcodes.MONITOREXIT)
        mv.visitLabel(label5)
        mv.visitVarInsn(Opcodes.ALOAD, 4)
        mv.visitInsn(Opcodes.ATHROW)
        val label16 = Label()
        mv.visitLabel(label16)
        mv.visitLocalVariable(
            ServiceAssistantConstant.DESC_CLAZZ,
            ServiceAssistantConstant.SIGNATURE_CLASS,
            ServiceAssistantConstant.SIGNATURE_CLASS_T_T,
            label6,
            label16,
            0
        )
        mv.visitLocalVariable(
            ServiceAssistantConstant.DESC_NAME,
            ServiceAssistantConstant.SIGNATURE_STRING,
            null,
            label7,
            label16,
            1
        )
        mv.visitLocalVariable(
            ServiceAssistantConstant.DESC_SERVICE,
            ServiceAssistantConstant.SIGNATURE_OBJECT,
            null,
            label8,
            label16,
            2
        )
        mv.visitMaxs(3, 5)
        mv.visitEnd()

    }

}

其中这里面哪些代码我也看不懂， 我们可以利用 ASM 插件生成这些代码， 其插件是 ASM Bytecode Viewer。 这个使用的技巧和心得我们在后面进行讲解。

总之利用上面的在 Service 类最终的代码如下:

object Service {

    private val sServiceRelation = mutableMapOf<String, Any?>()
    private val sLock = Any()

    @JvmStatic
    fun <T> getService(clazz: Class<T>): T? {
        val name = clazz.name
        var service = sServiceRelation[name]
        if (service != null) {
            return service as T?
        }
        synchronized(sLock) {
            service = sServiceRelation[name]
            if (service != null) {
                return service as T?
            }

            if ("cn.xiaoxige.loginapi.ILoginAbilityApi" == name) {
                service = LoginAbilityApiImpl()
                sServiceRelation[name] = service
                return service as T?
            }

            if ("xxx" == name) {
                service = xxxImpl()
                sServiceRelation[name] = service
                return service as T?
            }
        }
        return null
    }
}

看到了嘛， 这个时候使用 Service.getService(xxx::class.java) 即可获取到对应的实现啦！

注入的实现原理（注解处理器、 javepoet、 transform、 ASM）

这个的实现稍微比较复杂点， 总体思路如下:

通过注解处理器找到通过 NeedInjected 注解的类信息, 然后利用 javapoet 进行生成一个对应的代理初始化类（这个类的类名是以接口名 + Producer）， 然后通过 transform 扫描所有的 Injected 注解的属性， 在对应的类的构造函数中对其进行赋值， 也就是调用 javepoet 生成的代理初始化类进行赋值。

让我们开始注解处理器收集 NeedInjected 注解的类信息并使用 javapoet 进行生成相应的代理初始化类吧。

注解处理器

@AutoService(Processor::class)
class AnnotationProcessor : AbstractProcessor() {

    private lateinit var mFiler: Filer

    private val mNeedInjectedInfo = mutableMapOf<String, Pair<String, Boolean>>()

    override fun init(p0: ProcessingEnvironment?) {
        super.init(p0)
        this.mFiler = p0.filer
    }
    
    override fun process(p0: MutableSet<out TypeElement>?, p1: RoundEnvironment?): Boolean {
        if (p0 == null || p0.isEmpty()) return false
        p0.forEach { element ->
            if (element.qualifiedName.contentEquals(NeedInjected::class.java.canonicalName)) {
                p1?.getElementsAnnotatedWith(NeedInjected::class.java)?.forEach {
						// ......
						// 收集信息
                    if (handleNeedInjected(it as TypeElement).not()) return false
                }
            }
        }
        
        // 生成相应的代理初始化类
        mNeedInjectedInfo.keys.forEach {
            val value = mNeedInjectedInfo[it]
            AutoWriteInjectedInfoProducer(
                it,
                value,
                mFiler
            ).write()
        }

        mNeedInjectedInfo.clear()

        return true
    }

    private fun handleNeedInjected(
        needInjected: TypeElement
    ): Boolean {
        val interfaces = needInjected.interfaces
        if (interfaces.isEmpty() || interfaces.size > 1) {
            e("Currently, only one interface injection is supported")
        }
        val interfacePath = interfaces[0].toString()
        val annotation = needInjected.getAnnotation(NeedInjected::class.java)
        mNeedInjectedInfo[interfacePath] =
            Pair(needInjected.qualifiedName.toString(), annotation.isSingleCase)
        return true
    }

}

其中 mNeedInjectedInfo 保存了所有 NeedInjected 注解信息和对应的类信息。 (Map<接口, Pair<类, 是否为单例>>)

利用 javapoet 生成代理初始化类


class AutoWriteInjectedInfoProducer(
    private val injectedInterface: String,
    private val needInjectedInfo: Pair<String, Boolean>?,
    private val filer: Filer
) {

    fun write() {

        // 生成类相关的信息
        val injectedInfoProducerFullClass = getInjectedProducerClassFullName()
        val injectedInfoProducerFullClassInfo =
            injectedInfoProducerFullClass.getPackageAndClassName()

        // 目标接口信息
        val injectedInterfaceInfo = injectedInterface.getPackageAndClassName()

        // 注解
        val annotation =
            AnnotationSpec.builder(ClassName.get("androidx.annotation", "Keep")).build()

        // 属性
        val field = createField(
            injectedInterfaceInfo.first,
            injectedInterfaceInfo.second
        )
        val lockField = createLockField()

        // 方法
        val method = createMethod(injectedInterfaceInfo)

        val autoClass = TypeSpec.classBuilder(injectedInfoProducerFullClassInfo.second)
            .addJavadoc("This class is a Service Assistant Processor transfer center class.\n which is automatically generated. Please do not make any changes.\n")
            .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
            .addAnnotation(annotation)
            .addField(lockField)
            .addField(field)
            .addMethod(method)
            .build()

        JavaFile.builder(injectedInfoProducerFullClassInfo.first, autoClass)
            .build().writeTo(filer)
    }

    private fun createField(packageInfo: String, className: String): FieldSpec {
        return FieldSpec.builder(ClassName.get(packageInfo, className), NAME_TARGET_INSTANCE)
            .addModifiers(Modifier.STATIC, Modifier.PRIVATE)
            .addJavadoc("target entity class")
            .initializer("null")
            .build()
    }

    private fun createLockField(): FieldSpec {
        return FieldSpec.builder(
            Any::class.java,
            "sLock",
            Modifier.PRIVATE,
            Modifier.FINAL,
            Modifier.STATIC
        )
            .addJavadoc("Changed mainly for lock guarantee instance\n")
            .initializer("""new ${'$'}T()""", Any::class.java)
            .build()
    }

    private fun createMethod(injectedInterfaceInfo: Pair<String, String>): MethodSpec {

        val methodSpaceBuilder = MethodSpec
            .methodBuilder(NAME_GET_TARGET_INSTANCE_METHOD)
            .addJavadoc("How to get the target instance")
            .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
            .returns(ClassName.get(injectedInterfaceInfo.first, injectedInterfaceInfo.second))

        // 如果未发现, 那么直接返回 null
        if (needInjectedInfo == null) {
            return methodSpaceBuilder.addStatement("return null").build()
        }

        // 生成目标对象的信息
        val needInjectedInterfaceInfo = needInjectedInfo.first.getPackageAndClassName()
        // 如果为非单例, 那么每次都会产生一个新对象
        if (!needInjectedInfo.second) {
            return methodSpaceBuilder.addStatement(
                """return new ${'$'}T()""",
                ClassName.get(needInjectedInterfaceInfo.first, needInjectedInterfaceInfo.second)
            ).build()
        }

        // 单例模式
        methodSpaceBuilder.beginControlFlow("if($NAME_TARGET_INSTANCE != null)")
        methodSpaceBuilder.addStatement("return $NAME_TARGET_INSTANCE")
        methodSpaceBuilder.endControlFlow()

        methodSpaceBuilder.beginControlFlow("synchronized(sLock)")

        // 再次判断是否为空
        methodSpaceBuilder.beginControlFlow("if($NAME_TARGET_INSTANCE != null)")
        methodSpaceBuilder.addStatement("return $NAME_TARGET_INSTANCE")
        methodSpaceBuilder.endControlFlow()

        methodSpaceBuilder.addStatement(
            """$NAME_TARGET_INSTANCE = new ${'$'}T()""",
            ClassName.get(needInjectedInterfaceInfo.first, needInjectedInterfaceInfo.second)
        )
        methodSpaceBuilder.addStatement("return $NAME_TARGET_INSTANCE")

        methodSpaceBuilder.endControlFlow()

        return methodSpaceBuilder.build()
    }

    private fun getInjectedProducerClassFullName(): String = "${injectedInterface}Producer"

    companion object {
        private const val NAME_TARGET_INSTANCE = "sInstance"
        private const val NAME_GET_TARGET_INSTANCE_METHOD = "getInstance"
    }
}

通过以上代码， 通过扫描进行生成的类如下:

  • 不是单例的模式生成的类
@Keep
public final class ISettingRepoProducer {

  private static final Object sLock = new Object();
  private static ISettingRepo sInstance = null;

  public static ISettingRepo getInstance() {
    return new SettingRepoImpl();
  }
}
  • 单例的模式生成的类
@Keep
public final class IAboutRepoProducer {

    private static final Object sLock = new Object();
    private static IAboutRepo sInstance = null;

    public static IAboutRepo getInstance() {
        if (sInstance != null) {
            return sInstance;
        }
        synchronized (sLock) {
            if (sInstance != null) {
                return sInstance;
            }
            sInstance = new AboutRepoImpl();
            return sInstance;
        }
    }
}

看到这里看来我们的前期工作已经做好了， 现在开始我们的 transform 利用 ASM 然后对属性在构造函数里进行赋值吧。

使用 transform 利用 ASM 对属性操作

这里需要考虑两个问题，

  • 就是如果一个类有多个构造函数呢， 不能内次都对其赋值吧！ 这里的解决方式为， 在有 Injected 的类里生成一个 Boolean 属性， 在每一个构造函数中对这个变量进行判读, 如果没有赋值则进行赋值， 如果已经赋值了那么就不在进行赋值。
  • 如果我们扫描到 Injected 属性但是没有找到对应的代理初始化类咋整， 这个情况是需要考虑的哈， 可能用户忘记实现或没有引入改实现的库， 比如我依赖的实现没有引入呢对吧。这里的解决方式为， 在复制的时候进行 try, 先进行 Class.forName, 如果没有找到该类就不进行赋值。

访问所有的类找到存在 Injected 属性的类

class ServiceAssistantClassVisitor(
    private val byteArray: ByteArray,
    private val serviceTargetFindBack: () -> Unit,
    private val needScanClassInfoBack: (String, String) -> Unit
) : ClassVisitor(Opcodes.ASM7) {

    private lateinit var mVisitorClassName: String
    private var mIsInsertInitField = false
    private var mIsAutoInitFieldName: String? = null
    private val mFieldInfo = mutableMapOf<String, String>()

    override fun visit(
        version: Int,
        access: Int,
        name: String?,
        signature: String?,
        superName: String?,
        interfaces: Array<out String>?
    ) {
        super.visit(version, access, name, signature, superName, interfaces)
        this.mVisitorClassName = name ?: ""
        // 是否已经生成了控制重复赋值的变量
        this.mIsInsertInitField = false
        // 生成变量的名字
        this.mIsAutoInitFieldName = "is${DigestUtils.md5Hex(this.mVisitorClassName)}"
    }

    override fun visitField(
        access: Int,
        name: String?,
        descriptor: String?,
        signature: String?,
        value: Any?
    ): FieldVisitor {
		// 对该属性的注解进行访问
        return ServiceAssistantFieldVisitor(
            super.visitField(
                access,
                name,
                descriptor,
                signature,
                value
            )
        ) {
			// ......
			// 变量和对应接口的关系
            this.mFieldInfo[name] = descriptor
			// 如果没有生成控制变量进行控制
            if (!this.mIsInsertInitField) {
                cv.visitField(
                    Opcodes.ACC_VOLATILE or Opcodes.ACC_PRIVATE,
                    this.mIsAutoInitFieldName,
                    ServiceAssistantConstant.SIGNATURE_BOOLEAN,
                    null,
                    false
                ).visitEnd()
                this.mIsInsertInitField = true
            }
        }
    }

    override fun visitMethod(
        access: Int,
        name: String?,
        descriptor: String?,
        signature: String?,
        exceptions: Array<out String>?
    ): MethodVisitor {
    	// 仅仅对构造函数进行处理
        return if (name == null || name != ServiceAssistantConstant.DESC_INIT || this.mFieldInfo.isEmpty()) {
            super.visitMethod(access, name, descriptor, signature, exceptions)
        } else {
       	    // 进行代码生成
            ServiceAssistantMethodVisitor(
                super.visitMethod(access, name, descriptor, signature, exceptions),
                this.mVisitorClassName,
                this.mIsAutoInitFieldName!!,
                this.mFieldInfo,
                access, name, descriptor
            )
        }

    }

    override fun visitEnd() {
        this.mIsInsertInitField = false
        this.mIsAutoInitFieldName = null
        super.visitEnd()
    }

}

对属性直接的访问

class ServiceAssistantFieldVisitor(
    fieldVisitor: FieldVisitor,
    private val targetAnnotationBack: () -> Unit
) :
    FieldVisitor(Opcodes.ASM7, fieldVisitor) {

    override fun visitAnnotation(descriptor: String?, visible: Boolean): AnnotationVisitor {
        if (ServiceAssistantConstant.SIGNATURE_INJECTED_ANNOTATION == descriptor) {
            targetAnnotationBack.invoke()
        }
        return super.visitAnnotation(descriptor, visible)
    }

}

处理很简单， 就是如果是 Injected 注解的属性进行回调出去处理。

利用 ASM 对构造函数的赋值操作

class ServiceAssistantMethodVisitor(
    methodVisitor: MethodVisitor,
    private val visitorClassName: String,
    private val isAutoInitFieldName: String,
    private val fieldInfo: Map<String, String>,
    access: Int,
    name: String?,
    desc: String?
) : AdviceAdapter(Opcodes.ASM7, methodVisitor, access, name, desc) {

    override fun onMethodEnter() {
        super.onMethodEnter()

        mv.visitInsn(ACONST_NULL)
        mv.visitVarInsn(ALOAD, 0)
        mv.visitFieldInsn(
            GETFIELD,
            visitorClassName,
            isAutoInitFieldName,
            ServiceAssistantConstant.SIGNATURE_BOOLEAN
        )
        val label1 = Label()
        mv.visitJumpInsn(IF_ACMPEQ, label1)
        mv.visitVarInsn(ALOAD, 0)
        mv.visitFieldInsn(
            GETFIELD,
            visitorClassName,
            isAutoInitFieldName,
            ServiceAssistantConstant.SIGNATURE_BOOLEAN
        )
        mv.visitMethodInsn(
            INVOKEVIRTUAL,
            ServiceAssistantConstant.PATH_BOOLEAN,
            ServiceAssistantConstant.NAME_BOOLEAN,
            ServiceAssistantConstant.DESC_RETURN_BOOLEAN,
            false
        )
        val label2 = Label()
        mv.visitJumpInsn(IFNE, label2)
        mv.visitLabel(label1)

        fieldInfo.keys.forEach {
            val value = fieldInfo[it]
                ?: throw RuntimeException("Injection target interface signature error")
            insertInjectedProducer(it, value)
        }

        mv.visitVarInsn(ALOAD, 0)
        mv.visitInsn(ICONST_1)
        mv.visitMethodInsn(
            INVOKESTATIC,
            ServiceAssistantConstant.PATH_BOOLEAN,
            ServiceAssistantConstant.DESC_VALUE_OF,
            ServiceAssistantConstant.DESC_RETURN_BOOLEAN_FULL,
            false
        )
        mv.visitFieldInsn(
            PUTFIELD,
            visitorClassName,
            isAutoInitFieldName,
            ServiceAssistantConstant.SIGNATURE_BOOLEAN
        )
        mv.visitLabel(label2)

    }

    private fun insertInjectedProducer(name: String, injectedInterface: String) {

        val targetInterfaceProducer = ServiceAssistantConstant.getInjectedProducerClassFullName(
            injectedInterface.substring(
                1,
                injectedInterface.length - 1
            )
        )

        val label0 = Label()
        val label1 = Label()
        val label2 = Label()
        mv.visitTryCatchBlock(label0, label1, label2, ServiceAssistantConstant.PATH_EXCEPTION)
        mv.visitLabel(label0)
        mv.visitLineNumber(33, label0)
        mv.visitLdcInsn(targetInterfaceProducer.replace("/", "."))
        mv.visitMethodInsn(
            INVOKESTATIC,
            ServiceAssistantConstant.PATH_CLASS,
            ServiceAssistantConstant.DESC_FOR_NAME,
            ServiceAssistantConstant.SIGNATURE_STRING_CLASS,
            false
        )
        mv.visitInsn(POP)
        val label3 = Label()
        mv.visitLabel(label3)
        mv.visitLineNumber(34, label3)
        mv.visitVarInsn(ALOAD, 0)
        mv.visitMethodInsn(
            INVOKESTATIC,
            targetInterfaceProducer,
            ServiceAssistantConstant.NAME_GET_TARGET_INSTANCE_METHOD,
            "()$injectedInterface",
            false
        )
        mv.visitFieldInsn(
            PUTFIELD,
            visitorClassName,
            name,
            injectedInterface
        )
        mv.visitLabel(label1)
        mv.visitLineNumber(36, label1)
        val label4 = Label()
        mv.visitJumpInsn(GOTO, label4)
        mv.visitLabel(label2)
        mv.visitLineNumber(35, label2)
        mv.visitFrame(F_SAME1, 0, null, 1, arrayOf<Any>(ServiceAssistantConstant.PATH_EXCEPTION))
        mv.visitVarInsn(ASTORE, 1)
        mv.visitLabel(label4)
    }

}

通过上面的操作其生成的代码的对应关系如下

  • 需要注入的类
class TestTest {

    @Injected
    private IAccountRepo mAccountRepo;

    @Injected
    private IAboutRepo mAboutRepo;


}
  • 生成后的代码
class TestTest {
    @Injected
    private IAccountRepo mAccountRepo;
    private volatile Boolean is35887f203c598919a929ebf9203e4f24;
    @Injected
    private IAboutRepo mAboutRepo;

    TestTest() {
        if (null == this.is35887f203c598919a929ebf9203e4f24 || !this.is35887f203c598919a929ebf9203e4f24) {
            try {
                Class.forName("cn.xiaoxige.accountcomponent.repo.IAccountRepoProducer");
                this.mAccountRepo = IAccountRepoProducer.getInstance();
            } catch (Exception var3) {
            }

            try {
                Class.forName("cn.xiaoxige.serviceassistant.repo.IAboutRepoProducer");
                this.mAboutRepo = IAboutRepoProducer.getInstance();
            } catch (Exception var2) {
            }

            this.is35887f203c598919a929ebf9203e4f24 = true;
        }

    }
}

到这里， 你应该对其原理都明白了吧。 最后在说下使用 ASM 插件生成代码的技巧。

利用 ASM 生成代码的技巧（以注入为例）

通过上面我们可以知道我们需要写入构造函数的代码其实也很复杂, 其中我们拿到注入信息后还需要循环进行生成， 还是在 if 中间， 咋办？ 技巧和心得如下

  • 装上 ASM Bytecode Viewer 插件, 这个技巧不说了哈， 我们利用的就是这个插件呢

  • 新建一个测试类手写想通的代码进行生成， 点击右键生成， 生成的 ASM 代码里我们可以看到 visitLineNumber(1, label0) 这行， 其中 1 就是我们源码里对应的行数， 如果我们生成的代码在 1 行之 10 行的代码， 那么我们主需要赋值 visitLineNumber 1 ~ visitLineNumber 11 之间的代码， 赋值后可以把 visitLineNumber 这行再删除掉哦， 有人说如果我源码 10 行就结尾了没有 11 行咋办， 你可以在源码里加上一个打印嘛， 比如 Log.e(“tag”, “”)。

  • 光上面的技巧就行了嘛, 不行不行， 还不够， 按照注入为例， 我们拿到对应关系是需要循环生成的， 而且还是在 if 中间， 这个改怎么办呀， 别急， 我们可以分批进行。 以注入为例， 比如

class TestTest {

    @Injected
    private IAccountRepo mAccountRepo;

    private Boolean mIsInit;

    private void test() {

        if (null == mIsInit || !mIsInit) {

            Log.e("TAG", "");

            mIsInit = true;
        }

    }

    private void test1() {
        try {
            Class.forName("cn.xiaoxige.accountcomponent.repo.IAccountRepo");
            mAccountRepo = IAccountRepoProducer.getInstance();
        } catch (Exception e) {
        }
    }

}

那么好， 我们先找到 test 方法对应的 ASM 代码复制出来， 然后把打 log 的 ASM 代码删除， 这个利用第二个技巧也就是通过源码的行编号查找就很容易找到对应的位置哈。 在删除的 AMS 代码里就可以写 for 循环了哈， 然后再把 test1 方法生成对应的 ASM 复制放在循环里， 最后的最后别忘了把类名啥的用我们收集到的进行替换哈。

到这里就终结了。

其他

其中组件的设计、 以及该库的详细用法比如获取服务， 组件通讯， 组件回调， 注入， 等可以参考文章开头的 github 地址哈， 也可以参考其源码实现。 最后最后也希望大家可以给个 Star 哈哈。

小稀革
关注
专栏目录
Vue组件通信原理剖析（三）provide/inject原理分析
没做过产品的后端不是个好前端
12-10 1606
首先我们先从一个面试题入手。 面试官问： “Vue中组件通信的常用方式有哪些？” 我答： 1. props 2. 自定义事件 3. eventbus 4. vuex 5. 还有常见的边界情况$parent、$children、$root、$refs、provide/inject 6. 此外还有一些非props特性$attrs、$listeners 面试官追问：“那你能分别说说他们的原理吗？” 我：[一脸懵逼]???? 在介绍provide和inject之前我们先简单看看其他几个常用属性。 $pare
小程序的父子之间的传值调用
浩星
10-22 914
前言： 我们在小程序中父子组件之间的传值方法。 目录： 父传子 ：properties 步骤： 1、在父组件 index.wxml里面给调用子组件的地方绑定一个字段map 2、在父组件 index.js中定义字段map,并用this.setData改变这个值 3、在子组件 map.js中定义properties接收我们绑定的值 4、在子组件 map.js中通过this.data.map调用properties的字段 子传父：triggerEvent 步骤： 1、在子组件 ...
android 定位模式,Android 简单服务定位器模式实现
weixin_42315616的博客
05-26 165
依赖注入(Dependency Injection)和服务定位器(Service Locator)是实现控制反转(Inversion of Control)的两种主要手段。Android的主流依赖注入框架有：Dagger 和 Kion这些依赖注入框架都感觉比较重。服务定位器比如少见，这里提供一个一个简单的服务定位器模式实现。引入repositories {maven { url "https://...
istio简介和基础组件原理（服务网格Service Mesh）
热门推荐
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
11-27 7万+
Istio简介 Istio：一个连接，管理和保护微服务的开放平台。 按照isito文档中给出的定义: Istio提供一种简单的方式来建立已部署的服务的网络，具备负载均衡，服务到服务认证，监控等等功能，而不需要改动任何服务代码。简单的说，有了Istio，你的服务就不再需要任何微服务开发框架（典型如Spring Cloud，Dubbo），也不再需要自己手动实现各种复杂的服务...
React组件设计模式与最佳实践
kangzai的博客
05-02 2680
React组件的设计非常灵活，可供选择的方式也很多，如何正确合理地设计组件，在这里总结了一些常用的设计方法和实践
quartz原理 java_深入解读Quartz的原理
weixin_39640395的博客
02-26 879
Quartz是一个大名鼎鼎的Java版开源定时调度器，功能强悍，使用方便。一、核心概念Quartz的原理不是很复杂，只要搞明白几个概念，然后知道如何去启动和关闭一个调度程序即可。1、Job表示一个工作，要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context)2、JobDetailJobDetail表示一个具体的可执行的调度程序，Job...
android 微信小程序原理,微信小程序架构原理
weixin_28981373的博客
05-26 993
前言昨日看朋友圈，据说有人花钱买star，不知道真的假的？以前以为只是大家开玩笑。今日早读文章由百度EUX@田光宇投稿分享。正文从这开始~~微信小程序微信小程序包含下面四种文件：jsjson 配置文件wxml 小程序专用 xml 文件wxss 小程序专用 css 文件{{ text }}Page({data:{text:"这是一个页面"},onLoad:function(options){// 页...
由浅入深RPC通信原理实战
赵广陆
05-15 1550
目录 1 背景知识 2 RPC概述 3 RPC框架实现要点 3.1 注册中心 3.2 代理技术 3.3 序列化技术 3.4 RPC通信协议 3.5 系统IO 3.6 超时重试机制 3.7 时间轮算法 3.8 负载均衡策略 3.9 熔断限流 3.10 滑动窗口算法 3.11 限流组件
游戏外挂基本原理及实现
liujiayu2的专栏
05-12 4万+
1、游戏外挂的原理  　　外挂现在分为好多种，比如模拟键盘的，鼠标的，修改数据包的，还有修改本地内存的，但好像没有修改服务器内存的哦，呵呵。其实修改服务器也是有办法的，只是技术太高一般人没有办法入手而已。（比如请GM去夜总会、送礼、收黑钱等等办法都可以修改服务器数据，哈哈） 修改游戏无非是修改一下本地内存的数据，或者截获API函数等等。这里我把所能想到的方法都作一个介绍，希望大家能做出很好的外挂
Istio设计理念、核心功能原理及运行流程
XR风云
04-17 1982
Istio 的起源 为了实现由 William Morgan 提出的微服务 Service Mesh 模式和诸多理念，Google , IBM 和 Lyft 这三家公司协同研发，并于 2017 年 6 月 8 日( 根据 Github 最后一次提交的时间 )发布了 Istio 的第一个发行版——Istio 0.1 版本。 Istio 的设计目标 作为一款 Service Mesh 模式...
ASP.NET毕业设计——ASP.NET基于BS方式的即时通讯软件的设计与实现(源代码+论文).zip
09-15
ASP.NET是一种由微软开发的用于构建Web应用程序的框架，...通过以上分析，我们可以看出这个毕业设计涵盖了ASP.NET开发的核心技术和即时通讯系统的实现原理，对于学习者来说，是一个全面了解和实践Web应用开发的好机会。
jsp+sqlH2003032027_一个简单的即时通讯工具的设计与开发(系统+论文).zip
08-11
综上所述，"jsp+sqlH2003032027"项目为学习者提供了从理论到实践的全面体验，涵盖了JSP开发、SQL数据库管理、即时通讯原理及其实现等多个重要知识点。通过深入研究该项目，不仅可以提升编程技能，还能为将来设计更...
软件架构设计与模式之：模块化设计与组件化架构
程序员光剑
10-29 585
模块化与组件化是现代软件工程的一个重要发展方向。模块化设计是一种将复杂系统划分为多个相对独立、功能完整、可替换和可维护的模块的方式，它能够使复杂的软件系统更容易理解、开发、测试、修改和扩展。而组件化设计则在这一基础上进一步提出将复杂的软件系统由单个大型软件拆分成不同层次的小型软件组件的观点。模块化与组件化设计都是为了解决软件系统复杂性问题。它们的关键是通过结构化的方式将复杂的软件系统分解成多个相互协作的模块或组件。但是，两者也存在着一些区别，下面我们就分别阐述一下二者之间的差异。模块（Module）
ASP.NET Core依赖注入实现原理：生命周期管理
依赖注入（DI）是一种设计模式，用于管理类之间的依赖关系。简而言之，它允许我们将对象的创建和维护任务委托给外部供应商，从而增强了代码的松耦合性和可测试性。 ## 1.2 为什么依赖注入是重要的？ 依赖注入有助于...
NanoAirline航空公司管理系统.zip
最新发布
09-13
NanoAirline是一个基于Spring Boot框架开发的简单航空公司管理系统。该系统旨在提供航空公司的基本管理功能，包括但不限于航班管理、乘客信息管理、机票预订等功能。该系统适用于中小型航空公司或作为大型航空公司管理系统的补充，能够帮助航空公司实现高效、便捷的管理和操作。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
基于Tensorflow的手势识别代码+数据集+文档说明（期末大作业）
09-13
基于Tensorflow的手势识别代码+数据集+文档说明（期末大作业），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。该项目可以作为毕设、课程设计期末大作业使用，该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 基于Tensorflow的手势识别代码+数据集+文档说明（期末大作业），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。该项目可以作为毕设、课程设计期末大作业使用，该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。 基于Tensorflow的手势识别代码+数据集+文档说明（期末大作业），含有代码注释，新手也可看懂。毕业设计、期末大作业、课程设计、高分必看，下载下来，简单部署，就可以使用。该项目可以作为毕设、课程设计期末大作业使用，该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值。基于Tensorflow的手势识别代码+数据集+文档说明（期末大作业），含有代码注释，新手也可看懂
weixin029微信阅读网站小程序+ssm.rar
09-13
所有源码，都是可以运行起来的
基于java的植物健康系统设计与实现.docx
09-13
基于java的植物健康系统设计与实现.docx
书籍推荐系统构建实践.zip
09-13
本项目旨在从零开始构建一个书籍推荐系统。推荐系统在当前电子商务网站中非常受欢迎，能够向用户推荐最符合其喜好和特点的书籍。构建推荐系统需要掌握数据分析、机器学习和软件工程等领域的专业知识，学习新技能和工具具有挑战性和耗时的特点。本项目采用Book-Crossings书籍评分数据集，包含百万级别的用户书籍评分数据。此外，还提供书籍信息和用户信息表。项目全部代码基于Google Colab进行编写，利用GPU加速，数据集上传至Google Driv方e便直接下载。通过Jupyter notebook重现整个项目。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
C++实现依赖注入：原理与容器设计详解
C++ 依赖注入是一种关键的软件设计策略，它旨在降低组件间的耦合度，提高代码的内聚度，从而简化软件架构和维护。在复杂的软件系统中，依赖注入的重要性不言而喻，它遵循SOLID设计原则和领域驱动设计（DDD）的理念，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值