logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

【原】做Java开发，你需要了解这些

 贪挽懒月 2022-06-20 发布于广东

前言:

在开发中，我们写的代码肯定是越少越好，代码层次越清晰越好。那么下面就介绍一些可以减少代码量、可以让结构更清晰的好东西。本文涉及vo、dto的使用、全局异常处理、表单验证以及一些小工具的使用。

一、lombok的使用：

lombok是一个可以减少代码量的小工具，使用非常简单，只需要添加如下依赖：

  1. <dependency>
  2.     <groupId>org.projectlombok</groupId>
  3.     <artifactId>lombok</artifactId>
  4. </dependency>

如果开发工具为idea，那么再安装一下lombok插件即可。安装方法： setting ---> plugins ---> browse repositories，然后搜索lombok。

如果开发工具是eclipse，安装lombok插件就麻烦一些，百度上有很多教程，此处就不再搬运了。 添加了依赖，安装好了插件，就可以使用了。下面主要介绍它的两个注解。

1、@Data:

我们在写实体类时，每个实体类都要写set、get方法以及toString方法等，虽然编辑器可以自动生成，但还是有些麻烦，而且大量的set、get方法使代码看起来不清爽。那么可以使用 @Data来搞定。在实体类上加上此注解，就相当于写了set、get、toString、equals等方法。

  1. @Entity
  2. @Data
  3. public class OrderDetail {
  4.     @Id
  5.     private String detailId;
  6.     private String orderId;
  7.     private String productId;
  8.     private String productName;
  9.     private BigDecimal productPrice;
  10.     private Integer productQuantity;
  11.     private String productIcon;
  12. }

这样的代码看起来就干净清爽多了。

2、@Slf4j：

这也是一个常用的注解。一般我们需要用日志都会像下面这样写：

  1. Logger log = (Logger) LoggerFactory.getLogger(当前类.class);
  2. log.error("【查询商品】商品不存在，productId={}",productId);

而加了这个注解，就不用自己创建log对象了，要用时直接用 log调用对应方法就行了。

  1. log.error("【查询商品】商品不存在，productId={}",productId);

关于lombok还有好多注解，暂且先介绍这两个常用的。

二、createTime和updateTime问题：

一般的表中，我们都会加上createTime和updateTime两个字段。然后有记录存入数据库时，要 实体.setCreateTime(newDate())来赋值，更新时就要 实体.setUpdateTime(newDate())。每次有新增记录或有更新时都要这样set一下，有些麻烦。其实这两个时间字段可以交给数据库管理。建表时createTime和updateTime字段这样写：

  1. create table 'product_category'(
  2.    ......
  3.    `create_time` timestamp not null default current_timestamp comment '创建时间',
  4.    `update_time` timestamp not null default current_timestamp 
  5.                  on update current_timestamp comment '修改时间',
  6.    ......
  7. )

然后在对应的实体类上加 @DynamicUpdate注解即可实现这两个字段的自动更新。创建时不用setCreateTime，更新时也不用setUpdateTime了。

  1. @Entity
  2. @DynamicUpdate // 动态更新
  3. @Data
  4. public class ProductCategory {
  5.     ......
  6.     private Date createTime;
  7.     private Date updateTime;
  8. }

三、枚举类的使用：

关于枚举类，我之前只是在学Java基础的时候了解过，后来老师教的一些demo中都没用到过，最近看的一个项目用到了，在此记录其用法。先看下面的代码：

  1. @Entity
  2. @Data
  3. public class ProductInfo {
  4.     ......
  5.     private Integer productStatus;//商品状态(0正常，1下架)
  6. }

有一个商品类，productStatus是其状态，0是上架，1是下架。如果现在要查询所有上架商品，那么做法如下：

  1.  List<ProductInfo> productInfoList = 
  2.        productInfoRepository.findByProductStatus(0);

这里可能看得还挺清楚，0表示上架，查询上架的，那么就是productStatus = 0 的，所以传入0即可。但是在项目中，实体类一多，用0和1表示的东西一多，就很容易搞错，到时候自己都要看半天才知道0代表什么1代表什么。这种情况就可以用枚举类来处理。新建一个ProductStatusEnum枚举类：

  1. @Getter
  2. public enum ProductStatusEnum {
  3.     UP(0,"上架"),
  4.     DOWN(1,"下架")
  5.     ;
  6.     private Integer code;
  7.     private String message;
  8.     ProductStatusEnum(Integer code,String message) {
  9.         this.code = code;
  10.         this.message = message;
  11.     }
  12. }

那么查询方法就可以这样写了：

  1. List<ProductInfo> productInfoList = 
  2.       productInfoRepository.findByProductStatus(ProductStatusEnum.UP.getCode());

ProductStatusEnum.UP.getCode()就是0，这样一看就知道是查上架的商品。

四、VO的使用：

VO是view object的简称，中文意思是视图对象，也就是我们在controller中返回给前端的内容。一般开发时，我们要按照前端给的文档给前端返回相应的内容，比如现有api如下：

路由： GET/sell/buyer/product/list参数：无 返回：

  1. {
  2.     "code": 0,
  3.     "msg": "成功",
  4.     "data": [
  5.         {
  6.             "name": "类目名1",
  7.             "type": 1,
  8.             "foods": [
  9.                 {
  10.                     "id": "123456",
  11.                     "name": "商品名1",
  12.                     "price": 4.5,
  13.                     "description": "xxxxx",
  14.                     "icon": "http://",
  15.                 }
  16.             ]
  17.         },
  18.         {
  19.             "name": "类目名2",
  20.             "type": 2,
  21.             "foods": [
  22.                 {
  23.                     "id": "123457",
  24.                     "name": "商品名2",
  25.                     "price": 10.9,
  26.                     "description": "xxxxx",
  27.                     "icon": "http://",
  28.                 },
  29.                 {
  30.                     "id": "123457",
  31.                     "name": "商品名3",
  32.                     "price": 10.9,
  33.                     "description": "xxxxx",
  34.                     "icon": "http://",
  35.                 }
  36.             ]
  37.         }
  38.     ]
  39. }

乍一看很复杂，其实不然。一个中括号就表示里面的是list。那么可以知道，最外层是由code、msg和类目的list组成；第二层就是由类目名name、type和商品的list组成；商品的list就包含了商品的信息。那么要如何构造这样的返回对象呢？先从最外层开始写。根据最外层的三个字段，可以写出ResultVo类：

  1. /**
  2.  * 返回给前端的最外层对象
  3.  * Create by zhu on 2018/10/7
  4.  */
  5. @Data
  6. public class ResultVo<T> {
  7.     private Integer code;//错误码
  8.     private String msg;//提示信息
  9.     private T data;//返回的内容
  10. }

这里data定义为泛型，这样就可以通用。 现在将ResultVo对象返回给前端：

  1.  @GetMapping("/test")
  2.  public ResultVo test(){
  3.         ResultVo resultVo = new ResultVo();
  4.         resultVo.setCode(0);
  5.         resultVo.setMsg("test");
  6.         resultVo.setData("这是内容");
  7.         return resultVo;
  8.  }

就会得到如下效果：说明最外层是没有错的，根据api提供的信息又可以写出如下vo:

  1. @Data
  2. public class ProductVo {
  3.     //这里写的字段名与前端api需要的不一致没关系，加上如下注解，直接里面写api需要的字段名
  4.     @JsonProperty("name")
  5.     private String categoryName;
  6.     @JsonProperty("type")
  7.     private Integer categoryType;
  8.     @JsonProperty("foods")//这个foods是一个商品的list
  9.     private List<ProductInfoVo> productInfoVoList;
  10. }
  1. //这个就是最里层的商品对象
  2. @Data
  3. public class ProductInfoVo {
  4.     @JsonProperty("id")
  5.     private String productId;
  6.     @JsonProperty("name")
  7.     private String productName;
  8.     @JsonProperty("price")
  9.     private BigDecimal productPrice;
  10.     @JsonProperty("description")
  11.     private String productDescription;
  12.     @JsonProperty("icon")
  13.     private String productIcon;
  14. }

注意，前端需要的name其实是类目名，如果这个vo也直接定义变量name，到时候会搞不清楚到底是商品的name还是类目的name。解决方案是：这里应该是什么就写什么，然后通过@JsonProperty("xxx")来指定返回给前端时的名字。

写好后再去controller中：

  1.   @GetMapping("/test")
  2.     public ResultVo test() {
  3.         ResultVo resultVo = new ResultVo();
  4.         ProductVo productVo = new ProductVo();
  5.         ProductInfoVo productInfoVo = new ProductInfoVo();
  7.         productInfoVo.setProductName("商品1");
  8.         productVo.setProductInfoVoList(Arrays.asList(productInfoVo));
  9.         productVo.setCategoryName("类目1");
  11.         resultVo.setData(Arrays.asList(productVo));
  12.         resultVo.setMsg("成功");
  13.         resultVo.setCode(0);
  15.         return resultVo;
  16.     }

把最里层的赋好值设置给中间层，中间层赋好值设置给最外层，再把最外层返回给前端，效果如下：这样返回的格式就对了，和api一致。接下来要做的事就是从数据库查出相应的记录，然后赋给这三个对象就行了。 从上面的controller中可以发现，我们每次都要new一个最外层的ResultVo对象，然后setCode、setMsg、setData。每个方法中都new一个还是很麻烦的，所以可以封装一下：

  1. public class ResultVoUtil {
  2.     /** 成功时使用 */
  3.     public static ResultVo success(Object object){
  4.         ResultVo resultVo = new ResultVo();
  5.         resultVo.setData(object);
  6.         resultVo.setCode(0);
  7.         resultVo.setMsg("成功");
  8.         return resultVo;
  9.     }
  11.     /** 成功时且不需要返回值时使用 */
  12.     public static ResultVo success(){
  13.         return success(null);
  14.     }
  16.     /** 请求错误时使用 */
  17.     public static ResultVo error(Integer code,String msg){
  18.         ResultVo resultVo = new ResultVo();
  19.         resultVo.setCode(code);
  20.         resultVo.setMsg(msg);
  21.         return resultVo;
  22.     }
  23. }

那么上面的controller就可以改成：

  1.  @GetMapping("/test")
  2.     public ResultVo test() {
  3.         ProductVo productVo = new ProductVo();
  4.         ProductInfoVo productInfoVo = new ProductInfoVo();
  6.         productInfoVo.setProductName("商品1");
  7.         productVo.setProductInfoVoList(Arrays.asList(productInfoVo));
  8.         productVo.setCategoryName("类目1");
  10.         return ResultVoUtil.success(Arrays.asList(productVo));
  11.     }

这样代码看起来就简洁多了，而且这个ResultVoUtil也是通用的，传入相应的Object对象即可。

五、使用BeanUtils进行属性拷贝：

上面说到把从数据库查到的productInfo的属性的值赋给productInfoVo对应的属性，这里说一下赋值的问题： ProductInfo类如下：

  1. @Entity
  2. @Data
  3. public class ProductInfo {
  4.     @Id
  5.     private String productId;
  6.     private String productName;
  7.     private BigDecimal productPrice;
  8.     private Integer productStock;//库存
  9.     private String productDescription;//描述
  10.     private String productIcon;//小图
  11.     private Integer productStatus;//商品状态(0正常，1下架)
  12.     private Integer categoryType;//类目编号
  13. }

ProductInfoVo类上面已给出，对比可以发现，ProductInfoVo与ProductInfo相比，就是少几个属性。我们现在从数据库查出来的是productInfo，而前端需要的是productInfoVo，所以需要将productInfo里的值设置到productInfoVo里去。常规做法是先从productInfo中get再set到productInfoVo中去：

  1. ProductInfo productInfo = productService.findOne(productId);
  2. ProductInfoVo productInfoVo = new ProductInfoVo();
  3. productInfoVo.setProductName(productInfo.getProductName());
  4. productInfoVo.setProductPrice(productInfo.getProductPrice());
  5. ......

如果属性少问题也不大，如果属性很多，那么就要写一大堆这样的代码。可以使用spring提供的一个属性拷贝工具，不管多少个属性，只需一行代码：

  1. BeanUtils.copyProperties(productInfo, productInfoVo);

这就表示把productInfo的属性拷贝到productInfoVo对象中去。注意：使用这个工具有两点要注意，第一个就是这两个对象的属性名要一致；第二就是null值也会拷贝进去，所以如果productInfo中有个属性值为null,进行拷贝后productInfoVo对应的属性值也会是null，就算拷贝之前设置了值也会覆盖掉，所以要先拷贝再赋值。

六、dto的使用：

dto全称是data transfer object，中文意思为数据传输对象。那么dto有什么作用？什么时候该用dto？如何使用呢？看下面的例子： 假如我数据库有两张表，一张学生表student，一张班级表class。它们对应的实体类如下：

  1. @Data
  2. public class Student {
  3.     @Id
  4.     private String studentId;
  5.     private String classId;
  6.     private String name;
  7. }
  1. @Data
  2. public class Class {
  3.     @Id
  4.     private String classId;
  5.     private String  className;
  6. }

假如我现在要查一个班级的信息，班级应该是包含了多个学生的，因为一个班级有多个学生，那么通常class实体类应该这样设计：

  1. @Data
  2. public class Class {
  3.     @Id
  4.     private String classId;
  5.     private String  className;
  6.     private List<Student> studentList;
  7. }

那么问题来了，这样实体类和表就对应不上了，因为在class表中没有与studentList这个属性对应的字段。虽然可以在studentList上加上 @Transient注解，这样jpa在与数据表对应时就会忽略这个属性。但是这样不好，感觉就是污染了这个与数据表对应的实体类，我们还是要让实体类与数据表 一 一对应，所以class类不能增加这个字段。那么我们就新建一个实体类，叫ClassDto：

  1. @Data
  2. public class ClassDto {
  3.     private String classId;
  4.     private String  className;
  5.     private List<Student> studentList;
  6. }

这就是dto的作用，最常用的就是当某两个实体类存在关系时，而数据表对应的实体类为了跟数据表一致，没有体现这种关系，那么就可以使用dto。dto不对应数据表，所@Id注解也不需要了。

七、异常处理：

平时我们用异常可能直接throw一个exception就完事了，但是这样不好，因为这样抛出去自己也看不懂是什么异常，所以可以像下面这样处理：自定义一个异常类继承RuntimeException：

  1. public class GlobalException extends RuntimeException{
  2.     private Integer code;
  3.     public GlobalException(ExceptionEnum exceptionEnum ){
  4.         super(resultEnum.getMessage());
  5.         this.code = resultEnum.getCode();
  6.     }
  8.     public GlobalException(Integer code,String message){
  9.         super(message);
  10.         this.code = code;
  11.     }
  13. }

用到的枚举类：

  1. @Getter
  2. public enum ExceptionEnum {
  3.     PRODUCT_NOT_EXIST(10,"商品不存在"),
  4.     PRODUCT_STOCK_ERROR(11,"库存不足"),
  5.     ;
  6.     private Integer code;
  7.     private String message;
  9.     ExceptionEnum (Integer code, String message) {
  10.         this.code = code;
  11.         this.message = message;
  12.     }
  13. }

自定义一个异常类，搭配枚举一起使用。那么在抛异常的时候就可以这样写：

  1. throw new GlobalException(ExceptionEnum.PRODUCT_NOT_EXIST);

这样前端就可以看到“商品不存在”这样的提示，而不是一串看不懂的异常。枚举类种我只是列举了两个例子，有异常就可以往枚举种添加，然后像上面那样用就行了。

八、生成随机数：

有时候数据表的Id没有设置自增，需要我们自己设置Id。Id要求是必须唯一，提供如下工具类：

  1. public class KeyUtil {
  2.     /**
  3.      * 生成唯一主键
  4.      * 格式：当前时间+随机数
  5.      */
  6.     public static synchronized String genUniqueKey(){
  7.         Random random = new Random();
  8.         //Integer a =random.nextInt(90) + 10;//生成两位随机数
  9.         //生成六位随机数
  10.         Integer number =random.nextInt(900000) + 100000;
  11.         return  System.currentTimeMillis() + String.valueOf(number);
  13.     }
  14. }

九、表单验证：

前端给后台传参数的时候，我们要在controller中获取前端传入的参数，一般有以下几种做法：

  • HttpServletRequest: 用这个一般要编写一个工具类，用来获取指定类型的参数：

  1. public class HttpServletRequestUtil {
  2.     public static int getInt(HttpServletRequest request, String name) {
  3.         try {
  4.             return Integer.decode(request.getParameter(name));
  5.         } catch (Exception e) {
  6.             return -1;
  7.         }
  8.     }
  10.     public static long getLong(HttpServletRequest request, String name) {
  11.         try {
  12.             return Long.valueOf(request.getParameter(name));
  13.         } catch (Exception e) {
  14.             return -1;
  15.         }
  16.     }
  18.     public static Double getDouble(HttpServletRequest request, String name) {
  19.         try {
  20.             return Double.valueOf(request.getParameter(name));
  21.         } catch (Exception e) {
  22.             return -1d;
  23.         }
  24.     }
  26.     public static Boolean getBoolean(HttpServletRequest request, String name) {
  27.         try {
  28.             return Boolean.valueOf(request.getParameter(name));
  29.         } catch (Exception e) {
  30.             return false;
  31.         }
  32.     }
  34.     public static String getString(HttpServletRequest request, String name) {
  35.         try {
  36.             String result = request.getParameter(name);
  37.             if (result != null) {
  38.                 result = result.trim();
  39.             }
  40.             if ("".equals(result))
  41.                 result = null;
  42.             return result;
  43.         } catch (Exception e) {
  44.             return null;
  45.         }
  46.     }
  47. }

然后在controller中这样用：

  1. @RequestMapping(value = "/getproductlistbyshop")
  2. public ResultVo list(HttpServletRequest request) {
  3.         // 获取前台传过来的页码
  4.         int pageIndex = HttpServletRequestUtil.getInt(request, "pageIndex");
  5.         // 获取前台传过来的每页显示的数量
  6.         int pageSize = HttpServletRequestUtil.getInt(request, "pageSize");
  7.                 ......
  8. }

但是这样获取参数，如果要校验的话需要自己写if语句来判断，比如：

  1. if (pageIndex == null || pageSize == null){
  2.     log.error(...);
  3.     throw new GlobalException(...);
  4. }

看第二种获取前端参数的方法：

  • @RequestParam：

  1.  @GetMapping("/list")
  2.  public ResultVo list(@RequestParam(value = "page",defaultValue = "0") Integer page,
  3.                       @RequestParam(value = "size",defaultValue = "10") Integer size){
  4.        ......    
  5.     }

用这个还可以用defaultValue指定默认值，当前端没传时默认就为defaultValue指定的值。这种方法呢其实就是第一种方法的注解形式，如果要对获取的参数判断，还是要自己写if语句。 接下来看第三种方法：

  • 表单对象： 如果前端传过来的参数很多，用上面两种方法写未免有些麻烦，而且还要自己一个个的判断传过来的参数是否为空，为空的话又要给前端什么提示。我们可以把前端的参数封装成一个对象，然后在controller中直接获取该对象即可，而且对于参数的验证都可以在封装的这个对象中完成，这就是springmvc提供的表单验证。看例子：

  1. @Data
  2. public class OrderForm {
  3.     @NotEmpty(message = "姓名必填")
  4.     private String name;
  5.     @NotEmpty(message = "手机号必填")
  6.     private String phone;
  7.     @NotEmpty(message = "地址必填")
  8.     private String address;
  9.     @NotEmpty(message = "openid必填")
  10.     private String openid;
  11.     @NotEmpty(message = "购物车不能为空")
  12.     private String items;
  13. }

比如从前端获取的参数有这么多，那么就可以封装成这样一个OrderForm表单对象。加上 @NotEmpty注解就表示这个参数不能为空，里面的message就是当该参数为空时给前端的提示。接下来看如何在controller中使用该对象：

  1. @PostMapping("/create")
  2.  public ResultVo create(@Valid OrderForm orderForm, BindingResult bindingResult){
  3.       //判断表单校验后有没有错误
  4.       if (bindingResult.hasErrors()) {
  5.           log.error("【创建订单】参数不正确，orderForm={}",orderForm);
  6.           throw new GlobalException(ExceptionEnum.PARAM_ERROR.getCode(),
  7.                     bindingResult.getFieldError().getDefaultMessage());
  8.       }
  9.       ......
  10. }

用 @Valid注解就可以使用该对象，bindingResult就是验证的结果，如果验证参数不正确，通过 bindingResult.getFieldError().getDefaultMessage()就可以获取到刚才 @NotEmpty注解里面message的内容，配合全局异常使用，就可以把这个message返回给前端。

总结：

上面的介绍的lombok、创建时间和更新时间的处理、BeanUtils的使用都可以减少代码量，而dto、vo、全局异常处理、表单验证等可以使代码结构更加清晰，使程序更加健壮。希望大家喜欢！

    转藏 分享 献花（0）

    来自： 贪挽懒月 > 《待分类》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多