自定义Mybatis框架

项目结构:

    

https://files-cdn.cnblogs.com/files/mkl7/ownMybatis.zip

1. 创建maven工程并引入坐标:

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mkl</groupId>
    <artifactId>ownMybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
        </dependency>
        <!--dom4j是一个Java的XML API，是jdom的升级品，用来读写XML文件的。-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!--Jaxen是一个Java编写的开源的XPath库。
        这是适应多种不同的对象模型，包括DOM，XOM，dom4j和JDOM。
        也可以作为适配器，转换Java字节代码或XML的Java bean为xml，
        从而使您可以使用XPath查询这些树了。-->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
    </dependencies>

</project>

2. 创建实体类User

package com.mkl.domain;

import java.io.Serializable;
import java.util.Date;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:34
 */

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    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 Date getBirthday () {
        return birthday;
    }

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

    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;
    }

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

3. 编写DAO层接口

package com.mkl.dao;

import com.mkl.domain.User;

import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:12:48
 * 用户的持久层接口
 */

public interface IUserDao {

    /**
     * 查询所有用户
     */
    List<User> findAll();
}

4.编写主配置文件SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
    <environments default="MySql">
        <environment default="MySql">
            <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/mybatisdb" />
                    <property name="username" value="root" />
                    <property name="password" value="root" />
                </dataSource>
            </transactionManager>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/mkl/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

5. 编写映射配置文件, 注意目录  IUserDao.xml

<?xml version="1.0" encoding="utf-8" ?>
<mapper namespace="com.mkl.dao.IUserDao">
    <selsect id="findAll" resultType="com.mkl.domain.User">
        select * from user
    </selsect>
</mapper>

6. 编写映射配置文件对应的实体类

package com.mkl.config;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

public class Mapper {
    private String SQL;  //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;
    }
}

7. 编写主配置文件对应的实体类

package com.mkl.config;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:01
 */

public class Configuration {
    private  String driver;
    private  String url;
    private String username;
    private String password;

    private Map<String,Mapper> mappers=new HashMap<String, Mapper> ();

    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;
    }

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

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

8. 编写Resources用于读取配置文件    使用类加载器读取配置文件的类

　　根据传入的filePath参数,读取文件,获取字节输入流,并返回

package com.mkl.mybatis.io;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:08
 * 使用类加载器读取配置文件的类
 */

public class Resources {

    /**
     * 根据传入的参数,读取文件,获取字节输入流
     * @param filePath
     * @return
     */
    public  static InputStream getResourceAsStream(String filePath){
        return Resources.class.getClassLoader ().getResourceAsStream (filePath);
    }
}

9. 创建与数据库交互的核心接口  :  SqlSession    它里面可以创建DAO接口的代理对象

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 * 自定义Mybatis中与数据库交互的核心类
 * 它里面可以创建DAO接口的代理对象
 */

public interface SqlSession {

    /**
     * 根据参数创建dao接口的代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    <T> T getMapper(Class<T> daoInterfaceClass);

    /**
     * 释放资源
     */
    void close();
}

9.1 编写SqlSession的实现类DefaultSqlSession

　　实现类DefaultSqlSession中的类成员变量:

　　　　private Configuration cfg;

　　　　　　cfg通过构造方法传入

　　　　private Connection connection;

　　　　　　connection通过在构造方法中, 使用创建数据源的工具类来获取一个连接

　　在实现类中获取dao接口的实现类,使用Proxy.newProxyInstance      动态代理

　　其参数:

　　　　类加载器使用和被代理对象相同的类加载器   daoInterfaceClass.getClassLoader()

　　　　代理类的接口列表   字节码数组   new Class[]{daoInterfaceClass}

　　　　InvocationHandler : 用于提供增强的代码   new MapperProxy(cfg.getMappers(),connection)

　　　　　　此处自己编写实现类MapperProxy实现InvocationHandler接口

　　　　　　该实现类就是用于对方法进行增强的，我们的增强其实就是调用Executor执行器的selectList方法

　　　　　　　　 (Executor: 用于实现 SQL 语句的执行，主要是调用 JDBC 来实现 SQL 语句的执行)

　　　　　　在增强(invoke方法)中:

　　　　　　　　需要获取代理类调用的方法名称和方法所在类的全限定类名

　　　　　　　　　　method.getName();

　　　　　　　　　　method.getDeclaringClass().getName();

　　　　　　　　对以上两者进行组合   得到 key

　　　　　    　　　　key =　className+"."+methodName

　　　　　　　　然后从   主配置文件对应的实体类(Configuration)中   存贮的  映射配置文件的实体类的Map(mappers)中

　　　　　　　　　　(该Configuration的一个实例cfg存储在DefaultSqlSession中,为类成员变量, 通过DefaultSqlSession类的构造方法传入,

　　　　　　　　　　cfg.getMappers()作为参数,将获取到的mappers传给MapperProxy的实例)

　　　　　　　　根据key  获取dao层接口的对应的  映射文件的实体类mapper ,      mapper中封装着执行的SQL语句和结果类型的全限定类名

　　　　

　　　　　　　　然后调用工具类执行查询所有    将获取到的mapper和数据库连接conn  做参数传进去   并将结果返回

　　　　　　　　return new Executor().selectList(mapper,conn);

9.1.1编写DefaultSqlSession

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.DataSourceUtil;
import com.mkl.mybatis.proxy.MapperProxy;
import com.mkl.mybatis.sqlsession.SqlSession;

import java.lang.reflect.Proxy;
import java.sql.Connection;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:28
 */

public class DefaultSqlSession implements SqlSession {
    private Configuration cfg;
    private Connection conn;

    public DefaultSqlSession (Configuration cfg) {
        this.cfg =
        conn= DataSourceUtil.getConnection (cfg);
    }

    /**
     * 根据参数创建代理对象
     * @param daoInterfaceClass
     * @param <T>
     * @return
     */
    public <T> T getMapper (Class<T> daoInterfaceClass) {
        return (T)Proxy.newProxyInstance (daoInterfaceClass.getClassLoader (),
                new Class[]{daoInterfaceClass},new MapperProxy (cfg.getMappers (),conn));
    }

    public void close () {
　　　　　if(conn!=null){
　　　　　　try{
　　　　　　　　conn.close();
　　　　　　}catch(Exeception e){
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　　}
}

9.1.2编写MapperProxy

package com.mkl.mybatis.proxy;

import com.mkl.config.Mapper;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.util.Map;
import java.util.concurrent.Executor;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:17
 */

public class MapperProxy implements InvocationHandler {
    private Connection conn;
    private Map<String, Mapper> mappers;

    public MapperProxy (Map<String, Mapper> mappers, Connection conn) {
            this.conn = conn;
            this.mappers = mappers;
    }

    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.通过key获取mappers中的mapper对象
        Mapper mapper = mappers.get (key);
        //5. 判断是否有mapper
        if (mapper==null){
            throw  new IllegalArgumentException ("参数有误,为获取到对应的mapper");
        }
        //6. 调用工具类执行查询所有
        return new Executor ().selectList(mapper,conn);
    }
}

9.1. 3编写用于创建数据源的工具类,用于获取连接

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;

import java.sql.Connection;
import java.sql.DriverManager;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:52
 * 用于创建数据源的工具类
 */

public class DataSourceUtil {

    /**
     * 用于获取一个连接
     * @param config
     * @return
     */
    public static Connection getConnection (Configuration config){
        try {
            Class.forName (config.getDriver ());//加载驱动
            //获取连接并返回
            return DriverManager.getConnection (config.getUrl (),config.getUsername (),config.getPassword ());
        }catch (Exception e){
            throw  new RuntimeException (e);
        }
    }
}

9.1.4 编写Executor  负责执行SQL语句，并且封装结果集

package com.mkl.mybatis.Utils;

import com.mkl.config.Mapper;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:15:28
 */

public class Executor {
    public <E>List<E> selectList(Mapper mapper, Connection conn){
        PreparedStatement pstm=null;
        ResultSet rs=null;
        try {
            //1. 取出mapper中的数据
            String SQL=mapper.getSQL (); //select *from user
            String resultType=mapper.getResultType ();//com.mlk.domain.User
            Class domainClass=Class.forName (resultType);
            //2. 获取PreparedStatement对象
            pstm= conn.prepareStatement (SQL);
            //3. 执行SQL语句 获取结果集
            rs= pstm.executeQuery ();
            //4. 封装结果集
            List<E> list=new ArrayList<E> ();//定义返回值
            while (rs.next ()){
                //实例化要封装的实体类对象
                E obj= (E)domainClass.newInstance ();

                //取出结果集的元信息
                ResultSetMetaData resultSetMetaData= rs.getMetaData ();
                //取出总列数
                int columnCount= resultSetMetaData.getColumnCount ();
                //遍历
                for (int i=1;i<=columnCount;i++) {
                    //获取每列的名称, 列名的序号是从1开始的
                    String columnName=resultSetMetaData.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 ();
            }
        }
    }
}

10. 编写工厂接口:  SqlSessionFactory   创建SqlSession对象

提供返回值SqlSession 的openSession方法

package com.mkl.mybatis.sqlsession;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:17
 */

public interface SqlSessionFactory {

    /**
     * 用于打开一个新的SqlSession对象
     */
    SqlSession openSession();
}

10.1 编写工厂接口 SqlSessionFactory的实现类  DefaultSqlSessionFactory

package com.mkl.mybatis.sqlsession.defaults;

import com.mkl.config.Configuration;
import com.mkl.mybatis.sqlsession.SqlSession;
import com.mkl.mybatis.sqlsession.SqlSessionFactory;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:29
 */

public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

    public DefaultSqlSessionFactory (Configuration configuration) {
        this.configuration = configuration;
    }

    /**
     *  用于打开一个新的SqlSession对象
     * @return
     */
    public SqlSession openSession () {
        return new DefaultSqlSession (configuration);
    }
}

11. 编写SqlSessionFactoryBuilder  用于构建SqlSessionFactory工厂

　　根据传入的字节输入流参数, 读取主配置文件, 并返回主配置文件对应的实体类
　　根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回

package com.mkl.mybatis.sqlsession;

import com.mkl.config.Configuration;
import com.mkl.mybatis.Utils.XMLConfigBuilder;
import com.mkl.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;

import java.io.InputStream;

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:13:16
 * 用于创建一个SqlSessionFactory对象
 */

public class SqlSessionFactoryBuilder {

    /**
     * 根据传入的字节输入流, 读取主配置文件, 并返回主配置文件对应的实体类
     * 根据此主配置文件的实体类, 创建SqlSessionFactory工厂并返回
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
        Configuration configuration= XMLConfigBuilder.loadConfiguration (config);
        return  new DefaultSqlSessionFactory(coniguration);
    }
}

11.1XMLConfigBuilder用于解析配置文件

package com.mkl.mybatis.Utils;

import com.mkl.config.Configuration;
import com.mkl.config.Mapper;
import com.mkl.mybatis.io.Resources;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
 *  用于解析配置文件
 */
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();//获取属性的值"com/itheima/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);
                }
            }
            //返回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.setSQL (queryString);
                mapper.setResultType(resultType);
                //把key和value存入mappers中
                mappers.put(key,mapper);
            }
            return mappers;
        }catch(Exception e){
            throw new RuntimeException(e);
        }finally{
            in.close();
        }
    }

    /**
     * 根据传入的参数，得到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;
    //}

}

12. 编写测试类

package com.mkl.test;

import com.mkl.dao.IUserDao;
import com.mkl.domain.User;
import com.mkl.mybatis.io.Resources;
import com.mkl.mybatis.sqlsession.SqlSession;
import com.mkl.mybatis.sqlsession.SqlSessionFactory;
import com.mkl.mybatis.sqlsession.SqlSessionFactoryBuilder;

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

/**
 * Created by IDEA
 * User:MKL7
 * Date:2019/4/19
 * Time:16:39
 */

public class MybatisTest {
    public static void main (String[] args) {
        //1. 读取配置文件
        InputStream in= Resources.getResourceAsStream ("SqlMapConfig.xml");
        //2. 根据配置文件使用构建者创建SqlSessionFactory
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder=new SqlSessionFactoryBuilder ();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build (in);
        //3. 使用工厂打开一个SqlSession
        SqlSession sqlSession=sqlSessionFactory.openSession ();
        //4. 使用SqlSession获取dao接口的代理对象
        IUserDao userDao=sqlSession.getMapper (IUserDao.class);
        //5. 使用代理对象执行方法
        List<User> users=userDao.findAll ();
        for (User user:users){
            System.out.println (user);
        }
        //6. 释放资源
        sqlSession.close ();
    }
}