通用Mapper使用介绍
通用Mapper是简化mybatis操作的一个框架，使用它就不需要再建立xml映射文件了，也不用在dao接口(注解开发)写sql语句，只需要将pojp用注解跟数据库的表和字段建立映射关系，然后在dao接口继承Mapp类并指定泛型(你要对哪个pojo操作就指定哪个pojo)，在service实现类中，直接调用相关方法，就可以执行简单的CRUD，这样dao接口中也不需要再写方法了。但是这个也只能在简单的CRUD中可以使用。
通用Mapper其实也可以当作一种编程思维，不仅仅是dao接口可以用它抽取，service、controller也一样可以用这种思想抽取出来，直接调用抽取出来的代码就可以了，而不需要重复的写一些代码，这篇随笔里面只说使用方式，这种思想会另起随笔解释。
1、添加起步依赖：
tk.mybatis
mapper-spring-boot-starter
2.0.4
mysql
mysql-connector-java
com.github.pagehelper
pagehelper-spring-boot-starter
1.2.3
2、将pojo类跟数据库用注解建立映射关系
/****
* @Author:admin
* @Description:Brand构建
*
*****/@Table(name="tb_brand")//指定要映射的数据库中的哪个表
public class Brand implementsSerializable{@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方法
publicInteger getId() {returnid;
}//set方法
public voidsetId(Integer id) {this.id =id;
}//get方法
publicString getName() {returnname;
}//set方法
public voidsetName(String name) {this.name =name;
}//get方法
publicString getImage() {returnimage;
}//set方法
public voidsetImage(String image) {this.image =image;
}//get方法
publicString getLetter() {returnletter;
}//set方法
public voidsetLetter(String letter) {this.letter =letter;
}//get方法
publicInteger getSeq() {returnseq;
}//set方法
public voidsetSeq(Integer seq) {this.seq =seq;
}
}3、但是想要使用上面这个pojo中的注解，还需要加该系列注解的依赖才能使用：
javax.persistence
persistence-api
1.0
compile4、创建controller、service、serviceImpl、dao，我按顺序挂一遍：
controller：
@RestController
@RequestMapping("/brand")public classBrandController {
@AutowiredprivateBrandService brandService;
@GetMapping("findAll")publicResult findBrandAll(){
List brandAll =brandService.findBrandAll();return new Result(true, StatusCode.OK,"操作成功！",brandAll);
}
}
service：
public interfaceBrandService {
ListfindBrandAll();
}
serviceImpl：
@Servicepublic class BrandServiceImpl implementsBrandService {
@AutowiredprivateBrandDao brandDao;
@Overridepublic ListfindBrandAll() {returnbrandDao.selectAll();
}
}dao：关键的地方到了，这个dao需要继承Mapper类，并指定泛型(泛型指定你要操作的pojo)：继承它就行了，不需要写方法，当它继承了Mapper之后，调用这个dao接口的serviceImpl类中就可以调用mapper中定义好的方法，这些方法内部会拼接sql语句
public interface BrandDao extends Mapper{
}还有最关键的一点，就是跟mybatis使用一样，它需要扫描dao接口：这里要要注意，使用扫描的组件必须是tk，而不能用mybatis原本的：
importorg.springframework.boot.SpringApplication;importorg.springframework.boot.autoconfigure.SpringBootApplication;importorg.springframework.cloud.netflix.eureka.EnableEurekaClient;//tk!!tk!!tk!! 重要的事情说三遍，这里必须使用这个包里面的MapperScan！！
importtk.mybatis.spring.annotation.MapperScan;
@SpringBootApplication//spring boot自动配置注解
@EnableEurekaClient//这是spring cloud中的eureka客户端注解
@MapperScan(basePackages = "com.changgou.goods.dao")//指定要扫描的dao接口的包
public classGoodsServiceApplication {public static voidmain(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的条件查询，两个条件可能没有，也可能只有一个，或者两个都有)
/*** 根据搜索条件查询
**/@Overridepublic ListsearchBrand(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 and name like '%'#{"name"}'%'
criteria.andLike("name","%"+brand.getName()+"%");
}//这里做判断是因为两个条件，如果有其中一个没有值，说明客户端只传来一个，另一个条件就不添加
if(!StringUtils.isEmpty(brand.getLetter())){//相当于sql语句：select * from t_brand and letter = #{"name"}
criteria.andEqualTo("letter",brand.getLetter());
}
}//如果以上判断都没有进入，说明没有条件，那么查询的就是所有数据//第一步：用dao接口调用Mapper的selectByExample方法，它需要一个类作为参数，所以第二步就new出这个对象
List brandList =brandDao.selectByExample(example);returnbrandList;
}
它基本的步骤就是代码里面的第一步到第三步，自己设置一下条件对象，然后手动进行是否有条件的判断就好了。
然后就是分页查询，也比较简单：只不过需要添加PageHelper的依赖，它也被spring boot集成了，所以可以添加starter的PageHelper依赖，就可以用了，不需要自己配置
/*** 分页查询所有数据
**/@Overridepublic PageInfofindPage(Integer page, Integer size) {//调用PageHelper的startPage方法，设置当前页、每页条数
PageHelper.startPage(page,size);//调用dao接口继承的Mapper方法，查询所有的数据
List brandList =brandDao.selectAll();//把查到的数据封装到PageInfo中，然后返回，PageInFo中包含了所有的数据，总条数等等
PageInfo brandPageInfo = new PageInfo<>(brandList);//返回即可
returnbrandPageInfo;
}
最后，在很多场景下，根据条件查询的数据也需要进行分页，不仅仅前端需要传当前页和每页条数的参数，还需要传条件过来，所以跟上面不一样的是，前端要发送post请求为好，上面发get请求就可以：
这个就是将分页查询和根据条件查询结合起来就可以了，代码示范如下：(只要上面两个看明白了，这个就会无师自通)
/*** 根据条件分页查询
**/@Overridepublic PageInfocearchPageByTerm(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 brandList =brandDao.selectByExample(example);//将查询到的数据封装到pageinfo中
PageInfo listPageInfo = new PageInfo<>(brandList);returnlistPageInfo;
}
最后附加一个全局处理异常的方法：
这里面用的注解都是spring里面的，所以也并不需要添加其它的依赖，只要你有spring 或者 spring boot的依赖就可以了
//添加注解，交给spring容器，这个注解还标识这是一个全局异常处理类
@ControllerAdvicepublic classGlobalExceptionHandler {/*** 写一个方法，表示只要出现指定的某种异常，就进入到这个方法中进行处理
* @ResponseBody: 因为前端只能接收JSON数据，不能直接返回Result对象，所以需要添加这个注解
* @ExceptionHandler(value = Exception.class)： 表示这个方法是全局处理异常的方法
* 这里面value值，要指定出现什么异常进入下面的方法，如果不指定默认就是Exception
**/@ResponseBody
@ExceptionHandler(value= Exception.class)publicResult 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所在工程的依赖，这些依赖一定要有，其它的视情况定，这里偷个懒，直接从项目中拷贝了依赖)
com.changgou
changgou-common
1.0-SNAPSHOT
tk.mybatis
mapper-spring-boot-starter
2.0.4
mysql
mysql-connector-java
com.github.pagehelper
pagehelper-spring-boot-starter
1.2.3
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-data-redis
org.springframework.cloud
spring-cloud-starter-openfeign
org.springframework.cloud
spring-cloud-starter-netflix-eureka-client
com.github.wxpay
wxpay-sdk
0.0.3
org.apache.httpcomponents
httpclient2、在core工程中创建包：com.xxx.core.service，在包内创建五个CRDUP接口，根据需求实现相关功能：
/***
* 描述*/
public interface UpdateService{/*** 根据对象进行更新
*
*@paramrecord
*@return
*/
intupdateByPrimaryKey(T record);
}
/*** 描述
**/
public interface SelectService{/*** 查询所有
*
*@return
*/
public ListselectAll();/*** 查询一个对象
*
*@paramid
*@return
*/
publicT selectByPrimaryKey(Object id);/*** 根据条件查询
*
*@paramrecord
*@return
*/
public Listselect(T record);
}
/*** 描述*/
public interface PagingService{/*** 查询所有并分页
*
*@parampageNo
*@parampageSize
*@return
*/PageInfofindByPage(Integer pageNo, Integer pageSize);/*** 根据查询条件 record 分页查询
*
*@parampageNo
*@parampageSize
*@paramrecord
*@return
*/PageInfofindByPage(Integer pageNo, Integer pageSize, T record);/*** 根据查询条件exmaple来分页查询
*
*@parampageNo
*@parampageSize
*@paramexample
*@return
*/PageInfofindByPageExample(Integer pageNo, Integer pageSize, Object example);
}
/***
* 描述*/
public interface InsertService{/*** 添加记录
*@paramrecord
*@return
*/
intinsert(T record);
}
/*** 删除相关*/
public interface DeleteService{/*** 根据条件删除
*
*@paramrecord
*@return
*/
intdelete(T record);/*** 根据ID 删除
*
*@paramid
*@return
*/
intdeleteById(Object id);
}然后再创建一个核心接口并继承以上五个接口：
/***
* 描述：继承了CRUDP五个接口的核心接口，它被一个抽象类所实现*/
public interface CoreService extendsDeleteService,
InsertService,
PagingService,
SelectService,
UpdateService{
}再创建一个impl包，在包内创建一个抽象类，实现上面这个核心接口
/***
* 描述
* 抽象类，实现了CoreService核心接口的CRUDP功能，谁继承这个抽象类实现谁就要提供操作的实体类，这样这个抽象类才能知道操作哪个对象
* 继承这个类，需要给通用mapper和操作的实体类赋值，通过super方式*/
public abstract class CoreServiceImpl implements CoreService{//通用mapepr
protected MapperbaseMapper;//操作的实体类
protected Classclazz;//提供构造方法，方便它的子类给通用mapper和操作的实体类赋值
public CoreServiceImpl(Mapper baseMapper, Classclazz) {this.baseMapper =baseMapper;this.clazz =clazz;
}//删除数据
@Overridepublic intdelete(T record) {returnbaseMapper.delete(record);
}//根据id删除数据
@Overridepublic intdeleteById(Object id) {returnbaseMapper.deleteByPrimaryKey(id);
}//添加数据
@Overridepublic intinsert(T record) {returnbaseMapper.insertSelective(record);
}//查询所有数据
@Overridepublic ListselectAll() {returnbaseMapper.selectAll();
}//根据主键id查询数据
@OverridepublicT selectByPrimaryKey(Object id) {returnbaseMapper.selectByPrimaryKey(id);
}//根据条件查询数据，条件只能是where = ，不能是where like之类的
@Overridepublic Listselect(T record) {returnbaseMapper.select(record);
}//根据主键id修改数据
@Overridepublic intupdateByPrimaryKey(T record) {returnbaseMapper.updateByPrimaryKeySelective(record);
}//分页查询数据
@Overridepublic PageInfofindByPage(Integer pageNo, Integer pageSize) {
PageHelper.startPage(pageNo, pageSize);
List list =baseMapper.selectAll();
PageInfo pageInfo = new PageInfo(list);returnpageInfo;
}//根据条件模糊分页查询数据
@Overridepublic PageInfofindByPage(Integer pageNo, Integer pageSize, T record) {
Example example= newExample(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 = newPropertyDescriptor(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 ts =baseMapper.selectByExample(example);
PageInfo info = new PageInfo(ts);returninfo;
}//根据条件分页查询数据
@Overridepublic PageInfofindByPageExample(Integer pageNo, Integer pageSize, Object example) {
PageHelper.startPage(pageNo, pageSize);
List list =baseMapper.selectByExample(example);
PageInfo info = new PageInfo(list);returninfo;
}
}
这样，通用的service就已经写完了，只需要在使用的时候指定泛型、给父类成员变量赋值就可以了，最后在controller就可以使用这个通用service的方法完成CRUDP
功能模块中的service接口代码如下：
/*** 品牌模块service
* core工程抽取了service的通用代码，所以这里继承这个通用service接口，指定要操作的实体类即可
**/
public interface BrandService extends CoreService{
}
功能模块中的serviceImpl实现类代码如下：
/*** 品牌模块service实现类
* 继承core工程中抽取的通用service的抽象实现类，并指定要操作的实体类，这个实现类实现了基本的CRUDP的方法，所以继承它也就相当于实现了CRUDP
* 实现本工程编写的BrandService
* 因为本工程dao接口中也是操作的通用mapper，所以需要将dao接口赋值给父类，完成实现
* 还需要给父类需要操作的实体类赋值(当前所在的类为子类，它继承的类为父类)
**/@Servicepublic class BrandServiceImpl extends CoreServiceImpl implementsBrandService{privateBrandDao brandDao;
@AutowiredpublicBrandServiceImpl(Mapper brandDao) {super(brandDao, Brand.class);
}
}
做到这里，开启功能模块就可以接收到请求并处理请求了，以后相关的单表的CRUDP操作中业务层层不再需要写这些代码，只需要继承通用service即可
既然service可以抽取通用代码，那么controller中的代码也都是差不多的，所以也可以用相同思路实现，这里挂一下代码：依赖没挂了，它需要上面写的core-service工作作为依赖就可以了
1、相同的在core工程中创建子工程core-controller，建好包创建5个接口：
/***
* 描述*/
public interface IUpdateController{/*** 根据对象进行更新 根据ID
*
*@paramrecord
*@return
*/Result updateByPrimaryKey(T record);
}
/***
* 描述*/
public interface ISelectController{//根据ID 获取信息
public ResultfindById(Object id);//根据ID 获取信息列表
public Result>findAll();
}
/*** 描述*/
public interface IPagingController{/*** 查询所有并分页
*
*@parampageNo
*@parampageSize
*@return
*/Result>findByPage(Integer pageNo, Integer pageSize);/*** 根据查询条件 record 分页查询
*
*@parampageNo
*@parampageSize
*@paramrecord
*@return
*/Result>findByPage(Integer pageNo, Integer pageSize, T record);
}
/***
* 描述*/
public interface IInsertController{/*** 添加记录
*@paramrecord
*@return
*/Result insert(T record);
}
/***
* 描述*/
public interface IDeleteController{/*** 根据ID 删除
*
*@paramid
*@return
*/Result deleteById(Object id);
}2、一样是编写核心接口继承上面5个接口
/***
* 描述
* 继承了CRUDP五个接口的核心接口*/
public interface ICoreController extendsISelectController,
IInsertController,
IPagingController,
IDeleteController,
IUpdateController{
}3、编写抽象类：
/***
* 描述
* 抽象类，该抽象类实现了有CRUDP功能的service接口，继承它即可使用这些功能，但要给抽取的通用service对象和调用方类型赋值
* 这里方法上用mapping做第二个请求路径，加载类上的第一个请求路径不放在这，由继承它的类加，或者在方法上写两级请求路径*/
public abstract class AbstractCoreController implements ICoreController{//调用方的service
protected CoreServicecoreService;//调用方的类型
protected Classclazz;//通过构造方法给通用service和操作实体类赋值
public AbstractCoreController(CoreService coreService, Classclazz) {this.coreService =coreService;this.clazz =clazz;
}/*** 删除记录
*
*@paramid
*@return
*/@DeleteMapping("/{id}")
@Overridepublic Result deleteById(@PathVariable(name = "id") Object id) {
coreService.deleteById(id);return new Result(true, StatusCode.OK, "删除成功");
}/*** 添加记录
*
*@paramrecord
*@return
*/@PostMapping
@OverridepublicResult insert(@RequestBody T record) {
coreService.insert(record);return new Result(true, StatusCode.OK, "添加成功");
}/*** 分页查询记录
*
*@parampageNo
*@parampageSize
*@return
*/@GetMapping(value= "/search/{page}/{size}")
@Overridepublic Result> findByPage(@PathVariable(name = "page") Integer pageNo,
@PathVariable(name= "size") Integer pageSize) {
PageInfo pageInfo =coreService.findByPage(pageNo, pageSize);return new Result>(true, StatusCode.OK, "分页查询成功", pageInfo);
}
@PostMapping(value= "/search/{page}/{size}")
@Overridepublic Result> findByPage(@PathVariable(name = "page") Integer pageNo,
@PathVariable(name= "size") Integer pageSize,
@RequestBody T record) {
PageInfo pageInfo =coreService.findByPage(pageNo, pageSize, record);return new Result>(true, StatusCode.OK, "条件分页查询成功", pageInfo);
}
@Override
@GetMapping("/{id}")public Result findById(@PathVariable(name = "id") Object id) {
T t=coreService.selectByPrimaryKey(id);return new Result(true, StatusCode.OK, "查询单个数据成功", t);
}
@Override
@GetMappingpublic Result>findAll() {
List list =coreService.selectAll();return new Result>(true, StatusCode.OK, "查询所有数据成功", list);
}//更新数据
@Override
@PutMappingpublicResult 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{privateCoreService coreService;
@Autowiredpublic BrandController(CoreServicecoreService) {super(coreService, Brand.class);
}
}然后就可以发送请求实验了。
