You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@felix.apache.org by tj...@apache.org on 2021/01/12 18:29:14 UTC
[felix-dev] 03/04: Add support for Optional to be
injected
This is an automated email from the ASF dual-hosted git repository.
tjwatson pushed a commit to branch scrR8
in repository https://gitbox.apache.org/repos/asf/felix-dev.git
commit 5d167e215e240ae5a779023c0f7e6b24f9c6b425
Author: Thomas Watson <tj...@us.ibm.com>
AuthorDate: Tue Jan 12 12:24:45 2021 -0600
Add support for Optional<ServiceType> to be injected
This is only supported for unary (0..1, 1..1) cardinality injection to
fields and constructor. Method injection is not supported for Optional
type injection.
---
.../apache/felix/scr/impl/inject/ValueUtils.java | 14 +-
.../felix/scr/impl/inject/field/FieldHandler.java | 45 ++++--
.../felix/scr/impl/inject/internal/ClassUtils.java | 3 +
.../inject/internal/ComponentConstructorImpl.java | 10 +-
.../scr/integration/ComponentOptionalTest.java | 170 +++++++++++++++++++++
.../components/ConstructorSingleReference.java | 12 ++
.../components/InjectOptionalComponent.java | 162 ++++++++++++++++++++
.../resources/integration_test_inject_optional.xml | 121 +++++++++++++++
8 files changed, 523 insertions(+), 14 deletions(-)
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
index 2e29a3c..4f2af5c 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
@@ -23,6 +23,7 @@ import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;
+import java.util.Optional;
import org.apache.felix.scr.impl.helper.ReadOnlyDictionary;
import org.apache.felix.scr.impl.inject.internal.Annotations;
@@ -54,7 +55,8 @@ public class ValueUtils {
ref_serviceObjects, // reference (field, constructor, method)
ref_serviceType, // reference (field, constructor, method)
ref_map, // reference (field, constructor, method)
- ref_tuple // reference (field, constructor ??) // TDODO
+ ref_tuple, // reference (field, constructor ??) // TDODO
+ ref_optional // reference (field, constructor, XX)
}
/** Empty array. */
@@ -148,6 +150,14 @@ public class ValueUtils {
{
return ValueType.ref_formatterLogger;
}
+ // 1.5 Optional
+ else if (typeClass == ClassUtils.OPTIONAL_CLASS)
+ {
+ // Note that the first check for "typeClass.isAssignableFrom(referenceType)"
+ // will handle case where they want an actual Optional service type.
+
+ valueType = ValueType.ref_optional;
+ }
else
{
if ( field != null )
@@ -320,6 +330,8 @@ public class ValueUtils {
case ref_logger :
case ref_formatterLogger : value = getLogger(componentType, targetType, componentContext, refPair);
break;
+ case ref_optional : value = Optional.ofNullable(refPair.getServiceObject(componentContext));
+ break;
default: value = null;
}
return value;
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
index ce6f926..a5d25bd 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
@@ -25,6 +25,7 @@ import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
@@ -129,23 +130,32 @@ public class FieldHandler
}
if ( fieldType == ClassUtils.LIST_CLASS )
{
- this.setFieldValue(componentInstance, new CopyOnWriteArrayList<>());
+ this.setFieldValue(componentInstance,
+ new CopyOnWriteArrayList<>());
}
else
{
- this.setFieldValue(componentInstance, new CopyOnWriteArraySet<>());
+ this.setFieldValue(componentInstance,
+ new CopyOnWriteArraySet<>());
}
}
}
}
else
{
- // only optional field need initialization
- if ( metadata.isOptional() )
- {
- // null the field if optional and unary
- this.setFieldValue(componentInstance, null);
- }
+ // only optional field need initialization
+ if (metadata.isOptional())
+ {
+ if (valueType == ValueType.ref_optional)
+ {
+ this.setFieldValue(componentInstance, Optional.empty());
+ }
+ else
+ {
+ // null the field if optional and unary
+ this.setFieldValue(componentInstance, null);
+ }
+ }
}
}
catch ( final InvocationTargetException ite)
@@ -182,7 +192,7 @@ public class FieldHandler
{
// unary references
- // unbind needs only be done, if reference is dynamic and optional
+ // unbind needs only be done, if reference is dynamic and optional
if ( mType == METHOD_TYPE.UNBIND )
{
if ( this.metadata.isOptional() && !this.metadata.isStatic() )
@@ -190,7 +200,15 @@ public class FieldHandler
// we only reset if it was previously set with this value
if ( bp.getComponentContext().getBoundValues(metadata.getName()).size() == 1 )
{
- this.setFieldValue(componentInstance, null);
+ if (valueType == ValueType.ref_optional)
+ {
+ this.setFieldValue(componentInstance, Optional.empty());
+ }
+ else
+ {
+ // null the field if optional and unary
+ this.setFieldValue(componentInstance, null);
+ }
}
}
bp.getComponentContext().getBoundValues(metadata.getName()).remove(refPair);
@@ -518,8 +536,11 @@ public class FieldHandler
//??? this resolves which we need.... better way?
if (rawParameter.getRefPair().getServiceObject(rawParameter.getComponentContext()) == null
&& handler.fieldExists( rawParameter.getComponentContext().getLogger() )
- && (handler.valueType == ValueType.ref_serviceType || handler.valueType == ValueType.ref_tuple
- || handler.valueType == ValueType.ref_logger || handler.valueType == ValueType.ref_formatterLogger) )
+ && (handler.valueType == ValueType.ref_serviceType //
+ || handler.valueType == ValueType.ref_tuple
+ || handler.valueType == ValueType.ref_logger
+ || handler.valueType == ValueType.ref_formatterLogger
+ || handler.valueType == ValueType.ref_optional))
{
return rawParameter.getRefPair().getServiceObject(rawParameter.getComponentContext(), context);
}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
index dcdd6b7..04b7a36 100755
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
@@ -21,6 +21,7 @@ package org.apache.felix.scr.impl.inject.internal;
import java.util.Collection;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import org.apache.felix.scr.impl.logger.ComponentLogger;
import org.apache.felix.scr.impl.logger.InternalLogger.Level;
@@ -55,6 +56,8 @@ public class ClassUtils
public static final Class<?> COLLECTION_CLASS = Collection.class;
public static final Class<?> LIST_CLASS = List.class;
+ public static final Class<?> OPTIONAL_CLASS = Optional.class;
+
public static final Class<?> COMPONENT_CONTEXT_CLASS = ComponentContext.class;
public static final Class<?> BUNDLE_CONTEXT_CLASS = BundleContext.class;
public static final Class<?> INTEGER_CLASS = Integer.class;
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
index 0e44eb0..5d9fc5a 100755
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
@@ -24,6 +24,7 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.felix.scr.impl.inject.ComponentConstructor;
@@ -279,7 +280,8 @@ public class ComponentConstructorImpl<S> implements ComponentConstructor<S>
&& (constructorArgTypes[i] == ValueType.ref_serviceType
|| constructorArgTypes[i] == ValueType.ref_tuple
|| constructorArgTypes[i] == ValueType.ref_logger
- || constructorArgTypes[i] == ValueType.ref_formatterLogger) )
+ || constructorArgTypes[i] == ValueType.ref_formatterLogger
+ || constructorArgTypes[i] == ValueType.ref_optional))
{
refPair.getServiceObject(componentContext, componentContext.getBundleContext());
}
@@ -294,6 +296,12 @@ public class ComponentConstructorImpl<S> implements ComponentConstructor<S>
}
}
}
+ // check for optional ref type; if null then use empty Optional
+ if (ref == null && constructorArgTypes[i] == ValueType.ref_optional)
+ {
+ ref = Optional.empty();
+ }
+
if ( !refMetadata.isMultiple())
{
if (ref == null && !refMetadata.isOptional())
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/ComponentOptionalTest.java b/scr/src/test/java/org/apache/felix/scr/integration/ComponentOptionalTest.java
new file mode 100644
index 0000000..efd13e7
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/ComponentOptionalTest.java
@@ -0,0 +1,170 @@
+/*
+ * 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.felix.scr.integration;
+
+
+import static org.junit.Assert.assertEquals;
+
+import org.apache.felix.scr.integration.components.ConstructorSingleReference;
+import org.apache.felix.scr.integration.components.InjectOptionalComponent;
+import org.apache.felix.scr.integration.components.InjectOptionalComponent.Mode;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.ops4j.pax.exam.junit.PaxExam;
+import org.osgi.service.component.runtime.dto.ComponentConfigurationDTO;
+
+
+@RunWith(PaxExam.class)
+public class ComponentOptionalTest extends ComponentTestBase
+{
+
+ static
+ {
+ // use different components
+ descriptorFile = "/integration_test_inject_optional.xml";
+
+ // uncomment to enable debugging of this test class
+ // paxRunnerVmOption = DEBUG_VM_OPTION;
+ }
+
+ static final String SINGLE_REFERENCE1 = "SingleReference1";
+ static final String SINGLE_REFERENCE2 = "SingleReference2";
+
+ private void doTest(Mode mode) throws Exception
+ {
+ final String componentname = mode.name();
+ ComponentConfigurationDTO cc = getDisabledConfigurationAndEnable(componentname,
+ mode.getInitialState());
+ assertEquals(mode.getInitCount(), cc.description.init);
+
+ InjectOptionalComponent cmp1 = null;
+ if (!mode.isMandatory())
+ {
+ cmp1 = this.getServiceFromConfiguration(cc, InjectOptionalComponent.class);
+ cmp1.checkMode(mode, null);
+ }
+
+ ComponentConfigurationDTO ref1DTO = getDisabledConfigurationAndEnable(
+ SINGLE_REFERENCE1,
+ mode.isDynamic() && !mode.isMandatory()//
+ ? ComponentConfigurationDTO.ACTIVE
+ : ComponentConfigurationDTO.SATISFIED);
+ ConstructorSingleReference ref1Service = getServiceFromConfiguration(ref1DTO,
+ ConstructorSingleReference.class);
+
+ cc = findComponentConfigurationByName(componentname, mode.getSecondState());
+ InjectOptionalComponent cmp2 = this.getServiceFromConfiguration(cc,
+ InjectOptionalComponent.class);
+
+ if (!mode.isMandatory())
+ {
+ assertEquals(cmp1, cmp2);
+ }
+
+ if (mode.isMandatory() || mode.isDynamic())
+ {
+ cmp2.checkMode(mode, ref1Service);
+ }
+ else
+ {
+ cmp2.checkMode(mode, null);
+ }
+
+ ComponentConfigurationDTO ref2DTO = getDisabledConfigurationAndEnable(
+ SINGLE_REFERENCE2, ComponentConfigurationDTO.SATISFIED);
+
+ ConstructorSingleReference ref2Service = getServiceFromConfiguration(ref2DTO,
+ ConstructorSingleReference.class);
+
+ if (mode.isMandatory() || mode.isDynamic())
+ {
+ cmp2.checkMode(mode, ref1Service);
+ }
+ else
+ {
+ cmp2.checkMode(mode, null);
+ }
+
+ disableAndCheck(ref1DTO);
+
+ if (mode.isDynamic())
+ {
+ cmp2.checkMode(mode, ref2Service);
+ }
+ else if (mode.isMandatory())
+ {
+ cc = findComponentConfigurationByName(componentname,
+ ComponentConfigurationDTO.SATISFIED);
+ InjectOptionalComponent cmp3 = this.getServiceFromConfiguration(cc,
+ InjectOptionalComponent.class);
+ cmp3.checkMode(mode, ref2Service);
+ }
+ else // is optional
+ {
+ cmp2.checkMode(mode, null);
+ }
+
+ disableAndCheck(cc);
+
+ cc = getDisabledConfigurationAndEnable(componentname,
+ ComponentConfigurationDTO.SATISFIED);
+ assertEquals(mode.getInitCount(), cc.description.init);
+ cmp1 = this.getServiceFromConfiguration(cc, InjectOptionalComponent.class);
+
+ cmp1.checkMode(mode, ref2Service);
+
+ disableAndCheck(cc);
+ }
+
+ @Test
+ public void test_field_static_optional() throws Exception
+ {
+ doTest(Mode.FIELD_STATIC_OPTIONAL);
+ }
+
+ @Test
+ public void test_field_dynamic_optional() throws Exception
+ {
+ doTest(Mode.FIELD_DYNAMIC_OPTIONAL);
+ }
+
+ @Test
+ public void test_field_static_mandatory() throws Exception
+ {
+ doTest(Mode.FIELD_STATIC_MANDATORY);
+ }
+
+ @Test
+ public void test_field_dynamic_mandatory() throws Exception
+ {
+ doTest(Mode.FIELD_DYNAMIC_MANDATORY);
+ }
+
+ @Test
+ public void test_constructor_mandatory() throws Exception
+ {
+ doTest(Mode.CONSTRUCTOR_MANDATORY);
+ }
+
+ @Test
+ public void test_constructor_optional() throws Exception
+ {
+ doTest(Mode.CONSTRUCTOR_OPTIONAL);
+ }
+}
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/components/ConstructorSingleReference.java b/scr/src/test/java/org/apache/felix/scr/integration/components/ConstructorSingleReference.java
index 0905f8e..96e0e37 100644
--- a/scr/src/test/java/org/apache/felix/scr/integration/components/ConstructorSingleReference.java
+++ b/scr/src/test/java/org/apache/felix/scr/integration/components/ConstructorSingleReference.java
@@ -18,8 +18,14 @@
*/
package org.apache.felix.scr.integration.components;
+import java.util.concurrent.atomic.AtomicLong;
+
public class ConstructorSingleReference
{
+ private static final AtomicLong instances = new AtomicLong();
+
+ private final long instanceID = instances.incrementAndGet();
+
public @interface Config
{
String name();
@@ -37,4 +43,10 @@ public class ConstructorSingleReference
{
return this.name;
}
+
+ @Override
+ public String toString()
+ {
+ return getClass().getSimpleName() + '-' + instanceID;
+ }
}
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/components/InjectOptionalComponent.java b/scr/src/test/java/org/apache/felix/scr/integration/components/InjectOptionalComponent.java
new file mode 100644
index 0000000..90cbd1d
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/components/InjectOptionalComponent.java
@@ -0,0 +1,162 @@
+/*
+ * 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.felix.scr.integration.components;
+
+
+import java.util.Map;
+import java.util.Optional;
+
+import org.osgi.service.component.ComponentConstants;
+import org.osgi.service.component.runtime.dto.ComponentConfigurationDTO;
+
+public class InjectOptionalComponent
+{
+ public enum Mode
+ {
+ FIELD_STATIC_MANDATORY(1, false, true), //
+ FIELD_DYNAMIC_MANDATORY(1, true, true), //
+ FIELD_STATIC_OPTIONAL(1, false, false), //
+ FIELD_DYNAMIC_OPTIONAL(1, true, false), //
+ CONSTRUCTOR_MANDATORY(2, false, true), //
+ CONSTRUCTOR_OPTIONAL(2, false, false);
+
+ final int initCount;
+ final int initialState;
+ final int secondState;
+ final boolean isMandatory;
+ final boolean isDynamic;
+
+ Mode(int initCount, boolean isDynamic, boolean isMandatory)
+ {
+ this.initCount = initCount;
+ this.initialState = isMandatory
+ ? ComponentConfigurationDTO.UNSATISFIED_REFERENCE
+ : ComponentConfigurationDTO.SATISFIED;
+ this.secondState = isMandatory ? ComponentConfigurationDTO.SATISFIED
+ : ComponentConfigurationDTO.ACTIVE;
+ this.isMandatory = isMandatory;
+ this.isDynamic = isDynamic;
+ }
+
+ public int getInitCount()
+ {
+ return initCount;
+ }
+
+ public int getInitialState()
+ {
+ return initialState;
+ }
+
+ public int getSecondState()
+ {
+ return secondState;
+ }
+
+ public final boolean isMandatory()
+ {
+ return isMandatory;
+ }
+
+ public final boolean isDynamic()
+ {
+ return isDynamic;
+ }
+
+ }
+
+ private final Mode mode;
+
+ private final Optional<ConstructorSingleReference> refConstructor;
+ private Optional<ConstructorSingleReference> refFieldStatic = null;
+ private volatile Optional<ConstructorSingleReference> refFieldDynamic = null;
+
+ public InjectOptionalComponent(Map<String, Object> props, Optional<ConstructorSingleReference> single)
+ {
+ this.mode = getMode(props);
+ this.refConstructor = single;
+ }
+
+ public InjectOptionalComponent(Map<String, Object> props)
+ {
+ this(props, null);
+ }
+
+ private Mode getMode(Map<String, Object> props)
+ {
+ return Mode.valueOf((String) props.get(ComponentConstants.COMPONENT_NAME));
+ }
+
+ public boolean checkMode(Mode mode, ConstructorSingleReference expected)
+ {
+ if (this.mode != mode)
+ {
+ throw new AssertionError(
+ "Wrong mode, expected \"" + mode + "\" but was\"" + this.mode);
+ }
+ Optional<ConstructorSingleReference> optional = getOptional();
+ if (expected != null)
+ {
+ return optional.map((c) -> checkExpected(expected, c)).orElseGet(
+ () -> throwAssertionError(
+ "FAILED - expected: " + expected + " but got empty optional."));
+ }
+ else
+ {
+ return optional.map(
+ (c) -> throwAssertionError(
+ "FAILED - expected empty optional but got: " + c)).orElse(true);
+ }
+ }
+
+ private boolean throwAssertionError(String message)
+ {
+ throw new AssertionError(message);
+ }
+
+ private boolean checkExpected(ConstructorSingleReference expected,
+ ConstructorSingleReference actual)
+ {
+ if (expected == actual)
+ {
+ return true;
+ }
+ throw new AssertionError(
+ "FAILED - expected: " + expected + " bug got: " + actual);
+ }
+
+ private Optional<ConstructorSingleReference> getOptional()
+ {
+ switch (mode)
+ {
+ case CONSTRUCTOR_MANDATORY:
+ case CONSTRUCTOR_OPTIONAL:
+ return refConstructor;
+ case FIELD_DYNAMIC_MANDATORY:
+ case FIELD_DYNAMIC_OPTIONAL:
+ return refFieldDynamic;
+ case FIELD_STATIC_MANDATORY:
+ case FIELD_STATIC_OPTIONAL:
+ return refFieldStatic;
+ default:
+ throw new UnsupportedOperationException(String.valueOf(mode));
+ }
+ }
+
+}
diff --git a/scr/src/test/resources/integration_test_inject_optional.xml b/scr/src/test/resources/integration_test_inject_optional.xml
new file mode 100644
index 0000000..a40be9d
--- /dev/null
+++ b/scr/src/test/resources/integration_test_inject_optional.xml
@@ -0,0 +1,121 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ 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.
+-->
+<components xmlns:scr="http://www.osgi.org/xmlns/scr/v1.4.0">
+
+ <!-- Static Field -->
+ <scr:component name="FIELD_STATIC_MANDATORY" enabled="false"
+ init="1">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference
+ name="refFieldStatic"
+ interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ field="refFieldStatic"
+ cardinality="1..1"
+ />
+ </scr:component>
+
+ <scr:component name="FIELD_STATIC_OPTIONAL" enabled="false"
+ init="1">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference
+ name="refFieldStatic"
+ interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ field="refFieldStatic"
+ cardinality="0..1"
+ />
+ </scr:component>
+
+ <!-- Dynamic Field -->
+ <scr:component name="FIELD_DYNAMIC_MANDATORY" enabled="false"
+ init="1">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference
+ name="refFieldDynamic"
+ interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ field="refFieldDynamic"
+ cardinality="1..1"
+ policy="dynamic"
+ />
+ </scr:component>
+
+ <scr:component name="FIELD_DYNAMIC_OPTIONAL" enabled="false"
+ init="1">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference
+ name="refFieldDynamic"
+ interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ field="refFieldDynamic"
+ cardinality="0..1"
+ policy="dynamic"
+ />
+ </scr:component>
+
+ <!-- mandatory constructor -->
+ <scr:component name="CONSTRUCTOR_MANDATORY" enabled="false"
+ init="2">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ cardinality="1..1"
+ parameter="1"/>
+ </scr:component>
+
+ <!-- optional constructor -->
+ <scr:component name="CONSTRUCTOR_OPTIONAL" enabled="false"
+ init="2">
+ <implementation class="org.apache.felix.scr.integration.components.InjectOptionalComponent" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.InjectOptionalComponent"/>
+ </service>
+ <reference interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"
+ cardinality="0..1"
+ parameter="1"/>
+ </scr:component>
+
+ <scr:component name="SingleReference1" enabled="false" activate="activator">
+ <implementation class="org.apache.felix.scr.integration.components.ConstructorSingleReference" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"/>
+ </service>
+ <property name="name" value="single"/>
+ </scr:component>
+
+ <scr:component name="SingleReference2" enabled="false" activate="activator">
+ <implementation class="org.apache.felix.scr.integration.components.ConstructorSingleReference" />
+ <service factory="false">
+ <provide interface="org.apache.felix.scr.integration.components.ConstructorSingleReference"/>
+ </service>
+ <property name="name" value="single"/>
+ </scr:component>
+</components>