你真的了解SpringMVC吗？

<?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_Ray.springMVC.controller"></context:component-scan>

    <!-- 配置Thymeleaf视图解析器
        作用：解析视图 ，使用之后就可以使用springmvc为我们提供的方式来进行视图渲染，并实现页面跳转
    -->
    <bean id="viewResolver"
          class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
        <property name="order" value="1"/>
        <property name="characterEncoding" value="UTF-8"/>
        <property name="templateEngine">
            <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
                <property name="templateResolver">
                    <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
                        <!-- 视图前缀 -->
                        <property name="prefix" value="/WEB-INF/templates/"/>
<!--                逻辑视图：/WEB-INF/templates/(前缀)  index - .html(后缀)
                            == 物理视图(全地址) - 视图前缀 - 视图后缀
                    物理视图（需要访问的网页）-->
                        <!-- 视图后缀 -->
                        <property name="suffix" value=".html"/>
                        <property name="templateMode" value="HTML5"/>
                        <property name="characterEncoding" value="UTF-8" />
                    </bean>
                </property>
            </bean>
        </property>
    </bean>


</beans>

<?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/maven-v4_0_0.xsd">
    <parent>
        <artifactId>java_workSpace_SSM</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>

    <name>SpringMVC</name>
    <artifactId>SpringMVC</artifactId>

    <build>
        <plugins>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>6.1.7</version>
                <configuration>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>8888</port>
                            <maxIdleTime>30000</maxIdleTime>
                        </connector>
                    </connectors>
                    <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}
                    </webAppSourceDirectory>
                    <contextPath>/</contextPath>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>

        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- 日志 -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- ServletAPI -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!-- Spring5和Thymeleaf整合包 -->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
            <version>3.0.12.RELEASE</version>
        </dependency>
    </dependencies>

</project>

<!--a
    - SpringMVC 的前端控制器DispatcherServlet

    - Servlet that dispatches requests to the Spring managed block servlets
    -->
  <servlet>
<!--    这里的servlet-name一定要与WEB_INF下的配置文件XXX-servlet.xml中的XXX名字相同-->
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
          <!--初始化的作用：将我们的配置文件放到resources路径下-->
          <param-name>ContextConfigLocation</param-name>
          <param-value>classpath:springmvc.xml</param-value>
      </init-param>
  </servlet>
  <!-- URL space mappings ============================================= -->
  <servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <url-pattern>/</url-pattern><!--表示所有的请求都需要进行过滤 （被前端控制器处理）  *.do :表示后缀处理-->
  </servlet-mapping>

@Controller
@RequestMapping("/test/")
public class EmployeeController {

    @Autowired
    private EmployeeDao employeeDao;
    //查询所有的员工信息
//请求地址问 ： /test/employee
    @GetMapping("/employee")
    public String selectAll(Model model){
        Collection<Employee> employeeAll = employeeDao.getAll();
        model.addAttribute("employeeAll",employeeAll);
        return "emp_list";
    }


}

//查询所有的员工信息
@GetMapping({"/test/employee","test/hello","..."})
public String selectAll(Model model){
    Collection<Employee> employeeAll = employeeDao.getAll();
    model.addAttribute("employeeAll",employeeAll);
    return "emp_list";
}

@RequestMapping(" /XXX" )

pubic String getHeader( @RequestParam（value= "name"...）String name @RequestHeader(value = "referer" ) String referer ){

    sout("name = " + name);

    sout("referer = "+ referer);

    return "XXX"; //请求跳转的逻辑页面

}

/**
 * 保证User类中的属性名与请求参数中的参数保持一致
 * @param user
 * @return
 */
@RequestMapping("/param/pojo")
public String pojoRequest(User user){
    System.out.println(user);
    return "success";
}

<!--配置springMVC的编码过滤器-->
<filter>
    <filter-name>CharacterEncodingFilter</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>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

@RequestMapping("/test/mav")
public ModelAndView testModelAndView(){
    /**
     * ModelAndView有Model和View的功能
     * Model主要用于向请求域共享数据
     * View主要用于设置视图，实现页面跳转
     */
    ModelAndView mav = new ModelAndView();
    //向请求域共享数据
    mav.addObject("testScope", "hello,ModelAndView");
    //设置逻辑视图，实现页面跳转
    mav.setViewName("success");
    return mav;
}

@RequestMapping("/test/model")
public String testModel(Model model){
    model.addAttribute("testModel","hello,model");
    return "success";
}

/**
 * 测试   向session域中共享数据
 * @param session
 * @return
 */
@RequestMapping("/test/session")
public String testSession(HttpSession session){
    session.setAttribute("testSessionScope", "hello,session");
    return "success";
}
@RequestMapping("/test/application")
public String testApplication(HttpSession session){
    ServletContext servletContext = session.getServletContext();
    servletContext.setAttribute("testApplication","hello,application");
    return "success";
}

<!--    设置请求处理的过滤器-->
    <filter>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HiddenHttpMethodFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 可以作为一个模板，以后只需要改一些内容即可
 */
@Controller
public class FileController {

    @RequestMapping("/test/down")
    public ResponseEntity<byte[]> testResponseEntity(HttpSession session) throws
            IOException {
        //获取ServletContext对象
        ServletContext servletContext = session.getServletContext();
        //获取服务器中文件的真实路径
        String realPath = servletContext.getRealPath("WEB-INF/img");
        realPath = realPath + File.separator +"5.png";
        System.out.println(realPath);
        //创建输入流
        InputStream is = new FileInputStream(realPath);
        //创建字节数组
        byte[] bytes = new byte[is.available()];
        //将流读到字节数组中
        is.read(bytes);
        //创建HttpHeaders对象设置响应头信息
        MultiValueMap<String, String> headers = new HttpHeaders();
        //设置要下载方式以及下载文件的名字 key为固定的
        headers.add("Content-Disposition", "attachment;filename=5.png");
        //设置响应状态码
        HttpStatus statusCode = HttpStatus.OK;
        //创建ResponseEntity对象
        ResponseEntity<byte[]> responseEntity = new ResponseEntity<>(bytes, headers, statusCode);
        //关闭输入流
        is.close();
        return responseEntity;
    }
}

<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>

<!--    图片解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>

@RequestMapping("test/up")
  public String upPhotos(MultipartFile photo,HttpSession session) throws IOException {
      String filename = photo.getOriginalFilename();
      System.out.println(filename);
     //如果出现重名的情况就做如下操作
      String substring = filename.substring(filename.lastIndexOf("."));
      String uuid = UUID.randomUUID().toString();
      filename = uuid + substring;
      //这样设置的名字就与其有所差别，不会让文件内容被覆盖
      
      //获取servletContext对象
      ServletContext servletContext = session.getServletContext();

      //获取当前工程的真实路径
      String photoPath = servletContext.getRealPath("photo");
      //创建photoPath对应的file对象
      File file = new File(photoPath);
      if (!file.exists()){
          //如果没有直接创建
          file.mkdir();
      }
      String finalPath = photoPath + File.separator + filename;
      //上传文件(转移文件到指定的位置)
      photo.transferTo(new File(finalPath));
      return "success";
  }

<!--    图片解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver"></bean>
    <bean class="com.atguigu.interceptor.FirstInterceptor"></bean>
    <ref bean="firstInterceptor"></ref>
    <!-- 以上两种配置方式都是对DispatcherServlet所处理的所有的请求进行拦截 -->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <mvc:exclude-mapping path="/testRequestEntity"/>
        <ref bean="firstInterceptor"></ref>
    </mvc:interceptor>
    <!--
    以上配置方式可以通过ref或bean标签设置拦截器，通过mvc:mapping设置需要拦截的请求，通过
    mvc:exclude-mapping设置需要排除的请求，即不需要拦截的请求
    -->

public class LoginInterceptor implements HandlerInterceptor{
	/*
	 * 在处理器执行之前调用(non-Javadoc)
	 * 1. 获取session
	 * 2. 读取session中的uid的值
	 * 		如果为null，表示没有登录，那么直接重定向到登录界面，同时返回false，不需要执行后面的流程了
	 * 		如果不为null，表示已经登录了，那么直接返回true，继续执行后面的拦截器或者处理器
	 */
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		HttpSession session=request.getSession();   //获取session
		Object uid=session.getAttribute("uid");  //读取session中的对象
		//如果uid存在，那么即可登录完成
		if (uid!=null) {
			return true;   //返回true，登录成功就需要执行后续的流程
		}
		response.sendRedirect(request.getContextPath()+"/user/login.do");  //重定向到登录界面
		return false;   //返回false，后面的流程也不用执行了，直接中断
	}

	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
	}

	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		
	}
}

再判断是否配置了mvc:default-servlet-handler

如果没配置，则控制台报映射查找不到，客户端展示404错误
  

如果有配置，则访问目标资源（一般为静态资源，如：JS,CSS,HTML），找不到客户端也会展示404错误
 

DispatcherServlet 根据获得的Handler(控制器方法)，选择一个合适的HandlerAdapter。

如果成功获得HandlerAdapter，此时将开始执行拦截器的preHandler(…)方法【正向】s

提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)方法，处理请求。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象。

此时将开始执行拦截器的postHandle(...)方法【逆向】。

根据返回的ModelAndView（此时会判断是否存在异常：如果存在异常，则执行 HandlerExceptionResolver进行异常处理）选择一个适合的ViewResolver进行视图解析，根据Model 和View，来渲染视图。

渲染视图完毕执行拦截器的afterCompletion(…)方法【逆向】。

将渲染结果返回给客户端。