求助：Java中Identity Map模式的真实行业实现实用示例

Hey there! Great question—Identity Map is such a foundational pattern for avoiding duplicate object loads and keeping your domain model consistent, so it’s smart to dig into real-world Java implementations. Let’s break down practical, industry-used examples across different scenarios:

First, a quick recap #

Identity Map核心是维护一个内存缓存，以实体主键为键，确保同一个数据库记录在应用中仅对应一个对象实例。这既能减少重复数据库查询，也能避免同一数据存在多个实例导致的状态不一致问题。

1. Custom Basic Identity Map (for understanding fundamentals) #

If you want to see how the pattern works under the hood, here’s a simplified production-ready-style implementation for a User entity:

Entity Class #

public class User {
    private Long id;
    private String username;
    private String email;

    // Constructor, getters, setters
    public User(Long id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    // Getters and setters omitted for brevity
}

Identity Map Implementation #

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class IdentityMap<T> {
    // Use ConcurrentHashMap for thread-safe access in multi-threaded apps
    private final Map<Long, T> cache = new ConcurrentHashMap<>();

    public T get(Long id) {
        return cache.get(id);
    }

    // Ensure we only store an entity once (prevents overwriting existing instances)
    public void put(Long id, T entity) {
        cache.putIfAbsent(id, entity);
    }

    public void remove(Long id) {
        cache.remove(id);
    }

    public void clear() {
        cache.clear();
    }
}

DAO Layer Integration #

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class UserDAO {
    private final IdentityMap<User> userIdentityMap = new IdentityMap<>();
    private final Connection dbConnection;

    public UserDAO(Connection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public User findById(Long id) throws SQLException {
        // Check cache first
        User cachedUser = userIdentityMap.get(id);
        if (cachedUser != null) {
            return cachedUser;
        }

        // Fetch from DB if not in cache
        String sql = "SELECT id, username, email FROM users WHERE id = ?";
        try (PreparedStatement stmt = dbConnection.prepareStatement(sql)) {
            stmt.setLong(1, id);
            ResultSet rs = stmt.executeQuery();
            if (rs.next()) {
                User user = new User(
                    rs.getLong("id"),
                    rs.getString("username"),
                    rs.getString("email")
                );
                // Add to cache after fetching
                userIdentityMap.put(id, user);
                return user;
            }
            return null;
        }
    }

    // Sync cache after update to avoid stale data
    public void update(User user) throws SQLException {
        String sql = "UPDATE users SET username = ?, email = ? WHERE id = ?";
        try (PreparedStatement stmt = dbConnection.prepareStatement(sql)) {
            stmt.setString(1, user.getUsername());
            stmt.setString(2, user.getEmail());
            stmt.setLong(3, user.getId());
            stmt.executeUpdate();
            // Update cache with the latest state
            userIdentityMap.put(user.getId(), user);
        }
    }
}

2. Hibernate Session First-Level Cache (Industry Standard) #

Hibernate’s Session is a de facto implementation of Identity Map. Its built-in first-level cache (session-scoped) ensures that within a single session, the same entity ID maps to exactly one object instance:

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateExample {
    public static void main(String[] args) {
        SessionFactory factory = new Configuration().configure().buildSessionFactory();
        Session session = factory.openSession();
        session.beginTransaction();

        // First call: fetches from DB and stores in session cache
        User user1 = session.get(User.class, 1L);
        // Second call: returns directly from cache (no DB hit)
        User user2 = session.get(User.class, 1L);

        // Output: true (same object instance)
        System.out.println(user1 == user2);

        session.getTransaction().commit();
        session.close();
        factory.close();
    }
}

3. Spring Data JPA EntityManager Cache #

Spring Data JPA relies on JPA’s EntityManager, whose persistence context acts as an Identity Map. This is the most common implementation in modern Java enterprise apps:

import org.springframework.stereotype.Service;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Service
public class UserService {
    @PersistenceContext
    private EntityManager entityManager;

    public User getUserById(Long id) {
        // First call: loads entity into persistence context
        User user1 = entityManager.find(User.class, id);
        // Second call: retrieves from context (no DB query)
        User user2 = entityManager.find(User.class, id);
        
        // user1 and user2 are the same object
        return user1;
    }
}

4. DDD Aggregate Root Identity Map #

In Domain-Driven Design, you might implement an Identity Map for aggregate roots to enforce consistency within bounded contexts:

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import java.sql.PreparedStatement;
import java.util.Optional;

public class UserRepository {
    private final IdentityMap<User> userIdentityMap = new IdentityMap<>();
    private final JdbcTemplate jdbcTemplate;

    public UserRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public Optional<User> findById(Long userId) {
        // Check cache first
        User cachedUser = userIdentityMap.get(userId);
        if (cachedUser != null) {
            return Optional.of(cachedUser);
        }

        // Fetch from DB and populate cache
        String sql = "SELECT id, username, email FROM users WHERE id = ?";
        return jdbcTemplate.query(sql, new Object[]{userId}, rs -> {
            if (rs.next()) {
                User user = new User(
                    rs.getLong("id"),
                    rs.getString("username"),
                    rs.getString("email")
                );
                userIdentityMap.put(userId, user);
                return Optional.of(user);
            }
            return Optional.empty();
        }).stream().findFirst();
    }

    public void save(User user) {
        if (user.getId() == null) {
            // Insert new user
            String insertSql = "INSERT INTO users (username, email) VALUES (?, ?)";
            KeyHolder keyHolder = new GeneratedKeyHolder();
            jdbcTemplate.update(connection -> {
                PreparedStatement stmt = connection.prepareStatement(insertSql, new String[]{"id"});
                stmt.setString(1, user.getUsername());
                stmt.setString(2, user.getEmail());
                return stmt;
            }, keyHolder);
            user.setId(keyHolder.getKey().longValue());
        } else {
            // Update existing user
            String updateSql = "UPDATE users SET username = ?, email = ? WHERE id = ?";
            jdbcTemplate.update(updateSql, user.getUsername(), user.getEmail(), user.getId());
        }
        // Sync cache with saved state
        userIdentityMap.put(user.getId(), user);
    }
}

Key Takeaways #

• ORM frameworks like Hibernate/Spring Data JPA handle Identity Map automatically via session/persistence context—this is what most enterprise apps use.
• Custom implementations are great for learning the pattern, lightweight apps, or DDD scenarios where you need fine-grained control over cache lifecycle.

内容的提问来源于stack exchange，提问作者Ramesh Fadatare