use of org.springframework.roo.classpath.details.annotations.AnnotationMetadata in project spring-roo by spring-projects.
the class ExceptionsOperationsImpl method addHandlersAnnotations.
/**
* Generates {@link RooExceptionHandlers} and {@link RooExceptionHandler} annotations
* and adds or updates it on specified class.
*
* @param exception
* @param targetClass
* @param errorView
*/
private void addHandlersAnnotations(JavaType exception, JavaType targetClass, String errorView) {
Validate.notNull(targetClass, "Target class is required to add @RooExceptionHandlers annotation");
// Create @RooExceptionHandler Annotation
final AnnotationMetadataBuilder exceptionHandlerAnnotationBuilder = new AnnotationMetadataBuilder(RooJavaType.ROO_EXCEPTION_HANDLER);
final List<AnnotationAttributeValue<?>> exceptionHandlerAnnotationAttributes = new ArrayList<AnnotationAttributeValue<?>>();
exceptionHandlerAnnotationAttributes.add(new ClassAttributeValue(new JavaSymbolName(EXCEPTION), exception));
if (errorView != null) {
exceptionHandlerAnnotationAttributes.add(new StringAttributeValue(new JavaSymbolName(ERROR_VIEW), errorView));
}
exceptionHandlerAnnotationBuilder.setAttributes(exceptionHandlerAnnotationAttributes);
// Check if container annotation already exists
ClassOrInterfaceTypeDetails typeDetails = typeLocationService.getTypeDetails(targetClass);
ClassOrInterfaceTypeDetailsBuilder typeDetailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(typeDetails);
AnnotationMetadata exceptionHandlersAnnotation = typeDetails.getAnnotation(RooJavaType.ROO_EXCEPTION_HANDLERS);
AnnotationMetadataBuilder exceptionHandlersAnnotationBuilder = null;
if (exceptionHandlersAnnotation != null) {
exceptionHandlersAnnotationBuilder = new AnnotationMetadataBuilder(exceptionHandlersAnnotation);
} else {
exceptionHandlersAnnotationBuilder = new AnnotationMetadataBuilder(RooJavaType.ROO_EXCEPTION_HANDLERS);
}
Validate.notNull(exceptionHandlersAnnotationBuilder);
// Add @RooExceptionHandler annotation into @RooExceptionHandlers
final List<NestedAnnotationAttributeValue> exceptionHandlersArrayValues = new ArrayList<NestedAnnotationAttributeValue>();
exceptionHandlersArrayValues.add(new NestedAnnotationAttributeValue(new JavaSymbolName(VALUE), exceptionHandlerAnnotationBuilder.build()));
final List<AnnotationAttributeValue<?>> attributeValues = new ArrayList<AnnotationAttributeValue<?>>();
attributeValues.add(new ArrayAttributeValue<NestedAnnotationAttributeValue>(new JavaSymbolName(VALUE), exceptionHandlersArrayValues));
if (exceptionHandlersAnnotation == null) {
// Add new @RooExceptionHandlers annotation with given values
exceptionHandlersAnnotationBuilder.setAttributes(attributeValues);
typeDetailsBuilder.addAnnotation(exceptionHandlersAnnotationBuilder.build());
} else {
// Get current annotation values from @RooExceptionHandlers annotation
AnnotationAttributeValue<?> currentHandlers = exceptionHandlersAnnotation.getAttribute(VALUE);
if (currentHandlers != null) {
List<?> values = (List<?>) currentHandlers.getValue();
Iterator<?> it = values.iterator();
while (it.hasNext()) {
NestedAnnotationAttributeValue handler = (NestedAnnotationAttributeValue) it.next();
if (handler.getValue() != null) {
// Check if there is a @RooExceptionHandlers with same 'exception' value
if (exceptionHandlerAnnotationBuilder.build().getAttribute(EXCEPTION).getValue().equals(handler.getValue().getAttribute(EXCEPTION).getValue())) {
LOGGER.warning(String.format("There is already a handler for exception %s in class %s", exception.getSimpleTypeName(), targetClass.getSimpleTypeName()));
return;
}
exceptionHandlersArrayValues.add(handler);
}
}
}
// Add found values
attributeValues.add(new ArrayAttributeValue<NestedAnnotationAttributeValue>(new JavaSymbolName(VALUE), exceptionHandlersArrayValues));
exceptionHandlersAnnotationBuilder.setAttributes(attributeValues);
// Update annotation
typeDetailsBuilder.updateTypeAnnotation(exceptionHandlersAnnotationBuilder.build());
}
// Write to disk
getTypeManagementService().createOrUpdateTypeOnDisk(typeDetailsBuilder.build());
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadata in project spring-roo by spring-projects.
the class ExceptionsOperationsImpl method isExceptionAnnotatedWithResponseStatus.
private boolean isExceptionAnnotatedWithResponseStatus(JavaType exception) {
ClassOrInterfaceTypeDetails exceptionCid = typeLocationService.getTypeDetails(exception);
Validate.notNull(exceptionCid, String.format("Can't found class: %s", exception.getFullyQualifiedTypeName()));
AnnotationMetadata annotation = exceptionCid.getAnnotation(SpringJavaType.RESPONSE_STATUS);
if (annotation == null) {
return false;
}
return true;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadata in project spring-roo by spring-projects.
the class ControllerLocatorImpl method getControllers.
@Override
public Collection<ClassOrInterfaceTypeDetails> getControllers(JavaType domainType, ControllerType type, JavaType viewType) {
final Collection<ClassOrInterfaceTypeDetails> found = getControllers(domainType, type);
if (found.isEmpty()) {
return found;
}
Collection<ClassOrInterfaceTypeDetails> result = new HashSet<ClassOrInterfaceTypeDetails>();
for (ClassOrInterfaceTypeDetails item : found) {
AnnotationMetadata annotation = item.getAnnotation(viewType);
if (annotation == null) {
continue;
}
result.add(item);
}
return result;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadata in project spring-roo by spring-projects.
the class ControllerMVCServiceImpl method getMVCMethodByRequestMapping.
@Override
public MethodMetadata getMVCMethodByRequestMapping(JavaType controller, EnumDetails method, String path, List<String> params, String consumes, String produces, String headers) {
// Replacing null values with empty
path = path == null ? "" : path;
consumes = consumes == null ? "" : consumes;
produces = produces == null ? "" : produces;
headers = headers == null ? "" : headers;
// Getting controller member details
MemberDetails controllerDetails = getMemberDetailsScanner().getMemberDetails(getClass().toString(), getTypeLocationService().getTypeDetails(controller));
// Getting all controller methods
List<MethodMetadata> methods = controllerDetails.getMethods();
for (MethodMetadata definedMethod : methods) {
// Getting request mapping annotation
AnnotationMetadata requesMappingAnnotation = definedMethod.getAnnotation(SpringJavaType.REQUEST_MAPPING);
if (requesMappingAnnotation != null) {
// Get all attributes
String methodAttr = requesMappingAnnotation.getAttribute("method") == null ? "" : requesMappingAnnotation.getAttribute("method").getValue().toString();
String valueAttr = requesMappingAnnotation.getAttribute("value") == null ? "" : requesMappingAnnotation.getAttribute("value").getValue().toString();
// TODO: Get params and compare them
String consumesAttr = requesMappingAnnotation.getAttribute("consumes") == null ? "" : requesMappingAnnotation.getAttribute("consumes").getValue().toString();
String producesAttr = requesMappingAnnotation.getAttribute("produces") == null ? "" : requesMappingAnnotation.getAttribute("produces").getValue().toString();
String headersAttr = requesMappingAnnotation.getAttribute("headers") == null ? "" : requesMappingAnnotation.getAttribute("headers").getValue().toString();
// If every attribute match, return this method
if (method.toString().equals(methodAttr) && valueAttr.equals(path) && consumesAttr.equals(consumes) && producesAttr.equals(produces) && headersAttr.equals(headers)) {
return definedMethod;
}
}
}
return null;
}
use of org.springframework.roo.classpath.details.annotations.AnnotationMetadata in project spring-roo by spring-projects.
the class PushInOperationsImpl method pushInClass.
/**
* Makes push-in of all items defined on a provided class
*
* @param klass
* class to make the push-in operation
* @param weiteOnDisk
* indicates if pushed elements should be writed on .java file
* @param force
* if some operation will produce several changes, this parameter
* should be true.
*
* @return list of objects with all the pushed elements.
*/
public List<Object> pushInClass(JavaType klass, boolean writeOnDisk, boolean force) {
List<Object> pushedElements = new ArrayList<Object>();
// Check if current klass exists
Validate.notNull(klass, "ERROR: You must specify a valid class to continue with push-in action");
// Getting class details
ClassOrInterfaceTypeDetails classDetails = getTypeLocationService().getTypeDetails(klass);
Validate.notNull(klass, "ERROR: You must specify a valid class to continue with push-in action");
// String builder where changes will be registered
StringBuilder changesToApply = new StringBuilder();
// Getting member details
MemberDetails memberDetails = getMemberDetailsScanner().getMemberDetails(getClass().getName(), classDetails);
List<MemberHoldingTypeDetails> memberHoldingTypes = memberDetails.getDetails();
// Return if the class has not associated ITD's
if (memberHoldingTypes.size() == 1 && memberHoldingTypes.get(0).getPhysicalTypeCategory() != PhysicalTypeCategory.ITD) {
return pushedElements;
}
// Check if the provided class is a test to be able to select valid
// class path
Path path = classDetails.getAnnotation(RooJavaType.ROO_JPA_UNIT_TEST) == null ? Path.SRC_MAIN_JAVA : Path.SRC_TEST_JAVA;
// Getting current class .java file metadata ID
final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(klass, getPathResolver().getPath(klass.getModule(), path));
// Getting detailsBuilder
ClassOrInterfaceTypeDetailsBuilder detailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(classDetails);
// Getting all details
for (final MemberHoldingTypeDetails memberHoldingTypeDetails : memberDetails.getDetails()) {
// this .java file
if (!memberHoldingTypeDetails.getType().equals(classDetails.getType())) {
continue;
}
// Getting all declared methods (including declared on ITDs
// and .java files)
List<MethodMetadata> allDeclaredMethods = memberHoldingTypeDetails.getMethods();
// Checking if is necessary to make push-in for all declared methods
for (MethodMetadata method : allDeclaredMethods) {
// If method exists on .aj file, add it!
if (method.getDeclaredByMetadataId().split("\\?").length > 1 && method.getDeclaredByMetadataId().split("\\?")[1].equals(klass.getFullyQualifiedTypeName()) && !method.getDeclaredByMetadataId().equals(declaredByMetadataId)) {
// Add method to .java file
MethodMetadata newMethod = getNewMethod(declaredByMetadataId, method);
detailsBuilder.addMethod(newMethod);
// Save changes on pushed elements list
pushedElements.add(newMethod);
changesToApply.append(String.format("Method '%s' will be pushed on '%s.java' class. \n", method.getMethodName(), klass.getSimpleTypeName()));
}
}
// Getting all declared fields (including declared on ITDs
// and .java files)
List<? extends FieldMetadata> allDeclaredFields = memberHoldingTypeDetails.getDeclaredFields();
// Checking if is necessary to make push-in for all declared fields
for (FieldMetadata field : allDeclaredFields) {
// If field exists on .aj file, add it!
if (field.getDeclaredByMetadataId().split("\\?").length > 1 && field.getDeclaredByMetadataId().split("\\?")[1].equals(klass.getFullyQualifiedTypeName()) && !field.getDeclaredByMetadataId().equals(declaredByMetadataId)) {
// Add field to .java file
FieldMetadata newField = getNewField(declaredByMetadataId, field);
detailsBuilder.addField(newField);
// Save changes on pushed elements list
pushedElements.add(newField);
changesToApply.append(String.format("Field '%s' will be pushed on '%s.java' class. \n", field.getFieldName(), klass.getSimpleTypeName()));
}
}
// Getting all declared constructors (including declared on ITDs and
// .java files)
List<? extends ConstructorMetadata> allDeclaredConstructors = memberHoldingTypeDetails.getDeclaredConstructors();
// constructors
for (ConstructorMetadata constructor : allDeclaredConstructors) {
// Check if current constructor exists on .java file
classDetails = getTypeLocationService().getTypeDetails(detailsBuilder.build().getType());
List<JavaType> parameterTypes = new ArrayList<JavaType>();
for (AnnotatedJavaType type : constructor.getParameterTypes()) {
parameterTypes.add(type.getJavaType());
}
ConstructorMetadata javaDeclaredConstructor = classDetails.getDeclaredConstructor(parameterTypes);
// If not exists, add it!
if (javaDeclaredConstructor == null) {
// Add constructor to .java file
detailsBuilder.addConstructor(constructor);
// Save changes on pushed elements list
pushedElements.add(constructor);
String constructorParametersNames = "";
for (JavaSymbolName paramName : constructor.getParameterNames()) {
constructorParametersNames = constructorParametersNames.concat(paramName.getSymbolName()).concat(", ");
changesToApply.append(String.format("Constructor with parameters '%s' will be pushed on '%s.java' class. \n", constructorParametersNames.substring(0, constructorParametersNames.length() - 2), klass.getSimpleTypeName()));
}
}
}
// Getting all declared annotations (including declared on ITDs
// and .java files)
List<AnnotationMetadata> allDeclaredAnnotations = memberHoldingTypeDetails.getAnnotations();
for (AnnotationMetadata annotation : allDeclaredAnnotations) {
// Check if current annotation exists on .java file
classDetails = getTypeLocationService().getTypeDetails(detailsBuilder.build().getType());
List<AnnotationMetadata> javaDeclaredAnnotations = classDetails.getAnnotations();
boolean annotationExists = false;
for (AnnotationMetadata javaAnnotation : javaDeclaredAnnotations) {
if (javaAnnotation.getAnnotationType().getFullyQualifiedTypeName().equals(annotation.getAnnotationType().getFullyQualifiedTypeName())) {
annotationExists = true;
}
}
// If not exists, add it!
if (!annotationExists) {
// Add annotation to .java file
detailsBuilder.addAnnotation(annotation);
// Save changes on pushed elements list
pushedElements.add(annotation);
changesToApply.append(String.format("Annotation '%s' will be pushed on '%s.java' class. \n", annotation.getAnnotationType().getSimpleTypeName(), klass.getSimpleTypeName()));
}
}
// Getting all extends registered on .aj file to move to .java file
List<JavaType> allExtendsTypes = memberHoldingTypeDetails.getExtendsTypes();
for (JavaType extendsType : allExtendsTypes) {
// If extends exists on .aj file, add it!
if (!detailsBuilder.getExtendsTypes().contains(extendsType)) {
detailsBuilder.addExtendsTypes(extendsType);
// Save changes on pushed elements list
pushedElements.add(extendsType);
changesToApply.append(String.format("Extends type '%s' will be pushed on '%s.java' class. \n", extendsType.getSimpleTypeName(), klass.getSimpleTypeName()));
}
}
// Getting all implements registered on .aj file to move to .java
// file
List<JavaType> allImplementsTypes = memberHoldingTypeDetails.getImplementsTypes();
for (JavaType implementsType : allImplementsTypes) {
if (!detailsBuilder.getImplementsTypes().contains(implementsType)) {
detailsBuilder.addImplementsType(implementsType);
// Save changes on pushed elements list
pushedElements.add(implementsType);
changesToApply.append(String.format("Implements type '%s' will be pushed on '%s.java' class. \n", implementsType.getSimpleTypeName(), klass.getSimpleTypeName()));
}
}
// Getting all imports registered on .aj file to move to .java file
Set<ImportMetadata> allRegisteredImports = memberHoldingTypeDetails.getImports();
detailsBuilder.addImports(allRegisteredImports);
// Save changes on pushed elements list
pushedElements.add(allRegisteredImports);
}
// Updating .java file
if (!force) {
// Show message to be able to know which changes will be applied
if (changesToApply.length() > 0) {
LOGGER.log(Level.INFO, changesToApply.toString());
}
} else if (writeOnDisk) {
getTypeManagementService().createOrUpdateTypeOnDisk(detailsBuilder.build());
}
return pushedElements;
}
Aggregations