Skip to main content

From ZX Spectrum over Clouds To Winning the Java Duke's Choice Award-an airhacks.fm podcast

by admin at April 18, 2021 05:09 PM

Subscribe to airhacks.fm podcast via: spotify| iTunes| RSS

The #136 airhacks.fm episode with Prof. dr. Matjaz Juric (@matjazbj) about:
"distributed computing, Java EE, microservices with Java before and with MicroProfile, SOA, orchestration challenges, BPEL, BPMN, clouds and KumuluzEE"
is available for download.

by admin at April 18, 2021 05:09 PM

Hashtag Jakarta EE #68

by Ivar Grimstad at April 18, 2021 09:59 AM

Welcome to the sixty-eighth issue of Hashtag Jakarta EE!

We have a date for Jakarta EE 9.1!

Eclipse GlassFish 6.1.0.RC1 passes the Jakarta EE 9.1 TCK and is available for download. The TCK project is in the process of wrapping up everything for the release. We plan to initiate the review ballot for the Jakarta EE 9.1 specifications on April 30, which means that the artifacts will be released to Maven Central on May 14th. This is a soft launch as we have been doing the last couple of releases, so the official release date with all the marketing splash around it will be May 25th.

Worth noting for this release is that it looks like GlassFish won’t be alone as a compatible implementation when the specification is ratified. A number of vendors are working hard to have their implementations available along with Glassfish for the release review ballot.

When the Jakarta EE Platform team set April 15 as a deadline for specifications to file for plan reviews in order to be considered for the next Jakarta EE release, we didn’t really know what to expect. There have been quite a few efforts to write down expectations, such as the Jakarta EE AmbassadorsGuide to Contributing to Jakarta EE 10, Arjan TijmsJava for the enterprise: What to expect in Jakarta EE 10 and Greg WilkinsLess is More? Evolving the Servlet API!. But would this crystalize into concrete plans?

I guess it is safe to say that we were blown away by the number of detailed plans and outlines submitted as pull requests to the Jakarta EE Specifications repository. Just take a look at the list below grouped by major and minor updates to the specifications.

Major updates
Jakarta Authentication 4.0
Jakarta Authorization 3.0
Jakarta Concurrency 3.0
Jakarta Expression Language 5.0
Jakarta Faces 4.0
Jakarta JSON Binding 3.0
Jakarta RESTful Web Services 4.0
Jakarta Security 3.0
Jakarta Servlet 6.0
Jakarta SOAP with Attachments 3.0
Jakarta Standard Tag Library 3.0
Jakarta XML Binding 4.0
Jakarta XML Web Services 4.0

Minor updates
Jakarta Activation 2.1
Jakarta Connectors 2.1
Jakarta JSON Processing 2.1
Jakarta Mail 2.1
Jakarta MVC 2.1
Jakarta Persistence 3.1
Jakarta Server Pages 3.1
Jakarta WebSocket 2.1

I can’t wait to dive into the details of these plans as they progress through the plan reviews stipulated by the Jakarta EE Specifiation Process. Take a look at the JESP Guide for a simple walk-through of the process.

In addition to the efforts around Jakarta EE 9.1 and Jakarta EE 10, there are ongoing discussions about the alignment between Jakarta EE and MicroProfile. These discussions take place in the CN4J Alliance. Read Jakarta EE/MicroProfile Alignment Survey Results! by Reza Rahman to see how the community responded to the alternatives being discussed.


by Ivar Grimstad at April 18, 2021 09:59 AM

Your Voice Matters: Take the Jakarta EE Developer Survey

by dmitrykornilov at April 17, 2021 11:36 AM

The Jakarta EE Developer Survey is in its fourth year and is the industry’s largest open source developer survey. It’s open until April 30, 2021. I am encouraging you to add your voice. Why should you do it? Because Jakarta EE Working Group needs your feedback. We need to know the challenges you facing and suggestions you have about how to make Jakarta EE better.

Last year’s edition surveyed developers to gain on-the-ground understanding and insights into how Jakarta solutions are being built, as well as identifying developers’ top choices for architectures, technologies, and tools. The 2021 Jakarta EE Developer Survey is your chance to influence the direction of the Jakarta EE Working Group’s approach to cloud native enterprise Java.

The results from the 2021 survey will give software vendors, service providers, enterprises, and individual developers in the Jakarta ecosystem updated information about Jakarta solutions and service development trends and what they mean for their strategies and businesses. Additionally, the survey results also help the Jakarta community at the Eclipse Foundation better understand the top industry focus areas and priorities for future project releases.

A full report from based on the survey results will be made available to all participants.

The survey takes less than 10 minutes to complete. We look forward to your input. Take the survey now!


by dmitrykornilov at April 17, 2021 11:36 AM

Survival Guide for the Java Architect in the Cloud Era

by otaviojava at April 15, 2021 06:37 PM

Cloud Final Version of NIST Cloud Computing Definition Published Agile Manifesto 97 Things Every Cloud Engineer Should Know: Collective Wisdom from the Experts  Infrastructure as Code: Dynamic Systems for the Cloud Age Getting GitOps right CI/CD Github Action Tekton Pipelines  Cloud Native Architecting Cloud Native Applications: Design high-performing and cost-effective applications for the cloud What […]

by otaviojava at April 15, 2021 06:37 PM

Java 16: a minimalistic Apache Maven / pom.xml

by admin at April 14, 2021 02:57 PM

To use Java 16 with Apache Maven, you will have to set the following properties:

<maven.compiler.source>16</maven.compiler.source>
<maven.compiler.target>16</maven.compiler.target>
<java.version>16</java.version>

With the following pom.xml:


<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.airhacks</groupId>
    <artifactId>java16</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>
        </plugins>
    </build>
    <dependencies>
	<dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.1</version>
            <scope>test</scope>
	</dependency>
    </dependencies>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>16</maven.compiler.source>
        <maven.compiler.target>16</maven.compiler.target>
        <java.version>16</java.version>
    </properties>
    
</project>    

you should be able to use e.g. text blocks:


public class Java16Test {
    @Test
    public void hello() {
        var message = """
            hello, java 16
                """;
        System.out.println(message);
    }
}    


by admin at April 14, 2021 02:57 PM

#ToniteWithMe Sneak Peek | The Two Minutes Tuesday 021 | Announcement

by Markus Karg at April 13, 2021 09:00 PM

Be with us, when Andres and me are LIVE HACKING Maven’s source code on this Friday’s Live Show #ToniteWithMe on 20:00 CET right here on this channel!

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂

CU!


by Markus Karg at April 13, 2021 09:00 PM

Less is More? Evolving the Servlet API!

by gregw at April 13, 2021 06:19 AM

With the release of the Servlet API 5.0 as part of Eclipse Jakarta EE 9.0 the standardization process has completed its move from the now-defunct Java Community Process (JCP) to being fully open source at the Eclipse Foundation, including the

by gregw at April 13, 2021 06:19 AM

Writing Boring Software: From WebLogic over GlassFish to Quarkus--an airhacks.fm podcast

by admin at April 12, 2021 06:22 AM

Subscribe to airhacks.fm podcast via: spotify| iTunes| RSS

The #135 airhacks.fm episode with Antonio Goncalves (@agoncal) about:
"learn once, apply anywhere", Java backends, WebLogic, GlassFish, publishing books and Quarkus experiences
is available for download.

by admin at April 12, 2021 06:22 AM

Hashtag Jakarta EE #67

by Ivar Grimstad at April 11, 2021 09:59 AM

Welcome to the sixty-seventh issue of Hashtag Jakarta EE!

One of the most exciting things that happened in the Jakarta EE space this week is that the Jakarta EE Platform project decided to start working on a new Jakarta EE Core Profile. The Pull Request to start the process of creation- and plan reviews from the Jakarta EE Specification Committee has been created. I will post more when work progresses.

If you are involved in a Jakarta EE specification project, do remember to submit a request for plan review by April 15. This will make it possible for the platform team to get an overview, and plan for the content of the next release. Refer to the JESP Guide for useful pointers and links to help you navigate the Jakarta EE Specification Process (JESP).

The 2021 Jakarta EE Developer Survey is now open. This has become an annual tradition and is your chance to influence the direction of the Jakarta EE working group. It takes less than 8 minutes to complete.

Take the 2021 Jakarta EE Developer Survey!

Another exciting thing that happened this week is that Microsoft announced their build of OpenJDK. Of course, I went ahead and installed it directly 🙂

$ java -version
openjdk version "11.0.10" 2021-01-19
OpenJDK Runtime Environment Microsoft-18724 (build 11.0.10+9)
OpenJDK 64-Bit Server VM Microsoft-18724 (build 11.0.10+9, mixed mode)

by Ivar Grimstad at April 11, 2021 09:59 AM

Spring / Summer Java and Web Conferences, Workshops and Shows

by admin at April 11, 2021 09:44 AM

  1. airhacks.live workshop: Best Practices, Hacks and Frontend Patterns with Vanilla Web Components [online event]
    web apps best practices airhacks.live virtual workshop 15 Apr 2021
    https://airhacks.live
  2. Tech Flow Europe: It's 2021: ...and you are still using JavaScript frameworks? [online event]
    online session 16 Apr 2021
    https://www.meetup.com/airhacks/events/277419682/
  3. airhacks.tv Q&A: 86th airhacks.tv [online event]
    live streaming Q & A show 3 May 2021
    https://airhacks.tv
  4. airhacks.live workshop: Building Mobile Apps with Vanilla Web Components, redux and lit-html [online event]
    mobile apps best practices airhacks.live virtual workshop 6 May 2021
    https://airhacks.live
  5. Monitoring and Observability Day: Wie überlebt man in den Wolken? Survival-Training mit Monitoring, Observability und Metriken (#slideless) [online event]
    online session 18 May 2021
    https://www.continuouslifecycle.de/lecture_compact1.php?id=12950&source=0
  6. Java Day Istanbul: Web Components Are Made For YOU [online event]
    online session 28 May 2021
    https://www.javaday.istanbul/
  7. airhacks.live workshop: Building Java Applications on AWS [online event]
    building Java apps on AWS: airhacks.live virtual workshop 8 Jul 2021
    https://airhacks.live

Also checkout: meetup.com/airhacks/ and airhacks.eventbrite.com/


by admin at April 11, 2021 09:44 AM

Jakarta EE/MicroProfile Alignment Survey Results!

by Reza Rahman at April 10, 2021 10:16 PM

As you are likely aware, Java EE has transitioned to Open Source governance in the Eclipse Foundation as Jakarta EE. MicroProfile has been moving forward as an independent initiative to optimize enterprise Java for microservices architectures. The Cloud Native for Java (CN4J) Alliance has recently been formed to promote better alignment between Jakarta EE and MicroProfile.

One of the key issues to sort out is how Jakarta EE can consume MicroProfile specifications (such as MicroProfile Configuration). There are several alternatives as to how this could be done. These alternatives were put into a survey for the community to weigh in. In addition to choosing the option respondents believe to be best, they were able to provide comments justifying their preferred alternative. The results of the survey are summarized here. The results have been shared with the CN4J community and key decision makers.

Survey Results

More than 200 people filled out the survey. Even more remarkably, there were more than 50 comments representing the voice of the community. A fairly strong majority (57.73%) of developers want some MicroProfile specifications to move to Jakarta EE including the namespace.

Jakarta EE/MicroProfile survey results

The results are similar to what earlier surveys have indicated and congruent with the official Jakarta EE Ambassadors joint position. It is remarkable how consistent the community view has been, even over a period of time.

The Voice of the Community

It is impossible to do justice to all the people that provided comments. Each one of the comments is invaluable. The following is a decent sampling representing the majority opinion.

“MicroProfile should evolve APIs that eventually get absorbed by Jakarta EE. MicroProfile applications should eventually be able to run with pure Jakarta EE APIs.”

“Moving MicroProfile specs into Jakarta EE including namespace will make clear where the longer term specs are maintained. Also, for MicroProfile users it’s a very easy migration path.”

“I think no matter which of these options is chosen there is going to be an effect on either end users, or developers. Therefore, I would rather make the large upfront breaking changes all at once and merge the two into the same namespace. Then, have consistency going forward.”

“I would see the movement from org.eclipse.microprofile to the jakarta namespace as a sign of maturity (and success) for MicroProfile.”

“Option A2 has fewer cons and is more end user friendly.”

“Using a different namespace makes it clear what version and expectations (e.g. backward compatibility) the user is making. Moving without a namespace is confusing.”

“The aim of a specification should always be to make something as simple and clear as possible. The entry barriers and opportunities for error for new and inexperienced developers must be as low as possible. An inconsistent namespace or even the possibility of circular dependencies make the use simply too complicated and difficult. At the end of the day, it’s all about the economic and productive development of applications.”

“Move some MicroProfile specifications (e.g. MP Config when its stable) to Jakarta EE including the namespace.”

Source Data

I really hope the results help pave the way for sensible decisions on Jakarta EE and MicroProfile alignment. For me, gathering input and listening to people that are not necessarily involved in the lower level details of specification development is extremely important.

The Eclipse Foundation very graciously ran the survey and shared the source data publicly. Reading all the comments in full is especially insightful.


by Reza Rahman at April 10, 2021 10:16 PM

[LIVESTREAM] Andres Almiray LIVE HACKING Maven Plugins | Tonite with me | Java Latenite

by Markus Karg at April 10, 2021 12:46 PM

#ToniteWithMe hacking on #MavenPlugins in #Java is #JavaChampion Andres Almiray.

Ever wanted to watch some Java professionals hacking on the source code of Maven plugins? Then this LIVE STREAM is what you definitively NOT want to miss! Join this LIVE SESSION on Friday at 20:00 CET. Just type your own questions into the chat while the show runs!

Andreas and me did a live hack of the Maven Shade Plugin: Andres fixed issue [MSHADE-382] by adding a `skip` property to the plugin, following best practices and conventions, adding unit test and integration test utilizing the Maven Invoker Plugin, then filing PR 90 — in just one hour. #Amazing #ASFMavenProject #Java

If you like this live show, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂


by Markus Karg at April 10, 2021 12:46 PM

NoSQL, the Cloud, and Java: Part 1: The NoSQL Approaches

by otaviojava at April 07, 2021 02:02 PM

Learn how NoSQL, the cloud, and Java interact, the various kinds of non-relational databases you’ll encounter, and the tradeoffs you can expect. https://dzone.com/articles/framewars-part-1

by otaviojava at April 07, 2021 02:02 PM

What's New in the Payara Platform April Release?

by Debbie Hoffman at April 07, 2021 01:00 PM

This month we release Payara Platform Enterprise 5.27.0 (request here) with 18 improvements and 3 new features, including an update to the previously released Upgrade Tool, an automated JBatch Job execution data cleanup feature, and the addition of a pluggable Notifier API with the ability to create your own notifiers.

Meanwhile, the Payara Platform Community 5.2021.2 (download here) includes improvements for running Jakarta EE 9 applications. 

Don't miss our release overview virtual event on the 20th of April, which is now open for registrations on Meetup here. 

Read more below to find out the details.

 Payara Platform  Download Here 


by Debbie Hoffman at April 07, 2021 01:00 PM

How to retrieve DTOs from your Envers Audit Logs

by Thorben Janssen at April 06, 2021 12:00 PM

The post How to retrieve DTOs from your Envers Audit Logs appeared first on Thorben Janssen.

Hibernate Envers is a popular library that automates the creation of an audit log. As I’ve shown in previous articles, it logs all write operations performed using your entity classes in an audit log and provides a flexible API to query data from that log. Based on these articles, I got recently asked if Hibernate […]

The post How to retrieve DTOs from your Envers Audit Logs appeared first on Thorben Janssen.


by Thorben Janssen at April 06, 2021 12:00 PM

Hashtag Jakarta EE #66

by Ivar Grimstad at April 04, 2021 09:59 AM

Welcome to the sixty-sixth issue of Hashtag Jakarta EE!

Jakarta EE 9.1 is on track for the mid-May release. GlassFish 6.1 now passes the TCK and a release candidate will be made available this week.

Meanwhile, the work with planning for the next Jakarta EE release goes on. We are getting very close to be proposing a new profile in addition to the current Full Platform and Web Profile. This profile will most likely be called Jakarta EE Core Profile and be specifically targeted at smaller runtimes for microservices and capable of producing minimal cloud-native images.

For the other component specifications, please do remember to submit a request for plan review by April 15. This will make it possible for the platform team to get an overview, and plan for the content of the next release. We will also shortly invite all specification projects to participate in a community meeting. Stay tuned and look out for the invite that will be socialized on all appropriate channels when we have nailed down the details.

I will encourage specification projects to open calls to help drive their work forward. Since we currently don’t meet in the hallways at events and conferences, these meetings are an important way of having discussions in realtime. Makes life on the mailing lists so much easier afterward…

We have created the Specifications Calendar specifically for this purpose. All the project leads of Jakarta EE specification projects have been given permissions to add events to the calendar.

As an inspiration for topics, please check out Arjan’s excellent article Java for the enterprise: What to expect in Jakarta EE 10 in the Java Magazine.

I also want to point you to the newly released Jakarta EE white paper and my accompanying article Why Java Developers Continue to Rely on Jakarta EE.


by Ivar Grimstad at April 04, 2021 09:59 AM

Get your Drone License NOW! | Head Crashing Informatics 30

by Markus Karg at April 03, 2021 03:00 PM

Hey guys! How’s it going?

Learn everything you need to do to LEGALLY fly a drone in Europe in this short video!

Since January 1st, flying a #drone in Europe is only possible if the owner is officially registered with the local authorities, and if the pilot has a license from the european authorities (#EASA).

My wife and me just recently passed the exam, are now registered and own a pilot #license form the LBA (Luftfahrtbundesamt), the German authorities, and we want to show you in this video all the needed steps, how to do them, how easy they are, and how long they need, so you can LEGALLY fly all over Europe by investing just one single day. 🙂

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon. Thanks!

Stay safe and… Party on!


by Markus Karg at April 03, 2021 03:00 PM

Undertow AJP balancer. UT005028: Proxy request failed: java.nio.BufferOverflowException

April 02, 2021 09:00 PM

Wildfly provides great out of the box load balancing support by Undertow and modcluster subsystems
Unfortunately, in case HTTP headers size is huge enough (close to 16K), which is so actual in JWT era - pity error happened:

ERROR [io.undertow.proxy] (default I/O-10) UT005028: Proxy request to /ee-jax-rs-examples/clusterdemo/serverinfo failed: java.io.IOException: java.nio.BufferOverflowException
 at io.undertow.server.handlers.proxy.ProxyHandler$HTTPTrailerChannelListener.handleEvent(ProxyHandler.java:771)
 at io.undertow.server.handlers.proxy.ProxyHandler$ProxyAction$1.completed(ProxyHandler.java:646)
 at io.undertow.server.handlers.proxy.ProxyHandler$ProxyAction$1.completed(ProxyHandler.java:561)
 at io.undertow.client.ajp.AjpClientExchange.invokeReadReadyCallback(AjpClientExchange.java:203)
 at io.undertow.client.ajp.AjpClientConnection.initiateRequest(AjpClientConnection.java:288)
 at io.undertow.client.ajp.AjpClientConnection.sendRequest(AjpClientConnection.java:242)
 at io.undertow.server.handlers.proxy.ProxyHandler$ProxyAction.run(ProxyHandler.java:561)
 at io.undertow.util.SameThreadExecutor.execute(SameThreadExecutor.java:35)
 at io.undertow.server.HttpServerExchange.dispatch(HttpServerExchange.java:815)
...
Caused by: java.nio.BufferOverflowException
 at java.nio.Buffer.nextPutIndex(Buffer.java:521)
 at java.nio.DirectByteBuffer.put(DirectByteBuffer.java:297)
 at io.undertow.protocols.ajp.AjpUtils.putString(AjpUtils.java:52)
 at io.undertow.protocols.ajp.AjpClientRequestClientStreamSinkChannel.createFrameHeaderImpl(AjpClientRequestClientStreamSinkChannel.java:176)
 at io.undertow.protocols.ajp.AjpClientRequestClientStreamSinkChannel.generateSendFrameHeader(AjpClientRequestClientStreamSinkChannel.java:290)
 at io.undertow.protocols.ajp.AjpClientFramePriority.insertFrame(AjpClientFramePriority.java:39)
 at io.undertow.protocols.ajp.AjpClientFramePriority.insertFrame(AjpClientFramePriority.java:32)
 at io.undertow.server.protocol.framed.AbstractFramedChannel.flushSenders(AbstractFramedChannel.java:603)
 at io.undertow.server.protocol.framed.AbstractFramedChannel.flush(AbstractFramedChannel.java:742)
 at io.undertow.server.protocol.framed.AbstractFramedChannel.queueFrame(AbstractFramedChannel.java:735)
 at io.undertow.server.protocol.framed.AbstractFramedStreamSinkChannel.queueFinalFrame(AbstractFramedStreamSinkChannel.java:267)
 at io.undertow.server.protocol.framed.AbstractFramedStreamSinkChannel.shutdownWrites(AbstractFramedStreamSinkChannel.java:244)
 at io.undertow.channels.DetachableStreamSinkChannel.shutdownWrites(DetachableStreamSinkChannel.java:79)
 at io.undertow.server.handlers.proxy.ProxyHandler$HTTPTrailerChannelListener.handleEvent(ProxyHandler.java:754)

The same request directly to backend server works well. Tried to play with ajp-listener and mod-cluster filter "max-*" parameters, but have no luck.

Possible solution here is switch protocol from AJP to HTTP which can be bit less effective, but works well with big headers:

/profile=full-ha/subsystem=modcluster/proxy=default:write-attribute(name=listener, value=default)

April 02, 2021 09:00 PM

Why Java Developers Continue to Rely on Jakarta EE

by Ivar Grimstad at March 31, 2021 12:36 PM

Over the past year, the Eclipse Foundation spoke to leading Java developers around the world to discuss why they rely on Jakarta EE and the unique benefits of using Jakarta EE technologies. Their input is captured in our white paper, which describes the important advantages Jakarta EE offers today and for the future.

Download the Jakarta EE white paper!

They’re Looking Ahead, Not Back

With Jakarta EE’s long history as Java EE, it’s sometimes easy for developers to dismiss the technology as yesterday’s approach. But Jakarta EE technologies are embedded, and relied upon, in a way no other technologies are. Here are some examples you might not be aware of:

  • Apache Tomcat implements several Jakarta EE specifications
  • Eclipse Jetty is a certified implementation of Jakarta Servlet 5.0
  • Spring Boot embeds Eclipse Jetty or Apache Tomcat as a runtime


Open Specifications Bring Important Advantages

One of the advantages every one of the developers raised was the value of the specification-based approach to technologies in Jakarta EE.

The clear boundary between fully tested specifications and underlying implementations means developers can easily switch between the implementations with minimal impact on the application code. This agility saves considerable time, effort, and money when changes are required.

Jakarta EE Provides a Unique Combination of Features and Functions

The developers also described a combination of strategic and technical advantages that aren’t available in any other platform. Some of the main Jakarta EE benefits they noted include:

  • Stability and backward compatibility. Jakarta EE provides a mature and proven foundation for innovation that allows organizations to fully leverage the investments they’ve already made in enterprise Java applications.
  • Architectural flexibility. Organizations can support cloud-based microservices architectures, as well as traditional, monolithic architectures. They can also seamlessly incorporate newer technologies, such as MicroProfile, Docker containers, and Kubernetes orchestration.
  • Speed and simplicity. A Jakarta EE application can be set up with significantly less configuration compared to other frameworks.
  • Development and deployment freedom. Developers can use any Jakarta EE-compatible runtime, and they can implement and blend whichever aspects of the application server are needed to leverage Jakarta EE capabilities in a modern and efficient way.
  • Longevity. The open, vendor-neutral, and community-driven approach at the Eclipse Foundation ensures applications developed using Jakarta EE will remain relevant and usable over the long term.

Get the Full Story

These insights are just a few of the reasons leading Java developers remain committed to Jakarta EE. For the complete story, download the white paper.

Visit the Jakarta EE website to learn more about Jakarta EE and explore the Jakarta EE specifications.


by Ivar Grimstad at March 31, 2021 12:36 PM

The Payara Monthly Catch: March 2021

by Priya Khaira-Hanks at March 31, 2021 09:19 AM

It's that time again, our March monthly catch! The "fishes" in our "net" are Java, Jakarta EE, Open Source and Microprofile articles, news stories, videos and podcasts we've found useful and interesting, as well as a few Payara Services updates.

Big news this month is the General Availability release of Java 16. Articles under the 'Java EE' subheading in our Community news section below provide expert opinions on what's new in this release.


by Priya Khaira-Hanks at March 31, 2021 09:19 AM

Migration Path to JDK 16 | The Two Minutes Tuesday 020 | Modern Java

by Markus Karg at March 30, 2021 09:00 PM

Migrate to #JDK16 NOW! #Java 16 is here since last week, and there is no excuse to stay with any older versions! There is a simple four-steps migration path to more speed, more performance, more fun!

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂

CU!


by Markus Karg at March 30, 2021 09:00 PM

Polymorphic association mappings of independent classes

by Thorben Janssen at March 30, 2021 12:00 PM

The post Polymorphic association mappings of independent classes appeared first on Thorben Janssen.

JPA and Hibernate make it very easy to model associations between entities. You can model associations between 2 concrete classes or model a polymorphic association to an inheritance hierarchy. These mappings are more than sufficient for almost all of your association mappings. But sometimes, you might want to model a polymorphic association to independent entity […]

The post Polymorphic association mappings of independent classes appeared first on Thorben Janssen.


by Thorben Janssen at March 30, 2021 12:00 PM

Hashtag Jakarta EE #65

by Ivar Grimstad at March 28, 2021 09:59 AM

Welcome to the sixty-fifth issue of Hashtag Jakarta EE!

It looks like Jakarta EE 9.1 may be delivered sometime in May. The Jakarta EE Platform project discussed the possibility for a release date in mid-May at this week’s platform call. There are still a couple of details to be sorted out before a final date can be announced. Stay tuned for updates.

The platform team has also started discussions regarding adding a profile to the next release of Jakarta EE. This discussion is currently going on the mailing list.

On Wednesday, March 31, I am giving a short keynote at JakartaOne LivesStream – Russian. What’s interesting about this one is that it will be in Russian. Since I, unfortunately, don’t speak Russian, the organizers have been very helpful in translating my talk and adding a Russian audio track. I hope you will enjoy it!

As you can see, the program for JakartaOne Livestream – Russian is packed with great content!

If you still can’t get enough of Jakarta EE, please don’t hesitate to contact us if you want to host us at your local JUG or Meetup. We still offer free use of Crowdcast for JUGs for streaming your events.

Tanja and I are always eager to visit you and talk about Jakarta EE. We have visited a lot of JUGs in the last 6 months. And we want to visit more. If you want your JUG on this list, you know what to do. Contact us!

At the end, I want to point you to the new Adoptium web site that was just recently launched. This is your one stop shop to download prebuilt OpenJDK binaries for free.


by Ivar Grimstad at March 28, 2021 09:59 AM

NoSQL design pitfalls with Java [TDC]

by otaviojava at March 25, 2021 09:39 AM

References Frameworks DataStax Mapper Neo4j – OGM Object Graph Mapper Morphia Neo4j from Java Apache TinkerPop openCypher Cassandra driver JRedis MongoDB driver Spring Data Micronaut Quarkus Jakarta EE/NoSQL Hibernate OGM Books NoSQL Distilled: A Brief Guide to the Emerging World of Polyglot Persistence Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems […]

by otaviojava at March 25, 2021 09:39 AM

Hashtag Jakarta EE #64

by Ivar Grimstad at March 21, 2021 10:59 AM

Welcome to the sixty-fourth issue of Hashtag Jakarta EE!

$ java -version
openjdk version "16" 2021-03-16
OpenJDK Runtime Environment AdoptOpenJDK (build 16+36)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 16+36, mixed mode, sharing)

Java 16 contains a lot of goodies for us, so go ahead and download it to give it a try. or me, the most important feature in JDK 16 is Records (JEP 395). The reason for this is that it reduces the amount of boilerplate code needed. The possibility to write record Point(int x, int y) { } rather than the entire class listed below really appeals to me. The code never written is the best code, as it is guaranteed not to contain any bugs.

class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    int x() { return x; }
    int y() { return y; }

    public boolean equals(Object o) {
        if (!(o instanceof Point)) return false;
        Point other = (Point) o;
        return other.x == x && other.y = y;
    }

    public int hashCode() {
        return Objects.hash(x, y);
    }

    public String toString() {
        return String.format("Point[x=%d, y=%d]", x, y);
    }
}

I participated in three sessions at JavaLand 2021. First out on Tuesday was Jakarta EE 9 and Beyond which was followed by a Jakarta EE Panel. On Wednesday, it was time for Mobile Java Web Applications with MVC and OpenDDR where I was presenting together with Werner Keil. Despite some technical difficulties with the streaming platform on Tuesday, the conference went smoothly. Let’s hope that we will be back in Phantasialand for next year’s edition!

Work with Jakarta EE 9.1 continues. An agenda item for the platform call this week is to set a release date for Jakarta EE 9.1. We have also started the work by looking ahead towards the next releases. Currently, there are some interesting discussions happening on the Jakarta EE Platform mailing list regarding the definition of new profile specifications.

Also, note that the platform team requests plan reviews from the specification projects to be ready for ballot by April 15 in order to be a candidate for the next release. If you are unsure what to do for a plan review, check out the JESP Guide.


by Ivar Grimstad at March 21, 2021 10:59 AM

Crashing JavaLand 2021 [Such fun! Such fun!] | Head Crashing Informatics 29 | Satire

by Markus Karg at March 21, 2021 09:57 AM

Hey guys! How’s it going?

The somewhat different report from #JavaLand 2021… Such fun!

[ironic]

Top of the evening to you, enchanting subscribers! Some people told me that I do sound arrogant sometimes, and to proof them right I do present to you, with all my gracious magnanimity, hereby this absolutely outstanding report from JavaLand 2021. Produced by the best #Java programmer I ever heard of, if not the best one ever, feel honoured to enjoy this exclusive insider report from this years top Java conference in Europe! Such fun! Such fun! 😉

[/ironic]

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂

Jewellery by stkarg.design (https://www.instagram.com/stkarg.design/)

A Peilung 0 Production (https://www.youtube.com/channel/UCsbwCYGr9sZMeF0z2GpEk8g)

Stay safe and… Party on!


by Markus Karg at March 21, 2021 09:57 AM

NoSQL design pitfalls with Java [MontrelJUG]

by otaviojava at March 18, 2021 05:20 PM

Non-relational databases have come with the promise of assisting software in the Big Data age, handling the challenges of variety, velocity, and volume that come with it.However, several points plague even the most experienced software architects: How do I migrate my data to NoSQL and which one? Where are the relationships? Should I use some […]

by otaviojava at March 18, 2021 05:20 PM

Getting Started with Jakarta EE 9: Hello World

by Rudy De Busscher at March 18, 2021 10:00 AM

Introduction

The release of Jakarta EE 9, at the end of 2020, was in many ways a historic event. The Java Enterprise framework is already 20 years old, having its first release in 1999. It has changed names a few times but the main concepts of the first release can still be found in this new release. During all those years, it has adapted itself to keep it up to date but has always adhered to its main principle of stability and backward compatibility.


by Rudy De Busscher at March 18, 2021 10:00 AM

Enabling Jakarta EE 9 for development and test by using the Eclipse Transformer

March 17, 2021 12:00 AM

Overview

In this post, we describe how to use the Eclipse Transformer to update your applications and test artifacts for Jakarta EE 9. We also describe the steps to update Open Liberty server configurations to run Jakarta EE 9 applications.

The core problem that is introduced by Jakarta EE 9 is the renaming of package prefixes from javax to jakarta for APIs and properties. As a consequence, existing applications that run against Java EE 7 or Jakarta EE 8 do not run against Jakarta EE 9. To run existing applications as Jakarta EE 9 applications, specific package references must be updated.

To solve this problem, the Open Liberty development team created the Eclipse Transformer. This open source project provides a utility that updates package references in various artifacts.

The development team uses the Eclipse Transformer to update bundle implementation archives. The team also uses the transformer to update test artifacts, including applications, test classes, and Open Liberty server configurations.

Similarly, you can use the Eclipse Transformer to update applications, test classes, and server configurations. Updates to applications and test classes are usually necessary. Updates to server configurations are necessary when using Open Liberty.

The transformer is quick and efficient. When integrated as a build step, as is done in Open Liberty builds, using the transformer avoids the creation of new Jakarta EE 9 source files.

Although this post focuses on updating from Jakarta EE 8 to Jakarta EE 9, the same information holds true for updating from Java EE 7 to Jakarta EE 9.

Test transformation strategy

To transform test artifacts, package references must be updated to change old javax package references into new jakarta package references. Package references can be in several locations, including test applications, test code, and server configurations.

Additionally, in Open Liberty, server configurations must be updated to replace old Jakarta EE 8 features with corresponding new Jakarta EE 9 features. Currently, the transformer does not have the rules data necessary to specify feature name updates. These updates must either be made manually, through custom code, or by creating new rules data for the transformer. For more information about updating Open Liberty features, see Updating Open Liberty features in server configurations.

Preparing to run the transformer

A transformer image can be obtained either by downloading the image or by building an image by using the open source repository.

Alternatively, the transformer can be built by cloning the Eclipse Transformer repository and invoking maven to build the transformer JAR file:

    mvn clean package

The maven build creates the distribution JAR file at:

    org.eclipse.transformer.cli/target/org.eclipse.transformer.cli-0.3.0-SNAPSHOT-distribution.jar

Unzipping the downloaded or built distribution obtains the transformer and prerequisite JAR files:

    unzip org.eclipse.transformer.cli-0.3.0-SNAPSHOT-distribution.jar
    org.eclipse.transformer.cli-0.3.0-SNAPSHOT.jar
    libs/org.eclipse.transformer-0.3.0-SNAPSHOT.jar
    libs/biz.aQute.bnd.transform-5.2.0.jar
    libs/slf4j-api-1.7.25.jar
    libs/commons-cli-1.4.jar
    libs/slf4j-simple-1.7.30.jar

Running the transformer

The Eclipse Transformer can be run directly from the command line, as a Gradle task, or from Java code. This post describes using the transformer from the command line. For more information, see the transformer project pages.

To run the transformer by using the default rules, run the following command:

  java -jar org.eclipse.transformer.cli-0.3.0-SNAPSHOT.jar \
    <target_location> \
    <output_location>

The target location can be a packed application archive file (EAR, WAR, RAR, or JAR) or a directory that contains the fully or partially expanded contents of one of these archives. The target can also be a directory that contains Java source, or a directory that contains several application archives. It can even be a single file, such as a server.xml file. The transformer processes all of the artifacts in the target location. Transformed artifacts are written to the output location.

The org.eclipse.transformer.cli-0.3.0-SNAPSHOT.jar file is a runnable JAR file that specifies org.eclipse.transformer.jakarta.JakartaTransformer as the main class and uses the necessary JAR files from the libs folder in its class path.

You can run the transformer using custom rules by specifying options on the command line. The additional options specify local rules files that the transformer uses instead of the default rules files.

For example, to use Open Liberty rules data, which can be more up to date than the default rules data, download Open Liberty Rules. Then, pull in the downloaded rules data by adding options -tr, -td, and -tf, to the command-line invocation:

  java -jar org.eclipse.transformer.cli-0.3.0-SNAPSHOT.jar \
    <target_location> \
    <output_location> \
    -tr ${rules}/jakarta-renames.properties \
    -td ${rules}/jakarta-direct.properties \
    -tf ${rules}/jakarta-xml-master.properties

The -tr option specifies a properties file that contains package rename data. The -td option specifies a properties file that contains java direct string replacement data. The -tf option specifies a main properties file that links to other properties files. Each of the linked properties files contains replacement data for text-like files that match specific patterns, as specified in the main properties file.

These three command-line options are most important for application and test developers. Other command line options are available, but are less important. For example, the option -tb is used to specify data for transforming bundle archives, while the option -ts is used to specify which target files are to be transformed. For more information about command-line options, run the transformer with either the -usage option or with the -help option.

  java -jar org.eclipse.transformer.cli-0.3.0-SNAPSHOT.jar \
    -usage

Transforming server configurations

When you specify your server.xml file as a target location for the transformer, Open Liberty server configuration elements that contain javax package references are updated to jakarta. For example, the destinationType attribute of the jmsActivationSpec element contains a javax package reference:

  <jmsActivationSpec id="SharedSubscriptionWithMsgSel/TestTopic1">
    <properties.wasJms
        destinationRef="jms/FAT_TOPIC"
        destinationType="javax.jms.Topic"
        subscriptionDurability="DurableShared"
        clientId="cid1"
        subscriptionName="DURSUB"/>
  </jmsActivationSpec>

This configuration is updated to:

  <jmsActivationSpec id="SharedSubscriptionWithMsgSel/TestTopic1">
    <properties.wasJms
        destinationRef="jms/FAT_TOPIC"
        destinationType="jakarta.jms.Topic"
        subscriptionDurability="DurableShared"
        clientId="cid1"
        subscriptionName="DURSUB"/>
  </jmsActivationSpec>

Only package names in the server configuration are updated by the transformer. Features must be handled separately

Updating Open Liberty features in server configurations

For Jakarta EE 9 applications to run in Open Liberty, new Jakarta EE 9 features must be specified in the server configuration. In many cases, the new Jakarta EE 9 features use the same short names as the corresponding Jakarta EE 8 features. In those cases, the Jakarta EE 9 features simply have an updated feature version. For example, cdi-2.0 was updated to cdi-3.0. However, in some cases, the feature short name is also different, as with ejb-3.2, which was updated to enterpriseBeans-4.0.

If an old short name is incorrectly used with a new Jakarta EE 9 version, the server does not start, and the server logs provide information to say which new feature short name must be used. For example, if ejb-3.2 is incorrectly changed to ejb-4.0, the server logs indicate that enterpriseBeans-4.0 must be used.

Currently, the transformer cannot update Open Liberty features because it is missing rules data to specify the updates. Features must be updated manually or by custom code.

The following table lists features for which only the feature version is updated:

Table 1. Jakarta EE 8 to Jakarta EE 9 feature updates: version only
Jakarta EE 8 feature name Jakarta EE 9 feature name

appClientSupport-1.0

appClientSupport-2.0

appSecurity-3.0

appSecurity-4.0

batch-1.0

batch-2.0

beanValidation-2.0

beanValidation-3.0

cdi-2.0

cdi-3.0

concurrent-1.0

concurrent-2.0

jakartaee-8.0

jakartaee-9.0

jsonb-1.0

jsonb-2.0

jsonbContainer-1.0

jsonbContainer-2.0

jsonp-1.1

jsonp-2.0

jsonpContainer-1.1

jsonpContainer-2.0

managedBeans-1.0

managedBeans-2.0

mdb-3.2

mdb-4.0

servlet-4.0

servlet-5.0

webProfile-8.0

webProfile-9.0

websocket-1.1

websocket-2.0

The following table lists features for which both the feature short name and the feature version are updated:

Table 2. Jakarta EE 8 to Jakarta EE 9 feature updates: short name and version
Jakarta EE 8 feature name Jakarta EE 9 feature name

ejb-3.2

enterpriseBeans-4.0

ejbHome-3.2

enterpriseBeansHome-4.0

ejbLite-3.2

enterpriseBeansLite-4.0

ejbPersistentTimer-3.2

enterpriseBeansPersistentTimer-4.0

ejbRemote-3.2

enterpriseBeansRemote-4.0

el-3.0

expressionLanguage-4.0

jacc-1.5

appAuthorization-2.0

jaspic-1.1

appAuthentication-2.0

javaee-8.0

jakartaee-9.0

javaeeClient-8.0

jakartaeeClient-9.0

javaMail-1.6

mail-2.0

jaxb-2.2

xmlBinding-3.0

jaxrs-2.1

restfulWS-3.0

jaxrsClient-2.1

restfulWSClient-3.0

jaxws-2.2

xmlWS-3.0

jca-1.7

connectors-2.0

jcaInboundSecurity-1.0

connectorsInboundSecurity-2.0

jms-2.0

messaging-3.0

jpa-2.2

persistence-3.0

jpaContainer-2.2

persistenceContainer-3.0

jsf-2.3

faces-3.0

jsfContainer-2.3

facesContainer-3.0

jsp-2.3

pages-3.0

wasJmsClient-2.0

messagingClient-3.0

wasJmsSecurity-1.0

messagingSecurity-3.0

wasJmsServer-1.0

messagingServer-3.0

Reference Resources


March 17, 2021 12:00 AM

JavaLand 2021: Behind The Scenes | The Two Minutes Tuesday 019 | Conference Report

by Markus Karg at March 16, 2021 10:00 PM

Day one of virtual #JavaLand 2021 is over, so it is time to look behind the scenes! Join me for short a studio tour, see the gear I’m using, and have fun watching me doing JavaLang Kung Fu!

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂

CU!


by Markus Karg at March 16, 2021 10:00 PM

Architecting and delivering Java Applications in the Cloud Era

by otaviojava at March 16, 2021 03:38 PM

Nowadays, the best company is the one that delivers value quicker to its customers. They seek to spend less, and in consequence, they end up searching for cloud solutions. On the technical side, we have Java, which is the most mature and popular language of the past 25 years. Nevertheless, the most asked questions of […]

by otaviojava at March 16, 2021 03:38 PM

Hashtag Jakarta EE #63

by Ivar Grimstad at March 14, 2021 10:59 AM

Welcome to the sixty-third issue of Hashtag Jakarta EE!

We have tried to keep the overhead to a minimum with the Eclipse Foundation Specification Process (EFSP). Compared to other specification processes, it is pretty lightweight. Both the Jakarta EE Specification Process (JESP) and the MicroProfile Specification Process (MPSP) adopts the EFSP with a couple of additions that are so similar that they are barely distinguishable.

While knowing the process is good, every developer does not need to know the nitty-gritty details. That is why we have created a step-by-step guide to help developers on Jakarta EE specification projects with the steps of the JESP. Take a look at the JESP Guide to check it out!

JavaLand 2021 is happening this week! We have a lot of great content and community activities to look forward to. Here is a pointer to some of the talks on Wednesday, March 16 by Emily Jiang, Ondrej Mihalyi, and yours truly.

On Wednesday, March 17, I have a joint talk with Werner Keil where we use Jakarta MVC in one of the demos. Directly after, Emily Jiang and Ed Burns show how to port an application from Spring Boot to MicroProfile.

At the end, I want to point you to the article Don’t replace Spring Boot with Quarkus, replace it with Wildfly by Hélio Bessoni Rodrigues. This is an excellent write-up comparing microservices with modular monoliths that encourages developers to build software that lasts rather than being led by hypes and trends..


by Ivar Grimstad at March 14, 2021 10:59 AM

Meet me in JavaLand!

by Markus Karg at March 13, 2021 09:17 AM

As a frequent follower, you certainly know that I am part of the JavaLand Team. While my main task is to organize things upfront to the conference, I try to be a bit more visible on the show itself every year. So how can you meet me in JavaLand this year? Just get an online ticket to this virtual conference, enable mike and cam, and enter here: https://www.javaland.eu.

You can find me all day in the virtual JavaLand (which is done in Gather.town), so just search my name in the visitors panel and click on “follow” to directly find me on the map. Or attend one of my own sessions:

Listen to my part of the Opening Address

Come to the Jakarta EE panel discussion

Exercise JavaLand Kung-Fu

And… spoiler alert…: Join me after the first conference day in a “Behind The Scenes of JavaLand 2021” Special of The Two Minutes Tuesday on my Youtube channel at Tuesday 23:00 CET!

Jatumba! JavaLand rocks!


by Markus Karg at March 13, 2021 09:17 AM

Jakarta EE Community Update for February 2021

by Tanja Obradovic at March 11, 2021 07:07 PM

For Jakarta EE even in the short month as February is, we have quite a few things going on. Here is an update highlighting key initiatives.

The Jakarta EE community and Working Group is growing

Another Participant member joined the Jakarta EE working group. We are very excited to welcome  jadeva GmbH to the working group.

We talked to the enthusiastic and engaging duo Stephan Zubke, CTO is one of the initial founders of the company, and Claudia Geiger, CEO of the company,  who provided a bit more information about the company. 

jadeva GmbH is based in Stuttgart, with a team that consists of developers, scrum masters and product owners, following agile development methods. The company itself was founded in 2010 as OZ Solutions and renamed into jadeva UG in 2012, but just going under rebranding from UG to GmbH, hence you now see jadeva GmbH as the name of the company.

“Due to our technological focus it was an important step for us to join the community since it is our wish to contribute and support the development of Jakarta EE. We see networking and learning from each other as an important part in the growth of a company. Not only in numbers, but also in knowledge”, Claudia Geiger, CEO.

 

Jakarta EE 9.1 release

Jakarta EE 9.1 Release will target a release date for 2021 Q2. Kevin Sutter (IBM) is leading the effort. As previously communicated, the primary goal of the release is to provide support for Java SE 11 and to deliver it as soon as possible. We do not expect any API changes in this release.

You can view the Jakarta EE 9.1 Release Plan here. 

 

Jakarta EE Specification project teams 

We have organized a public calendar Jakarta EE Specifications Calendar (public url, iCal) to display all Jakarta EE Specification project teams meetings. Everyone interested to join the calls is welcome to join.

The Jakarta EE Platform team (meeting on Feb 9th, 2021) has invited all specification project team members and leads to submit their release plans for review by April 15th, so the planning for release after 9.1 can start.

 

Compatible Products and Compatible Implementations

Our list of Compatible Products, implementations of Jakarta EE Platform and Web Profile, is growing, and not just for Jakarta EE 8, but also for Jakarta EE 9.

Jakarta EE 8 newly certified products are

Jakarta EE 9 newly certified products are 

Our list of Compatible Implementations, implementations of Jakarta EE individual or component specifications is growing as well. We will highlight these implementations on the specification pages

 

Book your 2021 Jakarta EE Virtual Tour and Adopt-A-Spec

We are looking for the opportunity to virtually visit you, so don’t hesitate to get in touch (tanja.obradovic@eclipse-foundation.org) if you’d like to hear about Jakarta EE 9 and beyond.

We need help from the community! All JUGs out there please choose the specification of your interest and adopt it. Here is the information about the Adopt-A-Spec program. 

 

Stay Connected With the Jakarta EE Community

The Jakarta EE community is very active and there are a number of channels to help you stay up to date with all of the latest and greatest news and information. Subscribe to your preferred channels today:

·  Social media: Twitter, Facebook, LinkedIn Group

·  Mailing lists: jakarta.ee-community@eclipse.org, jakarta.ee-wg@eclipse.org, project mailing lists, slack workspace

·  Newsletters, blogs, and emails: Eclipse newsletter, Jakarta EE blogs, Hashtag Jakarta EE

·  Meetings: Jakarta Tech Talks, Jakarta EE Update, Jakarta Town Hall, and Eclipse Foundation events and conferences

You can find the complete list of channels here.

To help shape the future of open source, cloud native Java, get involved in the Jakarta EE Working Group.

To learn more about Jakarta EE-related plans and check the date for the next Jakarta Tech Talk, be sure to bookmark the Jakarta EE Community Calendar.

 


by Tanja Obradovic at March 11, 2021 07:07 PM

Modern Cloud-Native Jakarta EE Frameworks: tips, challenges, and trends

by otaviojava at March 11, 2021 03:29 PM

Java has a large number of tools and frameworks to facilitate integration with databases, microservices, and so on. These tools have evolved considerably. It all started with class integrated with XML files and has undergone significant evolution with reflections and annotations within the class definitions. In the cloud-native scenario, requirements have changed and this impacts […]

by otaviojava at March 11, 2021 03:29 PM

Profiling Jakarta EE Applications with NetBeans Profiler

by WildFly Admin (francesco@mastertheboss.com) at March 10, 2021 08:56 AM

In this article we will learn how to profile Java/Jakarta EE applications with NetBeans built-in profiler tool and how to instrument WildFly application server for this purpose.


by WildFly Admin (francesco@mastertheboss.com) at March 10, 2021 08:56 AM

Hibernate Slow Query Log – The easiest way to find slow queries

by Thorben Janssen at March 09, 2021 01:00 PM

The post Hibernate Slow Query Log – The easiest way to find slow queries appeared first on Thorben Janssen.

One of the common questions when analyzing a slow application is if there are any slow database queries. You can, of course, monitor these queries on your database. But then you still need to match them with a part of your Java code. And because there is no easy way to see what happened immediately […]

The post Hibernate Slow Query Log – The easiest way to find slow queries appeared first on Thorben Janssen.


by Thorben Janssen at March 09, 2021 01:00 PM

Introduction to Reflectionless: Discover the New Trend in the Java World

by otaviojava at March 08, 2021 10:28 AM

Discover this new movement in Java frameworks that aim to circumvent the disuse of reflection to decrease application startup and decrease memory consumption. https://dzone.com/articles/introduction-to-reflectionless-know-what-the-new-t

by otaviojava at March 08, 2021 10:28 AM

Hashtag Jakarta EE #62

by Ivar Grimstad at March 07, 2021 10:59 AM

Welcome to the sixty-second issue of Hashtag Jakarta EE!

One of the major changes introduced with Jakarta EE over how it used to be is that the TCKs are available for free to anyone that wants to certify their implementation. I described how to do this in Compatible Implementations.

This is exactly what the Eclipse Jetty team has done, so Eclipse Jetty 11.0.1 is now certified as a compatible implementation of Jakarta Servlet 5.0! Congratulations to the Jetty team!

In parallel with the work on Jakarta EE 9.1, the individual specifications plans for future releases. Some of the teams are setting up ad-hoc or regular calls in addition to discussing on the mailing lists. In order to have a common calendar to keep track of these calls, we have created the Jakarta EE Specifications Calendar. We encourage the teams to publish their meetings on this calendar. This will make it easier for the community to attend calls they are interested in.

JavaLand 2021 is coming up next week. It will be an online two-day conference happening on March 16 and 17. I have one Jakarta EE talk scheduled. I will also co-speak Mobile Java Web Applications with MVC and OpenDDR with Werner Keil. There is also a Jakarta EE panel scheduled.

That’s it for this week. Hope you enjoyed it, and see you again next week!


by Ivar Grimstad at March 07, 2021 10:59 AM

[LIVESTREAM] Nicolai Parlog LIVE CHAT about Modern Java | Tonite with me | Java Latenite

by Markus Karg at March 07, 2021 08:31 AM

#ToniteWithMe chatting about modern #Java is #JavaChampion Nicolai Parlog.

When you want to know what is hot and what is not in Java, then Nicolai defintively is the perfect guest to ask your questions. He will be chatting with me about what is there in the queue for Java, and what already available gems we all should pick up rather eagerly.

Join this LIVE SESSION on Friday at 20:00 CET. Just type your own questions into the chat while the show runs!

If you like this live show, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂


by Markus Karg at March 07, 2021 08:31 AM

Coffee with Thorben 2020-03-05 – Natural vs Surrogate Keys

by Thorben Janssen at March 05, 2021 01:30 PM

The post Coffee with Thorben 2020-03-05 – Natural vs Surrogate Keys appeared first on Thorben Janssen.

Join the chat on YouTube. Natural vs Surrogate Primary Keys When modeling your entity classes and database tables, you need to decide what kind of primary key you want to use. You can use a combination of attributes that identify an object. This is called a natural key. Or you could introduce an artificial, technical […]

The post Coffee with Thorben 2020-03-05 – Natural vs Surrogate Keys appeared first on Thorben Janssen.


by Thorben Janssen at March 05, 2021 01:30 PM

Open Liberty beta is Jakarta EE 9 compatible

March 05, 2021 12:00 AM

JakartaEE Logo Compatible color

Late last year, the Jakarta EE community released the next step in the evolution of the Jakarta EE specification. Version 9.0 of the Jakarta EE specification focuses on renaming packages and namespaces by changing to jakarta prefixed packages names in the API and to the jakarta.ee namespace in the deployment descriptor files. Additionally, the specification makes optional or removes older functions that have been deprecated or stabilized for many years.

Over the last year, the Open Liberty development team worked to implement the Jakarta EE 9 specification as it was being finalized. To avoid having to duplicate the code just to change the API package names, the team developed an open source byte code transformation technology. With this technology, Jakarta EE 8 compatible code is transformed to work with Jakarta EE 9 APIs by manipulating the byte code to convert class and property reference prefixes from javax to jakarta.

As of the 21.0.0.2-beta release, Open Liberty is the first vendor product to be Jakarta EE Web Profile 9.0 compatible. With the recent 21.0.0.3-beta release, Open Liberty is the first vendor product to be added to the Jakarta EE Platform 9.0 compatibility list. These releases continue to demonstrate Open Liberty’s leadership in the Jakarta EE technologies. With the upcoming Jakarta EE 9.1 release that adds Java 11 support to the TCK, I anticipate that Open Liberty will be added to the compatibility list for the 9.1 release when it is available since Open Liberty has supported Java 11 for the last 2 years.

Even with reaching these milestones, the journey to support Jakarta EE 9 in the Open Liberty product will continue until it is available in a non-beta release. Many Liberty value-add features need to be enabled to run with Jakarta EE 9 and still continue to work with the previous EE specifications. In the coming months, you will see additional enablement of these features in the beta releases until all are ready. Thanks to the Open Liberty pluggable feature architecture, you will be able to run your Java EE 7, Java / Jakarta EE 8 and Jakarta EE 9 applications with the same product install.


March 05, 2021 12:00 AM

The Payara Monthly Catch: February 2021

by Priya Khaira-Hanks at March 03, 2021 09:42 AM

In our February Monthly Catch,  we’ve rounded up a wide range of the most useful learning materials, community news pieces, videos and podcasts from the world of Java, Jakarta EE and MicroProfile - and of course provided updates from Team Payara!

As we progress into the year, the new releases of Jakarta EE - including the breaking namespace change - and MicroProfile are becoming more embedded and discussed. For example, it was great to see Dalia Shea from JetBrains discuss using the new “jakarta” namespace, and Michael Redlich at InfoQ summarizing the JakartaOne conference where Jakarta EE 9 was officially announced.

We’re also seeing a lot of looking round the corner to what’s next for our community: to JDK 17, as well as the innovations coming through Project Loom and Project Panama.

It also seems to be unofficial survey season! We’ve launched our own, Omnifaces have published its survey’s fascinating results looking into JakartaEE and MicroProfile, and you still have time to answer questions forthe Snyk and Azul survey that came out this month. It’s exciting to see so many opportunities for people to feedback, drive and shape the future of Enterprise Java and its associated technologies.

If you enjoy the content, make sure to follow us on our Twitter and LinkedIn, for the very latest news as it comes in. 

Enjoy!


by Priya Khaira-Hanks at March 03, 2021 09:42 AM

Foreign Linker API outperforms JNI | The Two Minutes Tuesday 018 | Java Performance Test Result

by Markus Karg at March 02, 2021 10:00 PM

The actual performance of the #ForeignLinkerAPI is amazing, once you do one small trick: Resuse native memory! It has the potential to outperform #JNI with whopping 6.8 millions native invocations per seconds already, compared to 7 millions in pure C++, while still being in incubation! #Java really rocks!

This video was produced with a pre-release of #JDK16.

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon https://www.patreon.com/mkarg. Thanks! 🙂

CU!


by Markus Karg at March 02, 2021 10:00 PM

Configuring Spring Data JPA with Spring Boot

by Thorben Janssen at March 02, 2021 12:42 PM

The post Configuring Spring Data JPA with Spring Boot appeared first on Thorben Janssen.

Before Spring Boot, you had to do quite a few things to set up Spring Data JPA. You not only had to annotate your entity classes with mapping annotations, add a dependency to Spring Data JPA and configure your database connection. You also had to enable repositories and transaction management and configure your EntityManagerFactory. That […]

The post Configuring Spring Data JPA with Spring Boot appeared first on Thorben Janssen.


by Thorben Janssen at March 02, 2021 12:42 PM

Welcome jadeva GmbH to the Jakarta EE Working Group!

by Tanja Obradovic at March 01, 2021 05:08 PM

Our Jakarta EE Working group is growing! Please meet our new member jadeva GmbH!  

We talked to the enthusiastic and engaging duo Stephan Zubke, CTO is one of the initial founders of the company, and Claudia Geiger, CEO of the company,  who provided a bit more information about the company. 

jadeva GmbH is based in Stuttgart, with a team that consists of developers, scrum masters and product owners, following agile development methods. The company itself was founded in 2010 as OZ Solutions and renamed into jadeva UG in 2012, but just going under rebranding  from UG to GmbH, hence you now see jadeva GmbH as the name of the company.

They are strongly interested in the development of Jakarta EE. It is best to quote Claudia explaining their reasons for joining Jakarta EE Working Group.

“Due to our technological focus it was an important step for us to join the community since it is our wish to contribute and support the development of Jakarta EE. We see networking and learning from each other as an important part in the growth of a company. Not only in numbers, but also in knowledge.”

We are looking forward to the collaborations and their contributions to Jakarta EE. 

Welcome jadeva GmbH!


by Tanja Obradovic at March 01, 2021 05:08 PM

Hashtag Jakarta EE #61

by Ivar Grimstad at February 28, 2021 10:59 AM

Welcome to the sixty-first issue of Hashtag Jakarta EE!

Tanja and I have been touring JUGs over the last couple of months. So far, we have visited JUGs (virtually) in India, South Africa, Sweden, Serbia, the USA, Poland, Germany, and Spain. And we don’t want to stop there! Please reach out to us if you want us to visit YOUR JUG or Meetup!

It is the end of February already, and the release date for Jakarta EE 9.1 is approaching quickly. A release candidate of the API is available in Maven Central. The current activities are around updating the compatible implementations to pass the TCK on JDK 11.

In order to make it to the proposed release date of March 25, the release review must start at the latest on March 11. That means that there are less than two weeks to get Eclipse GlassFish to pass the TCK on JDK 11.

Beyond Jakarta EE 9.1

Looking ahead, discussions around the next release have started in the Jakarta EE Platform Project. To be able to define the scope of the next release, we need input from the component specifications. Plan reviews are due on April 15, 2021 to be considered as candidates for the next release of Jakarta EE. The plan submitted for review must be possible to implement within 6 months. Which in turn means that we are looking at a Jakarta EE release in October, 2021.


by Ivar Grimstad at February 28, 2021 10:59 AM

Java Performance Shootout: Foreign Linker vs JNI | Modern Java | JDK16 | Head Crashing Informatics 28

by Markus Karg at February 27, 2021 04:00 PM

Hey guys! How’s it going?

The #ForeignLinkerAPI, which is in incubation in #JDK16, was announced to be as fast as, OR EVEN FASTER AS, #JNI (#JavaNativeInterface, the sole OFFICIAL way to call native code from Java). But how looks the realitity? See an ACTUAL performance shootout of the Foreign Linker API vs JNI, AND VERSUS #JNA (#JavaNativeAccess, the DE-FACTO way for invoking native code from #Java). I don’t want to spoil TOO MUCH, but prepare yourself for adopting the new API AS SOON AS YOU CAN…!

In this video, I am using the #JavaMicrobenchmarkHarness (#JMH), see https://github.com/openjdk/jmh.

The source code of the shootout can be found on Gitlab: https://gitlab.com/mkarg/foreignlinkerapi.

If you like this video, please give it a thumbs up, share it, subscribe to my channel, or become my patreon. Thanks!

Stay safe and… Party on!


by Markus Karg at February 27, 2021 04:00 PM

Coffee with Thorben 2020-02-26 – Utility classes that make your life easier

by Thorben Janssen at February 26, 2021 01:00 PM

The post Coffee with Thorben 2020-02-26 – Utility classes that make your life easier appeared first on Thorben Janssen.

Join the chat on YouTube. Utility classes that make your life easier Implementing a persistence layer with Hibernate can require a lot of String references: You’re referencing entities and their attributes by their name. Query hints have very long names that you need to provide as a String. When registering an entity graph, you need […]

The post Coffee with Thorben 2020-02-26 – Utility classes that make your life easier appeared first on Thorben Janssen.


by Thorben Janssen at February 26, 2021 01:00 PM

Payara Platform 2021 Survey

by Debbie Hoffman at February 26, 2021 09:00 AM

The Payara Platform 2021 Survey is underway and we're inviting everyone to answer a few questions about your use of the Payara Platform and ecosystem components. We want to know what you like, what you want to see improved, and we're giving you the opportunity to vote on new features you'd like to see added to the Payara Platform.


by Debbie Hoffman at February 26, 2021 09:00 AM

Keeping Brazil’s Medical Industry Safe with MicroProfile | JakartaOne Livestream 2020

by Cesar Hernandez at February 25, 2021 03:12 PM

Jakarta One 2020, held on December 8th, 2020, gathered industry users and Java communities to share and learn the latest Java enterprise-related technologies. Jakarta EE 9, officially announced in November 2020, that they have created a lot of momentum to keep the conversation going in terms of lessons learned, roadmaps, and best practices. 

Rafael Guimares, and I, had the opportunity to present the session “Keeping Brazil’s Medical Industry Safe with MicroProfile & JakartaEE”. The session addressed the challenges, opportunities, and roadmap to migrating one of Brazil’s medical industry applications from Java EE into Jakarta EE 9, and MicroProfile implementations, towards a Clod-Native Java architecture. 

If you are interested in learning more about Jakarta EE, catch up via its youtube channel and subscribe to its mailing lists here

The post Keeping Brazil’s Medical Industry Safe with MicroProfile | JakartaOne Livestream 2020 appeared first on Tomitribe.


by Cesar Hernandez at February 25, 2021 03:12 PM

Hibernate Performance Tuning Done Right

by Thorben Janssen at February 23, 2021 01:00 PM

The post Hibernate Performance Tuning Done Right appeared first on Thorben Janssen.

Optimizing the performance of your application is a complex and application-specific task. All domain models are different, and often enough, the amount of data managed by them also differs significantly between multiple installations. In addition to that, almost all performance tuning techniques have trade-offs, which don’t make them a great fit for all situations. Because […]

The post Hibernate Performance Tuning Done Right appeared first on Thorben Janssen.


by Thorben Janssen at February 23, 2021 01:00 PM

Panel Discussion: Minimising Security Risks when Developing your Applications

by Jadon Ortlepp (Jadon.Ortlepp@Payara.fish) at February 22, 2021 09:44 AM

United by our passion for Open Source, we are very excited to be teaming up with IBM for another panel event. In this session we will be discussing all things security. How can you minimise security risks when developing your applications?


by Jadon Ortlepp (Jadon.Ortlepp@Payara.fish) at February 22, 2021 09:44 AM

Hashtag Jakarta EE #60

by Ivar Grimstad at February 21, 2021 10:59 AM

Welcome to the sixtieth issue of Hashtag Jakarta EE!

As I mentioned last week, the release plan for Jakarta EE 9.1 has been published. The target release date is the end of March 2021. GlassFish 6.1 now compiles and runs on Java SE 11, and the work with getting it to pass the TCK goes on.

The Jakarta EE Platform team has also started to prepare for the next Jakarta EE release after 9.1. At them moment, we are collecting input from the various specification projects to be able to define the content of this release. The deadline for starting plan review for the next Jakarta EE release is April 15, 2021. Make sure to check the minutes for updates. We encourage specification projects to join the Platform calls and give an update on their plans. The details for the platform calls can be found in the Jakarta EE Platform Calendar.

The JUG Leaders Summit and Devnexus took place this week. Devnexus is an awesome conference to visit, and the virtual edition this year was no exception. Let’s just hope that we will be back in Atlanta for next year’s edition.

There is only one more stop planned on the Jakarta EE Virtual Tour, and that is Chicago JUG on February 25. We really enjoy giving these talks, so please reach out if you are interested in hosting us at your JUG or MeetUp.


by Ivar Grimstad at February 21, 2021 10:59 AM

Coffee with Thorben 2020-02-19 – Enums, Enums, Enums …

by Thorben Janssen at February 19, 2021 01:30 PM

The post Coffee with Thorben 2020-02-19 – Enums, Enums, Enums … appeared first on Thorben Janssen.

Join the chat on YouTube. Enums, Enums, Enums … Enums are the perfect data type, if an attribute can only have one out of a set of predefined values. A typical example is the rating of a product, which can have the values 1, 2, 3, 4 and 5. Using JPA’s default mappings, you can […]

The post Coffee with Thorben 2020-02-19 – Enums, Enums, Enums … appeared first on Thorben Janssen.


by Thorben Janssen at February 19, 2021 01:30 PM

How to deploy SOAP Web Services in Jakarta EE applications

by WildFly Admin (francesco@mastertheboss.com) at February 19, 2021 12:47 PM

This tutorial covers how to build and deploy SOAP based Web services in Jakarta EE applications, also discussing the changes in the Java SE that removed the JAX-WS API from the default Java modules.


by WildFly Admin (francesco@mastertheboss.com) at February 19, 2021 12:47 PM

Cleanup JBatch Job Execution Data with New Asadmin Tool Command

by Rudy De Busscher at February 18, 2021 09:49 AM

The JBatch Jakarta EE specification describes the process of how background jobs can be executed on a Jakarta EE compatible runtime. Using the Batch Specification, the runtime can execute some jobs that don't require any user input. Most of the time they are scheduled to execute at a certain moment of the day, but they can be triggered on-demand.


by Rudy De Busscher at February 18, 2021 09:49 AM

From Monolith to Microservices – Migrating a Persistence Layer

by Thorben Janssen at February 16, 2021 11:58 AM

The post From Monolith to Microservices – Migrating a Persistence Layer appeared first on Thorben Janssen.

Since microservices have become popular, teams are trying to split their monolithic application into a set of small, independent, and highly-scalable microservices. In theory, that often seems like an easy task. You only need to follow the key principles of domain-driven design, identify the bounded contexts in your application, and extract each of them as […]

The post From Monolith to Microservices – Migrating a Persistence Layer appeared first on Thorben Janssen.


by Thorben Janssen at February 16, 2021 11:58 AM

Coffee with Thorben 2020-02-12 – JPQL vs Criteria vs Native Queries

by Thorben Janssen at February 12, 2021 01:30 PM

The post Coffee with Thorben 2020-02-12 – JPQL vs Criteria vs Native Queries appeared first on Thorben Janssen.

Join the chat on YouTube. JPQL vs. Criteria vs. Native Queries With JPQL and native SQL queries, Hibernate supports 2 query languages that you can use to search data in your database. In addition to that, there is also JPA’s Criteria API that replaced Hibernate’s proprietary Criteria API. It might seem like there are 3 […]

The post Coffee with Thorben 2020-02-12 – JPQL vs Criteria vs Native Queries appeared first on Thorben Janssen.


by Thorben Janssen at February 12, 2021 01:30 PM

Back to the top