手写mybatis(一)：增删改查(CRUD)实现

最新推荐文章于 2024-08-03 17:05:14 发布
最新推荐文章于 2024-08-03 17:05:14 发布
阅读量198 收藏 1
点赞数
分类专栏： 自定义框架 文章标签： java 开发语言 后端 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45756124/article/details/121230142
版权

文末附有源码地址

博客为代码完成后才开始整理，展示的代码都是最终代码

介绍：

个人学习，代码写的不够好，有点乱
通过学习mybatis源码模拟实现Mybatis(在完善)
已实现：
crud（实现XML配置，注解配置写过一点，原理差不多不写了）、
事务、
数据库连接池、
动态sql(一部分，原理没问题了，以后有时间再完善)、
一级二级缓存

一、如何着手

我们从这段代码看起：

//1.读取配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory;
        factory = builder.build(in);
        //3.使用工厂生产SqlSession对象
        SqlSession session = factory.openSession(true);

        //SqlSession session = SessionUtil.getSession();
        //4.使用SqlSession创建Dao接口的代理对象
        IUserDao userDao = session.getMapper(IUserDao.class);
        //5.使用代理对象执行方法
      //  List<User> user = userDao.findAll();
        //User u = new User();
        //u.setSex("男");
        //User user = userDao.findById("41");
      //  List<User> user = userDao.findSome("%王%","男");
        List<User> user = userDao.findSomeOgnl(new User(105,"%王%",new Date(1920,11,23),null,"江西"));
       // userDao.insertUser(new User(105,"小q",new Date(1920,11,23),"男","江西"));
    //    userDao.deletebyId("49");
//        long time = System.currentTimeMillis();
//        java.sql.Date date = new java.sql.Date(time);
//        java.sql.Timestamp timestamp = new Timestamp(time);
        //userDao.update(new User(42,"小花k",timestamp,"女","江西"));
       // System.out.println(user);
        for(User u : user){
            System.out.println(u);
        }
        //6.释放资源
        //session.commit();
        session.close();

这段代码展示了如何调用使用mybaits执行sql，期间夹杂着我的一些测试用例。
具体流程我已经在注释上写的很清晰了。用工厂模式生产sqlsession,再创建代理对象。我们所需要做的是将这些类实现出来。

二、配置文件的读取

读取解析xml文件有许多方式如：DOM、DOM4J、SAX。本人使用的是dom4j。

  1. 主配置文件的读取
    首先来看一下mybatisXML配置：
<?xml version="1.0" encoding="UTF-8"?>
<!-- mybatis的主配置文件 -->
<configuration>
    <!-- 配置环境 -->
    <environments default="mysql">
        <!-- 配置mysql的环境-->
        <environment id="mysql">
            <!-- 配置事务的类型-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- 配置数据源（连接池） -->
            <dataSource type="POOLED">
                <!-- 配置连接数据库的4个基本信息 -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/eesy_mybatis?serverTimezone=GMT%2B8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value=""/>
            </dataSource>
        </environment>
    </environments>

    <!-- 指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件 -->
    <mappers>
        <mapper resource="com/baiye/dao/IUserDao.xml"/>
<!--        <mapper class="com.baiye.www.dao.IUserDao"/>-->
    </mappers>
</configuration>

我们要将其解析读取，下面是代码：

public static Configuration loadConfiguration(InputStream in) {
        Configuration config = new Configuration();
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(in);
            Element root = document.getRootElement();
            //xpath '//'表示在当先所选节点查找
            List dataSourceNode = root.selectNodes("//dataSource");
            String type = ((Element) dataSourceNode.get(0)).attributeValue("type");
            config.setDataSourceType(type);
            List nodes = root.selectNodes("//property");
            Iterator iterator = nodes.iterator();
            while (iterator.hasNext()) {
                Element element = (Element) iterator.next();
                String name = element.attributeValue("name");
                String value = element.attributeValue("value");
                if ("driver".equals(name)) {
                    config.setDriver(value);
                } else if ("url".equals(name)) {
                    config.setUrl(value);
                } else if ("username".equals(name)) {
                    config.setUsername(value);
                } else if ("password".equals(name)) {
                    config.setPassword(value);
                } else {
                    throw new RuntimeException("xml sql config error!");
                }
            }

            //mappers
            List mapperList = root.selectNodes("//mappers/mapper");
            Iterator mapperIterator = mapperList.iterator();
            Map<String, Mapper> mappers = new HashMap<>();
            while (mapperIterator.hasNext()) {
                Element element = (Element) mapperIterator.next();
                Attribute attribute = element.attribute("resource");
                if (attribute != null) {
                    //使用xml
                    String classPath = attribute.getValue();
                    Map<String, Mapper> mapper = loadMapperXMLConfiguration(classPath);
                    mappers.putAll(mapper);
                } else if (element.attribute("class") != null) {
                    //使用注解
                    String classPath = element.attribute("class").getValue();
                    Map<String, Mapper> mapper = loadMapperAnnotation(classPath);
                    mappers.putAll(mapper);
                } else {
                    throw new RuntimeException("xml mapper config error");
                }
            }
            config.setMappers(mappers);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("loadConfiguration error!");
        }

        if (config.getDataSourceType().equals("POOLED")) {
            config.setEnvironment(new Environment(null, null, new PooledDataSourceFactory(config).getDataSource()));
        } else if (config.getDataSourceType().equals("UNPOOLED")) {
            config.setEnvironment(new Environment(null, null, new UnpooledDataSourceFactory(config).getDataSource()));
        }
        return config;
    }
  1. mapper配置文件的读取
    配置文件如下：
<?xml version="1.0" encoding="UTF-8"?>
<mapper namespace="com.baiye.www.dao.IUserDao">
    <!--配置查询所有-->
    <select id="findById" resultType="com.baiye.www.domain.User" parameterType="Integer">
        select * from user where id= #{id}
    </select>

    <select id="findAll" resultType="com.baiye.www.domain.User">
        select * from user
    </select>

    <select id="findSome" resultType="com.baiye.www.domain.User">
        select * from `user` where username LIKE #{username} and sex = #{sex}
    </select>
    <select id="findSomeOgnl" resultType="com.baiye.www.domain.User" parameterType="com.baiye.www.domain.User">
        select * from `user` where username LIKE #{username} and username LIKE #{username}
        <if test="sex != null">
            and sex = #{sex}
        </if>
    </select>
    <insert id="insertUser" parameterType="com.baiye.www.domain.User">
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
    </insert>
    <delete id="deletebyId" parameterType="Integer">
        delete from user where id = #{id}
    </delete>
    <update id="update" parameterType="com.baiye.www.domain.User">
        update user set username=#{username},birthday=#{birthday},sex=#{sex} where id=#{id}
    </update>
</mapper>

代码如下，分别有读取注解配置的和读取xml配置的：

/**
     * 注解配置 根据传入的全限定类名封装mapper(sql,resultType)
     *
     * @param classPath
     * @return
     */
    private static Map<String, Mapper> loadMapperAnnotation(String classPath) {
        Map<String, Mapper> mappers = new HashMap<String, Mapper>();
        Mapper mapper = new Mapper();
        try {
            Class daoClass = Class.forName(classPath);
            Method[] methods = daoClass.getMethods();
            for (Method method : methods) {
                if (method.isAnnotationPresent(Select.class)) {
                    Select selectAnnotation = method.getAnnotation(Select.class);
                    String sql = selectAnnotation.value();
                    mapper.setSql(sql);
                    String methodName = method.getName();
                    Type type = method.getGenericReturnType();
                    //判断type是不是参数化的类型
                    if (type instanceof ParameterizedType) {
                        ParameterizedType ptype = (ParameterizedType) type;
                        Type[] types = ptype.getActualTypeArguments();
                        Class domainClass = (Class) types[0];
                        //获取domainClass的类名
                        String resultType = domainClass.getName();
                        mapper.setResultType(resultType);
                    }
                    String key = classPath + "." + methodName;
                    mappers.put(key, mapper);
                }
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return mappers;
    }


    /**
     * xml配置 根据传入的全限定类名封装mapper(sql,resultType)
     *
     * @param xmlPath
     * @return
     */
    private static Map<String, Mapper> private static Map<String, Mapper> loadMapperXMLConfiguration(String xmlPath) {
        Map<String, Mapper> mappers = new HashMap<String, Mapper>();
        InputStream in = null;
        try {
            in = Resources.getResourceAsStream(xmlPath);
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(in);
            Element root = document.getRootElement();
            String namespace = root.attributeValue("namespace");

            List selectNodes = root.selectNodes("//select");
            Map<String, Mapper> selectMappers = NodeToMapper(namespace,selectNodes, SqlCommandType.SELECT);

            List insertNodes = root.selectNodes("//insert");
            Map<String, Mapper> insertMappers = NodeToMapper(namespace,insertNodes, SqlCommandType.INSERT);

            List updateNodes = root.selectNodes("//update");
            Map<String, Mapper> updateMappers = NodeToMapper(namespace,updateNodes, SqlCommandType.UPDATE);


            List deleteNodes = root.selectNodes("//delete");
            Map<String, Mapper> deleteMappers =NodeToMapper(namespace,deleteNodes,SqlCommandType.DELETE);

            mappers.putAll(selectMappers);
            mappers.putAll(insertMappers);
            mappers.putAll(updateMappers);
            mappers.putAll(deleteMappers);
            in.close();


        } catch (Exception e) {
            e.printStackTrace();
        }

        return mappers;
    }

    private static Map<String, Mapper> NodeToMapper(String namespace, List list, SqlCommandType type){
        Map<String, Mapper> mappers = new HashMap<String, Mapper>();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Element element = (Element) iterator.next();
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String parameterType = element.attributeValue("parameterType");
            String resultMap = element.attributeValue("resultMap");
            String key = namespace + "." + id;
            String sql = element.getText();
            Mapper mapper = new Mapper(key,sql, element, resultType, parameterType, resultMap,type);
            mappers.put(key, mapper);
        }
        return mappers;
    }

标记Sql类型枚举类

public enum SqlCommandType {
    UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH
}

读取完成后我们将信息封装成Configuration类和Mapper类。

public class Configuration {
    protected Environment environment;
    private String dataSourceType;
    private String driver;
    private String url;
    private String username;
    private String password;
    private Cache perpetualCache = new PerpetualCache();
    private boolean enableCache;
    //全限定类名+方法名，mapper
    private Map<String, Mapper> mappers = new HashMap<String, Mapper>();
    ......
    }

public class Mapper {

    private String sql;
    private Element element;
    private String resultType;
    private String parameterType;
    private String resultMap;
    ......
    }

三、工厂类的创建

首先创建SqlSessionFactoryBuilder类，根据读取的配置文件创建工厂，支持多种参数。

public class SqlSessionFactoryBuilder {
    private SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        Configuration configuration = XMLConfigBuilder.loadConfiguration(inputStream);
        return build(configuration);
    }

    public SqlSessionFactory build(InputStream inputStream) {
        return build(inputStream, null, null);
    }

    public SqlSessionFactory build(Configuration configuration) {

        return new DefaultSqlSessionFactory(configuration);
    }
}

根据mybatis源码的设计，我们得分别创建SqlSessionFactory和SqlSession接口，并实现对应的默认实现类：DefaultSqlSession、DefaultSqlSession。

public interface SqlSessionFactory {
    SqlSession openSession();

    SqlSession openSession(boolean autoCommit);
}

public interface SqlSession {

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

    <T> T selectOne(String mapperName, Object[] parameter);

    <T> List<T> selectList(String mapperName, Object[] parameter);

    int insert(String mapperName, Object[] parameter);

    int update(String mapperName, Object[] parameter);

    int delete(String mapperName, Object[] parameter);

    void clearCache();

    /**
     * 若未提交直接关闭，会回滚
     */
    void close();

    void rollback();

    void commit();

}

DefaultSqlSession中包含配置涉及到事务等内容：

public class DefaultSqlSession implements SqlSession {
    private final boolean autoCommit;
    protected Configuration configuration;
    private Executor executor;
    private boolean dirty;
    .....
    }

四、代理对象

下面这个方法为关键：

@Override
    public <T> T getMapper(Class<T> daoInterfaceClass) {
        return (T) Proxy.newProxyInstance(daoInterfaceClass.getClassLoader(), new Class[]{daoInterfaceClass}, new MapperProxy(this));
    }

这个方法得到代理对象。

下面为MapperProxy类：

package com.baiye.www.mybaits.proxy;

import com.baiye.www.mybaits.annotation.Param;
import com.baiye.www.mybaits.sqlsession.SqlSession;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: baiye
 * @Date: 2021/07/13/16:54
 * @Description:
 */
public class MapperProxy implements InvocationHandler {
    //map的key是全限定类名+方法名
    //private Map<String, Mapper> mappers;
    private SqlSession sqlSession;


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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(method.getDeclaringClass().getName() + "." + method.getName());
        //最终还是将执行方法转给 sqlSession，因为 sqlSession 里面封装了 Executor
        //根据调用方法的类名和方法名以及参数，传给 sqlSession 对应的方法

        if (args != null && args.length > 1) {
            Annotation[][] annotation = method.getParameterAnnotations();
            for (int i = 0; i < args.length; i++) {
                Map<String, String> map = new HashMap(1);
                Param anno = (Param) annotation[i][0];
                map.put(anno.value(), args[i] + "");
                args[i] = map;
            }
        }
        String namespace=method.getDeclaringClass().getName() + "." + method.getName();
        SqlCommandType sqlType = sqlSession.getConfiguration().getMappers().get(namespace).getSqlType();
        if (sqlType.equals(SqlCommandType.SELECT)) {
            if (Collection.class.isAssignableFrom(method.getReturnType())) {
                return sqlSession.selectList(namespace, args);
            }
            return sqlSession.selectOne(namespace, args);
        } else if (sqlType.equals(SqlCommandType.UPDATE)||sqlType.equals(SqlCommandType.DELETE)||sqlType.equals(SqlCommandType.INSERT)) {
            return sqlSession.update(namespace, args);
        } else {
            throw new RuntimeException("no such SqlType");
        }

    }
}

五、执行sql语句

代理对象调用sqlsession的方法。最终session调用Executor执行sql语句。

下面为构造sql语句写的类，没有参考mybatis极为粗糙和简单：

public static String paramToSql(String originalSql, Object[] object) throws InvocationTargetException, IllegalAccessException, IntrospectionException {
        int paramCount = StringUtil.getTargetStringNum(originalSql, "#");
        //没有参数
        if (paramCount < 1) {
            return originalSql;
        } else if (paramCount == 1) { //只有一个参数即只有一个基本数据类型,转化为字符串
            String regex = "#\\{([^}])*}";
            //将 sql 语句中的 #{*} 替换为 ？
            return originalSql.replaceAll(regex, "\"" + object[0] + "" + "\"");
        } else if (paramCount > 1 && object.length == 1) { //多个参数，且传实体对象
            Class obj = object[0].getClass();
            Field[] declaredFields = obj.getDeclaredFields();
            for (Field field : declaredFields) {
                String fieldName = field.getName();
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fieldName, obj);
                Method readMethod = propertyDescriptor.getReadMethod();
                Object o = readMethod.invoke(object[0]);
                if (o != null) {
                    originalSql = originalSql.replace("#{" + fieldName + "}", "\"" + o + "" + "\"");
                } else {
                    originalSql = originalSql.replace("#{" + fieldName + "}", "null");
                }
            }
            return originalSql;
        } else { //多个参数，传的也是多个基本类型
            for (Object o : object) {
                //前面已经是String，String，防止意外改为String,Object
                HashMap<String, Object> map = (HashMap<String, Object>) o;
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    String regex = "#\\{" + entry.getKey() + "}";
                    //将 sql 语句中的 #{*} 替换为实际参数
                    if (entry.getValue() instanceof Integer || entry.getValue().equals("1 OR 1")) {
                        originalSql = originalSql.replaceAll(regex, entry.getValue() + "");
                    } else {
                        if (entry.getValue() != null) {
                            originalSql = originalSql.replaceAll(regex, "\"" + entry.getValue() + "" + "\"");
                        } else {
                            originalSql = originalSql.replaceAll(regex, "null");
                        }

                    }
                }
            }
            return originalSql;
        }
    }

六、结果的封装

执行查询的sql得到的结果通过在Executor以下代码封装:

while (resultSet.next()) {
                E pojo = (E) pojoClass.newInstance();
                ResultSetMetaData metaData = resultSet.getMetaData();
                for (int i = 1; i <= metaData.getColumnCount(); i++) {
                    String columnName = metaData.getColumnName(i);
                    Object value = resultSet.getObject(columnName);
                    columnName = StringUtil.underlineToHump(columnName);

                    PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, pojoClass);
                    Method writeMethod = propertyDescriptor.getWriteMethod();
                    writeMethod.invoke(pojo, value);
                }
                list.add(pojo);
            }

项目地址

github:https://github.com/Alice-175/Mybaits

gitee:https://gitee.com/alice-175/Mybaits

白夜的Alice
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【MyBatis笔记03】MyBatis实现CRUD增删改查功能
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
08-12 444
MyBatis作为一个持久层框架，那必然缺少不了对数据库的增删改查操作，下面介绍一下如何通过MyBatis实现增删改查的功能。 1.1、添加数据 MyBatis提供了【】标签用于添加数据到数据库里面，【】标签具有如下属性： 标签属性： id：唯一标识，这个id值必须和Mapper接口中方法名称相同（一个XML映射文件里面不能存在相同的id值）。 parameterType：参数类型（这个用于指定方法的参数数据类型）。 useGeneratedKeys：是...
Mybatis注解实现CRUD
Massimo__JAVA的博客
06-17 127
Mybatis注解实现CRUD
Mybatis基于注解实现CRUD
hjkl761的博客
04-12 71
Demo小练习
Mybatis中使用注解实现CRUD
...
04-10 181
pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="h...
Mybatis小白入门实现CRUD详解（增删改查）（一）
归途
09-02 1840
什么是Mybatis？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。 MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。 MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 Mybatis：传统的JDBC代码太过复杂。简化。框架。自动化 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要
数据库框架Mybatis-plus,实现java代码对数据库的增删改查
12-20
Mybatis-plus是一个基于Mybatis和Spring的轻量级框架，主要目标是简化对数据库的常规操作，例如增、删、改、查（CRUD），它提供了更为方便的API，使得开发者能够更高效地进行数据库操作。这个框架在Mybatis的基础上...
springboot+mybatis-plus+mysql+微信小程序实现简单的增删改查.zip
05-23
5. **API 设计**：后端通过设计清晰的RESTful API，使得微信小程序能够进行数据的增删改查操作。通常，这会包括如GET /users（获取所有用户）、POST /users（新建用户）、PUT /users/{id}（更新用户）和DELETE /...
Spring、SpringMVC、Mybatis、BootStrap、Mysql、Maven、Eclipse增删改查
06-04
在IT行业中，构建Web应用程序是常见的任务，而Spring、SpringMVC、Mybatis和BootStrap这四个框架的组合是实现这一目标的强大工具。这里，我们将深入探讨这些技术及其在实际开发中的应用。 首先，Spring是一个全面的...
Mybatis基于注解实现增删查改和多参数列表查询
05-15
在本文中，我们将深入探讨如何利用Mybatis的注解实现增删查改（CRUD）操作以及多参数列表查询。 1. **增（Create）**： 在Mybatis中，我们可以使用`@Insert`注解来插入数据。例如： ```java @Insert("INSERT INTO ...
Java 的一个比较初级的增删该查的例子
04-04
在Java编程语言中，"增删改查"（Create, Read, Update, Delete，简称CRUD）是数据库操作的基础，也是任何数据驱动应用程序的核心部分。对于初学者来说，理解并熟练掌握这些基本操作至关重要，因为它们构成了实际项目...
mybatis的CRUD(注解版)
github_zwl的博客
06-04 271
mybatis注解实现CRUD 接上： 1.User表及实体类、工具类、配置文件config.xml 2.建立接口UserMapper.java package com.mybits_01.test2; import java.util.List; import org.apache.ibatis.annotations.Delete; import org.apache.ibati
Mybatis小白入门实现CRUD详解（增删改查）（二）
归途
09-02 239
配置解析： 以下为最基本的mybatis-config.xml配置文件 <?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&
手把手教会MyBatis连接Mysql完成增删改查（CRUD）
weixin_47267628的博客
12-03 890
MyBatis连接Mysql完成增删改查 1.第一步：创建一个SpringBoot项目 选择相关的依赖 注意如果忘记导入相关依赖：可以手动导入在下面的链接搜索相关jar的名称maven仓库 第二步：根据业务逻辑创建数据库表 DROP DATABASE emp_dep; CREATE DATABASE emp_dep; USE emp_dep; CREATE TABLE department( id INT PRIMARY KEY AUTO_INCREMENT, DepartmentName VA
如何用mysql实现增删改查_mysql简单使用增删改查
weixin_42131618的博客
01-19 298
修改配置文件在my.in配置文件找到client 指的是mysql客户端 port3306default -charachter-set=utf-8default -charachter-set=utf8basedir 和datadir 存储路劲下面有有个服务器的字符编码 修改为utf8不是utf-8default -charachter-set=utf8数据类型：整形：tinyint ...
MySQL表的增删查改CRUD—（经典SQL语句）
weixin_45803426的博客
04-25 688
目录增删查改（CRUD） 增删查改（CRUD） DDL（data definition language）：数据定义语言，用来维护存储数据的结构，主要包括增加（create）、删除（drop）、alter（修改）。 DML（Data Manipulation Language）： 操作是指对数据库中表记录的操作，主要包括表记录的插入（insert）、更新（update）、删除（delete）和查询（select），是开发人员日常使用最频繁的操作。 在使用MySQL中，我们接触最多的就是：==CRUD 即增加
MyBatis增删改查(步骤详细，由浅入深，适合初学者,只看这一篇就够了)
热门推荐
客官不爱喝酒的博客
01-02 1万+
MyBatis目录java（后端框架）MyBatis的使用1.mybatis基本使用2.mybatis工具类的封装和实现增删改查3.mybatis中主要类的介绍4.nybatis实现动态代理:(使用的是反射机制)5.mybatis参数传递:6.$和#的区别 java（后端框架）MyBatis的使用 mybatis的简介这里就不多说了,百度一大堆,我们只需要这是一个JDBC的升级版,让我们更好的操作数据库,减少不必要的代码,让我们专注于实现自己的业务逻辑. web开发的三层架构 (mvc ) 三层架构 界
mysql数据库的查询
anmodiao5169的博客
08-29 2762
1、“查”——之单表查询 　　　　　　　　INSERT INTO student2(name,grade,gender) 　　　　　　　　VALUES ('songjiang',40,'男'),('wuyong',100,'男'),('qinming',90,'男'),('husanniang',88,'女'),('sunerniang',66,'女'),('wusong',8...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 626
1.导入hutool的maven依赖。2.复制一下代码执行。
SpringBoot+Vue图书(图书借阅)管理系统-附项目源码与配套文档
最新发布
m0_74283290的博客
08-03 653
本论文阐述了一套先进的图书管理系统的设计与实现，该系统采用Java语言，结合现代Web开发框架和技术，旨在为图书馆提供高效、灵活且用户友好的资源管理解决方案。系统利用Spring Boot框架为核心，整合MyBatis ORM工具，以及MySQL数据库，构建了一个高性能、可扩展的后端服务。前端界面则采用了Vue.js框架，以提供流畅的用户交互体验。论文首先进行了详尽的需求分析，确定了系统的核心功能，包括图书的添加、编辑、删除、查询，读者的注册、登录、个人信息管理，以及图书的借阅、归还、续借流程。
mybatis generator增删改查
03-16
Mybatis Generator可以通过自动生成代码来实现增删改查操作。它可以根据数据库表结构自动生成对应的实体类、Mapper接口和XML文件，从而实现对数据库的CRUD操作。其中，增加操作使用insert语句，删除操作使用delete...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值