Java J2EE Technologies Articles Concepts Spring Hibernate

Java Synchronization

2012-03-12T23:34:00.001-07:00

Synchronization in Java:

Java Synchronization is a process of controlling the access of shared resources by the multiple threads in such a manner where only one thread can access one resource at a time. In non synchronized multithreaded application, it is possible for one thread to modify a shared object, while another thread is in the process of using or updating the object's value.

Synchronization prevents such type of data corruption. Synchronization is best use with the Multi-Threading in Java. Synchronization can be done at two levels:

Synchronizing a function
Synchronizing a block of code

Please find the sample code below

Synchronizing a function:

public synchronized void Display()

{
// related code
}

Synchronizing a block of code inside a function:

public myFunction ()
{
synchronized (this)
{
// Synchronized code
}
}

Oracle Weblogic Server CLASSPATH

2012-02-09T22:44:00.000-08:00

Setting up CLASSPATH in Weblogic Server:

Oracle WebLogic Server installs the following script that you can use to set the classpath that a server requires

WL_HOME/server\bin/setWLSEnv.cmd (on Windows)
WL_HOME/server/bin/setWLSEnv.sh (on UNIX)

In addition, WebLogic distribution server includes shell scripts that you can use to start the server. These scripts, which are located in the domain directories under the config directory of your WebLogic Server distribution, automatically set up the CLASSPATH variable in the shell before starting the server.

Java Spring Framework Dependency Injection Variants

2012-01-24T03:27:00.000-08:00

Variants in Java Spring Framework Dependency Injection:

Constructor dependency Injection: Dependencies are provided through the constructors of the component.

Setter dependency injection: Dependencies are provided through the JavaBeanstyle setter methods of the component and are more popular than Constructor dependency injection.

Constructor Dependency Injection Syntax:

public class ConstructorInjection
{
private Dependency dep;
public ConstructorInjection(Dependency dep)
{
this.dep = dep;
}
}

Setter Dependency Injection Syntax

public class SetterInjection
{
private Dependency dep;
public void setMyDependency(Dependency dep)
{
this.dep = dep;
}
}

Java Stack and Heap Memory

2012-01-20T23:50:00.000-08:00

Java Stack and Heap Memory:

Each time an object is created in Java it goes into the area of memory known as heap. The primitive variables like int and double are allocated in the stack, if they are local method variables and in the heap if they are member variables (i.e. fields of a class). In Java methods local variables are pushed into stack when a method is invoked and stack pointer is decremented when a method call is completed. In a multi-threaded application each thread will have its own stack but will share the same heap. This is why care should be taken in your code to avoid any concurrent access issues in the heap space. The stack is threadsafe (each thread will have its own stack) but the heap is not threadsafe unless guarded with synchronization through your code.

A method in stack is re-entrant allowing multiple concurrent invocations that do not interfere with each other. A function is recursive if it calls itself. Given enough stack space, recursive method calls are perfectly valid in Java though it is tough to debug. Recursive functions are useful in removing iterations from many sorts of algorithms. All recursive functions are re-entrant but not all re-entrant functions are recursive. Idempotent methods are methods, which are written in such a way that repeated calls to the same method with the same arguments yield same results. For example clustered EJBs, which are written with idempotent methods, can automatically recover from a server failure as long as it can reach another server.

STRUTS 2 Interceptors

2012-01-10T02:27:00.000-08:00

Interceptors in STRUTS 2

Many of the features provided in the Struts2 framework are implemented using interceptors; examples include exception handling, file uploading, lifecycle callbacks and validation. Interceptors are conceptually the same as servlet filters or the JDKs Proxy class. They provide a way to supply pre-processing and post-processing around the action. Similar to servlet filters,interceptors can be layered and ordered. They have access to the action being executed, as well as all environmental variables and execution

properties. (Reference: Ian Roughley - Starting Struts 2 Book)

Below are the implementing interceptors mentioned:

Spring Framework the ActionAutowiringInterceptor interceptor.
Request String and Form Values the ParametersInterceptor interceptor.
Servlet-based objects the ServletConfigInterceptor interceptor.

The first two interceptors work independently, with no requirements from the action, but the last interceptor ServletConfigInterceptor is different.It works with the assistance of the following interfaces:

SessionAware to provide access to all the session attributes via a Map
ServletRequestAware to provide access to the HttpServletRequest object
RequestAware to provide access to all the request attributes via a Map
ApplicationAware to provide access to all the application attributes via a Map
ServletResponseAware to provide access to the HttpServletResponse object
ParameterAware to provide access to all the request string and form values attributes via a Map
PrincipalAware to provide access to the PrincipleProxy object; this object implements the principle and role methods of the HttpServletRequest object in implementation, but by providing a proxy,allows for implementation independence in the action
ServletContextAware to provide access to the ServletContext object

Java Mail API

2012-01-01T22:37:00.000-08:00

Java Mail API is used to send and receive emails between applications. To send and receive the emails SMPT, POP and IMAP protocols are used. The message sending and receiving is done by creating a framework using set of abstract classes in the API. This framework allows the application to create customized cross-platform mail application by having basic knowledge of e-mail. There are methods and classes that are used to access mail folders, message downloading and sending messages along with attachments feature.

Java Mail API is used to create personal mail filter, simple mailing lists and personal mail applications. Java mail also includes the capabilities to add the emailing process to an enterprise application or even to create a full-fledged e-mail client. Many companies in the industry have written new e-mail clients using Java Mail.

JavaMail is a set of abstract classes that create a framework for sending, receiving and handling e-mail.
The package that Sun provides contains implementations of IMAP and SMTP, which allow sending and receiving mail.
The framework eases the creation of cross-platform mail application without an in-depth knowledge of e-mail.
There are methods and classes that allow access to mail folders, download messages, send messages with attachments and filter mail.

WebSphere Application Server Node Agents

2011-12-28T23:48:00.000-08:00

Node Agents in WebSphere Application Server

A Websphere Node is a logical grouping of server processes managed by WebSphere and that share common configuration and operation control. A node is a grouping of managed or unmanaged servers. A node usually corresponds to a logical or physical computer system with a distinct IP host address. Nodes cannot span multiple computers. Node names usually are identical to the host name for the computer.

Nodes in the network deployment topology can be managed or unmanaged. A managed node has a node agent process that manages its configuration and servers. Unmanaged nodes do not have a node agent.

A node corresponds to a physical computer system with a distinct IP host address. The node name is usually the same as the host name for the computer. The following table lists the nodes in this cell. You can add new nodes into the cell by clicking on "Add Node" and specifying a remote, running WebSphere Application Server instance.

The Websphere Node Agent represents the node in the management cell and keeps the configuration up to date. Node agents are administrative agents that represent a node to your system and manage the servers on that node. Node agents monitor application servers on a host system and route administrative requests to servers.

A Websphere Node Group is a new concept introduced with WebSphere Application Server V6. A node group is a grouping of nodes within a cell that have similar capabilities. A node group is a collection of managed nodes.

WebLogic Server Load Balancing

2011-12-21T23:23:00.000-08:00

Load Balancing in WebLogic Server

Load balancing is about distributing work across multiple servers within a cluster. Ideally you want this work to be distributed evenly, to the capabilities and load on each server within the cluster. WebLogic is able to load-balance requests to members within a cluster when certain conditions are satisfied.

First, WebLogic requires that (most) components be deployed homogeneously to each server in the cluster. In the multi-tier application setup, the web application is targeted to all servers that belong to the presentation tier cluster. Because of this, incoming requests can be distributed evenly across the different members of the presentation tier. Similarly, the EJB components are available on all members of the object tier cluster. Because of this, incoming EJB calls from the presentation tier (or any external client) can be distributed across the different servers in the object tier.

When a component is deployed to a cluster, multiple copies of the component will be sitting on the different servers comprising the cluster. WebLogic uses the cluster-wide JNDI tree to record the availability of these replicas in the object tier, whereas a proxy plug-in typically holds the information about the availability of servers hosting the servlets and JSP pages.

WebLogic also must be aware of the status of the components that have been deployed to the cluster. This information forms the basis on which a load balancer can decide which server instances should be used when a request is made to the cluster. WebLogic uses a variety of methods to determine the health status of servers, including multicast heartbeats. By knowing when a server instance is under heavy load while the others aren't, a load balancer is able to direct new requests to the other members of the cluster. Hardware load balancers often have this capability

Accessing the Java Spring Container

2011-12-18T22:59:00.000-08:00

How to access the java Spring Container:

Java Spring is an open source, lightweight, application framework that is intended to help structure entire applications in a consistent manner, pulling together best of breed single-tier frameworks in
a coherent architecture.

From Stand-alone:

ApplicationContext context = new
ClassPathXmlApplicationContext(APP_CONTEXT_CLASSPATH);
(APP_CONTEXT_CLASSPATH is spring/pam-contact-loader-spring-context.xml)

From Web Application

ApplicationContext context =
WebApplicationContextUtils.getWebApplicationContext(
pRequest.getSession().getServletContext());

web.xml modification

<ltcontext-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/classes/spring/pam-spring-context.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listenerclass>
</listener>

WebLogic Clustering

2011-12-15T23:25:00.000-08:00

Clustering in WebLogic

A WebLogic domain can be composed of a number of WebLogic instances, and several of these servers may be grouped into clusters. The Domain is the parent of a Cluster. It contains typically one Admin and one or more Managed servers. Now the Cluster is a grouping of some or all of these managed servers within the domain.For instance, you could set up a cluster of WebLogic servers, all of which host your web application and related resources. This cluster of servers could be fronted by a load balancer that distributes requests evenly across all the members of the cluster. The load balancer could itself be another WebLogic instance. All server instances must belong to the same WebLogic domain.

Thus, a WebLogic cluster is a group of servers working together with services, such as clustered JNDI, to provide support for failover and load balancing. A domain may in turn have a number of WebLogic instances, several groups of which can be placed into different clusters.

Difference between Web Server and Application Server

2011-12-14T20:34:00.000-08:00

Webserver A Web server handles the HTTP protocol. When the Web server receives an HTTP request, it responds with an HTTP response, such as sending back an HTML page. To process a request, a Web server may respond with a static HTML page or image, send a redirect, or delegate the dynamic response generation to some other program such as CGI scripts, JSPs (JavaServer Pages), servlets, ASPs (Active Server Pages), server-side JavaScripts, or some other server-side technology. Whatever their purpose, such server-side programs generate a response, most often in HTML, for viewing in a Web browser.

Web servers are technology designed to create and deploy Web site, serving up content more so than applications. They both use Web interfaces, but Web servers are more about the interface than the back-end logic. In other words, Web servers serve up content. As time moves on Web servers are looking more like application server, as they adopt their functionality.

Application Server As for the application server, according to our definition, an application server exposes business logic to client applications through various protocols, possibly including HTTP. While a Web server mainly deals with sending HTML for display in a Web browser, an application server provides access to business logic for use by client application programs. The application program can use this logic just as it would call a method on an object.

An application server is technology where developers can create, test, and execute application components. Application servers are typically J2EE-based, running EJBs or other Java components. Application servers are designed to create true applications with complex business logic, and have scalability features such as load balancing, fail-over, and process distribution. In other words, it's primarily a development environment.

Difference between JRE/JVM/JDK

2011-09-13T20:44:00.000-07:00

JDK is the Java Development Kit i.e. JDK is bundle of software that you can use to develop Java based software. JRE is the Java Runtime Environment i.e. JRE is an implementation of the Java Virtual Machine which actually executes Java programs. Typically, each JDK contains one (or more) JRE’s along with the various development tools like the Java source compilers, bundling and deployment tools, debuggers,development libraries, etc.

Struts ActionForm & DynaActionForm

2010-03-03T06:40:00.000-08:00

Difference between ActionForm and DynaActionForm

An ActionForm represents an HTML form that the user interacts with over one or more pages. You will provide properties to hold the state of the form with getters and setters to access them. Whereas, using DynaActionForm there is no need of providing properties to hold the state. Instead these properties and their type are declared in the struts-config.xml

The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as the Struts Config file grow larger.

The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the form fields. Detecting them at runtime is painful and makes you go through redeployment.

ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.

ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the HTTP request parameters from direct use in Actions. With DynaActionForm, the property access is no different than using request.getParameter( .. ).

DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that can be avoided.

Hibernate proxy

2010-02-21T18:47:00.000-08:00

Hibernate proxy

Proxies are created dynamically by subclassing your object at runtime. The subclass has all the methods of the parent, and when any of the methods are accessed, the proxy loads up the real object from the DB and calls the method for you. Very nice in simple cases with no object hierarchy. Typecasting and instanceof work perfectly on the proxy in this case since it is a direct subclass. By default Hibernate creates a proxy for each of the class you map in mapping file. This class contain the code to invoke JDBC. This class is created by hibernate using CGLIB.

Proxies are the mechanism that allows Hibernate to break up the interconnected cloud of objects in the database into smaller chunks, that can easily fit in memory. Proxies are created dynamically by subclassing your object at runtime. The subclass has all the methods of the parent, and when any of the methods are accessed, the proxy loads up the real object from the DB and calls the method for you.

A class can be mapped to a proxy instead to a table. When you actually call load on session it returns you proxy. This proxy may contain actual method to load the data. Object proxies can be defined in one of two ways. First, you can add a proxy attribute to the class element. You can either specify a different class or use the persistent class as the proxy.

For example:

<class name="Loc"
proxy="com.ch01.Loc">
lt;/class>

The second method is to use the lazy attribute. Setting lazy="true"is a shorthand way of defining the persistent class as the proxy.

JSP Program to Delete a Cookie Values

2010-02-07T09:47:00.000-08:00

JSP is a dynamic scripting capability for web pages that allows Java as well as a few special tags to be embedded into a web file (HTML/XML, etc). The suffix traditionally ends with .jsp to indicate to the web server that the file is a JSP files. JSP is a server side technology - you can’t do any client side validation with it. The JSP assists in making the HTML more functional. Servlets on the other hand allow outputting of HTML but it is a tedious process. It is easy to make a change and then let the JSP capability of the web server you are using deal with
compiling it into a servlet and running it.

Sample JSP Program to Delete a Cookie Value:

<%
Cookie killCookie = new Cookie(“Ck”, null);
KillCookie.setPath(“/”);
killCookie.setMaxAge(0);
response.addCookie(killCookie);
%>

JSP pages are focused around HTML (or XML) with Java codes and JSP tags inside them. When a web server that has JSP support is asked for a JSP page, it checks to see if it has already compiled the page into a servlet. Thus, JSP pages become servlets and are transformed into pure Java and then compiled, loaded into the server and executed.

STRING OBJECTS in JAVA

2010-02-04T07:14:00.000-08:00

The Java String class (java.lang.String) is a class of object that represents a character array of arbitrary length. While this external class can be used to handle string objects, Java integrates internal, built-in strings into the language.

An important attribute of the String class is that once a string object is constructed, its value cannot change (note that it is the value of an object that cannot change, not that of a string variable, which is just a reference to a string object). All String data members are private, and no string method modifies the string’s value.

CONVERTING OBJECTS TO STRINGS

The String + operator accepts a non-string operand, provided the other operand is a string. The action of the + operator on non-string operands is to convert the non-string to a string, then to do the concatenation. Operands of native types are converted to string by formatting their values. Operands of class types are converted to a string by the method toString()
that is defined for all classes. Any object or value can be converted to a string by explicitly using one of the static valueOf() methods defined in class String:

String str = String.valueOf (obj);

If the argument to valueOf() is of class type, then valueOf() calls that object’s toString() method. Any class can define its own toString() method, or just rely on the default. The output produced by toString() is suitable for debugging and diagnostics. It is not meant to be an elaborate text representation of the object, nor is it meant to be parsed. These conversion rules also apply to the right-hand side of the String += operator.

CONVERTING STRINGS TO NUMBERS

Methods from the various wrapper classes, such as Integer and Double, can be used to convert numerical strings to numbers. This is often necessary for command line arguments where the parameter list is available to the main () method as a string array. The wrapper classes contain static methods ( such as parseInt() ) which convert a string to its own internal data type.

These can be used with class names rather than creating a separate object. Be aware that these particular conversion methods throw a NumberFormatException and must be used in the context of a try and catch block combination.

JDBC Java Program Using JDBC TYPE 3 Driver

2010-01-28T07:43:00.000-08:00

A Sample Java Program Using JDBC TYPE 3 Driver. This driver is called as Network Protocol Pure Java Driver. This driver would only be the option when DB vendor supplied Type II & IV drivers are not available.

Software: www.idssoftware.com

Server:

a) Install IDSServer software

b) d:\IDSServer\IDSS.exe

(The above said .exe runs as system startup service. IDSS.exe is a server socket program which runs on port number 12.)

c) Notice one more dir called

d:\IDSServer\classes>

jdk11drv.jar, jdk13drv.jar, jdk14drv.jar

Client:a) Client must demand server to download jdk14drv.jar file into client system and the same must be updated in CLASSPATH

[Note: Software installation is not required]

PATH: (only server)

d:\IDSServer

CLASSPATH (server & client)

d:\IDSServer\classes\jdk14drv.jar

Arch:

Driver: ids.driver.IDSDriver

URL: jdbc:ids://abc:12/conn?dsn='oracleSysDSN'

Procedure creation

c:> sqlplus scott/tiger

SQL> cle scr

sql> create or replace procedure emp_sal_proc(eno IN number, sal1 OUT number) IS
BEGIN
SELECT sal INTO sal1 FROM emp WHERE empno=eno;
END;

// Java Program

// ProcExecTest.java

import java.sql.*;
public class ProcExecTest
{
public static void main(String rags[]) throws Exception
{
Class.forName("ids.driver.IDSDriver");
Connection con=DriverManager.getConnection
("jdbc:ids://abc:12/conn?dsn='oracleSysDSN'", "scott", "tiger");
CallableStatement cstmt=con.prepareCall("{call emp_sal_proc(?,?)}");
cstmt.setInt(1, Integer.parseInt(rags[0]));
cstmt.registerOutParameter(2, Types.DOUBLE);
cstmt.execute();
System.out.println(cstmt.getDouble(2));
cstmt.close();
con.close();
}// main()
}// class

Hibernate Meta Model

2010-01-27T05:42:00.000-08:00

The meta model is the model used by Hibernate core to perform its object relational mapping. The model includes information about tables, columns, classes, properties, components, values, collections etc. The API is in org.hibernate.mapping and its main entry point is the Configuration class, the same class that is used to build a session factory.

The model represented by the Configuration class can be build in many ways. The following list the currently supported ones in Hibernate Tools.

A Core configuration uses Hibernate Core and supports reading hbm.xml files, requires a hibernate.cfg.xml. Named core in Eclipse and <configuration> in ant.
A Annotation configuration uses Hibernate Annotations and supports hbm.xml and annotated classes, requires a hibernate.cfg.xml. Named annotations in Eclipse and <annotationconfiguration> in ant.
A JPA configuration uses a Hibernate EntityManager and supports hbm.xml and annotated classes requires that the project has a META-INF/persistence.xml in its classpath. Named JPA in Eclipse and <jpaconfiguration> in ant.
A JDBC configuration uses Hibernate Tools reverse engineering and reads its mappings via JDBC metadata + additional reverse engineering files (reveng.xml). Automatically used in Eclipse when doing reverse engineering from JDBC and named <jdbcconfiguration> in ant.

In most projects you will normally use only one of the Core, Annotation or JPA configuration and possibly the JDBC configuration if you are using the reverse engineering facilities of Hibernate Tools. The important thing to note is that no matter which Hibnerate Configuration type you are using Hibernate Tools supports them.

The code generation is done based on the Configuration model no matter which type of configuration have been used to create the meta model, and thus the code generation is independent on the source of the meta model and represented via Exporters.

Servlet HttpSession Management

2009-11-09T06:48:00.000-08:00

Session tracking is a mechanism that is used to maintain state about a series of requests from the same user. Java Servlet technology provides an API for managing sessions and allows several mechanisms for tracking sessions. One of the best approach is by using HttpSession object. HttpSession interface is defined in "javax.servlet.http" package and is used for the purpose of session tracking while working with servlets.

we can access a session by calling the HttpServletRequest.getSession() or HttpServletRequest.getSession(boolean) method of a request object. This method will return the current session associated with this request or if the request does not have any session, it will create a new one.

A sample Program demonstrating the usage of HttpSession

import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

class HttpSessionEx extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {

response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println( "<HTML><BODY>" );

HttpSession sess = request.getSession(true);

// HttpSession Methods

Date cd = new Date(sess.getCreationTime());
Date acd = new Date(sess.getLastAccessedTime());
out.println("Session ID " + sess.getId());
out.println("Session was Created at: " + cd);
out.println("Session was Last Accessed at: " + acd);

// getting the session item

Object sessobj = sess.getAttribute( "power" );
out.println( "<BR>" + sessobj );

// getting the contents of the session

Enumeration data = sess.getAttributeNames();

while( data.hasMoreElements() ) {

String value = (String) data.nextElement();
sessobj = sess.getAttribute(value);
out.println( "<BR>" + value + " = " + sessobj );
}

out.println( "</BODY></HTML>" );

}
}

Hibernate Lazy Initialization

2009-11-06T06:22:00.000-08:00

Lazy Initialization in Hibernate

Hibernate supports the feature of lazy initilasation for both entities and collections, which actually means is, the Hibernate engine loads only those objects that we are querying for and doesn't try to fetch other entities (that are associated with the entity we are querying) or collections.

Lazy initialization load the child objects while loading parent object. To getting this set the lazy false in mapping file or class.lazy false in class file and hibernate will load the child when parent is loaded from the database. by default lazy is true. Lazy loading means that any foreign key references that you have in your table will be loaded only when referred to by the application. Eager loading means everything will be loaded at once.

An attribute 'lazy' can be used to let Hibernate know if the associated entity or collection has to be lazily loaded or prefetched.

<set name="Child" lazy="false" inverse="true">
<key column="FOREIGN_KEY_COL"/>
<one-to-many class="Parent"/>
</set>

This causes the collection to be eagerly fetched rather than doing a lazy fetch. If on the other hand, the attribute value of lazy is set to true, then hibernate will not make an attempt to fire the query for fetchingthe collection object until the request is made by the user.

Java Program to list the Contents of a Zip File

2009-11-04T06:33:00.000-08:00

Java Sample program to list the contents of a zip file

In this program we need to get the entries of the zip file, since each file in a zip file is represented by an entry. In this program assume that the filename of the zip file is 'Test.zip'. By calling the entries method of the ZipFile object we get an Enumeration back that can be used to loop through the entries of the file. We have to cast each element in the Enumeration to a ZipEntry.

import java.util.zip.ZipFile;
import java.util.zip.ZipEntry;
import java.io.IOException;
import java.util.Enumeration;

public class ListZipFiles
{
public void doListFiles()
{
try
{
ZipFile zipFile = new ZipFile("Test.zip");
Enumeration zipEntries = zipFile.entries();

while (zipEntries.hasMoreElements())
{
//Process the name, here we just print it out
System.out.println(((ZipEntry)zipEntries.nextElement()).getName());
}
}
catch (IOException ex) {
ex.printStackTrace();
}
}
// Command line arguments
public static void main(String[] args) {

new Main().doListFiles();
}
}

EJB Home Interface & Remote Interface

2009-08-09T05:14:00.000-07:00

EJB Home Interface

The EJBHome object must implement the home interface.
This interface contains the methods used by the clients to create and remove the instances of the EJB.
The home interface is the client’s initial point of contact with your EJB components.
For the client to access the EJB , an instance of the EJB is created from one or more create() methods of the Home interface.
The ejbCreate() methods defined in the EJB must also be declared with matching signatures in the Home interface.
Returns a reference to a EJB by creating or finding it.

EJB Remote Interface

The EJBObject class must implement the remote interface.
Once the client has used the home interface to gain access to EJB ,it uses this interface to invoke the business methods defined in the EJB class.
Clients can never get a reference to the EJBs class , only the EJBObject class.
The EJB container uses the remote interface for your bean to generate both the client-side stub and server-side proxy object that passes client calls to your EJB object.

Java Deployment Descriptor

2009-08-05T09:32:00.000-07:00

The deployment descriptor objects are used to establish the runtime service settings for an enterprise bean
This object defines the enviromental properties , along with the enterprise bean class name, the
JNDI namespace,the home and remote interface name
It has two types depending on the requirements,Session descriptor and entity descriptor
The deployment descriptor also contains detailed inforamtion about how the bean should execute regarding transaction and security
The deployment descriptor provides the full description of all files in the ejb jar
Deployment descriptor is defined in a XML based format having some standard tags and attributes

Entity Bean's Ready State & Pooled State

2009-07-28T11:39:00.000-07:00

The idea of the “Pooled State” is to allow a container to maintain a pool of entity beans that has been created, but has not been yet “synchronized” or assigned to an EJBObject. This mean that the instances do represent entity beans, but they can be used only for serving Home methods (create or findBy), since those methods do not relay on the specific values of the bean.

All these instances are, in fact, exactly the same, so, they do not have meaningful state. It can be looked at it this way

If no client is using an entity bean of a particular type there is no need for caching it (the data is persisted in the database). Therefore, in such cases, the container will, after some time, move the entity bean from the “Ready State” to the “Pooled state” to save memory. Then, to save additional memory, the container may begin moving entity beans from the “Pooled State” to the “Does Not Exist State", because even though the bean’s cache has been cleared, the bean still takes up some memory just being in the “Pooled State".

Struts 2

2009-07-26T21:37:00.000-07:00

Programming the abstract classes instead of interfaces is one of design problem of struts1 framework that has been resolved in the struts 2 framework

Most of the Struts 2 classes are based on interfaces and most of its core interfaces are HTTP independent

Unlike ActionForwards, Struts 2 Results provide flexibility to create multiple type of

outputs

In Struts 2 any java class with execute() method can be used as an Action class

ActionForms feature is no more known to the Struts 2 framework. Simple JavaBean flavored actions are used to put properties directly

Struts 2 Actions are HTTP independent and framework neutral. This enables to test struts applications very easily without resorting to mock objects

Java 5 annotations can be used as an alternative to XML and Java properties configuration

Struts 2 lets to customize the request handling per action, if desired. Struts 1 lets to customize the request processor per module

Struts 2 Actions are Spring-aware.Just need to add Spring beans

AJAX client side validation