自定义持久层框架

最新推荐文章于 2021-06-25 09:55:30 发布
最新推荐文章于 2021-06-25 09:55:30 发布
阅读量130 收藏
点赞数 2
分类专栏： 持久层框架设计实现及Mybatis源码分析 文章标签： java 后端 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40977467/article/details/116562861
版权

DEMO自定义持久层框架的增删改查

自定义持久层框架的设计思路

使用端引入自定义持久层框架jar包，定义自定义持久层框架本身就是对JDBC代码进行封装，去解决或者规避原生JDBC在使用中的一些问题。

JDBC问题分析以及在自定义框架的解决方式

JDBC问题分析：

  1. 数据库配置信息存在硬编码问题
  2. 频繁创建和释放数据库链接
  3. SQL语句，设置参数，获取结果集参数存在硬编码问题
  4. 手动封装结果集较为繁琐

解决方式：

  1. 使用配置文件配置数据库
  2. 使用链接池
  3. 使用映射配置文件
  4. 反射，内省

整体流程

在这里插入图片描述

导包：

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.17</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</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>

创建核心配置文件sqlMapConfig.xml以及映射配置文件UserMapper.xml

sqlMapConfig.xml:

<configuration>
    <!--数据库配置信息-->
    <dataSource>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///localbase1"></property>
        <property name="user" value="root"></property>
        <property name="password" value="0000"></property>
    </dataSource>

    <!--存放mapper.xml的全路径-->
    <mapper resource="usermapper.xml"></mapper>
</configuration>`

UserMapper.xml:

<mapper namespace="com.lagou.dao.IUserDao">
    <select id="findAll" resultType="com.lagou.pojo.User" >
        select * from user
    </select>
    <select id="findByCondition" resultType="com.lagou.pojo.User" paramterType="com.lagou.pojo.User">
        select * from user where id = #{id} and username = #{username}
    </select>
    <insert id="addUser" paramterType="com.lagou.pojo.User">
        insert into user  values (#{id},#{username},#{password},#{birthday})
    </insert>
    <update id="updateUser" paramterType="com.lagou.pojo.User">
        update user set username = #{username} ,password = #{password}, birthday = #{birthday}
        where id = #{id}
    </update>
    <delete id="deleteUser" paramterType="java.lang.Integer">
        delete from user where id = #{id}
    </delete>
</mapper>

创建Resources类，添加getResourcesAsStream(String path)方法，根据配置文件路径将配置文件加载成字节输入流

public class Resources {
    //根据配置文件的路径，将配置文件加载成字节流
    public static InputStream getResourceAsStream(String path){
        InputStream resourceAsStream = Resources.class.getClassLoader().getResourceAsStream(path);
        return resourceAsStream;
    }
}

创建两个容器对象类，用来存放配置文件解析出来的内容。

核心配置类Configuration

存放sqlMapConfig.xml解析出来的内容，具体如下

public class Configuration {

    private DataSource dataSource;

    /*
    * key:statementId
    * value:mappedStatement对象
    * */
    Map<String,MappedStatement> mappedStatementMap = new HashMap<>();

    public DataSource getDataSource() {
        return dataSource;
    }

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

    public Map<String, MappedStatement> getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }
}

映射配置类MappedStatement

存放mapper.xml解析出来的内容

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

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

    public String getSql() {
        return sql;
    }

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

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }
}

创建SqlSessionFactoryBuilder解析配置文件：dom4j

创建SqlSessionFactoryBuilder类以及build(InputStream in)

  1. 使用dom4j解析配置文件，将配置文件内容封装到容器上面的两个对象中
  2. 创建SqlSessionFactory对象；生产SqlSession

SqlSessionFactoryBuilder:

public class SqlSessionFactoryBuilder {

    public SqlSessionFactory build(InputStream in) throws PropertyVetoException, DocumentException {
        //使用dom4j解析配置文件，将解析出来的内容封装到Configuration中
        XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
        Configuration configuration = xmlConfigBuilder.parseConfig(in);

        //创建SqlSessionFactory对象
        DefaultSqlSessionFactory defaultSqlSessionFactory = new DefaultSqlSessionFactory(configuration);
        return defaultSqlSessionFactory;
    }
}

XMLConfigBuilder 解析核心配置文件

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);
        //<configuration>
        Element rootElement = document.getRootElement();
        List<Element> 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("user"));
        comboPooledDataSource.setPassword(properties.getProperty("password"));
        configuration.setDataSource(comboPooledDataSource);

        //mapper.xml解析：拿到路径--字节输入流--dom4j进行解析
        List<Element> mapperlist = rootElement.selectNodes("//mapper");
        for (Element element : mapperlist) {
            String mapperPath = element.attributeValue("resource");
            InputStream resourceAsStream = Resources.getResourceAsStream(mapperPath);
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
            xmlMapperBuilder.parse(resourceAsStream);
        }
        return configuration;
    }
}

XMLMapperBuilder解析映射配置文件

public class XMLMapperBuilder {
    private Configuration configuration;

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

    public void parse(InputStream in) throws DocumentException {
        Document document = new SAXReader().read(in);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> list = rootElement.selectNodes("//select|//delete|//update|//insert");
        for (Element element : list) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String paramterType = element.attributeValue("paramterType");
            String sqlTest = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setResultType(resultType);
            mappedStatement.setParamterType(paramterType);
            mappedStatement.setSql(sqlTest);
            String key = namespace+"."+id;
            configuration.getMappedStatementMap().put(key,mappedStatement);
        }
    }
}

创建SqlSessionFactory接口及实现类DefaultSqlSessionFactory

通过openSession()方法生产SqlSession

public interface SqlSessionFactory {
    public SqlSession openSession();
}
public class DefaultSqlSessionFactory implements SqlSessionFactory{

    private Configuration configuration;

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

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

创建SqlSession接口及实现类DefaultSession

	定义对数据库的Crud操作，以及代理方法getMapper()	

public interface SqlSession {
    //查询所有
    public <E> List<E> selectList(String statementid, Object... params) throws Exception;

    //查询单个
    public <T> T selectOne(String statementid, Object... params) throws Exception;

    //为DAO接口生成代理实现类
    public <T> T getMapper(Class<?> mapperClass);

    public Boolean except(String statementId, Object[] args) throws Exception;
}

public class DefaultSqlSession implements SqlSession {

    private Configuration configuration;

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

    @Override
    public <E> List<E> selectList(String statementid,Object... params) throws Exception {
        //完成对simpleExecutor里的query方法的调用
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementid);
        List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);
        return (List<E>) list;
    }

    @Override
    public <T> T selectOne(String statementid, Object... params) throws Exception {
        List<Object> objects = selectList(statementid,params);
        if(objects.size()==1){
            return (T) objects.get(0);
        }else{
            throw new RuntimeException("查询结果为空或者返回结果过多");
        }
    }

    @Override
    public <T> T getMapper(Class<?> mapperClass) {
        //使用JDK动态代理为DAO接口生成代理实现类
        Object proxyInstance = 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();
                //获取statementId
                String statementId = className+"."+methodName;

                Type genericReturnType = method.getGenericReturnType();
                Class<?> returnType = method.getReturnType();
                if(returnType == List.class){
                    System.out.println("返回类型为：list");
                }
                //判断是否为增删改方法
                if(methodName.contains("delete")||methodName.contains("update")||methodName.contains("insert")||methodName.contains("add")){
                    return except(statementId,args);
                }
                //泛型类型参数化
                if(genericReturnType instanceof ParameterizedType){
                    List<Object> objects = selectList(statementId, args);
                    return objects;
                }
                return selectOne(statementId,args);
            }
        });
        return (T) proxyInstance;
    }

    @Override
    public Boolean except(String statementId, Object[] args) throws Exception {
        //将要去完成对simpleExecutor里的executeUpdate方法的调用
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        return  simpleExecutor.except(configuration, mappedStatement, args);
    }
}

创建Executor执行器接口及实现类SimpleExecutor

public interface Executor {

    public <E> List<E>
    query(Configuration configuration, MappedStatement mappedStatement,Object... params) throws SQLException, Exception;

    public boolean except(Configuration configuration,MappedStatement mappedStatement,Object... params)throws Exception;
}

public class SimpleExecutor implements Executor {
    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
        //1.注册驱动，获取链接
        Connection connection = configuration.getDataSource().getConnection();
        //2.获取sql语句,转换sql语句,转换的过程中还需要对#{}中的值进行解析存储
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        //3.获取预处理对象
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
        //4.设置参数
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        String paramterType = mappedStatement.getParamterType();
        Class<?> parameterTypeClass = getClassType(paramterType);
        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(params[0]);

            preparedStatement.setObject(i+1,o);
        }
        //5.执行SQL
        ResultSet resultSet = preparedStatement.executeQuery();
        String resultType = mappedStatement.getResultType();
        Class<?> resultTypeClass = getClassType(resultType);
       // = resultTypeClass.newInstance();
        ArrayList<Object> results = new ArrayList<>();
        //6.封装返回结果集
        while(resultSet.next()){
            Object o1 = resultTypeClass.newInstance();
            //去除resultSet中的元数据 ResultSetMetaData元数据
           ResultSetMetaData metaData = resultSet.getMetaData();

            int columnCount = metaData.getColumnCount();
            for (int i = 1; i <= columnCount; i++) {
               //字段名
               String columnName = metaData.getColumnName(i);
               //字段值
               Object value = resultSet.getObject(columnName);
               //使用反射或者内省根据数据库表和实体的对应关系，完成封装，PropertyDescriptor类是内省库中的类
               PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
               Method readMethod = propertyDescriptor.getWriteMethod();
               readMethod.invoke(o1,value);
           }
            results.add(o1);
        }

        return (List<E>) results;
        //return new ArrayList<>();
    }

    /**增删改
     *
     * @param configuration
     * @param mappedStatement
     * @param params
     * @return
     * @throws Exception
     */
    @Override
    public boolean except(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
        //1.注册驱动，获取链接
        Connection connection = configuration.getDataSource().getConnection();
        //2.获取sql语句,转换sql语句,转换的过程中还需要对#{}中的值进行解析存储
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        //3.获取预处理对象
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());
        //获取参数类型
        String parameterType = mappedStatement.getParamterType();
        Class<?> paramClassType = getClassType(parameterType);

        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        if (parameterMappingList.size()==1){
            preparedStatement.setObject(1,params[0]);
        }else{
            for (int i = 0; i < parameterMappingList.size(); i++) {
                ParameterMapping parameterMapping = parameterMappingList.get(i);
                String content = parameterMapping.getContent();
                Field declaredField = paramClassType.getDeclaredField(content);
                declaredField.setAccessible(true);
                Object o = declaredField.get(params[0]);
                preparedStatement.setObject(i+1,o);
            }
        }

        return preparedStatement.executeUpdate()>0;
    }

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

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

        BoundSql boundSql = new BoundSql(genericsql,parameterMappings);
        return boundSql;
    }
}

代码地址：自定义持久层框架DEMO

思维导图，验证及讲解视频地址：思维导图及验证讲解视频

痛冕
关注
专栏目录
java 自定义持久层框架代码
10-18
在Java开发中，自定义持久层框架是提升项目可维护性和灵活性的重要手段。这个自定义框架结合了Mybatis的部分功能，同时引入了多种设计模式，如构建者模式、工厂模式和代理模式，以实现更高效、更灵活的数据访问操作...
Mybatis系列教程自定义持久层框架共15页.pdf.z
11-19
本教程旨在深入解析Mybatis的自定义持久层框架，帮助开发者更好地理解和掌握其核心功能，从而实现高效的数据访问。 在Mybatis中，自定义持久层框架意味着开发者可以根据自身项目的特性和需求对Mybatis进行扩展，如...
自定义持久层框架，在查询基础上，完善新增，删除，修改。
weixin_43960071的博客
03-15 178
自定义持久层框架，在查询基础上，完善新增，删除，修改。 自定义持久层框架实现大致思路。 在原有的基础上要注意的事项； 1.之前xml文件中的查询标签都是，因此需要把update，insert，delete标签也加上 xml文件 <mapper namespace="com.lagou.dao.IUserDao"> <!--sql的唯一标识：namespace.id来组成 ： statementId--> <select id="findAll" result
一、自定义持久层框架
u013131379的博客
03-01 147
1. JDBC问题分析： 1.1 加载驱动获取连接部分代码： （1）数据库配置信息存在硬编码 -->配置文件 （2）频繁创建释放数据库连接-->连接池 1.2 sql语句部分代码： (1).设置参数获取结果集均存在硬编码问题-->配置文件 1.3 封装返回结果代码： 手动封装，较为繁琐-->反射，内省 2. 自定义持久层框架设计思路（对以上JDBC问题进行规避） 2.1 使用端：（项目）： 1.引入2.2的...
Java进阶之路-自定义持久层框架
程序员yqy的博客
11-05 610
早期实现持久层使用JDBC操作即可完成数据层的操作，接触过JDBC的同学应该不陌生，那么既然JDBC已经能够完成数据库的操作，为什么还会出现各种持久层框架呢?有新框架出现说明JDBC本身还是存在一些问题,今天让我们来自定义一个持久层框架吧!
mybatis第一阶段自定义持久层框架-作业
qq_22160985的博客
09-14 294
@常柏俭-mybatis第一阶段自定义持久层框架-作业 一 简答 1、Mybatis动态sql是做什么的？都有哪些动态sql？简述一下动态sql的执行原理？ 执行原理为使用OGNL从sql参数中计算表达式的值，根据表达式的值动态拼接sql,完成动态sql功能 使用boundSql类，封装mybatis最终产生的sql,包括sql语句，参数，参数源数据等参数 1 XMLConfigBuilder 解析mybatis中configLocation属性中的全局xml文件，内部会使用XMLMapperBuilde
自定义持久层框架和mybatis源码分析
qq_44959631的博客
04-13 166
自定义持久层框架和mybatis源码分析 JDBC问题分析： 1.数据库配置信息存在硬编码（修改源代码再打包部署） 2.频繁创建释放数据库连接 3.手动封装结果集 繁琐 自定义持久层框架： 1.创建Persistence IPersistence两个模块 Persistence是自定义持久层框架的具体实现。 IPersistence是用户端存放sqlMapConfig.xml和mapper.xml端。 2.IPersistence编写 1.sqlMapConfig.xml配置 <configurati
Mybatis自定义持久层框架
xhuiting的博客
09-07 298
自定义持久层框架本质就是对JDBC代码进行了封装，下面我们结合test的模块一起进行详细解说： 首先，在test模块编写配置文件，主要包括数据源和sql配置两部分： Test模块通过 “Resources.getResourceAsStream”加载配置文件“SqlMapConfig.xml”的路径，该配置文件中已包含sql配置文件的路径“UserMapper.xml”。 持久层框架中，Resources 类的getResourceAsStream方法，会根据配置文件的路径，加载配置文件成字节输入
学习笔记_自定义持久层框架
haxihaxihehe的博客
06-25 111
剖析JDBC存在问题，梳理自定义持久层框架需求----解决JDBC存在的问题
[由零开始] 二、手写Mybatis-自定义持久层框架思路分析
MrSoon的博客
04-22 364
[由0开始手写Mybatis] 二、自定义持久层框架思路分析自定义持久层框架思路分析自定义持久层框架使用设计分析 自定义持久层框架思路分析 自定义持久层框架 本质上就是对JDBC的代码封装 在封装的时候解决或规避我们上一章分析出的问题 自定义持久层框架使用设计分析 首先我们想要自定义框架供使用者使用 我们思考的问题就是要从使用者的角度出发 使用者(项目): 引入我们自定义的持久层框架的jar包(目...
mybatis雏形之自定义持久层框架
11-05
接触过JDBC的同学应该不陌生，那么既然JDBC已经能够完成数据库的操作，为什么还...有新框架出现说明JDBC本身还是存在一些问题, 针对jdbc存在的问题 ，通过学习自定义持久层框架能帮助我们更好的理解和学习mybatis的原理
自定义持久层框架开源架构源码2021.pdf
04-27
自定义持久层框架开源架构源码2021.pdf 这篇文章将详细介绍自定义持久层框架的开源架构源码，通过Mybatis框架来实现数据库持久层的操作。本文将从 JDBC 的基本概念开始，逐步介绍如何使用 Mybatis 框架来实现数据库...
java自定义持久层框架
07-30
自定义持久层框架
Mybatis插件
qq_40977467的博客
05-17 2599
Mybatis插件 插件简介 一般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者自行拓展。这样的好处是显而易见的，一是增加了框架的灵活性。二是开发者可以结合实际需求，对框架进行拓展，使其能够更好的工作。以MyBatis为例，我们可基于MyBatis插件机制实现分页、分表，监控等功能。由于插件和业务 无关，业务也无法感知插件的存在。因此可以无感植入插件，在无形中增强功能 Mybatis插件介绍 Mybatis作为一个应用广泛的优秀的ORM开源框架，这个框架具有强大的灵活性，在四大组件(Executo
JDBC步骤及实现流程
qq_40977467的博客
05-13 2151
JDBC具体步骤及实现流程 Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。 加载数据库驱动 在连接数据库之前，首先要加载想要连接的数据库的驱动加载到JVM，这通过java.lang.Class类的静态方法forName(String className)实现。 Cl
Mybatis通用mapper
qq_40977467的博客
05-17 1307
Mybatis通用mapper 什么是通用Mapper 通用Mapper就是为了解决单表增删改查，基于Mybatis的插件机制。开发人员不需要编写SQL,不需要在DAO中增加方法，只要写好实体类，就能支持相应的增删改查方法 如何使用 首先在maven项目，在pom.xml中引入mapper的依赖 <dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper</artifactId> &l
Mybatis-Plus学习笔记(二)
qq_40977467的博客
05-17 384
Mybatis-Plus学习笔记(二) 乐观锁插件 主要适用场景 **意图：**当要更新一条记录的时候，希望这条记录没有被别人更新 乐观锁实现方式： 取出记录时，获取当前version 更新时，带上这个version 执行更新时， set version = newVersion where version = oldVersion 如果version不对，就更新失败 插件配置 Spring <bean class="com.baomidou.mybatisplus.extension.plugi
Mybatis-Plus学习笔记(一)
qq_40977467的博客
05-17 383
Mybatis-Plus Mybatis-Plus概念 MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 Mybatis-Plus介绍 https://mp.baomidou.com/或https://mp.baomidou.com/ 特性 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作 强大的 CRUD 操作：内置
基于jdbc实现自定义持久层框架
最新发布
07-16
基于JDBC实现自定义持久层框架可以分为以下几个步骤： 1. 设计数据访问接口：首先，你需要定义数据访问接口，包括插入、更新、删除和查询等操作的方法。这些方法应该是通用的，可适用于不同的实体类。 2. 编写实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值