tkmybatis和mybatis

tkmybatis.rar
2020-08-20 14:43:12
Springboot整合TkMybatis，效果跟mybatis-plus一致，省掉CRUD的代码编写，让我们一起优雅。
收起

SpringBoot - 整合mybatis、TkMybatis和MyBatis Plus（零基础整合无压力~！）

2021-09-12 20:10:39

零、前言本文提到的内容，都只是最基础的应用，个人学习的同时，记录下来，忘记之后还可查看此文档快速回忆。参看： ...文章目录零、前言一、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,… … 


 文章目录
 零、前言
一、Mybatis
1.SpringBoot整合Mybatis
2.动态SQL
3.注意的点
  
二、tkmybatis
1.SpringBoot整合tkmybatis
1.1 tkmybatis启动器
1.2 实体类
1.3 Mapper接口
   
2.自定义映射文件
3.注意的点
  
三、mybatis plus
1.SpringBoot整合mp
2.注意的点
3.更多功能
  
四、结语

 
 
在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.注意的点 
手写sql，且手写的SQL必须正确。
实体类的字段可以由mybatis.xml文件配置与数据库字段对应。
在启动类上加注解@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注解会简单提及到用法 
 
 默认表名=类名，字段名=属性名（支持下划线转驼峰）
 
 @Table(name = "tableName") 指定表名
 
 @Column(name = "fieldName") 指定属性名
 
 @Transient表示此字段不进行映射
 
 @Id标注主键
 
 @GeneratedValue指定主键策略 
   
   @GeneratedValue(strategy = GenerationType.IDENTITY)注解中，GenerationType是枚举类，它有四种类型（以及解释）： 
   TABLE：使用一个特定的数据库表格来保存主键。
SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
IDENTITY：主键由数据库自动生成（主要是自动增长型）
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.注意的点 
实体类的编写需要遵守tkmybatis的规定，合理使用注解。
Mapper类需要继承Mapper<T>接口，之后可只有Mapper<T>接口提供的诸多方法。
扩展方法，编写复杂需要在UserMapper.xml映射文件中编写好对于的SQL逻辑。
在启动类上加tkmybatis的MapperScan注解。
tkmybatis自动下划线转驼峰（如数据库属性user_id对于Java代码的userId字段）。 
 
三、mybatis plus 
 
 官方使用的是H2数据库进行演示，我这里提供了H2数据库 
 
Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 
1.SpringBoot整合mp 
 
 与整合tkmybatis步骤一样，不同的点是 依赖、继承BaseMapper<T>，mapper对应的方法名不同。 
 
创建一个含mysql启动器的SpringBoot项目，再开始之后的整合操作。 
 mp启动器
 <!--mybatis plus 间接引入mybatis-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version> <!--版本根据需求选择-->
</dependency>
 
 application.yml编写配置文件（数据库，端口号，mapper映射文件，… …），诸多配置信息还可由xml文件进行配置。
 
 创建实体类User，在创建实体类的时候，也与tkmybatis有类是的注解（下面是常见注解）： 
  @TableName()：表名注解，value指定表名。
@TableId()：主键注解，value绑定主键字段名。
@TableField()：字段注解（非主键），value指定数据库字段名，数据表中不存在的字段使用@TableField(exist = false)修饰。
 
 编写Mapper接口。是继承BaseMapper<T>，再添加对应的自定义方法。
 
 有需要就编写Mapper.xml映射文件，绑定自定义方法的SQL。
 
 编写测试类，进行测试即可（具体的方法API移步官网）。
  
 
2.注意的点 
实体类的编写需要遵守mybatis plus的规定，合理使用注解。
Mapper类需要继承BaseMapper<T>接口。
扩展方法，编写复杂需要在UserMapper.xml映射文件中编写好对于的SQL逻辑。
在启动类上加mybatis plus的MapperScan注解。
mybatis plus自动下划线转驼峰。
mybatis plus功能非常的强大，熟练使用会成为开发利器。 
 
3.更多功能 
Mybatis-Plus是Mybatis的增强工具包，Mybatis Plus具有的功能有： 
通用的CURD
代码生成器（真香）
条件构造器
自定义SQL语句
分页插件、性能分析插件、全局拦截插件等。
公共字段自动填充。 
在之后的学习中，我会总结一下mybatis-plus的这些外挂式的功能，多多益善！ 
 
四、结语 
SpringBoot持久层操作有很多方式，就目前而言，mybatis plus是使用最多的，自己手里面的项目到底适合那一种，当然的根据自己项目的情况来决定采用谁。关于mp和tkmybatis比较：点击我跳转。

收起

展开全文

spring java

tkmybatis-tempate:tkmybatis自动生成模板-源码
2021-03-20 20:11:29
Tkmybatis是基于Mybatis框架开发的一个工具，通过调用它提供的方法实现对单表的数据操作，不需要写任何sql语句，这极大地提高了项目开发效率。代码说明 tk-mybatis为spring boot集成的tkmybatis ，在配置好文件后，...
收起
Java
TkMybatis通用Mapper逆向工程代码生成工具
2018-08-06 16:58:03
TkMybatis通用Mapper逆向工程代码生成工具，Maven项目工具；
收起
springboot+tkmybatis+gradle环境搭建
2018-10-20 18:09:20
springboot+tkmybatis+gradle环境搭建，测试代码在Test类中
收起

SpringBoot 与Mybatis ,TKMyBatis 的集成

2019-12-29 22:34:37

前面我们讲了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 的集成工作并且完成测试

收起

展开全文

springboot mybatis tk.mybatis

TKmybatis的框架介绍和原理分析及Mybatis新特性

万次阅读 2018-07-03 10:27:23

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
2019-08-15 16:34:50
配合文章使用，springboot +tkmybatis + generator+单元.zip 请配和文件使用
收起