Jin'story

implementation 'org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE'

spring:
  jackson:
    property-naming-strategy: SNAKE_CASE
  datasource:
    url: jdbc:mysql://localhost:3306/community?serverTimezone=Asia/Seoul
    username: root
    password: password
  redis:
    host: localhost
    port: 6379
  jpa:
    hibernate:
      ddl-auto: create
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  data: # spring data rest - 관련 설정
    rest:
      base-path: /api  #endpoint start path
      detection-strategy: annotated
  profiles:
    include: API-KEY   #key가 저장된 yml 연동


cloud: # AWS 계정연동 관련설정
  aws:
    region:
      static: ap-northeast-2
#    s3:
#      credentials:
#        access-key: access-key
#        secret-key: secret-key
    stack:
      auto: false

### api key 관련 ###
/src/main/resources/application-API-KEY.yml

@NoArgsConstructor
@Setter @Getter
@Entity
public class UploadFile{
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long fileId;
    private String fileName;
    private String imagePath;
    @ManyToOne
    @JoinColumn(name = "board_id")
    private Board board;

    public UploadFile(String fileName, String imagePath) {
        this.fileName = fileName;
        this.imagePath = imagePath;
    }
}

@RequiredArgsConstructor
@Service
public class S3Service {

    private String S3Bucket = "kjs-project-upload"; // Bucket 이름
    private final AmazonS3Client amazonS3Client;
    private final UploadFileRepository uploadFileRepository;

    public List<String> uploadFiles(MultipartFile[] multipartFileList) throws Exception {
        List<String> imagePathList = new ArrayList<>();

        for (MultipartFile multipartFile : multipartFileList) {
            String fileName = multipartFile.getOriginalFilename(); // 파일 이름
            long size = multipartFile.getSize(); // 파일 크기

            ObjectMetadata objectMetaData = new ObjectMetadata();
            objectMetaData.setContentType(multipartFile.getContentType());
            objectMetaData.setContentLength(size);

            // S3에 업로드
            amazonS3Client.putObject(
                    new PutObjectRequest(S3Bucket, fileName, multipartFile.getInputStream(), objectMetaData)
                            .withCannedAcl(CannedAccessControlList.PublicRead)
            );

            String imagePath = amazonS3Client.getUrl(S3Bucket, fileName).toString(); // 접근가능한 URL 가져오기
            imagePathList.add(imagePath); //String Type URL주소

            //엔티티에 저장하는 로직

            UploadFile uploadFile = new UploadFile();
            uploadFile.setFileName(fileName);
            uploadFile.setImagePath(imagePath);
            uploadFileRepository.save(uploadFile);
        }
        return imagePathList;
    }
}

public interface UploadFileRepository extends JpaRepository<UploadFile, Long> {}

@RestController
@RequiredArgsConstructor
public class BoardController {
    private final S3Service s3Service;

    @PostMapping("/upload")
    public ResponseEntity<Object> upload(@RequestParam MultipartFile[] files) throws Exception {
        List<String> imagePathList = s3Service.uploadFiles(files);

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

@Setter @Getter
@AllArgsConstructor
@NoArgsConstructor
public static class Response {
    @JsonProperty("comment_id")
    private Long commentId;
    private String contents;
    @JsonProperty("like_count")
    private int likeCount;
    @JsonProperty("create_at")
    private LocalDateTime createdAt;
    @JsonProperty("modified_at")
    private LocalDateTime modifiedAt;
    @JsonProperty("board_id")
    private long boardId;
    @JsonProperty("member_id")
    private long memberId;
}

spring:
  jackson:
    property-naming-strategy: SNAKE_CASE

@RepositoryRestResource // spring data rest 사용하기 위함
public interface ArticleRepository extends
        JpaRepository<Article, Long>,
        QuerydslPredicateExecutor<Article>, //해당 엔티티 안에있는 모든 검색기능을 추가해줌 // 완전 동일해야만 동작
        QuerydslBinderCustomizer<QArticle> // 부분검색, 대소문자 구분 등을 위함
{
    Page<Article> findByTitleContaining(String title, Pageable pageable); //제목검색
    Page<Article> findByContentContaining(String content, Pageable pageable); //내용검색/ Containing-부분검색
//    Page<Article> findByUserAccount_UserIdContaining(String userId, Pageable pageable); //회원id검색
//    Page<Article> findByUserAccount_NicknameContaining(String nickName, Pageable pageable); //닉네임검색
    Page<Article> findByHashtag(String hashtag, Pageable pageable); //제목검색

    @Override
    default void customize(QuerydslBindings bindings, QArticle root){
        //Article에 대해 선택적인 필드에 대한 검색
        bindings.excludeUnlistedProperties(true); //리스팅 하지 않은 프로퍼티 검색 제외
        bindings.including(root.title, root.content, root.hashtag, root.createdAt, root.createdBy); //검색 컬럼
        bindings.bind(root.title).first(StringExpression::containsIgnoreCase); // like '%${v}%'/ 부분검색
        bindings.bind(root.content).first(StringExpression::containsIgnoreCase);
        bindings.bind(root.hashtag).first(StringExpression::containsIgnoreCase);
        bindings.bind(root.createdAt).first(DateTimeExpression::eq);//원하는 날짜검색 /시분초 동일하게 넣어야함
        bindings.bind(root.createdBy).first(StringExpression::containsIgnoreCase);
    }
}

@Slf4j
@RequiredArgsConstructor
@Transactional //import annotation 유의해서 가져오기
@Service
public class ArticleService {
    private final ArticleRepository articleRepository;
    //게시글 페이지형 검색
    @Transactional(readOnly = true) // 변경하지 않기때문에 readonly
    public Page<Article> searchArticles(SearchType searchType, String search_keyword, Pageable pageable) {
        // 검색어 없이 검색하면 게시글 페이지를 반환.
        if (search_keyword == null || search_keyword.isBlank()) {
            return articleRepository.findAll(pageable);
        }
        // 항목에 따른 검색 - 조회
        switch (searchType) { // return이 되는 switch ->와 함께 사용 java14이상부터 사용가능
            case TITLE:
                return articleRepository.findByTitleContaining(search_keyword, pageable);
            case CONTENT:
                return articleRepository.findByContentContaining(search_keyword, pageable);
//            case ARTICLE_ID:
//                return articleRepository.findByUserAccount_UserIdContaining(search_keyword, pageable);
//            case NICKNAME:
//                return articleRepository.findByUserAccount_NicknameContaining(search_keyword, pageable);
            case HASHTAG:
                return articleRepository.findByHashtag(search_keyword, pageable);
        }
        return null;
    }

public enum SearchType {
    TITLE, CONTENT, ARTICLE_ID, NICKNAME, HASHTAG
}

@RequiredArgsConstructor
@Validated
@RequestMapping("/articles")
@RestController
public class ArticleController {

    private final ArticleService articleService;
    private final ArticleMapper articleMapper;



    @GetMapping //부분검색 //http://localhost:8080/articles?searchType=CONTENT&searchValue=검색어
    public ResponseEntity searchArticles(@RequestParam(required = false)SearchType searchType,//required = false- 선택적 파라미터
                           @RequestParam(required = false)String searchValue,
                           @PageableDefault(size = 10,sort = "createdAt", direction = Sort.Direction.DESC)Pageable pageable)
    {
        Page<Article> articlePages = articleService.searchArticles(searchType, searchValue, pageable);
        List<Article> articles = articlePages.getContent();
        List<ArticleDto.Response> response = articleMapper.articleToArticleListResponse(articles);
        return new ResponseEntity(response, HttpStatus.OK);
    }

@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
public interface ArticleMapper {
    Article articlePostToArticle(ArticleDto.Post articlePostDto);
    Article articlePatchToArticle(ArticleDto.Patch articlePatchDto);
    ArticleDto.Response articleToArticleResponse(Article article);
    List<ArticleDto.Response> articleToArticleListResponse(List<Article> articles);
}

@Getter
@ToString(callSuper = true) //callSuper = true - 안쪽까지 들어가서 ToString을 찍어냄
@Table(indexes = {
        @Index(columnList = "title"),
        @Index(columnList = "hashtag"),
        @Index(columnList = "createdAt"),
        @Index(columnList = "createdBy"),
})
@Entity
@NoArgsConstructor//(access = AccessLevel.PROTECTED) //기본생성자의 무분별한 생성을 막아서 의도치않는 엔티티 생성을 막음
public class Article extends AuditingFields {
    /* @Setter을 클래스레벨로 설정하지 않는 이유 id, 시간 등 을 Setter 하지 않기 위함*/
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long articleId;
   // @Setter @ManyToOne(optional = false)
    //private UserAccount userAccount; //유저 정보(id) 매핑
    @Setter @Column(nullable = false)
    private String title; // 제목
    @Setter @Column(nullable = false, length = 10000)
    private String content; // 본문
    @Setter
    private String hashtag; // 해시태그

    @OrderBy("createdAt DESC") // 생성 시간순 정렬
    @OneToMany(mappedBy = "article", cascade = CascadeType.ALL)// 모든경우 외래키를 걸어줌/ 실무에선 양방향바인딩 지양
    @ToString.Exclude //조회하는 과정에서 무한 순환참조 방지, 퍼포먼스 이슈로 인하여 설정 / 연결고리를 끊어줌
    private final Set<ArticleComment> articleComments = new LinkedHashSet<>();

    public Article(String title, String content, String hashtag) { //도메인과 관련있는 정보만 오픈
        //this.userAccount = userAccount;
        this.title = title;
        this.content = content;
        this.hashtag = hashtag;
    }
/**
    //new를 사용하지 않고 생성자 생성하기 위함  // of는 매개변수가 뭐가필요한지 가이드해줌
    public static Article of(String title, String content, String hashtag) {
        return new Article(title, content, hashtag);
    } // @Mapper 사용 할때에는 쓸수없는 방법
**/

    //equalse 해시코드 기능 생성(alt+insert에 있음) / id만 같으면 같은게시물
    @Override //동일성 검사
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Article)) return false;
        Article article = (Article) o;
        return articleId!=null && articleId.equals(article.articleId); //데이터가 insert되기 전에 만들어진 id는 탈락
    }

    @Override
    public int hashCode() { //동일성 검사를 마친 아이디에 대해서만 해시
        return Objects.hash(articleId);
    }
}

@Configuration // 설정값으로 사용
public class SecurityConfig {

    @Bean // SecurityAdapter상속 대신 사용 /최신  // 시큐리티 기본 로그인화면 탈출하기위함
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        return http
                .csrf().disable() // CSRF() 로인해서 post 요청이 막히는것을 해제해줌 / post 403에러 해결
                .authorizeHttpRequests(auth -> auth //auth를 받아서 어떤 리퀘스트를 열것인지
                        .antMatchers(HttpMethod.POST, "/articles").permitAll() //Role메서드 추가예정
                        .anyRequest().permitAll()) //auth를 받아서 어떤리퀘스트든 다열겠다
                .formLogin().and() //폼로그인 사용
                .build();
    }

@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass

package main22.community.domain;

import lombok.Getter;
import lombok.ToString;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import org.springframework.format.annotation.DateTimeFormat;

import javax.persistence.Column;
import javax.persistence.EntityListeners;
import javax.persistence.MappedSuperclass;
import java.time.LocalDateTime;
@Getter
@ToString
@EntityListeners(AuditingEntityListener.class)//엔티티 Auditing이 동작하기위해 필수추가
@MappedSuperclass  //Jpa애너테이션
public class AuditingFields { // 공통 필드에 대한 처리

    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) //파라미터 파싱에 대한 룰
    @CreatedDate
    @Column(nullable = false, updatable = false) //수정불가
    private LocalDateTime createdAt; // 생성일시
    @CreatedBy
    @Column(nullable = false, length = 100)//누가 만들었는지에 대한 정보 JpaConfig에서 확인
    private String createdBy; // 생성자
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) //파라미터 파싱에 대한 룰
    @LastModifiedDate
    @Column(nullable = false)
    private LocalDateTime modifiedAt; // 수정일시
    @LastModifiedBy
    @Column(nullable = false, length = 100)
    private String modifiedBy; // 수정자
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-web'
    runtimeOnly 'com.mysql:mysql-connector-j'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-data-rest' // data rest기능 / api빠르게만들수있음
    implementation 'org.springframework.data:spring-data-rest-hal-explorer' // 해당내용을 시각적으로 보는것
    runtimeOnly 'com.h2database:h2'
    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // queryDSL 설정
    // 엔티티 검색기능 사용 가능
    implementation "com.querydsl:querydsl-jpa"
    implementation "com.querydsl:querydsl-core"
    implementation "com.querydsl:querydsl-collections"
    annotationProcessor "com.querydsl:querydsl-apt:${dependencyManagement.importedProperties['querydsl.version']}:jpa" // querydsl JPAAnnotationProcessor 사용 지정
    annotationProcessor "jakarta.annotation:jakarta.annotation-api" // java.lang.NoClassDefFoundError (javax.annotation.Generated) 대응 코드
    annotationProcessor "jakarta.persistence:jakarta.persistence-api" // java.lang.NoClassDefFoundError (javax.annotation.Entity) 대응 코드
}

tasks.named('test') {
    useJUnitPlatform()
}

// Querydsl 설정부
def generated = 'src/main/generated'  //파일경로  
// build디렉터리 안에 있는걸 눈에 보이게 꺼내옴
// ide같은 툴을 사용해서 발생할 수 있는 잠재적 문제를 해결하기위함

// querydsl QClass 파일 생성 위치를 지정
tasks.withType(JavaCompile) {
    options.getGeneratedSourceOutputDirectory().set(file(generated))
}

// java source set 에 querydsl QClass 위치 추가
sourceSets {
    main.java.srcDirs += [ generated ]
}

// gradle clean 시에 QClass 디렉토리 삭제
clean {
    delete file(generated)  //build clean할때 해당 파일도 같이 삭제

package main22.community.repository;

import com.querydsl.core.types.dsl.DateTimeExpression;
import com.querydsl.core.types.dsl.StringExpression;
import main22.community.domain.entity.Article;
import main22.community.domain.entity.QArticle;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.querydsl.binding.QuerydslBinderCustomizer;
import org.springframework.data.querydsl.binding.QuerydslBindings;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;
//@Repository안붙여도 정상동작함 상속하는 클래스에 이미 붙어있음
@RepositoryRestResource // spring data rest 사용하기 위함
public interface ArticleRepository extends
        JpaRepository<Article, Long>,
        QuerydslPredicateExecutor<Article>, //해당 엔티티 안에있는 모든 검색기능을 추가해줌 // 완전 동일해야만 동작
        QuerydslBinderCustomizer<QArticle> // 부분검색, 대소문자 구분 등을 위함
{
    @Override
    default void customize(QuerydslBindings bindings, QArticle root){
        //Article에 대해 선택적인 필드에 대한 검색
        bindings.excludeUnlistedProperties(true); //리스팅 하지 않은 프로퍼티 검색 제외
        bindings.including(root.title, root.content, root.hashtag, root.createdAt, root.createdBy); //검색 컬럼
        bindings.bind(root.title).first(StringExpression::containsIgnoreCase); // like '%${v}%'/ 부분검색
        bindings.bind(root.content).first(StringExpression::containsIgnoreCase);
        bindings.bind(root.hashtag).first(StringExpression::containsIgnoreCase);
        bindings.bind(root.createdAt).first(DateTimeExpression::eq);//원하는 날짜검색 /시분초 동일하게 넣어야함
        bindings.bind(root.createdBy).first(StringExpression::containsIgnoreCase);
    }
}

spring:
  data: # spring data rest - 관련 설정
    rest:
      base-path: /api  #endpoint start path
      detection-strategy: annotated

@Builder  //QuestionDto.Post클래스타입 매개변수를 Question타입으로 변환하기 위함
public Question(final Long questionId,
                final String title,
                final String contents) {
    this.questionId = questionId;
    this.title = title;
    this.contents = contents;
}

public Question toQuestion() {
    return Question.builder()
            .title(title)
            .contents(contents)
            .build();
}

@Getter
@RequiredArgsConstructor
public class QuestionTagDto {
        private Long tagId; //필수
        private String tagName;
}

//  implementation 'org.springframework.boot:spring-boot-starter-security'
//     testImplementation 'org.springframework.security:spring-security-test'

@Column(nullable = false)

@Enumerated(value = EnumType.STRING) //enum값 string으로 출력
private QuestionStatus questionStatus = QuestionStatus.QUESTION_REGISTRATION;

@CreatedDate
@Column(nullable = false)
private LocalDateTime createdAt ;
@LastModifiedDate
private LocalDateTime modifiedAt;

@EnableJpaAuditing

@EntityListeners(AuditingEntityListener.class)

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/stackoverflow?serverTimezone=Asia/Seoul
    username: root
    password: 1234

  jpa:
    hibernate:
      ddl-auto: create  # (1) ??? ?? ??
    show-sql: true      # (2) SQL ?? ??
    properties:
      hibernate:
        format_sql: true  # (3) SQL pretty print
  logging:
    level:
      org:
        springframework:
          orm:
            jpa: DEBUG

implementation 'org.springframework.boot:spring-boot-starter-web'
runtimeOnly 'com.mysql:mysql-connector-j'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'org.springframework.boot:spring-boot-starter-jdbc'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
implementation 'org.mapstruct:mapstruct:1.5.3.Final'
annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.3.Final'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation 'org.springframework.boot:spring-boot-starter-mail'