Spring Framework 소개

스프링 프레임워크 소개

•

스프링 프레임워크란?

•

스프링 프레임워크 핵심 기능

◦

의존성 주입 (DI)

◦

제어의 역전 (IoC)

◦

관점 지향 프로그래밍 (AOP)

•

다양한 스프링 프로젝트 및 모듈

◦

Spring Framework

▪

Spring Core

▪

Spring Web

▪

Spring Web MVC

▪

Spring AOP

▪

Spring JDBC

▪

Spring ORM 

◦

Spring Boot

◦

Spring Data

◦

Spring Security

스프링 프레임워크 (Spring framework)

스프링 프레임워크는 Java 기반의 오픈 소스 애플리케이션 프레임워크입니다. 스프링은 간단한 자바 객체를 사용하여 엔터프라이즈급 애플리케이션을 구축하는 데 도움이 됩니다. 스프링은 다양한 모듈과 기능을 제공하여 개발자들이 애플리케이션을 더 쉽게 구축하고 유지할 수 있도록 지원합니다.

스프링 프레임워크의 핵심 기능은 제어 역전(IoC) 컨테이너와 의존성 주입(DI)입니다. 이러한 기능을 통해 개발자는 객체 간의 결합도를 낮추고 유연하고 테스트 가능한 코드를 작성할 수 있습니다. 스프링은 또한 관계형 데이터베이스 액세스, 웹 애플리케이션 개발, 보안, 트랜잭션 관리 등을 위한 다양한 모듈을 제공합니다.

스프링 프레임워크는 엔터프라이즈급 애플리케이션 개발에 많이 사용되며, 많은 개발자들과 기업에서 신뢰하고 선택하는 프레임워크입니다.

스프링 프레임워크의 핵심 기능

•

의존성 주입 (DI;  Dependency Injection)

•

제어의 역전 (IoC; Inversion of Control Container)

•

관점 지향 프로그래밍 (AOP; Aspect Orented Programming)

의존성 주입 (Dependency Injection)

의존성 주입은 스프링 프레임워크의 핵심 기능 중 하나입니다. 이를 통해 개발자는 객체 간의 의존 관계를 스프링이 자동으로 관리하도록 할 수 있습니다. 의존성 주입은 객체가 필요로 하는 의존 객체를 스프링이 자동으로 주입해주는 방식으로 동작합니다.

의존성 주입을 사용하면 개발자는 객체 간의 결합도를 낮출 수 있습니다. 객체가 직접 의존하는 객체를 생성하거나 참조하지 않고, 스프링 컨테이너가 필요한 의존 객체를 주입해줍니다. 이를 통해 코드의 재사용성과 유지보수성을 향상시킬 수 있습니다.

스프링 프레임워크에서는 다양한 방법으로 의존성 주입을 지원합니다. 주요한 방법으로는 생성자 주입, 필드 주입, 메서드 주입 등이 있습니다. 개발자는 자신의 프로젝트에 적합한 방법을 선택하여 의존성 주입을 구현할 수 있습니다.

의존성 주입은 스프링 프레임워크의 핵심 개념 중 하나로, 개발자가 유연하고 테스트 가능한 코드를 작성할 수 있도록 도와줍니다.

의존성 주입 이해하기 위해 알아야 할 것

•

의존 및 의존성

•

의존의 종류

◦

클래스 의존

◦

인터페이스 의존

•

IoC (제어의 역전)

•

IoC 컨테이너 

•

빈 (Bean)

의존?

다른 것에 도움을 받아 존재하는 것

의존성

다른 것에 도움을 받아 존재하는 상태(성질)

Java 에서의 의존, 의존성

의존

: 하나의 클래스에서 다른 클래스를 사용하는 것

A 클래스에서 B 클래스를 사용하는 것을 “A 클래스가 B 클래스의 의존한다.” 라고 할 수 있습니다.

A 클래스에서 B 클래스를 사용하려면, A 클래스 내에서 B 클래스의 객체를 생성하고 B 클래스의 변수 및 메소드를 사용해야합니다. 이 대 B 클래스의 변수 및 메소드가 변경되면 B 클래스를 사용하는 A 클래스도 영향을 받게 됩니다.

이렇게, B 클래스가 변경되면 A 클래스도 변경을 해야하기 때문에, A 클래스는 B 클래스에 도움을 받아 존재하게 됩니다. 이를 “A 클래스는 B 클래스에 의존한다.” 라고 할 수 있습니다.

의존성

: 하나의 클래스가 다른 클래스를 사용하여 의존하고 있는 상태

A 클래스에서 B 클래스를 사용하여, A 클래스가 B 클래스에 의존하고 있다면, A 클래스는 B 클래스에 대한 의존성을 가진다고 할 수 있습니다. 이렇게 하나의 클래스가 다른 클래스를 사용하여 의존하고 있는 상태를 의존성이라고 합니다.

아래 코드는 A 클래스가 B 클래스의 의존하고 있는 예시 코드입니다.

// 클래스 B 정의
public class B {
    public void method() { 
        System.out.println("클래스 B의 메서드 수행");
    }
}

// 클래스 A 정의
public class A {
    private B b; // 클래스 B에 대한 의존성을 가집니다.

    // 생성자를 통해 클래스 B의 객체를 주입 받습니다.
    public A(B b) {
        this.b = b;
    }

    public void execute() {
        System.out.println("클래스 A의 기능 수행");
        // 클래스 A는 클래스 B의 메서드를 호출하여 사용합니다.
        b.method();
    }

    public static void main(String[] args) {
        // 클래스 B의 객체를 생성합니다.
        B b = new B(); 

        // 클래스 A의 객체를 생성하면서 클래스 B의 객체를 주입합니다.
        A a = new A(b); 

        // 클래스 A의 기능을 실행합니다.
        a.execute();
    }
}
Java
복사

의존의 종류

•

클래스 의존

•

인터페이스 의존

클래스 의존

: 하나의 클래스가 다른 클래스를 사용하는 것

인터페이스 의존

: 하나의 클래스가 특정 인터페이스를 구현한 다른 클래스를 사용하는 것

클래스 의존 vs 인터페이스 의존

의존	클래스 의존	인터페이스 의존
결합도	높음	낮음
응집도	낮음	높음

결론 : 인터페이스 의존이 결합도가 낮고, 응집도가 높아 클래스 의존보다 유지보수하기 쉽다.

클래스 의존성은 결합도와 응집도 측면에서 문제를 발생시킬 수 있으며, 인터페이스 의존성을 통해 이러한 문제를 해결할 수 있습니다. 인터페이스를 사용하면 코드의 유연성을 높이고, 클래스 간의 결합도를 낮추며, 클래스의 응집도를 높일 수 있습니다.

클래스 의존 이해하기

A 클래스는 B 클래스의 의존합니다.

•

A 클래스에서, B 객체(인스턴스) 생성

•

A 클래스에서, B 객체의 메소드(methodA) 호출

코드 - (A ← B)

// B 클래스 정의
public class B {
    public void methodA() {
        System.out.println("B 클래스의 methodA() 메서드 호출");
    }
}

// A 클래스 정의
public class A {
	  public void execute() {
        B b = new B();
        b.methodA();
    }
}
Java
복사

더욱 확장된 프로그램을 개발하면서, B 클래스를 더 많은 클래스에서 사용하게 되었습니다. 기존에 클래스 A 하나만 의존하고 있었다가 이제는 50개, 100개 이상의 클래스에서 B 클래스에 의존하게 되었습니다.

코드 - (X,Y,Z ← B)

// B 클래스 정의
public class B {
    public void methodA() {
        System.out.println("B 클래스의 methodA() 메서드 호출");
    }
}

// X 클래스 정의
public class X {
    public void execute() {
        B b = new B();
        b.methodA();
    }
}

// Y 클래스 정의
public class Y {
    public void execute() {
        B b = new B();
        b.methodA();
    }
}


// Z 클래스 정의
public class Z {
    public void execute() {
        B b = new B();
        b.methodA();
    }
}

...
Java
복사

그런데, 프로그램의 전반적인 설계가 변경되어 클래스 B 대신 클래스 C 를 사용하게 되었습니다. 이때 클래스 B 에 의존하던 여러 클래스들은 모두 클래스 C 로 의존하도록 코드를 변경해야합니다.

기존에 클래스 B 에 의존하던, 클래스 100개를 클래스 C 를 의존하도록, 객체 B를 생성하고 methodA() 를 호출하던 코드들을 객체 C를 생성하고, methodB( ) 를 호출하도록 변경하였습니다.

이렇게 클래스 의존을 사용하게 되면, 클래스 간의 결합도가 높아져 유지보수가 어려워집니다.

코드 - (A ← C)

// C 클래스 정의
public class C {
    public void methodB() {
        System.out.println("C 클래스의 methodB() 메서드 호출");
    }
}

// A 클래스 수정
public class A {
    public void execute() {
        // ★(수정) B b = new B();     
        // ★C 객체 생성
        C c = new C();

				// ★(수정) b.methodA();
        // ★C 객체의 methodB() 메서드 호출
        c.methodB();
    }
}

// X 클래스 수정
// (생략)

// Y 클래스 수정
// (생략)

// Z 클래스 수정
// (생략)
Java
복사

인터페이스 의존 이해하기

인터페이스 I 를 구현한 클래스 B, 클래스 C 가 있습니다. 두 클래스 모두 인터페이스에서 정의한 추상메소드 methodA( ) 를 오버라이딩하여 구현하였습니다.

클래스 A 는 인터페이스 I 에 의존하고 있습니다. 이때, 인터페이스로 선언하되 필요에 따라 클래스 B 에 대한 객체를 생성하거나 클래스 C에 대한 객체를 생성할 수 있습니다.

코드 ( A ← I B )

// 인터페이스 I 정의
public interface I {
    void methodA();
}

// 클래스 B: 인터페이스 I를 구현
public class B implements I {
    @Override
    public void methodA() {
        System.out.println("B 클래스의 methodA() 메서드 호출");
    }
}

// 클래스 A: 인터페이스 I에 의존
public class A {
    public void execute() {
	       I i = new B();
         i.methodA();
    }
}
Java
복사

더욱 확장된 프로그램을 개발하면서, 구현 클래스 B 를 가지는 인터페이스 I 를 더 많은 클래스에서 사용하게 되었습니다. 기존에 클래스 A 하나만 의존하고 있었다가 이제는 50개, 100개 이상의 클래스에서 인터페이스 I 에 의존하게 되었습니다.

코드 - ( A ← I X,Y,Z )

// 인터페이스 I 정의
public interface I {
    void methodA();
}

// 클래스 B: 인터페이스 I를 구현
public class B implements I {
    @Override
    public void methodA() {
        System.out.println("B 클래스의 methodA() 메서드 호출");
    }
}


// 클래스 X: 인터페이스 I에 의존
public class X {
    public void execute() {
	       I i = new B();
         i.methodA();
    }
}

// 클래스 Y: 인터페이스 I에 의존
public class Y {
    public void execute() {
	       I i = new B();
         i.methodA();
    }
}

// 클래스 Z: 인터페이스 I에 의존
public class Z {
    public void execute() {
	       I i = new B();
         i.methodA();
    }
}

...
Java
복사

하지만, 인터페이스 의존을 사용하여 프로그램을 설계하였기 때문에, 기존 인터페이스 I 에 의존하는 클래스 C 를 새로 정의하고 인터페이스 I 를 사용하는 클래스들에서는 객체 생성에 대한 부분만 변경하면 됩니다.

클래스 의존에서는 객체 생성 및 메소드 호출에 대한 코드를 모두 변경하였지만, 인터페이스 의존에서는 B 객체를 생성하는 코드를 C 객체를 생성하는 코드로 변경하기만 하면됩니다.

이렇게 인터페이스 의존을 사용하게 되면, 클래스 간의 결합도가 낲아져 유지보수가 쉬워집니다.

코드 ( A ← I C )

// 인터페이스 I 정의
public interface I {
    void methodA();
}

// 클래스 B: 인터페이스 I를 구현
public class B implements I {
    @Override
    public void methodA() {
        System.out.println("B 클래스의 methodA() 메서드 호출");
    }
}

// ★클래스 C: 인터페이스 I를 구현
public class C implements I {
    @Override
    public void methodA() {
        System.out.println("C 클래스의 methodA() 메서드 호출");
    }
}

// 클래스 A: 인터페이스 I에 의존
public class A {
    public void execute() {
 	       // ★(수정) I i = new B();
				 I i = new C();
         i.methodA();
    }
}
Java
복사

결론 - 클래스 의존 vs 인터페이스 의존

“인터페이스 의존이 유지보수하기 더 좋다.”

의존성 주입

: 해당 클래스가 사용할 객체를 외부에서 생성하여 대입하는 것

의존성 주입 종류

생성자 주입 (Constructor Injection)

세터 주입 (Setter Injection)

생성자 주입

특징:

•

생성자 주입은 객체를 생성할 때 해당 객체의 의존성을 주입하는 방법입니다.

•

주로 필수적인 의존성을 주입할 때 사용됩니다.

•

객체를 생성하는 시점에 의존성이 명확하게 결정되고 변경되지 않아야 할 때 적합합니다.

사용 방법:

•

클래스의 생성자에 의존성을 전달받는 매개변수를 추가합니다.

•

주입하려는 의존성을 생성자 매개변수로 전달하고, 이를 필드에 저장합니다.

코드 - 생성자 주입

•

Main.java

•

Board.java

•

Comment.java

•

MyService.java

•

BoardDAO.java

•

CommentDAO.java

코드 - Main.java

import java.util.List;

import DI.DAO.BoardDAO;
import DI.DAO.CommentDAO;
import DI.DTO.Board;
import DI.DTO.Comment;
import DI.Service.MyService;

public class Main {
    public static void main(String[] args) {
        // BoardDAO 객체를 생성
        BoardDAO boardDAO = new BoardDAO();
		// CommentDAO 객체를 생성
        CommentDAO commentDAO = new CommentDAO();

		// ★ 의존성 주입 - 생성자 주입
        // MyService 객체를 생성하고 BoardDAO 객체를 생성자를 통해 주입
        MyService myService1 = new MyService(boardDAO);

		// ★ 의존성 주입 - 생성자 주입
        // MyService 객체를 생성하고 commentDAO 객체를 생성자를 통해 주입
        MyService myService2 = new MyService(commentDAO);

        // MyService를 사용
        List<Board> boardList = myService1.selectBoardAll();
        List<Comment> commentList = myService2.selectCommentAll();
    }
}


Java
복사

코드 - Board.java

// Board 클래스
class Board {
    // 게시물 정보를 나타내는 필드들
}
Java
복사

코드 - Comment.java

// Comment 클래스
class Comment {
    // 댓글 정보를 나타내는 필드들
}
Java
복사

코드 - MyService.java

import java.util.List;

import DI.DAO.BoardDAO;
import DI.DAO.CommentDAO;
import DI.DTO.Board;
import DI.DTO.Comment;

//MyService 클래스
public class MyService {
 private final BoardDAO boardDAO;
 private final CommentDAO commentDAO;

 // 생성자를 통한 의존성 주입
 public MyService(BoardDAO boardDAO) {
     this.boardDAO = boardDAO;
     this.commentDAO = null; // CommentDAO는 null로 초기화
 }

 // 또 다른 생성자를 통한 의존성 주입
 public MyService(CommentDAO commentDAO) {
     this.boardDAO = null; // BoardDAO는 null로 초기화
     this.commentDAO = commentDAO;
 }

 // selectAll() 메소드 정의
 public List<Board> selectBoardAll() {
     // BoardDAO를 사용하여 게시물 목록을 가져옴
     return boardDAO.getAllBoards();
 }

 // 다른 selectAll() 메소드 정의
 public List<Comment> selectCommentAll() {
     // CommentDAO를 사용하여 댓글 목록을 가져옴
     return commentDAO.getAllComments();
 }
}
Java
복사

코드 - BoardDAO.java

import java.util.List;

// BoardDAO 클래스 (의존성 주입 대상)
public class BoardDAO {
    // getAllBoards() 메소드 정의
    public List<Board> getAllBoards() {
        // 게시물 목록을 데이터베이스에서 가져오는 로직
        return null; // 간략하게 표시
    }
}
Java
복사

코드 - CommentDAO.java

import java.util.List;

// CommentDAO 클래스 (의존성 주입 대상)
public class CommentDAO {
    // getAllComments() 메소드 정의
    public List<Comment> getAllComments() {
        // 댓글 목록을 데이터베이스에서 가져오는 로직
        return null; // 간략하게 표시
    }
}
Java
복사

세터 주입

특징:

•

세터 주입은 객체 생성 후에 의존성을 주입하는 방법입니다.

•

주로 선택적인 의존성을 주입할 때 사용됩니다.

•

의존성이 변경 가능하거나 여러 번 변경되어야 할 때 적합합니다.

사용 방법:

•

클래스 내에 Setter 메서드를 만들고 해당 메서드를 통해 의존성을 주입합니다.

•

주입하려는 의존성을 Setter 메서드의 매개변수로 전달하고, 이를 필드에 저장합니다.

코드 - 세터 주입

•

Main.java

•

Board.java

•

Comment.java

•

MyService.java

•

BoardDAO.java

•

CommentDAO.java

코드 - Main.java

import java.util.List;

import DI.DAO.BoardDAO;
import DI.DAO.CommentDAO;
import DI.DTO.Board;
import DI.DTO.Comment;
import DI.Service.MyService;

public class Main {
    public static void main(String[] args) {
        // BoardDAO 객체를 생성
        BoardDAO boardDAO = new BoardDAO();
        // CommentDAO 객체를 생성
        CommentDAO commentDAO = new CommentDAO();

        // MyService 객체를 생성
        MyService myService1 = new MyService();
        // ★ 의존성 주입 - 세터 주입
        // BoardDAO 객체를 세터 메서드를 통해 주입
        myService1.setBoardDAO(boardDAO);

        // MyService 객체를 생성
        MyService myService2 = new MyService();
        // ★ 의존성 주입 - 세터 주입
        // CommentDAO 객체를 세터 메서드를 통해 주입
        myService2.setCommentDAO(commentDAO);

        // MyService를 사용하여 selectAll() 메소드 호출
        List<Board> boardList = myService1.selectBoardAll();
        List<Comment> commentList = myService2.selectCommentAll();
    }
}


Java
복사

코드 - Board.java

// Board 클래스
class Board {
    // 게시물 정보를 나타내는 필드들
}
Java
복사

코드 - Comment.java

// Comment 클래스
class Comment {
    // 댓글 정보를 나타내는 필드들
}
Java
복사

코드 - MyService.java

import java.util.List;

import DI.DAO.BoardDAO;
import DI.DAO.CommentDAO;
import DI.DTO.Board;
import DI.DTO.Comment;

//MyService 클래스
public class MyService {
 private BoardDAO boardDAO;
 private CommentDAO commentDAO;

 // Setter 메서드를 통한 의존성 주입
 public void setBoardDAO(BoardDAO boardDAO) {
     this.boardDAO = boardDAO;
 }

 // Setter 메서드를 통한 의존성 주입
 public void setCommentDAO(CommentDAO commentDAO) {
     this.commentDAO = commentDAO;
 }

 // selectAll() 메소드 정의
 public List<Board> selectBoardAll() {
     // BoardDAO를 사용하여 게시물 목록을 가져옴
     return boardDAO.getAllBoards();
 }

 // selectAll() 메소드 정의
 public List<Comment> selectCommentAll() {
     // CommentDAO를 사용하여 댓글 목록을 가져옴
     return commentDAO.getAllComments();
 }
}

Java
복사

코드 - BoardDAO.java

import java.util.List;

// BoardDAO 클래스 (의존성 주입 대상)
public class BoardDAO {
    // getAllBoards() 메소드 정의
    public List<Board> getAllBoards() {
        // 게시물 목록을 데이터베이스에서 가져오는 로직
        return null; // 간략하게 표시
    }
}
Java
복사

코드 - CommentDAO.java

import java.util.List;

// CommentDAO 클래스 (의존성 주입 대상)
public class CommentDAO {
    // getAllComments() 메소드 정의
    public List<Comment> getAllComments() {
        // 댓글 목록을 데이터베이스에서 가져오는 로직
        return null; // 간략하게 표시
    }
}
Java
복사

의존성 주입의 필요성

클래스 의존보다 인터페이스 의존이 프로그램 개발에 있어서 모듈(클래스) 간 결합도가 낮아서 유지보수하기 쉽다는 결론을 알았습니다. 그런데, 프로그램은 한 번에 완벽하게 개발하여 완성하는 경우는 별로 없습니다. 또한, 기존의 프로그램의 설계와 로직을 변경하여 재구축하기도 합니다.

개발자는 수십 개, 수백 개의 클래스와 인터페이스들을 개발 한 뒤, 유지보수 및 재구축을 위하여 설계와 로직을 변경합니다. 이렇게 이미 개발된 프로그램은 수 많은 클래스들로 서로 상당히 많은 수의 의존성으로 얽혀있습니다. 그래서 하나의 클래스만 변경해도 이에 의존하고 있는 많은 클래스들에 대하여 아주 많은 수정을 해주어야합니다.

이러한 작업을 일반적으로 “의존성 관리”라고 부릅니다.

사실 “의존성 관리”는 프로그램의 핵심 기능을 처리하는 비즈니스 로직, 알고리즘 등과 달리 실질적인 업무 프로세스를 구현하는 것은 아닙니다. 따라서 이 의존성 관리 때문에 실질적으로 더 중요한 로직들을 개발하는데에 써야하는 시간을 낭비하게 됩니다.

그래서 이런 생각을 하게 되었습니다.

“의존성 관리를 누가 대신해줄 수 없을까?”

의존성 관리하는 시간만 줄여도 더 중요한 비즈니스 로직을 작성하는데에 집중하고 시간을 더 많이 사용할 수 있을테니까요.

인터페이스 의존성을 사용해서, 해당 클래스에서 사용할 인터페이스만 선언하고 실제로 생성될 인스턴스(객체)는 누가 알아서 생성해서 넣어주며 좋지 않을까?

그렇게하면, 의존성 관리는 신경쓰지 않고, 인터페이스 선언만 한 뒤 비즈니스 로직 개발에 집중할 수 있겠죠.

즉, 예시코드 (A ← I C) 처럼, 설계가 B 클래스에서 C 클래스로 변경되어도, 객체 생성을 B 에서 C 로 변경하는 작업조차 하지 않아도 된다는 것입니다. 인터페이스 I 만 선언해놓고 여기에 대입될 인스턴스는 누군가 알아서 생성해서 넣어주기 때문입니다.

이렇게, 특정 클래스에서 사용할 객체, 즉 의존할 객체를 외부에서 생성하여 대입해주는 것을 의존성 주입(Dependency Injection) 이라고 합니다.

의존성 주입의 장점

•

객체간 결합도 감소 (느슨한 결합)

◦

코드 변경과 유지보수가 쉬워진다.

•

코드의 재사용성 향상

◦

기존의 코드를 변경하지 않고도 새로운 코드를 추가하기 쉬워진다.

•

테스트 용이성 향상

◦

테스트용 의존성을 주입하여, 테스트를 쉽게 수행할 수 있다.

프레임워크 (Framework)

: 프로그램 개발의 생산성 및 유지보수성 향상, 최적화, 구조화된 개발을 도와주는 도구

기존에는 프로그램 개발에 있어서 의존성 관리 등 프로그래밍의 전반적인 제어를 개발자가 직접해왔습니다. 하지만, 프로그램이 커지면 커질수록 의존성 관리와 같은 작업의 경우 중요성은 비교적 낮지만 작업해야할 양이 많아지게 됩니다.

이러한 작업은 일반적인 프로그램에 공통적으로 들어가는 작업이고 업무 프로세스에 따라 달라지는 작업이 아니기 때문에 매번 새로운 프로그램을 개발할 때에도 반복되는 작업이 될 수 있습니다.

따라서, 프로그램 개발의 보편적이고 공통적인 작업들을 미리 만들어 두고 그 구조 또는 틀을 그대로 사용한다면, 프로그램 개발에 생산성을 향상시킬 수 있을 것입니다.

그래서 등장한 것이 바로 “프레임워크” 입니다.

이제는 의존성 관리와 같은 일반적이 작업들은 프레임워크가 도와줄 것입니다.

따라서, 개발자는 의존성 관리와 같은 작업은 프레임워크에게 맡기고 핵심 기능 개발에 집중할 수 있습니다.

프레임워크에는 여러 가지가 있습니다. 그 중에서도 대표적인 자바 개발 프레임워크는 Spring Framework 입니다.

Spring Framework 를 사용하면, 프레임워크를 통해서 의존성 주입과 AOP 를 할 수 있습니다.

이렇게 개발자가 쥐고 있던 프로그램 개발에 대한 전반적인 제어권을 프레임워크에 넘겨주는 것을 제어권을 가지고 있는 주체가 뒤바뀌었다고 해서 제어의 역전이라고 부릅니다.

제어의 역전 (IoC; Inversion of Control)

제어의 역전(IoC; Inversion of Control)은 개발자가 객체의 생명 주기 및 의존성 관리를 하던 것을 스프링이 대신 처리하도록 하는 것을 의미합니다.

Ioc 컨테이너 (Inversion of Control Container)

Ioc 컨테이너는 스프링 프레임워크의 핵심 기능 중 하나입니다. 이 컨테이너는 개발자가 객체의 생명주기 및 의존성 관리를 스프링이 대신 처리하도록 합니다. 개발자는 객체를 생성하고 구성하는 대신, Ioc 컨테이너에게 필요한 객체를 요청하고 주입받습니다. 이를 통해 객체 간의 결합도를 낮추고 유연하고 관리 가능한 코드를 작성할 수 있습니다.

Ioc 컨테이너는 스프링 애플리케이션의 핵심 엔진으로 동작하며, 스프링 프레임워크에서 제공하는 다양한 기능과 모듈들을 지원합니다. 스프링은 객체의 라이프사이클, 의존성 주입, 설정 정보 관리 등을 효과적으로 처리할 수 있는 IoC 컨테이너를 제공합니다.

Ioc 컨테이너를 사용하여 개발자는 애플리케이션의 객체를 생성하고 구성함으로써 애플리케이션의 동작을 유연하게 제어할 수 있습니다. 또한, 스프링이 제공하는 다양한 기능들과 통합하여 개발자가 효과적으로 개발할 수 있도록 도와줍니다.

IoC 컨테이너? 스프링 컨테이너? DI 컨테이너? 

모두 동일한 개념을 가리키는 용어입니다. 스프링 공식 문서에는 주로 Ioc 컨테이너라는 용어를 사용합니다.

빈 (Bean)

: 의존성 주입을 하기 위해서, IoC 컨테이너가 관리하는 객체

Spring DI

관점 지향 프로그래밍 (AOP)

: 프로그램의 횡단적 관심사를 중심적 관심사(비즈니스 로직)로부터 분리시켜 모듈화하는 프로그래밍 패러다임

중심적 관심사 (Core Concern)

: 소프트웨어의 핵심 기능과 로직에 직접적으로 관련된 부분, 비즈니스 로직

횡단적 관심사 (Cross-Cutting Concern)

: 중심적 관심사를 지원하고 보완하는 부수적인 부분, 반복적으로 사용되는 공통 로직

•

예외처리

•

로깅

•

보안

•

트랜잭션

AOP 의 필요성

프로그램 개발을 하다보면, 예외처리, 로깅 등에 대한 코드들은 여러 곳에서 반복적으로 작성하게 됩니다. 그러다보니 비슷한 코드를 여러 곳에 반복적으로 작성하는 경우가 많아집니다. 이렇게 되면 코드의 중복이 늘어나고 유지보수하기 어려워질 수 있습니다.

그래서 이런 생각을 해볼 수 있습니다. 예외처리, 로깅 등 늘 공통적으로 반복해서 사용하는 코드들을 특정 메소드로 미리 정의해두고, 프로그램의 전반적인 흐름 사이에 특정 조건과 타이밍에 맞게 적절히 미리 정의한 공통 로직을 실행시켜주면, 핵심 로직에 집중하고 비교적 덜 중요한 부수적인 코드들은 중심 로직과 분리시켜 관리할 수 있지 않을까?

AOP 주요 용어

용어	설명
어드바이스(Advice)	관점에서 수행할 작업을 정의한 코드 블록입니다.
관점 (Aspect)	관심사의 모듈화된 단위로, 어드바이스와 포인트컷으로 구성됩니다.
조인포인트 (Join Point)	어드바이스가 적용될 수 있는 코드의 특정 지점(메서드 호출, 예외 발생 등)입니다.
포인트컷 (Pointcut)	어드바이스가 적용될 Join Point를 선택하는 표현식입니다.
타겟 (Target)	관심사가 적용되는 대상 객체 또는 메서드입니다.

어드바이스 (Advice)

: 횡단 관심사를 작성한 메소드

관점 (Aspect)

: 조인 포인트와 포인트컷을 정의한 어드바이스들을 모아놓은 클래스

조인 포인트 (Join Point)

: 어드바이스를 타겟에 적용하는 타이밍

포인트컷 (Pointcut)

: 어드바이스 적용 조건

타켓 (Target)

: 어드바이스가 적용되는 클래스

어드바이스 종류

종류	설명
Before (이전)	대상 메서드 호출 전에 실행
After Returning (반환 후)	대상 메서드가 예외 없이 정상적으로 실행되고 반환될 때 실행
After Throwing (예외 후)	대상 메서드가 예외를 던질 때 실행. 주로 예외 처리 작업을 수행
After (이후)	대상 메서드 실행 후 항상 실행
Around (주변)	대상 메서드 호출 전과 후에 실행

포인트컷 식 와일드카드

와일드 카드	설명
*	임의의 문자열을 나타내며, 패키지 이름, 클래스 이름, 메서드 이름에 사용될 수 있습니다.
..	임의의 문자열을 나타내며, 패키지 레벨 또는 메서드 시그니처의 일부로 사용될 수 있습니다.
+	클래스 레벨에서 사용되며, 해당 클래스 및 그 서브클래스를 나타냅니다.
(..)	메서드 시그니처의 일부로 사용되며, 메서드의 매개변수와 반환 타입을 나타냅니다.

포인트컷 지시자

지시자	설명
execution()	메서드 실행 지점을 지정하는데 사용됩니다. 예: execution(* com.example.service..(..))는 com.example.service 패키지의 모든 메서드를 대상으로 합니다.
within()	특정 타입 또는 패키지 내의 모든 메서드를 대상으로 합니다. 예: within(com.example.service.*)는 com.example.service 패키지 내의 모든 메서드를 대상으로 합니다.
bean()	특정 빈 이름과 관련된 메서드를 대상으로 합니다. 예: bean(myService)는 myService 빈과 관련된 메서드를 대상으로 합니다.
this()	특정 인스턴스의 메서드 호출을 대상으로 합니다. 예: this(com.example.MyService)는 MyService 클래스의 인스턴스 메서드 호출을 대상으로 합니다.
target()	특정 타입 또는 인터페이스를 구현한 객체의 메서드를 대상으로 합니다. 예: target(com.example.MyService)는 MyService 인터페이스를 구현한 객체의 메서드 호출을 대상으로 합니다.
args()	특정 매개변수 타입을 가지고 있는 메서드 호출을 대상으로 합니다. 예: args(java.lang.String)는 String 타입의 매개변수를 가지는 메서드 호출을 대상으로 합니다.
@annotation()	특정 어노테이션이 적용된 메서드 호출을 대상으로 합니다. 예: @annotation(org.springframework.transaction.annotation.Transactional)는 @Transactional 어노테이션이 적용된 메서드 호출을 대상으로 합니다.

Spring AOP

요약

스프링 프레임워크

: 자바 기반 애플리케이션 개발 오픈 소스 프레임워크

의존성 주입 (DI; Dependency Injection)

: 의존 객체를 외부에서 생성하여 대입하는 것

제어의 역전 (Inversion of Control)

: 프로그램 제어권의 위치가 개발자에서 프레임워크로 뒤집히는 것

IoC 컨테이너 (Inversion of Control Container)

: 스프링 프레임워크에서 의존성 관리가 필요한 객체들을 관리하는 영역

관점 지향 프로그래밍 (AOP; Aspect Oriented Programming)

: 중심적 관심사와 횡단적 관심사를 분리시켜 특정 조건과 타이밍에 맞게 중심로직에 횡단로직을 적용하는 프로그래밍 패러다임