스프링 MVC 기본 사용 방법과 핵심 개념

1. 스프링 MVC란?

스프링 mvc는 스프링 프레임워크의 일부로, 웹 애플리케이션을 개발하기 위한 강력한 웹 프레임워크이다.

MVC 아키텍쳐를 따르며, 애플리케이션의 비즈니스 로직과 프레젠테이션 계층을 분리하여 개발의 유연성과 유지보수성을 높인다.

 

MVC 아키텍처란?

MVC 아키텍처는 애플리케이션을 세 가지 주요 컴포넌트로 분리하는 디자인 패턴이다.

- Model : 애플리케이션의 데이터와 비즈니스 로직을 담당

- View : 사용자에게 데이터를 시작적으로 표시하는 부분

- Controller : 사용자 입력을 처리하고, 모델과 뷰 사이의 인터랙션을 관리

 

 

2. 스프링 MVC의 주요 구성 요소

DispatcherServlet

DispatcherServlet은 스프링 MVC의 프론트 컨트롤러 역할을 하며, 모든 HTTP 요청을 받아서 적절한 핸들러로 라우팅 한다. 

 

Controller

Controller는 사용자 요청을 처리하고, 필요한 데이터를 Model에 추가한 후, View 이름을 반환한다. 주로 @Controller 어노테이션을 사용하여 정의한다. 

 

ViewResolver

ViewResolver는 컨트롤러가 반환한 View 이름을 실제 View 객체로 변환하는 역할을 한다. JSP, thymeleaf, Freemarker 등의 템플릿 엔진과 연동할 수 있다.

 

 

3. 스프링 MVC 설정

스프링 MVC프로젝트를 설정하는 방법에는 일반적으로 Maven또는 Gradle을 사용한다.

 

Maven

xml파일에 의존성을 추가한다.

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.10</version>
</dependency>

 

 

Gradle

gradle파일에 의존성을 추가

dependencies {
    implementation 'org.springframework:spring-webmvc:5.3.10'
}

 

 

 

 

스프링 설정 파일 (XML/ Java Config)

스프링 MVC를 설정하기 위한 방법

 

XML

xml설정은 web.xml과 스프링 설정파일을 사용하여 구성할 수 있다. 먼저 web.xml파일에서 dispactcherServlet을 설정하는 방법이다.

<web-app>
    <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/dispatcher-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 

dispatcher-servlet.xml 파일에서 뷰 리졸버와 기본적인 빈을 설정하는 방법이다.

 

<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">

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <context:component-scan base-package="com.example"/>
    <mvc:annotation-driven/>

</beans>

 

 

 

Java Config

@Configuration 어노테이션이 붙은 클래스와 @EnableWebMvc 어노테이션을 사용하여 구성할 수 있다.

 

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/views/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

 

그리고 스프링 부트처럼 servletInitalizer 클래스를 만들어 초기 설정을 할 수 있다.

public class ServletInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

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

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

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

 

이 설정은 스프링 부트를 사용하지 않는 환경에서 스프링MVC를 설정할 때 유용하다.

 

4. 스프링 MVC의 작동 원리

요청 처리 과정

1. 클라이언트가 요청 보냄

2. DispatcherServlet이 요청을 받음

3. DispatcherServlet은 HandlerMapping을 사용하여 요청을 적절한 컨트롤러에 매핑

4. 컨트롤러는 요청을 처리하고, 모델 데이터를 생성

5. 컨트롤러는 ViewResolver를 통해 적절한 뷰를 선택

6. View는 최종 결과를 클라이언트에게 응답으로 보냄

 

DispatcherServlet의 역할

DispatcherServlet은 모든 요청을 중앙에서 처리하고, 적절한 핸들러로 라우팅 한다.

 

 

 

 

5. Controller

@Controller, @RestController

@Controller는 웹 요청을 처리하는 클래스에 사용되고, @RestController는 Restful 웹 서비스를 쉽게 만들 수 있도록 도와준다.

두 어노테이션의 차이점은 @RestController는 @Controllerdhk @ResponseBody를 결합한 것으로 RESTful를 구축하는 데 사용된다.

 

@Controller
public class MyController {

    @GetMapping("/welcome")
    public String welcome(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC!");
        return "welcome";
    }
}

@RestController
public class MyRestController {

    @GetMapping("/api/welcome")
    public String welcome() {
        return "Welcome to Spring MVC!";
    }
}

 

 

요청 매핑(@RequestMapping, @GetMapping, @PostMapping 등)

스프링 MVC에서는 요청을 매핑하기 위해 다양한 어노테이션을 사용한다. 예를 들면 @GetMapping은 Get요청을 처리하는 메소드에 사용된다.

 

@Controller
public class MyController {

    @GetMapping("/welcome")
    public String welcome(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC!");
        return "welcome";
    }

    @PostMapping("/submit")
    public String submit(@RequestParam("name") String name, Model model) {
        model.addAttribute("message", "Hello, " + name + "!");
        return "welcome";
    }
}

 

 

6. 뷰(View) 구성

JSP, Thymeleaf, Freemarker 등 스프링 MVC는 다양한 뷰 템플릿 엔진을 지원한다. JSP, Thymeleaf, Freemarker 등이 대표적이다.

 

JSP 설정 및 사용

JSP 설정

JSP(JavaServer Pages)는 자바 기반의 템플릿 엔진으로, 스프링 MVC에서 자주 사용된다. JSP를 사용하려면 다음과 같이 설정한다.

 

1. WebConfig 설정 (javaConfig):

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/views/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

 

 

2. Web.xml 설정(XML Config)

 

<web-app>
    <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/dispatcher-servlet.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

 

 

3. dispatcher-servlet.xml 설정 (XML Config) :

<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">

    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <context:component-scan base-package="com.example"/>
    <mvc:annotation-driven/>

</beans>

 

 

JSP 사용 예제

 

1.  컨트롤러 작성

@Controller
public class MyController {

    @GetMapping("/welcome")
    public String welcome(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC with JSP!");
        return "welcome";
    }
}

 

 

2. JSP 파일 작성 ( welcome.jsp)

<!DOCTYPE html>
<html>
<head>
    <title>Welcome</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

 

 

Thymeleaf 설정 및 사용

의존성 추가 :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

 

2. WebConfig 설정 :

 

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public SpringResourceTemplateResolver templateResolver() {
        SpringResourceTemplateResolver templateResolver = new SpringResourceTemplateResolver();
        templateResolver.setPrefix("/WEB-INF/views/");
        templateResolver.setSuffix(".html");
        templateResolver.setTemplateMode(TemplateMode.HTML);
        return templateResolver;
    }

    @Bean
    public SpringTemplateEngine templateEngine() {
        SpringTemplateEngine templateEngine = new SpringTemplateEngine();
        templateEngine.setTemplateResolver(templateResolver());
        templateEngine.setEnableSpringELCompiler(true);
        return templateEngine;
    }

    @Bean
    public ThymeleafViewResolver viewResolver() {
        ThymeleafViewResolver viewResolver = new ThymeleafViewResolver();
        viewResolver.setTemplateEngine(templateEngine());
        return viewResolver;
    }
}

 

Thymleaf 사용 예제

1. 컨트롤러 작성

@Controller
public class MyController {

    @GetMapping("/welcome")
    public String welcome(Model model) {
        model.addAttribute("message", "Welcome to Spring MVC with Thymeleaf!");
        return "welcome";
    }
}

 

2.  Thymeleaf 템플릿 파일 작성

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Welcome</title>
</head>
<body>
    <h1 th:text="${message}">Welcome</h1>
</body>
</html>

 

 

 

7. 폼 처리 및 데이터 바인딩

폼 데이터 처리

폼 데이터 처리하는 기본적인 방법은 @Controller를 사용한 클래스에서 폼 데이터를 수신하고, 이를 처리한다.

 

 

예제: 사용자 등록 폼 처리

 

1. 폼 데이터를 담을 모델 클래스 작성

package com.example.model;

public class User {
    private String name;
    private String email;

    // Getters and setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

 

2. 컨트롤러 작성

package com.example.controller;

import com.example.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class UserController {

    @GetMapping("/register")
    public String showForm(Model model) {
        model.addAttribute("user", new User());
        return "register";
    }

    @PostMapping("/register")
    public String submitForm(@ModelAttribute User user, Model model) {
        model.addAttribute("message", "User registered successfully!");
        model.addAttribute("user", user);
        return "result";
    }
}

 

 

3. JSP 파일 작성

• register.jsp

<!DOCTYPE html>
<html>
<head>
    <title>Register</title>
</head>
<body>
    <h2>Register</h2>
    <form action="register" method="post">
        Name: <input type="text" name="name"/><br/>
        Email: <input type="email" name="email"/><br/>
        <input type="submit" value="Submit"/>
    </form>
</body>
</html>

• result.jsp

<!DOCTYPE html>
<html>
<head>
    <title>Result</title>
</head>
<body>
    <h2>${message}</h2>
    <p>Name: ${user.name}</p>
    <p>Email: ${user.email}</p>
</body>
</html>

 

 

 

@ModelAttribute와 데이터 바인딩

예제: @ModelAttribute 사용

 

1. 컨트롤러 수정

@Controller
public class UserController {

    @GetMapping("/register")
    public String showForm(Model model) {
        model.addAttribute("user", new User());
        return "register";
    }

    @PostMapping("/register")
    public String submitForm(@ModelAttribute("user") User user, Model model) {
        model.addAttribute("message", "User registered successfully!");
        return "result";
    }
}

 

@Valid와 유효성 검사

예제: 유효성 검사 추가

 

1. User 클래스에 유효성 검증 어노테이션 추가

package com.example.model;

import javax.validation.constraints.Email;
import javax.validation.constraints.NotEmpty;

public class User {
    @NotEmpty(message = "Name is required")
    private String name;

    @Email(message = "Email should be valid")
    @NotEmpty(message = "Email is required")
    private String email;

    // Getters and setters
    // ...
}

 

2. 컨트롤러 수정

@Controller
public class UserController {

    @GetMapping("/register")
    public String showForm(Model model) {
        model.addAttribute("user", new User());
        return "register";
    }

    @PostMapping("/register")
    public String submitForm(@Valid @ModelAttribute("user") User user, BindingResult result, Model model) {
        if (result.hasErrors()) {
            return "register";
        }
        model.addAttribute("message", "User registered successfully!");
        return "result";
    }
}

 

3. JSP 파일 수정

<!DOCTYPE html>
<html>
<head>
    <title>Register</title>
</head>
<body>
    <h2>Register</h2>
    <form action="register" method="post">
        Name: <input type="text" name="name"/><br/>
        <c:if test="${not empty user.name.errors}">
            <span style="color: red;">${user.name.errors}</span><br/>
        </c:if>
        Email: <input type="email" name="email"/><br/>
        <c:if test="${not empty user.email.errors}">
            <span style="color: red;">${user.email.errors}</span><br/>
        </c:if>
        <input type="submit" value="Submit"/>
    </form>
</body>
</html>

 

 

 

 

8. 예외 처리

 

예외 처리 방법

스프링 MVC에서 예외를 처리하는 기본적인 방법은 @ExceptionHandler 어노테이션을 사용하는 것이다.

 

 

1. 컨트롤러에서 예외 처리기 작성

@Controller
public class MyController {

    @GetMapping("/causeError")
    public String causeError() {
        throw new RuntimeException("Intentional Error");
    }

    @ExceptionHandler(RuntimeException.class)
    public String handleRuntimeException(RuntimeException ex, Model model) {
        model.addAttribute("message", ex.getMessage());
        return "error";
    }
}

 

2. 에러 뷰 작성

• error.jsp

<!DOCTYPE html>
<html>
<head>
    <title>Error</title>
</head>
<body>
    <h2>Error occurred</h2>
    <p>${message}</p>
</body>
</html>

 

 

 

@ControllerAdvice를 사용한 글로벌 예외 처리

 

모든 컨트롤러에서 발생하는 예외를 전역적으로 처리할 수 있다.

 

1. GlobalExceptionHandler 클래스 작성

 

package com.example.exception;

import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public String handleException(Exception ex, Model model) {
        model.addAttribute("message", ex.getMessage());
        return "error";
    }
}

 

 

2. 컨트롤러에서 예외 발생

@Controller
public class MyController {

    @GetMapping("/causeError")
    public String causeError() {
        throw new RuntimeException("Intentional Error");
    }
}

 

위 설정을 통해 모든 컨트롤러에서 발생하는 예외를 GlobalExceptionHandler에서 처리할 수 있다.

 

 

사용자 정의 예외 처리

1. 사용자 정의 예외 클래스 작성

package com.example.exception;

public class CustomException extends RuntimeException {

    public CustomException(String message) {
        super(message);
    }
}

 

2. 컨트롤러에서 사용자 정의 예외 발생

@Controller
public class MyController {

    @GetMapping("/causeCustomError")
    public String causeCustomError() {
        throw new CustomException("Custom Error Occurred");
    }
}

 

3. GlobalExceptionHandler에서 사용자 정의 예외 처리

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(CustomException.class)
    public String handleCustomException(CustomException ex, Model model) {
        model.addAttribute("message", ex.getMessage());
        return "error";
    }
}

 

 

스프링 MVC: 핵심 개념 요약

1. MVC 패턴

• Model: 애플리케이션의 데이터와 비즈니스 로직을 담당합니다.
• View: 사용자에게 데이터를 표시하는 역할을 합니다.
• Controller: 사용자의 요청을 처리하고 적절한 모델과 뷰를 결합합니다.

2. 주요 구성 요소

• DispatcherServlet: 모든 요청을 받아서 처리하고 적절한 컨트롤러에 전달합니다.
• Controller: 사용자 요청을 처리하고 모델 데이터를 준비하여 뷰 이름을 반환합니다.
• Model: 컨트롤러가 뷰에 전달할 데이터를 담고 있습니다.
• ViewResolver: 뷰 이름을 실제 뷰로 변환합니다.
• HandlerMapping: 요청 URL을 적절한 컨트롤러에 매핑합니다.

3. 요청 흐름

1. 클라이언트 요청: 사용자가 웹 브라우저에서 특정 URL로 요청을 보냅니다.
2. DispatcherServlet: 모든 요청을 받아서 처리할 준비를 합니다.
3. HandlerMapping: 요청 URL을 분석하여 해당 URL을 처리할 컨트롤러를 찾습니다.
4. Controller: 요청을 처리하고 모델 데이터를 준비하여 뷰 이름을 반환합니다.
5. ViewResolver: 뷰 이름을 실제 뷰 템플릿으로 변환합니다.
6. View: 모델 데이터를 사용하여 사용자에게 보여줄 최종 HTML을 생성합니다.
7. 응답 반환: 생성된 HTML이 클라이언트에게 응답으로 전송됩니다.

4. 주요 애너테이션

• @Controller: 클래스가 컨트롤러임을 나타냅니다.
• @RestController: RESTful 웹 서비스를 위한 컨트롤러임을 나타냅니다.
• @RequestMapping: 요청 URL을 컨트롤러 메서드에 매핑합니다.
• @GetMapping, @PostMapping: HTTP 메서드와 URL을 매핑합니다.
• @RequestParam: 요청 파라미터를 메서드 파라미터에 매핑합니다.
• @PathVariable: URL 경로 변수 값을 메서드 파라미터에 매핑합니다.
• @RequestBody: 요청 본문을 객체로 변환하여 컨트롤러 메서드에 전달합니다.

5. 뷰 템플릿 엔진

• Thymeleaf: 스프링 부트에서 기본적으로 사용되는 템플릿 엔진입니다.
• JSP: 자바 기반의 뷰 템플릿 엔진입니다.