乐趣区

关于java:SSM三大框架的整合

jiezi

好好学习，天天向上

文本已收录至我的 Github 仓库 DayDayUP：github.com/RobodLee/DayDayUP，欢送 Star，更多文章请返回：目录导航

在 Java 后端开发畛域，Spring+SpringMVC+MyBatis 三大框架的应用尤为频繁，很多敌人学了这三个框架却不晓得怎么整合起来，本文将带着大家一步步的实现三大框架的整合。我也是初学者，写作本文的目标一方面是想让大家少走点弯路，还有一方面是为了加深本人对于这三大框架的了解。整合的思路是以 Spring 框架为外围去整合 SpringMVC 和 MyBatis 框架。首先咱们须要创立一个我的项目并且筹备好测试用的数据库。

一. 筹备工作

怎么创立 Maven 工程我置信大家都会，我就不再赘述了，不会的敌人请自行百度。
我创立了一个叫 SSMTest 的我的项目，而后应用 MySQL 创立了一个叫 ssmtest 的数据库并且创立了一张 user 表，为了节俭大家的工夫，我将 sql 语句粘贴在这里：

create database ssmtest;
use ssmtest;
create table user(
id int primary key auto_increment,
name varchar(20),
age int
);

而后就须要筹备好所需的 jar 包和配置文件，我将我的整个 pom 文件的内容都粘贴在这里，大家自行参考。

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.playman</groupId>
  <artifactId>SSMTest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>SSM Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring.version>5.0.2.RELEASE</spring.version>
    <slf4j.version>1.6.6</slf4j.version>
    <log4j.version>1.2.12</log4j.version>
    <mysql.version>5.1.6</mysql.version>
    <mybatis.version>3.4.5</mybatis.version>
  </properties>

  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.6.8</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <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>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>${mysql.version}</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!-- log start -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <!-- log end -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>${mybatis.version}</version>
    </dependency>

    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.0</version>
    </dependency>
    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>SSMTest</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
        <!--jdk 编译插件 -->
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-compiler-plugin</artifactId>
          <configuration>
            <source>1.8</source>
            <target>1.8</target>
            <encoding>utf-8</encoding>
          </configuration>
        </plugin>
        <!--tomcat 插件 -->
        <plugin>
          <groupId>org.apache.tomcat.maven</groupId>
          <!-- tomcat7 的插件，不同 tomcat 版本这个也不一样 -->
          <artifactId>tomcat7-maven-plugin</artifactId>
          <version>2.1</version>
          <configuration>
            <!-- 通过 maven tomcat7:run 运行我的项目时，拜访我的项目的端口号 -->
            <port>8080</port>
            <!-- 我的项目拜访门路  本例：localhost:9090,  如果配置的 aa，则拜访门路为 localhost:9090/aa-->
            <path>/ssmtest</path>
            <!-- 解决中文乱码问题 -->
            <uriEncoding>UTF-8</uriEncoding>
          </configuration>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

当初就能够将一些所须要的目录以及文件先创立好:

OK！筹备工作实现了，咱们就能够进行下一步了。

二．搭建 Spring 框架

我这次搭建 Spring 框架采纳了注解的形式，因为本次波及的内容不多，所以采纳注解的形式较为简单。首先咱们在 resources 目录下新建一个 applicationContext.xml 文件作为 Spring 的配置文件，内容如下：

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

    <!-- 开启注解的扫描 -->
    <context:component-scan base-package="com.robod">
        <!-- 配置哪些注解不扫描 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

</beans>

而后在 UserServiceImpl.java 中实现 UserService 接口中的办法，并且为其加上注解。

@Service("userService")
public class UserServiceImpl implements UserService {

    @Override
    public List<User> findAll() {System.out.println("当初调用了 UserService 中的 findAll() 办法");
        return null;
    }

    @Override
    public void save(List<User> users) {}}

筹备工作实现啦，当初咱们就能够测试 Spring 框架搭建的有没有问题了。咱们在 test 包下应用 Junit 进行单元测试，

public class TEST {

    @Test
    public void testSpring(){ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = ac.getBean("userService",UserService.class);
        userService.findAll();}
}

运行一下，看有没有后果

运行后果呈现了，阐明咱们的 Spring 框架搭建的没有问题，当初就能够进行 SpringMVC 框架的搭建了。

三．搭建 SpringMVC 框架

配置 SpringMVC 框架首先咱们须要筹备好 SpringMVC 的配置文件，在 resources 目录下新建一个 SpringMVC.xml 文件，内容如下：

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

    <!-- 1. 开启注解扫描，只扫描 Controller 注解 -->
    <context:component-scan base-package="com.robod.controller">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 2. 开启 SpringMVC 注解的反对 -->
    <mvc:annotation-driven/>
</beans>

光筹备好配置文件可不够，tomcat 服务器在启动的时候可不会去主动加载 SpringMVC.xml 文件，所以咱们接下来的工作就是要让 tomcat 在启动的时候就加载配置文件。关上 webapp 目录下的 WEB-INF 文件夹，外面有个 web.xml 文件，在外面配置一个前端控制器，代码如下：

  <!-- 配置前端控制器 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 加载 SpringMVC.xml 配置文件 -->
    <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>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

当初就该配置门路了，关上咱们在 controller 目录下创立的 UserController.java 文件 

@Controller
@RequestMapping("/user")
public class UserController {@RequestMapping("/findAll")
    public void findAll() {System.out.println("UserController 中的 findAll() 办法执行了");
    }
}

当初拜访 http://localhost:8080/ssmtest/user/findAll 门路就能够执行 findAll() 办法了，启动 tomcat 后在浏览器中输出该门路后按回车，看一下控制台的打印：

OK，办法失常执行了，阐明咱们的 SpringMVC 框架搭建胜利了，当初就能够进行 Spring 和 SpringMVC 框架的整合了。

四．Spring 和 SpringMVC 框架的整合

终于能够开始两个框架的整合了。话不多说，让咱们开始吧！
如果咱们能够在 controller 中胜利调用到 service 中的办法就阐明咱们的框架整合没有问题，之前咱们在独自应用 Spring 的时候是手动加载 Spring 容器，放在这里显然不太适合，所以咱们须要在 tomcat 一启动的时候就主动加载 Spring 容器，怎么办呢？咱们须要在 web.xml 中配置监听器实现启动时加载，增加以下内容：

  <!-- Spring 整合 SpringMVC-->
  <!-- 配置 Spring 的监听器，默认只加载 WEB-INF 目录下的 applicationContext.xml 配置文件，所以须要配置文件门路 -->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!-- 设置配置文件的门路 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

当初批改 UserController，在外面退出 UserService，并调用 UserService 中的办法：

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

    @Autowired
    UserService userService;

    @RequestMapping("/findAll")
    public void findAll() {System.out.println("UserController 中的 findAll() 办法执行了");
        userService.findAll();}

}

当初启动 tomcat 服务器，拜访 http://localhost:8080/ssmtest/user/findAll，看看执行后果。

很显然，咱们的 Spring 框架和 SpringMVC 框架整合胜利了，接下来咱们就能够筹备 MyBatis 框架了。

五．Spring 框架整合 MyBatis 框架

原本我筹备先搭建 MyBatis 框架，测一下有没有问题再进行整合，然而独自应用 MyBatis 框架须要筹备配置文件，整合的时候又用不到，所以就跳过独自测试 MyBatis 框架，间接一边搭建一边整合。
应用过 MyBatis 框架的敌人们都应该晓得咱们在配置文件中配置了什么，无非就是配置 dataSource 和引入映射配置文件两件事件而已，而后在应用的时候就是创立 SqlSession 去初始化 dao 的实例。这些咱们都能够将其配置到 Spring 的容器中去，这样就实现了 Spring 框架整合 MyBatis 框架。在 applicationContext.xml 文件中增加以下内容：

    <!-- Spring 整合 MyBatis 框架 -->
    <!-- 配置连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/ssmtest"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <!-- 配置 SqlSessionFactory 工厂 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 配置 AccountDao 接口所在包 -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.robod.dao"/>
</bean>

这样咱们就能够将其加载进 Spring 容器中了，接下来咱们就在 UserDao 中加上相应的注解，并在 UserServiceImpl 中调用 UseDao 中的相应办法，而后在 UserController 中打印后果：
UserDao：

@Repository("userDao")
public interface UserDao {@Select("select * from user")
    public List<User> findAll();

    @Update("insert into user(name , age) values (#{name},#{age})")
    public void save(User user);

}

UserController：

    @RequestMapping("/findAll")
    public void findAll() {System.out.println("UserController 中的 findAll() 办法执行了");
        List<User> users = userService.findAll();
        for (User user : users) {System.out.println(user.toString());
        }
    }

这时候咱们的数据库中还没有数据，咱们先轻易增加几条数据，而后再启动 tomcat 服务器，看一下后果:

没有问题，至此咱们的三大框架就整合实现啦！

六．Spring 申明式事务管理

Spring 中有个十分弱小的性能就是申明式事务管理，咱们当然不能忘了。配置 Spring 申明式事务管理有三个步骤，我在代码里加了正文，大家本人看，在 applicationContext.xml 中增加以下内容：

    <!-- 配置 Spring 框架申明式事务管理 -->
    <!-- (1) 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- (2) 配置事务告诉 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" isolation="DEFAULT"/>
        </tx:attributes>
    </tx:advice>
    <!-- (3) 配置 AOP 加强 -->
    <aop:config>
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.playman.service.impl.*ServiceImpl.*(..))"/>
    </aop:config>

OK，当初咱们能够来测试一下了，我在后面写了一个 save 办法还没用，就是筹备测试申明式事务管理的。
在 UserController 中增加一个 save 办法：

    @RequestMapping("/save")
    public void saveAccounts() {User user1 = new User();
        user1.setId(1);
        user1.setName("li");
        user1.setAge(20);
        User user2 = new User();
        user2.setId(2);
        user2.setName("j");
        user2.setAge(25);
        List<User> accounts = new ArrayList<>();
        accounts.add(user1);
        accounts.add(user2);
        userService.save(accounts);
    }

而后将 UserServiceImpl 的 save 办法补充残缺：

@Override
public void save(List<User> users) {User user1 = users.get(0);
    User user2 = users.get(1);
    userDao.save(user1);
    userDao.save(user2);
}

咱们启动 tomcat，拜访 http://localhost:8080/ssmtest/user/save

关上数据库能够看到，咱们的 save 办法是没有问题的。当初为了可能看到咱们的申明式事务管理是否能够失常运行，咱们人为地加一点异样，批改 UserServiceImpl 的 save 办法：

    @Override
    public void save(List<User> users) {User user1 = users.get(0);
        User user2 = users.get(1);
        userDao.save(user1);
        int i = 1/0;    // 如果事务没有回滚，那么应该能够失常增加一条数据
        userDao.save(user2);
    }

为了看到比照的成果，咱们先把申明式事务管理的配置删除掉，再删掉数据库中咱们方才增加的数据，运行一下：

能够看到，数据库中增加了一条数据，阐明再没配置事务管理前出现异常是不会回滚的，当初咱们将方才删掉的配置代码再加上，删除数据库中的信息，再运行一下：

能够看到，数据库中一条数据都没有增加，阐明真的回滚了，咱们的申明式事务管理就配置胜利了。到当初，所有的操作就全副实现啦！

退出移动版