Java 8 Collectors for Guava Collections

Java 8 comes with streaming API, it divides data processing into two phases: intermediate operations and terminal operation.Terminal operation can have few different forms and I would like to concentrate on reduction to collections, especially to Guava immutable collections. Terminal operation requires collector which will collect data and return it as required structure, but Guava does not provide such collector. In order to create Guava collection out of a stream we have to first reduce stream result into temporary collection and than transfer it:

Continue reading

cS at Mind the product 2014 #mtpcon

When I started my journey to “mind the product conference”, I was looking forward to the pubs. I knew that this was Europe’s biggest product conference, perhaps even the world’s largest one. I expected it to be a great event with many speakers and visitors from around the world. However, I was not really sure what to expect from the conference or the kind of educational experience it could offer me.

The mtp workshops

The day before the conference I joined the workshops. I’ve been particularly looking forward to the half-day workshop “Analytics and Testing” with Craig Sullivan. It’s known that most companies create their products solely based on assumptions without prior investigation and within the scope of user tests. The consequences that follow are wasted development investments, frustrated users and lost time to generate early competitive advantage. In Craig’s Workshop, UX, Analytics, Testing and Innovation were some of the topics discussed. Furthermore we discussed the importance of Copywrite-Testing. A variety of informative practice examples were also presented. In order to provide you with some practical examples from our projects, another blog on this topic would be recommendable.

My highlights from the #mtpcon

Continue reading

Spring Boot – my favorite timesaving conventionenabling autoconfigcreating beanmaking classpathshaking microcontainer

One of the common misconceptions when it comes to Spring based Java applications is that these require a sheer amount of configuration before one can even start working on the actual domain problem that the application is suppose to solve. This is mainly because of XML configurations that were greatly reduced with annotations already. But still, if you want to set-up a web application as quickly as possible without Spring (XML) configuration files you need to download and configure a web server, set-up a database connection, then write all the required beans, persistence.xml for hibernate, web.xml, etc. Since what you actually wanted was to code the solution to your very own problem you start asking yourself whether it really has to be so complicated!?

Continue reading

Eberhard Wolff zeigt wie’s geht – Die Spring Master Class in Berlin

berlin

Vom 24. bis 26. September 2014 fand erstmalig eine Schulung im Themenumfeld “Spring Framework” statt, die sich abseits der Platzhirsche VMWare und FastLane zu platzieren versucht. Angeboten und organisiert wird das hands-on Training von der Firma Gedoplan, die den Spring Evangelisten und Java Champion Eberhard Wolff für diese Veranstaltung in Berlin gewinnen konnte.

Wie der Titel bereits andeutet, zielen die Inhalte auf die Vermittlung von weiterführenden Konzepten in der Verwendung des Spring Framework ab. Ein guter Ausgangspunkt ist der Kenntnisstand der Spring Core Schulung und ca. zwei bis drei Projekte Praxiserfahrung. Diese helfen dabei, die verschiedenen Fragestellungen, die im Verlauf der Schulung aufgrund der extremen Flexibilität des Frameworks entstehen, aufzugreifen und einzuordnen.

Da Spring seiner Umgebung und dem Entwickler quasi keine Bedingungen auferlegt, haben Projekte, die darauf basieren, anfangs ein sehr hohes Entwicklungstempo und viel Prototyping Charakter, da viel ausprobiert wird. Ab einem gewissen Punkt kann diese Flexibilität zur Last werden wenn sich das Projekt hin zu einem Mix aus vielen verschiedenen Ansätzen entwickelt hat. Um dem entgegen zu wirken, empfiehlt es sich in einem frühen Stadium ein paar Konventionen festzulegen, die in der Regel wiederum von Spring belonht werden. Zu diesen Konzepten gehören ansich ganz natürliche und selbsterklärende Maßnahmen, deren eigentliche Macht spielen dann AOP Techniken und verschiedene Scanning Techniken aus.

So erarbeitete der Lehrgang zum Beispiel in einigen Übungen ein System das verschiedenen Ansätzen folgt, um eine 3 Tier Anwendung nicht nur in ihre technischen Schichten zu strukturieren sondern auch fachlich also vertikal in verschiedene Slices aufzuteilen. Über einfache aber oft unterschätzte Hilfsmittel wie Facaden oder die Sichtbarkeit von Klassen und Interfaces definierten wir klare Schnittstellen, ohne dass wir aufwendig mehrere jar Module erstellen mussten. Methoden zur Einbettung der Komponenten in unterschiedlichen Umgebungen zeigte, wie leicht mit Spring Boardmitteln zum Beispiel eine Anwendung für den Betrieb in einerseits einem JEE Application Server aufgesetzt werden konnte, mit wenigen Handgriffen aber auch ohne Probleme in einem Tomcat oder einer normalen SE jar runtime auskommen konnte, und das nur durch geschickte Strukturierung der Konfiguration. Das selbe Konzept greift natürlich für Spring-basierte JUnit/TestNG Tests, für die normalerweise nicht produktive Datenbanken verwendet werden. Also wird kurzerhand ein Teil der Konfiguration ausgetauscht. Konventionen und Struktur sind für solche Ansätze unerlässlich.

Wie bei Spring üblich gab es in allen besprochenen Ansätzen kein richtig oder falsch. Der Spring XML Konfiguration mit ihren mächtigen Namespaces wurde genauso Rechnung getragen wie der Möglichkeit, das gesamte Setup in reinem Java zu definieren. Als wichtigster Punkt wurde aber angeführt, sich für bestimmte Konzepte zu entscheiden und an diesen dann auch, so weit wie es geht, festzuhalten.

Ein neuer Big Player im spring.io Portfolio kam in dieser Schulung ebenfalls nicht zu kurz. Das Spring Boot Projekt vereint sehr viele Best Practices und sinnvolle Konventionen aus über 10 Jahren Spring unter einer Haube und löst so eine kleine Revolution in der Spring Welt aus. Der Spring Boot Aha Effekt für Entwickler wird deutlich, wenn man das Parade Code Beispiel von der Projekt Website unter die Lupe nimmt. Mit diesen wenigen Zeilen Code kann man ein normales jar File erzeugen, aus dem eine komplette Spring Webanwendung erwachsen kann:

package hello;

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;

@Controller
@EnableAutoConfiguration
public class SampleController {
    @RequestMapping("/")
    @ResponseBody
    String home() {
        return "Hello World!";
    }
    public static void main(String[] args) throws Exception {
        SpringApplication.run(SampleController.class, args);
    }
}

Diese Java Klasse hat fast genauso viele Zeilen Annotationen wie Code Zeilen. Das bringt die Spring Boot Magie ins Spiel. Im Hintergrung sorgen eine Vielzahl an Scannern, JavaConfig Klassen und “Good Guesses” für einen reibungslosen Start der Anwendung. Welche Java Libraries generell in der Applikationen verwendet werden sollen, gibt der Entwickler wie gewohnt per Maven oder Gradle an, hat dabei aber nun die Möglichkeit, auf vorgefertigte Spring Boot Dependencies zuzugreifen, die wie ein Plugin System automagisch Features hinzufügen, teilweise sogar ohne dass eine Zeile an der Klasse geändert werden muss. Wer noch mehr Details über Spring Boot erfahren möchte, dem sei dieser Spring Boot Artikel empfohlen.

Spring Boot macht hierbei vieles vor, was an vielen Stellen immer wieder angesprochen wird, Konventionen und Konsistenz erleichtern viele Dinge im täglichen Umgang mit Spring.

Hier noch einmal die besprochenen Themen in der Kurzzusammenfassung:

  • Infrastruktur Konfiguration
  • Pattern und Best Practices aus großen Spring Anwendungen
  • Spring AOP und AspectJ Support
  • weitere Spring Projekte wie  Integration, Security, Web Services und Batch im Einsatz

Zusammenfassend lässt sich die Schulung thematisch als durchweg gelungen und sehr gut organisiert bezeichnen. Auch wenn hier und da vielleicht nicht das letzte Spring Interna herausgequetscht wurde (was auch nicht Ziel dieser Schulung ist), so boten die drei Tage ein sehr gutes Hands-On Training. Für alle, die wissen wollen, wie große und komplexe Spring Anwendungen bereits in den Kinderschuhen richtig auf den Weg gebracht werden können, oder was bei einer Konsolidierung am ehesten angegangen werden sollte um am Ende des Tages ein einfach zu konfigurierendes und dennoch flexibles Stück Software ausliefern zu können, ist diese Schulung genau das Richtige.

 

How to create your own ‘dynamic’ bean definitions in Spring

Recently, I joined a software project with a Spring/Hibernate-based software stack, which is shipped in an SAAS-like manner, but the databases of the customers need to be separated from each other. Sounds easy for you? Ok let’s see what we have in detail.

1. Baseline study

Requirement: There is a software product that can be sold to different customers, but the provider wants to keep the sensible data of the customer in separate data sources. Every customer/login has only access to exactly one data source.

Continue reading

Processing and analysing sensor data – a DIY approach Part II

In a recent Lab, we set up sensors in our office to collect our own machine-generated data (see this blog post). For the follow-up lab, our team split up into three groups. Two of us set out to implement a nice real-time visualization of our data, another colleague investigated and benchmarked different document schemas for storing time series data in MongoDB (see this post on the MongoSoup blog), while the remaining two started analysing the data we collected. Continue reading

Advanced Reactive Programming with Akka and Scala

After getting acquainted with Akka in our first Akka lab, we – @RoadRunner12048 and @dmitterd – wanted to try monitoring an Akka application to get a better understanding of its dynamic behavior. Additionally, we wanted to play with clustering support. We used a very rough Stock trading simulation and a Ping-Pong application that we’ve both implemented in the first lab as subject for our experiments.

Continue reading