技術標籤：筆記mybatis

Mybatis框架

1.三層架構

• 介面層：和使用者打交道的，接受使用者的請求引數，顯示處理結果的（jsp.html.servlet）
• 業務邏輯層：接受了介面層傳遞的資料，計算邏輯，呼叫資料庫，獲取資料
• 資料訪問層：就是訪問資料庫，執行對資料的查詢，修改，刪除等

MVC：

• M：資料層
• V：檢視層
• C：控制層

三層架構對應的包

• 介面層：controller（servlet）
• 業務邏輯層：Service 包 （XXXservice）
• 資料訪問層：dao包（XXXDao包）

三層中類的互動

使用者使用介面層——業務邏輯層——資料訪問層（持久層）——資料庫（mysql）

三層對應的處理框架

1. 介面層——servlet——springmvc(框架)
2. 業務邏輯層——Service類——spring（框架）
3. 資料訪問層——dao類——mybatis(框架)

2.框架

框架是一個舞臺，一個模板

模板：

1. 規定好了一些條款，內容；
2. 加入自己的東西；

框架是一個模組

1. 框架中定義好了一些功能。這些功能是可用的。
2. 可以加入專案中自己的功能，這些功能可以利用框架中寫好的功能

框架是一個軟體，半成品的軟體，定義好了一些基礎的功能，需要加入你的功能就是完整的，基礎功能是可重複使用的，可升級的

框架的特點：

• 框架一般不是全能的，不能做所有的事情
• 框架是針對某一領域有效，特長是在某一個方面，比如mybatis做資料庫操作強
• 框架是一個軟體

mybatis框架

mybatis是Mybatis Sql Mapper Framework for java（SQL對映框架）

1. sql mapper ：sql對映

   可以將資料庫表中的一行資料，對映為一個java物件

   一行資料可以看做是一個java物件，操作這個物件就相當於操作表中的資料

2. Data Access Objects(Daos):資料訪問，對資料庫執行增刪改查

mybatis提供了哪些功能：

1. 提供了建立Connection，Statement，ResultSet的能力，不用開發人員建立這些物件

2. 提供了執行SQL語句的能力，不用你執行SQL

3. 提供了迴圈SQL，把SQL的結果轉為java物件，List集合的能力

   while(rs.next){

   ​ Student stu = new Student();

   ​ stu.setId(rs.getInt(“id”));
   ​ stu.setName(rs.getString(“name”));
   ​ stu.setAge(rs.getInt(“age”));
   ​ //從資料庫取出資料轉為 Student 物件，封裝到 List 集合
   ​ stuList.add(stu);

   }

4.提供了關閉資源的能力，不用你關閉Connection, Statement, ResultSet

開發人員做的是： 提供sql語句
最後是： 開發人員提供sql語句–mybatis處理sql—開發人員得到List集合或java物件（表中的資料）

總結：
mybatis是一個sql對映框架，提供的資料庫的操作能力。增強的JDBC, 使用mybatis讓開發人員集中精神寫sql就可以了，不必關心 Connection,Statement,ResultSet的建立，銷燬，sql的執行。

實行步驟

1. 新建student表

   CREATE TABLE `student` (
    `id` int(11) NOT NULL ,
    `name` varchar(255) DEFAULT NULL,
    `email` varchar(255) DEFAULT NULL,
    `age` int(11) DEFAULT NULL,
    PRIMARY KEY (`id`)
   ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
   

2. 加入Maven的mybatis座標，MySQL驅動的座標

   <dependencies>
   <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>4.11</version>
       <scope>test</scope>
     </dependency>
     <!--mybatis依賴-->
     <dependency>
       <groupId>org.mybatis</groupId>
       <artifactId>mybatis</artifactId>
       <version>3.5.1</version>
     </dependency>
     <!--mysql驅動-->
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>5.1.9</version>
     </dependency>
   </dependencies>
   
   <build>
     <resources>
       <resource>
         <directory>src/main/java</directory><!--所在的目錄-->
         <includes><!--包括目錄下的.properties,.xml 檔案都會掃描到-->
           <include>**/*.properties</include>
           <include>**/*.xml</include>
         </includes>
         <filtering>false</filtering>
       </resource>
     </resources>
   </build>
   

3. 建立實體類，student——儲存表中的一行資料的

   //推薦和表名一樣。容易記憶
   public class Student {
       //定義屬性， 目前要求是屬性名和列名一樣。
       private Integer id;
       private String name;
       private String email;
       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 String getEmail() {
           return email;
       }
   
       public void setEmail(String email) {
           this.email = email;
       }
   
       public Integer getAge() {
           return age;
       }
   
       public void setAge(Integer age) {
           this.age = age;
       }
   
       @Override
       public String toString() {
           return "Student{" +
                   "id=" + id +
                   ", name='" + name + '\'' +
                   ", email='" + email + '\'' +
                   ", age=" + age +
                   '}';
       }
   }
   

4. 建立持久層dao介面,定義操作資料庫的方法

   //介面操作student表
   public interface StudentDao {
   
       //查詢student表的所有的資料
       public List<Student> selectStudents();
   
       //插入方法
       //引數： student ,表示要插入到資料庫的資料
       //返回值： int ， 表示執行insert操作後的 影響資料庫的行數
       public int insertStudent(Student student);
   }
   

5. 建立一個mybatis 使用的配置檔案 sqlmapper

   叫做SQL對映檔案：寫SQL語句的，一般一個表一個SQL對映檔案

   這個檔案是xml檔案

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.bjpowernode.dao.StudentDao">
       <!--
          select:表示查詢操作。
          id: 你要執行的sql語法的唯一標識， mybatis會使用這個id的值來找到要執行的sql語句
              可以自定義，但是  要求你使用介面中的方法名稱。
   
          resultType:表示結果型別的， 是sql語句執行後得到ResultSet,遍歷這個ResultSet得到java物件的型別。
             值寫的型別的全限定名稱
       -->
       <select id="介面中的方法名稱" resultType="方法執行得到的java物件的型別，使用全限定名稱" >
           select id,name,email,age from student order by id
       </select>
   
       <!--插入操作-->
       <insert id="insertStudent">
           insert into student values(#{id},#{name},#{email},#{age})
       </insert>
   </mapper>
   <!--
     sql對映檔案（sql mapper）： 寫sql語句的， mybatis會執行這些sql
     1.指定約束檔案
        <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   
       mybatis-3-mapper.dtd是約束檔案的名稱， 副檔名是dtd的。
     2.約束檔案作用：  限制，檢查在當前檔案中出現的標籤，屬性必須符合mybatis的要求。
   
     3.mapper 是當前檔案的根標籤，必須的。
       namespace：叫做名稱空間，唯一值的， 可以是自定義的字串。
                  要求你使用dao介面的全限定名稱。
   
     4.在當前檔案中，可以使用特定的標籤，表示資料庫的特定操作。
      <select>:表示執行查詢，select語句
      <update>:表示更新資料庫的操作， 就是在<update>標籤中 寫的是update sql語句
      <insert>:表示插入， 放的是insert語句
      <delete>:表示刪除， 執行的delete語句
   -->
   

6. 建立mybatis的主配置檔案

   一個專案就一個主配置檔案

   主配置檔案提供了資料庫的連線資訊和SQL對映檔案的位置資訊

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE configuration
           PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-config.dtd">
   <configuration>
   
       <!--settings：控制mybatis全域性行為-->
       <settings>
           <!--設定mybatis輸出日誌-->
           <setting name="logImpl" value="STDOUT_LOGGING" />
       </settings>
   
       <!--環境配置： 資料庫的連線資訊
           default:必須和某個environment的id值一樣。
           告訴mybatis使用哪個資料庫的連線資訊。也就是訪問哪個資料庫
       -->
       <environments default="mydev">
           <!-- environment : 一個數據庫資訊的配置， 環境
                id:一個唯一值，自定義，表示環境的名稱。
           -->
           <environment id="mydev">
               <!--
                  transactionManager ：mybatis的事務型別
                      type: JDBC(表示使用jdbc中的Connection物件的commit，rollback做事務處理)
               -->
               <transactionManager type="JDBC"/>
               <!--
                  dataSource:表示資料來源，連線資料庫的
                     type：表示資料來源的型別， POOLED表示使用連線池
               -->
               <dataSource type="POOLED">
                   <!--
                      driver, user, username, password 是固定的，不能自定義。
                   -->
                   <!--資料庫的驅動類名-->
                   <property name="driver" value="com.mysql.jdbc.Driver"/>
                   <!--連線資料庫的url字串-->
                   <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                   <!--訪問資料庫的使用者名稱-->
                   <property name="username" value="root"/>
                   <!--密碼-->
                   <property name="password" value="123456"/>
               </dataSource>
           </environment>
   
   
           <!--表示線上的資料庫，是專案真實使用的庫-->
           <environment id="online">
               <transactionManager type="JDBC"/>
               <dataSource type="POOLED">
                   <property name="driver" value="com.mysql.jdbc.Driver"/>
                   <property name="url" value="jdbc:mysql://localhost:3306/onlinedb"/>
                   <property name="username" value="root"/>
                   <property name="password" value="fhwertwr"/>
               </dataSource>
           </environment>
       </environments>
   
       <!-- sql mapper(sql對映檔案)的位置-->
       <mappers>
           <!--一個mapper標籤指定一個檔案的位置。
              從類路徑開始的路徑資訊。  target/clasess(類路徑)
           -->
           <mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
           <!--<mapper resource="com/bjpowernode/dao/SchoolDao.xml" />-->
       </mappers>
   </configuration>
   <!--
      mybatis的主配置檔案： 主要定義了資料庫的配置資訊， sql對映檔案的位置
   
      1. 約束檔案
      <!DOCTYPE configuration
           PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-config.dtd">
   
       mybatis-3-config.dtd：約束檔案的名稱
   
     2. configuration 根標籤。
   -->
   

7. 建立使用mybatis類

   通過mybatis訪問資料庫

   public class MyApp {
   
       public static void main(String[] args) throws IOException {
           //訪問mybatis讀取student資料
           //1.定義mybatis主配置檔案的名稱, 從類路徑的根開始（target/clasess）
           String config="mybatis.xml";
           //2.讀取這個config表示的檔案
           InputStream in = Resources.getResourceAsStream(config);
           //3.建立了SqlSessionFactoryBuilder物件
           SqlSessionFactoryBuilder builder  = new SqlSessionFactoryBuilder();
           //4.建立SqlSessionFactory物件
           SqlSessionFactory factory = builder.build(in);
           //5.獲取SqlSession物件，從SqlSessionFactory中獲取SqlSession
           SqlSession sqlSession = factory.openSession();
           //6.【重要】指定要執行的sql語句的標識。  sql對映檔案中的namespace + "." + 標籤的id值
           //String sqlId = "com.bjpowernode.dao.StudentDao" + "." + "selectStudents";
           String sqlId = "com.bjpowernode.dao.StudentDao.selectStudents";
           //7. 重要】執行sql語句，通過sqlId找到語句
           List<Student> studentList = sqlSession.selectList(sqlId);
           //8.輸出結果
           //studentList.forEach( stu -> System.out.println(stu));
           for(Student stu : studentList){
               System.out.println("查詢的學生="+stu);
           }
           //9.關閉SqlSession物件
           sqlSession.close();
   
       }
   
   }
   

   注意：支援中文的URL；

jdbc:mysql://localhost:3306/springdb?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8

mybatis的使用步驟

1. 建立student表
2. 加入Maven的mybatis和MySQL依賴
3. 建立實體類
4. 建立持久層dao介面，定義操作資料庫的方法
5. 建立一個mybatis使用的配置檔案（SQL對映檔案）
6. 建立mybatis的主配置檔案
7. 建立使用mybatis使用類，通過mybatis訪問資料庫

mybatis訪問資料庫主要類的介紹：

1. Resources： mybatis中的一個類， 負責讀取主配置檔案
   InputStream in = Resources.getResourceAsStream(“mybatis.xml”);

2. SqlSessionFactoryBuilder:建立SqlSessionFactory物件，

   SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();

   建立SqlSessionFactory物件

   SqlSessionFactory factory = builder.build(in);

3. SqlSessionFactory ： 重量級物件， 程式建立一個物件耗時比較長，使用資源比較多。 在整個專案中，有一個就夠用了。

 SqlSessionFactory:介面  ， 介面實現類： DefaultSqlSessionFactory
  SqlSessionFactory作用： 獲取SqlSession物件。
  SqlSession sqlSession = factory.openSession();

  openSession()方法說明：
   1. openSession() ：無引數的， 獲取是非自動提交事務的SqlSession物件
   2. openSession(boolean): 
			openSession(true)  獲取自動提交事務的SqlSession. 
	         openSession(false)  非自動提交事務的SqlSession物件

4.SqlSession:
SqlSession介面 ：定義了操作資料的方法 例如 selectOne() ,selectList() ,insert(),update(), delete(), commit(), rollback()
SqlSession介面的實現類DefaultSqlSession。

使用要求： SqlSession物件不是執行緒安全的，需要在方法內部使用， 在執行sql語句之前，使用openSession()獲取SqlSession物件。
在執行完sql語句後，需要關閉它，執行SqlSession.close(). 這樣能保證他的使用是執行緒安全的。

MybatisUntils

public class MyBatisUtils {

    private  static  SqlSessionFactory factory = null;
    static {
        String config="mybatis.xml"; // 需要和你的專案中的檔名一樣
        try {
            InputStream in = Resources.getResourceAsStream(config);
            //建立SqlSessionFactory物件，使用SqlSessionFactoryBuild
            factory = new SqlSessionFactoryBuilder().build(in);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    //獲取SqlSession的方法
    public static SqlSession getSqlSession() {
        SqlSession sqlSession  = null;
        if( factory != null){
            sqlSession = factory.openSession();// 非自動提交事務
        }
        return sqlSession;
    }
}

有了Mybatis工具類，那麼mybatis訪問資料庫的操作就簡單了

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

    //獲取SqlSession物件，從SqlSessionFactory中獲取SqlSession
    SqlSession sqlSession = MyBatisUtils.getSqlSession();
    //【重要】指定要執行的sql語句的標識。  sql對映檔案中的namespace + "." + 標籤的id值
    String sqlId = "com.bjpowernode.dao.StudentDao.selectStudents";
    //【重要】執行sql語句，通過sqlId找到語句
    List<Student> studentList = sqlSession.selectList(sqlId);
    //輸出結果
    studentList.forEach( stu -> System.out.println(stu));
    //關閉SqlSession物件
    sqlSession.close();

}

在IDEA中建立mybatis模板

mybatis-mapper

<?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="">
	<select id="" resultType="">
		
	</select>
	

</mapper>

mybatis-config

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--settings：控制mybatis全域性行為-->
    <settings>
        <!--設定mybatis輸出日誌-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <environments default="mydev">
        <environment id="mydev">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--資料庫的驅動類名-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <!--連線資料庫的url字串-->
                <property name="url" value="jdbc:mysql://localhost:3306/springdb"/>
                <!--訪問資料庫的使用者名稱-->
                <property name="username" value="root"/>
                <!--密碼-->
                <property name="password" value="123456"/>
            </dataSource>
        </environment>

    </environments>

    <!-- sql mapper(sql對映檔案)的位置-->
    <mappers>
        <mapper resource="com/jfd/dao/StudentDao.xml"/>
        <!--<mapper resource="com/jfd/dao/SchoolDao.xml" />-->
    </mappers>
</configuration>

使用動態代理的條件分析

1. dao物件，型別是StudentDao,全限定名稱是：com.fudao.dao.StudentDao全限定名稱 和 namespace 是一樣的。

2. 方法名稱，selectStudents,這個方法就是mapper 檔案中的id值 selectStudents

3. 通過dao中方法的返回值也可以確定mybatis要呼叫的SqlSession方法

   如果返回值是List，呼叫的是SqlSession.selectList()方法

   如果返回值int ,或是非List的，看mapper檔案中的 標籤,就會呼叫SqlSession的insert，update等方法

mybatis的動態代理

mybatis根據dao的方法呼叫，獲取執行SQL語句的資訊。

mybatis根據你的dao介面，創建出一個dao介面的實現類， 並建立這個類的物件。 完成SqlSession呼叫方法， 訪問資料庫。

動態代理的使用例子

使用mybatis的動態代理機制，使用SqlSession.getMapper(dao介面)

getMapper能獲取dao介面對應的實現類物件

SqlSession sqlSession = MyBatisUtils.getSqlSession();
StudentDao dao = sqlSession.getMapper(StudentDao.class);

測試類

public class TestMyBatis {

    @Test
    public void testSelectStudents(){
        /**
         * 使用mybatis的動態代理機制， 使用SqlSession.getMapper(dao介面)
         * getMapper能獲取dao介面對於的實現類物件。
         */
        SqlSession sqlSession = MyBatisUtils.getSqlSession();
        StudentDao dao  =  sqlSession.getMapper(StudentDao.class);

        //com.sun.proxy.$Proxy2 : jdk的動態代理
        System.out.println("dao="+dao.getClass().getName());
        //呼叫dao的方法， 執行資料庫的操作
        List<Student> students = dao.selectStudents();
        for(Student stu: students){
            System.out.println("學生="+stu);
        }
    }

    @Test
    public void testInsertStudent(){
        SqlSession sqlSession  = MyBatisUtils.getSqlSession();
        StudentDao dao  =  sqlSession.getMapper(StudentDao.class);

        Student student = new Student();
        student.setId(1007);
        student.setName("李飛");
        student.setEmail("[email protected]");
        student.setAge(28);
        int nums = dao.insertStudent(student);
        sqlSession.commit();
        System.out.println("新增物件的數量："+nums);
    }

}

mybatis預設支援的別名

​

使用mbatis實現動態代理

什麼是動態代理？

mybatis幫你建立dao介面的實現類，在實現類中呼叫SqlSession的方法執行sql語句

使用動態代理：

1. 獲取SqlSession物件，SqlSessionFactory.openSession()
2. 使用getMapper方法獲取某個介面的物件，sqlSession.getMapper(介面.class)
3. 使用dao介面的方法，呼叫方法就執行了mapper檔案中的sql語句

使用動態代理的要求：

1. dao介面和mapper 放在一起，同一個目錄
2. dao介面和mapper檔名稱一致
3. mapper檔案中的namespace的值是dao介面中的全限定名稱
4. mapper檔案中的,,,等 id是介面中的方法名稱
5. dao介面中不要使用過載方法，不要使用同名的，不同引數的方法

理解引數

1. 從java程式碼中將實際的值傳入到mapper 檔案中
   1. 一個簡單型別的引數：#{任意字元}
   2. 多個簡單型別的引數：使用@Param{“自定義名稱”}
   3. 使用一個java物件，物件的屬性值作為mapper檔案中找到引數，#{java物件的屬性名稱}
   4. 使用引數的位置，語法#{arg0},#{arg1},mybatis3.4之前的版本，使用#{0}，#{1}
   5. 使用map作為引數，#{map的key}

# 和 $ 的區別

1. #是佔位符，表示列值的，放在等號右側
2. $佔位符，表示字串的連線，把sql語句連線成一個字串
3. #佔位符使用的JDBC指定PrepareStatement物件執行Sql語句，效率高，沒有SQL注入的風險
4. $使用的是Statement物件執行SQL，效率會低一點

mybatis的輸出結果

mybatis執行了sql語句，得到了java物件

1. resultType結果型別，指SQL語句執行完畢後，資料轉為的java物件，java型別是任意的。
2. resultType結果型別的值
   1. 型別的全限定名稱
   2. 型別的別名，例如java.lang.integer別名是int

處理方式：

1. mybatis執行sql語句，然後mybatis呼叫類的無引數構造方法，建立物件
2. mybatis把ResultSet指定列值付給同名的屬性

<select id="selectMultiPosition" resultType="com.bjpowernode.domain.Student">
          		select id,name, email,age from student
 </select>

對等的jdbc
		  ResultSet rs = executeQuery(" select id,name, email,age from student" )
		  while(rs.next()){
               Student  student = new Student();
					student.setId(rs.getInt("id"));
					student.setName(rs.getString("name"))
		  }

定義自定義型別的別名

1. 在mybatis的主配置檔案中定義，使用定義別名
2. 可以在resultType中定義別名

<!--定義別名-->
<typeAliases>
    <!--
        第一種方式：
        可以指定一個型別一個自定義別名
        type:自定義型別的全限定名稱
        alias:別名（短小，容易記憶的）
    -->
    <!--<typeAlias type="com.bjpowernode.domain.Student" alias="stu" />
    <typeAlias type="com.bjpowernode.vo.ViewStudent" alias="vstu" />-->

    <!--
      第二種方式
      <package> name是包名， 這個包中的所有類，類名就是別名（類名不區分大小寫）
    -->
    <package name="com.bjpowernode.domain"/>
    <package name="com.bjpowernode.vo"/>
</typeAliases>

注意：不建議使用別名的方式，建議使用全限定名稱

查詢返回Map集合

定義返回的Map集合建議鍵值對均採用Object

Map<Object,Object> selectStudents(integer id );

resultMap:

結果對映，指定列名和java物件的屬性對應關係

1. 你自定義列值賦值給哪個屬性

2. 當你的列名和屬性名不一樣時，一定要使用resultMap

   resultMap和resultType不要一起用，二選一

resultMap的使用方式：

1. 在mapper檔案中配置標籤
2. id:自定義名稱，表示你定義的這個resultMap
3. type:java型別的全限定名稱

<!--使用resultMap
    1)先定義resultMap
    2)在select標籤，使用resultMap來引用1定義的。
-->

<!--定義resultMap
    id:自定義名稱，表示你定義的這個resultMap
    type：java型別的全限定名稱
-->
<resultMap id="studentMap" type="com.bjpowernode.domain.Student">
    <!--列名和java屬性的關係-->
    <!--註解列，使用id標籤
        column :列名
        property:java型別的屬性名
    -->
    <id column="id" property="id" />
    <!--非主鍵列，使用result-->
    <result column="name" property="name" />
    <result column="email" property="email" />
    <result column="age" property="age" />

</resultMap>

動態SQL

動態sql: sql的內容是變化的，可以根據條件獲取到不同的sql語句。
主要是where部分發生變化。

動態sql的實現，使用的是mybatis提供的標籤， ,,

1)是判斷條件的，
語法
部分sql語句

2) 用來包含 多個的， 當多個if有一個成立的， 會自動增加一個where關鍵字，
並去掉 if中多餘的 and ，or等。

3） 迴圈java中的陣列，list集合的。 主要用在sql的in語句中。
學生id是 1001,1002,1003的三個學生

 select * from student where id in (1001,1002,1003)

 public List<Student> selectFor(List<Integer> idlist)

 List<Integer> list = new ...
 list.add(1001);
 list.add(1002);
 list.add(1003);

 dao.selectFor(list)

 <foreach collection="" item="" open="" close="" separator="">
         #{xxx}
</foreach>

collection:表示介面中的方法引數的型別， 如果是陣列使用array , 如果是list集合使用list
 item:自定義的，表示陣列和集合成員的變數
 open:迴圈開始是的字元
 close:迴圈結束時的字元
separator:集合成員之間的分隔符

4）sql程式碼片段， 就是複用一些語法
步驟
1.先定義 sql語句， 表名，欄位等
2.再使用，

定義sql片段事項sql語句的複用

<!--定義sql片段-->
<sql id="studentSql">
    select id,name, age, email from student
</sql>

<sql id="studentSqlOne">
     id,name, age, email
</sql>

where 和 if 的聯合使用

<!--
 where: <where> <if> <if>...</where>
 <if:test="使用引數java物件的屬性值作為判斷條件，語法 屬性=XXX值">
-->
<select id="selectStudentWhere" resultType="com.bjpowernode.domain.Student">
    <include refid="studentSql" />
    <where>
        <if test="name !=null and name !='' ">
            name = #{name}
        </if>
        <if test="age > 0">
            or age > #{age}
        </if>
    </where>
</select>

<!--foreach使用1 ， List<Integer>-->
<select id="selectForeachOne" resultType="com.bjpowernode.domain.Student">
    select * from student where id in
    <foreach collection="list" item="myid" open="(" close=")" separator=",">
              #{myid}
    </foreach>

</select>

配置檔案的補充說明mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--指定properties檔案的位置，從類路徑根開始找檔案-->
    <properties resource="jdbc.properties" />

    <!--settings：控制mybatis全域性行為-->
    <settings>
        <!--設定mybatis輸出日誌-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <!--定義別名-->
    <typeAliases>
        <!--
            第一種方式：
            可以指定一個型別一個自定義別名
            type:自定義型別的全限定名稱
            alias:別名（短小，容易記憶的）
        -->
        <!--<typeAlias type="com.bjpowernode.domain.Student" alias="stu" />
        <typeAlias type="com.bjpowernode.vo.ViewStudent" alias="vstu" />-->

        <!--
          第二種方式
          <package> name是包名， 這個包中的所有類，類名就是別名（類名不區分大小寫）
        -->
        <package name="com.bjpowernode.domain"/>
        <package name="com.bjpowernode.vo"/>
    </typeAliases>

    <!--配置外掛-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor" />
    </plugins>

    <environments default="mydev">
        <environment id="mydev">
            <!--
              transactionManager:mybatis提交事務，回顧事務的方式
                 type: 事務的處理的型別
                     1）JDBC : 表示mybatis底層是呼叫JDBC中的Connection物件的，commit， rollback
                     2）MANAGED : 把mybatis的事務處理委託給其它的容器（一個伺服器軟體，一個框架（spring））
            -->
            <transactionManager type="JDBC"/>
            <!--
               dataSource:表示資料來源，java體系中，規定實現了javax.sql.DataSource介面的都是資料來源。
                          資料來源表示Connection物件的。

               type:指定資料來源的型別
                  1）POOLED: 使用連線池， mybatis會建立PooledDataSource類
                  2）UPOOLED: 不使用連線池， 在每次執行sql語句，先建立連線，執行sql，在關閉連線
                              mybatis會建立一個UnPooledDataSource，管理Connection物件的使用
                  3）JNDI：java命名和目錄服務（windows登錄檔）
            -->
            <dataSource type="POOLED">
                <!--資料庫的驅動類名-->
                <property name="driver" value="${jdbc.driver}"/>
                <!--連線資料庫的url字串-->
                <property name="url" value="${jdbc.url}"/>
                <!--訪問資料庫的使用者名稱-->
                <property name="username" value="${jdbc.user}"/>
                <!--密碼-->
                <property name="password" value="${jdbc.passwd}"/>
            </dataSource>
        </environment>
    </environments>

    <!-- sql mapper(sql對映檔案)的位置-->
    <mappers>
        <!--第一種方式：指定多個mapper檔案-->
        <!--<mapper resource="com/bjpowernode/dao/StudentDao.xml"/>
        <mapper resource="com/bjpowernode/dao/OrderDao.xml" />-->

        <!--第二種方式： 使用包名
            name: xml檔案（mapper檔案）所在的包名, 這個包中所有xml檔案一次都能載入給mybatis
            使用package的要求：
             1. mapper檔名稱需要和介面名稱一樣， 區分大小寫的一樣
             2. mapper檔案和dao介面需要在同一目錄
        -->
        <package name="com.bjpowernode.dao"/>
       <!-- <package name="com.bjpowernode.dao2"/>
        <package name="com.bjpowernode.dao3"/>-->
    </mappers>
</configuration>

配置檔案properties

1. 資料庫的屬性配置檔案： 把資料庫連線資訊放到一個單獨的檔案中。 和mybatis主配置檔案分開。
   目的是便於修改，儲存，處理多個數據庫的資訊。

   1）在resources目錄中定義一個屬性配置檔案， xxxx.properties ,例如 jdbc.properties
   在屬性配置檔案中， 定義資料，格式是 key=value
   key： 一般使用 . 做多級目錄的。
   例如 jdbc.mysql.driver , jdbc.driver, mydriver
   jdbc.driver=com.mysql.jdbc.Driver
   jdbc.url=jdbc:mysql//…
   jdbc.username=root
   jdbc.password=123456

   2）在mybatis的主配置檔案，使用 指定檔案的位置
   在需要使用值的地方， ${key}

2.mapper檔案，使用package指定路徑

   <mappers>
   <!--第二種方式： 使用包名
        name: xml檔案（mapper檔案）所在的包名, 這個包中所有xml檔案一次都能載入給mybatis
        使用package的要求：
         1. mapper檔名稱需要和介面名稱一樣， 區分大小寫的一樣
         2. mapper檔案和dao介面需要在同一目錄
    -->
    <package name="com.bjpowernode.dao"/>
</mappers>

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.user=root
jdbc.passwd=123456