Como eu posso otimizar a seguinte rotina.
AnaliseItem analiseItem = AnaliseItemHelper.criarAnaliseItem(
itemAtual, analiseContratada);
Meu problema que esta demorando demais na rotina acima, demora aproximadamente 8 segundos para ler todo o registro do “FOR”, pois na rotina acima
ele entra em muito metodos e gostaria de otimizar isso para melhorar a performace.
Estou desenvolvendo uma view, mas gostaria de desenvolver uma unica view para executar antes do for e dentro do for, pois tenho chaves estrangeiras o
suficiente, consegui fazer isso mas o meu problema esta no ANALISEITEM, da minha rotina.
ALGUEM PODE ME DAR UMA LUZ ???
Set<Analise> analisesConsultadas = analiseService
.buscarAnalisesPadraoPorMatriz(matriz);
1º Passo Executa o select abaixo
public class AnaliseServiceBean implements AnaliseServiceLocal {
public Set buscarAnalisesPadraoPorMatriz(Matriz matriz) {
StringBuffer jpql = new StringBuffer();
jpql.append("select a ");
jpql.append("from Analise a ");
jpql.append("where a.padrao = true “);
jpql.append(” and a.matriz = :matriz ");
Query query = em.createQuery(jpql.toString());
query.setParameter("matriz", matriz);
query.setHint("org.hibernate.cacheable", true);
Set<Analise> analises = new HashSet<Analise>(query.getResultList());
return analises;
}
2º Passo irá ler o FOR
for (Analise analise : analisesConsultadas) {
AnaliseContratada analiseContratada = new AnaliseContratada(analise);
AnaliseItem analiseItem = AnaliseItemHelper.criarAnaliseItem(
itemAtual, analiseContratada);
this.todasAnalises.add(analiseItem);
}
ANEXOS :
***************************************************************************************AnaliseContratada
package br.com.cqa.lims.analise;
@Entity
@Domain( { "Analise", "Orcamento", "ExecucaoAnalise" })
public class AnaliseContratada extends Entidade {
private static final long serialVersionUID = -4124578908606135742L;
@OneToOne(fetch = FetchType.EAGER)
private Analise analise;
@OneToOne(fetch = FetchType.EAGER)
private Unidade unidade;
@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
private List<ExecucaoAnalise> execucoes = new ArrayList<ExecucaoAnalise>();
/**
* Especificacoes que esta analise esta seguindo
*/
@ManyToMany
private List<AnaliseEspecificada> analisesEspecificadas = new ArrayList<AnaliseEspecificada>();
protected AnaliseContratada() {
}
public AnaliseContratada(Analise analise) {
this(analise, analise.getUnidadePadrao());
}
public AnaliseContratada(Analise analise, Unidade unidade) {
this.analise = analise;
this.unidade = unidade;
}
public boolean especificadaPor(AnaliseEspecificada analiseEspecificada) {
return this.analisesEspecificadas.contains(analiseEspecificada);
}
public void removerEspecificacao(AnaliseEspecificada analiseEspecificada) {
this.analisesEspecificadas.remove(analiseEspecificada);
}
public List<AnaliseEspecificada> getAnalisesEspecificadas() {
return analisesEspecificadas;
}
public AnaliseEspecificada getPrimeiraAnaliseEspecificada() {
if (this.analisesEspecificadas.size() == 0) {
return null;
}
return this.analisesEspecificadas.get(0);
}
public void adicionarEspecificacao(AnaliseEspecificada analiseEspecificada) {
if (!analisesEspecificadas.contains(analiseEspecificada)) {
this.analisesEspecificadas.add(analiseEspecificada);
}
}
public boolean isEspecificada() {
return !this.analisesEspecificadas.isEmpty();
}
public List<ExecucaoAnalise> getExecucoes() {
return execucoes;
}
public void setExecucoes(List<ExecucaoAnalise> resultados) {
this.execucoes = resultados;
}
public boolean isExecucaoAprovada(Amostra amostra) {
ExecucaoAnalise execucao = this.getExecucao(amostra);
return execucao == null || execucao.isResultadoAprovado();
}
public ExecucaoAnalise getExecucao(Amostra amostra) {
for (ExecucaoAnalise execucaoAnalise : execucoes) {
if (execucaoAnalise.getAmostra().equals(amostra)) {
return execucaoAnalise;
}
}
return null;
}
public ExecucaoAnalise criarExecucao(Amostra amostra) {
ExecucaoAnalise execucaoAnalise = new ExecucaoAnalise(this, amostra);
return execucaoAnalise;
}
public void adicionaExecucao(ExecucaoAnalise execucaoAnalise) {
this.execucoes.add(execucaoAnalise);
}
public boolean possuePeloMenosUmEnsaioComExecucaoIniciada() {
for (ExecucaoAnalise execucaoAnalise : this.execucoes) {
if (execucaoAnalise.isIniciada()) {
return true;
}
}
return false;
}
public void voltarExecucoesParaAprovacao() {
for (ExecucaoAnalise execucaoAnalise : execucoes) {
if (execucaoAnalise.isResultadoAprovado()) {
execucaoAnalise.voltarParaAprovacao();
}
}
}
public Unidade getUnidade() {
return unidade;
}
public void setUnidade(Unidade unidade) {
this.unidade = unidade;
}
public void accept(Visitor<AnaliseContratada> visitor) {
visitor.visit(this);
}
public void setAnalisesEspecificadas(
List<AnaliseEspecificada> analisesEspecificadas) {
this.analisesEspecificadas = analisesEspecificadas;
}
public boolean isConcorrente(AnaliseContratada outra) {
return this.analise.equals(outra.analise)
&& this.unidade.equals(outra.unidade);
}
/**
* Delega a obtenção do
* {@link br.com.cqa.lims.funcionario.Departamento} para a
* {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getDepartamento()
*/
public Departamento getDepartamento() {
return this.analise.getDepartamento();
}
/**
* Delega a obtenção do {@link br.com.cqa.lims.analise.Ensaio}
* para a {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getEnsaio()
*/
public Ensaio getEnsaio() {
return this.analise.getEnsaio();
}
public List<Especificacao> getEspecificacoes() {
Set<Especificacao> especificacoes = new HashSet<Especificacao>();
for (AnaliseEspecificada analiseEspecificada : analisesEspecificadas) {
especificacoes.add(analiseEspecificada.getEspecificacao());
}
return new ArrayList<Especificacao>(especificacoes);
}
/**
* Delega a obtenção da informação de <i>LD</i>
* para a {@link br.com.cqa.lims.analise.Analise} encapsulada e aplica o
* conversão de unidades
*
* @return {@link I18NBigDecimal} gerado a partir do <i>LD</i> convertido na
* unidade contratada
*
* @throws LimsRuntimeException
* caso haja erro de conversão de unidades (gerada por um
* {@link ConversaoInvalidaException})
*
* @see br.com.cqa.lims.analise.Analise#getLd()
*/
public I18NBigDecimal getLd() throws LimsRuntimeException {
if (this.analise.getLd() == null) {
return null;
}
if (!this.analise.getUnidadePadrao().isConversivel(this.unidade)) {
return analise.getLd();
}
try {
ValorUnidade valor = new ValorUnidade(
(UnidadeQuantitativa) this.analise.getUnidadePadrao(),
this.analise.getLd());
return valor.getValorConvertido((UnidadeQuantitativa) this.unidade);
} catch (ConversaoInvalidaException e) {
return analise.getLd();
}
}
/**
* Delega a obtenção da informação de <i>LQ</i>
* para a {@link br.com.cqa.lims.analise.Analise} encapsulada e aplica o
* conversão de unidades
*
* @return {@link I18NBigDecimal} gerado a partir do <i>LQ</i> convertido na
* unidade contratada
*
* @throws LimsRuntimeException
* caso haja erro de conversão de unidades (gerada por um
* {@link ConversaoInvalidaException})
*
* @see br.com.cqa.lims.analise.Analise#getLq()
*/
public I18NBigDecimal getLq() throws LimsRuntimeException {
if (this.analise.getLq() == null) {
return null;
}
if (!this.analise.getUnidadePadrao().isConversivel(this.unidade)) {
return analise.getLq();
}
try {
ValorUnidade valor = new ValorUnidade(
(UnidadeQuantitativa) this.analise.getUnidadePadrao(),
this.analise.getLq());
return valor.getValorConvertido((UnidadeQuantitativa) this.unidade);
} catch (ConversaoInvalidaException e) {
return this.analise.getLq();
}
}
/**
* Delega a obtenção do {@link br.com.cqa.lims.analise.Matriz}
* para a {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getMatriz()
*/
public Matriz getMatriz() {
return this.analise.getMatriz();
}
/**
* Delega a obtenção do {@link br.com.cqa.lims.analise.Metodo}
* para a {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getMetodo()
*/
public Metodo getMetodo() {
return this.analise.getMetodo();
}
/**
* Delega a obtenção da informação de prazo para
* a {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getPrazo()
*/
public int getPrazo() {
return this.analise.getPrazo();
}
/**
* Delega a obtenção da informação de
* preço para a {@link br.com.cqa.lims.analise.Analise} encapsulada
*
* @see br.com.cqa.lims.analise.Analise#getPreco()
*/
public Dinheiro getPreco() {
return this.analise.getPreco();
}
public AnaliseContratada clone() {
AnaliseContratada result = new AnaliseContratada();
result.setAnalise(this.analise);
result.setUnidade(this.unidade);
return result;
}
/**
* @deprecated Este método deveria ser <b><code>protected</code></b>.<br>
* É utilizado em alguns testes. <b>NÃO deve ser
* mais utilizado.</b>
*/
public Analise getAnalise() {
return analise;
}
protected void setAnalise(Analise analise) {
this.analise = analise;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((analise == null) ? 0 : analise.hashCode());
result = prime * result + ((unidade == null) ? 0 : unidade.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
AnaliseContratada other = (AnaliseContratada) obj;
if (id != null && other.id != null) {
return id.equals(other.id);
} else {
if (analise == null) {
if (other.analise != null)
return false;
} else if (!analise.equals(other.analise))
return false;
if (unidade == null) {
if (other.unidade != null)
return false;
} else if (!unidade.equals(other.unidade))
return false;
return true;
}
}
}
***************************************************************************************AnaliseContratada
***************************************************************************************AnaliseItemHelper
public class AnaliseItemHelper {
public static AnaliseItem criarAnaliseItem(ItemOrcamento itemOrcamento,
AnaliseContratada analiseContratada) {
return new AnaliseItem(analiseContratada, itemOrcamento, getService()
.buscarMetodosPorEnsaioMatriz(analiseContratada.getEnsaio(),
analiseContratada.getMatriz()));
}
private static ImportadorServiceLocal getService() {
ServiceLocator sl = new ServiceLocator();
return sl.lookup("ImportadorServiceBean/local",
ImportadorServiceBean.class);
}
***************************************************************************************AnaliseItemHelper
***************************************************************************************ImportadorServiceBean
public class ImportadorServiceBean implements ImportadorServiceLocal {
public Set<Metodo> buscarMetodosPorEnsaioMatriz(Ensaio ensaio, Matriz matriz) {
StringBuilder jpql = new StringBuilder("select a.metodo ");
jpql.append("from Analise a ");
jpql.append("where a.ensaio = :ensaio ");
jpql.append("and a.matriz = :matriz ");
Query query = em.createQuery(jpql.toString());
query.setParameter("ensaio", ensaio);
query.setParameter("matriz", matriz);
return new HashSet<Metodo>(query.getResultList());
}
***************************************************************************************ImportadorServiceBean
***************************************************************************************AnaliseItem
public class AnaliseItem {
private static final long serialVersionUID = 5789179660536189585L;
private AnaliseContratada analiseContratada;
private boolean ensaiosAlocados;
private boolean selecionado;
private ItemOrcamento itemOrcamento;
private Metodo metodoLocal;
private Metodo metodoDefinido;
private Set<Metodo> metodosDisponiveis;
private List<AnaliseEspecificada> analisesEspecificadas = new ArrayList<AnaliseEspecificada>();
AnaliseItem(AnaliseContratada analiseContratada,
ItemOrcamento itemOrcamento, Set<Metodo> metodosDisponiveis) {
this.itemOrcamento = itemOrcamento;
this.analiseContratada = analiseContratada;
this.metodosDisponiveis = metodosDisponiveis;
}
***************************************************************************************AnaliseItem