使用tk.mybatis集成通用Dao和Service

搭建

目录如下：

引入依赖和tk.mybatis

    <!--tk.mybatis-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper</artifactId>
        <version>3.4.2</version>
    </dependency>
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>1.1.3</version>
    </dependency>

完整的pom

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

<properties>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <!--日志-->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.21</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.21</version>
    </dependency>


    <!-- https://mvnrepository.com/artifact/com.alibaba/druid-spring-boot-starter -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.4</version>
    </dependency>



    <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.75</version>
    </dependency>


    <!--tk.mybatis-->
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper</artifactId>
        <version>3.4.2</version>
    </dependency>
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>1.1.3</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
</project>

配置类

import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import tk.mybatis.spring.mapper.MapperScannerConfigurer;


/**
 * Mybatis & Mapper & PageHelper 配置
 */
@Configuration
public class MybatisConfigurer {
    public static final String MAPPER_INTERFACE = "com.redis.demo.common.mapper.Dao";//Mapper插件基础接口的完全限定名,该接口需要自己定义
    public static final String BASE_PACKAGE = "com.redis.demo.**.dao";//Mapper插件基础接口的完全限定名

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        factory.setTypeAliasesPackage("com.redis.demo.**.entity");

        //配置分页插件，详情请查阅官方文档(pageHelperStarter中已自动配置，此处配置会重复)
        //PageInterceptor pageInterceptor = new PageInterceptor();
        //Properties properties = new Properties();
        //properties.setProperty("pageSizeZero", "true");//分页尺寸为0时查询所有纪录不再执行分页
        //properties.setProperty("reasonable", "true");//页码<=0 查询第一页，页码>=总页数查询最后一页
        //properties.setProperty("supportMethodsArguments", "true");//支持通过 Mapper 接口参数来传递分页参数
        //pageInterceptor.setProperties(properties);

        //添加插件
        //factory.setPlugins(new Interceptor[]{pageInterceptor});

        //添加XML目录
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        factory.setMapperLocations(resolver.getResources("classpath*:mapper/*.xml"));
        return factory.getObject();
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactoryBean");
        mapperScannerConfigurer.setBasePackage(BASE_PACKAGE);
        //配置通用Mapper，详情请查阅官方文档
        Properties properties = new Properties();
        properties.setProperty("mappers", MAPPER_INTERFACE);
        properties.setProperty("notEmpty", "false");//insert、update是否判断字符串类型!='' 即 test="str != null"表达式内是否追加 and str != ''
        properties.setProperty("IDENTITY", "MYSQL");
        mapperScannerConfigurer.setProperties(properties);

        return mapperScannerConfigurer;
    }

}

通用基础Dao和Service编写 ，Dao路径和名称要和上面配置类指定的一致

通用Dao

import tk.mybatis.mapper.common.BaseMapper;
import tk.mybatis.mapper.common.ConditionMapper;
import tk.mybatis.mapper.common.ExampleMapper;
import tk.mybatis.mapper.common.IdsMapper;
import tk.mybatis.mapper.common.special.InsertListMapper;

/**
 * 定制版MyBatis Mapper插件接口，如需其他接口参考官方文档自行添加。
 */
public interface Dao<T>
        extends
        BaseMapper<T>,
        ExampleMapper<T>,
        ConditionMapper<T>,
        IdsMapper<T>,
        InsertListMapper<T> {
}

通用service

import org.apache.ibatis.exceptions.TooManyResultsException;
import tk.mybatis.mapper.entity.Condition;
import tk.mybatis.mapper.entity.Example;
import java.util.List;
/**
 * Service 层 基础接口，其他Service 接口 请继承该接口
 */
public interface Service<T> {
	/**
	 * //持久化
	 * @param record
	 */
    void save(T record);
    /**
     * 批量持久化
     * @param records
     */
    void save(List<T> records);
    /**
     * 批量刪除 eg：ids -> “1,2,3,4”
     * @param ids
     */
    void deleteByIds(String ids);
    /**
     * 通过主键刪除
     * @param ids
     */
    void deleteByIds(Long ...ids);
    /**
     * 更新
     * @param record
     */
    void update(T record);
    /**
     * 查询一条记录
     * @param record
     * @return
     * @throws TooManyResultsException
     */
    T selectOne(T record) throws TooManyResultsException;
    /**
     * 根据一个字段selectOne
     * @param fieldName
     * @param value
     * @return
     * @throws TooManyResultsException
     * @throws ReflectiveOperationException
     */
    T selectOneBy(String fieldName, Object value) throws TooManyResultsException,ReflectiveOperationException; //通过Model中某个成员变量名称（非数据表中column的名称）查找,value需符合unique约束
    /**
     * 根据ID查找
     * @param id
     * @return
     */
    T selectById(Long id);
    /**
     * 根据ids字符串查询eg:ids -> "1,2,3,4"
     * @param ids
     * @return
     */
    List<T> selectByIds(String ids);//通过多个ID查找//eg：ids -> “1,2,3,4”
    /**
     * 根据ids查询
     * @param ids
     * @return
     */
    List<T> selectByIds(Long ...ids);//通过多个ID查找
    /**
     * 根据条件查询 sql语句
     * Condition condition=new Condition(Test1.class);
        condition.createCriteria().andCondition("name like '%zhangsan%'");
        condition.setOrderByClause("name desc");
     * @param condition
     * @return
     */
    List<T> selectByCondition(Condition condition);//根据条件查找
    /**
     * 根据example查询
     * @param example
     * @return
     */
    List<T> selectByExample(Example example);//根据条件查找
    /**
     * 查询全部
     * @return
     */
    List<T> selectAll();//获取所有
}

通用service实现类

import com.alibaba.fastjson.JSON;
import com.redis.demo.common.mapper.Dao;
import org.apache.ibatis.exceptions.TooManyResultsException;
import org.springframework.beans.factory.annotation.Autowired;
import tk.mybatis.mapper.entity.Condition;
import tk.mybatis.mapper.entity.Example;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.List;

/**
 * 基于通用MyBatis Mapper插件的Service接口的实现
 */
public abstract class AbstractService<T> implements Service<T> {

    @Autowired
    protected Dao<T> mapper;

    private Class<T> modelClass;    // 当前泛型真实类型的Class

    @SuppressWarnings("unchecked")
    public AbstractService() {
        ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
        modelClass = (Class<T>) pt.getActualTypeArguments()[0];
    }
    @Override
    public void save(T record) {
        mapper.insertSelective(record);
    }
    @Override
    public void save(List<T> models) {
        mapper.insertList(models);
    }
    @Override
    public void deleteByIds(Long ...ids) {
        if (ids == null) {

        } else if (ids.length == 1){
            mapper.deleteByPrimaryKey(ids[0]);
        } else {
            //TODO StingUtil
//    		mapper.deleteByIds(ids);
        }
    }
    @Override
    public void deleteByIds(String ids) {
        mapper.deleteByIds(ids);
    }
    @Override
    public void update(T model) {
        mapper.updateByPrimaryKeySelective(model);
    }
    @Override
    public T selectById(Long id) {
        return mapper.selectByPrimaryKey(id);
    }
    @Override
    public T selectOneBy(String fieldName, Object value) throws TooManyResultsException, ReflectiveOperationException {
        try {
            T model = modelClass.newInstance();
            Field field = modelClass.getDeclaredField(fieldName);
            field.setAccessible(true);
            field.set(model, value);
            return mapper.selectOne(model);
        } catch (ReflectiveOperationException e) {
            throw e;
        }
    }
    @Override
    public T selectOne(T record) throws TooManyResultsException {
        return mapper.selectOne(record);
    }
    @Override
    public List<T> selectByIds(String ids) {
        return mapper.selectByIds(ids);
    }
    @Override
    public List<T> selectByIds(Long... ids) {
        //TODO 转换数组到字符串ids
        return mapper.selectByIds(JSON.toJSONString(ids));
    }
    @Override
    public List<T> selectByCondition(Condition condition) {
        return mapper.selectByCondition(condition);
    }
    @Override
    public List<T> selectByExample(Example example) {
        return mapper.selectByExample(example);
    }
    @Override
    public List<T> selectAll() {
        return mapper.selectAll();
    }
	}

测试使用

实体类：

import javax.persistence.*;

/**
*@Description 用户
*@Date 2021/1/14
*@Version 1.0
*/
@Table(name ="person")
public class Person {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private  Integer id;
    @Column(name = "name")
    private String name;
    @Column(name = "age")
    private Integer age;
    @Column(name = "sex")
    private String sex;

public Person() {
}

public Integer getId() {
    return id;
}

public void setId(Integer id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public Integer getAge() {
    return age;
}

public void setAge(Integer age) {
    this.age = age;
}

public String getSex() {
    return sex;
}

public void setSex(String sex) {
    this.sex = sex;
}

@Override
public String toString() {
    return "Person{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            ", sex='" + sex + '\'' +
            '}';
}
}

serviceImpl实现类

import com.redis.demo.common.service.AbstractService;
import com.redis.demo.entity.Person;
import org.springframework.stereotype.Service;

@Service
public class PersonServiceImpl extends AbstractService<Person> {
}

Controller接口

import com.redis.demo.entity.Person;
import com.redis.demo.service.PersonServiceImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import tk.mybatis.mapper.entity.Example;

import javax.annotation.Resource;
import java.util.List;

/**
*@Description 人员Person
*@Author PengYongMei
*@Date 2021/1/14
*@Version 1.0
*/
@Controller
public class PersonController {
    private static Logger logger= LoggerFactory.getLogger(PersonController.class);
    @Resource
    private PersonServiceImpl personService;



@RequestMapping(value = "/insertPerson",method = RequestMethod.GET)
@ResponseBody
public  void  insertPerson(){
    logger.info("保存用户——————————————————————————————————————");
    Person person = new Person();
    person.setName("藏三");
    person.setAge(26);
    person.setSex("女");
    personService.save(person);
    logger.info(person.toString());

}


@RequestMapping(value = "/getPerson",method = RequestMethod.GET)
@ResponseBody
public  void  getPerson(){
    logger.info("查询用户——————————————————————————————————————");
    Person person=new Person();
    person.setId(1);
    Person person1 = personService.selectOne(person);
    logger.info(person1.toString());

    logger.info("——————————————————————————————————————————————————————————————————————————");


    Example example=new Example(Person.class);
    Example.Criteria criteria = example.createCriteria();
    criteria.andEqualTo("name","藏三");

    List<Person> peopleList = personService.selectByExample(example);
    logger.info(peopleList.get(0).toString());
}
}

启动类标记

import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = "com.redis.demo.dao.*")
public class RedisDemoApplication implements CommandLineRunner {

    Logger logger= LoggerFactory.getLogger(this.getClass());

    public static void main(String[] args) {
        SpringApplication.run(RedisDemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("Redis Project is starting");
    }
}

结果：

调用接口

完整源码

链接：https://pan.baidu.com/s/1lzPcTnSOHdvjt5Oj8P9ulA
提取码：7y70