미정

@Entity
@Table(name = "refresh_token")
@Getter
@Setter
public class RefreshToken {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // 리프레시 토큰의 고유 식별자

    @Column(name = "user_id")
    private Long userId; // 이 리프레시 토큰과 연관된 사용자의 식별자

    private String value; // 리프레시 토큰의 실제 값 -> 이 값은 서버가 클라이언트의 요청을 인증하는 데 사용
}

@Entity
@Table(name = "jwt_blacklist")
@Getter
@Setter
@NoArgsConstructor
public class JwtBlacklist {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id; // 블랙리스트 항목의 고유 식별자

    private String token; // 블랙리스트에 포함된 JWT 문자열

    @Column(name = "expiration_time")
    private Date expirationTime; // 블랙리스트에 있는 JWT의 만료 시간

    public JwtBlacklist(String token, Date expirationTime) {
        this.token = token;
        this.expirationTime = expirationTime;
    }
}

public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
    Optional<RefreshToken> findByValue(String value); // 리프레시 토큰 값으로 RefreshToken 엔티티 조회
    
    boolean existsByValue(String token); // 리프레시 토큰 값이 데이터베이스에 존재하는지 여부

    Optional<RefreshToken> findByUserId(Long userId); // 사용자 ID로 RefreshToken 엔티티 조회
}

public interface JwtBlacklistRepository extends JpaRepository<JwtBlacklist, Long> {
    boolean existsByToken(String token); // JWT 토큰이 블랙리스트에 존재하는지 여부 확인
}

@Service
@RequiredArgsConstructor
public class RefreshTokenService {

    private final RefreshTokenRepository refreshTokenRepository;
	
    // 리프레시 토큰 추가
    @Transactional
    public RefreshToken addRefreshToken(RefreshToken refreshToken) {
        return refreshTokenRepository.save(refreshToken);
    }

	// 리프레시 토큰 조회
    @Transactional
    public Optional<RefreshToken> findRefreshToken(String refreshToken) {
        return refreshTokenRepository.findByValue(refreshToken);
    }

	// 리프레시 토큰 삭제
    public void deleteRefreshToken(String refreshToken) {
        refreshTokenRepository.findByValue(refreshToken).ifPresent(refreshTokenRepository::delete);
    }

	// 사용자 기반 리프레시 토큰 삭제
    public void deleteRefreshToken(Long userId) {
        refreshTokenRepository.findByUserId(userId).ifPresent(refreshTokenRepository::delete);
    }

	// 리프레시 토큰 유효성 검증
    public boolean isRefreshTokenValid(String refreshToken) {
        return refreshTokenRepository.existsByValue(refreshToken);
    }
}

@Service
@RequiredArgsConstructor
public class JwtBlacklistService {

    private final JwtBlacklistRepository jwtBlacklistRepository;
    
    // 블랙리스트에 추가
    public void save(JwtBlacklist blacklist) {
        jwtBlacklistRepository.save(blacklist);
    }
    
    // 블랙리스트 저장
    public void addToBlacklist(String token, Date expirationDate) {
        JwtBlacklist blacklist = new JwtBlacklist(token, expirationDate);
        jwtBlacklistRepository.save(blacklist);
    }

	// 토큰 블랙리스트 확인
    public boolean isTokenBlacklisted(String token) {
        return jwtBlacklistRepository.existsByToken(token);
    }
}

/**
 * 웹 애플리케이션의 보안을 설정
*/

@Configuration // 이 클래스가 Spring의 설정 클래스를 나타낸다는 것을 의미
@EnableWebSecurity // Spring Security를 활성화
@RequiredArgsConstructor // final로 선언된 필드를 위한 생성자 자동 생성
public class SecurityConfig {

    private final CustomUserDetailsService customUserDetailsService; // 사용자 세부 정보 로드 서비스
    private final JwtTokenizer jwtTokenizer; // JWT 토큰을 생성하고 검증하는 도구
    private final CustomAuthenticationEntryPoint customAuthenticationEntryPoint; // 인증 실패 시 처리할 커스텀 엔트리 포인트
    private final JwtBlacklistService jwtBlacklistService; // 블랙리스트에 등록된 JWT를 관리하는 서비스
    private final RefreshTokenService refreshTokenService; // 리프레시 토큰을 관리하는 서비스

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    	// 특정 URL 패턴에 대한 접근 권한 설정
        http
                .authorizeRequests(authorize -> authorize
                        .requestMatchers("/userregform", "/loginform", "/login", "/css/**", "/js/**", "/files/**", "/", "/api/login", "/api/**").permitAll() // 이 주소로 시작되면 인증 필요 없음
                        .requestMatchers("/posts/**", "/{username}", "/about/{username}", "/ws","/chat").permitAll() // 이 주소로 시작되면 인증 필요 없음
                        .requestMatchers("/admin/**", "/admin").hasRole("ADMIN") // 관리자 역할을 가진 사용자만 접근
                        .requestMatchers("/comments/post/**", "/likes/post/**").authenticated() // 인증된 사용자만 접근
                        .anyRequest().authenticated() // 그 외의 모든 요청은 인증된 사용자만 접근
                )
                // UsernamePasswordAuthenticationFilter 앞에 JWT 인증 필터를 추가하여 JWT를 통한 인증을 처리
                .addFilterBefore(new JwtAuthenticationFilter(jwtTokenizer, jwtBlacklistService, refreshTokenService), UsernamePasswordAuthenticationFilter.class)
                .formLogin(form -> form.disable()) // 기본 폼 로그인 비활성화
                .sessionManagement(sessionManagement -> sessionManagement
                        .sessionCreationPolicy(SessionCreationPolicy.STATELESS)) // 세션을 사용하지 않음
                // CSRF 보호 비활성화
                .csrf(csrf -> csrf.disable())
                // http 기본 인증(헤더) 비활성화
                .httpBasic(httpBasic -> httpBasic.disable())
                // CORS (Cross-Origin Resource Sharing)를 구성 및 허용 
                .cors(cors -> cors.configurationSource(configurationSource()))
                // 사용자 정의 인증 진입 지점을 처리하기 위한 예외 처리를 구성
                .exceptionHandling(exception -> exception
                        .authenticationEntryPoint(customAuthenticationEntryPoint)
                );
        return http.build(); // SecurityFilterChain을 빌드 후 반환
    }

    /**
     * 모든 origin, header, method를 허용하는 CORS 구성 소스 정의
     */
    @Bean
    public CorsConfigurationSource configurationSource() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("*"); //모든 도메인 허용
        config.addAllowedHeader("*"); //모든 HTTP 메서드 허용
        config.addAllowedMethod("*");
        config.setAllowedMethods(List.of("GET", "POST", "DELETE")); // 명시적으로 GET, POST, DELETE 메서드 허용
        source.registerCorsConfiguration("/**", config);
        return source;
    }

    /**
     * BCryptPasswordEncoder 빈 정의
     * 비밀번호를 암호화하는 데 사용
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

// security
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'

// lombok
implementation 'org.springframework.boot:spring-boot-starter-web'
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'

// 타임리프에서 스프링시큐리티를 쓸수있게.
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6:3.1.2.RELEASE'
implementation 'org.jsoup:jsoup:1.14.3'

// jwt & json
implementation group: 'io.jsonwebtoken', name: 'jjwt-api', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-impl', version: '0.11.5'
runtimeOnly group: 'io.jsonwebtoken', name: 'jjwt-jackson', version: '0.11.5'

// gson - json 메시지를 다루기 위한 라이브러리
implementation 'com.google.code.gson:gson'

// validation사용
implementation 'jakarta.validation:jakarta.validation-api:3.0.2'