// 定義抽象組件類，它是一個接口，定義了被裝飾對象和裝飾對象共同實現的方法
interface Component {
    void operation();
}

// 定義具體組件類，它是一個實現了抽象組件接口的具體對象
class ConcreteComponent implements Component {
    public void operation() {
        System.out.println("具體組件的操作");
    }
}

// 定義裝飾者抽象類，它繼承了抽象組件類，并持有一個抽象組件的引用
abstract class Decorator implements Component {
    protected Component component; // 通過構造函數傳入被裝飾對象

    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation(); // 可以在調用被裝飾對象的方法之前或之后添加新的行為
    }
}

// 定義具體裝飾者類，它繼承了裝飾者抽象類，并在其中添加新的行為或功能
class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    public void operation() {
        super.operation(); // 調用父類的方法
        addedBehavior(); // 調用自己的方法
    }

    public void addedBehavior() {
        System.out.println("具體裝飾者A的操作");
    }
}

// 定義具體裝飾者類，它繼承了裝飾者抽象類，并在其中添加新的行為或功能
class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    public void operation() {
        super.operation(); // 調用父類的方法
        addedBehavior(); // 調用自己的方法
    }

    public void addedBehavior() {
        System.out.println("具體裝飾者B的操作");
    }
}

// 測試代碼
public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Component component = new ConcreteComponent(); // 創建被裝飾對象
        Component decoratorA = new ConcreteDecoratorA(component); // 創建具體裝飾者A，并傳入被裝飾對象
        Component decoratorB = new ConcreteDecoratorB(decoratorA); // 創建具體裝飾者B，并傳入具體裝飾者A
        decoratorB.operation(); // 調用具體裝飾者B的方法，輸出如下：
        // 具體組件的操作
        // 具體裝飾者A的操作
        // 具體裝飾者B的操作
    }
}

// 定義一個目標類，其中有一個final方法
class Target {
    public final void finalMethod() {
        System.out.println("目標類的final方法");
    }
}

// 定義一個裝飾者抽象類，它持有一個目標對象的引用
abstract class Decorator {
    protected Target target; // 通過構造函數傳入目標對象

    public Decorator(Target target) {
        this.target = target;
    }

    public abstract void operation(); // 定義一個抽象方法，用于增強目標對象
}

// 定義一個具體裝飾者類，它繼承了裝飾者抽象類，并在其中添加新的行為或功能
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Target target) {
        super(target);
    }

    public void operation() {
        before(); // 調用自己的方法
        target.finalMethod(); // 調用目標對象的final方法
        after(); // 調用自己的方法
    }

    public void before() {
        System.out.println("調用final方法之前");
    }

    public void after() {
        System.out.println("調用final方法之后");
    }
}

// 測試代碼
public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Target target = new Target(); // 創建目標對象
        Decorator decorator = new ConcreteDecorator(target); // 創建具體裝飾者，并傳入目標對象
        decorator.operation(); // 調用具體裝飾者的方法，輸出如下：
        // 調用final方法之前
        // 目標類的final方法
        // 調用final方法之后
    }
}

// 定義一個目標類，包含一個final方法
public class Target {
    public final void sayHello() {
        System.out.println("你好，我是目標");
    }
}

// 定義一個切面類，用來編寫增強邏輯
@Aspect
public class AspectDemo {
    // 定義一個前置通知，用@Before注解指定切入點表達式，匹配目標類的final方法
    @Before("execution(final void com.example.Target.sayHello())")
    public void beforeAdvice() {
        System.out.println("建議之前：這是最后的方法");
    }
}

// 定義一個測試類，用來創建代理對象并調用目標方法
public class TestDemo {
    public static void main(String[] args) {
        // 創建目標對象
        Target target = new Target();
        // 創建代理工廠
        AspectJProxyFactory factory = new AspectJProxyFactory(target);
        // 添加切面類
        factory.addAspect(AspectDemo.class);
        // 獲取代理對象
        Target proxy = factory.getProxy();
        // 調用代理對象的final方法
        proxy.sayHello();
    }
}
/**
建議之前：這是最后的方法
你好，我是目標**/