org.apache.deltaspike.jpa.api.transaction.Transactional Java Examples

public <T> T get(Contextual<T> component)
{
    Map<Contextual, TransactionBeanEntry> transactionBeanEntryMap =
            TransactionBeanStorage.getInstance().getActiveTransactionContext();

    if (transactionBeanEntryMap == null)
    {
        TransactionBeanStorage.close();

        throw new ContextNotActiveException("Not accessed within a transactional method - use @" +
                Transactional.class.getName());
    }

    TransactionBeanEntry transactionBeanEntry = transactionBeanEntryMap.get(component);
    if (transactionBeanEntry != null)
    {
        return (T) transactionBeanEntry.getContextualInstance();
    }

    return null;
}
 

public <T> T get(Contextual<T> component, CreationalContext<T> creationalContext)
{
    Map<Contextual, TransactionBeanEntry> transactionBeanEntryMap =
        TransactionBeanStorage.getInstance().getActiveTransactionContext();

    if (transactionBeanEntryMap == null)
    {
        TransactionBeanStorage.close();

        throw new ContextNotActiveException("Not accessed within a transactional method - use @" +
                Transactional.class.getName());
    }

    TransactionBeanEntry transactionBeanEntry = transactionBeanEntryMap.get(component);
    if (transactionBeanEntry != null)
    {
        return (T) transactionBeanEntry.getContextualInstance();
    }

    // if it doesn't yet exist, we need to create it now!
    T instance = component.create(creationalContext);
    transactionBeanEntry = new TransactionBeanEntry(component, instance, creationalContext);
    transactionBeanEntryMap.put(component, transactionBeanEntry);

    return instance;
}
 

@Transactional
public void executeInTransaction()
{
    try
    {
        nestedTransactionBean.executeInTransaction();
    }
    catch (TestException e)
    {
        //expected -> do nothing
    }
}
 

public RepositoryMethodMetadata init(RepositoryMetadata repositoryMetadata, Method method, BeanManager beanManager)
{
    RepositoryMethodMetadata repositoryMethodMetadata = new RepositoryMethodMetadata();
    
    repositoryMethodMetadata.setMethod(method);

    repositoryMethodMetadata.setReturnsOptional(Optional.class.isAssignableFrom(method.getReturnType()));
    repositoryMethodMetadata.setReturnsStream(Stream.class.isAssignableFrom(method.getReturnType()));
    
    repositoryMethodMetadata.setQuery(method.isAnnotationPresent(Query.class)
            ? method.getAnnotation(Query.class) : null);
    repositoryMethodMetadata.setModifying(method.isAnnotationPresent(Modifying.class)
            ? method.getAnnotation(Modifying.class) : null);
    
    repositoryMethodMetadata.setTransactional(AnnotationUtils.extractAnnotationFromMethodOrClass(
            beanManager, method, repositoryMetadata.getRepositoryClass(), Transactional.class));

    repositoryMethodMetadata.setMethodPrefix(new RepositoryMethodPrefix(
                repositoryMetadata.getRepositoryClass().getAnnotation(Repository.class).methodPrefix(),
                method.getName()));
    repositoryMethodMetadata.setMethodType(
            extractMethodType(repositoryMetadata, repositoryMethodMetadata));
    
    repositoryMethodMetadata.setQueryProcessor(queryProcessorFactory.build(repositoryMethodMetadata));
    
    repositoryMethodMetadata.setQueryInOutMapperClass(
            extractMapper(method, repositoryMetadata));

    initQueryRoot(repositoryMetadata, repositoryMethodMetadata);
    initQueryInOutMapperIsNormalScope(repositoryMethodMetadata, beanManager);

    initSingleResultType(repositoryMethodMetadata);
    initRequiresTransaction(repositoryMethodMetadata);

    
    return repositoryMethodMetadata;
}
 

/**
 * @return the @Transactional annotation from either the method or class
 *         or <code>null</code> if none present.
 */
protected Transactional extractTransactionalAnnotation(InvocationContext context)
{
    Class targetClass = context.getTarget() != null ? context.getTarget().getClass() :
        context.getMethod().getDeclaringClass();
    return AnnotationUtils
        .extractAnnotationFromMethodOrClass(beanManager, context.getMethod(), targetClass, Transactional.class);
}
 

public boolean readFrom(AnnotatedElement method, BeanManager beanManager)
{
    EntityManagerConfig entityManagerConfig = method.getAnnotation(EntityManagerConfig.class);
    boolean processed = processEntityManagerConfig(beanManager, entityManagerConfig);

    Transactional transactional = method.getAnnotation(Transactional.class);

    processed = processTransactional(processed, transactional);

    return processed;
}
 

private boolean processTransactional(boolean processed, Transactional transactional)
{
    if (transactional != null && this.qualifiers == null)
    {
        processed = true;
        this.setQualifiers(transactional.qualifier());
    }

    if (transactional != null)
    {
        this.readOnly = transactional.readOnly();
    }
    return processed;
}
 

@Transactional
public void executeInTransaction()
{
    try
    {
        nestedTransactionBean.executeInTransaction();
    }
    catch (TestException e)
    {
        //catch to test that the transaction doesn't get rolled back
        //do nothing
    }
}
 

/**
 * This methods requests a transaction for the EntityManager qualified with {@link Second} although there is no
 * producer for such an {@link EntityManager}.
 */
@Transactional
@EntityManagerConfig(qualifier = Second.class)
public void executeInTransaction()
{
    // no need to do anything
}
 

@Transactional
public void executeInTransaction()
{
    secondEntityManager.getTransaction().setRollbackOnly();
}
 

@Transactional
public void executeInTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
    nestedTransactionBean.executeInTransaction();
}
 

@Transactional
public void executeInTransactionRollback2()
{
    this.secondEntityManager.getTransaction().setRollbackOnly();
}
 

@Transactional
public void executeInTransactionRollback1()
{
    this.firstEntityManager.getTransaction().setRollbackOnly();
}
 

@Transactional
public void executeInTransactionRollbackDefault()
{
    this.defaultEntityManager.getTransaction().setRollbackOnly();
}
 

@Transactional
public void executeInTransaction()
{
    throw new TestException();
}
 

@Transactional
public void executeInTransaction()
{
    nestedTransactionBean.executeInTransaction();
}
 

@Transactional
public void executeInTransaction()
{
    throw new TestException();
}
 

@Transactional
public void executeInTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
    nestedTransactionBean.executeInTransaction();
}
 

@Transactional
public void executeInTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
    nestedTransactionBean.executeInTransaction();
}
 

@Transactional
public void executeInTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
    nestedTransactionBean.executeInTransaction();
}
 

@Transactional
public void executeInTransaction()
{
    throw new TestException();
}
 

@Transactional(qualifier = Default.class)
public void executeInDefaultTransaction()
{
}
 

@Transactional(qualifier = First.class)
public void executeInFirstTransaction()
{
}
 

@Transactional(qualifier = Second.class)
public void executeInSecondTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
}
 

@Transactional
public void executeInTransaction()
{
}