通用Mapper简单使用介绍

通用Mapper使用介绍

　　通用Mapper是简化mybatis操作的一个框架，使用它就不需要再建立xml映射文件了，也不用在dao接口（注解开发）写sql语句，只需要将pojp用注解跟数据库的表和字段建立映射关系，然后在dao接口继承Mapp类并指定泛型（你要对哪个pojo操作就指定哪个pojo），在service实现类中，直接调用相关方法，就可以执行简单的CRUD，这样dao接口中也不需要再写方法了。但是这个也只能在简单的CRUD中可以使用。

　　通用Mapper其实也可以当作一种编程思维，不仅仅是dao接口可以用它抽取，service、controller也一样可以用这种思想抽取出来，直接调用抽取出来的代码就可以了，而不需要重复的写一些代码，这篇随笔里面只说使用方式，这种思想会另起随笔解释。

1、添加起步依赖：

<!--通用mapper起步依赖，它内部集成了mybatis、数据源的依赖，所以加了它就可以了-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.4</version>
        </dependency>
        <!--MySQL数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>

2、将pojo类跟数据库用注解建立映射关系

/****
 * @Author:admin
 * @Description:Brand构建
 * 
 *****/
@Table(name="tb_brand")//指定要映射的数据库中的哪个表
public class Brand implements Serializable{

    
    @Id//表示该成员变量是主键id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//标识该主键的策略，自增
    @Column(name = "id")
    private Integer id;//品牌id
    
    @Column(name = "name")//标识该成员变量跟数据库中的name字段映射
    private String name;//品牌名称
    
    @Column(name = "image")
    private String image;//品牌图片地址
    
    @Column(name = "letter")
    private String letter;//品牌的首字母
    
    @Column(name = "seq")
    private Integer seq;//排序


    //get方法
    public Integer getId() {
        return id;
    }

    //set方法
    public void setId(Integer id) {
        this.id = id;
    }
    //get方法
    public String getName() {
        return name;
    }

    //set方法
    public void setName(String name) {
        this.name = name;
    }
    //get方法
    public String getImage() {
        return image;
    }

    //set方法
    public void setImage(String image) {
        this.image = image;
    }
    //get方法
    public String getLetter() {
        return letter;
    }

    //set方法
    public void setLetter(String letter) {
        this.letter = letter;
    }
    //get方法
    public Integer getSeq() {
        return seq;
    }

    //set方法
    public void setSeq(Integer seq) {
        this.seq = seq;
    }


}

3、但是想要使用上面这个pojo中的注解，还需要加该系列注解的依赖才能使用：

<!--(该依赖是通用mapper的注解依赖，跟数据库的表产生映射关系)-->
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
            <scope>compile</scope>
        </dependency>

4、创建controller、service、serviceImpl、dao，我按顺序挂一遍：

controller：

@RestController
@RequestMapping("/brand")
public class BrandController {
    @Autowired
    private BrandService brandService;

    @GetMapping("findAll")
    public Result findBrandAll(){
        List<Brand> brandAll = brandService.findBrandAll();
        return new Result(true, StatusCode.OK,"操作成功！",brandAll);
    }
}

service：

public interface BrandService {
    List<Brand> findBrandAll();
}

serviceImpl：

@Service
public class BrandServiceImpl implements BrandService {
    @Autowired
    private BrandDao brandDao;

    @Override
    public List<Brand> findBrandAll() {
        return brandDao.selectAll();

    }
}

dao：关键的地方到了，这个dao需要继承Mapper类，并指定泛型（泛型指定你要操作的pojo）：继承它就行了，不需要写方法，当它继承了Mapper之后，调用这个dao接口的serviceImpl类中就可以调用mapper中定义好的方法，这些方法内部会拼接sql语句

public interface BrandDao extends Mapper<Brand> {

}

还有最关键的一点，就是跟mybatis使用一样，它需要扫描dao接口：这里要要注意，使用扫描的组件必须是tk，而不能用mybatis原本的：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
//tk!!tk!!tk!!  重要的事情说三遍，这里必须使用这个包里面的MapperScan！！
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication//spring boot自动配置注解
@EnableEurekaClient//这是spring cloud中的eureka客户端注解
@MapperScan(basePackages = "com.changgou.goods.dao")//指定要扫描的dao接口的包
public class GoodsServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(GoodsServiceApplication.class,args);
    }
}

再附加一些Mapper中的常用api介绍：

查询所有：里面代码就有体现，用继承了Mapper的dao接口（以下都是这样，不重复写了）.select()

根据主键id查询：selectByPrimaryKey(id);

添加数据：有两个api

　　　　　　.insertSelective(brand); 添加数据，如果添加的数据中有为null的字段，则不进行更改一般都用这种方式比较好，如果有特需，则用下面方式

　　　　　　.insert(brand);　　　　　添加数据，不管要添加的数据是否为null，都进行更改，如果为null则将数据库中的该字段修改为null

根据id更新数据：跟添加数据一样，只不过把snsert换成update就行了，同样有两个api，解释同上，这里唯一要注意的就是根据id更新数据，那么传入的pojo对象中的id字段一定要有值，否则它不知道修改哪条数据

根据id删除数据：.deleteByPrimaryKey(id);

根据条件查询数据：这个就要复杂一些了，这个根据条件查询和分页查询放一起单独挂：

根据条件查询数据：（这里是根据两个条件，第一个条件是name的模糊查询，第二个是letter的条件查询，两个条件可能没有，也可能只有一个，或者两个都有）

    /**
     * 根据搜索条件查询
     * */
    @Override
    public List<Brand> searchBrand(Brand brand) {
        //第二步：NEW出这个对象，指定存放条件内容的pojo，自动生成代码它是object接收的，所以要转换成Example
        Example example = new Example(Brand.class);
        //第三步，用刚刚NEW出的类创建条件对象，给这个条件对象设置条件就好了
        Example.Criteria criteria = example.createCriteria();
        //第四步，要进行非空判断，这里用的是StringUtils做的非空判断，
        //并且是SpringBoot的StringUtils，只要参数为null就会进入判断，所以下面取非就是只要不为null就进入判断执行代码
        if (!StringUtils.isEmpty(brand)){
            //这里做判断是因为两个条件，如果有其中一个没有值，说明客户端只传来一个，另一个条件就不添加
            if (!StringUtils.isEmpty(brand.getName())){
                //相当于sql语句：select * from t_brand <where> and name like '%'#{"name"}'%'</where>
                criteria.andLike("name","%"+brand.getName()+"%");
            }
            //这里做判断是因为两个条件，如果有其中一个没有值，说明客户端只传来一个，另一个条件就不添加
            if (!StringUtils.isEmpty(brand.getLetter())){
                //相当于sql语句：select * from t_brand <where> and letter = #{"name"}</where>
                criteria.andEqualTo("letter",brand.getLetter());
            }
        }
        //如果以上判断都没有进入，说明没有条件，那么查询的就是所有数据

        //第一步：用dao接口调用Mapper的selectByExample方法，它需要一个类作为参数，所以第二步就new出这个对象
        List<Brand> brandList = brandDao.selectByExample(example);
        return brandList;
    }

它基本的步骤就是代码里面的第一步到第三步，自己设置一下条件对象，然后手动进行是否有条件的判断就好了。

然后就是分页查询，也比较简单：只不过需要添加PageHelper的依赖，它也被spring boot集成了，所以可以添加starter的PageHelper依赖，就可以用了，不需要自己配置

    /**
     * 分页查询所有数据
     * */
    @Override
    public PageInfo<Brand> findPage(Integer page, Integer size) {
        //调用PageHelper的startPage方法，设置当前页、每页条数
        PageHelper.startPage(page,size);
        //调用dao接口继承的Mapper方法，查询所有的数据
        List<Brand> brandList = brandDao.selectAll();
        //把查到的数据封装到PageInfo中，然后返回，PageInFo中包含了所有的数据，总条数等等
        PageInfo<Brand> brandPageInfo = new PageInfo<>(brandList);
        //返回即可
        return brandPageInfo;
    }

最后，在很多场景下，根据条件查询的数据也需要进行分页，不仅仅前端需要传当前页和每页条数的参数，还需要传条件过来，所以跟上面不一样的是，前端要发送post请求为好，上面发get请求就可以：

这个就是将分页查询和根据条件查询结合起来就可以了，代码示范如下：（只要上面两个看明白了，这个就会无师自通）

    /**
     * 根据条件分页查询
     * */
    @Override
    public PageInfo<Brand> cearchPageByTerm(Integer page, Integer size,Brand brand) {
        //0、如果前端没有传入当前页和每页条数，则给它赋值
        if (page==null){
            page=1;
        }
        if (size==null){
            size=10;
        }
        //1、设置当前页、每页条数
        PageHelper.startPage(page,size);
        //2、查询数据
        Example example = new Example(Brand.class);
        Example.Criteria criteria = example.createCriteria();
        if (!StringUtils.isEmpty(brand)){
            if (!StringUtils.isEmpty(brand.getName())){
                criteria.andLike("name","%"+brand.getName()+"%");
            }
            if (!StringUtils.isEmpty(brand.getLetter())){
                criteria.andEqualTo("letter",brand.getLetter());
            }
        }
        List<Brand> brandList = brandDao.selectByExample(example);
        //将查询到的数据封装到pageinfo中
        PageInfo<Brand> listPageInfo = new PageInfo<>(brandList);
        return listPageInfo;
    }

最后附加一个全局处理异常的方法：

这里面用的注解都是spring里面的，所以也并不需要添加其它的依赖，只要你有spring 或者 spring boot的依赖就可以了

//添加注解，交给spring容器，这个注解还标识这是一个全局异常处理类
@ControllerAdvice
public class GlobalExceptionHandler {

    /**
     * 写一个方法，表示只要出现指定的某种异常，就进入到这个方法中进行处理
     * @ResponseBody: 因为前端只能接收JSON数据，不能直接返回Result对象，所以需要添加这个注解
     * @ExceptionHandler(value = Exception.class)： 表示这个方法是全局处理异常的方法
     *                    这里面value值，要指定出现什么异常进入下面的方法，如果不指定默认就是Exception
     * */
    @ResponseBody
    @ExceptionHandler(value = Exception.class)
    public Result globalExceptionHandler(Exception ex){
        //捕获异常并封装到result中返回
        return new Result(false, StatusCode.ERROR,ex.getMessage());
    }

}

然后，发送请求，就可以获取到数据了。这里比较简单，就是熟练度的问题了，当然，看关键部位就可以了，不要尝试直接复制搭建，这是我从微服务项目中拷贝了一部分代码，还有很多环境配置这里没有复制上来。

当然，除了通用mapper（也就是dao）之外，service、controller的CRUD也基本上代码一致，所以我们也可以抽取出来，在微服务架构中，一般是单独抽取到一个微服务，然后在各个模块的controller、service中就可以不用写那些重复代码，直接继承一个抽象类（该抽象类实现了一个核心接口，该核心接口继承了CRUDP等五个增删改查分页查询功能的接口），这样就省下了很多重复代码的编写。

通用service代码抽取

上图大概的思路就是：在core微服务中编写五个接口，分别实现增、删、查、改、分页五个功能，其中又分为查询所有、根据条件查询、根据主键id查询等等

　　　　　　　　　　然后用一个核心接口，继承这5个接口

　　　　　　　　　　再就是编写一个抽象类，实现这个核心接口的方法

　　　　　　　　　　最后，在真正功能模块中的service接口继承核心接口，并指定泛型为要操作的实体类

　　　　　　　　　　　　　然后在真正功能模块中的serviceImpl（service接口的实现类）先继承core微服务中实现了接口的抽象类，并指定泛型（要操作的实体类），然后再实现真正模块中的service接口（这个不是core工程中的核心接口），并在下面用super的方式给父类成员变量赋值

代码实现：

1、先创造一个微服务core，打包方式为pom，再在这个微服务中创建子工程core-service，打包方式jar，并添加相关依赖（通用Mapper、mysql、pagehandler、微服务的话pojo所在工程的依赖，这些依赖一定要有，其它的视情况定，这里偷个懒，直接从项目中拷贝了依赖）

<dependencies>
        <!--对changgou-common的依赖-->
        <dependency>
            <groupId>com.changgou</groupId>
            <artifactId>changgou-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!--通用mapper起步依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.0.4</version>
        </dependency>
        <!--MySQL数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--mybatis分页插件-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
<!--web起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--redis 使用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--spring-cloud-feign-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!--eureka客户端-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--微信支付-->
        <dependency>
            <groupId>com.github.wxpay</groupId>
            <artifactId>wxpay-sdk</artifactId>
            <version>0.0.3</version>
        </dependency>
        <!--httpclient支持-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>
    </dependencies>

2、在core工程中创建包：com.xxx.core.service，在包内创建五个CRDUP接口，根据需求实现相关功能：

/***
 * 描述
 */
public interface UpdateService<T> {

    /**
     * 根据对象进行更新
     *
     * @param record
     * @return
     */
    int updateByPrimaryKey(T record);
}

/**
 * 描述
 *
 */
public interface SelectService<T> {

    /**
     * 查询所有
     *
     * @return
     */
    public List<T> selectAll();

    /**
     * 查询一个对象
     *
     * @param id
     * @return
     */
    public T selectByPrimaryKey(Object id);

    /**
     * 根据条件查询
     *
     * @param record
     * @return
     */
    public List<T> select(T record);


}

/**
 * 描述
 */
public interface PagingService<T> {

    /**
     * 查询所有并分页
     *
     * @param pageNo
     * @param pageSize
     * @return
     */
    PageInfo<T> findByPage(Integer pageNo, Integer pageSize);


    /**
     * 根据查询条件 record 分页查询
     *
     * @param pageNo
     * @param pageSize
     * @param record
     * @return
     */
    PageInfo<T> findByPage(Integer pageNo, Integer pageSize, T record);


    /**
     * 根据查询条件exmaple来分页查询
     *
     * @param pageNo
     * @param pageSize
     * @param example
     * @return
     */
    PageInfo<T> findByPageExample(Integer pageNo, Integer pageSize, Object example);


}

/***
 * 描述
 */
public interface InsertService<T> {
    /**
     * 添加记录
     * @param record
     * @return
     */
    int insert(T record);

}

/**
 * 删除相关
 */
public interface DeleteService<T> {

    /**
     * 根据条件删除
     *
     * @param record
     * @return
     */
    int delete(T record);

    /**
     * 根据ID 删除
     *
     * @param id
     * @return
     */
    int deleteById(Object id);


}

然后再创建一个核心接口并继承以上五个接口：

/***
 * 描述：继承了CRUDP五个接口的核心接口，它被一个抽象类所实现
 */
public interface CoreService<T> extends
        DeleteService<T>,
        InsertService<T>,
        PagingService<T>,
        SelectService<T>,
        UpdateService<T> {
}

再创建一个impl包，在包内创建一个抽象类，实现上面这个核心接口

/***
 * 描述
 * 抽象类，实现了CoreService核心接口的CRUDP功能，谁继承这个抽象类实现谁就要提供操作的实体类，这样这个抽象类才能知道操作哪个对象
 * 继承这个类，需要给通用mapper和操作的实体类赋值，通过super方式
 */
public abstract class CoreServiceImpl<T> implements CoreService<T> {
    //通用mapepr
    protected Mapper<T> baseMapper;
    //操作的实体类
    protected Class<T> clazz;

    //提供构造方法，方便它的子类给通用mapper和操作的实体类赋值
    public CoreServiceImpl(Mapper<T> baseMapper, Class<T> clazz) {
        this.baseMapper = baseMapper;
        this.clazz = clazz;
    }

    //删除数据
    @Override
    public int delete(T record) {
        return baseMapper.delete(record);
    }
    //根据id删除数据
    @Override
    public int deleteById(Object id) {
        return baseMapper.deleteByPrimaryKey(id);
    }
    //添加数据
    @Override
    public int insert(T record) {
        return baseMapper.insertSelective(record);
    }
    //查询所有数据
    @Override
    public List<T> selectAll() {
        return baseMapper.selectAll();
    }
    //根据主键id查询数据
    @Override
    public T selectByPrimaryKey(Object id) {
        return baseMapper.selectByPrimaryKey(id);
    }
    //根据条件查询数据，条件只能是where = ，不能是where like之类的
    @Override
    public List<T> select(T record) {
        return baseMapper.select(record);
    }
    //根据主键id修改数据
    @Override
    public int updateByPrimaryKey(T record) {
        return baseMapper.updateByPrimaryKeySelective(record);
    }
    //分页查询数据
    @Override
    public PageInfo<T> findByPage(Integer pageNo, Integer pageSize) {
        PageHelper.startPage(pageNo, pageSize);
        List<T> list = baseMapper.selectAll();
        PageInfo<T> pageInfo = new PageInfo<T>(list);
        return pageInfo;
    }
    //根据条件模糊分页查询数据
    @Override
    public PageInfo<T> findByPage(Integer pageNo, Integer pageSize, T record) {
        Example example = new Example(clazz);
        Example.Criteria criteria = example.createCriteria();
        Field[] declaredFields = record.getClass().getDeclaredFields();

        for (Field declaredField : declaredFields) {
            try {
                //遇到 id注解 和 transient注解 不需要进行值的设置 直接跳过。
                if (declaredField.isAnnotationPresent(Transient.class) || declaredField.isAnnotationPresent(Id.class)) {
                    //遇到
                    continue;
                }
                //属性描述器  record.getClass()
                PropertyDescriptor propDesc = new PropertyDescriptor(declaredField.getName(), record.getClass());
                //获取这个值  先获取读方法的方法对象,并调用获取里面的值
                Object value = propDesc.getReadMethod().invoke(record);
                //Object value = propDesc.getValue(declaredField.getName());
                //如果是字符串
                if (value != null && value.getClass().getName().equals("java.lang.String")) {
                    Column columnAnnotation = declaredField.getAnnotation(Column.class);
                    //判断如果是长度为1 则 执行=号
                    int length = columnAnnotation.length();
                    if (length == 1) {
                        criteria.andEqualTo(declaredField.getName(), value);
                    } else {
                        criteria.andLike(declaredField.getName(), "%" + value + "%");
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        PageHelper.startPage(pageNo, pageSize);
        List<T> ts = baseMapper.selectByExample(example);
        PageInfo<T> info = new PageInfo<T>(ts);
        return info;
    }
    //根据条件分页查询数据
    @Override
    public PageInfo<T> findByPageExample(Integer pageNo, Integer pageSize, Object example) {
        PageHelper.startPage(pageNo, pageSize);
        List<T> list = baseMapper.selectByExample(example);
        PageInfo<T> info = new PageInfo<T>(list);
        return info;
    }


}

这样，通用的service就已经写完了，只需要在使用的时候指定泛型、给父类成员变量赋值就可以了，最后在controller就可以使用这个通用service的方法完成CRUDP

功能模块中的service接口代码如下：

/**
 * 品牌模块service
 * core工程抽取了service的通用代码，所以这里继承这个通用service接口，指定要操作的实体类即可
 * */
public interface BrandService extends CoreService<Brand> {

}

功能模块中的serviceImpl实现类代码如下：

/**
 * 品牌模块service实现类
 * 继承core工程中抽取的通用service的抽象实现类，并指定要操作的实体类，这个实现类实现了基本的CRUDP的方法，所以继承它也就相当于实现了CRUDP
 * 实现本工程编写的BrandService
 * 因为本工程dao接口中也是操作的通用mapper，所以需要将dao接口赋值给父类，完成实现
 * 还需要给父类需要操作的实体类赋值（当前所在的类为子类，它继承的类为父类）
 * */
@Service
public class BrandServiceImpl extends CoreServiceImpl<Brand> implements BrandService{
    private BrandDao brandDao;

    @Autowired
    public BrandServiceImpl(Mapper brandDao) {
        super(brandDao, Brand.class);
    }
}

做到这里，开启功能模块就可以接收到请求并处理请求了，以后相关的单表的CRUDP操作中业务层层不再需要写这些代码，只需要继承通用service即可

既然service可以抽取通用代码，那么controller中的代码也都是差不多的，所以也可以用相同思路实现，这里挂一下代码：依赖没挂了，它需要上面写的core-service工作作为依赖就可以了

1、相同的在core工程中创建子工程core-controller，建好包创建5个接口：

/***
 * 描述
 */
public interface IUpdateController<T> {

    /**
     * 根据对象进行更新 根据ID
     *
     * @param record
     * @return
     */
    Result updateByPrimaryKey(T record);
}

/***
 * 描述
 */
public interface ISelectController<T> {
    //根据ID 获取信息
    public Result<T> findById(Object id);


    //根据ID 获取信息列表
    public Result<List<T>> findAll();
}

/**
 * 描述
 */
public interface IPagingController<T> {

    /**
     * 查询所有并分页
     *
     * @param pageNo
     * @param pageSize
     * @return
     */
    Result<PageInfo<T>> findByPage(Integer pageNo, Integer pageSize);


    /**
     * 根据查询条件 record 分页查询
     *
     * @param pageNo
     * @param pageSize
     * @param record
     * @return
     */
    Result<PageInfo<T>> findByPage(Integer pageNo, Integer pageSize, T record);


}

/***
 * 描述
 */
public interface IInsertController<T> {
    /**
     * 添加记录
     * @param record
     * @return
     */
    Result insert(T record);

}

/***
 * 描述
 */
public interface IDeleteController<T> {
    /**
     * 根据ID 删除
     *
     * @param id
     * @return
     */
    Result deleteById(Object id);
}

2、一样是编写核心接口继承上面5个接口

/***
 * 描述
 * 继承了CRUDP五个接口的核心接口
 */
public interface ICoreController<T> extends
        ISelectController<T>,
        IInsertController<T>,
        IPagingController<T>,
        IDeleteController<T>,
        IUpdateController<T> {
}

3、编写抽象类：

/***
 * 描述
 * 抽象类，该抽象类实现了有CRUDP功能的service接口，继承它即可使用这些功能，但要给抽取的通用service对象和调用方类型赋值
 * 这里方法上用mapping做第二个请求路径，加载类上的第一个请求路径不放在这，由继承它的类加，或者在方法上写两级请求路径
 */

public abstract class AbstractCoreController<T> implements ICoreController<T> {

    //调用方的service
    protected CoreService<T> coreService;
    //调用方的类型
    protected Class<T> clazz;

    //通过构造方法给通用service和操作实体类赋值
    public AbstractCoreController(CoreService<T> coreService, Class<T> clazz) {
        this.coreService = coreService;
        this.clazz = clazz;
    }

    /**
     * 删除记录
     *
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    @Override
    public Result deleteById(@PathVariable(name = "id") Object id) {
        coreService.deleteById(id);
        return new Result(true, StatusCode.OK, "删除成功");
    }

    /**
     * 添加记录
     *
     * @param record
     * @return
     */
    @PostMapping
    @Override
    public Result insert(@RequestBody T record) {
        coreService.insert(record);
        return new Result(true, StatusCode.OK, "添加成功");
    }

    /**
     * 分页查询记录
     *
     * @param pageNo
     * @param pageSize
     * @return
     */
    @GetMapping(value = "/search/{page}/{size}")
    @Override
    public Result<PageInfo<T>> findByPage(@PathVariable(name = "page") Integer pageNo,
                                          @PathVariable(name = "size") Integer pageSize) {
        PageInfo<T> pageInfo = coreService.findByPage(pageNo, pageSize);
        return new Result<PageInfo<T>>(true, StatusCode.OK, "分页查询成功", pageInfo);
    }

    @PostMapping(value = "/search/{page}/{size}")
    @Override
    public Result<PageInfo<T>> findByPage(@PathVariable(name = "page") Integer pageNo,
                                          @PathVariable(name = "size") Integer pageSize,
                                          @RequestBody T record) {
        PageInfo<T> pageInfo = coreService.findByPage(pageNo, pageSize, record);
        return new Result<PageInfo<T>>(true, StatusCode.OK, "条件分页查询成功", pageInfo);
    }

    @Override
    @GetMapping("/{id}")
    public Result<T> findById(@PathVariable(name = "id") Object id) {
        T t = coreService.selectByPrimaryKey(id);
        return new Result<T>(true, StatusCode.OK, "查询单个数据成功", t);
    }

    @Override
    @GetMapping
    public Result<List<T>> findAll() {
        List<T> list = coreService.selectAll();
        return new Result<List<T>>(true, StatusCode.OK, "查询所有数据成功", list);
    }

    //更新数据
    @Override
    @PutMapping
    public Result updateByPrimaryKey(@RequestBody T record) {
        coreService.updateByPrimaryKey(record);
        return new Result(true, StatusCode.OK, "更新成功");
    }
}

4、然后就是使用这个通用controller，在真正的功能模块的controller类中继承这个抽象类，因为controller就没有本身的接口需要实现了，所以直接继承抽象类指定泛型即可，这里唯一不同的就是请求的映射路径，第一个路径在真正功能模块的类上，第二个路径在通用controller的抽象类上。

/**
 * 品牌模块
 * */
@RestController
@RequestMapping("/brand")
public class BrandController extends AbstractCoreController<Brand> {

    private CoreService coreService;
    @Autowired
    public BrandController(CoreService<Brand> coreService) {
        super(coreService, Brand.class);
    }
}

然后就可以发送请求实验了。

通用Mapper简单使用介绍

通用Mapper使用介绍

通用service代码抽取

推荐阅读