23种设计模式

小丑的忧伤

已于 2022-03-03 15:52:05 修改

阅读量442

点赞数

文章标签： java elasticsearch 开发语言

于 2022-03-03 13:48:51 首次发布

原文链接：https://www.runoob.com/design-pattern/design-pattern-tutorial.html

版权

内容参考：菜鸟教程

单例模式

1：单例类只能有一个实例
2：单例类必须自己创建自己的唯一实例
3：单例类必须给其使用着提供这一实例

懒汉式

懒加载初始化，多线线程业务下需要加锁synchronized
加锁之后效率就会降低，建议不要在多线程业务中使用

public class SingleDemo {
    private static SingleDemo demo;
    // 私有化无参构造，只能在当前类中使用
    private SingleDemo() {}
    public static synchronized SingleDemo getInstance() {
        if (demo == null) {
            return new SingleDemo();
        }
        return demo;
    }
}
public class SingleDemo {
    private static SingleDemo demo;
    // 私有化无参构造，只能在当前类中使用
    private SingleDemo() {}
    public static SingleDemo getInstance() {
        if (demo == null) {
            return new SingleDemo();
        }
        return demo;
    }
}

饿汉式

非懒加载，线程安全
效率高，易产生垃圾

public class SingleDemo {
	// 类加载时初始化
    private static SingleDemo demo = new SingleDemo();
    // 私有化无参构造，只能在当前类中使用
    private SingleDemo(){}
    public static SingleDemo getInstance(){
        return demo;
    } 
}

双检锁/双重校验锁

懒加载，线程安全，在多线程情况下也能保持高效

public class SingleDemo {
    private static SingleDemo demo;
    // 无参构造私有化，只能在当前类中使用
    private SingleDemo() {}
    public static SingleDemo getInstance() {
        // 如果不是null，直接返回对象
        if (demo== null) {
            synchronized (SingleDemo.class) {
                // 如果不是null，直接返回对象
                if (demo== null) {
                    demo= new SingleDemo();
                }
            }
        }
        return demo;
    }
}

总结：将对象私有化，外部使用该对象时，只能通过静态方法来使用

工厂模式

主要解决接口选择的问题，前提是有明确的条件
以系统支付为例：

1：创建支付接口

public interface IPayService {

    void pay(String payType);
    
}

2：创建支付业务类，并实现支付接口

public class AliPayService implements IPayService {
    @Override
    public void pay(String payType) {
        System.out.println("支付宝支付");
    }
}

public class WechatPayService implements IPayService {
    @Override
    public void pay(String payType) {
        System.out.println("微信支付");
    }
}

public class OtherPayService implements IPayService {
    @Override
    public void pay(String payType) {
        System.out.println("其他支付");
    }
}

3：创建工厂类

public class PayFactoryBean {
    public static IPayService getPay(String payType) {
        if (StringUtils.isEmpty(payType)) {
            throw new RuntimeException("支付方式非法");
        }
        if (payType.equals(PayConstant.ALI_PAY)) {
            return new AliPayService();
        } else if (payType.equals(PayConstant.WECHAT_PAY)) {
            return new WechatPayService();
        } else if (payType.equals(PayConstant.OTHER_PAY)) {
            return new OtherPayService();
        }
        return null;
    }

    public static void main(String[] args) {
        PayBean payBean = new PayBean();
        IPayService pay = getPay("WECHAT_PAY");
        if (pay != null) {
            pay.pay(payBean);
        }else {
            System.out.println("支付方式非法");
        }
    }
}

结构
在这里插入图片描述

总结：正常的一个接口，多个实现。通过工厂类进行标识、类名等方式判断并返回对应的实现类，然后处理业务，在外界看来，只要满足条件即可执行对应业务

适配器模式

是作为两个不兼容的接口之间的桥梁
主要解决在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足的。
业务感觉好乱，建议没必要不要使用，不要过多使用
以支付为例：

1：创建接口，对内适配的调用接口

public interface AdapterPayService {
    void pay(String payType, String amount);
}

2：创建接口，不同的支付接口

public interface PayService {
    /**
     * 微信支付
     * @param amount
     */
    void wechatPay(String amount);
    /**
     * 支付宝支付
     * @param amount
     */
    void aliPay(String amount);
    /**
     * 其他支付
     * @param amount
     */
    void otherPay(String amount);
}

3：实现2的接口

public class AliPayService implements PayService {

    @Override
    public void wechatPay(String amount) {}
	// 只处理当前实现类单一业务接口
    @Override
    public void aliPay(String amount) {
        System.out.println("阿里支付："+amount);
    }
    @Override
    public void otherPay(String amount) {}
}

public class OtherPayService implements PayService {
    
    @Override
    public void wechatPay(String amount) {}

    @Override
    public void aliPay(String amount) {}

    @Override
    public void otherPay(String amount) {
        System.out.println("其他支付："+amount);
    }
}

public class WechatPayService implements PayService {
    @Override
    public void wechatPay(String amount) {
        System.out.println("微信支付："+amount);
    }
    @Override
    public void aliPay(String amount) {}

    @Override
    public void otherPay(String amount) {}
}

3：创建实现AdapterPayService 的适配器类

public class AdapterPayServiceImpl implements AdapterPayService {

    private PayService payService;
	// 适配选择
    public AdapterPayServiceImpl(String payType){
        if (payType.equals(PayConstant.OTHER_PAY)){
            payService = new OtherPayService();
        }else if (payType.equals(PayConstant.WECHAT_PAY)){
            payService = new WechatPayService();
        }else if (payType.equals(PayConstant.ALI_PAY)){
            payService = new AliPayService();
        }
    }
	// 适配调用
    @Override
    public void pay(String payType, String amount) {
        if (payType.equals(PayConstant.OTHER_PAY)){
            payService.otherPay(amount);
        }else if (payType.equals(PayConstant.WECHAT_PAY)){
            payService.wechatPay(amount);
        }else if (payType.equals(PayConstant.ALI_PAY)){
            payService.aliPay(amount);
        }
    }
}

4：创建一个对外访问的类，实现AdapterPayService

public class AdapterPayServiceImpl2 implements AdapterPayService {
    AdapterPayService adapterPayService;
    @Override
    public void pay(String payType, String amount) {
        adapterPayService = new AdapterPayServiceImpl(payType);
        adapterPayService.pay(payType,amount);
    }

    public static void main(String[] args) {
        AdapterPayServiceImpl2 adapterPayServiceImpl2 = new AdapterPayServiceImpl2();
        adapterPayServiceImpl2.pay("WECHAT_PAY","100元");
        adapterPayServiceImpl2.pay("ALI_PAY","10元");
        adapterPayServiceImpl2.pay("OTHER_PAY","101元");
    }
}

在这里插入图片描述

总结：感觉和工厂模式业务逻辑是一致的，但是比工厂模式复杂且代码多，且不易维护。两个接口多个实现，再创建一个类似工厂的对外适配器

中介者模式

把对象要做的事情交给中介来处理，
用来降低多个对象和类之间的通信复杂性
用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。

结构：
在这里插入图片描述
1：创建中介类

public class MediatorDemo {
    public static void sayHello(String userName,String tall){
        System.out.println(userName+"："+tall);
    }
}

2：创建对象

public class MediatorBean {

    private String userName;
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public MediatorBean(String userName){
        this.userName = userName;
    }
    public void sayHello(String tall){
        MediatorDemo.sayHello(userName,tall);
    }
    public static void main(String[] args) {
        MediatorBean zz = new MediatorBean("郑州");
        MediatorBean rz = new MediatorBean("汝州");
        zz.sayHello("你好！汝州");
        rz.sayHello("你好！郑州");
    }
}