精华内容
下载资源
问答
  • tkmybatis.rar

    2020-08-20 14:43:12
    Springboot整合TkMybatis,效果跟mybatis-plus一致, 省掉CRUD的代码编写,让我们一起优雅。
  • 零、前言 本文提到的内容,都只是最基础的应用,个人学习的同时,记录下来,忘记之后还可查看此文档快速回忆。 参看: ...文章目录零、前言一、Mybatis1....注意的点二、tkmybatis1.SpringBoot整合tkmybatis1.1 tkmybati

    零、前言

    本文提到的内容,都只是最基础的应用,个人学习的同时,记录下来,忘记之后还可查看此文档快速回忆。

    参看:

    • Mybatis:https://mybatis.org/mybatis-3/zh/getting-started.html
    • Mybatis plus:https://mp.baomidou.com

    环境:
    JDK1.8+,MAVEN,IDEA,internet,… …


    在SpringBoot中,使用各种持久层工具都非常的方便,这是基于它的 自动装配原理 而实现。

    SpringBoot中实现持久化的步骤

    在这里插入图片描述

    先约定一下SQL,之后所有的操作都是基于此SQL执行后的表:

    DROP TABLE IF EXISTS `user_db`;
    CREATE TABLE `user_db` (
      `id` int(4) NOT NULL AUTO_INCREMENT,
      `username` varchar(32) NOT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1;
    
    INSERT INTO `user_db`(id,username) values
    (1,'张三'),
    (2,'李四'),
    (3,'王二'),
    (4,'麻子'),
    (5,'王三'),
    (6,'李三');
    

    一、Mybatis

    配置文件都使用YAML文件。并且Mybatus的是很多公司都在用的框架,虽然需要配置XML文件的CURD。

    1.SpringBoot整合Mybatis

    目录结构图(提供此图后,对应的文件应该放在对应的包目录下,可千万别放错了哟~)

    在这里插入图片描述

    SpringBoot官方并没有提供Mybatis的启动器,所以得引入启动器:

    如果连接数据库,当然还得引入MySQL的依赖。

    <!--mybatis -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>
    

    之后就是在application.yml配置文件中编写简单的配置即可

    server:
      port: 8080
    
    spring:
      # 标注项目现在环境 dev-开发 test-测试 pro-上线
      profiles:
        active: dev
      # 配置数据源
      datasource:
        username: root
        password:
        url: jdbc:mysql://localhost:3306/test # 我的库是test
    
    #mybatis配置
    mybatis:
      type-aliases-package: com.pdh.entity
      mapper-locations: classpath:/mybatis/*.xml # mapper位置,默认扫描这里
    

    之后就是创建实体类User

    实体类需要与数据表对应,如果有不对应的字段,需要在mybatis.xml文件中指定表示出来。(映射文件是mybatis.xml)

    public class User {
        private int id;
        private String username;
        // 生成getter,setter,构造等方法
    }
    

    编写Mapper接口,并加入一个方法find()方法

    可以加上@Mapper注解加载Mpper类,但是能够直接在启动类上加@MapperScan(“com.pdh.mapper”)注解扫描指定的包,后者更加简约。

    public interface UserMapper {
    
        /**
         * 查询
         * @param user  condition
         * @return
         */
        public List<User> find(User user);
    
    }
    
    

    编写映射文件UserMapper.xml

    还可使用注解直接注入到Mapper类中对应的方法上,但是并不灵活,这种方式就低耦合一些,还可以实现动态SQL

    <?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.pdh.mapper.UserMapper">
    
        <!--resultMap用于映射数据库中的熟悉于实体类中的属性对应-->
        <resultMap id="BaseResultMap" type="com.pdh.entity.User">
            <result column="id" jdbcType="INTEGER" property="id" />
            <result column="username" jdbcType="VARCHAR" property="username" />
            <!--假设实体类中的username对应数据库中的name,那么就需要添加
                <result column="name" jdbcType="VARCHAR" property="username" />
            -->
        </resultMap>
    
        <select id="find" resultType="com.pdh.entity.User" resultMap="BaseResultMap">
            SELECT * FROM user_db
        </select>
    
    </mapper>
    

    此时,各项正常的话就会出现一个 绿色的箭头mybatis.xml里的sql和UserMapper里的方法对应

    要在启动类上加上注解:@MapperScan(“com.pdh.mapper”)

    之后引入Springboot的测试依赖(有就不用引入)

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    

    测试:在UserMapper类下按快捷键 Alt+Insert 选择新建Test,JUnit4,之后测试类上加上@RunWith(SpringRunner.class)和@SpringBootTest 两个注解:

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest {
    
        @Autowired
        private UserMapper mapper;
    
        @Test
        void findAll() {
            List<User> list = mapper.find(new User());
            list.forEach(System.out::println); // User类加上toString()方法这里才能看见数据
        }
    }
    

    结果:

    User{id=1, username=‘张三’}
    User{id=2, username=‘李四’}
    User{id=3, username=‘王二’}
    User{id=4, username=‘麻子’}
    User{id=5, username=‘王三’}
    User{id=6, username=‘李三’}

    测试成功,之后就可以按照步骤搭建Service,Controller了这些模块。


    2.动态SQL

    在SpringBoot整个Mybatis能运行起来之后,实现动态SQL要怎么做?那你可看好了

    前面我们的UserMapper接口中的find()方法需要传入一个User类,就是为了实现动态SQL。实现动态SQL的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.pdh.mapper.UserMapper">
    
        <!--resultMap用于映射数据库中的熟悉于实体类中的属性对应-->
        <resultMap id="BaseResultMap" type="com.pdh.entity.User">
            <result column="id" jdbcType="INTEGER" property="id" />
            <result column="username" jdbcType="VARCHAR" property="username" />
            <!--假设实体类中的username对应数据库中的name,那么就需要添加
                <result column="name" jdbcType="VARCHAR" property="username" />
            -->
        </resultMap>
    
        <sql id="selectSql">
            SELECT
                *
            FROM
                user_db
        </sql>
    
        <select id="find" resultType="com.pdh.entity.User" resultMap="BaseResultMap">
            <include refid="selectSql"/>
            <where>
                <!-- 下面这种写法不能达到需要的效果,id默认为0 而数据表中没有id=0的数据
                    <if test="id != null">
                        id = #{id}
                    </if>
                -->
                <if test="username != null">
                    username like '%${username}%'
                </if>
            </where>
        </select>
    </mapper>
    

    当我们在UserMapper中在此调用find()方法时,在传递的User类中,传递对应的参数即可实现条件查询,不传递参数就查询全部。

    测试:

    @Test
    public void findCondition() {
        //条件查询 username中有 ‘三’ 的
        mapper.find(new User("三")).forEach(System.out::println);
    }
    

    测试结果

    User{id=1, username=‘张三’}
    User{id=5, username=‘王三’}
    User{id=6, username=‘李三’}

    Mybatis动态sql可以让我们在Xml映射文件内,以标签的形式编写动态sql,完成逻辑判断和动态拼接sql的功能,Mybatis提供了9种动态sql标签 trim|where|set|foreach|if|choose|when|otherwise|bind


    3.注意的点

    1. 手写sql,且手写的SQL必须正确。
    2. 实体类的字段可以由mybatis.xml文件配置与数据库字段对应。
    3. 在启动类上加注解@MapperScan(“com.pdh.mapper”)。

    二、tkmybatis

    在使用Mybatis的时候要编写大量简单的SQL语句在XML文档中,且数据表结构更改时间,对应的SQL以及实体类都需要更改,对开发人员非常的不友好。为了减轻开发人员的负担,就出现了tkmybatis(通用mybatis)和mybatis plus。

    通用Mapper解决了单表增删改查,基于Mybatis的插件。开发人员不需要编写SQL,不需要在DAO中增加方法,只要写好实体类,就能支持相应的增删改查方法。

    1.SpringBoot整合tkmybatis

    还是创建一个含mysql启动器的SpringBoot项目,再开始之后的整合操作。

    1.1 tkmybatis启动器

    引入通用mapper之后,就不需要再手动引入mybaits,通用mapper里面已经包含了mybatis的依赖

    <!-- 通用mapper -->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.0.3</version>
    </dependency>
    

    之后就是在application.yml配置文件中编写简单的配置即可

    server:
      port: 8080
    
    spring:
      # 标注项目现在环境 dev-开发 test-测试 pro-上线
      profiles:
        active: dev
      # 配置数据源
      datasource:
        username: root
        password:
        url: jdbc:mysql://localhost:3306/test # 我的库是test
    
    #mybatis配置
    mybatis:
      type-aliases-package: com.pdh.entity
      mapper-locations: classpath:/mybatis/*.xml # mapper位置,默认扫描这里
    

    之后就是创建实体类User

    1.2 实体类

    实体类与数据库表对应策略:

    tkmybatis注解使用JPA注解,这里针对@GeneratedValue注解会简单提及到用法

    1. 默认表名=类名,字段名=属性名(支持下划线转驼峰

    2. @Table(name = "tableName") 指定表名

    3. @Column(name = "fieldName") 指定属性名

    4. @Transient表示此字段不进行映射

    5. @Id标注主键

    6. @GeneratedValue指定主键策略

      @GeneratedValue(strategy = GenerationType.IDENTITY)注解中,GenerationType是枚举类,它有四种类型(以及解释):

      1. TABLE:使用一个特定的数据库表格来保存主键。
      2. SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。
      3. IDENTITY:主键由数据库自动生成(主要是自动增长型)
      4. AUTO(默认):主键由程序控制。

    还是使用上面约定的数据表进行实体类的创建

    @Table(name = "user_db")
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键策略使用IDENTITY
        private int id;
    
        @Column(name = "username")
        private String username;
        
        // 生成getter,setter,构造等方法
    }
    

    1.3 Mapper接口

    在启动类上添加Mapper扫描@MapperScan("com.pdh.mapper")注解的时候,添加的应该是tk.mybatis的MapperScan。不要误添加mybatis的MapperScan。会出现Error invoking SqlProvider method。

    一旦继承了Mapper,继承的Mapper就拥有了Mapper所有的通用方法:

    public interface UserMapper extends Mapper<User> {
        // Mapper接口继承Mapper后,可以调用它的诸多方法
    }
    

    Mapper方法一览:

    在这里插入图片描述

    之后就不编写任何映射文件,就能进行使用,但是针对于复杂的SQL还是需要开发人员自行实现的。

    这里就直接先不添加映射文件,直接先进行一次接口测试:

    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest {
    
        @Resource
        private UserMapper mapper;
    
        @Test
        public void findAll() {
            mapper.selectAll().forEach(System.out::println);
        }
    
        @Test
        public void findById(){
            // 查询id=2的数据(只有一个约束)
            User user = mapper.selectByPrimaryKey(2);
            System.out.println(user.toString());
        }
    
        @Test
        public void findDynamic(){
            // 动态查询 字段有数据就加入条件,没有就不加入条件
            mapper.select(new User("张三")).forEach(System.out::println);
        }
    
        @Test
        public void findByExample() {
            // 测试一下这种操作 实现reg查询
            Example example = new Example(User.class);
            // example.createCriteria() 有诸多条件实现,这里暂且使用and like条件
            // 可实现链式添加条件
            example.createCriteria().andLike("username","%三%");
            mapper.selectByExample(example).forEach(System.out::println);
        }
    }
    

    findAll()得到的结果是:

    User{id=1, username=‘张三’}
    User{id=2, username=‘李四’}
    User{id=3, username=‘王二’}
    User{id=4, username=‘麻子’}
    User{id=5, username=‘王三’}
    User{id=6, username=‘李三’}

    findById()得到的结果是:

    User{id=2, username=‘李四’}

    … …


    2.自定义映射文件

    可选,不定义也能使用Mapper提供的方法。如果有复杂的SQL需求,就必须自定义。这里我添加一个动态的条件查询SQL。注意,简单的动态SQL,Mapper里面有对于的select方法就能实现,但是我不满足于此,我要实现的是 动态SQL+查询username中带有我指定的字符 的数据,这样的SQL相对复杂些,如果直接使用Mapper的方法的话,使用selectByExample()也可以实现,但是非常的麻烦,使用XML配置文件就简单很多:

    映射复杂方法 resources/mappers/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.pdh.mapper.UserMapper">
    
        <sql id="selectSql">
            SELECT
                *
            FROM
                user_db
        </sql>
    
        <select id="find" resultType="com.pdh.entity.User">
            <include refid="selectSql"/>
            <where>
                <if test="username != null">
                    username like '%${username}%'
                </if>
            </where>
        </select>
    
    
    </mapper>
    

    之后,需要在UserMapper接口中添加此方法find()(此方法必须与xml映射文件中的对应上)

    /**
         * 条件查询
         * @param user  condition
         * @return
         */
    public List<User> find(User user);
    

    测试

    @Test
    public void find(){
        // 查找username中含有`四`的数据
      	mapper.find(new User("四")).forEach(System.out::println);
    }
    

    结果

    User{id=2, username=‘李四’}


    3.注意的点

    1. 实体类的编写需要遵守tkmybatis的规定,合理使用注解。
    2. Mapper类需要继承Mapper<T>接口,之后可只有Mapper<T>接口提供的诸多方法。
    3. 扩展方法,编写复杂需要在UserMapper.xml映射文件中编写好对于的SQL逻辑。
    4. 在启动类上加tkmybatis的MapperScan注解。
    5. tkmybatis自动下划线转驼峰(如数据库属性user_id对于Java代码的userId字段)。

    三、mybatis plus

    官方使用的是H2数据库进行演示,我这里提供了H2数据库

    Mybatis-Plus(简称MP)是一个 Mybatis 的增强工具,在 Mybatis 的基础上只做增强不做改变,为简化开发、提高效率而生。

    1.SpringBoot整合mp

    与整合tkmybatis步骤一样,不同的点是 依赖、继承BaseMapper<T>,mapper对应的方法名不同。

    创建一个含mysql启动器的SpringBoot项目,再开始之后的整合操作。

    1. mp启动器

      <!--mybatis plus 间接引入mybatis-->
      <dependency>
          <groupId>com.baomidou</groupId>
          <artifactId>mybatis-plus-boot-starter</artifactId>
          <version>3.3.2</version> <!--版本根据需求选择-->
      </dependency>
      
    2. application.yml编写配置文件(数据库,端口号,mapper映射文件,… …),诸多配置信息还可由xml文件进行配置。

    3. 创建实体类User,在创建实体类的时候,也与tkmybatis有类是的注解(下面是常见注解):

      • @TableName():表名注解,value指定表名。
      • @TableId():主键注解,value绑定主键字段名。
      • @TableField():字段注解(非主键),value指定数据库字段名,数据表中不存在的字段使用@TableField(exist = false)修饰。
    4. 编写Mapper接口。是继承BaseMapper<T>,再添加对应的自定义方法。

    5. 有需要就编写Mapper.xml映射文件,绑定自定义方法的SQL。

    6. 编写测试类,进行测试即可(具体的方法API移步官网)。


    2.注意的点

    1. 实体类的编写需要遵守mybatis plus的规定,合理使用注解。
    2. Mapper类需要继承BaseMapper<T>接口。
    3. 扩展方法,编写复杂需要在UserMapper.xml映射文件中编写好对于的SQL逻辑。
    4. 在启动类上加mybatis plus的MapperScan注解。
    5. mybatis plus自动下划线转驼峰。
    6. mybatis plus功能非常的强大,熟练使用会成为开发利器。

    3.更多功能

    Mybatis-PlusMybatis的增强工具包,Mybatis Plus具有的功能有:

    1. 通用的CURD
    2. 代码生成器(真香)
    3. 条件构造器
    4. 自定义SQL语句
    5. 分页插件、性能分析插件、全局拦截插件等。
    6. 公共字段自动填充。

    在之后的学习中,我会总结一下mybatis-plus的这些外挂式的功能,多多益善!


    四、结语

    SpringBoot持久层操作有很多方式,就目前而言,mybatis plus是使用最多的,自己手里面的项目到底适合那一种,当然的根据自己项目的情况来决定采用谁。关于mp和tkmybatis比较:点击我跳转

    展开全文
  • Tkmybatis是基于Mybatis框架开发的一个工具,通过调用它提供的方法实现对单表的数据操作,不需要写任何sql语句,这极大地提高了项目开发效率。 代码说明 tk-mybatis为spring boot集成的tkmybatis ,在配置好文件后,...
  • TkMybatis通用Mapper逆向工程代码生成工具,Maven项目工具;
  • springboot+tkmybatis+gradle环境搭建,测试代码在Test类中
  • 前面我们讲了SpringBoot集成Mybatis及 SpringBoot 与 Mybatis的逆向工程,可以使的我们编译程序更加的简单,今天主要讲解下 SpringBoot 与 TkMybatis 的集成 SpringBoot 单单集成Mybatis 需要我们编写大量的Sql语句...

    前面我们讲了SpringBoot集成Mybatis及 SpringBoot 与 Mybatis的逆向工程,可以使的我们编译程序更加的简单,今天主要讲解下 SpringBoot 与 TkMybatis 的集成
    SpringBoot 单单集成Mybatis 需要我们编写大量的Sql语句,我们可以通过MyBatis的逆向工程生成大量的实体类及mapper文件进行服务开发,TkMybatis 可以让我们更加简单的实现数据的持久化,而不需要编写大量的SQL语句,TkMybatis已经继承了常用的mapper接口提供给我们是使用。当然如果TkMaytis不能满足我们的要求,我们也可以配置mapper xml文件实现我们自己的接口实现。
    下面就来讲一讲 TkMybatis 的集成步骤。
     1. 数据库配置信息及构建表数据
     2. 创建SpringBoot工程
     3. 配置pom.xml文件
     4. 配置application.yml 文件
     5. 新建Entity实体类(可以通过Mymatis逆向工程构建)
     6. 新建Mapper基础接口类
     7. 新建实体对应的Mapper接口类
     8. 新建Service接口
     9. 新建RestControler接口(也可以通过Test进行测试)
     10. 启动测试
     
    1. 数据库配置信息及构建表数据

    mysql://10.10.34.28:3306/gaea  root/123456
        
    SET NAMES utf8mb4;
    SET FOREIGN_KEY_CHECKS = 0;
     
    -- ----------------------------
    -- Table structure for user
    -- ----------------------------
    DROP TABLE IF EXISTS `user`;
    CREATE TABLE `user`  (
    `id` int(32) NOT NULL AUTO_INCREMENT,
    `userName` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
    `passWord` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
    `realName` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
    PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
     
    SET FOREIGN_KEY_CHECKS = 1;

    2. 创建SpringBoot工程
    通过IDEA创建Spring Boot工程,选择Web,DevOpt,MySql,JDBC,MyBatis,lombok 等模块,本工程需要使用swagger插件,增加swagger配置文件及pom.xml 依赖文件,关于swagger的配置,前面有专门章节介绍,请出门左拐,这里不作过多解释。

      配置代码结构:
        在Applicaiton同级目录下新建 config,entity,mapper,rest,service 包(package)
        在Resouces 目录下建 mapper目录

    3. 配置pom.xml文件

    <dependency>
          <groupId>tk.mybatis</groupId>
          <artifactId>mapper</artifactId>
          <version>${tk.mybatis.mapper.version}</version>
        </dependency>
        <dependency>
          <groupId>tk.mybatis</groupId>
          <artifactId>mapper-spring-boot-starter</artifactId>
          <version>${tk.mybatis.version}</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis.spring.boot</groupId>
          <artifactId>mybatis-spring-boot-starter</artifactId>
          <version>1.3.2</version>
        </dependency>
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
          <groupId>com.zaxxer</groupId>
          <artifactId>HikariCP</artifactId>
        </dependency>

    注意:此处必须包含mybatis,tkmybatis,mysql-connector 等jar包

    4. 配置application.yml 文件

    server:
      port: 8080
    
    spring:
      datasource:
        username: root
        password: 123456
        type: com.zaxxer.hikari.HikariDataSource
        url: jdbc:mysql://10.1.3.38:3306/datagaea?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&autoReconnect=true&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
        driver-class-name: com.mysql.cj.jdbc.Driver
        hikari:
          # 连接只读数据库时配置为true, 保证安全
          readOnly: false
          # 测试连接的有效性
          connection-test-query: select 1 from dual
          # 连接池名称
          pool-name: springHikariCP
          # 一个连接idle状态的最大时长(毫秒),超时则被释放(retired),缺省:10分钟
          idleTimeout: 600000
          # 一个连接的生命时长(毫秒),超时而且没被使用则被释放(retired),缺省:30分钟,建议设置比数据库超时时长少30秒,参考MySQL wait_timeout参数(show variables like '%timeout%';)
          maxLifetime: 1800000
          # 连接池中允许的最大连接数,缺省值:10;推荐的公式:((core_count * 2) + effective_spindle_count)
          maximumPoolSize: 12
          # 空闲时保持的最小连接数
          minimumIdle: 4
    
    mybatis:
      mapper-locations: classpath*:mapper/*.xml

    注意:1. 此处需要注意mybatis.mapper-locations 的配置路径

                2. 还需要注意 datasource.type,url,user,password,driver-class-name

    5. 新建Entity实体类(可以通过Mymatis逆向工程构建)

    import java.io.Serializable;
    import javax.persistence.Column;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import lombok.Data;
    @Data
    @Table(name = "user_info")
    public class User implements Serializable {
    
      @Id
      private long id;
      @Column(name = "name")
      private String name;
      @Column(name = "sex")
      private String sex;
      @Column(name = "age")
      private int age;
    
    
    }

    注意:此处必须指明@Table,@Id,@Column ,否则数据库不知道字段的对应关系

    6. 新建Mapper基础接口类

    import tk.mybatis.mapper.common.Mapper;
    
    public interface BaseMapper<T> extends Mapper<T> {
    
    }
    

    注意:此处集成Mapper继承的接口为  tk.mybatis.mapper.common.Mapper;

    7. 新建实体对应的Mapper接口类

    import com.tudou.datagaeatkbatis.BaseMapper;
    import com.tudou.datagaeatkbatis.entity.User;
    import org.apache.ibatis.annotations.Mapper;
    
    @Mapper
    public interface UserMapper extends BaseMapper<User> {
    
    }
    

    注意:此处@Mapper 注解的接口为 import org.apache.ibatis.annotations.Mapper, 和上面的 tk.mybatis.mapper.common.Mapper 不一样

    7.1 新建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.tudou.datagaeatkbatis.entity.User">
    </mapper>
    

    注意:此处namespace 必须对应到 entity的实体user类应用路径

    8. 新建BaseService接口

    import com.tudou.datagaeatkbatis.entity.User;
    import java.util.List;
    
    public interface BaseUserService {
    
      List<User> selectByEntity(User customer);
    
      int insertSelective(User customer);
    
      int updateSelectiveById(User record);
    }

    9. 新建UserBaseService接口

    
    import com.tudou.datagaeatkbatis.entity.User;
    import com.tudou.datagaeatkbatis.mapper.UserMapper;
    import com.tudou.datagaeatkbatis.repo.BaseUserService;
    import java.util.List;
    import java.util.Objects;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    import tk.mybatis.mapper.entity.Example;
    import tk.mybatis.mapper.entity.Example.Criteria;
    
    @Service
    @Transactional
    public class BaseUserServiceImpl implements BaseUserService {
    
      @Autowired
      private UserMapper customerMapper;
    
      @Override
      public List<User> selectByEntity(User customer) {
        if(Objects.isNull(customer)) {
          customer = new User();
        }
        Example example = new Example(User.class);
        Criteria criteria = example.createCriteria();
        criteria.andEqualTo(customer);
        return customerMapper.selectByExample(example);
      }
    
      @Override
      public int insertSelective(User customer) {
        return customerMapper.insertSelective(customer);
      }
    
      @Override
      public int updateSelectiveById(User record) {
        return customerMapper.updateByPrimaryKeySelective(record);
      }
    }

    注意:此处@Service, @Autowired 注解

    9. 新建RestControler接口(也可以通过Test进行测试),此处通过Test进行测试

    import com.tudou.datagaeatkbatis.entity.User;
    import com.tudou.datagaeatkbatis.repo.BaseUserService;
    import java.util.List;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class DatagaeatkbatisApplicationTests {
    
      @Autowired
      private BaseUserService userRoleService;
    
      @Test
      void contextLoads() {
        User userRole = new User();
        int icount = userRoleService.insertSelective(userRole);
      }
    
    }
    

    注意:此处 @Autowired,@Test注解

    10. 启动测试

     

    到此为止,通过以上10步即可完成TKMybatis 的集成工作并且完成测试

     

    展开全文
  • tkmybatis是在mybatis框架的基础上提供了很多工具,让开发更加高效,下面来看看这个框架的基本使用,后面会对相关源码进行分析,感兴趣的同学可以看一下,挺不错的一个工具实现对员工表的增删改查的代码 java的dao层...

    tkmybatis是在mybatis框架的基础上提供了很多工具,让开发更加高效,下面来看看这个框架的基本使用,后面会对相关源码进行分析,感兴趣的同学可以看一下,挺不错的一个工具

    实现对员工表的增删改查的代码
    java的dao层接口

    public interface WorkerMapper extends Mapper<Worker> {
    }
    • 1
    • 2

    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.jjs.kaiwen.dao.WorkerMapper">
      <resultMap id="BaseResultMap" type="com.jjs.kaiwen.model.Worker">
        <!--
          WARNING - @mbggenerated
        -->
        <id column="id" jdbcType="INTEGER" property="id" />
        <result column="worker_id" jdbcType="VARCHAR" property="workerId" />
        <result column="name" jdbcType="VARCHAR" property="name" />
        <result column="org_id" jdbcType="INTEGER" property="orgId" />
        <result column="status" jdbcType="VARCHAR" property="status" />
        <result column="role_id" property="roleId" jdbcType="INTEGER" />
      </resultMap>
    </mapper>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    实体对象

    @Table(name = "worker")
    public class Worker {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Integer id;
    
        @Column(name = "worker_id")
        private String workerId;
    
        private String name;
    
        @Column(name = "org_id")
        private Integer orgId;
    
        private String status;
    
        @Column(name = "role_id")
        private Integer roleId;
    
        // getters and setters ...
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    以上就是实现对Worker进行增删改查的所有代码,包括选择性更新、插入、删除等,所有的方法列表如下

    这里写图片描述

    以后对表字段的添加或修改只需要更改实体对象的注解,不需要修改xml映射文件,如将worker_id改成worker_no

    @Column(name = "worker_no")
    private String workerNo;
    • 1
    • 2

    数据源的配置,只需要将org.mybatis.spring.mapper.MapperScannerConfigurer改成tk.mybatis.spring.mapper.MapperScannerConfigurer,然后加一个属性
    ,也可不加,因为框架提供了默认实现

        <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
            <property name="basePackage" value="com.jjs.zanbi.dao" />
            <property name="properties">
                <value>
                    mappers=tk.mybatis.mapper.common.Mapper
                </value>
            </property>
        </bean>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    用这个库之后写代码感觉在飞…….如果只是简单的了解此框架到这里就可以了,下面是对框架实现原理的分析

    原理的简单分析

    此框架为我们实现这些功能所有的改动都在Mapper层面,所有的Mapper都继承了tk.mybatis.mapper.common.Mapper

    public interface WorkerMapper extends Mapper<Worker> {}
    • 1

    Mapper接口的声明如下,可以看到Mapper接口实现了所有常用的方法

    public interface Mapper<T> extends
            BaseMapper<T>,
            ExampleMapper<T>,
            RowBoundsMapper<T>,
            Marker {
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    看一下完整的UML图,太大了,可以用新窗口打开,放大之后再看
    这里写图片描述

    这里选择一个接口:SelectOneMapper接口,对于源码进行简单分析,此接口声明如下:

    public interface SelectOneMapper<T> {
    
        /**
         * 根据实体中的属性进行查询,只能有一个返回值,有多个结果是抛出异常,查询条件使用等号
         *
         * @param record
         * @return
         */
        @SelectProvider(type = BaseSelectProvider.class, method = "dynamicSQL")
        T selectOne(T record);
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    @SelectProvider是mybatis3之后提供的,用于灵活的设置sql来源,这里设置了服务提供类和方法,但这个库并没有直接用method指定的方法来返回sql,而是在运行时进行解析的,代码如下

    public class BaseSelectProvider extends MapperTemplate {
    
        public String selectOne(MappedStatement ms) {
            Class<?> entityClass = getEntityClass(ms);
            //修改返回值类型为实体类型
            setResultType(ms, entityClass);
            StringBuilder sql = new StringBuilder();
            sql.append(SqlHelper.selectAllColumns(entityClass));
            sql.append(SqlHelper.fromTable(entityClass, tableName(entityClass)));
            sql.append(SqlHelper.whereAllIfColumns(entityClass, isNotEmpty()));
            return sql.toString();
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    到这里我们就大概知道了这个库为我们提供便利的原理了,总的来说就是这个库帮我们提供了对表的基本操作的sql,帮我们省了很多工作量,而且维护起来也很方便,否则我们的xml文件动不动就几百行甚至上千行

    对源码的探索不能到这里停止,最起码要分析到与另一个框架的整合点

    我们知道,mybatis的mapper接口是在启动的时候被框架以JdkProxy的形式封装了的,具体对应的类是MapperFactoryBean,这个类中有一个checkDaoConfig()方法,是从父类继承并重写了该方法,继承结构如下

    MapperFactoryBean -> SqlSessionDaoSupport -> DaoSupport
    • 1

    这里的DaoSupport就是spring提供的Dao的抽象,代码如下

    public abstract class DaoSupport implements InitializingBean {
    
    // spring 完成属性设置后会调用此方法
        @Override
        public final void afterPropertiesSet() throws IllegalArgumentException, BeanInitializationException {
            // 这里提供了接口供子类去实现
            checkDaoConfig();
    
            // Let concrete implementations initialize themselves.
            try {
                initDao();
            }
            catch (Exception ex) {
                throw new BeanInitializationException("Initialization of DAO failed", ex);
            }
        }
    
        protected abstract void checkDaoConfig() throws IllegalArgumentException;
    
        protected void initDao() throws Exception {
        }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    框架自定义的MapperFactoryBean重写了checkDaoConfig()方法,完成对所有sql语句的设置,代码如下

        @Override
        protected void checkDaoConfig() {
            super.checkDaoConfig();
            //通用Mapper
            if (mapperHelper.isExtendCommonMapper(getObjectType())) {
            //这里去处理该类所对应的MappedStatement,封装在helper类中处理
                mapperHelper.processConfiguration(getSqlSession().getConfiguration(), getObjectType());
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    MapperHelper的processConfiguration方法如下

        public void processConfiguration(Configuration configuration, Class<?> mapperInterface) {
            String prefix;
            if (mapperInterface != null) {
                prefix = mapperInterface.getCanonicalName();
            } else {
                prefix = "";
            }
            for (Object object : new ArrayList<Object>(configuration.getMappedStatements())) {
                if (object instanceof MappedStatement) {
                    MappedStatement ms = (MappedStatement) object;
                    //检查这个MappedStatement是否属于此映射对象
                    if (ms.getId().startsWith(prefix) && isMapperMethod(ms.getId())) {
                        if (ms.getSqlSource() instanceof ProviderSqlSource) {
                           //去设置该statement的sql语句
                            setSqlSource(ms);
                        }
                    }
                }
            }
        }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    设置sql的逻辑,提供了几种不同类型的sqlsource

        public void setSqlSource(MappedStatement ms) throws Exception {
            if (this.mapperClass == getMapperClass(ms.getId())) {
                throw new RuntimeException("请不要配置或扫描通用Mapper接口类:" + this.mapperClass);
            }
            Method method = methodMap.get(getMethodName(ms));
            try {
                //第一种,直接操作ms,不需要返回值
                if (method.getReturnType() == Void.TYPE) {
                    method.invoke(this, ms);
                }
                //第二种,返回SqlNode
                else if (SqlNode.class.isAssignableFrom(method.getReturnType())) {
                    SqlNode sqlNode = (SqlNode) method.invoke(this, ms);
                    DynamicSqlSource dynamicSqlSource = new DynamicSqlSource(ms.getConfiguration(), sqlNode);
                    setSqlSource(ms, dynamicSqlSource);
                }
                //第三种,返回xml形式的sql字符串
                else if (String.class.equals(method.getReturnType())) {
                    String xmlSql = (String) method.invoke(this, ms);
                    SqlSource sqlSource = createSqlSource(ms, xmlSql);
                    //替换原有的SqlSource
                    setSqlSource(ms, sqlSource);
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    到这里整个sql的获取流程就分析完了,本人用这个库写过一个小项目,确实节省了开发的工作量,而且DAO层的结构更加清晰简洁了

    关于mybatis新特性

    从3.4.0开始,mybatis提供对外部表的alias引用方法,多表联合查询就方便多了,我们先看原始的方式是怎样做的

    select a.id,a.name,b.bid,b.bname .....
    from user a 
    left join room b 
    • 1
    • 2
    • 3

    原始的方式是将所有的表字段列出来,再来看用新特性怎样做

    select id="selectUsers" resultType="map">
      select
        <include refid="user_col_sql_id"><property name="alias" value="t1"/>,
        <include refid="room_col_sql_id"><property name="alias" value="t2"/>
      from user t1
        left join room t2
    </select>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    这里主要就是对基本的sql进行了复用,如果对表进行了修改只要在原始的sql节点修改就可以了,就算是5个表的联合查询,sql也是清晰易懂,维护起来会更轻松

    新版本的mybatis对于对象映射也提供了更友好的方式,直接使用外部的ResultMap再加上查询语句中的别名就映射完成了

        <resultMap id="workerResultMap" type="com.jjs.kaiwen.model.Worker" extends="BaseResultMap">
            <association property="room" columnPrefix="b_"  resultMap="com.jjs.kaiwen.dao.OrgMapper.BaseResultMap"/>
        </resultMap>
    • 1
    • 2
    • 3

    更进一步

    敏锐的程序员可能会提出问题,如当多表查询的时候可能会存在字段名称相同的情况,这里的解决方案是给include添加另一个属性

    <include refid="user_col_sql_id_with_alias">
    <property name="alias" value="t"/>
    <property name="prefix" value="t_"/>
    </include>
    • 1
    • 2
    • 3
    • 4

    包含prefix的sqlNode如下

        <sql id="base_column_with_alias">
            ${alias}.ID as ${prefix}ID,
            ${alias}.WORKER_ID as ${prefix}WORKER_ID,
            ${alias}.NAME as ${prefix}NAME,
            ${alias}.ZB_ROLE_ID as ${prefix}ZB_ROLE_ID,
            ${alias}.ORG_ID as ${prefix}ORG_ID,
            ${alias}.STATUS as ${prefix}STATUS
        </sql>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    如果说觉得手动写包含alias和prefix的字段麻烦,可以用,mybatis代码生成器的插件的方式实现,我自己写了一个生成器的插件,可以代码再这里,仅供参考

    通用Service类

    /**
     * Created by Kaiwen
     */
    @Service
    public abstract class CommonServiceImpl<T,PK extends Serializable> implements CommonService<T,PK> {
        /**
         * 泛型注入
         */
        @Autowired
        private Mapper<T> mapper;
    
        public T selectByPrimaryKey(PK entityId) {
    
            return mapper.selectByPrimaryKey(entityId);
        }
    
        public int deleteByPrimaryKey(PK entityId) {
            return mapper.deleteByPrimaryKey(entityId);
        }
    
        public int insert(T record) {
            return mapper.insert(record);
        }
    
        public int insertSelective(T record) {
            return mapper.insertSelective(record);
        }
    
        public int updateByPrimaryKeySelective(T record) {
            return mapper.updateByPrimaryKeySelective(record);
        }
    
        public int updateByPrimaryKey(T record) {
            return mapper.updateByPrimaryKey(record);
        }
    
        public List<T> selectByExample(Example example) {
            return mapper.selectByExample(example);
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

    注入方式区别

        <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
            <property name="basePackage" value="com.jjshome.esf.core.dao.school" />
            <property name="properties">
                <value>
                    mappers=tk.mybatis.mapper.common.Mapper
                </value>
            </property>
        </bean>
    
    
        <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            <property name="basePackage" value="com.jjshome.esf.core.dao.community,com.jjshome.esf.core.dao.hsl"/>
        </bean>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    实体类

    package com.jjshome.esf.common.entity.school;
    
    import java.util.Date;
    import javax.persistence.*;
    
    @Table(name = "XQ_SCHOOL_AREA")
    public class SchoolArea {
        /**
         * 主键ID
         */
        @Id
        @Column(name = "ID")
        private Integer id;
    
        /**
         * 城市编码
         */
        @Column(name = "CITY_CODE")
        private String cityCode;
    
        /**
         * 学区名称
         */
        @Column(name = "NAME")
        private String name;
    
        /**
         * 学区名称拼音
         */
        @Column(name = "NAME_SPELL")
        private String nameSpell;
    
        /**
         * 状态,1:正常,0:删除
         */
        @Column(name = "STATUS")
        private Byte status;
    
        /**
         * 添加人
         */
        @Column(name = "CREATE_ID")
        private String createId;
    
    
        @Transient
        private Integer primaryCount; //小学数量
        @Transient
        private Integer middleCount; //初中数量
        @Transient
        private Integer highCount;//高中数量
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    TK mybatis Mapper文件内容

    <?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.jjshome.esf.core.dao.school.ISchoolAreaDAO" >
      <resultMap id="BaseResultMap" type="com.jjshome.esf.common.entity.school.SchoolArea" >
        <!--
          WARNING - @mbggenerated
        -->
        <id column="ID" property="id" jdbcType="INTEGER" />
        <result column="CITY_CODE" property="cityCode" jdbcType="VARCHAR" />
        <result column="NAME" property="name" jdbcType="VARCHAR" />
        <result column="NAME_SPELL" property="nameSpell" jdbcType="VARCHAR" />
        <result column="STATUS" property="status" jdbcType="TINYINT" />
        <result column="CREATE_ID" property="createId" jdbcType="VARCHAR" />
        <result column="CREATE_DATE" property="createDate" jdbcType="TIMESTAMP" />
        <result column="UPDATE_ID" property="updateId" jdbcType="VARCHAR" />
        <result column="UPDATE_DATE" property="updateDate" jdbcType="TIMESTAMP" />
        <result column="CITY_NAME" property="cityName"/>
        <result column="PRIMARY_COUNT" property="primaryCount"/>
        <result column="MIDDLE_COUNT" property="middleCount"/>
        <result column="HIGH_COUNT" property="highCount"/>
      </resultMap>
    
        <resultMap id="SchoolDetailArea" type="com.jjshome.esf.common.entity.school.SchoolAreaDetail"
                   extends="com.jjshome.esf.core.dao.school.ISchoolInfoDAO.SchoolInfo">
            <result column="SCHOOL_AREA_NAME" property="schoolAreaName"/>
        </resultMap>
    
        <select id="selectByPage" parameterType="map" resultMap="BaseResultMap">
    
            SELECT A.*, C.NAME AS CITY_NAME,
            (SELECT COUNT(*) FROM XQ_SCHOOL_INFO B WHERE A.ID=B.AREA_ID AND B.TYPE='553' AND B.STATUS = 1 ) AS PRIMARY_COUNT,
            (SELECT COUNT(*) FROM XQ_SCHOOL_INFO B WHERE A.ID=B.AREA_ID AND B.TYPE='554' AND B.STATUS = 1 ) AS MIDDLE_COUNT,
            (SELECT COUNT(*) FROM XQ_SCHOOL_INFO B WHERE A.ID=B.AREA_ID AND B.TYPE='555' AND B.STATUS = 1 ) AS HIGH_COUNT
            FROM XQ_SCHOOL_AREA A
            LEFT JOIN YW_CITY_SETTING C ON A.CITY_CODE = C.CODE
            <where>
                <if test="name != null and name != '' "> A.NAME LIKE CONCAT('%',#{NAME},'%')  </if>
                <if test="areaCityCode != null and areaCityCode != '' "> A.CITY_CODE = #{areaCityCode}  </if>
                <if test="keywords != null and keywords != '' ">
                    ( A.NAME LIKE CONCAT('%',#{keywords},'%')
                    )
                </if>
            </where>
        </select>
    
    
        <select id="selectAreaIdAndKeyWord" parameterType="java.util.Map" resultMap="BaseResultMap">
            SELECT
            *
            FROM
            XQ_SCHOOL_AREA
            WHERE
            1=1
            <if test="cityId != null">
                AND CITY_CODE=#{cityId}
            </if>
            <if test="key != null and key!=''">
                AND (NAME like CONCAT(#{key},'%' ) or NAME_SPELL like CONCAT(#{key},'%' ))
            </if>
            AND
            STATUS=1
            <if test="pageSize != null">
                limit #{pageSize}
            </if>
        </select>
    
    
        <!--查询学区详情列表-->
        <select id="selectAreaDetailByPage" parameterType="map" resultMap="SchoolDetailArea">
    
            SELECT A.* ,B.NAME AS SCHOOL_AREA_NAME ,C.NAME AS CITY_NAME,D.NAME AS AREA_NAME FROM XQ_SCHOOL_INFO A
            LEFT JOIN XQ_SCHOOL_AREA B ON A.AREA_ID = B.ID
            LEFT JOIN YW_CITY_SETTING C ON A.CITY_CODE = C.CODE
            LEFT JOIN YW_CITY_SETTING D ON A.AREA_CODE = D.CODE
    
            WHERE A.STATUS = 1 AND B.STATUS =1
            <if test="areaId != null and areaId.length() &gt; 0">  AND A.AREA_ID = #{areaId} </if>
            <if test="typeList != null and typeList.size &gt; 0">
                AND
                A.TYPE IN
                <foreach collection="typeList"  item="item" index="index" open="(" close=")" separator=",">
                    #{item}
                </foreach>
            </if>
            <if test="name != null and name != '' "> AND   A.NAME LIKE CONCAT('%',#{name},'%')  </if>
        </select>
    
    </mapper>
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88

    普通mybatisMapper文件

    <?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.jjshome.esf.core.dao.school.ISchoolInfoDAO">
        <resultMap id="SchoolInfo" type="com.jjshome.esf.common.entity.school.SchoolInfo">
            <id column="ID" property="id"/>
            <result column="NAME" property="name"/>
            <result column="NAME_SPELL" property="nameSpell"/>
            <result column="ALIAS" property="alias"/>
            <result column="ALIAS_SPELL" property="aliasSpell"/>
            <result column="TYPE" property="type" typeHandler="com.jjshome.esf.core.component.handler.DictValueTypeHandler"/>
            <result column="AREA_ID" property="areaId"/>
            <result column="CITY_CODE" property="cityCode"/>
            <result column="AREA_CODE" property="areaCode"/>
            <result column="ADDR" property="addr"/>
            <result column="START_TIME" property="startTime"/>
            <result column="MOTTO" property="motto"/>
            <result column="WEB_SITE" property="webSite"/>
            <result column="PHONE" property="phone"/>
            <result column="FEATURE" property="feature" typeHandler="com.jjshome.esf.core.component.handler.DictValueListTypeHandler"/>
            <result column="LNG" property="lng"/>
            <result column="LAT" property="lat"/>
            <result column="UNIT_PRICE" property="unitPrice"/>
            <result column="SALE_PRICE" property="salePrice"/>
            <result column="NATURE_TYPE" property="natureType" typeHandler="com.jjshome.esf.core.component.handler.DictValueTypeHandler"/>
            <result column="NATURE_CITY" property="natureCity" typeHandler="com.jjshome.esf.core.component.handler.DictValueTypeHandler"/>
            <result column="SCHOOL_DEGREE" property="schoolDegree"/>
            <result column="ENROL_DEGREE" property="enrolDegree"/>
            <result column="IMG_DEGREE" property="imgDegree"/>
            <result column="STATUS" property="status"/>
            <result column="CREATE_ID" property="createId"/>
            <result column="CREATE_DATE" property="createDate"/>
            <result column="UPDATE_ID" property="updateId"/>
            <result column="UPDATE_DATE" property="updateDate"/>
    
            <result column="CITY_NAME" property="cityName" />
            <result column="AREA_NAME" property="areaName" />
            <result column="SCHOOL_DISTRICT_NAME" property="schoolDistrictName" />
            <result column="SALE_COUNT" property="saleCount" />
        </resultMap>
    
        <sql id="Base_Column_List">
            ID,
            NAME,
            NAME_SPELL,
            ALIAS,
            ALIAS_SPELL,
            TYPE,
            AREA_ID,
            CITY_CODE,
            AREA_CODE,
            ADDR,
            START_TIME,
            MOTTO,
            WEB_SITE,
            PHONE,
            FEATURE,
            LNG,
            LAT,
            UNIT_PRICE,
            SALE_PRICE,
            NATURE_TYPE,
            NATURE_CITY,
            SCHOOL_DEGREE,
            ENROL_DEGREE,
            IMG_DEGREE,
            STATUS,
            CREATE_ID,
            CREATE_DATE,
            UPDATE_ID,
            UPDATE_DATE,
            SALE_COUNT,
            SALE_COUNT
        </sql>
    
        <select id="selectById" resultMap="SchoolInfo" parameterType="java.lang.Integer">
            SELECT
                i.*,
                yc.NAME as 'CITY_NAME',
                ya.NAME as 'AREA_NAME',
                xq.NAME as 'SCHOOL_DISTRICT_NAME'
            FROM
                XQ_SCHOOL_INFO i
                LEFT JOIN YW_CITY_SETTING yc ON i.CITY_CODE = yc.CODE
                LEFT JOIN YW_CITY_SETTING ya ON i.AREA_CODE = ya.CODE
                LEFT JOIN XQ_SCHOOL_AREA xq ON i.AREA_ID = xq.ID
            WHERE
                i.ID = #{id,jdbcType=INTEGER}
        </select>
    
        <delete id="deleteById" parameterType="java.util.Map">
            UPDATE
                XQ_SCHOOL_INFO
            SET
                STATUS = 0,
                UPDATE_ID = #{updateId},
                UPDATE_DATE = NOW()
            WHERE
                ID = #{id,jdbcType=INTEGER}
        </delete>
    
        <delete id="batchDeleteByIds" parameterType="java.util.Map">
            UPDATE
                XQ_SCHOOL_INFO
            SET
                STATUS = 0,
                UPDATE_ID = #{updateId},
                UPDATE_DATE = NOW()
            WHERE
            ID IN (${ids})
        </delete>
    
        <update id="deleteAreaRelation" parameterType="com.jjshome.esf.common.entity.school.SchoolInfo">
            update XQ_SCHOOL_INFO
                SET AREA_ID = NULL,
                UPDATE_DATE = NOW()
            WHERE
            ID = #{id}
        </update>
    
        <insert id="insert" parameterType="com.jjshome.esf.common.entity.school.SchoolInfo">
            <selectKey resultType="Integer" keyProperty="id">
                SELECT LAST_INSERT_ID()
            </selectKey>
            INSERT INTO XQ_SCHOOL_INFO
                (NAME,
                NAME_SPELL,
                ALIAS,
                ALIAS_SPELL,
                TYPE,
                AREA_ID,
                CITY_CODE,
                AREA_CODE,
                ADDR,
                START_TIME,
                MOTTO,
                WEB_SITE,
                PHONE,
                FEATURE,
                LNG,
                LAT,
                UNIT_PRICE,
                SALE_PRICE,
                NATURE_TYPE,
                NATURE_CITY,
                SCHOOL_DEGREE,
                ENROL_DEGREE,
                IMG_DEGREE,
                STATUS,
                CREATE_ID,
                CREATE_DATE,
                UPDATE_ID,
                UPDATE_DATE)
            VALUES
                (#{name,jdbcType=VARCHAR},
                #{nameSpell,jdbcType=VARCHAR},
                #{alias,jdbcType=VARCHAR},
                #{aliasSpell,jdbcType=VARCHAR},
                #{type,jdbcType=INTEGER},
                #{areaId,jdbcType=INTEGER},
                #{cityCode,jdbcType=VARCHAR},
                #{areaCode,jdbcType=VARCHAR},
                #{addr,jdbcType=VARCHAR},
                #{startTime,jdbcType=DATE},
                #{motto,jdbcType=VARCHAR},
                #{webSite,jdbcType=VARCHAR},
                #{phone,jdbcType=VARCHAR},
                #{feature,jdbcType=VARCHAR},
                #{lng,jdbcType=DECIMAL},
                #{lat,jdbcType=DECIMAL},
                #{unitPrice},
                #{salePrice},
                #{natureType,jdbcType=INTEGER},
                #{natureCity,jdbcType=INTEGER},
                #{schoolDegree,jdbcType=INTEGER},
                #{enrolDegree,jdbcType=INTEGER},
                #{imgDegree,jdbcType=INTEGER},
                #{status,jdbcType=TINYINT},
                #{createId,jdbcType=VARCHAR},
                #{createDate,jdbcType=DATE},
                #{updateId,jdbcType=VARCHAR},
                #{updateDate,jdbcType=DATE})
        </insert>
        <insert id="insertSelective" parameterType="com.jjshome.esf.common.entity.school.SchoolInfo">
            <selectKey resultType="Integer" keyProperty="id">
                SELECT LAST_INSERT_ID()
            </selectKey>
            INSERT INTO XQ_SCHOOL_INFO
            <trim prefix="(" suffix=")" suffixOverrides=",">
                <if test="name != null">
                    NAME,
                </if>
                <if test="nameSpell != null">
                    NAME_SPELL,
                </if>
                <if test="alias != null">
                    ALIAS,
                </if>
                <if test="aliasSpell != null">
                    ALIAS_SPELL,
                </if>
                <if test="type != null">
                    TYPE,
                </if>
                <if test="areaId != null">
                    AREA_ID,
                </if>
                <if test="cityCode != null">
                    CITY_CODE,
                </if>
                <if test="areaCode != null">
                    AREA_CODE,
                </if>
                <if test="addr != null">
                    ADDR,
                </if>
                <if test="startTime != null">
                    START_TIME,
                </if>
                <if test="motto != null">
                    MOTTO,
                </if>
                <if test="webSite != null">
                    WEB_SITE,
                </if>
                <if test="phone != null">
                    PHONE,
                </if>
                <if test="feature != null">
                    FEATURE,
                </if>
                <if test="lng != null">
                    LNG,
                </if>
                <if test="lat != null">
                    LAT,
                </if>
                <if test="UNIT_PRICE != null">
                    UNIT_PRICE,
                </if>
                <if test="SALE_PRICE != null ">
                    SALE_PRICE,
                </if>
                <if test="natureType != null">
                    NATURE_TYPE,
                </if>
                <if test="natureCity != null">
                    NATURE_CITY,
                </if>
                <if test="schoolDegree != null">
                    SCHOOL_DEGREE,
                </if>
                <if test="enrolDegree != null">
                    ENROL_DEGREE,
                </if>
                <if test="imgDegree != null">
                    IMG_DEGREE,
                </if>
                <if test="status != null">
                    STATUS,
                </if>
                <if test="createId != null">
                    CREATE_ID,
                </if>
                <if test="createDate != null">
                    CREATE_DATE,
                </if>
                <if test="updateId != null">
                    UPDATE_ID,
                </if>
                <if test="updateDate != null">
                    UPDATE_DATE,
                </if>
            </trim>
            <trim prefix="VALUES (" suffix=")" suffixOverrides=",">
                <if test="name != null">
                    #{name,jdbcType=VARCHAR},
                </if>
                <if test="nameSpell != null">
                    #{nameSpell,jdbcType=VARCHAR},
                </if>
                <if test="alias != null">
                    #{alias,jdbcType=VARCHAR},
                </if>
                <if test="aliasSpell != null">
                    #{aliasSpell,jdbcType=VARCHAR},
                </if>
                <if test="type != null">
                    #{type,jdbcType=INTEGER},
                </if>
                <if test="areaId != null">
                    #{areaId,jdbcType=INTEGER},
                </if>
                <if test="cityCode != null">
                    #{cityCode,jdbcType=VARCHAR},
                </if>
                <if test="areaCode != null">
                    #{areaCode,jdbcType=VARCHAR},
                </if>
                <if test="addr != null">
                    #{addr,jdbcType=VARCHAR},
                </if>
                <if test="startTime != null">
                    #{startTime,jdbcType=DATE},
                </if>
                <if test="motto != null">
                    #{motto,jdbcType=VARCHAR},
                </if>
                <if test="webSite != null">
                    #{webSite,jdbcType=VARCHAR},
                </if>
                <if test="phone != null">
                    #{phone,jdbcType=VARCHAR},
                </if>
                <if test="feature != null">
                    #{feature,jdbcType=VARCHAR},
                </if>
                <if test="lng != null">
                    #{lng,jdbcType=DECIMAL},
                </if>
                <if test="lat != null">
                    #{lat,jdbcType=DECIMAL},
                </if>
                <if test="unitPrice ! =null">
                    #{unitPrice},
                </if>
                <if test="salePrice">
                    #{salePrice},
                </if>
                <if test="natureType != null">
                    #{natureType,jdbcType=INTEGER},
                </if>
                <if test="natureCity != null">
                    #{natureCity,jdbcType=INTEGER},
                </if>
                <if test="schoolDegree != null">
                    #{schoolDegree,jdbcType=INTEGER},
                </if>
                <if test="enrolDegree != null">
                    #{enrolDegree,jdbcType=INTEGER},
                </if>
                <if test="imgDegree != null">
                    #{imgDegree,jdbcType=INTEGER},
                </if>
                <if test="status != null">
                    #{status,jdbcType=TINYINT},
                </if>
                <if test="createId != null">
                    #{createId,jdbcType=VARCHAR},
                </if>
                <if test="createDate != null">
                    #{createDate,jdbcType=DATE},
                </if>
                <if test="updateId != null">
                    #{updateId,jdbcType=VARCHAR},
                </if>
                <if test="updateDate != null">
                    #{updateDate,jdbcType=DATE},
                </if>
            </trim>
        </insert>
        <update id="updateSelective" parameterType="com.jjshome.esf.common.entity.school.SchoolInfo">
            UPDATE XQ_SCHOOL_INFO
            <set>
                <if test="name != null">
                    NAME=#{name,jdbcType=VARCHAR},
                </if>
                <if test="nameSpell != null">
                    NAME_SPELL=#{nameSpell,jdbcType=VARCHAR},
                </if>
                <if test="alias != null">
                    ALIAS=#{alias,jdbcType=VARCHAR},
                </if>
                <if test="aliasSpell != null">
                    ALIAS_SPELL=#{aliasSpell,jdbcType=VARCHAR},
                </if>
                <if test="type != null">
                    TYPE=#{type,jdbcType=INTEGER},
                </if>
                <if test="type != null">
                    AREA_ID=#{areaId,jdbcType=INTEGER},
                </if>
    
                <if test="cityCode != null">
                    CITY_CODE=#{cityCode,jdbcType=VARCHAR},
                </if>
                <if test="areaCode != null">
                    AREA_CODE=#{areaCode,jdbcType=VARCHAR},
                </if>
                <if test="addr != null">
                    ADDR=#{addr,jdbcType=VARCHAR},
                </if>
                <if test="startTime != null">
                    START_TIME=#{startTime,jdbcType=DATE},
                </if>
                <if test="motto != null">
                    MOTTO=#{motto,jdbcType=VARCHAR},
                </if>
                <if test="webSite != null">
                    WEB_SITE=#{webSite,jdbcType=VARCHAR},
                </if>
                <if test="phone != null">
                    PHONE=#{phone,jdbcType=VARCHAR},
                </if>
                <if test="feature != null">
                    FEATURE=#{feature,jdbcType=VARCHAR},
                </if>
                <if test="lng != null">
                    LNG=#{lng,jdbcType=DECIMAL},
                </if>
                <if test="lat != null">
                    LAT=#{lat,jdbcType=DECIMAL},
                </if>
                <if test="salePrice != null">
                    UNIT_PRICE=#{unitPrice},
                </if>
                <if test="salePrice != null">
                    SALE_PRICE=#{salePrice},
                </if>
                <if test="natureType != null">
                    NATURE_TYPE=#{natureType,jdbcType=INTEGER},
                </if>
                <if test="natureCity != null">
                    NATURE_CITY=#{natureCity,jdbcType=INTEGER},
                </if>
                <if test="schoolDegree != null">
                    SCHOOL_DEGREE=#{schoolDegree,jdbcType=INTEGER},
                </if>
                <if test="enrolDegree != null">
                    ENROL_DEGREE=#{enrolDegree,jdbcType=INTEGER},
                </if>
                <if test="imgDegree != null">
                    IMG_DEGREE=#{imgDegree,jdbcType=INTEGER},
                </if>
                <if test="status != null">
                    STATUS=#{status,jdbcType=TINYINT},
                </if>
                <if test="createId != null">
                    CREATE_ID=#{createId,jdbcType=VARCHAR},
                </if>
                <if test="createDate != null">
                    CREATE_DATE=#{createDate,jdbcType=DATE},
                </if>
                <if test="updateId != null">
                    UPDATE_ID=#{updateId,jdbcType=VARCHAR},
                </if>
                <if test="updateDate != null">
                    UPDATE_DATE=#{updateDate,jdbcType=DATE},
                </if>
                <if test="saleCount != null">
                    SALE_COUNT=#{saleCount},
                </if>
            </set>
            WHERE
                ID = #{id,jdbcType=INTEGER}
        </update>
        <select id="selectList" parameterType="com.jjshome.esf.common.entity.school.SchoolInfo" resultMap="SchoolInfo">
            SELECT
                <include refid="Base_Column_List" />
            FROM
                XQ_SCHOOL_INFO
            WHERE
                STATUS = 1
                <if test="areaId != null and areaId != null"> AND AREA_ID = #{areaId} </if>
    
        </select>
    
        <select id="selectSchoolInfoAll" resultMap="SchoolInfo">
            SELECT
                <include refid="Base_Column_List" />
            FROM
                XQ_SCHOOL_INFO
            WHERE
                STATUS = 1
            ORDER BY ID DESC
        </select>
    
        <select id="selectSchoolInfo" parameterType="com.jjshome.esf.common.model.SchoolInfoSearchModel" resultMap="SchoolInfo">
            SELECT
                i.*,
                yc.NAME as 'CITY_NAME',
                ya.NAME as 'AREA_NAME'
            FROM
                XQ_SCHOOL_INFO i
                LEFT JOIN YW_CITY_SETTING yc ON i.CITY_CODE = yc.CODE
                LEFT JOIN YW_CITY_SETTING ya ON i.AREA_CODE = ya.CODE
            WHERE
                i.STATUS = 1
            <if test="city != null and city != '' ">
                AND i.CITY_CODE=#{city}
            </if>
            <if test="area != null and area != '' ">
                AND i.AREA_CODE=#{area}
            </if>
            <if test="schoolId != null and schoolId != ''">
                AND i.ID=#{schoolId}
            </if>
    
            <if test="schoolName != null and schoolName != ''">
                AND i.NAME LIKE concat('%',#{schoolName},'%')
            </if>
    
            <if test="schoolDistrictId != null and schoolDistrictId != ''">
                AND i.AREA_ID=#{schoolDistrictId}
            </if>
            <if test="schoolType != null and schoolType != '' ">
                AND i.TYPE=#{schoolType}
            </if>
            <if test="key != null and key != '' ">
                AND (i.NAME LIKE CONCAT('%',#{key},'%') OR  i.ALIAS LIKE CONCAT('%', #{key}, '%'))
            </if>
            /*priceType == 1:起售价 2:房源售均价*/
            <if test="priceType == 1">
                <if test="salePriceStart != null and salePriceStart != '' ">
                    AND SALE_PRICE &gt;= #{salePriceStart}
                </if>
                <if test="salePriceEnd != null and salePriceEnd != '' ">
                    AND SALE_PRICE &lt;= #{salePriceEnd}
                </if>
            </if>
            <if test="priceType == 2">
                <if test="salePriceStart != null and salePriceStart != '' ">
                    AND UNIT_PRICE &gt;= #{salePriceStart}
                </if>
                <if test="salePriceEnd != null and salePriceEnd != '' ">
                    AND UNIT_PRICE &lt;= #{salePriceEnd}
                </if>
            </if>
            <if test="perfectSituation == 1">
                AND SCHOOL_DEGREE = 100
            </if>
            <if test="perfectSituation == 2">
                AND SCHOOL_DEGREE &lt; 100
            </if>
            ORDER BY ID DESC
    
        </select>
    
        <select id="selectSchoolByNameAndCityAndArea" parameterType="java.util.Map" resultMap="SchoolInfo">
            SELECT
                <include refid="Base_Column_List" />
            FROM
                XQ_SCHOOL_INFO
            WHERE
                STATUS = 1
            AND NAME = #{name}
            AND CITY_CODE=#{city}
            AND AREA_CODE=#{area}
            AND TYPE = #{type}
        </select>
    
        <select id="selectAreaIdAndKeyWord" parameterType="java.util.Map" resultMap="SchoolInfo">
            SELECT
            XSI.*,CYCS.NAME AS  'CITY_NAME',AYCS.NAME AS  'AREA_NAME'
            FROM
                XQ_SCHOOL_INFO XSI
                LEFT JOIN YW_CITY_SETTING CYCS ON  XSI.CITY_CODE = CYCS.CODE
                LEFT JOIN YW_CITY_SETTING AYCS ON XSI.AREA_CODE = AYCS. CODE
            WHERE
                1=1
            <if test="areaId != null and areaId != ''">
                AND XSI.AREA_CODE=#{areaId}
            </if>
            <if test="key != null and key!=''">
                AND (XSI.NAME like CONCAT(#{key},'%' ) or XSI.NAME_SPELL like CONCAT(#{key},'%' ))
            </if>
            AND
            XSI.STATUS=1
            <if test="pageSize != null">
                limit #{pageSize}
            </if>
        </select>
    
    
        <select id="selectAreaIdList" parameterType="map" resultType="integer">
            SELECT DISTINCT AREA_ID FROM XQ_SCHOOL_INFO WHERE NAME LIKE CONCAT('%',#{schoolName},'%')
        </select>
    
    
        <select id="selectSchoolList" parameterType="map" resultMap="SchoolInfo">
            SELECT
            <include refid="Base_Column_List" />
            FROM
            XQ_SCHOOL_INFO
            WHERE
            STATUS = 1
            <if test="idList != null and idList.size gt 0">
                AND ID IN
                <foreach collection="idList"  item="item" index="index" open="(" close=")" separator=",">
                    #{item}
                </foreach>
            </if>
    
            <if test="areaId != null and areaId != null"> AND AREA_ID = #{areaId} </if>
    
        </select>
    </mapper>
    
    展开全文
  • 配合文章使用,springboot +tkmybatis + generator+单元.zip 请配文件使用
  • TKmybatis和mybatisplus哪个好用

    千次阅读 2019-07-02 23:02:00
    文档连接 :http://baomidou.oschina.io/mybatis-plus-doc/#/?id=%E7%AE%80%E4%BB%8B https://gitee.com/hengboy/mybatis-enhance https://gitee.com/free/Mapper/wikis/1.3-s...

    文档连接 :http://baomidou.oschina.io/mybatis-plus-doc/#/?id=%E7%AE%80%E4%BB%8B

                        https://gitee.com/hengboy/mybatis-enhance

                        https://gitee.com/free/Mapper/wikis/1.3-spring-boot?sort_id=208198

                        https://durcframework.gitee.io/fastmybatis/

    注: mybatis-enhance也同样可以跟相同namespace的mapper.xml自动合并

    转载于:https://www.cnblogs.com/Jeremy2001/p/11123703.html

    展开全文
  • mybatis-generator和TKmybatis的结合使用

    千次阅读 2018-07-03 10:29:33
    mybatis-generator可以自动生成mapperentity文件,mybatis-generator有三种用法:命令行、eclipse...TKmybatis提供一种通用mapper,它不需要针对每个mapper写sql语句,只需继承通用mapper调用相应的接口来完成单...
  • spring-boot+tk.mybatis通用mapper
  • 【Mybatis】TKMybatis 介绍使用

    万次阅读 多人点赞 2020-05-24 23:19:04
    一、什么是 TKMybatis TKMybatis 是基于 Mybatis 框架开发的一个工具,内部实现了对单表的基本数据操作,只需要简单继承 TKMybatis 提供的接口,就能够实现无需编写任何 sql 即能完成单表操作。 二、 TKMybatis ...
  • MyBatis通用Mapper3 通用Mapper都可以极大的方便开发人员。可以随意的按照自己的需要选择通用方法,还可以很方便的开发自己的通用方法。 极其方便的使用MyBatis单表的增删改查。...赞助后保留截图,将截图
  • spring4.0 集成 tk.mybatis插件,增删改无需增删改查,快速开发
  • 生成已tk.mybatis封装的mybatis代码
  • tkmybatis VS mybatisplus

    万次阅读 多人点赞 2019-07-10 20:30:15
    文章目录TkMybatis Vs MybatisPlus1.基础CRUD BaseMapper2.代码生成器3. 全局主键 Sequence主键4. 热加载5. 分页Mybatis-PlusTk.Mybatis6. 额外功能Mybatis-PlusTk.Mybatis TkMybatis Vs MybatisPlus 1.基础CRUD ...
  • tkmybatis是在mybatis框架的基础上提供了很多工具,让开发更加高效,下面来看看这个框架的基本使用,后面会对相关源码进行分析,感兴趣的同学可以看一下,挺不错的一个工具实现对员工表的增删改查的代码 ...
  • tkmybatis generator生成代码

    千次阅读 2019-04-24 18:41:02
    generatorConfig.xml <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://myba...
  • SpringBoot整合TKmybatis

    千次阅读 2019-09-30 22:48:32
    SpringBoot整合TKmybatis 前言:最近公司在用tkmybatis,于是乎去看了一下,挺好用的,所以在这里记录一下其用法。 一 什么是TKmybatis 就我个人的理解而言,tkmybatis就是一个框架或者说工具,其在mybatis的基础上...
  • TkMybatis的使用

    2020-06-01 23:05:29
    通用mapper:tkmybatis tkmybatis是上一次进行做项目时进行使用的以下对其进行总结,以便日后记忆使用。 tkmybatis在git上的链接https://github.com/abel533/Mapper/wiki Java 编码方式集成 Java 编码方式集成是最...
  • tkmybatis详细教程(一篇就明白)

    千次阅读 2021-05-28 19:27:04
    tkmybatis 是对底层 sql 进行了抽象封装,不需要考虑 sql 怎么写,只需要按照逻辑思维,遵循 tkmybatis 的语法即可实现数据库操作。 本文适合对springboot项目结构有一定了解的读者。 本文的项目基础是一个demo...
  • 一、spring boot的resourcesh/generatorConfig.xml内容如下: <?xml version="1.0" encoding="UTF-8...DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN...
  • tkmybatis使用教程

    千次阅读 2019-04-23 15:35:22
    mybatis-generator:generate
  • TKmybatis的使用,MyBatis的Mapper接口、Example方法

    千次阅读 多人点赞 2020-11-28 23:13:00
    文章目录TKmybatis的使用TKmybatis的常用注解Mapper中的方法(dao继承可用)Example方法设置查询条件 TKmybatis的使用 pom.xml导入依赖 <!-- https://mvnrepository.com/artifact/tk.mybatis/mapper --> &...
  • TkMybatis 笔记

    千次阅读 2018-08-06 17:37:18
    1 通用TkMybatis笔记 1 引入 1.1作用  替我们生成常用增删改查操作的SQL 语句。 1.2代码官方发布地址 https://gitee.com/free https://gitee.com/free/Mapper/wikis/1.1-java?parent=1.integration 1.3前置知识...
  • <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/> <!-- caseSensitive默认false,当数据库表名区分大小写时,可以将该属性设置为true --> <!--数据库连接 --> connectionURL="jdbc:...
  • SpringBoot整合TkMyBatis

    2019-12-09 21:08:54
    搜索MyBatisCodeHelperPro GenerateAllSetter安装 2、连接数据库 点击idea右侧边栏Database,选择MySQL 按照下图操作连接成功后,点击Schemas所示选项,勾选你的数据库,点击应用 3、选择一个表,自动生成...
  • TK mybatis 逆向工程

    2020-11-29 23:06:18
    配置文件 pom.xml <build> <plugins>...org.mybatis.generator</groupId> <artifactId>mybatis-generator-maven-plugin</artifactId> <version>1.3.7</vers
  • tkmybatis更新无效

    千次阅读 2019-04-28 16:17:04
    项目中持久层引入了tkmybatis,在一个更新的操作中,遇到一个问题:根据主键更新数据,方法为: public interface UpdateByPrimaryKeySelectiveMapper<T> { /** * 根据主键更新属性不为null的值 * * @...
  • tk-mybatis-dynamic-tablename tk.mybatis动态表操作

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,855
精华内容 5,142
关键字:

tkmybatis和mybatis