实现简单的MyBatis框架

最新推荐文章于 2023-04-05 11:18:43 发布
最新推荐文章于 2023-04-05 11:18:43 发布
阅读量264 收藏 2
点赞数 1
分类专栏： MyBatis 文章标签： mybatis orm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GrayGo/article/details/116954886
版权

实现简单的MyBatis框架

一、传统JDBC存在的问题与解决思路

首先我们要知道为什么我们需要引入向MyBatis这样的ORM框架（传统JDBC访问存在的问题），以及怎样才能解决传统所发现的问题（实现简单的ORM框架）

传统JDBC存在的问题

简单的JDBC操作
上图是一个简单的原生JDBC操作，我们不难发现存在以下问题：

  1. 数据库连接创建、释放频繁造成系统资源浪费，从⽽影响系统性能
  2. sql语句在代码中硬编码，造成代码不易维护，实际应⽤中sql变化的可能较⼤，sql变动需要改变java代码。
  3. 使⽤preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不⼀定，可多可少，修改sql还要修改代码，系统不易维护。
  4. 对结果集解析存在硬编码(查询列名)，sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析⽐较⽅便

解决思路

  1. 频繁创建/释放资源，可以考虑使用如线程池相似的概念（数据库连接池）
  2. sql语句不硬编码在java代码中，实现sql与java业务代码解耦，可放在其它文件（xml，或其它java文件），且可动态添加参数（使用集合或pojo传递入参），并动态构建出sql
  3. 使⽤反射、内省等底层技术，⾃动将实体与表进⾏属性与字段的⾃动映射（可动态设置返回值）

二、实现简单的mybatis框架

流程图

大致流程

框架整体结构

项目结构

  1. config包为常用设置类
  2. enums包为常用枚举
  3. io包为读取文件（配置文件/映射文件）相关类
  4. pojo包为封装中间态/结果集
  5. sqlsession包中有sqlsession工厂类，对应工厂实例与执行器executor方法
  6. utils为常用工具类

三、详细流程讲解

调用方传递配置文件与映射文件路径

// 传递配置文件
InputStream inputStream = Resource.getResourceAsSteam("SqlMapConfig.xml");

SqlMapConfig.xml

<configuration>
    <!-- 数据源 -->
    <dataSource>
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver" ></property>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/blog?characterEncoding=utf-8&amp;serverTimezone=UTC" ></property>
        <property name="username" value="root" ></property>
        <property name="password" value="***" ></property>
    </dataSource>

    <!-- 加载配置文件无需加载两次 所以这里还需存放mapper.xml 的全路径 -->
    <mapper resource = "UserMapper.xml"></mapper>
</configuration>

UserMapper.xml

<mapper namespace = "dao.SysUserDAO">
    <select parameterType = "entity.SysUserEntity" id="queryById" resultType = "entity.SysUserEntity">
        SELECT * FROM sys_user WHERE id = #{id}
    </select>

    <select id="queryAll" resultType = "entity.SysUserEntity">
        SELECT * FROM sys_user
    </select>

    <select id="countAll" resultType = "java.lang.Integer">
        SELECT count(1) FROM sys_user
    </select>

    <insert parameterType = "entity.SysUserEntity" id="insertUser">
        INSERT INTO sys_user VALUES (#{id}, #{loginName}, #{password}, #{email}, #{phone}, #{headPhoto}, #{loginIp}, #{loginDate}, #{loginFlag}, #{motto}, #{createBy}, #{createDate}, #{updateBy}, #{updateDate}, #{remarks}, #{delFlag})
    </insert>

    <update parameterType = "entity.SysUserEntity" id="updateNameById">
        UPDATE sys_user SET login_name = #{loginName} WHERE id = #{id}
    </update>

    <delete parameterType = "entity.SysUserEntity" id="deleteById">
        DELETE FROM sys_user WHERE id = #{id}
    </delete>
</mapper>

解析配置文件

调用方调用SqlSessionFactoryBuilder 的build方法将输入流传入

// 传递配置文件
InputStream inputStream = Resource.getResourceAsSteam("SqlMapConfig.xml");
// 创建sqlSession
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

框架方的SqlSessionFactoryBuilder build 方法

public class SqlSessionFactoryBuilder {
    public SqlSessionFactory build(InputStream in) throws PropertyVetoException, DocumentException {
        // 1.使用dom4j解析配置文件，将解析结果封装至Configuration
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        // 2.创建sqlSessionFactory 工厂类：生产sqlsession会话对象（与数据库家交互的对象）工厂模式
        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return defaultSqlSessionFactory;
    }
}

com.gray.config.XMLConfigBuilder#parseConfig(解析配置文件与mapper文件并封装为Configuration对象)

public class XMLConfigBuilder {

    private Configuration configuration;

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

    /**
     * 使用dom4j将配置文件解析封装Configuration
     *
     * @param inputStream
     * @return
     */
    public Configuration parseConfig(InputStream inputStream) throws DocumentException, PropertyVetoException {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();

        // 基础配置信息读取/封装
        // 读取所有property 节点
        List<Element> propertyNodes = rootElement.selectNodes("//property");
        Properties properties = new Properties();
        for (Element element : propertyNodes) {
            String name = element.attributeValue(ElementAttributeValue.NAME.getAttributeValue());
            String value = element.attributeValue(ElementAttributeValue.VALUE.getAttributeValue());
            properties.setProperty(name, value);
        }
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setDriverClass(properties.getProperty(PropertiesProperty.DRIVER_CLASS.getProperty()));
        comboPooledDataSource.setJdbcUrl(properties.getProperty(PropertiesProperty.JDBC_URL.getProperty()));
        comboPooledDataSource.setUser(properties.getProperty(PropertiesProperty.USER_NAME.getProperty()));
        comboPooledDataSource.setPassword(properties.getProperty(PropertiesProperty.PASSWORD.getProperty()));
        configuration.setDataSource(comboPooledDataSource);

        // mapper文件读取
        // 读取所有mapper节点
        List<Element> mapperList = rootElement.selectNodes("//mapper");
        for (Element element : mapperList) {
            String mapperPath = element.attributeValue(ElementAttributeValue.RESOURCE.getAttributeValue());
            // 获取所有mapper配置文件路径并解析
            InputStream resourceAsSteam = Resource.getResourceAsSteam(mapperPath);
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsSteam);
        }
        return configuration;
    }

}

解析mapper文件

这里的statementId 十分重要，主要是为了确定唯一一条sql执行计划，通常使用mapper上的namespace + sql上的id确定

       String id = element.attributeValue(ElementAttributeValue.ID.getAttributeValue());
        String parameterType = element.attributeValue(ElementAttributeValue.PARAMETER_TYPE.getAttributeValue());
        String resultType = element.attributeValue(ElementAttributeValue.RESULT_TYPE.getAttributeValue());
        // 获取sql
        String elementName = element.getName();
        String sqlText = element.getTextTrim();
        DMLOperating dmlOperating = DMLOperating.sqlToOperating(sqlText);
        if (StringUtils.isBlank(sqlText) || dmlOperating == null || !elementName.toLowerCase().equals(dmlOperating.getOperating())) {
            throw new RuntimeException("标签类型与sql类型不一致");
        }
        MappedStatement mappedStatement = new MappedStatement();
        mappedStatement.setId(id);
        // 入参类型
        mappedStatement.setParameterType(parameterType);
        // 返回值类型
        mappedStatement.setResultType(resultType);
        // 所写入sql
        mappedStatement.setSql(sqlText);
        // dml 类型 select, insert等
        mappedStatement.setDmlOperating(dmlOperating);
        StringJoiner statementId = new StringJoiner(".");
        // statementId id 为 namespace与sql id 相结合唯一确定一个sql执行语句
        statementId.add(namespace).add(id);
        configuration.getMappedStatementMap().put(statementId.toString(), mappedStatement);

封装完成的Configuration 对象

@Data
public class Configuration implements Serializable {

    private DataSource dataSource;

    /**
     * 加载的映射对象，这样向下传递参数时就只用传递Configuration对象
     * key:Statement namespace + id
     * value：封装的MappedStatement
     */
    private Map<String, MappedStatement> mappedStatementMap = Maps.newHashMap();

}

Configuration 对象中的MappedStatement

@Data
public class MappedStatement implements Serializable {

    // id标识
    private String id;

    // 返回值类型
    private String resultType;

    // 参数值
    private String parameterType;

    // sql语句
    private String sql;

    // dml 类型
    private DMLOperating dmlOperating;

}

最后生成将生成的configuration 放入工厂实例中返回给调用端（第二步）

public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream in) throws PropertyVetoException, DocumentException {
        // 1.使用dom4j解析配置文件，将解析结果封装至Configuration
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        // 2.创建sqlSessionFactory 工厂类：生产sqlsession会话对象（与数据库家交互的对象）工厂模式
        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return defaultSqlSessionFactory;
    }
}

寻找对应sql计划

调用端获取到工厂后通过工厂生成sqlsession（sqlsession用于sql会话）

 // 创建sqlSession
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlsession = sqlSessionFactory.openSession();

openSession 其实就只是创建了一个sqlsession

@AllArgsConstructor
public class DefaultSqlSessionFactory implements SqlSessionFactory {

    private Configuration configuration;

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration);
    }
}

通过getmapper形式获取对应sql实例
先看看sqlsession中内容

public interface SqlSession {

    <E> List<E> selectList(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException;

    <E> E selectOne(String statementId, Object... params) throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException, NoSuchFieldException;

    void insert(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException;

    void update(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException;

    void delete(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException;

    <E> E getMapper(Class<?> mapperClass);

}

再来看看它的实现类DefaultSqlSession

@AllArgsConstructor
public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

    @Override
    public <E> List<E> selectList(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        List<Object> resultList = simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementId), params);
        return (List<E>) resultList;
    }

    @Override
    public <E> E selectOne(String statementId, Object... params) throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        List<Object> objects = selectList(statementId, params);
        if (objects.size() == 1) {
            return (E) objects.get(0);
        } else {
            throw new RuntimeException("查询结果为空/有多条");
        }
    }

    @Override
    public void insert(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementId), params);
    }

    @Override
    public void update(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementId), params);
    }

    @Override
    public void delete(String statementId, Object... params) throws ClassNotFoundException, SQLException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        simpleExecutor.query(configuration, configuration.getMappedStatementMap().get(statementId), params);
    }

    @Override
    public <E> E getMapper(Class<?> mapperClass) {
        // 使用JDK动态代理为DAO接口生成代理对象
        Object instance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                String methodName = method.getName();
                String className = method.getDeclaringClass().getName();
                String statementId = className + "." + methodName;
                MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
                if (mappedStatement == null) {
                    return null;
                }
                // 暂时只处理简单dml
                DMLOperating dmlOperating = mappedStatement.getDmlOperating();
                if (dmlOperating == null) {
                    return null;
                }
                switch (dmlOperating) {
                    case SELECT: {
                        Type genericExceptionTypes = method.getGenericReturnType();
                        if (genericExceptionTypes instanceof ParameterizedType) {
                            return selectList(statementId, args);
                        }
                        return selectOne(statementId, args);
                    }
                    case UPDATE: {
                        update(statementId, args);
                    }
                    case DELETE: {
                        delete(statementId, args);
                    }
                    case INSERT: {
                        insert(statementId, args);
                    }
                }
                return null;
            }
        });
        return (E) instance;
    }
}

这里主要要说下getmapper方法，调用端使用getmapper方法将本身的类（mapper接口）当做入参放入，之后mapper这里使用动态代理，当有当前对象执行对象方法时都会先执行getmapper中的invoke方法，这样就能实现动态根据当前方法的classname拼装出statementId 找出对应mappedStatement 来执行对应sql

执行sql

不管是执行到SqlSession 哪个方法最后都会执行到executor的query方法，在这里就会连接JDBC最后拼装sql执行sql

public class SimpleExecutor implements Executor {

    private static Pattern linePattern = Pattern.compile("_(\\w)");

    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... object) throws SQLException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        // 1.注册驱动，获取连接
        Connection connection = configuration.getDataSource().getConnection();

        // 2.获取sql 转换#{} 转换为 ?（?才能被jdbc识别）
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);

        // 3. 获取预处理对象
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());

        // 4.设置参数
        // 获取参数对象属性值
        if (StringUtils.isNotBlank(mappedStatement.getParameterType())) {
            Class<?> parameterTypeClass = Class.forName(mappedStatement.getParameterType());
            List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
            for (int i = 0; i < parameterMappingList.size(); i++) {
                ParameterMapping parameterMapping = parameterMappingList.get(i);
                String content = parameterMapping.getContent();
                // 使用反射获取实体对象的属性值
                Field declaredField = parameterTypeClass.getDeclaredField(content);
                declaredField.setAccessible(true);
                Object o = declaredField.get(object[0]);
                preparedStatement.setObject(i + 1, o);
            }
        }

        // 5.执行sql
        ResultSet resultSet = null;
        if (DMLOperating.executeQuery(mappedStatement.getDmlOperating())) {
            resultSet = preparedStatement.executeQuery();
        } else {
            preparedStatement.execute();
        }

        ArrayList<Object> objects = new ArrayList<>();
        // 6.封装返回结果
        // 获取返回值
        if (StringUtils.isNotBlank(mappedStatement.getResultType()) && resultSet != null) {
            Class<?> resultTypeClass = Class.forName(mappedStatement.getResultType());
            boolean isBaseType = isBaseType(resultTypeClass, false);
            while (resultSet.next()) {
                // 生成结果对象
                Object resultObject = null;
                if (!isBaseType) {
                    resultObject = resultTypeClass.newInstance();
                }
                // 取出原始数据(其中有字段名)
                ResultSetMetaData metaData = resultSet.getMetaData();
                for (int i = 1; i <= metaData.getColumnCount(); i++) {
                    // 字段名(i要从1开始)
                    String columnName = metaData.getColumnName(i);
                    // 获取字段值
                    Object columnValue = resultSet.getObject(columnName);
                    if (isBaseType) {
                        resultObject = handleBaseTypeObject(resultTypeClass, columnValue);
                    } else {
                        try {
                            // 使用反射/内省完成结果封装(转换驼峰)
                            PropertyDescriptor propertyDescriptor = new PropertyDescriptor(lineToHump(columnName), resultTypeClass);
                            Method writeMethod = propertyDescriptor.getWriteMethod();
                            // 将值设置带结果对象中
                            writeMethod.invoke(resultObject, columnValue);
                        } catch (Exception e) {
                            System.out.println(e);
                        }
                    }
                }
                objects.add(resultObject);
            }
        }
        return (List<E>) objects;
    }


    /**
     * 完成对#{} 解析
     * 1.#{} -> ？
     * 2.解析#{}中的值
     *
     * @param sql
     * @return
     */
    public BoundSql getBoundSql(String sql) {
        // 标记处理类：配置标记解析器完成对占位符的解析处理工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        // 解析出来的sql
        String parseSql = genericTokenParser.parse(sql);
        // #{} 解析出来的参数名称(属性名)
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        return new BoundSql(parseSql, parameterMappings);
    }

    /**
     * 下划线转驼峰
     *
     * @param str
     * @return
     */
    public static String lineToHump(String str) {
        str = str.toLowerCase();
        Matcher matcher = linePattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
        }
        matcher.appendTail(sb);
        return sb.toString();
    }


    /**
     * 判断对象属性是否是基本数据类型,包括是否包括string
     *
     * @param className
     * @param incString 是否包括string判断,如果为true就认为string也是基本数据类型
     * @return
     */
    public boolean isBaseType(Class className, boolean incString) {
        if (incString && className.equals(String.class)) {
            return true;
        }
        return className.equals(Integer.class) ||
                className.equals(int.class) ||
                className.equals(Byte.class) ||
                className.equals(byte.class) ||
                className.equals(Long.class) ||
                className.equals(long.class) ||
                className.equals(Double.class) ||
                className.equals(double.class) ||
                className.equals(Float.class) ||
                className.equals(float.class) ||
                className.equals(Character.class) ||
                className.equals(char.class) ||
                className.equals(Short.class) ||
                className.equals(short.class) ||
                className.equals(Boolean.class) ||
                className.equals(boolean.class);
    }

    public Object handleBaseTypeObject(Class<?> resultTypeClass, Object columnValue) {
        if ((resultTypeClass.equals(Integer.class) || resultTypeClass.equals(int.class)) && columnValue != null) {
            return Integer.valueOf(columnValue.toString());
        }
        return columnValue;
    }

}
GrayGo
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
6. 实现Mybatis框架
大头鱼
04-07 394
Mybatis框架源码实现 源码下载地址 创建一个mybatis框架，我们首先要做以下几件事 1.创建配置信息对应的实体类Configuration和MapperStatement，将配置信息提取出来时进行封装 2.创建SqlSessionFactory工厂类，加载配置信息 3.通过SqlSessionFactory对象创建SqlSession 4.通过SqlSession获取mapper接口的...
Mybatis框架详解（全）
swy2560666141的博客
02-21 7074
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis。
简单的mybatis框架实现
qq_35654259的博客
08-19 233
以查询部门表为例       部门表sql语句 /* Navicat MySQL Data Transfer Source Server : a Source Server Version : 50027 Source Host : localhost:3306 Source Database : erp Target Server Typ...
架构成长之路：透彻理解MyBatis设计思想及手写实现MyBaits框架
the shy
04-05 88
第二，在getMapper的获取过程中，我们看到了具体业务处理Handler的身影：MyMapperProxy，根据JDK动态代理的知识，我们知道，最终都是要回调Handler的invoke方法完成的。当invoke方法被调用时，我们根据调用的方法，进行反射，得到namespace以及对应的SQL，然后，我们把SQL交给sqlSession进行执行即可。第一，MyDefaultSqlSession持有执行器的引用，调用selectOne等方法，就是在调用执行器的query方法。query的JDBC实现。
mybatis框架
m0_64372028的博客
06-05 5789
mybatis框架
Mybatis框架
02-17
Mybatis框架是一个强大的、灵活的Java持久层框架，它的出现极大地简化了数据库操作与Java对象之间的映射工作。Mybatis的核心在于SQL映射文件和SqlSessionFactory，它将传统的JDBC代码封装起来，使得开发者可以专注于...
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
spring+spring mvc+mybatis框架整合实现超市货物管理系统
01-08
在本文中，我们将深入探讨如何使用JavaEE技术栈，特别是Spring、Spring MVC和MyBatis框架，来构建一个超市货物管理系统的实现。这个系统涵盖了基本的登录功能以及与MySQL数据库的交互，包括增删改查操作和分页显示。...
mybatis框架练习
11-01
Mybatis框架是一个强大的持久层框架，它允许开发者编写SQL映射文件来实现SQL与Java代码的分离，从而提高开发效率和代码的可维护性。这个"mybatis框架练习"资源显然是为初学者设计的，旨在帮助他们更好地理解和掌握...
mybatis实现简单例子
12-28
使用mybatis实现的一个简单例子，可以使初学者快速入门
【MyBatis教程】mybatis框架超全面详解总结
d586947的博客
01-18 9128
目录 一、什么是MyBatis 二、Mybatis相对JDBC有哪些优势 三、Mybatis框架的原理介绍 四、Mybatis全局配置文件 1.全局配置文件的类容和顺序 五、映射文件 1.输入映射parameterType 2.resultType结果映射 3.resultMap结果映射 六、Mybatis之传统Dao层的开发(该方式很少用) 1.开发环境准备： 2.需求分析： 3.代码实现 七、Mybatis之Mapper接口的开发方式 1.需求分析 2.Mapper开发代
mybatis精讲
04-05
1.讲解mybatis的完整实现案例2.讲解mybatis的核心配置文件和映射文件是怎样操作的3.讲解mybatis的动态sql
自己实现一个简单的Mybatis框架
bw_yyziq的博客
03-11 2500
接上一篇自己写一个简单的Struts框架（3）开发环境： win10，jdk1.8，tomcat9，mysql，MyEclipse写一个简单的与数据库进行交互的框架，集成简单的打开关闭数据库，增删改查的功能。还有OR-Mapping的功能，使框架能够实现把对对象的CRUD操作映射到数据库表中，并用代理的方式实现懒加载的功能。SimpleController工程目录： 抽象类BaseDao抽象类Bas
自定义实现Mybatis框架
m0_49747181的博客
07-31 159
文章目录前言一、Mybatis框架入门程序1.1、导入表和数据1.2、准备数据库环境、创建项目、添加依赖1.3、SqlMapConfig.xml配置1.4实体类1.5、编写UserDao接口和UserDao接口映射文件1.6、测试二、自定义实现Mybatis框架2.1、把刚才的入门程序复制一份出来2.2、自定义框架 环境准备2.3、把mybatis的依赖去掉，添加新的依赖2.4、修改测试类2.5自定义框架分析1.引入库2.读入数据总结 前言 本文分为两部分： 第一部分用mybatis写一个入门程序 第二
简易版 Mybatis 实现
小松de博客
03-30 121
1. JDBC 操作存在的问题 package com.study; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; /** * JDBC 测试 * @author xiaosong * @since 2021/03/26 */ public class JdbcTest { public st
Mybatis框架简单搭建(对数据实现增删改查操作)
qq_45729435的博客
01-06 655
Mybatis框架简单搭建(对数据实现增删改查操作)
仿MyBatis手写简易ORM框架 手写MyBatis
monetto咖啡小栈
09-29 829
https://github.com/monettoCoffee/YourBatis 190516注意: 仅支持查询, 不支持多参数传递查询, 不支持查询多个结果 更完善的ORM请参考:https://github.com/monettoCoffee/EELinker 基于动态代理实现。使用Idea社区版直接Open即可。需要配置Maven。 1.弱引用队列创建SqlSes...
手动实现一个简单的 MyBatis
qfzhaohan的博客
11-11 1194
（一）、创建 SqlSessionFactory 实例。 （二）、实例化过程，加载配置文件创建 Configuration 对象。 （三）、通过 factory 创建 SqlSession。 （四）、通过 SqlSession 获取 mapper 接口动态代理。 （五）、动态代理回调 SqlSession 中某查询方法。 （六）、SqlSession 将查询方法转发给 Executor。 （七）、Executor 基于 JDBC 访问数据库获取数据。 （八）、Executor 通过反...
手写实现mybatis框架
最新发布
07-28
手写实现MyBatis框架可以分为以下几个步骤： 1. 创建Maven工程并引入需要的依赖坐标。\[3\] 2. 编写Mybatis-config.xml配置文件，配置数据库连接信息、映射文件路径等。\[3\] 3. 创建XMLConfigBuilder类，用于解析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值