Comitar dentro do transactional mesmo com problemas

Programação
, ,
#1

Bom dia, tenho um método que faz algumas validações,salva em alguns momentos usando o saveAndFlush porém tenho um problema.
Acontece que se no meio do método ali no trecho “OsbResponseDTO response” acontece alguma merda, ele não comita nada (o “atualizarTicket” é um método que deveria dar um saveAndFlush ou seja comitar) e o pool de conexão com o banco fica aberto.
O que posso fazer para que o commit seja feito independente se der problema naquele trecho ou/e o pool de conexão seja fechado?!

Melhorando a pergunta, como priorizo meus saveAndFlush antes do método que tenha a anotação @Transactional termine… ou seja, eu quero que os “saveAndFlush” sejam feitos independente se o método marcado com “Transactional” terminou sem erros

Obrigado!

@Transactional()
	public Ticket efetivaVenda(VendaDTO vendaDTO) throws EntregaFlexivelException {
		
		Loja loja = lojaRepository.findOne(vendaDTO.getCodigoLoja());
		
		if (loja == null)
			throw new EntregaFlexivelException(ErroConstants.LOJA_NAO_ENCONTRADA, 
					"Loja informada não cadastrada.", HttpStatus.BAD_REQUEST);
		
		List<Ticket> tickets = ticketService.buscaTicketPorPedido(vendaDTO.getNumeroPedido());
		Ticket ticket = null;
		
		if (tickets == null || tickets.isEmpty()) {
			ticket = ticketService.criaNovoTicket(vendaDTO, loja);
		
		} else if(tickets.size() == 1) {
			Ticket t = tickets.get(0); 
			
			if(t.getCdTipClsPagOpr().equals(EntregaFlexivelConstants.TIPO_OPERACAO_PAGAMENTO_VENDA)) {
					return tickets.get(0);
			}else { 
				ticket = atualizarTicket(t, vendaDTO, loja);	
			}
		}else {
			Ticket t = tickets.get(0); 
			if (t.getCdTipClsPagOpr().equals(EntregaFlexivelConstants.TIPO_OPERACAO_PAGAMENTO_EM_ANDAMENTO)) {
				ticket = atualizarTicket(t, vendaDTO, loja);
			} else if(t.getCdTipClsPagOpr().equals(EntregaFlexivelConstants.TIPO_OPERACAO_PAGAMENTO_DESISTENCIA) ||
					t.getCdTipClsPagOpr().equals(EntregaFlexivelConstants.TIPO_OPERACAO_PAGAMENTO_CANCELAMENTO)) {
				ticket = ticketService.criaNovoTicket(vendaDTO, loja);
			} else {
				return t;
			}
		}
				
		ticketRepository.saveAndFlush(ticket);

		try {
			OsbResponseDTO response = osbService.enviaDadosOSB(ticket, vendaDTO);
			ticket = OsbDadosConverter.atualizaDadosTicket(ticket, response);
			ticketRepository.save(ticket);
			sllService.baixaSerialSLL(ticket, EntregaFlexivelConstants.TRANSACAO_VENDA_SLL);
			
			// atualizar a base do siv, inserindo um novo registro.
			ControleCsmSiv novoTktCtrl = this.sivService.buscaTicketControlePorNumero(Long.valueOf(ticket.getNuTkt()), ticket.getLoja().getCdLoj());
			
			if (novoTktCtrl == null) {
				novoTktCtrl = this.sivService.criaNovoTicketControleSiv(ticket);
				this.sivService.insereNovoTicketControleSiv(novoTktCtrl);
			}
		} catch(EntregaFlexivelException e) {
			throw e;
		}

		return ticket;
	}
#2

A ideia de transação é, justamente, para evitar que você comite algo sem que tudo esteja 100% adequado. Isso garante a integridade dos dados armazenados no banco de dados.

#3

Mas é exatamente esse o problema.
Caso no meio do processo alguma coisa aconteça a conexão com o banco não é fechada pois ja foi aberta no inicio do método. Não existe uma forma de falar “olha respeite esse saveAndflush e faça ele independente se der merda?”… Ou “Se der merda fecha essa conexão com o banco, não deixe aberta”… algo assim… pq estou tendo problemas de lock no banco… quando da problema em um método o pool de conexão fica aberto… até que encavale todos e a aplicação trave.
Eu fiz uma solução aqui para acabar com o problema… separei o código do método em 2 metodos…
Mas ambos ficaram transactional o que pode acabar dando merda…

#4

Olha to vendo que isso ai é JPA, provavelmente com hibernate, faz um bom tempo que não mexo com isso, mas ocê poderia adicionar um try catch onde pode acontecer alguma exception(exception não checada), dai é so fechar a conexão no catch e se o jpa não da o rollback, não lembro se o @transaction ja faz, faça manualmente dentro do catch também, já tentou isso?

#5

Fabioreis1415 obrigado pela dica!
O problema é o seguinte, eu gostaria que ele respeitasse os saveAndflush dos outros métodos que são chamados dentro desse, e fizesse o comitt neles…independente se der algum pau durante a execução do método principal…
Tem alguma anotação tipo “olha independente do que acontecer salva essa pichorra e respeite os saveandflush” rsrsr ?

Obrigado!

#6

Pra ter total controle, faça programaticamente. Anotações são engessadas ou vai perder mais tempo resolvendo problemas de configuração do que programando.

Exemplo do básico, mas pode fazer respeitando a “pichorra” que quiser:

  UserTransaction transacao = entityManager.getTransaction();    
  try {
      transacao.begin();
      suaRotina();   
      transacao.commit();
  } catch(Exception ex) {
      transacao.rollback();
      throw ex;
  }

Além disso, use o try/finally para garantir que a conexão será fechada (try… finally… entityManager.close()).

#7

Está fazendo o gerenciamento das transações manualmente? Se sim, é tua obrigação forçar o fechamento da conexão no finally.
Caso não, teoricamente, a conexão deve ser fechada, independente de haver sucesso ou não.