MyBatis的动态SQL实战

最新推荐文章于 2023-02-04 20:48:42 发布
最新推荐文章于 2023-02-04 20:48:42 发布
阅读量286 收藏 2
点赞数
分类专栏： MyBatis 文章标签： MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqiuming/article/details/100179726
版权

一 设计数据表

CREATE TABLE tb_employee (
  ID INT(11) PRIMARY KEY AUTO_INCREMENT,
  loginname VARCHAR(18),
  PASSWORD VARCHAR(18),
  NAME VARCHAR(18) DEFAULT NULL,
  SEX CHAR(2) DEFAULT NULL,
  AGE INT(11) DEFAULT NULL,
  phone VARCHAR(21),
  sal DOUBLE,
  state VARCHAR(18)
);
INSERT INTO tb_employee(loginname,PASSWORD,NAME,sex,age,phone,sal,state)
VALUES('jack','123456','杰克','男',26,'13902019999',9800,'ACTIVE');
  INSERT INTO tb_employee(loginname,PASSWORD,NAME,sex,age,phone,sal,state)
VALUES('rose','123456','露丝','女',21,'13902018888',6800,'ACTIVE');

二 领域模型

package org.fkit.domain;
import java.io.Serializable;

public class Employee implements Serializable {
     
     private static final long serialVersionUID = 1L;
     
     private Integer id;              // 主键id
     private String loginname;   // 登录名
     private String password;    // 密码
     private String name;        // 真实姓名
     private String sex;              // 性别
     private Integer age;        // 年龄
     private String phone;       // 电话
     private Double sal;             // 薪水
     private String state;      // 状态
     
     public Employee() {
           super();
           // TODO Auto-generated constructor stub
     }
     public Integer getId() {
           return id;
     }
     public void setId(Integer id) {
           this.id = id;
     }
     public String getLoginname() {
           return loginname;
     }
     public void setLoginname(String loginname) {
           this.loginname = loginname;
     }
     public String getPassword() {
           return password;
     }
     public void setPassword(String password) {
           this.password = password;
     }
     public String getName() {
           return name;
     }
     public void setName(String name) {
           this.name = name;
     }
     public String getSex() {
           return sex;
     }
     public void setSex(String sex) {
           this.sex = sex;
     }
     public Integer getAge() {
           return age;
     }
     public void setAge(Integer age) {
           this.age = age;
     }
     public String getPhone() {
           return phone;
     }
     public void setPhone(String phone) {
           this.phone = phone;
     }
     public Double getSal() {
           return sal;
     }
     public void setSal(Double sal) {
           this.sal = sal;
     }
     public String getState() {
           return state;
     }
     public void setState(String state) {
           this.state = state;
     }
     @Override
     public String toString() {
           return "Employee [id=" + id + ", loginname=" +  loginname
                     + ", password=" + password + ", name=" +  name + ", sex=" + sex
                     + ", age=" + age + ", phone=" + phone + ",  sal=" + sal
                     + ", state=" + state + "]";
     }
}

三 会话工厂

package org.fkit.factory;

import java.io.InputStream;

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

public class FKSqlSessionFactory {
    
    private static SqlSessionFactory sqlSessionFactory = null;
    
    // 初始化创建SqlSessionFactory对象
    static{
        try (// 读取mybatis-config.xml文件
                InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            ){
            sqlSessionFactory = new SqlSessionFactoryBuilder()
                    .build(is);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    // 获取SqlSession对象的静态方法
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }

    // 获取SqlSessionFactory的静态方法
    public static SqlSessionFactory getSqlSessionFactory() {
        return sqlSessionFactory;
    }

}

四 配置文件

1 db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/mybatis
username=root
password=123456

2 log4j.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">  
<log4j:configuration  xmlns:log4j="http://jakarta.apache.org/log4j/">  
    <appender name="STDOUT"  class="org.apache.log4j.ConsoleAppender">  
        <layout class="org.apache.log4j.PatternLayout">  
            <param name="ConversionPattern" value="%5p [%t] %m%n"  />  
        </layout>  
    </appender>   
     <logger name="org.fkit.mapper">  
        <level value="DEBUG" />  
    </logger>
    <root>  
        <level value="ERROR" />  
        <appender-ref ref="STDOUT" />  
    </root>  
</log4j:configuration>

3 mybatis-config.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">
  <!--  XML 配置文件包含对 MyBatis 系统的核心设置 -->
<configuration>
     <properties resource="db.properties"/>
     <!-- 指定 MyBatis 所用日志的具体实现 -->
     <settings>
           <setting name="logImpl" value="LOG4J"/>
           <!-- 要使延迟加载生效必须配置下面两个属性 -->
           <setting name="lazyLoadingEnabled" value="true"/>
           <setting name="aggressiveLazyLoading" value="false"/>
     </settings>
     <environments default="mysql">
     <!-- 环境配置，即连接的数据库。 -->
    <environment id="mysql">
    <!--  指定事务管理类型，type="JDBC"指直接简单使用了JDBC的提交和回滚设置 -->
      <transactionManager type="JDBC"/>
      <!--  dataSource指数据源配置，POOLED是JDBC连接对象的数据源连接池的实现。 -->
      <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告诉了MyBatis去哪里找持久化类的映射文件 -->
  <mappers>
      <mapper resource="org/fkit/mapper/EmployeeMapper.xml"/>
  </mappers>
</configuration>

五 mapper

1 EmployeeMapper

package org.fkit.mapper;

import java.util.HashMap;
import java.util.List;
import org.fkit.domain.Employee;

public interface EmployeeMapper {
    
    List<Employee> selectEmployeeByIdLike(HashMap<String, Object> params);
    
    List<Employee> selectEmployeeByLoginLike(HashMap<String, Object> params);
    
    List<Employee> selectEmployeeChoose(HashMap<String, Object> params);
    
    List<Employee> findEmployeeLike(HashMap<String, Object> params);
    
    List<Employee> selectEmployeeLike(HashMap<String, Object> params);
    
    Employee selectEmployeeWithId(Integer id);
    
    void updateEmployeeIfNecessary(Employee employee);
    
    List<Employee> selectEmployeeIn(List<Integer> ids);
    
    List<Employee> selectEmployeeLikeName(Employee employee);
    
    

}

2 EmployeeMapper.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">
<!-- namespace指用户自定义的命名空间。 -->
<mapper namespace="org.fkit.mapper.EmployeeMapper">
  <select id="selectEmployeeWithId" parameterType="int"  resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee where id = #{id}
  </select>
     
  <!-- if -->
  <select id="selectEmployeeByIdLike"
      resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee WHERE state = 'ACTIVE'
      <!-- 可选条件，如果传进来的参数有id属性，则加上id查询条件 -->
      <if test="id != null ">
           and id = #{id}
      </if>
  </select>
  
  <!-- if -->
  <select id="selectEmployeeByLoginLike"
      resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee WHERE state = 'ACTIVE'
      <!-- 两个可选条件，例如登录功能的登录名和密码查询 -->
      <if test="loginname != null and password != null">
           and loginname = #{loginname} and password =  #{password}
      </if>
  </select>
  
  <!-- choose（when、otherwise） -->
  <select id="selectEmployeeChoose"
      parameterType="hashmap"
      resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee WHERE state = 'ACTIVE'
      <!-- 如果传入了id，就根据id查询，没有传入id就根据loginname和password查询，否则查询sex等于男的数据 -->
      <choose>
           <when test="id != null">
                and id = #{id}
           </when>
           <when test="loginname != null and password != null">
                and loginname = #{loginname} and password =  #{password}
           </when>
           <otherwise>
                and sex = '男'
           </otherwise>
      </choose>
  </select>
  
  <!-- 没有使用where元素，如果没有传入state参数，会导致执行失败 -->
  <select id="findEmployeeLike"  
      resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee WHERE
      <if test="state != null ">
           state = #{state}
      </if>
      <if test="id != null ">
           and id = #{id}
      </if>
      <if test="loginname != null and password != null">
           and loginname = #{loginname} and password =  #{password}
      </if>
  </select>
  
  <!-- where -->
  <select id="selectEmployeeLike"
      resultType="org.fkit.domain.Employee">
      SELECT * FROM tb_employee  
      <where>
           <if test="state != null ">
                state = #{state}
          </if>
          <if test="id != null ">
                and id = #{id}
          </if>
          <if test="loginname != null and password != null">
                and loginname = #{loginname} and password =  #{password}
          </if>
      </where>
  </select>
  
  <!-- set -->
  <update id="updateEmployeeIfNecessary"
      parameterType="org.fkit.domain.Employee">
       update tb_employee
         <set>
           <if test="loginname !=  null">loginname=#{loginname},</if>
           <if test="password !=  null">password=#{password},</if>
           <if test="name != null">name=#{name},</if>
           <if test="sex != null">sex=#{sex},</if>
           <if test="age != null">age=#{age},</if>
           <if test="phone != null">phone=#{phone},</if>
           <if test="sal != null">sal=#{sal},</if>
           <if test="state != null">state=#{state}</if>
         </set>
       where id=#{id}
     </update>
  
  <!-- foreach -->
  <select id="selectEmployeeIn"  resultType="org.fkit.domain.Employee">
       SELECT *
       FROM tb_employee
       WHERE ID in
       <foreach item="item" index="index" collection="list"
           open="(" separator="," close=")">
             #{item}
       </foreach>
  </select>
  
  <!-- bind -->
     <select id="selectEmployeeLikeName"   resultType="org.fkit.domain.Employee">
       <bind name="pattern" value="'%' + _parameter.getName() +  '%'" />
          SELECT * FROM tb_employee
          WHERE loginname LIKE #{pattern}
     </select>
</mapper>

六 测试代码

package org.fkit.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.fkit.domain.Employee;
import org.fkit.factory.FKSqlSessionFactory;
import org.fkit.mapper.EmployeeMapper;


public class DynamicSQLTest {

    public static void main(String[] args)  {
        
        // 定义SqlSession变量
        SqlSession sqlSession = null;
        try {
            // 创建SqlSession实例
            sqlSession = FKSqlSessionFactory.getSqlSession();
            
            DynamicSQLTest t = new DynamicSQLTest();
            
            t.testSelectEmployeeByIdLike(sqlSession);
            
//            t.testSelectEmployeeByLoginLike(sqlSession);
            
//            t.testSelectEmployeeChoose(sqlSession);
            
            // 没有使用where元素，如果没有传入state参数，会导致执行失败 的例子
//            t.testFindEmployeeLike(sqlSession);
            
//            t.testSelectEmployeeLike(sqlSession);
            
//            t.testUpdateEmployeeIfNecessary(sqlSession);
            
//            t.testSelectEmployeeIn(sqlSession);
            
//            t.testSelectEmployeeLikeName(sqlSession);
            
            // 提交事务
            sqlSession.commit();
        } catch (Exception e) {
            // 回滚事务
            sqlSession.rollback();
            e.printStackTrace();
        }finally {
            // 关闭SqlSession
            if(sqlSession != null)
                sqlSession.close();
        }
                
    }
    
    // 测试<select id="selectEmployeeByIdLike" ...>
    public void testSelectEmployeeByIdLike(SqlSession sqlSession){
        // 获得EmployeeMapper接口的代理对象
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        // 创建一个HashMap存储参数
        HashMap<String, Object> params = new HashMap<String, Object>();
        // 设置id属性
        params.put("id", 1);
        // 调用EmployeeMapper接口的selectEmployeeByIdLike方法
        List<Employee> list = em.selectEmployeeByIdLike(params);
        // 查看返回结果
        list.forEach(employee -> System.out.println(employee));
    }
    
    public void testSelectEmployeeByLoginLike(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        HashMap<String, Object> params = new HashMap<String, Object>();
        // 设置loginname和password属性
        params.put("loginname", "jack");
        params.put("password", "123456");
        List<Employee> list = em.selectEmployeeByLoginLike(params);
        list.forEach(employee -> System.out.println(employee));
    }
    
    public void testSelectEmployeeChoose(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        HashMap<String, Object> params = new HashMap<String, Object>();
        // 设置id属性
        params.put("id", 1);
        params.put("loginname", "jack");
        params.put("password", "123456");
        List<Employee> list = em.selectEmployeeChoose(params);
        list.forEach(employee -> System.out.println(employee));
    }
    
    // 没有使用where元素，如果没有传入state参数，会导致执行失败 的例子
    public void testFindEmployeeLike(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        HashMap<String, Object> params = new HashMap<String, Object>();
        params.put("id", 1);
        params.put("loginname", "jack");
        params.put("password", "123456");
        List<Employee> list = em.findEmployeeLike(params);
        list.forEach(employee -> System.out.println(employee));
    }
    
    public void testSelectEmployeeLike(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        HashMap<String, Object> params = new HashMap<String, Object>();
        // 设置state属性和id属性
        params.put("id", 1);
        params.put("loginname", "jack");
        params.put("password", "123456");
        List<Employee> list = em.selectEmployeeLike(params);
        list.forEach(employee -> System.out.println(employee));
    }
    
    public void testUpdateEmployeeIfNecessary(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        Employee employee = em.selectEmployeeWithId(4);
        // 设置需要修改的属性
        employee.setLoginname("mary");
        employee.setPassword("123");
        employee.setName("玛丽");
        em.updateEmployeeIfNecessary(employee);
    }
    
    public void testSelectEmployeeIn(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        // 创建List集合
        List<Integer> ids = new ArrayList<Integer>();
        // 往List集合中添加两个测试数据
        ids.add(1);
        ids.add(2);
        List<Employee> list = em.selectEmployeeIn(ids);
        list.forEach(employee -> System.out.println(employee));
    }
    
    public void testSelectEmployeeLikeName(SqlSession sqlSession){
        EmployeeMapper em = sqlSession.getMapper(EmployeeMapper.class);
        Employee employee = new Employee();
        // 设置模糊查询的参数
        employee.setName("o");
        List<Employee> list = em.selectEmployeeLikeName(employee);
        list.forEach(result -> System.out.println(result));
    }
}

七 测试效果

1 测试testSelectEmployeeByIdLike

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE  state = 'ACTIVE' and id = ?
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] <==      Total: 1
Employee [id=1, loginname=jack, password=123456, name=杰克,  sex=男, age=26, phone=13902019999, sal=9800.0, state=ACTIVE]

2 测试testSelectEmployeeByLoginLike

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE  state = 'ACTIVE' and loginname = ? and password = ?
DEBUG [main] ==> Parameters: jack(String), 123456(String)
DEBUG [main] <==      Total: 1
Employee [id=1, loginname=jack, password=123456, name=杰克,  sex=男, age=26, phone=13902019999, sal=9800.0, state=ACTIVE]

3 测试testSelectEmployeeChoose

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE  state = 'ACTIVE' and id = ?
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] <==      Total: 1
Employee [id=1, loginname=jack, password=123456, name=杰克,  sex=男, age=26, phone=13902019999, sal=9800.0, state=ACTIVE]

4 测试testFindEmployeeLike

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE and  id = ? and loginname = ? and password = ?
DEBUG [main] ==> Parameters: 1(Integer), jack(String),  123456(String)
org.apache.ibatis.exceptions.PersistenceException:
### Error querying database.  Cause:  com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: You  have an error in your SQL syntax; check the manual that  corresponds to your MySQL server version for the right syntax to  use near 'and id = 1

5 测试testSelectEmployeeLike

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE id  = ? and loginname = ? and password = ?
DEBUG [main] ==> Parameters: 1(Integer), jack(String),  123456(String)
DEBUG [main] <==      Total: 1
Employee [id=1, loginname=jack, password=123456, name=杰克,  sex=男, age=26, phone=13902019999, sal=9800.0, state=ACTIVE]

6 测试testUpdateEmployeeIfNecessary

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee where id  = ?
DEBUG [main] ==> Parameters: 1(Integer)
DEBUG [main] <==      Total: 1
DEBUG [main] ==>  Preparing: update tb_employee SET loginname=?,  password=?, name=?, sex=?, age=?, phone=?, sal=?, state=? where  id=?
DEBUG [main] ==> Parameters: mary(String), 123(String), 玛丽(String), 男(String), 26(Integer), 13902019999(String),  9800.0(Double), ACTIVE(String), 1(Integer)
DEBUG [main] <==    Updates: 1

7 测试testSelectEmployeeIn

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE ID  in ( ? , ? )
DEBUG [main] ==> Parameters: 1(Integer), 2(Integer)
DEBUG [main] <==      Total: 2
Employee [id=1, loginname=mary, password=123, name=玛丽, sex=男,  age=26, phone=13902019999, sal=9800.0, state=ACTIVE]
Employee [id=2, loginname=rose, password=123456, name=露丝,  sex=女, age=21, phone=13902018888, sal=6800.0, state=ACTIVE]

8 测试testSelectEmployeeLikeName

DEBUG [main] ==>  Preparing: SELECT * FROM tb_employee WHERE  loginname LIKE ?
DEBUG [main] ==> Parameters: %o%(String)
DEBUG [main] <==      Total: 1
Employee [id=2, loginname=rose, password=123456, name=露丝,  sex=女, age=21, phone=13902018888, sal=6800.0, state=ACTIVE]

 

chengqiuming
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis动态SQL
qq_40320015的博客
09-17 631
一、使用动态SQL完成多条件查询 动态SOL是MyBatis的一个强大的特性。在使用JDBC操作数据时，如果查询条件特别多，将条件串联成SQL字符串是一件痛苦的事情。通常的解决方法是写很多的if-else条件语句对字符丰进行拼接，并确保不能忘了空格或在字段的最后省略逗号。MyBatis使用一种强大的动态SOL语言来改善这种情形。动态SQL基于OGNL的表达式，可使我们方便地在SQL语句中实现某些逻...
mybatis实战之路，疯狂的数据库操作框架、动态sql的mybats之快速搭建基本环境
try
03-19 1111
1、快速配置环境 引入jar,解压jar,找到mybatis-3.2.2.jar\org\apache\ibatis\builder\xml下的两个dtd文件添加到eclipse中如下图： 如果你能记得住标签就不用了，当然也是能提高写代码速度的。 2、编写核心配置文件 核心配置文件是用于连接数据库的配置文件，以及增删改查具体操作的映射文件。如下图： <!DOCTYPE co
MyBatis最佳实践之——动态SQL语句
yuiezt的专栏
02-04 88
使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。
SSM框架实战系列之十二_MyBatis框架之动态查询
hanhf的专栏
12-08 1365
SSM框架实战系列之十二_MyBatis框架之动态查询
【荐】Mybatis实战心得
攻城狮的博客
07-25 165
--------mybatis-------- <!--动态SQL语句，多条件查询--> <select id="findSomeByMore" resultType="userInfoModel" parameterType="hashmap"> select * from userinfo -- (where标签自动去掉满足条件的第一个and) <w...
Mybatis-Plus实战
06-03
它们支持and、or、eq、ne、like等条件，使得动态SQL编写变得简单。 四、高级特性 1. 自动填充：MP支持字段自动填充，如创建时间、更新时间等，只需在实体类中定义注解@TableField(fill = FieldFill.INSERT)。 2. ...
mybatis-plu实战数据源.sql
11-07
mybatis-plu实战数据源，主要用于演示mybatas-plus的核心功能操作。
《spring+mybatis 企业应用实战》源码、类库全资料
06-07
同时，MyBatis 提供了动态SQL的功能，使得在编写复杂查询时更加便捷。 Spring 和 MyBatis 集成后，可以发挥各自的优势，Spring 负责业务逻辑的组织和管理，MyBatis 负责数据的CRUD操作。通常，我们会使用 Spring 的...
详解Mybatis框架SQL防注入指南
08-18
5. 对于动态SQL，考虑使用`<if>`、`<choose>`等标签来限制可能的执行路径，避免直接使用字符串拼接。 总的来说，了解Mybatis的SQL注入防护机制，并结合代码审查和测试，可以有效地防止这类安全问题的发生。在开发...
spring+mybatis企业应用实战官方源码下载
06-01
spring+mybatis企业应用实战官方源码下载，含光盘所有内容，除了官方的02-14讲义的源码外，13张的sql我也手写了，且综合资源压缩资源359M，资源未做任何精简，myeclispe和eclipse能直接引用运行。
MyBatis动态SQL的学习心得
LiQiangQiangIT的博客
12-15 627
MyBatis动态SQL的学习心得 1、if元素 相当于JAVA中的if语句。常常和test属性联合使用，有如下查询要求 1>当name不为空时，执行模糊查询。如下代码清单： <select id="selData" parameterType="string" resultType="com.test.Data"> select * from data where 1=1 ...
MyBatis学习10-动态SQL
wwww641788662的博客
07-07 164
MyBatis学习10-动态SQL1 概述2 if3 choose (when, otherwise)4 trim (where, set)5 foreach 1 概述 业务上经常会出现不同条件下需要组装不同的 SQL 语句，使用 Java 代码进行 SQL 语句的组装过于复杂，MyBatis 针对这一痛点，提供了动态 SQL 来解决该问题。动态 SQL 是 MyBatis 的强大特性之一。借助功能强大的基于 OGNL 的表达式，使我们完成复杂 SQL 更为简单。 2 if if 标签是动态 SQL 中最为
SqlSession was not registered for synchronization because synchronization is not active
m0_49142489的博客
06-25 6558
遇到的SqlSession报错问题
MyBatis学习之 一级缓存与二级缓存
wuqihawubito的博客
10-02 139
首先创建项目，这里就不使用Spring框架了，直接用mybatis原生： 文章目录准备工作一级缓存：二级缓存 准备工作 首先创建maven项目，引入依赖： <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId
MyBatis实战：动态SQL
qq_44656531的博客
06-23 1440
在我们日常开发中我们经常会有通过多张表查询数据的需求，而这种SQL的编写语句通常过于复杂容易出错，在mybatis中我们可以通过其所提供的标签实现动态SQL帮助我们日常开发。 实例说明： 在上述实例说明中展示了两个例子，其中因为在xml文件中是禁止出现符号的，那么在xml文件标签中的判断类符号通常使用实体符号去代替。在我们使用标签的时候我们很容易引起SQL的语法错误，在我们同时使用标签的时候可以很好地解决这一问题，在标签中存放一个或多个标签，当其中一个标签为true，标签会变成SQL语句中的wher
Mybatis动态SQL的使用案例（实战Demo）
辰兮要努力
02-24 3252
【辰兮要努力】：hello你好我是辰兮，很高兴你能来阅读，昵称是希望自己能不断精进，向着优秀程序员前行！ 博客来源于项目以及编程中遇到的问题总结，偶尔会有读书分享，我会陆续更新Java前端、后台、数据库、项目案例等相关知识点总结，感谢你的阅读和关注，希望我的博客能帮助到更多的人，分享获取新知，大家一起进步! 吾等采石之人，应怀大教堂之心，愿你们奔赴在各自的热爱中… 文章目录一、文章序言二、实例应用1、动态SQL:if+where 语句2、动态SQL:if+set 语句 一、文章序言 开局分享一波干.
MyBatis 菜鸟教程 1 环境配置
热门推荐
菜鸟教程
01-10 1万+
MyBatis MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Map
Mybatis动态sql语句
weixin_34273481的博客
01-04 75
1.if 通过if把会做的事情有条件的包含在where里面，例子： select * from tb_employee where state='active' &lt;if test='id!=null and sex!=null'&gt; and id=#{id} and sex=#{sex} &lt;/if&gt; 这句话意思是如果没有传入id这个参数，那么...
MyBatis中的动态SQL
Hopefully Sky的博客
08-06 3032
1、静态SQL与动态SQL       首先，所谓SQL的动态和静态，是指SQL语句在何时被编译和执行，二者都是用在SQL嵌入式编程中的，这里所说的嵌入式是指将SQL语句嵌入在高级语言中，而不是针对于单片机的那种嵌入式编程。        在某种高级语言中，如果嵌入了SQL语句，而这个SQL语句的主体结构已经明确，例如在Java的一段代码中有一个待执行的SQL语句：“select * from t1
2024最新MyBatis CRUD操作，动态SQL HM
最新发布
03-21
"2024最新MyBatis CRUD操作，动态SQL HM" 在本文中，我们将探讨MyBatis框架在2024年的最新应用，包括CRUD操作和动态SQL，以及如何在实际项目中应用这些技术。我们将以《tlias智能学习辅助系统》中的员工管理需求为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值