💷스프링 시큐리티로 로그인 하기

전 시간 까지 완전 간단한 회원 가입만 해보았다. 이번엔 로그인을 해보자

📌MemberService 상속 받기

package com.shop.service;

import com.shop.entity.Member;
import com.shop.repository.MemberRepository;
import lombok.RequiredArgsConstructor;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;






// 서비스
@Service
// 트랜잭션 설정 : 성공하면 적용 실패하면 롤백
@Transactional
// final 또는 @NonNull 명령어가 붙으면 객체를 자동으로 붙여준다. @Autowired가 필요 없다는 뜻
@RequiredArgsConstructor // 롬복 어노테이션
public class MemberService implements UserDetailsService { // implements? 👉 UserDetailsService는 인터페이스 👉 추상화 메소드 재정의

    //@Autowired
    //MemberRepository memberRepository;
    private final MemberRepository memberRepository;

    // 중복 검사 후에 없으면 저장
    public Member saveMember(Member member) {
        validateDuplicateMember(member);
        return memberRepository.save(member); // 데이터베이스에 저장을 하라는 명령
    }

    // 이메일 중복 검사 메소드
    private void validateDuplicateMember(Member member) {
        Member findMember = memberRepository.findByEmail(member.getEmail());

        // Controller 에서 try/catch 로 나오게
        if (findMember != null) {
            throw new IllegalStateException("이미 가입된 회원입니다.");
        }
    }


    // UserDetailsService : 데이터베이스에서 회원 정보를 가져오는 역할 인터페이스
    // UserDetail : 스프링 시큐리티에서 회원 정보를 담기 위해 사용하는 인터페이스
    // UserDetails로 usernameParameter("email")를 가지고 로그인 인증. 
    // 즉, 직접 구현하거나 스프링 시큐리티에서 제공하는 User 클래스 사용 (구현체)
    // loadUserByUsername() 메소드를 통해 회원정보를 조회 -> UserDetails 인터페이스 반환
    @Override
    public UserDetails loadUserByUsername(String email){
        Member member = memberRepository.findByEmail(email);

        if (member == null){
            throw new UsernameNotFoundException(email);
        }

        //빌더 패턴
        return User.builder().username(member.getEmail())
                .password(member.getPassword())
                .roles(member.getRole().toString())
                .build();
    }

}

📌SecurityConfig 클래스 수정

package com.shop.config;

import com.shop.service.MemberService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    @Autowired
    MemberService memberService;

    // 전부 허락
    // filterChain(HttpSecurity http) 메소드를 통해 로그인 및 로그아웃 URL 지정
    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception{
        http.authorizeRequests(auth -> auth.requestMatchers("/", "/members/**").permitAll())
                // http.formLogin() - http 를 통해 들어오는 form 기반 request 를 이용하여 Login 을 처리
				// form 태그에서 사용자의 ID 부분은 default 값으로 "username" 필드
                .formLogin(formLogin -> formLogin
                        .loginPage("/members/login") // 로그인 페이지
                        .defaultSuccessUrl("/") // 로그인 성공 페이지 👉 "/"
                        .usernameParameter("email")
                        .failureUrl("/members/login/error")) // 로그인 에러 페이지
                // 로그아웃
                .logout(logout -> logout
                        .logoutRequestMatcher(new AntPathRequestMatcher("/members/logout")) // 로그아웃 페이지
                        .logoutSuccessUrl("/")); // 로그아웃 성공 페이지 👉 "/"

        return  http.build();

    }

    // 비밀번호 암호화
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
    /*
    AuthenticationManagerBuilder 를 통해 AuthenticationManager 를 생성하여 인증 처리 수행
	UserDetailsService 인터페이스를 구현하고 loadUserByUsername 메소드를 오버라이딩한 
    memberService 객체를 이용하여 User 객체를 얻어낸 뒤, 
    지정된 비밀번호 암호화 방식으로 비밀번호가 일치하는지 검증
    */
    @Autowired
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(memberService).passwordEncoder(passwordEncoder());
    }


}

📌memberLoginFrom.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      layout:decorate="~{layouts/layout1}">
<!-- 사용자 CSS 추가 -->
<th:block layout:fragment = "css">
    <style>
        .error{
            color: red;
        }
    </style>
</th:block>

<div layout:fragment = "content">
    <form action="/members/login" role="form" method="post">
        <div class = "form-group">
            <label th:for = "email">이메일</label>
            <input type="email" name="email" class="form-control" placeholder="이메일을 입력해주세요">
        </div>
        <div class = "form-group">
            <label th:for = "password">비밀번호</label>
            <input type="password" name="password" class="form-control" placeholder="비밀번호를 입력해주세요">
        </div>

        <p th:if="${loginErrorMsg}" class="error" th:text="${loginErrorMsg}"></p>

        <br>

        <button class="btn btn-success">로그인</button>

        <button type="button" class="btn btn-warning" onclick="location.href='/members/new'">회원가입</button>

        <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}">

    </form>
</div>

</html>

📌MemberController 클래스 수정

package com.shop.controller;

import com.shop.dto.MemberFormDto;
import com.shop.entity.Member;
import com.shop.service.MemberService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.Value;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;


@Controller
@RequestMapping("/members")
@RequiredArgsConstructor
public class MemberController {

    private final MemberService memberService;

    private final PasswordEncoder passwordEncoder;

    // method = "get" 일 때 실행
    @GetMapping(value = "/new")
    public String memberForm(Model model){

        model.addAttribute("memberFormDto", new MemberFormDto());

        return "member/memberForm";
    }

    // method = "post" 일 때 실행 DB에 저장
    @PostMapping(value = "/new")
    // memberForm 오버로딩
    public String memberForm(@Valid MemberFormDto memberFormDto, BindingResult bindingResult, Model model){

        // 에러나면 다시 가입
        if(bindingResult.hasErrors()){

            return "member/memberForm";

        }

        try {

            Member member = Member.createMember(memberFormDto, passwordEncoder);

            memberService.saveMember(member);

        }catch (IllegalStateException e){

            model.addAttribute("errorMessage", e.getMessage());

            return "member/memberForm";

        }

        return "redirect:/";

    }
    
    
    // Header에서 눌렀을 때 실행 되어 "/member/memberLoginForm"로 보낸다. 그래서 GetMapping
    // memberLoginForm 에서의 post는 SecurityConfig  .loginPage("/members/login") 으로 간다
    // 복잡....
    @GetMapping(value = "/login")
    public String loginMember(){

        return "/member/memberLoginForm";

    }

    // 로그인이 실패 했을 때 실행
    @GetMapping(value = "login/error")
    public String loginError(Model model){

        model.addAttribute("loginErrorMsg", "아이디 또는 비밀번호를 확인해주세요");

        return "/member/memberLoginForm";
    }


}

👉 추가

📌결과

실행 해보면
org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'securityConfig': Requested bean is currently in creation: Is there an unresolvable circular reference?
에러가 발생 할 텐데 애플리케이션 프로퍼티에 순환을 추가 해줘야 한다. 아마 버전이 바뀌면서서 변경 된 것으로 추정

    // 비밀번호 암호화
    @Bean
    public static PasswordEncoder passwordEncoder(){
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

👉 SecurityConfig 에서 이렇게 변경 해줘야 한다

👉 로그인 실패

👉 성공, 로그아웃 까지 잘 된다

❓어떤 구조로 실행?

1. memberLoginForm.html 로그인

👉 클릭

에 의해
\

2. 로그인을 눌렀을 경우

👉 실행 후

👉 인증 실행

👉 .usernameParameter("email") 로 email 을 가지고 select 실행

👉 member email 객체를 하나(중복 x) 받는다. null 이면 에러 throw

👉 null이 아니면 View에서 내려온 email과 password를 UserDetails와 비교해서 확인. password는 이미 encoder를 해놓음.
👉 일치한다? 로그인 성공

3. 로그인 실패 했을 때

👉 실행

---

📖시큐리티 테스트하기

JUnit 으로 테스트하는 습관을 들여야 한다

        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>

👉 의존성 추가

📌MemberController test 생성

🤦‍♀️로그인 성공 테스트

package com.shop.controller;

import com.shop.dto.MemberFormDto;
import com.shop.entity.Member;
import com.shop.service.MemberService;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.test.web.servlet.response.SecurityMockMvcResultMatchers;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestBuilders.formLogin;

@SpringBootTest
// 가상의 웹을 만들어 주는 mockMvc
@AutoConfigureMockMvc
@Transactional
@TestPropertySource(locations = "classpath:application-test.properties")
class MemberControllerTest {

    @Autowired
    private MemberService memberService;

    // mockMvc : 웹 브라우저에 요청을 하는 것 처럼 테스를를 할 수 있게 하는 가짜 객체
    @Autowired
    private MockMvc mockMvc;

    @Autowired
    PasswordEncoder passwordEncoder;

     /*
     1. memberFormDto 객체를 생성해서 더미데이터에 넣는다.
     2. Member 👉 createMember를 호출하는데
     매개변수 memberFormDto, passwordEncoder로 Member 객체 생성
     3. memberService.saveMember 👉 Member를 테이블에 저장
     validateDuplicateMember를 이용해 기존 가입 여부 확인
     가입이 안된 경우 : memberRepository.save(member) 로 테이블에 저장
     테이블에 데이터가 저장이 되면 똑같은 Member 객체를 반환
     가입이 된 경우 : IllegalStateException("이미 가입된 회원입니다.")
     */
    public Member createMember(String email, String password){

        MemberFormDto memberFormDto = new MemberFormDto();

        memberFormDto.setEmail(email);
        memberFormDto.setPassword(password);
        memberFormDto.setName("홍길동");
        memberFormDto.setAddress("서울시 마포구 합정동");
        memberFormDto.setTelNumber("010-1234-5678");

        Member member = Member.createMember(memberFormDto, passwordEncoder);

        return memberService.saveMember(member);

    }

    @Test
    @DisplayName("로그인 성공 테스트")
    public void loginSuccessTest() throws Exception {
        String email = "test@email.com";
        String password = "1234";
        this.createMember(email, password); // 위 변수를 넣어 createMember로 DB에 데이터 저장

        // 가상 웹 실행 👉 로그인 실행 userParameter("email")를 가지고
        // "/members/login" 에서 user : "test@email.com", password : "1234" 를
        // mockMvc 가상 웹에서 authenticated()로 인증된 걸로 기대 한다. 안되면 테스트 실패
        mockMvc.perform(formLogin().userParameter("email")
                .loginProcessingUrl("/members/login")
                .user(email)
                .password(password))
                .andExpect(SecurityMockMvcResultMatchers.authenticated());



    }

}

🤦‍♀️로그인 실패 테스트

    @Test
    @DisplayName("로그인 실패 테스트")
    public void loginFailedTest() throws Exception {
        String email = "test@email.com";
        String password = "1234";
        this.createMember(email, password);

        mockMvc.perform(formLogin().userParameter("email")
                        .loginProcessingUrl("/members/login")
                        .user(email)
                        .password("12345"))
                 // 로그인 인증이 되지 않기를 기대 👉 로그인이 실패하기를 원한다
                .andExpect(SecurityMockMvcResultMatchers.unauthenticated());
    }

---

💷인증 및 권한 넣기

Thymeleaf Extras Springsecurity6

        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-springsecurity6</artifactId>
            <version>3.1.2.RELEASE</version>
        </dependency>

👉 의존성 추가

📌header.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security" lang="ko"> 👉 sec 추가
<head>

...

<ul class="navbar-nav me-auto mb-2 mb-lg-0">
                    <!-- ADMIN만 접근 가능 hasAnyAuthority('ROLE_ADMIN')-->
                    <li class="nav-item" sec:authorize="hasAnyAuthority('ROLE_ADMIN')">
                        <a class="nav-link" href="/admin/item/new">상품 등록</a>
                    </li>
                    <li class="nav-item" sec:authorize="hasAnyAuthority('ROLE_ADMIN')">
                        <a class="nav-link" href="/admin/items">상품 관리</a>
                    </li>
                    <!-- 로그인이 된 경우 isAuthenticated -->
                    <li class="nav-item" sec:authorize="isAuthenticated()">
                        <a class="nav-link" href="/cart">장바구니</a>
                    </li>
                    <li class="nav-item" sec:authorize="isAuthenticated()">
                        <a class="nav-link" href="/orders">구매이력</a>
                    </li>
                    <!-- 아무나 접근 가능 isAnonymous-->
                    <li class="nav-item" sec:authorize="isAnonymous()">
                        <a class="nav-link" href="/members/login">로그인</a>
                    </li>
                    <li class="nav-item" sec:authorize="isAuthenticated()">
                        <a class="nav-link" href="/members/logout">로그아웃</a>
                    </li>
                </ul>

...

📌결과

👉 로그인만 표시

👉 변경후에 Apply

👉 USER 로그인 성공

👉 ADMIN 로그인 성공

---

💷상품페이지 만들기

📌itemForm.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org"
      xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
      xmlns:sec="http://www.thymeleaf.org/extras/spring-security"
      layout:decorate="~{layouts/layout1}" lang="ko">

<!-- 치환 되는 녀석이니까 head, body는 필요 없다 -->
<div layout:fragment="content">
    <h1>상품 등록 페이지입니다.</h1>
</div>

</html>

📌ItemController 클래스 생성

package com.shop.controller;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ItemController {

    @GetMapping(value = "/admin/item/new") // ADMIN ROLE 만 들어올 수 있다
    public String itemForm(){
        return "/item/itemForm";
    }
    
}

📌CustomAuthenticationEntryPoint 클래스 생성

package com.shop.config;

import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;

import java.io.IOException;

// AuthenticationEntryPoint 인터페이스 구현 클래스
// 인증되지 않은 사용자가 리소스 요청 시 "Unauthorized" 에러를 발생시킴
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authenticationException) throws IOException, ServletException {
        // int SC_UNAUTHORIZED = 401; 👉 우리가 인증 에러(401 에러)를, "Unauthorized"로  바꾼 것
        response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
        
    }

}

📌SecurityConfig 클래스 수정

...

        http.authorizeRequests(auth -> auth.requestMatchers("/", "/members/**", "/item/**" , "/images/**").permitAll() // 누구나 접근 가능한 페이지
                        .requestMatchers("/css/**", "/js/**", "/img/**").permitAll() // static 폴더 안에 있는 /css, /js, /img 하위 모든 파일은 인증 무시
                        .requestMatchers("/admin/**").hasRole("ADMIN") // ADMIN만 접근 가능한 페이지
                        .anyRequest().authenticated()) // 위에 존재하는 url patterns 들을 제외한 나머지 요청들

...

									                        .logoutSuccessUrl("/")); // 로그아웃 성공 페이지 👉 "/"

        // 권한에 맞지 않는 사용자가 리소스에 접근할 때 수행되는 핸들러
        // 권한이 없는 사용자가 리소스를 요청하면 "Unauthorized" 에러 발생
        http.exceptionHandling(exceptHand -> exceptHand
                .authenticationEntryPoint(new CustomAuthenticationEntryPoint()));
                .authenticationEntryPoint(new CustomAuthenticationEntryPoint()));


        return  http.build();
        
        ...
        
        

📌결과

👉 회원가입

👉 http://localhost/admin/item/new 에 접근 가능하다

👉 member.setRole(Role.USER); 로 바꾸고

👉 USER는 item/new에 접근이 불가하다. requestMatchers("/admin/**").hasRole("ADMIN") 설정 했기 때문

🤦‍♀️ItemController 테스트하기

package com.shop.controller;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;


@SpringBootTest
// 가상의 웹을 만들어 주는 mockMvc
@AutoConfigureMockMvc
@TestPropertySource(locations = "classpath:application-test.properties")
class ItemControllerTest {

    @Autowired
    MockMvc mockMvc;

    @Test
    @DisplayName("상품 등록 페이지 권한 테스트")
    // 회원의 이름이 admin이고 role(권한)이 ADMIN인 유저가 접근하는 것처럼 가상의 UserDetails 객체 구현
    @WithMockUser(username = "admin", roles = "ADMIN")
    public void itemFormTest() throws Exception {
    	//가상의 Get 방식 URL Request 생성
        // 요청 빌더를 get으로 만듦 "/admin/item/new" 에서 admin에 걸리게 된다.
        mockMvc.perform(MockMvcRequestBuilders.get("/admin/item/new")) // get 요청
                .andDo(print()) // 콘솔창에 출력
                .andExpect(status().isOk()); // 응답 상태가 OK인지 체크
    }

    @Test
    @DisplayName("상품 등록 페이지 일반 회원 접근 테스트")
    @WithMockUser(username = "user", roles = "USER") // 가상의 role과 username 설정
    public void itemFormNotAdminTest() throws Exception {
        // 요청 빌더를 get으로 만듦 "/admin/item/new" 에서 admin에 걸리게 된다.
        mockMvc.perform(MockMvcRequestBuilders.get("/admin/item/new")) // get 요청
                .andDo(print()) // Request & Response 메시지 콘솔창에 출력
                .andExpect(status().isForbidden()); // 응답이 Forbidden이 발생 👉 권한 없는 사용자 접근 403 에러
    }

}

📍결과

👉 ADMIN, 여러 정보가 담겨있다

👉 USER Status = 403, Error message = Forbidden 에러

---

📖🔥⭐(Spring 1대장)Entity 연관 관계 매핑⭐🔥

연관 관계 : 테이블 외래키(FK) 연결 👉 상대방의 기본키(PK)
보통은 1:N 이면 N인 녀석이 외래키를 갖고 1은 기본키를 주는 역할. 아닌 경우도 있다

1. 1:1 관계 : @OnetoOne, 회원가입과 회원/유저와 장바구니
2. 1:N 관계 : @OnetoMany, 교수와 학생/장바구니와 상품
3. N:1 관계 : @ManytoOne, 위와 반대
4. N:M 관계 : @ManytoMany, 유저들과 상품

   단방향/양방향

• 데이터베이스 중심 설계 테이블에서 관계는 항상 양방향
• JPA 객체지향 중심 설계에서는 단방향, 양방향 존재

📌1:1 단방향 관계

장바구니(cart) ⟶ 유저(member), 장바구니가 유저 PK를 갖고 있는 상황

📍Cart Entity 클래스 생성

package com.shop.entity;

import jakarta.persistence.*;
import lombok.Data;

@Entity
@Table(name = "cart")
@Data
public class Cart {

    @Id
    @Column(name = "cart_id")
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @OneToOne // 1:1 매핑
    @JoinColumn(name = "member_id") // JoinColumn 매핑 할 외래키 지정. member_id 이름 설정
    //name을 명시하지 않으면 JPA가 알아서 ID를 찾긴하지만 원하는 name이 아닐 수도 있다
    private Member member;

}

📍결과

Hibernate: 
    create table cart (
        cart_id bigint not null,
        member_id bigint,
        primary key (cart_id)
    ) engine=InnoDB
    
    ...
    
Hibernate: 
    create table item (
        price integer not null,
        stock_number integer not null,
        item_id bigint not null,
        reg_time datetime(6),
        update_time datetime(6),
        item_nm varchar(50) not null,
        item_detail tinytext not null,
        item_sell_status enum ('SELL','SOLD_OUT'),
        primary key (item_id)
    ) engine=InnoDB   
    
    ...
    
Hibernate: 
    create table member (
        member_id bigint not null,
        address varchar(255),
        email varchar(255),
        name varchar(255),
        password varchar(255),
        tel_number varchar(255),
        role enum ('USER','ADMIN'),
        primary key (member_id)
    ) engine=InnoDB
    
    ...
    
Hibernate: 
    alter table cart 
       add constraint UK_7dds3r67nkhxm9sbs9r5obd46 unique (member_id)
Hibernate: 
    alter table member 
       add constraint UK_mbmcqelty0fbrvxp1q58dn57t unique (email)
Hibernate: 
    alter table cart 
       add constraint FKix170nytunweovf2v9137mx2o 
       foreign key (member_id) 
       references member (member_id)

 

👉 cart 테이블 생성 후 alter 명령어로 외래키(FK)를 마지막에 지정 했다

📍CartRepository 인터페이스 생성

package com.shop.repository;

import com.shop.entity.Cart;
import org.springframework.data.jpa.repository.JpaRepository;


// 장바구니 조회를 위한 쿼리문 날리는 JpaRepository
public interface CartRepository extends JpaRepository<Cart, Long> {

}

🤦‍♀️Cart Entity 테스트 하기

package com.shop.entity;

import com.shop.dto.MemberFormDto;
import com.shop.repository.CartRepository;
import com.shop.repository.MemberRepository;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityNotFoundException;
import jakarta.persistence.PersistenceContext;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.test.context.TestPropertySource;
import org.springframework.transaction.annotation.Transactional;

import static org.junit.jupiter.api.Assertions.*;


@SpringBootTest
@Transactional
@TestPropertySource(locations = "classpath:application-test.properties")
class cartTest {

    @Autowired
    CartRepository cartRepository;

    @Autowired
    MemberRepository memberRepository;

    @Autowired
    PasswordEncoder passwordEncoder;

    @PersistenceContext // Entity 영속성 저장 환경
    EntityManager em;

    public Member createMember(){

        MemberFormDto memberFormDto = new MemberFormDto();
        memberFormDto.setEmail("test@email.com");
        memberFormDto.setName("홍길동");
        memberFormDto.setAddress("서울시 마포구 합정동");
        memberFormDto.setPassword("1234");

        return Member.createMember(memberFormDto, passwordEncoder);

    }

    @Test
    @DisplayName("장바구니 회원 엔티티 매핑 조회 테스트")
    public void findCartAndMemberTest(){
        Member member = createMember();
        memberRepository.save(member);

        Cart cart = new Cart();
        cart.setMember(member);
        cartRepository.save(cart);
        
        em.flush(); // 영속성 컨텍스트에 데이터를 저장 후 트랜잭션이 끝날 때 flush() 호출하여 DB에 반영
        em.clear(); // 영속성 컨텍스트에 조회 후 엔티티가 없을 경우 데이터 베이스를 조회, 영속성 컨텍스트를 비운다
        
        // Member 테이블에 저장 되고 Cart 테이블에 저장
        /*
            findById select * from cart where id = ?
            위 쿼리문에서 문제가 발생하면 EntityNotFoundException Throw
            orElseThrow 👉 EntityNotFoundException(결과가 없을때)
            위 쿼리문에서 문제가 없으면 Cart(Entity)
         */
        Cart savedCart = cartRepository.findById(cart.getId()).orElseThrow(EntityNotFoundException::new);
        // savedCart의 member_id와 member_id가 같나 비교
        assertEquals(savedCart.getMember().getId(), member.getId());

    }

}

📍결과

select
        c1_0.cart_id,
        m1_0.member_id,
        m1_0.address,
        m1_0.email,
        m1_0.name,
        m1_0.password,
        m1_0.role,
        m1_0.tel_number 
    from
        cart c1_0 
    left join
        member m1_0 
            on m1_0.member_id=c1_0.member_id 
    where
        c1_0.cart_id=?

👉 left 조인 성공, 즉시 로딩으로 Cart 엔티티를 조회할 때, 매핑된 엔티티도 한 번에 조회(default) 👉 @OnetoOne(fetch = FetchType.EAGER) 이 디폴트라는 것. 많이 쓰는 것은 지연 로딩 LAZY. 나중에 나올 예정.

📌1:N/N:1 단방향 관계

cart(장바구니) ⬅ cart_item(장바구니 안의 상품) ➡ item (판매 상품)
하나의 장바구니에 여러개의 상품을 담는 것

📍CartItem Entity 클래스 생성

package com.shop.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

@Entity
@Getter
@Setter
@Table(name = "cart_item")
public class CartItem {

    @Id
    @GeneratedValue
    @Column(name = "cart_item_id")
    private Long id;

    // 1 : N
    @ManyToOne // CartItem : Cart, 클래스 : 변수 👉 이런 식으로 알면 편하다.
    @JoinColumn(name = "cart_id")
    private Cart cart;

    // N : 1
    @ManyToOne // CartItem : Item, 클래스 : 변수 👉 이런 식으로 알면 편하다.
    @JoinColumn(name = "item_id")
    private Item item;

    // 상품 개수 count
    private int count;

}

📍결과

👉 cart 테이블 생성

👉 cart_item 테이블 생성

👉 item 테이블 생성

👉 alter 명령어로 각각 외래키(FK) 지정

📌1:N/N:1 단방향 관계 2

order ➡ member
회원 한명이 주문을 여러개 한다

📍OrderStatus Enum 클래스 생성

package com.shop.constant;

public enum OrderStatus {
    
    // 주문, 취소. 환불 같은 건 나중에
    ORDER, CANCEL
}

📍Order Entity 클래스 생성

package com.shop.entity;

import com.shop.constant.OrderStatus;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import javax.annotation.processing.Generated;
import java.time.LocalDateTime;

@Entity
@Table(name = "orders")
@Getter
@Setter
public class Order {

    @Id
    @GeneratedValue
    @Column(name = "order_id")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "member_id")
    private Member member;

    private LocalDateTime orderDate;

    @Enumerated(EnumType.STRING)
    private OrderStatus orderStatus;
    
    private LocalDateTime regTime;
    
    private LocalDateTime updateTime;


}

📍결과

👉 alter 명령어로 각각 외래키(FK) 지정

🤦‍♀️ MySQL 다이어 그램 만들기

👉 중간에 비밀번호 넣어주면 된다.

👉 외래키

👉 기본키

👉 테이블을 눌러가며 어떤 것이 사용되는지 확인 할 수 있다

📌N:M 단방향 관계

member ↔ item
1:N ↔ N:1 형태로 교차 엔티티를 자동으로 만든다. 이런 식으로 연결 된 테이블에는 컬럼을 추가할 수 없어 사용 할 일은 많지 않다.

📍Item Entity 클래스 수정

    private LocalDateTime updateTime; // 수정 시간

    @ManyToMany
    // 중간 테이블을 넣는 과정
    @JoinTable(
            name = "member_item",
            joinColumns = @JoinColumn(name = "member_id"),
            inverseJoinColumns = @JoinColumn(name = "item_id")
    )
    private List<Member> member; // Member에서 외래키를 가져 왔으니 Member가 주인
}

---

📌양방향 관계

엔티티를 양방향으로 연관 관계를 설정하면 객체의 참조는 둘인데 외래키는 하나인 관계.
즉, 외래키를 서로 갖고 있다 👉 주인과 부하 관계를 정립하기 쉽지 않다.
Java에서는 List<>등 을 추가하며 관계를 나타내는데 DB 에서는 따로 나타낼 것이 없고 그냥 넣으면 된다.

주인과 부하를 정하는 규칙

• 연관 관계의 주인(PK)은 외래키(FK)가 있는 곳으로 설정
• 연관 관계의 주인(PK)이 외래키(FK)를 관리(등록, 수정, 삭제)
• 부하는 연관 관계 매핑 시 mappedBy 속성 값으로 주인 지정. 읽기만 가능하다 👉 서로 외래키를 갖고 있으므로 mappedBy를 갖는 쪽이 부하
  👉 주인은 mappedBy 속성 사용 ❌, 부하는 mappedBy 속성으로 주인 지정

  ❓📍 mappedBy를 적어주는 이유는 뭘까? (by 김영한)

  객체와 테이블간의 연관관계를 맺는 차이를 이해해야 한다

  MEMBER과 TEAM을 예시로 들어보면
  
  객체 연관 관계는
  회원 ➡ 팀 연관관계 1개 (단방향)
  팀 ➡ 회원 연관관계 1개 (단방향) 이며
  테이블 연관 관계는
  회원 ↔ 팀 연관관게로 양방향 이다.

  여기서 차이점은 객체의 양방향 관계는 사실 양방향 관계가 아니라 서로 다른 단방향 관계 2개 이다. 즉, 객체를 양방향으로 참조하려면 단방향 연관 관계 2개를 만들어야 한다( a.getB(), b.getA() 👉 use 관계 )
  하지만 테이블의 양방향 관계는 외래키 하나로 두 테이블의 연관 관계를 관리한다. MEMBER.TEAM_ID 외래키 하나로 양방향 연관 관계를 갖는다. 즉, 양쪽으로 Join이 가능하다.

  그럼 어떤 외래키로 관리를 해야할까? TEAM.MEMBER_ID 로 관리가 가능할까? 둘 중에 뭘 믿어야해? TEAM을 업데이트 했는데 왜 안되는거야?? 왜 MEMBER가 바뀌지?? 아니 왜 값이 안들어가?? 반대로하니까 값이 들어가는데?? 버근가???

  👉 그래서 규칙을 하나 정했다. 둘다 동시에 들어가면 연관 관계의 주인만 관리를 한다.

  👉 주인과 부하를 정하는 규칙 을 mappedBy 하기로 한 것

  ❓그래서 누구를 주인으로 해야하는데?

  답은 99% 정해져 있다. 외래키를 갖고 있는 곳을 주인으로 정하자. 인지부조화를 차단하자.
  

  👉 여기서는 Member.team이 연관관계의 주인.
  일단 단방향 매핑으로 개발을 하고 양방향이 필요할 때 Java에 몇줄 추가해 줘서(DB에는 영향이 없으니) 추가해 주면 된다.

  즉, 단방향 매핑만으로도 ORM 매핑을 끝낼 수 있다. 양방향 매핑은 단순하게 조회하는 것을 편하게 하기 위해 추가하는 부가적인 기능이라 생각하면 된다.

  값을 입력할 땐 주인에 값을 입력하면 되는데 순수한 객체 관계를 고려한다면 항상 양쪽 다 값을 입력해야 한다.

양방향 매핑의 장점

• 단방향 매핑만으로도 이미 연관관계 매핑은 완료
• 양방향 매핑은 반대 방향으로 조회(객체 그래프 탐색) 기능이 추가 된 것 뿐이다
• JPQL에서 역방향으로 탐색할 일이 많다
• 단방향 매핑을 잘 하고 양방향은 필요할 때 추가해도 된다.

member ⬅ orders ↔ order_item

👉 한 명의 회원은 여러 번 주문 가능하며 한 번의 주문에 여러 개의 상품을 주문 가능

📍OrderItem Entity 클래스 생성

package com.shop.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDateTime;

@Entity
@Getter
@Setter
// 테이블명이 없으면 알아서 만듦
public class OrderItem {
    @Id
    @GeneratedValue
    @Column(name = "order_item_id")
    private Long id;

    @ManyToOne
    @JoinColumn(name = "item_id") // 외래키
    private Item item;

    @ManyToOne
    @JoinColumn(name = "order_id") // 외래키
    private Order order;

    private int orderPrice;

    private int count;

    private LocalDateTime regTime;

    private LocalDateTime updateTime;
}

📍Order Entity 클래스 수정

...

    @ManyToOne
    @JoinColumn(name = "member_id") // Order : Member
    private Member member;

    // 서로 외래키를 갖고 있지만
    // mappedBy로 주인/부하 관계를 지정. 즉, order_item이 주인
    // Join 컬럼을 사용하지 않는다
    @OneToMany(mappedBy = "order") // order_item 테이블의 order 필드에 매핑
    private List<OrderItem> orderItems = new ArrayList<>(); 

    private LocalDateTime orderDate;
    
...

---

👁‍🗨쇼핑몰 프로젝트 ERD