SSM（Spring+Spring MVC+MyBatis）框架整合搭建详细步骤

朱雀 2020-02-01 10:22 2581阅读 0赞

SSM（Spring+Spring MVC+MyBatis）框架整合搭建详细步骤

因为 Spring MVC 是 Spring 框架中的一个子模块，所以 Spring 与 SpringMVC 之间不存在整合的问题。实际上，SSM 框架的整合只涉及 Spring 与 MyBatis 的整合以及 Spring MVC 与 MyBatis 的整合。

实现 SSM 框架的整合首先需要准备 3 个框架的 JAR 包以及其他整合所需要的 JAR 包。

在《MyBatis与Spring的整合步骤》教程中已经讲解了 Spring 与 MyBatis 框架整合所需要的 JAR 包，本节只需再加入 Spring MVC 的相关 JAR 包（spring-web-3.2.13.RELEASE.jar 和 spring-webmvc-3.2.13.RELEASE.jar）即可。因此，SSM 框架整合所需的 JAR 包如图 1 所示。

ssm框架整合所需JAR包
图 1 ssm 框架整合所需 JAR 包

SSM 框架整合应用测试

下面是一个应用案例（根据用户名模糊查询用户信息，用户表是《第一个MyBatis程序》教程中的数据表 user），使用 SSM 框架实现该案例的具体步骤如下：

1. 创建应用并导入相关 JAR 包

创建应用 ssm，将图 1 所示的 JAR 包复制到应用的 lib 中。

2. 创建信息输入页面

在 WebContent 目录下创建 input.jsp 页面，具体代码如下：

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  4. <html>
  5. <head>
  6. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  7. <title>Insert title here</title>
  8. </head>
  9. <body>
  10.     <form action="${pageContext.request.contextPath }/select" method="post">
  11.         输入用户名：<input type="text" name="uname"/><br>
  12.         <input type="submit" value="提交"/>
  13.     </form>
  14. </body>
  15. </html>

3. 创建持久化类

在 src 目录下创建一个名为 com.po 的包，并在该包中创建一个 PO 类 MyUser。具体代码如下：

  1. package com.po;
  2. /**
  3. * mybatis数据库中user表的持久化类
  4. */
  5. public class MyUser {
  6.     private Integer uid;
  7.     private String uname;
  8.     private String usex;
  9.     public Integer getUid() {
  10.         return uid;
  11.     }
  12.     public void setUid(Integer uid) {
  13.         this.uid = uid;
  14.     }
  15.     public String getUname() {
  16.         return uname;
  17.     }
  18.     public void setUname(String uname) {
  19.         this.uname = uname;
  20.     }
  21.     public String getUsex() {
  22.         return usex;
  23.     }
  24.     public void setUsex(String usex) {
  25.         this.usex = usex;
  26.     }
  27. }

4. 创建 Dao 层

在 src 目录下创建一个名为 com.dao 的包，并在该包中创建一个名为 UserDao 的接口。具体代码如下：

  1. package com.dao;
  2. import java.util.List;
  3. import org.springframework.stereotype.Repository;
  4. import com.po.MyUser;
  5. @Repository("userDao")
  6. /*
  7. * 使用Spring自动扫描MyBatis的接口并装配 （Spring将指定包中所有被@Mapper注解标注的接口自动装配为Mybatis的映射接口
  8. */
  9. public interface UserDao {
  10.     /**
  11.      * 接口方法对应SQL映射文件UserMapper.xml中的id
  12.      */
  13.     public List<MyUser> selectUserByUname(MyUser user);
  14. }

5. 创建 Service 层

在 src 目录下创建一个名为 com.service 的包，并在该包中创建一个名为 UserService 的接口和该接口的实现类 UserServiceImpl。

UserService 接口的代码如下：

  1. package com.service;
  2. import java.util.List;
  3. import com.po.MyUser;
  4. public interface UserService {
  5.     public List<MyUser> selectUserByUname(MyUser user);
  6. }

UserServiceImpl 实现类的代码如下：

  1. package com.service;
  2. import java.util.List;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Service;
  5. import org.springframework.transaction.annotation.Transactional;
  6. import com.dao.UserDao;
  7. import com.po.MyUser;
  8. @Service("userService")
  9. @Transactional
  10. /**
  11. * 加上注解@Transactional可以指定这个类需要受Spring的事务管理，
  12. *注意@Transactional只能针对public属性范围内的方法添加，
  13. *本案例并不需要处理事务，在这里只是告诉读者如何使用事务
  14. */
  15. public class UserServiceImpl implements UserService {
  16.     @Autowired
  17.     private UserDao userDao;
  18.     @Override
  19.     public List<MyUser> selectUserByUname(MyUser user) {
  20.         return userDao.selectUserByUname(user);
  21.     }
  22. }

6. 创建 Controller 层

在 src 目录下创建一个名为 com.controller 的包，并在该包中创建一个名为 UserController 的控制器类。具体代码如下：

  1. package com.controller;
  2. import java.util.List;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.stereotype.Controller;
  5. import org.springframework.ui.Model;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import com.dao.UserDao;
  8. import com.po.MyUser;
  9. @Controller
  10. public class UserController {
  11.     @Autowired
  12.     private UserDao userDao;
  13.     @RequestMapping("/select")
  14.     public String select(MyUser user, Model model) {
  15.         List<MyUser> list = userDao.selectUserByUname(user);
  16.         model.addAttribute("userList", list);
  17.         return "userList";
  18.     }
  19. }

7. 创建用户信息显示页面

在 WEB-INF 目录下创建文件夹 JSP，并在该文件夹下创建用户信息显示页面 userList. jsp。具体代码如下：

  1. <%@ page language="java" contentType="text/html; charset=UTF-8"
  2.     pageEncoding="UTF-8"%>
  3. <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
  4. <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  5. <html>
  6. <head>
  7. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  8. <title>Insert title here</title>
  9. </head>
  10. <body>
  11.     用户信息
  12.     <br>
  13.     <c:forEach items="${userList }" var="user">
  14.     ${user.uid }&nbsp;&nbsp;&nbsp;&nbsp;
  15.     ${user.uname }&nbsp;&nbsp;&nbsp;&nbsp;
  16.     ${user.usex }<br>
  17.     </c:forEach>
  18. </body>
  19. </html>

8. 创建相关配置文件

1）web.xml

在 WEB-INF 目录下创建 web.xml 文件，并在该文件中实例化 ApplicationContext 容器、启动 Spring 容器、配置 DispatcherServlet 以及配置字符编码过滤器。具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns="http://java.sun.com/xml/ns/javaee"
  4.     xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  6.     version="3.0">
  7.     <display-name>springMVC</display-name>
  8.     <welcome-file-list>
  9.         <welcome-file>index.jsp</welcome-file>
  10.     </welcome-file-list>
  11.     <!-- 实例化ApplicationContext容器 -->
  12.     <context-param>
  13.         <!-- 加载src目录下的 applicationContext-*.xml文件-->
  14.         <param-name>contextConfigLocation</param-name>
  15.         <param-value>classpath:applicationContext-*.xml</param-value>
  16.     </context-param>
  17.     <filter>
  18.         <filter-name>encodingFilter</filter-name>
  19.         <filter-class>
  20.             org.springframework.web.filter.CharacterEncodingFilter
  21.         </filter-class>
  22.         <init-param>
  23.             <param-name>encoding</param-name>
  24.             <param-value>UTF-8</param-value>
  25.         </init-param>
  26.         <init-param>
  27.             <param-name>forceEncoding</param-name>
  28.             <param-value>true</param-value>
  29.         </init-param>
  30.     </filter>
  31.     <filter-mapping>
  32.         <filter-name>encodingFilter</filter-name>
  33.         <url-pattern>/*</url-pattern>
  34.     </filter-mapping>
  35.     <servlet>
  36.         <servlet-name>spring</servlet-name>
  37.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  38.         <init-param>
  39.             <param-name>contextConfigLocation</param-name>
  40.             <param-value>classpath:springmvc-servlet.xml</param-value>
  41.         </init-param>
  42.         <load-on-startup>1</load-on-startup>
  43.     </servlet>
  44.     <servlet-mapping>
  45.         <servlet-name>spring</servlet-name>
  46.         <url-pattern>/</url-pattern>
  47.     </servlet-mapping>
  48.     <listener>
  49.         <listener-class>
  50.             org.springframework.web.context.ContextLoaderListener
  51.         </listener-class>
  52.     </listener>
  53.     <listener>
  54.         <listener-class>
  55.             org.springframework.web.util.Log4jConfigListener
  56.         </listener-class>
  57.     </listener>
  58. </web-app>

2）springmvc-servlet.xml

在 WEB-INF 目录下创建 Spring MVC 的核心配置文件 springmvc-servlet.xml，在该文件中仅配置控制器扫描包和视图解析器，具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.     xmlns:mvc="http://www.springframework.org/schema/mvc"
  5.     xmlns:p="http://www.springframework.org/schema/p" 
  6.     xmlns:context="http://www.springframework.org/schema/context"
  7.     xsi:schemaLocation="
  8.         http://www.springframework.org/schema/beans
  9.         http://www.springframework.org/schema/beans/spring-beans.xsd
  10.         http://www.springframework.org/schema/context
  11.         http://www.springframework.org/schema/context/spring-context.xsd
  12.         http://www.springframework.org/schema/mvc
  13.         http://www.springframework.org/schema/mvc/spring-mvc.xsd">
  14.     <!-- 使用扫描机制扫描包 -->
  15.     <context:component-scan base-package="com.controller" />
  16.     <!-- 完成视图的对应 -->
  17.     <!-- 对转向页面的路径解析。prefix：前缀， suffix：后缀 -->
  18.     <bean
  19.         class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  20.         <property name="prefix" value="/WEB-INF/jsp/" />
  21.         <property name="suffix" value=".jsp" />
  22.     </bean>
  23. </beans>

3）log4j.properties

在 src 目录下创建 MyBatis 的日志文件 log4j.properties，具体代码如下：

  1. \# Global logging configuration
  2. log4j.rootLogger=ERROR,stdout
  3. \# MyBatis logging configuration...
  4. log4j.logger.com.mybatis=DEBUG
  5. \# Console output...
  6. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  7. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  8. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

4）applicationContext.xml

在 src 目录下创建 Spring 的配置文件 applicationContext.xml，在该文件中配置数据源、添加事务支持、开启事务注解、配置 MyBatis 工厂、进行 Mapper 代理开发以及指定扫描包。具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.     xmlns:aop="http://www.springframework.org/schema/aop"
  5.     xmlns:p="http://www.springframework.org/schema/p" 
  6.     xmlns:tx="http://www.springframework.org/schema/tx"
  7.     xmlns:context="http://www.springframework.org/schema/context"
  8.     xsi:schemaLocation="  
  9.             http://www.springframework.org/schema/beans 
  10.             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  11.             http://www.springframework.org/schema/aop 
  12.             http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
  13.             http://www.springframework.org/schema/tx 
  14.             http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
  15.             http://www.springframework.org/schema/context
  16.             http://www.springframework.org/schema/context/spring-context.xsd">
  17.     <!--配置数据源 -->
  18.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
  19.         destroy-method="close" scope="singleton">
  20.         <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  21.         <property name="url"
  22.             value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" />
  23.         <property name="username" value="root" />
  24.         <property name="password" value="1128" />
  25.         <property name="maxTotal" value="30" />
  26.         <property name="maxIdle" value="10" />
  27.         <property name="initialSize" value="5" />
  28.     </bean>
  29.     <!-- 添加事务支持 -->
  30.     <bean id="txManager"
  31.         class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  32.         <property name="dataSource" ref="dataSource" />
  33.     </bean>
  34.     <!-- 开启事务注解 -->
  35.     <tx:annotation-driven transaction-manager="txManager" />
  36.     <!-- 配置mybitas工厂，同时指定数据源，并与MyBatis完美整合 -->
  37.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  38.         <property name="dataSource" ref="dataSource" />
  39.         <!-- configLocation的属性值为Mybatis的核心配置文件 -->
  40.         <property name="configLocation" value="classpath:mybatis-config.xml" />
  41.     </bean>
  42.     <!-- Mapper代理开发，使用Spring自动扫描Mybatis的接口并装配 -->
  43.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  44.         <!-- mybatis-spring组件的扫描器 -->
  45.         <property name="basePackage" value="com.dao" />
  46.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
  47.     </bean>
  48.     <!-- 指定需要扫描的包（包括子包），使注解生效。dao包在mybatis-spring组件中已经扫描，这里不在需要扫描 -->
  49.     <context:component-scan base-package="com.service" />
  50. </beans>

5）创建 MyBatis 的核心配置文件和 SQL 映射文件

在 src 目录下创建 com.mybatis 文件夹，并在该文件夹中创建 MyBatis 的核心配置文件 mybatis-config.xml。具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <!DOCTYPE configuration  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5.     <mappers><!-- 映射器告诉MyBatis到哪里去找映射文件 -->
  6.         <mapper resource="com/dao/UserMapper.xml" />
  7.     </mappers>
  8. </configuration>

在 com.mybatis 文件夹中创建 SQL 映射文件 UserMapper.xml。具体代码如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <mapper namespace="com.dao.UserDao">
  5.     <select id="selectUserByUname" resultType="com.po.MyUser"
  6.         parameterType="com.po.MyUser">
  7.         select * from user where 1=1
  8.         <if test="uname!=null and uname!=''">
  9.             and uname like concat('%',#{uname},'%')
  10.         </if>
  11.     </select>
  12. </mapper>

9. 发布并运行应用

首先将 springMVCDemo11 应用发布到 Tomcat 服务器并启动 Tomcat 服务器，然后通过地址“http://localhost:8080/ssm/input.jsp”访问信息输入页面，运行结果如图 2 所示。

信息输入页面
图 2 信息输入页面

在图 2 中输入用户名，例如“张”，然后单击“提交”按钮，显示如图 3 所示的结果。

用户列表页面
图 3 用户列表页面

发表评论

表情：
评论列表 （有 0 条评论，2581人围观）

还没有评论，来说两句吧...

相关阅读