精华内容
下载资源
问答
  • 2020-10-08 13:37:59

    JPA的接口定义可以继承的接口有

    • Repository (总接口)
    • CrudRepository (CRUD简单接口)
    • PagingAndSortingRepository (分页排序接口)
    • JpaRepository (继承上面所有接口)
    • JpaSpecificationExecutor (条件查询接口)

    jpa接口方法定义共三大类

    • 默认的方法
    • 自定义有规则名的方法
    • 自定义sql

    浩瀚的网络中,你我的相遇也是种缘分,看你天资聪慧、骨骼精奇,就送你一场大造化吧,能领悟多少就看你自己了。㊙传承之地🙇

    1.默认方法

    当类继承了上面几个接口后,就会有很多默认的方法

    • save
    • existsById
    • findById
    • saveAll
    • deleteById
    • findOne
    • findAll
    • count

    示例

    @Repository
    public interface StudentRepository extends JpaRepository<Student, String> {
    }
    

    配置

    server.port=8080
    
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.url=jdbc:mysql://localhost:3306/xxx_tool?useUnicode=true&characterEncoding=UTF-8
    spring.datasource.username=iworkh
    spring.datasource.password=iworkh123
    
    spring.jpa.hibernate.ddl-auto=update
    spring.jpa.show-sql=true
    

    2.规则名方法

    KeywordSampleJPQL snippet
    AndfindByLastnameAndFirstnamewhere x.lastname = ?1 and x.firstname = ?2
    OrfindByLastnameOrFirstnamewhere x.lastname = ?1 or x.firstname = ?2
    Is, EqualsfindByFirstname
    findByFirstnameIs
    findByFirstnameEquals
    where x.firstname = ?1
    BetweenfindByStartDateBetweenwhere x.startDate between ?1 and ?2
    LessThanfindByAgeLessThanwhere x.age < ?1
    LessThanEqualfindByAgeLessThanEqualwhere x.age <= ?1
    GreaterThanfindByAgeGreaterThanwhere x.age > ?1
    GreaterThanEqualfindByAgeGreaterThanEqualwhere x.age >= ?1
    AfterfindByStartDateAfterwhere x.startDate > ?1
    BeforefindByStartDateBeforewhere x.startDate < ?1
    IsNull, NullfindByAge(Is)Nullwhere x.age is null
    IsNotNull, NotNullfindByAge(Is)NotNullwhere x.age not null
    LikefindByFirstnameLikewhere x.firstname like ?1
    NotLikefindByFirstnameNotLikewhere x.firstname not like ?1
    StartingWithfindByFirstnameStartingWithwhere x.firstname like ?1 (parameter bound with appended %)
    EndingWithfindByFirstnameEndingWithwhere x.firstname like ?1 (parameter bound with prepended %)
    ContainingfindByFirstnameContainingwhere x.firstname like ?1 (parameter bound wrapped in %)
    OrderByfindByAgeOrderByLastnameDescwhere x.age = ?1 order by x.lastname desc
    NotfindByLastnameNotwhere x.lastname <> ?1
    InfindByAgeIn(Collection ages)where x.age in ?1
    NotInfindByAgeNotIn(Collection ages)where x.age not in ?1
    TruefindByActiveTrue()where x.active = true
    FalsefindByActiveFalse()where x.active = false
    IgnoreCasefindByFirstnameIgnoreCasewhere UPPER(x.firstame) = UPPER(?1)

    示例:

    @Repository
    public interface ToolsSysDao extends JpaRepository<ToolsSysEntity, String>,
            JpaSpecificationExecutor<ToolsSysEntity> {
    
        List<ToolsSysEntity> findAllBySysNameOrderByOrderNumDesc(String sysName);
    }
    

    根据SysName来查,并OrderNum字段进行降序。(注意驼峰)

    entity实体类

    @Entity
    @Table(name = "tools_sys", schema = "iworkh_tool")
    public class ToolsSysEntity {
    
        @Id
        @Column(length = 32, name = "id")
        private String id;
    
        @Column(length = 20, name = "sys_name")
        private String sysName;
    
        @Column(length = 2, name = "order_num")
        private int orderNum = 1;
    
        @Column(name = "visible_flag")
        private boolean visibleFlag = true;
    
        @Column(length = 500, name = "description")
        private String description;
    
        ...省略setter、getter方法...
    }
    
    

    3.自定义sql

    通过名称规则的方式,可以处理比较简单的sql,如果特别复杂的sql。需要通过sql编写来完成。jpa里支持通过自定义sql来完成。

    自定sql是指:在方法上使用@Query注解,然后写sql

    @Query注解中两个常用的属性

    • value (不用多讲,定义sql)
    • nativeQuery (true表示数据的sql,false表示HQL,默认值是false)

    3-1.hql

    hql大白话讲: sql里字段用定义entity实体类的变量名(驼峰),而不是数据库里的字段(下划线)

    示例:

    @Repository
    public interface ToolsSysDao extends PagingAndSortingRepository<ToolsSysEntity, String>,
            JpaSpecificationExecutor<ToolsSysEntity> {
    
     @Query(value = "SELECT sysName as name FROM ToolsSysEntity WHERE visibleFlag=:visibleFlag ORDER BY orderNum DESC")
        List<Map<String, String>> findSysNameByVisibleFlagOrderByOrderNumDesc(boolean visibleFlag);
    
    }
    

    native默认值是false,即HSQL。字段名要是entity定义的变量名(驼峰),表名是类名.

    3-2.native

    示例:

    @Repository
    public interface ToolsSysDao extends PagingAndSortingRepository<ToolsSysEntity, String>,
            JpaSpecificationExecutor<ToolsSysEntity> {
    
        @Query(value = "SELECT sys_name as name FROM logistics_tools_sys WHERE visible_flag=:visibleFlag ORDER BY order_num DESC limit :limitSize", nativeQuery = true)
        List<Map<String, String>> findSysNameByVisibleFlagOrderByOrderNumDescLimit(boolean visibleFlag, int limitSize);
    }
    

    hql里不支持limit语法,可以使用native为true,写数据库sql。这时需要注意字段要是数据库字段了(下划线)。

    4.推荐

    能读到文章最后,首先得谢谢您对本文的肯定,你的肯定是对博主最大的鼓励。

    你觉本文有帮助,那就点个👍
    你有疑问,那就留下您的💬
    怕把我弄丢了,那就把我⭐
    电脑不方便看,那就把发到你📲

    更多相关内容
  • 主要介绍了MyBatisPlus 自定义sql语句的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了MyBatis-Plus 分页查询以及自定义sql分页的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 主要介绍了MybatisPlus自定义Sql实现多表查询的示例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JEECG 开发文档系列 ——JEECG 数据权限自定义SQL表达式用法说明
  • 基于jquery js自定义sql条件查询.rar
  • 该文章介绍了自定义sql在ibaits应用,并描述了自己在实现过程中遇到的问题及解决过程,望能遇到同样问题的你提供参考
  • MyBatis-plus自定义SQL

    多人点赞 热门讨论 2022-05-23 22:37:20
    Plus Mybatis-Plus(连接Hive) 23 MyBatis-Plus MyBatis-plus配置自定义SQL(执行用户传入SQL) 24 MyBatis-Plus Mybatis-Plus(Service CRUD 接口) 文章目录 一、原生MyBatis执行 二、MyBatis 执行 2.1、调用dao 2.2、...
    序号类型地址
    1MySQLMySQL操作之概念、SQL约束(一)
    2MySQLMySQL操作之数据定义语言(DDL)(二)
    3MySQLMySQL操作之数据操作语言(DML)(三)
    4MySQLMySQL操作之数据查询语言:(DQL)(四-1)(单表操作)
    5MySQLMySQL操作之数据查询语言:(DQL)(四-2)(多表查询)
    6MySQLMySQL操作之数据控制语言:(DC)(五)
    7MySQLMySQL操作之数据库函数
    8MySQLMySQL管理之数据类型
    9MySQLMySQL管理之索引
    10MySQLMySQL管理之事务管理
    11MySQLMySQL管理之存储过程
    12MySQLMySQL管理之视图
    13MySQLMySQL管理之数据备份与还原
    14MySQLLinux(centos 7.5)服务器安装MySQL
    15MyBatisMyBatis从入门到多表关联
    16MyBatisMyBatis常用方法
    17MyBatisMybatis逆向工程的使用(附文件地址)
    18MyBatisspring boot连接Mybatis数据库的配置文件(MySql、SQLserver、Oracle)
    19MyBatis-PlusMybatis-Plus使用案例(包括初始化以及常用插件)
    20MyBatis-Plusmybatis-plus代码生成器
    21MyBatis-Plus自定义SQL
    22MyBatis-PlusMybatis-Plus(连接Hive)
    23MyBatis-PlusMyBatis-plus配置自定义SQL(执行用户传入SQL)
    24MyBatis-PlusMybatis-Plus(Service CRUD 接口)


    一、原生MyBatis执行

    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionTemplate;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import java.sql.SQLException;
    
    public class TestMySql {
        @Autowired
        private SqlSessionTemplate sqlSessionTemplate;
    
        //    自定义执行SQL
        public void mySql() throws SQLException {
            String sql = "select * from User";
            SqlSession sqlSession = openSession();
            sqlSession.getConnection().prepareStatement(sql);
            closeSession(sqlSession);
        }
    
        //    开启链接
        private SqlSession openSession() {
            SqlSessionFactory sqlSessionFactory = sqlSessionTemplate.getSqlSessionFactory();
            return sqlSessionFactory.openSession();
        }
    
        //    关闭链接
        private void closeSession(SqlSession sqlSession) {
            sqlSession.close();
        }
    }
    
    

    二、MyBatis 执行

    2.1、调用dao

    String sql = "Select * From User";
    sqlMapper.explainQuery(sql);
    

    2.2、dao层接口配置

    @SqlParser(filter = true)
    void explainQuery(String sql);
    

    2.3、dao中xml配置

    <update id="explainQuery">
      ${templateName,jdbcType=VARCHAR}
    </update>
    

    三、MyBatis-plus中Sql注入器

    3.1、编写MyBaseMapper(要添加方法)

    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import java.util.List;
    public interface MyBaseMapper<T> extends BaseMapper<T> {
        List<T> findAll();
    }
    

    3.2、编写FindAll(方法具体实现)

    import com.baomidou.mybatisplus.core.enums.SqlMethod;
    import com.baomidou.mybatisplus.core.injector.AbstractMethod;
    import com.baomidou.mybatisplus.core.metadata.TableInfo;
    import org.apache.ibatis.mapping.MappedStatement;
    import org.apache.ibatis.mapping.SqlSource;
    
    public class FindAll extends AbstractMethod {
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
            String sqlMethod = "findAll";
            String sql = "select * from " + tableInfo.getTableName();
            SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
            return this.addSelectMappedStatement(mapperClass, sqlMethod, sqlSource, modelClass, tableInfo);
        }
    }
    

    3.3、编写MySqlInjector(注册到MyBatis-plus中)

    import com.baomidou.mybatisplus.core.injector.AbstractMethod;
    import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
    
    import java.util.List;
    
    public class MySqlInjector extends DefaultSqlInjector {
        @Override
        public List<AbstractMethod> getMethodList() {
            List<AbstractMethod> methodList = super.getMethodList();
            methodList.add(new FindAll()); // 再扩充自定义的方法
            list.add(new FindAll());
            return methodList;
        }
    }
    

    3.4、编写MySqlInjector(注册到MyBatis-plus中)

    import com.baomidou.mybatisplus.core.injector.AbstractMethod;
    import com.baomidou.mybatisplus.core.injector.DefaultSqlInjector;
    
    import java.util.List;
    
    public class MySqlInjector extends DefaultSqlInjector {
        @Override
        public List<AbstractMethod> getMethodList() {
            List<AbstractMethod> methodList = super.getMethodList();
            methodList.add(new FindAll()); // 再扩充自定义的方法
            list.add(new FindAll());
            return methodList;
        }
    }
    
    ### 2.4、注册到Spring容器
    
    ```java
    /*** 自定义SQL注入器 */
    @Bean
    public MySqlInjector mySqlInjector() {
        return new MySqlInjector();
    }
    

    3.5、测试

    @Test
    public void testFindAll() {
        List<User> users = this.userMapper.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    
    展开全文
  • MyBatis-Plus--自定义SQL

    千次阅读 2020-08-01 10:02:46
    其他网址 一文MyBatis-Plus快速入门 - 享智同行 - 博客园mybatis-plus的使用 -----...mybatis-plus之自定义sql、分页、Wrapper_CDN-CSDN博客_mybatisplus wrapper分页Mybatisplus 自定义sql 使用条件构造器 - 静水165

    原文网址:MyBatis-Plus--自定义SQL_IT利刃出鞘的博客-CSDN博客

    简介

    说明

        本文用实例介绍MybatisPlus如何自定义SQL。

    使用

    自定义的sql使用Wrapper对版本有要求:mybatis-plus版本需要大于或等于3.0.7。

    含义

    ew.customSqlSegment

    条件构造器(Wrapper)

    ew.sqlSet

    所设置的列

    ew.sqlSelect

    要select的列

    特殊语句

    操作实例说明
    TRUNCATE@Update("TRUNCATE xxx")不要用@Delete
    ALTER@Update("ALTER xxx")
    DELETE@Delete("DELETE xxx")

    源码

    包里边定义好的常量。我们可以直接用这些常量。

    mybatis-plus-core-3.3.2.jar\com\baomidou\mybatisplus\core\toolkit\Constants.class

    package com.baomidou.mybatisplus.core.toolkit;
    
    public interface Constants extends StringPool {
        String MYBATIS_PLUS = "mybatis-plus";
        String MD5 = "MD5";
        String AES = "AES";
        String AES_CBC_CIPHER = "AES/CBC/PKCS5Padding";
        String ENTITY = "et";
        String ENTITY_DOT = "et.";
        String WRAPPER = "ew";
        String WRAPPER_DOT = "ew.";
        String WRAPPER_ENTITY = "ew.entity";
        String WRAPPER_SQLSEGMENT = "ew.sqlSegment";
        String WRAPPER_EMPTYOFNORMAL = "ew.emptyOfNormal";
        String WRAPPER_NONEMPTYOFNORMAL = "ew.nonEmptyOfNormal";
        String WRAPPER_NONEMPTYOFENTITY = "ew.nonEmptyOfEntity";
        String WRAPPER_EMPTYOFWHERE = "ew.emptyOfWhere";
        String WRAPPER_NONEMPTYOFWHERE = "ew.nonEmptyOfWhere";
        String WRAPPER_ENTITY_DOT = "ew.entity.";
        String U_WRAPPER_SQL_SET = "ew.sqlSet";
        String Q_WRAPPER_SQL_SELECT = "ew.sqlSelect";
        String Q_WRAPPER_SQL_COMMENT = "ew.sqlComment";
        String Q_WRAPPER_SQL_FIRST = "ew.sqlFirst";
        String COLUMN_MAP = "cm";
        String COLUMN_MAP_IS_EMPTY = "cm.isEmpty";
        String COLLECTION = "coll";
        String WHERE = "WHERE";
        String MP_OPTLOCK_INTERCEPTOR = "oli";
        String MP_OPTLOCK_VERSION_ORIGINAL = "MP_OPTLOCK_VERSION_ORIGINAL";
        String MP_OPTLOCK_VERSION_COLUMN = "MP_OPTLOCK_VERSION_COLUMN";
        String MP_OPTLOCK_ET_ORIGINAL = "MP_OPTLOCK_ET_ORIGINAL";
        String WRAPPER_PARAM = "MPGENVAL";
        String WRAPPER_PARAM_FORMAT = "#{%s.paramNameValuePairs.%s}";
    }

    实例1:常用操作

    代码

    Mapper

    package com.example.business.customsql.mapper;
    
    import com.baomidou.mybatisplus.core.conditions.Wrapper;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.example.business.customsql.entity.User;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> {
        // 条件放到wrapper
        @Select("SELECT * FROM t_user ${ew.customSqlSegment}")
        List<User> testSelect1(@Param("ew") Wrapper wrapper);
        // 也可以这么写
        // List<User> testSelect1(@Param(Constants.WRAPPER) Wrapper wrapper);
    
        // 条件放到wrapper,指定表名
        @Select("SELECT * FROM ${table_name} ${ew.customSqlSegment}")
        List<User> testSelect2(@Param("table_name") String tableName, @Param("ew") Wrapper wrapper);
    
        // 条件放到wrapper,指定表名、所需字段
        @Select("SELECT ${ew.SqlSelect} FROM ${table_name} ${ew.customSqlSegment}")
        List<User> testSelect3(@Param("table_name") String tableName, @Param("ew") Wrapper wrapper);
    
        // 条件放到wrapper,指定某个字段,指定表名、所需字段
        @Select("SELECT ${ew.SqlSelect} FROM ${table_name} ${ew.customSqlSegment} AND age = #{age} ")
        List<User> testSelect4(@Param("table_name") String tableName,
                               @Param("age") Integer age, @Param("ew") Wrapper wrapper);
    }
    

    Controller

    package com.example.business.customsql;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    import com.example.business.customsql.entity.User;
    import com.example.business.customsql.mapper.UserMapper;
    import com.example.business.customsql.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    @RestController
    @RequestMapping("customSQL")
    public class CustomSQLController {
        @Autowired
        private UserMapper userMapper;
        
        @Autowired
        private UserService userService;
    
        @GetMapping("test1234")
        public void test1234() {
            
            // 写法1:Wrappers获取LambdaQueryWrapper(推荐)
            LambdaQueryWrapper<User> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper
                    .eq(User::getUserName, "Tony2")
                    .select(User::getId, User::getAge);
        
            // 写法2:通过service获得lambdaQuery。
            // 这样写有的版本会报错:MybatisPlusException: can not use this method for "getCustomSqlSegment"
            // LambdaQueryChainWrapper<User> queryWrapper = userService
    		// 			.lambdaQuery
    		// 			.eq(User::getUserName, "Tony2")
            //             .select(User::getId, User::getAge)
    
            // 写法3:QueryWrapper
            // QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            // queryWrapper.eq("name", "Tony2").select("id", "age");
            
            List<User> users1 = userMapper.testSelect1(queryWrapper);
            List<User> users2 = userMapper.testSelect2("t_user", queryWrapper);
            List<User> users3 = userMapper.testSelect3("t_user", queryWrapper);
            List<User> users4 = userMapper.testSelect4("t_user", 22, queryWrapper);
    
            System.out.println("----------------------------------------------------------");
            System.out.println(users1);
            System.out.println(users2);
            System.out.println(users3);
            System.out.println(users4);
        }
    }
     

    测试

    访问:http://localhost:8080/customSQL/test1234

    结果

    JDBC Connection [HikariProxyConnection@1693577632 wrapping com.mysql.cj.jdbc.ConnectionImpl@55539d0] will not be managed by Spring
    ==>  Preparing: SELECT * FROM t_user WHERE (user_name = ?)
    ==> Parameters: Tony2(String)
    <==    Columns: id, user_name, age
    <==        Row: 2, Tony2, 22
    <==        Row: 3, Tony2, 22
    <==        Row: 4, Tony2, 23
    <==      Total: 3
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@17030d24]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@425ed15b] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@243999369 wrapping com.mysql.cj.jdbc.ConnectionImpl@55539d0] will not be managed by Spring
    ==>  Preparing: SELECT * FROM t_user WHERE (user_name = ?)
    ==> Parameters: Tony2(String)
    <==    Columns: id, user_name, age
    <==        Row: 2, Tony2, 22
    <==        Row: 3, Tony2, 22
    <==        Row: 4, Tony2, 23
    <==      Total: 3
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@425ed15b]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@38c16ae] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@938269581 wrapping com.mysql.cj.jdbc.ConnectionImpl@55539d0] will not be managed by Spring
    ==>  Preparing: SELECT id,age FROM t_user WHERE (user_name = ?)
    ==> Parameters: Tony2(String)
    <==    Columns: id, age
    <==        Row: 2, 22
    <==        Row: 3, 22
    <==        Row: 4, 23
    <==      Total: 3
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@38c16ae]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@53f471bc] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@808334346 wrapping com.mysql.cj.jdbc.ConnectionImpl@55539d0] will not be managed by Spring
    ==>  Preparing: SELECT id,age FROM t_user WHERE (user_name = ?) AND age = ?
    ==> Parameters: Tony2(String), 22(Integer)
    <==    Columns: id, age
    <==        Row: 2, 22
    <==        Row: 3, 22
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@53f471bc]
    ----------------------------------------------------------
    [User(id=2, userName=Tony2, age=22), User(id=3, userName=Tony2, age=22), User(id=4, userName=Tony2, age=23)]
    [User(id=2, userName=Tony2, age=22), User(id=3, userName=Tony2, age=22), User(id=4, userName=Tony2, age=23)]
    [User(id=2, userName=null, age=22), User(id=3, userName=null, age=22), User(id=4, userName=null, age=23)]
    [User(id=2, userName=null, age=22), User(id=3, userName=null, age=22)]

    实例2:不常用操作

    代码

    Mapper

    package com.example.business.customsql.mapper;
    
    import com.baomidou.mybatisplus.core.conditions.Wrapper;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.example.business.customsql.entity.User;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.apache.ibatis.annotations.Update;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    import java.util.Map;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> {
        // 指定某个条件,指定表名
        @Select("SELECT * FROM ${table_name} WHERE age = #{age}")
        List<User> testSelect5(@Param("table_name") String tableName, @Param("age") Integer age);
    
        // 条件放到wrapper,指定表名、所需字段,返回map
        @Select("SELECT ${ew.SqlSelect} FROM ${table_name} ${ew.customSqlSegment}")
        List<Map<String, Object>> testSelect6(@Param("table_name") String tableName, @Param("ew") Wrapper wrapper);
    
        // 只取name这一列
        @Select("SELECT t_user.user_name FROM t_user ${ew.customSqlSegment}")
        List<String> testSelect7(@Param("ew") Wrapper wrapper);
    
        // 条件放到wrapper,指定表名,只获取一个。若有多个则报错
        @Select("SELECT * FROM ${table_name} ${ew.customSqlSegment}")
        User testSelect8(@Param("table_name") String tableName, @Param("ew") Wrapper wrapper);
    
        // 测试更新
        @Update("UPDATE ${table_name} SET ${ew.sqlSet} ${ew.customSqlSegment}")
        int testUpdate1(@Param("table_name") String tableName, @Param("ew") Wrapper wrapper);
    }
    

    Controller

    package com.example.business.customsql;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    import com.example.business.customsql.entity.User;
    import com.example.business.customsql.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    @RestController
    @RequestMapping("customSQL")
    public class CustomSQLController {
        @Autowired
        private UserMapper userMapper;
    
        @GetMapping("test5678")
        public void test5678() {
            List<User> users1 = userMapper.testSelect5("t_user", 22);
            LambdaQueryWrapper<User> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper
                    .eq(User::getUserName, "Tony2")
                    .eq(User::getAge, 22)
                    .select(User::getUserName, User::getAge);
    
            // 写法2  有service时可以这么写,此写法推荐使用。
    		// LambdaQueryChainWrapper<User> queryWrapper = userService
    		// 			.lambdaQuery
    		// 			.eq(User::getUserName, "Tony2")
            //          .eq(User::getAge, 22)
            //          .select(User::getId, User::getAge)
    
            // 写法3
            // QueryWrapper<User> queryWrapper = new QueryWrapper<>();
            // queryWrapper.eq("user_name", "Tony2").eq("age", 22);
    
            List<Map<String, Object>> users2 = userMapper.testSelect6("t_user", queryWrapper);
            List<String> userNames = userMapper.testSelect7(queryWrapper);
    
            LambdaQueryWrapper<User> queryWrapper1 = Wrappers.lambdaQuery();
            queryWrapper1
                    .eq(User::getUserName, "Tony1")
                    .eq(User::getAge, 21)
                    .select(User::getUserName, User::getAge);
            User user = userMapper.testSelect8("t_user", queryWrapper1);
    
            System.out.println("----------------------------------------------------------");
            System.out.println(users1);
            System.out.println(users2);
            System.out.println(userNames);
            System.out.println(user);
        }
    }
    

    测试

    访问:http://localhost:8080/customSQL/test5678

    结果

    JDBC Connection [HikariProxyConnection@570520501 wrapping com.mysql.cj.jdbc.ConnectionImpl@54a994a6] will not be managed by Spring
    ==>  Preparing: SELECT * FROM t_user WHERE age = ?
    ==> Parameters: 22(Integer)
    <==    Columns: id, user_name, age
    <==        Row: 2, Tony2, 22
    <==        Row: 3, Tony2, 22
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@55b1e390]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3589afac] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@672917088 wrapping com.mysql.cj.jdbc.ConnectionImpl@54a994a6] will not be managed by Spring
    ==>  Preparing: SELECT user_name,age FROM t_user WHERE (user_name = ? AND age = ?)
    ==> Parameters: Tony2(String), 22(Integer)
    <==    Columns: user_name, age
    <==        Row: Tony2, 22
    <==        Row: Tony2, 22
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3589afac]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@61942f9f] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@1111642269 wrapping com.mysql.cj.jdbc.ConnectionImpl@54a994a6] will not be managed by Spring
    ==>  Preparing: SELECT t_user.user_name FROM t_user WHERE (user_name = ? AND age = ?)
    ==> Parameters: Tony2(String), 22(Integer)
    <==    Columns: user_name
    <==        Row: Tony2
    <==        Row: Tony2
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@61942f9f]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5cf8e912] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@622095606 wrapping com.mysql.cj.jdbc.ConnectionImpl@54a994a6] will not be managed by Spring
    ==>  Preparing: SELECT * FROM t_user WHERE (user_name = ? AND age = ?)
    ==> Parameters: Tony1(String), 21(Integer)
    <==    Columns: id, user_name, age
    <==        Row: 1, Tony1, 21
    <==      Total: 1
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@5cf8e912]
    ----------------------------------------------------------
    [User(id=2, userName=Tony2, age=22), User(id=3, userName=Tony2, age=22)]
    [{user_name=Tony2, age=22}, {user_name=Tony2, age=22}]
    [Tony2, Tony2]
    User(id=1, userName=Tony1, age=21)
    

    实例3:IN的坑

    简介

    Mybatis-Plus无法在自定义SQL中直接使用IN查询,无论传参类型是List、ArrayList、数组、可变参数。

    解决方法:将IN查询放到Wrapper中,然后传入自定义SQL。

    代码

    Mapper

    package com.example.business.customsql.mapper;
    
    import com.baomidou.mybatisplus.core.conditions.Wrapper;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.example.business.customsql.entity.User;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> {
        // 错误做法。Mybatis-Plus不支持自定义SQL中使用IN,参数类型是List、ArrayList、数组、可变参数都不行
        @Select("SELECT t_user.user_name FROM t_user WHERE id IN (#{ids}) AND user_name = #{userName}")
        List<User> testIn1(@Param("ids") List<Long> ids, @Param("userName")String userName);
    
        // 错误做法。Mybatis-Plus不支持自定义SQL中使用IN,参数类型是List、ArrayList、数组、可变参数都不行
        @Select("SELECT t_user.user_name FROM t_user WHERE id IN (#{ids}) AND user_name = #{userName}")
        List<User> testIn2(@Param("userName") String userName, @Param("ids") Long... ids);
    
        @Select("SELECT t_user.user_name FROM t_user ${ew.customSqlSegment} AND user_name = #{userName}")
        List<User> testIn3(@Param("ew") Wrapper wrapper, @Param("userName")String userName);
    }
    

    Controller

    package com.example.business.customsql;
    
    import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    import com.example.business.customsql.entity.User;
    import com.example.business.customsql.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Arrays;
    import java.util.List;
    
    @RestController
    @RequestMapping("customSQL")
    public class CustomSQLController {
        @Autowired
        private UserMapper userMapper;
    
        @GetMapping("testIn")
        public void testIn() {
            Long[] ids = new Long[]{1L, 2L, 3L};
            List<Long> idList = Arrays.asList(ids);
            List<User> users1 = userMapper.testIn1(idList, "Tony2");
            List<User> users2 = userMapper.testIn2("Tony2", ids);
    
            LambdaQueryWrapper<User> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(User::getId, idList);
            List<User> users3 = userMapper.testIn3(queryWrapper, "Tony2");
    
            System.out.println("----------------------------------------------------------");
            System.out.println(users1);
            System.out.println(users2);
            System.out.println(users3);
        }
    }
    

    测试

    访问:http://localhost:8080/customSQL/testIn

    结果

    JDBC Connection [HikariProxyConnection@1841994020 wrapping com.mysql.cj.jdbc.ConnectionImpl@73e5ef65] will not be managed by Spring
    ==>  Preparing: SELECT t_user.user_name FROM t_user WHERE id IN (?) AND user_name = ?
    ==> Parameters: [1, 2, 3](ArrayList), Tony2(String)
    <==      Total: 0
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@7b3d58a6]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6e65ce0e] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@676282173 wrapping com.mysql.cj.jdbc.ConnectionImpl@73e5ef65] will not be managed by Spring
    ==>  Preparing: SELECT t_user.user_name FROM t_user WHERE id IN (?) AND user_name = ?
    ==> Parameters: [Ljava.lang.Long;@e4762e9(Long[]), Tony2(String)
    <==      Total: 0
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6e65ce0e]
    Creating a new SqlSession
    SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3eadc23b] was not registered for synchronization because synchronization is not active
    JDBC Connection [HikariProxyConnection@1413127542 wrapping com.mysql.cj.jdbc.ConnectionImpl@73e5ef65] will not be managed by Spring
    ==>  Preparing: SELECT t_user.user_name FROM t_user WHERE (id IN (?,?,?)) AND user_name = ?
    ==> Parameters: 1(Long), 2(Long), 3(Long), Tony2(String)
    <==    Columns: user_name
    <==        Row: Tony2
    <==        Row: Tony2
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3eadc23b]
    ----------------------------------------------------------
    []
    []
    [User(id=null, userName=Tony2, age=null), User(id=null, userName=Tony2, age=null)]

    实例4:动态查询

    简介

            代码里经常遇到动态查询(多条件查询)的情况,mybatis-plus在查单表的时候直接用代码拼接动态条件即可,但多表的时候就只能手写sql了。

            本处示例如何手写sql来进行动态查询。本处示例单表自定义SQL动态查询,多表是一样的用法。

    代码

    mapper

    package com.example.business.customsql.mapper;
    
    import com.baomidou.mybatisplus.core.conditions.Wrapper;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.example.business.customsql.entity.User;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> {
        // ----------------- 测试动态查询 ---------------------------------------------------------------------
        @Select("SELECT * FROM t_user WHERE " +
                " IF(#{userName} IS NOT NULL, t_user.user_name = #{userName}, 1=1)" +
                " AND IF(#{age} IS NOT NULL, t_user.age = #{age}, 1=1)")
        List<User> testDynamic1(@Param("userName") String userName, @Param("age") Integer age);
    }
    

    controller

    package com.example.business.customsql;
    
    import com.baomidou.mybatisplus.core.toolkit.Wrappers;
    import com.example.business.customsql.entity.User;
    import com.example.business.customsql.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    
    @RestController
    @RequestMapping("customSQL")
    public class CustomSQLController {
        @Autowired
        private UserMapper userMapper;
    
        @GetMapping("testDynamic")
        public void testDynamic() {
            List<User> users = userMapper.testDynamic1(null, 22);
            System.out.println(users);
        }
    }
    

    测试

    访问:http:localhost:8080/customSQL/testDynamic

    后端结果

    JDBC Connection [HikariProxyConnection@245966168 wrapping com.mysql.cj.jdbc.ConnectionImpl@7e2d6fd9] will not be managed by Spring
    ==>  Preparing: SELECT * FROM t_user WHERE IF(? IS NOT NULL, t_user.user_name = ?, 1=1) AND IF(? IS NOT NULL, t_user.age = ?, 1=1)
    ==> Parameters: null, null, 22(Integer), 22(Integer)
    <==    Columns: id, user_name, age
    <==        Row: 2, Tony2, 22
    <==        Row: 3, Tony2, 22
    <==      Total: 2
    Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@3e93302e]
    [User(id=2, userName=Tony2, age=22), User(id=3, userName=Tony2, age=22)]
    

    其他网址

    mybatis-plus之自定义sql、分页、Wrapper_CDN-CSDN博客_mybatisplus wrapper分页
    Mybatisplus 自定义sql 使用条件构造器 - 静水165 - 博客园

    展开全文
  • MyBatis-Plus——自定义SQL语句

    千次阅读 多人点赞 2022-01-18 12:30:36
    讲解在如何在MyBatis-Plus中自定义XML配置文件,用两种配置方式来进行讲解分析,更快的提高我们的开发效率。

    📢📢📢📣📣📣

    哈喽!大家好,我是【一心同学】,一位上进心十足的【Java领域博主】!😜😜😜

    ✨【一心同学】的写作风格:喜欢用【通俗易懂】的文笔去讲解每一个知识点,而不喜欢用【高大上】的官方陈述。

    ✨【一心同学】博客的领域是【面向后端技术】的学习,未来会持续更新更多的【后端技术】以及【学习心得】。

    ✨如果有对【后端技术】感兴趣的【小可爱】,欢迎关注一心同学】💞💞💞

    ❤️❤️❤️感谢各位大可爱小可爱!❤️❤️❤️ ‘


    目录

    前言

    一、在src/main/resource目录下编写XML

    1.1  目录结构

    1.2   编写实体类对应的Mapper接口

    1.3  编写UserMapper.xml

    1.4  在配置文件中扫描我们的xml配置的位置。

    1.5  测试

    二、在src/main/java目录下编写XML

    2.1  目录结构

    1.2   编写实体类对应的Mapper接口

    1.3   编写UserMapper.xml

    1.4   编写配置文件

    1.5  🔥 配置pom.xml(重要)🔥

    1.6  测试

    三、classpath和classpath*的区别

    小结


    前言

    当我们在开发过程中,如果MyBatis-Plus中的SQL语句并不能满足我们的需求,那么我们可以在XML文件中自定义SQL语句,这样的话我们就可以在MyBatis-Plus的基础上继续提高我们的开发效率了。本篇博客也将讲解如何在src/main/resource目录下和src/main/java目录下对XML的配置。

    一、在src/main/resource目录下编写XML

    1.1  目录结构

    我们将UserMapper.xml放在resource下的mapper目录中,我的整个项目目录如下

    1.2   编写实体类对应的Mapper接口

    Tip:我们这里自定义了getAll()方法,获取全部用户的信息。

    package com.yixin.mapper;
    
    import com.yixin.pojo.User;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    /**
     * <p>
     *  Mapper 接口
     * </p>
     *
     * @author yixin
     * @since 2022-01-17
     */
    @Repository
    public interface UserMapper extends BaseMapper<User> {
    
        public List<User> getAll();
    
    }
    

    1.3  编写UserMapper.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.yixin.mapper.UserMapper">
    
        <select id="getAll" resultType="com.yixin.pojo.User">
            select * from user
        </select>
    
    </mapper>
    

    1.4  在配置文件中扫描我们的xml配置的位置。

    application.properties:

    mybatis-plus.mapper-locations=classpath:/mapper/**.xml

    1.5  测试

    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    @SpringBootTest
    class AutoApplicationTests {
    
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        void test() {
    
            List<User> userList=userMapper.getAll();
            System.out.println(userList);
        }
    }

    结果:

    可以发现,成功出现我们的信息了!

    二、在src/main/java目录下编写XML

    2.1  目录结构

    TIp:在java下的mapeer目录中建立存放我们的xml配置的目录xml包

    1.2   编写实体类对应的Mapper接口

    package com.yixin.mapper;
    
    import com.yixin.pojo.User;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    /**
     * <p>
     *  Mapper 接口
     * </p>
     *
     * @author yixin
     * @since 2022-01-17
     */
    @Repository
    public interface UserMapper extends BaseMapper<User> {
    
        public List<User> getAll();
    
    }
    

    1.3   编写UserMapper.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.yixin.mapper.UserMapper">
    
        <select id="getAll" resultType="com.yixin.pojo.User">
            select * from user
        </select>
    
    </mapper>
    

    1.4   编写配置文件

    application.properties:

    mybatis-plus.mapper-locations=classpath:com/yixin/mapper/xml/UserMapper.xml

    1.5  🔥 配置pom.xml(重要)🔥

    这一步非常重要,因为如果没有配置pom.xml就去运行,那么会出现以下的错误

    为什么呢?

    这是因为在maven默认情况下是不会将src/main/java目录的xml等资源打包进入class文件夹的,而是直接忽略掉。不信的话我们去看一下target目录。

    可以发现这里并没有将我们的xml文件打包进去

    解决方案配置pom.xml

    我们只需在pom中加入如下配置,告诉idea,在编译的时候将src/main/java下的xml一起打包进class文件夹中,这样也就不会报异常了。

    <build>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                </resource>
            </resources>
        </build>
    

    1.6  测试

    import org.springframework.boot.test.context.SpringBootTest;
    
    import java.io.InputStream;
    import java.util.ArrayList;
    import java.util.List;
    
    @SpringBootTest
    class AutoApplicationTests {
    
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        void test() {
    
            List<User> userList=userMapper.getAll();
            System.out.println(userList);
        }
    }

    结果:

    可以发现成功出现我们的数据库信息了!

    我们再去查看以下target目录

    可以发现,已经把我们的xml配置导进来了,如果发现还是没有的话,建议把target目录删除,然后重新运行,就可以重新生成target目录了,这时候就能发现你的xml文件了。

    三、classpath和classpath*的区别


    classpath:只会在你的class路径下寻找
    classpath*:不仅包含class路径,还包括jar文件中(class路径)进行查找

    一般来说,在大型公司的项目开发中都会需要用到classpath*进行文件配置,因为通常会用到第三方的jar,所以大多情况下会需要查找这些jar的配置文件。


    小结

    以上就是【一心同学】对在MyBatis-Plus中【自定义SQL】的步骤和注意事项的讲解,【自定义SQL】可以帮助我们在MyBatis-Plus的基础上去编写我们自己的SQL语句,让我们的开发变得【十分高效】。

    如果这篇【文章】有帮助到你,希望可以给【一心同学】点个👍,创作不易,相比官方的陈述,我更喜欢用【通俗易懂】的文笔去讲解每一个知识点,如果有对【后端技术】感兴趣的小可爱,也欢迎关注❤️❤️❤️ 【一心同学】❤️❤️❤️,我将会给你带来巨大的【收获与惊喜】💕💕!

    展开全文
  • MybatisPlus自定义sql分页查询

    千次阅读 2022-03-02 15:03:55
    mybatisplus 自定义sql分页查询
  • Mybatis自定义Sql

    千次阅读 2019-08-22 11:57:52
    * 用于复杂sql查询提供sql拼接 * * @param * @return */ public String canAutoCreateSourceDetailList ( WarehouseTransferRuleConfig warehouseTransferRuleConfig , String deviceTypeCodeById , ...
  • 说明 在使用JPA实现数据持久化过程中经常会遇到这种情况:我有2张表是一对多的关系,需要通过一个外键ID去关联查询到另外...这里主要借助JPA提供的@Query自定义查询语句。在查询之前需要先定义几个模型类。 商品表模型
  • JPA 自定义sql语句

    2022-04-22 11:00:52
    1.什么是JPA JPA是Java Persistence API的简称,中文名Java持久层API,是JDK 5.0注解或XML描述对象关系表的映射关系,并将运行期的实体[对象持久化]到... *复杂JPA操作 使用@Query()自定义sql语句 根据业务id UId去更新整
  • 本文实例讲述了Django框架orM与自定义SQL语句混合事务控制操作。分享给大家供大家参考,具体如下: 用单纯的ORM 或者单纯的自定义SQL语句,都比较好控制事务。在前面的一篇文章中已经讲过Django事务小结 ,但里面没有...
  • MyBatis-Plus_自定义sql

    2022-04-06 13:55:46
    查询专栏:自定义查询sql 文章目录 1. 在mapper接口中定义接口 2. 在xml文件中书写sql 3. 全局配置 3.1 配置xml的位置 3.2 配置实体类的位置 4. 在实体类中测试 ... //自定义sql 无分页 Li.
  • (三)mybatisPlus自定义Sql语句

    千次阅读 2021-11-08 14:33:44
    mybatisPlus自定义Sql语句 ???? Java学习路线:搬砖工的Java学习路线 ???? 作者:程序员小王 ???? 程序员小王的博客:https://www.wolai.com/wnaghengjie/ahNwvAUPG2Hb1Sy7Z8waaF ???? 扫描主页左侧二维码,加我微信...
  • 高级需求,还可以方便自定义SQL语句。 自定义sql方式操作数据库及其多表查询 1. 为什么需要自定义SQL 软件开发中,对数据库的访问操作,约80%的工作可以由简单的面向对象操作方式完成,只有约20%的工作才需要复杂...
  • 在写自己的开发框架时,需要用到特殊的sql语句,使用默认的generatorConfig.xml文件配置,无法实现,我们可以自己定义一个generator插件 一、先新建一个项目,作为插件项目 首先引入依赖: <?xml version=...
  • 如何快速实现自定义sql分页?若不会,我便手把手教你!
  • mybaties plus 的 orderBy方式是支持sql的,从它的查询条件要传数据库字段我就猜到了 QueryWrapper<MapResources> wrapper = new QueryWrapper<>(); wrapper.orderByAsc("replace(split_part(area_...
  • Mybatis执行自定义sql

    千次阅读 2019-07-08 09:27:03
    SSM框架中,实体层-Mapper(Dao)层-severice层-controller层...所以怎样在原先系统的框架衍生出灵活的数据库操作,该怎么写在mapper里面反射出来,这个自定义sql并没有和任何实体字段完全一样,所以无法用实体接收当...
  • MyBatis-Plus 使用wrapper自定义SQL
  • MyBatis-Plus 之自定义sql

    千次阅读 2020-10-11 10:43:44
    MyBatis-Plus 之自定义sql 首先创建一个数据库表,如下图所示: 然后创建一个Spring Boot项目,pom.xml和配置如下: <?xml version="1.0" encoding="UTF-8"?> <project xmlns=...
  • 基于jquery js自定义sql条件查询

    热门讨论 2013-09-04 10:00:02
    用户自己定义动态组织sql查询条件,对于用户来说相当方便的啦。可以自由选择查询字段、条件条件、条件值,选择与或关系,包括括号优先的使用。根据查询字段不同,查询条件值的动态改变,如日期控件、下拉框、可输入...
  • 本文介绍了在mybatis-plus中如何实现:自定义SQL语句,多表查询语句,多表分页查询语句 在说怎么实现之前我们要先明白一个概念,就是mybatis-plus是在mybatis的基础上进行增强,并不做改变,所以mybatis的操作在...
  • 使用 Wrapper 自定义SQL

    千次阅读 2021-04-06 17:28:20
    MyBatis-Plus支持使用 Wrapper 自定义SQL, 但是官方文档描述简陋, 本文将结合实例做一个扩展补充. 自定义SQL一般用于解决多表联合查询问题, 与使用视图查询, 使用动态SQL查询相比各有优劣, 可根据实际需要做选择 用...
  • 本文说明如何使用Mybatis执行我自定义输入的SQL语句。 需要的mybaits文件包括:配置文件(mybatis-config-dao.xml 和 jdbc.properties)、接口文件(ISqlMapper.class)、xml文件 (sqlMapper.xml)、工具类...
  • Mybatis-Plus注解自定义sql分页查询 @Select("select * from t_ ${ew.customSqlSegment}") IPage<Map<String,String>> getList(IPage<Map<String,String>> page, @Param(Constants.WRAPPER)...
  • .Net core中对dataTable不像.net ...所以这里需要自己去对于dataTable处理(也是在.Net core中执行自定义sql的核心) public class EfService : IEfService { public IConfiguration _Configuration; public s...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 444,544
精华内容 177,817
关键字:

自定义SQL