深入浅出详解SSM框架整合全过程

最编程 2024-07-22 09:03:41

...

我们都知道SSM框架是Java中使用非常多的框架，虽然现在流行SpringBoot框架。但是SSM框架依旧有人在用，这篇博客也是为了刚刚学习SSM框架的Java开发者后期整合做准备，也是我回顾SSM框架整合流程的一个总结。很惭愧，之前学习SSM都没写过博客。

SSM整合就是将Spring与Mybatis整合，SM需要中间件充当整合的桥梁。Spring与SpringMVC整合，SS整合不需要中间件。
在Java中，中间件就是一堆具有某个功能的jar包，因为Java都是类class，而jar包又是类的集合。

这里使用Maven来创建Web工程，这样方便我们管理项目中所需要的依赖。那么接下来我们就开始整合SSM框架。

SSM整合所需要的依赖

我们先引入日志依赖，因为每个项目都需要日志来记录项目中的任何事情。不管是开发中在控制台打印日志，还是上线后将日志输出到文件中
这里日志类库我们采用sl4j + log4j2，所需的依赖如下：

<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-slf4j-impl</artifactId>
  <version>2.7</version>
</dependency>
<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-web</artifactId>
  <version>2.7</version>
</dependency>

接下来我们引入数据库相关的依赖：mysql驱动包，Druid数据库连接池，mybatis框架包，spring整合mybatis的桥梁jar包

<!-- mysql jdbc驱动包 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
    <scope>runtime</scope>
</dependency>
<!--Druid数据库连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.20</version>
</dependency>
<!-- mybatis框架包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.2</version>
</dependency>
<!-- mybatis和spring整合依赖包 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

然后我们引入spring框架的依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

哎，spring框架不是有很多jar包吗，这里为啥只引入一个，我们通过下面一张图来解释...

在这里插入图片描述

我们知道Maven的一个作用就是依赖管理，引入一个依赖就会把它所依赖的jar包也引进来，所以我们无需把spring的每个依赖都引一遍。
上面我们看到AOP的依赖也引入进来，但是要使用AOP技术，还是要其他jar包的支持

<!--spring AOP和aspectj框架整合的模块-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

在这里插入图片描述

接下来引入spring jdbc和事务相关的依赖

<!--spring 支持jdbc 编程模块-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

在这里插入图片描述

然后我们再引入javaweb相关依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

最后我们把springmvc默认解析json的jar包和文件上传的jar包引进来

<!-- spring-json依赖 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>
<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>

这样我们就把ssm整合基本需要的jar包都引进来了，整合时只需要把上面的jar包归总即可。
我也看过其他ssm整合的博客，都是把spring全部的依赖都加进来，虽然不影响功能的实现。毕竟我们使用了Maven管理项目，所以尽可能的理清每个依赖所关联的依赖，而不是把全部的spring依赖都加进来。

依赖搞定了，接下来我们就开始配置文件的编写，不得不说ssm最大弊病就是配置文件太多，写错一点配置就可能查找半天原因。这也是为什么springboot这么火的原因--零XML配置等其他特性。

log4j2.xml

上面引入的日志类库需要配置文件的支持才能生效

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--先定义所有的appender-->
    <appenders>
        <!--输出控制台的配置-->
        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <!--<patternlayout pattern="%d{yyyy-MM-dd HH:mm:ss} [%p] %c %m
            %n"/>-->
            <patternlayout pattern="[%p] %m %n"/>
        </console>
    </appenders>
    <!-- 然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!-- 日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
    <loggers>
        <root level="DEBUG">
            <!--输出到控制台-->
            <appender-ref ref="Console"/>
        </root>
        <!--org.springframework
        <logger name="org.springframework" level="INFO"/>-->
    </loggers>
</configuration>

db.properties

我们把数据源的相关配置单独放在一个文件中

jdbc.username=root
jdbc.password=root用户的密码
jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm?useSSL=false&serverTimezone=Asia/Shanghai
jdbc.driverClassName=com.mysql.jdbc.Driver
#初始化连接数大小
jdbc.initialSize=5

applicationContext.xml

这是spring的核心配置文件，把数据源，sqlSessionFactory交给了spring IOC容器管理，以及开启了注解式事务。

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

    <!--扫描service层组件-->
    <context:component-scan base-package="cn.zwq.ssm.service"/>

    <!--读取外部配置文件-->
    <context:property-placeholder location="classpath:application.properties"/>

    <!--将Druid数据源交给Spring IOC容器来管理-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="initialSize" value="${jdbc.initialSize}"/>
    </bean>

    <!--SqlSessionFactory 会话工厂交给spring容器管理-->
    <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--配置Mapper映射文件的位置-->
        <property name="mapperLocations" value="classpath:mapper/*/*Mapper.xml"/>
    </bean>

    <!--配置Mapper接口的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--配置mapper接口所在的包-->
        <property name="basePackage" value="cn.zwq.ssm.mapper"/>
        <!--注入会话工厂-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    </bean>

    <!--配置jdbc的事务管理器-->
    <bean name="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 启用注解事务 -->
    <tx:annotation-driven transaction-manager="txManager"/>
</beans>

springmvc.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">

    <!--开启Controller层注解扫描-->
    <context:component-scan base-package="cn.zwq.ssm.controller"/>

    <!--springmvc注解支持-->
    <mvc:annotation-driven/>

    <!--不拦截静态资源-->
    <mvc:default-servlet-handler/>

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

    <!--文件上传解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 限制文件上传总大小，不设置默认没有限制，单位为字节 200*1024*1024即200M -->
        <property name="maxUploadSize" value="209715200" />
        <!-- 设置每个上传文件的大小上限 1024*1024*2 2M -->
        <property name="maxUploadSizePerFile" value="2019152"/>
        <!-- 处理文件名中文乱码 -->
        <property name="defaultEncoding" value="UTF-8" />
        <!-- resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常 -->
        <property name="resolveLazily" value="true" />
    </bean>

</beans>

web.xml

在web.xml中配置了初始化spring容器的监听器，以及前端控制器和编码过滤器

<?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">

    <!-- spring 核心配置文件位置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 服务启动监听，web应用启动的时候初始化Spring核心IOC容器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 配置前端控制器 -->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 配置字符集编码过滤器 -->
    <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>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

这样ssm整合的基本配置已经完成了，接下来我们对用户表进行增删改查，来验证我们ssm整合是否正确可行。
我们上面在配置数据源的时候，指定连接到ssm数据库，所有我们先创建ssm数据库，再在其中创建用户表。

用户表语句

我们通过下面sql语句创建用户表并插入6条记录

create database if no exist `ssm`;
use `ssm`;
CREATE TABLE `users` (
  `uid` int(10) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `uname` varchar(255) DEFAULT NULL COMMENT '用户姓名',
  `pwd` varchar(255) DEFAULT NULL COMMENT '用户密码',
  `sex` int(1) DEFAULT NULL COMMENT '用户性别，1：男，0：女',
  `age` int(3) DEFAULT NULL COMMENT '用户年龄',
  PRIMARY KEY (`uid`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO users VALUES(1,"张三","zs",1,21);
INSERT INTO users VALUES(2,"李四","ls",0,18);
INSERT INTO users VALUES(3,"王五","ww",0,20);
INSERT INTO users VALUES(4,"赵六","zl",1,26);
INSERT INTO users VALUES(5,"十七","sq",0,22);
INSERT INTO users VALUES(6,"阿什","as",1,25);

用户实体类

在类上面我们使用Lombok的@Data注解帮我们简化代码，该注解会自动生成getter、setter、toString等方法

@Data
public class User {
    private Integer uid;
    private String uname;
    private String pwd;
    private Integer sex;
    private Integer age;
}

UserMapper

这是操作用户表数据的持久化接口，使用注解的方式实现，

public interface UserMapper  {
    
    //查询全部用户
    @Select("select * from users")
    List<User> selectAll();

    //根据id查询用户
    @Select("select *  from users where uid = #{uid}")
    User selectByPrimaryKey(Integer uid);
    
    //根据id修改用户
    void updateByPrimaryKeySelective(User user);
    
    //保存用户
    void insertSelective(User user);
    
    //根据id删除用户
    @Delete("delete from users where uid = #{uid}")
    void deleteByPrimaryKey(Integer uid);
}

UserService与UserServiceImpl

UserService

public interface UserService {
    /*查询所有用户*/
    List<User> queryAllUser();

    /*根据用户id查询用户*/
    User queryUserByUid(Integer uid);

    /*根据用户id修改用户信息*/
    void updateUserByUid(User user);

    /*添加用户*/
    void addUser(User user);

    /*根据用户id删除用户*/
    void deleteUserByUids(Integer[] uids);
}

UserServiceImpl
我们在类上加入@Transactional表明启动注解式事务

@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

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

    @Override
    public User queryUserByUid(Integer uid) {
        return userMapper.selectByPrimaryKey(uid);
    }

    @Override
    public void updateUserByUid(User user) {
        userMapper.updateByPrimaryKeySelective(user);
    }

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

    /*根据用户id删除用户*/
    @Override
    public void deleteUserByUids(Integer[] uids) {
        /*Stream流+方法引用+lambda表达式简化删除代码*/
        Stream.of(uids).forEach(userMapper::deleteByPrimaryKey);
    }
}

UserController

我们知道在类上加入@Controller注解表示该类是控制器，用来接收并响应客户端的请求。
而@RestController是由@Controller和@ResponseBody组成，表示该类中的所有方法都是返回Json数据。

在这里插入图片描述

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

    @Autowired
    private UserService userService;

    /*查询所有用户*/
    @RequestMapping("/queryAllUser")
    public List<User> queryAllUser() {
        return userService.queryAllUser();
    }

    /*根据用户id查询用户*/
    @RequestMapping("/queryUserByUid/{uid}")
    public User queryUserByUid(@PathVariable("uid") Integer uid) {
        return userService.queryUserByUid(uid);
    }

    /*根据用户id修改用户信息*/
    @RequestMapping("/updateUserByUid")
    public boolean updateUserByUid(User user) {
        try {
            userService.updateUserByUid(user);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /*添加用户*/
    @RequestMapping("/addUser")
    public Boolean addUser(User user) {
        try {
            userService.addUser(user);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /*根据用户id删除用户*/
    @RequestMapping("/deleteUserByUids")
    public Boolean deleteUserByUids(Integer[] uids) {
        try {
            userService.deleteUserByUids(uids);
            return true;
        }catch (Exception e){
            return false;
        }
    }
}

我们使用postman工具来测试我们上面方法的效果。Postman工具是专门用来向服务器发起请求，然后得到最原始的响应数据。

我们先测试查询全部用户的接口：http://localhost:8080/ssm/user/queryAllUser

在这里插入图片描述

剩下的几个方法也测试过，是????的。这样我们就把ssm整合完毕，并且通过对用户模块的操作验证了是可行的，以后需要使用ssm框架的时候，也可以拿这个来当ssm框架的基本骨架。
这次整合ssm框架的源码

上一篇： SSM三大框架基础面试题-一、Spring篇什么是Spring框架？ Spring是一种轻量级框架，提高开发人员的开发效率以及系统的可维护性。我们一般说的Spring框架就是Spring Framework，它是很多模块的集合，使用这些模块可以很方便地协助我们进行开发。这些模块是核心容器、数据访问/集成、Web、AOP（面向切面编程）、工具、消息和测试模块。比如Core Container中的Core组件是Spring所有组件的核心，Beans组件和Context组件是实现IOC和DI的基础，AOP组件用来实现面向切面编程。 Spring的6个特征：核心技术：依赖注入（DI），AOP，事件（Events），资源，i18n，验证，数据绑定，类型转换，SpEL。测试：模拟对象，TestContext框架，Spring MVC测试，WebTestClient。数据访问：事务，DAO支持，JDBC，ORM，编组XML。 Web支持：Spring MVC和Spring WebFlux Web框架

下一篇：什么是Java SSM架构?

深入浅出详解SSM框架整合全过程

SSM整合所需要的依赖

log4j2.xml

db.properties

applicationContext.xml

springmvc.xml

web.xml

用户表语句

用户实体类

UserMapper

UserService与UserServiceImpl

UserController

SSM框架整合指南：配置文件与纯注解两种实现方式详解

深入浅出详解SSM框架整合全过程

用SSM框架实现Java中的 CRUD 操作流程详解

深入浅出SSM框架详解（最全面易懂的指南）

零基础新手指南：一步步详解2021 IDEA搭建SSM框架实战教程(第一部分)

简单易懂！详解SSM框架的工作机制与实施步骤

2022年SSM整合深度学习指南与实战笔记详解

深入浅出详解SSM架构教程 - 史上最全面易懂指南

ssm框架整合

SSM架构详解与整合要点简介