2. 程式人生 > >自定義註解驗證引數

自定義註解驗證引數

阿新 • • 發佈：2019-01-30

使用註解去驗證某個物件屬性是否按照我們的註解來賦值的。

例子：我們需要定義一個MyLimit的註解，這個註解裡面規定了類屬性的限制；編寫註解解析；在類中屬性使用註解；最後測試是否是我們需要的效果。

定義MyLimit註解：

[java] view plain copy print?
  1. @Target({ ElementType.FIELD })  
  2. // 標註只能放在類或介面的註解
  3. @Retention(RetentionPolicy.RUNTIME)  
  4. // 在執行時有效
  5. public@interface MyLimit {  
  6.     //這個欄位是否為必填
  7.     boolean isNotNull() default
    false;  
  8.     // 欄位描述
  9.     String description() default“”;  
  10.     int MaxLength() default0;  
  11.     int MinLength() default0;  
  12.     //表示這個欄位是否為int型別
  13.     boolean isInt() defaultfalse;  
  14.     int MaxNum() default30;  
  15.     int MinNum() default18;  
  16. }  
@Target({ ElementType.FIELD })
// 標註只能放在類或介面的註解
@Retention(RetentionPolicy.RUNTIME)
// 在執行時有效
public @interface MyLimit {
    //這個欄位是否為必填
    boolean isNotNull() default false;
    // 欄位描述
    String description() default "";
    int MaxLength() default 0;
    int MinLength() default 0;
    //表示這個欄位是否為int型別
    boolean isInt() default false;
    int MaxNum() default 30;
    int MinNum() default 18;
}
編寫註解的解析：VerifyAnnotationMyLimit類，這個裡面使用一個List來存放驗證的錯誤資訊，getListExceptions()方法返回這個List，可以通過annotationMyLimit.getListExceptions().size()!=0來判斷驗證是否成功，不成功可以取得錯誤資訊：

VerifyAnnotationMyLimit：

[java] view plain copy print?
  1. import java.lang.reflect.Field;  
  2. import java.util.ArrayList;  
  3. publicclass VerifyAnnotationMyLimit {  
  4.     private MyLimit limit;  
  5.     private Class obj;  
  6.     private ArrayList<Exception> ListExceptions;  
  7.     public VerifyAnnotationMyLimit(Object object) throws Exception {  
  8.         obj = object.getClass();  
  9.         ListExceptions = new ArrayList<Exception>();  
  10.         Field[] fields = obj.getDeclaredFields();  
  11.         for (Field field : fields) {  
  12.             // 設定field為private時設定可以訪問許可權,
  13.             field.setAccessible(true);  
  14.             // 開始驗證
  15.             verify(field, object);  
  16.             // 重新對field設定許可權
  17.             field.setAccessible(false);  
  18.         }  
  19.     }  
  20.     public ArrayList<Exception> getListExceptions() {  
  21.         return ListExceptions;  
  22.     }  
  23.     privatevoid verify(Field field, Object object) throws Exception {  
  24.         limit = field.getAnnotation(MyLimit.class);  
  25.         // 檢查這個field是否被MyLimit註釋
  26.         if (!field.isAnnotationPresent(MyLimit.class)) {  
  27.             return;  
  28.         }  
  29.         // 取出object物件中的field值
  30.         Object objectvalue = field.get(object);  
  31.         String description = ”“.equals(limit.description()) ? field.getName()  
  32.                 : limit.description();  
  33.         // 先驗證是否為必填，如果必填且value為空，則丟擲異常，如果不是必填，那我們
  34.         if (limit.isNotNull()) {  
  35.             if (“”.equals(objectvalue) || objectvalue == null) {  
  36.                 ListExceptions.add(new Exception(description + “不能為空”));  
  37.             }  
  38.         } else {  
  39.             // 不是必填項先檢查是否有值，沒有就直接返回，有就繼續向下驗證
  40.             if (objectvalue == null) {  
  41.                 return;  
  42.             }  
  43.         }  
  44.         if (limit.isInt()) {  
  45.             int value = Integer.valueOf(objectvalue.toString());  
  46.             if (value < limit.MinNum() || value > limit.MaxNum()) {  
  47.                 ListExceptions.add(new Exception(description + “必須在”
  48.                         + limit.MinNum() + ”到” + limit.MaxNum() + “之間”));  
  49.             }  
  50.             return;  
  51.         }  
  52.         if (objectvalue.toString().length() < limit.MinLength()  
  53.                 || objectvalue.toString().length() > limit.MaxLength()) {  
  54.             ListExceptions.add(new Exception(description + “長度必須在”
  55.                     + limit.MinLength() + ”到” + limit.MaxLength() + “之間”));  
  56.         }  
  57.     }  
  58. }  
import java.lang.reflect.Field;
import java.util.ArrayList;

public class VerifyAnnotationMyLimit {
    private MyLimit limit;
    private Class obj;
    private ArrayList<Exception> ListExceptions;

    public VerifyAnnotationMyLimit(Object object) throws Exception {
        obj = object.getClass();
        ListExceptions = new ArrayList<Exception>();
        Field[] fields = obj.getDeclaredFields();
        for (Field field : fields) {
            // 設定field為private時設定可以訪問許可權,
            field.setAccessible(true);
            // 開始驗證
            verify(field, object);
            // 重新對field設定許可權
            field.setAccessible(false);

        }
    }

    public ArrayList<Exception> getListExceptions() {
        return ListExceptions;
    }

    private void verify(Field field, Object object) throws Exception {
        limit = field.getAnnotation(MyLimit.class);
        // 檢查這個field是否被MyLimit註釋
        if (!field.isAnnotationPresent(MyLimit.class)) {
            return;
        }
        // 取出object物件中的field值
        Object objectvalue = field.get(object);
        String description = "".equals(limit.description()) ? field.getName()
                : limit.description();

        // 先驗證是否為必填，如果必填且value為空，則丟擲異常，如果不是必填，那我們
        if (limit.isNotNull()) {
            if ("".equals(objectvalue) || objectvalue == null) {
                ListExceptions.add(new Exception(description + "不能為空"));
            }
        } else {
            // 不是必填項先檢查是否有值，沒有就直接返回，有就繼續向下驗證
            if (objectvalue == null) {
                return;
            }
        }

        if (limit.isInt()) {
            int value = Integer.valueOf(objectvalue.toString());
            if (value < limit.MinNum() || value > limit.MaxNum()) {
                ListExceptions.add(new Exception(description + "必須在"
                        + limit.MinNum() + "到" + limit.MaxNum() + "之間"));
            }
            return;
        }

        if (objectvalue.toString().length() < limit.MinLength()
                || objectvalue.toString().length() > limit.MaxLength()) {
            ListExceptions.add(new Exception(description + "長度必須在"
                    + limit.MinLength() + "到" + limit.MaxLength() + "之間"));
        }
    }
}
Students類時註解的使用者： [java] view plain copy print?
  1. publicclass Students {  
  2.     privateint id;  
  3.     @MyLimit(description=“學生的姓名”,MaxLength=5,MinLength=2,isNotNull=true)  
  4.     private String name;  
  5.     @MyLimit(description=“學生的年齡”,isNotNull=true,isInt=true)  
  6.     privateint age;  
  7.     @MyLimit(MaxLength=200,isNotNull=true)  
  8.     private String addr;  
  9.     @MyLimit(description=“學生所在城市”,MaxLength=20)  
  10.     private String city;  
  11.     set…get…  
  12.     @Override
  13.     public String toString() {  
  14.         return“Students [id=” + id + “, name=” + name + “, age=” + age  
  15.                 + ”, addr=” + addr + “, city=” + city + “]”;  
  16.     }     
  17. }  
public class Students {
    private int id;
    @MyLimit(description="學生的姓名",MaxLength=5,MinLength=2,isNotNull=true)
    private String name;
    @MyLimit(description="學生的年齡",isNotNull=true,isInt=true)
    private int age;
    @MyLimit(MaxLength=200,isNotNull=true)
    private String addr;
    @MyLimit(description="學生所在城市",MaxLength=20)
    private String city;
    set...get...
    @Override
    public String toString() {
        return "Students [id=" + id + ", name=" + name + ", age=" + age
                + ", addr=" + addr + ", city=" + city + "]";
    }   
}
在Students類中我們沒有在id的屬性上設定註解，所以不會對id進行驗證；對name屬性設定規定了長度在2到5之間，而且是必填項；在age上規定了這個是必填項，是一個int型別的，所以會使用註解對int型別預設的範圍18到哦30之間；而對於addr屬性只是規定了200長度，但是必填。

最後到了測試部分：

[java] view plain copy print?
  1. publicstaticvoid main(String[] args) {  
  2.         // TODO Auto-generated method stub
  3.         Students students = new Students();  
  4.         students.setName(”abcdefghijklmn”);  
  5.         students.setAddr(”“);  
  6.         students.setAge(230);  
  7.         try {//傳人Students物件進行驗證
  8.             VerifyAnnotationMyLimit annotationMyLimit = new VerifyAnnotationMyLimit(students);  
  9.             if(annotationMyLimit.getListExceptions().size()!=0){  
  10.                 for (Exception exception : annotationMyLimit.getListExceptions()) {  
  11.                     System.out.println(”錯誤：”+exception.getMessage());  
  12.                 }  
  13.             }  
  14.         } catch (Exception e) {  
  15.             // TODO Auto-generated catch block
  16.             System.out.println(e.getMessage());  
  17.             e.printStackTrace();  
  18.         }  
  19.         System.out.println(students.toString());  
  20.     }  
public static void main(String[] args) {
        // TODO Auto-generated method stub
        Students students = new Students();
        students.setName("abcdefghijklmn");
        students.setAddr("");
        students.setAge(230);
        try {//傳人Students物件進行驗證
            VerifyAnnotationMyLimit annotationMyLimit = new VerifyAnnotationMyLimit(students);
            if(annotationMyLimit.getListExceptions().size()!=0){
                for (Exception exception : annotationMyLimit.getListExceptions()) {
                    System.out.println("錯誤："+exception.getMessage());
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            System.out.println(e.getMessage());
            e.printStackTrace();
        }

        System.out.println(students.toString());
    }

if(annotationMyLimit.getListExceptions().size()!=0)判斷是驗證有錯誤；

for (Exception exception : annotationMyLimit.getListExceptions()) {
System.out.println(“錯誤：”+exception.getMessage());//輸出錯誤資訊。
}
結果：


當我們改動一些值時：

[java] view plain copy print?
  1. students.setName(“張三”);  
  2. students.setAddr(”xxx省xxx市xxx縣”);  
  3. students.setAge(23);  
       students.setName("張三");
        students.setAddr("xxx省xxx市xxx縣");
        students.setAge(23);

我們按照規定填寫時就沒有錯誤了，

但是這樣還是有弊端的，因為我們是使用已經設定好屬性的物件去驗證了，等於是先給Students賦值，再去驗證我們賦值是否正確，有了一些中間操作。

相關推薦

自定義註解驗證引數

使用註解去驗證某個物件屬性是否按照我們的註解來賦值的。 例子：我們需要定義一個MyLimit的註解，這個註解裡面規定了類屬性的限制；編寫註解解析；在類中屬性使用註解；最後測試是否是我們需要的效果。 定義MyLimit註解： [java] view plain copy print?@Target({ El

SpringMVC自定義註解進行引數校驗

在我的另一篇部落格中（SpringMVC），學習瞭如何使用Spring MVC結合Hibernate的校驗框架validation（它和hibernate沒有任何關係）對引數進行校驗。在實際專案中，引數的校驗邏輯可能比較複雜，這時我們可以自定義註解來實現引數校驗，下面是一個簡單的例子。 po

java 自定義註解驗證 （僅限於實體屬性值上的註解）

資源下載地址：http://download.csdn.net/detail/weilai_zhilu/9761533   該驗證主要包含三部分 註解驗證類 註解處理方法類 實體類 測試類 第一部分：註解驗證類（此部分暫時只寫了三個驗證類） 下面

Spirng自定義註解(驗證身份證+性別+地區)

第一步：定義註解   MyDateTimeFormat： package com.wbg.maven1128.intface; import java.lang.annotation.*; @Documented @Retention(RetentionPolicy.

SpringMVC自定義註解進行引數校驗（以校驗列舉值是否合法為例）

pom引入springMVC依賴，以springboot專案為例 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-

自定義註解完成引數校驗

在現在的專案開發中，經常會用到註解，比如Spring的@Autowired，SpringMVC的@Controller，@RequestMapping等等，大部分人只知道用，不知道這些註解的怎麼發揮作用。有沒有想過手動寫一個註解，完成引數校驗呢？ 簡介 註解（

自定義註解驗證

註解類 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy

【Java】——自定義註解對引數進行校驗、spring掃描自定義註解

前提    上篇部落格中詳細介紹自定義註解的使用，本文主要是對自定義註解的進一步深入。會使用CGLIb進行動態代理來完成對方法引數是否為空的判斷，以及再spring中如何掃描自定義註解自定義註解對方法引數為空校驗為什麼要用動態代理？因為Java的反射拿不到引數的相關資訊，對方

自定義註解+springAop實現引數的分組驗證

廢話：一個同事寫的，感覺很實用，然後我從中整理出來的一個小demo。 問題引入 在日常開發中免不了對傳入的引數進行校驗，例如更新資料的時候id不能為空，新增資料的時候某個元素不能為空等。我們不得不寫類似於下面的程式碼： @RequestMa

基於springboot通過自定義註解和AOP實現許可權驗證

這篇文章主要介紹自定義註解配合AOP的使用來完成一個簡單的許可權驗證的功能。 一、移入依賴 <parent> <groupId>org.springframework.boot</groupId> <artifactId>sprin

自定義註解 @Target @Retention 引數含義

示例： @Target(value = {ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface MyAnnotation { long time() de

java @Target 自定義註解 校驗引數是否為空

第一步自定義類 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; impor

用AOP攔截自定義註解並獲取註解屬性與上下文引數（基於Springboot框架）

目錄 AOP可以用於日誌的設計，這樣話就少不了要獲取上下文的資訊，博主在設計日誌模組時考慮了一下此法，整理了一下如何用AOP來攔截你自定義的註解。 自定義註解 首先先自定義一個註解 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNT

使用SpringBoot通過自定義註解+AOP+全域性異常處理實現引數統一非空校驗

一、前言         在我們寫後臺介面時，難免對引數進行非空校驗，如果一兩個還好，但如果需要寫大量的介面，及必填引數太多的時候，會給我們開發帶來大量的重複工作，及很多相似程式碼。而sping自帶的@RequestParam註解並不能完全滿足我們的需求，因為

SpringMvc通過自定義註解在方法的引數中注入資料

說一個場景，有時候我們做後臺業務的時候，經常需要取session中儲存的使用者資訊，所以免不了一直需要寫下面這一段又長又無聊的程式碼： MemberCommand memberCommand = (MemberCommand) request.getSes

spring資料驗證----自定義註解

<dependency> <groupId>commons-validator</groupId> <artifactId>commons-validator&l

Spring boot 自定義註解 簡單版本解析引數

背景：其實就是想用一個註解，來統一處理獲取userid的解析過程。 嗯，但是我覺得自己對註解也沒有那麼瞭解，所以再記錄下。spring boot 中自定義註解的方案：STEP1. 定義註解STEP2. 註解解析1. 定義註解import java.lang.annotatio

springmvc_引數校驗自定義註解

呼叫的例子 @PostMapping("/create") public void create(@RequestBody @Valid ProductSerCreateInput productSerCreateInput, Errors errors) { Api

自己試驗在spring的環繞通知裡獲取目標物件的類名和目標方法的引數類名，用於根據自定義註解判斷訪問許可權，有沒有更好的辦法，高手指點一下

public Object doInBusiness(ProceedingJoinPoint pjp) throws Throwable{   Object[] args = pjp.getArgs();   Class[] argsClass = new Class[ar

SpringBoot使用自定義註解實現簡單引數加密解密(註解+HandlerMethodArgumentResolver)

# 前言 > 我黃漢三又回來了，快半年沒更新部落格了，這半年來的經歷實屬不易， > 疫情當頭，本人實習的公司沒有跟員工共患難，直接辭掉了很多人。 > 作為一個實習生，本人也被無情開除了。所以本人又得重新準備找工作了。 > 算了，感慨一下，本來想昨天發的，但昨天是清明，哀悼時期，就留到了今天發。 話不多說，