Java代码中常见技术债务处理之Exception
Posted zhangmike
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java代码中常见技术债务处理之Exception相关的知识,希望对你有一定的参考价值。
写在前面
异常处理是代码中常见的处理,本文根据SonarQube在异常方面的规则和常见检查结果,选取说明了常见异常处理中的技术债务,提倡技术债务最少的编码方式。
Exception handlers should preserve the original exceptions
Either log or rethrow this exception.
When handling a caught exception, the original exception’s message and stack trace should be logged or passed forward.
NONCOMPLIANT CODE EXAMPLE
// Noncompliant - exception is lost
try /* ... */ catch (Exception e) LOGGER.info("context");
// Noncompliant - exception is lost (only message is preserved)
try /* ... */ catch (Exception e) LOGGER.info(e.getMessage());
// Noncompliant - exception is lost
try /* ... */ catch (Exception e) throw new RuntimeException("context");
COMPLIANT SOLUTION
try /* ... */ catch (Exception e) LOGGER.info(e);
try /* ... */ catch (Exception e) throw new RuntimeException(e);
try
/* ... */
catch (RuntimeException e)
doSomething();
throw e;
catch (Exception e)
// Conversion into unchecked exception is also allowed
throw new RuntimeException(e);
错误实例:
protected int analyzeJobStep1(String jobName)
try
notifyBHandler();
return analyzeJobStep2(jobName)
catch (Exception e)
logger.error(e.getMessage();
return 0;
解决实例:
protected int analyzeJobStep1(String jobName)
int nRet=0;
try
notifyBHandler();
nRet = analyzeJobStep2(jobName);
catch (Exception e)
logger.error("notifyBHandler trigger exception", e);
return nRet;
Don’t directly use Exception and RuntimeException
Sonarrule:Generic exceptions should never be thrown (squid:S00112)
Using such generic exceptions as Error, RuntimeException, Throwable, and Exception prevents calling methods from handling true, system-generated exceptions differently than application-generated errors.
Noncompliant Code Example
public void foo(String bar) throws Throwable // Noncompliant
throw new RuntimeException("My Message"); // Noncompliant
Compliant Solution
public void foo(String bar)
throw new MyOwnRuntimeException("My Message");
Another related rule: Generic exceptions should never be thrown
the below should be avoided.
@Override
public void myMethod() throws Exception ...
Define and throw a dedicated exception instead of using a generic one.
Exceptions should not be thrown in finally blocks
try
/* some work which end up throwing an exception */
throw new IllegalArgumentException();
finally
/* clean up */
throw new RuntimeException(); // Noncompliant; will mask the IllegalArgumentException
Compliant Solution
try
/* some work which end up throwing an exception */
throw new IllegalArgumentException();
finally
/* clean up */ // Compliant
Checked exceptions should not be thrown
The purpose of checked exceptions is to ensure that errors will be dealt with, either by propagating them or by handling them, but some believe that checked exceptions negatively impact the readability of source code, by spreading this error handling/propagation logic everywhere.
This rule verifies that no method throws a new checked exception.
CODE EXAMPLE
public void myMethod1() throws CheckedException
...
throw new CheckedException(message); // Noncompliant
...
throw new IllegalArgumentException(message); // Compliant; IllegalArgumentException is unchecked
Solution Example
public void myMethod2() throws CheckedException // Compliant; propagation allowed
myMethod1();
Public methods should throw at most one checked exception
Using checked exceptions forces method callers to deal with errors, either by propagating them or by handling them. Throwing exceptions makes them fully part of the API of the method.
But to keep the complexity for callers reasonable, methods should not throw more than one kind of checked exception.
NONCOMPLIANT CODE EXAMPLE
public void delete() throws IOException, SQLException // Noncompliant
/* ... */
COMPLIANT SOLUTION
public void delete() throws SomeApplicationLevelException
/* ... */
以上是关于Java代码中常见技术债务处理之Exception的主要内容,如果未能解决你的问题,请参考以下文章