SpringMVC

最新推荐文章于 2025-03-19 21:14:48 发布
最新推荐文章于 2025-03-19 21:14:48 发布
阅读量1.2k 收藏 32
点赞数 15
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/st03zy/article/details/142561719
版权

一 SpringMVC概述

1.1 什么是设计模式

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。

设计模式使代码编写真正工程化；

设计模式是软件工程的基石脉络，如同大厦的结构一样。

设计模式就是一种模子，经过多年实践锤炼形成一套行之有效的完成某个特定任务的步骤和方式。

例如：飞天茅台的酿造过程，酿造工序，前后不能变，温差不能变，这样做就是好喝，稍微改动就变味道了。

1.2 MVC设计模式

MVC设计模式是一种通用的软件编程思想，MVC开始是存在于桌面程序中的，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。

在MVC设计模式中认为, 任何软件都可以分为三部分：

  1. 模型（Model）

    模型是应用程序的核心部分，负责管理数据和业务逻辑。它直接与数据库交互，检索数据并处理前端的命令。

  2. 视图（View）

    视图是用户界面的部分，负责将数据以图形界面的形式展示给用户。它仅仅展示数据，不包含业务逻辑处理。

  3. 控制器（Controller）

    控制器作为模型和视图之间的中介，处理用户的输入，将命令传递给模型，并选择视图来显示模型的数据。

MVC 属于[架构](模式的一种，所谓架构就是如何设计一个程序的结构。MVC 将程序结构划分为三层，每一层都对外提供了可供上层调用的接口，既能维系三层之间的联系，也能保持相对的独立性。

这种将业务逻辑、数据和界面分离的代码组织形式，降低了模块间的耦合度，有利于日后的维护与扩展。

在这里插入图片描述

1.3 SpringMVC

springmvc是基于spring Framwork衍生出来的一个mvc框架，主要解决原有mvc架构中，控制器（Controller）的问题，常见的控制器有servlet，struts2等，控制器的核心功能是根据用户的请求调用对应业务功能，然后依据业务处理的结果，控制程序的运行流程。

而servlet实现控制器存在的问题如下：

  1. 接收客户端请求参数时，存在代码的冗余

    String value = request.getParameter("name");

  2. 只能接收字符串类型的数据，其它数据类型需要手动的转换

    Integer num = Integer.parseInt(request.getParameter("number"));`

  3. 无法接收对象类型的参数

  4. 调用业务对象存在耦合 （new）

  5. 流程跳转存在耦合（路径耦合，视图耦合）

1.4 核心组件

Spring MVC 涉及到的组件有 DispatcherServlet（前端控制器）、HandlerMapping（映射处理器）、HandlerAdapter（处理适配器）、Handler（处理器）、ViewResolver（视图解析器）和 View（视图）。下面对各个组件的功能说明如下：

  • DispatcherServlet

DispatcherServlet 是前端控制器，从图 1 可以看出，Spring MVC 的所有请求都要经过 DispatcherServlet 来统一分发。DispatcherServlet 相当于一个转发器或中央处理器，控制整个流程的执行，对各个组件进行统一调度，以降低组件之间的耦合性，有利于组件之间的拓展。

  • HandlerMapping

HandlerMapping 是处理器映射器，其作用是根据请求的 URL 路径，通过注解或者 XML 配置，寻找匹配的处理器（Handler）信息。

  • HandlerAdapter

HandlerAdapter 是处理器适配器，其作用是根据映射器找到的处理器（Handler）信息，按照特定规则执行相关的处理器（Handler）。

  • Handler

Handler 是处理器，和 Java Servlet 扮演的角色一致。其作用是执行相关的请求处理逻辑，并返回相应的数据和视图信息，将其封装至 ModelAndView 对象中。

  • View Resolver

View Resolver 是视图解析器，其作用是进行解析操作，通过 ModelAndView 对象中的 View 信息将逻辑视图名解析成真正的视图 View（如通过一个 JSP 路径返回一个真正的 JSP 页面）

  • View

View 是视图，其本身是一个接口，实现类支持不同的 View 类型（JSP、FreeMarker、Excel 等）。

以上组件中，需要开发人员进行开发的是处理器（Handler，常称Controller）和视图（View）。通俗的说，要开发处理该请求的具体代码逻辑，以及最终展示给用户的界面

1.5 SpringMVC执行流程

Spring MVC 框架是高度可配置的，包含多种视图技术，例如 JSP、FreeMarke和 POI。Spring MVC 框架并不关心使用的视图技术，也不会强迫开发者只使用 JSP。

在这里插入图片描述

SpringMVC 的执行流程如下:

  1. 用户点击某个请求路径，发起一个 HTTP request 请求，该请求会被提交到 DispatcherServlet（前端控制器）；

  2. 由 DispatcherServlet 请求一个或多个 HandlerMapping（处理器映射器），并返回一个执行链（HandlerExecutionChain）。

  3. DispatcherServlet 将执行链返回的 Handler 信息发送给 HandlerAdapter（处理器适配器）；

  4. HandlerAdapter 根据 Handler 信息找到并执行相应的 Handler（常称为 Controller）；

  5. Handler 执行完毕后会返回给 HandlerAdapter 一个 ModelAndView 对象（Spring MVC的底层对象，包括 Model 数据模型和 View 视图信息）；

  6. HandlerAdapter 接收到 ModelAndView 对象后，将其返回给 DispatcherServlet ；

  7. DispatcherServlet 接收到 ModelAndView 对象后，会请求 ViewResolver（视图解析器）对视图进行解析；

  8. ViewResolver 根据 View 信息匹配到相应的视图结果，并返回给 DispatcherServlet；

  9. DispatcherServlet 接收到具体的 View 视图后，进行视图渲染，将 Model 中的模型数据填充到 View 视图中的 request 域，生成最终的 View（视图）；

  10. 视图负责将结果显示到浏览器（客户端）

在这里插入图片描述

二 SpringMVC入门案例

需求：

(1)通过浏览器访问 http://localhost:8088/项目名称/hello 地址，在控制台输出 “hello Springmvc”

(2)将请求转向（跳转到） /WEB-INF/pages/hello.jsp 页面

2.1 搭建步骤简述

  1. 创建maven的Module

  2. 在pom.xml中引入springmvc所需jar包

  3. 在web.xml中配置前端控制器

  4. 创建并配置springmvc-config.xml

  5. 创建并实现HelloController类

  6. 创建并实现hello.jsp

  7. 访问测试

2.2 具体实现

1）创建maven的Module， 命名为spring-mvc01， 同时添加web框架支持。

2）在pom.xml中引入springmvc所需jar包

<dependencies>
   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13</version>
      <scope>test</scope>
   </dependency>
   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.10.RELEASE</version>
   </dependency>
   <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
   </dependency>
</dependencies>

3）在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">
   <!-- 配置Springmvc前端控制器, 将所有请求交给Springmvc来处理 -->
   <servlet>
      <servlet-name>springmvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <!-- 配置Springmvc核心配置文件的位置，默认Springmvc的配置文件是在WEB-INF目录下，
          默认的名字为Springmvc-servlet.xml，如果要放在其他目录，则需要指定如下配置： -->
      <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:springmvc-config.xml</param-value>
      </init-param>
   </servlet>
   <!-- 其中的斜杠（/）表示拦截所有请求（除JSP以外）, 所有请求都要经过Springmvc前端控制器 -->
   <servlet-mapping>
      <servlet-name>springmvc</servlet-name>
      <url-pattern>/</url-pattern>
   </servlet-mapping>
</web-app>

4）创建并配置springmvc-config.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/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
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 1.配置前端控制器放行静态资源(html/css/js等，否则静态资源将无法访问) -->
    <mvc:default-servlet-handler/>

    <!-- 2.配置注解驱动，用于识别注解（比如@Controller）和json、xml自动转换等功能 -->
    <mvc:annotation-driven/>

    <!-- 3.配置需要扫描的包：Spring自动去扫描 base-package 下的类，
        如果扫描到的类上有 @Controller、@Service、@Component等注解，
        将会自动将类注册为bean
     -->
    <context:component-scan base-package="com.sldl.controller"/>

    <!-- 4.配置内部资源视图解析器
        prefix:配置路径前缀
        suffix:配置文件后缀
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

5）创建并实现HelloController类

package com.sldl.controller;

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

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String sayhello(){
        System.out.println("hello spring mvc");
        /* 跳转路径，默认使用转发，会经过视图解析器。  返回的字符串，就是jsp页面的名称 。 */
        return "hello";
    }
}

6）创建并实现hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
   <head>
      <title>Title</title>
   </head>
   <body>
      <h1>springmvc...hello.jsp....</h1>
   </body>
</html>

7）配置tomcat, 修改虚拟项目名称，项目构建=>put into output root

8）启动tomcat，浏览器访问

http://localhost:8088/spring_mvc01/hello

三 SpringMVC参数绑定

当项目中引入Springmvc框架后，所有的请求流转将由Springmvc进行控制，当客户端发送的请求中包含数据（也就是请求参数）时，那么该如何在controller层获取这些参数呢？

Springmvc会自动的将请求中包含的参数和方法的参数进行匹配，也就是说只要保证请求中的参数名称和方法中的参数名称相对应（另，参数的格式也要正确），在方法中就可以使用这些参数—即请求中的参数。

3.1 基本数据类型绑定

形参的名字和传递参数的名字保持一致，参数需要全部传递否则报500错误，为了解决不传参报错，可以给基本类型的参数设置默认值

1）添加方法

@RequestMapping("/login1")
    public String login1(int id,String name,double price,boolean flag){
        System.out.println(id);
        System.out.println(name);
        System.out.println(price);
        System.out.println(flag);
        return "hello";
    }

2）测试

http://localhost:8088/spring_mvc01/login1?id=10&name=张三&price=10.4&flag=true

3）测试结果

在这里插入图片描述

4）如果参数不全，会报500错误，需要使用@RequestParam(defaultValue = “xxx”)设置默认值。 如果传值了，则以传的值为最终值。

@RequestMapping("/login1")
public String login1(int id, String name, @RequestParam(defaultValue = "20") double price, boolean flag){
   System.out.println(id);
   System.out.println(name);
   System.out.println(price);
   System.out.println(flag);
   return "hello";
}

3.2 包装数据类型的传递

使用包装类型可以解决基本类型不传递值，出现500错误的问题但是还是要保持参数名字和形参保持一致，

1）添加方法

@RequestMapping("/login2")
public String login2(Integer id,String name,Double price,boolean flag){
   System.out.println(id);
   System.out.println(name);
   System.out.println(price);
   System.out.println(flag);
   return "hello";
}

2）测试

http://localhost:8088/spring_mvc01/login2?id=20&name=李四

3）测试结果

在这里插入图片描述

3.3 字符串类型绑定

1）添加方法

@RequestMapping("req3")
public String testRequest3(String name,String address){
   System.out.println(name);
   System.out.println(address);
   return "hello";
}

2）测试

http://localhost:8088/spring_mvc01/req3?name=zhangsan&address=长春

3）测试结果

在这里插入图片描述

3.4 数组类型绑定

1）添加方法

@RequestMapping("/login4")
public String login4(String[] names){
   for (String name : names) {
      System.out.println(name);
   }
   return "hello";
}

2）测试

http://localhost:8088/spring_mvc01/login4?names=王一&names=张二&names=李三&names=赵四

3）测试结果

在这里插入图片描述

3.5 javaBean类型

参数名的字段和Javabean中的属性保持一致即可。 底层调用的是javaBean的setter方法。

准备pojo类型

package com.sldl.pojo;

public class User {
    private int id;
    private String name;
    private String gender;
    private double balance;

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", balance=" + balance +
                '}';
    }
}

1）添加方法

@RequestMapping("/login5")
public String login5(User user){

   System.out.println(user);

   return "hello";
}

2）测试

http://localhost:8088/spring_mvc01/login5?id=1001&name=张三&gender=女&balance=200.3

3）测试结果

在这里插入图片描述

3.6 日期类型

Springmvc默认是以斜杠(yyyy/MM/dd)接收日期类型的参数, 因此如果日期参数不是yyyy/MM/dd 格式，就会出现400错误！

如果提交的日期就是以斜杠分隔的, Springmvc就可以接收这个日期类型的参数, 否则将无法接收。

如果提交的日期参数的格式是自定义的, 也可以修改Springmvc默认的接收格式，改为自定义的方式!!

1）添加方法

@RequestMapping("/login6")
public String login6(int id,Date date,String remark){
   System.out.println(id);
   System.out.println(date);
   System.out.println(remark);
   return "hello";
}

2）测试

http://localhost:8088/spring_mvc01/login6?id=1001&date=2024/06/12 12:20:30&remark=哈哈哈

备注： %20 其实就是空格，序列化之后就变成%20了。在url传递参数的时候，一般都会序列化一下，以保证参数的安全。

在这里插入图片描述

3）测试结果

在这里插入图片描述

4）自定义日期格式

在Springmvc中，提供了@InitBinder注解，用于指定自定义的日期转换格式，因此，我们只需要在Controller类中添加下面的代码即可，在接受日期类型的参数时，会自动按照自定义的日期格式进行转换。

只需要在类中添加如下方法

@InitBinder
public void InitBinder (ServletRequestDataBinder binder){
   binder.registerCustomEditor(java.util.Date.class,
                               new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), true)
                              );
}

5）测试

http://localhost:8088/spring_mvc01/login6?id=1001&date=2024-05-31%2012:20:30&remark=哈哈哈

6）测试结果

在这里插入图片描述

四 SpringMVC响应数据

4.1 ModelAndView方式

1）添加方法

@Controller
public class ResponseController {
    @RequestMapping("/resp1")
    public ModelAndView test1(){
        ModelAndView mav = new ModelAndView();
        mav.setViewName("hello");
        mav.addObject("scheme","ModelAndView");
        mav.addObject("content","日照香炉生紫烟");
        return mav;
    }
}

2）hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>springmvc响应数据</title>
</head>
<body>
    <br>
    模式：${scheme}  <br><br>
    内容: ${content}

</body>
</html>

3）测试

在这里插入图片描述

4.2 Model方式

Model对象实际上是一个Map集合，例如：往model中添加一个属性

model.addAttribute(String name, Object value);

其中，addAttribute方法会将属性保存到request域中，再通过转发将属性数据带到相应的JSP中，通过${}取出并显示。

1）添加方法

@RequestMapping("/resp2")
public String test2(Model model){
   model.addAttribute("scheme","Model");
   model.addAttribute("content","遥看瀑布挂前川");
   return "hello";
}

2）测试

在这里插入图片描述

4.3 ModelMap方式

1）添加方法

@RequestMapping("/resp3")
public String test3(ModelMap map){
   map.addAttribute("scheme","ModelMap");
   map.addAttribute("content","飞流直下三千尺 疑是银河落九天");
   return "hello";
}

2）测试结果

五 SpringMVC的跳转

5.1 转发

在前面request对象的学习中，通过request对象可以实现请求转发（即资源的跳转）。同样的，Springmvc也提供了请求转发的方式，具体实现如下
在这里插入图片描述

1）hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>springmvc跳转测试</title>
</head>
<body>
    <br>
    主题：${theme}  <br><br>
    内容：${content}
</body>
</html>

2）代码

@Controller
public class SkipController {

    @RequestMapping("f1")
    public String test1(Model model){
        model.addAttribute("theme","forward");
        model.addAttribute("content","时维九月,序嘱三秋");
        /* 字符串格式:  forward: xxxx
        *   forward:  转发关键字
        *      xxxx:  转发目的地的名称(页面)
        * */
        return "forward:hello";
    }
}

3）测试结果

在这里插入图片描述

4）简写方式

即SpringMVC的默认方式，就是转发

@RequestMapping("f2")
public String test2(Model model){
   model.addAttribute("theme","forward");
   model.addAttribute("content","潦水尽而寒潭清，烟光凝而暮山紫");
   /* 简写方式： 直接书写页面的名字。 */
   return "hello";
}

5）测试结果

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

6）总结

forward方式相当于:

request.getRequestDispatcher("url").forward(request,response);

转发是一次请求，一次响应；

转发后地址栏地址没有发生变化（还是访问testForward的地址）；

转发前后的request和response对象也是同一个。

5.2 重定向

在前面response对象的学习中，通过response对象可以实现请求重定向（即资源的跳转）。同样的，SpringMVC也提供了请求重定向的方式，具体实现如下：

1）添加方法

@RequestMapping("re1")
public String test3(){
   /**
    * 重定向的格式：  "redirect:xxxx"
    * redirect:  重定向的关键字
    *     xxxx:  重定向的新地址。 也就是浏览器收到这个新地址，然后向该地址再次发送请求
    *            因此：浏览器的地址会发生变化
   *
    * 该案例： 浏览器的最初访问地址：http://localhost:8088/项目名/re1
    *         改变后的地址：       http://localhost:8088/项目名/f1
    *
    * 逻辑如下：
    *       1. 浏览器最初发送了re1请求，
    *       2. 然后走到该方法test3
    *       3. 遇到返回值里的关键字redirect和新地址f1
    *       4. 服务器会将新地址f1以及302状态码发送回浏览器
    *       5. 浏览器收到信息后，会向新地址f1再次发送请求
    * */
   return "redirect:f1";
}

2）测试

http://localhost:8088/spring_mvc01/re1

3）测试结果

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4）总结

redirect方式相当于：

response.sendRedirect("url");

重定向是两次或多次请求，两次或多次响应；

重定向后地址栏地址发生了变化(变为转发后的地址)；

并且在重定向前后，request和response对象不是同一个。

六 SpringMVC处理JSON

6.1 数据准备

1）引入js文件

在web的根目录下创建目录statics，在目录statics下创建子目录js。将jquery-1.8.3.min.js文件放进去

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2）创建regist.jsp文件

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3）pojo类型
package com.sldl.pojo;

public class Student {
   private String username;
   private String password;
   private int age;
   private String gender;

   public Student() {
   }

   public Student(String username, String password, int age, String gender) {
      this.username = username;
      this.password = password;
      this.age = age;
      this.gender = gender;
   }

   public String getUsername() {
      return username;
   }

   public void setUsername(String username) {
      this.username = username;
   }

   public String getPassword() {
      return password;
   }

   public void setPassword(String password) {
      this.password = password;
   }

   public int getAge() {
      return age;
   }

   public void setAge(int age) {
      this.age = age;
   }

   public String getGender() {
      return gender;
   }

   public void setGender(String gender) {
      this.gender = gender;
   }

   @Override
   public String toString() {
      return "User{" +
         "username='" + username + '\'' +
         ", password='" + password + '\'' +
         ", age=" + age +
         ", gender='" + gender + '\'' +
         '}';
   }
}

6.2 JSON响应数据

6.2.1 @ResponseBody注解的应用

  • @ResponseBody的作用其实是将java对象转为json格式的数据。

  • @responseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。一般用于AJAX

  • 注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

  • 注意：在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。

6.2.2 方案1-JSON字符串

1）编写html代码

<h2>
   <button onclick="getJson1()">服务端返回json--方案1</button>
   <button onclick="getJson2()">服务端返回json--方案2</button>
</h2>

2）编写后端代码

@Controller
public class LoginController {
   
   @RequestMapping("toRegist")
   public String toRegistPage(){
      return "regist";
   }
   
   @RequestMapping("getJson1")
   @ResponseBody
   public Object testJson1(){
      return "{\"username\":\"张三\",\"age\":21}";
   }
}

3）编写Ajax代码

function getJson1(){
   $.ajax({
      url:"getJson1",
      type:"post",
      dataType:"json",
      success:function (data){
         console.log(data);
         console.log(data.username);
         console.log(data.age)
      },
      error:function (){
         alert("系统错误")
      },
      async:true
   })
}

4）解决乱码情况

//解决乱码情况
@RequestMapping(value = "getJson1",produces ="application/json;charset=utf-8" )

6.2.3 方案2-JavaBean写法

1）后端代码编写

@RequestMapping("getJson2")
@ResponseBody
public User testJson2(){
   User user = new User("xiaoming","123123",23,"女");
   /** 如果想要将student对象转成json对象返回给浏览器，需要在方法上
         *  添加@ResponseBody注解
         *
         *  如果想要序列化到浏览器，需要添加另外一个依赖jackson-databind,否则报如下错误
         *  No converter found for return value of type
         *  */
   return user;
}

2）编写Ajax代码

function getJson2(){
   $.ajax({
      url:"getJson2",
      type:"post",
      dataType:"json",
      success:function (data){
         console.log(data);
         console.log(data.username);
         console.log(data.password);
         console.log(data.age);
         console.log(data.gender);
      },
      error:function (){
         alert("系统错误")
      },
      async:true
   })
}

6.3 JSON请求数据

1）编写regist.jsp代码

<br>
<h2>
   <button οnclick="getJson1()">服务端返回json--方案1</button>
   <button οnclick="getJson2()">服务端返回json--方案2</button>
</h2>

<h2>注册页面</h2>

<form>
   用户: <input type="text" 		id="username" 	name="username" 	placeholder="请输入用户名">  <br>
   密码: <input type="password" id="pwd"  		name="pwd" 			placeholder="请输入密码">  <br>
   年龄: <input type="text" 		id="age"  		name="age" 			placeholder="请输入年龄">  <br>
   性别: <input type="text" 		id="gender"  	name="gender" 		placeholder="请输入性别">  <br>
   <input type="button" value="注册" οnclick="regist()">
</form>

2）编写ajax代码

function regist(){
   var u1 = $("#username").val();
   var p1 = $("#pwd").val();
   var a1 = parseInt($("#age").val());
   var g1 = $("#gender").val();
   //组织json对象
   var jsonData = {"username":u1,"pwd":p1,"age":a1,"gender":g1}
   console.log(jsonData)
   $.ajax({
      url:"regist",
      data:jsonData,
      type:"post",
      dataType:"text",
      success:function (data){
         alert(data);
      },
      error:function (){
         alert("系统错误")
      },
      async:true
   })
}

3）编写后端代码

@RequestMapping("regist")
@ResponseBody
public String regist(String username,String pwd,int age, String gender){
   System.out.println(username);
   System.out.println(pwd);
   System.out.println(age);
   System.out.println(gender);
   return "hello";
}

4）后端代码的另外一种写法

@RequestMapping("regist")
@ResponseBody
public String regist(User user){
   System.out.println(user);
   return "hello";
}

七 SSM框架整合

7.1 简述

SSM框架，即是将SpringMVC框架、Spring框架、MyBatis框架三个框架，整合到一起使用，用于构建企业级的Web应用程序。这样可以大大的简化在web开发中繁琐、重复的操作，让开发人员的精力专注于业务处理的开发上。

  • spring框架和mybatis框架整合到一起

    • spring容器来管理dataSource，SqlSessionFactory等

  • spring框架与springmvc框架整合到一起。

    • SpringMVC容器：主要对Controller控制器对象，视图等用户请求和请求结果进行管理。

    • Spring容器：主要对Service、Dao、工具类等对象进行管理。

    • 两个容器的关系：SpringMVC容器为Spring容器的子容器，进而两容器中的对象进行间接管理。

那么如何整合到一起呢，需要做哪些工作？其实只需要整合以下四个配置文件即可。

  1. mybatis的主配置文件
  2. spring的配置文件
  3. springMVC的配置文件
  4. web.xml

7.2 SSM整合项目演示

7.2.1 创建项目/模块，引入坐标

1）创建模块，命名spring-ssm01。

2）添加web应用支持

3）引入坐标依赖

<!--junit的依赖jar包-->
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.13</version>
   <scope>test</scope>
</dependency>
<!-- servlet依赖 -->
<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>javax.servlet-api</artifactId>
   <version>3.1.0</version>
   <scope>provided</scope>
</dependency>
<!-- jsp依赖 -->
<dependency>
   <groupId>javax.servlet.jsp</groupId>
   <artifactId>jsp-api</artifactId>
   <version>2.2.1-b03</version>
   <scope>provided</scope>
</dependency>
<!-- jstl -->
<dependency>
   <groupId>jstl</groupId>
   <artifactId>jstl</artifactId>
   <version>1.2</version>
</dependency>
<!-- jackson依赖 -->
<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.11.0</version>
</dependency>

<!-- springmvc依赖 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.2.5.RELEASE</version>
</dependency>
<!--mybatis的依赖jar包-->
<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.5</version>
</dependency>
<!--mysql的依赖jar包-->
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>8.0.31</version>
</dependency>
<!-- druid连接池依赖 -->
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.1.12</version>
</dependency>
<!-- spring事务依赖 -->
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-tx</artifactId>
   <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>5.2.5.RELEASE</version>
</dependency>

<!-- 参考版本对应 http://www.mybatis.org/spring/ -->
<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.3</version>
</dependency>

<!-- commons 文件上传jar -->
<dependency>
   <groupId>commons-io</groupId>
   <artifactId>commons-io</artifactId>
   <version>1.4</version>
</dependency>
<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.3.1</version>
</dependency>

7.2.2 编写配置文件

1）SSM的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">

    <!--解决SpringMVC的中文乱码问题的过滤器-->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--配置SpringMVC的前端控制器-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--初始化SSM的主配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:beans.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>
2）mybatis的核心配置文件mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

</configuration>
3) 数据源的配置文件jdbc.properties
driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai&useTimezone=true
user=root
password=123456
4) spring的核心配置文件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:context="http://www.springframework.org/schema/context"
       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">

    <!--开启注解扫描，比如扫描Dao,Service-->
    <context:component-scan base-package="com.sldl"/>

    <!--配置加载jdbc.properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置druid的连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClassName}"></property>
        <property name="url" value="${url}"/>
        <property name="username" value="${user}"/>
        <property name="password" value="${password}"/>
    </bean>

    <!--配置SqlSessionFactory的bean-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--绑定数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!--加载mybatis的核心配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"></property>
        <!--配置加载各个pojo对应的XXXXMapper.xml-->
        <property name="mapperLocations"  value="classpath:com/sldl/mapper/*.xml"/>
    </bean>

    <!--配置可以扫描mapper/dao接口的类型-->
    <bean  class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
        <property name="basePackage" value="com.sldl.dao"></property>
    </bean>
    
</beans>
5) SpringMVC的核心配置文件SpringMVC.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--开启SpringMVC的注解，主要是Controller注解-->
    <mvc:annotation-driven/>

    <!--静态资源的访问通过配置-->
    <mvc:default-servlet-handler/>

    <!--视图解析器的配置-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages"/>
        <property name="suffix" value=".jsp" />
    </bean>
</beans>
6) ssm的主配置文件beans.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">

    <!--整合两个配置文件-->
    <import resource="classpath:applicationContext.xml"/>
    <import resource="classpath:SpringMVC.xml"/>
</beans>

7.2.3 构建一下包结构

在蓝色的java里构建package

com.sldl.dao
com.sldl.service
com.sldl.service.impl
com.sldl.controller
com.sldl.pojo

在resources里构建Directory

com/sldl/mapper

7.2.4 准备数据源(资费表)

-- 创建库
create database if not exists ssm_db;
-- 切换库
use ssm_db;
drop table cost;
create table cost(
  cost_id 			int(4) primary key auto_increment comment "资费ID,唯一标识符",     
  name 				varchar(50)  not null comment "资费名称",
  base_duration 	int(11) comment "资费基本时长",
  base_cost 		double(7,2) comment "资费花销",
  unit_cost 		double(7,4) comment "资费的单位花销",
  status 			char(1) comment "资费状态 0表示关闭，1表示启用",
  descr 			varchar(100) comment "资费的具体信息",
  creatime 			datetime comment "资费的创建时间",
  startime 			datetime comment "资费的启用时间",
  cost_type    	char(1) not null comment "资费类型"
  );
delete from cost;
insert into cost values (null,'5.9元套餐',20,5.9,0.4,1,'5.9元20小时/月,超出部分0.4元/时',now(),null,'1');
insert into cost values (null,'6.9元套餐',40,6.9,0.3,1,'6.9元40小时/月,超出部分0.3元/时',now(),null,'2');
insert into cost values (null,'8.5元套餐',100,8.5,0.2,1,'8.5元100小时/月,超出部分0.2元/时',now(),null,'3');
insert into cost values (null,'10.5元套餐',200,10.5,0.1,1,'10.5元200小时/月,超出部分0.1元/时',now(),null,'3');
insert into cost values (null,'计时收费',null,null,0.5,1,'0.5元/时,不使用不收费',now(),null,'1');
insert into cost values (null,'包月',null,20,null,1,'每月20元,不限制使用时间',now(),null,'2');

INSERT INTO cost VALUES (null,'18元套餐',20,5.9,0.4,0,'18元40小时/月,超出部分0.4元/时',now(),now(),'1');
INSERT INTO cost VALUES (null,'28元套餐',40,6.9,0.3,0,'28元60小时/月,超出部分0.3元/时',now(),now(),'1');
INSERT INTO cost VALUES (null,'38元套餐',100,8.5,0.2,0,'38元100小时/月,超出部分0.2元/时',now(),now(),'1');
INSERT INTO cost VALUES (null,'58元套餐',200,10.5,0.1,0,'58元200小时/月,超出部分0.1元/时',now(),now(),'1');
INSERT INTO cost VALUES (null,'88元套餐',400,10.5,0.1,0,'88元400小时/月,超出部分0.1元/时',now(),now(),'1');
INSERT INTO cost VALUES (null,'包月2',null,200,null,0,'每月200元,不限制使用时间',now(),now(),'2');
commit;

select * from cost;

7.2.5 创建资费的pojo类型

7.2.6 创建Cost的Dao接口

7.2.7 配置Cost的Mapper.xml

7.2.8 编写Cost的Service接口

7.2.9 编写Cost的Service实现类型

e char(1) not null comment “资费类型”
);
delete from cost;
insert into cost values (null,‘5.9元套餐’,20,5.9,0.4,1,‘5.9元20小时/月,超出部分0.4元/时’,now(),null,‘1’);
insert into cost values (null,‘6.9元套餐’,40,6.9,0.3,1,‘6.9元40小时/月,超出部分0.3元/时’,now(),null,‘2’);
insert into cost values (null,‘8.5元套餐’,100,8.5,0.2,1,‘8.5元100小时/月,超出部分0.2元/时’,now(),null,‘3’);
insert into cost values (null,‘10.5元套餐’,200,10.5,0.1,1,‘10.5元200小时/月,超出部分0.1元/时’,now(),null,‘3’);
insert into cost values (null,‘计时收费’,null,null,0.5,1,‘0.5元/时,不使用不收费’,now(),null,‘1’);
insert into cost values (null,‘包月’,null,20,null,1,‘每月20元,不限制使用时间’,now(),null,‘2’);

INSERT INTO cost VALUES (null,‘18元套餐’,20,5.9,0.4,0,‘18元40小时/月,超出部分0.4元/时’,now(),now(),‘1’);
INSERT INTO cost VALUES (null,‘28元套餐’,40,6.9,0.3,0,‘28元60小时/月,超出部分0.3元/时’,now(),now(),‘1’);
INSERT INTO cost VALUES (null,‘38元套餐’,100,8.5,0.2,0,‘38元100小时/月,超出部分0.2元/时’,now(),now(),‘1’);
INSERT INTO cost VALUES (null,‘58元套餐’,200,10.5,0.1,0,‘58元200小时/月,超出部分0.1元/时’,now(),now(),‘1’);
INSERT INTO cost VALUES (null,‘88元套餐’,400,10.5,0.1,0,‘88元400小时/月,超出部分0.1元/时’,now(),now(),‘1’);
INSERT INTO cost VALUES (null,‘包月2’,null,200,null,0,‘每月200元,不限制使用时间’,now(),now(),‘2’);
commit;

select * from cost;


### 7.2.5 创建资费的pojo类型

### 7.2.6  创建Cost的Dao接口

### 7.2.7 配置Cost的Mapper.xml

7.2.8 编写Cost的Service接口

7.2.9 编写Cost的Service实现类型

7.2.10编写Cost的Controller
spring的自定义MVC
qq_65975514的博客
04-04 377
1. 什么是springMVC? Spring Web MVC是一种基于Java的实现了MVC设计模式的、请求驱动类型的、轻量级Web框架。 2. SpringMVC处理请求的流程图 2.1 工作原理： 1. 首先用户发送请求-->DispatherServlet 2. DispatcherServlet-->HandlerMapping 3. DispatcherServlet-->HandlerAdapter 4. HandlerAdap...
springMvc
08-02
使用了spring，springMvc，mybatis框架开发的一个小案例
Spring MVC学习
weixin_30800807的博客
09-05 132
SpringMVC框架 转载请注明出处 目录 一：配置springMVC开发环境 1.1.配置文件的helloworld 1.2.基于注解的helloworld 二：@RequestMapping详解 2.1.类的@RequestMapping注解 2.2.请求方式的设置 2.3.参数的规定与请求头的规定设置 2.4.@Req...
springmvc 框架学习
最新发布
一弓虽的博客
03-19 1122
介绍 spring 框架之一 springmvc 的概述及如何使用
Spring MVC 学习笔记（整理）
weixin_30393907的博客
10-30 195
SpringMVC学习 1、概述 Spring MVC是一种基于Java实现MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行解耦，基于请求-响应模型帮助我们简化日常web系统的开发。 Spring MVC框架就是一种MVC框架。其前端控制器是DispatcherServlet主要用于控制流程；应用控制器为Handler Map...
SpringMvc
stone的博客
02-04 800
SpringMvc的概述 SpringMvc是一套完整的MVC框架 SpringMvc有一套全面的MVC注解 SpringMvc支持REST风格的URL请求 SpringMvc采用了松散耦合可插拔组件结构,比其他MVC框架更具扩展性和灵活性(基于组件开发) SpringMvc的执行流程 SpringMvc案例 项目架构 maven依赖 <properties> ...
SpringMVC基础1
weixin_61551023的博客
08-13 714
SpringMVC基础知识
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
SpringMVC demo 完整源码实例下载
05-02
SpringMVC是一款强大的Java web开发框架，用于构建高效、可维护的Web应用程序。在这个"SpringMVC demo 完整源码实例下载"中，我们能够深入理解并学习SpringMVC的核心概念和实际应用。 首先，SpringMVC是Spring框架...
SpringMVC精品资源--SpringMVC+Mybatis 脚手架.zip
02-18
SpringMVC和Mybatis是Java开发中非常流行的两个框架，它们在企业级Web应用开发中起着关键作用。SpringMVC作为Spring框架的一部分，主要负责处理HTTP请求和响应，而Mybatis则是一个轻量级的持久层框架，专注于数据库...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
SpringMVC简介
qq_41555278的博客
07-08 663
一、SpringMVC简介MVC是我们开发WEB应用程序的通用架构方式MVC的核心思想是业务数据抽取和业务数据呈现相分离。MVC：M（Model）+V（View）+C（Controller）M（模型层）：业务数据的信息表示，通常是业务实体V（视图层）：为用户呈现数据的页面C（控制层）：调用业务逻辑产生合适的数据（Model），同时传递数据（Model）给视图层（View）呈现给用户MVC：是一种架...
springmvc
lwj_07的博客
07-23 270
也就是说springmvc容器（springmvcConfig）等同于servlet，是专门做表现层方面的业务的，因此我们希望springmvcConfig中@ComponentScan("com.itheima.controller")注解加载到表现层包下的含有注解bean的对象当中，这样我们就可以访问获取该对象的资源了。注意是不希望加载到表现层controller包下的对象，不是config包下的对象。第三步初始化springmvc环境，设定springmvc加载对应的bean。......
【Spring】Spring MVC原理及配置详解
热门推荐
简约人生的博客
04-27 37万+
【Spring】Spring MVC原理及配置1.Spring MVC概述：Spring MVC是Spring提供的一个强大而灵活的web框架。借助于注解，Spring MVC提供了几乎是POJO的开发模式，使得控制器的开发和测试更加简单。这些控制器一般不直接处理请求，而是将其委托给Spring上下文中的其他bean，通过Spring的依赖注入功能，这些bean被注入到控制器中。Spring MVC
SpringMVC演示项目详解
SpringMVC Demo知识点解析： 1. SpringMVC框架概念： SpringMVC是Spring Framework的一部分，是一种基于Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，通过分离控制器、模型对象、视图解析，以及处理用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值