@Component
public class JwtUtil {
// private String SECRET_KEY = Base64.getEncoder().encodeToString("secret".getBytes());
private final SecretKey SECRET_KEY = Keys.secretKeyFor(SignatureAlgorithm.HS256);
public String extractUsername(String token) {
return extractClaim(token, Claims::getSubject);
}
public Date extractExpiration(String token) {
return extractClaim(token, Claims::getExpiration);
}
public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
final Claims claims = extractAllClaims(token);
return claimsResolver.apply(claims);
}
private Claims extractAllClaims(String token) {
return Jwts.parserBuilder()
.setSigningKey(SECRET_KEY)
.build()
.parseClaimsJws(token)
.getBody();
}
private Boolean isTokenExpired(String token) {
return extractExpiration(token).before(new Date());
}
public String generateToken(UserDetails userDetails) {
return createToken(userDetails.getUsername());
}
private String createToken(String subject) {
return Jwts.builder()
.setSubject(subject)
.setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 10)) // 10시간 유효
.signWith(SECRET_KEY)
.compact();
}
public Boolean validateToken(String token, UserDetails userDetails) {
final String username = extractUsername(token);
return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
}
}
SecurityConfig
@Configuration
public class SecurityConfig {
private final JwtRequestFilter jwtRequestFilter;
//@Lazy 이렇게 하면 JwtRequestFilter 빈의 초기화를 지연시켜 순환 참조 문제를 피할 수 있습니다.
@Autowired
public SecurityConfig(@Lazy JwtRequestFilter jwtRequestFilter) {
this.jwtRequestFilter = jwtRequestFilter;
}
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
// http
// .authorizeHttpRequests(authorizeRequests ->
// authorizeRequests
// .requestMatchers("/admin/**").hasRole("ADMIN")
// .requestMatchers("/user/**").hasRole("USER")
// .anyRequest().authenticated()
// )
// • authorizeHttpRequests 메서드를 사용하여 HTTP 요청에 대한 인가(Authorization) 규칙을 설정합니다.
// • requestMatchers("/admin/**").hasRole("ADMIN"): URL 패턴이 /admin/**인 요청은 ADMIN 역할을 가진 사용자만 접근할 수 있도록 설정합니다.
// • requestMatchers("/user/**").hasRole("USER"): URL 패턴이 /user/**인 요청은 USER 역할을 가진 사용자만 접근할 수 있도록 설정합니다.
// • anyRequest().authenticated(): 나머지 모든 요청은 인증된 사용자만 접근할 수 있도록 설정합니다.
// .formLogin(formLogin ->
// formLogin
// .loginPage("/login")
// .permitAll()
// )
// • formLogin 메서드를 사용하여 폼 기반 로그인을 설정합니다.
// • loginPage("/login"): 사용자 정의 로그인 페이지를 설정합니다. 사용자가 /login URL로 접근하면 로그인 페이지가 표시됩니다.
// • permitAll(): 로그인 페이지는 인증되지 않은 사용자도 접근할 수 있도록 허용합니다.
//
// .csrf(csrf -> csrf.disable()); // CSRF 보호 비활성화. 필요한 경우 활성화 가능
// • csrf 메서드를 사용하여 CSRF(Cross-Site Request Forgery) 보호 설정을 합니다.
// • csrf.disable(): CSRF 보호를 비활성화합니다. CSRF 보호가 필요할 경우 이 부분을 제거하거나 다른 방법으로 설정할 수 있습니다.
http
.csrf(csrf -> csrf.disable())
.authorizeHttpRequests(authorizeRequests ->
authorizeRequests
.requestMatchers("/api/auth/**").permitAll()
.anyRequest().authenticated()
)
.sessionManagement(sessionManagement ->
sessionManagement.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
)
.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
return http.build();
}
@Bean
public UserDetailsService userDetailsService() {
var userDetailsManager = new InMemoryUserDetailsManager();
var user = User.withUsername("user")
.password(passwordEncoder().encode("password"))
.roles("USER")
.build();
var admin = User.withUsername("admin")
.password(passwordEncoder().encode("admin"))
.roles("ADMIN")
.build();
userDetailsManager.createUser(user);
userDetailsManager.createUser(admin);
return userDetailsManager;
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
/**
* Spring Security 설정 파일에서 AuthenticationManager를 빈으로 정의해야 합니다.
* Spring Boot 2.x에서는 AuthenticationManager를 직접 정의하는 것이 필요했지만,
* Spring Boot 3.x에서는 이를 자동으로 구성하지 않으므로 명시적으로 설정해야 합니다.
* @param authenticationConfiguration
* @return
* @throws Exception
*/
@Bean
public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
return authenticationConfiguration.getAuthenticationManager();
}
}
user 와 password 라는 아이디 및 비밀번호를 이용하면 로그인 가능하다.
AuthController
@RestController
@RequestMapping("/api/auth")
public class AuthController {
@Autowired
private AuthenticationManager authenticationManager;
@Autowired
private UserDetailsService userDetailsService;
@Autowired
private JwtUtil jwtUtil;
@PostMapping("/login")
public String createAuthenticationToken(@RequestBody AuthRequest authRequest) throws Exception {
authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(authRequest.getUsername(), authRequest.getPassword())
);
final UserDetails userDetails = userDetailsService.loadUserByUsername(authRequest.getUsername());
final String jwt = jwtUtil.generateToken(userDetails);
return jwt;
}
}
AuthRequest
@Getter
@Setter
public class AuthRequest {
private String username;
private String password;
}
이렇게 요청할 경우 JWT 토큰을 응답 받고 응답받은 토큰을 API Request 헤더에 Authtication : Bearar {토큰} 으로 넣어주면 인가를 해주면 됩니다.
인가를 원하지 않으면 SecurityConfig 클래스의 securityFilterChain 에 permit 하는 경로를 추가해 주면 됩니다.
•Spring Security 5.4 이후부터는 WebSecurityConfigurerAdapter 대신 SecurityFilterChain을 사용하여 보안 구성을 합니다.
Spring Security에서 인증 및 인가 구현 시 사용되는 주요 개념들
1.Filter 체인
•설명: Spring Security는 다양한 필터들의 체인으로 구성됩니다. 각 필터는 Request를 가로챈 후 일련의 절차를 처리합니다.
•주요 필터: UsernamePasswordAuthenticationFilter는 사용자가 제출한 인증 정보를 처리합니다.
2.UsernamePasswordAuthenticationToken 생성
•설명: UsernamePasswordAuthenticationFilter는 UsernamePasswordAuthenticationToken을 생성하여 AuthenticationManager에게 전달합니다. 이 토큰에는 사용자가 제출한 인증 정보가 포함되어 있습니다.
3.AuthenticationManager
•설명: AuthenticationManager는 실제로 인증을 수행하는데, 여러 AuthenticationProvider들을 이용합니다.
4.AuthenticationProvider
•설명: 각각의 Provider들은 특정 유형의 인증을 처리합니다. 예시로 DaoAuthenticationProvider는 사용자 정보를 데이터베이스에서 가져와 인증을 수행합니다.
5.PasswordEncoder
•설명: 인증과 인가에서 사용될 패스워드의 인코딩 방식을 지정합니다.
6.UserDetailsService
•설명: AuthenticationProvider는 UserDetailsService를 사용하여 사용자 정보를 가져옵니다. UserDetailsService는 사용자의 아이디를 받아 loadUserByUsername을 호출하여 해당 사용자의 UserDetails를 반환합니다.
7.UserDetails
•설명: UserDetails에는 사용자의 아이디, 비밀번호, 권한 등이 포함되어 있습니다.
8.Authentication 객체 생성
•설명: 인증이 성공하면, AuthenticationProvider는 Authentication 객체를 생성하여 AuthenticationManager에게 반환합니다. 이 Authentication 객체에는 사용자의 세부 정보와 권한이 포함되어 있습니다.
9.SecurityContextHolder
•설명: 현재 실행 중인 스레드에 대한 SecurityContext를 제공합니다.
10.SecurityContext
•설명: 현재 사용자의 Authentication이 저장되어 있습니다. 애플리케이션은 SecurityContextHolder를 통해 현재 사용자의 권한을 확인하고, 인가 결정을 합니다.
인증 및 인가 설정에 대한 주요 사항
1.CSRF 보호 비활성화
•설명: CSRF 토큰을 사용하지 않으므로 확인하지 않도록 설정합니다.
2.CORS 설정 적용
•설명: 다른 도메인의 웹 페이지에서 리소스에 접근할 수 있도록 허용합니다.
3.폼 로그인과 HTTP 기본 인증 비활성화
•설명: Spring 웹 페이지에서 제공되는 로그인 폼을 통해 사용자를 인증하는 메커니즘과 HTTP 기본 인증을 비활성화합니다.
4.JwtAuthFilter 추가
•설명: UsernamePasswordAuthenticationFilter 앞에 JwtAuthFilter를 추가하여, JWT 필터를 거치도록 설정합니다. JwtAuthFilter를 통해서 Authentication을 획득하였다면 인증된 자원에 접근할 수 있습니다.
5.권한에 대한 규칙 작성
•설명: anyRequest().permitAll() 설정은 기본적으로 모두 허용해 주지만, EnableGlobalMethodSecurity를 설정하는 이유는 Annotation으로 접근 제한을 설정하기 위함입니다.
•추가 설명: 만약 Annotation을 통해 접근 제한을 하지 않을 것이라면, anyRequest() 부분에서 접근 승인할 엔드포인트들을 작성해야 합니다.
6.인증과 인가 실패 시 Exception Handler 추가
•설명: Security 단계에서 권한 관련 401이나 403 에러 등을 처리해 줄 핸들러를 함께 등록해줍니다.
•authenticationEntryPoint: 인증되지 않은 사용자에 대해 처리하는 핸들러 정의
•accessDeniedHandler: 인증되었지만, 특정 리소스에 대한 권한이 없는 경우(인가) 처리하는 핸들러 정의
요약
CSRF 보호 비활성화: CSRF 토큰 사용하지 않음.
•CORS 설정: 다른 도메인의 웹 페이지에서 리소스 접근 허용.
•폼 로그인과 HTTP 기본 인증 비활성화: Spring 웹 페이지의 로그인 폼과 HTTP 기본 인증 비활성화.
•JwtAuthFilter 추가: UsernamePasswordAuthenticationFilter 앞에 JWT 필터 추가.
비동기 작업에서 Executor를 사용하는 방법은 CompletableFuture의 비동기 작업을 특정 Executor를 통해 실행하도록 설정하는 것입니다. 기본적으로 CompletableFuture.supplyAsync와 CompletableFuture.runAsync는 공용 ForkJoinPool의 공용 스레드 풀을 사용하지만, 특정 Executor를 지정하여 사용자 정의 스레드 풀을 사용할 수도 있습니다.
Executor를 사용하는 방법
1. Executor 생성
먼저, 사용할 Executor를 생성해야 합니다. 예를 들어, ExecutorService는 자주 사용되는 Executor 구현 중 하나입니다.
CompletableFuture의 비동기 작업을 시작할 때, Executor를 두 번째 인수로 전달합니다.
supplyAsync 사용 예
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CompletableFutureWithExecutorExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 비동기 작업 수행
return "Hello, World!";
}, executor);
future.thenAccept(result -> System.out.println("Result: " + result));
// Executor 서비스 종료
executor.shutdown();
}
}
3. 여러 비동기 작업을 결합하여 Executor 사용
thenApplyAsync, thenAcceptAsync, thenRunAsync 등의 메서드도 Executor를 인수로 받아서 지정할 수 있습니다.
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CompletableFutureWithMultipleAsyncExample {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> {
// 첫 번째 비동기 작업
return "Hello";
}, executor).thenApplyAsync(result -> {
// 두 번째 비동기 작업
return result + ", World!";
}, executor).thenAcceptAsync(result -> {
// 세 번째 비동기 작업
System.out.println("Result: " + result);
}, executor);
// Executor 서비스 종료
executor.shutdown();
}
}
요약
1.Executor 생성:ExecutorService와 같은 Executor 구현체를 생성합니다.
3.Executor 서비스 종료: 모든 비동기 작업이 완료되면 executor.shutdown()을 호출하여 Executor를 종료합니다.
executor.shutdown();
CompletableFuture와Executor
CompletableFuture와 Executor를 같이 사용하는 것은 여러 가지 이점을 제공합니다.
이 조합을 사용하면 비동기 작업의 효율성과 유연성을 극대화할 수 있습니다.
주요 이점
1. 병렬 처리의 효율성 증가
•설명: 여러 비동기 작업을 병렬로 처리함으로써 전체 작업의 수행 시간을 단축할 수 있습니다. Executor를 사용하면 특정 스레드 풀을 통해 작업을 분산시켜 병렬 처리의 효율성을 극대화할 수 있습니다.
2. 작업 스케줄링 제어
•설명:Executor를 사용하면 비동기 작업의 실행 정책을 세밀하게 제어할 수 있습니다. 예를 들어, 고정된 수의 스레드 풀, 캐시된 스레드 풀, 단일 스레드 풀 등을 사용하여 작업을 스케줄링할 수 있습니다.
3. 리소스 관리
•설명:Executor를 사용하면 스레드 생성 및 관리를 중앙집중식으로 제어할 수 있어 시스템 리소스를 효율적으로 관리할 수 있습니다. 이를 통해 과도한 스레드 생성으로 인한 성능 저하를 방지할 수 있습니다.
4. 작업의 독립성 보장
•설명: 각 비동기 작업을 별도의 스레드에서 실행하므로 작업 간의 간섭을 최소화할 수 있습니다. 이를 통해 독립적인 작업이 서로 영향을 주지 않고 안전하게 실행될 수 있습니다.
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
// 첫 번째 작업
}, executor);
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
// 두 번째 작업
}, executor);
5. 복잡한 비동기 작업 처리
•설명: 여러 비동기 작업을 조합하여 복잡한 비동기 워크플로우를 쉽게 구현할 수 있습니다. CompletableFuture의 다양한 메서드를 사용하여 작업 간의 의존성을 설정하고, Executor를 통해 이러한 작업을 효율적으로 처리할 수 있습니다.
6. 예외 처리 및 복구
•설명: 비동기 작업에서 발생하는 예외를 처리하고, 필요시 복구 작업을 수행할 수 있습니다. CompletableFuture의 exceptionally, handle 메서드와 함께 사용하여 예외 처리를 더 유연하게 할 수 있습니다.
CompletableFuture는 자바 8에서 도입된 java.util.concurrent 패키지의 클래스입니다. 비동기 프로그래밍을 쉽게 구현할 수 있도록 다양한 메서드와 기능을 제공합니다. CompletableFuture는 비동기 작업을 수행하고, 그 결과를 비동기적으로 처리할 수 있게 해줍니다.
1. CompletableFuture의 기본 개념
•비동기 프로그래밍: 메인 스레드와는 별도로 작업을 수행하여 응답성을 높입니다.
•비동기 작업의 관리: 작업의 완료 여부를 확인하고, 작업이 완료되면 후속 작업을 수행합니다.
•콜백 등록: 작업이 완료되면 실행할 콜백 함수를 등록할 수 있습니다.
2. CompletableFuture의 생성
CompletableFuture 객체는 여러 가지 방법으로 생성할 수 있습니다.
•직접 생성:
CompletableFuture<String> future = new CompletableFuture<>();
List<String> result = stream.collect(Collectors.toList());
- 반복 (Iteration):
stream.forEach(System.out::println);
람다 표현식의 필요성
•간결한 코드: 람다 표현식은 익명 함수를 표현하는 간결한 방법으로, 코드의 길이를 줄이고 가독성을 높입니다.
•함수형 프로그래밍: 함수형 인터페이스와 함께 사용되어 함수형 프로그래밍 패턴을 지원합니다.
람다 표현식의 기본 사용법
•기본 문법:(매개변수) -> { 함수 내용 }
(int a, int b) -> a + b;
•단순 예제:
•Runnable 인터페이스 구현:
Runnable r = () -> System.out.println("Hello, World!");
new Thread(r).start();
•함수형 인터페이스와 함께 사용:
•Predicate 인터페이스:
Predicate<String> isEmpty = s -> s.isEmpty();
boolean result = isEmpty.test("");
실습 예제 1: 리스트 필터링과 매핑
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> items = Arrays.asList("Apple", "Banana", "Orange", "Apricot");
// 필터링: "A"로 시작하는 항목 필터링
List<String> filteredItems = items.stream()
.filter(item -> item.startsWith("A"))
.collect(Collectors.toList());
System.out.println("Filtered Items: " + filteredItems);
// 매핑: 모든 항목을 대문자로 변환
List<String> mappedItems = items.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println("Mapped Items: " + mappedItems);
}
}
실습 예제 2: 숫자 리스트 처리
import java.util.Arrays;
import java.util.List;
public class LambdaExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 스트림을 사용하여 합계 계산
int sum = numbers.stream()
.reduce(0, (a, b) -> a + b);
System.out.println("Sum: " + sum);
// 람다 표현식을 사용하여 각 숫자를 출력
numbers.forEach(n -> System.out.println("Number: " + n));
}
}
