在不更改用法的情况下代理抽象类

Question

我有一个抽象类（数据库映射），该类实现了一个接口，该接口在运行时注入了默认实现（这是另一个库的一部分，无法更改）。

我想通过代理覆盖默认的实现之一（因为这似乎是覆盖它的方法）。

public abstract class Table1 implements Storable<Table1>
{   
    @Sequence("ID_SEQUENCE")
    @Alias("ID")
    public abstract String getID();
    public abstract void setID(String ID);

    @Alias("NAME")
    public abstract String getAvailabilityZone();
    public abstract void setAvailabilityZone(String value);
}

public interface Storable<S extends Storable<S>> {
     //a bunch of method definition.
     boolean tryLoad() throws Exception;
}

假设我想重写tryLoad（）方法来做自己的事情，而不是生成的代码提供的内容。 鉴于库的性质，我无法通过简单的@Override来实现。 当前使用的简单方法如下：

public void method() {
        Table1 t = Repository.storageFor(Table1.class).prepare();
        t.setName( "temp" );
        if (!t.tryLoad())
           t.tryInsert();
}

我想在不更改整个代码库的所有方法的情况下代理tryLoad（），这将是获取代理实例而不是实际实例并对该实例执行操作。

有什么推荐的方法可以做到这一点吗？

谢谢！

Answer 1

我昨晚醒来后感到很无聊，因此尽管您缺乏反馈，我还是创建了一个Carbonbonado展示项目并在GitHub上共享。 我做了三项承诺：

1. Maven项目的初次提交已经为AspectJ作了准备，并为我进行了JUnit测试以了解Carbonado的实际工作原理，因为我以前从未使用过它。

2. 为期望由方面提供的tryLoad()行为添加失败的单元测试 。

3. 添加方面使单元测试通过 。 Aspect挂接到tryLoad()并自动创建不存在的记录。 我不知道我猜对了您实际想要实现的目标，但是如果是另一回事，则只需更改方面的实现即可。

样例代码

卡本多可储存：

package de.scrum_master.app;

import com.amazon.carbonado.Nullable;
import com.amazon.carbonado.PrimaryKey;
import com.amazon.carbonado.Storable;

@PrimaryKey("ID")
public interface StoredMessage extends Storable<StoredMessage> {
  long getID();
  void setID(long id);
  @Nullable String getMessage();
  void setMessage(String message);
}

方面：

package de.scrum_master.aspect;

import com.amazon.carbonado.Storable;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

@Aspect
public class CarbonadoAspect {
  @Around("call(boolean tryLoad()) && target(storable)")
  public boolean tryInsertIfNotFound(ProceedingJoinPoint thisJoinPoint, Storable storable) throws Throwable {
    System.out.println(thisJoinPoint);
    if ((boolean) thisJoinPoint.proceed())
      return true;
    System.out.println("Not found: " + storable + " -> inserting");
    return storable.tryInsert();
  }
}

JUnit测试：

package de.scrum_master.app;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.amazon.carbonado.FetchException;
import com.amazon.carbonado.PersistException;
import com.amazon.carbonado.Repository;
import com.amazon.carbonado.RepositoryException;
import com.amazon.carbonado.Storage;
import com.amazon.carbonado.SupportException;
import com.amazon.carbonado.repo.map.MapRepositoryBuilder;

import de.scrum_master.app.StoredMessage;

public class CarbonadoTest {
  private Repository repo;
  private Storage<StoredMessage> storage;
  StoredMessage message;

  @Before
  public void setUp() throws Exception {
    repo = MapRepositoryBuilder.newRepository();
    storage = repo.storageFor(StoredMessage.class);
    message = storage.prepare();
  }

  @After
  public void tearDown() throws Exception {
    repo.close();
    repo = null;
    storage = null;
    message = null;
  }

  // (...)

  @Test
  public void aspectCreatesNonExistentRecord() throws SupportException, RepositoryException {
    message.setID(1);
    // Without the aspect this would be false
    assertTrue(message.tryLoad());
    assertEquals(message.getID(), 1);
    assertEquals(message.getMessage(), null);
  }

}

请享用！