Josh's Dev Blog - Java, Jakarta EE, Jython, Oracle, and More...

Azure JBoss EAP On App Service

noreply@blogger.com (Josh Juneau) — Sun, 17 Sep 2023 04:31:00 +0000

Over the past couple of months I have had the opportunity to check out the Microsoft Azure JBoss EAP On App Service, and I wanted to share my thoughts on this service. If you have not previously heard of it, you can think of it as a cloud application service which enables one to deploy Jakarta EE applications in various formats, and host them on Azure. The Azure App Service contains a plethora of options, from allowing one to deploy a single JAR, to providing the ability to deploy containers, to the ability of deploying single WAR files.

To get started with the service, you can go to the Azure Portal and create a free account. There are a number of different services that are available for free to get started and take it for a spin. If you are interested in using the platform for development and production, you will need to subscribe to a paid plan. If you wish to get started on a learning path, then there are some great articles available to check out, but here I will show you what I did in order to deploy a simple Jakarta EE application to the cloud using this service. There are also some excellent examples on Github, including the Jakarta EE Azure example by Reza Rahman. Let's go quickly through some of my experiences while working through the Jakarta EE Azure example.

The database configuration when following through the Jakarta EE Azure example was very easy. I was able to create a hosted PostgreSQL database on Azure almost instantly. Following along with the example, I also configured the database security to enable access to the Azure services. Without the step-by-step of a tutorial, some of this configuration may have been a bit complex, as Azure offers a large variety of options for configuration of the services.

Next, I created a web application using JBoss EAP. This again provided many options, but many are fairly straight forward if you are familiar with Java web applications. I chose Java 11 as my runtime stack and JBoss EAP 7 as the web server. At this point, I was in a position to install an application in WAR file format to the JBoss EAP server.

Following along with the tutorial, one should install the Azure CLI to their machine in order to deploy a local application. However, I did not want to install anything locally to my machine. So instead of performing the local CLI installation, I used the cloud based CLI that is hosted on Azure. Using this cloud CLI, I was able to clone one of my personal Github repositories, modify it, build, and deploy it to JBoss EAP 7. This was very nice...having the ability to perform a complete build and deployment in the web browser.

A very nice feature is the ability to create resource groups that can be used to group application resources together. This feature allows one to group databases, web applications, and other services together in order to better manage all of the resources that are required for an application.

Overall, Azure JBoss EAP on App Service is a useful tool and is fairly easy to use. The downside is that the hosting can be quite costly if not using a free package, but I believe that may change at some point in the near future. Unfortunately, I was unable to dig much deeper because I left my services running for a couple of weeks and used up my credits. However, I am happy with my experience in the Microsoft Azure Portal with JBoss EAP 7, and I greatly appreciate the opportunity to look at the service. I look forward to the opportunity to continue my journey with these resources, hopefully free as a developer for testing purposes, in the future.

Review: OpenJDK Migration for Dummies

noreply@blogger.com (Josh Juneau) — Sun, 10 Sep 2023 16:15:00 +0000

Have you been thinking of moving away from the Oracle JDK to OpenJDK? The book "OpenJDK Migration for Dummies", written by Simon Ritter of Azul, provides direction for those who are looking to make the move. In many cases, organizations develop Java applications to work on a specific version of the JDK. Oftentimes, as long as the application continues running without issue, organizations wouild not upgrade the JDK. As we well know, with all software, as time goes on, the JDK which is in use can age and become out-of-date, exposing security vulnerabilities. Moreover, if the JDK in use is aging, then there likely have been many enhancements in more recently released JDKs which could provide performance benefits for the deployed application(s).

We are at a time where older releases of the JDK such as JDK 8 are no longer being supported by Oracle unless commercial support is being paid. If an organization needs to maintain the use of JDK 8, then it may make sense for the organization to purchase a support agreement. In other cases, the organization may be able to move to another JDK that will work with their application. There are many different options available today. One of those options is OpenJDK, which is freely available for use. There are a number of organizations that have taken OpenJDK and added features or enhancements, and typically offer a paid support for enhanced protection or even for access to premium features.

This book nicely covers the arduous process of learning about the different licensing options when using the Oracle JDK, and what the OpenJDK has to offer. The book makes it easy to understand so that readers to not need to delve into long white papers to read about them. The book also covers the different points that need to be reviewed while preparing to make a migration to OpenJDK, including making an inventory of all JDK versions are in use within your organization. There are several key processes outlined in the book that must not be overlooked while performing a migration, such as looking at each of the "optional" features of the JDK that are in-use within your organization to ensure that they are available in the OpenJDK release of your choice. For instance, JavaFX may not be incorporated within all OpenJDK releases and may be an additional package to incorporate into your migration.

Since the book is written by Simon who works with Azul, he does cover some of the benefits of the Azul Platform Core JDK. There are many to cover, and the book offers a high level overview of some of the most important features. It also covers the question of why commercial support may be something of value to your organization. What if you still need to run JDK 8 in order to make your application work? In such a case, it makes sense to pay for commercial support. How about if your organization is looking to have first hand support? That is another solid reason to purchase commercial support. The list goes on.

The book "OpenJDK Migration for Dummies" is a great read for anyone looking to migrate to the OpenJDK. It is a nice and quick read, landing in at under 80 pages, and it covers the process from start to finish.

Cocktails and Code: Margaritas and Jakarta EE

noreply@blogger.com (Josh Juneau) — Mon, 03 Jul 2023 21:58:00 +0000

It is summer time, and that means warm weather, swimming pools, and ice cold drinks. In this post, I will demonstrate how to develop a simple microservices-based application using Jakarta RESTful Web Services to provide the data for the application. Did you know that there is an easy way to get started with Jakarta EE using the Jakarta EE Starter project? In this post, I will demonstrate how to utilize the starter. First, we need to mix up a drink to enjoy while we code! If you'd prefer to skip the cocktail and code without it, then please skip to the "Time to Code" section below.

Let's Mix a Cocktail - Classic Margarita Recipe

While you could go to a store and purchase a pre-mixed margarita, those mixes are rarely as good as a classic margarita made from scratch. I prefer my margaritas on-the-rocks (ice cubes), although it is also popular to have a frozen margarita, which is more of an icy concoction similar to a slush. Whatever your preference, this classic recipe will work. Let's get mixing!

What you'll need:

– 2 fluid ounces of blanco tequila (higher quality is better)

– 1 1/2 fluid ounces of triple sec (higher quality is better)

– 1 ounce of lime juice (fresh is best)

– 1 1/2 cup of ice cubes

– Coarse salt

– Lime

– Cocktail Shaker (improvise if you do not have one) or blender for frozen margarita

– Margarita glass (any glass will do, but a margarita glass adds to the experience)

Details:

Cut lime into wedges, and then take one wedge and moisten the rim of the glass with the wedge. Pour coarse salt onto a plate and dip the moistened rim of the glass into the salt. Add a 1/2 cup of ice to the glass.

Add 1 cup of ice to shaker. Pour the tequila, triple sec, and lime juice into a shaker. Shake for 20-25 seconds, until the shaker is frosted on the outside. Strain the margarita into the glass and garnish with a slice of lime. If you prefer a frozen margarita, skip the shaker and instead add 2 cups of ice to a blender and then pour tequila, triple sec, and lime juice into the blender and blend until smooth. If you do not have a cocktail shaker, any closable liquid-tight container may do the trick...so long as you can shake vigorously without the beverage getting all over your code.

Enjoy the refreshing goodness of a classic margarita!

Time to Code - Jakarta EE Starter

Now that we have a cocktail, it is time to code! In this example, we are going to build a simple web service using Jakarta RESTful Web Services, and deploy to a Payara application server. While it is easy to deploy to a Docker or Podman container, in this example I will deploy to a standard application server.

Creating a Simple Web Service

To get started, head over to Eclipse Starter for Jakarta EE and choose your project options from the generator. In this example, please choose:

– Jakarta EE Version: Jakarta EE 10

– Jakarta EE Profile: Platform

– Java SE Version: Java SE 17

– Runtime: Payara

– Docker Support: Yes (this way you can experiment with Docker if you wish)

Once the options are selected, click the "Generate" button, and a ZIP file will be downloaded to your device. Once downloaded and unzipped to your machine, open the README file to learn how to start the project and run it. At a minimum, you need to do the following:

1) Ensure your JAVA_HOME environment variable is set to the appropriate JDK for the version you selected at the Jakarta EE Starter. In this case, ensure that your JAVA_HOME is pointing to JDK 17. On OS X, the following will set the home accordingly:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/<java-home>>

2) Unzip the downloaded project. Traverse into the jakartaee-hello-world directory within a command prompt or terminal, and execute the following in order to invoke Maven to download dependencies and run the application/service:

./mvnw clean package cargo:run

3) Once the server has been started, navigate to the following page in a web browser: http//localhost:8080/jakartaee-hello-world/

This minimialistic application will simply output a Jakarta EE logo and some text onto the screen. To initiate the RESTful web service, visit the following URL:

http//localhost:8080/jakartaee-hello-world/rest/hello

This web service will return the JSON {"hello":"world"} and it does so by invoking a Jakarta REST web service and returning text to the caller. The RESTful service accepts a parameter identified as “name”, and if any word is passed to this parameter, then the JSON will be modified to {"hello”:<name>}. To invoke the web service passing the name “Jane”, open a web browser or use a curl command in a terminal open the following URL:

http://localhost:8080/jakartaee-hello-world/rest/hello?name=Jane

A REST web service endpoint class named HelloWorldResource is where the magic happens. Open the jakartaee-hello-world project within your favorite Integrated Development Environment (IDE) or use a text editor to open the org/eclipse/jakarta/HelloWorldResourc.java file. The HelloWorldResource class is annotated with @Path to indicate the URI path for invoking the REST web service. There is a single method named hello is contained within the class. The @GET annotation is placed on the method to indicate that the method is responding to HTTP GET requests, and the @Produces annotation ensures that the application will produce or return the JSON media type. The method accepts a QueryParam identified as name, which should be noted as the ?name portion from the above URL. In the body of the method, if the name parameter is null or empty, then the word “world” will be assigned to it. The method returns an object identified as Hello, which is a plain old Java object (POJO). If you wish to compile and deploy this application to a stand alone server, then you can do that as well! Here is a look at the HelloWorldResource REST service class:

public class HelloWorldResource {

@GET

@Produces({ MediaType.APPLICATION_JSON })

public Hello hello(@QueryParam("name") String name) {

if ((name == null) || name.trim().isEmpty()) {

name = "world";

}

return new Hello(name);

}

Code for the Hello object:

public class Hello {

private String name;

public Hello(String name) {

this.name = name;

}

public String getHello(){

return name;

}

There you have it! Now you should be able to get up and running quickly with the Jakarta EE Starter. Thanks to the team involved with working on the starter project!

JakartaOne Livestream 2022

noreply@blogger.com (Josh Juneau) — Thu, 22 Sep 2022 15:15:00 +0000

The JakartaOne Livestream 2022 will be held virtually on December 6th. The Call for Papers is now open!

Please submit your paper to speak at an event that has been very well attended for the last three years!

Submit a Talk!

Apache NetBeans 12.5

noreply@blogger.com (Josh Juneau) — Sun, 15 Aug 2021 16:37:00 +0000

Apache NetBeans 12.5 - beta 1 is available for testing. Please download it and give it a try at:

https://ci-builds.apache.org/job/Netbeans/job/netbeans-TLP/job/netbeans/job/release125/lastSuccessfulBuild/artifact/dist/netbeans/

New features in this release are listed at the following link: https://cwiki.apache.org/confluence/display/NETBEANS/Apache+NetBeans+12.5

Kicking the Tires of Jakarta EE 9 with Payara

noreply@blogger.com (Josh Juneau) — Sat, 24 Oct 2020 15:06:00 +0000

We've been hearing all about it. Jakarta EE 9 will be released in November 2020. The Jakarta EE working group and community have been working hard to bring this release to the masses, and it is about ready. Here's how to take a look at it today, using one of the most popular application server containers.

1. Download the latest Payara Server Community 5.2020.5 release, which includes "Tech Preview" support for Jakarta EE 9. https://www.payara.fish/downloads/#community

2. Create a simple service using Jakarta EE APIs, adding the jakarta.platform:jakartaee.jakarta.jakartaee-api:9.0.0-RC3 dependency.

3. Build and deploy the service to Payara Server Community 5.2020.5.

That's it. The Payara Server Community edition includes an Eclipse Transformer Configuration Option, which will automatically detect jakarta.* package references during the deployment of the application, and transform the class and resource files from the jakarta.* namespace to javax.*. Take a look at this Payara blog post for more info: https://blog.payara.fish/eclipse-transformer-configuration

Example POM including Payara Server Community Support:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.employeeevent</groupId>
    <artifactId>AcmeChat</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>AcmeChat-1.0-SNAPSHOT</name>
    
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <failOnMissingWebXml>false</failOnMissingWebXml>
        <jakartaee>9.0.0-RC3</jakartaee>
    </properties>
    
    <dependencies>
        <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-api</artifactId>
            <version>${jakartaee}</version>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <compilerArguments>
                        <endorseddirs>${endorsed.dir}</endorseddirs>
                    </compilerArguments>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.6</version>
                <executions>
                    <execution>
                        <phase>validate</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>${endorsed.dir}</outputDirectory>
                            <silent>true</silent>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>jakarta.platform</groupId>
                                    <artifactId>jakarta.jakartaee-api</artifactId>
                                    <version>${jakartaee}</version>
                                    <type>pom</type>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Developing a Simple Service with Spring Boot

noreply@blogger.com (Josh Juneau) — Wed, 09 Sep 2020 03:44:00 +0000

In this post, I will demonstrate how to create a simple web service using Spring Boot. This framework makes it almost effortless to develop web services, so long as the appropriate dependencies are in-place. In this example, I will create a web service that will read the current temperature from a file and make it available to clients via a RESTful endpoint.

The Spring Initializr helps one to choose the dependencies that are required for production a particular solution. The Initializr can be found at: https://start.spring.io/

The first thing to note when creating a project using the Initializr is that one can develop Spring Boot applications using a number of different JVM languages, including Java, Kotlin, or Groovy. This is one area where Spring Boot differs from Jakarta EE, which is primarily focused on the Java language. One also has the option to choose either Gradle or Maven for their Spring Boot project. Perhaps one of the most tedious parts of using the Initialzr to create a project is choosing the appropriate dependencies for the project. The reason being that there are so many dependency options, it can take a while to learn which are the most useful for a particular solution. This is not a bad thing...it is just something that needs to be learned over time.

To get started, choose the following options within the Initializr:

Project: Maven

Language: Java

Spring Boot: 2.3.3

Dependencies: Spring Web

Project Metadata

- Group: org.demo

- Artifact: poolservice

- Name: poolservice

- Package Name: org.demo.poolservice

- Packaging: WAR

- Java: 11

Once these options are chosen, click "Generate" to download the project files. Once downloaded, open the project in your favorite IDE. In this case, I will be using Apache NetBeans 12. The project can now be built and deployed to a container, such as Payara server. The project comes configured and ready to begin adding RESTful services. The following code shows the generated PoolserviceApplication class, which was created by the Initializr, contains the @SpringBootApplication annotation.

package org.demo.poolservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PoolserviceApplication {

	public static void main(String[] args) {
		SpringApplication.run(PoolserviceApplication.class, args);
	}

}

The @SpringBootApplication annotation is a shortcut annotation that combines the default functionality of the following three annotations:

@EnableAutoConfiguration: enables Spring Boot auto-configuration
@ComponentScan: enables component scanning on the package where application is loaded
@Configuration: allows registration of extra beans in the context or the ability to import additional configuration classes

Since the application is configured by default, generate a new RESTful service by creating a class named HelloController in the same package and placing the following code into it:

package org.demo.poolservice;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

	@RequestMapping("/")
	public String index() {
		return "Greetings from Spring Boot This is the main service!";
	}

}

The @RestController annotation wires the class up as a RESTful web service controller by combining the traditional @Controller and @ResponseBody annotation functionality. In this example, I am using the request root to serve the response, as the @RequestMapping annotation indicates. Once this controller class has been added and the code has been compiled and redeployed, the URL http://localhost:8080/poolservice can be visited to display the message: "Greetings from Spring Boot This is the main service!".

It is time to add the functionality for reading the current temperature from a text file (written by a Raspberry Pi) by creating a new class named TemperatureReader. This class can be made a contextual bean by annotating it with @Component and specifying a name by which the bean will be referenced. In this case, "temperatureReader". The functionality of the class is very simple, as it reads temperatures from a file that are in the format: (23.5, 78.3), and makes them accessible via currentTemperatureC and currentTemperatureF, respectively.

package org.demo.poolservice;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import org.springframework.stereotype.Component;


@Component("temperatureReader")
public class TemperatureReader {
    
    private String currentTemperatureF;
    
    private String currentTemperatureC;
    
    protected String readTemperatureFile() {
        
        
        String temperatureFile = "/<>/temperature.txt";
        System.out.println("Temperature File: " + temperatureFile);
        java.nio.file.Path path = Paths.get(temperatureFile);
        String currentTemperature = null;
        try (BufferedReader reader = Files.newBufferedReader(path, Charset.forName("UTF-8"))) {

            String currentLine = null;
            while ((currentLine = reader.readLine()) != null) {//while there is content on the current line
                currentTemperature = currentLine;
            }
        } catch (IOException ex) {
            ex.printStackTrace(); //handle an exception here
        }
        return currentTemperature;
    }

    /**
     * @return the currentTemperatureF
     */
    public String getCurrentTemperatureF() {
        String temp = readTemperatureFile();
        currentTemperatureF = temp.substring(temp.indexOf(",") + 1, temp.lastIndexOf(")"));
        return currentTemperatureF;
    }

    /**
     * @param currentTemperatureF the currentTemperatureF to set
     */
    public void setCurrentTemperatureF(String currentTemperatureF) {
        this.currentTemperatureF = currentTemperatureF;
    }

    /**
     * @return the currentTemperatureC
     */
    public String getCurrentTemperatureC() {
        String temp = readTemperatureFile();
        currentTemperatureC = temp.substring(temp.indexOf("(") + 1, temp.lastIndexOf(","));
        return currentTemperatureC;
    }

    /**
     * @param currentTemperatureC the currentTemperatureC to set
     */
    public void setCurrentTemperatureC(String currentTemperatureC) {
        this.currentTemperatureC = currentTemperatureC;
    }
    
}

Finally, to make the temperature readings available via a RESTFul service, create a controller named TemperatureController and annotate it with @RestController. Inject the TemperatureReader by annotating a private TemperatureReader field with @Autowired. The bean can then be used to obtain the temperature via the use of the TemperatureReader field. The URL mapping for the service is supplied via the @RequestMapping("/temperature") annotation on the index() method, which will be used to serve up the temperature at the respective request mapping. The functionality contained within the index() method is very minimal, as it merely calls upon the temperatureReader.getCurrentTemperatureF() method to return the current temperature in Fahrenheit.

package org.demo.poolservice;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class TemperatureController {
    
    @Autowired
    private TemperatureReader temperatureReader;
    
    @RequestMapping("/temperature")
	public String index() {
            return temperatureReader.getCurrentTemperatureF();
	}
    
}

To see the temperature, visit the URL: http://localhost:8080/poolservice/temperature

See the sources at: https://github.com/juneau001/poolServiceSpringBoot

Developing Web & Enterprise Applications for the JVM - "This and That"

noreply@blogger.com (Josh Juneau) — Sun, 23 Aug 2020 16:15:00 +0000

I am starting a new series of blog posts which will cover the ins and outs, tips and tricks of developing web and enterprise applications with Java. Some people refer to enterprise meaning that an application requires interaction with a database and/or communication with other applications and services. Therefore, this blog series will apply to "Web" or "Enterprise" application development for the Java Virtual Machine (JVM) using a number of different technologies.

In this blog series, I will not focus on any single strategy or API, but rather, I will cover a number of technical strategies and options that can be used for developing applications for deployment on the JVM. The main goal is to provide readers with a broad overview of the ecosystem available for the JVM, ensuring that one knows various paths that can be followed to develop sophisticated applications. I also hope to keep each post short and to the point, to allow one more time to develop and experiment, rather than reading my ramblings.

There is no doubt that the JVM is one of the key technologies of our time, as it is installed on millions of devices worldwide, and tens of thousands of applications have been written for the JVM. Even though it is one of the most popular platforms for application development, there tends to be questioning on which path to take when developing certain applications. I like to think of the myriad of options as "tools" that are in the toolshed. We can utilize a Phillips screwdriver to tighten an Allen wrench screw, but it certainly may not be the optimal choice and there are more suitable options available. Much in the same manner, one may use Jakarta EE to develop a microservice just because he or she may know that tech, but there may be better options out there for the particular solution at hand.

Hopefully this blog series will provide you with a better understanding of which tool to choose for your future projects. Just because you know one technology very well, it does not mean that you cannot pick up another technology easily enough and make your toolshed even more substantial for future endeavors. One should continually learn new technologies so that they are not locked into using a single strategy.

To that end...I will start this series by showing how to develop a very simple web service which will be used to provide a temperature reading. The web service end point can be harnessed by clients to obtain the current temperature by reading a file that has been written by a temperature sensor connected to a raspberry pi. In the first post, I will utilize Jakarta EE 8 to build this service.

Note: As you read on in this series, you will see that version numbers of APIs mean the world. As with any technology, web and enterprise development are ever-changing, and so moving from one version to the next usually means that there may be a number of changes in the way a service or application needs to be developed.

The following index will be updated to include posts as they are written for inclusion in this series.

Developing a Simple Web Service with Jakarta EE 8

Developing a Simple Service with Spring Boot

Developing a Simple Web Service with Jakarta EE 8

noreply@blogger.com (Josh Juneau) — Sun, 23 Aug 2020 16:05:00 +0000

For context, Jakarta EE 8 is very much the same as Java EE 6 through Java EE 8. The main differences between Java EE 6 and Jakarta EE 8 are the inclusion of newer specifications and updated technologies that had been added over the years. Moreover, Jakarta EE 8 is an open source platform, whereas Java EE was not open source. When Oracle open sourced Java EE to the Eclipse Foundation, it became known as Jakarta EE.

This example application (web service) will create a WAR file which can be deployed to any Jakarta EE 8-compliant application server container. This includes micro-containers such as Payara Micro or WildFly. To begin, create a Maven based WAR file project in your favorite Integrated Development Environment (IDE). The most prevalent IDE's for developing Jakarta EE 8 applications include Eclipse, IntelliJ, or Apache NetBeans. Another option is to download the Jakarta EE starter project. In this post, I start with the Jakarta EE starter project and then I will open and develop within Apache NetBeans 12. I will deploy to Payara Micro.

To get started, grab a copy of the Jakarta EE starter project simple-hello and copy it into a working directory on your machine. Open the project in your IDE and rename it to PoolService-1.0-SNAPSHOT, as seen in Figure 1.

Figure 1: Rename Project

Modify the class named org.demo.simple.ApplicationConfig, by adding a path. Once finished, it should look as follows:

package com.demo.simple;

import javax.ws.rs.ApplicationPath;
import javax.ws.rs.core.Application;

/**
 * Configures the Jakarta REST application.
 * 
 * @author Ivar Grimstad (ivar.grimstad@eclipse-foundation.org)
 */
@ApplicationPath("resources")
public class ApplicationConfig extends Application {
    
}

This will create a root path for your Jakarta RESTful web services at the path "resources", meaning that in order to access any JAX-RS resources, preface the service name with this path.

Next, develop a controller class that can be utilized for reading the temperature file when invoked. Create a new Java class named org.demo.simple.TemperatureController, which is responsible for reading the file and setting values within variables. The temperature will be in the format (23.5, 74.3) with the first reading being in Celsius, and the second reading being in Fahrenheit.

package com.demo.simple;

import java.io.BufferedReader;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import javax.enterprise.context.RequestScoped;
import javax.inject.Named;

/**
 *
 * @author juneau
 */
@Named
@RequestScoped
public class TemperatureController {
    
    private String currentTemperatureF;
    
    private String currentTemperatureC;
    
    public TemperatureController(){
        
    }
    
    protected String readTemperatureFile() {
        
        String temperatureFile = "<<path-to-file>>/temperature.txt";
        java.nio.file.Path path = Paths.get(temperatureFile);
        String currentTemperature = null;
        try (BufferedReader reader = Files.newBufferedReader(path, Charset.forName("UTF-8"))) {

            String currentLine = null;
            while ((currentLine = reader.readLine()) != null) {//while there is content on the current line
                currentTemperature = currentLine;
            }
        } catch (IOException ex) {
            ex.printStackTrace(); //handle an exception here
        }
        return currentTemperature;
    }

    /**
     * @return the currentTemperatureF
     */
    public String getCurrentTemperatureF() {
        String temp = readTemperatureFile();
        currentTemperatureF = temp.substring(temp.indexOf(",") + 1, temp.lastIndexOf(")"));
        return currentTemperatureF;
    }

    /**
     * @param currentTemperatureF the currentTemperatureF to set
     */
    public void setCurrentTemperatureF(String currentTemperatureF) {
        this.currentTemperatureF = currentTemperatureF;
    }

    /**
     * @return the currentTemperatureC
     */
    public String getCurrentTemperatureC() {
        String temp = readTemperatureFile();
        currentTemperatureC = temp.substring(temp.indexOf("(") + 1, temp.lastIndexOf(","));
        return currentTemperatureC;
    }

    /**
     * @param currentTemperatureC the currentTemperatureC to set
     */
    public void setCurrentTemperatureC(String currentTemperatureC) {
        this.currentTemperatureC = currentTemperatureC;
    }
    
}

An interested service can now inject TemperatureController using Contexts and Dependency Injection (CDI), and call upon getCurrentTemperatureF() or getCurrentTemperatureC() in order to obtain the requested temperature format. As such, lastly create a Jakarta Restful Web Services file named TemperatureResource, and enter the following code:

package com.demo.simple;

import javax.ws.rs.core.Context;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.Consumes;
import javax.ws.rs.Produces;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PUT;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.ws.rs.core.MediaType;

/**
 * JAX-RS Web Service
 *
 * @author juneau
 */
@Path("temperature")
@RequestScoped
public class TemperatureResource {
    
    @Inject
    private TemperatureController temperatureController;

    /**
     * Creates a new instance of TemperatureResource
     */
    public TemperatureResource() {
    }

    /**
     * Calls upon the TemperatureController and obtains the current temperature
     * in Fahrenheit.
     *
     * @return an instance of java.lang.String
     */
    @GET
    @Produces({MediaType.TEXT_PLAIN})
    public String getXml() {
        String currentTemperature = temperatureController.getCurrentTemperatureF();
        return currentTemperature;
    }

    /**
     * PUT method for updating or creating an instance of TemperatureResource
     *
     * @param content representation for the resource
     */
    @PUT
    @Consumes(MediaType.APPLICATION_XML)
    public void putXml(String content) {
    }
    
    /**
     * Calls upon the TemperatureController and retrieves the current temperature
     * in Fahrenheit.  Same as getXml();
     * @return 
     */
    @GET
    @Produces({MediaType.TEXT_PLAIN, MediaType.APPLICATION_JSON})
    @Path("f")
    public String getF() {
        String currentTemperature = temperatureController.getCurrentTemperatureF();
        return currentTemperature;
    }

    /**
     * Calls upon the TemperatureController and retrieves the current temperature
     * in Celsius.
     * @return 
     */
    @GET
    @Produces({MediaType.TEXT_PLAIN, MediaType.APPLICATION_JSON})
    @Path("c")
    public String getC() {
        String currentTemperature = temperatureController.getCurrentTemperatureC();
        return currentTemperature;
    }
    
}

This is a web service that will be made available at the URI /resources/temperature, so when the URL http://localhost:8080/poolService/resources/temperature is entered, then the temperature in Fahrenheit should be displayed. This happens because the method named getXml() is called by default since it is annotated with @GET and does not contain a path. It will return plain text since it is annotated with @Produces({MediaType.TEXT_PLAIN}). If I wish to change the default format to something else, say XML, then I could modify the @Produces annotation to: @Produces({MediaType.APPLICATION_JSON}). The getXml() method invokes the TemperatureController getCurrentTemperatureF() method to read the temperature and return the result.

Use your favorite IDE or the command line to compile and build the project to create a WAR (Web Archive) file named simple-hello.war.

Deployment

I am going to use a micro container to deploy the application. However, it could also be deployed into any other Jakarta EE compatible container such as GlassFish, Payara, or Open Liberty. See the following link for compatible implementations: https://jakarta.ee/compatibility/

In this case, download Payara Micro 5.2020.4 and place the downloaded JAR file into a directory. Next, open a terminal and type in the following to start Payara Micro and deploy the WAR file:

java -jar payara-micro-5.2020.4.jar --deploy <path-to-war-file>/simple-hello.war

This will start the server and output something similar to the following in the terminal:

Payara Micro URLs:
http://<your-machine>:8080/simple-hello

'simple-hello' REST Endpoints:
GET	/simple-hello/resources/application.wadl
GET	/simple-hello/resources/hello
GET	/simple-hello/resources/temperature
PUT	/simple-hello/resources/temperature
GET	/simple-hello/resources/temperature/c
GET	/simple-hello/resources/temperature/f

]]

Input the following URL into the browser to run the service: http://<your-machine>:8080/simple-hello/resources/temperature

Jakarta EE Contribution - Getting Started

noreply@blogger.com (Josh Juneau) — Thu, 28 Nov 2019 21:32:00 +0000

Are you interested in helping out with moving Jakarta EE forward? So am I, and I wanted to provide a few details that can be used to help those who are interested in getting started.

Step 1:

The first step to begin contributing is to sign the Eclipse Foundation Committer and Contributor Agreement (ECA): https://www.eclipse.org/legal/committer_process/re-sign/. The ECA must be signed by anyone who wants to contribute to an Eclipse open source software or specification project. This allows one to have the ability to accept a contributor's pull requests.

The Eclipse ICA (Eclipse Individual Committer Agreement) can be signed by those who do not work for the Eclipse Foundation Member Company when they become a committer.

** Note: Be sure that your employer is okay with you signing the agreement. In many cases it is a win-win for all...as your contributions will benefit the community, including your employer.

Step 2:

Sign up for the mailing lists and get involved. Certainly sign up for the Jakarta Platform Developer mailing list, as many of the details for moving the platform forward are being discussed here.

https://accounts.eclipse.org/mailing-list/jakartaee-platform-dev

Look through the list of projects that are part of Jakarta EE and sign up for the individual mailing lists for those projects which you are interested in helping out: https://projects.eclipse.org/projects/ee4j

A few of the tasks for the delivery of Jakarta EE 9 include the following:

* Take control of the CI/CD pipeline for release.
* Coordinate release across all the projects.
* Make the actual changes to the API, docs and TCK.
* Make the implementation changes on at least one server - probably Eclipse GlassFish.

Hopefully this will be of use to hose who are interested in getting started.

Automating Docker Deployments Using Jib and Payara Micro

noreply@blogger.com (Josh Juneau) — Mon, 26 Nov 2018 16:17:00 +0000

If you are like me, you spend most of your day developing applications. During that time, it is difficult to carve out the time to manage containers. Writing a Dockerfile has almost become part of the normal development process nowadays, but there is a different way. I'd rather spend as much time developing my applications as possible, and leave the Docker configuration as a minimal deployment procedure that is automatically completed for me.

I believe that the folks at Google were thinking in this way when they produced Jib. The Jib project allows one to automate the creation of a Docker image so that the container can simply be started up after building the project. There is no need to create a Dockerfile, as Jib takes care of this for you. Jib works with both Maven and Gradle, and in this post I will demonstrate how to use it with Maven and deploy to Payara Micro. By default, Jib includes a Jetty distribution to which an application will deployed inside of the container. However, I am familiar with Payara Micro and quite enjoy the Payara Micro environment, so I'll bypass the use of Jetty and deploy to Payara Micro in this example.

To begin, it is important to get familiar with the Jib Maven process by reading through the documentation.

In this example I am utilizing the SportsTeamQueryService microservice that I produced for a Java Magazine article in 2018, but simply modifying the POM file to incorporate the Jib build. I will not go into full detail on Jib in this post, as the documentation itself does quite well. Rather, I will explain how I was able to get this project to build and deploy to Docker on my Mac. If using a different OS, you may have to configure host-container networking in order for the container to communicate with the host database.

To begin, the POM file looks like the following, including only those dependencies that are required for the project. I call your attention to the <plugins> section for the Jib hooks:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>org.javamagazine</groupId>
<artifactId>SportsTeamQueryService</artifactId>
<version>1.0</version>
<packaging>war</packaging>

<name>SportsTeamQueryService</name>

<properties>
<endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<dependencies>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.jpa</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>javax.ws.rs-api</artifactId>
<version>2.1</version>
<scope>provided</scope>
</dependency>

<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.core</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.ejb</groupId>
<artifactId>javax.ejb-api</artifactId>
<version>3.2.2</version>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.asm</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.antlr</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.jpa.jpql</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>javax.persistence</artifactId>
<version>2.1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.eclipse.persistence</groupId>
<artifactId>org.eclipse.persistence.jpa.modelgen.processor</artifactId>
<version>2.5.2</version>
<scope>provided</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArguments>
<endorseddirs>${endorsed.dir}</endorseddirs>
</compilerArguments>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>2.3</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>

<plugin>
<groupId>com.google.cloud.tools</groupId>
<artifactId>jib-maven-plugin</artifactId>
<version>0.10.0</version>
<configuration>
<from>
<image>
payara/micro:latest
</image>
</from>
<to>
<image>sportsteamqueryservice</image>
</to>
<container>
<appRoot>/opt/payara/SportsTeamQueryService</appRoot>
<args>
<arg>
--addlibs
</arg>
<arg>
/jars/derbyclient.jar
</arg>
<arg>
--deploy
</arg>
<arg>
/opt/payara/SportsTeamQueryService
</arg>
</args>
<environment>
<DOCKER_HOST>docker.for.mac.localhost</DOCKER_HOST>
<DB_NAME>ACME</DB_NAME>
<DB_USER>acmeuser</DB_USER>
<DB_PASSWORD>password</DB_PASSWORD>
</environment>
</container>
</configuration>
</plugin>
</plugins>
</build>

</project>

In the POM, I added the Jib workflow within the <plugins> section. In this project I utilized the latest Jib dependency at the time of writing, using the following maven coordinates:

<groupId>com.google.cloud.tools</groupId>
<artifactId>jib-maven-plugin</artifactId>
<version>0.10.0</version>

The <configuration> portion of the plugin specifies custom configuration for my project. If I leave the <configuration> section off the declaration, then the WAR file generated by the project will be deployed to a Docker image containing a Jetty server. The WAR file will be available at the Jetty ROOT. Instead, since I am interested in using Payara Micro, I customized the Jib declaration as follows:

1) Inherit FROM the latest hosted Payara Micro image using the <from><image> tags.

2) Next, the <to><image> tags declare the name of the resulting Docker image.

3) Add a <container> section to specify details about the container.
a) First, I added an <appRoot> tag to specify that the WAR file will be loaded into the "/opt/payara/" location, within the "SportsTeamQueryService" directory.

b) Next, I added a number of arguments by specifying <args><arg></arg></args>.

The first argument adds the Apache Derby Jar file to the deployment. One note is that in the project itself, there is a "src/main/jib/jars" folder. You must add the derbyclient.jar file inside of this "jib/jars" folder so that it is copied into the image. By default, Jib adds anything within the "src/main/jib" folder into the project image.

The second argument specifies the Payara Micro "--deploy" argument and points to the "/opt/payara/SportsTeamQueryService" directory...which is the exploded WAR for the project.

c) Lastly, add the <environment> section to specify any environment variables that will be passed into the image. In this case, I added database-specific environment variables. If you take a look at the glassfish-resources.xml file within the project, you can see that these environment variables are referenced to configure the datasource.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE resources PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Resource Definitions//EN" "http://glassfish.org/dtds/glassfish-resources_1_5.dtd">
<resources>
<jdbc-connection-pool ..abbreviated for brevity...>
<property name="serverName" value="${ENV=DOCKER_HOST}"/>
<property name="portNumber" value="1527"/>
<property name="databaseName" value="${ENV=DB_NAME}"/>
<property name="User" value="${ENV=DB_USER}"/>
<property name="Password" value="${ENV=DB_PASSWORD}"/>
<property name="URL" value="jdbc:derby://${ENV=DOCKER_HOST}:1527/acme"/>
<property name="driverClass" value="org.apache.derby.jdbc.ClientDriver"/>
</jdbc-connection-pool>
<jdbc-resource enabled="true" jndi-name="java:app/jdbc/acme" object-type="user" pool-name="derby_net_acme_acmeuserPool"/>
</resources>

Note that you may need to modify the servername environment variable if not using Docker for Mac.

That is it for configuring Jib! Now all that is required is simply to build the project and deploy the image to your local Docker repository. In this case, I open the terminal and traverse inside of the SportsTeamQueryService-Jib project directory and issue the following Maven build:

mvn clean install

After the project has been built, invoke the Jib build by issuing the following:

mvn compile jib:dockerBuild

The Docker image should now be ready to start within the local Docker environment. To start the container, issue the following:

docker run -d -p 8080:8080 sportsteamqueryservice

The container should now be up and running. Visit the URL http://localhost:8080/SportsTeamQueryService/rest/teamrosterqueryservice/findAll to see the list of players.

In order to rebuild the Docker image, simply issue the command:

mvn compile jib:dockerBuild

Project Sources: https://github.com/juneau001/SportsTeamQueryService-Jib

Oracle Code One...A Conference I'll Never Forget

noreply@blogger.com (Josh Juneau) — Sun, 28 Oct 2018 06:35:00 +0000

In the spring of 2018 when Oracle Code One was first announced, I was fairly certain that I would not be attending this year. The main reason is because I normally only attended the JavaOne conference every couple of years, and I thought this would be an "off" year. Since I hadn't planned on attending, I did not submit any talks. I was happy to be asked to join the "Content Selection Committee" for Oracle Code One, as I had been a member of the selection committee for a number of JavaOne conferences in the past. I enjoy being part of the committee, as it is great to see the diversity of talks submitted to the conference each year.

As the conference was about a month out, I received a surprise email congratulating me on being a 2018 Duke's Choice Award winner. I was flabbergasted, and in complete disbelief. So much so, that I replied to the email and asked if the sender had the correct person, and why I had been chosen to win this award. I received an email response confirming that I indeed did win, and I had been chosen as the "Java EE" winner this year. During the nomination period for the Duke's Choice Award, I had nominated a couple of projects...but I couldn't believe that someone had nominated me. Still in disbelief, I knew that this had certainly changed things, and I was no doubt going to attend the conference this year.

This was going to be a different type of conference, as I was not speaking for the first time at this conference in years. Since I had no talks to prepare for, I signed up for a time slot in the Hackergarten on Tuesday. My friend and podcast colleague Freddy Guime purchased recording equipment so I could get some interviews for the Java PubHouse and OffHeap podcasts...so I now had plenty of things to do while at the conference! Luckily, I was able to have my wife attend the conference with me so that she could be there as I received this surprising Duke's Choice award.

I was very lucky to have the opportunity to attend the Java Champions summit on Saturday before the conference. It was great to meet up with old friends again and listen to some amazing speakers at the Java Champions summit. There were talks covering: the new Java release cadence, Jakarta EE, MicroProfile, Machine Learning, OpenJFX, Java and Containers, Women In Tech, JUG Evolution in Latin America, and JCP EC Update. Excellent speakers, great friends, and very awesome...especially because this was my first "JavaOne" (okay...Code One but JavaOne always holds a place in my heart) as a Java Champion...being that I was inducted into the program in March of 2017.

I spent Sunday with my wife visiting the sites of San Francisco. We were lucky to have such great weather to see places like Chinatown and Fisherman's Wharf. We attended the "Java in the Cloud" event at the Thirsty Bear that evening, and it was great to see even more familiar faces that evening. It really is the networking at conferences such as Oracle Code One that makes the event.

Monday was full of great sessions, as I started off right with attending a talk from Adam Bien on Jakarta EE. As per his standard, the talk contained some live coding and excellent examples of how to package Java EE applications into Docker containers. I also attended a talk on "Serverless" from Ivar Grimstad, which focused on writing serverless functions and deploying to different cloud solutions. After these talks, I attended a "JUG Leaders and User Group Appreciation Luncheon" with several other esteemed Java community members. I had the honor of attending to represent the Chicago Java User's Group (CJUG). After lunch, I attended a talk on MicroProfile by Emily Jiang and Antoine Sabot-Durand...excellent session! Other sessions and an excellent Java Keynote concluded my Monday at the conference. I then headed out with my wife to the annual JCP party. This event has become one of my favorite gatherings whenever I attended the conference, and this year was no different...a great time was had by all who attended.

Tuesday was full of more great sessions, and it was also award day! I worked the Hackergarten in the morning, where I finished up some licensing reviews for Apache NetBeans enterprise modules, and worked on testing Mojarra 2.3.9. This was an especially great day because I had learned on Monday that the Apache NetBeans community was going to be receiving the Duke's Choice Award this year also...so I had the very rare opportunity to celebrate the Duke's Choice Award with the NetBeans Community, as well as for "Java EE". Prior to the award ceremony in the afternoon, I visited the Java Hub with my wife and we explored the great vendor booths and fun activities such as the Java Escape Rooms. As we gathered in the afternoon for the award ceremony, I saw and congratulated other members of the Apache NetBeans team.

The first Duke's Choice Award was presented to Apache NetBeans, and it was surreal as we community members went on stage to receive the award as a community. Many other great projects won the award as well. MicroProfile was then presented the award, and to my surprise it was being presented to me! This was the award that I was emailed about a month earlier...it was not for "Java EE", but rather, it was for MicroProfile! I was shocked, surprised, and truly honored to have the privilege to accept the Duke's Choice Award on behalf of the MicroProfile community!! Luckily enough, my friend David Heffelfinger was in attendance for the Apache NetBeans award, so I was able to get a photo with the Duke's Choice Award with him, as he is another member of the Java EE and MicroProfile community. I was glad to have the great privilege of taking a photo together with some members of the MicroProfile community later that evening after the MicroProfile BoF session.

As mentioned, I am truly honored for having the opportunity to receive the award on behalf of the MicroProfile community. This community has done amazing things in a very short time. There are so many esteemed members of the Java community that contribute to the MicroProfile project...and I only wish that I had known that the award was for MicroProfile so that I could have invited them all to attend the award event to celebrate as a community. Regardless...the MicroProfile community has made a tremendous impact to enterprise Java, and every member of the community should be proud of this win!! The Dukes Choice Award is the most highly regarded award in the Java Ecosystem...and MicroProfile has achieved this award in such a short time...it is amazing!

Photo: Josh Juneau and David Heffelfinger

I spent much of my Wednesday attending other sessions and recording interviews for the Java PubHouse and OffHeap podcasts. I was so lucky to have well known members of the Java Community take a few moments out of their day to give me insight to their conference experience. I wish I had more time to meet with many others in the community...but time flies so fast at the conference that it seemed as though I never had a spare minute!

I mentioned before that the Java Community makes the conferences worth attending. That is what it is all about! I met so many old friends and made many new acquaintances. Not only did I meet up with many amazing Java luminaries, but I was lucky enough to finally meet up with a fellow Apress author Alex Jecan and Apress editor Jonathan Gennick. It was also great to meet up with so many others such as Oracle Java Magazine editor in chief Andrew Binstock.

I also had the unique opportunity to be with the Apache NetBeans community to accept the 2018 Duke's Choice Award, and I had the honor of accepting the 2018 Duke's Choice Award on behalf of the MicroProfile community! This will certainly be a conference that I will never forget. I want to thank the folks are Oracle, including those that run the Java Champions program, and my organization for helping to make this year's trip to Oracle Code One possible for me. Thanks Oracle Code One for an amazing conference...and I look forward to attending again and meeting up with all of my friends in the amazing Java community!

Photo (left-to-right): John Clingan, Ken Finnigan, Mark Little, Ian Robinson, Reza Rahman, Emily Jiang, Josh Juneau

Micronaut for Java EE/Jakarta EE Developers

noreply@blogger.com (Josh Juneau) — Tue, 18 Sep 2018 11:12:00 +0000

There is a new microservices framework in town called Micronaut. In this post, I'll discuss how I've ventured into working with the Micronaut framework from a Java EE/Jakarta EE perspective. I am a Java EE developer, so developing microservices using solutions such as Eclipse MicroProfile are closer to my line of expertise, but Micronaut caught my attention since it offers the following abilities:

- Develop in Java, Groovy, or Kotlin
- Easy to test..fully integrated testing with Spock or JUnit
- Embedded Server & Compile Time HTTP Client
- Easy packaging for Docker
- Fast startup time, low memory consumption
- Fully Reactive

As an enterprise developer at heart, my first thought usually goes to the database, as the majority of applications that I author utilize an RDBMS. I found the number of examples using Micronaut with an RDBMS to be few and far between, so I thought it may be useful for me to create another example for that use case. In this example, I utilize PostgreSQL. However, most other RDBMS are also supported. This article is not meant to be a full explanation of installing Micronaut or utilizing all of the many Micronaut features. Instead, it is a primer for those looking to get started utilizing Micronaut with a relational database...particularly geared towards those with some Java EE/Jakarta EE background.

In my particular case, I am interested in quickly spinning up Microservices that are fully testable, extensible, and efficient. Although I can do this with MicroProfile or standard Java EE, I thought it would be interesting to learn something new and also have the ability to utilize Groovy or Kotlin. I also wanted to put a Java EE/Jakarta EE spin on it...so I'm using JPA for working with the data. Many of the Micronaut examples utilize Groovy and GORM for persistence...but I likely wouldn't be using that in any of my applications.

The example was developed using Apache NetBeans 9.0 and the Command Line Interface (CLI) that comes packaged with Micronaut. This particular example was written against Micronaut 1.0.0.M4. In this case, I kept it simple and utilized only a single, basic database table for persistence within a PostgreSQL database.

To begin, I created an app by utilizing the CLI by issuing the following command:

mn create-app org.acme.books --features hibernate-jpa,jdbc-tomcat

This simply creates a skeleton for my app within a directory named "books", and the Application.java main class will be placed within the org.acme.books package. By default, there are basic features supported by an application, but in this case I've added support for the Tomcat connection pool. This will be utilized when creating database connections via the Java Persistence API (JPA). The default application is also generated with support for the Gradle build system. Therefore, a build.gradle is created, and that is the file in which dependency management will take place. Note that an application can also be generated utilizing the Apache Maven build system, but I had issues running Maven projects under Micronaut 1.0.0.M4...so I stuck with Gradle for this example.

If using Apache NetBeans 9.0, you can install the "Groovy and Grails" and "Gradle" plugins (currently available in the NetBeans 8.2 plugin center) to provide support for opening the project. Once this is completed, the project can be opened within NetBeans and development can begin. After installing the plugins and opening the project within Apache NetBeans, the completed project structure should look like that in the following figure:

To provide support for the PostgreSQL database, I added the dependencies to build.gradle:

compile group: 'org.postgresql', name: 'postgresql', version: '42.2.5'

Next, I opened up the application.yml file and added a datasource for the application. This is the file that takes place of a persistence.xml within a traditional Java EE application. Also, JPA support is added via this file, indicating which package includes the entity classes, as well as configuration of Hibernate. Port 8080 is also set, as by default Micronaut will choose a random port on which to start the server. The full sources of application.xml are as follows:

micronaut:
application:
name: books

#Uncomment to set server port
server:
port: 8080

---
datasources:
default:
url: jdbc:postgresql://localhost/postgres
username: postgres
password: yourpassword
driverClassName: org.postgresql.Driver
connectionTimeout: 4000
jpa:
default:
packages-to-scan:
- 'org.acme.domain'
properties:
hibernate:
hbm2ddl:
auto: update
show_sql: true

Now that the configuration is out of the way, I can get to the fun part...development. In this example, I create a basic service allowing one to create, read, update, or delete records in the BOOK table. The automatically generated Application class within the org.acme package, which starts the service.

package org.acme;

import io.micronaut.runtime.Micronaut;

public class Application {

public static void main(String[] args) {

Micronaut.run(Application.class);

}

To begin development, create two packages within the application for organizing the source code. First, create org.acme.domain, which will contain the entity class. Next, create org.acme.book, which will contain the implementation classes. Create a Book.java class within the org.acme.domain package, which will be the entity class containing a standard JPA mapping for the database. In this case, note that I utilize java.time.LocalDate for the date fields, and I utilize a database sequence generator for population of the primary key. The sources are as follows:

package org.acme.domain;

import java.time.LocalDate;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.SequenceGenerator;

import javax.persistence.Table;

import javax.validation.constraints.NotNull;

/**

* JPA Mappings for the BOOK database table.

@Entity

@Table(name="BOOK")

public class Book {

@Id

@GeneratedValue(strategy=GenerationType.SEQUENCE,

generator="book_generator")

@SequenceGenerator(name="book_generator",sequenceName="book_s", allocationSize=1)

private Long id;

@Column(name="PUBLISH_DATE")

@NotNull

private LocalDate publishDate;

@Column(name="TITLE")

@NotNull

private String title;

@Column(name="AUTHOR_FIRST")

@NotNull

private String authorFirst;

@Column(name="AUTHOR_LAST")

@NotNull

private String authorLast;

private Long pages;

public Book(){}

public Book(@NotNull Long id, @NotNull LocalDate publishDate, @NotNull String title, String authorFirst, String authorLast, Long pages){

this.id = id;

this.publishDate = publishDate;

this.title = title;

this.authorFirst = authorFirst;

this.authorLast = authorLast;

this.pages = pages;

}

public Book(@NotNull LocalDate publishDate, @NotNull String title, String authorFirst, String authorLast, Long pages){

this.publishDate = publishDate;

this.title = title;

this.authorFirst = authorFirst;

this.authorLast = authorLast;

this.pages = pages;

}

/**

* @return the id

public Long getId() {

return id;

}

/**

* @param id the id to set

public void setId(Long id) {

this.id = id;

}

/**

* @return the publishDate

public LocalDate getPublishDate() {

return publishDate;

}

/**

* @param publishDate the publishDate to set

public void setPublishDate(LocalDate publishDate) {

this.publishDate = publishDate;

}

/**

* @return the title

public String getTitle() {

return title;

}

/**

* @param title the title to set

public void setTitle(String title) {

this.title = title;

}

/**

* @return the authorFirst

public String getAuthorFirst() {

return authorFirst;

}

/**

* @param authorFirst the authorFirst to set

public void setAuthorFirst(String authorFirst) {

this.authorFirst = authorFirst;

}

/**

* @return the authorLast

public String getAuthorLast() {

return authorLast;

}

/**

* @param authorLast the authorLast to set

public void setAuthorLast(String authorLast) {

this.authorLast = authorLast;

}

/**

* @return the pages

public Long getPages() {

return pages;

}

/**

* @param pages the pages to set

public void setPages(Long pages) {

this.pages = pages;

}

@Override

public String toString() {

return "Book{" +

"id=" + id +

", publishDate='" + publishDate + '\'' +

", title='" + title + '\'' +

", authorFirst='" + authorFirst + '\'' +

", authorLast='" + authorLast + '\'' +

", pages='" + pages +

'}';

}

In a Micronaut application, HTTP requests and responses need to be encapsulated in Serializable classes for processing, and therefore it makes sense to generate some simple "Plain Old Java Objects" (POJOs) for encapsulating the data that will be used within database operations. In the same org.acme.domain package, I created two such classes, BookSaveOperation.java and BookUpdateOperation.java. These classes will define the fields required for passing data from the HTTP request to the controller class. The sources for BookSaveOperation.java are as follows (see the GitHub repository for full sources):

package org.acme.domain;

import java.time.LocalDate;

import javax.validation.constraints.NotBlank;

import javax.validation.constraints.NotNull;

/**

* @author Josh Juneau

public class BookSaveOperation implements java.io.Serializable {

@NotNull

private LocalDate publishDate;

@NotNull

@NotBlank

private String title;

@NotNull

@NotBlank

private String authorFirst;

@NotNull

@NotBlank

private String authorLast;

private Long pages;

public BookSaveOperation(){}

public BookSaveOperation(LocalDate publishDate, String title,

String authorFirst, String authorLast, Long pages){

this.publishDate = publishDate;

this.title = title;

this.authorFirst = authorFirst;

this.authorLast = authorLast;

this.pages = pages;

}

// ...

// getters and setters

// ...

}

The application business logic occurs within a class which is much like an EJB or DAO implementation, and the class must implement an interface that has defined each of the business logic methods. In this case, I created an interface org.acme.book.BookRepository.java, and define a few standard operational methods:

package org.acme.book;

import java.time.LocalDate;

import java.util.List;

import java.util.Optional;

import org.acme.domain.Book;

/**

public interface BookRepository {

Book save(LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages);

Optional<Book> findById(Long id);

void deleteById(Long id);

List<Book> findAll();

int update(Long id, LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages);

}

Next, implement that interface within a class entitled org.acme.book.BookRepositoryImpl.java, and annotate as a @Singleton. Since this is the class which will implement business logic, inject a PersistenceContext, which provides the JPA EntityManager that will be used for performing database operations. Simply implement each of the operations outlined within the BookRepository interface, marking each with @Transactional (io.micronaut.spring.tx.annotation.Transactional), implying read only for those methods that will not modify any data. The sources for BookRepositoryImpl.java are as follows:

package org.acme.book;

import io.micronaut.configuration.hibernate.jpa.scope.CurrentSession;

import io.micronaut.spring.tx.annotation.Transactional;

import java.time.LocalDate;

import java.util.List;

import java.util.Optional;

import javax.inject.Singleton;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import org.acme.domain.Book;

/**

* Business logic for the service.

@Singleton

public class BookRepositoryImpl implements BookRepository {

@PersistenceContext

private EntityManager entityManager;

public BookRepositoryImpl(@CurrentSession EntityManager entityManager) {

this.entityManager = entityManager;

}

@Override

@Transactional

public Book save(LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages) {

Book book = new Book(publishDate, title, authorFirst, authorLast, pages);

entityManager.persist(book);

return book;

}

@Override

@Transactional(readOnly = true)

public Optional<Book> findById(Long id) {

return Optional.ofNullable(entityManager.find(Book.class, id));

}

@Transactional(readOnly = true)

public List<Book> findAll() {

return entityManager

.createQuery("SELECT b FROM Book b", Book.class)

.getResultList();

}

@Override

@Transactional

public int update(Long id, LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages) {

return entityManager.createQuery("UPDATE Book b SET publishDate = :publishDate, title = :title, " +

"authorFirst = :authorFirst, authorLast = :authorLast, pages = :pages where id = :id")

.setParameter("publishDate", publishDate)

.setParameter("title", title)

.setParameter("authorFirst", authorFirst)

.setParameter("authorLast", authorLast)

.setParameter("pages", pages)

.setParameter("id", id)

.executeUpdate();

}

@Override

@Transactional

public void deleteById(Long id) {

findById(id).ifPresent(book -> entityManager.remove(book));

}

In an effort to explain the Micronaut application infrastructure from a Java EE perspective, I'll compare the implementation with a simple JAX-RS application. Micronaut utilizes io.micronaut.http.annotation.Controller classes to perform the request-response handling for a service. This is much like a JAX-RS controller class, with a few slight differences. This very much reminds me of the Eclipse Krazo project, or MVC 1.0 for Java EE. For instance, instead of annotating methods with the JAX-RS annotations javax.ws.rs.GET, javax.ws.rs.POST, or javax.ws.rs.Path, Micronaut uses io.micronaut.http.annotation.Get and io.micronaut.http.annotation.Post, among others. The URI path for each of the methods can be directly declared via the @Get, @Post, @Put, @Delete annotations. Each controller class will implement the functionality for the service and handles the request-response life cycle. The business logic for persistence (contained within the BookRepositoryImpl class) is injected into the controller class via the @Inject annotation or via constructor injection. In the sources for this example, constructor injection is used.

package org.acme.book;

import org.acme.domain.Book;

import io.micronaut.http.HttpHeaders;

import io.micronaut.http.HttpResponse;

import io.micronaut.http.annotation.Body;

import io.micronaut.http.annotation.Controller;

import io.micronaut.http.annotation.Delete;

import io.micronaut.http.annotation.Get;

import io.micronaut.http.annotation.Post;

import io.micronaut.http.annotation.Put;

import io.micronaut.validation.Validated;

import javax.validation.Valid;

import java.net.URI;

import java.util.List;

import org.acme.domain.BookSaveOperation;

import org.acme.domain.BookUpdateOperation;

@Validated

@Controller("/books")

public class BookController {

protected final BookRepository bookRepository;

public BookController(BookRepository bookRepository) {

this.bookRepository = bookRepository;

}

@Get("/")

public List<Book> list() {

return bookRepository.findAll();

}

@Put("/")

public HttpResponse update(@Body @Valid BookUpdateOperation operation) {

bookRepository.update(operation.getId(), operation.getPublishDate(),

operation.getTitle(), operation.getAuthorFirst(), operation.getAuthorLast(), operation.getPages());

return HttpResponse.noContent().header(HttpHeaders.LOCATION, location(operation.getId()).getPath());

}

@Get("/{id}")

Book show(Long id) {

return bookRepository

.findById(id)

.orElse(null);

}

@Delete("/{id}")

HttpResponse delete(Long id) {

bookRepository.deleteById(id);

return HttpResponse.noContent();

}

@Post("/")

HttpResponse<Book> save(@Body @Valid BookSaveOperation operation) {

Book book = bookRepository.save(operation.getPublishDate(), operation.getTitle(),

operation.getAuthorFirst(), operation.getAuthorLast(), operation.getPages());

return HttpResponse

.created(book)

.headers(headers -> headers.location(location(book)));

}

protected URI location(Book book) {

return location(book.getId());

}

protected URI location(Long id) {

return URI.create("/books/" + id);

}

Testing the Application

Micronaut provides easy testing with Spock or JUnit and an embedded server...making it easy to create tests for each of the controllers. In this case, I utilize JUnit to test the application. I created a testing class within the test folder of the project named org.acme.BookControllerTest.

package org.acme;

import io.micronaut.context.ApplicationContext;

import io.micronaut.core.type.Argument;

import io.micronaut.http.HttpHeaders;

import io.micronaut.http.HttpRequest;

import io.micronaut.http.HttpResponse;

import io.micronaut.http.HttpStatus;

import io.micronaut.http.client.HttpClient;

import io.micronaut.runtime.server.EmbeddedServer;

import java.time.LocalDate;

import java.util.ArrayList;

import java.util.List;

import org.acme.domain.Book;

import org.acme.domain.BookSaveOperation;

import org.acme.domain.BookUpdateOperation;

import org.junit.AfterClass;

import static org.junit.Assert.assertEquals;

import org.junit.BeforeClass;

import org.junit.Test;

/**

* Test cases for BookController

public class BookControllerTest {

private static EmbeddedServer server;

private static HttpClient client;

private Book book;

HttpRequest request;

HttpResponse response;

Long id;

List<Long> bookIds = new ArrayList<>();

@BeforeClass

public static void setupServer() {

server = ApplicationContext.run(EmbeddedServer.class);

client = server.getApplicationContext().createBean(HttpClient.class, server.getURL());

}

@AfterClass

public static void stopServer() {

if (server != null) {

server.stop();

}

if (client != null) {

client.stop();

}

@Test

public void testInsertBooks() {

request = HttpRequest.POST("/books", new BookSaveOperation(LocalDate.now(), "Java EE 8 Recipes", "Josh", "Juneau", new Long(750)));

response = client.toBlocking().exchange(request);

assertEquals(HttpStatus.CREATED, response.getStatus());

request = HttpRequest.POST("/books", new BookSaveOperation(LocalDate.now(), "Java 9 Recipes", "Josh", "Juneau", new Long(600)));

response = client.toBlocking().exchange(request);

id = entityId(response, "/books/");

assertEquals(HttpStatus.CREATED, response.getStatus());

}

@Test

public void testBookRetrieve() {

request = HttpRequest.GET("/books");

List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));

// Populate a book instance for later

for(Book b:books){

book = b;

}

assertEquals(2, books.size());

}

@Test

public void testBookOperations() {

request = HttpRequest.GET("/books");

List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));

// Populate a book instance for later

for(Book b:books){

book = b;

}

request = HttpRequest.PUT("/books/", new BookUpdateOperation(book.getId(),

book.getPublishDate(),

"Java 10 Recipes",

book.getAuthorFirst(),

book.getAuthorLast(),

book.getPages()));

response = client.toBlocking().exchange(request);

assertEquals(HttpStatus.NO_CONTENT, response.getStatus());

request = HttpRequest.GET("/books/" + book.getId());

book = client.toBlocking().retrieve(request, Book.class);

assertEquals("Java 10 Recipes", book.getTitle());

testDelete();

}

public void testDelete(){

request = HttpRequest.GET("/books");

List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));

// Populate a book instance for later

for(Book b:books){

request = HttpRequest.DELETE("/books/" + b.getId());

response = client.toBlocking().exchange(request);

assertEquals(HttpStatus.NO_CONTENT, response.getStatus());

}

Long entityId(HttpResponse response, String path) {

String value = response.header(HttpHeaders.LOCATION);

if (value == null) {

return null;

}

int index = value.indexOf(path);

if (index != -1) {

return Long.valueOf(value.substring(index + path.length()));

}

return null;

}

Walk-Through of the Logic in Testing Class

In the method that runs @BeforeClass, the HTTP server and client are created. Similarly, when the tests have finished executing, the method that is annotated with @AfterClass is invoked, which stops the server if it is running.

From within the textInsertBooks() method, two new book records are created by passing new BookSaveOperation objects populated with data to the service that is available via the "/books" path with the @Post designation. In this case, the controller method BookController.save() is invoked. Taking a look at the save() method, you can see that the method simply passes the contents of BookSaveOperation to the BookRepository.save() business method (utilizing the interface), persisting the object. In the end, an HttpResponse is returned.

The testBookRetrieve() method calls upon the service that is available via the "/books" path containing the @Get designation. This, in-turn, calls upon the BookController.list() method, which performs a findAll() on the BookRepository, returning a List of Book objects.

The testBookOperations() method is responsible for performing updates to the records. First, the list of Book objects is retrieved from the BookController, and then one of the books is updated via the BookController.update() method by populating a BookUpdateOperation object with the contents to be updated.

** Keep in mind, the BookSaveOperation.java and BookUpdateOperation.java objects are simply POJOs that are used to move the data

Lastly, the testDelete() method is invoked, which traverses the List of Book objects, calling upon the BookController.delete() method via the service call to the "/books" path and invoking the method designated as @Delete.

To execute the tests, simply right-click the project in NetBeans and choose "Test", or use the command line to invoke using the following command

./gradlew test

If the database table has not yet been created, then it will be generated for you. Note that you may need to modify the database configuration within application.yml accordingly for your environment.

Running the Service

Micronaut is self-contained, allowing a service to be executed using the embedded server which is built on Netty. This can be done by right-clicking the project in Apache NetBeans and selecting "Run". You could also go to the command line and invoke using the following command:

./gradlew run

You should see the URL on which the server is hosted displayed within the output in the terminal or Apache NetBeans output panel.

Summary

As a Java EE developer, I have to say that Micronaut does have a different development approach. It is not too much different than that of Spring Boot or Grails, but it is different enough that it took me some time to find my way around. In the end, I find it an easy to use framework that has a lot of potential for quickly developing services or scheduled tasks, while still harnessing some of the concepts from Java EE/Jakarta EE.

There are a number of features that I've not played much with yet, such as creating scheduled tasks via the Micronaut framework, and developing using Groovy or Kotlin, rather than Java. I hope to follow up to this post in the future with more information for Java EE and Jakarta EE developers who are interested in beginning their journey with Micronaut.

GitHub Project: https://github.com/juneau001/micronaut-books

Micronaut JPA-Hibernate Guide: http://guides.micronaut.io/micronaut-data-access-jpa-hibernate/guide/index.html

Apache NetBeans 9.0 - How to Build & Run the Latest

noreply@blogger.com (Josh Juneau) — Fri, 22 Jun 2018 17:12:00 +0000

In my last post, I spoke about how to obtain the Release Candidate of Apache NetBeans 9.0. There have been some changes made since the Release Candidate (including the addition of a very nice updated splash screen), so in this post I will cover how to build and run the latest sources. I really is quite simple to run the latest code...here's how:

1) Clone the latest source code from the GitHub repository to your local machine:

git clone https://github.com/apache/incubator-netbeans.git

2) Open your terminal and traverse inside of the cloned directory named "incubator-netbeans"

3) Build the IDE using Apache Ant. If you do not have it installed, please download from here: https://ant.apache.org/

To build, simply issue the "ant" command from within the "incubator-netbeans" directory.

4) The build process will take several minutes, as it obtains all of the dependencies and performs the compilation process. Once completed, open the incubator-netbeans/nbbuild directory, and you should see a directory entitled "netbeans". Inside this directory are all of the files required to run the Apache NetBeans IDE. You can run the IDE by invoking the incubator-netbeans/nbbuild/netbeans/bin/netbeans executable.

Once the executable is started, you will be presented with the new Apache NetBeans 9.0 splash screen, and you can then begin to use the latest build.

Apache NetBeans 9.0 - Release Candidate Review

noreply@blogger.com (Josh Juneau) — Mon, 21 May 2018 11:53:00 +0000

First, I want to thank all of the developers that have been working hard on the Apache NetBeans 9.0 release. I am on the mailing lists and these developers have been working around the clock to ensure that this release is solid. I was part of the NetBeans 9.0 NETCAT testing team for the profiler tool this year. I only contributed a few hours of testing, but it was a great experience to be part of the team helping to move NetBeans forward. There are plenty of people who have contributed dozens of hours...so thank you!

Release Candidate 1 (currently in testing and not yet officially released) can be downloaded using the following links:

Build Artifacts:
https://dist.apache.org/repos/dist/dev/incubator/netbeans/incubating-netbeans-java/incubating-9.0-rc1-rc1

ZIP Artifact:
https://dist.apache.org/repos/dist/dev/incubator/netbeans/incubating-netbeans-java/incubating-9.0-rc1-rc1/incubating-netbeans-java-9.0-rc1-source.zip

This release of NetBeans constitutes all of the modules within the Apache NetBeans GitHub repository ((https://github.com/apache/incubator-netbeans). These modules include the NetBeans Platform and the full IDE for Java SE development.

There are still a number of tasks that will need to be performed before moving forward, but Release Candidate 1 is a huge step. In the coming days/weeks, there will likely be another release candidate which will include some final pieces, such as a new splash screen. We are getting very close to the official Apache NetBeans IDE 9.0 release.

Keep in mind that this first release does not include the transfer of all NetBeans modules. For instance, the Java EE modules have not yet been transferred or included in Apache NetBeans 9.0. That transfer will occur sometime in the future. However, it is still possible to develop Java EE applications using Apache NetBeans 9.0 by simply installing the Java EE related NetBeans 8.2 plugins. I am doing this today and it works well!

Stay tuned during the coming weeks for the official release of Apache NetBeans 9.0. In the meantime, get involved! Please download the Release Candidate and take it for a spin. Join the NetBeans developer mailing list to provide feedback and/or vote on upcoming release candidates.

https://netbeans.apache.org/

Easy Java EE Microservices with Payara Micro

noreply@blogger.com (Josh Juneau) — Wed, 29 Nov 2017 14:31:00 +0000

Wondering how to get started with Java EE Microservices? It only takes a few quick steps to deploy a Microservice using Java EE APIs. Many think that Java EE is too heavyweight for use with Microservices, but that is simply not the case...especially if you only utilize the Java EE specifications that are required by your service. In this brief post, I'll demonstrate how to quickly develop a Microservice with Java EE and then deploy to Payara Micro.

To download the example project, please go to GitHub: https://github.com/juneau001/SimpleService

For the purposes of this example, I will utilize NetBeans, but any Java IDE will suffice. To get started, create a Maven web application and name it SimpleService. Next, create two Java packages: org.simpleservice and org.simpleservice.entity. Once complete, the project should resemble the following figure:

Now many believe that a Microservice should not connect to an enterprise database, but I will leave that for those who wish to debate. In this example, I will connect this service to a central Apache derby database to obtain data because I believe this to be a very likely scenario in many organizations. In this case, we'll create a "Suggested Name" database web service, which will query a database table of suggested names for the upcoming EE4J platform. To create the infrastructure, connect to a local Apache Derby database and create it using the following SQL:

create table SUGGESTED_NAME (
id numeric primary key,
name varchar(150));

insert into suggested_name values(1, 'Open EE');
insert into suggested_name values(2, 'Open JOE');
insert into suggested_name values(3, 'Cappucino');

Next, open the Maven POM file for the SimpleService project and add the following dependencies:

<dependencies>
        <dependency>
            <groupId>javax.ws.rs</groupId>
            <artifactId>javax.ws.rs-api</artifactId>
            <version>2.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>javax.persistence-api</artifactId>
            <version>2.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.validation</groupId>
            <artifactId>validation-api</artifactId>
            <version>2.0.0.Final</version>
        </dependency>
        <dependency>
            <groupId>javax.ejb</groupId>
            <artifactId>javax.ejb-api</artifactId>
            <version>3.2</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>eclipselink</artifactId>
            <version>2.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>org.eclipse.persistence.jpa.modelgen.processor</artifactId>
            <version>2.5.2</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.derby</groupId>
            <artifactId>derbyclient</artifactId>
            <version>10.14.1.0</version>
        </dependency>
    </dependencies>

Note that there is no Java EE dependency. This is because I am utilizing only those dependencies that are required for the service. Each dependency is added separately.

Next, create a package org.simpleservice.entity, and create an entity class named SuggestedName within it. For brevity, I'm not going into all of the sources here, but you can check the sources out on GitHub (https://github.com/juneau001/SimpleService).

We'll need to implement our JAX-RS web service class next. To configure the Java EE application for JAX-RS, let's create a class named ApplicationConfig and place it within the org.simpleservice package:

import java.util.Set;
import javax.ws.rs.core.Application;

/**
 *
 * @author Juneau
 */
@javax.ws.rs.ApplicationPath("rest")
public class ApplicationConfig extends Application {
    @Override
    public Set<Class<?>> getClasses() {
        Set<Class<?>> resources = new java.util.HashSet<>();
        resources.add(org.simpleservice.SuggestedNameService.class);
        return resources;
    }
}

Next, I'll create the JAX-RS web service class itself, and I will name it SuggestedNameService. Here are the sources for the SuggestedNameService class. Note that I have injected a Persistence Unit. I will get to that next.



@Stateless

@Path("suggestedNameService")

public class SuggestedNameService {



    @PersistenceContext(unitName = "SimpleService_1.0PU")

    private EntityManager em;





    @GET

    @Path("{id}")

    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})

    public SuggestedName find(@PathParam("id") BigDecimal id) {

        SuggestedName suggestedName = null;

        try {

            suggestedName = (SuggestedName) 

                    em.createQuery("select object(o) from SuggesetedName o " +

                    "where o.id = :id")

                    .setParameter("id", id)

                    .getSingleResult();

        } catch (NoResultException ex){

            System.out.println("Error: "  + ex);

        }

        return suggestedName;

    }

   

    @GET

    @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})

    public List<SuggestedName> findAll() {

        List<SuggestedName> suggestedNames = null;

        try {

            suggestedNames = em.createQuery("select object(o) from SuggestedName o")

                    .getResultList();

        } catch (NoResultException ex){

            System.out.println("Error: "  + ex);

        }

        return suggestedNames;

    }



    protected EntityManager getEntityManager() {

        return em;

    }

    

}

Since this service will connect to a database, I will create a persistence unit for the project. This can be easily done in NetBeans by right-clicking the project and choosing New->Persistence->Persistence Unit. Name the persistence unit SimpleService_1.0PU and use EclipseLink as the provider. Do not add a data source at this point.

Once created, open the Persistence Unit and add the connection information. In this case, I will connect to a JTA data source that I'll define next. The data source is named DerbyDataSource, so the content of the Persistence Unit (persistence.xml) should look as follows:



<?xml version="1.0" encoding="UTF-8"?>


<persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">

  <persistence-unit name="AuthorService_1.0PU" transaction-type="JTA">

    <jta-data-source>java:global/DerbyDataSource</jta-data-source>

    <exclude-unlisted-classes>false</exclude-unlisted-classes>

    <properties/>

  </persistence-unit>

</persistence>

Create a web.xml deployment descriptor for the project. If doing this within NetBeans, simply right-click the project and choose New->Web->"Standard Deployment Descriptor (web.xml) and click Finish. Once the web.xml deployment descriptor has been generated, add the data source to it.



<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"


         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"

         version="3.1">

    <session-config>

        <session-timeout>

            30

        </session-timeout>

    </session-config>



<data-source>

        <name>java:global/DerbyDataSource</name>

        <class-name>org.apache.derby.jdbc.ClientDriver</class-name>

        <server-name>localhost</server-name>

        <port-number>1527</port-number>

        <url>jdbc:derby://localhost:1527/acme</url>

        <user>acmeuser</user>

        <password>yourpassword</password> 

    </data-source>


</web-app>

That's it for the Java EE application. You should now be able to compile the project into a WAR file and deploy to GlassFish, Payara, or another Java EE application server of your choice. In this case, let's deploy to Payara Micro.

To begin, download the latest Payara Micro JAR file from the website: https://www.payara.fish/payara_micro

Once downloaded, the server can be started up by opening a command prompt and executing the JAR with your local Java runtime by typing:

java -jar payara-micro-4.1.2.174.jar

To deploy the application (microservice) that we've created, simply utilize the --deploy option when executing the Payara Micro JAR, and point it to the SimpleService WAR file:

java -jar payara-micro-4.1.2.174.jar --deploy SimpleService-1.0.war

The SimpleService microservice can now be accessed via the following URL: http://localhost:8080/SimpleService-1.0/rest/suggestedNameService

To learn more about Java EE: https://examples.javacodegeeks.com/what-is-java-ee/

Utilizing Apache NetBeans with JDK 9

noreply@blogger.com (Josh Juneau) — Sat, 04 Nov 2017 18:08:00 +0000

Did you know that you can build Apache NetBeans from scratch today and utilize the latest JDK 9 features? Here is how to do it:

Clone the NetBeans Incubator sources to your machine:

git clone https://github.com/apache/incubator-netbeans

Build using JDK 8 and Ant 1.9.9 by traversing into the cloned incubator-netbeans directory and invoking the ant build:

ant

Once the build is complete, traverse into the nbbuild/netbeans directory to see the resulting IDE build. Run the IDE by invoking the executable or shell script contained within nbbuild/netbeans/bin.

Open EE: My Thoughts on an Open Java EE Platform

noreply@blogger.com (Josh Juneau) — Sat, 09 Sep 2017 05:41:00 +0000

About two years ago, thousands of Java developers attended the JavaOne 2015 conference and learned about specifications and features that would be part of the Java EE 8 platform. These features included the MVC 1.0 specification, Java EE Security 1.0, Microservices, CDI and more. Java EE 8 was shaping up to be a great follow-up to the excellent Java EE 7 release.

After JavaOne 2015, progress and news around Java EE went silent. In early January 2016, I received an invite to a Slack group that was created by some members of the Java EE community. On the Slack channel, there were discussions around the halt of Java EE, and what the community may be able to do in order to keep it moving forward. I was humbled by the sense of community from the members of the channel and the devotion to the platform was very evident. Not long after, the Java EE Guardians were formed, focusing on publicizing the stall of Java EE. The group put forth effort pressuring Oracle to make a statement and continue moving Java EE forward. Especially in this fast paced space, looming silence regarding the future of any technology can be taxing on those involved. Others worked on the Java EE specifications as much as possible, making strides forward.

After almost a year of silence, we started to hear music around Java EE again, and at JavaOne 2016 Oracle unveiled the plan to continue moving Java EE 8 forward, albeit a bit differently than originally planned. The newly envisioned Java EE centered around Microservices and dropped a few of the specifications that no longer fit into the puzzle. MVC 1.0, JMS 2.1, and Management 2.0 were taken out of the picture, while the newly proposed Health Checking and Configuration APIs were added. MVC was eventually handed over to the community, which I think was a great move. The Health Checking and Configuration APIs, which were clearly aimed toward microservices support, were later taken out of the picture for Java EE 8 due to lack of time. Java EE 8 had more community involvement than any previous Java EE release, and much of this is likely due to the hiatus. Java EE 8 moves forward, albeit a bit more lean than originally planned, we are moving forward.

Now, nearing the JavaOne 2017 conference, we are on the heels of a Java EE 8 release. This release includes much of the original core Java EE 8 plan, bringing the Java EE platform in-line with Java SE 8. It also enhances CDI support throughout the specifications, brings forth Security 1.0, which is long overdue, and JSON-B, closing the JSON to Java conversion gap that was left after JSON-P was released. Java EE 8 will be a solid release, and I am thankful to all who are involved in making it happen. I am sorry to say that I will not be at the JavaOne conference this year when it will likely be released, but I know that my colleagues will keep me in-tune with the latest news coming from the conference! If you are going, make sure you check out the many great Java EE talks that will be presented.

Almost like a professional sports superstar going out on a high note, Oracle recently announced that they are planning to open source Java EE. I have to applaud Oracle for all of the great work they've done and the support that they've given to Java EE through the years. I am hopeful that they will remain engaged even after Java EE is open sourced, as they are a very important player in this space. In my mind, they chose a perfect time to announce the opening of Java EE, as the Java EE 8 release will mark a great milestone making Java EE even more productive and relevant as one of the top application development platforms in the industry. The community around Java EE seems as though it has never been more engaged than it is now. Over the years since the cumbersome J2EE morphed into the productive platform that we call Java EE today, the community has continued to grow by the thousands. The Java EE Guardians have thousands of supporters, each of them hoping to help move Java EE forward for years to come.

I see a great future for an open Java EE. However, many questions are left to be answered. Will the JCP still be used to manage the changes that are proposed for the platform? Perhaps this is one of the questions that has the potential to impact the platform the most. If the JCP will still be used to manage the platform, can it be changed in such a way that it will be conducive to a faster moving platform? Do we want Java EE to become a faster moving platform, much to the likes of other frameworks such as Spring?

One of the main strongholds of Java EE is standardization. If the open Java EE were to become more dynamic, can it maintain its place as a standard in the industry? I think so. I think that ideally the JCP could still be used to move the specifications forward, with a bit of a modernizing on the approach. I like the idea of having shorter Java EE release cycles with fewer changes in each release. Such an approach can really help the platform to retain its relevancy in this fast moving space.

What are your thoughts on the opening of Java EE? I welcome it and look forward to seeing what is to come for JavaOne 2018.

Java EE 8: Start Testing Today

noreply@blogger.com (Josh Juneau) — Wed, 26 Jul 2017 12:29:00 +0000

Java EE 8 will be finalized and ready for public use soon. There is no better time to get started testing the new features than now. You can do so by grabbing a copy of my Java EE 8 Playground project and deploying to GlassFish 5.

I've just updated the project to repair bugs and include better formatted table data within the tables. I've also added a couple of examples:

- JSON-B example: Allows one to fetch the JSON for customer objects.

- CDI 2.0 Async: Add a new Job object to see async event output in server log

GitHub Project: https://github.com/juneau001/JavaEE8-Playground

Java 9 Recipes Published!

noreply@blogger.com (Josh Juneau) — Sat, 10 Jun 2017 14:57:00 +0000

A bit ahead of schedule, my latest book entitled Java 9 Recipes: A Problem-Solution Approach, has just been published!

This book is the 3rd Edition in the Java Recipes series. It covers all of the information that was in the previous editions, including the new content for Java 9. Specifically, you will learn how to use new Java 9 features including:

Modularity
Private Method Implementations in Interfaces
Process API Enhancements
New Streams API Enhancements
HTTP/2 Client API

I'd like to thank Apress for providing me with the opportunity to help share my knowledge of the Java platform.

For more information on using Java 9, check out the tutorials found in this post: https://www.javacodegeeks.com/java-9-tutorials

Testing the Java EE 8 Specifications

noreply@blogger.com (Josh Juneau) — Wed, 29 Mar 2017 17:13:00 +0000

The Java EE 8 Platform has definitely been moving along within the past couple of months. Specifications have been releasing early draft reviews, milestones, and even final releases. As a matter of fact, JSR-372 has just gone final, as JSF 2.3 has been released. For more information, please see Arjan's Post. It had the privilege to be a part of the JSR-372 expert group, and I really appreciate the opportunity to work with these experts on a specification that I use every day.

I created a Github Project entitled the Java EE 8 Playground, and it includes a Java EE application that contains a number of the latest updates to those specifications that will be part of the Java EE 8 release. I will make an effort to update this project often so that it includes current dependencies for the specifications. I will also try to add demos for the specifications so that it will be easy to build upon the examples. In the current project, some of the JSF 2.3 features are used.

It is important that as a community we test and provide feedback for the Java EE 8 specifications as they are being developed. It is in these stages that you have a voice that can make a change to an upcoming specification. Please test, read the latest specification documents, and provide feedback to the respective JSRs.

Java EE 8 Playground Project: https://github.com/juneau001/JavaEE8-Playground

Java EE 8 JSRs:

JSR 365 (CDI 2.0): https://www.jcp.org/en/jsr/detail?id=365
JSR 366 (Java EE 8): https://www.jcp.org/en/jsr/detail?id=366
JSR 367 (JSON Binding): https://www.jcp.org/en/jsr/detail?id=367
JSR 369 (Servlet 4.0): https://www.jcp.org/en/jsr/detail?id=369
JSR 370 (JAX-RS 2.1): https://www.jcp.org/en/jsr/detail?id=370
JSR 372 (JSF 2.3 - FINAL): https://www.jcp.org/en/jsr/detail?id=372
JSR 374 (JSON Processing 1.1): https://www.jcp.org/en/jsr/detail?id=374
JSR 375 (Java EE Security 1.0): https://www.jcp.org/en/jsr/detail?id=375
JSR 380 (Bean Validation 2.0): https://www.jcp.org/en/jsr/detail?id=380

JSR 371 (MVC - No longer officially part of Java EE 8): https://www.jcp.org/en/jsr/detail?id=371

JSR 365 Update: Digging Into CDI 2.0

noreply@blogger.com (Josh Juneau) — Sat, 04 Mar 2017 15:53:00 +0000

Contexts and Dependency Injection 2.0 (JSR 365), is an update to CDI 1.2, which is currently part of the Java EE 7 platform. It is currently in Public Review stage. For those of you who are not very familiar with CDI, it defines a powerful set of complimentary services that act as a gel that help to improve the coordination and structure of application code. For more details, please visit the specification page.

CDI 2.0 expands the usability of the Contexts and Dependency Injection services to Java SE as well, as it will now target both the Java SE and Java EE platforms. The CDI specification has been organized into 3 parts, Part I - Core CDI, Part II - CDI in Java SE, and Part III - CDI in Java EE. The major changes for CDI 2.0 are as follows:

Better alignment with Java SE 8
API for booting CDI within a Java SE application
Ability to provide observer ordering
Ability to fire asynchronous events
New Configurators Interfaces for Service Provider Interface (SPI) elements
Ability to configure or veto an observer method in ProcessObserverEvent event
Support for inline instantiation of specific annotation types
Addition of the InterceptionFactory interface, which allows to create a wrapper instance whose method invocations are intercepted by method interceptors and forwarded to a provided instance.

I encourage you to take a look at the CDI 2.0 Public Review Draft for more details on the specifics of each enhancement listed, as well as a complete listing of new features. Read through the draft and provide feedback to the expert group. All of the pertinent details for providing feedback can be found on the JSR 365 page. To get started testing, create a new maven based Java EE application in your favorite IDE, and add the following dependencies:

<dependency>
<groupid>javax.enterprise</groupid>
<artifactid>cdi-api</artifactid>
<version>2.0-PFD</version>
</dependency>
<dependency>
<groupid>org.jboss.weld</groupid>
<artifactid>weld-core-bom</artifactid>
<version>3.0.0.Alpha14</version>
<type>pom</type>
</dependency>

In this post, we will dig into one of the new features to get you started working with the API. Let's take a look at asynchronous events. Until CDI 2.0, events could only be fired in a synchronous manner. They've been enhanced in this latest iteration for asynchronous processing. Here's how it works:

Create an event of some type. Next, fire the event in an asynchronous manner, and handle accordingly once the event is complete. In this example, I have created a MovieEvent class, which will be utilized whenever a persist event occurs for a Movie object. The MovieEvent class is as follows:

public class MovieEvent {
    
    private String message;
    private Movie movie;
    
    public MovieEvent(String message, Movie movie){
        this.message = message;
        this.movie = movie;
    }
    
    public String getMessage(){
        return this.message;
    }
    
    public void setMessage(String message){
        this.message = message;
    }
    
    public Movie getMovie(){
        return this.movie;
    }
    
    public void setMovie(Movie movie){
        this.movie = movie;
    }
    
}

In the following scenario, we are firing an event when a new Movie is persisted. The following code resides within a MovieController CDI bean of an example JSF application:

@Named("movieController")
@SessionScoped
public class MovieController implements Serializable {

    @EJB
    private com.mycompany.cditest.session.MovieFacade ejbFacade;
    private List items = null;
    private Movie selected;
    
    @Inject
    Event<MovieEvent> movieEvents;
. . .
   private void persist(PersistAction persistAction, String successMessage) {
        if (selected != null) {
            setEmbeddableKeys();
            try {
                if (persistAction != PersistAction.DELETE) {
                    getFacade().edit(selected);
                    movieEvents.fireAsync(new MovieEvent("New Movie Released", selected))
                            .whenComplete((event, throwable) -> {
                                if(throwable != null){
                                    System.out.println("Error has occurred: " + throwable.getMessage());
                                } else {
                                    System.out.println("Successful Movie Processing...");
                                }
                            });
                } else {
                    getFacade().remove(selected);
                }
                JsfUtil.addSuccessMessage(successMessage);
            } catch (Exception ex) {
                Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, null, ex);
                JsfUtil.addErrorMessage(ex, ResourceBundle.getBundle("/Bundle").getString("PersistenceErrorOccured"));
            }
        }
. . .

When the event is fired, it creates a new MovieEvent object, and if it successfully completes then a message is printed to indicate success. In this example, a stream is used to process the "whenComplete" action.

Feel free to clone the repository located at https://github.com/juneau001/CdiTest and take CDI 2.0 test for a spin. This example is just one simple test of CDI 2.0. You can clone and utilize this test project as a starting point to work with other aspects of the specification. Keep an eye on JSR 365, which is currently in the Public Review Ballot stages.

JavaOne 2016 Follow-Up

noreply@blogger.com (Josh Juneau) — Wed, 28 Sep 2016 17:16:00 +0000

I had the pleasure of attending JavaOne this year, and I can sum up the experience in one word: Brilliant. This year was much different than in years past for me, as I had one talk to co-present on Sunday and I had the rest of the week wide open for attending sessions. As such, I've learned that it really is nice to have a lighter schedule at JavaOne so that you can take in all of the expertise and networking...that is what JavaOne is all about...learning from the experts and growing your network. I also had my lovely wife along with for part of this trip, which made my stay in San Francisco very nice, as I finally took a few minutes to enjoy the city this year...never had done that in the past.

My conference experience started off with the excellent NetBeans party on Saturday evening. I am a member of the NetBeans Dream Team, so many of my colleagues were in attendance at this party. It was the first time I had seen many old friends, and it was great to have a chance to catch up without needing to worry about rushing to the next session. I want to thank Geertjan Wielenga and Oracle for hosting this excellent event, and I cannot wait until the next Apache NetBeans party.

On Sunday at NetBeans Day, I had the pleasure of presenting "Enterprise Modeling of MVC and Java EE Artifacts" with experts Ivar Grimstad and Gaurav Gupta. Ivar is on the expert group for JSR 371 (MVC 1.0)...which we hope to move forward for use with Java EE 8. Gaurav is the lead developer for the excellent JPA Modeler tool. During our session, Ivar gave an overview of MVC 1.0, Gaurav highlighted the JPA Modeler utility, and I demonstrated how the JPA Modeler could be utilized with JSF applications, as well as MVC 1.0. I want to thank Geertjan again for getting the three of us together for this excellent talk.

The opening keynote was amazing. A large portion was devoted to showing how the world is using Java, including the outstanding Mars rover presentation by Dr. Anita Sengupta (@Doctor_Astro). It was amazing to see the complexity and detail that went into ensuring the Curiosity rover landed without issues. Of course, Java 9 was mentioned, along with a demo of modularity and the jshell by Mark Reinhold...very informative, as always.

During the opening keynote, I anxiously awaited word on the status of Java EE, and after quite a long wait, the announcement was made. I am very excited that Java EE 8 efforts are moving forward, albeit a bit differently than previously planned. Essentially most of the specifications for Java EE 8 is moving forward, and it is proposed that the following be removed so that resources can spend time in other areas: JSR 371 (MVC 1.0) and JSR 368 (JMS 2.1), JSR 373 (Management 2.0). I will cover my thoughts on these proposed dropped specifications in a follow-up post. The main focus for Java EE 8 will be to start paving the path for a more micoservices focused platform, whereby Java EE 9 will be released a year later and it will include the full microservices implementation. The addition of Health Checking and Configuration specifications would be beneficial for providing a standard means by which to monitor services and dynamically configure our applications. Overall, it is great to see things moving forward for Java EE, although I do have some reservations on the overall approach. I do not believe that every industry will adopt the microservices architecture, so there needs to be a path for those who will be continuing with the standard Java EE application architecture.

Rather than going through detail on each of the sessions that I had attended, I will provide a summary of my thoughts on the conference overall. As I have said many times before, time is not our friend...and this certainly was the case this year at JavaOne, as there were too many great tutorials, sessions, and networking events that it was difficult to see everything. Hats off to Sharat Chander and others at Oracle for organizing such a great conference. I also want to thank the content review committees for reviewing and choosing such great conference tutorials and sessions...the content was excellent!

The tutorials and hands-on labs dealing with Microservices were hot this year. I attended two of them myself. One of them was a hands on lab that enabled us to develop Microservices using JBoss Forge and WildFly Swarm. It was a fast pace tutorial covering everything from setting up Eclipse (unfortunately not my favorite IDE), through utilizing Forge, constructing services, and deployment. I am glad I attended, as it gave me a different perspective on development from what I am used to. The second was a tutorial on utilizing Payara Micro and the Payara MicroProfile. I found this tutorial very in-depth, covering these technologies from the ground-up, with lots of detailed explanation. I learned it is quite easy to add the Payara Microprofile to a project, simply by including the dependency in the POM:

<dependency>
   <groupId>fish.payara.extras</groupId>
   <artifactId>payara-microprofile</artifactId>
   <version>1.0</version>
   <scope>provided</scope>

</dependency>

Deploying is as simple as:

java -jar payara-microprofile-1.0.jar --deploy test-app.war

I attended many key Java EE sessions, including those given by Linda DeMichiel and others leading the specifications. All of these were informative, covering content from previous Java EE incarnations through what to expect in Java EE 8. Linda's presentation on Monday went into a bit more detail on the plans for Java EE 8, and it is clear to see that Oracle is "all in" on moving forward with the newly proposed plan for Java EE 8...which is great! Each of the specification-specific talks that I attended were excellent, including CDI 2.0, JAX-RS 2.1, and JSF 2.3. Great to hear from the experts for these areas. I also took in a couple of other key talks: Java EE Extendable to Functional by David Blevins, and 50 Java EE Best Practices by Ryan Cuprak and Michael Remijan...both great!

There were a lot of sessions on Java 9 and modularity this year. I attended a session on modularity, which was a great introduction for those hadn't yet had a chance to experiment with it. Docker was another hot topic at the conference, and I had the opportunity to attend a couple of sessions covering this great tech.

I had the privilege to attend the JCP Party on Monday evening. Always an excellent opportunity to network with others in the JCP, and this year's event did not let us down. The Chicago Java Users Group (CJUG), Bob Paulin, and myself won an award at the JCP Party on Monday evening for Adopt-a-JSR participants of the year. This was a very nice surprise! I also attended PartyOne, hosted by Tomitribe, ZeroTurnaround, BainCapital, and Hazelcast. This was a great opportunity to network with so many experts...and there was also a great view of the Bay Bridge off the balcony. I want to thank Tomitribe for the invitation! Lastly, I attended the Oracle Appreciation Event, which was very nice. The Oracle OpenWorld and JavaOne attendees had AT&T Park to themselves, and we got to see Sting and Gwen Stefani. Great networking opportunity with many great friends.

Overall, JavaOne 2016 was another great conference...very glad to have been a part of it. If you have not done so already, please take the Java EE Survey and provide your thoughts on the upcoming Java EE 8 proposal:

http://glassfish.org/survey

NetBeans Java EE 8 MVC Plugin Enhancements

noreply@blogger.com (Josh Juneau) — Thu, 15 Sep 2016 17:24:00 +0000

A while back, Geertjan Wielenga had posted about a NetBeans plugin that had been developed for the upcoming Java EE 8 MVC framework. The plugin was originally developed by Manfred Riem, co-spec lead for JSR 371, and Geertjan had extended it to add functionality for viewing all of the MVC controllers within an application. This plugin is a great start to a useful MVC plugin for NetBeans.

I've since taken the plugin and extended it further, adding the following enhancements:

NetBeans workspace now scanned to apply plugin only to those projects that contain MVC controller classes.
Ability to create a new MVC application which includes a basic controller class and corresponding view.
Ability to add new MVC controller class to a project.

Come and check out the new plugin functionality at JavaOne. I have the honor of presenting along with Ivar Grimstad (JSR 371 Expert Group) and Gaurav Gupta (JPA Modeler) in the presentation UGF6435 -- Enterprise Modeling of MVC and Java EE Artifacts for NetBeans Day 2016. I'll demo the plugin during the session, alongside the powerful JPA Modeler utility.

Hope to see you there!

For more information on NetBeans IDE, please check out the Java NetBeans IDE Tutorial.

NetBeans 8.2 Profiler: Colored Results

noreply@blogger.com (Josh Juneau) — Fri, 15 Jul 2016 15:28:00 +0000

One of the new features in NetBeans 8.2 is the ability to color profiler results differently based upon filters. This can make things visually stand out, and easier to follow in the profiler output.

To enable colored profiler results, go into the NetBeans "Preferences"->"Java"->"Profiler" menu, as seen in Figure 1. Check the box to "Use defined filters for coloring results".

Figure 1: NetBeans Profiler Colored Filter Results

Add any filter(s) you wish, and assign a color to the results of those filters (Figure 2). If you wish to display the output from one of the existing filters in a different color, click the tool icon and change the colors. As you can see in the previous figure, I updated the Java EE Frameworks filter to be a green color.

Figure 2: Assign Colors to Filters

After applying the colors to the filters, run the profiler and see the results!

Figure 3: Colored Results!

More Info: http://wiki.netbeans.org/NewAndNoteworthyNB82#Colored_Profiling_Results