1. 첫 번째 주석이 달린 SpringMVC 프로그램

ch01-hello-springmvc : 주석이 달린 첫 번째 springmvc 프로젝트

SpringMVC의 소위 어노테이션 개발은 코드에서 클래스와 메소드에 어노테이션을 작성하여 프로세서를 완료 할 수 있음을 의미합니다.

springmvc 컨테이너에 등록합니다. 주석이 달린 개발이 초점 입니다.

요구 사항 : 사용자가 페이지에서 요청을 시작하고 요청이 springmvc 컨트롤러 객체로 전달
되고 요청 처리 결과가 표시됩니다 (결과 페이지에 welcome 문이 표시됨).

구현 단계 :

1. 새로운 웹 메이븐 프로젝트
2. 의존성
   spring-webmvc 의존성 추가, 간접적으로 프로젝트
   jsp, 서블릿 의존성에 스프링 의존성 추가

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

        <!--servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

      <!--springmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
    </dependencies>

	<build>
      <plugins>
        <!-- 编码和编译和JDK版本 -->
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.1</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>

    </build>

3. 요점 : springmvc 프레임 워크의 핵심 객체 인 DispatcherServlet을 web.xml에 등록
   1) DispatcherServlet은 중앙 디스패처라고하며 서블릿이며 부모 클래스는 HttpServlet을 상속받습니다.
   2) DispatcherServlet은 프론트 컨트롤러 (프론트 컨트롤러)라고도합니다.
   3 ) DispatcherServlet은 사용자가 제출 한 요청을 다른 컨트롤러 객체를 호출하고 사용자에게 요청 처리 결과를 표시합니다.
4. 요청 페이지 index.jsp 만들기
5. 컨트롤러 클래스 생성
   1) 클래스에 @Controller 어노테이션을 추가하고, 객체를 생성하고,이를 springmvc 컨테이너에 넣습니다.
   2) 클래스의 메소드에 @RequestMapping 어노테이션을 추가합니다.
6. 결과로 JSP를 생성하고 요청 처리 결과를 표시합니다.
7. springmvc 구성 파일 생성 (스프링 구성 파일과 동일)
   1) 컴포넌트 스캐너 선언, @Controller 주석이있는 패키지 이름 지정
   2) 뷰 처리를 돕기 위해 뷰 리졸버 선언

<!--声明 springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

pom.xml 파일 :

<?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>org.example</groupId>
    <artifactId>ch01-hello-springmvc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>


    <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>
    </properties>

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

        <!--servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>

      <!--springmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
      <plugins>
        <!-- 编码和编译和JDK版本 -->
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.1</version>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
          </configuration>
        </plugin>
      </plugins>

    </build>
</project>

0. 프로젝트 구조 :

1. web.xml 파일을 구성합니다.

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

 <!-- 声明，注册springmvc的核心对象DispatcherServlet
  需要在tomcat服务器启动后，创建DispatcherServlet对象的实例
  为什么要创建DispatcherServlet对象的实例呢？
  因为DispatcherServlet在他的创建过程中，会同时创建springmvc容器对象
  读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起
  请求时，就可以直接使用对象了。

  servlet的初始化会执行init()方法。DispatcherServlet在init()中{
      // 创建容器，读取配置文件
      WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
      // 把容器对象放入到ServletContext中
      getServletContext().setAttribute(key,ctx);
  }
注册中央处理器-->

    <!--启动tomcat报错
     读取这个文件/WEB-INF/springmvc-servlet.xml失败
     springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/《servlet-name》-servlet.xml
     我们可以不使用这种默认的读取文件的方式，自定义springmvc读取的配置文件所在的位置
    -->

  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

      <!--自定义springmvc读取的配置文件的位置-->
      <init-param>
          <!--springmvc的配置文件的位置的属性-->
          <param-name>contextConfigLocation</param-name>
          <!--指定自定义文件的位置-->
          <param-value>classpath:springmvc.xml</param-value>
      </init-param>

      <!--在tomcat启动后，创建Servlet对象
        load-on-startup:表示tomcat启动后创建对象的顺序。
        它的值是整数，数值越小，tomcat创建对象的时间越早。
        大于等于0的整数
      -->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
      <!--
            使用框架的时候，url-pattern可以使用两种值
            1. 使用扩展名方式，语法：*.xxx, xxx是自定义的扩展名。常用的方式 *.do、*.action、*.mvc等等
                http://localhost:8080/springmvc/some.do
                http://localhost:8080/springmvc/other.do
            2. 使用斜杠“/”

      -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

1. 全限定性类名
该中央调度器为一个 Servlet，名称为 DispatcherServlet。中央调度器的全限定性类名在
导入的 Jar 文件 spring-webmvc-5.2.5.RELEASE.jar 的第一个包 org.springframework.web.servlet
下可找到。


2. <load-on-startup/>:
在<servlet/>中添加<load-on-startup/>的作用是，标记是否在Web服务器（这里是Tomcat）
启动时会创建这个 Servlet 实例，即是否在 Web 服务器启动时调用执行该 Servlet 的 init()方
法，而不是在真正访问时才创建。
它的值必须是一个整数。 
➢ 当值大于等于 0 时，表示容器在启动时就加载并初始化这个 servlet，数值越小，该 Servlet
的优先级就越高，其被创建的也就越早；
➢ 当值小于 0 或者没有指定时，则表示该 Servlet 在真正被使用时才会去创建。 
➢ 当值相同时，容器会自己选择创建顺序。

3. <url-pattern/>
对于<url-pattern/>，可以写为 / ，建议写为*.do 的形式。


4. 配置文件位置与名称
注册完毕后，可直接在服务器上发布运行。此时，访问浏览器页面，控制台均会抛出
FileNotFoundException 异常。即默认要从项目根下的 WEB-INF 目录下找名称为 Servlet 名称
-servlet.xml 的配置文件。这里的“Servlet 名称”指的是注册中央调度器<servlet-name/>标签
中指定的 Servlet 的 name 值。本例配置文件名为 springmvc-servlet.xml。

而一般情况下，配置文件是放在类路径下，即 resources 目录下。所以，在注册中央调
度器时，还需要为中央调度器设置查找 SpringMVC 配置文件路径，及文件名。

2. MyController.java 파일 :

@Controller
	 创建处理器对象，对象放在springmvc容器中
	 使用位置：在类的上面
和Spring中讲的@Service、@Component一样能处理请求的都是控制器（处理器）：
MyController能够处理请求，叫做后端控制器（back controller）

@RequestMapping:请求映射，作用时把一个请求地址和一个方法绑定在一起
              一个请求指定一个方法处理
      属性：
         	 1.value是一个String，表示请求的uri地址的（some.do），
         	 value的值必须是唯一的，不能重复。在使用时推荐地址以“/”开头
      使用的位置：
		     1.在方法的上面，常用的
		     2.在类的上面
		       说明：使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
		                使用@RequestMapping修饰的方法是可以处理请求的，类似Servlet中
		                的doGet()、doPost()。
		                若有多个请求路径均可匹配该处理器方法的执行，则@RequestMapping 
		                的 value 属性中可以写上一个数组。

ModelAndView 클래스 의 addObject () 메서드는 모델에 데이터를 추가하는 데 사용됩니다. 모델의 맨 아래 계층은 HashMap입니다.
모델의 데이터는 요청 범위에 저장됩니다. SringMVC는 기본적으로 포워딩을 사용하여 뷰로 이동합니다. 모델의 데이터는 요청이 끝나면 삭제됩니다.

package com.zep.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

/**
 * @Controller 创建处理起对象，对象放在springmvc容器中
 * 使用位置：在类的上面
 * 和Spring中讲的@Service、@Component一样
 * 能处理请求的都是控制器（处理器）：MyController能够处理请求，
 *                              叫做后端控制器（back controller）
 */
@Controller
public class MyController {
    
    
    /**
     * 处理用户提交的请求：springmvc中是使用方法来处理的。
     * 方法是自定义的，可以有多种返回值，多种参数，方法名称自定义
     * 准备使用doSome方法处理some.do请求
     * @RequestMapping:请求映射，作用时把一个请求地址和一个方法绑定在一起,一个请求指定一个方法处理
     *              属性：
     *                  1.value是一个String，表示请求的uri地址的（some.do）,value的值必须是唯一的，不能重复。在使用时推荐地址以“/”开头
     *              使用的位置：
     *                  1.在方法的上面，常用的
     *                  2.在类的上面
     *              说明：使用@RequestMapping修饰的方法叫做处理器方法或者控制器方法
     *                      使用@RequestMapping修饰的方法是可以处理请求的，类似Servlet中的doGet()、doPost()
     *              返回值：ModelAndView
     *                  Model:数据，请求处理完成后，要显示给用户的数据
     *                  View:视图，比如jsp等待
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome() {
    
      // doGet()--service请求处理
        // 可以处理some.do请求了，相当于service调用处理完成了
        ModelAndView mv = new ModelAndView();
        // 添加数据,框架在请求的最后部分把数据放入到request作用域
        // 相当于是执行了request.setAttribute("msg","欢迎使用springmvc做web开发")
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        // 指定视图,指定视图的完整路径
        // 框架对视图执行的是forward操作，类似于request.getRequestDispatcher("/show.jsp").forward(request,response);
//        mv.setViewName("/show.jsp");
//        mv.setViewName("/WEB-INF/view/show.jsp");
//        mv.setViewName("/WEB-INF/view/other.jsp");

        // 当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
        // 框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完整路径，这里就是字符串拼接操作
        // /WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

        // 返回mv
        return mv;
    }
}

3. spring-mvc.xml 파일 :
컴포넌트 스캐너 선언

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.zep.controller"/>
</beans>

4. 뷰 리졸버 등록 수정
요청 리소스 경로와 확장의 중복을 피하기 위해 뷰 리졸버
InternalResouceViewResolver는 요청 의 접두사와 접미사를 도입합니다 . ModelAndView에서는 이동하고자하는 페이지의 파일명 만 입력하면되고, 특정 파일 경로와 파일 확장자에 대해서는 뷰 파서가 자동으로 접합을 완료합니다.

index.jsp :

<%--
  Created by IntelliJ IDEA.
  User: Zep
  Date: 2020/12/2
  Time: 0:52
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>index</title>
</head>
<body>

    <p>第一个springmvc项目</p>
    <p><a href="some.do">发起some.do的请求</a></p>

</body>
</html>

show.jsp :

<%--
  Created by IntelliJ IDEA.
  User: Zep
  Date: 2020/12/2
  Time: 1:14
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>show</title>
</head>
<body>
    <h3>show.jsp从request作用域获取数据</h3>
    <h3>msg数据：${msg}</h3>
    <h3>fun数据：${fun}</h3>

</body>
</html>

결과 :

클릭 이 some.do의 요청을 시작했습니다.

요약하자면 :

* SpringMVC 요청 처리 흐름 :
1) index.jsp 페이지를 방문하여 하이퍼 링크를 클릭하고 some.do 요청을 시작합니다.
2) Tomcat ( .do 요청이 url-pattern을 통해 web.xml file-know 읽기 for DispatcherServlet)
3) DispatcherServlet (springmvc.xml 구성 파일에 따르면 some.do 요청이 doSome () 메서드에 해당함을 알고 있습니다.)
4) DispatcherServlet이 some.do를 MyController.doSome () 메서드로 전달합니다.
5) 프레임 워크가 실행됩니다. 결과 ModelAndView를 처리하는 doSome (), show.jsp로 전달됨

위의 프로세스는 단순화되었습니다.
some.do ——> DispatcherServlet ——> MyController