【企业微信审批流程功能研发】

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 请假申请类
class LeaveRequest {
    private String employee;
    private int days;
    private boolean approvedByLeader;
    private boolean approvedByManager;

    public LeaveRequest(String employee, int days) {
        this.employee = employee;
        this.days = days;
        this.approvedByLeader = false;
        this.approvedByManager = false;
    }

    public String getEmployee() {
        return employee;
    }

    public int getDays() {
        return days;
    }

    public boolean isApprovedByLeader() {
        return approvedByLeader;
    }

    public void setApprovedByLeader(boolean approvedByLeader) {
        this.approvedByLeader = approvedByLeader;
    }

    public boolean isApprovedByManager() {
        return approvedByManager;
    }

    public void setApprovedByManager(boolean approvedByManager) {
        this.approvedByManager = approvedByManager;
    }
}

// 部门领导类
class DepartmentLeader {
    private String name;
    private Lock lock;
    private Condition approveCondition;

    public DepartmentLeader(String name, Lock lock, Condition approveCondition) {
        this.name = name;
        this.lock = lock;
        this.approveCondition = approveCondition;
    }

    public void approve(LeaveRequest request) {
        lock.lock();
        try {
            System.out.println(name + " received leave request from employee: " + request.getEmployee());
            System.out.println(name + " is reviewing the request...");

            // 模拟实际的审批逻辑，根据具体情况进行判断和处理
            if (request.getDays() <= 3) {
                request.setApprovedByLeader(true);
                System.out.println(name + " approved the request from employee: " + request.getEmployee());

                // 通知等待的线程继续执行
                approveCondition.signal();
            } else {
                System.out.println(name + " rejected the request from employee: " + request.getEmployee());
                request.setApprovedByLeader(false);
            }
        } finally {
            lock.unlock();
        }
    }
}

// 经理类
class Manager {
    private String name;
    private Lock lock;
    private Condition approveCondition;

    public Manager(String name, Lock lock, Condition approveCondition) {
        this.name = name;
        this.lock = lock;
        this.approveCondition = approveCondition;
    }

    public void approve(LeaveRequest request) {
        lock.lock();
        try {
            System.out.println(name + " received leave request from employee: " + request.getEmployee());
            System.out.println(name + " is reviewing the request...");

            // 模拟实际的审批逻辑，根据具体情况进行判断和处理
            if (request.isApprovedByLeader() && request.getDays() > 3 && request.getDays() <= 7) {
                request.setApprovedByManager(true);
                System.out.println(name + " approved the request from employee: " + request.getEmployee());

                // 通知等待的线程继续执行
                approveCondition.signal();
            } else {
                System.out.println(name + " rejected the request from employee: " + request.getEmployee());
                request.setApprovedByManager(false);
            }
        } finally {
            lock.unlock();
        }
    }
}

public class LeaveSystemDemo {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition leaderApproveCondition = lock.newCondition();
        Condition managerApproveCondition = lock.newCondition();

        DepartmentLeader leader = new DepartmentLeader("Leader", lock, leaderApproveCondition);
        Manager manager = new Manager("Manager", lock, managerApproveCondition);

        List<LeaveRequest> leaveRequests = new ArrayList<>();
        leaveRequests.add(new LeaveRequest("John", 2));
        leaveRequests.add(new LeaveRequest("Alice", 4));
        leaveRequests.add(new LeaveRequest("Bob", 6));
        leaveRequests.add(new LeaveRequest("Tom", 10));

        for (LeaveRequest request : leaveRequests) {
            new Thread(() -> {
                leader.approve(request);

                lock.lock();
                try {
                    if (!request.isApprovedByLeader()) {
                        System.out.println("Leave request from employee: " + request.getEmployee() + " is rejected by leader, aborting...");
                        return;
                    }

                    // 等待经理审批
                    managerApproveCondition.await();

                    if (!request.isApprovedByManager()) {
                        System.out.println("Leave request from employee: " + request.getEmployee() + " is rejected by manager, aborting...");
                        return;
                    }

                    // 完成整个流程
                    System.out.println("Leave request from employee: " + request.getEmployee() + " is approved by leader and manager, process completed.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }).start();
        }

        // 模拟经理审批的等待时间
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 唤醒等待的经理审批的线程
        lock.lock();
        managerApproveCondition.signalAll();
        lock.unlock();
    }
}