Java PersistenceExceptionTranslator类代码示例

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Actually create the EntityManager proxy.
 * @param rawEm raw EntityManager
 * @param emIfc the (potentially vendor-specific) EntityManager
 * interface to proxy, or {@code null} for default detection of all interfaces
 * @param cl the ClassLoader to use for proxy creation (maybe {@code null})
 * @param exceptionTranslator the PersistenceException translator to use
 * @param jta whether to create a JTA-aware EntityManager
 * (or {@code null} if not known in advance)
 * @param containerManaged whether to follow container-managed EntityManager
 * or application-managed EntityManager semantics
 * @param synchronizedWithTransaction whether to automatically join ongoing
 * transactions (according to the JPA 2.1 SynchronizationType rules)
 * @return the EntityManager proxy
 */
private static EntityManager createProxy(
		EntityManager rawEm, Class<? extends EntityManager> emIfc, ClassLoader cl,
		PersistenceExceptionTranslator exceptionTranslator, Boolean jta,
		boolean containerManaged, boolean synchronizedWithTransaction) {

	Assert.notNull(rawEm, "EntityManager must not be null");
	Set<Class<?>> ifcs = new LinkedHashSet<Class<?>>();
	if (emIfc != null) {
		ifcs.add(emIfc);
	}
	else {
		ifcs.addAll(ClassUtils.getAllInterfacesForClassAsSet(rawEm.getClass(), cl));
	}
	ifcs.add(EntityManagerProxy.class);
	return (EntityManager) Proxy.newProxyInstance(
			(cl != null ? cl : ExtendedEntityManagerCreator.class.getClassLoader()),
			ifcs.toArray(new Class<?>[ifcs.size()]),
			new ExtendedEntityManagerInvocationHandler(
					rawEm, exceptionTranslator, jta, containerManaged, synchronizedWithTransaction));
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Actually create the EntityManager proxy.
 * @param rawEm raw EntityManager
 * @param emIfc the (potentially vendor-specific) EntityManager
 * interface to proxy, or {@code null} for default detection of all interfaces
 * @param plusOperations an implementation of the EntityManagerPlusOperations
 * interface, if those operations should be exposed (may be {@code null})
 * @param exceptionTranslator the PersistenceException translator to use
 * @param jta whether to create a JTA-aware EntityManager
 * (or {@code null} if not known in advance)
 * @param containerManaged whether to follow container-managed EntityManager
 * or application-managed EntityManager semantics
 * @return the EntityManager proxy
 */
private static EntityManager createProxy(
		EntityManager rawEm, Class<? extends EntityManager> emIfc, ClassLoader cl,
		EntityManagerPlusOperations plusOperations, PersistenceExceptionTranslator exceptionTranslator,
		Boolean jta, boolean containerManaged) {

	Assert.notNull(rawEm, "EntityManager must not be null");
	Set<Class> ifcs = new LinkedHashSet<Class>();
	if (emIfc != null) {
		ifcs.add(emIfc);
	}
	else {
		ifcs.addAll(ClassUtils.getAllInterfacesForClassAsSet(rawEm.getClass(), cl));
	}
	ifcs.add(EntityManagerProxy.class);
	if (plusOperations != null) {
		ifcs.add(EntityManagerPlusOperations.class);
	}
	return (EntityManager) Proxy.newProxyInstance(
			(cl != null ? cl : ExtendedEntityManagerCreator.class.getClassLoader()),
			ifcs.toArray(new Class[ifcs.size()]),
			new ExtendedEntityManagerInvocationHandler(
					rawEm, plusOperations, exceptionTranslator, jta, containerManaged));
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Create a new PersistenceExceptionTranslationAdvisor.
 * @param persistenceExceptionTranslator the PersistenceExceptionTranslator to use
 * @param repositoryAnnotationType the annotation type to check for
 */
public PersistenceExceptionTranslationAdvisor(
		PersistenceExceptionTranslator persistenceExceptionTranslator,
		Class<? extends Annotation> repositoryAnnotationType) {

	this.advice = new PersistenceExceptionTranslationInterceptor(persistenceExceptionTranslator);
	this.pointcut = new AnnotationMatchingPointcut(repositoryAnnotationType, true);
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
private ExtendedEntityManagerInvocationHandler(EntityManager target,
		PersistenceExceptionTranslator exceptionTranslator, Boolean jta,
		boolean containerManaged, boolean synchronizedWithTransaction) {

	this.target = target;
	this.exceptionTranslator = exceptionTranslator;
	this.jta = (jta != null ? jta : isJtaEntityManager());
	this.containerManaged = containerManaged;
	this.synchronizedWithTransaction = synchronizedWithTransaction;
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
protected void doTestExceptionTranslationWithDialectFound(PersistenceExceptionTranslator pet) throws Exception {
	RuntimeException in1 = new RuntimeException("in1");
	PersistenceException in2 = new PersistenceException();
	assertNull("No translation here", pet.translateExceptionIfPossible(in1));
	DataAccessException dex = pet.translateExceptionIfPossible(in2);
	assertNotNull(dex);
	assertSame(in2, dex.getCause());
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
@Override
protected void addPersistenceExceptionTranslation(ProxyFactory pf, PersistenceExceptionTranslator pet) {
	if (AnnotationUtils.findAnnotation(pf.getTargetClass(), Repository.class) != null) {
		DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
		bf.registerBeanDefinition("peti", new RootBeanDefinition(PersistenceExceptionTranslationInterceptor.class));
		bf.registerSingleton("pet", pet);
		pf.addAdvice((PersistenceExceptionTranslationInterceptor) bf.getBean("peti"));
	}
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
		PersistenceExceptionTranslator exceptionTranslator) {

	super(sqlSessionFactory, executorType, exceptionTranslator);

	this.sqlSessionFactory = sqlSessionFactory;
	this.executorType = executorType;
	this.exceptionTranslator = exceptionTranslator;

	this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(),
			new Class[] { SqlSession.class }, new SqlSessionInterceptor());

	this.defaultTargetSqlSessionFactory = sqlSessionFactory;
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Constructs a Spring managed {@code SqlSession} with the given {@code SqlSessionFactory} and {@code ExecutorType}.
 * A custom {@code SQLExceptionTranslator} can be provided as an argument so any {@code PersistenceException} thrown
 * by MyBatis can be custom translated to a {@code RuntimeException} The {@code SQLExceptionTranslator} can also be
 * null and thus no exception translation will be done and MyBatis exceptions will be thrown
 *
 * @param sqlSessionFactory
 * @param executorType
 * @param exceptionTranslator
 */
public SimpleSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
		PersistenceExceptionTranslator exceptionTranslator) {
	super(sqlSessionFactory);
	notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
	notNull(executorType, "Property 'executorType' is required");

	this.defaultSqlSessionFactory = sqlSessionFactory;
	this.executorType = executorType;
	this.exceptionTranslator = exceptionTranslator;
	this.sqlSessionProxy = (SqlSession) newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[] { SqlSession.class },
			new SqlSessionInterceptor());
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Constructs a Spring managed {@code SqlSession} with the given
 * {@code SqlSessionFactory} and {@code ExecutorType}.
 * A custom {@code SQLExceptionTranslator} can be provided as an
 * argument so any {@code PersistenceException} thrown by MyBatis
 * can be custom translated to a {@code RuntimeException}
 * The {@code SQLExceptionTranslator} can also be null and thus no
 * exception translation will be done and MyBatis exceptions will be
 * thrown
 *
 * @param sqlSessionFactory
 * @param executorType
 * @param exceptionTranslator
 */
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
  notNull(executorType, "Property 'executorType' is required");

  this.sqlSessionFactory = sqlSessionFactory;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
  this.sqlSessionProxy = (SqlSession) newProxyInstance(
      SqlSessionFactory.class.getClassLoader(),
      new Class[] { SqlSession.class },
      new SqlSessionInterceptor());
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Creates a new holder instance.
 *
 * @param sqlSession the {@code SqlSession} has to be hold.
 * @param executorType the {@code ExecutorType} has to be hold.
 */
public SqlSessionHolder(SqlSession sqlSession,
    ExecutorType executorType,
    PersistenceExceptionTranslator exceptionTranslator) {

  notNull(sqlSession, "SqlSession must not be null");
  notNull(executorType, "ExecutorType must not be null");

  this.sqlSession = sqlSession;
  this.executorType = executorType;
  this.exceptionTranslator = exceptionTranslator;
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
/**
 * Gets any {@link PersistenceExceptionTranslator}s from the {@link BeanFactory}.
 *
 * @param beanFactory The {@link BeanFactory} to use.
 *
 * @return A {@link PersistenceExceptionTranslator} from the {@link BeanFactory}.
 */
protected PersistenceExceptionTranslator detectPersistenceExceptionTranslators(ListableBeanFactory beanFactory) {
    // Find all translators, being careful not to activate FactoryBeans.
    Map<String, PersistenceExceptionTranslator> pets = BeanFactoryUtils.beansOfTypeIncludingAncestors(beanFactory,
            PersistenceExceptionTranslator.class, false, false);
    ChainedPersistenceExceptionTranslator cpet = new ChainedPersistenceExceptionTranslator();
    for (PersistenceExceptionTranslator pet : pets.values()) {
        cpet.addDelegate(pet);
    }
    // always add one last persistence exception translator as a catch all
    cpet.addDelegate(new DefaultPersistenceExceptionTranslator());
    return cpet;
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
private void registerPersistenceExceptionTranslator() {
	if (this.applicationContext != null
			&& this.applicationContext.getBeansOfType(PersistenceExceptionTranslator.class).isEmpty()) {
		if (this.applicationContext instanceof ConfigurableApplicationContext) {
			((ConfigurableApplicationContext) this.applicationContext).getBeanFactory().registerSingleton(
					"solrExceptionTranslator", EXCEPTION_TRANSLATOR);
		}
	}
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
@Bean
public PersistenceExceptionTranslator persistenceExceptionTranslator() {
    return new PersistenceExceptionTranslator() {
        @Override
        public DataAccessException translateExceptionIfPossible(RuntimeException e) {
            return null;
        }
    };
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
private ExtendedEntityManagerInvocationHandler(
		EntityManager target, EntityManagerPlusOperations plusOperations,
		PersistenceExceptionTranslator exceptionTranslator, Boolean jta, boolean containerManaged) {

	this.target = target;
	this.plusOperations = plusOperations;
	this.exceptionTranslator = exceptionTranslator;
	this.jta = (jta != null ? jta : isJtaEntityManager());
	this.containerManaged = containerManaged;
}
 

import org.springframework.dao.support.PersistenceExceptionTranslator; //导入依赖的package包/类
@Override
@Bean
public MongoDbFactory mongoDbFactory() {
  return new SimpleMongoDbFactory(mongo, getDatabaseName(), getUserCredentials(), getAuthenticationDatabaseName()) {
    @Override
    public PersistenceExceptionTranslator getExceptionTranslator() {
      return MongoTemplateWithRetry.getExceptionTranslator();
    }
  };
}