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))
        }
    }