SpringMVC学习记录

最新推荐文章于 2024-11-12 21:14:07 发布

ZFKLcol

最新推荐文章于 2024-11-12 21:14:07 发布

阅读量91

点赞数

文章标签： java 开发语言后端 springmvc

本文链接：https://blog.csdn.net/ZFKLcol/article/details/120659036

版权

SpringMVC

SpringMVC内部执行流程

1.用户发起请求给DispatcherServlet

2.DispatcherServlet把请求交给处理器映射（HandlerMapping)）。
处理器映射器实现了HandlerMapping接口，作用是从springmvc容器中获取控制器对象，然后把找到的控制器和拦截器对象放到处理器执行链中。并返回给DispatcherServlet

3.DispatcherServlet将获取到的处理器执行链中的控制器对象，交给处理器适配器(HandlerAdapter)。适配器用来执行控制器的方法，得到结果ModelAndView
4.DispatcherServlet把控制器执行结果ModelAndView交给视图解析器(ViewResolver)。
视图解析器处理视图组成视图的完整路径，并创建view对象返回给DispatcherServlet。
5.DispatcherServlet调用View类的方法，将Model中的数据放入到request作用域。执行request.setAttribute(),对视图执行forward转发。
项目发布方式：
war模式：将WEB工程以包的形式上传到服务器；
war exploded模式：将WEB工程以当前文件夹的位置关系上传到服务器；
配置文件
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">
    <servlet>
        <servlet-name>springmvc</servlet-name>
<!--        申明前端处理器-->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        1.初始化操作；自定义配置文件位置，在创建DispatcherServlet对象时会执行init方法，
在init方法中执行SpringMVC对象创建ClassPathXmlApplicationContext ctx= new 
ClassPathXmlApplicationContext("springmvc.xml");
2.接收请求并分配
-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
<!--        tomcat创建对象的顺序，整数 大于等于0，且值越小，越早执行-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
<!--        "/"代表拦截处理 .jsp以外的所有请求，"/*"拦截所有请求。**.do,**.action 拦截指定后缀的请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <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>
<!--        强制 请求/响应 使用utf-8-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

springmvc.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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 http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<!--    <mvc:annotation-driven/>-->
<!--    引入context命名空间，扫包-->
    <context:component-scan base-package="com.suli.controller"/>
<!--    视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

后端控制器

@Controller
@ResultMapping("/test")//公共前缀
public class User {
    @RequestMapping(value="/so")//请求映射，下面处理so请求vaule是url地址
    public ModelAndView ssm(HttpServletRequest req, HttpServletResponse resp){
        return ssm1(req, resp);
    }

    /**
     *
     * @param req 请求
     * @param resp 响应
     *
     * @return
     */
    @RequestMapping(value = "/mm",method = RequestMethod.POST)
    public ModelAndView ssm1(HttpServletRequest req, HttpServletResponse resp){
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        Cookie cookie=new Cookie("username", username);
        Cookie cookie1=new Cookie("password", password);
        cookie.setMaxAge(180);
        cookie1.setMaxAge(180);
        resp.addCookie(cookie);
        resp.addCookie(cookie1);
        ModelAndView mm=new ModelAndView();//

        mm.setViewName("show");//在指定视图
        return mm;
    }


    /**
     *         逐个传参：<br/>
     *           1.框架使用request.getParameter("username"); request.getParameter("age")；<br/>
     *           2.前端控制器内部调用ssm2方法按名称传参<br/>
     *  ssm2(name,Integer.valueof(age))框架对其进行封装，可以直接使用参数<br/>
     *  name可以为空,age只能为int型，不然会报400异常（客户端异常：主要发生在用户提交参数过程）可以使用Integer防止age为空，
     *  但依然还有NumberFormatException<br/>
     *  所以参数应该使用包装类<br/>
     *  post请求乱码可以使用字符集过滤器：CharacterEncodingFilter<br/>
     * @param name
     * @param age
     * @return
     */
    public ModelAndView ssm2(String name, int age){
        ModelAndView mm=new ModelAndView();
          mm.addObject("msg", name);//对数据操作等于
          //request.setAttribute("msg",name);
         
          mm.addObject("pass", age);
        mm.setViewName("show.jsp");//forword转发
        return mm;
    }

springmvc处理请求过程
用户发起 *.do请求->Tomcat接收请求->DispatcherServlet->分配给User->
根据具体的action来调用方法，返回ModelAndView对象
web开发配置文件说明
web.xml:部署描述文件，给服务器用的
作用：启动时服务器根据文件说明创建Servlet对象。根据说明了解请求与Servlet的对应关系。
框架配置文件：SpringMVC配置文件：作用：声明框架创建的项目中的各个对象。主要创建Controller对象

SpringMVC参数接收

HttpServletRequest,HttpServletResponse,HttpSession可以直接使用
1.逐个接收
要求传过来的参数名和处理方法的形参名类型，名称相同。如果不同使用@RequestParam直接使形参名与传的参数名一样。该注解中有一个参数required默认为true表示注解的这个形参必须存在。
传参中的乱码问题
get传中文通过地址栏没有乱码问题
post传会有乱码问题
解决：

<!--使用过滤器处理-->
<filter>
        <filter-name>characterEncodingFilter</filter-name>

        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <!--        使用过滤器指定项目字符集-->
<init-param>
    <param-name>econding</param-name>
    <param-value>utf-8</param-value>
</init-param>
<!--       强制请求字符集为encoding的编码方式-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--       强制响应字符集为encoding的编码方式-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <!--       强制所有请求先经过过滤器处理-->
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

对象接收参数
对象的属性必须与传递的参数一样，类中要有无参构造器和set方法。
框架处理数据时调用无参构造器创建对象，使用set方法设置值
控制器方法的返回值
ModelAndView,String,void,Object
请求结果有数据和视图使用ModelAndView
数据：存放在request域中
视图：执行forword转发

只操作视图不涉及数据，使用String
执行forword转发操作，没有视图解析器使用完全路径，反之使用逻辑名称就行
如果要执行数据操作可以使用HttpServleRequestt,HttpServletResponse作为参数
void无返回值和视图
可以使用HttpServletRequest,HttpServletResponse输出数据响应ajax请求处理
前端页面

 <script type="text/javascript">
      $(function () {
          $("#rec").click(function () {
             $.post("ajax.do",{username:"李四",age:"10"},function (data) {
                 alert("已返回"+data.name+"===="+data.age)
             });
          })
      })


    </script>

后端控制器

 public void testAjax(HttpServletRequest req,HttpServletResponse res) throws IOException {
        res.setContentType("application/json;charset=utf-8");
        //获取前端传的参数
        String username = req.getParameter("username");
        String age = req.getParameter("age");
        int ages=Integer.parseInt(age);
        //封住到Student对象中
        Student student=new Student(username, ages);
        //调用jackjson转成字符串
        ObjectMapper objectMapper=new ObjectMapper();
        String s = objectMapper.writeValueAsString(student);
        //将字符串输出，让前端ajax能接收到
        PrintWriter writer = res.getWriter();
        writer.println(s);
        writer.flush();
        writer.close();
    }

Object返回对象
返回的对象List,Map,String都是数据，可以用来响应ajax请求，因此要经常做数据转换工作，框架提供了处理数据转换的工作
**HttpMessageConverter消息转换器

public interface HttpMessageConverter<T> {
//检查clazz类型对象能否转为mediaType表示的数据类型，返回true调用read()方法
boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);
//接收请求数据转化为clazz表示的对象并返回
	T read(Class<? extends T> clazz, HttpInputMessage inputMessage)
			throws IOException, HttpMessageNotReadableException;
			//判断clazz类型数据能否转为MediaType数据格式
	boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

	List<MediaType> getSupportedMediaTypes();

	
	//把t对象按照contentType说明的格式(json)，将对象转成outputMessage
	void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
			throws IOException, HttpMessageNotWritableException;
}

在这里插入图片描述

HttpMessageConverter接口实现类
MappingJackson2HttpMessageConverter:使用jackson工具库的ObjectMapper将java对象转为json数据格式。

StringHttpMessageConverter：把字符串类型进行格式转换和编码

默认sopringmvc使用HttpMessageConverter接口的4个实现类，包括StringHttpMessageConverter
在springmvc配置文件中加入注解驱动标签mvc:annotation-drivern，加入标签后springmvc启动后会创建HttpMessageConverter的8个实现类对象包括StringHttpMessageConverter和MappingJackson2HttpMessageConverter
主要完成以下工作

 //将对象转为json
        ObjectMapper objectMapper=new ObjectMapper();
        String s = objectMapper.writeValueAsString(student);

@ResponseBody注解
完成输出操作

//输出json，响应ajax
        PrintWriter writer = res.getWriter();
        writer.println(s);
        writer.flush();
        writer.close();

作用将student对象转换后的json通过HttpResponseServlet对象输出给浏览器

控制器方法返回对象转为json的步骤

1.pom.xml中引入jackson依赖，springmvc框架处理json默认使用jackson
2.在springmvc加入注解驱动标签mvc:annotation-drivern
3.在控制器方法上加入@ResponseBody注解，表示返回值数据，输出到浏览器

Student转为json

@ResponseBody
    @RequestMapping("/ajax.do")
 public Student testAjax(@RequestParam("username") String name, int age){
        return new Student(name, age);
    }

List转json

 @ResponseBody
    @RequestMapping("/ajax.do")
  public List<Student> testAjax(@RequestParam("username") String name, int age){

        Student student1= new Student(name, age);
        Student student2= new Student("张三", 23);
        Student student3= new Student("SuLi",18);
        List<Student> list=new ArrayList<>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        return list;
    }

返回String数据

    @ResponseBody
    //@RequestMapping("/ajax.do")
     @RequestMapping(value = "/ajax.do",produces = "text/plain;charset=utf-8")
  public String testAjax(@RequestParam("username") String name, int age) {
        return "hello 世界";
        
    }
    //ajax请求没进过过滤器，导致中文乱码，响应头编码 text/plain;charset=ISO-8859-1
    //StringHttpMessageConverter类的默认编码格式 public static final Charset 
    //DEFAULT_CHARSET = StandardCharsets.ISO_8859_1;
    //使用@RequestMapping的produce属性解决中文乱码问题，如上

静态资源处理

tomcat处理静态资源
defaultServlet 目录在/conf/web.xml

<servlet>
        <servlet-name>default</servlet-name>
        <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
        <init-param>
            <param-name>debug</param-name>
            <param-value>0</param-value>
        </init-param>
        <init-param>
            <param-name>listings</param-name>
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
     <servlet-mapping>
        <servlet-name>default</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

<!-- 这个是tomcat默认欢迎页-->
<welcome-file-list>
        <welcome-file>index.html</welcome-file>
        <welcome-file>index.htm</welcome-file>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    default叫默认servlet，作用：
    1.提供静态资源处理
    2.处理未映射到其它请求的请求处理

中央调度器设置"/"
中央调度器成为了默认的default，而中央调度器默认没有处理静态资源的对象，所以无法处理静态资源。
中央调度器处理静态资源第一种方式
在springmvc配置文件中加入mvc:default-servlet-handler标签，springmvc框架在运行时加入DefaultServletRequestHandler对象，让这个对象处理静态资源的访问。
如果只加入这个标签，静态资源可以访问，但动态资源访问不了，因为它个@RequestMapping有冲突。加入mvc:annotation-driven/可以解决。

<!--处理静态资源,将创建DefaultServletRequestHandler处理静态资源。将接收的静态资源地址转发给tomcat的default

优点：解决方式简单
缺点:依赖于服务器提供的default
-->
   <mvc:default-servlet-handler/>

中央调度器处理静态资源第二种方式
在springmvc配置文件中加入mvc:resources标签，springmvc框架在运行时加入ResourcesHttpRequestHandler对象，让这个对象处理静态资源的访问。不依赖于服务器，推荐使用，只要有框架就能使用。

<!--    <mvc:default-servlet-handler/>-->
<!--    mapping:访问静态资源的url,可以使用通配符（**）;
        **:表示任意目录和目录中的资源名称。
        location:静态资源在项目中的位置，不要使用/WEB-INF目录，项目中静态资源和网页是放在单独的服务器中，与代码分开放。
-->
    <mvc:resources mapping="/static/**" location="/static/"/>

异常处理

框架是集中处理，将异常集中到一个地方统一处理。通过两个注解
@ExceptionHandler:放在方法上面，表示方法处理某个类型的异常。
@ControllerAdvice：放在类上面，表明这个类有异常的处理方法。

拦截器

springmvc框架的对象，要实现接口HandlerInterceptor.拦截用户请求。拦截到controller的请求。
作用：拦截用户的请求，进行预处理，决定是否执行controller。可以把多个controller共用的功能定义到拦截器。
分为系统拦截器和自定义拦截器，一个项目中可以有多个拦截器

拦截器定义：
1.创建类实现HandlerInterceptor，实现接口中的方法。
2。springmvc配置文件中声明拦截器对象，并指定拦截的地址。

<!--    声明拦截器-->
    <mvc:interceptors>
<!--        声明第一个拦截器-->
        <mvc:interceptor>
<!--            指定拦截地址
path是拦截uri,使用** 如：path="/ssm/**" 表示拦截ssm下所有的地址
 -->
            <mvc:mapping path="/**"/>
<!--            指定使用的拦截器-->
            <bean class="com.suli.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

public class MyInterceptor implements HandlerInterceptor {
    /**
     * 预先处理的方法
     * @param request
     * @param response
     * @param handler 被拦截的对象
     * @return boolean true:放给controller/false::请求到此结束，后面的都不会被执行
     * @throws Exception
     * 特点：
     * 1.预处理执行时间在控制器方法之前先执行
     * 2.对请求做预处理，可以做登录检查，权限判断，统计数据等。
     * 3.决定请求是否执行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("==preHandler==");
        return false;
    }

    /**
     * 后处理方法
     * @param request
     * @param response
     * @param handler 被拦截的控制器对象
     * @param modelAndView 控制器方法的返回值
     * @throws Exception
     * 1.在控制器方法后面执行
     * 2.可以修改控制器方法的返回值
     * 3.对请求的二次处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("==postHandler==");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    /**
     *
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     * 特点：
     * 1.请求处理完成后执行的，请求处理的标志是视图处理完成。完成标志是对视图执行forward后。
     * 2.做善后工作，释放内存，清理临时变量。
     * 3.执行条件
     * 1）当前拦截器必须执行preHandler方法
     * 2）preHandler方法必须返回true
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("==afterHandler==");
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }

拦截器执行顺序

==preHandler==
执信controller方法
==postHandler==
==afterHandler==

执行链
多个拦截器，在一条执行链上执行。

public class HandlerExecutionChain {
    private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
    private final Object handler;//存放控制器对象
    @Nullable
    private HandlerInterceptor[] interceptors;//存储多个拦截器对象，数组，通过循环遍历实现拦截器的执行
    @Nullable
    private List<HandlerInterceptor> interceptorList;
    private int interceptorIndex;

执行preHandle()是正循环，执行postHandle()是反循环