Organize code; add event exception handling interface; add corresponding test items;

LamGC · LamGC · commit 2c24e2a807b1 · 2019-12-24T20:48:26.000+08:00
diff --git a/src/main/java/net/lamgc/utils/event/EventExecutor.java b/src/main/java/net/lamgc/utils/event/EventExecutor.java
@@ -22,6 +22,8 @@ public class EventExecutor {
 
     private Thread.UncaughtExceptionHandler exceptionHandler = null;
 
+    private EventUncaughtExceptionHandler eventExceptionHandler = null;
+
     /**
      * 构造一个EventExecutor.
      * @param threadPoolExecutor 事件线程池, 线程池将用于执行Handler中的EventMethod.
@@ -45,6 +47,15 @@ public EventExecutor(ThreadPoolExecutor threadPoolExecutor,
             Thread newThread = threadFactory.newThread(r);
             if(newThread.getUncaughtExceptionHandler() == newThread.getThreadGroup()){
                 newThread.setUncaughtExceptionHandler((t, e) -> {
+                    if(e instanceof EventInvokeException && eventExceptionHandler != null){
+                        EventInvokeException exception = (EventInvokeException) e;
+                        eventExceptionHandler.exceptionHandler(
+                                exception.getHandler(),
+                                exception.getHandlerMethod(),
+                                exception.getEventObject(),
+                                exception.getCause());
+                        return;
+                    }
                     if(this.exceptionHandler != null){
                         this.exceptionHandler.uncaughtException(t, e);
                     }
@@ -88,15 +99,7 @@ public void executor(final EventObject eventObject){
         }
         eventHandlerMethod.forEach(method -> {
             final Set<EventHandler> handlerSet = eventHandlerObjectMap.getHandlerObject(method.getDeclaringClass());
-            threadPoolExecutor.execute(() -> handlerSet.forEach(handler -> {
-                try {
-                    method.invoke(handler, eventObject);
-                } catch (IllegalAccessException e) {
-                    throw new RuntimeException(e);
-                } catch (InvocationTargetException e){
-                    throw new RuntimeException(e.getCause() == null ? e : e.getCause());
-                }
-            }));
+            threadPoolExecutor.execute(() -> handlerSet.forEach(handler -> executeEvent(handler, eventObject, method)));
         });
     }
 
@@ -122,20 +125,24 @@ public int executor(EventHandler handler, EventObject eventObject){
                 continue;
             }
 
-            threadPoolExecutor.execute(() -> {
-                try {
-                    method.invoke(handler, eventObject);
-                } catch (IllegalAccessException e) {
-                    throw new RuntimeException(e);
-                } catch (InvocationTargetException e){
-                    throw new RuntimeException(e.getCause() == null ? e : e.getCause());
-                }
-            });
+            executeEvent(handler, eventObject, method);
             invokeCount++;
         }
         return invokeCount;
     }
 
+    private void executeEvent(EventHandler handler, EventObject event, Method eventMethod){
+        threadPoolExecutor.execute(() -> {
+            try {
+                eventMethod.invoke(handler, event);
+            } catch (IllegalAccessException e) {
+                throw new RuntimeException(e);
+            } catch (InvocationTargetException e){
+                throw new EventInvokeException(handler, eventMethod, event, e.getCause());
+            }
+        });
+    }
+
     /**
      * 等待线程池内任务执行完成并关闭线程池.
      * @param timeout 时间
@@ -149,8 +156,12 @@ public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedE
 
     /**
      * 设置线程池异常处理类.
+     *
      * EventExecutor在内部经过处理,
      * 可以动态更改UncaughtExceptionHandler而不用担心设置后需要等线程重新建立后才生效.
+     * 注意: 如需捕获EventHandler方法抛出的异常请使用{@link #setEventUncaughtExceptionHandler(EventUncaughtExceptionHandler)},
+     * 设置捕获EventHandler抛出的异常, 因EventExecutor内部处理,
+     * UncaughtExceptionHandler无法捕获{@link InvocationTargetException}异常来获取事件方法抛出的异常.
      * @param handler 处理类对象
      */
     public void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler){
@@ -187,6 +198,32 @@ public List<Runnable> shutdown(boolean shutdownNow){
         }
     }
 
+    /**
+     * 设置事件异常捕获处理对象.
+     * 该对象能详细获得
+     * @param handler 事件异常捕获处理对象
+     */
+    public void setEventUncaughtExceptionHandler(EventUncaughtExceptionHandler handler){
+        this.eventExceptionHandler = handler;
+    }
+
+    /**
+     * 事件异常处理接口
+     */
+    @FunctionalInterface
+    public interface EventUncaughtExceptionHandler{
+
+        /**
+         * 当事件对象抛出异常时触发.
+         * @param handler 事件处理方法所在{@link EventHandler}
+         * @param handlerMethod 抛出异常的方法对象
+         * @param event 事件对象
+         * @param cause 异常对象
+         */
+        void exceptionHandler(EventHandler handler, Method handlerMethod, EventObject event, Throwable cause);
+    }
+
+
     @Override
     protected void finalize() {
         threadPoolExecutor.shutdownNow();
diff --git a/src/main/java/net/lamgc/utils/event/EventInvokeException.java b/src/main/java/net/lamgc/utils/event/EventInvokeException.java
@@ -0,0 +1,55 @@
+package net.lamgc.utils.event;
+
+import java.lang.reflect.Method;
+
+public class EventInvokeException extends RuntimeException {
+
+    private EventHandler handler;
+
+    private Method handlerMethod;
+
+    private EventObject eventObject;
+
+    private Throwable cause;
+
+    public EventInvokeException(EventHandler handler, Method handlerMethod, EventObject event, Throwable cause){
+        super();
+        this.handler = handler;
+        this.handlerMethod = handlerMethod;
+        this.eventObject = event;
+        this.cause = cause;
+    }
+
+    public EventHandler getHandler() {
+        return handler;
+    }
+
+    public void setHandler(EventHandler handler) {
+        this.handler = handler;
+    }
+
+    public EventObject getEventObject() {
+        return eventObject;
+    }
+
+    public void setEventObject(EventObject eventObject) {
+        this.eventObject = eventObject;
+    }
+
+    @Override
+    public Throwable getCause() {
+        return cause;
+    }
+
+    public void setCause(Throwable cause) {
+        this.cause = cause;
+    }
+
+    public Method getHandlerMethod() {
+        return handlerMethod;
+    }
+
+    public void setHandlerMethod(Method handlerMethod) {
+        this.handlerMethod = handlerMethod;
+    }
+}
diff --git a/src/test/java/net/lamgc/utils/event/EventExecutorTest.java b/src/test/java/net/lamgc/utils/event/EventExecutorTest.java
@@ -38,6 +38,33 @@ public void executorTest() throws IllegalAccessException, InterruptedException {
         executor.executor(new SimpleEventObject(2, "HelloWorld123"));
     }
 
+    @Test
+    public void caughtExceptionTest() throws IllegalAccessException, InterruptedException {
+        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
+                1,
+                Runtime.getRuntime().availableProcessors() / 2,
+                30L, TimeUnit.SECONDS,
+                new ArrayBlockingQueue<>(10)
+        );
+        threadPoolExecutor.setRejectedExecutionHandler((r, executor) -> {
+            try {
+                executor.getQueue().put(r);
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        EventExecutor executor = new EventExecutor(threadPoolExecutor);
 
+        executor.setEventUncaughtExceptionHandler((handler, handlerMethod, event, cause) -> {
+            System.out.println("Handler: " + handler.toString() + ", MethodName: " + handlerMethod.getName() +
+                    ", Event: " + event.getClass().getSimpleName() + " throw Exception: " + cause.getMessage());
+            cause.printStackTrace();
+        });
+
+        SimpleEventHandler handler = new SimpleEventHandler("handler1");
+        executor.addHandler(handler);
+        executor.executor(new ExceptionThrowEvent(new NullPointerException()));
+        Thread.sleep(1000L);
+    }
 
 }
diff --git a/src/test/java/net/lamgc/utils/event/ExceptionThrowEvent.java b/src/test/java/net/lamgc/utils/event/ExceptionThrowEvent.java
@@ -0,0 +1,18 @@
+package net.lamgc.utils.event;
+
+public class ExceptionThrowEvent implements EventObject {
+
+    private Throwable exception;
+
+    public ExceptionThrowEvent(Throwable exception){
+        this.exception = exception;
+    }
+
+    public Throwable getException() {
+        return exception;
+    }
+
+    public void setException(Throwable exception) {
+        this.exception = exception;
+    }
+}
diff --git a/src/test/java/net/lamgc/utils/event/SimpleEventHandler.java b/src/test/java/net/lamgc/utils/event/SimpleEventHandler.java
@@ -12,4 +12,8 @@ public void simpleEventHandler(SimpleEventObject event){
         System.out.println(this.toString() + "." + flag + " - [" + event.errorCode + "] " + event.msg);
     }
 
+    public void throwExceptionEvent(ExceptionThrowEvent event){
+        throw new RuntimeException(event.getException());
+    }
+
 }

Original file line number	Diff line number	Diff line change
`@@ -12,4 +12,8 @@ public void simpleEventHandler(SimpleEventObject event){`
`12`	`12`	`System.out.println(this.toString() + "." + flag + " - [" + event.errorCode + "] " + event.msg);`
`13`	`13`	`}`
`14`	`14`
	`15`	`+ public void throwExceptionEvent(ExceptionThrowEvent event){`
	`16`	`+ throw new RuntimeException(event.getException());`
	`17`	`+ }`
	`18`	`+`
`15`	`19`	`}`