yangys
2024-05-18 040976de6f9934b99f30268a28e2ecf42260e217
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package com.qianwen.core.boot.config;
 
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ThreadPoolExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.boot.error.ErrorType;
import com.qianwen.core.boot.error.ErrorUtil;
import com.qianwen.core.context.BladeContext;
import com.qianwen.core.context.BladeRunnableWrapper;
import com.qianwen.core.launch.props.BladeProperties;
import com.qianwen.core.log.event.ErrorLogEvent;
import com.qianwen.core.log.model.LogError;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.boot.task.TaskExecutorCustomizer;
import org.springframework.boot.task.TaskSchedulerCustomizer;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.NonNull;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.util.ErrorHandler;
 
@EnableScheduling
@Configuration
@EnableAsync
public class BladeExecutorConfiguration extends AsyncConfigurerSupport {
    private static final Logger log = LoggerFactory.getLogger(BladeExecutorConfiguration.class);
    private final BladeContext bladeContext;
    private final BladeProperties bladeProperties;
    private final ApplicationEventPublisher publisher;
 
    public BladeExecutorConfiguration(final BladeContext bladeContext, final BladeProperties bladeProperties, final ApplicationEventPublisher publisher) {
        this.bladeContext = bladeContext;
        this.bladeProperties = bladeProperties;
        this.publisher = publisher;
    }
 
    @Bean
    public TaskExecutorCustomizer taskExecutorCustomizer() {
        return taskExecutor -> {
            taskExecutor.setThreadNamePrefix("async-task-");
            taskExecutor.setTaskDecorator(BladeRunnableWrapper::new);
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        };
    }
 
    @Bean
    public TaskSchedulerCustomizer taskSchedulerCustomizer() {
        return taskExecutor -> {
            taskExecutor.setThreadNamePrefix("async-scheduler");
            taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            taskExecutor.setErrorHandler(new BladeErrorHandler(this.bladeContext, this.bladeProperties, this.publisher));
        };
    }
 
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new BladeAsyncUncaughtExceptionHandler(this.bladeContext, this.bladeProperties, this.publisher);
    }
 
    
    private static class BladeAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {
        private final BladeContext bladeContext;
        private final BladeProperties bladeProperties;
        private final ApplicationEventPublisher eventPublisher;
 
        public BladeAsyncUncaughtExceptionHandler(final BladeContext bladeContext, final BladeProperties bladeProperties, final ApplicationEventPublisher eventPublisher) {
            this.bladeContext = bladeContext;
            this.bladeProperties = bladeProperties;
            this.eventPublisher = eventPublisher;
        }
 
        public void handleUncaughtException(@NonNull Throwable error, @NonNull Method method, @NonNull Object... params) {
            BladeExecutorConfiguration.log.error("Unexpected exception occurred invoking async method: {}", method, error);
            LogError logError = new LogError();
            logError.setParams(ErrorType.ASYNC.getType());
            logError.setEnv(this.bladeProperties.getEnv());
            logError.setServiceId(this.bladeProperties.getName());
            logError.setRequestUri(this.bladeContext.getRequestId());
            ErrorUtil.initErrorInfo(error, logError);
            Map<String, Object> event = new HashMap<>(16);
            event.put("log", logError);
            this.eventPublisher.publishEvent(new ErrorLogEvent(event));
        }
    }
 
    /* loaded from: blade-core-boot-9.3.0.0-SNAPSHOT.jar:org/springblade/core/boot/config/BladeExecutorConfiguration$BladeErrorHandler.class */
    private static class BladeErrorHandler implements ErrorHandler {
        private final BladeContext bladeContext;
        private final BladeProperties bladeProperties;
        private final ApplicationEventPublisher eventPublisher;
 
        public BladeErrorHandler(final BladeContext bladeContext, final BladeProperties bladeProperties, final ApplicationEventPublisher eventPublisher) {
            this.bladeContext = bladeContext;
            this.bladeProperties = bladeProperties;
            this.eventPublisher = eventPublisher;
        }
 
        public void handleError(@NonNull Throwable error) {
            BladeExecutorConfiguration.log.error("Unexpected scheduler exception", error);
            LogError logError = new LogError();
            logError.setParams(ErrorType.SCHEDULER.getType());
            logError.setServiceId(this.bladeProperties.getName());
            logError.setEnv(this.bladeProperties.getEnv());
            logError.setRequestUri(this.bladeContext.getRequestId());
            ErrorUtil.initErrorInfo(error, logError);
            Map<String, Object> event = new HashMap<>(16);
            event.put("log", logError);
            this.eventPublisher.publishEvent(new ErrorLogEvent(event));
        }
    }
}