SpringBoot 常用注解和项目常用工具类

红太狼 2021-09-20 14:16 433阅读 0赞

*  @SpringBootApplication 用于springboot的启动类上，相当于三个注解@EnableAutoConfig(启动自动配置) ， @CompentScen 表示开启组件扫描， @Config表示是一个配置类
 *  @Controller, 放类上面，表示是一个controller, 每个方法返回默认是 跳转的地址
 *  @RestController, 放类上面，表示是一个controller, 每个方法返回默认是 Json对象。 @Controller里面的方法也可返回Json就需要多写一个注解，在方法的上面加一个@ResponseBody.
 *  @RequestMapping 在controller上，设置拦截路径，同时支持Post和Get
 *  @GetMapping 在controller上，设置拦截路径，只支持Get请求
 *  @PostMapping 在controller上，设置拦截路径，只支持Post请求

# SpringBoot和SpringMVC的区别 #

*  SpringBoot 是SpringMVC的基础上改进的，主要是少了很多配置文件
 *  只有SpringBoot里面有@RestControlle
 *  只有SpringBoot里面有@SpringBootApplication
 *  SpringBoot 内置了Tomcat服务器

# 常用工具类 #

package com.zz.vo;
    
    import lombok.Data;
    
    /**
     * http请求返回的最外层对象
     * Created by Bsea
     * 2017-05-12 14:13
     */
    @Data
    public class ResultVO<T> {
    
        /** 结果. */
        private boolean success;
    
        /** 错误码. */
        private Integer errorCode;
    
        /** 提示信息. */
        private String msg;
    
        /** 具体内容. */
        private T body;
    }

package com.zz.util;
    
    
    import com.zz.vo.ResultPaginationVO;
    import com.zz.vo.ResultVO;
    
    /**
     * Created by Bsea
     * 2017-05-15 00:22
     */
    public class ResultVOUtil {
    
        public static ResultVO success(Object object) {
            ResultVO resultVO = new ResultVO();
            resultVO.setBody(object);
            resultVO.setErrorCode(-1);
            resultVO.setMsg("成功");
            resultVO.setSuccess(true);
    
            return resultVO;
        }
    
        public static ResultVO success(Object object, int next, boolean isNext) {
            ResultPaginationVO resultVO = new ResultPaginationVO();
            resultVO.setBody(object);
            resultVO.setErrorCode(-1);
            resultVO.setMsg("成功");
            resultVO.setSuccess(true);
            resultVO.setNext(next);
            resultVO.setHasNext(isNext);
    
            return resultVO;
        }
    
        public static ResultVO success() {
            return success(null);
        }
    
        public static ResultVO error(Integer code, String msg) {
            ResultVO resultVO = new ResultVO();
            resultVO.setErrorCode(code);
            resultVO.setMsg(msg);
            resultVO.setSuccess(false);
            return resultVO;
        }
    }

package com.zz.exception;
    
    import com.zz.enums.ResultEnum;
    import lombok.Getter;
    
    /**
     * Created by Bsea
     * 2019-06-11 18:55
     */
    @Getter
    public class OrderException extends RuntimeException{
    
        private Integer code;
    
        public OrderException(ResultEnum resultEnum) {
            super(resultEnum.getMessage());
    
            this.code = resultEnum.getCode();
        }
    
        public OrderException(Integer code, String message) {
            super(message);
            this.code = code;
        }
    }

package com.zz.controller;
    
    import com.zz.VO.ResultVO;
    import com.zz.dto.OrderDTO;
    import com.zz.entity.OrderDetail;
    import com.zz.entity.OrderMaster;
    import com.zz.enums.ResultEnum;
    import com.zz.exception.OrderException;
    import com.zz.form.OrderForm;
    
    import com.zz.service.OrderService;
    import com.zz.utils.ResultVOUtil;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiImplicitParam;
    import io.swagger.annotations.ApiImplicitParams;
    import io.swagger.annotations.ApiOperation;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.PageRequest;
    import org.springframework.util.StringUtils;
    import org.springframework.validation.BindingResult;
    import org.springframework.web.bind.annotation.*;
    
    import javax.validation.Valid;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /**
     * Created by Bsea
     * 2019-06-18 23:27
     */
    @Api(value = "订单控制器")
    @RestController
    @RequestMapping("/order")
    @Slf4j
    public class OrderController {
    
        @Autowired
        private OrderService orderService;
    
    //    @Autowired
    //    private BuyerService buyerService;
    
        //创建订单
        @PostMapping("/create")
        @ApiOperation(value = "创建订单", notes = "创建订单")
    
        public ResultVO<Map<String, String>> create(@Valid OrderForm orderForm,
                                                    BindingResult bindingResult) {
            if (bindingResult.hasErrors()) {
                log.error("【创建订单】参数不正确, orderForm={}", orderForm);
                throw new OrderException(ResultEnum.PARAM_ERROR.getCode(),
                        bindingResult.getFieldError().getDefaultMessage());
            }
    
    
    
            OrderMaster createResult = orderService.create(orderForm);
    
            Map<String, String> map = new HashMap<>();
            map.put("orderId", createResult.getOrderId());
    
            return ResultVOUtil.success(map);
        }
    
        //订单列表
        @GetMapping("/list")
        @ApiOperation(value = "订单列表", notes = "分页订单列表")
        @ApiImplicitParams({
                @ApiImplicitParam(name = "openid", value = "用户微信唯一标识符", required = true, dataType = "String"),
                @ApiImplicitParam(name = "page", value = "第几页", required = true, dataType = "Integer"),
                @ApiImplicitParam(name = "size", value = "一页显示记录", required = true, dataType = "Integer")
        })
        public ResultVO<List<OrderDTO>> list(@RequestParam("openid") String openid,
                                             @RequestParam(value = "page", defaultValue = "0") Integer page,
                                             @RequestParam(value = "size", defaultValue = "10") Integer size) {
            if (StringUtils.isEmpty(openid)) {
                log.error("【查询订单列表】openid为空");
                throw new OrderException(ResultEnum.PARAM_ERROR);
            }
            PageRequest request = PageRequest.of(page, size);
            Page<OrderMaster> orderDTOPage = orderService.findList(openid, request);
    
            return ResultVOUtil.success(orderDTOPage.getContent());
        }
    
    
        //订单详情
        @GetMapping("/detail")
        @ApiOperation(value = "订单详情", notes = "订单详情")
        @ApiImplicitParams({
    
                @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "String")
        })
        public ResultVO<OrderDetail> detail(@RequestParam("orderId") String orderId) {
    
            return ResultVOUtil.success(orderService.findDetail(orderId));
        }
    
        //取消订单
        @PostMapping("/cancel")
        @ApiOperation(value = "取消订单", notes = "取消订单")
        @ApiImplicitParams({
    
                @ApiImplicitParam(name = "orderId", value = "订单ID", required = true, dataType = "String")
        })
        public ResultVO cancel(
                               @RequestParam("orderId") String orderId) {
            orderService.cancel(orderId);
            return ResultVOUtil.success();
        }
    }