2. 程式人生 > >MyBatis註解詳解

MyBatis註解詳解

阿新 • • 發佈：2019-01-24

首先當然得下載mybatis-3.0.5.jar和mybatis-spring-1.0.1.jar兩個JAR包，並放在WEB-INF的lib目錄下(如果你使用maven，則jar會根據你的pom配置的依賴自動下載，並存放在你指定的maven本地庫中，預設是~/.m2/repository)，前一個是mybatis核心包，後一個是和spring整合的包。

使用mybatis，必須有個全域性配置檔案configuration.xml，來配置mybatis的快取，延遲載入等等一系列屬性，該配置檔案示例如下：

    <?xml version="1.0" encoding="UTF-8" ?>   
    <!DOCTYPE configuration        
        PUBLIC "-//ibatis.apache.org//DTD Config 3.0//EN"        
        "http://ibatis.apache.org/dtd/ibatis-3-config.dtd">  
    <configuration>  
        <settings>  
                    <!-- 全域性對映器啟用快取 -->  
            <setting name="cacheEnabled" value="true" />  
                    <!-- 查詢時，關閉關聯物件即時載入以提高效能 -->  
            <setting name="lazyLoadingEnabled" value="true" />  
                    <!-- 設定關聯物件載入的形態，此處為按需載入欄位(載入欄位由SQL指              定)，不會載入關聯表的所有欄位，以提高效能 -->  
            <setting name="aggressiveLazyLoading" value="false" />  
                    <!-- 對於未知的SQL查詢，允許返回不同的結果集以達到通用的效果 -->  
            <setting name="multipleResultSetsEnabled" value="true" />  
                    <!-- 允許使用列標籤代替列名 -->  
            <setting name="useColumnLabel" value="true" />  
                    <!-- 允許使用自定義的主鍵值(比如由程式生成的UUID 32位編碼作為鍵值)，資料表的PK生成策略將被覆蓋 -->  
            <setting name="useGeneratedKeys" value="true" />  
                    <!-- 給予被巢狀的resultMap以欄位-屬性的對映支援 -->  
            <setting name="autoMappingBehavior" value="FULL" />  
                    <!-- 對於批量更新操作快取SQL以提高效能  -->  
            <setting name="defaultExecutorType" value="BATCH" />  
                    <!-- 資料庫超過25000秒仍未響應則超時 -->  
            <setting name="defaultStatementTimeout" value="25000" />  
        </settings>  
            <!-- 全域性別名設定，在對映檔案中只需寫別名，而不必寫出整個類路徑  -->  
        <typeAliases>  
             <typeAlias alias="TestBean"  
            type="com.wotao.taotao.persist.test.dataobject.TestBean" />  
        </typeAliases>  
            <!-- 非註解的sql對映檔案配置，如果使用mybatis註解，該mapper無需配置，但是如果mybatis註解中包含@resultMap註解，則mapper必須配置，給resultMap註解使用 -->  
        <mappers>  
            <mapper resource="persist/test/orm/test.xml" />  
        </mappers>  
    </configuration>
該檔案放在資原始檔的任意classpath目錄下，假設這裡就直接放在資源根目錄，等會spring需要引用該檔案。

檢視ibatis-3-config.dtd發現除了settings和typeAliases還有其他眾多元素，比如properties,objectFactory,environments等等，這些元素基本上都包含著一些環境配置，資料來源定義，資料庫事務等等，在單獨使用mybatis的時候非常重要，比如通過以構造引數的形式去例項化一個sqlsessionFactory，就像這樣：
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);  
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, properties);  
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment, properties);

而typeHandlers則用來自定義對映規則，如你可以自定義將Character對映為varchar，plugins元素則放了一些攔截器介面，你可以繼承他們並做一些切面的事情，至於每個元素的細節和使用，你參考mybatis使用者指南即可。

現在我們用的是spring，因此除settings和typeAliases元素之外，其他元素將會失效，故不在此配置，spring會覆蓋這些元素的配置，比如在spring配置檔案中指定c3p0資料來源定義如下： 
    <!-- c3p0 connection pool configuration -->  
        <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
            destroy-method="close">  
                    <!-- 資料庫驅動 -->  
            <property name="driverClass" value="${db.driver.class}" />  
                    <!-- 連線URL串 -->  
            <property name="jdbcUrl" value="${db.url}" />  
                    <!-- 連線使用者名稱 -->  
            <property name="user" value="${db.username}" />  
                    <!-- 連線密碼 -->  
            <property name="password" value="${db.password}" />  
                    <!-- 初始化連線池時連線數量為5個 -->  
            <property name="initialPoolSize" value="5" />  
                    <!-- 允許最小連線數量為5個 -->  
            <property name="minPoolSize" value="5" />  
                    <!-- 允許最大連線數量為20個 -->  
            <property name="maxPoolSize" value="20" />  
                    <!-- 允許連線池最大生成100個PreparedStatement物件 -->  
            <property name="maxStatements" value="100" />  
                    <!-- 連線有效時間，連線超過3600秒未使用，則該連線丟棄 -->  
            <property name="maxIdleTime" value="3600" />  
                    <!-- 連線用完時，一次產生的新連線步進值為2 -->  
            <property name="acquireIncrement" value="2" />  
                    <!-- 獲取連線失敗後再嘗試10次，再失敗則返回DAOException異常 -->  
            <property name="acquireRetryAttempts" value="10" />  
                    <!-- 獲取下一次連線時最短間隔600毫秒，有助於提高效能 -->  
            <property name="acquireRetryDelay" value="600" />  
                    <!-- 檢查連線的有效性，此處小弟不是很懂什麼意思 -->  
            <property name="testConnectionOnCheckin" value="true" />  
                    <!-- 每個1200秒檢查連線物件狀態 -->  
            <property name="idleConnectionTestPeriod" value="1200" />  
                    <!-- 獲取新連線的超時時間為10000毫秒 -->  
            <property name="checkoutTimeout" value="10000" />  
        </bean>
配置中的${}都是佔位符，在你指定資料庫驅動打war時會自動替換，替換的值在你的父pom中配置，至於c3p0連線池的各種屬性詳細資訊和用法，你自行參考c3p0的官方文件，這裡要說明的是checkoutTimeout元素，記得千萬要設大一點，單位是毫秒，假如設定太小，有可能會導致沒等資料庫響應就直接超時了，小弟在這裡吃了不少苦頭，還是基本功太差。資料來源配置妥當之後，我們就要開始非常重要的sessionFactory配置了，無論是hibernate還是mybatis，都需要一個sessionFactory來生成session，sessionFactory配置如下：
    <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <property name="configLocation" value="classpath:configuration.xml" />  
        <property name="dataSource" ref="testDataSource" />  
    </bean>
testSqlSessionFactory有兩處注入，一個就是前面提到的mybatis全域性設定檔案configuration.xml，另一個就是上面定義的資料來源了（注：hibernate的sessionFactory只需注入hibernate.cfg.xml，資料來源定義已經包含在該檔案中），好了，sessionFactory已經產生了，由於我們用的mybatis3的註解，因此spring的sqlSessionTemplate也不用配置了，sqlSessionTemplate也不用注入到我們的BaseDAO中了，相應的，我們需要配置一個對映器介面來對應sqlSessionTemplate，該對映器介面定義了你自己的介面方法，具體實現不用關心，程式碼如下： 
    <!-- data OR mapping interface -->  
    <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">  
        <property name="sqlSessionFactory" ref="testSqlSessionFactory" />  
        <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />  
    </bean>
對應於sqlSessionTemplate，testMapper同樣需要testSqlSessionFactory注入，另外一個注入就是你自己定義的Mapper介面，該介面定義了操作資料庫的方法和SQL語句以及很多的註解，稍後我會講到。到此，mybatis和spring整合的檔案配置就算OK了（注：如果你需要開通spring對普通類的代理功能，那麼你需要在spring配置檔案中加入<aop:aspectj-autoproxy />），至於其他的如事務配置，AOP切面註解等內容不在本文範圍內，不作累述。

至此，一個完整的myabtis整合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:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"  
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd   
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
      
        <!-- c3p0 connection pool configuration -->  
        <bean id="testDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
            destroy-method="close">  
            <property name="driverClass" value="${db.driver.class}" />  
            <property name="jdbcUrl" value="${db.url}" />  
            <property name="user" value="${db.username}" />  
            <property name="password" value="${db.password}" />  
            <property name="initialPoolSize" value="5" />  
            <property name="minPoolSize" value="5" />  
            <property name="maxPoolSize" value="20" />  
            <property name="maxStatements" value="100" />  
            <property name="maxIdleTime" value="3600" />  
            <property name="acquireIncrement" value="2" />  
            <property name="acquireRetryAttempts" value="10" />  
            <property name="acquireRetryDelay" value="600" />  
            <property name="testConnectionOnCheckin" value="true" />  
            <property name="idleConnectionTestPeriod" value="1200" />  
            <property name="checkoutTimeout" value="10000" />  
        </bean>  
        <bean id="testSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
            <property name="configLocation" value="classpath:configuration.xml" />  
            <property name="dataSource" ref="testDataSource" />  
        </bean>  
        <!-- data OR mapping interface -->  
        <bean id="testMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">  
            <property name="sqlSessionFactory" ref="testSqlSessionFactory" />  
            <property name="mapperInterface" value="com.wotao.taotao.persist.test.mapper.TestMapper" />  
        </bean>  
      
        <!-- add your own Mapper here -->  
      
        <!-- comment here, using annotation -->  
        <!-- <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate"> -->  
        <!-- <constructor-arg index="0" ref="sqlSessionFactory" /> -->  
        <!-- </bean> -->  
        <!-- base DAO class, for module business, extend this class in DAO -->  
        <!-- <bean id="testBaseDAO" class="com.test.dao.TestBaseDAO"> -->  
        <!-- <property name="sqlSessionTemplate" ref="sqlSessionTemplate" /> -->  
        <!-- </bean> -->  
        <!-- <bean id="testDAO" class="com.test.dao.impl.TestDAOImpl" /> -->  
      
        <!-- you can DI Bean if you don't like use annotation -->  
      
    </beans>
到此為止，我們只講了mybatis和spring的整合，還沒有真正觸及mybatis的核心：使用mybatis註解代替對映檔案程式設計（不過官方文件也說了，如果真正想發揮mybatis功能，還是需要用到對映檔案，看來myabtis自己都對mybatis註解沒信心，呵呵），通過上述內容，我們知道配置搞定，但是testMapper還沒有被實現，而註解的使用，全部集中在這個testMapper上，是mybatis註解的核心所在，先來看一下這個testMapper介面是個什麼樣的：
    /** 
     * The test Mapper interface. 
     *  
     * @author HuangMin <a href="mailto:[email protected]>send email</a> 
     *  
     * @since 1.6 
     * @version 1.0 
     *  
     *          #~TestMapper.java 2011-9-23 : afternoon 10:51:40 
     */  
    @CacheNamespace(size = 512)  
    public interface TestMapper {  
      
        /** 
         * get test bean by UID. 
         *  
         * @param id 
         * @return 
         */  
        @SelectProvider(type = TestSqlProvider.class, method = "getSql")  
        @Options(useCache = true, flushCache = false, timeout = 10000)  
        @Results(value = {  
                @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),  
                @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })  
        public TestBean get(@Param("id") String id);  
      
        /** 
         * get all tests. 
         *  
         * @return 
         */  
        @SelectProvider(type = TestSqlProvider.class, method = "getAllSql")  
        @Options(useCache = true, flushCache = false, timeout = 10000)  
        @Results(value = {  
                @Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),  
                @Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) })  
        public List<TestBean> getAll();  
      
        /** 
         * get tests by test text. 
         *  
         * @param testText 
         * @return 
         */  
        @SelectProvider(type = TestSqlProvider.class, method = "getByTestTextSql")  
        @Options(useCache = true, flushCache = false, timeout = 10000)  
        @ResultMap(value = "getByTestText")  
        public List<TestBean> getByTestText(@Param("testText") String testText);  
      
        /** 
         * insert a test bean into database. 
         *  
         * @param testBean 
         */  
        @InsertProvider(type = TestSqlProvider.class, method = "insertSql")  
        @Options(flushCache = true, timeout = 20000)  
        public void insert(@Param("testBean") TestBean testBean);  
      
        /** 
         * update a test bean with database. 
         *  
         * @param testBean 
         */  
        @UpdateProvider(type = TestSqlProvider.class, method = "updateSql")  
        @Options(flushCache = true, timeout = 20000)  
        public void update(@Param("testBean") TestBean testBean);  
      
        /** 
         * delete a test by UID. 
         *  
         * @param id 
         */  
        @DeleteProvider(type = TestSqlProvider.class, method = "deleteSql")  
        @Options(flushCache = true, timeout = 20000)  
        public void delete(@Param("id") String id);  
    }

下面逐個對裡面的註解進行分析：
@CacheNamespace(size = 512) ： 定義在該名稱空間內允許使用內建快取，最大值為512個物件引用，讀寫預設是開啟的，快取內省重新整理時間為預設3600000毫秒，寫策略是拷貝整個物件映象到全新堆（如同CopyOnWriteList）因此執行緒安全。

@SelectProvider(type = TestSqlProvider.class, method = "getSql") ： 提供查詢的SQL語句，如果你不用這個註解，你也可以直接使用@Select("select * from ....")註解，把查詢SQL抽取到一個類裡面，方便管理，同時複雜的SQL也容易操作，type = TestSqlProvider.class就是存放SQL語句的類，而method = "getSql"表示get介面方法需要到TestSqlProvider類的getSql方法中獲取SQL語句。

@Options(useCache = true, flushCache = false, timeout = 10000) ： 一些查詢的選項開關，比如useCache = true表示本次查詢結果被快取以提高下次查詢速度，flushCache = false表示下次查詢時不重新整理快取，timeout = 10000表示查詢結果快取10000秒。

@Results(value = {
@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR),
@Result(property = "testText", column = "test_text", javaType = String.class, jdbcType = JdbcType.VARCHAR) }) ： 表示sql查詢返回的結果集，@Results是以@Result為元素的陣列，@Result表示單條屬性-欄位的對映關係，如：@Result(id = true, property = "id", column = "test_id", javaType = String.class, jdbcType = JdbcType.VARCHAR)可以簡寫為：@Result(id = true, property = "id", column = "test_id")，id = true表示這個test_id欄位是個PK，查詢時mybatis會給予必要的優化，應該說陣列中所有的@Result組成了單個記錄的對映關係，而@Results則單個記錄的集合。另外還有一個非常重要的註解@ResultMap也和@Results差不多，到時會講到。

@Param("id") ：全侷限定別名，定義查詢引數在sql語句中的位置不再是順序下標0,1,2,3....的形式，而是對應名稱，該名稱就在這裡定義。

@ResultMap(value = "getByTestText") ：重要的註解，可以解決複雜的對映關係，包括resultMap巢狀，鑑別器discriminator等等。注意一旦你啟用該註解，你將不得不在你的對映檔案中配置你的resultMap，而value = "getByTestText"即為對映檔案中的resultMap ID(注意此處的value = "getByTestText"，必須是在對映檔案中指定名稱空間路徑)。@ResultMap在某些簡單場合可以用@Results代替，但是複雜查詢，比如聯合、巢狀查詢@ResultMap就會顯得解耦方便更容易管理。
一個對映檔案如下所示： 
    <?xml version="1.0" encoding="UTF-8" ?>    
    <!DOCTYPE mapper    
    PUBLIC "-//ibatis.apache.org//DTD Mapper 3.0//EN"    
    "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd">  
      
    <mapper namespace="com.wotao.taotao.persist.test.mapper.TestMapper">  
        <resultMap id="getByTestText" type="TestBean">  
            <id property="id" column="test_id" javaType="string" jdbcType="VARCHAR" />  
            <result property="testText" column="test_text" javaType="string" jdbcType="VARCHAR" />  
        </resultMap>  
    </mapper>

注意檔案中的namespace路徑必須是使用@resultMap的類路徑，此處是TestMapper，檔案中 id="getByTestText"必須和@resultMap中的value = "getByTestText"保持一致。

@InsertProvider(type = TestSqlProvider.class, method = "insertSql") ：用法和含義@SelectProvider一樣，只不過是用來插入資料庫而用的。

@Options(flushCache = true, timeout = 20000) ：對於需要更新資料庫的操作，需要重新重新整理快取flushCache = true使快取同步。

@UpdateProvider(type = TestSqlProvider.class, method = "updateSql") ：用法和含義@SelectProvider一樣，只不過是用來更新資料庫而用的。

@Param("testBean") ：是一個自定義的物件，指定了sql語句中的表現形式，如果要在sql中引用物件裡面的屬性，只要使用testBean.id，testBean.textText即可，mybatis會通過反射找到這些屬性值。

@DeleteProvider(type = TestSqlProvider.class, method = "deleteSql") ：用法和含義@SelectProvider一樣，只不過是用來刪除資料而用的。

現在mybatis註解基本已經講完了，接下來我們就要開始寫SQL語句了，因為我們不再使用對映檔案編寫SQL，那麼就不得不在java類裡面寫，就像上面提到的，我們不得不在TestSqlProvider這個類裡面寫SQL，雖然已經把所有sql語句集中到了一個類裡面去管理，但聽起來似乎仍然有點噁心，幸好mybatis提供SelectBuilder和SqlBuilder這2個小工具來幫助我們生成SQL語句，SelectBuilder專門用來生成select語句，而SqlBuilder則是一般性的工具，可以生成任何SQL語句，我這裡選擇了SqlBuilder來生成，TestSqlProvider程式碼如下： 
    /* 
     * #~ test-afternoon10:51:40  
     */  
    package com.wotao.taotao.persist.test.sqlprovider;  
      
    import static org.apache.ibatis.jdbc.SqlBuilder.BEGIN;  
    import static org.apache.ibatis.jdbc.SqlBuilder.FROM;  
    import static org.apache.ibatis.jdbc.SqlBuilder.SELECT;  
    import static org.apache.ibatis.jdbc.SqlBuilder.SQL;  
    import static org.apache.ibatis.jdbc.SqlBuilder.WHERE;  
    import static org.apache.ibatis.jdbc.SqlBuilder.DELETE_FROM;  
    import static org.apache.ibatis.jdbc.SqlBuilder.INSERT_INTO;  
    import static org.apache.ibatis.jdbc.SqlBuilder.SET;  
    import static org.apache.ibatis.jdbc.SqlBuilder.UPDATE;  
    import static org.apache.ibatis.jdbc.SqlBuilder.VALUES;  
      
    import java.util.Map;  
      
    /** 
     * The test sql Provider,define the sql script for mapping. 
     *  
     * @author HuangMin <a href="mailto:[email protected]>send email</a> 
     *  
     * @since 1.6 
     * @version 1.0 
     *  
     *          #~TestSqlProvider.java 2011-9-23 : afternoon 10:51:40 
     */  
    public class TestSqlProvider {  
      
        /** table name, here is test */  
        private static final String TABLE_NAME = "test";  
      
        /** 
         * get test by id sql script. 
         *  
         * @param parameters 
         * @return 
         */  
        public String getSql(Map<String, Object> parameters) {  
            String uid = (String) parameters.get("id");  
            BEGIN();  
            SELECT("test_id, test_text");  
            FROM(TABLE_NAME);  
            if (uid != null) {  
                WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");  
            }  
            return SQL();  
        }  
      
        /** 
         * get all tests sql script. 
         *  
         * @return 
         */  
        public String getAllSql() {  
            BEGIN();  
            SELECT("test_id, test_text");  
            FROM(TABLE_NAME);  
            return SQL();  
        }  
      
        /** 
         * get test by test text sql script. 
         *  
         * @param parameters 
         * @return 
         */  
        public String getByTestTextSql(Map<String, Object> parameters) {  
            String tText = (String) parameters.get("testText");  
            BEGIN();  
            SELECT("test_id, test_text");  
            FROM(TABLE_NAME);  
            if (tText != null) {  
                WHERE("test_text like #{testText,javaType=string,jdbcType=VARCHAR}");  
            }  
            return SQL();  
        }  
      
        /** 
         * insert a test sql script. 
         *  
         * @return 
         */  
        public String insertSql() {  
            BEGIN();  
            INSERT_INTO(TABLE_NAME);  
            VALUES("test_id", "#{testBean.id,javaType=string,jdbcType=VARCHAR}");  
            VALUES("test_text", "#{testBean.testText,javaType=string,jdbcType=VARCHAR}");  
            return SQL();  
        }  
      
        /** 
         * update a test sql script. 
         *  
         * @return 
         */  
        public String updateSql() {  
            BEGIN();  
            UPDATE(TABLE_NAME);  
            SET("test_text = #{testBean.testText,javaType=string,jdbcType=VARCHAR}");  
            WHERE("test_id = #{testBean.id,javaType=string,jdbcType=VARCHAR}");  
            return SQL();  
        }  
      
        /** 
         * delete a test sql script. 
         *  
         * @return 
         */  
        public String deleteSql() {  
            BEGIN();  
            DELETE_FROM(TABLE_NAME);  
            WHERE("test_id = #{id,javaType=string,jdbcType=VARCHAR}");  
            return SQL();  
        }  
    }

BEGIN();表示重新整理本地執行緒，某些變數為了執行緒安全，會先在本地存放變數，此處需要重新整理。
SELECT，FROM，WHERE等等都是sqlbuilder定義的公用靜態方法，用來組成你的sql字串。如果你在testMapper中呼叫該方法的某個介面方法已經定義了引數@Param()，那麼該方法的引數Map<String, Object> parameters即組裝了@Param()定義的引數，比如testMapper介面方法中定義引數為@Param("testId"),@Param("testText")，那麼parameters的形態就是：[key="testId",value=object1],[key="testText",value=object2]，如果介面方法沒有定義@Param()，那麼parameters的key就是引數的順序小標：[key=0,value=object1],[key=1,value=object2]，SQL()將返回最終append結束的字串，sql語句中的形如
#{id,javaType=string,jdbcType=VARCHAR}完全可簡寫為#{id}，我只是為了規整如此寫而已。另外，對於複雜查詢還有很多標籤可用，比如：JOIN，INNER_JOIN，GROUP_BY，ORDER_BY等等，具體使用詳情，你可以檢視原始碼。

最後記得把你的Mapper介面注入到你的DAO類中，在DAO中引用Mapper介面方法即可。我在BaseDAO中的註解注入如下： 
    ......  
    @Repository("testBaseDAO")  
    public class TestBaseDAO {  
    ......  


    ......  
        /** 
         * @param testMapper 
         *            the testMapper to set 
         */  
        @Autowired  
        public void setTestMapper(@Qualifier("testMapper") TestMapper testMapper) {  
            this.testMapper = testMapper;  
        }  
    ......

相關推薦

MyBatis註解詳解

首先當然得下載mybatis-3.0.5.jar和mybatis-spring-1.0.1.jar兩個JAR包，並放在WEB-INF的lib目錄下(如果你使用maven，則jar會根據你的pom配置的依賴自動下載，並存放在你指定的maven本地庫中，預設是~/.m2/rep

MyBatis原始碼分析之@ResultMap註解詳解

MyBatis原始碼分析之@ResultMap註解詳解 在前一篇文章講**@MapKey註解時，我原想將@ResultMap註解也一起拿出來說一下，但是發現@ResultMap解析載入原始碼非常多，想想就不在一篇文章中講了，分開單獨來說，這一篇就來徹底探索一下@ResultMap**

Mybatis用法詳解（配置和註解的使用）

mybatis是持久層框架 使用方法（基於xml配置） 1.新增依賴（Maven） <!--資料庫相關, mysql, mybatis--> <!--jdbc連線-->

（轉）@RequestParam @RequestBody @PathVariable 等參數綁定註解詳解

erro 後綁定 false zip ons type() eba veh manager 引言： 接上一篇文章，對@RequestMapping進行地址映射講解之後，該篇主要講解request 數據到handler method 參數數據的綁定所用到的註解和什麽情形下使用

Spring中@Component註解,@Controller註解詳解（網摘）

tin ava 代碼 autowired reat control type imp 訪問 　　在使用Spring的過程中，為了避免大量使用Bean註入的Xml配置文件,我們會采用Spring提供的自動掃描註入的方式, 只需要添加幾行自動註入的的配置,便可以完成Servic

mybatis 基礎詳解

batis 添加用戶 主鍵 actor cor @override iba 基本功 ide 轉 https://www.cnblogs.com/Mr-Kenson/p/8124680.html mybatis 是一個開源的 用於對數據庫操作的框架， 讀者基本都大體了解其

@Qualifier註解詳解

num fine ali factor BE comm alt nta expec @Qualifier註解意味著可以在被標註bean的字段上可以自動裝配。Qualifier註解可以用來取消Spring不能取消的bean應用。 下面的示例將會在Customer的person

springboot的註解詳解

ica prope pan span 配置 作用 cat fix 文件中 配置類相關： @PropertySource(value = "classpath:test.properties") //我們都把配置文件寫到application.yml中。有時我們不願意把

Sping框架中的註解詳解

例子 上下 troy getbean 用戶id 查找 oge 數據庫 配置 傳統的Spring做法是使用.xml文件來對bean進行註入或者是配置aop、事物，這麽做有兩個缺點：1、如果所有的內容都配置在.xml文件中，那麽.xml文件將會十分龐大；如果按需求分開.xml文

Spring MVC @RequestMapping註解詳解（2）

並不是 value get ecif 使用 .com java代碼 處理方法 分開 @RequestMapping 參數說明 　　value：定義處理方法的請求的 URL 地址。（重點） 　　method：定義處理方法的 http method 類型，如 GET、POST

JPA註解詳解及示例

文章出處：https://blog.csdn.net/zhengchao1991/article/details/70236919 1、用例項介紹JPA 使用JPA，肯定是有ORM的意思在裡面，當然我們首先要定義一個實體類（要將 Java 類指定為 JPA 實體，請使用 @Entity 批註

spring+springmvc+mybatis整合詳解

一，導包 1，建立一個web工程，匯入spring，springmvc，mybatis需要的jar包 2，下載適配包Mybatis-Spring.jar（或者寫依賴），不同版本的spring和mybatis需要的適配包不同 二，web.xml （在WEB-INF目錄下） 1，載

@GeneratedValue 註解詳解

springboot中@GeneratedValue作用： （1）、@GeneratedValue註解存在的意義主要就是為一個實體生成一個唯一標識的主鍵、@GeneratedValue提供了主鍵的生成策略。 （2）、@GeneratedValue註解有兩個屬性,分別是strategy和g

@Table 註解詳解

spring @Table註解  作用是 ： 宣告此物件對映到資料庫的資料表，通過它可以為實體指定表(talbe) 常用的兩個屬性：  1、name 用來命名 當前實體類 對應的資料庫 表的名字  @Table(name = "tab_u

Hibernate與Mybatis的詳解區別

1. hibernate是全自動，而mybatis是半自動 hibernate完全可以通過物件關係模型實現對資料庫的操作，擁有完整的JavaBean物件與資料庫的對映結構來自動生成sql。而mybatis僅有基本的欄位對映，物件資料以及物件實際關係仍然

SwaggerAPI註解詳解,以及註解常用引數配置

官網github地址：https://github.com/swagger-api/swagger-core/wiki/Annotations-1.5.X 註解 @Api： 作用在類上，用來標註該類具體實現內容。表示標識這個類是swagger的資源 。  引數：  1

Java 註解詳解

一、什麼是註解 註解也叫元資料，例如我們常見的@Override和@Deprecated，註解是JDK1.5版本開始引入的一個特性，用於對程式碼進行說明，可以對包、類、介面、欄位、方法引數、區域性變數等進行註解 註解都預設繼承介面Annotation.jav

java元註解詳解

java中元註解有四個： @Retention @Target @Document @Inherited； 　　 @Retention：註解的保留位置　　　　　　　　　 　　　　　　@Retention(RetentionPolicy.SOURCE)   //註解僅

mybatis配置詳解

1.SqlMapConfig.xml configuration作為根標籤有如下子標籤,dtd資訊已經將其子標籤出現的順序以及次數規定好了 <1>properties(屬性)，該標籤中有resource(類路徑)或url(檔案路徑例：url=”file:/

Java——註解詳解

Java註解同 classs 和 interface 一樣，註解也屬於一種型別。它是在 Java SE 5.0 版本中開始引入的概念。 註解的定義 通過 @interface 關鍵字進行定義。 public @interface TestAnnotation { } 這段程式碼就建立了一個名字為 Tes