手写类mybatis持久层

最新推荐文章于 2022-07-11 20:43:34 发布
最新推荐文章于 2022-07-11 20:43:34 发布
阅读量174 收藏
点赞数
分类专栏： 训练 文章标签： 训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ko0491/article/details/106864198
版权

mybatis

JDBC

JDBC存 的问题

  • 数据库配置硬编码

  • 频繁创建与销毁数据库连接 ，资源严重浪费

  • SQL语句、参数写在代码里和代码在一起，存在硬编码，不好维护，

  • 对参数和返回结果需要手动一个一个去绑定，较为繁琐

JDBC 解决方案

  • 使用配置文件

  • 使用数据库连接池

  • 使用配置文件与代码分开维护（与数据库配置文件分开），SQL配置文件可能经常变更

  • 使用反射、内省的方式来重实现绑定与封装

自定义持久层-persistent

使用端引用自定义持久框架 的jar包

提供数据库配置信息-配置文件

sqlMapConfig.xml存放数据库配置信息

sql配置信息-sql语句，入参数 ，返回类型-配置文件

UserMapper.xml-存放Sql的配置信息

自定义持久层框架本身

本质是对JDBC的封装

解析sqlMapConfig.xml、UserMapper.xml配置文件

  1. 加载配置文件-加载为流
  2. 将解析到XML内容存放在JAVABENA(容器) Configuration核心配置类sqlMapConfig.xm,MappedStatement映射配置类
  3. 解析XML-使用DOM4J，将数据封装
  4. 创建SqlSessionFactoryBuilder与SqlSessionFactory
  5. 创建SqlSession会话对象-增删改查
  6. 创建Executor ,执行JDBC，

使用

<!--sqlMapConfig.xml-->
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>

    <properties>
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/mylearning"/>
        <property name="jdbcUser" value="root"/>
        <property name="jdbcPassword" value="root"/>
    </properties>

    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>
<!--UserMapper-->
<mapper namespace="com.liu.me.mapper.UserMapper">

    <select id="selectOne" paramterType="com.liu.me.entity.User"
            resultType="com.liu.me.entity.User">
        select * from user where id = #{id} and username =#{username}
    </select>

    <select id="selectList" resultType="com.liu.me.entity.User">
        select * from user
    </select>
</mapper>

持久层框架的基本实现

    <dependencies>
        <!--mysql 驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--dom4j-->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.2.0</version>
        </dependency>
        <!--数据库连接池-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>

    </dependencies>
加载资源类
public class Resources {

    /**
     * 根据配置文件的路径加载资源
     * @param path
     * @return
     */
    public  static InputStream getResourceAsStream(String path){

        return Resources.class.getClassLoader().getResourceAsStream(path);
    }
}
SqlCommandType
public enum SqlCommandType {
     INSERT, UPDATE, DELETE, SELECT;
}
配置类 MappedStatement
public class MappedStatement {
    /**
     * ID namespace +"."+id
     */
    private String id;
    /**
     * SQL语句
     */
    private String sql;

    private String parameterType;

    private String returnType;

    private SqlCommandType sqlCommandType;
}
配置类 Configuration
public class Configuration {

    private DataSource dataSource;
    private Properties properties;
    
    private Map<String, MappedStatement> mappedStatementMap = new ConcurrentHashMap<>();;
}

xml解析-SqlSessionFactoryBuilder

public class SqlSessionFactoryBuilder {


    /**
     * 创建SqlSessionFactory
     * @param in
     * @return
     */
    public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {

        XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder();

        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        //创建SqlSessionFactory

        return null;
    }
}

xml解析-XmlConfigBuilder

public class XmlConfigBuilder {


    private Configuration configuration;

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

    /**
     * 解析配置文件封装Configuration对象
     * @param inputStream
     * @return
     */
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {

        //使用Dom4j
        Document document = new SAXReader().read(inputStream);

        //获取根据节点
        Element rootElement = document.getRootElement();

        //property 获取所有

        List<Element> list =rootElement.selectNodes("//property");


        Properties properties = new Properties();

        for (Element element : list) {
            //获取name
            String name = element.attributeValue("name");
            //获取value
            String value = element.attributeValue("value");
            properties.put(name, value);

        }

        configuration.setProperties(properties);

       //创建数据源
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //driverClass
        dataSource.setDriverClass(properties.getProperty("driverClass"));
        //jdbcUrl
        dataSource.setJdbcUrl(properties.getProperty("jdbcUrl"));
        //jdbcUser
        dataSource.setUser(properties.getProperty("jdbcUser"));
        //jdbcPassword
        dataSource.setPassword(properties.getProperty("jdbcPassword"));
        //设置到配置类中
        configuration.setDataSource(dataSource);


        List<Element> mappers =rootElement.selectNodes("//mapper");


        for (Element element : mappers) {

            String resource = element.attributeValue("resource");

            InputStream asStream = Resources.getResourceAsStream(resource);

            XmlMappedBuilder xmlMappedBuilder = new XmlMappedBuilder(configuration);

            xmlMappedBuilder.parse(inputStream);



        }


        return configuration;

    }
}

xml解析-XmlMappedBuilder

public class XmlMappedBuilder {

    private Configuration configuration;

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

    public void parse(InputStream inputStream) throws DocumentException {


        //使用Dom4j
        Document document = new SAXReader().read(inputStream);
        //获取根对象
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> selectList=rootElement.selectNodes("//select");
        doConfig(namespace,selectList,SqlCommandType.SELECT);
        List<Element> updateList= rootElement.selectNodes("//update");
        doConfig(namespace,selectList,SqlCommandType.UPDATE);
        List<Element> deleteList= rootElement.selectNodes("//delete");
        doConfig(namespace,selectList,SqlCommandType.DELETE);
        List<Element> insertList= rootElement.selectNodes("//insert");
        doConfig(namespace,selectList,SqlCommandType.INSERT);



    }

    private void doConfig(String namespace,List<Element> list, SqlCommandType sqlCommandType) {

        for (Element element : list) {
            //id
            String id = element.attributeValue("id");
            //参数
            String paramterType = element.attributeValue("paramterType");
            //返回值
            String resultType = element.attributeValue("resultType");
            //sql
            String sqlText = element.getTextTrim();

            //封装数据
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setSqlCommandType(sqlCommandType);
            //id值命名空间.id
            String key =namespace+"."+id;

            mappedStatement.setId(key);
            mappedStatement.setSql(sqlText);
            mappedStatement.setReturnType(resultType);
            mappedStatement.setParameterType(paramterType);

            //放入容器
            configuration.getMappedStatementMap().put(key, mappedStatement);
        }
    }
}

到此XML解析完毕

创建SqlSessionFactory
public class SqlSessionFactoryBuilder {


    /**
     * 创建SqlSessionFactory
     * @param in
     * @return
     */
    public SqlSessionFactory build(InputStream in) throws DocumentException, PropertyVetoException {

        XmlConfigBuilder xmlConfigBuilder = new XmlConfigBuilder();

        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        //创建SqlSessionFactory

        return new DefaultSqlSessionFactory(configuration);
    }
}
SqlSessionFactory
public interface SqlSessionFactory {


    SqlSession openSqlSession();
}
DefaultSqlSessionFactory
public class DefaultSqlSessionFactory implements SqlSessionFactory{

    private Configuration configuration;

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

    @Override
    public SqlSession openSqlSession() {
        //传配置类
        return new DefaultSqlSession(configuration);
    }
}
SqlSession
public interface SqlSession {
    /**
     *
     * @param statementId
     * @param params
     * @param <E>
     * @return
     */
   <E> List<E>  selectList(String statementId,Object...params);

    /**
     *
     * @param statementId
     * @param params
 
     * @return
     */
   <T>  T  selectOne(String statementId,Object...params);
}
DefaultSqlSession

public class DefaultSqlSession implements SqlSession {

    /**
     * 醘
     */
    private Configuration configuration;
    /**
     * 执行器
     */
    private Executor executor;

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

    @Override
    public <E> List<E> selectList(String statementId, Object... params) {
        executor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        


        return executor.query(configuration, mappedStatement, params);
    }

    @Override
    public <T> T selectOne(String statementId, Object... params) {
        List<T> list = selectList(statementId, params);
        if(list.size()==1){
            return list.get(0);
        }
        throw  new  RuntimeException("返回结果过多");

    }


}
Executor
public interface Executor {

    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement,Object[] params);
    
    void close() throws  SQLException;
}
SimpleExecutor
package com.liu.me.executor;

import com.liu.me.mapping.BoundSql;
import com.liu.me.mapping.MappedStatement;
import com.liu.me.session.Configuration;
import com.liu.me.util.GenericTokenParser;
import com.liu.me.util.ParameterMapping;
import com.liu.me.util.ParameterMappingTokenHandler;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;

/**
 * @Description
 * @ClassName SimpleExecutor
 * @Author 刘楠
 * @date 2020.06.19
 */
public class SimpleExecutor implements Executor {


    private Connection connection;

    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object[] params) throws SQLException, NoSuchFieldException, IllegalAccessException, IntrospectionException, InvocationTargetException, InstantiationException {

        //1.创建连接
        connection = configuration.getDataSource().getConnection();

        //2. 获取sql语句 : select * from user where id = #{id} and username = #{username}
        //            //转换sql语句： select * from user where id = ? and username = ? ，转换的过程中，还需要对#{}里面的值进行解析存储
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);

        //3. 获取预处理对象：preparedStatement

        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());

        //4. 设置参数
        String parameterType = mappedStatement.getParameterType();
        Class<?> paramtertypeClass = null;
        if (null != parameterType) {
            paramtertypeClass = getClassType(parameterType);
        }

        if (paramtertypeClass != null) {
            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();

            for (int i = 0; i < parameterMappings.size(); i++) {
                //获取元素
                ParameterMapping mapping = parameterMappings.get(i);
                //属性名
                String content = mapping.getContent();
                //反射获取属性
                Field field = paramtertypeClass.getDeclaredField(content);
                //设置可访问
                field.setAccessible(true);
                Object o = field.get(params[0]);
                //为SQL中的?设置值
                preparedStatement.setObject(i + 1, o);
            }
        }

        //5. 执行sql
        ResultSet resultSet = preparedStatement.executeQuery();


        //6.结果封装
        String returnType = mappedStatement.getReturnType();
        Class<?> resultTypeClass = getClassType(returnType);

        List<Object> objects = new ArrayList<>();

        while (resultSet.next()) {
            Object newInstance = resultTypeClass.newInstance();
            //元数据
            ResultSetMetaData metaData = resultSet.getMetaData();
            //获取列组
            int columnCount = metaData.getColumnCount();
            //从1开始
            for (int i = 1; i <=columnCount; i++) {
                //获取名
                String columnName = metaData.getColumnName(i);
                //获取查询出的出来值
                Object value = resultSet.getObject(columnName);
                //使用反射java.beans中的内省
                PropertyDescriptor descriptor = new PropertyDescriptor(columnName, resultTypeClass);

                //获取写方法
                Method writeMethod = descriptor.getWriteMethod();
                writeMethod.invoke(newInstance, value);


            }
            objects.add(newInstance);

        }

        return (List<E>)objects;
    }


    @Override
    public void close() throws SQLException {
        if (connection != null) {
            connection.close();
        }
    }

    private Class<?> getClassType(String paramterType) {
        if (paramterType != null) {
            Class<?> aClass = null;
            try {
                aClass = Class.forName(paramterType);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return aClass;
        }
        return null;

    }


    /**
     * 完成对#{}的解析工作：1.将#{}使用？进行代替，2.解析出#{}里面的值进行存储
     *
     * @param sql
     * @return
     */
    private BoundSql getBoundSql(String sql) {
        //标记处理类：配置标记解析器来完成对占位符的解析处理工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        //解析出来的sql
        String parseSql = genericTokenParser.parse(sql);
        //#{}里面解析出来的参数名称
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();

        BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
        return boundSql;

    }

}
测试
public class User {

  private Integer  id;
  private String username;
  private String password;
  private Date birthday;
}

public static void main(String[] args) throws PropertyVetoException, DocumentException, IllegalAccessException, IntrospectionException, InstantiationException, SQLException, InvocationTargetException, NoSuchFieldException {
    InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    System.err.println(inputStream);
    SqlSessionFactoryBuilder factoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sessionFactory = factoryBuilder.build(inputStream);

    User user = new User();
    user.setId(1);
    user.setUsername("lucy");
    User userResult = sessionFactory.openSqlSession().selectOne("com.liu.me.mapper.UserMapper.selectOne", user);
    System.err.println(userResult);

   List<User>  userList = sessionFactory.openSqlSession().selectList("com.liu.me.mapper.UserMapper.selectList", null);
    System.err.println(userList);

}
SqlSession 中增加getMapper
public interface SqlSession {
    /**
     *
     * @param statementId
     * @param params
     * @param <E>
     * @return
     */
   <E> List<E>  selectList(String statementId,Object...params) throws SQLException, InvocationTargetException, IntrospectionException, InstantiationException, IllegalAccessException, NoSuchFieldException;

    /**
     *
     * @param statementId
     * @param params

     * @return
     */
   <T>  T  selectOne(String statementId,Object...params) throws SQLException, IntrospectionException, InstantiationException, IllegalAccessException, NoSuchFieldException, InvocationTargetException;


   <T> T getMapper(Class<T> mapperClass);

}
DefaultSqlSession 中增加getMapper
 @Override
    public <T> T getMapper(Class<T> mapperClass) {
        T t =(T) Proxy.newProxyInstance(mapperClass.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                //获取方法名
                String methodName = method.getName();

                //获取namespace
                String className = method.getDeclaringClass().getName();

                String statementId = className+"."+methodName;

                //判断是否有泛型
                Type type = method.getGenericReturnType();

                if(type instanceof  ParameterizedType){
                    return  selectList(statementId, args);
                }



                return selectOne(statementId, args);
            }
        });
        return t;
    }
森林森
关注
专栏目录
Java精进-手写持久层框架
「 虚幻私塾」
08-20 406
本文适合有一定java基础的同学，通过自定义持久层框架，可以更加清楚常用的mybatis等开源框架的原理。我们新建一个sqlMapConfig.xml，定义数据源信息、并且增加两个sql语句，parameterType为sql执行参数，resultType为方法返回实体。select>select>现在xml文件数据库信息也有了，sql语句定义也有了，还有什么问题呢？我们实际中对sql的操作会涉及到不同的表，所以我们改进一下，把每个表的sql语句单独放在一个xml里，这样结构更清晰就容易维护。
Mybatis（一）：手写一套持久层框架
潘潘和他的朋友们
11-16 925
Mybatis（一）：手写一套持久层框架 作者 ： 潘潘 未来半年，有幸与导师们一起学习交流，趁这个机会，把所学所感记录下来。 「封面图」 自毕业以后，自己先创业后上班，浮沉了近8年，内心着实焦躁，虽一直是走科班路线，但在技术道路上却始终没静下心来研究、思考、梳理，机会来了，便抓牢。 希望自己记录下来的知识内容，对后来的学习之人，能有些许帮助。 对文章内容有任何建议或意见，或对互联网开发有希望交流学习，或单纯热爱生活，都欢迎随时微信我：panshenlian。 第一个系列的文章主要围绕「架构师
手写类mybatis持久层-2
小城我家
06-22 160
me-battis me-persistent 自定义持久化 me-batis-demo 测试类 接口与配置文件 package com.liu.me.mapper; import com.liu.me.entity.User; import javax.jws.soap.SOAPBinding; import java.util.List; /** * @Description * @ClassName UserMapper * @Author 刘楠 * @date 2020.06.19
一.手写持久层框架
weixin_40947906的博客
11-26 342
手写自定义持久层框架 public static void main(String[] args) { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null; try { Class.forName("com.mysql.jdbc.Driver");
自定义持久层MyBatis框架
cyd_0619的博客
11-06 210
一、自定义持久层MyBatis框架 1.1. 分析JDBC操作的问题 public class JDBCTest { public static void main(String[] args) throws Exception { Connection connection = null; PreparedStatement preparedStatement = null; ResultSet resultSet = null;
手写mybatis框架源码由浅入深
01-03
手写mybatis框架源码 不借助其他任何框架，从最底层开始着手，用最简单的代码，将mybatis的底层框架，手写出来，让你对mybatis有一个更加深刻和直观的理解 详见：...
手写mybatis
12-07
在Java开发中，Mybatis是一个广泛应用的持久层框架，它简化了JDBC的繁琐过程，提供了灵活的SQL映射和对象关系映射功能。本篇文章将深入探讨如何手写Mybatis的核心功能，包括基础的数据库访问、XML映射文件解析以及...
手写Mybatis自动填充插件
最新发布
03-14
Mybatis 是一个流行的 Java 持久层框架，它简化了数据库操作，使得开发者能够更加专注于 SQL 查询本身，而不是数据库连接管理和结果集处理。而“手写Mybatis自动填充插件”则是为了进一步提高开发效率，减少手动编写...
手写mybatis实现查询所有操作
01-28
MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。在本文中，我们将深入探讨如何手写MyBatis实现查询所有操作，以加深对其工作原理的理解。 首先，我们需要理解MyBatis的核心组件。MyBatis...
Java 面试八股文2023：MyBatis 持久层框架深入理解
MyBatis 是一款基于 Java 的持久层框架，它通过 XML 或注解的方式将对象和 SQL 语句进行映射，提供了简洁、灵活的数据访问方式。 ## 1.2 MyBatis 与 Hibernate 的区别 | MyBatis | Hibernate | |------------------...
手写一个简单的持久层框架（持续更新）
FDXCG_X的博客
05-29 221
一.JDBC的问题分析 1.数据库配置信息存在硬编码的问题 - 解决办法：采用配置文件的方式 2.频繁创建释放数据库连接 - 解决办法：采用连接池的方式 3.sql语句、设置参数、获取结果集参数均存在硬编码的问题 - 解决办法：采用配置文件的方式 4.手动封装返回结果，较为繁琐 - 解决办法：反射、内省 二.自定义持久层框架设计思路 使用端：(项目)：引入自定义持久层框架的jar包 提供两部分配置信息：数据库配置信息、sql配置信息：sql语句、参数类型、返回值类型 使用配置文件来提供者两部分配置信息
[MyBatis学习笔记] 一、仿造Mybatis实现一个简单的自定义持久层框架
Gavin
04-03 234
仿造Mybatis实现一个简单的自定义持久层框架
手写自定义简单持久层框架
叶存菜鸟博客
05-09 366
一、 JDBC问题分析 上代码 package com.lg; import com.mysql.jdbc.PreparedStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.util.ArrayList; import java...
手写ORM持久层框架（转）
weixin_33892359的博客
05-09 109
工程结构： 本文测试的数据库为： 其中student的表结构为： 表数据： 配置文件 DB2.properties driver=com.mysql.jdbc.Driver url=jdbc\:mysql\://127.0.0.1\:3306/test user=root password=123456 usingDB=mysql srcPath...
模仿与学习MyBatis - 实现自己的ORM层框架
陀氏
12-05 3319
目录陆续新增中，敬请期待 第一版 综述：MyBatis核心功能 DataSource与Session xml配置的解析 SessionFactory与Session Mapper与动态代理 注解与Session：sql语句 注解与Session：返回值映射 vxml配置的解析：返回值映射 第二版 暂无 前言对于MyBatis，前前后后接触了有一段时间了。最初是懵懵懂懂的，听说它是可以直接将sq
Mybatis——持久层框架
胖虎虎
07-11 2423
目录MyBatis01 简介1.1 什么是Mybatis1.2 持久化1.3 持久层1.4 为什么需要MyBatis02 第一个Mybatis程序2.1 搭建环境2.2 创建一个模块2.3 编写代码2.4 注意点03 CRUD3.1 namespace3.2 select3.3 insert3.4 update3.5 delete3.6 分析错误3.7 万能的Map3.8 思考题3.9 注意点04 配置解析4.1 核心配置4.2 环境配置（environments）4.3 属性（properties）4.4
自己实现一个简单的Mybatis框架
bw_yyziq的博客
03-11 2529
接上一篇自己写一个简单的Struts框架（3）开发环境： win10，jdk1.8，tomcat9，mysql，MyEclipse写一个简单的与数据库进行交互的框架，集成简单的打开关闭数据库，增删改查的功能。还有OR-Mapping的功能，使框架能够实现把对对象的CRUD操作映射到数据库表中，并用代理的方式实现懒加载的功能。SimpleController工程目录： 抽象类BaseDao抽象类Bas
基于mybatis封装的持久层。目前只完美支持mysql
akey1012的博客
02-07 1969
此框架只是为了解决mybatis少写xml和sql。 链接地址点击打开链接 如果这里面的满足不了你的需求，你可以用mybatis的MapperScannerConfigurer 继续原生使用mybatis 集成步骤 1 配置sqlSessionFactory里的mapperLocations,第二个value内容必须写，复制就行          
Mybatis的简单模仿实现
小老弟的博客
11-02 1006
通过网上的各种资源，结合自身，模仿出Mybatis的简单实现，下面是主要代码：项目是一个普通Java项目，只要导入数据库的Jar包就行（我使用的是Mysql） 其实也就是底层jdbc的实现，底层查询数据库基本就是通过给一个查询语句，使用原生的jdbc实现来查询出结果，其中主要的五个步骤是： 不多说，直接上代码： 项目结构： package com.lyh; import java...
手写实现mybatis与底层原理深度剖析
MyBatis 是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的XML或注解用于配置和原始映射，将接口和Java的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值