// 抽象處理者
public abstract class Handler {
    protected Handler successor;
    
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    
    public abstract void handleRequest(Request request);
}

// 具體處理者A
public class ConcreteHandlerA extends Handler {
    public void handleRequest(Request request) {
        if (request.getType().equals("TypeA")) {
            System.out.println("HandlerA處理請(qǐng)求: " + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具體處理者B
public class ConcreteHandlerB extends Handler {
    public void handleRequest(Request request) {
        if (request.getType().equals("TypeB")) {
            System.out.println("HandlerB處理請(qǐng)求: " + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 請(qǐng)求對(duì)象
public class Request {
    private String type;
    private String content;
    
    public Request(String type, String content) {
        this.type = type;
        this.content = content;
    }
    
    // getter方法
    public String getType() { return type; }
    public String getContent() { return content; }
}

// 使用示例
Handler h1 = new ConcreteHandlerA();
Handler h2 = new ConcreteHandlerB();
h1.setSuccessor(h2);

Request request = new Request("TypeB", "測(cè)試請(qǐng)求");
h1.handleRequest(request);

public interface Handler {
    boolean handle(Request request);
}

public class AuthHandler implements Handler {
    public boolean handle(Request request) {
        if (!request.isAuthenticated()) {
            System.out.println("認(rèn)證失敗");
            return false;
        }
        System.out.println("認(rèn)證通過");
        return true;
    }
}

public class LoggingHandler implements Handler {
    public boolean handle(Request request) {
        System.out.println("記錄請(qǐng)求日志: " + request);
        return true;
    }
}

public class ProcessingHandler implements Handler {
    public boolean handle(Request request) {
        System.out.println("處理業(yè)務(wù)請(qǐng)求: " + request);
        return true;
    }
}

public class HandlerChain {
    private List<Handler> handlers = new ArrayList<>();
    
    public HandlerChain addHandler(Handler handler) {
        handlers.add(handler);
        return this;
    }
    
    public boolean process(Request request) {
        for (Handler handler : handlers) {
            if (!handler.handle(request)) {
                return false;
            }
        }
        return true;
    }
}

// 使用示例
HandlerChain chain = new HandlerChain()
    .addHandler(new AuthHandler())
    .addHandler(new LoggingHandler())
    .addHandler(new ProcessingHandler());

Request request = new Request("test");
chain.process(request);

public interface Filter {
    void doFilter(HttpRequest request, HttpResponse response, FilterChain chain);
}

public class AuthenticationFilter implements Filter {
    public void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) {
        if (!request.isAuthenticated()) {
            response.setStatus(401);
            return;
        }
        System.out.println("認(rèn)證通過");
        chain.doFilter(request, response);
    }
}

public class LoggingFilter implements Filter {
    public void doFilter(HttpRequest request, HttpResponse response, FilterChain chain) {
        System.out.println("請(qǐng)求日志: " + request.getPath());
        chain.doFilter(request, response);
    }
}

public class FilterChain {
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;
    
    public FilterChain addFilter(Filter filter) {
        filters.add(filter);
        return this;
    }
    
    public void doFilter(HttpRequest request, HttpResponse response) {
        if (index < filters.size()) {
            Filter filter = filters.get(index++);
            filter.doFilter(request, response, this);
        }
    }
}

public abstract class Approver {
    protected Approver successor;
    protected String name;
    
    public Approver(String name) {
        this.name = name;
    }
    
    public void setSuccessor(Approver successor) {
        this.successor = successor;
    }
    
    public abstract void processRequest(PurchaseRequest request);
}

public class DepartmentHead extends Approver {
    public DepartmentHead(String name) {
        super(name);
    }
    
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 5000) {
            System.out.println("部門主管" + name + "審批采購單: " + request);
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

public class VicePresident extends Approver {
    public VicePresident(String name) {
        super(name);
    }
    
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() < 10000) {
            System.out.println("副總裁" + name + "審批采購單: " + request);
        } else if (successor != null) {
            successor.processRequest(request);
        }
    }
}

// 使用示例
Approver zhangsan = new DepartmentHead("張三");
Approver lisi = new VicePresident("李四");
zhangsan.setSuccessor(lisi);

PurchaseRequest request = new PurchaseRequest(8000, "購買設(shè)備");
zhangsan.processRequest(request);

public interface ExceptionHandler {
    void handle(Exception e, ExceptionHandlerChain chain);
}

public class NullPointerHandler implements ExceptionHandler {
    public void handle(Exception e, ExceptionHandlerChain chain) {
        if (e instanceof NullPointerException) {
            System.out.println("處理空指針異常");
        } else {
            chain.handle(e);
        }
    }
}

public class IOExceptionHandler implements ExceptionHandler {
    public void handle(Exception e, ExceptionHandlerChain chain) {
        if (e instanceof IOException) {
            System.out.println("處理IO異常");
        } else {
            chain.handle(e);
        }
    }
}

public class DefaultExceptionHandler implements ExceptionHandler {
    public void handle(Exception e, ExceptionHandlerChain chain) {
        System.out.println("默認(rèn)異常處理");
    }
}

public class ExceptionHandlerChain {
    private List<ExceptionHandler> handlers = new ArrayList<>();
    private int index = 0;
    
    public ExceptionHandlerChain addHandler(ExceptionHandler handler) {
        handlers.add(handler);
        return this;
    }
    
    public void handle(Exception e) {
        if (index < handlers.size()) {
            ExceptionHandler handler = handlers.get(index++);
            handler.handle(e, this);
        }
    }
}

public interface Function<T, R> {
    R apply(T t, Function<T, R> next);
}

public class FunctionChain<T, R> {
    private List<Function<T, R>> functions = new ArrayList<>();
    
    public FunctionChain<T, R> addFunction(Function<T, R> function) {
        functions.add(function);
        return this;
    }
    
    public R execute(T input) {
        if (functions.isEmpty()) return null;
        
        Function<T, R> first = functions.get(0);
        return first.apply(input, (t, n) -> {
            int nextIndex = functions.indexOf(n) + 1;
            if (nextIndex < functions.size()) {
                return functions.get(nextIndex).apply(t, functions.get(nextIndex));
            }
            return null;
        });
    }
}

public abstract class InterruptibleHandler {
    private InterruptibleHandler next;
    
    public void setNext(InterruptibleHandler next) {
        this.next = next;
    }
    
    public final void handle(Request request) {
        if (!doHandle(request) && next != null) {
            next.handle(request);
        }
    }
    
    protected abstract boolean doHandle(Request request);
}