Esta é uma pergunta simples Java 8+, há estruturas utilizadas.
Estamos produzindo uma API para uma camada superior que lida com a camada de apresentação, entre outras atividades. Temos e interface de acordado com o solicitante, por isso são felizes em receber algumas exceções específicas que jogamos.
Ao mesmo tempo, também estamos usando outras APIs sob o mesmo acordo, para que possamos fazer coisas por nós mesmos e lançar exceções ou podemos invocar outras APIs que lançam exceções acordadas. Atualmente, nós não fazemos nada com as exceções lançadas pelas APIs estamos invocando.
Coisa é, nós somos a melhor posicionada nesta infra-estrutura para lidar com atividades intermediários, enquanto exceções são lançadas, por isso precisamos de capturar ambos, nossos exceções e as excepções previstas por aqueles que estão invocando; basicamente relatar o problema, aumentando os controles do sistema, etc, e então re-lançar a exceção original, de modo que a camada superior mantém como é agora.
Temos cerca de 300 métodos na classe ponto de entrada do nosso API:
public void method1 (arguments for method 1) {
...
}
...
public void method300 (arguments for method 300) {
...
}
Eu entendo claramente que eu posso criar um método para centralizar as ações a serem tomadas na gestão exceção, algo como:
public void myExceptionHandler (Exception e) {
if (e instanceOf X) {
} else if ...
...
throw particularExceptionAccordingTheCase
}
Mas eu também gostaria de evitar modificar esses 300 métodos.
Alguma idéia de como injetar um try-catch naqueles 300 métodos para enviar a Exceção à myExceptionHandler sem realmente adicionar um try-catch em cada um deles?
Quaisquer comentários e idéias são muito apreciados!
----------- Após sugestão mprev0 -------------------------------
Eu tentei esta abordagem. É realmente captura a exceção e assim por diante, mas não posso re-trow uma exceção: Eu sou obrigado a pegá-lo, mas isso vai contra a exigência de re-envio de parte de trás exceção à camada superior. Embora eu possa lançar um erro, eu tenho um erro do compilador na linha throw new FileNotFoundException ();
public class myExceptionHandler implements Thread.UncaughtExceptionHandler {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("gotcha!");
if (e instanceof java.lang.Error) {
System.out.println("AAT-CORE: Fatal Error");
throw new java.lang.Error(e.getCause());
} else if (e instanceof java.lang.Exception) {
System.out.println("AAT-CORE: Exception Error");
throw new FileNotFoundException();
}
}
}
Alguma ideia?
------------ Depois de mais algumas escavações, fixado com um padrão decorador -------
implementação da classe anterior não trabalho, como eu não pode alterar a assinatura do método e eu preciso re-lançar o java.lang.Exception.
Usando um decorador e manipulação da interface não faz o truque. Como um resumo:
classe camada superior:
public class TopLayer {
public static void main (String[] args) {
MiddleLayer m = new MiddleLayer();
m.method1();
}
}
classe camada inferior contém APIs específicos e alguns implementação, a única coisa interessante é que ele contém java.lang.Exceptions descontrolada, esperando a camada superior para fazer este trabalho. Mas, estamos trabalhando no meio e vamos fazer este trabalho:
public class MiddleLayer extends BottomLayer {
public MiddleLayer () {
final UncaughtExceptionHandler subclass = Thread.currentThread().getUncaughtExceptionHandler();
Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread thread, Throwable ex) {
System.out.println("gotcha2!");
// carry on with prior flow
subclass.uncaughtException(thread, ex);
}
});
}
}
Desta forma, eu posso obter o system.out eo java.lang.Exception é propagada para a camada superior.
Decorator inspiração veio a partir daqui: Rethrow UncaughtExceptionHandler Exceção após registrá-lo
Comentários adicionais são bem-vindos!
Como você pode ver nas atualizações de interrogação, a solução final é uma combinação de duas abordagens diferentes, de um lado, tendo a abordagem mprev0 de implementar a java.lang.Thread.UncaughtExceptionHandler e, em cima disso, a adição de um padrão Decoração para ser capaz de re-lançar uma exceção em tempo de execução.
Não houve abordagens adicionais, até agora, então eu vou fechar a questão e trazer isso como a resposta mais completa.
Mais informações sobre UncaughtExceptionHandler podem ser encontradas na documentação do Java, mas como sempre, é curto em exemplos, e aqui: exceção avançada manipulação Exemplo Thread.UncaughtExceptionHandler
Mais informações sobre o uso do padrão Decorator, pode ser encontrada aqui: Decorator Design Pattern em Java Design Patterns - padrão Decorator
E como usar para manipular exceções aqui: Rethrow UncaughtExceptionHandler Exceção após registrá-lo