2주차 데이터베이스 다루기
데이터베이스 생성 (H2)
- Server Mode
- 외부에서 DB 엔진 구동
- 애플리케이션을 종료시 데이터가 사라지지 않음.
- 배포용도
- In-memory Mode
- 엔진을 설치하지 않고 애플리케이션 내부의 엔진을 사용
- 데이터를 애플리케이션의 메모리에 저장.
- 애플리케이션 종료시 데이터가 사라짐.
- 테스트 용도
- Embedded Mode
- 엔진을 설치하지 않고 애플리케이션 내부의 엔진을 사용.
- 데이터를 애플리케이션 외부에 저장.
- 애플리케이션 종료시 데이터가 사라지지 않음.
- 개발 용도
인메모리 모드 설정 방법
# application.yml
spring:
datasource:
driver-class-name: org.h2.Driver
url: jdbc:h2:mem:{DB 이름}
username: sa
password:
임베디드 모드 설정 방법
# application.yml
spring:
datasource:
driver-class-name: org.h2.Driver
url: jdbc:h2:{DB가 저장될 경로}
username: sa
password:
h2 콘솔은 spring boot를 통해 여는 것이긴 하지만 application.yml 설정과 상관 없이 콘솔 입력 값에 따라 동작한다.
데이터베이스에서 데이터 다루기(SQL)
- DDL: 데이터 정의 언어
- 테이블 생성 (CREATE TABLE)
- 테이블 수정 (ALTER TABLE)
- 테이블 삭제 (DROP TABLE)
- DML: 데이터 조작 언어
- SELECT문 (SELECT, WHERE, ORDER BY, GROUP BY, JOIN ...)
- 데이터 추가 (INSERT INTO)
- 데이터 업데이트 (UPDATE)
- 데이터 삭제 (DELETE FROM)
- DCL: 데이터 제어 언어
트랜잭션
- 데이터베이스의 상태를 변화시키기 위해서 수행하는 작업의 단위
- 원자성 (All of Noting)
- 트랜잭션이 데이터베이스에 모두 반영되던가, 아니면 전혀 반영되지 않아야 한다.
- 트랜잭션은 논리적인 작업 단위.
- 일관성 (Keeps Data Correct)
- 작업 처리 결과가 항상 일관성이 있어야 한다.
- 트랜잭션 중에 데이터베이스가 변경되어도 이전 데이터베이스를 바탕으로 작업한다.
- 독립성 (Independent)
- 둘 이상의 트랜잭션이 동시에 실행되고 있을 경우 다른 트랜잭션의 연산에 끼어들 수 없다.
데이터베이스 연결 (Driver)
- 드라이버의 역할: 애플리케이션의 요청을 데이터베이스가 이해할 수 있는 언어로 변환.
- 드라이버의 종류: 데이터베이스 시스템마다 호환되는 드라이버가 있음.
드라이버의 동작 방식
- 연결 초기화
- 요청 수신: 애플리케이션은 데이터베이스 작업을 시작하기 위해 드라이버에 연결을 요청.
- 연결 설정: 드라이버는 데이터베이스 서버에 로그인하고 필요한 설정을 수행하여 연결을 완료.(네트워크 정보, 인증 자격 증명 등 사용)
- SQL 전송 및 실행
- SQL 명령 변환: 애플리케이션에서 발송된 SQL 명령을 데이터베이스가 이해할 수 있는 형태로 변환.
- 명령 처리: 변환된 명령은 데이터베이스 서버로 전송되어 실행.
- 결과 처리
- 결과 수신: 데이터베이스에서 작업의 결과가 도착하면 애플리케이션에서 해석할 수 있는 형태로 변환.
- 결과 전달: 결과를 애플리케이션에 전달.
- 연결 종료
- 드라이버는 데이터베이스 서버와의 연결을 종료.
JDBC Driver Manager는 런타임 시점에 Connection(데이터베이스 서버와 연결 함), Statement(쿼리를 요청하게 함), ResultSet(쿼리 결과를 받아올 수 있게 함) 객체를 생성한다.
데이터베이스 데이터를 외부에서 다루기 (JDBC)
spring-boot-starter-jdbc
- JDBC API 지원: JDBC API를 통해 SQL 데이터베이스에 접근하고 작업을 수행할 수 있음.
- DataSource 구성: 데이터 소스 연결을 위한 기본적인 설정을 자동으로 구성.
- JdbcTemplate: Spring의 핵심 클래스 중 하나. SQL 쿼리 실행, 결과 세트 처리, 예외 처리 등을 단순화.
- 장점
- 간소화된 데이터베이스 연결: DataSource, JdbcTemplate 사용을 통해 JDBC 코드 간소화.
- 자동 구성: 대부분의 구성을 자동으로 처리.
- 효율적인 예외 처리: DataAccessException을 통해 일관될 예외 체계로 변환.
JDBC 실습
// JdbcApplication.java
package com.thesun4sky.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class JdbcApplication {
public static void main(String[] args) throws SQLException {
// 어플리케이션 실행 컨텍스트 생성
SpringApplication.run(JdbcApplication.class, args);
// 데이터베이스 연결정보
String url = "jdbc:h2:mem:test"; // spring.datasource.url
String username = "sa"; // spring.datasource.username
// connection 얻어오기
try (Connection connection = DriverManager.getConnection(url, username, null)) {
try {
// 테이블 생성 (statement 생성)
String creatSql = "CREATE TABLE USERS (id SERIAL, username varchar(255))";
try (PreparedStatement statement = connection.prepareStatement(creatSql)) {
statement.execute();
}
// 데이터 추가 (statement 생성)
String insertSql = "INSERT INTO USERS (username) VALUES ('teasun kim')";
try (PreparedStatement statement = connection.prepareStatement(insertSql)) {
statement.execute();
}
// 데이터 조회 (statement 생성 후 rs = resultSet 수신 & next() 조회)
String selectSql = "SELECT * FROM USERS";
try (PreparedStatement statement = connection.prepareStatement(selectSql)) {
var rs = statement.executeQuery();
while (rs.next()) {
System.out.printf("%d, %s", rs.getInt("id"), rs.getString("username"));
}
}
} catch (SQLException e) {
if (e.getMessage().equals("ERROR: relation \"account\" already exists")) {
System.out.println("USERS 테이블이 이미 존재합니다.");
} else {
throw new RuntimeException();
}
}
}
}
}
PreparedStatement란?
- Statement를 상속하고 있는 Interface로 내부적으로 Statement의 4단계 중 첫 번째(parse) 과정의 결과를 캐싱하고 나머지 3 단계만 거쳐 SQL 문이 실행될 수 있게 한다. (성능 향상)
String을 만들 때 + 연산자를 사용하는 것과 %s 등으로 포맷팅 하는 것의 차이와 비슷.
JDBC Template
JDBC로 직접 SQL을 작성했을 때는 자원 관리를 따로 해줘야 하고, 중복 코드도 자주 발생한다는 문제가 있음. 이를 해결하기 위해 Persistence Framework가 등장.
- Persistence Framework
- SQL Mapper: JDBC Template, MyBatis
- ORM: JPA, Hibernate
- SQL Mapper(QueryMapper)
- SQL <-> Object
- SQL 문과 객체의 필드를 매핑하여 데이터를 객체화
- RowMapper
- 쿼리 수행 결과와 객체 필드 매핑
- 응답필드 매핑코드 재사용.
// UserRowMapper.java
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class UserRowMapper implements RowMapper<User> {
// JDBCTemplate 에서 row 응답을 mapRow() 메서드에 rs 파라미터로 넘겨주어 객체에 매핑하기 쉽도록 도와준다.
@Override
public User mapRow(ResultSet rs, int rowNum) throws SQLException {
var user = new User();
user.setId(rs.getInt("ID"));
user.setName(rs.getString("NAME"));
return user;
}
}
// 레지스토리
// 사용자 ID로 User 조회 (Read)
public User findUserById(Long id) {
return jdbcTemplate.queryForObject(
"SELECT * FROM users WHERE id = ?",
new UserRowMapper(), // 이자리에 매퍼를 생성자로 넣어주면 됨
id
);
}
3주차 RawJPA 기본
쿼리 파일 만들기 (QueryMapper)
MyBatis
- 코드의 설정(Connection) 부분을 줄여 반복적인 JDBC 프로그래밍 단순화.
- SQL 쿼리를 XML 파일에 작성하여 코드와 SQL 분리.
- 다른 방식에 비해 객체 보다는 쿼리에 집중 가능.
단점
- 결국 SQL을 직접 작성해야 한다는 한계가 있음.
- DB타입 및 테이블에 종속적임.
쿼리 파일
<!-- UserMapper.xml -->
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.thesun4sky.querymapper.mapper.UserMapper">
<select id="selectUserById" resultType="User">
select id, name from users where id = #{id}
</select>
</mapper>
Dao 클래스 정의
// UserDao.java
import org.apache.ibatis.session.SqlSession;
import org.springframework.stereotype.Component;
import com.thesun4sky.querymapper.domain.User;
@Component
public class UserDao {
// SqlSession 멤버 변수로 사용하며 쿼리파일 수행 요청
private final SqlSession sqlSession;
public UserDao(SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
public User selectUserById(long id) {
return this.sqlSession.selectOne("selectUserById", id);
}
}
select id(selectUserById)를 sqlSession.selectOne의 첫 파라미터로 넣는다. 다음 파라미터부터는 쿼리의 변수들을 받는다.
Mapper Interface 정의
// UserMapper.java
@Mapper
public interface UserMapper {
User selectUserById(@Param("id") Long id);
}
select id(selectUserById)와 메서드 이름을 맞춘다. 파라미터로는 쿼리의 변수들을 받는다.
쿼리 코드 만들기 (JpaRepository)
ORM은 테이블을 하나의 객체와 대응시킨다.
테이블과 객체를 매핑할 때 문제점
- 상속의 문제
- 문제점: 객체에는 상속관계를 맺을 수 있으나 RDB는 모두 독립적으로 존재함.
- 해결법: 매핑정보에 상속정보를 넣어줌. (@OneToMany, @ManyToOne)
- 관계 문제
- 문제점: 참조를 통해 관계를 가지며 방향을 가지나 RDB는 FK를 설정해 Join해야 참조 가능.
- 해결법: 매핑정보에 방향정보를 넣어줌. (@JoinColumn, @MappedBy)
- 탐색 문제
- 문제점: 객체는 참조를 통해 다른 객체로 순차적 탐색 가능하나 RDB는 참조하는 만큼 추가 쿼리나 Join이 발샘함.
- 해결법: 매핑/조회 정보로 참조탐색 시점을 관리함. (@FetchType, fetchJoin())
- 밀도 문제
- 문제점: 객체는 멤버 객체크기가 각양각색이나 RDB는 기본 데이터 타입만 존재함.
- 해결법: 크기가 큰 멤버 객체는 테이블을 분리하여 상속으로 처리. (@embedded)
- 식별성 문제
- 문제점: 객체는 hashCode 또는 equals() 메소드를 통해 식하나 RDB는 PK로만 식별함.
- 해결법: PK를 객체 Id로 설정하고 EntityManager는 해당 값으로 객체를 식별하여 관리 함. (@Id, @GeneratedValue)
영속성 컨텍스트(1차 캐시)를 활용한 쓰기지연
(영속성에 대한 정리는 많이 했었으므로 자세한 내용 생략!)
영속성이란 데이터를 생성한 프로그램이 종료되어도 사라지지 않는 데이터의 특성을 말한다.
영속성 4가지 상태 (비영속 -> 영속 -> 준영속 / 삭제)
단 키 생성전략이 generationType.IDENTITY 로 설정 되어있는 경우 중복키 생성을 방지하기 위해 단일 쿼리로 수행하며 쓰기 지연이 발생하지 않는다.
JpaRepository
JpaRepository는 @NotRepositoryBean 된 인터페이스들을 상속 받고있음. Bean으로 등록하지 않을 것이라는 뜻으로 상속받으면 생성돼서 사용.
테이블 객체 이해하기
Raw JPA 타입 매핑 기능
- @Entity
- @Table
- RDB의 테이블 이름. 기본값은 Entity 이름
- @Id
- 엔티티의 주키를 매핑할 때 사용
- 자바의 모든 primitive 타입과 그 래퍼 클래스 사용 가능.
- Date, BigDecimal, BigInteger도 사용 가능.
- @GeneratedValue
- TABLE, SEQUENCE, IDENTITY 중 하나
- @Column
- uniqu, nullable, length, columnDefinition... DB의 설정 넣기 위해 사용
- @Temparal
- @Transient
Raw JPA 필드 매핑 기능
- 기본 타입
- @Column: DB의 설정 넣기 위해 사용. Class에 @Entity가 붙어있으면 자동으로 필드에 @Column이 붙음.
- @Enumerated: Enum 매핑용도로 쓰임. @Enumerated(EnumType.STRING) 으로 사용 권장. Default의 경우 순서에 영향을 받는 문제 있음.
- Composite Value 타입
- @Embeddable: 복합 값 객체로 사용할 클래스 지정
- @Embedded: 복합 값 객체 적용할 필드 지정
- @AttributeOverrides: 복합 값 객체 여러개 지정
- @AttributeOverride: 복합 값 객체 필드명 선언
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Entity
@Setter
@Getter
public class Member{
@Id @GeneratedValue
@Column(name = "MEMBER_ID")
private Long id;
@Embeddable public class Address { private String city; private String street; }
private String name;
@Embedded
@AttributeOverrides({
@AttributeOverride(name = "city", column = @Column(name = "home_city")),
@AttributeOverride(name = "street", column = @Column(name = "home_street")),
})
private Address homeAddress;
@Embedded
@AttributeOverrides({
@AttributeOverride(name = "city", column = @Column(name = "company_city")),
@AttributeOverride(name = "street", column = @Column(name = "company_street")),
})
private Address companyAddress;
}
```
- Collection Value 타입
- 현업에선 잘 사용하지 않음. 일대다 연관관계로 풀어 씀.
- @ElementCollection
테이블 객체 만들기
템플릿
/**
* 컬럼 - 연관관계 컬럼을 제외한 컬럼을 정의합니다.
*/
/**
* 생성자 - 약속된 형태로만 생성가능하도록 합니다.
*/
/**
* 연관관계 - Foreign Key 값을 따로 컬럼으로 정의하지 않고 연관 관계로 정의합니다.
*/
/**
* 연관관계 편의 메소드 - 반대쪽에는 연관관계 편의 메소드가 없도록 주의합니다.
*/
/**
* 서비스 메소드 - 외부에서 엔티티를 수정할 메소드를 정의합니다. (단일 책임을 가지도록 주의합니다.)
*/
샘플
// User.java
// lombok
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString
// jpa
@Entity
@Table(name = "users")
public class User {
/**
* 컬럼 - 연관관계 컬럼을 제외한 컬럼을 정의합니다.
*/
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
private String username;
private String password;
/**
* 생성자 - 약속된 형태로만 생성가능하도록 합니다.
*/
@Builder
public User(String username, String password) {
this.username = username;
this.password = password;
}
/**
* 연관관계 - Foreign Key 값을 따로 컬럼으로 정의하지 않고 연관 관계로 정의합니다.
*/
@OneToMany
@Exclude
private Set<UserChannel> userChannel;
/**
* 연관관계 편의 메소드 - 반대쪽에는 연관관계 편의 메소드가 없도록 주의합니다.
*/
/**
* 서비스 메소드 - 외부에서 엔티티를 수정할 메소드를 정의합니다. (단일 책임을 가지도록 주의합니다.)
*/
public void updateUserName(String username) {
this.username = username;
}
public void updatePassword(String password) {
this.password = password;
}
}
테이블 객체끼리 관계만들기
- @OneToOne
- @OneToMany
- 단방향으로 쓰이면 문제가 발생할 수 있음.
- 속성: mappedBy, fetch(기본 LAZY), cascade, targetEntity...
- @ManyToOne
- optional(default true): false로 설정하면 연관된 엔티티가 반드시 있어야 함.
- fetch: 기본 EGEAR이나 LAZY 추천.
- cascade: 영속성 전이
- targetEntity: 연관된 엔티티의 타입 정보 설정
- @ManyToMany
- 실무에서는 사용하지 않음. 중간 테이블 생성.
4주차 SpringData JPA 기본
테이블 객체 다루는법
Cascade (영속성 전이)
- 부모 엔티티(OneToMany, OneToOne이 있는 곳)에서 사용
- 양쪽 엔티티의 라이프사이클이 비슷할 경우
- 대상 엔티티로의 영속성 전이는 현재 엔티티에서만 전이 되어야 함
- 옵션 종류
- ALL: 전체 상태 전이
- PERSIST: 저장 상태 전이
- REMOVE: 삭제 상태 전이
- MERGE: 업데이트 상태 전이
- REFRESH: 갱신 상태 전이
- DETACH: 비영속성 상태 전이
orhanRemoval (고아 객체 제거)
- 부모 엔티티에서 사용
- 부모 객체에서 리스트 요소를 삭제했을 때 자식 객체는 매핑정보가 없어져 고아 객체가 되므로 삭제.
보통 둘 다 같이 사용.
Fetch (조회시점)
- Entity에 FetchType으로 설정
- 기본적으로 LAZY를 설정하고 필요할 때만 fetch Join을 수행하는 것이 좋다.
- 항상 같이 쓰일 경우에는 EAGER를 사용하자.
테이블 객체로 자동 쿼리 생성하기
구조와 작동 원리
@SpringBootApplication을 통해 자동으로 붙여지는 @EnableJpaRepositories의 JpaRepositoriesRegistrar를 통해 등록된다. JrpRepositoriesRegistrar는 ImportBeanDefinitionRegistrar의 구현체로 프로그래밍을 통해 빈을 주입해준다.
JpaRepository 쿼리 사용 방법
리턴타입 {접두어}{도입부}By{프로퍼티 표현식}(조건식)(And|Or){프로퍼티 표현식}(조건식) (매개변수...)
| |
|
| 접두어 |
Find, Get, Query, Count, ... |
| 도입부 |
Distinct, First(N), Top(N) |
| 프로퍼티 표현식 |
Person.Address.ZipCode => find(Person)ByAddress_ZipCode(...) |
| 조건식 |
IgnoreCase, Between, LessThan, GreaterThan, Like, Contains, ... |
| 정렬 조건 |
OrderBy{프로퍼티}Asc |
| 리턴 타입 |
E, Optional, List, Page, Slice, Stream |
| 매개변수 |
Pageable, Sort |
예시 코드
// 기본
List<User> findByNameAndPassword(String name, String password);
// distinct (중복제거)
List<User> findDistinctUserByNameOrPassword(String name, String password);
List<User> findUserDistinctByNameOrPassword(String name, String password);
// ignoring case (대소문자 무시)
List<User> findByNameIgnoreCase(String name);
List<User> findByNameAndPasswordAllIgnoreCase(String name, String password);
// 정렬
List<Person> findByNameOrderByNameAsc(String name);
List<Person> findByNameOrderByNameDesc(String name);
// 페이징
Page<User> findByName(String name, Pageable pageable); // Page 는 카운트쿼리 수행됨
Slice<User> findByName(String name, Pageable pageable); // Slice 는 카운트쿼리 수행안됨
List<User> findByName(String name, Sort sort);
List<User> findByName(String name, Pageable pageable);
// 스트림 (stream 다쓴후 자원 해제 해줘야하므로 try with resource 사용추천)
Stream<User> readAllByNameNotNull();
JpaRepository 효율적으로 사용하는 방법
default 메서드를 사용하여 변형한 jpa 쿼리 메서드를 사용할 수 있다.
Optional 제거하고 반환
public interface UserRepository extends JpaRepository<User, Long> {
// Default 메소드를 사용하여 findById의 Optional을 내부적으로 처리
default User findUserById(Long id) {
return findById(id).orElseThrow(() -> new DataNotFoundException("User not found with id: " + id));
}
}
메서드명 간소화
public interface UserRepository extends JpaRepository<User, Long> {
// Default 메소드를 사용하여 findById의 Optional을 내부적으로 처리
default User findUserById(Long id) {
return findById(id).orElseThrow(() -> new DataNotFoundException("User not found with id: " + id));
}
}
비즈니스 로직 통합(예시를 위한 코드로 현업에서는 서비스 레이어에서 처리)
public interface UserRepository extends JpaRepository<User, Long> {
// 사용자 ID로 사용자를 찾고, 존재할 경우 연락처 정보를 업데이트하는 메소드
default void updateUserContact(Long userId, String newContact) {
findById(userId).ifPresent(user -> {
user.setContact(newContact);
save(user);
});
}
}
테이블 객체로 페이지 조회하기
페이징 요청: Pageable
Pageable 만드는 법
PageRequest.of(int page, int size) : 0부터 시작하는 페이지 번호와 개수. 정렬이 지정되지 않음
PageRequest.of(int page, int size, Sort sort) : 페이지 번호와 개수, 정렬 관련 정보
PageRequest.of(int page int size, Sort sort, Direction direction, String ... props) : 0부터 시작하는 페이지 번호와 개수, 정렬의 방향과 정렬 기준 필드들
Pageable 메서드
pageable.getTotalPages() : 총 페이지 수
pageable.getTotalElements() : 전체 개수
pageable.getNumber() : 현재 페이지 번호
pageable.getSize() : 페이지 당 데이터 개수
pageable.hasnext() : 다음 페이지 존재 여부
pageable.isFirst() : 시작페이지 여부
pageable.getContent(), PageRequest.get() : 실제 컨텐츠를 가지고 오는 메서드. getContext는 List<Entity> 반환, get()은 Stream<Entity> 반환
페이징 응답
- Page: 게시판 형태의 페이징에서도 사용됨. 전체 요소 갯수도 함께 조회.
`{ "content": [ {"id": 1, "username": "User 0", "address": "Korea", "age": 0}, ... {"id": 5, "username": "User 4", "address": "Korea", "age": 4} ], "pageable": { "sort": { "sorted": false, // 정렬 상태 "unsorted": true, "empty": true }, "pageSize": 5, // 페이지 크기 "pageNumber": 0, // 페이지 번호 (0번 부터 시작) "offset": 0, // 해당 페이지의 첫번째 요소의 전체 순번 (다음 페이지에서는 5) "paged": true, "unpaged": false }, "totalPages": 20, // 페이지로 제공되는 총 페이지 수 "totalElements": 100, // 모든 페이지에 존재하는 총 원소 수 "last": false, // 마지막 페이지 여부 "number": 0, "sort": { "sorted": false, // 정렬 사용 여부 "unsorted": true, "empty": true }, "size": 5, // Contents 사이즈 "numberOfElements": 5, // Contents 의 원소 수 "first": true, // 첫페이지 여부 "empty": false // 공백 여부 }`- Slice: 더보기 형태의 페이징에서 사용됨. 전체 요소 갯수 대신 offset 필드로 조회 가능하나 성능이 안 좋아서 현업에서 안 씀.
`{ "content": [ { "id": 13, "username": "User 12", "address": "Korea", "age": 12 }, ... { "id": 16, "username": "User 15", "address": "Korea", "age": 15 } ], "pageable": { "sort": { "sorted": false, "unsorted": true, "empty": true }, "pageNumber": 3, "pageSize": 4, "offset": 12, "paged": true, "unpaged": false }, "number": 3, "numberOfElements": 4, "first": false, "last": false, "size": 4, "sort": { "sorted": false, "unsorted": true, "empty": true }, "empty": false }`
- List: 전체 목록보기 형태의 페이징에서 사용.
정렬
Sort 클래스 사용.
Sort sort1 = Sort.by("name").descending(); // 내림차순
Sort sort2 = Sort.by("password").ascending(); // 오름차순
Sort sortAll = sort1.and(sort2); // 2개이상 다중정렬도 가능하다
Pageable pageable = PageRequest.of(0, 10, sortAll); // pageable 생성시 추가
컬럼이 아닌 값도 Alias를 기준으로 정렬 가능.
// 아래와 같이 AS user_password 로 Alias(AS) 를 걸어주면
@Query("SELECT u.user_name, u.password AS user_password FROM user u WHERE u.username = ?1")
List<User> findByUsername(String username, Sort sort);
// 이렇게 해당 user_password 를 기준으로 정렬할 수 있다.
List<User> users = findByUsername("user", Sort.by("user_password"));
SQL 함수도 사용 가능: JpaSort 사용
// 아래와 같이 일반적인 쿼리에서
@Query("SELECT u FROM user u WHERE u.username = ?1") // 이건 없어도됨
List<User> findByUsername(String username, Sort sort);
// 이렇게 쿼리함수 LENGTH() 조건을 걸어서 password 문자길이 기준으로 정렬할 수 있다.
List<User> users = findByUsername("user", JpaSort.unsafe("LENGTH(password)"));
테이블 객체로 수동 쿼리 생성하기
Query
@Query의 인자값으로 쿼리 작성 가능.
- 테이블명이 아니라 Entity 명으로 작성한다.
- ?변수순번, :변수명 두 가지 사용 방법이 있다.
public interface UserRepository extends JpaRepository<User, Long> { @Query("SELECT u, u.password AS customField FROM User u WHERE u.username = ?1") List<User> findByUsernameWithCustomField(String username, Sort sort);`
@Query("SELECT u FROM User u WHERE u.username = :username")
List findByUsername(String username, Sort sort);
}
5주차 SpringDataJPA 심화
QueryDSL
Entity 의 매핑정보를 활용하여 쿼리에 적합하도록 쿼리 전용 클래스(Q클래스)로 재구성해주는 기술.
JPAQueryFactory는 Q클래스를 통해 객체 또는 함수로 쿼리를 작성하고 실행하게 해주는 기술로 Q클래스를 활용할 수 있는 기능들을 제공함.
@PersistenceContext
EntityManager em;
public List selectUserByUsernameAndPassword(String username, String password){
JPAQueryFactory jqf = new JPAQueryFactory(em);
QUser user = QUser.user;
List<Person> userList = jpf
.selectFrom(user)
.where(person.username.eq(username)
.and(person.password.eq(password))
.fetch();
return userList;
}
config
// configuration 패키지안에 추가
@Configuration
public class JPAConfiguration {
@PersistenceContext
private EntityManager entityManager;
@Bean
public JPAQueryFactory jpaQueryFactory() {
return new JPAQueryFactory(entityManager);
}
}
Auditing
엔티티를 언제 생성/마지막 수정 했는지 자동으로 기록
- 메인 애플리케이션 위에 @EnableJpaAuditing 추가
- 엔티티 클래스 위에 @EntityListeners(AuditingEntityListener.class) 추가
@CreatedDate
private Date created;
@LastModifiedDate
private Date updated;
@CreatedBy
@ManyToOne
private Account createdBy;
@LastModifiedBy
@ManyToOne
private Account updatedBy;
방명록 기능에서 작성/수정한 사람을 찾기 위해 AuditorAware 구현체를 만들 수 있음.
- SecurityContextHolder에서 UserDetailsImpl을 사용해 user 객체 가져오기.
@Service
public class UserAuditorAware implements AuditorAware {
@Override
public Optional getCurrentAuditor() {
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
if (authentication == null || !authentication.isAuthenticated()) {
return Optional.empty();
}
return Optional.of(((UserDetailsImpl) authentication.getPrincipal()).getUser());
}
}
```
Dynamic Insert/Update
@DynamicInsert
@DynamicUpdate
불필요한 칼럼이 들어가는 것을 막아 최적화.
