SSM框架整合(超详细讲解)

作者: JTravler | 来源:发表于2020-03-04 15:52 被阅读0次

我们都知道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框架整合(超详细讲解)

SSM整合所需要的依赖

log4j2.xml

db.properties

applicationContext.xml

springmvc.xml

web.xml

用户表语句

用户实体类

UserMapper

UserService与UserServiceImpl

UserController

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java web