SpringMVC学习基础总结

战胜.

已于 2022-03-15 15:05:34 修改

阅读量1.1k

点赞数 1

分类专栏： Jav 学习系列 # SSM框架文章标签：学习 java mvc

于 2022-03-14 12:07:15 首次发布

本文链接：https://blog.csdn.net/qq_45021180/article/details/123460179

版权

Jav 学习系列同时被 2 个专栏收录

17 篇文章 7 订阅

订阅专栏

SSM框架

6 篇文章 0 订阅

订阅专栏

一、MVC回顾

Model(模型)： 数据模型，提供要展示的数据，分为数据Dao和服务层Servide，提供数据查询和模型数据的状态更新。
View(视图)： 负责进行模型的展示，也就是用户界面。
Controller(控制层)： 接受用户请求，委托模型进行处理，处理完后将返回的模型数据返回给视图。

MVC框架要做的事情：
① 将url映射到java类或者java的方法；
② 封装用户提交的数据；
③ 处理请求 ---- 调用相关业务处理 ---- 封装响应数据；
④ 将响应的数据进行渲染；

二、Servlet回顾

创建一个Maven项目
新建 ----> 选择Maven ----> Next ----> 填写名称 ----> 完成；
删除src
导入依赖：

<dependencies>
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.12</version>
     </dependency>

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

     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>servlet-api</artifactId>
         <version>2.5</version>
     </dependency>

     <dependency>
         <groupId>javax.servlet.jsp</groupId>
         <artifactId>jsp-api</artifactId>
         <version>2.2</version>
     </dependency>

     <dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>jstl</artifactId>
         <version>1.2</version>
     </dependency>
 </dependencies>

在这里插入图片描述

在子项目的java中创建一个继承HttpServlet的类。

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.获取前端参数
        String method = req.getParameter("method");
        if(method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }else if(method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层
        //3.视图转发后者重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

在web.xml中配置servlet

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.nzs.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>



<!--配置session时间：15分钟-->
<session-config>
    <session-timeout>15</session-timeout>
</session-config>
<!--配置欢迎界面-->
<welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

配置tomcat
在这里插入图片描述

执行
在这里插入图片描述

三、什么是SpringMVC

Spring MVC是Spring Framework的一部分，是基于java实现MVC的轻量级Web框架。

Spring MVC的特点：
① 轻量级、简单易学，简洁灵活；
② 高效，基于请求响应的MVC框架；
③ 与Spring兼容性好；
④ 约定优于配置；
⑤ 功能强大：RESTFul、数据验证、格式化、本地化、主题等；
DispatcherServlet：
① Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用就是将请求分发到不同的处理器，DispatcherServlet是一个实际的Servlet。

SpringMVC实例：
① 新建一个Moudel，添加web支持；
② 确导入SpringMVC的依赖；
③ 配置web.xml，注册DispatcherServlet；

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

   <!--注册DispatcherServlet-->
   <servlet>
       <servlet-name>springmvc</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--关联一个springmvc的配置文件：在resources文件下创建【servlet-name】-servlet.xml-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
           <!--启动级别-->
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>

   <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>
</web-app>

④ resources文件下创建【servlet-name】-servlet.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"
      xsi:schemaLocation="http://www.springframework.org/schema/beans >http://www.springframework.org/schema/beans/spring-beans.xsd">

   <!--1.添加处理映射器-->
   <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
   <!--2.添加处理器适配器-->
   <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>
   <!--3.添加视图解析器：DispatcherServlet给他的ModelAndView-->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
       <!--前缀-->
       <property name="prefix" value="/WEB-INF/jsp/"/>
       <!--后缀-->
       <property name="suffix" value=".jsp"/>
   </bean>


   <!--Handler-->
   <bean id="/hello" class="com.nzs.controller.HelloController"/>

</beans>

⑤ 编写业务Controller，要么实现Controll接口，要么添加注解；需要返回一个ModelAndView，装数据，封视图。

public class HelloController implements Controller {
   @Override
   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //1.modelAndView 模型和视图
       ModelAndView mv = new ModelAndView();
       //2.封装对象，放在ModelAndView中
       mv.addObject("msg","HelloSpringMVC!!!!!");
       //3.封装要跳转的视图，放在ModelAndView中
       mv.setViewName("hello"); // :/WEB_INF/jsp/hello.jsp
       return mv;
   }
}

⑥ 将自己的类交给SpringIOC容器，在pringmvc-servlet.xml注册bean；

   <!--Handler-->
   <bean id="/hello" class="com.nzs.controller.HelloController"/>

如果404，则需要下面操作：
在这里插入图片描述

四、SpringMVC执行原理

执行流程：
① DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接受请求并拦截请求。
② HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping;HandlerMapping根据请求url查找Handler。
③ HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello
④ HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。
⑤ HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。
⑥ Handler让具体的Controller执行。
⑦ Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。
⑧ HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。
⑨ DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。
⑩ 视图解析器将解析的逻辑视图名传给DispatcherServlet。
① DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。
② 最终视图呈现给用户。

五、使用注解开发SpringMVC

① 在pom.xml中加入

   <build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>

           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
       </resources>
   </build>

② 添加web支持，将jar包加入打包中；然后配置web.xml；

   <!--注册DispatcherServlet-->
   <servlet>
       <servlet-name>springmvc</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--关联一个springmvc的配置文件：在resources文件下创建【servlet-name】-servlet.xml-->
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <param-value>classpath:springmvc-servlet.xml</param-value>
           <!--启动级别-->
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>


   <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

③ 创建springmvc-servlet.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 >http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/mvc >http://www.springframework.org/schema/mvc/spring-mvc.xsd">


   <!--自动扫描包-->
   <context:component-scan base-package="com.nzs.springmvc"/>


   <!--让springMvc不处理静态资源-->
   <mvc:default-servlet-handler/>


   <!--支持mvc注解驱动：
       在spring中一般采川@RequestMapping注解来完成映射关系
       要想使@RequestMapping注解生效
       必须向上下文中注册DefaultAnnotationHandLerMapping和一个>AnnotationMethodHandLerAdapter实例
       这两个实例分别在类级别和方法级别处理。
       而annotation-driven配置帮助我们自动完成上述两个实例的注入。
   -->
   <mvc:annotation-driven/>


   <!--视图解析器-->
   <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" >id="internalResourceViewResolver">
       <!--前缀-->
       <property name="prefix" value="/WEB-INF/jsp/"/>
       <!--后缀-->
       <property name="suffix" value=".jsp"/>
   </bean>

</beans>

④ 创建一个controller

@Controller
public class HelloControll {

   @RequestMapping("/hello")
   public String hello(Model model){
       //封装数据
       model.addAttribute("msg","通过注解开发SpringMVC");
       return "hello";
   }
}

在这里插入图片描述

六、RestFul风格

好处：
① 使得路径更加整洁、安全；
② 获得参数更加方便，框架会自动进行类型装换；
③ 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法；

实例：
① 新建一个RestFulController
② 在SpringMVC中使用@PathVariable注解，让方法参数值对应绑定到一个URL模板变量上；

@Controller
public class RestFulController {
   @RequestMapping("/add/{a}/{b}")
   public String test(@PathVariable int a,@PathVariable int b, Model model){
       int res = a + b;
       model.addAttribute("msg","a + b = "+res);
       return "hello";
   }
}

在这里插入图片描述
通过注解设置不同请求方式的响应方法：

@RequestMapping(path = "/add/{a}/{b}",method = {RequestMethod.GET})
或者
@GetMapping("/add/{a}/{b}")

七、接收请求参数和数据回显

① Model：精简版，只有寥寥几个方法，只适合存储数据；
②ModelMap：继承了LinkedMap，除了实现了自身的一些方法，同样继承LinkeMap的方法和特性；
③ ModelAndMap：可以存储数据的同时，可以进行设置返回的逻辑视图，进行控制层的跳转；

1. 提交的域名称和处理方法的参数一致：

   @RequestMapping("/hello")
   public String test1(String name){
        System.out.println(name);
        return "hello";
   }

2. 提交的域名称和处理方法的参数不一致：

   @RequestMapping("/hello")
   public String test1(@RequestParam("username") String name){
       System.out.println(name);
       return "hello";
   }

3. 提交的是一个对象：

   @RequestMapping("/index")
   public String userIndex(User user , Model model){
       //1.接收前端参数
       System.out.println(user);
       //2.将返回的结果返回
       model.addAttribute("msg","----------"+user);
       return "user";
   }

八、解决乱码问题

过滤器决解；

① 在web.xml中配置乱码过滤器；

   <!--2.配置乱码过滤器-->
   <filter>
       <filter-name>encoding</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>encoding</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

②如果通过上面还不能决解，则修改Tomcat配置文件：设置编码；
在这里插入图片描述
修改service.xml

   <Connector port="8080" protocol="HTTP/1.1"
              connectionTimeout="20000"
              redirectPort="8443" 
              URIEncoding="UTF-8"/>

③ 如果通过上面还不能决解，则自定义乱码过滤器；

public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
   }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //处理response的字符编码
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 转型为与协议相关对象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 对request包装增强
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
   }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
   }
}

//自定义request对象，HttpServletRequest的包装类
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否编码的标记
   private boolean hasEncode;
   //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
   public MyRequest(HttpServletRequest request) {
       super(request);// super必须写
       this.request = request;
   }

   // 对需要增强方法 进行覆盖
   @Override
   public Map getParameterMap() {
       // 先获得请求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post请求
           try {
               // 处理post乱码
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
           } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
           }
       } else if (method.equalsIgnoreCase("get")) {
           // get请求
           Map<String, String[]> parameterMap = request.getParameterMap();
           if (!hasEncode) { // 确保get手动编码逻辑只运行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 处理get乱码
                               values[i] = new String(values[i]
                                       .getBytes("ISO-8859-1"), "utf-8");
                           } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                           }
                       }
                   }
               }
               hasEncode = true;
           }
           return parameterMap;
       }
       return super.getParameterMap();
   }

   //取一个值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
       }
       return values[0]; // 取回参数的第一个值
   }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
   }
}

   <!--2.配置乱码过滤器-->
   <filter>
       <filter-name>encoding</filter-name>
       <filter-class>com.nzs.springmvc.filter.GenericEncodingFilter</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>encoding</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

决解json乱码问题

<!--解决json 乱码配置-->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="org.springframework.http.converter.StringHttpMessageConverter">
            <constructor-arg value="UTF-8"/>
        </bean>
        <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
            <property name="objectMapper">
                <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                    <property name="failOnEmptyBeans" value="false"/>
                </bean>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

九、Jackson、Fastjson的使用的使用

Jackson使用 :

① 导入jar包；

       <!--Jackson依赖-->
       <dependency>
           <groupId>com.fasterxml.jackson.core</groupId>
           <artifactId>jackson-databind</artifactId>
           <version>2.11.4</version>
       </dependency>

② @ResponseBody不会走视图解析器，直接返回一个字符串；@RestController下面所有都只返回字符串；

   @RequestMapping("/json1")
   @ResponseBody
   public String jsonText() throws JsonProcessingException {
       ObjectMapper mapper = new ObjectMapper();//jackson
       User user = new User(1,"11",1);
       String str = mapper.writeValueAsString(user);
       return str;
   }

③ 决解json乱码问题；(代码在上面)

Fastjson使用：

① 导入依赖；

       <!--FastJson-->
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.36</version>
       </dependency>

② 使用

   @RequestMapping("/json1")
   public String jsonText(){
       User user = new User();
       // 1.Java对象转JSON字符串
       String str = JSON.toJSONString(user);
       //2.JSON对象转Java对象
       JSON.parseObject(str,User.class);
       //3.Java对象转JSON对象
       JSONObject o = (JSONObject)JSON.toJSON(user);
       //4.JSON对象转Java对象
       User user1 = JSON.toJavaObject(o, User.class);
       return "hell0";
   }