MyBatis集成Spring

時間 2019-12-06

原文原文鏈接

本章主要內容包括Spring簡介、Spring的兩大特性(IOC和AOP)、事務MyBatis集成Spring等。
也許有讀者會疑惑，明明是MyBatis-Plus實戰，怎麼還講MyBatis這麼多東西？
其實很簡單，MyBatis-Plus是由MyBatis衍生而來的，其實MyBatis-Plus與Spring整合其實與MyBatis跟Spring整合差別並不大，讀者經過前面的MyBatis-Plus初步和MyBatis初步這兩個章節，我相信讀者們若是看過，心中自會明瞭。java

1.1 Spring簡介

Spring是企業Java最流行的應用程序開發框架。全球數百萬開發人員使用Spring Framework建立高性能，易於測試和可重用的代碼。mysql

Spring框架是一個開源Java平臺。它最初由Rod Johnson編寫，並於2003年6月首次在Apache 2.0許可下發布。git

Spring Framework的核心功能可用於開發任何Java應用程序，但有一些擴展用於在Java EE平臺之上構建Web應用程序。Spring框架的目標是經過啓用基於POJO的編程模型，使J2EE開發更易於使用並促進良好的編程實踐。github

Spring相關資料:web

Spring官方文檔spring

Spring官網sql

Spring的架構圖，以下:數據庫

使用Spring有什麼好處?express

(1)Spring使開發人員可以使用POJO開發企業級應用程序。僅使用POJO的好處是您不須要EJB容器產品（如應用程序服務器），但您能夠選擇僅使用強大的servlet容器（如Tomcat）或某些商業產品;apache

(2)Spring採用模塊化方式組織。即便包和類的數量很大，你也只須要擔憂你須要的那些而忽略其他的;

(3)Spring並無從新發明輪子，而是真正利用了一些現有技術，如幾個ORM框架，日誌框架，JEE，Quartz和JDK計時器以及其餘視圖技術;

(4)測試用Spring編寫的應用程序很簡單，由於依賴於環境的代碼被移動到這個框架中。此外，經過使用JavaBeanstyle POJO，使用依賴注入來注入測試數據變得更加容易;

(5)Spring的Web框架是一個設計良好的Web MVC框架，它提供了一個很好的替代Web框架，如Struts或藉着Spring名氣流行+自身相比Struts2更輕量級的實現方式的SpringMVC;

(6)Spring提供了一個方便的API，用於將特定於技術的異常（例如，JDBC，Hibernate或JDO拋出）轉換爲一致的，未經檢查的異常;

(7)輕量級IoC容器每每是輕量級的，尤爲是與EJB容器相比時。這有利於在具備有限內存和CPU資源的計算機上開發和部署應用程序;

1.2 IOC特性

1.2.1 IOC簡介

控制反轉（Inversion of Control，縮寫爲IoC），是面向對象編程中的一種設計原則，能夠用來減低計算機代碼之間的耦合度。其中最多見的方式叫作依賴注入（Dependency Injection，簡稱DI），還有一種方式叫「依賴查找」（Dependency Lookup）。經過控制反轉，對象在被建立的時候，由一個調控系統內全部對象的外界實體，將其所依賴的對象的引用傳遞給它。也能夠說，依賴被注入到對象中。

那麼什麼是依賴注入呢？

咱們分別看看這兩個詞。這裏依賴部分轉換爲兩個類之間的關聯。例如，A類依賴於B類。如今，讓咱們看第二部分，注入。全部這些意味着，B類將由IoC注入A類。

依賴注入能夠經過將參數傳遞給構造函數或使用setter方法進行後構建來實現。

1.2.2 IOC實例

下面我本身曾經的一個項目博客系統裏面的部分代碼爲例來說解

(1)編寫數據訪問層接口

package cn.blog.mapper;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.blog.entity.Post;
/*
 * 文章接口
 */
public interface PostMapper {
   
    /**
     * 根據文章ID顯示文章
     */
    public Post selectByPostId(Integer postId);
    
    /**
     * 顯示文章總數
     */
    public int selectPostCount();
    
    
    /**
     *分頁顯示
     */
    public List<Post> selectPostWherePage(HashMap<String,Object> map);
    
    
    /**
     * 根據用戶ID顯示該用戶的全部文章
     */
    public List<Post> selectUserIdWherePage(Map<String,Object> map);
    
    
    /**
     *顯示該用戶ID下全部文章總數
     */
    public int selectUserIdWherePageCount(Integer userId);
    
    
    
    
}

(2)編寫業務接口

package cn.blog.service;

import org.apache.ibatis.annotations.Param;

import cn.blog.entity.Post;
import cn.blog.utils.PageBean;

public interface PostService {

    
    /**
     * 根據文章ID顯示文章
     */
    public Post selectByPostId(Integer postId);
    
    
    /**
     * 顯示文章總數
     */
    public int selectPostCount();
    
    
    /**
     *分頁顯示
     */
    public PageBean<Post> selectPostWherePage(int currentPage);
    
    /**
     * 根據用戶ID顯示該用戶的全部文章
     */
    public PageBean<Post> selectUserIdWherePage(int currentPate,int userId);
    

    /**
     *顯示該用戶ID下全部文章總數
     */
    public int selectUserIdWherePageCount(Integer userId);
    
     
}

(3)編寫業務接口實現類

package cn.blog.service.impl;


import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.blog.entity.Post;
import cn.blog.mapper.PostMapper;
import cn.blog.service.PostService;
import cn.blog.utils.PageBean;


@Service
public class PostServiceImpl implements PostService{

    @Autowired
    private PostMapper postMapper;
    
    @Override
    public Post selectByPostId(Integer postId) {
        // TODO Auto-generated method stub
        return postMapper.selectByPostId(postId);
    }

    @Override
    public int selectPostCount() {
        // TODO Auto-generated method stub
        return postMapper.selectPostCount();
    }

    @Override
    public PageBean<Post> selectPostWherePage(int currentPage) {
            HashMap<String,Object> map = new HashMap<String,Object>();
            PageBean<Post> pageBean = new PageBean<Post>();

            //封裝當前頁數
            pageBean.setCurrPage(currentPage);

            //每頁顯示的數據
            int pageSize=5;
            pageBean.setPageSize(pageSize);
            
            //封裝總記錄數
            int totalCount = postMapper.selectPostCount();
            pageBean.setTotalCount(totalCount);
            
            //封裝總頁數
            double tc = totalCount;
            Double num =Math.ceil(tc/pageSize);//向上取整
            pageBean.setTotalPage(num.intValue());

            map.put("start",(currentPage-1)*pageSize);
            map.put("size", pageSize);
            //封裝每頁顯示的數據
            List<Post> lists = postMapper.selectPostWherePage(map);
            pageBean.setLists(lists);
            

            return pageBean;
    }



    @Override
    public int selectUserIdWherePageCount(Integer userId) {
        // TODO Auto-generated method stub
        return postMapper.selectUserIdWherePageCount(userId);
    }

    @Override
    public PageBean<Post> selectUserIdWherePage(int currentPage,int userId) {

        
        PageBean<Post> pageBean = new PageBean<Post>();

        Map<String,Object> paramMap = new HashMap<String,Object>();
        //封裝當前頁數

        pageBean.setCurrPage(currentPage);

        //每頁顯示的數據
        int pageSize=5;
        pageBean.setPageSize(pageSize);

        //封裝總記錄數
        int totalCount = postMapper.selectUserIdWherePageCount(userId);
        pageBean.setTotalCount(totalCount);

        //封裝總頁數
        double tc = totalCount;
        Double num =Math.ceil(tc/pageSize);//向上取整
        pageBean.setTotalPage(num.intValue());
        paramMap.put("start", (currentPage-1)*pageSize);
        paramMap.put("size", pageBean.getPageSize());
        paramMap.put("userId", userId);

        //封裝每頁顯示的數據
        List<Post> lists = postMapper.selectUserIdWherePage(paramMap);
        
        pageBean.setLists(lists);
        

        return pageBean;
    }

}

(4)對應的Spring的xml文件內容

<bean id="postMapper" class="com.blog.mapper.PostMapper">
</bean>

<bean id="postService" class="cn.blog.service.impl.PostServiceImpl">
<property name="postMapper" ref="postMapper"/>
</bean>

經過這段例子，我想你們應該明白了什麼是依賴注入，若是不這樣寫的話，你前臺要想得到對應的數據訪問層(DAO層)數據，必須得實例化，十幾二十個還好管理，成千上萬個呢？那估計你確定會有罵孃的衝動了。同時也明白了Spring爲你管理對象的好處。若是沒有Spring爲你管理對象，一個一個實例化，那將是一件很是恐懼的事情。

1.3 AOP特性

1.3.1 AOP簡介

Spring的一個關鍵組件是面向切面編程（AOP）框架。跨越應用程序多個點的功能稱爲跨領域問題，這些跨領域問題在概念上與應用程序的業務邏輯分開。各方面有各類常見的良好示例，包括日誌記錄，聲明式事務，安全性，緩存等。

OOP中模塊化的關鍵單元是類，而在AOP中，模塊化單元是方面。DI可幫助您將應用程序對象彼此分離，而AOP可幫助您將交叉問題與它們所影響的對象分離。

Spring Framework的AOP模塊提供了面向方面的編程實現，容許您定義方法攔截器和切入點，以便乾淨地解耦實現應該分離的功能的代碼。

1.3.2 AOP實例

就拿Spring的xml註解事務配置講解:

(1)spring-mybatis.xml事務配置部份內容

<!-- 配置事務管理 -->
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!-- 事務管理 屬性 -->
    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="append*" propagation="REQUIRED"/>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="modify*" propagation="REQUIRED"/>
            <tx:method name="edit*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="remove*" propagation="REQUIRED"/>
            <tx:method name="repair" propagation="REQUIRED"/>

            <tx:method name="get*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="find*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="load*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="search*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="datagrid*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!-- 配置切面 -->
    <aop:config>
        <aop:pointcut id="transactionPointcut" expression="execution(* com.blog.service..*.*(..))"/>
        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice"/>
    </aop:config>

上述內容，好比配置切面，這個切面至關於無論怎麼樣你一定會通過的，好比電視中山大王常常去某個必經之路搶通過路人的錢財。

固然了，上面的配置，主要是關於事務的。熟悉xml事務配置的，對於上面xml代碼再熟悉不過了。

不熟悉的也沒有關係，用多了天然明白。另外補充一點，上面同時也表明了一種規則，好比個人添加方法叫userAdd，可是個人事務配置了必需要以add或者append或者其餘read-only爲false開頭的才能在數據庫對應的表新增數據，如今個人添加方法叫userAdd，它就會觸發該規則中包含的另一種規則就是:<tx:method name="*" propagation="REQUIRED" read-only="true"/>,這個規則將非上述列出的均判斷爲查詢，而個人userAdd是新增，可是不符合上述配置的事務規則，就會致使報錯，從而插入數據失敗。

這樣一來，你們或許就知道它的應用了，若是是傳統的那種Java編程(非Spring),咱們將要寫不少判斷。

1.4 事務

1.4.1 事務簡介

這裏說到的事務主要是指數據庫事務。數據庫事務是一個被視爲單一的工做單元的操做序列。這些操做要麼徹底地執行，要麼徹底不執行。事務管理是一個重要組成部分，RDBMS 面向企業應用程序，以確保數據完整性和一致性。

事務的概念能夠描述爲具備如下四個關鍵屬性說成是ACID：

(1)原子性：事務應該看成一個單獨單元的操做，這意味着整個序列操做要麼是成功，要麼是失敗的;

(2)一致性：這表示數據庫的引用完整性的一致性，表中惟一的主鍵等;

(3)隔離性：可能同時處理不少有相同的數據集的事務，每一個事務應該與其餘事務隔離，以防止數據損壞;

(4)持久性：一個事務一旦完成所有操做後，這個事務的結果必須是永久性的，不能因系統故障而從數據庫中刪除。

一個真正的 RDBMS 數據庫系統將爲每一個事務保證全部的四個屬性。使用 SQL 發佈到數據庫中的事務的簡單視圖以下：

(1)使用 begin transaction 命令開始事務。

(2)使用 SQL 查詢語句執行各類刪除、更新或插入操做。

(3)若是全部的操做都成功，則執行提交操做，不然回滾全部操做。

Spring 框架在不一樣的底層事務管理 APIs 的頂部提供了一個抽象層。Spring 的事務支持旨在經過添加事務能力到 POJOs 來提供給 EJB 事務一個選擇方案。Spring 支持編程式和聲明式事務管理。EJBs 須要一個應用程序服務器，但 Spring 事務管理能夠在不須要應用程序服務器的狀況下實現。

1.4.2 兩種事務(局部事務與全局事務)

局部事務是特定於一個單一的事務資源，如一個 JDBC 鏈接，而全局事務能夠跨多個事務資源事務，如在一個分佈式系統中的事務。

局部事務管理在一個集中的計算環境中是有用的，該計算環境中應用程序組件和資源位於一個單位點，而事務管理只涉及到一個運行在一個單一機器中的本地數據管理器。局部事務更容易實現。

全局事務管理須要在分佈式計算環境中，全部的資源都分佈在多個系統中。在這種狀況下事務管理須要同時在局部和全局範圍內進行。分佈式或全局事務跨多個系統執行，它的執行須要全局事務管理系統和全部相關係統的局部數據管理人員之間的協調。

1.4.3 事務管理的兩種形式

Spring 支持兩種類型的事務管理:

編程式事務管理:這意味着你在編程的幫助下有管理事務。這給了你極大的靈活性，但卻很難維護(編程管理事務，一大堆if-else等各類判斷，代碼量大先不說，可是之後維護起來會使你有種想跳樓的衝動)。

聲明式事務管理:這意味着你從業務代碼中分離事務管理。你僅僅使用註解或 XML 配置來管理事務(前面的AOP示例就很好地體現了XML管理事務)。

聲明式事務管理比編程式事務管理更可取，儘管它不如編程式事務管理靈活，但它容許你經過代碼控制事務。但做爲一種橫切關注點，聲明式事務管理可使用 AOP 方法進行模塊化。Spring 支持使用 Spring AOP 框架的聲明式事務管理。

1.5 MyBatis集成Spring

1.5.1 新建Maven項目導入依賴

這裏的依賴不只僅包括MyBatis整合Spring的必需依賴，同時也包含SpringMVC的依賴，之因此導入是爲了後面的複用。

<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>cn.demo.test</groupId>
  <artifactId>test001</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
   
   
  <dependencies>
        <!-- 單元測試 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <!-- spring核心包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>org.codehaus.jackson</groupId>
            <artifactId>jackson-mapper-asl</artifactId>
            <version>1.9.11</version>
        </dependency>
        <!--mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
            <type>jar</type>
        </dependency>
        <!--打印日誌 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.5</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.13.RELEASE</version>
 
        </dependency>
        <!-- mybatis分頁插件 -->
        <!-- <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId>
            <version>4.1.4</version> </dependency> -->     <!-- javax.servlet.jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.2.1</version>
            <scope>provided</scope>
        </dependency>
        <!-- javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
 
        <!-- spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
 
        <!-- spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>
        <!-- 阿里巴巴fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.41</version>
        </dependency>
        <!--dbcp -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-dbcp2</artifactId>
            <version>2.1.1</version>
        </dependency>
 
        <!-- 輔助 -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.2.4</version>
        </dependency>
 
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.3.2</version>
        </dependency>
 
        <!-- end -->
 
 
    </dependencies>
    <build>
 
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
 
        </plugins>
    </build>
</project>

1.5.2 創建實體類和相應的mapper以及xml

(1)編寫POJO

package cn.entity;
 
public class User {
 
     
    private Integer Id;
    private String userName;
    private String PassWord;
    public Integer getId() {
        return Id;
    }
    public void setId(Integer id) {
        Id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWord() {
        return PassWord;
    }
    public void setPassWord(String passWord) {
        PassWord = passWord;
    }
     
     
}

(2)編寫數據訪問層接口

package cn.mapper;

import cn.entity.User;

public interface UserMapper {

    
    public User selectUserInfo(String userName);
}

(3)編寫XML配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.mapper.UserMapper">

<select id="selectUserInfo" parameterType="String" resultType="User">
select * from `user` where userName=#{userName}

</select>

</mapper>

1.5.3 創建service以及service的實現類

(1)編寫業務接口

package cn.service;

import cn.entity.User;

public interface UserService {

    
    public User selectUserInfo(String userName);
}

(2)編寫業務接口實現類

package cn.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.entity.User;
import cn.mapper.UserMapper;
import cn.service.UserService;

@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    @Override
    public User selectUserInfo(String userName) {
        // TODO Auto-generated method stub
        return userMapper.selectUserInfo(userName);
    }

}

1.5.4 編寫mybatis整合spring相關的配置文件

application-config.xml

<?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:p="http://www.springframework.org/schema/p"
    xmlns:c="http://www.springframework.org/schema/c" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:ehcache="http://www.springmodules.org/schema/ehcache"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd  
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd  
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd  
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd  
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  
        http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">

    <!-- 自動掃描(自動注入) -->
    <context:component-scan base-package="cn.service" />
    
    <!-- 配置鏈接池 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="1234"></property>
    </bean>


    <!-- myBatis文件 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!-- 自動掃描entity目錄, 省掉Configuration.xml裏的手工配置 -->
        <property name="configLocation" value="classpath:mybatis-config.xml" />
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.mapper" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
    </bean>
    <!-- 配置事務管理器 -->
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 配置事物的註解方式注入 -->
    <tx:annotation-driven transaction-manager="transactionManager" />


</beans>

mybatis-config.xml

<?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>
    <typeAliases>
        <!-- 給cn.entity包下起別名 -->
        <package name="cn.entity" />

    </typeAliases>

</configuration>

log4j.properties

#config root logger
log4j.rootLogger = INFO,system.out
log4j.appender.system.out=org.apache.log4j.ConsoleAppender
log4j.appender.system.out.layout=org.apache.log4j.PatternLayout
log4j.appender.system.out.layout.ConversionPattern=[Log] %5p[%F:%L]:%m%n

#config this Project.file logger
log4j.logger.thisProject.file=INFO,thisProject.file.out
log4j.appender.thisProject.file.out=org.apache.log4j.DailyRollingFileAppender
log4j.appender.thisProject.file.out.File=logContentFile.log
log4j.appender.thisProject.file.out.layout=org.apache.log4j.PatternLayout

1.5.5 單元測試確保application-config.xml和mybatis-config.xml配置正確

package cn.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.entity.User;
import cn.mapper.UserMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:application-config.xml")
public class JunitTest {

    
    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void testName() throws Exception {
        
        User user = userMapper.selectUserInfo("youcong");
        System.out.println(user.getPassWord());
        
    }
}

運行出來輸出對應的信息，說明配置沒有問題，同時也說明的MyBatis成功整合Spring。

1.6 小結

經過本章的學習，我相信你對Spring會有一個大體的瞭解，另外本章動手實踐的只有一個MyBatis整合Spring的例子，其實本章能夠有不少例子，筆者由於時間緣故就沒有寫太多，固然了，還考慮到本章確定會很是長，因此例子也沒有寫太多，不過讀者請放心，後續會有更多的補充，這種更多的補充，不只對讀者有幫助，同時對筆者我的也有幫助。

本文部份內容來自:筆者博客園