Welcome
Welcome to Java News and Code, where I tell you about interesting goings-on in the world of IT in general, and Java in particular.
And there’s always code.
On This Episode:
- Oracle wants to open source Java EE
- Android Oreo is here
- Code: A custom Maven archetype for JUnit 5
TLDR;
TODO: VIDEO HERE
On August 17th, Oracle Software Evangelist David Delabassee said Oracle wants to open up Java EE.
The announcement on the Oracle Blog says that as the summer ends, releases wrap up, and JavaOne 2017 approaches, this is an “…opportunity to rethink how Java EE is developed in order to make it more agile and responsive to changing industry and technology demands.”
As InfoQ points out, Oracle has been criticized regarding how it’s steered Java EE in the past, which has led to efforts such as the Java EE Guardians, a group “…committed to moving the Java EE platform forward through active community participation and advocacy.”
Java EE Guardians’ members include James Gosling, the Father of Java, and Cameron McKenzie, editor-in-chief of the Server side. It’s not clear what qualifies someone to be a Java EE Guardian, but qualifications span the spectrum from Father of Java, to Java Blogger, to this Java EE Guardian, whose qualifications include Student.
Reaction outside Oracle seems to be positive, with IBM’s Ian Robinson weighing in on the WASDev blog saying, “…we are delighted that Java EE is moving with the times to an open foundation for its ongoing development following the completion of Java EE 8 this year.”
So who will take over Java EE?
Responses to an unofficial Twitter poll by Java EE Guardian Reza Rahman asking that question seem overwhelmingly in favor of handing stewardship of the platform over to Apache.
So what does this mean for Java EE? It depends on whom you ask, but given the popularity and prevalence of the platform, I’m sure it will stay in good hands.
Be sure to check out the show notes page, where you can find more information on this story, and everything I talk about in this episode.
We’ve been following Android O for some time now here at Java News and Code, and at long last, Android O, named Oreo, has been released!
For users, Android Oreo has a bunch of new features, some of which are immediately obvious like picture in picture, and per-app notification options.
Other changes like background limits, are designed to improve device responsiveness and extend battery life.
For developers, things get more complicated. The optimizations and improvements come at a cost, which will be paid on the development side. And rightly so.
What does that mean for developers like me, who have apps in the Play Store?
For now, probably not much. Oreo is not even showing up on the Android Dashboard as of today, but of course, it’s only a matter of time.
Android Marshmallow has the single greatest share of installations, and it was released in October of 2015, coming on two years. So we have time.
But as developers we need to be ready. Fortunately, there is information available already to help us get ahead of this, like this video on the Android Developers YouTube channel.
This release is huge, there’s no denying it. And in my opinion totally worth it. Check out this article at Gizmodo, that lays out 11 cool new features in Oreo.
Be sure to check out the show notes page, where you can find more information on this story, and everything I talk about in this episode.
Code: A custom Maven archetype for JUnit 5
On August 24th, JUnit 5, Release Candidate 3 was released.
This release, which signals the impending General Availability (GA) Release, includes the usual spate of bug fixes, breaking changes, and new features.
The GA release is scheduled for September 6th, according to the milestones page.
A Maven archetype is a special type of Maven project that is used to generate other Maven projects. If you’ve ever used the New Project wizard in Eclipse to create a Maven project, chances are you’ve used the maven-quick-start archetype. Guess what? That’s a Maven archetype!
For this episode’s code talk through, I want to show you how to create a Maven archetype that you can use to create new projects that will come with JUnit 5 dependencies and boilerplate code.
The source code for the archetype is available in GitHub. And in this episode I want to do a quick walk through of the code for a Maven archetype, how it’s structured, and how to use it to generate a new project.
Let’s get started.
First, clone the code from GitHub. Open a Terminal window, navigate to the directory where you want the code to land and execute the git clone command:
git clone https://github.com/makotogo/JUnitJupiterArchetype
Next, import the code into Eclipse.
With the code in Eclipse, let’s take a quick tour. Expand all of the nodes in the source tree. Open the src/main/resources/META-INF/maven/archetype-metadata.xml file, which tells the archetype generator what source files, test source files, resources and so forth you want to be included in new projects generated from the archetype.
A Maven archetype project is itself a Maven project, so there are two POM files to deal with:
The one that controls the archetype project itself, located in the project root:
4.0.0
com.makotojava.learn
junit-jupiter-archetype
0.9.1
Archetype - jupiterArchetype
http://maven.apache.org
jar
And the POM file that will be included in any projects created from the archetype, src/main/resources/archetype-resources/pom.xml.
The archetype project also includes boilerplate code like this:
package $package;
import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
/**
* Unit test for simple App.
*/
@RunWith(JUnitPlatform.class)
public class AppTest {
private static final Logger log = Logger.getLogger(AppTest.class);
private App classUnderTest;
@BeforeEach
void setUp() {
classUnderTest = new App();
}
@Test
@DisplayName("assertAll on a bunch of Strings should succeed.")
public void doIt() {
log.info("Testing doIt()...");
assertAll(
() -> assertEquals("String", classUnderTest.doIt("String")),
() -> assertEquals("StringToo", classUnderTest.doIt("StringToo")),
() -> assertEquals("String2", classUnderTest.doIt("String2")),
() -> assertEquals("StringAlso", classUnderTest.doIt("StringAlso")));
}
}
To use the archetype to create new projects, you first have to build the archetype project itself. Like I said, it’s a Maven project, so to build it go to Run As > Maven Project and specify the install and archetype:crawl goals to install it in your local Maven repository, and update your local archetype catalog, respectively.
Next, make sure the archetype is included in your local Maven archetype catalog, which is located in the repository root in a file called archetype-catalog.xml. And there it is.
Now, I can use that to create projects in Eclipse. First, make sure Eclipse recognizes the local maven catalog. Under Preferences > Maven > Archectypes, click on Add Local Catalog. Browse or enter the path to your local archetype-catalog.xml file, give it a description you’ll recognize later, click Ok. Then Click Apply and close.
To create a new project based on the new archetype, go to File > New Project > Maven Project. Click Next. Click Next again. Select the archetype in the list, and complete the wizard.
When the wizard completes, you now have a new project based on your custom archetype!
How cool is that?
For a detailed walkthrough of this, check out this video.
Fini
Well, that’s it for today’s episode. Be sure to check out the show notes page, where you can find more information on this story, and everything I talk about in this episode.
Thanks for watching Java News and Code (and reading this post).
I’ll see you next time.
–jsp
j steven perry, The Blog 
You must be logged in to post a comment.