2025最新SSM整合教程从0 ~ 1 就算cv也可成功运行

前言： 按照教程步骤完成，可以从0 ~ 1对SSM进行整合，非常简单，小白都能配置成功

需要准备配置：jdk17、mysql8.0+、tomcat10+

测试使用：Apifox 官网： https://apifox.com/

项目仓库地址：https://gitee.com/addmdxwg/ssm-configuration-tutorial

如果觉得本教程还不错，可以点一个免费的star，您的支持就是我创作的动力

一、创建Maven项目

创建一个空的maven项目，准备配置

创建Maven项目

二、配置需要的maven依赖

我这里已经准备好了，cv就可以

<dependencies>
    <!-- mysql驱动 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.3.0</version>
    </dependency>
    <!-- druid连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.24</version>
    </dependency>
    <!-- mybatis框架 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.19</version>
    </dependency>
    <!-- mybatis整合spring的插件 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>3.0.4</version>
    </dependency>
    <!-- 数据库分页插件 -->
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>6.1.0</version>
    </dependency>
    <!-- servlet依赖 -->
    <dependency>
        <groupId>jakarta.servlet</groupId>
        <artifactId>jakarta.servlet-api</artifactId>
        <version>6.1.0</version>
    </dependency>
    <!-- JSON转换依赖 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.19.0</version>
    </dependency>
    <!-- spring-mvc 依赖 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>6.2.6</version>
    </dependency>
    <!-- spring-jdbc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>6.2.6</version>
    </dependency>
    <!-- spring-tx -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>6.2.6</version>
    </dependency>
    <!-- lombok 选配：用来简化实体类代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.38</version>
    </dependency>
</dependencies>

三、项目文件架构

我先将完整的项目结构展示一下，方便后续新建类的时候知道放在什么地方

完整项目结构

src/
├── main/
│   ├── java/
│   │   └── com.hgz.ssmdemo/
│   │       ├── common/
│   │       │   ├── config/
│   │       │   │   ├── MvcConfig
│   │       │   │   ├── MybatisConfig
│   │       │   │   ├── RootConfig
│   │       │   │   └── WebInitializer
│   │       │   ├── BaseController
│   │       │   └── ResultVO
│   │       ├── entity/
│   │       │   └── User
│   │       ├── mapper/
│   │       │   └── UserMapper
│   │       ├── service/
│   │       │   ├── impl/
│   │       │   │   └── UserServiceImpl
│   │       │   └── UserService
│   │       ├── web.controller/
│   │       │   └── UserController
│   │       └── Main
│   └── resources/
│       ├── mappers/
│       ├── druid.properties
│       └── pagerHelper.properties
├── test/
└── web/

四、编写配置文件

MVC配置类

package com.hgz.ssmdemo.common.config;

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;

/**
 * Mvc配置类
 * 1、开启 Spring MVC 的核心配置功能
 * 2、开启默认请求处理方式
 */
@Configuration
// 开启 Spring MVC 的核心配置功能
@EnableWebMvc
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        // 将无法处理的请求交给默认的servlet处理器来处理
        configurer.enable();
    }
}

Mybatis配置类

package com.hgz.ssmdemo.common.config;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.github.pagehelper.PageInterceptor;
import org.apache.ibatis.logging.stdout.StdOutImpl;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.io.InputStream;
import java.util.Properties;

/**
 * mybatis配置类
 * 1、获取所有的mapper接口
 * 2、配置数据源
 * 3、配置mybatis的工厂bean
 * 4、开启事务管理器
 */
@Configuration
// 扫描当前的mapper包
@MapperScan("com.hgz.ssmdemo.mapper")
//启用事务注解管理器
@EnableTransactionManagement
public class MybatisConfig {


    /**
     * 配置druid连接池
     * 1、配置注册销毁方法（init,close）
     * 2、获取druid配置文件获取数据源
     * @return 数据源
     * @throws Exception 抛出异常
     */
    @Bean(initMethod = "init",destroyMethod = "close")
    public DruidDataSource  dataSource()  throws Exception{
        // 读取druid配置
        Properties properties = new Properties();
        // 获取到当前的配置文件并加载
        InputStream druid = MybatisConfig.class.getClassLoader().getResourceAsStream("druid.properties");
        properties.load(druid);
        // 使用 DruidDataSourceFactory的静态方法createDataSource获取到DruidDataSource
        return (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
    }

    /**
     * 配置Mybatis的工厂Bean
     * 1、配置数据源
     * 2、配置实体包
     * 3、配置xml文件映射
     * 4、注册分页插件
     * 5、启动sql日志
     * @return 一个配置好的SqlSessionFactoryBean
     * @throws Exception 配置报错
     */
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
        // 创建 SqlSessionFactoryBean 对象
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        // 注入数据源
        factoryBean.setDataSource(dataSource());
        // 设置实体别名,让 MyBatis 扫描该包中的类，在 XML 中可以直接写 User 而不是全限定名
        factoryBean.setTypeAliasesPackage("com.hgz.ssmdemo.entity");
        // 设置mapper.xml的文件映射路径
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        factoryBean.setMapperLocations(resolver.getResources("classpath:/mappers/*.xml"));
        // 设置分页插件
        PageInterceptor pageInterceptor = new PageInterceptor();
        // 设置分页属性
        Properties properties = new Properties();
        properties.load(MybatisConfig.class.getClassLoader().getResourceAsStream("pagerHelper.properties"));
        pageInterceptor.setProperties(properties);
        // 将分页拦截器添加到插件中
        factoryBean.setPlugins(pageInterceptor);
        // 启用sql日志
        org.apache.ibatis.session.Configuration conf = new org.apache.ibatis.session.Configuration();
        conf.setLogImpl(StdOutImpl.class);
        factoryBean.setConfiguration(conf);
        return factoryBean;
    }

    /**
     * 装配事务管理器
     * 装配后会识别 @Transactional 注解
     */
    @Bean
    public PlatformTransactionManager txManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

分页 pagerHelper.properties配置文件

# 分页插件配置
helperDialect = mysql
supportMethodsArguments = true
reasonable = true

druid 连接池配置文件 druid.properties 配置文件

# 数据源
driverClassName = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/city?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
username = root
password = root

# druid连接池设置
# 允许最大激活连接数
maxActive = 200
# 允许最小空闲连接数
minIdle = 5
# 初始化连接池的时候先创建5个连接
initialSize = 5
# 是否缓存PreparedStatements（mysql建议关闭）
poolPreparedStatements = false
# 校验连接对象有效性
validationQuery = select 1

主配置类

package com.hgz.ssmdemo.common.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * 主配置类
 * 1、导入其它的配置类,统一装配
 * 2、识别当前项目中包含 @Component 注解的类
 */
@Configuration
@ComponentScan("com.hgz.ssmdemo")
@Import({MvcConfig.class, MybatisConfig.class})
public class RootConfig {
}

五、使用初始化器来初始化容器

创建 WebInitializer （web初始化器）继承 AbstractAnnotationConfigDispatcherServletInitializer 接口

这个使用到了servlet3.0的新特性，实现了servlet初始化器，就不需要再使用xml来配置了

package com.hgz.ssmdemo.common.config;

import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * 容器自动初始化类
 */
public class WebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        // 将主配置类交给容器初始化
        return new Class[]{RootConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        // 拦截所有请求
        return new String[]{"/"};
    }
}

六、测试项目

注意：后面可能会使用到lombok，下面是一些常见的注解

@NoArgsConstructor ：生成无参构造器
@AllArgsConstructor ：生成全参构造器
@RequiredArgsConstructor ：生成包含 final 或 @NonNull 字段的构造器
@Data ：生成Getter ，Setter方法

下面的文件要放入对应的位置

6.1 创建必要的测试类

6.1.1 创建数据库，数据表，添加数据

创建数据库，数据表，添加数据

CREATE DATABASE ssm

USE ssm

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `name` varchar(100) DEFAULT NULL COMMENT '名称',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

INSERT INTO `user` (`name`, `age`) VALUES ('张三', 25), ('李四', 30), ('王五', 28), ('赵六', 17);

6.1.2 编写User实体类

编写User实体类

@Data // 添加get set方
@AllArgsConstructor // 添加全参构造器
@NoArgsConstructor // 添加空参构造器
public class User {
    private Integer id;
    private String name;
    private Integer age;
}

6.1.3 编写UserMapper.xml 以及 UserMapper.java

编写UserMapper.xml 以及 UserMapper.java

import com.hgz.ssmdemo.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @author 小志
 * @date 2025/6/25 - 15:29
 */
@Mapper
public interface UserMapper {
    /**
     * 添加单个用户
     * @param user 需要添加的用户
     */
    void saveUser(User user);

    /**
     * 使用用户id删除单个用户
     * @param userId 用户id
     */
    void deleteUser(Integer userId);

    /**
     * 修改用户信息
     * @param user 修改用户
     */
    void updateUser(User user);

    /**
     * 批量查询用户
     * @return 当前查询的用户集合
     */
    List<User> listUser();

    /**
     * 使用id获取当前用户
     * @param userId 用户id
     * @return 当前查询出来的用户
     */
    User getUserById(Integer userId);
}

<?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.hgz.ssmdemo.mapper.UserMapper">
    
    <sql id="selectAll">
        select id,name,age from user
    </sql>
    
    <!-- 添加单个用户 -->
    <insert id="saveUser" useGeneratedKeys="true" keyProperty="id">
        insert into user(name,age) values(#{name},#{age})
    </insert>

    <!-- 修改用户 -->
    <update id="updateUser">
        update user
        <set>
            <if test="name != null  and name != ''">
                name = #{name},
            </if>
            <if test="age != null">
                age = #{age}
            </if>
        </set>
        <where>
            id = #{id}
        </where>
    </update>

    <!-- 删除用户 -->
    <delete id="deleteUser">
        delete from user where id = #{userId}
    </delete>

    <!-- 分页批量查询用户 -->
    <select id="listUser" resultType="com.hgz.ssmdemo.entity.User">
        <include refid="selectAll"/>
    </select>

    <!-- 使用id查询用户 -->
    <select id="getUserById" resultType="com.hgz.ssmdemo.entity.User">
        <include refid="selectAll"/>
        <where>
            id = #{userId}
        </where>
    </select>

</mapper>

6.1.4 编写UserService接口以及实现类

编写UserService接口以及实现类

public interface UserService {

    /**
     * 添加用户
     * @param user 用户信息
     */
    void saveUser(User user);

    /**
     * 使用id删除用户
     * @param userId 用户id
     */
    void delete(Integer userId);

    /**
     * 修改用户信息
     * @param user 需要修改的用户信息
     */
    void updateUser(User user);

    /**
     * 使用id查询当前用户信息
     * @param userId 用户id
     * @return 当前的用户信息
     */
    User getByUserid(Integer userId);

    /**
     * 查询分页查询用户信息
     * @return 当前查询到的用户信息
     */
    List<User> listUser();
}

实现类

import com.hgz.ssmdemo.entity.User;
import com.hgz.ssmdemo.mapper.UserMapper;
import com.hgz.ssmdemo.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {

    /**
     * 用户mapper
     */
    private final UserMapper userMapper;

    @Override
    public void saveUser(User user) {
        try {
            userMapper.saveUser(user);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void delete(Integer userId) {
        try {
            userMapper.deleteUser(userId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateUser(User user) {
        try {
            userMapper.updateUser(user);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public User getByUserid(Integer userId) {
        try {
            return userMapper.getUserById(userId);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<User> listUser() {
        try {
            return userMapper.listUser();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

6.1.5 编写UserController，并创建后端统一响应对象

@RestController
@RequestMapping("/user")
@RequiredArgsConstructor
public class UserController extends BaseController {
    /**
     * 用户服务
     */
    private final UserService userService;

    @PostMapping("saveUser")
    public ResultVO<?> saveUser(@RequestBody User user){
        userService.saveUser(user);
        return success();
    }
    @PostMapping("deleteUser")
    public ResultVO<?> deleteUser(@RequestBody User user){
        userService.delete(user.getId());
        return success();
    }
    @PostMapping("updateUser")
    public ResultVO<?> updateUser(@RequestBody User user){
        userService.updateUser(user);
        return success();
    }
    @GetMapping("getUserById")
    public ResultVO<?> getUserById(@RequestParam("userId") Integer userId){
        return success(userService.getByUserid(userId));
    }
    @GetMapping("listUser")
    public ResultVO<?> listUser(){
        return success(userService.listUser());
    }
}

ResultVO

后端统一响应对象，用来统一响应体

@Data
public class ResultVO<T> {
    /**
     * 响应状态码
     */
    private Integer code;
    /**
     * 响应消息
     */
    private String message;
    /**
     * 响应的数据内容
     */
    private T data;
}

BaseController.java

基准Controller，所有Controller都继承这个Controller

public class BaseController {

    public <T> ResultVO<T> success(T data) {
        ResultVO<T> vo = new ResultVO<>();
        vo.setCode(HttpStatus.OK.value());
        vo.setData(data);
        return vo;
    }

    public <T> ResultVO<T> success() {
        ResultVO<T> vo = new ResultVO<>();
        vo.setCode(HttpStatus.OK.value());
        return vo;
    }

    public <T> ResultVO<T> error(int code, String message) {
        ResultVO<T> vo = new ResultVO<>();
        vo.setCode(code);
        vo.setMessage(message);
        return vo;
    }

    public <T> ResultVO<T> error(int code) {
        ResultVO<T> vo = new ResultVO<>();
        vo.setCode(code);
        return vo;
    }
}

6.2 添加web支持和构建工件

1、打开项目配置框

打开项目配置窗口

2、添加web支持

配置web支持1

配置web支持2

3、点击工件栏

构建工件1

4、点击构建工件

构建工件2

构建工件3

6.3 配置Tomcat

1、打开配置框

tomcat1

2、选择本地tomcat并添加

tomcat2

3、选择自己的tomcat

tomcat3

4、使用配置好的工件

tomcat4

tomcat5

tomcat6

七、结语

ssm整合到这里就已经结束了，后续测试可以看自己是直接用浏览器测试还是使用测试工具测试，另外如果出现问题可以留言，或者私信，虽然现在的项目很少会使用ssm，都是直接使用spring-boot，但是配置ssm的这个过程也是学习过程中必不可少的，也希望我的教程能够帮到大家快速的配置ssm项目。后续我也想添加一个跨域和全局异常处理进入这个demo，如果有想要的朋友可以给我私信留言