代理模式和装饰器模式区别

参考https://blog.csdn.net/andong154564667/article/details/80258061

 

根据自己的理解，做了一点点修改。

两种模式的作用：用于AOP，不改变原有实现的情况下，进行功能扩展，proxy模式比较适合固定的AOP功能需求，decorator比较适合动态扩展的AOP需求

1. 同样的事情，proxy模式和decorator模式都能实现，都是用来实现AOP的，关键在于可扩展性方便的区别，是否更满足单一职责原则和开闭原则

来选择哪种模式

2.proxy模式是，对于需要代理的类A，A可以是interface，提供一个代理类ProxyA，A想要增加的功能都在ProxyA不停的增加根据不断的需求。

3. decorator模式是，对于需要装饰的类A，A可以是interface，如果A需要增加一个功能func1，则提供一个装饰类Func1DecoratorA，如果A还需要增加一个功能func2，则提供一个装饰类Func2DecoratorA，如果A还需要增加一个功能func3，则提供一个装饰类Func3DecoratorA，以此类推...，对于每一个单一的功能扩展需要，都一个FuncNDecoratorA，这样

就能保证满足开闭原则和单一职责原则。

通过代理模式实现

套用https://blog.csdn.net/andong154564667/article/details/80258061的例子：

public interface Greeting {
 
    void sayHello(String name);
}

public class GreetingImpl implements Greeting {
 
    @Override
    public void sayHello(String name) {
        System.out.println("Hello! " + name);
    }
}

public class GreetingProxy implements Greeting {
 
    private Greeting greetingImpl;
 
    public GreetingProxy(Greeting greeting) {
        this.greetingImpl = greeting;
    }
 
    @Override
    public void sayHello(String name) {
        before();
        func1();
        func2();
        func3();
        greetingImpl.sayHello(name);
        after();
    }
 
    private void before() {
        System.out.println("Before");
    }
    private void func1() {
        System.out.println("func1");
    }
    private void func2() {
        System.out.println("func2");
    }
    private void func3() {
        System.out.println("func3");
    }
    private void after() {
        System.out.println("after");
    }
}

注意，GreetingProxy的构造函数的入参从具体实现GreetingImpl改成了接口Greeting, 新的功能扩展func1， func2， func3都是直接修改GreetingProxy类中的sayHello方法。这样会破坏单一职责原则（GreetingProxy包含的功能越来越多）和开闭原则（每一次新的功能需求都得修改原来的GreetingProxy类）

public class ClientProxy {
 
    public static void main(String[] args) {
        Greeting greeting = new GreetingProxy(new GreetingImpl());
        greeting.sayHello("Jack");
    }
}

而通过decorator模式，则：

public abstract class GreetingDecorator implements Greeting {
 
    private Greeting greeting;
 
    public GreetingDecorator(Greeting greeting) {
        this.greeting = greeting;
    }
 
    @Override
    public void sayHello(String name) {
        greeting.sayHello(name);
    }
}

GreetingDecorator 只是一个抽象的装饰器，要想真正使用它，您得去继承它，实现具体的装饰器才行，他存在的作用相当于一个decorator parent类，用来继承，同时用来调用传入的greeting的功能（即某个greeting的具体实现的原始功能）

public class GreetingBefore extends GreetingDecorator {
 
    public GreetingBefore(Greeting greeting) {
        super(greeting);
    }
 
    @Override
    public void sayHello(String name) {
        before();
        super.sayHello(name);
    }
 
    private void before() {
        System.out.println("Before");
    }
}

public class GreetingAfter extends GreetingDecorator {
 
    public GreetingAfter(Greeting greeting) {
        super(greeting);
    }
 
    @Override
    public void sayHello(String name) {
        super.sayHello(name);
        after();
    }
 
    private void after() {
        System.out.println("After");
    }
}

public class GreetingFunc1 extends GreetingDecorator {
 
    public GreetingFunc1 (Greeting greeting) {
        super(greeting);
    }
 
    @Override
    public void sayHello(String name) {
        super.sayHello(name);
        func1();
    }
 
    private void func1() {
        System.out.println("func1");
    }
}
public class GreetingFunc2 extends GreetingDecorator {
 
    public GreetingFunc2 (Greeting greeting) {
        super(greeting);
    }
 
    @Override
    public void sayHello(String name) {
        super.sayHello(name);
        func2();
    }
 
    private void func2() {
        System.out.println("func2");
    }
}

public class GreetingFunc3 extends GreetingDecorator {
 
    public GreetingFunc3 (Greeting greeting) {
        super(greeting);
    }
 
    @Override
    public void sayHello(String name) {
        super.sayHello(name);
        func3();
    }
 
    private void func3() {
        System.out.println("func3");
    }
}

测试类：

public class ClientDecorator {
 
    public static void main(String[] args) {
        Greeting greeting = new GreetingAfter(new GreetingBefore(new GreetingImpl()));
        greeting.sayHello("Jack brfore after");
        Greeting greeting = new GreetingAfter(new GreetingFunc1(new GreetingBefore(new GreetingImpl())));
        greeting.sayHello("Jack with brfore func1 after ");
        Greeting greeting = new GreetingAfter(new GreetingFunc2(new GreetingFunc1(new GreetingBefore(new GreetingImpl()))));
        greeting.sayHello("Jack with brfore func1 func2 after");
    }
}