728x90

객체 지향 쿼리 심화

한번에 여러 데이터를 수정할 수 있는 벌크 연산이 있다.

벌크 연산

엔티티를 수정하려면 영속성 컨텍스트 변경 감지 기능이나 병합을 사용하고, 삭제하려면 em.remove() 를 사용한다. 데이터를 하나씩 처리하기엔 너무 오래걸려서 여러개를 동시에 처리할 수 있는 벌크연산이 있다.

벌크 연산은 executeUpdate() 를 사용한다. 이 메소드는 벌크 연산으로 영향을 받은 엔티티 건수를 반환한다.

주의사항

벌크 연산은 영속성 컨텍스트를 통하지 않고 바로 DB에 직접 쿼리를 날린다. 그래서 영속성 컨텍스트에 있는 엔티티와 DB에 있는 테이블의 칼럼 값이 다를 수 있는데, 그래서 이 부분을 주의하여야 한다.

  • em.refresh 사용
    • 엔티티를 사용해야 할 경우엔 DB에서 다시 조회한다.
  • 벌크 연산 먼저 실행
    • 벌크연산을 가장 먼저 실행하여 실행한 후에 조회쿼리를 하면 변경된 것으로 조회가 된다.
  • 벌크연산 수행 후 영속성 컨텍스트 초기화
    • 수행 직후 컨텍스트를 초기화하여 엔티티를 제거했다가 벌크연산이 적용된 DB에서 조회하는 방법

영속성 컨텍스트와 JPQL

쿼리 후 영속 상태인것과 아닌 것

select m from Member m //엔티티 조회 (영속성 O)
select o.address from Order o //임베디드 타입 조회 (영속성 X)
select m.id, m.name from Member m // 필드 조회 (영속성 X)

엔티티 전체를 조회해야만이 영속성 컨텍스트가 관리한다❗️

JPQL로 조회한 엔티티와 영속성 컨텍스트

앞선 포스팅에서 JPQL로 DB에서 조회한 엔티티가 영속성 컨텍스트에 있다면 JPQL로 DB에서 조회한 값은 버리고 영속성 컨텍스트에 있던것을 꺼내온다고 했다.

덮어쓰거나 하게 된다면 컨텍스트안에서 수정 중이었던 데이터가 사라질 수 있어 위험하다.
그래서 영속성 컨텍스트는 엔티티의 동일성을 보장하기 때문에 em.find로 조회를 하던, JPQL을 사용하던 영속성 컨텍스트가 같으면 동일한 엔티티를 반환해준다.

JPQL의 특징

  • JPQL은 항상 DB를 조회한다.
  • JPQL로 조회한 엔티티는 영속 상태이다.
  • 영속성 컨텍스트에 이미 존재하는 엔티티가 있으면 기존 엔티티를 반환한다.

그래서 영속성 컨텍스트의 1차 캐시를 되도록이면 관리하여 많이 이용하는 것이 DB에 부하를 적게 주는 것이고 그게 바람직한 사용방법인것 같다는 나의 견해? 🤔

JPQL과 플러시 모드

flush는 영속성 컨텍스트의 변경 내역을 DB에 동기화 해주는 것이다.
그래서 JPA는 flush가 발생했을 때 쓰기지연 SQL 저장소 라고 했던 저장소에 있던 쿼리들을 쭉 만들어 DB에 반영해준다. flush를 호출하려면 em.flush()를 하거나 flush 모드에 따라 커밋 직전이나 쿼리 실행 직전에 자동 호출된다.

쿼리와 플러시 모드

JPQL은 영속성 컨텍스트 데이터를 고려하지 않고 DB에서 조회하기 때문에 사용할때는 반드시 영속성 컨텍스트의 변경사항을 flush해주어야 한다. 그렇지 않으면 데이터가 섞일 수 있다.

@Test
@DisplayName("쿼리와 플러시 모드")
void queryAndFlushTest() {
    em.setFlushMode(FlushModeType.COMMIT);
    Item item = em.find(Item.class, 1L);
    item.setPrice(2000);

    Object item2 = em.createQuery("select i from Item i where i.price = 2000").getSingleResult();
    System.out.println(item2.toString());
}

flush모드를 commit시에만 플러시로 설정해놓으면

이러한 select쿼리문 후에 에러를 발생한다.


맞는 엔티티를 찾을 수 없다고 나오게 된다.

정리

  • JPQL은 SQL을 추상화하여 특정 DB에 의존하지 않는다.
  • QueryDSL은 JPQL을 만드는 빌더 역할만 하므로 JPQL을 잘 알아야 함!
  • QueryDSL을 사용하면 동적 쿼리를 생성하기가 편리하다.
  • QueryDSL은 JPA가 공식 지원하는 것은 아니지만 직관적이고 편리하다.
  • JPA도 네이티브 쿼리를 지원하지만, 종속적인 SQL을 사용하게 되면 특정 DB에만 한정적인게 된다.
    • JPQL을 최대한 활용 해보고 안되면 그 때 네이티브 SQL을 사용하자😊
  • JPQL은 대용량 수정, 삭제를 할 수 있는 벌크 연산을 지원한다.
728x90

'Java' 카테고리의 다른 글

TDD Clean Code with Java 12기 2주차 피드백  (0) 2022.08.06
TDD Clean Code with Java 12기 2주차  (0) 2022.08.05
Effective Java 1장  (0) 2022.08.05
MockMvc  (0) 2022.08.04
728x90

내 팀 프로젝트를 예전에 Spring으로 구현을 했었는데 이것을 스프링부트로 마이그레이션 해보았다. 더불어 Maven 의존성을 Gradle로 바꾸면서 마이그레이션을 한 것이다.

오류들이 상당히 많았지만 남들과 같은 오류인지는 잘 모르겠다.🤣

어떤 오류들이 있었는지 알아보자

Lombok

일단 Jar로 빌드하게되면 SpringBoot는 WEB-INF안의 jsp파일을 읽을수가 없다. 그래서 war로 빌드를 해주어야한다.

추후에 Mybatis로 db연결을 하는 방식을 JPA로 변경할 예정이다.

우선 제일 먼저 gradle 을 의존성 관리 툴로 추가하기 위해서

pom.xml 이 있는 경로로 가서 gradle init을 시켜주었다.

gradle init --type pom

이것으로 pom.xml의 내용이 Gradle로 변환이된다.

그다음 war파일이 있어야 실행할 수 있는 환경이 되기 때문에

apply plugin: 'war'

를 해준다.
이왕이면 최신버전으로 마이그레이션 하자 생각해서 다 최신버전으로 엮어주었다.

여기서 에러가 발생했던건 lombok이었는데
implementaion만으로 lombok을 추가하는 것이 아니라
annotationProcessor로도 lombok을 추가해줘야 했었다.

간략하게 gradle 지시어를 정리하자면

  • compileOnly: 해당 의존성을 컴파일시에만 포함한다.

  • runtimeOnly: 해당 의존성을 런타임시에만 포함한다.

  • compile: 해당 의존성을 직/간접적으로 의존하고 있는 모든 의존성을 재빌드한다.

  • implementation: 해당 의존성을 직접 의존하고 있는 의존성만 재빌드 한다.

기본적으로 포함이 되어있지 않은 어노테이션이 바로 lombok이기 때문에
annotationProcessor로 명시적 추가를 해줘야한다.

Mybatis

탈 xml을 하기 위해서 이것도 다 Java의 @Bean으로 설정을 해주었다.
여기서도 에러가 조금 많이 발생했다.

@Configuration
@MapperScan(
        sqlSessionFactoryRef="dataSource",
        sqlSessionTemplateRef="sqlSessionFactoryBean")
public class MapperConfig {
    @Value("${spring.datasource.driver-class-name}")
    String driverClassName;

    @Value("${spring.datasource.url}")
    String url;

    @Value("${spring.datasource.username}")
    String userName;

    @Value("${spring.datasource.password}")
    String password;

    @Bean(name="dataSource")
    public DataSource dataSource() {
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }

    @Bean(name="sqlSessionFactory")
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setVfs(SpringBootVFS.class);

        sessionFactoryBean.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis/Configuration.xml"));
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
        return sessionFactoryBean;
    }
    @Bean(name="sqlSessionTemplate")
    public SqlSessionTemplate sqlSession(SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

application.properties

여기에는 web.xml을 제거하고 application.properties에

server.port=8080
server.servlet.context-path=/

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
spring.mvc.static-path-pattern=/resources/static/**

spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/테이블명
spring.datasource.username=계정명
spring.datasource.password=비밀번호

이렇게 진행했다. 그래서 파일 구조도 resources의 static 안으로 js, css 등 여러 정적 파일들을 넣어주고 불러오는 것으로 경로를 잡았다.

그러면서 동시에 WEB-INF폴더는 src/main/webapp 하위에 넣어주고 밖으로 빠져있던 jsp파일도 안으로 넣어주었다.

Tomcat

org.apache.catalina.webresources.Cache.getResource []에 위치한 리소스를 웹 애플리케이션 []을(를) 위한 캐시에 추가할 수 없습니다.
이런 에러도 Tomcat 구동시에 에러를 뱉었는데
이것은
tomcat경로중 apache-tomcat/conf/context.xml
아래와 같은 문구를 넣어준다.

<Resources cachingAllowed="true" cacheMaxSize="100000" />

이렇게 보면 단순한 에러들이었는데 Mybatis가 얽히고 조금만 건드리면 바로 에러가 나고 마이그레이션 경험이 생겨서 좋은것 같다. 앞으로도 레거시를 업데이트 해야할 경우에 오류들을 상기시키면서 잘 진행해보면 한번 더 성장할 수 있을것 같다.

728x90

'Spring' 카테고리의 다른 글

Spring -> Spring Boot 마이그레이션 2  (0) 2022.08.06
Spring Data JPA  (0) 2022.08.06
[Spring] MockMvc Bean 주입 에러  (0) 2022.08.04
[Spring] Spring Security  (0) 2022.08.03
728x90

깃허브 바로가기
책의 내용이 너무많아 계속 분리해서 작성하게 된다.
이번 포스팅에서는 서브 쿼리부터 내용을 다뤄보도록 하겠다.

서브 쿼리

JPQL도 SQL처럼 서브 쿼리를 지원하는데, 여기서는 몇 가지 제약사항이 있다.
서브 쿼리를 WHERE, Having 절에서만 사용할 수 있고 select, from 절에서는 사용할 수 없다.

서브쿼리 함수

  • [NOT] EXISTS 서브쿼리
    • 서브쿼리에 결과가 존재하면 참. NOT은 반대
  • {ALL | ANY | SOME} 서브쿼리
    • 비교 연산자와 같이 사용한다.
      • ALL: 조건을 모두 만족하면 참
      • ANY or SOME : 둘은 같은 의미이다. 조건을 하나라도 만족하면 참
  • [NOT] IN 서브쿼리
    • 서브쿼리의 결과 중 하나라도 같은 것이 있으면 참. 참고로 IN은 서브쿼리가 아닌 곳에서도 사용한다.

조건식

종류 설명 예제
문자 작은 따옴표 사이에 표현, 작은 따옴표를 표현하고 싶다면 작은따옴표 2개('') 사용 'Hello', 'He''s'
숫자 L(Long), D(Double), F(Float) 10L, 10D, 10F
날짜 Date {d 'yyyy-mm-dd'}
Time {t 'hh-mm-ss'}
DateTime {ts 'yyyy-mm-dd hh:mm:ss.f'}
{d '2021-07-25'}
{t '15:00:12'}
{ts '2021-07-25 15:48:22.123}
m.createDate = {d '2021-07-25'}
Boolean TRUE, FALSE -
Enum 패키지명을 포함한 전체 이름을 사용해야 한다. pack.MemberType.Customer
엔티티 타입 엔티티의 타입을 표현한다. 주로 상속과 관련해서 사용한다. TYPE(m) = Member

연산자 우선 순위

  1. 경로 탐색 연산(.)
  2. 수학 연산 : 단항 연산자: +, -, 사칙연산 : *, /, +, -
  3. 비교 연산 : =, >=, >, 등, <>(다름), Between, Like, In, Is Null, Is Empty, Exists
  4. 논리 연산 : NOT, AND, OR

Between

where m.age between 10 and 20
where 뒤에 식으로 작성할 수 있다. Member의 나이가 10~20인 사람 찾기

In

In에는 서브쿼리를 사용할 수 있다. in절의 조건이 하나라도 있으면 참이다.

Like

문자표현식과 패턴을 비교한다.

  • % : 아무 값들이 입력되어도 된다. (값이 없어도 됨)
  • _ : 한 글자는 아무 값이 입력되어도 되지만 값이 있어야 한다.

NULL

Null 인지 비교한다. Null은 =으로 비교하면 안되고 is null을 사용해야 한다.

컬렉션 식

컬렉션에만 사용하는 특별한 기능이다. 컬렉션은 컬렉션 식 이외에 다른 식은 사용할 수가 없다.

Is Empty

컬렉션에 값이 비었으면 참이다.

스칼라 식

위의 수학 연산에 더해 아래와 같은 문자함수도 있다.

함수 설명 예제
CONCAT(1, 2) 문자를 합한다. CONCAT('A','B') = AB
SubString(문자, 위치, [길이]) 길이 값이 없으면 나머지 전체 길이를 뜻한다. SUBSTRING('ABCDEF', 2, 3) = BCD
TRIM([[LEADING] , TRAILING , BOTH] [트림문자] FROM] 문자) LEADING: 왼쪽만, TRAILING: 오른쪽만, BOTH: 양쪽 다 트림 문자를 제거한다. 기본값은 Both, 트림문자 기본값은 공백이다. TRIM(' ABC ') = 'ABC'
LOWER(문자) 소문자로 변경
UPPER(문자) 대문자로 변경
LENGTH(문자) 문자 길이
LOCATE(찾을 문자, 원본 문자, [검색시작위치]) 검색 위치부터 문자를 검색한다. 1부터 시작, 못 찾으면 0을 반환 LOCATE('AB', 'ABCDE') = 1
함수 설명
ABS() 절대값
SQRT() 제곱근
MOD(수학식, 나눌수) 나머지
SIZE(컬렉션 값 연관 경로식) 컬렉션 크기 구함
INDEX(별칭) LIST 타입 컬렉션의 위치값 구함, 컬렉션이 @OrderColumn을 사용해야 할 수 있다.

날짜 함수는 아래와 같다.

  • Current_Date: 현재 날짜
  • Current_Time: 현재 시간
  • Current_TimeStamp: 현재 날짜 시간

이렇게 보면 DB에서 사용하는 함수가 거의 다 문법이 비슷하게 사용되는 것을 볼 수 있다.

CASE식은 생략하고 추후에 내가 사용할 때 다시 정리해야 겠다.

다형성 쿼리

JPQL로 부모 엔티티를 조회하면 자식 엔티티도 조회된다. Item의 자식으로 Book, Album, Movie 가 있다고 한다면 조회를 했을때 Item을 상속받는 Book, Album, Movie도 조회한다.

이걸 단일 테이블 전략을 사용하면 SQL이 select * from Item 이 되는데
조인 전략을 가져가면 left outer join이 세번 걸리게 된다.

TYPE

TYPE은 엔티티의 상속 구조에서 조회 대상을 특정 자식 타입으로 한정할 때 주로 사용한다.

TREAT

자바의 타입 캐스팅과 빗슷함. 상속 구조에서 부모 타입을 특정 자식 타입으로 다룰 때 사용.
JPA 표준은 FROM, Where 절에서 사용할 수 있지만, Hibernate는 Select 절에서도 Treat를 사용할 수 있다.

사용자 정의 함수 호출

JPA2.1 버전부터 사용자 정의 함수를 지원한다.
문법은 다음과 같다.
function_invocation::= FUNCTION(function_name {, function_arg}*)
예) select function('group_concat', i.name) from Item i

Hibernate 구현체를 사용하면 방언클래스를 상속해서 구현하고 사용할 DB함수를 미리 등록해야 한다.

spring.jpa.hibernate.dialect: org.hibernate.dialect.H2Dialect

방언에따라 dialect 뒤를 해당 SQL로 바꿔서 등록한다.
그렇게 이 구현체를 사용하면 해당하는 함수를 바로 사용할 수 있다.

기타 정리

  • enum은 =비교 연산만 지원한다.
  • 임베디드 타입은 비교를 지원하지 않는다.

Empty String

JPA표준은 ''을 길이가 0인 Empty String으로 정했지만 DB에 따라 ''를 Null로 사용하는 DB가 있으므로 확인하고 사용해야 한다.

Null 정의

  • 조건을 만족하는 데이터가 하나도 없으면 Null
  • Null은 알수 없는 값이다. Null과의 모든 수학적 계산 결과도 Null이 된다.
  • Null == Null 은 알수 없는 값이다.
  • Null is Null은 참이다.

엔티티 직접 사용

기본 키 값

객체 인스턴스는 참조 값으로 식별하고 테이블 로우는 기본 키 값으로 식별한다.
JPQL에서 엔티티 객체를 직접 사용하면 SQL에서는 해당 엔티티의 기본 키값을 사용한다.

Named 쿼리 : 정적 쿼리

  • 동적 쿼리: em.createQuery("") 처럼 JPQL을 문자로 완성해서 직접 넘기는 것을 동적 쿼리라고 한다. 런타임에 특정 조건에 따라 JPQL을 동적으로 구성할 수 있다.
  • 정적 쿼리: 미리 정의한 쿼리에 이름을 부여해서 필요할 때 사용할 수 있는데 Named 쿼리라고 한다. Named쿼리는 한번 정의하면 변경할 수 없는 정적인 쿼리다.

Named쿼리는 애플리케이션 로딩 시점에 JPQL 문법을 체크하고 미리 파싱해둔다. 그래서 오류를 빨리 확인할 수 있고, 사용하는 시점에 결과를 재사용하므로 성능상의 이점도 있다.
Named 쿼리는 정적 SQL이 생성되기 때문에 DB의 성능 최적화에 도움이 된다.
Named 쿼리는 @NamedQuery 를 사용하여 자바 코드에 작성하거나 XML문서에 작성할 수 있다.

  • lockMode: 쿼리 실행 시 락을 건다.
  • hints: 여기서의 힌트는 SQL 힌트가 아니라 JPA 구현체에게 제공하는 힌트이다. 2차 캐시를 다룰때 사용한다.

하나 이상의 NamedQuery를 사용하려면 @NamedQueries 어노테이션 사용할 것.

Named 쿼리를 XML에 정의하는 부분은 XML 대신에 Java에서 많이 하려고 노력하자.

728x90
728x90

JPQL

다시한번 JPQL의 특징을 정리해보자

  • JPQL은 객체지향 쿼리 언어이다. 따라서 테이블을 대상으로 쿼리하는 것이 아니라 엔티티 객체를 대상으로 쿼리한다.
  • JPQL은 SQL을 추상화해서 특정 DB SQL에 의존하지 않는다.
  • JPQL은 결국 SQL로 변환된다.

기본 문법과 쿼리 API

JPQL도 SQL과 비슷하게 SELECT, UPDATE, DELETE 문을 사용할 수 있다. em.persist()로 엔티티를 저장하므로 INSERT 쿼리는 없다.

JPQL 문법

select_문 :: =
    select_절
    from_절
    [where_절]
    [groupby_절]
    [having_절]
    [orderby_절]

update_문 :: = update_절 [where_절]
delete_문 :: = delete_절 [where_절]

SELECT문

SELECT m FROM Member AS m where m.name = 'hello'
  • 대소문자 구분
    • 엔티티와 속성은 대소문자를 구분한다.
    • Member, name 은 대소문자를 구분함.
    • SELECT, FROM, AS 등.. JPQL 키워드는 대소문자를 구분하지 않음.
  • 엔티티 이름
    • JPQL에서 사용한 Member는 클래스 명이 아니라 엔티티 명이다.
    • @Entity(name="") 로 지정할 수 있지만, 기본값은 클래스명을 기본값으로 한다.
  • 별칭 필수
    • 여기서는 m 이라는 별칭을 주었는데 JPQL은 별칭을 필수로 줘야한다. 아니면 에러 발생.

TypeQuery, Query

작성한 JPQL을 실행하려면 쿼리 객체를 만들어야 한다. 쿼리 객체는 TypeQuery, Query가 있는데 반환할 타입을 명확하게 지정할 수 있다면 TypeQuery를, 그렇지 않으면 Query 객체를 사용하면 된다.

@Test
@DisplayName("TypeQuery 테스트")
void typeQueryTest() {
    TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m", Member.class);

    List<Member> resultList = query.getResultList();

    assertThat(resultList.get(0).getName()).isEqualTo(member.getName());
}

em.createQuery()부분의 두번째 매개변수에 반환 타입을 위와같이 지정하면 TypeQuery를 반환, 아니면 Query를 반환한다.

결과조회

  • query.getResultList() : 결과를 리스트로 반환, 결과가 없으면 빈 컬렉션을 반환한다.
  • query.getSingleResult() : 결과가 하나일때 사용
    • 결과가 없으면 NoResultException 예외 발생
    • 결과가 1개보다 많으면 NonUniqueResultException 발생

파라미터 바인딩

JDBC와의 차이점

JDBC는 위치 기준 파라미터 바인딩만 지원하지만 JPQL은 이름 기준 파라미터 바인딩 지원

  • 이름 기준 파라미터
    • 이름 기준 파라미터는 파라미터를 이름으로 구분하는 방법이다.
    • 앞에 : 를 사용한다.

예제

@Test
@DisplayName("이름기준 파라미터")
void nameOfParameterTest() {
    String name = "kim";

    TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m where m.name = :name", Member.class);

    query.setParameter("name", name);
    List<Member> resultList = query.getResultList();
    assertThat(resultList.get(0).getName()).isEqualTo(member.getName());
}

이렇게도 할 수 있고
메소드 체이닝 방식으로도 할 수 있다.

List<Member> resultList = em.createQuery("SELECT m FROM Member m where m.name = :name", Member.class)
                            .setParameter("name", name);
                            .getResultList();
  • 위치 기준 파라미터
    • 위치 기준은 사용하려면 ? 다음에 위치 값을 주면 된다.
    • 위치 값은 1부터 시작이다.
em.createQuery("SELECT m FROM Member m where m.name= ?1", Member.class);

이런식으로 사용하면 되겠다. 나머지는 이름 기준과 같다.

위치 기준 보다는 이름 기준 파라미터 바인딩 방식이 더 명확하다.

프로젝션

SELECT절에 조회할 대상을 지정하는 것을 프로젝션이라고 하고 프로젝션 대상은 엔티티, 임베디드 타입, 스칼라 타입이 있다.

엔티티 프로젝션

SELECT m FROM Member m      //회원
SELECT m.team From Member m //팀

처음은 회원을 조회했고 두번째는 회원과 연관된 팀을 조회했는데 엔티티를 프로젝션 대상으로 한 예시이다.
이렇게 조회한 엔티티는 영속성 컨텍스트에서 관리된다❗❗

임베디드 타입 프로젝션

JPQL에서 임베디드 타입은 엔티티와 비슷하게 사용 되는데 임베디드 타입은 조회의 시작점이 될 수 없다는 제약이 있다.

주가 되는 엔티티에서부터 시작해서 나가야 쿼리가 수행된다.
임베디드 타입은 엔티티 타입이 아니라 값 타입이다.
따라서 이렇게 직접 조회한 임베디드 타입은 영속성 컨텍스트에서 관리되지 않는다.

스칼라 타입 프로젝션

숫자, 문자, 날짜와 같은 기본 데이터 타입이 스칼라 타입.
반환되는 값의 Wrapper클래스 매칭하여 추출

중복 데이터를 제거하려면 DISTINCT를 사용한다.
통계형 쿼리는 지금 다루지 않지만, 통계용 쿼리도 스칼라 타입이다.

여러 값 조회

엔티티 대상이 조회하기 편리하지만, 특정 데이터만 선택해서 추출해야 하는 경우에는 Query클래스 객체를 사용해야한다.

페이징 API

페이징 처리용 SQL을 작성하는 일은 지루하고 반복적이다. 더 큰 문제는 DB마다 페이징을 처리하는 SQL 문법이 다르다.
JPA는 페이징을 두개의 API로 추상화했다.

  • setFirstResult(int startPosition) : 조회 시작 위치(0부터 시작)
  • setMaxResults(int maxResult) : 조회할 데이터의 수

DB마다 다른 페이징 처리를 같은 API로 처리할 수 있는 이유는 DB 방언 덕분이다. JPQL이 방언에 따라 설정에 맞는 DB SQL로 변환된다.

나는 PostgreSQL을 사용해서 결과는 아래와 같이 나왔다.

@Test
@DisplayName("페이징 API")
void pagingApiTest() {
    TypedQuery<Member> query = em.createQuery("SELECT m FROM Member m order by m.name desc", Member.class);

    query.setFirstResult(10);
    query.setMaxResults(20);
    query.getResultList();
}

집합과 정렬

집합은 집합 함수와 함께 통계 정보를 구할때 사용함.

집합 함수

함수 설명
COUNT 결과 수를 구한다. 반환 타입: Long
MAX, MIN 최대, 최소 값을 구한다. 문자, 숫자, 날짜 등에 사용한다.
AVG 평균 값을 구한다. 숫자타입만 사용이 가능하다. 반환 타입: Double
SUM 합을 구한다. 숫자타입만 사용할 수 있다. 반환 타입: 정수합: Long, 소수합: Double, BigInteger합: BigInteger, BigDecimal합: BigDecimal

고려사항

  • Null 값은 무시하므로 통계에 잡히지 않는다.
  • 값이 없는데 AVG, MIN, MAX, SUM 을 사용하면 Null 값이 된다. COUNT는 0
  • DISTINCT를 집합함수 안에 사용하여 중복된 값 제거 후 집합을 구할 수 있다.
  • DISTINCT를 COUNT에서 사용할 때 임베디드 타입 지원 ❌

Group By, Having

Group By는 통계 데이터를 구할 때 특정 그룹을 묶어준다.
Having은 Group By와 같이 사용하는데 Group By가 끝나고 난 뒤에 필터링해준다.

Order By

order by는 정렬할 때 사용한다.

  • ASC : 기본값, 오름차순
  • DESC : 내림차순

JPQL 조인

JPQL도 조인을 지원한다. SQL 조인과 기능은 같은데 문법이 조금 다르다.

JPQL조인을 SQL 조인처럼 사용하면 문법 오류가 발생한다.
반드시 JOIN 명령어 다음에 조인할 객체의 연관 필드를 사용해야 한다.

SELECT m.username, t.name
FROM Member m JOIN m.team t
WHERE t.name = 'team1'

이렇게가 아니라 WHERE m.팀과관련된 것 이 나와야 한다.

내부조인

Inner Join을 사용한다. Inner는 생략이 가능하다.

외부조인

외부 조인은 기능상 SQL의 외부 조인과 같다. OUTER는 생략이 가능하기 때문에 LEFT JOIN 으로 사용한다.

컬렉션 조인

1:N, N:1 처럼 컬렉션을 사용하는 곳에 조인하는 것이 컬렉션 조인이다.

세타 조인

WHERE절을 이용해 세타 조인을 할 수 있다.
세타 조인은 내부 조인만 지원
select count(m) from Member m, Team t where m.name = t.name
관계없는 엔티티를 조인할 수 있다.

JOIN ON절

ON 절을 사용하면 조인 대상을 필터링 후 조인이 가능하다. Inner Join에서의 ON 절은 WHERE절을 사용할 때와 같아서 외부 조인에서만 사용한다.

페치 조인

JPQL에서 성능 최적화를 위해 제공하는 기능이다.
join fetch로 사용할 수 있다.

엔티티 페치 조인

select m from Member m join fetch m.team

join뒤에 fetch를 붙이면 연관된 엔티티나 컬렉션을 함께 조회한다.
m.team 다음에 별칭을 붙이는데 페치 조인은 별칭을 사용할 수 없다.

Member와 Team을 지연로딩으로 설정했다고 한다면 회원을 조회할 때 페치 조인을 사용해서 팀도 같이 조회를해서 팀 엔티티는 프록시가 아닌 실제 엔티티이다. 그래서 연관된 팀을 사용해도 지연로딩이 일어나지 않는다.
프록시가 아닌 실제 엔티티기 때문에 멤버 엔티티가 영속성 컨텍스트에서 분리되어 준영속 상태여도 연관된 팀을 조회할 수가 있다.

컬렉션 페치 조인

컬렉션으로 페치 조인한 JPQL은 조회하는 엔티티가 어떤 엔티티안에 연관되어있다면, 연관된 다른 엔티티도 같이 조회한다. 그래서 조인하면서 결과가 증가하여 조회를 두번하게 된다.

페치조인과 DISTINCT

SQL의 DISTINCT는 중복된 결과를 제거하는 명령이다. JPQL에서의 DISTINCT 명령어는 SQL에 DISTINCT를 추가하는 것과 더불어 애플리케이션에서 한번 더 중복을 제거한다.

JPQL에서 select distinct의 의미는 엔티티의 중복을 제거하라는 뜻이므로 위에서 조회를 두번했던 결과를 하나만 조회하게 된다.

페치 조인과 일반 조인의 차이

JPQL은 결과를 반환할 때 연관관계까지 고려하지 않는다. 단지 SELECT 절에 지정한 엔티티만 조회할 뿐이다. 그래서 연관된 엔티티는 조회하지 않는다.
컬렉션을 지연 로딩으로 설정한다면 프록시나 아직 초기화하지 않은 컬렉션 래퍼를 반환한다.
즉시 로딩 이라면 컬렉션을 즉시 로딩하기 위해 바로 쿼리를 한번 더 실행한다.

페치 조인의 특징과 한계

페치 조인을 사용하면 SQL한번으로 연관된 엔티티들을 함께 조회할 수 있어서 SQL 호출 횟수를 줄여 성능을 최적화할 수 있다.
엔티티에 직접 적용하는 로딩 전략은 애플리케이션 전체에 영향을 미치므로 글로벌 로딩 전략이라고 한다.
페치 조인은 글로벌 로딩 전략보다 우선한다. 지연 로딩을 설정해도 JPQL에서 페치 조인을 사용하면 페치 조인이 적용되어 같이 조회하게 된다.
최적화를 위해서 즉시 로딩을 글로벌 로딩 전략으로 가져간다면 항상 즉시 로딩이 일어나게 된다.
일부는 빠를 수 있지만 사용하지 않는 엔티티들도 자주 로딩하여 속도 저하가 우려된다.
그래서

글로벌 로딩 전략은 지연 로딩으로 채택하고 최적화가 필요할 때는 JPQL에서 페치 조인을 적용하는 것이 효과적이다.

페치 조인을 사용하면 연관된 엔티티를 쿼리 시점에 조회하므로 지연 로딩이 발생하지 않는다. 따라서 준영속 상태에서도 객체 그래프를 탐색할 수 있다

페치조인의 한계점

  • 페치 조인 대상에는 별칭을 줄 수 없다.
  • 둘 이상의 컬렉션을 페치할 수 없다.
  • 컬렉션을 페치 조인하면 페이징 API를 사용할 수 없다.
    • 컬렉션이 아닌 단일 값 연관 필드들은 페치 조인을 사용해도 페이징 API 사용 가능

페치 조인은 SQL한번으로 연관된 여러 엔티티를 조회할 수가 있어서 성능 최적화에 상당히 유용하지만 모든 것을 해결할 수는 없다. 그래서 여러 테이블을 조인해서 원하는 값들만 추출해야 할 경우에는 페치 조인보다는 여러 테이블에서 필요한 값들만 조회 한 후에 DTO로 반환 해주는 것이 더 효과적일 수가 있다.

경로 표현식

경로 표현식은 .(점)을 통해 객체 그래프를 탐색하는 것이다.

  • 상태 필드 : 단순히 값을 저장하기 위한 필드
  • 연관 필드 : 연관관계를 위한 필드, 임베디드 타입 포함
    • 단일 값 연관 필드 : @ManyToOne, @OneToOne, 대상이 엔티티
    • 컬렉션 값 연관 필드 : @OneToMany, @ManyToMany, 대상이 컬렉션

경로 표현식과 특징

경로 표현식을 사용하여 경로 탐색을 하려면 3가지 경로에 따라 어떤 특징이 있는지 보자

  • 상태 필드 경로 : 경로 탐색의 끝 더는 탐색 할 수 없음.
  • 단일 값 연관 경로 : 묵시적으로 내부 조인이 일어남, 단일 값 연관 경로는 계속 탐색할 수 있다.
  • 컬렉션 값 연관 경로 : 묵시적으로 내부 조인이 일어남, 더는 탐색할 수 없다.
    • 단, FROM 절에서 조인을 통해 별칭을 얻으면 별칭으로 탐색이 가능함.

단일 값 연관 필드로 경로 탐색을 하면 SQL에서 내부 조인이 일어나는데 이것을 묵시적 조인 이라고 한다.
묵시적 조인은 모두 내부 조인이다.

  • 명시적 조인 : JOIN을 직접 적어주는 것
  • 묵시적 조인 : 경로 표현식에 의해서 묵시적으로 조인이 일어 나는 것, INNER JOIN만 할 수 있음.

경로 탐색을 사용한 묵시적 조인 시 주의 사항

경로 탐색을 사용하면 묵시적 조인이 발생해서 SQL에서 내부 조인이 일어날 수 있다.

  • 항상 내부조인이다.
  • 컬렉션은 경로탐색의 끝, 컬렉션에서 경로 탐색을 하려면 명시적으로 조인을 해서 별칭을 얻어야만 한다.
    • ex) select m.name from Team t join t.members m
  • 경로 탐색은 SELECT, WHERE 절에서 사용하지만 묵시적 조인으로 인해 SQL의 FROM절에 영향을 준다.

조인이 성능으로 차지하는 부분이 아주 크다. 묵시적 조인의 단점은 조인이 일어나는 상황을 한눈에 파악하기 어렵다는 단점이 있다. 성능이 중요하다면 분석하기 쉽도록 명시적 조인을 사용하는것이 좋다.

728x90

'JPA' 카테고리의 다른 글

[JPA] 객체 지향 쿼리 언어 - Querydsl  (0) 2022.08.05
[JPA] 객체 지향 쿼리 언어 - 3  (0) 2022.08.05
[JPA] 객체지향 쿼리 언어 - 1  (0) 2022.08.05
[JPA] 값 타입  (0) 2022.08.05
728x90

JPA는 복잡한 검색 조건을 사용해서 엔티티 객체를 조회할 수 있는 다양한 쿼리기술을 지원한다.

JPQL은 가장 중요한 객체지향 쿼리 언어이다. 다른 Criteria나 QueryDSL은 JPQL을 편리하게 사용하도록 도와주는 기술이므로 JPA를 다루는 개발자라면 JPQL을 필수로 학습해야 된다.

객체지향 쿼리 소개

EntityManager.find() 메소드를 사용하면 식별자로 엔티티 하나를 조회할 수 있다.
검색 방법은 두가지다.

  • 식별자 조회 : EntityManager.find();
  • 객체 그래프 탐색 : a.getB().getC();
    이런 단순한 SELECT 쿼리들로는 개발을 하지 않는다.
    복잡 쿼리나 통계형 쿼리같은 복잡한 쿼리들을 수행할 때에는 이런 쿼리로는 택도 없다.
    ORM을 사용하면 DB테이블이 아니라 엔티티 객체를 대상으로 개발하기 때문에 검색도 마찬가지로 엔티티 객체를 대상으로 하는 방법이 필요함.
    JPQL이 이 문제를 해결하기 위해 만들어졌다. 특징은 다음과 같다.
  • 테이블이 아닌 객체를 대상으로 검색하는 객체지향 쿼리
  • SQL을 추상화해서 특정 DB SQL에 의존하지 않는다.

JPQL을 사용하게 되면 JPA는 이 JPQL을 분석한 다음 적절한 SQL을 만들어 DB를 조회한다. 그리고 그 결과로 엔티티 객체를 생성하여 반환해준다.

JPQL은 객체지향 SQL이라고 정의할 수 있다.

JPA 공식 지원 기능

  • JPQL
  • Criteria 쿼리 : JPQL을 편하게 작성하도록 도와주는 API, Builder 클래스 모음
  • 네이티브 SQL : Mybatis처럼 JPQL대신 직접 SQL사용하는 기능
  • QueryDSL : Criteria 쿼리처럼 JPQL을 편하게 작성하도록 도와주는 빌더 클래스 모음, 비표준 오픈소스 프레임워크임.
  • JDBC 직접 사용, SQL 매퍼 프레임워크 사용 : 필요에 의해 JDBC를 직접 사용가능.

@Test
void jpqlTest() {
    Member member = new Member("kim");
    em.persist(member);
    em.flush();

    String jpql = "select m from Member as m where m.name = 'kim'";
    List<Member> resultList = em.createQuery(jpql, Member.class).getResultList();

    assertThat(resultList.get(0).getName()).isEqualTo("kim");
}

실행결과는 다음과 같다.

다른 값들은 생성자에서 설정 안해주었기 때문에 넣지 않았다.
근데 조금 다른 것이 있다.
그것은 원래 우리가 사용하던 방식인 em.find()를 사용했을 때에는 영속성 컨텍스트인 member가 지금 존재하기 때문에 SELECT쿼리를 날리지 않고 1차캐시에서 조회했었다.

그렇지만 JPQL은 직접 SQL을 추상화해서 사용하기 때문에 쿼리를 날려서 조회하게 된다. 그래서 항상 DB에서 찾는데 이 찾은 엔티티가 영속성 컨텍스트에 존재한다면? DB에서 찾는 데이터를 버리고 영속성 컨텍스트에 있는 반환값을 넘긴다

Criteria의 장점은 문자가 아닌 query.select(m).where(...) 처럼 메소드 체이닝으로 JPQL을 작성할 수 있다.
장점이 많지만 모든 장점을 상쇄할 정도로 복잡하고 장황하다. 따라서 사용하기 불편한건 물론이고 Criteria로 작성한 코드도 한눈에 들어오지 않는 단점이 있음.

@Test
void criteriaTest() {
    //Criteria 사용 준비
    CriteriaBuilder cb = em.getCriteriaBuilder();
    CriteriaQuery<Member> query = cb.createQuery(Member.class);

    //루트 클래스(조회를 시작할 클래스)
    Root<Member> m = query.from(Member.class);

    //쿼리 생성
    CriteriaQuery<Member> cq = query.select(m).where(cb.equal(m.get("name"), "kim"));
    List<Member> resultList = em.createQuery(cq).getResultList();        
}

QueryDSL

QueryDSL도 Criteria처럼 JPQL 빌더 역할을 한다. QueryDSL의 장점은 코드 기반이면서 단순하고 사용하기 쉽다. 작성한 코드도 JPQL과 비슷해서 한눈에 들어온다.

QueryDSL은 JPA 표준은 아니고 오픈소스 프로젝트이다.

코드를 보자

//세팅
JPAQuery query = new JPAQuery(em);
QMember member = QMember.member;

//쿼리, 결과조회
List<Member> members = query.from(member)
                            .where(member.name.eq("kim"))
                            .list(member);

여기서 QMember 클래스는 Member 엔티티 클래스를 기반으로 생성한 QueryDSL 쿼리 전용 클래스이다.

여기까지 보면 이제는 JPA와 QueryDSL로 전반적인 코드를 작성할 수 있을것 같다.
그리고 추가적으로 정말 복잡한 것이라면 네이티브 쿼리를 사용하는것도 방법이겠다.

네이티브 쿼리

SQL을 직접 사용하는 기능이 바로 네이티브 쿼리이다. SI회사에 근무했을 당시 MyBatis, iBatis 많이 사용했는데 바꾸려는 시도가 최근에 이루어졌었기 때문에 점점 JPA가 편해져 가는중이지만 그래도 익숙해보인다.

  • 단점
    • 특정 DB에 의존하는 SQL을 작성해야 한다는 것. 그래서 DB를 바꾸면 쿼리문도 수정해주어야 한다.

내가 MySQL이나 MariaDB를 배웠는데 회사에서 Oracle, PostgreSQL 사용한다면 바꿔야 한다는 얘기이다...

String sql = "SELECT id, name, age FROM Member WHERE name='kim'";
List<Member> resultList = em.createNativeQuery(sql, Member.class).getResultList();

JDBC를 사용하는것과 흡사하다. 다른점은 다음에서 설명하겠다.

JDBC 직접 사용, MyBatis 같은 SQL Mapper 사용

Hibernate에서 JDBC 커넥션을 획득하는 방법

Session session = em.unwrap(Session.class);
session.doWork(new Work() {

    @Override
    public void execute(Connection connection) throws SQLException {
       //작업..
    }
});

위에서 다른점이라고 하는것이 이부분인데,
JDBC나 MyBatis를 JPA와 함께 사용하면 영속성 컨텍스트 관리가 안되는 애들이기 때문에 컨텍스트를 적절한 시점에 강제로 플러시 해줘야 한다. 영속성 컨텍스트와 DB 불일치로 데이터 무결성을 훼손해선 절대적으로 안된다.

728x90

'JPA' 카테고리의 다른 글

[JPA] 객체 지향 쿼리 언어 - 3  (0) 2022.08.05
[JPA] 객체 지향 쿼리 언어 - 2  (0) 2022.08.05
[JPA] 값 타입  (0) 2022.08.05
[JPA] 프록시  (0) 2022.08.05
728x90

이펙티브 자바를 읽으면서 내 기술을 확장하고 싶었다. 그래서 부족한 부분은 채우고 앞으로의 개발에 적용해보려고 한다.

1. 객체의 생성과 파괴

생성자 대신 정적 팩토리 메서드를 고려하라

클래스는 클라이언트에 public 생성자 대신 정적 팩토리 메서드를 제공할 수 있다.

정적 팩토리 메소드가 생성자보다 좋은 장점

  • 이름을 가질 수 있다.
  • 호출될 때마다 인스턴스를 새로 생성하지는 않아도 된다.
  • 반환 타입의 하위 타입 객체를 반환할 수 있는 능력이 있다.
  • 입력 매개변수에 따라 매번 다른 클래스의 객체를 반환할 수 있다.
  • 정적 펙토리 메서드를 작성하는 시점에는 반환할 객체의 클래스가 존재하지 않아도 된다.

단점

  • 상속을 하려면 public이나 protected 생성자가 필요하니 정적 팩토리 메서드만 제공하면 하위 클래스를 만들 수 없다.
  • 정적 팩토리 메서드는 프로그래머가 찾기 어렵다.

정적 팩토리 메서드의 명명 방식

  • from: 매개변수를 하나 받아서 해당 타입의 인스턴스를 반환하는 형변환 메서드
    • Date d = Date.from(instant);
  • of: 여러 매개변수를 받아 적합한 타입의 인스턴스를 반환하는 집계 메서드
    • Set<Rank> faceCards = EnumSet.of(JACK, KING, QUEEN);
  • valueOf: from과 of의 자세한 버전
  • instacne 혹은 getInstance: (매개변수를 받는다면)매개변수로 명시한 인스턴스를 반환하지만, 같은 인스턴스임을 보장하지는 않는다.
  • create 혹은 newInstance: instance 혹은 getInstance와 같지만, 매번 새로운 인스턴스를 생성해 반환함을 보장한다.
  • getType: getInstance와 같으나, 생성할 클래스가 아닌 다른 클래스에 팩토리 메서드를 정의할 때 사용한다. Type은 팩토리 메서드가 반환할 객체의 타입이다.
  • newType: newInstance와 같으나, 생성할 클래스가 아닌 다른 클래스에 팩토리 메서드를 정의할 때 사용한다. Type은 팩토리 메서드가 반환할 객체의 타입이다.
  • type: getType과 newType의 간결한 버전

핵심정리

정적 팩터리 메서드와 public 생성자는 각자의 쓰임새가 있으니 상대적인 장단점을 이해하고 사용하는 것이 좋다. 그렇지만 정적 팩토리를 사용하는게 유리한 경우가 더 많으므로 무작정 public 생성자를 제공하는 습관은 고치자😊

생성자에 매개변수가 많다면 빌더를 고려해라

생성자를 오버로딩하여 만든 점층적 생성자 패턴도 사용은 가능하지만, 매개변수가 엄청 많아지게 된다면 클라이언트 코드를 작성하거나 읽기가 어렵다.
이럴 때 활용하는 대안이 바로 자바빈즈 패턴이다.
기본 생성자로 객체를 초기화하고, setter 메소드를 사용하여 매개변수 값을 설정해주는 방식이다.

public class Apple {
    private int price;
    private String taste;

    public Apple() {
        //기본값이 이것을 생성
    }

    private getPrice() {
        return price;
    }

    private getTaste() {
        return taste;
    }

    private setPrice(int price) {
        this.price = price;
    }

    private setTaste(String taste) {
        this.taste = taste;
    }
}

class Main {
    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.setPrice(1000);
        apple.setTaste("맛있다");
    }
}

이런식으로 구성된 것이 바로 자바빈즈 패턴이다.
그런데 이것도 단점인 이유는 객체 하나를 만드려면 지금은 인자가 2개라서 별로 못느낄 수 있겠지만, 메서드를 여러개 호출해야하고, 완전히 생성된 것이 아니라면 일관성이 무너진 상태에 놓인다.

점층적 생성자 패턴에서는 매개변수들이 유효한지는 생성자에서 확인하면 되었지만, 이 패턴은 그런 것이 없다. 그래서 이 패턴에서는 클래스를 불변으로 만들 수 없다.

빌더 패턴 - 점층적 생성자, 자바빈즈 패턴의 장점만 취함

필요한 객체를 직접 만드는 대신, 필수 매개변수만으로 생성자(혹은 정적 팩토리)를 호출해 빌더 객체를 얻는다. 그 다음 세터 메서드로 원하는 선택적 매개변수 세팅을 한다. 그 후 build 메서드를 호출하여 객체를 생성한다.

여기에 null값을 체크하는 유효성 검사를 넣어주면 완벽한 객체 생성기가 될것이다.

핵심정리

생성자나 정적 팩토리가 처리해야 할 매개변수가 많다면 빌더 패턴을 선택하는게 더 낫다.

Private 생성자나 열거 타입으로 싱글톤임을 보증하라

싱글톤(Singleton)은 인스턴스를 오직 하나만 생성할 수 있는 클래스를 말한다.
클래스를 싱글톤으로 만들면 이를 사용하는 클라이언트를 테스트하기가 어려워질 수 있다.

대부분 상황에서는 원소가 하나뿐인 Enum(열거) 타입이 싱글톤을 만드는 가장 좋은 방법이다.

❗ 단, 만드려는 싱글톤이 Enum 외의 클래스를 상속해야 한다면 사용할 수 없다.

인스턴스화를 막으려면 private 생성자 사용

추상 클래스로 만드는 것으로는 인스턴스화를 막을 수 없다. 왜냐면 하위 클래스를 만들어 인스턴스화를 진행할 수 있기 때문이다. 이것으로 인해 사용하는 개발자가 상속해서 쓰라는 뜻으로 오해할 수 있는 우려가 있다.

컴파일러가 기본 생성자를 만드는 경우는 명시된 생성자가 없을 때밖에 없으니 private생성자를 추가하면 클래스의 인스턴스화를 방지할 수 있다.

728x90

'Java' 카테고리의 다른 글

TDD Clean Code with Java 12기 2주차  (0) 2022.08.05
[JPA] 객체 지향 쿼리 심화  (0) 2022.08.05
MockMvc  (0) 2022.08.04
Mock, Mockito  (0) 2022.08.04

+ Recent posts