18-mybatis高级

最新推荐文章于 2022-11-03 15:54:52 发布
最新推荐文章于 2022-11-03 15:54:52 发布
阅读量196 收藏
点赞数
分类专栏： mybatis JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296313/article/details/112207050
版权

mybatis注解开发实现CRUD(重要)

1 Mapper接口中使用注解

public interface StudentMapper {

  //查询全部
  @Select("select * from student")
  public abstract List<Student> selectAll();

  //根据id查询
  @Select("select * from student where id=#{id}")
  public abstract Student selectById(Integer id);

  //新增数据
  @Insert("insert into student values(null,#{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);
  
}

2 核心配置文件引入Mapper

<!--加载映射文件-->
<mappers>
  <!--引入mapper接口的位置-->
  <!--<mapper class="com.itheima.mapper.StudentMapper"/>-->

  <!--引入整个包-->
  <package name="com.itheima.mapper"/>
</mappers>

3 测试类

public class StudentTest {
  @Test
  public void testSelectAll() throws IOException {
    //1、加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //2、获取工厂对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //3、获取SqlSession核心对象
    SqlSession sqlSession = factory.openSession(true);
    //4、获取接口的实现类代理对象，执行操作
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List<Student> list = mapper.selectAll();
    //5、处理/打印结果
    list.forEach(stu-> System.out.println(stu));
    //6、释放资源
    sqlSession.close();
  }
  @Test
  public void testSelectById() throws IOException {
    //1、加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //2、获取工厂对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //3、获取SqlSession核心对象
    SqlSession sqlSession = factory.openSession(true);
    //4、获取接口的实现类代理对象，执行操作
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    Student student = mapper.selectById(3);   //底层使用sqlSession.selectOne()方法
    //5、处理/打印结果
    System.out.println(student);
    //6、释放资源
    sqlSession.close();
  }
  @Test
  public void testInsert() throws IOException {
    //1、加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //2、获取工厂对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //3、获取SqlSession核心对象
    SqlSession sqlSession = factory.openSession(true);
    //4、获取接口的实现类代理对象，执行操作
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    Integer count = mapper.insert(new Student(null, "刘曲", 30));
    //5、处理/打印结果
    System.out.println("count = " + count);
    //6、释放资源
    sqlSession.close();
  }
  @Test
  public void testUpdate() throws IOException {
    //1、加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //2、获取工厂对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //3、获取SqlSession核心对象
    SqlSession sqlSession = factory.openSession(true);
    //4、获取接口的实现类代理对象，执行操作
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    Integer count = mapper.update(new Student(13, "刘曲", 40));
    //5、处理/打印结果
    System.out.println("count = " + count);
    //6、释放资源
    sqlSession.close();
  }
  @Test
  public void testSelectDelete() throws IOException {
    //1、加载核心配置文件
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //2、获取工厂对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //3、获取SqlSession核心对象
    SqlSession sqlSession = factory.openSession(true);
    //4、获取接口的实现类代理对象，执行操作
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    Integer count = mapper.delete(13);
    //5、处理/打印结果
    System.out.println("count = " + count);
    //6、释放资源
    sqlSession.close();
  }
}

mybatis注解多表开发(注解)

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

在这里插入图片描述

在这里插入图片描述

1 一对一

OneToOneMapper接口中执行查询
public interface OneToOneMapper {
  //查询全部
  @Select("select * from card")
  @Results({
    //id = true 表示是主键，默认值是false
    @Result(id = true,column = "id",property = "id"), //id标签
    @Result(column = "number",property = "number"), //result标签
    //column = "pid" 此处的column = "pid"表示拿着pid的值传递到selectById方法中查询对应的person信息，封装到property = "p"属性中
    @Result(
      column = "pid",//根据查询出的card表中的pid字段来查询person表
      property = "p",//被包含对象的变量名
      javaType = Person.class,//被包含对象的实际数据类型
        /*
              one=@One 一对一固定写法
              select属性：指定调用哪个接口中的那个方法
                     */
      one = @One(select = "com.itheima.mapper.PersonMapper.selectById")), //result标签
  })
  public abstract List<Card> selectAll();
}
新建PersonMaper接口，创建方法根据id查询
public interface PersonMapper {
  @Select("select * from person where id=#{id}")
  Person selectById(Integer id);
}
测试方法
/*
        测试一对一关系：查询所有card的信息，包括每个card对应的person信息
     */
@Test
public void testOneToOneMapper(){
  //加载资源
  SqlSession sqlSession = null;
  try {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //获取SqlSessionFactory对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //获取SqlSession对象
    sqlSession = factory.openSession(true);
    //获取mapper接口的代理对象，执行方法
    OneToOneMapper mapper = sqlSession.getMapper(OneToOneMapper.class);
    List<Card> cards = mapper.selectAll();
    //打印结果
    cards.forEach(card -> System.out.println(card));
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(sqlSession!=null){
      //释放资源
      sqlSession.close();
    }
  }
}

2 一对多

OneToManyMapper接口中执行查询
//查询全部
@Select("select * from classes")
@Results({
  @Result(id = true,column = "id",property = "id"),
  @Result(column = "name",property = "name"),
  @Result(
    property = "students",
    javaType = List.class,
    column = "id",
    many = @Many(select = "com.itheima.mapper.StudentMapper.selectByCid")),
})
public abstract List<Classes> selectAll();
新建StudentMaper接口，创建方法根据id查询
public interface StudentMapper {
  @Select("select * from student where cid=#{cid}")
  List<Student> selectByCid(int cid);
}
测试方法
/*
        测试一对多关系：查询所有班级以及该班级的所有学生信息
     */
@Test
public void testOneToManyMapper(){
  //加载资源
  SqlSession sqlSession = null;
  try {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //获取SqlSessionFactory对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //获取SqlSession对象
    sqlSession = factory.openSession(true);
    //获取mapper接口的代理对象，执行方法
    OneToManyMapper mapper = sqlSession.getMapper(OneToManyMapper.class);
    List<Classes> classes = mapper.selectAll();
    //打印结果
    classes.forEach(cla -> System.out.println(cla));
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(sqlSession!=null){
      //释放资源
      sqlSession.close();
    }
  }
}

3 多对多

ManyToManyMapper接口中执行查询
public interface ManyToManyMapper {
  //查询全部
  //@Select("select * from student") //没有选课的学生也能被查到
  @Select("select distinct s.* from student s,stu_cr sc where s.id=sc.sid") //没有选课的学生查不到
  @Results({
    @Result(id = true,column = "id",property = "id"),
    @Result(column = "name",property = "name"),
    @Result(column = "age",property = "age"),
    @Result(
      property = "courses",
      javaType = List.class,
      column = "id",
      many = @Many(select = "com.itheima.mapper.CourseMapper.selectBySid")),
  })
  public abstract List<Student> selectAll();
}
新建CourseMaper接口，创建方法根据id查询
public interface CourseMapper {
  @Select("select c.* from stu_cr sc,course c where sc.cid=c.id and sc.sid=#{sid}")
  public List<Course> selectBySid(Integer sid);
}
测试方法
/*
        测试多对多关系：查询所有学生及其选课信息
     */
@Test
public void testManyToManyMapper(){
  //加载资源
  SqlSession sqlSession = null;
  try {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
    //获取SqlSessionFactory对象
    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
    //获取SqlSession对象
    sqlSession = factory.openSession(true);
    //获取mapper接口的代理对象，执行方法
    ManyToManyMapper mapper = sqlSession.getMapper(ManyToManyMapper.class);
    List<Student> list = mapper.selectAll();
    //打印结果
    list.forEach(stu -> System.out.println(stu));
  } catch (IOException e) {
    e.printStackTrace();
  } finally {
    if(sqlSession!=null){
      //释放资源
      sqlSession.close();
    }
  }
}

4 懒加载 — 了解

4.1 在核心配置文件中开启懒加载
<!--开启全局的延迟加载开关-->
<setting name="lazyLoadingEnabled" value="true"/>

<!--取消默认触发懒加载的方法-->
<setting name="lazyLoadTriggerMethods" value=""/>
4.2 如果某个多表操作需要取消懒加载，就使用fetchType = FetchType.EAGER取消，那么就是立即加载
public interface ManyToManyMapper {
  //查询全部
  //@Select("select * from student")
  @Select("select distinct s.* from student s,stu_cr sc where s.id=sc.sid")
  @Results({
    @Result(id = true,column = "id",property = "id"),
    @Result(column = "name",property = "name"),
    @Result(column = "age",property = "age"),
    @Result(
      property = "courses",
      column = "id",
      many = @Many(select = "com.itheima.mapper.CourseMapper.selectBySid",fetchType = FetchType.EAGER)),
  })
  public abstract List<Student> selectAll();

mybatis构建SQL(了解)

-查询操作
    @SelectProvider：生成查询用的SQL语句注解
    	type属性：生成SQL语句功能类字节码对象
    	method属性：指定调用方法(方法名字)
    
-新增操作
    @InsertProvider：生成新增用的SQL语句注解
    	type属性：生成SQL语句功能类字节码对象
    	method属性：指定调用方法(方法名字)
    
-更新操作
    @UpdateProvider：生成修改的SQL语句注解
    	type属性：生成SQL语句功能类字节码对象
    	method属性：指定调用方法(方法名字)
    
-删除操作
    @DeleteProvider：生成修改的SQL语句注解
    	type属性：生成SQL语句功能类字节码对象
    	method属性：指定调用方法(方法名字)

1.提供类和方法返回Sql语句

public class ReturnSql {
  
  public String getSelectCondition(Student stu){
        //select * from student where id=#{id} and name=#{name} and age=#{age}
        //创建初始化语句
    
    		//  select * from student
        SQL sql = new SQL().SELECT("*").FROM("student");

        //判断
        if(stu!=null && stu.getId()!=null){
            sql.WHERE("id=#{id}");
        }
        if(stu!=null && stu.getName()!=null){
            sql.WHERE("name=#{name}"); //where方法会自动添加上and关键字
        }
        if(stu!=null && stu.getAge()!=null){
            sql.WHERE("age=#{age}"); //where方法会自动添加上and关键字
        }
    
    		//  select * from student where id=#{id} and name=#{name} and age=#{age}
        return sql.toString();
    }

  /*public String getSelectCondition(Student stu){
    //select * from student where id=#{id} and name=#{name} and age=#{age}
    //创建初始化语句
    StringBuilder sb=new StringBuilder("select * from student where 1=1");
    //判断
    if(stu!=null && stu.getId()!=null){
      sb.append(" and id=#{id}");
    }
    if(stu!=null && stu.getName()!=null){
      sb.append(" and name=#{name}"); //where方法会自动添加上and关键字
    }
    if(stu!=null && stu.getAge()!=null){
      sb.append(" and age=#{age}"); //where方法会自动添加上and关键字
    }
    return sb.toString();
  }*/
}

2.在Mapper接口的方法上使用@XxxxProvider注解使用构建的sql

@SelectProvider(type = ReturnSql.class,method = "getSelectCondition")
public abstract List<Student> selectCondition(Student stu);

3.测试类测试

@Test
public void testSelectCondition() throws IOException {
  //1、加载核心配置文件
  InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");
  //2、获取工厂对象
  SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
  //3、获取SqlSession核心对象
  SqlSession sqlSession = factory.openSession(true);
  //4、获取接口的实现类代理对象，执行操作
  StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
  //创建条件
  Student stu=new Student();
  //stu.setId(2);
  stu.setAge(25);
  //执行查询
  List<Student> list = mapper.selectCondition(stu);
  //5、处理/打印结果
  list.forEach(student -> System.out.println(student));
  //6、释放资源
  sqlSession.close();
}

补充：注解方式实现动态SQL的脚本方式

//多条件查询
@Select("<script>select * from student\n" +
        "        <where>\n" +
        "            <if test=\"id != null\">\n" +
        "                id=#{id}\n" +
        "            </if>\n" +
        "            <if test=\"name != null and name !='' \">\n" +
        "                and name=#{name}\n" +
        "            </if>\n" +
        "            <if test=\"age != null\">\n" +
        "                and age=#{age}\n" +
        "            </if>\n" +
        "        </where></script>")
public abstract List<Student> selectCondition(Student stu);

//根据多个id查询
@Select("<script>select * from student\n" +
        "        <where>\n" +
        "            <foreach collection=\"list\" open=\"id in(\" close=\")\" item=\"id\" separator=\",\">\n" +
        "                #{id}\n" +
        "            </foreach>\n" +
        "        </where></script>")
public abstract List<Student> selectByIds(List<Integer> ids);

案例改进

在这里插入图片描述

1 项目环境搭建

  • 执行给定的sql，创建项目需要的数据库和表。
  • 创建动态web项目，项目名为mybatis_sms。
  • 将资料中mybatis_sms中的src目录和web目录中的所有内容复制到自己的mybatis_sms中
  • 修改config.properties中连接数据库的参数
  • 在tomcat中修改项目的虚拟目录为sms

2、mybatis环境搭建

  • 复制mybatis和log4j相关的jar包
  • 复制mybatis核心配置文件和log4j的配置文件
  • 修改mybatis核心配置文件(修改引入的属性文件、别名配置、Mapper)

3、删除StudentDaoImpl,在StudentDao接口中使用注解配置CRUD

/*
    Dao层接口
 */
public interface StudentDao {
  //查询所有学生信息
  @Select("select * from student")
  public abstract ArrayList<Student> findAll();

  //条件查询，根据id获取学生信息
  @Select("select * from student where sid=#{id}")
  public abstract Student findById(Integer id);

  //新增学生信息
  @Insert("insert into student(sid,name,age,birthday)values(null,#{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 id);
}

4、在utils包下创建MybatisUtils工具类

public class MybatisUtils {
  private MybatisUtils(){}

  //获取SqlSession对象
  public static SqlSession openSession() throws IOException {
    return openSession(false);
  }

  //获取SqlSession对象
  public static SqlSession openSession(boolean autoCommit) throws IOException {
    InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");

    SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);

    return factory.openSession(autoCommit);
  }

  //释放资源
  public static void close(SqlSession sqlSession){
    if(sqlSession!=null){
      sqlSession.close();
    }
  }
}

5、在StudentServiceImpl中使用mybatis接口代理方式实现dao

public class StudentServiceImpl implements StudentService {
  @Override
  public List<Student> findAll() {
    SqlSession sqlSession = null;
    try {
      //从工具类中获取SqlSession对象
      sqlSession = MybatisUtils.openSession(true);
      //获取dao接口代理对象
      StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
      //执行操作
      return studentDao.findAll();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      MybatisUtils.close(sqlSession);
    }
    return null;
  }

  @Override
  public Student findById(Integer sid) {
    SqlSession sqlSession = null;
    try {
      //从工具类中获取SqlSession对象
      sqlSession = MybatisUtils.openSession(true);
      //获取dao接口代理对象
      StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
      return studentDao.findById(sid);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      MybatisUtils.close(sqlSession);
    }
    return null;
  }

  @Override
  public void save(Student student) {
    SqlSession sqlSession = null;
    try {
      //从工具类中获取SqlSession对象
      sqlSession = MybatisUtils.openSession(true);
      //获取dao接口代理对象
      StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
      //保存
      studentDao.insert(student);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      MybatisUtils.close(sqlSession);
    }
  }

  @Override
  public void update(Student student) {
    SqlSession sqlSession = null;
    try {
      //从工具类中获取SqlSession对象
      sqlSession = MybatisUtils.openSession(true);
      //获取dao接口代理对象
      StudentDao studentDao = sqlSession.getMapper(StudentDao.class);

      studentDao.update(student);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      MybatisUtils.close(sqlSession);
    }
  }
  @Override
  public void delete(Integer sid) {
    SqlSession sqlSession = null;
    try {
      //从工具类中获取SqlSession对象
      sqlSession = MybatisUtils.openSession(true);
      //获取dao接口代理对象
      StudentDao studentDao = sqlSession.getMapper(StudentDao.class);

      studentDao.delete(sid);
    } catch (IOException e) {
      e.printStackTrace();
    } finally {
      MybatisUtils.close(sqlSession);
    }
  }
}
yololee_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis一对多关联查询详解
Jay
05-02 1万+
要点 在Student类中添加List<Classes> classList属性 在Classes类中添加List<Student> students属性 在ClassesMapper.xml中 < resultMap> … < collection ofType="Student"> < /collection> </ resultMap> 在StudentMapper.xml中 < resultMap> ….
mysql/mybatis解决查询字段为关键字的问题condition
luo_yu_1106的博客
03-22 1万+
本来是很简单的一句 select condition from table 但是就是报错 咨询了相关人士后才知道，要把condition加上反引号，也就是esc下面的那个按键 因为condition这个字段在一些数据库工具里面是关键字 所以正确的查询是 select`condition`from table 那么在mybatis/mybatisPlus中记得要把字段都改成加 ...
Mybatis(完）
IT_LaoFan的博客
12-05 359
本篇讲了下模糊查询和分页插件和查询，也是Mybatis的结尾！！!
【Mybatis学习03】动态SQL
一个正在努力学习的iter
03-28 506
1.动态SQL之<if>
MyBatis——基于MyBatis注解的学生管理程序
m0_72151428的博客
11-03 2283
MyBatis——基于MyBatis注解的学生管理程序
quarkus-mybatis:Quarkus MyBatis扩展
03-17
Quarkus MyBatis扩展 MyBatis是一流的持久性框架，支持自定义SQL，存储过程和高级映射。 此扩展为开发人员提供了易于配置和本机支持的功能。 在pom.xml中添加以下依赖项以开始使用， < dependency> < groupId>io....
mybatis-3-mybatis-3.1.0
最新发布
03-04
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使你更好地将精力集中在你的业务逻辑上，而不是数据持久...
SpringMVC-Mybatis-Shiro-redis
02-23
在实际开发过程中，开发者可以根据项目需求调整这四个组件的具体配置，例如优化Mybatis的SQL执行效率，调整Shiro的权限策略，或者利用Redis的高级特性如发布订阅模式来实现更复杂的功能。此外，通过持续集成和自动化...
springboot-mybatis-mysample
06-20
`MyBatis` 是一个优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。将两者结合，可以打造高效且灵活的 Web 应用程序。 **1. Spring Boot 概述** Spring Boot 的核心特性包括： - 自动配置：基于 @...
mybatis-3-mybatis-3.2.6
04-05
MyBatis是一个优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。在深入探讨MyBatis 3.2.6版本的源码之前，我们首先需要了解MyBatis的基本概念和功能。 MyBatis的核心部分主要包括SqlSessionFactory、...
MySQL进阶学习笔记一（未完待续）
weixin_42420792的博客
08-28 1509
一、Linux安装MySQL 1、yum安装 1、下载设置安装源 #下载安装源 wget http://repo.mysql.com/mysql57-community-release-el6-8.noarch.rpm #安装rpm包 rpm -ivh mysql57-community-release-el6-8.noarch.rpm #修改安装源 vim /etc/yum.repos.d/mysql-community.repo 将[mysql55-community]的enabled设置为１,[m
mybatis 联查
weixin_34289454的博客
03-28 77
association关键字： 关联表数据在这个mxl中写 resultmap： 表联查映射 多对一关系 public class Student { private Integer sid; private String sname; private Str...
mybatis-plus 使用Condition拼接Sql语句各方法的作用
热门推荐
万万没想到的博客
01-11 3万+
1.setSqlSelect—用于添加查询的列信息 public Wrapper setSqlSelect(String... columns) { StringBuilder builder = new StringBuilder(); String[] arr = columns; int len = columns.length;
mybatis条件构造器Condition
kanglong129的博客
10-24 5129
@Override public Result getListUnhandle(User user) { List<Integer> formNode = handleRightToNode(user); Condition condition = new Condition(LsUnpassForm.class); cond...
mybatis中"#"和"$"的区别
weixin_33972649的博客
09-18 1183
　　动态 sql 是 mybatis 的主要特性之一，在 mapper 中定义的参数传到 xml 中之后，在查询之前 mybatis 会对其进行动态解析。mybatis 为我们提供了两种支持动态 sql 的语法：#{} 以及 ${}。 　　在下面的语句中，如果 username 的值为 zhangsan，则两种方式无任何区别： 　　 select * from user where na...
MyBatis中#{}和${}的区别详解
weixin_30275415的博客
07-18 147
首先看一下下面两个sql语句的区别： <select id="selectByNameAndPassword" parameterType="java.util.Map" resultMap="BaseResultMap"> select id, username, password, role from user where username = #{username,j...
MyBatis映射文件4(参数获取#{}和${}/select标签详解[返回类型为list])
weixin_30409849的博客
04-19 454
参数获取 之前我们都是采用#{}的方式进行参数传递，其实MyBatis还有另外的参数传递方式${} 使用方法相同，但是还是有很大区别的 这里做一个测试： <selectid="getEmpByMap"resultType="com.figsprite.bean.Employee"> selectid,last_namelastNam...
Mybatis中#{}和${}的用法
li_w_ch的博客
11-17 1万+
1、#{}将传入的数据当作一个字符串，会对传入的数据加上一个双引号。 比如， select * from student where student_name = #{studentName} 如果传入的值为xiaoming，那么解析成sql的值为student_name="xioming"。 2、${}将传入的数据直接显示生成在sql中。 如 : select ${fieldNmae} from student where student_age = 18 此时，传入的参数作为要查询的字
mybatis-plus高级用法
09-13
MyBatis-Plus是一个强大的MyBatis增强工具，提供了许多高级的用法。以下是一些常见的MyBatis-Plus高级用法： 1. 自动填充：通过注解或者实现接口的方式，自动填充实体的创建时间、更新时间等字段。 2. 逻辑删除：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值