AOP Gradle插件的仓库地址不稳定，干脆自己来搭建Nexus私服

问题来源

今天研究了下如何将gradle的aop插件打包上传到Nexus私服，本来也想使用第三方的maven仓库，但是发现网上的几乎都关服了，那么没办法，只能自己搭建一下Nexus私服了。

搭建Nexus环境

我使用的是CentOS 7.6（64位版本），至少需要4G内存的服务器。那么我们现在开始上干货了。

安装java的环境

yum install java

Nexus下载

wget https://download.sonatype.com/nexus/3/nexus-3.37.1-01-unix.tar.gz

解压缩

tar -zxvf nexus-3.37.1-01-unix.tar.gz

运行Nexus

进入bin目录

cd nexus-3.37.1-01/bin

运行nexus

./nexus start // 后台运行
./nexus run // 前台运行，退出命令行停止

这里你可以先拿run的命令测试一下，有问题可以随时Ctrl+C关掉。

开放服务器端口，配置安全组规则

这里注意选出方向，入方向是指该服务器访问别的服务器开放的端口。在浏览器输入你的服务器的公网IP地址加上8081端口，8081是Nexus的默认端口，如果你不配置，那就是它。

然后复制maven releases地址。

这个地址在Gradle插件项目中会用到。

apply plugin: 'groovy'
apply plugin: 'maven-publish'

repositories {
    mavenCentral()
}

dependencies {
    implementation gradleApi()//gradle sdk
    implementation localGroovy()//groovy sdk
    implementation fileTree("libs/aspectjtools-1.9.19.jar")
}

jar {
    from {
        zipTree(new File(project.projectDir.absolutePath + "/libs/aspectjtools-1.9.19.jar"))
    }
}

java {
    withJavadocJar()
    withSourcesJar()
}

sourceSets {
    main {
        java {
            srcDirs = ["src"]
        }

    }
}

publishing {
    // Components are the standard way of defining a publication.
    // They are provided by plugins, usually of the language or platform variety.
    // For example, the Java Plugin defines the components.java SoftwareComponent,
    // while the War Plugin defines components.web.
    publications {
        myLibrary(MavenPublication) {
            from components.java
            groupId "com.dorachat"
            version "1.0"
        }
    }
    repositories {
        maven {
            name = "beta"
            // 不使用https
            allowInsecureProtocol true
            url = uri("http://47.236.19.46:8081/repository/maven-releases/")
            credentials {
                username = "admin"
                password = "填入你的Nexus密码"
            }
        }
    }
}

// 注意⚠️:   插件修改后需要重新发布: ./gradlew clean build publish --info
// 注意jdk的字节码版本和gradle的对应关系

我这里就为了图方便，就不加ssl证书了，这样的话要设置allowInsecureProtocol证书为true，你也可以添加SSL证书，这样就可以以https的方式访问了。然后执行

./gradlew clean build publish –info

这行命令就发布成功了。

Java字节码版本对照

如果你报这个错： General error during conversion: Unsupported class file major version 63，那就是gradle和jdk版本不匹配导致的。

49 = Java 5

50 = Java 6

51 = Java 7

52 = Java 8

53 = Java 9

54 = Java 10

55 = Java 11

56 = Java 12

57 = Java 13

58 = Java 14

59 = Java 15

60 = Java 16

61 = Java 17

62 = Java 18

63 = Java 19

64 = Java 20

⚠: Indicates that the Java version can be used for compilation and tests, but not yet running Gradle itself.

Kotlin

Gradle is tested with Kotlin 1.6.10 through 1.8.10. Beta and RC versions may or may not work.

Android项目中使用aop插件

在settings.xml中添加以下代码，告诉编译器在哪里找插件。

pluginManagement {
    repositories {
        maven {
            setUrl("http://47.236.19.46:8081/repository/maven-releases/")
            isAllowInsecureProtocol = true
            credentials {
                username = "admin"
                password = "填入你的Nexus密码"
            }
        }
    }
    resolutionStrategy {
        eachPlugin {
            if (requested.id.namespace == "com.dorachat") {
                useModule("com.dorachat:dora-aop-plugin:1.0")
            }
        }
    }
}

然后在app模块的build.gradle使用插件。

id("com.dorachat.aop")

那么重点来了，这个id是哪个id呢？

这个id就是我们META-INF/gradle-plugins/那个properties文件的名称。这个属性文件直接指向了我们插件的入口代码。

package com.dorachat.plugin





import org.aspectj.bridge.IMessage
import org.aspectj.bridge.MessageHandler
import org.aspectj.tools.ajc.Main
import org.gradle.api.Plugin
import org.gradle.api.Project


/**
 * @使用ajc编译java代码 ， 同 时 织 入 切 片 代 码
 * 使用 AspectJ 的编译器（ajc，一个java编译器的扩展）
 * 对所有受 aspect 影响的类进行织入。
 * 在 gradle 的编译 task 中增加额外配置，使之能正确编译运行。
 */

 class AspectjPlugin implements Plugin<Project> {


    void apply(Project project) {
        project.dependencies {
            implementation 'org.aspectj:aspectjrt:1.9.19'
        }
        final def log = project.logger
        log.info "============DoraChat AOP START============"
        def hasApp = project.plugins.hasPlugin("com.android.application")
        final def variants
        if (hasApp) {
            variants = project.android.applicationVariants
        } else {
            variants = project.android.libraryVariants
        }



        variants.all { variant ->
            def javaCompile = variant.javaCompile
            javaCompile.doLast {
                String[] args = [
                        "-showWeaveInfo",
                        "-1.8",
                        "-inpath", javaCompile.destinationDir.toString(),
                        "-aspectpath", javaCompile.classpath.asPath,
                        "-d", javaCompile.destinationDir.toString(),
                        "-classpath", javaCompile.classpath.asPath,
                        "-bootclasspath", project.android.bootClasspath.join(File.pathSeparator)
                ]
                log.debug "ajc args: " + Arrays.toString(args)

                MessageHandler handler = new MessageHandler(true)
                new Main().run(args, handler)
                for (IMessage message : handler.getMessages(null, true)) {
                    switch (message.getKind()) {
                        case IMessage.ABORT:
                        case IMessage.ERROR:
                        case IMessage.FAIL:
                            log.error message.message, message.thrown
                            break
                        case IMessage.WARNING:
                            log.warn message.message, message.thrown
                            break
                        case IMessage.INFO:
                            log.info message.message, message.thrown
                            break
                        case IMessage.DEBUG:
                            log.debug message.message, message.thrown
                            break
                    }
                }
            }
        }
        log.info "============DoraChat AOP STOP============"
    }
}

使用到AOP的例子

防止快速点击

package site.doramusic.app.aop






import dora.util.LogUtils
import org.aspectj.lang.ProceedingJoinPoint

import org.aspectj.lang.annotation.Around

import org.aspectj.lang.annotation.Aspect

import org.aspectj.lang.annotation.Pointcut


/**
 * 能过注解@SingleClick aop切片的方式在编译期间织入源代码中，防止二次点击。
 */
@Aspect
class SingleClickAspect {

    private var lastClickTime: Long = 0


    @Pointcut("execution(@site.doramusic.app.annotation.SingleClick * *(..))")
    fun singleClick() {
    }



    @Around("singleClick()")
    @Throws(Throwable::class)

    fun aroundPointMethod(joinPoint: ProceedingJoinPoint) {
        if (isFastClick) {
            LogUtils.e("您的手速太赞了")
            return
        }
        joinPoint.proceed()
    }


    private val isFastClick: Boolean
        get() {
            val currentClickTime = System.currentTimeMillis()
            val flag = currentClickTime - lastClickTime < MIN_DELAY_TIME
            lastClickTime = currentClickTime
            return flag
        }


    companion object {
        private const val MIN_DELAY_TIME = 500
    }
}

package site.doramusic.app.annotation






/**

 * 防止短时间内多次触发点击事件。
 */

@Retention(AnnotationRetention.RUNTIME)

@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)
annotation class SingleClick

埋点统计方法执行时间

package site.doramusic.app.aop






import android.util.Log
import org.aspectj.lang.ProceedingJoinPoint

import org.aspectj.lang.annotation.Around

import org.aspectj.lang.annotation.Aspect

import org.aspectj.lang.reflect.MethodSignature
import org.aspectj.lang.reflect.SourceLocation
import site.doramusic.app.BuildConfig
import site.doramusic.app.annotation.TimeTrace

/**
 * 打印方法执行时间。
 */

@Aspect
internal class TimeTraceAspect {
    companion object {
        const val TAG = "TimeTrace"
    }



    @Around("execution(@site.doramusic.app.annotation.TimeTrace * *(..))")
    @Throws(Throwable::class)

    fun methodTimeTrace(joinPoint: ProceedingJoinPoint) {
        if (BuildConfig.DEBUG) {
            val methodSignature: MethodSignature = joinPoint.signature as MethodSignature
            val methodLocation: SourceLocation = joinPoint.sourceLocation
            val methodLine = methodLocation.line
            val className = methodSignature.declaringType.simpleName
            val methodName = methodSignature.name
            val timeTrace: TimeTrace = methodSignature.method.getAnnotation(TimeTrace::class.java) as TimeTrace
            val startTime = System.currentTimeMillis()
            joinPoint.proceed()
            val duration: Long = System.currentTimeMillis() - startTime
            Log.d(TAG, String.format("ClassName:【%s】,Line:【%s】,Method:【%s】,【%s】耗时:【%dms】", className, methodLine, methodName, duration))
        } else {
            joinPoint.proceed()
        }

    }
}

package site.doramusic.app.annotation






/**

 * 打印方法执行时间。
 */

@Retention(AnnotationRetention.RUNTIME)

@Target(AnnotationTarget.FUNCTION)
annotation class TimeTrace

总结

使用到AOP面向切面编程的例子还有很多，比如点击按钮发送网络请求前先检测下网络，如果没有网，就拦截掉，不发请求，然后显示一个没有网络的对话框。再比如Android6.0运行时权限的动态申请，在需要申请权限的方法前配置一个权限注解，就可以先保证权限被授予再调用该方法。再比如，所有没有登录情况下的统一处理等。如果你擅长Gradle插件开发，你也可以搭建一个自己的插件仓库，以后要使用某个插件，直接apply就可以了。