Kategorie-Archiv: Java

Jenkins – Manueller Neustart

Kurz und knapp und zur Dokumentation für mich selbst, die Möglcihkeiten Jenkins manuell neuzustarten (abgesehen von der klassischen Möglichkeit an der Kommandozeile)

(jenkins_url)/safeRestart

Alle im moment laufenden Jobs werden noch beendet. Neue Jobs werden in einer Queue vorgehalten um sie nach dem Neustart durchzuführen.

(jenkins_url)/restart

Wenns schneller gehen soll. Laufende Jobs werden ignoriert und einfach abgebrochen.

Ähnliche Artikel:

  • Noch keine vorhanden.

Refactoring: Eine Methode mit einem Methodenobjekt ersetzen

Heute möchte ich meine neue Artikelserie einläuten: Refactoring. Dabei werde ich in unregelmäßigen Abständen Tipps und Tricks dazu veröffentlichen. Der erste geht im speziellen an meinen Freund Eggi, der viel mit von Kollegen geerbten Legacy Code zu kämpfen hat:

Wer kennt sie nicht, viel zu lange Methoden. Mit Variablen die am anfang deklariert, in der Mitte 5x verändert und am Ende zurückgegeben werden sollen. Und dann auch noch 2 oder mehr von den Dingern!

Ok es müssen nicht 5 davon sein, und die Methode noch nichtmal lange. Ein schnelles, bewusst sehr simples Beispiel: Einfach mal versuchen die beiden Zuweisungen mittels Eclipse -> Extract Method als neue private Method rausziehen.

package test;

public class ToMuchVarMethod {
	
	public void shortExample(){
		
		int i = 1;
		int j = 1;
		
		i = 2;
	    j = 2;
	    
	    System.out.println(i +" "+ j);
	}

}

Die neue Methode wird einem mit der Meldung “Ambiguous return value: Selected block modifies more than one local variable used in subsequent code.” versagt.

Was also tun? Nun es mag in dem hier gewählten Beispiel nicht besonders schlau wirken, aber eine saubere Lösung wäre es, die Methode in ein eigenes Objekt umzuwandeln. Man muss dazu den Scope der lokalen Methodenvariablen ändern und sie zu Instanzvariablen dieses Objektes werden lassen. Als nächsten Schritt gilt es, die lange Methode in einzelne Methoden innerhalb des neuen Objekts aufzusplitten. Die neue Klasse bietet dann eine Startmethode an wie z.B. compute() oder run() und bildet darin durch die einzelnen Methodenaufrufe die alte Methode nach.

So entsehen gut testbare Units und klare logische Abgrenzungen was in den einzelnen Methoden passiert.

Auch wenn es in dem hier angeführten Beispiel zu mehr Zeilen Code führt und somit etwas aufgebläht wirkt, bedient man dabei doch folgende zwei Prinzipien, die zu einem besser lesbaren, verständlicheren und damit besser wartbaren Code führen:

Hier noch das Beispiel von oben aufgesplittet in

das Aufrufende Objekt:

package test;

public class ToMuchVarMethod {
	
	public void shortExample(){
		
		ShortExample e = new ShortExample(1, 1);
		e.compute();
	}

}

und Methodenobjekt:

package test;

public class ShortExample {
	
	private int i;
	private int j;
	
	ShortExample(int i, int j){
		this.i = i;
		this.j = j;
	}
	
	private void setToTwo(){
		this.i = 2;
		this.j = 2;
	}
	
	private void print(){
		System.out.println(this.i + " "+ this.j);
	}
	
	public void compute(){
		setToTwo();
		print();
	}

}

Ähnliche Artikel:

JavaFX seit Java 8 in Maven

Musste man während Java 7 noch die JavaFX Librarys per Maven dezitiert einbinden, stehen diese mit Java 8 von Haus aus im Classpath zur Verfügung. Einfach das Maven Compiler Plugin entsprechend konfigurieren:

<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>
	<groupId>at.nullpointer</groupId>
	<artifactId>test-java8</artifactId>
	<version>0.0.1-SNAPSHOT</version>	
	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>

Zu Java 7 Zeiten war dafür noch ein extra dependency Eintrag notwendig. Wie dieser ausgesehen hat sieht man z.B. im Blog von Hendrik Ebbers.

Ähnliche Artikel:

Java 8 auf der Synology DS214+

Eine schnelle Anleitung wie ich Java 8 auf meiner Synology DS214+ zum Laufen brachte.

  1. Download des JDK 8 in der Linux ARM v6/v7 Hard Float ABI Version.
  2. Entpackt nach /opt
  3. Symlink angelegt:
    ln –s /opt/jdk1.8.0 /opt/java
  4. Zu /etc/profile folgendes hinzufügen:
    JAVA_HOME=/usr/java 
    export JAVA_HOME         
    PATH=/usr/java/bin:$PATH
  5. Neu laden mittels
    source /etc/profile
  6. Viel Spaß mit Java 8 auf der Synology DS214+

Ähnliche Artikel:

Java 8 – Date and Time API

Da etwas in die Jahre gekommen, wurde zu java.util.Date und java.util.Calendar mit dem Release von Java 8 eine Alternative geschaffen. Zuhause im Package java.time versucht die neue Lösung sich an benutzerfreundlicheren Factorymethoden, Formatierungslösungen, Threadsicherheit durch Unveränderlichkeit.

LocalDate und LocalTime

Als für den Menschen lesbare Formate sind java.time.LocalDate und java.time.LocalTime vorgesehen (und natürlich die Kombination: java.time.LocalDateTime). Sie bieten übersichtliche Factory Methoden

LocalDateTime now= LocalDateTime.now( ); // Aktuelles Datum LocalDate.of(2013, Month.DECEMBER, 24);
LocalTime.of(12, 00); LocalTime.parse("10:15:30");

und ihre Werte können mittels Getter erfragt werden und bieten Methoden an um neue Instanzen mit anderen Werten zu generieren.

LocalDate theDate = now.toLocalDate(); Month month = timePoint.getMonth();
//Da immutable, immer neue Instanzen erzeugt
LocalDateTime before = now.withYear(2013);
LocalDateTime soon = new.plusWeeks(1);
LocalDateTime wednesday = now.with(TemporalAdjusters.previousOrSame(ChronoUnit.WEDNESDAY));

Instant

Eine andere Darstellung eines Datums ist das java.time.Instant, das die Zeit als Millisekunden seit 01.01.1970 darstellt.

Abschneiden von Werten

Das Beschneiden von Zeiten auf eine Bestimmte Einheit ist nun ebenfalls Teil der neuen API:

LocalTime truncatedTime = now.truncatedTo(ChronoUnit.SECONDS);

Zeitzonen

Zeitzonen können mittels java.time.ZoneId mit berücksichtigt werden. Die ZoneId entspricht dann entweder dem Zeitzonenkürzel (dem Offset von UTC) oder einem Ort der entsprechenden Zeitzone. Damit kann man sich nun Entsprechungen der oben genannten Zeitklassen mit dem Prefix Zoned erzeugen, die somit eindeutig auf den Gebrauch von Zeitzonen hinweisen. z.B. java.time.ZonedDateTime

ZoneId id = ZoneId.of("Europe/Vienna");
ZonedDateTime zoned = ZonedDateTime.of(dateTime, id);

Noch viel mehr

Außerdem bietet die neue Zeit API verschiedene Kalendersysteme, Zeitspannen (Periods, Durations,…) und Formatierungen mittels DateTimeFormatter.

Werft einen Blick rein! http://docs.oracle.com/javase/tutorial/datetime/TOC.html

Ähnliche Artikel: