3.1 Spring Core

모든 실습 코드(+주석) 링크: 프로젝트명: diexam01

1) Spring이란?

Spring Framework란?

• 엔터프라이즈급 애플리케이션을 구축할 수 있는 가벼운 솔루션이자, 원스-스탑-숍(One-Stop-Shop)
• 원하는 부분만 가져다 사용할 수 있도록 모듈화가 잘 되어 있습니다.
• IoC 컨테이너입니다.
• 선언적으로 트랜잭션을 관리할 수 있습니다.
• 완전한 기능을 갖춘 MVC Framework를 제공합니다.
• AOP 지원합니다.
• 스프링은 도메인 논리 코드와 쉽게 분리될 수 있는 구조로 되어 있습니다.

프레임 워크 모듈

• 스프링 프레임워크는 약 20개의 모듈로 구성되어 있습니다.
• 필요한 모듈만 가져다 사용할 수 있습니다.

AOP와 인스트루멘테이션 (Instrumentation)

• spring-AOP : AOP 얼라이언스(Alliance)와 호환되는 방법으로 AOP를 지원합니다.
• spring-aspects : AspectJ와의 통합을 제공합니다.
• spring-instrument : instrumentation을 지원하는 클래스와 특정 WAS에서 사용하는 클래스로 더 구현체를 제공합니다. 참고로 BCI(Byte Code Instrumentations)은 런타임이나 로드(Load) 때 클래스의 바이트 코드에 변경을 가하는 방법을 말합니다.

메시징(Messaging)

• spring-messaging : 스프링 프레임워크 4는 메시지 기반 어플리케이션을 작성할 수 있는 Message, MessageChannel, MessageHandler 등을 제공합니다. 또한, 해당 모듈에는 메소드에 메시지를 맵핑하기 위한 어노테이션도 포함되어 있으며, Spring MVC 어노테이션과 유사합니다.

Data Access/Integration

• 데이터 엑세스/통합 계층은 JDBC, ORM, OXM, JMS 및 트랜잭션 모듈로 구성되어 있다.
• spring-jdbc : 자바 JDBC프로그래밍을 쉽게 할 수 있도록 기능을 제공합니다. (이 과정에서 배우는 것. 데이터베이스에 데이터를 넣거나 읽어올 때 사용한다)
• spring-tx : 선언적 트랜잭션 관리를 할 수 있는 기능을 제공합니다. (이 과정에서 배우는 모듈)
• spring-orm : JPA, JDO및 Hibernate를 포함한 ORM API를 위한 통합 레이어를 제공합니다.
• spring-oxm : JAXB, Castor, XMLBeans, JiBX 및 XStream과 같은 Object/XML 맵핑을 지원합니다.
• spring-jms : 메시지 생성(producing) 및 사용(consuming)을 위한 기능을 제공, Spring Framework 4.1부터 spring-messaging모듈과의 통합을 제공합니다.

웹(Web)

• 웹 계층은 spring-web, spring-webmvc, spring-websocket, spring-webmvc-portlet 모듈로 구성됩니다.
• spring-web : 멀티 파트 파일 업로드, 서블릿 리스너 등 웹 지향 통합 기능을 제공한다. HTTP클라이언트와 Spring의 원격 지원을 위한 웹 관련 부분을 제공합니다. (이 과정에서 배우는 모듈)
• spring-webmvc : Web-Servlet 모듈이라고도 불리며, Spring MVC 및 REST 웹 서비스 구현을 포함합니다. (이 과정에서 배우는 모듈)
• spring-websocket : 웹 소켓을 지원합니다.
• spring-webmvc-portlet : 포틀릿 환경에서 사용할 MVC 구현을 제공합니다.

---

 

2) Spring IoC/DI 컨테이너

컨테이너(Container)

컨테이너는 인스턴스의 생명주기를 관리하며, 생성된 인스턴스에게 추가적인 기능을 제공합니다.

예를 들어, Servlet을 실행해주는 WAS는 Servlet 컨테이너를 가지고 있다고 말합니다.

WAS는 웹 브라우저로부터 서블릿 URL에 해당하는 요청을 받으면, 서블릿을 메모리에 올린 후 실행합니다.

개발자가 서블릿 클래스를 작성했지만, 실제로 메모리에 올리고 실행하는 것은 WAS가 가지고 있는 Servlet 컨테이너입니다.

Servlet컨테이너는 동일한 서블릿에 해당하는 요청을 받으면, 또 메모리에 올리지 않고 기존에 메모리에 올라간 서블릿을 실행하여 그 결과를 웹 브라우저에게 전달합니다.

컨테이너는 보통 인스턴스의 생명주기를 관리하며, 생성된 인스턴스들에게 추가적인 기능을 제공하는 것을 말합니다.

IoC(Inversion of Control)

객체를 대신 생성해주고 싱글턴으로 관리해주는 기능

컨테이너가 코드 대신 오브젝트의 제어권을 갖고 있어 IoC(제어의 역전)이라 합니다.

예를 들어, 서블릿 클래스는 개발자가 만들지만, 그 서블릿의 메소드를 알맞게 호출하는 것은 WAS입니다.

이렇게 개발자가 만든 어떤 클래스나 메소드를 다른 프로그램이 대신 실행해주는 것을 제어의 역전이라고 합니다.

"공장을 매번 내가 만들어야 되는 거 되게 귀찮은 일일 텐데 Spring이 그 일을 대신해주는 거예요.

Spring이 갖고 있는 Bean Factory라든가 Application Context 같은 것이 이런 공장의 역할을 해줄 거다."

DI(Dependency Injection)

DI는 의존성 주입이란 뜻을 가지고 있으며, 클래스 사이의 의존 관계를 빈(Bean) 설정 정보를 바탕으로 컨테이너가 자동으로 연결해주는 것을 말합니다.

공장이 생성해준 객체를 어떻게 쓸 거예요 하는 게 중요할 텐데요. DI가 해당 객체를 주입받는 방법 중에 하나다

DI가 적용 안 된 예: 개발자가 직접 인스턴스를 생성합니다.

class 엔진 {  
}
class 자동차 {
  엔진 v5 = new 엔진();
}

Spring에서 DI가 적용된 예

엔진 type의 v5변수에 아직 인스턴스가 할당되지 않았습니다.

어디에서도 엔진에 대한 생성을 하지 않았는데 컨테이너가 v5변수에 인스턴스를 할당해주게 됩니다.

@Component
class 엔진 { 
}

@Component
class 자동차 {
  @Autowired
  엔진 v5;
}

Spring에서 제공하는 IoC/DI 컨테이너

• BeanFactory : IoC/DI에 대한 기본 기능을 가지고 있습니다.

• ApplicationContext : BeanFactory의 모든 기능을 포함하며, 일반적으로 BeanFactory보다 추천됩니다. 트랜잭션처리, AOP등에 대한 처리를 할 수 있습니다. BeanPostProcessor, BeanFactoryPostProcessor등을 자동으로 등록하고, 국제화 처리, 어플리케이션 이벤트 등을 처리할 수 습니다.

• BeanPostProcessor : 컨테이너의 기본로직을 오버라이딩하여 인스턴스화 와 의존성 처리 로직 등을 개발자가 원하는 대로 구현할 수 있도록 합니다.

• BeanFactoryPostProcessor : 설정된 메타데이터를 커스터마이징 할 수 있습니다.

---

3) xml파일을 이용한 설정

에러사항

Maven으로 Java프로젝트 만들기

Archetype은 Maven 프로젝트에서 제공해주는 템플릿이다.

어떤 것을 지정하느냐에 따라서 프로젝트 구조가 달라지고 예제 등이 들어있을 수 있습니다.

pom.xml 파일에 JDK를 사용하기 위한 플러그인 설정을 추가합니다.

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>4.3.14.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <!-- jdk 1.8 사용하기 위해. -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.6.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

App.java과 AppTest.java으로 잘 작동하는지 확인해본다.

Bean class란?

예전에는 Visual한 컴포넌트를 Bean이라고 불렀지만, 근래 들어서는 일반적인 Java클래스를 Bean클래스라고 보통 말합니다.

Bean클래스의 3가지 특징은 다음과 같습니다.

• 기본생성자를 가지고 있습니다.
• 필드는 private하게 선언합니다.
• getter, setter 메소드를 가집니다.
• getName() setName() 메소드를 name 프로퍼티(property)라고 합니다. (용어 중요)

Spring컨테이너가 관리하는 객체를 빈(Bean)이라고 말합니다.

(직접 new연산자로 생성해서 사용하는 객체는 빈(Bean)이라고 말하지 않습니다.)

Spring은 빈을 생성할 때 기본적으로 싱글톤(Singleton) 객체로 생성합니다.

싱글톤이란 메모리에 하나만 생성한다는 것입니다.

UserBean.java

public class UserBean {        
        private String name;
        private int age;
        private boolean male;

        public UserBean() {    }
        public UserBean(String name, int age, boolean male) {
            this.name = name; this.age = age; this.male = male;
        }
        getter, setter 생략
    }

Spring Bean Factory를 이용하여 Bean객체 이용하기

1. pom.xml 파일에 Spring 라이브러리를 추가합니다.

https://mvnrepository.com/artifact/org.springframework/spring-context

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>${spring.version}</version>
</dependency>

참고로 context가 공장이다.

maven repository에 원하는 의존성(spring context)을 검색하고 spring version 스프링버전과 dependency 부분을 복사하여 붙여넣으면 된다.

2. 추가된 라이브러리 확인합니다.

maven dependencies 폴더에 추가된 것을 확인할 수 있다.

3. src/main 폴더 밑에 resources 소스 폴더를 생성합니다. 해당 폴더에 applicationContext.xml 파일을 생성합니다.

applicationContext.xml

설정을 담고 있는 파일들을 applicationContext.xml로 한다.

애플리케이션 context(공장)들에게 설정들을 알려주도록 한다.

<?xml version="1.0" encoding="UTF-8"?>
<!-- xml 파일은 반드시 나 xml이고, 버전은 뭐고, 캐릭터 셋은 뭘 쓸 거야를 알려줘야해 -->

<!-- 루트 element는 beans 라는 element에요 xml 파일로 Spring 설정 파일을 만들게 되면 가장 바깥쪽 태그, 이것을 루트 element라고 하거든요 이게 반드시 beans로 되어있어야 한다. 그리고 xml 스키마에 대한 설정도 되어있어야해요. 해당 설정 파일은 spring 컨테이너가 읽어들이는데 beans 태그 안에 아무것도 없으면 당연히 아무 일도 안하겠죠. -->
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

applicationContext.xml파일에 이어서 bean 태그를 하나 입력해보겠습니다.

 <bean id="userBean" class="kr.or.connect.diexam01.UserBean"></bean>

위의 태그는 다음과 같은 의미를 가집니다.

UserBean userBean = new UserBean();

ApplicationContext를 이용해서 설정파일을 읽어들여 실행하기

 

ApplicationContextExam01.java

 

 

main 밑에 있는 resources 폴더에서 생성한 xml 파일은 자동으로 classpath로 지정이 된다. 그렇기 때문에 ClassPathXmlApplicationContext 로 읽어서 사용할 수가 있다.

ClassPathXmlApplicationContext 인스턴스가 생성될 때 생성자 파라미터로 지정된 설정 파일을 읽어들인 후에 그 안에 선언된 bean들을 모두 메모리에 올려준다.

DI 확인하기

이번에는 DI 즉 의존성 주입을 확인해보도록 하겠습니다.

Car와 Engine이라는 클래스 2개를 생성합니다.

Engine.java

Car.java

위의 Car 클래스가 제대로 동작하도록 하려면 보통 다음과 같은 코드가 작성되야 합니다.

Engine e = new Engine();
Car c = new Car();
c.setEngine(e);
c.run();

1, 2 번째 줄을 Spring 컨테이너에게 맡기기 위해 설정파일에 다음과 같은 코드를 입력합니다.

<bean id="e" class="kr.or.connect.diexam01.Engine"></bean>
<bean id="car" class="kr.or.connect.diexam01.Car">
<property name="engine" ref="e"></property>
</bean>

즉, 위의 XML설정은 다음과 같은 의미를 가집니다.

Engine e = new Engine();
Car c = new Car();
c.setEngine( e );

 

이번엔 위의 설정 파일을 읽어들여 실행하는 ApplicationContextExam02.java를 작성해보도록 하겠습니다.

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ApplicationContextExam02 {
    public static void main(String[] args) {
        // ClassPath에서 설정을 읽어옴
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        Car car = (Car) ac.getBean("c"); // 등록했던 bean id 주기
        car.run();

        ((ConfigurableApplicationContext)ac).close();
        }
}

---

4) Java Config를 이용한 설정

 

우리는 앞에서 xml을 이용한 설정에 대해 살펴보았습니다. 이번 시간엔 xml 설정을 대체할 수 있는 Java Config에 대해 배워보도록 하겠습니다. Java Config란 말그대로 자바 클래스 파일을 설정 파일로 사용을 하겠다는 것입니다. xml설정과 비교해서 Java Config를 사용하는 이유는, 클래스의 경우 이클립스나 인텔리J와 같은 IDE에서 오타 등을 발견하기 쉽고, 자동완성 등을 지원해서 편리하기 때문입니다.

스프링에서는 Java Config로 사용하는 클래스에는 @Configuration이라는 어노테이션을 붙여서 표시를 합니다.

Java config를 이용한 설정을 위한 어노테이션

@Configuration

• 스프링 설정 클래스를 선언하는 어노테이션

@Bean

• bean을 정의하는 어노테이션

@ComponentScan

• @Controller, @Service, @Repository, @Component 어노테이션이 붙은 클래스를 찾아 컨테이너에 등록

@Component

• 컴포넌트 스캔의 대상이 되는 애노테이션 중 하나로써 주로 유틸, 기타 지원 클래스에 붙이는 어노테이션

@Autowired

• 주입 대상이되는 bean을 컨테이너에 찾아 주입하는(객체생성) 어노테이션

Java Config를 이용해 설정하기

ApplicationConfig.java

package kr.or.connect.diexam01;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//xml 설정을 대체할 수 있는 Java Config
//자바 클래스 파일을 설정 파일로 사용

@Configuration
public class ApplicationConfig {
    @Bean
    public Car car(Engine e) {
        Car c = new Car();
        c.setEngine(e);
        return c;
    }

    @Bean
    public Engine engine() {
        return new Engine();
    }
}

@Configuration 은 스프링 설정 클래스라는 의미를 가집니다.

JavaConfig로 설정을 할 클래스 위에는 @Configuration가 붙어 있어야 합니다.

ApplicationContext중에서 AnnotationConfigApplicationContext는 JavaConfig클래스를 읽어들여 IoC와 DI를 적용하게 됩니다.

이때 설정파일 중에 @Bean이 붙어 있는 메소드들을 AnnotationConfigApplicationContext는 자동으로 실행하여 그 결과로 리턴하는 객체들을 기본적으로 싱글턴으로 관리를 하게 됩니다.

 

ApplicationContextExam03.java

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextExam03 {
    public static void main(String[] args) {
        // 설정을 가지고 있는 클래스를 읽어들이면 됨. 클래스 파일을 읽도록.
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig.class);

        Car car = (Car) ac.getBean(Car.class); // "메서드 이름" 아님 Car의 클래스를 주세요
        car.run();

        ((ConfigurableApplicationContext)ac).close();
        }


}

파라미터로 요청하는 class 타입으로 지정 가능합니다.

Car car = ac.getBean(Car.class);

---

ApplicationConfig2.java

package kr.or.connect.diexam01;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("kr.or.connect.diexam01")
public class ApplicationConfig2 {

}

기존 JavaConfig에서 빈을 생성하는 메소드를 모두 제거했습니다.

단, @Configuration아래에 @ComponentScan이라는 어노테이션을 추가했습니다.

@ComponentScan어노테이션은 파라미터로 들어온 패키지 이하에서 @Controller, @Service, @Repository, @Component 어노테이션이 붙어 있는 클래스를 찾아 메모리에 몽땅 올려줍니다.

기존의 Car클래스와 Engine클래스 위에 @Component를 붙이도록 하겠습니다.

수정된 JavaConfig를 읽어들여 실행하는 클래스를 보도록 하겠습니다.

 

ApplicationContextExam04.java

package kr.or.connect.diexam01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class ApplicationContextExam04 {
    public static void main(String[] args) {
        // 설정을 가지고 있는 클래스를 읽어들이면 됨. 클래스 파일을 읽도록.
        ApplicationContext ac = new AnnotationConfigApplicationContext(ApplicationConfig2.class);

        Car car = (Car) ac.getBean(Car.class); // "메서드 이름" 아님 Car의 클래스를 주세요
        car.run();

        ((ConfigurableApplicationContext)ac).close();
        }    
}

정리:

Spring에서 사용하기에 알맞게 @Controller, @Service, @Repository, @Component 어노테이션이 붙어 있는 객체들은 ComponentScan을 이용해서 읽어들여 메모리에 올리고 DI를 주입하도록 하고, 이러한 어노테이션이 붙어 있지 않은 객체는 @Bean어노테이션을 이용하여 직접 생성해주는 방식으로 클래스들을 관리하면 편리합니다.