zoukankan      html  css  js  c++  java

  • 浅谈dubbo的ExceptionFilter异常处理

    背景

    我们的项目使用了dubbo进行不同系统之间的调用。
    每个项目都有一个全局的异常处理，对于业务异常，我们会抛出自定义的业务异常（继承RuntimeException）。
    全局的异常处理会根据不同的异常类型进行不同的处理。
    最近我们发现，某个系统调用dubbo请求，provider端（服务提供方）抛出了自定义的业务异常，但consumer端（服务消费方）拿到的并不是自定义的业务异常。
    这是为什么呢？还需要从dubbo的ExceptionFilter说起。

    ExceptionFilter

    如果Dubbo的 provider端 抛出异常（Throwable），则会被 provider端 的ExceptionFilter拦截到，执行以下invoke方法：
    [java] view plain copy
     
    1. /* 
    2.  * Copyright 1999-2011 Alibaba Group. 
    3.  *   
    4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
    5.  * you may not use this file except in compliance with the License. 
    6.  * You may obtain a copy of the License at 
    7.  *   
    8.  *      http://www.apache.org/licenses/LICENSE-2.0 
    9.  *   
    10.  * Unless required by applicable law or agreed to in writing, software 
    11.  * distributed under the License is distributed on an "AS IS" BASIS, 
    12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
    13.  * See the License for the specific language governing permissions and 
    14.  * limitations under the License. 
    15.  */  
    16. package com.alibaba.dubbo.rpc.filter;  
    17.   
    18. import java.lang.reflect.Method;  
    19.   
    20. import com.alibaba.dubbo.common.Constants;  
    21. import com.alibaba.dubbo.common.extension.Activate;  
    22. import com.alibaba.dubbo.common.logger.Logger;  
    23. import com.alibaba.dubbo.common.logger.LoggerFactory;  
    24. import com.alibaba.dubbo.common.utils.ReflectUtils;  
    25. import com.alibaba.dubbo.common.utils.StringUtils;  
    26. import com.alibaba.dubbo.rpc.Filter;  
    27. import com.alibaba.dubbo.rpc.Invocation;  
    28. import com.alibaba.dubbo.rpc.Invoker;  
    29. import com.alibaba.dubbo.rpc.Result;  
    30. import com.alibaba.dubbo.rpc.RpcContext;  
    31. import com.alibaba.dubbo.rpc.RpcException;  
    32. import com.alibaba.dubbo.rpc.RpcResult;  
    33. import com.alibaba.dubbo.rpc.service.GenericService;  
    34.   
    35. /** 
    36.  * ExceptionInvokerFilter 
    37.  * <p> 
    38.  * 功能： 
    39.  * <ol> 
    40.  * <li>不期望的异常打ERROR日志（Provider端）<br> 
    41.  *     不期望的日志即是，没有的接口上声明的Unchecked异常。 
    42.  * <li>异常不在API包中，则Wrap一层RuntimeException。<br> 
    43.  *     RPC对于第一层异常会直接序列化传输(Cause异常会String化)，避免异常在Client出不能反序列化问题。 
    44.  * </ol> 
    45.  *  
    46.  * @author william.liangf 
    47.  * @author ding.lid 
    48.  */  
    49. @Activate(group = Constants.PROVIDER)  
    50. public class ExceptionFilter implements Filter {  
    51.   
    52.     private final Logger logger;  
    53.       
    54.     public ExceptionFilter() {  
    55.         this(LoggerFactory.getLogger(ExceptionFilter.class));  
    56.     }  
    57.       
    58.     public ExceptionFilter(Logger logger) {  
    59.         this.logger = logger;  
    60.     }  
    61.       
    62.     public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {  
    63.         try {  
    64.             Result result = invoker.invoke(invocation);  
    65.             if (result.hasException() && GenericService.class != invoker.getInterface()) {  
    66.                 try {  
    67.                     Throwable exception = result.getException();  
    68.   
    69.                     // 如果是checked异常，直接抛出  
    70.                     if (! (exception instanceof RuntimeException) && (exception instanceof Exception)) {  
    71.                         return result;  
    72.                     }  
    73.                     // 在方法签名上有声明，直接抛出  
    74.                     try {  
    75.                         Method method = invoker.getInterface().getMethod(invocation.getMethodName(), invocation.getParameterTypes());  
    76.                         Class<?>[] exceptionClassses = method.getExceptionTypes();  
    77.                         for (Class<?> exceptionClass : exceptionClassses) {  
    78.                             if (exception.getClass().equals(exceptionClass)) {  
    79.                                 return result;  
    80.                             }  
    81.                         }  
    82.                     } catch (NoSuchMethodException e) {  
    83.                         return result;  
    84.                     }  
    85.   
    86.                     // 未在方法签名上定义的异常，在服务器端打印ERROR日志  
    87.                     logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getContext().getRemoteHost()  
    88.                             + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName()  
    89.                             + ", exception: " + exception.getClass().getName() + ": " + exception.getMessage(), exception);  
    90.   
    91.                     // 异常类和接口类在同一jar包里，直接抛出  
    92.                     String serviceFile = ReflectUtils.getCodeBase(invoker.getInterface());  
    93.                     String exceptionFile = ReflectUtils.getCodeBase(exception.getClass());  
    94.                     if (serviceFile == null || exceptionFile == null || serviceFile.equals(exceptionFile)){  
    95.                         return result;  
    96.                     }  
    97.                     // 是JDK自带的异常，直接抛出  
    98.                     String className = exception.getClass().getName();  
    99.                     if (className.startsWith("java.") || className.startsWith("javax.")) {  
    100.                         return result;  
    101.                     }  
    102.                     // 是Dubbo本身的异常，直接抛出  
    103.                     if (exception instanceof RpcException) {  
    104.                         return result;  
    105.                     }  
    106.   
    107.                     // 否则，包装成RuntimeException抛给客户端  
    108.                     return new RpcResult(new RuntimeException(StringUtils.toString(exception)));  
    109.                 } catch (Throwable e) {  
    110.                     logger.warn("Fail to ExceptionFilter when called by " + RpcContext.getContext().getRemoteHost()  
    111.                             + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName()  
    112.                             + ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e);  
    113.                     return result;  
    114.                 }  
    115.             }  
    116.             return result;  
    117.         } catch (RuntimeException e) {  
    118.             logger.error("Got unchecked and undeclared exception which called by " + RpcContext.getContext().getRemoteHost()  
    119.                     + ". service: " + invoker.getInterface().getName() + ", method: " + invocation.getMethodName()  
    120.                     + ", exception: " + e.getClass().getName() + ": " + e.getMessage(), e);  
    121.             throw e;  
    122.         }  
    123.     }  
    124.   
    125. }  

    代码分析

    按逻辑顺序进行分析，满足其中一个即返回，不再继续执行判断。

    逻辑0

    [java] view plain copy
     
    1. if (result.hasException() && GenericService.class != invoker.getInterface()) {  
    2.     //...  
    3. }  
    4. return result;  
    调用结果有异常且未实现GenericService接口，进入后续判断逻辑，否则直接返回结果。
    [java] view plain copy
     
    1. /** 
    2.  * 通用服务接口 
    3.  *  
    4.  * @author william.liangf 
    5.  * @export 
    6.  */  
    7. public interface GenericService {  
    8.   
    9.     /** 
    10.      * 泛化调用 
    11.      *  
    12.      * @param method 方法名，如：findPerson，如果有重载方法，需带上参数列表，如：findPerson(java.lang.String) 
    13.      * @param parameterTypes 参数类型 
    14.      * @param args 参数列表 
    15.      * @return 返回值 
    16.      * @throws Throwable 方法抛出的异常 
    17.      */  
    18.     Object $invoke(String method, String[] parameterTypes, Object[] args) throws GenericException;  
    19.   
    20. }  
    泛接口实现方式主要用于服务器端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成，比如：实现一个通用的远程服务Mock框架，可通过实现GenericService接口处理所有服务请求。
    不适用于此场景，不在此处探讨。
     

    逻辑1

    [java] view plain copy
     
    1. // 如果是checked异常，直接抛出  
    2. if (! (exception instanceof RuntimeException) && (exception instanceof Exception)) {  
    3.     return result;  
    4. }  
    不是RuntimeException类型的异常，并且是受检异常（继承Exception），直接抛出。
    provider端想抛出受检异常，必须在api上明确写明抛出受检异常；consumer端如果要处理受检异常，也必须使用明确写明抛出受检异常的api。
    provider端api新增 自定义的 受检异常， 所有的 consumer端api都必须升级，同时修改代码，否则无法处理这个特定异常。

    consumer端DecodeableRpcResult的decode方法会对异常进行处理


    此处会抛出IOException，上层catch后会做toString处理，放到mErrorMsg属性中：
    [java] view plain copy
     
    1. try {  
    2.     decode(channel, inputStream);  
    3. } catch (Throwable e) {  
    4.     if (log.isWarnEnabled()) {  
    5.         log.warn("Decode rpc result failed: " + e.getMessage(), e);  
    6.     }  
    7.     response.setStatus(Response.CLIENT_ERROR);  
    8.     response.setErrorMessage(StringUtils.toString(e));  
    9. } finally {  
    10.     hasDecoded = true;  
    11. }  

    DefaultFuture判断请求返回的结果，最后抛出RemotingException：
    [java] view plain copy
     
    1. private Object returnFromResponse() throws RemotingException {  
    2.     Response res = response;  
    3.     if (res == null) {  
    4.         throw new IllegalStateException("response cannot be null");  
    5.     }  
    6.     if (res.getStatus() == Response.OK) {  
    7.         return res.getResult();  
    8.     }  
    9.     if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {  
    10.         throw new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage());  
    11.     }  
    12.     throw new RemotingException(channel, res.getErrorMessage());  
    13. }  

    DubboInvoker捕获RemotingException，抛出RpcException：
    [java] view plain copy
     
    1. try {  
    2.     boolean isAsync = RpcUtils.isAsync(getUrl(), invocation);  
    3.     boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);  
    4.     int timeout = getUrl().getMethodParameter(methodName, Constants.TIMEOUT_KEY,Constants.DEFAULT_TIMEOUT);  
    5.     if (isOneway) {  
    6.         boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);  
    7.         currentClient.send(inv, isSent);  
    8.         RpcContext.getContext().setFuture(null);  
    9.         return new RpcResult();  
    10.     } else if (isAsync) {  
    11.         ResponseFuture future = currentClient.request(inv, timeout) ;  
    12.         RpcContext.getContext().setFuture(new FutureAdapter<Object>(future));  
    13.         return new RpcResult();  
    14.     } else {  
    15.         RpcContext.getContext().setFuture(null);  
    16.         return (Result) currentClient.request(inv, timeout).get();  
    17.     }  
    18. } catch (TimeoutException e) {  
    19.     throw new RpcException(RpcException.TIMEOUT_EXCEPTION, "Invoke remote method timeout. method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);  
    20. } catch (RemotingException e) {  
    21.     throw new RpcException(RpcException.NETWORK_EXCEPTION, "Failed to invoke remote method: " + invocation.getMethodName() + ", provider: " + getUrl() + ", cause: " + e.getMessage(), e);  
    22. }  

    调用栈：
    FailOverClusterInvoker.doInvoke -...-> DubboInvoker.doInvoke -> ReferenceCountExchangeClient.request -> HeaderExchangeClient.request -> HeaderExchangeChannel.request -> AbstractPeer.send -> NettyChannel.send -> AbstractChannel.write -> Channels.write --back_to--> DubboInvoker.doInvoke -> DefaultFuture.get -> DefaultFuture.returnFromResponse -> throw new RemotingException
     
    异常示例：
    [java] view plain copy
     
    1. com.alibaba.dubbo.rpc.RpcException: Failed to invoke the method triggerCheckedException in the service com.xxx.api.DemoService. Tried 1 times of the providers [192.168.1.101:20880] (1/1) from the registry 127.0.0.1:2181 on the consumer 192.168.1.101 using the dubbo version 3.1.9. Last error is: Failed to invoke remote method: triggerCheckedException, provider: dubbo://192.168.1.101:20880/com.xxx.api.DemoService?xxx, cause: java.io.IOException: Response data error, expect Throwable, but get {cause=(this Map), detailMessage=null, suppressedExceptions=[], stackTrace=[Ljava.lang.StackTraceElement;@23b84919}  
    2. java.io.IOException: Response data error, expect Throwable, but get {cause=(this Map), detailMessage=null, suppressedExceptions=[], stackTrace=[Ljava.lang.StackTraceElement;@23b84919}  
    3.     at com.alibaba.dubbo.rpc.protocol.dubbo.DecodeableRpcResult.decode(DecodeableRpcResult.java:94)  

    逻辑2

    [java] view plain copy
     
    1. // 在方法签名上有声明，直接抛出  
    2. try {  
    3.     Method method = invoker.getInterface().getMethod(invocation.getMethodName(), invocation.getParameterTypes());  
    4.     Class<?>[] exceptionClassses = method.getExceptionTypes();  
    5.     for (Class<?> exceptionClass : exceptionClassses) {  
    6.         if (exception.getClass().equals(exceptionClass)) {  
    7.             return result;  
    8.         }  
    9.     }  
    10. } catch (NoSuchMethodException e) {  
    11.     return result;  
    12. }  
    如果在provider端的api明确写明抛出运行时异常，则会直接被抛出。
     
    如果抛出了这种异常，但是consumer端又没有这种异常，会发生什么呢？
    答案是和上面一样，抛出RpcException。

    因此如果consumer端不care这种异常，则不需要任何处理；
    consumer端有这种异常（路径要完全一致，包名+类名），则不需要任何处理；
    没有这种异常，又想进行处理，则需要引入这个异常进行处理（方法有多种，比如升级api，或引入/升级异常所在的包）。

    逻辑3

    [java] view plain copy
     
    1. // 异常类和接口类在同一jar包里，直接抛出  
    2. String serviceFile = ReflectUtils.getCodeBase(invoker.getInterface());  
    3. String exceptionFile = ReflectUtils.getCodeBase(exception.getClass());  
    4. if (serviceFile == null || exceptionFile == null || serviceFile.equals(exceptionFile)){  
    5.     return result;  
    6. }  
    如果异常类和接口类在同一个jar包中，直接抛出。
     

    逻辑4

    [java] view plain copy
     
    1. // 是JDK自带的异常，直接抛出  
    2. String className = exception.getClass().getName();  
    3. if (className.startsWith("java.") || className.startsWith("javax.")) {  
    4.     return result;  
    5. }  
    以java.或javax.开头的异常直接抛出。
     

    逻辑5

    [java] view plain copy
     
    1. // 是Dubbo本身的异常，直接抛出  
    2. if (exception instanceof RpcException) {  
    3.     return result;  
    4. }  
    dubbo自身的异常，直接抛出。
     

    逻辑6

    [java] view plain copy
     
    1. // 否则，包装成RuntimeException抛给客户端  
    2. return new RpcResult(new RuntimeException(StringUtils.toString(exception)));  
    不满足上述条件，会做toString处理并被封装成RuntimeException抛出。
     

    核心思想

    尽力避免反序列化时失败（只有在jdk版本或api版本不一致时才可能发生）。

    如何正确捕获业务异常

    了解了ExceptionFilter，解决上面提到的问题就很简单了。
    有多种方法可以解决这个问题，每种都有优缺点，这里不做详细分析，仅列出供参考：
    1. 将该异常的包名以"java.或者"javax. " 开头
    2. 使用受检异常（继承Exception）
    3. 不用异常，使用错误码
    4. 把异常放到provider-api的jar包中
    5. 判断异常message是否以XxxException.class.getName()开头（其中XxxException是自定义的业务异常）
    6. provider实现GenericService接口
    7. provider的api明确写明throws XxxException，发布provider（其中XxxException是自定义的业务异常）
    8. 实现dubbo的filter，自定义provider的异常处理逻辑（方法可参考之前的文章给dubbo接口添加白名单——dubbo Filter的使用）
  • 相关阅读:
    【转】ASP.NET配置文件详解
    asp.net 使用application实现单点登录（一个账号只能在一个地方登录）
    转：gridview获取当前行索引的方法
    awk中调用shell的自定义函数
    不想做操作工就把你的心静下来
    nagios通过脚本对系统进行定制监控
    关于一个sql执行时间而引发的讨论
    网站前端服务器高可用方案
    NFS在Centos 6.3下的安装
    关于perl中中文乱码的解决办法
  • 原文地址：https://www.cnblogs.com/exmyth/p/8653681.html
Copyright © 2011-2022 走看看