Spring Security에서 JWT(JSON Web Token) 인증은 일반적으로 다음 단계를 거칩니다.

1. 클라이언트 로그인 요청 → 서버에서 JWT 발급.
2. 클라이언트 요청 시 헤더에 JWT 포함 (Authorization: Bearer <토큰>).
3. 서버의 필터(JwtAuthenticationFilter)가 요청을 가로채서:
   • 헤더에서 토큰 추출
   • 유효성 검증
   • 사용자 정보 로드
   • SecurityContext에 인증 객체 저장
4. 이후 컨트롤러에서 @AuthenticationPrincipal 등을 통해 인증된 사용자 정보를 활용.

이 필터는 모든 HTTP 요청을 가로채 JWT를 검증하고 인증 여부를 확인하는 핵심적인 역할을 합니다.

📝 코드 전체

package com.example.demo.security;

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.*;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.*;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtTokenProvider jwt;
    private final UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
            throws ServletException, IOException {

        // 1. 요청 헤더에서 Authorization 값 가져오기
        String header = req.getHeader("Authorization");

        // 2. "Bearer "로 시작하는지 확인
        if (header != null && header.startsWith("Bearer ")) {
            String token = header.substring(7);

            // 3. 토큰 유효성 검증
            if (jwt.validate(token)) {
                // 4. 토큰에서 사용자 이름(username) 추출
                String username = jwt.getUsername(token);

                // 5. DB에서 사용자 정보 로드
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);

                // 6. 사용자 정보 기반 인증 객체 생성
                UsernamePasswordAuthenticationToken auth =
                        new UsernamePasswordAuthenticationToken(
                                userDetails, null, userDetails.getAuthorities());

                // 7. SecurityContext에 인증 객체 저장
                SecurityContextHolder.getContext().setAuthentication(auth);
            }
        }

        // 8. 다음 필터/컨트롤러로 요청 전달
        chain.doFilter(req, res);
    }
}

🔍 세부 설명

1. 클래스 선언부

@Component
@RequiredArgsConstructor
public class JwtAuthenticationFilter extends OncePerRequestFilter

• @Component: 이 클래스를 Spring Bean으로 등록하여 Spring IoC 컨테이너가 관리하게 합니다.
• OncePerRequestFilter: 한 번의 요청(request)에 대해 단 한 번만 실행되는 필터를 보장합니다.
• @RequiredArgsConstructor: final 필드(jwt, userDetailsService)를 인자로 받는 생성자를 자동으로 생성하여 **의존성 주입(DI)**을 처리합니다.

2. Authorization 헤더 처리

String header = req.getHeader("Authorization");
if (header != null && header.startsWith("Bearer ")) {
    String token = header.substring(7);
}

클라이언트가 전송한 HTTP 요청의 Authorization 헤더에서 JWT를 추출합니다. 일반적으로 JWT는 "Bearer <토큰값>" 형식으로 전달되므로, "Bearer " 접두어를 제거하고 순수 토큰 값만 얻습니다.

3. JWT 검증 및 사용자 이름 추출

if (jwt.validate(token)) {
    String username = jwt.getUsername(token);
}

**JwtTokenProvider**를 사용하여 토큰의 유효성을 검사합니다. 토큰이 유효하다면, 토큰 내에 저장된 **사용자 이름(Subject)**을 추출합니다.

4. 사용자 정보 로드

UserDetails userDetails = userDetailsService.loadUserByUsername(username);

**UserDetailsService**는 Spring Security에서 사용자 정보를 제공하는 핵심 인터페이스입니다. 이를 통해 추출한 사용자 이름으로 데이터베이스나 다른 저장소에서 사용자 계정 정보를 UserDetails 객체로 가져옵니다.

5. 인증 객체 생성 및 SecurityContext 저장

UsernamePasswordAuthenticationToken auth =
        new UsernamePasswordAuthenticationToken(
                userDetails, null, userDetails.getAuthorities());

SecurityContextHolder.getContext().setAuthentication(auth);

**인증 객체(Authentication)**를 생성하고 SecurityContextHolder에 저장합니다.

• 첫 번째 인자: Principal (사용자 정보)
• 두 번째 인자: Credentials (비밀번호) - 토큰 기반 인증이므로 null로 설정 가능.
• 세 번째 인자: Authorities (권한 목록)

이렇게 SecurityContextHolder에 저장된 인증 정보는 이후 컨트롤러나 서비스 계층에서 전역적으로 접근할 수 있습니다.

✅ 정리 / 배운 점

• JwtAuthenticationFilter는 모든 요청을 가로채 JWT를 검증하는 핵심 필터입니다.
• 인증에 성공하면 SecurityContext에 인증 객체를 저장하여 Spring Security 전역에서 인증 상태를 유지합니다.
• 이 덕분에 컨트롤러 단에서는 별도의 인증 로직 없이 @AuthenticationPrincipal 등을 활용하여 인증된 사용자 정보에 손쉽게 접근할 수 있습니다.

🚀 확장

• 토큰이 유효하지 않을 때 401 Unauthorized 응답을 반환하도록 예외 처리를 추가하여 필터를 개선할 수 있습니다.
• Refresh Token과 Access Token을 함께 사용하는 방식으로 더 안전한 인증 구조를 설계할 수 있습니다.
• 로그아웃 시 토큰을 무효화하는 JWT 블랙리스트 기능을 추가하여 보안을 강화할 수 있습니다.

JWT(Json Web Token)는 JSON 형식으로 사용자 정보를 안전하게 전달하기 위한 토큰 기반 인증 방식입니다. 사용자가 로그인하면 서버는 JWT를 발급하고, 이후 요청마다 클라이언트는 이 토큰을 헤더에 담아 보냅니다. 서버는 별도의 세션 저장소 없이도 토큰만으로 사용자를 인증할 수 있습니다.

📦 JWT의 구조

JWT는 .으로 구분된 세 부분으로 이루어집니다.

xxxxx.yyyyy.zzzzz

• Header (헤더) 토큰의 타입(JWT)과 해싱 알고리즘(예: HS256) 정보를 담습니다.

  {
    "alg": "HS256",
    "typ": "JWT"
  }

• Payload (페이로드) 실제 담고 싶은 사용자 정보(Claims)입니다. 예: 사용자 이름, 권한, 만료 시간 등.

  {
    "sub": "user123",
    "iat": 1691234567,
    "exp": 1691238167
  }

• Signature (서명) Header와 Payload를 비밀 키(Secret Key)로 서명한 값입니다. 토큰 위·변조 여부를 검증할 때 사용됩니다.

🛠 코드 소개

이번에 작성한 JwtTokenProvider 클래스는 Spring Security에서 JWT를 생성하고 검증하는 핵심 역할을 담당합니다. 구체적으로는 다음과 같은 역할을 수행합니다.

• 토큰 생성 (generateToken)
• 토큰에서 사용자 이름 추출 (getUsername)
• 토큰 유효성 검증 (validate)

📝 코드 전체

package com.example.demo.security;

import io.jsonwebtoken.*;
import io.jsonwebtoken.io.Decoders;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;

@Component
public class JwtTokenProvider {

    // HMAC-SHA 알고리즘을 위한 시크릿 키와 토큰 만료 시간
    private final SecretKey key;
    private final long expirationMs;

    // 생성자: application.yml에서 시크릿 키와 만료 시간 주입
    public JwtTokenProvider(
            @Value("${jwt.secret}") String secret,
            @Value("${jwt.expiration-ms}") long expirationMs
    ) {
        byte[] keyBytes = (secret.matches("^[A-Za-z0-9+/=]+$") ? Decoders.BASE64.decode(secret) : secret.getBytes());
        this.key = Keys.hmacShaKeyFor(keyBytes);
        this.expirationMs = expirationMs;
    }
    // 핵심: 토큰을 만들고 검증하는 데 필요한 시크릿 키와 만료 시간을 application.yml에서 가져와서 준비하는 과정

    // ✅ JWT 토큰 생성
    public String generateToken(UserDetails user) {
        Date now = new Date();
        Date exp = new Date(now.getTime() + expirationMs);

        return Jwts.builder()
                .setSubject(user.getUsername())   // 토큰의 주체(사용자 이름)
                .setIssuedAt(now)                 // 토큰 발행 시간
                .setExpiration(exp)               // 토큰 만료 시간
                .signWith(key, Jwts.SIG.HS256)    // 시크릿 키로 HS256 알고리즘을 사용하여 토큰에 서명
                .compact();                       // 최종적으로 문자열로 압축하여 반환
    }
    // 핵심: 토큰에 사용자 이름, 발행 시간, 만료 시간 등의 정보를 담고, 시크릿 키로 서명하여 안전하게 생성하고 문자열 형태로 변환하는 과정

    // ✅ 토큰에서 사용자 이름 추출
    public String getUsername(String token) {
        return Jwts.parser()
                .verifyWith(key)                 // 토큰의 서명을 시크릿 키로 검증
                .build()
                .parseSignedClaims(token)        // 토큰을 파싱하고 클레임(정보)을 가져옴
                .getPayload()
                .getSubject();                   // 토큰의 주체(사용자 이름) 반환
    }
    // 핵심: 토큰이 유효한지 먼저 확인한 다음, 그 안에 담긴 사용자 이름을 추출하는 과정

    // ✅ 토큰 유효성 검증
    public boolean validate(String token) {
        try {
            // 토큰을 파싱하고 서명을 검증
            Jwts.parser().verifyWith(key).build().parseSignedClaims(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            // 토큰이 잘못되었거나 만료된 경우 예외 발생
            return false;
        }
    }

    // 토큰 만료 시간 반환
    public long getExpirationMs() {
        return expirationMs;
    }
}

🔍 세부 설명

1. 생성자

public JwtTokenProvider(@Value("${jwt.secret}") String secret, @Value("${jwt.expiration-ms}") long expirationMs)

application.yml에서 jwt.secret과 jwt.expiration-ms 값을 읽어옵니다. 이 값들로 HMAC-SHA256 알고리즘에 맞는 SecretKey 객체를 생성하여 토큰 서명에 사용합니다.

2. 토큰 생성 (generateToken)

public String generateToken(UserDetails user)

user.getUsername()을 토큰의 Subject로 설정하고, 발행 시간(IssuedAt)과 만료 시간(Expiration)을 지정합니다. signWith(key, Jwts.SIG.HS256)를 통해 시크릿 키 기반으로 서명하여 위변조를 방지합니다. 최종적으로 문자열 형태의 JWT를 반환합니다.

3. 토큰에서 사용자 이름 추출 (getUsername)

public String getUsername(String token)

토큰을 파싱하고 서명을 검증한 뒤, Payload의 Subject(사용자 이름)를 꺼내옵니다.

4. 토큰 유효성 검증 (validate)

public boolean validate(String token)

parseSignedClaims(token) 실행 시 예외가 발생하지 않으면 true를 반환합니다. 만료되었거나 위조된 경우 JwtException이 발생하여 false를 반환합니다.

✅ 정리 및 배운 점

• JWT는 세션 저장소 없이 인증 상태를 유지할 수 있는 강력한 방법입니다.
• JwtTokenProvider는 토큰 발급과 검증 로직을 담당하며 Spring Security와 자연스럽게 연동됩니다.
• 보안을 위해 시크릿 키는 반드시 환경 변수로 관리해야 하며, 외부에 노출되지 않도록 주의해야 합니다.

🚀 확장

• Refresh Token 발급 및 재발급 기능 추가: Access Token 만료 시 사용자 경험을 개선할 수 있습니다.
• 권한(Role) 정보를 토큰에 함께 저장하여 Spring Security의 Authentication 객체로 변환할 수 있습니다.
• 예외 처리 강화: 단순히 true/false 대신 "만료됨 / 위조됨 / 형식 오류" 등 구체적인 응답을 제공하여 클라이언트가 문제를 정확히 파악할 수 있도록 돕습니다.

1. 생성자 어노테이션: 객체 생성 방식을 자유롭게

객체를 생성하는 방법은 여러 가지가 있으며, Lombok은 각 상황에 맞는 생성자를 자동으로 만들어줍니다.

@NoArgsConstructor (기본 생성자)

인자가 없는 기본 생성자를 만듭니다.

• 사용 목적:

  • JPA(Java Persistence API): JPA는 데이터베이스에서 엔티티를 조회할 때 리플렉션(Reflection)을 통해 객체를 생성하는데, 이때 기본 생성자가 반드시 필요합니다.
  • JSON 직렬화/역직렬화: Jackson이나 Gson 같은 라이브러리가 JSON 데이터를 객체로 변환할 때도 기본 생성자를 사용합니다.

• 예제:

@NoArgsConstructor
public class Book {
    private String title;
    private String author;
}

// Lombok이 생성하는 코드:
// public Book() {}

@AllArgsConstructor (모든 필드 생성자)

클래스의 모든 필드를 인자로 받는 생성자를 만듭니다.

• 사용 목적:
  • 객체를 생성하는 시점에 모든 필드를 한 번에 초기화할 때 유용합니다.
• 예제:

@AllArgsConstructor
public class Book {
    private String title;
    private String author;
}

// Lombok이 생성하는 코드:
// public Book(String title, String author) {
//     this.title = title;
//     this.author = author;
// }

@RequiredArgsConstructor (필수 필드 생성자)

final로 선언되었거나 @NonNull 어노테이션이 붙은 필수 필드만을 인자로 받는 생성자를 만듭니다.

• 사용 목적:

  • 의존성 주입(Dependency Injection): 스프링(Spring) 프레임워크에서 가장 흔히 사용되는 방식으로, 반드시 필요한 의존성만 모아 생성자를 만들 수 있어 안정적입니다.
  • 불변 객체: final 필드를 사용해 불변 객체를 생성할 때 매우 유용합니다.

• 예제:

@RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;

    @NonNull
    private String version;
}

// Lombok이 생성하는 코드:
// public UserService(UserRepository userRepository, String version) {
//     this.userRepository = userRepository;
//     this.version = version;
// }

@Builder (빌더 패턴)

가장 강력하고 유연한 생성 방식으로, 빌더 패턴을 자동으로 구현해 줍니다.

• 사용 목적:

  • 필드가 많은 경우: 필드가 5개 이상일 때 @AllArgsConstructor보다 훨씬 명확하고 안전합니다.
  • 선택적 필드: 모든 필드가 필수적이지 않고, 일부 필드만 설정하고 싶을 때 사용하면 코드가 깔끔해집니다.

• 예제:

@Builder
public class UserProfile {
    private String name;
    private int age;
    private String email;
    private boolean isPublic;
}

// 사용 방법:
UserProfile profile = UserProfile.builder()
                        .name("Alice")
                        .age(30)
                        .isPublic(true) // 이메일은 선택적으로 생략 가능
                        .build();

2. 보일러플레이트(Boilerplate) 코드 제거

매일 반복해서 작성하는 Getter, Setter, toString() 같은 메서드들도 Lombok을 사용하면 한 줄로 해결할 수 있습니다.

@Getter & @Setter

필드에 대한 Getter와 Setter 메서드를 자동으로 생성해줍니다.

• 사용 목적:

  • @Getter: 객체의 데이터를 읽어와야 할 때 주로 사용합니다.
  • @Setter: 외부에서 필드의 값을 변경해야 할 때 사용합니다. 불변 객체를 만들 때는 @Setter를 사용하지 않는 것이 좋습니다.

• 예제:

public class Product {
    @Getter @Setter private String name;
    @Getter private int price; // price는 변경 불가능하게 설정
}

// Lombok이 생성하는 코드:
// public String getName() { return name; }
// public void setName(String name) { this.name = name; }
// public int getPrice() { return price; }

@ToString

객체의 필드 값들을 포함하는 toString() 메서드를 자동으로 만들어줍니다.

• 사용 목적:

  • 디버깅: 객체의 현재 상태를 로그로 출력하거나 디버깅 툴에서 확인할 때 매우 편리합니다.
  • 예외 처리: 예외 로그에 객체 상태를 포함시켜 문제를 빠르게 파악할 수 있습니다.

• 예제:

@ToString(exclude = "password") // password 필드는 제외
public class User {
    private String username;
    private String password;
    private String email;
}

// User 객체 출력 시:
// User(username=johndoe, email=john@example.com)

@EqualsAndHashCode

equals()와 hashCode() 메서드를 자동으로 오버라이딩합니다.

• 사용 목적:
  • 객체 비교: 두 객체가 논리적으로 동일한지 비교해야 할 때 사용합니다.
  • 컬렉션 사용: HashSet이나 HashMap 같은 컬렉션에 객체를 저장할 때, hashCode()를 이용해 성능을 높일 수 있습니다.
• 예제:

@EqualsAndHashCode
public class Point {
    private int x;
    private int y;
}

// 두 Point 객체 비교
Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
p1.equals(p2); // true

@Data (최강의 종합 어노테이션)

@Data는 @Getter, @Setter, @ToString, @EqualsAndHashCode, @RequiredArgsConstructor를 모두 포함하는 종합 선물 세트입니다.

• 사용 목적:

  • DTO(Data Transfer Object): 데이터를 담아 계층 간에 전달하는 역할을 하는 DTO 클래스에 주로 사용됩니다.

• 주의점: 엔티티 클래스에서는 데이터베이스 테이블의 컬럼을 직접 변경하는 @Setter를 함부로 사용하는 것을 지양해야 합니다.

• 예제:

@Data
public class PostDto {
    private String title;
    private String content;
}

마치며

이러한 Lombok 어노테이션들은 개발자가 비즈니스 로직에 더 집중할 수 있게 도와줍니다. 코드를 간결하게 만들고 유지보수를 쉽게 하는 어노테이션을 잘 활용하여 생산성을 높여 보세요!

1. 첫 번째 난관: API 요청에 뜨는 302 Found, 그 정체는?

저는 /api/posts라는 새로운 REST API를 만들고 Postman으로 POST 요청을 보냈습니다. 그런데 예상과 달리 200 OK 대신 302 Found 오류가 발생했고, 응답 헤더의 Location 필드는 저를 /login 페이지로 안내하고 있었습니다.

📌 문제 분석: formLogin의 함정

스프링 시큐리티는 기본적으로 웹 애플리케이션에 최적화되어 있습니다. 따라서 **formLogin**이라는 필터가 자동으로 활성화되는데, 이 필터의 주된 역할은 사용자가 인증되지 않았을 때 로그인 페이지로 리다이렉트시키는 것입니다.

포스트맨으로 보낸 API 요청은 당연히 로그인 정보를 담고 있지 않았습니다. 따라서 formLogin 필터는 요청을 차단하고 "로그인하세요!"라는 의미로 저를 /login 페이지로 보내버린 것이죠. API는 HTML 페이지를 받아 리다이렉트하는 것이 아닌, 상태 코드와 데이터만 주고받아야 하는데 말이죠.

• 해결책의 시작: API와 웹 애플리케이션의 보안 설정을 분리해야 한다는 것을 깨달았습니다. 스프링 시큐리티는 **여러 개의 SecurityFilterChain 빈(Bean)**을 허용하므로, API만을 위한 필터 체인과 웹을 위한 필터 체인을 따로 만들기로 했습니다. API용 필터 체인에는 formLogin을 비활성화하는 formLogin(form -> form.disable()) 설정을 추가했습니다.

2. 두 번째 난관: 302가 사라지니 403 Forbidden이 나타났다

formLogin 필터를 비활성화하자 마침내 302 오류가 사라졌습니다. 하지만 이번에는 403 Forbidden 오류가 저를 기다리고 있었습니다. SecurityConfig에 /api/** 경로를 permitAll()로 설정했음에도 말이죠.

📌 문제 분석: @AuthenticationPrincipal과 permitAll()의 충돌

403 Forbidden은 "인증은 되었지만, 해당 리소스에 접근할 권한이 없다"는 의미의 오류입니다. 그런데 저는 로그인한 적이 없으니 인증이 될 리가 없는데, 왜 이 오류가 발생했을까요? 원인은 바로 API 컨트롤러 메서드에 있었습니다.

// PostRestController.java
@PostMapping
public String createPost(@RequestBody PostCreateRequestDto dto,
                         @AuthenticationPrincipal UserDetails userDetails) {
    // ... userDetails.getUsername() 사용 ...
}

• permitAll()은 '로그인 여부와 관계없이' 접근을 허용합니다. 따라서 요청은 컨트롤러 메서드까지 도달했습니다.

• 하지만 메서드의 @AuthenticationPrincipal 파라미터는 **'로그인한 사용자의 정보'**를 요구합니다.

• 익명 사용자가 접근했기 때문에 userDetails가 null이 되었고, userDetails.getUsername() 같은 코드를 실행하는 순간 NullPointerException이 발생합니다.

• 스프링 시큐리티는 이 예외를 가로채서 403 상태 코드로 변환한 것입니다.

• 해결책: createPost 메서드에서 @AuthenticationPrincipal 파라미터를 제거하고, 게시글 작성자를 임시로 데이터베이스에 있는 특정 사용자(userRepository.findById(1L))로 지정했습니다. 이 API는 익명 사용자의 글쓰기를 허용하는 API였으므로, 로그인 정보를 요구하는 로직 자체가 잘못된 것이었죠.

3. 세 번째 난관: 돌아온 302와 필터 체인 우선순위

위의 두 가지 문제를 해결하고 다시 실행했을 때, 302 Found 오류가 또다시 저를 괴롭혔습니다. SecurityFilterChain을 분리하고 @Order를 부여했음에도 말이죠.

📌 문제 분석: 매칭 순서의 함정

스프링 시큐리티는 여러 개의 SecurityFilterChain 빈이 있을 때, 요청 URL에 맞는 가장 구체적인 필터를 먼저 적용합니다. 하지만 제 코드에서는 이 순서가 예상과 다르게 작동하고 있었습니다.

// apiFilterChain
http.securityMatcher("/api/**") // API 전용 필터
// ...
// webFilterChain
http.securityMatcher("/**") // 모든 경로에 대한 필터
// ...

이 두 필터는 POST /api/posts 요청에 모두 매칭될 수 있습니다. Spring Boot는 apiFilterChain이 더 구체적이므로 먼저 적용해야 하지만, 내부적인 로딩 순서나 설정 미스로 인해 webFilterChain이 먼저 동작하는 경우가 발생할 수 있습니다. webFilterChain은 formLogin 필터를 포함하고 있으므로, API 요청을 가로채 다시 302 리다이렉트를 일으킨 것입니다.

• 최종 해결책: apiFilterChain을 가장 단순하고 명확하게 만들었습니다. 다른 설정들과 충돌할 여지가 있는 anyRequest().authenticated()를 제거하고, anyRequest().permitAll()만 남겼습니다. 또한, apiFilterChain에 formLogin(form -> form.disable())을 명시적으로 추가하여, 설령 요청이 잘못 매칭되더라도 로그인 페이지로 리다이렉트되는 것을 원천적으로 차단했습니다.

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    // ...
    @Bean
    @Order(1) // 우선순위 1
    public SecurityFilterChain apiFilterChain(HttpSecurity http) throws Exception {
        http
                .securityMatcher("/api/**")
                .csrf(csrf -> csrf.disable())
                .authorizeHttpRequests(auth -> auth.anyRequest().permitAll()) // ✅ API 요청은 무조건 허용
                .formLogin(form -> form.disable()) // ✅ 로그인 폼 비활성화
                .httpBasic(basic -> basic.disable());
        return http.build();
    }
    // ...
}

최종 결론: 200 OK를 만나다! 🎉

수많은 오류와 디버깅 끝에 마침내 200 OK 응답을 받았습니다. 이 경험을 통해 스프링 시큐리티 디버깅의 핵심 원칙을 깨달았습니다.

• 302 Found 오류는 단순한 리다이렉트 문제가 아니라, 내부 로직의 충돌이나 예외가 겉으로 드러난 현상일 수 있습니다.
• API와 웹 애플리케이션을 함께 개발할 때는 반드시 SecurityFilterChain을 분리하고 @Order를 사용해 우선순위를 명확히 해야 합니다.
• API용 필터 체인은 formLogin, httpBasic 등 인증 필터를 명시적으로 비활성화하는 것이 가장 안전합니다.

이 글이 여러분의 302 Found 디버깅에 큰 도움이 되기를 바랍니다.

JDBC 기본 구성 요소 및 문법

JDBC를 사용하여 SQL 쿼리를 실행하려면 다음과 같은 단계를 거칩니다.

1. JDBC 드라이버 로드
2. 데이터베이스 연결 설정
3. Statement 또는 PreparedStatement 객체 생성
4. SQL 쿼리 실행
5. 결과 처리 (SELECT 문인 경우)
6. 자원 해제 (Connection, Statement, ResultSet 닫기)

1. JDBC 드라이버 로드 (Class.forName())

데이터베이스와 통신하려면 해당 데이터베이스 벤더가 제공하는 JDBC 드라이버를 JVM에 로드해야 합니다.

try {
    Class.forName("com.mysql.cj.jdbc.Driver"); // MySQL 드라이버
    // Class.forName("oracle.jdbc.driver.OracleDriver"); // Oracle 드라이버
    // Class.forName("org.postgresql.Driver"); // PostgreSQL 드라이버
    System.out.println("JDBC 드라이버 로드 성공!");
} catch (ClassNotFoundException e) {
    System.err.println("JDBC 드라이버를 찾을 수 없습니다: " + e.getMessage());
    e.printStackTrace();
}

• 설명: Class.forName() 메소드를 사용하여 드라이버 클래스를 메모리에 로드합니다. 이렇게 하면 드라이버가 스스로 등록됩니다. (JDBC 4.0 이상에서는 이 단계가 필수는 아니지만, 명시적으로 로드하는 것이 명확합니다.)

2. 데이터베이스 연결 설정 (DriverManager.getConnection())

로드된 드라이버를 사용하여 특정 데이터베이스에 연결합니다.

String url = "jdbc:mysql://localhost:3306/userdb?useSSL=false&serverTimezone=UTC"; // JDBC URL
String user = "root"; // 데이터베이스 사용자 이름
String password = "1234"; // 데이터베이스 비밀번호

Connection conn = null; // Connection 객체 선언

try {
    conn = DriverManager.getConnection(url, user, password);
    System.out.println("데이터베이스 연결 성공!");
} catch (SQLException e) {
    System.err.println("데이터베이스 연결 실패: " + e.getMessage());
    e.printStackTrace();
}

• url (JDBC URL): 연결할 데이터베이스의 위치와 속성을 지정합니다. jdbc:mysql:// 부분은 MySQL 드라이버를 사용한다는 의미이고, localhost:3306은 데이터베이스 서버의 주소와 포트, /userdb는 데이터베이스 이름입니다. ? 이후는 추가 옵션입니다.
• user, password: 데이터베이스 접속에 필요한 사용자 이름과 비밀번호입니다.
• Connection 객체: 데이터베이스 세션을 나타냅니다. 모든 SQL 작업은 이 연결을 통해 이루어집니다.

3. Statement 또는 PreparedStatement 객체 생성

SQL 쿼리를 실행하기 위한 객체를 생성합니다.

• Statement (정적 SQL 쿼리용):

    Statement stmt = null;
    try {
        stmt = conn.createStatement();
        System.out.println("Statement 객체 생성 성공!");
    } catch (SQLException e) {
        e.printStackTrace();
    }

  • 용도: SQL 쿼리 문자열이 실행 시점에 변하지 않는 (매개변수가 없는) 간단한 쿼리에 사용됩니다.
  • 단점: SQL 인젝션 공격에 취약할 수 있으며, 반복 실행 시 성능 저하가 발생할 수 있습니다.

• PreparedStatement (매개변수 있는 동적 SQL 쿼리용 - 권장):

    String sqlInsert = "INSERT INTO users (name, email) VALUES (?, ?)"; // '?' 자리표시자
    PreparedStatement pstmt = null;
    try {
        pstmt = conn.prepareStatement(sqlInsert);
        System.out.println("PreparedStatement 객체 생성 성공!");
    } catch (SQLException e) {
        e.printStackTrace();
    }

  • 용도: SQL 쿼리 문자열에 물음표(?)와 같은 자리표시자가 포함되어 실행 시점에 값을 바인딩해야 하는 쿼리에 사용됩니다. 보안(SQL 인젝션 방지) 및 성능 향상 측면에서 Statement보다 훨씬 권장됩니다.

4. SQL 쿼리 실행

생성된 Statement 또는 PreparedStatement 객체를 사용하여 SQL 쿼리를 실행합니다.

• INSERT, UPDATE, DELETE (데이터 변경): Statement 사용 시:

    String sqlUpdate = "UPDATE users SET email = 'new_email@example.com' WHERE name = 'Alice'";
    try {
        int rowsAffected = stmt.executeUpdate(sqlUpdate);
        System.out.println(rowsAffected + " 개의 행이 업데이트되었습니다.");
    } catch (SQLException e) {
        e.printStackTrace();
    }

  PreparedStatement 사용 시:

    String sqlUpdate = "UPDATE users SET email = ? WHERE name = ?";
    try {
        pstmt = conn.prepareStatement(sqlUpdate);
        pstmt.setString(1, "new_email@example.com"); // 첫 번째 '?'
        pstmt.setString(2, "Alice"); // 두 번째 '?'
        int rowsAffected = pstmt.executeUpdate();
        System.out.println(rowsAffected + " 개의 행이 업데이트되었습니다.");
    } catch (SQLException e) {
        e.printStackTrace();
    }

  • executeUpdate(): INSERT, UPDATE, DELETE와 같이 데이터베이스의 데이터를 변경하는 SQL 쿼리를 실행할 때 사용합니다. 실행된 행의 수를 int 타입으로 반환합니다.

• SELECT (데이터 조회): Statement 사용 시:

    String sqlSelect = "SELECT id, name, email FROM users WHERE id > 10";
    ResultSet rs = null;
    try {
        rs = stmt.executeQuery(sqlSelect);
        // 5. 결과 처리 부분으로 이어짐
    } catch (SQLException e) {
        e.printStackTrace();
    }

  PreparedStatement 사용 시:

    String sqlSelect = "SELECT id, name, email FROM users WHERE id > ?";
    ResultSet rs = null;
    try {
        pstmt = conn.prepareStatement(sqlSelect);
        pstmt.setInt(1, 10); // 첫 번째 '?'
        rs = pstmt.executeQuery();
        // 5. 결과 처리 부분으로 이어짐
    } catch (SQLException e) {
        e.printStackTrace();
    }

  • executeQuery(): SELECT 쿼리를 실행하여 데이터를 조회할 때 사용합니다. 쿼리 결과를 ResultSet 객체로 반환합니다.

5. 결과 처리 (ResultSet - SELECT 문인 경우)

SELECT 쿼리의 결과를 ResultSet 객체로부터 읽어들입니다.

// 위에서 얻은 ResultSet rs 객체를 사용
if (rs != null) { // rs가 null이 아닌지 확인 (쿼리 실패 방지)
    try {
        while (rs.next()) { // 다음 행이 존재하는 동안 반복
            int id = rs.getInt("id"); // "id" 컬럼의 정수 값 가져오기
            String name = rs.getString("name"); // "name" 컬럼의 문자열 값 가져오기
            String email = rs.getString("email"); // "email" 컬럼의 문자열 값 가져오기

            // 컬럼 인덱스로도 가져올 수 있습니다. (성능은 약간 좋지만 가독성은 떨어짐)
            // int id = rs.getInt(1); // 첫 번째 컬럼
            // String name = rs.getString(2); // 두 번째 컬럼

            System.out.printf("ID: %d, 이름: %s, 이메일: %s\n", id, name, email);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

• rs.next(): ResultSet의 커서를 다음 행으로 이동시키고, 다음 행이 존재하면 true, 없으면 false를 반환합니다. while 루프와 함께 사용하여 모든 행을 순회합니다.
• rs.get데이터타입("컬럼이름") 또는 rs.get데이터타입(컬럼인덱스): 현재 커서가 가리키는 행에서 지정된 컬럼의 값을 Java 타입으로 가져옵니다.

6. 자원 해제 (Connection, Statement, ResultSet 닫기)

데이터베이스 자원은 사용 후 반드시 닫아주어 누수를 방지해야 합니다. try-with-resources 문을 사용하는 것이 가장 권장되는 방법입니다.

// try-with-resources 사용 (Java 7 이상)
// 괄호 안에 선언된 자원들은 블록이 끝나면 자동으로 close() 메소드가 호출됩니다.
try (Connection conn = DriverManager.getConnection(url, user, password);
     Statement stmt = conn.createStatement(); // 또는 PreparedStatement
     ResultSet rs = stmt.executeQuery("SELECT * FROM users")) { // SELECT 쿼리인 경우

    // SQL 쿼리 실행 및 결과 처리 코드

} catch (SQLException e) {
    System.err.println("SQL 에러 발생: " + e.getMessage());
    e.printStackTrace();
} catch (ClassNotFoundException e) { // Class.forName() 에서 발생 가능
    System.err.println("드라이버 로드 에러: " + e.getMessage());
    e.printStackTrace();
}

• try-with-resources: AutoCloseable 인터페이스를 구현하는 객체(여기서는 Connection, Statement, ResultSet)를 try 문 괄호 안에 선언하면, try 블록이 정상적으로 종료되거나 예외가 발생하더라도 해당 객체들의 close() 메소드가 자동으로 호출됩니다. 이 방법이 자원 관리의 가장 안전하고 효율적인 방법입니다.

전체 예시 코드 (SELECT 문):

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement; // 또는 java.sql.Statement
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcSelectExample {

    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/userdb?useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "1234";

        // try-with-resources를 사용하여 자원 자동 해제
        try (Connection conn = DriverManager.getConnection(url, user, password);
             // PreparedStatement 사용 예시 (더 권장)
             PreparedStatement pstmt = conn.prepareStatement("SELECT id, name, email FROM users WHERE id > ?")) {

            // 드라이버 로드는 JDBC 4.0+ 에서는 필수가 아니지만, 명시적으로 넣어줄 수 있습니다.
            // Class.forName("com.mysql.cj.jdbc.Driver"); 

            System.out.println("데이터베이스 연결 성공!");

            // PreparedStatement에 값 바인딩
            pstmt.setInt(1, 0); // id가 0보다 큰 모든 사용자 (WHERE id > 0)

            // 쿼리 실행 및 결과 받기
            ResultSet rs = pstmt.executeQuery();

            System.out.println("📝 저장된 사용자 목록:");
            // ResultSet에서 데이터 한 행씩 읽기
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                System.out.printf("👉 [%d] %s / %s\n", id, name, email);
            }

        } catch (SQLException e) {
            System.err.println("SQL 에러 발생: " + e.getMessage());
            e.printStackTrace();
        } 
        // ClassNotFoundException은 DriverManager.getConnection() 호출시 드라이버 로드가
        // 실패했을 때 발생할 수 있지만, 요즘은 대부분의 경우 자동으로 로드되므로 생략하기도 합니다.
        // 하지만 Class.forName()을 명시적으로 사용한다면 필요합니다.
        /* catch (ClassNotFoundException e) {
            System.err.println("JDBC 드라이버를 찾을 수 없습니다: " + e.getMessage());
            e.printStackTrace();
        }*/
    }
}

이것이 SQL과 관련된 Java (JDBC) 코드의 기본적인 문법과 흐름입니다. 실제 프로젝트에서는 Connection Pool, ORM (JPA/Hibernate, MyBatis) 등을 사용하여 JDBC 코드를 직접 작성하는 것을 최소화하기도 하지만, JDBC의 기본 원리를 이해하는 것은 매우 중요합니다.

🔁 1. Single Source of Truth (단일 상태 저장소)

Redux는 애플리케이션의 모든 상태를 하나의 객체 트리로 만들고, 이를 하나의 store에 저장합니다. 즉, 상태는 중앙 집중식으로 관리됩니다.

const store = createStore(reducer);

🔄 2. State는 읽기 전용 (Read-Only)

Redux에서는 상태(state)를 직접 수정하지 않습니다. 오직 action을 통해서만 상태를 변경할 수 있으며, 실제 변경은 reducer에서 처리합니다.

🧬 3. 상태는 순수 함수인 reducer를 통해 변경된다

reducer는 이전 상태와 action을 입력받아 새로운 상태를 반환하는 순수 함수입니다.

function reducer(state, action) {
  switch(action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    default:
      return state;
  }
}

🧩 Redux 용어 정리

1. 📦 Store

• Redux의 중앙 상태 저장소입니다.
• createStore()로 생성하며, 현재 상태(state), reducer, dispatch 기능을 포함합니다.

2. ⚡ Action

• 상태 변경을 요청하는 일반 자바스크립트 객체입니다.
• 필수 속성: type (변경의 종류를 나타냄)
• 선택 속성: payload (데이터 전달용)

const incrementAction = {
  type: 'INCREMENT',
  payload: 1 // 선택적
};

3. 🖱️ Event

• 일반적으로 사용자의 입력(클릭, 키보드 입력 등) 또는 네트워크 응답 등을 의미합니다.
• Redux 자체 용어는 아니며, 보통 이벤트가 발생하면 그에 따라 action을 생성합니다.

// 버튼 클릭 이벤트 → 액션 생성 → 디스패치
<button onClick={() => dispatch({ type: 'INCREMENT' })}>+</button>

4. 📤 Dispatch

• store.dispatch(action) 형태로 사용.
• 특정 액션을 스토어에 전달해서 상태 업데이트를 트리거합니다.

dispatch({ type: 'INCREMENT' });

• 디스패치된 액션은 reducer로 전달되어 상태를 변경하게 됩니다.

5. 🔄 Reducer

• 액션을 받아서, 이전 상태를 기반으로 새로운 상태 객체를 반환하는 순수 함수.

const initialState = { count: 0 };

function counterReducer(state = initialState, action) {
  switch(action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      return state;
  }
}

6. 🛠️ Middleware (선택 사항)

• 액션이 리듀서에 도달하기 전에 가로채서 작업을 수행할 수 있는 중간 단계입니다.
• 예: redux-thunk, redux-saga (비동기 처리에 자주 사용)

🔁 Redux 데이터 흐름 정리 (One-way data flow)

1. Event 발생 (예: 버튼 클릭)
2. → Action 생성
3. → Dispatch로 액션 전달
4. → Reducer가 상태를 변경
5. → Store의 새로운 상태가 컴포넌트에 반영됨

🔍 예제 (카운터)

// 1. 액션 생성자
const increment = () => ({ type: 'INCREMENT' });

// 2. 리듀서
function counter(state = { count: 0 }, action) {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    default:
      return state;
  }
}

// 3. 스토어 생성
const store = createStore(counter);

// 4. 디스패치 (예: 버튼 클릭 시)
store.dispatch(increment());

📝 정리

🌟 React 상태 관리 완벽 가이드

리액트(React)는 컴포넌트 기반 UI 라이브러리로, 컴포넌트 내부 상태(state)를 다루는 기능(useState, useReducer 등)을 기본 제공합니다. 하지만 애플리케이션 규모가 커질수록, 컴포넌트 간 데이터를 효율적으로 공유하고 복잡도를 관리하기 위해 별도의 상태 관리 라이브러리를 도입하는 것이 일반적입니다.
이 글에서는 상태 관리의 기초 개념부터 언제, 왜, 어떻게 라이브러리를 쓰는지, 주요 원리와 종류, 마지막으로 Redux를 활용한 실전 예제까지 하나씩 살펴보겠습니다.

목차

1. 상태(state)란 무엇인가?
2. 상태 관리가 필요한 이유 & 언제 사용하는가?
3. 상태 관리 라이브러리를 왜 사용하는가?
4. 주요 상태 관리 라이브러리 종류 비교
5. 상태 관리의 기본 원리
6. Redux 심화: 구조와 사용법
   • 6.1. 단방향 데이터 흐름(Flux 아키텍처)
   • 6.2. store: 중앙 저장소
   • 6.3. slice/reducer: 상태 모듈화
   • 6.4. Provider: React와 연결
   • 6.5. Hooks(useSelector, useDispatch)
   • 6.6. 비동기 처리(createAsyncThunk)
7. 마무리 및 추천 학습 자료

1️⃣ 상태(state)란 무엇인가?

• 정의: 컴포넌트 내부에서 변할 수 있는 데이터, 즉 UI와 로직을 연결하는 값
• 예시

  const [count, setCount] = useState(0);
  const [text, setText] = useState("");

  • 버튼 클릭 시 숫자(count)가 오르내리고
  • 사용자 입력(input) 값을 관리

2️⃣ 상태 관리가 필요한 이유 & 언제 사용하는가?

1. 컴포넌트 간 데이터 공유가 필요할 때

   • 로그인 상태, 장바구니 아이템, 테마 설정 등
   • props로 매번 전달하면 깊이가 깊어질수록 코드 복잡도↑ (prop drilling 문제)

2. 전역 또는 공통으로 사용되어야 할 데이터가 있을 때

   • 사이트 전체에서 사용하는 유저 정보, 알림 토큰, 다크 모드, 언어 설정 등

3. 복잡한 상태 로직을 모듈화/테스트하기 위해

   • 단순 useState만으로는 액션 흐름을 추적하기 어려움
   • 상태 업데이트 로직을 분리해 유지보수성↑

4. 비동기 작업 관리

   • 서버 API 호출, 로딩/에러 상태 관리
   • 복잡한 비동기 로직을 체계적으로 다루고 싶을 때

3️⃣ 상태 관리 라이브러리를 왜 사용하는가?

• 규모 확장성: 프로젝트가 커질수록 상태와 액션이 늘어나고, 이를 통합 관리하는 구조가 필요
• 예측 가능성: 상태 변경이 모두 “액션 → 리듀서” 흐름을 거치므로, 로그나 디버깅이 쉬움
• 공동 작업 편의: 팀원 간 역할 분리(프론트엔드 작업, 상태 로직 작성 등)가 수월
• 클린 아키텍처: UI, 로직, 데이터 계층을 명확히 분리

4️⃣ 주요 상태 관리 라이브러리 종류 비교

5️⃣ 상태 관리의 기본 원리

1. 단방향 데이터 흐름
   • UI → Action → Reducer → New State → UI
2. 불변성(Immutable State)
   • 상태 객체를 직접 수정하지 않고, 항상 새 복사본을 반환
3. 순수 함수로서의 리듀서
   • 같은 입력(state, action)이면 항상 같은 출력 반환
4. 모듈화
   • 기능별로 slice/reducer 분리 → 유지보수 용이

6️⃣ Redux 심화: 구조와 사용법

6.1 단방향 데이터 흐름 (Flux 아키텍처)

UI ──▶ Action ──▶ Reducer ──▶ Store ──▶ UI

• Action: 상태 변경 의도를 나타내는 객체
• Reducer: action에 따라 state를 반환하는 순수 함수
• Store: 애플리케이션 전체 상태를 보관하는 중앙 저장소

6.2 store: 중앙 저장소

// src/app/store.js
import { configureStore } from '@reduxjs/toolkit';
import counterReducer from '../features/counter/counterSlice';

export const store = configureStore({
  reducer: {
    counter: counterReducer,
    // user: userReducer,
    // todo: todoReducer,
  },
});

• 왜? 모든 상태를 한 곳에 모아두면, 어디서나 일관되게 꺼내 쓰고, 변경 이력을 추적할 수 있음

6.3 slice/reducer: 상태 조각 모듈화

// src/features/counter/counterSlice.js
import { createSlice } from '@reduxjs/toolkit';

const initialState = { value: 0 };

const counterSlice = createSlice({
  name: 'counter',
  initialState,
  reducers: {
    increment: (state) => { state.value += 1; },  // Immer 덕분에 직접 수정처럼 보이지만, 불변성 유지
    decrement: (state) => { state.value -= 1; },
    incrementByAmount: (state, action) => { state.value += action.payload; },
  },
});

export const { increment, decrement, incrementByAmount } = counterSlice.actions;
export default counterSlice.reducer;

• 왜? 액션 생성자와 리듀서를 한 곳에 묶어 가독성과 유지보수성을 높임

6.4 Provider: React와 Redux 연결

// src/index.js
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
import { Provider } from 'react-redux';
import { store } from './app/store';

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <Provider store={store}>
    <App />
  </Provider>
);

• 왜? React 트리 전체에 store를 “주입”하여, 하위 컴포넌트 어디서든 접근 가능하게 함

6.5 Hooks: useSelector & useDispatch

• useSelector: store에서 원하는 상태를 추출

  const count = useSelector((state) => state.counter.value);

• useDispatch: 액션을 디스패치(dispatch)하여 상태 변경

  const dispatch = useDispatch();
  dispatch(increment());
  dispatch(incrementByAmount(5));

6.6 비동기 처리: createAsyncThunk

// features/todo/todoSlice.js
import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';

export const fetchTodos = createAsyncThunk(
  'todos/fetchTodos',
  async () => {
    const res = await fetch('/api/todos');
    return res.json();
  }
);

const todoSlice = createSlice({
  name: 'todos',
  initialState: { items: [], status: 'idle', error: null },
  reducers: { /* 동기 액션 */ },
  extraReducers: (builder) => {
    builder
      .addCase(fetchTodos.pending, (state) => { state.status = 'loading'; })
      .addCase(fetchTodos.fulfilled, (state, action) => {
        state.status = 'succeeded';
        state.items = action.payload;
      })
      .addCase(fetchTodos.rejected, (state, action) => {
        state.status = 'failed';
        state.error = action.error.message;
      });
  },
});
export default todoSlice.reducer;

• 왜? API 호출 로직과 상태(loading, success, error)를 간결하게 관리

7️⃣ 마무리 및 추천 학습 자료

• 공식 문서
  • Redux Toolkit: https://redux-toolkit.js.org/
  • React Redux: https://react-redux.js.org/
• 튜토리얼
  • Redux Essentials: https://redux.js.org/tutorials/essentials/part-1-overview-concepts
• 다른 라이브러리 탐색
  • Zustand: https://github.com/pmndrs/zustand
  • Recoil: https://recoiljs.org/

1. Request 객체

HttpServletRequest 객체는 클라이언트가 보낸 데이터를 서버에서 처리하기 위한 정보를 제공합니다. 주로 사용자의 입력 데이터를 처리하는 데 사용됩니다.

예제 1: 사용자 데이터를 서버로 전송

form.html 코드

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <form action="mSignUp.jsp" method="get">
        name: <input type="text" name="m_name"><br> 
        password: <input type="password" name="m_pass"><br> 
        hobby: 
        sport <input type="checkbox" name="m_hobby" value="sport"> 
        cooking <input type="checkbox" name="m_hobby" value="cooking"> 
        travel <input type="checkbox" name="m_hobby" value="travel"><br> 
        <input type="submit" value="sign up">
    </form>
</body>
</html>

설명

• <form> 태그:
  • action="mSignUp.jsp": 데이터를 처리할 JSP 페이지를 지정.
  • method="get": GET 방식으로 데이터를 전송.
• 사용자가 입력한 데이터를 mSignUp.jsp 페이지로 전송합니다.

  결과

  

mSignUp.jsp 코드

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <%!String m_name;
    String m_pass;
    String[] m_hobby;%>

    <%
    // request 객체를 이용해 form 데이터 가져오기
    m_name = request.getParameter("m_name"); // 단일 값
    m_pass = request.getParameter("m_pass"); // 단일 값
    m_hobby = request.getParameterValues("m_hobby"); // 다중 값
    %>

    <p>m_name: <%= m_name %></p>
    <p>m_pass: <%= m_pass %></p>
    <p>m_hobby:</p>
    <ul>
    <%
        for (int i = 0; i < m_hobby.length; i++) {
    %>
        <li><%= m_hobby[i] %></li>
    <%
        }
    %>
    </ul>
</body>
</html>

설명

• request.getParameter(String name)
  • 클라이언트가 전송한 단일 값을 가져옵니다. (name, password 등)
• request.getParameterValues(String name)
  • 다중 선택 항목(예: 체크박스) 값을 배열로 가져옵니다.
• 입력된 데이터는 화면에 출력되며, m_name, m_pass, m_hobby 변수에 저장됩니다.

  결과

  

2. Response 객체

HttpServletResponse 객체는 서버에서 클라이언트로 데이터를 전송하거나 다른 페이지로 리다이렉트할 때 사용됩니다.

예제 2: 페이지 리다이렉트

firstPage.jsp 코드

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <p>First Page!!</p>
    <%
        // response 객체를 사용하여 페이지 리다이렉트
        response.sendRedirect("secondPage.jsp");
    %>
</body>
</html>

설명

• response.sendRedirect(String location)
  • 클라이언트를 지정된 URL로 리다이렉트합니다.
  • secondPage.jsp로 페이지 이동이 이루어지며, 클라이언트는 해당 URL로 새로운 요청을 보내게 됩니다.

secondPage.jsp 코드

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
    <p>Second Page!!</p>
</body>
</html>

설명

• 리다이렉트된 페이지에서는 클라이언트가 새로운 요청을 받습니다.
• 첫 번째 페이지에서 처리된 정보는 사라지며, 두 번째 페이지가 새롭게 로드됩니다.

  결과

  

Request와 Response 객체의 주요 메서드

Request 객체

1. getParameter(String name)

   • 단일 값 가져오기.
   • 예: request.getParameter("m_name");

2. getParameterValues(String name)

   • 다중 값 가져오기.
   • 예: request.getParameterValues("m_hobby");

3. getAttribute(String name)

   • 서버 내에서 속성을 가져옵니다.

Response 객체

1. sendRedirect(String location)

   • 지정된 URL로 클라이언트를 리다이렉트.
   • 예: response.sendRedirect("secondPage.jsp");

2. setContentType(String type)

   • 응답 데이터의 MIME 유형을 설정.
   • 예: response.setContentType("text/html");

3. getWriter()

   • 출력 스트림을 반환하여 클라이언트에 데이터를 보냅니다.

결론

HttpServletRequest와 HttpServletResponse는 웹 애플리케이션에서 클라이언트와 서버 간의 데이터 흐름을 처리하는 데 필수적인 객체입니다.

• Request 객체는 클라이언트 데이터를 서버로 전달하며, 폼 입력 처리, 데이터 검증 등에 사용됩니다.
• Response 객체는 서버의 처리 결과를 클라이언트로 전달하거나 다른 페이지로 리다이렉트할 때 사용됩니다.

이 두 객체를 잘 활용하면 클라이언트-서버 간의 효율적인 데이터 처리가 가능합니다.

JSP와 Servlet의 차이

• Servlet: Java 코드로만 이루어져 있으며, .java 파일로 작성된 후 .class 파일로 컴파일됩니다.

  • 예: MyServlet.java -> MyServlet.class

• JSP: HTML 문서 안에 Java 코드를 포함하는 형태로, JSP 파일은 서버에서 처리되며 최종적으로 Servlet으로 변환됩니다.

  • 예: example.jsp -> example_jsp.java -> example_jsp.class

이 변환 과정 덕분에 JSP는 Java의 동적 처리 능력과 HTML의 간단한 문서 작성 능력을 결합합니다.

JSP 주요 스크립트 태그

JSP 스크립트 태그는 HTML 문서 내에서 Java 코드를 삽입하거나 실행하기 위해 사용됩니다. 주요 태그는 다음과 같습니다:

1. 선언 태그 (<%! ... %>):

• 용도: JSP 페이지에서 Java 멤버 변수나 메서드를 선언합니다.
• 특징: 선언된 변수와 메서드는 JSP 파일이 서블릿으로 변환된 후 클래스의 멤버로 정의됩니다.

<%!
    int num = 10;
    String str = "jsp";
    ArrayList<String> list = new ArrayList<String>();

    public void jspMethod() {
        System.out.println("--jspMethod()--");
    }
%>

2. 주석 태그 (<%-- ... --%>):

• 용도: JSP에서 주석을 작성합니다.
• 특징: 주석 내용은 JSP가 서블릿으로 변환될 때 제외되므로 클라이언트에게 전송되지 않습니다.

<%-- This is a JSP comment. It will not appear in the client-side HTML. --%>

3. 스크립트릿 태그 (<% ... %>):

• 용도: JSP 페이지 내에서 Java 코드를 삽입하고 실행합니다.
• 특징: HTML과 Java 코드를 혼합하여 동적 로직을 처리할 수 있습니다.

<%
    if (num > 0) {
%>
<p>num is greater than 0</p>
<%
    } else {
%>
<p>num is less than or equal to 0</p>
<%
    }
%>

4. 표현식 태그 (<%= ... %>):

• 용도: Java 변수나 메서드의 반환값을 출력합니다.
• 특징: 태그 내부의 코드는 자동으로 out.print() 메서드로 처리됩니다.

<p>num is <%= num %></p>

5. 지시어 (<%@ ... %>):

• 용도: JSP 페이지의 설정 및 외부 파일 또는 라이브러리 포함 등을 정의합니다.
• 주요 지시어:
  1. page 지시어: JSP 페이지의 전역 설정을 정의합니다.

     <%@ page language="java" contentType="text/html; charset=UTF-8" %>

  2. include 지시어: 다른 JSP 파일을 포함합니다.

     <%@ include file="header.jsp" %>

  3. taglib 지시어: 커스텀 태그 라이브러리를 사용할 수 있도록 정의합니다.

     <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

JSP 예제 코드

다음은 위에서 설명한 주요 태그를 활용한 JSP 예제입니다.

<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSP Example</title>
</head>
<body>

<%@include file="header.jsp" %>

<!-- 선언태그 -->
<%!
    int num = 10;
    String str = "jsp";
    ArrayList<String> list = new ArrayList<String>();

    public void jspMethod() {
        System.out.println("--jspMethod()--");
    }
%>

<!-- 주석태그 -->
<%-- This is a JSP comment. It will not appear in the client-side HTML. --%>

<!-- 스크립트릿 태그 -->
<%
    if (num > 0) {
%>
<p>num is greater than 0</p>
<%
    } else {
%>
<p>num is less than or equal to 0</p>
<%
    }
%>

<!-- 표현식 태그 -->
<p>num is <%= num %></p>

<%@include file="footer.jsp" %>

</body>
</html>

Java 코드가 브라우저에 표시되지 않는 이유

JSP 파일은 서버에서 처리되며, HTML은 클라이언트(브라우저)로 전송됩니다. Java 코드는 서버에서 실행된 후 결과만 HTML로 변환되기 때문에 클라이언트는 실행된 결과만 확인할 수 있습니다.

• 변환 과정:
  1. example.jsp → example_jsp.java: JSP 파일이 Servlet으로 변환.
  2. example_jsp.java → example_jsp.class: Servlet 클래스가 컴파일.
  3. example_jsp.class: 서버에서 실행되고, 결과 HTML이 클라이언트로 전송.

추가적으로 알아두면 좋은 사항

1. JSP의 장점:

   • HTML과 Java의 자연스러운 통합.
   • 빠른 프로토타이핑이 가능.
   • Java의 강력한 기능 활용.

2. JSP의 단점:

   • 복잡한 비즈니스 로직 포함 시 가독성 저하.
   • MVC 패턴에서 View에 해당하며, 비즈니스 로직은 별도의 Servlet 또는 Java 클래스에서 처리하는 것이 바람직.

3. JSP와 MVC 패턴:

   • JSP는 View 역할로 사용되고, Servlet은 Controller 역할을 담당합니다. 이를 통해 코드의 재사용성과 유지보수를 높일 수 있습니다.

결론

JSP 스크립트는 동적인 웹 애플리케이션 개발에서 HTML과 Java를 유연하게 결합할 수 있는 강력한 도구입니다. 선언 태그, 주석 태그, 스크립트릿 태그, 표현식 태그, 지시어 등을 적절히 활용하면 동적이고 효율적인 웹페이지를 쉽게 구현할 수 있습니다.

웹 애플리케이션에서 사용자의 Form 데이터를 처리하는 것은 매우 중요한 작업입니다. 이번 글에서는 Form 데이터를 처리하는 Servlet의 활용 방법과 doGet() 및 doPost() 메서드의 차이를 학습한 내용을 바탕으로 설명하겠습니다.

Form 데이터 처리의 기본 흐름

1. 사용자가 Form을 제출하면 브라우저는 데이터를 HTTP 요청(Request)으로 웹 컨테이너(Servlet)로 전송합니다.
2. Servlet에서 HttpServletRequest 객체를 통해 데이터를 수신하고 처리합니다.
3. 응답은 HttpServletResponse 객체를 통해 브라우저로 전달됩니다.

GET과 POST의 차이점

HTML Form 코드

아래의 Form 코드는 사용자 정보를 입력받아 POST 방식으로 Servlet에 데이터를 전송합니다.

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Form Example</title>
</head>
<body>

    <form action="mSignUp" method="post">
        Name: <input type="text" name="m_name"><br>
        Password: <input type="password" name="m_pass"><br>
        Gender: 
        <input type="radio" name="m_gender" value="M" checked> Man
        <input type="radio" name="m_gender" value="W"> Woman<br>
        Hobby: 
        <input type="checkbox" name="m_hobby" value="sport"> Sport
        <input type="checkbox" name="m_hobby" value="cooking"> Cooking
        <input type="checkbox" name="m_hobby" value="reading"> Reading
        <input type="checkbox" name="m_hobby" value="travel"> Travel<br>
        Residence: 
        <select name="m_residence">
            <option value="seoul" selected>Seoul</option>
            <option value="jeju">Jeju</option>
            <option value="busan">Busan</option>
        </select><br>
        <input type="submit" value="Sign Up">
    </form>

</body>
</html>

Servlet 코드: MemSignUp.java

핵심 기능

• GET 요청 처리: doGet() 메서드를 통해 데이터를 URL 쿼리에서 읽어옵니다.
• POST 요청 처리: doPost() 메서드는 doGet()을 호출하여 동일한 방식으로 데이터를 처리합니다.
• Form 데이터 추출: request.getParameter(), request.getParameterValues(), request.getParameterNames()를 사용합니다.

Servlet 코드 설명

@WebServlet("/mSignUp")
public class MemSignUp extends HttpServlet {

    // GET 요청 처리
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(" -- doGet() -- ");

        // Form 데이터 수신
        String m_name = request.getParameter("m_name");
        String m_pass = request.getParameter("m_pass");
        String m_gender = request.getParameter("m_gender");
        String[] m_hobbys = request.getParameterValues("m_hobby");
        String m_residence = request.getParameter("m_residence");

        // 데이터 출력
        System.out.println("Name: " + m_name);
        System.out.println("Password: " + m_pass);
        System.out.println("Gender: " + m_gender);
        System.out.println("Hobbies: " + Arrays.toString(m_hobbys));
        System.out.println("Residence: " + m_residence);

        // 모든 파라미터 이름 출력
        Enumeration<String> names = request.getParameterNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            System.out.println("Parameter Name: " + name);
        }
    }

    // POST 요청 처리
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(" -- doPost() -- ");
        // POST 요청도 GET 방식으로 처리
        doGet(request, response);
    }
}

주요 메서드 설명

1. request.getParameter(String name)

   • 단일 값 데이터를 반환합니다.
   • 예: request.getParameter("m_name") → 사용자의 이름 반환.

2. request.getParameterValues(String name)

   • 다중 값 데이터를 배열로 반환합니다.
   • 예: request.getParameterValues("m_hobby") → 선택한 취미 반환.

3. request.getParameterNames()

   • 모든 요청 파라미터 이름을 Enumeration으로 반환합니다.
   • 예: 모든 Form 필드 이름을 순회하며 출력.

4. response.getWriter()

   • 응답으로 데이터를 출력하는 스트림을 반환합니다.
   • 예: response.getWriter().println("Hello User!").

실행 결과

GET 요청

• URL:

  http://localhost:8090/mSignUp?m_name=John&m_pass=1234&m_gender=M&m_hobby=sport&m_hobby=reading&m_residence=seoul

• Console 출력:

  -- doGet() --
  Name: John
  Password: 1234
  Gender: M
  Hobbies: [sport, reading]
  Residence: seoul
  Parameter Name: m_name
  Parameter Name: m_pass
  Parameter Name: m_gender
  Parameter Name: m_hobby
  Parameter Name: m_residence

POST 요청

• URL:

  http://localhost:8090/mSignUp

• Console 출력: 위와 동일 (Form 데이터는 요청 본문에 포함).

결론

• GET과 POST 요청은 각각 목적에 맞게 사용해야 합니다.
• GET: 데이터 조회용으로 사용하며, 데이터가 URL에 노출됩니다.
• POST: 민감한 데이터 전송이나 데이터 수정/생성에 적합합니다.
• Form 데이터를 Servlet에서 처리하려면 HttpServletRequest의 다양한 메서드를 활용하면 됩니다.

Servlet은 클라이언트의 요청을 처리하고 서버에서 동적 콘텐츠를 생성하는 Java 기반의 기술입니다. 이번 글에서는 Servlet이 동작하는 생명 주기(Life Cycle)를 단계별로 살펴보고, 각 단계에서 호출되는 메서드의 역할과 중요성을 이해하겠습니다.

Servlet Life Cycle의 주요 단계

Servlet의 생명 주기는 Servlet 컨테이너에 의해 관리되며, 아래와 같은 단계를 거칩니다:

1. 객체 생성: Servlet 인스턴스가 메모리에 로드됩니다.
2. 초기화(init): 초기 설정을 수행합니다.
3. 요청 처리(service): 클라이언트의 요청을 처리하고 응답을 반환합니다.
4. 종료(destroy): 자원을 정리하고 Servlet을 메모리에서 해제합니다.

Servlet Life Cycle의 실행 흐름

1. Servlet 객체 생성 전후: @PostConstruct

@PostConstruct는 Servlet 객체가 생성된 후, init() 메서드가 호출되기 전에 실행됩니다. 이 어노테이션은 초기화 작업이 필요한 경우에 유용합니다.

@PostConstruct
public void postConstruct() {
    System.out.println(" -- postConstruct() --");
}

주요 포인트

• Servlet 생성 이후 바로 실행됩니다.
• 초기화 메서드(init()) 호출 전에 사용자 정의 작업을 수행할 수 있습니다.

2. 초기화: init()

init() 메서드는 Servlet이 처음 초기화될 때 한 번 호출됩니다. 주로 설정 파일 읽기, 리소스 초기화 등의 작업을 수행합니다.

@Override
public void init() throws ServletException {
    System.out.println(" -- init() --");
}

주요 포인트

• Servlet이 처음 로드될 때 호출됩니다.
• init() 메서드는 초기화 실패 시 예외를 던질 수 있습니다.

3. 요청 처리: service()와 doGet()/doPost()

service() 메서드는 클라이언트의 HTTP 요청을 처리하며, 요청 방식(GET, POST 등)에 따라 doGet() 또는 doPost() 메서드를 호출합니다.

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    System.out.println(" -- doGet() --");
}

주요 포인트

• service()는 HTTP 요청을 분류하며, 기본적으로 재정의하지 않습니다.
• doGet()은 GET 요청, doPost()는 POST 요청을 처리합니다.

4. 종료 전후: @PreDestroy

@PreDestroy는 Servlet이 제거되기 전에 호출됩니다. 주로 종료 작업을 수행하는 데 사용됩니다.

@PreDestroy
public void preDestroy() {
    System.out.println(" -- preDestroy() --");
}

주요 포인트

• destroy() 메서드 호출 전 실행됩니다.
• 외부 리소스 정리 또는 로그 저장 등에 활용됩니다.

5. 종료: destroy()

destroy() 메서드는 Servlet이 메모리에서 해제될 때 호출됩니다. 종료 작업을 수행합니다.

@Override
public void destroy() {
    System.out.println(" -- destroy() --");
}

주요 포인트

• 메모리 누수를 방지하기 위해 리소스를 해제합니다.
• 주로 데이터베이스 연결 해제, 파일 스트림 닫기 등을 수행합니다.

Servlet Life Cycle 코드 예제

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class LifeCycleServlet extends HttpServlet {

    @PostConstruct
    public void postConstruct() {
        System.out.println(" -- postConstruct() -- ");
    }

    @Override
    public void init() throws ServletException {
        System.out.println(" -- init() -- ");
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        System.out.println(" -- doGet() -- ");
        response.getWriter().println("Hello from doGet()");
    }

    @Override
    public void destroy() {
        System.out.println(" -- destroy() -- ");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println(" -- preDestroy() -- ");
    }
}

Servlet Life Cycle의 흐름 정리

1. 객체 생성: Servlet 컨테이너가 Servlet 클래스를 메모리에 로드합니다.
2. 초기화: @PostConstruct → init() 실행. 초기 설정 작업 수행.
3. 요청 처리: service() → 요청 방식에 따라 doGet() 또는 doPost() 호출.
4. 종료 전후: @PreDestroy → 종료 작업 수행.
5. 종료: destroy() → 리소스 정리 후 Servlet 객체 메모리 해제.

Servlet Life Cycle을 활용하는 팁

1. 리소스 효율 관리

   • init()과 destroy()를 활용해 데이터베이스 연결과 같은 리소스를 효율적으로 관리하세요.

2. 로그 남기기

   • 각 단계에서 로그를 기록하여 Servlet의 동작 흐름을 추적할 수 있습니다.

3. 테스트와 디버깅

   • @PostConstruct와 @PreDestroy를 활용하면 초기화와 종료 작업의 디버깅이 쉬워집니다.

Servlet은 클라이언트의 요청을 처리하고 응답을 생성하는 Java 기반의 서버 측 프로그램입니다. 이 과정에서 HttpServletRequest와 HttpServletResponse는 각각 클라이언트와 서버 간의 데이터 흐름을 담당하며 핵심 역할을 합니다.

HttpServletRequest와 HttpServletResponse의 역할과 사용 시점

1. HttpServletRequest: 클라이언트 요청 처리

HttpServletRequest는 클라이언트가 서버로 보낸 요청 정보를 담고 있으며, 서버에서 이를 활용해 요청을 처리합니다.

사용 시점

• 폼 데이터 처리: 클라이언트가 HTML 폼을 통해 보낸 데이터(예: 로그인 정보, 검색 키워드)를 읽어올 때.
• 헤더 정보 분석: 요청 헤더에서 클라이언트의 정보(예: User-Agent, Accept-Language)를 분석할 때.
• 세션 관리: 현재 사용자의 세션 정보를 가져오거나 새로운 세션을 생성할 때.
• 쿠키 관리: 클라이언트가 보낸 쿠키 정보를 가져와 사용자의 상태를 파악할 때.
• 파일 업로드: 멀티파트 요청에서 파일 데이터를 처리할 때.

예시 코드

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 폼 데이터 읽기
    String username = request.getParameter("username");
    String password = request.getParameter("password");

    // 세션 생성 및 설정
    HttpSession session = request.getSession();
    session.setAttribute("user", username);

    // 응답 처리
    response.getWriter().println("Welcome, " + username);
}

2. HttpServletResponse: 서버 응답 생성

HttpServletResponse는 서버에서 생성한 응답을 클라이언트로 전송하는 데 사용됩니다.

사용 시점

• HTML 출력: 동적으로 생성한 HTML 페이지를 클라이언트에 전달할 때.
• 리다이렉션: 클라이언트를 다른 URL로 이동시킬 때.
• 상태 코드 설정: 응답 상태 코드(예: 200, 404, 500)를 설정할 때.
• 파일 다운로드: 바이너리 데이터를 응답으로 전송해 파일 다운로드를 제공할 때.
• 쿠키 전송: 서버가 클라이언트에 새 쿠키를 설정할 때.

예시 코드

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // 쿠키 설정
    Cookie cookie = new Cookie("sessionId", "12345");
    cookie.setMaxAge(3600); // 1시간 유지
    response.addCookie(cookie);

    // 상태 코드 설정
    response.setStatus(HttpServletResponse.SC_OK);

    // HTML 응답 출력
    response.setContentType("text/html;charset=UTF-8");
    PrintWriter out = response.getWriter();
    out.println("<html><body><h1>Response Example</h1></body></html>");
}

HttpServletRequest의 상세 사용 예와 메서드

클라이언트의 요청 데이터를 처리하는 주요 메서드

HttpServletResponse의 상세 사용 예와 메서드

서버가 응답을 생성하는 주요 메서드

Servlet, HttpServletRequest, HttpServletResponse의 상호작용

1. 클라이언트 요청: 사용자가 브라우저를 통해 URL을 요청하거나 폼을 제출하면, 해당 요청은 HTTP 요청 형태로 서버로 전송됩니다.
2. HttpServletRequest 활용: 서버는 요청 데이터를 HttpServletRequest 객체를 통해 분석하고 필요한 정보를 추출합니다.
3. 서버 처리: 요청을 처리한 결과를 생성하며, 필요 시 세션, 쿠키 등을 설정합니다.
4. HttpServletResponse 활용: 처리 결과를 HttpServletResponse 객체를 통해 클라이언트로 응답합니다.
5. 클라이언트 응답: 클라이언트는 서버에서 전달된 응답 데이터를 화면에 렌더링하거나 추가 요청을 수행합니다.

Servlet 사용의 주요 이점

1. 동적 콘텐츠 생성: 클라이언트 요청에 따라 맞춤형 데이터를 제공합니다.
2. HTTP 프로토콜 지원: GET, POST, PUT 등 다양한 요청 방식을 처리합니다.
3. 확장성: 요청당 스레드를 생성하여 대규모 트래픽도 안정적으로 처리할 수 있습니다.
4. 다양한 API 지원: 세션 관리, 쿠키 처리 등 HTTP 기반의 다양한 기능을 제공합니다.

결론

HttpServletRequest와 HttpServletResponse는 웹 애플리케이션에서 클라이언트와 서버 간 데이터 흐름을 관리하는 핵심 도구입니다. 이를 효율적으로 사용하면 동적 웹 애플리케이션을 개발할 수 있으며, 사용자의 요구에 맞춘 동작 구현도 가능합니다🚀

영화 산업은 수십 년간 놀라운 성장을 이루어왔으며, 다양한 장르와 콘텐츠 유형을 통해 전 세계 관객들에게 즐거움을 선사하고 있습니다. 이번 프로젝트에서는 IMDB 데이터를 분석하여 영화와 TV 콘텐츠의 장르별, 연도별, 그리고 평점과 투표 수 간의 관계를 시각화한 대시보드를 제작했습니다. 이를 통해 얻은 주요 인사이트를 공유합니다.

1. 데이터 요약

주요 지표

• 전체 평균 평점: 7.259점
• 가장 많은 투표를 받은 영화: The Shawshank Redemption (296만 7,074표)
• 최다 투표 상위 10개 작품: 영화와 TV 시리즈가 혼합된 형태로, The Dark Knight*와 *Inception 등 잘 알려진 작품들이 포함.

2. 분석 인사이트

1) 장르별 데이터 분석

• 장르별 평균 평점:
  • Documentary(다큐멘터리)가 평균 평점 7.259로 가장 높은 평가를 받았습니다.
  • 반면, Horror(호러)는 평균 4.877점으로 가장 낮은 평점을 기록.
  • 코미디와 드라마 장르가 다양한 하위 조합(Comedy, Drama, Drama, Romance)에서 꾸준히 높은 점수를 유지.

인사이트: 다큐멘터리는 관객층이 한정적이지만, 높은 품질의 콘텐츠를 제공해 평점이 우수. 반면, 호러 장르는 대중적이지만 작품 간 품질 차이가 커 평점이 낮은 경향을 보입니다.

2) 출시 연도별 영화 수와 평균 평점

• 연도별 영화 수 증가:

  • 1970년대 이후 영화 제작 수가 급격히 증가, 2000년대 이후 정점에 도달.
  • 특히 2010년대에는 스트리밍 서비스의 발전과 함께 콘텐츠 양이 폭발적으로 증가.

• 평균 평점의 변화:

  • 연도별로 큰 변동은 없으나, 최신 영화의 평점 분포는 다소 낮은 경향을 보임.
  • 이는 최근 수많은 콘텐츠 출시로 인해 관객의 평가 기준이 더 엄격해졌음을 시사.

인사이트: 영화 제작 기술과 플랫폼의 발전이 양적 성장을 이끌었지만, 질적 기준은 다양화됨. 이는 관객과 제작사 간의 기대치 조정이 필요함을 보여줍니다.

3) 평점과 투표 수의 관계

• 평점이 8.0 이상인 경우, 투표 수가 대체로 많아지는 경향을 보임.
• 반면, 평점이 낮은 작품(5.0 미만)은 투표 수가 적어 관객의 관심이 부족.

인사이트: 높은 평점 작품은 바이럴 효과로 인해 더 많은 관객과 상호작용을 끌어내는 반면, 저평점 콘텐츠는 주목받기 어려운 경향이 있습니다. 제작사는 평점이 높은 콘텐츠 제작에 집중해야 할 필요가 있습니다.

4) 타입별 콘텐츠 비율

• Documentary와 Comedy 콘텐츠의 비율이 가장 높음.
• TV 시리즈와 영화가 고르게 분포되어 있으며, 다양한 장르가 폭넓게 제작되고 있음.

인사이트: 최근 관객의 관심은 TV 시리즈와 다큐멘터리로 확대되고 있으며, 플랫폼별 특화 콘텐츠 전략이 중요해지고 있습니다.

5) 상위 10개 작품의 특징

• 최다 투표 상위 10개 작품은 대부분 Action, Drama, Adventure 장르에 속함.
• The Shawshank Redemption*과 *The Dark Knight 등은 스토리와 연출의 완성도로 관객에게 깊은 인상을 남김.

인사이트: 대중적 사랑을 받는 작품은 강렬한 스토리와 독창성이 주요 요소로 작용합니다. 제작사는 이러한 트렌드를 분석하여 성공적인 콘텐츠를 기획해야 할 것입니다.

3. 결론 및 제안

이번 분석을 통해 IMDB 데이터를 바탕으로 영화 및 TV 콘텐츠의 주요 트렌드와 성과를 확인할 수 있었습니다. 아래는 추가적인 제안 사항입니다:

• 콘텐츠 제작:

  • 다큐멘터리와 드라마/코미디 장르의 품질 높은 콘텐츠에 투자.
  • 관객의 관심을 끌 수 있는 새로운 장르와 형식의 실험 필요.

• 데이터 기반 마케팅:

  • 높은 평점을 받은 작품을 중심으로 마케팅 캠페인 강화.
  • 투표 수가 적은 콘텐츠에 대한 개선 및 리마케팅 전략 수립.

• 플랫폼별 차별화:

  • 스트리밍 서비스와 전통적 극장 배급 간의 전략적 차별화가 중요.

대시보드 활용

이번 대시보드는 데이터를 시각적으로 효과적으로 전달하여 비즈니스 의사결정에 활용 가능하도록 설계되었습니다. 장르, 연도별 트렌드, 그리고 평점과 투표 수 관계를 통해 콘텐츠 제작 및 유통의 새로운 방향성을 제시할 수 있습니다.

이번 포스팅에서는 노벨상 탐색기 프로젝트의 핵심 기능 중 하나인 검색창과 관련된 코드를 리뷰합니다. 검색창은 사용자로부터 입력을 받아 API를 호출하고, 결과를 필터링하여 사용자에게 표시하는 중요한 UI/UX 요소입니다. 리뷰 대상은 다음과 같습니다:

• SearchBox.js: 검색창 컴포넌트
• SearchBox.css: 검색창 스타일링
• SearchResults.js: 검색 결과를 표시하는 컴포넌트
• SearchResults.css: 결과 목록 스타일링

1️⃣ SearchBox.js - 검색창 컴포넌트

import React, { useState } from "react";
import { useNavigate } from "react-router-dom";
import "./SearchBox.css";

function SearchBox({ onSearch }) {
  const [query, setQuery] = useState("");
  const [year, setYear] = useState("");
  const [prizeCategory, setPrizeCategory] = useState("");
  const navigate = useNavigate();

  const handleSubmit = async (e) => {
    e.preventDefault();
    try {
      let apiUrl = `https://api.nobelprize.org/2.1/laureates?`;
      if (query) apiUrl += `name=${query}&`;
      if (year) apiUrl += `nobelPrizeYear=${year}&`;
      if (prizeCategory) apiUrl += `nobelPrizeCategory=${prizeCategory}`;

      const response = await fetch(apiUrl);
      const data = await response.json();

      const filteredData = data.laureates.filter((laureate) =>
        laureate.fullName.en.toLowerCase().startsWith(query.toLowerCase())
      );

      onSearch(filteredData || []);
      navigate("/search-results");
    } catch (error) {
      console.error("Error fetching data:", error);
    }
  };

  return (
    <div className="search-container">
      <form onSubmit={handleSubmit}>
        <input
          type="text"
          value={query}
          onChange={(e) => setQuery(e.target.value)}
          placeholder="이름 검색"
        />
        <input
          type="text"
          value={year}
          onChange={(e) => setYear(e.target.value)}
          placeholder="수상 연도"
        />
        <input
          type="text"
          value={prizeCategory}
          onChange={(e) => setPrizeCategory(e.target.value)}
          placeholder="수상 종류"
        />
        <button type="submit">검색</button>
      </form>
    </div>
  );
}

export default SearchBox;

📌 리뷰 포인트

1. 구조적 완성도

   • useState를 활용해 검색 필드의 상태를 관리하며, 입력값에 실시간으로 반응합니다.
   • useNavigate를 사용해 검색 결과 페이지로 이동을 구현한 점이 효율적입니다.

2. API 호출 및 데이터 처리

   • 조건에 따라 API URL을 동적으로 생성하며, 사용자 입력값에 맞는 데이터를 필터링하는 로직이 명확합니다.
   • try-catch 블록을 사용해 에러를 처리하고 있어 안정성이 돋보입니다.

3. 코드 개선 제안

   • Validation 추가: 연도나 상 종류가 유효하지 않은 경우 적절한 경고 메시지를 표시하는 로직을 추가하면 사용자 경험이 개선됩니다.
   • 필드 초기화: 검색이 완료된 후 입력값을 초기화하는 기능을 고려해보세요.

     setQuery("");
     setYear("");
     setPrizeCategory("");

2️⃣ SearchBox.css - 검색창 스타일링

.search-container {
  width: 100%;
  max-width: 800px;
  margin: 50px auto;
  padding: 20px;
  background-color: #f9f9f9;
  border-radius: 8px;
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
}

form {
  display: flex;
  flex-direction: row;
  justify-content: space-between;
  align-items: center;
  gap: 20px;
}

input {
  width: 30%;
  padding: 12px;
  border: 1px solid #ccc;
  border-radius: 5px;
  font-size: 1rem;
  box-sizing: border-box;
}

input:focus {
  border-color: #007bff;
  outline: none;
  box-shadow: 0 0 5px rgba(0, 123, 255, 0.5);
}

button {
  width: 20%;
  padding: 12px;
  background-color: #007bff;
  color: white;
  border: none;
  border-radius: 5px;
  font-size: 1.1rem;
  cursor: pointer;
  transition: background-color 0.3s ease;
}

button:hover {
  background-color: #0056b3;
}

📌 리뷰 포인트

1. 레이아웃 및 스타일링

   • flexbox를 사용하여 각 필드를 깔끔하게 정렬하고 간격을 유지하였습니다.
   • box-shadow와 border-radius로 검색창에 부드러운 느낌을 더했습니다.

2. 디자인 개선 제안

   • 반응형 디자인: 모바일 화면에서 입력 필드와 버튼이 너무 좁아 보일 수 있으므로, 미디어 쿼리를 통해 필드의 너비를 100%로 조정하는 것이 좋습니다.

     @media (max-width: 768px) {
       input, button {
         width: 100%;
         margin-bottom: 10px;
       }
     }

3️⃣ SearchResults.js - 검색 결과 표시

import React from "react";
import "./SearchResults.css";

function SearchResults({ searchResults }) {
  if (!searchResults || searchResults.length === 0) {
    return <div>검색 결과가 없습니다.</div>;
  }

  return (
    <div className="search-results">
      <h2>검색 결과</h2>
      <ul>
        {searchResults.map((result, index) => (
          <li key={index}>
            <h3>{result.knownName?.en || result.fullName?.en || "이름 없음"}</h3>
            <p>수상 연도: {result.nobelPrizes[0]?.awardYear}</p>
            <p>수상 종류: {result.nobelPrizes[0]?.category?.en}</p>
          </li>
        ))}
      </ul>
    </div>
  );
}

export default SearchResults;

📌 리뷰 포인트

1. 구조적 간결성

   • 조건부 렌더링을 통해 결과가 없을 경우 메시지를 출력하는 구조가 명확합니다.
   • API 응답 데이터를 적절히 매핑하여 사용자에게 필요한 정보를 제공합니다.

2. 코드 개선 제안

   • 로딩 상태 추가: API 호출 중 로딩 스피너를 표시하면 사용자 경험이 향상됩니다.

     const [isLoading, setIsLoading] = useState(false);

4️⃣ SearchResults.css - 결과 스타일링

.search-results {
  margin: 20px;
  padding: 20px;
  background-color: #f9f9f9;
  border: 1px solid #ddd;
  border-radius: 8px;
}

.search-results h2 {
  font-size: 24px;
  margin-bottom: 16px;
}

.search-results li {
  padding: 15px;
  background-color: #fff;
  border: 1px solid #ddd;
  border-radius: 6px;
  margin-bottom: 16px;
}

📌 리뷰 포인트

• 결과 목록을 깔끔하게 정리한 스타일링이 돋보입니다.
• 호버 효과로 시각적 피드백을 제공하는 점이 유용합니다.

마무리 ✨

이 코드는 검색창 구현과 관련된 구조적 완성도와 디자인의 균형이 돋보입니다. 다만, 추가적인 UX 개선 사항(로딩 상태, 에러 처리 등)을 반영하면 더 나은 사용자 경험을 제공할 수 있습니다.

이번 포스팅에서는 노벨상 탐색기 프로젝트의 내비게이션 바 구현과 관련된 주요 파일들의 코드 리뷰를 할 것입니다.내비게이션 바는 사용자 경험을 높이고 페이지 간의 이동을 직관적으로 만들어주는 중요한 UI 요소입니다. 리뷰 대상은 다음과 같습니다:

• Nav.js: 내비게이션 바의 구조를 정의한 컴포넌트
• Nav.css: 내비게이션 바의 스타일링
• About.js: "About" 페이지의 콘텐츠를 제공하는 컴포넌트
• Contact.js: "Contact" 페이지의 콘텐츠를 제공하는 컴포넌트
• App.js: 내비게이션 바 및 라우팅 설정 적용

1️⃣ Nav.js - 내비게이션 바 구조

import React from "react";
import { Link } from "react-router-dom";
import "./Nav.css";

function Nav() {
  return (
    <div className="navbar">
      <Link to="/" className="navbarTitle">
        <h1>Nobel Winners</h1>
      </Link>
      <Link className="navbarMenu" to="/about">
        About
      </Link>
      <Link className="navbarMenu" to="/contact">
        Contact
      </Link>
    </div>
  );
}

export default Nav;

📌 리뷰 포인트

1. 컴포넌트 구조

   • <Link>를 사용하여 React Router와의 통합을 매끄럽게 구현하였습니다.
   • 각 메뉴는 의미에 맞는 클래스 이름을 부여받아 스타일링 및 식별이 용이합니다.

2. UI/UX 고려

   • Nobel Winners는 h1 태그로 정의되어 화면의 중심 요소로 자리 잡습니다.
   • "About"와 "Contact" 링크는 적절한 텍스트로 표현되어 내비게이션 용도를 명확히 합니다.

3. 코드 개선 제안

   • 활성화된 메뉴 표시: NavLink를 사용해 현재 활성화된 메뉴를 강조하면 UX가 더욱 향상됩니다.

     import { NavLink } from "react-router-dom";
     
     <NavLink 
       to="/about" 
       className={({ isActive }) => isActive ? "navbarMenu active" : "navbarMenu"}
     >
       About
     </NavLink>

     위와 같이 활성 상태에 따라 추가 클래스(active)를 적용하면 현재 페이지를 직관적으로 표시할 수 있습니다.

2️⃣ Nav.css - 내비게이션 바 스타일링

.navbar {
  width: 100%;
  background-color: white;
  padding: 15px 0;
  display: flex;
  align-items: center; /* 수직 중앙 정렬 */
  text-align: left;
}

.navbarTitle {
  text-decoration: none; /* Link 태그의 기본 밑줄 제거 */
}

.navbarTitle h1 {
  font-size: 36px; /* Nobel Winners의 크기를 더 크게 설정 */
  font-weight: bold; /* 글자 굵게 설정 */
  margin-left: 20px;
  color: black;
  text-decoration: none; /* h1 태그의 밑줄도 제거 */
}

.navbarTitle h1:hover {
  text-decoration: underline; /* 마우스를 올리면 밑줄 표시 */
}

.navbarMenu {
  color: black;
  margin-left: 20px;
  font-size: 18px; /* 나머지 메뉴의 크기는 기본보다 작게 설정 */
  text-decoration: none;
}

.navbarMenu:hover {
  text-decoration: underline;
}

📌 리뷰 포인트

1. 레이아웃 설계

   • flexbox를 사용해 메뉴를 수평 정렬하고, 텍스트가 가운데 정렬되도록 구현했습니다.

2. 디자인 세부사항

   • Nobel Winners는 더 크고 굵은 글씨로 설정하여 헤더 역할을 강조했습니다.
   • 메뉴 항목(About, Contact)에는 호버 시 밑줄 효과를 추가하여 시각적인 피드백을 제공합니다.

3. 코드 개선 제안

   • 반응형 고려: 모바일 화면에서는 메뉴가 좁게 보일 수 있으므로 미디어 쿼리를 추가해 메뉴를 드롭다운 형식으로 전환하거나 폰트를 조정하는 것이 좋습니다.

     @media (max-width: 768px) {
       .navbar {
         flex-direction: column;
         align-items: flex-start;
         padding: 10px;
       }
       .navbarMenu {
         font-size: 16px;
         margin-left: 0;
         margin-top: 10px;
       }
     }

3️⃣ About.js - About 페이지 구현

function About() {
  return (
    <div>
      <h1>About</h1>
      <p>
        The Nobel Prize is a set of prestigious international awards given
        annually in several categories. The prizes were established by the 1895
        will of Alfred Nobel, the inventor of dynamite. The prizes in Physics,
        Chemistry, Physiology or Medicine, Literature, and Peace were first
        awarded in 1901.
      </p>
    </div>
  );
}
export default About;

📌 리뷰 포인트

1. 구조적 완성도

   • 간결하고 명확한 구조로 About 페이지를 설명합니다.

2. 코드 개선 제안

   • 스타일링 추가: About.css 파일을 만들어 텍스트 정렬, 폰트 스타일 등을 세부적으로 지정하면 더욱 완성도를 높일 수 있습니다.
   • 예시:

     .aboutContainer {
       padding: 20px;
       font-family: Arial, sans-serif;
     }

4️⃣ Contact.js - Contact 페이지 구현

function Contact() {
  return (
    <div>
      <h1>Contact</h1>
    </div>
  );
}
export default Contact;

📌 리뷰 포인트

1. 구조의 간소화

   • Contact 페이지는 기본적인 틀만 구현되어 있습니다.

2. 코드 개선 제안

   • 폼 추가: 사용자가 연락처나 이메일을 입력할 수 있는 폼을 추가하면 실용성이 향상됩니다.

     function Contact() {
       return (
         <div>
           <h1>Contact</h1>
           <form>
             <label htmlFor="email">Email:</label>
             <input type="email" id="email" name="email" />
             <label htmlFor="message">Message:</label>
             <textarea id="message" name="message"></textarea>
             <button type="submit">Send</button>
           </form>
         </div>
       );
     }

5️⃣ App.js - 내비게이션 바 적용

import React from "react";
import { BrowserRouter as Router, Route, Routes } from "react-router-dom";
import Nav from "./Nav";
import About from "./About";
import Contact from "./Contact";

function App() {
  return (
    <Router>
      <Nav />
      <Routes>
        <Route path="/about" element={<About />} />
        <Route path="/contact" element={<Contact />} />
      </Routes>
    </Router>
  );
}

export default App;

📌 리뷰 포인트

1. 라우팅 통합

   • React Router의 <Routes>와 <Route>를 활용해 페이지 간 이동을 간단히 구성했습니다.

2. 구성의 명확성

   • Nav 컴포넌트를 모든 페이지에서 공유하도록 설정하여 일관된 내비게이션 경험을 제공합니다.

완성본

이제 이 코드를 기반으로 내비게이션 바와 페이지 전환의 세부 구현을 학습해 보세요! 😊

🌟 프로젝트 개요

"노벨상 탐색기"는 노벨상 수상자 데이터를 쉽게 탐색할 수 있도록 설계된 React 기반의 웹 애플리케이션입니다.
학생, 연구자, 일반 사용자들이 카테고리별로 노벨상 수상자 정보를 확인할 수 있는 인터랙티브한 환경을 제공합니다.
React Router와 CSS Grid를 활용하여 사용성과 시각적인 매력을 동시에 고려하였으며 API 연동을 통해 실시간 데이터를 제공합니다.

🎯 프로젝트 목표

1. 정보 제공 플랫폼

   • 노벨상 수상 데이터를 기반으로 누구나 쉽게 원하는 정보를 얻을 수 있는 사용자 친화적인 플랫폼을 구축합니다.

2. 데이터 활용 및 시각화

   • Nobel Prize API를 활용하여 실시간 데이터를 제공하며 향후 데이터 시각화를 도입할 계획입니다.

3. UI/UX 최적화

   • 반응형 디자인을 적용하여 데스크탑, 태블릿, 모바일에서도 최적의 경험을 제공합니다.

4. 코드의 확장성 및 재사용성 확보

   • 모듈화된 컴포넌트 구조를 통해 유지보수와 확장이 용이한 프로젝트를 구현하였습니다.

✨ 주요 기능

1. 카테고리별 탐색

   • Medicine, Physics, Chemistry 등 다양한 노벨상 카테고리를 선택해 각 카테고리에 대한 수상 정보를 확인할 수 있습니다.

2. 이미지 기반 인터페이스

   • 시각적 매력을 더하기 위해 카테고리마다 관련 이미지를 배치하였으며 사용자가 직관적으로 탐색할 수 있도록 구성했습니다.

3. 에러 처리

   • API 호출 중 발생할 수 있는 오류를 감지하고 사용자에게 알림을 표시하여 안정성을 높였습니다.

4. 라우팅 시스템

   • React Router를 사용해 부드러운 페이지 전환을 구현하고 사용자의 탐색 경험을 향상시켰습니다.

🛠️ 기술 스택

1. React: 모던 UI 라이브러리로, 컴포넌트 기반 개발을 통해 효율적인 UI 구현.
2. React Router: 페이지 전환 및 라우팅 기능을 제공.
3. CSS Grid: 카테고리 선택 화면에 적용하여 반응형 레이아웃 구현.
4. 노벨상 API: 동적 데이터 로드에 사용.
5. Node.js (옵션): 추가적인 서버 로직 처리 가능.

🗂️ 프로젝트 특징

💡 컴포넌트 중심의 구조

모든 UI 요소를 재사용 가능한 React 컴포넌트로 구현하여 유지보수와 확장성을 극대화했습니다.

🌍 반응형 설계

CSS Grid와 미디어 쿼리를 활용하여 다양한 디바이스에서 최적의 화면을 제공합니다.

📊 데이터 기반 애플리케이션

실시간 데이터 로드 기능을 통해 동적이고 최신 정보를 제공합니다.

🚀 앞으로의 계획

1. 검색 기능 추가

   • 특정 키워드나 수상자 이름으로 정보를 탐색할 수 있는 글로벌 검색창을 도입할 예정입니다.

2. 시각화 도구 통합

   • Chart.js 또는 D3.js를 활용하여 수상자 데이터의 트렌드 및 국가별 통계를 시각화합니다.

3. 다크 모드 구현

   • 라이트 모드와 다크 모드 간 전환을 지원하는 사용자 설정 기능 추가.

4. 테스트 자동화

   • Cypress 및 React Testing Library를 활용한 자동화 테스트 도입.

노벨상 탐색기 프로젝트는 데이터 중심의 웹 애플리케이션 개발에 관심 있는 개발자들에게 좋은 학습 자료가 될 것이라고 생각합니다.
사용자 친화적인 UI/UX와 동적 데이터 처리에 대한 도전을 통해 한 단계 더 성장할 수 있었던 프로젝트였습니다.
이 블로그 시리즈를 통해 여러분과 함께 프로젝트 코드를 상세히 리뷰하고 개선 아이디어를 나누고자 합니다. 😊

Git을 사용하다 보면 한 번에 여러 파일을 수정하지만, 특정 파일만 커밋하고 싶을 때가 있습니다. 이럴 때 유용한 명령어가 git add 입니다. 이번 포스팅에서는 Git에서 특정 파일만 add하는 방법을 알아보겠습니다.

1. Git 상태 확인 (git status)

먼저, 현재 작업 중인 디렉토리의 변경 사항을 확인하려면 git status 명령어를 사용합니다. 이 명령어를 통해 어떤 파일이 수정되었는지, 추가해야 할 파일이 무엇인지 확인할 수 있습니다.

git status

이 명령어를 입력하면 다음과 같이 출력됩니다.

On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   file1.txt
    modified:   file2.txt

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    file3.txt

위의 결과에서 file1.txt와 file2.txt는 수정되었고, file3.txt는 새로 추가된 파일임을 알 수 있습니다.

2. 특정 파일만 git add 하기

여러 파일이 변경되었을 때, 그 중 하나만 add하려면 git add 명령어 뒤에 파일 경로를 지정해줍니다. 예를 들어, file1.txt만 추가하고 싶다면 다음과 같이 입력합니다.

git add file1.txt

이렇게 하면 file1.txt만 스테이징 영역에 추가됩니다. 나머지 파일들은 아직 스테이징 되지 않은 상태로 남아 있습니다.

3. 여러 파일을 개별적으로 add 하기

만약 여러 파일을 선택적으로 추가하고 싶다면, 파일을 하나씩 선택하여 git add 명령어를 반복 실행하면 됩니다.

git add file1.txt
git add file3.txt

이렇게 하면 file1.txt와 file3.txt만 스테이징 영역에 추가되고, 나머지 파일들은 스테이징되지 않은 상태로 남습니다.

4. 특정 디렉토리의 파일만 add 하기

특정 디렉토리 내의 파일을 한꺼번에 추가하고 싶을 때는 해당 디렉토리 경로를 명시해주면 됩니다. 예를 들어, src 디렉토리 내의 모든 파일을 추가하려면 아래와 같이 입력합니다.

git add src/

이 명령어는 src 디렉토리 내부의 모든 파일을 스테이징 영역에 추가합니다.

5. 변경된 모든 파일을 add 하기

만약 변경된 모든 파일을 한 번에 스테이징하고 싶다면, .(점)을 사용하면 됩니다. 다음 명령어를 실행하면 현재 디렉토리와 그 하위 디렉토리 내의 모든 변경 사항이 스테이징 영역에 추가됩니다.

git add .

결론

Git을 사용할 때, 특정 파일만 선택적으로 add하는 방법은 협업 과정에서 실수를 줄이고 원하는 변경 사항만 커밋하는 데 큰 도움이 됩니다.

1. DataFrame이란?

DataFrame은 Pandas의 핵심 데이터 구조 중 하나로, 2차원 테이블(표) 형식으로 데이터를 저장합니다. 각 열은 데이터의 특징을 나타내고, 각 행은 개별 데이터를 나타냅니다. DataFrame은 여러 타입의 데이터를 함께 저장할 수 있으며, 인덱스를 통해 행과 열을 참조할 수 있습니다.

예시

import pandas as pd

# 딕셔너리를 사용한 DataFrame 생성
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 24, 35, 32],
        'City': ['New York', 'Paris', 'Berlin', 'London']}

df = pd.DataFrame(data)

# DataFrame 출력
print(df)

결과:

    Name  Age      City
0   John   28  New York
1   Anna   24     Paris
2  Peter   35    Berlin
3  Linda   32    London

2. DataFrame 생성 방법

2.1. 딕셔너리를 사용한 생성

딕셔너리로 DataFrame을 생성할 때, 키는 열 이름이 되고, 값은 데이터가 됩니다.

# 딕셔너리로 생성
data = {'Product': ['Phone', 'Tablet', 'Laptop'],
        'Price': [500, 800, 1200],
        'Stock': [50, 30, 20]}

df = pd.DataFrame(data)
print(df)

2.2. 리스트를 사용한 생성

리스트의 리스트를 사용하여 DataFrame을 생성할 수 있으며, 열 이름을 columns 파라미터로 지정합니다.

# 리스트로 생성
data = [['Alice', 25], ['Bob', 30], ['Charlie', 35]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

2.3. Numpy 배열로 생성

Pandas는 Numpy와 호환되므로, Numpy 배열을 이용하여 DataFrame을 만들 수 있습니다.

import numpy as np

# Numpy 배열로 생성
data = np.array([[1, 2, 3], [4, 5, 6]])
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print(df)

3. DataFrame의 주요 속성

DataFrame은 여러 유용한 속성을 제공하여 데이터에 대한 정보를 쉽게 확인할 수 있습니다.

• df.shape: DataFrame의 행과 열 개수를 튜플 형태로 반환합니다.
• df.columns: 열 이름을 반환합니다.
• df.index: 행 인덱스를 반환합니다.
• df.dtypes: 각 열의 데이터 타입을 반환합니다.
• df.head(): 처음 5개 행을 반환합니다.
• df.tail(): 마지막 5개 행을 반환합니다.

예시

print(df.shape)     # (4, 3)
print(df.columns)   # Index(['Name', 'Age', 'City'], dtype='object')
print(df.dtypes)    # 각 열의 데이터 타입 출력

4. DataFrame 데이터 접근 및 조작

4.1. 열 단위 접근

열을 선택할 때는 열 이름을 대괄호 [] 안에 입력하여 접근할 수 있습니다.

# 'Name' 열 선택
print(df['Name'])

4.2. 행 단위 접근

행을 선택할 때는 iloc[]나 loc[]를 사용합니다.

• iloc[]: 정수 기반 인덱싱
• loc[]: 라벨 기반 인덱싱

# 첫 번째 행 선택 (정수 인덱스)
print(df.iloc[0])

# 'John'이 있는 행 선택 (라벨 인덱스)
print(df.loc[df['Name'] == 'John'])

4.3. 새로운 열 추가

새로운 열을 쉽게 추가할 수 있습니다.

# 'Country'라는 새 열 추가
df['Country'] = ['USA', 'France', 'Germany', 'UK']
print(df)

4.4. 데이터 필터링

조건을 이용해 데이터를 필터링할 수 있습니다.

# 나이가 30 이상인 사람들만 필터링
filtered_df = df[df['Age'] >= 30]
print(filtered_df)

4.5. 데이터 정렬

특정 열을 기준으로 데이터를 정렬할 수 있습니다.

# 나이를 기준으로 오름차순 정렬
sorted_df = df.sort_values(by='Age')
print(sorted_df)

5. 데이터 조작 (기본 연산)

Pandas는 데이터를 조작하는 여러 기본 기능을 제공합니다.

5.1. 통계 연산

Pandas는 기본적인 통계 기능을 제공하며, 각 열에 대해 계산할 수 있습니다.

# 기본 통계 정보
print(df.describe())

# 특정 열의 평균
print(df['Age'].mean())

5.2. 결측치 처리

결측치(NaN)를 처리하는 방법도 제공합니다.

# 결측치가 있는 행 삭제
df_cleaned = df.dropna()

# 결측치를 특정 값으로 대체
df_filled = df.fillna(0)

6. DataFrame 병합 및 연결

6.1. 행/열 연결

concat() 함수를 사용하여 여러 DataFrame을 연결할 수 있습니다.

# 두 DataFrame을 행 단위로 연결
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
df_concat = pd.concat([df1, df2])
print(df_concat)

6.2. 병합(Join)

두 개 이상의 DataFrame을 특정 키를 기준으로 병합할 수 있습니다.

# 공통된 'ID'를 기준으로 병합
df1 = pd.DataFrame({'ID': [1, 2, 3], 'Name': ['John', 'Anna', 'Peter']})
df2 = pd.DataFrame({'ID': [1, 2, 4], 'Age': [28, 24, 35]})
df_merged = pd.merge(df1, df2, on='ID')
print(df_merged)

1. CSV 파일 불러오기

가장 일반적으로 사용하는 데이터 형식인 CSV 파일은 read_csv() 함수로 불러올 수 있습니다.

import pandas as pd

# CSV 파일 불러오기
df = pd.read_csv('data.csv')

# 데이터 출력
print(df.head())  # 처음 5개의 행 출력

주요 옵션

• index_col: 특정 열을 인덱스로 설정할 수 있습니다.
• usecols: 특정 열만 선택하여 불러올 수 있습니다.
• encoding: CSV 파일의 인코딩을 지정할 수 있습니다.

# 인덱스 열 설정 및 특정 열만 불러오기
df = pd.read_csv('data.csv', index_col='ID', usecols=['ID', 'Name', 'Age'], encoding='utf-8')
print(df)

2. Excel 파일 불러오기

Excel 파일은 read_excel() 함수를 사용하여 불러올 수 있습니다.

# Excel 파일 불러오기
df = pd.read_excel('data.xlsx')

# 데이터 출력
print(df.head())

여러 시트 불러오기

Excel 파일에서 특정 시트를 불러오거나, 여러 시트를 불러와 딕셔너리로 저장할 수 있습니다.

# 특정 시트 불러오기
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')

# 여러 시트 불러오기
dfs = pd.read_excel('data.xlsx', sheet_name=None)  # 딕셔너리로 모든 시트를 불러옴
print(dfs['Sheet1'].head())

3. SQL 데이터베이스에서 불러오기

Pandas는 SQL 데이터베이스에서 데이터를 쉽게 불러올 수 있습니다. 이를 위해 read_sql() 함수를 사용하며, SQLAlchemy 등의 데이터베이스 커넥터가 필요합니다.

from sqlalchemy import create_engine

# SQLite 엔진 생성
engine = create_engine('sqlite:///data.db')

# SQL 쿼리를 통해 데이터 불러오기
df = pd.read_sql('SELECT * FROM people', engine)

# 데이터 출력
print(df.head())

4. JSON 파일 불러오기

JSON 형식의 데이터를 불러올 때는 read_json() 함수를 사용합니다.

# JSON 파일 불러오기
df = pd.read_json('data.json')

# 데이터 출력
print(df.head())

다양한 JSON 형식 불러오기

orient 옵션을 사용하여 JSON 데이터의 구조를 지정할 수 있습니다.

# 'records' 구조의 JSON 불러오기
df = pd.read_json('data_records.json', orient='records')
print(df)

5. HTML 파일에서 테이블 불러오기

HTML 파일에서 테이블을 불러올 때는 read_html() 함수를 사용합니다. 이는 웹 페이지에 있는 테이블 데이터를 가져오는 데 유용합니다.

# HTML 파일에서 테이블 불러오기
dfs = pd.read_html('https://example.com/data.html')

# 첫 번째 테이블 출력
print(dfs[0].head())

6. 압축된 파일 불러오기

Pandas는 압축된 파일에서 데이터를 불러오는 것도 지원합니다. CSV 파일을 gzip, zip, bz2, xz 형식으로 압축한 후 read_csv() 함수에서 compression 옵션을 사용하여 불러올 수 있습니다.

# Gzip 압축된 CSV 파일 불러오기
df = pd.read_csv('data.csv.gz', compression='gzip')
print(df.head())

7. 클립보드에서 데이터 불러오기

데이터를 클립보드에서 불러올 수도 있습니다. 예를 들어, 엑셀이나 구글 스프레드시트에서 데이터를 복사한 후 read_clipboard()를 사용하면 쉽게 DataFrame으로 변환됩니다.

# 클립보드에서 데이터 불러오기
df = pd.read_clipboard()

# 데이터 출력
print(df.head())

8. 특정 파일 형식 감지 및 불러오기

read_*() 함수 외에도 파일의 형식을 자동으로 감지하여 불러오는 경우도 있습니다. 예를 들어, .csv, .xlsx와 같은 파일 확장자를 기반으로 파일을 불러오는 도구도 사용할 수 있습니다.

1. CSV 파일로 저장

기본적인 CSV 저장

DataFrame을 CSV 파일로 저장할 때 to_csv() 메서드를 사용합니다.

import pandas as pd

# 예제 데이터프레임 생성
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 24, 35, 32],
        'City': ['New York', 'Paris', 'Berlin', 'London']}
df = pd.DataFrame(data)

# CSV 파일로 저장
df.to_csv('data.csv', index=False)

• index=False는 인덱스 열을 CSV에 저장하지 않도록 합니다.

CSV 파일에 특정 인코딩 적용

특정 인코딩으로 저장하고 싶을 때는 encoding 파라미터를 사용할 수 있습니다.

# UTF-8 인코딩으로 저장
df.to_csv('data_utf8.csv', index=False, encoding='utf-8')

2. Excel 파일로 저장

기본적인 Excel 저장

DataFrame을 Excel 파일로 저장할 때는 to_excel() 메서드를 사용합니다.

# Excel 파일로 저장
df.to_excel('data.xlsx', index=False)

여러 시트에 저장

여러 DataFrame을 하나의 Excel 파일의 다른 시트에 저장하려면 ExcelWriter를 사용합니다.

# 여러 시트에 저장
with pd.ExcelWriter('multi_sheet_data.xlsx') as writer:
    df.to_excel(writer, sheet_name='Sheet1')
    df.to_excel(writer, sheet_name='Sheet2')

3. SQL 데이터베이스에 저장

SQLite에 저장

SQLite 데이터베이스에 저장할 때는 to_sql() 메서드를 사용합니다. 이때 sqlalchemy 또는 sqlite3 라이브러리가 필요합니다.

from sqlalchemy import create_engine

# SQLite 엔진 생성
engine = create_engine('sqlite:///data.db')

# 데이터베이스에 저장 (테이블 이름: people)
df.to_sql('people', engine, index=False, if_exists='replace')

• if_exists='replace'는 테이블이 이미 존재하면 덮어쓰기를 수행합니다. 데이터베이스 테이블을 업데이트하려면 append로 설정할 수 있습니다.

4. JSON 파일로 저장

기본적인 JSON 저장

DataFrame을 JSON 형식으로 저장할 때는 to_json() 메서드를 사용합니다.

# JSON 파일로 저장
df.to_json('data.json')

포맷 옵션 설정

orient 옵션을 사용하여 JSON 형식의 구조를 지정할 수 있습니다. 예를 들어, records로 설정하면 각 행이 JSON 객체로 저장됩니다.

# JSON 포맷을 'records'로 저장
df.to_json('data_records.json', orient='records')

5. HTML 파일로 저장

DataFrame을 HTML 파일로 저장할 때는 to_html() 메서드를 사용합니다.

# HTML 파일로 저장
df.to_html('data.html')

6. 압축된 파일로 저장

CSV나 Excel 파일을 압축하여 저장할 수 있습니다. compression 파라미터를 이용하여 여러 압축 방식을 설정할 수 있습니다.

# Gzip 압축을 사용하여 CSV 저장
df.to_csv('data.csv.gz', index=False, compression='gzip')

# ZIP 압축을 사용하여 Excel 저장
df.to_excel('data.zip', index=False, engine='xlsxwriter', compression={'method': 'zip', 'archive_name': 'data.xlsx'})

7. 클립보드에 저장

데이터를 클립보드에 복사하여 쉽게 붙여넣을 수 있습니다. 예를 들어, 엑셀이나 구글 스프레드시트에 데이터를 빠르게 붙여넣을 때 유용합니다.

# 클립보드에 저장
df.to_clipboard(index=False)