java异步工厂记录日志_程序日志打印格式

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ServiceA {
    public static void main(String[] args) {
        // 创建异步任务执行器
        ExecutorService executor = Executors.newCachedThreadPool();

        // 定义服务调用和回退的任务列表
        List<Callable<Boolean>> serviceCalls = new ArrayList<>();
        List<Callable<Boolean>> rollbackCalls = new ArrayList<>();
        List<Future<Boolean>> results = new ArrayList<>();

        // 初始状态设为成功
        boolean previousCallSuccess = true;

        // 服务B的调用和回退
        serviceCalls.add(() -> callServiceB());
        rollbackCalls.add(() -> rollbackServiceB());

        // 服务C的调用和回退
        serviceCalls.add(() -> callServiceC());
        rollbackCalls.add(() -> rollbackServiceC());

        // 服务D的调用和回退
        serviceCalls.add(() -> callServiceD());
        rollbackCalls.add(() -> rollbackServiceD());

        try {
            // 循环调用所有服务
            for (int i = 0; i < serviceCalls.size(); i++) {
                Callable<Boolean> call = serviceCalls.get(i);
                Callable<Boolean> rollbackCall = rollbackCalls.get(i);

                // 如果前一个调用失败，则不再继续调用后续服务
                if (!previousCallSuccess) {
                    System.out.println("Previous call failed, skipping current service call");
                    break;
                }

                // 调用当前服务
                Future<Boolean> result = executor.submit(call);
                results.add(result);
                boolean currentCallSuccess = result.get();

                // 检查当前服务调用结果
                if (!currentCallSuccess) {
                    System.out.println("Current call failed, rolling back...");
                    // 执行回滚操作
                    for (int j = i; j >= 0; j--) {
                        executor.submit(rollbackCalls.get(j)).get();
                    }
                    // 标记前一个调用失败
                    previousCallSuccess = false;
                } else {
                    // 标记当前调用成功
                    previousCallSuccess = true;
                }
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // 关闭任务执行器
        executor.shutdown();
    }

    // 调用服务B的方法
    private static boolean callServiceB() {
        System.out.println("Calling service B...");
        // 执行服务B的操作
        // 如果需要返回结果，可以在此处返回相应的结果
        return true; // 假设调用成功
    }

    // 回退服务B的方法
    private static boolean rollbackServiceB() {
        System.out.println("Rolling back service B...");
        // 执行回退操作，比如撤销之前的服务B操作
        return true; // 假设回退成功
    }

    // 调用服务C的方法
    private static boolean callServiceC() {
        System.out.println("Calling service C...");
        // 执行服务C的操作
        // 如果需要返回结果，可以在此处返回相应的结果
        return true; // 假设调用成功
    }

    // 回退服务C的方法
    private static boolean rollbackServiceC() {
        System.out.println("Rolling back service C...");
        // 执行回退操作，比如撤销之前的服务C操作
        return true; // 假设回退成功
    }

    // 调用服务D的方法
    private static boolean callServiceD() {
        System.out.println("Calling service D...");
        // 执行服务D的操作
        // 如果需要返回结果，可以在此处返回相应的结果
        // 假设此处出现异常
        throw new RuntimeException("Error occurred while calling service D");
    }

    // 回退服务D的方法
    private static boolean rollbackServiceD() {
        System.out.println("Rolling back service D...");
        // 执行回退操作，比如撤销之前的服务D操作
        return true; // 假设回退成功
    }
}
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

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class ServiceRollbackUtil {
    private static ExecutorService executor = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        // 用法示例
        List<String> services = new ArrayList<>();
        services.add("B");
        services.add("C");
        services.add("D");

        try {
            boolean success = callServices(services);
            if (!success) {
                System.out.println("One or more services failed, performing rollback...");
                // 执行回滚操作
                // rollbackServices(services);
            } else {
                System.out.println("All services executed successfully.");
            }
        } finally {
            // 关闭任务执行器
            executor.shutdown();
        }
    }

    public static boolean callServices(List<String> services) {
        List<Callable<Boolean>> serviceCalls = new ArrayList<>();
        List<Callable<Boolean>> rollbackCalls = new ArrayList<>();
        List<Future<Boolean>> results = new ArrayList<>();
        boolean previousCallSuccess = true;

        // 根据服务列表生成对应的调用和回滚任务
        for (String service : services) {
            // 生成调用任务
            serviceCalls.add(() -> callService(service));
            // 生成回滚任务
            rollbackCalls.add(() -> rollbackService(service));
        }

        try {
            // 循环调用所有服务
            for (int i = 0; i < serviceCalls.size(); i++) {
                Callable<Boolean> call = serviceCalls.get(i);
                Callable<Boolean> rollbackCall = rollbackCalls.get(i);

                // 如果前一个调用失败，则不再继续调用后续服务
                if (!previousCallSuccess) {
                    System.out.println("Previous call failed, skipping current service call");
                    break;
                }

                // 调用当前服务
                Future<Boolean> result = executor.submit(call);
                results.add(result);
                boolean currentCallSuccess = result.get();

                // 检查当前服务调用结果
                if (!currentCallSuccess) {
                    System.out.println("Current call failed, rolling back...");
                    // 执行回滚操作
                    rollbackServices(rollbackCalls, i);
                    // 标记前一个调用失败
                    previousCallSuccess = false;
                } else {
                    // 标记当前调用成功
                    previousCallSuccess = true;
                }
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // 检查是否所有服务都成功执行
        return previousCallSuccess;
    }

    private static void rollbackServices(List<Callable<Boolean>> rollbackCalls, int index) throws InterruptedException, ExecutionException {
        // 从失败的服务开始执行回滚操作
        for (int j = index; j >= 0; j--) {
            executor.submit(rollbackCalls.get(j)).get();
        }
    }

    // 模拟调用服务
    private static boolean callService(String serviceName) {
        System.out.println("Calling service " + serviceName + "...");
        // 执行服务操作
        // 假设调用成功
        return true;
    }

    // 模拟回滚服务
    private static boolean rollbackService(String serviceName) {
        System.out.println("Rolling back service " + serviceName + "...");
        // 执行回滚操作
        // 假设回滚成功
        return true;
    }
}
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