Mapper的优化

1，导入jar包

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

2，新建MyMapper接口到util包下

/**
 * 继承自己的MyMapper
 */
public interface MyMapper<T> extends Mapper<T>, MySqlMapper<T> {
    
}

3，dao的mapper实现MyMapper接口

/**
 * 答题卡Mapper接口 
 * @author guo
 *
 */
public interface AnswersMapper extends MyMapper<Answers>  {
    
}

 4，新建BaseService的接口

package com.yun.apps.poll.base;

import java.util.List;

public interface BaseService<T> {  
  
    int insert(T entity);  
  
    /** 
     * 添加非空值，null不会被保存，使用数据库默认值 
     *  
     * @param entity 
     * @return 
     */  
    int insertSelective(T entity);  
  
    int updateByPrimaryKey(T entity);  
  
    int updateByPrimaryKeySelective(T entity);  
  
    int deleteByPrimaryKey(Object primaryKey);  
  
    int deleteByPrimaryKeys(List<Object> primarykeys);  
  
    /** 
     * 根据指定字段值删除，判断条件为等号 
     *  
     * @param field 
     * @param value 
     * @return 
     */  
    int deleteByField(String field, String value);  
  
    int deleteByFields(String[] fields, String[] values);  
  
    /** 
     * 根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常，查询条件使用等号 
     *  
     * @param entity 
     * @return 
     */  
    T selectOne(T entity);  
  
    T selectByPrimaryKey(Object primaryKey);

    List<T> selectAll();  
   
}
  

5，BaseService的实现

package com.yun.apps.poll.base.impl;
import java.lang.reflect.ParameterizedType;
import java.util.List;  
  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
import org.springframework.beans.factory.annotation.Autowired;

import com.yun.apps.poll.base.BaseService;

import tk.mybatis.mapper.common.Mapper;  
import tk.mybatis.mapper.entity.Example;  
import tk.mybatis.mapper.entity.Example.Criteria;  
  
public class AbstractService<T> implements BaseService<T> {  
  
    protected Logger logger = LoggerFactory.getLogger(getClass());  
    
    @Autowired  
    protected Mapper<T> baseMapper;  
  
    private Class<?> clazz = null;  
  
    protected Class<?> getEntityClass() {  
        if (clazz == null) {  
            clazz = (Class<?>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];  
        }  
        return clazz;  
    }  
  
    @Override  
    public int insert(T entity) {  
        return baseMapper.insert(entity);  
    }  
  
    @Override  
    public int insertSelective(T entity) {  
        return baseMapper.insertSelective(entity);  
    }  
  
    @Override  
    public int updateByPrimaryKey(T entity) {  
        return baseMapper.updateByPrimaryKey(entity);  
    }  
  
    @Override  
    public int updateByPrimaryKeySelective(T entity) {  
        return baseMapper.updateByPrimaryKeySelective(entity);  
    }  
  
    @Override  
    public int deleteByPrimaryKey(Object primaryKey) {  
        return baseMapper.deleteByPrimaryKey(primaryKey);  
    }  
  
    @Override  
    public int deleteByPrimaryKeys(List<Object> primaryKeys) {  
        int resulrt = 0;  
        for (Object primaryKey : primaryKeys) {  
            resulrt += baseMapper.deleteByPrimaryKey(primaryKey);  
        }  
        return resulrt;  
    }  
  
    @Override  
    public int deleteByField(String field, String value) {  
        return deleteByFields(new String[] { field }, new String[] { value });  
    }  
  
    @Override  
    public int deleteByFields(String[] fields, String[] values) {  
        if (null == fields || null == values || fields.length == 0 || fields.length != values.length) {  
            return 0;  
        }  
        Example example = new Example(getEntityClass());  
        Criteria criteria = example.createCriteria();  
        for (int i = 0; i < fields.length; i++) {  
            criteria.andEqualTo(fields[i], values[i]);  
        }  
        return baseMapper.deleteByExample(example);  
    }  
  
    @Override  
    public T selectOne(T entity) {  
        return baseMapper.selectOne(entity);  
    }  
  
    @Override  
    public T selectByPrimaryKey(Object primaryKey) {  
        return baseMapper.selectByPrimaryKey(primaryKey);  
    }  
  
    @Override  
    public List<T> selectAll(){
        return baseMapper.selectAll();  
    }  
}

6，IAnswersSerivce继承BaseService

package com.yun.apps.poll.service;


import com.yun.apps.poll.base.BaseService;
import com.yun.apps.poll.bean.Answers;

public interface IAnswersService  extends BaseService<Answers>{

}

7，AnswersServiceImpl的实现

package com.yun.apps.poll.service.impl;


import org.springframework.stereotype.Service;

import com.yun.apps.poll.base.impl.AbstractService;
import com.yun.apps.poll.bean.Answers;
import com.yun.apps.poll.service.IAnswersService;

@Service
public class AnswersServiceImpl extends AbstractService<Answers> implements IAnswersService{

    
}

8，controller的调用

package com.yun.apps.poll.web.controller;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.yun.apps.poll.bean.Answers;
import com.yun.apps.poll.result.CodeMsg;
import com.yun.apps.poll.result.Result;
import com.yun.apps.poll.service.IAnswersService;

@RestController
@RequestMapping("/answers")
public class AnswersController {

    @Autowired
    private IAnswersService answersService;
    
    //保存数据成功
    @PostMapping("/saveAnswers")
    public Result<Answers> saveAnswers(Answers answers){
        try {
            answersService.insert(answers);
            return Result.success(answers);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(CodeMsg.COURSE_SAVE_ERROR);
        }
    }
    
    @GetMapping("/delectAnswersById")
    public String delectAnswersById(@RequestParam long id){
        try {
            answersService.deleteByPrimaryKey(id);
            return "成功";
        } catch (Exception e) {
            e.printStackTrace();
            return "失败";
        }
    }
    
    
    @PostMapping("/updateAnswers")
    public String updateAnswers(Answers answers){
        try {
            answersService.updateByPrimaryKey(answers);
            return "成功";
        } catch (Exception e) {
            e.printStackTrace();
            return "失败";
        }
    }
    
    @GetMapping("/findAllAnswers")
    public List<Answers> findAllAnswers(){
        List<Answers> answers = new ArrayList<>();
        try {
            answers = answersService.selectAll();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return answers;
    }
    
}