4단계 - EntityEntryStep4

README.md

@@ -10,4 +10,8 @@
 
 ## 3단계
 ### 요구 사항1 - 만들었던 PersistenceContext 에서 효율적인 메모리 관리를 위한 기능 구현 (1차 캐싱)[O]
-### 요구 사항2 - 더티체킹 구현[]
+### 요구 사항2 - 더티체킹 구현[O]
+
+## 4단계
+### 요구 사항 1 - Entity 의 라이프 사이클 관리 작업 수행 시 엔터티의 상태를 추가[O]
+

src/main/java/jdbc/JdbcTemplate.java

@@ -25,6 +25,21 @@ public void execute(final String sql) {
         }
     }
 
+    public Long executeAndReturnGeneratedKey(final String sql) {
+        try (final Statement statement = connection.createStatement()) {
+            statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
+            try (ResultSet generatedKeys = statement.getGeneratedKeys()) {
+                if (generatedKeys.next()) {
+                    return generatedKeys.getLong(1);
+                } else {
+                    throw new RuntimeException("No ID generated for the insert.");
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     public <T> T queryForObject(final String sql, final RowMapper<T> rowMapper) {
         final List<T> results = query(sql, rowMapper);
         if (results.size() != 1) {

src/main/java/persistence/entity/EntityEntry.java

@@ -0,0 +1,36 @@
+package persistence.entity;
+
+import static persistence.util.ReflectionCopy.copy;
+
+import java.util.List;
+import lombok.Getter;
+import persistence.sql.dml.ColumnValues;
+
+public class EntityEntry {
+    @Getter
+    private final Object entity;
+    @Getter
+    private Status status;
+    private Object snapshot;
+
+    public EntityEntry(Object entity, Status status) {
+        this.entity = entity;
+        this.status = status;
+    }
+
+    public void updateStatus(Status newStatus) {
+        this.status = newStatus;
+    }
+
+    public void updateSnapshot(Object entity) {
+        this.snapshot = copy(entity);
+    }
+
+    public List<String> findDirtyColumns(Object entity) throws IllegalAccessException {
+        if (status != Status.MANAGED) {
+            throw new IllegalAccessException("Entity is not managed");
+        }
+        return new ColumnValues<>(snapshot).findDifferentColumns(new ColumnValues<>(entity));
+    }
+
+}

src/main/java/persistence/entity/EntityPersister.java

@@ -1,5 +1,6 @@
 package persistence.entity;
 
+import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -25,9 +26,15 @@ public void update(Object entity, List<String> changedColumns) throws IllegalAcc
             .update(entity, changedColumns);
     }
 
-    public void insert(Object entity) throws IllegalAccessException {
-        getEntityQueryHandler(entity.getClass())
+    public Object insert(Object entity) throws IllegalAccessException {
+        long id = getEntityQueryHandler(entity.getClass())
             .insert(entity);
+        return setId(entity, id);
+    }
+
+    public void delete(Object entity) {
+        getEntityQueryHandler(entity.getClass())
+            .delete(entity);
     }
 
     private EntityQueryHandler<?> getEntityQueryHandler(Class<?> entityClass) {
@@ -37,4 +44,15 @@ private EntityQueryHandler<?> getEntityQueryHandler(Class<?> entityClass) {
         return entityQueryHandlerMap.get(entityClass);
     }
 
+    private Object setId(Object entity, long id) throws IllegalAccessException {
+        try {
+            Field idField = entity.getClass().getDeclaredField("id");
+            idField.setAccessible(true);
+            idField.set(entity, id);
+            return entity;
+        } catch (NoSuchFieldException e) {
+            throw new IllegalStateException("Entity does not have an 'id' field", e);
+        }
+    }
+
 }

src/main/java/persistence/entity/EntityQueryHandler.java

@@ -35,16 +35,16 @@ public T findById(Object primaryKey) {
         return jdbcTemplate.queryForObject(sql, entityLoader);
     }
 
-    public void update(Object entity, List<String> changedColumns) throws IllegalAccessException {
+    public void update(Object entity, List<String> updateColumns) throws IllegalAccessException {
         UpdateQuery updateQuery = sqlQueries.getSqlQuery(UPDATE);
-        String sql = updateQuery.generateQuery(entity, changedColumns);
+        String sql = updateQuery.generateQuery(entity, updateColumns);
         jdbcTemplate.execute(sql);
     }
 
-    public void insert(Object entity) throws IllegalAccessException {
+    public long insert(Object entity) throws IllegalAccessException {
         InsertQuery insertQuery = sqlQueries.getSqlQuery(INSERT);
         String sql = insertQuery.generateQuery(entity);
-        jdbcTemplate.execute(sql);
+        return jdbcTemplate.executeAndReturnGeneratedKey(sql);
     }
 
     public void delete(Object entity) {

src/main/java/persistence/entity/PendingEntities.java

@@ -1,26 +1,27 @@
 package persistence.entity;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 
 public class PendingEntities {
 
-    private final Set<Object> pendingEntities = new HashSet<>();
+    private final Map<Integer, EntityEntry> entityEntries = new HashMap<>();
 
     public void persistEntity(Object entity) {
-        pendingEntities.add(entity);
+        entityEntries.put(getKey(entity), new EntityEntry(entity, Status.SAVING));
     }
 
-    public Set<Object> getEntities() {
-        return pendingEntities;
+    public List<Object> getEntities() {
+        return entityEntries.values().stream().map(EntityEntry::getEntity).toList();
     }
 
-    public void removeEntity(Object entity) {
-        pendingEntities.remove(entity);
+    public void evict(Object entity) {
+        entityEntries.remove(getKey(entity));
     }
 
-    public void clear() {
-        pendingEntities.clear();
+    private int getKey(Object entity) {
+        return System.identityHashCode(entity);
     }
 
 }

src/main/java/persistence/entity/PersistedEntities.java

@@ -1,31 +1,63 @@
 package persistence.entity;
 
-import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class PersistedEntities {
 
-    private final Map<EntityKey, Object> persistedEntities = new HashMap<>();
+    private final Map<EntityKey, EntityEntry> entityEntries = new HashMap<>();
 
     public Object findEntity(EntityKey entityKey) {
-        return persistedEntities.getOrDefault(entityKey, null);
+        if (entityEntries.containsKey(entityKey)) {
+            return entityEntries.get(entityKey).getEntity();
+        }
+        return null;
     }
 
     public void persistEntity(EntityKey entityKey, Object entity) {
-        persistedEntities.put(entityKey, entity);
+        var entityEntry = new EntityEntry(entity, Status.MANAGED);
+        entityEntry.updateSnapshot(entity);
+        entityEntries.put(entityKey, entityEntry);
     }
 
-    public void removeEntity(EntityKey entityKey) {
-        persistedEntities.remove(entityKey);
+    public void evict(Object entity) {
+        var entityKey = getKey(entity);
+        entityEntries.remove(entityKey);
     }
 
-    public Collection<Object> getEntities() {
-        return persistedEntities.values();
+    public void changeToDeleteState(EntityKey entityKey) {
+        var entityEntry = entityEntries.get(entityKey);
+        if (entityEntry == null) {
+            return;
+        }
+        entityEntry.updateStatus(Status.DELETED);
     }
 
-    public void clear() {
-        persistedEntities.clear();
+    public List<Object> getDeletedEntities() {
+        return entityEntries.values().stream().filter(e -> e.getStatus() == Status.DELETED).map(EntityEntry::getEntity)
+            .toList();
+    }
+
+    public List<Object> getManagedEntities() {
+        return entityEntries.values().stream().filter(e -> e.getStatus() == Status.MANAGED).map(EntityEntry::getEntity)
+            .toList();
+    }
+
+    public List<String> findDirtyColumns(Object entity) throws IllegalAccessException {
+        var entityKey = getKey(entity);
+        var entityEntry = entityEntries.get(entityKey);
+        return entityEntry.findDirtyColumns(entity);
+    }
+
+    public void updateDatabaseSnapshot(Object entity) {
+        var entityKey = getKey(entity);
+        var entityEntry = entityEntries.get(entityKey);
+        entityEntry.updateSnapshot(entity);
+    }
+
+    private EntityKey getKey(Object entity) {
+        return new EntityKey(new LongTypeId(entity).getId(), entity.getClass().getName());
     }
 
 }

src/main/java/persistence/entity/PersistenceContext.java

@@ -1,24 +1,27 @@
 package persistence.entity;
 
-import java.util.Collection;
-import java.util.Set;
+import java.util.List;
 
 public interface PersistenceContext {
 
     <T> T getEntity(Class<T> entityClass, Object primaryKey);
 
-    void attachEntity(Object entity);
+    void addEntity(Object entity);
+
+    void removeEntity(Object entity);
 
     void detachEntity(Object entity);
 
-    Set<Object> getPendingEntities();
+    List<Object> getSavingEntities();
+
+    List<Object> getDeletedEntities();
 
-    Collection<Object> getPersistedEntities();
+    List<Object> getManagedEntities();
 
-    void captureDatabaseSnapshot(Object entity);
+    List<String> findDirtyColumns(Object entity) throws IllegalAccessException;
 
-    Object getDatabaseSnapshot(Object entity);
+    void updateDatabaseSnapshot(Object entity);
 
-    void reset();
+    void mangeEntity(Object entity) throws IllegalAccessException;
 
 }

src/main/java/persistence/entity/Status.java

@@ -0,0 +1,10 @@
+package persistence.entity;
+
+public enum Status {
+    MANAGED,
+    READ_ONLY,
+    DELETED,
+    GONE,
+    LOADING,
+    SAVING
+}