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.beans.PropertyDescriptor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.TypeVariable; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.BeanUtils; import org.springframework.core.MethodParameter; import org.springframework.core.convert.ConversionFailedException; import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.TypeDescriptor; import org.springframework.expression.Expression; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.util.ClassUtils; import org.springframework.web.bind.support.WebArgumentResolver; import org.springframework.web.context.request.ServletWebRequest; import org.springframework.web.util.UrlPathHelper; import org.springframework.web.util.WebUtils; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.type.CollectionType; import com.fasterxml.jackson.databind.type.TypeBindings; import com.fasterxml.jackson.databind.type.TypeFactory; import ch.ralscha.extdirectspring.annotation.ExtDirectMethodType; import ch.ralscha.extdirectspring.bean.ExtDirectRequest; import ch.ralscha.extdirectspring.bean.ExtDirectStoreReadRequest; import ch.ralscha.extdirectspring.bean.GroupInfo; import ch.ralscha.extdirectspring.bean.SortDirection; import ch.ralscha.extdirectspring.bean.SortInfo; import ch.ralscha.extdirectspring.filter.Filter; /** * Resolver of ExtDirectRequest parameters. */ public final class ParametersResolver { private static final Log log = LogFactory.getLog(ParametersResolver.class); private final UrlPathHelper urlPathHelper = new UrlPathHelper(); private final ConversionService conversionService; private final JsonHandler jsonHandler; private final Collection<WebArgumentResolver> webArgumentResolvers; private final Expression getPrincipalExpression = new SpelExpressionParser().parseExpression( "T(org.springframework.security.core.context.SecurityContextHolder).getContext().getAuthentication()?.getPrincipal()"); /** Java 8's java.util.Optional.empty() */ private static Object javaUtilOptionalEmpty = null; static { try { Class<?> clazz = ClassUtils.forName("java.util.Optional", ParametersResolver.class.getClassLoader()); javaUtilOptionalEmpty = ClassUtils.getMethod(clazz, "empty").invoke(null); } catch (Exception ex) { // Java 8 not available - conversion to Optional not supported then. } } public ParametersResolver(ConversionService conversionService, JsonHandler jsonHandler, Collection<WebArgumentResolver> webArgumentResolvers) { this.conversionService = conversionService; this.jsonHandler = jsonHandler; this.webArgumentResolvers = webArgumentResolvers; } public Object[] prepareParameters(HttpServletRequest request, HttpServletResponse response, Locale locale, MethodInfo methodInfo) { List<ParameterInfo> methodParameters = methodInfo.getParameters(); Object[] parameters = null; if (!methodParameters.isEmpty()) { parameters = new Object[methodParameters.size()]; for (int paramIndex = 0; paramIndex < methodParameters.size(); paramIndex++) { ParameterInfo methodParameter = methodParameters.get(paramIndex); if (methodParameter.isSupportedParameter()) { parameters[paramIndex] = SupportedParameters.resolveParameter(methodParameter.getType(), request, response, locale, null); } else if (methodParameter.hasRequestHeaderAnnotation()) { parameters[paramIndex] = resolveRequestHeader(request, methodParameter); } else if (methodParameter.hasCookieValueAnnotation()) { parameters[paramIndex] = resolveCookieValue(request, methodParameter); } else if (methodParameter.hasAuthenticationPrincipalAnnotation()) { parameters[paramIndex] = resolveAuthenticationPrincipal(methodParameter); } else { parameters[paramIndex] = resolveRequestParam(request, null, methodParameter); } } } return parameters; } @SuppressWarnings("unchecked") public Object[] resolveParameters(HttpServletRequest request, HttpServletResponse response, Locale locale, ExtDirectRequest directRequest, MethodInfo methodInfo) throws Exception { int jsonParamIndex = 0; Map<String, Object> remainingParameters = null; ExtDirectStoreReadRequest extDirectStoreReadRequest = null; List<Object> directStoreModifyRecords = null; Class<?> directStoreEntryClass; if (methodInfo.isType(ExtDirectMethodType.STORE_READ) || methodInfo.isType(ExtDirectMethodType.FORM_LOAD) || methodInfo.isType(ExtDirectMethodType.TREE_LOAD)) { List<Object> data = (List<Object>) directRequest.getData(); if (data != null && data.size() > 0) { if (methodInfo.isType(ExtDirectMethodType.STORE_READ)) { extDirectStoreReadRequest = new ExtDirectStoreReadRequest(); remainingParameters = fillReadRequestFromMap(extDirectStoreReadRequest, (Map<String, Object>) data.get(0)); } else { remainingParameters = (Map<String, Object>) data.get(0); } jsonParamIndex = 1; } } else if (methodInfo.isType(ExtDirectMethodType.STORE_MODIFY)) { directStoreEntryClass = methodInfo.getCollectionType(); List<Object> data = (List<Object>) directRequest.getData(); if (directStoreEntryClass != null && data != null && data.size() > 0) { Object obj = data.get(0); if (obj instanceof List) { directStoreModifyRecords = convertObjectEntriesToType((List<Object>) obj, directStoreEntryClass); } else { Map<String, Object> jsonData = (Map<String, Object>) obj; Object records = jsonData.get("records"); if (records != null) { if (records instanceof List) { directStoreModifyRecords = convertObjectEntriesToType((List<Object>) records, directStoreEntryClass); } else { directStoreModifyRecords = new ArrayList<Object>(); directStoreModifyRecords .add(this.jsonHandler.convertValue(records, directStoreEntryClass)); } remainingParameters = new HashMap<String, Object>(jsonData); remainingParameters.remove("records"); } else { directStoreModifyRecords = new ArrayList<Object>(); directStoreModifyRecords .add(this.jsonHandler.convertValue(jsonData, directStoreEntryClass)); } } jsonParamIndex = 1; } else if (data != null && data.size() > 0) { Object obj = data.get(0); if (obj instanceof Map) { remainingParameters = new HashMap<String, Object>((Map<String, Object>) obj); remainingParameters.remove("records"); } } } else if (methodInfo.isType(ExtDirectMethodType.SIMPLE_NAMED)) { Map<String, Object> data = (Map<String, Object>) directRequest.getData(); if (data != null && data.size() > 0) { remainingParameters = new HashMap<String, Object>(data); } } else if (methodInfo.isType(ExtDirectMethodType.POLL)) { throw new IllegalStateException("this controller does not handle poll calls"); } else if (methodInfo.isType(ExtDirectMethodType.FORM_POST)) { throw new IllegalStateException("this controller does not handle form posts"); } else if (methodInfo.isType(ExtDirectMethodType.FORM_POST_JSON)) { List<Object> data = (List<Object>) directRequest.getData(); if (data != null && data.size() > 0) { Object obj = data.get(0); if (obj instanceof Map) { remainingParameters = new HashMap<String, Object>((Map<String, Object>) obj); remainingParameters.remove("records"); } } } List<ParameterInfo> methodParameters = methodInfo.getParameters(); Object[] parameters = null; if (!methodParameters.isEmpty()) { parameters = new Object[methodParameters.size()]; for (int paramIndex = 0; paramIndex < methodParameters.size(); paramIndex++) { ParameterInfo methodParameter = methodParameters.get(paramIndex); if (methodParameter.isSupportedParameter()) { parameters[paramIndex] = SupportedParameters.resolveParameter(methodParameter.getType(), request, response, locale, directRequest); } else if (ExtDirectStoreReadRequest.class.isAssignableFrom(methodParameter.getType())) { parameters[paramIndex] = extDirectStoreReadRequest; } else if (directStoreModifyRecords != null && methodParameter.getCollectionType() != null) { parameters[paramIndex] = directStoreModifyRecords; } else if (methodParameter.hasRequestParamAnnotation()) { parameters[paramIndex] = resolveRequestParam(null, remainingParameters, methodParameter); } else if (methodParameter.hasMetadataParamAnnotation()) { parameters[paramIndex] = resolveRequestParam(null, directRequest.getMetadata(), methodParameter); } else if (methodParameter.hasRequestHeaderAnnotation()) { parameters[paramIndex] = resolveRequestHeader(request, methodParameter); } else if (methodParameter.hasCookieValueAnnotation()) { parameters[paramIndex] = resolveCookieValue(request, methodParameter); } else if (methodParameter.hasAuthenticationPrincipalAnnotation()) { parameters[paramIndex] = resolveAuthenticationPrincipal(methodParameter); } else if (remainingParameters != null && remainingParameters.containsKey(methodParameter.getName())) { Object jsonValue = remainingParameters.get(methodParameter.getName()); parameters[paramIndex] = convertValue(jsonValue, methodParameter); } else if (directRequest.getData() != null && directRequest.getData() instanceof List && ((List<Object>) directRequest.getData()).size() > jsonParamIndex) { Object jsonValue = ((List<Object>) directRequest.getData()).get(jsonParamIndex); parameters[paramIndex] = convertValue(jsonValue, methodParameter); jsonParamIndex++; } else { if (methodInfo.isType(ExtDirectMethodType.SIMPLE_NAMED)) { if (Map.class.isAssignableFrom(methodParameter.getType())) { parameters[paramIndex] = remainingParameters; continue; } else if (methodParameter.isJavaUtilOptional()) { parameters[paramIndex] = javaUtilOptionalEmpty; continue; } } log.info("WebResolvers size:" + this.webArgumentResolvers.size()); log.info("ParamIndex:" + paramIndex); log.info("Request params size:" + request.getParameterMap().isEmpty()); log.info("Request params names:" + request.getParameterMap().keySet()); log.info("Direct Request:" + directRequest.toString()); MethodParameter p = new MethodParameter(methodInfo.getMethod(), paramIndex); request.setAttribute("directRequest", directRequest); request.setAttribute("extDirectStoreReadRequest", extDirectStoreReadRequest); ServletWebRequest r = new ServletWebRequest(request); Object result = WebArgumentResolver.UNRESOLVED; for (WebArgumentResolver resolver : this.webArgumentResolvers) { log.info("Resolving with:" + resolver.getClass().getCanonicalName()); result = resolver.resolveArgument(p, r); if (result != WebArgumentResolver.UNRESOLVED) { log.info("Resolved by:" + resolver.getClass().getCanonicalName()); parameters[paramIndex] = result; break; } } if (result == WebArgumentResolver.UNRESOLVED) { throw new IllegalArgumentException( "Error, parameter mismatch. Please check your remoting method signature to ensure all supported parameters types are used."); } } } } return parameters; } private Object resolveRequestParam(HttpServletRequest request, Map<String, Object> valueContainer, final ParameterInfo parameterInfo) { if (parameterInfo.getName() != null) { Object value; if (request != null) { value = request.getParameter(parameterInfo.getName()); } else if (valueContainer != null) { value = valueContainer.get(parameterInfo.getName()); } else { value = null; } if (value == null) { value = parameterInfo.getDefaultValue(); } if (value != null) { return convertValue(value, parameterInfo); } // value is null and the parameter is java.util.Optional then return an empty // Optional if (parameterInfo.isJavaUtilOptional()) { return javaUtilOptionalEmpty; } if (parameterInfo.isRequired()) { throw new IllegalStateException("Missing parameter '" + parameterInfo.getName() + "' of type [" + parameterInfo.getTypeDescriptor().getType() + "]"); } } return null; } private Object resolveRequestHeader(HttpServletRequest request, ParameterInfo parameterInfo) { String value = request.getHeader(parameterInfo.getName()); if (value == null) { value = parameterInfo.getDefaultValue(); } if (value != null) { return convertValue(value, parameterInfo); } // value is null and the parameter is java.util.Optional then return an empty // Optional if (parameterInfo.isJavaUtilOptional()) { return javaUtilOptionalEmpty; } if (parameterInfo.isRequired()) { throw new IllegalStateException("Missing header '" + parameterInfo.getName() + "' of type [" + parameterInfo.getTypeDescriptor().getType() + "]"); } return null; } private Object resolveCookieValue(HttpServletRequest request, ParameterInfo parameterInfo) { Cookie cookieValue = WebUtils.getCookie(request, parameterInfo.getName()); String value = null; if (cookieValue != null) { value = this.urlPathHelper.decodeRequestString(request, cookieValue.getValue()); } else { value = parameterInfo.getDefaultValue(); } if (value != null) { return convertValue(value, parameterInfo); } // value is null and the parameter is java.util.Optional then return an empty // Optional if (parameterInfo.isJavaUtilOptional()) { return javaUtilOptionalEmpty; } if (parameterInfo.isRequired()) { throw new IllegalStateException("Missing cookie '" + parameterInfo.getName() + "' of type [" + parameterInfo.getTypeDescriptor().getType() + "]"); } return null; } private Object resolveAuthenticationPrincipal(ParameterInfo parameterInfo) { Object principal = this.getPrincipalExpression.getValue(); if (principal != null && !parameterInfo.getType().isAssignableFrom(principal.getClass())) { if (parameterInfo.authenticationPrincipalAnnotationErrorOnInvalidType()) { throw new ClassCastException(principal + " is not assignable to " + parameterInfo.getType()); } return null; } return principal; } private Object convertValue(Object value, ParameterInfo methodParameter) { if (value != null) { Class<?> rawType = methodParameter.getType(); if (rawType.equals(value.getClass())) { return value; } else if (this.conversionService.canConvert(TypeDescriptor.forObject(value), methodParameter.getTypeDescriptor())) { try { return this.conversionService.convert(value, TypeDescriptor.forObject(value), methodParameter.getTypeDescriptor()); } catch (ConversionFailedException e) { // ignore this exception for collections and arrays. // try to convert the value with jackson TypeFactory typeFactory = this.jsonHandler.getMapper().getTypeFactory(); if (methodParameter.getTypeDescriptor().isCollection()) { JavaType elemType = typeFactory.constructType( methodParameter.getTypeDescriptor().getElementTypeDescriptor().getType()); TypeVariable<?>[] vars = rawType.getTypeParameters(); TypeBindings bindings; if ((vars == null) || (vars.length != 1)) { bindings = TypeBindings.emptyBindings(); } else { bindings = TypeBindings.create(rawType, elemType); } JavaType superClass = null; Class<?> parent = rawType.getSuperclass(); if (parent != null) { superClass = TypeFactory.unknownType(); } JavaType type = CollectionType.construct(rawType, bindings, superClass, null, elemType); return this.jsonHandler.convertValue(value, type); } else if (methodParameter.getTypeDescriptor().isArray()) { JavaType type = typeFactory.constructArrayType( methodParameter.getTypeDescriptor().getElementTypeDescriptor().getType()); return this.jsonHandler.convertValue(value, type); } throw e; } } else { return this.jsonHandler.convertValue(value, rawType); } } else if (methodParameter.isJavaUtilOptional()) { return javaUtilOptionalEmpty; } return null; } private Map<String, Object> fillReadRequestFromMap(ExtDirectStoreReadRequest to, Map<String, Object> from) { Set<String> foundParameters = new HashSet<String>(); for (Entry<String, Object> entry : from.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); if (key.equals("filter")) { List<Filter> filters = new ArrayList<Filter>(); if (value instanceof String) { List<Map<String, Object>> rawFilters = this.jsonHandler.readValue((String) value, new TypeReference<List<Map<String, Object>>>() {/* empty */ }); for (Map<String, Object> rawFilter : rawFilters) { Filter filter = Filter.createFilter(rawFilter, this.conversionService); if (filter != null) { filters.add(filter); } } } else if (value instanceof List) { @SuppressWarnings("unchecked") List<Map<String, Object>> filterList = (List<Map<String, Object>>) value; for (Map<String, Object> rawFilter : filterList) { Filter filter = Filter.createFilter(rawFilter, this.conversionService); if (filter != null) { filters.add(filter); } } } to.setFilters(filters); foundParameters.add(key); } else if (key.equals("sort") && value != null && value instanceof List) { List<SortInfo> sorters = new ArrayList<SortInfo>(); @SuppressWarnings("unchecked") List<Map<String, Object>> rawSorters = (List<Map<String, Object>>) value; for (Map<String, Object> aRawSorter : rawSorters) { sorters.add(SortInfo.create(aRawSorter)); } to.setSorters(sorters); foundParameters.add(key); } else if (key.equals("group") && value != null && value instanceof List) { List<GroupInfo> groups = new ArrayList<GroupInfo>(); @SuppressWarnings("unchecked") List<Map<String, Object>> rawGroups = (List<Map<String, Object>>) value; for (Map<String, Object> aRawGroupInfo : rawGroups) { groups.add(GroupInfo.create(aRawGroupInfo)); } to.setGroups(groups); foundParameters.add(key); } else { PropertyDescriptor descriptor = BeanUtils.getPropertyDescriptor(to.getClass(), key); if (descriptor != null && descriptor.getWriteMethod() != null) { try { descriptor.getWriteMethod().invoke(to, this.conversionService.convert(value, descriptor.getPropertyType())); foundParameters.add(key); } catch (IllegalArgumentException e) { log.error("fillObjectFromMap", e); } catch (IllegalAccessException e) { log.error("fillObjectFromMap", e); } catch (InvocationTargetException e) { log.error("fillObjectFromMap", e); } } } } if (to.getLimit() != null) { // this test is no longer needed with extjs 4.0.7 and extjs 4.1.0 // these two libraries always send page, start and limit if (to.getPage() != null && to.getStart() == null) { to.setStart(to.getLimit() * (to.getPage() - 1)); // the else if is still valid for extjs 3 code } else if (to.getPage() == null && to.getStart() != null) { to.setPage(to.getStart() / to.getLimit() + 1); } } if (to.getSort() != null && to.getDir() != null) { List<SortInfo> sorters = new ArrayList<SortInfo>(); sorters.add(new SortInfo(to.getSort(), SortDirection.fromString(to.getDir()))); to.setSorters(sorters); } if (to.getGroupBy() != null && to.getGroupDir() != null) { List<GroupInfo> groups = new ArrayList<GroupInfo>(); groups.add(new GroupInfo(to.getGroupBy(), SortDirection.fromString(to.getGroupDir()))); to.setGroups(groups); } Map<String, Object> remainingParameters = new HashMap<String, Object>(); for (Entry<String, Object> entry : from.entrySet()) { if (!foundParameters.contains(entry.getKey())) { remainingParameters.put(entry.getKey(), entry.getValue()); } } to.setParams(remainingParameters); return remainingParameters; } private List<Object> convertObjectEntriesToType(List<Object> records, Class<?> directStoreType) { if (records != null) { List<Object> convertedList = new ArrayList<Object>(); for (Object record : records) { Object convertedObject = this.jsonHandler.convertValue(record, directStoreType); convertedList.add(convertedObject); } return convertedList; } return null; } }