1. @MappedSuperclass
2. AuditorAware 인터페이스
3. @EntityListeners
4. @EnableJpaAuditing

JPQL

-설정된 주기별로 실행될 함수를 설정

@Scheduled

1) fixedDelay : 작업 완료 후 고정 시간 지연 간격

2) fixedRate : 고정 시간 간격으로 실행

3) initialDelay : 작업 시작 전 시간 간격 지연

4) cron : 상세한 실행 주기를 설정할 때

0 0 /1*** 1시간 마다 실행 정각 실행

0 30 13,18***

오후 1시 30분 오후 6시 30분 실행

5) @EnableScheduling : 스케줄링 설정 활성화

스프링 시큐리티

-인증,인가

1. 의존성 설치
2. 스프링 시큐티리 설정
3. 회원가입 구현

   1) UserDetails 인터페이스 : DTO

2) UserDetailsService 인터페이스 : Service

4. 시큐리티를 이용한 회원 인증(로그인) 구현
5. 로그인 정보 가져오기 1) Principal 요청메서드에 주입 : getName() : 아이디 : 요청 메서드의 주입 2) SecurityContextHolder를 통해서 가져오기 3) @AuthenticationPrincipal : UserDetails 구현 객체 주입, 요청 메서드의 주입시 밖에 사용 가능

4) Authentication Object getPrincipal(...) : UserDetails의 구현 객체 boolean isAuthenticated() : 인증 여부

/error 템플릿 경로 : 응답 코드.html

6. thymeleaf-extras-springsecurity6 1) xmlns:sec="http://www.thymeleaf.org/extras/spring-security"

   2) sec:authorize="hasAnyAuthority(...)", sec:authorize="hasAuthority(...)" 3) sec:authorize="isAuthenticated()" : 로그인 상태 4) sec:authorize="isAnonymous()" : 미로그인 상태

   5) csrf 토큰 설정하기

    - ${_csrf.token}
    - ${_csrf.headerName}

7. 페이지 권한 설정하기

   • AuthenticationEntryPoint

8. Spring Data Auditing + Spring Security

• 로그인 사용자가 자동 DB 추가 1) AuditorAware 인터페이스

POST 요청시 CSRF 토큰 검증 : 검증 실패시 403

• 자바 스크립트 ajax 형태로 POST 데이터를 전송할시 CSRF 토큰 검증

9. @EnableMethodSecurity

1) @PreAuthorize: 메서드가 실행되기 전에 인증을 거친다. 2) @PostAuthorize: 메서드가 실행되고 나서 응답을 보내기 전에 인증을 거친다.

3) 사용할수 있는 표현식

• hasRole([role]) : 현재 사용자의 권한이 파라미터의 권한과 동일한 경우 true
• hasAnyRole([role1,role2]) : 현재 사용자의 권한디 파라미터의 권한 중 일치하는 것이 있는 경우 true
• principal : 사용자를 증명하는 주요객체(User)를 직접 접근할 수 있다.
• authentication : SecurityContext에 있는 authentication 객체에 접근 할 수 있다.
• permitAll : 모든 접근 허용
• denyAll : 모든 접근 비허용
• isAnonymous() : 현재 사용자가 익명(비로그인)인 상태인 경우 true
• isRememberMe() : 현재 사용자가 RememberMe 사용자라면 true
• isAuthenticated() : 현재 사용자가 익명이 아니라면 (로그인 상태라면) true
• isFullyAuthenticated() : 현재 사용자가 익명이거나 RememberMe 사용자가 아니라면 true

Q클래스는 QueryDSL이 엔터티를 기반으로 자동 생성하는 클래스

Q클래스를 사용하면 엔터티의 필드를 타입 안정성(Type Safety)을 유지하면서 쿼리를 작성할 수 있다.

추가 방법

의존성에 추가해준다.

public class QWishList extends EntityPathBase<WishList> {
    public final StringPath email = createString("email");
    public final NumberPath<Long> seq = createNumber("seq", Long.class);
    public final DateTimePath<LocalDateTime> createdAt = createDateTime("createdAt", LocalDateTime.class);
}

위처럼 WishList 엔터티를 기반으로 QWishList 클래스가 src/main/generated 폴더에 생성된다.

사용법

특정 필드로 조회 (eq 사용)

QWishList wishList = QWishList.wishList;
WishList result = queryFactory
    .selectFrom(wishList)
    .where(wishList.email.eq("user@example.com"))
    .fetchOne();

다중 조건 조회 (BooleanBuilder 활용)

BooleanBuilder builder = new BooleanBuilder();
builder.and(wishList.email.eq("user@example.com"));
builder.and(wishList.seq.eq(123L));

List<WishList> results = repository.findAll(builder);

정렬해서 조회 (Sort.by 활용)

List<WishList> results = repository.findAll(
    wishList.email.eq("user@example.com"),
    Sort.by(Sort.Direction.DESC, "createdAt")
);

또한, build.gradle 에서 QClass에 관한 설정을 할 수 있다.

// JUnit 5 (JUnit Platform) 사용 설정
tasks.named('test') {
    useJUnitPlatform()
}

// QueryDSL 자동 생성된 파일이 저장될 디렉토리 지정
def querydslDir = layout.buildDirectory.dir("generated/querydsl").get().asFile

sourceSets {
    // QueryDSL이 생성한 Q클래스를 소스 코드로 인식하도록 추가
    main.java.srcDirs += [ querydslDir ]
}

tasks.withType(JavaCompile) {
    // Java 컴파일 시, QueryDSL이 생성한 Q클래스도 함께 컴파일되도록 설정
    options.getGeneratedSourceOutputDirectory().set(file(querydslDir))
}

clean.doLast {
    // 'gradle clean' 실행 시 QueryDSL이 생성한 Q클래스 삭제 (최신 상태 유지)
    file(querydslDir).deleteDir()
}

예를들어 요청이

 if (anno instanceof RequestMapping) { // 모든 요청 방식 매핑
                RequestMapping mapping = (RequestMapping) anno;
                mappings = mapping.value();
            }

에 해당되는 요청이 들어왔다면

//에노테이션

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestMapping {
    String[] value();
}

해당 에노테이션 배열에

(MemberController)

@Controller
@RequestMapping("/member")
@RequiredArgsConstructor
public class MemberController {
    private final JoinService joinService;

    @GetMapping("/{mode}/test/{num}")
    public String join(@PathVariable("mode") String mode, @RequestParam("seq") int seq, RequestJoin form,  HttpServletResponse response, @PathVariable("num") int num) {
        System.out.printf("mode=%s, seq=%d, num=%d%n", mode, seq, num);
        System.out.println(form);
        joinService.process();
        return "member/join";
    }
}

[/member] 이 담기게된다.

package org.choongang.global.router;

import jakarta.servlet.http.HttpServletRequest;
import org.choongang.global.config.annotations.*;
import org.choongang.global.config.containers.BeanContainer;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
public class HandlerMappingImpl implements HandlerMapping{


    private String controllerUrl;

    @Override
    public List<Object> search(HttpServletRequest request) {

        List<Object> items = getControllers();

        for (Object item : items) {         // item = req
            /* Type 애노테이션에서 체크 S */
            // @RequestMapping, @GetMapping, @PostMapping, @PatchMapping, @PutMapping, @DeleteMapping
            if (isMatch(request,item.getClass().getDeclaredAnnotations(), false, null)) {
                // 메서드 체크
                for (Method m : item.getClass().getDeclaredMethods()) {
                    if (isMatch(request, m.getDeclaredAnnotations(), true, controllerUrl)) {
                        return List.of(item, m);    // req객체와 매칭되는 컨트롤러에 정의되어 있는 요청 메서드를 리스트로 리턴
                    }
                }
            }
            /* Type 애노테이션에서 체크 E */

            /**
             * Method 애노테이션에서 체크 S
             *  - Type 애노테이션 주소 매핑이 되지 않은 경우, 메서드에서 패턴 체크
             */
            for (Method m : item.getClass().getDeclaredMethods()) {
                if (isMatch(request, m.getDeclaredAnnotations(), true, null)) {
                    return List.of(item, m);
                }
            }
            /* Method 애노테이션에서 체크 E */
        }

        return null;
    }


    /**
     *
     * @param request
     * @param annotations : 적용 애노테이션 목록
     * @param isMethod : 메서드의 에노테이션 체크인지
     * @param prefixUrl : 컨트롤러 체크인 경우 타입 애노테이션에서 적용된 경우
     * @return
     */
    private boolean isMatch(HttpServletRequest request, Annotation[] annotations, boolean isMethod, String prefixUrl) {
    //에노테이션과 요청이 일치하는지 확인하기 위함.
        String uri = request.getRequestURI();
        String method = request.getMethod().toUpperCase();  //요청 방식 가져옴 GET,POST 등등
        String[] mappings = null;
        for (Annotation anno : annotations) {

            if (anno instanceof RequestMapping) { // 모든 요청 방식 매핑
                RequestMapping mapping = (RequestMapping) anno;
                mappings = mapping.value();
            } else if (anno instanceof GetMapping && method.equals("GET")) { // GET 방식 매핑
                GetMapping mapping = (GetMapping) anno;
                mappings = mapping.value();
            } else if (anno instanceof PostMapping && method.equals("POST")) {
                PostMapping mapping = (PostMapping) anno;
                mappings = mapping.value();
            } else if (anno instanceof PutMapping && method.equals("PUT")) {
                PutMapping mapping = (PutMapping) anno;
                mappings = mapping.value();
            } else if (anno instanceof PatchMapping && method.equals("PATCH")) {
                PatchMapping mapping = (PatchMapping) anno;
                mappings = mapping.value();
            } else if (anno instanceof DeleteMapping && method.equals("DELETE")) {
                DeleteMapping mapping = (DeleteMapping) anno;
                mappings = mapping.value();
            }

            if (mappings != null && mappings.length > 0) {

                String matchUrl = null;
                if (isMethod) {
                    String addUrl = prefixUrl == null ? "" : prefixUrl;
                    // 메서드인 경우 *와 {경로변수} 고려하여 처리
                    for(String mapping : mappings) {
                        String pattern = mapping.replace("/*", "/\\w*")
                                .replaceAll("/\\{\\w+\\}", "/(\\\\w*)");

                        Pattern p = Pattern.compile("^" + request.getContextPath() + addUrl + pattern + "$");
                        Matcher matcher = p.matcher(uri);
                        return matcher.find();
                    }
                } else {
                    List<String> matches = Arrays.stream(mappings)
                            .filter(s -> uri.startsWith(request.getContextPath() + s)).toList();
                    if (!matches.isEmpty()) {
                        matchUrl = matches.get(0);
                        controllerUrl = matchUrl;
                    }
                }
                return matchUrl != null && !matchUrl.isBlank();
            }
        }

        return false;
    }

    /**
     * 모든 컨트롤러 조회
     *
     * @return
     */
    private List<Object> getControllers() {
       return BeanContainer.getInstance().getBeans().entrySet()
                    .stream()
                    .map(s -> s.getValue())
                .filter(b -> Arrays.stream(b.getClass().getDeclaredAnnotations()).anyMatch(a -> a instanceof Controller || a instanceof RestController))
                .toList();
    }
}

Spring Boot 애플리케이션에서는 예외 메시지를 코드에서 직접 하드코딩하는 대신, 프로퍼티 파일을 활용하여 중앙에서 관리할 수 있다.

1. 예외 메시지 프로퍼티 파일 설정

우선, messages.properties 파일을 src/main/resources 경로에 생성하고 예외 메시지를 정의

이제 특정 예외가 발생할 때, 해당 키를 사용하여 메시지를 불러올 수 있도록 설정

2.1 CommonException 클래스 만들기

모든 예외의 부모 클래스 역할을 하는 CommonException을 생성

2.2 NotFoundException 클래스 구현

프로퍼티에서 예외 메시지를 가져오는 NotFoundException 클래스를 작성.

이제 NotFoundException을 생성할 때, 프로퍼티에서 해당 키의 메시지를 가져와 예외 메시지로 설정

3. 예외 발생 및 메시지 출력

예외를 발생시킬 때 프로퍼티 키를 전달하여 적절한 메시지를 반환 가능

throw new NotFoundException("NotFound.board");

위 코드를 실행하면 messages.properties에서 NotFound.board 키를 찾아 "게시판을 찾을 수 없습니다." 라는 메시지를 반환

4. 다국어 지원

Spring Boot의 MessageSource를 활용하면 다국어 지원도 가능. 예를 들어 messages_en.properties 파일을 추가하여 영어 메시지를 설정 가능

# messages_en.properties
NotFound.board=Board not found.
NotFound.boardData=Post not found.
NotFound.comment=Comment not found.
RequiredCheck.guestPw=Password confirmation is required.
Mismatch.password=Passwords do not match.

그리고 application.yml 또는 application.properties에서 기본 메시지 소스를 등록.

spring:
  messages:
    basename: messages
    encoding: UTF-8

이제 클라이언트의 요청 언어(Accept-Language 헤더)에 따라 한국어 또는 영어 메시지가 자동으로 적용된다.

위와 같이 프로퍼티 파일을 활용하면 예외 메시지를 한 곳에서 효율적으로 관리할 수 있으며, 다국어 지원까지 가능해지고, 이를 통해 코드의 유지보수성을 높이고, 보다 깔끔한 예외 처리 방식을 구현할 수 있다.

JWT(Json Web Token)는 사용자 인증과 권한 부여를 위해 사용되는 토큰 기반 인증 방식 일반적으로 사용자가 로그인하면 서버는 JWT를 발급하고, 이후 요청마다 클라이언트는 이 토큰을 포함하여 서버에 보냄 서버는 이 토큰을 검증하여 사용자를 인증하고 권한을 확인할 수 있음.

• 구조

  헤더(Header).페이로드(Payload).서명(Signature)

Header(헤더): 토큰 타입(JWT)과 해싱 알고리즘(HMAC, RSA 등) 정보 포함

Payload(페이로드): 사용자 정보(예: ID, 권한, 만료 시간) 포함

Signature(서명): 토큰 위조 방지를 위한 서명

ex)

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjMiLCJyb2xlIjoiVVNFUiIsImV4cCI6MTcwOTAwMDAwMH0.abc123xyz456

Spring Security JWT

일반적으로 Spring Security에서 UsernamePasswordAuthenticationFilter를 사용하여 로그인 처리를 함. 하지만 JWT를 사용할 경우, 서버가 사용자 세션을 관리하지 않고, 클라이언트가 인증 정보를 자체적으로 보유하게 됨. 따라서 요청이 들어올 때마다 JWT를 검증하고, 해당 정보를 기반으로 사용자를 인증하는 커스텀 필터를 구현해야함.

필터 클래스 생성

Spring Security의 GenericFilterBean을 상속하여 필터를 구현

@Component
@RequiredArgsConstructor
public class LoginFilter extends GenericFilterBean {

    private final RestTemplate restTemplate;
    private final ObjectMapper objectMapper;
    private final Utils utils;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {

        String token = getToken(request);
        if (StringUtils.hasText(token)) {
            loginProcess(token);
        }

        chain.doFilter(request, response);
    }
}

JWT 토큰 추출

클라이언트가 보낸 요청에서 JWT 토큰을 추출하는 메서드를 작성

private String getToken(ServletRequest request) {
    HttpServletRequest req = (HttpServletRequest) request;
    String bearerToken = req.getHeader("Authorization");
    if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
        return bearerToken.substring(7).trim();
    }
    return req.getParameter("token");
}

• Authorization 헤더에서 Bearer 토큰을 추출함.
• 헤더가 없는 경우, URL의 token 파라미터 값을 검사함.

JWT 검증 및 사용자 인증 처리

JWT를 검증하고, 사용자 정보를 SecurityContextHolder에 저장하는 로직을 작성

private void loginProcess(String token) {
    try {
        String apiUrl = utils.url("/account", "memberservice");

        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        HttpEntity<Void> entity = new HttpEntity<>(headers);
        ResponseEntity<JSONData> response = restTemplate.exchange(apiUrl, HttpMethod.GET, entity, JSONData.class);

        if (response.getStatusCode().is2xxSuccessful()) {
            JSONData data = response.getBody();
            if (data != null && data.isSuccess()) {
                String json = objectMapper.writeValueAsString(data.getData());
                Member member = objectMapper.readValue(json, Member.class);

                List<SimpleGrantedAuthority> authorities = List.of(new SimpleGrantedAuthority(member.getAuthority().name()));

                MemberInfo memberInfo = MemberInfo.builder()
                        .email(member.getEmail())
                        .password(member.getPassword())
                        .member(member)
                        .authorities(authorities)
                        .build();

                Authentication authentication = new UsernamePasswordAuthenticationToken(memberInfo, token, memberInfo.getAuthorities());
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
}

• JWT를 이용해 회원 정보를 가져온다.
• 회원의 Authority 정보를 SimpleGrantedAuthority 리스트에 추가한다.
• SecurityContextHolder에 인증 객체를 저장하여 로그인 처리를 완료한다.

-SimpleGrantedAuthority는 Spring Security에서 제공하는 클래스, Spring Security에서 권한을 설정하고 체크할 때 필수적으로 사용

필터 등록 및 적용

Spring Security에서 LoginFilter가 실행되도록 필터 체인에 등록해야 한다.

@Configuration
public class SecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http, LoginFilter loginFilter) throws Exception {
        return http
                .addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class)
                .authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
                .build();
    }
}

• addFilterBefore(loginFilter, UsernamePasswordAuthenticationFilter.class)을 사용하여 로그인 필터가 Spring Security 필터 체인에서 먼저 실행되도록 설정한다.

• 모든 요청을 인증된 사용자만 접근할 수 있도록 설정한다.

인증서

도메인 변경

RequestJoin : DTO MemberMapper : DAO

DTO(Data Transfer Object)는 계층 간 데이터 교환을 위한 객체로, 데이터베이스와 직접적인 연관 없이 사용된다. 예를 들어, RequestJoin 같은 DTO는 회원 가입 요청 정보를 담는 데 사용된다.

DAO(Data Access Object)는 데이터베이스와 직접 상호작용하는 객체로, CRUD(Create, Read, Update, Delete) 작업을 수행한다. MemberMapper 같은 DAO는 회원 정보를 조회하거나 저장하는 역할을 한다.

암호화 개념

1. 양방향 암호화 암호화된 데이터를 다시 복호화할 수 있는 방식으로, AES, RSA 같은 알고리즘이 있다. 비밀번호보다는 신용카드 정보 같은 복호화가 필요한 데이터에 사용된다.

2. 단방향 암호화 (해시) 암호화된 데이터를 복호화할 수 없는 방식이다. 비밀번호 저장에 적합하며, 대표적인 해시 알고리즘으로 MD5, SHA-256, SHA-512 등이 있다.

고정 해시 : 같은 값이면 항상 같은 해시 값이 생성된다. (MD5, SHA 계열) 유동 해시 : 같은 값이라도 매번 다른 해시 값이 생성된다. (Salt 사용, 예: BCrypt)

BCrypt (jbcrypt 라이브러리)

BCrypt는 보안성이 뛰어난 유동 해시 방식으로, 비밀번호 저장 시 주로 사용된다.

hashpw(...) : 비밀번호를 해시화 checkpw(...) : 해시 값을 검증

import org.mindrot.jbcrypt.BCrypt;

public class PasswordEncryption {
    public static void main(String[] args) {
        String password = "mySecurePassword";

        // 비밀번호 해싱
        String hashedPassword = BCrypt.hashpw(password, BCrypt.gensalt());
        System.out.println("Hashed Password: " + hashedPassword);

        // 비밀번호 검증
        boolean isMatch = BCrypt.checkpw(password, hashedPassword);
        System.out.println("Password Match: " + isMatch);
    }
}

Spring Boot의 DTO(데이터 전송 객체)나 엔티티 클래스에서 입력값을 검증할 때 주로 사용된다.

@RestController
@RequestMapping("/users")
public class UserController {

    @PostMapping("/register")
    public ResponseEntity<String> registerUser(@Valid @RequestBody UserRequest request) {
        return ResponseEntity.ok("회원가입 성공!");
    }
}

위 예시처럼 @Vaild 애노테이션을 통해 검증한다.

그 후 엔티티나 DTO에서

@Entity
public class User {

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

    @NotBlank
    private String name;

    @Size(min = 6, max = 20)
    private String password;

    @Min(18)
    private int age;
}

위와 같이 DB에 저장할때 유효하지 않은 값을 예외처리할 수 있다.

기본적인 애노테이션만 알아보자면, 문자열 ✔️ @NotBlank → 빈 값, 공백 문자열 불가 ✔️ @Size(min=, max=) → 문자열 길이 제한

숫자 ✔️ @Min(value) → 최소값 지정 ✔️ @Max(value) → 최대값 지정

컬렉션 & 객체 ✔️ @NotEmpty → 리스트나 배열이 비어있으면 안 됨 ✔️ @Valid → 내부 객체 필드까지 검증

등이있다.

웹에서 리소스를 효과적으로 다루는 방식이다.

• 리소스: 웹에서 관리할 대상(데이터, 자원)

✔ RESTful API는 REST 원칙을 지키는 API ✔ 리소스 중심의 설계 + HTTP 메서드 활용 ✔ 일관성 있고, 확장 가능하며, 유지보수하기 쉬운 구조 ✔ URI는 리소스를 표현하고, 동작은 HTTP 메서드로

- 장점

1. 일관된 인터페이스
2. 확장성
3. 유지보수 용이
4. 다양한 클라이언트와 호환
5. 캐싱 가능

- 원칙

• 리소스명은 복수형 (/users 대신 /user ❌ → /users ⭕)
• 행동(동사)은 URL이 아니라 HTTP 메서드로 표현 (/getUser ❌ → GET /users/1 ⭕)
• 계층적 구조 유지 (/users/1/posts → 1번 사용자 게시글)
• 필요한 경우 쿼리 스트링 사용 (/users?role=admin)
• 하위 리소스를 나타낼 때는 슬래시(/) 사용 (/posts/1/comments/2 → 1번 게시글의 2번 댓글)

restful에서는 리소스 자체를 식별하는 데는 쿼리스트링을 사용하지 않는다.

- 쿼리스트링을 사용할 때

• 리소스를 필터링, 정렬, 페이징

예) 쿼리스트링 사용 예

검색 (필터링)    GET /posts?skey=REST (REST 관련 게시글 검색)
정렬    GET /posts?sort=date_DESC (날짜 내림차순 정렬)
페이징    GET /posts?page=2&limit=10 (2페이지, 10개씩)
복합 검색    GET /posts?skey=API&sort=likes_DESC&page=1&limit=5

사용하지 않는 예

GET /users/1   (URI로 리소스 식별)
GET /posts/10  (URI로 특정 게시글 조회)

결론 리소스를 적절하게 효율적으로 다루는 것이 중요하다.

- @PathVariable 에노테이션의 역할

1. URL 경로 변수(bid)를 컨트롤러 메서드의 매개변수로 변환

2. 클라이언트가 요청한 URL에서 {bid} 값을 추출하여 bid 변수에 저장

예시) /list/12345 와 같이 요청이 들어온다면 {bid} 부분이 12345로 치환된다.

그 후, bid 값이 infoService.getList(bid, search)에 전달된다.

가장 스프링부트에서 기본적인 애노테이션이면서 필수적으로 사용된다.

생략가능

@GetMapping("/config/{bid}")
public JSONData getConfig(@PathVariable String bid) {  // "bid" 생략 가능
    Board board = configInfoService.get(bid);
    return new JSONData(board);
}

위와 같이 변수명이 같다면 생략하여 표기도 가능하다.

vs @RequestParam

@GetMapping("/posts")
    public JSONData listAllPosts(
            @RequestParam(value = "page", defaultValue = "1") int page, // 기본값 1
            @RequestParam(value = "limit", defaultValue = "10") int limit, // 기본값 10
            @ModelAttribute BoardDataSearch search) {

        search.setPage(page);
        search.setLimit(limit); // limit은 기본적으로 10으로 설정됨

        ListData<BoardData> data = infoService.getList(search, DeleteStatus.ALL);
        return new JSONData(data);
    }

꽤나 비슷하게 사용될 수 있지만

1. 클라이언트가 /posts?page=2&limit=20 요청을 보냄
2. @RequestParam(value = "page")는 page=2 값을 추출하여 int page에 저장
3. @RequestParam(value = "limit")는 limit=20 값을 추출하여 int limit에 저장

위와 같이 쿼리스트링 값을 추출하여 컨트롤러 메서드의 매개변수에 주입할때 사용한다.

위와 같이 정렬되게 되고 클릭할 시 API 엔드포인트, HTTP 메서드(GET, POST, PUT 등), 요청 파라미터, 응답 형식 등을 보여준다.

작성하는 법은

게시글 목록 api를 기준으로

이런식으로 애노테이션을 활용하여 작성하게 된다.

자세하게는

 @Parameter(name="bid", required = true, description = "경로변수, 게시판 ID", example = "notice")

• required를 활성화할 경우 필수적으로 필요한 요소임을 표시하고,

• description를 통해 해당 요소에 대한 설명을 덧붙인다. 예시) 게시글 번호, 작성자 번호 등등.. (HTML 태그를 사용할 수 있다.)

• example를 통해 파라미터에 대한 예시 값을 제공한다.

여기서

이 항목에 대해서는 따로 작성한 적이 없는데 표기되는 이유는

swagger UI에서

@ModelAttribute 

를 사용하면 Swagger가 자동으로 해당 객체를 쿼리 파라미터로 변환하고, 이를 API 문서에 반영한다.

그리고 required가 표시된 이유는 쿼리 파라미터의 요소중에 한개라도 필수 항목이라고 판단하면 표시된다 .

@Data
public class BoardSearch extends CommonSearch {
    private String bid;
    private List<String> bids;

    private String bname;

    private boolean active;
}

active 요소가 null일수 없기에 필수적이다.

우선 위 상태코드를 이해 한뒤

위 반환타입을 이해하면,

데이터 베이스에 새로운 값을 저장할 경우에는 상태값을 201 created로 지정하여 전송하는 것이 맞다. 하지만 삭제, 단순 조회 같은 경우는 요청이 성공적으로 이루어졌는지만 판단하면 되기에 일반적인 JSONData 형식으로 반환 타입을 설정하는게 일반적이다.

그리고 사실은 글 수정 같은경우에도 실패 or 성공 둘중 하나만 전송하면 되기에 200OK를 전송하는 것이 맞지만, 위 코드(생략된 부분) 에는 글 수정과 작성을 통합해서 기능을 처리하고 있기때문에 상태코드를 수정할 수 있는

ResponseEntity <JSONData>

를 사용하였다.

젠킨스

http://jenkins.hidog.xyz:8080/

1) props: 부모 props가 변경이 되면 자식 컴포넌트가 리로드 2) state: 컴포넌트 안의 상태 값이 변경이 되면(useState를 통해 만든 값) 리로드 3) 부모 컴포넌트가 리로드 -> 자식 컴포넌트도 리로드 -하위 컴포넌트가 변경 사항이 없는 경우 다시 로딩하면 메모리 낭비

• 메모제이션 기법(캐싱) : React.memo(컴포넌트) 4) 강제 (클래스형 컴포넌트에서 this.forceUpdate())

1. JSX

<Fragment> -> <> 변수, 간단한 식 -> {...} {/* 주석 ... */} 조건문(if), 반복문(for, while) 사용 불가

삼항 조건문 : 간단한 조건문 대체

참고) or 연산자(||) : 기본값 설정시 and 연산자 : 간단한 조건식을 대체 (참인 조건만 체크하는 경우)

참고) 코드 정리

2. 컴포넌트

함수형 컴포넌트

function 컴포넌트 명() {
    return (
        JSX 문법
    );
}

화살표 함수를 써도 됨

Greeting

속성 : 컴포넌트에 전달하는 값

• 컴포넌트의 함수 매개변수에서 확인 가능 (props)

3. 이벤트 핸들링

1) useState

-state : 상태값 -컴포넌트 내부에서 변경될 수 있는 값 -컴포넌트의 리렌더링 기준, 값이 바뀌면 컴포넌트 리렌더링이 된다. -const [상태값, 상태 변경 함수] = useState(기본값);

상태 변경 함수 (값); 상태 변경 함수 (함수 형태)

예) setItems(newItems);

setItems((이전 상태 값) => 반환값); // useCallback, useEffect

• react-icons

참고) 컨테이너 컴포넌트 -이벤트 처리 -값의 가공 처리

프리젠테이셔널 컴포넌트 -컨테이너 컴포넌트가 가공한 값을 출력

• immer를 사용하여 더 쉽게 불변성 유지하기

• 값만 변경해도 불변성 유지 (새로운 객체 자동 생성) yarn add immer npm i immer

{...} -> if X, for X -> 배열 객체의 map 메서드 데이터 -> JSX 객체 변환

2) useEffect

컴포넌트 렌더링시 호출 : 최초에 필요한 작업 변화 감지 기준 값이 변경될때 호출

3) useReducer

useState와 비슷한 기능 상태값 관리 상태 변화 함수를 컴포넌트 외부에 정의 :컴포넌트가 렌더링 다시 돼도

메모제이션(캐싱)

4) useMemo

특정 함수의 연산 값

5) useCallback

변화 감지 기준의 값이 변경되지 않으면 함수가 다시 정의 X

6) useRef

-지역변수 current 속성 값으로 접근 가능

-DOM 선택시

스타일링

Sass

설치 yarn add sass

2) Scss -> {} 3) CSS Module -리액트에서 기본 제공

4) classnames yarn add classnames

5) styled-components yarn add styled-components

tagged 함수

코드 스플리팅

게임 랜더링 느낌 보이는것만 로드

Loadable Component yarn add @loadable/component

Context API

: 전역 상태 관리

램부족

(cicd 맨아래 복사)

#!/bin/bash
pid=$(pgrep -f deploytest)
if [ -n "${pid}" ]
then
        kill -15 ${pid}
        echo kill process ${pid}
else
        echo no process
fi
chmod +x ./project/deploytest-0.0.1-SNAPSHOT.jar 
nohup java -jar -Dspring.profiles.active=prod ./project/deploytest-0.0.1-SNAPSHOT.jar  >> application.log 2> /dev/null &

최종

(다른 거 등록)

환경변수 찾아서 넣어줘야함

여기 참고

생략------- 웹사이트 연동

----- 여기까지

------ 젠킨스

pem파일 key에 넣기 (aws 에서 다운받았던 거)

젠킨스 파이프라인 복붙 후 주소 바꾸기

pipeline {
    agent any

    stages {
        stage('Git Clone') {
            steps {
                git branch: 'master', url: '브랜치 깃 클론 주소'
            }
        }
        stage('Build') {
            steps {
                dir(".") {
                    sh "chmod 744 gradlew"
                    sh "./gradlew clean bootJar"
                }
            }
        }
        stage('Deploy') {
            steps {
                sshagent(credentials: ['키이름']) {
                    sh '''
                        ssh -o StrictHostKeyChecking=no ubuntu@서버아이피주소 uptime
                        scp /var/jenkins_home/workspace/젠킨스 서버 이름(ex:configserver)/build/libs/젠킨스 서버 이름(ex:configserver)-0.0.1-SNAPSHOT.jar ubuntu@서버아이피주소:/home/ubuntu/젠킨스 서버 이름(ex:configserver)

                        ssh -t ubuntu@서버아이피주소 ./deploy.sh
                    '''
                }
            }
        }
    }
}

서버주소로 연결 확인

• 데이터베이스는 리눅스 서버에서 https://github.com/yonggyo1125/lecture_cicd 도커 설치후 깔면됨

// 수동 시작

sh deploy_boardservice.sh
tail -f application_boardservice.log

MSA

설정 서버

: 깃허브 레포지토리

게이트웨이

회원 member-service - /api/v1/member

Next.js

1. 설치 & 실행

yarn create next-app@latest 프로젝트명

yarn create next-app exam01

npm i -g next-app

yarn dev : 개발 서버 실행 yarn build : 배포 파일 생성 yarn start : 실서버 실행 (빌드 -> 스타트)

2. 빌드와 배포

3. 뼈대 만들기

메타데이터 -> 레이아웃에서 헤더쪽 데이터 치환

member/layout.js -> 멤버전용 레이아웃

4. 라우팅

폴더 -> url 주소

1) 경로변수 - 폴더명 [경로변수명]로 만듦 props : params : 경로변수 searchParams : 쿼리스트링 값

콘솔찍으면 터미널에 찍힘

params 종류 두개 기억

seq 세 개 명이 같기만 하면 됨(글자 seq 필수 X)

params 글자는 필수

5. Single Page Application

-CSR(client Side Rendering) - React Router

:반응성이 좋음 :인터넷 연결이 없어도 기본 페이지가 출력 :검색 반영 X :Link, NavLink

-SSR(Server Side Rendering) next.js의 기본 방식

:검색 반영 O :페이지 새로고침 - 반응성 X :a 태그를 사용해서 링크 이동

:next.js에서 CSR을 사용하려면? Link 태그 사용

6. 환경 변수

.env ...

NEXT_PUBLIC_ : NEXT_PUBLIC_ 접두어가 있어야 환경 변수 접근 가능 (process.env.NEXT_PUBLIC_API_URL) 참고) 리액트 REATC_APP_ : REACT_APP_ 접두어가 있어야 환경 변수 접근 가능 (process.env.REACT_APP_API_URL...)

줄개행을 처리하고 있던 중 한글은 줄 개행이 잘 되는데 영어는 잘 안되는 오류를 발견했다.

스타일에서 해결할 수 있었다.

영어나 끊어지지 않는 단어에서 사용하도록 하자.

        String referer = request.getHeader("Referer");  // 요청 발생시킨 주소 가져옴

이렇게 추출한 url을 통해 iframe창을 이동 시킬 예정이였다.

(해당 사진 아래 댓글 창이 iframe)

   if (referer != null && referer.contains("board/comment/")) {
            String redirectUrl = utils.redirectUrl(String.format("/board/comment/%d?comment_id=%d", commentData.getBoardData().getSeq(), commentData.getSeq()));

            String script = String.format("location.replace('%s');", redirectUrl);

            System.out.println("script12321" + script);
            model.addAttribute("script", script);

            return "common/_execute_script";
        }

그러나 댓글은 추가 되지만 url이 이동되지 않았다. 이유는 iframe에 target 설정이 올바르지 않기때문이다 . iframe 댓글의 레이아웃을 적용해야했다.

그리고 이 정보들을 HTML(th) 로 넘겨서 데이터를 출력하거나 사용할 수 있는데,

예외적으로 사용못하는 경우가 있다.

위와 같이 빈에 있는 메서드를 사용한 경우 내부에서 사용할 수 없다. (위 메서드는 오류가 발생함 seq = null)

이 데이터를 사용하기 위해 url에 직접 변화를 가하면 된다.

 const href = seqEl.href.substring(0, seqEl.href.lastIndexOf("/")) + "/" + this.seq;
                    seqEl.href = href;
                    ifrmBoard.location.href = href.substring(0, href.lastIndexOf("/board/view/")) + "/board/comment/" + this.seq;
                    console.log(ifrmBoard.location.href)