桥梁设计模式

介绍

Java桥梁模式(也称桥接模式)(Bridge Pattern)是一种设计模式,它将抽象和实现分离,使它们可以独立地变化.它通过一个大类或者一系列紧密关联的类拆分成两个独立的层次结构来实现这种分离,其中一个层次结构包含抽象类或接口,另一个层次结构包含实现类.桥梁模式使得抽象类和实现类可以独立地变化,从而实现了松耦合.

在Java中,桥梁模式通常使用接口来定义抽象部分,使用抽象类来实现部分实现,并将它们通过组合的方式组合起来.抽象部分包含一个只想实现部分的引用,实现部分实现了抽象部分定义的接口.

Java桥梁模式分为以下四种角色:

1. 抽象化角色(Abstraction):定义抽象化的接口,维护一个指向实现化对象的引用.
2. 扩展抽象化角色(Refined Abstraction):扩展抽象化角色,通常是抽象化角色的子类,实现抽象化角色中的业务方法.
3. 实现化角色(Implementor):定义实现化角色的接口,这个接口不一定要与抽象化角色的接口完全一致,事实上,这两个接口可以完全不同.
4. 具体实现化角色(Concrete Implementor):具体实现化角色实现实现化角色接口,并完成具体的业务逻辑.

实现

例如,在电商网站中,可能需要支持多种支持方式,如支付宝,微信支付和银联支付等.使用桥梁模式可以轻松地添加或切换不同的支付方式,以满足用户的需求.

实现化角色

public interface PaymentImplementor {

    /**
     * 支付
     *
     * @param amount
     */
    void processPayment(double amount);
}

具体实现化角色

public class AliPaymentImplementor implements PaymentImplementor {

    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("支付宝支付:" + amount + "元...");
    }
}

public class WechatPaymentImplementor implements PaymentImplementor {

    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("微信支付:" + amount + "元...");
    }
}


public class UnionpayPaymentImplementor implements PaymentImplementor {

    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void processPayment(double amount) {
        System.out.println("银联支付:" + amount + "元...");
    }
}

抽象化角色

public abstract class Payment {

    protected PaymentImplementor implementor;

    public Payment(PaymentImplementor implementor) {
        this.implementor = implementor;
    }

    /**
     * 支付
     *
     * @param amount
     */
    public abstract void pay(double amount);
}

扩展化抽象角色

public class OnlinePayment extends Payment{

    public OnlinePayment(PaymentImplementor implementor) {
        super(implementor);
    }

    /**
     * 支付
     *
     * @param amount
     */
    @Override
    public void pay(double amount) {
        System.out.println("开始在线支付...");
        implementor.processPayment(amount);
        System.out.println("在线支付完成...");
    }
}

测试

public class Demo {

    public static void main(String[] args) {
        // 支付宝支付
        PaymentImplementor paymentImplementor = new AliPaymentImplementor();
        Payment payment = new OnlinePayment(paymentImplementor);
        payment.pay(100);
        System.out.println();
        // 微信支付
        paymentImplementor = new WechatPaymentImplementor();
        payment = new OnlinePayment(paymentImplementor);
        payment.pay(101);
        System.out.println();
        // 银联支付
        paymentImplementor = new UnionpayPaymentImplementor();
        payment = new OnlinePayment(paymentImplementor);
        payment.pay(102);
    }
}

这段代码是一个简单的实现了桥梁模式的示例.其中,Payment是抽象类,OnlinePayment是其子类,PaymentImplementor是接口,AliPaymentImplementor,UnionpayPaymentImplementor和WechatPaymentImplementor都是其实现类.通过这种方式,Payment类PayImplementor接口被解耦,可以独立地发展和扩展.

在这个示例中,Payment类是抽象化,不能被实例化,而是通过OnlinePayment子类进行实例化.OnlinePayment子类重写了pay方法,并调用implementor.processPayment方法,该方法由实现PaymentImplementor接口的类来是心啊,例如,AliPaymentImplementor,UnionpayPaymentImplementor和WechatPaymentImplementor.这种方式使得PaymentImplementor接口的实现类可以动态地注入到OnlinePayment类中,从而实现了不同的支付方式,而不需要修改OnlinePayment类.

总结

优点

• 分离抽象和实现部分,使得它们可以独立变化,从而增加了系统的灵活性和可扩展性.
• 通过抽象接口来管理对象之间的关系,更加符合面向对象编程的原则,使得系统更加易于维护和理解.
• 桥梁模式可以避免使用继承造成的类爆炸问题,因为它似乎用了组合关系.

缺点

• 桥梁模式增加了系统的复杂性,需要额外的抽象层,可能会导致系统的设计变得复杂.
• 如果不恰当地设计桥梁接口和实现类,可能会导致系统的耦合度增加.

应用场景

• 当一个类具有多个变化维度(例如,一个形状类有不同的颜色和尺寸)时,可以使用桥梁模式来将它们分离开来,从而使得系统更加灵活.
• 当需要支持不同平台,数据库或协议时,可以使用桥梁模式来封装这些实现细节,使得客户端和实现部分可以独立变化,而不影响彼此.
• 当需要运行时动态地切换实现时,可以使用桥梁模式来实现这种切换.