').text(key), 18 | $('
| Name | 33 |Active | 34 |
|---|
| Name | 48 |Active | 49 |
|---|
64 | (Micro)services to the rescue:
65 | Spring Boot Banner Generator by
66 | dhubau
67 |
68 | Or try the
69 | Text to ASCII Art Generator (TAAG).
70 |
")); 20 | cache.putIfAbsent("bannerlessBanner", rv); 21 | return rv; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /thymeleaf-banner-spring-boot-starter/src/main/java/ac/simons/springio2016/starter/ThymeleafBannerAutoConfiguration.java: -------------------------------------------------------------------------------- 1 | package ac.simons.springio2016.starter; 2 | 3 | import java.util.ArrayList; 4 | import org.springframework.beans.factory.annotation.Value; 5 | import org.springframework.boot.Banner; 6 | import org.springframework.boot.autoconfigure.AutoConfigureAfter; 7 | import org.springframework.boot.autoconfigure.AutoConfigureBefore; 8 | import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration; 9 | import org.springframework.boot.autoconfigure.condition.AllNestedConditions; 10 | import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; 11 | import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; 12 | import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; 13 | import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; 14 | import org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration; 15 | import org.springframework.cache.CacheManager; 16 | import org.springframework.context.annotation.Bean; 17 | import org.springframework.context.annotation.Conditional; 18 | import org.springframework.context.annotation.Configuration; 19 | import org.springframework.core.annotation.Order; 20 | import org.springframework.core.env.Environment; 21 | import org.thymeleaf.spring4.SpringTemplateEngine; 22 | 23 | @Configuration 24 | @ConditionalOnClass(SpringTemplateEngine.class) 25 | @AutoConfigureBefore(ThymeleafAutoConfiguration.class) 26 | @AutoConfigureAfter(CacheAutoConfiguration.class) 27 | class ThymeleafBannerAutoConfiguration { 28 | 29 | static class OnNoBannerButFun extends AllNestedConditions { 30 | 31 | public OnNoBannerButFun() { 32 | // This controlls wether beans are added or not. 33 | // If you would want to prevent configuration classes, 34 | // use ConfigurationPhase.PARSE_CONFIGURATION 35 | super(ConfigurationPhase.REGISTER_BEAN); 36 | } 37 | 38 | // See https://github.com/spring-projects/spring-boot/issues/2541 39 | @ConditionalOnProperty(name = "spring.main.banner-mode", havingValue = "off") 40 | static class OnBannerTurnedOff{} 41 | 42 | @ConditionalOnBean(CacheManager.class) 43 | static class OnCacheManagerAvailable{} 44 | 45 | @ConditionalOnProperty("thymeleaf-banner.cacheName") 46 | static class OnCacheNameSpecified{} 47 | } 48 | 49 | @Bean 50 | @Conditional(OnNoBannerButFun.class) 51 | @Order(-30) 52 | public BannerSupplier bannerlessBannerSupplier(CacheManager cacheManager, @Value("${thymeleaf-banner.cacheName}") String cacheName) { 53 | return new BannerlessBannerSupplier(cacheManager.getCache(cacheName)); 54 | } 55 | 56 | @Bean 57 | @ConditionalOnMissingBean(BannerSupplier.class) 58 | @ConditionalOnProperty(name = "spring.main.banner-mode", havingValue = "off") 59 | @Order(-20) 60 | public BannerSupplier emptyBannerSupplier() { 61 | return args -> new ArrayList<>(); 62 | } 63 | 64 | @Bean 65 | @ConditionalOnMissingBean(BannerSupplier.class) 66 | @Order(-10) 67 | public BannerSupplier defaultBannerSupplier( 68 | final Banner banner, 69 | final Environment environment 70 | ) throws ClassNotFoundException { 71 | return new ThymeleafBannerSupplier(banner, environment); 72 | } 73 | 74 | @Bean 75 | public ThymeleafBannerDialect webBannerDialect(final BannerSupplier bannerSupplier) { 76 | return new ThymeleafBannerDialect(bannerSupplier); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /thymeleaf-banner-spring-boot-starter/src/main/java/ac/simons/springio2016/starter/ThymeleafBannerDialect.java: -------------------------------------------------------------------------------- 1 | package ac.simons.springio2016.starter; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashSet; 5 | import java.util.List; 6 | import java.util.Set; 7 | import org.thymeleaf.Arguments; 8 | import org.thymeleaf.dialect.AbstractDialect; 9 | import org.thymeleaf.dom.Element; 10 | import org.thymeleaf.dom.Node; 11 | import org.thymeleaf.dom.Text; 12 | import org.thymeleaf.processor.IProcessor; 13 | import org.thymeleaf.processor.element.AbstractMarkupSubstitutionElementProcessor; 14 | 15 | class ThymeleafBannerDialect extends AbstractDialect { 16 | 17 | private final BannerSupplier bannerSupplier; 18 | 19 | public ThymeleafBannerDialect(BannerSupplier bannerSupplier) { 20 | this.bannerSupplier = bannerSupplier; 21 | } 22 | 23 | @Override 24 | public String getPrefix() { 25 | return "banner"; 26 | } 27 | 28 | @Override 29 | public Setthere are some SICK, @SpringBoot-bannerless people on the internet.
— Josh Long (龙之春) (@starbuxman) 23. Februar 2016
stay banner’d, my friends.
Even in the light of microservices good architecture and well thought modularization is vital for all kinds of application. A microservice without inner structure is as bad maintainable as an old-fashioned monolith, maybe even worse. Candidates for external modules that are intrinsic parts of many microservices without being one of their own could be:
460 | 461 |Those modules must not only be provided but also be configured, but often this configuration can be an opinionated configuration using sensible defaults which reduces manual configuration in many cases by magnitudes.
468 | 469 |In this article i will show you how to create custom "Starters" for Spring Boot based applications that provide opinionated configuration, custom functionality and more.
470 | 471 |Spring Boot can be seen as an umbrella project for the Spring eco-system that has been created with the following goals in mind:
474 | 475 |Spring Boot does not generate code during bootstrapping or during runtime and there is absolutely no requirement for XML configuration. All tools that are used by Spring Boot to detect available libraries, environment and configuration are available outside Spring Boot for the creation of custom configuration classes or whole "Starters".
482 | 483 |Rumor has it, that there's still a need for server-side generated HTML code, JavaScript as progressive enhancement und simple management of JavaScript dependencies without the the need to use the "Universal install script", even in 2016:
486 | 487 |
We all have been cursed about Maven, but fact is: It works most of the time unobtrusive and it is also pretty good in managing dependencies, resolve them and find conflicting versions (for example using the enforcer-plugin).
490 | 491 |WebJars is a project by James Ward and facilitates the explicit and easy management of the client-side dependencies in JVM-based web applications through Maven, SBT, Gradle, ivy or other build tools. Spring Boot supports WebJars out of the box and dependencies can be used like this:
492 | 493 |<link rel='stylesheet' href='/webjars/bootstrap/3.1.0/css/bootstrap.min.css'>wro4j is a tool for analyzing and optimizing web resources that combines many modern tools from frontend development.
496 | 497 |The goal is to express frontend dependencies inside the pom.xml:
<properties>
500 | <jquery.version>1.11.3</jquery.version>
501 | <angularjs.version>1.2.29</angularjs.version>
502 | </properties>
503 | <!-- ... -->
504 | <dependencies>
505 | <dependency>
506 | <groupId>org.webjars</groupId>
507 | <artifactId>jquery</artifactId>
508 | <version>${jquery.version}</version>
509 | </dependency>
510 | <dependency>
511 | <groupId>org.webjars</groupId>
512 | <artifactId>angularjs</artifactId>
513 | <version>${angularjs.version}</version>
514 | </dependency>
515 | </dependencies> and to combine those dependencies into logical modules. The following example shows a library group that is combined with custom JavaScript code into one module:
518 | 519 |<groups xmlns="http://www.isdc.ro/wro">
520 | <group name="lib">
521 | <js minimize="false">/webjars/jquery/@jquery.version@/jquery.min.js</js>
522 | <js minimize="false">/webjars/angularjs/@angularjs.version@/angular.min.js</js>
523 | <js minimize="false">/webjars/angularjs/@angularjs.version@/angular-route.min.js</js>
524 | </group>
525 |
526 | <group name="biking2">
527 | <group-ref>lib</group-ref>
528 |
529 | <css>/css/stylesheet.css</css>
530 |
531 | <js>/js/app.js</js>
532 | <js>/js/controllers.js</js>
533 | <js>/js/directives.js</js>
534 | </group>
535 | </group>We're using the Xml configuration of Wro4j but there's also a nice Groovy DSL available.
538 | 539 |This necessary configuration of what is to be used combined with the starter should be enough to include jQuery, AngularJS and custom functionality through one single HTML element.
540 | 541 |A Spring Boot starter consists of two components:
544 | 545 |autoconfigure module containing the automatic configuration including it's default values.starter module itself, providing the dependency to the autoconfigure module and all needed additional dependenciesIncluding the starter as a dependency for a Spring Boot application should be enough to start using that library. If a separation of those two isn't needed, combine everything into the starter module.
Pivotals Spring Developer Advocate Josh Long explicitly opposes calling auto configuration inside Spring Boot applications "magic" and he is right saying so.
555 | 556 |The environments automatic configuration is based on two core components:
557 | 558 |@Profile, available since Spring 3.1) and@Conditional together with org.springframework.context.annotation.Condition, available since Spring 4)Profiles allow provisioning of Beans based on active profiles (spring.profiles.active), whereas conditions can be used to model simple to complex conditions under which Beans are instantiated and configured:
@Conditional from the core framework allows with a custom implementation of a Condition arbitrary statementsSpring Boot contains several useful implementations
570 | 571 |@ConditionalOnBean / @ConditionalOnMissingBean: Configuration and beans are only instantiated and used when certain other Beans are available or missing@ConditionalOnClass / @ConditionalOnMissingClass: Configuration and beans are only instantiated and used when certain classes are available to the classloader@ConditionalOnResource is triggered only when specific resources are available@ConditionalOnProperty: A really powerful condition that matches concrete properties inside configurational filesAs much the automatic configuration of Spring Boot applications and their adaption to environment seems magical, it doesn't fit Clarke's third law. It's all there to see and use. Spring Boot even provides a ConditionEvaluationReport, that allows exactly to understand, why a configuration in a given order took place.
579 | 580 |And by the way: Spring uses it's own features: The @Profile annotation has been rewritten for Spring 4 and is based on Conditions itself.
Wro4js core is basically the Servlet filter mapped to an URL pattern which processes the requests for CSS and JavaScript files configured in wro.xml or wro.groovy. This filter should be added the the servlet registration without manual interaction by just adding the wro4j-spring-boot-starter dependency:
@Configuration
587 | @ConditionalOnClass(WroFilter.class)
588 | @ConditionalOnMissingBean(WroFilter.class)
589 | @EnableConfigurationProperties(Wro4jProperties.class)
590 | @AutoConfigureAfter(CacheAutoConfiguration.class)
591 | public class Wro4jAutoConfiguration {
592 | }
593 |
594 | @ConfigurationProperties("wro4j")
595 | public class Wro4jProperties {
596 | }Wro4jAutoConfiguration is a common Spring @Configuration class (classes which use programmatically instantiate, configure and provide Beans). The configuration - all methods annotated with @Bean among others - should only be done if the WroFilter class is available and there isn't a bean of that type yet. Configuration should be done after the automatic cache configuration as this will be used later. This class also provides properties starting with "wro4j.*" inside an object, in an instance of Wro4jProperties.
There's a caveat here: Often you create configuration for a possible starter inside the project that's using the starter first. That works fine (as by default all @Configuration classes under the base package are evaluated) until the classes building that starter are extracted from the project and you forget to add a META-INF/spring.factories. This file is very similar to the Java "Service Provider Interfaces" and contains the list of classes that should take part in autoconfiguration:
org.springframework.boot.autoconfigure.EnableAutoConfiguration = ac.simons.spring.boot.wro4j.Wro4jAutoConfigurationWith this file Spring Boot neither doesn't have to scan the whole classpath for starter nor the user must take additional steps besides adding the starter itself.
605 | 606 |Back to the example. The Servlet filter is a regular Spring Bean and is created like this inside Wro4jAutoConfiguration:
@Bean
609 | ConfigurableWroFilter wroFilter(WroManagerFactory wroManagerFactory, Wro4jProperties wro4jProperties) {
610 | ConfigurableWroFilter wroFilter = new ConfigurableWroFilter();
611 | wroFilter.setProperties(wroFilterProperties(wro4jProperties));
612 | wroFilter.setWroManagerFactory(wroManagerFactory);
613 | return wroFilter;
614 | }As you can see: The filter depends on a WroManagerFactory and other properties which are injected as usual into this method.
This example shows how powerful the code based configuration of Spring Beans is: Complex conditions and configuration are right their in the source and can be understood, debugged and more, with or without tooling support by IDEs.
619 | 620 |Wro4j supports caching of optimized resources through a simple, memory-based Least Recently Used strategy. The strategy is an interface and an implementation of a new CacheStrategy using the built-in org.springframework.cache.CacheManager is easily done. To make it work there must be an instance of Springs CacheManager. To get one, use @EnableCaching for example. As Spring supports several caches, ehcache, Redis and others, you get either get a manager backed by either one of those.
Otherwise, if there's no cache manager, the starter should use the basic Wro4j strategy that certainly doesn't make use of any Spring features:
625 | 626 |@Bean
627 | @ConditionalOnBean(CacheManager.class)
628 | @ConditionalOnProperty("wro4j.cacheName")
629 | @ConditionalOnMissingBean(CacheStrategy.class)
630 | @Order(-100)
631 | <K, V> CacheStrategy<K, V> springCacheStrategy(CacheManager cacheManager, Wro4jProperties wro4jProperties) {
632 | return new SpringCacheStrategy<K, V>(cacheManager, wro4jProperties.getCacheName());
633 | }
634 |
635 | @Bean
636 | @ConditionalOnMissingBean(CacheStrategy.class)
637 | @Order(-90)
638 | <K, V> CacheStrategy<K, V> defaultCacheStrategy() {
639 | return new LruMemoryCacheStrategy<K, V>();
640 | }The springCacheStrategy method is only executed if a CacheManager is active, the name for the actual cache is configured and there isn't a cache strategy already defined. By using an additional @Order annotation its ensured that this method is evaluated before defaultCacheStrategy, which instantiates the default Wro4j strategy.
There are certainly people who would add this exampel to @Annotatiomania™ in no time, but I think using this combination of annotations and code for conditions and configuration apart from business logic and objects is an appropriate and actually readable way.
645 | 646 |The example project is a standard Maven project, combining a shared autoconfigure and starter module. As such, it bundles the implementation of autoconfiguration as well as the dependencies to Wroj4:
<dependencies>
651 | <dependency>
652 | <groupId>org.springframework.boot</groupId>
653 | <artifactId>spring-boot-starter</artifactId>
654 | </dependency>
655 |
656 | <dependency>
657 | <groupId>ro.isdc.wro4j</groupId>
658 | <artifactId>wro4j-core</artifactId>
659 | <version>${wro4j.version}</version>
660 | </dependency>
661 |
662 | <dependency>
663 | <groupId>org.springframework.boot</groupId>
664 | <artifactId>spring-boot-starter-test</artifactId>
665 | <scope>test</scope>
666 | </dependency>
667 | </dependencies>The dependencies of the autoconfigure module are usually marked as optional and only finalized in the starter module when creating two separate projects.
There's one peculiarity of the starter presented here: It's a child artifact of the official spring-boot-starters parent project. I thought it would be a nice training for clean code and good coding guidelines learning from the settings the Spring team uses. But, as i heard, they only want to inflict them on themselves. What made my life easier was my preferred IDE, which supports Checkstyle, JaCoCo and others out of the box.
672 | 673 |The project is available on GitHub.
674 | 675 |The starter described here is in production in several projects in our company as well as in public, for example at the Euregio JUG. It saved us from manually managing dependencies and copy and pasting recurring configuration.
678 | 679 |There are few alternatives to Spring Boot Starters when developing shared modules for Spring Boot based applications. You could use annotation based configuration for them (@Service and the like) but than you'd have to trigger classpath scanning on a broader level. Manually writing additional XML or Java based configuration seems tedious and may lead to errors.
There are many useful starters listed in the spring-boot-starters-repository: Be it database integration, support for various template engines or even remote shells.
682 | 683 |The goal of providing a starter for Wro4j was reached. You have to add the starter and a wro.xml like above containing Maven placeholders like @jquery.version@, which are also used for the WebJar dependencies and processed by the Maven resource plugin:
<resources>
686 | <resource>
687 | <directory>src/main/resources</directory>
688 | <filtering>true</filtering>
689 | <includes>
690 | <include>wro.xml</include>
691 | </includes>
692 | </resource>
693 | </resources>You are free to configure the Wro4j processors and url inside application.properties:
wro4j.filterUrl = /owr
698 | wro4j.managerFactory.preProcessors = removeSourceMaps, cssUrlRewriting, cssImport, cssMinJawr, semicolonAppender, jsMin
699 | wro4j.cacheName = wro4jand as a result you'll get minimized CSS and JavaScript resources that can be included with a single statement in your HTML pages.
702 | 703 |The starter here can be extended by creating custom Thymeleaf elements that either render one single HTML element or links to the original resources so that they can be easily debugged. The approach would be the same: Check if Thymeleaf is on the path, register additional tags and so on.
706 | 707 |
Michael Simons is a Software-Architect (CPSA-F) at ENERKO Informatik in Aachen and working on GIS, EDM und sales management systems. Michael is cofounder of the Euregio JUG and is blogging in regular intervals at info.michael-simons.eu.
712 | 713 |Auch in Zeiten von Microservices ist Architektur und sinnvolle Modularisierung wichtig. Ein Microservice ohne innere Struktur ist ebensowenig wartbar wie ein Monolith. Auch wenn Architekturen immer feiner zergliedert werden gibt es dennoch Module, die in mehreren Microservices genutzt werden, ohne selber wiederum ein Microservice zu sein. 460 | Konkrete Beispiele sind zum Beispiel:
461 | 462 |Natürlich müssen diese Module nicht nur bereitgestellt werden, sie müssen ebenfalls konfiguriert werden. In vielen Fällen kann dabei allerdings eine Vorgabe mit sinnvollen Standardwerten manuellen Mehraufwand erheblich verringern.
469 | 470 |Dieser Artikel stellt eine Möglichkeit vor, wie eigene Module zur Bereitstellung von Funktionen und zur Autokonfiguration für Spring Boot basierte Anwendungen erstellt werden können.
471 | 472 |Spring Boot kann im weitesten Sinne als Schirmprojekt im Spring Eco-System betrachtet werden, das mit folgenden Zielen geschaffen wurde:
475 | 476 |Während des Bootstrappings von Anwendungen und deren Autokonfiguration wird zu keinem Zeitpunkt Code generiert. Alle Mittel, die von Spring Boot genutzt werden, um festzustellen, welche Bibliotheken verfügbar sind, in welchem Umfeld eine Anwendung läuft und wie sie konfiguriert ist, stehen auch außerhalb des Frameworks zur Entwicklung eigener "Starter" zur Verfügung.
483 | 484 |Auch im Jahr 2016 soll es den Bedarf geben, Webanwendungen mit serverseitig gerendertem HTML Code, JavaScript als "Progressive Verbesserung" und einfacher Verwaltung von JavaScript zu erstellen, ohne das "Universal install script" benutzen zu müssen:
487 | 488 |
Wir alle haben schon über Maven geflucht, aber in der Regel funktioniert Maven unauffällig und es ist ziemlich gut darin, Abhängigkeiten zu verwalten, aufzulösen und widersprüchliche Versionen (z.B. mit dem enforcer-plugin) zu entdecken.
491 | 492 |WebJars ist ein Projekt von James Ward und ermöglicht die explizite und einfache Verwaltung von JavaScript, CSS und ähnlichen Abhängigkeiten mittels Maven, SBT, Gradle, ivy oder anderen Buildtools. Spring Boot unterstützt WebJars unmittelbar. Abhängigkeiten können direkt genutzt werden, z.B.
493 | 494 |<link rel='stylesheet' href='/webjars/bootstrap/3.1.0/css/bootstrap.min.css'>wro4j ist ein Werkzeug zur Analyse und Optimierung von Webresourcen, das viele moderne Werkzeuge aus der Webentwicklung zusammen bringt.
497 | 498 |Ziel ist es, Abhängigkeiten im pom.xml zu definieren:
<properties>
501 | <jquery.version>1.11.3</jquery.version>
502 | <angularjs.version>1.2.29</angularjs.version>
503 | </properties>
504 | <!-- ... -->
505 | <dependencies>
506 | <dependency>
507 | <groupId>org.webjars</groupId>
508 | <artifactId>jquery</artifactId>
509 | <version>${jquery.version}</version>
510 | </dependency>
511 | <dependency>
512 | <groupId>org.webjars</groupId>
513 | <artifactId>angularjs</artifactId>
514 | <version>${angularjs.version}</version>
515 | </dependency>
516 | </dependencies> und dann logische Einheiten zu bilden. In diesem kleinen Beispiel soll eine Library mit allen fremden Ressourcen zusammen mit den eigenen JavaScript Programmen ein gemeinsames Modul bilden (zusätzlich zu der hier verwendeten Xml Konfiguration stellt Wro4j auch eine Grooy DSL zur Verfügung):
519 | 520 |<groups xmlns="http://www.isdc.ro/wro">
521 | <group name="lib">
522 | <js minimize="false">/webjars/jquery/@jquery.version@/jquery.min.js</js>
523 | <js minimize="false">/webjars/angularjs/@angularjs.version@/angular.min.js</js>
524 | <js minimize="false">/webjars/angularjs/@angularjs.version@/angular-route.min.js</js>
525 | </group>
526 |
527 | <group name="biking2">
528 | <group-ref>lib</group-ref>
529 |
530 | <css>/css/stylesheet.css</css>
531 |
532 | <js>/js/app.js</js>
533 | <js>/js/controllers.js</js>
534 | <js>/js/directives.js</js>
535 | </group>
536 | </group>Diese Konfiguration sollte mit dem zu erstellenden Starter ausreichen, jQuery, AngularJS und eigene Funktionen in eine Webseite über ein einziges Element einzubinden.
539 | 540 |Zu einem Starter gehören folgende Komponenten
543 | 544 |autoconfigure Modul, das die automatische Konfiguration mit ihren entsprechenden Standardwerten beinhaltetstarter Modul, das von der autoconfigure Modul abhängig ist und gegebenenfalls weitere Abhängigkeiten mit bringtIn der eigentlichen Anwendung wird das starter Modul eingebunden. Natürlich können beide Module in einem Modul kombiniert werden.
Pivotals Spring Developer Advocate Josh Long spricht sich explizit dagegen aus, die Autokonfiguration durch Spring Boot als "Magie" zu bezeichnen und er hat Recht damit.
554 | 555 |Die automatische Konfiguration der Umgebung basiert auf 2 Kernkomponenten
556 | 557 |@Profile, verfügbar seit Spring 3.1) und@Conditional im Zusammenspiel org.springframework.context.annotation.Condition, verfügbar seit Spring 4)Profile ermöglichen die Bereitstellungen von Beans auf Basis aktivierter Umgebungen (spring.profiles.active), Bedingungen ermöglichen einfache bis komplexe Bedingungen, unter denen Beans instanziiert und konfiguriert werden:
@Conditional aus dem Kernframework selber ermöglich mit der Implementierung eigener Bedingungen beliebige AbfragenAus Spring Boot selber einige Highlights:
569 | 570 |@ConditionalOnBean / @ConditionalOnMissingBean: Konfiguration oder Beans werden nur erzeugt, wenn bestimmte andere Beans vorliegen oder fehlen@ConditionalOnClass / @ConditionalOnMissingClass: Konfiguration oder Beans werden nur erzeugt, wenn bestimmte Klassen auf dem Klassenpfad verfügbar sind@ConditionalOnResource: Tritt nur in Kraft, wenn spezifische Ressourcen verfügbar sind@ConditionalOnProperty: Eine mächtige Bedingung zur Abfrage auf konkrete Eigenschaften in KonfigurationsdateienSo sehr die automatische Umgebung magisch wirkt, sie ist es nicht. Spring Boot stellt mit dem ConditionEvaluationReport sogar eine Reporting Lösung zur Verfügung, mit der genau nachvollzogen werden kann, warum, wie und in welcher Reihenfolge automatische Konfiguration durchgeführt wurde.
578 | 579 |Übrigens nutzt Spring seine eigenen Features intensiv: Die @Profile Annotation wurde im Rahmen von Spring 4 neu geschrieben und basiert nun selber auf Conditions.
Der Kern des Wro4j Packets ist der Servletfilter, der unter einem bestimmten Mapping Anfragen für CSS und JavaScript Dateien entgegen nimmt und entsprechend seiner Konfiguration verarbeitet. Durch hinzufügen des wro4j-spring-boot-starter soll dieser Filter ohne weitere "Nacharbeit" bereitgestellt werden:
@Configuration
586 | @ConditionalOnClass(WroFilter.class)
587 | @ConditionalOnMissingBean(WroFilter.class)
588 | @EnableConfigurationProperties(Wro4jProperties.class)
589 | @AutoConfigureAfter(CacheAutoConfiguration.class)
590 | public class Wro4jAutoConfiguration {
591 | }
592 |
593 | @ConfigurationProperties("wro4j")
594 | public class Wro4jProperties {
595 | }Wro4jAutoConfiguration ist eine gewöhnliche Spring @Configuration Klasse (das sind Klassen, in denen Beans programmatisch über Java Code instanziiert und konfiguriert werden können). Die in ihr vorgenommene Konfiguration soll dann ausgeführt werden, wenn die WroFilter Klasse verfügbar ist und es noch keine Bean entsprechenden Types gibt. Sie soll nach der automatischen Cache Konfiguration durchgeführt werden, da diese benötigt wird. Ferner stellt sie alle Eigenschaften, die mit "wro4j.*" beginnen, als Objekt mit entsprechenden Attributen zur Verfügung.
Entsteht der eigene Spring Boot Starter innerhalb des Projektes, in dem er zuerst benutzt wird, übersieht man sehr schnell META-INF/spring.factories, da alle @Configuration Klassen mit ihren Bedingungen in einem Spring Boot Projekt automatisch ausgewertet werden. spring.factories ähnelt nicht ganz zufällig dem eingebauten Java "Service Provider Interfaces". Die Factories Definition für den Wro4j Starter sieht ganz einfach aus:
org.springframework.boot.autoconfigure.EnableAutoConfiguration = ac.simons.spring.boot.wro4j.Wro4jAutoConfigurationDiese Aufzählung von Konfigurationsklassen führt beim Laden der Bibliothek zu ihrer Auswertung und vermeidet dadurch sowohl ein manuelles Aufzählen als auch einen vollständigen Scan des Klassenpfads nach @Component-Beans.
Zurück zum Beispiel. Der eigentliche Filter ist nichts anderes als eine normale Spring Bean und wird wie folgt in Wro4jAutoConfiguration erzeugt:
@Bean
608 | ConfigurableWroFilter wroFilter(WroManagerFactory wroManagerFactory, Wro4jProperties wro4jProperties) {
609 | ConfigurableWroFilter wroFilter = new ConfigurableWroFilter();
610 | wroFilter.setProperties(wroFilterProperties(wro4jProperties));
611 | wroFilter.setWroManagerFactory(wroManagerFactory);
612 | return wroFilter;
613 | }Gut erkennbar: Der Filter hängt von einer WroManagerFactory und zusätzlichen Eigenschaften ab, die in diese Methode injiziert werden.
Am Beispiel der automatischen Konfiguration zeigt sich die Mächtigkeit der Javabasierten Konfiguration von Spring Beans: Komplexe Bedingungen lassen sich in Quelltext ausdrücken und mit Werkzeugunterstützung aller aktuellen IDEs nachvollziehen.
618 | 619 |Wro4j unterstützt Caching von optimierten Ressourcen in Form einer einfachen, speicherbasierten Least Recently Used Strategy. Eine Implementierung dieser CacheStrategy ist schnell geschrieben und mit wenig Code kann der org.springframework.cache.CacheManager genutzt werden, sofern zur Laufzeit eine Instanz vorliegt (das ist zum Beispiel immer dann der Fall, wenn Springs @EnableCaching genutzt wird; Spring unterstützt eine Vielzahl Caches, u.a. ehcache, Redis und mehr).
Ist für die jeweilige Applikation kein Cache konfiguriert, so soll die standardmässige Wro4j Implementierung genutzt werden:
624 | 625 |@Bean
626 | @ConditionalOnBean(CacheManager.class)
627 | @ConditionalOnProperty("wro4j.cacheName")
628 | @ConditionalOnMissingBean(CacheStrategy.class)
629 | @Order(-100)
630 | <K, V> CacheStrategy<K, V> springCacheStrategy(CacheManager cacheManager, Wro4jProperties wro4jProperties) {
631 | return new SpringCacheStrategy<K, V>(cacheManager, wro4jProperties.getCacheName());
632 | }
633 |
634 | @Bean
635 | @ConditionalOnMissingBean(CacheStrategy.class)
636 | @Order(-90)
637 | <K, V> CacheStrategy<K, V> defaultCacheStrategy() {
638 | return new LruMemoryCacheStrategy<K, V>();
639 | }Die springCacheStrategy Methode wird nur dann ausgeführt, wenn ein CacheManager aktiv ist, der Name des zu nutzenden Caches konfiguriert wurde und noch keine anderweitig konfigurierte Strategie vorhanden ist. Durch @Order Annotation wird sichergestellt, dass die Methode vor defaultCacheStrategy ausgewertet wird, die die Defaultimplementierung von Wro4j nutzt.
Es gibt sicherlich Stimmen, die dieses Beispiel gerne auf @Annotatiomania™ sehen würden, aber gerade zur Konfiguration außerhalb von Geschäftslogik und fachlichen Objekten hält der Autor Annotationen für ein probates und gut lesbares Werkzeug, Bedingungen zu definieren.
644 | 645 |Das Beispielprojekte ist ein normales Maven Projekt, in dem ein gemeinsames autoconfigure und starter Modul implementiert wurde. Es bringt daher die Abhängigkeiten zu Wro4j direkt mit:
<dependencies>
650 | <dependency>
651 | <groupId>org.springframework.boot</groupId>
652 | <artifactId>spring-boot-starter</artifactId>
653 | </dependency>
654 |
655 | <dependency>
656 | <groupId>ro.isdc.wro4j</groupId>
657 | <artifactId>wro4j-core</artifactId>
658 | <version>${wro4j.version}</version>
659 | </dependency>
660 |
661 | <dependency>
662 | <groupId>org.springframework.boot</groupId>
663 | <artifactId>spring-boot-starter-test</artifactId>
664 | <scope>test</scope>
665 | </dependency>
666 | </dependencies>Sollen zwei separate Projekte erstellt werden, so werden die Abhängigkeiten des autoconfigure Moduls in der Regel als optional gekennzeichnet und erst im starter Modul konkretisiert.
Die Besonderheit des hier erstellten Starters liegt darin, dass er als Child-Artifact vom offiziellen spring-boot-starters Projekt erbt, weil der Autor sich bei diesem Projekt an die Kodierungsrichtlinien des Spring Teams halten wollte. Erleichternd dabei war die Tatsache, dass NetBeans Checkstyleregeln ebenso wie JaCoCo direkt unterstützt.
671 | 672 |Der vollständige Quelltext des Projektes ist auf GitHub verfügbar.
673 | 674 |Der hier beschriebene Spring Boot Starter wird in mehreren Projekten produktiv eingesetzt, unter anderem bei der Euregio JUG: Durch Einbinden des Starters entfallen das manuelle Einbinden von Abhängigkeiten, zusätzliche Konfiguration und vieles mehr.
677 | 678 |Es gibt wenige Alternativen zu Spring Boot Startern im Spring Umfeld, wenn gemeinsame Module für Anwendungen erstellt werden sollen: Wird Annotationsbasierte Konfiguration in diesen Modulen eingesetzt (zum Beispiel @Service und ähnliche), so muss Sorge dafür getragen werden, dass diese Komponenten auch im Klassenpfad gefunden werden. XML basierte Konfiguration ist aufwändig und oft fehlerträchtig.
Das spring-boot-starters-Repository listet eine Vielzahl Starter auf: Von Datenbankanbindungen über Templatesprachen zu Remote Shells ist viel Nützliches dabei.
681 | 682 |Der Autor nutzt weitere Starter, zum Beispiel zur Bereitstellung von Entitäten und Repositories zur Speicherung von OAuth Credentials.
683 | 684 |Das Ziel des wro4j-starters wurde vollständig erfüllt. Im obigen Listing sieht man, dass die wro.xml Konfigurationsdatei Mavenplatzhalter wie zum Beispiel @jquery.version@ enthält, die während des Buildvorgangs durch die entsprechenden Maven Properties ersetzt werden:
<resources>
687 | <resource>
688 | <directory>src/main/resources</directory>
689 | <filtering>true</filtering>
690 | <includes>
691 | <include>wro.xml</include>
692 | </includes>
693 | </resource>
694 | </resources>Die automatische Konfiguration liest application.properties aus:
wro4j.filterUrl = /owr
699 | wro4j.managerFactory.preProcessors = removeSourceMaps, cssUrlRewriting, cssImport, cssMinJawr, semicolonAppender, jsMin
700 | wro4j.cacheName = wro4jDas Ergebnis ist jeweils eine minimierte CSS und JavaScript Datei, die mit einem Statement eingebunden werden kann. Diese Optimierung funktioniert auch problemlos mit AngularJS SPA Anwendungen.
703 | 704 |Der Starter kann dahingehend erweitert werden, dass je nach Umgebung die URL der optimierten Ressourcen oder die Informationen aus dem Model in die Seite generiert werden. Das Vorgehen wäre identisch: Feststellen, ob Unterstützung für Templatesprachen wie Thymeleaf oder andere auf dem Klassenpfad sind und entsprechende zusätzliche Tags registrieren.
707 | 708 |
Michael Simons ist Software-Architekt (CPSA-F) bei ENERKO Informatik in Aachen und entwickelt dort GIS-, EDM- und Vertriebsmanagement-Systeme für Stromnetzbetreiber und Energielieferanten. Michael ist Mitgründer der Euregio JUG und schreibt über ihre Entwicklung und andere Dinge unter info.michael-simons.eu.
713 | 714 |