[TIL] 221205 - JPA : JPA 소개

SpringBoot Part4 (1) 

 

 

Spring Frameworks을 활용한 데이터 레이어(RDB) 접근 방법

H2Database

: In-memory 데이터 베이스 ( 서버가 내려가면 메모리가 전부 날라감 )

: 보통 샘플코드나 테스트를 할때 사용.

 

JDBC

자바 어플리케이션은 JDBC API를 이용하여 데이터 계층과 통신한다.

@Slf4j
public class JDBCTest {

    // H2DB의 url과 default userName, pass
    static final String JDBC_DRIVER = "org.h2.Driver";
    static final String DB_URL = "jdbc:h2:~/test";
    static final String USER = "sa";
    static final String PASS = "";

    static final String DROP_TABLE_SQL = "DROP TABLE customers IF EXISTS";
    static final String CREATE_TABLE_SQL = "CREATE TABLE customers(id SERIAL, first_name VARCHAR(255), last_name VARCHAR(255))";
    static final String INSERT_SQL = "INSERT INTO customers (id, first_name, last_name) VALUES(1, 'honggu', 'kang')";

    @Test
    void jdbc_sample() {
        try {
            // jdbc driver 설정
            Class.forName(JDBC_DRIVER);

            // DB 연결
            Connection connection = DriverManager.getConnection(DB_URL, USER, PASS);
            log.info("Connection 획득");

            // 통신을 하기 위한 statement 객체 - 쿼리를 날릴 수 있다.
            Statement statement = connection.createStatement();
            log.info("Statement 획득");

            log.info("쿼리 실행");
            statement.executeUpdate(DROP_TABLE_SQL);
            statement.executeUpdate(CREATE_TABLE_SQL);

            statement.executeUpdate(INSERT_SQL);
            // ResultSet 조회된 정보를 순환하며 볼수 있는 객체
            ResultSet resultSet = statement.executeQuery("SELECT id, first_name, last_name FROM customers WHERE id = 1");

            while(resultSet.next()) {
                log.info(resultSet.getString("first_name"));
            }

            // 셍성된 connection 반납
            log.info("반납, 반납");
            statement.close();
            connection.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

• JDBC template

기존 JDBC를 이용했을때의 반복적인 작업을 JDBC Template이 대신 수행해준다.

JDBC template을 사용하기 위해선 SpringApplicationContext가 떠야한다.

@Slf4j
@SpringBootTest
public class JDBCTest {

    static final String DROP_TABLE_SQL = "DROP TABLE customers IF EXISTS";
    static final String CREATE_TABLE_SQL = "CREATE TABLE customers(id SERIAL, first_name VARCHAR(255), last_name VARCHAR(255))";
    static final String INSERT_SQL = "INSERT INTO customers (id, first_name, last_name) VALUES(1, 'honggu', 'kang')";

    @Autowired
    JdbcTemplate jdbcTemplate;

    @Test
    void jdbcTemplate_sample(){
        jdbcTemplate.update(DROP_TABLE_SQL);
        jdbcTemplate.update(CREATE_TABLE_SQL);
        log.info("CREATED TABLE USING JDBC TEMPLATE");

        jdbcTemplate.update(INSERT_SQL);
        log.info("CREATED CUSTOMER RECORD JDBC TEMPLATE");

        String fullName = jdbcTemplate.queryForObject(
                "SELECT * FROM customers WHERE id = 1",
                (resultSet,i)-> resultSet.getString("first_name")+ " "+ resultSet.getString("last_name"));
        log.info("FULL NAME : {}",fullName);
    }
}

단점 → java code 상에 JDBC 구문을 작성하여 쿼리 관리가 어려워진다.

 

MyBatis

JDBC의 반복적인 작업을 쿼리메퍼인 Mybatis가 대신 수행하며 자바코드와 쿼리를 분리해준다.

쿼리 수정으로 자바 코드를 수정 하거나 컴파일 하는 작업을 하지 않아도 된다.

 

(spring-boot-starter 패키지는 기본적으로 auto configuration 으로 설정이 가능 )

mybatis:
  type-aliases-package: com.kdt.lecture.repository.domain  # 쿼리 결과(resultSet)를 어떤 package에 mapping 할지
  configuration:
    map-underscore-to-camel-case: true # 언더바 형태 필드를 -> 카멜케이스 형태로 매칭
    default-fetch-size: 100 # 한번에 몇개씩 가져 올것인가.
    default-statement-timeout: 30  # statement 객체가 통신하는 time limit
  mapper-locations: classpath:mapper/*.xml # 쿼리를 관리하는 위치

 

쿼리를 사용하는 방법

 

1. Annotiation 이용

// Using Annotation
@Mapper
public interface CustomerMapper {
    @Insert("INSERT INTO customers (id, first_name, last_name) VALUES(#{id}, #{firstName}, #{lastName})")
    void save(Customer customer);

    @Update("UPDATE customers SET first_name=#{firstName}, last_name=#{lastName} WHERE id=#{id}")
    void update(Customer customer);

    @Select("SELECT * FROM customers")
    List<Customer> findAll();

    @Select("SELECT * FROM customers WHERE id = #{id}")
    Customer findById(@Param("id") long id);
}

 

2. XML 이용

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kdt.lecture.repository.CustomerMapper">
    <insert id="save">
        INSERT INTO customers (id, first_name, last_name)
        VALUES (#{id}, #{firstName}, #{lastName})
    </insert>

    <update id="update">
        UPDATE customers
        SET first_name=#{firstName},
            last_name=#{lastName}
        WHERE id = #{id}
    </update>

    <select id="findById" resultType="customers">
        SELECT *
        FROM customers
        WHERE id = #{id}
    </select>

    <select id="findAll" resultType="customers">
        SELECT *
        FROM customers
    </select>
</mapper>

 

com.kdt.lecture.repository.CustomerMapper

@Mapper
public interface CustomerMapper {

    void save(Customer customer);
    Customer findById(long id);
}

 

사용하기

customerMapper.save(new Customer(1L, "youngji", "jang"));
Customer customer = customerMapper.findById(1L);

⇒ RDB와 java 객체가 갖는 패러다임의 불일치가 생기게 되는데 JPA를 이용해 보완할 수 있다.

 

JPA (Object Relation Mapper)

Spring :
  datasource:
    hikari:
      driver-class-name: org.h2.Driver
      url: jdbc:h2:~/test
      username: sa
      password:
  jpa:
    generate-ddl: true  #ddl option
    open-in-view: false
    show-sql: true    #sql 쿼리 확인

 

객체 생성

@Entity // 실제 RDB 테이블과 mapping이 되는 객체 라는 것을 명시
@Table(name = "customer") // table ㅇ어노테이션이 없으면 기본적으로 class 명과 동일한 테이블을 찾는다.
public class CustomerEntity {

    @Id // pk 명시
    private long id;
    private String firstName;
    private String lastName;

    //getter setter를 통해 entity 작동
    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

 

 

객체와 매핑될 repository interface - JpaRepository 구현체 상속

public interface CustomerRepository extends JpaRepository<CustomerEntity, Long> {
}

 

사용하기

@Slf4j
@SpringBootTest
public class JPATest {

    @Autowired
    CustomerRepository customerRepository;

    @BeforeEach
    void setUp() {
    }

    @AfterEach
    void tearDown() {
        customerRepository.deleteAll();
    }

    @Test
    void INSERT_TEST() {

        //Given
        CustomerEntity customer = new CustomerEntity();
        customer.setId(1L);
        customer.setFirstName("youngji");
        customer.setLastName("jang");

        //When
        customerRepository.save(customer);

        //then
        CustomerEntity entity = customerRepository.findById(1L).get();
        log.info("{} {}", entity.getFirstName(), entity.getLastName());
    }

    @Test
    @Transactional // 영속석 컨텍스트 안에서 관리를 하겠다.
    void UPDATE_TEST(){
        //Given
        CustomerEntity customer = new CustomerEntity();
        customer.setId(1L);
        customer.setFirstName("youngji");
        customer.setLastName("jang");
        customerRepository.save(customer);

        //When
        CustomerEntity entity = customerRepository.findById(1L).get();

        //then
        entity.setFirstName("guppy");
        entity.setLastName("kang");
        // 따로 저장을 하지 않아도 영속석 컨텍스트에 의해 더티 체킹하고 있어 감지를 하고 속성이 변경되면 자동적으로 update 쿼리가 날라간다.
        CustomerEntity updated = customerRepository.findById(1L).get();
        log.info("{} {}", updated.getFirstName(), updated.getLastName());
    }
}

: entity 객체만 수정하여도 영속성 컨텍스트에 의해 변경이 감지되서 자동적으로 쿼리가 실행된 것을 볼 수 있다.

: 컬럼 추가나 변경이 있을때도 객체만 변경하면 쿼리를 손대지 않고 손쉽게 테이블 변경이 가능하다.

 

 

JPA 사용 이유 (ORM 프레임워크 → 객체와 관계형 테이블을 매핑해준다.)

1. 생산성 증진
   • → SQL에 의존적인 개발에서 탈피하여, 객체중심으로 생산적인 개발이 가능하다.
2. 객체와 관계형 테이블의 패러다임 불일치를 보완
   • → 객체 지향 프로그램은 추상화, 캡슐화, 상속, 다형성 등을 제공한다.
   • → 관계형 데이터베이스는 데이터 중심으로 구조화 되어있으며, OOP의 특징을 지원하지 않는다.

 

JPA 프로젝트 세팅

• configration 세팅

→ spring boot의 auto configration으로 설정 가능. 내부적으로 어떻게 세팅 되는지 확인하기~

@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource(){
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("org.h2.Driver");
        dataSource.setUrl("jdbc:h2:~/test");
        dataSource.setUsername("sa");
        dataSource.setPassword("");
        return dataSource;
    }

    // 어떤 구현체를 쓸지 설정
    // jpa 구현체들 중에 hibernate를 가장 많이 사용한다.
    @Bean
    public JpaVendorAdapter jpaVendorAdapter(JpaProperties jpaProperties){ //yaml을 통해 설정한 JpaProperties Bean에 주입됨
        AbstractJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
        jpaVendorAdapter.setShowSql(jpaProperties.isShowSql());
        jpaVendorAdapter.setDatabasePlatform(jpaProperties.getDatabasePlatform());
        jpaVendorAdapter.setGenerateDdl(jpaProperties.isGenerateDdl());

        return jpaVendorAdapter;
    }

    // entity manager factory - 테이블과 매핑될 entity를 관리
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(DataSource dataSource,JpaVendorAdapter jpaVendorAdapter,
                                                                           JpaProperties jpaProperties) {

        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource); // 어떤 데이터 베이스를 쓸것인지
        em.setPackagesToScan("com.example.kdtjpapractice.domain"); // entity를 어떤 패키지에 두고 관리할 것인지.
        em.setJpaVendorAdapter(jpaVendorAdapter); // 위에 명시한 hibernate adapter를 사용할 것이다.

        // 추가 hibernate 튜닝 - yaml에 설정
        Properties properties = new Properties();
        properties.putAll(jpaProperties.getProperties());
        em.setJpaProperties(properties);

        return em;
    }

    // transaction manger - RDB의 트랜잭션 관리
    @Bean
    public PlatformTransactionManager transactionManager(LocalContainerEntityManagerFactoryBean entityManagerFactoryBean){
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactoryBean.getObject());
        
        return transactionManager;
    }

}

 

yaml JpaProperties 세팅

Spring :
  h2:
    console:
      enabled: true
  jpa:
    generate-ddl: true  #ddl option
    hibernate:
      ddl-auto:
    database: H2
    open-in-view: false
    show-sql: true    #sql 쿼리 확인
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect
        query.in_clause_parameter_padding: true
        hbm2ddl:
          auto: create-drop

 

 

properties.hibernate.dialect 설정시 오류가 발생한다.

 

https://2dongdong.tistory.com/66

해당 구문을 지우고 어떨 dialect를 사용하나 보았다.

 

 

 

https://github.com/jojoldu/freelec-springboot2-webservice/issues/67

아래와 같이 설정하니까 잘 동작한다.

dialect: org.hibernate.dialect.MySQL57Dialect

자동으로 설정되는 것과 어떤 차이가 있는지 알아봐야 할것같다.

 

 

 

 

출처 - backend dev course 강홍구님