自定义持久层框架Mybatis

一、前言

想要深入了解mybatis，就得自己自定义持久层框架，现在我们来试一下如何制定？

二、前期准备

jdk11

mysql 8

idea

我们创建两个maven项目

一个是自定义框架，一个是测试自定义框架

三、分析JDBC操作

我们知道Mybatis其实就是jdbc封装后的框架,先将其分为几个部分

package birenyin;

import java.sql.*;


public class jdbc {
	public static void main(String[] args) {
		Connection connection = null;
		PreparedStatement preparedStatement = null;
		ResultSet resultSet = null;
		try {
			// 加载数据库驱动
			Class.forName("com.mysql.jdbc.Driver");
			// 通过驱动管理类获取数据库链接
			connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis? " +
							"characterEncoding = utf - 8", " root", " root");
							// 定义sql语句？表示占位符
							String sql = "select * from user where username = ?";
			// 获取预处理statement
			preparedStatement = connection.prepareStatement(sql);
			// 设置参数，第⼀个参数为sql语句中参数的序号(从1开始)，第⼆个参数为设置的参数值
			preparedStatement.setString(1, "tom");
			// 向数据库发出sql执⾏查询，查询出结果集
			resultSet = preparedStatement.executeQuery();
			// 遍历查询结果集
			while (resultSet.next()) {
				int id = resultSet.getInt("id");
				String username = resultSet.getString("username");
				// 封装User
				User user = new User();
				user.setId(id);
				user.setUsername(username);
				System.out.println(user);
			}

		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// 释放资源
			if (resultSet != null) {
				try {
					resultSet.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (preparedStatement != null) {
				try {
					preparedStatement.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
			if (connection != null) {
				try {
					connection.close();
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}

		}
	}
}

jdbc问题分析和解决方法：

1、数据库配置信息存在硬编码问题 : 配置文件

2、频繁创建释放数据库连接：连接池（druid)

3、sql语句、设置参数、获取结果集参数均存在硬编码问题：配置文件

4、手动封装返回结果集繁琐：进行反射/内省

四、自定义框架设计

1、测试端

提供核⼼配置⽂件：

sqlMapConfig.xml : 存放数据源信息，引⼊mapper.xml （为了能在同一代码中进行解析）存放

Mapper.xml : sql语句的配置⽂件信息

2、自定义框架端

1、读取配置文件

读取完成以后以流的形式存在，我们不能将读取到的配置信息以流的形式存放在内存中，因为不好操作，可以创建javaBean来存储

（1） Configuration : 存放数据库基本信息、Map<唯⼀标识，Mapper> 唯⼀标识：namespace + “.”+ id

（2） MappedStatement：sql语句、statement类型、输⼊参数java类型、输出参数java类型

2、解析配置⽂件

创建sqlSessionFactoryBuilder类：

⽅法：sqlSessionFactory build()：

第⼀：使⽤dom4j解析配置⽂件，将解析出来的内容封装到Configuration和MappedStatement中第⼆：创建SqlSessionFactory的实现类DefaultSqlSession

3、创建SqlSessionFactory：

⽅法：openSession() : 获取sqlSession接⼝的实现类实例对象

4、创建sqlSession接⼝及实现类：主要封装crud⽅法

⽅法：selectList(String statementId,Object param)：查询所有

selectOne(String statementId,Object param)：查询单个

具体实现：封装JDBC完成对数据库表的查询操作

涉及到的设计模式：

构建者设计模式、⼯⼚模式、代理模式

五、自定义框架实现

测试端:

sqlMapConfig.xml

UserMapper.xml



    
    
        select * from user where id = #{id} and username = #{username}

IUserDao

package com.birenyin.dao;

import com.birenyin.pojo.User;

import java.util.List;

public interface IUserDao {

    //查询所有用户
    public List findAll() throws Exception;


    //根据条件进行用户查询
    public User findByCondition(User user) throws Exception;


}

User

package com.birenyin.pojo;

public class User {

    private Integer id;
    private String username;


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

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

test

package com.birenyin.test;

import com.birenyin.dao.IUserDao;
import com.birenyin.io.Resources;
import com.birenyin.pojo.User;
import com.birenyin.sqlSession.SqlSession;
import com.birenyin.sqlSession.SqlSessionFactory;
import com.birenyin.sqlSession.SqlSessionFactoryBuilder;
import org.junit.Test;

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

public class Test {

    @Test
    public void test() throws Exception {
        InputStream resourceAsSteam = Resources.getResourceAsSteam("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsSteam);
        SqlSession sqlSession = sqlSessionFactory.openSession();

        //调用
        User user = new User();
        user.setId(1);
        user.setUsername("张三");
      

       

        IUserDao userDao = sqlSession.getMapper(IUserDao.class);

        List all = userDao.findAll();
        for (User user1 : all) {
            System.out.println(user1);
        }


    }



}

自定义框架端

pom.xml


    UTF-8
    UTF-8
    1.8
    1.8
    1.8




    
        mysql
        mysql-connector-java
        5.1.17
    
    
        c3p0
        c3p0
        0.9.1.2
    
    
        log4j
        log4j
        1.2.12
    
    
        junit
        junit
        4.10
    
    
        dom4j
        dom4j
        1.6.1
    
    
        jaxen
        jaxen
        1.1.6

BoundSql

package com.birenyin.config;

import com.birenyin.utils.ParameterMapping;

import java.util.ArrayList;
import java.util.List;

public class BoundSql {

    private String sqlText; //解析过后的sql

    private List parameterMappingList = new ArrayList<>();

    public BoundSql(String sqlText, List parameterMappingList) {
        this.sqlText = sqlText;
        this.parameterMappingList = parameterMappingList;
    }

    public String getSqlText() {
        return sqlText;
    }

    public void setSqlText(String sqlText) {
        this.sqlText = sqlText;
    }

    public List getParameterMappingList() {
        return parameterMappingList;
    }

    public void setParameterMappingList(List parameterMappingList) {
        this.parameterMappingList = parameterMappingList;
    }
}

XMLConfigBuilder

package com.birenyin.config;

import com.birenyin.io.Resources;
import com.birenyin.pojo.Configuration;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.beans.PropertyVetoException;
import java.io.InputStream;
import java.util.List;
import java.util.Properties;

public class XMLConfigBuilder {

    private Configuration configuration;

    public XMLConfigBuilder() {
        this.configuration = new Configuration();
    }

    
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {

        Document document = new SAXReader().read(inputStream);
        //
        Element rootElement = document.getRootElement();
        List list = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element element : list) {
            String name = element.attributeValue("name");
            String value = element.attributeValue("value");
            properties.setProperty(name,value);
        }

        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(properties.getProperty("driverClass"));
        comboPooledDataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        comboPooledDataSource.setUser(properties.getProperty("username"));
        comboPooledDataSource.setPassword(properties.getProperty("password"));

        configuration.setDataSource(comboPooledDataSource);

        //mapper.xml解析: 拿到路径--字节输入流---dom4j进行解析
        List mapperList = rootElement.selectNodes("//mapper");

        for (Element element : mapperList) {
            String mapperPath = element.attributeValue("resource");
            InputStream resourceAsSteam = Resources.getResourceAsSteam(mapperPath);
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsSteam);

        }


        return configuration;
    }


}

XMLMapperBuilder

package com.birenyin.config;

import com.birenyin.pojo.Configuration;
import com.birenyin.pojo.MappedStatement;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

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

public class XMLMapperBuilder {

    private Configuration configuration;

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

    public void parse(InputStream inputStream) throws DocumentException {

        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();

        String namespace = rootElement.attributeValue("namespace");

        List list = rootElement.selectNodes("//select");
        for (Element element : list) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String paramterType = element.attributeValue("paramterType");
            String sqlText = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParamterType(paramterType);
            mappedStatement.setSql(sqlText);
            String key = namespace+"."+id;
            configuration.getMappedStatementMap().put(key,mappedStatement);

        }

    }


}

resources

package com.birenyin.io;

import java.io.InputStream;

public class Resources {

    // 根据配置文件的路径，将配置文件加载成字节输入流，存储在内存中
    public static InputStream getResourceAsSteam(String path){
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return  resourceAsStream;

    }



}

Configuration

package com.birenyin.pojo;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

public class Configuration {

    private DataSource dataSource;

    
    Map mappedStatementMap = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}

mappedStatement

package com.birenyin.pojo;

public class MappedStatement {

    //id标识
    private String id;
    //返回值类型
    private String resultType;
    //参数值类型
    private String paramterType;
    //sql语句
    private String sql;

    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 getParamterType() {
        return paramterType;
    }

    public void setParamterType(String paramterType) {
        this.paramterType = paramterType;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }
}

DefaultSqlSession

package com.birenyin.sqlSession;

import com.birenyin.pojo.Configuration;
import com.birenyin.pojo.MappedStatement;

import java.lang.reflect.*;
import java.util.List;

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

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

    @Override
    public  List selectList(String statementid, Object... params) throws Exception {

        //将要去完成对simpleExecutor里的query方法的调用
        simpleExecutor simpleExecutor = new simpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementid);
        List

自定义持久层框架Mybatis

Java相关栏目本月热门文章