Archiv der Kategorie: Open Source

WildFly 15 ist final

Siehe Läuft ordentlich auf Java 11. Zur Wiederholung der Versionen:

JBoss 3.2.x. implementiert Java EE-Spezifikation 1.3(.1) (EJB 2.0)

JBoss 4.x: Java EE 1.4 (EJB 2.1, Servlet 2.4, JSF 2.1, …) und am Ende der Serie schon Teile von Java EE 5.

JBoss 5.x: Java EE 5 (EJB 3, JPA 1.0, Servlet 2.5, JSP 1.2)

JBoss 6.x: Java EE 6 (EJB 3.1, CDI 1.0, JPA 2.0, Servlet 3.0, JSF 2.0, JAX-WS 2.2, JAX-RS 1.1, Bean Validation 1.0)

JBoss 7.x: ebenfalls Java EE 6. Implementierung hat modularen Kernel, neue Verzeichnisstruktur.

Wildfly 8.x  Java EE 7 zertifiziert für Voll- und Web-Profil. Vierteljährliche Updates.

Wildfly 14.x. Java EE 8 zertifiziert

Wildfly 15. Aktuellste Version, läuft gut auf Java 11

Hystrix wird nicht weiterentwickelt bleibt in „maintenance mode“

So schreibt es

Hystrix is no longer in active development, and is currently in maintenance mode.

Hystrix (at version 1.5.18) is stable enough to meet the needs of Netflix for our existing applications. Meanwhile, our focus has shifted towards more adaptive implementations that react to an application’s real time performance rather than pre-configured settings (for example, through adaptive concurrency limits). For the cases where something like Hystrix makes sense, we intend to continue using Hystrix for existing applications, and to leverage open and active projects like resilience4j for new internal projects. We are beginning to recommend others do the same.

Netflix Hystrix is now officially in maintenance mode, with the following expectations to the greater community: Netflix will no longer actively review issues, merge pull-requests, and release new versions of Hystrix. We have made a final release of Hystrix (1.5.18) per issue 1891 so that the latest version in Maven Central is aligned with the last known stable version used internally at Netflix (1.5.11). If members of the community are interested in taking ownership of Hystrix and moving it back into active mode, please reach out to

GWT 2.8.2 erschienen
  • Supports running in Java 9. Note that this does not yet mean that GWT can compile Java 9 sources, or support the Java 9 JRE changes, but that a Java 9 JRE can be used to compile a GWT project. Do note that the new --module-path flag is not supported, but-classpath must still be used as in the past.

  • Chrome 61 removed functionality that had been used for reading the absolute top/left values. The internal implementation has been updated to reflect modern standards.

  • Uncaught exception handler will now receive all errors on the page, as handled bywindow.onerror. This may potentially be a breaking change if there were misbehaving scripts on the page. To disable this functionality, set the propertygwt.uncaughtexceptionhandler.windowonerror to IGNORE:

    <set-property name="gwt.uncaughtexceptionhandler.windowonerror" value="IGNORE"/>

For more details, see

Bug fixes
  • LookupMethodCreator creates too large method
  • NativeRegExp should use iframe instance, fixing Edge JIT bug
  • JsProperty getter/setter sometimes were reported as incompatible
  • Instantiating native JsTypes from JSNI results in InternalCompilerException
  • Remove the SUBSIZED characteristic from filtered streams
  • Internal compiler exception when using native JsType varargs in a JsMethod
  • Regression in String.toLowerCase and toUpperCase for some locales, specifically for Turkish
  • Missing bounds check in String.charAt
  • Fix AIOOBE when compiling method references involving varargs.
  • Apply HtmlUnit workaround ensuring that window.onerror is called correctly
  • Migrated lang/jre emulation JSNI to JsInterop to share with J2CL
  • Added ErrorProne to gwt builds
  • Improved compliance with CSP
  • Added emulation for
  • Added emulation for java.lang.reflect.Array
  • JSO.equals/hashcode will delegate to the JS object if it has methods with those names
  • Removed outdated or unused parts of project
  • Migrate guava JRE emulation to GWT
  • HtmlUnit tests are now run in batch mode

For more detail, see the issue tracker and the commit log.

Google Guava steigt (endlich) auf Java 8 um

Die News unter

Significant API additions and changes


  • Function, Predicate and Supplier: changed to extend the new java.util.functioninterfaces with the same names.
  • Optional: added toJavaUtil and fromJavaUtil methods for easy conversion between Guava’s Optional and java.util.Optional.
  • Objects: removed deprecated firstNonNull and toStringHelper methods (both found on MoreObjects since Guava 18.0).


New default methods on ConcurrentMap that were added in Java 8 are now implemented and safe to use for Cache.asMap() views.


Many APIs in collect now have better implementations of many of the default methods added to Collection and Map types in Java 8.

New classes

  • Comparators: With the addition of many useful methods to the Comparator type in Java 8, Ordering now provides little benefit. Comparators is a new location for methods on Orderingthat still don’t have a good equivalent in the JDK.
  • Streams: Utility class for working with Includes methods for creating streams (such as stream(Iterable), stream(Optional) and concat(Stream...)) and methods that do things with streams (such as findLast(Stream)).
  • MoreCollectors: Factories for objects; note that Collectors for Guava’s collection types are generally found on those types themselves rather than here.
  • Interners.InternerBuilder: Builder for Interner instances, with options similar to those found on MapMaker. Created with Interners.newBuilder().

Removed classes

  • MapConstraint and MapConstraints: deprecated since 19.0.


  • FluentIterable: added stream() method.
  • ForwardingBlockingDeque: deprecated; moved to util.concurrent.
  • Immutable* types: added methods to all named toImmutable[Type]() (e.g. ImmutableList.toImmutableList()) which return a Collector for collecting a Stream into an immutable collection/map object. As with most methods that create Collectors, these are generally intended to be used as static imports.
  • Multimap: added forEach(BiConsumer) method.
  • Multimaps: added toMultimap and flatteningToMultimap methods returning Collectorobjects that collect to a Multimap.
  • Multiset: added forEachEntry(ObjIntConsumer) method.
  • Maps: added toImmutableEnumMap methods returning Collector objects that collect to an ImmutableMap with enum keys.
  • Sets: added toImmutableEnumSet method returning a Collector that collects to an ImmutableSet of enums.
  • Tables: added toTable methods returning Collector objects that collect to a Table.
  • RangeSet: added default addAll(Iterable<Range>), removeAll(Iterable<Range>) and enclosesAll(Iterable<Range>) methods.
  • ImmutableRangeSet: added copyOf(Iterable<Range>), unionOf(Iterable<Range>), union(RangeSet), intersection(RangeSet) and difference(RangeSet) methods.
  • TreeRangeSet: added create(Iterable<Range>) method.
  • A number of rarely-used methods on concrete implementations of Guava collection types that aren’t present on the interface they implement have been deprecated. These include: ArrayListMultimap.trimToSize(), TreeMultimap.keyComparator(), and TreeBasedTable.row/columnComparator().

  • MoreFiles: New class which contains methods similar to those in Files, but for use with java.nio.file.Path objects.
  • This includes deleteRecursively and deleteDirectoryContents methods which are secure against race conditions that Java previously had no way of dealing with provided that the FileSystem supports SecureDirectoryStream (modern Linux versions do; Windows [NTFS at least] does not). For security, these will throw an exception if SecureDirectoryStream is not supported unless RecursiveDeleteOption.ALLOW_INSECURE is passed when calling the method.


  • Most classes: added constrainToRange([type] value, [type] min, [type] max) methods which constrain the given value to the closed range defined by the min and max values. They return the value itself if it’s within the range, the min if it’s below the range and the max if it’s above the range.


  • ForwardingBlockingDeque: added; moved from common.collect because BlockingDeque is a concurrent type rather than a standard collection (it’s defined in java.util.concurrent).
  • AtomicLongMap: added a number of methods such as accumulateAndGet(K, LongBinaryOperator) that take advantage of new Java functional types.
  • Monitor: added newGuard(BooleanSupplier).
  • MoreExecutors: removed sameThreadExecutor(); deprecated since 18.0 in favor of directExecutor() (preferable) or newDirectExecutorService().

GWT 2.8.0 ist raus

Details zu den Änderungen unter Toll ist die Unterstützung von Java 8.

  • Started using ES6 Maps when available for HashMap/HashSet that yields up 3x performance improvements.
  • Partial support for Java 8 standard library APIs (see below for full list).
  • Source level set to Java 8.
  • Static and default methods in interfaces aren’t visible to generators. If you want to take advantage of those Java-8isms, you’re encouraged to switch to an annotation processor. This could break existing build if an interface is changed to turn a non-default method into a default method.
  • Emulate
  • Emulate Optional<T> and its int, long, double variants.
  • Emulate Objects.requireNonNull() with message Supplier.
  • Fix Math.min/max(float/double) emulation behavior.
  • Emulate Character.isBmpCodePoint().
  • Emulate CharSequence.chars().
  • Emulate java.lang.SecurityException.
  • Emulate Java 8 API of
  • java.util.Arrays,
  • java.util.ArrayDeque,
  • java.math.BigInteger,
  • java.util.BitSet,
  • java.util.Comparator,
  • java.util.function,
  • java.util.Iterator,
  • java.lang.Iterable,
  • java.util.IntSummaryStatistics/LongSummaryStatistics/DoubleSummaryStatistics
  • java.util.Collection/Lists/Queues,
  • java.util.Map,
  • java.util.logging.Logger,
  • java.util.PrimitiveIterator,
  • java.util.Spliterator,
  • java.util.StringJoiner

Update von Retrolambda

Java 8 Sprachfeatures für Java 7, 6, 5 VM. Details unter Die Updates von letzter Woche:

Retrolambda 2.3.0 (2016-04-30)

  • Optimize generated code to reduce method count (Issue #81)
  • Fix method reference to protected method in base class in other package failing with IllegalAccessError (Issue #89)

Retrolambda 2.2.0 (2016-04-29)

  • Backports calls to Objects.requireNonNull, improving JDK 9 support (Issue #75)
  • Optimize generated code to reduce method count (Issue #81)

WildFly 10 Beta herausgegeben

Detail unter und, kurz zusammengefasst:

  • Continued Java EE7 Support

  • Java 8+ Required

  • ActiveMQ Artemis

  • JavaScript Support with Hot Reloading

  • Offline CLI Support For Domain Mode

  • HA Singleton Deployments

  • Migration Operations for Legacy Subsystems

  • Capabilities and Requirements

  • Hibernate 5

  • Infinispan 8

Guava 19.0-rc1 herausgekommen

Die Änderungen führt auf.

Von meiner Seite bin ich nicht mehr so scharf auf Guava, ich komme mittlerweile seit Java 8 ganz gut ohne aus. Klar, könnte ich mehr Guava nutzen, doch ich kann auch ohne, auch wenn ich einmal eine Argument mehr an eine Methode setze.

Heiß her geht auch die Diskussion auf einen Java 8-Umstieg (!topic/guava-discuss/fEdrMyNa8tA). Die Google Entwickler wissen nicht so recht, was der beste Weg ist, da man bemüht ist, mit einer neuen Java 8-Version keinen alten Code zu brechen.