MyBatis學習總結

時間 2019-12-13

原文原文鏈接

1、Mybatis介紹html

　　MyBatis是一個支持普通SQL查詢，存儲過程和高級映射的優秀持久層框架。MyBatis消除了幾乎全部的JDBC代碼和參數的手工設置以及對結果集的檢索封裝。MyBatis可使用簡單的XML或註解用於配置和原始映射，將接口和Java的POJO（Plain Old Java Objects，普通的Java對象）映射成數據庫中的記錄。java

2、mybatis快速入門mysql

2.1、準備開發環境web

一、建立測試項目，普通java項目或者是JavaWeb項目都可，以下圖所示：算法

二、添加相應的jar包spring

　　【mybatis】sql

　　mybatis-3.1.1.jar數據庫

【MYSQL驅動包】或者【ORACLE驅動包】
　　　　mysql-connector-java-5.1.7-bin.jar（ojdbc14.jar）express

若是有須要還能夠適當添加junit測試包【junit-4.7.jar】

junit-4.7.jar

三、建立數據庫和表，針對MySQL數據庫

　　SQL腳本以下：

1 create database mybatis;

2 use mybatis;

3 CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(20), age INT);

4 INSERT INTO users(NAME, age) VALUES('孤傲蒼狼', 27);

5 INSERT INTO users(NAME, age) VALUES('白虎神皇', 27);

　　將SQL腳本在MySQL數據庫中執行，完成建立數據庫和表的操做，以下：

　　到此，前期的開發環境準備工做所有完成。

2.2、使用MyBatis查詢表中的數據

　　1、添加Mybatis的配置文件conf.xml

　　在src目錄下建立一個conf.xml文件，以下圖所示：

　　conf.xml文件中的內容以下：

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

<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

</typeAliases>

</dataSource>

</environment>

</environments>

</mappers>

</configuration>

　　2、定義表所對應的實體類，以下圖所示：

　　User類的代碼以下：

package com.mybatis.entity;

/**

* users表數對應的實體類

* @author skill

public class Users {

//實體類的屬性和表的字段名稱一一對應

private Integer id;

private String name;

private Integer age;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

@Override

public String toString() {

return "Users[id="+id+",name="+name+"]";

}

　　三、定義操做users表的sql映射文件userMapper.xml

　　在com.mybatis,entity包中建立一個userMapper.xml文件，以下圖所示：

　　userMapper.xml文件的內容以下：

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

2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

3 <!-- 爲這個mapper指定一個惟一的namespace，namespace的值習慣上設置成包名+sql映射文件名，這樣就可以保證namespace的值是惟一的

4 例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除後綴)

5 -->

6 <mapper namespace="me.gacl.mapping.userMapper">

7 <!-- 在select標籤中編寫查詢的SQL語句，設置select標籤的id屬性爲getUser，id屬性值必須是惟一的，不可以重複

8 使用parameterType屬性指明查詢時使用的參數類型，resultType屬性指明查詢返回的結果集類型

9 resultType="me.gacl.domain.User"就表示將查詢結果封裝成一個User類的對象返回

10 User類就是users表所對應的實體類

11 -->

12 <!--

13 根據id查詢獲得一個user對象

14 -->

15 <select id="getUser" parameterType="int"

16 resultType="me.gacl.domain.User">

17 select * from users where id=#{id}

18 </select>

19 </mapper>

　　四、在conf.xml文件中註冊userMapper.xml文件

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

2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

3 <configuration>

4 <environments default="development">

5 <environment id="development">

6 <transactionManager type="JDBC" />

7

8 <dataSource type="POOLED">

9 <property name="driver" value="com.mysql.jdbc.Driver" />

10 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />

11 <property name="username" value="root" />

12 <property name="password" value="XDP" />

13 </dataSource>

14 </environment>

15 </environments>

17 <mappers>

18 <!-- 註冊userMapper.xml文件，

19 userMapper.xml位於me.gacl.mapping這個包下，因此resource寫成me/gacl/mapping/userMapper.xml-->

20 <mapper resource="me/gacl/mapping/userMapper.xml"/>

21 </mappers>

23 </configuration>

　　五、編寫測試代碼：執行定義的select語句

　　建立一個Test1類，編寫以下的測試代碼：

package me.gacl.test;

import java.io.IOException;

import java.io.InputStream;

import java.io.Reader;

import me.gacl.domain.User;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Test1 {

public static void main(String[] args) throws IOException {

//mybatis的配置文件

String resource = "conf.xml";

//使用類加載器加載mybatis的配置文件（它也加載關聯的映射文件）

InputStream is = Test1.class.getClassLoader().getResourceAsStream(resource);

//構建sqlSession的工廠

SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

//使用MyBatis提供的Resources類加載mybatis的配置文件（它也加載關聯的映射文件）

//Reader reader = Resources.getResourceAsReader(resource);

//構建sqlSession的工廠

//SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);

//建立能執行映射文件中sql的sqlSession

SqlSession session = sessionFactory.openSession();

/**

* 映射sql的標識字符串，

* me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

* getUser是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

String statement = "me.gacl.mapping.userMapper.getUser";//映射sql的標識字符串

//執行查詢返回一個惟一user對象的sql

User user = session.selectOne(statement, 1);

System.out.println(user);

}

　　執行結果以下：

MyBatis學習總結(二)——使用MyBatis對錶執行CRUD操做

3、使用MyBatis對錶執行CRUD操做——基於XML的實現

一、定義sql映射xml文件

　　userMapper.xml文件的內容以下：

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

 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3 <!-- 爲這個mapper指定一個惟一的namespace，namespace的值習慣上設置成包名+sql映射文件名，這樣就可以保證namespace的值是惟一的

 4 例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除後綴)

 5  -->

 6 <mapper namespace="me.gacl.mapping.userMapper">

 7     <!-- 在select標籤中編寫查詢的SQL語句， 設置select標籤的id屬性爲getUser，id屬性值必須是惟一的，不可以重複

 8     使用parameterType屬性指明查詢時使用的參數類型，resultType屬性指明查詢返回的結果集類型

 9     resultType="me.gacl.domain.User"就表示將查詢結果封裝成一個User類的對象返回

10     User類就是users表所對應的實體類

11     -->

12     <!--

13         根據id查詢獲得一個user對象

14      -->

15     <select id="getUser" parameterType="int"

16         resultType="me.gacl.domain.User">

17         select * from users where id=#{id}

18     </select>

20     <!-- 建立用戶(Create) -->

21     <insert id="addUser" parameterType="me.gacl.domain.User">

22         insert into users(name,age) values(#{name},#{age})

23     </insert>

25     <!-- 刪除用戶(Remove) -->

26     <delete id="deleteUser" parameterType="int">

27         delete from users where id=#{id}

28     </delete>

30     <!-- 修改用戶(Update) -->

31     <update id="updateUser" parameterType="me.gacl.domain.User">

32         update users set name=#{name},age=#{age} where id=#{id}

33     </update>

35     <!-- 查詢所有用戶-->

36     <select id="getAllUsers" resultType="me.gacl.domain.User">

37         select * from users

38     </select>

40 </mapper>

　　單元測試類代碼以下：

 1 package me.gacl.test;

 3 import java.util.List;

 4 import me.gacl.domain.User;

 5 import me.gacl.util.MyBatisUtil;

 6 import org.apache.ibatis.session.SqlSession;

 7 import org.junit.Test;

 9 public class TestCRUDByXmlMapper {

11     @Test

12     public void testAdd(){

13         //SqlSession sqlSession = MyBatisUtil.getSqlSession(false);

14         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

15         /**

16          * 映射sql的標識字符串，

17          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

18          * addUser是insert標籤的id屬性值，經過insert標籤的id屬性值就能夠找到要執行的SQL

19          */

20         String statement = "me.gacl.mapping.userMapper.addUser";//映射sql的標識字符串

21         User user = new User();

22         user.setName("用戶孤傲蒼狼");

23         user.setAge(20);

24         //執行插入操做

25         int retResult = sqlSession.insert(statement,user);

26         //手動提交事務

27         //sqlSession.commit();

28         //使用SqlSession執行完SQL以後須要關閉SqlSession

29         sqlSession.close();

30         System.out.println(retResult);

31     }

33     @Test

34     public void testUpdate(){

35         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

36         /**

37          * 映射sql的標識字符串，

38          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

39          * updateUser是update標籤的id屬性值，經過update標籤的id屬性值就能夠找到要執行的SQL

40          */

41         String statement = "me.gacl.mapping.userMapper.updateUser";//映射sql的標識字符串

42         User user = new User();

43         user.setId(3);

44         user.setName("孤傲蒼狼");

45         user.setAge(25);

46         //執行修改操做

47         int retResult = sqlSession.update(statement,user);

48         //使用SqlSession執行完SQL以後須要關閉SqlSession

49         sqlSession.close();

50         System.out.println(retResult);

51     }

53     @Test

54     public void testDelete(){

55         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

56         /**

57          * 映射sql的標識字符串，

58          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

59          * deleteUser是delete標籤的id屬性值，經過delete標籤的id屬性值就能夠找到要執行的SQL

60          */

61         String statement = "me.gacl.mapping.userMapper.deleteUser";//映射sql的標識字符串

62         //執行刪除操做

63         int retResult = sqlSession.delete(statement,5);

64         //使用SqlSession執行完SQL以後須要關閉SqlSession

65         sqlSession.close();

66         System.out.println(retResult);

67     }

69     @Test

70     public void testGetAll(){

71         SqlSession sqlSession = MyBatisUtil.getSqlSession();

72         /**

73          * 映射sql的標識字符串，

74          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

75          * getAllUsers是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

76          */

77         String statement = "me.gacl.mapping.userMapper.getAllUsers";//映射sql的標識字符串

78         //執行查詢操做，將查詢結果自動封裝成List<User>返回

79         List<User> lstUsers = sqlSession.selectList(statement);

80         //使用SqlSession執行完SQL以後須要關閉SqlSession

81         sqlSession.close();

82         System.out.println(lstUsers);

83     }

84 }

4、使用MyBatis對錶執行CRUD操做——基於註解的實現

　　一、定義sql映射的接口

　　UserMapperI接口的代碼以下：

 1 package me.gacl.mapping;

 3 import java.util.List;

 4 import me.gacl.domain.User;

 5 import org.apache.ibatis.annotations.Delete;

 6 import org.apache.ibatis.annotations.Insert;

 7 import org.apache.ibatis.annotations.Select;

 8 import org.apache.ibatis.annotations.Update;

10 /**

11  * @author gacl

12  * 定義sql映射的接口，使用註解指明方法要執行的SQL

13  */

14 public interface UserMapperI {

16     //使用@Insert註解指明add方法要執行的SQL

17     @Insert("insert into users(name, age) values(#{name}, #{age})")

18     public int add(User user);

20     //使用@Delete註解指明deleteById方法要執行的SQL

21     @Delete("delete from users where id=#{id}")

22     public int deleteById(int id);

24     //使用@Update註解指明update方法要執行的SQL

25     @Update("update users set name=#{name},age=#{age} where id=#{id}")

26     public int update(User user);

28     //使用@Select註解指明getById方法要執行的SQL

29     @Select("select * from users where id=#{id}")

30     public User getById(int id);

32     //使用@Select註解指明getAll方法要執行的SQL

33     @Select("select * from users")

34     public List<User> getAll();

35 }

　　須要說明的是，咱們不須要針對UserMapperI接口去編寫具體的實現類代碼，這個具體的實現類由MyBatis幫咱們動態構建出來，咱們只須要直接拿來使用便可。

　　二、在conf.xml文件中註冊這個映射接口

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

 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

 3 <configuration>

 4     <environments default="development">

 5         <environment id="development">

 6             <transactionManager type="JDBC" />

 7             <!-- 配置數據庫鏈接信息 -->

 8             <dataSource type="POOLED">

 9                 <property name="driver" value="com.mysql.jdbc.Driver" />

10                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />

11                 <property name="username" value="root" />

12                 <property name="password" value="XDP" />

13             </dataSource>

14         </environment>

15     </environments>

17     <mappers>

18         <!-- 註冊userMapper.xml文件，

19         userMapper.xml位於me.gacl.mapping這個包下，因此resource寫成me/gacl/mapping/userMapper.xml-->

20         <mapper resource="me/gacl/mapping/userMapper.xml"/>

21         <!-- 註冊UserMapper映射接口-->

22         <mapper class="me.gacl.mapping.UserMapperI"/>

23     </mappers>

25 </configuration>

　　單元測試類的代碼以下：

 1 package me.gacl.test;

 3 import java.util.List;

 4 import me.gacl.domain.User;

 5 import me.gacl.mapping.UserMapperI;

 6 import me.gacl.util.MyBatisUtil;

 7 import org.apache.ibatis.session.SqlSession;

 8 import org.junit.Test;

10 public class TestCRUDByAnnotationMapper {

12     @Test

13     public void testAdd(){

14         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

15         //獲得UserMapperI接口的實現類對象，UserMapperI接口的實現類對象由sqlSession.getMapper(UserMapperI.class)動態構建出來

16         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);

17         User user = new User();

18         user.setName("用戶xdp");

19         user.setAge(20);

20         int add = mapper.add(user);

21         //使用SqlSession執行完SQL以後須要關閉SqlSession

22         sqlSession.close();

23         System.out.println(add);

24     }

26     @Test

27     public void testUpdate(){

28         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

29         //獲得UserMapperI接口的實現類對象，UserMapperI接口的實現類對象由sqlSession.getMapper(UserMapperI.class)動態構建出來

30         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);

31         User user = new User();

32         user.setId(3);

33         user.setName("孤傲蒼狼_xdp");

34         user.setAge(26);

35         //執行修改操做

36         int retResult = mapper.update(user);

37         //使用SqlSession執行完SQL以後須要關閉SqlSession

38         sqlSession.close();

39         System.out.println(retResult);

40     }

42     @Test

43     public void testDelete(){

44         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);

45         //獲得UserMapperI接口的實現類對象，UserMapperI接口的實現類對象由sqlSession.getMapper(UserMapperI.class)動態構建出來

46         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);

47         //執行刪除操做

48         int retResult = mapper.deleteById(7);

49         //使用SqlSession執行完SQL以後須要關閉SqlSession

50         sqlSession.close();

51         System.out.println(retResult);

52     }

54     @Test

55     public void testGetUser(){

56         SqlSession sqlSession = MyBatisUtil.getSqlSession();

57         //獲得UserMapperI接口的實現類對象，UserMapperI接口的實現類對象由sqlSession.getMapper(UserMapperI.class)動態構建出來

58         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);

59         //執行查詢操做，將查詢結果自動封裝成User返回

60         User user = mapper.getById(8);

61         //使用SqlSession執行完SQL以後須要關閉SqlSession

62         sqlSession.close();

63         System.out.println(user);

64     }

66     @Test

67     public void testGetAll(){

68         SqlSession sqlSession = MyBatisUtil.getSqlSession();

69         //獲得UserMapperI接口的實現類對象，UserMapperI接口的實現類對象由sqlSession.getMapper(UserMapperI.class)動態構建出來

70         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);

71         //執行查詢操做，將查詢結果自動封裝成List<User>返回

72         List<User> lstUsers = mapper.getAll();

73         //使用SqlSession執行完SQL以後須要關閉SqlSession

74         sqlSession.close();

75         System.out.println(lstUsers);

76     }

77 }

　　用到的MyBatisUtil工具類代碼以下：

 1 package me.gacl.util;

 3 import java.io.InputStream;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.apache.ibatis.session.SqlSessionFactory;

 7 import org.apache.ibatis.session.SqlSessionFactoryBuilder;

 9 public class MyBatisUtil {

11     /**

12      * 獲取SqlSessionFactory

13      * @return SqlSessionFactory

14      */

15     public static SqlSessionFactory getSqlSessionFactory() {

16         String resource = "conf.xml";

17         InputStream is = MyBatisUtil.class.getClassLoader().getResourceAsStream(resource);

18         SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);

19         return factory;

20     }

22     /**

23      * 獲取SqlSession

24      * @return SqlSession

25      */

26     public static SqlSession getSqlSession() {

27         return getSqlSessionFactory().openSession();

28     }

30     /**

31      * 獲取SqlSession

32      * @param isAutoCommit

33      *         true 表示建立的SqlSession對象在執行完SQL以後會自動提交事務

34      *         false 表示建立的SqlSession對象在執行完SQL以後不會自動提交事務，這時就須要咱們手動調用sqlSession.commit()提交事務

35      * @return SqlSession

36      */

37     public static SqlSession getSqlSession(boolean isAutoCommit) {

38         return getSqlSessionFactory().openSession(isAutoCommit);

39     }

40 }

　　以上的相關代碼是所有測試經過的，關於使用MyBatis對錶執行CRUD操做的內容就這麼多。

MyBatis學習總結(三)——優化MyBatis配置文件中的配置

1、鏈接數據庫的配置單獨放在一個properties文件中

　　以前，咱們是直接將數據庫的鏈接配置信息寫在了MyBatis的conf.xml文件中，以下：

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

 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

 3 <configuration>

 4     <environments default="development">

 5         <environment id="development">

 6             <transactionManager type="JDBC" />

 7             <!-- 配置數據庫鏈接信息 -->

 8             <dataSource type="POOLED">

 9                 <property name="driver" value="com.mysql.jdbc.Driver" />

10                 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />

11                 <property name="username" value="root" />

12                 <property name="password" value="XDP" />

13             </dataSource>

14         </environment>

15     </environments>

17 </configuration>

　　其實咱們徹底能夠將數據庫的鏈接配置信息寫在一個properties文件中，而後在conf.xml文件中引用properties文件，具體作法以下：

　　一、在src目錄下新建一個db.properties文件，以下圖所示：

　　在db.properties文件編寫鏈接數據庫須要使用到的數據庫驅動，鏈接URL地址，用戶名，密碼，以下：

1 driver=com.mysql.jdbc.Driver

2 url=jdbc:mysql://localhost:3306/mybatis

3 name=root

4 password=XDP

　　二、在MyBatis的conf.xml文件中引用db.properties文件，以下：

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

 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

 3 <configuration>

 5     <!-- 引用db.properties配置文件 -->

 6     <properties resource="db.properties"/>

 7     <!--

 8         development : 開發模式

 9         work : 工做模式

10      -->

11     <environments default="development">

12         <environment id="development">

13             <transactionManager type="JDBC" />

14             <!-- 配置數據庫鏈接信息 -->

15             <dataSource type="POOLED">

16                 <!-- value屬性值引用db.properties配置文件中配置的值 -->

17                 <property name="driver" value="${driver}" />

18                 <property name="url" value="${url}" />

19                 <property name="username" value="${name}" />

20                 <property name="password" value="${password}" />

21             </dataSource>

22         </environment>

23     </environments>

25 </configuration>

2、爲實體類定義別名，簡化sql映射xml文件中的引用

　　以前，咱們在sql映射xml文件中的引用實體類時，須要寫上實體類的全類名(包名+類名)，以下：

<!-- 建立用戶(Create) -->

<insert id="addUser" parameterType="me.gacl.domain.User">

    insert into users(name,age) values(#{name},#{age})

</insert>

　　parameterType="me.gacl.domain.User"這裏寫的實體類User的全類名me.gacl.domain.User，每次都寫這麼一長串內容挺麻煩的，而咱們但願可以簡寫成下面的形式

<insert id="addUser2" parameterType="_User">

    insert into users(name,age) values(#{name},#{age})

</insert>

　　parameterType="_User"這樣寫就簡單多了，爲了達到這種效果，咱們須要在conf.xml文件中爲實體類="me.gacl.domain.User"定義一個別名爲"_User"，具體作法以下：
　　在conf.xml文件中<configuration></configuration>標籤中添加以下配置：

<typeAliases>

    <typeAlias type="me.gacl.domain.User" alias="_User"/>

</typeAliases>

　　這樣就能夠爲me.gacl.domain.User類定義了一個別名爲_User，之後_User就表明了me.gacl.domain.User類，這樣sql映射xml文件中的凡是須要引用me.gacl.domain.User類的地方均可以使用_User來代替，這就達到了一個簡化實體類引用的目的。

　　除了可使用<typeAlias type="me.gacl.domain.User" alias="_User"/>這種方式單獨爲某一個實體類設置別名以外，咱們還可使用以下的方式批量爲某個包下的全部實體類設置別名，以下：

<!-- 配置實體類的別名，配置實體類別名的目的是爲了在引用實體類時可使用實體類的別名來代替實體類，達到簡寫的目的 -->

    <typeAliases>

        <!-- 爲實體類me.gacl.domain.User配置一個別名_User -->

        <!-- <typeAlias type="me.gacl.domain.User" alias="_User"/> -->

        <!-- 爲me.gacl.domain包下的全部實體類配置別名，MyBatis默認的設置別名的方式就是去除類所在的包後的簡單的類名

        好比me.gacl.domain.User這個實體類的別名就會被設置成User

-->

        <package name="me.gacl.domain"/>

    </typeAliases>

　　<package name="me.gacl.domain"/>就表示爲這個包下面的全部實體類設置別名。MyBatis默認的設置別名的方式就是去除類所在的包後的簡單的類名，好比me.gacl.domain.User這個實體類的別名就會被設置成User。

MyBatis學習總結(四)——解決字段名與實體類屬性名不相同的衝突

　　在平時的開發中，咱們表中的字段名和表對應實體類的屬性名稱不必定都是徹底相同的，下面來演示一下這種狀況下的如何解決字段名與實體類屬性名不相同的衝突。

1、準備演示須要使用的表和數據

CREATE TABLE orders(

    order_id INT PRIMARY KEY AUTO_INCREMENT,

    order_no VARCHAR(20),

    order_price FLOAT

);

INSERT INTO orders(order_no, order_price) VALUES('aaaa', 23);

INSERT INTO orders(order_no, order_price) VALUES('bbbb', 33);

INSERT INTO orders(order_no, order_price) VALUES('cccc', 22);

2、定義實體類

 1 package me.gacl.domain;

 3 /**

 4  * @author gacl

 5  * 定義orders表對應的實體類

 6  */

 7 public class Order {

 8     /**

 9      *

10     CREATE TABLE orders(

11         order_id INT PRIMARY KEY AUTO_INCREMENT,

12         order_no VARCHAR(20),

13         order_price FLOAT

14     );

15      */

17     //Order實體類中屬性名和orders表中的字段名是不同的

18     private int id;                //id===>order_id

19     private String orderNo;        //orderNo===>order_no

20     private float price;        //price===>order_price

22     public int getId() {

23         return id;

24     }

26     public void setId(int id) {

27         this.id = id;

28     }

30     public String getOrderNo() {

31         return orderNo;

32     }

34     public void setOrderNo(String orderNo) {

35         this.orderNo = orderNo;

36     }

38     public float getPrice() {

39         return price;

40     }

42     public void setPrice(float price) {

43         this.price = price;

44     }

46     @Override

47     public String toString() {

48         return "Order [id=" + id + ", orderNo=" + orderNo + ", price=" + price+ "]";

49     }

50 }

3、編寫測試代碼

3.一、編寫SQL的xml映射文件

　　一、建立一個orderMapper.xml文件，orderMapper.xml的內容以下：

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

 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3 <!-- 爲這個mapper指定一個惟一的namespace，namespace的值習慣上設置成包名+sql映射文件名，這樣就可以保證namespace的值是惟一的

 4 例如namespace="me.gacl.mapping.orderMapper"就是me.gacl.mapping(包名)+orderMapper(orderMapper.xml文件去除後綴)

 5  -->

 6 <mapper namespace="me.gacl.mapping.orderMapper">

 8     <!--

 9         根據id查詢獲得一個order對象，使用這個查詢是查詢不到咱們想要的結果的，

10         這主要是由於實體類的屬性名和數據庫的字段名對應不上的緣由，所以沒法查詢出對應的記錄

11      -->

12     <select id="getOrderById" parameterType="int"

13         resultType="me.gacl.domain.Order">

14         select * from orders where order_id=#{id}

15     </select>

17     <!--

18         根據id查詢獲得一個order對象，使用這個查詢是能夠正常查詢到咱們想要的結果的，

19         這是由於咱們將查詢的字段名都起一個和實體類屬性名相同的別名，這樣實體類的屬性名和查詢結果中的字段名就能夠一一對應上

20      -->

21     <select id="selectOrder" parameterType="int"

22         resultType="me.gacl.domain.Order">

23         select order_id id, order_no orderNo,order_price price from orders where order_id=#{id}

24     </select>

26     <!--

27     根據id查詢獲得一個order對象，使用這個查詢是能夠正常查詢到咱們想要的結果的，

28     這是由於咱們經過<resultMap>映射實體類屬性名和表的字段名一一對應關係 -->

29     <select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap">

30         select * from orders where order_id=#{id}

31     </select>

32     <!--經過<resultMap>映射實體類屬性名和表的字段名對應關係 -->

33     <resultMap type="me.gacl.domain.Order" id="orderResultMap">

34         <!-- 用id屬性來映射主鍵字段 -->

35         <id property="id" column="order_id"/>

36         <!-- 用result屬性來映射非主鍵字段 -->

37         <result property="orderNo" column="order_no"/>

38         <result property="price" column="order_price"/>

39     </resultMap>

41 </mapper>

　　二、在conf.xml文件中註冊orderMapper.xml映射文件

<mappers>

        <!-- 註冊orderMapper.xml文件，

        orderMapper.xml位於me.gacl.mapping這個包下，因此resource寫成me/gacl/mapping/orderMapper.xml-->

        <mapper resource="me/gacl/mapping/orderMapper.xml"/>

</mappers>

3.二、編寫單元測試代碼

 1 package me.gacl.test;

 3 import me.gacl.domain.Order;

 4 import me.gacl.util.MyBatisUtil;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.junit.Test;

 8 public class Test2 {

10     @Test

11     public void testGetOrderById(){

12         SqlSession sqlSession = MyBatisUtil.getSqlSession();

13         /**

14          * 映射sql的標識字符串，

15          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper標籤的namespace屬性的值，

16          * getOrderById是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

17          */

18         String statement = "me.gacl.mapping.orderMapper.getOrderById";//映射sql的標識字符串

19         //執行查詢操做，將查詢結果自動封裝成Order對象返回

20         Order order = sqlSession.selectOne(statement,1);//查詢orders表中id爲1的記錄

21         //使用SqlSession執行完SQL以後須要關閉SqlSession

22         sqlSession.close();

23         System.out.println(order);//打印結果：null，也就是沒有查詢出相應的記錄

24     }

26     @Test

27     public void testGetOrderById2(){

28         SqlSession sqlSession = MyBatisUtil.getSqlSession();

29         /**

30          * 映射sql的標識字符串，

31          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper標籤的namespace屬性的值，

32          * selectOrder是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

33          */

34         String statement = "me.gacl.mapping.orderMapper.selectOrder";//映射sql的標識字符串

35         //執行查詢操做，將查詢結果自動封裝成Order對象返回

36         Order order = sqlSession.selectOne(statement,1);//查詢orders表中id爲1的記錄

37         //使用SqlSession執行完SQL以後須要關閉SqlSession

38         sqlSession.close();

39         System.out.println(order);//打印結果：Order [id=1, orderNo=aaaa, price=23.0]

40     }

42     @Test

43     public void testGetOrderById3(){

44         SqlSession sqlSession = MyBatisUtil.getSqlSession();

45         /**

46          * 映射sql的標識字符串，

47          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper標籤的namespace屬性的值，

48          * selectOrderResultMap是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

49          */

50         String statement = "me.gacl.mapping.orderMapper.selectOrderResultMap";//映射sql的標識字符串

51         //執行查詢操做，將查詢結果自動封裝成Order對象返回

52         Order order = sqlSession.selectOne(statement,1);//查詢orders表中id爲1的記錄

53         //使用SqlSession執行完SQL以後須要關閉SqlSession

54         sqlSession.close();

55         System.out.println(order);//打印結果：Order [id=1, orderNo=aaaa, price=23.0]

56     }

57 }

　　執行單元測試的結果：

　　一、testGetOrderById方法執行查詢後返回一個null。

　　二、testGetOrderById2方法和testGetOrderById3方法執行查詢後能夠正常獲得想要的結果。

4、總結

　　上面的測試代碼演示當實體類中的屬性名和表中的字段名不一致時，使用MyBatis進行查詢操做時沒法查詢出相應的結果的問題以及針對問題採用的兩種辦法：

　　解決辦法一: 經過在查詢的sql語句中定義字段名的別名，讓字段名的別名和實體類的屬性名一致，這樣就能夠表的字段名和實體類的屬性名一一對應上了，這種方式是經過在sql語句中定義別名來解決字段名和屬性名的映射關係的。

　　解決辦法二: 經過<resultMap>來映射字段名和實體類屬性名的一一對應關係。這種方式是使用MyBatis提供的解決方式來解決字段名和屬性名的映射關係的。

MyBatis學習總結(五)——實現關聯表查詢

1、一對一關聯

1.一、提出需求

　　根據班級id查詢班級信息(帶老師的信息)

1.二、建立表和數據

　　建立一張教師表和班級表，這裏咱們假設一個老師只負責教一個班，那麼老師和班級之間的關係就是一種一對一的關係。

 1 CREATE TABLE teacher(

 2     t_id INT PRIMARY KEY AUTO_INCREMENT,

 3     t_name VARCHAR(20)

 4 );

 5 CREATE TABLE class(

 6     c_id INT PRIMARY KEY AUTO_INCREMENT,

 7     c_name VARCHAR(20),

 8     teacher_id INT

 9 );

10 ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES teacher(t_id);

12 INSERT INTO teacher(t_name) VALUES('teacher1');

13 INSERT INTO teacher(t_name) VALUES('teacher2');

15 INSERT INTO class(c_name, teacher_id) VALUES('class_a', 1);

16 INSERT INTO class(c_name, teacher_id) VALUES('class_b', 2);

　　表之間的關係以下：

1.三、定義實體類

　　一、Teacher類，Teacher類是teacher表對應的實體類。

 1 package me.gacl.domain;

 3 /**

 4  * @author gacl

 5  * 定義teacher表對應的實體類

 6  */

 7 public class Teacher {

 9     //定義實體類的屬性，與teacher表中的字段對應

10     private int id;            //id===>t_id

11     private String name;    //name===>t_name

13     public int getId() {

14         return id;

15     }

17     public void setId(int id) {

18         this.id = id;

19     }

21     public String getName() {

22         return name;

23     }

25     public void setName(String name) {

26         this.name = name;

27     }

29     @Override

30     public String toString() {

31         return "Teacher [id=" + id + ", name=" + name + "]";

32     }

33 }

　　二、Classes類，Classes類是class表對應的實體類

 1 package me.gacl.domain;

 3 /**

 4  * @author gacl

 5  * 定義class表對應的實體類

 6  */

 7 public class Classes {

 9     //定義實體類的屬性，與class表中的字段對應

10     private int id;            //id===>c_id

11     private String name;    //name===>c_name

13     /**

14      * class表中有一個teacher_id字段，因此在Classes類中定義一個teacher屬性，

15      * 用於維護teacher和class之間的一對一關係，經過這個teacher屬性就能夠知道這個班級是由哪一個老師負責的

16      */

17     private Teacher teacher;

19     public int getId() {

20         return id;

21     }

23     public void setId(int id) {

24         this.id = id;

25     }

27     public String getName() {

28         return name;

29     }

31     public void setName(String name) {

32         this.name = name;

33     }

35     public Teacher getTeacher() {

36         return teacher;

37     }

39     public void setTeacher(Teacher teacher) {

40         this.teacher = teacher;

41     }

43     @Override

44     public String toString() {

45         return "Classes [id=" + id + ", name=" + name + ", teacher=" + teacher+ "]";

46     }

47 }

1.四、定義sql映射文件classMapper.xml

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

 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3 <!-- 爲這個mapper指定一個惟一的namespace，namespace的值習慣上設置成包名+sql映射文件名，這樣就可以保證namespace的值是惟一的

 4 例如namespace="me.gacl.mapping.classMapper"就是me.gacl.mapping(包名)+classMapper(classMapper.xml文件去除後綴)

 5  -->

 6 <mapper namespace="me.gacl.mapping.classMapper">

 8     <!--

 9         根據班級id查詢班級信息(帶老師的信息)

10         ##1. 聯表查詢

11         SELECT * FROM class c,teacher t WHERE c.teacher_id=t.t_id AND c.c_id=1;

13         ##2. 執行兩次查詢

14         SELECT * FROM class WHERE c_id=1;  //teacher_id=1

15         SELECT * FROM teacher WHERE t_id=1;//使用上面獲得的teacher_id

16      -->

18     <!--

19     方式一：嵌套結果：使用嵌套結果映射來處理重複的聯合結果的子集

20              封裝聯表查詢的數據(去除重複的數據)

21         select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1

22     -->

23     <select id="getClass" parameterType="int" resultMap="ClassResultMap">

24         select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}

25     </select>

26     <!-- 使用resultMap映射實體類和字段之間的一一對應關係 -->

27     <resultMap type="me.gacl.domain.Classes" id="ClassResultMap">

28         <id property="id" column="c_id"/>

29         <result property="name" column="c_name"/>

30         <association property="teacher" javaType="me.gacl.domain.Teacher">

31             <id property="id" column="t_id"/>

32             <result property="name" column="t_name"/>

33         </association>

34     </resultMap>

36     <!--

37     方式二：嵌套查詢：經過執行另一個SQL映射語句來返回預期的複雜類型

38         SELECT * FROM class WHERE c_id=1;

39         SELECT * FROM teacher WHERE t_id=1   //1 是上一個查詢獲得的teacher_id的值

40     -->

41      <select id="getClass2" parameterType="int" resultMap="ClassResultMap2">

42         select * from class where c_id=#{id}

43      </select>

44      <!-- 使用resultMap映射實體類和字段之間的一一對應關係 -->

45      <resultMap type="me.gacl.domain.Classes" id="ClassResultMap2">

46         <id property="id" column="c_id"/>

47         <result property="name" column="c_name"/>

48         <association property="teacher" column="teacher_id" select="getTeacher"/>

49      </resultMap>

51      <select id="getTeacher" parameterType="int" resultType="me.gacl.domain.Teacher">

52         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}

53      </select>

55 </mapper>

　　在conf.xml文件中註冊classMapper.xml

<mappers>

        <!-- 註冊classMapper.xml文件，

        classMapper.xml位於me.gacl.mapping這個包下，因此resource寫成me/gacl/mapping/classMapper.xml-->

        <mapper resource="me/gacl/mapping/classMapper.xml"/>

</mappers>

1.五、編寫單元測試代碼

 1 package me.gacl.test;

 3 import me.gacl.domain.Classes;

 4 import me.gacl.util.MyBatisUtil;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.junit.Test;

 8 public class Test3 {

10     @Test

11     public void testGetClass(){

12         SqlSession sqlSession = MyBatisUtil.getSqlSession();

13         /**

14          * 映射sql的標識字符串，

15          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper標籤的namespace屬性的值，

16          * getClass是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

17          */

18         String statement = "me.gacl.mapping.classMapper.getClass";//映射sql的標識字符串

19         //執行查詢操做，將查詢結果自動封裝成Classes對象返回

20         Classes clazz = sqlSession.selectOne(statement,1);//查詢class表中id爲1的記錄

21         //使用SqlSession執行完SQL以後須要關閉SqlSession

22         sqlSession.close();

23         System.out.println(clazz);//打印結果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1]]

24     }

26     @Test

27     public void testGetClass2(){

28         SqlSession sqlSession = MyBatisUtil.getSqlSession();

29         /**

30          * 映射sql的標識字符串，

31          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper標籤的namespace屬性的值，

32          * getClass2是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

33          */

34         String statement = "me.gacl.mapping.classMapper.getClass2";//映射sql的標識字符串

35         //執行查詢操做，將查詢結果自動封裝成Classes對象返回

36         Classes clazz = sqlSession.selectOne(statement,1);//查詢class表中id爲1的記錄

37         //使用SqlSession執行完SQL以後須要關閉SqlSession

38         sqlSession.close();

39         System.out.println(clazz);//打印結果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1]]

40     }

41 }

1.六、MyBatis一對一關聯查詢總結

　　MyBatis中使用association標籤來解決一對一的關聯查詢，association標籤可用的屬性以下：

property:對象屬性的名稱
javaType:對象屬性的類型
column:所對應的外鍵字段名稱
select:使用另外一個查詢封裝的結果

2、一對多關聯

2.一、提出需求

　　根據classId查詢對應的班級信息,包括學生,老師

2.二、建立表和數據

　　在上面的一對一關聯查詢演示中，咱們已經建立了班級表和教師表，所以這裏再建立一張學生表

CREATE TABLE student(

    s_id INT PRIMARY KEY AUTO_INCREMENT,

    s_name VARCHAR(20),

    class_id INT

);

INSERT INTO student(s_name, class_id) VALUES('student_A', 1);

INSERT INTO student(s_name, class_id) VALUES('student_B', 1);

INSERT INTO student(s_name, class_id) VALUES('student_C', 1);

INSERT INTO student(s_name, class_id) VALUES('student_D', 2);

INSERT INTO student(s_name, class_id) VALUES('student_E', 2);

INSERT INTO student(s_name, class_id) VALUES('student_F', 2);

2.三、定義實體類

　　一、Student類

 1 package me.gacl.domain;

 3 /**

 4  * @author gacl

 5  * 定義student表所對應的實體類

 6  */

 7 public class Student {

 9     //定義屬性，和student表中的字段對應

10     private int id;            //id===>s_id

11     private String name;    //name===>s_name

13     public int getId() {

14         return id;

15     }

17     public void setId(int id) {

18         this.id = id;

19     }

21     public String getName() {

22         return name;

23     }

25     public void setName(String name) {

26         this.name = name;

27     }

29     @Override

30     public String toString() {

31         return "Student [id=" + id + ", name=" + name + "]";

32     }

33 }

　　二、修改Classes類，添加一個List<Student> students屬性，使用一個List<Student>集合屬性表示班級擁有的學生，以下：

 1 package me.gacl.domain;

 3 import java.util.List;

 5 /**

 6  * @author gacl

 7  * 定義class表對應的實體類

 8  */

 9 public class Classes {

11     //定義實體類的屬性，與class表中的字段對應

12     private int id;            //id===>c_id

13     private String name;    //name===>c_name

15     /**

16      * class表中有一個teacher_id字段，因此在Classes類中定義一個teacher屬性，

17      * 用於維護teacher和class之間的一對一關係，經過這個teacher屬性就能夠知道這個班級是由哪一個老師負責的

18      */

19     private Teacher teacher;

20     //使用一個List<Student>集合屬性表示班級擁有的學生

21     private List<Student> students;

23     public int getId() {

24         return id;

25     }

27     public void setId(int id) {

28         this.id = id;

29     }

31     public String getName() {

32         return name;

33     }

35     public void setName(String name) {

36         this.name = name;

37     }

39     public Teacher getTeacher() {

40         return teacher;

41     }

43     public void setTeacher(Teacher teacher) {

44         this.teacher = teacher;

45     }

47     public List<Student> getStudents() {

48         return students;

49     }

51     public void setStudents(List<Student> students) {

52         this.students = students;

53     }

55     @Override

56     public String toString() {

57         return "Classes [id=" + id + ", name=" + name + ", teacher=" + teacher

58                 + ", students=" + students + "]";

59     }

60 }

2.四、修改sql映射文件classMapper.xml

　　添加以下的SQL映射信息

 1 <!--

 2         根據classId查詢對應的班級信息,包括學生,老師

 3      -->

 4     <!--

 5     方式一: 嵌套結果: 使用嵌套結果映射來處理重複的聯合結果的子集

 6     SELECT * FROM class c, teacher t,student s WHERE c.teacher_id=t.t_id AND c.C_id=s.class_id AND  c.c_id=1

 7      -->

 8     <select id="getClass3" parameterType="int" resultMap="ClassResultMap3">

 9         select * from class c, teacher t,student s where c.teacher_id=t.t_id and c.C_id=s.class_id and  c.c_id=#{id}

10     </select>

11     <resultMap type="me.gacl.domain.Classes" id="ClassResultMap3">

12         <id property="id" column="c_id"/>

13         <result property="name" column="c_name"/>

14         <association property="teacher" column="teacher_id" javaType="me.gacl.domain.Teacher">

15             <id property="id" column="t_id"/>

16             <result property="name" column="t_name"/>

17         </association>

18         <!-- ofType指定students集合中的對象類型 -->

19         <collection property="students" ofType="me.gacl.domain.Student">

20             <id property="id" column="s_id"/>

21             <result property="name" column="s_name"/>

22         </collection>

23     </resultMap>

25     <!--

26         方式二：嵌套查詢：經過執行另一個SQL映射語句來返回預期的複雜類型

27             SELECT * FROM class WHERE c_id=1;

28             SELECT * FROM teacher WHERE t_id=1   //1 是上一個查詢獲得的teacher_id的值

29             SELECT * FROM student WHERE class_id=1  //1是第一個查詢獲得的c_id字段的值

30      -->

31      <select id="getClass4" parameterType="int" resultMap="ClassResultMap4">

32         select * from class where c_id=#{id}

33      </select>

34      <resultMap type="me.gacl.domain.Classes" id="ClassResultMap4">

35         <id property="id" column="c_id"/>

36         <result property="name" column="c_name"/>

37         <association property="teacher" column="teacher_id" javaType="me.gacl.domain.Teacher" select="getTeacher2"></association>

38         <collection property="students" ofType="me.gacl.domain.Student" column="c_id" select="getStudent"></collection>

39      </resultMap>

41      <select id="getTeacher2" parameterType="int" resultType="me.gacl.domain.Teacher">

42         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}

43      </select>

45      <select id="getStudent" parameterType="int" resultType="me.gacl.domain.Student">

46         SELECT s_id id, s_name name FROM student WHERE class_id=#{id}

47      </select>

2.五、編寫單元測試代碼

 1 package me.gacl.test;

 3 import me.gacl.domain.Classes;

 4 import me.gacl.util.MyBatisUtil;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.junit.Test;

 8 public class Test4 {

10     @Test

11     public void testGetClass3(){

12         SqlSession sqlSession = MyBatisUtil.getSqlSession();

13         /**

14          * 映射sql的標識字符串，

15          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper標籤的namespace屬性的值，

16          * getClass3是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

17          */

18         String statement = "me.gacl.mapping.classMapper.getClass3";//映射sql的標識字符串

19         //執行查詢操做，將查詢結果自動封裝成Classes對象返回

20         Classes clazz = sqlSession.selectOne(statement,1);//查詢class表中id爲1的記錄

21         //使用SqlSession執行完SQL以後須要關閉SqlSession

22         sqlSession.close();

23         //打印結果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1], students=[Student [id=1, name=student_A], Student [id=2, name=student_B], Student [id=3, name=student_C]]]

24         System.out.println(clazz);

25     }

27     @Test

28     public void testGetClass4(){

29         SqlSession sqlSession = MyBatisUtil.getSqlSession();

30         /**

31          * 映射sql的標識字符串，

32          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper標籤的namespace屬性的值，

33          * getClass4是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

34          */

35         String statement = "me.gacl.mapping.classMapper.getClass4";//映射sql的標識字符串

36         //執行查詢操做，將查詢結果自動封裝成Classes對象返回

37         Classes clazz = sqlSession.selectOne(statement,1);//查詢class表中id爲1的記錄

38         //使用SqlSession執行完SQL以後須要關閉SqlSession

39         sqlSession.close();

40         //打印結果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1], students=[Student [id=1, name=student_A], Student [id=2, name=student_B], Student [id=3, name=student_C]]]

41         System.out.println(clazz);

42     }

43 }

2.六、MyBatis一對多關聯查詢總結

　　MyBatis中使用collection標籤來解決一對多的關聯查詢，ofType屬性指定集合中元素的對象類型。

MyBatis學習總結(六)——調用存儲過程

1、提出需求

2、準備數據庫表和存儲過程

 1 create table p_user(

 2     id int primary key auto_increment,

 3     name varchar(10),

 4     sex char(2)

 5 );

 7 insert into p_user(name,sex) values('A',"男");

 8 insert into p_user(name,sex) values('B',"女");

 9 insert into p_user(name,sex) values('C',"男");

11 -- 建立存儲過程(查詢獲得男性或女性的數量, 若是傳入的是0就女性不然是男性)

12 DELIMITER $

13 CREATE PROCEDURE mybatis.ges_user_count(IN sex_id INT, OUT user_count INT)

14 BEGIN

15 IF sex_id=0 THEN

16 SELECT COUNT(*) FROM mybatis.p_user WHERE p_user.sex='女' INTO user_count;

17 ELSE

18 SELECT COUNT(*) FROM mybatis.p_user WHERE p_user.sex='男' INTO user_count;

19 END IF;

20 END

21 $

23 -- 調用存儲過程

24 DELIMITER ;

25 SET @user_count = 0;

26 CALL mybatis.ges_user_count(1, @user_count);

27 SELECT @user_count;

3、編輯userMapper.xml

　　編輯userMapper.xml文件，添加以下的配置項

 1 <!--

 2         查詢獲得男性或女性的數量, 若是傳入的是0就女性不然是男性

 3      -->

 4     <select id="getUserCount" parameterMap="getUserCountMap" statementType="CALLABLE">

 5         CALL mybatis.ges_user_count(?,?)

 6     </select>

 8     <!--

 9         parameterMap.put("sexid", 0);

10         parameterMap.put("usercount", -1);

11      -->

12     <parameterMap type="java.util.Map" id="getUserCountMap">

13         <parameter property="sexid" mode="IN" jdbcType="INTEGER"/>

14         <parameter property="usercount" mode="OUT" jdbcType="INTEGER"/>

15     </parameterMap>

4、編寫單元測試代碼

 1 package me.gacl.test;

 3 import java.util.HashMap;

 4 import java.util.List;

 5 import java.util.Map;

 7 import me.gacl.custom.model.ConditionUser;

 8 import me.gacl.domain.User;

 9 import me.gacl.util.MyBatisUtil;

10 import org.apache.ibatis.session.SqlSession;

11 import org.junit.Test;

13 /**

14  * @author gacl

15  * 測試調用存儲過程

16  */

17 public class Test6 {

19     @Test

20     public void testGetUserCount(){

21         SqlSession sqlSession = MyBatisUtil.getSqlSession();

22         /**

23          * 映射sql的標識字符串，

24          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper標籤的namespace屬性的值，

25          * getUserCount是select標籤的id屬性值，經過select標籤的id屬性值就能夠找到要執行的SQL

26          */

27         String statement = "me.gacl.mapping.userMapper.getUserCount";//映射sql的標識字符串

28         Map<String, Integer> parameterMap = new HashMap<String, Integer>();

29         parameterMap.put("sexid", 1);

30         parameterMap.put("usercount", -1);

31         sqlSession.selectOne(statement, parameterMap);

32         Integer result = parameterMap.get("usercount");

33         System.out.println(result);

34         sqlSession.close();

35     }

36 }

MyBatis學習總結(七)——Mybatis緩存

1、MyBatis緩存介紹

　　正如大多數持久層框架同樣，MyBatis 一樣提供了一級緩存和二級緩存的支持

一級緩存: 基於PerpetualCache 的 HashMap本地緩存，其存儲做用域爲 Session，當 Session flush 或 close 以後，該Session中的全部 Cache 就將清空。

　　2. 二級緩存與一級緩存其機制相同，默認也是採用 PerpetualCache，HashMap存儲，不一樣在於其存儲做用域爲 Mapper(Namespace)，而且可自定義存儲源，如 Ehcache。

　　3. 對於緩存數據更新機制，當某一個做用域(一級緩存Session/二級緩存Namespaces)的進行了 C/U/D 操做後，默認該做用域下全部 select 中的緩存將被clear。

1.一、Mybatis一級緩存測試

 1 package me.gacl.test;

 3 import me.gacl.domain.User;

 4 import me.gacl.util.MyBatisUtil;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.junit.Test;

 8 /**

 9  * @author gacl

10  * 測試一級緩存

11  */

12 public class TestOneLevelCache {

14     /*

15      * 一級緩存: 也就Session級的緩存(默認開啓)

16      */

17     @Test

18     public void testCache1() {

19         SqlSession session = MyBatisUtil.getSqlSession();

20         String statement = "me.gacl.mapping.userMapper.getUser";

21         User user = session.selectOne(statement, 1);

22         System.out.println(user);

24         /*

25          * 一級緩存默認就會被使用

26          */

27         user = session.selectOne(statement, 1);

28         System.out.println(user);

29         session.close();

30         /*

31          1. 必須是同一個Session,若是session對象已經close()過了就不可能用了

32          */

33         session = MyBatisUtil.getSqlSession();

34         user = session.selectOne(statement, 1);

35         System.out.println(user);

37         /*

38          2. 查詢條件是同樣的

39          */

40         user = session.selectOne(statement, 2);

41         System.out.println(user);

43         /*

44          3. 沒有執行過session.clearCache()清理緩存

45          */

46         //session.clearCache();

47         user = session.selectOne(statement, 2);

48         System.out.println(user);

50         /*

51          4. 沒有執行過增刪改的操做(這些操做都會清理緩存)

52          */

53         session.update("me.gacl.mapping.userMapper.updateUser",

54                 new User(2, "user", 23));

55         user = session.selectOne(statement, 2);

56         System.out.println(user);

58     }

59 }

1.二、Mybatis二級緩存測試

　　一、開啓二級緩存，在userMapper.xml文件中添加以下配置

<mapper namespace="me.gacl.mapping.userMapper">

<!-- 開啓二級緩存 -->

<cache/>

　　二、測試二級緩存

 1 package me.gacl.test;

 3 import me.gacl.domain.User;

 4 import me.gacl.util.MyBatisUtil;

 5 import org.apache.ibatis.session.SqlSession;

 6 import org.apache.ibatis.session.SqlSessionFactory;

 7 import org.junit.Test;

 9 /**

10  * @author gacl

11  * 測試二級緩存

12  */

13 public class TestTwoLevelCache {

15     /*

16      * 測試二級緩存

17      * 使用兩個不一樣的SqlSession對象去執行相同查詢條件的查詢，第二次查詢時不會再發送SQL語句，而是直接從緩存中取出數據

18      */

19     @Test

20     public void testCache2() {

21         String statement = "me.gacl.mapping.userMapper.getUser";

22         SqlSessionFactory factory = MyBatisUtil.getSqlSessionFactory();

23         //開啓兩個不一樣的SqlSession

24         SqlSession session1 = factory.openSession();

25         SqlSession session2 = factory.openSession();

26         //使用二級緩存時，User類必須實現一個Serializable接口===> User implements Serializable

27         User user = session1.selectOne(statement, 1);

28         session1.commit();//不懂爲啥，這個地方必定要提交事務以後二級緩存纔會起做用

29         System.out.println("user="+user);

31         //因爲使用的是兩個不一樣的SqlSession對象，因此即便查詢條件相同，一級緩存也不會開啓使用

32         user = session2.selectOne(statement, 1);

33         //session2.commit();

34         System.out.println("user2="+user);

35     }

36 }

1.三、二級緩存補充說明

　　1. 映射語句文件中的全部select語句將會被緩存。

　　2. 映射語句文件中的全部insert，update和delete語句會刷新緩存。

　　3. 緩存會使用Least Recently Used（LRU，最近最少使用的）算法來收回。

　　4. 緩存會根據指定的時間間隔來刷新。

　　5. 緩存會存儲1024個對象

cache標籤經常使用屬性：

<cache

eviction="FIFO"  <!--回收策略爲先進先出-->

flushInterval="60000" <!--自動刷新時間60s-->

size="512" <!--最多緩存512個引用對象-->

readOnly="true"/> <!--只讀-->

只爲成功找方法，不爲失敗找藉口！

MyBatis學習總結(八)——Mybatis3.x與Spring4.x整合

1、搭建開發環境

1.一、使用Maven建立Web項目

　　執行以下命令：

mvn archetype:create -DgroupId=me.gacl -DartifactId=spring4-mybatis3 -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

　　以下圖所示：
　　

　　建立好的項目以下：

　　編輯pom.xml文件

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

 2   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

 3   <modelVersion>4.0.0</modelVersion>

 4   <groupId>me.gacl</groupId>

 5   <artifactId>spring4-mybatis3</artifactId>

 6   <packaging>war</packaging>

 7   <version>1.0-SNAPSHOT</version>

 8   <name>spring4-mybatis3 Maven Webapp</name>

 9   <url>http://maven.apache.org</url>

10   <dependencies>

11     <dependency>

12       <groupId>junit</groupId>

13       <artifactId>junit</artifactId>

14       <version>3.8.1</version>

15       <scope>test</scope>

16     </dependency>

17   </dependencies>

18   <build>

19     <finalName>spring4-mybatis3</finalName>

20   </build>

21 </project>

　　修改 <name>spring4-mybatis3 Maven Webapp</name> 部分，把" Maven Webapp"這部分包含空格的內容去掉，不然Maven在編譯項目時會由於空格的緣由致使一些莫名其妙的錯誤出現，修改爲： <name>spring4-mybatis3</name> 。

　　另外，把如下內容刪掉：

1 <dependency>

2       <groupId>junit</groupId>

3       <artifactId>junit</artifactId>

4       <version>3.8.1</version>

5       <scope>test</scope>

6 </dependency>

　　這部分是junit的jar包依賴信息，這個版本過低了，咱們不使用這個Junit測試版本，修改事後的pom.xml內容以下：

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

 2   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

 3   <modelVersion>4.0.0</modelVersion>

 4   <groupId>me.gacl</groupId>

 5   <artifactId>spring4-mybatis3</artifactId>

 6   <packaging>war</packaging>

 7   <version>1.0-SNAPSHOT</version>

 8   <name>spring4-mybatis3</name>

 9   <url>http://maven.apache.org</url>

10   <dependencies>

12   </dependencies>

13   <build>

14     <finalName>spring4-mybatis3</finalName>

15   </build>

16 </project>

1.二、將建立好的項目導入MyEclipse中

　　具體操做步驟以下圖所示：

　　手動建立【src/main/java】、【src/test/resources】、【src/test/java】這三個source folder，以下圖所示：

　　到此，項目搭建的工做就算是所有完成了。

2、建立數據庫和表(針對MySQL)

SQL腳本以下：

Create DATABASE spring4_mybatis3;

USE spring4_mybatis3;

DROP TABLE IF EXISTS t_user;

CREATE TABLE t_user (

  user_id char(32) NOT NULL,

  user_name varchar(30) DEFAULT NULL,

  user_birthday date DEFAULT NULL,

  user_salary double DEFAULT NULL,

  PRIMARY KEY (user_id)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

　　建立好的數據庫和表以下：

3、使用generator工具生成代碼

　　在網上找到了一個generator工具能夠根據建立好的數據庫表生成MyBatis的表對應的實體類，SQL映射文件和dao，找到generator工具根目錄下的generator.xml文件，這個文件是用來配置代碼生成規則的，以下圖所示：

　　編輯generator.xml文件，內容以下：

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

 2 <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

 3 <generatorConfiguration>

 4     <!-- 數據庫驅動包位置 -->

 5     <classPathEntry location="E:\repository\mysql\mysql-connector-java\5.1.34\mysql-connector-java-5.1.34.jar" />

 6     <!-- <classPathEntry location="C:\oracle\product\10.2.0\db_1\jdbc\lib\ojdbc14.jar" />-->

 7     <context id="DB2Tables" targetRuntime="MyBatis3">

 8         <commentGenerator>

 9             <property name="suppressAllComments" value="true" />

10         </commentGenerator>

11         <!-- 數據庫連接URL、用戶名、密碼 -->

12          <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/spring4_mybatis3" userId="root" password="XDP">

13         <!--<jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver" connectionURL="jdbc:oracle:thin:@localhost:1521:orcl" userId="msa" password="msa">-->

14         </jdbcConnection>

15         <javaTypeResolver>

16             <property name="forceBigDecimals" value="false" />

17         </javaTypeResolver>

18         <!-- 生成實體類的包名和位置，這裏配置將生成的實體類放在me.gacl.domain這個包下 -->

19         <javaModelGenerator targetPackage="me.gacl.domain" targetProject="C:\Users\gacl\spring4-mybatis3\src\main\java">

20             <property name="enableSubPackages" value="true" />

21             <property name="trimStrings" value="true" />

22         </javaModelGenerator>

23         <!-- 生成的SQL映射文件包名和位置，這裏配置將生成的SQL映射文件放在me.gacl.mapping這個包下 -->

24         <sqlMapGenerator targetPackage="me.gacl.mapping" targetProject="C:\Users\gacl\spring4-mybatis3\src\main\java">

25             <property name="enableSubPackages" value="true" />

26         </sqlMapGenerator>

27         <!-- 生成DAO的包名和位置，這裏配置將生成的dao類放在me.gacl.dao這個包下 -->

28         <javaClientGenerator type="XMLMAPPER" targetPackage="me.gacl.dao" targetProject="C:\Users\gacl\spring4-mybatis3\src\main\java">

29             <property name="enableSubPackages" value="true" />

30         </javaClientGenerator>

31         <!-- 要生成那些表(更改tableName和domainObjectName就能夠) -->

32         <table tableName="t_user" domainObjectName="User" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false" />

33     </context>

34 </generatorConfiguration>

　　打開命令行窗口，切換到生成工具的根目錄下，執行以下命令：

java -jar mybatis-generator-core-1.3.2.jar -configfile generator.xml -overwrite

　　以下圖所示：
　　

　　剛纔咱們在generator.xml文件中配置將生成的代碼和SQL映射文件放到"C:\Users\gacl\spring4-mybatis3\src\main\java"這個目錄下，這個目錄就是咱們的spring4-mybatis3項目所在目錄，咱們刷新一下src/main/java目錄，就能夠看到生成的代碼和映射文件了，以下圖所示：

　　生成的代碼和映射文件一行都不用改，能夠直接應用到項目當中。下面咱們看一眼由generator工具生成的代碼和映射文件：

　　一、生成的dao類

 1 package me.gacl.dao;

 3 import me.gacl.domain.User;

 5 public interface UserMapper {

 6     int deleteByPrimaryKey(String userId);

 8     int insert(User record);

10     int insertSelective(User record);

12     User selectByPrimaryKey(String userId);

14     int updateByPrimaryKeySelective(User record);

16     int updateByPrimaryKey(User record);

17 }

　　生成的UserMapper是一個接口，裏面定義了一些操做t_user表的增刪改查方法。

二、生成的實體類

 1 package me.gacl.domain;

 3 import java.util.Date;

 5 public class User {

 6     private String userId;

 8     private String userName;

10     private Date userBirthday;

12     private Double userSalary;

14     public String getUserId() {

15         return userId;

16     }

18     public void setUserId(String userId) {

19         this.userId = userId == null ? null : userId.trim();

20     }

22     public String getUserName() {

23         return userName;

24     }

26     public void setUserName(String userName) {

27         this.userName = userName == null ? null : userName.trim();

28     }

30     public Date getUserBirthday() {

31         return userBirthday;

32     }

34     public void setUserBirthday(Date userBirthday) {

35         this.userBirthday = userBirthday;

36     }

38     public Double getUserSalary() {

39         return userSalary;

40     }

42     public void setUserSalary(Double userSalary) {

43         this.userSalary = userSalary;

44     }

45 }

　　User類是t_user表的對應的實體類，User類中定義的屬性和t_user表中的字段一一對應。

　　三、生成的SQL映射文件

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

 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

 3 <mapper namespace="me.gacl.dao.UserMapper" >

 4   <resultMap id="BaseResultMap" type="me.gacl.domain.User" >

 5     <id column="user_id" property="userId" jdbcType="CHAR" />

 6     <result column="user_name" property="userName" jdbcType="VARCHAR" />

 7     <result column="user_birthday" property="userBirthday" jdbcType="DATE" />

 8     <result column="user_salary" property="userSalary" jdbcType="DOUBLE" />

 9   </resultMap>

10   <sql id="Base_Column_List" >

11     user_id, user_name, user_birthday, user_salary

12   </sql>

13   <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >

14     select

15     <include refid="Base_Column_List" />

16     from t_user

17     where user_id = #{userId,jdbcType=CHAR}

18   </select>

19   <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >

20     delete from t_user

21     where user_id = #{userId,jdbcType=CHAR}

22   </delete>

23   <insert id="insert" parameterType="me.gacl.domain.User" >

24     insert into t_user (user_id, user_name, user_birthday,

25       user_salary)

26     values (#{userId,jdbcType=CHAR}, #{userName,jdbcType=VARCHAR}, #{userBirthday,jdbcType=DATE},

27       #{userSalary,jdbcType=DOUBLE})

28   </insert>

29   <insert id="insertSelective" parameterType="me.gacl.domain.User" >

30     insert into t_user

31     <trim prefix="(" suffix=")" suffixOverrides="," >

32       <if test="userId != null" >

33         user_id,

34       </if>

35       <if test="userName != null" >

36         user_name,

37       </if>

38       <if test="userBirthday != null" >

39         user_birthday,

40       </if>

41       <if test="userSalary != null" >

42         user_salary,

43       </if>

44     </trim>

45     <trim prefix="values (" suffix=")" suffixOverrides="," >

46       <if test="userId != null" >

47         #{userId,jdbcType=CHAR},

48       </if>

49       <if test="userName != null" >

50         #{userName,jdbcType=VARCHAR},

51       </if>

52       <if test="userBirthday != null" >

53         #{userBirthday,jdbcType=DATE},

54       </if>

55       <if test="userSalary != null" >

56         #{userSalary,jdbcType=DOUBLE},

57       </if>

58     </trim>

59   </insert>

60   <update id="updateByPrimaryKeySelective" parameterType="me.gacl.domain.User" >

61     update t_user

62     <set >

63       <if test="userName != null" >

64         user_name = #{userName,jdbcType=VARCHAR},

65       </if>

66       <if test="userBirthday != null" >

67         user_birthday = #{userBirthday,jdbcType=DATE},

68       </if>

69       <if test="userSalary != null" >

70         user_salary = #{userSalary,jdbcType=DOUBLE},

71       </if>

72     </set>

73     where user_id = #{userId,jdbcType=CHAR}

74   </update>

75   <update id="updateByPrimaryKey" parameterType="me.gacl.domain.User" >

76     update t_user

77     set user_name = #{userName,jdbcType=VARCHAR},

78       user_birthday = #{userBirthday,jdbcType=DATE},

79       user_salary = #{userSalary,jdbcType=DOUBLE}

80     where user_id = #{userId,jdbcType=CHAR}

81   </update>

82 </mapper>

　　UserMapper.xml這個文件的內容是編寫操做t_user表的SQL語句，重點說一下UserMapper.xml配置中須要注意的幾個小細節問題：

　　一、UserMapper.xml的<mapper>標籤的namespace必須是UserMapper接口的全類名，既<mapper namespace="me.gacl.dao.UserMapper" >

　　二、UserMapper.xml的定義操做數據庫的<select><delete><update><insert>這些標籤的id屬性的值必須和UserMapper接口定義的方法名一致，以下圖所示：

　　之因此有上述說的這兩點要求，就是爲了可以讓MyBatis可以根據UserMapper接口和UserMapper.xml文件去自動實現UserMapper接口中定義的相關方法，這樣咱們就再也不須要針對UserMapper接口去編寫具體的實現代碼了。

4、Spring與MyBatis整合

　　首先咱們要在項目中加入咱們須要的相關jar包，咱們能夠到Maven的中央倉庫：http://search.maven.org/ 找到咱們要的相關jar包，以下圖所示：

　　咱們只須要在搜索框中輸入要找的jar包的名稱，點擊【SEARCH】按鈕，就能夠找到咱們要的jar包了。

4.一、添加Spring與Mybatis的相關jar包

　　一、添加spring-core，輸入spring-core關鍵字進行查找，以下圖所示：

　　找到關於spring-core的依賴描述信息，以下圖所示：

　　將

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-core</artifactId>

    <version>4.1.4.RELEASE</version>

</dependency>

　　複製到項目的pom.xml文件中，以下所示：

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

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>me.gacl</groupId>

    <artifactId>spring4-mybatis3</artifactId>

    <packaging>war</packaging>

    <version>1.0-SNAPSHOT</version>

    <name>spring4-mybatis3</name>

    <url>http://maven.apache.org</url>

    <dependencies>

        <!-- 添加Spring4.1.4的核心包 -->

        <dependency>

            <groupId>org.springframework</groupId>

            <artifactId>spring-core</artifactId>

            <version>4.1.4.RELEASE</version>

        </dependency>

    </dependencies>

    <build>

        <finalName>spring4-mybatis3</finalName>

    </build>

</project>

　　這樣Maven就會自動幫咱們從Maven的中央倉庫中下載spring-core這個jar包到咱們的本地倉庫，而後將spring-core這個jar包以及它的相關依賴包加入到咱們的項目當中，以下所示：

　　spring4.x與mybatis3.x所須要的相關jar包均可以採用上述所說的方式進行查找，而後添加到項目當中，添加完spring4.x與mybatis3.x相關jar包後，pom.xml文件內容最終以下：

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

  2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

  3     <modelVersion>4.0.0</modelVersion>

  4     <groupId>me.gacl</groupId>

  5     <artifactId>spring4-mybatis3</artifactId>

  6     <packaging>war</packaging>

  7     <version>1.0-SNAPSHOT</version>

  8     <name>spring4-mybatis3</name>

  9     <url>http://maven.apache.org</url>

 10     <dependencies>

 11         <!-- 添加Spring-core包 -->

 12         <dependency>

 13             <groupId>org.springframework</groupId>

 14             <artifactId>spring-core</artifactId>

 15             <version>4.1.4.RELEASE</version>

 16         </dependency>

 17         <!-- 添加spring-context包 -->

 18         <dependency>

 19             <groupId>org.springframework</groupId>

 20             <artifactId>spring-context</artifactId>

 21             <version>4.1.4.RELEASE</version>

 22         </dependency>

 23         <!-- 添加spring-tx包 -->

 24         <dependency>

 25             <groupId>org.springframework</groupId>

 26             <artifactId>spring-tx</artifactId>

 27             <version>4.1.4.RELEASE</version>

 28         </dependency>

 29         <!-- 添加spring-jdbc包 -->

 30         <dependency>

 31             <groupId>org.springframework</groupId>

 32             <artifactId>spring-jdbc</artifactId>

 33             <version>4.1.4.RELEASE</version>

 34         </dependency>

 35         <!-- 爲了方便進行單元測試，添加spring-test包 -->

 36         <dependency>

 37             <groupId>org.springframework</groupId>

 38             <artifactId>spring-test</artifactId>

 39             <version>4.1.4.RELEASE</version>

 40         </dependency>

 41         <!--添加spring-web包 -->

 42         <dependency>

 43             <groupId>org.springframework</groupId>

 44             <artifactId>spring-web</artifactId>

 45             <version>4.1.4.RELEASE</version>

 46         </dependency>

 47         <!--添加aspectjweaver包 -->

 48         <dependency>

 49             <groupId>org.aspectj</groupId>

 50             <artifactId>aspectjweaver</artifactId>

 51             <version>1.8.5</version>

 52         </dependency>

 53         <!-- 添加mybatis的核心包 -->

 54         <dependency>

 55             <groupId>org.mybatis</groupId>

 56             <artifactId>mybatis</artifactId>

 57             <version>3.2.8</version>

 58         </dependency>

 59         <!-- 添加mybatis與Spring整合的核心包 -->

 60         <dependency>

 61             <groupId>org.mybatis</groupId>

 62             <artifactId>mybatis-spring</artifactId>

 63             <version>1.2.2</version>

 64         </dependency>

 65         <!-- 添加servlet3.0核心包 -->

 66         <dependency>

 67             <groupId>javax.servlet</groupId>

 68             <artifactId>javax.servlet-api</artifactId>

 69             <version>3.0.1</version>

 70         </dependency>

 71         <dependency>

 72             <groupId>javax.servlet.jsp</groupId>

 73             <artifactId>javax.servlet.jsp-api</artifactId>

 74             <version>2.3.2-b01</version>

 75         </dependency>

 76         <!-- jstl -->

 77         <dependency>

 78             <groupId>javax.servlet</groupId>

 79             <artifactId>jstl</artifactId>

 80             <version>1.2</version>

 81         </dependency>

 82         <!-- 添加mysql驅動包 -->

 83         <dependency>

 84             <groupId>mysql</groupId>

 85             <artifactId>mysql-connector-java</artifactId>

 86             <version>5.1.34</version>

 87         </dependency>

 88         <!-- 添加druid鏈接池包 -->

 89         <dependency>

 90             <groupId>com.alibaba</groupId>

 91             <artifactId>druid</artifactId>

 92             <version>1.0.12</version>

 93         </dependency>

 94         <!-- 添加junit單元測試包 -->

 95         <dependency>

 96             <groupId>junit</groupId>

 97             <artifactId>junit</artifactId>

 98             <version>4.12</version>

 99             <scope>test</scope>

100         </dependency>

101     </dependencies>

102     <build>

103         <finalName>spring4-mybatis3</finalName>

104     </build>

105 </project>

4.二、編寫相關配置文件

　　一、dbconfig.properties

　　在src/main/resources目錄下建立一個dbconfig.properties文件，用於編寫鏈接MySQL數據庫的相關信息，dbconfig.properties的內容以下：

driverClassName=com.mysql.jdbc.Driver

validationQuery=SELECT 1

jdbc_url=jdbc:mysql://localhost:3306/spring4_mybatis3?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull

jdbc_username=root

jdbc_password=XDP

　　二、spring.xml(spring框架的配置文件)

　　在src/main/resources目錄下建立一個spring.xml文件，spring.xml文件就是針對Spring框架編寫的核心配置文件，spring.xml的內容以下：

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

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <!-- 引入dbconfig.properties屬性文件 -->

    <context:property-placeholder location="classpath:dbconfig.properties" />

    <!-- 自動掃描(自動注入)，掃描me.gacl.service這個包以及它的子包的全部使用@Service註解標註的類 -->

    <context:component-scan base-package="me.gacl.service" />

</beans>

　　咱們的spring.xml文件的配置很是簡單，就兩個配置。
　　三、spring-mybatis.xml(spring與mybatis整合的配置文件)

　　在src/main/resources目錄下建立一個spring-mybatis.xml文件，spring-mybatis.xml文件就是針對Spring框架與Mybatis框架整合編寫的配置文件，spring-mybatis.xml的內容以下：

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

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns: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-3.0.xsd

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

">

    <!-- JNDI方式配置數據源 -->

    <!-- <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="${jndiName}"></property> </bean> -->

    <!-- ========================================配置數據源========================================= -->

    <!-- 配置數據源，使用的是alibaba的Druid(德魯伊)數據源 -->

    <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">

        <property name="url" value="${jdbc_url}" />

        <property name="username" value="${jdbc_username}" />

        <property name="password" value="${jdbc_password}" />

        <!-- 初始化鏈接大小 -->

        <property name="initialSize" value="0" />

        <!-- 鏈接池最大使用鏈接數量 -->

        <property name="maxActive" value="20" />

        <!-- 鏈接池最大空閒 -->

        <property name="maxIdle" value="20" />

        <!-- 鏈接池最小空閒 -->

        <property name="minIdle" value="0" />

        <!-- 獲取鏈接最大等待時間 -->

        <property name="maxWait" value="60000" />

        <!--

        <property name="poolPreparedStatements" value="true" />

        <property name="maxPoolPreparedStatementPerConnectionSize" value="33" />

-->

        <property name="validationQuery" value="${validationQuery}" />

        <property name="testOnBorrow" value="false" />

        <property name="testOnReturn" value="false" />

        <property name="testWhileIdle" value="true" />

        <!-- 配置間隔多久才進行一次檢測，檢測須要關閉的空閒鏈接，單位是毫秒 -->

        <property name="timeBetweenEvictionRunsMillis" value="60000" />

        <!-- 配置一個鏈接在池中最小生存的時間，單位是毫秒 -->

        <property name="minEvictableIdleTimeMillis" value="25200000" />

        <!-- 打開removeAbandoned功能 -->

        <property name="removeAbandoned" value="true" />

        <!-- 1800秒，也就是30分鐘 -->

        <property name="removeAbandonedTimeout" value="1800" />

        <!-- 關閉abanded鏈接時輸出錯誤日誌 -->

        <property name="logAbandoned" value="true" />

        <!-- 監控數據庫 -->

        <!-- <property name="filters" value="stat" /> -->

        <property name="filters" value="mergeStat" />

    </bean>

    <!-- ========================================分隔線========================================= -->

    <!-- ========================================針對myBatis的配置項============================== -->

    <!-- 配置sqlSessionFactory -->

    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

        <!-- 實例化sqlSessionFactory時須要使用上述配置好的數據源以及SQL映射文件 -->

        <property name="dataSource" ref="dataSource" />

        <!-- 自動掃描me/gacl/mapping/目錄下的全部SQL映射的xml文件, 省掉Configuration.xml裏的手工配置

        value="classpath:me/gacl/mapping/*.xml"指的是classpath(類路徑)下me.gacl.mapping包中的全部xml文件

        UserMapper.xml位於me.gacl.mapping包下，這樣UserMapper.xml就能夠被自動掃描

-->

        <property name="mapperLocations" value="classpath:me/gacl/mapping/*.xml" />

    </bean>

    <!-- 配置掃描器 -->

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

        <!-- 掃描me.gacl.dao這個包以及它的子包下的全部映射接口類 -->

        <property name="basePackage" value="me.gacl.dao" />

        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

    </bean>

    <!-- ========================================分隔線========================================= -->

    <!-- 配置Spring的事務管理器 -->

    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <property name="dataSource" ref="dataSource" />

    </bean>

    <!-- 註解方式配置事物 -->

    <!-- <tx:annotation-driven transaction-manager="transactionManager" /> -->

    <!-- 攔截器方式配置事物 -->

    <tx:advice id="transactionAdvice" transaction-manager="transactionManager">

        <tx:attributes>

            <tx:method name="add*" propagation="REQUIRED" />

            <tx:method name="append*" propagation="REQUIRED" />

            <tx:method name="insert*" propagation="REQUIRED" />

            <tx:method name="save*" propagation="REQUIRED" />

            <tx:method name="update*" propagation="REQUIRED" />

            <tx:method name="modify*" propagation="REQUIRED" />

            <tx:method name="edit*" propagation="REQUIRED" />

            <tx:method name="delete*" propagation="REQUIRED" />

            <tx:method name="remove*" propagation="REQUIRED" />

            <tx:method name="repair" propagation="REQUIRED" />

            <tx:method name="delAndRepair" propagation="REQUIRED" />

            <tx:method name="get*" propagation="SUPPORTS" />

            <tx:method name="find*" propagation="SUPPORTS" />

            <tx:method name="load*" propagation="SUPPORTS" />

            <tx:method name="search*" propagation="SUPPORTS" />

            <tx:method name="datagrid*" propagation="SUPPORTS" />

            <tx:method name="*" propagation="SUPPORTS" />

        </tx:attributes>

    </tx:advice>

    <aop:config>

        <aop:pointcut id="transactionPointcut" expression="execution(* me.gacl.service..*Impl.*(..))" />

        <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />

    </aop:config>

    <!-- 配置druid監控spring jdbc -->

    <bean id="druid-stat-interceptor" class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor">

    </bean>

    <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut" scope="prototype">

        <property name="patterns">

            <list>

                <value>me.gacl.service.*</value>

            </list>

        </property>

    </bean>

    <aop:config>

        <aop:advisor advice-ref="druid-stat-interceptor" pointcut-ref="druid-stat-pointcut" />

    </aop:config>

</beans>

　　到此，相關的配置文件算是編寫完成了，以下圖所示：

4.三、進行單元測試

　　通過以上兩個步驟，spring4與mybatis3的整合算是所有完成了。接下來咱們要作的工做就算進行單元測試，測試一下spring4與mybatis3的整合是否成功。

　　一、在src/main/java目錄下建立一個me.gacl.service包，而後在me.gacl.service包建立一個UserServiceI接口，以下所示：

 1 package me.gacl.service;

 3 import me.gacl.domain.User;

 5 public interface UserServiceI {

 7     /**

 8      * 添加用戶

 9      * @param user

10      */

11     void addUser(User user);

13     /**

14      * 根據用戶id獲取用戶

15      * @param userId

16      * @return

17      */

18     User getUserById(String userId);

19 }

　　二、在src/main/java目錄下建立一個me.gacl.service.impl包，而後在me.gacl.service.impl包建立一個針對UserServiceI接口的實現類：UserServiceImpl，以下所示：

 1 package me.gacl.service.impl;

 3 import org.springframework.beans.factory.annotation.Autowired;

 4 import org.springframework.stereotype.Service;

 5 import me.gacl.dao.UserMapper;

 6 import me.gacl.domain.User;

 7 import me.gacl.service.UserServiceI;

 9 /**

10  * @author gacl

11  * 使用@Service註解將UserServiceImpl類標註爲一個service

12  * service的id是userService

13  */

14 @Service("userService")

15 public class UserServiceImpl implements UserServiceI {

17     /**

18      * 使用@Autowired註解標註userMapper變量，

19      * 當須要使用UserMapper時，Spring就會自動注入UserMapper

20      */

21     @Autowired

22     private UserMapper userMapper;//注入dao

24     @Override

25     public void addUser(User user) {

26         userMapper.insert(user);

27     }

29     @Override

30     public User getUserById(String userId) {

31         return userMapper.selectByPrimaryKey(userId);

32     }

33 }

　　建立好的兩個類以下所示：

　　三、在src/test/java目錄下編寫單元測試類，新建一個me.gacl.test包，而後在這個包下建立一個MyBatisTest類，代碼以下：

 1 package me.gacl.test;

 3 import java.util.Date;

 4 import java.util.UUID;

 5 import me.gacl.domain.User;

 6 import me.gacl.service.UserServiceI;

 7 //import me.gacl.service.UserServiceI;

 8 import org.junit.Before;

 9 import org.junit.Test;

10 import org.springframework.context.ApplicationContext;

11 import org.springframework.context.support.ClassPathXmlApplicationContext;

13 public class MyBatisTest {

15     private UserServiceI userService;

17     /**

18      * 這個before方法在全部的測試方法以前執行，而且只執行一次

19      * 全部作Junit單元測試時一些初始化工做能夠在這個方法裏面進行

20      * 好比在before方法裏面初始化ApplicationContext和userService

21      */

22     @Before

23     public void before(){

24         //使用"spring.xml"和"spring-mybatis.xml"這兩個配置文件建立Spring上下文

25         ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-mybatis.xml"});

26         //從Spring容器中根據bean的id取出咱們要使用的userService對象

27         userService = (UserServiceI) ac.getBean("userService");

28     }

30     @Test

31     public void testAddUser(){

32         //ApplicationContext ac = new ClassPathXmlApplicationContext(new String[]{"spring.xml","spring-mybatis.xml"});

33         //UserServiceI userService = (UserServiceI) ac.getBean("userService");

34         User user = new User();

35         user.setUserId(UUID.randomUUID().toString().replaceAll("-", ""));

36         user.setUserName("白虎神皇xdp");

37         user.setUserBirthday(new Date());

38         user.setUserSalary(10000D);

39         userService.addUser(user);

40     }

42 }

　　執行單元測試代碼，這時候會報以下錯誤：

　　錯誤提示是說沒有找到"me.gacl.test.MyBatisTest"這個類，這是由於咱們沒有使用maven編譯項目中的類的緣故。

　　下面咱們使用Maven編譯項目，選中項目的pom.xml文件→【Debug As】→【maven install】，以下所示：

編譯結果以下：

　　在這裏說一下我執行Maven install以後遇到的問題，第一次執行Maven install命令時，就出現了以下一堆亂七八糟的錯誤：

　　後來我把項目刪掉，再從新導入項目，而後再執行Clean項目操做以後，以下圖所示：

　　再執行Maven install操做又能夠正常編譯經過了，這讓我鬱悶了很久，這應該不是我項目配置的緣由，而是Maven的緣由，具體也不知道爲啥會這樣。反正這算是一種解決辦法吧，若是遇到執行Maven install操做不能正常編譯經過的狀況：能夠嘗試採用：Maven clean→Clean項目→Maven install這三個步驟去解決問題。

　　除了能夠用常規的Junit進行單元測試以外，咱們還可使用Spring提供的Junit測試框架進行單元測試，在me.gacl.test下新建一個MyBatisTestBySpringTestFramework類，代碼以下：

 1 package me.gacl.test;

 3 import java.util.Date;

 4 import java.util.UUID;

 5 import me.gacl.domain.User;

 6 import me.gacl.service.UserServiceI;

 7 import org.junit.Test;

 8 import org.junit.runner.RunWith;

 9 import org.springframework.beans.factory.annotation.Autowired;

10 import org.springframework.test.context.ContextConfiguration;

11 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

13 @RunWith(SpringJUnit4ClassRunner.class)

14 //配置了@ContextConfiguration註解並使用該註解的locations屬性指明spring和配置文件以後，

15 @ContextConfiguration(locations = {"classpath:spring.xml", "classpath:spring-mybatis.xml" })

16 public class MyBatisTestBySpringTestFramework {

18     //注入userService

19     @Autowired

20     private UserServiceI userService;

22     @Test

23     public void testAddUser(){

24         User user = new User();

25         user.setUserId(UUID.randomUUID().toString().replaceAll("-", ""));

26         user.setUserName("xdp_gacl_白虎神皇");

27         user.setUserBirthday(new Date());

28         user.setUserSalary(10000D);

29         userService.addUser(user);

30     }

32     @Test

33     public void testGetUserById(){

34         String userId = "fb1c5941094e400b975f10d9a9d602a3";

35         User user = userService.getUserById(userId);

36         System.out.println(user.getUserName());

37     }

38 }

　　執行這兩個測試方法，是能夠正常測試經過的，以下所示：

　　到此，咱們框架的整合測試工做就算是所有經過了，整合成功。

4.四、在web服務器中進行測試

　　一、編輯web.xml文件，添加spring監聽器配置項，內容以下：

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

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

                      http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"

    version="3.0">

    <welcome-file-list>

        <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>

    <listener>

        <description>Spring監聽器</description>

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>

    <!-- ContextLoaderListener初始化Spring上下文時須要使用到的contextConfigLocation參數 -->

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <!-- 配置spring.xml和spring-mybatis.xml這兩個配置文件的位置，固定寫法 -->

        <param-value>classpath:spring.xml,classpath:spring-mybatis.xml</param-value>

    </context-param>

</web-app>

　　二、在UserMapper接口中添加一個獲取全部用戶信息的getAllUser()方法，以下所示：

 1 package me.gacl.dao;

 3 import java.util.List;

 5 import me.gacl.domain.User;

 7 public interface UserMapper {

 8     int deleteByPrimaryKey(String userId);

10     int insert(User record);

12     int insertSelective(User record);

14     User selectByPrimaryKey(String userId);

16     int updateByPrimaryKeySelective(User record);

18     int updateByPrimaryKey(User record);

20     /**獲取全部用戶信息

21      * @return List<User>

22      */

23     List<User> getAllUser();

24 }

　　三、在UserMapper.xml文件中編寫getAllUser()方法要執行的SQL語句，以下所示：

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

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >

<mapper namespace="me.gacl.dao.UserMapper" >

  <resultMap id="BaseResultMap" type="me.gacl.domain.User" >

    <id column="user_id" property="userId" jdbcType="CHAR" />

    <result column="user_name" property="userName" jdbcType="VARCHAR" />

    <result column="user_birthday" property="userBirthday" jdbcType="DATE" />

    <result column="user_salary" property="userSalary" jdbcType="DOUBLE" />

  </resultMap>

  <sql id="Base_Column_List" >

    user_id, user_name, user_birthday, user_salary

  </sql>

  <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >

    select

    <include refid="Base_Column_List" />

    from t_user

    where user_id = #{userId,jdbcType=CHAR}

  </select>

  <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >

    delete from t_user

    where user_id = #{userId,jdbcType=CHAR}

  </delete>

  <insert id="insert" parameterType="me.gacl.domain.User" >

    insert into t_user (user_id, user_name, user_birthday,

      user_salary)

    values (#{userId,jdbcType=CHAR}, #{userName,jdbcType=VARCHAR}, #{userBirthday,jdbcType=DATE},

      #{userSalary,jdbcType=DOUBLE})

  </insert>

  <insert id="insertSelective" parameterType="me.gacl.domain.User" >

    insert into t_user

    <trim prefix="(" suffix=")" suffixOverrides="," >

      <if test="userId != null" >

        user_id,

      </if>

      <if test="userName != null" >

        user_name,

      </if>

      <if test="userBirthday != null" >

        user_birthday,

      </if>

      <if test="userSalary != null" >

        user_salary,

      </if>

    </trim>

    <trim prefix="values (" suffix=")" suffixOverrides="," >

      <if test="userId != null" >

        #{userId,jdbcType=CHAR},

      </if>

      <if test="userName != null" >

        #{userName,jdbcType=VARCHAR},

      </if>

      <if test="userBirthday != null" >

        #{userBirthday,jdbcType=DATE},

      </if>

      <if test="userSalary != null" >

        #{userSalary,jdbcType=DOUBLE},

      </if>

    </trim>

  </insert>

  <update id="updateByPrimaryKeySelective" parameterType="me.gacl.domain.User" >

    update t_user

    <set >

      <if test="userName != null" >

        user_name = #{userName,jdbcType=VARCHAR},

      </if>

      <if test="userBirthday != null" >

        user_birthday = #{userBirthday,jdbcType=DATE},

      </if>

      <if test="userSalary != null" >

        user_salary = #{userSalary,jdbcType=DOUBLE},

      </if>

    </set>

    where user_id = #{userId,jdbcType=CHAR}

  </update>

  <update id="updateByPrimaryKey" parameterType="me.gacl.domain.User" >

    update t_user

    set user_name = #{userName,jdbcType=VARCHAR},

      user_birthday = #{userBirthday,jdbcType=DATE},

      user_salary = #{userSalary,jdbcType=DOUBLE}

    where user_id = #{userId,jdbcType=CHAR}

  </update>

  <!-- ==============如下內容是根據自身業務擴展的內容======================= -->

      <!-- select標籤的id屬性與UserMapper接口中定義的getAllUser方法要如出一轍 -->

    <select id="getAllUser" resultMap="BaseResultMap">

        select user_id, user_name, user_birthday, user_salary from t_user

    </select>

</mapper>

　　四、在UserServiceI接口中也添加一個getAllUser()方法，以下：

 1 package me.gacl.service;

 3 import java.util.List;

 5 import me.gacl.domain.User;

 7 public interface UserServiceI {

 9     /**

10      * 添加用戶

11      * @param user

12      */

13     void addUser(User user);

15     /**

16      * 根據用戶id獲取用戶

17      * @param userId

18      * @return

19      */

20     User getUserById(String userId);

22     /**獲取全部用戶信息

23      * @return List<User>

24      */

25     List<User> getAllUser();

26 }

　　五、在UserServiceImpl類中實現getAllUser方法，以下：

 1 package me.gacl.service.impl;

 3 import java.util.List;

 5 import org.springframework.beans.factory.annotation.Autowired;

 6 import org.springframework.stereotype.Service;

 7 import me.gacl.dao.UserMapper;

 8 import me.gacl.domain.User;

 9 import me.gacl.service.UserServiceI;

11 /**

12  * @author gacl

13  * 使用@Service註解將UserServiceImpl類標註爲一個service

14  * service的id是userService

15  */

16 @Service("userService")

17 public class UserServiceImpl implements UserServiceI {

19     /**

20      * 使用@Autowired註解標註userMapper變量，

21      * 當須要使用UserMapper時，Spring就會自動注入UserMapper

22      */

23     @Autowired

24     private UserMapper userMapper;//注入dao

26     @Override

27     public void addUser(User user) {

28         userMapper.insert(user);

29     }

31     @Override

32     public User getUserById(String userId) {

33         return userMapper.selectByPrimaryKey(userId);

34     }

36     @Override

37     public List<User> getAllUser() {

38         return userMapper.getAllUser();

39     }

40 }

　　六、在src/main/java目錄下建立一個me.gacl.web.controller包，而後在me.gacl.web.controller下建立一個UserServlet，以下：

 1 package me.gacl.web.controller;

 3 import java.io.IOException;

 4 import java.util.List;

 6 import javax.servlet.ServletException;

 7 import javax.servlet.annotation.WebServlet;

 8 import javax.servlet.http.HttpServlet;

 9 import javax.servlet.http.HttpServletRequest;

10 import javax.servlet.http.HttpServletResponse;

12 import org.springframework.context.ApplicationContext;

13 import org.springframework.web.context.support.WebApplicationContextUtils;

15 import me.gacl.domain.User;

16 import me.gacl.service.UserServiceI;

18 /**

19  * @author gacl

20  * @WebServlet是Servlet3.0提供的註解，目的是將一個繼承了HttpServlet類的普通java類標註爲一個Servlet

21  * UserServlet使用了@WebServlet標註以後，就不須要在web.xml中配置了

22  */

23 @WebServlet("/UserServlet")

24 public class UserServlet extends HttpServlet {

26     //處理業務邏輯的userService

27     private UserServiceI userService;

29     public void doGet(HttpServletRequest request, HttpServletResponse response)

30             throws ServletException, IOException {

31         //獲取全部的用戶信息

32         List<User> lstUsers = userService.getAllUser();

33         request.setAttribute("lstUsers", lstUsers);

34         request.getRequestDispatcher("/index.jsp").forward(request, response);

35     }

37     public void doPost(HttpServletRequest request, HttpServletResponse response)

38             throws ServletException, IOException {

39         this.doGet(request, response);

40     }

42     public void init() throws ServletException {

43         //在Servlet初始化時獲取Spring上下文對象(ApplicationContext)

44         ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());

45         //從ApplicationContext中獲取userService

46         userService = (UserServiceI) ac.getBean("userService");

47     }

48 }

　　七、編輯index.jsp頁面，用於展現查詢到的用戶信息，內容以下：

<%@ page language="java" pageEncoding="UTF-8"%>

<%--引入JSTL核心標籤庫 --%>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

<!DOCTYPE html>

<html>

    <head>

        <title>顯示用戶信息</title>

        <style type="text/css">

            table,td{

                border: 1px solid;

                border-collapse: collapse;

        </style>

    </head>

    <body>

        <table>

            <tr>

                <td>用戶ID</td>

                <td>用戶名</td>

                <td>用戶生日</td>

                <td>工資</td>

            </tr>

            <%--遍歷lstUsers集合中的User對象 --%>

            <c:forEach var="user" items="${lstUsers}">

                <tr>

                    <td>${user.userId}</td>

                    <td>${user.userName}</td>

                    <td>${user.userBirthday}</td>

                    <td>${user.userSalary}</td>

                </tr>

            </c:forEach>

        </table>

    </body>

</html>

　　八、執行maven install命令編譯項目，而後將項目部署到tomcat服務器中運行，注意，因爲要使用Servlet3.0，因此必須將項目部署到tomcat7.x以上的服務器中去運行，以下所示：

　　輸入地址：http://localhost:8080/spring4-mybatis3/UserServlet 訪問UserServlet，訪問結果以下：

　　能夠看到，t_user表中的用戶信息所有查詢出來顯示到頁面上了。這樣在web服務器中的測試也正常經過了。

　　以上就是Spring4.x與MyBatis3.x整合的所有內容了。編寫這個整合例子花了很多時間，使用Maven編譯時老是出現莫名其妙的問題，有時候成功，有時候失敗，反正很莫名其妙。若是遇到執行Maven install操做不能正常編譯經過的狀況：能夠嘗試採用：Maven clean→Clean項目→Maven install這三個步驟去解決問題

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。