jacodb
1.4.5 Release
JacoDB é uma biblioteca Java Pure que permite obter informações sobre o Java Bytecode fora do processo JVM e armazená -lo em um banco de dados. Embora Reflection do Java possibilite a inspeção do código em tempo de execução, JacoDB faz o mesmo para o bytecode armazenado em um sistema de arquivos.
JacoDB usa a estrutura ASM para leitura e análise Java ByteCode.
Informações sobre aulas, hierarquias, anotações, métodos, campos e seus usos são armazenados no banco de dados SQLite-na memória ou persistente. Os dados persistentes podem ser reutilizados entre as reinicializações. O acesso ao armazenamento persistente de vários processos simultaneamente não é suportado.
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 " )ou
Maven:
< 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 >A API possui dois níveis: o representando no FileSystem ( ByteCode e Classes ) e o que aparece no tempo de execução ( tipos ).
class : classe com métodos, campos, etc. Ambos os níveis estão conectados ao JcClasspath . Você não pode modificar as classes recuperadas do bytecode puro. Os tipos podem ser construídos manualmente por substituição genérica.
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 ());
}Kotlin
val database = jacodb {
useProcessJavaRuntime()
}
val clazz = database.classpath().findClassOrNull( " java.lang.String " )Exemplos mais complexos:
Java
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 ();
}
}Kotlin
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()
} A classe pode estar em ambiente incompleto (ou seja, super classe, interface, tipo de retorno ou parâmetro do método não é encontrado no ClassPath), então a API lançará NoClassInClasspathException em tempo de execução. Para corrigir este recurso de instalação, UnknownClasses no ClassPath durante a criação.
O banco de dados pode observar as alterações do sistema de arquivos em segundo plano e atualizar os arquivos de jarra explicitamente:
Java
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.Kotlin
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.Tipo pode ser representado como um dos
Representa o comportamento do tempo de execução de acordo com a substituição de parâmetros no tipo genérico fornecido:
Java
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`
}Kotlin
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`
} Os recursos podem ser usados para JcDatabase inteiro ou em particular JcClasspath
Recurso do banco de dados para pesquisar usos de campos e métodos.
val database = jacodb {
install( Usages )
}Veja mais
Zomba de classes desconhecidas. É uma maneira graça de lidar
val database = jacodb {}
val classpath = database.classpath( listOf ( UnknownClasses ))
val clazz = classpath.findClass( " UnknownClasses " ) // will return `JcClassOrInterface` instanceVeja mais
Hierarquia um pouco mais rápida, mas consome mais memória RAM:
val database = jacodb {
install( InMemoryHierarchy )
}Veja mais
As instâncias do JcClassOrInterface , JcMethod e JcClasspath são seguras de threads e imutáveis.
JcClasspath representa um instantâneo independente de classes, que não pode ser modificado desde que é criado. A remoção ou modificação dos arquivos da biblioteca não afeta a estrutura da instância JcClasspath . O método JcClasspath#close fecha todos os instantâneos e limpa os dados persistentes se algumas bibliotecas estiverem desatualizadas.
Java
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
}Kotlin
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 Se houver uma solicitação para uma instância JcClasspath contendo as bibliotecas, que ainda não foram indexadas, o processo de indexação será acionado e a nova instância do conjunto JcClasspath será retornada.
Java
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
}Kotlin
val database = jacodb {
loadByteCode( listOf (lib1))
persistent( " " )
}
val cp = database.classpath( listOf (buildDir)) // database will automatically process buildDir JacoDB é seguro para threads. Se alguém solicitar a instância JcClasspath enquanto carrega arquivos de jar de outro thread, JcClasspath poderá representar apenas um estado consistente dos arquivos de jarro sendo carregados. É o arquivo JAR completamente carregado que aparece no JcClasspath . Observação: não há garantia de que todos os arquivos de jar, enviados para carregamento, sejam realmente carregados.
Java
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 ();
}
}Kotlin
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))
}
}O carregamento de bytecode consiste em duas etapas:
JcFeature , etc.) As instâncias JacoDB ou JcClasspath são devolvidas logo após a primeira etapa ser executada. Você recupera a representação final das classes durante a segunda etapa. É possível que os arquivos .class sofrem alterações em algum momento entre a primeira etapa e a segunda, e a representação das classes é afetada de acordo.
Aqui estão os resultados dos benchmarks e a migração da fuligem.
