Mybatis传统方式实现Dao层与接口代理方式实现dao

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量593 收藏 3
点赞数 16
分类专栏： Mybatis 文章标签： java 数据库 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61611746/article/details/131971829
版权

1.传统方式实现dao层

1.Dao 层传统实现方式

分层思想：控制层(controller)、业务层(service)、持久层(dao)。

调用流程：控制层→业务层→持久层→DB

2.环境准备

在mybatis项目中持久层就不再叫dao，而是叫做mapper（只是换了名字）

mapper层：

package Mybatis2.mapper.impl;

import mybatis1.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 stu);

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

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


package Mybatis2.mapper.impl;

import mybatis1.bean.Student;

import java.util.List;

/*
    持久层实现类
 */
public class StudentMapperImpl implements StudentMapper {

    /*
        查询全部
     */
    @Override
    public List<Student> selectAll() {
        return null;
    }

    /*
        根据id查询
     */
    @Override
    public Student selectById(Integer id) {
        return null;
    }

    /*
        新增功能
     */
    @Override
    public Integer insert(Student stu) {
        return null;
    }

    /*
        修改功能
     */
    @Override
    public Integer update(Student stu) {
        return null;
    }

    /*
        删除功能
     */
    @Override
    public Integer delete(Integer id) {
        return null;
    }
}

service层：

package Mybatis2.service;

import mybatis1.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 stu);

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

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


package Mybatis2.service;

import Mybatis2.mapper.impl.StudentMapper;
import Mybatis2.mapper.impl.StudentMapperImpl;
import mybatis1.bean.Student;

import java.util.List;

/*
    业务层实现类
 */
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 stu) {
        return mapper.insert(stu);
    }

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

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

 controller层：

package Mybatis2.controller;

import Mybatis2.service.StudentService;
import Mybatis2.service.StudentServiceImpl;
import mybatis1.bean.Student;
import org.junit.Test;

import java.util.List;

/*
    控制层测试类
 */
public class StudentController {
    //创建业务层对象
    private StudentService service = new StudentServiceImpl();

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

    //根据id查询功能测试
    @Test
    public void selectById() {
        Student stu = service.selectById(3);
        System.out.println(stu);
    }

    //新增功能测试
    @Test
    public void insert() {
        Student stu = new Student(4,"赵六",26);
        Integer result = service.insert(stu);
        System.out.println(result);
    }

    //修改功能测试
    @Test
    public void update() {
        Student stu = new Student(4,"赵六",16);
        Integer result = service.update(stu);
        System.out.println(result);
    }

    //删除功能测试
    @Test
    public void delete() {
        Integer result = service.delete(4);
        System.out.println(result);
    }
}

3.mapper层功能实现

package Mybatis2.mapper.impl;

import mybatis1.bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/*
    持久层实现类
 */
public class StudentMapperImpl implements StudentMapper {

    /*
        查询全部
     */
    @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.执行映射配置文件中的sql语句，并接收结果
            list = sqlSession.selectList("StudentMapper.selectAll");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //6.返回结果
        return list;
    }

    /*
        根据id查询
     */
    @Override
    public Student selectById(Integer id) {
        Student stu = 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.执行映射配置文件中的sql语句，并接收结果
            stu = sqlSession.selectOne("StudentMapper.selectById",id);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //6.返回结果
        return stu;
    }

    /*
        新增功能
     */
    @Override
    public Integer insert(Student stu) {
        Integer result = 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.执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.insert("StudentMapper.insert",stu);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //6.返回结果
        return result;
    }

    /*
        修改功能
     */
    @Override
    public Integer update(Student stu) {
        Integer result = 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.执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.update("StudentMapper.update",stu);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //6.返回结果
        return result;
    }

    /*
        删除功能
     */
    @Override
    public Integer delete(Integer id) {
        Integer result = 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.执行映射配置文件中的sql语句，并接收结果
            result = sqlSession.delete("StudentMapper.delete",id);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //5.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //6.返回结果
        return result;
    }
}

4.LOG4J的使用

在日常开发过程中，排查问题时难免需要输出 MyBatis 真正执行的 SQL 语句、参数、结果等信息，我们就可以借助 LOG4J 的功能来实现执行信息的输出

使用步骤

1.导入 jar 包：log4j-1.2.17.jar

2.修改核心配置文件：MyBatisConfig.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration 核心根标签-->
<configuration>
    <!--引入数据库连接的配置文件-->
    <properties resource="jdbc.properties"/>
    <!--配置LOG4J：以下name和value是固定写法-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--起别名-->
    <typeAliases>
        <typeAlias type="mybatis1.bean.Student" alias="student"/>
        <!--<package name="mybatis.bean"/>
      如果bean包下有很多Javabean都需要起别名，就可以使用package，指定一个包名
      这样的话，就自动给这个包下所有的类添加别名，别名是类名的小写名字
      -->
</typeAliases>

        <!--每一个environment标签都是一个具体的连接数据库的环境 ，default：设置默认使用的环境的id-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"/>
            <!-- 设置数据源的类型，以下表示使用数据库连接池缓存数据库连接-->
            <dataSource type="POOLED">
                <!-- property获取数据库连接的配置信息 -->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--mappers引入映射配置文件-->
    <mappers>
        <!-- mapper 引入指定的映射配置文件   resource属性指定映射配置文件的名称 -->
        <mapper resource="StudentMapper.xml"/>
    </mappers>
</configuration>

3.在 src 下编写 LOG4J 配置文件 ： log4j.properties （配置文件名字也是固定写法）

# Global logging configuration
# ERROR WARN INFO DEBUG
# 日志的四个级别，从高到低：ERROR（错误信息） WARN（警告信息） INFO（普通信息） DEBUG（调试信息，推荐使用）
# stdout：输出到控制台
log4j.rootLogger=DEBUG, stdout
# Console output...  输出格式
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

2.接口代理方式实现dao

传统方式实现Dao层，既要写接口，还要写实现类而Mybatis框架可以帮助我们省略编写Dao层接口实现类的步骤程序员只需要编写接口，由Mybatis框架根据接口的定义来创建该接口的动态代理对象

1.接口代理方式实现规则

1.映射配置文件中的名称空间必须和Dao层接口的全类名相同（Mapper.xml文件中的namespace与mapper接口的全限定名相同）

2.映射配置文件中的增删改查标签的id属性必须和Dao层接口的方法名相同

3.映射配置文件中的增删改查标签的parameterType属性必须和Dao层接口方法的参数相同

4.映射配置文件中的增删改查标签的result Type属性必须和Dao层接口方法的返回值相同

2.代码实现

1.删除 mapper 层接口的实现类

2.修改映射配置文件

3.修改 service 层接口的实现类，采用接口代理方式实现功能（因为现在没有持久层实现类了，所

以业务层无法直接调用，需要自己实现并且调用代理接口方式的MapperImpl）

修改映射配置文件：

<!-- 将命名空间修改为StudentMapper全路径名-->

<mapper namespace="Mybatis2.mapper.StudentMapper">

修改service层接口的实现类：

package Mybatis2.service;

import Mybatis2.mapper.StudentMapper;
import mybatis1.bean.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

/*
    业务层实现类
 */
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 mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            list = mapper.selectAll();

        } catch (Exception e) {

        } 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 stu = 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 mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            stu = mapper.selectById(id);

        } catch (Exception e) {

        } finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //7.返回结果
        return stu;
    }

    @Override
    public Integer insert(Student stu) {
        Integer result = 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 mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            result = mapper.insert(stu);

        } catch (Exception e) {

        } finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //7.返回结果
        return result;
    }

    @Override
    public Integer update(Student stu) {
        Integer result = 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 mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            result = mapper.update(stu);

        } catch (Exception e) {

        } finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //7.返回结果
        return result;
    }

    @Override
    public Integer delete(Integer id) {
        Integer result = 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 mapper = sqlSession.getMapper(StudentMapper.class); // StudentMapper mapper = new StudentMapperImpl();

            //5.通过实现类对象调用方法，接收结果
            result = mapper.delete(id);

        } catch (Exception e) {

        } finally {
            //6.释放资源
            if(sqlSession != null) {
                sqlSession.close();
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //7.返回结果
        return result;
    }
}

3.源码分析

分析动态代理对象如何生成的

通过动态代理开发模式，我们只编写一个接口，不写实现类，我们通过 getMapper() 方法最终获取

到 org.apache.ibatis.binding.MapperProxy 代理对象，然后执行功能，

而这个代理对象正是 MyBatis 使用了 JDK 的动态代理技术，帮助我们生成了代理实现类对象。从

而可以进行相关持久化操作。

分析方法是如何执行的

跟踪mapper.insert方法，代码打断点，然后调试跟踪

代码执行到insert之后，进入方法的执行，然后就进入到了invoke方法（动态代理执行方法，都会执行invoke）

在invoke中调用了mapperMethod.execute()方法

这个方法中通过 switch 语句根据操作类型来判断是新增、修改、删除、查询操作，

最后一步回到了 MyBatis 最原生的 SqlSession 方式来执行增删改查

天演L
关注
  • 16
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SSM】05-Mybatis中dao的使用
m0_50964976的博客
12-24 1743
文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 在Mybatis的使用中，对于数据库的操作，我们针对每一张表创建一个对应的接口和sql映射文件。 注意到上述两篇中并没有在代码中直接使用我们的dao接口，下面将会介绍dao接口的两种用法。 提示：以下是本篇文章正文内容，下面案例可供参考 一、传统的dao使用 1、回顾一下接口 在java编程语言中，接口是一个抽象类型，是所有抽象方法的一个集合。接口不能被继承，只能被...
Mybatis之传统dao层与动态代理实现方式
oLengNuanZiZhi12的博客
03-17 147
dao层两种实现方式1>传统方式实现dao层2>动态代理 1>传统方式实现dao层 1、在dao包中创建一个包叫作impl，impl创建一个StudentDao实现类，并复写它的方法 package com.bjpowernode.dao.impl; import com.bjpowernode.dao.StudentDao; import com.bjpowernode.domain.Student; import com.bjpowernode.util.MyBatisUtil;
MyBatis-03 (Dao 代理)
小北呱的博客
06-06 194
第3章 MyBatis 框架 Dao 代理 内容列表 Dao 接口动态代理 参数传递 处理查询结果 like 和主键 Dao 代理实现 CURD 步骤 去掉 Dao 接口实现类 getMapper 获取代理对象 只需调用 SqlSession 的getMapper()方法，即可获取指定接口的实现类对象。该方法的参数为指定 Dao 接口类的 class 值。 ...
Mybatis的Dao层实现
折叠伞的博客
02-13 367
传统实现方式 传统的开发方式 1.编写UserDao接口 public interface UserDao{ List <User> findAll() throws IOException; } 2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao{ public List<User> findAll() throws IOException{ InputStream resou
（二）Mybatis dao层实现基础增删改查
SwaggerHB的博客
05-18 926
Mybatis dao层实现基础增删改查（详解）及注意事项、错误分析
mybatis注解Dao示例
麦子的博客
06-12 6310
Springboot与mybatis整合在application.properties文件中mybatis.type-aliases-package=com.baidu.*.daoDao层@Mapper public interface ProvMarkSuppDao { @Select("&lt;script&gt;" + "SELECT " +...
【Mybatis】Mybatis介绍和Dao层实现
weixin_52847234的博客
07-24 1429
原始jdbc开发存在的问题如下①数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能②sql语句在代码中硬编码，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。③查询操作时，需要手动将结果集中的数据手动封装到实体中。插入操作时，需要手动将实体的数据设置到sql语句的占位符位置应对上述问题给出的解决方案①使用数据库连接池初始化连接资源②将sql语句抽取到xml配置文件中ORM编写UserMapper映射文件...
MyBatis开发Dao层的两种方式实现（原始Dao层开发）
08-26
在MyBatis中，Dao层可以通过两种方式实现：原始Dao层开发和Mapper动态代理方式。本文将详细介绍原始Dao层开发方式的实现。 一、MyBatis基本概念 MyBatis是一个基于Java的持久化层框架，用于简化Java应用程序中的...
spring和mybatis整合(原始dao方式实现
04-08
- 在Spring中，原始DAO方式指的是不使用MyBatis的Mapper接口，而是直接通过SqlSession进行数据库操作。这需要我们在DAO实现类中注入SqlSessionFactory，然后创建SqlSession实例，调用其`openSession()`、`selectOne...
MyBatis在webApp中的使用，此种使用方式是实现dao层接口，并未让mybatis自动生成dao接口的实现类
01-17
在这个特定的情况下，我们将讨论如何在不依赖MyBatis自动生成DAO接口实现的情况下，手动实现DAO层接口。 首先，我们需要在项目中引入MyBatis的依赖。在`pom.xml`文件中，你需要添加以下Maven依赖： ```xml ...
mybatis开发dao之mapper代理方式
01-24
在Mapper代理方式下，我们无需手动创建DAO实现类，只需定义接口，MyBatis会自动生成对应的动态代理实现。 首先，我们创建一个`Mapper`接口，这个接口通常包含对应数据库表的操作方法，如增删查改。例如，我们可以...
MyBatis实践之DAO与Mapper
09-02
在MyBatis中，DAO通常是一个Java接口，这个接口的方法与SQL语句相对应。DAO的具体实现则是通过MyBatis的Mapper机制来完成的。 **Mapper接口**： Mapper接口是MyBatis的核心组件之一，它允许开发者定义SQL语句和Java...
「Mybatis实战九」：Mybatis的dao层开发使用 - 代理开发方式
CAUC_lin的博客
03-05 1036
Mybatis提供的基于接口的代理开发方式是现代企业级应用中广泛采用的标准实践。这种方式允许开发者仅需专注于定义Mapper接口，而无需编写其实现类。Mybatis框架会在运行时依据这些接口自动生成代理对象，负责处理数据访问操作。Mapper.xml映射文件的namespace属性应与对应的Mapper接口的全限定名一致。Mapper接口的方法名必须与Mapper.xml中的每个SQL statement的id相匹配。
Mybatis的Dao层实现原理
kopoo的博客
10-19 2077
1.Mybatis的Dao层实现 1.1 传统开发方式 1.1.1编写UserDao接口 public interface UserDao { List<User> findAll() throws IOException; } 1.1.2.编写UserDaoImpl实现 public class UserDaoImpl implements UserDao { public List<User> findAll() throws IOException
Java_Mybatis（Dao层_框架）
D大调奏鸣曲_第七序章_de博客
05-06 2774
目录 前言 一、概念 二、实现方法 2.1 配置文件开发 1) 导入MyBatis的坐标和其他相关坐标（创建Maven工程，在pom.xml文件中导入以下坐标（即jar包）） 2）创建user数据表（创建数据库表，Dao层就是对数据库表进行增删改查） 3）编写User实体类 4）编写UserMapper映射文件（放在Maven工程_resources包下） 5）编写MyBatis核心文件sqlMapConfig.xml（数据源环境、别名、映射文件等） 6)编写测试代码 2.2 注解开.
Mybatis的入门、接口代理实现dao以及注解开发
郝的博客
07-14 777
本文介绍了Mybatis的快速入门使用、接口代理实现dao以及注解开发
Mybatis中的Dao接口是什么？Dao接口里面的方法能重载吗？
JSANXWT的博客
10-25 757
通常一个 xml 映射文件，都会写一个 Dao 接口与之对应。Dao 接口里的方法可以重载，但是 Mybatis 的 xml 里面的 ID 不允许重复。接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为。能正常运行，并能得到相应的结果，这样就实现了在 Dao 接口中写重载方法。值，接口方法内的参数，就是传递给 sql 的参数。中利用 Mybatis 的动态 sql 就可以实现。接口，接口的全限名，就是映射文件中的。的值，接口的方法名，就是映射文件中。标签，都会被解析为一个。
mybatis中Dao的三种实现方式
同是天涯程序猿
07-23 1657
mybatis是继Hibernate后优秀的ORM框架之一，是支持自定义SQL，存储过程和高级映射的第一类持久化框架。本文将总结一下mybatis中Dao的三种实现方式。 1.Dao类调用映射文件：创建BaseDao，BaseDao中有sqlSession和对数据库的相关操作，其他Dao类继承BaseDao来实现使用sqlSession，其他的Dao类调用xml文件中定义的select中的id方
配置Java开发环境
最新发布
Broken_x的博客
07-10 1287
Java开发环境配置
mybatis通用dao层封装代码实现
06-01
下面是一个使用Mybatis-Plus进行通用DAO层封装的示例代码： 1. 首先，我们需要引入Mybatis-Plus依赖： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.4.2</version> </dependency> ``` 2. 接着，我们需要定义一个基础的Mapper接口，用于封装通用的增删改查操作： ```java import com.baomidou.mybatisplus.core.mapper.BaseMapper; public interface MyBaseMapper<T> extends BaseMapper<T> { } ``` 3. 然后，我们需要定义一个基础的Service接口，用于封装通用的增删改查操作： ```java import com.baomidou.mybatisplus.extension.service.IService; public interface MyBaseService<T> extends IService<T> { } ``` 4. 最后，我们需要定义一个基础的ServiceImpl实现类，用于实现通用的增删改查操作： ```java import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; public abstract class MyBaseServiceImpl<M extends MyBaseMapper<T>, T> extends ServiceImpl<M, T> implements MyBaseService<T> { } ``` 通过以上代码实现，我们可以很方便地使用Mybatis-Plus进行通用DAO层封装。接下来，我们只需要定义具体的Mapper和Service接口，继承以上基础接口即可，如： ```java public interface UserMapper extends MyBaseMapper<User> { } public interface UserService extends MyBaseService<User> { } public class UserServiceImpl extends MyBaseServiceImpl<UserMapper, User> implements UserService { } ``` 这样，我们就可以通过UserService接口，调用Mybatis-Plus提供的通用方法，实现对User表的增删改查操作了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值