• 【狂神】SpringMVC笔记（一）之详细版

    1.Restful 风格

    概念：

    实现方式：

    使用@PathVariable

    在url相同的情况下，会根据请求方式的不同来执行不同的方法。

    使用RestFull风格的好处：简洁、高效、安全

    2、接受请求参数及数据回显

    2.1、请求参数

    方式一：这里的@RequestParam("username")意思是，将前端用username="xxx"的值传到name变量里。

     方式二：当接受的对象是一个对象时，那我们在前端传入的变量名应与实体类中的名字保持一致，否则就为null

     2.2、数据回显

    也有三种方式，分别是Model,ModelMap,ModelAandView

    这个是第三种的。

     tips：

    3、乱码问题

    我以为我的配置是最优的，结果... 果然，人就是不能乱飘。

    先建个包，再建个类，专门用于存放过滤器的代码，用以解决乱码的问题。代码如下：

    1. package com.zhang.Filter;
    2. import javax.servlet.*;
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletRequestWrapper;
    5. import javax.servlet.http.HttpServletResponse;
    6. import java.io.IOException;
    7. import java.io.UnsupportedEncodingException;
    8. import java.util.Map;
    9.  
    10. public class GenericEncodingFilter implements Filter {
    11.     @Override
    12.     public void destroy() {
    13.     }
    14.  
    15.     @Override
    16.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException, IOException {
    17.         //处理response的字符编码
    18.         HttpServletResponse myResponse=(HttpServletResponse) response;
    19.         myResponse.setContentType("text/html;charset=UTF-8");
    20.  
    21.         // 转型为与协议相关对象
    22.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    23.         // 对request包装增强
    24.         HttpServletRequest myrequest = new MyRequest(httpServletRequest);
    25.         chain.doFilter(myrequest, response);
    26.     }
    27.  
    28.     @Override
    29.     public void init(FilterConfig filterConfig) throws ServletException {
    30.     }
    31.  
    32. }
    33.  
    34. //自定义request对象，HttpServletRequest的包装类
    35. class MyRequest extends HttpServletRequestWrapper {
    36.  
    37.     private HttpServletRequest request;
    38.     //是否编码的标记
    39.     private boolean hasEncode;
    40.     //定义一个可以传入HttpServletRequest对象的构造函数，以便对其进行装饰
    41.     public MyRequest(HttpServletRequest request) {
    42.         super(request);// super必须写
    43.         this.request = request;
    44.     }
    45.  
    46.     // 对需要增强方法 进行覆盖
    47.     @Override
    48.     public Map getParameterMap() {
    49.         // 先获得请求方式
    50.         String method = request.getMethod();
    51.         if (method.equalsIgnoreCase("post")) {
    52.             // post请求
    53.             try {
    54.                 // 处理post乱码
    55.                 request.setCharacterEncoding("utf-8");
    56.                 return request.getParameterMap();
    57.             } catch (UnsupportedEncodingException e) {
    58.                 e.printStackTrace();
    59.             }
    60.         } else if (method.equalsIgnoreCase("get")) {
    61.             // get请求
    62.             Map parameterMap = request.getParameterMap();
    63.             if (!hasEncode) { // 确保get手动编码逻辑只运行一次
    64.                 for (String parameterName : parameterMap.keySet()) {
    65.                     String[] values = parameterMap.get(parameterName);
    66.                     if (values != null) {
    67.                         for (int i = 0; i < values.length; i++) {
    68.                             try {
    69.                                 // 处理get乱码
    70.                                 values[i] = new String(values[i]
    71.                                         .getBytes("ISO-8859-1"), "utf-8");
    72.                             } catch (UnsupportedEncodingException e) {
    73.                                 e.printStackTrace();
    74.                             }
    75.                         }
    76.                     }
    77.                 }
    78.                 hasEncode = true;
    79.             }
    80.             return parameterMap;
    81.         }
    82.         return super.getParameterMap();
    83.     }
    84.  
    85.     //取一个值
    86.     @Override
    87.     public String getParameter(String name) {
    88.         Map parameterMap = getParameterMap();
    89.         String[] values = parameterMap.get(name);
    90.         if (values == null) {
    91.             return null;
    92.         }
    93.         return values[0]; // 取回参数的第一个值
    94.     }
    95.  
    96.     //取所有值
    97.     @Override
    98.     public String[] getParameterValues(String name) {
    99.         Map parameterMap = getParameterMap();
    100.         String[] values = parameterMap.get(name);
    101.         return values;
    102.     }
    103. }

    然后再在web.xml中进行相关配置

    1. <filter>
    2.         <filter-name>encodingfilter-name>
    3.         <filter-class>com.zhang.Filter.GenericEncodingFilterfilter-class>
    4.     filter>
    5.     <filter-mapping>
    6.         <filter-name>encodingfilter-name>
    7.         <url-pattern>/*url-pattern>
    8.     filter-mapping>

    4、JSON

    4.1、概念：

     在前端页面json和js对象的相互转换：

     4、JSON

    这里需要注意的是@RestController 注解会自动将返回值转换为JSON或XML格式的响应。

    4.1、注解RestController和Controller的区别如下：

     注意@RestController=Controller+ResponseBody,二者可以组合起来搭配使用。用RestController注解返回的就只是一个JSON风格的字符串。

     4.2、一个小案例

    我的jdk版本是1.8。

    1.建立一个实体类User。

    1. package com.zhang.pojo;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. @Data  //需要导入lomb的相关依赖
    8. @AllArgsConstructor //有参构造
    9. @NoArgsConstructor  //无参构造
    10. public class User {
    11.     private String name;
    12.     private int age;
    13.     private String sex;
    14. }

    2.导入pom.xml的相关依赖。

    2.     <dependencies>
    3.         <dependency>
    4.             <groupId>junitgroupId>
    5.             <artifactId>junitartifactId>
    6.             <version>4.12version>
    7.             <scope>testscope>
    8.         dependency>
    9.         <dependency>
    10.             <groupId>org.springframeworkgroupId>
    11.             <artifactId>spring-webmvcartifactId>
    12.             <version>5.3.4version>
    13.         dependency>
    14.         <dependency>
    15.             <groupId>javax.servletgroupId>
    16.             <artifactId>servlet-apiartifactId>
    17.             <version>2.5version>
    18.         dependency>
    19.         <dependency>
    20.             <groupId>javax.servletgroupId>
    21.             <artifactId>jstlartifactId>
    22.             <version>1.2version>
    23.         dependency>
    24.         <dependency>
    25.             <groupId>com.fasterxml.jackson.coregroupId>
    26.             <artifactId>jackson-databindartifactId>
    27.             <version>2.9.8version>
    28.         dependency>
    29.         <dependency>
    30.             <groupId>org.projectlombokgroupId>
    31.             <artifactId>lombokartifactId>
    32.             <version>1.18.26version>
    33.             <scope>compilescope>
    34.         dependency>
    35.     dependencies>
    36.     
    37.     <build>
    38.         <resources>
    39.             <resource>
    40.                 <directory>src/main/javadirectory>
    41.                 <includes>
    42.                     <include>**/*.propertiesinclude>
    43.                     <include>**/*.xmlinclude>
    44.                 includes>
    45.                 <filtering>falsefiltering>
    46.             resource>
    47.             <resource>
    48.                 <directory>src/main/resourcesdirectory>
    49.                 <includes>
    50.                     <include>**/*.propertiesinclude>
    51.                     <include>**/*.xmlinclude>
    52.                 includes>
    53.                 <filtering>falsefiltering>
    54.             resource>
    55.         resources>
    56.     build>

    3.在springmvc-servlet.xml中导入相关的解决json乱码的问题。

    1.  
    2.     <context:component-scan base-package="com.zhang.controller"/>
    3.     
    4.     <mvc:default-servlet-handler />
    5.     
    6.     <mvc:annotation-driven />
    7.  
    8.     
    9.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
    10.           id="internalResourceViewResolver">
    11.         
    12.         <property name="prefix" value="/WEB-INF/jsp/" />
    13.         
    14.         <property name="suffix" value=".jsp" />
    15.     bean>
    16.     
    17.     <mvc:annotation-driven>
    18.         <mvc:message-converters register-defaults="true">
    19.             <bean class="org.springframework.http.converter.StringHttpMessageConverter">
    20.                 <constructor-arg value="UTF-8"/>
    21.             bean>
    22.             <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    23.                 <property name="objectMapper">
    24.                     <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
    25.                         <property name="failOnEmptyBeans" value="false"/>
    26.                     bean>
    27.                 property>
    28.             bean>
    29.         mvc:message-converters>
    30.     mvc:annotation-driven>

    4.在web.xml中导入相关依赖。

    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.  
    7.     
    8.     <servlet>
    9.         <servlet-name>SpringMVCservlet-name>
    10.         <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    11.         
    12.         <init-param>
    13.             <param-name>contextConfigLocationparam-name>
    14.             <param-value>classpath:springmvc-servlet.xmlparam-value>
    15.         init-param>
    16.         
    17.         <load-on-startup>1load-on-startup>
    18.     servlet>
    19.  
    20.     
    21.     <servlet-mapping>
    22.         <servlet-name>SpringMVCservlet-name>
    23.         <url-pattern>/url-pattern>
    24.     servlet-mapping>
    25.  
    26.     <filter>
    27.         <filter-name>encodingfilter-name>
    28.         <filter-class>com.zhang.Filter.GenericEncodingFilterfilter-class>
    29.     filter>
    30.     <filter-mapping>
    31.         <filter-name>encodingfilter-name>
    32.         <url-pattern>/*url-pattern>
    33.     filter-mapping>
    34.  
    35. web-app>

    5.建立一个controller类进行测试就可以了

    1. import com.zhang.pojo.User;
    2. import org.springframework.stereotype.Controller;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6. @RestController
    7. public class UserController {
    8.     @RequestMapping("/json1")
    9.     public String json1() throws JsonProcessingException {
    10.         ObjectMapper mapper=new ObjectMapper();
    11.         User user=new User("章鱼卷",1,"女");
    12.         String str=mapper.writeValueAsString(user);
    13.         return str;
    14.     }
    15. }

    6.EEROR 记得lib下要导入相关的jar包呀，不然会报500的错的

     5、ssm整合：Mybatis层

    学习就是苦中作乐，加油呀！我还有4天就开学了，呜呜呜，好快！

  • 相关阅读:
    python基于PHP+MySQL的图书馆自习室预约占座系统
    LeetCode刷题系列 -- 652. 寻找重复的子树
    pycharm2022.2 远程连接服务器调试代码
    uniapp中vue3使用uni.createSelectorQuery().in(this)报错
    10道不得不会的Docker面试题
    笔试强训(三十八)
    深度学习环境配置（tensorflow、anaconda、pycharm）
    JavaSE学习--数据类型和运算符
    java毕业生设计中小学图书馆管理计算机源码+系统+mysql+调试部署+lw
    如何构建Hive数据仓库Hive 、数据仓库的存储方式 以及hive数据的导入导出
  • 原文地址：https://blog.csdn.net/qq_62649563/article/details/132689373