Saturday Mar 29, 2014

Get all countries using Java SE 8 Locale

I saw this blog post "Get all the country using Java Locale List" and then I thought about posting something similar, but using Lambda and the Stream API of Java SE 8. Here's my "fork", including a call to sort the locales based on "display country" property.

Continue reading...

Wednesday Mar 26, 2014

Migrating JDBC Resources from GlassFish to WebLogic

Following up with my series of articles about Migrating from GlassFish to WebLogic, this time I want to cover the migration of a very common resource used by every Java EE developer: JDBC resources, or simply, DataSources. And in case you haven't read yet the first article, here it is: Migrating a Java EE App from GlassFish to WebLogic. That one will walk you through redeploying a simple yet almost complete Java EE 6 application on WebLogic, without any code change nor specific deployment descriptors, and still taking advantage of the enhanced Maven Plugin in WebLogic 12c.

It is easy to migrate resources by using the Web consoles of both WebLogic and GlassFish. Just open one browser window for each server, put them side-by-side, and follow the UI menus. Most of the properties are the same. But if you walkthrough the full article below, you will not only learn the concepts and what is required to migrate JDBC resources, but also how to migrate things using Command-line Interface (asadmin from GlassFish; wlst from WebLogic). So in order to understand what I'm doing here, I strongly recommend you to read, at least the introduction of, these two docs below in case you are not familiar with asadmin or wlst:


Oracle WebLogic Types of JDBC Data Sources

WebLogic offers three types of DataSources. For this migration, the type we will use will be "Generic". To know more about each type, click on the links below:

  • Generic Data Source
    • the type you are most familiar with; we will focus on this one
  • GridLink Data Source
    • in case you have an Oracle RAC Database, this is an optimal data source with HA and Failover features
  • Multi Data Source
    • abstracts two or more Generic Data Sources; works like a 'pool of data sources' so you can use it for either failover or load balancing



JDBC Resources: DataSources and Connection Pools

In the first article this was sort of covered from a Java EE Standard point of view. I simply took advantage of the @DataSourceDefinition annotation type, which allows developers to define JDBC DataSources directly from the Java source code, and requires no vendor-specific deployment descriptors nor manual previous configuration of the application server.

Now in case you have a legacy application or you are not using @DataSourceDefinition, you will be required to migrate these resources by hand. This will require three (plus one optional) simple steps:

  1. List JDBC resources from a GlassFish domain
  2. (optional; see below) Install 3rd-party JDBC drivers in WebLogic
  3. Extract and convert relevant and required information by WebLogic
  4. Create datasources inside WebLogic
Oracle WebLogic 12c already comes with JDBC drivers for Oracle DB 11g, MySQL 5.1.x, and Derby DB, so you won't need to do anything for these databases. For more information, read the docs JDBC Drivers Installed with WebLogic Server. In this doc you will also learn how to update the versions already provided by WebLogic, for example if you want to take advantage of the new features in Oracle DB 12c

If you are using Microsoft SQL Server, PostgreSQL, or any other database, check the Setting the Environment for a Thirdy-Party JDBC Driver for more information on how to install these drivers.

Concepts of JDBC Resources

We should also learn one difference between the concept of JDBC Resources in GlassFish 3 versus WebLogic 12c. In GlassFish, there are two types of JDBC Resources:
  • JDBC Connection Pools
  • JDBC Resources (aka DataSources)
On the other hand, WebLogic treats JDBC Resources as one single thing: Data Sources. The connection pool is part of the data source definition where in GlassFish, the Data Source is a separate artifact, which allows enabling/disabling the object, and also provides the JNDI name to a specific Connection Pool. In few words, when migrating a data source from GlassFish to WebLogic, you will only care about the JDBC Connection Pool and the JNDI name given at the JDBC Resource item.

Listing JDBC Resources from a GlassFish domain

First, let's list all JDBC Resources (datasources) in our GlassFish server. Connect with asadmin and execute thelist-jdbc-resources command:

asadmin> list-jdbc-resources
jdbc/__TimerPool
jdbc/__default
jdbc/gf2wls
Command list-jdbc-resources executed successfully.

Let's focus on our example: the jdbc/gf2wls datasource. This will be the DataSource we will migrate from GlassFish to WebLogic. Now let's list all Connection Pools in this GlassFish domain by using asadmin list-jdbc-connection-pools:

asadmin> list-jdbc-connection-pools
__TimerPool
DerbyPool
mysql_gf2wls_gf2wlsPool
Command list-jdbc-connection-pools executed successfully.

Now of course in case you have dozens of connection pools created in your GlassFish domain, it would be easier to issue a command that shows you which connection pool is associated to the Data Source you want to migrate. To do this, let's use the asadmin get command:

asadmin> get resources.jdbc-resource.jdbc/gf2wls.*
resources.jdbc-resource.jdbc/gf2wls.enabled=true
resources.jdbc-resource.jdbc/gf2wls.jndi-name=jdbc/gf2wls
resources.jdbc-resource.jdbc/gf2wls.object-type=user
resources.jdbc-resource.jdbc/gf2wls.pool-name=mysql_gf2wls_gf2wlsPool

We not only got which connection pool is associated to this data source but also its JNDI name, because the name of the resource may not be exactly the same as the JNDI name. 

Extracting GlassFish's JDBC Connection Pool data

Next step is to get all properties of your Connection Pool. Let's issue the asadmin get command again:

asadmin> get resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.*
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.portNumber=3306
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.serverName=localhost
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.databaseName=gf2wls
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.User=gf2wls
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.URL=jdbc:mysql://localhost:3306/gf2wls?zeroDateTimeBehavior=convertToNull
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.driverClass=com.mysql.jdbc.Driver
resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.Password=gf2wls
Command get executed successfully.

Easy, isn't? Now, let's focus on the minimum required properties we need to create this DataSource in WebLogic 12c. They are under resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.* , so if you want to list only these, change the asadmin method above to the following: asadmin get resources.jdbc-connection-pool.mysql_gf2wls_gf2wlsPool.property.*

Create the Data Source in WebLogic using WLST

To help you witht he final step, I've created a sample WLST script to create a Data Source in WebLogic. In this script, there are a few variables you must define. To call this script, go to your WebLogic installation directory and, if you are on Linux, call $ source setDomainEnv.sh (or the proper script for your environment). Then execute the WLST script: $ java weblogic.WLST ds_gf2wls.py

You should see the following output:

$ java weblogic.WLST ds_gf2wls.py
Initializing WebLogic Scripting Tool (WLST) ...

Welcome to WebLogic Server Administration Scripting Shell

Type help() for help on available commands

Connecting to t3://localhost:7001 with userid weblogic ...
...
Starting an edit session ...
Started edit session, please be sure to save and activate your 
changes once you are done.
Saving all your changes ...
Saved all your changes successfully.
Activating all your changes, this may take a while ... 
The edit lock associated with this edit session is released 
once the activation is completed.
Activation completed

That's it. Check your WebLogic Console, by going to the Data Sources page.

Extending and improving the migration process

Now you may be wondering how to improve the process by automating everything, right? Yes you can do that! Since we have been using CLI commands, it all depends now on you by tweaking and coding some bash scripts. For example, you can use asadmin to get the information of all Data Sources, generate a bunch of files, usesed to, you know, hack the output files, then loop through them and call a more dynamic WLST script. If you want to read files from WLST, here's a fragment you can use:

from java.io import FileInputStream

propIS = FileInputStream("MyGFDS.properties")
configDS = Properties()
configDS.load(propIS)

dsName=configDS.get("dsName")
dsFileName=configDS.get("dsFileName")
dsDatabaseName=configDS.get("dsDataBaseName")
datasourceTarget=configDS.get("datasourceTarget")
dsJNDIName=configDS.get("dsJNDIName")
dsDriverName=configDS.get("dsDriverName")
dsURL=configDS.get("dsURL")
dsUserName=configDS.get("dsUserName")
dsPassword=configDS.get("dsPassword")
dsTestQuery=configDS.get("dsTestQuery")

Migrating Advanced Settings

If you want to migrate advanced settings of the Connection Pool, take a look at the full list of properties I extracted from GlassFish in my sample Data Source. To change for example the Max Pool Size, tweak the WLST script and add the following:

dsMaxPoolSize=25

cd('/JDBCSystemResources/' + dsName + '/JDBCResource/' + dsName + '/JDBCConnectionPoolParams/' + dsName)
cmo.setMaxCapacity(dsMaxPoolSize)

Again, you can do whatever you want in WLST.

There you go! If you come up with a super awesome script to automate the whole process, let me know!

Monday Mar 03, 2014

Migrating a Java EE App from GlassFish to WebLogic

WebLogic is Oracle's strategic application server for the Java EE Platform. Since Oracle decided to focus on it for commercial support, and decided to leave GlassFish free of any ties with commercial decisions, I decided to bring this type of content to help GlassFish customers as well users to experiment, try, and evaluate Oracle WebLogic 12c (Java EE 6 certified).



But before getting down to the migration part, first thing you should learn is How to Install WebLogic 12c. For this migration tutorial in a developer environment, we will be using the Developer installation, but for production environments, we recommend the Full installation.

Full Installation
For full installation that can be used either in a production environment or in a developer environment, download the WebLogic Generic Installer and follow the steps descriped in the documentation for 12.1.2 on how to install WebLogic.

The difference between full and dev, is that full is targeted for any environment, and dev is well, for developers only. Oracle always recommend the full installation, but usually and specially for Java EE applications in a dev environment, the Development installation is enough. The good thing about it is the download size: less than 200Mb, and still you also get Oracle Coherence to play with. By the way, there is no licensing requirements for development purposes (either full or dev install), because WebLogic (and other Oracle products) are free for developers.

Required software

For this series of Migrating from GlassFish to WebLogic, I will be using NetBeans 8.0, GlassFish 3.1.2.2Oracle JDK 7, Oracle MySQL Community 5.6, and WebLogic 12.1.2. So make sure you have that software (except WLS for now) installed and configured in your system.

Developer Installation of WebLogic 12c

Let's get started by first installing WebLogic 12c for Developers. Instructions here are for Linux, but it is not that much different for Windows or Mac.
  1. Download WebLogic 12c ZIP Distribution for Developers (latest version: 12.1.2)
  2. Unzip it somewhere, for example:
    $ unzip wls1212_dev.zip -d /opt
  3. Go into the newly created directory
    $ cd /opt/wls12120
  4. Let's unpack the JAR files that were optimally compressed with pack200
    $ sh configure.sh    // for Windows, call configure.cmd
  5. After the uncompression, configure script will ask you if you want to create a new domain. Say "yes" by pressing 'y', then [enter]
  6. Provide a username, a password, and then confirm again the password
  7. Wait for the domain to be created and started
In just a few minutes you will have WebLogic installed, configured, and running!

Test your WebLogic 12c Developer Installation

At this point, you should have a WebLogic domain configured, up, and running. You can access the Admin Web Console at the following URL: http://localhost:7001/console. It will ask for username/password you typed during install. Take a moment to explore the Admin Console. You can find more information at the official documentation for 12.1.2.

You may also find very useful to know you can manipulate all domain settings through the WebLogic Scripting Tool, a command-line interface for you to code in Python, and issue commands to view and edit all settings. In an upcoming version of WebLogic we will also provide a REST interface.

I will use WLST in the next posts in this series, so maybe you want to read more later.

How to Start/Stop WebLogic 12c

In order to start and stop correctly your WebLogic domain, you can either do that from an IDE such as NetBeans, or by running specific scripts. These scripts are located under the following path location:

/opt/wls12120/user_projects/domains/mydomain/bin
  • $ sh startWebLogic.sh
  • $ sh stopWebLogic.sh

The Beauty of Java EE 6

Now, instead of going through the process of creating a Java EE application, I coded a small application that covers a large set of Java EE 6 APIs and pushed it to this GitHub repository. It is an application using the following APIs:
  • CDI 1.0
  • JSF 2.1
  • Bean Validation 1.0
  • EJB 3.1
  • JPA 2.0
  • JAX-WS 2.2
  • JAXB 2.2
  • JAX-RS 1.1
The beauty of Java EE is that you will learn from this migration how good it is when you follow standards, and also the value of the platform. Simply put: we will migrate this application without touching any code. At least not for now. Let's first set some infrastructure requirements. For now, we must have a database.

JPA and Database setup

To facilitate things, and before you can run this application, make sure you have MySQL installed and running onlocalhost, and with a database named gf2wls with username/password gf2wls with all privileges. The project comes with a drop-and-create configuration when JPA (through EclipseLink) is initialized.

To setup this, connect as root to your local MySQL server and issue the following two commands:
  1. $ mysql -u root -p
  2. mysql> create database gf2wls;
  3. mysql> grant all privileges on gf2wls.* to gf2wls@localhost identified by 'gf2wls';
And you are set!

Import project to NetBeans, setup MySQL driver, and run it on GlassFish 3.1.2.2

Since this is an article about migrating from GlassFish to WebLogic, I will assume you know how to get this application running on GlassFish 3.1.2.2 from NetBeans. But I will provide some highlights to make it work smoothless.



In order for the @DataSourceDefinition entry inside class InitializeSampleDataSessionBean work fine and connect to your MySQL database in GlassFish, make sure you have copied MySQL JDBC Driver into glassfish3/glassfish/domains/domain/domain1/lib/ext/ of course, before starting it up. In WebLogic, you don't need to do this since MySQL Connector/J is already part of the default installation.

Download the project 'bookmark-javaee6' to your local machine by either cloning the GitHub repository locally, or by downloading the zip and extracting somewhere. This is an Apache Maven project, so don't worry about environment. Just make sure you have this project up and running on a GlassFish domain.

Import the project bookmark-javaee6 into your NetBeans environment. Right click on bookmark-javaee6 project and select Run. Test the application by going to http://localhost:8080/bookmark-javaee6.

You should by now looking at the following screen:


Test the Bookmark WebService with a simple client

The sample Bookmark application comes with a JAX-WS WebService.

  1. You can test this WebService in many ways, but I will give you three main options: one is to try SoapUI
  2. Another option is to right click on the WebService in NetBeans, and select Test WebService
  3. Last option is to run the bookmark-javaee6-wsclient that comes with JUnit Test Cases. 
Make your choice, and see it working!

Running the sample Java EE 6 application in WebLogic 12c

Before we go to a pure Maven description on how to do this, let's give NetBeans a try. Now that you have everything ready (a Java EE 6 application running on GlassFish 3.1.2.2), with source code as a Maven project in NetBeans, let's add WebLogic as a Server to it.

  1. Go to the Services tab in NetBeans, and right click in Servers, then select Add Server....
  2. Select Oracle WebLogic Server
  3. Insert the path location of your recently installed WebLogic server. Remember to select the subfolderwlserver. If you installed as described in the beginning, you should try /opt/wls12120/wlserver
  4. Type your username and password of your WebLogic domain
  5. Finish this wizard
Now we must change from GlassFish to WebLogic in Project Properties. Select bookmark-javaee6 project and right click on it. Go to Run and select your newly created WebLogic 12.1.2 server. Press OK. See the picture below to understand what has to be done:



Start your project by right clicking in it, and select Run! Test your application running on WebLogic by going to the following location: http://localhost:7001/bookmark-javaee6


In case you had any problem, try these two articles:


Success! You have now the same application running on WebLogic 12c! Without any code change!

WebLogic understands GlassFish Deployment Descriptor

I haven't mentioned this before because I wanted you to see the sample application up and running on WebLogic, but what you can do in this application is to remove src/main/webapp/WEB-INF/weblogic.xml, and change the context-root inside glassfish-web.xml. What will happened if you redeploy this application without weblogic.xml, is that the application will start just fine, but in a different context-root: the one you typed inside glassfish-web.xml.

The reason for this is well documented on Support for GlassFish Deployment Descriptors. Give it a look in case you want to know what else does WebLogic understands from GlassFish's DD.

Now, let's try something different. Let's now use pure Apache Maven to compile and run the application on your WebLogic installation! For that, we will first need to configure the plugin.

Configuring the WebLogic Development Maven Plugin

Before you can use the plugin, you must install it in your local or remote Maven repository. Feel free to follow official instructions for WebLogic 12.1.2. But in case you want to just get it done, here's the short version:

  1. Go to your WLS installation. It is probably located here:
    /opt/wls12120
  2. Now change to the following directory:
    $ cd oracle_common/plugins/maven/com/oracle/maven/oracle-maven-sync/12.1.2
  3. Issue the following command to sync WLS Maven Plugin into your local repository:
    $ mvn com.oracle.maven:oracle-maven-sync:push -Doracle-maven-sync.oracleHome=/opt/wls12120/oracle_home/.
You have now successfully installed WLS Maven Plugin. To validate the installation, type:
$ mvn help:describe -DgroupId=com.oracle.weblogic-DartifactId=weblogic-maven-plugin -Dversion=12.1.2-0-0

To continue, let's configure the plugin onto our bookmark-javaee6 sample application, and then deploy the package into WebLogic
  1. Open the POM file of bookmark-javaee6 project
  2. Uncomment the WebLogic Maven Plugin definition
  3. Make sure to enter the same username and password as your domain when you installed and configured WebLogic
  4. Make sure WebLogic is running
  5. Make sure there's no other bookmark-jaavaee6 project deployed on your WebLogic instance
  6. Execute the following command:
    $ mvn package pre-integration-test
  7. Check your logs and try http://localhost:7001/bookmark-javaee6!

Conclusion

As you could see, if you are working with a Java EE 6 project 100% standardized, and perhaps Maven, you will find no problems at migrating this project to WebLogic 12c. In fact, if you are using Maven it will be as simple as adding a new plugin just to facilitate deployment. But even this you won't have to do in case you have a binary only. Just open the Admin Web Console, and fire a deployment from there!

And by the way, WebLogic is not that heavyweight and unproductive application server developers thought it still is. For more information about Developer Productivity with WebLogic 12c, read my entry "WebLogic in Comparison: RebelLabs and the Java App Server Debate".

Caveats for Java EE projects, road ahead for migrations

In the next blog posts of this series, I will cover how to work around some common issues when your project is not exactly following, or taking advantage of all standards defined in the Java EE 6 platform, or simply using extra features, customizations of GlassFish.

Here's a sneak peek of what's coming next:
  • How to Migrate JDBC DataSources from GlassFish to WebLogic
  • How to Define, Deploy, and Use JMS resources
  • How to Migrate JMS resources from GlassFish to WebLogic
  • How to Add and Isolate (classpath of) 3rd-party libraries (for example PrimeFaces)
And many more things to come!
  • Applying a GlassFish Domain Topology to a WebLogic Domain (clustering, etc)
  • Migrating Security Realms
  • Migrating Custom Login Modules
If there's any other subject you'd like to see, please post a comment!

Cheers!
About


Bruno has been having fun working with Java since 2000 and now helps Oracle on sharing the technology accross all Latin America. Also plays videogames, does trekking and loves beer.

Follow me on Twitter! @brunoborges

Search

Archives
« March 2014 »
SunMonTueWedThuFriSat
      
1
2
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
27
28
30
31
     
Today