了解spring框架的设计模式

小咪咪 2024-03-16 14:38 44阅读 0赞

##  ##

## 1、工厂模式（简单工厂和工厂方法） ##

Spring 使用工厂模式可以通过 `BeanFactory` 或 `ApplicationContext` 创建 bean 对象

### 1.1 两个创建方式有何不同 ###

**`BeanFactory` :**延迟注入(使用到某个 bean 的时候才会注入),相比于`ApplicationContext` 来说会占用更少的内存，程序启动速度更快。

**`ApplicationContext:`**容器启动的时候，不管你用没用到，一次性创建所有 bean 。`BeanFactory` 仅提供了最基本的依赖注入支持，`ApplicationContext` 扩展了 `BeanFactory` ,除了有`BeanFactory`的功能还有额外更多功能，所以一般开发人员使用`ApplicationContext`会更多 。

### 1.2 简单工厂 ###

简单工厂不算是一个真正的设计模式，它的实现方式是通过`BeanFactory` ，本质就是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

拿动物类简单举个例

![d8475451871747bba82e4dd38b348e73.png][]

### 1.3 工厂方法 ###

实现方式是通过`ApplicationContext` ，它定义一个抽象的工厂方法，通过让子类决定该创建的对象是什么，来达到将对象创建的过程封装的目的。

工厂方法的模式的组成部分

1 抽象产品(Product) ：定义产品的属性和行为

2 具体产品 (Concrete Product) ：实现抽象产品接口的具体类。

3 抽象工厂 (Factory) ：定义工厂的属性和行为以及返回实例化产品的方法。

4 具体工厂 (Concrete Factory) ：实现抽象工厂接口的具体类。

## 2、单例设计模式 ##

在开发过程中，很多时候有些频繁使用到的类我们并想每调用一次就创建一次，如果调用次数过多的话，不仅每次创建也会浪费时间，而且还会非常占用内存空间，这时候就体现了单例模型的重要性了，单例模型使需要的类都只创建一个对象，这不仅仅节约了内存空间，而且还提供了系统的性能。

### 2.1 "懒汉"模式 ###

"懒汉"模式比较简单粗暴，调用方法的时候进行判断，如果系统存在该对象，直接调用该对象，如果没有，就新创建一个对象。

public class Singleton01 {
        private static Singleton01 instance;
        private Singleton01() {
        }
        public static Singleton01 getInstance(){
            if(null==instance){
                instance = new Singleton01();
            }
            return instance;
        }
    }
    public class SingLetonTest {
        public static void main(String[] args) {
        
            Set<Integer> set = new HashSet<>();
            for (int i = 0; i < 1000; i++) {
               SingLeton singLeton= SingLeton.getSingLeton();
                System.out.println(singLeton.hashCode());
                set.add(singLeton.hashCode());
            }
            System.out.println(set.size());
    
           //多线程运行
            Thread t1 = new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    SingLeton singLeton= SingLeton.getSingLeton();
                    System.out.println(singLeton.hashCode());
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            Thread t2 = new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    SingLeton singLeton= SingLeton.getSingLeton();
                    System.out.println(singLeton.hashCode());
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            });
            t1.start();
            t2.start();
    
        }
    
    }

"懒汉"模式的缺点就是多线程访问的时候会发生线程安全问题，这线程安全问题可以通过加同步锁进行优化

![8f47f52b237f5bdcfd6938f7655c6497.png][]

![96976225c73fa27e6a2351fe4d0d4556.png][]

### 2.2 "饿汉"模式 ###

"饿汉"模式是通过static，直接在类加载的时候创建新的对象，当多线程访问的时候，JVM就会阻挡其他线程，这样就不会发生线程安全。

public class SingLeton2 {
        private static SingLeton2 singLeton = new SingLeton2();
        private SingLeton2() {
        }
        public static SingLeton2 getSingLeton(){
            return singLeton;
        }
    }
    public class SingLetonTest2 {
        public static void main(String[] args) {
            Thread t1 = new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    SingLeton2 singLeton= SingLeton2.getSingLeton();
                    System.out.println(singLeton.hashCode());
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            Thread t2 = new Thread(()->{
                for (int i = 0; i < 100; i++) {
                    SingLeton2 singLeton= SingLeton2.getSingLeton();
                    System.out.println(singLeton.hashCode());
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
    
            });
            t1.start();
            t2.start();
    
        }
    
    }

![395fe7d74aa389fe244f7bf07549dbc5.png][]

## 3、代理设计模式 ##

### 代理模式在AOP中的应用 ###

AOP(Aspect-Oriented Programming，面向切面编程) 能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

Spring AOP 就是基于动态代理的，如果要代理的对象，实现了某个接口，那么 Spring AOP 会使用 JDK Proxy 去创建代理对象，而对于没有实现接口的对象，就无法使用 JDK Proxy 去进行代理了，这时候 Spring AOP 会使用 Cglib 生成一个被代理对象的子类来作为代理，如下图所示：

![4f4b20de4e79bbe4e84b71009d7ae23a.jpeg][]

## 4、模板方法设计模式 ##

**模板方法模式** 又叫模板模式(Template Pattern)，它在一个抽象类公开定义了执行它的方法的模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。换种说法就是在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

public abstract class Template {
        //模板方法
        public final void TemplateMethod() {
            Operation1();
            Operation2();
            Operation3();
        }
    
        protected void Operation1() {
            
        }
    
        //抽象方法
        protected abstract void Operation2();
    
        protected abstract void Operation3();
    }
    
    public class Template0l extends Template {
    
        @Override
        public void Operation2() {
            //当前类实现
        }
    
        @Override
        public void Operation3() {
            //当前类实现
        }
    }

## 5、观察者设计模式 ##

**观察者设计模式**是一种对象行为模式。它表示的是一种对象与对象之间具有依赖关系，当一个对象发生改变时，这个对象锁依赖的对象也会做出反应。Spring事件驱动模型就是观察者模式很经典的应用。

### Spring事件驱动模型中的三种角色 ###

#### 1.事件角色 ####

**`ApplicationEvent`** 充当事件的角色,这是一个抽象类

**`ApplicationContextEvent`** 的四个实现：

**`ContextStartedEvent`：`ApplicationContext`**启动后触发的事件;

**`ContextStoppedEvent`：`ApplicationContext`** 停止后触发的事件;

**`ContextRefreshedEvent`：`ApplicationContext`**初始化或刷新完成后触发的事件;

**`ContextClosedEvent`：`ApplicationContext`** 关闭后触发的事件

![d8a5673a361f6a6b045adaf72137c06f.jpeg][]

#### 2.事件监听者角色 ####

**`ApplicationListener`**充当了事件监听者角色，它是一个接口，里面只定义了一个 **`onApplicationEvent（）`**方法来处理**`ApplicationEvent`。`ApplicationListener`**接口类源码如下，可以看出接口定义看出接口中的事件只要实现了 **`ApplicationEvent`**就可以了。所以，在 Spring 中我们只要实现**`ApplicationListener`** 接口的 **`onApplicationEvent()`** 方法即可完成监听事件

package org.springframework.context;
    import java.util.EventListener;
    @FunctionalInterface
    public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
        void onApplicationEvent(E var1);
    }

#### 3.事件发布者角色 ####

**`ApplicationEventPublisher`**充当了事件的发布者，它也是一个接口。

@FunctionalInterface
    public interface ApplicationEventPublisher {
        default void publishEvent(ApplicationEvent event) {
            this.publishEvent((Object)event);
        }
    
        void publishEvent(Object var1);
    }

## 6、适配器设计模式 ##

适配器模式(Adapter Pattern) 将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作。

### 6.1 Spring AOP 中的适配器模式 ###

Spring AOP 的实现是基于代理模式，但是 Spring AOP 的增强或通知(Advice)使用到了适配器模式，与之相关的接口是**`AdvisorAdapter`**。

Advice 常用的类型有：**`BeforeAdvice`**（目标方法调用前,前置通知）、`AfterAdvice`（目标方法调用后,后置通知）、**`AfterReturningAdvice`**(目标方法执行结束后，return 之前)等等。每个类型 Advice（通知）都有对应的拦截器:**`MethodBeforeAdviceInterceptor`**、**`AfterReturningAdviceInterceptor`**、**`ThrowsAdviceInterceptor`**等等。

Spring 预定义的通知要通过对应的适配器，适配成 **`MethodInterceptor`**接口(方法拦截器)类型的对象（如：**`MethodBeforeAdviceAdapter`**通过调用 **`getInterceptor`**方法，将 **`MethodBeforeAdvice`**适配成 **`MethodBeforeAdviceInterceptor`**）。

### 6.2 Spring MVC 中的适配器模式 ###

在 Spring MVC 中，**`DispatcherServlet`**根据请求信息调用 **`HandlerMapping`**，解析请求对应的 **`Handler`**。解析到对应的 **`Handler`**（也就是我们平常说的 **`Controller`**控制器）后，开始由**`HandlerAdapter`**适配器处理。**`HandlerAdapter`**作为期望接口，具体的适配器实现类用于对目标类进行适配，**`Controller`**作为需要适配的类。

## 7、装饰者设计模式 ##

装饰者模式可以动态地给对象添加一些额外的属性或行为。相比于使用继承，装饰者模式更加灵活。简单点儿说就是当我们需要修改原有的功能，但我们又不愿直接去修改原有的代码时，设计一个 Decorator 套在原有代码外面。其实在 JDK 中就有很多地方用到了装饰者模式，比如 **`InputStream`**家族，**`InputStream`**类下有 **`FileInputStream`**(读取文件)、**`BufferedInputStream`**(增加缓存,使读取文件速度大大提升)等子类都在不修改**`InputStream`**代码的情况下扩展了它的功能。

![63ff761d47db4778b13dabb5cc34fcd7.jpeg][]

## 8、策略设计模式 ##

该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性。

A. 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。

B. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。

C. 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

**具体实例可以参考**

[【设计模式系列】策略模式看这篇就够了 - 掘金 (juejin.cn)][- _ _juejin.cn]

[Spring 中的设计模式详解 | JavaGuide(Java面试 + 学习指南)][Spring _ _ JavaGuide_Java_ _]

##  ##

[d8475451871747bba82e4dd38b348e73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/853a99e65c8c40b7aec41d59f42c11b2.png
[8f47f52b237f5bdcfd6938f7655c6497.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0e0e21601268415cb23ffc5066fb6fc3.png
[96976225c73fa27e6a2351fe4d0d4556.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/16922abacd8b4954b588ba4944a9919f.png
[395fe7d74aa389fe244f7bf07549dbc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/62b7610081fd4872b401ee70a5592e7b.png
[4f4b20de4e79bbe4e84b71009d7ae23a.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0e848c1662bd4e25a7957101beb069ef.png
[d8a5673a361f6a6b045adaf72137c06f.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3da1fef449af4fd8b345d1e84d49b7e7.png
[63ff761d47db4778b13dabb5cc34fcd7.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/42c45dc2d1ed4fc5bf31bdf0d377f7de.png
[- _ _juejin.cn]: https://juejin.cn/post/7030976391596212255
[Spring _ _ JavaGuide_Java_ _]: https://javaguide.cn/system-design/framework/spring/spring-design-patterns-summary.html