zhuxiaoan
zhuxiaoan

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

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

主要涉及一下核心知识点

  • 注解
  • 注解处理器
  • 自动生成代码 (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 {

    /**
     * 使用方提供
     */
    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()

        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()
    private val sLock = Any()

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

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

  • transfrom:
class ServiceAssistantTransform : Transform() {

    private val mNeedScanClassInfo = mutableListOf>()
    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?
    ) {
        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>
) :
    ClassVisitor(Opcodes.ASM7) {

    override fun visitMethod(
        access: Int,
        name: String?,
        descriptor: String?,
        signature: String?,
        exceptions: Array?
    ): MethodVisitor {
        if(如果是我们要插入的方法){
            return 处理该方法
        }
        
        super.visitMethod(access, name, descriptor, signature, exceptions)
    }
}
  • 利用 ASM 合理的写入我们的目标 Service 中 getService 方法中
class ServiceClassMethodVisitor(
    private val needInsertInfo: List>,
    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(
                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(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(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()
    private val sLock = Any()

    @JvmStatic
    fun  getService(clazz: Class): 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>()

    override fun init(p0: ProcessingEnvironment?) {
        super.init(p0)
        this.mFiler = p0.filer
    }
    
    override fun process(p0: MutableSet?, 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?,
    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): 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()

    override fun visit(
        version: Int,
        access: Int,
        name: String?,
        signature: String?,
        superName: String?,
        interfaces: Array?
    ) {
        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?
    ): 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,
    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(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 哈哈。

你可能感兴趣的:(组件通讯设计原理及注入实现原理)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动 李蕾1229
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
  • 向内而求 陈陈_19b4
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • 春季养肝正当时 dxn悟
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • git - Webhook让部署自动化 大猪大猪
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • CX8836：小体积大功率升降压方案推荐（附Demo设计指南） 诚芯微科技 社交电子
    CX8836是一颗同步四开关单向升降压控制器，在4.5V-40V宽输入电压范围内稳定工作，持续负载电流10A，能够在输入高于或低于输出电压时稳定调节输出电压，可适用于USBPD快充、车载充电器、HUB、汽车启停系统、工业PC电源等多种升降压应用场合，为大功率TYPE-CPD车载充电器提供最优解决方案。提供CX8836Demo测试、CX8836样品申请及CX8836方案开发技术支持。CX8836同升
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • java责任链模式 3213213333332132 java责任链模式村民告县长
    责任链模式，通常就是一个请求从最低级开始往上层层的请求，当在某一层满足条件时，请求将被处理，当请求到最高层仍未满足时，则请求不会被处理。 就是一个请求在这个链条的责任范围内，会被相应的处理，如果超出链条的责任范围外，请求不会被相应的处理。 下面代码模拟这样的效果： 创建一个政府抽象类,方便所有的具体政府部门继承它。 package 责任链模式; /** *
  • linux、mysql、nginx、tomcat 性能参数优化 ronin47
    一、linux 系统内核参数 /etc/sysctl.conf文件常用参数 net.core.netdev_max_backlog = 32768 #允许送到队列的数据包的最大数目 net.core.rmem_max = 8388608 #SOCKET读缓存区大小 net.core.wmem_max = 8388608 #SOCKET写缓存区大
  • php命令行界面 dcj3sjt126com PHPcli
    常用选项 php -v php -i PHP安装的有关信息 php -h 访问帮助文件 php -m 列出编译到当前PHP安装的所有模块 执行一段代码 php -r 'echo "hello, world!";' php -r 'echo "Hello, World!\n";' php -r '$ts = filemtime("
  • Filter&Session 171815164 session
    Filter HttpServletRequest requ = (HttpServletRequest) req; HttpSession session = requ.getSession(); if (session.getAttribute("admin") == null) { PrintWriter out = res.ge
  • 连接池与Spring,Hibernate结合 g21121 Hibernate
            前几篇关于Java连接池的介绍都是基于Java应用的，而我们常用的场景是与Spring和ORM框架结合，下面就利用实例学习一下这方面的配置。         1.下载相关内容：     &nb
  • [简单]mybatis判断数字类型 53873039oycg mybatis
           昨天同事反馈mybatis保存不了int类型的属性,一直报错，错误信息如下:       Caused by: java.lang.NumberFormatException: For input string: "null" at sun.mis
  • 项目启动时或者启动后ava.lang.OutOfMemoryError: PermGen space 程序员是怎么炼成的 eclipsejvmtomcatcatalina.sheclipse.ini
       在启动比较大的项目时，因为存在大量的jsp页面，所以在编译的时候会生成很多的.class文件，.class文件是都会被加载到jvm的方法区中，如果要加载的class文件很多，就会出现方法区溢出异常 java.lang.OutOfMemoryError: PermGen space.     解决办法是点击eclipse里的tomcat，在
  • 我的crm小结 aijuans crm
    各种原因吧，crm今天才完了。主要是接触了几个新技术： Struts2、poi、ibatis这几个都是以前的项目中用过的。 Jsf、tapestry是这次新接触的，都是界面层的框架，用起来也不难。思路和struts不太一样，传说比较简单方便。不过个人感觉还是struts用着顺手啊，当然springmvc也很顺手，不知道是因为习惯还是什么。jsf和tapestry应用的时候需要知道他们的标签、主
  • spring里配置使用hibernate的二级缓存几步 antonyup_2006 javaspringHibernatexmlcache
    ．在spring的配置文件中 applicationContent.xml，hibernate部分加入 xml 代码 <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop> <prop key="hi
  • JAVA基础面试题 百合不是茶 抽象实现接口String类接口继承抽象类继承实体类自定义异常
    /*   * 栈（stack）：主要保存基本类型（或者叫内置类型）（char、byte、short、   *int、long、 float、double、boolean）和对象的引用，数据可以共享，速度仅次于   * 寄存器（register），快于堆。堆（heap）：用于存储对象。   */  &
  • 让sqlmap文件 "继承" 起来 bijian1013 javaibatissqlmap
            多个项目中使用ibatis , 和数据库表对应的 sqlmap文件（增删改查等基本语句)，dao, pojo 都是由工具自动生成的, 现在将这些自动生成的文件放在一个单独的工程中，其它项目工程中通过jar包来引用 ，并通过"继承"为基础的sqlmap文件，dao,pojo 添加新的方法来满足项
  • 精通Oracle10编程SQL(13)开发触发器 bijian1013 oracle数据库plsql
    /* *开发触发器 */ --得到日期是周几 select to_char(sysdate+4,'DY','nls_date_language=AMERICAN') from dual; select to_char(sysdate,'DY','nls_date_language=AMERICAN') from dual; --建立BEFORE语句触发器 CREATE O
  • 【EhCache三】EhCache查询 bit1129 ehcache
    本文介绍EhCache查询缓存中数据，EhCache提供了类似Hibernate的查询API，可以按照给定的条件进行查询。   要对EhCache进行查询，需要在ehcache.xml中设定要查询的属性   数据准备 @Before public void setUp() { //加载EhCache配置文件 Inpu
  • CXF框架入门实例 白糖_ springWeb框架webserviceservlet
    CXF是apache旗下的开源框架，由Celtix + XFire这两门经典的框架合成，是一套非常流行的web service框架。 它提供了JAX-WS的全面支持，并且可以根据实际项目的需要，采用代码优先（Code First）或者 WSDL 优先（WSDL First）来轻松地实现 Web Services 的发布和使用，同时它能与spring进行完美结合。 在apache cxf官网提供
  • angular.equals boyitech AngularJSAngularJS APIAnguarJS 中文APIangular.equals
    angular.equals   描述: 比较两个值或者两个对象是不是 相等。还支持值的类型，正则表达式和数组的比较。   两个值或对象被认为是 相等的前提条件是以下的情况至少能满足一项： 两个值或者对象能通过=== （恒等） 的比较 两个值或者对象是同样类型，并且他们的属性都能通过angular
  • java-腾讯暑期实习生-输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A[0]*A[1]*...*A[i-1]*A[i+1] bylijinnan java
    这道题的具体思路请参看 何海涛的微博：http://weibo.com/zhedahht import java.math.BigInteger; import java.util.Arrays; public class CreateBFromATencent { /** * 题目：输入一个数组A[1,2,...n]，求输入B，使得数组B中的第i个数字B[i]=A
  • FastDFS 的安装和配置 修订版 Chen.H linuxfastDFS分布式文件系统
    FastDFS Home:http://code.google.com/p/fastdfs/ 1. 安装 http://code.google.com/p/fastdfs/wiki/Setup http://hi.baidu.com/leolance/blog/item/3c273327978ae55f93580703.html 安装libevent (对libevent的版本要求为1.4.
  • [强人工智能]拓扑扫描与自适应构造器 comsci 人工智能
          当我们面对一个有限拓扑网络的时候,在对已知的拓扑结构进行分析之后,发现在连通点之后,还存在若干个子网络,且这些网络的结构是未知的,数据库中并未存在这些网络的拓扑结构数据....这个时候,我们该怎么办呢?       那么,现在我们必须设计新的模块和代码包来处理上面的问题
  • oracle merge into的用法 daizj oraclesqlmerget into
    Oracle中merge into的使用 http://blog.csdn.net/yuzhic/article/details/1896878 http://blog.csdn.net/macle2010/article/details/5980965 该命令使用一条语句从一个或者多个数据源中完成对表的更新和插入数据. ORACLE 9i 中，使用此命令必须同时指定UPDATE 和INSE
  • 不适合使用Hadoop的场景 datamachine hadoop
    转自：http://dev.yesky.com/296/35381296.shtml。 　　Hadoop通常被认定是能够帮助你解决所有问题的唯一方案。 当人们提到“大数据”或是“数据分析”等相关问题的时候，会听到脱口而出的回答：Hadoop!  实际上Hadoop被设计和建造出来，是用来解决一系列特定问题的。对某些问题来说，Hadoop至多算是一个不好的选择，对另一些问题来说，选择Ha
  • YII findAll的用法 dcj3sjt126com yii
    看文档比较糊涂，其实挺简单的： $predictions=Prediction::model()->findAll("uid=:uid",array(":uid"=>10));   第一个参数是选择条件：”uid=10″。其中:uid是一个占位符，在后面的array(“:uid”=>10)对齐进行了赋值； 更完善的查询需要
  • vim 常用 NERDTree 快捷键 dcj3sjt126com vim
    下面给大家整理了一些vim NERDTree的常用快捷键了，这里几乎包括了所有的快捷键了，希望文章对各位会带来帮助。 切换工作台和目录 ctrl + w + h 光标 focus 左侧树形目录ctrl + w + l 光标 focus 右侧文件显示窗口ctrl + w + w 光标自动在左右侧窗口切换ctrl + w + r 移动当前窗口的布局位置 o 在已有窗口中打开文件、目录或书签，并跳
  • Java把目录下的文件打印出来 蕃薯耀 列出目录下的文件文件夹下面的文件目录下的文件
    Java把目录下的文件打印出来 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月11日 11:02:
  • linux远程桌面----VNCServer与rdesktop hanqunfeng Desktop
    windows远程桌面到linux，需要在linux上安装vncserver，并开启vnc服务，同时需要在windows下使用vnc-viewer访问Linux。vncserver同时支持linux远程桌面到linux。   linux远程桌面到windows，需要在linux上安装rdesktop，同时开启windows的远程桌面访问。   下面分别介绍，以windo
  • guava中的join和split功能 jackyrong java
    guava库中，包含了很好的join和split的功能，例子如下： 1） 将LIST转换为使用字符串连接的字符串    List<String> names = Lists.newArrayList("John", "Jane", "Adam", "Tom");
  • Web开发技术十年发展历程 lampcy androidWeb浏览器html5
    回顾web开发技术这十年发展历程： Ajax 03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。 彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
  • 架构师之mima-----------------mina的非NIO控制IOBuffer(说得比较好) nannan408 buffer
    1.前言。   如题。 2.代码。   IoService IoService是一个接口，有两种实现：IoAcceptor和IoConnector；其中IoAcceptor是针对Server端的实现，IoConnector是针对Client端的实现；IoService的职责包括： 1、监听器管理 2、IoHandler 3、IoSession
  • ORA-00054:resource busy and acquire with NOWAIT specified Everyday都不同 oraclesessionLock
    [Oracle] 今天对一个数据量很大的表进行操作时，出现如题所示的异常。此时表明数据库的事务处于“忙”的状态，而且被lock了，所以必须先关闭占用的session。   step1，查看被lock的session：   select t2.username, t2.sid, t2.serial#, t2.logon_time from v$locked_obj
  • javascript学习笔记 tntxia JavaScript
      javascript里面有6种基本类型的值:number、string、boolean、object、function和undefined。number：就是数字值，包括整数、小数、NaN、正负无穷。string:字符串类型、单双引号引起来的内容。boolean:true、false object:表示所有的javascript对象，不用多说function:我们熟悉的方法，也就是
  • Java enum的用法详解 xieke90 enum枚举
    Java中枚举实现的分析：     示例：  public static enum SEVERITY{ INFO,WARN,ERROR }     enum很像特殊的class，实际上enum声明定义的类型就是一个类。 而这些类都是类库中Enum类的子类      (java.l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他