org.springframework.dao.annotation

## Class PersistenceExceptionTranslationPostProcessor

- java.lang.Object
- - org.springframework.aop.framework.ProxyConfig
  - - org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor
    - - org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor

- All Implemented Interfaces:
    Serializable, Aware, BeanClassLoaderAware, BeanFactoryAware, BeanPostProcessor, Ordered

      public class PersistenceExceptionTranslationPostProcessor
      extends AbstractAdvisingBeanPostProcessor
      implements BeanFactoryAware

  Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @`Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

  Translates native resource exceptions to Spring's `DataAccessException` hierarchy. Autodetects beans that implement the `PersistenceExceptionTranslator` interface, which are subsequently asked to translate candidate exceptions.

  All of Spring's applicable resource factories (e.g. `LocalSessionFactoryBean`, `LocalEntityManagerFactoryBean`) implement the `PersistenceExceptionTranslator` interface out of the box. As a consequence, all that is usually needed to enable automatic exception translation is marking all affected beans (such as Repositories or DAOs) with the `@Repository` annotation, along with defining this post-processor as a bean in the application context.

  Since:
    2.0
  Author:
    Rod Johnson, Juergen Hoeller
  See Also:
    `PersistenceExceptionTranslationAdvisor`, `Repository`, `DataAccessException`, `PersistenceExceptionTranslator`, Serialized Form

- - ### Field Summary

    - ### Fields inherited from class org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor

      `advisor, beforeExistingAdvisors`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PersistenceExceptionTranslationPostProcessor()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
    `void` | `setRepositoryAnnotationType(Class<? extends Annotation> repositoryAnnotationType)` Set the 'repository' annotation type.

    - ### Methods inherited from class org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor

      `getOrder, isEligible, postProcessAfterInitialization, postProcessBeforeInitialization, setBeanClassLoader, setBeforeExistingAdvisors, setOrder`

    - ### Methods inherited from class org.springframework.aop.framework.ProxyConfig

      `copyFrom, isExposeProxy, isFrozen, isOpaque, isOptimize, isProxyTargetClass, setExposeProxy, setFrozen, setOpaque, setOptimize, setProxyTargetClass, toString`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### PersistenceExceptionTranslationPostProcessor

          public PersistenceExceptionTranslationPostProcessor()

  - ### Method Detail

    - #### setRepositoryAnnotationType

          public void setRepositoryAnnotationType(Class<? extends Annotation> repositoryAnnotationType)

      Set the 'repository' annotation type. The default repository annotation type is the `Repository` annotation.

      This setter property exists so that developers can provide their own (non-Spring-specific) annotation type to indicate that a class has a repository role.

      Parameters:
        `repositoryAnnotationType` - the desired annotation type

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Description copied from interface: `BeanFactoryAware`
      Callback that supplies the owning factory to a bean instance.

      Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`