Mybatis Plus框架 基本语法

已于 2024-03-02 23:57:31 修改
阅读量1.1k 收藏 18
点赞数 21
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： mybatis spring boot
于 2024-03-02 23:40:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/twtongwei/article/details/136424277

MybatisPlus 中文官网

依赖配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--MybatisPlus官方提供的starter，其中集成了Mybatis以及plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
        
        <!-- 代码生成器 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!-- Apache Velocity -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.3</version>
        </dependency>
        
		<!-- @ApiModel等注解对应依赖 -->
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.5.13</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

数据库连接

#设置开发环境 @Profile指定
#spring.profiles.active=dev

#驱动类名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库连接的url
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai&characterEncoding=utf-8
#连接数据库的用户名
spring.datasource.username=root
#连接数据库的密码
spring.datasource.password=123456

#配置日志:Sql如何执行的
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

#mybatis plus逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

注解

package com.example.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;


@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("user")
public class User {
    @TableId(value = "id",type = IdType.AUTO)
    private Integer id;
    @TableField(value = "name")
    private String name;
    private Short age;
    private Short gender;
    private String phone;
    @Version
    private Integer version;

	//对于字段is前缀的需要使用注解绑定
    @TableField(value = "is_deleted")
    @TableLogic
    private Integer isDeleted;

    //首次时间是插入，之后是更新
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;

    @TableField(fill = FieldFill.INSERT)
    private Date createTime;
}

CRUD接口

在这里插入图片描述
Lambda条件构造器使用原因：
QueryWrapper、UpdateWrapper条件构造器都是用字符串的形式指定。这种方式无法在编译期确定列名的合法性。

Wrapper 注意

条件调用 如果不写.select(XX,XX)，默认就是select*

自动填充

package com.example.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        log.info("start insert fill ....");
        this.setFieldValByName("createTime", new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("start update fill ....");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

乐观锁和分页插件

package com.example.config;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.aop.interceptor.PerformanceMonitorInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// Spring Boot 方式
@Configuration
public class MybatisPlusConfig {

    /**
     * 新版 注册乐观锁插件
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));//如果配置多个插件,切记分页最后添加
        return mybatisPlusInterceptor;
    }

  /*  //分页插件
    @Bean
    public PaginationInnerInterceptor pageInterceptor(){
        return new PaginationInnerInterceptor();
    }*/


}

Mapper层

说明:

 /*通用 CRUD 封装BaseMapper (opens new window)接口，为 Mybatis-Plus
   启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器 
   */
public interface UserMapper extends BaseMapper<User> {

}


package com.example;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class DemoApplicationTests {

    //UserMapper集成BaseMapper所有方法，也可以自定义
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //wrapper：条件构造器
        //查询所有用户
        List<User> userList = userMapper.selectList(null);
        userList.stream().forEach(user -> System.out.println(user));
    }

    //批量查询 In
    @Test
    public void selectByIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.stream().map(user -> user.getName()).forEach(user -> System.out.println(user));
    }

    //Map查询：条件查询
    @Test
    public void selectByMap(){
        Map<String, Object> map = new HashMap<>();
        map.put("name","圆圆");

        List<User> users = userMapper.selectByMap(map);
        users.stream().map(user -> user.getName()).forEach(user -> System.out.println(user));

    }

    //Wrapper查询：类比Map条件查询
    @Test
    public void selectByWrapper(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.ge("age","1")
        .eq("phone","123456");
        userMapper.selectList(queryWrapper).stream().map(user -> user.getName()).forEach(e -> System.out.println(e));


    }

    //分页查询
    @Test
    public void selectPage(){
        //参数1：当前页面    参数2：页面大小
        Page<User> page = new Page<>(3,3);  //limit 6,3
        userMapper.selectPage(page,null);

        page.getRecords().stream().forEach(user -> System.out.println(user));
    }

    @Test
    public void insert(){
        User user = new User();
        user.setName("元宝");
        user.setAge((short)1);
        user.setGender((short)1);
        user.setPhone("123456");
        int i = userMapper.insert(user);
        System.out.println("插入结果："+i);
    }

    //乐观锁测试 version初始值为1
    @Test
    public void testOptimisticLocker(){
        User user1 = userMapper.selectById(11);
        user1.setPhone("2444");

        User user2 = userMapper.selectById(11);
        user2.setPhone("2555");
        userMapper.updateById(user2);
        //执行失败，version=2
        userMapper.updateById(user1);
    }

    @Test
    public void deleteById(){
        userMapper.deleteById(12);

    }

    //只能更新一条记录
    //UPDATE user SET age=? ,updateTime=? WHERE is_deleted=0 AND (id < ?)
    @Test
    public void update1(){
        User user = new User();
        user.setId(10);
        user.setAge((short)20);
        //在调用updateById方法前，需要在T entity（对应的实体类）中的主键属性上加上@TableId注解。
        userMapper.updateById(user);
    }

    //可以更新一批对象，更为细致地设置具体字段
    // UPDATE user SET age=? WHERE is_deleted=0 AND (id < ?)
    @Test
    public void update2(){
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.lt("id",11);
        updateWrapper.set("age",20);
        userMapper.update(null,updateWrapper);
    }

    /*
    Lambda条件构造器
    使用原因：之前使用条件构造器都是用字符串的形式指定。这种方式无法在编译期确定列名的合法性。
     */

    //查询
    @Test
    public void select(){
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getAge,20);
        List<User> users = userMapper.selectList(queryWrapper);
        users.stream().forEach(e -> System.out.println(e));
    }


}

Service CRUD 接口

/*
- 通用 Service CRUD 封装IService (opens new window)接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
- 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
对象 Wrapper 为 条件构造器
*/


public interface UserService extends IService<User> {
    //自定义方法
    List<String> test();

}


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

    /*
    技巧：
    操作一个对应的表直接使用getBaseMapper()
    操作其他表@Autowired注入
     */
    @Override
    public List<String> test() {
        UserMapper userMapper = getBaseMapper();
        List<User> userList = userMapper.selectList(new QueryWrapper<User>()  //在userMapper.selectList()方法中不能使用LambdaQueryWrapper
                .lambda()
                .eq(User::getAge, 20));
        List<String> list = userList.stream().map(e -> e.getName()).collect(Collectors.toList());
        return list;
    }
}

Controller层

 @Autowired //将service接口注入
    private EmployeeService employeeService;

    /**
     * 员工登录
     * @param request 将员工id存到session中
     * @param param 前端传来JSON形式数据，使用@RequestBody接收
     * @return
     */
    @PostMapping("/login")
    public void login(HttpServletRequest request, @RequestBody Employee param){
        /**
         *  SELECT
         *  name,phone
         *  FROM employee
         *  WHERE name = 'xxx' AND password = 'xxx' AND id > 1000 AND (update_time between 'xxx' AND 'xxxx') AND
         *  ORDER BY create_time DESC limit 1;
         * */
        LambdaQueryWrapper<Employee> queryWrapper = new QueryWrapper<Employee>()  
                .lambda()
                .select(Employee::getName , Employee::getPhone)  //条件默认用AND连接
                .eq(Employee::getName ,param.getName())
                .eq(Employee::getPassword , param.getPassword())
                .ne(Employee::getStatus , 2)
                .ge(Employee::getId , 1000)
                .between(Employee::getUpdateTime , "2023-09-10" , "2023-10-10")
                .orderByDesc(Employee::getCreateTime)
                .last("limit 1");    //如果有多个数据，只获取一个。类似数据库中的unique。
        Employee employee1 = employeeService.getOne(queryWrapper);  //getOne()：获取一条结果

        employeeService.getOne(new QueryWrapper<Employee>()
                .lambda()
                .select(Employee::getName , Employee::getPhone)
                .eq(Employee::getName ,param.getName())
                .eq(Employee::getPassword , param.getPassword())
                .last("limit 1"));

        //查询phone是182开头、或者 (name以王开头 并且 用户状态是1)
        //SELECT XXX FROM xx WHERE (phone like 182) OR (name LIKE 王 AND status = 1)
        //王 2
        employeeService.list(new QueryWrapper<Employee>()
                .lambda()
                .likeLeft(Employee::getPhone , "182") //182XXX。likeLeft和likeRigt查询效率高。
                .or(e -> e.likeLeft(Employee::getName , "王").eq(Employee::getStatus , 1)) //这里e指代new QueryWrapper<Employee>对象
        );


        /*
        List<Employee> employeeList = new ArrayList<>();
        employeeList.stream().filter(e -> e.getName().equals("王子怡")); //这里e 代表Employee对象。如果有List类型，就代表集合元素
        */


    }

代码生成器

package com.example.demo;

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;

/**
 * @author
 * @since 2018/12/13
 */
@Slf4j
public class CodeGenerator {

    @Test
    public void run() {

        // 1、创建代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 2、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("Vivi"); //需要手动修改！
        gc.setOpen(false); //生成后是否打开资源管理器
        gc.setFileOverride(false); //重新生成时文件是否覆盖
        gc.setServiceName("%sService");    //去掉Service接口的首字母I
        gc.setIdType(IdType.ASSIGN_ID); //主键策略
        gc.setDateType(DateType.ONLY_DATE);//定义生成的实体类中日期类型
        gc.setSwagger2(true);//开启Swagger2模式

        mpg.setGlobalConfig(gc);

        // 3、数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT%2B8"); //需要手动修改！
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root"); //需要手动修改！
        dsc.setPassword("123456");  //需要手动修改！
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);

        // 4、包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("project1"); //模块名 需要手动修改！
        pc.setParent("com.example.demo");  //需要手动修改！
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setService("service");
        pc.setMapper("mapper");
        mpg.setPackageInfo(pc);

        // 5、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("user"); //表名 需要手动修改！
        strategy.setNaming(NamingStrategy.underline_to_camel);//数据库表映射到实体的命名策略
        //strategy.setTablePrefix(pc.getModuleName() + "_"); //生成实体时去掉表前缀

        strategy.setColumnNaming(NamingStrategy.underline_to_camel);//数据库表字段映射到实体的命名策略
        strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter链式操作

        strategy.setRestControllerStyle(true); //restful api风格控制器
        strategy.setControllerMappingHyphenStyle(true); //url中驼峰转连字符

        mpg.setStrategy(strategy);


        // 6、执行
        mpg.execute();
    }
}

代码模板

@Override
    public PageResult<EmployeeListVO> pageEmployee(HrEmployeeRequest hrEmployeeRequest) {
        LambdaQueryWrapper<HrEmployee> wrapper = createWrapper(hrEmployeeRequest);
        //创建时间倒序
        wrapper.orderByDesc(HrEmployee::getCreateTime);
        wrapper.select(
                HrEmployee::getEmployeeId , HrEmployee::getEmployeeName , HrEmployee::getPhone
        );
        Page<HrEmployee> sysRolePage = this.page(PageFactory.defaultPage(), wrapper);

        //提取List并转成对应的VO
        List<HrEmployee> employeePageList = sysRolePage.getRecords();
        List<EmployeeListVO> employeeVOList = BeanUtil.copyToList(employeePageList , EmployeeListVO.class);

        //提取这一批数据的员工id集合
        List<Long> employeeIdList = employeePageList.stream().map(e -> e.getEmployeeId()).collect(Collectors.toList());

        //从hr_employee_org关系表 提取这一批员工的主要组织机构 + 主要部门 + 主要任职岗位
        List<EmployeeOrg> relationList = employeeOrgService.list(new QueryWrapper<EmployeeOrg>()
                .lambda()
                .eq(EmployeeOrg::getMainFlag , YesOrNotEnum.Y.getCode())
                .in(EmployeeOrg::getEmployeeId , employeeIdList)
        );
        Map<Long , EmployeeOrg> relationMap = new HashMap<>();
        Map<Long , String> orgMap = new HashMap<>();
        Map<Long , String> departmentMap = new HashMap<>();
        Map<Long , String> positionMap = new HashMap<>();
        if (!relationList.isEmpty()) {
            //转map，备用
            relationMap = relationList.stream().collect(
                    Collectors.toMap(e -> e.getEmployeeId() , Function.identity() , (e1 , e2) -> e2)
            );

            //提取组织机构、部门、任职岗位信息
            List<Long> orgIdList = relationList.stream().map(e -> e.getOrgId()).collect(Collectors.toList());
            List<Long> departmentIdList = relationList.stream().map(e -> e.getDepartmentId()).collect(Collectors.toList());
            List<Long> positionIdList = relationList.stream().map(e -> e.getPositionId()).collect(Collectors.toList());
            //组织机构信息
            List<HrOrganization> orgList = hrOrganizationService.list(new QueryWrapper<HrOrganization>()
                    .lambda()
                    .select(HrOrganization::getOrgId , HrOrganization::getOrgName)
                    .in(HrOrganization::getOrgId , orgIdList)
            );
            orgMap = orgList.stream().collect(
                    Collectors.toMap(e -> e.getOrgId() , e -> e.getOrgName() , (e1,e2) -> e2)
            );
            //部门信息
            List<HrOrganization> departmentList = hrOrganizationService.list(new QueryWrapper<HrOrganization>()
                    .lambda()
                    .select(HrOrganization::getOrgId , HrOrganization::getOrgName)
                    .in(HrOrganization::getOrgId , departmentIdList)
            );
            departmentMap = departmentList.stream().collect(
                    Collectors.toMap(e -> e.getOrgId() , e -> e.getOrgName() , (e1,e2) -> e2)
            );
            //职位信息
            List<HrPosition> positionList = hrPositionService.list(new QueryWrapper<HrPosition>()
                    .lambda()
                    .select(HrPosition::getPositionId , HrPosition::getPositionName)
                    .in(HrPosition::getPositionId , positionIdList)
            );
            positionMap = positionList.stream().collect(
                    Collectors.toMap(e -> e.getPositionId() , e -> e.getPositionName() , (e1,e2) -> e2)
            );

        }

        //TODO 提取员工的登录账号
        List<EmployeeUser> accountRelationList = employeeUserService.list(new QueryWrapper<EmployeeUser>()
                .lambda()
                .in(EmployeeUser::getEmployeeId , employeeIdList)
        );
        Map<Long , EmployeeUser> accountRelationMap = new HashMap<>();
        if (!accountRelationList.isEmpty()) {
            accountRelationMap = accountRelationList.stream().collect(
                    Collectors.toMap(e -> e.getEmployeeId() , Function.identity() , (e1 , e2) -> e2)
            );
        }

        //遍历一遍，设置关联字段的属性值
        for (EmployeeListVO vo : employeeVOList) {
            //从关系map提取当前员工的数据
            EmployeeOrg relation = relationMap.get(vo.getEmployeeId());
            if (relation == null) {
                continue;
            }

            vo.setOrgName(orgMap.get(relation.getOrgId()));
            vo.setDepartmentName(departmentMap.get(relation.getDepartmentId()));
            vo.setPositionName(positionMap.get(relation.getPositionId()));
        }

        //复制分页信息，绑定List
        Page<EmployeeListVO> employVOPage = new Page<>();
        BeanUtil.copyProperties(sysRolePage , employVOPage);
        employVOPage.setRecords(employeeVOList);

        return PageResultFactory.createPageResult(employVOPage);
    }
MyBatisPlus 用法详解
2301_80035594的博客
11-10 4946
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。它提供了许多便捷的功能，比如 CRUD 操作的自动实现、分页插件、性能分析插件等，这些功能可以帮助开发者更快速地开发出高质量的应用程序。
Mybatis 框架 基础语法
twtongwei的博客
03-03 1206
考点： SQL 注入#{}最终生成预编译sql，预编译Sql语句中?替换#{}内容一个#{} 替换一个?在模糊查询时要使用′{}%’ ，因为？不能出现在‘’中，而${}不会生成预编译sql，会直接将传过来的字符串进行拼接。但这种方式性能低、不安全、存在SQL注入问题因此可换成：concat(‘%’,‘张’,‘%’)插件在idea中下载 MybatisX插件，更好地使用mybtiais。
MybatisPlus语法
Chen_Ping_DAYTOY的博客
12-23 890
字符串数组是否包含入参 数据库中存储的是一个字符串数组，传入一个字符串数组或一个字符串，判断数据库中存储的数组是否包含传入的元素。 queryWrapper.apply(入参!=null,"FIND_IN_SET('"+入参+",字段名)"); ...
mybatis-plus
ilov_的博客
06-11 1006
Wrapper ： 条件构造抽象类，最顶端父类AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件QueryWrapper ： 查询条件封装UpdateWrapper ： Update 条件封装AbstractLambdaWrapper ： 使用Lambda 语法LambdaQueryWrapper ：用于Lambda语法使用的查询WrapperLambdaUpdateWrapper ： Lambda 更新封装Wrapper测试用例。
前言技术之Mybatis Plus02
weixin_60389087的博客
03-14 1563
接着上期内容：前言技术之Mybatis Plus_爱嘤斯塔的博客-优快云博客 一、mybatis-plus的含义 升级版的mybatis，目的是让mybatis更易于使用， 用官方的话说“为简化而生”
Mybatis-Puls的语法详细使用
m0_53151031的博客
03-15 7679
目录 一、日志 二、主键生成策略 1、雪花算法 2、自增ID 3、其他类型 三、更新 四、自动填充 1、通过数据库完成自动填充 2、使用程序完成自动填充 第一步：实体类中加入注解 第二步：编写处理类 五、乐观锁 1、乐观锁实现方式 2、乐观锁原理 3、乐观锁配置步骤 1. 在数据库表中.........
Mybatis-plus 常用语法(详细)
xiaoxiaohan130的博客
12-08 3862
mybatis-plus 详细常用语法、注解
Java框架之MyBatis Plus
一个老Java开发的自白
10-22 1293
MyBatis Plus 是一个功能强大且易于使用的数据库访问框架，它不仅简化了 MyBatis 的使用难度，还提供了许多实用的功能。无论是对于新手还是经验丰富的开发者，MyBatis Plus 都是一个值得尝试的选择。通过上述的介绍和代码示例，希望能帮助你更好地理解和使用 MyBatis Plus。
Mybatis plus中使用in查询出错如何解决
08-18
Mybatis plus是一个基于Java的持久层框架，它提供了许多实用的功能来简化数据库操作。然而，在使用Mybatis plus时，开发者可能会遇到一些问题，例如在使用in查询时出现错误。本文将详细介绍Mybatis plus中使用in查询...
mybatis语法增强框架, 综合了mybatis plus, danymic sql, jpa等框架特性和优点生成代码.zip
04-28
mybatis动态sql 1.什么是动态SQL? Mabits是一个Java持久化框架，它提供了动态SQL的功能。动态SQL是一种根据不同条件动态生成SQL语句的技术。在Mabits中，动态SQL通常是通过使用一组特殊的标签和代码块来实现的，...
fluent-mybatis, mybatis语法增强框架
06-29
`fluent-mybatis` 是一个针对 MyBatis 框架的语法增强工具，旨在提升开发效率，简化 SQL 编写过程。它综合了 `MyBatis Plus`、`Dynamic SQL` 和 `JPA` 等多个流行框架的特性与优点，为开发者提供了更强大的功能和...
mybatisplus常用语法
qq_38331606的博客
04-06 894
【代码】mybatisplus常用语法。
Mybatis-Plus 简便语法详解
weixin_39793432的博客
12-27 688
ServiceImpl.insertOrUpdate(Entity entity) 插入或更新，很好用的方法 判断entity表内的主键是否存在，存在则更新，不存在则插入，
mybatisplus 语法
az44yao的专栏
05-13 254
MyBatis-Plus 使用条件构造器进行查询https://blog.youkuaiyun.com/qq_37960603/article/details/108960110 mybatis plus 中增删改查及Wrapper的使用 https://www.cnblogs.com/zjdxr-up/p/14323081.html MyBatis-Plus官网 https://mybatis.plus/guide/wrapper.html#likeright ...
MyBatis-Plus 语法和常用注解使用
weixin_40579395的博客
04-24 2760
MyBatis-Plus 语法和常用注解使用
【MybatisPlus】基础用法整理
归忆_AC的博客
05-29 1013
MyBatis-Plus 是 MyBatis 的一个增强工具，主要简化了 MyBatis 的开发工作，提高了开发效率。它提供了 CRUD 接口、条件构造器、自动分页、代码生成等功能，大大减少了重复代码的编写。简介 | MyBatis-Plus黑马程序员——MybatisPlus1.先看下目录，可以将测试类中的方法看成在业务层中实现功能。2.业务层实现方法，将条件传递到mapper代理层。3.mappper层声明方法，参数前需要加上注解，可以用"ew"也可以用Constants.WRAPPER。
MyBatis-Plus常用语法使用实例汇总(全)
Dahlin哥's 博客
04-10 5790
总结汇总一些MyBatis-Plus常用的语法，包括常用的增删改查，复杂查询构建器，连接多表查询，自定义sql传参查询，构建实体查询，Lambda查询，函数式查询等等。这里不在重复叙述MyBatis-Plus的项目搭建过程。
入门Mybatis-Plus框架
weixin_66153022的博客
07-19 1212
MybatisPlus提供了自定义SQL功能，可以让我们利用Wrapper生成查询条件，再结合Mapper.xml编写SQL。
Mybatis Plus语法
最新发布
m0_52637088的博客
06-20 325
最近工作的时候用到了Mybatis Plus来简化sql,但是当写一些稍微复杂一点的sql时也踩了一些坑,所以写一篇文章来介绍一下Mybatis Plus的一些语法.
mybatis plus框架结构图
05-25
### MyBatis Plus 框架结构图及其架构组成 MyBatis-Plus 是一款基于 MyBatis 的增强工具包，旨在通过自动化的方式提升开发者的工作效率。它不仅提供了单表 CRUD 的自动实现，还集成了多种实用的功能模块[^1]。 #### 1. **核心组件** MyBatis-Plus 的整体架构由多个核心部分构成，以下是主要组成部分： - **Mapper 接口扩展** Mapper 接口是 MyBatis 的核心接口之一，用于执行数据库操作。MyBatis-Plus 提供了一个通用的 `BaseMapper` 接口，继承该接口后即可获得一系列基础的 CRUD 方法支持[^2]。 - **Service 层抽象** Service 层封装了业务逻辑处理能力，MyBatis-Plus 提供了 `IService` 和其实现类 `ServiceImpl`，进一步简化了数据访问层的操作[^3]。 - **条件构造器 (Wrapper)** 条件构造器允许开发者以链式调用的形式构建复杂的查询条件，从而减少手动拼接 SQL 的繁琐过程[^3]。 - **分页插件** 支持对查询结果进行分页处理，并兼容主流数据库的分页语法[^3]。 #### 2. **框架结构图** 下图为 MyBatis-Plus 的典型架构图解： ``` +-----------------------------+ | Application | +-----------------------------+ | 调用 +-----------------------------+ | Service Layer | | (IService, etc.) | +-----------------------------+ | 调用 +-----------------------------+ | Mapper Layer | | (BaseMapper, etc.) | +-----------------------------+ | 映射 +-----------------------------+ | Database Access | | (SQL Execution Engine) | +-----------------------------+ ``` - **Application**: 应用程序入口，负责调用服务层。 - **Service Layer**: 封装业务逻辑，通常依赖于 Mapper 进行数据交互。 - **Mapper Layer**: 数据映射层，提供基础的数据操作功能。 - **Database Access**: 数据库访问引擎，具体执行 SQL 请求并返回结果。 #### 3. **功能模块详解** - **单表 CRUD 自动化** 开发者只需定义实体类和对应的 Mapper 接口，无需编写任何 SQL 即可完成常见的增删改查操作[^1]。 - **批量操作支持** 提供批量插入、更新等功能，适用于大规模数据处理场景[^3]。 - **动态 SQL 构建** 利用 Wrapper 工具可以灵活地组合各种查询条件，满足复杂业务需求。 - **分页与性能优化** 内置高性能分页插件，能够显著降低大数据量下的内存占用和响应时间[^3]。 ```java // 示例代码：使用 MyBatis-Plus 实现分页查询 Page<User> page = new Page<>(current, size); IPage<User> userPage = userMapper.selectPage(page, null); for (User record : userPage.getRecords()) { System.out.println(record.getName()); } ``` --- ####
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值