Mybatis基础总结-基于注解开发

已于 2023-07-09 12:46:20 修改
阅读量287 收藏 2
点赞数
分类专栏： 框架使用 文章标签： mybatis
于 2023-07-09 12:41:00 首次发布
伟仔
本文链接：https://blog.csdn.net/weixin_42439274/article/details/131621693
版权

mybatis基础-注解开发

一.Mybatis注解开发单表操作

1.1 MyBatis的常用注解

这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper

映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。

@Insert：实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@Result 一起使用，封装多个结果集

@One：实现一对一结果集封装

@Many：实现一对多结果集封装

1.2 MyBatis的增删改查

我们完成简单的student表的增删改查的操作

  • 步骤一:创建mapper接口

    public interface StudentMapper {
    //查询全部
    @Select("SELECT * FROM student")
    public abstract List<Student> selectAll();

    //新增操作
    @Insert("INSERT INTO student VALUES (#{id},#{name},#{age})")
    public abstract Integer insert(Student stu);

    //修改操作
    @Update("UPDATE student SET name=#{name},age=#{age} WHERE id=#{id}")
    public abstract Integer update(Student stu);

    //删除操作
    @Delete("DELETE FROM student WHERE id=#{id}")
    public abstract Integer delete(Integer id);
}

  • 步骤二：测试类

    public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Student> list = mapper.selectAll();

        //6.处理结果
        for (Student student : list) {
            System.out.println(student);
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void insert() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",26);
        Integer result = mapper.insert(stu);

        //6.处理结果
        System.out.println(result);

        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void update() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        Student stu = new Student(4,"赵六",36);
        Integer result = mapper.update(stu);

        //6.处理结果
        System.out.println(result);

        //7.释放资源
        sqlSession.close();
        is.close();
    }

    @Test
    public void delete() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        Integer result = mapper.delete(4);

        //6.处理结果
        System.out.println(result);

        //7.释放资源
        sqlSession.close();
        is.close();
    }
}

  • 注意：

    修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的Mapper接口即可

<mappers>
    <!--扫描使用注解的类-->
    <mapper class="com.itheima.mapper.UserMapper"></mapper>
</mappers>

​ 或者指定扫描包含映射关系的接口所在的包也可以

<mappers>
    <!--扫描使用注解的类所在的包-->
    <package name="com.itheima.mapper"></package>
</mappers>
1.3 注解开发总结

注解可以简化开发操作，省略映射配置文件的编写。

  • 常用注解

    @Select(“查询的 SQL 语句”)：执行查询操作注解

    @Insert(“查询的 SQL 语句”)：执行新增操作注解

    @Update(“查询的 SQL 语句”)：执行修改操作注解

    @Delete(“查询的 SQL 语句”)：执行删除操作注解

  • 配置映射关系

    <mappers> <package name="接口所在包"/> </mappers>

二.MyBatis注解开发的多表操作

2.1 MyBatis的注解实现复杂映射开发

实现复杂关系映射之前我们可以在映射文件中通过配置来实现，使用注解开发后，我们可以使用@Results注解，@Result注解，@One注解，@Many注解组合完成复杂关系的配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oWXOB8CJ-1688877949054)(img\图片10.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xQbMlckB-1688877949057)(img\图片11.png)]

2.2 一对一查询
2.2.1 一对一查询的模型

一对一查询的需求：查询一个用户信息，与此同时查询出该用户对应的身份证信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a7XyTwsT-1688877949058)(img/1590942011460.png)]

2.2.2 一对一查询的语句

对应的sql语句：

SELECT * FROM card；

SELECT * FROM person WHERE id=#{id};
2.2.3 创建PersonMapper接口
public interface PersonMapper {
    //根据id查询
    @Select("SELECT * FROM person WHERE id=#{id}")
    public abstract Person selectById(Integer id);
}
2.2.4 使用注解配置Mapper
public interface CardMapper {
    //查询全部
    @Select("SELECT * FROM card")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "number",property = "number"),
            @Result(
                    property = "p",             // 被包含对象的变量名
                    javaType = Person.class,    // 被包含对象的实际数据类型
                    column = "pid",             // 根据查询出的card表中的pid字段来查询person表
                    /*
                        one、@One 一对一固定写法
                        select属性：指定调用哪个接口中的哪个方法
                     */
                    one = @One(select = "com.itheima.one_to_one.PersonMapper.selectById")
            )
    })
    public abstract List<Card> selectAll();
}
2.2.5 测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取CardMapper接口的实现类对象
        CardMapper mapper = sqlSession.getMapper(CardMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Card> list = mapper.selectAll();

        //6.处理结果
        for (Card card : list) {
            System.out.println(card);
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
2.2.6 一对一配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	one 属性：一对一查询固定属性
 @One：一对一查询的注解。
	select 属性：指定调用某个接口中的方法
2.3 一对多查询
2.3.1 一对多查询的模型

一对多查询的需求：查询一个课程，与此同时查询出该该课程对应的学生信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KOUkUnKr-1688877949059)(img/1590942772892.png)]

2.3.2 一对多查询的语句

对应的sql语句：

SELECT * FROM classes

SELECT * FROM student WHERE cid=#{cid}
2.3.3 创建StudentMapper接口
public interface StudentMapper {
    //根据cid查询student表
    @Select("SELECT * FROM student WHERE cid=#{cid}")
    public abstract List<Student> selectByCid(Integer cid);
}
2.3.4 使用注解配置Mapper
public interface ClassesMapper {
    //查询全部
    @Select("SELECT * FROM classes")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(
                    property = "students",  // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出的classes表的id字段来查询student表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.itheima.one_to_many.StudentMapper.selectByCid")
            )
    })
    public abstract List<Classes> selectAll();
}
2.3.5 测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取ClassesMapper接口的实现类对象
        ClassesMapper mapper = sqlSession.getMapper(ClassesMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Classes> list = mapper.selectAll();

        //6.处理结果
        for (Classes cls : list) {
            System.out.println(cls.getId() + "," + cls.getName());
            List<Student> students = cls.getStudents();
            for (Student student : students) {
                System.out.println("\t" + student);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
2.3.6 一对多配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	many 属性：一对多查询固定属性
@Many：一对多查询的注解。
	select 属性：指定调用某个接口中的方法
2.4 多对多查询
2.4.1 多对多查询的模型

多对多查询的需求：查询学生以及所对应的课程信息

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fhTdYJps-1688877949060)(img/1590943489827.png)]

2.4.2 多对多查询的语句

对应的sql语句：

SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id
SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}
2.4.3 添加CourseMapper 接口方法
public interface CourseMapper {
    //根据学生id查询所选课程
    @Select("SELECT c.id,c.name FROM stu_cr sc,course c WHERE sc.cid=c.id AND sc.sid=#{id}")
    public abstract List<Course> selectBySid(Integer id);
}
2.4.4 使用注解配置Mapper
public interface StudentMapper {
    //查询全部
    @Select("SELECT DISTINCT s.id,s.name,s.age FROM student s,stu_cr sc WHERE sc.sid=s.id")
    @Results({
            @Result(column = "id",property = "id"),
            @Result(column = "name",property = "name"),
            @Result(column = "age",property = "age"),
            @Result(
                    property = "courses",   // 被包含对象的变量名
                    javaType = List.class,  // 被包含对象的实际数据类型
                    column = "id",          // 根据查询出student表的id来作为关联条件，去查询中间表和课程表
                    /*
                        many、@Many 一对多查询的固定写法
                        select属性：指定调用哪个接口中的哪个查询方法
                     */
                    many = @Many(select = "com.itheima.many_to_many.CourseMapper.selectBySid")
            )
    })
    public abstract List<Student> selectAll();
}
2.4.5 测试类
public class Test01 {
    @Test
    public void selectAll() throws Exception{
        //1.加载核心配置文件
        InputStream is = Resources.getResourceAsStream("MyBatisConfig.xml");

        //2.获取SqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        //3.通过工厂对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession(true);

        //4.获取StudentMapper接口的实现类对象
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        //5.调用实现类对象中的方法，接收结果
        List<Student> list = mapper.selectAll();

        //6.处理结果
        for (Student student : list) {
            System.out.println(student.getId() + "," + student.getName() + "," + student.getAge());
            List<Course> courses = student.getCourses();
            for (Course cours : courses) {
                System.out.println("\t" + cours);
            }
        }

        //7.释放资源
        sqlSession.close();
        is.close();
    }

}
2.4.6 多对多配置总结
@Results：封装映射关系的父注解。
	Result[] value()：定义了 Result 数组
@Result：封装映射关系的子注解。
	column 属性：查询出的表中字段名称
	property 属性：实体对象中的属性名称
	javaType 属性：被包含对象的数据类型
	many 属性：一对多查询固定属性
@Many：一对多查询的注解。
	select 属性：指定调用某个接口中的方法

三.构建sql

3.1 SQL 构建对象介绍
  • 我们之前通过注解开发时，相关 SQL 语句都是自己直接拼写的。一些关键字写起来比较麻烦、而且容易出错。
  • MyBatis 给我们提供了 org.apache.ibatis.jdbc.SQL 功能类，专门用于构建 SQL 语句
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OhfbM4Pt-1688877949061)(img/1590943921472.png)]
3.2 查询功能的实现

  • 定义功能类并提供获取查询的 SQL 语句的方法。 

  • @SelectProvider：生成查询用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

3.3 新增功能的实现

  • 定义功能类并提供获取新增的 SQL 语句的方法。

  • @InsertProvider：生成新增用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

3.4 修改功能的实现

  • 定义功能类并提供获取修改的 SQL 语句的方法。

  • @UpdateProvider：生成修改用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

3.5 删除功能的实现

  • 定义功能类并提供获取删除的 SQL 语句的方法。

  • @DeleteProvider：生成删除用的 SQL 语句注解。

    type 属性：生成 SQL 语句功能类对象

    method 属性：指定调用方法

四.综合案例

4.1 系统介绍

​ 我们之前在做学生管理系统时，使用的是原始JDBC操作数据库的，操作非常麻烦，现在我们使用MyBatis操作数据库，简化Dao的开发。

4.2 环境搭建（略）
4.3 代码改造

  • 步骤一：新增MyBatis配置文件 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="config.properties"/>

    <!--配置LOG4J-->
    <settings>
        <setting name="logImpl" value="log4j"/>
    </settings>

    <!--environments配置数据库环境，环境可以有多个。default属性指定使用的是哪个-->
    <environments default="mysql">
        <!--environment配置数据库环境  id属性唯一标识-->
        <environment id="mysql">
            <!-- transactionManager事务管理。  type属性，采用JDBC默认的事务-->
            <transactionManager type="JDBC"></transactionManager>
            <!-- dataSource数据源信息   type属性 连接池-->
            <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>
        <package name="com.itheima"/>
    </mappers>
</configuration>

  • 步骤二: 删除StudentDaoImpl，修改StudentDao

    package com.itheima.dao;
import com.itheima.domain.Student;
  import org.apache.ibatis.annotations.Delete;
  import org.apache.ibatis.annotations.Insert;
  import org.apache.ibatis.annotations.Select;
  import org.apache.ibatis.annotations.Update;

  import java.util.ArrayList;

  /*
      Dao层接口
   */
  public interface StudentDao {
      //查询所有学生信息
      @Select("SELECT * FROM student")
      public abstract ArrayList<Student> findAll();
        //条件查询，根据id获取学生信息
      @Select("SELECT * FROM student WHERE sid=#{sid}")
      public abstract Student findById(Integer sid);

      //新增学生信息
      @Insert("INSERT INTO student VALUES (#{sid},#{name},#{age},#{birthday})")
      public abstract int insert(Student stu);

      //修改学生信息
      @Update("UPDATE student SET name=#{name},age=#{age},birthday=#{birthday} WHERE sid=#{sid}")
      public abstract int update(Student stu);

      //删除学生信息
      @Delete("DELETE FROM student WHERE sid=#{sid}")
      public abstract int delete(Integer sid);
  }

  • 步骤三：修改StudentServiceImpl
    package com.itheima.service.impl;

    import com.itheima.dao.StudentDao;
    import com.itheima.domain.Student;
    import com.itheima.service.StudentService;
    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.ArrayList;
    import java.util.List;

    /**

    • 学生的业务层实现类

    • @author 黑马程序员

    • @Company http://www.itheima.com
      */
      public class StudentServiceImpl implements StudentService {

      @Override
      public List findAll() {
      ArrayList 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.获取StudentDao接口的实现类对象
     StudentDao mapper = sqlSession.getMapper(StudentDao.class);

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

 } catch (Exception 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 findById(Integer sid) {
      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.获取StudentDao接口的实现类对象
     StudentDao mapper = sqlSession.getMapper(StudentDao.class);

     //5.调用实现类对象的方法，接收结果
     stu = mapper.findById(sid);

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

 //7.返回结果
 return stu;

      }

      @Override
      public void save(Student student) {
      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.获取StudentDao接口的实现类对象
     StudentDao mapper = sqlSession.getMapper(StudentDao.class);

     //5.调用实现类对象的方法，接收结果
     mapper.insert(student);

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

      }

      @Override
      public void update(Student student) {
      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.获取StudentDao接口的实现类对象
     StudentDao mapper = sqlSession.getMapper(StudentDao.class);

     //5.调用实现类对象的方法，接收结果
     mapper.update(student);

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

      }

      @Override
      public void delete(Integer sid) {
      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.获取StudentDao接口的实现类对象
     StudentDao mapper = sqlSession.getMapper(StudentDao.class);

     //5.调用实现类对象的方法，接收结果
     mapper.delete(sid);

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

      }
      }

一个双鱼座的测开
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Mybatis的注解开发
qq_56751933的博客
05-24 1701
一、Mybatis的注解开发 1.1 MyBatis的常用注解 这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。 @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 @Result：实现结果集封装 @Results：可以与@Result 一起使用，封装多个结果集 @One：实现一对一结果集封装 @Many：实现一对多结果集封装 1.
MyBatis之注解开发
yandao的博客
05-19 926
除了XML映射方式，MyBatis还支持注解方式实现POJO对象和数据表之间的关联映射，使用注解的方式一般将SQL语句直接写到接口上。与XML的映射方式相比，基于注解的映射方式相对简单。Mybatis提供的注解有： 1.环境准备 1.1 数据库准备 USE mybatis; # 创建一个名称为tb_worker的表 CREATE TABLE tb_worker( id INT PRIMARY KEY AUTO_INCREMENT, name VARCHAR(32), ag
Mybatis注解开发（超详细），超详细
最新发布
2401_83739503的博客
03-29 1052
编程基础的初级开发者，计算机科学专业的学生，以及平时没怎么利用过数据结构与算法的开发人员希望复习这些概念为下次技术面试做准备。或者想学习一些计算机科学的基本概念，以优化代码，提高编程技能。这份笔记都是可以作为参考的。CodeChina开源项目：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
【MyBatis】| MyBatis的注解式开发
m0_61933976的博客
02-18 1864
【MyBatis】| MyBatis的注解式开发
MyBatis注解开发
沐雨橙风ιε的博客
06-10 771
MyBatis使用注解开发
MyBatis-Plus 的官方示例(mybatis-plus-samples-master.zip)
05-05
本工程为 MyBatis-Plus 的官方示例，项目结构如下： mybatis-plus-sample-quickstart: 快速开始示例 mybatis-plus-sample-quickstart-springmvc: 快速开始示例（Spring MVC版本） mybatis-plus-sample-reduce-...
mybatis-plus-code-generator-3.5.2.x.jar
03-09
MyBatis-Plus代码生成器
mybatis-plus-extension-3.4.0.jar
03-01
mybatis-plus-extension-3.4.0.jar
mybatis-spring-boot-starter-2.1.4.jar
01-10
mybatis-spring-boot-starter-2.1.4.jarmybatis-spring-boot-starter-2.1.4.jar
mybatis-3-config.dtd mybatis-3-mapper.dtd
06-04
mybatis配置的重要文件包括mybatis-3-config.dtd mybatis-3-mapper.dtd
springmvc和mybatis框架整合（注解和非注解）
04-11
springmvc和mybatis框架整合，Controller使用注解和非注解方式实现。
Mybatis注解开发（超详细）
segegefe的博客
06-08 2665
注解说明@Insert实现新增@Delete实现删除@Update实现更新@Select实现查询@Result实现结果集封装@Results可以与@Result 一起使用，封装多个结果集@ResultMap实现引用@Results 定义的封装@One实现一对一结果集封装@Many实现一对多结果集封装@SelectProvider实现动态 SQL 映射@CacheNamespace实现注解二级缓存的使用User： 使用注解方式开发持久层接口 IUserDao： 编写 SqlMapConfig.xml 配置文
【MyBatis】基础篇(十四) MyBatis基于注解开发
不想当架构师的程序员不是好程序员
08-19 1647
MyBatis·基础篇(十四) MyBatis基于注解开发 1. mybatis 的常用注解说明 常见注解 作用 @Insert 实现新增 @Update 实现更新 @Delete 实现删除 @Select 实现查询 @Result 实现结果集封装 @Results 可以与@Result 一起使用，封装多个结果集 @ResultMap 实现引用@Resu...
Mybatis注解开发
weixin_46532941的博客
04-03 5196
这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。我们先围绕一些基本的CRUD来学习，再学习复杂映射多表操作。@Insert：实现新增@Update：实现更新@Delete：实现删除@Select：实现查询@Result：实现结果集封装@Results：可以与@Result 一起使用，封装多个结果集@One：实现一对一结果集封装@Many：实现一对多结果集封装。
Mybatis使用注解开发
qq_52146944的博客
04-01 82
mybatis注解开发
Mybatis相关：基于注解的Mybatis开发
zitian246的博客
10-25 470
1.Mybatis常用注解 @Insert:实现新增 @Update:实现更新 @Delete:实现删除 @Select:实现查询 @Result:实现结果集封装 @Results:可以与@Result 一起使用，封装多个结果集 @ResultMap:实现引用@Results 定义的封装 @One:实现一对一结果集封装 @Many:实现一对多结果集封装 @SelectProvider: 实现动态 SQL 映射 @CacheNamespace:实现注解二级缓存的使用 2.基于注解的增删改查
基于mybatis注解的学生管理程序
03-16
基于MyBatis注解的学生管理程序是一个使用Java编写的程序，它通过MyBatis框架来连接数据库并实现对学生信息的管理。在该程序中，使用注解方式代替了传统的XML配置文件，简化了配置过程。 该程序包含了对学生信息的增删改查功能，可以实现向数据库中添加学生信息、修改学生信息、删除学生信息以及查询学生信息等操作。程序通过MyBatis提供的注解来定义SQL语句，使得数据库的操作变得非常方便。 在实现该程序之前，需要先定义好数据库的表结构，并在程序中定义对应的Java类来映射数据库中的表。然后，通过MyBatis提供的注解来定义SQL语句，并将其与Java类中的方法进行绑定。这样，就可以通过Java类的方法来操作数据库了。 总之，基于MyBatis注解的学生管理程序是一个简单而实用的程序，它能够帮助开发者更快捷地实现对学生信息的管理，并且提高了程序的可读性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一个双鱼座的测开

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值