02. JWT AUTH

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-data-jpa"
    // thymeleaf 제거!
    implementation "org.springframework.boot:spring-boot-starter-webmvc"
    implementation "org.springframework.security:spring-security-crypto" // BCrypt만 (Security 전체 X)
    // ↓ JWT 관련 3개 추가
    implementation "io.jsonwebtoken:jjwt-api:0.12.3"
    runtimeOnly "io.jsonwebtoken:jjwt-impl:0.12.3"
    runtimeOnly "io.jsonwebtoken:jjwt-jackson:0.12.3"
    compileOnly "org.projectlombok:lombok"
    runtimeOnly "org.mariadb.jdbc:mariadb-java-client"
    annotationProcessor "org.projectlombok:lombok"
    testImplementation "org.springframework.boot:spring-boot-starter-test"
}

spring.datasource.url=jdbc:mariadb://localhost:3306/boarddb
spring.datasource.username=root
spring.datasource.password=1234
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# JWT 설정 추가 (1차에 없던 것)
jwt.secret=mySecretKeyForJWTTokenGenerationAndValidation2024
jwt.expiration=86400000  # 24시간 (밀리초)

@Component
public class JwtUtil {
    @Value("${jwt.secret}") private String secret;
    @Value("${jwt.expiration}") private Long expiration;

    private SecretKey getSigningKey() {
        return Keys.hmacShaKeyFor(secret.getBytes());
    }

    public String createToken(String username, String nickname) {
        return Jwts.builder()
            .subject(username)
            .claim("nickname", nickname)
            .issuedAt(new Date())
            .expiration(new Date(System.currentTimeMillis() + expiration))
            .signWith(getSigningKey())
            .compact();
    }

    public String getUsername(String token) {
        return getClaims(token).getSubject();
    }

    public boolean validateToken(String token) {
        try { getClaims(token); return true; }
        catch (Exception e) { return false; }
    }

    private Claims getClaims(String token) {
        return Jwts.parser().verifyWith(getSigningKey()).build()
            .parseSignedClaims(token).getPayload();
    }
}

@Component @RequiredArgsConstructor
public class JwtFilter extends OncePerRequestFilter {
    private final JwtUtil jwtUtil;
    private final UserRepository userRepository;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
            HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7); // "Bearer " 7글자 제거
            if (jwtUtil.validateToken(token)) {
                String username = jwtUtil.getUsername(token);
                // DB에서 User 조회 → request에 저장
                userRepository.findByUsername(username).ifPresent(user ->
                    request.setAttribute("loginUser", user)
                );
            }
        }
        filterChain.doFilter(request, response); // 다음 필터/컨트롤러로
    }
}

@Configuration @RequiredArgsConstructor
public class CorsConfig implements WebMvcConfigurer {
    private final JwtFilter jwtFilter;

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
            .allowedOrigins("http://localhost:3000")
            .allowedMethods("GET","POST","PUT","DELETE")
            .allowedHeaders("*")
            .allowCredentials(true);
    }

    // JwtFilter를 수동 등록 — 3차에서는 SecurityConfig가 대신 처리
    @Bean
    public FilterRegistrationBean<JwtFilter> jwtFilterRegistration() {
        FilterRegistrationBean<JwtFilter> registration = new FilterRegistrationBean<>(jwtFilter);
        registration.addUrlPatterns("/api/*");
        return registration;
    }
}

@Getter @Setter
public class BoardDto {
    private Long id;           // 추가 (상세/수정/삭제에 필요)
    private String title;
    private String content;
    private String nickname;   // 추가 (목록에 작성자 표시)
    private String username;   // 추가 (본인 글 여부 확인)
    private int viewCount;     // 추가
    private String createdAt;  // 추가 (LocalDateTime → String 변환)
    private Long userId;       // 추가
}

@Service @RequiredArgsConstructor
public class UserService {
    private final UserRepository userRepository;
    private final BCryptPasswordEncoder bCryptPasswordEncoder;
    private final JwtUtil jwtUtil; // 추가!

    // register()는 1차와 동일

    // 반환타입 변경: User → String (JWT 토큰)
    public String login(String username, String password) {
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new IllegalArgumentException("아이디 또는 비밀번호가 틀렸습니다."));
        if (!bCryptPasswordEncoder.matches(password, user.getPassword()))
            throw new IllegalArgumentException("아이디 또는 비밀번호가 틀렸습니다.");
        return jwtUtil.createToken(user.getUsername(), user.getNickname()); // JWT 반환!
    }
}

@Service @RequiredArgsConstructor
public class BoardService {
    private final BoardRepository boardRepository;

    // 반환타입 변경: Page<Board> → Page<BoardDto>
    public Page<BoardDto> getBoardList(int page) {
        Pageable pageable = PageRequest.of(page, 10, Sort.by("createdAt").descending());
        Page<Board> boardPage = boardRepository.findAllByOrderByCreatedAtDesc(pageable);
        List<BoardDto> dtoList = boardPage.getContent().stream()
            .map(this::toDto).collect(Collectors.toList());
        return new PageImpl<>(dtoList, pageable, boardPage.getTotalElements());
    }

    // write, update, delete 는 1차와 동일

    // toDto() 추가 — Entity를 JSON으로 변환할 때 사용
    private BoardDto toDto(Board board) {
        BoardDto dto = new BoardDto();
        dto.setId(board.getId());
        dto.setTitle(board.getTitle());
        dto.setContent(board.getContent());
        dto.setViewCount(board.getViewCount());
        dto.setUserId(board.getUser().getId());
        dto.setNickname(board.getUser().getNickname());
        dto.setUsername(board.getUser().getUsername());
        dto.setCreatedAt(board.getCreatedAt()
            .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
        return dto;
    }
}

@RestController @RequiredArgsConstructor   // @Controller → @RestController
@RequestMapping("/api/user")               // /user → /api/user
public class UserController {
    private final UserService userService;

    @PostMapping("/register")
    public ResponseEntity<?> register(@RequestBody UserDto userDto) {  // @RequestBody!
        try {
            userService.register(userDto);
            return ResponseEntity.ok(Map.of("message", "회원가입 성공"));
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(Map.of("message", e.getMessage()));
        }
    }

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody UserDto userDto) {
        try {
            String token = userService.login(userDto.getUsername(), userDto.getPassword());
            return ResponseEntity.ok(Map.of("token", token)); // {"token":"eyJ..."}
        } catch (IllegalArgumentException e) {
            return ResponseEntity.badRequest().body(Map.of("message", e.getMessage()));
        }
    }
}

import axios from "axios";

const api = axios.create({ baseURL: "http://localhost:8080" });

// 모든 요청에 JWT 토큰 자동 첨부
api.interceptors.request.use((config) => {
    const token = localStorage.getItem("token");
    if (token) config.headers.Authorization = `Bearer ${token}`;
    return config;
});

// 401 응답 시 자동 로그아웃
api.interceptors.response.use(
    (response) => response,
    (error) => {
        if (error.response?.status === 401) {
            localStorage.removeItem("token");
            window.location.href = "/login";
        }
        return Promise.reject(error);
    }
);

export default api;

import { BrowserRouter, Routes, Route, Navigate } from "react-router-dom";

// 토큰 없으면 로그인 페이지로 강제 이동
const PrivateRoute = ({ children }) => {
    const token = localStorage.getItem("token");
    return token ? children : <Navigate to="/login" />;
};

function App() {
    return (
        <BrowserRouter>
            <Routes>
                <Route path="/login" element={<Login />} />
                <Route path="/register" element={<Register />} />
                <Route path="/board/list"
                    element={<PrivateRoute><BoardList /></PrivateRoute>} />
                <Route path="/board/write"
                    element={<PrivateRoute><BoardWrite /></PrivateRoute>} />
                <Route path="/board/detail/:id"
                    element={<PrivateRoute><BoardDetail /></PrivateRoute>} />
                <Route path="/board/edit/:id"
                    element={<PrivateRoute><BoardEdit /></PrivateRoute>} />
                <Route path="/" element={<Navigate to="/login" />} />
            </Routes>
        </BrowserRouter>
    );
}
export default App;