<properties>
        <!--dom4j版本-->
        <dom4j.vesrion>1.6.1</dom4j.vesrion>
        <!--dom4j依赖包版本-->
        <jaxen.version>1.1.6</jaxen.version>
        <!--mysql驱动版本-->
        <mysql.version>5.1.30</mysql.version>
        <!--c3p0版本-->
        <c3p0.version>0.9.2.1</c3p0.version>
        <!-- junit版本 -->
        <junit.version>4.12</junit.version>
    </properties>

    <dependencies>
        <!--dom4j依赖-->
        <dependency>
            <groupid>dom4j</groupid>
            <artifactid>dom4j</artifactid>
            <version>${dom4j.vesrion}</version>
        </dependency>
        <dependency>
            <groupid>jaxen</groupid>
            <artifactid>jaxen</artifactid>
            <version>${jaxen.version}</version>
        </dependency>
        <!-- mysql数据库依赖 -->
        <dependency>
            <groupid>mysql</groupid>
            <artifactid>mysql-connector-java</artifactid>
            <version>${mysql.version}</version>
        </dependency>
        <!--c3p0依赖-->
        <dependency>
            <groupid>com.mchange</groupid>
            <artifactid>c3p0</artifactid>
            <version>${c3p0.version}</version>
        </dependency>
        <!-- junit依赖 -->
        <dependency>
            <groupid>junit</groupid>
            <artifactid>junit</artifactid>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>

package com.it.mybatis;

/**
 用来封装映射文件的实体类
 */
public class mapper {

    private string namespace;  //接口类全名
    private string id;   //接口中方法名
    private string resulttype;  //封装的数据类型
    private string sql;   //要执行的sql语句

    @override
    public string tostring() {
        return "mapper{" +
                "namespace='" + namespace + '\'' +
                ", id='" + id + '\'' +
                ", resulttype='" + resulttype + '\'' +
                ", sql='" + sql + '\'' +
                '}';
    }

    public string getnamespace() {
        return namespace;
    }

    public void setnamespace(string namespace) {
        this.namespace = namespace;
    }

    public string getid() {
        return id;
    }

    public void setid(string id) {
        this.id = id;
    }

    public string getresulttype() {
        return resulttype;
    }

    public void setresulttype(string resulttype) {
        this.resulttype = resulttype;
    }

    public string getsql() {
        return sql;
    }

    public void setsql(string sql) {
        this.sql = sql;
    }
}

package com.it.mybatis;

import com.mchange.v2.c3p0.combopooleddatasource;
import org.dom4j.document;
import org.dom4j.documentexception;
import org.dom4j.element;
import org.dom4j.io.saxreader;

import javax.sql.datasource;
import java.beans.propertyvetoexception;
import java.io.inputstream;
import java.util.hashmap;
import java.util.list;
import java.util.map;

/**
 1. 封装sqlmapconfig.xml配置信息
 2. 得到数据源
 3. 加载usermapper.xml配置信息
 */
public class configuration {

    //数据源的四个属性
    private string username;
    private string password;
    private string url;
    private string driver;

    //封装其它的映射文件中属性
    private map<string, mapper> mappers = new hashmap<>();

    private datasource datasource;  //数据源

    //在构造方法中调用
    public configuration() {
        try {
            loadsqlmapconfig();  //加载配置文件
            createdatasource();  //创建数据源
        } catch (exception e) {
            e.printstacktrace();
        }
    }

    /*
        解析sqlmapconfig.xml文件，封装上面的数据源的四个属性
         */
    private void loadsqlmapconfig() throws exception {
        //得到输入流
        inputstream inputstream = configuration.class.getresourceasstream("/sqlmapconfig.xml");
        //得到文档对象
        saxreader saxreader = new saxreader();
        document document = saxreader.read(inputstream);
        //读取property
        list<element> list = document.selectnodes("//property");
        for (element property : list) {
            //读取name属性
            string name = property.attributevalue("name");
            //读取value属性
            string value = property.attributevalue("value");
            //判断是哪个属性
            switch (name) {
                case "username":
                    this.username = value;
                    break;
                case "password":
                    this.password = value;
                    break;
                case "driver":
                    this.driver = value;
                    break;
                case "url":
                    this.url = value;
                    break;
            }
        }
        //读取usermapper.xml文件
        loadmapper(document);
    }

    /**
    解析其它的实体类映射文件
    @param document 上面已经得到的文档对象
     */
    private void loadmapper(document document) throws exception {
        //读取mapper中resource属性
        list<element> list = document.selectnodes("//mapper");
        for (element mapperelement : list) {
            //读取mapper中resource属性
            string resource = mapperelement.attributevalue("resource");
            //再次读取新的xml文件
            inputstream in = configuration.class.getresourceasstream("/" + resource);
            //创建文档对象
            document doc = new saxreader().read(in);
            //得到根元素
            element rootelement = doc.getrootelement();
            string namespace = rootelement.attributevalue("namespace");
            //得到mapper下select元素
            element select = rootelement.element("select");
            //得到id属性
            string id = select.attributevalue("id");
            string resulttype = select.attributevalue("resulttype");
            string sql = select.gettexttrim();
            //创建mapper对象
            mapper mapper = new mapper();
            mapper.setid(id);
            mapper.setnamespace(namespace);
            mapper.setsql(sql);
            mapper.setresulttype(resulttype);
            //键=namespace + "." + "id";
            string key = namespace + "." + id;
            //将创建好的mapper对象加到map集合中
            mappers.put(key,mapper);
        }
    }

    /**
     创建数据源
     */
    private void createdatasource() throws propertyvetoexception {
        //使用c3p0的数据源
        combopooleddatasource ds = new combopooleddatasource();
        //设置数据库访问属性
        ds.setuser(username);
        ds.setpassword(password);
        ds.setjdbcurl(url);
        ds.setdriverclass(driver);
        this.datasource = ds;
    }

    @override
    public string tostring() {
        return "configuration{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", url='" + url + '\'' +
                ", driver='" + driver + '\'' +
                ", mappers=" + mappers +
                ", datasource=" + datasource +
                '}';
    }

    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 string geturl() {
        return url;
    }

    public void seturl(string url) {
        this.url = url;
    }

    public string getdriver() {
        return driver;
    }

    public void setdriver(string driver) {
        this.driver = driver;
    }

    public map<string, mapper> getmappers() {
        return mappers;
    }

    public void setmappers(map<string, mapper> mappers) {
        this.mappers = mappers;
    }

    public datasource getdatasource() {
        return datasource;
    }

    public void setdatasource(datasource datasource) {
        this.datasource = datasource;
    }
}

package com.it.mybatis;

import com.itheima.entity.user;

import javax.sql.datasource;
import java.lang.reflect.field;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
import java.sql.*;
import java.util.arraylist;
import java.util.list;
import java.util.map;

/**
 核心类
 1. 生成了usermapper接口的代理对象，jdk代理。
 2. 访问数据库：jdbc
 3. 封装查询的结果集，使用反射。
 */
public class sqlsession {

    public <t> t getmapper(class<t> clazz) {
        /*
        参数1：类加载器
        参数2：接口数组
        参数3：每个方法调用一次
         */
        return (t) proxy.newproxyinstance(
                sqlsession.class.getclassloader(),
                new class[]{clazz},
                new invocationhandler() {
                    @override
                    public object invoke(object proxy, method method, object[] args) throws throwable {
                       //1. 通过键得到mapper对象
                        //创建configuration对象
                        configuration configuration = new configuration();
                        //得到集合
                        map<string, mapper> mappers = configuration.getmappers();
                        string id = method.getname();  //方法名
                        //getdeclaringclass得到method所在类全名
                        string namespace = method.getdeclaringclass().getname();
                        //如何得到键
                        string key = namespace + "." + id;
                        //通过键得到值
                        mapper mapper = mappers.get(key);

                        //2. 从mapper对象中得到sql语句执行，并且封装成对象返回
                        string sql = mapper.getsql();
                        //resulttype = com.itheima.entity.user
                        string resulttype = mapper.getresulttype();
                        //将字符串转成class
                        class type = class.forname(resulttype);

                        //3.查询数据库，必须要连接对象
                        //连接对象从数据源中得到
                        datasource datasource = configuration.getdatasource();
                        connection connection = datasource.getconnection();

                        //使用jdbc访问数据库得到封装好的结果
                        list list = queryforlist(connection, sql, type);
                        return list;
                    }
                });
    }

    /**
     通过jdbc来访问数据库
     @param connection 连接对象
     @param sql 语句
     @param type 返回类型
     @return
     */
    private list queryforlist(connection connection, string sql, class type) throws exception {
        list users = new arraylist<>();

        //1. 通过connection创建语句对象：preparedstatement
        preparedstatement ps = connection.preparestatement(sql);

        //2. 通过语句对象执行sql语句
        resultset rs = ps.executequery();

        //3. 执行完毕以后得到结果集resultset
        while(rs.next()) {
            //4. 将resultset进行遍历，封装成实体类对象，添加到集合中
            //创建对象
            object user = type.getconstructor().newinstance();
            //得到类中所有的属性
            field[] fields = type.getdeclaredfields();
            for (field field : fields) {
                //得到属性名
                string name = field.getname();
                //得到相应的值
                object value = rs.getobject(name);
                //暴力反射
                field.setaccessible(true);
                //给每个属性赋值
                field.set(user, value);
            }
            users.add(user);
        }

        //5.释放资源
        rs.close();
        ps.close();
        connection.close();

        return users;
    }

}