[SpringBoot] mallangShop

📍 GitHub 바로가기

1 JWT 설계

1️⃣ JWT dependency

compileOnly group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.2'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.2'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.2'

2️⃣ SecretKey → application.properties

jwt.secret.key=7ZWt7ZW0OTntmZTsnbTtjIXtlZzqta3snYTrhIjrqLjshLjqs4TroZzrgpjslYTqsIDsnpDtm4zrpa3tlZzqsJzrsJzsnpDrpbzrp4zrk6TslrTqsIDsnpA=

3️⃣ JwtUtil.java

@Slf4j
@Component
@RequiredArgsConstructor
public class JwtUtil {

    /* 1. JWT Token 생성 필요값 */
    // Header Key 값
    public static final String AUTHORIZATION_HEADER = "Authorization";

    // 사용자 권한값 Key
    public static final String AUTHORIZATION_KEY = "auth";

    // JWT Token 인증방식 (Bearer + JWT Token 함께 전송)
    private static final String BEARER_PREFIX = "Bearer ";

    // JWT Token 만료시간
    private static final long TOKEN_TIME = 60 * 60 * 1000L; // ms기준 -> 1시간

    // application.properties -> JWT Secret Key 불러옴
    @Value("${jwt.secret.key}")
    private String secretKey;

    // JWT Token 생성 및 검증 Key 저장용도
    private Key key;

    // JWT Token 생성(사인)알고리즘
    private final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

    // Spring Bean 초기화 -> 실행되는 메서드
    @PostConstruct
    public void init() {
        // secretKey -> 디코딩 -> byte배열에 담음
        byte[] bytes = Base64.getDecoder().decode(secretKey);

        // 디코딩 한 byte배열 -> JWT Token 서명 및 검증에 필요한 key 생성
        key = Keys.hmacShaKeyFor(bytes);
    }


    /* 2. Client Request Header -> JWT Token 가져오기 */
    public String getToken(HttpServletRequest httpServletRequest) {

        // Header에 있는 JWT Token -> clientToken에 담음
        String clientToken = httpServletRequest.getHeader(AUTHORIZATION_HEADER);

        // clientToken 존재 + Bearer로 시작 -> JWT Token 값만 추출
        if (StringUtils.hasText(clientToken) && clientToken.startsWith(BEARER_PREFIX)) {
            return clientToken.substring(7);
        }

        return null;

    }


    /* 3. JWT Token 생성 */
    public String createToken(String username, UserRoleEnum userRoleEnum) {

        Date date = new Date();

        return BEARER_PREFIX +
                Jwts.builder()
                        .setSubject(username)
                        .claim(AUTHORIZATION_KEY, userRoleEnum)
                        .setExpiration(new Date(date.getTime() + TOKEN_TIME))
                        .setIssuedAt(date)
                        .signWith(key, signatureAlgorithm)
                        .compact();

    }


    /* 4. JWT Token 검증 */
    public boolean validateToken(String token) {

        try {

            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;

        } catch (SecurityException | MalformedJwtException exception) {
            log.info("Invalid JWT signature, 유효하지 않는 JWT 서명 입니다");
        } catch (ExpiredJwtException exception) {
            log.info("Expired JWT Token, 만료된 JWT Token 입니다");
        } catch (UnsupportedJwtException exception) {
            log.info("Unsupported JWT Token, 지원되지 않는 JWT Token 입니다");
        } catch (IllegalArgumentException exception) {
            log.info("JWT claims is empty, 잘못된 JWT Token 입니다");
        }

        return false;

    }


    /* 5. JWT Token -> 회원정보 가져오기 */
    public Claims getUserInfoFromToken(String token) {

        return Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token).getBody();

    }

}

• import org.springframework.beans.factory.annotation.Value; → @Value import문 수정적용

---

2 JWT적용 설계

로그인성공 → HTTP Response Header에 JWT Token 생성 후, 실어 Client에게 보냄

1️⃣ UserController.java

/* 앞부분 생략 */

	// 로그인
    @ResponseBody
    @PostMapping("/login")
    public String login(@RequestBody LoginRequestDto loginRequestDto, HttpServletResponse httpServletResponse) {

        userService.login(loginRequestDto, httpServletResponse);

        return "success";

    }

2️⃣ UserService.java

/* 앞부분 생략 */
// 로그인
    @Transactional(readOnly = true)
    public void login(LoginRequestDto loginRequestDto, HttpServletResponse httpServletResponse) {

        // 1. RequestDto -> ID/PW 가져옴
        String username = loginRequestDto.getUsername();
        String password = loginRequestDto.getPassword();

        // 2. 회원유효성검사
        User user = userRepository.findByUsername(username).orElseThrow(
                () -> new IllegalArgumentException("등록된 사용자가 없습니다")
        );

        // 3. 비밀번호유효성검사
        if (! user.getPassword().equals(password)) {
            throw new IllegalArgumentException("비밀번호가 일치하지 않습니다");
        }

        // 4. 로그인성공 -> Http Response Header에 JWT Token 보내기
        httpServletResponse.addHeader(JwtUtil.AUTHORIZATION_HEADER, jwtUtil.createToken(user.getUsername(), user.getRole()));

    }

---

3 JWT인가 설계

1️⃣ 관심상품 조회

📍 ProductController.java

/* 앞부분 생략 */

    // 관심상품 조회
    @GetMapping("/products")
    public List<ProductResponseDto> getProducts(HttpServletRequest httpServletRequest) {

        return productService.getProducts(httpServletRequest);

    }
    
/* 뒷부분 생략 */

📍 ProductService.java

/* 앞부분 생략 */

	// 관심상품 조회
    @Transactional(readOnly = true)
    public List<ProductResponseDto> getProducts(HttpServletRequest httpServletRequest) {

        // 1. HTTP Request Header -> JWT Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // 2. JWT Token 있는경우에만 -> 관심상품 조회 가능
        if (token != null) {

            // 2-1. JWT Token 검증
            if (jwtUtil.validateToken(token)) {

                // true -> Token에서 사용자정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);

            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 2-2. Token에서 가져온 사용자정보 -> DB조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다")
            );

            // 2-3. 사용자권한 ADMIN ; 전체조회, USER ; 본인 관심상품조회
            UserRoleEnum userRoleEnum = user.getRole();
            System.out.println("role = " + userRoleEnum);

            List<ProductResponseDto> productResponseDtoList = new ArrayList<>();
            List<Product> productList;

            if (userRoleEnum == UserRoleEnum.USER) {
                productList = productRepository.findAllByUserId(user.getId());
            } else {
                productList = productRepository.findAll();
            }

            for (Product product : productList) {
                productResponseDtoList.add(ProductResponseDto.of(product));
            }

            return productResponseDtoList;

        } else {

            return null;

        }

    }

/* 뒷부분 생략 */

2️⃣ 관심상품 등록

📍 ProductController.java

/* 앞부분 생략 */

	// 관심상품 등록
    @PostMapping("/products")
    public ProductResponseDto createProduct(@RequestBody ProductRequestDto productRequestDto, HttpServletRequest httpServletRequest) {

        return productService.createProduct(productRequestDto, httpServletRequest);

    }

/* 뒷부분 생략 */

📍 ProductService.java

/* 앞부분 생략 */

// 관심상품 등록
    @Transactional
    public ProductResponseDto createProduct(ProductRequestDto productRequestDto, HttpServletRequest httpServletRequest) {

        // 1. HTTP Request Header -> JWT Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // 2. JWT Token 있는경우에만 -> 관심상품 등록 가능
        if (token != null) {

            // 2-1. JWT Token 검증
            if (jwtUtil.validateToken(token)) {

                // true -> Token에서 사용자정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);

            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 2-2. Token에서 가져온 사용자정보 -> DB조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다")
            );

            // 2-3. 요청받은 DTO -> DB에 저장할 객체생성
            Product product = productRepository.saveAndFlush(Product.of(productRequestDto, user.getId()));

            return ProductResponseDto.of(product);

        } else {

            return null;

        }

    }

/* 뒷부분 생략 */

3️⃣ 관심상품 최저가 등록

📍 ProductController.java

/* 앞부분 생략 */

	@PutMapping("/products/{id}")
    public Long updateProduct(@PathVariable Long id, @RequestBody ProductMypriceRequestDto productMypriceRequestDto, HttpServletRequest httpServletRequest) {

        return productService.updateProduct(id, productMypriceRequestDto, httpServletRequest);

    }

/* 뒷부분 생략 */

📍 ProductService.java

/* 앞부분 생략 */

	// 관심상품 최저가 등록
    @Transactional
    public Long updateProduct(Long id, ProductMypriceRequestDto productMypriceRequestDto, HttpServletRequest httpServletRequest) {

        // 1. HTTP Request Header -> JWT Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // 2. JWT Token 있는경우에만 -> 관심상품 등록 가능
        if (token != null) {

            // 2-1. JWT Token 검증
            if (jwtUtil.validateToken(token)) {

                // true -> Token에서 사용자정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);

            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 2-2. Token에서 가져온 사용자정보 -> DB조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다")
            );

            Product product = productRepository.findByIdAndUserId(id, user.getId()).orElseThrow(
                    () -> new IllegalArgumentException("해당상품은 존재하지 않습니다")
            );

            product.update(productMypriceRequestDto);

            return product.getId();

        } else {

            return null;

        }
    }

/* 뒷부분 생략 */

---

4 페이징 및 정렬

구분	종류
페이징	- page : 조회할 페이지 번호 (1부터 시작) - size : 한 페이지에 보여줄 내용 갯수 (10개로 고정)
정렬	- sortBy (정렬항목) : id, title, lprice - isAsc (오름차순) : true → asc 오름차순, false → desc 내림차순

1️⃣ API 명세서 - Product 변경

기능	Method	URL	Request	Response
메인페이지	GET	/api/shop	-	index.html
Query로 상품검색, 상품검색결과 목록반환	GET	/api/search?query=검색어	-	[ {   "title" : String,   "image" : String,   "link" : String,   "lprice" : int }, ••• ]
관심상품 등록	POST	/api/products	Header Authorization : Bearer <JWT> {   "title" : String,   "image" : String,   "link" : String,   "lprice" : int }	{   "id" : Long,   "title" : String,   "image" : String,   "link" : String,   "lprice" : int,   "myprice" : int }
관심상품 조회	GET	/api/products?sortBy=String&isAsc=boolean&size=int&page=int	Header Authorization : Bearer <JWT>	Page<Product>
관심상품 최저가 등록	PUT	/api/products/{id}	Header Authorization : Bearer <JWT> {   "myprice" : int }	id

2️⃣ ProductController.java

/* 앞부분 생략 */

	// 관심상품 조회
    @GetMapping("/products")
    public Page<Product> getProducts(
            @RequestParam("page") int page, // 조회할 페이지 번호 (1부터 시작)
            @RequestParam("size") int size, // 한 페이지에 보여줄 개수
            @RequestParam("sortBy") String sortBy, // 정렬항목
            @RequestParam("isAsc") boolean isAsc, // 오름차순(True), 내림차순(False)
            HttpServletRequest httpServletRequest) {

        return productService.getProducts(httpServletRequest, page-1, size, sortBy, isAsc);

    }

/* 뒷부분 생략 */

3️⃣ ProductService.java

/* 앞부분 생략 */

	// 관심상품 조회
    @Transactional(readOnly = true)
    public Page<Product> getProducts(HttpServletRequest httpServletRequest,
                                     int page, int size, String sortBy, boolean isAsc) {

        // 페이징
        Sort.Direction direction = isAsc ? Sort.Direction.ASC : Sort.Direction.DESC;

        Sort sort = Sort.by(direction, sortBy);

        Pageable pageable = PageRequest.of(page, size, sort);

        // 1. HTTP Request Header -> JWT Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // 2. JWT Token 있는경우에만 -> 관심상품 조회 가능
        if (token != null) {

            // 2-1. JWT Token 검증
            if (jwtUtil.validateToken(token)) {

                // true -> Token에서 사용자정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);

            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 2-2. Token에서 가져온 사용자정보 -> DB조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다")
            );

            // 2-3. 사용자권한 ADMIN ; 전체조회, USER ; 본인 관심상품조회
            UserRoleEnum userRoleEnum = user.getRole();
            System.out.println("role = " + userRoleEnum);

            Page<Product> productPage;

            if (userRoleEnum == UserRoleEnum.USER) {
                productPage = productRepository.findAllByUserId(user.getId(), pageable);
            } else {
                productPage = productRepository.findAll(pageable);
            }

            return productPage;


        } else {

            return null;

        }

    }

/* 뒷부분 생략 */

4️⃣ ProductRepository.java

/* 앞부분 생략 */

public interface ProductRepository extends JpaRepository<Product, Long> {

    Page<Product> findAllByUserId(Long userId, Pageable pageable);

    Optional<Product> findByIdAndUserId(Long id, Long userId);

    Page<Product> findAll(Pageable pageable);

}

/* 뒷부분 생략 */

---

5 폴더설계 및 JPA 연관관계

1️⃣ 서비스요구사항

요구사항	기능
폴더 생성	- 회원별 폴더 추가 가능 - 폴더 추가 시, 1~N개 한번에 추가 가능
폴더에 관심상품 삽입	- 관심상품은 폴더 N개에 들어갈 수 있음 - 관심상품이 등록되는 시점 → 어느 폴더에도 저장 ❌
폴더 별 조회	- 회원은 폴더 별 관심상품 조회 가능 - 전체 : 폴더와 상관없이 회원이 저장한 전체 관심상품 조회 - 폴더명 : 폴더 별 저장된 관심상품만 조회 가능

2️⃣ JPA 연관관계 설정

• 회원 1명이 여러개의 폴더를 가질 수 있음 → @OneToMany

public class User {

	@OneToMany
    private List<Folder> folderList;

}

// 회원이 가진 폴더 조회
List<Folder> folderList = user.getFolderList();

• 폴더 여러개를 회원 1명이 가질 수 있음 → @ManyToOne

public class Folder {
	
    @ManyToOne
    private User user;
    
}

// 폴더 소유 회원 조회
folder.getUser();

• JPA 연관관계 Column 설정

@ManyToOne
@JoinColumn(name = "USER_ID", nullable = false)
private User user;

// name : 외래키명
// nullable : 외래키 null 허용여부

---

6 폴더생성 및 조회 설계

1️⃣ API 명세서 - 폴더생성 및 조회

기능	Method	URL	Request	Response
폴더 생성	POST	api/folders	{   "folderNames" : [String, •••] }	[String, •••]
폴더 조회	GET	api/user-folder	-	index.html model 추가 → folders

2️⃣ 폴더생성 설계

User.java

/* 앞부분 생략 */

@OneToMany
List<Folder> folders = new ArrayList<>();

/* 뒷부분 생략 */

Folder.java

@Entity
@Getter
@NoArgsConstructor
public class Folder {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(nullable = false)
    private String name;

    @ManyToOne
    @JoinColumn(name = "USER_ID", nullable = false)
    private User user;

    // 생성자
    public Folder(String name, User user) {

        this.name = name;
        this.user = user;

    }

}

FolderRequestDto.java

@Getter
public class FolderRequestDto {

    List<String> folderNames;

}

FolderController.java

@RestController
@RequiredArgsConstructor
@RequestMapping("/api")
public class FolderController {

    private final FolderService folderService;

    // 폴더 생성
    @PostMapping("/folders")
    public List<Folder> addFolders(@RequestBody FolderRequestDto folderRequestDto, HttpServletRequest httpServletRequest) {

        List<String> folderNames = folderRequestDto.getFolderNames();

        return folderService.addFolders(folderNames, httpServletRequest);

    }
    
}

FolderService.java

@Service
@RequiredArgsConstructor
public class FolderService {

    private final FolderRepository folderRepository;
    private final UserRepository userRepository;
    private final JwtUtil jwtUtil;


    // 폴더 생성
    @Transactional
    public List<Folder> addFolders(List<String> folderNames, HttpServletRequest httpServletRequest) {

		// Client Request -> Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // Token 유효 -> 폴더생성 가능
        if (token != null) {

            // Token 검증
            if (jwtUtil.validateToken(token)) {
                // 토큰 -> 사용자 정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);
            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 토큰에서 가져온 사용자 정보를 사용하여 DB 조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다.")
            );

            List<Folder> folderList = new ArrayList<>();

            for (String folderName : folderNames) {
            
                Folder folder = new Folder(folderName, user);
                folderList.add(folder);
                
            }

            return folderRepository.saveAll(folderList);
            
        } else {
        
            return null;
            
        }
    }

    // 폴더 조회
    public List<Folder> getFolders(HttpServletRequest httpServletRequest) {

        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        if (token != null) {
            
            if (jwtUtil.validateToken(token)) {
                claims = jwtUtil.getUserInfoFromToken(token);
            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 토큰에서 가져온 사용자 정보를 사용하여 DB 조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다.")
            );

            return folderRepository.findAllByUser(user);

        } else {
            return null;
        }
    }

}

FolderRepository.java

public interface FolderRepository extends JpaRepository<Folder, Long> {

    List<Folder> findAllByUser(User user);
    
}

ShopController.java

@Controller
@RequiredArgsConstructor
@RequestMapping("/api")
public class ShopController {

    private final FolderService folderService;

    @GetMapping("/shop")
    public ModelAndView shop() {
        return new ModelAndView("index");
    }

    // 로그인 한 유저 -> 메인페이지 요청 시, 폴더 자동 조회
    @GetMapping("/user-folder")
    public String getUserInfo(Model model, HttpServletRequest httpServletRequest) {

        model.addAttribute("folders", folderService.getFolders(httpServletRequest));

        return "/index :: #fragment";
    }

}

---

7 관심상품 폴더추가기능 설계

1️⃣ 요구사항

📌 Folder와 Product JPA 연관관계 ➡️ M : N

• 관심상품 → 폴더 0 ~ N개 설정가능

• 관심상품 등록시점 → 어떤 폴더에도 저장 ❌

• 관심상품 → 기 생성된 폴더를 선택해 추가가능

2️⃣ API 명세서 - 관심상품 폴더추가기능

기능	Method	URL	Request	Response
폴더 전체 조회	GET	api/folders	-	[ {   "id" : int,   "name" : String,   "user" : {     "id" : int,     "username" : String,     "password" : String,     "email" : String,      "role" : String,      "folders" : []    } }, ••• ]
관심상품에 폴더 추가	POST	api/products/{productId}/folder	{productId} : 관심상품 Id [Form 형태] folderId : 추가할 폴더 Id	폴더가 추가 된 관심상품 Id

3️⃣ 폴더 전체 조회

FolderController.java

/* 앞부분 생략 */

	// 폴더 전체 조회
    @GetMapping("/folders")
    public List<Folder> getFolders(HttpServletRequest httpServletRequest) {
    
        return folderService.getFolders(httpServletRequest);
        
    }

/* 뒷부분 생략 */

4️⃣ 관심상품에 폴더추가

ProductController.java

/* 앞부분 생략 */

	// 관심상품에 폴더추가
    @PostMapping("products/{productId}/folder")
    public Long addFolder(@PathVariable Long productId, @RequestParam Long folderId, HttpServletRequest httpServletRequest) {

        Product product = productService.addFolder(productId, folderId, httpServletRequest);

        return product.getId();

    }

ProductService.java

/* 앞부분 생략 */

	// 관심상품에 폴더추가
    @Transactional
    public Product addFolder(Long productId, Long folderId, HttpServletRequest httpServletRequest) {

        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        if (token != null) {

            if (jwtUtil.validateToken(token)) {
                claims = jwtUtil.getUserInfoFromToken(token);
            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 사용자 유효성검사
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다")
            );

            // 상품 유효성검사
            Product product = productRepository.findById(productId)
                    .orElseThrow( () -> new NullPointerException("해당 상품 아이디가 존재하지 않습니다") );

            // 폴더 유효성검사
            Folder folder = folderRepository.findById(folderId)
                    .orElseThrow( () -> new NullPointerException("해당 폴더 아이디가 존재하지 않습니다") );

            // 상품, 폴더 -> 같은 회원 소유인지 확인
            Long loginUserId = user.getId();

            if (! product.getUserId().equals(loginUserId) || ! folder.getUser().getId().equals(loginUserId)) {
                throw new IllegalArgumentException("회원님의 관심상품이 아니거나, 회원님의 폴더가 아닙니다");
            }

            product.addFolder(folder);

        } else {

            return null;

        }

    }

Product.java

/* 앞부분 생략 */

	@ManyToMany
    private List<Folder> folderList = new ArrayList<>();
    
    /* 중간부분 생략 */
    
    // 관심상품에 폴더추가
    public void addFolder(Folder folder) {
        this.folderList.add(folder);
    }
    
/* 뒷부분 생략 */

---

8 폴더별 관심상품조회 설계

1️⃣ 요구사항

• 회원은 폴더 별 관심상품 조회가능

  • '폴더별' : 폴더별 저장된 관심상품 조회가능

  • '전체' : 폴더와 상관없이 회원이 저장한 전체 관심상품 조회가능

2️⃣ API 명세서 - 폴더별 관심상품조회

기능	Method	URL	Request	Response
폴더 별 관심상품 조회	GET	api/folders/{folderId}/products	{folderId} : 조회를 원하는 폴더 Id	Page<Product>

FolderController.java

/* 앞부분 생략 */

	// 폴더 별 관심상품 조회
    @GetMapping("/folders/{folderId}/products")
    public Page<Product> getProductsInFolder (@PathVariable Long folderId,
                                              @RequestParam int page,
                                              @RequestParam int size,
                                              @RequestParam String sortBy,
                                              @RequestParam boolean isAsc,
                                              HttpServletRequest httpServletRequest) {

        return folderService.getProductsInFolder(folderId, page-1, size, sortBy, isAsc, httpServletRequest);

    }

FolderService.java

/* 앞부분 생략 */

	@Transactional(readOnly = true)
    public Page<Product> getProductsInFolder(Long folderId, int page, int size, String sortBy, boolean isAsc, HttpServletRequest httpServletRequest) {

        // 페이징 처리
        Sort.Direction direction = isAsc ? Sort.Direction.ASC : Sort.Direction.DESC;
        Sort sort = Sort.by(direction, sortBy);
        Pageable pageable = PageRequest.of(page, size, sort);

        // Request에서 Token 가져오기
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        // 토큰이 있는 경우에만 관심상품 조회 가능
        if (token != null) {
            // Token 검증
            if (jwtUtil.validateToken(token)) {
                // 토큰에서 사용자 정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);
            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 토큰에서 가져온 사용자 정보를 사용하여 DB 조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다.")
            );

            return productRepository.findAllByUserIdAndFolderList_Id(user.getId(), folderId, pageable);

        } else {
            return null;
        }

ProductRepository.java

public interface ProductRepository extends JpaRepository<Product, Long> {

	Page<Product> findAllByUserIdAndFolderList_Id(Long userId, Long folderId, Pageable);

}

---

9 폴더명 중복 Issue

1️⃣ 중복검사 메서드추가

FolderService.java

private boolean isExistFolderName(String folderName, List<Folder> existFolderList) {

        // 기존 폴더 리스트에서 folder name 이 있는지 검사
        for (Folder existFolder : existFolderList) {
        
            if (existFolder.getName().equals(folderName)) {
                return true;
            }
            
        }

        return false;
    }

2️⃣ 폴더생성 시, 중복검사 메서드사용

FolderService.java

/* 폴더생성 addFolders 메서드 */

	// 폴더명 중복검사
    List<Folder> existFolderList = folderRepository.findAllByUserAndNameIn(user, folderNames);

	List<Folder> folderList = new ArrayList<>();

	for (String folderName : folderNames) {

		if (! isExistFolderName(folderName, existFolderList)) {

			Folder folder = new Folder(folderName, user);
            folderList.add(folder);

		}

	}

	return folderRepository.saveAll(folderList);

3️⃣ FolderRepository.java

/* 앞부분 생략 */

	List<Folder> findAllByUserAndNameIn(User user, List<String> names);

---

10 폴더 내 관심상품 중복생성 Issue

1️⃣ ProductService.java

/* 관심상품에 폴더추가 addFolder 메서드 */

	// 중복확인
    Optional<Product> overlapFolder = productRepository.findbyIdAndFolderList_Id(product.getId(), folder.getId());
    
    if (overlapFolder.isPresent()) {
    	throw new IllegalArgumentException("중복된 폴더입니다");
    }
    
    product.addFolder(folder);

2️⃣ ProductRepository.java

/* 앞부분 생략 */

	Optional<Product> findByIdAndFolderList_Id(Long productId, Long folderId);

---

Outro

• 로그인 한 User가 메인페이지 요청 시, 유저의 이름 반환

• ShopController.java

@GetMapping("/user-info")
    @ResponseBody
    public String getUserName(HttpServletRequest httpServletRequest) {
        String token = jwtUtil.getToken(httpServletRequest);
        Claims claims;

        if (token != null) {
            // Token 검증
            if (jwtUtil.validateToken(token)) {
                // 토큰에서 사용자 정보 가져오기
                claims = jwtUtil.getUserInfoFromToken(token);
            } else {
                throw new IllegalArgumentException("Token Error");
            }

            // 토큰에서 가져온 사용자 정보를 사용하여 DB 조회
            User user = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new IllegalArgumentException("사용자가 존재하지 않습니다.")
            );

            return user.getUsername();
        }else {
            return "fail";
        }
    }