[Java] Spring Web Annotation 이해하고 사용하기 -1 : 환경 구성

해당 글에서는 Spring Web에서 사용되는 주요 어노테이션 중 환경구성과 관련된 어노테이션의 종류에 대해 상세히 알아봅니다.

 
 

1) Spring Boot Web

---

💡 Spring Boot Web

- Spring Boot 프레임워크의 일부로 웹 애플리케이션을 빠르고 쉽게 구축할 수 있도록 도와주는 도구입니다.

- 내장된 웹 서버를 제공하여 웹 애플리케이션을 실행하고 관리하는 데 필요한 모든 설정을 자동으로 처리합니다. (내장된 웹 서버로 Tomcat, Jetty, Undertow와 같은 서버를 사용할 수 있습니다.)
- 이를 사용하면 간단한 설정으로 HTTP 엔드포인트를 생성하고 관리할 수 있습니다. 또한, Spring MVC와 같은 웹 프레임워크와 통합되어 효율적인 웹 애플리케이션 개발을 지원합니다.
- RESTful API, 웹 서비스, 단일 페이지 애플리케이션 등 다양한 유형의 웹 애플리케이션 개발에 적합합니다.

 

💡 [참고] Spring Boot Web을 사용하기 위한 의존성 추가

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'                   // Spring Boot Web
}

Maven Repository: org.springframework.boot » spring-boot-starter-web
 
 
 
 

1. 주요 어노테이션

---

💡 해당 글에서는 Spring Web에서 환경 구성을 위한 어노테이션에 대해 확인합니다.

 
 

어노테이션	설명
@SpringBootApplication	스프링 부트 애플리케이션의 주요 구성 요소로, 자동 구성, 구성 요소 검색 및 프로퍼티 설정을 제공합니다.
@Configuration	스프링 빈 설정을 위한 클래스임을 나타냅니다. 이 어노테이션이 지정된 클래스는 하나 이상의 @Bean 메서드를 포함할 수 있습니다.
@Bean	스프링 컨테이너에 의해 관리되는 빈 객체를 정의하는 메서드임을 나타냅니다. @Configuration 어노테이션이 지정된 클래스 내에서 사용됩니다.
@Component	스프링 관리 빈으로 등록되는 클래스임을 나타냅니다. 일반적으로 의존성 주입(Dependency Injection)을 위해 사용됩니다.
@Controller	스프링 MVC 애플리케이션에서 컨트롤러로 사용되는 클래스임을 나타냅니다.
@Service	스프링 애플리케이션에서 서비스 클래스임을 나타냅니다.
@Repository	스프링 애플리케이션에서 리포지토리 클래스임을 나타냅니다.
@ComponentScan	컴포넌트를 검색하여 스프링 빈으로 등록하는 데 사용됩니다. 지정된 패키지에서 @Component 어노테이션이 지정된 클래스를 검색합니다.

 

💡 [참고] 해당 어노테이션 관련하여 참고한 사이트입니다.

https://baeldung.com/spring-bean-annotations
 
 
 

2) Spring Web Annotation 주요 어노테이션 : 환경 구성

---

 

1. @SpringBootApplication

---

 💡 @SpringBootApplication

- 스프링 부트 애플리케이션의 ‘진입점’이 되는 클래스에 적용되며 Spring Boot 애플리케이션의 구성, 자동 구성 및 컴포넌트 스캔을 간편하게 설정하도록 하는 어노테이션을 의미합니다.

- 해당 어노테이션을 사용하면 세 가지 중요한 애노테이션인 @Configuration, @EnableAutoConfiguration, @ComponentScan을 한 번에 사용할 수 있습니다.

어노테이션	설명
@Configuration	- 현재 클래스를 스프링의 구성 클래스로 지정합니다. 어노테이션을 사용한 클래스내에서 Bean을 정의하고 구성하는 데 사용됩니다.
@EnableAutoConfiguration	- Spring Boot의 자동 구성을 활성화합니다. 자동 구성은 클래스 경로에서 사용 가능한 라이브러리, 설정 파일 및 기타 속성을 기반으로 애플리케이션을 구성합니다.
@ComponentScan	- 스프링이 컴포넌트 클래스를 검색하고 등록하는 데 사용됩니다. 이렇게 하면 스프링이 해당 패키지와 하위 패키지에서 컴포넌트를 찾아 스캔합니다.

 
 
 

💡 [사용예시] Spring Boot 진입점으로 사용 

- Spring Boot 애플리케이션의 시작점이 되는 main() 메서드에 이를 지정하여 사용합니다. MultiFlexApiApplication 클래스를 실행하는 역할을 합니다.

package com.adjh.multiflexapi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MultiFlexApiApplication {

    public static void main(String[] args) {
        SpringApplication.run(MultiFlexApiApplication.class, args);
    }

}

 

 
 
 
 

2. @Configuration

---

 💡 @Configuration

- @Configuration을 선언한 클래스를 ‘구성 클래스’로 선언하며, 스프링 IoC 컨테이너에게 해당 클래스가 구성 클래스로 인식하도록 하는 어노테이션을 의미합니다.

- 스프링 컨테이너에서 의존성 주입을 위한 방식 중 하나로 ‘자바 기반의 설정 파일’에서 의존성을 정의하고 주입하는 방식으로 사용됩니다.
- 의존성 주입 방식은 클래스 내에 @Configuration을 선언하고 클래스 내의 메서드에 @Bean 어노테이션을 사용하여 의존성을 정의하고 주입합니다.

Configuration (Spring Framework 6.0.13 API)

 
 

💡 [참고] Spring Framework의 의존성 주입 방식에 대해 궁금하시면 아래의 글이 도움이 됩니다.

[Java] Spring Framework 주요 특징 이해하기 : DI, IoC, POJO, AOP

 
 

[ 더 알아보기 ]

💡 스프링 IoC(Inversion of Control) 컨테이너

- 컨테이너는 객체의 생명주기와 의존성 관리를 담당하며, 애플리케이션의 개발자가 직접 객체를 생성하고 관리하는 번거로움을 덜어줍니다.
- 객체의 생성과 관리에 대한 제어를 더욱 효과적으로 할 수 있으며, 애플리케이션의 유연성과 확장성을 개선할 수 있습니다.


💡 구성 클래스

- 애플리케이션의 구성 요소들을 정의하고, 서로 다른 빈 객체들 간의 의존성을 설정하는 역할을 합니다. 또한, 구성 클래스는 외부 속성 파일을 로드하거나 다른 구성 요소를 조합하여 빈 객체들을 생성할 수도 있습니다.


💡 외부 라이브러리의 의존성을 추가했는데 별도의 @Configuration을 구성해야 하는 이유는 무엇인가?

- 외부 라이브러리를 프로젝트에 통합하기 위해서 구성이 필요합니다. 외부 라이브러리는 일반적으로 프로젝트의 특정 요구사항을 충족하기 위해 설정되어야 합니다.
- 이를 위해 @Configuration은 외부 라이브러리가 올바르게 작동하고 필요한 설정을 갖추도록 도와줍니다. 또한 외부 라이브러리를 프로젝트에 통합할 수 있고, 라이브러리의 기능을 올바르게 활용할 수 있습니다.

 
 

💡 @Configuration 사용 예시 :Swagger OpenAPI 환경 구성

- 해당 아래의 어노테이션은 Swagger 구성을 위한 @Configuration을 구성하고 @Bean을 통해 스프링 IoC 컨테이너에 의해 관리가 되도록 주입합니다.

package com.adjh.multiflexapi.config;

import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Swagger springdoc-ui 구성 파일
 */
@Configuration
public class OpenApiConfig {
    @Bean
    public OpenAPI openAPI() {
        Info info = new Info()
                .title("Multi-flex 프로젝트 API Document")
                .version("v0.0.1")
                .description("Multi-flex 프로젝트의 API 명세서입니다.");
        return new OpenAPI()
                .components(new Components())
                .info(info);
    }
}

 
 

💡 [참고] 이전에 작성한 Swagger 설정에 소스코드를 가져왔습니다.

[Java/Library] Swagger 이해하고 적용하기 : SpringDoc openAPI UI

 
 
 

3. @Bean

---

 💡 @Bean

- 스프링 컨테이너에게 해당 클래스를 빈으로 등록하도록 지시하는 어노테이션이며, 빈으로 등록된 ‘메서드’를 관리하고 필요한 부분에서 해당 빈을 주입하여 사용할 수 있도록 합니다.

- 일반적으로 클래스에서 @Configuration 어노테이션을 지정하며 메서드 별로 @Bean을 적용하여 의존성을 주입합니다. 해당 메서드는 빈으로 등록되며 스프링컨 테이너는 이를 인스턴스화하고 필요한 곳에 사용할 수 있습니다.
- @Bean 함수는 이외에도 커스텀 빈 객체를 생성하거나 외부 라이브러리를 빈으로 등록하는 등 다양한 용도로 활용할 수 있습니다.

org.springframework.beans (Spring Framework 6.0.13 API)

 

💡 [참고] Spring Framework의 의존성 주입 방식에 대해 궁금하시면 아래의 글이 도움이 됩니다.

[Java] Spring Framework 주요 특징 이해하기 : DI, IoC, POJO, AOP

 

💡 @Bean 사용예시 : Spring Boot Cache 구성 파일입니다.

- 해당 파일에서도 동일하게 @Configuration을 통해서 환경 클래스임을 선언하고 외부 라이브러리가 해당 프로젝트에 통합하기 위해 @Bean을 컨테이너에 관리되도록 추가하였습니다.

package com.adjh.multiflexapi.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 'ConcurrentMapCacheManager' 를 통해서 캐시를 관리합니다.
 *
 * @author : lee
 * @fileName : CacheConfig
 * @since : 2023/03/28
 */
@Slf4j
@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        log.debug("[+] CacheConfig Start !!! ");
        // "codeCacheInfo"라는 캐시를 관리합니다.
        return new ConcurrentMapCacheManager("codeCacheInfo", "codeUpdateInfo");
    }
}

 

💡 [참고] 이전에 작성한 Spring Boot Cache 설정에 소스코드를 가져왔습니다.

[Java] Spring Boot Cache 이해하고 설정하기 -1 : 정의, 환경 설정

 
 
 
 

4. @Component

---

 💡 @Component

- 해당 어노테이션을 이용하여 스프링 컨테이너에게 해당 클래스를 ‘컴포넌트의 스캔 대상’으로 지정하는 어노테이션을 의미합니다.

- @Component 어노테이션이 붙은 클래스는 자동으로 스프링 Application Context에 빈으로 등록됩니다.
- 다른 세부적인 어노테이션의 기반이 되는 어노테이션을 의미합니다. 예를 들어 @Controller, @Service, @Repository 등은 모두 @Component 어노테이션을 상속받아 구현되어 있습니다.

Component (Spring Framework 6.0.13 API)

https://www.geeksforgeeks.org/difference-between-component-repository-service-and-controller-annotations-in-spring/

 
 
 

 

💡 @Component 사용예시 : Spring Boot AOP 구성 파일입니다.

package com.adjh.multiflexapi.aspects;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 로깅 관련 AOP 구성
 *
 * @author : jonghoon
 * @fileName : LoggingAspect
 * @since : 2023/03/01
 */
@Aspect
@Component
@Slf4j
public class LoggingAspect {

    /**
     * Before: 대상 “메서드”가 실행되기 전에 Advice를 실행합니다.
     *
     * @param joinPoint
     */
    @Before("execution(* com.adjh.multiflexapi.controller.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        log.info("Before: " + joinPoint.getSignature().getName());
    }

    /**
     * After : 대상 “메서드”가 실행된 후에 Advice를 실행합니다.
     *
     * @param joinPoint
     */
    @After("execution(* com.adjh.multiflexapi.controller.*.*(..))")
    public void logAfter(JoinPoint joinPoint) {
        log.info("After: " + joinPoint.getSignature().getName());
    }

    /**
     * AfterReturning: 대상 “메서드”가 정상적으로 실행되고 반환된 후에 Advice를 실행합니다.
     *
     * @param joinPoint
     * @param result
     */
    @AfterReturning(pointcut = "execution(* com.adjh.multiflexapi.controller.*.*(..))", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        log.info("AfterReturning: " + joinPoint.getSignature().getName() + " result: " + result);
    }

    /**
     * AfterThrowing: 대상 “메서드에서 예외가 발생”했을 때 Advice를 실행합니다.
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "execution(* com.adjh.multiflexapi.controller.*.*(..))", throwing = "e")
    public void logAfterThrowing(JoinPoint joinPoint, Throwable e) {
        log.info("AfterThrowing: " + joinPoint.getSignature().getName() + " exception: " + e.getMessage());
    }

    /**
     * Around : 대상 “메서드” 실행 전, 후 또는 예외 발생 시에 Advice를 실행합니다.
     *
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("execution(* com.adjh.multiflexapi.controller.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("Around before: " + joinPoint.getSignature().getName());
        Object result = joinPoint.proceed();
        log.info("Around after: " + joinPoint.getSignature().getName());
        return result;
    }

}

 

💡[참고] 해당 소스코드는 이전에 작성한 글에서 가져왔습니다.

 

[Java] Spring Boot AOP(Aspect-Oriented Programming) 이해하고 설정하기

 
 
 
 

5. @Controller

---

💡 @Controller

- 스프링 애플리케이션에서 ‘웹 컨트롤러’를 나타내는 데 사용됩니다. 웹 애플리케이션에서 클라이언트의 요청을 처리하고 해당 요청에 대한 응답을 반환하는 역할을 하는 클래스에 @Controller 어노테이션을 지정합니다.

- 해당 어노테이션이 지정된 클래스에서는 스프링 애플리케이션 컨텍스트에서 빈으로 등록되며, 요청 매핑과 같은 웹 요청 처리를 위한 다양한 기능을 사용할 수 있게 됩니다.
- 이 어노테이션은 주로 웹 애플리케이션의 비즈니스 로직을 처리하는 컨트롤러 클래스에 사용됩니다.

Controller (Spring Framework 6.0.13 API)

 

💡 @Controller 사용 예시 : Thymeleaf의 파일을 불러오기 위한 예시로 사용이 됩니다.

- String, ModalAndView와 같이 요청에 따른 리턴값을 반환해주는 것이 아닌 ‘화면 자체’를 리턴해주기 위한 목적으로 사용이 되었습니다
- 즉, Controller 내에서도 Rest API 역할로 요청에 따른 리턴값을 반환해 주는 API와 같지만 실제 사용은 SpringMVC 패턴에서 Controller에서 View를 리턴하기 위한 목적으로 주된 사용을 합니다.

package com.adjh.multiflexapi.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Slf4j
@Controller
public class MainController {

    @GetMapping("/")
    public String selectImageList(Model model) {
        model.addAttribute("title", "");
        return "pages/test/testPage";
    }

}

 
 
 

[ 더 알아보기 ]

💡 @Component와 @Controller는 무슨 관계인가?

- @Controller 어노테이션은 @Component 어노테이션의 일종으로 웹 애플리케이션에서의 ‘역할을 명시적으로 나타내기 위해 사용’됩니다.
- @Component 어노테이션은 일반적인 컴포넌트를 나타내는 데 사용되고, @Controller 어노테이션은 웹 컨트롤러를 나타내는 데 사용됩니다.


💡 @Controller와 @RestController는 무슨 차이인가?

- @Controller는 전통적인 웹 애플리케이션에서 사용되는 어노테이션으로, 주로 View를 반환하기 위해 사용됩니다. 메서드에 @RequestMapping과 함께 사용되어 특정 URL에 매핑되는 요청 처리기로 동작합니다. 주로 JSP와 같은 View 템플릿을 이용하여 HTML을 생성하고 반환합니다.

- @RestController는 Spring 4.0 버전부터 도입된 어노테이션으로, JSON, XML 등의 데이터를 반환하기 위해 사용됩니다. @Controller와는 달리 모든 메서드에 @ResponseBody 어노테이션이 자동으로 적용되어 응답을 직접 반환합니다. 주로 RESTful API를 구현할 때 사용됩니다.

 
 
 
 

6. @Service

---

💡 @Service

- 자바에서 스프링 애플리케이션에서 ‘서비스’ 컴포넌트를 나타내는 데 사용됩니다.

- 클래스에 @Service 어노테이션이 지정되면 자동 감지가 가능하고 스프링 애플리케이션 컨텍스트에 빈으로 등록될 수 있습니다. 이 어노테이션은 주로 비즈니스 로직을 포함하거나 서비스 관련 작업을 수행하는 클래스에 사용됩니다.
- 스프링의 의존성 주입 및 트랜잭션 관리와 같은 기능을 활용할 수 있습니다. 이를 통해 애플리케이션의 컴포넌트를 효율적으로 구성하고 관리할 수 있습니다.

org.springframework.web.service.annotation (Spring Framework 6.0.13 API)

 
 

💡 @Service 사용 예시 : N Tier Architecture 내의 비즈니스 계층에 속하며 Service 계층에서 사용됨을 보여줍니다.

- 해당 예시에서는 Interface로 Service를 구현하고 인터페이스에 대한 실제 로직을 수행하는 구현체를 구현한 곳입니다.
- 정의에서 언급하였듯 주로 비즈니스 로직을 포함하거나 서비스 관련 작업을 수행하는 클래스에서 사용이 됩니다.

 
 

💡 TemplateService

- Interface로 확장성을 위해 인터페이스로 구성을 하였습니다.
- 비즈니스 계층에 속하기에 @Service 어노테이션을 사용하였습니다.

/**
 * [ 템플릿 설명 ]
 * - 해당 파일은 **ServiceImpl 내에서 구현된 구현체를 사용하기 위한 인터페이스 입니다.
 * - 해당 파일의 기능은 구현체에서 작성한 비즈니스 로직을 Controller 내에서 호출하기 위한 interface 입니다.
 *
 * @author lee
 * @since 2022.09.30
 */
@Service
public interface TemplateService {
    List<TemplateVO> selectTempList();

    TemplateVO selectTempById(Integer templateId);

    int insertTemp(TemplateVO templateVO);

    int updateTemp(TemplateVO templateVO);

    int deleteTempById(Integer templateId);
}

 
 

💡 TemplateServiceImpl

- Interface로 Service를 구성하여 실제 비즈니스 로직이 수행되는 서비스의 인터페이스 구현체입니다.
- 동일하게 비즈니스 계층에 속하기에 @Serivce 어노테이션을 사용하였습니다.

/**
 * [ 템플릿 설명 ]
 * - 해당 파일은 서비스의 비즈니스 로직을 구현하는 곳입니다.
 * - 해당 *ServiceImpl 에서는 @Service 어노테이션을 필수적으로 사용합니다.
 */
@Slf4j
@Service
public class TemplateServiceImpl implements TemplateService {

    /**
     * '생성자 주입 형태'로 사용합니다.
     * - Autowired 는 권장되지 않기에 생성자 주입 형태로 구성합니다.
     */
    private final SqlSession sqlSession;

    public TemplateServiceImpl(SqlSession ss) {
        this.sqlSession = ss;
    }

    /**
     * Template 리스트 값 조회
     *
     * @return List<TemplateVO> 반환값
     */
    @Transactional(readOnly = true)
    public List<TemplateVO> selectTempList() {
        TemplateMapper tm = sqlSession.getMapper(TemplateMapper.class);
        return tm.selectTempList();
    }

    /**
     * Template Delete
     *
     * @param tempId 삭제 아이디
     * @return TemplateVO 결과값 반환
     */
    @Transactional
    public int deleteTempById(Integer templateId) {
        TemplateMapper tm = sqlSession.getMapper(TemplateMapper.class);
        return tm.deleteTempById(templateId);
    }
}

 
 

💡[참고] 해당 소스코드는 이전에 작성한 글에서 가져왔습니다.

[Java] 계층화된 아키텍처(Layered Architecture) : N Tier Architecture

[JAVA] Spring Boot내에서 MyBatis & PostgreSQL 연동하기

 
 
 

 [ 더 알아보기 ]

💡 @Service 어노테이션은 인터페이스나 인터페이스 구현체에서도 사용해도 되는 거였네?

-  인터페이스나 해당 인터페이스의 구현 클래스에 모두 명시할 수 있습니다. 일반적으로 이 어노테이션은 스프링 애플리케이션에서 서비스 컴포넌트를 나타내는 데 사용됩니다.

 
 
 

7. @Repository

---

💡 @Repository

- 스프링 애플리케이션에서 ‘데이터 액세스 계층’을 나타내는 데 사용됩니다.

- 데이터 액세스 계층은 데이터베이스와의 상호 작용을 담당하며, 데이터의 영속성과 관련된 작업을 처리하는 클래스에 @Repository 어노테이션을 지정합니다.
- 해당 어노테이션이 지정된 클래스에서는 스프링 애플리케이션 컨텍스트에서 빈으로 등록되며, 스프링의 의존성 주입과 같은 기능을 활용할 수 있습니다. 이를 통해 데이터 액세스 계층의 컴포넌트를 효율적으로 구성하고 관리할 수 있습니다.

Repository (Spring Framework 6.0.13 API)

 

 💡 @Repository 사용 예시 : N-Tier Architecture 내의 영속성 계층(Persistence Layer)에 속하며, *Mapper.xml 파일과 1:1 매핑이 되는 인터페이스를 의미합니다.

- 해당 예시에서는 Mybatis의 *.xml 파일로 구성한 태그를 기반으로 Java 코드와 매핑을 하여서 인터페이스를 구성하였습니다.
- 정의에서 언급하였듯 주로 데이터베이스와의 상호작용을 담당하며 데이터의 영속성과 관련된 작업을 처리하는 클래스에 지정을 합니다.

/**
 * - 해당 파일은 xml 파일과 1:1 매핑되는 인터페이스 입니다. (환경파일 내에서 지정함)
 * - 해당 Mapper 폴더는 @Repository 어노테이션을 필수적으로 사용합니다.
 * [ 참고 ]
 * - xml 파일이 아닌 해당 파일 내에서 처리하려면 @Mapper 어노테이션을 사용하길 권장합니다.
 */
@Repository
public interface TemplateMapper {
    List<TemplateVO> selectTempList();

    TemplateVO selectTempById(Integer templateId);

    int insertTemp(TemplateVO templateVO);

    int updateTemp(TemplateVO templateVO);

    int deleteTempById(Integer templateId);
}

 

💡[참고] 해당 소스코드는 이전에 작성한 글에서 가져왔습니다.

 

[Java] 계층화된 아키텍처(Layered Architecture) : N Tier Architecture

 

[JAVA] Spring Boot내에서 MyBatis & PostgreSQL 연동하기

 
 
 
 

8. @ComponentScan

---

💡 @ComponentScan

- 스프링 컴포넌트 스캔을 활성화하는 데 사용됩니다. 이 어노테이션이 있는 클래스가 속한 패키지와 하위 패키지에서 스프링 컴포넌트를 검색하고 등록합니다.

ComponentScan (Spring Framework 6.0.13 API)

 

속성	설명
basePackages	컴포넌트를 스캔할 기본 패키지를 지정합니다.
basePackageClasses	컴포넌트를 스캔할 기본 클래스를 지정합니다.
excludeFilters	스캔 대상에서 제외할 컴포넌트를 지정합니다.
includeFilters	스캔 대상에 포함할 컴포넌트를 지정합니다.
lazyInit	컴포넌트의 지연 초기화를 사용할지 여부를 나타냅니다.
resourcePattern	컴포넌트를 스캔할 때 사용할 Ant 스타일 리소스 패턴을 지정합니다.
scopedProxyMode	스코프 빈에 대한 스코프 프록시 모드를 지정합니다.
useDefaultFilters	컴포넌트를 스캔할 때 기본 필터를 사용할지 여부를 나타냅니다.

 
 
 

 [ 더 알아보기 ]

💡@Component와 @ComponentScan에 대한 차이

- @Component: 스프링에서 일반적인 컴포넌트로서 해당 클래스를 빈으로 등록하는 역할을 합니다. 이는 스프링의 의존성 주입과 관련된 기능을 사용하기 위해서는 필요한 애노테이션입니다.

- @ComponentScan : 스프링이 지정된 패키지 및 하위 패키지에서 컴포넌트를 검색하고 자동으로 빈으로 등록하는 역할을 합니다. 즉, @ComponentScan을 사용하면 프로젝트의 여러 컴포넌트를 자동으로 스캔하고 빈으로 등록할 수 있습니다.

 
 
 

💡 [참고] Spring Web Annotation에 대해 더 궁금하시면 아래의 글을 참고하시면 도움이 됩니다.

구분	링크
Spring Web Annotation : 환경 구성	https://adjh54.tistory.com/311
Spring Web Annotation : 요청 및 응답	https://adjh54.tistory.com/312
Spring Web Annotation : 예외처리 및 주입	https://adjh54.tistory.com/313

 

 
 
 
오늘도 감사합니다. 😀