Campo versão errado e cotação com muitos registros demorando muito para finalizar, mais de 10 minutos

guilhermebhte · Agosto 1, 2022, 11:52pm

Model Cotacao

package br.com.ghnetsoft.comprasfood.model;

import static javax.persistence.EnumType.STRING;
import static javax.persistence.GenerationType.IDENTITY;
import static lombok.AccessLevel.PROTECTED;
import static org.hibernate.annotations.CacheConcurrencyStrategy.NONSTRICT_READ_WRITE;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Collection;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Table;

import org.hibernate.annotations.BatchSize;
import org.hibernate.annotations.Cache;

import br.com.ghnetsoft.comprasfood.model.enuns.StatusCotacaoEnum;
import br.com.ghnetsoft.principal.auditoria.AuditableBase;
import br.com.ghnetsoft.principal.enuns.SimNaoEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@ToString(of = { "id", "usuario", "funcionario", "loja", "cotacaoTemplate", "numero", "dataValidade", "status", "observacao", "total", "aceitaMarcaSimilar", "centralizar" })
@EqualsAndHashCode(of = "id", callSuper = false)
@Setter
@Getter
@Entity
@Builder
@Table(name = "TAB_COTACAO")
@NoArgsConstructor(access = PROTECTED)
@AllArgsConstructor(access = PROTECTED)
@Cache(usage = NONSTRICT_READ_WRITE)
public class Cotacao extends AuditableBase {

    private static final long serialVersionUID = -1441903328694037862L;
    @Id
    @Column(name = "PK_COTACAO")
    @GeneratedValue(strategy = IDENTITY)
    private Long id;
    @ManyToOne(targetEntity = Usuario.class)
    @JoinColumn(name = "FK_USUARIO")
    private Usuario usuario;
    @ManyToOne(targetEntity = Funcionario.class)
    @JoinColumn(name = "FK_FUNCIONARIO")
    private Funcionario funcionario;
    @ManyToOne(targetEntity = Loja.class)
    @JoinColumn(name = "FK_LOJA")
    private Loja loja;
    @ManyToOne(targetEntity = CotacaoTemplate.class)
    @JoinColumn(name = "FK_COTACAO_TEMPLATE")
    private CotacaoTemplate cotacaoTemplate;
    @Column(name = "NR_NUMERO")
    private Long numero;
    @Column(name = "DT_VALIDADE")
    private LocalDateTime dataValidade;
    @Enumerated(STRING)
    @Column(name = "ST_STATUS_COTACAO")
    private StatusCotacaoEnum status;
    @Column(name = "OB_OBSERVACAO")
    private String observacao;
    @Column(name = "VR_TOTAL")
    private BigDecimal total;
    @Enumerated(STRING)
    @Column(name = "ST_ACEITA_MARCA_SIMILAR")
    private SimNaoEnum aceitaMarcaSimilar;
    @Enumerated(STRING)
    @Column(name = "ST_CENTRALIZAR")
    private SimNaoEnum centralizar;

    @OneToMany(mappedBy = "cotacao", targetEntity = CotacaoItem.class)
    @Cache(usage = NONSTRICT_READ_WRITE)
    @BatchSize(size = 20)
    private Collection<CotacaoItem> cotacoesItens;
    @OneToMany(mappedBy = "cotacao", targetEntity = CotacaoFornecedorUsuario.class)
    @Cache(usage = NONSTRICT_READ_WRITE)
    @BatchSize(size = 20)
    private Collection<CotacaoFornecedorUsuario> cotacoesFornecedoresUsuarios;
}

Classe AuditableBase

package br.com.ghnetsoft.principal.auditoria;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Embedded;
import javax.persistence.EntityListeners;
import javax.persistence.MappedSuperclass;
import javax.persistence.Version;

import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
@MappedSuperclass
@EntityListeners({ Auditor.class })
public abstract class AuditableBase implements Serializable {
private static final long serialVersionUID = 3026068998520990814L;
@Embedded
private Principal metadadoAuditoria = new Principal();
@Version
@Column(name = "NR_VERSAO")
private Integer versao;
}
Classe **Auditor **

package br.com.ghnetsoft.principal.auditoria;

import static br.com.ghnetsoft.principal.enuns.OperacacoBancoLogEnum.ALTERACAO;
import static br.com.ghnetsoft.principal.enuns.OperacacoBancoLogEnum.EXCLUSAO;
import static br.com.ghnetsoft.principal.enuns.OperacacoBancoLogEnum.INCLUSAO;
import static br.com.ghnetsoft.principal.enuns.SituacaoRegistroEnum.EM_EDICAO;
import static br.com.ghnetsoft.principal.enuns.StatusDoRegistroEnum.ATIVO;
import static java.time.LocalDateTime.now;

import java.io.Serializable;
import java.net.InetAddress;
import java.net.UnknownHostException;

import javax.annotation.PreDestroy;
import javax.persistence.PrePersist;
import javax.persistence.PreUpdate;

import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@Slf4j
class Auditor implements Serializable {

    private static final long serialVersionUID = 9110288632011211834L;
    private Principal auditData = new Principal();

    @PrePersist
    public void auditaInclusao(final AuditableBase entidade) {
        auditData.setTipoOperacao(INCLUSAO);
        auditData.setDataHoraCadastro(now());
        auditData.setStatusDoRegistro(ATIVO);
        auditData.setDsSituacao(EM_EDICAO);
        audita(entidade);
    }

    @PreUpdate
    public void auditaAlteracao(final AuditableBase entidade) {
        auditData = entidade.getMetadadoAuditoria();
        auditData.setTipoOperacao(ALTERACAO);
        audita(entidade);
    }

    @PreDestroy
    public void auditaDelete(final AuditableBase entidade) {
        auditData = entidade.getMetadadoAuditoria();
        auditData.setTipoOperacao(EXCLUSAO);
        audita(entidade);
    }

    private void audita(final AuditableBase entidade) {
        try {
            auditData.setDataHoraMovimentacao(now());
            auditData.setIpMovimentacao(InetAddress.getLocalHost().getHostAddress());
            auditData.setLoginMovimentacao(" ");
            log.info("Loga para a classe" + getClass().getName() + " : " + entidade.getClass().getName());
            entidade.setMetadadoAuditoria(auditData);
        } catch (final UnknownHostException e) {
            log.error(e.getLocalizedMessage(), e);
        }
    }
}

Classe Principal

package br.com.ghnetsoft.principal.auditoria;

import static javax.persistence.AccessType.FIELD;
import static javax.persistence.EnumType.STRING;
import static lombok.AccessLevel.PROTECTED;

import java.io.Serializable;
import java.time.LocalDateTime;

import javax.persistence.Access;
import javax.persistence.Column;
import javax.persistence.Embeddable;
import javax.persistence.Enumerated;
import javax.persistence.MappedSuperclass;

import org.springframework.data.annotation.CreatedDate;

import br.com.ghnetsoft.principal.enuns.OperacacoBancoLogEnum;
import br.com.ghnetsoft.principal.enuns.SituacaoRegistroEnum;
import br.com.ghnetsoft.principal.enuns.StatusDoRegistroEnum;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;

@ToString(of = { "dataHoraCadastro", "dataHoraMovimentacao", "loginMovimentacao", "ipMovimentacao", "tipoOperacao", "statusDoRegistro", "dsSituacao" })
@MappedSuperclass
@Getter
@Setter
@Embeddable
@Access(FIELD)
@NoArgsConstructor(access = PROTECTED)
@AllArgsConstructor(access = PROTECTED)
public class Principal implements Serializable {

    private static final long serialVersionUID = -7494237554968808847L;
    @Column(name = "TS_CADASTRO")
    @CreatedDate
    private LocalDateTime dataHoraCadastro;
    @Column(name = "TS_MOVIMENTACAO")
    private LocalDateTime dataHoraMovimentacao;
    @Column(name = "CD_LOGIN_MOVIMENTACAO")
    private String loginMovimentacao;
    @Column(name = "IP_MOVIMENTACAO")
    private String ipMovimentacao;
    @Column(name = "TP_OPERACAO")
    @Enumerated(STRING)
    private OperacacoBancoLogEnum tipoOperacao;
    @Enumerated(STRING)
    @Column(name = "ST_REGISTRO")
    private StatusDoRegistroEnum statusDoRegistro;
    @Enumerated(STRING)
    @Column(name = "ST_SITUACAO")
    private SituacaoRegistroEnum dsSituacao;
}

Para salvar utilizo este metodo

@Transactional
    public boolean inserir(final CotacaoFormDTO dto, final Principal principal) {
        try {
            validar(dto, null);
            Cotacao entidade = Cotacao.builder().build();
            final Usuario usuario = usuarioService.buscarUsuario(Long.parseLong(principal.getName()));
            preencher.preencherModelIncluir(entidade, dto, usuario);
            entidade.setNumero(numeroCotacao(entidade));
            statusCotacao(dto, entidade);
            entidade = salvarEntidade(entidade, dto, principal, null);
            if (funcionalidadeService.buscarFuncionalidadesPorTela(usuario)) {
                insumoLojaFornecedorService.salvarFornecedoresLojaInsumos(dto);
            }
            cotacaoTemplate(entidade, cotacaoTemplate(dto, principal, entidade));
            requisicoes(dto, entidade, principal);
            enviarMensagemService.enviarMensagemSistema(entidade, "Incluiu a cotação de número: ", null, true);
            enviarEmailService.enviarEmail(entidade, entidade.getStatus().getDescricao(), "Inclusão");
            return false;
        } catch (final ResourceAccessException e) {
            log.error(e.getMessage(), e);
            return true;
        }
    }

Só que ele insere e depois vai fazendo updates, mesmo não sendo necessário.

Ai o campo NR_VERSAO fica com um número muito grade que no qual deveria ficar somente com o valor 1, pois ele só insere uma vez em cada tabela.

No console do eclipse, vejo que ele vai fazendo upates sem necessidade.

O que está errado neste código ?

Campo versão errado e cotação com muitos registros demorando muito para finalizar, mais de 10 minutos

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI