Welcome to the first post in our Introduction to Java blog series! Join us for a multi-part series to introduce the key concepts derived from our Introduction to Java training class. And, if you have any suggestions for future blog posts, just leave a comment below! Let’s get kicked off with a discussion on the basics of Java for new programmers.

Lets get started by looking at some general syntax rules.

Java is case-sensitive

• main(), Main(), and MAIN() would all be different methods

There are a limited number of reserved words that have a special meaning within Java.

• You may not use these words for your own variables or methods.
• Examples: public, void, static, do, for, while, if

Most keyboard symbol characters (the set of characters other than alphabetic or numeric) have a special meaning.

Names may contain alphabetic characters, numeric characters, currency characters, and connecting characters such as the underscore ( _ ) character.

• Names may not begin with a numeric character.
• Note that the set of legal characters draws from the entire Unicode character set.
• Also note that it is probably impossible to write a succinct set of rules about what are valid characters, other than to say a character, that when passed to Character.isJavaIdentifierPart(char ch), results in a true value.

The compiler parses your code by separating it into individual entities:

• names (of classes, variables, and methods)
• command keywords
• single or compound symbols (Compound symbols are when an operation is signified by a two-symbol combination.)
• these entities are called tokens or symbols in computer science jargon

Tokens may be separated by spaces, tabs, carriage returns, or by use of an operator (such as +, -, etc.)

• Since names may not contain spaces, tabs, or carriage returns, or operator characters, these characters imply a separation of what came before them from what comes after them.

Extra whitespace is ignored

• Once the compiler knows that two items are separate, it ignores any additional separating whitespace characters (spaces, tabs, or carriage returns).

Java Statements

A statement:

• is one step of code, which may take more than one line
• ends with a semicolon (the ; character)
• can have multiple statements on one line

Program execution is statement by statement, one statement at a time

• from top to bottom (if more than one statement on a line, left to right)

Within a statement, execution of the individual pieces is not necessarily left to right

• there are concepts called operator precedence and associativity that determine the order of operations within a statement

Blocks of Code

A block of code:

• is enclosed in curly braces – start with { and end with }
• consists of zero, one, or more statements
• behaves like a single statement to the outside world
• a complete method is a block
• blocks may be nested – containing one or more blocks inside
• generally, blocks belong to whatever comes before them (although it is perfectly OK to create a block that does not, this is almost never done)

Variables

Variables store data that your code can use.

There are two fundamental categories of variables: primitive data and references.

• With primitive data, the compiler names a memory location and uses to store the actual data -
  numeric values such as integers, floating point values, and the code values of single individual text characters are stored as primitives.
• With references, the data is accessed indirectly – the compiler selects a memory location, associates it with the variable name, and stores in it a value that is effectively the memory address of the actual data.
  In Java, all objects and arrays are stored using references.

Declaring Variables

Variables must be declared before they are used.

A declaration informs the compiler that you wish to:

• create an identifier that will be accepted by the compiler within a section of code (Exactly what that section is depends on how and where the variable is declared; that is the concept of scope, which will be addressed later.)
• associate that identifier with a specified type of data, and enforce restrictions related to that in the remainder of your code
• create a memory location for the specified type of data
• associate the identifier with that memory location

Java uses many specific data types; each has different properties in terms of size required and handling by the compiler.

• The declaration specifies the name and datatype.
• Generally the declaration also defines the variable, meaning that it causes the compiler to allocate storage space in memory of the requested type’s size.
• A declaration may also assign in initial value (to initialize the variable).
• Multiple variables of the same type can be declared in a comma-separated list.

Note that different languages have different rules regarding trying to read data from variables that have not been initialized.

• Some languages just let the value be whatever happened to be in that memory location already (from some previous operation).
• Some languages initialize automatically to 0.
• Some languages give a compiler or runtime error.
• Java uses both of the last two: local variables within methods must be initialized before attempting to use their value, while variables that are fields within objects are automatically set to zero

Now, that was a quick look into some of the basic fundamentals of Java. If you want to learn more about Java, stay tuned for our next blog installment in the series, and check out all of our upcoming Java training options. To receive the latest news on our blogs, classes, and tutorials, sign up for our free newsletter. Click here to sign up.

In C/C++ memory management is handled by the programmer. Even after a programmer has put in a lot of effort to ensure the code is free of memory management problems, the more likely it is that they are likely to exist. The risk of these bugs increases with code size and complexity.

On the other hand, the Java programming language and runtime environments go a long way to eliminate these problems. Here’s how:

• In Java, memory is allocated only to objects. There is no explicit allocation of memory, only the creation of new objects.
• The Java Virtual Machine (JVM) employs a garbage collector that reclaims the memory occupied by an object once it determines that it is no longer accessible. This automatic process makes it safe to throw away unneeded object references because the garbage collector does not collect the object if it is still needed elsewhere.
• Java makes it easy to let go of an entire “tree” of objects by setting the reference to the tree’s root to null; the garbage collector will then reclaim all the objects (unless some of the objects are needed elsewhere).

So what about memory leaks caused by poor program design? Unfortunately, this can still be a problem.

In these programs unnecessary object references linger in long-lived parts of the application and prevent the garbage collector from reclaiming objects that are no longer needed. Most often, properly encapsulating object references in various parts of the code solves the problem.

Another design flaw occurs at the algorithm level. Not closing JDBC connections properly when using connection pools, threads left running after they have finished their work, and objects retaining their reference to legacy objects are typical examples. The use of Collection objects will magnify this problem.

Programmers should design applications with an object’s lifecycle in mind, rather than only rely on the features of a JVM implementation. Memory problems can be mitigated by letting go of object references to legacy classes as soon as possible. The KL Group’s JProbe tool can help identify possible sources of memory leaks by showing which objects are holding on to references passed their prime.

Interested in more? Check out our upcoming Java training classes!

A common misconception about JavaServer Pages is that they are executed by the web container. Actually they only supply the web container with the instructions it needs to generate the Java code for a specialized servlet. That generated code is then compiled by the web container, and the resulting class is executed. To illustrate this concept, consider the simple JSP listing below:

1
2
3
4
5
6
7
8
9
10
11
12
13

<html>
	<head>
		<title>JSP to Servlet</title>
	</head>
	<body>
		<jsp:useBean id="bean" class="com.webucator.bean.NameBean"/>
		<jsp:setProperty name="bean" property="firstName" value="Roger"/>
		<jsp:setProperty name="bean" property="lastName" 
			value="Sakowski"/>
		My name is: 
		<jsp:getProperty name="bean" property="fullName"/>
	</body>
</html>

When this page is requested, the following is displayed in a web browser:

My name is: Roger Sakowski

It seems pretty straightforward, but it’s not. The listing below is the generated source code produced by Tomcat’s web container:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

package org.apache.jsp;
 
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
 
public final class MyJsp_jsp 
extends org.apache.jasper.runtime.HttpJspBase
	implements org.apache.jasper.runtime.JspSourceDependent {
 
	private static final JspFactory _jspxFactory = 
		JspFactory.getDefaultFactory();
	private static java.util.List _jspx_dependants;
	private javax.el.ExpressionFactory _el_expressionfactory;
	private org.apache.AnnotationProcessor _jsp_annotationprocessor;
 
	public Object getDependants() {
		return _jspx_dependants;
	}
 
	public void _jspInit() {
		_el_expressionfactory = 
			_jspxFactory.getJspApplicationContext(
				getServletConfig().getServletContext()).
				getExpressionFactory();
		_jsp_annotationprocessor = 
			(org.apache.AnnotationProcessor) getServletConfig()
				.getServletContext().getAttribute(
					org.apache.AnnotationProcessor.
						class.getName());
	}
 
	public void _jspDestroy() {
	}
 
	public void _jspService(HttpServletRequest request,
		HttpServletResponse response) throws java.io.IOException,
		ServletException {
 
		PageContext pageContext = null;
		HttpSession session = null;
		ServletContext application = null;
		ServletConfig config = null;
		JspWriter out = null;
		Object page = this;
		JspWriter _jspx_out = null;
		PageContext _jspx_page_context = null;
 
		try {
			response.setContentType("text/html");
			pageContext = 
				_jspxFactory.getPageContext(this, request, 
					response, null, true, 8192, true);
			_jspx_page_context = pageContext;
			application = pageContext.getServletContext();
			config = pageContext.getServletConfig();
			session = pageContext.getSession();
			out = pageContext.getOut();
			_jspx_out = out;
 
			out.write("<html>\r\n");
			out.write("\t<head>\r\n");
			out.write("\t\t<title>JSP to Servlet</title>\r\n");
			out.write("\t</head>\r\n");
			out.write("  \r\n");
			out.write("\t<body>\r\n");
			out.write("\t\t");
			com.webucator.bean.NameBean bean = null;
			synchronized (_jspx_page_context) {
				bean = (com.webucator.bean.NameBean) 
					_jspx_page_context
						.getAttribute("bean", 
							PageContext.PAGE_SCOPE);
				if (bean == null) {
					bean = new com.webucator.bean.NameBean();
					_jspx_page_context.setAttribute("bean", 
						bean, PageContext.PAGE_SCOPE);
				}
			}
			out.write("\r\n");
			out.write("\t\t");
			org.apache.jasper.runtime.JspRuntimeLibrary.
				introspecthelper(
					_jspx_page_context.
						findAttribute("bean"), "firstName",
							"Roger", null, null, false);
			out.write("\r\n");
			out.write("\t\t");
			org.apache.jasper.runtime.
				JspRuntimeLibrary.introspecthelper(
					_jspx_page_context.findAttribute("bean"), 
						"lastName", "Sakowski", null, null, false);
			out.write("\r\n");
			out.write("\t\tMy name is: \r\n");
			out.write("\t\t");
			out.write(org.apache.jasper.runtime.
				JspRuntimeLibrary.toString((((com.webucator.
					bean.NameBean) _jspx_page_context.
						findAttribute("bean")).getFullName())));
			out.write("\r\n");
			out.write("\t</body>\r\n");
			out.write("</html>");
 
		} catch (Throwable t) {
			if (!(t instanceof SkipPageException)) {
				out = _jspx_out;
				if (out != null && out.getBufferSize() != 0)
					try { out.clearBuffer();} 
					catch (java.io.IOException e) {}
				if (_jspx_page_context != null)
					_jspx_page_context.handlePageException(t);
			}
		} finally {
			_jspxFactory.releasePageContext(_jspx_page_context);
		}
	}
}

The web container compiles this code and executes the resulting servlet.

You probibly noticed that the listed code isn’t exactly the same sort of servlet you generally develop yourself, but it’s pretty easy to recognize some familiar elements. The init and destroy methods become _jspInit and _jspDestroy. The service method is _jspService.

Check out our Introduction the JavaServer Pages, Comprehensive JSP, and Advanced JSP outlines.

I remember when Sun released JDK 1.08. It was dubbed the “classic” version. After a few years of feedback from developers, Sun made some meaningful changes and additions and released the JDK 1.1. The release was given the nickname of Java SE 2. Obviously the 0.02 increment in the version number is a little misleading. A few years later, Sun released version 1.5. Once again the industry judged the changes more significant than the version indicated so they dubbed it Java 5. It happened again. The release of version1.6 is called Java SE 6. The following is a list of some of the notable additions and changes:

1. Web Services:
   Developers will find better support for writing Web Service clients. They can expose APIs that are interoperable with .NET using a simple annotation. It also adds new parsing and XML capabilities to Java object-mapping, previously only available in Java EE or the Java Web Services Pack.
2. Scripting::
   Developers can mix in JavaScript. Useful for prototyping and teams with varying skill sets. Advanced developers can plug in their own scripting engines and use their favorite scripting language with Java code as they see fit.
3. Database:
   The Java SE 6 development kit – but not in the Java Runtime Environment (JRE) – bundles the Java JDBC database (based on Apache Derby). Developers will also get JDBC 4.0 offering many improvements, such as support for XML as a SQL datatype and better integration of Binary Large OBjects (BLOBs) and Character Large OBjects (CLOBs) into the API.
4. Desktop Deployment:
   Applications deployed to the desktop will benefit from a number of changes that enhance OS access: better look-and-feel in Swing technology, LCD text rendering, and better performance overall. Java applications integrate better with the native platform with access to the platform’s System Tray and Start menu. Java SE 6 unifies the Java Plug-in technology and Java WebStart engines. Additionally, Java WebStart intallation got a needed makeover.
5. More Desktop APIs:
   GUI developers get a few new items: SwingWorker streamlines threading, JTable offers sorting and filtering, and a facility for creating splash screens.
6. Monitoring and Management:
   Developers don’t have to do anything special to attach the monitoring and management tools. Java SE 6 adds more diagnostic information, and bundles the memory-heap analysis tool Jhat for core dump analysis.
7. Compiler Access:
   The compiler API opens up programmatic access to javac for in-process compilation of dynamically generated Java code. It is not intended for the everyday developer, but it’s sure to improved Java frameworks development and implementation in general.
8. Pluggable Annotations:
   For every feature missing in Java, an annotation can solve the problem. Java tool and framework vendors can define custom annotations that support plug-ins and processes.
9. Security:
   This release adds a few more security features:
   • XML-Digital Signature (XML-DSIG) APIs for creating and manipulating digital signatures
   • Simplified security administration via new access to platform-native security services, such as native Public Key Infrastructure (PKI) and cryptographic services on Microsoft Windows
   • Java Generic Security Services (Java GSS) and Kerberos services for authentication
   • Access to LDAP servers for authenticating users
10. Quality, Compatibility, Stability:
    Sun has done regular releases of Java SE for years and built a massive set of test cases in the process. Additionally, people have been downloading binary snapshots for over 20 months prior to the beta release filing their bug reports, areas of irritation, compliance issues, etc. This extensive testing has fixed a number of quality and regression issues well in advance of general release. Most notable is better performance than J2SE 5.0.

Webucator’s Java courses, labs, and workshops are Java SE capable. Check them out.

I was asked to go into Java’s database API (the JDBC) using the open source database, MySQL. The JDBC is included in the Java SE and the Java EE distributions in the java.sql package. It’s designed to hide the specifics of a RDBMS from business logic. In this article I’ll cover the basics of the JDBC and what it requires to use MySQL.

Before we get started we need to install the software:

1. Of course you will need a current revision of the JDK or Java EE installed on your computer.
2. Download MySQL and install it. The MySQL download for Windows comes in two types: as an Installer, and as a simple ZIP file. I use the ZIP version, mysql-noinstall-5.1.48-win32.zip. Other OS platforms will require matching versions of MySQL and the installation procedures may vary.
3. Download the MySQL jConnector. I used mysql-connector-java-5.1.13.zip. Unzip the archive and locate the mysql-connector-java-5.1.13-bin.jar file. You’ll need to point your CLASSPATH to this JAR. It contains the MySQL driver, com.mysql.jdbc.Driver.

The mysql text console utility in the bin directory of MySQL can be used to execute SQL statements. See the documentation for this utility for it’s commands and login requirements. In this example, I used the following SQL statements to establish a database and user:

1
2
3
4
5
6
7
8
9
10
11

create database test;
use test;
 
create table person (
id integer,
name varchar(30),
job_id integer,
location varchar(30)
);
 
grant all on test.* to roger@localhost identified by 'toast';

I populated the test database with the following statements:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

insert into person (id, name, job_id, location) 
	values (1, 'Bill Smith', 1183, 'OH');
insert into person (id, name, job_id, location) 
	values (2, 'Sue Jones', 529, 'NJ');
insert into person (id, name, job_id, location) 
	values (3, 'Tom Swift', 84443, 'FL');
insert into person (id, name, job_id, location) 
	values (4, 'Bob the Builder', 34693, 'MA');
insert into person (id, name, job_id, location) 
	values (5, 'Homer Simpson', 39, 'NE');
insert into person (id, name, job_id, location) 
	values (7, 'Margo Lane', 2222, 'TX');
insert into person (id, name, job_id, location) 
	values (8, 'Bud Abbot', 5202, 'RI');

It’s not much to look at, but it does give us something to work against.

The JDBC defines five classes that our example will use:

• java.sql.DriverManager: serves as a factory for creating Connection objects.
• java.sql.Connection: fosters the database connection and serves as a factory for creating Statement objects.
• java.sql.Statement: represents the SQL statement to be executed by the database.
• java.sql.ResultSet: represents the rows and fields obtained through a SQL select statement.
• java.sql.SQLException: all JDBC operations require this exception to be caught.

The following code serves as my Data Access Object (DAO). The block comments explain how it works:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

package com.webucator.jdbc;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
public class DAO {
 
   /* These variable values are used to setup
      the Connection object */
 
   static final String URL = "jdbc:mysql://localhost:3306/test";
   static final String USER = "roger";
   static final String PASSWORD = "toast";
   static final String DRIVER = "com.mysql.jdbc.Driver";
 
   /* This method is used to create a connection using 
      the values listed above. Notice the throws clause 
      in the method signature. This allows the calling method 
      to deal with the exception rather than catching it in 
      both places. The ClassNotFoundException must be caught 
      because the forName method requires it. */
 
   public Connection getConnection() throws SQLException {
      Connection con = null;
      try {
         Class.forName(DRIVER); 
         con = DriverManager.getConnection(URL, USER, PASSWORD);
      }
      catch(ClassNotFoundException e) {
         System.out.println(e.getMessage());
         System.exit(-1);
      }
      return con;
   }
 
   /* This method does most of the work. Note the try 
      and catch. Virtually all JDBC methods throw a 
      SQLException that must be tended to. The Connection 
      object is used to create a Statement object. 
      The executeQuery method is used to submit a 
      SELECT SQL query. The executeUpdate method can be 
      used to delete, change, or insert records. 
      The executeQuery method returns a ResultSet object. 
      It contains methods to navigate through the records 
      in the ResultSet object (the next method for 
      example moves the cursor to the next row; it 
      returns false when it runs out of rows) as well 
      as methods to access fields in those rows. Notice 
      that the id and job_id fields are long data types 
      while name and location are Strings. The ResultSet 
      object provides methods to deal with most common data 
      types, but it’s a good idea to review how Java data 
      types align with database data types. The report is 
      formatted using the format method introduced in Java 5.  */
 
   public void getEmployees() {
      ResultSet rs = null;
      try {
         Statement s = getConnection().createStatement();
         rs = s.executeQuery("SELECT * FROM PERSON");
         System.out.format("%3s %-15s %-7s %-7s%n", 
            "ID", "NANE", "JOB ID", 
			"LOCATION");
         System.out.format("%3s %15s %7s %7s%n", 
            "---", "---------------", 
			"-------", "--------");
 
         while(rs.next()) {
            long id = rs.getLong("id");
            String name = rs.getString("name");
            long job = rs.getLong("job_id");
            String location = rs.getString("location");
            System.out.format("%-3d %-15s %7d %5s%n", 
               id, name, job, location);
         }
      }
      catch(SQLException e) {
         System.out.println(e.getMessage());
         System.exit(-1);
      }
   }
}

The following class just exercises the DOA object:

1
2
3
4
5
6
7
8
9

package com.webucator.jdbc;
 
public class JDBCClient {
 
	public static void main(String[] args) {
		DAO dao = new DAO();
		dao.getEmployees();
	}
}

The output of this program is shown below:

ID NANE            JOB ID  LOCATION
--- --------------- ------- --------
1   Bill Smith         1183    OH
2   Sue Jones           529    NJ
3   Tom Swift         84443    FL
4   Bob the Builder   34693    MA
5   Homer Simpson        39    NE
7   Margo Lane         2222    TX
8   Bud Abbot          5202    RI

Check out our JDBC course for more information.

A common question students ask me is what’s the difference between a Java Application server and a Java EE Application server? Actually the question usually goes a bit further to include a HTTP (HyperText Transport Protocol) Server as well. Seeing as how the application server is a central player in running your projects, the question isn’t trivial.

A HTTP Server:
Client requests to a HTTP Server create a server response, usually in the form of an HTML (HyperText Markup Language) document or dynamic content through CGI (Common Gateway Interface) programs. The most popular HTTP Server is Apache, an open source Web server. The first version of Apache was developed in 1995. A distant second place in popularity is Microsoft’s IIS.

Java Application Server:
These servers are focused on Java technologies for dynamic content rather than CGI. They provide a web container capable of executing JSP (JavaServer Pages) and Servlets, a subset of the Java EE specification. They do have some HTTP Server capabilities as well, but they are usually not strong enough to meet the needs of a large, complex web site. It is common to front a Java Application Server with a HTTP Server to capitalize on the best of both worlds. The most popular Java Application Server is Tomcat from the Apache Software Foundation. Described as a "reference implementation" of the Java Servlet and the JSP specifications, Tomcat is the result of an open collaboration of developers and is available from the Apache Web site in both binary and source versions. Tomcat requires a Java Runtime Environment that conforms to JRE 1.1 or later.

Java EE Application Server:
Enterprise servers provide everything Java Application Servers do and a lot more. Java EE includes several API specifications, such as JDBC, RMI, e-mail, JMS, web services, XML, etc., and defines how to coordinate them. Java EE also features some specifications unique to Java EE components. These include Enterprise JavaBeans (EJB), Connectors, servlets, portlets, JavaServer Pages and several Web Service technologies. This allows developers to create enterprise applications that are portable and scalable, and that integrate with legacy technologies. A Java EE Application Server can handle transactions, security, scalability, concurrency and management of the components that are deployed to it.

JBoss is the most popular Java EE Application Server. It is a Red Hat, open source project supporting the JBoss Enterprise Middleware Suite (JEMS) brand. It is an alternative to commercial offerings from IBM WebSphere, Oracle BEA Services, and SAP NetWeaver. Like Tomcat, JBoss is often fronted by Apache to support clustering and cash in on its Web Server power.

JavaServer Faces (JSF) is a web-based application framework. It is a request-driven MVC technology based on a component driven UI design model. As with Struts, JSF uses XML files for configuration and the integration of MVC elements.

Requests are processed by the FacesServlet, which loads the appropriate view template, builds a component tree, processes events, and renders the response to the client. The state of UI components (and other objects) is saved at the end of each request, and restored upon next creation of that view.

Several types of state persistence are available, including client-side and server-side state-saving.

JSF 1.x uses JavaServer Pages (JSP) for its display technology, but it can accommodate other technologies. JSF2 uses Facelets, a powerful view description language.

JSF Features:

• Inversion of Control (IoC), a methodology for leveraging Plain Old Java Objects (POJO).
• Template-based component system provides a means of creating composite component creation.
• Ajax support minimizes the requirement for JavaScript.
• Unified Expression Language (EL) which allows views to access Managed Bean properties and methods.
• A set of HTML and web-application specific UI components.
• A server-side event model for dispatching events and attaching listeners to system operations.
• State management for “request”, “session”, “application”, “flash”, and “view” scoped beans.
• XML-based tag libraries defining core and html functionality.

For more information on JSF, check out our JavaServer Faces training opportunities.

The following Struts Hello World application introduces the primary players in a Struts application. It might seem like a lot of work to do a very simple job (display Hello World! in your browser), but don’t let that put you off. The real value of any framework is realized after it’s been setup. Building on it is extremely easy, efficient and maintainable from then on.

The first order of business is to create the web.xml so we can use Struts’ ActionServlet.

web.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	version="2.5"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
	<servlet>
		<servlet-name>action</servlet-name>
		<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
		<init-param>
			<param-name>config</param-name>
			<param-value>/WEB-INF/struts-config.xml</param-value>
		</init-param>
		<init-param>
			<param-name>debug</param-name>
			<param-value>3</param-value>
		</init-param>
		<init-param>
			<param-name>detail</param-name>
			<param-value>3</param-value>
		</init-param>
		<load-on-startup>0</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>action</servlet-name>
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

index.jsp:

The gateway for our Struts “hello world” application is the index.jsp file. It forwards the request to the hello world action as follows using the *.do URL pattern used in web.xml:

1

<jsp:forward page="HelloWorld.do"/>

struts-config.xml:

The struts-config.xml file is used to configure the Struts framework.
This file contains the details regarding the form bean and the action mapping.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC 
"-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" 
"http://struts.apache.org/dtds/struts-config_1_2.dtd">
<struts-config>
	<form-beans>
		<form-bean name="HelloWorldActionForm"
			type="com.webucator.struts.HelloWorldActionForm" />
	</form-beans>
	<action-mappings>
		<action input="/index.jsp" name="HelloWorldActionForm"
			path="/HelloWorld"
			scope="session" type="com.webucator.struts.HelloWorldAction">
			<forward name="success" path="/helloWorld.jsp" />
		</action>
	</action-mappings>
</struts-config>

HelloWorldActionForm.java:

HelloWorldActionForm class has one String variable, message, and the corresponding getter and setter methods.

1
2
3
4
5
6
7
8
9
10
11
12
13

package com.webucator.struts;
public class HelloWorldActionForm extends org.apache.struts.action.ActionForm {
	private String message;
	public HelloWorldActionForm() {
		super();
	}
	public String getMessage() {
		return message;
	}
	public void setMessage(String message) {
		this.message = message;
	}
}

HelloWorldAction.java:

The HelloWorldAction class contains the execute method which contains the business logic of the application. To access the HelloWorldActionForm variables in the HelloWorldAction we need to type caste the form object from the Object class. Then we can access its variable using the getter and setter methods. The execute method returns ActionForward. Based on the String value set in this class, the corresponding view will be called. This configuration is done in struts-config.xml file where the forward tag indicates that “success” is mapped to the view helloWorld.jsp.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

package com.webucator.struts;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class HelloWorldAction extends org.apache.struts.action.Action {
	private final static String SUCCESS = "success";
	public ActionForward execute(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		HelloWorldActionForm helloWorldForm = (HelloWorldActionForm) form;
		helloWorldForm.setMessage("Hello World!");
		return mapping.findForward(SUCCESS);
	}
}

helloWorld.jsp:

In helloWorld.jsp we get the value of the form variable, message, and display it. We use Struts bean tag to do this. The name attribute of the bean tag holds the value of the action form and the property attribute holds the value of the variable to be displayed.

1
2
3
4
5
6
7
8
9
10
11
12
13

<%@ page language="java" import="java.util.*" pageEncoding="ISO-8859-1"%>
<%@ taglib prefix="bean" uri="http://struts.apache.org/tags-bean"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
   <head>
      <title>Hello World</title>
   </head>
   <body>
      <h1>
         <bean:write name="HelloWorldActionForm" property="message" />
      </h1>
   </body>
</html>

There you go, your first Struts program. Learn how to bring the full power of Struts to your projects in our Apache Struts class.

In a standard Java EE web application, a client typically submits information via an HTML or JSP form. The information is handed a Java servlet or another JSP for processing. This approach is not recommended for large projects. How come? You guessed it. It usually mixes model and presentation logic inappropriately making maintenance difficult. It would be nice if we had a framework that inherently supported MVC. Apache Struts to the rescue!

Struts was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000. It became prime a Apache project in 2005. It’s an open-source, web application framework with a focus on the View, but embraces the Model and the Controller as well.

The ActionServlet plays the role of Controller in Struts. This servlet takes care of the intricacies of linking things together via declarations in the struts-config.xml configuration file.

Requests from the client are sent to the ActionServlet in the form of Actions defined in the configuration file; such a request calls the corresponding Action class that interacts with the application’s Model . The Model code returns an ActionForward object that tells the servlet what page to send to the client. Information is passed between model and view in the form of JavaBeans. A comprehensive custom tag library allows it to read and write the content of these JavaBeans to and from the presentation layer without the need for any embedded Java code.

Struts also supports internationalization, provides validation capability for submitted data, and includes a templating technology called Tiles that allows the presentation layer to be composed from independent HTML or JSP fragments.

Apache Struts offers a lot to developers faced with complex projects. In the next article I’ll go through a simple Struts example to demonstrate how the pieces fit together.

Apache Struts training can put you on the fast track. Check it out.

In previous articles, I talked a lot about the Model/View/Controller design pattern. Using it is recommended for all programming projects in the same way it’s recommended to pull a parachute’s ripcord when sky diving. The more independent (loosely coupled) each MVC tier is in relation to the complexities of the others, the more likely our applications will survive maintenance changes and enhancements. Equally I demonstrated how loose coupling can be employed by using JSP and JavaBeans.

So we’re set to develop that enterprise project our boss just put on our desk, right? Not really. An enterprise application will get very complicated, and it will get there very fast. Program features will interact with each other creating a ridge overall design. Endless hours will be spent solving problems over and over again. New features will be added, and old features will be removed or changed. And on it goes.

Here is another “ripcord” recommendation: get acquainted with Java design patterns.

Four eggheads (Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides), nicknamed the Gang of Four or GoF, with a lot of time on their hands created a set of programmatic design patterns. Their book, Design Patterns: Elements of Reusable Object-Oriented Software (ISBN 0-201-63361-2), describes recurring solutions to common problems in software design. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic patterns. Besides providing time-tested solutions, most of them have something else in common: they employ fine-grained, loose coupling. Although the book is over 15 years old, the recommendations are still applicable today, which is why it remains in the top 20 on Amazon’s top best-selling programing books list.

So, armed with an understanding of MVC and GoF design patterns, all our bases are covered; we have everything we need to develop that robust, flexible, and scalable, enterprise application, right? Sort of. With a lot of care and planning (and I do mean A LOT) we can create an application that lives up to these goals, but the plumbing that links all the business logic together can add a huge amount of infrastructure complexity to a project; and worse: it tends to be tightly coupled to the business components! It would be better if we could just plug our business logic into some existing structure. If you had something like that, you could focus on what a program is supposed to do and not how it’s glued together. And better yet, if it does it using design patterns, our loosely couple business classes will be loosely bound to the infrastructure.

Eureka!

Java Frameworks do just that:

• provide all the plumbing infrastructure
• implement design patterns
• enforce MVC

And they do in a way that is open to most any application development requirements. In my upcoming articles I will take a look at some of the most popular frameworks: Hibernate, Enterprise JavaBeans (EJB 3.0), JavaServer Faces (JSF), Struts, Spring, and others.

]]>