Spring之SSM整合流程详解（Spring+SpringMVC+MyBatis）

发布于：2025-07-26 ⋅ 阅读:(15) ⋅ 点赞:(0)

Spring之SSM整合流程详解-Spring+SpringMVC+MyBatis

SSM（Spring + SpringMVC + MyBatis）是企业级Java开发的经典框架组合：Spring负责IoC容器和事务管理，SpringMVC处理Web请求，MyBatis简化数据库操作，掌握SSM整合是Java后端开发的必备技能。

一、SSM整合的核心思路

SSM整合的本质是将三个框架的容器融合，实现组件的自动装配和调用，核心思路：

  1. 容器整合：

    • Spring容器（ApplicationContext）：管理Service、Dao、数据源等核心Bean；
    • SpringMVC容器：管理Controller、视图解析器等Web层Bean，作为Spring容器的子容器，可引用父容器的Bean。

  2. 职责划分：

    • SpringMVC：接收请求（@Controller）、参数绑定、返回响应；
    • Spring：管理Service和Dao的依赖注入、声明式事务；
    • MyBatis：提供Mapper接口和SQL映射，与数据库交互。

  3. 整合关键点：

    • Spring配置数据源和MyBatis的SqlSessionFactory；
    • SpringMVC配置Web层组件，扫描@Controller；
    • 确保Service能注入Mapper，Controller能注入Service。

二、环境准备与依赖配置

2.1 开发环境

  • JDK：1.8+
  • 数据库：MySQL 8.0
  • 构建工具：Maven 3.6+
  • 框架版本：Spring 5.3.x + SpringMVC 5.3.x + MyBatis 3.5.x

2.2 Maven依赖（pom.xml）

核心依赖包括Spring、SpringMVC、MyBatis及整合包，需注意版本兼容性：

<?xml version="1.0" encoding="UTF-8"?>
<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>ssm-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <properties>
        <spring.version>5.3.20</spring.version>
        <mybatis.version>3.5.9</mybatis.version>
        <mybatis-spring.version>2.0.7</mybatis-spring.version>
        <mysql.version>8.0.33</mysql.version>
        <servlet-api.version>4.0.1</servlet-api.version>
    </properties>

    <dependencies>
        <!-- Spring核心 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spring.version}</version>
        </dependency>

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

        <!-- MyBatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>

        <!-- MyBatis与Spring整合 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring.version}</version>
        </dependency>

        <!-- MySQL驱动 -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- 数据库连接池（HikariCP） -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>4.0.3</version>
        </dependency>

        <!-- Servlet API -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>${servlet-api.version}</version>
            <scope>provided</scope>
        </dependency>

        <!-- JSTL（可选，用于JSP） -->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>javax.servlet.jsp.jstl-api</artifactId>
            <version>1.2.2</version>
        </dependency>

        <!-- Lombok（简化POJO） -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <!-- 编译和打包配置 -->
    <build>
        <plugins>
            <!-- Java编译 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <!-- Tomcat插件（用于本地运行） -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat9-maven-plugin</artifactId>
                <version>3.0.0</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>

        <!-- 资源文件打包（确保Mapper XML被正确加载） -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include> <!-- 打包java目录下的XML -->
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

依赖说明：

  • mybatis-spring：MyBatis与Spring的整合包，必不可少；
  • HikariCP：高性能连接池，替代传统的C3P0；
  • 资源配置：确保src/main/java下的Mapper XML能被打包（MyBatis需要读取）。

三、整合配置文件（核心步骤）

SSM整合需要5类核心配置文件，按加载顺序依次为：

  1. 数据库配置（db.properties）
  2. Spring核心配置（spring.xml）
  3. SpringMVC配置（spring-mvc.xml）
  4. MyBatis配置（mybatis-config.xml，可选）
  5. Web容器配置（web.xml）

3.1 数据库配置（db.properties）

创建src/main/resources/db.properties，存储数据库连接信息：

# 数据库驱动
jdbc.driver=com.mysql.cj.jdbc.Driver
# 连接URL（指定时区和编码）
jdbc.url=jdbc:mysql://localhost:3306/ssm_db?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
# 用户名
jdbc.username=root
# 密码
jdbc.password=123456
# 连接池配置
jdbc.maxPoolSize=10
jdbc.minIdle=5

3.2 Spring核心配置（spring.xml）

创建src/main/resources/spring.xml，配置Spring容器的核心组件（数据源、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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           https://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/tx
           https://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 1. 加载数据库配置文件 -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 2. 扫描Service和Dao（排除Controller，由SpringMVC扫描） -->
    <context:component-scan base-package="com.example">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 3. 配置数据源（HikariCP） -->
    <bean id="dataSource" class="com.zaxxer.hikari.HikariConfig">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maximumPoolSize" value="${jdbc.maxPoolSize}"/>
        <property name="minimumIdle" value="${jdbc.minIdle}"/>
    </bean>
    <bean id="hikariDataSource" class="com.zaxxer.hikari.HikariDataSource">
        <constructor-arg ref="dataSource"/>
    </bean>

    <!-- 4. 配置SqlSessionFactory（MyBatis核心） -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="hikariDataSource"/> <!-- 关联数据源 -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/> <!-- MyBatis配置 -->
        <property name="mapperLocations" value="classpath:com/example/mapper/*.xml"/> <!-- Mapper XML路径 -->
        <property name="typeAliasesPackage" value="com.example.pojo"/> <!-- 实体类别名包 -->
    </bean>

    <!-- 5. 扫描Mapper接口（生成代理对象，注入Spring） -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.mapper"/> <!-- Mapper接口包 -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!-- 6. 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="hikariDataSource"/>
    </bean>

    <!-- 7. 开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

核心作用：

  • 整合MyBatis：通过SqlSessionFactoryBean创建SqlSessionFactory，关联数据源和Mapper；
  • 事务管理：配置DataSourceTransactionManager，支持@Transactional注解；
  • 组件扫描：扫描@Service、@Repository，排除@Controller（由SpringMVC扫描）。

3.3 SpringMVC配置（spring-mvc.xml）

创建src/main/resources/spring-mvc.xml，配置Web层组件：

<?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
           https://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">

    <!-- 1. 扫描Controller（仅扫描@Controller） -->
    <context:component-scan base-package="com.example.controller">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 2. 开启SpringMVC注解驱动 -->
    <mvc:annotation-driven>
        <!-- 配置JSON消息转换器（解决中文乱码） -->
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <property name="supportedMediaTypes">
                    <list>
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json;charset=UTF-8</value>
                    </list>
                </property>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>

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

    <!-- 4. 静态资源处理 -->
    <mvc:resources mapping="/static/**" location="/static/"/>
</beans>

核心作用：

  • 扫描@Controller：确保SpringMVC能接管请求；
  • 注解驱动：支持@RequestMapping、@ResponseBody等Web注解；
  • 视图解析：配置JSP路径，处理页面跳转。

3.4 MyBatis配置（mybatis-config.xml）

创建src/main/resources/mybatis-config.xml，配置MyBatis全局参数（可选，非必须）：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 全局设置 -->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 下划线转驼峰 -->
        <setting name="logImpl" value="org.apache.ibatis.logging.stdout.StdOutImpl"/> <!-- 日志输出 -->
        <setting name="cacheEnabled" value="true"/> <!-- 开启二级缓存 -->
    </settings>
</configuration>

3.5 Web容器配置（web.xml）

创建src/main/webapp/WEB-INF/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">

    <!-- 1. 配置Spring容器监听器（加载spring.xml） -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring.xml</param-value>
    </context-param>

    <!-- 2. 配置SpringMVC的DispatcherServlet -->
    <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:spring-mvc.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>

    <!-- 3. 编码过滤器（解决中文乱码） -->
    <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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

核心作用：

  • ContextLoaderListener：加载Spring核心配置（spring.xml），创建Spring容器；
  • DispatcherServlet：加载SpringMVC配置（spring-mvc.xml），处理Web请求；
  • 编码过滤器：确保请求和响应的中文正常显示。

四、实战案例：用户管理模块

通过用户CRUD演示SSM整合后的使用，验证框架是否正常工作。

4.1 数据库表设计

CREATE DATABASE ssm_db;
USE ssm_db;

CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `age` int DEFAULT NULL,
  `email` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

4.2 实体类（User.java）

package com.example.pojo;

import lombok.Data;

@Data
public class User {
    private Integer id;
    private String username;
    private Integer age;
    private String email;
}

4.3 Mapper接口与XML

4.3.1 UserMapper接口
package com.example.mapper;

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

public interface UserMapper {
    // 新增
    int insert(User user);

    // 更新
    int update(User user);

    // 删除
    int deleteById(Integer id);

    // 按ID查询
    User selectById(Integer id);

    // 查询所有
    List<User> selectAll();
}
4.3.2 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">
    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (username, age, email)
        VALUES (#{username}, #{age}, #{email})
    </insert>

    <update id="update">
        UPDATE user
        SET username = #{username}, age = #{age}, email = #{email}
        WHERE id = #{id}
    </update>

    <delete id="deleteById">
        DELETE FROM user WHERE id = #{id}
    </delete>

    <select id="selectById" resultType="User">
        SELECT id, username, age, email FROM user WHERE id = #{id}
    </select>

    <select id="selectAll" resultType="User">
        SELECT id, username, age, email FROM user
    </select>
</mapper>

4.4 Service层

package com.example.service;

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

public interface UserService {
    void addUser(User user);
    void updateUser(User user);
    void deleteUser(Integer id);
    User getUserById(Integer id);
    List<User> getAllUsers();
}

package com.example.service.impl;

import com.example.mapper.UserMapper;
import com.example.pojo.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @Transactional
    public void addUser(User user) {
        userMapper.insert(user);
    }

    @Override
    @Transactional
    public void updateUser(User user) {
        userMapper.update(user);
    }

    @Override
    @Transactional
    public void deleteUser(Integer id) {
        userMapper.deleteById(id);
    }

    @Override
    public User getUserById(Integer id) {
        return userMapper.selectById(id);
    }

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

4.5 Controller层

package com.example.controller;

import com.example.pojo.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.*;

import java.util.List;

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

    @Autowired
    private UserService userService; // 注入Service

    // 跳转列表页
    @GetMapping("/list")
    public String list(Model model) {
        List<User> users = userService.getAllUsers();
        model.addAttribute("users", users);
        return "user/list"; // 对应/WEB-INF/views/user/list.jsp
    }

    // 跳转新增页
    @GetMapping("/toAdd")
    public String toAdd() {
        return "user/add";
    }

    // 新增提交
    @PostMapping("/add")
    public String add(User user) {
        userService.addUser(user);
        return "redirect:/user/list"; // 重定向到列表页
    }

    // 跳转编辑页
    @GetMapping("/toUpdate/{id}")
    public String toUpdate(@PathVariable Integer id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "user/update";
    }

    // 编辑提交
    @PostMapping("/update")
    public String update(User user) {
        userService.updateUser(user);
        return "redirect:/user/list";
    }

    // 删除
    @GetMapping("/delete/{id}")
    public String delete(@PathVariable Integer id) {
        userService.deleteUser(id);
        return "redirect:/user/list";
    }

    // 测试JSON接口
    @GetMapping("/api/{id}")
    @ResponseBody
    public User apiGet(@PathVariable Integer id) {
        return userService.getUserById(id);
    }
}

4.6 JSP页面（视图层）

4.6.1 列表页（list.jsp）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>用户列表</title>
</head>
<body>
<h1>用户列表</h1>
<a href="/user/toAdd">新增用户</a>
<table border="1">
    <tr>
        <th>ID</th>
        <th>用户名</th>
        <th>年龄</th>
        <th>邮箱</th>
        <th>操作</th>
    </tr>
    <c:forEach items="${users}" var="user">
        <tr>
            <td>${user.id}</td>
            <td>${user.username}</td>
            <td>${user.age}</td>
            <td>${user.email}</td>
            <td>
                <a href="/user/toUpdate/${user.id}">编辑</a>
                <a href="/user/delete/${user.id}" onclick="return confirm('确定删除？')">删除</a>
            </td>
        </tr>
    </c:forEach>
</table>
</body>
</html>
4.6.2 新增页（add.jsp）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>新增用户</title>
</head>
<body>
<h1>新增用户</h1>
<form action="/user/add" method="post">
    用户名：<input type="text" name="username"><br>
    年龄：<input type="number" name="age"><br>
    邮箱：<input type="email" name="email"><br>
    <button type="submit">提交</button>
</form>
</body>
</html>
4.6.3 编辑页（update.jsp）
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>编辑用户</title>
</head>
<body>
<h1>编辑用户</h1>
<form action="/user/update" method="post">
    <input type="hidden" name="id" value="${user.id}">
    用户名：<input type="text" name="username" value="${user.username}"><br>
    年龄：<input type="number" name="age" value="${user.age}"><br>
    邮箱：<input type="email" name="email" value="${user.email}"><br>
    <button type="submit">提交</button>
</form>
</body>
</html>

五、启动与测试

5.1 项目目录结构

确保目录结构正确，否则可能导致配置文件或页面找不到：

src
├── main
│   ├── java
│   │   └── com
│   │       ├── example
│   │       │   ├── controller
│   │       │   ├── mapper
│   │       │   ├── pojo
│   │       │   └── service
│   │       │       └── impl
│   ├── resources
│   │   ├── db.properties
│   │   ├── mybatis-config.xml
│   │   ├── spring-mvc.xml
│   │   └── spring.xml
│   └── webapp
│       ├── WEB-INF
│       │   ├── views
│       │   │   └── user
│       │   │       ├── add.jsp
│       │   │       ├── list.jsp
│       │   │       └── update.jsp
│       │   └── web.xml
│       └── static

5.2 启动项目

执行Maven命令启动Tomcat：

mvn tomcat9:run

启动成功后，访问http://localhost:8080/user/list。

5.3 测试功能

  1. 新增用户：点击“新增用户”，填写表单提交，列表页应显示新增数据；
  2. 编辑用户：点击“编辑”，修改信息提交，列表页应显示更新后的数据；
  3. 删除用户：点击“删除”，确认后数据应从列表中移除；
  4. JSON接口：访问http://localhost:8080/user/api/1，应返回ID为1的用户JSON数据。

六、常见问题与避坑指南

6.1 Mapper注入失败（NoSuchBeanDefinitionException）

错误：No qualifying bean of type 'com.example.mapper.UserMapper' available

原因：

  • MapperScannerConfigurer的basePackage配置错误（未扫描到Mapper接口）；
  • Mapper接口未与XML匹配（namespace错误）；
  • 资源配置错误，Mapper XML未被打包（pom.xml的resources配置缺失）。

解决方案：

  • 检查basePackage是否为com.example.mapper；
  • 确保XML的namespace与Mapper接口全类名一致；
  • 确认pom.xml的resources配置包含**/*.xml。

6.2 Service注入失败（NoSuchBeanDefinitionException）

错误：No qualifying bean of type 'com.example.service.UserService' available

原因：

  • UserServiceImpl未添加@Service注解；
  • Spring配置的component-scan未扫描到com.example.service；
  • Service实现类未实现Service接口（implements UserService缺失）。

解决方案：

  • 为UserServiceImpl添加@Service；
  • 检查spring.xml的component-scan是否包含com.example（且未排除Service）。

6.3 事务不生效（@Transactional无效）

错误：Service方法抛出异常后，数据未回滚。

原因：

  • spring.xml未配置tx:annotation-driven；
  • 异常被try-catch捕获（未抛出到外层）；
  • 方法非public（Spring事务仅对public方法生效）。

解决方案：

  • 确保spring.xml包含<tx:annotation-driven transaction-manager="transactionManager"/>；
  • 异常需抛出（或在catch中重新抛出RuntimeException）；
  • 事务方法必须为public。

总结：SSM整合核心要点

SSM整合将三个框架的优势结合，形成完整的开发体系：

  • MyBatis：简化数据库操作，专注SQL编写；
  • Spring：统一管理Bean和事务，实现依赖解耦；
  • SpringMVC：高效处理Web请求，衔接前后端。

整合的核心是“容器融合”：Spring容器管理核心Bean，SpringMVC容器管理Web Bean，通过父子容器关系实现Bean的共享和调用。

若这篇内容帮到你，动动手指支持下！关注不迷路，干货持续输出！
ヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉヾ(´∀ ˋ)ﾉ

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布