[Association - Step 1단계] OneToMany (FetchType.EAGER)

src/main/java/docs/lecture.md

@@ -0,0 +1,28 @@
+## 3/16
+
+### 구현
+```markdown
+- Query
+- Entity
+-> 이렇게 2개의 패키지로 나누고, 1주차 미션과 약간 별개일 수 있다.
+
+- SessionImpl 에 의해 session 을 계속 넣어서 다닌다.
+    - `return new StatefulPersistenceContext(this);`
+- StatefulPersistenceContext
+    - `entitiesByKey`
+    - `collectionsByKey`
+- AnnotationBinder 참고
+
+- InFlightMetadataCollector
+    - metadata 수집
+    - 캐싱 설정(default = true)
+
+```
+
+### logging
+```markdown
+- logging.level.org.hibernate.boot=trace
+- logging.level.org.hibernate=trace => 직접 api 실행해서 로깅 확인
+- Spring 은 로깅해서 확인해보는 것을 추천 => Spring 공부!
+```
+

src/main/java/docs/step1.md

@@ -0,0 +1,20 @@
+# 1단계 - OneToMany (FetchType.EAGER)
+
+## 요구사항 1 - Join Query 만들기
+
+- Sql 쿼리 문을 수정해 보자
+```java
+public class CustomSelect {
+
+}
+
+```
+
+## 요구사항 2 - Join Query 를 만들어 Entity 화 해보기
+
+- FetchType.EAGER 인 경우
+```java
+public class SimplePersistenceContext implements PersistenceContext {
+
+}
+```

src/main/java/entity/Order.java

@@ -0,0 +1,69 @@
+package entity;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+
+import java.util.List;
+import java.util.Objects;
+
+@Entity
+@Table(name = "orders")
+public class Order {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "order_number")
+    private String orderNumber;
+
+    @OneToMany(fetch = FetchType.EAGER)
+    @JoinColumn(name = "order_id")
+    private List<OrderItem> orderItems;
+
+    public Order() {
+    }
+
+    public Order(Long id, String orderNumber, List<OrderItem> orderItems) {
+        this.id = id;
+        this.orderNumber = orderNumber;
+        this.orderItems = orderItems;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getOrderNumber() {
+        return orderNumber;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (object == null || getClass() != object.getClass()) return false;
+        Order order = (Order) object;
+        return Objects.equals(id, order.id) && Objects.equals(orderNumber, order.orderNumber) && Objects.equals(orderItems, order.orderItems);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, orderNumber, orderItems);
+    }
+
+    @Override
+    public String toString() {
+        return "Order{" +
+                "id=" + id +
+                ", orderNumber='" + orderNumber + '\'' +
+                ", orderItems=" + orderItems +
+                '}';
+    }
+}

src/main/java/entity/OrderItem.java

@@ -0,0 +1,65 @@
+package entity;
+
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+
+import java.util.Objects;
+
+@Entity
+@Table(name = "order_items")
+public class OrderItem {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    private String product;
+
+    private Integer quantity;
+
+    public OrderItem() {
+    }
+
+    public OrderItem(Long id, String product, Integer quantity) {
+        this.id = id;
+        this.product = product;
+        this.quantity = quantity;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getProduct() {
+        return product;
+    }
+
+    public Integer getQuantity() {
+        return quantity;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (this == object) return true;
+        if (object == null || getClass() != object.getClass()) return false;
+        OrderItem orderItem = (OrderItem) object;
+        return Objects.equals(id, orderItem.id) && Objects.equals(product, orderItem.product) && Objects.equals(quantity, orderItem.quantity);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, product, quantity);
+    }
+
+    @Override
+    public String toString() {
+        return "OrderItem{" +
+                "id=" + id +
+                ", product='" + product + '\'' +
+                ", quantity=" + quantity +
+                '}';
+    }
+}

src/main/java/persistence/entity/EntitySnapshot.java

@@ -1,6 +1,6 @@
 package persistence.entity;
 
-import pojo.FieldInfo;
+import pojo.EntityColumn;
 import pojo.FieldInfos;
 
 import java.lang.reflect.Field;
@@ -17,7 +17,7 @@ public class EntitySnapshot {
     public EntitySnapshot(Object entity) {
         List<Field> fields = new FieldInfos(entity.getClass().getDeclaredFields()).getIdAndColumnFields();
         this.map = fields.stream()
-                .map(field -> new FieldInfo(field, entity))
+                .map(field -> new EntityColumn(field, entity))
                 .collect(Collectors.toMap(
                         fieldInfo -> fieldInfo.getFieldName().getName(),
                         fieldInfo -> fieldInfo.getFieldValue().getValue()

src/main/java/persistence/sql/ddl/CreateQueryBuilder.java

@@ -34,9 +34,10 @@ public CreateQueryBuilder(Dialect dialect, EntityMetaData entityMetaData) {
 
     public String createTable(Object entity) {
         FieldInfos fieldInfos = new FieldInfos(entity.getClass().getDeclaredFields());
-        return String.format(CREATE_TABLE_QUERY, entityMetaData.getTableInfo().getName(), createClause(fieldInfos.getFieldDataList(), entity));
+        return String.format(CREATE_TABLE_QUERY, entityMetaData.getEntityName(), createClause(fieldInfos.getFieldDataList(), entity));
     }
 
+    //create 시에 JoinColumn 어노테이션이 있는 필드는 -> JoinColumn 의 name 을 그 필드 객체 생성 시 만들어줘야 한다.
     private String createClause(List<Field> fields, Object entity) {
         return fields.stream()
                 .filter(field -> !field.isAnnotationPresent(Transient.class))

src/main/java/persistence/sql/ddl/DropQueryBuilder.java

@@ -4,7 +4,7 @@
 
 public class DropQueryBuilder {
 
-    private static final String DROP_TABLE_QUERY = "DROP TABLE %s IF EXISTS;";
+    private static final String DROP_TABLE_QUERY = "DROP TABLE IF EXISTS %s;";
 
     private final EntityMetaData entityMetaData;
 
@@ -13,6 +13,6 @@ public DropQueryBuilder(EntityMetaData entityMetaData) {
     }
 
     public String dropTable() {
-        return String.format(DROP_TABLE_QUERY, entityMetaData.getTableInfo().getName());
+        return String.format(DROP_TABLE_QUERY, entityMetaData.getEntityName());
     }
 }

src/main/java/persistence/sql/dml/CustomSelectQueryBuilder.java

@@ -0,0 +1,72 @@
+package persistence.sql.dml;
+
+import pojo.EntityJoinMetaData;
+import pojo.EntityMetaData;
+import pojo.FieldInfos;
+import pojo.IdField;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.ParameterizedType;
+
+import static constants.CommonConstants.COMMA;
+
+public class CustomSelectQueryBuilder {
+
+    private static final String FIND_BY_ID_JOIN_QUERY = "SELECT %s FROM %s LEFT JOIN %s ON %s = %s WHERE %s = %s;";
+
+    private final EntityJoinMetaData entityJoinMetaData; //Order
+    private final EntityMetaData owner; //OrderItem
+
+    public CustomSelectQueryBuilder(EntityJoinMetaData entityJoinMetaData) {
+        this.entityJoinMetaData = entityJoinMetaData;
+        this.owner = entityJoinMetaData.getOwner();
+    }
+
+    public String findByIdJoinQuery1(Object entity, Class<?> clazz, Object condition) {
+        Field field = new FieldInfos(clazz.getDeclaredFields()).getIdField();
+        IdField idField = new IdField(field, entity);
+
+        return String.format(FIND_BY_ID_JOIN_QUERY, getSelectData(),
+                entityJoinMetaData.getEntityName(), owner.getEntityName(),
+                entityJoinMetaData.getEntityName() + "." + idField.getFieldNameData(),
+                owner.getEntityName() + "." + entityJoinMetaData.joinColumnName(),
+                entityJoinMetaData.getEntityName() + "." + idField.getFieldNameData(), condition);
+    }
+
+    /**
+     * 아래 방법을 고민 중이라서 한번 피드백 부탁드립니다.
+     */
+    public String findByIdJoinQuery2(Object entity, Class<?> clazz, Object condition) {
+        Field field = new FieldInfos(clazz.getDeclaredFields()).getIdField();
+        IdField idField = new IdField(field, entity);
+
+        Field joinColumnField = new FieldInfos(clazz.getDeclaredFields()).getJoinColumnField();
+        Class<?> subClass = (Class<?>) ((ParameterizedType) joinColumnField.getGenericType()).getActualTypeArguments()[0];
+        EntityMetaData owner = new EntityMetaData(subClass, null);
+
+        return String.format(FIND_BY_ID_JOIN_QUERY, getSelectData(),
+                entityJoinMetaData.getEntityName(), owner.getEntityName(),
+                entityJoinMetaData.getEntityName() + "." + idField.getFieldNameData(),
+                owner.getEntityName() + "." + entityJoinMetaData.joinColumnName(),
+                entityJoinMetaData.getEntityName() + "." + idField.getFieldNameData(), condition);
+    }
+
+    private String getSelectData() {
+        String entityData = entityJoinMetaData.getEntityColumns()
+                .stream()
+                .map(entityColumn -> entityColumn.getFieldName().getName())
+                .map(name -> entityJoinMetaData.getEntityName() + "." + name)
+                .reduce((o1, o2) -> String.join(COMMA, o1, o2))
+                .orElseThrow(() -> new IllegalStateException("Id 혹은 Column 타입이 없습니다."));
+
+        String ownerEntityData = owner.getEntityColumns()
+                .stream()
+                .map(entityColumn -> entityColumn.getFieldName().getName())
+                .map(name -> owner.getEntityName() + "." + name)
+                .reduce((o1, o2) -> String.join(COMMA, o1, o2))
+                .orElseThrow(() -> new IllegalStateException("Id 혹은 Column 타입이 없습니다."));
+
+        return entityData + COMMA + ownerEntityData;
+    }
+
+}

src/main/java/persistence/sql/dml/DeleteQueryBuilder.java

@@ -17,7 +17,7 @@ public DeleteQueryBuilder(EntityMetaData entityMetaData) {
     }
 
     public String deleteQuery(IdField idField) {
-        return String.format(DELETE_QUERY, entityMetaData.getTableInfo().getName(), idField.getFieldNameData(), idField.getFieldValueData());
+        return String.format(DELETE_QUERY, entityMetaData.getEntityName(), idField.getFieldNameData(), idField.getFieldValueData());
     }
 
     public String deleteByIdQuery(Object entity) {

src/main/java/persistence/sql/dml/SelectQueryBuilder.java

@@ -18,13 +18,13 @@ public SelectQueryBuilder(EntityMetaData entityMetaData) {
     }
 
     public String findAllQuery() {
-        return String.format(FIND_ALL_QUERY, entityMetaData.getTableInfo().getName());
+        return String.format(FIND_ALL_QUERY, entityMetaData.getEntityName());
     }
 
     public String findByIdQuery(Object entity, Class<?> clazz, Object condition) {
         Field field = new FieldInfos(clazz.getDeclaredFields()).getIdField();
         IdField idField = new IdField(field, entity);
-        return String.format(FIND_BY_ID_QUERY, entityMetaData.getTableInfo().getName(),
+        return String.format(FIND_BY_ID_QUERY, entityMetaData.getEntityName(),
                 idField.getFieldNameData(), condition);
     }
 }

src/main/java/persistence/sql/dml/UpdateQueryBuilder.java

@@ -1,15 +1,17 @@
 package persistence.sql.dml;
 
+import pojo.EntityColumn;
 import pojo.EntityMetaData;
-import pojo.FieldInfo;
 import pojo.FieldInfos;
 
 import java.lang.reflect.Field;
 import java.util.List;
+import java.util.Objects;
 
 import static constants.CommonConstants.AND;
 import static constants.CommonConstants.COMMA;
 import static constants.CommonConstants.EQUAL;
+import static utils.StringUtils.joinNameAndValue;
 
 public class UpdateQueryBuilder {
 
@@ -23,24 +25,24 @@ public UpdateQueryBuilder(EntityMetaData entityMetaData) {
     }
 
     public String insertQuery(Object entity) {
-        return String.format(INSERT_DATA_QUERY, entityMetaData.getTableInfo().getName(), columnsClause(entity), valuesClause(entity));
+        return String.format(INSERT_DATA_QUERY, entityMetaData.getEntityName(), columnsClause(entity), valuesClause(entity));
     }
 
     public String updateQuery(Object entity) {
-        return String.format(UPDATE_DATA_QUERY, entityMetaData.getTableInfo().getName(), setClause(entity), whereClause(entity));
+        return String.format(UPDATE_DATA_QUERY, entityMetaData.getEntityName(), setClause(entity), whereClause(entity));
     }
 
     private String columnsClause(Object entity) {
         return new FieldInfos(entity.getClass().getDeclaredFields()).getIdAndColumnFields().stream()
-                .map(field -> new FieldInfo(field, entity))
+                .map(field -> new EntityColumn(field, entity))
                 .map(fieldInfo -> fieldInfo.getFieldName().getName())
                 .reduce((o1, o2) -> String.join(COMMA, o1, String.valueOf(o2)))
                 .orElseThrow(() -> new IllegalStateException("Id 혹은 Column 타입이 없습니다."));
     }
 
     private String valuesClause(Object entity) {
         return new FieldInfos(entity.getClass().getDeclaredFields()).getIdAndColumnFields().stream()
-                .map(field -> new FieldInfo(field, entity))
+                .map(field -> new EntityColumn(field, entity))
                 .map(fieldInfo -> fieldInfo.getFieldValue().getValue())
                 .reduce((o1, o2) -> String.join(COMMA, o1, String.valueOf(o2)))
                 .orElseThrow(() -> new IllegalStateException("Id 혹은 Column 타입이 없습니다."));
@@ -58,10 +60,11 @@ private String whereClause(Object entity) {
 
     private String fieldNameAndValueClause(Object entity, List<Field> fields, String delimiter) {
         return fields.stream()
-                .map(field -> new FieldInfo(field, entity))
-                .filter(FieldInfo::isNotBlankOrEmpty)
-                .map(fieldInfo -> fieldInfo.joinNameAndValueWithDelimiter(EQUAL))
-                .reduce((o1, o2) -> String.join(delimiter, o1, String.valueOf(o2)))
+                .map(field -> new EntityColumn(field, entity))
+                .filter(fieldInfo -> Objects.nonNull(fieldInfo.getFieldName()) && Objects.nonNull(fieldInfo.getFieldValue()))
+                .map(fieldInfo ->
+                        joinNameAndValue(EQUAL, fieldInfo.getFieldName().getName(), String.valueOf(fieldInfo.getFieldValue().getValue())))
+                .reduce((o1, o2) -> String.join(delimiter, o1, o2))
                 .orElseThrow(() -> new IllegalStateException("update 데이터가 없습니다."));
     }
 }