Eclipse und Java 8

Nun, nachdem ich bequem das JDK8 auf meinem Rechner habe, will ich näturlich die neuen Features in meiner Lieblings-IDE ausprobieren. Mmmh, ich mußte feststellen, dass Eclipse Kepler noch gar nicht für Java 8 vorgesehen ist.

Aber alles gar kein Problem, denn unter http://downloads.efxclipse.org/eclipse-java8/ kann sich jeder eine Eclipse Version herunterladen, die Java 8 unterstützt. Ich habe die Version „efxclipse-jdk8“ genommen.

Unter Window > Perferences > Java > Installed JREs müßt ihr lediglich das JDK 8 hinzfügen.

Installierte JREs

Dann könnt ihr Java 8 in euren Projekten als JRE verwenden. Und es kann los gehen, z.B. mit Lambda Expressions.

Beispiel Lambda Expression

Übrigens, den aktuellen Status des Eclipse JDK 8 Support könnt ihr euch unter: http://wiki.eclipse.org/JDT_Core/Java8 anschauen.

Bildquelle: R_K_B_by_Claudia-Hautumm / pixelio.de

Einfach und schnell Java 8 auf Linux installieren

Ich habe einen Weg entdeckt, wie ich bequem Java 7 und Java 8 auf meinem Rechner mit Kubuntu installieren kann. Am JDK 8 reizen mich die neuen funktionalen Features.

Die Leute von webupd8.org haben in ihrem Artikel  sehr schön beschrieben, wie man per apt JDK7 und JDK8 installieren kann. Das tolle daran ist, dass du auch den JDK Default leicht umschalten kannst.

Repository hinzufügen

[code language=“bash“]
sudo apt-add-repository ppa:webupd8team/java
sudo apt-get update
[/code]

JDK installieren

[code language=“bash“]
sudo apt-get install oracle-java7-installer
sudo apt-get install oracle-java8-installer
[/code]

Bei Problemen aufrufen

[code language=“bash“]
sudo update-java-alternatives -s java-7-Oracle
sudo update-java-alternatives -s java-8-Oracle
[/code]

Umgebungsvariabel setzen

[code language=“bash“]
sudo apt-get install oracle-java7-set-default
sudo apt-get install oracle-java8-set-default
[/code]

Versionen wieder deinstallieren

[code language=“bash“]
sudo apt-get remove oracle-java7-installer
sudo apt-get remove oracle-java8-installer
[/code]

Bildquelle: pixelio.de/S.Hainz

Developer Conference 2013

Anfang November war ich auch auf der DC13. Das war ein sehr cooler Event, wo ich jede Menge Sachen mitgenommen habe. Dabei sind mir interessante Technologien und Praktiken immer wieder in den Vorträgen aufgefallen.

Praktiken, die immer wieder vorkamen:

KISS
Just-in-Time
YAGNI
Move fast
Verschwendung eliminieren
Zu große Features
Überflüssige und nutzlose Features
Technische Schulden, keine Schulden ohne Zinsen
Unklare Zuständigkeiten
Single Point of Knowledge
Wartezeit
Task-Queueing im Backlog
Verbesserungen in kleinen Schritten
Komplexität senken
nicht benutzte Features ausbauen
Upgraden von Sprachversionen, Frameworks, DBs und Tools
Experimente machen
Nicht zu viel planen
Fail early, fail often, learn fast
Prototypen einsetzen
Cache all things
never block
go async
share-nothing-architecture
be domain driven
stateless
persist all events as raw data
In memory
Self Tuning

Technologien, die ich ausprobieren werde:

akka
Build powerful concurrent & distributed applications more easily. Akka is a toolkit and runtime for building highly concurrent, distributed, and fault tolerant event-driven applications on the JVM.

Apache Thrift
The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and seamlessly between C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, OCaml and Delphi and other languages.

elasticsearch

flexible and powerful open source, distributed real-time search and analytics engine for the cloud

Google Protobuf
Protocol Buffers are a way of encoding structured data in an efficient yet extensible format. Google uses Protocol Buffers for almost all of its internal RPC protocols and file formats.

Maria DB

An enhanced, drop-in replacement for MySQL.

Metrics

Metrics provides a powerful toolkit of ways to measure the behavior of critical components in your production environment.With modules for common libraries like Jetty, Logback, Log4j, Apache HttpClient, Ehcache, JDBI, Jersey and reporting backends like Ganglia and Graphite, Metrics provides you with full-stack visibility.

netty

Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.

Postgres + Postgis

PostGIS is a spatial database extender for PostgreSQL object-relational database. It adds support for geographic objects allowing location queries to be run in SQL.

Swagger

Document your API with style. Swagger is a specification and complete framework implementation for describing, producing, consuming, and visualizing RESTful web services.

Statische Codeanalyse – Wie starte ich am besten?

In meinen Projekten hat sich der Einsatz von Codeanalyse-Tools immer gelohnt. Anfangs war es immer schwer, andere Entwickler von den Vorteilen zu überzeugen. Spätestens, wenn ein Tool einen unentdeckten Fehler, der noch zugleich kritisch war, gefunden hatte, waren alle anderen vom Nutzen überzeugt. Doch wie starte ich am besten in einem Projekt mit einem Codeanalysetool?

Heute gehe ich weniger auf die Vorteile der statischen Codeanalyse oder die verschiedenen Tools ein, sondern erzähle von den Möglichkeiten, wie ihr in euren Projekten
mit der statischen Codeanalyse starten könnt. Ich sehe hier 3 Möglichkeiten:

1. Verwendung des Standardregelsatzes

2. Starten mit einen eigenen, schon bestehenden Regelsatzes

3. Sukzessiver Aufbau eine Regelsatzes

Die Verwendung des Standardregelsatzes, die die Tools wie Checkstyle, PMD oder
FindBugs mitbringen, ist näturlich die einfachste Möglichkeit. Die Entwickler haben sich schon im Vorwege Gedanken gemacht, was wichtig ist wie Naming Convetions, Duplicate Code, Header, Imports, Kommentare, Größen, Modifier und Whitespace. Vorteil ist hier, dass die Entwickler im Projekt sofort sehen, welche Regeln mißachtet wurden, die in der Java Community existieren. Nachteil ist, dass in Brownfield Projekten die Entwickler „vor lauter Kraut die Rüben“, sprich die wichtigsten Regelverletzungen nicht sehen und beheben.

Der Start mit einem eigenen, schon bestehenden Regelsatzes ist eine prima Möglichkeit. Man hat schon Erfahrungen mit Codeanalysetools, kennt die Projekte in einem Unternehmen und die Art und Weise wie bisher in Softwaree entwickelt wurde. Bei dieser Methode ist alles in Ordnung. Voraussetzung ist, dass man schon Erfahrungen mit den Tools gesammelt hat und weiß, welche Dinge bei der Softwareerstellung „vernachläßigt“ werden.

Der sukzessive Aufbau eines Regelsatzes ist eine gute Möglichkeit, die ich schon in mehreren Projekten erfolgreich angewendet habe, wenn man „vor lauter Kraut die Rüben“ nicht sehen kann. Ich bin schon mal mit nur einer Regel gestartet: Nullpointer Check
(FindBugs Bug Description). Nach und nach haben wir dann weitere Regeln hinzugefügt, wenn die Bugs der einen Kategorie behoben wurden sind oder neue Fälle aufgetreten sind, wo das Hinzufügen einer neuen Regel Sinn machte. Vorteil dieses Weges ist, dass beim Start des Einsatzes eines Codeanalysetools der Fokus auf wenige Regeln liegt, nämlich die man als die wichtigsten identizifiziert hat. So bleibt die Motivation bei den Entwickler erhalten, die sich ansonsten von den Bug-Meldungen erschlagen fühlen könnten. Nachteil der Methode ist, dass ohne Plan wie der Aufbau vonstatten gehen soll, z.B. welche Regel wann folgen, ob weitere Tools eingesetzt werden, etc. , der Aufbau langsam und unkoordiniert erfolgt.

Ich selber nutze gerne die erste Möglichkeit, wenn ich in Projekten neu reinkomme. Somit sehe ich sofort, wo der Schuh drückt. Für die eigentliche Arbeit im Brownfield-Projekten empfehle ich aber den sukzessiven Aufbau einese Regelsatzes. Wenn ihr euch für die zweite oder dritte Methode entscheidet, dann ist es wichtig, dass ihr regelmäßig überprüft, welche Regeln noch Sinn machen.

Links:
Checkstyle
PMD
FindBugs

Bildquelle: Pixelio.de/Karl-Heinz Laube

Clean Code Developer Days 2013

Ich bin heute und morgen auf den Clean Code Developer Days und rede in meinem Vortag „Die 7 Wege zum Clean Code“ über Clean Code.

Die Konferenz findet dies Jahr in Dresden statt. In meinem Vortrag rede ich über folgende Themen:

  • statische Codeanalyse
  • Testdriven Development
  • Refactoring
  • Continuous Integration
  • Reviews
  • Coding Standards
  • Coding Dojos

Wenn ihr euch für den Vortrag interessiert, dann meldet euch
bei meinem Newsletter an.
Als Dankeschön erhält ihr den Vortrag als PDF.

Spring und Unit-Tests mit Mockito

Ich hatte mich schon längere Zeit gefragt, ob ich nicht noch einfacher auf die Mocks zugreifen kann, um das Verhalten zu manipulieren.

Also recherierte ich ein bißchen und bin dann bei der neusten Mockito-Version (1.9.5) auf die Annotations @Mock und @InjectMocks aufmerksam gewurden.

[code language=“java“]
package de.claudioaltamura.spring.mockito.example.controller;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.Errors;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "masterdatadetailvalidator-test.xml" })
public class MasterDataDetailValidatorTest {

@Autowired
@InjectMocks
private MasterDataDetailValidator validator;

private MasterDataFormBean formBean;

private Errors errors;

@Mock
@Autowired
private DateRangeValidator dateRangeValidator;

@Before
public void setUp() {

}

@Test
public void test() {
final DateRange dateRange = new DateRange(null, null);
formBean.getLoginData().setUseraccountValidRange(dateRange);
validator.validate(formBean, errors);

assertFalse(errors.hasErrors());
}

}
[/code]

Mit @Mock kennzeichne ich einfach die Klassen die zu Mocken sind.
Und @InjectMocks benutze ich für die Klasse, die zu testen ist,
und wo die Mocks injiziert werden sollen. Das ist alles.

Consent Management Platform von Real Cookie Banner