if(method.getAllAnnotations().length > 0) { if(method.isAnnotationPresent(Insert.class)) { } else if(method.isAnnotationPresent(Update.class)) { } else if(method.isAnnotationPresent(Delete.class)) { } else if(method.isAnnotationPresent(Flush.class)) { } else if(method.isAnnotationPresent(Lookup.class)) { } else if(method.isAnnotationPresent(LookupByQuery.class)) {
/** * */ private void analyzeParameters() { final AnnotatedMethod aMethod = AnnotationManager.getAnnotatedClass(method.getDeclaringClass()).getAnnotatedMethod(method); final Annotation[][] parameterAnnotations = aMethod.getParameterAnnotations(); int parameterSize = aMethod.getMethod().getParameterTypes().length; for(int i = 0; i < parameterAnnotations.length; i++) { for(final Annotation annotation : parameterAnnotations[i]) { if(Param.class.equals(annotation.annotationType())) { namedParameters = true; final Param param = (Param) annotation; final String name = param.value().trim(); if(name.length() == 0) { throw new RuntimeException("Illegal empty parameter value encounterd on parameter " + i + " of method '" + method + "' from class '" + method.getDeclaringClass().getName() +"'."); } if(parameterPositions == null) { parameterPositions = new HashMap<String, Integer>(); } parameterPositions.put(param.value(), i); break; } } } if(namedParameters && parameterPositions.size() != parameterSize) { throw new RuntimeException("Not all the parameters of the method '" + method.getDeclaringClass().getName() + "." + method + "' are annotated with the '" + Param.class.getName() + "' annotation." + " All the parameters of the method need to be have the '" + Param.class.getName() + "' annotation when using the annotation on a method."); } }
/** * @param method */ private void analyzeFindByMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Lookup findByAnnotation = aMethod.getAnnotation(Lookup.class); String name = findByAnnotation.name(); if(name.trim().length() == 0) { name = method.getName(); } assertUniqueName(lookupWithNamedParameters, Lookup.class, name); if(void.class.equals(method.getReturnType())){ throw new IllegalAnnotationUsageException("The FindBy annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' " + "returns void, which isn't allowed. The method must return something."); } lookupWithNamedParameters.put(name, new LookupMethod(method)); }
/** * @param result is the map of classes to annotations to fill * @param annotatedMethod the method to get annotations. Does nothing * if the annotated method is null. */ private void fillAnnotationsForOneMethod(final HashMap<Class<?>, Annotation> result, final AnnotatedMethod annotatedMethod) { if (annotatedMethod == null) { return; } addAnnotations(result, annotatedMethod.getAllAnnotations()); }
final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations(); final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations();
/** * @param method */ private void analyzeFlushMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); if(flushMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Flush.class.getName() +"'. Only one method per class is allowed to be the flush method."); } if(method.getParameterTypes().length > 0) { throw new IllegalAnnotationUsageException("The Flush annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' has parameters, which isn't allowed."); } flushMethod = new FlushMethod(method); }
/** * @param result is the map of classes to annotations to fill * @param annotatedMethod the method to get annotations. Does nothing * if the annotated method is null. */ private void fillAnnotationsForOneMethod(final HashMap<Class<?>, Annotation> result, final AnnotatedMethod annotatedMethod) { if (annotatedMethod == null) { return; } addAnnotations(result, annotatedMethod.getAllAnnotations()); }
final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations(); final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations();
/** * @param method */ private void analyzeFlushMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); if(flushMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Flush.class.getName() +"'. Only one method per class is allowed to be the flush method."); } if(method.getParameterTypes().length > 0) { throw new IllegalAnnotationUsageException("The Flush annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' has parameters, which isn't allowed."); } flushMethod = new FlushMethod(method); }
/** * @param method */ private void analyzeFindByMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Lookup findByAnnotation = aMethod.getAnnotation(Lookup.class); String name = findByAnnotation.name(); if(name.trim().length() == 0) { name = method.getName(); } assertUniqueName(lookupWithNamedParameters, Lookup.class, name); if(void.class.equals(method.getReturnType())){ throw new IllegalAnnotationUsageException("The FindBy annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' " + "returns void, which isn't allowed. The method must return something."); } lookupWithNamedParameters.put(name, new LookupMethod(method)); }
/** * */ private void analyzeParameters() { final AnnotatedMethod aMethod = AnnotationManager.getAnnotatedClass(method.getDeclaringClass()).getAnnotatedMethod(method); final Annotation[][] parameterAnnotations = aMethod.getParameterAnnotations(); int parameterSize = aMethod.getMethod().getParameterTypes().length; for(int i = 0; i < parameterAnnotations.length; i++) { for(final Annotation annotation : parameterAnnotations[i]) { if(Param.class.equals(annotation.annotationType())) { namedParameters = true; final Param param = (Param) annotation; final String name = param.value().trim(); if(name.length() == 0) { throw new RuntimeException("Illegal empty parameter value encounterd on parameter " + i + " of method '" + method + "' from class '" + method.getDeclaringClass().getName() +"'."); } if(parameterPositions == null) { parameterPositions = new HashMap<String, Integer>(); } parameterPositions.put(param.value(), i); break; } } } if(namedParameters && parameterPositions.size() != parameterSize) { throw new RuntimeException("Not all the parameters of the method '" + method.getDeclaringClass().getName() + "." + method + "' are annotated with the '" + Param.class.getName() + "' annotation." + " All the parameters of the method need to be have the '" + Param.class.getName() + "' annotation when using the annotation on a method."); } }
if(method.getAllAnnotations().length > 0) { if(method.isAnnotationPresent(Insert.class)) { } else if(method.isAnnotationPresent(Update.class)) { } else if(method.isAnnotationPresent(Delete.class)) { } else if(method.isAnnotationPresent(Flush.class)) { } else if(method.isAnnotationPresent(Lookup.class)) { } else if(method.isAnnotationPresent(LookupByQuery.class)) {
/** * @param result is the map of classes to annotations to fill * @param annotatedMethod the method to get annotations. Does nothing * if the annotated method is null. */ private void fillAnnotationsForOneMethod(final HashMap<Class<?>, Annotation> result, final AnnotatedMethod annotatedMethod) { if (annotatedMethod == null) { return; } addAnnotations(result, annotatedMethod.getAllAnnotations()); }
final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations(); final Annotation[][] paramAnnotations = aMethod.getParameterAnnotations();
Method method = aMethod.getMethod();
/** * @param method */ private void analyzeInsertMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Insert annotation = aMethod.getAnnotation(Insert.class); String name = annotation.name(); if(name.length() == 0) { name = method.getName(); } assertUniqueName(insertMethods, Insert.class, name); if(annotation.isDefault() && defaultInsertMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Insert.class.getName() +"'annotation having the isDefault on true. Only one method per class is allowed to be the default insert method."); } if(method.getParameterTypes().length == 0) { throw new IllegalAnnotationUsageException("The Insert annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' doesn't have any parameters."); } if(method.getParameterTypes().length > 1) { throw new IllegalAnnotationUsageException("The Insert annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' has more then 1 parameter, which isn't allowed."); } boolean returnsEntity = !method.isAnnotationPresent(ReturnsNoEntity.class); EntityMethod insertMethod = new EntityMethod(method, returnsEntity); if(annotation.isDefault()) { defaultInsertMethod = insertMethod; } insertMethods.put(name, insertMethod); }
Method method = aMethod.getMethod();
/** * @param method */ private void analyzeDeleteMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Delete annotation = aMethod.getAnnotation(Delete.class); String name = annotation.name(); if(name.length() == 0) { name = method.getName(); } assertUniqueName(deleteMethods, Delete.class, name); if(annotation.isDefault() && defaultDeleteMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Delete.class.getName() +"' annotation having the isDefault on true. Only one method per class is allowed to be the default delete method."); } if(method.getParameterTypes().length == 0) { throw new IllegalAnnotationUsageException("The Delete annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' doesn't have a parameter, which it needs."); } if(method.getParameterTypes().length > 1) { throw new IllegalAnnotationUsageException("The Delete annotated method '"+ method +"' the DAO class '"+ daoClass.getName() +"' has more then 1 parameter, which isn't allowed."); } boolean returnsEntity = !method.isAnnotationPresent(ReturnsNoEntity.class); EntityMethod deleteMethod = new EntityMethod(method, returnsEntity); if(annotation.isDefault()) { defaultDeleteMethod = deleteMethod; } deleteMethods.put(name, deleteMethod); }
/** * @param method */ private void analyzeDeleteMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Delete annotation = aMethod.getAnnotation(Delete.class); String name = annotation.name(); if(name.length() == 0) { name = method.getName(); } assertUniqueName(deleteMethods, Delete.class, name); if(annotation.isDefault() && defaultDeleteMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Delete.class.getName() +"' annotation having the isDefault on true. Only one method per class is allowed to be the default delete method."); } if(method.getParameterTypes().length == 0) { throw new IllegalAnnotationUsageException("The Delete annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' doesn't have a parameter, which it needs."); } if(method.getParameterTypes().length > 1) { throw new IllegalAnnotationUsageException("The Delete annotated method '"+ method +"' the DAO class '"+ daoClass.getName() +"' has more then 1 parameter, which isn't allowed."); } boolean returnsEntity = !method.isAnnotationPresent(ReturnsNoEntity.class); EntityMethod deleteMethod = new EntityMethod(method, returnsEntity); if(annotation.isDefault()) { defaultDeleteMethod = deleteMethod; } deleteMethods.put(name, deleteMethod); }
/** * @param method */ private void analyzeUpdateMethod(final AnnotatedMethod aMethod) { Method method = aMethod.getMethod(); Update annotation = aMethod.getAnnotation(Update.class); String name = annotation.name(); if(name.length() == 0) { name = method.getName(); } assertUniqueName(updateMethods, Update.class, name); if(annotation.isDefault() && defaultUpdateMethod != null) { throw new IllegalAnnotationUsageException("At least two methods are annotated with the '"+ Update.class.getName() +"' having the isDefault on true. Only one method per class is allowed to be the default update method."); } if(method.getParameterTypes().length == 0) { throw new IllegalAnnotationUsageException("The Update annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' doesn't have any parameters."); } if(method.getParameterTypes().length > 1) { throw new IllegalAnnotationUsageException("The Update annotated method '"+ method +"' of the DAO class '"+ daoClass.getName() +"' has more then 1 parameter, which isn't allowed."); } boolean returnsEntity = !method.isAnnotationPresent(ReturnsNoEntity.class); EntityMethod updateMethod = new EntityMethod(method, returnsEntity); if(annotation.isDefault()) { defaultUpdateMethod = updateMethod; } updateMethods.put(name, updateMethod); }