Spring DB 기술 파헤치기 #2

스프링 DB 2편 - 데이터 접근 활용 기술 강의 - 인프런

 

 

🍀 JdbcTemplate

implementation 'org.springframework.boot:spring-boot-starter-jdbc'

 

참고로 JPA를 사용한다면 spring-boot-starter-data-jpa 에 jdbc 의존성도 포함되어있어 따로 추가할 필요 없다.

 

 

JdbcTemplate은 DataSource를 이용해 직접 생성하거나 빈으로 등록할 수 있다. 다만 스프링 부트를 사용한다면 그냥 바로 쓰면되는데,  JdbcTemplateAutoConfiguration 에 의해 JdbcTemplate, NamedParameterJdbcTemplate 빈이 없다면 등록하게 구성되어있다.

JdbcTemplate은 JdbcOperations 인터페이스의 구현체이다. 즉 수동으로 등록 해둔 빈이 없다면 자동으로 추가한다.

 

 

이후 사용법은 너무나 간단하다. dataSource로 JdbcTemplate를 만들어서 사용하면 된다.

 

• execute() 그냥 sql 자체를 실행하고 싶을 때, 서비스에서 사용할 일은 거의 없다.

jdbcTemplate.execute("create table mytable (id integer, name varchar(100))");

 jdbcTemplate.update(
         "call SUPPORT.REFRESH_ACTORS_SUMMARY(?)",
         Long.valueOf(unionId));

 

• update : 영향받은 row 수를 반환한다. (update, insert, delete)
• insert 를 할 때 자동 생성한 pk 를 얻고싶다면 KeyHolder = new GenereatedKeyHolder()를 update에 같이 넘기면 된다.

String sql = "update item set item_name=?, price=?, quantity=? where id=?";
template.update(sql,
        updateParam.getItemName(),
        updateParam.getPrice(),
        updateParam.getQuantity(),
        itemId);

 

 

• query: 기본 메서드, 잘 사용하지않는다. 단건 조회는 queryForObject() 사용 권장
• queryForXXX: 읽어보면 바로 알 수 있다. 참고로 queryForStream은 타입만 Stream<>일 뿐이다. 병렬처리는 지원하지 않는다.

 int countOfActorsNamedJoe = jdbcTemplate.queryForObject(
         "select count(*) from t_actor where first_name = ?", Integer.class,"Joe");

 String lastName = jdbcTemplate.queryForObject( "select last_name from t_actor where id = ?", String.class, 1212L);
 
 
 Actor actor = jdbcTemplate.queryForObject(
         "select first_name, last_name from t_actor where id = ?",
         (resultSet, rowNum) -> {
    Actor newActor = new Actor();
    newActor.setFirstName(resultSet.getString("first_name"));
    newActor.setLastName(resultSet.getString("last_name"));
    return newActor;
}, 1212L);

List<Actor> actors = jdbcTemplate.query(
         "select first_name, last_name from t_actor",
         (resultSet, rowNum) -> {
             Actor actor = new Actor();
             actor.setFirstName(resultSet.getString("first_name"));
             actor.setLastName(resultSet.getString("last_name"));
             return actor;
});

 

 

실제 Repository를 구현해보면 아래와 같다.

public class JdbcTemplateItemRepository implements ItemRepository {

    private final JdbcTemplate template;

    public JdbcTemplateItemRepository(DataSource dataSource) {
        this.template = new JdbcTemplate(dataSource);
    }

    @Override
    public Item save(Item item) {
        String sql = "insert into item(item_name, price, quantity) values (?,?,?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();
        template.queryFor
        template.update(connection -> {
            //자동 증가 키
            PreparedStatement ps = connection.prepareStatement(sql, new String[]{"id"});
            ps.setString(1, item.getItemName());
            ps.setInt(2, item.getPrice());
            ps.setInt(3, item.getQuantity());
            return ps;
        }, keyHolder);

        long key = keyHolder.getKey().longValue();
        item.setId(key);
        return item;
    }

    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        String sql = "update item set item_name=?, price=?, quantity=? where id=?";
        template.update(sql,
                updateParam.getItemName(),
                updateParam.getPrice(),
                updateParam.getQuantity(),
                itemId);
    }

    @Override
    public Optional<Item> findById(Long id) {
        String sql = "select id, item_name, price, quantity from item where id = ?";
        try {
            Item item = template.queryForObject(sql, itemRowMapper(), id);
            return Optional.of(item);
        } catch (EmptyResultDataAccessException e) {
            return Optional.empty();
        }
    }

    @Override
    public List<Item> findAll(ItemSearchCond cond) {
        String itemName = cond.getItemName();
        Integer maxPrice = cond.getMaxPrice();

        String sql = "select id, item_name, price, quantity from item";
        //동적 쿼리
        if (StringUtils.hasText(itemName) || maxPrice != null) {
            sql += " where";
        }

        boolean andFlag = false;
        List<Object> param = new ArrayList<>();
        if (StringUtils.hasText(itemName)) {
            sql += " item_name like concat('%',?,'%')";
            param.add(itemName);
            andFlag = true;
        }

        if (maxPrice != null) {
            if (andFlag) {
                sql += " and";
            }
            sql += " price <= ?";
            param.add(maxPrice);
        }

        return template.query(sql, itemRowMapper(), param.toArray());
    }

    private RowMapper<Item> itemRowMapper() {
        return ((rs, rowNum) -> {
            Item item = new Item();
            item.setId(rs.getLong("id"));
            item.setItemName(rs.getString("item_name"));
            item.setPrice(rs.getInt("price"));
            item.setQuantity(rs.getInt("quantity"));
            return item;
        });
    }
}

 

 

 

그 외 미리 만들어둔 편의기능들이 존재한다.

• SimpleJdbcInsert 를 미리 만들어 등록해두면, insert를 메서드 하나로 할 수 있다.

public class JdbcTemplateItemRepository implements ItemRepository {

    private final NamedParameterJdbcTemplate template;
    private final SimpleJdbcInsert jdbcInsert;

    public JdbcTemplateItemRepositoryV3(DataSource dataSource) {
        this.template = new NamedParameterJdbcTemplate(dataSource);
        this.jdbcInsert = new SimpleJdbcInsert(dataSource)
                .withTableName("item")
                .usingGeneratedKeyColumns("id")
                .usingColumns("item_name", "price", "quantity"); // usingColumns 는 생략 가능
    }

    @Override
    public Item save(Item item) {
        SqlParameterSource param = new BeanPropertySqlParameterSource(item);
        Number key = jdbcInsert.executeAndReturnKey(param);
        item.setId(key.longValue());
        return item;
    }
}

 

• NamedParameterJdbcTemplate 를 사용하면 :itemName 으로 바인딩 할 수 있다.
• BeanPropertyRowMapper.newInstance(MyClass.class) 같이 편의용 rowMapper를 제공한다. 필드 camel 변환도 지원!

• SimpleJdbcCall 같은 프로시저 콜도 있지만, 사용할 일이 없으므로 생략
  

public class JdbcTemplateItemRepository implements ItemRepository {

    private final NamedParameterJdbcTemplate template;
    private final SimpleJdbcInsert jdbcInsert;

    public JdbcTemplateItemRepositoryV3(DataSource dataSource) {
        this.template = new NamedParameterJdbcTemplate(dataSource);
        this.jdbcInsert = new SimpleJdbcInsert(dataSource)
                .withTableName("item") // 테이블 명
                .usingGeneratedKeyColumns("id") // pk 명
                // 생략하더라도 DB 메타 읽어서 맞춰줌. 생략 가능하나 특정 칼럼만 사용하고 싶을 때 사용
                .usingColumns("item_name", "price", "quantity");
    }
    
    @Override
    public Item save(Item item) {
        SqlParameterSource param = new BeanPropertySqlParameterSource(item);
        // 이렇게 매우 편하게 쓸 수 있다.
        Number key = jdbcInsert.executeAndReturnKey(param);
        item.setId(key.longValue());
        return item;
    }
    
    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        String sql = "update item " +
                "set item_name=:itemName, price=:price, quantity=:quantity " +
                "where id=:id";

        SqlParameterSource param = new MapSqlParameterSource()
                .addValue("itemName", updateParam.getItemName())
                .addValue("price", updateParam.getPrice())
                .addValue("quantity", updateParam.getQuantity())
                .addValue("id", itemId); //이 부분이 별도로 필요하다.

        template.update(sql, param);
    }

    
    @Override
    public List<Item> findAll(ItemSearchCond cond) {
        String itemName = cond.getItemName();
        Integer maxPrice = cond.getMaxPrice();

        SqlParameterSource param = new BeanPropertySqlParameterSource(cond);

        String sql = "select id, item_name, price, quantity from item";
        //동적 쿼리
        if (StringUtils.hasText(itemName) || maxPrice != null) {
            sql += " where";
        }

        boolean andFlag = false;
        if (StringUtils.hasText(itemName)) {
            sql += " item_name like concat('%',:itemName,'%')";
            andFlag = true;
        }

        if (maxPrice != null) {
            if (andFlag) {
                sql += " and";
            }
            sql += " price <= :maxPrice";
        }

        log.info("sql={}", sql);
        return template.query(sql, param, itemRowMapper());
    }

    private RowMapper<Item> itemRowMapper() {
        return BeanPropertyRowMapper.newInstance(Item.class); //camel 변환 지원
    }
}

 

 

 

 

 

 

🍀 MyBatis

https://mybatis.org/mybatis-3/ko/getting-started.html

implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.0'

스프링 필요없으면 공식문서보고 org.mybatis.mybatis 쓰면 된다

spring:
  profiles:
    active: local
  datasource:
    url: jdbc:h2:tcp://localhost/~/test
    username: sa
  logging:
    level:
      org:
        springframework:
          jdbc: debug

mybatis:
  # xml 파일에서 사용할 기본 패키지명, 여기에 적어야 생략 가능하다. ( ; 로 여러 곳을 지정할 수도 있다)
  type-aliases-package: hello.itemservice.domain
  # mapper 클래스의 기본 위치. 이게 없으면 실제 클래스 패키지 위치와 동일하게 resource/../ 에 만들어 주어야한다.
  mapper-locations: classpath:sql/**/*.xml
  # db camel case -> java camelCase 자동 변환
  configuration:
    map-underscore-to-camel-case: true

logging:
  level:
    hello:
      itemservice:
        repository:
          mybatis: trace

 

Spring MyBatis를 사용하면 구현체를 따로 만들어주지 않아도된다. 그냥 @Mapper를 인터페이스 달아주면 구현체 빈이 생성된다

참고로 그냥 myBatis를 사용하면 SqlSessionFactory, SqlSession을 아래와 같이 사용하면 된다.

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

// Open a new SqlSession
try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
    // Retrieve data from the database using MyBatis
    List<MyObject> myObjects = sqlSession.selectList("com.example.MyObjectMapper.selectMyObjects");
} ...

 

우린 스프링없이 MyBatis 쓸일 없으므로 아래와 같이 @Mapper만 달아주면 끝. 빈으로 스캔된다.

@Mapper
public interface ItemMapper {

    void save(Item item);

    void update(@Param("id") Long id, @Param("updateParam") ItemUpdateDto updateParam);

    Optional<Item> findById(Long id);

    List<Item> findAll(ItemSearchCond itemSearch);
}

@Slf4j
@Repository
@RequiredArgsConstructor
public class MyBatisItemRepository implements ItemRepository {

    private final ItemMapper itemMapper;

    @Override
    public Item save(Item item) {
        log.info("itemMapper class={}", itemMapper.getClass());
        itemMapper.save(item);
        return item;
    }

    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        itemMapper.update(itemId, updateParam);
    }

    @Override
    public Optional<Item> findById(Long id) {
        return itemMapper.findById(id);
    }

    @Override
    public List<Item> findAll(ItemSearchCond cond) {
        return itemMapper.findAll(cond);
    }
}

 

xml path는 실제 클래스와 동일하게 맞춰주면 된다.

<?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="hello.itemservice.repository.mybatis.ItemMapper">

    <insert id="save" useGeneratedKeys="true" keyProperty="id">
        insert into item (item_name, price, quantity)
        values (#{itemName}, #{price}, #{quantity})
    </insert>

    <update id="update">
        update item
        set item_name=#{updateParam.itemName},
            price=#{updateParam.price},
            quantity=#{updateParam.quantity}
        where id = #{id}
    </update>

    <select id="findById" resultType="Item">
        select id, item_name, price, quantity
        from item
        where id = #{id}
    </select>

    <select id="findAll" resultType="Item">
        select id, item_name, price, quantity
        from item
        <where>
            <if test="itemName != null and itemName != ''">
                and item_name like concat('%', #{itemName}, '%')
            </if>
            <if test="maxPrice != null">
                and price &lt;= #{maxPrice}
            </if>
        </where>
    </select>

</mapper>

 

 

sqlSessionTemplate 직접 사용

이런식으로 추상화해서 사용하기 싫은 분들을 위해 sqlSessionTemplate 을 스프링에서 제공해준다. 조금 더 직관적으로 사용할 수 있다.대신 MyBatis의 구조에 대해 조금 이해하고 사용해야한다.

 

 

스프링이 제공하는 sqlSessionFactoryBean을 등록해서 쓰면 된다. sqlSessionTemplate을 추가해놓자

물론 추가하지 않더라도 MybatisAutoConfiguration 에 의해서 아래 빈들은 자동으로 다 등록된다. 수동으로 설정할 때만 사용

스프링 마이베티스 의존성을 불러오면, 스프링 부트가 MybatisAutoConfiguration 를 빈으로 등록한다. 해당 클래스에 다 있음

@Configuration
public class DatabaseConfiguration {

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        var sqlSessionFactory = new SqlSessionFactoryBean();

        // yml 설정을 코드로 직접 추가
        sqlSessionFactory.setDataSource(dataSource);

        var configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        sqlSessionFactory.setConfiguration(configuration);
        sqlSessionFactory.setTypeHandlersPackage("com.your.package");
        
        // mapper-locations: classpath:sql/**/*.xml 등록
        var resolver = new PathMatchingResourcePatternResolver();
        sqlSessionFactory.setMapperLocations(resolver.getResources("classpath:mapper/xml/*.xml"));

        return sqlSessionFactory.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

 

설정에보면 typeHandlers 스캔 패키지 경로를 지정해줄 수 있는데, 이는 Enum Converter처럼 특정 DB 타입을 매핑할 때 사용된다

// RoleType 컨버터
@MappedTypes(Role.class)
public final class RoleTypeHandler implements TypeHandler<Role> {

    @Override
    public void setParameter(PreparedStatement ps, int i,
        Role parameter, JdbcType jdbcType) throws SQLException {
        ps.setString(i, parameter.name());
    }

    @Override
    public Role getResult(ResultSet rs, String columnName) throws SQLException {
        return Role.findRole(rs.getString(columnName));
    }

    @Override
    public Role getResult(ResultSet rs, int columnIndex) throws SQLException {
        return Role.findRole(rs.getString(columnIndex));
    }

    @Override
    public Role getResult(CallableStatement cs, int columnIndex) throws SQLException {
        return Role.findRole(cs.getString(columnIndex));
    }
}

 

 

 

사용하는 코드

public final class MybatisAccountRepository implements AccountRepository, AccountReader {

    private static final String SAVE_FQCN = "com.yam.app.account.domain.AccountRepository.save";
    private static final String UPDATE_FQCN = "com.yam.app.account.domain.AccountRepository.update";

    private final SqlSessionTemplate template;

    public MybatisAccountRepository(SqlSessionTemplate template) {
        this.template = template;
    }

    @Override
    public boolean existsByEmail(String email) {
        return template.getMapper(AccountReader.class).existsByEmail(email);
    }

    @Override
    public void update(Account entity) {
        int result = template.update(UPDATE_FQCN, entity);
        if (result != 1) {
            throw new IllegalStateException(String.format(
                "Unintentionally, more records were updated than expected. : %s", entity));
        }
    }

    @Override
    public void save(Account entity) {
        int result = template.insert(SAVE_FQCN, entity);
        if (result != 1) {
            throw new IllegalStateException(String.format(
                "Unintentionally, more records were saved than expected. : %s", entity));
        }
    }

    @Override
    public Optional<Account> findByEmail(String email) {
        return template.getMapper(AccountReader.class).findByEmail(email);
    }

    @Override
    public MemberAccount findByEmailAndMemberId(String email,
        Long memberId) {
        return template.getMapper(AccountReader.class).findByEmailAndMemberId(email, memberId);
    }
}

 

 

 

 

🍀 JPA, Hibernate

https://jiwondev.tistory.com/category/%F0%9F%8C%B1Backend/JDBC%20%26%20JPA?page=1

https://jiwondev.tistory.com/252

JPA 성능 개선팁

 

 

 

🍀 스프링 데이터 JPA

https://jiwondev.tistory.com/253

Spring Data JPA

 

하나만 추가하자면, JPA의 의존성을 인터페이스로 완전히 감출 수 있다. 우선 아래와 같이 인터페이스를 정의한다. 이렇게 분리할 경우, 인터페이스 분리 원칙에 따라 Repository ->  { Reader , Writer } 로 인터페이스를 분리해서 쓰는 방법도 있다.

public interface SampleRepository {
    Optional<SampleEntity> findById(Long id);

    SampleEntity save(SampleEntity entity);
}

 

1️⃣ JPA 구현체만 사용한다면 아래와 같이 인터페이스를 추가하면 깔끔하게 사용할 수 있다. 참고로 QueryDsl등을 쓴다면 interface CustomJpaRepository 를 만들고, SampleJpaRepository가 상속하게 하면 동일하게 쓸 수 있다.

// 참고로 @Repository를 생략해도 @EnableJpaRepositories 에 의해 JpaRepository 타입이 스캔되어 빈 등록된다.
@Repository 
public interface SampleJpaRepository extends SampleRepository, JpaRepository<SampleEntity, Long> {

    @Override
    Optional<SampleEntity> findById(Long id);
}

 

 

2️⃣ 여러 DB 구현체를 사용한다면 컴포지션을 활용해서, 아예 별도의 RepositoryImpl 클래스를 만들어서 이용해도 좋다.

@Repository
public interface SampleJpaRepository extends JpaRepository<SampleEntity, Long> {

}

@RequiredArgsConstructor
public class SampleRepositoryImpl implements SampleRepository {

    private final SampleJpaRepository jpaRepository;
    private final SampleCustomRepository customRepository;

    @Override
    public Optional<SampleEntity> findById(Long id) {
        return customRepository.findById(id);
    }

    @Override
    public SampleEntity save(SampleEntity entity) {
        return jpaRepository.save(entity);
    }
}

 

하지만 결국 모든건 트레이드 오프라는 걸 명심하자. 우리는 왜 DIP 원칙을 지키고, 추상화시켜서 코드를 분리하는걸까? 결국 코드 수정의 영향도를 줄여 잠재적인 버그와 개발 비용을 줄이기 위함이다. 원칙을 지키기 위한 원칙은 아무런 의미가 없다.

 

현실적으로 DB 의존성이 바뀌는 경우가 얼마나 될까? 아니, 애초에 인터페이스로 분리한다고 해도 DB를 쉽게 바꿀 수 있을까?

모든 것은 트레이드 오프이다. 서비스에 따라 Repository 자체가 너무나 복잡하다면 위 예제처럼 분리하는게 훨씬 나을 수 있다. 반대로 그 정도로 큰 서비스가 아니거나 당장 만드는게 급하다면 JpaRepository를 바로 사용하는 것이 정답일 수도 있다.

 

 

🍀 Querydsl

https://jiwondev.tistory.com/255

스프링JPA의 영속성컨텍스트 (EntityManager)

 

 

스프링에서 QuerydslRepositorySupport라고 따로 지원해주는게 있긴한데 사용해보면 알겠지만 살짝 불편하다.

// 스프링 데이터 리포지토리에 사용자 정의 인터페이스 상속 (MemberRepositoryCustom)
public interface MemberRepository extends JpaRepository<Member, Long>, MemberRepositoryCustom {
    List<Member> findByUsername(String username);
}

public class MemberRepositoryImpl extends QuerydslRepositorySupport implements MemberRepositoryCustom {
    public MemberRepositoryImpl() {
        super(Member.class);
    }

    //  QuerydslRepositorySupport 사용
    //  from절이 먼저 시작합니다.
    private Page<MemberTeamDto> getMemberTeamDtoQueryResults(MemberSearchCondition condition, Pageable pageable) {
        JPQLQuery<MemberTeamDto> jpaQuery = from(member)
                .leftJoin(member.team, team)
                .where(usernameEq(condition.getUsername()),
                        teamNameEq(condition.getTeamName()),
                        ageGoe(condition.getAgeGoe()),
                        ageLoe(condition.getAgeLoe()))
                .select(new QMemberTeamDto(
                        member.id.as("memberId"),
                        member.username,
                        member.age,
                        team.id.as("teamId"),
                        team.name.as("teamName")));

        JPQLQuery<MemberTeamDto> query = getQuerydsl().applyPagination(pageable, jpaQuery);// offset, limit 지원

        query.fetch();
    }

}

 

 

차라리 QueryDsl에서 제공하는 JpaQueryFactory (* EntityManager와 1:1 관계)를 직접 사용하는게 훨씬 깔끔하고 편하다. 참고로 Spring Jpa에서는 `Impl` 이라는 prefix를 붙이면 자동으로 빈 스캔이 된다.

public interface MemberRepository extends JpaRepository<Member, Long>, MemberRepositoryCustom {
}

// 1. Jpa가 아닌 다른걸로 확장하고 싶은 메서드는 여기에다가 따로 정의해둔다.
public interface MemberRepositoryCustom {
    List<Member> findMemberCustom();
}

//2. 참고로 'Custom' 은 꼭 안붙여도 된다. 뒤에 'Impl' 이름을 기준으로 같은 패키지안의 클래스를 스캔한다.
public class MemberRepositoryCustomImpl implements MemberRepositoryCustom {
 
    private final EntityManager em;
    public MemberRepositoryImpl(EntityManager em) { this.em = em; }
 
    @Override
    public List<Member> findMemberCustom() {
        return em.createQuery("select m from Member m")
            .getResultList();
    }
}

 

 

참고로 `Impl` 접두사 설정 또한 @EnableJpaRepository에서 커스텀할 수 있다. 이는 스프링 부트가 Jpa 의존성이있으면 설정해줌.

@EnableJpaRepositories(basePackages = "study.datajpa.repository", // 물론 스캔 패키지도 변경가능
                            repositoryImplementationPostfix = "Impl") // 여기

 

 

물론 이름 규칙을 사용하지 않고 그냥 JpaRepository, QueryDslRepostiory로 따로 만들어서 사용해도 된다. 만드는건 더 귀찮아지지만 service 에서 하나만 쓰고싶다면 ItemRepository 자바 인터페이스를 만들고, ItemRepositoryImpl 에서 실제 구현체를 빈으로 받아와서 아래 코드처럼 쓰면 된다.

@Repository
public class ItemQueryRepository{
       private final JPAQueryFactory query;
}

@Service
public class ItemService {
    private final ItemRepositoryV2 itemRepositoryV2;
    private final ItemQueryRepositoryV2 itemQueryRepositoryV2;
}

 

 

https://jiwondev.tistory.com/254

QueryDSL + JPA

 

 

 

 

🍀 트랜잭션 전파옵션

스프링은 @Transactional로 손쉽게 트랜잭션을 걸 수 있게 만들어놨지만, 사실 실제 트랜잭션 동작과 100% 일치하는건 아닙니다.

• 개발자가 @Transactional 로 건 것을 논리 트랜잭션이라고 표현합니다.
• JDBC를 통해 실제로 걸리는 부분을 물리 트랜잭션이라고 표현합니다.

 

 

이렇게 개념을 나눠서 JDBC에는 없는 트랜잭션 전파라는 재밌는 기능을 스프링이 구현해놓았습니다.

// 기본값은 REQUIRED, 없으면 걸고 있으면 기존 트랜잭션을 같이 쓴다.
 @Transactional(propagation = Propagation.REQUIRES_NEW)

사실 전파 옵션을 변경할 일은 잘 없긴하다. 구조 자체를 변경하는게 더 나으니까

 

🔥 기본값 REQUIRED에서 고려해야하는 문제들

MemberService, MemberRepository, LogRepository에 각각 트랜잭션이 걸려있다고 가정해봅시다.

개발자는 논리적으로 @Transaction을 전체로 걸었지만, 실제로는 아래와 같이 하나의 JDBC 물리 트랜잭션으로 실행됩니다.

 

 

1️⃣ (외부 롤백) 당연히 최상위 클래스에서 에러가 발생하면, 전체 트랜잭션이 롤백됩니다.

 

 

2️⃣ (내부 롤백) 일부만 성공하고 내부에서 Runtime 에러가 발생하더라도 전체가 롤백됩니다.

이 경우 try-catch로 에러를 처리하더라도 UnexpectedRollbackException 가 발생하며 전체 트랜잭션이 롤백됩니다. 물론 @Transactional(rollbackOnly=false) 설정이나 (rollbackFor=MyClass.class) 로 바꿀 순 있지만 권장하지 않습니다.

트랜잭션동기화 매니저가 rollback을 기록합니다. 만약 트랜잭션을 추상화해서 엄청 크게 잡았다면 바로 찾기 어렵습니다.

 

정확히는 아래와 같은 과정을 거쳐 롤백됩니다.

 

 

 

3️⃣ AOP 특성상 this를 통한 내부 호출은 트랜잭션이 걸리지 않습니다.

• JVM은 class, method 등의 정보는 딱 한번만 static 영역에 저장합니다.
• 이후 각 클래스의 인스턴스가 만들어질 때 힙메모리를 할당합니다. 
• 즉 인스턴스는 class, method를 가지고 있지 않고 각각의 힙 메모리를 가지고 있습니다. 이 메모리는 this 로 참조할 수 있습니다.

Spring AOP는 상속을 활용한 프록시 객체를 통해 걸립니다. this 로 참조해버리면 프록시 객체를 사용하지 않기 때문에 트랜잭션이 걸리지 않습니다.

 

 

3️⃣ 스프링 @Transactional 은 public 메서드만 지원합니다.

클래스에 붙이는건 그 클래스가 가진 모든 public 메서드에만 적용됩니다. 물론 protected와 default 접근제어자는 상속이 가능한데 스프링이 정책적으로 막아뒀습니다. 애초에 거기에 트랜잭션이 걸어야하는 상황 자체도 없고, 그런식의 동작도 이상하니까요.

 

다행히 메서드에 직접 걸면 IntelliJ가 바로 경고를 띄워주기에 실수할 일이 없습니다.

 

 

그런데 Class에 @Transactional을 붙이는 경우 따로 알려주지 않으니 주의하도록 합시다. 트랜잭션은 public Method 에만 걸립니다.

에러가 안뜬다.

 

 

4️⃣ 전파옵션으로 해결할 수 있지만.. 그러지말고 계층을 분리합시다.

Required_New 등으로 트랜잭션을 분리할 수 있습니다만.. 동작을 예측하기도 어렵고 오히려 더 큰 버그를 만들어 낼 수 있습니다. 원래는 에러터지고 말았다면, 트랜잭션 전파옵션을 통해 똑같은 회원이 3번씩 저장되는 이상한 버그를 만들 수 도 있죠

 

그냥 애초부터 트랜잭션을 분리하면 됩니다. 최상단에 @Transacational을 시작하지 마세요.

 

 

비동기로 동작해서 위 그림처럼 컨트롤 할 수 없다면 @TransactionEventListener 등을 활용하는 방법도 있습니다.

class Service(
    private val eventPublisher: ApplicationEventPublisher
) {
    @Transactional
    fun signUp(dto: MemberSignUpRequest) {
        val member = createMember(dto.toEntity())
        eventPublisher.publishEvent(MemberSignedUpEvent(member)) // 이벤트 발송
    }
}

class EventHandler{
    // 아래의 메서드는 eventPublisher 코드에 있는 트랜잭션이 성공해야 동작합니다. 
    @TransactionalEventListener
    fun memberSignedUpEventListener(event: MemberSignedUpEvent) {
        emailSenderService.sendSignUpEmail(event.member)
    }
}

 

 

트랜잭션 범위가 엄청 복잡해서 상세하게 걸고싶다면, Spring @Transactional을 사용하지말고 TransactionTemplate을 직접 쓰면 됩니다. 사용법만 다를 뿐 똑같이 동작합니다. 

@Service
@RequiredArgsConstructor
public class MyService {
    private final TransactionTemplate transactionTemplate;
    
    /** ⭐️ Java8 람다로 정의된 메서드를 쓰면 매우 깔끔합니다. */
    void myTransactionalLambda() {
        transactionTemplate.executeWithoutResult(status -> { /*..트랜잭션 로직..*/ });
        
        var result = transactionTemplate.execute(status -> { /*..트랜잭션 로직..*/ return null; });
    }
    
    /** 익명클래스로 사용할 땐 아래와 같습니다 */
    MyResultDto myTransactionalMethod() {
        return transactionTemplate.execute(new TransactionCallback<MyResultDto>() {
            @Override
            public MyResultDto doInTransaction(TransactionStatus status) {
                // 여기에 트랜잭션을 적용할 비즈니스 로직을 작성합니다.
                // 필요한 경우 status.setRollbackOnly(); 호출로 롤백을 지시할 수 있습니다.
                MyResultDto result = new MyResultDto();
                return result;
            }
        });
    }
 
    void myTransactionalMethod() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                // 여기에 트랜잭션을 적용할 비즈니스 로직을 작성합니다.
                // 필요한 경우 status.setRollbackOnly(); 호출로 롤백을 지시할 수 있습니다.
            }
        });
    }
}