Java tutorial
/** * Copyright 2010-2016 Ralph Schaer <ralphschaer@gmail.com> * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package ch.ralscha.extdirectspring.util; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Map; import org.apache.commons.logging.LogFactory; import org.springframework.context.ApplicationContext; import org.springframework.core.annotation.AnnotationUtils; import org.springframework.util.StringUtils; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.method.HandlerMethod; import ch.ralscha.extdirectspring.annotation.ExtDirectDocParameters; import ch.ralscha.extdirectspring.annotation.ExtDirectDocReturn; import ch.ralscha.extdirectspring.annotation.ExtDirectMethod; import ch.ralscha.extdirectspring.annotation.ExtDirectMethodDocumentation; import ch.ralscha.extdirectspring.annotation.ExtDirectMethodType; import ch.ralscha.extdirectspring.bean.api.Action; import ch.ralscha.extdirectspring.bean.api.ActionDoc; import ch.ralscha.extdirectspring.bean.api.PollingProvider; /** * Object holds information about a method like the method itself and a list of * parameters. */ public final class MethodInfo { private final String group; private final ExtDirectMethodType type; private final Class<?> jsonView; private final boolean synchronizeOnSession; private final boolean streamResponse; private List<ParameterInfo> parameters; private Method method; private String forwardPath; private HandlerMethod handlerMethod; private Class<?> collectionType; private Action action; private PollingProvider pollingProvider; public MethodInfo(Class<?> clazz, ApplicationContext context, String beanName, Method method) { ExtDirectMethod extDirectMethodAnnotation = AnnotationUtils.findAnnotation(method, ExtDirectMethod.class); this.type = extDirectMethodAnnotation.value(); if (extDirectMethodAnnotation.jsonView() != ExtDirectMethod.NoJsonView.class) { this.jsonView = extDirectMethodAnnotation.jsonView(); } else { this.jsonView = null; } if (StringUtils.hasText(extDirectMethodAnnotation.group())) { this.group = extDirectMethodAnnotation.group().trim(); } else { this.group = null; } this.synchronizeOnSession = extDirectMethodAnnotation.synchronizeOnSession(); this.streamResponse = extDirectMethodAnnotation.streamResponse(); if (this.type != ExtDirectMethodType.FORM_POST) { this.method = method; this.parameters = buildParameterList(clazz, method); this.collectionType = extDirectMethodAnnotation.entryClass() == Object.class ? null : extDirectMethodAnnotation.entryClass(); if (this.collectionType == null) { for (ParameterInfo parameter : this.parameters) { Class<?> collType = parameter.getCollectionType(); if (collType != null) { this.collectionType = collType; break; } } } } else { if (method.getReturnType().equals(Void.TYPE)) { RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class); RequestMapping classAnnotation = AnnotationUtils.findAnnotation(clazz, RequestMapping.class); String path = null; if (hasValue(classAnnotation)) { path = classAnnotation.value()[0]; } if (hasValue(methodAnnotation)) { String methodPath = methodAnnotation.value()[0]; if (path != null) { path = path + methodPath; } else { path = methodPath; } } if (path != null) { if (path.charAt(0) == '/' && path.length() > 1) { path = path.substring(1, path.length()); } this.forwardPath = "forward:" + path; } } else { this.handlerMethod = new HandlerMethod(beanName, context, method).createWithResolvedBean(); } } switch (this.type) { case SIMPLE: int paramLength = 0; for (ParameterInfo parameter : this.parameters) { if (parameter.isClientParameter()) { paramLength++; } } this.action = Action.create(method.getName(), paramLength, extDirectMethodAnnotation.batched()); break; case SIMPLE_NAMED: int noOfClientParameters = 0; Class<?> parameterType = null; List<String> parameterNames = new ArrayList<String>(); for (ParameterInfo parameter : this.parameters) { if (parameter.isClientParameter()) { noOfClientParameters++; parameterType = parameter.getType(); parameterNames.add(parameter.getName()); } } if (noOfClientParameters == 1 && Map.class.isAssignableFrom(parameterType)) { this.action = Action.createNamed(method.getName(), Collections.<String>emptyList(), Boolean.FALSE, extDirectMethodAnnotation.batched()); } else { this.action = Action.createNamed(method.getName(), Collections.unmodifiableList(parameterNames), null, extDirectMethodAnnotation.batched()); } break; case FORM_LOAD: this.action = Action.create(method.getName(), 1, extDirectMethodAnnotation.batched()); break; case STORE_READ: case STORE_MODIFY: case TREE_LOAD: List<String> metadataParams = new ArrayList<String>(); for (ParameterInfo parameter : this.parameters) { if (parameter.hasMetadataParamAnnotation()) { metadataParams.add(parameter.getName()); } } this.action = Action.createTreeLoad(method.getName(), 1, metadataParams, extDirectMethodAnnotation.batched()); break; case FORM_POST: this.action = Action.createFormHandler(method.getName(), 0); break; case FORM_POST_JSON: this.action = Action.create(method.getName(), 1, extDirectMethodAnnotation.batched()); break; case POLL: this.pollingProvider = new PollingProvider(beanName, method.getName(), extDirectMethodAnnotation.event()); break; default: throw new IllegalStateException("ExtDirectMethodType: " + this.type + " does not exists"); } this.action = extractDocumentationAnnotations(extDirectMethodAnnotation.documentation()); } /** * The rule is: whatever has been given is taken as is the API documentation is non * critical, so any discrepancies will be silently ignored * * @param documentation * @return ActionDoc */ private Action extractDocumentationAnnotations(ExtDirectMethodDocumentation documentation) { if (!documentation.value().isEmpty()) { ActionDoc actionDoc = new ActionDoc(getAction(), documentation.value(), documentation.author(), documentation.version(), documentation.deprecated()); ExtDirectDocParameters docParameters = documentation.parameters(); if (null != docParameters) { String[] params = docParameters.params(); String[] descriptions = docParameters.descriptions() == null ? new String[params.length] : docParameters.descriptions(); if (params.length == descriptions.length) { for (int i = 0; i < params.length; i++) { actionDoc.getParameters().put(params[i], descriptions[i] == null ? "No description" : descriptions[i]); } } else { LogFactory.getLog(MethodInfo.class).info( "Documentation: skip generation of parameters, params size is different from descriptions size"); } } ExtDirectDocReturn docReturn = documentation.returnMethod(); if (null != docReturn) { String[] properties = docReturn.properties(); String[] descriptions = docReturn.descriptions() == null ? new String[properties.length] : docReturn.descriptions(); if (properties.length == descriptions.length) { for (int i = 0; i < properties.length; i++) { actionDoc.getReturnMethod().put(properties[i], descriptions[i] == null ? "No description" : descriptions[i]); } } else { LogFactory.getLog(MethodInfo.class).info( "Documentation: skip generation of return method properties, properties size is different from descriptions size"); } } return actionDoc; } return this.action; } private static boolean hasValue(RequestMapping requestMapping) { return requestMapping != null && requestMapping.value() != null && requestMapping.value().length > 0 && StringUtils.hasText(requestMapping.value()[0]); } private static List<ParameterInfo> buildParameterList(Class<?> clazz, Method method) { List<ParameterInfo> params = new ArrayList<ParameterInfo>(); Class<?>[] parameterTypes = method.getParameterTypes(); Method methodWithAnnotation = findMethodWithAnnotation(method, ExtDirectMethod.class); if (methodWithAnnotation == null) { methodWithAnnotation = method; } for (int paramIndex = 0; paramIndex < parameterTypes.length; paramIndex++) { params.add(new ParameterInfo(clazz, methodWithAnnotation, paramIndex)); } return params; } public Method getMethod() { return this.method; } public String getForwardPath() { return this.forwardPath; } public HandlerMethod getHandlerMethod() { return this.handlerMethod; } public List<ParameterInfo> getParameters() { return this.parameters; } public Class<?> getCollectionType() { return this.collectionType; } public boolean isType(ExtDirectMethodType methodType) { return this.type == methodType; } public Class<?> getJsonView() { return this.jsonView; } public boolean isSynchronizeOnSession() { return this.synchronizeOnSession; } public boolean isStreamResponse() { return this.streamResponse; } public PollingProvider getPollingProvider() { return this.pollingProvider; } public Action getAction() { return this.action; } public String getGroup() { return this.group; } /** * Find a method that is annotated with a specific annotation. Starts with the method * and goes up to the superclasses of the class. * * @param method the starting method * @param annotation the annotation to look for * @return the method if there is a annotated method, else null */ public static Method findMethodWithAnnotation(Method method, Class<? extends Annotation> annotation) { if (method.isAnnotationPresent(annotation)) { return method; } Class<?> cl = method.getDeclaringClass(); while (cl != null && cl != Object.class) { try { Method equivalentMethod = cl.getDeclaredMethod(method.getName(), method.getParameterTypes()); if (equivalentMethod.isAnnotationPresent(annotation)) { return equivalentMethod; } } catch (NoSuchMethodException e) { // do nothing here } cl = cl.getSuperclass(); } return null; } }