当前位置： 首页 > article >正文

Spring MVC ONE

article 2025/2/6 20:14:05

第一章：Java web的发展历史

一.Model I和Model II

1.Model I开发模式

Model1的开发模式是：JSP+JavaBean的模式，它的核心是Jsp页面，在这个页面中，Jsp页面负责整合页面和JavaBean（业务逻辑），而且渲染页面，它的基本流程如下：

这样的设计模式到这一个jsp页面负责了视图的展示和业务流程的控制高度耦合的结果是Jsp代码十分复杂，后期维护困难！

2.Model II开发模式

在Model II的模式下。利用jsp页面、servlet和JavaBean组件分工协作共同完成系统的所有任务。其中jsp负责数据显示逻辑任务，servlet负责程序的流程控制任务，JavaBean负责处理业务逻辑任务。它的基本流程如下：

Model2：相对于Model1来说，职责分工更为明确，在Model1的基础上，抽取了Servlet层，体现了一个分层的思想，适合大型的项目开发！（当时的评判标准是适合大型项目开发的，现在看起来已经过时了！）

二. MVC模式

Spring mvc是基于Spring的一个模块，专门做web开发，可以理解为是Servlet的升级

在Spring MVC框架当中，Controller替代Servlet担负控制器的职能，

M：指model:模型层，指工程当中的Java Bean,作用是处理数据

Java Bean分两类：

  • 一类是实体类Bean:专门存储业务数据的
  • 一类为业务处理Bean:指Servlet或Dao对象，专门处理业务逻辑和数据

V:View,视图层指项目当中的html或jsp等页面，作用是与用户进程交互，展示数据

C:Contoller,控制层，指工程当中的servlet,作用是接受请求和响应数据

MAC思想不是那个语言所特有的设计模式，也不是web应用所特有的思想，而是一种规范。MVC思想将一个应用分成三个基本部分：Model(模型)、View(视图)和Controller(控制器)，这三个部分以最少的耦合协同工作，从而提高了应用的可扩展性和可维护性。他们三者的关系如下图所示

第二章：SpringMVC的入门案例

一. SpringMVC的入门程序

1、搭建spring MVC

①：创建WEB工程，引入开发的jar包

②：具体的坐标如下
<!--版本锁定-->
<properties>
    <spring.version>5.0.2.RELEASE</spring.version>
</properties>

<dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--SpringMVC-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--servlet API-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>

    <!--日志-->
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>

</dependencies>
③：添加web模块

④：配置DispatcheServlet

Spring MVC是基于原生的servlet,通过强大的前端控制器DispatcheServlet，对请求和响应进行统一处理。

Spring MVC的本质就是一个servlet,是对原生的servlet进行了封装。在以前我们浏览器的每一次请求都需要我们写一个对应的servlet,现在我们只需要将浏览器的请求和响应交给DispatcheServlet进行统一的处理。

在web.xml配置文件中核心控制器DispatcherServlet
<!‐‐配置前端控制器，对浏览器发送的请求进行统一处理‐‐>
<servlet>
    <servlet‐name>dispatcherServlet</servlet‐name>
    <servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
    <!‐‐加载springmvc.xml配置文件的位置和名称，配置的是Spring配置‐‐>
    <init‐param>
    	<!--contextConfigLocation:上下文配置路径，固定值-->
    	<param‐name>contextConfigLocation</param‐name>
     	<!--classpath:类路径，值得是Java和resources文件夹-->
      	<!--springmvc.xml:指的是配置文件的名称：需要配置springmvc.xml，在下面-->
    	<param‐value>classpath:springmvc.xml</param‐value>
    </init‐param>
    <!‐‐配置启动加载‐‐>
    <load‐on‐startup>1</load‐on‐startup>
</servlet>
<servlet‐mapping>
    <servlet‐name>dispatcherServlet</servlet‐name>
    <url‐pattern>*.do</url‐pattern>
</servlet‐mapping>

⑥：配置springmvc.xml

----------------------------------

编写index.html页面

<html>
<head>
<meta charset="utf-8">
<title>入门程序</title>
</head>
<body>
<h3>入门</h3><a href="/hello.do" >入门程序</a>
</body>
</html>

编写suc.html页面 INF/pages/suc.jsp

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>成功</title>
</head>
<body>
<h3>入门成功了2...</h3>
</body>
</html>

编写Controller类和方法

package cn.tx.demo1;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

// 把当前类交给IOC容器进行管理
@Controller
public class HelloController {
/**
* 处理超链接发送出来的请求
* @return
*/
// 配置映射的配置
@RequestMapping(path = "/hello.do")
        public String sayHello(){
        System.out.println("入门方法执行了2...");
        // 跳转的JSP页面的路径，默认使用的是请求的转发
        // return "/WEB‐INF/pages/suc.jsp";
        // 配置了视图解析器后，写法
        return "suc";
    }
}

编写springmvc.xml的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!‐‐ 配置spring创建容器时要扫描的包 ‐‐>
<context:component‐scan base‐package="cn.tx"></context:component‐scan>
<!‐‐ 配置视图解析器 ‐‐>
<!-- 定义跳转的文件的前后缀 ，视图模式配置-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 这里的配置我的理解是自动给后面action的方法return的字符串加上前缀和后缀，变成一个 可用的url地址 -->
    <property name="prefix" value="/html/" />
    <property name="suffix" value=".html" />
</bean>
<!-- 配置spring开启注解mvc的支持  默认就是开启的 ，要想让其他组件（不包含映射器、适配器、处理器）生效就必须需要配置了-->
<mvc:annotation-driven></mvc:annotation-driven>
</beans>

启动Tomcat服务器，进行测试

3. 入门案例的执行过程分析

入门案例的执行流程

  • 1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件
  • 2. 开启了注解扫描，那么HelloController对象就会被创建
  • 3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到执行的具体方法
  • 4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件
  • 5. Tomcat服务器渲染页面，做出响应

SpringMVC官方提供图形

入门案例中的组件分析

  • 1. 前端控制器（DispatcherServlet）
  • 2. 处理器映射器（HandlerMapping）
  • 3. 处理器（Handler）
  • 4. 处理器适配器（HandlAdapter）
  • 5. 视图解析器（View Resolver）
  • 6. 视图（View）

4. RequestMapping注解

RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系

RequestMapping注解可以作用在方法和类上

  • 1. 作用在类上：第一级的访问目录
  • 2. 作用在方法上：第二级的访问目录
  • 3. 细节：路径可以不编写 / 表示应用的根目录开始

RequestMapping的属性

  • 1. path 指定请求路径的url
  • 2. value value属性和path属性是一样的
  • 3. mthod 指定该方法的请求方式
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
@RequestMapping(path = "/role") // 一级请求路径
public class RoleController {
    /**
     * /role/save.do
     * method="当前方法允许请求方式能访问"
     * params="请求路径上传参数"
     * @return
     */
    @RequestMapping(path = "/save.do",method = {RequestMethod.GET})
    public String save(){
        System.out.println("保存角色...");
        return "suc";
    }
    @RequestMapping(value = "/delete.do")
    public String delete(){
        System.out.println("删除角色...");
        return "suc";
    }
}

第三章：请求参数的绑定

请求参数的绑定说明

1. 绑定机制

  • 1. 表单提交的数据都是k=v格式的 username=haha&password=123
  • 2. SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
  • 3. 要求：提交表单的name和参数的名称是相同的

2. 支持的数据类型

  • 1. 基本数据类型和字符串类型
  • 2. 实体类型（JavaBean）
  • 3. 集合数据类型（List、map集合等）

基本数据类型和字符串类型

  • 1. 提交表单的name和参数的名称是相同的
  • 2. 区分大小写

实体类型（JavaBean）

  • 1. 提交表单的name和JavaBean中的属性名称需要一致
  • 2. 如果一个JavaBean类中包含其他的引用类型，那么表单的name属性需要编写成：对象.属性 例如：address.name

给集合属性数据封装

  • 1. JSP页面编写方式：list[0].属性

jsp代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>请求参数绑定入门程序</h1>
    <form action="/user/save.do" method="get">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（封装到实体类）</h1>
    <form action="/user/save1.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（封装到实体类）</h1>
    <form action="/user/save2.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="text" name="account.money"/><br/>
        <input type="submit"/>
    </form>
    <h1>请求参数绑定入门程序（存在list集合）</h1>
    <form action="/user/save3.do" method="post">
        <input type="text" name="username"/><br/>
        <input type="text" name="age"/><br/>
        <input type="text" name="account.money"/><br/>
        <input type="text" name="accounts[0].money"/><br/>
        <input type="text" name="accounts[1].money"/><br/>
        <input type="submit"/>
    </form>
</body>
</html>

Javabean代码

package com.qcby.entity;

import java.io.Serializable;
import java.util.List;

public class User implements Serializable {
    private String username;
    private Integer age;
    private Account account;
    private List<Account> accounts;

    public String getUsername() {
        return username;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", account=" + account +
                ", accounts=" + accounts +
                '}';
    }
}
package com.qcby.entity;

import java.io.Serializable;

public class Account implements Serializable {
    private Double money;

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "money=" + money +
                '}';
    }
}

controller代码

package com.qcby.web;

import com.qcby.entity.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/save.do")
    public String save(String username,Integer age){
        System.out.println(username);
        System.out.println(age);
        return "suc";
    }

    @RequestMapping("/save1.do")
    public String save1(User user){
        System.out.println(user);
        return "suc";
    }

    @RequestMapping("/save2.do")
    public String save2(User user){
        System.out.println(user);
        return "suc";
    }

    @RequestMapping("/save3.do")
    public String save3(User user){
        System.out.println(user);
        return "suc";
    }
}

post请求中参数中文乱码的解决

在web.xml中配置Spring提供的过滤器类

<!‐‐ 配置过滤器，解决中文乱码的问题 ‐‐>
<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>

=================================================================================================================================================================

在控制器中使用原生的ServletAPI对象

1. 只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

@RequestMapping("/save6.do")
public String save6(HttpServletRequest request, HttpServletResponse response){
    System.out.println(request);
    // 获取到HttpSession对象
    HttpSession session = request.getSession();
    System.out.println(session);
    System.out.println(response);
    return "suc";
}

第四章：常用的注解

1. RequestParam注解

1. 作用：把请求中的指定名称的参数传递给控制器中的形参赋值

2. 属性：

  • 1. value：请求参数中的名称
  • 2. required：请求参数中是否必须提供此参数，默认值是true，必须提供

3. 代码如下

package com.qcby.web;

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

@Controller
@RequestMapping("/dept")
public class DeptController {
    @RequestMapping("/save")
    public String save(@RequestParam(value = "username",required = false) String name){
        System.out.println(name);
        return "suc";
    }
}

http://localhost:8080/SpringMVCDemo/dept/save.do?username=张三

2. PathVaribale注解

1. 作用：拥有绑定url中的占位符的。例如：url中有/delete/{id}，{id}就是占位符

2. 属性

  • 1. value：指定url中的占位符名称

3. Restful风格的URL

  • 1. 请求路径一样，可以根据不同的请求方式去执行后台的不同方法
  • 2. restful风格的URL优点：1. 结构清晰 2. 符合标准 3. 易于理解 4. 扩展方便

4. 代码如下

package com.qcby.demo3;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

@Controller
// @RequestMapping("/emp")
public class EmpController {
    /**
    * 保存
    * @return
    */
    @RequestMapping(path = "/emp",method = RequestMethod.POST)
    public String save(){
        System.out.println("保存员工...");
        return "suc";
    }/**
    * 查询所有
    * @return
    */
    @RequestMapping(path = "/emp",method = RequestMethod.GET)
    public String findAll(){
        System.out.println("查询员工...");
        return "suc";
    }
    /**
    * 查询所有
    * @return
    */
    @RequestMapping(path = "/emp/{id}",method = RequestMethod.GET)
    public String findById(@PathVariable(value = "id") Integer id){
        System.out.println("通过id查询员工..."+id);
        return "suc";
    }
}

5. 修改前端控制器的配置文件

<!‐‐配置前端控制器‐‐>
<servlet>
<servlet‐name>dispatcherServlet</servlet‐name>
<servlet‐class>org.springframework.web.servlet.DispatcherServlet</servlet‐class>
<!‐‐加载springmvc.xml配置文件，配置的是Spring配置‐‐>
<init‐param>
<param‐name>contextConfigLocation</param‐name>
<param‐value>classpath:springmvc.xml</param‐value>
</init‐param>
<!‐‐配置启动加载‐‐>
<load‐on‐startup>1</load‐on‐startup>
</servlet>
<!‐‐
<servlet‐mapping>
<servlet‐name>dispatcherServlet</servlet‐name>
<url‐pattern>*.do</url‐pattern>
</servlet‐mapping>
‐‐>
<servlet‐mapping>
<servlet‐name>dispatcherServlet</servlet‐name>
<url‐pattern>/</url‐pattern>
</servlet‐mapping>

3. RequestHeader注解

1. 作用：获取指定请求头的值

2. 属性

  • 1. value：请求头的名称

3. 代码如下

/**
* RequestHeader 获取请求头的值
* @return
*/
@RequestMapping("/save3.do")
public String save3(@RequestHeader(value = "Accept") String header){
    System.out.println("Accept请求头的值："+header);
    return "suc";
}

4. CookieValue注解

1. 作用：用于获取指定cookie的名称的值

2. 属性

  • 1. value：cookie的名称

3. 代码

/**
* CookieValue 获取到cookie中的值
* @return
*/
@RequestMapping("/save4.do")
public String save4(@CookieValue(value = "JSESSIONID") String cookie){
    System.out.println("值："+cookie);
    return "suc";
}

http://www.kler.cn/a/534128.html

相关文章：

  • 【分布式架构理论3】分布式调用（2）：API 网关分析
  • TCP | RFC793
  • Linux 的 sysfs 伪文件系统介绍【用户可以通过文件操作与内核交互(如调用内核函数),而无需编写内核代码】
  • ubuntu 网络管理--wpa_supplicant、udhcpc
  • (脚本学习)BUU18 [CISCN2019 华北赛区 Day2 Web1]Hack World1
  • 25.02.04 《CLR via C#》 笔记14
  • WordPress自动SEO文章生成器——一款基于AI技术的智能插件，能够自动生成高质量、SEO优化的文章，并提供强大的内容采集与优化功能。
  • zyNo.20
  • Got socket exception during request. It might be caused by SSL misconfiguration
  • 哪些专业跟FPGA有关？
  • 基于SpringBoot的体检预约管理系统
  • 5.【BUUCTF】[BJDCTF2020]Easy MD5及知识点
  • PyQt4学习笔记4】窗口布局 和 QSplitter
  • JAVAweb学习日记（九） MySQL-事务索引
  • 低代码提升交付效率的公式计算
  • 响应式编程_05 Project Reactor 框架
  • 永久免费语音服务！微软 Azure 注册实操，零成本实现TTS自由
  • Page Assist实现deepseek离线部署的在线搜索功能
  • Mac 基于Ollama 本地部署DeepSeek离线模型
  • MyBatis Plus 输出完整 SQL（带参数）的 3 种方案
  • Boosting 框架
  • 硬件工程师思考笔记02-器件的隐秘角落：磁珠与电阻噪声
  • 堆的实现——堆的应用（堆排序）
  • CTFSHOW-WEB入门-PHP特性89-100
  • 基于SpringBoot+MySQL的图书借阅管理系统源代码+数据库
  • 稳定Android Studio2021.1.2.16的安装