스프링 MVP 주요 구성 요소

구성 요소  설명
DispatcherServlet 클라이언트 요청을 전달받는다. 컨트롤러에게 클라이언트의 요청을 전달하고, 컨트롤러가 리턴한 결과값을 View에 전달하여 알맞은 응답을 생성하도록 한다.
HandlerMapping 클라이언트의 요청 URL을 어떤 컨트롤러가 처리할지 결정한다.
HandlerAdaptor DispatcherServlet의 처리요청을 반환해서 컨트롤러에게 전달하고, 컨트롤러의 응답 결과를 DispatcherServlet이 요구하는 형식으로 변환한다.
컨트롤러(Controller) 클라이언트의 요청을 처리한 뒤, 결과를 리턴한다. 응답 결과에서 보여줄 데이터를 모델에 담아 전달한다.
ModelAndView 컨트롤러가 처리한 결과 정보 및 뷰 선택에 필요한 정보를 담는다.
ViewResolver 컨트롤러의 처리 결과를 보여줄 뷰를 결정한다.
View(뷰) 컨트롤러의 처리 결과 화면을 생성한다. JSP나 Velocity 템플릿 파일 등을 이용해서 클라이언트에 응답 결과를 전송한다.

 

 

DisDispatcherServlet은 스프링 MVC 프레임워크의 중심이 되는 서블릿 클래스

  • 웹 브라우저의 요청을 DispatcherServlet 이 받게 되며, DispatcherServlet 은 컴포넌트를 이용해서 웹 브라우저의 요청을 처리한 결과를 전송하게 된다.

 

web.xml (DispatcherServlet 설정)

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--DispatcherServlet 등록 -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/mvc-quick-start.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--dispathcer 서블릿에 대한 매핑을 '*.do' 로 지정한다.-->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <!-- 요청 파라미터를 UTF-8로 처리하기 위한 필터를 설정한다. -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

 

스프링 MVC 설정 기초

  • HandlerMapping
  • HanddlerAdapter
  • ViewResolver

HandlerMapping, HanddlerAdapter는 <mvc:annotation-driven> 태그를 이용하면 설정이 끝난다. 따라서, ViewResolver만 추가로 설정해주면 된다.

 

mvc-quick-start.xml

<?xml version="1.0" encoding="UTF-8" ?>
<bean xmls ="http://www.springframework.org/schema/beans"
      xmlns:mvc="http://www.springframework.org/schema/mvc"
      xmlns:xsi="http://wwww.w3.rog/2001/XMLSchema-instace"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/beans/mvc
      http://www.springframework.org/schema/beans/mvc/spring-mvc.xsd">
    <!-- RequesstMappingHandlerMapping과 RequestMappingHandlerAdapter를 빈으로 등록해준다.-->
    <mvc:annotaion-driven/>
    <!-- 뷰 이름을 실제 어떤뷰와 연결할지 결정하는 VeiwResolver를 설정
    prefix + 뷰 이름 + suffix
    - /WEB-INF/view/hello.jsp
    -->
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name = "prefix" value ="/WEB-INF/view/"/>
        <property name ="suffix" value=".jsp"/>
    </bean>
    <bean class ="net.madvirus.spring4.chap07.quickstart.HelloController"/>
</bean>

InternalResourceViewResolver는 JSP를 이용해서 뷰를 생성할 때 사용되는 ViewResolver 구현체이다. 

주의할 점 : ViewResolver의 이름이 "viewResolver"여야한다.

 

@Configuration 사용

@EnableWebMvc 어노테이션을 이용하여 @Configuration 자바 설정을 사용한다.

@EnableWebMvc 어노테이션을 사용하면 <mvc:annotation-driven>과 동일하게 스프링 MVC를 설정하는데 필요한 빈을 자동으로 등록하게 해준다. 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
public class MvcQuickStartConfig {
    @Bean
    public InternalResourceViewResolver viewResolver(){
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/view/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

 

서블릿 매핑에 따른 컨트롤러 경고 매핑과 디폴트 서블릿 설정

DispatcherServlet을 web.xml에 설정할 때 *.do 패턴에 해당하는 요청을 처리하도록 매핑을 설정했었다. 

    <!--DispatcherServlet 등록 -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/mvc-quick-start.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
<!--
web.xml
dispathcer 서블릿에 대한 매핑을 '*.do' 로 지정한다. 
-->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

위의 매핑은 확장자를 이용해서 클라이언트의 요청과 DispatcherServlet을 매핑한다. 이 경우 웹 브라우저에서 입력하는 URL은 아래와 같은 형태를 띄게 된다.

  • http:://localhst:8080/spring4-chap07/hello.do
  • http://somhost/board/article/read.do?articleId=100

 

Spring MVC 실습

  1. .프로젝트 디렉토리를 생성한다.
  2. 프로젝트 디렉토리에서 다음의 세 디렉토리를 생성한다.
  • src/main/java
    • 자바 소스 코드
  • src/main/resources
    • xml등의 자원 파일
  • src/main/webapp
    • 웹 어플리케이션을 위한 폴더

3. 웹 어플리케이션을 위한 pom.xml 파일을 프로젝트 디렉토리에 생성한다.

 

pom.xml

서블릿, JSP, JSTL을 위한 의존설정

스프링 MVC 실행을 위한 의존설정

메이븐 웹 프로젝트를 실행 시키기위한 Jetty 프러그인 설정

  • 의존모듈
    • 서블릿, JSP
    • 스프링 MVC 모듈 및 스프링 MVC가 필요로 하는 모듈
  • 웹 테스트를 위한 Jetty 서버 설정
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>test6</groupId>
    <artifactId>test6</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 서블릿, JSP, JSTL을 위한 의존 설정-->
    <dependencies>
        <dependency>
            <groupId>
                javax.servlet.jsp
            </groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
            <scope>runtime</scope>
        </dependency>
        
        
    <!-- 스프링 mvc 실행을 위한 의존 설정-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.18.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>spring4-chap07</finalName>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>utf-8</encoding>
                </configuration>

            </plugin>
            <!-- jetty 설정 (=tomcat)-->
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.4.9.v20180320</version>
                <configuration>
                    <httpConnector>
                        <port>9080</port>
                    </httpConnector>
                    <scanIntervalSeconds>0</scanIntervalSeconds>
                    <webApp>
                        <contextPath>/</contextPath>
                    </webApp>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

 

스프링 MVC를 위한 설정을 web.xml에 추가하기

  • DispatcherServlet 등록
  • dispatcher 서블릿에 대한 매핑을 '*.do'로 지정한다. 따라서 웹 브라우저 요청 중에서 확장자가 do로 끝나는 모든 요청을 dispatcher 서블릿이 처리하게 된다.
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--DispatcherServlet 등록 -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/mvc-quick-start.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!--dispathcer 서블릿에 대한 매핑을 '*.do' 로 지정한다.-->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    <!-- 요청 파라미터를 UTF-8로 처리하기 위한 필터를 설정한다. -->
    <filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        </filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

 

스프링 컨트롤러 구현

web.xml의 DispatcherServlet 설정이나 뒤에서 살펴볼 스프링 MVC 설정은 프로젝트 시작 시점에 설정하면 대부분 완료되며, 실제 컨트롤러와 뷰를 구현하는 데 많은 시간을 사용한다.

package net.madvirus.spring4.chap07.quickstart;


import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//클래스가 스프링 MVC 컨트롤러임을 지정
@Controller
public class HelloController {
    //hello() 메서드가 /hello.do로 들어오는 요청을 처리함을 지정
    @RequestMapping("/hello.do")
    public String hello(Model model) {
        //뷰에 "greeting"이라는 이름으로 "안녕하세요"라는 데이터를 전달
        model.addAttribute("greeting","안녕하세요");
        //리턴 값 "hello"를 뷰 이름으로 사용
        return "hello";
    }
}
  • @Controller
    • 클래스가 스프링 MVC 컨트롤러임을 지정
    • 컨트롤러는 클라이언트(웹 브라우저)의 요청을 처리하는 기능을 제공한다. 위 코드의 경우 웹 브라우저가 "/hello.do" 주소로 요청을 하면 hello() 메서드를 이용해서 그 요청을 처리한다.
    • 컨트롤러가 직접 응답 결과를 생성할 수도 있지만, 보통은 결과를 보여줄 때 사용할 뷰 이름을 리턴한다.
    • 위의 코드에서 hello를 리턴했는데, 스프링MVC는 "hello"에 해당하는 뷰 구현을 찾은 뒤, 해당 뷰를 이용해서 응답 결과를 생성한다.
    • 컨트롤러는 뷰에서 사용할 데이터를 모델(model)에 담아서 전달한다.
  • @RequestMapping("/hello.do")
    • hello() 메서드가 /hello.do로 들어오는 요청을 처리함을 지정
  • model.addAttribute("greeting","안녕하세요");
    • 뷰에 "greeting"이라는 이름으로 "안녕하세요" 라는 데이터를 전달
  • return "hello"
    • 리턴 값을 "hello"를 뷰 이름으로 사용

 

JSP를 이용한 뷰 구현

greeting의 값은 앞서 작성했던 HelloController 클래스의 모델 설정을 통해서 전달된다.

<!-- JSP를 이용한 뷰 구현-->
<%@ page contentType="text/html; charset=utf-8" %>
<!DOCTYPE html>
<html>
<head>
    <title>Hello</title>
</head>
<body>
<!-- controller에서 greeting 전달-->
인사말:${greeting}
</body>
</html>

 

스프링 MVC 설정 파일 작성

helloController에서 "hello"를 리턴했는데, 이 값으로 어떻게 WEB-INF/view 디렉토리에 위치한 hello.jsp 파일을 뷰로 사용하느냐 하는 점이다. 이는 스프링 MVC 설정을 통해 처리된다.

<?xml version="1.0" encoding="UTF-8" ?>
<bean xmls ="http://www.springframework.org/schema/beans"
      xmlns:mvc="http://www.springframework.org/schema/mvc"
      xmlns:xsi="http://wwww.w3.rog/2001/XMLSchema-instace"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/beans/mvc
      http://www.springframework.org/schema/beans/mvc/spring-mvc.xsd">
    <!-- 몇 개의 설정을 한 번에 해주는 코드이다.
    RequesstMappingHandlerMapping과 RequestMappingHandlerAdapter를 빈으로 등록해준다.-->
    <mvc:annotaion-driven/>
    <!-- 뷰 이름을 실제 어떤뷰와 연결할지 결정하는 VeiwResolver를 설정
    prefix + 뷰 이름 + suffix
    - /WEB-INF/view/hello.jsp
    -->
    <bean id="viewResolver"
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name = "prefix" value ="/WEB-INF/view/"/>
        <property name ="suffix" value=".jsp"/>
    </bean>
    <bean class ="net.madvirus.spring4.chap07.quickstart.HelloController"/>
</bean>

 

File->Setting

 

 

Run -> Edit Configurations

Name을 반드시 입력하여야 한다.

Maven Configuration(pom.xml)

자신의 프로젝트에 대한 고유의 좌표 설정

groupId

  • 자신의 프로젝트를 고유하게 식별하게 해주는 것으로, 최소한 내가 컨트롤하는 domatin name이어야한다.
  • package 명명 규칙을 따른다.
  • 하위 그룹은 얼마든지 추가할 수 있다.

artifactId

  • 제품의 이름으로, 버전 정보를 생략한 jar 파일의 이름이다.
  • 프로젝트 이름과 동일하게 설정한다.
  • 소문자로만 작성하며 특수문자는 사용하지 않는다.

Version

  • SNAPSHOT: 개발용, RELSEASE : 배포용
  • 숫자와 점을 사용하여 버전 형태를 표현한다.(1.0, 1.1, 1.1..)

 

Maven 장점

  • pom.xml에 명시한 lib 자동으로 다운
  • build process 자동화
    • compile->test->package(.war)->install->deploy

Web Deployment Descriptor(web.xml)

  • 개념
    • web application의 설정을 위한 deployment descriptor
    • SUN에서 정해놓은 규칙에 맞게 작성해야 하며 모든 WAS에 대하여 작성 방법이 동일하다.
  • 역할
    • Deploy 할 때 Servlet의 정보를 설정해준다.
    • 브라우저가 Java Servlet에 접근하기 위해서는 WAS(ex. tomcat)에 필요한 정보를 알려줘야 해당하는 Servelet을 호출할 수 있다.
      • 정보1) 배포할 Servlet이 무엇인지
      • 정보2) 해당 Servlet이 어떤 URL에 매핑되는지
    • 구체적인 설정 내용
      • DispatcherServlet
      • ContextLoaderListener
      • Filter : encodingFilter, springSecurityFilterChain
  • Dependency 목록

    • Spring-webmvc
      : Spring mvc 프로젝트를 하기위해선 추가해야할 기본적인 dependency이다.

    • spring-tx
      : spring transaction을 사용하기위한 dependency이다.

    • spring-orm
      : jpa를 사용하고자 할때 추가해야하는 dependency이다.

    • hibernate-core
      : jpa를 사용하고 hibernate를 사용하고자 할때 추가하는 dependency이다.

    • hibernate-c3p0 
      : db connection pool로 c3p0를 사용하고자 할때 사용하는 dependency이다.

    • c3p0
      : dpcp 라이브러리인 c3p0 dependency이다.

    • hibernare-validator
      : entity에서 데이터의 유효성 검증을 하기 위한 dependency이다.

    • javax.servlet.jsp.jstl-api
      : front end 단에서 jstl을 사용하기 위한 dependency이다.

    • standard
      : taglib를 사용하기 위한 dependency이다.

    • javax.servlet-api
      : servlet dependency 이다.

    • javax.servlet.jsp-api
      : JSP dependency 이다.

    • com.fasterxml.jackson.core
      : Json converter 로 RESTful api를 작성할때 json데이터를 변환하고 결과를 json 데이터로 전송해주기 위해 필요한 dependency이다. 

    • mysql
      : database로 mysql을 사용하기 위한 connector-J dependency 이다.

    • jUnit
      : 당장은 사용안하지만 후에 unit 테스트를 하기위한 dependency이다.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>
    <groupId>com.pang</groupId>
    <artifactId>pangs-spring-mvc</artifactId>
    <version>1.0.0</version>
    <packaging>war</packaging>

    <properties>
        <springframework.version>5.0.6.RELEASE</springframework.version>
        <hibernate.version>5.2.16.Final</hibernate.version>
        <hibernate.validator>5.4.1.Final</hibernate.validator>
        <c3po.version>0.9.5.2</c3po.version>
        <jstl.version>1.2.1</jstl.version>
        <tld.version>1.1.2</tld.version>
        <servlets.version>3.1.0</servlets.version>
        <jsp.version>2.3.1</jsp.version>
        <mysql.connector.version>8.0.13</mysql.connector.version>
        <jackson.databind.version>2.9.5</jackson.databind.version>
        <junit.version>3.8.1</junit.version>

        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

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

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

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

        <!-- Hibernate -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>${hibernate.version}</version>
        </dependency>

        <!-- C3PO -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3po.version}</version>
        </dependency>

        <!-- Hibernate Validator -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.validator}</version>
        </dependency>

        <!-- JSTL Dependency -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>javax.servlet.jsp.jstl-api</artifactId>
            <version>${jstl.version}</version>
        </dependency>

        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>${tld.version}</version>
        </dependency>

        <!-- Servlet Dependency -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlets.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- JSP Dependency -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>${jsp.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- MySQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.connector.version}</version>
        </dependency>

        <!-- Add Jackson for JSON converters -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.databind.version}</version>
        </dependency>

        <!-- junit Dependency -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>

        <sourceDirectory>src/main/java</sourceDirectory>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
        <plugins>
            <!-- Builds a Web Application Archive (WAR) file from the project output
                and its dependencies. -->
            <plugin>
                <!-- Add Maven coordinates (GAV) for: maven-war-plugin -->
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.2.0</version>
            </plugin>

        </plugins>
    </build>
</project>

Model

  • Controller에서 View로 객체를 전달하는데 사용된다.
  • 명명된 객체들의 집합이라고 할 수 있다.
    • Key-value 형식의 하나의 쌍을 명명된 객체라고 부른다.
    • 또한 이 명명된 객체는 model attribute라고 부른다.
    • 여러 개의 attribute가 모여 Table형식을 이룬다.
  • view에서 attribute의 key 값을 통해 value 값을 사용할 수 있다.
key(name) value
key1 value
key2 value

Model Inplementations

  • Model을 표현하기 위해 여러 자료구조를 사용할 수 있다.
  • Controller 메서드에 input argument로 값을 넣어주면 Spring FrameWork가 자동으로 Model을 만들어주고 해당 Model의 주소값만 넘겨준다.

Controller

@Controller

  • bean으로 등록
  • 해당 클래스가 Controller로 사용됨을 Spring Framework에 알림
  • @Component (구체화) -> @Controller, @Service, @Repository

@RequestMapping

  • value : 해당 url로 요청이 들어오면 이 메서드가 수행된다.
  • method : 요청 method를 명시한다.
  • 즉, 위의 예시에서는 "\home" url로 HTTP GET 요청이 들어오면 home() 메서드가 실행된다.

View

  • View를 생성하는 방법은 여러가지 있다.
    • jsp이외에도 Thymeleaf, Groovy, Freemarker 등 여러 Tempate Engine이 있다.
  • JSP(Java Server Pages)
    • JSP 제한 사항
    • Java EE에 종속적이라는 단점이 있다.
    • SpringBoot에서는 공식적으로 JSP를 지원하지 않는다.
      • SpringBoot의 내장 Tomcat에 하드코딩 패턴 때문에 jar형식으로는 webapp내용을 가져올 수 없다.
      • 따라서 spring boot에서는 war가 아닌 jar로 jsp를 사용할 수 없다.
    • JSTL(JSP Standard Tag Library)
      • 많은 JSP 애플리케이션의 공통적인 핵심 기능을 캡슐화하는 유용한 JSP 태그 모음
      • 즉, JSP 페이지를 작성할 때 유용하게 사용할 수 있는 여러 가지 action과 함수가 포함된 라이브러리
Srping MVC에서 Model , View, Controller의 사용법을 이해한다.
Model, View, Controller 를 분리한 디자인 패턴(개발자가 직접 구현해야 하는 것)

Spring MVC을 위한 필수적인 기본 설정 방법

  • Maven Configuraion (pom.xml)
  • Web Deployment Descriptor(web.xml)
  • Spring VMC configuration

Spring MVC Archtecture란

Model

  • 애플리케이션의 상태(data)를 나타낸다.
  • 일반적으러 POJO로 구성된다.
    • POJO(Plain Old Java Object) : 오래된 방식의 순수한 자바 객체, 다른 특정 기술에 종속적이면 POJO가 아니다.
    • https://siyoon210.tistory.com/120
  • Java bean의 형태이다.

 

siyoon210.tistory.com/120

 

POJO - (Plain Old Java Object)란 뭘까?

POJO 자바나 스프링 프레임워크를 조금이라도 공부 해본 개발자 (혹은 학생)이라면 POJO 라는 단어를 한번쯤 듣게됩니다. POJO의 정의는 사실 그렇게 어렵지 않습니다. 아래 내용은 위키 백과에 나

siyoon210.tistory.com

View

  • 디스플레이 데이터 또는 프레젠테이션
  • Model data의 렌더링을 담당하며, HTML output을 생성한다.
  • JSP
  • JSP이외에도 Thymeleaf, Groovy, Freemarker등 여러 Tempate Engine이 있다.

Controller

  • View와 Model 사이의 인터페이스 역할
  • Model/View 에 대한 사용자 입력 및 요청을 수신하여 그에 따라 적절한 결과를 Model에 담아 View에 전달
    • Model Object와 이 Model을 화면에 출력할 View Name을 반환한다.
  • Controller ->Service ->Dao ->DB
  • Servlet

Spring Framework가 제공하는 class

  • DispatcherServlet
    • Spring Framework가 제공하는 Servlet 클래스
    • 사용자의 요청을 받는다.
    • Dispatcher가 받은 요청은 HandlerMapping으로 넘어간다.
  • HandlerMapping
    • 사용자의 요청을 처리할 Controller를 찾는다.(Controller URL Mapping)
      • 하지만 controller를 실행시키진 못한다.
    • 요청 url에 해당하는 Controller정보를 저장하는 table을 가진다.
    • 즉, 클래스에 @RequestMapping("/url") annotation을 명시하면 해당 URL에 대한 요청이 들어왔을 때 table에 저장된 정보에 따라 해당 클래스 또는 메서드에 Mapping한다.
  • ViewResover
    • Controller가 반환한 View Name(the logical names)에 prefix, suffix를 적용하여 View Object(the physical view files)를 반환한다.
      • 예를들어 view name : home, prefix : /WEB-INF/views
      • suffix : .jsp는 "/WEB-INF/views/home.jsp 라는 위치의 View(JSP)에 Controller에게 받은 Model을 전달한다.
      • 이 후에 해당 View에서 이 Model data를 이용하여 적절한 페이지를 만들어 사용자에게 보여준다.

기본 Project Structure

src

개발자가 작성한 Servlet 코드가 저장된다. Controller, Model, Service, Dao

src/main/java

  • 개발되는 java 코드의 경로

src/main/resources

  • 서버가 실행될 때 필요한 파일들의 경로

src/test/java

  • 테스트 전용 경로(각 테스트 코드 작성 경로)

src/test/resources

  • 테스트 시에만 사용되는 파일들의 경로

Libraries

  • Servlet이나 JSP에서 추가로 사용하는 라이브러리 또는 드라이버
  • jar로 압축한 파일이어야한다.

WebContent(전체 ROOT) - webapp

Deploy할 때 WebContent 디렉터리 전체가 .war로 묶어서 보내진다.

  • resources
    • 정적인 데이터(ex, image file, css, js, fonts)
  • WEB-INF
    • classes : 작성한 Java Servlet 파일이 나중에 .class로 이곳에 모두 저장된다.
    • lib : 추가한 모든 라이브러리 또는 드라이버가 이곳에 저장된다.
    • props : property file을 저장한다.
    • spring : spring configuration files을 저장한다. (Spring과 관련된 설정 파일을 모아둔 것)
      • dispathcer-servlet.xml
      • apllicationContext.xml
      • dao-context.xml, service-context.xml 등
      • views : Controller와 매핑되는 .jsp 파일들을 저장한다. (JSP파일의 경로)
      • web.xml : web application의 설정을 위한 web deployment descriptor
        • DispatcherServlet, ContextLoadListener 설정 

pom.xml

  • maven configuration file
  • 어떤 lib를 쓸지 명시한다.

+ Recent posts