Spring-MVC

Spring-MVC

什么是Spring-MVC？

它是一种基于 Java 实现MVC设计模型的请求驱动类型的Web框架。它是封装了Servlet。

● 入门案例，步骤分析：

一：启动服务器，加载一些配置文件。

①：DispatcherServlet对象创建。

②：Spring-mvc.xml被加载了。

  <!-- 前端控制器 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
​
    <!-- 让这个类帮我们读取Spring-mvc配置信息 -->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:Spring-mvc.xml</param-value>
    </init-param>
​
    <load-on-startup>1</load-on-startup> <!-- 启动服务器就创建Servlet -->
​
  </servlet>
​
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern> <!-- /表示所有请求都会经过此servlet -->
  </servlet-mapping>

③：Controller对象创建。

        <!-- 开启注解扫描 -->
        <context:component-scan base-package="Controller"></context:component-scan>

④：开启Spring-mvc注解的支持。

        <!-- 开启Spring-mvc框架注解的支持 -->
        <mvc:annotation-driven/>

二：发送请求，后台处理请求。

① ：客户端发送请求。

    <h3>入门程序</h3>
    <a href="hello">入门程序</a>

②：DispatcherServlet 前端控制器，起控制作用。

③：读取配置类。

/**
 * 控制器的类
 */
@Controller
public class ControllerTest {
​
    @RequestMapping(path = "/hello")
    public String sayhello(){
        System.out.println("hello spring-mvc");
        return "success";
    }
}

④：通过视图解析器对象解析配置类(InternalResourceViewResolver)。

        <!-- 视图解析器 -->
        <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"></property> <!-- 指找那个包 -->
            <property name="suffix" value=".jsp"></property> <!-- 指文件后缀名 -->
        </bean>

步骤总结：

① Request请求。

② 前端控制器(DispatcherServlet)：用于接收请求响应。

③ 请求查找Handler。处理映射器(HandlerMapping)。返回一个执行链，此执行链就是某个类某个与请求路径一致的方法。

④ 请求适配器执行(HandlerAdapter)，去执行Handler(去执行处理器返回的方法)，返回 ModelAndView(xxx.jsp)。

⑤ 通过视图解析器(ViewResolver)根据返回结果最终跳转到xxx.jsp页面。

⑥ 前端控制器(DispatcherServlet)返回响应。

在SpringMvc的各个组件中，处理器映射器，处理器适配器，视图解析器称为SpringMvc三大组件。

        <!-- 开启SpringMvc注解支持-->
        <mvc:annotation-driven/>

使用以上注解，自动加载RequestMappingHandlerMapping(处理映射器) 和 RequestMappingHandlerAdapter(处理适配器)。

---

● 配置解决中文乱码：

  <!-- 配置过滤器 -->
  <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>
  </filter>
​
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

● 常用注解：

○ RequestParam注解。

    @RequestMapping(path = "/hello")
    public String RequestParamTest(@RequestParam(value = "username") String username){
        System.out.println("hello spring-mvc"+username);
        return "success";
    }

○ RequestBody注解：用于获取请求体的内容,get请求不适应，因为它把请求的参数放在url上的。

    @RequestMapping(path = "/hello")
    public String RequestBodyTest(@RequestBody String body){
        System.out.println("请求体内容："+body);
        return "success";
    }

○ PathVaribale注解：用于绑定url中的占位符。

    @RequestMapping(path = "/hello/{id}")
    public String PathVariableTest(@PathVariable(name = "id") String id){
        System.out.println("hello spring-mvc"+id);
        return "success";
    }

● restful编程风格：请求地址都一样，根据不同的请求方式，让不同的方法去执行。

 

● 拦截器：

拦截器封装的是Aop，实现的功能与过滤器相似。

有了过滤器为什么还要用拦截器：过滤器是建立在请求与servlet之间的。而拦截器是建立在servlet与controller之间的。

执行过程：

1、spring开放一个接口（HandlerInterceptor）给我们去实现。

2、在实现方法中输入用户指令

3、交回给框架执行

自定义有三个方法：预处理（只有返回ture才执行controller）、数据返回但视图没有渲染、数据返回视图渲染。

    <bean id="interceptor" class="com.djl.project.util.Interceptor"></bean>
    <!--拦截器-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="b.djl"/> <!-- 放行 -->
            <ref bean="interceptor"></ref>
        </mvc:interceptor>
    </mvc:interceptors>

public class Interceptor implements HandlerInterceptor {
​
    @Autowired
    private UserService userService;
​
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        boolean flag = false;
        String username = (String) request.getParameter("username");
        String password = (String) request.getParameter("password");
        System.out.println(username);
        System.out.println(password);
        UserBean userBean = userService.user_login(username, password);
        if(userBean==null){
            flag = false;
            response.setCharacterEncoding("UTF-8");
            response.getWriter().print("error!");
        }else{
            flag = true;
        }
        System.out.println("前置过滤器");
        return flag;
    }
​
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("返回数据不渲染视图");
    }
​
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("返回数据渲染视图");
    }
}
​

7：异常处理

系统所有异常都往外抛，我们自定义一个异常类来做同统一处理。

1），自定义异常。

2），Spring如何管理？

public class MyException implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
​
        HandlerMethod handler = (HandlerMethod)o;
        String s = handler.getBean().toString();  // 报错的类名
        String method = handler.getMethod().getName(); //报错的方法名
        System.out.println(s);
        System.out.println(method);
        return new ModelAndView("error.html");
    }
}

    <!-- 异常处理 -->
    <bean class="com.djl.project.util.MyException"></bean>