SpringMvc学习笔记！

最新推荐文章于 2021-12-28 10:36:08 发布

程序猿二鍋頭

最新推荐文章于 2021-12-28 10:36:08 发布

阅读量115

点赞数

分类专栏： SSM 文章标签： spring mvc

本文链接：https://blog.csdn.net/qq_45441466/article/details/115054571

版权

SSM 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

SpringMVC

SSM: mybatis +Spring + SpringMVC MVC三层架构

回顾MVC：

什么是MVC

MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
是将业务逻辑、数据、显示分离的方法来组织代码。
MVC主要作用是降低了视图与业务逻辑间的双向耦合。
MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

Model(模型)：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件(包含数据和行为),不过现在一般都分离开来：Value Object(数据Dao)和服务层(行为Service)。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View(视图)：负责进行模型的展示，一般就是我们见到用户界面，客户想看到的东西。

Controller(控制器)：接收用户请求，委托给模型进行处理(状态改变),处理完毕后吧返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最经典的MVC就是JSP + servlet + javabean的模式。

回顾Servlet：

Maven坐标：

<?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/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>SpringMvc</artifactId>
        <groupId>com.panghl</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springmvc-01-servlet</artifactId>

    <dependencies>
        <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>
    </dependencies>

</project>

servlet：

package com.panghl.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * @Author panghl
 * @Date 2021/3/21 20:41
 * @Description TODO
 **/
//@WebService(name = "/hello")
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方法");
        }
        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 {
        this.doGet(req, resp);
    }
}

form.jsp：

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/21
  Time: 20:47
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
</head>
<body>
<form action="/hello" method="post">
  <input type="text" name="method" />
  <input type="submit"/>
</form>
</body>
</html>

test.jsp:

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/21
  Time: 20:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
</head>
<body>
test.jsp
${msg}
</body>
</html>

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>hello</servlet-name>
        <servlet-class>com.panghl.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>15</session-timeout>
    </session-config>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

</web-app>

配置好tomcat 测试！

我们为什么要学习SpringMVC呢？

Spring MVC的特点：

1、轻量级，简单易学

2、高效，基于请求响应的MVC框架

3、与Spring兼容性好，无缝结合

4、约定由于配置

5、功能强大：RESTful、数据验证、格式化、本地化、主题等

6、简洁灵活

Spring的web框架围绕DispatcherServlet[调度Servlet]设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5 或者以上版本的用户可以采用基于注解形式开发，十分简洁；

HelloMvc：

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

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


    <!--/ 匹配所有的请求: （不包括.jsp）-->
    <!--/* 匹配所有的请求： (包括.jsp)-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

spring-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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

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

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

</beans>

HelloController:

package com.panghl.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @Author panghl
 * @Date 2021/3/21 21:32
 * @Description TODO
 **/
//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg", "HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

测试：

可能遇到的问题：访问出现404，排查步骤：

1.查看控制台输出，看一下是不是缺少了什么jar包

2.如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！

3.重启Tomcat即可解决！

小结：看这个估计大部分同学能理解其中的原理了，但是我们实际开发才不会这么写，不然就疯了，还学和这个玩意干嘛！我们来看个注解版实现，这才是SpringMVC的精髓，到底有多么简单，看个图就知道了。

SpringMvc执行流程：

使用注解开发SpringMVC

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>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <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-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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
">

    <!--自动扫描包，让指定包下的注解生效，由IOC容器统一管理-->
    <context:component-scan base-package="com.panghl.controller"/>

    <!--让Spring MVC不处理静态资源  .css .js .html .mp3 .mp4-->
    <mvc:default-servlet-handler/>


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

    <!--视图解析器: 模板引擎Thymeleaf Freemarker-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

controller:

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author panghl
 * @Date 2021/3/22 23:01
 * @Description TODO
 **/
@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/h1")
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","hello,Springmvc");
        return "test"; //会被视图解析器处理
    }

}

启动tomcat----》测试

RESTFul 风格

概念

Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

功能

资源：互联网所有的事物都可以被抽象为资源
资源操作：使用POST、DELETE、PUT、GET ，使用不同方法对资源进行操作。
分别对应 ：添加、删除、修改、查询

传统方式操作资源：通过不同的参数来实现不同的效果！方法单一，post和get

http://127.0.0.1/item/queryItem.action?id=1 查询，Get
http://127.0.0.1/item/saveItem.action 新增，POST
http://127.0.0.1/item/updateItem.action 更新，POST
http://127.0.0.1/item/deleteItem.action?id=1 删除，GET或POST

使用Restful操作资源：可以通过不同的请求方式来实现不同的效果！如下：请求地址一样，但是功能可以不同！

http://127.0.0.1/item/1 查询，Get
http://127.0.0.1/item 新增，POST
http://127.0.0.1/item 更新，PUT
http://127.0.0.1/item/1 删除，Delete

测试

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author panghl
 * @Date 2021/3/28 22:42
 * @Description TODO
 **/
@Controller
public class RestFulController {

    //原来的： http://localhost:8080/add?a=1&b=2
    //RestFul: http://localhost:8080/add/1/2

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

思考：使用路径变量的好处？

使路径变得更加简洁；
获得参数更加方便，框架会自动进行类型转换，高效；
通过路径变量的类型可以约束访问参数。如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/a,则路径与方法不匹配，而不是参数类型转换失败。

ModelAndView

设置ModelAndView对象，根据view的名称，和视图解析器跳到指定的页面。

页面：{视图解析器前缀}+viewName+{视图解析器后缀}

    <!--视图解析器: 模板引擎Thymeleaf Freemarker-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

ServletAPI

通过设置ServletAPI，不需要视图解析器。

1.通过HttpServletResponse进行输出

2.通过HttpServletResponse实现重定向

3.通过HttpServletResponse实现转发

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

/**
 * @Author panghl
 * @Date 2021/3/28 23:10
 * @Description TODO
 **/
@Controller
public class ModelTest1 {

    @RequestMapping("/m1/t1")
    public String test(HttpServletRequest request, HttpServletResponse response){
        HttpSession session = request.getSession();
        System.out.println(session.getId());
        return "test";
    }

    @RequestMapping("/m1/t2")
    public void test2(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession();
        System.out.println("请求转发"+session.getId());
        request.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(request,response);
    }

    @RequestMapping("/t3")
    public void test3(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession();
        System.out.println("重定向"+session.getId());
        response.sendRedirect("index.jsp");
    }

}

SpringMVC

通过SpringMVC来实现转发和重定向-无需视图解析器

测试前，需要将视图解析器注释掉！

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

/**
 * @Author panghl
 * @Date 2021/3/28 23:10
 * @Description 没有配置视图解析器
 **/
@Controller
public class ModelTest2 {

    /**
     * 没有配置视图解析器 需要全路径
     * @param model
     * @return
     */
    @RequestMapping("/m2/t1")
    public String test1(Model model){
        model.addAttribute("msg","ModelTest2");
        return "/WEB-INF/jsp/test.jsp";
    }

    /**
     * 重定向
     * @param model
     * @return
     */
    @RequestMapping("/m2/t2")
    public String test2(Model model){
        model.addAttribute("msg","ModelTest2");
        return "redirect:/index.jsp";
    }
}

通过SpringMVC来实现转发和重定向-有视图解析器

重定向，不需要视图解析器，本质就是重新请求一个新地方，所以注意路径问题。

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Author panghl
 * @Date 2021/3/28 23:10
 * @Description 没有配置视图解析器
 **/
@Controller
public class ModelTest3 {

    /**
     * 没有配置视图解析器 需要全路径
     * @param model
     * @return
     */
    @RequestMapping("/m3/t1")
    public String test1(Model model){
        model.addAttribute("msg","ModelTest2");
        return "test";
    }

    /**
     * 重定向
     * @param model
     * @return
     */
    @RequestMapping("/m3/t2")
    public String test2(Model model){
        model.addAttribute("msg","ModelTest2");
        return "redirect:/index.jsp";
    }
}

乱码问题

    <!--配置编码过滤器-->
    <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>

JSON

JSON(JavaScript Object Notation,JS对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
采用完全独立于编程语言的文本格式来存储和表示数据
简介和清晰的层次结构使得JSON称为利息的数据交互语言
易于人阅读和编写，同时也易于及其解析和生成，并有效地提升网络传输效率。

在JavaScript语言汇总，一切都是对象。因此，任何JavaScript 支持的类型都可以通过JSON来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

对象表示为键值对，数据由逗号分隔
花括号保存对象
方括号保存数组

JSON键值对是用来保存JavaScript对象的一种方式，和JavaScript对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号：分离，然后进阶着值：

{"name": "Panghl"}
{"age": 2}

var jsonObj1 = JSON.parse(data); //使用JSON.parse() 将JSON字符串转为JS对象;

JS对象转JSON ：Object.toJSONString()

JSON转JS对象：String.parseJSON()

Controller返回JSON数据

Jackson应该是目前比较好的json解析工具了
当然工具不止这一个，比如还有阿里巴巴的fastjson等等
我们这里使用Jackson，使用它需要导入它的jar包

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.8</version>
        </dependency>

Jackson

controller:

package com.panghl.controller;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.panghl.pojo.User;
import com.panghl.utils.JsonUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author panghl
 * @Date 2021/3/29 0:12
 * @Description TODO
 **/
//@Controller
@RestController
public class UserController {
    @RequestMapping(value = "j1", produces = "application/json;charset=utf-8")
    //@ResponseBody //它就不会走视图解析器 会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //jackson ,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(1, "panghl", 1);
        return JsonUtils.getJson(user);
    }

    @RequestMapping(value = "j2")
    public String j2() throws JsonProcessingException {
        //jackson ,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        SimpleDateFormat sdf = new SimpleDateFormat();
        mapper.setDateFormat(sdf);
        Date date = new Date();

//        String format = sdf.format(date);

        //ObjectMapper,时间解析后的默认格式为：Timestamp 时间戳
        return mapper.writeValueAsString(date);
    }

    @RequestMapping(value = "j3")
    public String j3() throws JsonProcessingException {
        //ObjectMapper,时间解析后的默认格式为：Timestamp 时间戳
        return JsonUtils.getJson(new Date(),"yyy-MM-dd HH:mm:ss");
    }
}

抽取工具类：

package com.panghl.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

/**
 * @Author panghl
 * @Date 2021/3/29 0:29
 * @Description TODO
 **/
public class JsonUtils {

    public static String getJson(Object object) throws JsonProcessingException {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String sdf) throws JsonProcessingException {
        //jackson ,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        SimpleDateFormat sdf1 = new SimpleDateFormat(sdf);
        mapper.setDateFormat(sdf1);
        return mapper.writeValueAsString(object);
    }

}

还有另一种解决乱码的办法：

  <!--JSON乱码问题配置-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"></constructor-arg>
            </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>

fastjson

fastjson三个主要的类

【JSONObject代表json对象】
- JSONObject实现Map接口，猜想JSONObject底层操作是由Map实现的。
- JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size(),isEmpty（）等方法获取"键:值"对的个数来判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
【JSONArray代表json对象数组】
- 内部是有List接口中的方法来完成操作的
【JSON代表JSONObject和JSONArray的转化】
- JSON类源码分析与使用
- 自习观察这些方法，主要实现json对象，json对象数组，javabean对象，json字符串之间的相互转换

代码测试：

package com.panghl.controller;

import com.alibaba.fastjson.JSON;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.panghl.pojo.User;
import com.panghl.utils.JsonUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import sun.nio.cs.US_ASCII;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @Author panghl
 * @Date 2021/3/29 0:12
 * @Description TODO
 **/
//@Controller
@RestController
public class UserController {
    @RequestMapping(value = "j1", produces = "application/json;charset=utf-8")
    //@ResponseBody //它就不会走视图解析器 会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        //jackson ,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(1, "panghl", 1);
        return JsonUtils.getJson(user);
    }

    @RequestMapping(value = "j2")
    public String j2() throws JsonProcessingException {
        //jackson ,ObjectMapper
        ObjectMapper mapper = new ObjectMapper();
        //不使用时间戳的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        SimpleDateFormat sdf = new SimpleDateFormat();
        mapper.setDateFormat(sdf);
        Date date = new Date();

//        String format = sdf.format(date);

        //ObjectMapper,时间解析后的默认格式为：Timestamp 时间戳
        return mapper.writeValueAsString(date);
    }

    @RequestMapping(value = "j3")
    public String j3() throws JsonProcessingException {
        //ObjectMapper,时间解析后的默认格式为：Timestamp 时间戳
        return JsonUtils.getJson(new Date(),"yyy-MM-dd HH:mm:ss");
    }

    @RequestMapping(value = "j4")
    //@ResponseBody //它就不会走视图解析器 会直接返回一个字符串
    public String j4() throws JsonProcessingException {
        //创建一个对象
        User user = new User(1, "panghl", 1);
        return JSON.toJSONString(user);
    }
}

Ajax技术

简介

AJAX=Asynchronous JavaScript XML （异步的JavaScript和XML）
AJAX是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。
Ajax不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web程序的技能。

代码示例：

package com.panghl.controller;

import com.panghl.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author panghl
 * @Date 2021/3/30 22:14
 * @Description TODO
 **/
@RestController
public class AjaxController {

    @RequestMapping("/t1")
    public String test(){
        return "hello";
    }

    @RequestMapping("/a1")
    public void a1(String name, HttpServletResponse response) throws IOException {
        System.out.println("a1:param=>"+name);
        if ("panghl".equals(name)){
            response.getWriter().print("true");
        }else {
            response.getWriter().print("false");
        }
    }

    @RequestMapping("/getUsers")
    public List<User> getUsers() throws IOException {
        List<User> userList = new ArrayList<>();

        userList.add(new User("panghl2",1,"男"));
        userList.add(new User("panghl3",1,"男"));
        userList.add(new User("panghl4",1,"男"));
        userList.add(new User("panghl5",1,"男"));
        userList.add(new User("panghl6",1,"男"));
        return userList;

    }


    @RequestMapping("/a3")
    public String a3(String name,String pwd) throws IOException {
        String msg = "";
        if (name!=null){
            if ("admin".equals(name)){
                msg="ok";
            }else {
                msg="用户名有误";
            }
        }
        if (pwd!=null){
            if ("123456".equals(pwd)){
                msg="ok";
            }else {
                msg="密码有误";
            }
        }
        return msg;
    }
}

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 22:12
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
  <script>
    function a() {
      $.post({
        url: "${pageContext.request.contextPath}/a1",
        data: {"name": $("#username").val()},
        success: function (res,status) {
          console.log(res);
          console.log(status);
        }
      })
      $.get({
        url: "${pageContext.request.contextPath}/getUsers",
        data: {},
        success: function (res,status) {
          console.log(res);
          console.log(status);
        }
      })
    }
  </script>
</head>
<body>
<%--失去焦点的时候，发起一个请求到后台--%>
用户名: <input type="text" id="username" onblur="a()">
</body>
</html>

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 23:20
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
  <script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
  <script>
    function a1() {
      $.post({
        url: "${pageContext.request.contextPath}/a3",
        data: {"name": $("#name").val()},
        success: function (res,status) {
          console.log(res);
          console.log(status);
        }
      })
    }
    function a2() {
      $.post({
        url: "${pageContext.request.contextPath}/a3",
        data: {"pwd": $("#pwd").val()},
        success: function (res,status) {
          console.log(res);
          console.log(status);
        }
      })
    }
  </script>
</head>
<body>
<p>
  用户名: <input type="text" id="name" onblur="a1()">
</p>
<p>
  密码: <input type="text" id="pwd" onblur="a2()">
  <span id="pwdInfo"></span>
</p>
</body>
</html>

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 22:12
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>$Title$</title>
  <script src="${pageContext.request.contextPath}/statics/js/jquery-3.6.0.js"></script>
  <script>
    $(function () {
      $("#btn").click(function () {
        $.get({
          url: "${pageContext.request.contextPath}/getUsers",
          data: {},
          success: function (res, status) {
            var html = "";

            for (let i =0;i<res.length;i++){
              html+="<tr>"+
                "<td>"+res[i].name+"</td>"+
                "<td>"+res[i].age+"</td>"+
                "<td>"+res[i].sex+"</td>"+
                "<tr>"
            }

            $("#content").html(html);
          }
        })
      })
    })
  </script>
</head>
<body>
<input type="submit" value="加载数据" id="btn">
<table>
  <tr>
    <td>姓名</td>
    <td>年龄</td>
    <td>性别</td>
  </tr>
  <tbody id="content">
  <%--数据：后台--%>

  </tbody>
</table>
</body>
</html>

SpringMVC拦截器

概述

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特点的功能。

过滤器与拦截器的区别：拦截器是AOP思想的具体应用

过滤器

servlet规范中的一部分，任何java web工程都可以使用
在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的。

自定义拦截器

那如何实现拦截器呢？

想要自定义拦截器，必须实现HandlerInterceptor接口

编写一个拦截器：

package com.panghl.config;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * @Author panghl
 * @Date 2021/3/30 23:38
 * @Description TODO
 **/
public class MyInterceptor implements HandlerInterceptor {

    //return true; 执行下一个拦截器，放行
    //return false; 不执行下一个拦截器
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("===========处理前============");
        HttpSession session = request.getSession();
//放行：判断什么情况下登录

        //登录页面也会放行
        if (request.getRequestURI().contains("Login")) {
            return true;
        }
        //登录方法也放行
        if (request.getRequestURI().contains("login")) {
            return true;
        }
        //第一次登陆，也是没有session的
        if (session.getAttribute("userLoginInfo") != null) {
            return true;
        }
        //判断什么情况下没有登录
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }

    //日志
    @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("===========清理============");

    }
}

在applicationContext.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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
">
    <context:component-scan base-package="com.panghl.controller"/>

    <!--静态资源过滤-->
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>

    <!--视图解析器: 模板引擎Thymeleaf Freemarker-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--JSON乱码问题配置-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"></constructor-arg>
            </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>

    <!--拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--包括这个请求下面的所有请求-->
            <mvc:mapping path="/user/**"/>
            <bean id="myInterceptor" class="com.panghl.config.MyInterceptor">

            </bean>
        </mvc:interceptor>
    </mvc:interceptors>

</beans>

LoginController

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpSession;

/**
 * @Author panghl
 * @Date 2021/3/30 23:48
 * @Description TODO
 **/
@Controller
@RequestMapping("/user")
public class LoginController {

    @RequestMapping("/main")
    public String main() {
        return "main";
    }

    @RequestMapping("/goLogin")
    public String goLogin() {
        return "login";
    }

    @RequestMapping("/login")
    public String login(HttpSession session, String name, String pwd, Model model) {
        //吧用户的信息存入session中
        session.setAttribute("userLoginInfo", name);
        model.addAttribute("msg",name);
        return "main";
    }

    @RequestMapping("/goOut")
    public String goOut(HttpSession session) {
        //吧用户的信息清除
//        session.invalidate();
        session.removeAttribute("userLoginInfo");
        return "main";
    }
}

index.jsp

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 23:36
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
  <h1>
    <a href="${pageContext.request.contextPath}/user/goLogin">登录页面</a>
    <a href="${pageContext.request.contextPath}/user/main">首页</a>
  </h1>
  </body>
</html>

login.jsp

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 23:46
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>登录</title>
</head>
<body>
<%--在WEB-INF下的所有页面或者资源，只能通过controller，或者servlet进行访问--%>
<h1>登录页面</h1>
<form action="${pageContext.request.contextPath}/user/login" method="post">
    用户名: <input type="text" id="name" name="name">
    密码: <input type="text" id="pwd" name="pwd" >
  <input type="submit" value="提交">
</form>
</body>
</html>

main.jsp

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/30
  Time: 23:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
  <title>Title</title>
</head>
<body>
<h1>首页</h1>
<h2>${msg}</h2>
</body>
</html>

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>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <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>
</web-app>

文件上传-下载

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>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <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-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <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>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

</web-app>

Spring-mvc.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:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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
">
    <context:component-scan base-package="com.panghl.controller"/>

<!--    <mvc:default-servlet-handler/>-->
<!--    <mvc:annotation-driven/>-->

    <!--视图解析器: 模板引擎Thymeleaf Freemarker-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--JSON乱码问题配置-->
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"></constructor-arg>
            </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>


    <!--文件上传配置-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--请求的编码格式，必须和jsp的pageEncoding属性一致，以便读取表单的内容，默认为ISO-8859-1-->
        <property name="defaultEncoding" value="utf-8"/>
        <!--文件上传大小限制，单位为字节(10485760=10M)-->
        <property name="maxUploadSize" value="10485760"/>
        <property name="maxInMemorySize" value="40960"/>
    </bean>
</beans>

FileController.class

package com.panghl.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;

/**
 * @Author panghl
 * @Date 2021/3/29 23:45
 * @Description TODO
 **/
@RestController
public class FileController {
    @RequestMapping("/upload")
    public String upload(@RequestParam("file")CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        //获取文件名
        String originalFilename = file.getOriginalFilename();

        //如果文件名为空，直接返回首页!
        if ("".equals(originalFilename)){
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名: =>"+originalFilename);

        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址: "+realPath);

        InputStream is = file.getInputStream(); //文件输入流
        OutputStream os = new FileOutputStream(new File(realPath,originalFilename)); //文件输出流

        //读取写出
        int len = 0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }

    @RequestMapping("/upload2")
    public String upload2(@RequestParam("file")CommonsMultipartFile file, HttpServletRequest request) throws IOException {
        //获取文件名
        String originalFilename = file.getOriginalFilename();

        //如果文件名为空，直接返回首页!
        if ("".equals(originalFilename)){
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名: =>"+originalFilename);

        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址: "+realPath);

        //通过CommonsMultipartFile的方法直接写文件(注意这个时候)
        file.transferTo(new File(realPath+"/"+originalFilename));
        return "redirect:/index.jsp";
    }

    @RequestMapping("download")
    public String download(HttpServletRequest req, HttpServletResponse resp) throws Exception{
        //要下载的图片地址
        String realPath = req.getServletContext().getRealPath("/upload");
        String fileName = "前台流程图.jpg";

        //1.设置response响应头
        resp.reset(); //设置页面不缓存，清空buffer
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("multipart/form-data"); //二进制传输数据
        //设置响应头
        resp.setHeader("Content-Disposition",
                "attachment;fileName="+ URLEncoder.encode(fileName,"UTF-8"));

        File file = new File(realPath,fileName);
        //2. 读取文件--输入流
        InputStream input = new FileInputStream(file);
        //3. 写出文件--输出流
        OutputStream outputStream = resp.getOutputStream();

        byte[] buffer = new byte[1024];
        int index=0;
        while ((index=input.read(buffer))!=-1){
            outputStream.write(buffer,0,index);
            outputStream.flush();
        }
        outputStream.close();
        input.close();
        return "下载成功";
    }
}

index.jsp

<%--
  Created by IntelliJ IDEA.
  User: phl04
  Date: 2021/3/29
  Time: 23:39
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
  <head>
    <title>$Title$</title>
  </head>
  <body>
<form method="post" action="${pageContext.request.contextPath}/upload" enctype="multipart/form-data">
  <input type="file" name="file"/>
  <input type="submit" value="upload">
</form>
  </body>
</html>

程序猿二鍋頭

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
SpringMvc学习笔记！

SpringMVCSSM: mybatis +Spring + SpringMVC MVC三层架构回顾MVC：什么是MVCMVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。是将业务逻辑、数据、显示分离的方法来组织代码。 MVC主要作用是降低了视图与业务逻辑间的双向耦合。 MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。Model(模型)：数据模型，提供要展示的数据，因此包含数据和行为...
复制链接

扫一扫