⚜ 개요

가. 소개

• 사이트 소개 : ToolTool
• 캠핑용품 리뷰 및 판매글 커뮤니티
• 타임리프를 사용한 템플릿 적용
• NCP, Nginx , Docker와 Jenkins 를 사용한 배포 및 자동화 //아직보류

나. 사이트

• ToolTool
• 발표

🔰 환경

가. 형상관리

• 깃허브 형상관리 :

나. 사용기술

1-1 기술스택

	⚓ 
	- Spring Boot
	- HTML5 / CSS5 / JS
	- jQuery
	- MariaDB
	- Java

1-2 개발환경

	⚓
	- SQL yog
    - DBeaver
	- Chrome
	- Intellij
    - Windows 10
    - Windows 11

1-3 배포

	⚓
	- GITHUB
	- Docker
	- Jenkins CI / CD

1-4 서비스 환경

	⚓
	- NGINX
	- MariaDB
	- Docker
	- CentOS7
    - NCP

1-5 ERD

💬 요구사항과 기능구현 여부

목록	요구사항	이용대상	기능종류	구현여부	비고
RQ-001-C	리뷰게시판에 게시글을 작성할 수 있다	회원,관리자	등록	✅
RQ-002-R	리뷰게시판 게시글 검색이 가능하다	회원,관리자	검색	✅
RQ-003-R	리뷰게시판 특정 단어 포함한 게시글 검색어 가능하다	회원,관리자	검색	✅
RQ-004-C-R-U-D	리뷰게시글 댓글 등록이 가능하다	회원,관리자	등록	✅
RQ-005-C-D	리뷰게시글 게시글 추천 등록이 가능하다	회원,관리자	등록	✅
RQ-006-C-D	리뷰게시글 댓글 추천 등록이 가능하다	회원,관리자	등록	✅
RQ-007-R	리뷰게시글 작성 날짜순으로 출력되어 나와야한다	회원,관리자	출력	✅
RQ-008-R	리뷰게시글 작성 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-009-R	리뷰게시글 수정 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-010-R	댓글 작성 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-011-R	댓글 수정 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-012-C	판매게시판에 게시글을 작성할 수 있다	회원,관리자	등록	✅
RQ-013-R	판매게시판 게시글 검색이 가능하다	회원,관리자	검색	✅
RQ-014-R	판매게시판 특정 단어 포함한 게시글 검색어 가능하다	회원,관리자	검색	✅
RQ-015-C-R-U-D	판매게시글 댓글 등록이 가능하다	회원,관리자	등록	✅
RQ-016-C-D	판매게시글 게시글 추천 등록이 가능하다	회원,관리자	등록	✅
RQ-017-C-D	판매게시글 댓글 추천 등록이 가능하다	회원,관리자	등록	✅
RQ-018-R	판매게시글 작성 날짜순으로 출력되어 나와야한다	회원,관리자	출력	✅
RQ-019-R	판매게시글 작성 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-020-R	판매게시글 수정 날짜가 출력되어 나와야한다	회원,관리자	출력	✅
RQ-021-R	게시판의 페이지가 1페이지부터 출력되어 나와야한다.	회원,관리자	출력	✅
RQ-022-R	각 게시판에 카테고리 선택시 내용이 출력되어야한다.	회원,관리자	출력	✅
RQ-023-R	마이페이지 프로필사진,내가 쓴 리뷰 횟수,내가 쓴 판매 글 횟수가 출력되어 나와야한다	회원	출력	✅
RQ-024-R	마이페이지 내정보,내가 쓴 리뷰,내가 쓴 판매 글,내가 찜한 목록이 출력되어 나와야한다	회원	출력	✅
RQ-025-R	마이페이지 내가 쓴 리뷰가 출력되어 나와야한다	회원	출력	✅
RQ-026-R	마이페이지 내가 쓴 판매글이 출력되어 나와야한다	회원	출력	✅
RQ-027-R	마이페이지 내가 찜한 목록이 출력되어 나와야한다	회원	출력	✅
RQ-028-C-R-U-D	관리자페이지 공지사항을 관리한다	관리자	출력,등록	✅
RQ-029-R-D	관리자페이지 리뷰 글 삭제 관리한다	관리자	출력	✅
RQ-030-R-D	관리자페이지 판매 글 삭제 관리한다	관리자	출력	✅
RQ-031-R-D	관리자페이지 회원 정보 및 삭제 관리한다	관리자	출력	✅
RQ-032-R-D	관리자페이지 관리자 정보 및 삭제 관리한다	관리자	출력,등록	✅
RQ-033-C	회원가입 이용약관 선택이 가능하다	회원,관리자	등록	✅
RQ-034-C	회원가입이 가능하다	회원,관리자	등록	✅
RQ-035-C	로그인이 가능하다	회원,관리자	로그인	✅
RQ-036-C	로그인,비밀번호 찾기가 가능하다	회원,관리자	로그인	✅

💭 기능

	- 회원가입
	- 로그인 및 로그아웃(이메일인증)
    - 관리자페이지
    - 관리자(글관리, 마켓글관리, 회원관리, 관리자관리) 
	- 게시글 작성
	- 게시글 수정 및 삭제
	- 게시글 추천
	- 게시글 댓글 작성
  	- 게시글 댓글 수정 및 삭제
	- 게시글 댓글 추천
    - 판매글 작성
    - 판매글 수정 및 삭제
    - 판매글 찜
    - 판매글 댓글 작성
    - 판매글 댓글 수정 및 삭제
    - 판매글 댓글 추천
    - 마이페이지(프로필 변경, 내 정보 변경 , 내가 쓴 리뷰, 내가 쓴 판매글, 내가 쓴 찜목록)
    

🚩 기술설명

🪐서버 구조

🪐Termius

🪐 Nginx

🪐 Jenkins

🪐 Jenkins pipeline

🪐젠킨스 배포순서, 테스트 실패시

🪐젠킨스 배포순서, 테스트 성공시

♻ 페이지설명

✔ 메인페이지

✔ 로그인

✔ 회원가입약관 및 회원가입

@Service
@RequiredArgsConstructor
public class UserService {

    private final UserRepository userRepository;

    private final PasswordEncoder passwordEncoder;

    @Transactional
    public SiteUser create(String username, String password, String email, String nickname, int mailKey, UserRole role) {
        SiteUser user = new SiteUser();
        user.setUsername(username);
        user.setEmail(email);
        user.setNickname(nickname);
        user.setMailKey(mailKey);
        user.setPassword(passwordEncoder.encode(password));
        user.setCreateDate(LocalDate.now());
        this.userRepository.save(user);
        return user;
    }

    public void updateMailKey(int mailKey, String email, Long id) {
        userRepository.updateMailKey(mailKey, email, id);
    }

    public void updateMailAuth(String email, int mailKey) {
        int updatedRows = userRepository.updateMailAuth(email, mailKey);
        if (updatedRows > 0) {
            System.out.println("Mail auth updated successfully.");
        } else {
            System.out.println("Failed to update mail auth.");
        }
    }

    public long countByEmailAndMailAuth(String email) {
        return userRepository.countByEmailAndMailAuth(email, true);
    }

    public SiteUser getUser(String username) {
        Optional<SiteUser> siteUser = this.userRepository.findByusername(username);
        if (siteUser.isPresent()) {
            return siteUser.get();
        } else {
            throw new DataNotFoundException("siteuser not found");
        }
    }


    public boolean authenticateUser(String username, String password) {
        Optional<SiteUser> siteUserOptional = userRepository.findByusername(username);
        if (siteUserOptional.isPresent()) {
            SiteUser siteUser = siteUserOptional.get();
            return passwordEncoder.matches(password, siteUser.getPassword());
        }
        return false;
    }

    public SiteUser getUserByEmail(String email) {
        Optional<SiteUser> siteUserOptional = this.userRepository.findByEmail(email);
        if (siteUserOptional.isPresent()) {
            return siteUserOptional.get();
        } else {
            throw new DataNotFoundException("siteuser not found");
        }
    }


    public SiteUser getUserByEmailAndUsername(String email, String username) {
        Optional<SiteUser> siteUserOptional = userRepository.findByEmailAndUsername(email, username);
        if (siteUserOptional.isPresent()) {
            return siteUserOptional.get();
        } else {
            throw new DataNotFoundException("siteuser not found");
        }
    }


    public String generateTempPassword() {
        String characters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        StringBuilder sb = new StringBuilder();

        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            int index = random.nextInt(characters.length());
            sb.append(characters.charAt(index));
        }

        return sb.toString();
    }

    public boolean userEmailCheck(String userEmail, String userName) {

        SiteUser user = userRepository.findUserById(userEmail);
        if (user != null && user.getUsername().equals(userName)) {
            return true;
        } else {
            return false;
        }
    }

    public void updatePassword(String str, String userEmail) {
        String pw = passwordEncoder.encode(str);
        int id = userRepository.findUserById(userEmail).getId();
        userRepository.updateUserPassword(id, pw);
    }

    public SiteUser getUserByUsername(String username) {
        Optional<SiteUser> optionalUser = this.userRepository.findByUsername(username);
        return optionalUser.orElseThrow(() -> new DataNotFoundException("User not found"));
    }

    public SiteUser saveUser(SiteUser user) {
        return userRepository.save(user);
    }

    public SiteUser getUserById(int id) {
        return userRepository.findById(id);
    }

    public List<SiteUser> getAll() {
        return this.userRepository.findAll();
    }

    public List<SiteUser> getUserByUserRole(UserRole admin) {
        return this.userRepository.findUserByUserRole(UserRole.ADMIN);
    }

    public void changePhoto(SiteUser user, MultipartFile file) throws IOException {
        String projectPath = System.getProperty("user.dir") + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "static" + File.separator + "files";
        UUID uuid = UUID.randomUUID(); // 랜덤으로 이름을 만들어줄 수 있음
        // uuid는 파일에 붙일 랜덤이름을 생성

        String fileName = uuid + "_" + file.getOriginalFilename();
        // 랜덤이름(uuid)을 앞에다 붙이고 그 다음에 언더바(_) 하고 파일이름을 뒤에 붙여서 저장될 파일 이름을 생성해줌
        String filePath = "/files/" + fileName;

        File saveFile = new File(projectPath, fileName);
        file.transferTo(saveFile);
        user.setFilepath(filePath);
        user.setFilename(fileName);
        this.userRepository.save(user);
    }

    public void emailConfirm(String email, int mailKey) throws Exception {
        SiteUser user = this.getUserByEmail(email);

        if (user != null && user.getMailKey() == mailKey) {
            updateMailAuth(email, mailKey);
        } else {
            throw new Exception("유효하지 않은 이메일 또는 메일 키입니다.");
        }
    }
}

---

✔ 리뷰페이지

---

✔ 리뷰글작성

@Service
@RequiredArgsConstructor
public class ArticleService {

    private final ArticleRepository articleRepository;

    private Specification<Article> search(String kw) {
        return new Specification<>() {
            private static final long serialVersionUID = 1L;

            @Override
            public Predicate toPredicate(Root<Article> q, CriteriaQuery<?> query, CriteriaBuilder cb) {
                query.distinct(true);  // 중복을 제거
                Join<Article, SiteUser> u1 = q.join("author", JoinType.LEFT);
                Join<Article, Answer> a = q.join("answerList", JoinType.LEFT);
                Join<Answer, SiteUser> u2 = a.join("author", JoinType.LEFT);
                return cb.or(cb.like(q.get("subject"), "%" + kw + "%"), // 제목
                        cb.like(q.get("content"), "%" + kw + "%"),      // 내용
                        cb.like(u1.get("username"), "%" + kw + "%"),    // 질문 작성자
                        cb.like(a.get("content"), "%" + kw + "%"),      // 답변 내용
                        cb.like(u2.get("username"), "%" + kw + "%"));   // 답변 작성자
            }
        };
    }

    public Page<Article> getList(int page, String kw) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = search(kw);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getMainList(int page) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 3, Sort.by(sorts));
        return this.articleRepository.findAll(pageable);
    }

    public Page<Article> getHigtList(int page, String kw, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = search(kw);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getRowList(int page, String kw, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = search(kw);
        return this.articleRepository.findAll(spec, pageable);
    }


    public Page<Article> getUserList(int page, String kw, String user) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchUser(user);
        return this.articleRepository.findAll(spec, pageable);
    }


    private Specification<Article> searchUser(String user) {
        return (root, query, builder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Add a condition to check for equality between the username field and the provided user value
            predicates.add(builder.equal(root.get("author").get("username"), user));

            // Add any other search conditions if needed
            // ...

            return builder.and(predicates.toArray(new Predicate[0]));
        };
    }


    public Page<Article> getSeasonList(int page, String kw, String season) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchSeason(season);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getSeasonHighList(int page, String kw, String season, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchSeason(season);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getSeasonRowList(int page, String kw, String season, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchSeason(season);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Specification<Article> searchSeason(String sea) {
        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Season 컬럼을 기준으로 검색 조건 생성
            if (sea != null) {
                Path<String> seasonPath = root.get("season");
                Predicate seasonPredicate = criteriaBuilder.equal(seasonPath, sea);
                predicates.add(seasonPredicate);
            }

            // 다른 조건들을 추가하고 싶다면 여기에 추가

            // 검색 조건들을 조합하여 최종 검색 조건 생성
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }

    public Page<Article> getTypeList(int page, String kw, String type) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchType(type);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getTypeHighList(int page, String kw, String type, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchType(type);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getTypeRowList(int page, String kw, String type, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = searchType(type);
        return this.articleRepository.findAll(spec, pageable);
    }

    public Specification<Article> searchType(String sea) {
        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Season 컬럼을 기준으로 검색 조건 생성
            if (sea != null) {
                Path<String> typePath = root.get("type");
                Predicate typePredicate = criteriaBuilder.equal(typePath, sea);
                predicates.add(typePredicate);
            }

            // 다른 조건들을 추가하고 싶다면 여기에 추가

            // 검색 조건들을 조합하여 최종 검색 조건 생성
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }

    public Page<Article> getPriceList(int page, String kw, int min, int max) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Article> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getPriceHigtList(int page, String kw, int min, int max, String sortKey) {

        Specification<Article> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        return this.articleRepository.findAll(spec, pageable);
    }

    public Page<Article> getPriceRowList(int page, String kw, int min, int max, String sortKey) {

        Specification<Article> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        return this.articleRepository.findAll(spec, pageable);
    }


    public Article getArticle(Integer id) {
        Optional<Article> article = this.articleRepository.findById(id);
        if (article.isPresent()) {
            return article.get();
        } else {
            throw new DataNotFoundException("article not found");
        }
    }

    public void create(ArticleForm articleForm, SiteUser user, MultipartFile[] files) throws IOException {
        String projectPath = System.getProperty("user.dir") + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "static" + File.separator + "files";

        List<String> filenames = new ArrayList<>();
        List<String> filepaths = new ArrayList<>();

        for (MultipartFile file : files) {
            UUID uuid = UUID.randomUUID();
            String fileName = uuid + "_" + file.getOriginalFilename();
            String filePath = "/files/" + fileName;

            File saveFile = new File(projectPath, fileName);
            file.transferTo(saveFile);

            filenames.add(fileName);
            filepaths.add(filePath);
        }

        Article article = new Article();
        article.setSubject(articleForm.getSubject());
        article.setContent(articleForm.getContent());
        article.setCreateDate(LocalDateTime.now());
        article.setAuthor(user);
        article.setPrice(articleForm.getPrice());
        article.setStarScore(articleForm.getStarScore());
        article.setSeason(articleForm.getSeason());
        article.setType(articleForm.getType());
        article.setFilenames(filenames);
        article.setFilepaths(filepaths);
        this.articleRepository.save(article);
    }


    public List<Article> getAll() {

        return this.articleRepository.findAll();
    }

    public List<Article> getByType(String type) {

        return this.articleRepository.findByType(type);
    }

    public List<Article> getBySeason(String season) {

        return this.articleRepository.findBySeason(season);
    }

    public List<Article> getAuthor(SiteUser siteUser) {
        return this.articleRepository.findByAuthor(siteUser);
    }

    public void modify(Article article, String subject, String content, String type, String season, int price, int starscore) {
        article.setSubject(subject);
        article.setContent(content);
        article.setPrice(price);
        article.setSeason(season);
        article.setType(type);
        article.setStarScore(starscore);
        article.setModifyDate(LocalDateTime.now());
        this.articleRepository.save(article);
    }

    public void delete(Article article) {
        this.articleRepository.delete(article);
    }

    public void vote(Article article, SiteUser siteUser) {
        article.getVoter().add(siteUser);
        this.articleRepository.save(article);
    }

    public List<Article> getByPrice(int min, int max) {

        return this.articleRepository.findByPriceBetween(min, max);
        // 비트윈을 사용하면 인트값의 범위를 지정하여 불러올 수 있다. (프라이스가 int값으로 지정되어있음 )
    }

    public void delVote(Article article, SiteUser siteUser) {
        article.getVoter().remove(siteUser);
        this.articleRepository.save(article);
    }

    public void viewCountUp(Article article) {

        article.setViewCount(article.getViewCount() + 1);
        this.articleRepository.save(article);
    }

}

---

✔ 리뷰글상세페이지

@RequiredArgsConstructor
@Service
public class AnswerService {

    private final AnswerRepository answerRepository;


    public void create(Article article, String content, SiteUser author) {
        Answer answer = new Answer();
        answer.setContent(content);
        answer.setCreateDate(LocalDateTime.now());
        answer.setArticle(article);
        answer.setAuthor(author);
        this.answerRepository.save(answer);
    }

    public Answer getAnswer(Integer id) {
        Optional<Answer> answer = this.answerRepository.findById(id);
        if (answer.isPresent()) {
            return answer.get();
        } else {
            throw new DataNotFoundException("answer not found");
        }
    }

    public void modify(Answer answer, String content) {
        answer.setContent(content);
        answer.setModifyDate(LocalDateTime.now());
        this.answerRepository.save(answer);
    }

    public void delete(Answer answer) {
        this.answerRepository.delete(answer);
    }

}

---

✔ 판매페이지

---

✔ 판매글작성

@RequiredArgsConstructor
@Service
public class MarketService {

    private final MarketRepository marketRepository;


    private Specification<Market> search(String kw) {
        return new Specification<>() {
            private static final long serialVersionUID = 1L;

            @Override
            public Predicate toPredicate(Root<Market> q, CriteriaQuery<?> query, CriteriaBuilder cb) {
                query.distinct(true);  // 중복을 제거
                Join<Market, SiteUser> u1 = q.join("author", JoinType.LEFT);
                Join<Market, MarketAnswer> a = q.join("marketAnswerList", JoinType.LEFT);
                Join<MarketAnswer, SiteUser> u2 = a.join("author", JoinType.LEFT);
                return cb.or(cb.like(q.get("subject"), "%" + kw + "%"), // 제목
                        cb.like(q.get("content"), "%" + kw + "%"),      // 내용
                        cb.like(u1.get("username"), "%" + kw + "%"),    // 질문 작성자
                        cb.like(a.get("content"), "%" + kw + "%"),      // 답변 내용
                        cb.like(u2.get("username"), "%" + kw + "%"));   // 답변 작성자
            }
        };
    }

    public Page<Market> getList(int page, String kw) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = search(kw);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getMainList(int page) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 3, Sort.by(sorts));
        return this.marketRepository.findAll(pageable);
    }

    public Page<Market> getUserList(int page, String kw, String user) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchUser(user);
        return this.marketRepository.findAll(spec, pageable);
    }


    private Specification<Market> searchUser(String user) {
        return (root, query, builder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Add a condition to check for equality between the username field and the provided user value
            predicates.add(builder.equal(root.get("author").get("username"), user));

            // Add any other search conditions if needed
            // ...

            return builder.and(predicates.toArray(new Predicate[0]));
        };
    }

    public Market getMarket(Integer id) {
        Optional<Market> Market = this.marketRepository.findById(id);
        if (Market.isPresent()) {
            return Market.get();
        } else {
            throw new DataNotFoundException("market not found");
        }
    }

    public void create(MarketForm marketForm, SiteUser user, MultipartFile[] files) throws IOException {
        String projectPath = System.getProperty("user.dir") + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "static" + File.separator + "files";

        List<String> filenames = new ArrayList<>();
        List<String> filepaths = new ArrayList<>();

        for (MultipartFile file : files) {
            UUID uuid = UUID.randomUUID();
            String fileName = uuid + "_" + file.getOriginalFilename();
            String filePath = "/files/" + fileName;

            File saveFile = new File(projectPath, fileName);
            file.transferTo(saveFile);

            filenames.add(fileName);
            filepaths.add(filePath);
        }

        Market market = new Market();
        market.setSubject(marketForm.getSubject());
        market.setContent(marketForm.getContent());
        market.setCreateDate(LocalDateTime.now());
        market.setPrice(marketForm.getPrice());
        market.setBrand(marketForm.getBrand());
        market.setType(marketForm.getType());
        market.setSeason(marketForm.getSeason());
        market.setAuthor(user);
        market.setFilenames(filenames);
        market.setFilepaths(filepaths);
        this.marketRepository.save(market);
    }


    public List<Market> findByType(String type) {
        return this.marketRepository.findByType(type);
    }

    public List<Market> getAll() {
        return this.marketRepository.findAll();
    }


    public List<Market> findBySeason(String season) {
        return this.marketRepository.findBySeason(season);
    }


    public List<Market> getAuthor(SiteUser siteUser) {
        return this.marketRepository.findByAuthor(siteUser);
    }

    //////////////////////////0618 추가

    public Page<Market> getPriceList(int page, String kw, int min, int max) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        return this.marketRepository.findAll(spec, pageable);
    }

    public List<Market> getByPrice(int min, int max) {

        return this.marketRepository.findByPriceBetween(min, max);
        // 비트윈을 사용하면 인트값의 범위를 지정하여 불러올 수 있다. (프라이스가 int값으로 지정되어있음 )
    }

    public Page<Market> getSeasonList(int page, String kw, String season) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchSeason(season);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Specification<Market> searchSeason(String sea) {
        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Season 컬럼을 기준으로 검색 조건 생성
            if (sea != null) {
                Path<String> seasonPath = root.get("season");
                Predicate seasonPredicate = criteriaBuilder.equal(seasonPath, sea);
                predicates.add(seasonPredicate);
            }

            // 다른 조건들을 추가하고 싶다면 여기에 추가

            // 검색 조건들을 조합하여 최종 검색 조건 생성
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }

    public List<Market> getBySeason(String season) {

        return this.marketRepository.findBySeason(season);
    }

    public List<Market> getByType(String type) {

        return this.marketRepository.findByType(type);
    }

    public Page<Market> getTypeList(int page, String kw, String type) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchType(type);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Specification<Market> searchType(String sea) {
        return (root, query, criteriaBuilder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Season 컬럼을 기준으로 검색 조건 생성
            if (sea != null) {
                Path<String> typePath = root.get("type");
                Predicate typePredicate = criteriaBuilder.equal(typePath, sea);
                predicates.add(typePredicate);
            }

            // 다른 조건들을 추가하고 싶다면 여기에 추가

            // 검색 조건들을 조합하여 최종 검색 조건 생성
            return criteriaBuilder.and(predicates.toArray(new Predicate[0]));
        };
    }

    public void modify(Market market, String subject, String content, Integer price, String brand, String season, String type) {
        market.setSubject(subject);
        market.setContent(content);
        market.setPrice(price);
        market.setBrand(brand);
        market.setSeason(season);
        market.setType(type);
        market.setModifyDate(LocalDateTime.now());
        this.marketRepository.save(market);
    }

    public void vote(Market market, SiteUser siteUser) {
        market.getVoter().add(siteUser);
        this.marketRepository.save(market);
    }

    public void delete(Market market) {
        this.marketRepository.delete(market);
    }

    public void delVote(Market market, SiteUser siteUser) {
        market.getVoter().remove(siteUser);
        this.marketRepository.save(market);
    }

    // 카테고리 /////////////////////////////
    public Page<Market> getHigtList(int page, String kw, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = search(kw);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getRowList(int page, String kw, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = search(kw);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getPriceHigtList(int page, String kw, int min, int max, String sortKey) {

        Specification<Market> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getPriceRowList(int page, String kw, int min, int max, String sortKey) {

        Specification<Market> spec = (root, query, builder) -> {
            return builder.between(root.get("price"), min, max);
        };
        // 비트윈으로 미니멈, 맥시멈값 지정후 spec변수에 담고 해당변수값의 아티클만 파인드올로 불러옴  //
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getSeasonHighList(int page, String kw, String season, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchSeason(season);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getSeasonRowList(int page, String kw, String season, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchSeason(season);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getTypeHighList(int page, String kw, String type, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchType(type);
        return this.marketRepository.findAll(spec, pageable);
    }

    public Page<Market> getTypeRowList(int page, String kw, String type, String sortKey) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.asc(sortKey));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchType(type);
        return this.marketRepository.findAll(spec, pageable);
    }

    public void viewCountUp(Market market) {
        market.setViewCount(market.getViewCount() + 1);
        this.marketRepository.save(market);
    }


    public Page<Market> getUserVoterList(int page, String kw, String user) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 9, Sort.by(sorts));
        Specification<Market> spec = searchVoteUser(user);
        return this.marketRepository.findAll(spec, pageable);
    }


    private Specification<Market> searchVoteUser(String user) {
        return (root, query, builder) -> {
            List<Predicate> predicates = new ArrayList<>();

            // Add a condition to check for equality between the username field and the provided user value
            predicates.add(builder.equal(root.get("voter").get("username"), user));

            // Add any other search conditions if needed
            // ...

            return builder.and(predicates.toArray(new Predicate[0]));
        };
    }
}

---

✔ 판매글상세페이지

@RequiredArgsConstructor
@Service
public class MarketAnswerService {

    private final MarketAnswerRepository marketAnswerRepository;

    public void create(Market market, String content, SiteUser author) {
        MarketAnswer m = new MarketAnswer();
        m.setContent(content);
        m.setCreateDate(LocalDateTime.now());
        m.setMarket(market);
        m.setAuthor(author);
        this.marketAnswerRepository.save(m);
    }

    public void delete(MarketAnswer marketAnswer) {
        this.marketAnswerRepository.delete(marketAnswer);
    }

    public MarketAnswer getMarketAnswer(Integer id) {
        Optional<MarketAnswer> answer = this.marketAnswerRepository.findById(id);
        if (answer.isPresent()) {
            return answer.get();
        } else {
            throw new DataNotFoundException("answer not found");
        }
    }


    public void modify(MarketAnswer marketAnswer, String content) {
        marketAnswer.setContent(content);
        marketAnswer.setModifyDate(LocalDateTime.now());
        this.marketAnswerRepository.save(marketAnswer);
    }

}

---

✔ 공지사항

@Service
@RequiredArgsConstructor
public class NoticeService {

    private final NoticeRepository noticeRepository;

    public List<Notice> getList() {
        return this.noticeRepository.findAll();
    }

    public Page<Notice> getList(int page, String kw) {
        List<Sort.Order> sorts = new ArrayList<>();
        sorts.add(Sort.Order.desc("createDate"));
        Pageable pageable = PageRequest.of(page, 10, Sort.by(sorts));
        return this.noticeRepository.findAll(pageable);
    }

    public Notice getNotice(Integer id) {
        Optional<Notice> Notice = this.noticeRepository.findById(id);
        if (Notice.isPresent()) {
            return Notice.get();
        } else {
            throw new DataNotFoundException("notice not found");
        }
    }

    public void create(String subject, String content) {
        Notice q = new Notice();
        q.setSubject(subject);
        q.setContent(content);
        q.setCreateDate(LocalDateTime.now());
        this.noticeRepository.save(q);
    }

    public List<Notice> getAll() {
        return this.noticeRepository.findAll();
    }

    public void modify(String subject, String content) {
        Notice q = new Notice();
        q.setSubject(subject);
        q.setContent(content);
        q.getModifyDate();
        this.noticeRepository.save(q);
    }

    public void delete(Notice notice) {
        this.noticeRepository.delete(notice);
    }

    public void viewCountUp(Notice notice) {
        notice.setViewCount(notice.getViewCount() + 1);
        this.noticeRepository.save(notice);
    }
}

---

✔ 마이페이지

 @GetMapping("/mypage")
    private String mypage(Model model, @RequestParam(value = "page", defaultValue = "0") int page,
                          @RequestParam(value = "kw", defaultValue = "") String kw, Principal principal) {
        SiteUser siteUser = this.userService.getUser(principal.getName());
        Page<Article> articlePaging = this.articleService.getUserList(page, kw, siteUser.getUsername());
        Page<Market> marketPaging = this.marketService.getUserList(page, kw, siteUser.getUsername());

        Page<Market> marketVoterPaging = this.marketService.getUserVoterList(page, kw, siteUser.getUsername());

        List<Article> articles = this.articleService.getAuthor(siteUser);
        List<Market> markets = this.marketService.getAuthor(siteUser);

        int articleCount = articles.size();
        int marketCount = markets.size();
        model.addAttribute("markets", markets);
        model.addAttribute("marketCount", marketCount);
        model.addAttribute("articles", articles);
        model.addAttribute("articleCount", articleCount);
        model.addAttribute("articlePaging", articlePaging);
        model.addAttribute("marketPaging", marketPaging);
        model.addAttribute("marketVoterPaging", marketVoterPaging);
        model.addAttribute("kw", kw);
        model.addAttribute("user", siteUser);
        return "mypage";
    }

    @GetMapping("/mypage/article")
    @ResponseBody
    private Model mypageArticlePaging(Model model, @RequestParam(value = "page", defaultValue = "0") int page,
                                      @RequestParam(value = "kw", defaultValue = "") String kw, Principal principal) {
        SiteUser siteUser = this.userService.getUser(principal.getName());
        Page<Article> articlePaging = this.articleService.getUserList(page, kw, siteUser.getUsername());
        List<Article> articles = this.articleService.getAuthor(siteUser);
        int articleCount = articles.size();
        model.addAttribute("articlePaging", articlePaging);
        model.addAttribute("articles", articles);
        model.addAttribute("articleCount", articleCount);
        return model;
    }

    @GetMapping("/mypage/market")
    @ResponseBody
    private Model mypageMarketPaging(Model model, @RequestParam(value = "page", defaultValue = "0") int page,
                                     @RequestParam(value = "kw", defaultValue = "") String kw, Principal principal) {
        SiteUser siteUser = this.userService.getUser(principal.getName());
        Page<Market> marketPaging = this.marketService.getUserList(page, kw, siteUser.getUsername());
        List<Market> markets = this.marketService.getAuthor(siteUser);
        int marketCount = markets.size();
        model.addAttribute("marketPaging", marketPaging);
        model.addAttribute("markets", markets);
        model.addAttribute("marketCount", marketCount);
        return model;

    }


    @GetMapping("/user/find")
    public String find() {
        return "UserSearch";
    }

    @PostMapping("/user/findId")
    @ResponseBody
    public String findId(@RequestParam("email") String email) {
        SiteUser user = userService.getUserByEmail(email);

        if (user != null) {
            mailController.sendEmailForId(email, user.getUsername());
            return "true";
        } else {
            return "redirect:/user/find";
        }
    }


    @PostMapping("/user/findPw")
    @ResponseBody
    public String findPw(@RequestParam("userEmail") String userEmail, @RequestParam("userName") String userName) {
        SiteUser user = userService.getUserByEmailAndUsername(userEmail, userName);
        if (user != null) {
            mailController.sendEmailForPw(userEmail, user.getUsername());
            return "true";
        } else {
            return "redirect:/user/find";
        }
    }

    @PostMapping("/mypage/changePassword")
    @ResponseBody
    public String changePassword(@RequestParam("newpassword") String newpw, @RequestParam("newpasswordcf") String newpwcf) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication.getName();
        SiteUser user = userService.getUserByUsername(username);

        if (!newpw.equals(newpwcf)) {
            return "변경할 비밀번호와 확인 비밀번호가 일치하지 않습니다.";
        }
        user.setPassword(passwordEncoder.encode(newpw));
        userService.saveUser(user);
        return "/mypage";
    }

    @PostMapping("/mypage/changeNickname")
    @ResponseBody
    public String changeNickname(@RequestParam("newnickname") String newnickname) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication.getName();
        SiteUser user = userService.getUserByUsername(username);
        user.setNickname(newnickname);
        userService.saveUser(user);
        return "/mypage";
    }

    @PostMapping("/mypage/changeEmail")
    @ResponseBody
    public String changeEmail(@RequestParam("newemail") String newemail) {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication.getName();
        SiteUser user = userService.getUserByUsername(username);
        user.setEmail(newemail);
        return "/mypage";
    }

    @PostMapping("/mypage/changePhoto")
    @ResponseBody
    public String changePhoto(@RequestParam("file") MultipartFile file) throws Exception {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication.getName();
        SiteUser user = userService.getUserByUsername(username);
        userService.changePhoto(user, file);
        return "redirect:/mypage";
    }
}

---

✔ 관리자페이지

@Controller
@RequiredArgsConstructor
@RequestMapping("/admin")
public class AdminController {

    private final ArticleService articleService;

    private final MarketService marketService;

    private final UserService userService;

    private final NoticeService noticeService;

    @GetMapping("/")
    public String adminroot(Model model, @RequestParam(value = "page", defaultValue = "0") int page) {

        List<Notice> noticeList = this.noticeService.getAll();
        List<SiteUser> userList = this.userService.getAll();
        List<SiteUser> adminList = this.userService.getUserByUserRole(UserRole.ADMIN);
        List<Article> articleList = this.articleService.getAll();
        List<Market> marketList = this.marketService.getAll();

        model.addAttribute("noticeList", noticeList);
        model.addAttribute("articleList", articleList);
        model.addAttribute("marketList", marketList);
        model.addAttribute("userList", userList);
        model.addAttribute("adminList", adminList);

        return "AdminPage";
    }

    @GetMapping("/notice/delete/{id}")
    public String noticeDelete(@PathVariable("id") Integer id) {
        Notice notice = this.noticeService.getNotice(id);
        this.noticeService.delete(notice);
        return "redirect:/admin/";
    }

    @PostMapping("/addAdminRole")
    public String addAdminRole(@RequestParam("id") int id) {
        // 관리자 권한을 부여할 유저를 조회합니다.
        SiteUser user = userService.getUserById(id);
        if (user == null) {
            return "redirect:/admin/user";
        }

        user.setUserRole(UserRole.ADMIN);
        userService.saveUser(user);

        return "redirect:/admin/user";
    }

    @PostMapping("/minusAdminRole")
    public String minusAdminRole(@RequestParam("id") int id) {

        SiteUser user = userService.getUserById(id);
        if (user == null) {
            return "redirect:/admin/user";
        }

        user.setUserRole(UserRole.USER);
        userService.saveUser(user);

        return "redirect:/admin/user";
    }

    @GetMapping("/review")
    private String admin_review(Model model) {
        List<Article> articleList = this.articleService.getAll();
        model.addAttribute("articleList", articleList);
        return "/admin_review";
    }

    @GetMapping("/review/delete/{id}")
    public String reviewDelete(@PathVariable("id") Integer id) {
        Article article = this.articleService.getArticle(id);
        this.articleService.delete(article);
        return "redirect:/admin/review";
    }

    @GetMapping("/market")
    private String admin_market(Model model) {
        List<Market> marketList = this.marketService.getAll();
        model.addAttribute("marketList", marketList);
        return "/admin_market";
    }

    @GetMapping("/market/delete/{id}")
    public String marketDelete(@PathVariable("id") Integer id) {
        Market market = this.marketService.getMarket(id);
        this.marketService.delete(market);
        return "redirect:/admin/market";
    }

    @GetMapping("/user")
    private String admin_user(Model model) {
        List<SiteUser> userList = this.userService.getAll();
        model.addAttribute("userList", userList);
        return "/admin_user";
    }

    @GetMapping("/admin")
    private String admin(Model model) {
        List<SiteUser> adminList = this.userService.getUserByUserRole(UserRole.ADMIN);
        List<SiteUser> userList = this.userService.getAll();
        model.addAttribute("adminList", adminList);
        model.addAttribute("userList", userList);
        return "/admin";
    }
}

---