Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.camel.maven; import java.io.File; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.TreeMap; import java.util.regex.Pattern; import org.apache.camel.util.component.ApiMethodParser; import org.apache.camel.util.component.ArgumentSubstitutionParser; import org.apache.commons.lang.ClassUtils; import org.apache.maven.plugin.MojoExecutionException; import org.apache.maven.plugin.MojoFailureException; import org.apache.maven.plugins.annotations.Parameter; import org.apache.velocity.VelocityContext; /** * Base Mojo class for ApiMethod generators. */ public abstract class AbstractApiMethodGeneratorMojo extends AbstractApiMethodBaseMojo { private static final Map<Class<?>, String> PRIMITIVE_VALUES; @Parameter(required = true, property = PREFIX + "proxyClass") protected String proxyClass; // cached fields private Class<?> proxyType; private Pattern propertyNamePattern; private Pattern propertyTypePattern; @Override public void execute() throws MojoExecutionException, MojoFailureException { // load proxy class and get enumeration file to generate final Class proxyType = getProxyType(); // parse pattern for excluded endpoint properties if (excludeConfigNames != null) { propertyNamePattern = Pattern.compile(excludeConfigNames); } if (excludeConfigTypes != null) { propertyTypePattern = Pattern.compile(excludeConfigTypes); } // create parser ApiMethodParser parser = createAdapterParser(proxyType); parser.setSignatures(getSignatureList()); parser.setClassLoader(getProjectClassLoader()); // parse signatures @SuppressWarnings("unchecked") final List<ApiMethodParser.ApiMethodModel> models = parser.parse(); // generate enumeration from model mergeTemplate(getApiMethodContext(models), getApiMethodFile(), "/api-method-enum.vm"); // generate EndpointConfiguration for this Api mergeTemplate(getEndpointContext(models), getConfigurationFile(), "/api-endpoint-config.vm"); // generate junit test if it doesn't already exist under test source directory // i.e. it may have been generated then moved there and populated with test values final String testFilePath = getTestFilePath(); if (!new File(project.getBuild().getTestSourceDirectory(), testFilePath).exists()) { mergeTemplate(getApiTestContext(models), new File(generatedTestDir, testFilePath), "/api-route-test.vm"); } } @SuppressWarnings("unchecked") protected ApiMethodParser createAdapterParser(Class proxyType) { return new ArgumentSubstitutionParser(proxyType, getArgumentSubstitutions()); } public abstract List<String> getSignatureList() throws MojoExecutionException; public Class<?> getProxyType() throws MojoExecutionException { if (proxyType == null) { // load proxy class from Project runtime dependencies try { proxyType = getProjectClassLoader().loadClass(proxyClass); } catch (ClassNotFoundException e) { throw new MojoExecutionException(e.getMessage(), e); } } return proxyType; } private VelocityContext getApiMethodContext(List<ApiMethodParser.ApiMethodModel> models) throws MojoExecutionException { VelocityContext context = getCommonContext(models); context.put("enumName", getEnumName()); return context; } public File getApiMethodFile() throws MojoExecutionException { final StringBuilder fileName = new StringBuilder(); fileName.append(outPackage.replaceAll("\\.", File.separator)).append(File.separator); fileName.append(getEnumName()).append(".java"); return new File(generatedSrcDir, fileName.toString()); } private String getEnumName() throws MojoExecutionException { return getProxyType().getSimpleName() + "ApiMethod"; } private VelocityContext getApiTestContext(List<ApiMethodParser.ApiMethodModel> models) throws MojoExecutionException { VelocityContext context = getCommonContext(models); context.put("testName", getUnitTestName()); context.put("scheme", scheme); context.put("componentPackage", componentPackage); context.put("componentName", componentName); context.put("enumName", getEnumName()); return context; } private String getTestFilePath() throws MojoExecutionException { final StringBuilder fileName = new StringBuilder(); fileName.append(componentPackage.replaceAll("\\.", File.separator)).append(File.separator); fileName.append(getUnitTestName()).append(".java"); return fileName.toString(); } private String getUnitTestName() throws MojoExecutionException { return getProxyType().getSimpleName() + "IntegrationTest"; } private VelocityContext getEndpointContext(List<ApiMethodParser.ApiMethodModel> models) throws MojoExecutionException { VelocityContext context = getCommonContext(models); context.put("configName", getConfigName()); context.put("componentName", componentName); context.put("componentPackage", componentPackage); // generate parameter names and types for configuration, sorted by parameter name Map<String, ApiMethodParser.Argument> parameters = new TreeMap<String, ApiMethodParser.Argument>(); for (ApiMethodParser.ApiMethodModel model : models) { for (ApiMethodParser.Argument argument : model.getArguments()) { final String name = argument.getName(); final Class<?> type = argument.getType(); final String typeName = type.getCanonicalName(); if (!parameters.containsKey(name) && (propertyNamePattern == null || !propertyNamePattern.matcher(name).matches()) && (propertyTypePattern == null || !propertyTypePattern.matcher(typeName).matches())) { parameters.put(name, argument); } } } // add custom parameters if (extraOptions != null && extraOptions.length > 0) { for (ExtraOption option : extraOptions) { final String name = option.getName(); final String argWithTypes = option.getType().replaceAll(" ", ""); final int rawEnd = argWithTypes.indexOf('<'); String typeArgs = null; Class<?> argType; try { if (rawEnd != -1) { argType = getProjectClassLoader().loadClass(argWithTypes.substring(0, rawEnd)); typeArgs = argWithTypes.substring(rawEnd + 1, argWithTypes.lastIndexOf('>')); } else { argType = getProjectClassLoader().loadClass(argWithTypes); } } catch (ClassNotFoundException e) { throw new MojoExecutionException(String.format("Error loading extra option [%s %s] : %s", argWithTypes, name, e.getMessage()), e); } parameters.put(name, new ApiMethodParser.Argument(name, argType, typeArgs)); } } context.put("parameters", parameters); return context; } private File getConfigurationFile() throws MojoExecutionException { final StringBuilder fileName = new StringBuilder(); // endpoint configuration goes in component package fileName.append(componentPackage.replaceAll("\\.", File.separator)).append(File.separator); fileName.append(getConfigName()).append(".java"); return new File(generatedSrcDir, fileName.toString()); } private String getConfigName() throws MojoExecutionException { return getProxyType().getSimpleName() + "EndpointConfiguration"; } private VelocityContext getCommonContext(List<ApiMethodParser.ApiMethodModel> models) throws MojoExecutionException { VelocityContext context = new VelocityContext(); context.put("models", models); context.put("proxyType", getProxyType()); context.put("helper", this); return context; } public ArgumentSubstitutionParser.Substitution[] getArgumentSubstitutions() { ArgumentSubstitutionParser.Substitution[] subs = new ArgumentSubstitutionParser.Substitution[substitutions.length]; for (int i = 0; i < substitutions.length; i++) { final Substitution substitution = substitutions[i]; subs[i] = new ArgumentSubstitutionParser.Substitution(substitution.getMethod(), substitution.getArgName(), substitution.getArgType(), substitution.getReplacement(), substitution.isReplaceWithType()); } return subs; } public static String getType(Class<?> clazz) { if (clazz.isArray()) { // create a zero length array and get the class from the instance return "new " + getCanonicalName(clazz).replaceAll("\\[\\]", "[0]") + ".getClass()"; } else { return getCanonicalName(clazz) + ".class"; } } public static String getTestName(ApiMethodParser.ApiMethodModel model) { final StringBuilder builder = new StringBuilder(); final String name = model.getMethod().getName(); builder.append(Character.toUpperCase(name.charAt(0))); builder.append(name.substring(1)); // find overloaded method suffix from unique name final String uniqueName = model.getUniqueName(); if (uniqueName.length() > name.length()) { builder.append(uniqueName.substring(name.length())); } return builder.toString(); } public static boolean isVoidType(Class<?> resultType) { return resultType == Void.TYPE; } public String getExchangePropertyPrefix() { // exchange property prefix return "Camel" + componentName + "."; } public static String getResultDeclaration(Class<?> resultType) { if (resultType.isPrimitive()) { return ClassUtils.primitiveToWrapper(resultType).getSimpleName(); } else { return getCanonicalName(resultType); } } static { PRIMITIVE_VALUES = new HashMap<Class<?>, String>(); PRIMITIVE_VALUES.put(Boolean.TYPE, "Boolean.FALSE"); PRIMITIVE_VALUES.put(Byte.TYPE, "(byte) 0"); PRIMITIVE_VALUES.put(Character.TYPE, "(char) 0"); PRIMITIVE_VALUES.put(Short.TYPE, "(short) 0"); PRIMITIVE_VALUES.put(Integer.TYPE, "0"); PRIMITIVE_VALUES.put(Long.TYPE, "0L"); PRIMITIVE_VALUES.put(Float.TYPE, "0.0f"); PRIMITIVE_VALUES.put(Double.TYPE, "0.0d"); } public static String getDefaultArgValue(Class<?> aClass) { if (aClass.isPrimitive()) { // lookup default primitive value string return PRIMITIVE_VALUES.get(aClass); } else { // return type cast null string return "null"; } } public static String getBeanPropertySuffix(String parameter) { // capitalize first character StringBuilder builder = new StringBuilder(); builder.append(Character.toUpperCase(parameter.charAt(0))); builder.append(parameter.substring(1)); return builder.toString(); } public String getCanonicalName(ApiMethodParser.Argument argument) throws MojoExecutionException { // replace primitives with wrapper classes final Class<?> type = argument.getType(); if (type.isPrimitive()) { return getCanonicalName(ClassUtils.primitiveToWrapper(type)); } // get default name prefix String canonicalName = getCanonicalName(type); final String typeArgs = argument.getTypeArgs(); if (typeArgs != null) { // add generic type arguments StringBuilder parameterizedType = new StringBuilder(canonicalName); parameterizedType.append('<'); // Note: its ok to split, since we don't support parsing nested type arguments final String[] argTypes = typeArgs.split(","); boolean ignore = false; final int nTypes = argTypes.length; int i = 0; for (String argType : argTypes) { // try loading as is first try { parameterizedType.append(getCanonicalName(getProjectClassLoader().loadClass(argType))); } catch (ClassNotFoundException e) { // try loading with default java.lang package prefix try { if (log.isDebugEnabled()) { log.debug("Could not load " + argType + ", trying to load java.lang." + argType); } parameterizedType.append( getCanonicalName(getProjectClassLoader().loadClass("java.lang." + argType))); } catch (ClassNotFoundException e1) { log.warn("Ignoring type parameters <" + typeArgs + "> for argument " + argument.getName() + ", unable to load parametric type argument " + argType, e1); ignore = true; } } if (ignore) { // give up break; } else if (++i < nTypes) { parameterizedType.append(","); } } if (!ignore) { parameterizedType.append('>'); canonicalName = parameterizedType.toString(); } } return canonicalName; } }