为什么要优雅的处理异常
如果我们不统一的处理异常，经常会在controller层有大量的异常处理的代码， 比如：
@slf4j
@api(value = "user interfaces", tags = "user interfaces")
@restcontroller
@requestmapping("/user")
public class usercontroller {
/**
* http://localhost:8080/user/add .
*
* @param userparam user param
* @return user
*/
@apioperation("add user")
@apiimplicitparam(name = "userparam", type = "body", datatypeclass = userparam.class, required = true)
@postmapping("add")
public responseentity<string> add(@valid @requestbody userparam userparam) {
// 每个接口充斥着大量的异常处理
try {
// do something
} catch(exception e) {
return responseentity.fail("error");
}
return responseentity.ok("success");
}
}
那怎么实现统一的异常处理，特别是结合参数校验等封装？
实现案例
简单展示通过@controlleradvice进行统一异常处理。
@controlleradvice异常统一处理
对于400参数错误异常
/**
* global exception handler.
*/
@slf4j
@restcontrolleradvice
public class globalexceptionhandler {
/**
* exception handler for bad request.
*
* @param e
* exception
* @return responseresult
*/
@responsebody
@responsestatus(code = httpstatus.bad_request)
@exceptionhandler(value = { bindexception.class, validationexception.class, methodargumentnotvalidexception.class })
public responseresult<exceptiondata> handleparameterverificationexception(@nonnull exception e) {
exceptiondata.exceptiondatabuilder exceptiondatabuilder = exceptiondata.builder();
log.warn("exception: {}", e.getmessage());
if (e instanceof bindexception) {
bindingresult bindingresult = ((methodargumentnotvalidexception) e).getbindingresult();
bindingresult.getallerrors().stream().map(defaultmessagesourceresolvable::getdefaultmessage)
.foreach(exceptiondatabuilder::error);
} else if (e instanceof constraintviolationexception) {
if (e.getmessage() != null) {
exceptiondatabuilder.error(e.getmessage());
}
} else {
exceptiondatabuilder.error("invalid parameter");
}
return responseresultentity.fail(exceptiondatabuilder.build(), "invalid parameter");
}
}
对于自定义异常
/**
* handle business exception.
*
* @param businessexception
* business exception
* @return responseresult
*/
@responsebody
@exceptionhandler(businessexception.class)
public responseresult<businessexception> processbusinessexception(businessexception businessexception) {
log.error(businessexception.getlocalizedmessage(), businessexception);
// 这里可以屏蔽掉后台的异常栈信息，直接返回"business error"
return responseresultentity.fail(businessexception, businessexception.getlocalizedmessage());
}
对于其它异常
/**
* handle other exception.
*
* @param exception
* exception
* @return responseresult
*/
@responsebody
@exceptionhandler(exception.class)
public responseresult<exception> processexception(exception exception) {
log.error(exception.getlocalizedmessage(), exception);
// 这里可以屏蔽掉后台的异常栈信息，直接返回"server error"
return responseresultentity.fail(exception, exception.getlocalizedmessage());
}
controller接口
（接口中无需处理异常）
@slf4j
@api(value = "user interfaces", tags = "user interfaces")
@restcontroller
@requestmapping("/user")
public class usercontroller {
/**
* http://localhost:8080/user/add .
*
* @param userparam user param
* @return user
*/
@apioperation("add user")
@apiimplicitparam(name = "userparam", type = "body", datatypeclass = userparam.class, required = true)
@postmapping("add")
public responseentity<userparam> add(@valid @requestbody userparam userparam) {
return responseentity.ok(userparam);
}
}
运行测试
这里用postman测试下:
进一步理解
我们再通过一些问题来帮助你更深入理解
@controlleradvice还可以怎么用？
除了通过@exceptionhandler注解用于全局异常的处理之外，@controlleradvice还有两个用法：
- @initbinder注解
用于请求中注册自定义参数的解析，从而达到自定义请求参数格式的目的；
比如，在@controlleradvice注解的类中添加如下方法，来统一处理日期格式的格式化
@initbinder
public void handleinitbinder(webdatabinder databinder){
databinder.registercustomeditor(date.class,
new customdateeditor(new simpledateformat("yyyy-mm-dd"), false));
}
controller中传入参数（string类型）自动转化为date类型
@getmapping("testdate")
public date processapi(date date) {
return date;
}
- @modelattribute注解
用来预设全局参数，比如最典型的使用spring security时将添加当前登录的用户信息（userdetails)作为参数。
@modelattribute("currentuser")
public userdetails modelattribute() {
return (userdetails) securitycontextholder.getcontext().getauthentication().getprincipal();
}
所有controller类中requestmapping方法都可以直接获取并使用currentuser
@postmapping("savesomething")
public responseentity<string> savesomeobj(@modelattribute("currentuser") userdetails operator) {
// 保存操作，并设置当前操作人员的id（从userdetails中获得）
return responseentity.success("ok");
}
@controlleradvice是如何起作用的（原理）？
dispatcherservlet中onrefresh方法是初始化applicationcontext后的回调方法，它会调用initstrategies方法，主要更新一些servlet需要使用的对象，包括国际化处理，requestmapping，视图解析等等。
/**
* this implementation calls {@link #initstrategies}.
*/
@override
protected void onrefresh(applicationcontext context) {
initstrategies(context);
}
/**
* initialize the strategy objects that this servlet uses.
* <p>may be overridden in subclasses in order to initialize further strategy objects.
*/
protected void initstrategies(applicationcontext context) {
initmultipartresolver(context); // 文件上传
initlocaleresolver(context); // i18n国际化
initthemeresolver(context); // 主题
inithandlermappings(context); // requestmapping
inithandleradapters(context); // adapters
inithandlerexceptionresolvers(context); // 异常处理
initrequesttoviewnametranslator(context);
initviewresolvers(context);
initflashmapmanager(context);
}
从上述代码看，如果要提供@controlleradvice提供的三种注解功能，从设计和实现的角度肯定是实现的代码需要放在initstrategies方法中。
- @modelattribute和@initbinder处理
具体来看，如果你是设计者，很显然容易想到：对于@modelattribute提供的参数预置和@initbinder注解提供的预处理方法应该是放在一个方法中的，因为它们都是在进入requestmapping方法前做的操作。
如下方法是获取所有的handleradapter，无非就是从beanfactory中获取
private void inithandleradapters(applicationcontext context) {
this.handleradapters = null;
if (this.detectallhandleradapters) {
// find all handleradapters in the applicationcontext, including ancestor contexts.
map<string, handleradapter> matchingbeans =
beanfactoryutils.beansoftypeincludingancestors(context, handleradapter.class, true, false);
if (!matchingbeans.isempty()) {
this.handleradapters = new arraylist<>(matchingbeans.values());
// we keep handleradapters in sorted order.
annotationawareordercomparator.sort(this.handleradapters);
}
}
else {
try {
handleradapter ha = context.getbean(handler_adapter_bean_name, handleradapter.class);
this.handleradapters = collections.singletonlist(ha);
}
catch (nosuchbeandefinitionexception ex) {
// ignore, we'll add a default handleradapter later.
}
}
// ensure we have at least some handleradapters, by registering
// default handleradapters if no other adapters are found.
if (this.handleradapters == null) {
this.handleradapters = getdefaultstrategies(context, handleradapter.class);
if (logger.istraceenabled()) {
logger.trace("no handleradapters declared for servlet '" + getservletname() +
"': using default strategies from dispatcherservlet.properties");
}
}
}
我们要处理的是requestmapping的handlerresolver，作为设计者，就很容易出如下的结构
在requestmappinghandleradapter中的afterpropertiesset去处理advice
@override
public void afterpropertiesset() {
// do this first, it may add responsebody advice beans
initcontrolleradvicecache();
if (this.argumentresolvers == null) {
list<handlermethodargumentresolver> resolvers = getdefaultargumentresolvers();
this.argumentresolvers = new handlermethodargumentresolvercomposite().addresolvers(resolvers);
}
if (this.initbinderargumentresolvers == null) {
list<handlermethodargumentresolver> resolvers = getdefaultinitbinderargumentresolvers();
this.initbinderargumentresolvers = new handlermethodargumentresolvercomposite().addresolvers(resolvers);
}
if (this.returnvaluehandlers == null) {
list<handlermethodreturnvaluehandler> handlers = getdefaultreturnvaluehandlers();
this.returnvaluehandlers = new handlermethodreturnvaluehandlercomposite().addhandlers(handlers);
}
}
private void initcontrolleradvicecache() {
if (getapplicationcontext() == null) {
return;
}
list<controlleradvicebean> advicebeans = controlleradvicebean.findannotatedbeans(getapplicationcontext());
list<object> requestresponsebodyadvicebeans = new arraylist<>();
for (controlleradvicebean advicebean : advicebeans) {
class<?> beantype = advicebean.getbeantype();
if (beantype == null) {
throw new illegalstateexception("unresolvable type for controlleradvicebean: " + advicebean);
}
// 缓存所有modelattribute注解方法
set<method> attrmethods = methodintrospector.selectmethods(beantype, model_attribute_methods);
if (!attrmethods.isempty()) {
this.modelattributeadvicecache.put(advicebean, attrmethods);
}
// 缓存所有initbinder注解方法
set<method> bindermethods = methodintrospector.selectmethods(beantype, init_binder_methods);
if (!bindermethods.isempty()) {
this.initbinderadvicecache.put(advicebean, bindermethods);
}
if (requestbodyadvice.class.isassignablefrom(beantype) || responsebodyadvice.class.isassignablefrom(beantype)) {
requestresponsebodyadvicebeans.add(advicebean);
}
}
if (!requestresponsebodyadvicebeans.isempty()) {
this.requestresponsebodyadvice.addall(0, requestresponsebodyadvicebeans);
}
}
- @exceptionhandler处理
@exceptionhandler显然是在上述inithandlerexceptionresolvers(context)方法中。
同样的，从beanfactory中获取handlerexceptionresolver
/**
* initialize the handlerexceptionresolver used by this class.
* <p>if no bean is defined with the given name in the beanfactory for this namespace,
* we default to no exception resolver.
*/
private void inithandlerexceptionresolvers(applicationcontext context) {
this.handlerexceptionresolvers = null;
if (this.detectallhandlerexceptionresolvers) {
// find all handlerexceptionresolvers in the applicationcontext, including ancestor contexts.
map<string, handlerexceptionresolver> matchingbeans = beanfactoryutils
.beansoftypeincludingancestors(context, handlerexceptionresolver.class, true, false);
if (!matchingbeans.isempty()) {
this.handlerexceptionresolvers = new arraylist<>(matchingbeans.values());
// we keep handlerexceptionresolvers in sorted order.
annotationawareordercomparator.sort(this.handlerexceptionresolvers);
}
}
else {
try {
handlerexceptionresolver her =
context.getbean(handler_exception_resolver_bean_name, handlerexceptionresolver.class);
this.handlerexceptionresolvers = collections.singletonlist(her);
}
catch (nosuchbeandefinitionexception ex) {
// ignore, no handlerexceptionresolver is fine too.
}
}
// ensure we have at least some handlerexceptionresolvers, by registering
// default handlerexceptionresolvers if no other resolvers are found.
if (this.handlerexceptionresolvers == null) {
this.handlerexceptionresolvers = getdefaultstrategies(context, handlerexceptionresolver.class);
if (logger.istraceenabled()) {
logger.trace("no handlerexceptionresolvers declared in servlet '" + getservletname() +
"': using default strategies from dispatcherservlet.properties");
}
}
}
我们很容易找到exceptionhandlerexceptionresolver
同样的在afterpropertiesset去处理advice
@override
public void afterpropertiesset() {
// do this first, it may add responsebodyadvice beans
initexceptionhandleradvicecache();
if (this.argumentresolvers == null) {
list<handlermethodargumentresolver> resolvers = getdefaultargumentresolvers();
this.argumentresolvers = new handlermethodargumentresolvercomposite().addresolvers(resolvers);
}
if (this.returnvaluehandlers == null) {
list<handlermethodreturnvaluehandler> handlers = getdefaultreturnvaluehandlers();
this.returnvaluehandlers = new handlermethodreturnvaluehandlercomposite().addhandlers(handlers);
}
}
private void initexceptionhandleradvicecache() {
if (getapplicationcontext() == null) {
return;
}
list<controlleradvicebean> advicebeans = controlleradvicebean.findannotatedbeans(getapplicationcontext());
for (controlleradvicebean advicebean : advicebeans) {
class<?> beantype = advicebean.getbeantype();
if (beantype == null) {
throw new illegalstateexception("unresolvable type for controlleradvicebean: " + advicebean);
}
exceptionhandlermethodresolver resolver = new exceptionhandlermethodresolver(beantype);
if (resolver.hasexceptionmappings()) {
this.exceptionhandleradvicecache.put(advicebean, resolver);
}
if (responsebodyadvice.class.isassignablefrom(beantype)) {
this.responsebodyadvice.add(advicebean);
}
}
}
到此这篇关于springboot接口如何统一异常处理的文章就介绍到这了,更多相关springboot接口 异常处理内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
