jacodb下载jacodb源代码下载

概述

JacoDB是一个纯Java库，可让您在JVM进程之外获取有关Java字节码的信息，并将其存储在数据库中。尽管Java Reflection使得在运行时检查代码成为可能，但JacoDB对存储在文件系统中的字节码执行了相同的操作。

JacoDB使用ASM框架来读取和解析Java字节码。

有关类，层次结构，注释，方法，字段及其用法的信息存储在SQLite数据库中 - 内存或持久性。可以在重新启动之间重复使用持续的数据。不支持同时从多个过程访问持久存储。

有用的链接

介绍
完整的API参考
数据库扩展（又称功能）
类路径扩展（又称功能）
字节码说明
控制流程图

安装

Gradle：

    implementation(group = " org.jacodb " , name = " jacodb-api " , version = " 1.2.0 " )
    implementation(group = " org.jacodb " , name = " jacodb-core " , version = " 1.2.0 " )
    implementation(group = " org.jacodb " , name = " jacodb-analysis " , version = " 1.2.0 " )

或者

马文：

< dependencies >
    < dependency >
        < groupId >org.jacodb</ groupId >
        < artifactId >jacodb-core</ artifactId >
        < verison >1.2.0</ verison >
    </ dependency >
    < dependency >
        < groupId >org.jacodb</ groupId >
        < artifactId >jacodb-api</ artifactId >
        < verison >1.2.0</ verison >
    </ dependency >
    < dependency >
        < groupId >org.jacodb</ groupId >
        < artifactId >jacodb-analysis</ artifactId >
        < verison >1.2.0</ verison >
    </ dependency >
</ dependencies >

概念

API有两个级别：一个表示文件系统中的一个级别（ bytecode and Class ），一个在运行时出现（类型）。

字节码和类- 表示class文件中的数据：与方法，字段等的类。
类型- 表示可以无效，参数化等的类型。

两个级别都连接到JcClasspath 。您无法修改从纯字节码检索的类。类型可以通过仿制药替代手动构建。

课程

    public static void getStringFields () throws Exception {
        JcDatabase database = JacoDB . async ( new JcSettings (). useProcessJavaRuntime ()). get ();
        JcClassOrInterface clazz = database . asyncClasspath ( emptyList ()). get (). findClassOrNull ( "java.lang.String" );
        System . out . println ( clazz . getDeclaredFields ());
    }

科特林

    val database = jacodb {
        useProcessJavaRuntime()
    }
    val clazz = database.classpath().findClassOrNull( " java.lang.String " )

更复杂的例子：

爪哇

 class Example {
    public static MethodNode findNormalDistribution () throws Exception {
        File commonsMath32 = new File ( "commons-math3-3.2.jar" );
        File commonsMath36 = new File ( "commons-math3-3.6.1.jar" );
        File buildDir = new File ( "my-project/build/classes/java/main" );
        JcDatabase database = JacoDB . async (
                new JcSettings ()
                        . useProcessJavaRuntime ()
                        . persistent ( "/tmp/compilation-db/" + System . currentTimeMillis ()) // persist data
        ). get ();

        // Let's load these three bytecode locations
        database . asyncLoad ( Arrays . asList ( commonsMath32 , commonsMath36 , buildDir ));

        // This method just refreshes the libraries inside the database. If there are any changes in libs then 
        // the database updates data with the new results.
        database . asyncLoad ( Collections . singletonList ( buildDir ));

        // Let's assume that we want to get bytecode info only for `commons-math3` version 3.2.
        JcClassOrInterface jcClass = database . asyncClasspath ( Arrays . asList ( commonsMath32 , buildDir ))
                . get (). findClassOrNull ( "org.apache.commons.math3.distribution.NormalDistribution" );
        System . out . println ( jcClass . getDeclaredMethods (). size ());
        System . out . println ( jcClass . getAnnotations (). size ());
        System . out . println ( JcClasses . getConstructors ( jcClass ). size ());

        // At this point the database read the method bytecode and return the result.
        return jcClass . getDeclaredMethods (). get ( 0 ). asmNode ();
    }
}

科特林

 suspend fun findNormalDistribution (): MethodNode {
    val commonsMath32 = File ( " commons-math3-3.2.jar " )
    val commonsMath36 = File ( " commons-math3-3.6.1.jar " )
    val buildDir = File ( " my-project/build/classes/java/main " )
    val database = jacodb {
        useProcessJavaRuntime()
        persistent( " /tmp/compilation-db/ ${ System .currentTimeMillis()} " ) // persist data
    }

    // Let's load these three bytecode locations
    database.load( listOf (commonsMath32, commonsMath36, buildDir))

    // This method just refreshes the libraries inside the database. If there are any changes in libs then 
    // the database updates data with the new results.
    database.load( listOf (buildDir))

    // Let's assume that we want to get bytecode info only for `commons-math3` version 3.2.
    val jcClass = database.classpath( listOf (commonsMath32, buildDir))
        .findClass( " org.apache.commons.math3.distribution.NormalDistribution " )
    println (jcClass.declaredMethods.size)
    println (jcClass.constructors.size)
    println (jcClass.annotations.size)

    // At this point the database read the method bytecode and return the result.
    return jcClass.methods[ 0 ].asmNode()
}

类可能在不完整的环境中（IE超级类，接口，返回类型或方法中未找到参数），然后API将在运行时抛出NoClassInClasspathException 。在创建过程中，要修复此安装UnknownClasses功能。

该数据库可以注意背景中的文件系统更改，并明确刷新jar-files：

爪哇

    public static void watchFileSystem () throws Exception {
        JcDatabase database = JacoDB . async ( new JcSettings ()
            . watchFileSystem ()
            . useProcessJavaRuntime ()
            . loadByteCode ( Arrays . asList ( lib1 , buildDir ))
            . persistent ( "" , false )). get ();
    }


    // A user rebuilds the buildDir folder.
    // The database re-reads the rebuilt directory in the background.

科特林

    val database = jacodb {
        watchFileSystem()
        useProcessJavaRuntime()
        loadByteCode( listOf (lib1, buildDir))
    }

    // A user rebuilds the buildDir folder.
    // The database re-reads the rebuilt directory in the background.

类型

类型可以表示为

原语
课程
数组
有限和无限的通配符

它根据给定的通用类型中的参数替换表示运行时行为：

爪哇

    public static class A < T > {
        T x = null ;
    }
    
    public static class B extends A < String > {
    }

    public static void typesSubstitution () {
        JcClassType b = ( JcClassType ) classpath . findTypeOrNull ( "org.jacodb.examples.JavaReadMeExamples.B" );
        JcType xType = b . getFields ()
                . stream ()
                . filter ( it -> "x" . equals ( it . getName ()))
                . findFirst (). get (). getFieldType ();
        JcClassType stringType = ( JcClassType ) classpath . findTypeOrNull ( "java.lang.String" );
        System . out . println ( xType . equals ( stringType )); // will print `true` 
    }

科特林

    open class A < T >( val x : T )
    
    class B ( x : String ): A<String>(x)
    
    suspend fun typesSubstitution () {
        val db = jacodb {
            loadByteCode( listOf ( File ( " all-classpath " )))
        }
        val classpath = db.classpath( listOf ( File ( " all-classpath " )))
        val b = classpath.findClass< B >().toType()
        println (b.fields.first { it.name == " x " }.fieldType == classpath.findClass< String >().toType()) // will print `true` 
    }

特征

功能可用于整个JcDatabase或特定的JcClasspath

用法

搜索字段和方法用法的数据库功能。

 val database = jacodb {
    install( Usages )
}

未知课程

模拟未知的课程。这是处理不完整的班级路径的恩典方式

 val database = jacodb {}
val classpath = database.classpath( listOf ( UnknownClasses ))

val clazz = classpath.findClass( " UnknownClasses " ) // will return `JcClassOrInterface` instance

inmemory层次结构

层次结构更快，但消耗更多的RAM内存：

 val database = jacodb {
    install( InMemoryHierarchy )
}

多线程

JcClassOrInterface ， JcMethod和JcClasspath的实例是线程安全且不可变的。

JcClasspath代表了类的独立快照，因为它是创建的，因此无法修改。删除或修改库文件不会影响JcClasspath实例结构。 JcClasspath#close方法释放了所有快照，如果某些库已过时，可以清理持久数据。

爪哇

    public static void refresh () throws Exception {
        JcDatabase database = JacoDB . async (
            new JcSettings ()
            . watchFileSystem ()
            . useProcessJavaRuntime ()
            . loadByteCode ( Arrays . asList ( lib1 , buildDir ))
            . persistent ( "..." )
        ). get ();

        JcClasspath cp = database . asyncClasspath ( Collections . singletonList ( buildDir )). get ();
        database . asyncRefresh (). get (); // does not affect cp classes

        JcClasspath cp1 = database . asyncClasspath ( Collections . singletonList ( buildDir )). get (); // will use new version of compiled results in buildDir
    }

科特林

    val database = jacodb {
        watchFileSystem()
        useProcessJavaRuntime()
        loadByteCode( listOf (lib1, buildDir))
        persistent( " " )
    }
    
    val cp = database.classpath( listOf (buildDir))
    database.refresh() // does not affect cp classes
    
    val cp1 = database.classpath( listOf (buildDir)) // will use new version of compiled results in buildDir

如果有一个尚未索引的JcClasspath实例的请求，则触发索引过程，并返回JcClasspath集的新实例。

爪哇

    public static void autoProcessing () throws Exception {
        JcDatabase database = JacoDB . async (
            new JcSettings ()
                . loadByteCode ( Arrays . asList ( lib1 ))
                . persistent ( "..." )
        ). get ();

        JcClasspath cp = database . asyncClasspath ( Collections . singletonList ( buildDir )). get (); // database will automatically process buildDir

    }

科特林

    val database = jacodb {
        loadByteCode( listOf (lib1))
        persistent( " " )
    }
    
    val cp = database.classpath( listOf (buildDir)) // database will automatically process buildDir

JacoDB是线程安全。如果一个人在从另一个线程加载jar-files时请求JcClasspath实例， JcClasspath只能表示正在加载的JAR-FILE的一致状态。这是出现在JcClasspath中的完全加载的jar-file。请注意：不能保证所有要加载的罐子文件将实际上加载。

爪哇

 class Example {
    public static void main ( String [] args ) {
        val db = JacoDB . async ( new JcSettings ()). get ();

        new Thread (() -> db . asyncLoad ( Arrays . asList ( lib1 , lib2 )). get ()). start ();

        new Thread (() -> {
            // maybe created when lib2 or both are not loaded into database
            // but buildDir will be loaded anyway
            var cp = db . asyncClasspath ( buildDir ). get ();
        }). start ();
    }
}

科特林

    val db = jacodb {
        persistent( " " )
    }
    
    thread(start = true ) {
        runBlocking {
            db.load( listOf (lib1, lib2))
        }
    }
    
    thread(start = true ) {
        runBlocking {
            // maybe created when lib2 or both are not loaded into database
            // but buildDir will be loaded anyway
            val cp = db.classpath( listOf (buildDir))
        }
    }