71 lines
No EOL
3.4 KiB
Markdown
71 lines
No EOL
3.4 KiB
Markdown
---
|
|
obj: concept
|
|
---
|
|
# Singleton Pattern
|
|
|
|
## **Description:**
|
|
The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a global point of access to that instance. It is commonly used when you want to restrict the instantiation of a class to a single object and control access to that unique instance across the application.
|
|
|
|
**How it's Used:**
|
|
1. **Private Constructor**: Ensure that the class has a private constructor to prevent direct instantiation from external code.
|
|
2. **Static Instance**: Create a static instance of the class within the class itself.
|
|
3. **Lazy or Eager Initialization**: Decide whether to initialize the instance lazily (on-demand) or eagerly (at the time of class loading). Lazy initialization is preferred if resource usage should be minimized.
|
|
4. **Static Method**: Provide a static method within the class to access the unique instance. This method should handle the creation of the instance if it doesn't exist or return the existing instance.
|
|
5. **Thread Safety (Optional)**: If your application is multithreaded, ensure that the creation of the instance and access to it is thread-safe, especially if using lazy initialization.
|
|
|
|
## **Example:**
|
|
A classic example of the Singleton Pattern is creating a configuration manager that provides access to application-wide configuration settings:
|
|
|
|
```java
|
|
public class ConfigurationManager {
|
|
private static ConfigurationManager instance; // Static instance variable
|
|
private String configurationData;
|
|
|
|
// Private constructor to prevent external instantiation
|
|
private ConfigurationManager() {
|
|
// Initialize configurationData from a configuration file or other source
|
|
configurationData = "Default configuration";
|
|
}
|
|
|
|
// Static method to provide access to the unique instance
|
|
public static ConfigurationManager getInstance() {
|
|
if (instance == null) {
|
|
instance = new ConfigurationManager(); // Lazy initialization
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
public String getConfigurationData() {
|
|
return configurationData;
|
|
}
|
|
|
|
public void setConfigurationData(String data) {
|
|
configurationData = data;
|
|
}
|
|
}
|
|
```
|
|
|
|
In this Java example:
|
|
- The `ConfigurationManager` class has a private constructor to prevent external instantiation.
|
|
- It contains a private static instance variable.
|
|
- The `getInstance` static method is used to access the unique instance of the class. It initializes the instance lazily when called for the first time.
|
|
- You can use `ConfigurationManager.getInstance()` to access the configuration manager from anywhere in your application.
|
|
|
|
```java
|
|
public class Main {
|
|
public static void main(String[] args) {
|
|
ConfigurationManager configManager1 = ConfigurationManager.getInstance();
|
|
ConfigurationManager configManager2 = ConfigurationManager.getInstance();
|
|
|
|
// Both instances refer to the same unique object
|
|
System.out.println(configManager1 == configManager2); // true
|
|
|
|
// Access and modify configuration data
|
|
System.out.println(configManager1.getConfigurationData()); // Default configuration
|
|
configManager1.setConfigurationData("New configuration");
|
|
System.out.println(configManager2.getConfigurationData()); // New configuration
|
|
}
|
|
}
|
|
```
|
|
|
|
The Singleton Pattern ensures that there's only one instance of `ConfigurationManager` throughout the application, providing a centralized and controlled way to manage configuration data. |