首頁手記 Spring設計模式學習：初學者指南

Spring設計模式學習：初學者指南

標簽：

Spring 設計模式

概述

学习Spring设计模式是一个复杂但重要的过程，涉及Spring框架和多种设计模式的应用。本文介绍了Spring框架的基本概念及其主要特点，并详细解释了单例模式、工厂模式、代理模式和观察者模式在Spring中的应用。通过实际案例和配置示例，帮助读者更好地理解和实践这些设计模式。

引入Spring框架和设计模式

Spring框架简介

Spring是一个用于Java应用程序的流行框架，它提供了全面的基础设施支持，包括依赖注入、面向切面编程、数据访问、事务管理、Web服务等。Spring框架的核心是依赖注入（Dependency Injection，DI）和控制反转（Inversion of Control，IoC），它通过DI和IoC来管理组件间的依赖关系。Spring框架的目标是简化Java应用程序的开发，提高开发效率，以及改善代码质量。

Spring框架的主要特点

依赖注入（DI）和控制反转（IoC）：Spring的核心机制，通过工厂模式和反射机制来管理对象的生命周期和依赖关系。
面向切面编程（AOP）：提供了一种方便的方式来定义通用的切面逻辑，如事务管理、日志记录等。
事务管理：支持编程式和声明式事务管理。
数据访问：提供了对JDBC、ORM框架（如Hibernate）的支持。
Web框架：提供了Spring MVC框架，用于构建Web应用程序。
集成支持：支持与其他框架和技术的集成，如Struts、Hibernate、JPA等。

Spring框架的优势

解耦：通过DI和IoC，Spring可以将对象的依赖关系解耦，提高系统的可维护性和可测试性。
简化配置：通过XML配置或注解来配置组件，简化了配置工作。
AOP支持：允许在不修改源代码的情况下，将通用的横切逻辑应用到多个组件上。
资源管理：通过JDBC模板和ORM支持，简化了数据库操作。
Web框架：提供了Spring MVC框架，可以用于构建高效的Web应用程序。

设计模式简介

设计模式是指针对软件开发中遇到的一系列典型问题所总结出的通用解决方案，并且这些解决方案已经被实践证明是有效的。设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。

创建型模式

单例模式：确保一个类只有一个实例，并提供一个访问它的全局访问点。
工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪一个类。
抽象工厂模式：提供一个接口，用于创建一系列相关或相互依赖的对象。
原型模式：通过复制现有的对象来创建新的对象。
建造者模式：将一个复杂对象的构建与它的表示分离，以便可以有不同的表示。

结构型模式

代理模式：提供一种代理对象来控制对对象的访问。
适配器模式：将一个类的接口转换为客户期望的接口。
装饰器模式：动态地给一个对象添加一些额外的职责。
组合模式：用一种树形结构组织多个对象。
外观模式：提供一个统一的接口，简化子系统中的接口。

行为型模式

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并被自动更新。
策略模式：定义一系列算法，并将每一个算法封装起来，使它们可以相互替换。
模板方法模式：定义一个算法的骨架，而将一些步骤延迟到子类中实现。
迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素。
职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

Spring框架与设计模式的关系

Spring框架本身广泛使用了设计模式，例如，它是基于工厂模式和控制反转（IoC）来管理对象的依赖关系。Spring框架中的依赖注入（DI）机制是控制反转（IoC）的具体实现，它利用工厂模式来创建和管理对象的生命周期，并通过反射机制来实现对象的依赖注入。这种机制在很大程度上简化了对象之间的依赖关系管理，使得应用程序的结构更加清晰、易于维护。

此外，Spring框架提供了面向切面编程（AOP）功能，它使用了代理模式，通过动态生成代理对象来实现横切关注点（如事务管理、日志记录等）的封装，从而将这些关注点从业务逻辑中分离出来，提高了代码的可维护性和复用性。

示例代码

下面是一个简单的工厂方法模式的示例代码，展示了如何使用工厂方法模式来创建不同的对象：

public interface Shape {
    void draw();
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public abstract class ShapeFactory {
    public abstract Shape getShape(String shapeType);
}

public class ConcreteShapeFactory extends ShapeFactory {
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        }
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        ShapeFactory factory = new ConcreteShapeFactory();
        Shape shape = factory.getShape("RECTANGLE");
        shape.draw();
        shape = factory.getShape("CIRCLE");
        shape.draw();
    }
}

关键概念

工厂方法模式：通过定义一个创建对象的接口，让子类决定实例化哪一个类。
创建型模式：负责对象的创建，包括工厂方法模式、单例模式等。
面向对象原则：如开放封闭原则、单一职责原则等。

常用的设计模式概述

本节将详细介绍在Spring框架中常用的几种设计模式，包括单例模式、工厂模式、代理模式和观察者模式。

单例模式

单例模式是创建型模式的一种，确保一个类只有一个实例，并提供一个全局访问点。在Spring框架中，单例模式用于确保Bean的实例在应用范围内是唯一的。Spring容器在创建Bean时，会根据配置文件或注解来决定Bean的作用范围，如果配置为singleton（默认），则会创建一个单例的Bean。

单例模式的优点

资源独占性：确保只有一个实例，避免资源浪费。
全局唯一性：在应用范围内只有一个实例，简化了对象的管理。
灵活性：在需要时可以更改实现，而不需要修改使用该单例的代码。

单例模式的缺点

线程安全问题：在多线程环境中，需要考虑同步问题。
测试困难：单例模式可能使单元测试变得复杂，因为无法轻松创建和销毁实例。

示例代码

下面是一个简单的单例模式的实现，展示了如何通过双重检查锁定机制来确保线程安全：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

关键概念

单例模式：确保一个类只有一个实例，并提供一个全局访问点。
作用域：描述对象的生命周期和作用范围。
线程安全：确保在多线程环境下操作的安全性。

工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但允许子类决定实例化哪一个类。工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式，其中工厂方法模式在Spring框架中应用广泛。

工厂方法模式

工厂方法模式定义一个创建对象的接口，让子类决定实例化哪一个类。工厂方法模式将实例化延迟到子类，使得子类可以决定实例化哪一个类，从而实现工厂模式的扩展。

工厂模式的优点

灵活性：可以轻松地引入新的实现，而不需要修改现有代码。
解耦：将对象的创建与使用分离，使代码更加灵活和可维护。
可测试性：可以使用不同的工厂来创建测试对象，提高单元测试的灵活性。

工厂模式的缺点

代码复杂性：工厂模式可能会引入额外的抽象层次，使得代码更加复杂。
维护成本：随着工厂类的增多，维护成本也会相应增加。

示例代码

下面是一个简单的工厂方法模式的实现，展示了如何通过工厂方法模式创建不同类型的对象：

public interface Factory {
    Product createProduct();
}

public class ConcreteFactory1 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

public class ConcreteFactory2 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactory1();
        Product product = factory.createProduct();
        product.use();

        factory = new ConcreteFactory2();
        product = factory.createProduct();
        product.use();
    }
}

关键概念

工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪一个类。
工厂类：负责创建具体对象的工厂类。
抽象工厂：定义创建对象的接口，让子类决定实例化哪一个类。

代理模式

代理模式是一种结构型设计模式，提供一个代理对象来控制对对象的访问。在Spring框架中，代理模式用于实现AOP（面向切面编程）功能，通过动态生成代理对象来实现横切关注点的封装。

代理模式的优点

灵活性：可以在不修改原始对象代码的情况下，动态地添加功能。
职责分离：将原始对象的职责与代理对象的职责分离，提高代码的复用性。
透明性：代理对象可以在不改变客户端代码的情况下，对原始对象进行增强或修改。

代理模式的缺点

复杂性：引入了额外的层次，增加了系统的复杂性。
性能开销：动态生成代理对象可能会带来一定的性能开销。

示例代码

下面是一个简单的代理模式的实现，展示了如何通过代理模式来实现对象的访问控制：

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        this.realSubject = new RealSubject();
    }

    @Override
    public void request() {
        preRequest();
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        System.out.println("Proxy: Pre-request operation.");
    }

    private void postRequest() {
        System.out.println("Proxy: Post-request operation.");
    }
}

public class Client {
    public static void main(String[] args) {
        Subject subject = new Proxy();
        subject.request();
    }
}

关键概念

代理模式：提供一个代理对象来控制对对象的访问。
代理对象：封装原始对象，并在调用原始对象的方法前或后执行额外的操作。
AOP：通过动态生成代理对象来实现横切关注点的封装。

观察者模式

观察者模式是一种行为型设计模式，定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在Spring框架中，观察者模式用于实现事件监听机制，通过事件监听器来监听和处理特定的事件。

观察者模式的优点

灵活性：可以轻松地添加新的观察者，而不需要修改被观察者。
解耦：将被观察者和观察者解耦，使得代码更加灵活和可维护。
可扩展性：可以通过添加新的观察者来扩展系统，而不需要修改现有代码。

观察者模式的缺点

复杂性：引入了额外的层次，增加了系统的复杂性。
性能开销：在观察者数量较多时，通知和更新操作可能会带来一定的性能开销。

示例代码

下面是一个简单的观察者模式的实现，展示了如何通过观察者模式来监听和处理事件：

public interface Observable {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

public interface Observer {
    void update();
}

public class ConcreteObservable implements Observable {
    private List<Observer> observers;

    public ConcreteObservable() {
        this.observers = new ArrayList<>();
    }

    @Override
    public void addObserver(Observer observer) {
        this.observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        this.observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : this.observers) {
            observer.update();
        }
    }

    public void setState(int state) {
        // Update state and notify observers
        System.out.println("ConcreteObservable: State changed to " + state);
        notifyObservers();
    }
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        System.out.println("ConcreteObserver: Received update.");
    }
}

public class Client {
    public static void main(String[] args) {
        Observable observable = new ConcreteObservable();
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();

        observable.addObserver(observer1);
        observable.addObserver(observer2);

        observable.setState(123);
        observable.setState(456);
    }
}

关键概念

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
被观察者：维护一个观察者列表，并通知所有观察者。
观察者：监听被观察者的状态变化，并在状态变化时作出响应。

Spring中的设计模式应用

Spring中的单例模式应用

Spring框架中使用单例模式来确保Bean的实例在应用范围内是唯一的。在Spring的配置文件或注解中，可以通过设置Bean的作用范围为singleton来实现单例模式。

单例模式的实现

在Spring配置文件中，可以通过<bean>标签的scope属性来设置Bean的作用范围，如：

<bean id="singletonBean" class="com.example.SingletonBean" scope="singleton"/>

在注解配置中，可以通过@Scope注解来设置Bean的作用范围，如：

@Component
@Scope("singleton")
public class SingletonBean {
    // Bean implementation
}

单例模式的优点

资源独占性：确保只有一个实例，避免资源浪费。
全局唯一性：在应用范围内只有一个实例，简化了对象的管理。
灵活性：在需要时可以更改实现，而不需要修改使用该单例的代码。

单例模式的缺点

线程安全问题：在多线程环境中，需要考虑同步问题。
测试困难：单例模式可能使单元测试变得复杂，因为无法轻松创建和销毁实例。

示例代码

下面是一个简单的单例模式的实现，展示了如何通过Spring框架来创建一个单例的Bean：

public class SingletonBean {
    public void doSomething() {
        System.out.println("SingletonBean: Doing something.");
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SingletonBean singletonBean = context.getBean("singletonBean", SingletonBean.class);
        singletonBean.doSomething();
    }
}

关键概念

<bean>标签：用于定义Spring Bean的配置。
@Scope注解：用于设置Bean的作用范围。
作用范围：描述Bean的生命周期和作用范围。

Spring中的工厂模式应用

Spring框架中广泛使用了工厂模式，用于创建和管理对象的生命周期。在Spring配置文件或注解中，可以通过设置Bean的作用范围为singleton或prototype来实现工厂模式。

工厂模式的实现

在Spring配置文件中，可以通过<bean>标签的scope属性来设置Bean的作用范围，如：

<bean id="factoryBean" class="com.example.FactoryBean" scope="singleton"/>

在注解配置中，可以通过@Scope注解来设置Bean的作用范围，如：

@Component
@Scope("singleton")
public class FactoryBean {
    // Bean implementation
}

工厂模式的优点

灵活性：可以轻松地引入新的实现，而不需要修改现有代码。
解耦：将对象的创建与使用分离，使代码更加灵活和可维护。
可测试性：可以使用不同的工厂来创建测试对象，提高单元测试的灵活性。

工厂模式的缺点

代码复杂性：工厂模式可能会引入额外的抽象层次，使得代码更加复杂。
维护成本：随着工厂类的增多，维护成本也会相应增加。

示例代码

下面是一个简单的工厂模式的实现，展示了如何通过Spring框架来创建和管理对象的生命周期：

public interface Product {
    void use();
}

public class ConcreteProduct {
    public void use() {
        System.out.println("ConcreteProduct: Using product.");
    }
}

public class FactoryBean {
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        FactoryBean factoryBean = context.getBean("factoryBean", FactoryBean.class);
        Product product = factoryBean.createProduct();
        product.use();
    }
}

关键概念

<bean>标签：用于定义Spring Bean的配置。
@Scope注解：用于设置Bean的作用范围。
工厂类：负责创建具体对象的工厂类。

Spring中的代理模式应用

Spring框架中使用代理模式实现AOP（面向切面编程）功能，通过动态生成代理对象来实现横切关注点的封装。在Spring配置文件或注解中，可以通过@Aspect注解来定义切面，通过@Before、@After等注解来定义切点。

代理模式的实现

在Spring配置文件中，可以通过<aop:config>标签来定义切面，如：

<aop:config>
    <aop:pointcut id="businessService" expression="execution(* com.example.service.*.*(..))"/>
    <aop:aspect ref="loggingAspect">
        <aop:before method="logBefore" pointcut-ref="businessService"/>
        <aop:after method="logAfter" pointcut-ref="businessService"/>
    </aop:aspect>
</aop:config>

在注解配置中，可以通过@Aspect注解来定义切面，通过@Before、@After等注解来定义切点，如：

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("LoggingAspect: Before method execution.");
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter() {
        System.out.println("LoggingAspect: After method execution.");
    }
}

代理模式的优点

灵活性：可以在不修改原始对象代码的情况下，动态地添加功能。
职责分离：将原始对象的职责与代理对象的职责分离，提高代码的复用性。
透明性：代理对象可以在不改变客户端代码的情况下，对原始对象进行增强或修改。

代理模式的缺点

复杂性：引入了额外的层次，增加了系统的复杂性。
性能开销：动态生成代理对象可能会带来一定的性能开销。

示例代码

下面是一个简单的代理模式的实现，展示了如何通过Spring框架来实现AOP功能：

public interface MyService {
    void doSomething();
}

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        System.out.println("MyServiceImpl: Doing something.");
    }
}

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("LoggingAspect: Before method execution.");
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter() {
        System.out.println("LoggingAspect: After method execution.");
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyService myService = context.getBean("myService", MyService.class);
        myService.doSomething();
    }
}

关键概念

<aop:config>标签：用于定义切面的配置。
@Aspect注解：用于定义切面。
切点注解：如@Before、@After等，用于定义切点。

Spring中的观察者模式应用

Spring框架中使用观察者模式实现事件监听机制，通过事件监听器来监听和处理特定的事件。在Spring配置文件或注解中，可以通过@EventListener注解来定义事件监听器。

观察者模式的实现

在Spring配置文件中，可以通过<bean>标签来定义事件监听器，如：

<bean id="eventListener" class="com.example.EventListener"/>

在注解配置中，可以通过@EventListener注解来定义事件监听器，如：

@Component
public class EventListener {
    @EventListener
    public void handleEvent(MyEvent event) {
        System.out.println("EventListener: Handling event.");
    }
}

观察者模式的优点

灵活性：可以轻松地添加新的观察者，而不需要修改被观察者。
解耦：将被观察者和观察者解耦，使得代码更加灵活和可维护。
可扩展性：可以通过添加新的观察者来扩展系统，而不需要修改现有代码。

观察者模式的缺点

复杂性：引入了额外的层次，增加了系统的复杂性。
性能开销：在观察者数量较多时，通知和更新操作可能会带来一定的性能开销。

示例代码

下面是一个简单的观察者模式的实现，展示了如何通过Spring框架来实现事件监听机制：

public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

@Component
public class EventPublisher {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void publishEvent() {
        MyEvent event = new MyEvent(this);
        publisher.publishEvent(event);
    }
}

@Component
public class EventListener {
    @EventListener
    public void handleEvent(MyEvent event) {
        System.out.println("EventListener: Handling event.");
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        EventPublisher eventPublisher = context.getBean("eventPublisher", EventPublisher.class);
        eventPublisher.publishEvent();
    }
}

关键概念

ApplicationEvent类：用于定义事件。
ApplicationEventPublisher接口：用于发布事件。
@EventListener注解：用于定义事件监听器。

实践案例

本节将通过具体的实践案例来展示如何使用Spring框架来实现单例模式、工厂模式、代理模式和观察者模式。

使用Spring实现单例模式

在Spring框架中，可以通过设置Bean的作用范围为singleton来实现单例模式。下面是一个简单的示例代码，展示了如何通过Spring框架来创建一个单例的Bean：

public class SingletonBean {
    public void doSomething() {
        System.out.println("SingletonBean: Doing something.");
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SingletonBean singletonBean = context.getBean("singletonBean", SingletonBean.class);
        singletonBean.doSomething();
    }
}

在applicationContext.xml配置文件中，可以通过<bean>标签的scope属性来设置Bean的作用范围：

<bean id="singletonBean" class="com.example.SingletonBean" scope="singleton"/>

在注解配置中，可以通过@Scope注解来设置Bean的作用范围：

@Component
@Scope("singleton")
public class SingletonBean {
    public void doSomething() {
        System.out.println("SingletonBean: Doing something.");
    }
}

使用Spring实现工厂模式

在Spring框架中，可以通过工厂模式来创建和管理对象的生命周期。下面是一个简单的示例代码，展示了如何通过Spring框架来创建和管理对象的生命周期：

public interface Product {
    void use();
}

public class ConcreteProduct {
    public void use() {
        System.out.println("ConcreteProduct: Using product.");
    }
}

public class FactoryBean {
    public Product createProduct() {
        return new ConcreteProduct();
    }
}

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        FactoryBean factoryBean = context.getBean("factoryBean", FactoryBean.class);
        Product product = factoryBean.createProduct();
        product.use();
    }
}

在applicationContext.xml配置文件中，可以通过<bean>标签的scope属性来设置Bean的作用范围：

<bean id="factoryBean" class="com.example.FactoryBean" scope="singleton"/>

在注解配置中，可以通过@Scope注解来设置Bean的作用范围：

```java.
.
.
.

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

素胚勾勒不出你

手記
篇

粉絲

53

獲贊與收藏

274

關注作者，訂閱最新文章

閱讀免費教程

Spring Cloud Hystrix

15個小節 6354 125

Spring Security

28個小節 17277 274

Spring MVC 入門教程

24個小節 23951 332

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空

Spring設計模式學習：初學者指南

Spring框架的主要特点

Spring框架的优势

创建型模式

结构型模式

行为型模式

示例代码

关键概念

单例模式的优点

单例模式的缺点

示例代码

关键概念

工厂方法模式

工厂模式的优点

工厂模式的缺点

示例代码

关键概念

代理模式的优点

代理模式的缺点

示例代码

关键概念

观察者模式的优点

观察者模式的缺点

示例代码

关键概念

单例模式的实现

单例模式的优点

单例模式的缺点

示例代码

关键概念

工厂模式的实现

工厂模式的优点

工厂模式的缺点

示例代码

关键概念

代理模式的实现

代理模式的优点

代理模式的缺点

示例代码

关键概念

观察者模式的实现

观察者模式的优点

观察者模式的缺点

示例代码

关键概念

閱讀免費教程