+
+
+ org.apache.maven
+ maven-artifact
+ ${version.lib.maven.plugin.api}
+ provided
+
+
+ org.apache.maven
+ maven-model
+ ${version.lib.maven.plugin.api}
+ provided
+
+
+ org.apache.maven
+ maven-plugin-api
+ ${version.lib.maven.plugin.api}
+ provided
+
+
+ org.apache.maven.plugin-tools
+ maven-plugin-annotations
+ ${version.lib.maven.plugin.annotations}
+ provided
+
+
+ org.apache.maven
+ maven-project
+ ${version.lib.maven.plugin.project}
+ provided
+
+
+
+ org.apiguardian
+ apiguardian-api
+ ${version.lib.apiguardian.api}
+
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
index 8c340ce7f04..c9a464af0cc 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/DescriptorClassCode.java
@@ -25,6 +25,28 @@
* New service descriptor metadata with its class code.
*/
public interface DescriptorClassCode {
+ /**
+ * Create a new instance.
+ *
+ * @param classCode class code that contains necessary information for the generated class.
+ * @param registryType type of registry that generates the descriptor (core, inject)
+ * @param weight weight of the service this descriptor describes
+ * @param contracts contracts of the service (i.e. {@code MyContract})
+ * @param factoryContracts factory contracts of this service (i.e. {@code Supplier})
+ * @return a new class code of service descriptor
+ */
+ static DescriptorClassCode create(ClassCode classCode,
+ String registryType,
+ double weight,
+ Set contracts,
+ Set factoryContracts) {
+ return new DescriptorClassCodeImpl(classCode,
+ registryType,
+ weight,
+ contracts,
+ factoryContracts);
+ }
+
/**
* New source code information.
*
diff --git a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java b/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
index 651ef707ffd..3fcc867a56d 100644
--- a/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
+++ b/service/codegen/src/main/java/io/helidon/service/codegen/GenerateServiceDescriptor.java
@@ -47,7 +47,7 @@
/**
* Generates a service descriptor.
*/
-class GenerateServiceDescriptor {
+public class GenerateServiceDescriptor {
static final TypeName SET_OF_RESOLVED_TYPES = TypeName.builder(TypeNames.SET)
.addTypeArgument(TypeNames.RESOLVED_TYPE_NAME)
.build();
@@ -89,11 +89,11 @@ private GenerateServiceDescriptor(TypeName generator,
* @param service service to create a descriptor for
* @return class model builder of the service descriptor
*/
- static ClassModel.Builder generate(TypeName generator,
- RegistryCodegenContext ctx,
- RegistryRoundContext roundContext,
- Collection allServices,
- TypeInfo service) {
+ public static ClassModel.Builder generate(TypeName generator,
+ RegistryCodegenContext ctx,
+ RegistryRoundContext roundContext,
+ Collection allServices,
+ TypeInfo service) {
return new GenerateServiceDescriptor(generator,
ctx,
roundContext,
diff --git a/service/inject/README.md b/service/inject/README.md
index 7a8f87f72a3..304f35e63a2 100644
--- a/service/inject/README.md
+++ b/service/inject/README.md
@@ -13,6 +13,7 @@ Helidon Inject includes:
- [Aspect Oriented Programming (interceptors)](#interceptors)
- [Events](events)
- [Programmatic Lookup](#programmatic-lookup)
+- [Startup](#startup)
- [Other](#other)
- [Glossary](#glossary)
@@ -361,6 +362,29 @@ Lookup parameter options:
- `TypeName` - the same, but using Helidon abstraction of type names (may have type arguments)
- `Lookup` - a full search criteria for a registry lookup
+# Startup
+
+The following options are available to start a service registry (and the application):
+
+1. Use API to create an `io.helidon.service.inject.InjectRegistryManager`
+2. Use the Helidon startup class `io.helidon.Main`, which will use the injection main class through service loader
+3. Use a generated main class, by default named `ApplicationMain` in the main package of the application (supports customization)
+
+## Generated Main Class
+
+To generate a main class, the Helidon Service Inject Maven plugin must be configured.
+This is expected to be configured only for an application (i.e. not for library modules) - this is the reason we do not generate it automatically.
+
+The generated main class will contain full, reflection less configuration of the service registry. It registers all services directly through API, and disables service discovery from classpath.
+
+The Main class can also be customized; to do this:
+1. Create a custom class (let's call it `CustomMain` as an example)
+2. The class must extend the injection main class (`public abstract class CustomMain extends InjectionMain`)
+3. The class must be annotated with `@Injection.Main`, so it is discovered by annotation processor
+4. Implement any desired methods; the generated class will only implement `serviceDescriptors(InjectConfig.Builder configBuilder)` (always), and `discoverServices()` (if created from the Maven plugin)
+
+For details on how to configure your build, see [Maven Plugin](../maven-plugin/README.md).
+
# Other
## API types quick reference
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
index d26291c3f97..5a643e45993 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
+++ b/service/inject/api/src/main/java/io/helidon/service/inject/api/Injection.java
@@ -311,6 +311,26 @@ private Injection() {
Class value() default Singleton.class;
}
+ /**
+ * Marks a custom main class (should be declared as {@code abstract}).
+ * This is a required annotation to make sure the generated main class extends the user's main class.
+ * Note that the custom main class MUST extend the {@code io.helidon.service.inject.InjectionMain} to customize
+ * startup sequence.
+ * The name {@code ApplicationMain} is reserved by service registry, and cannot be used for your custom main class;
+ * the generated name can be modified through {@code Maven} plugin configuration and annotation processor configuration.
+ *
+ * The generated main class adds registration of all available services to injection config,
+ * and disables service discovery to prevent any and all reflection done by service registry itself.
+ *
+ * To have correct startup of your application, use the {@code ApplicationMain} as your application entry point
+ * (such as a {@code mainClass} configured in {@code pom.xml} when using Maven and Helidon application parents).
+ */
+ @Documented
+ @Retention(RetentionPolicy.CLASS)
+ @Target(ElementType.TYPE)
+ public @interface Main {
+ }
+
/**
* Provides an ability to create more than one service instance from a single service definition.
* This is useful when the cardinality can only be determined at runtime.
diff --git a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java b/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
index 6f49a8ade71..6dad1fc703e 100644
--- a/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
+++ b/service/inject/api/src/main/java/io/helidon/service/inject/api/LookupSupport.java
@@ -110,6 +110,18 @@ static void addContract(Lookup.BuilderBase builder, Class contract) {
builder.addContract(ResolvedType.create(contract));
}
+ /**
+ * The managed services advertised types (i.e., typically its interfaces).
+ *
+ * @param builder builder instance
+ * @param contract contract the service implements
+ * @see Lookup#contracts()
+ */
+ @Prototype.BuilderMethod
+ static void addContract(Lookup.BuilderBase builder, TypeName contract) {
+ builder.addContract(ResolvedType.create(contract));
+ }
+
/**
* The managed service implementation type.
*
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
new file mode 100644
index 00000000000..4ba8d39126e
--- /dev/null
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/ApplicationMainGenerator.java
@@ -0,0 +1,260 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * 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 io.helidon.service.inject.codegen;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import io.helidon.codegen.CodegenException;
+import io.helidon.codegen.CodegenUtil;
+import io.helidon.codegen.ElementInfoPredicates;
+import io.helidon.codegen.classmodel.ClassModel;
+import io.helidon.codegen.classmodel.Method;
+import io.helidon.common.types.AccessModifier;
+import io.helidon.common.types.Annotations;
+import io.helidon.common.types.ElementSignature;
+import io.helidon.common.types.TypeInfo;
+import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
+import io.helidon.common.types.TypedElementInfo;
+
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.DOUBLE_ARRAY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_CONFIG_BUILDER;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_REGISTRY;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.STRING_ARRAY;
+import static java.util.function.Predicate.not;
+
+/**
+ * Utility for {@value #CLASS_NAME} class generation.
+ */
+public final class ApplicationMainGenerator {
+ /**
+ * Default class name of the generated main class.
+ */
+ public static final String CLASS_NAME = "ApplicationMain";
+ /**
+ * Signature of the {@code serviceDescriptors} method (this method is abstract in InjectionMain).
+ */
+ private static final ElementSignature METHOD_SERVICE_DESCRIPTORS = ElementSignature.createMethod(
+ TypeNames.PRIMITIVE_VOID,
+ "serviceDescriptors",
+ List.of(INJECT_CONFIG_BUILDER));
+ /**
+ * Signature of the {@code discoverServices} method.
+ */
+ private static final ElementSignature METHOD_DISCOVER_SERVICES = ElementSignature.createMethod(
+ TypeNames.PRIMITIVE_BOOLEAN,
+ "discoverServices",
+ List.of());
+ /**
+ * Signature of the {@code runLevels} method.
+ */
+ private static final ElementSignature METHOD_RUN_LEVELS = ElementSignature.createMethod(
+ DOUBLE_ARRAY,
+ "runLevels",
+ List.of(INJECT_CONFIG, INJECT_REGISTRY));
+
+ private ApplicationMainGenerator() {
+ }
+
+ /**
+ * Generate the common parts of the type.
+ *
+ *
+ *
Class declaration with javadoc, @Generated, and copyright, with name {@value #CLASS_NAME}
+ *
Protected constructor with javadoc
+ *
{@code public static void main} method with javadoc
+ *
+ *
+ * @param generator generator type name
+ * @param declaredSignatures signatures declared on custom main class (if any)
+ * @param superType super type of the generated class
+ * @param generatedType the type to generate
+ * @param discoverServices whether to discover services (false when all services are manually registered to the
+ * builder)
+ * @param addRunLevels whether to add run levels from discovered services
+ * @param serviceDescriptorsHandler handler of the service descriptor method
+ * @param runLevelHandler handler of the run level method
+ * @return class model builder
+ */
+ @SuppressWarnings("checkstyle:ParameterNumber") // all parameters are mandatory
+ public static ClassModel.Builder generate(TypeName generator,
+ Set declaredSignatures,
+ TypeName superType,
+ TypeName generatedType,
+ boolean discoverServices,
+ boolean addRunLevels,
+ CodeGeneratorHandler serviceDescriptorsHandler,
+ CodeGeneratorHandler runLevelHandler) {
+ ClassModel.Builder classModel = ClassModel.builder()
+ .type(generatedType)
+ .accessModifier(AccessModifier.PUBLIC)
+ .copyright(CodegenUtil.copyright(generator,
+ generator,
+ generatedType))
+ .addAnnotation(CodegenUtil.generatedAnnotation(generator,
+ generatedType,
+ generatedType,
+ "1",
+ ""))
+ .superType(superType)
+ .addDescriptionLine("Main class generated for Helidon Inject Application.")
+ .isFinal(true);
+
+ classModel.addConstructor(ctr -> ctr
+ .accessModifier(AccessModifier.PACKAGE_PRIVATE));
+
+ classModel.addMethod(main -> main
+ .accessModifier(AccessModifier.PUBLIC)
+ .isStatic(true)
+ .returnType(TypeNames.PRIMITIVE_VOID)
+ .description("Start the application.")
+ .name("main")
+ .addParameter(args -> args
+ .type(STRING_ARRAY)
+ .description("Command line arguments.")
+ .name("args"))
+ .update(it -> mainMethodBody(generatedType, it)));
+
+ if (!declaredSignatures.contains(METHOD_SERVICE_DESCRIPTORS)) {
+ // only create this method if it is not created by the user
+ classModel.addMethod(methodModel -> methodModel
+ .name("serviceDescriptors")
+ .addAnnotation(Annotations.OVERRIDE)
+ .accessModifier(AccessModifier.PROTECTED)
+ .returnType(TypeNames.PRIMITIVE_VOID)
+ .addParameter(config -> config
+ .type(INJECT_CONFIG_BUILDER)
+ .name("config"))
+ .update(it -> serviceDescriptorsHandler.handle(classModel, it, "config")));
+ }
+
+ if (discoverServices && !declaredSignatures.contains(METHOD_DISCOVER_SERVICES)) {
+ classModel.addMethod(discoverServicesMethod -> discoverServicesMethod
+ .name("discoverServices")
+ .addAnnotation(Annotations.OVERRIDE)
+ .accessModifier(AccessModifier.PROTECTED)
+ .returnType(TypeNames.PRIMITIVE_BOOLEAN)
+ .addContentLine("return true;"));
+ }
+
+ if (addRunLevels && !declaredSignatures.contains(METHOD_RUN_LEVELS)) {
+ classModel.addMethod(runLevels -> runLevels
+ .name("runLevels")
+ .addAnnotation(Annotations.OVERRIDE)
+ .accessModifier(AccessModifier.PUBLIC)
+ .returnType(DOUBLE_ARRAY)
+ .addParameter(config -> config
+ .type(INJECT_CONFIG)
+ .name("config"))
+ .addParameter(registry -> registry
+ .type(INJECT_REGISTRY)
+ .name("registry"))
+ .addContentLine("return new double[] {")
+ .update(it -> runLevelHandler.handle(classModel, it, "config"))
+ .addContentLine("};"));
+ }
+
+ return classModel;
+ }
+
+ /**
+ * Provides all relevant signatures that may override methods from {@code InjectionMain}.
+ *
+ * @param customMain type to analyze
+ * @return set of method signatures that are non-private, non-static
+ */
+ public static Set declaredSignatures(TypeInfo customMain) {
+ return customMain.elementInfo()
+ .stream()
+ .filter(ElementInfoPredicates::isMethod)
+ .filter(not(ElementInfoPredicates::isStatic))
+ .filter(not(ElementInfoPredicates::isPrivate))
+ .map(TypedElementInfo::signature)
+ .collect(Collectors.toUnmodifiableSet());
+ }
+
+ /**
+ * Validate a type, to make sure it is a valid custom main class.
+ *
+ * @param customMain type to validate
+ */
+ public static void validate(TypeInfo customMain) {
+ Optional superType = customMain.superTypeInfo();
+ if (superType.isEmpty()) {
+ throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
+ + customMain.typeName().fqName() + " does not extend any class",
+ customMain.originatingElementValue());
+ }
+ if (!superType.get().typeName().equals(INJECT_MAIN)) {
+ throw new CodegenException("Custom main class must directly extend " + INJECT_MAIN.fqName() + ", but "
+ + customMain.typeName().fqName() + " extends " + superType.get().typeName(),
+ customMain.originatingElementValue());
+ }
+ if (customMain.accessModifier() == AccessModifier.PRIVATE) {
+ throw new CodegenException("Custom main class must be accessible (non-private) class, but "
+ + customMain.typeName().fqName() + " is private.",
+ customMain.originatingElementValue());
+ }
+ if (customMain.elementInfo()
+ .stream()
+ .filter(ElementInfoPredicates::isMethod)
+ .filter(ElementInfoPredicates::isStatic)
+ .filter(not(ElementInfoPredicates::isPrivate))
+ .filter(ElementInfoPredicates.elementName("main"))
+ .anyMatch(ElementInfoPredicates.hasParams(TypeName.create(String[].class)))) {
+ throw new CodegenException("Custom main class must not declare a static main(String[]) method, as it is code "
+ + "generated into the ApplicationMain class, but "
+ + customMain.typeName().fqName() + " declares it.",
+ customMain.originatingElementValue());
+ }
+ if (customMain.elementInfo()
+ .stream()
+ .filter(ElementInfoPredicates::isConstructor)
+ .filter(not(ElementInfoPredicates::isPrivate))
+ .noneMatch(ElementInfoPredicates.hasParams())) {
+ throw new CodegenException("Custom main class must have an accessible no-argument constructor, but "
+ + customMain.typeName().fqName() + " does not.",
+ customMain.originatingElementValue());
+ }
+ }
+
+ private static void mainMethodBody(TypeName type, Method.Builder method) {
+ method.addContent("new ")
+ .addContent(type)
+ .addContentLine("().start(args);");
+ }
+
+ /**
+ * Handler to generated method serviceDescriptors in {@value #CLASS_NAME} class.
+ */
+ @FunctionalInterface
+ public interface CodeGeneratorHandler {
+ /**
+ * Handle the class model (to allow adding constants and helper methods), and method model (to add the body).
+ *
+ * @param classModel class model of the generated main
+ * @param methodModel method model of the serviceDescriptors method
+ * @param configParamName name of the parameter of {@code InjectConfig.Builder}
+ */
+ void handle(ClassModel.Builder classModel, Method.Builder methodModel, String configParamName);
+ }
+}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
index 50ebda400ac..e4c01742ad6 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/EventEmitterObserverProvider.java
@@ -184,7 +184,7 @@ private void addMergeQualifiers(ClassModel.Builder classModel) {
.addContentLine("}")
.addContent("var qualifierSet = new ")
.addContent(HashSet.class)
- .addContentLine("(QUALIFIERS);")
+ .addContentLine("<>(QUALIFIERS);")
.addContent("qualifierSet.addAll(")
.addContent(Set.class)
.addContentLine(".of(qualifiers));")
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
index 765b6e9521b..2737c061821 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectCodegenTypes.java
@@ -17,6 +17,7 @@
package io.helidon.service.inject.codegen;
import io.helidon.common.types.TypeName;
+import io.helidon.common.types.TypeNames;
/**
* Types for code generation from Helidon Service Inject API and Helidon Service Inject.
@@ -63,6 +64,10 @@ public class InjectCodegenTypes {
* {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.RunLevel}.
*/
public static final TypeName INJECTION_RUN_LEVEL = TypeName.create("io.helidon.service.inject.api.Injection.RunLevel");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.Injection.Main}.
+ */
+ public static final TypeName INJECTION_MAIN = TypeName.create("io.helidon.service.inject.api.Injection.Main");
/**
* {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectionPointFactory}.
*/
@@ -120,6 +125,42 @@ public class InjectCodegenTypes {
*/
public static final TypeName INJECT_SERVICE_DESCRIPTOR =
TypeName.create("io.helidon.service.inject.api.InjectServiceDescriptor");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig.Builder}.
+ */
+ public static final TypeName INJECT_CONFIG_BUILDER =
+ TypeName.create("io.helidon.service.inject.InjectConfig.Builder");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectConfig}.
+ */
+ public static final TypeName INJECT_CONFIG =
+ TypeName.create("io.helidon.service.inject.InjectConfig");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InjectRegistry}.
+ */
+ public static final TypeName INJECT_REGISTRY =
+ TypeName.create("io.helidon.service.inject.api.InjectRegistry");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectRegistryManager}.
+ */
+ public static final TypeName INJECT_REGISTRY_MANAGER =
+ TypeName.create("io.helidon.service.inject.InjectRegistryManager");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionMain}.
+ */
+ public static final TypeName INJECT_MAIN =
+ TypeName.create("io.helidon.service.inject.InjectionMain");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.Binding}.
+ */
+ public static final TypeName INJECT_BINDING =
+ TypeName.create("io.helidon.service.inject.Binding");
+ /**
+ * {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.InjectionPlanBinder}.
+ */
+ public static final TypeName INJECT_PLAN_BINDER =
+ TypeName.create("io.helidon.service.inject.InjectionPlanBinder");
+
/**
* {@link io.helidon.common.types.TypeName} for {@code io.helidon.service.inject.api.InvocationException}.
*/
@@ -210,6 +251,22 @@ public class InjectCodegenTypes {
public static final TypeName INJECT_G_EVENT_OBSERVER_REGISTRATION =
TypeName.create("io.helidon.service.inject.api.GeneratedInjectService.EventObserverRegistration");
+ /**
+ * {@link io.helidon.common.types.TypeName} for String array.
+ */
+ public static final TypeName STRING_ARRAY = TypeName.builder()
+ .from(TypeNames.STRING)
+ .array(true)
+ .build();
+ /**
+ * {@link io.helidon.common.types.TypeName} for primitive double array.
+ */
+ public static final TypeName DOUBLE_ARRAY = TypeName.builder()
+ .from(TypeNames.PRIMITIVE_DOUBLE)
+ .array(true)
+ .build();
+
+
private InjectCodegenTypes() {
}
}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
index 66e8e72db63..41cf8b1ddfc 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectOptions.java
@@ -17,6 +17,7 @@
package io.helidon.service.inject.codegen;
import java.util.Set;
+import java.util.function.Function;
import io.helidon.codegen.Option;
import io.helidon.common.GenericType;
@@ -48,6 +49,33 @@ public final class InjectOptions {
TypeName::create,
new GenericType>() { });
+ /**
+ * Name of the generated Main class for Injection. Defaults to
+ * {@value ApplicationMainGenerator#CLASS_NAME}.
+ * The same property must be provided to the maven plugin, to correctly update the generated class.
+ * To configure package name, use {@link io.helidon.codegen.CodegenOptions#CODEGEN_PACKAGE} option.
+ */
+ public static final Option APPLICATION_MAIN_CLASS_NAME =
+ Option.create("helidon.inject.application.main.class.name",
+ "Name of the generated Main class for Helidon Injection.",
+ ApplicationMainGenerator.CLASS_NAME,
+ Function.identity(),
+ GenericType.STRING);
+
+ /**
+ * Whether to generate main class for Helidon Injection.
+ * Defaults to false. In case a custom main class is present (annotated with Injection.Main), this option is ignored.
+ *
+ * As main class only makes sense for the end application, this is set to {@code false} by default, so we do not generate
+ * main classes for library modules.
+ */
+ public static final Option APPLICATION_MAIN_GENERATE =
+ Option.create("helidon.inject.application.main.generate",
+ "Whether to generate Main class for Helidon Injection.",
+ false,
+ Boolean::parseBoolean,
+ GenericType.create(Boolean.class));
+
private InjectOptions() {
}
}
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
index 2cef3307b2a..9ae22e16a18 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtension.java
@@ -34,6 +34,7 @@
import io.helidon.codegen.CodegenOptions;
import io.helidon.codegen.CodegenUtil;
import io.helidon.codegen.ElementInfoPredicates;
+import io.helidon.codegen.ModuleInfo;
import io.helidon.codegen.classmodel.ClassModel;
import io.helidon.codegen.classmodel.ContentBuilder;
import io.helidon.codegen.classmodel.Field;
@@ -70,6 +71,7 @@
import static io.helidon.service.codegen.ServiceCodegenTypes.SERVICE_ANNOTATION_PROVIDER;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_DESCRIBE;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_INJECT;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_MAIN;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_NAMED;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_INSTANCE;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECTION_PER_LOOKUP;
@@ -79,6 +81,7 @@
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_IP_SUPPORT;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_QUALIFIED_FACTORY_DESCRIPTOR;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_G_SCOPE_HANDLER_DESCRIPTOR;
+import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_MAIN;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INJECT_SERVICE_INSTANCE;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_DELEGATE;
import static io.helidon.service.inject.codegen.InjectCodegenTypes.INTERCEPTION_EXTERNAL_DELEGATE;
@@ -117,6 +120,9 @@ class InjectionExtension implements RegistryCodegenExtension {
private final Set scopeMetaAnnotations;
private final List observers;
+ private volatile boolean mainClassGenerated;
+ private volatile String packageName;
+
InjectionExtension(RegistryCodegenContext codegenContext) {
this.ctx = codegenContext;
@@ -131,6 +137,9 @@ class InjectionExtension implements RegistryCodegenExtension {
.stream()
.map(it -> it.create(codegenContext))
.toList();
+ this.packageName = CodegenOptions.CODEGEN_PACKAGE.findValue(options)
+ .orElse(null);
+ this.mainClassGenerated = !options.enabled(InjectOptions.APPLICATION_MAIN_GENERATE);
}
static void annotationsField(ClassModel.Builder classModel, TypeInfo service) {
@@ -180,7 +189,29 @@ static List declareCtrParamsAndGetThem(Method.Builder method, L
@Override
public void process(RegistryRoundContext roundContext) {
+ if (this.packageName == null) {
+ // first try from module
+ this.packageName = ctx.module()
+ .flatMap(ModuleInfo::firstUnqualifiedExport)
+ .orElse(null);
+ // then use the first from source code
+ if (packageName == null) {
+ packageName = roundContext.types()
+ .stream()
+ .map(TypeInfo::typeName)
+ .map(TypeName::packageName)
+ .findFirst()
+ .orElse(null);
+ }
+ }
+
+ Collection mainClasses = roundContext.annotatedTypes(INJECTION_MAIN);
+ if (!mainClasses.isEmpty()) {
+ generateMain(roundContext, mainClasses);
+ }
+
List descriptorsRequired = new ArrayList<>(roundContext.types());
+ mainClasses.forEach(descriptorsRequired::remove);
for (TypeInfo typeInfo : descriptorsRequired) {
if (typeInfo.hasAnnotation(INTERCEPTION_EXTERNAL_DELEGATE)) {
@@ -196,6 +227,13 @@ public void process(RegistryRoundContext roundContext) {
notifyObservers(roundContext, descriptorsRequired);
}
+ @Override
+ public void processingOver() {
+ if (!mainClassGenerated) {
+ generateMain();
+ }
+ }
+
private static void addAnnotationValue(ContentBuilder contentBuilder, Object objectValue) {
switch (objectValue) {
case String value -> contentBuilder.addContent("\"" + value + "\"");
@@ -389,6 +427,71 @@ private void generateScopeDescriptor(RegistryRoundContext roundContext, TypeInfo
serviceDescriptor.typeInfo().originatingElementValue());
}
+ private void generateMain() {
+ if (packageName == null) {
+ throw new CodegenException("Cannot determine package name for the generated main class. "
+ + "Please use option " + CodegenOptions.CODEGEN_PACKAGE.name()
+ + " to specify it");
+ }
+ // generate main class if it doe not exist
+ String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
+ TypeName generatedType = TypeName.builder()
+ .packageName(packageName)
+ .className(className)
+ .build();
+
+ ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
+ Set.of(),
+ INJECT_MAIN,
+ generatedType,
+ false,
+ false,
+ (a, b, c) -> {
+ },
+ (a, b, c) -> {
+ });
+ ctx.filer()
+ .writeSourceFile(applicationMain.build(), GENERATOR);
+ }
+
+ private void generateMain(RegistryRoundContext roundCtx, Collection customMainClasses) {
+ TypeInfo customMain = customMainClasses.iterator().next();
+
+ if (customMainClasses.size() != 1) {
+ String names = customMainClasses.stream()
+ .map(TypeInfo::typeName)
+ .map(TypeName::fqName)
+ .collect(Collectors.joining(", "));
+ throw new CodegenException("There can only be one class annotated with " + INJECTION_MAIN.fqName() + ", "
+ + "but discovered more than one: " + names,
+ customMain.originatingElementValue());
+ }
+
+ // we always generate the main class, even when there is no Maven plugin
+ mainClassGenerated = true;
+ String className = InjectOptions.APPLICATION_MAIN_CLASS_NAME.value(ctx.options());
+ TypeName generatedType = TypeName.builder()
+ .packageName(customMain.typeName().packageName())
+ .className(className)
+ .build();
+ ApplicationMainGenerator.validate(customMain);
+ var declaredSignatures = ApplicationMainGenerator.declaredSignatures(customMain);
+
+ ClassModel.Builder applicationMain = ApplicationMainGenerator.generate(GENERATOR,
+ declaredSignatures,
+ customMain.typeName(),
+ generatedType,
+ true,
+ false,
+ (a, b, c) -> {
+ },
+ (a, b, c) -> {
+ });
+ roundCtx.addGeneratedType(generatedType,
+ applicationMain,
+ GENERATOR);
+ }
+
// we are generating source code, that requires multiple lines
// I would rather keep this method readable, then to put multiple statements in a single line
@SuppressWarnings("checkstyle:MethodLength")
@@ -963,6 +1066,14 @@ private List fieldInjectElements(TypeInfo typeInfo) {
.filter(ElementInfoPredicates::isPrivate)
.findFirst();
if (firstFound.isPresent()) {
+ if (typeInfo.kind() == ElementKind.RECORD) {
+ throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+ + " annotation on record field(s). This is not supported. "
+ + "If this is the only constructor, you can remove the Inject annotation; "
+ + "if you need to inject the default constructor, kindly create an explicit"
+ + " default constructor and annotate it with Inject.",
+ firstFound.get().originatingElementValue());
+ }
throw new CodegenException("Discovered " + InjectCodegenTypes.INJECTION_INJECT.fqName()
+ " annotation on private field(s). We cannot support private field injection.",
firstFound.get().originatingElementValue());
diff --git a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
index e34e787efaf..fa8b4979485 100644
--- a/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
+++ b/service/inject/codegen/src/main/java/io/helidon/service/inject/codegen/InjectionExtensionProvider.java
@@ -71,7 +71,8 @@ public Set> supportedOptions() {
public Set supportedAnnotations() {
return Set.of(InjectCodegenTypes.INJECTION_INJECT,
InjectCodegenTypes.INJECTION_DESCRIBE,
- InjectCodegenTypes.INJECTION_PER_INSTANCE);
+ InjectCodegenTypes.INJECTION_PER_INSTANCE,
+ InjectCodegenTypes.INJECTION_MAIN);
}
@Override
diff --git a/service/inject/inject/pom.xml b/service/inject/inject/pom.xml
index 59f65966e6b..fab2a878377 100644
--- a/service/inject/inject/pom.xml
+++ b/service/inject/inject/pom.xml
@@ -39,6 +39,10 @@
+
+ io.helidon
+ helidon
+ io.helidon.commonhelidon-common
@@ -55,6 +59,10 @@
io.helidon.commonhelidon-common-types
+
+ io.helidon.logging
+ helidon-logging-common
+ io.helidon.builderhelidon-builder-api
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
index e021bb27c4d..3a0287053e0 100644
--- a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectConfigBlueprint.java
@@ -85,4 +85,15 @@ interface InjectConfigBlueprint extends ServiceRegistryConfig {
@Option.Configured
@Option.DefaultBoolean(true)
boolean useBinding();
+
+ /**
+ * Maximal run level to handle when starting from the generated main class
+ * ({@link InjectionMain}). This setting is ignored when starting registry using
+ * other means, as run levels are not handled by default.
+ *
+ * @return maximal run level to lookup during application startup when using generated main class
+ */
+ @Option.Configured
+ @Option.DefaultDouble(Double.MAX_VALUE)
+ double maxRunLevel();
}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
new file mode 100644
index 00000000000..58b13960320
--- /dev/null
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectStartupProvider.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * 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 io.helidon.service.inject;
+
+import java.lang.System.Logger.Level;
+
+import io.helidon.Main;
+import io.helidon.common.Weight;
+import io.helidon.common.Weighted;
+import io.helidon.service.registry.ServiceRegistryManager;
+import io.helidon.spi.HelidonShutdownHandler;
+import io.helidon.spi.HelidonStartupProvider;
+
+/**
+ * {@link java.util.ServiceLoader} implementation of a Helidon startup provider for Helidon Service Inject based
+ * applications.
+ */
+@Weight(Weighted.DEFAULT_WEIGHT) // explicit default weight, this should be the "default" startup class
+public class InjectStartupProvider extends InjectionMain implements HelidonStartupProvider {
+ /**
+ * Default constructor required by {@link java.util.ServiceLoader}.
+ *
+ * @deprecated please do not use directly
+ */
+ @Deprecated
+ public InjectStartupProvider() {
+ }
+
+ /**
+ * Register a shutdown handler.
+ * The handler is registered, and never de-registered. This method should only be used by main classes of applications.
+ * If a custom shutdown is desired, please use
+ * {@link io.helidon.Main#addShutdownHandler(io.helidon.spi.HelidonShutdownHandler)} directly.
+ *
+ * @param registryManager registry manager
+ */
+ public static void registerShutdownHandler(ServiceRegistryManager registryManager) {
+ System.Logger logger = System.getLogger(InjectStartupProvider.class.getName());
+ Main.addShutdownHandler(new InjectShutdownHandler(logger, registryManager));
+ }
+
+ @Override
+ public void start(String[] arguments) {
+ super.start(arguments);
+ }
+
+ @Override
+ protected void serviceDescriptors(InjectConfig.Builder configBuilder) {
+ // service descriptors are discovered when startup provider is used - see below discoverServices() method
+ }
+
+ @Override
+ protected boolean discoverServices() {
+ return true;
+ }
+
+ // higher than default, so we stop server as a service, not through shutdown
+ @Weight(Weighted.DEFAULT_WEIGHT + 10)
+ private static final class InjectShutdownHandler implements HelidonShutdownHandler {
+ private final System.Logger logger;
+ private final ServiceRegistryManager registryManager;
+
+ private InjectShutdownHandler(System.Logger logger, ServiceRegistryManager registryManager) {
+ this.logger = logger;
+ this.registryManager = registryManager;
+ }
+
+ @Override
+ public void shutdown() {
+ try {
+ registryManager.shutdown();
+ } catch (Exception e) {
+ logger.log(Level.ERROR,
+ "Failed to shutdown Helidon Inject registry",
+ e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "Helidon Inject shutdown handler";
+ }
+ }
+}
diff --git a/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
new file mode 100644
index 00000000000..ac153fe9516
--- /dev/null
+++ b/service/inject/inject/src/main/java/io/helidon/service/inject/InjectionMain.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2024 Oracle and/or its affiliates.
+ *
+ * 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 io.helidon.service.inject;
+
+import java.lang.System.Logger.Level;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import io.helidon.common.config.Config;
+import io.helidon.common.config.GlobalConfig;
+import io.helidon.common.types.TypeName;
+import io.helidon.logging.common.LogConfig;
+import io.helidon.service.inject.api.InjectRegistry;
+import io.helidon.service.inject.api.InjectServiceInfo;
+import io.helidon.service.inject.api.Injection;
+import io.helidon.service.inject.api.Lookup;
+import io.helidon.service.registry.GlobalServiceRegistry;
+import io.helidon.service.registry.ServiceDescriptor;
+import io.helidon.service.registry.ServiceLoader__ServiceDescriptor;
+
+/**
+ * Common ancestor for generated main classes.
+ *
+ * The following methods are code generated to the {@code ApplicationMain} class by the Maven plugin.
+ * If you do not want the generated code to be used, simply implement those methods in your custom Main class,
+ * and they will NOT be generated.
+ * When not using Maven plugin, the generated class will have no-op implementations nad service discovery will be enabled.
+ *
+ *
{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} - registers all service descriptors
+ * in the current application; to customize the config builder, you can use
+ * {@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} and
+ * {@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} methods
+ *
{@link #discoverServices()} - set to {@code false} when using Maven plugin, to avoid all reflection
+ *
+ */
+public abstract class InjectionMain {
+ /*
+ A change in this class requires change in ApplicationMainGenerator!
+ */
+
+ private static final System.Logger LOGGER = System.getLogger(InjectionMain.class.getName());
+
+ static {
+ LogConfig.initClass();
+ }
+
+ /**
+ * Default constructor with no side effects.
+ */
+ protected InjectionMain() {
+ LogConfig.configureRuntime();
+ }
+
+ /**
+ * Create a service descriptor for a Java {@link java.util.ServiceLoader} based service.
+ *
+ * @param providerInterface provider interface of the service
+ * @param implType provider implementation
+ * @param instanceSupplier supplier of a new instance of the service implementation (to allow avoiding reflection)
+ * @param weight weight assigned to the service
+ * @param type of the service implementation
+ * @return a new service descriptor of the service
+ */
+ protected static ServiceDescriptor serviceLoader(TypeName providerInterface,
+ Class implType,
+ Supplier instanceSupplier,
+ double weight) {
+ return ServiceLoader__ServiceDescriptor.create(providerInterface, implType, instanceSupplier, weight);
+ }
+
+ /**
+ * Method that handles the startup sequence of an application.
+ * This method is expected to be code generated.
+ *
+ * The following sequence is implemented:
+ *
+ *
{@link #configBuilder(String[])} to prepare the configuration builder from
+ * {@link io.helidon.common.config.Config}
+ *
{@link #beforeServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder
+ *
{@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} for code generated setup
+ *
{@link #afterServiceDescriptors(io.helidon.service.inject.InjectConfig.Builder)} to update the builder
+ *
{@link #init(InjectConfig)} to initialize the service registry
+ *
+ *
+ * @param arguments command line arguments
+ */
+ protected void start(String[] arguments) {
+ var config = configBuilder(arguments);
+ beforeServiceDescriptors(config);
+ serviceDescriptors(config);
+ afterServiceDescriptors(config);
+ var registry = init(config.build());
+ afterInit(registry);
+ }
+
+ /**
+ * Method that registers all service descriptors.
+ * This method is expected to be code generated.
+ *
+ * @param configBuilder in progress config builder
+ */
+ protected abstract void serviceDescriptors(InjectConfig.Builder configBuilder);
+
+ /**
+ * Create a config builder from command line arguments.
+ * This method will create default configuration (but not register it as a global config, so we still use the registry
+ * to create a config instance), configure the {@link io.helidon.service.inject.InjectConfig.Builder} from it,
+ * then disable discovery of services.
+ *
+ * @param arguments command line arguments
+ * @return a new config builder
+ */
+ protected InjectConfig.Builder configBuilder(String[] arguments) {
+ Config config;
+ if (GlobalConfig.configured()) {
+ config = GlobalConfig.config();
+ } else {
+ config = Config.create();
+ }
+
+ return InjectConfig.builder()
+ .config(config.get("registry"))
+ .discoverServices(discoverServices())
+ .discoverServicesFromServiceLoader(discoverServices());
+ }
+
+ /**
+ * Whether to discover services from classpath and from service loader.
+ * Defaults to {@code false}, should be overridden when
+ * {@link #serviceDescriptors(io.helidon.service.inject.InjectConfig.Builder)}
+ * does not configure all services.
+ *
+ * @return whether to discover services
+ */
+ protected boolean discoverServices() {
+ return false;
+ }
+
+ /**
+ * Called before service descriptors are configured in the generated main class.
+ * This method is invoked from generated {@link #start(String[])}.
+ *
+ * @param configBuilder in-progress config builder
+ */
+ protected void beforeServiceDescriptors(InjectConfig.Builder configBuilder) {
+ }
+
+ /**
+ * Called after service descriptors are configured in the generated main class, before the registry is initialized.
+ * This method is invoked from generated {@link #start(String[])}
+ *
+ * @param configBuilder in-progress config builder
+ */
+ protected void afterServiceDescriptors(InjectConfig.Builder configBuilder) {
+ }
+
+ /**
+ * Initialize the service registry, register it for shutdown during process shutdown, and lookup all
+ * startup services.
+ *
+ * @param config configuration of the Inject service registry
+ * @return the inject registry created within this method
+ */
+ protected InjectRegistry init(InjectConfig config) {
+ InjectRegistryManager manager = InjectRegistryManager.create(config);
+ InjectRegistry registry = manager.registry();
+ InjectStartupProvider.registerShutdownHandler(manager);
+
+ GlobalServiceRegistry.registry(registry);
+
+ double maxRunLevel = maxRunLevel(config, registry);
+ for (double runLevel : runLevels(config, registry)) {
+ if (runLevel <= maxRunLevel) {
+ List