运行时的Java注释

存在以下类，这些类由预定义的UUID组成，这些UUID描述数据库的可能实体

public class Predefined {
    @NotNull
    @Size(min = 1, max = 25)
    public UUID phone = UUID.fromString("47b58767-c0ad-43fe-8e87-c7dae489a4f0");

    @NotNull
    @Size(min = 1, max = 40)
    public UUID company = UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2");
}

这些值通过web服务作为密钥对值接收：然后将它们放入hashmap

47b58767-c0ad-43fe-8e87-c7dae489a4f0=+00112233445566778899

f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2=某个虚拟计算机名称

当我收到UUID时，我知道我正在创建预定义类的实例，然后获取预定义类中的字段注释，即：

Annotation[] annon = field.getDeclaredAnnotations(); 

现在，我需要检查这些注释是否与我在运行时从web服务获得的值一致，即“+00112233445566778899”和“someVirtualCompnayName”

这可能吗？ 我对涉及JSR303的示例特别感兴趣

我为什么会有这样的想法： DAO、@Repository类具有不同的结构，即

接触

联系人(属性)

接触式

其中数据库“contact_attibute_type”表示“公司”和“电话”。第二个表，即“contact_attrbute”是指“company”和“phone”的实际值

---

现在，我需要一种在hibernate中编写这些值之前验证这些值的方法，因此我将获得“公共UUID电话”，然后尝试将这些约束应用于从用户那里获得的实际值，即“+00112233445566778899”。

我将发布我提出的完整代码，以验证您的测试用例（包括一个简单的可执行演示）：

注释：

package annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target( {ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull
{

}

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target( {ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface Size
{
    int min() default 0;
    int max();
}

预定义类：

public class Predefined
{
    @NotNull
    @Size(min = 1, max = 25)
    public UUID phone;

    @NotNull
    @Size(min = 1, max = 40)
    public UUID company;

    public Predefined(UUID phone, UUID company)
    {
        this.phone = phone;
        this.company = company;
    }
}

验证程序类，它遍历声明的字段并检查其注释和字段/值映射：

public class PredefinedValidator
{
    public boolean validate(Predefined predefined, Map<UUID, String> mappings)
    {
        if (predefined == null)
            return false;

        for (Field field :predefined.getClass().getDeclaredFields())
        {
            if (field.getType().equals(UUID.class))
            {
                try
                {
                    Annotation[] annotations = field.getDeclaredAnnotations();
                    UUID uuid = (UUID)field.get(predefined);
                    if (!this.validateField(uuid, annotations, mappings))
                        return false;
                }
                catch (IllegalArgumentException | IllegalAccessException ex)
                {
                    Logger.getLogger(PredefinedValidator.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
        return true;
    }

    private boolean validateField(UUID field, Annotation[] annotations, Map<UUID, String> mapping)
    {
        boolean containsSize = false;
        boolean containsNotNull = false;
        int minSize = -1;
        int maxSize = -1;

        // fetch which annotations are available for the provided field
        for (Annotation annotation : annotations)
        {
            if (annotation instanceof Size)
            {
                containsSize = true;
                Size size = (Size)annotation;
                minSize = size.min();
                maxSize = size.max();
            }
            else if (annotation instanceof NotNull)
                containsNotNull = true;
        }

        // check if the provided value is null and an annotatition for @NotNull
        // is set
        if (field == null && containsNotNull)
            return false;

        if (containsSize)
        {
            // get the value of the mapped UUID which we are going to validate
            String value = mapping.get(field);
            if (value == null && containsNotNull)
                return false;
            else if (value == null)
                return true;

            // check if the length of the value matches
            if (value.length() <= minSize || value.length() >= maxSize)
                return false;
        }

        // passed all tests
        return true;
    }
}

公共类预定义验证器
{
公共布尔验证（预定义的映射映射）
{
如果（预定义==null）
返回false；
用于（字段：预定义的.getClass（）.getDeclaredFields（））
{
if（field.getType（）.equals（UUID.class））
{
尝试
{
Annotation[]annotations=field.getDeclaredAnnotations（）；
UUID UUID=（UUID）字段.get（预定义）；
if（！this.validateField（uuid、注释、映射））
返回false；
}
捕获（IllegalArgumentException | IllegalAccessException ex）
{
Logger.getLogger（预定义的validator.class.getName（））.log（Level.SEVERE，null，ex）；
}
}
}
返回true；
}
私有布尔validateField（UUID字段、注释[]注释、映射）
{
布尔containsSize=false；
布尔containsNotNull=false；
int minSize=-1；
int maxSize=-1；
//获取可用于所提供字段的批注
用于（注释：注释）
{
if（注释实例的大小）
{
containsSize=true；
大小=（大小）注释；
minSize=size.min（）；
maxSize=size.max（）；
}
else if（NotNull的注释实例）
containsNotNull=真；
}
//检查提供的值是否为null，以及@NotNull的注释
//设定
if（字段==null&&containsNotNull）
返回false；
如果（容器化）
{
//获取要验证的映射UUID的值
字符串值=mapping.get（字段）；
if（值==null&&containsNotNull）
返回false；
else if（值==null）
返回true；
//检查值的长度是否匹配
if（value.length（）=maxSize）
返回false；
}
//通过所有测试
返回true；
}
}

最后但并非最不重要的一个简单演示：

public static void main(String ... args)
{
    Map<UUID, String> mappings = new HashMap<>();
    mappings.put(UUID.fromString("47b58767-c0ad-43fe-8e87-c7dae489a4f0"), "+00112233445566778899");
    mappings.put(UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2"), "someVirtualCompnayName");       

    Predefined predefined = new Predefined(
            UUID.fromString("47b58767-c0ad-43fe-8e87-c7dae489a4f0"), 
            UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2"));
    Predefined predefined2 = new Predefined(
            UUID.randomUUID(), 
            UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2"));
    Predefined predefined3 = new Predefined(
            null, 
            UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2"));
    PredefinedValidator validator = new PredefinedValidator();

    System.out.println("predefined is valid: "+validator.validate(predefined, mappings));
    System.out.println("predefined is valid: "+validator.validate(predefined2, mappings));
    System.out.println("predefined is valid: "+validator.validate(predefined3, mappings));

    mappings.put(UUID.fromString("f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2"), "someVirtualCompnayNamesomeVirtualCompnayNamesomeVirtualCompnayNamesomeVirtualCompnayName"); 
    System.out.println("predefined is valid: "+validator.validate(predefined, mappings));
}

publicstaticvoidmain（字符串…参数）
{
Map mappings=newhashmap（）；
put（UUID.fromString（“47b58767-c0ad-43fe-8e87-c7dae489a4f0”），“+00112233445566778899”）；
put（UUID.fromString（“f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2”），“somevirtualcompanyname”）；
预定义=新预定义(
UUID.来自字符串（“47b58767-c0ad-43fe-8e87-c7dae489a4f0”），
UUID.fromString（“f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2”）；
预定义的预定义2=新的预定义(
UUID.randomUUID（），
UUID.fromString（“f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2”）；
预定义的预定义3=新的预定义(
无效的
UUID.fromString（“f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2”）；
PredefinedValidator validator=新的PredefinedValidator（）；
System.out.println（“预定义有效：”+validator.validate（预定义，映射））；
System.out.println（“预定义有效：”+validator.validate（预定义的2，映射））；
System.out.println（“预定义有效：”+validator.validate（预定义3，映射））；
mappings.put（UUID.fromString（“f9a1e8f4-b8c0-41f2-a626-49c11da8d5c2”），“someVirtualComNayNamesomeVirtualComNayNamesomeVirtualComNayNamesomeVirtualComNayNamesomeVirtualComNayNamesomeVirtualComNayName”）；
System.out.println（“预定义有效：”+validator.validate（预定义，映射））；
}

---

HTH

你好，罗曼，真诚的“danke schön”和“Мèèèèèè”对于这次重播。答案超出了我想要得到的。再次感谢。@Tito无需感谢。因此，保持一个基于投票的系统，如果答案解决了您的问题，接受答案作为解决方案。如果您同意帖子的内容，请对答案进行投票；如果您不同意，请对帖子进行评论，并讨论您的陈述，或者选择如果你认为答案根本不能解决问题，或者缺乏关于如何处理起源问题的适当提示，请投反对票