Este artigo estuda principalmente a explicação detalhada dos exemplos de mecanismo de tentativa de tentativa de programação Java e exemplos de código relevantes compartilhados. O editor acha que é muito bom e tem certo valor de referência. Amigos que precisam podem se referir a ele.
Uma função precisa ser implementada no aplicativo: os dados precisam ser carregados no serviço de armazenamento remoto e outras operações são executadas quando o processamento de retorno é bem -sucedido. Esta função não é complicada e é dividida em duas etapas: a primeira etapa é chamar o invólucro da lógica do serviço Remote Rest para retornar o resultado do processamento ao método de processamento; O segundo passo é obter o resultado da primeira etapa ou pegar a exceção. Se ocorrer um erro ou exceção, a lógica de upload será repetida, caso contrário, a operação lógica será continuada.
Com base na lógica normal de upload, a lógica da função é executada julgando se o resultado de retorno ou ouvindo a decisão de exceção está novamente novamente. Ao mesmo tempo, para resolver a execução inválida da tentativa imediata (assumindo que a exceção seja causada pela instabilidade de execução externa), a lógica da função é reexecução por um certo tempo de atraso.
public void Commonretry (map <string, object> datamap) lança interruptedException {map <string, object> parammap = maps.newhashmap (); parammap.put ("tablename", "criativeable"); parammap.put ("DS", "20160220"); parammap.put ("datamap", datamap); resultado booleano = false; tente {resultado = uploadToodps (parammap); if (! resultado) {thread.sleep (1000); uploadToodps (parammap); // tente uma vez}} catch (Exceção e) {thread.sleep (1000); uploadToodps (parammap); // tente uma vez}}A solução acima ainda pode ser inválida para tentar novamente. Para resolver esse problema, tente aumentar a contagem de repetições e o intervalo de tentativa de repetir o intervalo para alcançar a possibilidade de aumentar a tentativa válida.
public void Commonretry (map <string, object> datamap) lança interruptedException {map <string, object> parammap = maps.newhashmap (); parammap.put ("tablename", "criativeable"); parammap.put ("DS", "20160220"); parammap.put ("datamap", datamap); resultado booleano = false; tente {resultado = uploadToodps (parammap); if (! Result) {reuploadToodps (parammap, 1000l, 10); // atrasa a tentativa múltipla}} catch (Exceção e) {reuploadToodps (parammap, 1000l, 10); // atrasar a tentativa múltipla}}}Há um problema com a solução 1 e a solução 2: A lógica normal e a lógica de tentativa são fortemente acopladas. A lógica da tentativa depende muito dos resultados da execução da lógica normal e dos gatilhos passivos da tentativa para os resultados esperados da lógica normal. A causa raiz da tentativa é frequentemente sobrecarregada pela lógica complexa, o que pode levar a uma compreensão inconsistente de quais problemas resolver para operações e manutenção subsequentes. É difícil garantir a tentativa e não é propício à operação e manutenção, porque a repetição do design depende de exceções lógicas normais ou de nova elogios da conjectura.
Então, existe uma solução que pode ser usada para dissociar a lógica normal e a lógica de repetição e, ao mesmo tempo, ela pode dar à lógica uma solução padronizada? A resposta é: ou seja, uma ferramenta de tentativa baseada no padrão de design do agente. Tentamos usar a ferramenta correspondente para reconstruir o cenário acima.
A definição específica do padrão de design de comando não é explicada. O principal motivo é que o padrão de comando pode preencher a lógica de operação da interface executando o objeto e, ao mesmo tempo, o encapsulamento interno da lógica de tentativa não é exposto aos detalhes da implementação. Para o chamador, é a execução da lógica normal e atinge o objetivo de desacoplar. Consulte a implementação da função específica. (Estrutura do diagrama de aula)
A iretria concorda com a interface de upload e repetição, que implementa a lógica do upload do ODPS do tipo OdPSRetry e encapsula o mecanismo de tentativa e a estratégia de tentativa ao mesmo tempo. Ao mesmo tempo, use o método de recuperação para executar a operação de recuperação no final.
Nosso LogicClient do nosso chamador não precisa prestar atenção à tentativa. Ele implementa a função da interface da convenção através da tentativa da tentativa. Ao mesmo tempo, a apresentadora precisa responder e processar a lógica da tentativa. O processamento de tentativa específico da tentativa é entregue à classe de implementação da interface da interface real ODPSRETRY. Ao adotar o modo de comando, a lógica normal e a lógica de nova tentativa são separadas elegantemente e, ao mesmo tempo, a lógica normal e a lógica de tentativa são separadas pela construção do papel dos retalhos, de modo que a tentativa tem melhor escalabilidade.
A troca de primavera é um kit de ferramentas de código aberto, atualmente disponível versão 1.1.2.. Ao mesmo tempo, tente novamente a instância de execução para garantir a segurança do thread. Os exemplos de operação específicos são os seguintes:
upload public void (mapa final <string, object> map) lança a exceção {// construir um modelo de tentativa de repetição, retratemplate reprerytemplate = new RETRYTEMPLATE (); // Defina a política de nova tentativa, defina principalmente o número de tentativas simples da política da Policy = new SimpleretryPolicy (3, coleções. // Defina a política de operação de Fallback de nova tentativa, defina principalmente o intervalo de tentativa de fixação fixoffpolicy fixerbackoffpolicy = new FelletBackOffpolicy (); flortbackoffpolicy.setbackoffperiod (100); RETRYTEMPLATE.SETRRETRYPOLICY (POLÍTICA); RETRYTEMPLATE.SETBACKOFFPOLICY (FELLBACKOFFPOLICY); // RETRYCALLBACK RETY A instância de retorno de chamada para enrolar a lógica normal, a primeira execução e a execução da tentativa são toda essa lógica Final RETRYCALLBACK <Object, excepção> RETRYCALLBACK = RETRYCALLBACK <) OCKECTION (Exception> () {// RetryContext Retry O contexto da operação, UNIFIXA SPRING-TRY OBJETO PÚBLICO DOW DOW System.out.println ("Faça algo"); Exceção e = uploadToodps (mapa); System.out.println (context.getRetRyCount ()); Jogue e; // preste atenção especial a este ponto. A raiz da tentativa é retornada através da exceção}}; // Recuperar o processo de tentativa normalmente termina ou atinge o limite superior da tentativa. Final recuperyCallback <ject> recuperyCallback = new Recoverycallback <ject> () {public objeto recuperação (contexto de rerincyContext) lança a exceção {System.out.println ("Operação de recuperação"); retornar nulo; }}; tente {// Execute o método Execute by RetryTemplate para iniciar a execução lógica do RETRYTEMPLATE.EXECUTE (RETRYCALLBACK, RECECOUCALLBACK); } catch (Exceção e) {e.printStackTrace (); }}Depois de analisar o código do caso, o RETRYTEMPLAT assume a função do executor de repetição. Ele pode definir o SimpleRetryPolicy (política de nova tentativa, definir o limite superior da tentativa, a entidade radicular da tentativa), o FeltBackOffPolicy (política de fallback fixa, definir o intervalo de tempo para retratar fallback). O RETRYTEMPLATE executa operações por meio de execução, e duas instâncias de classe, RETRYCALLBACK e RECOBERCALLBACK, são necessárias para preparar duas instâncias de classe. O primeiro corresponde à instância da lógica de retorno de chamada da tentativa e envolve operações funcionais normais. Recoverycallback implementa a instância de operação de recuperação no final de toda a operação de execução.
A execução do RETRYTEMPLATE é segura por threads, e a lógica de implementação usa Threadlocal para salvar o contexto de execução do RERYCONTEXT de cada instância de execução.
Embora a ferramenta de retrização de primavera possa implementar elegantemente a tentativa, existem dois designs hostis: um é que a entidade de nova tentativa é limitada à subclasse jogável, indicando que a tentativa é destinada a exceções funcionais rápidas como a premissa de design, mas queremos confiar na entidade de um objeto de dados, como a entidade de retirada, mas a estrutura de mola deve ser fundida para ser fundida para a entrada de objeto de dados, mas a estrutura de régua, mas a estrutura de mola deve ser fundida para a entrada de dados, como a entrada Outra é o objeto de asserção que reformula a causa raiz usa a instância de exceção de exceção do Dowithretry, que não está em conformidade com o design de retorno de afirmações internas normais.
Os defensores da repetição da primavera de repetição de métodos de repetição na anotação. A lógica da tentativa é executada de maneira síncrona. A "falha" da tentativa é direcionada para arremesso. Se você deseja determinar se precisa tentar novamente com base em um determinado estado do valor de retorno, poderá apenas julgar o valor de retorno e depois lançar explicitamente uma exceção.
Abstração da primavera para tentar novamente
"Resumo" é uma qualidade necessária para todos os programadores. Para mim, com qualificações medíocres, não há melhor maneira de melhorar do que imitar e entender excelentes códigos de origem. Para fazer isso, reescrevo sua lógica principal ... Vamos dar uma olhada na abstração da Spring Rety para "repetir".
Spring Rety Related Interface.jpg
A ferramenta de repetição de goiaba é semelhante à retração da mola. Ele envolve a tentativa lógica normal, definindo o papel da apresentadora. No entanto, a tentativa de goiaba tem uma melhor definição de política. Com base no suporte ao número de tempos de tentativa e controle de frequência de tentativa, ele pode ser compatível com a definição de fonte de tentativa que suporta várias exceções ou objetos de entidade personalizada, dando mais flexibilidade à função de tentativa. A apresentadora de goiaba também é segura por threads. A lógica de chamada de entrada usa o método de chamada de java.util.concurrent.callable. O código de amostra é o seguinte:
Public void uploadodps (mapa final <string, objeto> map) {// RetentBuilder Construa um removedor de instâncias de tentação de retrato, você pode definir a fonte de retrato e suportar várias fontes de tentação de repetição. .retryifexception () .// Defina a exceção Repetir a fonte de fonte RETYIFRESULT (novo predicado <iOolean> () {// Definir fonte de tentativa de segmento personalizado, @Override public boolean Aplicar (estado booleano) {// Nota especial: Aplicar o retorno verdadeiro, o que significa que a retomada precisa ser diferenciada da semântica da lógica da operação. .WithStopStrategy (stopstrategies.stopafterattempt (5)) // Defina a tentativa 5 vezes, e você também pode definir o tempo de tempo limite da tentativa.withwaitstrategy (waitstrategies.fixedwait (100l de call, usa o MetodUnit.millisEcnds). java.util.Concurrent.Callable <V>, então a execução é o resultado booleano-seguro de rosca = retomador.Call (novo Callable <Boolean> () {@Override public boolean Call () lança a exceção {Try {// Special Note: Return Falses não requer a declaração, a declaração verdadeira precisa para continuar a retomar. Exceção (e);}}}); } catch (ExecutionException e) {} Catch (RETYEXCECCECTION EX) {}}Análise de princípios do código de exemplo:
O recipiente de repetição é um criador de fábrica que pode personalizar a fonte de nova tentativa e pode suportar várias fontes de tentativa, pode configurar o número de tempos de repetição ou o tempo limite de nova tentativa e pode configurar o intervalo de tempo de espera para criar uma instância de recorrente.
A fonte de tentativa de repetir objetos de exceção de exceção e objetos de asserção personalizada e é definida por meio de RETRYIVEXCECCECTION e RETYIFRESULT, ele suporta múltiplas e é compatível ao mesmo tempo.
O tempo de espera e a configuração do limite de tentativa do recipiente são implementados usando diferentes classes de políticas, e os recursos de tempo de espera podem suportar modos de intervalo uninterval e fixo.
A Repositora é uma instância do Repositório, que executa a lógica de operação através do método de chamada e encapsula a operação da fonte de repetição.
Elegante Commonalidade e Princípio
Representar e tentar, elegantemente desacoplado, novamente, novamente afirmando que instâncias condicionais ou instâncias de exceção lógica são os meios para a comunicação entre os dois.
Concorde com intervalos de nova tentativa, estratégias diferenciais de repetição e defina o tempo de repetição do tempo limite para garantir ainda mais a eficácia da tentativa e a estabilidade do processo de repetição.
Todos usam o padrão de design de comando, e as operações lógicas correspondentes são concluídas pela delegação do objeto de repetição, e a lógica de tentativa é implementada internamente.
As ferramentas Spring-Tra-Ter e Guava-Tra-Ters são uma nova tentativa de linha e podem suportar a correção da lógica de repetição em cenários de negócios simultâneos.
Cenários aplicáveis para tentar novamente graciosamente
Existem cenários instáveis de dependência na lógica funcional e é necessário usar a nova tentativa para obter o resultado esperado ou tentar reexecionar a lógica sem terminar imediatamente. Por exemplo, acesso à interface remota, acesso a carga de dados, verificação de upload de dados, etc.
Existem cenários que precisam ser repetidos para cenários de exceção e, ao mesmo tempo, espera -se que a lógica normal e a lógica da tentativa.
Para interações baseadas em mídia de dados, os esquemas de nova tentativa também podem ser considerados em cenários que exigem que as pesquisas de nova tentativa detectem a lógica de execução.
O exposto acima é toda a explicação detalhada do exemplo do mecanismo de tentativa de repetição de programação Java. Espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!