Maven on Micha Kops' Tech Notes

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

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:

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'

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>

Using Throwaway Containers for Integration Testing with Java, JUnit 5 and Testcontainers.

Wed, 30 Jan 2019 00:00:00 +0100

A lot of boilerplate code is written when developers need to test their applications with different connected systems like databases, stream platforms and other collaborators.

Docker allows to handle those dependencies but there is still some glue code required to bind the container’s lifecycle and the configuration to the concrete integration test.

Testcontainers is a testing library that offers lightweight throwaway instances of anything able to run in a Docker container, with bindings to configure the specific containers and also provides wrappers to manage our own custom containers.

Testing OpenAPI Swagger Schema Compliance with Java, JUnit and assertj-swagger

Fri, 31 Aug 2018 00:00:00 +0200

The OpenAPI and Swagger API description format are becoming important standards to specify API contracts for RESTful web services and the Microservices trend pushes the need for such contracts even further.

Therefore arises the need for software architects, testers and developers to write tests to verify if an exposed API follows such a specified contract.

In the following tutorial I will demonstrate a setup with Java, Maven, JUnit and the designated contract-testing-library, assertj-swagger that verifies the validity of such a contract exposed by a Spring Boot application against a local stored definition.

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.

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.

Reactive Streams – Java 9 Flow API, RxJava, Akka and Reactor Examples

Sun, 14 Jan 2018 00:00:00 +0100

Reactive Streams is an initiative trying to standardize asynchronous stream processing with non-blocking back-pressure. With Java 9, new classes in the java.util.concurrent.flow package offer a semantically equivalent counterpart to this standard that may be adopted by other frameworks.

In the following short tutorial we’re implementing examples for reactive streams with Java 9 and the Flow API, with RxJava2, with Akka, with Reactor and finally there is an example in RxJava1, too though it does not follow the standard.

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.

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.

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>

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

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.

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.

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.

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.

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.

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.

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.

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.

Running JavaScript Tests with Maven, Jasmine and PhantomJS

Sun, 04 May 2014 00:00:00 +0200

Sometimes in a project there is the need to run tests for your client-side code, written in JavaScript from a Maven build.
One reason might be that Maven manages a complex build life-cycle in your project and you need a close integration for your JavaScript tests, another one might be that you’re in an environment where it is complicated to install and manage additional software like an integration- or build-server.

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.

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.

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>

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 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.

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..

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.

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.

Compiling CoffeeScript with Maven

Fri, 18 May 2012 00:00:00 +0200

CoffeeScript is a neat language that is transcompiled into JavaScript but is more predictable and allows to write the same code with 1/3 fewer lines and of course with a (imho) nicer syntax.

CoffeeScript is nice but a vivid integration into our application build lifecycle with Maven is better and that is what the following example is all about.

Maven Dependencies

Though there are some alternatives, we’re using brew here so please add the following dependency to your Maven project:

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…

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:

Selenium WebDriver, Selenium Server and PageObjects by Example

Tue, 06 Mar 2012 00:00:00 +0100

A lot has changed since Selenium RC and WebDriver has given us a new syntax to write tests for our web pages. PageObjects add an abstraction to the pages under test and finally we’re able to programmatically start Selenium server instances and use them to run the tests.

In the following tutorial, we’re writing some tests using PageObjects, WebDriver, Selenium Server and finally we’re even taking some screenshots of our tested web pages..

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.

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

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.

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.

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.

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!

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

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.

Dependency management in Grails 1.2

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

Sometimes I get the impression that there are many Maven haters in the Groovy/Grails community – now with version 1.2 of the Grails framework they are able to abandon the evil satanic Grails Maven Plugin and embrace the neverending joys of a slim, nice, sexy dependency resolution dsl .. here we go .. lets define some dependencies wheee …

Our dependency configuration is defined in grails-app/config/BuildConfig.groovy as a property named grails.project.dependency.resolution:
```
grails.project.dependency.resolution = {
// here will be some dependencies
}
```

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.

A look at Maven 3 alpha

Sat, 22 May 2010 00:00:00 +0200

We are all waiting for a stable release of Maven3 with following updates ..

faster, more performant .. save us time building our software and some precious memory ;)
improved artifact resolution api and plugin api
better osgi integration
a few bugfixes
no mixing of application dependencies and tooling dependencies
though it does not matter that much to me: polyglot features .. e.g.: “Writing your pom files in Groovy”
version-less parent elements for multi-module or multi-pom projects, no need to define the parent version in every submodule
better artifact resolution, which dependency or pom supplied which artifact to the outcome .. got that information from: “Splitter from the world of Java”

Signing APK with the Maven-Jar-Signer Plugin

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

There is a nice Maven plugin helping you signing your Android app – the Maven Jar Signer Plugin. If you want to learn more about Maven integration in an android project take a look at this article.

Maven Profile Setup

Add the following code to your pom.xml

<?xml version="1.0"?>
<profiles>
    <profile>
        <id>sign</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jarsigner-plugin</artifactId>
                    <version>1.2</version>
                    <executions>
                        <execution>
                            <id>signing</id>
                            <goals>
                                <goal>sign</goal>
                            </goals>
                            <phase>package</phase>
                            <inherited>true</inherited>
                            <configuration>
                                <archiveDirectory/>
                                <includes>
                                    <include>target/*.apk</include>
                                </includes>
                                <keystore>path/to/keystore</keystore>
                                <storepass>storepasword</storepass>
                                <keypass>keypassword</keypass>
                                <alias>key-alias</alias>
                            </configuration>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                    <artifactId>maven-android-plugin</artifactId>
                    <inherited>true</inherited>
                    <configuration>
                        <sign>
                            <debug>false</debug>
                        </sign>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

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;
    }
}

How to integrate Android Development Tools and Maven

Fri, 02 Apr 2010 00:00:00 +0200

With the Maven Android Plugin it is possible to build and deploy/undeploy your android app and start/stop the emulator – if you’re used to maven you won’t be going without it ;)

If you’re interested in signing your apk using maven – take a look at this article

Project Setup

Create an android project using the android tool

We need some dependencies – so create a pom.xml in the project’s root directory – I took this from the plugin samples and modified it:

<?xml version="1.0" encoding="UTF-8"?>
<!--
 Copyright (C) 2009 Jayway AB

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->
<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.android.app</groupId>
     <artifactId>demo</artifactId>
     <packaging>apk</packaging>
     <name>hasCode.com - Sample Android App using the Maven Android Plugin</name>
     <version>0.1</version>
     <dependencies>
         <dependency>
             <groupId>android</groupId>
             <artifactId>android</artifactId>
             <version>2.1</version>
             <scope>provided</scope>
         </dependency>

         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>4.8.1</version>
             <scope>test</scope>
         </dependency>
     </dependencies>

     <build>
         <!--<finalName>${artifactId}</finalName>-->
         <plugins>
             <plugin>
                 <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                 <artifactId>maven-android-plugin</artifactId>
                 <configuration>
                     <sdk>
                         <path>${env.ANDROID_HOME}</path>
                         <platform>3</platform>
                     </sdk>
                     <deleteConflictingFiles>true</deleteConflictingFiles>
                 </configuration>
                 <extensions>true</extensions>
             </plugin>

             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
                 <source>1.5</source>
                 <target>1.5</target>
                 </configuration>
             </plugin>

         </plugins>
     </build>

</project>

How to build a Confluence SOAP client in 5 minutes

Sun, 28 Mar 2010 00:00:00 +0100

In this tutorial we are going to build a SOAP client for the popular Confluence Wiki in about five minutes. The client is going to receive rendered HTML Markup from a specified Confluence Page.

Prerequisites

A running Confluence Installation with SOAP API enabled – if you don’t already have one take a look at this article or if you’ve got the Atlassian Plugin SDK installed .. start a standalone instance using atlas-run-standalone ..
Maven – never go without it ;)
Five minutes of your life time ..

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);

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
```

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!

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>