• 常用设计模式+代理模式【Design Pattern】【我终于懂设计模式了】

    目录

    1什么是设计模式？

    2为什么使用设计模式？

    3常用设计模式

    4工厂模式【简单工厂模式】

    3创建一个手机工厂创建手机对象

    4进行测试

    5工厂方法模式【解决简单工厂的不足，避免增加新的对象修改原有代码】

    6抽象工厂模式【其实就是在工厂接口中新增一个抽象方法（新增ipad）】

    6模板模式【支付宝微信】

    7代理模式【终于搞懂了】

    8Spring中使用的是那种代理模式？

    9适配器模式

    10观察者模式【监听器模式】：

    11策略模式【这个回看上面模板模式举例中采用了策略模式】

    1什么是设计模式？

     官方解释：设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。

    人话：设计模式就是软件开发人员在开发过程中遇到问题的解决方案。

    2为什么使用设计模式？

            设计模式就是大佬写代码总结的优秀经验，总结下来了。我们把它拿到我们项目中使用，让我们的代码更加优美，高效，可读性高。

    3常用设计模式

    单例模式【懒汉式+饿汉式+枚举】

    单例模式和简单工厂模式..._GuGuBirdXXXX的博客-CSDN博客

    工厂模式【Factory，ThreadFactory，SqlSessionFactory，BeanFactory】

    工厂方法模式

    抽象工厂模式

    模板模式

    代理模式

    适配器模式

    监听器模式

    策略模式

    4工厂模式【简单工厂模式】

            创建简单对象的工厂，通过参数进行业务逻辑判读创建不同的对象。【所有的对象都是一个工厂创建】,需要在工厂增加新的对象创建的时候需要修改原本的代码。

    简单工厂的优缺点

    • 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

    • 缺点：所有的对象都用了同一个工厂去创建，试想一下如果我要增加一个手机类型，那么我的创建实例的工厂需要重新修改【违背了ocp【open-closed principle】开闭原则 】。

    简单代码举例：

    业务需求：小米手机和华为手机都有相同的功能可以打电话和发短信，然后这时候就认为不能打电话和发短信的手机都不能算是手机。然后手机的生产需要依托于手机工厂进行生产。

    1定义一个手机接口，实现了该接口，重写了里面的方法才能表示是手机。

    1. //手机的接口
    2. public interface IPhone {
    3.     void call();
    4.     void sendMsg();
    5. }

    2定义小米和华为手机的类去实现手机接口

    1. public class MIPhone implements IPhone{
    2.     @Override
    3.     public void call() {
    4.         System.out.println("小米手机在打电话");
    5.     }
    6.  
    7.     @Override
    8.     public void sendMsg() {
    9.         System.out.println("小米手机在发短信");
    10.     }
    11. }
    1. public class HWPhone implements IPhone{
    2.     @Override
    3.     public void call() {
    4.         System.out.println("华为手机再打电话");
    5.     }
    6.  
    7.     @Override
    8.     public void sendMsg() {
    9.         System.out.println("华为手机在发短信");
    10.     }
    11. }

    3创建一个手机工厂创建手机对象

    1. /**
    2.  * 工厂模式==简单工厂模式
    3.  * */
    4. public class PhoneFactory {
    5.     public IPhone createPhone(String type){
    6.         // 采用多态的方式进行接收
    7.         if(type.equals("mi"))return new MIPhone();
    8.         if(type.equals("hw"))return new HWPhone();
    9.         return null;
    10.     }
    11. }

    4进行测试

    1. public class FactoryTest {
    2.     public static void main(String[] args) {
    3.         PhoneFactory phoneFactory = new PhoneFactory();
    4.         IPhone mi = phoneFactory.createPhone("mi");
    5.         IPhone hw = phoneFactory.createPhone("hw");
    6.         mi.call();
    7.         hw.call();
    8.     }
    9. }

    5工厂方法模式【解决简单工厂的不足，避免增加新的对象修改原有代码】

            每个手机对象都有对应的工厂进行创建，新增手机对象时不会修改原本的代码【扩展性比较强】。

     1定义一个手机接口，实现了该接口，重写了里面的方法才能表示是手机。

    1. //手机的接口
    2. public interface IPhone {
    3.     void call();
    4.     void sendMsg();
    5. }

    2定义小米和华为手机的类去实现手机接口

    1. public class MIPhone implements IPhone{
    2.     @Override
    3.     public void call() {
    4.         System.out.println("小米手机在打电话");
    5.     }
    6.  
    7.     @Override
    8.     public void sendMsg() {
    9.         System.out.println("小米手机在发短信");
    10.     }
    11. }
    1. public class HWPhone implements IPhone{
    2.     @Override
    3.     public void call() {
    4.         System.out.println("华为手机再打电话");
    5.     }
    6.  
    7.     @Override
    8.     public void sendMsg() {
    9.         System.out.println("华为手机在发短信");
    10.     }
    11. }

    3为每个手机对象分别创建对应的手机工厂【华为小米】

    1. public class MIFactory implements IFactory {
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new MIPhone();
    5.     }
    6. }
    1. public class HWFactory implements IFactory{
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new HWPhone();
    5.     }
    6. }

    4进行测试

    1. public class FactoryTest {
    2.     public static void main(String[] args) {
    3.         // 每个对象单独由对应的工厂进行创建
    4.         IPhone hwphone = new HWFactory().createPhone();
    5.         IPhone miphone = new MIFactory().createPhone();
    6.         hwphone.call();
    7.         miphone.call();
    8.     }
    9. }

    6抽象工厂模式【其实就是在工厂接口中新增一个抽象方法（新增ipad）】

            上面两种模式都只是针对一类产品Phone（AbstractProduct），如果要生成另一种产品，应该怎么表示呢？

            抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建

    1创建手机和ipad和工厂的接口【接口中的抽象方法必须实现】

    1. public interface IPad {
    2.     void watchTV();
    3. }
    1. //手机的接口
    2. public interface IPhone {
    3.     void call();
    4.     void sendMsg();
    5. }
    23个设计模式的visio图（vsd）
    rar 4星 超过75%的资源 1.75MB
    下载
    1. //工厂接口
    2. public interface IFactory {
    3.     IPhone createPhone();
    4.     IPad createPad();
    5. }

    2ipad对象和手机对象和工厂对象去实现对应的接口

    1. public class MIPad implements IPad {
    2.     @Override
    3.     public void watchTV() {
    4.         System.out.println("我是小米PAD看片");
    5.     }
    6. }
    1. public class MIPhone implements IPhone {
    2.     @Override
    3.     public void call() {
    4.         System.out.println("小米手机在打电话");
    5.     }
    6.  
    7.     @Override
    8.     public void sendMsg() {
    9.         System.out.println("小米手机在发短信");
    10.     }
    11. }
    1. public class MIFactory implements IFactory {
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new MIPhone();
    5.     }
    6.  
    7.     @Override
    8.     public IPad createPad() {
    9.         return new MIPad();
    10.     }
    11. }
    1. ​public class MIFactory implements IFactory {
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new MIPhone();
    5.     }
    6.  
    7.     @Override
    8.     public IPad createPad() {
    9.         return new MIPad();
    10.     }
    11. }
    12.  
    13. ​

      3为每个手机对象分别创建对应的手机工厂【华为小米】

    1. public class HWFactory implements IFactory {
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new HWPhone();
    5.     }
    6.  
    7.     @Override
    8.     public IPad createPad() {
    9.         return new HWPad();
    10.     }
    11. }
    1. public class MIFactory implements IFactory {
    2.     @Override
    3.     public IPhone createPhone() {
    4.         return new MIPhone();
    5.     }
    6.  
    7.     @Override
    8.     public IPad createPad() {
    9.         return new MIPad();
    10.     }
    11. }

    4进行测试

    1. public class FactoryTest {
    2.     public static void main(String[] args) {
    3.         IPhone hwphone = new HWFactory().createPhone();
    4.         IPhone miphone = new MIFactory().createPhone();
    5.         hwphone.call();
    6.         miphone.call();
    7.  
    8.         //=============
    9.         IPad hpad = new HWFactory().createPad();
    10.         IPad mpad = new MIFactory().createPad();
    11.         hpad.watchTV();
    12.         mpad.watchTV();
    13.     }
    14. }

    6模板模式【支付宝微信】

            抽取一个抽象类，相似的方法定义成抽象方法（public abstract ），通过具体的子类中去实现。这就是模板方法。

    比如支付宝微信都有
//1.支付申请
//2.支付回调
//3.查询订单
//4.订单退款

    就可以使用模板技术。

    1

    1. public interface PayStrategy {
    2.     void applyPay();
    3. }

    给支付模板的支付申请定义一个接口

    2抽取一个支付模板【其中的方法是微信和支付宝都会使用】

    1. //1.支付申请
    2. //2.支付回调
    3. //3.查询订单
    4. //4.订单退款
    5. // 抽象类，继承了该类其中的抽象方法必须重写，普通方法可以不重写
    6. public abstract class PayTemplate implements PayStrategy{
    7.  
    8.     public void applyPay(){
    9.         System.out.println("发起支付申请");
    10.     }
    11.     // 模板模式，抽取一个抽象类，将相同的方法定义成抽象方法【模板技术】，继承过后采用不用逻辑进行重          //写方法（策略模式）
    12.     public abstract void notifys();
    13.     public abstract void queryOrder();
    14.     public abstract void refund();
    15.  
    16.     public void doPayProcess(){
    17.         applyPay();
    18.         notifys();
    19.         queryOrder();
    20.         refound();
    21.     }
    22.  
    23. }

    3微信和支付宝继承支付模板，重写里面的方法

    1. //1.支付申请
    2. //2.支付回调
    3. //3.查询订单
    4. //4.订单退款
    5. // 策略模式，执行相同的方法采用不同的策略进行实现。
    6. public class WxpayStrategy extends PayTemplate {
    7.  
    8.      
    9.     @Override
    10.     public void applyPay() {
    11.         // 直接调用父类的方法（策略）
    12.         super.applyPay();
    13.     }
    14.  
    15.     @Override
    16.     public void notifys() {
    17.         // 采用重写的方式（策略）
    18.         System.out.println("Wxpay notifys");
    19.     }
    20.  
    21.     @Override
    22.     public void queryOrder() {
    23.         System.out.println("Wxpay queryOrder");
    24.     }
    25.  
    26.     @Override
    27.     public void refund() {
    28.         System.out.println("Wxpay refound");
    29.     }
    30. }
    1. //1.支付申请
    2. //2.支付回调
    3. //3.查询订单
    4. //4.订单退款
    5. // 策略模式，执行相同的方法采用不同的策略进行实现。
    6. public class AlipayStrategy extends PayTemplate{
    7.  
    8.     @Override
    9.     public void applyPay() {
    10.         System.out.println("alipay applyPay");
    11.     }
    12.  
    13.     @Override
    14.     public void notifys() {
    15.         System.out.println("alipay notifys");
    16.     }
    17.  
    18.     @Override
    19.     public void queryOrder() {
    20.         System.out.println("alipay queryOrder");
    21.     }
    22.  
    23.     @Override
    24.     public void refund() {
    25.         System.out.println("alipay refound");
    26.     }
    27. }

    4进行测试

    1. public class TemplateTest {
    2.     public static void main(String[] args) {
    3.         //支付宝支付
    4.         //new Alipay().doPayProcess();
    5.  
    6.         // doPayProcess()是WxpayStrategy继承的PayTemplate支付模板中的方法。
    7.         // 进行调用执行时，执行的是子类WxpayStrategy的重写后的方法。
    8.         // 多态的方式进行调用支付服务方法，子类有就用子类的，子类没有重写就用父类的方法
    9.         new WxpayStrategy().doPayProcess();
    10.     }
    11. }

    7代理模式【终于搞懂了】

            SpringAOP就是采用的是代理模式中的动态代理，mapper没有实现类，feignClient都是采用的动态代理模式，@Autowired等。
            代理模式：对目标对象的功能进行增强 【其实是代理对象中注入了目标对象（将目标对象的类当作自己的成员变量），然后调用目标对象的方法，再进行扩展功能】，比如说在目标对象的某个方法执行前后增加一些代码进行功能增强。这样就能够保证在不修改原本目标对象的前提下，提供额外的功能给目标对象，扩展目标对象的功能。【遵守OCP原则】**

            代理模式分为静态代理和动态代理。

    静态代理：手写的增强代码可以理解为静态代理。

    动态代理:JDK动态代理和cglib动态代理

    JDK动态代理【必须要实现接口】（给你生成一个兄弟，你的功能你兄弟也有，并且你兄弟还可以有其他的功能。）

    必须需要实现接口--为什么要实现接口？

    设计模式课件（中科大外教课）
    application/x-rar 0星 超过10%的资源 768KB
    下载

            代理类和原生类需要实现相同的接口，从而具有相同的功能，JDK动态代理就是通过接口创建一个代理类，然后具有相同的接口功能，然后进行增强。

    cglib动态代理--采用继承的方式【给你生成一个儿子】

    代理对象（类）去继承目标对象（需要代理的类），而且可以进行重写和功能增强。

    代码实现静态代理：

    1创建一个接口用来表示目标对象本来的方法（功能）

    为了让代理对象进行实现，具有目标对象的功能，然后进行代理。

    1. //接口
    2. public interface Subject {
    3.     void sing();
    4.     void dance();
    5.     void rap();
    6. }

    2目标对象进行实现接口，重写抽象方法。

    1. //（需要代理的类）
    2. public class ChickenStar implements Subject{
    3.  
    4.     public void sing(){
    5.         System.out.println("唱");
    6.     }
    7.     public void dance(){
    8.         System.out.println("跳");
    9.     }
    10.     public void rap(){
    11.         System.out.println("rap");
    12.     }
    13. }

    3代理对象实现接口，具有目标对象（需要代理的类）相同的功能

    【并且，代理对象将目标对象变成自己的成员变量。并且提供构造方法】

    1. //代理对象
    2. public class ChickenStarProxy implements Subject{
    3.     // 代理对象将目标对象变成自己的成员变量
    4.     private ChickenStar star;
    5.  
    6.     public ChickenStarProxy(ChickenStar star){
    7.         this.star = star;
    8.     }
    9.  
    10.     public void sing(){
    11.         //前置增强
    12.         System.out.println("前置增强..");
    13.         try {
    14.            // int i = 1 / 0;
    15.            // 调用的代理对象的方法
    16.             star.sing();
    17.             //后置增强          
    18.             System.out.println("后置增强  ..");
    19.         }catch (Exception e){
    20.             System.out.println("出现异常..");
    21.         }
    22.     }
    23.  
    24.     public void dance(){
    25.         System.out.println("收费..");
    26.         star.dance();
    27.         System.out.println("送明信片..");
    28.     }
    29.     public void rap(){
    30.         System.out.println("收费..");
    31.         star.rap();
    32.         System.out.println("送明信片..");
    33.     }
    34. }

    4进行测试

    1. public class ProxyTest {
    2.     public static void main(String[] args) {
    3.         ChickenStarProxy proxy = new ChickenStarProxy(new ChickenStar());
    4.         // 这时候调用的就是代理对象的增强后的方法，但是方法中还是调用了目标对象的方法
    5.         proxy.sing();
    6.         //proxy.dance();
    7.         //proxy.rap();
    8.     }
    9. }

    8Spring中使用的是那种代理模式？

            使用的是JDK动态代理模式。如果目标对象没有实现接口，就需要使用cglib动态代理

    9适配器模式

    将不兼容的接口转换为可兼容的接口的中间类。

    拦截器HandlerInterceptor，实现需要重写三个抽象方法然后有些业务类不需要全部重写，只需要重新一个，这时候就可以采用适配器HandlerInterceptorAdapter进行空实现这个拦截器HandlerInterceptor接口，然后其他类只需要重写一个方法时就可以实现适配器的接口。JDK1.8之后，给接口中增加了默认方法，比如WebMvcConfigurer，可以有方法体，因此这些适配器类已经失去作用了

    10观察者模式【监听器模式】：

            当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新，比如Spring中的ApplicationListener

    11策略模式【这个回看上面模板模式举例中采用了策略模式】

            InstantiationStrategy【创建对象的不同策略--相同的方法不同的实现方式】采用不同的方式进行创建对象。

    支付宝支付和微信支付采用的什么设计模式【模板模式和策略模式】

  • 相关阅读:
    NoSQL之Redis
    QT当中的【QSetting和.ini配置文件】以及【创建Resources.qrc】
    Linux-Hadoop部署
    Jmeter接口自动化（八）监听器
    UFS详细介绍---终章
    华为云云耀云服务器L实例评测 ｜ 实例评测使用之体验评测：华为云云耀云服务器安全加固/防范黑客攻击
    完全背包问题
    JavaScript 作用域
    JavaSE_第7章 面向对象基础（下）
    【JAVA】：万字长篇带你了解JAVA并发编程【一】
  • 原文地址：https://blog.csdn.net/m0_64210833/article/details/126275995