You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by nf...@apache.org on 2016/11/08 12:53:58 UTC
[4/9] camel git commit: CAMEL-10186: Changed the generator mojo to
create Java files for components without properties
CAMEL-10186: Changed the generator mojo to create Java files for components without properties
Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/688e7ac1
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/688e7ac1
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/688e7ac1
Branch: refs/heads/master
Commit: 688e7ac111493e187ecbc41e2db95d2ed758082f
Parents: 3547f89
Author: Nicola Ferraro <ni...@gmail.com>
Authored: Tue Nov 8 12:13:03 2016 +0100
Committer: Nicola Ferraro <ni...@gmail.com>
Committed: Tue Nov 8 13:50:18 2016 +0100
----------------------------------------------------------------------
.../SpringBootAutoConfigurationMojo.java | 223 ++++++++++---------
1 file changed, 120 insertions(+), 103 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/camel/blob/688e7ac1/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/SpringBootAutoConfigurationMojo.java
----------------------------------------------------------------------
diff --git a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/SpringBootAutoConfigurationMojo.java b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/SpringBootAutoConfigurationMojo.java
index 0320934..def3966 100644
--- a/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/SpringBootAutoConfigurationMojo.java
+++ b/tooling/maven/camel-package-maven-plugin/src/main/java/org/apache/camel/maven/packaging/SpringBootAutoConfigurationMojo.java
@@ -176,30 +176,30 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
}
// Group the models by implementing classes
- Map<String, List<ComponentModel>> grModels = allModels.stream().collect(Collectors.groupingBy(m -> m.getJavaType()));
+ Map<String, List<ComponentModel>> grModels = allModels.stream().collect(Collectors.groupingBy(ComponentModel::getJavaType));
for (String componentClass : grModels.keySet()) {
List<ComponentModel> compModels = grModels.get(componentClass);
ComponentModel model = compModels.get(0); // They should be equivalent
- List<String> aliases = compModels.stream().map(m -> m.getScheme()).sorted().collect(Collectors.toList());
+ List<String> aliases = compModels.stream().map(ComponentModel::getScheme).sorted().collect(Collectors.toList());
- // only create source code if the component has options that can be used in auto configuration
- if (!model.getComponentOptions().isEmpty()) {
+ boolean hasOptions = !model.getComponentOptions().isEmpty();
- // use springboot as sub package name so the code is not in normal
- // package so the Spring Boot JARs can be optional at runtime
- int pos = model.getJavaType().lastIndexOf(".");
- String pkg = model.getJavaType().substring(0, pos) + ".springboot";
+ // use springboot as sub package name so the code is not in normal
+ // package so the Spring Boot JARs can be optional at runtime
+ int pos = model.getJavaType().lastIndexOf(".");
+ String pkg = model.getJavaType().substring(0, pos) + ".springboot";
- String overrideComponentName = null;
- if (aliases.size() > 1) {
- // determine component name when there are multiple ones
- overrideComponentName = model.getArtifactId().replace("camel-", "");
- }
+ String overrideComponentName = null;
+ if (aliases.size() > 1) {
+ // determine component name when there are multiple ones
+ overrideComponentName = model.getArtifactId().replace("camel-", "");
+ }
+ if (hasOptions) {
createComponentConfigurationSource(pkg, model, overrideComponentName);
- createComponentAutoConfigurationSource(pkg, model, aliases);
- createComponentSpringFactorySource(pkg, model);
}
+ createComponentAutoConfigurationSource(pkg, model, aliases, hasOptions);
+ createComponentSpringFactorySource(pkg, model);
}
}
}
@@ -232,24 +232,24 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
DataFormatModel model = dfModels.get(0); // They should be equivalent
List<String> aliases = dfModels.stream().map(m -> m.getName()).sorted().collect(Collectors.toList());
- // only create source code if the data format has options that can be used in auto configuration
- if (!model.getDataFormatOptions().isEmpty()) {
+ boolean hasOptions = !model.getDataFormatOptions().isEmpty();
- // use springboot as sub package name so the code is not in normal
- // package so the Spring Boot JARs can be optional at runtime
- int pos = model.getJavaType().lastIndexOf(".");
- String pkg = model.getJavaType().substring(0, pos) + ".springboot";
+ // use springboot as sub package name so the code is not in normal
+ // package so the Spring Boot JARs can be optional at runtime
+ int pos = model.getJavaType().lastIndexOf(".");
+ String pkg = model.getJavaType().substring(0, pos) + ".springboot";
- String overrideDataformatName = null;
- if (aliases.size() > 1) {
- // determine component name when there are multiple ones
- overrideDataformatName = model.getArtifactId().replace("camel-", "");
- }
+ String overrideDataformatName = null;
+ if (aliases.size() > 1) {
+ // determine component name when there are multiple ones
+ overrideDataformatName = model.getArtifactId().replace("camel-", "");
+ }
+ if (hasOptions) {
createDataFormatConfigurationSource(pkg, model, overrideDataformatName);
- createDataFormatAutoConfigurationSource(pkg, model, aliases);
- createDataFormatSpringFactorySource(pkg, model);
}
+ createDataFormatAutoConfigurationSource(pkg, model, aliases, hasOptions);
+ createDataFormatSpringFactorySource(pkg, model);
}
}
}
@@ -282,24 +282,25 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
LanguageModel model = dfModels.get(0); // They should be equivalent
List<String> aliases = dfModels.stream().map(m -> m.getName()).sorted().collect(Collectors.toList());
- // only create source code if the language has options that can be used in auto configuration
- if (!model.getLanguageOptions().isEmpty()) {
- // use springboot as sub package name so the code is not in normal
- // package so the Spring Boot JARs can be optional at runtime
- int pos = model.getJavaType().lastIndexOf(".");
- String pkg = model.getJavaType().substring(0, pos) + ".springboot";
+ boolean hasOptions = !model.getLanguageOptions().isEmpty();
- String overrideLanguageName = null;
- if (aliases.size() > 1) {
- // determine language name when there are multiple ones
- overrideLanguageName = model.getArtifactId().replace("camel-", "");
- }
+ // use springboot as sub package name so the code is not in normal
+ // package so the Spring Boot JARs can be optional at runtime
+ int pos = model.getJavaType().lastIndexOf(".");
+ String pkg = model.getJavaType().substring(0, pos) + ".springboot";
+ String overrideLanguageName = null;
+ if (aliases.size() > 1) {
+ // determine language name when there are multiple ones
+ overrideLanguageName = model.getArtifactId().replace("camel-", "");
+ }
+
+ if (hasOptions) {
createLanguageConfigurationSource(pkg, model, overrideLanguageName);
- createLanguageAutoConfigurationSource(pkg, model, aliases);
- createLanguageSpringFactorySource(pkg, model);
}
+ createLanguageAutoConfigurationSource(pkg, model, aliases, hasOptions);
+ createLanguageSpringFactorySource(pkg, model);
}
}
}
@@ -755,7 +756,7 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
writeSourceIfChanged(javaClass, fileName);
}
- private void createComponentAutoConfigurationSource(String packageName, ComponentModel model, List<String> componentAliases) throws MojoFailureException {
+ private void createComponentAutoConfigurationSource(String packageName, ComponentModel model, List<String> componentAliases, boolean hasOptions) throws MojoFailureException {
final JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
int pos = model.getJavaType().lastIndexOf(".");
@@ -770,18 +771,20 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
javaClass.addAnnotation(ConditionalOnBean.class).setStringValue("type", "org.apache.camel.springboot.CamelAutoConfiguration");
String configurationName = name.replace("ComponentAutoConfiguration", "ComponentConfiguration");
- AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
- ann.setLiteralValue("value", configurationName + ".class");
+ if (hasOptions) {
+ AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
+ ann.setLiteralValue("value", configurationName + ".class");
- // add method for auto configure
+ javaClass.addImport("java.util.HashMap");
+ javaClass.addImport("java.util.Map");
+ javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
+ }
- javaClass.addImport("java.util.HashMap");
- javaClass.addImport("java.util.Map");
javaClass.addImport(model.getJavaType());
javaClass.addImport("org.apache.camel.CamelContext");
- javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
- String body = createComponentBody(model.getShortJavaType());
+ // add method for auto configure
+ String body = createComponentBody(model.getShortJavaType(), hasOptions);
String methodName = "configure" + model.getShortJavaType();
MethodSource<JavaClassSource> method = javaClass.addMethod()
@@ -792,7 +795,10 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
.addThrows(Exception.class);
method.addParameter("CamelContext", "camelContext");
- method.addParameter(configurationName, "configuration");
+
+ if (hasOptions) {
+ method.addParameter(configurationName, "configuration");
+ }
// Determine all the aliases
String[] springBeanAliases = componentAliases.stream().map(alias -> alias + "-component").toArray(size -> new String[size]);
@@ -808,7 +814,7 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
writeSourceIfChanged(javaClass, fileName);
}
- private void createDataFormatAutoConfigurationSource(String packageName, DataFormatModel model, List<String> dataFormatAliases) throws MojoFailureException {
+ private void createDataFormatAutoConfigurationSource(String packageName, DataFormatModel model, List<String> dataFormatAliases, boolean hasOptions) throws MojoFailureException {
final JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
int pos = model.getJavaType().lastIndexOf(".");
@@ -823,19 +829,20 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
javaClass.addAnnotation(ConditionalOnBean.class).setStringValue("type", "org.apache.camel.springboot.CamelAutoConfiguration");
String configurationName = name.replace("DataFormatAutoConfiguration", "DataFormatConfiguration");
- AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
- ann.setLiteralValue("value", configurationName + ".class");
+ if (hasOptions) {
+ AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
+ ann.setLiteralValue("value", configurationName + ".class");
- // add method for auto configure
+ javaClass.addImport("java.util.HashMap");
+ javaClass.addImport("java.util.Map");
+ javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
+ }
- javaClass.addImport("java.util.HashMap");
- javaClass.addImport("java.util.Map");
+ javaClass.addImport("org.apache.camel.CamelContextAware");
javaClass.addImport(model.getJavaType());
javaClass.addImport("org.apache.camel.CamelContext");
- javaClass.addImport("org.apache.camel.CamelContextAware");
- javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
- String body = createDataFormatBody(model.getShortJavaType());
+ String body = createDataFormatBody(model.getShortJavaType(), hasOptions);
String methodName = "configure" + model.getShortJavaType();
MethodSource<JavaClassSource> method = javaClass.addMethod()
@@ -846,7 +853,10 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
.addThrows(Exception.class);
method.addParameter("CamelContext", "camelContext");
- method.addParameter(configurationName, "configuration");
+
+ if (hasOptions) {
+ method.addParameter(configurationName, "configuration");
+ }
// Determine all the aliases
@@ -864,7 +874,7 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
writeSourceIfChanged(javaClass, fileName);
}
- private void createLanguageAutoConfigurationSource(String packageName, LanguageModel model, List<String> languageAliases) throws MojoFailureException {
+ private void createLanguageAutoConfigurationSource(String packageName, LanguageModel model, List<String> languageAliases, boolean hasOptions) throws MojoFailureException {
final JavaClassSource javaClass = Roaster.create(JavaClassSource.class);
int pos = model.getJavaType().lastIndexOf(".");
@@ -879,19 +889,20 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
javaClass.addAnnotation(ConditionalOnBean.class).setStringValue("type", "org.apache.camel.springboot.CamelAutoConfiguration");
String configurationName = name.replace("LanguageAutoConfiguration", "LanguageConfiguration");
- AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
- ann.setLiteralValue("value", configurationName + ".class");
+ if (hasOptions) {
+ AnnotationSource<JavaClassSource> ann = javaClass.addAnnotation(EnableConfigurationProperties.class);
+ ann.setLiteralValue("value", configurationName + ".class");
- // add method for auto configure
+ javaClass.addImport("java.util.HashMap");
+ javaClass.addImport("java.util.Map");
+ javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
+ }
- javaClass.addImport("java.util.HashMap");
- javaClass.addImport("java.util.Map");
+ javaClass.addImport("org.apache.camel.CamelContextAware");
javaClass.addImport(model.getJavaType());
javaClass.addImport("org.apache.camel.CamelContext");
- javaClass.addImport("org.apache.camel.CamelContextAware");
- javaClass.addImport("org.apache.camel.util.IntrospectionSupport");
- String body = createLanguageBody(model.getShortJavaType());
+ String body = createLanguageBody(model.getShortJavaType(), hasOptions);
String methodName = "configure" + model.getShortJavaType();
MethodSource<JavaClassSource> method = javaClass.addMethod()
@@ -944,64 +955,70 @@ public class SpringBootAutoConfigurationMojo extends AbstractMojo {
writeComponentSpringFactorySource(packageName, name);
}
- private static String createComponentBody(String shortJavaType) {
+ private static String createComponentBody(String shortJavaType, boolean hasOptions) {
StringBuilder sb = new StringBuilder();
sb.append(shortJavaType).append(" component = new ").append(shortJavaType).append("();").append("\n");
sb.append("component.setCamelContext(camelContext);\n");
sb.append("\n");
- sb.append("Map<String, Object> parameters = new HashMap<>();\n");
- sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
- sb.append("\n");
- sb.append("for (Map.Entry<String, Object> entry : parameters.entrySet()) {\n");
- sb.append(" Object value = entry.getValue();\n");
- sb.append(" Class<?> paramClass = value.getClass();\n");
- sb.append(" if (paramClass.getName().endsWith(\"NestedConfiguration\")) {\n");
- sb.append(" Class nestedClass = null;\n");
- sb.append(" try {\n");
- sb.append(" nestedClass = (Class) paramClass.getDeclaredField(\"CAMEL_NESTED_CLASS\").get(null);\n");
- sb.append(" HashMap<String, Object> nestedParameters = new HashMap<>();\n");
- sb.append(" IntrospectionSupport.getProperties(value, nestedParameters, null, false);\n");
- sb.append(" Object nestedProperty = nestedClass.newInstance();\n");
- sb.append(" IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), nestedProperty, nestedParameters);\n");
- sb.append(" entry.setValue(nestedProperty);\n");
- sb.append(" } catch (NoSuchFieldException e) {\n");
- sb.append(" // ignore, class must not be a nested configuration class after all\n");
- sb.append(" }\n");
- sb.append(" }\n");
- sb.append("}\n");
- sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters);\n");
+ if (hasOptions) {
+ sb.append("Map<String, Object> parameters = new HashMap<>();\n");
+ sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
+ sb.append("\n");
+ sb.append("for (Map.Entry<String, Object> entry : parameters.entrySet()) {\n");
+ sb.append(" Object value = entry.getValue();\n");
+ sb.append(" Class<?> paramClass = value.getClass();\n");
+ sb.append(" if (paramClass.getName().endsWith(\"NestedConfiguration\")) {\n");
+ sb.append(" Class nestedClass = null;\n");
+ sb.append(" try {\n");
+ sb.append(" nestedClass = (Class) paramClass.getDeclaredField(\"CAMEL_NESTED_CLASS\").get(null);\n");
+ sb.append(" HashMap<String, Object> nestedParameters = new HashMap<>();\n");
+ sb.append(" IntrospectionSupport.getProperties(value, nestedParameters, null, false);\n");
+ sb.append(" Object nestedProperty = nestedClass.newInstance();\n");
+ sb.append(" IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), nestedProperty, nestedParameters);\n");
+ sb.append(" entry.setValue(nestedProperty);\n");
+ sb.append(" } catch (NoSuchFieldException e) {\n");
+ sb.append(" // ignore, class must not be a nested configuration class after all\n");
+ sb.append(" }\n");
+ sb.append(" }\n");
+ sb.append("}\n");
+ sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), component, parameters);\n");
+ }
sb.append("\n");
sb.append("return component;");
return sb.toString();
}
- private static String createDataFormatBody(String shortJavaType) {
+ private static String createDataFormatBody(String shortJavaType, boolean hasOptions) {
StringBuilder sb = new StringBuilder();
sb.append(shortJavaType).append(" dataformat = new ").append(shortJavaType).append("();").append("\n");
sb.append("if (dataformat instanceof CamelContextAware) {\n");
sb.append(" ((CamelContextAware) dataformat).setCamelContext(camelContext);\n");
sb.append("}\n");
- sb.append("\n");
- sb.append("Map<String, Object> parameters = new HashMap<>();\n");
- sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
- sb.append("\n");
- sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), dataformat, parameters);\n");
+ if (hasOptions) {
+ sb.append("\n");
+ sb.append("Map<String, Object> parameters = new HashMap<>();\n");
+ sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
+ sb.append("\n");
+ sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), dataformat, parameters);\n");
+ }
sb.append("\n");
sb.append("return dataformat;");
return sb.toString();
}
- private static String createLanguageBody(String shortJavaType) {
+ private static String createLanguageBody(String shortJavaType, boolean hasOptions) {
StringBuilder sb = new StringBuilder();
sb.append(shortJavaType).append(" language = new ").append(shortJavaType).append("();").append("\n");
sb.append("if (language instanceof CamelContextAware) {\n");
sb.append(" ((CamelContextAware) language).setCamelContext(camelContext);\n");
sb.append("}\n");
- sb.append("\n");
- sb.append("Map<String, Object> parameters = new HashMap<>();\n");
- sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
- sb.append("\n");
- sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), language, parameters);\n");
+ if (hasOptions) {
+ sb.append("\n");
+ sb.append("Map<String, Object> parameters = new HashMap<>();\n");
+ sb.append("IntrospectionSupport.getProperties(configuration, parameters, null, false);\n");
+ sb.append("\n");
+ sb.append("IntrospectionSupport.setProperties(camelContext, camelContext.getTypeConverter(), language, parameters);\n");
+ }
sb.append("\n");
sb.append("return language;");
return sb.toString();