Mr.Raindrop

public class CompositePattern {
    public static void main(String[] args) {
        Component c0 = new Composite();
        Component c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();
    }
}
//抽象構件
interface Component {
    public void add(Component c);
    public void remove(Component c);
    public Component getChild(int i);
    public void operation();
}
//樹葉構件
class Leaf implements Component {
    private String name;
    public Leaf(String name) {
        this.name = name;
    }
    public void add(Component c) {
    }
    public void remove(Component c) {
    }
    public Component getChild(int i) {
        return null;
    }
    public void operation() {
        System.out.println("樹葉" + name + "：被訪問！");
    }
}
//樹枝構件
class Composite implements Component {
    private ArrayList<Component> children = new ArrayList<Component>();
    public void add(Component c) {
        children.add(c);
    }
    public void remove(Component c) {
        children.remove(c);
    }
    public Component getChild(int i) {
        return children.get(i);
    }
    public void operation() {
        for (Object obj : children) {
            ((Component) obj).operation();
        }
    }
}

JAVApublic interface Subject {
    void request();
}

JAVApublic class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: 處理請求");
    }
}

JAVApublic class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        // 執行預處理操作
        System.out.println("Proxy: 執行預處理操作");
        realSubject.request();
        // 執行後處理操作
        System.out.println("Proxy: 執行後處理操作");
    }
}

JAVApublic class Client {
    public static void main(String[] args) {
        // 創建真實主題對象
        Subject realSubject = new RealSubject();
        
        // 創建代理對象，並將真實主題傳遞給代理
        Subject proxy = new Proxy(realSubject);
        
        // 調用代理的方法
        proxy.request();
    }
}

//業務接口
interface DateService {
    void add();
    void del();
}
// 具體業務類
class DateServiceImplA implements DateService {
    @Override
    public void add() {
        System.out.println("成功添加！");
    }

    @Override
    public void del() {
        System.out.println("成功刪除！");
    }
}
// 代理
class ProxyInvocationHandler implements InvocationHandler {
    private DateService service;

    public ProxyInvocationHandler(DateService service) {
        this.service = service;
    }
    
    
	// this.getClass().getClassLoader() 第一个是类加载器，用来加载代理类。
    // service.getClass().getInterfaces()  被代理类实现的所有接口，使得代理对象能够提供与目标对象相同的接口视图。
    // this 当前实例（即实现了 InvocationHandler 接口的对象），用于处理对代理对象的方法调用。
    public Object getDateServiceProxy() {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(), service.getClass().getInterfaces(), this);
    }

    /* invoke 方法：
	重寫的 invoke 方法會在代理對象上調用任何方法時觸發。它接收三個參數：
	Object proxy：代表代理對象本身。
	Method method：表示正在被調用的目標方法。
	Object[] args：傳遞給目標方法的參數列表。
	在方法體內，首先通過 method.invoke(service, args); 調用了目標對象的實際方法，並將結果保存到 result 變量中。
	然後打印出一條日志信息，表明代理對象執行了某個方法，並記錄了方法名和返回值。
	最後返回目標方法的執行結果。
	*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        var result = method.invoke(service, args); // 讓service調用方法，方法返回值
        System.out.println(proxy.getClass().getName() + "代理類執行" + method.getName() + "方法，返回" + result +  "，記錄日志！");
        return result;
    }
}

//客戶端
public class Test {
    public static void main(String[] args) {
        DateService serviceA = new DateServiceImplA();
        DateService serviceProxy = (DateService) new ProxyInvocationHandler(serviceA).getDateServiceProxy();
        serviceProxy.add();
        serviceProxy.del();
    }
}

// 抽象組件
public interface INoodles {
    public void cook();
}

// 具體組件
public class Noodles implements INoodles {

    @Override
    public void cook() {
        System.out.println("的面條");
    }
}

// 抽象裝飾類
public abstract class NoodlesDecorator implements INoodles {

    private INoodles noodles;    //添加一個INoodles 的引用

    public NoodlesDecorator(INoodles noodles){     //通過構造器來設置INoodles 
        this.noodles = noodles;
    }

    @Override
    public void cook() {
        if (noodles!=null){
            noodles.cook();
        }
    }

}

// 具體裝飾類
public class EggDecorator extends NoodlesDecorator {

    public EggDecorator(INoodles noodles) {
        super(noodles);
    }

    /**
     * 重寫父類的cook方法，並添加自己的實現，調用父類的cook方法，此cook方法是通過本類的構造器
     * EggDecorator(INoodles noodles)傳入的noodles的cook操作
     */
    @Override
    public void cook() {
        System.out.println("加了一个荷包蛋");
        super.cook();
    }
}

// 具體裝飾類
public class BeefDecorator extends NoodlesDecorator {

    public BeefDecorator(INoodles noodles) {
        super(noodles);
    }

    @Override
    public void cook() {
        System.out.println("加了一斤牛肉");
        super.cook();
    }
}

public class Client {

    public static void main(String[] args) {

        INoodles noodles1 = new Noodles();
        INoodles noodles1WithEgg = new EggDecorator(noodles1);
        noodles1WithEgg.cook();
    }
}