springMVC学习

已于 2022-03-04 09:50:17 修改
阅读量548 收藏 1
点赞数
分类专栏： spring 文章标签： mvc spring java
于 2021-08-21 15:05:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45598422/article/details/119839704
版权

1、SpringMVC

什么是MVC

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

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

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

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

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

MVC: 模型（dao，service） 视图（jsp） 控制器（servlet）

jsp：本质就是servlet

2、什么是Spring MVC

2.1、概述

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

我们为什么要学习SpringMVC呢?

Spring MVC的特点：

  1. 轻量级，简单易学
  2. 高效 , 基于请求响应的MVC框架
  3. 与Spring兼容性好，无缝结合
  4. 约定优于配置
  5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
  6. 简洁灵活、

最重要的一点还是用的人多 , 使用的公司多 .

2.2、中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

​ Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

SpringMVC的原理如下图所示：

​ 当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

图片

2.3、SpringMVC执行原理

图片

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

执行流程
在这里插入图片描述

  1. dispatcherservlet表示前置控制器，是整个springmvc的控制中心。用户发出请求，dispatcherservlet接受请求并拦截请求。

    我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

    如上url拆分成三部分：

    http://localhost:8080服务器域名

    SpringMVC部署在服务器上的web站点

    hello表示控制器

    通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

  2. HandlerMapping为处理器映射。dispatcherservlet调用HandlerMapping，然后HandlerMapping根据请求url查找Handler

  3. HandlerExecution表示具体的Handler，其主要作用是根据url查找控制器，如上url被查找的控制器为：hello

  4. HandlerExecution将解析后的信息传递给dispatcherservlet，如解析控制器

  5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler

  6. Handler让具体的controller执行

  7. controller将具体的执行信息返回给HandlerAdapter

  8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

  9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

  10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

  11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

  12. 最终视图呈现给用户。

配置版

  1. 新建一个Moudle ， springmvc-02-hello ， 添加web的支持！

  2. 确定导入了SpringMVC 的依赖！

  3. 配置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 ：这个是springmvc的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定spring的配置文件-->
        <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>

    <!--
       在springmvc中：/ /*
       /：只匹配所有的请求，不会去匹配jsp页面
       /*：匹配所有的请求，包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

  4. 编写SpringMVC 的 配置文件！名称：springmvc-servlet.xml : [servletname]-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">

</beans>

  5. 添加 处理映射器

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

  6. 添加 处理器适配器

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

  7. 添加 视图解析器

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

  8. 编写我们要操作业务Controller

    package com.wyl.controller;

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

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

public class HelloController implements Controller  {


    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();

        //业务代码
        String result = "hh";
        mv.addObject("msg",result);

        //视图跳转
        mv.setViewName("test");


        return mv;
    }
}

  9. 将自己的类交给SpringIOC容器，注册bean

        <!--BeanNameUrlHandlerMapping:bean -->
    <bean id="/hello" class="com.wyl.controller.HelloController"/>

    最后完整的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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--处理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

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

    <!--BeanNameUrlHandlerMapping:bean -->
    <bean id="/hello" class="com.wyl.controller.HelloController"/>

</beans>

  10. 写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；

    在这里插入图片描述

  11. 配置tomcat测试

注解版

  1. 新建一个Moudle ， springmvc-03-annnotation ， 添加web的支持！

  2. 确定导入了SpringMVC 的依赖！

  3. 配置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 ：这个是springmvc的核心，请求分发器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--DispatcherServlet要绑定spring的配置文件-->
        <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>

    <!--
       在springmvc中：/ /*
       /：只匹配所有的请求，不会去匹配jsp页面
       /*：匹配所有的请求，包括jsp页面
    -->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

  4. 编写SpringMVC 的 配置文件！

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


    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.wyl.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <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>

  5. 在com.wyl.controller包下创建一个controller

    @Controller
public class HelloController {

    @RequestMapping("/hello")//表示url输入的地址
    public String hello(Model model){
        //封装数据
        model.addAttribute("msg","Hello,controller");


        return "hello";//会被视图解析器处理
    }

}

  6. 在WEB-INF/jsp目录下创建jsp

    在这里插入图片描述

  7. 测试

可能遇到的问题：访问出现404

  1. 查看控制台输出，看一下是不是缺少了什么jar包。
  2. 如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！
    1. 增加一个lib文件
    2. 在lib文件里导入jar包

在这里插入图片描述

在这里插入图片描述

  1. 重启tomcat

小结

配置版：一个控制器只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；

注解方式是平时使用的最多的方式！

RequestMapping
@RequestMapping

@RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

为了测试结论更加准确，我们可以加上一个项目名测试 myweb

只注解在方法上面

@Controller//代表这个类会被spring接管
public class ControllerTest2 {

    @RequestMapping("/t1")
    public String test1(Model model){
        model.addAttribute("msg","controllerTest2");

        return "test";
    }
}

访问的url地址：http://localhost:8080 / 项目名 / t1

同时注解类与方法

@Controller//代表这个类会被spring接管
@RequestMapping("/c3")
public class ControllerTest3 {

    @RequestMapping("/t1")
    public String test1(Model model){
        model.addAttribute("msg","controllerTest3");
        return "test";
    }

}

访问的url地址：http://localhost:8080 / 项目名 /c3/ t1

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

编写一个RestFulController类

@Controller
public class RestFulController {

    //原来的：http://localhost:8080/add?a=1&b=3
    //RestFul:http://localhost:8080/add/a/b
    //@RequestMapping(value = "/add/{a}/{b}",method = RequestMethod.GET)
    @GetMapping("/add/{a}/{b}")//等价于上面的@RequestMapping
    public String test1(@PathVariable int a,@PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","结果为:"+res);
        return "test";
    }

}

使用路径变量的好处

  • 使路径变得更加简洁；
  • 获得参数更加方便，框架会自动进行类型转换。
  • 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，

小结：

Spring MVC 的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

所有的地址栏请求默认都会是 HTTP GET 类型的。

方法级别的注解变体有如下几个：组合注解

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@GetMapping 是一个组合注解，平时使用的会比较多！

它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。

结果跳转方式

ModelAndView

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

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

通过springmvc来实现转发和重定向

return默认是转发，修改为重定向只需在前面加上redirect:。

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

转发是可以被视图解析器解析的，而重定向则要写文件的完整路径，并且还无法访问WEB-INF目录下的文件

@Controller
public class ModelTest1 {

    @RequestMapping("/rd")
    public String test(Model model){

        model.addAttribute("msg","hello rd");
        //重定向
        return "redirect:/index.jsp";
    }

}

数据处理

@RequestParam：接收前端传来的参数尽量使用这个注解标注

@Controller
@RequestMapping("/user")
public class UserController {

    //localhost:8080/user/t1?name=xxx
    @GetMapping("/t1")
    public String test1(@RequestParam("username") String name, Model model){
        //1.接受前端参数
        System.out.println("接收到前端的参数为:"+name);
        //2.将返回的结果传递给前端
        model.addAttribute("msg",name);

        return "test";
    }

    //前端就收的是一个对象
    /*
        1.接收前端用户传递的参数，判断参数的名字，假设名字直接在方法上，可以直接使用
        2.假设传递的是一个对象User，匹配User对象中的字段名；如果名字不一致，则匹配不到
     */
    @RequestMapping("/t2")
    public String test2(User user,Model model){

        System.out.println(user);
        return "test";
    }

    

}

乱码问题

在web.xml中配置

<!--配置springmvc的乱码过滤-->
<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>

JSON

前后端分离时代：

后端部署后端，提供接口,提供数据

json

前端独立部署，负责渲染后端的数据

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

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

  • 对象表示为键值对，数据由逗号分隔
  • 花括号保存对象
  • 方括号保存数组
<script type="text/javascript">
    //编写一个javascript对象
    var user ={
        name : "张三",
        age:3,
        sex:"男"
    }
    //将js对象转换为json对象
    var json =JSON.stringify(user);
    console.log(json);

    //将JSON对象转换为JavaScript对象
    var obj = JSON.parse(json);
    console.log(obj);
</script>

Jackson

先导包

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.3</version>
</dependency>

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: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的乱码过滤-->
    <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>

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
       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.wyl.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
	
	<!-- 解决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>



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


</beans>

编写一个user类

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

编写Controller

//@RestController:不会走视图解析器，会直接返回一个字符串
@Controller
public class UserController {
	
    @RequestMapping("/j1")
    @ResponseBody//不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        User user = new User("张三",6,"男");
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);

        return str;
    }

 

}

FastJson

fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

先导包

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.60</version>
</dependency>

然后跟上面步骤一样

最后的conctroller代码

//@RestController:不会走视图解析器，会直接返回一个字符串
@Controller
public class UserController {

    //Jackson
    @RequestMapping("/j1")
    @ResponseBody//不会走视图解析器，会直接返回一个字符串
    public String json1() throws JsonProcessingException {
        User user = new User("张三",6,"男");
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);

        return str;
    }
	//FastJson
    @RequestMapping("/j4")
    @ResponseBody
    public String json4(){
        User user = new User("张三",6,"男");

        String s = JSON.toJSONString(user);
        return s;
    }

}

AJax技术

异步无刷新请求

  • AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

  • AJAX 是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

  • Ajax 不是一种新的编程语言，而是一种用于创建更好更快以及交互性更强的Web应用程序的技术。

  • 在 2005 年，Google 通过其 Google Suggest 使 AJAX 变得流行起来。Google Suggest能够自动帮你完成搜索单词。

  • Google Suggest 使用 AJAX 创造出动态性极强的 web 界面：当您在谷歌的搜索框输入关键字时，JavaScript 会把这些字符发送到服务器，然后服务器会返回一个搜索建议的列表。

  • 就和国内百度的搜索框一样!

  • 传统的网页(即不用ajax技术的网页)，想要更新内容或者提交一个表单，都需要重新加载整个网页。

  • 使用ajax技术的网页，通过在后台服务器进行少量的数据交换，就可以实现异步局部更新。

  • 使用Ajax，用户可以创建接近本地桌面应用的直接、高可用、更丰富、更动态的Web用户界面。

使用ajax要先导入jQuery，jQuery是一个库，在代码里通常用$表示

$.ajax(...)
      部分参数：
            url：请求地址
            type：请求方式，GET、POST（1.9.0之后用method）
        headers：请求头
            data：要发送的数据
    contentType：即将发送信息至服务器的内容编码类型(默认: "application/x-www-form-urlencoded; charset=UTF-8")
          async：是否异步
        timeout：设置请求超时时间（毫秒）
      beforeSend：发送请求前执行的函数(全局)
        complete：完成之后执行的回调函数(全局)
        success：成功之后执行的回调函数(全局)
          error：失败之后执行的回调函数(全局)
        accepts：通过请求头发送给服务器，告诉服务器当前客户端可接受的数据类型
        dataType：将服务器端返回的数据转换成指定类型
          "xml": 将服务器端返回的内容转换成xml格式
          "text": 将服务器端返回的内容转换成普通文本格式
          "html": 将服务器端返回的内容转换成普通文本格式，在插入DOM中时，如果包含JavaScript标签，则会尝试去执行。
        "script": 尝试将返回值当作JavaScript去执行，然后再将服务器端返回的内容转换成普通文本格式
          "json": 将服务器端返回的内容转换成相应的JavaScript对象
        "jsonp": JSONP 格式使用 JSONP 形式调用函数时，如 "myurl?callback=?" jQuery 将自动替换 ? 为正确的函数名，以执行回调函数

常用的

$.ajax({
    type:'post',  //设置请求的方式：get or post
    dataType:"text", //设置服务器返回到页面的数据类型（text、json）
    data:{'user':$('#account').val()},
    url:"${pageContext.request.contextPath}/xxx",
    success:function (d) {
     },
    error:function (rs) {
    }
})

样例：登录验证

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<script src="${pageContext.request.contextPath}/static/js/jquery-3.5.1.js"></script>

    <script>
        function a1(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{"name":$("#name").val()},
                success:function (data){
                    if (data.toString()==='ok'){
                        $("#userInfo").css("color","green")
                    }else {
                        $("#userInfo").css("color","red")
                    }
                    $("#userInfo").html(data)
                }
            })
        }
        function a2(){
            $.post({
                url:"${pageContext.request.contextPath}/a3",
                data:{"pwd":$("#pwd").val()},
                success:function (data){
                    if (data.toString()==='ok'){
                        $("#pwdInfo").css("color","green")
                    }else {
                        $("#pwdInfo").css("color","red")
                    }
                    $("#pwdInfo").html(data)
                }
            })
        }
    </script>

<body>

<p>
    用户名：<input type="text" id="name" onblur="a1()">
    <span id="userInfo"></span>
</p>
<p>
    密码：<input type="text" id="pwd" onblur="a2()">
    <span id="pwdInfo"></span>
</p>
</body>
</html>

AjaxController

@RequestMapping("/a3")
public String a3(String name,String pwd){
    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;

}

拦截器

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

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

过滤器

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

拦截器

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

自定义拦截器

  1. 编写一个拦截器

    public class MyInterceptor implements HandlerInterceptor {
    //return true;不拦截，放行
    //return false; 拦截
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    //日志
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

  2. 在springmvc的配置文件中配置拦截器

    <!-- 拦截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
       <!--/** 包括路径及其子路径-->
       <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
       <!--/admin/** 拦截的是/admin/下的所有-->            
            <mvc:mapping path="/**"/>
            <bean class="com.wyl.config.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

文件上传

  1. maven导包

    <!--文件上传-->
<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.3</version>
</dependency>
<!--servlet-api导入高版本的-->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>4.0.1</version>
</dependency>

  2. 在spring配置文件中配置bean

    <!--文件上传配置-->
<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>

  3. 编写前端页面

    <form action="${pageContext.request.contextPath}/upload2" enctype="multipart/form-data" method="post">
    <input type="file" name="file"/>
    <input type="submit" value="upload">
  </form>

  4. Controller

    @RestController
public class FileController {

    /*
     * 采用file.Transto 来保存上传的文件
     */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

        //上传路径保存设置
        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 +"/"+ file.getOriginalFilename()));

        return "redirect:/index.jsp";
    }

    

}
沐三i
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring MVC学习
Sun_study的博客
02-24 837
Spring MVC 一、简介 1、什么是MVC MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分 M：Model，模型层，指工程中的JavaBean，作用是处理数据 JavaBean分为两类： 一类称为实体类Bean：专门存储业务数据的，如 Student、User 等 一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。 V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据 C：Controller，控制层
Spring配置文件头及xsd文件解析
无人与我把酒欢的博客
12-04 1053
最初Spring配置文件的头部声明如下：  Xml代码   xml version="1.0" encoding="UTF-8"?>   "http://www.springframework.org/dtd/spring-beans-2.0.dtd">   beans>      beans>         说明：   1、第一行表示xml声明，任何格式
Spring MVC学习指南 高清完整.pdf版下载
01-24
通俗移动的Spring MVC入门书籍。请尊重版权，禁止用于商业目的。
Spring MVC 学习笔记 一 创建项目
03-23
sample code 博文链接：https://starscream.iteye.com/blog/1057305
Spring MVC学习资料
08-10
Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。使用 Spring 可插入的 MVC 架构，从而在使用Spring进行WEB开发时，可以选择使用Spring的SpringMVC框架或集成其他MVC开发框架，如Struts1，Struts2等
SpringMVC学习文档
02-05
**SpringMVC学习文档概述** SpringMVC是Spring框架的一个模块，主要负责处理Web应用程序的请求和响应。它是一个基于模型-视图-控制器（MVC）架构模式的轻量级Java Web开发框架，旨在简化Web应用开发并提高可测试性...
SpringMvc学习资料
05-30
这份"SpringMvc学习资料"包含了一个200页的Word文档，里面详细讲解了SpringMvc的原理、配置和实际应用，同时提供了大量源码，旨在通过实际项目帮助学习者更好地理解和掌握SpringMvc。 首先，"SpringMVC讲义-IDEA版....
SpringMVC 学习总结
12-05
SpringMVC 是一款基于 Java 的轻量级 Web 开发框架，它是 Spring 框架的一部分，主要用于构建 MVC（Model-View-Controller）架构的应用程序。SpringMVC 的核心是 DispatcherServlet，它作为前端控制器，负责接收请求...
SpringMVC详细文档，内容通俗易懂，适合学习springMVC的初学者
07-22
从基础到高级部分，讲解的很通俗易懂，案例包括spingMVC和myBatis的整合
SpringMVC学习笔记.zip
04-12
SpringMVC是Java web开发中一个非常重要的框架，它基于模型-视图-控制器（Model-View-Controller）设计模式...这份“SpringMVC学习笔记”包括了从基础到进阶的全面内容，旨在帮助读者从零开始掌握SpringMVC的各个方面。
springmvc学习笔记
10-28
springmvc学习笔记
SpringMVC学习编程代码
08-11
这个“SpringMVC学习编程代码”压缩包包含了一整套用于学习SpringMVC的实例代码，旨在帮助开发者更好地理解和掌握这一强大的Web开发工具。 在SpringMVC中，我们首先会接触到配置文件，这通常是`springmvc-config....
SpringMVC学习指南
01-19
SpringMVC是Spring框架的一个重要模块，用于构建Web应用程序的后端控制器。它是一个轻量级的MVC..."SpringMVC学习指南"这个压缩包中的PDF文档，很可能会涵盖这些内容的详细讲解，是学习和提升SpringMVC技能的好资源。
SpringMVC快速入门第一讲——SpringMVC介绍与入门
热门推荐
李阿昀的博客
05-15 3万+
SpringMVC介绍SpringMVC是什么？SpringMVC和Struts2都属于表现层的框架，它是Spring框架的一部分，我们可以从Spring的整体结构中看得出来： SpringMVC处理流程SpringMVC处理流程如下图所示： 这个图大致描述了SpringMVC的整个处理流程，乍一看有点晕乎，且待我一步步分析，最后弄个流程图出来就明白了。SpringMVC入门程序本系列教程使
Spring MVC 学习总结
学习笔记
07-12 4021
每个请求处理方法可以有多个不同的参数，以及一个多种类型的返回结果。 一、Action参数类型 如果在请求处理方法中需要访问HttpSession对象，则可以添加HttpSession作为参数，Spring会将对象正确的传递给方法，如:publish String action(HttpSession session)；若需要访问客户端语言环境和HttpServletRequest对象，则可以在
SpringMVC学习（三）
记录，记录，记录
10-05 439
数据校验 1.导入jar包 2.配置校验器，并加入适配器 3.bean上添加校验信息 4.controller上校验信息的处理 一：jar包的导入 二：配置校验器validator &lt;!-- 校验器，配置validator --&gt; &lt;bean id="validator" class="org.springframework.validation.be...
springmvc学习
最新发布
04-23
如果您想学习Spring MVC，您可以先了解Java EE和Spring框架的基础知识，然后阅读有关Spring MVC的文档和教程，并构建自己的示例代码以加深理解。此外，您还可以使用Spring MVC的示例应用程序和框架提供的其他资源来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值