## org.springframework.dao.annotation
Class PersistenceExceptionTranslationPostProcessor

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

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

    public class PersistenceExceptionTranslationPostProcessor

extends ProxyConfig
implements BeanPostProcessor, BeanClassLoaderAware, BeanFactoryAware, Ordered

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 interface org.springframework.core.Ordered
`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

Constructor Summary
`PersistenceExceptionTranslationPostProcessor()`

Method Summary
`int` `getOrder()` Return the order value of this object, with a higher value meaning greater in terms of sorting.
`Object` `postProcessAfterInitialization(Object bean, String beanName)` Apply this BeanPostProcessor to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
`Object` `postProcessBeforeInitialization(Object bean, String beanName)` Apply this BeanPostProcessor to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
`void` `setBeanClassLoader(ClassLoader classLoader)` Callback that supplies the bean `class loader` to a bean instance.
`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.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

### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader classLoader)

  Description copied from interface: `BeanClassLoaderAware`
  Callback that supplies the bean `class loader` to a bean instance.

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

  Specified by:
    `setBeanClassLoader` in interface `BeanClassLoaderAware`
  Parameters:
    `classLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

### setBeanFactory

    public void setBeanFactory(BeanFactory beanFactory)
                        throws BeansException

  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.
  Throws:
    `BeansException` - in case of initialization errors
  See Also:
    `BeanInitializationException`

### getOrder

    public int getOrder()

  Description copied from interface: `Ordered`
  Return the order value of this object, with a higher value meaning greater in terms of sorting.

  Normally starting with 0, with `Integer.MAX_VALUE` indicating the greatest value. Same order values will result in arbitrary positions for the affected objects.

  Higher values can be interpreted as lower priority. As a consequence, the object with the lowest value has highest priority (somewhat analogous to Servlet "load-on-startup" values).

  Specified by:
    `getOrder` in interface `Ordered`
  Returns:
    the order value

### postProcessBeforeInitialization

    public Object postProcessBeforeInitialization(Object bean,
                                                  String beanName)

  Description copied from interface: `BeanPostProcessor`
  Apply this BeanPostProcessor to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

  Specified by:
    `postProcessBeforeInitialization` in interface `BeanPostProcessor`
  Parameters:
    `bean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
  See Also:
    `InitializingBean.afterPropertiesSet()`

### postProcessAfterInitialization

    public Object postProcessAfterInitialization(Object bean,
                                                 String beanName)

  Description copied from interface: `BeanPostProcessor`
  Apply this BeanPostProcessor to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

  In case of a FactoryBean, this callback will be invoked for both the FactoryBean instance and the objects created by the FactoryBean (as of Spring 2.0). The post-processor can decide whether to apply to either the FactoryBean or created objects or both through corresponding `bean instanceof FactoryBean` checks.

  This callback will also be invoked after a short-circuiting triggered by a `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` method, in contrast to all other BeanPostProcessor callbacks.

  Specified by:
    `postProcessAfterInitialization` in interface `BeanPostProcessor`
  Parameters:
    `bean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
  See Also:
    `InitializingBean.afterPropertiesSet()`, `FactoryBean`