Home > Articles

  • Print
  • + Share This
This chapter is from the book

This chapter is from the book

Java Skills

Java skills are, of course, the essence of WLS 8.1 development. Java skills are vastly different depending on what you're doing. A programmer used to doing small command-line programs in Java won't necessarily even know where to start developing an online application using WLS, or even a Swing GUI app connecting through JDBC to a database.

Because of this, assembling a team to build applications becomes more difficult. A manager cannot simply hire a Java programmer; she must know what underlying technologies the application will be using. This doesn't mean the employee can't learn the new technology, but a learning curve will be associated with doing so.

The norm in software development is to have one person wear many hats and do multiple things. This not only enables the developer to grow in his craft, but also saves on the overhead of hiring another person. A word of caution: A developer doing too many things at one time can directly relate to nothing getting done on time. A division of labor and a hierarchy of Java skills are what it takes to develop mission-critical software quickly, efficiently, and correctly.

A Java Architect

Software solutions are only as good or as bad as their design. Hence the importance of a good Java architect. A Java architect developing for WLS 8.1 must understand all the technologies available and choose the best ones for the solution. Most architects will use a design product to lay out the project—first at a high level, and then at a more detailed level, showing what technologies and classes are being used, extended, and created.

As the software cycle progresses, changes will ultimately come into play as new requirements and technical limitations are uncovered. A good Java architect will have years of experience in software design and an excellent understanding of not only OOP, but the J2EE architecture as well. The architect should also be aware of the features of WLS 8.1, which will enable him to take full advantage of its benefits. This experience, coupled with knowledge, enables managers and architects to work together to provide the leadership and direction for the software project.

JSPs and Servlets

Almost all applications running on WLS 8.1 will use either JavaServer Pages (JSP) or servlets. A servlet or JSP page must be run in a J2EE-compliant server, whereas other Java programs are standalone. JSPs include HTML with tags that denote Java coding, whereas servlets are a bit more involved because they're coded completely in Java.

JSPs are the easiest J2EE programs to write. A basic understanding of the Java programming language and certain J2EE-specific Web classes are all that's needed.

Another important part of writing JSPs is writing custom tag libraries to go along with them. Tag libraries enhance the ability of the JSP creator to create complex pages without writing any Java within the JSP file. Tag libraries are written completely in Java and have basic rules associated with them. Java developers should understand how tag libraries work and how to write them.

Servlets are slightly more difficult, but not much. Different levels of Java developers should exist here, with the more advanced programmers leading the entry level programmers.


A J2EE application will usually connect to a database of some kind. This requires the use and set up of Java Database Connectivity (JDBC). JDBC enables Java programmers to connect, create, update, and retrieve information from databases that have JDBC drivers. Structured Query Language (SQL) statements are formed, and data is returned.

JDBC calls are an integral part of the J2EE framework. A developer who works with JDBC must understand SQL and how it operates because improperly designed SQL statements can have a huge affect on the runtime of an application—especially when the application is under heavy load. A developer experienced with connecting with databases is desired here, or a person who understands SQL is needed to properly formulate the SQL statements for the Java programmer.


Developers can always get help with database administrators or designers when constructing SQL statements for a program. However, understanding SQL at a high level is always beneficial.

Beyond the Basics

The scalability of the J2EE architecture is a paramount reason why J2EE is the platform of choice to develop on. Certain technologies work together to give the application seamless integration, even though it might be across different networks on multitudes of separate platforms. The skill set needed for this type of application requires the knowledge of some of, if not all, the following technologies:

  • EJB—Enterprise Java Beans, although not difficult to create or deploy, must be properly designed to fit into a framework.

  • CMP—Container-managed persistence, which is extended with the EJB 2.0 specification, allows entity beans to have container-managed relationships. That means multiple beans can interact with each other based on the containers they're in. The container can then perform actions, such as interact with databases, independent from the entity beans contained within.

  • BMP—Bean-managed persistence defines the persistence relationship at the bean level.

  • JMS—Java Message Service allows asynchronous messages and events to be sent and received through out an environment.

  • JTA and JTS—Java Transaction API and Java Transaction Service are related technologies that allow transactions to be managed by a transaction server instead of individual components.

  • RMI—Remote Method Invocation is a powerful feature of Java that allows different virtual machines to invoke methods on each other.

  • JNDI—Java Naming and Directory Interface enables programmers to access different directory interfaces, such as LDAP and DNS, seamlessly within Java.

  • JMX—Java Management Extensions is an API that can be used by component developers to create management interfaces and tools.

  • XML—Document Object Model (DOM) and Simple API for XML (SAX) parsers are two of the standard APIs used to create and parse XML documents in Java.

  • XML Web Services—Program to program Web interfaces using standardized XML protocols to communicate and run different programs or services.

  • JCOM—This is a Java connector for connecting to Microsoft COM components used in an environment in which both technologies are present.

These core technologies are advanced and are usually performed or directed by a senior Java developer. One person is usually not proficient in all the skills needed, but two or three developers with overlapping skills can work together to create and deploy these services.


Java applets are used to fill in the gaps between what HTML can do and what regular applications can do. Applets are graphical in nature, so they comprise a different skill set from J2EE. A J2EE programmer won't necessarily know even where to start when building an applet. Applets aren't used in all J2EE applications, but if dynamically displayed information is needed without requesting it from the server, this is a helpful skill.

Swing Components

Swing components are not usually thought of as being used in J2EE applications with WLS. Java Swing components are used to build fat graphical user interfaces in a standard environment such as Mac OS, KDE, or Windows 2000. Swing components can be used to design applets, but the primary focus is on developing utilities for managing Web applications.

  • + Share This
  • 🔖 Save To Your Account