Java on Micha Kops' Tech Notes

Orchestrator Agent with Parallel Sub-Agents in Kiro CLI

Thu, 02 Jul 2026 00:00:00 +0200

Figure 1. kiro orchestrator agents

Overview

Kiro CLI allows us to configure an orchestrator agent that executes specialized sub-agents in parallel. Each sub-agent has its own tools, permissions, and MCP servers – the parent’s trust settings are not inherited.

Architecture

Figure 2. Agents flow

Step 1: Define Specialized Agents

We give each sub-agent its own JSON configuration under .kiro/agents/.

.kiro/agents/code-agent.json

{
  "name": "code-agent",
  "description": "Implements features and writes code",
  "prompt": "You are an experienced Kotlin/Java developer. Write clean, tested code.",
  "tools": ["read", "write", "shell", "code", "grep"],
  "allowedTools": ["read", "code", "grep"],
  "toolsSettings": {
    "write": {
      "allowedPaths": ["./src/**", "./tests/**"],
      "deniedPaths": ["./.env", "./secrets/**"]
    },
    "shell": {
      "allowedCommands": ["mvn test", "mvn compile"],
      "autoAllowReadonly": true
    }
  }
}

CVE Scanning and Guided Remediation with OSV Scanner

Fri, 28 Mar 2025 00:00:00 +0100

Figure 1. OSV Scanner

Security is a critical aspect of software development, and staying ahead of vulnerabilities is essential for us application developers. Google’s OSV Scanner is a powerful tool that helps detect vulnerabilities in open-source dependencies.

This article will guide us through setting up and using OSV Scanner to secure our projects, scan for invalid licenses, scan OCI images and finally how to fix findings via guided remediation.

Messaging with NATS and Java

Tue, 26 Nov 2024 00:00:00 +0100

Figure 1. NATS Architecture Component Diagram

NATS is a high-performance messaging system that offers simplicity, speed, and scalability. It is particularly suited for building distributed systems and microservices.

This article demonstrates how to integrate NATS with Java, showcasing the essential steps to set up, connect, and publish/subscribe to messages.

Prerequisites

Before diving in, we should ensure to have the following installed:

Java Development Kit (JDK) 11 or later.
Maven or Gradle for dependency management.
Docker (optional).

Object Audit with Java and Javers

Mon, 18 Sep 2023 00:00:00 +0200

Figure 1. Object Audit with Java and Javers

Just a quick snippet

Maven Integration

pom.xml

<dependency>
  <groupId>org.javers</groupId>
  <artifactId>javers-core</artifactId>
  <version>${javers.version}</version>
</dependency>

Calculate Changes in Object Graph

package io.hascode;

import org.javers.core.Changes;
import org.javers.core.Javers;
import org.javers.core.JaversBuilder;
import org.javers.core.diff.Diff;

public <T> Changes diff(T snapshot, T latest) {
  Javers javers = JaversBuilder.javers().build();
  Diff diff = javers.compare(snapshot, latest);
  return diff.getChanges();
}

Resources

Javers Website

Forwardings Requests to static content in Spring Boot Webflux

Tue, 16 Aug 2022 00:00:00 +0200

The following WebFilter redirects incoming requests for / to a static HTML file, index.html.

ToIndexPageRedirection.java

package com.hascode.tutorial;

import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;

@Component
public class ToIndexPageRedirection implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        if (exchange.getRequest().getURI().getPath().equals("/")) {
            return chain.filter(
                exchange.mutate().request(
                    exchange.getRequest().mutate().path("/index.html").build()
                ).build()
            );
        }

        return chain.filter(exchange);
    }
}

Ressources:

JavaDocs WebFilter

Single Class Java HTTP Client with Proxy and SSL/TLS Keystore Settings

Tue, 02 Aug 2022 00:00:00 +0200

Sometimes this is useful for the diagnosis of configuration and network problems of ones Java application.

This is our single-class HTTP client example without the need for external dependencies:

HttpTest.java

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ProxySelector;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class HttpTest {
    public static void main(String[] args)
        throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException, IOException, CertificateException {
        String bodyPayload = """
            ourpayload, json, xml, ...
            """;

        String keyStorePath = "/opt/keystore.jks";
        String keyStorePassword = "ABCDEFG";

        String proxyHost = "ourproxy.proxy";
        String uriString = "https://some-service/api";
        int proxyPort = 8080;
        int timeoutInSeconds = 60;

        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());

        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX");
        keyManagerFactory.init(keyStore, null);

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("PKIX"); // using same keystore for both
        trustManagerFactory.init(keyStore);

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        HttpClient client = HttpClient.newBuilder()
                                      .proxy(
                                          ProxySelector.of(new InetSocketAddress(proxyHost, proxyPort)))
                                      .sslContext(sslContext)
                                      .build();
        URI uri = new URI(uriString);
        HttpRequest request = HttpRequest.newBuilder(uri)
                                         .POST(BodyPublishers.ofString(bodyPayload))
                                         .timeout(Duration.of(timeoutInSeconds, ChronoUnit.SECONDS))
                                         .build();
        System.out.printf("Sending POST request to %s, timeout: %ds%n", uri, timeoutInSeconds);
        try {
            HttpResponse response = client.send(request, BodyHandlers.ofString());
            System.out.println("Response received...");
            System.out.printf("\tResponse-Status: %d%n", response.statusCode());
            System.out.printf("\tResponse-Body: %s%n", response.body());
            System.out.println("-------------------------------------%n");

        } catch (IOException e) {
            System.err.printf("IOException caught: %s%n", e.getMessage());
            e.printStackTrace(System.err);
        } catch (InterruptedException e) {
            System.err.printf("IOException caught: %s%n", e.getMessage());
            e.printStackTrace(System.err);
        }
    }
}

Spring Boot Kafka Increase Message Size Limit

Thu, 09 Jun 2022 00:00:00 +0200

Let’s say we would like to increase the limit t 10MB …

Broker Configuration

Apply the new limit either by modifying the server.properties like this…

max.message.bytes=10485760

or apply it to a specific topic using

kafka-configs.sh --bootstrap-server localhost:9092 \
    --entity-type topics  \
    --entity-name thetopic \
    --alter \
    --add-config max.message.bytes=10485760

Producer Configuration for Spring Boot

We simply need to add the following line to our application.properties:

spring.kafka.producer.properties.max.request.size=spring.kafka.producer.properties.max.request.size

The following proof-of-concept demonstrates that without the property, sending a large message fails, with the property it succeeds:

Embedded Kafka for Spring Boot Testing without using Docker

Wed, 25 May 2022 00:00:00 +0200

Sometimes it is nice to set up an embedded Kafka broker for testing without the need to have Docker installed (e.g. for using testcontainers-lib).

The following snippet shows, how to set up an embedded Kafka instance for testing for a Spring Boot project.

Setup

Using Maven, this is our Spring Boot project with dependencies needed:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>(1)
        <version>2.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.hascode.tutorial</groupId>
    <artifactId>kafka-testing</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>17</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <kafka.version>3.1.0</kafka.version>(2)
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>(3)
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>(4)
            <scope>test</scope>
        </dependency>

        <dependency>(5)
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-launcher</artifactId>
            <scope>test</scope>
        </dependency>
        [..]
</project>

Java Bean Mapping with MapStruct

Thu, 31 Mar 2022 00:00:00 +0200

MapStruct is a nice tool to generate mappers for converting one Java bean into another e.g. for projections, data-transfer-objects and so on …

As long as fields in source and target beans do match, the mapper is able to generate the data setting automatically .. else we may specify which source fields to map into which target fields or to register custom converters with ease.

Using Maven, we need to add dependencies and plugin integration to our pom.xml:

Configuring Spring Boot WebserviceTemplate to sign WSS SOAP Requests

Wed, 30 Mar 2022 00:00:00 +0200

Sometimes when accessing SOAP APIs, our SOAP client needs to sign the request. How this can be achieved using Spring Boot’s WebserviceTemplate within a few steps is the scope of this short article.

This snippet only deals with the client side not with the security configuration on the server side.

Also it assumes, that you have already set up your keystore/truststore and that you’re loading these with your Spring Boot application’s startup without errors.

Converting XML Schema (XSD) to Protocol Buffers (Protobuf)

Wed, 02 Feb 2022 00:00:00 +0100

Sometimes one needs to derive a Google Protocol Buffers schema from an XML schema .. e.g. from an Enterprise Architect Export.

Tool used here: schema2proto (GitLab project)

Steps

Download schema2proto-lib from the global Maven repository: https://search.maven.org/search?q=schema2proto
Run Schema2Proto against a give XSD schema file and with a given output directory:

java -jar schema2proto-lib-1.53.jar Schema2Proto --outputDirectory=src/main/protobuf input.xsd

A yaml config file may be given instead of cli parameters:

java -jar schema2proto-lib-1.53.jar Schema2Proto ----configFile=config.yaml input.xsd

Kafka Java Quickstart with Docker

Sat, 29 Jan 2022 00:00:00 +0100

Goals

Setup Kafka and Zookeeper with Docker and docker-compose
Create a message consumer and producer in Java

Kafka Setup

We’re using docker-compose to set up our message broker, zookeper and other stuff using confluent-platform.

This is our docker-compose.yaml config file from Confluent’s following GitHub repository.

docker-compose.yaml

---
version: '2'
services:
  zookeeper:
    image: confluentinc/cp-zookeeper:7.0.1
    hostname: zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

  broker:
    image: confluentinc/cp-kafka:7.0.1
    hostname: broker
    container_name: broker
    depends_on:
      - zookeeper
    ports:
      - "29092:29092"
      - "9092:9092"
      - "9101:9101"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://broker:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_JMX_PORT: 9101
      KAFKA_JMX_HOSTNAME: localhost

  schema-registry:
    image: confluentinc/cp-schema-registry:7.0.1
    hostname: schema-registry
    container_name: schema-registry
    depends_on:
      - broker
    ports:
      - "8081:8081"
    environment:
      SCHEMA_REGISTRY_HOST_NAME: schema-registry
      SCHEMA_REGISTRY_KAFKASTORE_BOOTSTRAP_SERVERS: 'broker:29092'
      SCHEMA_REGISTRY_LISTENERS: http://0.0.0.0:8081

  connect:
    image: cnfldemos/kafka-connect-datagen:0.5.0-6.2.0
    hostname: connect
    container_name: connect
    depends_on:
      - broker
      - schema-registry
    ports:
      - "8083:8083"
    environment:
      CONNECT_BOOTSTRAP_SERVERS: 'broker:29092'
      CONNECT_REST_ADVERTISED_HOST_NAME: connect
      CONNECT_GROUP_ID: compose-connect-group
      CONNECT_CONFIG_STORAGE_TOPIC: docker-connect-configs
      CONNECT_CONFIG_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_OFFSET_FLUSH_INTERVAL_MS: 10000
      CONNECT_OFFSET_STORAGE_TOPIC: docker-connect-offsets
      CONNECT_OFFSET_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_STATUS_STORAGE_TOPIC: docker-connect-status
      CONNECT_STATUS_STORAGE_REPLICATION_FACTOR: 1
      CONNECT_KEY_CONVERTER: org.apache.kafka.connect.storage.StringConverter
      CONNECT_VALUE_CONVERTER: io.confluent.connect.avro.AvroConverter
      CONNECT_VALUE_CONVERTER_SCHEMA_REGISTRY_URL: http://schema-registry:8081
      CONNECT_PLUGIN_PATH: "/usr/share/java,/usr/share/confluent-hub-components"
      CONNECT_LOG4J_LOGGERS: org.apache.zookeeper=ERROR,org.I0Itec.zkclient=ERROR,org.reflections=ERROR

  ksqldb-server:
    image: confluentinc/cp-ksqldb-server:7.0.1
    hostname: ksqldb-server
    container_name: ksqldb-server
    depends_on:
      - broker
      - connect
    ports:
      - "8088:8088"
    environment:
      KSQL_CONFIG_DIR: "/etc/ksql"
      KSQL_BOOTSTRAP_SERVERS: "broker:29092"
      KSQL_HOST_NAME: ksqldb-server
      KSQL_LISTENERS: "http://0.0.0.0:8088"
      KSQL_CACHE_MAX_BYTES_BUFFERING: 0
      KSQL_KSQL_SCHEMA_REGISTRY_URL: "http://schema-registry:8081"
      KSQL_PRODUCER_INTERCEPTOR_CLASSES: "io.confluent.monitoring.clients.interceptor.MonitoringProducerInterceptor"
      KSQL_CONSUMER_INTERCEPTOR_CLASSES: "io.confluent.monitoring.clients.interceptor.MonitoringConsumerInterceptor"
      KSQL_KSQL_CONNECT_URL: "http://connect:8083"
      KSQL_KSQL_LOGGING_PROCESSING_TOPIC_REPLICATION_FACTOR: 1
      KSQL_KSQL_LOGGING_PROCESSING_TOPIC_AUTO_CREATE: 'true'
      KSQL_KSQL_LOGGING_PROCESSING_STREAM_AUTO_CREATE: 'true'

  ksqldb-cli:
    image: confluentinc/cp-ksqldb-cli:7.0.1
    container_name: ksqldb-cli
    depends_on:
      - broker
      - connect
      - ksqldb-server
    entrypoint: /bin/sh
    tty: true

  ksql-datagen:
    image: confluentinc/ksqldb-examples:7.0.1
    hostname: ksql-datagen
    container_name: ksql-datagen
    depends_on:
      - ksqldb-server
      - broker
      - schema-registry
      - connect
    command: "bash -c 'echo Waiting for Kafka to be ready... && \
                       cub kafka-ready -b broker:29092 1 40 && \
                       echo Waiting for Confluent Schema Registry to be ready... && \
                       cub sr-ready schema-registry 8081 40 && \
                       echo Waiting a few seconds for topic creation to finish... && \
                       sleep 11 && \
                       tail -f /dev/null'"
    environment:
      KSQL_CONFIG_DIR: "/etc/ksql"
      STREAMS_BOOTSTRAP_SERVERS: broker:29092
      STREAMS_SCHEMA_REGISTRY_HOST: schema-registry
      STREAMS_SCHEMA_REGISTRY_PORT: 8081

  rest-proxy:
    image: confluentinc/cp-kafka-rest:7.0.1
    depends_on:
      - broker
      - schema-registry
    ports:
      - 8082:8082
    hostname: rest-proxy
    container_name: rest-proxy
    environment:
      KAFKA_REST_HOST_NAME: rest-proxy
      KAFKA_REST_BOOTSTRAP_SERVERS: 'broker:29092'
      KAFKA_REST_LISTENERS: "http://0.0.0.0:8082"
      KAFKA_REST_SCHEMA_REGISTRY_URL: 'http://schema-registry:8081'

Logback and Spring Boot - Change Log Level to custom format

Thu, 19 Aug 2021 00:00:00 +0200

Create a custom converter

This class converts the well known log levels to a custom format

CustomLogLevelConverter.java

package com.hascode;

public class CustomLogLevelConverter extends ClassicConverter {
    @Override
    public String convert(ILoggingEvent event) {
        switch (event.getLevel().toInt()) {
            case Level.ERROR_INT:
                return "ERROR!!!";
            case Level.WARN_INT:
                return "WARN!!";
            case Level.INFO_INT:
                return "INFO!";
            case Level.TRACE_INT:
                return "DEBUG";
            default:
                return event.getLevel().toString();
        }
    }
}

Register the converter

The following Logback config includes some defaults and registers our custom converter.

GitHub Release Pipeline for Java

Fri, 14 May 2021 00:00:00 +0200

Goals

Set up Maven build pipeline for a Java 11 app
Release Maven artifact on GitHub using GitHub actions

Setup Maven

Assuming that we have a project named sample-app released for my hascode GitHub account:

We’re adding some release information to our project’s pom.xml:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hascode</groupId>
  <artifactId>sample-app</artifactId>
  <version>1.0.0-SNAPSHOT</version>bookmark-manager
  <name>sample-app</name>
  <description>hasCode.com Bookmark Manager</description>


  <scm>
    <developerConnection>scm:git:https://github.com/hascode/sample-app.git
    </developerConnection>
  </scm>


  <distributionManagement>
    <repository>
      <id>github</id>
      <name>GitHub</name>
      <url>https://maven.pkg.github.com/hascode/sample-app</url>
    </repository>
  </distributionManagement>


  <properties>
    <java.version>11</java.version>
    <project.scm.id>github</project.scm.id>
  </properties>

  [..]
</project>

JUnit5 Java Maven Snippet

Fri, 14 May 2021 00:00:00 +0200

Goals

Use JUnit Maven BOM for version alignment
Add minimal dependencies for JUnit5 Java Projekt

Setup

Excerpt from the Maven project’s pom.xml:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.junit</groupId>
      <artifactId>junit-bom</artifactId>
      <version>5.7.1</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

JUnit5 does not work with older versions of the Maven Compiler Plugin and the Surefire Plugin used for test execution. Setting their versions in the pom.xml is done like this:

Package a Spring Boot App as RPM

Fri, 14 May 2021 00:00:00 +0200

Goals

Package a Spring Boot Service as RPM Package
Configure systemd integration
Add install/uninstall hooks to create users, directories etc.

Maven Setup

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.2</version>
    <relativePath/>
  </parent>
  <groupId>com.hascode</groupId>
  <artifactId>sample-app</artifactId>
  <version>1.0.0-SNAPSHOT</version>
  <name>sample-app</name>

  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin> (1)
        <groupId>de.dentrassi.maven</groupId>
        <artifactId>rpm</artifactId>
        <version>1.5.0</version>
        <executions>
          <execution>
            <goals>
              <goal>rpm</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <packageName>sample-app</packageName>
          <skipSigning>true</skipSigning>
          <group>Application/Misc</group>
          <requires>
            <require>java-11-openjdk-headless</require> (2)
          </requires>
          <entries>
            <entry> (3)
              <name>/opt/sample-app</name>
              <directory>true</directory>
              <user>root</user>
              <group>root</group>
              <mode>0755</mode>
            </entry>
            <entry> (4)
              <name>/opt/sample-app/log</name>
              <directory>true</directory>
              <user>sample-app</user>
              <group>sample-app</group>
              <mode>0750</mode>
            </entry>
            <entry> (5)
              <name>/opt/sample-app/sample-app.jar</name>
              <file>${project.build.directory}/${project.build.finalName}.jar</file>
              <user>root</user>
              <group>root</group>
              <mode>0644</mode>
            </entry>
            <entry> (6)
              <name>/usr/lib/systemd/system/sample-app.service</name>
              <file>${project.basedir}/src/main/dist/sample-app.service</file>
              <mode>0644</mode>
            </entry>
          </entries>
          <beforeInstallation> (7)
            <file>${project.basedir}/src/main/dist/preinstall.sh</file>
          </beforeInstallation>
          <afterInstallation>
            <file>${project.basedir}/src/main/dist/postinstall.sh</file>
          </afterInstallation>
          <beforeRemoval>
            <file>${project.basedir}/src/main/dist/preuninstall.sh</file>
          </beforeRemoval>
          <license>All rights reserved</license>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

Implementing Reactive Client-Server Communication over TCP or Websockets with RSocket and Java

Sun, 25 Nov 2018 00:00:00 +0100

Reactive design or reactive architecture has an impact on how modern software systems are implemented. RSocket is a project that aims to adapt the benefits of the patterns described in the Reactive Manifesto and resulting tools like Reactive Streams or Reactive Extensions to a formal new communication protocol.

RSocket works with TCP, WebSockets and Aeron transport layers and offers additional features like session resumption.

In the following tutorial I’m going to demonstrate how to implement simple client-server communication over TCP and Websockets for different interaction models like request-response, request-stream, fire-and-forget and event subscription.

Capacity Planning using the Universal Scalability Law with Java and usl4j

Sun, 30 Sep 2018 00:00:00 +0200

Capacity planning is an important task when trying to anticipate resources and scaling factors for our applications.

The usl4j library offers us an easy abstraction for Neil J. Gunther’s Universal Scalability Law and allows us to build up a predictive model based on the parameters throughput, latency and concurrent operations.

With a basic input set of two of these parameters, we are able to predict how these values change if we change one input parameter so that we can build our infrastructure or systems according to our SLAs.

Testing Java Applications for Resilience by Simulating Network Problems with Toxiproxy, JUnit and the Docker Maven Plugin

Sun, 29 Jul 2018 00:00:00 +0200

When implementing distributed systems, client-server architectures and simple applications with network related functionalities, everything is fine when we’re in the development or in the testing stage because the network is reliable and the communicating systems are not as stressed as they are in production.

But to sleep well we want to validate how resilient we have implemented our systems, how they behave when the network fails, the latency rises, the bandwidth is limited, connections time out and so on.

Using jetstreamDB as in-memory Database for Java

Sat, 30 Jun 2018 00:00:00 +0200

JetstreamDB is a in-memory database engine for Java that claims to be built for ultra-high speed and the ability of managing complex data structures by storing real Java objects instead of serializing data structures to other database specific formats.

In the following short example I would like to demonstrate how to create and read items from such a database by building a small article management sample app.

Analyzing Java Problems – Tools, Snippets and Workflows

Mon, 30 Apr 2018 00:00:00 +0200

When we need to investigate the cause for a dysfunctional Java application we have a plethora of tools available that on the one hand help us in gathering information, artifacts and statistics and on the other hand help us in processing this information and identifying possible problems.

The following list of tools, snippets, workflows and information about specific artifacts could provide a starting point for analyzing such problems and covers topics like heap-dumps, thread-dumps, heap-histograms, heap-regions, garbage-collection-logs, hotspot-compiler/codecache-logs, debugging native-memory, tools for heap-dump-analysis, JVM unified logging and more..

Setting up Kafka Brokers for Testing with Kafka-Unit

Wed, 28 Mar 2018 00:00:00 +0200

When writing test for applications that interact with Kafka brokers we often need to setup a decent environment including an instance of Kafka and ZooKeeper.

Though Kafka ships with some classes for testing, setting up a simple testing environment is quite easier with the kafka-unit library that offers JUnit test rule support or a fast programmatic setup within no time.

In the following short example, I’d like to show how create a simple setup using Maven, Surefire and kafka-unit.

Implementing, Testing and Running Procedures for Neo4j

Tue, 27 Feb 2018 00:00:00 +0100

A lot of features are already included in the Neo4j graph database system but sometimes we want to extends its capabilities and implement functions and procedures by ourselves that we may reuse.

In the following tutorial I will demonstrate how to implement a procedure for Neo4j, how to write and run tests using JUnit and an embedded graph database and last but not least how to setup Neo4j with Docker and our stored procedure installed in no time.

Software Architecture Exploration and Validation with jqAssistant, Neo4j and Cypher

Sun, 31 Dec 2017 00:00:00 +0100

I have written about other software system analyzing and validation tools before but today I would like to introduce a new tool named jqAssistant that supports software architects, developers and analysts in a variety of tasks like analyzing given structures, validating architectural or quality constraints and generating reports.

Therefore jqAssistant analyzes given projects or artifacts and stores the gathered information – that is enriched by a variety of existing plugin-ins – in a Neo4j graph database.

Identity Management, One-Time-Passwords and Two-Factor-Auth with Spring Boot and Keycloak

Sun, 26 Nov 2017 00:00:00 +0100

Communicating with identity and access management systems is a common task for many web-applications exposing secured resources.

Keycloak is an open source software that provides not also such authorization services but also offers a lot of features from Single-Sign-On, Identity-Brokering, Social-Login, User-Federation, multiple client-adapters up to the administration console or support for protocols like OpenID, SAML, OAuth2, Kerberos and more.

I will demonstrate how to integrate a Spring Boot web application with Keycloak and configure an authentication flow that requires a two-factor-authentication with user credentials and also one-time-passwords.

Snippet: Java Mission Control (JMC) and Flight Recorder (JFR)

Wed, 11 Oct 2017 00:00:00 +0200

The Java Mission Control and the Java Flight Recorder allow us to capture run-time information from our Java applications without much overhead and aggregate profiling information.

I have written down the commands that I’m using the most when profiling a Java application with this tool chain in the following article.

Figure 1. Java Mission Control - Report

Running Java Mission Control (JMC)

We may start the JMC user interface shown above using the jmc command that is shipped with Oracle’s JRockit or Java (since Java 7 update 40).

Detecting Vulnerable Dependencies with Maven and the OWASP Dependency Check Plugin

Tue, 03 Oct 2017 00:00:00 +0200

On the one hand adding dependencies to a project is easy, on the other hand securing a project and checking for vulnerable dependencies is way harder.

The OWASP dependency check plugin for Maven allows us to scan our project’s dependencies for know vulnerabilities.

I will demonstrate its usage in the following short example.

Figure 1. OWASP Vulnerability Report

Dependencies

We just need to add one plugin-dependency to our Mavenized project’s pom.xml.

Microbenchmarks with JMH / Java Microbenchmark Harness

Mon, 02 Oct 2017 00:00:00 +0200

Writing microbenchmarks for parts of our applications is not always easy – especially when the internals of the virtual machine, the just-in-time-compiler and such things are coming into effect.

Java Microbenchmark Harness is a tool that takes care of creating JVM warmup-cycles, handling benchmark-input-parameters and running benchmarks as isolated processes etc.

Now following a few short examples for writing microbenchmarks with JMH.

Figure 1. Java JMH Microbenchmarks running in IntelliJ

Downloading Maven Artifacts from a POM file programmatically with Eclipse Aether

Fri, 08 Sep 2017 00:00:00 +0200

Sometimes I need to resolve Maven dependencies programmatically. Eclipse Aether is a library for working with artifact repositories and I’ll be using it in the following example to read dependency trees from a given POM descriptor file and download each dependency from a remote Maven repository to a local directory.

Figure 1. Using Eclipse Aether.

Dependencies

We’re adding a bunch of dependencies to our project’s pom.xml:

<properties>
    <aetherVersion>1.1.0</aetherVersion>
    <mavenVersion>3.2.1</mavenVersion>
</properties>

Using JUnit 5 Parameterized Tests, Argument Sources and Converters

Sat, 19 Aug 2017 00:00:00 +0200

With JUnit 5 the possibilities to write parameterized tests have changed and improved a lot.

The following short overview covers all new types of possible parameter sources for JUnit 5 tests as well as the new conversion API for test arguments.

In addition we’re showing how parameterized tests were written in JUnit 4.

Figure 1. Running JUnit5 in IntelliJ

About

We will be covering all available types of parameter sources in the following sections – all that you need as a prerequisite is Java ™, Maven and a few minutes of your time.

Assuring Architectural Rules with ArchUnit

Mon, 03 Jul 2017 00:00:00 +0200

Maintaining architecture rules and constraints for a specific software project or an application is not easy as textual documentation is easily forgotten after a while and hard to verify.

ArchUnit is a testing library that allows developers and software architects to write down such rules as executable tests that may be run by the development teams and the integration servers.

In the following article I will demonstrate the basic features of this library by applying rules and constraints to an existing application.

Template Driven Test POJO Generation with Fixture Factory and Java

Tue, 20 Jun 2017 00:00:00 +0200

In our tests we often need to create a bunch of test-objects that are populated with random-data. This data needs to follow specific rules as identifiers need to be unique or must be incremented, string-properties must follow special conventions and so on. In the following short tutorial I will demonstrate how to generate such test data using the Fixture Factory library.

Figure 1. Fixture Factory and JUnit

Distributed Authorization and Contextual Caveats for Java with Macaroons and jmacaroons

Wed, 31 May 2017 00:00:00 +0200

Google’s Macaroons are a mechanism to establish distributed authorization. The distinction to the classical bearer-token is their ability that they may be used to perform an action under certain restrictions and may then be used to create a new macaroon with stricter restrictions.

The following short tutorial demonstrates how to create macaroons, serialize and deserialize them, add first- and third-party caveats and finally to verify them.

Figure 1. jmacaroons example

Snippet: Java 9 Modules and JPMS

Mon, 17 Apr 2017 00:00:00 +0200

Playing around with the new module system in Java 9 I simply wanted to write down how to achieve the most basic tasks.

Therefore I created the following module how-to based upon a simple demonstration project consisting of two dependant modules.

Figure 1. Modules Component-Diagram

Prerequisites and Setup

We need an early access build of the Java ™ 9 JDK, available for download here.

In addition we should make sure, that our environment variable JAVA_HOME is set to the corresponding directory and calling java -version returns something similar to this:

Writing BDD-Style Webservice Tests with Karate and Java

Thu, 06 Apr 2017 00:00:00 +0200

There is a new testing framework out there called Karate that is build on top of the popular Cucumber framework.

Karate makes it easy to script interactions with out web-services under test and verify the results. In addition it offers us a lot of useful features like parallelization, script/feature re-use, data-tables, JsonPath and XPath support, gherkin syntax, switchable staging-configurations and many others.

In the following tutorial we’ll be writing different scenarios and features for a real-world RESTful web-service to demonstrate some of its features.

Snippet: Integrating the Drools Business Rules Management System in 5 Minutes

Thu, 30 Mar 2017 00:00:00 +0200

Drools is a slim Business Rules Management System (BRMS) solution with different integrations and tools available.

In the following short snippet I’d like to demonstrate how to integrate a simple rule engine into an application using this library.

Figure 1. Drools Example running in Eclipse IDE

Dependencies

Using Gradle here we only need to add one dependency for drools-compiler to our project’s build.gradle. In addition, we’re adding a task to execute our application.

Resilient Architecture in Practice – Circuit Breakers for Java: Failsafe, Javaslang, Hystrix and Vert.x

Tue, 14 Feb 2017 00:00:00 +0100

When dealing with remote services or APIs there is always the risk of latency issues, failures or connection losses. The worst thing to happen is when the remote service is down and our application hangs until the underlying protocol’s (e.g. TCP) connection timeout is reached and we’re receiving an exception. Until this moment is reached, our application might hang, memory is allocated for threads or bound objects and at last, our continuous requests might prevent the remote system from recovering.

Transforming JSON Structures with Java and JOLT

Sun, 29 Jan 2017 00:00:00 +0100

When it comes to web-services (especially RESTful web-services), configuration files or other data-descriptors, the JavaScript Object Notation, short: JSON is often used as format of choice.

As the task arises to transform these JSON structures, I have seen a variety of different approaches from converting JSON into XML using JAX-B, applying XSLT, transforming into JSON again on the one hand to loading JSON structures into Hash-maps of Hash-maps (..) and manually removing single elements from these collections on the other hand.

Handling System Properties, Environment Variables, STDOUT/STDERR in JUnit Tests with System Rules

Mon, 19 Dec 2016 00:00:00 +0100

When important data is written to STDIN/STDOUT and an application relies on specific system properties or environment variables, writing tests is getting more complicated.

System Rules is a collection of JUnit rules that helps us writing Java tests for everything that deals with java.lang.System.

In the following short examples I’d like to demonstrate how to deal with system properties, environment variables, STDOUT and STDERR and capturing both for testing e.g. for some golden master refactoring.

Creating Microservices with Bootique

Sun, 18 Sep 2016 00:00:00 +0200

When it comes to writing microservices in Java, plenty of tools and frameworks exist. In the following tutorial, I’d like to demonstrate another minimalistic framework called Bootique by implementing a simple microservice exposing its functions either as a RESTful web-service or as a runnable command executed using the command line.

Bootique Command Line

Dependencies

Using Maven here, we’re adding the following elements to our project’s pom.xml:

Bootiques Bill of Materials as dependency management: bootique-bom
Bootique Jersey for our REST service: bootique-jersey
Bootique Logback for logging: bootique-logback
Maven Shade Plugin to assemble our fat-jar

Elasticsearch Integration Testing with Java

Tue, 23 Aug 2016 00:00:00 +0200

When building up search engines, indexing tons of data into a schema-less, distributed data store, Elasticsearch has always been a favourite tool of mine.

In addition to its core features, it also offers tools and documentation for us developers when we need to write integration tests for our Elasticsearch powered Java applications.

In the following tutorial I’d like to demonstrate how to implement a small sample application using Elasticsearch under the hood and how to write integration-tests with these tools for this application afterwards.

Object Graph Mapping by Example with Neo4j OGM and Java

Mon, 18 Jul 2016 00:00:00 +0200

When integrating a Neo4j database into a Java application a developer often needs to map nodes and edges of the graph to corresponding Java classes of the domain model.

Neo4j OGM eases this work and allows us to map our domain objects to the graph database using simple annotations – similar to the Java Persistence API (JPA) for relational database management systems.

In the following tutorial I’d like to demonstrate how to use Neo4j OGM to build a simple train timetable planner and a permission system mapping between graph, nodes, edges and POJOs.

LDAP Testing with Java: ApacheDS vs Embedded-LDAP-JUnit

Mon, 04 Jul 2016 00:00:00 +0200

When writing applications that interchange information with LDAP directory services there is always the need to write integration tests for these components and services.

Therefore we need a the possibility to start-up an embedded LDAP server, fill it with test-data and control its life-cycle during the test-phases.

In the following tutorial I’d like to demonstrate two candidates that fulfil this purpose, the ApacheDS test integrations and a small library named embedded-ldap-junit.

Continuous Delivery with GitHub Cloud and GitHub Pipelines

Fri, 01 Jul 2016 00:00:00 +0200

Atlassian has added a continuous integration service as a new feature to their GitHub Cloud product. It’s called GitHub Pipelines and it is similar to Travis CI for GitHub offering a nice integration for continuous integration/delivery pipelines for projects hosted on GitHub.

It’s still in the beta phase and requires a sign-up but nevertheless I’d like to demonstrate the current state of this service and how easy it is to add scripted pipelines to a project.

Layout Testing with Galen, JUnit and Maven

Mon, 16 May 2016 00:00:00 +0200

Writing tests not only to verify the behaviour of a web site but also the correctness of its layout especially for responsive websites is not always easy.

Luckily the Galen Framework eases the task of writing layout tests for us, offering a specialized domain-specific-language to write layout-specifications, it integrates well with Selenium Grid, Sauce Labs or BrowserStack, it offers an easy way to deal with different browser sizes and responsive designs and it generates nice, detailed test reports.

Load Testing Web Applications with Gatling and Maven

Fri, 06 May 2016 00:00:00 +0200

I have written about other performance testing tools for web applications before. Nevertheless I’d like to demonstrate a library for load testing web applications named Gatling in combination with the build tool Maven.

Gatling offers a nice Scala DSL, high performance using Akka, Netty and asynchronous IO and plug-ins for all modern build tools.

In the following tutorial I’m going to show how to record simulations using an HTTP proxy, rewriting simulations in Scala and running and reporting simulations with Maven.

Dynamic Configuration Management with Netflix Archaius and Apache ZooKeeper, Property-Files, JMX

Wed, 13 Apr 2016 00:00:00 +0200

Though having written about other configuration management libraries for Java before, I would like to demonstrate another one today: Netflix Archaius.

Archaius offers some nice features like dynamic typed properties, thread-safe operations, an event system for property changes/updates, a JMX MBean to read and update properties and adaptors for a variety of dynamic configuration sources like Amazon DynamoDB, JDBC, URLs and Apache ZooKeeper.

In the following tutorial I’d like to demonstrate how to read and update application configuration properties with Archaius and data sources like property-files, system-properties, JMX and Apache ZooKeeper.

Setting up an OAuth2 Authorization Server and Resource Provider with Spring Boot

Sun, 13 Mar 2016 00:00:00 +0100

OAuth2 is a frequently used standard for authorization and with Spring Boot it is easy to set up authorization and resource server in no time.

In the following short tutorial I’d like to demonstrate how to set up an OAuth2 authorization server as well as a connected and secured resource server within a few minutes using Java, Maven and Spring Boot.

Figure 1. OAuth2 Flow with Spring Boot in Action

Generating JUnit Tests with Java, EvoSuite and Maven

Sun, 28 Feb 2016 00:00:00 +0100

Generating test suites for existing code allows us to verify the behaviour of an application before we’re making changes to its code base or for regression testing.

In the following short tutorial I’d like to demonstrate how to derive test suites from an existing Java application using EvoSuite and the EvoSuite Maven plug-in.

EvoSuite offers some nice features like running in a sandbox to avoid dangerous operations, virtual file-system and network and optimizing of different coverage criteria.

Mocking HTTP Interaction with Java, JUnit and MockServer

Tue, 05 Jan 2016 00:00:00 +0100

When writing tests for our software components sometimes we need to mock external services based on the HTTP protocol, might it be a RESTful web-service, an XML-RPC call or a simple GET request to some web-server.

In the following short tutorial I’d like to demonstrate how to create a mock HTTP server for testing and how to bootstrap and bind it to the life-cycle of a classical build-management tool like Maven.

Reactive Programming: Handling Service Timeouts and Retries with Retry4j

Wed, 02 Dec 2015 00:00:00 +0100

The Reactive Manifesto specifies responsive, resilient, elastic and message-driven as attributes for a reactive application.

When implementing specific mechanisms to achieve this requirements, we often need to deal with timeout and retry-operations in our application and depending on our setup and environment, different tools and libraries exist to help us here.

In the following short tutorial I’d like to demonstrate how to handle exceptions and operation retries on service boundaries with a lesser know, slim library named Retry4j.

Unix-like data pipelines with Java 8 Streams and UStream

Sun, 08 Nov 2015 00:00:00 +0100

We all love the simplicity when chaining commands and pipes in an Unix derivative environment.

UStream takes this approach and extends Java 8′s stream API to mimic some of the well known commands and apply them on streams.

In the following tutorial, I’d like to share some slim examples for using UStream.

Figure 1. Data pipelines with UStream

Dependencies

We simply need to add one dependency to our pom.xml (using Maven): io.github.benas:ustream:0.2

Creating REST Clients for JAX-RS based Webservices with Netflix Feign

Thu, 22 Oct 2015 00:00:00 +0200

For us developers there plenty of libraries exist helping us in deriving and generating clients for existing RESTful web-services and I have already covered some of the in this blog (e.g. the JAX-RS Client API). Nevertheless, I’d like to share my experience with another interesting lightweight library here: Netflix Feign.

Feign offers a nice fluent-builder API, a rich integration for common libraries and APIs like JAX-RS, Jackson, GSON, SAX, JAX-B, OkHttp, Ribbon, Hystrix, SLF4J and more and last bot not least, it is setup easy and the service contracts are specified using interfaces and annotations.

Using Deferred Objects and Promises with Java 8 and JDeferred

Sun, 27 Sep 2015 00:00:00 +0200

Promises may help us when dealing with asynchronous code and we need to merge, pipe or track the progress and the results of single parts of computation in our applications.

In the following tutorial I’d like to demonstrate a small library, JDeferred that helps us for this specific use case.

Figure 1. JDeferred examples running in Eclipse IDE.

Dependencies

Using Maven here, we simply need to add one dependency for jdeferred-core to our pom.xml:

Testing Asynchronous Applications with Java and Awaitility

Sun, 23 Aug 2015 00:00:00 +0200

Writing tests for asynchronous applications has never been much fun as we’re always struggling with the problem how to determine state changes, handle process terminations, dealing with timeouts or failures and stuff like this.

Awaitility eases this process for us offering a nice DSL, rich support for languages like Scala or Groovy and an easy-to-use syntax that’s even more fun when using it with Java 8′s lambda expressions.

In the following short introduction I’d like to demonstrate writing some tests different scenarios.

Snippet: Creating secure Password Hashes in Java with Heimdall

Sun, 12 Jul 2015 00:00:00 +0200

These days where a cheap GPU for about 100 € is capable to create 3 billion of MD5 Hashes per second, we need not only need to use salts the right way but we also need to choose a strong, non-reversible and slow hashing schemes when storing passwords in our application.

Heimdall is a library that implements a secure and upgradable password hashing mechanism and uses at the time of writing this article PBKDF2 SHA-1 HMAC with 20000 iterations and a 192 bit (24 byte) salt per default.

Integrating Swagger into a Spring Boot RESTful Webservice with Springfox

Wed, 01 Jul 2015 00:00:00 +0200

Spring Boot allows us to create RESTful web-services with ease, Swagger specifies a format to describe the capabilities and operations of these services and with Swagger UI it is possible to explore our REST API with a nice graphical user interface in our browser.

Springfox is a project that aims at creating automated JSON API documentation for API’s built with Spring and is used in the following tutorial to integrate Swagger into a sample application.

Documenting RESTful Webservices in Swagger, AsciiDoc and Plain Text with Maven and the JAX-RS Analyzer

Tue, 16 Jun 2015 00:00:00 +0200

A variety of different tools exists to help us analyze RESTful web-services and create documentations for their APIs in different formats.

In the following tutorial I’d like to demonstrate how to document an existing JAX-RS web-service in multiple formats like Swagger, AsciiDoc or Plain Text using Maven, the JAX-RS Analyzer and the JAX-RS Analyzer Maven Plugin.

The JAX-RS Analyzer gathers its information not only by reflection like most other tools but also by bytecode analysis and therefore does not require us to add special annotations for documentation to our code.

Mutation Testing with Pitest and Maven

Sun, 10 May 2015 00:00:00 +0200

Mutation testing makes an interesting addition to the classical test coverage metrics.

They seed mutations (errors) into the code, run the project’s tests afterwards and if the tests fail, the mutation is killed – otherwise it lived and we have a possible indication of an issue with our tests.

In the following short tutorial. I’d like to demonstrate how to setup mutation tests with the PIT/Pitest library and Maven and generate reports.

Immutables 2.0 for sexy Immutable Object Creation and more

Sun, 26 Apr 2015 00:00:00 +0200

Using immutable objects in Java (and other programming languages as well) is a good thing because immutable objects may be shared safely, are thread-safe and reduce the risk of side effects in your applications.

Nowadays multiple frameworks exist to reduce the need of writing boilerplate code here but there is one special framework whose features I’d like to demonstrate in the following short tutorial.

It hooks into your application using annotation processing and generates type-safe builders, toString, hashCode, equals methods for you, supports lazy attributes, singleton instances, serialization into data-formats like JSON and a lot of other features,too.

Creating In-Memory File Systems with Google’s Jimfs

Wed, 18 Mar 2015 00:00:00 +0100

Sometimes when writing an application we might consider using an in-memory file system to speed up data access or to create some kind of cache.

There are different libraries to help us here but one looks especially promising for me because it supports almost every functionality of the Java NIO File APIs added in Java 7 – from creating, reading, deleting files and directory to handling symbolic and hard links or watching directory changes with a WatchService.

Generating Java Source Files with JavaPoet

Sat, 28 Feb 2015 00:00:00 +0100

For the most of us developers, generating Java source files is an occasionally happening task and we’re dealing with it e.g. when writing annotation processors, writing tools or interacting with meta-data files.

JavaPoet is a nice library to simplify such tasks, offering an intuitive fluent-builder API to generate source files in no time.

In the following tutorial I’d like to share a few examples by writing code generators with the help of this library.

A short Overview of Neo4j Indexing Strategies

Sun, 25 Jan 2015 00:00:00 +0100

When it comes to indexing in a Neo4j graph database, different options exist for a developer to create and maintain the index.

In the following short examples I’d like to demonstrate different possibilities for index management.

Figure 1. Simple Domain Model

Dependencies

Only one dependency is needed to run the following examples and start an embedded neo4j server – I’m using Gradle here to manage my dependencies but Maven, Ivy, SBT should work without a problem, too.

Performance Testing a Multiuser Web Application with JMeter and Maven

Sun, 18 Jan 2015 00:00:00 +0100

When there is the need to create load tests or performance tests for an application, Apache JMeter is a handy tool and set up with ease.

In the following short tutorial I’d like to demonstrate how to configure JMeter to log into a Java EE web application with multiple users specified in a CSV file, how to generate some basic reports and how to integrate JMeter into a mavenized build using the JMeter Maven Plugin.

Marrying Java EE and BDD with Cucumber, Arquillian and Cukespace

Wed, 07 Jan 2015 00:00:00 +0100

Having written about the basics of using Cucumber in a Java project in my last blog article, I now would like to demonstrate how to use a similar setup in a Java EE web project with Arquillian and the Cukespace library.

In the following tutorial, we’re going to write a full Java EE web application and add BDD-style tests to the project so that we’re able to test our business layer on the one hand and the user interface on the other hand using Arquillian Drone and Selenium.

BDD Testing with Cucumber, Java and JUnit

Sun, 28 Dec 2014 00:00:00 +0100

Whether behaviour-driven-development, specification by example or acceptance test driven development is the goal, the Cucumber framework eases our life when we need to establish a link between the non-technical, textual description for a new feature and the tests that prove that the application fulfils these requirements.

In the following short tutorial I’d like to demonstrate how to add Cucumber to a Java project and how to write feature descriptions and test-cases for each step of these descriptions.

Java EE: Setting up and Testing Form-Based JDBC Authentication with Arquillian and Maven

Sun, 21 Dec 2014 00:00:00 +0100

Especially when it comes to testing, setting up a decent environment for a secured Java EE web application isn’t always an easy thing to do.

In the following tutorial I’d like to demonstrate how to create a secured web application using form-based authentication and a JDBC realm to fetch users and roles and how to run the application in an embedded container for testing and development.

Additionally I’d like to show how to write and run integration tests to verify the security setup using a setup of Maven, Embedded GlassFish, Arquillian, jUnit and rest-assured.

Creating different Websocket Chat Clients in Java

Sun, 09 Nov 2014 00:00:00 +0100

Having written two articles about different websocket based chat server implementations in Java, I was recently asked how an implementation of the client side would look like in Java.

That’s why I added this article to demonstrate how to create a websocket chat client applications within a few steps with the Java API for Websocket.

In the following tutorial, we’re going to write a text-based chat client for the console first and afterwards we’re going to program a chat client with a graphical user interface, implemented in JavaFX.

Creating a XMPP Chat Bot with Apache Camel

Sun, 12 Oct 2014 00:00:00 +0200

Apache Camel not only is one of my favourite frameworks ever but it also allows the humble developer to create a full blown chat bot within a few lines of code and using the Camel XMPP component.

In the following tutorial, we’re going to create a simple chat bot and since Atlassian’s HipChat basic plan is now free for unlimited users, we’re using HipChat as our play- and testing ground for the bot.

Snippet: Modifying Excel Files, Adding Formulas with Apache POI

Mon, 29 Sep 2014 00:00:00 +0200

Recently I needed to modify some excel files and to add some aggregated formula fields to a sheet and the following snippet did the work for me.

Figure 1. Modified Excel File with Formulas

Dependencies

Just two dependencies needed here: One for Apache POI and one for the Office Open XML Documents API.

<dependency>
	<groupId>org.apache.poi</groupId>
	<artifactId>poi</artifactId>
	<version>3.10.1</version>
</dependency>
<dependency>
	<groupId>org.apache.poi</groupId>
	<artifactId>poi-ooxml</artifactId>
	<version>3.10.1</version>
</dependency>

Sample Excel File

Our sample excel file is quite empty just some empty customer information and a chart that is bound to the data grid.

JAX-RS Server API Snippets

Sun, 28 Sep 2014 00:00:00 +0200

Because a lot of my current projects are using JAX-RS in different versions I’d like to write down and share some frequently used snippets for implementing RESTful web-services with the JAX-RS specification here.

Using RegEx in Path Expressions

Sometimes we need to extract multiple parameters from a path expression e.g. in the following example where year, month and day are fragments if the path.

@GET
@Path("/orders/{year:\\d{4}}-{month:\\d{2}}-{day:\\d{2}}")
@Produces(MediaType.TEXT_PLAIN)
public Response getOrders(@PathParam("year") final int year, @PathParam("month") final int month, @PathParam("day") final int day) {
	return Response.ok("Year: " + year + ", month: " + month + ", day: " + day).build();
}

Java EE 7 JMX Reports with Yammer Metrics

Tue, 26 Aug 2014 00:00:00 +0200

There are several ways to aggregate and report application performance indicators in a Java application. One common way here is to use Java Management Extensions (JMX) and MBeans.

The Yammer Metrics Library eases this task for us and simplifies the aggregation of different reports.

In the following tutorial, we’re going to set up a full Java EE 7 web application by the help of Maven archetypes and we’re running the application on WildFly application server that is downloaded and configured completely by the WildFly Maven Plugin.

Java EE 7 Database Migrations with Liquibase and WildFly

Thu, 31 Jul 2014 00:00:00 +0200

I have written about other database migration frameworks before but in this article I’d like to cover the Liquibase framework in combination with WildFly as Java EE 7 compatible application server.

In the following tutorial, we’re going to write a full Java EE 7 book store application with a few steps and with Liquibase on board to create the database structure and insert example data into the database.

Thanks to the WildFly Maven Plug-in we even do not need to download and configure the application server but let Maven and the plug-in do the work for us.

XMLBeam: Snippets and Examples

Tue, 22 Jul 2014 00:00:00 +0200

XMLBeam is an interesting library using an approach of projecting parts of an XML DOM tree into Java using some simple interfaces, annotations and XPath expressions.

In the following article, I’d like to share three experiments of mine with this library for reading, writing XML and parsing a live RSS feed.

RSS Feed Projection Interface

Dependencies

Using Maven, we need to add only one dependency to our pom.xml:

Lucene by Example: Specifying Analyzers on a per-field-basis and writing a custom Analyzer/Tokenizer

Sun, 06 Jul 2014 00:00:00 +0200

Lucene is my favourite search engine library and the more often I use it in my projects the more features or functionality I find that were unknown to me.

Two of those features I’d like to share in the following tutorial is one the one hand the possibility to specify different analyzers on a per-field basis and on the other hand the API to create a simple character based tokenizer and analyzer within a few steps.

Using jOOQ and Build Helper Plugin to Generate Database Metamodels with Maven

Tue, 10 Jun 2014 00:00:00 +0200

When you need to derive meta-models from existing databases and want to create type-safe queries with an elegant, fluent-API, jOOQ definitely is a tool to consider here.

In the following tutorial I’d like to demonstrate how to integrate the jOOQ meta-model generator into a Maven build using the jOOQ Maven Plug-in, the Build Helper Maven Plug-in and Maven profiles to finally create a running application to query an existing RDBMS using such a generated meta-model.

Java EE: Logging User Interaction the Aspect-Oriented Way using Interceptors

Mon, 26 May 2014 00:00:00 +0200

Using dependency injection and aspect-oriented mechanisms like interceptors allow us to separate cross-cutting-concerns in our Java enterprise application, to control global aspects of our application and to avoid boilerplate code.

In the following short tutorial we’re going to create an aspect-oriented logger to protocol the initiating user, class and method called and the parameters passed to the method and finally we’re adding this interceptor to a sample RESTful web-service by adding a simple annotation.

Using Java Config-Builder to assemble your Application Configuration

Tue, 20 May 2014 00:00:00 +0200

There’s a variety of configuration frameworks to use in our Java applications. Java Config Builder is one of them and it offers some nice features that I would like to demonstrate in the following short examples as are:

Loading values from different sources like property-files, environment variables, command-line-arguments or system properties, specifying default values, mapping arbitrary types or collections, merging configurations and using the Java Bean Validation standard aka JSR-303.

Allocating available random Ports in a Maven Build

Wed, 07 May 2014 00:00:00 +0200

Recently in a project I encountered the following problem: The development team used Git with a branch-per-feature-like workflow and the integration server, Bamboo in this case, was configured not only to run the integration-tests for the master-branch but also for every change in a feature branch.

As the team developed a Java EE web application ports like 8080 occasionally were already bound and builds failed.

I knew a plug-in for Jenkins CI I to search for available ports and assign them to a build variable but I wanted to control such information directly within the Maven build life-cycle so I searched and finally found Sonatype’s Port Allocator Plug-in for Maven.

Java Persistence API: Controlling the Second-Level-Cache

Mon, 21 Apr 2014 00:00:00 +0200

Using the Java Persistence API and a decent persistence provider allows us to configure and fine-tune when and how the second level cache is used in our application.

In the following short examples, we’re going to demonstrate those features written as JUnit test cases and running on a H2 in-memory database.

Figure 1. Persistence Unit Configuration

Setup

First of all we need some basic setup to run the following examples .. we need to select a JPA persistence provider and database, create a persistence-unit configuration and an environment to run tests on an in-memory database.

Using Apache Avro with Java and Maven

Sat, 08 Mar 2014 00:00:00 +0100

Apache Avro is a serialization framework similar to Google’s Protocol Buffers or Apache Thrift and offering features like rich data structures, a compact binary format, simple integration with dynamic languages and more.

In the following short five minute tutorial, we’re going to specify a schema to serialize books in a JSON format, we’re using the Avro Maven plugin to generate the stub classes and finally we’re serializing the data into a single file.

Creating elegant, typesafe Queries for JPA, mongoDB Morphia and Lucene using Querydsl

Thu, 13 Feb 2014 00:00:00 +0100

Querydsl is a framework that allows us to create elegant, type-safe queries for a variety of different data-sources like Java Persistence API (JPA) entities, Java Data Objects (JDO), mongoDB with Morphia, SQL, Hibernate Search up to Lucene.

In the following tutorial we’re implementing example queries for different environments – Java Persistence API compared with a JPQL and a criteria API query, mongoDB with Morphia and last but not least for Lucene.

Creating Grammar Parsers in Java and Scala with Parboiled

Sun, 26 Jan 2014 00:00:00 +0100

Parboiled is a modern. lightweight and easy to use library to parse expression grammars in Java or Scala and in my humble opinion it is perfect for use cases where you need something between regular expressions and a complex parser generator like ANTLR.

In the following tutorial we’re going to create a simple grammar to specify a task list and write an implementation of a parser also as unit tests for each grammar rule in Java.

JAX-RS 2.0 REST Client Features by Example

Mon, 30 Dec 2013 00:00:00 +0100

JAX-RS 2.0 aka JSR 339 not also specifies the API to build up a RESTful webservice but also enhances the client side API to ease up the process of writing a client for a REST service.

In the following tutorial we’re building up a client for a ready-to-play REST service and explore the different new options e.g. how to handle requests in a synchronous or asynchronous way, how to add callback handlers for a request, how to specify invocation targets to build up requests for a later execution or how to filter the client-server communication using client request filters and client response filters.

Creating a Websocket Chat Application with Vert.x and Java

Wed, 13 Nov 2013 00:00:00 +0100

Vert.x is a modern, lightweight framework to build high performance applications running on the Java Virtual Machine. The framework is polyglot so that you’re able to write your application in Java, Groovy, Ruby, Python or even JavaScript.

In addition it offers a nice component system, an actor-like concurrency model a distributed event bus and an elegant API to create scalable applications in no time.

In the following tutorial we’re going to build a websocket chat by creating a HTTP server and the websocket server using Vert.x, Java and Maven.

Writing Java Integration Tests for MongoDB

Wed, 16 Oct 2013 00:00:00 +0200

MongoDB is matured, document-oriented, cross-platform NoSQL database system with drivers available for a bunch of different programming languages.

In the following short examples I’m going to write some integration tests for MongoDB using the MongoDB Java driver and the Flapdoodle library to create an embedded MongoDB instance for testing.

We’re going to write tests for a simple persist-and-query scenarion and for a map-reduce function and in addition I’m going to show how to bind the start and stop of a MongoDB instance to a Maven goal using the embedmongo-maven-plugin.

Playing with Java 8 Lambda Expressions

Sun, 22 Sep 2013 00:00:00 +0200

Many articles have been written about JSR 335 aka Lambda Expressions for the Java^TM Programming Language but I like to try new things out for myself and that’s why I’d like to share my snippets here.

Figure 1. Lambda Hacking using the NetBeans Developer Version

Setup JDK and IDE

It takes just some short steps to setup your environment …

Download and install the Java 8 JDK with lambda support
Download and install the NetBeans IDE Development version
Configure NetBeans to use the Java 8 JDK (> Manage Platforms…)

Business Process Modeling with Activiti and BPMN 2.0

Sun, 15 Sep 2013 00:00:00 +0200

Having tried a bunch of workflow engines and business processing management platforms I now have given the Activiti framework a try.

I immediately liked the good test support using annotations and jUnit test rules, a straight API and the good Eclipse IDE integration as well as I liked the Activiti Explorer and the Activiti REST Application and the feeling to achieve quick results with less effort when using this framework.

Filtering Source Files using the Templating Maven Plugin

Tue, 03 Sep 2013 00:00:00 +0200

The Templating Maven Plugin looks useful if one needs to copy and to filter source files in a project e.g. to add property values from the build environment to a class.

For a short demonstration I’ve added the following short snippet.

Dependencies

Only one dependency needed .. simply add the following snippet to your pom.xml

<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>templating-maven-plugin</artifactId>
      <version>1.0-alpha-3</version>
      <executions>
        <execution>
          <id>filter-src</id>
          <goals>
            <goal>filter-sources</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Creating a Chat Application using Java EE 7, Websockets and GlassFish 4

Tue, 13 Aug 2013 00:00:00 +0200

Java EE 7 is out now and so I was curious to play around with the new specifications and APIs from in this technology stack.

That’s why I didn’t hesitate to add yet another websocket-chat tutorial to the existing ones on the internet in favour of gathering some experience with this technology and a possible integration using a GlassFish 4 server, the new Java API for JSON Processing for data serialization combined with custom websocket encoders/decoders and finally adding some Bootstrap and jQuery on the client side.

Embedding Jetty or Tomcat in your Java Application

Tue, 09 Jul 2013 00:00:00 +0200

Recently I needed to control an embedded web container from a Java application and I wanted to see how this could be achieved using an embedded instance of either Tomcat or Jetty here.

In the following short examples I would like to show how to embed both servers in an application in no time using Gradle or Maven as build tool.

Dependencies

We just need to add the web container libraries to our project here .. I’ve added the build config for Gradle and Maven here…

Handling Feature Flags in a Java EE Application using Togglz

Wed, 26 Jun 2013 00:00:00 +0200

Feature flags are a common technique, often combined with continuous deployment and delivery and they allow us to rollback a specific feature, to create A/B tests or to rollout a specific feature for a specific test group, a specific amount of users or dedicated systems.

In the following short examples I’d like you to demonstrate how easy it is to implement feature flags with the Togglz framework with a few steps in a Java EE environment.

Creating and Packaging a Game in Java FX 2.2

Sun, 23 Jun 2013 00:00:00 +0200

It’s been a long way for Java FX from the days of the F3 project the current release 2.2. Today there are many options how to create a Java FX application .. you may be using Java, Scala, Groovy or Visage, you may create your application in a programmatic way using the comfortable integrated builders or you may create your views using XML layouts and easy data-bindings with a few annotations.

Arquillian Transaction Extension: Transaction Rollback for your Java EE Integration Tests

Sun, 16 Jun 2013 00:00:00 +0200

I really love Arquillian to run integration tests for my Java EE applications – especially when running on different containers – and I also love the Arquillian tool stack from Arquillian Drone to the Arquillian Persistence Extensions.

Today I’d like to share a short snippet how to achieve transaction rollbacks when testing an EJB in combination with Arquillian and the Arquillian Transaction Extension…

Arquillian Basics

If you’ve never heard of the Arquillian framework before, please feel free to have a look at the Arquillian documentation or an article of mine: Arquillian Tutorial: Writing Java EE 6 Integration Tests and more...

Continuous Deployment using GlassFish, Jenkins, Maven and Git

Wed, 29 May 2013 00:00:00 +0200

Recently I needed a quick solution to deploy a Java EE 6 web application on a GlassFish instance automatically and subsequent to a successful build of the project on the integration server.

It took only a few steps using Jenkins, Maven and the Cargo plugin and I’d like to share this quick solution with you here.

Prerequisites

We need the following software installed and configured:

Git
Jenkins / Hudson + Git Plugin installed
Maven 3
GlassFish 3.1
JDK 7

Creating Rich Clients with Apache Pivot

Sun, 19 May 2013 00:00:00 +0200

Apache Pivot is a modern framework to create rich clients as desktop applications or to run in a web browser.

It offers nice GUI elements, supports XML/WTKX templates, data bindings, JVM scripting languages and much more.

In the following short examples I’m going to create a desktop application to open a file browser, select a file and output the selected file’s name, first using a programmatic approach to create the user interface, and afterwards using XML/WTKX templates.

Easy Database Migrations using Flyway, Java EE 6 and GlassFish

Sun, 28 Apr 2013 00:00:00 +0200

Database migrations often are a necessity in the application development and maintenance life-cycle.

Whenever we need to apply changes to the database structure, insert new data fragments and in doing so want to be sure that this all happens with some control and versioning.

The following tutorial shows how implement this for a simple Java EE 6 web application to be run on a GlassFish application server in a few quick steps using the Flyway framework, an eager initialized Singleton EJB and some Maven wiring.

Creating slim Database Projections using JPA2 Constructor Expressions

Sun, 14 Apr 2013 00:00:00 +0200

One common question that you may encounter one day when using object-relational-mapping in your application is how to slim down data that you’re retrieving from the persistence layer down to a specific subset for your use-case in an efficient manner and without using complex additional mapping frameworks. In some situations you might declare lazy loaded fields but another approach that I’d like to share with you here are JPA2 constructor expressions.

Creating a Blueprint or Content-Creator Plugin for Confluence

Sun, 17 Mar 2013 00:00:00 +0100

Blueprint is a new API in Confluence 5 that allows developers to create new content elements and to hook into the Confluence “create” dialogue – not to be confused with OSGi blueprints, the CSS blueprint framework or Tinkerpop Blueprints here.

Content may be added using simple XHTML templates, dynamic templates enriched with data from context providers or even customized JavaScript dialogues.

Another feature is, that pages of a specific blueprint type may be aggregated in a collector view that displays all pages created with the specific blueprint

Micro Benchmarking your Tests using JUnit and JUnitBenchmarks

Sun, 10 Mar 2013 00:00:00 +0100

I recently stumbled upon a nice framework that allows to convert simple JUnit tests into micro benchmarks named JUnitBenchmarks.

It allows to set basic benchmark options and and to generate charts by adding some simple annotations and a test rule to your tests.

One might argue if it is wise to mix the aspects, testing and benchmarking and I’d agree for sure – nevertheless I think this framework can be handy sometimes so let’s create some benchmarks using JUnit and JUnitBenchmarks..

Adding multiple EntityListeners to an Entity in JPA 2

Mon, 25 Feb 2013 00:00:00 +0100

The ability to attach lifecycle events to an entity using simple annotations sometimes is a neat feature in the Java Persistence API.

The following short snippets demonstrate how to bind and trigger the different available lifecycle events using an embedded derby database and a bunch of annotations.

Dependencies

I’m using Hibernate as persistence manager here and Derby as an easy to setup database. In the last step we’ll be writing a test that’s why we’ve added JUnit and Hamcrest.

Using Apache Camel with Scala and the Camel Scala DSL

Wed, 13 Feb 2013 00:00:00 +0100

Whenever I encounter a situation where I have to mix a blend of different services and endpoints and apply one or more of the traditional enterprise integration patterns then Apache Camel often is my weapon of choice.

I simply love how easy it is to set up some datasources, add some routing magic, data transformers, load balancers, content enrichers and enjoy the result.

Another thing that I’m beginning to love is Scala and so this is the perfect time to write an article about using Scala and Apache Camel together.

Using the Android Daydream API

Tue, 22 Jan 2013 00:00:00 +0100

Daydream is the new interactive screensaver mode that was added in the Android 4.2 / Jelly Beans release. Such “dreams” may be activated when the device is in idle mode or inserted into a dock.

In the following tutorial we’re going to create a simple daydream that starts a simple animation and in addition we’ll be adding a configuration screen to alter the behaviour of this daydream.

Create a new Android Application

First of all we need a new android project. I am using Eclipse and the ADT plugin here but any other solution like using a specific Maven archetype and the Jayway Maven plugin or using SBT should work, too.

Snippet: XML-Pull-Parser with XPP3

Fri, 28 Dec 2012 00:00:00 +0100

When there is XML to be parsed sometimes we’re chosing a DOM parser, sometimes a SAX parser and sometimes we’re using an XML pull parser, especially on Android.

The following short snippet shows how to use the xpp3 xml pull parse to fetch some information in xml format from a public issue tracker and to extract issue details.

Adding Dependencies

Just one dependency needed here: xpp3

SBT

Simply use the following build.sbt

Running categorized Tests using JUnit, Maven and Annotated-Test Suites

Thu, 06 Dec 2012 00:00:00 +0100

Sometimes we need to classify the tests in a project and a possible solution to achieve this goal is to assign different categories to the tests.

Often we’re doing this to separate the execution of fast-running and long-running tests or to run a specific set of tests that is only applicable in special situations.

To run a specific set of categorized tests there are different options and in the following tutorial we’ll be covering two of them: by configuring the Maven Surefire Plug-in or by using a JUnit Test Suite and the JUnit annotations.

Content Detection, Metadata and Content Extraction with Apache Tika

Sun, 02 Dec 2012 00:00:00 +0100

Encountering the situation that you want to extract meta-data or content from a file – might it be an office document, a spreadsheet or even a mp3 or an image – or you’d like to detect the content type for a given file then Apache Tika might be a helpful tool for you.

Apache Tika supports a variety of document formats and has a nice, extendable parser and detection API with a lot of built-in parsers available.

New features in JUnit 4.11

Sun, 18 Nov 2012 00:00:00 +0100

JUnit is one of the most popular testing frameworks out there. Version 4.11 has just been released and offers some nice improvements that you shouldn’t miss.

Dependencies

In older versions of JUnit there were two dependencies .. junit:junit contained an old version of hamcrest and could cause some nasty trouble .. junit:junit-dep just referenced hamcrest the maven way.

Now with version 4.11 there is just junit:junit with clean references to hamcrest and junit:junit-dep is relocated to junit:junit.

Creating an offline Rich-Client-Application using HTML, CSS and Java with SWT

Mon, 12 Nov 2012 00:00:00 +0100

There are a lot of frameworks out there to create offline applications and rich clients in Java.

One exotic alternative is to use the HTML, CSS and Javascript for this purpose and render the application in a Java frame using SWT and SWT’s browser component.

Creating a new Project

We’re using maven here for our project but you shouldn’t have a problem to use SBT, Gradle or Ivy instead…

Adding Maven Dependencies

We need two things .. first comes a repository for the swt dependencies …

Make your Tests more readable with custom Hamcrest Matchers

Sun, 28 Oct 2012 00:00:00 +0200

Everyday we’re writing tests for our software and sometimes we’re in a situation where we’re testing a specific type or object very often.

Luckily Hamcrest allows us to create custom matchers by subclassing from a given variety of available matchers.

Adding jUnit and Hamcrest

First add the dependencies for JUniti and Hamcrest to your project’s pom.xml or alternative build system.

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest-all</artifactId>
        <version>1.3</version>
        <scope>test</scope>
    </dependency>
</dependencies>

HTML5 Server Send Events using Node.js or Jetty

Sun, 21 Oct 2012 00:00:00 +0200

The HTML5 working draft describes different techniques to push information from a server to the client and the one described in this tutorial are Server-Send Events (SSE).

Using Server-Send-Events eliminates the need to poll a server periodically for information using AJAX and is really easy to implement because of the simple specification and the fact that nearly all modern browsers already implement this specification.

The Client Side

Registering for Server Send Events (SSE) is quite easy .. simply create a new EventSource object that is bound to the URL where the events are propagated.

Lucene Snippets: Index Stats

Sat, 08 Sep 2012 00:00:00 +0200

In Lucene 4.x there is an API to fetch index statistics for specific document’s fields.

The following examples shows how to create an index with some random documents and fetch some statistics for a field afterwards ..

Lucene Dependencies

Just one dependency needed here .. lucene-core. I’ve added the declarations needed for Maven and SBT here .. if you’re using Gradle or Buildr you should’t have a problem to create your build file either..

Lucene Snippets: Faceting Search

Tue, 28 Aug 2012 00:00:00 +0200

The latest snippet from my Lucene examples demonstrates how to achieve a facet search using the Lucene 4.0 API and how easy it is to define multiple category paths to aggregate search results for different possible facets.

In the following example we’re indexing some books as a classical example and create multiple category paths for author, publication date and category afterwards ..

Lucene Dependencies

We simply need two dependencies here .. lucene-core of course and in addition the lucene-facet library .. I’ve added the declarations needed for Maven and SBT here .. if you’re using Gradle or Buildr you should’t have a problem to transfer the information needed ;)

Creating a Windows Executable from a Jar using Maven

Tue, 07 Aug 2012 00:00:00 +0200

Often in the life of a developer there is the need to create a windows executable for a Java application that is build and packaged in a Jar file.

The following short example shows how to create an executable Jar first and a windows executable containing vendor information, a nice icon and other stuff afterwards by using a combination of the Maven Shade Plugin and the launch4j Plugin for Maven.

Integration Testing IMAP, SMTP and POP3 with GreenMail

Mon, 30 Jul 2012 00:00:00 +0200

Having written some e-mail handling, sending or receiving library you’d like to run some integration tests against a real mail server?

Then GreenMail might help you out here .. the framework is not quite new on the market but it is really easy to setup IMAP,SMTP or POP3 services with it and it comes with some helpful libraries making your life a bit easier here.

That’s why I’ve come to the idea to share some examples for setting up different server instances, creating user accounts and – at last – fetching and validating e-mails…

Aspects of Functional Programming in Java

Mon, 16 Jul 2012 00:00:00 +0200

Functional programming is a trending topic these days and a lot of Java programmers are hot for the features that modern functional programming languages might offer.

Waiting for Java 8 and native closure support is a nice thing but for now we’re going to take a look at several Java frameworks that are trying to implement typical structures from those functional languages where possible using the capabilities of the Java language to emulate elements like higher-order-functions, closures, options and others …

Task Scheduling in Java EE 6 on GlassFish using the Timer Service

Fri, 22 Jun 2012 00:00:00 +0200

Creating cronjobs or scheduled service executions is made really easy in Java EE 6. Scheduled tasks may be created in a programmatic style or simply by adding some annotations to an EJB.

In the following tutorial we’re creating some simple scheduled tasks and let them run on an embedded GlassFish instance using the Maven Embedded GlassFish plugin..

Java EE 6 Maven Project from Archetype

First of all we’re creating a new maven-ized project using one of the appropriate jee6 Maven archetypes

Creating updatable Java Applications using Getdown and the Getdown Maven Plugin

Sun, 27 May 2012 00:00:00 +0200

Many programmers have suffered when trying to setup an environment to handle updates for their application without much effort. Some tried Java Web Start for this purpose and many encountered difficulties with this approach.

Now there is getdown that aims to replace Java Web Start by offering a simple architecture to handle updates that is fast, realiable and the only thing you need is a normal http server. Though getdown lets us handle our updates really easy it is possible to make this process even easier with the getdown maven plugin.

Arquillian Tutorial: Writing Java EE 6 Integration Tests and more

Thu, 26 Apr 2012 00:00:00 +0200

Now that the long awaited stable version of the Arquillian framework is released I wanted to demonstrate some interesting features of this framework that really eases writing and running of integration tests for Java EE 6 applications in many different ways.

In the following tutorial we are going to create some real-world examples using Enterprise JavaBeans, Contexts and Dependency Injection, the Java Persistence API and we’re finally running Drone/Selenium tests against a JEE Web Application that is using Java Server Faces.

Wiring made easy using OSGi Blueprint and Apache Karaf

Mon, 16 Apr 2012 00:00:00 +0200

The OSGi Blueprint Container specification allows us to use dependency injection in our OSGi environment, declarative import and export of OSGi services, registering lifecycle listeners and wiring dependencies into our services with a few lines of XML code.
In the following tutorial we’re first building an OSGi bundle classical style and afterwards take a trip into the advantages of the Blueprint specification.

Our OSGi container of choice here will be Apache Karaf a lightweight container with a lot of nice features and – of course – blueprint enabled…

Hibernate Search Faceting: Discrete and Range Faceting by Example

Mon, 26 Mar 2012 00:00:00 +0200

In today’s tutorial we’re exploring the world of faceted searches like the one we’re used to see when we’re searching for an item on Amazon.com or other websites. We’re using Hibernate Search here that offers an API to perform discrete as well as range faceted searches on our persisted data.

Maven Dependencies Needed

For simplicity’s sake am I going to use an HSQL database for persistence, in addition the dependencies for hibernate-entitymanager and hibernate-search (of course) should be added to your pom.xml

Snippet: Mixing Scala, Java in a Maven Project

Fri, 23 Mar 2012 00:00:00 +0100

Having just returned from the Atlassian Camp 2012 I just toyed around with Java and Scala and wanted to share the following snippet that demonstrates how to mix code from both languages in a Maven project using the maven-scala-plugin.

Setting up the Maven Project

First create a new Maven project in your IDE or by running mvn archetype:generate.

In the next step, add the dependency for scala-library and the scala maven repositories to your pom.xml and hook the maven-scala-plugin to Maven’s lifecycle. My pom.xml finally looks like this one:

Using the Android Fragment API in a Tablet App

Sun, 18 Mar 2012 00:00:00 +0100

Since I got a new tablet running Android 4.0 aka ice cream sandwich I wanted to play around a bit with the fragments API and creating an application for a tablet.

In the following tutorial, we’re going to build an application that renders several articles from a popular tech blog (just kidding) in a web view.

What to build

We’re going to build an application that is able to display web links in the left section of the screen and when clicked, displaying the corresponding website content in the right section of the application screen.

JPA Persistence and Lucene Indexing combined in Hibernate Search

Sun, 05 Feb 2012 00:00:00 +0100

Often we’re writing an application that has to handle entities that – on the one side need to be persisted in a relational database using standards like the Java Persistence API (JPA) and using frameworks like Hibernate ORM or EclipseLink.

On the other side those entities and their fields are often stored in a highspeed indexer like Lucene. From this situation arises a bunch of common problems .. to synchronize both data sources, to handle special data mapped in an entity like an office document and so on..

Neo4j Graph Database Tutorial: How to build a Route Planner and other Examples

Fri, 20 Jan 2012 00:00:00 +0100

Often in the life of developer’s life there is a scenario where using a relational database tends to get complicated or sometimes even slow – especially when there are fragments with multiple relationships or multiple connections present. This often leads to complex database queries or desperate software engineers trying to handle those problems with their ORM framework.

A possible solution might be to switch from a relational database to a graph database – and – neo4j is our tool of choice here. In the following tutorial we’re going to implement several examples to demonstrate the strengths of a graph database .. from a route planner to a social graph.

Create Mobile Websites using Java Server Faces and PrimeFaces Mobile

Sun, 08 Jan 2012 00:00:00 +0100

The more smartphones and tablets are sold the bigger the need for a mobile version of a modern website. PrimeFaces Mobile helps us developers here and allows us to quickly create mobile websites that display well on an iPhone, Android, Palm, Blackberry, Windows Mobile and others.

In the following tutorial we’re going to create a web application that is using Java Server Faces 2.1, PrimeFaces 3.1 and PrimeFaces Mobile 1.0 and runs on a simple web container like Tomcat or Jetty.

Writing Styles and Themes on Android

Sat, 03 Dec 2011 00:00:00 +0100

Using reusable styles and themes to modify an Android application’s look is really easy and helps to not violate thy DRY (don’t repeat yourself) principle by typing styles in every single UI element again and again.

In the following tutorial we’re going to write and apply some simple styles and a finally theme to a simple Android application.

Prerequisites

The following environment is needed to follow this tutorial …

Java Development Kit 6
Android SDK
An AVM with at least Android 2.2 / API Version 8
I recommend using Eclipse with the ADT Plugin installed

Managing Background Tasks on Android using the Alarm Manager

Sun, 27 Nov 2011 00:00:00 +0100

In today’s tutorial we’re going to take a look on how to handle periodically scheduled tasks on our Android device by using BroadcastReceivers, Services and the AlarmManager.

Prerequisites

The following environment is needed to follow this tutorial …

Java Development Kit 6
Android SDK
An AVM with at least Android 2.2 / API Version 8
I recommend using Eclipse with the ADT Plugin installed

The Concept

We’re going to create a first broadcast receiver that gets initiated at boot time. This component then should make use of Android’s AlarmManager API and schedule a cyclic task using an explicit intent.

Finding Memory Leaks using Eclipse and the MemoryAnalyzer Plugin

Wed, 02 Nov 2011 00:00:00 +0100

The MemoryAnalyzer Plugin for Eclipse allows us to quickly analyze heap dumps from a virtual machine and search for memory leaks. In the following tutorial we’re going to create and run a small application that is going to cause an OutOfMemoryException during its runtime.

In addition, we’re forcing the virtual machine to save a heap dump and finally analyzing this data using Eclipse and the MemoryAnalyzer plugin.

Prerequisites

Testing RESTful Web Services made easy using the REST-assured Framework

Sun, 23 Oct 2011 00:00:00 +0200

Figure 1. REST-assured Integration Test Tutorial Logo

There are many frameworks out there to facilitate testing RESTful webservices but there is one framework I’d like to acquaint you with is my favourite framework named REST-assured.

REST-assured offers a bunch of nice features like a DSL-like syntax, XPath-Validation, Specification Reuse, easy file uploads and those features we’re going to explore in the following article.

With a few lines of code and Jersey I have written a RESTful web service that allows us to explore the features of the REST-assured framework and to run tests against this service.

Maven Tomcat Plugin: Adding Authentication to an Embedded Tomcat

Wed, 12 Oct 2011 00:00:00 +0200

The Tomcat Maven Plugin not only allows us to deploy our mavenized application to an existing Tomcat server but also to run our web application with an embedded instance from our project’s directory. Recently I needed to add basic authentication to such an instance and wanted to share the steps necessary here

Prerequisites

We just need Maven and a JDK …

Project Setup

I am using the webapp archetype here
We’re adding the following configuration for the Tomcat plugin to your pom.xml – my final descriptor is this one

pom.xml

Android Widget Tutorial: Creating a screen-lock Widget in a few steps

Thu, 06 Oct 2011 00:00:00 +0200

In today’s Android tutorial we’re going to take a look at Android’s Widget API and how to make a widget interact with a service using intents.

Figure 1. hasCode Android Widget Tutorial Logo

We’re going to create a fully functional application that allows us to enable or disable our smartphone’s screen lock settings using a widget that can be placed on our home screen.

Finally, I am going to show how to use a smartphone to test and debug our application and connect it to the IDE.

Java EE 6 Development using the Maven Embedded GlassFish Plugin

Tue, 20 Sep 2011 00:00:00 +0200

Today we’re going to take a look at the Maven Embedded GlassFish Plugin and how it allows us quick creation of GlassFish server instances in no time and Java EE 6 application deployment.

Figure 1. GlassFish + Maven

With a few lines of configuration in your Maven’s pom.xml we’ve got a running GlassFish instance and are able to redeploy our application fast by pressing enter in our console.

In the following tutorial we’re going to build a Java EE 6 Web Application with a stateless session bean and a web servlet and finally deploy – and redeploy the application using the Maven GlassFish Plugin.

REST-assured vs Jersey-Test-Framework: Testing your RESTful Web-Services

Mon, 05 Sep 2011 00:00:00 +0200

Today we’re going to take a look at two specific frameworks that enables you to efficiently test your REST-ful services: On the one side there is the framework REST-assured that offers a nice DSL-like syntax to create well readable tests – on the other side there is the Jersey-Test-Framework that offers a nice execution environment and is built upon the JAX-RS reference implementation, Jersey.

In the following tutorial we’re going to create a simple REST service first and then implement integration tests for this service using both frameworks.

Screenscraping made easy using jsoup and Maven

Tue, 30 Aug 2011 00:00:00 +0200

Sometimes in a developer’s life there is no clean API available to gather information from a web application .. no SOAP, no XML-RPC and no REST .. just a website hiding the information we’re looking for somewhere in its DOM hierarchy – so the only solution is screenscraping.

Screenscraping always leaves me with a bad feeling – but luckily there is a tool that makes this job at least a bit easier for a developer .. jsoup to the rescue!

Contract-First Web-Services using JAX-WS, JAX-B, Maven and Eclipse

Tue, 23 Aug 2011 00:00:00 +0200

Using the contract-first approach to define a web service offers some advantages in contrast to the code-first approach.

In the following tutorial we’re going to take a look at some details of this approach and we’re going to implement a real SOAP service using JAX-WS, Maven and the Eclipse IDE.

Finally we’re going to run our service implementation on an embedded Jetty instance and we’re going to take a look at soapUI and how to test our service using this neat tool.

Creating Portlets using Java Server Faces 2 and Liferay

Tue, 19 Jul 2011 00:00:00 +0200

Portlets are a common technology to create plug&play components for modern web applications and are specified by the Java Community Process in several specification requests.

In the following tutorial we’re going to learn how to create custom portlets and how to deploy and embed them in Liferay, the popular open-source enterprise portal.

In addition we’re taking a look at inter-portlet-communication and how to create portlets using annotations.

Finally we’re building a portlet-state-aware Java-Server-Faces portlet using the jsf-portlet-bridge mechanism.

Integrating Groovy in your Maven builds using GMaven

Tue, 12 Jul 2011 00:00:00 +0200

Often ant tasks are used in Maven builds but wouldn’t it be more attractive to integrate the Groovy language into our build process?

GMaven is the answers to this problem and brings together Maven and Groovy. It allows us to execute Groovy scripts inline from our Maven configuration, from a local script or even from a remote location. In the following short examples I am going to show how to configure Maven to execute Groovy scripts from different locations.

Confluence User Profile Mobile vCard Plugin released

Sat, 18 Jun 2011 00:00:00 +0200

I’ve released a new plugin for the popular Confluence Wiki that extends the user profile with new tab that displays the user’s vcard as a QR code.

This allows an easy import of address data from Confluence to your smartphone.

Features

Display of a Confluence user’s contact data as a QR code in a separate tab in the user profile
More to be implemented ..

Installation

Just download the plugin from Atlassian’s Plugin Exchange and install it using the Universal Plugin Manager in your Confluence’s administration area
That’s all .. nothing to configure here ..

Creating a LDAP server for your development environment in 5 minutes

Mon, 13 Jun 2011 00:00:00 +0200

I am currently working on a plugin that needs to receive some information from an LDAP/Active Directory using JNDI. That’s why I needed to set up a directory server in a short time and I didn’t want to waste much effort for here. Luckily for me the Apache Directory Studio saved my day and allowed me to set up everything I needed in a few minutes.

Short and sweet: In this tutorial I’m going to show you how to configure everything you need in your Eclipse IDE and finally how to query the created LDAP server with a tiny java client using JNDI.

Message Driven Beans in Java EE 6

Sun, 05 Jun 2011 00:00:00 +0200

Message Driven Beans are no new concept due to the fact that they exist since EJB 2.0 but in Java EE 6 and the EJB 3.0 specification it is even more fun to use them.

In this tutorial we’re going to take a look at the specification and create an example application that transfers some objects via the Java Message Service to a Message-Driven Bean deployed on a GlassFish application server.

Oh JBehave, Baby! Behaviour Driven Development using JBehave

Tue, 31 May 2011 00:00:00 +0200

Behaviour Driven Development is the keyword when we’re talking about test scenarios written in an ubiquitous language, strong interaction with stakeholders, product owners or testers and well described, common understandable test scenarios.

The popular JBehave framework is our tool of choice here and allows us to decouple our test stories from the test classes, offers an integration for web tests using Selenium and finally there’s a helpful Maven plugin for JBehave, too.

Confluence Social Comments Plugin

Mon, 30 May 2011 00:00:00 +0200

I have created a new, free plugin for Confluence, the popular enterprise wiki.

The plugin allows you to notify users of ongoing discussions in comments on a confluence page by posting a specific token including the user’s name like this: “@username:”

Features

Configurable notification settings in the administration area
Several placeholders to be used in the e-mail template for the notifications
User filtering to avoid sending duplicate e-mails
For more detailed information take a look at the Maven generated project website

SCJP/OCPJP Exam Preparation: Pitfalls to avoid

Mon, 25 Apr 2011 00:00:00 +0200

Last year I passed the exam for the “Oracle Certified Professional Java Programmer”successfully and wanted to share my exam preparation notes about common problems and pitfalls to be aware of.

That’s why I have added some code and examples for my top 25 challenges below.

Figure 1. ocpjp

Exam Preparation

I won’t cover how to prepare yourself for the exam, how the exam is structured or what is the best way to process the exam’s questions – these questions are very well covered by the SCJP study guide, JavaRanch.com or other resources of choice – I have listed a few at the and of this article in the resources section.

Mocking, Stubbing and Test Spying using the Mockito Framework and PowerMock

Sun, 27 Mar 2011 00:00:00 +0100

Today we’re going to take a look at the Mockito framework that not only does sound like my favourite summer cocktail but also offers nice testing, mocking/stubbing, test-spying features and mock injections.

After that we’re going to take a look on how to mock static or final classes by extending Mockito’s capabilities with PowerMock.

Prerequisites

We don’t need much for the following samples .. Java of course, Maven dependency management and that’s all ..

Creating a sample Java EE 6 Blog Application with JPA, EJB, CDI, JSF and Primefaces on GlassFish

Tue, 08 Feb 2011 00:00:00 +0100

Java EE 6 is out and it indeed offers an interesting stack of technologies. So in today’s tutorial we are going to build a small sample web application that builds on this stack using Enterprise JavaBeans, Java Persistence API, Bean Validation, CDI and finally Java Server Faces and PrimeFaces.

The application we’re going to develop is a simple blog app that allows us to create new articles, list them and – finally delete them. We’re also covering some additional topics like JSF navigation, i18n, Ajax-enabled components and the deployment on the GlassFish application server.

Enterprise Java Bean EJB 3.1 Testing using Maven and embedded Glassfish

Sat, 01 Jan 2011 00:00:00 +0100

Are you playing around with the shiny new 3.1 EJB API?

Using Maven for your Java projects?

Need an easy way to write and execute tests for your EJBs that depends on an Java Application Server?

No problem using Maven Archetypes, the Maven EJB Plugin and the GlassFish embedded Application Container..

Prerequisites

For the following tutorial we’re going to need an installation of Maven and of course – the Java Development Kit!

Bean Validation with JSR-303 and Hibernate Validator

Tue, 14 Dec 2010 00:00:00 +0100

You want to add some validation logic to your Java beans? You want to achieve this with some shiny extendable annotations? Then give the Java Bean Validation standard aka JSR-303 a try..

We’re going to use the reference implementation for bean validation, Hibernate Validator in this tutorial but there are also links to other alternatives like Oval or Apache Bean Validation.

So let’s begin and validate some stuff ..

Prerequisites

JDK >=6
Maven >=2
An IDE or text editor of choice

Creating a REST Client Step-by-Step using JAX-RS, JAX-B and Jersey

Thu, 25 Nov 2010 00:00:00 +0100

Often in a developer’s life there is a REST service to deal with and nowadays one wants a fast and clean solution to create a client for such a service.

The following tutorial shows a quick approach using JAX-RS with its reference implementation, Jersey in combination with JAX-B for annotation driven marshalling between XML or JSON structures and our Java-Beans.

Prerequisites

The following stuff is needed to run the following examples and code samples

Using PrimeFaces to pimp up existing Java Server Faces / JSF 2 Applications

Sun, 14 Nov 2010 00:00:00 +0100

In this tutorial we’re going to modify an existing Java Server Faces / JSF 2 web application by adding rich UI components to the existing layout.

Our tool of choice here is the PrimeFaces framework. It offers a wide range of interesting, customizable and (several) Ajax-enabled components that blend very well with JSF1+2 and also a solid documentation that allows a quick integration into existing projects.

Project setup

For this tutorial we’re going to reuse the web application from my JSF2 Tutorial “Java Server Faces/JSF 2 Tutorial – Step 1: Project setup, Maven and the first Facelet” – the source code is available at GitHub.org.

How to create a Confluence SOAP Component in 5 Minutes

Sun, 24 Oct 2010 00:00:00 +0200

You’re using the popular Confluence wiki? You’re using its RPC/SOAP API and missing a function you really need? Just extend the capabilities of the Confluence RPC API by programming a custom web service component – it is really easy and also well documented.

In this tutorial we’re going to take a look on how to quickly implement a SOAP service, securing it and putting its methods in a transactional context.

Prerequisites

Maven >=2
JDK >= 5
Confluence Wiki >= 3.0 (for a quick installation guide take a look at this article)
SoapUI for Testing

Object-relational Mapping using Java Persistence API JPA 2

Mon, 11 Oct 2010 00:00:00 +0200

Today we’re going to take a look at the world of object-relational Mapping and how it is done using the Java Persistence API by creating some basic examples, mapping some relations and querying objects using JPQL or the Criteria API..

Prerequisites

Java 6 JDK
Maven >= 2
If you’d like to take a look behind the scenes e.g. how entities are mapped in your database you could install a RDBMS of your choice .. or just use Derby/JavaDB that is bundled with the JDK 6

Playing around with the Android Animation Framework

Mon, 27 Sep 2010 00:00:00 +0200

Animations add some spice to our Android applications and the offered animation framework makes it easy to create custom animations and tweens.

So lets dance around and create some animations ;) ..

About

There are two ways to create animations – via XML declaration or in a Java class. We’re going to focus on XML declaration – if you’re interested in java based declaration – take a look at the Android JavaDocs and the subclasses of android.view.animation.Animation.

Creating a SOAP Service using JAX-WS Annotations

Thu, 23 Sep 2010 00:00:00 +0200

It is possible to create SOAP webservices with only a few lines of code using the JAX-WS annotations. In a productivity environment you might prefer using contract-first instead of code-first to create your webservice but for now we’re going to use the fast method and that means code-first and annotations olé!

Creating the SOAP Service

Create a class SampleService with two public methods
Annotate this class with @WebService (javax.jws.WebService) – now all public methods of this class are exported for our SOAP service
To change the name of an exported method, annotate the method with @WebMethod(operationName = “theDesiredName”) (javax.jws.WebMethod)

Finally the service class could look like this

package com.hascode.tutorial.soap;

import javax.jws.WebMethod;
import javax.jws.WebService;

@WebService public class SampleService {
 @WebMethod(operationName = "getInfo") public String getInformation() {
 return "hasCode.com";
 }

 public String doubleString(String inString) {
 return inString + inString;
 }
}

How to create a simple Messaging Application using RabbitMQ 2 and Maven

Sun, 05 Sep 2010 00:00:00 +0200

Having read an interesting comparison by Lindenlabs evaluating modern message broker systems like ActiveMQ, ApacheQpid and amongst others – RabbitMQ – I wanted to take a quick look at the last one and built a small application producing and consuming some sample messages.

If you need some lecture on getting started with RabbitMQ or the key concepts of messaging I strongly recommend reading this list of introductional articles from the RabbitMQ homepage.

Spring 3, Maven and Annotation Based Configuration

Sun, 22 Aug 2010 00:00:00 +0200

There is still the urban myth that using Spring IoC container without thousands lines of XML code isn’t possible – so today we’re taking a look at annotation based configuration with Spring 3 and of course we’re using Maven..

Setup your project

Create a simple Maven project using

mvn archetype:generate // or
mvn archetype:create

Add a lot of dependencies and reference them to the Spring version defined as a property in your pom.xml. A good reference on Spring 3 and Maven artifacts can be found at Springsource.com

<properties>
     <org.springframework.version>3.0.0.RELEASE</org.springframework.version>
 </properties>
 <dependencies>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-core</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-expression</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>

     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-beans</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-aop</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context-support</artifactId>
         <version>${org.springframework.version}</version>
     </dependency>
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>com.springsource.org.aspectj.runtime</artifactId>
         <version>1.6.8.RELEASE</version>
     </dependency>
 </dependencies>

How to create a simple OSGi Web Application using Maven

Sun, 25 Jul 2010 00:00:00 +0200

In this tutorial we will take a look at the development of a simple OSGi Web Application and what tools can save us some time.

The Maven Bundle Plugin makes our life much easier here as does the OSGi Bundle Repository that offers some nice bundles – in our case the servlet API and an embedded Jetty web server.

So lets develop some bundles ..

Prerequisites

You are going to need a JDK (>=5), Maven2, the Apache Felix OSGi implementation and and text editor/http://eclipse.org/[IDE] of your choice.

How to create a Template Bundle Plugin in Confluence

Mon, 12 Jul 2010 00:00:00 +0200

Since Confluence 3.2. there is a new plugin module type that allows you to deploy templates in a bundle via the plugin API.

In addition it is possible to assign these templates to specific spaces and preview available templates in the Confluence administration area.

So let’s build some sample templates..

Creating a Template Bundle Plugin

Creating a template bundle is easy – just create a class implementing TemplatePackage – there are two methods: one returns a list of bundled PageTemplate Objects the other the name for the template bundle.

A look at Google’s Protocol Buffers

Tue, 06 Jul 2010 00:00:00 +0200

Protocol Buffers are a serialization format developed by Google- you might ask if another IDL is really needed here – is Google barking at the wrong tree?

But protocol buffers offer some advantages over data serialization via XML or JSON – Google says they (compared to XML)..

are 3 to 10 times smaller
are 20 to 100 times faster
provide generated data access classes for programmatic use
provide backward compatibility

Java Server Faces/JSF 2 Tutorial – Step 1: Project setup, Maven and the first Facelet

Sat, 05 Jun 2010 00:00:00 +0200

In this short tutorial we are going to build a Java Server Faces Web-Application using JSF2.0, Facelets, Maven and Hibernate as ORM Mapper.

The goals for this first step are: Setting up the project structure using Maven, defining a frame template/decorator and a registration facelet, creating a managed bean and mapping it’s values to the facelet, adding some basic validation, displaying validation errors and finally adding a navigation structure.

In step2 of this tutorial we are going to add persistence using Hibernate, add some security, create a custom UI component and add some AJAX.

Sensor Fun: Location Based Services and GPS for Android

Sun, 30 May 2010 00:00:00 +0200

The Android SDK offers a nice API to receive information about available providers for location based services and get the current location and coordinates.

In this short tutorial we’re going to build a small activity that displays a list of available location providers and shows the current position using GPS services.

Example Application

Create a new Android Project using ADT and your IDE with a package named com.hascode.android.location_app

Add the permissions needed to the AndroidManifest.xml – it should look like this

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
	package="com.hascode.android.location_app" android:versionCode="1"
	android:versionName="1.0">
	<application android:icon="@drawable/icon" android:label="@string/app_name">
		<activity android:name=".LocationActivity" android:label="@string/app_name">
			<intent-filter>
				<action android:name="android.intent.action.MAIN" />
				<category android:name="android.intent.category.LAUNCHER" />
			</intent-filter>
		</activity>

	</application>
	<uses-sdk android:minSdkVersion="7" />

	<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS"></uses-permission>
	<uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION"></uses-permission>
</manifest>

Review: SCJP Sun Certified Programmer for Java 6 Study Guide

Mon, 24 May 2010 00:00:00 +0200

Short Facts:

About 850 pages – heavy weight – use it for self defence! ;)
Preparation material for the Sun Exam 310-065 (Sun Certified Java Programmer for Java SE 6)
CD-Rom with a nice exam simulator included
Authors: Kathy Sierry and Bert Bates
ISBN: 978-0071591065

My two cents:
My favorite author team strikes back – this time with a book for the certification exam to become a glorious “http://in.sun.com/training/certification/java/scjp.xml[Sun Certified Java Programmer]” for Java SE 6. I’ve read some other books from both authors before – especially from the “http://headfirstlabs.com/[Head First]” series from O’Reilly as they are “Head First Design Patterns”, “Head First Servlets and JSP” and last and least “Head First EJB”. Perhaps I am going to write a review for one of those, too – who knows..

Extending the Confluence Search Index

Sun, 23 May 2010 00:00:00 +0200

Developing plugins for the Confluence Wiki a developer sometimes needs to save additional metadata to a page object using Bandana or the ContentPropertyManager. Wouldn’t it be nice if this metadata was available in the built-in Lucene index?

That is were the Confluence Extractor Module comes into play..

Overview

An extractor allows the developer to add new fields to the lucene search index. Creating a new extractor is quite simple – just implement the interface com.atlassian.bonnie.search.Extractor or bucket.search.lucene.extractor.BaseAttachmentContentExtractor if you want to build a new file extractor.

Creating a simple Gesture App with Android

Fri, 14 May 2010 00:00:00 +0200

The integration of gestures into your android app adds some nice functionality and is made very easy using Google’s GestureBuilder application and the integrated GestureLibrary and Gesture Overlay API – so let’s build a sample app.

If you need some basic information regarding gestures on android first – take a look at this article.

Creating a gesture library

First you need to define the gestures that should be captured in the application later. For this reason there’s the GestureBuilder delivered with the Android SDK. You can find the app in the samples directory of your android sdk – e.g. <installation-directory>/android-sdk-linux_86/platforms/android-2.1/samples/GestureBuilder.

Playing around with QR Codes

Tue, 11 May 2010 00:00:00 +0200

Sometimes QR codes are a nice way to distribute information like calendar events, contact information, e-mail, geo-locations or internet addresses.

In the following article we’re going to encode information to QR code images using the ZXing library and afterwards decode information from a given QR code.

Finally we’re taking a look on online QR code generators and how to integrate the ZXing library in a Maven project.

The ZXing Library

Download the ZXing Libraries from http://code.google.com/p/zxing/downloads/list – the file name is ZXing-<version>.zip
Unpack the downloaded archive somewhere
Change to the extracted directory and run ant. If you don’t have JavaME installed – and you don’t have to for the samples below – run ant buildwithoutj2me – that will do the job
Having compiled the libraries you’re now free to include the core.jar from zxing-<version>/core/ and the javase.jar from zxing-<version>/javase as dependency in your project

Snippets: Getting License Information from the Confluence API

Thu, 06 May 2010 00:00:00 +0200

Sometimes one needs to look up license details of a running Confluence system .. perhaps for creating a commercial plugin or to display recommendations dependant from the license used. For this reason there are a few possibilities for receiving some license information from the Confluence API or the velocity context.

Note: This article is outdated since the Atlassian Marketplace was launched and a shiny new licensing API was added. Until this article is updated I strongly recommend to take a closer look at the detailed information that Atlassian is providing in the Developer Documentation.

Sensor Fun: Creating a simple audio recorder/player

Sun, 02 May 2010 00:00:00 +0200

Sound recording and playback is really simple using the MediaRecorder and MediaPlayer classes .. see the example below ..

Sample App

First some layout .. a button to start/stop recording and a button to play the recorded stuff (main.xml):

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView
	android:id="@+id/output"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text=""
    />
<Button android:text="@+string/record" android:id="@+id/btRecord" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>
<Button android:text="@+string/play" android:id="@+id/btPlay" android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>
</LinearLayout>

Adjusting the externalized strings in the strings.xml

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">Soundrecorder Tutorial</string>
	<string name="record">Record!</string>
	<string name="play">Play</string>
</resources>

Sensor Fun: Using the accelerometer on Android

Tue, 27 Apr 2010 00:00:00 +0200

Here is an example on how to use the accelerometer in your Android application. If you want to simulate the acceleration on the emulator I highly recommend the Sensor Simulator on the OpenIntents website.

The following example app displays the coordinates received by the sensor.

The Acceleration App

The activity – AccelerationActivity.java

package com.hascode.android;

import android.app.Activity;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.widget.TextView;

public class AccellerationActivity extends Activity {
	private TextView result;
	private SensorManager sensorManager;
	private Sensor sensor;
	private float x, y, z;

	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
		sensor = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER).get(0);

		result = (TextView) findViewById(R.id.result);
		result.setText("No result yet");
	}

	private void refreshDisplay() {
		String output = String
				.format("x is: %f / y is: %f / z is: %f", x, y, z);
		result.setText(output);
	}

	@Override
	protected void onResume() {
		super.onResume();
		sensorManager.registerListener(accelerationListener, sensor,
				SensorManager.SENSOR_DELAY_GAME);
	}

	@Override
	protected void onStop() {
		sensorManager.unregisterListener(accelerationListener);
		super.onStop();
	}

	private SensorEventListener accelerationListener = new SensorEventListener() {
		@Override
		public void onAccuracyChanged(Sensor sensor, int acc) {
		}

		@Override
		public void onSensorChanged(SensorEvent event) {
			x = event.values[0];
			y = event.values[1];
			z = event.values[2];
			refreshDisplay();
		}

	};
}

First steps on Android: Creating a simple Todo App

Mon, 26 Apr 2010 00:00:00 +0200

In this tutorial we are going to build a simple todo app that is able to store simple todos in a database. The user is able to add new todos or delete old ones by clicking on a todo. For this tutorial we won’t use maven to keep it simple – if maven integration is desired – take a look at this tutorial.

Steps

Create a new android project using the Android SDK and your IDE
Create some packages com.hascode.android.activity and com.hascode.android.persistence

Create the layout in res/layout/main.xml – the main elements: a listview for the todos-list, a textbox and a button to enter new data.

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout
        android:id="@+id/widget31"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        xmlns:android="http://schemas.android.com/apk/res/android"
    >
        <TableRow
            android:id="@+id/row"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:orientation="horizontal"
            android:layout_below="@+id/tasklist"
            android:layout_alignParentLeft="true"
        >
            <EditText
                android:id="@+id/etNewTask"
                android:layout_width="200px"
                android:layout_height="wrap_content"
                android:text=""
                android:textSize="18sp"
            >
            </EditText>
            <Button
                android:id="@+id/btNewTask"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="@+string/add_button_name"
            >
            </Button>
        </TableRow>
        <ListView
            android:id="@+id/tasklist"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:layout_alignParentTop="true"
            android:layout_alignParentLeft="true"
        >
        </ListView>
</RelativeLayout>

Coding Katas with Maven

Thu, 15 Apr 2010 00:00:00 +0200

Searching for nice coding kata sites I found this one – codingkata.org – I really liked because of the quick start and nice maven integration.

Just head over to the kata overview select the kata you wish to try out, copy the generated maven command line option and run it in the console – heres the code for the hello-world sample:

Coding Katas from Maven Archetype

mvn archetype:generate -DinteractiveMode=false -DarchetypeRepository=http://www.codingkata.org/repo/release -DarchetypeGroupId=org.codingkata.template -DarchetypeArtifactId=solv-java-archetype -DarchetypeVersion=1.04 -DgroupId=org.codingkata.unit -DartifactId=hello-world-solv-java -DkataId=hello-world -DkataVersion=1.02 -DlangVersion=1.6 -DlibVersion=1.3.2 -Dversion=1271358

How to build a Confluence Macro Plugin

Tue, 13 Apr 2010 00:00:00 +0200

The goal is to build a small macro plugin deployable via the Confluence plugin API rendering some spaces.

Please note that I am going to build the plugin using just Maven and not the Atlassian Maven Wrapper called the “Atlassian Plugin SDK” – more information about that is available at the Atlassian website.

The macro output will be rendered using a Velocity template and all messages are stored for i18n in properties files bundled with the plugin.

Create a SOAP client using the JAX-WS Maven Plugin

Thu, 08 Apr 2010 00:00:00 +0200

Having written the article “How to build a Confluence SOAP client in 5 minutes” some readers asked me for some more information and help using the JAX-WS plugin that I mentioned in the article instead of the Axis plugin – so here we go ;)

Steps

Create a simple maven project first using archetype:create or archetype:generate
```
mvn archetype:create -DgroupId=com.hascode.jaxws -DartifactId=soap-tutorial
```

We get a pom.xml like this:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.hascode.jaxws</groupId>
     <artifactId>soap-tutorial</artifactId>
     <version>0.1</version>
</project>

Manage dependencies with the Maven Dependency Plugin

Sun, 04 Apr 2010 00:00:00 +0200

In a maven project there are lots of dependencies to handle – often one wants to know which version of a software comes from.

The solution to this problem is the Maven Dependency Plugin which helps you to find used/unused/declared/undeclared dependencies in your project.

In addition the plugin allows you to copy or unpack artifacts.

Maven Goals

dependency:copy – copies artifacts defined in the config to a specified location – details available here
dependency:resolve – resolves all dependencies and shows the versions
dependency:go-offline – resolves everything the project needs like dependencies, plugins and reports
dependency:analyze - parses the dependencies and shows if they are used/declared/unused/undeclared ..
dependency:analyze-dep-gmt - finds mismatches between resolved dependencies and those listed in the dependencyManagement section
dependency:tree – shows a nice dependency tree for the maven project

Snippet: Simple One-Minute IMAP Client

Sat, 03 Apr 2010 00:00:00 +0200

Building a simple IMAP Client that displays the subject of the messages in the “inbox” Folder using Maven (I just like Maven).

Project Setup / Maven

Create a new Maven project

mvn archetype:create -DgroupId=com.hascode.imap -DartifactId=imap-client

Edit your pom.xml and add some dependencies

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.hascode.imap</groupId>
     <artifactId>imap-client</artifactId>
     <version>0.0.1-SNAPSHOT</version>
     <dependencies>
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.8.1</version>
         </dependency>
         <dependency>
             <groupId>javax.mail</groupId>
             <artifactId>mail</artifactId>
             <version>1.4.2</version>
         </dependency>
     </dependencies>
</project>

Creating the E-Mail Client

Create a package .. something like com.hascode.imap.client ;)

Create a simple mail client using javax.mail in a class named ImapClient

package com.hascode.imap.client;

import javax.mail.Folder;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Store;

public class ImapClient {
    private Session session = null;
    private Store store = null;
    private String host = null;
    private String userName = null;
    private String password = null;

    public ImapClient(String host, String userName, String password){
        this.host = host;
        this.userName = userName;
        this.password = password;
    }

    public boolean getMail() throws MessagingException {
        session = Session.getDefaultInstance(System.getProperties(),null);
        //        session.setDebug(true);
        System.out.println("get store..");
        store = session.getStore("imaps");
        System.out.println("connect..");
        store.connect(this.host, this.userName, this.password);
        System.out.println("get default folder ..");
        Folder folder = store.getDefaultFolder();
        folder = folder.getFolder("inbox");
        folder.open(Folder.READ_ONLY);
        System.out.println("reading messages..");
        Message[] messages = folder.getMessages();
        for(Message m:messages){
          System.out.println(m.getSubject());
        }
        return false;
    }
}

Confluence Developer Instance Quick Setup

Fri, 26 Mar 2010 00:00:00 +0100

This short tutorial shows how to set-up a developer instance of the popular Confluence Wiki from Atlassian in a few minutes.

It’s a prerequisite for a few following tutorials regarding the Confluence API and plug-in development for this system.

We want a quick install so we are going to run Confluence with the embedded servlet container and HSQL database.

update Meanwhile it is way much easier to use Atlassian’s Plugin SDK using atlas-mvn run or atlas-mvn-run-standalone –product confluence –version x.x.x but if you need to setup an independant instance, this article still might be useful.

How to build a quick Lucene Search

Thu, 25 Mar 2010 00:00:00 +0100

Helo – today I wanted to post a small tutorial for a small index and search operation using the Lucene indexer and Maven for the project setup.

Setup

Create an empty Maven sample project using the Eclipse Maven Plugin or use the following console command:
```
mvn archetype:create -DgroupId=com.hascode.demo.search -DartifactId=lucene-sample
```

Here is my pom.xml there are some dependencies for Lucene defined:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.hascode.demo.search</groupId>
  <artifactId>lucene-sample</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>My Lucene Search Sample</name>
  <description>Lucene Search Sample</description>
  <dependencies>
    <dependency>
      <groupId>org.apache.lucene</groupId>
      <artifactId>lucene-core</artifactId>
      <version>2.4.1</version>
    </dependency>
    <dependency>
      <groupId>lucene</groupId>
      <artifactId>lucene</artifactId>
      <version>1.4.3</version>
    </dependency>
  </dependencies>
</project>

How to add a local lib directory to Maven

Thu, 18 Mar 2010 00:00:00 +0100

Sometimes there is a dependency not available at a remote repository and one is too lazy to set up a local maven repository – that’s when one adds a directory in the project structure and wants maven to find dependencies there.

Create a directory called “lib” in the project root

Add the following markup to the pom.xml inside the <repositories>-Tag (create if it does not exist):

<repository>
    <id>lib</id>
    <name>lib</name>
    <releases>
        <enabled>true</enabled>
        <checksumPolicy>ignore</checksumPolicy>
    </releases>
    <snapshots>
        <enabled>false</enabled>
    </snapshots>
    <url>file://${project.basedir}/lib</url>
</repository>

Atlassian Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Disable YUI compressor

<plugin>
    <groupId>com.atlassian.maven.plugins</groupId>
    <artifactId>maven-jira-plugin</artifactId>
    <version>${amps.version}</version>
    <extensions>true</extensions>
    <configuration>
        <compressResources>false</compressResources>
        [..]
    </configuration>
</plugin>

Confluence – Get favourites by user

Using the label manager.

List getFavouriteSpaces(String username)

Confluence – Determine the base URL

Using the SettingsManager:

String baseUrl = settingsManager.getGlobalSettings().getBaseUrl();

Confluence – Get the context path

Using the BootstrapManager:

String contextPath = bootstrapManager.getWebAppContextPath();

Confluence – Using Velocity Template for a Macro

final VelocityContext contextMap = new VelocityContext(MacroUtils.defaultVelocityContext());

contextMap.put("key", obj); // references obj as variable named $key in the velocity template

VelocityUtils.getRenderedTemplate("path/to/template.vm", contextMap);

Eclipse Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Favorites

Spare my time when using static imports ..

Window > Preferences > Java > Editor > Content Assist > Favorites:

com.google.common.collect.Lists
com.jayway.restassured.matcher.RestAssuredMatchers
com.jayway.restassured.RestAssured
io.restassured.matcher.RestAssuredMatchers
io.restassured.RestAssured
org.hamcrest.MatcherAssert
org.hamcrest.Matchers
org.mockito.Mockito
javaslang.API
javaslang.Predicates

Template to insert a static logger instance

Go Windows > Preferences > Java > Editor > Templates > New …

Enter logger as name and as template:

${:import(org.slf4j.Logger,org.slf4j.LoggerFactory)}
private static final Logger LOG = LoggerFactory.getLogger(${enclosing_type}.class);

Afterwards you’re able to type logger in your code and ctrl+space gives the option to insert the logger

Java Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Remote Debug a Pod’s Java Process

Simple steps for remote debugging a Java process running on a k8 pod:

Edit deployment and add the following parameters to the Java start line: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=127.0.0.1:5005

Also add the following port mapping at the section container → ports in the deployment:
```
- containerPort: 5005
  protocol: TCP
```
Safe, wait for the new pods and then add a port forward for port 5005 for this pod:
```
kubectl port-forward podname 5005
```

Kafka Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Start an Image with kcat / kafka-cat for Debugging

kubectl -n NAMESPACE run "$(whoami)-debug" -it --rm \
    --image=confluentinc/cp-kafkacat:6.1.9 \
    --restart=Never \
    -- bash

Dockerfile for Kafka Analysis Container with different Tools

With jq, kafka console tools, schema registry tools and kafkacat installed ….

Dockerfile

FROM confluentinc/cp-kafka:6.2.1 as cp-kafka
FROM confluentinc/cp-schema-registry:6.2.1 as cp-schema-registry

FROM debian:10-slim
ARG DEBIAN_FRONTEND=noninteractive

# Install necessary tools
RUN apt-get update && apt-get install -y \
    curl \
    jq \
    yq \
    && rm -rf /var/lib/apt/lists/*

# Install kafkacat binary
RUN apt-get update && apt-get install -y kafkacat && rm -rf /var/lib/apt/lists/*

# Copy Kafka binaries
COPY --from=cp-kafka /usr/bin/kafka-* /usr/bin/
COPY --from=cp-schema-registry /usr/bin/schema-registry* /usr/bin/

# Copy entrypoint script
COPY entrypoint.sh /usr/bin/entrypoint.sh
RUN chmod +x /usr/bin/entrypoint.sh

ENTRYPOINT ["/usr/bin/entrypoint.sh"]

Kotlin Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Checks / Exit Conditions

Instead of writing something like if !condition throw … we may use require and check for quick exit conditions:

val num = 1;

require(num > 1){
    // ...
}

val num = 1;

require(num > 1){
    // ..
}

Pluralize Strings

Adding pluralization as extension function

fun String.pluralize(count:Int):String {
    return if (count > 1){
        this + 's'
    } else {
        this
    }
}

Use it like this

Maven Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Extract Coordinates from the POM

Helpful for build and integration environments, pipelines etc.

Exctract the Project version from the pom.xml

mvn org.apache.maven.plugins:maven-help-plugin:3.1.0:evaluate -Dexpression=project.version -q -DforceStdout

Override a Property via local configuration

e.g. to override the property xxx from your project’s pom.xml

Create a directory .mvn in your project directory root
Create a file named maven.config in this directory
Insert -Dxxx=newvalue into the file to override this property

Don’t forget to add .mvn to your .gitignore!

MyBatis Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Use List of Parameters in Annotation-based Query

Possible using MyBatis Dynamic SQL feature

package com.hascode.example.mybatis;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface SampleMapper {

    @Select({"<script>",
             "SELECT sample.bar",
             "FROM sampletable sample",
             "WHERE sample.id IN",
            "<foreach item='item' index='index' collection='ids'",
            "open='(' separator=',' close=')'>",
            "#{item}",
            "</foreach>",
            "</script>"})
    List<Foo> getSamplesMatchingIds(@Param("ids") List<String> ids);
}

The mapper may now be used with a list of parameter objects:

var samples = sampleMapper.getSamplesMatchingIds(List.of("24059e5b-aa07-424d-855e-50f499b8f697", "65140fc0-fc9f-42d2-9531-5e5d6caeba30"));

Call a Procedure

package com.hascode.example.mybatis;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.StatementType;

@Mapper
public interface SampleMapper {

    @Select("CALL SCHEMA.CL.setScope(#{scope})")
    @Options(statementType = StatementType.CALLABLE)
    void setScope(int scope);
}

Spring Boot Snippets

Mon, 01 Mar 2010 00:00:00 +0100

Define and Configure Log Groups

This allows to configure a group of loggers at the same time

Define a log group named myaspect with two packages
application.properties
```
logging.group.myaspect=com.hascode.package1,com.hascode.package2
```
Configure the log group and set all loggers to level TRACE
application.properties
```
logging.level.myaspect=TRACE
```

This is also possible as parameter on startup

java -Dlogging.level.myaspect=TRACE myapp.jar

Use JUnit 5 with Spring Boot

Use newer versions of Surefire and Failsafe plugins:

<properties>
[..]
  <maven-failsafe-plugin.version>2.22.0</maven-failsafe-plugin.version>
  <maven-surefire-plugin.version>2.22.0</maven-surefire-plugin.version>
</properties>