🌱 Spring 핵심 개념 마스터하기

 

목차

 

 

Spring은 단순한 프레임워크가 아닙니다.

객체 지향 설계, 의존성 주입, AOP, 설정 유연성 등 여러 철학과 기술이 녹아 있는 종합 개발 플랫폼이죠.

 

Spring Boot로 프로젝트를 만들어보신 분이라면 @Autowired, @Component 같은 어노테이션은 익숙하지만

“도대체 내부에서 무슨 일이 일어나는 걸까?” 라는 의문이 한 번쯤은 들었을 겁니다.

 

이번 글에서는 Spring의 핵심 개념들을 실제 코드 예시와 실무 활용 포인트 중심으로 정리해보겠습니다

---

🧠 제어의 역전(IoC)과 의존성 주입(DI)

IoC(Inversion of Control) 란?

IoC(Inversion of Control)는 객체의 생성과 의존성 관리를 개발자가 아닌 스프링 컨테이너가 담당하는 구조를 말합니다.

그리고 이 IoC를 구현하는 방식이 바로 DI(Dependency Injection), 즉 의존성 주입입니다.

 

전통적인 방식 (IoC 적용 전)

public class UserService {
    private UserRepository userRepository = new UserRepository(); // 직접 생성
    
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
}

 

Spring IoC 적용 후

@Service
public class UserService {
    private final UserRepository userRepository;
    
    // Spring이 UserRepository를 주입해줌
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
}

 

🔧 핵심 어노테이션

• @Component, @Service, @Repository: 스프링이 자동으로 관리하는 빈 등록
• @Autowired: 의존성 주입 표시 (생성자/필드/세터 방식 지원)

 

💡 활용 포인트

• 결합도를 낮추고 테스트 용이성 향상
• 스프링 컨테이너를 통해 모든 객체(빈)의 라이프사이클을 관리

DI의 3가지 방식

1. 생성자 주입 (권장)

@Service
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // 생성자가 하나면 @Autowired 생략 가능
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

 

2. 필드 주입 (테스트하기 어려움, 비추천)

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository; // 권장하지 않음
}

 

3. 세터 주입 (선택적 의존성에 사용)

@Service
public class UserService {
    private UserRepository userRepository;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

생성자 주입은 final 키워드를 활용해 불변성을 보장할 수 있고, Mock 주입 테스트에도 적합합니다.

---

🧬 Bean 생명주기와 스코프 이해하기

스프링이 관리하는 객체를 Bean이라고 합니다.

이 Bean은 생성부터 소멸까지 IoC 컨테이너에 의해 관리되며, 스코프(scope)에 따라 그 수명도 달라집니다.

 

생명주기 훑어보기

1. Bean 객체 생성
2. 의존성 주입 (DI)
3. 초기화 (@PostConstruct)
4. 애플리케이션 실행 중 사용
5. 종료 시 소멸 (@PreDestroy)

@Component
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("초기화 완료");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("소멸 처리");
    }
}

 

Bean 스코프 종류

스코프	설명
singleton	애플리케이션 내에서 하나의 인스턴스만 생성 (기본값)
prototype	요청할 때마다 새로운 인스턴스 생성
request	HTTP 요청마다 하나 (웹 환경)
session	사용자 세션마다 하나 (웹 환경)

대부분의 서비스 로직은 singleton 스코프로 작성되며, 필요에 따라 prototype 등을 조합합니다.

---

✨ AOP로 중복 코드 줄이기

AOP(Aspect-Oriented Programming, 관점 지향 프로그래밍)는 공통 관심사(Cross-cutting Concern)를 분리하여

핵심 비즈니스 로직을 더 깔끔하게 유지할 수 있도록 돕습니다.

 

AOP 없이 작성한 코드의 문제점

@Service
public class UserService {
    
    public User createUser(String name, String email) {
        // 로깅 코드 - 중복!
        log.info("사용자 생성 시작: name={}, email={}", name, email);
        
        // 권한 체크 코드 - 중복!
        if (!SecurityUtils.hasPermission("USER_CREATE")) {
            throw new AccessDeniedException("권한이 없습니다");
        }
        
        // 실행 시간 측정 - 중복!
        long startTime = System.currentTimeMillis();
        
        try {
            // 실제 비즈니스 로직
            User user = new User(name, email);
            userRepository.save(user);
            
            log.info("사용자 생성 완료: userId={}", user.getId());
            return user;
            
        } finally {
            long endTime = System.currentTimeMillis();
            log.info("실행 시간: {}ms", endTime - startTime);
        }
    }
}

 

AOP를 적용한 깔끔한 코드

@Service
public class UserService {
    
    @LogExecutionTime  // 실행 시간 측정
    @RequiredPermission("USER_CREATE")  // 권한 체크
    @Transactional  // 트랜잭션 관리
    public User createUser(String name, String email) {
        // 순수한 비즈니스 로직만!
        User user = new User(name, email);
        return userRepository.save(user);
    }
}

비즈니스 로직은 그대로 두고, 부가 로직은 Aspect로 분리할 수 있어 유지보수성이 대폭 향상됩니다.

 

실제 AOP 구현 예시

1. 실행 시간 측정 Aspect

@Aspect
@Component
@Slf4j
public class ExecutionTimeAspect {
    
    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        
        try {
            Object result = joinPoint.proceed(); // 실제 메서드 실행
            return result;
        } finally {
            long endTime = System.currentTimeMillis();
            String methodName = joinPoint.getSignature().getName();
            log.info("메서드 [{}] 실행 시간: {}ms", methodName, endTime - startTime);
        }
    }
}

// 커스텀 어노테이션
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecutionTime {
}

 

2. 예외 처리 Aspect

@Aspect
@Component
@Slf4j
public class ExceptionHandlingAspect {
    
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", 
                   throwing = "exception")
    public void handleException(JoinPoint joinPoint, Exception exception) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        
        log.error("메서드 [{}] 실행 중 예외 발생. 파라미터: {}", 
                  methodName, Arrays.toString(args), exception);
        
        // 추가적인 예외 처리 로직 (알림, 메트릭 수집 등)
        notificationService.sendErrorAlert(methodName, exception);
    }
}

---

⚙️ Spring Boot 자동 설정의 비밀

Spring Boot의 가장 강력한 특징 중 하나는 자동 설정(Auto Configuration)입니다.

개발자가 별도로 설정하지 않아도, 클래스패스에 존재하는 라이브러리와 설정 파일을 분석해서 필요한 설정을 자동으로 구성해 줍니다.

 

 @SpringBootApplication이란?

@SpringBootApplication

이 한 줄 어노테이션은 사실 세 가지 핵심 어노테이션을 조합한 메타 어노테이션(Meta-Annotation) 입니다.

 

• @Configuration: 빈 등록 클래스
• @ComponentScan: 컴포넌트 스캔
• @EnableAutoConfiguration: 의존성 기반 자동 설정

즉, @SpringBootApplication만 붙이면 스프링 부트 애플리케이션을 시작하는 데 필요한 거의 모든 설정이 자동으로 준비됩니다.

 

 동작 방식

Spring Boot는 META-INF/spring.factories 또는 최신 버전에서는

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 파일을 참고해서 자동 설정 후보 클래스를 로딩합니다.

그리고 이 설정들은 조건부 어노테이션(@Conditional) 을 기반으로 작동합니다.

@Bean
@ConditionalOnClass(HikariDataSource.class)
@ConditionalOnMissingBean(DataSource.class)
public DataSource dataSource() {
    return new HikariDataSource();
}

설정을 몰라도 쓸 수 있지만, 원리를 알면 디버깅과 커스터마이징이 훨씬 쉬워집니다.

---

🔧 외부 설정과 프로파일로 환경 관리하기

실무에서는 로컬, 개발, 운영 환경마다 설정이 달라야 합니다.

Spring Boot는 이를 위해 프로파일(Profile) 기능을 제공합니다.

프로파일별 설정 파일 구성

src/main/resources/
├── application.yml              # 공통 설정
├── application-dev.yml          # 개발 환경
├── application-test.yml         # 테스트 환경
└── application-prod.yml         # 운영 환경

# application.yml
spring:
  profiles:
    active: dev

# application-dev.yml
spring:
  datasource:
    url: jdbc:h2:mem:testdb

# application-prod.yml
spring:
  datasource:
    url: jdbc:mysql://prod-db:3306/app

 

@ConfigurationProperties 사용

@ConfigurationProperties를 활용하면 외부 설정을 객체로 바인딩할 수 있습니다.

@ConfigurationProperties(prefix = "app")
@Component
@Data
public class AppProperties {
    
    private String name;
    private String version;
    private Security security = new Security();
    private Mail mail = new Mail();
    
    @Data
    public static class Security {
        private String jwtSecret;
        private long jwtExpirationMs = 86400000; // 24시간
        private List<String> allowedOrigins = new ArrayList<>();
    }
    
    @Data
    public static class Mail {
        private String host;
        private int port = 587;
        private String username;
        private String password;
        private boolean enabled = true;
    }
}

---

🎨 실무에서 자주 쓰이는 스프링 기능들

이벤트 기반 아키텍처

// 이벤트 정의
public class UserRegisteredEvent {
    private final String userId;
    private final String email;
    private final LocalDateTime registeredAt;
    
    // 생성자, getter
}

// 이벤트 발행
@Service
@RequiredArgsConstructor
public class UserService {
    
    private final ApplicationEventPublisher eventPublisher;
    
    @Transactional
    public User registerUser(String name, String email) {
        User user = userRepository.save(new User(name, email));
        
        // 이벤트 발행
        eventPublisher.publishEvent(
            new UserRegisteredEvent(user.getId(), user.getEmail(), LocalDateTime.now())
        );
        
        return user;
    }
}

// 이벤트 리스너
@Component
@Slf4j
public class UserEventListener {
    
    @EventListener
    @Async
    public void handleUserRegistered(UserRegisteredEvent event) {
        log.info("새 사용자 등록됨: {}", event.getUserId());
        
        // 환영 이메일 발송
        emailService.sendWelcomeEmail(event.getEmail());
        
        // 통계 업데이트 등
        statisticsService.incrementUserCount();
    }
}

 

스케줄링

@Component
@EnableScheduling
@Slf4j
public class ScheduledTasks {
    
    @Scheduled(fixedRate = 300000) // 5분마다
    public void healthCheck() {
        log.info("시스템 상태 체크 실행");
        systemHealthService.performHealthCheck();
    }
    
    @Scheduled(cron = "0 0 2 * * ?") // 매일 새벽 2시
    public void dailyReportGeneration() {
        log.info("일일 리포트 생성 시작");
        reportService.generateDailyReport();
    }
}

---

🧡 마무리하며

이번 글에서는 Spring의 핵심 개념들을 실무 관점에서 살펴봤습니다.

 

📌 핵심 요약

• IoC/DI: 객체 관리를 스프링에게 맡기고, 결합도를 낮춰 테스트와 유지보수가 쉬운 구조 설계
• Bean 생명주기/스코프: 객체 수명과 사용 범위를 명확히 이해
• AOP: 중복 로직 제거, 비즈니스 코드의 순수성 유지
• 환경 설정/프로파일: 환경별 설정 분리로 실무 유연성 확보

이 개념들을 정확히 이해하고 나면, Spring Boot를 더 효과적으로 활용할 수 있습니다.

특히 실무에서는 AOP를 통한 로깅, 프로파일을 통한 환경 분리, 이벤트 기반 아키텍처 등이 매우 유용하게 사용돼요.

 

다음 글에서는 데이터베이스 연동과 JPA에 대해 다뤄보겠습니다.

궁금한 점이나 더 자세히 알고 싶은 개념이 있다면 댓글로 남겨주세요! 🚀