前端数据到后端

前端到后端流程

项目和包：

先写dao

import com.changgou.goods.pojo.Brand;
import tk.mybatis.mapper.common.Mapper;

/**
 * 品牌dao。使用通用mapper
 * dao接口需要继承Mapper接口
 *      此时根本不需要写dao，直接从service开始写
 */
public interface BrandMapper extends Mapper<Brand>{

}

service

import com.changgou.goods.pojo.Brand;
import com.github.pagehelper.PageInfo;

import java.util.List;

public interface BrandService {

    /**
     * 查询所有，返回的是一个list集合
     */
    public List<Brand> findAll();

    /**
     * 根据id进行查询
     */
    public Brand findById(Integer id);


    /**
     * 增加品牌
     * 前端传入一个品牌对象，然后后端接收这个对象调用添加的方法完成赋值
     */
    public void addBrand(Brand brand);

    /**
     * 修改操作
     */
    public void updateBrand(Brand brand);

    /**
     * 根据id删除品牌
     */
    public void deleteBrandById(Integer id);

    /**
     * 品牌条件查询：
     *      业务情况：用户可能根据品牌首字母查询，也可能根据品牌首字母查询
     *      根据传入的对象，如果传入的对象的名字则根据名字查询
     *      如果传入的是首字母，则根据首字母查询
     */
    public List<Brand> findList(Brand brand);


    /**
     * 条件搜索
     *      当前页
     *      每页显示的条数
     * 返回对象时pageInfo
     * 这个是通用分页插件中的对象
     */
    public PageInfo<Brand> findPage(Integer page,Integer size);

    /**
     * 条件分页搜索,方法重载
     */
    public PageInfo<Brand> findPage(Brand brand,Integer page,Integer size);

}

impl

import com.changgou.dao.BrandMapper;
import com.changgou.goods.pojo.Brand;
import com.changgou.service.BrandService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.List;

@Service
public class BrandServiceImpl implements BrandService
{
    @Autowired
    private BrandMapper brandMapper;
    /**
     * mapper.selectAll()
     * 继承了父类，直接可以用父类中的方法
     * @return
     */
    @Override
    public List<Brand> findAll() {
//        List<Brand> brands = brandMapper.selectAll();
//        brands.forEach(System.out::println);
        return brandMapper.selectAll();
    }

    /**
     * 根据id查询品牌
     * @param id
     * @return
     */
    @Override
    public Brand findById(Integer id) {
        //根据主键进行查询
        return brandMapper.selectByPrimaryKey(id);
    }

    /**
     * 添加品牌
     * Selective,如果通用mapper中的方法带有Selective表示会忽略空值
     *      拼接sql语句
     * @param brand
     */
    @Override
    public void addBrand(Brand brand) {
        brandMapper.insertSelective(brand);
    }

    /**
     * 品牌的修改，根据id来进行修改
     * 会根据被修改的内容将对象修改掉
     * @param brand
     */
    @Override
    public void updateBrand(Brand brand) {
        brandMapper.updateByPrimaryKeySelective(brand);
    }

    /**
     * 根据id删除品牌
     * @param id
     */
    @Override
    public void deleteBrandById(Integer id) {
        brandMapper.deleteByPrimaryKey(id);
    }

    /**
     * 根据条件查询
     * @param brand
     * @return
     */
    // @Override
    public List<Brand> findList1(Brand brand) {
        /**
         * 自定义条件搜索对象.导入tk包
         */
        Example example = new Example(Brand.class);
        //条件构造器
        Example.Criteria criteria = example.createCriteria();
        //条件的组装
        if (brand!=null){
            //名字不为空
            if (!StringUtils.isEmpty(brand.getName())){
                /**
                 * 方法参数,因为是拼接语句底层
                 *      1:属性名
                 *      2：方法搜索的条件
                 */
                criteria.andLike("name","%"+brand.getName()+"%");
            }
            if (!StringUtils.isEmpty(brand.getLetter())){
                criteria.andEqualTo("letter",brand.getLetter());
            }

        }
        return brandMapper.selectByExample(example);
    }


    /**
     * 条件查询的抽取
     */
    public Example createExample(Brand brand){
        /**
         * 自定义条件搜索对象.导入tk包
         */
        Example example = new Example(Brand.class);
        //条件构造器
        Example.Criteria criteria = example.createCriteria();
        //条件的组装
        if (brand!=null){
            //名字不为空
            if (!StringUtils.isEmpty(brand.getName())){
                /**
                 * 方法参数,因为是拼接语句底层
                 *      1:属性名
                 *      2：方法搜索的条件
                 */
                criteria.andLike("name","%"+brand.getName()+"%");
            }
            if (!StringUtils.isEmpty(brand.getLetter())){
                criteria.andEqualTo("letter",brand.getLetter());
            }

        }
        return example;

    }

    /**
     *
     * @param brand
     * @return
     */
    @Override
    public List<Brand> findList(Brand brand) {
        //调用本类的方法构建条件来完成
        Example example = createExample(brand);
        return brandMapper.selectByExample(example);
    }

    /**
     * 分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Brand> findPage(Integer page, Integer size) {
        PageHelper.startPage(page,size);
        //需要跟着集合查询
        List<Brand> brands = brandMapper.selectAll();

        /**
         * 返回对象时PageInfo，封装这么一个对象
         */

        return new PageInfo<Brand>(brands);
    }

    /**
     * 条件分页搜索
     * @param brand
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Brand> findPage(Brand brand, Integer page, Integer size) {
        //设置分页
        PageHelper.startPage(page,size);
        //构造条件
        Example example = createExample(brand);
        //查询
        List<Brand> brands = brandMapper.selectByExample(example);
        //封装返回结果
        return new PageInfo<Brand>(brands);
    }

}

controller

import com.changgou.goods.pojo.Brand;
import com.changgou.service.BrandService;
import com.github.pagehelper.PageInfo;
import entity.Result;
import entity.StatusCode;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
//访问，加入这个注解后，会被全局异常处理器给管控异常处理
@RequestMapping(value = "/brand")
//跨域
@CrossOrigin
public class BrandController {

    @Autowired
    private BrandService brandService;

    /**
     * 查询所有的品牌
     * 查询所有品牌，前端传入数据,swagger中要求返回的数据是一个Result
     */
    @GetMapping
    public Result<List<Brand>> findAll(){
        List<Brand> brands = brandService.findAll();
        //需要返回的是一个Result对象,使用这个对象的构造函数创造对象
        /**
         * 第一个参数表示操作是否成功
         * 第二个是状态码
         * 第三个是信息
         * 第四个是返回的数据
         */
        return new Result<List<Brand>>(true, StatusCode.OK,"品牌集合查询成功",brands);
    }

    /**
     * 根据主键id进行查询
     * @PathVariable(value = "id")，将注解中的值抽取出来，作为id
     */
    @GetMapping(value = "/{id}")
    public Result<Brand> findById(@PathVariable(value = "id") Integer id){
        Brand byId = brandService.findById(id);
        return new Result<Brand>(true, StatusCode.OK,"品牌id查询成功",byId);
    }

    /**
     * 品牌的增加
     * 前端的传入的数据，如果是json数据，想要转成对象
     *      需要添加一个胡姐@RequestBody
     * 项目中具体的返回类型看swagger文档然后自己创建
     */
    @PostMapping
    public Result addBrand(@RequestBody Brand brand){
        brandService.addBrand(brand);
        return new Result(true, StatusCode.OK,"新增品牌查询成功");
    }

    /**
     * 修改品牌
     * 接收一个前端的对象，还要拿到这个对象的id
     *
     */
    @PutMapping(value = "/{id}")
    public Result updateBrand(@PathVariable(value = "id")Integer id,@RequestBody Brand brand){
        brand.setId(id);
        brandService.updateBrand(brand);
        return new Result(true,StatusCode.OK,"修改成功");
    }

    /**
     * 根据id删除品牌
     */
    @DeleteMapping(value = "/{id}")
    public Result deleteBrandById(@PathVariable(value = "id")Integer id){
        brandService.deleteBrandById(id);
        return new Result(true,StatusCode.OK,"删除品牌成功");
    }

    /**
     * 条件查询
     */
    @PostMapping(value = "/search")
    public Result<List<Brand>> findList(@RequestBody Brand brand){
        List<Brand> list = brandService.findList(brand);
        return new Result<List<Brand>>(true, StatusCode.OK,"条件搜索查询成功",list);
    }

    /**
     * 分页查询
     */
    @GetMapping(value = "/search/{page}/{size}")
    public Result<PageInfo<Brand>> findPage(@PathVariable(value = "page")Integer page,
                                    @PathVariable(value = "size")Integer size){
        PageInfo<Brand> pageInfo = brandService.findPage(page, size);
        return new Result<PageInfo<Brand>>(true,StatusCode.OK,"分页查询成功",pageInfo);

    }

    /**
     * 条件分页搜索
     */
    @PostMapping(value = "/search/{page}/{size}")
    public Result<PageInfo<Brand>> findPage(@RequestBody Brand brand,@PathVariable(value = "page")Integer page,
                                            @PathVariable(value = "size")Integer size){
        PageInfo<Brand> pageInfo = brandService.findPage(brand,page, size);
        return new Result<PageInfo<Brand>>(true,StatusCode.OK,"条件分页查询成功",pageInfo);

    }
}

全局异常处理

import entity.Result;
import entity.StatusCode;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 全局异常处理
 *      @ControllerAdvice这个注解会识别@RequestMapping()注解类中方法的异常
 */
@ControllerAdvice
public class GloabalExceptionHandler {
    /***
     * 异常处理
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public Result error(Exception e) {
        e.printStackTrace();
        return new Result(false, StatusCode.ERROR, e.getMessage());
    }
}