Today I will show you how to write a CDI extension.<\/p>\n
CDI provides a easy way for extending the functionality, like<\/p>\n
In this tutorial we will implement an extension that will inject properties from a property file, as usual I will provide the sources at github [Update: sources @ github<\/a>].<\/p>\n Providing an extension that allows us to do the following<\/p>\n where version<\/em> and appname<\/em> are defined in the file myProps.txt<\/em>.<\/p>\n At first we need the dependency of the CDI api<\/p>\n Now we can start. So let\u2019s<\/p>\n The entry point for every CDI extension is a class that implements\u00a0\u00a0javax.enterprise.inject.spi.Extension<\/em><\/p>\n Additionally we must add the full qualified name of this class to a file named\u00a0\u00a0javax.enterprise.inject.spi.Extension<\/em> in META-INF\/services<\/em> directory.<\/p>\n javax.enterprise.inject.spi.Extension<\/strong><\/p>\n These are the basic steps for writing a CDI extension.<\/p>\n Background information Now we must choose the right event to listen for.<\/p>\n Background information For this tutorial we need to listen for the\u00a0ProcessInjectionTarget<\/em>\u00a0event. This event is fired for every single java class, interface or enum that is discovered and that is possibly instantiated by the container during runtime. The\u00a0ProcessInjectionTarget<\/em> grants access to the underlying class via the method\u00a0getAnnotatedType<\/em> and the instance in creation via getInjectionTarget.<\/em> We use the annotatedType for getting the annotations on the class to check if @PropertyFile<\/em> is available.\u00a0If not, we will return directly as a short circuit.<\/p>\n The InjectionTarget<\/em> is later used for overwriting the current behavior and setting the values from the properties file.<\/p>\n For the sake of this tutorial we assume that the properties file is located directly in the root of the classpath. With this assumption we can add the following code to load the properties from the file Now we can assign the property values to the fields. But for CDI we have to do this in a slightly different way. We should use the\u00a0InjectionTarget\u00a0<\/em>and override the current AnnotatedType. This allows CDI to ensure that all things could happen in a proper order.<\/p>\n For achieving this we use a final Map<Field, Object><\/em> where we can store the current assignments for later usage in the InjectionTarget<\/em>. The mapping is done in the method\u00a0assignPropertiesToFields<\/em>.<\/p>\n As a last step we will now create a new InjectionTarget to assign the field values to all newly created instance of the underlying class.<\/p>\n That\u2019s all for doing the magic. Finally here is the complete code of the ProperyLoaderExtension. The complete source code will be available on git hub until Monday evening. The jar archive is available here\u00a0PropertyLoaderExtension<\/a>.<\/p>\n This tutorial has shown how simply you can add a new features to the CDI framework. Within a few lines of code a working property loading and injection mechanism was added. The events that are fired during the lifecycles of an application provides a loose coupled and powerful approach to add new features, intercept bean creation or changing the behavior.<\/p>\n The property injection could also be achieved by introducing a set of producer methods, but this approach requires one producer method per field type. With this general approach you just have to add new converters for enabling injection of other types of values. Today I will show you how to write a CDI extension. CDI provides a easy way for extending the functionality, like adding own scopes, enabling java core classes for extension, using the annotation meta data for augmentation or modification, and much more. In this tutorial we will implement an extension that will inject properties from …<\/p>\n","protected":false},"author":538,"featured_media":148,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[290],"class_list":["post-21839","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-cdi"],"yoast_head":"\nThe goal<\/h2>\n
@PropertyFile(\"myProps.txt\")\r\npublic class MyProperties {\r\n @Property(\"version\")\r\n Integer version;\r\n \r\n @Property(\"appname\")\r\n String appname;\r\n}<\/pre>\nPreparation<\/h2>\n
dependencies.compile \"javax.enterprise:cdi-api:1.1-20130918\"<\/pre>\n
Getting wet<\/h2>\n
The basics<\/h3>\n
package com.coderskitchen.propertyloader;\r\n \r\nimport javax.enterprise.inject.spi.Extension;\r\npublic class PropertyLoaderExtension implements Extension {\r\n\/\/ More code later\r\n}<\/pre>\n \t\r\ncom.coderskitchen.propertyloader.PropertyLoaderExtension<\/pre>\n
\n
\n<\/strong>CDI uses Java SE\u2019s service provider architecture, that\u2019s why we need to implement the marker interface and adding the file with the FQN of the implementing class.<\/p>\n<\/blockquote>\nDiving deeper<\/h3>\n
\n
\n<\/strong>The CDI specs defines several events which are fired by the container during the initialization of the application.
\nFor example the\u00a0BeforeBeanDiscovery<\/em> is fired before the container starts with the bean discovery.<\/p>\n<\/blockquote>\n
\nSo let\u2019s add the observer for this event:<\/p>\npublic <T> void initializePropertyLoading(final @Observes ProcessInjectionTarget<T> pit) {\r\n}<\/pre>\npublic <T> void initializePropertyLoading(final @Observes ProcessInjectionTarget<T> pit) {\r\n AnnotatedType<T> at = pit.getAnnotatedType();\r\n if(!at.isAnnotationPresent(PropertyFile.class)) {\r\n return;\r\n }\r\n }<\/pre>\nPropertyFile propertyFile = at.getAnnotation(PropertyFile.class);\r\nString filename = propertyFile.value();\r\nInputStream propertiesStream = getClass().getResourceAsStream(\"\/\" + filename);\r\nProperties properties = new Properties();\r\ntry {\r\n properties.load(propertiesStream);\r\n assignPropertiesToFields(at.getFields, properties); \/\/ Implementation follows\r\n} catch (IOException e) {\r\n e.printStackTrace();\r\n}<\/pre>\nprivate <T> void assignPropertiesToFields(Set<AnnotatedField<? super T>> fields, Properties properties) {\r\n for (AnnotatedField<? super T> field : fields) {\r\n if(field.isAnnotationPresent(Property.class)) {\r\n Property property = field.getAnnotation(Property.class);\r\n String value = properties.getProperty(property.value());\r\n Type baseType = field.getBaseType();\r\n fieldValues.put(memberField, value);\r\n }\r\n }<\/pre>\nfinal InjectionTarget<T> it = pit.getInjectionTarget();\r\n InjectionTarget<T> wrapped = new InjectionTarget<T>() {\r\n @Override\r\n public void inject(T instance, CreationalContext<T> ctx) {\r\n it.inject(instance, ctx);\r\n for (Map.Entry<Field, Object> property: fieldValues.entrySet()) {\r\n try {\r\n Field key = property.getKey();\r\n key.setAccessible(true);\r\n Class<?> baseType = key.getType();\r\n String value = property.getValue().toString();\r\n if (baseType == String.class) {\r\n key.set(instance, value);\r\n } else if (baseType == Integer.class) {\r\n key.set(instance, Integer.valueOf(value));\r\n } else {\r\n pit.addDefinitionError(new InjectionException(\"Type \" + baseType + \" of Field \" + key.getName() + \" not recognized yet!\"));\r\n }\r\n } catch (Exception e) {\r\n pit.addDefinitionError(new InjectionException(e));\r\n }\r\n }\r\n }\r\n \r\n @Override\r\n public void postConstruct(T instance) {\r\n it.postConstruct(instance);\r\n }\r\n \r\n @Override\r\n public void preDestroy(T instance) {\r\n it.dispose(instance);\r\n }\r\n \r\n @Override\r\n public void dispose(T instance) {\r\n it.dispose(instance);\r\n }\r\n \r\n @Override\r\n public Set<InjectionPoint> getInjectionPoints() {\r\n return it.getInjectionPoints();\r\n }\r\n \r\n @Override\r\n public T produce(CreationalContext<T> ctx) {\r\n return it.produce(ctx);\r\n }\r\n };\r\n pit.setInjectionTarget(wrapped);<\/pre>\n
\n
\nPropertyLoaderExtension<\/strong><\/p>\npackage com.coderskitchen.propertyloader;\r\n \r\nimport javax.enterprise.context.spi.CreationalContext;\r\nimport javax.enterprise.event.Observes;\r\nimport javax.enterprise.inject.InjectionException;\r\nimport javax.enterprise.inject.spi.AnnotatedField;\r\nimport javax.enterprise.inject.spi.AnnotatedType;\r\nimport javax.enterprise.inject.spi.Extension;\r\nimport javax.enterprise.inject.spi.InjectionPoint;\r\nimport javax.enterprise.inject.spi.InjectionTarget;\r\nimport javax.enterprise.inject.spi.ProcessInjectionTarget;\r\nimport java.io.IOException;\r\nimport java.io.InputStream;\r\nimport java.lang.reflect.Field;\r\nimport java.util.HashMap;\r\nimport java.util.Map;\r\nimport java.util.Properties;\r\nimport java.util.Set;\r\n \r\npublic class PropertyLoaderExtension implements Extension {\r\n \r\n final Map<Field, Object> fieldValues = new HashMap<Field, Object>();\r\n \r\n public <T> void initializePropertyLoading(final @Observes ProcessInjectionTarget<T> pit) {\r\n AnnotatedType<T> at = pit.getAnnotatedType();\r\n if(!at.isAnnotationPresent(PropertyyFile.class)) {\r\n return;\r\n }\r\n PropertyyFile propertyyFile = at.getAnnotation(PropertyyFile.class);\r\n String filename = propertyyFile.value();\r\n InputStream propertiesStream = getClass().getResourceAsStream(\"\/\" + filename);\r\n Properties properties = new Properties();\r\n try {\r\n properties.load(propertiesStream);\r\n assignPropertiesToFields(at.getFields(), properties);\r\n \r\n } catch (IOException e) {\r\n e.printStackTrace();\r\n }\r\n \r\n final InjectionTarget<T> it = pit.getInjectionTarget();\r\n InjectionTarget<T> wrapped = new InjectionTarget<T>() {\r\n @Override\r\n public void inject(T instance, CreationalContext<T> ctx) {\r\n it.inject(instance, ctx);\r\n for (Map.Entry<Field, Object> property: fieldValues.entrySet()) {\r\n try {\r\n Field key = property.getKey();\r\n key.setAccessible(true);\r\n Class<?> baseType = key.getType();\r\n String value = property.getValue().toString();\r\n if (baseType == String.class) {\r\n key.set(instance, value);\r\n } else if (baseType == Integer.class) {\r\n key.set(instance, Integer.valueOf(value));\r\n } else {\r\n pit.addDefinitionError(new InjectionException(\"Type \" + baseType + \" of Field \" + key.getName() + \" not recognized yet!\"));\r\n }\r\n } catch (Exception e) {\r\n pit.addDefinitionError(new InjectionException(e));\r\n }\r\n }\r\n }\r\n \r\n @Override\r\n public void postConstruct(T instance) {\r\n it.postConstruct(instance);\r\n }\r\n \r\n @Override\r\n public void preDestroy(T instance) {\r\n it.dispose(instance);\r\n }\r\n \r\n @Override\r\n public void dispose(T instance) {\r\n it.dispose(instance);\r\n }\r\n \r\n @Override\r\n public Set<InjectionPoint> getInjectionPoints() {\r\n return it.getInjectionPoints();\r\n }\r\n \r\n @Override\r\n public T produce(CreationalContext<T> ctx) {\r\n return it.produce(ctx);\r\n }\r\n };\r\n pit.setInjectionTarget(wrapped);\r\n }\r\n \r\n private <T> void assignPropertiesToFields(Set<AnnotatedField<? super T>> fields, Properties properties) {\r\n for (AnnotatedField<? super T> field : fields) {\r\n if(field.isAnnotationPresent(Propertyy.class)) {\r\n Propertyy propertyy = field.getAnnotation(Propertyy.class);\r\n Object value = properties.get(propertyy.value());\r\n Field memberField = field.getJavaMember();\r\n fieldValues.put(memberField, value);\r\n }\r\n }\r\n }\r\n}<\/pre>\nDownloads<\/h2>\n
Final notes<\/h3>\n
\n <\/p>\n