world_changer.log

230619_4주차

Mon, 19 Jun 2023 02:58:46 GMT

월요일 (오전)

Tether 에서 usdt 가격은 항상 1달러 (stable coin)

유니스왑, 바이낸스를 통한 시장 프로세스

web3@1.9.0 버전 node 진행 (send가 가능한 버전)

hardhat 배포 실습

etherscan 회원가입 및 api key 발급

hardhat setting

> npm install --save-dev hardhat
> npm install --save -dev @nomicfoundation/hardhat-toolbox
> npx hardhat

Lock.sol 변경

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.9;

// Uncomment this line to use console.log // import "hardhat/console.sol";

contract Lock { uint public a;

function getA() public view returns(uint) {
    return a;
}

function setA(uint _a) public {
    a = _a;
}

}


4. compile
```> npx hardhat compile```

5. deploy.js 변경

const hre = require("hardhat");

async function main() { //contract 변수로 설정 const Contract_A = await hre.ethers.getContractFactory("Lock"); //contract를 deploy하고 const contract_a = await Contract_A.deploy();

await contract_a.deployed();
console.log("Address : ", contract_a.address);

}

main().catch((error) => { console.error(error); process.exitCode = 1; });


6. hardhat.config.js 변경

require("@nomicfoundation/hardhat-toolbox");

const PVK = "개인키"

module.exports = { solidity: "0.8.17", etherscan : { apiKey : "이더스캔 api 키", }, networks : { goerli : { url : https://goerli.infura.io/v3/infura api 키, accounts : [PVK], } } };


7. 배포

// goerli npx hardhat run --network goerli .\scripts\deploy.js

// etherscan verify & publishing


hardhat을 통해서 더 쉽게 verify & publishing이 가능하다.

npx hardhat verify --network goerli {컨트랙트 주소}

![](https://velog.velcdn.com/images/world_changer/post/cca384e1-3ab1-4355-b0a6-2d6e90efd8dc/image.png)

이런식으로 바로 업데이트

# 월요일 (오후)
```Flatten``` 기능
import 되어있는 것들도 전부 한 파일에 담는 것.
(remix 에서는 우클릭 후 flatten 누르면 파일 생성됨)

## hardhat 배포 실습 (constructor 있는)
```npm install @openzeppelin/contracts```

1. erc20_3.sol 생성

// SPDX-License-Identifier: MIT pragma solidity ^0.8.0;

import '@openzeppelin/contracts/token/ERC20/ERC20.sol';

contract ABCToken is ERC20("LikeLion", "LION") { constructor(uint totalSupply) { _mint(msg.sender, totalSupply); }

function MintToken(uint a) public {
    _mint(address(this), a);
}

function decimals() public pure override returns(uint8) {
    return 0;
}

receive() external payable{}

}


2. deploy_erc20_3.js 생성

// scripts 폴더의 deploy.js 파일 수정

const hre = require("hardhat");

async function main() { const LOCK = await hre.ethers.getContractFactory("ABCToken"); const lock = await LOCK.deploy(1234); console.log("LOCK deployed to : ", lock); console.log("LOCK deployed to : ", lock.target); }

main().catch((error) => { console.error(error); process.exitCode = 1; });


3. 배포

npx hardhat run --network goerli ./scripts/deploy_erc20_3.js


4. verify & publishing

npx hardhat verify --network goerli {컨트랙트 주소} {배포시 constructor input}

위 1234랑 같은 값을 넣어주어야, verify가 작동한다.

## react 실습
1. web3 goerli websocket 설정

const web3 = new Web3( "wss://goerli.infura.io/ws/v3/{apikey}" );

const privateKey = ''; const account = web3.eth.accounts.privateKeyToAccount(privateKey).address;

해당 사이트에서 subscribe 사용법 확인 가능!
https://docs.web3js.org/guides/web3_upgrade_guide/x/subscribe_migration_guide

2. subscribe event 추가
전체 코드

import React from 'react'; import {useEffect, useState} from 'react'; import Web3 from 'web3';

function App() { const [blockNumber, setblockNumber] = useState(); const [balance, setBalance] = useState();

const web3 = new Web3("wss://goerli.infura.io/ws/v3/apiKey");

const privateKey = '개인키'; const account = web3.eth.accounts.privateKeyToAccount(privateKey).address;

useEffect(()=> { async function getBlock() { const blockNumber = await web3.eth.getBlockNumber(); setblockNumber(Number(blockNumber)); }

getBlock();

})

useEffect(()=> { async function subscribeBlock() { const subscription = await web3.eth.subscribe('newHeads'); subscription.on('data', async blockhead => { console.log("Number of New Block : ", blockhead.number); setblockNumber(Number(blockhead.number)); }) } subscribeBlock();

async function getBalance() {
  var balance = await web3.eth.getBalance(account);
  setBalance(Number(balance));
}

getBalance();

})

return (

real time current block number is : {blockNumber}

current Wallet : {account}

current Balance : {balance}

); }

export default App;


## dApp 구조
contract의 주소 접근 관련!!
https://ethereum.stackexchange.com/questions/268/ethereum-block-architecture

## 다양한 event listener 실습

window.ethereum.request({ method: "eth_chainId", });

window.ethereum.on("chainChanged", () => {});

window.ethereum.on("accountsChanged", () => {});



# 화요일 (오전)

이쪽 진로 라인 정리 (feat. 민서 강사님)
![](https://velog.velcdn.com/images/world_changer/post/c45e2980-2dfc-47bd-8c40-b7456048b83c/image.png)

## 이더 송금

``` ``` async function sendTx(e) { e.preventDefault(); const data = new FormData(e.target); console.log(typeof data.get("amount")); /*var a = Number(data.get("amount")); a = web3.utils.numberToHex(a);*/ var a = web3.utils.numberToHex(Number(data.get("amount"))); console.log(a, typeof a);

await window.ethereum.request({
  method: "eth_sendTransaction",
  params: [{ from: account, to: data.get("address"), value: a }],
});

}




# 화요일 (오후)
## 컨트랙트 실습 (erc20)

import abi from "./abi.json"; ... var c_addr = "0xf7389e84220FF1165842e38C8e92772846e61A9d"; var contract = new web3.eth.Contract(abi, c_addr); console.log("methods are : ", contract.methods);

토큰 balance를 관리할 useState 추가

const [tBalance, setTbalance] = useState();

토큰 balance 받아오기

async function getTbalance() { if (account) { setTbalance(await contract.methods.balanceOf(account)); } else { console.log("connect the wallet"); } }


### 토큰 transfer

async function sendErc(e) { e.preventDefault(); const data = new FormData(e.target); var a = web3.utils.numberToHex(Number(data.get("amount_2")));

await window.ethereum.request({
  method: "eth_sendTransaction",
  params: [
    {
      from: account,
      // to: data.get("address_2"), <- 함수 호출은 CA 한테 하는 거
      // to: data.get(c_addr), <- 실패
      to: c_addr,
      data: contract.methods.transfer(data.get("address_2"), a).encodeABI(),
    },
  ],
});

}


### 토큰 minting

``` ``` async function minting(e) { e.preventDefault(); const data = new FormData(e.target); var a = web3.utils.numberToHex(Number(data.get("amount_3")));

await window.ethereum.request({
  method: "eth_sendTransaction",
  params: [
    {
      from: account,
      to: c_addr,
      data: contract.methods.MintToken(a).encodeABI(),
    },
  ],
});

}


### minttoken payable 추가
contract addreess, abi 변경 필요
![](https://velog.velcdn.com/images/world_changer/post/2b5df538-b96e-4c2a-8e76-976d6aabb1bc/image.png)

async function payMinting(e) { e.preventDefault(); const data = new FormData(e.target); var a = web3.utils.numberToHex(Number(data.get("amount_3"))); var b = web3.utils.numberToHex(Number(data.get("amount_3"))*10000);

await window.ethereum.request({
  method : "eth_sendTransaction",
  params : [{
    from : account,
    to : c_addr_2,
    value : b,
    data : contract2.methods.MintToken(a).encodeABI()
  }]
})

}

### evm 동작 원리 구경
https://www.evm.codes/playground?fork=shanghai
이 사이트에서 stack, memory, storage 등 동작 프로세스 확인 가능



# 수/목 (typescript)

## create react app

npx create-react-app [directory] --template typescript


각종 자료형


### FC (Function Component)

### type, interface

type TCreature = { name: string; level: number; };

interface ICreature { name: string; level: number; }

const player: TCreature = { name: "Knight", level: 10, };

const monster: ICreature = { name: "Skeleton", level: 8, };


### type, interface 확장

interface IHuman extends ICreature { age: number; }

const c: IHuman[] = [ { name: "Knight", level: 10, age: 10, }, ];


### props
props 변수들을 interface 로 지정해서, <> 안에 적어주면 된다.

interface BoxProps { color: string; }

const Box: FC = ({ color }) => { return (

); };

export interface BoxProps { color: Color; width: number; height?: number; }

이런식으로 ```?``` 를 붙혀주면 생략가능.

# 금 (오전)

CSR (Client Side Rendering)
SSR (Server Side Rendering)

SSG 라는 것도 있음 (Static Site Generation)

## Next js
```> npx create-next-app [폴더명]```
(전부 yes로 설치)
typescript, eslint, src/, app router, alias(@)

query dsl - 2

Fri, 05 May 2023 08:48:20 GMT

실무 활용

Repository 연동



    public List findAll(){
        return em.createQuery("select m from Member m", Member.class)
                .getResultList();
    }
    public List findAll_querydsl(){
        return queryFactory.selectFrom(member).fetch();
    }

    public List findByUsername(String username){
        return em.createQuery("select m from Member m where m.username = :username", Member.class)
                .setParameter("username", username)
                .getResultList();
    }
    public List findByUsername_querydsl(String username){
        return queryFactory.selectFrom(member).where(member.username.eq(username)).fetch();
    }

@Data
public class MemberTeamDto {
    private Long memberId;
    private String username;
    private int age;
    private Long teamId;
    private String teamName;

    @QueryProjection
    public MemberTeamDto(Long memberId, String username, int age, Long teamId, String teamName) {
        this.memberId = memberId;
        this.username = username;
        this.age = age;
        this.teamId = teamId;
        this.teamName = teamName;
    }
}

@Data
public class MemberSearchCondition {
    private String username;
    private String teamName;
    private Integer ageGoe;
    private Integer ageLoe;
}

ctrl + shift + enter 구문 자동 완성!!

BooleanBuilder 동적 쿼리

    public List searchByBuilder(MemberSearchCondition condition){

        BooleanBuilder builder = new BooleanBuilder();

        if (StringUtils.hasText(condition.getUsername())) {
            builder.and(member.username.eq(condition.getUsername()));
        }
        if (StringUtils.hasText(condition.getTeamName())) {
            builder.and(team.name.eq(condition.getTeamName()));
        }
        if(condition.getAgeGoe() != null){
            builder.and(member.age.goe(condition.getAgeGoe()));
        }

        if(condition.getAgeLoe() != null){
            builder.and(member.age.loe(condition.getAgeLoe()));
        }

        return queryFactory
                .select(new QMemberTeamDto(
                        member.id.as("memberId"),
                        member.username,
                        member.age,
                        team.id.as("teamId"),
                        team.name.as("teamName")
                ))
                .from(member)
                .leftJoin(member.team, team)
                .where(builder)
                .fetch();
    }

where 동적 쿼리

    public List search(MemberSearchCondition condition) {
        return queryFactory
                .select(new QMemberTeamDto(
                        member.id.as("memberId"),
                        member.username,
                        member.age,
                        team.id.as("teamId"),
                        team.name.as("teamName")
                ))
                .from(member)
                .leftJoin(member.team, team)
                .where(
                        usernameEq(condition.getUsername()),
                        teamNameEq(condition.getTeamName()),
                        ageGoe(condition.getAgeGoe()),
                        ageLoe(condition.getAgeLoe())
                        )
                .fetch();
    }

    // BooleanExpression 이 추후  composition 에 유리
    private BooleanExpression usernameEq(String username) {
        return StringUtils.hasText(username) ? member.username.eq(username) : null;
    }

    private BooleanExpression teamNameEq(String teamName) {
        return StringUtils.hasText(teamName) ? team.name.eq(teamName) : null;
    }

    private BooleanExpression ageGoe(Integer num) {
        return num != null ? member.age.goe(num) : null;
    }

    private BooleanExpression ageLoe(Integer num) {
        return num != null ? member.age.loe(num) : null;
    }

where 절... 너무 깔끔하잖아!! 좋아좋아 최고! 재사용 및 조립도 가능함!

API 컨트롤러

샘플 데이터 설정

테스트를 돌릴때는, 샘플 데이터 추가 로직이 동작 x
톰캣을 띄울때는, 샘플 데이터 추가 로직이 실행 되는 걸로!

application.yml 에 profiles -> active: local 추가

test 폴더에 application.yml 추가

다 똑같은데, profiles active 를 test 로 설정!

파일 생성

@Profile("local")
@ComponentScan
@RequiredArgsConstructor
public class InitMember {

    private final InitMemberService initMemberService;

    @PostConstruct
    public void init() {
        initMemberService.init();
    }

    @Component
    static class InitMemberService {
        @PersistenceContext
        private EntityManager em;

        @Transactional
        public void init(){
            Team teamA = new Team("teamA");
            Team teamB = new Team("teamB");
            em.persist(teamA);
            em.persist(teamB);

            for (int i = 0; i < 100; i++) {
                Team selectedTeam = i % 2 == 0 ? teamA : teamB;
                em.persist(new Member("member" + i, i, selectedTeam));
            }
        }
    }
}

@Profile("local") 은 profile local 에서만 실행하겠다는 어노테이션 @ComponentScan 은 spring 이 돌아갈떄, component scan 을 하라는 뜻. @PostConstruct 는 시작할때 실행을 하겠다는 뜻 @Component 는 spring bean 에 component 로 지정

굳이 InitMemberService 를 만들어서 init 해주는 이유는 JPA 기능인 @Transactional 은 @PostConstruct 랑 함께 지정할 수가 없기 때문!!

api controller

    @GetMapping("/v1/members")
    public List searchMemberV1(MemberSearchCondition condition){
        return memberJpaRepository.search(condition);
    }

호출하는 법

스프링 데이터 JPA Repository 로 변경

기존

Spring 데이터 JPA 를 활용한

Query dsl 은 사용자 정의 리포지토리를 통해 구현한다.

사용자 정의 리포지토리

스프링 데이터 JPA 에서 했던 방식.

파일 생성

public interface MemberRepositoryCustom {
    List search(MemberSearchCondition condition);
}

파일 생성

public class MemberRepositoryImpl implements MemberRepositoryCustom{

    private final JPAQueryFactory queryFactory;

    public MemberRepositoryImpl(EntityManager em) {
        this.queryFactory = new JPAQueryFactory(em);
    }

    @Override
    public List search(MemberSearchCondition condition) {
        return queryFactory
                .select(new QMemberTeamDto(
                        member.id.as("memberId"),
                        member.username,
                        member.age,
                        team.id.as("teamId"),
                        team.name.as("teamName")
                ))
                .from(member)
                .leftJoin(member.team, team)
                .where(
                        usernameEq(condition.getUsername()),
                        teamNameEq(condition.getTeamName()),
                        ageGoe(condition.getAgeGoe()),
                        ageLoe(condition.getAgeLoe())
                )
                .fetch();
    }
    ...
    // usernameEq, teamNameEq, ageGoe, ageLoe 함수
}

파일

public interface MemberRepository extends JpaRepository, MemberRepositoryCustom {
    List findByUsername(String username);
}

MemberRepositoryCustom 이라는 interface를 만들어, MemberRepositoryImpl 로 구현

이때 구현체는 JpaRepository를 상속받는 리포지토리 뒤에 impl 붙은 이름과 같아야함 (MemberRepository, MemberRepositoryImpl)

MemberRepository 는 JpaRepository 와 <해당 인터페이스> 를 상속받으면 됨.

조회 쿼리가 너무 복잡한 경우. MemberRepository 에 합치는 것이 아니라, 새로운 MemberQueryRepository 를 만드는 것도 좋음. 특화된 기능은 따로 만드는 것도 좋음!! 합치는 것이 무조건 정답이 아님.

비즈니스, 설계에 따라 유동적으로 도입할 줄 아는 유연성을 가질 것!!

스프링 데이터 페이징 활용

Page, Pageable 을 활용해보기!
simple 과 complex 두 버전

public interface MemberRepositoryCustom {
    List search(MemberSearchCondition condition);
    /*추가*/ Page searchPageSimple(MemberSearchCondition condition, Pageable pageable);
    /*추가*/ Page searchPageComplex(MemberSearchCondition condition, Pageable pageable);
}

simple pageable

기존 쿼리문에 offset 과 limit 를 추가 해주는 방식으로 pageable 구현이 가능하다!! PageImpl 구현체를 사용하여 Page 타입으로 반환 가능!

테스트 코드

    @Test
    public void searchPageSimpleTest() throws Exception{
        // given
        Team teamA = new Team("teamA");
        Team teamB = new Team("teamB");
        em.persist(teamA);
        em.persist(teamB);

        Member m1 = new Member("m1", 10, teamA);
        Member m2 = new Member("m2", 20, teamA);

        Member m3 = new Member("m3", 15, teamB);
        Member m4 = new Member("m4", 25, teamB);

        Member m5 = new Member("m5", 30);
        Member m6 = new Member("m6", 40);

        em.persist(m1);
        em.persist(m2);
        em.persist(m3);
        em.persist(m4);
        em.persist(m5);
        em.persist(m6);

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

        // when
        MemberSearchCondition condition = new MemberSearchCondition();
        PageRequest pageRequest = PageRequest.of(0, 3);

        Page result = memberRepository.searchPageSimple(condition, pageRequest);

        // then

        assertThat(result.getSize()).isEqualTo(3);
        assertThat(result.getContent()).extracting("username").containsExactly("m1", "m2", "m3");

    }

이 방법의 경우, getTotal() 을 통해 count 를 불러오는데, 이때 count query에 특정 쿼리를 지정해주면 좋다.

complex pageable

result 를 그냥 fetch 를 활용하여 그대로 받아오고, fetchCount 를 활용해서, 최적화된 count 함수를 실행함.

핵심은 count 를 직접 지정해주어서, count와 상관 없는 쿼리가 포함되는 것을 막을 수 있음 (성능 최적화) count 가 0일때는 search 쿼리를 날리지 않는 다던지 하는 데이터가 얼마 없을때는 그냥... fetchResult 써라...

count 쿼리 최적화

상황에 따라서는 count 쿼리를 생략할 수 있다.
1) 페이지 시작이면서, 컨텐츠 사이즈가 페이지 사이즈 보다 작을때
2) 마지막 페이지 일때

        JPAQuery countQuery = queryFactory
                .selectFrom(member)
                .leftJoin(member.team, team)
                .where(
                        usernameEq(condition.getUsername()),
                        teamNameEq(condition.getTeamName()),
                        ageGoe(condition.getAgeGoe()),
                        ageLoe(condition.getAgeLoe())
                );

        return PageableExecutionUtils.getPage(content, pageable, () -> countQuery.fetchCount());

스프링데이터 JPA 에서 PageableExecutionUtils 로 그 기능을 제공해준다. 세번째 input 으로는 page count 가 필요할때 실행할 함수를 넣어주면 된다!

if 문 넣어서 직접 해도 되긴함!!

이런식으로 controller 에서 불러와 사용하면 됨!

스프링 데이터 JPA 가 지원하는 Querydsl

여러개 가 있기는 하지만, 복잡한 실무에서 사용하기는 좀 애매함... 참고만!!

QuerydslPredicateExecutor 1 - query dsl 코드를 인자로 넘길 수 있음 2 - left join 지원 안해줌. 3 - 서비스, 컨트롤러 계층에 query 문이 들어감
Querydsl Web 지원 1 - @QuerydslPredicate 를 활용해서 파라미터를 편하게 받을 수 있음 2 - 조건문이 한정적임 / custom 하려면 너무 복잡해짐 3 - 마찬가지로 상위 계층에 query 관련 function 이 포함됨.
QuerydslRepositorySupport 1 - 추상클래스임 (특정 리포지토리에 상속시키면 됨) 2 - queryFactory 없이, 구현된 특정 메소드들을 활용하여 쉽게 메소드 짤 수 있음

Querydsl 지원 클래스 직접 만들기 (Advance)

김영한 강사님의. QuerydslRepositorySupport 한계 극복 클래스 직접 제작!!

@Repository
public abstract class Querydsl4RepositorySupport {
    private final Class domainClass;
    private Querydsl querydsl;
    private EntityManager entityManager;
    private JPAQueryFactory queryFactory;
    public Querydsl4RepositorySupport(Class domainClass) {
        Assert.notNull(domainClass, "Domain class must not be null!");
        this.domainClass = domainClass;
    }
    @Autowired
    public void setEntityManager(EntityManager entityManager) {
        Assert.notNull(entityManager, "EntityManager must not be null!");
        JpaEntityInformation entityInformation =
                JpaEntityInformationSupport.getEntityInformation(domainClass, entityManager);
        SimpleEntityPathResolver resolver = SimpleEntityPathResolver.INSTANCE;
        EntityPath path = resolver.createPath(entityInformation.getJavaType());
        this.entityManager = entityManager;
        this.querydsl = new Querydsl(entityManager, new
                PathBuilder<>(path.getType(), path.getMetadata()));
        this.queryFactory = new JPAQueryFactory(entityManager);
    }
    @PostConstruct
    public void validate() {
        Assert.notNull(entityManager, "EntityManager must not be null!");
        Assert.notNull(querydsl, "Querydsl must not be null!");
        Assert.notNull(queryFactory, "QueryFactory must not be null!");
    }
    protected JPAQueryFactory getQueryFactory() {
        return queryFactory;
    }
    protected Querydsl getQuerydsl() {
        return querydsl;
    }
    protected EntityManager getEntityManager() {
        return entityManager;
    }
    protected  JPAQuery select(Expression expr) {
        return getQueryFactory().select(expr);
    }
    protected  JPAQuery selectFrom(EntityPath from) {
        return getQueryFactory().selectFrom(from);
    }
    protected  Page applyPagination(Pageable pageable,
                                          Function contentQuery) {
        JPAQuery jpaQuery = contentQuery.apply(getQueryFactory());
        List content = getQuerydsl().applyPagination(pageable,
                jpaQuery).fetch();
        return PageableExecutionUtils.getPage(content, pageable,
                jpaQuery::fetchCount);
    }
    protected  Page applyPagination(Pageable pageable,
                                          Function contentQuery, Function countQuery) {
        JPAQuery jpaContentQuery = contentQuery.apply(getQueryFactory());
        List content = getQuerydsl().applyPagination(pageable,
                jpaContentQuery).fetch();
        JPAQuery countResult = countQuery.apply(getQueryFactory());
        return PageableExecutionUtils.getPage(content, pageable,
                countResult::fetchCount);
    }
}

이런 식으로 기존에 있던게 불편하다면, 중간에 함수들을 약간 변경해서 내 맛대로 사용해도 되는 거였음!!

query dsl - 1

Thu, 04 May 2023 03:40:09 GMT

Query DSL 기본 문법

query 위주의 실습이기에, 첫 데이터를 항상 넣고 시작. (같은 class 내의 테스트 들만) ++ compileQuerydsl 실행해두기 (Q type 을 만들어줌)

JPQL 과 차이

    @Test
    public void startJPQL() {
        // find m1
        String queryString = "select m from Member m where m.username =:username";

        Member findByJPQL = em.createQuery(queryString, Member.class)
                .setParameter("username", "m1")
                .getSingleResult();

        assertThat(findByJPQL.getUsername()).isEqualTo("m1");
    }
    @Test
    public void startQuerydsl() {
        // find m1
        JPAQueryFactory queryFactory = new JPAQueryFactory(em);
//        QMember m = new QMember("member"); 이거는 에러가 뜨더라, Member 랑 같아서 그런가봄
        QMember m = new QMember("m");

        Member findMember = queryFactory.select(m).from(m).where(m.username.eq("m1")).fetchOne();
        assertThat(findMember.getUsername()).isEqualTo("m1");
    }

컴파일 시점에 오류를 발견할 수 있음!

이런식으로 지정해두고, 가져올 수 있다!! (할때마다 지정해주지 않아도 됨)

기본 Q-Type 활용

1. 직접 별칭 지정
QMember m = new QMember("m");

2. default 사용
QMember m = QMember.class; // <= new QMember("member1")

3. static 화 해서 바로 사용
QMember.member 말고 member 로 바로 사용.

JPQL 로 어떻게 생성되서 만들어지는지 확인하고 싶으면,

application.yml

jpa -> properties -> hibernate -> use_sql_comments:true 추가

검색 조건 Query

select, from 을 합쳐서 selectFrom 으로 쓸 수 있음 (같은 경우에)

Member findMember = queryFactory
    .selectFrom(member)
    .where(
        member.username.eq("m1").and(member.age.eq(10))
    ).fetchOne();
assertThat(findMember.getUsername()).isEqualTo("m1");

and 의 경우 이렇게 , 로 끊어 갈 수도 있다!

값으로 null 이 들어갈때는 해당 조건문을 무시한다. => 동적 쿼리 작성에 기가 막힌 구조!!!

결과 조회

주로 fetch 를 사용함. <- getResultList 와 비슷

        List fetch = queryFactory.selectFrom(member).fetch();

        Member fetchOne = queryFactory.selectFrom(member).fetchOne();

        // queryFactory.selectFrom(member).limit(1).fetchOne(); 이거랑 같음
        Member fetchFirst = queryFactory.selectFrom(member).fetchFirst();

        // paging 형식으로! 쿼리 2번 날림 (count)
        QueryResults results = queryFactory.selectFrom(member).fetchResults();
        results.getTotal(); // 전체 개수 -> count 쿼리를 따로 날림 => member 의 id 값으로만 count
        List content = results.getResults();
        // getLimit, getOffset 같은 여러 함수 지원

        // paging 말고 count 만 가지고 오고 싶을때
        long total = queryFactory.selectFrom(member).fetchCount();

fetch, fetchOne, fetchFirst, fetchResults, fetchCount 메소드로 결과 조회 가능!

정렬

이런식으로 바로 QMember 에서 엔티티 필드값에 desc, asc 적용 가능하고, 기타 설정들도 적용 가능하다!

페이징

offset 과 limit 로 가능하고, fetchResults 로 받아오면, 여러 페이징 관련 메소드를 사용할 수 있음!!

여기에 where 문 이나, 다른 테이블 참조 등 여러 복합쿼리가 나가게 되면, count 절에도 똑같이 적용이 되어 성능이 안나올 때가 있음! count 문을 위한 쿼리를 따로 짜주는게 좋음!!

집합

Tuple 은 querydsl 에서 제공해주는 자료형 (데이터 타입이 여러개 들어올때)

이런식으로 Tuple 값 접근 가능! => 실무에서는 DTO 로 처리함!

이런식의 groupBy 기능도 가능

join - 기본

        List result = queryFactory
                .selectFrom(member)
                .join(member.team, team)
                .where(team.name.eq("teamA"))
                .fetch();

        assertThat(result)
                .extracting("username")
                .containsExactly("m1", "m2");

team 은 QTeam.team 을 static 화 해놓은 것!

덧. 세타조인 이라고, 막 조인을 하는 것도 가능! DB 가 최적화를 하겠지만, member 와 team Table 을 싹 불러와 NxM 테이블 만들고 where 절 처리! (cross join)

단점 : 외부 조인이 불가능 함 => 조인 on 을 사용하여 해결 가능!

join - on 절

이를 qeurydsl 로 가져가면,

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

left join 을 할건데, team name 이 teamA 인 애들만 join 할거야.

나머지는 team 이 있어도 조회 안되는 걸루!!

추가) join 이라면.

List result = queryFactory
                .select(member, team)
                .from(member)
                .join(member.team, team).on(team.name.eq("teamA")).fetch();

join 을 할건데, team name 이 teamA 인 애들만 조인할거야.

on 절은 join에 조건을 걸어주는 것!! -> inner 조인의 경우 on 이나 where 이나 같은 역할. -> outer 조인의 경우 on 으로만 가능함!

join - fetch join

서브 쿼리

JPAExpressions 를 활용하여 서브쿼리 구현! 따로 QMember 별칭과 함께 지정해두고 사용해야함!!

// 나이가 가장 많은 회원들 조회
        QMember subMember = new QMember("subMember");

        List result = queryFactory
                .selectFrom(member)
                .where(member.age.eq(
                        JPAExpressions
                                .select(subMember.age.max())
                                .from(subMember)
                ))
                .fetch();

        for (Member member : result) {
            System.out.println("member = " + member);
        }

// 평균나이보다 많은 회원들 조회
        QMember subMember = new QMember("subMember");

        List result = queryFactory
                .selectFrom(member)
                .where(member.age.gt(
                        JPAExpressions
                                .select(subMember.age.avg())
                                .from(subMember)
                ))
                .fetch();

        for (Member member : result) {
            System.out.println("member = " + member);
        }

case 문

        List result = queryFactory
                .select(member.age
                        .when(10).then("열살")
                        .when(20).then("스무살")
                        .otherwise("기타")
                )
                .from(member)
                .fetch();

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

        List result = queryFactory
                .select(new CaseBuilder()
                        .when(member.age.between(0, 20)).then("0 ~ 20 살")
                        .when(member.age.between(21, 30)).then("21 ~ 31 살")
                        .otherwise("기타")
                )
                .from(member)
                .fetch();

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

가능하면 DB 에서 이런 작업들은 하지 않는 걸로! 이런 작업들은 DB 밖에서 하는 것이 왠만하면 좋음!! (클라이언트 나 presentation layer 에서)

상수 문자 더하기

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

        List result2 = queryFactory
                .select(member.username.concat(member.age.stringValue()))
                .from(member)
                .fetch();
        for (String v : result2) {
            System.out.println("v = " + v);
        }

.stringValue() 이게 은근 쓸 데가 많음 (enum 의 경우 자주 사용)

query dsl 중급 문법

프로젝션

Tuple 형태 말고 DTO 형태로!!

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

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

기존 JPQL 에서 dto 로 불러오는 법

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

QueryDSL 에서 더 깔끔하게 지원해줌

1. 프로퍼티 접근

2. 필드 직접 접근

3. 생성자 사용

4. 프로젝션과 결과 반환

@QueryProjection 어노테이션을 달아주면, Query DSL compile 할때 DTO 클래스가 Q형태로 새로 만들어진다!

정말 편하긴 한데!! DTO는 보통 Respository 에서 Query DSL 함수로만 쓰이는 친구가 아님 Service, Controller 단에서도 쓰이게 되는데, Query DSL 관련 의존을 하고 있다는 건 뭔가 순수하지 않음...

동적쿼리

BooleanBuilder

    private List searchMember1(String usernameCond, Integer ageCond){

        BooleanBuilder builder = new BooleanBuilder();

        if(usernameCond != null){
            builder.and(member.username.eq(usernameCond));
        }

        if(ageCond != null){
            builder.and(member.age.eq(ageCond));
        }

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

where 다중 파라미터

    private List searchMember2(String usernameCond, Integer ageCond){
        return queryFactory.selectFrom(member).where(
                usernameEq(usernameCond),
                ageEq(ageCond)
        ).fetch();
    }
    private Predicate usernameEq(String usernameCond){
        return usernameCond != null ? member.username.eq(usernameCond) : null;
    }

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

수정, 삭제 배치 쿼리

필드 업데이트

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

      List result = queryFactory.selectFrom(member).fetch();

      for (Member member1 : result) {
          System.out.println("member1 = " + member1);
      }

update가 실행되고 나서 (벌크 연산), 영속성 컨텍스트가 유지되면, 조회를 하더라도 바뀐 값으로 업데이트 하지 않는 경우가 있다. update 같은 벌크연산을 하고 난 뒤에는, em.flush 및 clear 하기를!!

다른 벌크 기능

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

      System.out.println("executeCount = " + executeCount);

      long executeCount = queryFactory
              .delete(member)
              .where(member.age.gt(18))
              .execute();
      System.out.println("executeCount = " + executeCount);

SQL function 호출

    List result = queryFactory
              .select(Expressions.stringTemplate(
                      "function('replace', {0}, {1}, {2})",
                      member.username, "m", "member"))
              .from(member).fetch();

이런식으로 다양한 여러 function 을 사용할 수 있음!

Expressions.stringTemplate("function('lower', {0})", member.username) member.username.lower() 와 같은 의미임. 대부분 다 querydsl 에 구현이 되어 있긴 함

til_230501

Wed, 03 May 2023 01:49:38 GMT

합의 알고리즘

마지막 블록 헤더 해시값 비교 (고유한 체인의 특성)
길이 비교
길이가 긴 쪽에서 체인을 넘겨줌!
유효성 검사 (채굴 결과 검증)
유효하면 블록체인 동기화

1 이 달라서 2를 하는데 길이가 다르다? 잠시 대기상태임! 계속 상호 물어봄!!

합의 알고리즘의 끝은 네트워크 동기화!! 모든 full node 들의 목적은 동기화가 되는 것이다! (주변 노드들과)

스크립트

돈이 들어올때는 묶인 상태로 옴. 이걸 풀어줘야함.

sender 가 나의 공개키로 묶어서, 나에게 보내고 나는 private 로 풀어서 내 지갑에 넣는다?

UTXO

mempool 에서 수많은 UTXO 들이 모이고, 어떤 UTXO 를 담은 블록들을 채굴자들이 채굴한다.

full - node

노드가 다 같은 역할을 하지는 않음.

핸드셰이킹

version 을 보내고, versack 을 받음 (응답 받았다는 것을 확인)
version 을 받고, versack 을 보냄 (version + acknowledgement)

종자 노드

오래되고, 신뢰가 쌓여있는 이웃노드들 정보가 있음. 이 노드에 요청하면, 그 노드들 받을 수 있음.

처음에 블록 받아오는 법

https://developer.bitcoin.org/reference/p2p_networking.html

get block 방법 (구식)
get headers 방법 (신식)

블록체인 풀노드로 첫 시작을 할거면, 풀노드가 세팅해놓은 api 를 활용해서 정보들을 받아와야함!

SPV

Simplified Payment Verification
블록헤더만을 다운로드 받는 노드
풀노드의 도움을 받아야함.

머클트리

이를 하는 이유는 검증에 있어서, 효율적인 방법을 제공해주기 위함!

spv 가 특정 tx 가 옳은지 검증을 하기 위해, 풀노드에 관련 자료들을 요청함. 특정 tx 를 검증할 수 있게, 풀노드에서 힌트를 주는 느낌?

요즘 블체 네트워크

순수한 p2p 는 지금 아님

compact block optimization -> 안정적으로 운영되는 특정 노드들을 선발하여 AWS 에 호스팅!! FIBRE 개발 (Fast Internet Bitcoin Relay Engine)

덧.

채굴자(풀노드X)는 새로운 블록을 생성
생성된 블록은 풀 노드에 전송
풀 노드는 새로운 블록을 검증하고, 이전 블록과 연결하여 블록체인에 추가
새로운 블록이 추가된 블록체인은 모든 풀 노드에게 동기화
SPV 노드는 블록 헤더와 머클루트값을 사용하여 블록체인의 일부분을 다운로드
SPV 노드는 검증을 요청하는 TX의 해시값을 풀 노드에 보내어, 해당 거래의 정보 받음
SPV노드는 풀보드가 보내준 포함된 블록의 머클루트값과 path를 확인하여, 해당 거래의 유효성을 검증

1.채굴자(풀노드)는 새로운 블록을 생성 후 검증하고, 이전 블록과 연결하여 블록체인에 추가

2.새로운 블록이 추가된 블록체인은 모든 풀 노드에게 동기화

3.SPV 노드는 블록 헤더와 머클루트값을 사용하여 블록체인의 일부분을 다운로드

4.SPV 노드는 검증을 요청하는 TX의 해시값을 풀 노드에 보내어, 해당 거래의 정보 받음

5.SPV노드는 풀노드가 보내준 포함된 블록의 머클루트값과 path를 확인하여, 해당 거래의 유효성을 검증

솔리디티

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.18;

contract StoreandReturn {
    uint a; //숫자형 변수 a
    uint b; //숫자형 변수 b
    uint c=2; // 숫자형 변수 c, 값은 2

    // 함수이고, 이름은 valueA, input값은 없음, public 하고 view 함, output 값은 1개 있음, uint 형임
    function getA() public view returns(uint) {
        return a;
    }

    function setA(uint _a) public {
        a = _a;
    }

    function getB() public view returns(uint) {
        return b;
    }

    // 함수, 이름은 valueAB, input 없음, public하고 view 함, output 값은 2개, 둘 다 uint형
    function getAB() public view returns(uint, uint) {
        return (a, b);
    }

    function getABC() public view returns(uint, uint, uint) {
        return (a,b,c);
    }
}

view 의 경우 상태변수를 건드리지 않는 경우에 선언

상태변수 : contract 에서 관리되는 변수 지역변수 : 메소드의 input 값으로 들어와, 메소드 안에서만 관리되는 변수

함수 종류

none : 상태변수가 수정이 될 때 (가스 필요) view : 상태변수 수정은 x, 불러오기만 할때 (가스 x) pure : 상태변수 를 사용하지 않을때

/*
    view와 pure 함수는 state variable(상태변수)의 값을 변화시키지는 않음 -> gas비 안씀
    */
    // 숫자 _aa와 _bb를 받아서 이 2개의 숫자를 더한 결과값을 반환하는 함수 Add를 구현하세요
    function Add(uint _aa, uint _bb) public pure/*상태변수는 하나도 필요없을 때 pure*/ returns(uint) {
        return _aa+_bb;
    }

    // 숫자 a와 b를 갖고와서 이 2개의 숫자를 더한 결과값을 반환하는 함수 Add2를 구현하세요
    function Add2() public view/*상태변수를 갖고오기 때문에 view로로*/ returns(uint) {
        return a+b;
    }

query dsl - 0

Sat, 29 Apr 2023 10:12:16 GMT

컴터에 설치한 java가 11 버전이라 spring 2.x 를 사용.

Query DSL 설정

build.gradle 파일에 query dsl 관련 내용 추가

plugin {
    ...
    //querydsl 추가
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

dependencies {
    ...
    //querydsl 추가
    implementation 'com.querydsl:querydsl-jpa'
}

//querydsl 추가 시작
def querydslDir = "$buildDir/generated/querydsl"
querydsl {
    jpa = true
    querydslSourcesDir = querydslDir
}
sourceSets {
    main.java.srcDir querydslDir
}
configurations {
    querydsl.extendsFrom compileClasspath
}
compileQuerydsl {
    options.annotationProcessorPath = configurations.querydsl
}
//querydsl 추가 끝

내 경우 에러가 뜸. 스프링 버전이랑 쿼리 dsl 버전이 안 맞아서 그런듯.

이후 compileQueryDsl 다시 해주면, 이처럼 QHello 라는 파일이 생김!!

이런것 gitignore 되어야 하는 빌드 파일임!! (query dsl 버전따라 달라질 수 있으니!)

h2 데이터 베이스

첫 한번(생성시)은 파일 모드로 접근해야함. 이후에 tcp 모드로 접근 ㄱㄱ

앱 설정

yml 파일 따로 생성

spring:
  datasource:
    url: jdbc:h2:tcp://localhost/~/querydsl
    username: sa
    password:
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        # show_sql: true
        format_sql: true

logging.level:
  org.hibernate.SQL: debug
# org.hibernate.type: trace

쿼리로 나가는 값을 알고 싶을때는 외부 라이브러리를 설치해주면 됨. (실무에서는 성능을 꼭 확인하길 바람)

    // query log 남기기
    implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.5.8'

스프링 데이터 JPA - 3

Thu, 27 Apr 2023 02:47:26 GMT

Spring Data JPA 구현체 분석

우리가 평소에 만드는 Repository 처럼, @Repository, @Transactional(readOnly=true) 어노테이션을 가진다!

save 같은 친구들에겐 따로 @Transactional 을 달아주면서 처리!

save 함수

새로운 엔티티면 저장 (persist) 새로운 엔티티가 아니면 병합 (merge) <- 그냥 바꿔치기 해버리기!! (잘 활용해야함!)

새로운 엔티티 인지 어떻게 판단?

@GeneratedValue 를 사용한다면, id 값이 존재하지 않는 것으로 확인을 할 수 있으나

생성자로 id 를 받아오는 경우에는, id 유무로 isNew 를 판단해야하는데, DB 에 올라가있지도 않은 엔티티에 merge 가 일어남 -> 사이드 이펙트 느낌 물씬

이런 방식으로해서 isNew를 덮어씌워주면 됨.

@Entity
@EntityListeners(AuditingEntityListener.class)
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Item implements Persistable {
    @Id
    private String id;

    @CreatedDate
    private LocalDateTime createdDate;

    public Item(String id){
        this.id = id;
    }
    @Override
    public String getId(){
        return id;
    }

    @Override
    public boolean isNew(){
        return createdDate == null;
    }
}

기타 쿼리 기능들

Specifications

Jpa Criteria 를 활용해서 하는데, 김영한 개발자님 비추...

Query By Example

ExampleMatcher 와 Prove 로 Example 을 생성하여, 쿼리 조건 만들기! (QueryDSL 로 해결 가능)

Projections

Spring Data Jpa 를 사용해서 조회를 하는데, Entity 말고 특정 값들만 가지고 오고 싶을때!

엔티티 대신에 DTO를 바로 조회할때
```
public interface UsernameOnly {
  String getUsername();
}
```
이렇게 만들어 두고,

 - interface
    ...
    List findByUsername(@Param("username") String username);
    List findProjectionsByUsername(@Param("username") String username);

분명 interface 인데, 알아서 proxy 객체로 생성을 해줌!

이런식으로 지정해주는 것도 가능함!

class 기반의 Projections

public class UsernameOnlyDto {
  private final String username;

  public UsernameOnlyDto(String username) {
      this.username = username;
  }

  public String getUsername() {
      return username;
  }
}

생성자에서 받아오는 인자의 이름이 중요!! 이름 기반으로 엔티티 필드 찾아감

 interface 에 이와 같이 구현
List findClassProjectionsByUsername(@Param("username") String username);

이래도 똑같이 작동함!! class 가 명시되어 있기에, proxy 객체가 아님

애초에 findByUsername 함수를 만들때, class type 을 지정하도록 할 수 있음

 List findCustomByUsername(@Param("username") String username, Class type);

사용 예시

List result = memberRepository.findCustomByUsername("m1", UsernameOnlyDto.class);

덧) join 된 엔티티의 필드들도 같이 가져올 수 있음!! 실무에서는 단순할 때만 사용하고, 복잡해지면 QueryDSL을 사용하자!!

Native Query

JPQL 문법이 아닌, 실제 SQL 문법으로 적어서 쓸 수 있도록 지원해줌!! 위에서 이야기한 join 된 복합 DTO를 가져오는 것이 좀더 편리하게 가능함!

public interface MemberProjection {
    Long getId();
    String getUsername();
    String getTeamName();
}

    @Query(value = "select m.member_id as id, m.username, t.name as teamName " +
        "from member m left join team t",
            countQuery = "select count(*) from member",
            nativeQuery = true)
    Page findByNativeProjection(Pageable pageable);

역시나 가급적 안씀! JPQL, QueryDSL 로 왠만하면 다 해결하려고 함!!

스프링 데이터 JPA - 2

Wed, 26 Apr 2023 03:43:35 GMT

Custom Repository

아얘 다른 형태로 쿼리를 작성하고 싶을때!! (주로 QueryDSL)
내가 따로 interface 구현체를 만들어서 모든 기능을 override 시켜야하나?

원하는 기능을 가지는 interface 를 만들어, 구현체까지 만든다.

public interface MemberRepositoryCustom {
    List findMemberCustom();
}

@RequiredArgsConstructor
public class MemberRepositoryImpl implements  MemberRepositoryCustom{

    private final EntityManager em;
    @Override
    public List findMemberCustom() {
        return em.createQuery("select m from Member m"+
                " left join fetch m.team t", Member.class)
                .getResultList();
    }
}

public interface MemberRepository extends JpaRepository, MemberRepositoryCustom {
    ...
}

이런 식으로 JpaRespository 랑 같이 상속시켜주면 된다!!

주의사항!! 구현체의 경우 이름을 꼭 맞춰줘야함! 그래야지 Spring Data JPA 가 추적 가능! (repository이름)Impl 으로 구현체 이름을 지정해주어야함! xml 파일에 뒤에 붙을 이름 지정해줄 수 있다!! (왠만하면 관례 따르자)

그렇다고 해서! Custom 에 기능들 다 때려박으면 안된다! (항상 필요한게 아님)

유지보수 측면에서 Repository Class 를 나누어 관리하는 것이 좋을 때가 많음 ex) MemberQueryRepository, MemberUpdateRepository 등등 ex) Command 와 Query 구분, 핵심 비즈니스 로직과 아닌 것의 구분

Auditing

엔티티를 생성, 변경할 때 변경한 사람과 시간을 추적하고 싶으면?
등록일/수정일, 등록자/수정자

public class JpaBaseEntity {

    @Column(updatable = false)
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;

    @PrePersist // persist 하기 전에 event 발생
    public void prePersist(){
        LocalDateTime now = LocalDateTime.now();
        createdDate = now;
        updatedDate = now;
    }

    @PreUpdate
    public void preUpdate(){
        updatedDate = LocalDateTime.now();
    }
}

public class Member extends JpaBaseEntity{
    ...
}

상속을 했지만, 이게 JPA 에서 DB Table 과 연결한다는 뜻은 아님!! 그래서 @MappedSuperclass 을 추가해줘야함

@MappedSuperclass
@Getter // 아래 테스트 코드를 위함
public class JpaBaseEntity {...}

    @Test
    public void JpaEventBaseEntity() throws Exception{
        // given
        Member member = new Member("member1", 10);
        memberRepository.save(member); // @PrePersist 발생

        Thread.sleep(1000);
        member.setUsername("member2");

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

        // when
        Member findMember = memberRepository.findById(member.getId()).get();

        // then
        System.out.println("findMember.getCreatedDate() = " + findMember.getCreatedDate());
        System.out.println("findMember.getUpdatedDate() = " + findMember.getUpdatedDate());
    }

공통 관심사인 JpaBaseEntity 이거를 모든 엔티티에 상속하기한 하면, Table 에서 관리 알아서 가능함!! 엄청나게 강력함!!

그런데 이거를 Spring 데이터 JPA가 관리해줌!! ( 더 깔끔하게 )

Spring Data JPA Auditing

@EnableJpaAuditing 을 꼭 넣어줘야함!! (Spring 시작 클래스)

@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
@Getter
public class BaseEntity {
    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdDate;

    @LastModifiedDate
    private LocalDateTime lastModifiedDate;
}

@EntityListeners(AuditingEntityListener.class) 가 추가적으로 필요함!

위의 와 비교하면! 좀 간결함 (별 차이 없긴 하네...)

public class Member extends BaseEntity{...}

이렇게 하고 실행하면,

똑같이 Table 이 만들어지는 것을 확인 가능!! (이름이 좀 다르긴 함 last modified)

생성자/수정자

이런식으로 에 추가하면, 우리가 원하는 대로 생성/수정자를 지정할 수 있게 된다.

한가지 세팅이 필요함!! 이렇게 @Bean 에 AuditorAware<> 을 등록해줘야함.

해당 함수는 Create, Modify 가 일어날때 계속 호출 됨

위 예시는 랜덤 값이지만, 실제로는 세션에서 회원정보를 불러오는 식으로!!

덧

각 BaseEntity 마다 따로 @EntityListeners 를 달아주지 않고, 전체 설정도 가능 pom.xml 파일에 지정.. (생략)

김영한 개발자님의 경우 어떻게 실무에서 쓰는가 를 만들고, 는 이를 상속하도록!! 특정 엔티티는 Time 만 필요하고, 생성/수정자 추적은 필요가 x

도메인 클래스 컨버터

    @GetMapping("/members/{id}")
    public String findMember(@PathVariable("id") Long id){
        Member member = memberRepository.findById(id).get();
        return member.getUsername();
    }

    @GetMapping("/members2/{id}")
    public String findMember2(@PathVariable("id") Member member){
        return member.getUsername();
    }

받아오는 값이 엔티티의 PK 값이면, 바로 Member로 받아올 수 있게 해줌! findMember2 처럼!!

(조회용 엔티티 이므로, 영속성컨텍스트에서 관리 되지는 않음!)

페이징과 정렬

findAll 함수는 pageable을 받을 수 있도록 Spring Data JPA 에서 제공!

    @GetMapping("/members")
    public Page list(Pageable pageable){
        return memberRepository.findAll(pageable);
    }

input 값으로 pageable을 받는건 어떤 의미?

해당 데이터들과 함께, 21 ~ 40 번째 데이터를 content 로 반환한다. (default 값이 20개임. 다양한 방식으로 바꿀 수 있음!) (글로벌 설정) (로컬설정)

size 를 지정해줄 수도 있음!

아래처럼 여러 파라미터를 전달할 수 있음. pageable 에 자동으로 매칭되는 것들!!

Entity 를 Page<> 에 넣어서 하지 x

DTO 로 넘기자.

DTO Constructor를 Member 와 연결시켜 두면,

public MemberDto{
    ...
     public MemberDto(Member member){
        this.id = member.getId();
        this.username = member.getUsername();
        this.teamName = member.getTeam().getName();
    }
}

이런식으로 축약이 가능하다!

    @GetMapping("/members")
    public Page list(@PageableDefault(size = 5) Pageable pageable) {
        Page page = memberRepository.findAll(pageable);
//        Page dtoPage = page.map(member -> new MemberDto(member.getId(), member.getUsername(), ""));
        Page dtoPage = page.map(MemberDto::new);
        return dtoPage;
    }

스프링 데이터 JPA - 1

Wed, 19 Apr 2023 13:54:56 GMT

JPA -> 스프링 데이터 JPA 방식으로 진행!

세팅을 원래는 해줬어야 하나, Spring 부트가 알아서 해줌!

Repository

public class MemberJpaRepository {
    private final EntityManager em;

    public Member save(Member member){
        em.persist(member);
        return member;
    }

    public Member find(Long id){
        return em.find(Member.class, id);
    }

    public void delete(Member member){
        em.remove(member);
    }

    public List findAll(){
        return em.createQuery("select m from Member m", Member.class).getResultList();
    }

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

    public long count(){
        return em.createQuery("select count(m) from Member m", Long.class).getSingleResult();
    }
}

@SpringBootTest
@Transactional
@Rollback(false)
class MemberJpaRepositoryTest {

    @Autowired MemberJpaRepository memberJpaRepository;

    @Test
    public void testMember() throws Exception {
        // given
        Member member = new Member("memberA", 10);
        Member saveMember = memberJpaRepository.save(member);

        // when
        Member findMember = memberJpaRepository.find(saveMember.getId());

        // then
        assertThat(findMember.getId()).isEqualTo(member.getId());
        assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
        assertThat(findMember).isEqualTo(member);
    }

    @Test
    public void basicCRUD(){
        Member memberA = new Member("memberA", 10);
        Member memberB = new Member("memberB", 12);
        memberJpaRepository.save(memberA);
        memberJpaRepository.save(memberB);

        Member findMember1 = memberJpaRepository.findById(memberA.getId()).get();
        Member findMember2 = memberJpaRepository.findById(memberB.getId()).get();

        assertThat(findMember1).isEqualTo(memberA);
        assertThat(findMember2).isEqualTo(memberB);

        List all = memberJpaRepository.findAll();
        assertThat(all.size()).isEqualTo(2);

        long count = memberJpaRepository.count();
        assertThat(count).isEqualTo(2);

        memberJpaRepository.delete(memberA);
        memberJpaRepository.delete(memberB);

        long afterCount = memberJpaRepository.count();
        assertThat(afterCount).isEqualTo(0);
    }
}

interface 로 Repository

public interface MemberRepository extends JpaRepository {
}

Test 쪽 코드에서, memberRepository 를 MemberJpaRepository => MemberRepository 로 바꿔주면 똑같이 작동함!

interface 만 있고, 구현한 적이 없는데 대체 어떻게?

Spring Data JPA가 로딩 시점에 알아서 프록시 객체로 구현을 해줌!

TeamRepository

@Repository
@RequiredArgsConstructor
public class TeamJpaRepository {
    private final EntityManager em;

    public Team save(Team team){
        em.persist(team);
        return team;
    }

    public Team find(Long id){
        return em.find(Team.class, id);
    }

    public void delete(Team team){
        em.remove(team);
    }

    public List findAll(){
        return em.createQuery("select t from Team t", Team.class).getResultList();
    }

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

    public long count(){
        return em.createQuery("select count(t) from Team t", Long.class).getSingleResult();
    }
}

public interface TeamRepository extends JpaRepository {
}

Team 의 경우도 바꿔줄 수 있다!

JpaRepository<___, ___> Type 이 중요하다! 그것에 따라 내부 동작 메소드들이 결정되니깐!

기본적으로 사용할 것 같은 메소드들은 다 구현되어 있으니, CRUD 코드 노가다를 엄청 줄일 수 있음!! 최고!!

save, delete, findById, getOne, findAll, paging, sort 등의 메소드를 제공해준다!! getOne의 경우 getReference 프록시 객체로 받음!!

개발자로서 상상할 수 있는 공통기능은 전부다 제공해줌!!!

공통기능 외에 다른 기능이 필요하다면!!

ex. field 값에 따른 find List findByUsername(String username)

이런걸 구현하려고 하면, 구현체에서 interface 모든 메소드를 override 해야하는데... 크흠...

이걸 해결해주기 위해!! query method 를 제공해줌!

Query Method

method 이름으로 Query 작성 가능!

순수하게 했다고 치면

   public List findByUsernameAndAgeGreaterThen(String username, int age){
        return em.createQuery("select m from Member m" +
                        " where m.username = :username" +
                        " and m.age > :age", Member.class
                ).setParameter("username", username)
                .setParameter("age", age)
                .getResultList();
    }

뭐 그닥 어렵지 않기는 한데, 이런거 좀 알아서 해주면 안되나?

정말 웃기게도, Spring Data JPA 가 알아서 메소드를 연결해준다.

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

(IntelliJ 유료 버전에서는 이렇게 추천도 해줌!)

메소드 이름으로 쿼리를 생성!!! https://docs.spring.io/spring-data/jpa/docs/2.7.11/reference/html/#jpa.query-methods.query-creation

엔티티 필드명이 변경된다거나, 많은 양의 쿼리 조건이 들어간다면!! 아무래도 메소드 명도 길어지고, 뭔가 유지보수가 애매해진다!! 그래서 다른 방안들이 여러 개 존재한다!!

김영한 개발자님은 한두개 정도 필드의 쿼리는 메소드 쿼리로 생성한다고 하심! 나머지는 다른 방법으로!!

덧. 오류의 순위

가장 좋은 거 : 컴파일 단에서
그 다음 : Tdd 돌려서 알 수 있는
그 다음 : 실행을 하면서 세팅단에서 알 수 있는
최악 : 고객이 버튼을 클릭해야 나오는

JPA Named Query

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

    public List findByUsername(String username) {
        return em.createNamedQuery("Member.findByUsername", Member.class).setParameter("username", "aaa").getResultList();
    }

createNamedQuery 를 활용해서 사용 !!

이 방식을 Spring Data JPA 는 어떻게 도와준다는 걸까

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

    @Query(name = "Member.findByUsername")
    List findByUsername(@Param("username") String username);
}

@Query 를 활용하여 매칭해주고, @Param 으로 매개변수 지정!!
메소드 이름이 같을 필요 x

웃긴건, @Query 어노테이션을 지워도 동작을 하게 해줌! (Spring boot) 이런 관례가 있다고함! 메소드 쿼리를 생성할때, JpaRepository 에서 Type으로 받은 Member 로 Member.____ 이름의 NamedQuery 가 있는지 먼저 탐색! 없으면 메소드 쿼리로 생성!

장점이 있음!!
보통 jpql 상에서 오류가 뜨면, 해당 쿼리를 실행할 때 오류가 발생함!!
그런데 NamedQuery 안에 있는 jpql 문은 어플리케이션 로딩 시점에 에러를 체크함!!~

좋아 보이지만... 사실 실무에서 많이 사용되지는 않음!! 뭔가 엔티티에 쿼리가 들어가 있는게 좀 어색...? 위의 장점을 가진 다른 기능!!!

Repository에 Query 직접 지정

public interface MemberRepository extends JpaRepository {
    ...

    @Query("select m from Member m where m.username = :username and m.age = :age")
    List findUser(@Param("username") String username, @Param("age") int age);

    @Query("select m.username from Member m")
    List findUsernameList();
}

기본 CRUD 말고 필요한 쿼리들은 @Query 를 바로 적용하여 메소드 생성!

쿼리문도 똑같이 들어가는 것을 알 수 있다!! 위의 NamedQuery 처럼 어플리케이션 로딩 시점에 에러를 체크함!! 미리 에러를 발견하고 넘길 수 있다!

DTO 직접 조회

    @Query("select new study.datajpa.dto.MemberDto(m.id, m.username, t.name) from Member m join m.team t")
    List findMemberDto();

test code

    @Test
    public void findMemberDto() throws Exception {
        // given
        Member m1 = new Member("aaa", 10);
        Member m2 = new Member("bbb", 20);
        memberRepository.save(m1);
        memberRepository.save(m2);

        Team team = new Team("teamA");
        teamRepository.save(team);

        m1.changeTeam(team);

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

        // when
        List memberDtoList = memberRepository.findMemberDto();

        // then
        assertThat(memberDtoList.get(0).getTeamName()).isEqualTo("teamA");
        assertThat(memberDtoList.get(0).getUsername()).isEqualTo("aaa");
        assertThat(memberDtoList.size()).isEqualTo(1);
    }

동적 Query 의 경우는? QueryDSL 로 해야한다!!

파라미터 바인딩

위치기반 (사용하지 말것)
이름기반

컬렉션 파라미터 바인딩

    @Query("select m from Member m where m.username in :names")
    List findByNames(@Param("names") List names);

반환타입

컬렉션, 단건, 단건 Optional

public interface MemberRepository extends JpaRepository {
    ...
    List findListByUsername(String username);
    Member findMemberByUsername(String username);
    Optional findOptionalByUsername(String username);
}

find...ByUsername 형태의 모든 naming이 가능함! 위 형태는 반환값만 다르게 지정한 것임!

JPA 의 경우 SingleResult 메소드를 사용하면, 값이 없거나 2개 이상일때는 Exception 을 띄움 Spring Data JPA 의 경우 findMemberByUsername 의 경우

없으면 null
2개 이상일때는 Exception

    @Test
    public void returnType() throws Exception {
        // given
        Member m1 = new Member("aaa", 10);
        Member m2 = new Member("aaa", 20);
        memberRepository.save(m1);
        memberRepository.save(m2);

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

        // when

        List memberList = memberRepository.findListByUsername("aaa");
        Member oneMember = memberRepository.findMemberByUsername("bbb");
        Optional optionalMember = memberRepository.findOptionalByUsername("bbb");

        // then

        assertThat(memberList.size()).isEqualTo(2);
        assertThat(oneMember).isEqualTo(null);
        assertThat(optionalMember.isPresent()).isEqualTo(false);
    }

다양한 반환 타입을 지원한다!

순수 Jpa 페이징, 정렬

    public List findByPage(int age, int offset, int limit) {
        return em.createQuery("select m from Member m where m.age = :age order by m.username desc", Member.class)
                .setParameter("age", age)
                .setFirstResult(offset)
                .setMaxResults(limit)
                .getResultList();
    }

    public long totalCount(int age) {
        return em.createQuery("select count(m) from Member m where m.age = :age", Long.class)
                .setParameter("age", age)
                .getSingleResult();
    }

위와 같이

offset, limit 를 받아서 특정 요소들만 가져오고
전체 페이지를 알기위해 totalCount 를 불러온다 (이때 sorting은 필요 없음)

스프링 데이터 페이징, 정렬

public interface MemberRepository extends JpaRepository {
   ...
   Page findByAge(int age, Pageable pageable);
}

반환타입을 Page 로 지정해주고! input 값으로 Pageable 을 받는다!!

주의 사항 : 기존에 offset, limit 를 넣었던 과는 다르게 pageNum, pageSize 를 넣는 것임!!

find, sorting, paging 쿼리를 날리고, 추가적으로 count 쿼리도 알아서 날림! Page에 맞게 쿼리를 날려줌!! test code

    @Test
    public void pagingTest() throws Exception {
        // given
        Member m1 = new Member("aaa", 10);
        Member m2 = new Member("bbb", 20);
        Member m3 = new Member("ccc", 10);
        Member m4 = new Member("ddd", 10);
        Member m5 = new Member("eee", 10);
        Member m6 = new Member("fff", 10);
        Member m7 = new Member("ggg", 10);
        Member m8 = new Member("hhh", 10);

        memberRepository.save(m1);
        ...
        memberRepository.save(m8);

        int age = 10;
        int pageOffset = 0;
        int onePageContent = 3;
        PageRequest pageRequest = PageRequest.of(
                pageOffset,
                onePageContent,
                Sort.by(Sort.Direction.DESC, "username"));

        // when
        Page memberPage = memberRepository.findByAge(age, pageRequest);
        for (Member member : memberPage.getContent()) {
            System.out.println("member = " + member);
        }

        // then
        assertThat(memberPage.getContent().get(0).getUsername()).isEqualTo("hhh");
        assertThat(memberPage.getContent().get(1).getUsername()).isEqualTo("ggg");
        assertThat(memberPage.getContent().get(2).getUsername()).isEqualTo("fff");
        assertThat(memberPage.getTotalElements()).isEqualTo(7);
        assertThat(memberPage.getNumber()).isEqualTo(pageOffset);
        assertThat(memberPage.getTotalPages()).isEqualTo(3);
        assertThat(memberPage.isFirst()).isTrue();
        assertThat(memberPage.hasNext()).isTrue();
    }

Page 가 가지고 있는 기능들 중에, totalPage 나 totalElements 이런 것들은 좀 필요 없는데 좀 더 가벼운 같은 기능은 없나? (count 쿼리를 매번 호출하는게 약간 불만일때)

Page 가 상속받고 있는 Slice 를 활용하면 됨!

Page -> Slice

Page 경우

Slice 경우

Slice 의 경우 limit 보다 하나 더 들고와서, hasNext 에 대한 대응을 한다!!

Page 의 경우 3개를 불러오고, Slice 는 4개를 불러온다

Slice -> List

근데 Slice 까지도 필요 없어. 그냥 데이터 몇개 끊어서 가져와!! 하는 경우에는 이것도 가능

기존의 여러 메소드들을 전혀 사용할 수 없음!!

덧

total count 의 경우 복잡한 연관관계에 맞춰 성능이 저하될 수 있음.(join 등) 사실 테이블의 한 필드값만 접근해서 개수만 세어도 되는 건데!! 해당 쿼리를 따로 간단하게 제한하는 방법이 존재!!

Team 값을 함께 가져오는 join query 를 만들었다고 하자.

잘 보면, count를 하는데도 left join 이 들어간다! counter query 가 table join 을 할 필요는 없음!

그래서, 이런식으로 추가해서 해줄 수 있다!

countQuery 항목에 새로 넣어서, count에 복잡한 쿼리가 나가지 않도록 할 수 있음!!

덧1

외부 API 로 반환할때는 이런식으로 mapping 해서 DTO 로 보낼 수 있도록!

벌크성 수정 쿼리

순수 jpa

    public int bulkAgePlus(int age) {
        return em.createQuery("update Member m" +
                        " set m.age = m.age + 1" +
                        " where m.age >= :age")
                .setParameter("age", age).executeUpdate();
    }

이런 쿼리를 날림!

스프링 데이터 JPA

    @Modifying // 이게 있어야 executeUpdate() 를 실행함! 필수임!
    @Query("update Member m set m.age = m.age + 1 where m.age >= :age")
    int bulkAgePlus(@Param("age") int age);

@Modifying 필수!!

테스트 코드

    @Test
    public void bulkUpdate() throws Exception {
        // given
        Member m1 = new Member("aaa", 10);
        Member m2 = new Member("bbb", 20);
        Member m3 = new Member("ccc", 10);
        Member m4 = new Member("ddd", 10);
        Member m5 = new Member("eee", 20);
        Member m6 = new Member("fff", 10);
        Member m7 = new Member("ggg", 10);
        Member m8 = new Member("hhh", 20);

        memberRepository.save(m1);
        ...
        memberRepository.save(m8);

        // when
        int resultCount = memberRepository.bulkAgePlus(15);
        System.out.println("resultCount : " + resultCount);

        // then
        assertThat(resultCount).isEqualTo(3);
    }

주의해야할 사항이 있음!

update 벌크 연산의 경우, 영속성 컨텍스트를 거치지 않고 진행됨!

      ...
      Member m = new Member("hhh", 20);
      ...
      memberRepository.save(m);

      // when
      int resultCount = memberRepository.bulkAgePlus(15);
      System.out.println("resultCount : " + resultCount);

      Member memberH1 = memberRepository.findMemberByUsername("hhh");
      System.out.println("memberH1 : " + memberH1); // Member(id=8, username=hhh, age=20)

      em.clear();

      Member memberH2 = memberRepository.findMemberByUsername("hhh");
      System.out.println("memberH2 : " + memberH2); // Member(id=8, username=hhh, age=21)

영속성 컨텍스트를 거치치 않고 DB 업데이트 쿼리를 날리기 때문에, 업데이트 된 값을 사용하고 싶으면, clear 를 해주어야함

가능하면 벌크연산 후에 EntityManager 를 flush, clear 해버려라!! 업데이트 함수에서 먼저 flush 를 실행함!!

이걸 생략하고 싶으면, @Modifying(clearAutomatically = true) 추가

  @Modifying(clearAutomatically = true)
  @Query("update Member m set m.age = m.age + 1 where m.age >= :age")
  int bulkAgePlus(@Param("age") int age);

// em.clear();

@EntityGraph

평범하게 findAll 쿼리메소드를 활용하면, lazy 같은 것들은 어떻게 해결 할까? 여기서 fetch 조인은 어떻게 해야할까!!

무조건 @xToOne 관계에 있는 요소들을 N+1 문제가 있다고, fetch 조인 하는 것은 아님
상황에 따라 fetch 조인 하지 않는 경우도 있음!!

    @Query("select m from Member m left join fetch m.team")
    List findMemberFetchJoin();

Query 어노테이션을 활용해서, 이와 같이 하면 된다!

그런데 이것마저 귀찮다!!!!! @EntityGraph 로 해결!!!

public interface MemberRepository extends JpaRepository {
    ...
    @Override
    @EntityGraph(attributePaths = {"team"})
    List findAll();
}

findAll 자체에 fetch join 을 @Override 하면서, @EntityGraph 설정!!

    @Query("select m from Member m left join m.team")
    @EntityGraph(attributePaths = {"team"})
    List findMemberEntityGraph();

이렇게 쓰는 것도 가능하다!!

쿼리 메소드의 경우도 @EntityGraph 를 추가하면서, fetch join 기능이 가능하도록 해줌!!

JPA Hint & Lock

find 하고 나서, 영속성 컨텍스트 관리 안해도 됨!!
수정할 일도 없고, 삭제할 일도 없어!! 그 데이터 그대로 사용만 할거야!
변경감지 이런거 필요 없어!! (기존)

Transaction 이 끝나는 (flush 가 일어남) 시점에 update 쿼리가 실행됨.

하지만, @QueryHints 와 @QueryHint 를 통해 read only 라는 설정을 주게 되면

public interface MemberRepository extends JpaRepository {
    ...
    @QueryHints(value = @QueryHint(name = "org.hibernate.readOnly", value = "true"))
    Member findReadOnlyByUsername(String username);
}

분명 setUsername을 하여, findMember 에 변경이 일어났는데 이를 체크하지 않고 업데이트 쿼리를 실행하지 않음!! (각 엔티티마다 스냅샷을 지정해주고, 변경감지 등의 리소스를 사용하는 행위들을 하지 않도록 하여 성능을 향상 시킨다!!)

우리 서버 트래픽이 너무너무 많아서 최적화 시키는게 아닌 이상, 이 Read-only 기능은 다른 최적화들에 비해 미미하다!! 페치 조인, 페이징 등등이 훨씬 더 중요!

Lock 이라는 기능도 있는데, 동시 접근하여 수정을 하게 되면 안되므로, lock을 걸어 권한 있는 쪽만 수정하도록 하는 것!! 실무에서 꽤나 중요해 보임!! https://velog.io/@backtony/JPA-Lock 꼭 따로 공부해야함!

스프링 데이터 JPA - 세팅

Mon, 17 Apr 2023 12:16:23 GMT

한계를 넘어 마법 같은 기술

세팅

스프링 부트 스타터 : https://start.spring.io

왜인지 잘 안됨. 그냥 이거 복붙해서 gradle 돌리기!!

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.10'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'
}

group = 'study'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

tasks.named('test') {
    useJUnitPlatform()
}

Settings > Build, Execution, Deployment > Build Tools > Gradle > ... InteilliJ IDEA 로 변경

Settings > Build, Execution, Deployment > Compiler > Annotaion Processors > Enable annotation processing 체크!! (lombok 사용)

H2 세팅 첫 JDBC URL : jdbc:h2:~/datajpa 이후에는 : jdbc:h2:tcp://localhost/~/datajpa

Application.yml 세팅 처음엔 application.properties 가 있음 -> application.yml 만들고 지워주기!

spring:
  datasource:
    url: jdbc:h2:tcp://localhost/~/datajpa
    username: sa
    password:
    driver-class-name: org.h2.Driver
  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        # show_sql: true
        format_sql: true

logging.level:
  org.hibernate.SQL: debug
  # org.hibernate.type: trace

JPA 연결 설정, DB 동작 확인

@Entity
@Getter @Setter
public class Member {
    @Id
    @GeneratedValue
    private Long id;

    private String username;

    protected Member(){}

    public Member(String username) {
        this.username = username;
    }
}

protected Member(){} JPA 에서 엔티티 생성할때, 프록시로 구현할 때도 있어서, protected 레벨까지는 빈 Constructor를 열어주어야함!! 덧. @NoArgsConstructor(access = AccessLevel.PROTECTED) 로 대체 가능

@Repository
@RequiredArgsConstructor
public class MemberJpaRepository {
    private final EntityManager em;

    public Member save(Member member){
        em.persist(member);
        return member;
    }

    public Member find(Long id){
        return em.find(Member.class, id);
    }
}

test code

class MemberJpaRepositoryTest {

    @Autowired MemberJpaRepository memberJpaRepository;
    @Test
    public void testMember() throws Exception {
        // given
        Member member = new Member("memberA");
        Member saveMember = memberJpaRepository.save(member);

        // when
        Member findMember = memberJpaRepository.find(saveMember.getId());
        // then
        assertThat(findMember.getId()).isEqualTo(member.getId());
        assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
        assertThat(findMember).isEqualTo(member);
    }
}

public interface MemberRepository extends JpaRepository {
    // 이걸로 끝, interface 라는 점!!
}

test code

class MemberRepositoryTest {
    @Autowired MemberRepository memberRepository;

    @Test
    public void testMember() throws Exception {
        // given
        Member member = new Member("memberA");
        Member saveMember = memberRepository.save(member);

        // when
        Member findMember = memberRepository.findById(saveMember.getId()).get();
        // then
        assertThat(findMember.getId()).isEqualTo(member.getId());
        assertThat(findMember.getUsername()).isEqualTo(member.getUsername());
        assertThat(findMember).isEqualTo(member);
    }
}

memberRepository 내부에 메소드가 엄청 많다!! (save, findById 등등) 아무것도 해준게 없는데!!!

ctrl + p 자료형, 파라미터 알려주는!! get() 을 쓸때 예외처리 해주는게 맞음. 지금은 그냥 편의상 하는 것!!

query 파라미터를 로그로 남기는 외부 라이브러리가 있음 (운영 시스템에서는 꼭 성능 테스트 ㄱ) implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.5.7'

스프링부트 3.0 이상 버전부터는 추가 세팅이 필요함!!

도메인 모델

@Entity
@Getter
@Setter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@ToString(of = {"id", "username", "age"})
public class Member {
    @Id
    @GeneratedValue
    @Column(name="member_id")
    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 = username;
    }
}

덧. JPA 에서 모든 @xToOne 관계는 FetchType.LAZY 로 설정해줘라!

@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 member = new ArrayList();
}

jpa-spring boot - api OSIV

Mon, 17 Apr 2023 05:48:22 GMT

OSIV 와 성능 최적화

Open Session In View : 하이버네이트
Open EntityManger in View : JPA (관례상 OSIV 라 함)

open in view - true

spring.jpa.open-in-view true 가 기본값

true 일때는, transaction 이 끝나더라도 영속성 컨텍스트를 유지하고 있음. (데이터 베이스 커넥션을 유지) 화면이 렌더링 될때까지 혹은, Api 값이 반환 될때까지!

그래야, transaction 사용하는 서비스 계층 외부에서 사용되는 것들에서 활용이 가능하기 때문에!!

Lazy 로딩 을 할 수 있는 등, 데이터베이스 커넥션을 유지해준다!!

그런데 이 전략은... 오랜시간동안 데이터베이스 커넥션 리소스를 사용하기 때문에, 실시간 트래픽이 중요한 애플리케이션에서는 커넥션이 모자랄 수 있음!! -> 이는 장애로 이어질 수 있다. 만약 api Controller 에서 외부 API 를 반환하게 되면, 그 시간 만큼 커넥션 리소스를 붙잡고 있게 되고, 이는 리소스의 부족을 야기!!

open in view - false

데이터 베이스 커넥션 리소스를 낭비하지 않음! 하지만 lazy 로딩 같은 기능들은 트랜잭션 내 에서 해결이 되어야함! 트랜잭션 외부에서 쉽게 사용하던 것들을 트랜잭션 내부로 옮겨야함

기존에 lazy 로딩으로 잘 되던것들이, proxy 객체로 넘어오게 됨! (에러)

open in view - false 기법

OrderQueryService 만들기

이 서비스 계층에서 모든 걸 처리한 뒤에, Controller 로 내보내기!!

이런식으로 따로 만들어서, 최종적으로 데이터가 다 담겨 있는 데이터를 넘겨주기!!

커맨드와 쿼리를 구분하는 것이 좋다

커맨드 : C, U, D

쿼리 : Read (조회)

보통의 성능 문제는 쿼리에서 일어남!! 이 둘을 분리하는 것은 유지보수 관점에서 충분히 의미 있음.

OrderService: 핵심 비즈니스 로직
OrderQueryService: 화면이나 API에 맞춘 서비스 (주로 읽기 전용 트랜잭션 사용)

고객 서비스의 실시간 API 는 OSIV 를 끄고 ADMIN 사이트 처럼 커넥션을 많이 사용하지 않는 곳에서는 OSIV 를 켠다.

스프링 데이터 JPA

기본적으로 중복되는 메소드들을 줄이기 위해, 시작한 프로젝트!!

기존

@Repository
@RequiredArgsConstructor
public class MemberRepository {

    private final EntityManager em;

    public void save(Member member){
        em.persist(member);
    }
    public Member findOne(Long id){
        return em.find(Member.class, id);
    }

    public List findAll(){
        return em.createQuery("select m from Member m", Member.class).getResultList();
    }

    public List findByName(String name){
        return em.createQuery("select m from Member m where m.name= :name", Member.class)
                .setParameter("name", name)
                .getResultList();
    }

}

이후

public interface MemberRepository extends JpaRepository {
    List findByName(String name);
}

Repository 들이 기본적으로 제공할 것 같은 것들 메소드로 싹 저장 되어 있음!! 심지어 findByName 도 메소드 이름을 보고, 알아서 완성된다! => select m from Member m where m.name = :name 으로 jpql 쿼리

다른 계층에서 사용하는 findOne() 은 findById() 로 바꾸어 주면 됨!

// 이전
return memberRepository.findOne(memberId);
// 이후
return memberRepository.findById(memberId).get();

interface 로 해놔도, spring에서 알아서 주입을 해줌!!

QueryDSL

jpql 쿼리를 java 문법으로 바꿈!

세팅

build.gradle

QueryDSL 을 사용하려면 build.gradle 에 dependencies 추가해줘야함

//querydsl 추가
buildscript {
    ext {
        queryDslVersion = "5.0.0"
    }
}

plugins {
    id 'java'
    id 'org.springframework.boot' version '2.7.10'
    id 'io.spring.dependency-management' version '1.0.15.RELEASE'

    //querydsl 추가
    id 'com.ewerk.gradle.plugins.querydsl' version '1.0.10'
}


group = 'jpabook'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-devtools'
    implementation 'com.github.gavlyukovskiy:p6spy-spring-boot-starter:1.5.6'
    implementation 'com.fasterxml.jackson.datatype:jackson-datatype-hibernate5'
    testImplementation 'junit:junit:4.13.1'
    compileOnly 'org.projectlombok:lombok'
    runtimeOnly 'com.h2database:h2'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    //querydsl 추가
    implementation "com.querydsl:querydsl-jpa:${queryDslVersion}"
    implementation "com.querydsl:querydsl-apt:${queryDslVersion}"
}

tasks.named('test') {
    useJUnitPlatform()
}
//querydsl 추가
def querydslDir = 'src/main/generated'
//def querydslDir = "$buildDir/generated/querydsl"

querydsl {
    library = "com.querydsl:querydsl-apt"
    jpa = true
    querydslSourcesDir = querydslDir
}
sourceSets {
    main {
        java {
            srcDirs = ['src/main/java', querydslDir]
        }
    }
}
compileQuerydsl {
    options.annotationProcessorPath = configurations.querydsl
}
configurations {
    querydsl.extendsFrom compileClasspath
}

compileQuerydsl

사용

    public List findAllByQueryDSL(OrderSearch orderSearch){
        QOrder order = QOrder.order;
        QMember member = QMember.member;

        JPAQueryFactory query = new JPAQueryFactory(em);

        return query.select(order)
                .from(order)
                .join(order.member, member)
                .limit(1000)
                .fetch();
    }

메소드 체인으로 쉽게 구현 가능! 문자열 에러 걱정할 필요도 없음!!

조건을 걸고 싶을땐

이런 식들로 메소드 안에서 편하게 condition 적용 가능! (이런건 재사용도 됨)

QueryDSL generate 된 파일들은 .gitignore 에 포함시키기!!

jpa-spring boot - api 실습 (3)

Mon, 17 Apr 2023 05:48:14 GMT

컬렉션 조회 최적화 (OneToMany)

OrderItems 조회 V1

    @GetMapping("/api/v1/orders")
    public List ordersV1(){
        List all = orderRepository.findAll(new OrderSearch());
        for (Order order : all) {
            // 강제 초기화
            order.getMember().getName();
            order.getDelivery().getAddress();
            List orderItems = order.getOrderItems();
            orderItems.stream().forEach(o -> o.getItem().getName());
        }

        return all;
    }

<이건 기본적으로 추가해줘야하는!>
    @Bean
    Hibernate5Module hibernate5Module() {
        return new Hibernate5Module();
    }

강제로 프록시 초기화를 시켜주어, orderItems 각 객체마다, orderItem 프록시를 초기화 시켜주어 name에 값을 불러온다.

데이터는 잘 불러와지나, 각각 프록시 강제 초기화마다 sql 문을 날리는 것을 확인할 수 있음.
엔티티를 직접 노출하기 때문에, api 스펙이 Entity의 영향을 받게 됨

OrderItems 조회 V2 - DTO화

일단 DTO 를 만들자

    @GetMapping("/api/v2/orders")
    public List ordersV2(){
        List all = orderRepository.findAll(new OrderSearch());
        List collect = all.stream().map(o -> new OrderDto(o)).collect(Collectors.toList());
        return collect;
    }

    @Data
    static class OrderDto {
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List orderItems;


        public OrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getDelivery().getAddress();
            order.getOrderItems().stream().forEach(o -> o.getItem().getName());
            orderItems = order.getOrderItems();
        }
    }

이제 Entity의 변경에 Api 스펙이 변경되는 일은 없다! (컴파일 에러로 잡을 수 있게 됨) @Data 는 api 끝단에서 역할!

DTO 안에 Entity 가 있는 것은 좋지 않음! 직접적으로 1차 Api 스펙에는 영향을 주지 않지만, 내부 Entity 속성이 그대로 노출됨 (OrderItem, Item)

엔티티에 대한 의존을 완전하게 끊어야함!! 귀찮더라도,List< OrderItem > 을 전부 DTO 로 변환해 주어야함

    @Data
    static class OrderDto {
        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
        private List orderItems; // DTO로 수정

        public OrderDto(Order order) {
            orderId = order.getId();
            name = order.getMember().getName();
            orderDate = order.getOrderDate();
            orderStatus = order.getStatus();
            address = order.getDelivery().getAddress();

            // DTO 로 수정
            orderItems = order.getOrderItems().stream().map(o -> new OrderItemDto(o)).collect(Collectors.toList());
        }
    }

    // 새로운 DTO
    @Data
    static class OrderItemDto {
        private String itemName;
        private int orderPrice;
        private int count;
        public OrderItemDto(OrderItem orderItem) {
            itemName = orderItem.getItem().getName();
            orderPrice = orderItem.getOrderPrice();
            count = orderItem.getCount();
        }
    }

원하는 정보들만 뽑아내서 DTO로 만들 수 있음!!

OrderItems 조회 V3 - fetch join

    @GetMapping("/api/v3/orders")
    public List ordersV3(){
        List all = orderRepository.findAllWithItem();
        List collect = all.stream().map(o -> new OrderDto(o)).collect(Collectors.toList());
        return collect;
    }


    public List findAllWithItem() {
        return em.createQuery(
                "select o from Order o" +
                " join fetch o.member m" +
                " join fetch o.delivery d" +
                " join fetch o.orderItems oi" +
                " join fetch oi.item i", Order.class).getResultList();
    }

이처럼 fetch join 하면 될 것 같음!!

(이 사진도 다가 아님) 정말 어마무시한 쿼리문 하나가 나가는 것을 볼 수 있다!! n 번의 쿼리를 날리면서 성능을 잡아먹다가, 한번으로 최적화된 모습!

Fetch Join 의 고질적인 문제인, 테이블 데이터 중복!! 데이터를 받아보면 티가 난다! 같은 id 값이 두번 들어옴!!

Database 입장에서는 table join 이 되어버린 것임! (데이터 뻥튀기)

아이러니하게도 같은 참조값을 가지기는 함! jpa 가 자체적으로 같은 객체로 만들지만, 알아서 하나로 보내주지는 않음!! 기억나는가? 어떤걸 써야하는지? 바로 Distinct

    public List findAllWithItem() {
        return em.createQuery(
                "select distinct o from Order o" +
                " join fetch o.member m" +
                " join fetch o.delivery d" +
                " join fetch o.orderItems oi" +
                " join fetch oi.item i", Order.class).getResultList();
    }

이제 중복없이 잘 나온다!!

SQL 문에서의 distinct 와 무엇이 다를까? DB Query 에서의 행동이 다르다기 보다는! (이거는 distinct 가 있으나 없으나 같음) JPA 에서 자체적으로 버려주는 기능임!!! (들어오는 데이터는 뻥튀기 된 채로 들어옴)

엄청난 제약 조건 (fetch 조인)

치명적인 단점 하나가 있음!!!!!!!!!!!!!!!!!!!!! 진정한 의미의 페이징 이 불가능해진다 전부다 받아온 다음에, 그 데이터를 기반으로 페이징처럼 출력을 함!!

메모리 관점에서 의미 퇴색 (n개의 데이터를 다 불러오고, 그 중 몇개를 반환하는 꼴)
진정한 의미의 페이징 애매 (distinct 일때는 비슷하게 가능하긴 하지만...) order 기준으로 페이징 하는 것이 아닌, 다 쪽의 item 기준으로 페이징이 일어남

(hibernate에서도 warn 창을 띄워줌)

일대다의 경우엔 오히려 fetch join 을 사용하지 않는 것이 좋음!

🔶🔶 일대다(컬렉션) fetch join 금지!!!!!! 🔶🔶

10만개의 데이터가 메모리에 한방에 불러와진다면...!!
오우... 대형사고...
작은 데이터라는 것이 확실하면, 상관 없긴 함
컬렉션 페치 조인은 2개 이상 사용 금지!!

OrderItems 조회 V3.1 - 페이징 & 한계 돌파

페이징도 하고, 컬렉션 엔티티를 함꼐 조회하려면 어떻게 해야할까!! (아주 비장하게) 지금부터 코드도 단순하고, 성능 최적화도 보장하는 매우 강력한 방법을 소개하겠다!

기존에 @xToOne 은 전부 fetch join 나머지는 하나씩 프록시 초기화 시키면서 들고오는 거 대신, batch 로 들고오는 방법으로!!


  jpa:
    hibernate:
      ddl-auto: create
    properties:
      hibernate:
        format_sql: true
        default_batch_fetch_size: 100

그러면 sql query 문이 세번만 일어남!! 100개의 프록시 초기화를 동시에 진행한다고 생각하면 됨! (lazy 걸려있는 모든 프록시들)

Order : fetch join (1) <= batch 전 1
OrderItem : batch (1) <= batch 전 n
Item : batch (1) <= batch 전 n

batch 사이즈 설정만으로도! 1 / n / n ======>>>> 1 / 1 / 1 처럼 구현할 수 있음 (batch 사이즈에 따라 약간 차이)

각각 프록시 초기화를 사용한다면, query sql 효율성이 떨어지고,

모두 fetch join 을 사용한다면, 메모리 이슈 / 페이징 이슈가 생김

1) batch를 활용해서 쿼리 듬성듬성 날리기 2) @xToOne 관계에만 fetch join 사용! 2-1) join을 안하기 때문에, @OneToMany 일때 fetch join 은 데이터 뻥튀기가 일어나기에, 데이터 전송량 자체를 줄여주는 효과도 있음!! (이거 만개라고 생각하면, 데이터 양이 어마무시함)

꼭 글로벌하게 설정할 필요는 없음 @BatchSize(size = 100) 이런식으로 지정 가능

결론

@xToOne 관계는 fetch join 해도 페이징에 영향을 주지 않는다. 따라서 @xToOne 관계는 fetch join 으로 쿼리수를 줄이고

나머지는 batch size 를 설정하여 최적화!!

사이즈를 얼마로 두는 것이 좋은가? maximum 은 보통 1000 으로 보는 편!! (100 ~ 1000 사이 권장) 애매하면 100, 500 으로 두고 쓰셈!

OrderItems 조회 V4 - DTO 로 조회 (1)

OrderRepository 에 구현하는 것이 아닌, 새롭게 OrderQueryRepository 를 만들어서 따로 관리!!

@Data
public class OrderItemQueryDto {
    @JsonIgnore
    private Long orderId;
    private String itemName;
    private int orderPrice;
    private int count;

    public OrderItemQueryDto(Long orderId, String itemName, int orderPrice, int count) {
        this.orderId = orderId;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

@Data
public class OrderQueryDto {
    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;
    private List orderItems;

    /**
     * collection 을 바로 주입 받을 수가 없음
     * 해당 DTO Constructor 는 jpql 에서 사용됨.
      */
    public OrderQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address/*, List orderItems*/) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.orderItems = orderItems;
    }
}

@Repository
@RequiredArgsConstructor
public class OrderQueryRepository {
    private final EntityManager em;

    public List findOrderQueryDtos(){
        List result = findOrders();
        result.forEach(o -> {
           List orderItems = findOrderItems(o.getOrderId());
           o.setOrderItems(orderItems);
        });
        return result;
    }

    private List findOrderItems(Long orderId) {
        return em.createQuery("select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, i.name, oi.orderPrice, oi.count)" +
                        " from OrderItem oi" +
                        " join oi.item i" +
                        " where oi.order.id = :orderId", OrderItemQueryDto.class)
                .setParameter("orderId", orderId)
                .getResultList();
    }

    private List findOrders() {
        return em.createQuery("select new jpabook.jpashop.repository.order.query.OrderQueryDto(o.id, m.name, o.orderDate, o.status, d.address)" +
                        " from Order o" +
                        " join o.member m" +
                        " join o.delivery d", OrderQueryDto.class)
                .getResultList();
    }
}

Query 문 : 루트 1번, 컬렉션 N번 (for 문 돌면서) ToOne 관계들을 먼저 조회하고, ToMany(1:N) 관계는 각각 별도로 처리한다. row 수가 증가하지 않는 ToOne 관계는 조인으로 최적화하기 쉬우므로 한번에 조회하고, ToMany 관계는 최적화하기 어려우므로 findOrderItems() 같은 별도의 메소드로 조회

이런 방식은 N+1 문제를 야기한다.

OrderItems 조회 V5 - DTO 로 조회 (2)

    public List findAllByDto_optimization(){
        List result = findOrders();

        List orderIds = result.stream().map(o -> o.getOrderId()).collect(Collectors.toList());

        List orderItemQueryDtos = em.createQuery("select new jpabook.jpashop.repository.order.query.OrderItemQueryDto(oi.order.id, i.name, oi.orderPrice, oi.count)" +
                        " from OrderItem oi" +
                        " join oi.item i" +
                        " where oi.order.id in :orderIds", OrderItemQueryDto.class)
                .setParameter("orderIds", orderIds)
                .getResultList();

        Map> orderItemMap = orderItemQueryDtos.stream().collect(Collectors.groupingBy(orderItemQueryDto -> orderItemQueryDto.getOrderId()));

        result.forEach(o -> o.setOrderItems((orderItemMap.get(o.getOrderId()))));

        return result;
    }

in 을 활용해서 한방에 다 가져오기! OrderItemQueryDto 에 orderId 를 넣은 이유가 여기에 있었음!!

v4 와 다른 점은 query 문을 한번만 날린다는 것!!

OrderItems 조회 V6 - DTO 로 조회 (3)


@Data
public class OrderFlatDto {

    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;

    private String itemName;
    private int orderPrice;
    private int count;

    public OrderFlatDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address, String itemName, int orderPrice, int count) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
        this.itemName = itemName;
        this.orderPrice = orderPrice;
        this.count = count;
    }
}

plat 형태로 DTO를 설정하여, 직접 jpql 을 설정하면, query 문은 한방에 나간다! (페이징은 x)

    public List findAllByDto_flat(){
        List orderFlatDtoList = em.createQuery("select new" +
                " jpabook.jpashop.repository.order.query.OrderFlatDto(o.id, m.name, o.orderDate, o.status, d.address, i.name, oi.orderPrice, oi.count)" +
                " from Order o" +
                " join o.member m" +
                " join o.delivery d" +
                " join o.orderItems oi" +
                " join oi.item i", OrderFlatDto.class).getResultList();
        return orderFlatDtoList.stream()
                .collect(groupingBy(o -> new OrderQueryDto(o.getOrderId(),
                                o.getName(), o.getOrderDate(), o.getOrderStatus(), o.getAddress()),
                        mapping(o -> new OrderItemQueryDto(o.getOrderId(),
                                o.getItemName(), o.getOrderPrice(), o.getCount()), toList())
                )).entrySet().stream()
                .map(e -> new OrderQueryDto(e.getKey().getOrderId(),
                        e.getKey().getName(), e.getKey().getOrderDate(), e.getKey().getOrderStatus(),
                        e.getKey().getAddress(), e.getValue()))
                .collect(toList());
    }

추가적으로 DB 쪽 아닌, 코드 단에서 OrderQueryDto 형태로 매핑을 해주어 변환해주면 된다!

쿼리 한방에 원하는 기능을 할 수 있게 됨!!

OrderQueryDto 에 해당 어노테이션을 달아줘야, 매핑이 정상 작동!!

V5 (컬렉션 조회 최적화) vs V6 (플랫데이터 최적화)

V5는 쿼리 2번, V6는 쿼리 1번

V6는 쿼리가 1번이지만 조인으로 인해 중복 데이터가 추가되므로, 상황에 따라 더 느릴 수도 있음!

애플리케이션 추가 작업이 큼! + 페이징 x

요약 정리

엔티티 조회

v1 - 엔티티 그대로 반환

큰일 난다! 엔티티 스펙이 변함에 따라 API 스펙이 변함

v2 - DTO 로 변환

이때 문제는, 성능이 안나올 때가 있음!

v3 - 페치 조인으로 쿼리수 최적화

fetch join 으로 하면, 페이징이 힘들때가 있음

v3.1 - 컬렉션 페이징과 한계돌파

@xToOne 관계는 페치 조인으로 쿼리 수 최적화
컬렉션 은 지연 로딩을 유지하되, @BatchSize 로 최적화

DTO 직접 조회

v4 - JPA에서 DTO 조회

쿼리문을 많이 날려야함.

v5 - 컬렉션 조회 최적화

in jpql 문을 활용하여 쿼리 한방으로 '다' 를 불러옴

v6 - 플랫 데이터 최적화

어플리케이션 단에서 매핑하여 원하는 형태로 사용

권장 순서

1. 엔티티 조회

* 1-1. 페치 조인 (쿼리 수 최적화)

* 1-a. 컬렉션 최적화 (페이징 여부에 따라)

2. DTO 조회

* 2-a. 최적화

3. NativeSQL or JdbcTemplate

Why?

엔티티의 경우 여러 기능들을 손쉽게 적용 가능
DTO 의 경우 최적화에 코드 변경이 많이 필요하다!

개발자는 성능 최적화와 코드 복잡도 사이에서 줄타기! 보통 성능 최적화는 단순한 코드를 복잡한 코드로 몰고감

DTO 조회 방식의 선택지 각 v4, v5, v6 는 엔티티로 했다면 어노테이션으로 해결되는 문제들

단건 조회의 경우 V4
여러 주문을 한꺼번에 조회하는 경우 V5 (쿼리 수가 확 줄어듬)
V6 의 경우 실무에서는 페이징이 많기에, 활용되기 어려움!

DTO 직접 조회를 하다보면, 거의 V5를 하게 됨!

til_230415

Sat, 15 Apr 2023 11:16:48 GMT

react

SPA에서 화면 변경은 어떻게?

HTML 5 의 History API 를 사용해서 한다. 세션 관리!

react-router-dom

npm install react-router-dom --save --save 해주면, package.json 에 추가가 됨.

rfce

vscode 창에 rfce 하고 enter 하면 자동으로 export 가 되는 function을 만들어주게 하는 법! 요거 설치해주면 됨.

CSS Framework

기능을 만드는데 더 집중하기 위해!!

React Bootstrap

https://react-bootstrap.github.io/

다양한 기본 컴포넌트들을 import 해서 쉽게 사용 가능! (Button, Modal 등등)

설치 npm install react-bootstrap bootstrap --save

import "bootstrap/dist/css/bootstrap.min.css"; 추가

Clayful

backend 연동 솔루션 서비스! (다양한 커머스를 지원해주는!)

npm install clayful --save npm install axios --save

import clayful from "clayful/client-js";
import axios from "axios";

clayful.config({
  client: "TODO Client Token",
});

clayful.install("request", require("clayful/plugins/request-axios")(axios));

AuthContext

Context가 많아질 거기 때문에, 따로 Context들을 분리!

const AuthContextProvider = ({ children }) => {
  const [isAuth, setIsAuth] = useState(false);
  const navigate = useNavigate();

  const AuthContext = createContext();

  const signOut = () => {
    setIsAuth(false);
    localStorage.removeItem("accessToken");
    navigate("/login");
  };
  const isAuthenticated = () => {
    return;
    var Customer = clayful.Customer;
    let options = {
      customer: localStorage.getItem("accessToken"),
    };
    Customer.isAuthenticated(options, function (err, result) {
      if (err) {
        console.log(err.code);
        setIsAuth(false);
        return;
      }
      var data = result.data;
      if (data.authenticated) {
        setIsAuth(true);
      } else {
        setIsAuth(false);
      }
    });
  };

  const AuthContextData = {
    isAuth,
    isAuthenticated,
    signOut,
  };
  return (
    
      {children}
    
  );
};

export const AuthContext = createContext();

이런식으로 children 을 들고와서, 내부적으로 감싸주고

value 값은 AuthContextData 로 묶어주기
적절히 필요한 기능들 구현

사용은 이런식으로 하면 됨.

기타

 
<>
위 아래 같은 거임

dangerouselySetInnerHTML

dangerouslySetInnerHTML 은 브라우저 DOM에서 innerHTML을 사용하기 위한 React의 대채 방법.

react-bootstrap

Container, Row, Col 잘쓰면 반응형 대박!

til_230413_prisma

Thu, 13 Apr 2023 08:10:10 GMT

prisma 설치

npx install prisma

prisma 폴더와 .env 파일을 만들어줌!

파일

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mysql"
  url      = env("DATABASE_URL")
  relationMode = "prisma"
}

model User {
  id Int @id @default(autoincrement())
  account String @unique
  name String?
  todos Todo[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Todo {
  id Int @id @default(autoincrement())
  todo String
  isDone Boolean
  user User @relation(fields: [userId], references: [id])
  userId Int
  createAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  @@index([userId])
}

schema 에서 model 안에 주석을 넣으면 안됨!!!

planet scale 설치

DB 그 자체 라고 생각하면 됨.

윈도우 주의! 관리자 권한으로 하지 말것 ! PowerShell 에서 실행할 것!!

관리자 뭐시기 에러 뜰때

irm get.scoop.sh -outfile 'install.ps1' iex "& {$(irm get.scoop.sh)} -RunAsAdmin"

Scoop 설치

https://scoop.sh/ 에서 아래 명령어 2개 실행. (윈도우) ★터미널 파워쉘로 열기★ Set-ExecutionPolicy RemoteSigned -Scope CurrentUser irm [get.scoop.sh](http://get.scoop.sh/) | iex

planet scale 과정

https://github.com/planetscale/cli#installation 여기서 윈도우 / Mac에 따라 설치명령어 실행 윈도우 ↓ scoop bucket add pscale https://github.com/planetscale/scoop-bucket.git

scoop install pscale mysql

error 뜨는 경우

관리자 권한으로 실행
용량이 부족한 경우

planet scale 로그인

pscale auth login

실행

pscale connect todolist todolist : db 명 (미리 만들어놓은)

db 등록

위에서 실행해놓고, 틀어놓은 상태에서

npx prisma db push 하면 DB 상태가 푸쉬됨.

이것을 기반으로 SQL 이 작성되기 때문에, 수정이 되었다면, 다시 푸시를 해주어야함!!

prisma client

npm i @prisma/client

prisma studio

npx prisma studio 이런식으로 db 를 쉽게 접근/관리 할 수 있도록 도와주는 패키지!!

jpa-spring boot - api 실습 (2)

Wed, 12 Apr 2023 16:18:17 GMT

조회용 샘플 데이터 입력

@Component
@RequiredArgsConstructor
public class InitDb {

    private final InitService initService;

    @PostConstruct
    public void init(){
        initService.dbInit1();
        initService.dbInit2();
    }

    @Component
    @Transactional
    @RequiredArgsConstructor
    static class InitService {
        private final EntityManager em;
        public void dbInit1(){
            Member member = getMemberWidthNameAndAddressProps("user A", "서울", "1", "1245");
            em.persist(member);

            Book book1 = getBookWidthNamePriceStock("JPA1 bOOK", 10000, 100);
            em.persist(book1);

            Book book2 = getBookWidthNamePriceStock("JPA2 bOOK", 20000, 200);
            em.persist(book2);

            OrderItem orderItem1 = OrderItem.createOrderItem(book1, 10000, 1);
            OrderItem orderItem2 = OrderItem.createOrderItem(book2, 20000, 2);

            Delivery delivery = new Delivery();
            delivery.setAddress(member.getAddress());
            Order order = Order.createOrder(member, delivery, orderItem1, orderItem2);
            em.persist(order);
        }
        public void dbInit2(){
            ...
        }


        private static Member getMemberWidthNameAndAddressProps(String name, String cityName, String street, String zipcode) {
            ...
            return member;
        }

        private static Book getBookWidthNamePriceStock(String name, int price, int stock) {
            ...
            return book;
        }

    }
}

Spring 이 실행되면서, @PostConstruct 의 함수를 먼저 실행함! 이때 목업/샘플 데이터를 주입해주면 됨!!

지연 로딩과 조회 성능 최적화

지금부터 설명하는 내용은 정말 중요!! 대충 넘어가면 엄청난 시간을 날리고 인생을 허비하게 될 것임!! feat. 김영한 개발자님

simple order 조회 v1

    @GetMapping("/api/v1/simple-orders")
    public List ordersV1(){
        List all = orderRepository.findAll(new OrderSearch());
        return all;
    }

무난하게 List 를 json 파일로 바꿔줄 것 같은 식이다! 하지만!! json 으로 바꿔주는 과정에서,


    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "member_id")
    private Member member;

member를 타고


    @OneToMany(mappedBy = "member")
    private List orders = new ArrayList();

여기서 orders를 호출하여 이를 다시 json 화 시키는데, 이때 무한 루프가 발생한다!! 양방향 연관관계에서의 문제가 생김!

해결

@JsonIgnore 을 걸어주면 된다! 양방향 중에 한쪽은 무조건 걸어줘야함!! (일대다, 일대일 이던, 양방향이라면) Member OrderItem Delivery 다 바꿔주기

또 다른 이슈

class org.hibernate.proxy.poho.bytebuddy.ByteBuddyInterceptor 하는 친구가 뜬다. 바로, lazy loading 에 걸려있는 객체들이 json화 되는 과정에서 문제가 된 것!

지연 로딩인 경우, 그냥 뿌리지 말라고 지정해줄 수 있음!
해당 라이브러리를 다운로드 받아야함. (스프링부트가 알아서 버전 맞춰줌)


implementation 'com.fasterxml.jackson.datatype:jackson-datatype-hibernate5' // 추가

 추가
@Bean
Hibernate5Module hibernate5Module() {
    return new Hibernate5Module();
}

위 처럼, lazy loading 데이터들은 null로 넘어온다! lazy 로딩을 억지로 불러와서 data를 강제할 수 있는 속성도 추가할 수 있음! hibernate5Module.configure(Hibernate5Module.Featrue.FORCE_LAZY_LOADING, true);

엔티티를 직접 반환하는 api 는 여러모로 제약이 많다. json화, lazy loading 등 여러가지를 신경써줘야함.

왠만하면 DTO 로 변환해서 반환하자!!

lazy loading 때문에, eager 로 바꾸는 것이 아니라, 필요한 경우 페치 조인으로 ㄱㄱ

덧) 반환 값은 리스트로 보내는 일이 없도록하자! 추가적으로 필드 값을 수정할때, 확장이 용이 하지 않음


{
   newField: ~~~,
   data: [ ... ]
}


[
  ...
]

simple order 조회 v2

v1 에서의 엔티티 직접 반환을 해결하여, DTO를 세팅하면 아래와 같다.

    @GetMapping("/api/v2/simple-orders")
    public List ordersV2() {
        List orders = orderRepository.findAll(new OrderSearch());

        List orderDtoList = orders.stream()
                .map(o -> new SimpleOrderDto(o))
                .collect(Collectors.toList());

        return orderDtoList;
    }

    @Data
    static class SimpleOrderDto {
        public SimpleOrderDto(Order order) {
            this.orderId = order.getId();
            this.name = order.getMember().getName(); // LAZY 초기화
            this.orderDate = order.getOrderDate();
            this.orderStatus = order.getStatus();
            this.address = order.getDelivery().getAddress(); // LAZY 초기화
        }

        private Long orderId;
        private String name;
        private LocalDateTime orderDate;
        private OrderStatus orderStatus;
        private Address address;
    }

한계

lazy loading 으로 인한, 엔티티 개별로 query 호출!! (영속성 컨텍스트로 호출이긴 함) n + 1 문제 그렇다고 Lazy -> Eager로 바꾸면? NoNo! Fetch Join 튜닝!! ㄱㄱ

simple order 조회 v3

< OrderRespository.java >

    public List findAllWithMemberDelivery() {
        return em.createQuery("select o from Order o" +
                " join fetch o.member m" +
                " join fetch o.delivery d", Order.class).getResultList();


    }

Fetch Join 을 활용하여, 애초에 값을 다 가지고오기! JPA 가 고맙게도 쿼리를 한방에 작성해서 날려줌

100% 이해할 것!!!! 거의 이게 성능의 90퍼센트 임!!!


    @GetMapping("/api/v3/simple-orders")
    public List ordersV3() {

        List orders = orderRepository.findAllWithMemberDelivery();

        List result = orders.stream()
                .map(o -> new SimpleOrderDto(o))
                .collect(Collectors.toList());

        return result;
    }

v2 와 결과는 같지만! 실행하는 Query 개수가 다름!!

simple order 조회 v4

JPA 에서 바로 DTO 로 조회!!


    @GetMapping("/api/v4/simple-orders")
    public List ordersV4() {
        return orderRepository.findOrderDtos();
    }


    public List findOrderDtos(){
        return em.createQuery("select new jpabook.jpashop.repository.OrderSimpleQueryDto(o.id, m.name, o.orderDate, o.status, d.address) from Order o" +
                " join o.member m" +
                " join o.delivery d", OrderSimpleQueryDto.class).getResultList();
    }


@Data
public class OrderSimpleQueryDto {
    public OrderSimpleQueryDto(Long orderId, String name, LocalDateTime orderDate, OrderStatus orderStatus, Address address) {
        this.orderId = orderId;
        this.name = name;
        this.orderDate = orderDate;
        this.orderStatus = orderStatus;
        this.address = address;
    }

    private Long orderId;
    private String name;
    private LocalDateTime orderDate;
    private OrderStatus orderStatus;
    private Address address;
}

차이점이라 하면!

Entity에 종속되어 DTO를 만들지 않고, Entity와 별개로 원하는 것만 얻어오는 DTO 를 만들 수 있다는 것!! (member 나 delivery 상세 정보 같은 것들 생략 가능)

하지만 재사용성이 떨어짐! 확장성은 거의 없기 때문에

V3 과 V4 는 Trade-Off 가 있음. 가급적 V3 를 추천!! 너무나도 많은 Traffic을 다루는 거라면, 해당 프로세스에 맞게 V4 방식으로 고치면 됨.

김영한 개발자님 실무 팁

repository 에 query api 스펙이 포함된 DTO 파일을 관리하는게, 뭔가 애매 (+ repository 의 return 값이 순수하지 않음) query 용 repository 를 따로 만드는 것으로 하는 편


@Repository
@RequiredArgsConstructor
public class OrderSimpleQueryRepository {
    private final EntityManager em;

    public List findOrderDtos(){
        return em.createQuery("select new jpabook.jpashop.repository.order.simplequery.OrderSimpleQueryDto(o.id, m.name, o.orderDate, o.status, d.address) from Order o" +
                " join o.member m" +
                " join o.delivery d", OrderSimpleQueryDto.class).getResultList();
    }
}


    ...
    private final OrderSimpleQueryRepository orderSimpleQueryRepository;
    ...    
    @GetMapping("/api/v4/simple-orders")
    public List ordersV4() {
        return orderSimpleQueryRepository.findOrderDtos();
    }
    ...

이런 식으로 새로운 repository 를 추가해서, Controller 나 Service 계층에서 사용하는 방식을 선호하심!! (V4의 경우)

정리

조회 방식

엔티티로 받아 DTO로 변환 후 전달 (V3)

-- 리포지토리 재사용성 좋음 -- 개발이 단순해짐 -- fetch join 활용 가능

DTO로 받아 그대로 전달 (V4)

-- 하게 된다면! -- 새로운 독립된 repository 를 만들어서, 주입시키는 것을 추천!

til_230411 ~ 12

Tue, 11 Apr 2023 12:29:42 GMT

Express Routing

< user.js >

const express = require("express");

const router = express.Router();

router.get("/:id", (req, res) => {
  res.send("유저 조회");
});

module.exports = router;

< app.js >

const express = require("express");
const userRouter = require("./routes/user");

const app = express();

const port = 3010;

app.use("/user", userRouter);

app.get("/", (req, res) => {
  res.send("Hello, Express!");
});

app.listen(port, () => {
  console.log(`Server listening on port: ${port} 🚀🚀🚀`);
});

Middle ware

요즘은 서버 짜놓으면, 알아서 문서화 까지 해주는 패키지가 있다고 함!!

실시간 개발 모드

nodemon <= npm i nodemon

< package.json >

npm run dev 로 실행하면, 파일 바뀔 때마다 서버 재시작!

json post 요청을 받지 못함! -> app.use(express.json()); 을 추가해주어, json 을 읽을 수 있도록 세팅!!

오류 보내기

  if (parseInt(id) >= todoData.length) {
    res.status(400).json({ error: "존재하지 않는 ID입니다." });
  }

포트

포트 번호는 공용 번호를 제외하고는(http, https 등) 커스텀하게 사용해도 됨!!

기타

에

"scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

SOP (Same-Origin Policy)

같은 출처를 가진 곳에서만 리소스를 요청할 수 있는 정책

교차 출처(다른 출처) 간의 리소스를 공유할 수 있는 정책
서버 <-> 브라우저 간에 check를 함
서버 <-> 서버 간에는 따로 check 하지 않음 (포스트맨에서는 잘 됨)

브라우저에서 해결을 해버리면, 문을 활짝 열어버리게 됨. 따로 웹사이트를 올릴때, 정책 추가해주기!

CORS 라이브러리 설치 후 , Express 미들웨어로 추가!

뜬금 덧

포커 아웃츠 남았을때, 확률계산하는 알고리즘 진행중...

식을 대충 요약하자면, 나올 수 있는 모든 커뮤니티 카드를 potentialCommunityCards 에 담아서, 그 모든 경우마다 누가 이기는지를 리스트에 저장한다.

핸드가 2명일때 프리플랍 : (52 - 4) C 5 : 1712304 핸드가 3명일때 프리플랍 : (52 - 6) C 5 : 1370754 핸드가 9명일때 프리플랍 : (52 - 18) C 5 : 278256

calculatePokerRank 라는 함수는 7장의 카드를 받아, 족보/카드를 출력해준다!

calculatePokerRank 호출 회수 핸드가 2명일때 프리플랍 : (52 - 4) C 5 : 1712304 * 2 : 3424608 핸드가 3명일때 프리플랍 : (52 - 6) C 5 : 1370754 * 3 : 4112262 핸드가 4명일때 프리플랍 : (52 - 8) C 5 : 1086008 * 4 : 4344032 핸드가 9명일때 프리플랍 : (52 - 18) C 5 : 278256 * 9 : 2504304

대략적으로 약 300 - 400만회의 calculatePokerRank 함수 호출이 일어난다! 평균 25초가 걸리는데... 이건 말이 안됨!!

https://www.cardplayer.com/poker-tools/odds-calculator/texas-holdem https://www.pokernews.com/poker-tools/poker-odds-calculator.htm

이런 사이트에서는 1초도 안걸려서 해주는데!!

노력 1. reduce 같은 함수가 오래걸리지 않을까?

포카드, 풀하우스, 트리플 확인할때, numList로 변환한뒤에, 각 개수를 확인하기 위해 reduce 함수를 쓰는데, 그럴 가치 조차 없는 카드들은 배제하기 (카드 개수가 많으면 뜰수가 없는!)

택도 없네... 여전히 25초대

노력 2. straight 에 쓸데없는게 많다

5,4,3,2,a 스트레이트를 확인하기 위해, 만든 함수 getBottomStraight 가 쓸데없이 많이 도는 것 같아, a,2,3,4,5 를 가지고 있을때만 실행하도록 함! 미미하지만 효과는 있는 것 같다!!

노력 3. reduce 함수의 중복

포카드, 풀하우스, 트리플, 투페어, 원페어 5개의 함수에서 reduce가 쓰이고 있다. 하나로 만들어서, 넘기면? 노력1은 수포로 돌아가지만, 효과는 있어보이는 느낌적인...?

흠 이게 효과가 있다고 해야할까? 진짜아 쬐끔 줌....

노력4. list 에 몇백만개 쌓이는게 느려지나?

쌓지 말고, 계속 더해보자!

이전

후

흠... 미미하다... 쬐금...

노력5. 7장의 카드에 대한 filter가 너무 많음

순서 :

스트레이트
플러시
포카드
풀하우스
트리플
투페어
원페어

각 모든 경우에, 배열값을 리턴함에 있어, 계속 filter 함수가 실행됨. cards를 다 넣지 말고, 숫자만 넣고, filter 를 쓰지 않는 걸로!

스트레이트만 바꿔줬는데!!

에라라아ㅏㅇ아 모르곘다

til_230410

Mon, 10 Apr 2023 08:36:01 GMT

Rest Api

* REpresentational State Transfer * 이렇게 쓰는 편 ( 자원의 이름과 전달 방식만으로 해당역할 추론 가능 )

조회 : Get
생성 : Post
업데이트 : Put
삭제 : Delete

REST API 특징

Server - Client 구조로 되어 있습니다.
자윈을 가지고 있는 쪽이 서버, 제공받는 쪽이 클라이언트가 됩니다.
Stateless(무상태)입니다.
HTTP 프로토콜을 사용하므로 HTTP 프로토콜처럼 무상태성을 가지고 있습니다.
클라이언트의 context를 서버에 저장하지 않습니다. (서버는 신경쓸 것 없이 본연에 업무에만 집중하면 됩니다.)
서버는 각각에 요청에 대한 응답만 하면 됩니다.

Rest API의 장, 단점

실습

Axios - http 통신을 위한 라이브러리 npm install axios

Insomnia (PostMan) - rest api 테스트 툴

(번외) React Icons npm install react-icons

이런 식으로 react-icons 불러올 수 있음!

async, await

Geolocation 사용! useEffect 에서 사용되는 함수 자체를 async 로 할 수 없다.

useEffect(async () => {
    await .... // 이런 방식은 동작하지 않음
}, []);

const getGeolocation = async () => {};

useEffect(async () => {
    getGeolocation(); // 이런식으로 사용이 되어야함.
}, []);

await 같은 비동기 함수를 활용할때는, try {} catch(e) {} 을 감싸는 것이 좋음
api 서버에서 오류를 주거나, 무한 로딩에 빠지는 경우 등을 catch 해서 처리해줘야함!

const getGeolocation = async () => {
    try{
        navigator.geolocation.getCurrentPosition((position) => {
            setLat(position.coords.latitude);
            setLon(position.coords.longitude);
        },
        () => {
            // 에러 콜백
            alert("위치 정보에 동의 해주셔야 합니다.");
        });
    } catch (e) {
           console.error(e); // error message
    }    
};

const getWeatherInfo = (_lat, _lon) => {
    ...
    return <날씨정보>;
};

함수는 최대한 캡슐화 시켜주는 것이 좋음!!

Promise

function checkPromise() {
  let promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("완료!"), 1000);
  });

  console.log("1초 대기");
  let result = promise;

  console.log(result);
}

checkPromise();

async function checkPromise() {
  let promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve("완료!"), 1000);
  });

  console.log("[await] 1초 대기");
  let result = await promise;

  console.log(result);
}
checkPromise();

Promise 함수 사용법!

resolve 콜백함수에, value를 넣어서 반환값 지정
reject 콜백함수에, value 넣어서 예외때 반환값

api key 값 보안

API KEY 같은 경우는, 외부로 유출되면 안되는 값이므로, 밖에서 보이지 않게 관리하는 것이 좋음

const getWeatherInfo = async () => {
    try {
      await axios.get(
        `https://api.openweathermap.org/data/2.5/weather?lat=${lat}&lon=${lon}&appid=${process.env.REACT_APP_WEATHER_API}&units=metric`
      );
    } catch (error) {
      console.error(error);
    }
  };

process.env.REACT_APP_WEATHER_API 를 통해 외부에서 입력 가능!

< .env >

REACT_APP_WEATHER_API=

주의! REACT_APP 을 앞에 꼭 붙혀주어야함!

.gitignore 파일에 .env 를 추가해주어야함!! (숨기는 의미가 없어짐)

API response error catch

    const response = await axios.get();

    if (response.status !== 200) {
        alert("날씨 정보를 가져오지 못했습니다.");
        return;
    }

보통 data가 없을때 2xx 서버 오류를 많이 만들어낸다! weather의 경우! 200!

API 테스트 툴

PostMan, Insomnia 같은 것들로 ㄱㄱ

const response = await axios.post("https://holy-fire-2749.fly.dev/chat",
      { question: "안녕?", },
      { headers: { Authorization: "Bearer BLOCKCHAINSHCOOL3" }
  });

코드로는 이런 형태를 띈다!

Chat GPT part

< Card.jsx >

const Chat = () => {
  const [question, setQuestion] = useState("");
  const [content, setContent] = useState("");
  const [isLoading, setIsLoading] = useState(false);

  const onSubmitChat = async (e) => {
    try {
      e.preventDefault();

      if (isLoading) {
        alert("검색중입니다...");

        return;
      }
      if (!question) {
        alert("질문을 입력해주세요.");

        return;
      }

      setIsLoading(true);
      setContent("");

      const response = await axios.post(
        "https://holy-fire-2749.fly.dev/chat",
        {
          //   question: `${question}`,
          //   question: question,
          question,
        },
        {
          headers: {
            Authorization: "Bearer BLOCKCHAINSCHOOL3",
          },
        }
      );

      if (response.status !== 200) {
        alert("오류가 발생했습니다.");
        setIsLoading(false);

        return;
      }

      console.log(response);
      setContent(response.data.choices[0].message.content);

      setIsLoading(false);
    } catch (error) {
      console.error(error);

      setIsLoading(false);
    }
  };

  return (
    
      
         setQuestion(e.target.value)}
        />
        
      
      {content && {content}}
    
  );
};

export default Chat;

preventDefault() 는 Enter 를 눌렀을때 자동으로 submit이 실행되는 것을 막기 위해!! Enter 를 누르면, 자동으로 submit 이 되는 것이 default

백엔드 Node js 세팅

npm install express --save

< package.json >

{
  "name": "node_test",
  "version": "1.0.0",
  "description": "changer",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "changer",
  "license": "MIT",
  "dependencies": {
    "express": "^4.18.2"
  }
}

Module System 이란?

모듈 시스템 등장 이전의 자바스크립트 개발은 < script src='…' > 로 불러와야 했습니다.

모듈 시스템의 등장으로 보기에 직관적이고 효율성 있게 됨

가장 많이 쓰이는 ES6 와 CommonJS

우리는 CommonJS 로 사용

< a.js >

function goModule() {
  console.log("Hello, Module!");
}

// export default goModule;
module.exports = goModule;

< b.js >

const goModule = require("./a");

goModule();

node b.js 입력

서버 세팅

CommonJS 방식으로, express 를 불러오기 < app.js >

const express = require("express");

const app = express(); // get express

const port = 3010; // server port num

app.get("/", (req, res) => {
  res.send("Hellow, Express!!");
}); // handler

app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

get 요청 (req, res) 파라미터를 받아, 요청을 처리함!

node app.js 로 실행

post의 경우!

app.post("/", (req, res) => {
res.send("This is Post Request");
});

그 외

한번더 리마인드

조회 : Get

생성 : Post

업데이트 : Put

삭제 : Delete

url path

app.get("/abc", (req, res) => {
res.send("Hello, ABC ABC!!");
});

react_230331

Mon, 10 Apr 2023 07:54:02 GMT

가상 DOM

Document Object Model (DOM)
html을 javascript 모델로 만든 것
리액트에서는 직접적으로 DOM을 사용하지 않음
리액트에서는 상태관리가 중요함! (useContext, Redux, SWR ...)

useState()

useState를 사용하지 않는다면!

jpa-spring boot 실습 - 4

Sun, 09 Apr 2023 12:10:10 GMT

Order

order 같은 복잡한 class 같은 경우는 별도의 생성 메소드가 있으면 좋음

@Entity
@Table(name = "orders")
@Getter @Setter
public class Order {
  @Id @GeneratedValue
  @Column(name = "order_id")
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "member_id")
  private Member member;

  @OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
  private List orderItems = new ArrayList();

  // 주로 접근하는 것에 FK (Foreign 키를 두는 편) <- 연관관계 주인
  @OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
  @JoinColumn(name = "delivery_id")
  private Delivery delivery;

  private LocalDateTime orderDate;

  @Enumerated(EnumType.STRING)
  private OrderStatus status;

  // == 연관관계 편의 메서드 ==  //
  public void setMember(Member member){
      this.member = member;
      member.getOrders().add(this);
  }

  public void addOrderItem(OrderItem orderItem){
      orderItems.add(orderItem);
      orderItem.setOrder(this);
  }

  public void setDelivery(Delivery delivery){
      this.delivery = delivery;
      delivery.setOrder(this);
  }
}

   //== 생성 메서드 ==//
   public static Order createOrder(Member member, Delivery delivery, OrderItem... orderItems){ 
       Order order = new Order();
       order.setMember(member);
       order.setDelivery(delivery);
       for (OrderItem orderItem : orderItems) {
           order.addOrderItem(orderItem);
       }
       order.setStatus(OrderStatus.ORDER);
       order.setOrderDate(LocalDateTime.now());

       return order;
   }

여러개 받아올 수 있을때, ... 을 붙혀주면 가능함!!

생성 메소드로만 인스턴스 생성이 가능하도록 하고 싶으면!!

protected

protected Order(){}

이렇게 생성자를 protected 로 지정해두면, 생성 메소드안에서만 가능하게 됨!

@NoArgsConstructor(access = AccessLevel.PROTECTED) lombok 의 어노테이션을 활용하면, 외부에서 인스턴스 생성 불가능!

    //== 비즈니스 로직 ==//

    /**
     * 주문 취소
     */
    public void cancel() {
        if(delivery.getStatus() == DeliveryStatus.COMP){
            throw new IllegalStateException("이미 배송완료된 상품은 취소가 불가능합니다.");
        }
        this.setStatus(OrderStatus.CANCEL);
        for (OrderItem orderItem : orderItems) {
            orderItem.cancel();
        }
    }

    //== 조회 로직 ==//

    /**
     * 전체 주문 가격 조회
     */
    public int getTotalPrice(){
        return orderItems.stream().mapToInt(OrderItem::getTotalPrice).sum();
//        똑같이 동작
//        int totalPrice = 0;
//        for (OrderItem orderItem : orderItems) {
//            totalPrice += orderItem.getTotalPrice();
//        }
//        return totalPrice;
    }

OrderService

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class OrderService {
    private final OrderRepository orderRepository;
    private final MemberRepository memberRepository;
    private final ItemRepository itemRepository;

    // 주문
    /**
     * 주문
     */
    @Transactional
    public Long order(Long memberId, Long itemId, int count){
        // 엔티티 조회
        Member member = memberRepository.findOne(memberId);
        Item item = itemRepository.findOne(itemId);

        // 배송정보 생성
        Delivery delivery = new Delivery();
        delivery.setAddress(member.getAddress());

        // 주문상품 생성
        OrderItem orderItem = OrderItem.createOrderItem(item, item.getPrice(), count);

        // 주문 생성
        Order order = Order.createOrder(member, delivery, orderItem);

        // 주문 저장
        orderRepository.save(order);

        return order.getId();
    }

    // 취소

    // 검색
}

OrderService 의 경우 MemberRepository, ItemRepository 가 추가로 필요함. final field 로 지정하여, @RequiredArgsConstructor 에 의해 생성될때 주입 받음

위 기능에서 orderRepository.save(order) 만으로 되는 이유!!

Order.java -> CascadeType.ALL 으로 지정해두었기 때문에 Order 만 영속성 컨텍스트에 persist 하더라도, OrderItem, Delivery는 자동으로 따라 올라감!!

Order 가 두 객체 상대로 확실하게 private owner 포지션이기 때문에 가능!!

도메인 모델 패턴

비즈니스 로직 대부분이 엔티티에 있음! 서비스 계층은 단순히 엔티티에 필요한 요청을 위임하는 역할을 한다.

이처럼 엔티티가 비즈니스 로직을 가지고 객체 지향의 특성을 적극 활용하는 것을 도메인 모델 패턴 이라고 함

반대로 엔티티에는 비즈니스 로직이 거의 없고, 서비스 계층에서 대부분의 비즈니스 로직을 처리하는 것을 트랜잭션 스크립트 패턴 이라고 함

==> 한 프로젝트 안에서도, 문맥에 따라 두개가 공존하기도 한다!!

Test Code

참고! 정말로 좋은 Test Code는 운영 코드와 완전히 분리되어 비즈니스 로직들만 테스트 할 수 있는 것!! 지금의 경우, spring 이나 jpa 가 함께 종속되어 있으므로, 완벽하게 좋은 Test Code 라고 할 수는 없다.

    ...
    @Test
    public void 상품주문() throws Exception {
        // given
        Member member = getMember();
        Book book = getBook();

        // when
        int orderCount = 2;
        Long orderId = orderService.order(member.getId(), book.getId(), orderCount);

        // then
        Order getOrder = orderRepository.findOne(orderId);

        assertEquals("상품 주문시 상태는 ORDER", OrderStatus.ORDER, getOrder.getStatus());
        assertEquals("주문한 상품 종류 수가 정확해야 한다.", 1, getOrder.getOrderItems().size());
        assertEquals("주문한 가격은 가격 * 수량 이다.", 10000 * orderCount, getOrder.getTotalPrice());
        assertEquals("주문 수량만큼 재고가 줄어야 한다.", 8, book.getStockQuantity());
    }
    ...
    private Book getBook() {
        Book book = new Book();
        book.setName("시골 JPA");
        book.setPrice(10000);
        book.setStockQuantity(10);
        em.persist(book);
        return book;
    }

    private Member getMember() {
        Member member = new Member();
        member.setName("member1");
        member.setAddress(new Address("서울", "강가", "123-123"));
        em.persist(member);
        return member;
    }
    ...

ctrl + alt + p 하면, 함수 내 값을 parameter 로 받도록 자동 세팅!!

재고 초과 에러

    @Test(expected = NotEnoughStockException.class)
    public void 상품주문_재고수량초과() throws Exception {
        // given
        Member member = getMember("member1");
        Book book = getBook("시골 JPA", 10000, 10);

        int orderCount = 11;

        // when
        orderService.order(member.getId(), book.getId(), orderCount);

        // then
        fail("여기가 실행이 되면 안된다!");
    }

expected 에 Exception 정의해주면, 메소드 종료

실제 재고 수량 초과에 대한 알고리즘은 Item.java 파일에 있음

    public void removeStock(int quantity){
        int restStock = this.stockQuantity - quantity;
        if(restStock < 0){
            throw new NotEnoughStockException("need more stock");
        }
        this.stockQuantity = restStock;
    }

이 메소드에 대한, 단위 테스트를 만드는 것이 좋음!!

Entity 에 비즈니스 로직이 들어가 있으므로, Entity 단위로 테스트를 만드는 것도 괜찮다!!

주문 검색 기능

동적 쿼리가 필요한 상황 OrderSearch.java 를 만들어서, search 관련 파라미터들을 전달하는 용도로 사용.

@Getter @Setter
public class OrderSearch {
  private String memberName; // 회원 이름
  private OrderStatus orderStatus; // 주문 상태 [ ORDER, CANCEL ]
}

< OrderRepository.java >

  public List findAll(OrderSearch orderSearch) {
      List resultList = em.createQuery("select o from Order o join o.member m"
              + " where o.status = :status "
              + " and m.name like :name", Order.class)
              .setParameter("status", orderSearch.getOrderStatus())
              .setParameter("name", orderSearch.getMemberName())
              .setMaxResults(1000)
              .getResultList();
      return resultList;
  }

이처럼 orderSearch 를 받아서, jpql 생성가능!!

여기서, memberName 이 null 이거나 orderStatus 가 null 인 경우도 처리해 주어야지!!!

(권장 x) if 분 분기시켜서, jpql 구문 수정. query 수정

(권장 x) JPA Criteria 활용 => jpql / 쿼리 자동 생성 => 직관적이지 못함. 유지보수 힘듬

Query DSL [ 추후 제대로 ㄱㄱ ]

동적 쿼리, 복잡한 jpql 문 등등 자바 문법으로 가시화 하기 위해, Query DSL 을 쓰는 것을 강추

jpa-spring boot - api 실습 (1)

Sun, 09 Apr 2023 12:00:28 GMT

이런식으로 api 패키지를 만들어서 따로 관리하는 편 (김영한 개발자님)
@Controller @ResponseBody 로 쓰면 됨
@RestController 로 쓰면 똑같이 기능!

MemberApiController

saveMemberV1

    @PostMapping("/api/v1/members")
    public CreateMemberResponse saveMemberV1(@RequestBody @Valid Member member){
        Long id = memberService.join(member);
        return new CreateMemberResponse(id);
    }
    @Data
    static class CreateMemberResponse{
        private Long id;

        public CreateMemberResponse(Long id) {
            this.id = id;
        }
    }

@RequestBody 는 json 으로 input 이 들어오면, 해당 내용을 자동으로 Member에 맞게 매핑해주는 역할!!
http://localhost:8080/api/v1/members 로 post 요청을 하게 되면, 값이 반환 되는거 확인 가능!!
@Valid 는 엔티티 속의 @NotEmpty 가 있는 필드가 있는지 확인을 해줌.

Entity 가 Api Controller 의 파라미터로 쓰이는 것은 좋지 않다!

Entity 내부 코드 자체에 API function 이 섞이고 ( @NotEmpty 같은 )

Entity 수정에 api도 같이 영향을 받는다.

saveMemberV2

    @PostMapping("/api/v2/members")
    public CreateMemberResponse saveMemberV2(@RequestBody @Valid CreateMemberRequest request){
        Member member = new Member();
        member.setName(request.name);
        Long id = memberService.join(member);
        return new CreateMemberResponse(id);
    }
    @Data
    static  class CreateMemberRequest {
        @NotEmpty
        private String name;
    }

Entity 를 직접 쓰지않고, 따로 data 규약(DTO)을 만들어서 데이터를 왔다갔다!!
API 스펙이 Entity 영향을 받지 않음!

updateMemberV2

수정의 경우, rest api 규약, 관례(?) 에 따라 Put 방식을 활용
url 에 id 를 받아오는 방식으로 ㄱㄱ!

    @PutMapping("/api/v2/members/{id}")
    public UpdateMemberResponse updateMemberV2(
            @PathVariable("id") Long id,
            @RequestBody @Valid UpdateMemberRequest request){
        memberService.update(id, request.getName());
        Member findMember = memberService.findOne(id);
        return new UpdateMemberResponse(findMember.getId(), findMember.getName());
    }

Member Entity를 내부에서 직접 사용하지 않고, memberService 로 파라미터 넘기기 (캡슐화)

member 조회 v1

    @GetMapping("/api/v1/members")
    public List membersV1(){
        return memberService.findMembers();
    }

Entity를 직접 반환하면, 내부 정보들을 다 노출하게됨!!
원치 않은 정보에는 @JsonIgnore 을 넣어주면 된다. (+ 양방향 json 화 무한루프 방지)
회원과 관련된 다양한 API 가 있을텐데, 해당 기능마다 어노테이션을 달아주는 것이 어려움.
위와 마찬가지로, Entity 변경에 API 스펙이 변경된다!

member 조회 v2

    @GetMapping("/api/v2/members")
    public Result memberV2(){
        List findMembers = memberService.findMembers();

        List collect = findMembers.stream()
            .map(m -> new MemberDTO(m.getName()))
            .collect(Collectors.toList());
        return new Result(collect);
    }

    @Data
    @AllArgsConstructor
    static class Result {
        private T data;
    }
    @Data
    @AllArgsConstructor
    static class MemberDTO {
        private String name;
    }

@AllArgsConstructor 는 class 내부 필드를 생성때 바로 받을 수 있게 해줌.

jpa-spring boot 실습 - 5

Sun, 09 Apr 2023 06:49:13 GMT

Logger 를 사용할때는 import org.slf4j.Logger; 를 사용할 것
@Slf4j lombok 에서 해당 어노테이션 지원! 바로 코드에서 log 로 사용 가능!
Spring boot 에서 지원해주는 것 : re-run 을 하지 않고, ctrl + shift + F9 으로 즉시 컴파일 가능!

웹 계층 세팅

boot strap 주입

각종 html 파일 세팅

ctrl + E 최근에 썼던 명령어, 리소스 뜸! ctrl + alt + shift + T 리팩토링 관련 추천! ctrl + shift + U 해당 문자 upper case 로 변환

변경 감지와 병합 (merge)

변경 감지 (dirty checking)

영속성 컨텍스트에 올라와 있는 엔티티 에 대해서는, 어떤 변경들이 일어나더라도, EntityManager 가 flush 되는 시점에 감지를 하여 sql 문이 날아간다.

but, 준영속 엔티티는 어떻게 해야하나?

영속성 컨텍스트가 더는 관리하지 않는 엔티티

하지만, jpa DB를 한번 거쳐서, 식별자는 가지고 있는 경우!

임의로 만든 엔티티 여도, 기존 식별자를 가지고 있으면, 준영속 엔티티 로 볼 수 있다.

직접적으로 JPA 가 관리를 하지 않기에, 수정 이후 영속성 컨텍스트에 올려주어야함. 다른 방법은 없나? HOW?

변경 감지 기능

병합 (merge) 사용

준영속 경우 업데이트 기존

    @PostMapping("items/{itemId}/edit")
    public String updateItem( @PathVariable String itemId, @ModelAttribute("form") BookForm form){
        Book book = new Book();
        book.setId(form.getId());
        book.setName(form.getName());
        book.setPrice(form.getPrice());
        book.setStockQuantity(form.getStockQuantity());
        book.setAuthor(form.getAuthor());
        book.setIsbn(form.getIsbn());

        itemService.saveItem(book); // 영속성 컨텍스트 등록!
        return "redirect:/items";
    }

1. 변경 감지 활용

Service 계층에서 호출하면서, 영속성 컨텍스트에 올리고,

마음껏 수정 (flush 때 인식하여, db sql 문 날림)

  @PostMapping("items/{itemId}/edit")
  public String updateItem( @PathVariable String itemId, @ModelAttribute("form") BookForm form){
      itemService.updateItem(itemId, form); // Service 계층에 메소드 추가
      return "redirect:/items";
  }

< ItemService.java >

  @Transactional
  public void updateItem(Long itemId, BookForm form){
      Book book = (Book) itemRepository.findOne(itemId);
      book.setName(form.getName());
      book.setPrice(form.getPrice());
      book.setStockQuantity(form.getStockQuantity());
      book.setAuthor(form.getAuthor());
      book.setIsbn(form.getIsbn());
  }

이 부분도, 하나하나 setter 로 바꾸는 것 보다는, book 단의 Set Method 를 따로 만들어서, 하는 것을 추천! 우리 협업 좀 하자!! 몇달 뒤 너를 위해서라도! 동료 파트너를 위해서라도!

    @Transactional
    public void updateItem(Long itemId, BookForm form){
        Book book = (Book) itemRepository.findOne(itemId);
        book.changeWholeField(form.getName(),
                              form.getPrice(),
                              form.getStockQuantity(),
                              form.getAuthor(),
                              form.getIsbn());
    }

2. 병합 (merge) 활용

< ItemRepository.java >

    public void save(Item item){
        if(item.getId() == null){
            em.persist(item);
        } else {
            em.merge(item);
        }
    }

위의 변경감지랑 똑같은 flow 로 작동함!! 다만!!

불러온 값에서, merge 한 엔티티에 있는 값들로 전부 바꿔치기함!! 즉 영속성 컨텍스트 속에서는 내가 원하는 수정 상태로 가지고 있고, flush 하면 업데이트 sql 이 실행됨.

주의 사항!!

item 을 merge 했다고 해서, item 자체가 영속성 컨텍스트 위에 있지는 x
- 영속성 엔티티를 활용하고 싶으면, em.merge() 의 반환값을 사용해야함!!
변경감지를 사용하면, 원하는 속성만 변경 가능하지만, 병합은 모든 속성이 변경됨 (null 값들도)
- 수정을 원치 않던 값에 null 이 들어가서 기존 DB의 값을 덮어버리는 대참사 가능성...
가급적 (1) 변경감지 를 사용하는 것이 맞음. 보통 update는 몇가지만 일어나니!!

서비스 계층에서의 엔티티 관리

Controller 계층에서의 엔티티

바로 위 변경감지에서 Book Entity를 넘기지 않고, id 와 BookForm 을 service 계층에 파라미터로 전달
@Transactional 을 가지고 있는 서비스 계층에서, 엔티티의 시작과 끝을 관리하는 것이 좋음
파라미터 값으로는 엔티티와 최대한 연관이 없도록 분리 시켜주는 것이 유지 보수 등 코드에 유리!

< OrderController.java >

    @PostMapping("/order")
    public String order(@RequestParam("memberId") Long memberId,
                        @RequestParam("itemId") Long itemId,
                        @RequestParam("count") int count){
        orderService.order(memberId, itemId, count);
        return "redirect:/orders";
    }

이런 식으로 service 계층에 엔티티를 직접 넘기지 않는 방법이 좋음!!