Jin'story

int amount = 1000000000;
DecimalFormat decimal = new DecimalFormat("###,###");
String money = decimal.format(amount);
System.out.println(money);

String amount = "1000000000";
amount = amount.replaceAll("\\B(?=(\\d{3})+(?!\\d))", ",");
System.out.println(amount);

spring:
  datasource:
    url: jdbc:mysql://[엔드포인트]:3306/[DB명]?serverTimezone=Asia/Seoul
    username: [마스터이름]
    password: [패스워드]
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        default_batch_fetch_size: 1000 # N+1문제 해결

private Member loginMemberFindByToken(){
    String loginEmail = SecurityContextHolder.getContext().getAuthentication().getName(); // 토큰에서 유저 email 확인
    return memberService.findMemberByEmail(loginEmail); //이메일을 통해 유저 엔티티 반환
}

public Member findMemberByEmail(String email){ //로그인 이메일을 통해 유저 엔티티 반환 메서드
    Optional<Member> foundMember = memberRepository.findByEmail(email);
    return foundMember.orElseThrow(()-> new BusinessLogicException(ExceptionCode.MEMBER_NOT_FOUND));
}

public interface MemberRepository extends JpaRepository<Member, Long> {
    Optional<Member> findByEmail(String email);
}

public class SearchNewsDto {
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Post { //검색 쿼리
        private String query = ""; //검색어. UTF-8로 인코딩되어야 합니다.
        private int display = 20; //한 번에 표시할 검색 결과 개수(기본값: 10, 최댓값: 100)
        private int start = 1; //검색 시작 위치(기본값: 1, 최댓값: 1000)
        private String sort = "sim"; // sim: 정확도순 , date: 날짜순

        /*데이터를 한꺼번에 들어가게 해주는 메서드*/
        public MultiValueMap<String, String> toMultiValueMap() {
            var map = new LinkedMultiValueMap<String, String>();

            map.add("query", query);
            map.add("display", String.valueOf(display));
            map.add("start", String.valueOf(start));
            map.add("sort", sort);

            return map;
        }
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Response { //반환값
        private String lastBuildDate; //검색한 결과를 생성한 시간
        private int total; // 총 검색결과 갯수
        private int start; // 검색 시작 위치
        private int display; // 한번에 표시할 검색결과 갯수
        private List<NewsItem> items;
        @Data
        @NoArgsConstructor
        @AllArgsConstructor
        public static class NewsItem {
            private String title; //제목
            private String originallink; // 뉴스기사 원문 URL
            private String link; //뉴스 기사의 네이버 뉴스 URL. 네이버에 제공되지 않은 기사라면 기사 원문의 URL을 반환합니다.
            private String description; // 뉴스기사 내용을 요약한 정보
            private String pubDate;
        }
    }
}

@RequiredArgsConstructor
@RequestMapping("/news")
@RestController
public class NaverSearchController {
    private final NaverClient naverClient;
    @GetMapping
    public ResponseEntity searchNews(@RequestParam(required = false, defaultValue = "환경") String query,
                                     @RequestParam(required = false, defaultValue = "1") int start,
                                     @RequestParam(required = false, defaultValue = "20") int display,
                                     @RequestParam(required = false, defaultValue = "sim") String sort){

         SearchNewsDto.Response response = naverClient.searchQuerySet(query, start, display, sort);

        return new ResponseEntity<>(response, HttpStatus.OK);
    }
}

@Service
public class NaverClient {
    @Value("${naver.client.id}")
    private String naverClientId; //id
    @Value("${naver.client.secret}")
    private String naverClientSecret; //시크릿키
    @Value("${naver.url.search.news}")
    private String naverNewSearchUrl; //뉴스 검색주소
    @Value("${naver.url.search.image}")
    private String naverImageSearchUrl; //이미지 검색주소

    /* 뉴스검색 메서드*/
    public SearchNewsDto.Response searchNews(SearchNewsDto.Post post){
        var uri = UriComponentsBuilder.fromUriString(naverNewSearchUrl) //뉴스검색 주소
                .queryParams(post.toMultiValueMap())
                .build()
                .encode()
                .toUri();

        var headers = new HttpHeaders(); //http헤더에 키값을 넣어줌
        headers.set("X-Naver-Client-Id", naverClientId);
        headers.set("X-Naver-Client-Secret", naverClientSecret);
        headers.setContentType(MediaType.APPLICATION_JSON); //Json형식으로 변환

        var httpEntity = new HttpEntity<>(headers); //요청하는 부분
        var responseType = new ParameterizedTypeReference<SearchNewsDto.Response>(){}; //응답값

        var responseEntity = new RestTemplate().exchange( //모든 정보를 담아주는 부분
                uri,
                HttpMethod.GET,
                httpEntity,
                responseType
        );
        return responseEntity.getBody();
    }

    public SearchNewsDto.Response searchQuerySet(String query, int display, String sort){
        SearchNewsDto.Post post = new SearchNewsDto.Post();
        post.setQuery(query);
        post.setStart(start);
        post.setDisplay(display);
        post.setSort(sort);

        return searchNews(post);
    }
}

//HttpServletResponse response
response.setCharacterEncoding("UTF-8"); // objectMapper.writeValueAsString 한글깨지는 것에 대한 대응코드

public class MemberAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
    @Override
    public void onAuthenticationSuccess(HttpServletRequest request,
                                        HttpServletResponse response, //<- 적용할 파라미터
                                        Authentication authentication) throws IOException, ServletException {
        Member member = (Member) authentication.getPrincipal();

        response.setCharacterEncoding("UTF-8"); // objectMapper.writeValueAsString 한글깨지는 것에 대한 대응코드

        /*MemberDetails에서 유저정보를 가져와서 리스폰스에 뿌려주는 부분*/
        Map<String, Object> loginResponse = new HashMap<>();
        loginResponse.put("memberId", member.getMemberId());
        loginResponse.put("email", member.getEmail());
        loginResponse.put("roles", member.getRoles());
        loginResponse.put("level", member.getLevel().getLevel());
        loginResponse.put("name", member.getName());


        ObjectMapper objectMapper = new ObjectMapper();
        String responseBody = objectMapper.writeValueAsString(loginResponse);
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);

        response.getWriter().write(responseBody);

        log.info("# Authenticated successfully");
        log.info("name:{}, email: {}, role: {}", member.getName(), member.getEmail(), member.getRoles() );
    }
}

jasypt: #패스워드 암호화/복호화 키
  encryptor:
    password: ${{secrets.SECRET_KEY}} # 깃허브액션에 등록된 환경변수 사용

implementation 'com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.3' // yml Secret Key 암호화

@Configuration
public class JasyptConfig {

    @Value("${jasypt.encryptor.password}")
    private String password;

    @Bean("jasyptStringEncryptor")
    public StringEncryptor stringEncryptor() {
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();
        config.setPassword(password);
        config.setAlgorithm("PBEWithMD5AndDES");
        config.setKeyObtentionIterations("1000");
        config.setPoolSize("1");
        config.setProviderName("SunJCE");
        config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        config.setIvGeneratorClassName("org.jasypt.iv.NoIvGenerator");
        config.setStringOutputType("base64");
        encryptor.setConfig(config);
        return encryptor;
    }
}

cloud:
  aws:
    region:
      static: ap-northeast-2
    s3:
      credentials:
        access-key: ENC(xFO5USJEzJjHL8RB+a7IREpyQOoHp4HZhL2OFzzKIBs=)
        secret-key: ENC(PtaZU3cqX2thf4/AeCsoMF+XCJRo3WR8q3U1iGexhAqLXaFIQ5JKn8CKkO3uRyKipF9cb/Qy4W8=)
    stack:
      auto: false
     
      
#jasypt: #패스워드 암호화/복호화 키
#  encryptor:
#    password: 설정한 패스워드

@Setter @ManyToOne(optional = true) @JoinColumn(name = "userId") //매핑이 완료되면 필수옵션(false)으로 바꿔줘야함
private UserAccount userAccount; //유저 정보(id) 매핑

@JsonIgnore
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "board_id")
private Board board;

@JsonIgnore // 순환참조 방지
@OneToMany(mappedBy = "board",cascade = CascadeType.ALL, orphanRemoval = true) // 게시판과 생명주기 동일하게 관리
@ToString.Exclude // ToString
private List<UploadFile> uploadFiles = new ArrayList<>();

@PostMapping
public ResponseEntity<?> upload(@ModelAttribute MultipartFile[] files,
                                @ModelAttribute BoardDto.Post boardPostDto) throws Exception {
    Board board = boardMapper.boardPostToBoard(boardPostDto);
    board.setMember(memberService.findVerifiedMember(boardPostDto.getMemberId()));
    Board boardCreate = boardService.createBoard(board);

    List<UploadFile> uploadFiles = s3Service.uploadFiles(files, boardCreate); // aws s3업로드

    BoardDto.TotalPageResponse response = boardMapper.boardToBoardTotalPageResponse(boardCreate, uploadFiles);

    return new ResponseEntity<>(new SingleResponseDto<>(response), HttpStatus.CREATED);
}

@Getter @Setter //@ModelAttribute 사용하기위함
@NoArgsConstructor //@ModelAttribute 사용하기위함
@ToString
public static class Post {
    @Positive
    @NotNull
    private Long memberId;
    @NotBlank(message = "제목을 작성해주세요")
    @Size(max = 100, message = "100자 이내로 작성해 주세요.")
    private String title;
    @NotBlank(message = "내용은 공백이 아니어야 합니다.")
    private String contents;

    public Post(Long memberId, String title, String contents) {
        this.memberId = memberId;
        this.title = title;
        this.contents = contents;
    }
}