通过项目细说SSM整合开发环境搭建

前言

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.RELEASEspring.version>
    <slf4j.version>1.6.6slf4j.version>
    <log4j.version>1.2.17log4j.version>
    <mysql.version>5.1.6mysql.version>
    <mybatis.version>3.4.5mybatis.version>
    <aspectj.version>1.6.8aspectj.version>
    <junit.version>4.12junit.version>

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

 <dependency>
      
      
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-contextartifactId>
      <version>${spring.version}version>
    dependency>

      
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-aopartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>${aspectj.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webartifactId>
      <version>${spring.version}version>
    dependency>
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-webmvcartifactId>
      <version>${spring.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>${spring.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>${spring.version}version>
    dependency>

    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-txartifactId>
      <version>${spring.version}version>
    dependency>
    

    
    <dependency>
      <groupId>javax.servletgroupId>
      <artifactId>servlet-apiartifactId>
      <version>2.5version>
      <scope>providedscope>
    dependency>

    
    <dependency>
      <groupId>javax.servlet.jspgroupId>
      <artifactId>jsp-apiartifactId>
      <version>2.0version>
      <scope>providedscope>
    dependency>

    
    <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatisartifactId>
      <version>${mybatis.version}version>
    dependency>

    
    <dependency>
      <groupId>org.mybatisgroupId>
      <artifactId>mybatis-springartifactId>
      <version>1.3.0version>
    dependency>

    
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>${mysql.version}version>
    dependency>

    
    <dependency>
      <groupId>c3p0groupId>
      <artifactId>c3p0artifactId>
      <version>0.9.1.2version>
      <type>jartype>
      <scope>compilescope>
    dependency>

    
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>${junit.version}version>
      <scope>compilescope>
    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代码

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

    
    <context:component-scan base-package="com.pankx">
    
        <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主要配置包扫描、视图解析器等，具体配置如下

<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">
    
        <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>
    
        <mvc:annotation-driven/>

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

  <filter>
    <filter-name>characterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
      <param-name>encodingparam-name>
      <param-value>UTF-8param-value>
    init-param>
  filter>
  <filter-mapping>
    <filter-name>characterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>

  
  <servlet>
    <servlet-name>dispatcherServletservlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    
    <init-param>
      <param-name>contextConfigLocationparam-name>
      <param-value>classpath:springmvc.xmlparam-value>
    init-param>
    <load-on-startup>1load-on-startup>
  servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServletservlet-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文件的监听器配置代码如下

  
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>
  
  <context-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>classpath:applicationContext.xmlparam-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的环境，具体配置如下

    <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接口所在的包。具体配置如下

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

    
    <context:component-scan base-package="com.pankx">
    
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    context:component-scan>

    
    
    <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>
    
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="dataSource"/>
    bean>

    
    <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整合MyBatish1>
    <hr/>
    <a href="user/testfindAll">测试Spring整合MyBatisa>

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:config>
        <aop:advisor advice-ref="transactionInterceptor" pointcut="execution(* com.pankx.service.*ServiceImpl.*(..))"/>
    aop:config>
    
    <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
           

关注我的公众号