javax.transaction.Transactional.TxType Java Examples

@Transactional(TxType.REQUIRES_NEW)
@Override
public List<IntQueryOperateAggResponseDto> operateAggregationQuery(int ciTypeId, List<IntQueryOperateAggRequetDto> aggRequests) {
    if (logger.isDebugEnabled()) {
        logger.debug("operateAggregationQuery with ciTypeId:{}, aggRequests: {}", ciTypeId, JsonUtil.toJson(aggRequests));
    }

    List<IntQueryOperateAggResponseDto> responseDtos = new ArrayList<>(aggRequests.size());
    aggRequests.forEach(x -> {
        IntQueryAggOperation operation = IntQueryAggOperation.fromCode(x.getOperation());
        if (IntQueryAggOperation.None.equals(operation)) {
            throw new InvalidArgumentException(String.format("Wrong operation [%s] for integration aggreation query request.", x.getOperation()));
        }
        responseDtos.add(operateAggregationQueryUnit(ciTypeId, x, operation));
    });

    if (logger.isDebugEnabled()) {
        logger.debug("operateAggregationQuery response: {}", JsonUtil.toJson(responseDtos));
    }
    return responseDtos;
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public void doInTx() {
    Assertions.assertEquals(0, Person.count());

    Person entity = new Person();
    entity.name = "Stef";
    entity.persist();
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public Uni<String> doInTxUni() {
    Assertions.assertEquals(0, Person.count());

    Person entity = new Person();
    entity.name = "Stef";
    entity.persist();

    return Uni.createFrom().item("OK");
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public Multi<String> doInTxMulti() {
    Assertions.assertEquals(0, Person.count());

    Person entity = new Person();
    entity.name = "Stef";
    entity.persist();

    return Multi.createFrom().items("OK");
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public void doInTx() {
    Assertions.assertEquals(0, ContextEntity.count());

    ContextEntity entity = new ContextEntity();
    entity.name = "Stef";
    entity.persist();
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public Single<String> doInTxSingle() {
    Assertions.assertEquals(0, ContextEntity.count());

    ContextEntity entity = new ContextEntity();
    entity.name = "Stef";
    entity.persist();

    return Single.just("OK");
}
 

@Transactional(value = TxType.REQUIRES_NEW)
public Flowable<String> doInTxPublisher() {
    Assertions.assertEquals(0, ContextEntity.count());

    ContextEntity entity = new ContextEntity();
    entity.name = "Stef";
    entity.persist();

    return Flowable.fromArray("OK");
}
 

@Override
@Transactional(TxType.REQUIRED)
public <T> T required(Supplier<T> callback) {
    return callback.get();
}
 

@POST
@Path("/client/reindex")
@Transactional(TxType.NEVER)
public void reindex() throws InterruptedException {
	Search.mapping( entityManagerFactory )
			.scope( Client.class )
			.massIndexer()
			.startAndWait();
}
 

@Override
@Transactional(TxType.MANDATORY)
public void mandatory(Runnable callback) {
    callback.run();
}
 

@Override
@Transactional(TxType.REQUIRES_NEW)
public void doThrowing() {
  doOk();
  throw new IllegalStateException();
}
 

@Override
@Transactional(TxType.SUPPORTS)
public void supports(Runnable callback) {
    callback.run();
}
 

@Override
@Transactional(TxType.NOT_SUPPORTED)
public void notSupported(Runnable callback) {
    callback.run();
}
 

@Override
@Transactional(TxType.NEVER)
public void never(Runnable callback) {
    callback.run();
}
 

@Transactional(TxType.NEVER)
void reindexOnStart(@Observes StartupEvent event) throws InterruptedException {
	if ( "dev".equals( ProfileManager.getActiveProfile() ) ) {
		reindex();
	}
}
 

@Transactional(value=TxType.MANDATORY)
public String doSomething() {
    return "Success";
}
 

@Transactional(TxType.REQUIRES_NEW)
@Override
public int createIntegrationQuery(int ciTypeId, String queryName, IntegrationQueryDto intQueryDto) {
    if (logger.isDebugEnabled()) {
        logger.debug("Creating integrate query for ciTypeId [{}] queryName:{} intQueryDto:{}", ciTypeId, queryName, JsonUtil.toJsonString(intQueryDto));
    }
    intQueryDto.validate();

    List<AdmIntegrateTemplate> intQuerys = intTempRepository.findAllByName(queryName);
    if(intQuerys != null && intQuerys.size()>0){
        throw new InvalidArgumentException(String.format("The given integration name (%s) is existed.",queryName));
    }

    AdmIntegrateTemplate intTemplate = new AdmIntegrateTemplate();
    intTemplate.setName(queryName);
    intTemplate.setDes(queryName);
    intTemplate.setCiTypeId(ciTypeId);

    intTemplate = buildIntegrateTempl(intQueryDto, intTemplate, null, null);

    // validate selection
    if (intTemplate.getAdmIntegrateTemplateAlias().size() == 0) {
        throw new InvalidArgumentException("Please select at leaset one CI.");
    }

    AtomicInteger attrCount = new AtomicInteger(0);
    intTemplate.getAdmIntegrateTemplateAlias().forEach(x -> {
        attrCount.addAndGet(x.getAdmIntegrateTemplateAliasAttrs().size());
    });
    if (attrCount.get() == 0) {
        throw new InvalidArgumentException("Please select at least one attribute.");
    }

    intTempRepository.save(intTemplate);
    intTemplAliasRepository.saveAll(intTemplate.getAdmIntegrateTemplateAlias());
    intTemplate.getAdmIntegrateTemplateAlias().forEach(x -> {
        intTemplAliasAttrRepository.saveAll(x.getAdmIntegrateTemplateAliasAttrs());
        intTemplRltRepository.saveAll(x.getChildIntegrateTemplateRelations());
    });
    logger.info("Created integrate template:{}", intTemplate.getIdAdmIntegrateTemplate());
    return intTemplate.getIdAdmIntegrateTemplate();
}
 

@Override
@Transactional(TxType.REQUIRES_NEW)
public void requiresNew(Runnable callback) {
    callback.run();
}
 

@Override
@Transactional(TxType.REQUIRED)
public void required(Runnable callback) {
    callback.run();
}
 

@Override
@Transactional(TxType.NEVER)
public <T> T never(Supplier<T> callback) {
    return callback.get();
}
 

@Override
@Transactional(TxType.NOT_SUPPORTED)
public <T> T notSupported(Supplier<T> callback) {
    return callback.get();
}
 

@Override
@Transactional(TxType.SUPPORTS)
public <T> T supports(Supplier<T> callback) {
    return callback.get();
}
 

@Override
@Transactional(TxType.MANDATORY)
public <T> T mandatory(Supplier<T> callback) {
    return callback.get();
}
 

@Override
@Transactional(TxType.REQUIRES_NEW)
public <T> T requiresNew(Supplier<T> callback) {
    return callback.get();
}
 

@Override
@Transactional(TxType.REQUIRES_NEW)
public void doThrowing() {
  doOk();
  throw new IllegalStateException();
}
 

/**
 * Test value method.
 */
@Test
public void testValue() {
    Transactional transactional = new TestTransactional();
    assertEquals(transactional.value(), TxType.MANDATORY);
}