illegal是什么意思egal的用法读音典

illegalargumentexception是什么异常_实战统⼀异常处理介绍

及实战

背景

软件开发过程中，不可避免的是需要处理各种异常，就我⾃⼰来说，⾄少有⼀半以上的时间都是在处理各种异常情况，所以代码中就会出现

⼤量的try{...}catch{...}finally{...}代码块，不仅有⼤量的冗余代码，⽽且还影响代码的可读性。

⽐较下⾯两张图，看看您现在编写的代码属于哪⼀种风格？然后哪种编码风格您更喜欢？

丑陋的trycatch代码块

优雅的Controller

上⾯的⽰例，还只是在Controller层，如果是在Service层，可能会有更多的trycatch代码块。这将会严重影响代码的可读性、“美观

性”。

所以如果是我的话，我肯定偏向于第⼆种，我可以把更多的精⼒放在业务代码的开发，同时代码也会变得更加简洁。

既然业务代码不显式地对异常进⾏捕获、处理，⽽异常肯定还是处理的，不然系统岂不是动不动就崩溃了，所以必须得有其他地⽅捕获并处

理这些异常。

那么问题来了，如何优雅的处理各种异常？

什么是统⼀异常处理

Spring在3.2版本增加了⼀个注解@ControllerAdvice，可以与@ExceptionHandler、@InitBinder、@ModelAttribute等注解注解配套

使⽤，对于这⼏个注解的作⽤，这⾥不做过多赘述。

不过跟异常处理相关的只有注解@ExceptionHandler，从字⾯上看，就是异常处理器的意思，其实际作⽤也是：若在某个Controller类定

义⼀个异常处理⽅法，并在⽅法上添加该注解，那么当出现指定的异常时，会执⾏该处理异常的⽅法，其可以使⽤springmvc提供的数据绑

定，⽐如注⼊HttpServletRequest等，还可以接受⼀个当前抛出的Throwable对象。

但是，这样⼀来，就必须在每⼀个Controller类都定义⼀套这样的异常处理⽅法，因为异常可以是各种各样。这样⼀来，就会造成⼤量的冗

余代码，⽽且若需要新增⼀种异常的处理逻辑，就必须修改所有Controller类了，很不优雅。

当然你可能会说，那就定义个类似BaseController的基类，这样总⾏了吧。

这种做法虽然没错，但仍不尽善尽美，因为这样的代码有⼀定的侵⼊性和耦合性。简简单单的Controller，我为啥⾮得继承这样⼀个类呢，

万⼀已经继承其他基类了呢。⼤家都知道Java只能继承⼀个类。

那有没有⼀种⽅案，既不需要跟Controller耦合，也可以将定义的异常处理器应⽤到所有控制器呢？所以注解@ControllerAdvice出现

了，简单的说，该注解可以把异常处理器应⽤到所有控制器，⽽不是单个控制器。借助该注解，我们可以实现：在独⽴的某个地⽅，⽐如单

独⼀个类，定义⼀套对各种异常的处理机制，然后在类的签名加上注解@ControllerAdvice，统⼀对不同阶段的、不同异常进⾏处理。这

就是统⼀异常处理的原理。

注意到上⾯对异常按阶段进⾏分类，⼤体可以分成：进⼊Controller前的异常和Service层异常，具体可以参考下图：

不同阶段的异常

⽬标

消灭95%以上的trycatch代码块，以优雅的Assert(断⾔)⽅式来校验业务的异常情况，只关注业务逻辑，⽽不⽤花费⼤量精⼒写冗余的

trycatch代码块。

统⼀异常处理实战

注：因为整个统⼀异常处理⽅案涉及的代码⽐较多，这⾥不⽅便贴出所有代码，只会贴出关键部分，所以建议将源码clone到本地⽅便

查看奶的拼音 。

涉及到的项⽬包括：spring-cloud-advance山房春事岑参其二翻译 -common、unified-exception-handling。

在定义统⼀异常处理类之前，先来介绍⼀下如何优雅的判定异常情况并抛异常。

⽤Assert(断⾔)替换throwexception

想必Assert(断⾔)⼤家都很熟悉，⽐如Spring家族的，在我们写测试⽤例的时候经常会⽤到，使⽤

断⾔能让我们编码的时候有⼀种⾮⼀般丝滑的感觉，⽐如：

@Test

publicvoidtest1(){

...

Useruser=ById(userId);

l(user,\"⽤户不存在.\");

...

}

@Test

publicvoidtest2(){

//另⼀种写法

Useruser=ById(userId);

if(user==null){

thrownewIllegalArgumentException(\"⽤户不存在.\");

}

}

有没有感觉第⼀种判定⾮空的写法很优雅，第⼆种写法则是相对丑陋的if{...}代码块。那么神奇的l()背后到底做了什么

呢？下⾯是Assert的部分源码：(⾮空判断⽂章，可以参考这⾥)

publicabstractclassAssert{

publicAssert(){

}

publicstaticvoidnotNull(@NullableObjectobject,Stringmessage){

if(object==null){

thrownewIllegalArgumentException(message);

}

}

}

可以看到，Assert其实就是帮我们把if{...}封装了⼀下，是不是很神奇。虽然很简单，但不可否认的是编码体验⾄少提升了⼀个档次。那

么我们能不能模仿，也写⼀个断⾔类，不过断⾔失败后抛出的异常不是IllegalArgumentException这

些内置异常，⽽是我们⾃⼰定义的异常。下⾯让我们来尝试⼀下。

Assert

publicinterfaceAssert{

/**

*创建异常

*@paramargs

*@return

*/

args);

/**

*创建异常

*@paramt

*@paramargs

*@return

*/

BaseExceptionnewException(args);

/**

*

断⾔对象obj⾮空。如果对象obj为空，则抛出异常

*

*@paramobj待判断对象

*/

defaultvoidassertNotNull(Objectobj){

if(obj==null){

thrownewException(obj);

}

}

/**

*

断⾔对象obj⾮空。如果对象obj为空，则抛出异常

*

异常信息message⽀持传递参数⽅式，避免在判断之前进⾏字符串拼接操作

*

*@paramobj待判断对象

*@paramargsmessage占位符对应的参数列表

*/

defaultvoidassertNotNull(args){

if(obj==null){

thrownewException(args);

}

}

}

注：

1.这⾥只给出Assert接⼝的部分源码，更多断⾔⽅法请参考源码。

ception是所有⾃定义异常的基类。

3.在接⼝中定义默认⽅法是Java8的新语法。

上⾯的Assert断⾔⽅法是使⽤接⼝的默认⽅法定义的，然后有没有发现当断⾔失败后，抛出的异常不是具体的某个异常，⽽是交由2个

newException接⼝⽅法提供。因为业务逻辑中出现的异常基本都是对应特定的场景。

⽐如根据⽤户id获取⽤户信息，查询结果为null，此时抛出的异常可能为UserNotFoundException，并且有特定的异常码(⽐如7001)和异

常信息“⽤户不存在”。所以具体抛出什么异常，有Assert的实现类决定。

看到这⾥，您可能会有这样的疑问，按照上⾯的说法，那岂不是有多少异常情况，就得有定义等量的断⾔类和异常类，这显然是反⼈类的，

这也没想象中⾼明嘛。别急，且听我细细道来。

善解⼈意的Enum

⾃定义异常BaseException有2个属性，即code、message，这样⼀对属性，有没有想到什么类⼀般也会定义这2个属性？没错，就是枚

举类。且看我如何将Enum和Assert结合起来，相信我⼀定会让你眼前⼀亮。如下：

publicinterfaceIResponseEnum{

intgetCode();

StringgetMessage();

}

/**

*

业务异常

*

业务处理时，出现异常，可以抛出该异常

*/

publicclassBusinessExceptionextendsBaseException{

privatestaticfinallongserialVersionUID=1L;

publicBusinessException(IResponseEnumresponseEnum,Object[]args,Stringmessage){

super(responseEnum,args,message);

}

publicBusinessException(IResponseEnumresponseEnum,Object[]args,Stringmessage,Throwablecause){

super(responseEnum,args,message,cause);

}

}

publicinterfaceBusinessExceptionAssertextendsIResponseEnum,Assert{

@Override

args){

Stringmsg=(sage(),args);

returnnewBusinessException(this,args,msg);

}

@Override

defaultBaseExceptionnewException(args){

Stringmsg=(sage(),args);

returnnewBusinessException(this,args,msg,t);

}

}

@Getter

@AllArgsConstructor

publicenumResponseEnumimplementsBusinessExceptionAssert{

/**

*Badlicencetype

*/

BAD_LICENCE_TYPE(7001,\"Badlicencetype.\"),

/**

*Licencenotfound

*/

LICENCE_NOT_FOUND(7002,\"Licencenotfound.\")

;

/**

*返回码

*/

privateintcode;

/**

*返回消息

*/

privateStringmessage;

}

看到这⾥，有没有眼前⼀亮的感觉，代码⽰例中定义了两个枚举实例：BAD_LICENCE_TYPE、LICENCE_NOT_FOUND，分别对应了

BadLicenceTypeException、LicenceNotFoundException两种异常。

以后每增加⼀种异常情况，只需增加⼀个枚举实例即可，再也不⽤每⼀种异常都定义⼀个异常类了。然后再来看下如何使⽤，假设

LicenceService有校验Licence是否存在的⽅法，如下：

/**

*校验{@linkLicence}存在

*@paramlicence

*/

privatevoidcheckNotNull(Licencelicence){

E_NOT_NotNull(licence);

}

若不使⽤断⾔，代码可能如下：

privatevoidcheckNotNull(Licencelicence){

if(licence==null){

thrownewLicenceNotFoundException();

//或者这样

thrownewBusinessException(7001,\"Badlicencetype.\");

}

}

使⽤枚春草明年绿全诗 举类结合(继承)Assert，只需根据特定的异常情况定义不同的枚举实例，如上⾯的BAD_LICENCE_TYPE、

LICENCE_NOT_FOUND，就能够针对不同情况抛出特定的异常(这⾥指携带特定的异常码和异常消息)，这样既不⽤定义⼤量的异常类，同

时还具备了断⾔的良好可读性，当然这种⽅案的好处远不⽌这些，请继续阅读后⽂，慢慢体会。

注：上⾯举的例⼦是针对特定的业务，⽽有部分异常情况是通⽤的，⽐如：服务器繁忙、⽹络异常、服务器异常、参数校验异常、

404等，所以有CommonResponseEnum、ArgumentResponseEnum、ServletResponseEnum，其

中ServletResponseEnum会在后⽂详细说明。

定义统⼀异常处理器类

@Slf4j

@Component

@ControllerAdvice

@ConditionalOnWebApplication

@ConditionalOnMissingBean()

publicclassUnifiedExceptionHandler{

/**

*⽣产环境

*/

privatefinalstaticStringENV_PROD=\"prod\";

@Autowired

privateUnifiedMessageSourceunifiedMessageSource;

/**

*当前环境

*/

@Value(\"${}\")

privateStringprofile;

/**

*获取国际化消息

*

*@parame异常

*@return

*/

publicStringgetMessage(BaseExceptione){

Stringcode=\"response.\"+ponseEnum().toString();

Stringmessage=sage(code,s());

if(message==null||y()){

sage();

}

returnmessage;

}

/**

*业务异常

*

*@parame异常

*@return异常结果

*/

@ExceptionHandler(value=)

@ResponseBody

publicErrorResponsehandleBusinessException(BaseExceptione){

(sage(),e);

returnnewErrorResponse(ponseEnum().getCode(),getMessage(e));

}

/**

*⾃定义异常

*

*@parame异常

*@return异常结果

*/

@ExceptionHandler(value=)

@ResponseBody

publicErrorResponsehandleBaseException(BaseExceptione){

(sage(),e);

returnnewErrorResponse(ponseEnum().getCode(),getMessage(e));

}

/**

*Controller上⼀层相关异常

*

*@parame异常

*@return异常结果

*/

@ExceptionHandler({

,

,

,

,

,

,

,

,

//,

//

,

,

,

,

})

@ResponseBody

publicErrorResponsehandleServletException(Exceptione){

(sage(),e);

intcode=_e();

try{

ServletResponseEnumservletExceptionEnum=f(ss().getSimpleName());

code=e();

}catch(IllegalArgumentExceptione1){

(\"class[{}]notdefinedinenum{}\",ss().getName(),e());

}

if(ENV_(profile)){

//当为⽣产环境,不适合把具体的异常信息展⽰给⽤户,⽐如404.

code=_e();

BaseExceptionbaseException=newBaseException(_ERROR);

Stringmessage=getMessage(baseException);

returnnewErrorResponse(code,message);

}

returnnewErrorResponse(code,sage());

}

/**

*参数绑定异常

*

*@parame异常

*@return异常结果

*/

@ExceptionHandler(value=)

@ResponseBody

publicErrorResponsehandleBindException(BindExceptione){

(\"参数绑定校验异常\",e);

returnwrapperBindingResult(dingResult());

}

/**

*参数校验异常，将校验失败的所有异常组合成⼀条错误信息

*

*@parame异常

*@return异常结果

*@return异常结果

*/

@ExceptionHandler(value=)

@ResponseBody

publicErrorResponsehandleValidException(MethodArgumentNotValidExceptione){

(\"参数绑定校验异常\",e);

returnwrapperBindingResult(dingResult());

}

/**

*包装绑定异常结果

*

*@parambindingResult绑定结果

*@return异常结果

*/

privateErrorResponsewrapperBindingResult(BindingResultbindingResult){

StringBuildermsg=newStringBuilder();

for(ObjectErrorerror:Errors()){

(\",\");

if(errorinstanceofFieldError){

(((FieldError)error).getField()).append(\":\");

}

(aultMessage()==null?\"\":aultMessage());

}

returnnewErrorResponse(_e(),ing(2));

}

/**

*未定义异常

*

*@parame异常

*@return异常结果

*/

@ExceptionHandler(value=)

@ResponseBody

publicErrorResponsehandleException(Exceptione){

(sage(),e);

if(ENV_(profile)){

//当为⽣产环境,不适合把具体的异常信息展⽰给⽤户,⽐如数据库异常信息.

intcode=_e();

BaseExceptionbaseException=newBaseException(_ERROR);

Stringmessage=getMessage(baseExce重过阊门万事非 ption);

returnnewErrorResponse(code,message);

}

returnnewErrorResponse(_e(),sage());

}

}

可以看到，上⾯将异常分成⼏类，实际上只有两⼤类，⼀类是ServletException、ServiceException，还记得上⽂提到的按阶段分类

吗，即对应进⼊Controller前的异常和Service层异常；然后ServiceException再分成⾃定义异常、未知异常。对应关系如下：

进⼊Controller前的异常:handleServletException、handleBindException、handleValidException

⾃定义异常:handleBusinessException、handleBaseException

未知异常:handleException

接下来分别对这⼏种异常处理器做详细说明。其他关于springboot的内容，可以看这⾥。

异常处理器说明

handleServletException

⼀个http请求，在到达Controller前，会对该请求的请求信息与⽬标控制器信息做⼀系列校验。这⾥简单说⼀下：

NoHandlerFoundException：⾸先根据请求Url查找有没有对应的控制器，若没有则会抛该异常，也就是⼤家⾮常熟悉的404异常；

HttpRequestMethodNotSupportedException：若匹配到了(匹配结果是⼀个列表，不同的是http⽅法不同，如：Get、Post等)，

则尝试将请求的http⽅法与列表的控制器做匹配，若没有对应http⽅法的控制器，则抛该异常；

HttpMediaTypeNot佯组词 SupportedException：然后再对请求头与控制器⽀持的做⽐较，⽐如content-type请求头，若控制器的参数签

名包含注解@RequestBody，但是请求的content-type请求头的值没有包含application/json，那么会抛该异常(当然，不⽌这种情况

会抛这个异常)；

MissingPathVariableException：未检测到路径参数。⽐如url为：/licence/{licenceId}，参数签名包含

@PathVariable(\"licenceId\")，当请求的url为/licence，在没有明确定义url为/licence的情况下，会被判定为：缺少路径参数；

MissingServletRequestParameterException：缺少请求参数。⽐如定义了参数@RequestParam(\"licenceId\")StringlicenceId，

但发起请求时，未携带该参数，则会抛该异常；

TypeMismatchException:参数类型匹配失败。⽐如：接收参数为Long型，但传⼊的值确是⼀个字符串，那么将会出现类型转换失败

的情况，这时会抛该异常；

HttpMessageNotReadableException：与上⾯的HttpMediaTypeNotSupportedException举的例⼦完全相反，即请求头携带

了\"content-type:application/json;charset=UTF-8\"，但接收参数却没有添加注解@RequestBody，或者请求体携带的json串反

序列化成pojo的过程中失败了，也会抛该异常；

HttpMessageNotWritableException：返回的pojo在序列化成json过程失败了，那么抛该异常；

HttpMediaTypeNotAcceptableException：未知；

ServletRequestBindingException：未知；

ConversionNotSupportedException：未知；

MissingServletRequestPartException：未知；

AsyncRequestTimeoutException：未知；

handleBindException

参数校验异常，后⽂详细说明。

handleValidException

参数校验异常，后⽂详细说明。

handleBusinessException、handleBaseException

处理⾃定义的业务异常，只是handleBaseException处理的是除了BusinessException意外的所有业务异常。就⽬前来看，这2个是可以

合并成⼀个的。

handleException

处理所有未知的异常，⽐如操作数据库失败的异常。

注：上⾯的handleServletException、handleException这两个处理器，返回的异常信息，不同环境返回的可能不⼀样，以为这些

异常信息都是框架⾃带的异常信息，⼀般都是英⽂的，不太好直接展⽰给⽤户看，所以统⼀返回SERVER_ERROR代表的异常信息。

异于常⼈的404

上⽂提到，当请求没有匹配到控制器的情况下，会抛出NoHandlerFoundException异常，但其实默认情况下不是这样，默认情况下会出现

类似如下页⾯：

WhitelabelErrorPage

这个页⾯是如何出现的呢？实际上，当出现404的时候，默认是不抛异常的，⽽是forward跳转到/error控制器，spring也提供了默认的

error控制器，如下：

BasicErrorController

那么，如何让404也抛出异常呢，只需在properties⽂件中加⼊如下配置即可：

-exception-if-no-handler-found=true

-mappings=false

如此，就可以异常处理器中捕获它了，然后前端只要捕获到特定的状态码，⽴即跳转到404页⾯即可。

捕获404对应的异常

统⼀返回结果

在验证统⼀异常处理器之前，顺便说⼀下统⼀返回结果。说⽩了，其实是统⼀⼀下返回结果的数据结构。code、message是所有返回结果

中必有的字段，⽽当需要返回数据时，则需要另⼀个字段data来表⽰。

所以⾸先定义⼀个BaseResponse来作为所有返回结果的基类；

然后定义⼀个通⽤返回结果类CommonResponse，继承BaseResponse，⽽且多了字段data；

为了区分成功和失败返回结果，于是再定义⼀个ErrorResponse；

最后还有⼀种常见的返回结果，即返回的数据带有分页信息，因为这种接⼝⽐较常见，所以有必要单独定义⼀个返回结果类

QueryDataR碧云天 黄叶地 秋色连波 波上寒烟翠 esponse，该类继承⾃CommonResponse，只是把data字段的类型限制为QueryDdata，QueryDdata中定义了分页信

息相应的字段，即totalCount、pageNo、pageSize、records。

其中⽐较常⽤的只有CommonRe大江歌罢掉头东 sponse和QueryDataResponse，但是名字⼜贼⿁死长，何不定义2个名字超简单的类来替代呢？于是

R和QR诞⽣了，以后返回结果的时候只需这样写：newR<>(data)、newQR<>(queryData)。

所有的返回结果类的定义这⾥就不贴出来了。

验证统⼀异常处理

因为这⼀套统⼀异常处理可以说是通⽤的，所有可以设计成⼀个common包，以后每⼀个新项⽬/模块只需引⼊该包即可。所以为了验证，

需要新建⼀个项⽬，并引⼊该common包。项⽬结构如下：

项⽬结构

以后只需这样引⼊即可：

引⼊common包

主要代码

下⾯是⽤于验证的主要源码：

@Service

publicclassLicenceServiceextendsServiceImpl{

@Autowired

privateOrganizationClientorganizationClient;

/**

*查询{@linkLicence}详情

*@paramlicenceId

*@return

*/

publicLicenceDTOqueryDetail(LonglicenceId){

Licencelicence=d(licenceId);

checkNotNull(licence);

OrganizationDTOorg=e(()->anization(anizationId()));

returntoLicenceDTO(licence,org);

}

/**

*分页获取

*@paramlicenceParam分页查询参数

*@return

*/

publicQueryDatagetLicences(LicenceParamlicenceParam){

StringlicenceType=enceType();

LicenceTypeEnumlicenceTypeEnum=fNullable(licenceType);

//断⾔,⾮空

_LICENCE_NotNull(licenceTypeEnum);

LambdaQueryWrapperwrapper=newLambdaQueryWrapper<>();

(Licence::getLicenceType,licenceType);

IPagepage=(newQueryPage<>(licenceParam),wrapper);returnnewQueryData<>(page,this::toSimpleLicenceDTO);

}/**

*新增{@linkLicence}

*@paramrequest请求体

*@return

*/@Transactional(rollbackFor=)publicLicenceAddRespDataaddLicence(LicenceAddRequestrequest){

Licencelicence=newLicence();

anizationId(anizationId());

enceType(enceType());

ductName(ductName());

enceMax(enceMax());

enceAllocated(enceAllocated());

ment(ment());(licence);returnnewLicenceA端午节诗句大全 ddRespData(enceId());

}/**

*entity->simpledto

*@paramlicence{@linkLicence}entity

*@return{@linkSimpleLicenceDTO}

*/privateSimpleLicenceDTOtoSimpleLicenceDTO(Licencelicence){//省略

}/**

*entity->dto

*@paramlicence{@linkLicence}entity

*@paramorg{@linkOrganizationDTO}

*@return{@linkLicenceDTO}

*/privateLicenceDTOtoLicenceDTO(Licencelicence,OrganizationDTOorg){//省略

}/**

*校验{@linkLicence}存在

*@paramlicence

*/privatevoidcheckNotNull(Licencelicence){

E_NOT_NotNull(licence);

}

}

ps:这⾥使⽤的DAO框架是mybatis-plus。

启动时，⾃动插⼊的数据为：

--licence

INSERTINTOlicence(licence_id,organization_id,licence_type,product_name,licence_max,licence_allocated)

VALUES(1,1,\'user\',\'CustomerPro\',100,5);

INSERTINTOlicence(licence_id,organization_id,licence_type,product_name,licence_max,licence_allocated)

VALUES(2,1,\'user\',\'suitability-plus\',200,189);

INSERTINTOlicence(licence_id,organization_id,licence_type,product_name,licence_max,licence_allocated)

VALUES(3,2,\'user\',\'HR-PowerSuite\',100,4);

INSERTINTOlicence(licence_id,organization_id,licence_type,product_name,licence_max,licence_allocated)

VALUES(4,2,\'core-prod\',\'WildCatApplicationGateway\',16,16);

--organizations

INSERTINTOorganization(id,name,contact_name,contact_email,contact_phone)

VALUES(1,\'customer-crm-co\',\'MarkBalster\',\'r@\',\'823-555-1212\');

INSERTINTOorganization(id,name,contact_name,contact_email,contact_phone)

VALUES(2,\'HR-PowerSuite\',\'DougDrewry\',\'@\',\'920-555-1212\');

开始验证

捕获⾃定义异常

校验⾮空

捕获Licencenotfound异常

Licencenotfound

校验⾮空

捕获Badlicencetype异常

Badlicencetype

捕获进⼊Controller前的异常

捕获404异常

PostMapping

捕获Requestmethodnotsupported异常

Requestmethodnotsupported

getLicences

LicenceParam

捕获参数绑定校验异常

licencetypecannotbeempty

4.校验异常2：post请求，这⾥使⽤postman模拟。

addLicence

LicenceAddRequest

请求url即结果

捕获参数绑定校验异常

注：因为参数绑定校验异常的异常信息的获取⽅式与其它异常不⼀样，所以才把这2种情况的异常从进⼊Controller前的异常单独拆出

来，下⾯是异常信息的收集逻辑：

异常信息的收集

捕获未知异常

增加test字段

捕获数据库异常

Errorqueryingdatabase

⼩结

可以看到，测试的异常都能够被捕获，然后以code、message的形式返回。每⼀个项⽬/模块，在定义业务异常的时候，只需定义⼀个枚

举类，然后实现接⼝BusinessExceptionAssert，最后为每⼀种业务异常定义对应的枚举实例即可，⽽不⽤定义许多异常类。使⽤的时候

也很⽅便，⽤法类似断⾔。

扩展

在⽣产环境，若捕获到未知异常或者ServletException，因为都是⼀长串的异常信息，若直接展⽰给⽤户看，显得不够专业，于是，我们

可以这样做：当检测到当前环境是⽣产环境，那么直接返回\"⽹络异常\"。

⽣产环境返回“⽹络异常”

可以通过以下⽅式修改当前环境：

修改当前环境为⽣产环境

总结

使⽤断⾔和枚举类相结合的⽅式，再配合统⼀异常处理，基本⼤部分的异常都能够被捕获。为什么说⼤部分异常，因为当引⼊spring

cloudsecurity后，还会有认证/授权异常，⽹关的服务降级异常、跨模块调⽤异常、远程调⽤第三⽅服务异常等，这些异常的捕获⽅式与

本⽂介绍的不太⼀样，不过限于篇幅，这⾥不做详细说明，以后会有单独的⽂章介绍。

另外，当需要考虑国际化的时候，捕获异常后的异常信息⼀般不能直接返回，需要转换成对应的语⾔，不过本⽂已考虑到了这个，获取消息

的时候已经做了国际化映射东临碣石以观沧海赏析句子 ，逻辑如下：

获取国际化消息

由于国际化相关知识不属于本⽂介绍的范畴，所以不过多说明，以后也会有单独的⽂章介绍。

————end————

微服务、⾼并发、JVM调优、⾯试专栏等20⼤进阶架构师专题请关注公众号【Java进阶架构师】后在菜单栏查看。

看到这⾥，说明你喜欢本⽂

你的转发，是对我最⼤的⿎励！在看亦是⽀持↓