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

最新推荐文章于 2024-03-06 09:46:23 发布
最新推荐文章于 2024-03-06 09:46:23 发布
阅读量305 收藏
点赞数
分类专栏： # MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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;
    }
}
Mybatis Dao层参数传递的三种方式
zuozhongliang的博客
03-30 8222
本文来自收集整理: 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 982
【应用场景】 sqoop是常用的 关系数据库离线同步到数仓的 工具 sqoop导入有两种方式： 1）直接导入到hdfs，然后再load到表中 2）直接导入到hive中 下面介绍sqoop import 导入到hive中的 完整参数命令 【sqoop-import-mysql到hive完整命令】 1）需要已知的参数 mysql 的jdbc连接参数：jdbc链接、用户名、密码 mysql同步表的信息：列、表名 hive链接参数 ：是否有链接限制 hive目标表的信息：表名、分隔符、是否分区 2）具体参数 #
Mybatis 实现Dao层开发的2种方式
huangyh技术栈
10-20 310
使用 Mybatis开发 Dao，通常有两个方法，即原始 Dao 开发方式和 Mapper 接口代理开发方式。 而现在主流的开发方式是接口代理开发方式，这种方式总体上更加简便。 未完，待续... ...
dao 层实现 的方法
weixin_38170853的博客
08-28 426
@Override public boolean checkPhone(String phone) { String sql = "select username from user where phone=?"; List<Map<String, Object>> queryForList = DbUtil.queryForList(sql, phone);...
Dao层的开发方法（原始dao开发和Mapper接口开发）
廖子默
08-15 3421
原始Dao开发方法 1.编写dao接口 2.编写dao接口的实现类 3.Mapper映射文件 4.SqlMapConfig配置文件 5.测试类 6.结果 8.总结 1、dao接口实现类方法中存在大量重复方法，就是通过SqlSessionFactory创建SqlSession，调用SqlSession的数据库操作方法 2、调用sqlsession方法时将statement的id硬编码了...
Mybatis 学习笔记——原生DAO实现数据增删改查SQL
10-13
Mybatis 学习笔记——原生DAO实现数据增删改查SQL：https://blog.youkuaiyun.com/qq_24598601/article/details/83037252
MyBatis学习笔记—代理DAO开发
06-27
### MyBatis学习笔记——代理DAO开发 #### 一、概述 在Java开发领域中，MyBatis是一款非常流行的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果...
Mybatis学习笔记 —— 与spring整合后的原始Dao及Mapper代理方式的使用
Sirm23333
07-09 9212
一、整合思路 spring通过单例方式管理SqlSessionFactory。 spring和mybatis整合生成代理对象，使用SqlSessionFactory创建SqlSession。（spring和mybatis整合自动完成） 持久层的mapper都需要由spring进行管理。 二、整合环境 三、spring配置文件applicationContext.xml 在applica...
web学习笔记 —— DAO设计模式
03-16
在Web开发中，DAO模式是常用的数据访问层实现方式。 DAO模式的核心思想是创建一个接口，这个接口定义了对数据的访问方法，如增删改查等。然后为这个接口创建一个或多个实现类，这些实现类会具体实现接口中定义的...
【框架学习 | 第二篇】暴打MyBatis-Plus——MyBatis的升级版本
踢桃的成长之路
03-06 1319
框架系列第二篇主要学习并复习了Mybatis Plus持久化框架，是Mybatis的升级版本，封装了基础的增删查改语句、分页查询等语句，本篇深入学习BaseMapper、Service层各封装的增删查改语句、以及如何通过Mybatis Plus进行分页查询、自定义批量新增、条件构造器的解读，可以为读者快速入门并使用Mybatis Plus
MyBatis实践之DAO与Mapper
09-02
MyBatis前身是iBatis,是一个基于Java的数据持久层/对象关系映射(ORM)框架.通过本文给大家介绍MyBatis实践之DAO与Mapper的相关知识，需要的朋友参考下吧
MyBatis框架Dao代理
山丘i
08-06 190
目录一、Dao开发1. 实现接口中的select方法2. 实现接口中insert方法3. 实现接口中 update 方法4. 实现接口中 delete 方法二、Dao开发分析三、Dao代理实现CURD1. 使用getMapper获取代理对象四、总结1. 什么是动态代理？2. 使用动态代理的方式3. 使用动态代理的要求一、Dao开发 首先创建Dao接口 package com.md.dao...
2.mybatis的dao层开发
YvesHe的专栏
02-19 576
1.SqlSession使用范围 在进行dao层开发的时候,这里需要提到sqlSession,SqlSessionFactory和SqlSessionFactoryBuilder. SqlSession中封装了对数据库的操作，如：查询、插入、更新、删除等。 通过SqlSessionFactory创建SqlSession，而SqlSessionFactory是通过SqlSessionFactoryBu
mybatis动态代理与传统的dao访问数据库对比，来理解mybatis动态代理的原理。（部分注释内容属于个人理解内容）
Self_discipline8的博客
04-17 364
mybatis动态代理与传统的dao访问数据库对比，来理解mybatis动态代理的原理。（部分注释内容属于个人理解内容） 一、使用传统的dao方式来访问数据库的步骤如下。 第一，创建student类 public class Student{ private Integer id; private String name; private Integer age; private Integer grade; } 第二，创建StudentDao接口 //操作student表
mybatis框架学习 Dao层的两种实现方式
m0_59588838的博客
03-23 1941
昨天我们用的方法在测试类里利用三板斧：加载核心配置文件，创建会话工厂，创建会话。通过会话资源的访问得以实现数据库的操作，其实实现这个功能的方式有两种： 一种是手动的实现也就是在dao层创建接口与实现接口的实现类（dao层就是M<model层>V<view层>C<controller层>三层架构中M层里与数据库接触最深的代码层） public interface UserDao { List<User> list() throws IOExce
Mybits和原始的JDBC两种操作数据库Dao开发方式的对比
12-08 455
目录 Mybits简介 项目分层结构 原始JDBC数据库开发模式 Mybits--Mapper代理的开发方式开发模式 两种开发模式的对比 Mybits简介 MyBatis，原名 iBatis，由原来的 apache 迁移到了谷歌，更名为 MyBatis。MyBatis 指的就是 iBatis 3.x 后的版本。 MyBatis 是采用 ORM（Object Relational Mapping，对象关系映射）思想实现的持久化层框架，之前学习持久层解决方案...
Mybatis的两种配置方法和知识
weixin_43788143的博客
11-07 1151
一 环境准备 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 '
myBatis、DAO、Mapper解释
qq_42953044的博客
02-01 1540
MyBatis 是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。 DAO类都是进行数据操作的类， 是对于数据库中的数据做增删改查等操作的代码。 DAO(Data Access Object) 数据访问对象，是一个面向对象的数据库
mysql dao层怎么写_servlet的dao层怎么写
weixin_39681486的博客
02-07 382
dao层：dao层叫数据访问层，全称为data access object，属于一种比较底层，比较基础的操作，具体到对于某个表、某个实体的增删改查。推荐课程：Java教程。Dao层先声明一个接口类，类里声明一些将会用的方法，同一层内写一个实现这个接口类的类，重写接口类里的方法以实现Mybatis的写法方法主要是处理数据的方法;public interface IStuClassDao {//全表查...
mybatis学习笔记（全）
最新发布
01-15
### 关于 MyBatis 的全面学习笔记 #### 一、MyBatis 基础概念 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。通过 MyBatis 创建 DAO 接口的实现类对象完成对 SQL 语句的执行[^1]。 #### 二、环境搭建与配置 为了使 MyBatis 正常工作，在项目中需引入必要的依赖并配置数据库连接信息。通常这些信息会保存在一个名为 `jdbc.properties` 文件内，如下所示： ```properties jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/test jdbc.username=root jdbc.password=root ``` 此部分配置用于指定 JDBC 驱动程序名称、URL 地址及登录凭证等必要参数[^2]。 #### 三、数据操作流程概述 当利用 MyBatis 进行 CRUD 操作时，实际的数据源可以来自多种途径之一——例如从关系型数据库获取记录集作为 Java 对象列表 (`List<T>`) 来处理。对于导出至 Excel 文档的需求，则可通过编写工具方法接收上述提到的对象集合及其他元数据（如表头定义），最终返回文件流供下载使用[^3]。 #### 四、动态 SQL 技术详解 MyBatis 提供了一套强大的动态 SQL 功能，允许开发者依据业务逻辑灵活构建查询条件。这项特性极大地简化了复杂查询场景下的编码难度，并提高了代码可读性和维护效率[^4]。 --- 下面是一些具体的实践建议帮助更好地掌握 MyBatis: - **深入理解 XML 映射文件**: 学习如何声明命名空间(namespace)，编写 Select/Insert/Update/Delete 节点及其属性设置； - **探索注解方式开发 Mapper Interface**: 尝试不借助 XML 描述而仅依靠接口上的 @Select/@Insert 等标注来定义 SQL 片段； - **熟悉缓存机制**: 掌握一级缓存(默认开启)和二级缓存的工作原理及时机控制策略； - **研究插件扩展能力**: 利用拦截器(interceptor)自定义行为增强原有功能模块； - **练习分页查询优化技巧**: 结合具体应用场景评估不同方案性能表现差异； 最后提醒一点，随着版本迭代更新速度加快，官方文档始终是最权威可靠的学习资源，请务必定期查阅最新发布的内容保持知识体系与时俱进。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值