记一次手动实现mybatis框架findAll功能

Mybatis是基于持久层开发的框架，它内部封装了JDBC，开发者不需要将精力放在数据库连接这方面，只需要把关注点放在sql语句的编写上。Mybatis通过xml或者注解的方式将要执行的各种statement对象配置起来，并且通过java对象和statement中的sql的动态参数进行映射生成sql语句。最后由Mybatis框架执行sql语句并将结果集对象通过反射技术封装成javabean对象返回。Mybatis采用ORM思想（object relational mapping)将java实体和数据库映射结合。框架内部封装了jdbc底层技术。

开发前准备

导入依赖jar包

<dependencies>
        <!-- mysql驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.36</version>
        </dependency>
        <!-- 解析xml的dom4j -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <!-- dom4j的依赖包jaxen -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

表结构

+----------+--------------+------+-----+---------+-------+
| Field    | Type         | Null | Key | Default | Extra |
+----------+--------------+------+-----+---------+-------+
| username | varchar(255) | YES  |     | NULL    |       |
| password | varchar(255) | YES  |     | NULL    |       |
+----------+--------------+------+-----+---------+-------+

javaBean

public class User{
    private String username;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

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

接口Mapper和Mapper文件准备

package mapper;

import domain.User;

import java.util.List;

public interface UserMapper {
    /**
     * 查询所有用户的方法
     * @return
     */
    List<User> findAll();
}

<?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="mapper.UserMapper">
    <select id="findAll" resultType="domain.User">
        SELECT * FROM  user
    </select>
</mapper>

编写测试类

import domain.User;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class CustomerMyBatisTest {
    @Test
    public void testFindAll() {
        //1.将主配置文件转换成字节输入流
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("SqlMapConfig.xml");
            System.out.println(is);
            //2.创建一个SqlSessionFactoryBuilder的对象
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            //3.构建SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = builder.build(is);//使用了构建者模式
            //4.创建SqlSession对象
            sqlSession = sqlSessionFactory.openSession();
            //5.通过SqlSession对象，创建UserMapper接口的代理对象----->动态代理
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            //6.调用mapper对象的findAll()方法
            List<User> users = mapper.findAll();
            for (User user : users) {
                System.out.println(user);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //7.关闭资源
            sqlSession.close();
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

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">
<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://localhost:3306/test?characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <!--
        加载映射文件
    -->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

 测试类中的所有接口类都是空实现，需要我们自己补充。

项目结构如下

SqlSessionFactory接口及其实现类DefaultSqlSessionFactory

SqlSession接口及其实现类DefalutSqlSession

sqlMapConfig Mybatis配置文件

Resources类负责读取类路径下资源文件,具体内容如下：

public class Resources {
	    public static InputStream getResourceAsStream(String path){
	        InputStream is = Resources.class.getClassLoader().getResourceAsStream(path);
	        return is;
	    }
	}

项目准备完毕，接下来就是coding。。

读取sqlMapConfig获取jdbc连接

工具类XmlConfigBuilder

1、解析获取dateSource连接必须数据

public class XmlConfigBuilder {
//加载配置文件，解析相关信息，封装到Configuration对象返回
    public static Configuration loadSqlMapConfig(InputStream is) {
        SAXReader Reader = new SAXReader();//创建SAXReader对象解析XML
        try {
            Document document = Reader.read(is);//获取document对象
            List<Element> propertyElement = document.selectNodes("//property");//通过Xpath技术解析property对象
        

解析以后可以获取Element元素集合，对应的name分别是：XML中配置的username，password，url、以及dirver

创建Configuration实体类负责接收 

public class Configuration {
    private String username;
    private String password;
    private String driver;
    private String url;
    //存放每个mapper文件对应的sql语句和resultType
    private Map<String, Mapper> mappers = new HashMap<String, Mapper>();
    Get/Set....
}

 Configuration cfg = new Configuration();//创建Configuration对象
            //遍历集合取出对应value
            for (Element element : propertyElement) {
                String name = element.attributeValue("name");
                String value = element.attributeValue("value");
                if ("username".equals(name)) {
                    cfg.setUsername(value);
                }
                if ("password".equals(name)) {
                    cfg.setPassword(value);
                }
                if ("url".equals(name)) {
                    cfg.setUrl(value);
                }
                if ("driver".equals(name)) {
                    cfg.setDirver(value);
                }

2、解析获取映射文件路径

   for (Element mapperElement : mapperElements) {
                    String resource = mapperElement.attributeValue("resource");//获取映射文件路径
                    Map<String, Mapper> mappers = loadMapper(resource);//通过配置文件加载每个映射文件，具体方法后面实现TODO
                    cfg.setMappers(mappers);//将获取的每一个mapper对象放入Configuration对象中存储，并且补充
                }
            }
            return cfg;

        } catch (DocumentException e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
    }

3、加载每个映射文件获取对应sql语句、resultType

 //加载映射文件获取对应sql语句、resultType封装Mapper对象集合返回Map<namespace.id,Mapper对象>
    private static Map<String, Mapper> loadMapper(String resource) {
        Map<String, Mapper> mappers = new HashMap<String, Mapper>();
        InputStream is = Resources.getResourceAsStream(resource);//通过Resources对象将Mapper.xml文件转为流
        SAXReader reader = new SAXReader();//创建SAXReader对象
        try {
            Document document = reader.read(is);//获取document对象
            Element rootElement = document.getRootElement();//获得Mapper.xml文件根标签及<mapper namespace="">标签
            String namespace = rootElement.attributeValue("namespace");//获取namespace
            List<Element> selectElements = document.selectNodes("//select");//获取select标签集合
            //遍历集合取出每一个select标签的id和resultType
            for (Element selectElement : selectElements) {
                String id = selectElement.attributeValue("id");
                String resultType = selectElement.attributeValue("resultType");
                String sql = selectElement.getTextTrim();//获取标签中的内容及内部SQL语句
                //封装mapper对象
                Mapper mapper = new Mapper();
                mapper.setSql(sql);
                mapper.setResultType(resultType);
                mappers.put(namespace + "." + id, mapper);//存入map集合

            }
            return mappers;
        } catch (DocumentException e) {
            e.printStackTrace();
            throw new RuntimeException();
        }

    }

4、sql语句返回值类型，及其对应的连接信息全部封装在Configuration对象中，补充Configuration对象中连接方法

public Connection getConnection() throws SQLException {
        try {
            Class.forName(driver);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Connection conn = DriverManager.getConnection(url, username, password);

        return conn;
    }

SqlSessionFactory、SqlSession具体实现类方法实现

使用过mybatis就会发现，基本上所有的增删改查操作的执行都是交给SqlSession对象实现的。（sqlSession.getMapper()）

也就是说获取连接也是SqlSession内部实现的，所有我们需要将Configuration对象给SqlSession实现类DefaultSqlSession类。

还需要解决几个问题

1）到底什么时候加载配置文件？

我们可以在在SqlSessionFactory的openSqlSession方法调用时加载配置文件

2）通过什么方式通知程序读取Mybatis配置文件（SqlMapConfig.xml)。

我们已经将配置文件转为流了，只需要在SqlSessionFactory调用build方法的时候将流传入即可，所以我们只需要将流传给SqlSessionFactory的实现类DefaultSqlSessionFacotory。

首先实现SqlSessionFactoryBuilder类

public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream is) {
        DefaultSqlSessionFactory sqlSessionFactory = new DefaultSqlSessionFactory();
        //创建SqlSessionFactory对象设置上流并返回
        sqlSessionFactory.setIs(is);
        return sqlSessionFactory;
    }
}

DefaultSqlSessionFactory类实现

public class DefaultSqlSessionFactory implements SqlSessionFactory{
    private InputStream is;
    //在openSession方法内部创建SqlSession对象
    public SqlSession openSession() {
        //创建SqlSession对象
        DefaultSqlSession sqlSession = new DefaultSqlSession();

        //通过loadSqlMapConfig方法
        Configuration cfg = XmlConfigBuilder.loadSqlMapConfig(is);
        //给SqlSession对象设置Configuration对象
        sqlSession.setCfg(cfg);
        return sqlSession;
    }
    public void setIs(InputStream is) {
        this.is = is;
    }
}

DefalutSqlSession类实现

1、编写selectList()方法

 //key：mapper.xml中select的方法的全限定名（namespace.id名）
    public <E> List<E> selectList(String key) {
        //获取连接对象
        Connection conn = null;
        try {
            conn = cfg.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        //获取SQl语句
        Map<String, Mapper> mappers = cfg.getMappers();
        Mapper mapper = mappers.get(key);
        String sql = mapper.getSql();//获取要执行的SQL语句

        String resultType = mapper.getResultType();//JavaBean的全限定名
        //预编译SQL语句
        try {
            PreparedStatement pstm = conn.prepareStatement(sql);
            //执行Sql语句
            ResultSet resultSet = pstm.executeQuery();

            //通过反射技术将结果封装成javaBean对象，具体实现后面总结
            List<E> list = Converser.converList(resultSet, Class.forName(resultType));
            return list;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }finally {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

2、通过动态代理获取代理对象

 public <E> E getMapper(Class<E> mapperClass) {
        return (E) Proxy.newProxyInstance(mapperClass.getClassLoader(),new Class[]{mapperClass},new MapperProxyFactory(this));
    }

Proxy的newProxyInstance方法中需要三个参数：classLoader类加载器，代理对象实现的接口的字节码对象也就是我们这里的传入的mapperClass对象，InvocationHandler接口的实现类对象。具体实现如下

public class MapperProxyFactory implements InvocationHandler{
    private SqlSession sqlSession;

    public MapperProxyFactory(SqlSession sqlSession) {
        this.sqlSession = sqlSession;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //如果返回值是一个List集合才执行如下代码，即findAll
        Class<?> returnType = method.getReturnType();
        if (returnType == List.class) {
            String methodName = method.getName();//获取方法名

            Class<?> clazz = method.getDeclaringClass();//获取接口字节码对象
            String className = clazz.getName();//获取接口的全限定名
            //key ：mapper接口的全限定名
            String key = className+"."+methodName;

            List<Object> list = sqlSession.selectList(key);
            return list;
        }else {
            //TODO..
            return null;
        }
    }
}

3、Converser类的具体实现（反射将resultType映射成javaBean对象） 

 public static <E> List<E> converList(ResultSet set, Class clazz){
        List<E> javaBeans = new ArrayList<E>();
        //1.遍历结果集
        try {
            //根据结果集元数据，获取结果集中的每一列的列名
            ResultSetMetaData metaData = set.getMetaData();
            int columnCount = metaData.getColumnCount();//获取总列数
            while (set.next()){
                //每次遍历，遍历出一条数据，每条数据就对应一个JavaBean对象
                E o = (E) clazz.newInstance();
                //根据列名获取每一列数据
                for(int i=1;i<=columnCount;i++){
                    String columnName = metaData.getColumnName(i);//获取列名
                    Object value = set.getObject(columnName);//获取该列的值
                    //将该列的值存放到JavaBean中
                    //也就是调用JavaBean的set方法,使用内省机制
                    PropertyDescriptor descriptor = new PropertyDescriptor(columnName,clazz);
                    Method writeMethod = descriptor.getWriteMethod();//获取该属性的set方法
                    //调用set方法
                    writeMethod.invoke(o,value);
                }
                javaBeans.add(o);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return javaBeans;
    }