java_dong.log

QueryDSL 중급

Sun, 16 Mar 2025 03:02:19 GMT

프로젝션과 결과 반환

프로젝션 대상이 하나

List result = queryFactory
                    .select(member.username)
                    .from(member)
                    .fetch();

프로젝션 대상이 하나면 타입을 명확히 지정할 수 있음
프로젝션 대상이 둘 이상이면 튜플이나 DTO로 조회

튜플 조회

프로젝션 대상이 둘 이상일 때 사용

List result= queryFactory
.select(member.username,member.age)
.from(member)
.fetch();

프로젝션 결과 DTO 조회

MemberDto

@Data
public class MemberDto {
    private String username;
    private int age;

    public MemberDto() {
    }

    public MemberDto(String username, int age) {
        this.username = username;
        this.age = age;
    }
}

DTO 조회 코드

List result = em.createQuery(
"select new study.querydsl.dto.MemberDto(m.username,m.age)" +
"from Member m",MemberDto.class)
.getresultList();

순수 JPA에서는 DTO를 조회할때 new 명령어를 사용해야함
DTO의 패키지명과 생성자 방식만 지원해서 더러움

Querydsl 빈 생성

프로퍼티 접근
필드 직접 접근
생성자 사용

프로퍼티 접근 setter

List result =queryFactory.
select(Projections.bean(MemberDto.class,member.username,member.age))
.from(member)
.fetch();

필드 직접 접근

List result =queryFactory
.select(Projections.fields(MemberDto.class,member.suername,member.age))
.from(member)
.fetch();

별칭이 다를 때

@Data
public class UserDto {
    private String name;
    private int age;

    public UserDto() {
    }

    public UserDto(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

코드

List fetch =queryFactory
.select(Projections.fields(UserDto.class,member.username,as("name"),
ExpressionUtils.as(
JPAExpressions
.select(memberSub.age.max())
.from(memberSub),"age"))
.from(member)
.fetch();

ExpressionUtils.as(source,alias): 필드나 서브 쿼리에 별칭 적용
username.as("memberName"): 필드에 별칭 적용

생성자 사용

List result =queryFactory
.select(Projections.constructor(MemberDto.class,member.username,member.age))
.from(member)
.fetch();

@QueryProjection

@Data
public class MemberDto {
    private String username;
    private int age;

    public MemberDto() {
    }
    @QueryProjection
    public MemberDto(String username, int age) {
        this.username = username;
        this.age = age;
    }
}

이때 QMemberDto 생성 확인

@QueryProjection 활용

List result =queryFactory
.select(new QMemberDto(member.username,member.age))
.from(member)
.fetch();

동적쿼리

@Test
    void dynamicQuery_BooleanBuilder(){
        String usernameParam = "member1";
        Integer ageParam=10;

        List result = searchMember1(usernameParam,ageParam);
        assertThat(result.size()).isEqualTo(1);
    }

    private List searchMember1(String usernameParam, Integer ageParam) {
        BooleanBuilder builder = new BooleanBuilder();
        if(usernameParam!=null){
            builder.and(member.username.eq(usernameParam));
        }
        if(ageParam!=null){
            builder.and(member.age.eq(ageParam));
        }

        return queryFactory.selectFrom(member).where(builder).fetch();
    }

BooleanBuilder로 동적쿼리 설정

where 다중 파라미터 사용

 @Test
    void dynamicQuery_whereParam(){
        String usernameParam = "member1";
        Integer ageParam=10;

        List result = searchMember2(usernameParam,ageParam);
        assertThat(result.size()).isEqualTo(1);
    }

    private List searchMember2(String usernameParam, Integer ageParam) {
        return queryFactory.selectFrom(member)
                .where(usernameEq(usernameParam),ageEq(ageParam))
                .fetch();
    }

    private BooleanExpression ageEq(Integer ageParam) {
        return ageParam!=null ? member.age.eq(ageParam) : null;
    }

    private BooleanExpression usernameEq(String usernameParam) {
        return usernameParam==null ? null :  member.username.eq(usernameParam);
    }

where 조건에 null값은 무시
메서드를 다른 쿼리에서도 재활용 가능
쿼리자체의 가독성이 높아짐

조합 가능

private BooleanExpression allEq(String usernameParam, Integer ageParam) {
        return usernameEq(usernameParam).and(ageEq(ageParam));
    }

수정/삭제 벌크 연산

쿼리한번으로 대량 데이터 수정

long count = queryFactory.update(member).set(member.username,"비회원")
                        .where(member.age.lt(28)).execute();

        em.flush();
        em.clear();

기존 숫자에 더하기/곱하기

long count =queryFactory.update(member).set(member.age,member.age.add(1)).execute();
long count2 =queryFactory.update(member).set(member.age,member.age.multiply(2)).execute();

대용량 삭제

long cnt= queryFactory.delete(member).where(member.age.gt(18)).execute();

출처: https://www.inflearn.com/course/querydsl-%EC%8B%A4%EC%A0%84

프로젝트로 정리하는 리액트(4)

Sun, 16 Mar 2025 02:16:40 GMT

수정 기능

** Edit 페이지**

const Edit=()=>{
    const nav =useNavigate();
    const {onDelete} = useContext(DiaryDispatchContext);
    const {onUpdate}=useContext(DiaryDispatchContext);
    const data = useContext(DiaryStateContext);
    const params =useParams();
    const [curDiaryItem,setCurDiaryItem] = useState();
    useEffect(()=>{
        const currentDiaryItem = data.find((item)=>String(item.id)===String(params.id));
        if(!currentDiaryItem){
            window.alert('존재하지 않는 일기입니다');
            nav('/',{replace:true});                      
        }
        setCurDiaryItem(currentDiaryItem);
    },[params.id]);
    const onClickDelete = ()=>{
        if(window.confirm('정말로 삭제하실겁니까?')){
            onDelete(params.id);
            nav('/',{replace:true});
        }
    }

    const onSubmit=(input)=>{
        if(window.confirm("일기를 정말 수정?")){
            onUpdate(params.id,input.createdDate.getTime(),input.emotionId,input.content);
        }
        nav('/',{replace:true});
    }
    return(
        
            {
                nav(-1)}}>} rightChild={}>
            
            
        
    )
}

export default Edit

const currentDiaryItem = data.find((item)=>String(item.id)===String(params.id));
useContext로 전달 받은 데이터 중에서 아이디값과 파라미터로 받은 아이디 값이 같은 데이터 탐색
파라미터가 달라질 때마다 리렌더링 되어야 하니 params.id로 설정
confirm으로 사용자 편리성 증대

Editor Component

const Editor=({onSubmit,initData})=>{
    const [differ,setDiffer]=useState();
    useEffect(()=>{
        if(initData){
            setDiffer(initData.emotionId);
            setInput({
                ...initData,
                createdDate: new Date(Number(initData.createdDate))
            })
        }
    },[initData])

    const nav=useNavigate();
    const[input,setInput]=useState({
        createdDate:new Date(),
        emotionId:3,
        content:""
    });
   console.log(initData);


    const onClickSubmit=()=>{
        onSubmit(input);
    }

    const onChangeInput=(e)=>{
        let name=e.target.name;
        let value=e.target.value;
        if(name==='createdDate'){
            value= new Date(value);
        }

        setDiffer(null);

        setInput({...input,[name]:value});

    }

    return(
        
            
                오늘의 날짜
                
            
            
                오늘의 감정
                
                    {emotionList.map((item)=> onChangeInput({
                        target:{
                            name:'emotionId',
                            value:item.emotionId
                        }
                    })}> )}
                
            
            
                오늘의 일기
                
            
            
                
                
            
        
    )
}

export default Editor

initData를 값으로 전달 받아 수정하기를 누르면 기존에 입력되어있던 데이터가 화면상에 표시되도록 만듦
onChangeInput에서 사용자가 EmotionItem을 클릭하면 differ를 초기화 함
이는 후에 나오는 EmotionItem 컴포넌트에서 기존에 입력되었던 emotionId를 초기화하여 클릭시 기존에 있던 배경색은 사라지게 만들고 새로 클릭한 배경색이 되게 만듦

EmotionItem Component

const EmotionItem=({emotionId,emotionName,isSelected,onClick,differ})=>{

    const isDefault = differ !== null && differ === emotionId;


    console.log(isDefault);
    return(
        
            
                
                
                    {emotionName}
                
            
        
    )
}

export default EmotionItem

const isDefault = differ !== null && differ === emotionId;: null값이면 false
{isDefault ? EmotionItem_default_${emotionId}:""}}: true 일 때만 해당 css가 적용됨

QueryDSL 시작

Sat, 15 Mar 2025 10:33:37 GMT

예제 도메인 모델

Member

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString(of={"id","username","age"})
public class Member {
    @Id
    @GeneratedValue
    private Long id;
    private String username;
    private int age;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "team_id")
    private Team team;

    public Member(String username) {
        this(username, 0);
    }

    public Member(String username, int age) {
        this(username, age, null);
    }
    public Member(String username, int age, Team team) {
        this.username = username;
        this.age = age;
        if (team != null) {
            changeTeam(team);
        }
    }
    public void changeTeam(Team team) {
        this.team = team;
        team.getMembers().add(this);
    }
}

ToString은 가급적이면 연관관계에 해당하지 않는 걸로 설정
NoArgsConstructor => protected로 외부에서 접근 못하게 막음
changeTeam으로 양방향 연관관계 한번에 처리하기

Team

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString(of = {"id", "name"})
public class Team {
    @Id
    @GeneratedValue
    @Column(name = "team_id")
    private Long id;
    private String name;

    @OneToMany(mappedBy = "team")
    private List members=new ArrayList<>();

    public Team(String name) {
        this.name = name;
    }
}

Member와 Team의 양방향 연관관계 설정
하지만 연관관계의 주인은 Member이므로 Team에서는 조회만 가능함

기본 문법

JPQL

@Test
    void startJpql(){
        String qlString= "select m from Member m " +
                "where m.username = :username";
        Member findMember = (Member)em.createQuery(qlString).setParameter("username","member1").getSingleResult();
        assertThat(findMember.getUsername()).isEqualTo("member1");
    }

사전에 저장된 회원 값 찾기

QueryDSL

  @Test
    void startQuerydls(){

        JPAQueryFactory queryFactory = new JPAQueryFactory(em);
        QMember m= new QMember("m");
        Member findMember = queryFactory.select(m)
                .from(m)
                .where(m.username.eq("member1"))
                .fetchOne();
        assertThat(findMember.getUsername()).isEqualTo("member1");

    }

EntityManager로 JPAQueryFactory 생성

@BeforeEach
    public void before() {
        queryFactory = new JPAQueryFactory(em);
//...
}

쿼리팩토리를 필드로 제공하면 EntityManager가 크랜잭션 마다 별도의 영속성 컨텍스트를 제공하므로 동시성 문제는 걱정하지 않아도 됨

기본 Q-Type 활용

QMember qMember= new QMember("m");
QMember qMember = QMember.member

기본 인스턴스를 static import와 함께 사용 가능
같은 테이블을 조인해야 하는 경우가 아니라면 기본 인스턴스를 권장한다

검색조건 쿼리

@Test
    void search(){
        Member findMember= queryFactory.select(member).from(member).where(member.username.eq("member1").and(member.age.eq(10))).fetchOne();
        assertThat(findMember.getUsername()).isEqualTo("member1");
    }

검색조건은 and,or를 메서드 체인으로 연결이 가능
select,from을 select from으로 합치기도 가능

검색조건 예시

eq(member1): =
ne(member1): !=
eq(member1).not(): !=
isNotNull(): is not null
in(a,b)
notIn(a,b)
between(a,b)
goe(10) : >=
gt(10): >
loe(10): <=
lt(10): <
like(member1%)
contains(member) : like %member1%
startsWith(member): like member%

 @Test
    void searchAndParam(){
        Member findMember = queryFactory.selectFrom(member).where(member.username.eq("member1"),member.age.eq(10)).fetchOne();

        assertThat(findMember.getUsername()).isEqualTo("member1");
    }

where()에 파라미터로 검색조건을 추가하면 And 조건이 추가됨
이 경우 null값은 무시 => 메서드 추출을 활용해서 깔끔한 동적 쿼리를 만들 수 있다

결과조회

fetch(): 리스트 조회, 데이터 없으면 빈 리스트 반환
fetchOne(): 단건 조회
- 결과가 없으면 null
- 결과가 둘 이상이면 예외 반환
fetchFirst(): limit(1).fetchOne()
fetchResults(): 페이징 정보 포함, total count 쿼리 추가 실행
fetchCount(): count 쿼리로 변경해서 count 수 조회

정렬

@Test
    void sort(){
        em.persist(new Member(null,100));
        em.persist(new Member("member5",100));
        em.persist(new Member("member6",100));

        List result = queryFactory.selectFrom(member).where(member.age.eq(100)).orderBy(member.age.desc(), member.username.asc().nullsLast()).fetch();
        System.out.println(result.toString());
        Member member5 = result.get(0);
        Member member6 = result.get(1);
        Member member7 = result.get(2);
        assertThat(member5.getUsername()).isEqualTo("member5");
        assertThat(member6.getUsername()).isEqualTo("member6");
        assertThat(member7.getUsername()).isNull();
    }

desc(),asc(): 일반 정렬
nullsLast(),nullsFirst(): null 데이터 순서 부여

페이징

조회 건수 제한

 @Test
    void paging() {

        List result = queryFactory.selectFrom(member)
                .orderBy(member.username.desc())
                .offset(1)
                .limit(2)
                .fetch();
    }

offset(1): 0부터 조회
limit(2): 최대 2건 조회

*전체 조회 수 *

 @Test
    void paging2(){
        QueryResults result = queryFactory.selectFrom(member)
                .orderBy(member.username.desc())
                .offset(1)
                .limit(2)
                .fetchResults();
        assertThat(result.getTotal()).isEqualTo(4);
        assertThat(result.getLimit()).isEqualTo(2);
        assertThat(result.getOffset()).isEqualTo(1);

    }

집합

집합 함수

COUNT(m) : 회원 수
SUM(m.age): 나이 합
AVG(m.age): 평균 나이
MAX(m.age): 최대 나이
MIN(m.age): 최소 나이

사용 예시

@Test
    void aggregation(){
        List fetch = queryFactory.select(member.count(), member.age.sum(), member.age.avg(), member.age.max(), member.age.min()).from(member).fetch();
        Tuple tuple = fetch.get(0);
        assertThat(tuple.get(member.count())).isEqualTo(4) ;
        assertThat(tuple.get(member.age.sum())).isEqualTo(100);
    }

group by

 @Test
    void group() throws Exception{
        List result = queryFactory.select(team.name,member.age.avg())
                .from(member).join(member.team,team).groupBy(team.name).fetch();

        Tuple teamA = result.get(0);
        Tuple teamB = result.get(1);
        assertThat(teamA.get(team.name)).isEqualTo("teamA");
        assertThat(teamA.get(member.age.avg())).isEqualTo(15);
        assertThat(teamB.get(team.name)).isEqualTo("teamB");
        assertThat(teamB.get(member.age.avg())).isEqualTo(35);
    }

그룹화의 결과를 제한하려면 Having 사용

조인 - 기본 조인

join(조인대상, 별칭으로 사용할 Q 타입)

기본조인

@Test
    void join(){
        Listresult= queryFactory.select(member).from(member)
                .groupBy(member.team,team).where(team.name.eq("teamA")).fetch();

        assertThat(result).extracting("username").containsExactly("member1","member2");
    }

join(),innerJoin(): 내부조인
leftJoin: left 외부 조인
rightJoin(); right 외부 조인

세타조인

 @Test
    void setterJoin(){
        em.persist(new Member("teamA"));
        em.persist(new Member("teamB"));
        List result = queryFactory.select(member).from(member, team).where(member.username.eq(team.name)).fetch();

        assertThat(result).extracting("username").containsExactly("teamA","teamB");
    }

연관관계가 없는 필드로 조인
from 절에 여러 엔터티를 선택해서 세타 조인

조인 - ON 절

@Test
    void join_on_filterring(){
        List result = queryFactory.select(member,team).from(member)
                .leftJoin(member.team,team).on(team.name.eq("teamA")).fetch();

        for(Tuple tuple : result){
            System.out.println("tuple : "+tuple);
        }
    }

회원은 모두 조회하면서 팀 이름이 teamA인 팀만 조인

연관관계 없는 조인

 @Test
    void join_on_no_realation(){
        em.persist(new Member("teamA"));
        em.persist(new Member("teamB"));
        List result = queryFactory.select(member,team).from(member)
                .leftJoin(member.team,team).on(member.username.eq("teamA")).fetch();

        for(Tuple tuple : result){
            System.out.println("tuple : "+tuple);
        }
    }

주의: 문법을 잘 봐야 한다 leftJoin() 부분에 일반 조인과 다르게 엔터티 하나만 들어감

조인 - 페치조인

 @Test
    void fetchJoin(){
        em.flush();
        em.clear();
        Member findMember = queryFactory.selectFrom(member).join(member.team,team).fetchJoin().where(member.username.eq("member1"))
                .fetchOne();
        boolean loaded = emf.getPersistenceUnitUtil().isLoaded(findMember.getTeam());

    }

일반조인을 사용하면 사용하지 않는 엔터티인 Team까지 조회하지 않음
페치 조인을 사용하면 Team까지 한꺼번에 가져옴

서브 쿼리

예시 1

 @Test
    void subQuery(){
        QMember qmember= new QMember("memberSub");
        List result = queryFactory.select(member).from(member)
                        .where(member.age.eq(JPAExpressions.select(qmember.age.max())
                                .from(qmember))).fetch();
        assertThat(result).extracting("age").containsExactly(40);
    }

나이가 가장많은 회원 조회
JPAExpressions 사용

*예시 2 *

@Test
    void subQueryGoe(){
        QMember memberSub =new QMember("memberSub");
        List result = queryFactory.selectFrom(member).where(member.age.goe(
                JPAExpressions.select(memberSub.age.avg())
                        .from(memberSub)
        )).fetch();
        assertThat(result).extracting("age").containsExactly(30,40);
    }

나이가 전체 회원의 평균 이상인 사람

In 서브 쿼리

 @Test
    void subQueryIn(){
        QMember memberSub =new QMember("memberSub");
        List result = queryFactory.selectFrom(member)
                .where(member.age.in(
                        JPAExpressions.select(memberSub.age).from(memberSub)
                                .where(memberSub.age.gt(10))
                )).fetch();
        assertThat(result).extracting("age").containsExactly(20,30,40);
    }

CASE문

단순한 조건

 @Test
    void basicCase(){
        List result =queryFactory.select(member.age
                        .when(10).then("10살")
                        .when(20).then("20살")
                        .otherwise("기타"))
                .from(member)
                .fetch();

        for(String str : result){
            System.out.println("s =" +str);
        }

    }

복잡한 조건

@Test
    void complexCase(){
        List result = queryFactory.select(new CaseBuilder()
                        .when(member.age.between(0, 20)).then("0~20살")
                        .when(member.age.between(21, 30)).then("21~30살")
                        .otherwise("기타"))
                .from(member)
                .fetch();
        for(String str : result){
            System.out.println("s =" +str);
        }
    }

orderBy에서 Case문 함께 사용하기

0~30살이 아닌 사람을 가장 먼저 출력
0~20살 출력
21~30살 출력

NumberExpressions rankPath= new CaseBuilder();
                    .when(member.age.between(0,20)).then(2)
                    .when(member.age.between(21,30)).then(1)
                    .otherwise(3);

List result = queryFactory
                   .select(member.username, member.age, rankPath)
                   .from(member)
                   .orderBy(rankPath.desc())
                   .fetch();

 for (Tuple tuple : result) {
     String username = tuple.get(member.username);
     Integer age = tuple.get(member.age);
     Integer rank = tuple.get(rankPath);
     System.out.println("username = " + username + " age = " + age + " rank = " +rank);

상수 더하기 -concat/constant

 @Test
    void constant(){
        List result = queryFactory.select(member.username, Expressions.constant("A"))
                .from(member).fetch();
        for(Tuple tuple : result){
            System.out.println("tuple : "+tuple);
        }
    }

    @Test
    void concat(){
        List result = queryFactory.select(member.username.concat("_").concat(member.age.stringValue())).from(member).where(member.username.eq("member1")).fetch();

        for(String s: result){
            System.out.println("s =" +s);
        }
    }

출처: https://www.inflearn.com/course/querydsl-%EC%8B%A4%EC%A0%84

객체지향 쿼리 언어(JPQL)

Tue, 11 Mar 2025 03:44:26 GMT

JPQL이란?

JPA 쿼리방법

JPQL
QueryDSL

JPQL

JPA를 사용하면 엔터티 객체를 중심으로 개발
검색을 할 때 테이블이 아닌 엔터티 객체를 대상으로 검색
모든 DB 데이터를 객체로 변환해서 검색하는 것은 불가능
필요한 데이터만 불러오려면 결국 검색 조건이 포함된 SQL이 필요
JPA는 SQL을 추상화한 JPQL이라는 객체 지향 쿼리 언어 제공

예시

String jpql = "select m from Member m where m.age > 18";
List result= em.createQuery(jpql,Member.class).getResultList();

실행된 쿼리

select
m.id as id,
m.age as age,
m.USERNAME as USERNAME,
m.TEAM_ID as TEAM_ID
from
Member m
where
m.age>18

Criteria*
문자가 아닌 자바 코드로 JPQL을 작성할 수 있음
JPQL 빌더 역할
단점은 너무 복잡하고 실용성이 없음

QureyDSL

문자가 아닌 자바코드로 JPQL을 작성할 수 있음
JPQL 빌더 역할
컴파일 시점에서 문법 오류를 찾을 수 있음
동적쿼리 작성시 편리함
단순하고 쉬움

예시

JPAFactoryQuery query = new JPAQueryFactory(em);
QMember m= QMember.member;
List list= query.selectFrom(m).where(m.age.gt(18))
                  .orderBy(m.name.desc()).fetch();

JPQL 문법

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

select m from Member as m where m.age>18
엔터티와 속성은 대소문자를 구분함
JPQL 키워드는 대소문자 구분 x
별칭은 필수 as는 생략 가능

집합과 정렬

select
  COUNT(m), //회원수
  SUM(m.age), //나이 합
  AVG(m.age), //평균 나이
  MAX(m.age), //최대 나이
  MIN(m.age) //최소 나이
 from Member m

group by,Having
order by

TypedQuery/Query

TypedQuery: 반환 타입이 명확할 때 사용

TypedQuery query =
em.createQuery("SELECT m FROM Member m", Member.class);

Query: 반환 타입이 명확하지 않을 떄 사용

Query query =
em.createQuery("SELECT m.username, m.age from Member m");

*결과 조회 API *

query.getResultList(): 결과가 하나 이상일때 리스트 반환
- 결과가 없으면 빈 리스트 반환
query.getSingleResult(): 결과가 정확히 하나, 단일 객체 반환

파라미터 바인딩 - 이름/위치 기준

SELECT m FROM Member m where m.username=:username
query.setParameter("username", usernameParam);

SELECT m FROM Member m where m.username=?1
query.setParameter(1, usernameParam);

프로젝션

select절에 조회할 대상을 지정
프로젝션 대상: 엔터티, 임베디드 타입, 스칼라 타입
select m.username,m.age From Member m
단순값을 바로 DTO로 조회
- select new jpaBook.jpql.UserDto(m.username,m.age) from Member m
- 패키지 명을 포함한 전체 클래스 명 입력
- 순서와 타입이 일치하는 생성자 필요

페이징 API

setFirstResult(int str): 조회시작 위치 (0부터 시작)
setMaxResults(int max):조회할 데이터 수

예시

String jpql = "select m from Member m order by m.name desc";
List resultList = em.createQuery(jpql, Member.class)
.setFirstResult(10)
.setMaxResults(20)
.getResultList();

조인

내부조인: select m from Member m Join m.team t
외부조인: select m from Member m outer Join m.team t
세타조인: select count(m) from Member m ,Team t where m.username=t.username
on절을 활용한 조인
- 조인대상 필터링
  - 예시(회원과 팀을 조인하면서 팀이름이 A인 팀만 조회)
  SELECT m, t FROM Member m LEFT JOIN m.team t on t.name = 'A'
- 연관관계 없는 엔터티 외부 조인
  - 예시(회원 이름과 팀의 이름이 같은 대상 외부 조인)
  SELECT m, t FROM Member m LEFT JOIN Team t on m.username = t.name

서브쿼리

나이가 평균보다 많은 회원
```
select m from Member m
where m.age > (select avg(m2.age) from Member m2)
- 한건이라도 주문한 고객
```
select m from Member m where (select count(o) from Order o where m=o.member) > 0

서브쿼리 지원 함수
[NOT] EXISTS(subquery): 서브쿼리에 결과가 존재하면 참
- ALL/ANY/SOME
- ALL 모두 만족하면 참
- ANY,SOME : 같은 의미, 조건을 하나라도 만족하면 참
[NOT] IN(subquery): 서브쿼리의 결과중 하나라도 같은 것이 있으면 참
예제
- 팀 A 소속인 회원
  
  select m from Member m where exists (select t from m.team t where t.name = ‘팀A')
- 전체 상품 각각의 재고보다 주문량이 많은 주문들
```
 select o from Order o
```
  where o.orderAmount > ALL (select p.stockAmount from Product p)
- 어떤 팀이든 팀에 소속된 회원
```
        select m from Member m
```
  where m.team = ANY (select t from Team t)

서브 쿼리의 한계
- JPA는 WHERE HAVING 절에서만 서브 쿼리 사용 가능
- FROM 절의 서브쿼리는 현재 JPQL에서 불가능

JPQL 기본함수

CONCAT
SUBSTRING
TRIM
LOWER,UPPER
LENGTH
LOCATE
ABS, SQRT, MOD
SIZE, INDEX

경로 표현식

.을 찍어 객체 그래프를 탐색하는 것
용어정리
- 상태필드: 단순히 값을 저장하기 위한 필드
- 연관필드: 연관관계를 위한 필드

경로표현식 특징

상태필드 : 경로탐색의 끝, 탐색 x
단일값 연관 경로: 묵시적 내부 조인 발생, 탐색 0

컬렉션 값 연관 경로: 묵시적 내부 조인 발생 , 탐색 X

단일 값 연관 경로 탐색 예시

JPQL:select o.member from Order o
SQL: select m.* 
from Orders o
inner join Member m on o.member_id = m.id

명시적/묵시적 조인

select m from Member m join m.team t (명시적: join 키워드 직접 사용)
select m.team from Member m (묵시적: 경로 표현식에 의해 묵시적으로 SQL 조인발생)

경로 표현식 - 예제

  select o.member.team from Order o (성공)
select t.members from Team (성공)
select t.members.username from Team t (실패)
select m.username from Team t join t.members m (성공)

JPQL: 패치조인

SQL 조인 종류 x
JPQL에서 성능 최적화를 위해 제공하는 기능
연관된 엔터티나 컬렉션을 SQL 한번에 함께 조회하는 기능
join fetch 명령어 사용
- 패치조인 예시
  
  select m from Member m join fetch m.team (JPQL) select M.,T. from Member m inner join Team t on m.team_id=t.id (SQL)
- 회원을 조회하면서 연관된 팀도 함께 조회
- 패치조인과 일반 조인 실행시 차이점은 연관된 엔터티를 함께 조회하지 않는다는 것이다
  
  select t from Team t join t.members m where t.name='팀A'(JPQL) select T.* from Team t inner join Member m on t.id = m.team_id (SQL)

패치조인의 특징/한계

패치 조인대상에는 별칭을 줄 수 없다
둘 이상의 컬렉션은 패치 조인 x
컬렉션을 페치조인하면 페이징 API를 사용 할 수 없다
엔터티에 직접 적용하는 글로벌 로딩 전략보다 우선시 됨(FetchType.LAZY)

다형성 쿼리

조회대상을 특정 자식으로 한정하는 TYPE

[JPQL]
select i from Item i
where type(i) IN (Book, Movie)

[SQL] select i from i where i.DTYPE in (‘B’, ‘M’)






# 엔터티 직접 사용

- JPQL에서 엔터티를 직접 사용하면 SQL에서 해당 엔터티의 기본값을 사용

[JPQL] select count(m.id) from Member m select count(m) from Member m

[SQL] select count(m.id) as cnt from Member m

- 엔터티를 파라미터로 전달

String jpql = “select m from Member m where m = :member”; List resultList = em.createQuery(jpql) .setParameter("mem


- 식별자를 직접 전달

String jpql = “select m from Member m where m.id = :memberId”; List resultList = em.createQuery(jpql) .setParameter("memberId", memberId).getResultList();


- 실행된 SQL

select m.* from Member m where m.id=?






# Named 쿼리

- 미리 정의해서 이름을 부여해두고 사용하는 JPQL
- 정적 쿼리
- 에노테이션 또는 xml에 정의
- 에플리케이션 로딩 시점에 초기화 후 재사용
- 애플리케이션 로딩 시점에 쿼리를 검증

@Entity @NamedQuery( name = "Member.findByUsername", query="select m from Member m where m.username = :username") public class Member { ... }

List resultList = em.createNamedQuery("Member.findByUsername", Member.class) .setParameter("username", "회원1").getResultList();


**xml 정의(src/META-INF/...xml)**


    
        
          
    

    select count(m) from Member m

``` - xml이 항상 우선권을 가짐 - 운영환경에 따라 다른 xml을 배포 가능

벌크 연산

JPA 변경 감지로 순식간에 많은 양의 쿼리가 나갈수 있다
- 재고가 10개 미만인 상품을 리스트로 조회
  - 상품 엔터티 가격 10% 증가
- 트랜잭션 커밋 시점에 변경감지 동작
변경된 데이터가 100건이면 100번의 UPDATE 쿼리 실행

String qlString = "update Product p " +
"set p.price = p.price * 1.1 " +
"where p.stockAmount < :stockAmount";
int resultCount = em.createQuery(qlString)
.setParameter("stoc

executeUpdate(): 쿼리 한번으로 여러 테이블 로우 변경
벌크 연산은 영속성 컨텍스트를 무시하고 데이터베이스에 직접 쿼리
- 벌크 연산을 먼저 수행
- 벌크 연산 수행 후 영속성 컨텍스트 초기화

출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

프로젝트로 정리하는 리액트(3)

Mon, 10 Mar 2025 07:11:23 GMT

조회/삭제 기능 구현

Diary Page

const Diary =()=>{
    const nav=useNavigate();
    const param = useParams();
    const {onDelete}= useContext(DiaryDispatchContext);

    const data = useContext(DiaryStateContext);
    console.log(data);
    const dataR = data.filter((item)=> String(item.id)===String(param.id));
    const emotionId=dataR[0].emotionId;
    const onClick=()=>{
        if(confirm('삭제하시기를 원합니까?')){
            onDelete(Number(param.id));
            alert('삭제가 완료되었습니다');
            nav('/',{replace:true});
        }
    }
    // console.log(dataR);
    return (
        
             nav(-1)}>} rightChild={} >
            
                
            
            
                
            
        
    )
}

export default Diary;

header 부분은 새 일기장 만들기와 동일하게 구축함과 동시에 왼쪽 버튼을 클릭하면 home으로 오른쪽 버튼을 클릭하면 편집하는 페이지로 이동하게 만듦
사용자가 작성한 일기장의 내용은 View 컴포넌트에서 처리하게 만듦
이때 전달한 데이터는 감정아이디와 파라미터로 받은 id로 찾은 데이터를 전달
아래 삭제하기 버튼을 누르면 useContext로 받은 onDelete 함수를 이용해 삭제되는 기능 구현

보완점

const emotionItem= emotionList.find((item)=> String(item.emotionId)===String(emotionId));

리스트에서 굳이 맵이나 필터를 사용하지말고 find 함수를 이용하여 찾자

const useDiary=(id)=>{
    const nav=useNavigate();
    const data= useContext(DiaryStateContext);
    const [curDiaryItem,setCurDiaryItem] = useState();
    useEffect(()=>{
        const currentDiaryItem= data.find((item)=> String(item.id)===String(id));
        if(!currentDiaryItem){
            window.alert('존재하지않는 일기입니다');
            nav('/',{replace:true});
        }
        setCurDiaryItem(currentDiaryItem);
    },[id]);

    return curDiaryItem;
}

export default useDiary;

별도의 후크파일을 만들어 만약 찾고자 하는 일기장 페이지가 없으면 미리 생성해 놓은 후크를 이용하여 null 데이터 처리에 신경쓰자

View Component

const View=({emotionId,dataR})=>{
    const list = emotionList;
    const data = list.filter((item)=> String(item.emotionId)===String(emotionId));
    const emotionName = data[0].emotionName;
    const date=getStringedDate(dataR[0].createdDate);
    console.log(dataR[0].createdDate);
    return(
        
            
                오늘의 날짜
                
            
            
            
                
            

        
    )
}

export default View

찾은 데이터의 정보를 뿌리는 역할을 맡은 View 컴포넌트이다
주의점은 input,textarea에서 readonly속성을 넣지 않으면 계속 오류가 뜬다
이 이유는 이전까지는 온 체인지 핸들러로 처리하거나 값을 입력받았는데 지금은 값입력을 받으면 안되기 때문이다

프록시와 연관관계

Sun, 09 Mar 2025 06:45:08 GMT

프록시

프록시 기초

em,getReference(Member.class,memberId): 데이터베이스 조회를 미루는 가짜 엔터티 객체 조회
특징
- 실제 클래스를 상속 받아서 만들어짐
- 실제 클래스와 모습이 똑같음
- 이론상 진짜 객체인지 프록시 객체인지 구분하지 않고 사용하면 됨
- 프록시 객체는 진짜 객체의 참조값을 보관
- 프록시 객체를 호출하면 프록시 객체는 실제 객체의 메서드 호출
- 프록시 객체는 처음 사용할 때 한번만 초기화
- 초기화할때 프록시 객체가 실제 엔터티로 바뀌는 것은 아님, 초기화 되면 프록시 객체를 통해 실제 엔터티에 접근 가능
- 프록시 객체는 원본 엔터티를 상속 받음, 타입 체크시 == 비교가 아닌 instance of로 해야함
- 영속성 컨텍스트에 찾는 엔터티가 이미 존재하면 em.getReference()를 호출해도 실제 엔터티 반환

지연/즉시 로딩

*지연로딩 LAZY *

 @ManyToOne(fetch = FetchType.LAZY) // 이 방법은 프록시객체로 조회히한다
    @JoinColumn(name = "TEAM_ID")
    private Team team;

Team 객체를 LAZY 전략으로 조회

select
        m1_0.id,
        m1_0.city,
        m1_0.street,
        m1_0.zipcode,
        m1_0.EMP_START,
        m1_0.WORK_STREET,
        m1_0.WORK_ZIPCODE,
        m1_0.TEAM_ID,
        m1_0.username 
    from
        Member m1_0 
    where
        m1_0.id=?

Member 객체만 조회하면 Member 테이블만 조회함
지연로딩을 사용해서 Team객체를 프록시로 조회함

Member member3= em.find(Member.class, member.getId());
Team team2= member3.getTeam();
System.out.println(team2.getName());

select
        t1_0.TEAM_ID,
        t1_0.name 
    from
        Team t1_0 
    where
        t1_0.TEAM_ID=?

Team의 메서드를 호출하니 그때서야 Team 테이블에서 값 조회
Member와 Team을 함께 자주 사용하면 즉시 로딩 사용

 @ManyToOne(fetch = FetchType.EAGER) 
 @JoinColumn(name = "TEAM_ID")
 private Team team;

조인 쿼리문이 나가며 동시에 조회됨

    select
        m1_0.id,
        m1_0.city,
        m1_0.street,
        m1_0.zipcode,
        m1_0.EMP_START,
        m1_0.WORK_STREET,
        m1_0.WORK_ZIPCODE,
        t1_0.TEAM_ID,
        t1_0.name,
        m1_0.username 
    from
        Member m1_0 
    left join
        Team t1_0 
            on t1_0.TEAM_ID=m1_0.TEAM_ID 
    where
        m1_0.id=?

하지만 가급적이면 지연로딩을 사용하는 것이 좋다
즉시 로딩은 JPQL에서 N+1 문제를 일으킨다
@ManyToOne,@OneToMany 는 기본이 즉시 로딩이므로 LAZY로 변경해야함

영속성 전이 : CASCADE

특정 엔터테를 영속 상태로 만들 때 연관된 엔터티도 함꼐 영속상태로 만들고 싶을 때 사용
부모엔터티를 저장할 때 자식 엔터티도 함께 저장하는 예시가 있다

 @OneToMany(mappedBy = "parent",cascade = CascadeType.PERSIST,orphanRemoval = true)
    private List childList = new ArrayList<>();

    public void addChild(Child child) {
        childList.add(child);
        child.setParent(this);
    }

부모만 저장함에도 자식도 persist 됨

  Parent parent = new Parent();
  parent.setName("Jack");
 Child child = new Child();
 child.setName("Jackson");
 parent.addChild(child);
em.persist(parent);

영속성 전이는 연관관계를 매핑하는 것과 아무 관련이 없다
엔터티를 영속화 할떄 연관된 엔터티도 함께 영속화 하는 편리함을 제공할 뿐
영속성 전이 종류
- ALL: 모두 적용
- PERSIST: 영속
- REMOVE: 삭제
- MERGE: 병합
- REFRESH
- DETACH

고아 객체

고아 객체 제거: 부모 엔터티와 연관관계가 끊어진 자식엔터티를 자동으로 삭제
orphanRemoval=true

 em.persist(parent);
 Parent find= em.find(Parent.class, parent.getId());
find.getChildList().removeAll(parent.getChildList());

** 발생 쿼리 **

Hibernate: 
    /* delete for hellojpa.Child */delete 
    from
        Child 
    where
        id=?

자식객체 삭제됨

주의

참조가 제거된 엔터티는 다른 곳에서 참조하지않는 고아객체로 보고 삭제하는 기능
참조하는 곳이 하나일때 사용해야함
특정 엔터티가 개인 소유일때 사용
@OneToMany,@OneToOne 만 가능

값 타입

기본값 타입

엔터티 타입
- @Entity로 정의하는 객체
- 데이터가 변해도 식별자로 지속해서 추적 가능
값 타입
- int,Integer,String 처럼 단순히 값으로 사용하는 자바 기본 타입이나 객체
- 식별자가 없고 값만 있어 변경시 추적 불가

값 타입 분류

기본값 타입
- 자바 기본 타입
- 래퍼 클래스
- String
임베디드 타입(복합값 타입)
컬렉션 값 타입

임베디드 타입

새로운 값 타입을 직접 정의 가능
JPA는 임베디드 타입이라함
주로 기본값 타입을 모아서 만들어서 복합값 타입이라고도 함
int, String과 같은 값 타입

사용법
- @Embeddable: 값 타입을 정의하는 곳에 표시
- @Embedded: 값 타입을 사용하는 곳에 표시
- 기본 생성자 필수

-장점

재사용
높은 응집도
Period.isWork()처럼 해당 값 타입만 사용하는 의미있는 메서드를 만들 수 있음
임베디드 타입을 포함한 모든 값 타임은 값타입을 소유한 엔터티의 생명 주기에 의존

임베디드 타입은 엔터티의 값일 뿐이다
임베디드 타입을 사용하기 전과 후에 매핑하는 테이블은 같음

@AttributeOverride : 속성 재정의

한 엔터티에서 값은 값 타입을 사용하면 컬럼 명이 중복됨
@AttributeOverrides,@AttributeOverride를 사용해서 컬럼명 속성을 재정의

@Embeddable
@Setter
@Getter
@NoArgsConstructor
public class Address {
    private String city;
    private String street;
    private String zipcode;
}


@Embedded
@AttributeOverrides({
        @AttributeOverride(name = "city", column = @Column(name = "EMP_START")),
        @AttributeOverride(name = "street", column = @Column(name = "WORK_STREET")),
        @AttributeOverride(name = "zipcode", column = @Column(name = "WORK_ZIPCODE"))
})
private Address homeAddress;

이런 값타입의 문제는 바로 객체 타입이라는 것이다
이로 인해 언제든 누군가가 이 객체 타입을 수정할 수 있어 개발자들은 항상 알수없는 위협에 노출되어있다
이 문제를 해결하기 위해서는 setter를 제거해야한다
우리는 값 타입을 불변 타입으로 만들기 위해 노력해야함
Embeded로 받은 것은 객체이므로 equals로 동등성을 알아내야함

주의

값 타입은 정말 값 타입이라 판단될 때만 사용
엔터티와 값 타입을 혼동해서 엔터티를 값 타입으로 만들면 안됨
식별자가 필요하고 지속해서 값을 추적/변경해야 한다면 그것은 값 타입이 아닌 엔터티로 만들어야한다

프로젝트로 정리하는 리액트(2)

Sun, 09 Mar 2025 01:44:20 GMT

'/new' 새로운 일기 작성 페이지

New 페이지

/new url이 전달되면 해당 페이지로 이동

const New =()=>{
    const {onCreate} = useContext(DiaryDispatchContext);
    const nav = useNavigate();
    const onSubmit=(input)=>{
        onCreate(input.createdDate.getTime(),input.emotionId,input.content);
    }
    return(
        
            {
                nav(-1);
            }}>}>
            
        
    )

}

Header,Editor 컴포넌트로 url 호출 후 새로운 일기장을 작성하기 위한 페이지 만듦
해당 페이지에서는 Header를 사용해 이전페이지로 이동할 수 있게 child에 Button을 넣음

Editor

const emotionList=[
    {
        emotionId:1,
        emotionName:'완전좋음'
    },
    {
        emotionId:2,
        emotionName:'좋음'
    },
    {
        emotionId:3,
        emotionName:'그럭저럭' 
    },
    {
        emotionId:4,
        emotionName:'나쁨'
    },
    {
        emotionId:5,
        emotionName:'끔찍'
    }
];
const getStringedDate=(targetDate)=>{
    let year= targetDate.getFullYear();
    let month= targetDate.getMonth()+1;
    let date= targetDate.getDate();
    if(month<10){
        month=`0${month}`;
    }
    if(date<10){
        date=`0${date}`;
    }
    return `${year}-${month}-${date}`;
}
const Editor=({onSubmit})=>{
    const nav=useNavigate();
    const[input,setInput]=useState({
        createdDate:new Date(),
        emotionId:3,
        content:""
    });

    const onClickSubmit=()=>{
        onSubmit(input);
    }

    const onChangeInput=(e)=>{
        let name=e.target.name;
        let value=e.target.value;
        if(name==='createdDate'){
            value= new Date(value);
        }
        setInput({...input,[name]:value});

    }

    return(
        
            
                오늘의 날짜
                
            
            
                오늘의 감정
                
                    {emotionList.map((item)=> onChangeInput({
                        target:{
                            name:'emotionId',
                            value:item.emotionId
                        }
                    })}> )}
                
            
            
                오늘의 일기
                
            
            
                
                
            
        
    )
}

export default Editor

getStringedData: input값을 변환해서 xxxx-xx-xx 형식이 되게 만듦
onChangeInput: [name]으로 동적으로 객체값을 전달하게 만듦
name은 이벤트 객체의 name값을 가지고 오게 함
감정 정보가 담긴 리스트를 map을 사용해 리스트의 숫자만큼 EmotionItem을 반환하게 함
이때 EmotionItem에서는 리스트로 돌고 있는 감정 아이디와 현재 자신이 작성한 일기장의 감정 아이디가 같은지 여부를 전달하는 isSelected 프롭스를 전달받음
item을 클릭하면 감정 아이디를 해당 item의 감정 아이디로 변경하는 onClick

EmotionItem

const EmotionItem=({emotionId,emotionName,isSelected,onClick})=>{
    console.log(isSelected);
    return(
        
            
            
                {emotionName}
            
        
    )
}

전달 받은 프롭스를 근거로 다른 css를 적용하기 위해 동적으로 className 지정
getEmotionImage를 import하여 감정 아이디에 맞는 이미지 호출

프로젝트로 정리하는 리액트 (1)

Sat, 08 Mar 2025 08:37:19 GMT

create/Update/Delete

import { useState,useReducer,useRef } from 'react'
import './App.css'
import { Routes,Route,Link ,useNavigate} from 'react-router-dom'
import Home from './page/Home'

const mockData=[
  {
    id:1,
    createdDate:new Date('2025-01-08'),
    emotionId:1,
    content:'일번 일기내용'
  },
  {
    id:2,
    createdDate:new Date('2025-01-18'),
    emotionId:2,
    content:'2번 일기내용'
  },
  {
    id:3,
    createdDate:new Date('2025-01-28'),
    emotionId:3,
    content:'3번 일기내용'
  },
]
function reducer(state,action){
  switch(action.type){
      case "CREATE" : return [...state,action.data] ;
      case "UPDATE" : return state.map((item)=>String(item.id)===String(action.data.if)? action.data: item);
      case "DELETE" : return state.filter((item)=> String(item.id)!==String(action.data.id));
      default : return state;
  }
}
function App() {
  const idRef=useRef(3);
  const [count, setCount] = useState(0)
  const [data,dispatch] = useReducer(reducer,mockData);
  const onCreate=(createdDate,emotionId,content)=>{
    dispatch({
      type:"CREATE",
      data:{
        id:idRef.current++,
        createdDate,
        emotionId,
        content
      }
    })
  }

  const onDelete=(id)=>{
    dispatch({
      type:"DELETE",
      data:{
        id
      }
    })
  }

  const onUpdate=(id,createdDate,content,emotionId)=>{
    dispatch({
      type:"UPDATE",
      data:{
        id,
        createdDate,
        emotionId,
        content
      }
    })
  }
  return (
    <>
      
    
  )
}

export default App

경로 설정하기

* : 지정되지 않은 루트로 이동하면 정상적이지 않은 페이지라고 알려주는 페이지로 이동시킴
createContext로 props를 이용하여 부모에서 자식으로 전달이 아닌 어디에서나 접근이 가능하게 만듦
/edit:id : /edit/3과 같은 url로 접근하면 해당 아이디가 가지고 있는 정보를 나타내는 페이지로 이동

주의

Routes를 쓸때는 App이 BrowserRouter로 감싸져 있어야 함

'/' Home page 구축

HomePage 이미지

이렇게 만들기 위해 components 폴더를 만든 후 Header,Button,DiaryList,DiaryItem 컴포넌트를 구현함

Header

const Header=({title,leftChild,rightChild})=>{
    return 
            {leftChild}
            {title}
            {rightChild}
        

}

export default Header

title에는 텍스트 구문 leftChild,rightChild의 경우는 Button 컴포넌트를 상속받음

Button

const Button=({text,type,onClick})=>{
    return   
}

export default Button

버튼의 타입에 따라 다른 css를 적용하기 위해 동적으로 클래스 생성
상속받은 onClick 함수 적용

DiaryList

const DiaryList=({data})=>{

    const nav=useNavigate();
    const [sortType,setSortType]=useState("latest");
    const onChangeSortType=(e)=>{
        setSortType(e.target.value);
    }
    // 원본배열을 수정하면 문제가 생길수있어 새로운 배열로 반환받음
    const getSortedData=()=>{
        return data.toSorted((a,b)=>{
            if(sortType=="oldest"){
                return Number(a.createdDate) -Number(b.createdDate);
            }else{
                return Number(b.createdDate)-Number(a.createdDate);
            }
        })
    }

    const sortedData =getSortedData();
    return <>

    
        
            
            
        
        
            {sortedData.map((item)=>{
                return 
            })}
        
    

    
}

export default DiaryList

상속받은 데이터를 조작하면 문제가 될 수 있어서 함수로 새 데이터를 반환하게 함
최신순 , 오래된순 을 각각 클릭하면 onChangeSortType에서 setSortType으로 타입 조작과 동시에 getSortedData()를 새로 반환
그렇게 정렬한 데이터를 map을 써서 배열을 순환하며 각 데이터를 DiaryItem으로 props형태로 전달

DiaryItem

const DiaryItem=({id,emotionId,createdDate,content})=>{
    const nav=useNavigate();
    return (
        
            nav(`/diary/${id}`)}>
                
            
            nav(`/diary/${id}`)}>
                {new Date(createdDate).toLocaleDateString()}
                
                    {content}
                
            
            
                
            
        
    )

}

export default DiaryItem

getEmtionImage(): 별도의 자바 스크립트 파일로 만들어 emotionId에 따라 다른 이미지 전달
수정버튼이나 이미지를 클릭하면 수정페이지와 상세보기 페이지로 이동

연관관계 매핑

Fri, 07 Mar 2025 08:04:22 GMT

단방향 연관관계

객체의 참조와 테이블의 외래키 매핑

@Entity
public class Member {
    @Id
    @GeneratedValue
    private Long id;
    private String username;
    private int age;
    @Enumerated(EnumType.STRING)
    private MemberType type;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name="TEAM_ID")
    private Team team;

    public void createMember(Team team) {
        this.team = team;
        team.getMembers().add(this);

    }

    @Enumerated(EnumType.STRING)
    private MemberType memberType;
 }

객체지향 모델링

Team team = new Team(); 
team.setName("TeamA"); 
em.persist(team); 
 
//회원 저장 
Member member = new Member(); 
member.setName("member1"); 
member.setTeam(team); //단방향 연관관계 설정, 참조 저장 
em.persist(member);

객체 그래프 탐색 및 수정

//조회 
Member findMember = em.find(Member.class, member.getId());
//참조를 사용해서 연관관계 조회 
Team findTeam = findMember.getTeam();

// 새로운 팀B 
Team teamB = new Team(); 
teamB.setName("TeamB"); 
em.persist(teamB); 
 
// 회원1에 새로운 팀B 설정 
member.setTeam(teamB);

양방향 연관관계와 연관관계의 주인

양방향 매핑(팀 엔터티에 @OneToMany 추가)

@Entity
@Setter
@Getter
public class Team {
    @Id
    @GeneratedValue
    private Long id;
    private String name;

    @BatchSize(size = 100)
    @OneToMany(mappedBy = "team")
    private Listmembers = new ArrayList<>();
}

연관관계의 주인

객체의 두 관계 중 하나를 연관관계의 주인으로 지정
연관관계의 주인만이 외래키를 관리
주인이 아닌 쪽은 읽기만 가능하고 수정을 불가능
주인이 아니면 mappedBy 속성으로 주인 지정
양방향 연관관계에서 주인은 외래키가 있는 다(여기서는 Member) 쪽에 설정하는 것이 좋다

다대일 단방향/ 양방향

단방향

가장 많이 사용하는 연관관계
다대일의 반대는 일대다

양방향

외래키가 있는 쪽이 연관관계의 주인
양쪽을 서로 참고하도록 개발

일대다 단방향

일대다 단방향

일대다 단방향은 일대다에서 일이 연관관계의 주인
테이블 일대다 관계에서는 항상 다 쪽에 외래키가 있음
@JoinColumn을 사용하지 않으면 조인테이블 방식을 사용하여 중간에 테이블을 하나 추가함
단점
- 엔터티가 관리하는 외래키가 다른 테이블에 있음
- 연관관계 관리를 위해 추가로 UPDATE SQL을 실행
- 일대다 단방향 보다는 다대일 양방향을 권장

일대일 관계

주 테이블이나 대상 테이블 중에 외래키 선택 가능
다대일 단방향 매핑과 유사
일대일 양방향 매핑에서는 외래키가 있는 곳이 다대일과 마찬가지로 연관관계의 주인이다
반대편은 mappedBy 적용

다대다 관계

무조건 일대다, 다대일 관계로 다시 나눠야함
편리해 보이지만 실무에서 사용 x

상속관계 매핑

관계형 데이터베이스는 상속이란 개념이 없다
객체의 상속과 구조가 DB의 슈퍼타입 서브타입 관계를 매핑
- 각각 테이블로 변환 => 조인 전략
- 통합 테이블로 변환 => 단일 테이블 전략
- 서브타입 테이블로 변환 => 구현 클래스마다 테이블 전략

주요 에노테이션

@Inheritance(strategy=InheritanceType.xxx)
- Joined: 조인 전략
- Single Table: 단일 테이블 전략
- Table_Per_class: 구현 클래스마다 전략
@DiscriminatorColumn(name="DTYPE")
@DiscriminatorValue("XXX")

조인 전략

장점
- 테이블 정규화
- 외래 키 참조 무결성 제약조건 활용 가능
- 저장공간 효율화
단점
- 조회시 조인을 너무 많이 사용
- 조회 쿼리의 복잡도
- 데이터 저장시 INSERT 쿼리를 두번 호출

단일 테이블 전략

장점
- 조인이 필요 없으므로 일반적으로 조회 성능이 빠름
- 조회 쿼리가 단순함
단점
- 자식 엔터티가 매핑한 컬럼은 모두 null 허용
- 단일테이블에 모든 것을 저장하므로 테이블이 커질수 있다 상황에 따라 오히려 느려질 가능성이 있다

구현 클래스마다 전략

이 전략은 가급적이면 사용하지 않는것이 좋다
장점
- 서브 타입을 명확하게 구분해서 처리할 때 효과적
- not null 제약조건 사용 가능
단점
- 여러 자식 테이블을 함께 조회할 때 성능이 느림
- 자식 테이블을 통합해서 쿼리하기 어려움

상속 매핑 예시

@Entity
@Setter
@Getter
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@DiscriminatorColumn
public abstract class Item {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private int price;
}
@Entity
@Setter
@Getter
@ToString
@DiscriminatorValue("M")
public class Movie extends Item{
    private String director;
    private String actor;
}

@MappedSuperclass

공통 매핑 정보가 필요할 때 사용
테이블과 관계 없고 단군히 엔터티가 공통으로 사용하는 매핑정보를 모으는 역할
주로 등록일, 수정일, 등록자, 수정자 같은 전체 엔터티에서 공통으로 적용하는 정보를 모을 때 사용
사용 예시

BaseEntity Test

@MappedSuperclass
@Setter
@Getter
public class BaseEntity {
    @Column(name="created_by")
    private String createdBy;
    private LocalDateTime createdTime;
    private String lastModifiedBy;
    private LocalDateTime lastModifiedDate;
}


@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class Test extends BaseEntity{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    @Column
    private String name;


}

실행 결과 테스트 테이블

JPA의 시작

Thu, 06 Mar 2025 05:23:32 GMT

JPA의 동작

@Entity: JPA가 관리할 객체
@Id: 데이터베이스 PK와 매칭
회원 등록, 수정 , 삭제, 수정 ,단건 조회 기능

JPQL

JPA를 사용하면 엔터티 객체를 중심으로 개발
검색을 할 때도 테이블이 아닌 엔터티 객체를 대상으로 검색
모든 데이터베이스 데이터를 객체로 변환하여 검색하는 것은 불가능
SQL을 추상화한 JPQL이라는 객체 지향 쿼리언어 제공
JPQL은 엔터티 객체를 대상으로 만들어진 쿼리문

영속성 컨텍스트

영속성 컨텍스트 의미

엔터티를 영구 저장하는 환경이라는 뜻
EntityManger.persist(entity)
영속성 컨텍스트는 논리적인 개념으로 눈에 보이지 x
엔터티 매니저를 통해서 영속성 컨텍스트에 접근

엔터티의 생명주기

비영속: 영속성 컨텍스트와 전혀 관계없는 새로운 상태
- 객체를 막 생성한 상태는 비영속 상태
영속: 영속성 컨텍스트에 의해 관리되는 상태
- 객체를 생성후 저장하면 영속상태
준영속: 영속성 컨텍스트에 저장되었다가 분리된 상태
삭제

영속성 컨텍스트 장점

1차 캐시를 이용
- 객체를 영속상태로 만들면 이후 1차 캐시에서 관리 => em.find(Member.class,"member1")을 실행하면 데이터베이스가 아닌 1차 캐시에서 데이터를 탐색
- 만약 1차 캐시에 없으면 데이터베이스에서 해당 내용을 찾은 후 그 내용을 1차 캐시에 저장
동일성 보장
- == 으로 비교해도 true 값이 나와 동일성을 보장
트랜잭션을 지원하는 쓰기 지연
- em.persist(member) 까지는 INSERT SQL을 데이터베이스에 보내지 않음
- 커밋하는 순간 데이터베이스에 INSERT SQL 전송
변경감지
- 영속 컨텍스트 조회 후 Update라는 쿼리문을 사용하지 않고 영속 엔터티를 수정해도 변경을 감지하여 어플리케이션 내부에서 Update 구문이 전송됨
지연로딩

플러시

영속성 컨텍스트의 변경 내용을 데이터베이스에 반영
쓰기지연 SQL 저장소의 쿼리를 데이터베이스에 전송
em.flush(), transaction.commit(), JPQL 쿼리 실행을 하면 플러시가 호출
플러시는 영속성 컨텍스트를 비우는 것이 아닌 영속성 컨텍스트의 변경사항을 데이터베이스에 동기화 하는 것

준영속 상태로 만드는 법

em.detach(entity)
em.clear()
em.close()

엔터티 매핑

** @Entity**

name
- JPA에서 사용할 엔터티 이름을 지정
- 기본값: 클래스의 이름을 그대로 사용

@Table

name : 매핑할 테이블 이름
schema: 데이터베이스 schema 매핑
- create:기존 테이블 삭제후 다시 생성
- create-drop: create와 같으니 종료시점에 테이블 DROP
- update: 변경분만 반영
- validate: 엔터티와 테이블이 정상 매핑되었는지 확인
- none: 사용하지 않음
unique constraints: DDL 생성시에 유니크 제약조건 생성
- @Column(nullable=false,length=10)

필드와 컬럼 매핑

@Entity
public class Member {
    @Id
    private Long id;

    @Column(name = "name")
    private String username;

    private Integer age;

    @Enumerated(EnumType.STRING)
    private RoleType roleType;

    @Temporal(TemporalType.TIMESTAMP)
    private Date createdDate;

    @Temporal(TemporalType.TIMESTAMP)
    private Date lastModifiedDate;

    @Lob
    private String description;
}

@Column : 컬럼매핑
@Temporal: 날짜타입 매핑
@Enumerated: enum 타입 매핑
@Lob: BLOB,CLOB 매핑
@Transient: 특정 필드를 컬럼에 매핑 x

@Column

name: 필드와 매핑할 테이블의 컬럼이름
insertable/updateable: 등록 변경 가능 여부 (기본값:True)
nullable: null값의 허용여부
unique: 컬럼에 간단히 유니크 제약조건을 걸 때 사용
length: String 에서만 사용

@Enumerated

EnumType.ORDINAL: enum의 순서를 데이터베이스에 저장
EnumType.STRING: enum 이름을 데이터베이스에 저장

@Temporal

날짜 타입을 매핑할 때 사용
LocalDate,LocalDateTime을 사용할 때는 생략 가능

기본키 매핑

기본키 매핑 방법

직접 할당: @Id 사용
자동생성(@GeneratedValue)
- IDENTITY: 데이터베이스에 위임
- SEQUENCE: 데이터베이스 시퀀스 오브젝트 사용
- AUTO: 방언에 따라 자동 지정

IDENTITY 전략

기본키 생성을 데이터베이스에 위임
AUTO_INCREMENT는 데이터베이스에 INSERT SQL을 실행한 이후에 ID 값을 알 수 있음
IDENTITY 전략은 em.persist() 시점에 즉시 INSERT SQL을 실행하고 DB에서 식별자를 조회

데이터 접근 기술 _Querydsl

Thu, 27 Feb 2025 12:10:35 GMT

Querydsl 적용

@Repository
@Transactional
public class JpaItemRepositoryV3 implements ItemRepository {

    private final EntityManager em;
    private final JPAQueryFactory query;

    public JpaItemRepositoryV3(EntityManager em) {
        this.em = em;
        this.query = new JPAQueryFactory(em);
    }

    @Override
    public Item save(Item item) {
        em.persist(item);
        return item;
    }

    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        Item findItem = em.find(Item.class, itemId);
        findItem.setItemName(updateParam.getItemName());
        findItem.setPrice(updateParam.getPrice());
        findItem.setQuantity(updateParam.getQuantity());
    }

    @Override
    public Optional findById(Long id) {
        Item item = em.find(Item.class, id);
        return Optional.ofNullable(item);
    }

    public List findAllOld(ItemSearchCond cond) {

        String itemName = cond.getItemName();
        Integer maxPrice = cond.getMaxPrice();

        QItem item = QItem.item;
        BooleanBuilder builder = new BooleanBuilder();
        if (StringUtils.hasText(itemName)) {
            builder.and(item.itemName.like("%" + itemName + "%"));
        }
        if (maxPrice != null) {
            builder.and(item.price.loe(maxPrice));
        }

        List result = query
                .select(item)
                .from(item)
                .where(builder)
                .fetch();

        return result;
    }

    @Override
    public List findAll(ItemSearchCond cond) {

        String itemName = cond.getItemName();
        Integer maxPrice = cond.getMaxPrice();

        return query
                .select(item)
                .from(item)
                .where(likeItemName(itemName), maxPrice(maxPrice))
                .fetch();
    }

    private BooleanExpression likeItemName(String itemName) {
        if (StringUtils.hasText(itemName)) {
            return item.itemName.like("%" + itemName + "%");
        }
        return null;
    }

    private BooleanExpression maxPrice(Integer maxPrice) {
        if (maxPrice != null) {
            return item.price.loe(maxPrice);
        }
        return null;
    }
}

Querydsl을 사용하려면 JpaQueryFactory가 필요하다
이때 JpaQueryFaactory믐 Jpa 쿼리인 JPQL을 만들기 때문에 EntityManager가 필요
JpaQueryFactory를 빈으로 등록해서 사용 가능

findAll()

 @Override
    public List findAll(ItemSearchCond cond) {

        String itemName = cond.getItemName();
        Integer maxPrice = cond.getMaxPrice();

        return query
                .select(item)
                .from(item)
                .where(likeItemName(itemName), maxPrice(maxPrice))
                .fetch();
    }

QueryDsl에서 where(A,B)에 다양한 조건들을 직접 넣을 수 있다. 이렇게 넣으면 AND조건으로 처리되며 where()에 null값을 넣으면 해당 조건은 무시됨
코드의 재사용성이 높아져 다른 쿼리를 작성할 때 likeItemName , maxPrice 를 이용 할 수 있다

출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

데이터 접근 기술 _ 스프링 JPA

Wed, 26 Feb 2025 11:26:43 GMT

스프링 데이터 JPA 주요기능

공통 인터페이스 기능
- JpaRepository 인터페이스를 통해 기본적인 CRUD 기능 제공
- 공통화 가능한 기능이 거의 모두 포함
쿼리 메서드 기능

JPARepository 사용법

 public interface ItemRepository extends JpaRepository {
 }

JpaRepository 인터페이스를 인터페이스 상속 받고, 제네릭에 관리할 <엔티티, 엔티티ID> 를 주면 된다
JpaRepository가 제공하는 기본 CRUD기능을 모두 사용 가능
JpaRepository만 상속받으면 스ㅡㅍ링 데이터 JPA가 프록시 기술을 사용해서 구현 클래스를 만들어 준다. 그리고 만든 구현 클래스의 인스턴스를 만들어서 스프링 빈으로 등록

쿼리메서드 기능

 public interface MemberRepository extends JpaRepository {
     List findByUsernameAndAgeGreaterThan(String username, int age);
}

스프링 데이터 JPA는 메서드 이름을 분석해서 필요한 JPQL을 만들고 실행해 준다.

JPQL 사용 예시

public interface SpringDataJpaItemRepository extends JpaRepository {

    List findByItemNameLike(String itemName);

    List findByPriceLessThanEqual(Integer price);

    //쿼리 메서드 (아래 메서드와 같은 기능 수행)
    List findByItemNameLikeAndPriceLessThanEqual(String itemName, Integer price);

    //쿼리 직접 실행
    @Query("select i from Item i where i.itemName like :itemName and i.price <= :price")
    List findItems(@Param("itemName") String itemName, @Param("price") Integer price);
}

쿼리메서드 기능 대신에 직접 JPQL을 사용하고 싶을 때는 @Query와 함께 JPQL을 작성하면 도니다. 이때 메서드 이름으로 실행되는 규칙은 무시

스프링 데이터 JPA 적용1

List findByItemNameLike(String itemName);

List findByPriceLessThanEqual(Integer price);

    //쿼리 메서드 (아래 메서드와 같은 기능 수행)
List findByItemNameLikeAndPriceLessThanEqual(String itemName, Integer price);

    //쿼리 직접 실행
@Query("select i from Item i where i.itemName like :itemName and i.price <= :price")
List findItems(@Param("itemName") String itemName, @Param("price") Integer price);

findAll()

모든 아이템을 조회
select i from Item i

findByItemNameLike()

이름조건만 검색했을 때 사용하는 쿼리
select i from Item i where i.name like ?
findByPriceLessThanEqual()*
가격조건만 검색했을 때 사용하는 쿼리
select i from Item i where i.price <= ?

findByItemNameLikeAndPriceLessThanEqual()

이름과 가격조건을 검색했을 때 사용하는 메서드
select i from Item i where i.name like ? and i.price <= ?

쿼리를 직접 사용하려면 @Query 구문을 쓰면된다. 변수를 바인딩 할 때는 @Param("itemName") 와 같이 지정하면 됨

스프링 데이터 JPA 적용 2

@Repository
@Transactional
@RequiredArgsConstructor
public class JpaItemRepositoryV2 implements ItemRepository {

    private final SpringDataJpaItemRepository repository;

    @Override
    public Item save(Item item) {
        return repository.save(item);
    }

    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        Item findItem = repository.findById(itemId).orElseThrow();
        findItem.setItemName(updateParam.getItemName());
        findItem.setPrice(updateParam.getPrice());
        findItem.setQuantity(updateParam.getQuantity());
    }

    @Override
    public Optional findById(Long id) {
        return repository.findById(id);
    }

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

        if (StringUtils.hasText(itemName) && maxPrice != null) {
//            return repository
            .findByItemNameLikeAndPriceLessThanEqual("%" + itemName + "%", maxPrice);
            return repository.findItems("%" + itemName + "%", maxPrice);
        } else if (StringUtils.hasText(itemName)) {
            return repository.findByItemNameLike("%" + itemName + "%");
        } else if (maxPrice != null) {
            return repository.findByPriceLessThanEqual(maxPrice);
        } else {
            return repository.findAll();
        }
    }
}

의존관계와 구조

ItemService는 ItemRepository에 의존하므로 ItemService에서 직접 SpringDataJpaItemRepository을 사용할 수 없음
이를 해결하기 위해 JpaItemRepository2를 ItemRepository 와 SpringDataJpaItemRepository 사이를 맞추 기 위한 어댑터 처럼 사용함

** findAll()**

모든 데이터조회
이름 조회
가격 조회
이름 + 기격 조회

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

        if (StringUtils.hasText(itemName) && maxPrice != null) {
//            return repository
            .findByItemNameLikeAndPriceLessThanEqual("%" + itemName + "%", maxPrice);
            return repository.findItems("%" + itemName + "%", maxPrice);
        } else if (StringUtils.hasText(itemName)) {
            return repository.findByItemNameLike("%" + itemName + "%");
        } else if (maxPrice != null) {
            return repository.findByPriceLessThanEqual(maxPrice);
        } else {
            return repository.findAll();
        }
    }
}

like => % + itemName + % 이 부분을 주의하자
그냥 itemName이름을 넣으면 x

출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

데이터 접근 기술 _ JPA

Tue, 25 Feb 2025 09:57:09 GMT

JPA 시작

JPA는 ORM 데이터 접근 기술을 제공

JPA 설정

spring-boot-starter-data-jpa 라이브러리를 사용하면 JPA와 스프링 데이터 JPA를 스프링 부트와 통합하고 설정도 간단히 할 수 있다

application.properties

 logging.level.org.hibernate.SQL=DEBUG
 logging.level.org.hibernate.orm.jdbc.bind=TRACE

다음과 같이 로드를 설정해야 logger를 통해 sql이 출력됨

JPA 적용 1
Item*

 @Data
 @Entity
 public class Item {
     @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
     private Long id;
     @Column(name = "item_name", length = 10)
     private String itemName;
     private Integer price;
     private Integer quantity;

    public Item() {

    }

    public Item(String itemName, Integer price, Integer quantity) {
        this.itemName = itemName;
        this.price = price;
        this.quantity = quantity;
    } 
}

@Entity: JPA가 사용하는 객체라는 뜻이다.
@Id: 테이블의 PK와 해당 필드를 매핑
@GeneratedValue(strategy=GenerationType.Indetity): PK 생성값을 데이터 베이스에서 생성하는 identity 방식 사용 (auto_increment)
- @Column: 객체의 필드를 테이블의 칼럼과 매핑
- name: 객체는 itemName이지만 테이블의 컬럼은item_name이므로 이렇게 매핑
- length=10: varchar(10)
- @Column을 생략하면 필드의 이름을 테이블 컬럼 이름으로 사용

JpaRepositoryV1

@Slf4j
@Repository
@Transactional
public class JpaItemRepository implements ItemRepository {

    private final EntityManager em;

    public JpaItemRepository(EntityManager em) {
        this.em = em;
    }

    @Override
    public Item save(Item item) {
        em.persist(item);
        return item;
    }

    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        Item findItem = em.find(Item.class, itemId);
        findItem.setItemName(updateParam.getItemName());
        findItem.setPrice(updateParam.getPrice());
        findItem.setQuantity(updateParam.getQuantity());
    }

    @Override
    public Optional findById(Long id) {
        Item item = em.find(Item.class, id);
        return Optional.ofNullable(item);
    }

    @Override
    public List findAll(ItemSearchCond cond) {
        String jpql = "selectxxx i from Item i";

        Integer maxPrice = cond.getMaxPrice();
        String itemName = cond.getItemName();

        if (StringUtils.hasText(itemName) || maxPrice != null) {
            jpql += " where";
        }

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

        if (maxPrice != null) {
            if (andFlag) {
                jpql += " and";
            }
            jpql += " i.price <= :maxPrice";
            param.add(maxPrice);
        }

        log.info("jpql={}", jpql);

        TypedQuery query = em.createQuery(jpql, Item.class);
        if (StringUtils.hasText(itemName)) {
            query.setParameter("itemName", itemName);
        }
        if (maxPrice != null) {
            query.setParameter("maxPrice", maxPrice);
        }
        return query.getResultList();
    }
}

private final EntityManager em:생성자를 보면 스프링을 통해 엔터티 매니저라는 것을 주입 받은 것을 확인할 수 있다. JPA의 모든 동작은 엔터티 매니저를 통해서 이루어진다. 엔타티 매니저는 내부에 데이터소스를 가지고 있고 데이터베이스에 접근할 수 있다
@Transactional: JPA의 모든 데이터 변경은 트랜잭션 안에서 이뤄져야 함

JpaConfig

Configuration
public class JpaConfig {

    private final EntityManager em;

    public JpaConfig(EntityManager em) {
        this.em = em;
    }

    @Bean
    public ItemService itemService() {
        return new ItemServiceV1(itemRepository());
    }

    @Bean
    public ItemRepository itemRepository() {
        return new JpaItemRepository(em);
    }

}

JPA 적용 2

** public Item save(Item item) **

public Item save(Item item) {
        em.persist(item);
        return item;
    }

JPA에서 객체를 테이블에 저장할 때 엔터티 매니저가 제공하는 persist() 메서드를 사용하면 됨

실행된 쿼리

insert into item (id, item_name, price, quantity) values (null, ?, ?, ?)
insert into item (id, item_name, price, quantity) values (default, ?, ?, ?)
insert into item (item_name, price, quantity) values (?, ?, ?)

Item entity를 만들때 PK 값 전략을 IDENTITY로 사용했기 때문에 JPA가 이런 쿼리 생성
쿼리 실행 이후에 Item 객체의 id 필드에 데이터베이스가 생성한 PK값이 들어가게 된다

public void update(Long itemId, ItemUpdateDto updateParam)

public void update(Long itemId, ItemUpdateDto updateParam) {
        Item findItem = em.find(Item.class, itemId);
        findItem.setItemName(updateParam.getItemName());
        findItem.setPrice(updateParam.getPrice());
        findItem.setQuantity(updateParam.getQuantity());
    }

실행된 쿼리
```
update item set item_name=?, price=?, quantity=? where id=?
```
- em.update()같은 값을 전혀 호출하지 않았다.
- JPA는 트랜잭션이 커밋되는 시점에 변경된 엔티티 객체가 있는지 확인한다. 특정 엔터티 객체가 변경된 경우에는 UPDATE SQL을 실행

public Optional findById(Long id)

 public Optional findById(Long id) {
        Item item = em.find(Item.class, id);
        return Optional.ofNullable(item);
    }

실행된 쿼리 값

select
item0_.id as id1_0_0_,
item0_.item_name as item_nam2_0_0_,
item0_.price as price3_0_0_,
item0_.quantity as quantity4_0_0_
from item item0_
where item0_.id=?


 



# JPA 적용 3 _ 예외변환

-  `EntityManager` 는 순수한 JPA 기술이고, 스프링과는 관계가 없다. 따라서 엔티티 매니저는 예외가 발생하면 JPA 관련 예외를 발생시킨다.
- JPA는 `PersistenceException` 과 그 하위 예외를 발생시킨다.
- 추가로 JPA는 `IllegalStateException` , `IllegalArgumentException` 을 발생시킬 수 있다. 그렇다면 JPA 예외를 스프링 예외 추상화( `DataAccessException` )로 어떻게 변환할 수 있을까?
- 비밀은 바로 `@Repository` 에 있다.

 ![](https://velog.velcdn.com/images/java_dong/post/e354bb3c-b486-488d-80c9-6da50782b885/image.png)


 





 출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

데이터베이스 연결 테스트

Tue, 25 Feb 2025 07:42:19 GMT

데이터베이스 연동_ main_application.properties

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

데이터베이스 연동_test_application.properties

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

@SpringbootTest

@SpringbootTest은 @SpringbootApplication을 찾아서 설정으로 사용

테스트와 데이터베이스 분리

H2 데이터베이스를 용도에 따라 2가지로 구분
- jdbc:h2:tcp://localhost/~/test local에 접근하는 서버 전용 데이터베이스
- jdbc:h2:tcp://localhost/~/testcase test 케이스에서 사용하는 전용 데이터베이스

** 테스트 데이터 롤백 **

테스트가 끝나고 나서 트랜잭션을 강제로 롤백하면 데이터가 깔끔하게 제거된다. 데이터를 이미 저장했는데 중간에 테스트가 실패해서 롤백을 호출하지 못하더라도 상관 없다. 트랜잭션을 커밋하지 않았기 때문에 데이터베이스에 해당 내용이 반영되지 않음

테스트는 각각의 테스트 실행 전 후로 동작하는 @BeforeEach @AfterEach라는 편리한 기능을 제공

테스트에 직접 트랜잭션 추가

@SpringBootTest
 class ItemRepositoryTest {
     @Autowired
     ItemRepository itemRepository;
      //트랜잭션 관련 코드
      @Autowired
      PlatformTransactionManager transactionManager;
      TransactionStatus status;
      @BeforeEach
      void beforeEach() {
      //트랜잭션 시작
             status = transactionManager.getTransaction(new
               DefaultTransactionDefinition());
      }
      @AfterEach
      void afterEach() {
          //MemoryItemRepository 의 경우 제한적으로 사용
          if (itemRepository instanceof MemoryItemRepository) {
                   ((MemoryItemRepository) itemRepository).clearStore();
               }
      //트랜잭션 롤백
               transactionManager.rollback(status);
           }
      //...
}

@BeforeEach: 각각의 테스트 케이스를 실행하기 직전에 호출함 따라서 요기서 트랜잭션을 시작하면 각각의 테스트를 트랜잭션 범위 안에서 실행할 수 있다
@AfterEach: 각각의 테스트 케이스가 완료된 직후에 호출 됨 따라서 여기서 롤백하면 데이터를 트랜잭션 실행 전 상태로 복구가 가능

테스트에서 @Transactional

스프링에서 제공하는 @Transactional 에노테이션은 로직이 성공적으로 수행되면 커밋되도록 동작함
@Transactional을 테스트에서 사용하면 테스트를 트랜잭션 안에서 실행하고 테스트가 끝나면 트랜잭션을 커밋하는 것이 아닌 자동으로 롤백해버림
롤백으로 테스트 검증이 완료된 후에는 데이터가 삭제

강제로 커밋하기_ @Commit @Transactional을 테스트에서 사용하면 롤백이 되어버리기 때문에 데이터가 실제로 저장되었는지 확인하는 것이 어렵다. 실제로 데이터가 직접 저장되는지 여부를 확인하려면 @Commit을 클래스 또는 메서드에 붙이면 롤백대신 커밋이 호출된다. 참고로 @Rollback(value=false)를 사용해도 됨

테스트_임베디드 모드

테스트 케이스를 실행하기 위해서 데이터베이스를 별도로 설치하고 운영하는 것은 상당히 번잡스럽다. 단순히 테스트를 검증할 용도로만 사용하므로 테스트가 끝나면 데이터베이스를 아예 지워버려도 된다.

     @Bean
     @Profile("test")
     public DataSource dataSource() {
        log.info("메모리 데이터베이스 초기화");
          DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("org.h2.Driver");
        dataSource.setUrl("jdbc:h2:mem:db;DB_CLOSE_DELAY=-1");
        dataSource.setUsername("sa");
        dataSource.setPassword("");
        return dataSource;
    }

프로필이 test인 경우에만 해당 데이터베이스를 사용하도록 설정
테스트케이스에서만 이 데이터소스를 스프링 빈으로 등록해서 사용하겠다는 뜻
jdbc:h2:mem:db 을 쓰면 임베디드 모드로 동작하는 데이터베이스를 만들 수 있다

주의

메모리 DB는 애플리케이션이 종료될 때 함께 사라지기 때문에 애플리케이션 실행 시점에 데이터베이스 테이블도 새로 만들어 줘야 함

src/test/resources/schema.sql에 원하는 데이터베이스를 만들면 이 문제가 해결

drop table if exists item CASCADE;
create table item
(
   id        bigint generated by default as identity,
   item_name varchar(10),
   price     integer,
   quantity  integer,
   primary key (id)
);

출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

데이터 접근기술

Sun, 23 Feb 2025 07:08:47 GMT

데이터 접근 기술 종류

적용 데이터 접근 기술

Jdbc Template
MyBatis
JPa, Hibernate
스프링 데이터 Jpa
Querydsl

SQL Mapper

Jdbc Template
MyBatis
ORM 관련 기술*
Jpa, Hibernate
스프링 데이터 JPA
QueryDsl

SqL Mapper 주요 기능

개발자는 SQL만 작성하면 해당 SQl의 결과를 객체로 편리하게 매칭해 준다
JDBC를 직접 사용할 때 발생하는 여러가지 중복을 제거해 주고 기타 개발자에게 여러가지 편리한 기능을 제공해준다

ORM 주요기능

Jdbc Template이나 MyBatis 같은 SQL 을 개발자가 직접 작성해야 하지만 JPA를 사용하면 기본적인 SQL은 JPA가 대신 작성

도메인 분석

Item

 @Data
 public class Item {
     private Long id;
     private String itemName;
     private Integer price;
     private Integer quantity;
     public Item() {
     }
     public Item(String itemName, Integer price, Integer quantity) {
         this.itemName = itemName;
         this.price = price;
         this.quantity = quantity;
    } 
}

ItemRepository 인터페이스

public interface ItemRepository {
     Item save(Item item);
     void update(Long itemId, ItemUpdateDto updateParam);
     Optional findById(Long id);
     List findAll(ItemSearchCond cond);
}

ItemSearchCond

@Data
 public class ItemSearchCond {
     private String itemName;
     private Integer maxPrice;
     public ItemSearchCond() {
     }
     public ItemSearchCond(String itemName, Integer maxPrice) {
         this.itemName = itemName;
         this.maxPrice = maxPrice;
    }
}

검색조건으로 활용됨, 상품명, 최대 가격이 있다. 참고로 상품명의 일부만 포함되어있더라도 검색이 가능해야 함

ItemUpdateDto


 @Data
 public class ItemUpdateDto {
     private String itemName;
     private Integer price;
     private Integer quantity;
     public ItemUpdateDto() {
     }
     public ItemUpdateDto(String itemName, Integer price, Integer quantity) {
         this.itemName = itemName;
         this.price = price;
         this.quantity = quantity;
     }
 }

상품을 수정할 때 사용하는 객체
단순히 데이터를 전달하는 용도로만 사용됨

DTO 전송객체

데이터 전송객체
DTO는 기능은 없고 단순히 데이터를 전달만 하는 용도로 사용되는 객체

ItemRepository 구현체

@Repository
 public class MemoryItemRepository implements ItemRepository {
     private static final Map store = new HashMap<>(); //static
     private static long sequence = 0L; //static
     @Override
     public Item save(Item item) {
         item.setId(++sequence);
         store.put(item.getId(), item);
         return item;
         }
      @Override
      public void update(Long itemId, ItemUpdateDto updateParam) {
          Item findItem = findById(itemId).orElseThrow();
          findItem.setItemName(updateParam.getItemName());
          findItem.setPrice(updateParam.getPrice());
          findItem.setQuantity(updateParam.getQuantity());
      }
      @Override
      public Optional findById(Long id) {
          return Optional.ofNullable(store.get(id));
      }
      @Override
      public List findAll(ItemSearchCond cond) {
          String itemName = cond.getItemName();
          Integer maxPrice = cond.getMaxPrice();
          return store.values().stream().filter(item->{
          if(ObjectUtils.isEmpty(itemName)){
                  return true;
              }
            return item.getPrice()<=maxPrice;

          })
          .collect(Collectors.toList());
      }

    public void clearStore() {
        store.clear();
    }
}

ItemRepository 인터페이스를 구현한 메모리 저장소이다
메모리이기 때문에 자바를 다시 실행하면 기존에 저장된 모든 데이터가 사라짐
save,update,findById는 쉽게 이해할 수 있다
참고로 optional값을 반환하면 값이 존재하지 않으면 ofNullable로 오류가 안나게 할 수 있다
findAll은 ItemSearchCond이라는 검색 조건을 받아서 내부에서 데이터를 검색하는 기능 수행
- itemName이나 maxPrice가 빈값이면 해당 조건 무시
- 값이 있을 때만 해당 조건으로 필터링 기능 수행

서비스 분석

ItemService 인터페이스

public interface ItemService {
     Item save(Item item);
     void update(Long itemId, ItemUpdateDto updateParam);
     Optional findById(Long id);
     List findItems(ItemSearchCond itemSearch);
 }

ItemServiceV1

@Service
@RequiredArgsConstructor
public class ItemServiceV1 implements ItemService {
    private final ItemRepository itemRepository;
    @Override
    public Item save(Item item) {
        return itemRepository.save(item);
    }
    @Override
    public void update(Long itemId, ItemUpdateDto updateParam) {
        itemRepository.update(itemId, updateParam);
    }
    @Override
    public Optional findById(Long id) {
        return itemRepository.findById(id);
    }
    @Override
    public List findItems(ItemSearchCond cond) {
        return itemRepository.findAll(cond);
    }
}

이 구현체는 대부분의 기능을 단순히 저장소에 위임한다

컨트롤러 분석

HomeController

 @Controller
 @RequiredArgsConstructor
 public class HomeController {
     @RequestMapping("/")
     public String home() {
         return "redirect:/items";
     }
}

단순히 홈으로 요청이 왔을 때 items로 이동하는 컨트롤러

ItemController*

@Controller
@RequestMapping("/items")
@RequiredArgsConstructor
public class ItemController {
    private final ItemService itemService;
@GetMapping
    public String items(@ModelAttribute("itemSearch") ItemSearchCond itemSearch,
Model model) {
        List items = itemService.findItems(itemSearch);
       model.addAttribute("items", items);
       return "items";
   }
   @GetMapping("/{itemId}")
   public String item(@PathVariable long itemId, Model model) {
       Item item = itemService.findById(itemId).get();
       model.addAttribute("item", item);
       return "item";
   }
   @GetMapping("/add")
   public String addForm() {
       return "addForm";
   }
   @PostMapping("/add")
   public String addItem(@ModelAttribute Item item, RedirectAttributes
redirectAttributes) {
       Item savedItem = itemService.save(item);
       redirectAttributes.addAttribute("itemId", savedItem.getId());
       redirectAttributes.addAttribute("status", true);
       return "redirect:/items/{itemId}";
   }
   @GetMapping("/{itemId}/edit")
   public String editForm(@PathVariable Long itemId, Model model) {
       Item item = itemService.findById(itemId).get();
       model.addAttribute("item", item);
       return "editForm";
}
   @PostMapping("/{itemId}/edit")
   public String edit(@PathVariable Long itemId, @ModelAttribute ItemUpdateDto
updateParam) {
       itemService.update(itemId, updateParam);
       return "redirect:/items/{itemId}";
   }
}

스프링부트 설정 분석

MemoryConfig

@Configuration
 public class MemoryConfig {
     @Bean
     public ItemService itemService() {
         return new ItemServiceV1(itemRepository());
     }
     @Bean
     public ItemRepository itemRepository() {
         return new MemoryItemRepository();
     }
}

itemServiceV1,MemoryItemRepository를 스프링 빈으로 등록하고 생성자를 통해 의존관계를 주입
구현체를 편리하게 관리하기 위해 수동으로 빈 등록
컨트롤러는 컴포넌트 스캔을 사용

TestDataInit

@Slf4j
@RequiredArgsConstructor
public class TestDataInit {
    private final ItemRepository itemRepository;
/**
* 확인용 초기 데이터 추가 */
    @EventListener(ApplicationReadyEvent.class)
    public void initData() {
        log.info("test data init");
        itemRepository.save(new Item("itemA", 10000, 10));
        itemRepository.save(new Item("itemB", 20000, 20));
    } 
}

애플리케이션을 실행할 때 초기 데이터를 저장
리스트에서 데이터가 잘 나오는지 편리하게 확인할 용도로 사용
@EventListener(ApplicationReadyEvent.class) : 스프링 컨테이너가 완전히 초기화를 띁내놓고 실행 준비가 되었을 때 발생하는 이벤트이다. 스프링이 이 시점에 해당 애너테이션이 붙은 메서드를 호출함

ItemServiceApplication

@Import(MemoryConfig.class)
@SpringBootApplication(scanBasePackages = "hello.itemservice.web")
public class ItemServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ItemServiceApplication.class, args);
    }
    @Bean
    @Profile("local")
    public TestDataInit testDataInit(ItemRepository itemRepository) {
        return new TestDataInit(itemRepository);
    }
}

@Import(MemoryConfig.class) : 앞서 설정한 MemoryConfig를 설정 파일로 사용
scanBasePackages = "hello.itemservice.web" : 여기서는 컨트롤러만 컴포넌트 스캔을 사용하고 나머지는 직접 수동 등록함. 그래서 컴포넌트 스캔 경로를 hello.itemservice.web하위로 설정함
@Profile("local") : 특정 프로필의 경우에만 해당 스프링 빈을 등록. 여기서는 local이라는 이름의 프로필이 사용되는 경우에만 testDataInit이라는 스프링 빈을 등록

프로필 스프링은 로딩 시점에 application.properties의 spring.profiles.active 속성을 읽어서 프로필로 사용함

이 프로필은 다양한 환경에 따라서 다른 설정을 할때 사용하는 정보이다. 예를 들어서 로컬 PC에서는 로컬 PC에 저장된 데이터베이스에 접근해야하고 운영 환경에서는 운영 데이터베이스에 접근해야한다면 서로 설정 정보가 달라야한다. 심지어 환경에 따라서 다른 스프링 빈을 등록할 수 있어야한다. 프로필은 이런 문제를 해결하는데 도움을 준다

/src/main/resources 하위의 application.properties

spring.profiles.active=local

이 위치의 application.properties 는 /src/main 하위의 자바 객체를 실행할 때 (주로 main() ) 동작 하는 스프링 설정이다. spring.profiles.active=local 이라고 하면 스프링은 local 이라는 프로필로 동작한다. 따라서 직전에 설명한 @Profile("local") 가 동작하고, testDataInit 가 스프링 빈으로 등록 된다.

테스트_ ItemRepositoryTest

@SpringBootTest
 class ItemRepositoryTest {
     @Autowired
     ItemRepository itemRepository;

     @AfterEach
     void afterEach() {
//MemoryItemRepository 의 경우 제한적으로 사용
        if (itemRepository instanceof MemoryItemRepository) {
          ((MemoryItemRepository) itemRepository).clearStore();
        }
    }
    @Test
    void save() {
    //given
        Item item = new Item("itemA", 10000, 10);
        //when
        Item savedItem = itemRepository.save(item);
    //then
        Item findItem = itemRepository.findById(item.getId()).get();
        assertThat(findItem).isEqualTo(savedItem);
    }
    @Test
    void updateItem() {
    //given
        Item item = new Item("item1", 10000, 10);
        Item savedItem = itemRepository.save(item);
        Long itemId = savedItem.getId();
    //when
        ItemUpdateDto updateParam = new ItemUpdateDto("item2", 20000, 30);
        itemRepository.update(itemId, updateParam);
    //then
        Item findItem = itemRepository.findById(itemId).get();
        assertThat(findItem.getItemName()).isEqualTo(updateParam.getItemName());
        assertThat(findItem.getPrice()).isEqualTo(updateParam.getPrice());
        assertThat(findItem.getQuantity()).isEqualTo(updateParam.getQuantity());
    }
    @Test
    void findItems() {
    //given
        Item item1 = new Item("itemA-1", 10000, 10);
        Item item2 = new Item("itemA-2", 20000, 20);
        Item item3 = new Item("itemB-1", 30000, 30);
        itemRepository.save(item1);
         itemRepository.save(item2);
        itemRepository.save(item3);
        //둘 다 없음 검증
        test(null, null, item1, item2, item3); 
        test("", null, item1, item2, item3);
        //itemName 검증
        test("itemA", null, item1, item2);
        test("temA", null, item1, item2);
        test("itemB", null, item3);
        //maxPrice 검증
        test(null, 10000, item1);
        //둘 다 있음 검증
        test("itemA", 10000, item1);
    }
    void test(String itemName, Integer maxPrice, Item... items) {
        List result = itemRepository.findAll(new ItemSearchCond(itemName,maxPrice));
        assertThat(result).containsExactly(items);
    } 
}

afterEach() : 테스트는 서로 영향을 주면 안된다. 따라서 각각의 테스트가 끝나고 나면 저장한 데이터를 제거 해야 한다. @AfterEach 는 각각의 테스트의 실행이 끝나는 시점에 호출된다. 여기서는 메모리 저장소를 완전히 삭제해서 다음 테스트에 영향을 주지 않도록 초기화 한다.

출처:https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-2

Node 객체

Sun, 23 Feb 2025 01:09:40 GMT




    
    
    Document


 
    
        html
        css
        자바스크립트
             
                자바스크립트 core
                DOM
                BOM
            
        
      
    






    v




    
    
    Document


    
        html
        css
        자바스크립트
             
                자바스크립트 core
                DOM
                BOM




    
    
    Document


   
        HTML
        CSS
    
    
     
    
        html
        css
        java




    
    
    
    Document


    
    
        content1
    
    
        content2
    

    
        content3
    
    
        content4
    

    
        content3
    
    
        content4
    
    
        source




    
    
    Document
    


    
        HTML
        CSS

Element 객체

Sun, 23 Feb 2025 00:37:41 GMT




    
    
    Document
    


    opentutorials
    opentutorials
    
    
        html
        class
        java
            
                core
                DOM
                BOM

자바스크립트_DOM

Fri, 21 Feb 2025 05:21:21 GMT




    
    
    Document
    


    
    
    
    

        


    두번째 인자는 새창의 이름이다. _self는 스크립트가 실행되는창을의미    

        


    두번째 인자는 새창의 이름이다. _blank는 새창을의미    

    


    창에 이름을 붙일 수 있다 open을 재실행했을때 동일한 이름의 창이있으면 그곳으로 문서가 로드   

    


    창크기 조절하는 세번쨰 인자




    
    
    Document
    


    
        HTML
        CSS
        자바스크립트




    
    
    
    Document


    
        HTML
        CSS
         자바스크립트

스프링으로 예외 / 반복 처리

Thu, 20 Feb 2025 07:21:25 GMT

체크예외와 인터페이스

서비스 계층은 가급적 특정 구현 기술에 의존하지 않고 순수하게 유지하는 것이 좋다. 예를 들어서 서비스가 처리할 수 없는 SQlException에 대한 의존을 제거하려면 어떻게 해야할까?

서비스가 처리할 수 없으므로 리포지토리가 던지는 체크예외인 SQLException을 런타임예외로 전환해서 서비스 계층에 던지자. 이렇게 하면 서비스 계층이 예외를 무시할수 있기 때문에 특정 기술에 의존하는 부분을 제거할 수 있다.

런타임 예외 적용 - 인터페이스

 public interface MemberRepository {
      Member save(Member member);
      Member findById(String memberId);
      void update(String memberId, int money);
      void delete(String memberId);
}

MyDbException 런타임 예외

public class MyDbException extends RuntimeException {
      public MyDbException() {
      }
      public MyDbException(String message) {
          super(message);
    }
      public MyDbException(String message, Throwable cause) {
          super(message, cause);
    }
      public MyDbException(Throwable cause) {
          super(cause);
    }
 }

MemberRepositoryV4_1

@Slf4j
  public class MemberRepositoryV4_1 implements MemberRepository {
      private final DataSource dataSource;
      public MemberRepositoryV4_1(DataSource dataSource) {
          this.dataSource = dataSource;
    }

     @Override
      public Member save(Member member) {
          String sql = "insert into member(member_id, money) values(?, ?)";
          Connection con = null;
          PreparedStatement pstmt = null;
          try {
              con = getConnection();
               pstmt = con.prepareStatement(sql);
               pstmt.setString(1, member.getMemberId());
               pstmt.setInt(2, member.getMoney());
               pstmt.executeUpdate();
              return member;
        } catch (SQLException e) {
            throw new MyDbException(e);
        } finally {
            close(con, pstmt, null);
        }
    }

    @Override
    public void update(String memberId, int money) {
        String sql = "update member set money=? where member_id=?";
        Connection con = null;
           PreparedStatement pstmt = null;
        try {
            con = getConnection();
            pstmt = con.prepareStatement(sql);
            pstmt.setInt(1, money);
            pstmt.setString(2, memberId);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            throw new MyDbException(e);
    }     finally {
            close(con, pstmt, null);
        } 
    }
    .
    .
    .
   private void close(Connection con, Statement stmt, ResultSet rs) {
          JdbcUtils.closeResultSet(rs);
          JdbcUtils.closeStatement(stmt);
          DataSourceUtils.releaseConnection(con, dataSource);
    }
      private Connection getConnection() {
          Connection con = DataSourceUtils.getConnection(dataSource);
          log.info("get connection={} class={}", con, con.getClass());
          return con;
    } 
}

이 코드에서 핵심은 SQLException이라는 체크예외를 MyDbException이라는 런타임 예외로 변환해서 던지는 부분이다

예외변환

catch (SQLException e) {
      throw new MyDbException(e);
}

잘보면 기존 예외를 생성자를 통해서 포함하고 있는 것을 확인할 수 있다. 예외는 원인이 되는 예외를 내부에 포함할 수 있는데 이렇게 해야 원인이되는 기존 예외도 함께 확인 할 수있다

MemberService4

 @Slf4j
  @RequiredArgsConstructor
  public class MemberServiceV4 {
      private final MemberRepository memberRepository;
      @Transactional
      public void accountTransfer(String fromId, String toId, int money) {
          bizLogic(fromId, toId, money);
      }

      private void bizLogic(String fromId, String toId, int money) {
         Member fromMember = memberRepository.findById(fromId);
         Member toMember = memberRepository.findById(toId);
         memberRepository.update(fromId, fromMember.getMoney() - money);
         validation(toMember);
         memberRepository.update(toId, toMember.getMoney() + money);
     }
    private void validation(Member toMember) {
        if (toMember.getMemberId().equals("ex")) {
            throw new IllegalStateException("이체중 예외 발생"); 
            }
    } 
}

이전 버전과 달리 메서드에서 throws SQLException 부분이 제거된 것을 확인할 수 있다

데이터 접근 예외 만들기

데이터베이스 오류에 따라서 특정예외는 복구하고 싶을 수도 있다. 예를 들어 새롭게 회원가입을 시도했는데 기존에 존재하던 ID라서 임의의 숫자를 붙여서 다시 저장될 수 있게 만드는 것이다.

데이터를 DB에 저장할 때 같은 ID가 이미 데이터베이스에 저장되어 있다면 데이터베이스는 오류코드를 반환하고 이 오류 코드를 받은 JDBC 드라이버는 SQLException을 던진다. 그리고 SQLException에는 데이터베이스가 제공하는 errorCode라는 것이 들어있다

SQLException 내부에 들어있는 errorCode 를 활용하면 데이터베이스에서 어떤 문제가 발생했는지 확인할 수 있 다

H2 예시

23505: 키 중복 오류
42000: SQL 문법 오류

서비스 계층에서는 예외 복구를 위해 키 중복 오류를 확인 할 수 있어야한다. 그래야 새로운 ID를 만들어서 다시 저장을 시도할 수 있기 때문이다. 이러한 과정이 예외를 확인해서 복구하는 과정으로 리포지토리는 SQLException을 서비스 계층에 던지고 서비스 계층은 이 예외의 오류코드를 확인해서 키 중복 오류인 경우 새로운 ID를 만들어서 다시 저장하면 된다. 하지만 SQLException에 들어있는 오류코드를 활용하기 위해 SQLException을 서비스 계층으로 던지면 서비스 계층이 JDBC 기술의 의존하게 되면서 서비스 계층의 순수성이 무너진다. 이 문제를 해결하려면 앞서 해던것처럼 예외를 변환해서 던지면 된다.

변환을 위한 예외 생성 - MyDuplicatekeyException

public class MyDuplicateKeyException extends MyDbException {
      public MyDuplicateKeyException() {
      }
      public MyDuplicateKeyException(String message) {
          super(message);
    }
      public MyDuplicateKeyException(String message, Throwable cause) {
          super(message, cause);
    }
      public MyDuplicateKeyException(Throwable cause) {
          super(cause);
    } 
}

기존에 사용했던 MyDbException을 상속받아서 의미있는 계층을 형성한다. 이렇게 하면 데이터베이스 관련 예외라는 계층을 만들 수 있다
이 예외는 데이터 중복 발생시에만 던져야 한다
이 예외는 사용자 정의 예외로 특정기술에 종속되지 않는다

Test 예시

static class Service {
    private final Repository repository;
    public void create(String memberId) {
        try {
            repository.save(new Member(memberId, 0));
            log.info("saveId={}", memberId);
        } catch (MyDuplicateKeyException e) {
            log.info("키 중복, 복구 시도");
            String retryId = generateNewId(memberId);
            log.info("retryId={}", retryId); 
            repository.save(new Member(retryId, 0));
        } catch (MyDbException e) { 
            log.info("데이터 접근 계층 예외", e); 
            throw e;
        } 
    }
    private String generateNewId(String memberId) {
        return memberId + new Random().nextInt(10000);
    }
}

스프링 예외 추상화 이해

스프링은 데이터 접근과 관련된 예외를 추상화해서 제공한다

스프링은 데이터 접근 계층에 대한 수십개의 예외를 정리해서 일관된 예외 계층을 제공
각각의 예외는 특정 기술에 종속적이지 않게 설계됨
JDBC나 JPA를 사용할 때는 예외를 스프링이 제공하는 예외로 변환해주는 역할도 제공
런타임 예외를 상속받아서 스프링이 제공하는 데이터 접근 계층의 모든 예외는 런타임 예외이다

스프링이 제공하는 예외 변환기

@Slf4j
public class SpringExceptionTranslatorTest {
    DataSource dataSource;
    @BeforeEach
    void init() {
        dataSource = new DriverManagerDataSource(URL, USERNAME, PASSWORD);
    }
    @Test
    void sqlExceptionErrorCode() {
        String sql = "select bad grammar";
        try {
            Connection con = dataSource.getConnection();
            PreparedStatement stmt = con.prepareStatement(sql);
            stmt.executeQuery();
        } catch (SQLException e) {
            assertThat(e.getErrorCode()).isEqualTo(42122);
            int errorCode = e.getErrorCode();
            log.info("errorCode={}", errorCode);
            //org.h2.jdbc.JdbcSQLSyntaxErrorException
            log.info("error", e);
        } 
    }
}

기존에 사용했던 데이터베이스 오류 코드 확인

스프링이 제공하는 변환기

  SQLExceptionTranslator exTranslator = new
  SQLErrorCodeSQLExceptionTranslator(dataSource);
  DataAccessException resultEx = exTranslator.translate("select", sql, e);

translate() 메서드의 첫번째 파라미터는 읽을 수 있는 설명이고 두번째는 실행한 sql, 마지막은 발생된 SQLException을 전달하면된다. 이렇게 하면 스프링 데이터 접근 계층의 예외로 변환해서 반환해 준다

  @Test
  void exceptionTranslator() {
      String sql = "select bad grammar";
      try {
          Connection con = dataSource.getConnection();
          PreparedStatement stmt = con.prepareStatement(sql);
          stmt.executeQuery();
      } catch (SQLException e) {
          assertThat(e.getErrorCode()).isEqualTo(42122);
          //org.springframework.jdbc.support.sql-error-codes.xml
          SQLExceptionTranslator exTranslator = new
           SQLErrorCodeSQLExceptionTranslator(dataSource);
          //org.springframework.jdbc.BadSqlGrammarException
          DataAccessException resultEx = exTranslator.translate("select", sql, e);
          log.info("resultEx", resultEx);
            assertThat(resultEx.getClass()).isEqualTo(BadSqlGrammarException.class);
      }
}

이 예제에서 눈에 보이는 타입은 DataAccessException이지만 실제로는 BasSqlGrammarException이 반환됨

스프링 예외 추상화 적용


  @Slf4j
  public class MemberRepositoryV4_2 implements MemberRepository {
      private final DataSource dataSource;
      private final SQLExceptionTranslator exTranslator;

      public MemberRepositoryV4_2(DataSource dataSource) {
          this.dataSource = dataSource;
          this.exTranslator = new
              SQLErrorCodeSQLExceptionTranslator(dataSource);
      }

      @Override
      public Member save(Member member) {
            String sql = "insert into member(member_id, money) values(?, ?)";
            Connection con = null;
            PreparedStatement pstmt = null;
            try {
                con = getConnection();
                pstmt = con.prepareStatement(sql);
                pstmt.setString(1, member.getMemberId());
                pstmt.setInt(2, member.getMoney());
                pstmt.executeUpdate();
                return member;
            } catch (SQLException e) {
                throw exTranslator.translate("save", sql, e);
            } finally {
                close(con, pstmt, null);
        }
    }
    .
    .
    .
}

출처: https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-1

자바의 예외와 DB

Mon, 17 Feb 2025 09:40:06 GMT

예외 계층

Object:예외도 객체이다. 머든 객체의 최상위 부모가 Object이므로 예외의 최상위 부모도Object이다
Throwable:최상위 예외이다. 하위에 Exception,Error가 있다
Error: 메모리 부족이나 심각한 시스템 오류와 같이 에플리케이션에서 복구 불가능한 시스템 예외이다.
Exception:체크 예외
- 에플리케이션 로직에서 사용할 수 있는 실질적인 최상위 예외이다
- Exception과 그 하위 예외는 모두 컴파일러가 체크하는 체크 예외이다. 단 RuntimeException은 이에 해당하지 않는다
RuntimeException:언체크 예외, 런타임 예외
- 컴파일러가 체크하지 않는 예외이다
- RuntimeException과 그 자식 예외는 모두 언체크 예외이다
- RuntimeException의 이름을 따라서 RuntimeException과 그 하위 언체크 예외를 런타임 예외라고 부른다

기본예외

예외에서는 2가지 규칙을 기억하자

예외는 잡아서 처리하거나 던져야 한다
예외를 잡거나 던질 때 지정한 예외뿐만 아니라 그 예외의 자식들도 함께 처리된다
- 예를들어 Exception을 catch로 잡으면 그 하위 예외들도 모두 잡을 수 있다
자바 main() 스레드의 경우 예외 로그를 출력하면서 시스템이 종료
웹 애플리케이션의 경우 여러 사용자의 요청을 처리하기 때문에 하나의 예외 때문에 시스템이 종료되면 안된다. WAS가 해당 예외를 받아서 처리하는데, 주로 사용자에게 개발자가 지정한, 오류 페이지를 보여준다

체크 예외 기본 이해

Exception과 그 하위 예외는 모두 컴파일러가 체크하는 체크예외이며 이때 RuntimeException은 예외로 한다
체크예외는 잡아서 처리하거나 밖으로 던지도록 선언해야한다. 그러지 않으면 컴파일러에서 오류가 발생한다

체크 예외 코드

@Slf4j
  public class CheckedTest {
      @Test
      void checked_catch() {
          Service service = new Service();
          service.callCatch();
      }
      @Test
      void checked_throw() {
          Service service = new Service();
          assertThatThrownBy(() -> service.callThrow())
                  .isInstanceOf(MyCheckedException.class);
}
/**
* Exception을 상속받은 예외는 체크 예외가 된다. */
      static class MyCheckedException extends Exception {
          public MyCheckedException(String message) {
              super(message);
          }
    }

     static class Service {
          Repository repository = new Repository();
/**
* 예외를 잡아서 처리하는 코드 */
      public void callCatch() {
              try {
                  repository.call();
              } catch (MyCheckedException e) {
//예외 처리 로직
                log.info("예외 처리, message={}", e.getMessage(), e); }
             }    
      public void callThrow() throws MyCheckedException {
              repository.call();
            } 
    }
      static class Repository {
          public void call() throws MyCheckedException {
              throw new MyCheckedException("ex");
          }
    } 
}

Exception을 상속받은 예외

  static class MyCheckedException extends Exception {
      public MyCheckedException(String message) {
          super(message);
      }
  }

MyCheckedException는 Exception을 상속받았다. Exception을 상속받으면 체크예외가 됨
RuntimeException을 상속 받으면 언체크 예외가 됨

try~catch 예외처리

  @Test
  void checked_catch() {
      Service service = new Service();
      service.callCatch();
  }

service.callCatch() 에서 예외를 처리했기 때문에 테스트 메서드까지 예외가 올라오지 않는다

public void callCatch() {
      try {
          repository.call();
      } catch (Exception e) {
        //예외 처리 로직 
      }
}

catch에 MyCheckedException의 상위 타입인 Exception을 적어도 MyCheckedException을 잡을 수 있다
catch에 예외를 지정하면 해당 예외와 그 하위 타입 예외를 모두 잡아줌
throws로 예외를 밖으로 던져버리는 전략도 물론 사용가능하다

체크예외의 장단점

체크 예외는 잡아서 처리할수 없을 때 예외를 밖으로 던지는 throws예외를 필수로 선언해야 함. 그렇지 않으면 컴파일 오류가 발생해 장단점이 동시에 존재한다

언체크 예외 기본 이해

언체크 예외는 기본적으로 컴파일러가 체크하지 않는다
언체크 예외는 기본적으로 체크 예외와 동일하지만 차이가 있다면, throws를 선언하지 않고 생략이 가능하다는 점이다

언체크 예외

 static class MyUncheckedException extends RuntimeException {
        public MyUncheckedException(String message) {
            super(message);
        }
}

언체크 예외를 잡아서 처리하는 코드

 try {
      repository.call();
} catch (MyUncheckedException e) { //예외 처리 로직
      log.info("error", e);
  }

언체크 예외를 밖으로 던지는 코드

  public void callThrow() {
      repository.call();
}

언체크 예외는 말그대로 컴파일러가 체크하지않는 예외이기 때문에 throws 선언을 하지 않아도 됨

언체크 예외 장단점

장점: throws 생략 단점: 컴파일러가 체크를 하지 않아 개발자가 누락할 가능성이 있음

체크예외 활용

기본원칙 2가지

기본적으로 런타임 예외를 사용
체크 예외는 비즈니스 로직상 의도적으로 던지는 예외에만 사용
- 이 경우 해당 예외를 잡아서 반드시 처리해야하는 문제일때만 사용해야 함
  - ex) 계좌이체 실패 예외
  - 결제시 포인트 부족 실패 예외

체크예외의 문제점

복구 불가능한 예외
- 대부분의 예외는 복구가 불가능하다. SQLException로 예를 들자면 데이터베이스에 문제가 있어서 발생하는 예외이다. sql상 문법 오류 또는 데이터베이스 서버 다운등의 문제가 발생했을 수 있다. 이런 문제들은 대부분 복구가 불가능하다. 또한 대부분의 서비스나 컨트롤러는 이런 문제를 해결할 수 없다. 따라서 이런 문제들은 일관성있게 공통으로 처리해야 한다. 서블릿 필터, 스프링 인터셉터, 스프링의 ControllerAdvice 를 사용하면 이런 부분을 깔끔하게 공통으로 해결할 수 있다
의존관계에 대한 문제
- 체크 예외의 심각한 문제는 예외에 대한 의존 문제이다. 체크 예외는 대부분 해결 불가능한 오류이므로 throws로 던지면 서비스, 컨트롤러 , 레포지토리들도 해당 예외를 모두 알아야한다. 그래서 불필요한 의존관계가 발생하게된다

이런 문제가 발생하는 걸 막기 위해 throw Exception을 쓸수도 있는데 이는 위험한 결정이다. 사용자가 의도한 모든 오류를 던지기 때문에 어떤 오류가 발생했는지 모르게 될 가능성이 크다

언체크 예외 활용

SQLException 을 런타임 예외인 RuntimeSQLException 으로 변환했다
ConnectException 대신에 RuntimeConnectException 을 사용하도록 바꾸었다
런타임 예외이기 때문에 서비스, 컨트롤러는 해당 예외들을 처리할 수 없다면 별도의 선언 없이 그냥 두면 된다

예외 전환

레포지토리에서 체크 예외인 SqlExcption이 발생하면 런타임 예외인 RuntimeSQLException으로 전환해서 예외를 던진다
- 참고로 이때 기존 예외를 포함해야지 출력시 기존 예외도 함께 확인이 가능하다
NetworkClient 는 단순히 기존 체크 예외를 RuntimeConnectException 이라는 런타임 예외가 발생하 도록 코드를 바꾸었다

복구 불가능한 문제

시스템에서 발생한 예외는 대부분 복구 불가능 예외이다. 런타임 예외를 사용하면 서비스나 컨트롤러가 이런 복구 불가 능한 예외를 신경쓰지 않아도 된다. 물론 이렇게 복구 불가능한 예외는 일관성 있게 공통으로 처리해야 한다

의존관계 처리

런타임 예외는 해당 객체가 처리할 수 없는 예외는 무시하면 된다. 따라서 체크 예외 처럼 예외를 강제로 의존하지 않아 도 된다

기존예외를 포함

 public void call() {
      try {
          runSQL();
      } catch (SQLException e) {

        throw new RuntimeSQLException(e); 
        //기존 예외(e) 포함 
      }
}

기존예외 포함 x

  public void call() {
      try {
          runSQL();
      } catch (SQLException e) {
        throw new RuntimeSQLException(); 
        //기존 예외(e) 제외
      }
}

출처: https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-db-1

java_dong.log

QueryDSL 중급

프로젝션과 결과 반환

프로젝션 결과 DTO 조회

Querydsl 빈 생성

@QueryProjection

동적쿼리

수정/삭제 벌크 연산

프로젝트로 정리하는 리액트(4)

수정 기능

오늘의 날짜

오늘의 감정

오늘의 일기

QueryDSL 시작

예제 도메인 모델

기본 문법

검색조건 쿼리

검색조건 예시

결과조회

정렬

페이징

집합

group by

조인 - 기본 조인

서브 쿼리

CASE문

상수 더하기 -concat/constant

객체지향 쿼리 언어(JPQL)

JPQL이란?

JPQL 문법

경로 표현식

JPQL: 패치조인

다형성 쿼리

벌크 연산

프로젝트로 정리하는 리액트(3)

조회/삭제 기능 구현

Diary Page

View Component

오늘의 날짜

프록시와 연관관계

프록시

지연/즉시 로딩

영속성 전이 : CASCADE

고아 객체

값 타입

기본값 타입

값 타입 분류

임베디드 타입

@AttributeOverride : 속성 재정의

프로젝트로 정리하는 리액트(2)

'/new' 새로운 일기 작성 페이지

오늘의 날짜

오늘의 감정

오늘의 일기

프로젝트로 정리하는 리액트 (1)

create/Update/Delete

경로 설정하기

'/' Home page 구축

연관관계 매핑

단방향 연관관계

양방향 연관관계와 연관관계의 주인

다대일 단방향/ 양방향

일대다 단방향

일대일 관계

다대다 관계

상속관계 매핑

JPA의 시작

JPA의 동작

JPQL

영속성 컨텍스트

엔터티 매핑

기본키 매핑

데이터 접근 기술 _Querydsl

Querydsl 적용

데이터 접근 기술 _ 스프링 JPA

스프링 데이터 JPA 적용1

스프링 데이터 JPA 적용 2

데이터 접근 기술 _ JPA

JPA 시작

JPA 적용 1