SpringMVC整合MyBatis的步骤-精创网络云防护

帮助文档
SpringMVC整合MyBatis的步骤
来源：www.jcwlyf.com浏览：11更新：2025-11-11

SpringMVC 是一个基于 Java 的实现了 MVC 设计模式的请求驱动类型的轻量级 Web 框架，而 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。将 SpringMVC 和 MyBatis 进行整合，可以充分发挥两者的优势，实现高效的 Web 应用开发。下面将详细介绍 SpringMVC 整合 MyBatis 的具体步骤。

步骤一：创建 Maven 项目

首先，我们需要创建一个 Maven 项目，这样可以方便地管理项目的依赖。在 IDE 中创建一个新的 Maven 项目，选择合适的项目路径和命名。创建完成后，在项目的 pom.xml 文件中添加所需的依赖。以下是一个示例的 pom.xml 文件内容：

<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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>springmvc-mybatis-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- SpringMVC -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.18</version>
        </dependency>
        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.9</version>
        </dependency>
        <!-- MyBatis-Spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
        <!-- JDBC 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        <!-- Servlet API -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>

上述依赖中包含了 SpringMVC、MyBatis、MyBatis-Spring、MySQL 驱动、Druid 数据库连接池以及 Servlet API。添加完依赖后，Maven 会自动下载这些依赖到项目中。

步骤二：配置 SpringMVC

接下来，我们需要配置 SpringMVC。在 src/main/resources 目录下创建 springmvc-servlet.xml 文件，用于配置 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
                           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.example.controller"/>

    <!-- 开启 SpringMVC 注解支持 -->
    <mvc:annotation-driven/>

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

在上述配置中，我们使用 <context:component-scan> 标签开启了组件扫描，指定了扫描的包路径为 com.example.controller，这样 SpringMVC 会自动扫描该包下的控制器类。<mvc:annotation-driven> 标签用于开启 SpringMVC 的注解支持。InternalResourceViewResolver 是一个视图解析器，用于解析视图的路径，这里将视图文件放在 /WEB-INF/views/ 目录下，并且以 .jsp 为后缀。

然后，在 web.xml 文件中配置 SpringMVC 的前端控制器 DispatcherServlet。以下是一个示例的 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 的前端控制器 -->
    <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>
</web-app>

在上述配置中，我们配置了 DispatcherServlet，并指定了其配置文件的位置为 classpath:springmvc-servlet.xml。<load-on-startup>1</load-on-startup> 表示在服务器启动时就加载该 Servlet。<url-pattern>/</url-pattern> 表示将所有的请求都交给 DispatcherServlet 处理。

步骤三：配置 MyBatis 和数据源

在 src/main/resources 目录下创建 applicationContext.xml 文件，用于配置 MyBatis 和数据源。以下是一个示例的配置文件内容：

<?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
                           http://www.springframework.org/schema/context/spring-context.xsd">

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

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
    </bean>

    <!-- 配置 SqlSessionFactoryBean -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
    </bean>

    <!-- 配置 MapperScannerConfigurer -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.mapper"/>
    </bean>
</beans>

在上述配置中，我们首先使用 <context:property-placeholder> 标签加载了 jdbc.properties 文件，该文件用于存储数据库的连接信息。以下是一个示例的 jdbc.properties 文件内容：

jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456
jdbc.driver=com.mysql.cj.jdbc.Driver

然后，我们配置了 Druid 数据源，将数据库的连接信息注入到数据源中。接着，配置了 SqlSessionFactoryBean，指定了数据源和 Mapper XML 文件的位置。最后，使用 MapperScannerConfigurer 扫描指定包下的 Mapper 接口，将其注册为 Spring Bean。

步骤四：创建实体类和 Mapper 接口

在 com.example.entity 包下创建实体类，用于映射数据库表。例如，创建一个 User 实体类：

package com.example.entity;

public class User {
    private Integer id;
    private String username;
    private String password;

    // 省略 getter 和 setter 方法
    public Integer getId() {
        return id;
    }

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

    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;
    }
}

在 com.example.mapper 包下创建 Mapper 接口，用于定义数据库操作方法。例如，创建一个 UserMapper 接口：

package com.example.mapper;

import com.example.entity.User;
import java.util.List;

public interface UserMapper {
    List<User> findAll();
}

在 src/main/resources/mapper 目录下创建对应的 Mapper XML 文件，实现 Mapper 接口中的方法。例如，创建 UserMapper.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="findAll" resultType="com.example.entity.User">
        SELECT * FROM user
    </select>
</mapper>

步骤五：创建 Service 层和 Controller 层

在 com.example.service 包下创建 Service 接口和实现类，用于处理业务逻辑。例如，创建 UserService 接口和 UserServiceImpl 实现类：

package com.example.service;

import com.example.entity.User;
import java.util.List;

public interface UserService {
    List<User> findAll();
}

package com.example.service.impl;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> findAll() {
        return userMapper.findAll();
    }
}

在 com.example.controller 包下创建 Controller 类，用于处理请求和返回响应。例如，创建 UserController 类：

package com.example.controller;

import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

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

    @Autowired
    private UserService userService;

    @RequestMapping("/list")
    public String list(Model model) {
        List<User> userList = userService.findAll();
        model.addAttribute("userList", userList);
        return "userList";
    }
}

步骤六：创建视图文件

在 /WEB-INF/views/ 目录下创建 userList.jsp 文件，用于显示用户列表。以下是一个示例的 userList.jsp 文件内容：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>用户列表</title>
</head>
<body>
    <h1>用户列表</h1>
    <table border="1">
        <tr>
            <th>ID</th>
            <th>用户名</th>
            <th>密码</th>
        </tr>
        <c:forEach items="${userList}" var="user">
            <tr>
                <td>${user.id}</td>
                <td>${user.username}</td>
                <td>${user.password}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

在上述 JSP 文件中，我们使用了 JSTL 的 <c:forEach> 标签来遍历用户列表，并将用户信息显示在表格中。