반응형

Spring Boot에서 예외 처리 및 전역 예외 핸들러를 구현하는 코드를 통해, 다양한 예외 상황에서 일관된 응답을 제공하는 방법을 학습할 수 있습니다. 

@ControllerAdvice를 사용하여 전역 예외 처리기를 구현하고, 다양한 예외에 대해 적절한 응답을 반환하는 방법을 살펴보겠습니다.

 

1. 기본 예외 처리 설정

 

Spring Boot에서는 기본적으로 예외가 발생하면 HTTP 상태 코드와 함께 오류 메시지를 반환합니다. 하지만 이 기본 방식은 사용자 경험(UX)을 향상시키기 위해 커스터마이징이 필요할 수 있습니다.

 

2. 전역 예외 처리 클래스 생성

 

@ControllerAdvice를 사용하여 전역 예외 처리기를 생성합니다. 이 클래스는 애플리케이션 전반에서 발생하는 예외를 한 곳에서 처리하고, 일관된 방식으로 응답을 반환할 수 있게 합니다.

 

package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.WebRequest;

import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
@RestController
public class GlobalExceptionHandler {

    // 1. 기본적인 예외 처리
    @ExceptionHandler(Exception.class)
    public final ResponseEntity<Object> handleAllExceptions(Exception ex, WebRequest request) {
        Map<String, Object> response = new HashMap<>();
        response.put("message", ex.getMessage());
        response.put("details", request.getDescription(false));
        return new ResponseEntity<>(response, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    // 2. 특정 예외 처리 (예: NullPointerException)
    @ExceptionHandler(NullPointerException.class)
    public final ResponseEntity<Object> handleNullPointerException(NullPointerException ex, WebRequest request) {
        Map<String, Object> response = new HashMap<>();
        response.put("message", "Null value encountered!");
        response.put("details", request.getDescription(false));
        return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
    }

    // 3. 유효성 검사 실패 예외 처리 (예: MethodArgumentNotValidException)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public final Map<String, String> handleValidationExceptions(MethodArgumentNotValidException ex) {
        Map<String, String> errors = new HashMap<>();
        ex.getBindingResult().getFieldErrors().forEach(error -> 
            errors.put(error.getField(), error.getDefaultMessage()));
        return errors;
    }

    // 4. 사용자 정의 예외 처리
    @ExceptionHandler(ResourceNotFoundException.class)
    public final ResponseEntity<Object> handleResourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
        Map<String, Object> response = new HashMap<>();
        response.put("message", ex.getMessage());
        response.put("details", request.getDescription(false));
        return new ResponseEntity<>(response, HttpStatus.NOT_FOUND);
    }
}

 

3. 사용자 정의 예외 클래스 생성

 

필요에 따라 사용자 정의 예외를 만들어 사용할 수 있습니다. 예를 들어, 리소스를 찾을 수 없을 때 발생시키는 예외를 만들 수 있습니다.

src/main/java/com/example/demo/exception/ResourceNotFoundException.java

package com.example.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;

@ResponseStatus(value = HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException(String message) {
        super(message);
    }
}

어노테이션을 사용하는 경우:

예외 클래스에 @ResponseStatus 어노테이션을 추가하면, 해당 예외가 발생할 때 Spring이 자동으로 지정된 HTTP 상태 코드를 반환합니다.

예를 들어, @ResponseStatus(HttpStatus.NOT_FOUND)를 사용하면, 이 예외가 발생할 때 자동으로 404 Not Found 상태 코드가 반환됩니다.

어노테이션을 사용하지 않는 경우:

@ResponseStatus 어노테이션을 사용하지 않으면, 예외 처리 클래스에서 ResponseEntity를 사용해 상태 코드를 명시적으로 설정할 수 있습니다. 이렇게 하면 예외 상황에 대해 더 유연한 처리가 가능합니다.

 

 

4. 예외 발생 시나리오

 

다음은 리소스를 찾지 못했을 때 ResourceNotFoundException을 발생시키는 서비스 코드의 예입니다.

 

src/main/java/com/example/demo/service/PostService.java

package com.example.demo.service;

import com.example.demo.entity.Post;
import com.example.demo.exception.ResourceNotFoundException;
import com.example.demo.repository.PostRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class PostService {

    @Autowired
    private PostRepository postRepository;

    public Post getPostById(Long id) {
        Optional<Post> post = postRepository.findById(id);
        if (!post.isPresent()) {
            throw new ResourceNotFoundException("Post not found with id: " + id);
        }
        return post.get();
    }

    // 기타 CRUD 메서드들...
}

5. 컨트롤러에서의 사용 예시

컨트롤러에서 서비스 메서드를 호출할 때, 예외가 발생하면 GlobalExceptionHandler가 이를 처리하여 일관된 응답을 반환합니다.

 

src/main/java/com/example/demo/controller/PostController.java

package com.example.demo.controller;

import com.example.demo.entity.Post;
import com.example.demo.service.PostService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/posts")
public class PostController {

    @Autowired
    private PostService postService;

    // GET /api/posts/{id} - Get a post by id
    @GetMapping("/{id}")
    public ResponseEntity<Post> getPostById(@PathVariable Long id) {
        Post post = postService.getPostById(id);
        return ResponseEntity.ok(post);
    }

    // 기타 CRUD 엔드포인트들...
}

 

반응형
반응형

스프링 시큐리티 및 JWT 를 활용하기 위해 결국 유저정보를 저장하는 DB 가 있어야 합니다.


아래 글과 겹치는 부분 있을 수 있으니 먼저 확인해보세요. 아래 포스트는 디비 없이 하드코딩으로 user 와 password 를 설정했습니다.
https://juntcom.tistory.com/249 

 

spring security 와 jwt 를 이용한 인증 인가(spring boot3)

• Spring Security는 Spring 기반 애플리케이션의 보안을 제공하는 강력하고, 유연한 프레임워크입니다.특징  • 인증(Authentication)과 인가(Authorization) 기능 제공 • 다양한 보안 공격 방어 (CSRF, XSS 등)

juntcom.tistory.com

 

회원 테이블

CREATE TABLE users (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) UNIQUE NOT NULL,
    password VARCHAR(100) NOT NULL,
    enabled BOOLEAN NOT NULL,
    authority VARCHAR(50) NOT NULL
);

user 테이블과

authority 권한 테이블을 정규화 해서 나눌 수도 있지만 한 유저당 여러권한이 없다고 보는게 낫고 예시를 위해 한 테이블로 진행하려고 합니다. 

 

Entity Class

@Setter
@Getter
@Entity
@Table(name = "users")
public class User {

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

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    private boolean enabled;

    @Column(nullable = false)
    private String authority;

}

 

 

CustomUserDetailsService 

UserDetailsService 를 implements 해야 합니다. 

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Autowired
    private UserRepository userRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("User not found");
        }

        return new org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(),
                user.isEnabled(), true, true, true,
                Collections.singletonList(new SimpleGrantedAuthority(user.getAuthority())));
    }
}

UserRepository

package com.junt.studybasic.repository;

import com.junt.studybasic.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

 

Security 

package com.junt.studybasic.config;

import com.junt.studybasic.filter.JwtRequestFilter;
import com.junt.studybasic.service.CustomUserDetailsService;
import com.junt.studybasic.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
public class SecurityConfig {

    @Autowired
    private JwtRequestFilter jwtRequestFilter;

    @Autowired
    private CustomUserDetailsService customUserDetailsService;

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        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 AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration) throws Exception {
        return authenticationConfiguration.getAuthenticationManager();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

 

Login Controller 

package com.junt.studybasic.controller;

import com.junt.studybasic.util.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.web.bind.annotation.*;

@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;
    }
}

class AuthRequest {
    private String username;
    private String password;

    // Getters and Setters
}

 

 

회원가입 API

UserService

package com.junt.studybasic.service;

import com.junt.studybasic.entity.User;
import com.junt.studybasic.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private PasswordEncoder passwordEncoder;

    public User registerNewUser(String username, String password, String authority) {
        User user = new User();
        user.setUsername(username);
        user.setPassword(passwordEncoder.encode(password));
        user.setEnabled(true);
        user.setAuthority(authority);
        return userRepository.save(user);
    }
}

 

AuthController

 

package com.junt.studybasic.controller;

import com.junt.studybasic.entity.User;
import com.junt.studybasic.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/auth")
public class AuthController {

    @Autowired
    private UserService userService;

    @PostMapping("/register")
    public User registerUser(@RequestBody RegisterRequest registerRequest) {
        return userService.registerNewUser(
                registerRequest.getUsername(),
                registerRequest.getPassword(),
                registerRequest.getAuthority()
        );
    }
}

@Getter
@Setter
class RegisterRequest {
    private String username;
    private String password;
    private String authority;

}

 

 

JwtUtil

@Component
public class JwtUtil {

    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));
    }
}

 

JwtRequestFilter

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Autowired
    private JwtUtil jwtUtil;

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

        final String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            if (jwtUtil.validateToken(jwt, userDetails)) {

                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

 

참고

유저 권한에 따라 코드를 다르게 실행하는 방법

1. 메서드 수준의 보안 애노테이션 사용

 

Spring Security는 메서드 수준에서 접근 제어를 지원하는 몇 가지 애노테이션을 제공합니다. 가장 일반적인 애노테이션은 @PreAuthorize@Secured입니다.

1.1 @PreAuthorize 애노테이션 사용

 

@PreAuthorize 애노테이션을 사용하면 메서드 호출 전에 표현식을 평가하여 접근을 제어할 수 있습니다. 이를 위해 @EnableGlobalMethodSecurity(prePostEnabled = true)를 설정해야 합니다.

package com.junt.studybasic.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class MethodSecurityConfig {
    // 추가 설정이 필요 없다면 이 클래스는 비어 있어도 됩니다.
}

서비스 클래스 예시

package com.junt.studybasic.service;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public void adminOnlyMethod() {
        // 관리자 전용 메서드 로직
    }

    @PreAuthorize("hasAnyRole('ROLE_USER', 'ROLE_ADMIN')")
    public void userOrAdminMethod() {
        // 사용자 또는 관리자 접근 가능 메서드 로직
    }
}

 

2. Spring Security 권한 검사 API 사용

 

Spring Security의 권한 검사 API를 사용하여 프로그램 내에서 동적으로 권한을 검사할 수도 있습니다.

 

2.1 SecurityContextHolder를 사용한 권한 검사

@Service
public class MyService {

    public void performActionBasedOnRole() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        if (authentication.getAuthorities().contains(new SimpleGrantedAuthority("ROLE_ADMIN"))) {
            // 관리자 전용 로직
        } else if (authentication.getAuthorities().contains(new SimpleGrantedAuthority("ROLE_USER"))) {
            // 사용자 전용 로직
        } else {
            // 기타 권한 로직
        }
    }
}

 

3. 컨트롤러에서 권한에 따라 다른 로직 수행

 

Spring MVC 컨트롤러에서도 @PreAuthorize를 사용할 수 있습니다.

 

3.1 컨트롤러에서의 예시

package com.junt.studybasic.controller;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/admin")
    @PreAuthorize("hasRole('ROLE_ADMIN')")
    public String adminEndpoint() {
        return "관리자 전용 페이지";
    }

    @GetMapping("/user")
    @PreAuthorize("hasRole('ROLE_USER')")
    public String userEndpoint() {
        return "사용자 전용 페이지";
    }

    @GetMapping("/common")
    @PreAuthorize("hasAnyRole('ROLE_USER', 'ROLE_ADMIN')")
    public String commonEndpoint() {
        return "모든 사용자 접근 가능 페이지";
    }
}

 

요약

 

메서드 수준 보안 애노테이션: @PreAuthorize@Secured를 사용하여 메서드 접근 제어.

권한 검사 API: SecurityContextHolder를 사용하여 동적으로 권한 검사.

컨트롤러에서 권한 검사: @PreAuthorize를 사용하여 요청 핸들러 접근 제어.

템플릿 엔진에서 권한 검사: Thymeleaf를 사용하여 동적으로 UI 요소 표시.

 
반응형
반응형

프링 부트에서 의존성 주입(DI, Dependency Injection)은 주로 세 가지 방식으로 이루어집니다: 생성자 주입, 수정자 주입, 필드 주입. 각각의 방법에 대한 코틀린 예시를 제공하겠습니다.

 

1. 생성자 주입(Constructor Injection)

 

생성자 주입은 가장 권장되는 방법으로, 클래스의 의존성을 생성자를 통해 주입하는 방식입니다.

 

예시: 생성자 주입

package com.example.demo.service

import org.springframework.stereotype.Service

@Service
class GreetingService {
    fun greet(name: String): String {
        return "Hello, $name!"
    }
}

 

 
package com.example.demo.controller

import com.example.demo.service.GreetingService
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class GreetingController(private val greetingService: GreetingService) {

    @GetMapping("/greet")
    fun greet(@RequestParam name: String): String {
        return greetingService.greet(name)
    }
}

2. 수정자 주입(Setter Injection)

 

수정자 주입은 의존성을 수정자 메서드(Setter)를 통해 주입하는 방식입니다.

package com.example.demo.controller

import com.example.demo.service.GreetingService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class GreetingController {

    private lateinit var greetingService: GreetingService

    @Autowired
    fun setGreetingService(greetingService: GreetingService) {
        this.greetingService = greetingService
    }

    @GetMapping("/greet")
    fun greet(@RequestParam name: String): String {
        return greetingService.greet(name)
    }
}

여기서 GreetingController 클래스는 setGreetingService 메서드를 통해 GreetingService를 주입받습니다. 이 방법은 주입할 의존성이 선택적일 때 유용할 수 있습니다.

 

3. 필드 주입(Field Injection)

 

필드 주입은 의존성을 클래스의 필드에 직접 주입하는 방식입니다.

 

예시: 필드 주입

package com.example.demo.controller

import com.example.demo.service.GreetingService
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController

@RestController
class GreetingController {

    @Autowired
    private lateinit var greetingService: GreetingService

    @GetMapping("/greet")
    fun greet(@RequestParam name: String): String {
        return greetingService.greet(name)
    }
}

정리

 

생성자 주입: 가장 권장되는 방법으로, 변경 불가능하고 테스트가 용이합니다.

수정자 주입: 선택적 의존성을 주입할 때 유용합니다.

필드 주입: 간단하지만, 테스트와 유지보수가 어렵고 권장되지 않습니다.

반응형
반응형

Spring Security는 Spring 기반 애플리케이션의 보안을 제공하는 강력하고, 유연한 프레임워크입니다.

특징

 

인증(Authentication)과 인가(Authorization) 기능 제공

다양한 보안 공격 방어 (CSRF, XSS 등)

확장 가능하고 커스터마이징이 용이

 

 

프로젝트 라이브러리

build.gradle

    implementation 'org.springframework.boot:spring-boot-starter-security'
    implementation 'io.jsonwebtoken:jjwt-api:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.2'
    runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.2'

spring security 뿐 아니라 API 에서 jwt 토큰을 인증 및 인가 하는 기능을 사용하려면 jsonwebtoken 라이브러리도 추가하여야 한다. 

 

인증 개념

(Authentication)

인증은 사용자의 신원을 확인하는 과정입니다.

 

인가 개념

(Authorization)

인가는 사용자가 특정 리소스에 접근할 수 있는 권한이 있는지 확인하는 과정입니다.

 

JwtRequestFilter

@Component
public class JwtRequestFilter extends OncePerRequestFilter {

    private UserDetailsService userDetailsService;
    private JwtUtil jwtUtil;
    @Autowired
    public void setUserDetailsService(UserDetailsService userDetailsService) {
        this.userDetailsService = userDetailsService;
    }

    @Autowired
    public void setJwtUtil(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }

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

        final String authorizationHeader = request.getHeader("Authorization");

        String username = null;
        String jwt = null;

        if (authorizationHeader != null && authorizationHeader.startsWith("Bearer ")) {
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }

        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

            if (jwtUtil.validateToken(jwt, userDetails)) {

                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
            }
        }
        chain.doFilter(request, response);
    }
}

 

JwtUtil

@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;
}

 

 

로그인시 

curl --location 'http://localhost:8080/api/auth/login' \
--header 'Content-Type: application/json' \
--data '{
"username": "user",
"password": "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 필터 추가.

권한 규칙 작성: anyRequest().permitAll() 설정과 EnableGlobalMethodSecurity 설정.

Exception Handler 추가: 인증과 인가 실패 시 처리할 핸들러 정의.

반응형
반응형

JPA (Java Persistence API)

 

정의: JPA는 자바 애플리케이션에서 객체 관계 매핑(ORM)을 위한 표준 명세입니다.

주요 특징:

ORM 제공: 객체를 관계형 데이터베이스 테이블과 매핑합니다.

표준화: JPA는 여러 구현체 (예: Hibernate, EclipseLink) 간의 표준을 제공합니다.

애너테이션: 엔티티 클래스에 애너테이션을 사용하여 매핑을 정의합니다.

EntityManager: JPA의 핵심 인터페이스로, 데이터베이스 작업을 관리합니다.

장점:

코드와 데이터베이스 간의 간단한 매핑을 제공합니다.

여러 데이터베이스 벤더에 대한 추상화를 제공합니다.

단점:

복잡한 쿼리 작성이 어렵고, 특히 동적 쿼리에서는 제한적입니다.

 

JPQL (Java Persistence Query Language)

 

정의: JPQL은 JPA에서 제공하는 객체 지향 쿼리 언어입니다.

주요 특징:

객체 지향 쿼리: SQL과 비슷하지만, 테이블이 아닌 엔티티 객체를 대상으로 합니다.

엔티티 기반: 데이터베이스 테이블이 아닌 엔티티 클래스와 속성에 대해 쿼리합니다.

표준 쿼리 언어: JPA 표준의 일부로, 모든 JPA 구현체에서 지원됩니다.

장점:

JPA와 통합되어 있어 일관된 API를 제공합니다.

SQL과 유사하지만 객체 지향적인 쿼리를 작성할 수 있습니다.

단점:

복잡한 동적 쿼리 작성에 한계가 있습니다.

정적 쿼리에 적합하며, 동적 쿼리의 경우 문자열 조작이 필요합니다.

@Query("SELECT " +
            " blog  " +
            "FROM TbBlog blog " +
            "WHERE blog.isUse = UseYn.Y " +
            "AND blog.point > 0 " +
            "AND blog.writeType != 'INFO' " +
            "ORDER BY " +
            " blog.issuedType ASC" )
List<TbBlog> findBlogList();

QueryDSL

 

정의: QueryDSL은 Java에서 타입 안전한 SQL-like 쿼리를 작성하기 위한 프레임워크입니다.

주요 특징:

타입 안전성: 컴파일 시점에 쿼리의 유효성을 검사합니다.

동적 쿼리: 복잡한 동적 쿼리를 쉽게 작성할 수 있습니다.

플루언트 API: 메서드 체이닝을 통해 직관적이고 가독성 높은 쿼리를 작성할 수 있습니다.

지원되는 언어: JPA, SQL, MongoDB, Lucene 등 다양한 백엔드를 지원합니다.

장점:

컴파일 시점에 쿼리의 유효성을 검사하여 오류를 줄입니다.

복잡한 동적 쿼리를 간단하게 작성할 수 있습니다.

IntelliJ와 같은 IDE에서 자동 완성을 지원하여 생산성을 높입니다.

단점:

초기 설정이 복잡할 수 있습니다.

JPA와의 통합을 위해 추가적인 설정과 코드가 필요합니다.


예시

public List<TbBlog> findBlogList() {
        JPAQueryFactory queryFactory = new JPAQueryFactory(em);
        return queryFactory.selectFrom(tbBlog)
                .where(
                        tbBlog.isUse.eq(UseYn.Y),
                        tbBlog.point.gt(0),
                        tbBlog.writeType.ne("INFO")
                )
                .orderBy(
                        tbBlog.regDt.asc() 
                )
                .fetch();
    }



요약

 

JPA는 Java 애플리케이션에서 ORM을 위한 표준 명세로, 데이터베이스와 객체를 매핑합니다.

JPQL은 JPA에서 제공하는 객체 지향 쿼리 언어로, SQL과 유사하지만 엔티티 객체를 대상으로 합니다.

QueryDSL은 타입 안전한 SQL-like 쿼리를 작성하기 위한 프레임워크로, 동적 쿼리를 작성할 때 특히 유용합니다.

반응형
반응형

 

mysql 간단한 blog 테이블 만들기

-- mydb.tb_blog definition

CREATE TABLE mydb.tb_blog (
	blog_id BIGINT auto_increment NOT NULL,
	blog_title varchar(100) NOT NULL,
	blog_content varchar(100) NOT NULL,
	reg_dt DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
	upd_dt DATETIME DEFAULT CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP NOT NULL,
	PRIMARY KEY (`blog_id`)
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8mb4
COLLATE=utf8mb4_0900_ai_ci;

 

 

spring jpa 라이브러리 추가

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.mysql:mysql-connector-j'
    ...
}

 

entity 생성

@Getter
@Setter
@Entity
@Table(name="tb_blog")
public class TbBlog {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long blogId;

    @Column(nullable = false, length = 100)
    private String blogTitle;

    @Column(name = "blog_content", nullable = false, length = 100)
    private String blogContent;

    @CreationTimestamp
    @Column(updatable = false)
    private LocalDateTime regDt;

    @UpdateTimestamp
    @Column
    private LocalDateTime updDt;
}

 

@Respository 생성

@Repository
public interface TbBlogRepository extends JpaRepository<TbBlog, Long> {


}


dto 클래스 생성

@Setter
@Getter
public class BlogReq {

    private Long blogId;
    private String blogTitle;
    private String blogContent;
}

create 메소드 

public TbBlog createBlog(BlogReq req) {
    TbBlog tbBlog = new TbBlog();
    tbBlog.setBlogTitle(req.getBlogTitle());
    tbBlog.setBlogContent(req.getBlogContent());

    return tbBlogRepository.save(tbBlog); // 생성된 로또 번호 Set 반환
}

 

update 메소드

public TbBlog updateBlog(BlogReq req) {
    TbBlog tbBlog = new TbBlog();
    tbBlog.setBlogId(req.getBlogId());
    tbBlog.setBlogTitle(req.getBlogTitle());
    tbBlog.setBlogContent(req.getBlogContent());

    return tbBlogRepository.save(tbBlog); // 생성된 로또 번호 Set 반환
}

 

test 용 전체 데이터 조회 메소드

public List<TbBlog> getListAll() {
    return tbBlogRepository.findAll();
}

 

특정 id 를 조회하는 메소드 

public TbBlog getBlogId(Long blogId) {
    Optional<TbBlog> blog = tbBlogRepository.findById(blogId);
    return blog.get(); // 생성된 로또 번호 Set 반환
}

/**
 * Optional.isPresent() 메서드를 사용하여 값이 존재하는지 확인한 후에 값을 처리하는 방법입니다.
 */
public TbBlog getBlogByIdV1(Long blogId) {
    Optional<TbBlog> blog = tbBlogRepository.findById(blogId);
    if (blog.isPresent()) {
        return blog.get();
    } else {
        // 값이 없을 경우 예외를 던지거나 다른 처리를 합니다.
        throw new BlogNotFoundException("Blog not found with id: " + blogId);
    }
}

/**
 * orElse() 메서드 사용
 * Optional에 값이 없을 경우 기본 값을 반환하는 방법입니다.
 */
public TbBlog getBlogByIdV2(Long blogId) {
    Optional<TbBlog> blog = tbBlogRepository.findById(blogId);
    return blog.orElse(null); // 또는 적절한 기본값을 설정할 수 있습니다.
}

/**
 * orElseThrow() 메서드 사용
 * Optional에 값이 없을 경우 예외를 던지는 방법입니다.
 */
public TbBlog getBlogByIdV3(Long blogId) {
    return tbBlogRepository.findById(blogId)
            .orElseThrow(() -> new BlogNotFoundException("Blog not found with id: " + blogId));
}

Exception 클래스 추가 

public class BlogNotFoundException extends RuntimeException {
    public BlogNotFoundException(String message) {
        super(message);
    }
}

 


Optional 이라는 메소드

Optional은 Java 8에서 도입된 유틸리티 클래스입니다. 이 클래스는 주어진 값이 존재할 수도 있고, 존재하지 않을 수도 있는 상황을 처리하기 위한 도구입니다. Optional은 널(null) 참조로 인한 NullPointerException을 피하고, 더 명확하고 안전한 코드를 작성하는 데 도움이 됩니다.

controller 참고하세요

@Slf4j
@RestController
@RequiredArgsConstructor
@RequestMapping("/blog")
public class BlogController {

    private final BlogService blogService;


    @GetMapping(value = "/list-all")
    public ResponseEntity<Object> getBlogList() {
        return ResponseEntity.ok(blogService.getListAll());
    }

    @GetMapping(value = "/detail/{blogId}")
    public ResponseEntity<Object> getBlogDetail(
            @PathVariable Long blogId
    ) {
        return ResponseEntity.ok(blogService.getListAll());
    }


    @PostMapping(value = "/create")
    public ResponseEntity<Object> postBlog(BlogReq req) {
        return ResponseEntity.ok(blogService.createBlog(req));
    }

    @PutMapping(value = "/update/{blogId}")
    public ResponseEntity<Object> putBlog(
                BlogReq req) {
        return ResponseEntity.ok(blogService.updateBlog(req));
    }
}

 

반응형
반응형

JPA 란

JPA(Java Persistence API)는 자바 애플리케이션에서 관계형 데이터베이스와 객체 간의 매핑을 관리하는 표준 API입니다.

 

객체-관계 매핑(Object-Relational Mapping, ORM): 객체 지향 프로그래밍의 객체를 관계형 데이터베이스의 테이블에 매핑.

표준 인터페이스: JPA는 인터페이스를 제공하고, Hibernate, EclipseLink 등의 구현체를 통해 사용할 수 있음.

데이터베이스 독립성: 코드 변경 없이 다양한 데이터베이스에서 동작.

 

하이버네이트란

Hibernate는 자바 환경에서 객체 관계 매핑(Object-Relational Mapping, ORM) 프레임워크입니다. 이를 통해 자바 객체와 관계형 데이터베이스 간의 변환을 자동화할 수 있습니다. Hibernate는 JPA(Java Persistence API)의 주요 구현체 중 하나로, 객체 지향적인 방식으로 데이터베이스 작업을 수행할 수 있도록 도와줍니다.

 

1. 객체-관계 매핑 (ORM):

Hibernate는 자바 객체를 데이터베이스 테이블에 매핑하여, 객체 지향 프로그래밍과 관계형 데이터베이스의 패러다임을 연결합니다.

2. 자동화된 CRUD 작업:

Hibernate는 기본적인 CRUD(Create, Read, Update, Delete) 작업을 자동으로 처리합니다. 이를 통해 개발자는 SQL 쿼리를 직접 작성하지 않아도 됩니다.

3. 데이터베이스 독립성:

Hibernate는 다양한 데이터베이스를 지원하며, 데이터베이스에 종속되지 않는 코드를 작성할 수 있게 도와줍니다.

4. HQL (Hibernate Query Language):

SQL과 유사한 쿼리 언어를 제공하여 객체를 대상으로 쿼리를 작성할 수 있습니다.

5. 캐싱:

Hibernate는 1차 캐시(세션 수준 캐시)와 2차 캐시(전역 캐시)를 지원하여 데이터베이스 액세스를 최적화합니다.

6. 트랜잭션 관리:

Hibernate는 트랜잭션 관리를 지원하여 데이터 일관성과 무결성을 유지할 수 있도록 합니다.

 

 

 

jpa 사용방법

라이브러리 추가

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
}

 

Entity 정의

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private double price;

    // Getters and Setters
}

 

Repository 정의

import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
}

 

Service 클래스에서 사용

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;

    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    public Product saveProduct(Product product) {
        return productRepository.save(product);
    }
}

 

JPA와 JDBC의 관계

JPA를 사용하면 일반적으로 직접적인 JDBC 라이브러리를 사용할 필요가 없습니다. JPA는 JDBC를 추상화하여 객체 지향적인 방식으로 데이터베이스와 상호작용할 수 있게 해주기 때문입니다. 그러나 JPA는 내부적으로 JDBC를 사용하여 데이터베이스와 통신합니다.

 

JPA와 JDBC의 관계

 

JPA: Java Persistence API는 자바 객체를 관계형 데이터베이스의 테이블에 매핑하는 프레임워크입니다. 개발자는 객체 지향적인 방식으로 데이터베이스 작업을 수행할 수 있습니다.

JDBC: Java Database Connectivity는 자바에서 데이터베이스에 접속하고 SQL 쿼리를 실행하기 위한 API입니다. JDBC는 데이터베이스와의 저수준 통신을 처리합니다.

 

JPA는 내부적으로 JDBC를 사용하지만, 개발자가 직접 JDBC 코드를 작성할 필요는 없습니다. 대신 JPA의 리포지토리, 엔터티 매니저 등을 사용하여 데이터베이스 작업을 처리합니다.

 

JDBC 예제

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class Product {
    private Long id;
    private String name;
    private double price;

    // Getters and Setters
}

public class ProductDAO {
    private String jdbcURL = "jdbc:h2:mem:testdb";
    private String jdbcUsername = "sa";
    private String jdbcPassword = "password";

    private static final String INSERT_PRODUCTS_SQL = "INSERT INTO products (name, price) VALUES (?, ?)";
    private static final String SELECT_ALL_PRODUCTS = "SELECT * FROM products";

    public ProductDAO() {}

    protected Connection getConnection() {
        Connection connection = null;
        try {
            connection = DriverManager.getConnection(jdbcURL, jdbcUsername, jdbcPassword);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return connection;
    }

    public void insertProduct(Product product) {
        try (Connection connection = getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(INSERT_PRODUCTS_SQL)) {
            preparedStatement.setString(1, product.getName());
            preparedStatement.setDouble(2, product.getPrice());
            preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public List<Product> selectAllProducts() {
        List<Product> products = new ArrayList<>();
        try (Connection connection = getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(SELECT_ALL_PRODUCTS)) {
            ResultSet rs = preparedStatement.executeQuery();
            while (rs.next()) {
                Long id = rs.getLong("id");
                String name = rs.getString("name");
                double price = rs.getDouble("price");
                products.add(new Product(id, name, price));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return products;
    }
}

public class ProductService {
    private ProductDAO productDAO = new ProductDAO();

    public List<Product> getAllProducts() {
        return productDAO.selectAllProducts();
    }

    public void saveProduct(Product product) {
        productDAO.insertProduct(product);
    }
}

public class ProductController {
    private ProductService productService = new ProductService();

    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    public void saveProduct(Product product) {
        productService.saveProduct(product);
    }
}

 

 

요약

 

JPA 사용: JPA는 내부적으로 JDBC를 사용하지만, 개발자가 직접 JDBC 코드를 작성할 필요가 없습니다. JPA의 엔터티, 리포지토리, 서비스 계층을 통해 데이터베이스 작업을 쉽게 수행할 수 있습니다.

JDBC 사용: JDBC는 저수준의 데이터베이스 접근 방법으로, 개발자가 직접 SQL 쿼리와 데이터베이스 연결을 관리해야 합니다.

 

따라서 JPA를 사용하면 직접적인 JDBC 라이브러리 사용을 피할 수 있으며, 코드의 유지보수성과 생산성을 높일 수 있습니다.

반응형
반응형

스프링과 스프링부트 차이 (spring vs spring boot)

1. 설정 및 구성:

스프링: 스프링 프레임워크는 다양한 기능을 제공하지만, 이를 설정하는 데 많은 XML 구성 파일이나 Java 설정 클래스가 필요합니다. 개발자가 직접 빈(bean)을 정의하고 연결해야 하므로 초기 설정이 복잡할 수 있습니다.

스프링부트: 스프링부트는 자동 설정(autoconfiguration)을 통해 대부분의 설정 작업을 자동화합니다. 기본적인 프로젝트 설정과 함께 필요한 대부분의 의존성을 자동으로 구성해주기 때문에 설정 작업이 크게 줄어듭니다.

2. 프로젝트 구조 및 시작:

스프링: 스프링 프로젝트를 시작하려면 각종 라이브러리를 수동으로 추가하고 설정해야 합니다. 초기 세팅에 많은 시간이 걸릴 수 있습니다.

스프링부트: 스프링부트는 스타터 프로젝트(starter project) 개념을 도입하여 필요한 라이브러리를 쉽게 추가하고 설정할 수 있게 합니다. Spring Initializr와 같은 도구를 통해 몇 번의 클릭만으로 프로젝트를 생성할 수 있습니다.

3. 내장 서버:

스프링: 스프링에서는 애플리케이션을 실행하기 위해 별도의 서버(Tomcat, Jetty 등)를 설치하고 설정해야 합니다.

스프링부트: 스프링부트는 내장된 톰캣(Tomcat), 제티(Jetty), 언더토우(Undertow) 서버를 제공하여 별도의 서버 설치 없이 애플리케이션을 바로 실행할 수 있습니다.

4. 개발 생산성:

스프링: 강력하고 유연한 기능을 제공하지만, 설정과 구성이 복잡할 수 있어 초기 학습 곡선이 가파를 수 있습니다.

스프링부트: 설정의 단순화와 자동 구성을 통해 개발 생산성을 크게 향상시켜 줍니다. 코드 작성을 더 빠르고 간단하게 만들기 때문에 빠른 프로토타이핑과 개발이 가능합니다.

 

 

스프링 war 배포 vs 스프링부트 jar 배포

스프링(Spring) 애플리케이션을 사용할 때, 전통적으로 WAR 파일을 사용하여 배포하는 것이 일반적이었습니다. 이는 특히 스프링이 처음 등장했던 시절부터 많이 사용되었던 방식입니다. 하지만 최근 몇 년 동안 스프링부트(Spring Boot)의 등장으로 인해 JAR 파일로 배포하는 방식이 더 인기를 끌고 있습니다.

 

전통적인 스프링 애플리케이션과 WAR 파일

 

1. WAR 파일 사용 이유:

서버 배포: 전통적인 스프링 애플리케이션은 Tomcat, Jetty, JBoss 등과 같은 웹 애플리케이션 서버에 배포되었습니다. 이 서버들은 WAR 파일을 배포 유닛으로 사용합니다.

관리 및 스케일링: 여러 애플리케이션을 하나의 서버에서 관리하고 스케일링할 수 있는 장점이 있습니다.

2. WAR 파일 배포 과정:

애플리케이션 코드를 작성하고, 이를 WAR 파일로 패키징합니다.

WAR 파일을 웹 애플리케이션 서버의 특정 디렉토리에 배포합니다.

서버가 WAR 파일을 인식하고 애플리케이션을 실행합니다.

 

스프링부트와 JAR 파일

 

스프링부트는 전통적인 스프링 애플리케이션의 복잡성을 줄이고, 보다 단순하게 애플리케이션을 개발하고 배포할 수 있게 도와줍니다. 이 과정에서 JAR 파일 배포가 주로 사용됩니다.

 

1. JAR 파일 사용 이유:

독립 실행형 애플리케이션: 스프링부트는 내장 톰캣(Tomcat) 등을 포함하여 JAR 파일 형태로 패키징되므로, 별도의 웹 애플리케이션 서버 없이 독립적으로 실행할 수 있습니다.

간편한 배포: JAR 파일 하나로 애플리케이션을 쉽게 배포하고 실행할 수 있어 배포 과정이 단순화됩니다.

2. JAR 파일 배포 과정:

애플리케이션 코드를 작성하고, 이를 JAR 파일로 패키징합니다.

java -jar myapp.jar 명령어로 애플리케이션을 실행합니다.

 

결론

 

전통적인 스프링 애플리케이션: 주로 WAR 파일을 사용하여 웹 애플리케이션 서버에 배포.

스프링부트 애플리케이션: 주로 JAR 파일을 사용하여 독립 실행형 애플리케이션으로 배포.

반응형

+ Recent posts