mybatis入門教程(一)

時間  2021-02-01
標籤 java mysql sql 數據庫 apache 編程 設計模式 服務器 session mybatis 欄目 MyBatis 简体版
原文   原文鏈接

第一章 框架概述

1.1 什麼是框架

1.1.1 序言

框架（Framework）是整個或部分系統的可重用設計，表現爲一組抽象構件及構件實例間交互的方法；另外一種定義認爲，框架是可被應用開發者定製的應用骨架。前者是從應用方面然後者是從目的方面給出的定義。

​ 簡而言之，框架其實就是某種應用的半成品，就是一組組件，供你選用完成你本身的系統，或者說是使用別人搭好的舞臺，你來作表演。框架通常是成熟的，不斷升級的軟件。java

1.1.2 框架要解決的問題

​ 框架要解決的最重要的一個問題是技術整合的問題，在JavaEE的 框架中，有着各類各樣的技術，不一樣的軟件企業須要從JavaEE中選擇不一樣的技術，這就使得軟件企業最終的應用依賴於這些技術，技術自身的複雜性和技術的風險性將會直接對應用形成衝擊。而應用是軟件企業的核心，是競爭力的關鍵所在，所以應該將應用自身的設計和具體的實現技術解耦。這樣，軟件企業的研發將集中在應用的設計上，而不是具體的技術實現，技術實現是應用的底層支撐，它不該該直接對應用產生影響。mysql

1.1.3 軟件開發的分層重要性

​ 框架的重要性在於它實現了部分功能，而且可以很好的將低層應用平臺和高層業務邏輯進行了緩和。爲了實現軟件工程中的「高內聚、低耦合」。把問題劃分開來各個解決，易於控制，易於延展，易於分配資源。咱們常見的MVC軟件設計思想就是很好的分層思想。sql

image-20210117142846811

​ 經過分層更好的實現了各個部分的職責，在每一層將再細化出不一樣的框架，分別解決各層關注的問題。數據庫

1.1.4 分層開發下的常見框架

1.1.4.1 解決數據持久化問題的框架

Mybatisapache

​ MyBatis 本是apache的一個開源項目iBatis, 2010年這個項目由apache software foundation 遷移到了google code，而且更名爲MyBatis 。2013年11月遷移到Github。編程

​ 做爲持久層的框架，還有一個封裝程度更高的框架就是Hibernate，但這個框架由於各類緣由目前在國內的流行程度降低太多，如今公司開發也愈來愈少使用。目前Mybatis框架是主流，將來使用Spring Data來實現數據持久化也是一種趨勢。設計模式

1.1.4.2 解決數據持久化問題的框架

SpringMVC服務器

​ Spring MVC屬於SpringFrameWork的後續產品，已經融合在Spring Web Flow裏面。Spring 框架提供了構建 Web 應用程序的全功能 MVC 模塊。使用 Spring 可插入的 MVC 架構，從而在使用Spring進行WEB開發時，能夠選擇使用Spring的SpringMVC框架或集成其餘MVC開發框架，如Struts1(如今通常不用)，Struts2(通常老項目使用)等。session

1.1.4.3 解決技術整合問題的框架

​ Spring框架是因爲軟件開發的複雜性而建立的。Spring使用的是基本的JavaBean來完成之前只可能由EJB完成的事情。然而，Spring的用途不只僅限於服務器端的開發。從簡單性、可測試性和鬆耦合性角度而言，絕大部分Java應用均可以從Spring中受益。mybatis

  • 目的：解決企業應用開發的複雜性

  • 功能：使用基本的JavaBean代替EJB，並提供了更多的企業應用功能

  • 範圍：任何Java應用

    Spring是一個輕量級控制反轉(IoC)和麪向切面(AOP)的容器框架。

1.1.5 Mybatis框架概述

​ Mybatis是一個優秀的基於Java的持久層框架，它內部封裝了Jdbc，使開發者只須要關注sql語句自己，而不須要花費精力去處理加載驅動、建立鏈接、建立statement等繁雜的過程。

​ Mybatis經過xml或註解的方式將要執行的各類statement配置起來，並經過java對象和statement中sql的動態參數進行映射生成最終執行的sql語句，最後由Mybatis框架執行sql並將結果映射爲java對象並返回。

​ 採用ORM思想解決了實體和數據庫映射的問題，對Jdbc進行了封裝，屏蔽了Jdbc Api底層訪問細節，使咱們不用與Jdbc Api打交道，就能夠完成對數據庫的持久化操做。

​ 爲了咱們可以更好掌握框架運行的內部過程，而且有更好的體驗，下面咱們將從自定義Mybatis框架開始來學習框架。此時咱們將會體驗框架從無到有的過程體驗，也可以很好的綜合前面階段所學的基礎。

1.2 JDBC編程的分析

1.2.1 建立數據庫並初始化測試數據

一、建立數據庫，數據庫名 : mybatis

二、將以下Sql語句在數據庫中執行，初始化測試數據

-- ----------------------------
-- Table structure for `user`
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(32) NOT NULL COMMENT '用戶名稱',
`sex` char(1) DEFAULT NULL COMMENT '性別',
  `birthday` date DEFAULT NULL COMMENT '生日',
  `address` varchar(256) DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', '張三', '1', '2018-07-10', '北京');
INSERT INTO `user` VALUES ('2', '李四', '1', '2018-07-10', '上海');
INSERT INTO `user` VALUES ('3', '王五', '1', '2018-07-10', '廣州');
INSERT INTO `user` VALUES ('4', '王六', '1', '2018-07-10', '深圳');

1.2.2 JDBC程序回顧

public static void main(String[] args) {
        Connection connection = null;
        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 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) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

上邊使用JDBC的原始方法（未經封裝）實現了查詢數據庫表記錄的操做。

1.2.3 JDBC問題分析

  • 數據庫連接建立、釋放頻繁形成系統資源浪費從而影響系統性能，若是使用數據庫連接池可解決此問題。

  • Sql語句在代碼中硬編碼，形成代碼不易維護，實際應用sql變化的可能較大，sql變更須要改變Java代碼。

  • 使用preparedStatement向佔有位符號傳參數存在硬編碼，由於sql語句的where條件不必定，可能多也可能少，修改sql還要修改代碼，系統不易維護。

  • 對結果集解析存在硬編碼（查詢列名），sql變化致使解析代碼變化，系統不易維護，若是能將數據庫記錄封裝成pojo對象解析比較方便。

下面咱們將經過本身定義編寫一個持久層框架的方式來解決Jdbc編程存在的部分問題。

第二章 自定義Mybatis框架

2.1 自定義Mybatis框架的前期準備

​ 本章咱們將使用前面所學的基礎知識來構建一個屬於本身的持久層框架，將會涉及到的一些知識點：工廠模式（Factory工廠模式）、構建者模式（Builder模式）、反射、Xml解析，數據庫元數據等。

2.1.1 工廠模式

​ 工廠模式是咱們最經常使用的實例化對象模式了，是用工廠方法代替new操做的一種模式。著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統能夠說是隨處可見。由於工廠模式就至關於建立實例對象的new，咱們常常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來建立實例對象的，因此之後new時就要多個心眼，是否能夠考慮使用工廠模式，雖然這樣作，可能多作一些工做，但會給你係統帶來更大的可擴展性和儘可能少的修改量。

image-20210117162526430

2.1.2 構建者模式

構建者模式，又稱建造者模式，將一部負責對象的構建分爲許多小對象的構建，最後在整合構建的模式。

image.png

成員分析：

  • Director：控制者類，這是控制整個組合過程，在這個類內部有個Construct()方法，這個方法的做用就是經過調用Builder內部的各個組件的生成方法來完成組裝；

  • Builder：構建者接口，定義各部件生成的方法；

  • ConcreteBuilder：具體構建者類：實現Builder構建者接口，具體定義如何生成各個部件；依賴於Product成品類，其中還有獲取成品組裝結構的方法GetResult()方法；

  • Product：成品類

2.2 建立Maven工程並引入相關座標

2.2.1 開發環境的準備及統一

  • JDK環境 ： JDK 1.8 64bit
  • Maven環境 ： Maven 3.5.2

2.2.2 建立Maven工程並引入座標

  1. 在Idea中建立Maven工程，名字爲customMybatis

    image.png

  2. 在pom.xml中引入所需座標

    <dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

2.3 自定義Mybatis框架配置文件結構約定

2.3.1 Sql文件約定

​ 做爲一個框架，一般都會定義本身的配置文件（能夠有多個），用戶只須要按照框架的要求編寫相應的配置文件就能夠了。由於咱們自定義的Mybatis框架是一個持久層框架（操做數據庫的），因此須要配置文件用於存放Sql語句，此類配置文件一般稱爲Sql映射文件。配置文件的名稱能夠任意，可是最好有一個統一的規範，方便見名知意，此處咱們的約定是XXMapper.xml（XX爲該文件所對應的表名，如User表爲UserMapper.xml）。具體格式以下：

<?xml version="1.0" encoding="utf-8" ?>
<mapper namespace="com.hyl.pojo.User">
    <select id="findAllUsers" resultType="com.hyl.pojo.User">
        select * from user
    </select>
</mapper>

2.3.2 框架核心配置文件約定

​ 除了映射文件（存放SQL語句的文件），還須要有一個框架的核心配置文件，主要是存放數據源相關信息的。由於不一樣的用戶使用的數據庫類型不一樣，數據庫名稱不一樣，使用的數據庫用戶和密碼也都不相同，因此這些信息應該是由用戶本身指定。用戶經過這個核心配置文件就能夠指定數據源相關信息了。此處咱們約定配置文件名稱爲SqlMapConfig.xml。具體格式以下：

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"></property>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8"></property>
                <property name="username" value="root"></property>
                <property name="password" value="root"></property>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

2.4 核心組件開發

2.4.1 Mapper開發

​ 經過前面Jdbc存在問題的分析，咱們已經知道了要將SQL語句放入配置文件中，這樣未來修改SQL語句會比較方便，但放在配置文件中的SQL語句還須要讀取出來，這樣咱們就能夠基於面向對象思惟定義一個Mapper類，用於將配置文件中的SQL語句保存起來，使用時更方便。定義以下：

package frame.pojo;
public class Mapper {
    private String sql;
    private String resultType;

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }
}

2.4.2 Configuration開發

​ 咱們以面向對象思惟操做自定義框架的核心配置文件時，須要有一個實體類與之對應。Configuration 配置類主要用於保存SqlMapConfig.xml文件中讀取的xml結點的信息，以及映射的SQL語句的集合。定義以下：

package frame.pojo;
import java.util.HashMap;
import java.util.Map;

public class Configuration {
    private String driver;
    private String url;
    private String username;
    private String password;
    private Map<String,Mapper> mappers = new HashMap<>();

    public Map<String, Mapper> getMappers() {
  return mappers;
    }

    public void setMappers(Map<String, Mapper> mappers) {
        this.mappers = mappers;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.4.3 SqlSession開發

​ 咱們開發的是框架，所以封裝的對象是不固定的，所以這裏使用泛型 List 。此處僅示例一個查詢所有。 

package frame.core;

import java.util.List;
public interface SqlSession {
    public <T> List<T> selectList(String mapperId) throws Exception;
}

2.4.4 SqlSessionImpl實現類開發

package frame.core;

import frame.core.Executor;
import frame.pojo.Configuration;
import java.util.List;

public class SqlSessionImpl implements SqlSession {

    private Configuration configuration;

    public void setConfiguration(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public <T> List<T> selectList(String mapperId) throws Exception
 {
        List<T> list = new ArrayList<>();

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            Class.forName(configuration.getDriver());
            connection = DriverManager.getConnection(configuration.getUrl(),configuration.getUsername(),configuration.getPassword());
            Mapper mapper = configuration.getMappers().get(mapperId);
            String sql = mapper.getSql();
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();
            String resultType = mapper.getResultType();
            Class clazz = Class.forName(resultType);
            Method[] mehtods = clazz.getMethods();
            List<String> columnNames = new ArrayList<>();
            ResultSetMetaData metaData = resultSet.getMetaData();
            int count = metaData.getColumnCount();
            for(int i = 1; i <= count; i++) {
                columnNames.add(metaData.getColumnLabel(i));
            }
            Object object = null;
            while (resultSet.next()) {
                object = clazz.newInstance();
                for(String columnName : columnNames) {
                    for(Method method: mehtods) {
                        if(method.getName().equalsIgnoreCase("set" + columnName)) {
                            method.invoke(object,resultSet.getObject(columnName));
                        }
                    }
                }
                list.add((T) object);
            }
        } catch (Exception e) {
            throw e;
        } finally {
            if(resultSet != null) {
                resultSet.close();
            }
            if(preparedStatement != null) {
                preparedStatement.close();
            }
            if(connection != null){
                connection.close();
            }
        }
        return list;
    }
}

2.4.5 SqlSessionFactory開發

​ SqlSessionFactory的開發基於工廠模式，工廠模式是咱們最經常使用的用來實例化對象的設計模式，是用工廠方法代替new操做的一種模式。建立對象的時候使用工廠模式會帶來更大的可擴展性和儘可能少的修改量。

package frame.factory;

import frame.core.SqlSession;
import frame.core.SqlSessionImpl;
import frame.pojo.Configuration;
import frame.pojo.Mapper;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

public class SqlSessionFactory {

    public void setInputStream(InputStream inputStream) {
        this.inputStream = inputStream;
    }

    private InputStream inputStream;

    public SqlSession openSession() {
        SqlSessionImpl sqlSession = new SqlSessionImpl();
        Configuration configuration = loadXmlConfig();
        sqlSession.setConfiguration(configuration);
        return sqlSession;
    }

    private Configuration loadXmlConfig() {
        Configuration configuration = new Configuration();
        try {
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(inputStream);
            Element root = document.getRootElement();
            List<Element> list = root.selectNodes("//property");
            for (int i = 0; i < list.size(); i++) {
                Element element =  list.get(i);
                String name = element.attributeValue("name");
                String value = element.attributeValue("value");
                if("driver".equalsIgnoreCase(name)) {
                    configuration.setDriver(value);
                }
                if("url".equalsIgnoreCase(name)){
                    configuration.setUrl(value);
                }
                if("username".equalsIgnoreCase(name)) {
                    configuration.setUsername(value);
                }
                if("password".equalsIgnoreCase(name)) {
                    configuration.setPassword(value);
                }
            }

            List<Element> mappers = root.selectNodes("//mapper");

            for (int i = 0; i < mappers.size(); i++) {
                Element element =  mappers.get(i);
                String mapperPath = element.attributeValue("resource");
                // 讀取mapper文件
                loadXmlMapper(configuration,mapperPath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return configuration;
    }

    private void loadXmlMapper(Configuration configuration,String mapperPath) {
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(this.getClass().getClassLoader().getResourceAsStream(mapperPath));
            Element root = document.getRootElement();
            String namespace = root.attributeValue("namespace");
            List<Element> list = root.selectNodes("//select");
            for (int i = 0; i < list.size(); i++) {
                Element element =  list.get(i);
                String id = element.attributeValue("id");
                String resultType = element.attributeValue("resultType");
                String sql = element.getText();
                Mapper mapper = new Mapper();
                mapper.setResultType(resultType);
                mapper.setSql(sql);
                configuration.getMappers().put(namespace + "." + id,mapper);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}

注：XML 文件解析採用的是Dom4j結合xpath實現。

2.4.6 SqlSessionFactoryBuilder開發

使用構建者模式，應對不一樣的場景變化。

package frame.factory;

import frame.factory.SqlSessionFactory;
import java.io.InputStream;
public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build() {
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactory();
        sqlSessionFactory.setInputStream(inputStream);
        return sqlSessionFactory;
    }

    public SqlSessionFactory build(String filename) {
        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(filename);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactory();
        sqlSessionFactory.setInputStream(inputStream);
        return sqlSessionFactory;
    }

    public SqlSessionFactory build(InputStream inputStream) {
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactory();
        sqlSessionFactory.setInputStream(inputStream);
        return sqlSessionFactory;
    }
}

2.4.7 小結

自定義Mybatis框架架構圖以下：

image.png

2.5 安裝到Maven倉庫

1.通過上面的開發過程，工程的結構以下：

image.png

  1. 使用Idea自帶的打包和安裝功能將當前工程打成Jar包，而後安裝到到本地Maven倉庫，雙擊Install圖標便可：

    image.png

  2. 查看本地Maven倉庫

    image.png

第三章 基本自定義Mybatis框架實現數據庫的操做

3.1

3.1.1 功能需求

​ 基於自定義Mybatis框架和已有的Mysql數據庫，查詢全部用戶信息。

3.1.2 建立工程並引入自定義Mybatis框架的座標

  1. 建立一個Maven工程testCustomMybatis

    image.png

  2. 修改testCustomMybatis工程的pom.xml文件，添加自定義Mybatis框架的Maven座標和Mysql數據庫驅動的座標

    <dependencies>
    <dependency>
        <groupId>com.hyl.mybatis</groupId>
        <artifactId>customMybatis</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

3.1.3 建立Pojo

package com.hyl.mybatis.pojo;

import java.util.Date;

public class User {
    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

3.1.4 建立Sql文件UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>   
<mapper namespace="test">
<!-- select 查詢 -->   
   <select id="queryUserList" resultType="com.hyl.mybatis.pojo.User">
      select *  from user   
   </select>   
</mapper>

3.1.5 建立核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>   
<configuration>   
   <environments default="development">   
      <environment id="development">   
        <transactionManager type="JDBC" />   
        <dataSource type="POOLED">   
          <property name="driver" value="com.mysql.jdbc.Driver" ></property>   
          <property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf8" ></property>
          <property name="username" value="root"></property>
          <property name="password" value="root"></property>
        </dataSource>   
     </environment>   
  </environments>

  <mappers>
    <mapper resource="UserMapper.xml"></mapper>
  </mappers>
</configuration>

3.1.6 測試

  1. 測試程序
@Test
    public void testQueryUserList() throws Exception {
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build("SqlMapConfig.xml");
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> list = sqlSession.selectList("test.queryUserList");

        for (User user : list) {
            System.out.println(user);
        }
    }

​

  1. 測試結果

3.1.7 工程結構

image.png

3.1.8 小結

​ 以上經過自定義Mybatis框架的學習，咱們將前面的基礎知識很好的結合在一塊兒，而且強化了咱們對設計模式的使用。但願你們可以抽時間多練習，這也是系統架構師的必由之路。

第四章 Mybatis框架快速入門

​ 經過前面的學習，咱們已經可以使用所學的基礎知識構建自定義的Mybatis框架了。這個過程是基本功的考驗，咱們已經強大了很多，但現實是殘酷的，咱們所定義的Mybatis框架和真正的Mybatis框架相比，仍是顯得眇小。行業內所流行的Mybatis框架如今咱們將開啓學習。

4.1 官網下載Mybatis框架

  1. 進入官方，https://mybatis.org/mybatis-3/

    image.png

  2. 快速開發，咱們使用3.4.5的版本

    image.png

4.1.2 搭建Mybatis開發環境

4.1.2.1 建立Maven工程

image.png

4.1.2.2 引入Maven

在pom.xml文件中添加座標，以下：

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

4.1.2.3 編寫log4j.properties

​ 在resources下建立log4j.properties，內容以下：

# Global logging configuration
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

​ Mybatis默認使用log4j做爲輸出日誌組件。

4.1.2.4 編寫User實體類

package com.hyl.mybatis.pojo;

import java.util.Date;

public class User {
    private Integer id;
    private String username;
    private String sex;
    private Date birthday;
    private String address;

    public Integer getId() {
        return id;
    }

    public void setId(Integer 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 Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", birthday=" + birthday +
                ", address='" + address + '\'' +
                '}';
    }
}

4.1.2.5 編寫UserMapper.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="test">
    <!-- select 查詢 -->
    <select id="queryUserList" resultType="com.hyl.mybatis.pojo.User">
        select *  from user
    </select>
</mapper>

4.1.2.6 編寫SqlMapConfig.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"></mapper>
    </mappers>
</configuration>

4.1.3 測試

4.1.3.1 測試程序

@Test
    public void testQueryUserList() throws Exception {
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> list = sqlSession.selectList("test.queryUserList");
        for (int i = 0; i < list.size(); i++) {
            User user =  list.get(i);
            System.out.println(user);
        }
    }

4.1.3.2 測試結果

image.png

4.2 小結

​ 經過快速入門示例，咱們發現前面的自定義Mybatis框架和咱們官方的Mybatis框架不少是相同的，經過這個推導過程告訴咱們，只要基礎紮實，咱們徹底能夠運用基礎知識，將一個框架的基本原理掌握好。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程