Offene Java, JavaScript und SpringBoot Seminare in Dortmund für das Jahr 2020

tutego Schulungsraum

Collections Framework und Stream-API (›JAVACOL‹)

30. März–1. April 2020 (KW 14), 27.–29. April 2020 (KW 18), 18.–20. Mai 2020 (KW 21), 1.–3. Juli 2020 (KW 27), 22.–24. Juli 2020 (KW 30), 5.–7. August 2020 (KW 32), 26.–28. August 2020 (KW 35), 16.–18. September 2020 (KW 38), 30. September–2. Oktober 2020 (KW 40), 14.–16. Oktober 2020 (KW 42)

Java Grundlagen (›JAVA1‹)

11.–15. Mai 2020 (KW 20), 15.–19. Juni 2020 (KW 25), 29. Juni–3. Juli 2020 (KW 27), 20.–24. Juli 2020 (KW 30), 3.–7. August 2020 (KW 32), 24.–28. August 2020 (KW 35), 14.–18. September 2020 (KW 38), 28. September–2. Oktober 2020 (KW 40), 12.–16. Oktober 2020 (KW 42)

Java für Fortgeschrittene (›JAVA2‹)

11.–15. Mai 2020 (KW 20), 15.–19. Juni 2020 (KW 25), 29. Juni–3. Juli 2020 (KW 27), 20.–24. Juli 2020 (KW 30), 3.–7. August 2020 (KW 32), 24.–28. August 2020 (KW 35), 14.–18. September 2020 (KW 38), 28. September–2. Oktober 2020 (KW 40), 12.–16. Oktober 2020 (KW 42)

Spring Boot (›SPRINGBOOT‹)

30. März–1. April 2020 (KW 14), 27.–29. April 2020 (KW 18), 18.–20. Mai 2020 (KW 21), 1.–3. Juli 2020 (KW 27), 22.–24. Juli 2020 (KW 30), 5.–7. August 2020 (KW 32), 26.–28. August 2020 (KW 35), 16.–18. September 2020 (KW 38), 30. September–2. Oktober 2020 (KW 40), 14.–16. Oktober 2020 (KW 42)

JavaScript für Web-Entwickler (›JAVASCRIPT‹)

30. März–1. April 2020 (KW 14), 27.–29. April 2020 (KW 18), 18.–20. Mai 2020 (KW 21), 1.–3. Juli 2020 (KW 27), 22.–24. Juli 2020 (KW 30), 5.–7. August 2020 (KW 32), 26.–28. August 2020 (KW 35), 16.–18. September 2020 (KW 38), 30. September–2. Oktober 2020 (KW 40), 14.–16. Oktober 2020 (KW 42)

Snippet: JAXB and CDATA ContentHandler with CharacterEscapeHandler

Main program:

package com.tutego.jaxb;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
import java.io.PrintWriter;

public class App {
  public static void main( String[] args ) throws Exception {
    Dog dog = new Dog();
    dog.name = "Wüffi";
    Flea flea = new Flea();
    flea.name = "<><> Böser Floh <><>";
    dog.flea = flea;

    JAXBContext jaxbContext = JAXBContext.newInstance( dog.getClass() );
    Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
    jaxbMarshaller.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, true );
    jaxbMarshaller.marshal( dog, new CDATAContentHandler( new PrintWriter( System.out ) ) );
  }
}

Dog and Flea:

package com.tutego.jaxb;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Dog {
  public String name;
  public Flea flea;
}

class Flea {
  public String name;
}

CDATAContentHandler:

package com.tutego.jaxb;

import com.sun.xml.txw2.output.CharacterEscapeHandler;
import com.sun.xml.txw2.output.DataWriter;
import org.xml.sax.SAXException;
import java.io.IOException;
import java.io.Writer;

public class CDATAContentHandler extends DataWriter {
  public CDATAContentHandler( Writer writer ) {
    super( writer, "UTF-8", MinimumEscapeHandler.theInstance );
  }

  @Override
  public void characters( char[] ch, int start, int length ) throws SAXException {
    boolean useCData = false;

    loop:
    for ( int i = start; i < start + length; i++ )
      switch ( ch[ i ] ) {
        case '<': case '>': case '&': useCData = true;
        break loop;
      }

    if ( useCData ) super.startCDATA();
    super.characters( ch, start, length );
    if ( useCData ) super.endCDATA();
  }
}

/**
 * Performs no character escaping. Usable only when the output encoding
 * is UTF, but this handler gives the maximum performance.
 *
 * @author Kohsuke Kawaguchi (kohsuke.kawaguchi@sun.com)
 */
class MinimumEscapeHandler implements CharacterEscapeHandler {

  private MinimumEscapeHandler() {
  }  // no instanciation please

  public static final CharacterEscapeHandler theInstance = new MinimumEscapeHandler();

  public void escape( char[] ch, int start, int length, boolean isAttVal, Writer out )
      throws IOException {
    // avoid calling the Writerwrite method too much by assuming
    // that the escaping occurs rarely.
    // profiling revealed that this is faster than the naive code.
    int limit = start + length;
    for ( int i = start; i < limit; i++ ) {
      char c = ch[ i ];
      if ( c == '&' || c == '<' || c == '>' || c == '\r' || (c == '\n' && isAttVal) || (c == '\"' && isAttVal) ) {
        if ( i != start )
          out.write( ch, start, i - start );
        start = i + 1;
        switch ( ch[ i ] ) {
          case '&':
            out.write( "&amp;" );
            break;
          case '<':
            out.write( "&lt;" );
            break;
          case '>':
            out.write( "&gt;" );
            break;
          case '\"':
            out.write( "&quot;" );
            break;
          case '\n':
          case '\r':
            out.write( "&#" );
            out.write( Integer.toString( c ) );
            out.write( ';' );
            break;
          default:
            throw new IllegalArgumentException( "Cannot escape: '" + c + "'" );
        }
      }
    }

    if ( start != limit )
      out.write( ch, start, limit - start );
  }
}

Quarkus 1.0.0 erschienen

Das „Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.“ ist in der ersten Version erschienen und positioniert sich gegen Spring Boot und Jakarata EE.

Zum Weiterlesen und schauen:

this für kaskadierte Methoden und Builder

Die append(…)-Methoden bei StringBuilder liefern die this-Referenz, sodass sich Folgendes schreiben lässt:

StringBuilder sb = new StringBuilder();
sb.append( "Android oder iPhone" ).append( '?' );

Jedes append(…) liefert das StringBuilder-Objekt, auf dem es aufgerufen wird – wir können also Methoden kaskadiert anhängen oder es bleiben lassen.

Wir wollen diese Möglichkeit bei einem Zauberer (Klasse Wizard) programmieren, sodass die Methoden name(String) und age(int) Spielername und Alter zuweisen. Beide Methoden liefern ihr eigenes Wizard-Objekt über die this-Referenz zurück:

class Wizard {



  String name = "";

  int age;




  Wizard name( String name ) { this.name = name; return this; }

  String name() { return name; }




  Wizard age( int item ) { this.age = item; return this; }

  int age() { return age; }




  String format() {

    return name + " ist " + age;

  }

}

Erzeugen wir einen Wizard, und kaskadieren wir einige Methoden:

Wizard gundalf = new Wizard().name( "Gundalf" ).age( 60 );

System.out.println( gundalf.name() );         // Gundalf

System.out.println( gundalf.format() );       // Gundalf ist 60

Der Ausdruck new Wizard() liefert eine Referenz, die wir sofort für den Methodenaufruf nutzen. Da name(String) wiederum eine Objektreferenz vom Typ Wizard liefert, ist dahinter direkt .age(int) möglich. Die Verschachtelung von name(„Gunalf“).age(60) bewirkt, dass Name und Alter gesetzt werden und der jeweils nächste Methodenaufruf in der Kette über this eine Referenz auf dasselbe Objekt, aber mit verändertem internem Zustand bekommt.

Beispiele dieser Bauart sind in der Java-Bibliothek an einigen Stellen zu finden. Sie werden auch Builder genannt.

Hinweis: Die Methode Wizard name(String) ist mit ihrer Rückgabe praktisch, verstößt aber aus zwei Gründen gegen die JavaBeans-Konvention: Setter dürfen keine Rückgabe haben und müssen immer mit set beginnen. JavaBeans sind also nicht so dieser kompakten Builder-Schreibweise „kompatibel“.

Microsoft arbeitet am OpenJDK mit

https://mail.openjdk.java.net/pipermail/discuss/2019-October/005173.html:

Subject: Microsoft’s Ready do Contribute to OpenJDK

Hi OpenJDK Community,

In the past week Microsoft formally signed the Oracle Contributor Agreement, in which Oracle Inc. promptly acknowledged and welcomed us to the project. On behalf of the Microsoft Java Engineering Team, I’d like to say that we are thrilled to officially join the OpenJDK project and be ready to work with you.

As many of you may know, Microsoft and its subsidiaries are heavily dependent on Java in many aspects, and also offers Java runtimes in its Microsoft Azure cloud to its customers. Microsoft recognizes the immense value that Oracle’s successful and effective stewardship of the OpenJDK project has bought Java and the wider software ecosystem and we look forward to playing our part in contributing back!

The team will initially be working on smaller bug fixes and backports so that we can learn how to be good citizens within OpenJDK. For example, we already understand that discussing changes first before posting patches is preferred and I'm sure there's more for us to learn as well.

The Java engineering team led by Martijn Verburg [1] is already engaged with other Microsoft groups and its subsidiaries who are using Java, as well as its partners in the Java ecosystem such as Azul Systems, Oracle, Pivotal, Red Hat, Intel, SAP and others, and the overall team will be joining the many OpenJDK mailing lists to start conversations and participating.

We look forward to participating in the future of Java.

[1] martijn.verburg at microsoft.com<mailto:martijn.verburg at microsoft.com>

Best regards
Bruno Borges
Product Management for Java,
Microsoft Developer Division

Mehr zu der Geschichte unter

  • https://jaxenter.com/microsoft-ready-contribute-openjdk-163550.html

Spring Framework 5.2 fertig

Ankündigung im Blog https://spring.io/blog/2019/09/30/spring-framework-5-2-goes-ga:

Spring Framework 5.2 requires JDK 8 or higher and specifically supports JDK 11 as the current long-term support branch as well as JDK 13 as the latest OpenJDK release. It comes with many performance improvements (affecting startup time as well as peak performance) and further steps taken towards GraalVM native image support.

This release deeply integrates with Kotlin 1.3 and provides first-class support for Kotlin coroutines on top of Spring WebFlux. Furthermore, it comes with reactive messaging integration for the RSocket protocol as well as reactive transaction management for R2DBC, MongoDB and Neo4j (with datastore integration provided by Spring Data’s modules).

As of the upcoming Spring Boot 2.2 RC1 release, you’ll be able to consume Spring Framework 5.2 GA through start.spring.io!

Wichtige Links:

Finale Variablen und der Modifizierer final

Variablen können mit dem Modifizierer final deklariert werden, sodass genau eine Zuweisung möglich ist. Dieses zusätzliche Schlüsselwort verbietet folglich eine weitere Zuweisung an diese Variable, sodass sie nicht mehr verändert werden kann. Ein üblicher Anwendungsfall sind Konstanten.

int width = 40, height = 12;

final int area = width * height;

final int perimeter;

final var random = Math.random() * 100;

perimeter = width * 2 + height * 2;

area = 200;         //  Compilerfehler
perimeter = 100;    //  Compilerfehler

Im Fall einer versuchten zweiten Zuweisung meldet der Compiler von Eclipse: »The final local variable … cannot be assigned. It must be blank and not using a compound assignment.«; IntelliJ meldet über den Java-Compiler »cannot assign a value to final variable …«.

Java erlaubt bei finalen Werten eine aufgeschobene Initialisierung. Das heißt, dass nicht zwingend zum Zeitpunkt der Variablendeklaration ein Wert zugewiesen werden muss. Das sehen wir im Beispiel an der Variablen perimeter.

Werden Variablen deklariert und initialisiert können final und var zusammen eingesetzt werden; einige Programmiersprachen bieten hier ein eigenes Schlüsselwort, wie val, Java jedoch nicht.

Ausblick

Auch Objektvariablen und Klassenvariablen können final sein. Allerdings müssen die Variablen dann entweder bei der Deklaration belegt werden, oder in einer aufgeschobenen Initialisierung im Konstruktor. Das Schlüsselwort final hat noch zusätzliche Bedeutungen im Zusammenhang mit Vererbung.

JDK 13 ist in Release Candidate Phase

Laut https://mail.openjdk.java.net/pipermail/jdk-dev/2019-August/003250.html:

Per the JDK 13 schedule [1], we are now in the Release Candidate phase.
The stabilization repository, jdk/jdk13, is open for P1 bug fixes per
the JDK Release Process (JEP 3) [2].  All changes require approval via
the Fix-Request Process [3].

If you’re responsible for any of the bugs on the RC candidate-bug list
[4] then please see JEP 3 for guidance on how to handle them.

We’ll tag the first Release Candidate build shortly.

- Mark


[1] https://openjdk.java.net/projects/jdk/13/#Schedule
[2] https://openjdk.java.net/jeps/3
[3] https://openjdk.java.net/jeps/3#Fix-Request-Process
[4] https://j.mp/jdk-rc

Weiteres unter http://www.tutego.de/java/jdk-13-java-13-openjdk13.html.