java實際開發-框架-mybatis

原創 努力吧_骚年 2018-08-27 04:34

mybatis的入門需要掌握以下幾點：

1、使用jdbc程序使用原生態的jdbc進行開發存在很多弊端，優點是執行效率高，mybatis彌補了jdbc的缺陷。

2、mybatis的架構(重點)。

3、mybatis的入門程序(重點)。

     實現數據的查詢、添加、修改、刪除

4、mybatis開發DAO的兩種方法(重點)

     原始的DAO開發方式(DAO接口和DAO實現都需要編寫)

     mapper代理方式(只需要編寫DAO接口)

5、輸入映射類型和輸出映射類型

6、動態SQL

mybatis的高級知識主要包括以下幾點：

高級映射查詢(一對一、一對多、多對多)(重點)

查詢緩存

延遲加載

mybatis和Spring整合(重點)

mybatis逆向工程

開發環境(eclipse、MySQL)

創建數據庫

創建數據庫mybatis

新建表結構：

sql_table.sql

 

[sql] view plain copy

  1. *  
  2. SQLyog v10.2   
  3. MySQL - 5.1.72-community : Database - mybatis  
  4. *********************************************************************  
  5. */  
  6.   
  7.   
  8. /*!40101 SET NAMES utf8 */;  
  9.   
  10. /*!40101 SET SQL_MODE=''*/;  
  11.   
  12. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;  
  13. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;  
  14. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;  
  15. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;  
  16. /*Table structure for table `items` */  
  17.   
  18. CREATE TABLE `items` (  
  19.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  20.   `name` varchar(32) NOT NULL COMMENT '商品名稱',  
  21.   `price` float(10,1) NOT NULL COMMENT '商品定價',  
  22.   `detail` text COMMENT '商品描述',  
  23.   `pic` varchar(64) DEFAULT NULL COMMENT '商品圖片',  
  24.   `createtime` datetime NOT NULL COMMENT '生產日期',  
  25.   PRIMARY KEY (`id`)  
  26. ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;  
  27.   
  28. /*Table structure for table `orderdetail` */  
  29.   
  30. CREATE TABLE `orderdetail` (  
  31.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  32.   `orders_id` int(11) NOT NULL COMMENT '訂單id',  
  33.   `items_id` int(11) NOT NULL COMMENT '商品id',  
  34.   `items_num` int(11) DEFAULT NULL COMMENT '商品購買數量',  
  35.   PRIMARY KEY (`id`),  
  36.   KEY `FK_orderdetail_1` (`orders_id`),  
  37.   KEY `FK_orderdetail_2` (`items_id`),  
  38.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,  
  39.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
  40. ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;  
  41.   
  42. /*Table structure for table `orders` */  
  43.   
  44. CREATE TABLE `orders` (  
  45.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  46.   `user_id` int(11) NOT NULL COMMENT '下單用戶id',  
  47.   `number` varchar(32) NOT NULL COMMENT '訂單號',  
  48.   `createtime` datetime NOT NULL COMMENT '創建訂單時間',  
  49.   `note` varchar(100) DEFAULT NULL COMMENT '備註',  
  50.   PRIMARY KEY (`id`),  
  51.   KEY `FK_orders_1` (`user_id`),  
  52.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION  
  53. ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;  
  54.   
  55. /*Table structure for table `user` */  
  56.   
  57. CREATE TABLE `user` (  
  58.   `id` int(11) NOT NULL AUTO_INCREMENT,  
  59.   `username` varchar(32) NOT NULL COMMENT '用戶名稱',  
  60.   `birthday` date DEFAULT NULL COMMENT '生日',  
  61.   `sex` char(1) DEFAULT NULL COMMENT '性別',  
  62.   `address` varchar(256) DEFAULT NULL COMMENT '地址',  
  63.   PRIMARY KEY (`id`)  
  64. ) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;  
  65.   
  66. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;  
  67. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;  
  68. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;  
  69. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;  

創建數據

 

sql_data.sql

 

[sql] view plain copy

  1. /*  
  2. SQLyog v10.2   
  3. MySQL - 5.1.72-community : Database - mybatis  
  4. *********************************************************************  
  5. */  
  6.   
  7.   
  8. /*!40101 SET NAMES utf8 */;  
  9.   
  10. /*!40101 SET SQL_MODE=''*/;  
  11.   
  12. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;  
  13. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;  
  14. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;  
  15. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;  
  16. /*Data for the table `items` */  
  17.   
  18. insert  into `items`(`id`,`name`,`price`,`detail`,`pic`,`createtime`) values (1,'臺式機',3000.0,'該電腦質量非常好！！！！',NULL,'2015-02-03 13:22:53'),(2,'筆記本',6000.0,'筆記本性能好，質量好！！！！！',NULL,'2015-02-09 13:22:57'),(3,'揹包',200.0,'名牌揹包，容量大質量好！！！！',NULL,'2015-02-06 13:23:02');  
  19.   
  20. /*Data for the table `orderdetail` */  
  21.   
  22. insert  into `orderdetail`(`id`,`orders_id`,`items_id`,`items_num`) values (1,3,1,1),(2,3,2,3),(3,4,3,4),(4,4,2,3);  
  23.   
  24. /*Data for the table `orders` */  
  25.   
  26. insert  into `orders`(`id`,`user_id`,`number`,`createtime`,`note`) values (3,1,'1000010','2015-02-04 13:22:35',NULL),(4,1,'1000011','2015-02-03 13:22:41',NULL),(5,10,'1000012','2015-02-12 16:13:23',NULL);  
  27.   
  28. /*Data for the table `user` */  
  29.   
  30. insert  into `user`(`id`,`username`,`birthday`,`sex`,`address`) values (1,'王五',NULL,'2',NULL),(10,'張三','2014-07-10','1','北京市'),(16,'張小明',NULL,'1','河南鄭州'),(22,'陳小明',NULL,'1','河南鄭州'),(24,'張三丰',NULL,'1','河南鄭州'),(25,'陳小明',NULL,'1','河南鄭州'),(26,'王五',NULL,NULL,NULL);  
  31.   
  32. /*!40101 SET SQL_MODE=@OLD_SQL_MODE */;  
  33. /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;  
  34. /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;  
  35. /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;  

 

jdbc編程中的問題

 企業開發中，根據項目大小、特點進行技術選型，jdbc操作數據庫時效率時很高的，jdbc也是結束選型的參考

jdbc程序 

 需要數據庫驅動包

上邊是MySQL的驅動，下邊是oracle的驅動

參考下邊一段程序

 

[java] view plain copy

  1. package test.lx.mybatis.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8.   
  9. /** 
  10.  * jdbc的測試程序 
  11.  *  
  12.  * @author lx 
  13.  *  
  14.  */  
  15. public class JdbcTest {  
  16.     public static void main(String[] args) {  
  17.         Connection connection = null;  
  18.         //PreparedStatement是預編譯的Statement，通過Statement發起數據庫的操作  
  19.         //PreparedStatement防止sql注入，執行數據庫效率高  
  20.         PreparedStatement preparedStatement = null;  
  21.         ResultSet resultSet = null;  
  22.           
  23.         try {  
  24.             //加載數據庫驅動  
  25.             Class.forName("com.mysql.jdbc.Driver");  
  26.               
  27.             //通過驅動管理類獲取數據庫鏈接  
  28.             connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");  
  29.             //定義sql語句 ?表示佔位符  
  30.         String sql = "select * from user where username = ?" ;  
  31.             //獲取預處理statement  
  32.             preparedStatement = connection.prepareStatement(sql);  
  33.             //設置參數，第一個參數爲sql語句中參數的序號（從1開始），第二個參數爲設置的參數值  
  34.             preparedStatement.setString(1, "王五");  
  35.             //向數據庫發出sql執行查詢，查詢出結果集  
  36.             resultSet =  preparedStatement.executeQuery();  
  37.             //遍歷查詢結果集  
  38.             while(resultSet.next()){  
  39.                 System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));  
  40.             }  
  41.         } catch (Exception e) {  
  42.             e.printStackTrace();  
  43.         }finally{  
  44.             //釋放資源  
  45.             if(resultSet!=null){  
  46.                 try {  
  47.                     resultSet.close();  
  48.                 } catch (SQLException e) {  
  49.                     // TODO Auto-generated catch block  
  50.                     e.printStackTrace();  
  51.                 }  
  52.             }  
  53.             if(preparedStatement!=null){  
  54.                 try {  
  55.                     preparedStatement.close();  
  56.                 } catch (SQLException e) {  
  57.                     // TODO Auto-generated catch block  
  58.                     e.printStackTrace();  
  59.                 }  
  60.             }  
  61.             if(connection!=null){  
  62.                 try {  
  63.                     connection.close();  
  64.                 } catch (SQLException e) {  
  65.                     // TODO Auto-generated catch block  
  66.                     e.printStackTrace();  
  67.                 }  
  68.             }  
  69.   
  70.         }  
  71.   
  72.     }  
  73. }  

 

jdbc問題總結

1、數據庫連接頻繁的創建和關閉，缺點浪費數據庫的資源，影響操作效率

      設想：使用數據庫連接池

2、SQL語句是硬編碼，如果需求變更需要修改SQL，就需要修改Java代碼，需要重新編譯，系統不易維護。

      設想：將SQL語句統一配置在文件中，修改SQL不需要修改Java代碼

3、通過PreparedStatement向佔位符設置參數，存在硬編碼(參數位置，參數)問題。系統不易維護。

      設想：將SQL中的佔位符以及對應的參數類型配置在配置文件中，能夠自動輸入映射

4、遍歷查詢結果集中存在硬編碼(列名)

      設想：自動進行SQL查詢結果向Java對象的映射(輸出映射)

mybatis架構(重點)

mybatis介紹：

  • mybatis本是Apache的一個開源項目ibatis，2010年這個項目由Apache software foundation遷移到了Google code，並且改名爲mybatis，實質上mybatis對ibatis進行了一些改進。目前mybatis在GitHub上託管。git(分佈式版本控制，當前比較流行)
  • mybatis是一個優秀的持久層框架，它對jdbc的操作數據庫的過程進行封裝，使開發者只需要關注SQL本身，而不需要花費精力去處理例如註冊驅動、創建connection、創建statement、手動設置參數、結果集檢索等jdbc繁雜的過程代碼。
  • mybatis通過xml或註解的方式將要執行的各種statement( statement、PreparedStatement、CallableStatement)配置起來，並通過Java對象和Statement中的SQL進行映射生成最終執行的SQL語句，最後由mybatis框架執行SQL並將結果映射成Java對象並返回。

mybatis架構

 

mybatis入門程序

需求

實現用戶查詢：

根據用戶的id查詢用戶的信息(單條記錄)

根據用戶名模糊查詢用戶信息(多條記錄)

用戶添加、用戶修改、用刪除

導入jar包

從mybatis官網下載地址是: https://github.com/mybatis/mybatis-3/releases

mybatis-3.2.7.pdf —操作手冊

mybatis-3.2.7.jar— 核心jar

lib—依賴jar包

工程結構

log4j.properties(公用文件)

建議開發環境中要使用debug

 

[plain] view plain copy

  1. # Global logging configuration\uff0c\u5efa\u8bae\u5f00\u53d1\u73af\u5883\u4e2d\u8981\u7528debug  
  2. log4j.rootLogger=DEBUG, stdout  
  3. # Console output...  
  4. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  5. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  6. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n  

 

SqlMapConfig.xml(公用文件)

通過SqlMapConfig.xml加載mybatis運行環境

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE configuration  
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6.     <!-- 和Spring整合後environments配置將廢除 -->  
  7.     <environments default="development">  
  8.         <environment id="development">  
  9.             <!-- 使用jdbc事務管理 -->  
  10.             <transactionManager type="JDBC" />  
  11.             <dataSource type="POOLED">  
  12.                 <property name="driver" value="com.mysql.jdbc.Driver" />  
  13.                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />  
  14.                 <property name="username" value="root" />  
  15.                 <property name="password" value="root" />  
  16.             </dataSource>  
  17.         </environment>  
  18.     </environments>  
  19.   
  20.     <!-- 加載mapper文件 -->  
  21.     <mappers>  
  22.         <mapper resource="sqlmap/User.xml" />  
  23.     </mappers>  
  24. </configuration>  

根據id查詢用戶

pojo (User.java)

[java] view plain copy

  1. public class User {  
  2.     private int id;  
  3.     private String username; // 用戶姓名  
  4.     private String sex; // 性別  
  5.     private Date birthday; // 生日  
  6.     private String address; // 地址  
  7.         // 添加對應的setter和getter方法  
  8.         ......  
  9. }  

User.xml (重點)

建議命名規則：表名+mapper.xml

早期ibatis命名規則：表名.xml

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE mapper  
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5. <!-- namespace命名空間，爲了對SQL語句進行隔離，方便管理，mapper可開發dao方式，使用namespace有特殊作用   
  6. mapper代理開發時將namespace指定爲mapper接口的全限定名 -->  
  7. <mapper namespace="test">  
  8. <!-- 在mapper.xml文件中配置很多的SQL語句，執行每個SQL語句時，封裝爲MappedStatement對象  
  9. mapper.xml以statement爲單位管理SQL語句  
  10.  -->  
  11.    
  12.  <!-- 根據id查詢用戶信息 -->  
  13.  <!--   
  14.     id: 唯一標識一個statement  
  15.     #{}：表示一個佔位符，如果#{} 中傳入簡單類型的參數，#{}中的名稱隨意  
  16.     parameterType: 輸入參數的類型，通過#{}接收parameterType輸入的參數  
  17.     resultType：輸出結果類型，指定單條記錄映射的pojo類型  
  18.   -->  
  19.   <select id="findUserById" parameterType="int" resultType="test.lx.mybatis.po.User">  
  20.      SELECT * FROM USER WHERE id=#{id};  
  21.   </select>  
  22.     
  23. </mapper>  

編碼

創建SqlSessionFactory

[java] view plain copy

  1.               // 會話工廠  
  2. private SqlSessionFactory sqlSessionFactory;  
  3. // 創建工廠  
  4. @Before  
  5. public void init() throws IOException {  
  6.   
  7.     // 配置文件（SqlMapConfig.xml）  
  8.     String resource = "SqlMapConfig.xml";  
  9.   
  10.     // 加載配置文件到輸入 流  
  11.     InputStream inputStream = Resources.getResourceAsStream(resource);  
  12.   
  13.     // 創建會話工廠  
  14.     sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  15.   
  16. }  
  17.   
  18. // 測試根據id查詢用戶(得到單條記錄)  
  19. @Test  
  20. public void testFindUserById() {  
  21.   
  22.     // 通過sqlSessionFactory創建sqlSession  
  23.   
  24.     SqlSession sqlSession = sqlSessionFactory.openSession();  
  25.   
  26.     // 通過sqlSession操作數據庫  
  27.     // 第一個參數：statement的位置，等於namespace+statement的id  
  28.     // 第二個參數：傳入的參數  
  29.     User user = null;  
  30.     try {  
  31.         user = sqlSession.selectOne("test.findUserById", 1);  
  32.     } catch (Exception e) {  
  33.         e.printStackTrace();  
  34.     } finally {  
  35.         // 關閉sqlSession  
  36.         sqlSession.close();  
  37.     }  
  38.   
  39.     System.out.println(user);  
  40.   
  41. }  

根據用戶名稱模糊查詢用戶信息

根據用戶名稱模糊查詢用戶信息可能返回多條記錄。

User.xml

[html] view plain copy

  1. <!-- 根據用戶名稱查詢用戶信息，可能返回多條   
  2.  ${}:表示SQL的拼接，通過${}接收參數，將參數的內容不加任何修飾的拼接在SQL中  
  3.  -->  
  4.  <select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  5.       select * from user where username like '%${value}%'   
  6.  </select>  
  7.    
  8.  <select id="findUserByName2" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  9.       select * from user where username like #{username}   
  10.  </select>  

編碼

[java] view plain copy

  1. // 測試根據名稱模糊查詢用戶(可能得到多條記錄)  
  2.         @Test  
  3.         public void testFindUserByName() {  
  4.               
  5.             // 通過sqlSessionFactory創建sqlSession  
  6.               
  7.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  8.               
  9.             // 通過sqlSession操作數據庫  
  10.             // 第一個參數：statement的位置，等於namespace+statement的id  
  11.             // 第二個參數：傳入的參數  
  12.             List<User> list = null;  
  13.             try {  
  14.                 //list = sqlSession.selectList("test.findUserByName", "小明");  
  15.                 list = sqlSession.selectList("test.findUserByName2", "%小明%");  
  16.             } catch (Exception e) {  
  17.                 e.printStackTrace();  
  18.             } finally {  
  19.                 // 關閉sqlSession  
  20.                 sqlSession.close();  
  21.             }  
  22.               
  23.             System.out.println(list.size());  
  24.         }  

mybatis開發過程小結

1.編寫SqlMapConfig.xml

2.編寫mapper.xml（定義了statement）

3.編程通過配置文件創建SqlSessionFactory

4.通過SqlSessionFactory獲取SqlSession

5.通過SqlSession操作數據庫（如果執行修改、添加、刪除需要調用SqlSession.commit()）

6.SqlSession使用完後後要關閉

用戶添加

向用戶表中添加一條數據記錄

User.xml

[html] view plain copy

  1. <!-- 添加用戶   
  2.   parameterType:輸入參數的類型，User對象包括username,birthday,sex,address  
  3.   #{}接收pojo數據,可以使用OGNL解析出pojo的屬性值  
  4.   #{username}表示從parameterType中獲取pojo的屬性值  
  5.  -->  
  6.  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  7.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  8.  </insert>  

編碼

[java] view plain copy

  1. @Test  
  2. public void testInsertUser() {  
  3.     // 通過sqlSessionFactory創建sqlSession  
  4.     SqlSession sqlSession = sqlSessionFactory.openSession();  
  5.       
  6.     //通過sqlSession操作數據庫  
  7.     //創建插入數據對象  
  8.     User user = new User();  
  9.     user.setUsername("一蓑煙雨");  
  10.     user.setAddress("河南周口");  
  11.     user.setBirthday(new Date());  
  12.     user.setSex("1");  
  13.     try {  
  14.         sqlSession.insert("test.insertUser", user);  
  15.         //需要提交事務  
  16.         sqlSession.commit();  
  17.     } catch (Exception e) {  
  18.         e.printStackTrace();  
  19.     } finally {  
  20.         // 關閉sqlSession  
  21.         sqlSession.close();  
  22.     }  
  23.       
  24. }  

 

測試結果如下

 

主鍵返回

需求：user對象插入到數據庫後，新紀錄的主鍵要通過user對象返回，通過user獲取主鍵值。

解決思路：

通過LAST_INSERT_ID()獲取剛插入記錄的自增主鍵值，在insert語句執行後，執行select LAST_INSERT_ID()就可以獲取自增主鍵。注意：此語句必須和INSERT語句一塊使用並且要在插入後執行。

修改User.xml

[html] view plain copy

  1. <!-- 添加用戶   
  2.    parameterType:輸入參數的類型，User對象包括username,birthday,sex,address  
  3.    #{}接收pojo數據,可以使用OGNL解析出pojo的屬性值  
  4.    #{username}表示從parameterType中獲取pojo的屬性值  
  5.    <selectKey>:用於進行主鍵返回，定義了主鍵值的SQL  
  6.    order：設置selectKey標籤中SQL的執行順序，相對於insert語句而言  
  7.    keyProperty： 將主鍵設置到哪個屬性上  
  8.    resultType：select LAST_INSERT_ID()的結果類型  
  9.   -->  
  10.   <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  11.      <selectKey keyProperty="id" order="AFTER" resultType="int">  
  12.         select LAST_INSERT_ID()  
  13.      </selectKey>  
  14.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  15.   </insert>  

使用MySQL的uuid機制生成主鍵：

使用uuid生成主鍵的好處是不考慮數據庫移植後的主鍵衝突問題

實現思路：先查詢uuid得到主鍵，將主鍵設置到user對象中，將user插入到數據庫中

 

 

[html] view plain copy

  1. <!-- mysql的uuid()函數生成主鍵 -->  
  2.  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  3.     <selectKey keyProperty="id" order="BEFORE" resultType="string">  
  4.        select uuid()  
  5.     </selectKey>  
  6.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  7.  </insert>  

如何實現oracle數據庫的主鍵返回？
oracle沒有自增主鍵機制，使用序列完成主鍵生成

 

實現思路：先查詢序列得到主鍵，將主鍵設置到user對象中，將user對象插入數據庫

 

[html] view plain copy

  1. <!-- oracle  
  2.          在執行insert之前執行select 序列.nextval() from dual取出序列最大值，將值設置到user對象的id屬性中  
  3.    -->  
  4.   <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  5.      <selectKey keyProperty="id" order="BEFORE" resultType="int">  
  6.         select 序列.nextval() from dual  
  7.      </selectKey>  
  8.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  9.   </insert>  

 

用戶刪除和更新

User.xml

 

 

[html] view plain copy

  1. <!-- 用戶刪除 -->  
  2.  <delete id="deleteUser" parameterType="int">  
  3.   delete from user where id=#{id}  
  4.  </delete>  
  5.  <!-- 用戶更新  
  6.     要求：傳入的user對象包括id屬性值  
  7.   -->  
  8.   <update id="updateUser" parameterType="test.lx.mybatis.po.User">  
  9.   update user set username = #{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}  
  10.   </update>  

 

編碼

[java] view plain copy

  1. // 測試刪除用戶  
  2.         @Test  
  3.         public void testDeleteUser() {  
  4.             // 通過sqlSessionFactory創建sqlSession  
  5.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  6.               
  7.             //通過sqlSession操作數據庫  
  8.             try {  
  9.                 sqlSession.delete("test.deleteUser", 28);  
  10.                 //需要提交事務  
  11.                 sqlSession.commit();  
  12.             } catch (Exception e) {  
  13.                 e.printStackTrace();  
  14.             } finally {  
  15.                 // 關閉sqlSession  
  16.                 sqlSession.close();  
  17.             }  
  18.         }  
  19.         // 測試根據id更新用戶(得到單條記錄)  
  20.         @Test  
  21.         public void testUpdateUser() {  
  22.             // 通過sqlSessionFactory創建sqlSession  
  23.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  24.               
  25.             //通過sqlSession操作數據庫  
  26.             //創建更新數據庫對象，要求必須包括id  
  27.             User user= new User();  
  28.             user.setId(28);  
  29.             user.setUsername("任平生");  
  30.             //凡是沒有設置的屬性都被當成了NULL進行賦值  
  31.             //user.setBirthday(new Date());  
  32.             user.setSex("1");  
  33.               
  34.             try {  
  35.                 sqlSession.delete("test.updateUser", user);  
  36.                 //需要提交事務  
  37.                 sqlSession.commit();  
  38.             } catch (Exception e) {  
  39.                 e.printStackTrace();  
  40.             } finally {  
  41.                 // 關閉sqlSession  
  42.                 sqlSession.close();  
  43.             }  
  44.         }  

Mybatis解決jdbc編程中的問題

1.數據庫鏈接創建、釋放頻繁造成系統資源浪費從而影響性能，如果使用數據庫連接池可以解決此問題。

   解決：在SqlMapConfig.xml中配置數據連接池，使用連接池管理數據庫連接。

2.SQL語句寫在代碼中造成代碼不易維護，實際應用SQL變化可能較大，SQL變動需要改變Java代碼。

   解決：將SQL語句配置在XXXXMapper.xml文件中與Java代碼分離。

3.向SQL語句中傳參數麻煩，因爲SQL語句的where條件不一定，可能多也可能少，佔位符和參數要一一對應。

   解決：Mybatis自動將Java對象映射至SQL語句，通過statement中的parameterType定義輸入參數的類型。

4.對結果集解析麻煩，SQL變化導致解析代碼變化，且解析前需要遍歷，如果能將數據庫記錄封裝成pojo對象解析比較方便。

   解決：Mybatis自動將SQL執行結果映射至Java對象，通過statement中的resultType定義輸出結果的類型

 

Mybatis與Hibernate的重要區別

企業開發進行選型，考慮mybatis和Hibernate適用場景。

Mybatis：入門簡單，程序容易上手開發，節省開發成本。Mybatis需要程序員自己編寫SQL語句，是一個不完全的ORM框架，對SQL修改和優化非常容易實現。Mybatis適合開發需求變更頻繁的系統，比如：互聯網項目。

Hibernate：入門門檻高，如果使用Hibernate寫出高性能的程序不容易實現。Hibernate不用寫SQL語句，是一個完全的ORM框架。Hibernate適合需求固定，對象數據模型穩定，中小型項目，比如：企業OA系統。

總之，企業在技術選型時根據項目實際情況，以降低成本和提高系統可維護性爲出發點進行技術選型。

總結

SqlMapConfig.xml

是mybatis全局配置文件，只有一個，名稱不固定，主要mapper.xml,mapper.xml中配置SQL語句。

mapper.xml

mapper.xml是以statement爲單位進行配置。（把一個SQL稱爲一個statement），statement中配置SQL語句、parameterType輸入參數類型(完成輸入映射)、resultType輸出結果類型(完成輸出映射)。

還提供了parameterMap配置輸入參數類型(已過期，不推薦使用)

還提供了resultMap配置輸出結果類型(完成輸出映射)。

佔位符#{}

#{}表示一個佔位符嗎，向佔位符輸入參數，mybatis自動進行Java類型和jdbc類型的轉換。程序員不需要考慮參數的類型，比如傳入字符串，mybatis最終拼接好的SQL就是參數兩邊加上單引號。#{} 接收pojo數據，可以使用OGNL解析出pojo的屬性值。

拼接符${}

表示SQL的拼接，通過${}接收參數，將參數的內容不加任何修飾拼接在SQL中。${}也可以接收pojo的數據，可以使用OGNL解析出pojo的屬性值。

缺點：不能防止SQL注入。

selectOne和selectList

selectOne用於查詢單條記錄，不能用於查詢多條記錄，否則會拋出異常。而selectList用戶查詢多條記錄，也可用於查詢單條記錄。

mybatis開發DAO的方法

SqlSession的作用範圍

SqlSessionFactoryBuilder: 是以工具類的方式來使用，需要創建SqlSessionFactory時就new一個SqlSessionFactoryBuilder。

SqlSessionFactory：正常開發時，以單例方式管理SqlSessionFactory，整個系統運行過程中SqlSessionFactory只有一個實例，將來和Spring整合後由Spring以單例模式管理SqlSessionFactory。

SqlSession: SqlSession是一個面向用戶(程序員)的接口，程序員調用SqlSession的 接口方法進行操作數據庫

問題：SqlSession是否能以單例方式使用？

由於SqlSession是線程不安全的，所以SqlSession最佳應用範圍是在方法體內，在方法體內定義局部變量使用SqlSession。

原始DAO的開發方式

程序員需要編寫DAO接口和DAO的實現類

DAO接口

 

[java] view plain copy

  1. public interface UserDao {  
  2.     // 根據id查詢用戶信息  
  3.     public User findUserById(int id) throws Exception;  
  4. }  

 

DAO接口的實現

[java] view plain copy

  1. public class UserDaoImpl implements UserDao {  
  2.    private SqlSessionFactory sqlSessionFactory;  
  3.      
  4.    //將SqlSessionFactory注入  
  5.    public UserDaoImpl(SqlSessionFactory sqlSessionFactory){  
  6.        this.sqlSessionFactory = sqlSessionFactory;  
  7.    }  
  8.       
  9.     public User findUserById(int id) throws Exception {  
  10.         //創建SqlSession  
  11.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  12.           
  13.         //根據id查詢用戶信息  
  14.         User user = sqlSession.selectOne("test.findUserById", id);  
  15.         sqlSession.close();  
  16.         return user;  
  17.     }  
  18. }  

測試代碼

[java] view plain copy

  1. public class UserDaoImplTest {  
  2.     // 會話工廠  
  3.     private SqlSessionFactory sqlSessionFactory;  
  4.       
  5.     //創建工廠  
  6.     @Before  
  7.     public void init() throws IOException{  
  8.         //配置文件(SqlMapConfig.xml)  
  9.         String resource = "SqlMapConfig.xml";  
  10.           
  11.         //加載配置文件到輸入流  
  12.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  13.           
  14.         //創建會話工廠  
  15.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);        
  16.     }  
  17.       
  18.     @Test  
  19.     public void testFindUserById() throws Exception{  
  20.         UserDao userDao = new UserDaoImpl(sqlSessionFactory);  
  21.           
  22.         User user = userDao.findUserById(1);  
  23.         System.out.println(user);  
  24.     }  
  25.       
  26. }  

mapper代理方式

對於mapper代理的方式，程序員只需要寫DAO接口，DAO接口實現對象由mybatis自動生成代理對象。本身DAO在三層架構中就是一個通用的接口。

原始DAO開發方式的問題

 

  • DAO的實現類中存在重複代碼，整個mybatis操作的過程代碼模板重複(先創建SqlSession、調用SqlSession的方法、關閉SqlSession)
  • DAO的實現類中存在硬編碼，調用SqlSession方法時將statement的id硬編碼。

 

mapper開發規範

要想讓mybatis自動創建DAO接口實現類的代理對象，必須遵循一些規則：

1.mapper.xml中namespace指定爲mapper接口的全限定名。

 

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE mapper  
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5. <!-- namespace命名空間，爲了對SQL語句進行隔離，方便管理，mapper可開發dao方式，使用namespace有特殊作用   
  6. mapper代理開發時將namespace指定爲mapper接口的全限定名 -->  
  7. <mapper namespace="test.lx.mybatis.mapper.UserMapper">  
  8. ......  

此步驟目的：通過mapper.xml和mapper.java進行關聯

 

2.mapper.xml中statement的id就是mapper.java中的方法名。

3.mapper.xml中statement的parameterType和mapper.java中方法輸入參數類型一致。

4.mapper.xml中statement的resultType和mapper.java中方法返回值一致。

mapper.xml(映射文件)

mapper映射文件的命名方式建議: 表名Mapper.xml

namespace指定爲mapper接口的全限定名

 

[html] view plain copy

  1. <!-- 根據id查詢用戶信息 -->  
  2. <!--   
  3.    id: 唯一標識一個statement  
  4.    #{}：表示一個佔位符，如果#{} 中傳入簡單類型的參數，#{}中的名稱隨意  
  5.    parameterType: 輸入參數的類型，通過#{}接收parameterType輸入的參數  
  6.    resultType：輸出結果類型，不管返回是多條還是單條，指定單條記錄映射的pojo類型  
  7.  -->  
  8.  <select id="findUserById" parameterType="int" resultType="test.lx.mybatis.po.User">  
  9.     SELECT * FROM USER WHERE id=#{id};  
  10.  </select>  

 

mapper接口

mybatis提出了mapper接口，相當於DAO接口

mapper接口的命名方式建議: 表名Mapper

[html] view plain copy

  1. public interface UserMapper {  
  2.     
  3.     //根據用戶id查詢用戶信息  
  4.     public User findUserById(int id) throws Exception;  
  5. }  

將mapper.xml在SqlMapConfig.xml中加載

 

 

[html] view plain copy

  1. <!-- 加載mapper文件 -->  
  2.     <mappers>  
  3.         <mapper resource="sqlmap/User.xml" />  
  4.         <mapper resource="test/lx/mybatis/mapper/UserMapper.xml"/>  
  5.     </mappers>  

 

mapper接口返回單個對象和集合對象

不管查詢記錄是單條還是多條，在statement中resultType定義一致，都是單條記錄映射的pojo類型。

mapper接口方法返回值，如果是返回的單個對象，返回值類型是pojo類型，生成的代理對象內部通過selectOne獲取記錄，如果返回值類型是集合對象，生成的代理對象內部通過selectList獲取記錄。

[java] view plain copy

  1. //根據用戶id查詢用戶信息  
  2.     public User findUserById(int id) throws Exception;  
  3.       
  4.     //根據用戶姓名查詢用戶信息  
  5.     public List<User> findUserByName(String username) throws Exception;  

問題

返回值問題

如果方法調用的statement，返回的是多條記錄，而mapper.java方法的返回值爲pojo，此時代理對象通過selectOne調用，由於返回多條記錄，所以報錯：

org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 4

 

輸入參數的問題

使用mapper代理的方式開發，mapper接口方法輸入參數只有一個，可擴展性是否很差？

擴展性沒有任何問題，因爲DAO層就是通用的，可以通過擴展pojo(定義pojo包裝類型)將不同的參數(可以是pojo也可以是簡單類型)傳入進去。

SqlMapConfig.xml

SqlMapConfig.xml中配置的內容和順序如下：

properties（屬性）

settings（全局配置參數）

typeAliases（類型別名）

typeHandlers（類型處理器）

objectFactory（對象工廠）

plugins（插件）

environments（環境集合屬性對象）

       environment（環境子屬性對象）

               transactionManager（事務管理器）

               dataSource（數據源）

mappers（映射器）

properties屬性定義

可以把一些通用的屬性值配置在屬性文件中，加載到mybatis運行環境內，比如：創建db.properties配置數據庫連接參數。

 

[html] view plain copy

  1. <!-- 屬性定義  
  2.             加載一個properties文件  
  3.             在properties標籤中配置屬性值  
  4.     -->  
  5.     <properties resource="db.properties">  
  6.         <!-- <property name="" value=""/> -->  
  7.     </properties>  
  8. <!-- 和Spring整合後environments配置將廢除 -->  
  9. <environments default="development">  
  10.     <environment id="development">  
  11.         <!-- 使用jdbc事務管理 -->  
  12.         <transactionManager type="JDBC" />  
  13.         <dataSource type="POOLED">  
  14.             <property name="driver" value="${jdbc.driver}" />  
  15.             <property name="url" value="${jdbc.url}" />  
  16.             <property name="username" value="${jdbc.username}" />  
  17.             <property name="password" value="${jdbc.password}" />  
  18.         </dataSource>  
  19.     </environment>  
  20. </environments>  

 

注意：Mybatis將按照下面的順序加載屬性：

 

 

  • 在properties元素體內定義的屬性首先被讀取。
  • 然後會讀取properties元素中resource或url加載的屬性，它會覆蓋已經讀取的同名屬性。
  • 最後讀取parameterType傳遞的屬性，它會覆蓋已經讀取的同名屬性。

 

建議使用properties，不要在properties中定義屬性，只引用定義的properties文件中的屬性，並且properties中定義的key要有一些特殊的規則。

settings全局參數配置

mybatis運行時可以調整一些全局參數，根據使用需求進行參數配置。注意：需要小心配置，配置的參數會影響mybatis的執行。

ibatis的全局配置參數中包括很多的性能參數(最大線程數，最大等待時間...)，通過調整這些參數使ibatis達到高性能的運行，mybatis沒有這些性能參數，由mybatis自行調節。

mybatis中全局參數配置示例如下：

 

[html] view plain copy

  1. <settings>  
  2.        <setting name="cacheEnabled" value="true"/>  
  3.     </settings>  

還有許多全局參數，根據需求進行配置，如下表所示：

 

Setting(設置)  Description（描述） Valid Values(驗證值組)Default(默認值)

  • cacheEnabled 在全局範圍內啓用或禁用緩存配置任何映射器在此配置下。取值範圍(true | false),默認值爲TRUE
  • lazyLoadingEnabled 在全局範圍內啓用或禁用延遲加載。禁用時，所有協會將熱加載。取值範圍(true | false),默認值爲TRUE
  • aggressiveLazyLoading 啓用時，有延遲加載屬性的對象將被完全加載後調用懶惰的任何屬性。否則，每一個屬性是按需加載。取值範圍(true | false),默認值爲TRUE
  • multipleResultSetsEnabled 允許或不允許從一個單獨的語句（需要兼容的驅動程序）要返回多個結果集。取值範圍(true | false)默認值爲TRUE。
  • useColumnLabel 使用列標籤，而不是列名。在這方面，不同的驅動有不同的行爲。參考驅動文檔或測試兩種方法來決定你的驅動程序的行爲如何。取值範圍(true | false)，默認值爲TRUE。
  • useGeneratedKeys 允許JDBC支持生成的密鑰。兼容的驅動程序是必需的。此設置強制生成的鍵被使用，如果設置爲true，一些驅動會不兼容性，但仍然可以工作。取值範圍(true | false)，默認值爲FALSE。
  • autoMappingBehavior 指定MyBatis的應如何自動映射列到字段/屬性。NONE自動映射。 PARTIAL只會自動映射結果沒有嵌套結果映射定義裏面。 FULL會自動映射的結果映射任何複雜的（包含嵌套或其他）。取值範圍(NONE, PARTIAL, FULL),默認值爲PARTIAL。
  • defaultExecutorType 配置默認執行器。SIMPLE執行器確實沒有什麼特別的。 REUSE執行器重用準備好的語句。 BATCH執行器重用語句和批處理更新。取值範圍(SIMPLE REUSE BATCH),默認值爲SIMPLE。
  • defaultStatementTimeout 設置驅動程序等待一個數據庫響應的秒數。任意整型不允許爲空(Any positive integer  Not Set (null))。
  • safeRowBoundsEnabled 允許使用嵌套的語句RowBounds。取值範圍(true | false)，默認值爲FALSE。
  • mapUnderscoreToCamelCase 從經典的數據庫列名A_COLUMN啓用自動映射到駱駝標識的經典的Java屬性名aColumn。取值範圍(true | false)，默認值爲FALSE。
  • localCacheScope MyBatis的使用本地緩存，以防止循環引用，並加快反覆嵌套查詢。默認情況下（SESSION）會話期間執行的所有查詢緩存。如果localCacheScope=STATMENT本地會話將被用於語句的執行，只是沒有將數據共享之間的兩個不同的調用相同的SqlSession。取值範圍(SESSION | STATEMENT),默認值爲SESSION。
  • dbcTypeForNull  指定爲空值時，沒有特定的JDBC類型的參數的JDBC類型。有些驅動需要指定列的JDBC類型，但其他像NULL，VARCHAR或OTHER的工作與通用值。JdbcType enumeration. Most common are: NULL, VARCHAR and OTHEROTHER
  • lazyLoadTriggerMethods 指定觸發延遲加載的對象的方法。A method name list separated by commas equals,clone,hashCode,toString
  • defaultScriptingLanguage 指定所使用的語言默認爲動態SQL生成。A type alias or fully qualified class name.org.apache.ibatis.scripting.xmltags.XMLDynamicLanguageDriver
  • callSettersOnNulls 指定如果setter方法​​或地圖的put方法時，將調用檢索到的值是null。它是有用的，當你依靠Map.keySet（）或null初始化。注意原語（如整型，布爾等）不會被設置爲null。取值範圍(true | false)FALSE
  • logPrefix 指定的前綴字串，MyBatis將會增加記錄器的名稱。Any StringNot set
  • logImpl 指定MyBatis的日誌實現使用。如果此設置是不存在的記錄的實施將自動查找。SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGINGNot set
  • proxyFactory 指定代理工具，MyBatis將會使用創建懶加載能力的對象。CGLIB | JAVASSIST

 

 

typeAliases別名(常用)

mybatis提供的別名

 

 

別名

映射的類型

_byte

byte

_long

long

_short

short

_int

int

_integer

int

_double

double

_float

float

_boolean

boolean

string

String

byte

Byte

long

Long

short

Short

int

Integer

integer

Integer

double

Double

float

Float

boolean

Boolean

date

Date

decimal

BigDecimal

bigdecimal

BigDecimal

自定義別名

[html] view plain copy

  1. <!-- 定義別名 -->  
  2.      <typeAliases>  
  3.      <!--   
  4.          單個別名定義  
  5.          alias:別名, type:別名映射類型  
  6.          <typeAlias type="test.lx.mybatis.po.User" alias="user"/>  
  7.       -->  
  8.       <!-- 批量別名定義  
  9.          指定包路徑，自動掃描包內的pojo,定義別名，別名默認爲類名(首字母小寫或大寫)             
  10.        -->  
  11.        <package name="test.lx.mybatis.po"/>  
  12.      </typeAliases>  

使用別名

在parameterType、resultType中使用別名：

[html] view plain copy

  1. <!-- 根據id查詢用戶信息 -->  
  2.  <!--   
  3.     id: 唯一標識一個statement  
  4.     #{}：表示一個佔位符，如果#{} 中傳入簡單類型的參數，#{}中的名稱隨意  
  5.     parameterType: 輸入參數的類型，通過#{}接收parameterType輸入的參數  
  6.     resultType：輸出結果類型，不管返回是多條還是單條，指定單條記錄映射的pojo類型  
  7.   -->  
  8.   <select id="findUserById" parameterType="int" resultType="user">  
  9.      SELECT * FROM USER WHERE id=#{id};  
  10.   </select>  

typeHandlers

類型處理器將Java類型和jdbc類型進行映射。

mybatis默認提供很多類型處理器，一般情況下足夠使用。

mappers

[html] view plain copy

  1. <!-- 加載mapper映射  
  2.     如果和Spring整合後，可以使用整合包中的mapper掃描器，到那時此處的mapper就不用配置了  
  3.     -->  
  4.     <mappers>  
  5.          <!-- 通過resource映入mapper的映射文件 -->  
  6.         <mapper resource="sqlmap/User.xml" />  
  7.         <!-- <mapper resource="test/lx/mybatis/mapper/UserMapper.xml"/> -->  
  8.         <!-- 通過class引用mapper接口  
  9.              class：配置mapper接口的全限定名  
  10.              要求：需要mapper.xml和mapper.java同名並且在同一目錄中  
  11.          -->  
  12.         <!-- <mapper class="test.lx.mybatis.mapper.UserMapper"/> -->  
  13.         <!-- 批量mapper配置  
  14.              通過package進行自動掃描包下邊的mapper接口  
  15.              要求：需要mapper.xml和mapper.java同名並在同一目錄中  
  16.          -->  
  17.         <package name="test.lx.mybatis.mapper"/>  
  18.     </mappers>  

輸入和輸出映射

通過parameterType完成輸入映射，通過resultType和resultMap完成輸出映射。

parameterType傳遞pojo包裝對象

可以自定義pojo包裝類型擴展mapper接口輸入參數的內容。

需求：自定義查詢條件查詢用戶信息，需要向statement輸入查詢條件，查詢條件可以有user信息，商品信息......

定義包裝類型

[java] view plain copy

  1. public class UserQueryVo {  
  2.     //用戶信息  
  3.     private User user;  
  4.       
  5.     //自定義User的擴展對象  
  6.     private UserCustom userCustom;  
  7.     //提供對應的getter和setter方法  
  8.         ......  
  9. }  

mapper.xml

[html] view plain copy

  1. <!-- 自定義查詢條件查詢用戶信息   
  2.   parameterType: 指定包裝類型  
  3.   %${userCustom.username}%: userCustom是userQueryVo中的屬性，通過OGNL獲取屬性的值  
  4.   -->  
  5.   <select id="findUserList" parameterType="userQueryVo" resultType="user">  
  6.      select * from user where username like '%${userCustom.username}%'  
  7.   </select>  

mapper.java

[java] view plain copy

  1. //自定義查詢條件查詢用戶信息  
  2.     public List<User> findUserList(UserQueryVo userQueryVo) throws Exception;  

測試

[java] view plain copy

  1. //通過包裝類型查詢用戶信息  
  2.     @Test  
  3.     public void testFindUserList() throws Exception {  
  4.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  5.         // 創建代理對象  
  6.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  7.         // 構造查詢條件  
  8.         UserQueryVo userQueryVo = new UserQueryVo();  
  9.         UserCustom userCustom = new UserCustom();  
  10.         userCustom.setUsername("小明");  
  11.         userQueryVo.setUserCustom(userCustom);  
  12.   
  13.         List<User> list = userMapper.findUserList(userQueryVo);  
  14.         System.out.println(list);  
  15.     }  

異常

如果parameterType中指定屬性錯誤，會拋出異常，找不到getter方法：org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'userCusto' in class …

注意：如果將來和Spring整合後，不是通過getter方法來獲取獲取屬性值，而是通過反射強讀pojo的屬性值。

resultType

指定輸出結果的類型(pojo、簡單類型、hashmap...),將SQL查詢結果映射爲Java對象。

返回簡單類型

mapper.xml

[html] view plain copy

  1. <!-- 輸出簡單類型  
  2.   功能：自定義查詢條件，返回查詢記錄個數，通常用於實現查詢分頁  
  3.    -->  
  4.    <select id="findUserCount" parameterType="userQueryVo" resultType="int">  
  5.     select count(*) from user where username like '%${userCustom.username}%'  
  6.    </select>  

mapper.java

[java] view plain copy

  1. //查詢用戶返回記錄個數  
  2.     public int findUserCount(UserQueryVo userQueryVo) throws Exception;  

測試代碼

[java] view plain copy

  1. //返回查詢記錄總數  
  2.     @Test  
  3.     public void testFindUserCount() throws Exception{  
  4.         SqlSession sqlSession  =sqlSessionFactory.openSession();  
  5.         //創建代理對象  
  6.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  7.         //構建查詢條件  
  8.         UserQueryVo userQueryVo = new UserQueryVo();  
  9.         UserCustom userCustom = new UserCustom();  
  10.         userCustom.setUsername("小明");  
  11.         userQueryVo.setUserCustom(userCustom);  
  12.           
  13.         int count = userMapper.findUserCount(userQueryVo);  
  14.         System.out.println(count);  
  15.                   
  16.     }  

注意：如果查詢記錄結果集爲一條記錄且一列 才適合返回簡單類型。

resultMap(入門)

resultType：指定輸出結果的類型(pojo、簡單類型、hashmap),將SQL查詢結果映射爲Java對象。

使用resultType注意：sql查詢的列名要和resultType指定pojo的屬性相同，指定相同，屬性方可映射成功。如果sql查詢的列名要和resultType指定pojo的屬性全部不相同，list中是無法創建pojo對象的。有幾個屬性對應相同，則能給對應相同的屬性賦值。
resultMap：將SQL查詢結果映射爲Java對象。如果SQL查詢列名和最終要映射的pojo的屬性名不一致，使用resultMap將列名和pojo的屬性名做一個映射關係(列名和屬性名映射配置)。

resultMap配置

[html] view plain copy

  1. <!-- 定義resultMap，列名和屬性名映射配置  
  2.  id: mapper.xml中唯一標識  
  3.  type: 最終要映射的pojo類型  
  4.   -->  
  5.   <resultMap id="userListResultMap" type="user" >  
  6.       <!-- 列名  
  7.       id,username_,birthday_  
  8.       id:要映射結果集的唯一標識，稱爲主鍵  
  9.       column: 結果集的列名  
  10.       property:type指定pojo中的某個屬性  
  11.       -->  
  12.       <id column="id_" property="id" />  
  13.       <!-- result就是普通列的映射配置 -->  
  14.       <result column="username_" property="username"/>  
  15.       <result column="birthday_" property="birthday"/>  
  16.   </resultMap>  

使用resultMap

[html] view plain copy

  1. <!-- 使用resultMap作爲結果映射  
  2.  resultMap: 如果引用resultMap的位置和resultMap的定義在同一個mapper.xml中，  
  3.  直接使用resultMap的id,如果不在同一個mapper.xml中，要在引用resultMap的id前邊加namespace  
  4.   -->  
  5.  <select id="findUserListResultMap" parameterType="userQueryVo" resultMap="userListResultMap">  
  6.     select id id_,username username_,birthday birthday_ from user where username like '%${userCustom.username}%'  
  7.  </select>  

mapper.java

[java] view plain copy

  1. //查詢用戶，使用resultMap進行映射  
  2.     public List<User> findUserListResultMap(UserQueryVo userQueryVo) throws Exception;  

動態SQL(重點)

需求

將自定義查詢條件查詢用戶列表和查詢用戶列表總記錄數改爲動態SQL。

if和where

[html] view plain copy

  1. <!-- where標籤相當於where關鍵字，可以自動除去第一個and -->  
  2.     <where>  
  3.        <!-- 如果userQueryVo中傳入查詢條件，在進行SQL拼接 -->  
  4.        <!-- test中userCustom.username表示從userQueryVo中讀取屬性值 -->  
  5.        <if test="userCustom!=null">  
  6.         <if test="userCustom.username!=null and userCustom.username.trim().length() > 0">  
  7.             and username like '%${userCustom.username.trim()}%'  
  8.         </if>  
  9.         <if test="userCustom.sex!=null and userCustom.sex!=''">  
  10.             and sex = #{userCustom.sex}  
  11.         </if>  
  12.         <!-- 還可以添加更多的查詢條件 -->  
  13.           
  14.        </if>  
  15.     </where>  

sql片段

通過sql片段可以將通用的SQL語句抽取出來，單獨定義，在其它的statement中可以引用SQL片段。

即通用的SQL語句，常用的：where條件、查詢列

sql片段的定義

[html] view plain copy

  1. <!-- 將用戶查詢條件定義爲SQL片段  
  2.      建議對單表的查詢條件單獨抽取成SQL片段，提高公用性  
  3.      注意：不要講where標籤放在SQL片段,因爲where條件中可能有多個SQL片段進行結合  
  4.       -->  
  5.       <sql id="query_user_where">  
  6.             <!-- 如果userQueryVo中傳入查詢條件，在進行SQL拼接 -->  
  7.             <!-- test中userCustom.username表示從userQueryVo中讀取屬性值 -->  
  8.             <if test="userCustom!=null">  
  9.                 <if test="userCustom.username!=null and userCustom.username.trim().length() > 0">  
  10.                     and username like '%${userCustom.username.trim()}%'  
  11.                 </if>  
  12.                 <if test="userCustom.sex!=null and userCustom.sex!=''">  
  13.                     and sex = #{userCustom.sex}  
  14.                 </if>  
  15.                 <!-- 還可以添加更多的查詢條件 -->  
  16.                   
  17.             </if>  
  18.       </sql>  

引用sql片段

在查詢用戶數據中引用

[html] view plain copy

  1. <select id="findUserList" parameterType="userQueryVo" resultType="user">  
  2.          select * from user   
  3.          <!-- where標籤相當於where關鍵字，可以自動除去第一個and -->  
  4.          <where>  
  5.            <!-- 引用sql片段，如果sql片段和引用處不在同一個mapper 必須在前邊加namespace. -->  
  6.            <include refid="query_user_where"></include>  
  7.            <!-- 下邊還有很多其它的條件 -->  
  8.            <!-- <include refid="其它的sql片段"></include> -->  
  9.          </where>  
  10.       </select>  

在查詢用戶數據總數量中引用

[html] view plain copy

  1. <!-- 輸出簡單類型  
  2.   功能：自定義查詢條件，返回查詢記錄個數，通常用於實現查詢分頁  
  3.    -->  
  4.    <select id="findUserCount" parameterType="userQueryVo" resultType="int">  
  5.     select count(*) from user   
  6.     <!-- where標籤相當於where關鍵字，可以自動除去第一個and -->  
  7.      <where>  
  8.        <!-- 引用sql片段，如果sql片段和引用處不在同一個mapper 必須在前邊加namespace. -->  
  9.        <include refid="query_user_where"></include>  
  10.        <!-- 下邊還有很多其它的條件 -->  
  11.        <!-- <include refid="其它的sql片段"></include> -->  
  12.      </where>  
  13.    </select>  

foreach

在statement中通過foreach遍歷parameterType中的集合類型

需求：假設根據多個用戶id查詢用戶信息

在userQueryVo中定義list<Integer> ids;

在UserQueryVo中定義List<Integer> ids存儲多個id

[java] view plain copy

  1. public class UserQueryVo {  
  2.     //用戶信息  
  3.     private User user;  
  4.       
  5.     //自定義User的擴展對象  
  6.     private UserCustom userCustom;  
  7.       
  8.     //用戶id集合  
  9.     private List<Integer> ids;  
  10.        //添加對應的setter和getter方法  
  11.        ......  
  12. }  

修改where語句

使用foreach遍歷list

[html] view plain copy

  1. <!-- 根據id集合查詢用戶信息 -->  
  2.                 <!-- 最終拼接的效果：  
  3.                 SELECT id,username,birthday FROM USER WHERE username LIKE '%小明%' AND id IN (16,22,25)  
  4.                 collection: pojo中的表示集合的屬性  
  5.                 open: 開始循環拼接的串  
  6.                 close: 結束循環拼接的串  
  7.                 item: 每次循環從集合中取到的對象  
  8.                 separator: 沒兩次循環中間拼接的串  
  9.                  -->  
  10.                 <foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=",">  
  11.                     #{id}  
  12.                 </foreach>  
  13.                 <!--   
  14.                  SELECT id ,username ,birthday  FROM USER WHERE username LIKE '%小明%' AND (id = 16 OR id = 22 OR id = 25)   
  15.                  <foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=" OR ">  
  16.                     id=#{id}  
  17.                  </foreach>  
  18.                  -->  

測試代碼

[java] view plain copy

  1. //id集合  
  2.         List<Integer> ids = new ArrayList<Integer>();  
  3.         ids.add(16);  
  4.         ids.add(22);  
  5.         userQueryVo.setIds(ids);  
  6.   
  7.         List<User> list = userMapper.findUserList(userQueryVo);  

 

最終Demo代碼如下：(GitHub地址：https://github.com/LX1993728/mybatisDemo_1)

UserDao

[java] view plain copy

  1. package test.lx.mybatis.dao;  
  2.   
  3. import java.util.List;  
  4.   
  5. import test.lx.mybatis.po.User;  
  6.   
  7. /** 
  8.  * 用戶DAO 
  9.  *  
  10.  * @author lx 
  11.  *  
  12.  */  
  13. public interface UserDao {  
  14.     // 根據id查詢用戶信息  
  15.     public User findUserById(int id) throws Exception;  
  16.   
  17.     // 根據用戶名稱模糊查詢用戶列表  
  18.     public List<User> findUserByUsername(String username) throws Exception;  
  19.   
  20.     // 插入用戶  
  21.     public void insertUser(User user) throws Exception;  
  22. }  

UserDaoImpl

[java] view plain copy

  1. package test.lx.mybatis.dao;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.apache.ibatis.session.SqlSession;  
  6. import org.apache.ibatis.session.SqlSessionFactory;  
  7.   
  8. import test.lx.mybatis.po.User;  
  9.   
  10. public class UserDaoImpl implements UserDao {  
  11.    private SqlSessionFactory sqlSessionFactory;  
  12.      
  13.    //將SqlSessionFactory注入  
  14.    public UserDaoImpl(SqlSessionFactory sqlSessionFactory){  
  15.        this.sqlSessionFactory = sqlSessionFactory;  
  16.    }  
  17.       
  18.     public User findUserById(int id) throws Exception {  
  19.         //創建SqlSession  
  20.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  21.           
  22.         //根據id查詢用戶信息  
  23.         User user = sqlSession.selectOne("test.findUserById", id);  
  24.         sqlSession.close();  
  25.         return user;  
  26.     }  
  27.   
  28.       
  29.     public List<User> findUserByUsername(String username) throws Exception {  
  30.         //創建SqlSession  
  31.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  32.         List<User> list = sqlSession.selectList("test.findUserByName", username);  
  33.         sqlSession.close();  
  34.         return list;  
  35.     }  
  36.   
  37.       
  38.     public void insertUser(User user) throws Exception {  
  39.         //創建SqlSession  
  40.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  41.         sqlSession.insert("test.insertUser", user);  
  42.         sqlSession.commit();  
  43.         sqlSession.close();  
  44.     }  
  45.   
  46. }  

MyBatisFirst

[java] view plain copy

  1. package test.lx.mybatis.first;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.util.Date;  
  6. import java.util.List;  
  7.   
  8. import org.apache.ibatis.io.Resources;  
  9. import org.apache.ibatis.session.SqlSession;  
  10. import org.apache.ibatis.session.SqlSessionFactory;  
  11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  12. import org.junit.Before;  
  13. import org.junit.Test;  
  14.   
  15. import test.lx.mybatis.po.User;  
  16.   
  17. /** 
  18.  * mybatis入門程序 
  19.  *  
  20.  * @author lx 
  21.  *  
  22.  */  
  23. public class MybatisFirst {  
  24.         // 會話工廠  
  25.         private SqlSessionFactory sqlSessionFactory;  
  26.         // 創建工廠  
  27.         @Before  
  28.         public void init() throws IOException {  
  29.   
  30.             // 配置文件（SqlMapConfig.xml）  
  31.             String resource = "SqlMapConfig.xml";  
  32.   
  33.             // 加載配置文件到輸入 流  
  34.             InputStream inputStream = Resources.getResourceAsStream(resource);  
  35.   
  36.             // 創建會話工廠  
  37.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  38.   
  39.         }  
  40.   
  41.         // 測試根據id查詢用戶(得到單條記錄)  
  42.         @Test  
  43.         public void testFindUserById() {  
  44.   
  45.             // 通過sqlSessionFactory創建sqlSession  
  46.   
  47.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  48.   
  49.             // 通過sqlSession操作數據庫  
  50.             // 第一個參數：statement的位置，等於namespace+statement的id  
  51.             // 第二個參數：傳入的參數  
  52.             User user = null;  
  53.             try {  
  54.                 user = sqlSession.selectOne("test.findUserById", 1);  
  55.             } catch (Exception e) {  
  56.                 e.printStackTrace();  
  57.             } finally {  
  58.                 // 關閉sqlSession  
  59.                 sqlSession.close();  
  60.             }  
  61.   
  62.             System.out.println(user);  
  63.   
  64.         }  
  65.         // 測試根據名稱模糊查詢用戶(可能得到多條記錄)  
  66.         @Test  
  67.         public void testFindUserByName() {  
  68.               
  69.             // 通過sqlSessionFactory創建sqlSession  
  70.               
  71.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  72.               
  73.             // 通過sqlSession操作數據庫  
  74.             // 第一個參數：statement的位置，等於namespace+statement的id  
  75.             // 第二個參數：傳入的參數  
  76.             List<User> list = null;  
  77.             try {  
  78.                 //list = sqlSession.selectList("test.findUserByName", "小明");  
  79.                 list = sqlSession.selectList("test.findUserByName2", "%小明%");  
  80.             } catch (Exception e) {  
  81.                 e.printStackTrace();  
  82.             } finally {  
  83.                 // 關閉sqlSession  
  84.                 sqlSession.close();  
  85.             }  
  86.               
  87.             System.out.println(list.size());  
  88.         }  
  89.         // 測試插入用戶  
  90.         @Test  
  91.         public void testInsertUser() {  
  92.             // 通過sqlSessionFactory創建sqlSession  
  93.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  94.               
  95.             //通過sqlSession操作數據庫  
  96.             //創建插入數據對象  
  97.             User user = new User();  
  98.             user.setUsername("一蓑煙雨");  
  99.             user.setAddress("河南周口");  
  100.             user.setBirthday(new Date());  
  101.             user.setSex("1");  
  102.             try {  
  103.                 sqlSession.insert("test.insertUser", user);  
  104.                 //需要提交事務  
  105.                 sqlSession.commit();  
  106.             } catch (Exception e) {  
  107.                 e.printStackTrace();  
  108.             } finally {  
  109.                 // 關閉sqlSession  
  110.                 sqlSession.close();  
  111.             }  
  112.             System.out.println(user.getId());  
  113.         }  
  114.         // 測試刪除用戶  
  115.         @Test  
  116.         public void testDeleteUser() {  
  117.             // 通過sqlSessionFactory創建sqlSession  
  118.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  119.               
  120.             //通過sqlSession操作數據庫  
  121.             try {  
  122.                 sqlSession.delete("test.deleteUser", 28);  
  123.                 //需要提交事務  
  124.                 sqlSession.commit();  
  125.             } catch (Exception e) {  
  126.                 e.printStackTrace();  
  127.             } finally {  
  128.                 // 關閉sqlSession  
  129.                 sqlSession.close();  
  130.             }  
  131.         }  
  132.         // 測試根據id更新用戶(得到單條記錄)  
  133.         @Test  
  134.         public void testUpdateUser() {  
  135.             // 通過sqlSessionFactory創建sqlSession  
  136.             SqlSession sqlSession = sqlSessionFactory.openSession();  
  137.               
  138.             //通過sqlSession操作數據庫  
  139.             //創建更新數據庫對象，要求必須包括id  
  140.             User user= new User();  
  141.             user.setId(28);  
  142.             user.setUsername("任平生");  
  143.             //凡是沒有設置的屬性都被當成了NULL進行賦值  
  144.             //user.setBirthday(new Date());  
  145.             user.setSex("1");  
  146.               
  147.             try {  
  148.                 sqlSession.delete("test.updateUser", user);  
  149.                 //需要提交事務  
  150.                 sqlSession.commit();  
  151.             } catch (Exception e) {  
  152.                 e.printStackTrace();  
  153.             } finally {  
  154.                 // 關閉sqlSession  
  155.                 sqlSession.close();  
  156.             }  
  157.         }  
  158.   
  159. }  

JdbcTest

[java] view plain copy

  1. package test.lx.mybatis.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.DriverManager;  
  5. import java.sql.PreparedStatement;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8.   
  9. /** 
  10.  * jdbc的測試程序 
  11.  *  
  12.  * @author lx 
  13.  *  
  14.  */  
  15. public class JdbcTest {  
  16.     public static void main(String[] args) {  
  17.         Connection connection = null;  
  18.         //PreparedStatement是預編譯的Statement，通過Statement發起數據庫的操作  
  19.         //PreparedStatement防止sql注入，執行數據庫效率高  
  20.         PreparedStatement preparedStatement = null;  
  21.         ResultSet resultSet = null;  
  22.           
  23.         try {  
  24.             //加載數據庫驅動  
  25.             Class.forName("com.mysql.jdbc.Driver");  
  26.               
  27.             //通過驅動管理類獲取數據庫鏈接  
  28.             connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");  
  29.             //定義sql語句 ?表示佔位符  
  30.         String sql = "select * from user where username = ?" ;  
  31.             //獲取預處理statement  
  32.             preparedStatement = connection.prepareStatement(sql);  
  33.             //設置參數，第一個參數爲sql語句中參數的序號（從1開始），第二個參數爲設置的參數值  
  34.             preparedStatement.setString(1, "王五");  
  35.             //向數據庫發出sql執行查詢，查詢出結果集  
  36.             resultSet =  preparedStatement.executeQuery();  
  37.             //遍歷查詢結果集  
  38.             while(resultSet.next()){  
  39.                 System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));  
  40.             }  
  41.         } catch (Exception e) {  
  42.             e.printStackTrace();  
  43.         }finally{  
  44.             //釋放資源  
  45.             if(resultSet!=null){  
  46.                 try {  
  47.                     resultSet.close();  
  48.                 } catch (SQLException e) {  
  49.                     // TODO Auto-generated catch block  
  50.                     e.printStackTrace();  
  51.                 }  
  52.             }  
  53.             if(preparedStatement!=null){  
  54.                 try {  
  55.                     preparedStatement.close();  
  56.                 } catch (SQLException e) {  
  57.                     // TODO Auto-generated catch block  
  58.                     e.printStackTrace();  
  59.                 }  
  60.             }  
  61.             if(connection!=null){  
  62.                 try {  
  63.                     connection.close();  
  64.                 } catch (SQLException e) {  
  65.                     // TODO Auto-generated catch block  
  66.                     e.printStackTrace();  
  67.                 }  
  68.             }  
  69.   
  70.         }  
  71.   
  72.     }  
  73. }  

UserMapper.java

[java] view plain copy

  1. package test.lx.mybatis.mapper;  
  2.   
  3. import java.util.List;  
  4.   
  5. import test.lx.mybatis.po.User;  
  6. import test.lx.mybatis.po.UserQueryVo;  
  7.   
  8. /** 
  9.  * 用戶mapper 
  10.  *  
  11.  * @author lx 
  12.  * 
  13.  */  
  14. public interface UserMapper {  
  15.   
  16.     // 根據用戶id查詢用戶信息  
  17.     public User findUserById(int id) throws Exception;  
  18.   
  19.     // 根據用戶姓名查詢用戶信息  
  20.     public List<User> findUserByName(String username) throws Exception;  
  21.   
  22.     // 自定義查詢條件查詢用戶信息  
  23.     public List<User> findUserList(UserQueryVo userQueryVo) throws Exception;  
  24.   
  25.     // 查詢用戶，使用resultMap進行映射  
  26.     public List<User> findUserListResultMap(UserQueryVo userQueryVo) throws Exception;  
  27.   
  28.     // 查詢用戶返回記錄個數  
  29.     public int findUserCount(UserQueryVo userQueryVo) throws Exception;  
  30.   
  31.     // 插入用戶  
  32.     public void insertUser(User user) throws Exception;  
  33.   
  34.     // 刪除用戶  
  35.     public void deleteUser(int id) throws Exception;  
  36.   
  37.     // 修改用戶  
  38.     public void updateUser(User user) throws Exception;  
  39. }  

UserMapper.xml

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE mapper  
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5. <!-- namespace命名空間，爲了對SQL語句進行隔離，方便管理，mapper可開發dao方式，使用namespace有特殊作用   
  6. mapper代理開發時將namespace指定爲mapper接口的全限定名 -->  
  7. <mapper namespace="test.lx.mybatis.mapper.UserMapper">  
  8. <!-- 在mapper.xml文件中配置很多的SQL語句，執行每個SQL語句時，封裝爲MappedStatement對象  
  9. mapper.xml以statement爲單位管理SQL語句  
  10.  -->  
  11.    
  12.      <!-- 將用戶查詢條件定義爲SQL片段  
  13.      建議對單表的查詢條件單獨抽取成SQL片段，提高公用性  
  14.      注意：不要講where標籤放在SQL片段,因爲where條件中可能有多個SQL片段進行結合  
  15.       -->  
  16.       <sql id="query_user_where">  
  17.             <!-- 如果userQueryVo中傳入查詢條件，在進行SQL拼接 -->  
  18.             <!-- test中userCustom.username表示從userQueryVo中讀取屬性值 -->  
  19.             <if test="userCustom!=null">  
  20.                 <if test="userCustom.username!=null and userCustom.username.trim().length() > 0">  
  21.                     and username like '%${userCustom.username.trim()}%'  
  22.                 </if>  
  23.                 <if test="userCustom.sex!=null and userCustom.sex!=''">  
  24.                     and sex = #{userCustom.sex}  
  25.                 </if>  
  26.                 <!-- 根據id集合查詢用戶信息 -->  
  27.                 <!-- 最終拼接的效果：  
  28.                 SELECT id,username,birthday FROM USER WHERE username LIKE '%小明%' AND id IN (16,22,25)  
  29.                 collection: pojo中的表示集合的屬性  
  30.                 open: 開始循環拼接的串  
  31.                 close: 結束循環拼接的串  
  32.                 item: 每次循環從集合中取到的對象  
  33.                 separator: 沒兩次循環中間拼接的串  
  34.                  -->  
  35.                  <if test="ids != null and ids.size()>0">  
  36.                     <foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=",">  
  37.                         #{id}  
  38.                     </foreach>  
  39.                  </if>  
  40.                 <!--   
  41.                  SELECT id ,username ,birthday  FROM USER WHERE username LIKE '%小明%' AND (id = 16 OR id = 22 OR id = 25)   
  42.                  <foreach collection="ids" open=" AND id IN (" close=")" item="id" separator=" OR ">  
  43.                     id=#{id}  
  44.                  </foreach>  
  45.                  -->  
  46.                 <!-- 還可以添加更多的查詢條件 -->  
  47.                   
  48.             </if>  
  49.       </sql>  
  50.        
  51.      <!-- 定義resultMap，列名和屬性名映射配置  
  52.      id: mapper.xml中唯一標識  
  53.      type: 最終要映射的pojo類型  
  54.       -->  
  55.       <resultMap id="userListResultMap" type="user" >  
  56.           <!-- 列名  
  57.           id,username_,birthday_  
  58.           id:要映射結果集的唯一標識，稱爲主鍵  
  59.           column: 結果集的列名  
  60.           property:type指定pojo中的某個屬性  
  61.           -->  
  62.           <id column="id_" property="id" />  
  63.           <!-- result就是普通列的映射配置 -->  
  64.           <result column="username_" property="username"/>  
  65.           <result column="birthday_" property="birthday"/>  
  66.       </resultMap>  
  67.        
  68.      <!-- 根據id查詢用戶信息 -->  
  69.      <!--   
  70.         id: 唯一標識一個statement  
  71.         #{}：表示一個佔位符，如果#{} 中傳入簡單類型的參數，#{}中的名稱隨意  
  72.         parameterType: 輸入參數的類型，通過#{}接收parameterType輸入的參數  
  73.         resultType：輸出結果類型，不管返回是多條還是單條，指定單條記錄映射的pojo類型  
  74.       -->  
  75.       <select id="findUserById" parameterType="int" resultType="user">  
  76.          SELECT * FROM USER WHERE id=#{id};  
  77.       </select>  
  78.         
  79.       <!-- 根據用戶名稱查詢用戶信息，可能返回多條   
  80.       ${}:表示SQL的拼接，通過${}接收參數，將參數的內容不加任何修飾的拼接在SQL中  
  81.       -->  
  82.       <select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  83.            select * from user where username like '%${value}%'   
  84.       </select>  
  85.         
  86.       <!-- <select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  87.            select * from user where username like #{username}   
  88.       </select> -->  
  89.         
  90.       <!-- 自定義查詢條件查詢用戶信息   
  91.       parameterType: 指定包裝類型  
  92.       %${userCustom.username}%: userCustom是userQueryVo中的屬性，通過OGNL獲取屬性的值  
  93.       -->  
  94.       <select id="findUserList" parameterType="userQueryVo" resultType="user">  
  95.          select * from user   
  96.          <!-- where標籤相當於where關鍵字，可以自動除去第一個and -->  
  97.          <where>  
  98.            <!-- 引用sql片段，如果sql片段和引用處不在同一個mapper 必須在前邊加namespace. -->  
  99.            <include refid="query_user_where"></include>  
  100.            <!-- 下邊還有很多其它的條件 -->  
  101.            <!-- <include refid="其它的sql片段"></include> -->  
  102.          </where>  
  103.       </select>  
  104.         
  105.       <!-- 使用resultMap作爲結果映射  
  106.       resultMap: 如果引用resultMap的位置和resultMap的定義在同一個mapper.xml中，  
  107.       直接使用resultMap的id,如果不在同一個mapper.xml中，要在引用resultMap的id前邊加namespace  
  108.        -->  
  109.       <select id="findUserListResultMap" parameterType="userQueryVo" resultMap="userListResultMap">  
  110.         select id id_,username username_,birthday birthday_ from user where username like '%${userCustom.username}%'  
  111.       </select>  
  112.         
  113.       <!-- 輸出簡單類型  
  114.       功能：自定義查詢條件，返回查詢記錄個數，通常用於實現查詢分頁  
  115.        -->  
  116.        <select id="findUserCount" parameterType="userQueryVo" resultType="int">  
  117.         select count(*) from user   
  118.         <!-- where標籤相當於where關鍵字，可以自動除去第一個and -->  
  119.          <where>  
  120.            <!-- 引用sql片段，如果sql片段和引用處不在同一個mapper 必須在前邊加namespace. -->  
  121.            <include refid="query_user_where"></include>  
  122.            <!-- 下邊還有很多其它的條件 -->  
  123.            <!-- <include refid="其它的sql片段"></include> -->  
  124.          </where>  
  125.        </select>  
  126.          
  127.       <!-- 添加用戶   
  128.        parameterType:輸入參數的類型，User對象包括username,birthday,sex,address  
  129.        #{}接收pojo數據,可以使用OGNL解析出pojo的屬性值  
  130.        #{username}表示從parameterType中獲取pojo的屬性值  
  131.        <selectKey>:用於進行主鍵返回，定義了主鍵值的SQL  
  132.        order：設置selectKey標籤中SQL的執行順序，相對於insert語句而言  
  133.        keyProperty： 將主鍵設置到哪個屬性上  
  134.        resultType：select LAST_INSERT_ID()的結果類型  
  135.       -->  
  136.       <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  137.          <selectKey keyProperty="id" order="AFTER" resultType="int">  
  138.             select LAST_INSERT_ID()  
  139.          </selectKey>  
  140.          INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  141.       </insert>  
  142.         
  143.       <!-- mysql的uuid()函數生成主鍵 -->  
  144.      <!--  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  145.          <selectKey keyProperty="id" order="BEFORE" resultType="string">  
  146.             select uuid()  
  147.          </selectKey>  
  148.          INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  149.       </insert> -->  
  150.         
  151.       <!-- oracle  
  152.              在執行insert之前執行select 序列.nextval() from dual取出序列最大值，將值設置到user對象的id屬性中  
  153.        -->  
  154.      <!--  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  155.          <selectKey keyProperty="id" order="BEFORE" resultType="int">  
  156.             select 序列.nextval() from dual  
  157.          </selectKey>  
  158.          INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  159.       </insert> -->  
  160.         
  161.       <!-- 用戶刪除 -->  
  162.       <delete id="deleteUser" parameterType="int">  
  163.        delete from user where id=#{id}  
  164.       </delete>  
  165.       <!-- 用戶更新  
  166.         要求：傳入的user對象包括id屬性值  
  167.        -->  
  168.        <update id="updateUser" parameterType="test.lx.mybatis.po.User">  
  169.        update user set username = #{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}  
  170.        </update>  
  171. </mapper>  

User.java

[java] view plain copy

  1. package test.lx.mybatis.po;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  * 用戶PO類 
  7.  *  
  8.  * @author lx 
  9.  *  
  10.  */  
  11. public class User {  
  12.     private int id;  
  13.     private String username; // 用戶姓名  
  14.     private String sex; // 性別  
  15.     private Date birthday; // 生日  
  16.     private String address; // 地址  
  17.   
  18.     public int getId() {  
  19.         return id;  
  20.     }  
  21.   
  22.     public void setId(int id) {  
  23.         this.id = id;  
  24.     }  
  25.   
  26.     public String getUsername() {  
  27.         return username;  
  28.     }  
  29.   
  30.     public void setUsername(String username) {  
  31.         this.username = username;  
  32.     }  
  33.   
  34.     public String getSex() {  
  35.         return sex;  
  36.     }  
  37.   
  38.     public void setSex(String sex) {  
  39.         this.sex = sex;  
  40.     }  
  41.   
  42.     public Date getBirthday() {  
  43.         return birthday;  
  44.     }  
  45.   
  46.     public void setBirthday(Date birthday) {  
  47.         this.birthday = birthday;  
  48.     }  
  49.   
  50.     public String getAddress() {  
  51.         return address;  
  52.     }  
  53.   
  54.     public void setAddress(String address) {  
  55.         this.address = address;  
  56.     }  
  57.   
  58.     @Override  
  59.     public String toString() {  
  60.         return "User [id=" + id + ", username=" + username + ", sex=" + sex  
  61.                 + ", birthday=" + birthday + ", address=" + address + "]";  
  62.     }  
  63.   
  64. }  

UserCustom

[java] view plain copy

  1. package test.lx.mybatis.po;  
  2. /** 
  3.  * User的擴展類型 
  4.  * @author liuxun 
  5.  * 
  6.  */  
  7. public class UserCustom extends User {  
  8.     //添加一些擴展類型  
  9. }  

UserQueryVo

[java] view plain copy

  1. package test.lx.mybatis.po;  
  2.   
  3. import java.util.List;  
  4.   
  5. /** 
  6.  * 包裝類型，將來在使用時從頁面傳遞到controller、service、mapper 
  7.  * @author liuxun 
  8.  * 
  9.  */  
  10. public class UserQueryVo {  
  11.     //用戶信息  
  12.     private User user;  
  13.       
  14.     //自定義User的擴展對象  
  15.     private UserCustom userCustom;  
  16.       
  17.     //用戶id集合  
  18.     private List<Integer> ids;  
  19.   
  20.     public User getUser() {  
  21.         return user;  
  22.     }  
  23.   
  24.     public void setUser(User user) {  
  25.         this.user = user;  
  26.     }  
  27.   
  28.     public UserCustom getUserCustom() {  
  29.         return userCustom;  
  30.     }  
  31.   
  32.     public void setUserCustom(UserCustom userCustom) {  
  33.         this.userCustom = userCustom;  
  34.     }  
  35.   
  36.     public List<Integer> getIds() {  
  37.         return ids;  
  38.     }  
  39.   
  40.     public void setIds(List<Integer> ids) {  
  41.         this.ids = ids;  
  42.     }  
  43.       
  44.       
  45. }  

User.xml

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE mapper  
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5. <!-- namespace命名空間，爲了對SQL語句進行隔離，方便管理，mapper可開發dao方式，使用namespace有特殊作用   
  6. mapper代理開發時將namespace指定爲mapper接口的全限定名 -->  
  7. <mapper namespace="test">  
  8. <!-- 在mapper.xml文件中配置很多的SQL語句，執行每個SQL語句時，封裝爲MappedStatement對象  
  9. mapper.xml以statement爲單位管理SQL語句  
  10.  -->  
  11.    
  12.  <!-- 根據id查詢用戶信息 -->  
  13.  <!--   
  14.     id: 唯一標識一個statement  
  15.     #{}：表示一個佔位符，如果#{} 中傳入簡單類型的參數，#{}中的名稱隨意  
  16.     parameterType: 輸入參數的類型，通過#{}接收parameterType輸入的參數  
  17.     resultType：輸出結果類型，指定單條記錄映射的pojo類型  
  18.   -->  
  19.   <select id="findUserById" parameterType="int" resultType="test.lx.mybatis.po.User">  
  20.      SELECT * FROM USER WHERE id=#{id};  
  21.   </select>  
  22.     
  23.   <!-- 根據用戶名稱查詢用戶信息，可能返回多條   
  24.   ${}:表示SQL的拼接，通過${}接收參數，將參數的內容不加任何修飾的拼接在SQL中  
  25.   -->  
  26.   <select id="findUserByName" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  27.        select * from user where username like '%${value}%'   
  28.   </select>  
  29.     
  30.   <select id="findUserByName2" parameterType="java.lang.String" resultType="test.lx.mybatis.po.User">  
  31.        select * from user where username like #{username}   
  32.   </select>  
  33.     
  34.   <!-- 添加用戶   
  35.    parameterType:輸入參數的類型，User對象包括username,birthday,sex,address  
  36.    #{}接收pojo數據,可以使用OGNL解析出pojo的屬性值  
  37.    #{username}表示從parameterType中獲取pojo的屬性值  
  38.    <selectKey>:用於進行主鍵返回，定義了主鍵值的SQL  
  39.    order：設置selectKey標籤中SQL的執行順序，相對於insert語句而言  
  40.    keyProperty： 將主鍵設置到哪個屬性上  
  41.    resultType：select LAST_INSERT_ID()的結果類型  
  42.   -->  
  43.   <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  44.      <selectKey keyProperty="id" order="AFTER" resultType="int">  
  45.         select LAST_INSERT_ID()  
  46.      </selectKey>  
  47.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  48.   </insert>  
  49.     
  50.   <!-- mysql的uuid()函數生成主鍵 -->  
  51.  <!--  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  52.      <selectKey keyProperty="id" order="BEFORE" resultType="string">  
  53.         select uuid()  
  54.      </selectKey>  
  55.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  56.   </insert> -->  
  57.     
  58.   <!-- oracle  
  59.          在執行insert之前執行select 序列.nextval() from dual取出序列最大值，將值設置到user對象的id屬性中  
  60.    -->  
  61.  <!--  <insert id="insertUser" parameterType="test.lx.mybatis.po.User">  
  62.      <selectKey keyProperty="id" order="BEFORE" resultType="int">  
  63.         select 序列.nextval() from dual  
  64.      </selectKey>  
  65.      INSERT INTO USER(username,birthday,sex,address) VALUES(#{username},#{birthday},#{sex},#{address})  
  66.   </insert> -->  
  67.     
  68.   <!-- 用戶刪除 -->  
  69.   <delete id="deleteUser" parameterType="int">  
  70.    delete from user where id=#{id}  
  71.   </delete>  
  72.   <!-- 用戶更新  
  73.     要求：傳入的user對象包括id屬性值  
  74.    -->  
  75.    <update id="updateUser" parameterType="test.lx.mybatis.po.User">  
  76.    update user set username = #{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}  
  77.    </update>  
  78. </mapper>  

db.properties

[plain] view plain copy

  1. jdbc.driver=com.mysql.jdbc.Driver  
  2. jdbc.url=jdbc:mysql://localhost:3306/mybatis  
  3. jdbc.username=root  
  4. jdbc.password=root  

log4j.properties

[plain] view plain copy

  1. # Global logging configuration\uff0c\u5efa\u8bae\u5f00\u53d1\u73af\u5883\u4e2d\u8981\u7528debug  
  2. log4j.rootLogger=DEBUG, stdout  
  3. # Console output...  
  4. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  5. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  6. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n  

SqlMapConfig.xml

[html] view plain copy

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE configuration  
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6.     <!-- 屬性定義  
  7.              加載一個properties文件  
  8.              在properties標籤中配置屬性值  
  9.      -->  
  10.      <properties resource="db.properties">  
  11.          <!-- <property name="" value=""/> -->  
  12.      </properties>  
  13.        
  14.      <settings>  
  15.         <setting name="cacheEnabled" value="true"/>  
  16.      </settings>  
  17.      <!-- 定義別名 -->  
  18.      <typeAliases>  
  19.      <!--   
  20.          單個別名定義  
  21.          alias:別名, type:別名映射類型  
  22.          <typeAlias type="test.lx.mybatis.po.User" alias="user"/>  
  23.       -->  
  24.       <!-- 批量別名定義  
  25.          指定包路徑，自動掃描包內的pojo,定義別名，別名默認爲類名(首字母小寫或大寫)             
  26.        -->  
  27.        <package name="test.lx.mybatis.po"/>  
  28.      </typeAliases>  
  29.        
  30.     <!-- 和Spring整合後environments配置將廢除 -->  
  31.     <environments default="development">  
  32.         <environment id="development">  
  33.             <!-- 使用jdbc事務管理 -->  
  34.             <transactionManager type="JDBC" />  
  35.             <dataSource type="POOLED">  
  36.                 <property name="driver" value="${jdbc.driver}" />  
  37.                 <property name="url" value="${jdbc.url}" />  
  38.                 <property name="username" value="${jdbc.username}" />  
  39.                 <property name="password" value="${jdbc.password}" />  
  40.             </dataSource>  
  41.         </environment>  
  42.     </environments>  
  43.   
  44.     <!-- 加載mapper映射  
  45.     如果和Spring整合後，可以使用整合包中的mapper掃描器，到那時此處的mapper就不用配置了  
  46.     -->  
  47.     <mappers>  
  48.          <!-- 通過resource映入mapper的映射文件 -->  
  49.         <mapper resource="sqlmap/User.xml" />  
  50.         <!-- <mapper resource="test/lx/mybatis/mapper/UserMapper.xml"/> -->  
  51.         <!-- 通過class引用mapper接口  
  52.              class：配置mapper接口的全限定名  
  53.              要求：需要mapper.xml和mapper.java同名並且在同一目錄中  
  54.          -->  
  55.         <!-- <mapper class="test.lx.mybatis.mapper.UserMapper"/> -->  
  56.         <!-- 批量mapper配置  
  57.              通過package進行自動掃描包下邊的mapper接口  
  58.              要求：需要mapper.xml和mapper.java同名並在同一目錄中  
  59.          -->  
  60.         <package name="test.lx.mybatis.mapper"/>  
  61.     </mappers>  
  62. </configuration>  

UserDaoImplTest

[java] view plain copy

  1. package test.lx.mybatis.dao;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5.   
  6. import org.apache.ibatis.io.Resources;  
  7. import org.apache.ibatis.session.SqlSessionFactory;  
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  9. import org.junit.Before;  
  10. import org.junit.Test;  
  11.   
  12. import test.lx.mybatis.po.User;  
  13.   
  14. public class UserDaoImplTest {  
  15.     // 會話工廠  
  16.     private SqlSessionFactory sqlSessionFactory;  
  17.       
  18.     //創建工廠  
  19.     @Before  
  20.     public void init() throws IOException{  
  21.         //配置文件(SqlMapConfig.xml)  
  22.         String resource = "SqlMapConfig.xml";  
  23.           
  24.         //加載配置文件到輸入流  
  25.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  26.           
  27.         //創建會話工廠  
  28.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);        
  29.     }  
  30.       
  31.     @Test  
  32.     public void testFindUserById() throws Exception{  
  33.         UserDao userDao = new UserDaoImpl(sqlSessionFactory);  
  34.           
  35.         User user = userDao.findUserById(1);  
  36.         System.out.println(user);  
  37.     }  
  38.       
  39. }  

UserMapperTest.java

[java] view plain copy

  1. package test.lx.mybatis.mapper;  
  2.   
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7.   
  8. import org.apache.ibatis.io.Resources;  
  9. import org.apache.ibatis.session.SqlSession;  
  10. import org.apache.ibatis.session.SqlSessionFactory;  
  11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
  12. import org.junit.Before;  
  13. import org.junit.Test;  
  14.   
  15. import test.lx.mybatis.po.User;  
  16. import test.lx.mybatis.po.UserCustom;  
  17. import test.lx.mybatis.po.UserQueryVo;  
  18.   
  19. public class UserMapperTest {  
  20.   
  21.     // 會話工廠  
  22.     private SqlSessionFactory sqlSessionFactory;  
  23.   
  24.     // 創建工廠  
  25.     @Before  
  26.     public void init() throws IOException {  
  27.         // 配置文件（SqlMapConfig.xml）  
  28.         String resource = "SqlMapConfig.xml";  
  29.   
  30.         // 加載配置文件到輸入流  
  31.         InputStream inputStream = Resources.getResourceAsStream(resource);  
  32.   
  33.         // 創建會話工廠  
  34.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
  35.     }  
  36.   
  37.     @Test  
  38.     public void testFindUserById() throws Exception {  
  39.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  40.         // 創建代理對象  
  41.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  42.         User user = userMapper.findUserById(1);  
  43.         System.out.println(user);  
  44.         sqlSession.close();  
  45.     }  
  46.   
  47.     @Test  
  48.     public void testFindUserByUsername() throws Exception {  
  49.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  50.         // 創建代理對象  
  51.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  52.         List<User> list = userMapper.findUserByName("小明");  
  53.         sqlSession.close();  
  54.         System.out.println(list);  
  55.     }  
  56.       
  57.     @Test  
  58.     public void testInsertUser() throws Exception{  
  59.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  60.         // 創建代理對象  
  61.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  62.          
  63.         //插入對象  
  64.         User user = new User();  
  65.         user.setUsername("一蓑煙雨任平生");  
  66.         userMapper.insertUser(user);  
  67.         sqlSession.commit();  
  68.         sqlSession.close();  
  69.         System.out.println(user);  
  70.     }  
  71.   
  72.     //通過包裝類型查詢用戶信息  
  73.     @Test  
  74.     public void testFindUserList() throws Exception {  
  75.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  76.         // 創建代理對象  
  77.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  78.         // 構造查詢條件  
  79.         UserQueryVo userQueryVo = new UserQueryVo();  
  80.         UserCustom userCustom = new UserCustom();  
  81.         userCustom.setUsername("   小明");  
  82.         userCustom.setSex("1");  
  83.         userQueryVo.setUserCustom(userCustom);  
  84.           
  85.         //id集合  
  86.         List<Integer> ids = new ArrayList<Integer>();  
  87.         ids.add(16);  
  88.         ids.add(22);  
  89.         userQueryVo.setIds(ids);  
  90.   
  91.         List<User> list = userMapper.findUserList(userQueryVo);  
  92.           
  93.         sqlSession.close();  
  94.           
  95.         System.out.println(list);  
  96.     }  
  97.       
  98.     //使用resultMap進行結果映射  
  99.     @Test  
  100.     public void testFindUserListResultMap() throws Exception {  
  101.         SqlSession sqlSession = sqlSessionFactory.openSession();  
  102.         // 創建代理對象  
  103.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  104.         // 構造查詢條件  
  105.         UserQueryVo userQueryVo = new UserQueryVo();  
  106.         UserCustom userCustom = new UserCustom();  
  107.         userCustom.setUsername("小明");  
  108.         userQueryVo.setUserCustom(userCustom);  
  109.           
  110.         List<User> list = userMapper.findUserListResultMap(userQueryVo);  
  111.         sqlSession.close();  
  112.         System.out.println(list);  
  113.     }  
  114.       
  115.     //返回查詢記錄總數  
  116.     @Test  
  117.     public void testFindUserCount() throws Exception{  
  118.         SqlSession sqlSession  =sqlSessionFactory.openSession();  
  119.         //創建代理對象  
  120.         UserMapper userMapper = sqlSession.getMapper(UserMapper.class);  
  121.         //構建查詢條件  
  122.         UserQueryVo userQueryVo = new UserQueryVo();  
  123.         UserCustom userCustom = new UserCustom();  
  124.         userCustom.setUsername("小明");  
  125.         userQueryVo.setUserCustom(userCustom);  
  126.           
  127.         int count = userMapper.findUserCount(userQueryVo);  
  128.         sqlSession.close();  
  129.         System.out.println(count);  
  130.                   
  131.     }  
  132. }  

原文地址http://blog.csdn.net/u013087513/article/details/72851370

自己搭建的別博客 目前專講  springboot基礎 和 項目

過段時間，會抽時間專一把java環境 開發工具安裝部署等講解 有問題了可以一起探討

地址 http://www.liaoyifan.top/blog

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

快速熟悉H3 BPM的結構

這是我入職的時候公司讓熟悉的第一個框架，這個框架自己也是在上週熟悉了一週，也可以對他進行一個流程操作和集成的配置，同時也能夠對他進行進行配置吧，先來熟悉一下框架 首先，我們通過 http://47.114.182.41

大刺头 2020-07-08 11:50:48

【Android】android sqlite的一個 nullpointerexception問題

今天寫的一段代碼，創建一個sqlite表，ddms總是給我報nullpointerexception錯誤，找了好久，發現新建了一個數據庫對象之後，沒有打開， protected DatabaseHelper mDBHelper; mDB

yangmingysc 2020-07-08 11:45:39

省市三級聯動的DropDownList+Ajax的三種框架(aspnet/Jquery/ExtJs)示例

本文主要列舉了省市三級聯動的DropDownList+Ajax的三種框架(aspnet/Jquery/ExtJs)示例。前段時間需要作一個的Web前端應用，需要用多個框架，一個典型的應用場景是省市三級聯動，基於此應用，特將三種主要的aja

zrz009 2020-07-08 11:14:16

DataRabbit 企業級數據訪問框架（21）－－ DataRabbit 4.0 & DataRabbit 與三層架構融合Demo源碼

 DataRabbit 4.0 相比於前一版本，最大的增強在於以下幾點： 1.提供5大實體緩存。並且直接提供EntityCacheServer，以Remoting的方式發佈同步緩存服務，後面的博文會詳細介紹EntityCacheServe

zrz009 2020-07-08 11:14:04

程序員應該怎樣修身

導讀： 古人云：“修身齊家治國平天下”，可以看到任何事業都應該以修身爲始，作爲程序員自然也不例外。算法、設計、網絡、數據庫、新的語言、新的框架等

zys123456 2020-07-08 10:20:49

Dubbo技術知識總結之五——Dubbo遠程調用

接上篇《Dubbo技術知識總結之四——Dubbo集羣容錯》 五. 遠程調用 上篇《Dubbo技術知識總結之四——Dubbo集羣容錯》的七個步驟中，前四個步驟是 Cluster 層的工作。遠程調用是後續步驟 5, 6, 7 的內

琦小虾 2020-07-08 09:16:27

Dubbo技術知識總結之三——Dubbo 啓動與服務暴露、引用

接上篇《Dubbo技術知識總結之二——註冊中心》 三. Dubbo 啓動與服務暴露、引用 服務暴露：見書 5.2.2 章，文章《Dubbo服務暴露與註冊》 3.1 啓動時 dubbo 標籤解析 服務啓動時，首先解析 dub

琦小虾 2020-07-08 09:16:27

Dubbo技術知識總結之一——Dubbo架構

一. Dubbo 架構 參考地址：《dubbo系列三、架構介紹及各模塊關係》 Dubbo 是阿里服務化治理方案的核心框架，是一種分佈式 RPC 框架，它提供了註冊中心機制，解耦了消費方與服務方動態發現的問題。 1.1 Dubb

琦小虾 2020-07-08 09:16:27

Dubbo技術知識總結之二——註冊中心

接上篇《Dubbo技術知識總結之一——Dubbo架構》 二. 註冊中心 首先需要說明的一點是，服務的暴露與註冊是兩個不同的概念。在Dubbo中，微服務之間的交互默認是通過Netty進行的，而服務之間的通信是基於TCP以全雙工的

琦小虾 2020-07-08 09:16:27

Dubbo技術知識總結之四——Dubbo集羣容錯

接上篇《Dubbo技術知識總結之三——Dubbo 啓動與服務暴露、引用》 四. 集羣容錯 在客戶端已經從註冊中心拉取和訂閱服務列表完畢的前提下，Dubbo 完成一次完整的 RPC 調用，流程如下： 服務列表聚合； 路由； 負

琦小虾 2020-07-08 09:16:27

struts解析

第1章 struts與java web應用簡介1.1 java web應用概述1.2 web組件的三種關聯關係1.3 muv概述1.4 struts概述1.4.1 struts實現mvc的機制在struts框架中，模型由實現業務邏輯的ja

paneyjiang 2020-07-08 09:13:06

vb 框架設計

   這2天一直在研究老系統，老系統是VB寫的，就把老系統的框架寫下把，就當是隨筆了 首先 <!--#include virtual="/include/Common.aspx"--> '引用文件       <%@ Assembly

该用户懒的设置 2020-07-08 07:54:47

《五項核心度量》筆記1-軟件涉衆想要什麼

《五項核心度量》第一部分“軟件涉衆想要什麼”軟件涉衆（stakeholder），即客戶、管理者和開發者等，他們想要的是具有可預測性的工作。當前，已有一

水木九章 2020-07-08 07:15:58

可怕！你沒看錯，這次確實是純手工實現一個MyBatis框架！

目錄 前言 JDBC MyBatis 源碼分析 前置知識 原理分析 自己實現一個 MyBatis 框架 前言 MyBatis是一個非常優秀的持久層應用框架，目前幾乎已經一統天下。既然是持久層框架，

Java小罗 2020-07-08 06:52:07

學6000的一點心的體會

剛開始學6000時估計都會很迷糊的。估計在這學dsp的N多是學51出身的，反正按照俺的想法啊，學dsp不學硬件，不懂硬件，這東東沒辦法弄了，怎麼編程啊???汪洋覺得應該就這些問題大家探討一下，把你當初的迷惑，和後來的解決思路寫下了，這樣啊

gaolinjie 2020-07-08 04:32:36