스포츠 배팅 웹사이트 만들기(3)(Team Project)

지난 포스팅에 이어서 repository를 작성해보자

admin/repository/ConfigRepository

package com.springboot.shootformoney.admin.repository;

import com.springboot.shootformoney.admin.entity.ConfigEntity;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ConfigRepository extends JpaRepository<ConfigEntity, String> {
}

JpaRepository를 상속받아서 다양한 메서드들을 사용할 수 있게 된다. JpaRepository는 기본적인 CRUD기능 뿐만 아니라 페이징처리나 다른 유용한 메서드들도 사용할 수 있게 해준다.

bet/repository/BetRepository

package com.springboot.shootformoney.bet.repository;

import com.springboot.shootformoney.bet.entity.Bet;
import com.springboot.shootformoney.game.entity.Game;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface BetRepository extends JpaRepository<Bet, Long>, QuerydslPredicateExecutor<Bet> {
    Optional<Bet> findByBtNo(Long btNo);

    //회원번호로 배팅내역 조회하기.
    @Query("SELECT b FROM Bet b WHERE b.member.mNo = :mNo ORDER BY b.btTime DESC")
    List<Bet> findBymNo(@Param("mNo") Long mNo);

    //배팅 적중한 사람 조회하기.(중복 체크 포함)
    @Query("SELECT b FROM Bet b WHERE b.game = :game AND b.game.result = b.expect AND b.endPaid = 0")
    List<Bet> findByResultAndExpect(@Param("game") Game game);

    //경기가 끝난 배팅 중, 정산 안된 배팅 조회하기
    @Query("SELECT b FROM Bet b WHERE b.game = :game AND b.endPaid = 0")
    List<Bet> findByGameAndEndPaid(@Param("game") Game game);

    //gNo로 배팅내역 조회하기.
    @Query("SELECT b FROM Bet b WHERE b.game.gNo = :gNo")
    List<Bet> findAllByGame_gNo(@Param("gNo") Long gNo);

}

Querydsl을 사용할 수 있게 QuerydslPredicateExecutor를 상속받고 JpaRepository에서 제공하지 않는 기능들은 @Query로 직접 정적 쿼리를 작성해서 사용한다.

bet/repository/EuroPoolRepository

package com.springboot.shootformoney.bet.repository;

import com.springboot.shootformoney.bet.entity.EuroPool;
import com.springboot.shootformoney.member.entity.Euro;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;


@Repository
public interface EuroPoolRepository extends JpaRepository<EuroPool, Long> {
    Boolean existsByGame_gNo(Long gNo);
    EuroPool findByGame_gNo(Long gNo);


}

board/repository/BoardRepository

package com.springboot.shootformoney.board.repository;

import com.springboot.shootformoney.board.entity.Board;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;
import java.util.Optional;

public interface BoardRepository extends JpaRepository<Board, String> {

    Board findBybNo(Long bNo); // 게시판 bNo 조회

    boolean existsBybName(String bName); // 게시판 이름 중복 여부 판단

    // 게시판 - 게시글 개수
    @Query("SELECT COUNT(p) FROM Board b JOIN b.posts p WHERE b.bNo = :bNo")
    int getPostCountByBoardId(@Param("bNo") Long bNo);

    // 게시판 이름으로 검색
    Optional<Board> findBybName(String bName);

    // 게시판 bNo로 중복 여부 판단
    boolean existsBybNo(Long bNo);

}

comment/repository/CommentRepository

package com.springboot.shootformoney.comment.repository;

import com.springboot.shootformoney.comment.entity.Comment;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;

public interface CommentRepository extends JpaRepository<Comment,Long>, QuerydslPredicateExecutor<Comment> {

}

game/repository/GameRepository

package com.springboot.shootformoney.game.repository;

import com.springboot.shootformoney.game.dto.data.Result;
import com.springboot.shootformoney.game.entity.Game;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface GameRepository extends JpaRepository<Game, Long> {
    Optional<Game> findByMatchId(Integer matchId);

    Boolean existsByMatchId(Integer matchId);

    @Query("SELECT g FROM Game g WHERE g.result = 'NN' ORDER BY g.gStartTime")
    List<Game> findAllUnstartedMatches();

    @Query("SELECT g FROM Game g WHERE g.result = 'NN' AND g.gLeague = 'Bundesliga' ORDER BY g.gStartTime")
    List<Game> findUnstartedBL1Matches();

    @Query("SELECT g FROM Game g WHERE g.result = 'NN' AND g.gLeague = 'Premier League' ORDER BY g.gStartTime")
    List<Game> findUnstartedPLMatches();

    @Query("SELECT g FROM Game g WHERE g.result = 'NN' AND g.gLeague = 'Primera Division' ORDER BY g.gStartTime")
    List<Game> findUnstartedPDMatches();

    @Query("SELECT g FROM Game g WHERE g.result != 'NN' AND g.gLeague = 'Premier League' ORDER BY g.gStartTime DESC")
    List<Game> findFinishedPLMatches();

    @Query("SELECT g FROM Game g WHERE g.result != 'NN' AND g.gLeague = 'Primera Division' ORDER BY g.gStartTime DESC")
    List<Game> findFinishedPDMatches();

    @Query("SELECT g FROM Game g WHERE g.result != 'NN' AND g.gLeague = 'Bundesliga' ORDER BY g.gStartTime DESC")
    List<Game> findFinishedBL1Matches();

    @Query("SELECT g FROM Game g WHERE g.result != 'NN' ORDER BY g.gStartTime DESC")
    List<Game> findAllFinishedMatches();

}

member/repository/EuroRepository

package com.springboot.shootformoney.member.repository;

import com.springboot.shootformoney.member.entity.Euro;
import com.springboot.shootformoney.member.entity.Member;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.Optional;

public interface EuroRepository extends JpaRepository<Euro, Long> {
    Euro findByMember(Member member);

    @Query("SELECT e FROM Euro e WHERE e.member.mNo = :mNo")
    Euro findBymNo(@Param("mNo") Long mNo);
}

member/repository/MemberRepository

package com.springboot.shootformoney.member.repository;

import com.springboot.shootformoney.member.entity.Member;
import com.springboot.shootformoney.member.enum_.Grade;
import com.springboot.shootformoney.member.enum_.Role;
import com.springboot.shootformoney.post.Post;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;

import java.util.List;

public interface MemberRepository extends JpaRepository<Member, Long>, QuerydslPredicateExecutor<Member>{

    Member findBymId(String mId); // 회원 Id로 조회.
    Member findBymNickName(String mNickName); // 닉네임으로 조회
    Member findBymPhone(String mPhone); // 전화 번호로 조회
    Member findBymEmail(String mEmail); // 이메일로 조회

    /*
    페이징 처리용 by 유난
     */
    Page<Member> findBymNo(Long mNo, Pageable pageable); // 회원 no로 조회
    Page<Member> findBymId(String mName, Pageable pageable); // 회원 ID 조회
    Page<Member> findBymName(String mName, Pageable pageable); // 회원 이름 조회
    Page<Member> findBymNickName(String mName, Pageable pageable); // 회원 별명 조회
    Page<Member> findBymLevel(Integer mLevel, Pageable pageable); // 회원 LV 조회
    Page<Member> findByGrade(Grade grade, Pageable pageable); // 회원 등급 조회
    Page<Member> findByRole(Role role, Pageable pageable); // 회원 권한 조회
    // 여기까지 ~

    @Query("SELECT m FROM Member m WHERE m.mEmail = :mEmail AND m.mName = :mName ")
    Member findBymEmailAndmName(String mEmail, String mName); // 이메일 + 이름으로 조회
    @Query("SELECT m FROM Member m WHERE m.mId = :mId AND m.mEmail = :mEmail ")
    Member findBymIdAndmEmail(String mId, String mEmail); // 아이디 + 이메일로 조회
    @Query("SELECT m FROM Member m ORDER BY m.mLevel DESC, m.mStack DESC")
    List<Member> findByMemberOrderBymLevelAAndMStack();
}   

post/repository/PostRepository

package com.springboot.shootformoney.post;


import com.springboot.shootformoney.board.entity.Board;
import com.springboot.shootformoney.board.repository.BoardRepository;
import com.springboot.shootformoney.member.repository.MemberRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.TypedQuery;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Repository;
import lombok.RequiredArgsConstructor;

import java.util.List;

@Repository
@RequiredArgsConstructor
public class PostRepository {

    private final EntityManager em;
    private final BoardRepository boardRepository;


    //게시판 저장
    public void save(Post post){
        if (post.getPNo() == null) {
            em.persist(post);
        } else {
            em.merge(post);
        }
    }

    //게시글 삭제
    public void delete(Post post) {
        em.remove(post);
    }





    public Post findOne(Long pNo){
        return em.createQuery("select p from Post p where p.pNo = :pNo", Post.class)
                .setParameter("pNo", pNo)
                .getSingleResult();
    }



    //게시글 전체 조회
    public List<Post> findAll() {
        return em.createQuery("select p from Post p", Post.class)
                .getResultList();
    }

    //게시글 제목으로 조회
    public List<Post> findByTitle(String pTitle) {
        return em.createQuery("select p from Post p where p.pTitle = :pTitle", Post.class)
                .setParameter("pTitle", pTitle)
                .getResultList();
    }

    public List<Post> findByBoard_BName(String bName) {
        return em.createQuery("select p from Post p where p.board.bName = :bName", Post.class)
                .setParameter("bName", bName)
                .getResultList();
    }

    public List<Post> findAllWithBoard() {
        return em.createQuery("select p from Post p join fetch p.board", Post.class)
                .getResultList();
    }

    // 회원 닉네임(mNickName)에 해당하는 게시글을 조회
    public List<Post> findByMember_MNickName(String mNickName) {
        return em.createQuery("select p from Post p where p.member.mNickName = :mNickName", Post.class)
                .setParameter("mNickName", mNickName)
                .getResultList();
    }

    public List<Post> findByMemberId(String mId) {
        return em.createQuery("select p from Post p where p.member.mId = :mId", Post.class)
                .setParameter("mId", mId)
                .getResultList();
    }

    public List<Post> findByMemberNo(Long mNo) {
        return em.createQuery("select p from Post p where p.member.mNo = :mNo", Post.class)
                .setParameter("mNo", mNo)
                .getResultList();
    }

    public List<Post> findByBoardBNo(Long bNo) {
        return em.createQuery("select p from Post p where p.board.bNo = :bNo", Post.class)
                .setParameter("bNo", bNo)
                .getResultList();
    }

    public List<Post> findAllWithMember() { //수정
        return em.createQuery("SELECT p FROM Post p LEFT JOIN FETCH p.member", Post.class)
                .getResultList();
    }



}

여기서는 위와는 다르게 JpaRepository를 상속받는 것이 아닌 EntityManager에서 엔티티들을 관리하고 필요한 쿼리를 자동수행하도록 해준다.

전 포스팅에서 엔티티는 DB의 접근하기 위해 만든 객체이고 이번 포스팅의 레퍼지토리는 엔티티에 의해 생성된 DB에 접근하는 메서드들을 사용하기 위한 인터페이스라는 것을 알 수 있다. 다음 포스팅에서는 실제로 사용자의 요구사항을 수행하는, 비즈니스 로직을 처리하는 서비스 계층에 대해 알아보자.