MyBatis-Plus-入门操作(1)

这篇具有很好参考价值的文章主要介绍了MyBatis-Plus-入门操作(1)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

MyBatis-Plus-入门操作

2.1常见注解

约定大于配置

mp扫描实体类基于反射的方式作为数据库表的信息。

默认的约定

  • 类名驼峰转下划线
  • 名字为id的是主键
  • 属性名进行驼峰转换成下划线

要是不遵循约定的话就需要对应的注解进行修改。

表的名字和 实际的表的名字是不一致的

@TableName(value ="user",schema = "mp")
  • schema数据库
  • value 表名

mp的主键

默认是不支持多个主键的

 @TableId(type = IdType.AUTO)
  • TableId指定的是主键
  • type指定的主键的生成的策略

默认的是:ASSIGN_ID

AUTO 自增

NONE 无

INOUT:手动编码的方式

ASSIGN_ID:自动分配。采用的是雪花的算法和INOUT是类似的。没生成一个是自动生成的。Long类型的整数的形式

ASSIGN_UUID:分配UUID。这个是随机生成的非常长。 字母和数字混合的

字段不一致

尤其是针对JavaBean的属性是以isXxxx开头的,当进行反射的时候就会自动的去掉前面的is,会导致映射是失败的。此时就需要用到下面的注解进行标注。

当出现关键字和数据库中关键字是冲突的时候也是需要采用对应的TableField注解进行标注的但是需要单独加上``

@TableField("is_Del")
private Boolean isDel;

当出现数据库中的关键字的时候

TableField("`order`")
private Integer order;

当数据库中的字段的名称是实际是不一致的时候需要进行标注出来

@TableField("username")
private Boolean name;

字段不存在

 @TableField(exist = false)
    private static final long serialVersionUID = 1L;

更新策略

当什么的时候进行更新

当什么的时候进行不进行插入

类型转换器

常用的可以自动的进行转换的,只是针对比较复杂的是不能直接进行转换的,需要单独指定转换的处理器的

2.2常见的配置

下面是常见的配置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true  #开启驼峰命名匹配
    cache-enabled: true #是不是开启二级缓存
  global-config:
    db-config:
      update-strategy: not_null #更新策略,只更新非空的字段
  mapper-locations: classpath:mapper/**/*.xml #文件地址
  type-aliases-package: com.lxz.demo.domain #别名扫描包

补充:二级缓存

减少读取数据库的次数

cache-enabled和二级缓存是与数据访问相关的概念,用于提高应用程序的性能和响应速度。

cache-enabled:
cache-enabled是一个配置选项,通常用于配置数据访问框架(如Spring Data、Hibernate等),以启用或禁用缓存功能。当将cache-enabled配置为true时,表示启用缓存功能,数据访问框架将会自动将查询结果存储在缓存中,以便后续的请求可以直接从缓存中获取数据,而不需要再次访问数据库。

二级缓存:
二级缓存是一种位于数据库和应用程序之间的缓存层,用于存储数据库查询的结果。它是在数据访问框架层面实现的,独立于特定的数据库引擎。当启用了二级缓存后,查询结果会被缓存到内存中,以加快下次相同查询的响应速度。

二级缓存的工作原理如下:

当应用程序发送一个查询请求时,数据访问框架首先检查缓存中是否存在该查询的结果。
如果缓存中存在结果,数据访问框架直接从缓存中获取并返回结果,避免了与数据库的交互操作,从而提高了性能。
如果缓存中不存在结果,数据访问框架会执行查询操作,将结果存储到缓存中,并返回结果给应用程序。
二级缓存通常适用于频繁读取的数据,可以减少数据库的访问次数,提高系统的性能和响应速度。但需要注意的是,如果对于同一份数据的更新频繁,可能会导致缓存与数据库中的数据不一致,因此在使用二级缓存时需要做好缓存的管理和数据的一致性维护。

总结而言,cache-enabled配置项用于启用或禁用数据访问框架的缓存功能。二级缓存是在数据访问框架层面实现的缓存机制,用于存储数据库查询的结果,从而提高应用程序的性能和响应速度。

2.3条件构造器

实现一些复杂的操作

支持各种复杂的where条件的操作。
MyBatis-Plus-入门操作(1),MyBatis,mybatis
Wrapper就是一个条件构造器
Wrapper常见的实现

MyBatis-Plus-入门操作(1),MyBatis,mybatis
完成下面的操作
MyBatis-Plus-入门操作(1),MyBatis,mybatis
解析:采用得是QueryWrapper得链式编程得方式

  • select 指定要查询得字段
  • like 模糊
  • ge 大于得

 @Test
    void  test7(){
        //构建查询条件 支持链式编程的
        QueryWrapper<User>  wrapper = new QueryWrapper<User>()
                .select("id","username","info","balance")
                .like("username","o")
                .ge("balance",1000)
                ;

        //查询
        List<User> list=userMapper.selectList(wrapper);
        list.forEach(System.out::println);

    }

查询结果
JDBC Connection [HikariProxyConnection@1434151479 wrapping com.mysql.cj.jdbc.ConnectionImpl@11b32a14] will not be managed by Spring
==>  Preparing: SELECT id,username,info,balance FROM user WHERE (username LIKE ? AND balance >= ?)
==> Parameters: %o%(String), 1000(Integer)
<==    Columns: id, username, info, balance
<==        Row: 3, Hope, <<BLOB>>, 100000
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6aa7b67f]
User(id=3, username=Hope, password=null, phone=null, info={"age": 25, "intro": "上进青年", "gender": "male"}, status=null, balance=100000, createTime=null, updateTime=null)
2023-09-02 23:07:26.511  INFO 26960 --- [ionShutdownHook] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Shutdown initiated...

MyBatis-Plus-入门操作(1),MyBatis,mybatis

  @Test
    void  test8(){
        //更新得数据
        User user=new User();
        user.setBalance(2000);

        //条件
        QueryWrapper<User> wrapper=new QueryWrapper<User>()
                .eq("username","jack");
        //参数1 不是空得数据作为更新得数据
        //参数2 作为查询得条件 要进行更新得数据
        userMapper.update(user,wrapper);
    }



JDBC Connection [HikariProxyConnection@776192909 wrapping com.mysql.cj.jdbc.ConnectionImpl@649f25f3] will not be managed by Spring
==>  Preparing: UPDATE user SET balance=? WHERE (username = ?)
==> Parameters: 2000(Integer), jack(String)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@66deec87]

MyBatis-Plus-入门操作(1),MyBatis,mybatis
采用UpdateWrapper
MyBatis-Plus-入门操作(1),MyBatis,mybatis
解析:下面得是完成如下得操作得

UPDATE user SET balance=balance-200 WHERE (username = ?)
    @Test
    void  test9(){
      

        //条件 UpdateWrapper是可以不知道准确得值得
        UpdateWrapper<User> wrapper=new UpdateWrapper<User>()
                .setSql("balance=balance-200")
                .eq("username","Jack");

        userMapper.update(null,wrapper);
    }

LambdaUpdateWrapper

好处是不把对应得属性进行写死

    @Test
    void  test10(){
        //条件 UpdateWrapper是可以不知道准确得值得
        LambdaUpdateWrapper<User> wrapper=new LambdaUpdateWrapper<User>()
                .setSql("balance=balance+200")
                .eq(User::getUsername,"Jack");

        userMapper.update(null,wrapper);
    }

MyBatis-Plus-入门操作(1),MyBatis,mybatis

或者是采用下面得方式可以得

采用调用lambda得方式

    @Test
    void  test11(){
      
        QueryWrapper<User> wrapper=new QueryWrapper<User>();
        wrapper.lambda()
                .select(User::getUsername)
                .select(User::getBalance)
                .select(User::getInfo)
                .eq(User::getId,1L);


        userMapper.selectList(wrapper).forEach(System.out::println);
    }

或者是直接采用下面得方式

    @Test
    void  test12(){
        LambdaQueryWrapper<User> wrapper=new LambdaQueryWrapper<User>()
                .select(User::getUsername)
                .select(User::getBalance)
                .select(User::getInfo)
                .eq(User::getId,1L);
        userMapper.selectList(wrapper).forEach(System.out::println);
    }

比上面得那种调用lamda得方法是更加简便得。

MyBatis-Plus-入门操作(1),MyBatis,mybatis

2.4自定义SQL

并不是自己手写对应得sql

下面得sql不能出现在下面得语句中是不方便进行维护得。我们需要作出相应得修改得。

   @Test
    void  test10(){
        //条件 UpdateWrapper是可以不知道准确得值得
        LambdaUpdateWrapper<User> wrapper=new LambdaUpdateWrapper<User>()
                .setSql("balance=balance+200")
                .eq(User::getUsername,"Jack");

        userMapper.update(null,wrapper);
    }

采用sql转换得方式

采用where条件得拼接

MyBatis-Plus-入门操作(1),MyBatis,mybatis
下面是自定义sql得案例1

  • 构建自定义sql

LambdaQueryWrapper 就是我们需要查询得where中得条件是后面需要进行拼接得内容。

findUserByUserName是自定义得方法。传入得参数就是Wrapper

    @Test
    void  test13(){
        //构建
        LambdaQueryWrapper<User> wrapper=new LambdaQueryWrapper<User>()
                .like(User::getUsername,"o")
                .ge(User::getBalance,500);
        //查询
        userMapper.findUserByUserName(wrapper).forEach(System.out::println);
    }
    
  • mapper层的方法定义

传入得参数必须是ew

//此处必须是ew
    List<User> findUserByUserName(@Param("ew") LambdaQueryWrapper<User> wrapper);
  • xml文件

采用ew.customSqlSegment进行对应的参数内容的接收

 <select id="findUserByUserName" resultType="User">
        select * from  user ${ew.customSqlSegment}
 </select>

下面是查询的结果

拼接的sql:select * from user WHERE (username LIKE ? AND balance >= ?) 这个sql就是我们原先自己定义的sql的内容

JDBC Connection [HikariProxyConnection@1406324738 wrapping com.mysql.cj.jdbc.ConnectionImpl@5b39a3e6] will not be managed by Spring
==>  Preparing: select * from user WHERE (username LIKE ? AND balance >= ?)
==> Parameters: %o%(String), 500(Integer)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time
<==        Row: 3, Hope, 123, 13900112222, <<BLOB>>, 1, 100000, 2023-06-19 22:37:44, 2023-06-19 22:37:44
<==        Row: 4, Thomas, 123, 17701265258, <<BLOB>>, 1, 800, 2023-06-19 23:44:45, 2023-06-19 23:44:45
<==      Total: 2
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@39c96e48]
User(id=3, username=Hope, password=123, phone=13900112222, info={"age": 25, "intro": "上进青年", "gender": "male"}, status=1, balance=100000, createTime=Mon Jun 19 22:37:44 CST 2023, updateTime=Mon Jun 19 22:37:44 CST 2023)
User(id=4, username=Thomas, password=123, phone=17701265258, info={"age": 29, "intro": "伏地魔", "gender": "male"}, status=1, balance=800, createTime=Mon Jun 19 23:44:45 CST 2023, updateTime=Mon Jun 19 23:44:45 CST 2023)

下面是案例2

  • 未更新之前的数据
    MyBatis-Plus-入门操作(1),MyBatis,mybatis
    创建更新的测试方法
    @Test
    void  test14(){
        //构建条件
        LambdaQueryWrapper<User> wrapper=new LambdaQueryWrapper<User>()
                .in(User::getId,1L,2L,3L);
        //执行更新
       int line = userMapper.updateBalanceByWrapper(wrapper);
       System.out.println("line="+line);
    }

创建mapper层的方法

//批量更新
    int updateBalanceByWrapper(@Param("ew") LambdaQueryWrapper<User> wrapper);

创建自定义sql

<update id="updateBalanceByWrapper">
        update user set  balance = balance-200 ${ew.customSqlSegment}
</update>

更新的结果

JDBC Connection [HikariProxyConnection@200760156 wrapping com.mysql.cj.jdbc.ConnectionImpl@16da476c] will not be managed by Spring
==>  Preparing: update user set balance = balance-200 WHERE (id IN (?,?,?))
==> Parameters: 1(Long), 2(Long), 3(Long)
<==    Updates: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2e86807a]
line=3

更新之后的数据
MyBatis-Plus-入门操作(1),MyBatis,mybatis
对于多表的话一般采用的是原生的mybatis的方式进行写sql的操作。对于多表的mp的支持是不好的,但是部分是可以也是可以使用的。

完成部分多表查询的操作
MyBatis-Plus-入门操作(1),MyBatis,mybatis
sql是下面的写法

-- 查询所有的user的信息
SELECT * from user u ;

-- 查询所有地址
SELECT * from address addr;


-- 查询收获地址是北京的并且用户id是 1 2 4  的用户
SELECT * from user u 
JOIN
address addr
ON
u.id=addr.user_id
WHERE
addr.user_id IN(1,2,4)
AND 
addr.city='北京';



下面是原先的写法

    <select id="findUserByCity" resultType="User">
        SELECT * from user u
            JOIN  address addr
              ON u.id=addr.user_id
        WHERE
            addr.user_id
          <foreach collection="ids" separator="," item="id" open="in (" close=")">
                #{id}
           </foreach>
          AND
            addr.city=#{city};
    </select>
    
    
    
List<User> findUserByCity(@Param("ids") List<Long> ids,@Param("city") String city);
@Test
void  test15(){
    List<Long> ids=new ArrayList<Long>();
    ids.add(1L);
    ids.add(2L);
    ids.add(3L);
    userMapper.findUserByCity(ids,"北京").forEach(System.out::println);
}

结果

JDBC Connection [HikariProxyConnection@1709321711 wrapping com.mysql.cj.jdbc.ConnectionImpl@4b1ec694] will not be managed by Spring
==>  Preparing: SELECT * from user u JOIN address addr ON u.id=addr.user_id WHERE addr.user_id in ( ? , ? , ? ) AND addr.city=?;
==> Parameters: 1(Long), 2(Long), 3(Long), 北京(String)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time, id, user_id, province, city, town, mobile, street, contact, is_default, notes
<==        Row: 1, Jack, 123, 13900112224, <<BLOB>>, 1, 1800, 2023-05-19 20:50:21, 2023-06-19 20:50:21, 60, 1, 北京, 北京, 朝阳区, 13700221122, 修正大厦, Jack, 0, null
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23, 59, 2, 北京, 北京, 朝阳区, 13900112222, 金燕龙办公楼, Rose, 1, null
<==      Total: 2
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@118dcbbd]
User(id=1, username=Jack, password=123, phone=13900112224, info={"age": 20, "intro": "佛系青年", "gender": "male"}, status=1, balance=1800, createTime=Fri May 19 20:50:21 CST 2023, updateTime=Mon Jun 19 20:50:21 CST 2023)
User(id=2, username=Rose, password=123, phone=13900112223, info={"age": 19, "intro": "青涩少女", "gender": "female"}, status=1, balance=300, createTime=Fri May 19 21:00:23 CST 2023, updateTime=Mon Jun 19 21:00:23 CST 2023)

上面是原先的写法,采用的是sql拼接的方式现在我们不采用上面的方式而是采用一种比较新的sql拼接的方式

sql拼接的方式

 @Test
    void  test16(){
        List<Long> ids=new ArrayList<Long>();
        ids.add(1L);
        ids.add(2L);
        ids.add(3L);
        QueryWrapper<User>    queryWrapper=new QueryWrapper<User>()
                .in("u.id",ids)
                .eq("addr.city","北京");
        userMapper.findUserByCity2(queryWrapper).forEach(System.out::println);
    }

//采用mp完成多表查询
List<User> findUserByCity2(@Param("ew") QueryWrapper<User> queryWrapper);
<select id="findUserByCity2" resultType="User">
    SELECT * from user u
    JOIN
    address addr
    ON
    u.id=addr.user_id
     ${ew.customSqlSegment}
</select>

结果

==>  Preparing: SELECT * from user u JOIN address addr ON u.id=addr.user_id WHERE (u.id IN (?,?,?) AND addr.city = ?)
==> Parameters: 1(Long), 2(Long), 3(Long), 北京(String)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time, id, user_id, province, city, town, mobile, street, contact, is_default, notes
<==        Row: 1, Jack, 123, 13900112224, <<BLOB>>, 1, 1800, 2023-05-19 20:50:21, 2023-06-19 20:50:21, 60, 1, 北京, 北京, 朝阳区, 13700221122, 修正大厦, Jack, 0, null
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23, 59, 2, 北京, 北京, 朝阳区, 13900112222, 金燕龙办公楼, Rose, 1, null
<==      Total: 2
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2e86807a]
User(id=1, username=Jack, password=123, phone=13900112224, info={"age": 20, "intro": "佛系青年", "gender": "male"}, status=1, balance=1800, createTime=Fri May 19 20:50:21 CST 2023, updateTime=Mon Jun 19 20:50:21 CST 2023)
User(id=2, username=Rose, password=123, phone=13900112223, info={"age": 19, "intro": "青涩少女", "gender": "female"}, status=1, balance=300, createTime=Fri May 19 21:00:23 CST 2023, updateTime=Mon Jun 19 21:00:23 CST 2023)

上面的操作本质是用了单表的查询的操作。

2.5Service接口

完成对单表的Service操作

分为常见的8个范围的操作
MyBatis-Plus-入门操作(1),MyBatis,mybatis

save 单个
saveBatch 批量添加
saveOrUpdateBatch 
saveOrUpdate 增或该 要是传入id的话会根据id查询要是有的话就更新没有的话就插入
update
单个和批量

查询一个

getOne
getById
removeById
removeByMap
remove
removeByIds
removeBatchByIds
count

分页

page

链式编程

lambdaQuery
lambdaQUpdate

可以拿到当前的mapper

比如当使用自定义sql的时候可以使用获取mappe的方法

getBaseMapper

编写service

public interface UserService extends IService<User> {

}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
    implements UserService{

}

测试基本操作

 @Autowired
    private UserService userService;
    //测试增加
    @Test
    void test111(){
        //要么就是insert就是save,创建一个User对象就写入进行就可以的
        User user=new User();
        user.setUsername("李四");
        user.setPassword("123456");
        user.setPhone("13900112224");
        JSONObject jsonObject=new JSONObject();
        //hutool中的
        jsonObject.set("age",29);
        jsonObject.set("intro","伏地魔");
        jsonObject.set("gender","male");
        user.setInfo(jsonObject.toString());
        user.setStatus(1);
        user.setBalance(2000);
        user.setCreateTime(DateTime.now());
        user.setUpdateTime(DateTime.now());
        boolean line=userService.save(user);
        System.out.println("line="+line);
    }
JDBC Connection [HikariProxyConnection@1868288866 wrapping com.mysql.cj.jdbc.ConnectionImpl@3a401749] will not be managed by Spring
==>  Preparing: INSERT INTO user ( username, password, phone, info, status, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? )
==> Parameters: 李四(String), 123456(String), 13900112224(String), {"age":29,"intro":"伏地魔","gender":"male"}(String), 1(Integer), 2000(Integer), 2023-09-03 00:03:46.12(Timestamp), 2023-09-03 00:03:46.12(Timestamp)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2b0e9f30]
line=true

MyBatis-Plus-入门操作(1),MyBatis,mybatis

    @Test
    void test22(){
        LambdaQueryWrapper<User> queryWrapper=new LambdaQueryWrapper<User>()
                .in(User::getId,1L,2L,3L);
        List<User> users= userService.list(queryWrapper);
        System.out.println("users="+users.toString());
    }
JDBC Connection [HikariProxyConnection@2133998394 wrapping com.mysql.cj.jdbc.ConnectionImpl@4f169009] will not be managed by Spring
==>  Preparing: SELECT id,username,password,phone,info,status,balance,create_time,update_time FROM user WHERE (id IN (?,?,?))
==> Parameters: 1(Long), 2(Long), 3(Long)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time
<==        Row: 1, Jack, 123, 13900112224, <<BLOB>>, 1, 1800, 2023-05-19 20:50:21, 2023-06-19 20:50:21
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23
<==        Row: 3, Hope, 123, 13900112222, <<BLOB>>, 1, 99800, 2023-06-19 22:37:44, 2023-06-19 22:37:44
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@303c55fa]
users=[User(id=1, username=Jack, password=123, phone=13900112224, info={"age": 20, "intro": "佛系青年", "gender": "male"}, status=1, balance=1800, createTime=Fri May 19 20:50:21 CST 2023, updateTime=Mon Jun 19 20:50:21 CST 2023), User(id=2, username=Rose, password=123, phone=13900112223, info={"age": 19, "intro": "青涩少女", "gender": "female"}, status=1, balance=300, createTime=Fri May 19 21:00:23 CST 2023, updateTime=Mon Jun 19 21:00:23 CST 2023), User(id=3, username=Hope, password=123, phone=13900112222, info={"age": 25, "intro": "上进青年", "gender": "male"}, status=1, balance=99800, createTime=Mon Jun 19 22:37:44 CST 2023, updateTime=Mon Jun 19 22:37:44 CST 2023)]

service接口得批量插入
MyBatis-Plus-入门操作(1),MyBatis,mybatis

    @Test
    void tes51(){
        long b =System.currentTimeMillis();
        for (int i = 0; i <100000 ; i++) {
            User user=new User();
            user.setUsername("王五"+i);
            user.setPassword("123456"+i);
            user.setPhone(i+"");
            JSONObject jsonObject=new JSONObject();
            //hutool中的
            jsonObject.set("age",i);
            jsonObject.set("intro","伏地魔"+i);
            jsonObject.set("gender","male");
            user.setInfo(jsonObject.toString());
            user.setStatus(1);
            user.setBalance(2000);
            user.setCreateTime(DateTime.now());
            user.setUpdateTime(DateTime.now());
            userMapper.insert(user);
        }
        long e =System.currentTimeMillis();
        System.out.println("耗时="+(e-b));
    }

下面是插入的结果

...... 省略
JDBC Connection [HikariProxyConnection@1503775440 wrapping com.mysql.cj.jdbc.ConnectionImpl@34be065a] will not be managed by Spring
==>  Preparing: INSERT INTO user ( username, password, phone, info, status, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? )
==> Parameters: 王五99998(String), 12345699998(String), 99998(String), {"age":99998,"intro":"伏地魔99998","gender":"male"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:40:12.668(Timestamp), 2023-09-03 14:40:12.668(Timestamp)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@2493a6d]
Creating a new SqlSession
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@52140522] was not registered for synchronization because synchronization is not active
JDBC Connection [HikariProxyConnection@87335674 wrapping com.mysql.cj.jdbc.ConnectionImpl@34be065a] will not be managed by Spring
==>  Preparing: INSERT INTO user ( username, password, phone, info, status, balance, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? )
==> Parameters: 王五99999(String), 12345699999(String), 99999(String), {"age":99999,"intro":"伏地魔99999","gender":"male"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:40:12.671(Timestamp), 2023-09-03 14:40:12.671(Timestamp)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@52140522]
耗时=490293

下面是批量插入的过程

 //批量插入采用1000条的插入,减少内存的消耗
    @Test
    void tes52(){
        long b =System.currentTimeMillis();
        //设置一下初始化的内存
        List<User> list=new ArrayList<User>(1000);
        for (int i = 1; i <= 100000 ; i++) {
            User user=new User();
            user.setUsername("赵六"+i);
            user.setPassword(i+"123456");
            user.setPhone(i+"102");
            JSONObject jsonObject=new JSONObject();
            //hutool中的
            jsonObject.set("age",i);
            jsonObject.set("intro",i+"伏地魔");
            jsonObject.set("gender","female");
            user.setInfo(jsonObject.toString());
            user.setStatus(1);
            user.setBalance(2000);
            user.setCreateTime(DateTime.now());
            user.setUpdateTime(DateTime.now());
            list.add(user);
            if (i%1000==0) {
                userService.saveBatch(list);
                list.clear();
            }
        }
        long e =System.currentTimeMillis();
        System.out.println("耗时="+(e-b));
    }

结果

==> Parameters: 赵六99992(String), 99992123456(String), 99992102(String), {"age":99992,"intro":"99992伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99993(String), 99993123456(String), 99993102(String), {"age":99993,"intro":"99993伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99994(String), 99994123456(String), 99994102(String), {"age":99994,"intro":"99994伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99995(String), 99995123456(String), 99995102(String), {"age":99995,"intro":"99995伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99996(String), 99996123456(String), 99996102(String), {"age":99996,"intro":"99996伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99997(String), 99997123456(String), 99997102(String), {"age":99997,"intro":"99997伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99998(String), 99998123456(String), 99998102(String), {"age":99998,"intro":"99998伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六99999(String), 99999123456(String), 99999102(String), {"age":99999,"intro":"99999伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
==> Parameters: 赵六100000(String), 100000123456(String), 100000102(String), {"age":100000,"intro":"100000伏地魔","gender":"female"}(String), 1(Integer), 2000(Integer), 2023-09-03 14:46:53.14(Timestamp), 2023-09-03 14:46:53.14(Timestamp)
耗时=23273

490293-23273=467,020;两者时间的时间差是相当多的。

MyBatis-Plus-入门操作(1),MyBatis,mybatis

一条一条插入的是加入的values的方式
下面的方式是采用的预编译的方式进行插入的

修改默认插入的参数

需要打开对应的开关采用达到批处理的方式而不知直接传入参数的方式

参考博客:mybatis的批处理(效率)之rewriteBatchedStatements和allowMultiQueries_suqinyi的博客-CSDN博客

rewriteBatchedStatements=true:批量将数据传给mysql
一个一个的插入:490293
批处理耗时:23273
基于预编译的耗时=6519
底层是重写了一个sql。这个效率是最高的。

2.6IService的Lambda查询

    @Test
    void tes53(){
       User user= userService.lambdaQuery()
                .eq(User::getUsername,"Rose").one();
        System.out.println(user.toString());
    }

JDBC Connection [HikariProxyConnection@535910992 wrapping com.mysql.cj.jdbc.ConnectionImpl@217c23ce] will not be managed by Spring
==>  Preparing: SELECT id,username,password,phone,info,status,balance,create_time,update_time FROM user WHERE (username = ?)
==> Parameters: Rose(String)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@19a20bb2]
User(id=2, username=Rose, password=123, phone=13900112223, info={"age": 19, "intro": "青涩少女", "gender": "female"}, status=1, balance=300, createTime=Fri May 19 21:00:23 CST 2023, updateTime=Mon Jun 19 21:00:23 CST 2023)

   @Test
    void tes54(){
        Long count= userService.lambdaQuery()
                .eq(User::getUsername,"Rose").count();
        System.out.println(count);
    }

JDBC Connection [HikariProxyConnection@138010466 wrapping com.mysql.cj.jdbc.ConnectionImpl@76e90da5] will not be managed by Spring
==>  Preparing: SELECT COUNT( * ) FROM user WHERE (username = ?)
==> Parameters: Rose(String)
<==    Columns: COUNT( * )
<==        Row: 1
<==      Total: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@b5de58f]
1

2.7动态查询参数

MyBatis-Plus-入门操作(1),MyBatis,mybatis

    //查询用户列表

    public List<User> queryUsers(String userName, Integer status, Long min, Long max) {
        List<User>  list= userService.lambdaQuery()
                .like(userName!=null,User::getUsername,userName)
                .eq(status!=null,User::getStatus,status)
                .gt(min!=null,User::getBalance,min)
                .lt(max!=null,User::getBalance,max).list();

        return list;
    }
    @Test
    void tes56(){
        queryUsers("o",1,null,null);
    }

  • 第一个参数是条件就是后面的语句是不是运行的条件
SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3eb3232b] was not registered for synchronization because synchronization is not active
2023-09-03 15:28:17.012  INFO 11884 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
2023-09-03 15:28:17.168  INFO 11884 --- [           main] com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
JDBC Connection [HikariProxyConnection@302007694 wrapping com.mysql.cj.jdbc.ConnectionImpl@5fcd1c5f] will not be managed by Spring
==>  Preparing: SELECT id,username,password,phone,info,status,balance,create_time,update_time FROM user WHERE (username LIKE ? AND status = ?)
==> Parameters: %o%(String), 1(Integer)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23
<==        Row: 3, Hope, 123, 13900112222, <<BLOB>>, 1, 99800, 2023-06-19 22:37:44, 2023-06-19 22:37:44
<==        Row: 4, Thomas, 123, 17701265258, <<BLOB>>, 1, 1000, 2023-06-19 23:44:45, 2023-06-19 23:44:45
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3eb3232b]

2.8Lambda更新操作

下面将实现动态更新的功能
MyBatis-Plus-入门操作(1),MyBatis,mybatis

 @Test
    void tes57(){
        updateBalance(0L,1L,null);
    }


    public boolean updateBalance(Long balance,Long id,String userName){
        if (id==null&&userName==null){
            throw new RuntimeException("更新条件不能为空!");
        }
        //更新
        boolean flag=userService.lambdaUpdate()
        .set(User::getBalance,balance)
        .set(balance==0,User::getStatus,2)
        .eq(id!=null,User::getId,id)
        .eq(userName!=null,User::getUsername,userName).update();
        return flag;
    }
JDBC Connection [HikariProxyConnection@663925782 wrapping com.mysql.cj.jdbc.ConnectionImpl@4735d6e5] will not be managed by Spring
==>  Preparing: UPDATE user SET balance=?,status=? WHERE (id = ?)
==> Parameters: 0(Long), 2(Integer), 1(Long)
<==    Updates: 1
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@74d6736]

MyBatis-Plus-入门操作(1),MyBatis,mybatis

2.9静态插件

避免循环依赖

解决的方法1:

  • 直接调用mapper层的方法不去调用service层的方法

MyBatis-Plus-入门操作(1),MyBatis,mybatis

boolean line=Db.save(user);
 Db.saveBatch(list);
 
     @Test
    void tes53(){
       User user= Db.lambdaQuery(User.class)
                .eq(User::getUsername,"Rose").one();
        System.out.println(user.toString());
    }
    @Test
    void tes54(){
        Long count= Db.lambdaQuery(User.class)
                .eq(User::getUsername,"Rose").count();
        System.out.println(count);
    }
    @Test
    void tes55(){
        Long count= Db.lambdaQuery(User.class)
                .eq(User::getUsername,"Rose").count();
        System.out.println(count);
    }
 //查询用户列表

    public List<User> queryUsers(String userName, Integer status, Long min, Long max) {
        List<User>  list= Db.lambdaQuery(User.class)
                .like(userName!=null,User::getUsername,userName)
                .eq(status!=null,User::getStatus,status)
                .gt(min!=null,User::getBalance,min)
                .lt(max!=null,User::getBalance,max).list();

        return list;
    }
    @Test
    void tes56(){
        queryUsers("o",1,null,null);
    }

    @Test
    void tes57(){
        updateBalance(0L,1L,null);
    }
JDBC Connection [HikariProxyConnection@874548138 wrapping com.mysql.cj.jdbc.ConnectionImpl@71370fec] will not be managed by Spring
==>  Preparing: SELECT id,username,password,phone,info,status,balance,create_time,update_time FROM user WHERE (username LIKE ? AND status = ?)
==> Parameters: %o%(String), 1(Integer)
<==    Columns: id, username, password, phone, info, status, balance, create_time, update_time
<==        Row: 2, Rose, 123, 13900112223, <<BLOB>>, 1, 300, 2023-05-19 21:00:23, 2023-06-19 21:00:23
<==        Row: 3, Hope, 123, 13900112222, <<BLOB>>, 1, 99800, 2023-06-19 22:37:44, 2023-06-19 22:37:44
<==        Row: 4, Thomas, 123, 17701265258, <<BLOB>>, 1, 1000, 2023-06-19 23:44:45, 2023-06-19 23:44:45
<==      Total: 3
Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5b5a4aed]

唯一的区别是需要单独多传入一个类的类型的参数。

上面的方法的好处是可以解决服务层类之间循环依赖 之间的调用的关系。文章来源地址https://www.toymoban.com/news/detail-706125.html

到了这里,关于MyBatis-Plus-入门操作(1)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Mybatis-Plus快速入门

    目录   一、基础工程 1、创建一个数据库:mp 2、添加数据 3、创建初始工程  4、添加依赖 二、Mybatis + Mybatis-Plus 1、创建子工程:mybatis-plus-simple 2、在子工程下添加配置 2.1Mybatis实现查询User 2.1.1、编写User实体对象 2.1.2、编写UserMapper接口 2.1.3、编写UserMapper.xml文件 2.1.4、编写

    2024年02月10日
    浏览(39)
  • Mybatis-plus的操作(新增,修改)

    一般同时会引入Druid。 MP会默认将模型类的类名首字母小写作为表名使用,假如数据库名称都以tbl_开头,那么我们就需要将所有的模型类上添加@TableName,配置起来还是比较繁琐,简化方式可以在配置文件中配置如下内容: 设置前缀的内容,这样MP就会拿tbl_加上模型类的首字

    2024年02月02日
    浏览(45)
  • 【MyBatis-Plus】入门案例与简介

    1. 入门案例 MybatisPlus(简称MP)是基于MyBatis框架基础上开发的增强型工具,旨在简化开发、提供效率。 开发方式 基于MyBatis使用MyBatisPlus 基于Spring使用MyBatisPlus 基于SpringBoot使用MyBatisPlus SpringBoot刚刚我们学习完成,它能快速构建Spring开发环境用以整合其他技术,使用起来是非常简

    2024年02月10日
    浏览(41)
  • Mybatis-plus从入门到精通

    MyBatis-Plus(简称MP)是一个基于MyBatis的增强工具,在MyBatis的基础上对其进行扩展,用于简化MyBatis操作,提高开发效率。它继承了MyBatis原生的所有特性,并且添加了一些额外的功能,如自动化代码生成、通用增删改查操作、条件构造器等。MyBatis-Plus是为了满足日常开发中对简

    2024年02月15日
    浏览(53)
  • spring boot mybatis-plus操作实践

    1、先建一个数据表实体类 2、service目录下新建接口IDeptService,然后扩展mp的IService 3、service目录的impl目录下新建类 DeptServiceImpl,扩展mp的ServiceImpl,实现接口IDeptService,然后注册@Service 注解 4、DeptMapper 接口需要扩展mp的BaseMapper接口 5、调试一下看看是否可以使用

    2024年02月01日
    浏览(46)
  • mybatis-plus update更新操作(三种方式)

    MyBatis-Plus (opens new window)(简称 MP)是一个 MyBatis (opens new window)的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。 愿景 我们的愿景是成为 MyBatis 最好的搭档,就像 魂斗罗 中的 1P、2P,基友搭配,效率翻倍。 方式一(UpdateWrapper 条件构造器) 方

    2024年02月11日
    浏览(61)
  • 手搭手入门Mybatis-Plus配置多数据源

    https://baomidou.com/ 为简化开发而生 MyBatis-Plus(opens new window)(简称 MP)是一个 MyBatis (opens new window) 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。 无侵入 :只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑 损耗小 :启动即会自

    2024年02月07日
    浏览(40)
  • Mybatis-plus中的DML编程控制--增删改的高级操作

    1.1、id生成策略控制 不同的表应用不同的id生成策略 日志:自增(1,2,3,4,…) 购物订单:特殊规则( FQ23948AK3843) 外卖单:关联地区日期等信息(10 04 20200314 34 91) 关系表:可省略id ······ 名称: @TableId 类型: 属性注解 位置:模型类中用于表示主键的属性定义上方 作用:设置当前类中主

    2024年02月16日
    浏览(42)
  • mybatis-plus 复合主键的应用(多主键操作)

    在实际的生产过程中,某些业务场景会用到复合主键来标识唯一性。但是mybatisPlus亦或mybatis都不默认支持对复合主键的操作。刚好再一次实际的数据项目中遇到这个需求了,记录下来。 # 1、首先是导入项目的依赖 这里使用maven管理依赖,依赖于mybatis-plus有版本关联,使用的时

    2023年04月09日
    浏览(39)
  • MyBatis-Plus 基础操作指南:实现高效的增删改查

        大家好,今天我们来聊聊如何使用 MyBatis-Plus(接下来简称为 MP),一个流行的 MyBatis 增强工具,来简化和加速我们的数据库操作。如果你是一位初学者,不用担心,我将带你从头到尾详细了解 MP 的使用方法,特别是如何实现基本的增删改查操作。     在开始详细介绍之

    2024年02月05日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包