[TIL] 221110 - SpringBoot Part2 : Embedded DB, Named Parameter Template, 트랜잭션

SpringBoot Part2 (4) 

 

1. Embedded DataBase

기존 테스트 : DB 구동이 되지않으면 테스트에 실패하는 구조

→ 외부환경에 영향을 받는 테스트 → 테스트 자동화(jenkins같은 CI 툴을 이용한) 불가

 

Spring에서 Embedded Database 제공

Data Access

Data Access

<dependency>
	<groupId>com.h2database</groupId>
	<artifactId>h2</artifactId>
	<scope>runtime</scope>
</dependency>

EmbeddedDatabase db = new EmbeddedDatabaseBuilder()
                    .generateUniqueName(true)
                    .setType(H2)
                    .setScriptEncoding("UTF-8")
                    .ignoreFailedDrops(true)
                    .addScript("schema.sql")
                    .build();

function을 거의 지원하지않아 최대한 Ansi 표준에 맞게 sql을 작성해야한다.

MySQL이나 PostSQL가튼 경우 Embedded 오픈소스를 제공하여 그것을 이용하여 실제 mySQL DB가 구동되게 해야한다.

 

Embedded MySQL

https://github.com/wix/wix-embedded-mysql

<dependency>
	<groupId>com.wix</groupId>
	<artifactId>wix-embedded-mysql</artifactId>
	<version>4.6.1</version>
	<scope>test</scope>
</dependency>

-

import com.wix.mysql.EmbeddedMysql;
import static com.wix.mysql.EmbeddedMysql.anEmbeddedMysql;
import static com.wix.mysql.ScriptResolver.classPathScript;
import static com.wix.mysql.config.Charset.UTF8;
import static com.wix.mysql.config.MysqldConfig.aMysqldConfig;
import static com.wix.mysql.distribution.Version.v8_0_11;

@SpringJUnitConfig
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@TestInstance(TestInstance.Lifecycle.PER_CLASS) // PER_CLASS : class 마다 인스턴스가 하나
class CustomerJdbcRepositoryTest {

    @Configuration
    @ComponentScan(
            basePackages = {"org.prgrms.kdt.customer"}
    )
    static class Config {

        @Bean
        public DataSource dataSource() {
            HikariDataSource dataSource = DataSourceBuilder.create()
                    .url("jdbc:mysql://localhost:2215/test-order_mgmt")
                    .username("test") 
                    .password("test1234!") // 해당 테스트에서만 사용될 id,pw
                    .type(HikariDataSource.class)
                    .build();
            return dataSource;
        }

        @Bean
        public JdbcTemplate jdbcTemplate(DataSource dataSource) {
            return new JdbcTemplate(dataSource);
        }
    }

    @Autowired
    CustomerJdbcRepository customerJdbcRepository;
    @Autowired
    DataSource dataSource;
    EmbeddedMysql embeddedMysql;

    @BeforeAll
    void setup() {
        //customerJdbcRepository.deleteAll(); // embedded 사용시 어차피 싹다 디비가 내려갔다 올라오기 때문에 삭제해줄 필요없음
        var mysqlConfig = aMysqldConfig(v8_0_11)
                .withCharset(UTF8)
                .withPort(2215)
                .withUser("test", "test1234!")
                .withTimeZone("Asia/Seoul")
                .build();
        embeddedMysql = anEmbeddedMysql(mysqlConfig)
                .addSchema("test-order_mgmt", classPathScript("schema.sql"))
                .start();
    }

    @AfterAll
    void cleanUp() {
        embeddedMysql.stop();
    }
}

별도의 DB를 구동시키지않아도 테스트에 통과하는 것을 확인 할 수있다!

 

UUID 오류

https://remarkablemark.org/blog/2020/05/21/mysql-uuid-bin/

 

 

2. NamedParameterJDBCTemplate

NamedParameterJDBCTemplate

: keyHolder 인덱스기반에서 이름기반의 파라미터를 설정할 수 있게해주는 템플릿

: JDBCTemplate을 포함하며 파라미터만 변경해주는 역할을 한적

 

템플릿 적용

@Repository
public class CustomerJdbcRepository implements CustomerRepository {

    private static final Logger logger = LoggerFactory.getLogger(CustomerJdbcRepository.class);

    private final NamedParameterJdbcTemplate jdbcTemplate;

    private static final RowMapper<Customer> customerRowMapper = new RowMapper<Customer>() {
        @Override
        public Customer mapRow(ResultSet rs, int rowNum) throws SQLException { //resultSet, index
            var customerName = rs.getString("name");
            var customerId = toUUID(rs.getBytes("customer_id"));
            var email = rs.getString("email");
            var createdAt = rs.getTimestamp("created_at").toLocalDateTime();
            var lastLoginAt = rs.getTimestamp("last_login_at") != null ?
                    rs.getTimestamp("last_login_at").toLocalDateTime() : null;

            return new Customer(customerId, customerName, email, lastLoginAt, createdAt);
        }
    };

    private Map<String, Object> toParamMap(Customer customer) {
        return new HashMap<>(){{
            put("customerId", customer.getCustomerId().toString().getBytes());
            put("name",customer.getName());
            put("email",customer.getEmail());
            put("lastLoginAt", customer.getLastLoginAt() != null ? Timestamp.valueOf(customer.getLastLoginAt()):null);
            put("createdAt", customer.getCreatedAt());
        }};
    }

    public CustomerJdbcRepository(NamedParameterJdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Customer insert(Customer customer) {
        var update = jdbcTemplate.update("INSERT INTO customers(customer_id,name,email, created_at)" +
                "  VALUES (UUID_TO_BIN(:customerId),:name,:email,:createdAt)",toParamMap(customer));
        if(update != 1) throw new RuntimeException("Nothing was inserted!");
        return customer;
    }

    @Override
    public Customer update(Customer customer) {

        var update = jdbcTemplate.update("UPDATE customers SET name= :name, email= :email, last_login_at= :lastLoginAt  WHERE customer_id = UUID_TO_BIN(:customerId)",toParamMap(customer));
        if(update != 1) throw new RuntimeException("Nothing was updated!");
        return customer;
    }

    @Override
    public int count() {
        return jdbcTemplate.queryForObject("select count(*) from customers",Collections.EMPTY_MAP,Integer.class);
    }

    @Override
    public List<Customer> findAll() {
        return jdbcTemplate.query("select * from customers", customerRowMapper); //sql,row mapper 전달
    }

    @Override
    public Optional<Customer> findById(UUID customerId) {
        try {
            return Optional.ofNullable(jdbcTemplate.queryForObject("select * from customers WHERE customer_id = UUID_TO_BIN(:customerId)",
                    Collections.singletonMap("customerId",customerId.toString().getBytes()), customerRowMapper));
            // queryForObject -> 하나만 꺼내기 값이 없으면 ㅇㅖ외발생
        }catch (EmptyResultDataAccessException e){
            return Optional.empty();
        }
    }

    @Override
    public void deleteAll() {
        //jdbcTemplate.update("DELETE FROM customers",Collections.emptyMap());
        //empty map을 전달하기 귀찮으면 기존 템플릿을 가져와 사용해도된다.
			 jdbcTemplate.getJdbcTemplate().update("DELETE FROM customers");
    }

    static UUID toUUID(byte[] bytes) {
        var byteBuffer = ByteBuffer.wrap(bytes);
        return new UUID(byteBuffer.getLong(), byteBuffer.getLong());
    }
}

DB를 사용할땐 발생할 수 있는 예외가 다양하다. → JDBC가 SQLException을 발생시킨다.

Spring에서 예외들을 추상화시킨 DataAccessException 제공

 

 

3. 트랜잭션

하나의 작업을 수행하기 위해 필요한 연산들을 모아둔것. 논리적인 작업의 한 단위

출처 - https://jerryjerryjerry.tistory.com/48

 

 

: 각각의 트랜잭션은 원자성, 일관성, 독립성, 영구성을 보장한다.

: 원자성이 commit과 rollback에 의해 보장된다.

: 트랜잭션 상태는 트랜잭션에는 내가 적은 쿼리문과 데이터를 최종적으로 데이터베이스에 반영하는 COMMIT과 실패했을때 COMMINT 시점으로 다시 되돌아가는 ROLLBACK이 있다.

 

spring에서 트랜잭션 처리를하려면 AOP를 알아야한다.

 

JDBC를 이용한 직접 트랜잭션 처리

 // AutoCommit을 꺼서 퀴리 트랜잭션을 하나로 묶은 뒤 작업이 정상 종료되면 다시 킨다.
connection.setAutoCommit(false);
	.. excute 동작
connection.setAutoCommit(true);

// AutoCommit이 켜지기전에 실패하면 rollback후 connection 끊기
connection.rollback();
connection.close();

 

 

 

출처 - 해리 : SpringBoot Part1