3 ans de travail en mode décorateur incontournable

D'accord, entrons dans notre sujet Aujourd'hui, je vais partager avec vous 装饰器模式 les modèles de conception. Utilisez des histoires de vie appropriées et des scénarios de projet réels pour parler du modèle de conception, et enfin résumez le modèle de conception en une phrase.

Histoire

Comme le dit le vieil adage : Un homme compte sur ses vêtements et un cheval compte sur sa selle. Familiarisons-nous d'abord avec le contexte de cette phrase :

Les gens comptent sur les vêtements, les chevaux comptent sur les selles et les chiens comptent sur les cloches pour courir joyeusement. Elle vient du dixième chapitre du « Pavillon Wanghu » de Shen Zijin : « Néanmoins. , le Bouddha s'appuie sur des vêtements en or « Les gens comptent sur les vêtements, et la toilette est également très importante. » Volume 1 de « Des mots éternels pour éveiller le monde » : « Deux magistrats de comté se disputent les orphelins du mariage vertueux : « Comme le dit le dicton : « Les bouddhas sont habillés d'or, les gens sont habillés de vêtements et de nombreuses personnes dans le monde ont les yeux superficiels. " , seulement de la peau, pas d'os. " " Comme le dit le proverbe, les adultes comptent sur les vêtements et les chevaux.

Cette histoire classique me rappelle un modèle de design : le modèle décorateur.

Quel est le motif décorateur ? S'il vous plaît, écoutez Lao Tian parler lentement.

Aperçu du modèle Décorateur

Le modèle Décorateur est également appelé modèle Wrapper, qui fait référence à l'ajout dynamique de certains éléments à un objet sans modifier l'objet d'origine. Responsabilités supplémentaires. En termes d'ajout de fonctionnalités, le modèle de décorateur est plus flexible que la génération de sous-classes et constitue un modèle de conception structurelle.

Anglais :

Attachez dynamiquement des responsabilités supplémentaires à un objet en conservant la même interface. Les décorateurs offrent une alternative flexible au sous-classement pour étendre les fonctionnalités de l'objet. Par conséquent, le cœur du motif décoratif est l’extension fonctionnelle. Utilisez le modèle de décorateur pour étendre de manière transparente et dynamique les fonctionnalités d’une classe.

Cas de la vie Une maison brute a l'air très moche avant la décoration, mais tant qu'elle est légèrement décorée, elle sera bien plus belle, et elle pourra se baigner, dormir, cuisiner, etc., mais l'essence est toujours une maison.

Implémentation universelle du modèle de décorateur Nous utilisons toujours du code pour l'implémenter. Les programmeurs aiment d'abord faire une démo, puis l'étudier lentement.

//抽象组件
public abstract class Component {
    public abstract void operation();
}
//具体组件
public class ConcreteComponent extends Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}
//装饰器抽象
public abstract class Decorator extends Component {

    protected Component component;

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

    @Override
    public void operation() {
        component.operation();
    }
}
//具体装饰器
public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("开始前搞点事");
        super.operation();
        System.out.println("结束后搞点事");
    }
}
//测试
public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteDecorator(new ConcreteComponent());
        component.operation();
    }
}

Copier après la connexion

开始前搞点事
ConcreteComponent operation
结束后搞点事

Diagramme UML du motif décoratif

/**
 * @author 田先生
 * @date 2021-06-02
 *
 * 欢迎关注公众号：java后端技术全栈
 */
public interface IOrderPayService {
    String payment(Long orderId, BigDecimal amount);
}
public class OrderPayServiceImpl implements IOrderPayService {

    @Override
    public String payment(Long orderId, BigDecimal amount) {
        //先调用余额查询是否足够
        System.out.println("发起支付，订单号：" + orderId + "， 支付金额：" + amount.toString());
        //调用支付系统
        String result = "订单id=" + orderId + "支付完成";
        System.out.println("支付结果：" + result);
        return result;
    }
}
public class OrderClient {
    public static void main(String[] args) {
        IOrderPayService orderPayService = new OrderPayServiceImpl();
        orderPayService.payment(10001L,new BigDecimal("5000"));
    }
}

发起支付，订单号：10001， 支付金额：5000
支付结果：订单id=10001支付完成

/**
 * @author 田先生
 * @date 2021-06-02
 *
 * 欢迎关注公众号：java后端技术全栈
 */
public class OrderPayDecorator implements IOrderPayService {

    private IOrderPayService orderPayService;

    public OrderPayDecorator(IOrderPayService orderPayService) {
        this.orderPayService = orderPayService;
    }

    @Override
    public String payment(Long orderId, BigDecimal amount) {
        System.out.println("把这个订单信息（发起支付）" + "订单id=" + orderId + "支付金额=" + amount.toString() + " 【发送给MQ】");
        String result = orderPayService.payment(orderId, amount);
        System.out.println("把订单支付结果信息" + result + " 【发送给MQ】");
        return result;
    }
}
public class OrderClient {
    public static void main(String[] args) {
        IOrderPayService orderPayService =new OrderPayDecorator(new OrderPayServiceImpl());
        orderPayService.payment(10001L,new BigDecimal("5000"));
    }
}

把这个订单信息（发起支付）订单id=10001支付金额=5000 【发送给MQ】
发起支付，订单号：10001， 支付金额：5000
支付结果：订单id=10001支付完成
把订单支付结果信息订单id=10001支付完成 【发送给MQ】

public class TransactionAwareCacheDecorator implements Cache {
    private final Cache targetCache;
    //构造方法入参类型为自己的父类（接口类型）
    public TransactionAwareCacheDecorator(Cache targetCache) {
        Assert.notNull(targetCache, "Target Cache must not be null");
        this.targetCache = targetCache;
    }

    public Cache getTargetCache() {
        return this.targetCache;
    }
    //...
}

public class CachingExecutor implements Executor {
  //持有组件对象
  private Executor delegate;
  private TransactionalCacheManager tcm = new TransactionalCacheManager();
    //构造方法，传入组件对象
  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }
  @Override
  public int update(MappedStatement ms, Object parameterObject) throws SQLException {
      //转发请求给组件对象，可以在转发前后执行一些附加动作
    flushCacheIfRequired(ms);
    return delegate.update(ms, parameterObject);
  }
  //...
 }