如何用装饰者模式代理final方法

装饰者模式

装饰者模式是一种结构型设计模式，它可以在不改变对象的原有结构的情况下，动态地给对象添加新的功能和职责。装饰者模式的核心思想是使用组合和委托的方式，让装饰者类持有一个被装饰对象的引用，并在调用被装饰对象的方法之前或之后添加新的行为。这样，装饰者类可以在运行时动态地修改被装饰对象的行为，而不需要创建大量的子类。

代码示例：

// 定义抽象组件类，它是一个接口，定义了被装饰对象和装饰对象共同实现的方法
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方法。
• 然后创建一个装饰者类，实现这个接口，并在构造函数中传入一个目标类的实例。在装饰者类中，可以为每个方法添加代理逻辑，比如打印日志、检查权限等。然后，可以调用目标类的对应方法，或者直接返回结果。
• 最后，创建一个装饰者类的实例，并传入一个目标类的实例。这样，就可以通过装饰者类来代理目标类的所有方法，包括final方法。

代码示例：

假设有一个目标类叫做HelloService，它有一个final方法叫做sayHello：

// 定义一个目标类，其中有一个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方法，您可能需要为每个方法都创建一个装饰者类，这会增加代码的复杂度和冗余。

装饰者模式和JDK代理的区别：

• 装饰者模式和JDK代理都是使用组合而不是继承来扩展对象的功能，但是它们的目的和实现方式不同。
• 装饰者模式是为了增强对象本身的功能，而JDK代理是为了控制对对象的访问，比如添加权限检查、日志记录等。
• 装饰者模式是客户端透明的，也就是说客户端不需要知道被装饰的对象是怎么被装饰的，只需要使用它的增强功能即可。而JDK代理是客户端不透明的，也就是说客户端只能看到代理对象，而不能直接访问被代理的对象。
• 装饰者模式是动态的，也就是说可以在运行时根据需要给对象添加不同的装饰者。而JDK代理是静态的，也就是说在编译时就确定了代理对象和被代理对象的关系，不能在运行时改变。
• 装饰者模式和JDK代理都需要实现一个共同的接口，以保证类型的一致性。但是装饰者模式需要在构造函数中传入被装饰的对象，而JDK代理则需要通过反射机制来创建被代理的对象。

实际上可以使用Spring AOP实现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();
    }
}
/**
建议之前：这是最后的方法
你好，我是目标**/