title: 在Spring Boot 3中使用享元模式
date: 2023-08-15 21:04:47
cover: https://coupon-image.oss-cn-shanghai.aliyuncs.com/image/blog/java.jpeg
categories:

springBoot
tags:
springBoot3
享元模式
Flyweight
ai

在Spring Boot 3中使用享元模式

前言

享元(Flyweight)模式是一种软件设计模式。它使用共享对象可以有效地支持大量细粒度的对象。享元模式尝试重用现有的同类对象,如果未找到匹配的对象,则创建新对象。
Spring框架天然适合使用享元模式,因为Spring本身就充分利用了单例模式的设计。在Spring容器启动时,会预先创建并配置好各种Bean对象,将其缓存起来重复使用,而不是每次都创建新对象。

享元模式在Spring Boot项目中可以带来以下好处:

减少内存占用,提高性能
适合处理大量细粒度的对象
简化和提高开发效率

实现

开发例子

缓存对象

在Spring Boot中，我们可能需要缓存对象，以提高系统的性能和响应速度。使用享元模式，我们可以将需要缓存的对象作为享元对象，共享其内部状态，避免重复创建对象。

public class CachedObject {
  private String key;
  private Object value;
  
  // 省略了构造函数和其他方法
  
  // Getter and setter methods
}

public class ObjectCache {
  private Map<String, CachedObject> cache = new HashMap<>();
  
  public CachedObject getCachedObject(String key) {
    if (cache.containsKey(key)) {
      return cache.get(key);
    } else {
      CachedObject object = createObject(key);
      cache.put(key, object);
      return object;
    }
  }
  
  private CachedObject createObject(String key) {
    // 创建新的对象
    return new CachedObject(key, null);
  }
}

通过享元模式，我们可以使用ObjectCache类作为享元工厂，共享已经创建的对象，并通过getCachedObject方法返回缓存对象或创建新的对象。

ObjectCache cache = new ObjectCache();
CachedObject object1 = cache.getCachedObject("key1");
CachedObject object2 = cache.getCachedObject("key2");

池化对象

在Spring Boot开发中，我们可能需要池化对象，以提高系统的性能和资源利用率。使用享元模式，我们可以将需要池化的对象作为享元对象，共享其内部状态，避免重复创建对象。

public interface Connection {
  void connect();
  void disconnect();
}

public class DatabaseConnection implements Connection {
  private String url;
  
  public DatabaseConnection(String url) {
    this.url = url;
  }
  
  @Override
  public void connect() {
    // 建立数据库连接
  }
  
  @Override
  public void disconnect() {
    // 断开数据库连接
  }
}

public class ConnectionPool {
  private List<Connection> pool = new ArrayList<>();
  
  public Connection getConnection(String url) {
    for (Connection connection : pool) {
      if (connection instanceof DatabaseConnection && ((DatabaseConnection) connection).getUrl().equals(url)) {
        return connection;
      }
    }
    
    Connection connection = createConnection(url);
    pool.add(connection);
    return connection;
  }
  
  private Connection createConnection(String url) {
    // 创建新的连接
    return new DatabaseConnection(url);
  }
}

通过享元模式，我们可以使用ConnectionPool类作为享元工厂，共享已经创建的对象，并通过getConnection方法返回池化对象或创建新的对象。

ConnectionPool pool = new ConnectionPool();
Connection connection1 = pool.getConnection("jdbc:mysql://localhost:3306/db1");
Connection connection2 = pool.getConnection("jdbc:mysql://localhost:3306/db2");

使用享元模式实现连接池

在Spring Boot应用中，我们经常需要与数据库或其他外部服务建立连接。为了提高性能和资源利用率，我们可以使用享元模式实现连接池，从而共享连接对象。

public interface Connection {
  void executeQuery(String query);
}

public class DatabaseConnection implements Connection {
  private String url;
  private String username;
  private String password;
  
  public DatabaseConnection(String url, String username, String password) {
    this.url = url;
    this.username = username;
    this.password = password;
    
    // 创建数据库连接的操作
    System.out.println("Creating database connection: " + url);
  }
  
  @Override
  public void executeQuery(String query) {
    // 执行数据库查询的操作
    System.out.println("Executing query: " + query);
  }
}

public class ConnectionPool {
  private Map<String, Connection> connections;
  
  public ConnectionPool() {
    this.connections = new HashMap<>();
  }
  
  public Connection getConnection(String url, String username, String password) {
    String key = url + username + password;
    if (connections.containsKey(key)) {
      System.out.println("Getting connection from pool: " + url);
      return connections.get(key);
    } else {
      Connection connection = new DatabaseConnection(url, username, password);
      connections.put(key, connection);
      return connection;
    }
  }
}

在使用时，我们可以创建连接池对象，并通过连接池获取数据库连接。

ConnectionPool connectionPool = new ConnectionPool();
Connection connection1 = connectionPool.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");
Connection connection2 = connectionPool.getConnection("jdbc:mysql://localhost:3306/mydb", "root", "password");

connection1.executeQuery("SELECT * FROM users");
connection2.executeQuery("SELECT * FROM orders");

使用享元模式实现线程池

在某些场景下，我们需要同时处理多个并发任务。为了提高性能和资源利用率，我们可以使用享元模式实现线程池，从而共享线程对象。

public interface Task {
  void execute();
}

public class TaskImpl implements Task {
  private String name;
  
  public TaskImpl(String name) {
    this.name = name;
  }
  
  @Override
  public void execute() {
    // 执行任务的操作
    System.out.println("Executing task: " + name);
  }
}

public class ThreadPool {
  private List<Task> tasks;
  
  public ThreadPool() {
    this.tasks = new ArrayList<>();
  }
  
  public void addTask(Task task) {
    tasks.add(task);
  }
  
  public void executeTasks() {
    for (Task task : tasks) {
      task.execute();
    }
  }
}

在使用时，我们可以创建线程池对象，并向线程池添加任务。

ThreadPool threadPool = new ThreadPool();
threadPool.addTask(new TaskImpl("Task 1"));
threadPool.addTask(new TaskImpl("Task 2"));
threadPool.addTask(new TaskImpl("Task 3"));

threadPool.executeTasks();

享元模式在缓存管理中的应用

假设我们正在开发一个电商平台的商品管理模块。在该模块中，我们需要频繁地查询和展示商品信息，为了提高系统性能，我们可以使用享元模式来缓存商品对象。

首先，我们创建一个名为ProductCache的享元工厂类，它负责创建和管理商品对象。在该工厂类中，我们使用一个Map来缓存已创建的商品对象，当需要获取商品对象时，先从缓存中查找，如果不存在则创建新的对象并加入缓存。

public class ProductCache {
  private Map<Long, Product> productMap = new HashMap<>();

  public Product getProduct(long id) {
    if (productMap.containsKey(id)) {
      return productMap.get(id);
    } else {
      Product product = new Product(id);
      productMap.put(id, product);
      return product;
    }
  }
}

在使用享元模式的时候，我们可以通过ProductCache类来获取商品对象，避免重复创建对象，提高系统性能。

总结

享元模式是一种在Spring Boot开发中非常有用的设计模式，它可以帮助我们减少对象的创建，提高系统的性能和资源利用率。