mybati使用（二）

最新推荐文章于 2024-04-19 06:03:18 发布
最新推荐文章于 2024-04-19 06:03:18 发布
阅读量233 收藏
点赞数
分类专栏： java web框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiuwenjie123/article/details/79164534
版权

xml方式下

一、一对多关系（一个分类对应多个产品）

Product实体类

package com.how2java.pojo;
 
public class Product {
    private int id;
    private String name;
    private float price;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";
    }
 
}
Category实体类 
package com.how2java.pojo;
 
import java.util.List;
 
public class Category {
    private int id;
    private String name;
    List<Product> products;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public List<Product> getProducts() {
        return products;
    }
    public void setProducts(List<Product> products) {
        this.products = products;
    }
    @Override
    public String toString() {
        return "Category [id=" + id + ", name=" + name + "]";
    }
     
}
Category映射 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.how2java.pojo">
        <resultMap type="Category" id="categoryBean">                                                                                 <!--column指的是数据库字段名或别名,property指的是实体类的属性名-->
            <id column="cid" property="id" />          <!--主键使用id标签-->
            <result column="cname" property="name" />  <!--非主键使用result标签-->
           <!-- 一对多的关系,使用collection标签 -->                                                  
            <!-- property: 指的是集合属性的值, ofType：指的是集合中元素的类型 -->                               
            <collection property="products" ofType="Product">
                <id column="pid" property="id" />
                <result column="pname" property="name" />
                <result column="price" property="price" />
            </collection>
        </resultMap>
     
        <!-- 关联查询分类和产品表 -->                                                                                                                  <!--因为是关联查询，所以使用resultMap-->
        <select id="listCategory" resultMap="categoryBean">                                           
            select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname' from category_ c left join product_ p on c.id = p.cid
        </select>   
    </mapper>

二、多对一关系（多个产品对应一个分类）

Product实体类 

package com.how2java.pojo;
 
public class Product {
    private int id;
    private String name;
    private float price;
    private Category category;     //增加了Category属性，而在表里则是一个cid
     
    public Category getCategory() {
        return category;
    }
    public void setCategory(Category category) {
        this.category = category;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getPrice() {
        return price;
    }
    public void setPrice(float price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Product [id=" + id + ", name=" + name + ", price=" + price + "]";
    }
 
}
Product类映射文件（ 在mybatis-config.xml中增加对于Product.xml的映射） 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.how2java.pojo">
        <resultMap type="Product" id="productBean">
            <id column="pid" property="id" />
            <result column="pname" property="name" />
            <result column="price" property="price" />
     
            <!-- 多对一的关系，使用association标签 -->
            <!-- property: 指的是属性名称, javaType：指的是属性的类型 -->                                                       <!--此处与JavaType和ofType都是用来指定对象类型的，但是JavaType是用来指定pojo中属性的类型，而ofType指定的是映射到list集合属性中pojo的类型-->
            <association property="category" javaType="Category">
                <id column="cid" property="id"/>
                <result column="cname" property="name"/>
            </association>
        </resultMap>
     
        <!-- 根据id查询Product, 关联将Orders查询出来 -->
        <select id="listProduct" resultMap="productBean">
            select c.*, p.*, c.id 'cid', p.id 'pid', c.name 'cname', p.name 'pname' from category_ c left join product_ p on c.id = p.cid
        </select>   
    </mapper>

二、多对多的关系（一个订单对应多个产品，一个产品对应多个订单）

为了维系多对多关系，必须要一个中间表。 在这里我们使用订单项(OrderItem)表来作为中间表

实体类Order和OrderItem

public class OrderItem {
    private int id;
    private int number;
    private Order order;
    private Product product;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public Order getOrder() {
        return order;
    }
    public void setOrder(Order order) {
        this.order = order;
    }
    public Product getProduct() {
        return product;
    }
    public void setProduct(Product product) {
        this.product = product;
    }
     
}

package com.how2java.pojo;
 
import java.util.List;
 
public class Order {
    private int id;
    private String code;
     
    List<OrderItem> orderItems;
     
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getCode() {
        return code;
    }
    public void setCode(String code) {
        this.code = code;
    }
    public List<OrderItem> getOrderItems() {
        return orderItems;
    }
    public void setOrderItems(List<OrderItem> orderItems) {
        this.orderItems = orderItems;
    }
 
}
映射文件

order.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.how2java.pojo">
        <resultMap type="Order" id="orderBean">
            <id column="oid" property="id" />
            <result column="code" property="code" />
             
            <collection property="orderItems" ofType="OrderItem">
                <id column="oiid" property="id" />
                <result column="number" property="number" />
                <association property="product" javaType="Product">
                    <id column="pid" property="id"/>
                    <result column="pname" property="name"/>
                    <result column="price" property="price"/>
                </association>               
            </collection>
        </resultMap>
         
        <select id="listOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi    on o.id =oi.oid
                left join product_ p on p.id = oi.pid
        </select>
             
        <select id="getOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi on o.id =oi.oid
                left join product_ p on p.id = oi.pid
            where o.id = #{id}
        </select>
    </mapper>
product.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.how2java.pojo">
        <resultMap type="Order" id="orderBean">
            <id column="oid" property="id" />
            <result column="code" property="code" />
             
            <collection property="orderItems" ofType="OrderItem">
                <id column="oiid" property="id" />
                <result column="number" property="number" />
                <association property="product" javaType="Product">
                    <id column="pid" property="id"/>
                    <result column="pname" property="name"/>
                    <result column="price" property="price"/>
                </association>               
            </collection>
        </resultMap>
         
        <select id="listOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi    on o.id =oi.oid
                left join product_ p on p.id = oi.pid
        </select>
             
        <select id="getOrder" resultMap="orderBean">
            select o.*,p.*,oi.*, o.id 'oid', p.id 'pid', oi.id 'oiid', p.name 'pname'
                from order_ o
                left join order_item_ oi on o.id =oi.oid
                left join product_ p on p.id = oi.pid
            where o.id = #{id}
        </select>
    </mapper>
orderItem.xml 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.how2java.pojo">
     
        <insert id="addOrderItem" parameterType="OrderItem">
            insert into order_item_
                values(null,#{order.id},#{product.id},#{number})
        </insert>                                                                                                <!--除了select标签外，其实delete、update、insert标签可以通用，大概是因为他们的底层实现都是一样的吧-->
        <insert id="deleteOrderItem" parameterType="OrderItem">
            delete from order_item_
                where oid = #{order.id} and pid = #{product.id}
        </insert>   
     
    </mapper>

假如要mybatis执行多条sql语句，那么需要增加一个参数allowMultiQueries

<property name="url" value="jdbc:mysql://localhost:3306/how2java?characterEncoding=UTF-8&amp;allowMultiQueries=true"/>

注解方式下

一、增删改查

实体类的Mapper接口（其实就是把sql语句从xml文件挪到了注解上）

import java.util.List;
 
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 com.how2java.pojo.Category;
  
public interface CategoryMapper {
  
    @Insert(" insert into category_ ( name ) values (#{name}) ") 
    public int add(Category category); 
        
    @Delete(" delete from category_ where id= #{id} ") 
    public void delete(int id); 
        
    @Select("select * from category_ where id= #{id} ") 
    public Category get(int id); 
      
    @Update("update category_ set name=#{name} where id=#{id} ") 
    public int update(Category category);  
        
    @Select(" select * from category_ ") 
    public List<Category> list(); 
}
配置文件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">
<configuration>
    <typeAliases>
      <package name="com.how2java.pojo"/>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/how2java?characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="admin"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/how2java/pojo/Category.xml"/>    //这是原先的xml，可删去
        <mapper class="com.how2java.mapper.CategoryMapper"/>   //实体类的Mapper接口映射
    </mappers>
</configuration>
测试类 

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
 
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 com.how2java.mapper.CategoryMapper;
import com.how2java.pojo.Category;
   
public class TestMybatis {
   
    public static void main(String[] args) throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession session = sqlSessionFactory.openSession();
        CategoryMapper mapper = session.getMapper(CategoryMapper.class);   //此处与使用xml文件映射有所不同
  
//        add(mapper);
//        delete(mapper);
//        get(mapper);
//        update(mapper);
        listAll(mapper);
              
        session.commit();
        session.close();
   
    }
  
    private static void update(CategoryMapper mapper) {
        Category c= mapper.get(8);
        c.setName("修改了的Category名稱");
        mapper.update(c);
        listAll(mapper);
    }
  
    private static void get(CategoryMapper mapper) {
        Category c= mapper.get(8);
        System.out.println(c.getName());
    }
  
    private static void delete(CategoryMapper mapper) {
        mapper.delete(2);
        listAll(mapper);
    }
  
    private static void add(CategoryMapper mapper) {
        Category c = new Category();
        c.setName("新增加的Category");
        mapper.add(c);
        listAll(mapper);
    }
   
    private static void listAll(CategoryMapper mapper) {
        List<Category> cs = mapper.list();
        for (Category c : cs) {
            System.out.println(c.getName());
        }
    }
}

二、一对多关系

CategoryMapper接口

import java.util.List;
 
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Category;
 
public interface CategoryMapper {
    @Select(" select * from category_ ")
    @Results({ 
                @Result(property = "id", column = "id"),
                @Result(property = "products", javaType = List.class, column = "id", many =  @Many(select = "com.how2java.mapper.ProductMapper.listByCategory") )
            })
    public List<Category> list();
 <!--第一行result其实是查询category的主键id列（必不能少，我也不知道为什么），而非主键列会自动查询放到实体类里（实体类的属性名应与列名相同），至于第二行的result中的id则是把查询到的category的id列当做参数传递到"com.how2java.mapper.ProductMapper.listByCategory"方法里-->

}
ProductMapper接口 
import java.util.List;
 
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Product;
  
public interface ProductMapper {
  
    @Select(" select * from product_ where cid = #{cid}")
    public List<Product> listByCategory(int cid);
     
}

三、多对一关系

CategoryMapper接口 

import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Category;
  
public interface CategoryMapper {
    @Select(" select * from category_ where id = #{id}")
    public Category get(int id);
     
}

ProductMapper接口

import java.util.List;
 
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Product;
  
public interface ProductMapper {
    @Select(" select * from product_ ")
    @Results({ 
        @Result(property="category",column="cid",one=@One(select="com.how2java.mapper.CategoryMapper.get")) <!--把category的cid列当做参数传递到"com.how2java.mapper.CategoryMapper.get"方法中-->
<!--至于为什么没有“@Result(property = "id", column = "id")”也能查询到id列，而在一对多的情况时则不行，我也不清楚，大概是框架的错误吧...-->

    })
    public List<Product> list();
}

三、多对多关系（订单与产品的关系）

ProductMapper接口（产品） 
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Product;
 
public interface ProductMapper {
     
    @Select("select * from product_ where id = #{id}")
    public Product get(int id);
}
OrderItemMapper接口（订单项） 
import java.util.List;
 
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.OrderItem;
 
public interface OrderItemMapper {
     
    @Select(" select * from order_item_ where oid = #{oid}")
    @Results({ 
        @Result(property="product",column="pid",one=@One(select="com.how2java.mapper.ProductMapper.get")) 
    }) 
    public List<OrderItem> listByOrder(int oid);
}
OrderMapper接口（订单） 
import java.util.List;
 
import org.apache.ibatis.annotations.Many;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
 
import com.how2java.pojo.Order;
 
public interface OrderMapper {
    @Select("select * from order_")
     @Results({
            @Result(property = "id", column = "id"),
            @Result(property = "orderItems", javaType = List.class, column = "id", 
                    many = @Many(select = "com.how2java.mapper.OrderItemMapper.listByOrder"))
            })      
    public List<Order> list();
     
}

四、注解版的sql语句

新增CategoryDynaSqlProvider，提供CRUD对应的SQL语句。
这里的SQL语句使用SQL类的方式构建
 

import org.apache.ibatis.jdbc.SQL;
 
public class CategoryDynaSqlProvider {
    public String list() {
         return new SQL()
                 .SELECT("*")
                 .FROM("category_")
                 .toString();
         
    }
    public String get() {
        return new SQL()
                .SELECT("*")
                .FROM("category_")
                .WHERE("id=#{id}")
                .toString();
    }
     
    public String add(){
        return new SQL()
                .INSERT_INTO("category_")
                .VALUES("name", "#{name}")
                .toString();
    }
    public String update(){
        return new SQL()
                .UPDATE("category_")
                .SET("name=#{name}")
                .WHERE("id=#{id}")
                .toString();
    }
    public String delete(){
        return new SQL()
                .DELETE_FROM("category_")
                .WHERE("id=#{id}")
                .toString();
    }
     
}
修改后的CategoryMapper接口 

import java.util.List;
 
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
 
import com.how2java.CategoryDynaSqlProvider;
import com.how2java.pojo.Category;
  
public interface CategoryMapper {
  
    @InsertProvider(type=CategoryDynaSqlProvider.class,method="add") 
    public int add(Category category); 
        
    @DeleteProvider(type=CategoryDynaSqlProvider.class,method="delete")
    public void delete(int id); 
        
    @SelectProvider(type=CategoryDynaSqlProvider.class,method="get") 
    public Category get(int id); 
      
    @UpdateProvider(type=CategoryDynaSqlProvider.class,method="update") 
    public int update(Category category);  
        
    @SelectProvider(type=CategoryDynaSqlProvider.class,method="list")     
    public List<Category> list(); 
}
最后是关于这个sql类，SQL类是用于进行动态SQL生成的，如下代码是一个相对复杂的SQL类的使用举例，以后需要用到的时候，再来参考。 
private String selectPersonSql() {
  return new SQL() {{
    SELECT("P.ID, P.USERNAME, P.PASSWORD, P.FULL_NAME");
    SELECT("P.LAST_NAME, P.CREATED_ON, P.UPDATED_ON");
    FROM("PERSON P");
    FROM("ACCOUNT A");
    INNER_JOIN("DEPARTMENT D on D.ID = P.DEPARTMENT_ID");
    INNER_JOIN("COMPANY C on D.COMPANY_ID = C.ID");
    WHERE("P.ID = A.ID");
    WHERE("P.FIRST_NAME like ?");
    OR();
    WHERE("P.LAST_NAME like ?");
    GROUP_BY("P.ID");
    HAVING("P.LAST_NAME like ?");
    OR();
    HAVING("P.FIRST_NAME like ?");
    ORDER_BY("P.ID");
    ORDER_BY("P.FULL_NAME");
  }}.toString();
}






你丶怎么睡得着的？
关注
专栏目录
MyBatis如何使用(二)
09-01
在本文中，我们将继续探讨如何在实际开发中更方便地使用MyBatis，特别是通过接口进行数据操作的方法。 首先，我们回顾一下传统的MyBatis使用方式，即通过映射文件（Mapper XML文件）来定义SQL语句。映射文件中包含...
mybatis 小于号 报错问题
weixin_42960873的博客
07-03 739
异常原因: 问题不是mybatis不支持“<”，而是xml不支持这个符号 解决案例: SELECT * FROM tb_km_activity a WHERE a.is_del = #{isDel} AND a.activity_end_time >= #{now} <![CDATA[and a.activity_start_time <= #{now} ]]> AND b.user_status = 1 ORDER BY a.id DESC ...
Mybatis中用NOW()表示当前时间
m0_67401417的博客
04-06 2940
Mybatis中用NOW()表示当前时间
mybatis中获取当前时间_mybatis的xml中，时间怎么直接在xml中获取
weixin_39685024的博客
02-01 9171
比如操作一条数据需要记录操作时间，而接口文档规定传递的参数并没有时间，该怎么做呢？不需要后台传递过来，那么也可以直接在xml中获取，使用now()。先看update更新语句update t_follow_businessOPERATE_TIME = now(),BUSI_CATEGORY = #{busiCategory,jdbcType=VARCHAR},BUSI_BRAND = #{busiB...
MYSQL和mybatis_XML常用知识总结，新手入门
youtiantin的博客
12-14 1370
下列语句部分是Mssql语句，不可以在access中使用。 　　SQL分类： 　　DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) 　　DML—数据操纵语言(SELECT，DELETE，UPDATE，INSERT) 　　DCL—数据控制语言(GRANT，REVOKE，COMMIT，ROLLBACK) 　　首先,简要介绍基础语句： 　　1、说明：创建数据库 CREATE DATABASE database-name 　　2、说明：删除数据库 drop database dbname
Mybatis使用文档
03-11
# MyBatis 使用文档 ## 一、MyBatis 概述 MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使你更好地...
mybatis简单使用
07-18
本资源"mybatis简单使用"旨在帮助初学者快速掌握MyBatis的基础使用方法和配置。 一、MyBatis简介 MyBatis最初由Google Code托管，后迁移至GitHub，是Apache Software Foundation下的顶级项目。它摒弃了传统JDBC中的...
Mybatis Generator使用说明
02-03
### Mybatis Generator使用说明 #### 一、简介 Mybatis Generator 是一款强大的代码生成工具，它可以根据数据库表结构自动生成相应的 Java 实体类、Mapper 接口、XML 映射文件等，极大地提高了开发效率，减少了...
spring-mybatis与原生mybatis使用对比分析
08-28
Spring-MyBatis与原生MyBatis使用对比分析 摘要：本文将对比分析Spring-MyBatis与原生MyBatis的使用方法，讨论两者的区别和优缺点，并探讨Spring-MyBatis如何整合MyBatis，提高开发效率。 Spring-MyBatis与原生...
mybatis动态sql语法错误
deepquiet的博客
08-26 1361
<sql id="searchByPo"> <trim prefix="where" prefixOverrides="and|or"> <if test="id !='' and id !=null"> id = #{id} </if> <if test="taskName !
mybatis常用查询技巧1
飞血泪无痕的博客
10-09 2797
好久没有写csdn博客，在正文之前先扯蛋几句，很多时候坚持一件事情是很有价值同时也是很困难的事情，像我好像就停止更新csdn博客有些时间了，现在想想我的意志力还是没有达到那个程度，这次回归希望努力坚持。 1.介绍一下mybatis查询常用一些场景语句 使用场景：我们经常会遇到这样一种情况，比如我们做文章或者评论的时候会遇到每天只能点赞一次，此时，更具客户端ip作为独立条件，然后在更具时
关于mybatis标签sql踩坑
qsd1530的博客
05-17 597
sql标签中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的,说一下踩坑的地方，如果你的实体类没有空构造方法，这时在sql标签中写了表中的所有字段，运行则会抛出java.lang.IndexOutOfBoundsException: Index: 4, Size: 4异常 ...
使用Mybatis时, 在*Mapper.xml中出现大于号小于号的问题及两种解决方案
sakura的博客
01-11 8509
使用Mybatis时, 在*Mapper.xml中出现大于号小于号的问题及解决方案
mybatis入门
TomHaveNoCat的博客
10-07 1470
1Mybatis概述 1.1Mybatis是什么 MyBatis 是一个优秀持久层框架，由apache的开源项目iBatis演化而来，主要用于解决数据持久化问题，底层实现了对JDBC操作的封装。 参考网址：http://www.mybatis.org 1.2MyBatis 应用场景 a)简化JDBC编写步骤的复杂度 b)更好的实现ORM(对象关系映射) 提示:目前市场上还有一些类似的ORM框架,比...
Mybaits中当使用＜时被识别成标签导致报错
m0_49194578的博客
03-08 1020
今天进行CRUD的时候有一句sql需要查询小于当前时间的课程； 于时出现了 因为mybatis把<识别成了标签的开始所以报错了。 解决办法 方法1： 将左右两边对换使用>这个不会被识别成标签开始 start_time < NOW() ···· NOW() > start_time 方法2： <![CDATA[ ]]> start_time < NOW() ···· start_time <![CDATA[<]]> NOW() 方法3： 使用转
MyBatis原生批量插入的坑与解决方案
最新发布
2401_84415534的博客
04-19 744
/ 最大循环次数@Autowired/***/@Test// 统计开始时间i++) {// 批量插入// 统计结束时间System.out.println(“执行时间：” + (etime - stime));核心文件 UserMapper.xml 中的实现代码如下：USERNAMEPASSWORD) VALUES当我们开心地运行以上程序时，就出现了以下的一幕：沃，程序竟然报错了！
mybatis参数格式化异常
qq_40535097的博客
05-17 558
**由于mybatis参数格式化异常**导致，例如在动态sql拼接中String类型参数和数字比较。 <if test="param.xxx!= '2'"> 1 其中xxx为String类型，加单引号mybatis会认为String和char比较，也会导致报错 解决方法 用toString()转成字符串， '2'.toString() 改为双引号"2",外层使用单引号。 &lt...
理解MyBatis一二级缓存机制
二级缓存的使用需要注意数据一致性问题，因为它可能会导致不同SqlSession之间的数据不一致，尤其是在并发环境中。 MyBatis一级缓存的工作流程大致如下： 1. 当执行一个查询操作时，MyBatis首先会在当前SqlSession的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值