atwood-pan

 

SpringMVC06——数据绑定——2021-05-09

数据绑定介绍

  1. 在执行程序时，SpringMVC会根据客户端请求参数的不同，
    将请求信息中的信息以一定的方式转换并绑定到控制器类的方法参数中。

  2. 在数据绑定过程中，SpringMVC框架会通过数据绑定组件（DataBinder）将请求参数串的内容进行类型转换，然后将转换后的值赋给控制器类中的方法的形参，这样后台方法就可以正确绑定并获取客户端请求携带的参数了。

绑定默认数据类型

常用的默认参数类型：

  • HttpServletRequest:通过request对象获取请求信息。
  • HttpServletResponse:通过response处理相应信息。
  • HttpSession:通过session对象得到session中存储的对象。
  • Model/ModelMap：Model是一个接口，ModelMap是一个接口实现，作用是将model数据填充到request域。
  1. 创建springmvc-config.xml或者创建SpringMVCConfig.java
    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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        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">
    <context:component-scan base-package="com.pp.controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
<!--        后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

SpringMVCConfig.java

package com.pp.config;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
 
@Configuration
@EnableWebMvc
@ComponentScan("com.pp")//扫描包
 
public class SpringMVCConfig implements WebMvcConfigurer {
 
    //配置jsp视图解析器
    @Bean
    public InternalResourceViewResolver getViewResolver(){
        InternalResourceViewResolver viewResolver = new
                InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/jsp/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
    //配置静态资源的处理
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
 
}
  1. 在com.pp.controller包下创建控制器类UserController。
package com.pp.controller;
 
import com.pp.pojo.User;
import com.pp.pojo.UserVO;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
import javax.servlet.http.HttpServletRequest;
import java.util.List;
 
/**
 * @author Administrator
 */
@Controller
public class UserController {
    /**
     * 绑定默认数据类型
     * @param request
     * @return
     */
    @RequestMapping("/selectUser1")
    public String selectUser1(HttpServletRequest request){
        String id = request.getParameter("id");
        System.out.println("id=>" + id);
        return "success";
    }
   
}
  1. 在WEB-INF目录下，创建一个jsp文件夹，success.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>结果页面</title>
</head>
<body>
    OK！
</body>
</html>

绑定简单数据类型

简单数据类型的绑定，就是指Java中几种基本数据类型的绑定，如int、String、Double等类型。

/**
     * 绑定简单数据类型
     * @param id
     * @return
     */
    @RequestMapping("/selectUser2")
    public String selectUser2(Integer id){
        System.out.println("id=>" + id);
        return "success";
    }
    
	@RequestMapping("/selectUser2")
    public String selectUser2(@RequestParam(value="user_id")Integer id){
        System.out.println("id=>" + id);
        return "success";
    }

绑定POJO类型

POJO类型的数据绑定就是将所有关联的请求参数封装在一个POJO中，然后在方法中直接使用该POJO作为形参来完成数据绑定。

  1. 创建包com.pp.pojo包，创建User类来封装用户注册的信息参数。
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
 
/**
 * @author Administrator
 */
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class User {
    private Integer id;
    private String username;
    private Integer password;
 
}
  1. 在控制器UserController类中，编写接收用户注册信息和向注册页面跳转的方法。
/**
     * 绑定POJO类型
     */
    /**
     * 向用户注册页面跳转
     */
    @RequestMapping("/toRegister")
    public String toRegister(){
        return "register";
    }
    /**
     * 接受用户注册信息
     */
    @RequestMapping("/registerUser")
    public String registerUser(User user){
        String username = user.getUsername();
        Integer password = user.getPassword();
        System.out.println("username=>" + username);
        System.out.println("password=>" + password);
        return "success";
    }
  1. 在WEB-INF/jsp目录下，创建一个用户注册页面register.jsp，表单需要以POST方式提交，并且在提交时会发送一条以"/registerUser"结尾的请求消息
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>注册界面</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/registerUser" method="post">
        用户名:<input type="text" name="username"/><br/>
        密&nbsp;&nbsp;&nbsp;码:<input type="text" name="password"><br/>
        <input type="submit" value="注册">
    </form>
</body>
</html>

注意：在绑定POJO类型数据时，前端请求的参数名必须要与绑定的POJO类中的属性名一致，这样才会自动将请求数据绑定到POJO对象中，否则后台接收的参数值为null

遇到问题与解决方法：
在前端请求中，难免会有中文信息传递，这时就需要配置字符编码来解决这个问题。
在web.xml中添加

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

这样就可以解决乱码的问题啦！

绑定包装POJO

包装POJO，就是指一个POJO中包含另一个简单POJO。
例如：在订单对象中包含用户对象，这样的话可以通过订单来查询到用户信息了。
  1. 在com.pp.pojo包中创建一个订单类Orders
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Orders {
    private Integer ordersId;//订单编号
    private User user;//绑定用户
}
  1. 在com.pp.controller包中，创建一个OrdersController，在该类中编写一个跳转到订单查询页面的方法和一个查询订单及用户信息的方法。
import com.pp.pojo.Orders;
import com.pp.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
/**
 * @author Administrator
 */
 
@Controller
public class OrdersController {
    /**
     * 向订单查询页面跳转
     * @return
     */
    @RequestMapping("/tofindOrdersWithUser")
    public String toFindOrdersWithUser(){
        return "orders";
    }
    /**
     * 查询订单和用户信息
     */
    @RequestMapping("/findOrdersWithUser")
    public String findOrdersWithUser(Orders orders) {
        Integer ordersId = orders.getOrdersId();
        User user = orders.getUser();
        String username = user.getUsername();
        System.out.println("ordersId=>"+ordersId);
        System.out.println("username=>"+username);
        return "success";
    }
}
  1. 在WEB-INF/jsp目录下，创建一个用户订单查询页面order.jsp。
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>订单查询</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/findOrdersWithUser" method="post">
        订单编号：<input type="text" name="ordersId"/><br/>
        所属用户：<input type="text" name="user.username"/><br/>
                <input type="submit" value="查询"/>
    </form>
</body>
</html>

复杂数据绑定

常见的有：

  • 数组绑定
  • 集合绑定

绑定数组

在实际开发时，可能会遇到前端请求需要传递到后台一个或多个相同名称参数的情况（例如批量删除），这种情况就需要使用绑定数组的方式，来完成。

  1. 在WEB-INF/jsp下新建一个展示用户信息的列表页面user.jsp
 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>用户列表</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/deleteUsers" method="post">
        <table width="20%" border=1>
            <tr>
                <td>选择</td>
                <td>用户名</td>
            </tr>
            <tr>
                <td><input name="ids" value="1" type="checkbox" checked/></td>
                <td>tom</td>
            </tr>
            <tr>
                <td><input name="ids" value="2" type="checkbox" /></td>
                <td>jack</td>
            </tr>
            <tr>
                <td><input name="ids" value="3" type="checkbox" /></td>
                <td>lucy</td>
            </tr>
        </table>
        <input type="submit" value="删除"/>
    </form>
</body>
</html>
  1. 在控制器类UserController中，编写接受批量删除用户的方法
 /**
     * 向用户列表页面跳转
     */
    @RequestMapping("/toUser")
    public String selectUsers(){
        return "user";
    }
    /**
     * 接收批量删除用户的方法
     */
    @RequestMapping("/deleteUsers")
    public String deleteUsers(Integer[] ids) {
        if(ids != null){
            for (Integer id : ids) {
                System.out.println("删除了id为"+id + "的用户！");
            }
        }else {
            System.out.println("ids=NULL");
        }
        return "success";
    }

绑定集合

在批量删除用户的操作中，前端请求传递的都是同名参数的用户id，只需要在后台使用同一种数组类型的参数绑定接收，就可以在方法中通过循环数组参数的方式来完成删除操作。
但如果进行批量修改的时候，前端请求传递过来的数据可能就会批量包含各种类型的数据，如Integer、String等。这种情况就可以使用集合数据绑定。
即在包装类中定义一个包含用户信息类的集合，然后再接收方法中将参数类型定义为该包装类的集合。
  1. 创建com.pp.vo包，并且创建UserVO来封装用户集合属性。
/**
 * 用户包装类
 * @author Administrator
 * 该集合属性就是用于绑定批量修改用户的数据信息
 */
 
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class UserVO {
    private List<User> users;
 
}
  1. 在控制器类UserController中，编写接收批量修改用户的方法，以及向用户修改页面跳转的方法
	 /**
     * 向用户批量修改页面跳转
     */
    @RequestMapping("/toUserEdit")
    public String toUserEdit(){
        return "user_edit";
    }
    /**
     * 接受批量修改用户的方法
     *UserVO类型参数用于绑定并获取页面传递过来的用户数据
     */
    @RequestMapping("/editUsers")
    public String editUsers(UserVO userList){
        //将所有用户数据封装到集合中
        List<User> users = userList.getUsers();
        //循环输出所有用户信息
        for (User user : users) {
            //如果接受的用户id不为空，则表示对该用户进行了修改
            if(!(user.getId().equals(""))){
                System.out.println("修改了id为：" + user.getId()+"的用户名为："+ user.getUsername());
            }
        }
        return "success";
    }
  1. 在WEB-INF/jsp目录下，创建页面文件user_edit.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>修改用户</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/editUsers" method="post" id="formid">
    <table width="30%" border=1>
        <tr>
            <td>选择</td>
            <td>用户名</td>
        </tr>
        <tr>
            <td><input name="users[0].id" value="1" type="checkbox"/></td>
            <td><input name="users[0].username" value="tome" type="text"/></td>
        </tr>
        <tr>
            <td><input name="users[1].id" value="2" type="checkbox"/></td>
            <td><input name="users[1].username" value="jack" type="text"/></td>
        </tr>
    </table>
    <input type="submit" value="修改"/>
</form>
</body>
</html>

最后end

一定要记住配置tom运行测试！！

这次一定！

posted on   JavaCoderPan  阅读(43)  评论(0)  编辑  收藏  举报  

相关博文：
· SpringMVC08——拦截器——2021-05-11
· SpringMVC01——回顾MVC
· 第13章 数据绑定
· SpringMVC参数绑定
· 【SpringMVC学习04】SpringMVC中的参数绑定总结
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南

导航

统计

点击右上角即可分享
微信分享提示
AI IDE Trae