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();
    }
}