javaweb-mybatis-46

mybatis

第一个层次入门

概述

什么是 框架
框架，就是一个软件半成品，开发中加上我们实际的需求会形成我们最终的应用。提高开发效率
在实际开发中，三层架构和框架，所处的位置关系。


持久层的框。用于和数据库库行交互。
spring框架稍后再说，springmvc表现层
解决持久层的技术
JDBC技术：connection,preparedStatement,resultset
Spring的JdbcTemplate,对jdbc的简单封装
Apache的DBUtils:简单封装jdbc

jdbc 问题 分析
1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
2、Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java
代码。
3、使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能
多也可能少，修改 sql 还要修改代码，系统不易维护。
4、对结果集解析存在硬编码（查询列名），sql 变化导致解析代码变化，系统不易维护，如果能将数据库记
录封装成 pojo 对象解析比较方便。

但是都不是框架，并没有各种解决方案，只能成为工具类，封装的不够彻底，应该将更多的精力放在功能开发上
mybatis实现了，他让开发者更关注sql本身
ybatis通过 xml 或注解的方式将要执行的各种statement配置起来，并通过java对象和statement 中
sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并
返回。
O->Object
RM->Relational (关系) Mapping(映射)
实际上就是一种把数据库映射成对象的想法

数据库的表（table） --> 类（class）
记录（record，行数据）–> 对象（object）
字段（field）–> 对象的属性（attribute）
采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc进行了封装，屏蔽了 jdbc api 底层访问细节，使我
们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。

环境搭建

创建一个工程作为范例

不要使用之前的webapp模板
创建必要的数据库

在pom配置文件中打包方式确定为
jar
添加依赖

分别添加mybatis，数据库，日志，单元测试依赖

    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <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>
    </dependencies>

配置完成，开始案例

入门案例

用户对象user.java

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

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 + '\'' +
                '}';
    }
}

用户的持久层接口IUserDao

import java.util.List;


public interface IUserDao {
    
    

    /**
     * 查询所有操作
     * @return
     */
    List<User> findAll();
}

接下来创建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">
<!-- mybatis的主配置文件 -->
<configuration>
    <!-- 配置环境，叫什么名字无要求，但是需要为他施加定义，比如下面id -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <mapper resource="com/dao/IUserDao.xml"/>
    </mappers>
</configuration>

还有user接口对象的`配置文件也要声明

<?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="com.dao.IUserDao">
    <!--配置查询所有，注意这里有返回类型，代表数据的归途，查询完毕后返回到user对象中-->
    <select id="findAll" resultType="com.domain.User">
        select * from user
    </select>
</mapper>

注意数据的返回问题
总结起来就是
第一步:创建 maven工程并导入坐标
第二步:创建实体类和dao的接口
第三步:创建 Mybatis的主配置文件
SqlmapConifg. xml
第四步:创建映射配置文件
IUserDao, xml

最后因为添加了日志依赖，所以还需要日志的配置文件log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{
    
    ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{
    
    ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

注意事项

环境搭建的注意事项
第一个:创建 IUserDao.xm1和 IUserDao.java时名称是为了和我们之前的知识保持一致
在 Myatis中它把持久层的操作接口名称和映射文件也叫做: Mappe
所以: IUserDao和 IUserMapper是一样的
第二个在idea中创建目录的时候,它和包是不一样的
包在创建时:com. i theima.dao它是三级结构
目录在创建时:com. i theima.dao是一级目录
第三个: abatis的映射配置文件位置必须和dao接口的包结构相同，就是配置文件的目录结构和实际所配置的java类接口目录结构相同
比如接口 a.b.c a.class 配置文件也必须是配置文件下的a.b.c a.xml
第四个:映射配置文件的 mapper标签 namespace属性的取值必须是dao接口的全限定类名
第五个:映射配置文件的操作配置( select),id属性的取值必须是dao接口的方法名
当我们遵从了第三,四,五点之后,我们在开发中就无须再写dao的实现类。

接下来为测试项目写测试类

package com.test;

import com.dao.IUserDao;
import com.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

public class MybatisTest {
    
    

    /**
     * 入门案例
     * @param args
     */
    public static void main(String[] args)throws Exception {
    
    
        //1.读取配置文件，这里有连接数据库的信息
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//接口不能直接使用，需要找到他的实现。mybatis把创建工厂的细节省略了，把上面的一行添加
        SqlSessionFactory factory = builder.build(in);//如何读取配置文件，如何封装是mybatis的事情，
//把细节都封装好了
        //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();
    }
}

总结步骤就是：
第一步:读取配置文件
第二步:创建 SqlsessionFactory工厂
第三步:创建 Sqlsession
第四步:创建Dao接口的代理对象
第五步:执行dao中的方法
第六步:释放资源
注意事项
不要忘记在映射配置中告知 ibatis要封装到哪个实体类中
配置的方式:指定实体类的全限定类名

基于注解实现

那么不实用xml，而是用注解实现呢？
对于user接口iuser.java来说，其他都一样，只不过没有同目录结构的要求了
，iuserdao.xml文件也没用了
对于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">
<!-- mybatis的主配置文件 -->
<configuration>
    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="1234"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件
        如果是用注解来配置的话，此处应该使用class属性指定被注解的dao全限定类名
    -->
    <mappers>
        <mapper class="com.dao.IUserDao"/>
    </mappers>
</configuration>

接口类添加注解如此
IUserDao.java

package com.dao;

import com.domain.User;
import org.apache.ibatis.annotations.Select;

import java.util.List;
public interface IUserDao {
    
    

    /**
     * 查询所有操作
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
}

ibatis基于注解的入门案例
把 IUserDao、xm移除,在dao接口的方法上使用 Select注解,并且指定SαL语句
同时需要在 SqlmapConfig.xm1中的 mapper配置时,使用 class属性指定dao接口的全限定类
名
不需要再关心返回值封装归属问题，更简便了

前面只是讲了mybatis的配置问题，

对于dao类的实现问题

如果不使用提供的方法，自己写dao
自己写dao类
UserDaoImpl.java

package com.test.dao.impl;

import com.test.dao.IUserDao;
import com.test.domain.User;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class UserDaoImpl implements IUserDao {
    
    

    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory  factory){
    
    
        this.factory = factory;
    }


    public List<User> findAll(){
    
    
        //1.使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2.使用session执行查询所有方法,未来如果有很多的接口配置文件，会有重名的方法，
//可以使用xml配置文件中的namesapce+方法进行唯一定位
        List<User> users = session.selectList("com.test.dao.IUserDao.findAll");
        session.close();
        //3.返回查询结果
        return users;
    }
}

调用dao类，重新回到test方法中，进行测试

package com.test.test;

import com.test.dao.IUserDao;
import com.test.dao.impl.UserDaoImpl;
import com.test.domain.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * mybatis的入门案例
 */
public class MybatisTest {
    
    

    /**
     * 入门案例
     * @param args
     */
    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.使用工厂创建dao对象
        IUserDao userDao = new UserDaoImpl(factory);
        //4.使用代理对象执行方法
        List<User> users = userDao.findAll();
        for(User user : users){
    
    
            System.out.println(user);
        }
        //5.释放资源
        in.close();
    }
}

但是实际开发中意义不打，开发效率不高，但是namespace与方法的定位有效

对于项目的注意事项

配置文件的路径问题
绝对路径：d:xxxx，没有d盘完蛋
相对路径：src/xxx ,如果是web工程，一旦部署，没有此路径完蛋
解决：使用类加载器，但是只能读取类路径
使用servletcontext，得到当前路径部署的绝对路径，项目运行在那，他就在那
读配置文件的时候这两种方式最靠谱，其他都不靠谱

创建工厂的时候使用了构建这模式，就是相当于老板指挥包工头做事，把钱和需求给了就行
builder就是构建者，in就是钱
构建者模式:把对象的创建细节隐藏,是使用者直接调用方法即可拿到对象

使用工厂生产对象，生产 Sqlsessionf用了工厂模式优势:解耦(降低类之问的依赖关系)
假如对象发生改变，就不要修改源码重新编译部署，可以大大方便维护

创建Dao接口实现类使用了代理模式:不修改源码的基础上对已有方法增强

自定义mybatis-查询所有分析-项目

自定义mybaitis-根据上述分析完善类和接口

使用注解

使用xml配置

最后需要实现查询所有
executor执行者，最后要调用这个工具类，查询所有的功能，负责执行sql语句，封装结果类
什么时候调用呢？创建dao，实现增强的时候
什么时候创建dao的实现增强呢？defaultsqlsession
创建代理对象mapperproxy,找出要执行的语句与要封装的结果
从哪里找？配置文件，xmlconfgbuilder
读取之后存起来到对象前，比如configration
创建代理对象，实现查询所有

自定义mybatis和数据库交互的核心类
讲pom.xml中mybatis去掉，自己编写类，同时需要用到dom解析xml文件，
想用到xpath还需要jaxen
修改后的pom如下：
pom.xml

<?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.test</groupId>
    <artifactId>mybatis_design</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

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

</project>

mybatis至关重要的几个类
自定义 abatis能通过入门案例看到类
class resources
class SalsessionFactory Builder
interface SalSessionFactory
interface Salsessiol
讲几个类分别创建在不同文件夹下
可以同时创建文件夹与类

io文件夹
Resources.java读取配置文件

package com.test.mybatis.io;

import java.io.InputStream;

/**
 * 使用类加载器读取配置文件的类
 */
public class Resources {
    
    

    /**
     * 根据传入的参数，获取一个字节输入流
     * @param filePath
     * @return
     */
    public static InputStream getResourceAsStream(String filePath){
    
    
        return Resources.class.getClassLoader().getResourceAsStream(filePath);
//拿到类，类加载器，根据类加载器读取配置
    }
}

sqlsession文件夹
DefaultSqlSession.java

package com.test.mybatis.sqlsession.defaults;

import com.test.mybatis.cfg.Configuration;
import com.test.mybatis.sqlsession.SqlSession;
import com.test.mybatis.sqlsession.proxy.MapperProxy;
import com.test.mybatis.utils.DataSourceUtil;

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

/**
 * SqlSession接口的实现类
 */
public class DefaultSqlSession implements SqlSession {
    
    

    private Configuration cfg;
    private Connection connection;

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

    /**
     * 用于创建代理对象
     * @param daoInterfaceClass dao的接口字节码
     * @param <T>
     * @return
     */
    @Override
    public <T> T getMapper(Class<T> daoInterfaceClass) {
    
    
        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(),
                new Class[]{
    
    daoInterfaceClass},new MapperProxy(cfg.getMappers(),connection));
    }

    /**
     * 用于释放资源
     */
    @Override
    public void close() {
    
    
        if(connection != null) {
    
    
            try {
    
    
                connection.close();
            } catch (Exception e) {
    
    
                e.printStackTrace();
            }
        }
    }
}

DefaultSqlSessionFactory.java

package com.test.mybatis.sqlsession.defaults;

import com.test.mybatis.cfg.Configuration;
import com.test.mybatis.sqlsession.SqlSession;
import com.test.mybatis.sqlsession.SqlSessionFactory;


/**
 * SqlSessionFactory接口的实现类
 */
public class DefaultSqlSessionFactory implements SqlSessionFactory{
    
    

    private Configuration cfg;

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

    /**
     * 用于创建一个新的操作数据库对象
     * @return
     */
    @Override
    public SqlSession openSession() {
    
    
        return new DefaultSqlSession(cfg);
    }
}

MapperProxy.java

package com.test.mybatis.sqlsession.proxy;

import com.test.mybatis.cfg.Mapper;
import com.test.mybatis.utils.Executor;

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

public class MapperProxy implements InvocationHandler {
    
    

    //map的key是全限定类名+方法名
    private Map<String,Mapper> mappers;
    private Connection conn;

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

    /**
     * 用于对方法进行增强的，我们的增强其实就是调用selectList方法
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @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);
    }
}

SqlSession.java

package com.test.mybatis.sqlsession;

/**
 * 自定义Mybatis中和数据库交互的核心类
 *  它里面可以创建dao接口的代理对象
 */
public interface SqlSession {
    
    

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

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

SqlSessionFactory.java

package com.test.mybatis.sqlsession;

public interface SqlSessionFactory {
    
    

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

SqlSessionFactoryBuilder.java

package com.test.mybatis.sqlsession;

import com.test.mybatis.cfg.Configuration;
import com.test.mybatis.sqlsession.defaults.DefaultSqlSessionFactory;
import com.test.mybatis.utils.XMLConfigBuilder;

import java.io.InputStream;

/**
 *  用于创建一个SqlSessionFactory对象
 */
public class SqlSessionFactoryBuilder {
    
    

    /**
     * 根据参数的字节输入流来构建一个SqlSessionFactory工厂
     * @param config
     * @return
     */
    public SqlSessionFactory build(InputStream config){
    
    
        Configuration cfg = XMLConfigBuilder.loadConfiguration(config);
        return  new DefaultSqlSessionFactory(cfg);
    }
}

接下来创建相关的工具类
utils文件夹XMLConfigBuilder。java

package com.test.mybatis.utils;

//import com.test.mybatis.annotations.Select;

import com.test.mybatis.annotations.Select;
import com.test.mybatis.cfg.Configuration;
import com.test.mybatis.cfg.Mapper;
import com.test.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.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
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/test/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.setQueryString(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;
    }
}

Executor.java

package com.test.mybatis.utils;

import com.test.mybatis.cfg.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;

/**
 * 负责执行SQL语句，并且封装结果集
 */
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();//com.test.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.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();
            }
        }
    }
}

DataSourceUtil.java

package com.test.mybatis.utils;

import com.test.mybatis.cfg.Configuration;

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

/**
 * 用于创建数据源的工具类
 */
public class DataSourceUtil {
    
    

    /**
     * 用于获取一个连接
     * @param cfg
     * @return
     */
    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);
        }
    }
}

annotations文件夹

package com.test.mybatis.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

    /**
     * 配置SQL语句的
     * @return
     */
    String value();
}

cfg文件夹
Mapper.`java执行sql语句，封装结果的实体类全限定类名，结果类型

package com.test.mybatis.cfg;

/**
 * 用于封装执行的SQL语句和结果类型的全限定类名
 */
public class Mapper {
    
    

    private String queryString;//SQL
    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;
    }
}

Configuration.java，对数据库连接进行配置

package com.test.mybatis.cfg;

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

/**
 * 自定义mybatis的配置类
 */
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 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;
    }
}

代理谁就用谁的类加载器
实现原理`，自定义框架