设计模式-单例模式

最新推荐文章于 2025-12-31 09:03:07 发布

原创最新推荐文章于 2025-12-31 09:03:07 发布 · 置顶 · 1.4k 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #单例模式

设计模式专栏收录该内容

2 篇文章

订阅专栏

单例模式详解及Spring框架中的应用

引言

单例模式是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点。这种模式非常有用，特别是在需要频繁实例化然后销毁的对象，或者创建对象需要消耗较多资源的情况下，通过单例模式可以避免不必要的内存开销。本文将详细介绍单例模式的概念、实现方式、应用场景，并探讨Spring框架中单例模式的应用。

什么是单例模式？

单例模式是一种常用的软件设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式非常有用，尤其是在需要频繁实例化然后销毁的对象，或者创建对象需要消耗较多资源的情况下，通过单例模式可以避免不必要的内存开销。

单例模式的优势

节省资源：因为单例模式只创建一个实例，所以减少了创建和销毁对象的开销。
全局唯一：单例模式可以保证系统内存中该类只存在一个实例，便于控制共享资源的访问。
方便扩展：在单例模式的基础上可以很容易地进行扩展，比如可以定义许多个方法供外界调用，达到改变单例状态的目的。

单例模式的缺点

难以测试：由于单例模式的对象在整个应用程序的生命周期中一直存在，因此很难对其进行单元测试。
限制扩展：如果单例类的功能需要扩展，则必须修改单例类本身，这违反了开放-封闭原则。

单例模式的实现方式

单例模式有几种常见的实现方式：

懒汉式：在需要的时候才创建实例。
饿汉式：在类加载时就创建实例。
双重检查锁定：线程安全的懒汉式实现。

懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

饿汉式

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

双重检查锁定（线程安全）

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;
    }
}

枚举实现

public enum Singleton {
    INSTANCE;

    public void someMethod() {
        // ...
    }
}

应用场景

单例模式的应用场景非常广泛，例如：

日志记录：系统中只需要一个日志记录器来记录信息。
配置管理：系统中通常只需要一个配置管理对象来读取配置文件。
数据库连接池：系统中只需要一个数据库连接池来管理连接。
任务调度器：系统中只需要一个任务调度器来管理任务执行。

Java代码示例

下面是一个简单的Java单例模式实现示例：

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;
    }

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

public class SingletonDemo {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.doSomething();
    }
}

在这个例子中，Singleton 类实现了单例模式，而 SingletonDemo 类则展示了如何使用这个单例对象。

Spring框架中的单例模式应用

1. Bean的单例模式

Spring容器默认将Bean定义为单例。这意味着对于每一个Bean定义，在Spring容器中只会存在一个实例，无论有多少个引用指向它。这是Spring IoC容器的一个核心特性之一。

示例配置

<!-- Spring XML配置文件 -->
<bean id="myService" class="com.example.MyService" scope="singleton"/>

代码示例

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService();
    }
}

2. ApplicationContext的单例模式

Spring的ApplicationContext接口通常用于管理Bean的生命周期。在Spring容器启动时，它会创建一个ApplicationContext实例，并且在整个应用的生命周期内，该实例是唯一的。这意味着所有的Bean都由同一个ApplicationContext管理。

示例代码

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

3. AOP中的单例模式

在Spring的AOP（面向切面编程）中，当使用基于代理的AOP时，通常会对目标对象创建一个代理对象。这个代理对象也是单例的，即使它代理的是多个不同的目标对象。

示例代码

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example..*(..))")
    public void logBefore() {
        System.out.println("Logging before method execution.");
    }
}

4. 事件监听器的单例模式

Spring框架提供了事件发布机制，其中事件监听器通常作为单例存在。这意味着每当事件发生时，都会触发相同的监听器实例上的方法。

示例代码

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

public class StartupEventListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("Startup event received.");
    }
}