1. 概要

このチュートリアルでは、カスタムSpringアノテーションをbeanポストプロセッサで実装します。

では、これはどのように役立ちますか? 簡単に言えば、同じタイプの類似したBeanを複数作成する代わりに、同じBeanを再利用できます。

これは、単純なプロジェクトのDAO実装に対して行います。つまり、すべてを単一の柔軟な GenericDaoに置き換えます。

2. Maven

これを機能させるには、 spring-core spring-aop 、および spring-context-supportJARが必要です。 pom.xmlspring-context-supportを宣言するだけです。

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

Spring依存関係の新しいバージョンを使用したい場合は、Mavenリポジトリを確認してください。

3. 新しいジェネリックDAO

ほとんどのSpring/JPA / Hibernateの実装では、標準のDAOが使用されます。通常はエンティティごとに1つです。

そのソリューションをGenericDaoに置き換えます。 代わりにカスタムアノテーションプロセッサを作成し、そのGenericDao実装を使用します。

3.1. ジェネリックDAO

public class GenericDao<E> {

    private Class<E> entityClass;

    public GenericDao(Class<E> entityClass) {
        this.entityClass = entityClass;
    }

    public List<E> findAll() {
        // ...
    }

    public Optional<E> persist(E toPersist) {
        // ...
    }
}

もちろん、実際のシナリオでは、 PersistenceContext を接続して、これらのメソッドの実装を実際に提供する必要があります。 今のところ、これを可能な限り単純にします。

それでは、カスタムインジェクション用のアノテーションを作成しましょう。

3.2. データアクセス

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD})
@Documented
public @interface DataAccess {
    Class<?> entity();
}

上記のアノテーションを使用して、GenericDaoを次のように挿入します。

@DataAccess(entity=Person.class)
private GenericDao<Person> personDao;

「SpringはDataAccessアノテーションをどのように認識しますか?」と質問する人もいるかもしれません。 そうではありません–デフォルトではありません。

しかし、カスタム BeanPostProcessor を介して注釈を認識するようにSpringに指示することはできます。次に、これを実装してみましょう。

3.3. DataAccessAnnotationProcessor

@Component
public class DataAccessAnnotationProcessor implements BeanPostProcessor {

    private ConfigurableListableBeanFactory configurableBeanFactory;

    @Autowired
    public DataAccessAnnotationProcessor(ConfigurableListableBeanFactory beanFactory) {
        this.configurableBeanFactory = beanFactory;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
      throws BeansException {
        this.scanDataAccessAnnotation(bean, beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
      throws BeansException {
        return bean;
    }

    protected void scanDataAccessAnnotation(Object bean, String beanName) {
        this.configureFieldInjection(bean);
    }

    private void configureFieldInjection(Object bean) {
        Class<?> managedBeanClass = bean.getClass();
        FieldCallback fieldCallback = 
          new DataAccessFieldCallback(configurableBeanFactory, bean);
        ReflectionUtils.doWithFields(managedBeanClass, fieldCallback);
    }
}

次へ–使用したDataAccessFieldCallbackの実装は次のとおりです。

3.4. DataAccessFieldCallback

public class DataAccessFieldCallback implements FieldCallback {
    private static Logger logger = LoggerFactory.getLogger(DataAccessFieldCallback.class);
    
    private static int AUTOWIRE_MODE = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;

    private static String ERROR_ENTITY_VALUE_NOT_SAME = "@DataAccess(entity) "
            + "value should have same type with injected generic type.";
    private static String WARN_NON_GENERIC_VALUE = "@DataAccess annotation assigned "
            + "to raw (non-generic) declaration. This will make your code less type-safe.";
    private static String ERROR_CREATE_INSTANCE = "Cannot create instance of "
            + "type '{}' or instance creation is failed because: {}";

    private ConfigurableListableBeanFactory configurableBeanFactory;
    private Object bean;

    public DataAccessFieldCallback(ConfigurableListableBeanFactory bf, Object bean) {
        configurableBeanFactory = bf;
        this.bean = bean;
    }

    @Override
    public void doWith(Field field) 
    throws IllegalArgumentException, IllegalAccessException {
        if (!field.isAnnotationPresent(DataAccess.class)) {
            return;
        }
        ReflectionUtils.makeAccessible(field);
        Type fieldGenericType = field.getGenericType();
        // In this example, get actual "GenericDAO' type.
        Class<?> generic = field.getType(); 
        Class<?> classValue = field.getDeclaredAnnotation(DataAccess.class).entity();

        if (genericTypeIsValid(classValue, fieldGenericType)) {
            String beanName = classValue.getSimpleName() + generic.getSimpleName();
            Object beanInstance = getBeanInstance(beanName, generic, classValue);
            field.set(bean, beanInstance);
        } else {
            throw new IllegalArgumentException(ERROR_ENTITY_VALUE_NOT_SAME);
        }
    }

    public boolean genericTypeIsValid(Class<?> clazz, Type field) {
        if (field instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) field;
            Type type = parameterizedType.getActualTypeArguments()[0];

            return type.equals(clazz);
        } else {
            logger.warn(WARN_NON_GENERIC_VALUE);
            return true;
        }
    }

    public Object getBeanInstance(
      String beanName, Class<?> genericClass, Class<?> paramClass) {
        Object daoInstance = null;
        if (!configurableBeanFactory.containsBean(beanName)) {
            logger.info("Creating new DataAccess bean named '{}'.", beanName);

            Object toRegister = null;
            try {
                Constructor<?> ctr = genericClass.getConstructor(Class.class);
                toRegister = ctr.newInstance(paramClass);
            } catch (Exception e) {
                logger.error(ERROR_CREATE_INSTANCE, genericClass.getTypeName(), e);
                throw new RuntimeException(e);
            }
            
            daoInstance = configurableBeanFactory.initializeBean(toRegister, beanName);
            configurableBeanFactory.autowireBeanProperties(daoInstance, AUTOWIRE_MODE, true);
            configurableBeanFactory.registerSingleton(beanName, daoInstance);
            logger.info("Bean named '{}' created successfully.", beanName);
        } else {
            daoInstance = configurableBeanFactory.getBean(beanName);
            logger.info(
              "Bean named '{}' already exists used as current bean reference.", beanName);
        }
        return daoInstance;
    }
}

さて、これはかなりの実装ですが、その最も重要な部分は doWith()メソッドです。

genericDaoInstance = configurableBeanFactory.initializeBean(beanToRegister, beanName);
configurableBeanFactory.autowireBeanProperties(genericDaoInstance, autowireMode, true);
configurableBeanFactory.registerSingleton(beanName, genericDaoInstance);

これにより、実行時に@DataAccessアノテーションを介して注入されたオブジェクトに基づいてBeanを初期化するようにSpringに指示されます。

bean Name は、beanの一意のインスタンスを確実に取得します。これは、この場合、GenericDaoの単一のオブジェクトを作成するためです。 @DataAccessアノテーションを介して挿入されたエンティティ。

最後に、この新しいbeanプロセッサをSpring構成で使用してみましょう。

3.5. CustomAnnotationConfiguration

@Configuration
@ComponentScan("com.baeldung.springcustomannotation")
public class CustomAnnotationConfiguration {}

ここで重要なことの1つは、 @ComponentScan アノテーションの値が、カスタムBeanポストプロセッサが配置されているパッケージを指し、実行時にSpringによってスキャンおよび自動配線されていることを確認する必要があることです。

4. 新しいDAOのテスト

ここでは、Spring対応のテストと2つの簡単なエンティティクラスの例( PersonAccount)から始めましょう。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={CustomAnnotationConfiguration.class})
public class DataAccessAnnotationTest {

    @DataAccess(entity=Person.class) 
    private GenericDao<Person> personGenericDao;
    @DataAccess(entity=Account.class) 
    private GenericDao<Account> accountGenericDao;
    @DataAccess(entity=Person.class) 
    private GenericDao<Person> anotherPersonGenericDao;

    ...
}

DataAccess アノテーションを使用して、GenericDaoのインスタンスをいくつか挿入しています。 新しいBeanが正しく注入されていることをテストするには、以下をカバーする必要があります。

  1. 注射が成功した場合
  2. 同じエンティティを持つBeanインスタンスが同じである場合
  3. GenericDaoのメソッドが実際に期待どおりに機能する場合

ポイント1は、実際にはSpring自体によってカバーされています。Beanを配線できない場合、フレームワークはかなり早い段階で例外をスローするためです。

ポイント2をテストするには、両方がPersonクラスを使用するGenericDaoの2つのインスタンスを確認する必要があります。

@Test
public void whenGenericDaoInjected_thenItIsSingleton() {
    assertThat(personGenericDao, not(sameInstance(accountGenericDao)));
    assertThat(personGenericDao, not(equalTo(accountGenericDao)));
    assertThat(personGenericDao, sameInstance(anotherPersonGenericDao));
}

personGenericDaoaccountGenericDaoと等しくなることは望ましくありません。

ただし、personGenericDaoanotherPersonGenericDaoをまったく同じインスタンスにする必要があります。

ポイント3をテストするために、ここでいくつかの単純な永続性関連のロジックをテストします。

@Test
public void whenFindAll_thenMessagesIsCorrect() {
    personGenericDao.findAll();
    assertThat(personGenericDao.getMessage(), 
      is("Would create findAll query from Person"));

    accountGenericDao.findAll();
    assertThat(accountGenericDao.getMessage(), 
      is("Would create findAll query from Account"));
}

@Test
public void whenPersist_thenMessagesIsCorrect() {
    personGenericDao.persist(new Person());
    assertThat(personGenericDao.getMessage(), 
      is("Would create persist query from Person"));

    accountGenericDao.persist(new Account());
    assertThat(accountGenericDao.getMessage(), 
      is("Would create persist query from Account"));
}

5. 結論

この記事では、 BeanPostProcessor とともに、Springでカスタムアノテーションの非常に優れた実装を行いました。 全体的な目標は、永続層に通常ある複数のDAO実装を取り除き、プロセスで何も失うことなく、優れた単純な汎用実装を使用することでした。

これらすべての例とコードスニペットの実装は、 my GitHubプロジェクトにあります。これはEclipseベースのプロジェクトであるため、そのままインポートして実行するのは簡単です。