Configuration beyond Java EE 8

BASEL BERN BRUGG DÜSSELDORF FRANKFURT A.M. FREIBURG I.BR. GENF
HAMBURG KOPENHAGEN LAUSANNE MÜNCHEN STUTTGART WIEN ZÜRICH
Configuration
beyond
Java EE
Configuration
with Apache
Tamaya and Microprofile.io

Configuration beyond Java EE 828.03.2017
Anatole Tresch
Principal Consultant, Trivadis AG (Switzerland)
Star Spec Lead
Technical Architect, Lead Engineer
PPMC Member Apache Tamaya
@atsticks
anatole@apache.org
anatole.tresch@trivadis.com
2
About Me

Agenda
3
●
What‘s all about ?
●
Framework Architecture
●
Accessing Configuration
●
Configuration Backends
●
Configuration Runtime
●
Services
●
Demo / Adoption Area

Configuration beyond Java EE 828.03.2017 4
What‘s all about ?

What is Configuration ?
Simple Key/value pairs?
Typed values?

When is Configuration useful?
Use Cases?

7
How is it stored?
Remotely or locally?
Classpath, file or ...?
Which format?
All of the above (=multiple sources) ?

When to configure?
Development time ?
Build/deployment time?
Startup?
Dynamic, anytime?

Configuration Lifecycle ?
Static ?
Refreshing ?
Changes triggered ?

10
Do I need a runtime ?
Java SE?
Java EE?
OSGI?
Kubernetes?

Framework Architecture

12
What Configuration Solutions are out there?
Apache Commons Config
Apache Tamaya
Apache Deltaspike
Netflix Archaius Config
Typesafe Config
Microprofile.io
...

Common Framework Design
Accessor API
Runtime
Extended Services
API
Runtime
Backends
Services

Accessing Configuration

15
Accessing configuration: Patterns
Service Locator Pattern
Configuration Injection
Templates

16
Configuration cfg = ConfigurationProvider.getConfiguration();
String name = cfg.get("example.name"));
String nameWithDefault = cfg.getOrDefault("example.name", "N/A");
BigDecimal bd = cfg.get("example.number", BigDecimal.class);
Map<String,String> properties = config.getProperties();
Accessing Config: Service Location Pattern

Config config = ConfigProvider.getConfig();
Config config = ConfigProvider.getConfig(
Thread.currentThread().getContextClassLoader());
String value = config.getValue("fooBar", String.class);
Integer intValue = config.getValue("fooBar", Integer.class);
Optional<Integer> getOptionalValue("fooBar", Integer.class);

Accessing Config: Service Location Pattern

18
Accessing Config: Templates
MyConfigClass cfg = ConfigurationInjection.getConfigurationInjector()
.getCon(MyCofignfigClass.class);
String name = cfg.getName();
BigDecimal bd = cfg.getNumber();

19
Accessing Config: Injection
public class NonAnnotatedConfigBean {
public String simple_value = "Should be overridden!";
public String fieldKey;
public String classFieldKey = "Foo";
public String fullKey;
public String test2 = "This is not set.";
}
public class AnnotatedBean{
@Config(value = {"foo.bar.myprop", "mp"}, defaultValue = "ET")
private String simpleValue;
@Config
String anotherValue;
}

20
Accessing Config: CDI
@Inject
@Config(value = {"foo.bar.myprop", "mp"}, defaultValue = "ET")
@Inject @Config
}

21
Accessing Config: CDI
@Inject
@ConfigProperty(name = "foo.bar.myprop", defaultValue = "ET")
@Inject @ConfigProperty(name = "foo.bar.myprop")
}

●
System-, Environment Properties, CLI Args
●
Files, Classpath Resources
●
Git, Subversion
●
Databases
●
Remote Services (etcd, consul)
●
Distributed Caches/Grids (Redis, Hazelcast, Infinispan etc)
●
...

Backend Model: ConfigSource
24
●
Add dependency
org.apache.tamaya:core: 0.2-incubating
●
Add Config to META-INF/javaconfiguration.properties
●
GO!
public interface ConfigSource {
    String getValue(String propertyName);
    Map<String, String> getProperties();
    default int getOrdinal() { return 100; }
    String getName();
}

Backend Model: PropertySource
25
●
Add dependency
●
●
GO!
public interface PropertySource {
    PropertyValue get(String key);
    Map<String, PropertyValue> getProperties();

    int getOrdinal();
    String getName();
    boolean isScannable();
}

Backend Model: PropertyValue
26
●
Add dependency
●
●
GO!
public final class PropertyValue{
public String getKey();
public String getValue();
public String get(String key);
public Map<String,String> getMetaEntries();
...
}

Programmatic Configuration Creation

ConfigurationContextBuilder
28
●
Add dependencyConfigurationContext context =
                   ConfigurationProvider.getConfigurationContextBuilder()
                .addPropertySources(testPropertySource, testPS2)
                .loadDefaultPropertyFilters()
                .addPropertyFilter(myFilter)
                .build();
Configuration config = builder.createConfig(context);
// Optionally
ConfigurationProvider.setConfiguration(config);

ConfigurationBuilder
29
●
Add dependencyConfigBuilder builder;
Configuration config =
                   builder
                .withSources(testPropertySource, testPS2)
                .build();

Configuration Runtime:
Apache Tamaya

●
Just Java 7 or higher !
What I need to run Tamaya ?
Configuration Cluster
Java EE
Tamaya
Java SE
Tamaya
Tamaya
Vertx.io
Tamaya
TomEE
Tamaya
Spring
Tamaya
OSGI

And how does it work ?

Apache Tamaya in 120 seconds...
33
1.Configuration = ordered list of
PropertySources
2.Properties found are combined using a
CombinationPolicy
3.Raw properties are filtered by PropertyFilter
4.For typed access PropertyConverters
have to do work
5.Extensions add more features
(discussed later)
6.Component Lifecycle is controlled by the
ServiceContextManager
ConfigurationContext
PropertyFilters
PropertySource
PropertySource
PropertySource
PropertySource
Configuration
CombinationPolicy
PropertyProviders
<provides>
PropertyConverter

Configuration Services

Remote configuration !

●
Configuration is read from remote source, e.g.
●
Etcd cluster
●
Consul cluster
●
Any Web URL
●
...
Remote PropertySources
Service Location Layer
Configuration Cluster
<dependency>
    <groupId>org.apache.tamaya.ext</groupId>
    <artifactId>tamayaetcd</artifactId>
    <version>...</version>
</dependency>

Easy Configuration:
„Meta“-Configuration !

●
Configuration that configures configuration
●
E.g. at METAINF/tamayaconfig.xml
●
Allows easy and quick setup of your configuration environment
●
Allows dynamic enablement of property sources
●
...
Meta-Configuration DRAFT !

<configuration>
<context>
<context-param name="stage">DEV</context-param>
</context>
<sources>
<source type="env-properties" enabled="${stage=TEST || stage=PTA || stage=PROD}" ordinal="200"/>
<source type="sys-properties" />
<source type="file">
<observe period="20000">true</observe>
<location>./config.json</location>
</source>
<source type="resources" multiple="true">
<multiple>true</multiple>
<location>/META-INF/application-config.yml</location>
</source>
<source type="ch.mypack.MyClassSource">
<locale>de</locale>
</source>
<source type="includes" enabled="${context.cstage==TEST}">
<include>TEST.properties</include>
</source>
</sources>
</configuration>
DRAFT !

Property resolution...
java.home=/usr/lib/java
compiler=${ref:java.home}/bin/javac
<dependency>
    <artifactId>tamayaresolver</artifactId>
</dependency>

Resource expressions…
public class MyProvider extends AbstractPathPropertySourceProvider{
  public MyProvider(){
    super(“classpath:/METAINF/config/**/*.properties“);
  }
  @Override
  protected Collection<PropertySource> getPropertySources(URL url) {
      // TODO map resource to property sources
      return Collections.emptySet();
  }
}
<dependency>
    <artifactId>tamayaresources</artifactId>
</dependency>

And more: a topic on its own!
42
●
Tamaya-spi-support: Some handy base classes to implement SPIs
●
Tamaya-functions: Functional extension points (e.g. remapping, scoping)
●
Tamaya-events: Detect and publish ConfigChangeEvents
●
Tamaya-optional: Minimal access layer with optional Tamaya support
●
Tamaya-filter: Thread local filtering
●
Tamaya-usagetracker: Tracking use and stats for configuration consumption
●
Tamaya-validation*: Configuration Documentation and Validation
●
Format Extensions: yaml, json, ini, … including formats-SPI
●
Integrations with Vertx, CDI, Spring, OSGI*, Camel, etcd, Consul
●
Tamaya-mutable-config: Writable ConfigChangeRequests
●
Tamaya-metamodel*: Configuration Meta-Model
●
Tamaya-collections*: Collection Support
●
Tamaya-resolver: Expression resolution, placeholders, dynamic values
●
Tamaya-resources: Ant styled resource resolution
•...
* experimental

Demo
Adoption Area: We 13:00h
(Community Hall)

Summary

Summary
45
●
Work on config JSR for a EE 8 has been stopped by Oracle
●
Community work is done in Microprofile.io and ASF
●
Microprofile API is very minimal, but will evolve.
●
Apache Tamaya provides most features you will ever need and supports
all major runtimes.

You like it ?

„It is your turn !“
● Use it
● Evangelize it
● Join the force!

Links
●
Project Page: http://tamaya.incubator.apache.org
●
Twitter: @tamayaconfig
●
Blog: http://javaeeconfig.blogspot.com
●
Presentation by Mike Keith on JavaOne 2013:
https://oracleus.activeevents.com/2013/connect/sessionDetail.ww?SESSION_ID=7755
●
Apache Deltaspike: http://deltaspike.apache.org
●
Java Config Builder: https://github.com/TNG/config-builder
●
Apache Commons Configuration: http://commons.apache.org/proper/commons-configuration/
●
http://microprofile.io
●
Microprofile Config API source: https://github.com/eclipse/microprofile-config
48

Q&A
49
Thank you!
@atsticks
anatole@apache.org
Anatole Tresch
Trivadis AG
Principal Consultant
Twitter/Google+: @atsticks
anatole@apache.org
anatole.tresch@trivadis.com

Configuration beyond Java EE 8

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (16)

Similar to Configuration beyond Java EE 8

Similar to Configuration beyond Java EE 8 (20)

More from Anatole Tresch

More from Anatole Tresch (16)

Recently uploaded

Recently uploaded (20)

Configuration beyond Java EE 8