[Spring Boot] 프로젝트 구성방법

내가 이해하기 편하려고 적어놓기!!
DAO 또는 Repository  에 있는 내용을 Service 가 불러와서 작성

Service 의 내용을 Controller가 불러와서 작성

 

Configuration: 애플리케이션의 설정 파일과 클래스들을 관리하는 패키지로, 주로 Spring 설정 파일이나 Bean 정의 등을 포함한다. 

예시) CORS 설정, 뷰 리졸버 설정, 인터셉터 등록, xml설정, bean설정

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    // 설정 코드 (예: CORS 설정, 리소스 핸들러 등)
}

 

 

 

https://dambi1224.tistory.com/51

[Spring Boot] Bean이란?

 

https://dambi1224.tistory.com/57

CORS란?

 

 

Controller : 클라이언트 요청을 처리하고, 서비스 계층을 호출하여 비즈니스 로직을 수행한 후, 결과를 반환하는 역할을 한다. HTTP 요청을 처리하는 컨트롤러 클래스로 요청 경로에 따라 서비스 메서드를 호출하고, 응답을 반환한다.

예시) URL 매핑, 요청 처리 로직, 서비스 호출, 응답 반환

 

@RestController
@RequestMapping("/users")
public class UserController {
    // 사용자 관련 요청 처리 메서드
}

 

 

 

Service : 비즈니스 로직을 처리하는 계층으로, 주로 트랜잭션을 관리하고 여러 DAO를 호출하여 작업을 수행한다. Controller와 Repository 사이에서 중간 다리 역할을 하며, 여러 리포지토리 호출이나 다른 서비스 호출을 조합하여 비즈니스 규칙을 구현한다.

예시)

1. UserService.java: 사용자 등록, 수정, 삭제 등의 비즈니스 로직을 처리한다. 필요한 경우 여러 리포지토리를 호출하여 데이터를 조합하거나 가공한다.
2. OrderService.java: 주문 생성, 조회, 수정, 취소 등의 비즈니스 로직을 처리한다. 필요에 따라 여러 리포지토리를 호출하여 데이터를 조합하거나 가공한다.
3. ProductService.java: 제품 등록, 수정, 삭제, 조회 등의 비즈니스 로직을 처리한다.

@Service
public class UserService {
    // 사용자 관련 비즈니스 로직
}

 

 

Repository :  데이터베이스 접근을 담당하는 계층으로, Spring Data JPA를 사용하여 CRUD 작업을 수행한다. 리포지토리 파일에는 엔티티 객체와 데이터베이스 간의 매핑 설정, 기본적인 CRUD 메서드 정의 등이 포함된다. 주로 Spring Data JPA의 인터페이스를 확장한다.

예시) UserRepository.java: JPA 인터페이스를 확장하여 사용자 데이터에 대한 기본 CRUD 메서드를 제공하는 클래스다. 예를 들어, findById, save, delete와 같은 메서드가 정의된다.

public interface UserRepository extends JpaRepository<User, Long> {
    // 사용자 데이터베이스 쿼리 메서드
}

DAO :  데이터베이스와의 직접적인 상호작용을 담당하는 객체이다. Spring Data JPA를 사용할 경우 Repository가 DAO 역할을 대신할 수 있다. repository와 비슷하지만, 더 복잡한 쿼리 로직을 포함할 수 있다.

예시) UserDAO.java: 사용자 데이터에 대한 CRUD (Create, Read, Update, Delete) 작업을 SQL 쿼리로 직접 수행하는 클래스이다.

public class UserDAO {
    // 사용자 데이터베이스 접근 로직
}

 

---

Repository 와 DAO 의 공통점

 

1. 데이터 접근 : 데이터베이스와의 상호작용을 담당하는 계층으로 데이터베이스 CRUD(Create, Read, Update, Delete) 작업을 수행한다.
2. 추상화 : 데이터 접근 로직을 추상화하여 비즈니스 로직(Service 계층)과 데이터 접근 로직을 분리한다. 이는 코드의 가독성과 유지보수성을 높일 수 있다.
3. 인터페이스 사용 : 인터페이스를 사용하여 데이터 접근 메서드를 정의한다. DAO는 보통 인터페이스와 그 구현 클래스를 사용하고, Repository는 스프링 데이터 JPA가 제공하는 인터페이스를 사용한다.

 

 

Repository 와 DAO 의 차이점

 

1. 구현 방식

▷ DAO 
* 직접 SQL 쿼리나 ORM 매핑을 작성해야 한다.
* JDBC, Hibernate 등의 프레임워크를 사용하여 구현한다.
* 구현 클래스가 필요하다.

public interface UserDao {
    User findById(Long id);
    void save(User user);
    void update(User user);
    void delete(Long id);
}

public class UserDaoImpl implements UserDao {
    // JDBC or Hibernate logic here
}

 

▷ Repository 

* 스프링 데이터 JPA가 제공하는 인터페이스를 확장하여 사용한다.
* 기본적인 CRUD 메서드는 자동으로 구현된다.
* 복잡한 쿼리는 메서드 이름을 기반으로 자동 생성되거나 @Query 애노테이션을 사용하여 정의할 수 있다.
* 직접 구현 클래스가 필요하지 않다.

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByEmail(String email);
}

 

 

2. 자동화

▷ DAO 
개발자가 직접 구현해야 하며, 반복적인 코드 작성이 필요하다.
쿼리 작성, 결과 매핑 등 많은 수작업이 필요하다.

 

▷ Repository 

스프링 데이터 JPA가 자동으로 구현 클래스를 생성한다.
기본 CRUD 작업을 위한 메서드들이 자동으로 제공된다.
코드 작성이 간편하고 반복적인 작업이 줄어든다.

3. 통합 및 확장성
▷ DAO 
특정 데이터베이스나 ORM 프레임워크에 종속적이다.
다양한 데이터 소스를 통합하는데 추가적인 노력이 필요하다.

▷ Repository 
스프링 데이터 JPA의 일관된 접근 방식을 사용하여 다양한 데이터 소스(JPA, MongoDB, Cassandra 등)에 접근할 수 있다.
일관된 인터페이스와 확장성 있는 구조를 제공한다.

 

 

결론 : 스프링부트 환경에서는 Repository 패턴을 사용하는 것이 더 효율적이며, 반복적인 코드 작성을 줄이고 유지보수성을 높이는 데 유리하다.

---

DTO (Data Transfer Object) : 데이터를 전송하는 객체로, 주로 계층 간 데이터 교환을 위해 사용된다. DTO는 데이터베이스와의 상호작용과는 무관하며, 주로 서비스 계층과 프레젠테이션 계층 사이에서 데이터를 주고받기 위해 사용된다.

▷ 특징 

* 네트워크나 프로세스 간 데이터 전송을 목적으로 사용.
* 비즈니스 로직을 포함하지 않음.
* 데이터 검증이나 변환 로직을 포함할 수 있음.
* 주로 API 응답이나 요청에 사용됨.

public class UserDTO {

    private Long id;
    private String name;
    private String email;

    // Getters and Setters
}

 

내가 이해하기 편하려고 적어놓기!!

DTO는 나라는 사람이 있다면 도서대출을 할때 필요한 양식만 적는것이다. 나라는 사람이 Entity이고, 나라는 사람은 성별 나이 이름 주민등록번호 전화번호 사는곳 키 몸무게 등등이 있는데 도서대출을 할때는 이름, 주민등록번호, 전화번호만 적으면 충분한 것이다. 그래서 대출에 필요한 양식만 빼서 적는게 DTO인 것이다. DTO는 필요한 내용만 가져다 쓸 수 있어서 Entity에 있는 여러가지 정보들 중 필요한것만 끌어다 쓸 수 있다. 

서버 <- entity -> DB

서버 <- DTO -> 사용자

 

 

VO (Value Object) : 불변성을 유지하면서 도메인 모델의 값을 표현하기 위해 사용된다. (옛날? 개념이라 잘 사용안한다고 들음 추후 더 필요하면 내용 추가할 수도!?)

▷ 특징 
* 불변 객체(immutable).
* 값 자체로 동일성을 판단(식별자가 없음).
* 주로 도메인 모델링에 사용됨.
* 상태 변경이 불가능하며, 동일한 값을 가지는 객체는 동일한 것으로 간주됨.

public class AddressVO {

    private final String street;
    private final String city;
    private final String zipCode;

    public AddressVO(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }

    // Getters (Setters는 불변성을 유지하기 위해 제공하지 않음)
}

 

Entity : 데이터베이스 테이블과 매핑되는 객체로, JPA 어노테이션을 사용하여 매핑을 정의한다. 데이터베이스와의 직접적인 상호 작용을 위해 사용된다. Entity는 데이터베이스의 행(row)을 나타내며, 식별자를 가지고 있어 데이터베이스에서 특정 레코드를 식별할 수 있다.

▷ 특징 

* 데이터베이스 테이블과 1:1 매핑.
* 식별자(ID)를 가짐.
* 영속성(persistence)을 가짐: JPA/Hibernate 같은 ORM(Object-Relational Mapping) 프레임워크와 함께 사용.
* CRUD(Create, Read, Update, Delete) 작업에 직접 사용됨.

@Entity
public class User {

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

    // Getters and Setters
}

 

Exception : 커스텀 예외 클래스를 정의하고, 글로벌 예외 처리를 담당하는 클래스들을 포함한다. 예외 발생 시 공통된 응답 형식을 제공한다.

 

예시)

1. 글로벌 예외 처리 클래스

글로벌 예외 처리 클래스는 @ControllerAdvice 어노테이션을 사용하여 애플리케이션 전역에서 발생하는 예외를 처리한다. 예외 처리 메서드는 @ExceptionHandler 어노테이션을 사용하여 특정 예외를 처리한다.

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

// 글로벌 예외처리 로직
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorDetails> handleResourceNotFoundException(ResourceNotFoundException ex, WebRequest request) {
        ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
        return new ResponseEntity<>(errorDetails, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorDetails> handleGlobalException(Exception ex, WebRequest request) {
        ErrorDetails errorDetails = new ErrorDetails(new Date(), ex.getMessage(), request.getDescription(false));
        return new ResponseEntity<>(errorDetails, HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

 

2. 커스텀 예외 클래스 

애플리케이션에서 발생하는 특정 예외를 나타내기 위해 커스텀 예외 클래스를 정의한다. 이러한 예외 클래스는 일반적으로 RuntimeException을 상속받는다.

public class ResourceNotFoundException extends RuntimeException {
    private static final long serialVersionUID = 1L;

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

 

3. 응답형식을 공통적으로 작성

에러 응답의 일관성을 위해 ErrorDetails와 같은 클래스를 정의하여 응답 형식을 통일한다.

import java.util.Date;

public class ErrorDetails {
    private Date timestamp;
    private String message;
    private String details;

    public ErrorDetails(Date timestamp, String message, String details) {
        super();
        this.timestamp = timestamp;
        this.message = message;
        this.details = details;
    }

    // Getters and setters
}

 

 

 

Util : 공통적으로 사용되는 기능을 유틸리티 클래스로 정의한다.

예시) 문자열 조작, 날짜 변환 등의 기능을 수행하는 헬퍼 메서드

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateUtils {

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public static String formatDate(Date date) {
        return dateFormat.format(date);
    }
}

Mapper : 애플리케이션에서 데이터 전송 객체(DTO)와 엔티티(Entity) 간의 변환을 관리하는 데 사용된다. 이는 특히 데이터베이스 엔티티를 클라이언트에 반환할 DTO로 변환하거나, 클라이언트로부터 받은 DTO를 데이터베이스 엔티티로 변환하는 데 유용하다. 매퍼를 사용하면 데이터 변환 로직을 집중화하고 재사용 가능하게 만들어 코드의 가독성과 유지보수성을 높일 수 있다.  MapStruct와 같은 라이브러리를 사용할 수 있다. MapStruct는 컴파일 시간에 타입 안전성을 보장하며, boilerplate 코드를 자동으로 생성하여 효율적인 개발을 지원한다.

import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper
public interface UserMapper {

    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

    UserDTO toDto(User user);

    User toEntity(UserDTO userDTO);
}

 

예시)

1. 필드 매핑 맞춤화

기본적으로 MapStruct는 같은 이름의 필드를 자동으로 매핑합니다. 이름이 다를 경우, @Mapping 어노테이션을 사용하여 매핑을 지정할 수 있다.

@Mapper
public interface UserMapper {

    @Mapping(source = "emailAddress", target = "email")
    UserDTO toDto(User user);

    @Mapping(source = "email", target = "emailAddress")
    User toEntity(UserDTO userDTO);
}

 

2. Nested Mapping

중첩된 객체의 매핑도 가능하다.

public class Address {
    private String street;
    private String city;

    // Getters and Setters
}

public class User {
    private Long id;
    private String name;
    private String email;
    private Address address;

    // Getters and Setters
}

public class UserDTO {
    private Long id;
    private String name;
    private String email;
    private String street;
    private String city;

    // Getters and Setters
}

@Mapper
public interface UserMapper {

    @Mapping(source = "address.street", target = "street")
    @Mapping(source = "address.city", target = "city")
    UserDTO toDto(User user);

    @Mapping(source = "street", target = "address.street")
    @Mapping(source = "city", target = "address.city")
    User toEntity(UserDTO userDTO);
}​

 

3. 컬렉션 및 맵 매핑

MapStruct는 컬렉션 및 맵 타입의 매핑도 지원합니다.

@Mapper
public interface UserMapper {

    List<UserDTO> toDtoList(List<User> users);

    List<User> toEntityList(List<UserDTO> userDTOs);
}

 

4. Default Methods

Java 8의 기본 메서드를 사용하여 MapStruct 인터페이스에 기본 변환 로직을 추가할 수 있다.

@Mapper
public interface UserMapper {

    UserDTO toDto(User user);

    User toEntity(UserDTO userDTO);

    default List<UserDTO> toDtoList(List<User> users) {
        return users.stream()
                    .map(this::toDto)
                    .collect(Collectors.toList());
    }
}

 

 

 

Security : 보안 관련 클래스들을 포함한다. 스프링 시큐리티(Spring Security)는 스프링 프레임워크 기반의 애플리케이션에서 인증과 권한 부여를 처리하는 강력하고 유연한 보안 프레임워크다. 스프링 시큐리티는 웹 애플리케이션 및 RESTful API의 보안을 손쉽게 설정하고 관리할 수 있게 도와준다.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/", "/home").permitAll()
                .anyRequest().authenticated()
                .and()
            .formLogin()
                .loginPage("/login")
                .permitAll()
                .and()
            .logout()
                .permitAll();
    }

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

 

 

주요 구성 요소

* Authentication (인증): 사용자의 신원을 확인하는 과정이다. 사용자 이름과 비밀번호, OAuth2 토큰 등을 통해 인증을 수행한다.

* Authorization (권한 부여): 인증된 사용자가 요청한 리소스에 접근할 수 있는지를 결정하는 과정이다. 역할 기반 접근 제어(RBAC)를 주로 사용한다.

* Filter Chain: 요청이 처리되기 전에 보안 관련 여러 필터를 통해 요청을 처리한다.

* Security Context: 인증된 사용자의 세부 정보를 포함하며, 애플리케이션 전반에서 보안 컨텍스트를 통해 사용자 정보를 접근할 수 있다.

 

 

만약, 스프링 부트 애플리케이션에 스프링 시큐리티를 사용하려면 spring-boot-starter-security 의존성을 추가해야 한다.

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

 

Event : 스프링 이벤트 시스템은 애플리케이션 컴포넌트 간의 느슨한 결합을 유지하면서 효율적으로 커뮤니케이션할 수 있는 방법을 제공한다. 비동기 이벤트 처리와 이벤트 리스너의 순서를 조정하여 복잡한 비즈니스 로직도 효율적으로 처리할 수 있다.

 

예시) 이벤트, 이벤트 퍼블리셔, 이벤트 리스너

import org.springframework.context.ApplicationEvent;

// 이벤트는 ApplicationEvent를 상속하는 클래스로 정의된다.
public class UserRegisteredEvent extends ApplicationEvent {
    private String email;

    public UserRegisteredEvent(Object source, String email) {
        super(source);
        this.email = email;
    }

    public String getEmail() {
        return email;
    }
}

 

스프링 이벤트 시스템의 구성 요소

* 이벤트(Event): 특정 상황을 나타내는 객체입니다. 일반적으로 ApplicationEvent를 상속한다.

* 이벤트 퍼블리셔(Event Publisher): 이벤트를 발생시키는 컴포넌트이다. ApplicationEventPublisher 인터페이스를 사용한다.

* 이벤트 리스너(Event Listener): 특정 이벤트를 처리하는 컴포넌트이다. @EventListener 어노테이션을 사용한다.

 

Job : 주기적으로 또는 특정 조건에서 실행되는 작업을 의미한다. 이는 배치 작업이나 스케줄링 작업을 포함한다. Spring Batch는 대용량 데이터를 효율적으로 처리할 수 있는 강력한 프레임워크이며, Spring Scheduling은 주기적인 작업을 쉽게 설정할 수 있게 해준다.

예시) 

1. Spring Batch

* Spring Batch는 대량의 데이터를 읽고, 처리하고, 쓰는 일괄 처리 작업을 구성하고 실행할 수 있는 포괄적인 배치 프레임워크다. 일반적인 Spring Batch 애플리케이션의 구조는 Job과 Step으로 구성된다.

2. Spring Scheduling 

* Spring Scheduling은 주기적인 작업을 쉽게 수행할 수 있도록 도와주는 스케줄링 기능을 제공한다. 이를 통해 Cron 표현식을 사용하거나, 고정된 간격으로 작업을 실행할 수 있다.

 

 

Filter : 서블릿 필터 인터페이스를 구현하여 요청(Request) 및 응답(Response)을 처리하는 컴포넌트이다. 필터는 클라이언트 요청이 컨트롤러에 도달하기 전에 또는 컨트롤러의 응답이 클라이언트에게 반환되기 전에 수행된다. 

 

* Filter 인터페이스: 필터는 javax.servlet.Filter 인터페이스를 구현한다.

* FilterChain: 필터 체인을 통해 다음 필터 또는 최종 목적지(서블릿, 컨트롤러 등)로 요청을 전달한다.

* 필터 매핑: 필터를 특정 URL 패턴에 매핑하여 해당 패턴에 대한 요청만 필터링할 수 있다.

예시) 로깅, 인증, 권한 부여, 압축, 인코딩, CORS 처리

 

* 로깅 필터: 요청과 응답을 로깅한다.

* 인증 필터: 요청에 포함된 인증 정보를 검사한다.

* 권한 필터: 사용자의 역할이나 권한을 검사하여 접근을 제어한다.

* 압축 필터: 응답을 압축하여 네트워크 트래픽을 줄인다.

* CORS 필터: Cross-Origin Resource Sharing을 처리한다.

 

 

 

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

public class CustomFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 필터 초기화 작업
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 요청 전 처리
        System.out.println("Request received at " + request.getRemoteAddr());

        // 다음 필터 또는 서블릿으로 요청 전달
        chain.doFilter(request, response);

        // 응답 후 처리
        System.out.println("Response sent with status " + response.getContentType());
    }

    @Override
    public void destroy() {
        // 필터 종료 작업
    }
}