# ssm配置教程

**Repository Path**: addmdxwg/ssm-configuration-tutorial

## Basic Information

- **Project Name**: ssm配置教程
- **Description**: 最新SSM整合教程从0 ~ 1 ，就算cv也可成功运行
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-25
- **Last Updated**: 2025-06-26

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 最新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项目](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E5%88%9B%E5%BB%BAMaven%E9%A1%B9%E7%9B%AE.png)

### 二、配置需要的maven依赖

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

```xml
<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>
```

### 三、项目文件架构

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

![完整项目结构](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E5%AE%8C%E6%95%B4%E9%A1%B9%E7%9B%AE%E7%BB%93%E6%9E%84.png)

```markdown
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配置类

```java
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配置类

```java
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配置文件

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

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

```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
```

> 主配置类

```java
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来配置了

```java
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 创建数据库，数据表，添加数据

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

```sql
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实体类

```java
@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

```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
<?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接口以及实现类

```java
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();
}
```

> 实现类

```java
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，并创建后端统一响应对象

```java
@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
>
> - 后端统一响应对象，用来统一响应体

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

> BaseController.java 
>
> - 基准Controller，所有Controller都继承这个Controller

```java
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、打开项目配置框

![打开项目配置窗口](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E6%89%93%E5%BC%80%E9%A1%B9%E7%9B%AE%E9%85%8D%E7%BD%AE%E7%AA%97%E5%8F%A3.png)

2、添加web支持

![配置web支持1](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E9%85%8D%E7%BD%AEweb%E6%94%AF%E6%8C%811.png)

![配置web支持2](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E9%85%8D%E7%BD%AEweb%E6%94%AF%E6%8C%812.png)

3、点击工件栏

![构建工件1](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E6%9E%84%E5%BB%BA%E5%B7%A5%E4%BB%B61.png)

4、点击构建工件

![构建工件2](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E6%9E%84%E5%BB%BA%E5%B7%A5%E4%BB%B62.png)

![构建工件3](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/%E6%9E%84%E5%BB%BA%E5%B7%A5%E4%BB%B63.png)

#### 6.3 配置Tomcat

1、打开配置框

![tomcat1](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat1.png)

2、选择本地tomcat并添加

![tomcat2](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat2.png)

3、选择自己的tomcat

![tomcat3](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat3.png)

4、使用配置好的工件

![tomcat4](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat4.png)

![tomcat5](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat5.png)

![tomcat6](https://addmdxwg.oss-cn-guangzhou.aliyuncs.com/CSDN/ssm%E9%85%8D%E7%BD%AE/images/tomcat6.png)

### 七、结语

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