mybatis入門案例自定義實現

一、需要實現的類和介面

public static void main(String[] args) throws Exception{
    //1.讀取配置檔案
    InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
    //2.建立SqlSessionFactory工廠
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    SqlSessionFactory factory = builder.build(in);
    //3.使用工廠生產SqlSession物件
    SqlSession session = factory.openSession();
    //4.使用SqlSession建立Dao的代理物件
    IUserDao userDao = session.getMapper(IUserDao.class);
    //5.使用代理物件執行方法
    List<User> users = userDao.findAll();
    for(User user : users) {
        System.out.println(user);
    }
    //6.釋放資源
    session.close();
    in.close();
}
 

根據測試類MybatisTest中的main函式，需要實現的類有：Resources、SqlSessionFactoryBuilder，需要實現的介面有：SqlSessionFactory、SqlSession。由於是自定義mybatis，我們將專案配置檔案pom.xml中的mybatis的相關資訊刪除。

二、依據測試類建立缺少的介面和類

1.建立Resources類

在src/main/java目錄下，建立mybatis包，在mybatis包下建立io包，在io包下新建類Resources，新增靜態方法

//使用類載入器讀取配置檔案的類
public class Resources {

    /**
     * @description 根據傳入的引數獲取一個位元組輸入流
     * @param filePath
     * @return
     */

    public static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
    }

}
 

之所以這樣子新增，我們可以檢視原mybatis中，getResourcesAsStream()方法的呼叫層級，可以發現最終呼叫的就是ClassLoader類下的getResourceAsStream()方法，因此我們直接呼叫該方法即可。

//MybatisTest.class
 InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

//Resources.class
 public static InputStream getResourceAsStream(String resource) throws IOException {
       return getResourceAsStream((ClassLoader)null, resource);
 }

public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
        InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
        if (in == null) {
            throw new IOException("Could not find resource " + resource);
        } else {
            return in;
        }
 }

//ClassLoaderWrapper.class
 public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
        return this.getResourceAsStream(resource, this.getClassLoaders(classLoader));
 }

 InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
        ClassLoader[] var3 = classLoader;
        int var4 = classLoader.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            ClassLoader cl = var3[var5];
            if (null != cl) {
                InputStream returnValue = cl.getResourceAsStream(resource);
                if (null == returnValue) {
                    returnValue = cl.getResourceAsStream("/" + resource);
                }

                if (null != returnValue) {
                    return returnValue;
                }
            }
        }

        return null;
  }

//ClassLoader.class
 public InputStream getResourceAsStream(String name) {
        Objects.requireNonNull(name);
        URL url = getResource(name);
        try {
            return url != null ? url.openStream() : null;
        } catch (IOException e) {
            return null;
        }
  }
 

2.建立SqlSessionFactorty介面

在mybatis包下新建包sqlsession，在sqlsession包下新建介面SqlSessionFactorty，依據main()方法，該介面中需要宣告方法openSession()。

public interface SqlSessionFactory {

    //用於開啟一個新的SqlSession物件
    SqlSession openSession();
}

3.建立SqlSession介面

在sqlsession包下新建介面SqlSessionFactorty，依據main()方法，該介面中需要宣告方法getMapper()和close()。

//自定義mybatis中和資料庫互動的核心類，可以建立dao介面的代理物件
public interface SqlSession {

    /**
     * @description 根據引數建立一個代理物件
     * @param daoInterfaceClass dao的介面位元組碼
     * @param <T>
     * @return
     */
    <T> T getMapper(Class<T> daoInterfaceClass);
        
    //釋放資源
    void close();
}

至於getMapper的宣告為什麼是這樣子，可以檢視我的上一篇部落格：mybatis入門案例分析

4.建立SqlSessionFactoryBuilder類

在sqlsession包下建立SqlSessionFactoryBuilder類，新增一個build()方法，先返回空值，之後我們再來補全。

/* 用於建立一個SqlSessionFactory物件 */
public class SqlSessionFactoryBuilder {

    /**
     * @Description: 根據位元組輸入流來構建一個SqlSessionFactory工廠
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
        return null;
    }
}

在原mybatis中，build()方法呼叫層級為：

//MybatisTest.class
SqlSessionFactory factory = builder.build(in);

//SqlSessionFactoryBuilder.class
 public SqlSessionFactory build(InputStream inputStream) {
        return this.build((InputStream)inputStream, (String)null, (Properties)null);
 }

 public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();

            try {
                inputStream.close();
            } catch (IOException var13) {
            }

        }

        return var5;
 }

  public SqlSessionFactory build(Configuration config) {
        return new DefaultSqlSessionFactory(config);
  }

可以看到最後返回的是一個DefualtSqlSessionFactory物件，所以在自定義mybatis時，我們也需要返回一個DefuaultSqlSessionFactory物件。而且還用到了xml檔案解析類XMLConfigBuilder，因此接下來我們需要定義xml解析類和DefuaultSqlSessionFactory類。

5.建立xml解析類XMLConfigBuilder

解析xml檔案，我們採用的是dom4j技術，在查詢資訊時，用到了XPath。所以我們需要在專案檔案pom.xml中新增上相關內容，匯入jaxen是為了能夠使用XPath:

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.1</version>
</dependency>
<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.1.6</version>
</dependency>

在mybatis包下新建包utils，在utils包下新建類XMLConfigBuilder。解析xml不是本文重點，所以解析類的程式碼在這裡直接給出：

/**
 *  用於解析配置檔案
 */
public class XMLConfigBuilder {

    /**
     * 解析主配置檔案，把裡面的內容填充到DefaultSqlSession所需要的地方
     * 使用的技術：dom4j+xpath
     */
    public static Configuration loadConfiguration(InputStream config){
        try{
            //定義封裝連線資訊的配置物件（mybatis的配置物件）
            Configuration cfg = new Configuration();

            //1.獲取SAXReader物件
            SAXReader reader = new SAXReader();
            //2.根據位元組輸入流獲取Document物件
            Document document = reader.read(config);
            //3.獲取根節點
            Element root = document.getRootElement();
            //4.使用xpath中選擇指定節點的方式，獲取所有property節點
            List<Element> propertyElements = root.selectNodes("//property");
            //5.遍歷節點
            for(Element propertyElement : propertyElements){
                //判斷節點是連線資料庫的哪部分資訊
                //取出name屬性的值
                String name = propertyElement.attributeValue("name");
                if("driver".equals(name)){
                    //表示驅動
                    //獲取property標籤value屬性的值
                    String driver = propertyElement.attributeValue("value");
                    cfg.setDriver(driver);
                }
                if("url".equals(name)){
                    //表示連線字串
                    //獲取property標籤value屬性的值
                    String url = propertyElement.attributeValue("value");
                    cfg.setUrl(url);
                }
                if("username".equals(name)){
                    //表示使用者名稱
                    //獲取property標籤value屬性的值
                    String username = propertyElement.attributeValue("value");
                    cfg.setUsername(username);
                }
                if("password".equals(name)){
                    //表示密碼
                    //獲取property標籤value屬性的值
                    String password = propertyElement.attributeValue("value");
                    cfg.setPassword(password);
                }
            }
            //取出mappers中的所有mapper標籤，判斷他們使用了resource還是class屬性
            List<Element> mapperElements = root.selectNodes("//mappers/mapper");
            //遍歷集合
            for(Element mapperElement : mapperElements){
                //判斷mapperElement使用的是哪個屬性
                Attribute attribute = mapperElement.attribute("resource");
                if(attribute != null){
                    System.out.println("使用的是XML");
                    //表示有resource屬性，用的是XML
                    //取出屬性的值
                    String mapperPath = attribute.getValue();//獲取屬性的值"dao/IUserDao.xml"
                    //把對映配置檔案的內容獲取出來，封裝成一個map
                    Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
                    //給configuration中的mappers賦值
                    cfg.setMappers(mappers);
                }
            }
            //返回Configuration
            return cfg;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            try {
                config.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }

    /**
     * 根據傳入的引數，解析XML，並且封裝到Map中
     * @param mapperPath    對映配置檔案的位置
     * @return  map中包含了獲取的唯一標識（key是由dao的全限定類名和方法名組成）
     *          以及執行所需的必要資訊（value是一個Mapper物件，裡面存放的是執行的SQL語句和要封裝的實體類全限定類名）
     */
    private static Map<String,Mapper> loadMapperConfiguration(String mapperPath)throws IOException {
        InputStream in = null;
        try{
            //定義返回值物件
            Map<String,Mapper> mappers = new HashMap<String,Mapper>();
            //1.根據路徑獲取位元組輸入流
            in = Resources.getResourceAsStream(mapperPath);
            //2.根據位元組輸入流獲取Document物件
            SAXReader reader = new SAXReader();
            Document document = reader.read(in);
            //3.獲取根節點
            Element root = document.getRootElement();
            //4.獲取根節點的namespace屬性取值
            String namespace = root.attributeValue("namespace");//是組成map中key的部分
            //5.獲取所有的select節點
            List<Element> selectElements = root.selectNodes("//select");
            //6.遍歷select節點集合
            for(Element selectElement : selectElements){
                //取出id屬性的值      組成map中key的部分
                String id = selectElement.attributeValue("id");
                //取出resultType屬性的值  組成map中value的部分
                String resultType = selectElement.attributeValue("resultType");
                //取出文字內容            組成map中value的部分
                String queryString = selectElement.getText();
                //建立Key
                String key = namespace+"."+id;
                //建立Value
                Mapper mapper = new Mapper();
                mapper.setQueryString(queryString);
                mapper.setResultType(resultType);
                //把key和value存入mappers中
                mappers.put(key,mapper);
            }
            return mappers;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            in.close();
        }
    }

}

6.建立配置類Configuration

解析xml檔案啊返回的包含有資料庫的連線資訊、SQL語句和查詢結果的封裝資訊。在mybatis包下建立包config，在config包下新建類Configuration。結合我們之前的入門案例分析，這個類中的屬性應該包括：driver，url，username，password，對映資訊mappers。

/* 自定義mybatis的配置類 */
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.putAll(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;
    }
}

注意：對映資訊我們是存放在一個HashMap中，這樣可以更加方便地通過完整的id找到SQL語句和查詢結果的封裝資訊。因此接下來我們要定義一個Mapper類，並且setMapper()方法實際上是一個新增新元素並且去重的方法，所以我們不是直接賦值，而是呼叫putAll()方法。

7.建立Mapper類

結合我們對入門案例的分析，我們知道Mapper類中應該有兩大屬性，一個是queryString，即我們要執行的SQL語句；另一個是resultType，即封裝查詢資訊的類。在config包下新建類Mapper，如下：

/*用於封裝執行的SQL語句和結果型別的全限定類名*/
public class Mapper {

    private String queryString;
    private String resultType;

    public String getQueryString() {
        return queryString;
    }

    public void setQueryString(String queryString) {
        this.queryString = queryString;
    }

    public String getResultType() {
        return resultType;
    }

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

8.建立SqlSessionFactory介面的實現類DefualtSqlSessionFactory

在mybatis包下新建包defualts，在defualts包下建立類DefualtSqlSessionFactory，openSession()方法返回的是一個操作資料庫的物件，要想操作資料庫，我們需要提供資料庫的連線資訊，因此需要新增Configuration型別的欄位。

public class DefualtSqlSessionFactory implements SqlSessionFactory {
    private Configuration cfg;
    public  DefualtSqlSessionFactory(Configuration cfg){
        this.cfg = cfg;
    }
    /* 用於建立一個新的操作資料庫物件*/
    @Override
    public SqlSession openSession() {
        return new DefualtSqlSession(cfg);
    }
}

9.建立SqlSession介面的實現類DefualtSqlSession

在defualts包下建立類DefualtSqlSession。在該類中，我們同樣需要配置資訊，因此需要新增Configuration型別的欄位。為了連線資料庫，我們需要新增Connection型別的欄位。結合上篇文章的分析，在建立代理物件時，我們需要指定代理方式。接下來我們要實現的就是連線資料庫的類DataSourceUtil和呼叫selectList()方法的InvocationHandler介面的實現類。

public class DefualtSqlSession implements SqlSession {

    private Configuration cfg;
    private Connection connection;

    public DefualtSqlSession(Configuration cfg){
        this.cfg = cfg;
        connection = DataSourceUtil.getConnection(cfg);
    }

    /* 用於建立代理物件*/
    @Override
    public <T> T getMapper(Class<T> daoInterfaceClass) {
       return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
                new Class[]{daoInterfaceClass}, new MapperProxy(cfg.getMappers(), connection));
    }

    /*Description: 用於釋放資源*/
    @Override
    public void close(){
        if(connection != null){
            try {
                connection.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

10.建立連線資料庫的類DataSourceUtil

在utils包下新建類DataSourceUtil：

 /* 建立資料來源的工具類 */
public class DataSourceUtil {
    /* 用於獲取一個連線 */
    public static Connection getConnection(Configuration cfg){
        try {
            Class.forName(cfg.getDriver());
            return DriverManager.getConnection(cfg.getUrl(),cfg.getUsername(),cfg.getPassword());
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

11.建立InvocationHandler介面的實現類MapperProxy

在mybatis包下新建包proxy，在proxy包下新建類MapperProxy，該類中要對資料庫進行查詢，所以需要對映資訊和資料庫連線。在執行查詢操作時，我們呼叫了Executor().selectList(mapper,conn)靜態方法，所以接下來我們要定義工具類Executor。

public class MapperProxy implements InvocationHandler {

    private Map<String, Mapper> mappers;
    private Connection conn;

    public MapperProxy(Map<String,Mapper> mappers, Connection conn){
        this.mappers = mappers;
        this.conn = conn;
    }
    /* 用於對方法進行增強的，其實就是呼叫selectList方法 */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.獲取方法名
        String methodName = method.getName();
        //2.獲取方法所在類的名稱
        String className = method.getDeclaringClass().getName();
        //3.組合key
        String key = className+"."+methodName;
        //4.獲取mappers中的Mapper物件
        Mapper mapper = mappers.get(key);
        //5.判斷是否有mapper
        if(mapper == null){
            throw new IllegalArgumentException("傳入的引數有誤");
        }
        //6.呼叫工具類執行查詢所有
        return new Executor().selectList(mapper,conn);
    }
}

12.建立查詢工具類Executor

在utils包下，新建類Executor：

 /* 執行查詢封裝的工具類 */
public class Executor {
    public <E> List<E> selectList(Mapper mapper, Connection conn) {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        try {
            //1.取出mapper中的資料
            String queryString = mapper.getQueryString();//select * from user
            String resultType = mapper.getResultType();//domain.User
            Class domainClass = Class.forName(resultType);
            //2.獲取PreparedStatement物件
            pstm = conn.prepareStatement(queryString);
            //3.執行SQL語句，獲取結果集
            rs = pstm.executeQuery();
            //4.封裝結果集
            List<E> list = new ArrayList<E>();//定義返回值
            while(rs.next()) {
                //例項化要封裝的實體類物件
                E obj = (E)domainClass.getDeclaredConstructor().newInstance();
                //取出結果集的元資訊：ResultSetMetaData
                ResultSetMetaData rsmd = rs.getMetaData();
                //取出總列數
                int columnCount = rsmd.getColumnCount();
                //遍歷總列數
                for (int i = 1; i <= columnCount; i++) {
                    //獲取每列的名稱，列名的序號是從1開始的
                    String columnName = rsmd.getColumnName(i);
                    //根據得到列名，獲取每列的值
                    Object columnValue = rs.getObject(columnName);
                    //給obj賦值：使用Java內省機制（藉助PropertyDescriptor實現屬性的封裝）
                    PropertyDescriptor pd = new PropertyDescriptor(columnName,domainClass);//要求：實體類的屬性和資料庫表的列名保持一種
                    //獲取它的寫入方法
                    Method writeMethod = pd.getWriteMethod();
                    //把獲取的列的值，給物件賦值
                    writeMethod.invoke(obj,columnValue);
                }
                //把賦好值的物件加入到集合中
                list.add(obj);
            }
            return list;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            release(pstm,rs);
        }
    }

    private void release(PreparedStatement pstm,ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }

        if(pstm != null){
            try {
                pstm.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

13.補全SqlSessionFactoryBuilder類的build方法

build()方法是根據位元組輸入流來構建一個SqlSessionFactory工廠，因此首先要對xml檔案進行解析，讀取配置檔案，然後返回一個DefualtSqlSessionFactory類的例項。

public SqlSessionFactory build(InputStream config){
    Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
    return new DefualtSqlSessionFactory(cfg);
}

三、專案結果和執行結果

到這裡，我們就完成了自定義mybatis的通過xml檔案進行配置的實現，之後我們還可以新增提供註解進行配置的實現，專案結構如下；

最後執行測試類的結果為：

四、添加註解的實現

1.修改主配置檔案SqlMapConfig

將mapper標籤修改為；

<mappers>
    <mapper class="dao.IUserDao" />
</mappers>

2.添加註解類

在mybatis包下新建包annocations，在annocations包下新建註解Select，如下：

/* 查詢的註解 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Select {

    //配置SQL語句
    String value();
}

3.在dao介面中添加註解

public interface IUserDao {
    @Select("select * from user")
    List<User> findAll();
}

4.在xml解析類中新增對註解的解析

1.新增通過註解建立對映的函式loadMapperAnnotation()

注意在dao介面中添加註解時，我們並沒有新增resultType，因此這裡我們獲取resultType時運用了反射技術，findAll()方法的返回值是一個List，我們只需找到這個List當中元素的型別即為resultType。

/**
 * 根據傳入的引數，得到dao中所有被select註解標註的方法。
 * 根據方法名稱和類名，以及方法上註解value屬性的值，組成Mapper的必要資訊
 * @param daoClassPath
 * @return
 */
private static Map<String,Mapper> loadMapperAnnotation(String daoClassPath)throws Exception{
    //定義返回值物件
    Map<String,Mapper> mappers = new HashMap<String, Mapper>();

    //1.得到dao介面的位元組碼物件
    Class daoClass = Class.forName(daoClassPath);
    //2.得到dao介面中的方法陣列
    Method[] methods = daoClass.getMethods();
    //3.遍歷Method陣列
    for(Method method : methods){
        //取出每一個方法，判斷是否有select註解
        boolean isAnnotated = method.isAnnotationPresent(Select.class);
        if(isAnnotated){
            //建立Mapper物件
            Mapper mapper = new Mapper();
            //取出註解的value屬性值
            Select selectAnno = method.getAnnotation(Select.class);
            String queryString = selectAnno.value();
            mapper.setQueryString(queryString);
            //獲取當前方法的返回值，還要求必須帶有泛型資訊
            Type type = method.getGenericReturnType();//List<User>
            //判斷type是不是引數化的型別
            if(type instanceof ParameterizedType){
                //強轉
                ParameterizedType ptype = (ParameterizedType)type;
                //得到引數化型別中的實際型別引數
                Type[] types = ptype.getActualTypeArguments();
                //取出第一個
                Class domainClass = (Class)types[0];
                //獲取domainClass的類名
                String resultType = domainClass.getName();
                //給Mapper賦值
                mapper.setResultType(resultType);
            }
            //組裝key的資訊
            //獲取方法的名稱
            String methodName = method.getName();
            String className = method.getDeclaringClass().getName();
            String key = className+"."+methodName;
            //給map賦值
            mappers.put(key,mapper);
        }
    }
    return mappers;
}

2.修改loadConfiguration()方法

註解和xml檔案進行配置呼叫的方法是不一樣的，這裡我們取出mapper標籤，判斷mapperElement使用的是哪個屬性。將第二個迴圈體修改為：

//取出mappers中的所有mapper標籤，判斷他們使用了resource還是class屬性
List<Element> mapperElements = root.selectNodes("//mappers/mapper");
//遍歷集合
for(Element mapperElement : mapperElements){
    //判斷mapperElement使用的是哪個屬性
    Attribute attribute = mapperElement.attribute("resource");
    if(attribute != null){
        System.out.println("使用的是XML");
        //表示有resource屬性，用的是XML
        //取出屬性的值
        String mapperPath = attribute.getValue();//獲取屬性的值"com/whu/cs/dao/IUserDao.xml"
        //把對映配置檔案的內容獲取出來，封裝成一個map
        Map<String,Mapper> mappers = loadMapperConfiguration(mapperPath);
        //給configuration中的mappers賦值
        cfg.setMappers(mappers);
    }else{
        System.out.println("使用的是註解");
        //表示沒有resource屬性，用的是註解
        //獲取class屬性的值
        String daoClassPath = mapperElement.attributeValue("class");
        //根據daoClassPath獲取封裝的必要資訊
        Map<String,Mapper> mappers = loadMapperAnnotation(daoClassPath);
        //給configuration中的mappers賦值
        cfg.setMappers(mappers);
    }
}

5.執行結果

部落格連結：

mybatis入門案例

mybatis入門案例分