1.對原生態jdbc程序中問題總結

1.1 jdbc程序

需求：使用jdbc查詢mysql數據庫中用戶表的記錄java

statement:向數據庫中發送一個sql語句mysql

預編譯statement：好處：提升數據庫性能。git

　　　預編譯statement向數據庫中發送一個sql語句，數據庫編譯sql語句，並把編譯的結果保存在數據庫磚的緩存中。下次再發sql時，若是sql相同，則不會再編譯，直接使用緩存中的。程序員

jdbc編程步驟：github

1. 加載數據庫驅動spring

2. 建立並獲取數據庫連接sql

3. 建立jdbc statement對象數據庫

4. 設置sql語句apache

5. 設置sql語句中的參數(使用preparedStatement)編程

6. 經過statement執行sql並獲取結果

7. 對sql執行結果進行解析處理

8. 釋放資源(resultSet、preparedstatement、connection)

public class JDBCTest {
    public static void main(String[] args) {
        Connection connection = null;
        // 預編譯的Statement，使用預編譯的Statement提升數據庫性能
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            // 加載數據庫驅動
            Class.forName("com.mysql.jdbc.Driver");
            // 經過驅動管理類獲取數據庫連接
            connection = DriverManager.getConnection(
                            "jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8",
                            "root", "root");
            // 定義sql語句 ?表示佔位符
            String sql = "select * from t_user where username = ?";
            //獲取預處理statement
            preparedStatement = connection.prepareStatement(sql);
            // 設置參數，第一個參數爲sql語句中參數的序號（從1開始），第二個參數爲設置的參數值
            preparedStatement.setString(1, "王五");
            // 向數據庫發出sql執行查詢，查詢出結果集
            resultSet = preparedStatement.executeQuery();
            // 遍歷查詢結果集
            while (resultSet.next()) {
                System.out.println(resultSet.getString("id") + "  "+ resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //釋放資源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.2 問題總結

上面代碼的問題總結：

1. 數據庫鏈接，使用時就建立，不使用當即釋放，對數據庫進行頻繁鏈接開啓和關閉，形成數據庫資源浪費，影響數據庫性能。

解決方案：使用數據庫鏈接池管理數據庫鏈接。

2. 將sql語句硬編碼到Java代碼中，若是sql語句修。改，須要從新編譯java代碼，不利於系統維護。

解決方案：將sql語句配置在xml配置文件中，即便sql變化，不須要對java代碼進行從新編譯。

3. 向preparedStatement中設置參數，對佔位符位置和設置參數值，硬編碼在Java代碼中，不利於系統維護。

解決方案：將sql語句及佔位符和參數所有配置在xml中。

4. 從resultSet中遍歷結果集數據時，存在硬編碼，將獲取表的字段進行硬編碼，不利於系統維護。

解決方案：將查詢的結果集，自動映射成Java對象。

2.MyBatis框架

2.1MyBatis是什麼？

MyBatis 本是apache的一個開源項目iBatis, 2010年這個項目由apache software foundation 遷移到了google code，而且更名爲MyBatis，實質上Mybatis對ibatis進行一些改進。

MyBatis是一個優秀的持久層框架，它對jdbc的操做數據庫的過程進行封裝，使開發者只須要關注 SQL 自己，而不須要花費精力去處理例如註冊驅動、建立connection、建立statement、手動設置參數、結果集檢索等jdbc繁雜的過程代碼。

Mybatis經過xml或註解的方式將要執行的各類statement（statement、preparedStatemnt、CallableStatement）配置起來，並經過java對象和statement中的sql進行映射生成最終執行的sql語句，最後由mybatis框架執行sql並將結果映射成java對象並返回。

2.2MyBatis框架

1. mybatis配置

SqlMapConfig.xml，此文件做爲mybatis的全局配置文件，配置了mybatis的運行環境等信息。

mapper.xml文件即sql映射文件，文件中配置了操做數據庫的sql語句。此文件須要在SqlMapConfig.xml中加載。

2. 經過mybatis環境等配置信息構造SqlSessionFactory即會話工廠

3. 由會話工廠建立sqlSession即會話，操做數據庫須要經過sqlSession進行。

4. mybatis底層自定義了Executor執行器接口操做數據庫，Executor接口有兩個實現，一個是基本執行器、一個是緩存執行器。

5. Mapped Statement也是mybatis一個底層封裝對象，它包裝了mybatis配置信息及sql映射信息等。mapper.xml文件中一個sql對應一個Mapped Statement對象，sql的id便是Mapped statement的id。

6. Mapped Statement對sql執行輸入參數進行定義，包括HashMap、基本類型、pojo，Executor經過Mapped Statement在執行sql前將輸入的java對象映射至sql中，輸入參數映射就是jdbc編程中對preparedStatement設置參數。

7. Mapped Statement對sql執行輸出結果進行定義，包括HashMap、基本類型、pojo，Executor經過Mapped Statement在執行sql後將輸出結果映射至java對象中，輸出結果映射過程至關於jdbc編程中對結果的解析處理過程。

3.入門程序

3.1 需求

根據用戶id（主鍵）查詢用戶信息

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

添加用戶

刪除用戶

更新用戶

3.2 所需jar包

MyBatis下載地址：https://github.com/mybatis/mybatis-3/releases

mybatis-3.4.4.jar ：核心包

mysql-connector-java-5.1.jar：mysql的驅動包

3.3 工程結構

3.4 log4j.properties

# Global logging configuration
#在開發的環境下，日誌級別要設置成DEBUG，生產環境設置成info或error
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

3.5 SqlMapConfig.xml

MyBatis核心配置文件，配置MyBatis的運行環境，數據源、事務等。

<?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>
    <!-- 和spring整合後 environments配置將廢除-->
    <environments default="development">
        <environment id="development">
        <!-- 使用jdbc事務管理,事務控制由mybatis管理-->
            <transactionManager type="JDBC" />
        <!-- 數據庫鏈接池,由mybatis管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
<!-- 加載映射文件 -->
    <mappers>
        <mapper resource="sqlmap/User.xml"/>
    </mappers>
</configuration>

3.6 根據用戶id（主鍵）查詢用戶信息

3.6.1建立po類

package joanna.yan.mybatis.entity;

import java.sql.Date;

public class User {
    //屬性名稱和數據庫字段名稱保持一致
    private int id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    
    public User(String username, Date birthday, String sex, String address) {
        super();
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }
    public User(int id, String username, Date birthday, String sex,
            String address) {
        super();
        this.id = id;
        this.username = username;
        this.birthday = birthday;
        this.sex = sex;
        this.address = address;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", address=" + address + ", birthday=" + birthday + "]";
    }
}

3.6.2映射文件

映射文件命名：

User.xml（原始的ibatis的命名方式），mapper代理開發映射文件名稱叫XXXMapper.xml,好比：UserMapper.xml、ItemsMapper.xml。

在映射文件中配置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">
<!--namespace命名空間，做用就是對sql進行分類化的管理，理解爲sql隔離
    注意：使用mapper代理開發時，namespace有特殊做用  -->
<mapper namespace="test">
    <!--在映射文件中配置不少sql語句  -->
    <!--需求：經過id查詢用戶表的記錄  -->
    <!--id：標識映射文件中的sql，稱爲statement的id。將sql語句封裝在mapperStatement的對象中，全部id稱爲Statement的id；
        parameterType：指定輸入參數的類型，這裏指定int型；
        #{}:表示一個佔位符；
        #{id}:其中id表示接收輸入的參數，參數名稱就是id，若是輸入參數是簡單類型，#{}中的參數名能夠任意，能夠是value或其它名稱；
        resultType：指定輸出結果所映射的Java對象類型，select指定resultType表示將單條記錄映射成Java對象。
      -->
    <select id="findUserById" parameterType="java.lang.Integer" resultType="joanna.yan.mybatis.entity.User">
        select * from user where id=#{id}
    </select>
</mapper>

3.6.3在SqlMapConfig.xml中加載映射文件

<!-- 加載映射文件  -->
<mappers>
    <mapper resource="sqlmap/User.xml"/>
</mappers>

3.6.4程序編寫

public class MybatisFirst {
    
    @Test
    public void findUserByIdTest(){
        //mybatis的配置文件
        String resource="SqlMapConfig.xml";
        InputStream inputStream=null;
        SqlSession sqlSession=null;
        try {
            inputStream=Resources.getResourceAsStream(resource);
            //1.建立會話工廠，傳入mybatis的配置文件信息
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
            //2.經過工廠獲得SqlSession
            sqlSession=factory.openSession();
            //3.經過SqlSession操做數據庫
            //參數一：映射文件中的statement的id，等於namespace+"."+statement的id；
            //參數二：指定和映射文件中所匹配的parameterType類型的參數；
            //sqlSession.selectOne結果是與映射文件所匹配的resultType類型的對象；
            //selectOne：查詢一條結果
            User user=sqlSession.selectOne("test.findUserById", 1);
            System.out.println(user.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }        
    }
}

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

3.7.1映射文件

使用User.xml，添加根據用戶名稱模糊查詢用戶信息的sql語句。

　　<!--   
    需求：根據用戶名稱模糊查詢用戶信息，可能返回多條數據 
    resultType：指定的就是單條記錄所映射的Java類型；
        ${}：表示拼接sql字符串，將接收到的參數內容不加任何修飾的拼接在sql中。使用${}拼接sql，可能會引發sql注入；
        ${value}：接收輸入參數的內容，若是傳入的是簡單類型，${}中只能使用value
      -->
    <select id="findUserByName" parameterType="java.lang.String" resultType="joanna.yan.mybatis.entity.User">
        select * from user where username LIKE '%${value}%'
    </select>

3.7.2程序編寫

　　@Test
    public void findUserByNameTest(){
        //mybatis的配置文件
        String resource="SqlMapConfig.xml";
        InputStream inputStream=null;
        SqlSession sqlSession=null;
        try {
            inputStream=Resources.getResourceAsStream(resource);
            //1.建立會話工廠，傳入mybatis的配置文件信息
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
            //2.經過工廠獲得SqlSession
            sqlSession=factory.openSession();
            //3.經過SqlSession操做數據庫
            //參數一：映射文件中的statement的id，等於namespace+"."+statement的id；
            //參數二：指定和映射文件中所匹配的parameterType類型的參數；
            //sqlSession.selectOne結果是與映射文件所匹配的resultType類型的對象；
            //list中的user和resultType類型一致
            List<User> list=sqlSession.selectList("test.findUserByName", "小明");
            System.out.println(list);
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }        
    }

3.8添加用戶

3.8.1映射文件

在User.xml配置添加用戶的statement（多個sql）。

<!-- 
    需求：添加用戶 
    parameterType:指定輸入的參數類型是pojo（包括用戶信息）；
    #{}：中指定pojo的屬性名稱，接收到pojo對象的屬性值，mybatis經過ONGL（相似於struts2的OGNL）獲取對象的屬性值
      -->
    <insert id="insertUser" parameterType="joanna.yan.mybatis.entity.User">
        insert into user (username,sex,address,birthday) values (#{username},#{sex},#{address},#{birthday})
    </insert>

3.8.2程序編寫

@Test
    public void insertUserTest(){
        //mybatis的配置文件
        String resource="SqlMapConfig.xml";
        InputStream inputStream=null;
        SqlSession sqlSession=null;
        try {
            inputStream=Resources.getResourceAsStream(resource);
            //1.建立會話工廠，傳入mybatis的配置文件信息
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
            //2.經過工廠獲得SqlSession
            sqlSession=factory.openSession();
            User user=new User("yan",new Date(System.currentTimeMillis()),"女", "上海");
            //3.經過SqlSession操做數據庫
            //參數一：映射文件中的statement的id，等於namespace+"."+statement的id；
            //參數二：指定和映射文件中所匹配的parameterType類型的參數；
            sqlSession.insert("test.insertUser",user);
            //提交事務
            sqlSession.commit();
            System.out.println(user.getId());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }        
    }

3.8.3自增主鍵返回

mysql自增主鍵：執行insert提交以前自動生成一個自增主鍵。

經過Mysql函數獲取到剛插入記錄的自增主鍵：LAST_INSERT_ID()

是insert以後調用此函數。

修改insertUser定義：

<!-- 
    需求：添加用戶 
    parameterType:指定輸入的參數類型是pojo（包括用戶信息）；
    #{}：中指定pojo的屬性名稱，接收到pojo對象的屬性值，mybatis經過ONGL（相似於struts2的OGNL）獲取對象的屬性值
      -->
    <insert id="insertUser" parameterType="joanna.yan.mybatis.entity.User">
        <!-- 將insert插入的數據的主鍵返回到User對象中；
            select last_insert_id()：獲得剛inser進去記錄的主鍵值，只適用於自增主鍵；
            keyProperty：將查詢到的主鍵值，設置到parameterType指定的對象的那個屬性；
            order：select last_insert_id()的執行順序，相對於insert語句來講它的執行順序；
            resultType：指定select last_insert_id()的結果類型；
          -->
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            select last_insert_id()
        </selectKey>
        insert into user (username,sex,address,birthday) values (#{username},#{sex},#{address},#{birthday})
    </insert>

3.8.4非自增主鍵返回（使用uuid()）

使用mysql的uuid()函數生成主鍵，須要修改表中id字段類型爲String，長度設置爲35位。

執行思路：

先經過uuid()查詢到主鍵，將主鍵輸入到sql語句中。

執行uuid()語句順序相對於insert語句以前執行。

<!-- 
    需求：添加用戶 
    parameterType:指定輸入的參數類型是pojo（包括用戶信息）；
    #{}：中指定pojo的屬性名稱，接收到pojo對象的屬性值，mybatis經過ONGL（相似於struts2的OGNL）獲取對象的屬性值
      -->
    <insert id="insertUser" parameterType="joanna.yan.mybatis.entity.User"><!-- 
        
            使用mysql的uuid(),實現非自增主鍵的返回；
            執行過程：經過uuid()獲得主鍵，將主鍵設置到user對象的id的屬性中，其次，在inser執行時，從user對象中取出id屬性值； 
        -->
            <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
                select uuid()
            </selectKey>
            insert into user (id,username,sex,address,birthday) values (#{id},#{username},#{sex},#{address},#{birthday})      
    </insert>

經過oracle的序列生成主鍵：

<selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
            SELECT 序列名.nextval()
        </selectKey>
        insert into user(id,username,birthday,sex,address) value(#{id},#{username},#{birthday},#{sex},#{address})

3.9刪除用戶和更新用戶

3.9.1映射文件

<!-- 需求：刪除用戶  -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>
    <!-- 需求：更新用戶 注意：id必須存在 -->
    <update id="updateUser" parameterType="joanna.yan.mybatis.entity.User">
        update user set username=#{username},sex=#{sex},address=#{address},birthday=#{birthday} where id=#{id}
    </update>

3.9.2程序編寫

@Test
    public void deleteUserTest(){
        //mybatis的配置文件
        String resource="SqlMapConfig.xml";
        InputStream inputStream=null;
        SqlSession sqlSession=null;
        try {
            inputStream=Resources.getResourceAsStream(resource);
            //1.建立會話工廠，傳入mybatis的配置文件信息
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
            //2.經過工廠獲得SqlSession
            sqlSession=factory.openSession();
            //3.經過SqlSession操做數據庫
            //參數一：映射文件中的statement的id，等於namespace+"."+statement的id；
            //參數二：指定和映射文件中所匹配的parameterType類型的參數；
            sqlSession.delete("test.deleteUser",3);
            //提交事務
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    @Test
    public void updateUserTest(){
        //mybatis的配置文件
        String resource="SqlMapConfig.xml";
        InputStream inputStream=null;
        SqlSession sqlSession=null;
        try {
            inputStream=Resources.getResourceAsStream(resource);
            //1.建立會話工廠，傳入mybatis的配置文件信息
            SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(inputStream);
            //2.經過工廠獲得SqlSession
            sqlSession=factory.openSession();
            User user=new User(2,"yan",new Date(System.currentTimeMillis()), "女", "上海");
            //3.經過SqlSession操做數據庫
            //參數一：映射文件中的statement的id，等於namespace+"."+statement的id；
            //參數二：指定和映射文件中所匹配的parameterType類型的參數；
            //根據id更新用戶
            sqlSession.update("test.updateUser",user);
            //提交事務
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3.10 總結

3.10.1 parameterType

在映射文件中經過parameterType指定輸入參數的類型。

3.10.2 resultType

在映射文件中經過resultType指定輸出結果的類型

3.10.3 #{}和${}

#{}表示一個佔位符，#{}接收輸入參數。#{}能夠有效防止sql注入。類型能夠是簡單類型，pojo、hashmap。若是接收簡單類型，#{}中能夠寫成value或其它名稱。

#{}接收pojo對象值，經過OGNL讀取對象中的屬性值，經過屬性.屬性.屬性...的方式獲取對象屬性值。

${}表示一個拼接符號，拼接sql串，會引發sql注入存在安全隱患，因此不建議使用${}。${}接收輸入參數，類型能夠是簡單類型，pojo、hashmap。若是接收簡單類型，${}中只能寫成value。

${}接收pojo對象值，經過OGNL讀取對象中的屬性值，經過屬性.屬性.屬性...的方式獲取對象屬性值。

3.10.4 selectOne和selectList

selectOne查詢一條記錄，若是使用selectOne查詢多條記錄則拋出異常：

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

at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

selectList能夠查詢一條或多條記錄。

3.11 MyBatis和Hibernate本質區別和應用場景

hibernate：是一個標準ORM框架（對象關係映射）。入門門檻較高，不須要程序員寫sql，sql語句自動生成了。對sql語句進行優化、修改比較困難。

應用場景：

　　使用於須要變化很少的中小型項目，好比：後臺管理系統，erp、orm、oa。。。

mybatis:專一是sql自己，須要程序員編寫sql語句，sql修改、優化比較方便。mybatis是一個不徹底的ORM框架，雖然程序員本身寫sql，mybatis也能夠實現映射（輸入映射、輸出映射）。