前言

ssm指的是Spring框架+SpringMVC框架+MyBatis框架的整合开发,也是目前JavaWeb开发比较火的框架整合开发技术。在此简单记录下其环境的搭建过程。

开发环境

所用IDE为IntelliJ IDEA,项目管理Maven,服务器为Tomcat，本例使用Maven管理项目，项目所需的包依赖只需在pom.xml配置文件中添加相应的包的依赖坐标即可，Maven会自动帮我们把相关的包添加到项目中，也可以手动添加到开发环境中，此处只讲解Maven包管理的方式。

思路

整合思路大概是，先搭建好spring的环境，再通过spring框架去整合SpringMVC框架与MyBatis框架，现在开始配置相应的环境。

1.搭建Spring的开发环境

1.1、打开IDEA,新建一个Maven的webapp模板工程ssm，模板要选择maven-archetype-webapp选项，输入相应的项目名等创建好项目之后，在pom.xml配置文件中输入下面SSM整合所需的依赖坐标，maven会自动给我们项目添加相应的jar包。

1.2、在pom.xml文件的properties标签内加入如下依赖坐标的版本限定代码，方便管理依赖的版本号

    <spring.version>5.0.16.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
    <aspectj.version>1.6.8</aspectj.version>
    <junit.version>4.12</junit.version>

1.3、添加完版本限定后，在dependencies标签中添加依赖坐标。坐标可以参考下面坐标代码

 <dependency>
      <!-- Spring相关依赖坐标开始-->
      <!--spring容器-->
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>

      <!--spring aop-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>${aspectj.version}</version>
    </dependency>

    <!--spring mvc -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--测试支持-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--spring jdbc模板技术-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!--事务-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Spring依赖坐标结束-->

    <!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <!--jsp-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>

    <!--jsp页面提供el表达式支持-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

    <!--mybatis框架-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <!--用于spring整合mybatis-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>

    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>

    <!--连接池c3p0-->
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>

    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>compile</scope>
    </dependency>

1.4、创建实体类Users、Users的dao接口UsersDao、UsersDao的dao接口的实现类UsersDaoImpl、业务接口UsersService、业务接口UsersService的实现类UsersServiceImpl。本实例使用Spring的注解+xml方式配置。如果业务接口实现类中使用spring的注解注入UsersDao的对象到UsersServiceImpl实现类中，并且可以通过注入的对象访问到UsersDao接口中的方法，则表明Spring环境搭建成功
1.4.1、Users.java类的主要实现代码

/**
 * 账号实体类
 */
public class Users implements Serializable {
    private String userName;//用户名
    private String password;//密码
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "Users{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

1.4.2、UsersDao.java的主要实现代码

/**
 *用户的dao接口
 * 使用mybatis框架，dao接口可以不用实现例
 */
public interface UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    public List<Users> findAll();
    /**
     * 添加用户
     * @param users
     */
    public void saveUser(Users users);
}

1.4.3、UsersDaoImpl.java的主要实现代码

/**
 * UserDao接口的实现类
 */
@Repository
public class UsersDaoImpl implements UsersDao {
    /**
     * 查询所有用户
     *
     * @return
     */
    @Override
    public List<Users> findAll() {
        System.out.println("UsersDaoImpl类的findAlll方法执行了...");
        return null;
    }
    /**
     * 添加用户
     *
     * @param users
     */
    @Override
    public void saveUser(Users users) {
        System.out.println("UsersDaoImpl类的saveUser方法执行了...");
    }
}

1.4.4、业务接口UsersService.java的主要实现代码

/**
 * 用户的业务接口
 */
public interface UsersService {
    /**
     * 查询所有用户
     * @return
     */
    public List<Users> findAll();
    /**
     * 添加用户
     * @param users
     */
    public void saveUser(Users users);
}

1.4.5、业务接口的实现类UsersServiceImpl.java的主要实现代码

/**
 * 用户业务接口的实现类
 */
@Service("usersService")
public class UsersServiceImpl implements UsersService {
    @Autowired
    private UsersDao usersDao;
    /**
     * 查询所有用户
     *
     * @return
     */
    @Override
    public List<Users> findAll() {
        usersDao.findAll();
        System.out.println("UserServiceImpl类的findAll方法执行了。。。");
        return null;
    }
    /**
     * 添加用户
     *
     * @param users
     */
    @Override
    public void saveUser(Users users) {
        usersDao.saveUser(users);
        System.out.println("UserServiceImpl类的saveUser方法执行了。。。.");
    }
}

1.4.6、spring配置文件applicationContext.xml代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--   配置spring加载包扫描-->
    <context:component-scan base-package="com.pankx">
    <!--配置不加载的注解Controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

1.4.7、Spring的测试类TestSpring代码如下

 @Test
    public void testSpring(){
        //加载spring配置文件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        //获取UserService对象
        UsersService usersService = applicationContext.getBean("usersService", UsersService.class);
        usersService.findAll();
        Users users = new Users();
        usersService.saveUser(users);
    }

运行测试类控制台输入如下内容，表明Spring环境搭建成功

UsersDaoImpl类的findAlll方法执行了...
UserServiceImpl类的findAll方法执行了。。。
UsersDaoImpl类的saveUser方法执行了...
UserServiceImpl类的saveUser方法执行了。。。.

2、SpringMVC环境搭建

2.1、在ssm项目上创建SpringMVC配置文件，控制器类UsersController、testSpringmvc.jsp测试页面，如果通过测试页面的请求连接，能访问到控制器类中的方法表示SpringMVC环境搭建成功。

2.2、SpringMVC配置文件springmvc.xml主要配置包扫描、视图解析器等，具体配置如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       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
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--配置包扫描,只扫描controller-->
        <context:component-scan base-package="com.pankx">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>

    <!--配置视图解析器-->
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/WEB-INF/pages/"/>
            <property name="suffix" value=".jsp"/>
        </bean>
    <!--开启springmvc注解支持-->
        <mvc:annotation-driven/>

2.3、在web.xml配置文件中配置前端控制器、处理中文乱码的过滤器，具体配置如下

<!--处理post请求中文乱码-->
  <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>
  </filter>
  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

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

2.4、控制器类UsersController.java主要实现代码如下

/**
 * Users控制器类
 */
@Controller
@RequestMapping("/user")
public class UsersController {
    @RequestMapping("/testSpringmvc")
    public String testSpringmvc(){
        System.out.println("UsersController类的testSpringmvc方法执行了");
        //返回success经视图解析器解析将跳转到/WEB-INF/pages/目录下的success.jsp页面
        return "success";
    }
}

2.5、测试页面testSpringmvc.jsp的主要代码实现如下

    <h1>测试SpringMVC环境</h1>
    <hr/>
    <a href="user/testSpringmvc">测试SpringMVC环境</a>

2.6、配置好Tomcat服务器把项目部署到服务并访问testSpringmvc.jsp页面中的超链接即可成功跳线到success.jsp页面，表明SpringMVC环境搭建成功。

3、Spring整合SpringMVC框架

3.1、Spring整合SpringMVC框架也就是要实现表现层的springmvc框架可以访问到业务层的方法，由于服务器启动不会主动加载spring的配置文件，所以控制器类实现不了UsersService对象的注入，因此Spring要整合SpringMVC就要实现项目启动时就要加载spring的配置文件，可以用配置ContextLoaderListener监听器实现。
3.2、web.xml文件的监听器配置代码如下

  <!--配置spring监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--配置监听器加载指定的路径，默认只加载目录WEB-INF目录下的applicationContext.xml配置文件-->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

3.3、控制器类UsersController编辑UsersService对象注入与及testfindAll方法验证通过页面请求使用入注入的对象访问业务层的方法。
3.3.1、UsersController.java主要代码实现

    @Autowired
    private UsersService usersService;
    /**
     * 测试springmvc环境
     * @return
     */
    @RequestMapping("/testSpringmvc")
    public String testSpringmvc(){
        System.out.println("UsersController类的testSpringmvc方法执行了");
        //返回success经视图解析器解析将跳转到/WEB-INF/pages/目录下的success.jsp页面
        return "success";
    }
    /**
     *
     * @return
     */
    @RequestMapping("/testfindAll")
    public String testfindAll(){
        System.out.println("UsersController类的testfindAll方法执行了");
        usersService.findAll();
        return "list";
    }

3.4、如果通过testspringmvc.jsp页面的链接请求控制器的testfindAll方法执行，如果成功跳转到list.jsp页面，并且控制台输出业务层方法打印的方法中执行输出的日志表明整合成功。
3.4.1、testspringmvc.jsp主要代码如下

    <h1>测试SpringMVC环境</h1>
    <hr/>
    <a href="user/testSpringmvc">测试SpringMVC环境</a>
    <hr/>
    <a href="user/testfindAll">测试Spring整合SpringMVC环境</a>

3.4.2、测试成功控制台输出的信息

UsersController类的testfindAll方法执行了
UsersDaoImpl类的findAlll方法执行了...
UserServiceImpl类的findAll方法执行了。。。

至此Spring整合SpringMVC已经完成，下面继续MyBatis框架的相关环境搭建。

4、MyBatis环境搭建

4.1、创建ssm数据库与users表的命令如下

CREATE DATABASE ssm;
CREATE TABLE users (id INT(11) PRIMARY KEY AUTO_INCREMENT,username VARCHAR(20),password VARCHAR(30));
INSERT INTO users VALUES(null,"pankx","123456");

4.2、创建mybatis.xml配置文件，配置mysql的环境，具体配置如下

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
<!--    配置环境-->
        <environments default="mysql">
            <environment id="mysql">
                <!--事务类型-->
                <transactionManager type="jdbc"/>
                <!--数据源-->
                <dataSource type="POOLED">
                    <!--驱动-->
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <!--数据库地址-->
                    <property name="url" value="jdbc:mysql://localhost/ssm"/>
                    <!--用户名-->
                    <property name="username" value="root"/>
                    <!--密码-->
                    <property name="password" value="Pankx0128"/>
                </dataSource>
            </environment>
        </environments>

<!--    引入映射文件-->
    <mappers>
        <!--由于使用注解，所以引入注解包目录-->
        <package name="com.pankx.dao"/>
    </mappers>
    </configuration>

4.2.1、给UsersDao类中方法加载mybatis的相应注解，使用MyBatis框架Dao接口可以不需要实现类，因此删除UserDao的实现类文件UsersDaoImpl.java。
4.2.2、dao接口类UsersDao.java的主要代码实现如下

/**
 *用户的dao接口
 * 使用mybatis框架，dao接口可以不用实现例
 */
public interface UsersDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("SELECT * FROM users")
    public List<Users> findAll();

    /**
     * 添加用户
     * @param users
     */
    @Insert("INSERT INTO users (username,password) VALUES(#{userName},#{password})")
    public void saveUser(Users users);
}

4.3.1、创建TestMyBatis.java测试类测试MyBatis的配置环境，如果能成功操作mysql数据库，表明MyBatis环境搭建成功
4.3.2、TestMyBatis.java的主要实现代码如下代码主要实现查询数据库的所有数据和向数据库新增一条数据

public class TestMyBatis {
    @Test
    public void testMyBatis() throws IOException {
        //加载配置文件
       InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //获取SqlSession对象
        SqlSession session = sqlSessionFactory.openSession();
        //获取代理对象
        UsersDao usersDao = session.getMapper(UsersDao.class);
        //执行查询方法
        List<Users> list = usersDao.findAll();
        for(Users users:list){
            System.out.println(users);
        }
        Users users = new Users();
        users.setUserName("test1");
        users.setPassword("test123456");
        //执行新增用户方法
        usersDao.saveUser(users);
        //提交事务
        session.commit();
        //关闭资源
        session.close();
        inputStream.close();

    }
}

4.3.3、测试类执行成功控制台将输出如下信息，这条记录是创建数据库时添加的，所以可以查询到。

Users{userName='pankx', password='123456'}

4.3.4、查看数据库可以看到成功插入了一条username为test1的记录。

mysql> select * from users;
+----+----------+------------+
| id | username | password   |
+----+----------+------------+
|  1 | pankx    | 123456     |
|  2 | test1    | test123456 |
+----+----------+------------+

4.3.5、因此到这里MyBatis的开发环境搭建成功，接下来就是用Spring整合MyBatis。

5、Spring整合MyBatis

5.1、Spring要整合MyBatis只需Spring的配置文件中完成MyBatis的相关配置,配置数据库连接池、SqSessionFactory工厂Bean，使用MapperScannerConfigurer来配置Dao接口所在的包。具体配置如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--   配置spring加载包扫描-->
    <context:component-scan base-package="com.pankx">
    <!--配置不加载的注解Controller-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--spring整合MyBatis-->
    <!--配置连接池，此例使用c3p0连接池技术-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost/ssm"/>
        <property name="user" value="root"/>
        <property name="password" value="Pankx0128"/>
    </bean>
    <!--配置SqlSessionFactory工厂bean-->
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--传入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置dao接口的包路径-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.pankx.dao"/>
    </bean>

</beans>

5.2、配置好MyBatis后要把之前单独搭建时创建的mybatis.xml配置文件删除了，避免重复配置报错。
5.3、创建testmybatis.jsp页面与userslist.jsp页面，通过请求方式测试MyBatis的整合环境，此处主要测试数据库的查询，如果环境搭建成功，则可以在userslist.jsp页面显示查询到的用户数据。
5.3.1、testmybatis.jsp页面的主要代码实现如下

    <h1>测试Spring整合MyBatis</h1>
    <hr/>
    <a href="user/testfindAll">测试Spring整合MyBatis</a>

5.3.2、userslist.jsp页面的主要代码实现如下

    <c:forEach items="${userslist}" var="user">
        ${user}<br/>
    </c:forEach>

5.3.3、本实例经过测试可以正常显示查询到的数据，具体可以查看项目源码。
5.4、给项目加入声明式事务管理，具体在spring的配置文件中加入下面代码即可

 <!--配置事务管理-->
    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--配置通知-->
    <tx:advice id="transactionInterceptor" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
    <!--配置aop增强-->
    <aop:config>
        <aop:advisor advice-ref="transactionInterceptor" pointcut="execution(* com.pankx.service.*ServiceImpl.*(..))"/>
    </aop:config>
    <!--配置dao接口的包路径-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.pankx.dao"/>
    </bean>

5.5、到此ssm整合开发环境搭建完成,具体可以参考项目源代码:https://github.com/pkx0128/ssm

欢迎关注我的公众号