mybatis整合spring

youcongtech發表於2019-01-19
MyBatisSpring

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

1.1 Spring簡介

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

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

Spring Framework的核心功能可用於開發任何Java應用程式，但有一些擴充套件用於在Java EE平臺之上構建Web應用程式。Spring框架的目標是通過啟用基於POJO的程式設計模型，使J2EE開發更易於使用並促進良好的程式設計實踐。

Spring相關資料:

Spring官方文件

Spring官網

Spring的架構圖，如下:

clipboard.png

使用Spring有什麼好處?

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

(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的例子，其實本章可以有很多例子，筆者因為時間緣故就沒有寫太多，當然了，還考慮到本章肯定會非常長，所以例子也沒有寫太多，不過讀者請放心，後續會有更多的補充，這種更多的補充，不僅對讀者有幫助，同時對筆者個人也有幫助。

本文部分內容來自:筆者部落格園

相關文章