（二）MyBatis学习笔记——实现Dao层的不同方式

最新推荐文章于 2022-11-23 10:32:35 发布
最新推荐文章于 2022-11-23 10:32:35 发布
阅读量243 收藏
点赞数
分类专栏： # MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mbytes/article/details/115125004
版权

文章目录

一、传统方式实现

先导入MyBatis的jar包。项目依旧使用控制层——>业务层——>持久层的结构，使用MyBatis进行数据库CRUD。整体结构如下：
在这里插入图片描述

1.MyBatis配置文件

MyBatisConfig.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>
    <!--  引入数据库连接的配置文件  -->
    <properties resource="jdbc.properties"/>

    <typeAliases>
        <typeAlias type="com.example.bean.Student" alias="student"/>
        <!-- 给包下所有的类起别名，为文件名 -->
        <package name="com.example.bean"/>
    </typeAliases>
    
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="StudentMapper">
    <select id="selectAll" resultType="student">
        SELECT * FROM student
    </select>

    <select id="selectById" resultType="student" parameterType="int">
        SELECT * FROM student WHERE sid=#{sid}
    </select>

    <!--  从Student类中获取id name age  -->
    <insert id="insert" parameterType="student">
        INSERT INTO student VALUES(#{sid}, #{name}, #{age}, #{birthday});
    </insert>

    <update id="update" parameterType="student">
        UPDATE student SET name=#{name}, age=#{age}, birthday=#{birthday} WHERE sid=#{sid}
    </update>

    <delete id="delete" parameterType="java.lang.Integer">
        DELETE FROM student WHERE sid=#{sid};
    </delete>
</mapper>

2.持久层（Dao层或Mapper层）

定义接口：

package com.example.mapper;

import com.example.bean.Student;

import java.util.List;

//持久层接口
public interface StudentMapper {
    //查询全部
    public abstract List<Student> selectAll();

    //根据id查询
    public abstract Student selectById(Integer id);

    //新增数据
    public abstract Integer insert(Student student);

    //修改数据
    public abstract Integer update(Student student);

    //根据id删除数据
    public abstract Integer delete(Integer id);
}

接口实现：

public class StudentMapperImpl implements StudentMapper {
    //查询全部
    @Override
    public List<Student> selectAll() {
        InputStream is = null;
        SqlSession sqlSession = null;
        List<Student> list = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MybatisConfig.xml");
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);//自动提交事务
            //4.执行映射配置文件中的SQL语句，并接收结果
            list = sqlSession.selectList("StudentMapper.selectAll");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            if(sqlSession != null)
                sqlSession.close();
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return list;
    }
    //根据Id查询
    @Override
    public Student selectById(Integer id) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Student stu = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MybatisConfig.xml");
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);//自动提交事务
            //4.执行映射配置文件中的SQL语句，并接收结果
            stu = sqlSession.selectOne("StudentMapper.selectById", id);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            if(sqlSession != null)
                sqlSession.close();
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return stu;
    }

    //插入一条数据
    @Override
    public Integer insert(Student student) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer res = 0;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MybatisConfig.xml");
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);//自动提交事务
            //4.执行映射配置文件中的SQL语句，并接收结果
            res = sqlSession.insert("StudentMapper.insert", student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            if(sqlSession != null)
                sqlSession.close();
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return res;
    }

    //修改一条数据
    @Override
    public Integer update(Student student) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer res = 0;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MybatisConfig.xml");
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);//自动提交事务
            //4.执行映射配置文件中的SQL语句，并接收结果
            res = sqlSession.update("StudentMapper.update", student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            if(sqlSession != null)
                sqlSession.close();
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return res;
    }

    @Override
    public Integer delete(Integer id) {
        InputStream is = null;
        SqlSession sqlSession = null;
        Integer res = 0;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MybatisConfig.xml");
            //2.获取SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);//自动提交事务
            //4.执行映射配置文件中的SQL语句，并接收结果
            res = sqlSession.delete("StudentMapper.delete", id);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5.释放资源
            if(sqlSession != null)
                sqlSession.close();
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
        return res;
    }
}

3.业务层（Service层）

定义接口：

package com.example.service;

import com.example.bean.Student;

import java.util.List;
//业务层接口
public interface StudentService {
        //查询全部
        public abstract List<Student> selectAll();

        //根据id查询
        public abstract Student selectById(Integer id);

        //新增数据
        public abstract Integer insert(Student student);

        //修改数据
        public abstract Integer update(Student student);

        //根据id删除数据
        public abstract Integer delete(Integer id);

}

实现接口：

public class StudentServiceImpl implements StudentService {
    private StudentMapper mapper = new StudentMapperImpl();//创建持久层对象

    @Override
    public List<Student> selectAll() {
        return mapper.selectAll();
    }

    @Override
    public Student selectById(Integer id) {
        return mapper.selectById(id);
    }

    @Override
    public Integer insert(Student student) {
        return mapper.insert(student);
    }

    @Override
    public Integer update(Student student) {
        return mapper.update(student);
    }

    @Override
    public Integer delete(Integer id) {
        return mapper.delete(id);
    }
}

4.控制层（controller层）

public class StudentController {
    //创建业务层对象
    private StudentService service = new StudentServiceImpl();
    //日期格式化
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

    //查询全部功能测试
    @Test
    public void selectAll(){
        List<Student> students = service.selectAll();
        for (Student stu : students) System.out.println(stu);
    }
    //通过id查询
    @Test
    public void selectById(){
        Student student = service.selectById(3);
        System.out.println(student);
    }

    //新增功能
    @Test
    public void insert() throws ParseException {
        Student student = new Student(5,"小A",35, dateFormat.parse("2010-10-10"));
        Integer res = service.insert(student);
        System.out.println(res);
    }

    //修改功能
    @Test
    public void update() throws ParseException {
        Student student = new Student(5,"大A",33,dateFormat.parse("2000-01-01"));
        Integer res = service.update(student);
        System.out.println(res);
    }

    //删除功能
    @Test
    public void delete(){
        Integer res = service.delete(5);
        System.out.println(res);
    }
}

二、接口代理方式实现

分析：

  • 接口代理方式的好处？
    • 使用上面这种传统的方式实现Dao层，既要写接口，还要写实现类。使用MyBatis可以省略编写Dao层接口的实现类的步骤，有MyBatis根据定义好的接口，创建该接口的动态代理对象。
  • 动态代理对象如何生成？
    • 通过动态代理模式，持久层只需写一个接口，不需要实现类，通过getMapper()方法最终获取到org.apache.ibatis.binding.MapperProxy代理对象，然后执行功能。此代理对象时MyBatis使用JDK的动态代理技术自动生成的代理实现类对象。由此，可以进行数据持久化操作
  • 方法如何执行？
    • 动态代理实现类对象在执行方法时最终调用了mapperMethod.execute()方法，此方法中通过switch语句根据操作类型判断是CRUD中的哪个操作，最终使用了MyBatis最原生的SqlSession方式来执行CRUD。
  • 使用接口代理方式的要求：
    • 映射配置文件中的名称空间须与Dao层接口的详细目录下的类名相同。<mapper namespace="com.example.mapper.StudentMapper">
    • 映射配置文件中的增删改查标签的id属性须和持久层接口的方法名相同。
    • 映射配置文件中的增删改查标签的parameterType属性须与持久层接口方法的参数相同。
    • 映射配置文件中的增删改查标签的resultType属性须与持久层接口方法的返回值相同。

1.新建项目

和传统Dao实现方式基本相同，只需要修改映射配置文件中的名称空间等上面四步即可。现在不再需要StudentMapper的实现类，其方法实现将转移到StudentServiceImpl中进行实现。项目架构如下：
在这里插入图片描述

2.业务层代码编写

StudentServiceImpl.class

public class StudentServiceImpl implements StudentService {

    @Override
    public List<Student> selectAll() {
        List<Student> list = null;
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //2.获取到SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);//等同于：StudentMapper studentMapper = new StudentMapperImpl();
            //5.通过实现类对象调用方法，接收结果
            list = studentMapper.selectAll();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //7.返回结果
        return list;
    }

    @Override
    public Student selectById(Integer id) {
        Student student = null;
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //2.获取到SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);//等同于：StudentMapper studentMapper = new StudentMapperImpl();
            //5.通过实现类对象调用方法，接收结果
            student = studentMapper.selectById(id);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //7.返回结果
        return student;
    }

    @Override
    public Integer insert(Student student) {
        Integer res = 0;
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //2.获取到SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);//等同于：StudentMapper studentMapper = new StudentMapperImpl();
            //5.通过实现类对象调用方法，接收结果
            res = studentMapper.insert(student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //7.返回结果
        return res;
    }

    @Override
    public Integer update(Student student) {
        Integer res = 0;
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //2.获取到SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);//等同于：StudentMapper studentMapper = new StudentMapperImpl();
            //5.通过实现类对象调用方法，接收结果
            res = studentMapper.update(student);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //7.返回结果
        return res;
    }

    @Override
    public Integer delete(Integer id) {
        Integer res = 0;
        SqlSession sqlSession = null;
        InputStream is = null;
        try {
            //1.加载核心配置文件
            is = Resources.getResourceAsStream("MyBatisConfig.xml");
            //2.获取到SqlSession工厂对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            //3.通过工厂对象获取到SqlSession对象
            sqlSession = sqlSessionFactory.openSession(true);
            //4.获取StudentMapper接口的实现类对象
            StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);//等同于：StudentMapper studentMapper = new StudentMapperImpl();
            //5.通过实现类对象调用方法，接收结果
            res = studentMapper.delete(id);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //7.返回结果
        return res;
    }
}
MegaBytes
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis 学习笔记——原生DAO实现数据增删改查SQL
10-13
Mybatis 学习笔记——原生DAO实现数据增删改查SQL：https://blog.csdn.net/qq_24598601/article/details/83037252
使用MyBatis编写Dao的两种语法
Java客学习室
03-29 1033
原文链接：http://www.yiidian.com/mybatis/mybatis-dao.html 在MyBatis中，我们有两种Dao的写法，一种叫传统Dao写法，一种叫Mapper代理接口。下面看看如何实现。 1 传统Dao写法 1.1 编写CustomerDao接口 package com.yiidian.dao; import com.yiidian.domain.Customer;...
Mybatis怎么实现dao层？
qq_45721289的博客
09-24 1689
有两种方式：1、传统方式 2、代理方式开发 第一种方式：传统方式 1、编写dao层 public interface UserDao { //查询所有 List<User> findAll() throws IOException; } 2、编写dao层实现类 /* Dao层实现类 */ public class UserDaoImpl implement UserDao{ /* 定义查...
Mybatis Dao层参数传递的三种方式
zuozhongliang的博客
03-30 8107
本文来自收集整理: UserDao接口有一个方法  Public User selectUser(String name,String area); 第一种:            UserDao接口有一个方法  Public User selectUser(String name,String area);            对应的Mapper.xml  sel
sqoop-Mysql导入Hive完整命令参数解析
Vivi_static的博客
08-07 862
【应用场景】 sqoop是常用的 关系数据库离线同步到数仓的 工具 sqoop导入有两种方式： 1）直接导入到hdfs，然后再load到表中 2）直接导入到hive中 下面介绍sqoop import 导入到hive中的 完整参数命令 【sqoop-import-mysql到hive完整命令】 1）需要已知的参数 mysql 的jdbc连接参数：jdbc链接、用户名、密码 mysql同步表的信息：列、表名 hive链接参数 ：是否有链接限制 hive目标表的信息：表名、分隔符、是否分区 2）具体参数 #
Dao层的开发方法（原始dao开发和Mapper接口开发）
廖子默
08-15 3305
原始Dao开发方法 1.编写dao接口 2.编写dao接口的实现类 3.Mapper映射文件 4.SqlMapConfig配置文件 5.测试类 6.结果 8.总结 1、dao接口实现类方法中存在大量重复方法，就是通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法 2、调用sqlsession方法时将statement的id硬编码了...
web学习笔记 —— DAO设计模式
03-16
在Web开发中，DAO模式是常用的数据访问层实现方式。 DAO模式的核心思想是创建一个接口，这个接口定义了对数据的访问方法，如增删改查等。然后为这个接口创建一个或多个实现类，这些实现类会具体实现接口中定义的...
传智 mybatis mvc 教案及笔记 燕青
06-26
【传智mybatis MVC教案及笔记 燕青】涵盖了Java Web开发中的核心框架——MyBatis和MVC模式的应用，这些内容对于深入理解和实践Java后端开发至关重要。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及...
day01_eesy_01mybatis.zip
05-31
学习笔记——mybatis的起步（1） 1.什么是框架？ 他是我们软件开发中的一套解决方案，不同的框架解决的是不同的问题。 使用框架的好处： 框架封装了很多的细节，使开发者可以使用极简的方式实现功能。大大提高...
SSM实战项目——Java高并发秒杀API，详细流程+学习笔记.zip
最新发布
01-14
这个Java实战项目提供了详细的步骤和学习笔记，涵盖了从需求分析、架构设计到代码实现的全过程，是提升Java并发编程和分布式系统设计能力的宝贵资源。通过实际操作，你可以深入了解SSM框架的使用以及在高并发场景下...
mybatis框架学习 Dao层的两种实现方式
m0_59588838的博客
03-23 1845
昨天我们用的方法在测试类里利用三板斧：加载核心配置文件，创建会话工厂，创建会话。通过会话资源的访问得以实现数据库的操作，其实实现这个功能的方式有两种： 一种是手动的实现也就是在dao层创建接口与实现接口的实现类（dao层就是M<model层>V<view层>C<controller层>三层架构中M层里与数据库接触最深的代码层） public interface UserDao { List<User> list() throws IOExce
Mybatis的两种配置方法和知识
weixin_43788143的博客
11-07 1062
一 环境准备 IDEA 2020.2.3 JKD14 Maven工程 Mysql数据库 mysql> CREATE TABLE `user` ( `id` int(11) NOT NULL auto_increment, `username` varchar(32) NOT NULL COMMENT '用户名称', `birthday` datetime default NULL COMMENT '生日', `sex` char(1) default NULL COMMENT '
MyBatisPlus
m0_62051002的博客
11-23 176
MybatisPlus(简称MP)是基于MyBatis框架基础上开发的增强型工具，旨在简化开发、提供效率。开发方式SpringBoot刚刚我们学习完成，它能快速构建Spring开发环境用以整合其他技术，使用起来是非常简单。
DAO层的写法总结
qq_26882339的博客
01-31 1万+
DAO层的写法总结： DAO层持有实体层的对象，DAO层的增删改查写法会很多。下面总结一下三种写法：这里只给出查询的写法，其他写法类似。 1、最原始的JDBC写法 2、Apache的 Commons DbUtils 3、Hhibernate 或 Mybatis方式 mysql 5.5 建库、建表、两行示例数据的语句：（账号和密码都是root） create database studentdb; use studentdb; create table st
DAO常用方法（增删改查）
热门推荐
Mr long的博客
07-05 1万+
1.返回List&lt;对象&gt; Listpublic List searchAllData(){ String querySql = " select * from dt_tag_list order by order_number "; return jdbcTemplate.query(querySql, new Object[]{},new RowMapper&lt;T...
DAO层接口，为什么能操作数据库
子衿_青青的博客
11-09 1万+
public interface TestDAO { Test selectById(Integer id); } 一、问题：   如上代码所示，为什么调用TestMapper的selectById方法，就能从数据库中读取数据？TestMapper不是个接口吗？接口怎么能直接调用方法呢？ 猜测：   接口当然是不能直接调用方法的，那么接口的实现类呢？应该是mybatis框架，自动...
几种常用的dao层方法（用户列表，根据用户名和密码登录查询等）
wy123456__的博客
04-28 1263
用户列表： @Override public List<User> findAll() { String sql = "select * from sys_user"; List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class)); return users; } 根据用户名和密码查询 @Ov
dao 层实现 的方法
weixin_38170853的博客
08-28 379
@Override public boolean checkPhone(String phone) { String sql = "select username from user where phone=?"; List<Map<String, Object>> queryForList = DbUtil.queryForList(sql, phone);...
MyBatis快速入门第三讲——dao层开发方法
李阿昀的博客
05-12 1万+
使用MyBatis开发Dao层，通常有两个方法，即原始Dao开发方法和Mapper接口开发方法。本文案例代码的编写是建立在前文MyBatis框架的学习(二)——MyBatis架构与入门案例基础之上的！需求明确开发需求，在实际开发中，我们总归是要开发Dao层的，所以在本文中我使用MyBatis这个框架技术开发Dao层来将以下功能一一实现： 根据用户id查询一个用户信息 根据用户名称模糊查询用户信息列表
MyBatis学习笔记与实战指南
"这是一份关于MyBatis的学习笔记，包含笔记整理和示例代码，旨在帮助学习者全面理解并掌握MyBatis框架。" 在Java开发领域，MyBatis是一个广泛使用的开源免费数据访问层框架，原名为iBatis，自2010年起在Google Code...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值