How to apply DynamoDB Bean annotations to a different project's POJOs by using generics?

Question

I'm trying to setup a micro-framework within my application to remove duplication of code ("DRY" principle). Specifically I have a need to use annotations from my project in conjunction with several POJO classes that are in a different project (those are the <T>'s below) and which do not share my dependencies.

So I started with this:

public abstract class DynamoRepo<T> {

    @DynamoDbBean
    public static class Entity<T> {
        private Number id;
        private T bean;
    
        @DynamoDbPartitionKey
        @DynamoDbConvertedBy(IdConverter.class)
        public Number getId() {
            return id;
        }
    
        public void setId(Number id) {
            this.id = id;
        }
    
        @DynamoDbFlatten
        public T getBean() {
            return bean;
        }
    
        public void setBean(T bean) {
            this.bean = bean;
        }
        
        ...

... the annotations are required at runtime for the code below

    private DynamoDbTable<Entity<?>> table;

... with a bit of setup in the constructor ...

    table = enhancedClient.table(tableName, TableSchema.fromBean(new Entity<? extends T>() {}.getClass()));

... I'd like to be able to accept a <T> which doesn't require the caller to know about Entity:

public void putItem(T item) {
    table.putItem(new Entity<T>(item));
}

Alas, this code doesn't compile. There are several problems here and any small tweaks lead to a different compile error.

How can I possibly make this work without having to add @DynamoDb annotations to the underlying POJOs (which are not in my project and don't have DynamoDB as a dependency) or have to manually create subclasses that extend each of the POJOs (and throw DRY out the window by creating a whole parallel object hierarchy)?

This question is about code clarity. Please don't worry about performance overhead.

Answer 1

Recently I implemented an abstract DAO (Repository) in Spring Data style and reactive manner with WebFlux for AWS DynamoDB. Not the ideal, but works fine and as I assume it can fit to your case:

The first part is the abstract DAO. The common interface looks like this:

public interface DynamoDbRepository<T> {

  /** Constant prefix for logging purposes */
  String SN = "[DynamoDbRepository]";

  Mono<PutItemEnhancedResponse<T>> insert(final T object);

  Mono<T> getById(final String id);

  Flux<T> getAll();
}

Logic implementation class which extends DynamoDbRepository:

@Log4j2
@Repository
public abstract class EntityDynamoDbRepository<T> implements DynamoDbRepository<T> {

  private final Class<T> clazz;
  private DynamoDbAsyncTable<T> dynamoDbAsyncTable;

  @Autowired
  @SneakyThrows
  public final void setAsyncClient(DynamoDbEnhancedAsyncClient asyncClient) {
    DynamoDbTable tableName = AnnotationUtils.getAnnotation(clazz, DynamoDbTable.class);
    this.dynamoDbAsyncTable =
        asyncClient.table(tableName.value(), TableSchema.fromBean(this.clazz));
  }

  @SuppressWarnings("unchecked")
  @SneakyThrows
  public EntityDynamoDbRepository() {
    clazz =
        (Class<T>) GenericTypeResolver.resolveTypeArgument(getClass(), DynamoDbRepository.class);
    if (clazz == null) {
      throw new Exception("Not possible to resolve generic type");
    }
  }

  @Override
  public Mono<PutItemEnhancedResponse<T>> insert(final T object) {
    final PutItemEnhancedRequest<T> putItemEnhancedRequest =
        PutItemEnhancedRequest.builder(this.clazz)
            .item(object)
            .build();
    return Mono.fromFuture(dynamoDbAsyncTable.putItemWithResponse(putItemEnhancedRequest));
  }

  public Mono<T> getById(final String id) {
    return Mono.fromFuture(dynamoDbAsyncTable.getItem(getKeyBuild(id)));
  }

  public Flux<T> getAll() {
    return Flux.from(dynamoDbAsyncTable.scan().items());
  }

  private Key getKeyBuild(final String id) {
    return Key.builder().partitionValue(id).build();
  }
}

And finally to implement a concrete Repository:

@Repository
@Log4j2
public class ConcreteRepository extends EntityDynamoDbRepository<ConcreteEntity> {}

You might noticed setAsyncClient method which defines dynamoDbAsyncTable. Due to @DynamoDbBean using the entity class name as a DynamoDB table name, I put custom annotation to assign custom table name there:

@Retention(RetentionPolicy.RUNTIME)
@DynamoDbBean
public @interface DynamoDbTable {
  String value();
}

Answering your question: you can add/call whatever you want inside the EntityDynamoDbRepository constructor to wrap your <POJO> with any possible logic.

p.s.: I didn't paste the DynamoDbEnhancedAsyncClient bean but there are a lot of samples on a GitHub