IntelliJ에서 스프링 프로젝트 생성 및 설정하기(Gradle, Tomcat, MyBatis, Oracle, Java Configuration)

개발 도구 및 환경

 

Windows 10 OS  

IntelliJ 2019.2.3
JDK 1.8
Tomcat 9.0.19
Gradle
Oracle RDBMS

MyBatis

Java Configuration

 

 

 

References

 

[도서] 코드로 배우는 스프링 웹 프로젝트(개정판) - 구멍가게 코딩단

 

 

 

Goal

 

Spring 기본설정, MyBatis연동, JSP 화면 띄우기

 

 

 

 

---

 

시작에 앞서 gradle을 이용한 라이브러리 빌드시 라이브러리가 충돌하는 문제와 잦은 오류 탓에 인텔리제이가 제공하는 Framework Support를 이용하지 않고 직접 의존성을 추가하는 방법임을 알려드립니다.

 

 

1. 프로젝트 생성

Gradle 프로젝트를 생성해줍니다.

Additional Libraries로 Java와 Web을 선택합니다.

 

 

GroupId와 ArtifactId를 입력하고 finish해줍니다. 

 

 

2. Tomcat 서버설정 및 구동 테스트 

 

우측 상단의 Add Configuration을 클릭합니다.

 

 

Run/Debug Configurations 창이 뜨면, 좌측 상단의 + 버튼을 누르고

Tomcat Server - Local을 클릭합니다. 

 

 

기존에 설정된 내용이 없다면 Configure...버튼을 클릭하여 사용할 Tomcat의 디렉토리를 선택합니다.

제 경우 C:\Program Files\Apache Software Foundation\Tomcat 9.0 로 설정되어있습니다. 

Name을 입력하고, port설정을 해줍니다. 사용중인 8080 Port가 있다면 다른 포트로 설정합니다.

 

 

 

그 다음 Deployment탭을 클릭하고 우측 + 버튼을 눌러 Artifact를 클릭하면 아래와 같은 창이 뜹니다.

OK를 클릭합니다.

 

 

Application context경로를 깔끔하게 슬래시('/')로 설정해주고 설정을 마칩니다. 

클라이언트의 요청 URL에 포트뒤에 오는 내용으로, 프로젝트의 절대경로로 URL을 설정하기 위함입니다.

* 참고 : 클라이언트(브라우저)가 요청하는 URL정보 
요청을 보낼 서버의 IP 주소 : Port 번호 / App(프로젝트) 이름 / 달라고 요청하는 HTML
ex. localhost:8080/basic_board_project/index.html 
Application context를 '/'로 설정시 
ex. localhost:8080/index.html 

 

 

우측 상단의 Run버튼을 눌러 서버를 실행해봅니다. 

 

 

브라우저에 이렇게 고양이가 등장하면 성공입니다. 

 

 

콘솔창도 한번 확인해줍니다.

 

 

 

서버 구동 테스트가 완료되면 Run버튼 옆의 중지 버튼을 눌러 서버를 종료합니다. 

 

 

3. 라이브러리 의존성 추가

 

프로젝트 실행에 기본적으로 필요한 라이브러리를 추가해봅시다.

DB연결 및 Mapper 테스트까지 진행할 예정이라 DB 관련 라이브러리도 모두 추가했습니다.  

필요할때마다 추가하기 귀찮은 것도 있고요... 해당 라이브러리를 사용할때 다시한번 언급하겠습니다. 

 

이상하게도 ojdbc 라이브러리 추가에서 애를 먹었는데, (무엇이 문제인진...) 구글링해서 찾은 대부분의 nexus 레파지토리는 닫힌 상태였고 우여곡절 끝에 찾은 다른 레파지토리를 이용했습니다. 
아래와 같이 repositories부분을 추가 설정해주면 됩니다. (아니면 직접 라이브러리를 다운받아 추가하셔도 됩니다) 

 

plugins {
    id 'java'
    id 'war'
}

group 'com.dreamer'
version '1.0-SNAPSHOT'

sourceCompatibility = 1.8

repositories {
    mavenCentral()
    // for using OJDBC
    maven { url "http://maven.jahia.org/maven2"}
}

dependencies {
    // https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api
    providedCompile group: 'javax.servlet', name: 'javax.servlet-api', version: '4.0.0'
    compileOnly 'org.projectlombok:lombok:1.18.10'
    annotationProcessor 'org.projectlombok:lombok:1.18.10'
    testCompile('org.projectlombok:lombok:1.18.10')
    testAnnotationProcessor "org.projectlombok:lombok:1.18.10"

    // https://mvnrepository.com/artifact/log4j/log4j
    compile group: 'log4j', name: 'log4j', version: '1.2.17'

    // spring
    compile group: 'org.springframework', name: 'spring-context', version: '5.1.7.RELEASE'
    compile group: 'org.springframework', name: 'spring-test', version: '5.1.7.RELEASE'
    compile group: 'org.springframework', name: 'spring-webmvc', version: '5.1.7.RELEASE'
    compile group: 'org.springframework', name: 'spring-jdbc', version: '5.1.7.RELEASE'
    compile group: 'org.springframework', name: 'spring-tx', version: '5.1.7.RELEASE'

    // hikariCP
    compile group: 'com.zaxxer', name:'HikariCP', version: '2.7.8'
    compile group: 'org.projectlombok', name: 'lombok', version: '1.18.8'
    annotationProcessor('org.projectlombok:lombok:1.18.8')

    // mybatis
    compile group: 'org.mybatis', name: 'mybatis-spring', version: '1.3.2'
    compile group: 'org.mybatis', name: 'mybatis', version: '3.4.6'

    // oracle
    compile group: 'com.oracle', name: 'ojdbc7', version: '12.1.0.2'

    // log4j
    compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.25'
    compile group: 'org.slf4j', name: 'jcl-over-slf4j', version: '1.7.25'
    compile group: 'org.slf4j', name: 'slf4j-log4j12', version: '1.7.25'

    testCompile group: 'junit', name: 'junit', version: '4.12'
}

 

 

내용을 변경하면 우측 하단에 이런 알람창이 뜹니다.

Enable Auto-Import를 클릭하여 Auto Import기능을 활성화 해줍니다.

build.gradle내용이 변경될 때 마다 자동으로 업데이트 해 줄 것입니다.

 

 

 

Lombok 의존성을 추가했지만 따로 켜주지 않으면 사용할 수 없습니다.

File-Settings - Build, Execution, Deployment - Compiler - Annotation Processors로 들어가

Enable annotation processing을 클릭합니다.

 

 

 

Log4j 라이브러리도 추가했기에 Log4j 프레임워크가 사용할 설정파일을 만들어줘야 합니다.

log4j가 런타임시 로그를 기록할 때 사용되는 appender 정보와 로그 level 정보, 로그가 기록될 파일의 이름이나 로그정책 등이 모두 설정파일에 나타나야 합니다.

 

src/main/resources에 log4j.properties파일을 생성하고 아래와 같이 작성합니다.

 

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern= %-5p [%c{1}:%L] - %m%n

log4j.rootLogger=INFO, stdout

 

또한 테스트 코드가 실행될 때의 로그와 관련된 설정은 src/test/resources를 탐색하므로, 작성된 log4j.properties파일을 src/test/resources에도 복사하여 아래와 같은 구조를 만들어 줍니다.

 

 

 

4. root-context 설정(Java Configuration) 및 DB Connection 테스트 

 

이제 Configuration을 할 차례입니다. 저는 Java Config를 이용하겠습니다.

 

Spring은 Context라는 영역을 만들어 Bean들을 관리하는데, 여러개의 Context를 가질 수 있고 servlet-context > root-context의 계층 구조를 가지고 있습니다. 

이 중 root-context 영역에 대한 설정을 담당하는 파일이 root-context.xml입니다. 

Web application의 Business/Persistence Layer를 위한 설정으로, 데이터의 조회 및 처리 등 Database에 관한 Bean들에 대한 설정으로 이루어집니다. 

 

servlet-context 영역에 대한 설정을 담당하는 servlet-context.xml은 Web application의 요청을 받기 위한 Entry Point(Servlet)의 Context 설정으로, 요청에 대한 처리를 직접 해줄 Controller의 매핑 설정(Handler Mapping), View를 어떻게 처리할 것인지에 대한 설정(View Resolver) 등이 존재합니다. 

 

src/main/java패키지의 하위에 아래와 같이 디렉토리를 추가하고 RootConfig.java파일을 생성합니다.  root-context.xml을 대체하는 자바 설정파일입니다.

 

 

 

RootConfig.java를 작성해줍니다. 후에 하나둘 설정을 추가할 예정입니다. 일단 이렇게 비워두고 

@Configuration 어노테이션을 이용해 이 클래스가 설정파일임을 표기해줍시다. 

 

package com.dreamer.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class RootConfig {

}

 

그리고 아직 빈들을 설정해 주진 않았지만, 이 설정파일을 잘 읽고 Application Context가 정상적으로 로딩되는지 테스트코드를 통해 확인해봅시다. 

src/test/java에 com.dreamer.loading패키지를 만들어 LoadingTests.java 클래스를 추가하고 아래와 같이 작성해줍니다. 

 

package com.dreamer.loading;

import com.dreamer.config.RootConfig;
import lombok.extern.log4j.Log4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static junit.framework.TestCase.assertNotNull;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RootConfig.class})
@Log4j
public class LoadingTests {

    @Autowired
    private ApplicationContext ctx;

    @Test
    public void testLoding() {
        log.info(ctx);
        assertNotNull(ctx);
    }
}

 

@RunWith 어노테이션은 테스트 시 필요한 클래스를 지정하는 어노테이션입니다. 스프링은 SpringJUnit4ClassRunner 클래스가 대상이 됩니다. 

@ContextConfiguration 어노테이션은 스프링이 실행되면서 어떤 설정 정보를 읽어들여야 하는지를 명시하는 것입니다. 방금전 만든 RootConfig 클래스를 지정해줍니다. 

 

앞으로의 테스트 클래스는 모두 Application Context 로딩을 위한 설정이 담긴 이 LoadingTests.java를 상속받아 @RunWith나 @ContextConfiguration등의 어노테이션을 쓰지 않고도 원활한 테스트 구동이 가능하도록 할 것 입니다. 

 

테스트 메서드를 실행시켜 문제없이 로딩되는지 확인하고 RootConfig.java를 수정해봅시다. 

 

package com.dreamer.config;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class RootConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName("oracle.jdbc.driver.OracleDriver");
        hikariConfig.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
        hikariConfig.setUsername("아이디");
        hikariConfig.setPassword("비밀번호");
        HikariDataSource dataSource = new HikariDataSource(hikariConfig);
        return dataSource;
    }

}

 

일반적으로 여러 명의 사용자를 동시에 처리해야하는 웹 애플리케이션의 경우 DB연결을 이용할 때는 Connection Pool을 이용하므로, 아예 스프링에 커넥션 풀을 등록해서 사용합니다.

Java에서는 DataSource라는 인터페이스를 통해서 커넥션 풀을 사용합니다. DataSource를 통해 매번 DB와 연결하는 방식이 아닌, 미리 연결을 맺어주고 반환하는 구조를 이용하여 성능향상을 꾀합니다. 

저 위에서 미리 Dependency에 추가한 HikariCP가 그 커넥션 풀 라이브러리입니다.

Hikariconfig를 통해 db정보를 셋팅해주고 datasource를 생성합니다.

 

설정이 완료되었으면 RootConfig에 설정된 DataSource를이용해 DB와의 연결이 잘 이루어지는지 등을 확인하는 Test코드를 아래와 같이 작성해봅시다. 

 

package com.dreamer.loading;

import static org.junit.Assert.fail;
import lombok.extern.log4j.Log4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import javax.sql.DataSource;
import java.sql.Connection;

@Log4j
public class DBConnectionTests extends LoadingTests {

    @Autowired
    private DataSource dataSource;

    @Test
    public void connectTest() {

        try (Connection conn = dataSource.getConnection()) {
            log.info(conn);
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

}

 

자바 7버전에서부터 추가된 try - with - resources 문을 사용했습니다. 

try - catch - finally문을 이용해 예외처리를 하고 finally 구문에 close()를 하게 된다면, close()시에도 발생할 수 있는 예외에 그 안에 또 다시 try-catch문을 작성해야 할 수 있습니다. 

위와 같은 try - with - resources문은 그럴 필요가 없이, try 뒤에오는 소괄호 안에 작성한 내용(입출력 스트림을 생성하는 로직)에서 입출력 처리 시 예외가 발생하는 경우, JVM이 자동으로 close()를 호출하여 자원을 반납시켜 줍니다.

이 때 try()안의 객체는 AutoCloseable을 구현한 객체여야 합니다. 

 

이번에는 MyBatis를 연동해보겠습니다. 

스프링 프레임워크의 특징 중 하나는 다른 프레임워크들과의 연동을 쉽게 하는 추가적인 라이브러리들이 많다는 것입니다. MyBatis는 좀 더 빠르게 SQL을 처리할 수 있도록 하는 라이브러리 인데요, 우리는 위에서 미리 라이브러리를 추가했습니다. 

mybatis/mybatis-spring/spring-jdbc/spring-tx가 그에 해당합니다. 

 

MyBatis에서 가장 핵심적인 객체는 SQLSession과 SQLSession을 만들어 내는 SQLSessionFactor입니다. 우리는 개발시에 SQLSession을 통해서 Connection을 생성하거나 원하는 SQL을 전달하고, 결과를 리턴받는 구조로 작성됩니다.

스프링에 SqlSessonFactory를 등록하는 작업은 SqlSessionFactoryBean을 이용합니다.

 

RootConfig.java를 수정하여 아래와 같이 만들어 줍니다.

 

package com.dreamer.config;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class RootConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig hikariConfig = new HikariConfig();
        hikariConfig.setDriverClassName("oracle.jdbc.driver.OracleDriver");
        hikariConfig.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:orcl");
        hikariConfig.setUsername("아이디");
        hikariConfig.setPassword("비밀번호");
        HikariDataSource dataSource = new HikariDataSource(hikariConfig);
        return dataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dataSource());
        return (SqlSessionFactory)sqlSessionFactory.getObject();
    }

}

 

SqlSessionFactoryBean을 이용해서 sqlSession을 사용해보겠습니다.

아까 만들었던 DBConnectionTests 클래스 안에 SqlSessionFactory와 테스트메서드를 추가해줍니다.

 

package com.dreamer.loading;

import static org.junit.Assert.fail;

import lombok.extern.log4j.Log4j;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import javax.sql.DataSource;
import java.sql.Connection;

@Log4j
public class DBConnectionTests extends LoadingTests {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Test
    public void connectTest() {
        try (Connection conn = dataSource.getConnection()) {
            log.info(conn);
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

    @Test
    public void myBatisTest() {
        try (SqlSession session = sqlSessionFactory.openSession();
             Connection conn = session.getConnection();) {
            log.info(session);
            log.info(conn);
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

}

 

우리는 이렇게 만들어진 SqlSession객체의 메서드를 이용해 DB작업을 할 수 있지만(session.selectList, session.insert 등), 좀 더 편하게 작업하기 위해서는 'SQL을 어떻게 처리할 것인가'를 별도로 설정해주고, 자동으로 처리되는 방식을 이용하는 것이 좋습니다. 

이를 위해서 MyBatis의 Mapper를 이용합니다. 

Mapper는 SQL과 그에 대한 처리를 지정하는 역할을 합니다. MyBatis-Spring을 이용하는 경우에는 Mapper를 XML과 인터페이스+어노테이션의 형태로 작성할 수 있습니다.

저는 인터페이스+어노테이션을 이용하겠습니다.

 

com.dreamer.mapper 디렉토리를 생성해주고 그 안에 TimeMapper 인터페이스를 작성해봅시다. 

Oracle DB에서 현재 시간을 확인하는 쿼리를 작성하고 출력해 볼 예정입니다.  

(디렉토리는 아래와 같은 구조가 됩니다.)

 

 

package com.dreamer.mapper;

import org.apache.ibatis.annotations.Select;

public interface TimeMapper {

    @Select("select sysdate from dual")
    public String getTimeOracle();

}

 

그리고 이 Mapper를 Spring이 Bean으로써 인식할 수 있도록 RootConfig.java를 수정해줍시다.

RootConfig.java 클래스의 어노테이션을 아래와 같이 하나 추가해주기만 하면 됩니다.

 

 

 

Mapper를 설정하는 작업은 각각의 XML이나 Mapper 인터페이스를 설정할 수도 있지만, 매번 그렇게 하게 된다면 너무 번잡하기 때문에 자동으로 com.dreamer.mapper 패키지를 인식하는 방식으로 작성하는 것이 가장 편리합니다.  

프로젝트를 진행하며 작성될 모든 Mapper들은 위의 경로에 들어가게 될 것입니다. 

 

 

이 쿼리가 제대로 작동하는지 테스트 해봅시다. 

src/test/java/com.dreamer.mapper 디렉토리를 생성해 TimeMapperTests.java를 생성하고 아래와 테스트 코드를 작성합니다. 

 

 

 

package com.dreamer.mapper;

import com.dreamer.loading.LoadingTests;
import lombok.Setter;
import lombok.extern.log4j.Log4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

@Log4j
public class TimeMapperTests extends LoadingTests {

    @Setter(onMethod_ = {@Autowired})
    private TimeMapper timeMapper;

    @Test
    public void oracleTimeMapperAnnoTest() {
        log.info("Current Time is......");
        log.info(timeMapper.getTimeOracle());
    }

}

 

테스트를 구동시켜보고 로그가 아래처럼 정확히 뜨는지 확인해봅시다. 

 

 

 

 

5. MVC구조 만들기(servlet-context 설정 등)

이제 이렇게 DB에서 얻어온 시간을 JSP화면에 띄워봅시다. 

web.xml을 대신하는 WebConfig.java와 

servlet-context.xml을 대신하는 ServletConfig.java 클래스를 아래와 같은 구조로 생성합니다.

 

 

WebConfig는 Tomcat의 구동과 관련된 설정입니다. 프로젝트의 구동은 web.xml에서 시작하며 서버 시작 시 web.xml이 없으면 WebApplicationInitializer가 구현된 클래스를 찾아가 셋팅을 시작합니다.

 

스프링 3.2부터는 AbstractAnnotationConfigDispatcherServletInitializer 라는 추상클래스를 구현하면 됩니다. 이 클래스는 WebApplicationInitializer의 구현체로 여러 단계에 걸쳐 구현되어있는데, 좀 더 디테일한 설정이 필요한 경우에는 AbstractAnnotationConfigDispatcherServletInitializer의 상위 클래스인 AbstractDispatcherServletInitializer을 구현해주면 됩니다. 

 

 

package com.dreamer.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

public class WebConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] {RootConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] {ServletConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] {"/"};
    }
}

 

WebConfig에 의해 RootConfig의 설정파일을 읽어 Bean들을 스프링의 영역(Context) 안에 생성시키고, 객체들 간의 의존성을 처리합니다. 

RootConfig에 의한 처리가 끝난 후에는 스프링MVC에서 사용하는 DispatcherServlet이라는 서블릿과 관련된 설정이 동작합니다.

이때 사용하는 설정파일이 servlet-context.xml로, ServletConfig클래스로 대체 할 것입니다. 

Web application의 요청을 받기 위한 Entry Point(Servlet)의 Context 설정으로, 요청에 대한 처리를 직접 해줄 Controller의 매핑 설정(Handler Mapping), View를 어떻게 처리할 것인지에 대한 설정(View Resolver) 등이 존재합니다. 

 

ServletConfig.java를 아래와 같이 작성해줍니다. 

 

package com.dreamer.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@EnableWebMvc
@ComponentScan(basePackages = {"com.dreamer.controller"})
public class ServletConfig implements WebMvcConfigurer {

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {

        InternalResourceViewResolver bean = new InternalResourceViewResolver();
        bean.setViewClass(JstlView.class);
        bean.setPrefix("/WEB-INF/views/");
        bean.setSuffix((".jsp"));
        registry.viewResolver(bean);
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }

}

 

WebMvcConfigurer는 스프링 MVC와 관련된 설정을 메서드로 오버라이드 하는 형태를 이용할 때 사용합니다.

ServletConfig 클래스는 @ComponentScan을 이용해서 다른 패키지에 작성된 스프링의 객체(Bean)를 인식할 수 있습니다. 클라이언트의 요청을 처리해줄 Controller의 패키지를 설정했습니다. 

 

스프링 MVC를 이용하는 경우, 개발자들은 직접적으로 HttpServletRequest/HtppServletResponse등과 같이 Servlet/JSP의 API를 사용할 필요성이 없어집니다. 스프링 MVC가 개발자들과 Servlet/JSP 사이의 중간 역할을 하기 때문입니다. 

 

스프링은 클라이언트의 모든 request를 DispatcherServlet을 통해 받습니다.(Front-Controller 구조) 

그리고 DispatcherServlet은 HandlerMapping을 통해 해당 Request의 처리를 담당하는 컨트롤러를 찾습니다.  

컨트롤러에 @RequestMapping 어노테이션이 적용되어있는 것을 기준으로 컨트롤러를 찾고, HandlerAdapter를 이용해 해당 컨트롤러를 동작시킵니다.

 

개발자가 작성한 Controller는 클라이언트의 Request를 처리하고, 화면(View)으로 데이터를 전달합니다. 이때 View로 전달하는 데이터는 주로 Model이라는 객체에 담아서 전달합니다. Controller는 다양한 타입의 결과를 반환할 수 있는데, 이에 대한 처리는 ViewResolver를 이용하게 됩니다.

 

ViewResolver는 Controller가 반환한 결과를 어떤 View를 통해 처리하는 것이 좋을지 해석하는 역할입니다. 우리는 ServletConfig의 InternalResourceViewResolver를 이용해 설정했습니다. 

 

이제 Controller를 만들어보겠습니다.

 

 

 

 

 

 

 

 

RootConfig와 ServletConfig 

 

 

 

 

 

 

작성중