使用ByteBuddy生成双向关联Java动态类型的实现咨询

Absolutely, generating bidirectional JPA associations with ByteBuddy's DynamicTypes is totally feasible! The core challenge here is handling cyclic type references between the two entities (since each needs to reference the other), but ByteBuddy provides all the necessary tools to make this work. Let’s walk through a practical implementation that matches your sample entity structure, and cover key considerations along the way.

Step 1: Core Requirements Recap #

We need to build two dynamic entities that mirror your static sample, with:

• Mutual field references (SimpleTableEntity holds a Set<SimpleForeignTableEntity>, SimpleForeignTableEntity holds a SimpleTableEntity instance)
• Complete JPA annotation configuration (including @OneToMany, @ManyToOne, @JoinColumn, etc.)
• Proper resolution of cyclic type dependencies

Step 2: Practical Implementation Code #

Here’s how to replicate your sample entities dynamically with ByteBuddy:

First, import required dependencies:

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.description.annotation.AnnotationDescription;
import net.bytebuddy.description.type.TypeDescription;
import net.bytebuddy.dynamic.DynamicType;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.Visibility;
import javax.persistence.*;
import java.util.Set;
import java.util.Date;
import java.sql.Timestamp;

Then, build the dynamic entities:

// Define fully qualified names for our dynamic entities
String simpleTableFQN = "com.example.SimpleTableEntity";
String foreignTableFQN = "com.example.SimpleForeignTableEntity";

// 1. Create base builders for both entities (handle non-cyclic fields first)
// Builder for SimpleTableEntity
DynamicType.Builder<?> simpleTableBuilder = new ByteBuddy()
        .subclass(Object.class)
        .name(simpleTableFQN)
        .implement(Base.class) // Implement your generic Base<SimpleTableEntity> interface
        // Add simpleKey field with JPA annotations
        .defineField("simpleKey", String.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Id.class).build())
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_key")
                .define("nullable", false)
                .build())
        // Add simpleColumn field
        .defineField("simpleColumn", String.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_column")
                .define("nullable", false)
                .build())
        // Add simpleDate field
        .defineField("simpleDate", Date.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_date")
                .define("nullable", false)
                .build())
        // Add simpleTimestamp field
        .defineField("simpleTimestamp", Timestamp.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_timestamp")
                .define("nullable", false)
                .build());

// Builder for SimpleForeignTableEntity
DynamicType.Builder<?> foreignTableBuilder = new ByteBuddy()
        .subclass(Object.class)
        .name(foreignTableFQN)
        // Add simpleForeignKey field with JPA annotations
        .defineField("simpleForeignKey", String.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Id.class).build())
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_foreign_key")
                .define("nullable", false)
                .build())
        // Add simpleForeignColumn field
        .defineField("simpleForeignColumn", String.class, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(Column.class)
                .define("name", "simple_foreign_column")
                .define("nullable", false)
                .build());

// 2. Resolve cyclic references using TypeDescription
// Extract metadata descriptions for both entities (no need to load them yet)
TypeDescription simpleTableType = simpleTableBuilder.make().getTypeDescription();
TypeDescription foreignTableType = foreignTableBuilder.make().getTypeDescription();

// Update SimpleTableBuilder to add the OneToMany field with correct generic type
DynamicType.Builder<?> finalSimpleTableBuilder = simpleTableBuilder
        .defineField("simpleForeignTableEntitySet",
                TypeDescription.Generic.Builder.parameterizedType(Set.class, foreignTableType)
                        .build(), Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(OneToMany.class)
                .define("mappedBy", "simpleTableEntity")
                .define("cascade", new CascadeType[]{CascadeType.ALL})
                .build());

// Update ForeignTableBuilder to add the ManyToOne field referencing SimpleTableEntity
DynamicType.Builder<?> finalForeignTableBuilder = foreignTableBuilder
        .defineField("simpleTableEntity", simpleTableType, Visibility.PRIVATE)
        .annotateField(AnnotationDescription.Builder.ofType(ManyToOne.class).build())
        .annotateField(AnnotationDescription.Builder.ofType(JoinColumn.class)
                .define("name", "simple_key")
                .define("nullable", false)
                .build());

// 3. Load both dynamic types with the same ClassLoader
ClassLoader entityClassLoader = new ClassLoader(Thread.currentThread().getContextClassLoader()) {};

DynamicType.Unloaded<?> unloadedSimpleTable = finalSimpleTableBuilder.make();
DynamicType.Unloaded<?> unloadedForeignTable = finalForeignTableBuilder.make();

// Critical: Use the same ClassLoader for both entities to avoid class resolution issues
Class<?> simpleTableClass = unloadedSimpleTable.load(entityClassLoader, ClassLoadingStrategy.Default.INJECTION).getLoaded();
Class<?> foreignTableClass = unloadedForeignTable.load(entityClassLoader, ClassLoadingStrategy.Default.INJECTION).getLoaded();

Key Explanations & Best Practices #

1. Cyclic Reference Resolution

   • We first build "base" versions of each entity with non-cyclic fields, then extract their TypeDescription (metadata about the dynamic type, even before it’s loaded into the JVM).
   • These TypeDescription instances let us define the cyclic fields safely—ByteBuddy fully supports referencing unloaded dynamic types via their metadata.

2. Generic Type Handling

   • For the Set<SimpleForeignTableEntity> field, we use TypeDescription.Generic.Builder.parameterizedType() to create a valid generic type definition. This ensures JPA correctly recognizes the association target type.

3. TypeCache for Reusability

   • If you need to generate these entities multiple times, use ByteBuddy’s TypeCache to cache loaded types and avoid redundant work:

     import net.bytebuddy.TypeCache;
     
     TypeCache<Class<?>> entityCache = new TypeCache.WithInlineExpunction<>(TypeCache.Sort.SOFT);
     
     // Cache lookup for SimpleTableEntity
     Class<?> cachedSimpleTable = entityCache.findOrInsert(entityClassLoader, simpleTableFQN, () -> {
         return finalSimpleTableBuilder.make().load(entityClassLoader).getLoaded();
     });
     

   • This is ideal for applications that generate dynamic entities on demand for varying schemas.

4. JPA Annotation Accuracy

   • Ensure all annotation properties match your static setup:
     • @OneToMany(mappedBy = "simpleTableEntity") must reference the exact field name in SimpleForeignTableEntity.
     • @JoinColumn(name = "simple_key") must align with your database foreign key column name.
     • All nullable and cascade settings should mirror your original static entities.

Final Notes #

This approach produces dynamic entities that behave identically to your static sample in a JPA context. ByteBuddy doesn’t restrict cyclic type references—you just need to structure the builder process to resolve type metadata before defining interdependent fields.

If you encounter class loading errors (like ClassNotFoundException), double-check that you’re using the same ClassLoader for all related dynamic entities.

备注：内容来源于stack exchange，提问作者José Carlos Canova