feat: 4단계 - Simple Entity Object

src/main/java/jdbc/RowMapper.java

@@ -5,5 +5,6 @@
 
 @FunctionalInterface
 public interface RowMapper<T> {
-    T mapRow(final ResultSet resultSet) throws SQLException;
+    T mapRow(final ResultSet resultSet)
+        throws SQLException, InstantiationException, IllegalAccessException;
 }

src/main/java/persistence/entity/EntityManager.java

@@ -0,0 +1,29 @@
+package persistence.entity;
+
+public interface EntityManager {
+    /**
+     * Finds an entity by its id
+     *
+     * @param entityClass the entity class
+     * @param id the id of the entity
+     * @return the entity
+     *
+     * @param <T> the entity type
+     */
+    <T> T find(Class<T> entityClass, Long id);
+
+    /**
+     * Persists the entity object
+     *
+     * @param entity entity object to persist
+     * @return the persisted entity object
+     */
+    Object persist(Object entity);
+
+    /**
+     * Removes the entity object
+     *
+     * @param entity entity object to remove
+     */
+    void remove(Object entity);
+}

src/main/java/persistence/entity/EntityRowMapperFactory.java

@@ -0,0 +1,50 @@
+package persistence.entity;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+import java.util.stream.Collectors;
+import jdbc.RowMapper;
+import persistence.exception.ReflectionRuntimeException;
+import persistence.sql.ddl.ColumnTranslator;
+
+public class EntityRowMapperFactory {
+
+    private EntityRowMapperFactory() {
+        // Do nothing
+    }
+
+    public static class LazyLoadEntityRowMapperFactory {
+        private static final EntityRowMapperFactory INSTANCE = new EntityRowMapperFactory();
+    }
+
+    public static EntityRowMapperFactory getInstance() {
+        return LazyLoadEntityRowMapperFactory.INSTANCE;
+    }
+
+    public <T> RowMapper<T> getRowMapper(Class<T> entityClass) {
+        return resultSet -> {
+            try {
+                ColumnTranslator columnTranslator = new ColumnTranslator();
+                Constructor<T> declaredConstructor = entityClass.getDeclaredConstructor();
+                declaredConstructor.setAccessible(true);
+                T entity = entityClass.getDeclaredConstructor().newInstance();
+
+                List<Field> columnFieldList = columnTranslator.getColumnFieldStream(entityClass)
+                    .collect(Collectors.toList());
+
+                for (Field field : columnFieldList) {
+                    field.setAccessible(true);
+                    String columnName = columnTranslator.getColumnNameFrom(field);
+                    field.set(entity, resultSet.getObject(columnName));
+                }
+
+                return entity;
+            } catch (InstantiationException | IllegalAccessException | NoSuchMethodException |
+                     InvocationTargetException e) {
+                throw new ReflectionRuntimeException(entityClass, e);
+            }
+        };
+    }
+}

src/main/java/persistence/entity/impl/EntityManagerImpl.java

@@ -0,0 +1,48 @@
+package persistence.entity.impl;
+
+import jdbc.JdbcTemplate;
+import persistence.entity.EntityManager;
+import persistence.entity.EntityRowMapperFactory;
+import persistence.sql.QueryTranslator;
+
+public class EntityManagerImpl implements EntityManager {
+    private final JdbcTemplate jdbcTemplate;
+
+    private final QueryTranslator queryTranslator;
+
+    public EntityManagerImpl(JdbcTemplate jdbcTemplate) {
+        this(jdbcTemplate, new QueryTranslator());
+    }
+
+    public EntityManagerImpl(JdbcTemplate jdbcTemplate, QueryTranslator queryTranslator) {
+        this.jdbcTemplate = jdbcTemplate;
+        this.queryTranslator = queryTranslator;
+    }
+
+
+    @Override
+    public <T> T find(Class<T> entityClass, Long id) {
+        String selectByIdQuery = queryTranslator.getSelectByIdQuery(entityClass, id);
+
+        return jdbcTemplate.queryForObject(
+            selectByIdQuery,
+            EntityRowMapperFactory.getInstance().getRowMapper(entityClass)
+        );
+    }
+
+    @Override
+    public Object persist(Object entity) {
+        String insertQuery = queryTranslator.getInsertQuery(entity);
+
+        jdbcTemplate.execute(insertQuery);
+
+        return entity;
+    }
+
+    @Override
+    public void remove(Object entity) {
+        String deleteQueryFromEntity = queryTranslator.getDeleteQueryFromEntity(entity);
+
+        jdbcTemplate.execute(deleteQueryFromEntity);
+    }
+}

src/main/java/persistence/exception/ReflectionRuntimeException.java

@@ -0,0 +1,7 @@
+package persistence.exception;
+
+public class ReflectionRuntimeException extends RuntimeException {
+    public ReflectionRuntimeException(Class<?> clazz, Exception e) {
+        super("Reflection error on class: " + clazz.getName(), e);
+    }
+}

src/main/java/persistence/sql/exception/UnsupportedClassException.java → src/main/java/persistence/exception/UnsupportedClassException.java

@@ -1,4 +1,4 @@
-package persistence.sql.exception;
+package persistence.exception;
 
 public class UnsupportedClassException extends RuntimeException {
 

src/main/java/persistence/sql/exception/constraints/UnsupportedFieldException.java → src/main/java/persistence/exception/UnsupportedFieldException.java

@@ -1,4 +1,4 @@
-package persistence.sql.exception.constraints;
+package persistence.exception;
 
 import java.lang.reflect.Field;