Java J2ee Tutorials

javascript code to alert before delete a record

noreply@blogger.com (Alex Rabe) — Mon, 10 Dec 2012 22:53:00 -0800

Write the javascript file js/delete.js containing the utility methods

view source

rint?

01function go(url)

02{

03 window.location = url;

04}

05 

06function delete(url)

07{

08 var isOK = confirm("Are you sure to delete?");

09 if(isOK)

10 {

11  go(url);

12 }

13}

How to Upload and Take Backup of Large MySql Database File into Local Database Using Command Prompt

noreply@blogger.com (Alex Rabe) — Mon, 15 Oct 2012 21:52:00 -0700

How to upload and take backup of large MySql database file into local database using command prompt

Craete data base in your local database
Copy the path where MySql bin folder is available in command prompt for example C:\wamp\bin\mysql\mysql5.5.24\bin
Write command to store database : mysql -u root -p db_name.sql< C:\Users\Desktop\db_folder_name\db_name.sql

Where C:\Users\Desktop\db_folder_name\db_name.sql is the path where dump database is available and db_name.sql is the database name

Note:
u = username
p = password (write password after p without space)

How to take database backup

Write command to command prompt : mysqldump -u root -p db_name > d:\class_db.sql

Where d:\class_db.sql is the path where you want to save backup file and class_bd is the name you want to save file as.

How to upload and take backup of large MySql database file into local database using command prompt

noreply@blogger.com (Alex Rabe) — Fri, 14 Sep 2012 23:44:00 -0700

How to upload and take backup of large MySql database file into local database using command prompt

Create data base in your local database
Copy the path where MySql bin folder is available in command prompt for example D:\wamp\bin\mysql\mysql5.5.24\bin
Write command to store database : mysql -u root -p db_name < D:\db_name.sql
where D:\db_name.sql is the path where dump database is available and db_name.sql is the database name

Note:

u = username
p = password (write password after p without space)

How to take database backup

Write command to command prompt : mysqldump -u root -p db_name > D:\class_db.sql
where D:\class_db.sql is the path where you want to save backup file and class_bd is the name you want to save file as.

Writing the first Struts Application

noreply@blogger.com (Alex Rabe) — Fri, 31 Aug 2012 05:34:00 -0700

Let's start with developing your first Struts application. Here are the steps involved in creating the Struts application.

Add relevant entries into the web.xml

a. Add ActionServlet Configuration with initialization parameters
b. Add ActionServlet Mapping
c. Add relevant taglib declaration
Start with a blank template for the struts-config.xml. In the struts-config.xml, add the following

a. Declare the RequestProcessor
b. Create a properties file and declare it as Message Resource Bundle
c. Declare the Message Resource Bundle
d. Declare the Form-bean
e. Declare the ActionMapping for the Form-bean
f. Add the forwards in the ActionMapping
Create the Form-bean class
Create the JSP with Struts tags
Create the Action class
For every <bean:message> tag in the JSP, add key value pairs to the Message Resource Bundle (properties file) created in Step 2b
Add Validation in the Form-bean
Define the error messages in the Message Resource Bundle
Create the rest of the JSPs.
Next, you will find the steps to build the Struts application. You will find more explanation & rationale for the steps in the book Struts Survival Guide.

1. Add relevant entries into the web.xml

web.xml for the Struts Application

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<display-name>Hello World Struts Application</display-name>
<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>1</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>
<taglib>
<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
</web-app>

2) Create the struts-config.xml

struts-config.xml for the Struts Application

<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<form-beans>
<form-bean name="CustomerForm" type="struts.example.CustomerForm"/>
</form-beans>
<global-forwards>
<forward name="mainpage" path="index.jsp" />
</global-forwards>
<action-mappings>
<action path="/submitCustomerForm"
type="struts.example.CustomerAction"
name="CustomerForm"
scope="request"
validate="true"
input="CustomerForm.jsp">
<forward name="success" path="Success.jsp" />
</action>
</action-mappings>
<controller processorClass="org.apache.struts.action.RequestProcessor"/>
<message-resources parameter="struts.example.MessageResources"/>
</struts-config>

3) Create the ActionForm

CustomerForm

public class CustomerForm extends ActionForm {
private String firstName;
private String lastName;
public CustomerForm() {
firstName = “”;
lastName = “”;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String s) {
this.firstName = s;
}
public String getLastName() {
return lastName;
}
public void setLastName(String s) {
this.lastName = s;
}
}

4) Create the CustomerForm JSP using Struts Tags

CustomerForm.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<html:html xhtml="true">
<head>
<title><bean:message key="exercise01.formpage.title"/></title>
<html:base/>
</head>
<body background="images/blueAndWhiteBackground.gif">
<h2><bean:message key="exercise01.formpage.title"/></h2>
<html:errors/>
<html:form action="/submitCustomerForm">
<bean:message key="prompt.customer.firstname"/>:
<html:text property="firstName" size="16" maxlength="16"/>
<BR>
<bean:message key="prompt.customer.lastname"/>:
<html:text property="lastName" size="16" maxlength="16"/>
<BR>
<html:submit property="step">
<bean:message key="button.save"/>
</html:submit>

<html:cancel>
<bean:message key="button.cancel"/>
</html:cancel>
</html:form>
</body>
</html:html>

5) Create the Action class

CustomerAction class

public class CustomerAction extends Action
{
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) throws Exception
{
ActionForward nextPage = null;
if (isCancelled(request)) {
System.out.println("Cancel Operation Performed");
return mapping.findForward("mainpage");
}
CustomerForm custForm = (CustomerForm) form;
if ("Save".equals(custForm.getStep()))
{
String firstName = custForm.getFirstName();
String lastName = custForm.getLastName();
System.out.println("Customer First name is " + firstName);
System.out.println("Customer Last name is " + lastName);
nextPage = mapping.findForward("success");
}
return nextPage;
}
}

6) Add properties to MessageResources.properties

Message Resource Bundle

########################################
# Exercise01 index page strings
########################################
exercise01.indexpage.title=Welcome to Exercise01

########################################
# Exercise01 CustomerForm strings
########################################
exercise01.formpage.title=Please enter your details
prompt.customer.firstname=First Name
prompt.customer.lastname=Last Name
button.save=Save
button.cancel=Cancel

7) Add validation to the Form bean

validate() method for CustomerForm

public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
// Firstname cannot be empty
if (firstName == null || firstName.trim().equals("")) {
errors.add("firstName", new ActionError("error.cust.firstname.empty"));
}
// Lastname cannot be empty
if (lastName == null || lastName.trim().equals("")) {
errors.add("lastName", new ActionError("error.cust.lastname.empty"));
}
return errors;
}

8) Add ActionError keys to the Message Resources

ActionError keys to Message Resources

########################################
# Common
########################################
errors.header=<h3><font color="red">Validation Error</font></h3>You must
correct the following error(s) before proceeding:<ul>
errors.footer=</ul><hr>
errors.prefix=<li>
errors.suffix=</li>

########################################
# Exercise01 CustomerForm ActionErrors
########################################
error.cust.firstname.empty=First Name is Required
error.cust.lastname.empty=Last Name is Required

9) Create the rest of the JSPs - index.jsp and Success.jsp. Notice that index.jsp uses the regular html:link tag that just forwards to another JSP. The Success.jsp uses the MVC compliant action mapping as the link. Define entries in MessageResource.properties for each of the bean:message keys in the JSPs.

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<html:html xhtml="true">
<head>
<title><bean:message key="exercise01.indexpage.title"/></title>
<html:base/>
</head>
<body background="images/blueAndWhiteBackground.gif">
<div align="center">
<html:link page="/CustomerForm.jsp">Go to Customer Form</html:link>
</div>
</body>
</html:html>

Notice the usage of bean:write tags in Success.jsp. They let you access certain beans in appropriate scope and write their properties to the Servlet/JSP OutputStream

Success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<html:html xhtml="true">
<head>
<title><bean:message key="exercise01.successpage.title"/></title>
<html:base/>
</head>
<body background="images/blueAndWhiteBackground.gif">
<h2><bean:message key="exercise01.successpage.title" />
<bean:write name="CustomerForm" property="firstName" />
<bean:write name="CustomerForm" property="lastName" />
</h2>
<h3><bean:message key="exercise01.successpage.message" /></h3>
<html:img src="images/beerchug.gif"/>
<html:link page="/showCustomerForm.do">Go Back</html:link>
</body>
</html:html>

What Is the Struts Framework?

noreply@blogger.com (Alex Rabe) — Fri, 31 Aug 2012 04:25:00 -0700

The Struts Framework is a standard for developing well-architected Web applications. It has the following features:

Open source
Based on the Model-View-Controller (MVC) design paradigm, distinctly separating all three levels:
- Model: application state
- View: presentation of data (JSP, HTML)
- Controller: routing of the application flow
Implements the JSP Model 2 Architecture
Stores application routing information and request mapping in a single core file, struts-config.xml

The Struts Framework, itself, only fills in the View and Controller layers. The Model layer is left to the developer.

The diagram below describes the flow in more detail:

User clicks on a link in an HTML page.
Servlet controller receives the request, looks up mapping information in struts-config.xml, and routes to an action.
Action makes a call to a Model layer service.
Service makes a call to the Data layer (database) and the requested data is returned.
Service returns to the action.
Action forwards to a View resource (JSP page)
Servlet looks up the mapping for the requested resource and forwards to the appropriate JSP page.
JSP file is invoked and sent to the browser as HTML.
User is presented with a new HTML page in a web browser.

Differences Between Struts1 and Struts2

noreply@blogger.com (Alex Rabe) — Fri, 31 Aug 2012 03:30:00 -0700

The table given below describes some differences between struts1 and struts2

Feature	Struts 1	Struts 2
Action classes	Struts1 extends the abstract base class by its action class. The problem with struts1 is that it uses the abstract classes rather than interfaces.	While in Struts 2, an Action class implements an Action interface, along with other interfaces use optional and custom services. Struts 2 provides a base ActionSupport class that implements commonly used interfaces. Although an Action interface is not necessary, any POJO object along with an execute signature can be used as an Struts 2 Action object.
Threading Model	Struts 1 Actions are singletons therefore they must be thread-safe because only one instance of a class handles all the requests for that Action. The singleton strategy restricts to Struts 1 Actions and requires extra care to make the action resources thread safe or synchronized while developing an application.	Struts 2 doesn't have thread-safety issues as Action objects are instantiated for each request. A servlet container generates many throw-away objects per request, and one more object does not impose a performance penalty or impact garbage collection.
Servlet Dependency	Actions are dependent on the servlet API because HttpServletRequest and HttpServletResponse is passed to the execute method when an Action is invoked therefore Struts1.	Container does not treat the Struts 2 Actions as a couple. Servlet contexts are typically represented as simple Maps that allow Actions to be tested in isolation. Struts 2 Actions can still access the original request and response, if required. While other architectural elements directly reduce or eliminate the need to access the HttpServetRequest or HttpServletResponse.
Testability	Struts1 application has a major problem while testing the application because the execute method exposes the Servlet API. Struts TestCase provides a set of mock object for Struts 1.	To test the Struts 2 Actions instantiate the Action, set the properties, and invoking methods. Dependency Injection also makes testing easier.
Harvesting Input	Struts 1 recieves an input by creating an ActionForm object. Like the action classes, all ActionForms class must extend a ActionForm base class. Other JavaBeans classes cannot be used as ActionForms, while developers create redundant classes to receive the input. DynaBeans is the best alternative to create the conventional ActionForm classes.	Struts 2 requires Action properties as input properties that eliminates the need of a second input object. These Input properties may be rich object types, since they may have their own properties. Developer can access the Action properties from the web page using the taglibs. Struts 2 also supports the ActionForm pattern, POJO form objects and POJO Actions as well.
Expression Language	Struts1 integrates with JSTL, so it uses the JSTL EL. The EL has basic object graph traversal, but relatively weak collection and indexed property support.	Struts 2 can use JSTL, but the framework also supports a more powerful and flexible expression language called "Object Graph Notation Language" (OGNL).
Binding values into views	Struts 1 binds objects into the page context by using the standard JSP mechanism.	Struts 2 uses a ValueStack technology to make the values accessible to the taglibs without coupling the view to the object to which it is rendering. The ValueStack strategy enables us to reuse views across a range of types, having same property name but different property types.
Type Conversion	Struts 1 ActionForm properties are almost in the form of Strings. Commons-Beanutils are used by used by Struts 1 for type conversion. Converters are per-class, which are not configurable per instance.	Struts 2 uses OGNL for type conversion and converters to convert Basic and common object types and primitives as well.
Validation	Struts 1 uses manual validation that is done via a validate method on the ActionForm, or by using an extension to the Commons Validator. Classes can have different validation contexts for the same class, while chaining to validations on sub-objects is not allowed.	Struts 2 allows manual validation that is done by using the validate method and the XWork Validation framework. The Xwork Validation Framework allows chaining of validations into sub-properties using the validations defined for the properties class type and the validation context.
Control of Action Execution	Each module in Struts 1 has a separate Request Processors (lifecycles), while all the Actions in the module must share the same lifecycle.	In Struts 2 different lifecycles are created on a per Action basis via Interceptor Stacks. Custom stacks are created and used with different Actions, as required.s

Download and Install Hibernate

noreply@blogger.com (Alex Rabe) — Sat, 18 Aug 2012 05:51:00 -0700

Let us see what are the jar files we need to download to work with hibernate framework, and how to install.

Working with the framework software is nothing but, adding the .jar(s) files provided by that framework to our java application. Each framework software is not an installable software, it means we do not contain any setup.exe
When we download any framework software, we will get a ‘zip‘ file and we need to unzip it, to get the jar files required, actually all framework softwares will follow same common principles like:

Framework software will be in the form of a set of jar files, where one jar file acts as main (We can call this file as core) and remaining will acts as dependent jar files.
Each Framework software contain at least one configuration xml file, but multiple configuration files also allowed.
In this case, in order to setup the Hibernate framework environment into a java application, the configuration file is the first one to be loaded into a java application, will see about this in later sessions.

Download Hibernate .jar(s) files:
we can download jars related to hibernate at http://sourceforge.net/projects/hibernate/files/hibernate3

From the above URL choose hibernate 3.2.2-ga.zip, as we are in initial stage this version will be better.
Unzip it, and now you can find some jar files in the lib folder right.?, actually we doesn’t require all the jar files, out of them just select the following jar files :

Anttr-2.7.6.jar
asm.jar
asm-attrs.jar
cglib-2.1.3.jar
commons-collections-2.1.1.jar
commons-logging-1.0.4.jar
ehcash.jar
dom4j-1.6.1.jar
hibernate3.jar
jta.jar
log4j-1.2.3.jar

These are the main jar files to run hibernate related programming and among all the jars hibernate3.jar is the main file, but for annotation we need to add 4 – 6 other jar files, i will let you when time comes.
Remember: along with the hibernate jars we must include one more jar file, which is nothing but related to our database, this is depending on your database.
So finally we need total of 12 jar files to run the hibernate related program.

EClipse Directory Structure

noreply@blogger.com (Alex Rabe) — Sat, 18 Aug 2012 00:14:00 -0700

WebContent: Regular Web files (HTML, JavaScript, CSS, JSP, images, etc.)
WebContent/some-subdirectory: Web files in subdirectory.
WebContent/WEB-INF: web.xml (used for servlet mappings)
WebContent/WEB-INF/lib: JAR files specific to application.
src/(default package): Unpackaged (default package) Java code. Using the default package is generally a bad choice in Web apps.
src/somePackage: Java code in somePackage package.
Note: You can cut/paste or drag/drop existing files into appropriate locations, but it is hard to drag files into a Java package until you create at least one class first.

Java Questions

noreply@blogger.com (Alex Rabe) — Sun, 22 Apr 2012 10:42:00 -0700

1. What is the difference between ServletContext and ServletConfig?

Both are interfaces. The servlet engine implements the ServletConfig interface in order to pass configuration information to a servlet. The server passes an object that implements the ServletConfig interface to the servlet's init() method.

The ServletContext interface provides information to servlets regarding the environment in which they are
running. It also provides standard way for servlets to write events to a log file.

2.What are forward & include methods? Why these are used?

Both forward() and include() are concrete methods of the RequestDispatcher class in the Servlet context. forward() - this method is used to show a different resource in place of the servlet originally requested.

Hibernate's Main Feature

noreply@blogger.com (Alex Rabe) — Mon, 16 Apr 2012 02:10:00 -0700

The most important Hibernate's feature is mapping from Java classes to database tables (and from Java data types to SQL data types), but also to provides data query ( and retrieval facilities ).
It is important that Hibernate generates the SQL calls and relieves keeping the application portable to all SQL databases, with database portability delivered at very little performance overhead.This feature can significialy reduce development time that programmer would have to spent with manual data handling in SQL and JDBC.

Reasuming Hibernate allows to create high-performance database applications with Java much faster and easier. Thanks to transparent persistence for Plain Old Java Objects (POJOs) all you need to do is build a simple POJO, next create XML mapping file that will describe relationship between the databse and the class attributes and at the end call Hibernate API's to specify the operations

You can use Hibernate as in standalone Java applications or as in Java EE applications using servlets or EJB session beans.

What is a Hibernate?

noreply@blogger.com (Alex Rabe) — Mon, 16 Apr 2012 01:58:00 -0700

Hibernate is an open source object (relational) mapping library for the Java language,that provides persistent classes and logic without caring how to handle the data.

Persistance in Java ( Hibernate ) is storing data in a relational databse using SQL.

How does hibernate generate beans and DAO(Data Access Object) from database?

noreply@blogger.com (Alex Rabe) — Sun, 15 Apr 2012 02:17:00 -0700

This movie shows some basics about generating beans and DAO (Data Access Object)* from database. To achieve this in this sample we are using JBoss Tools which have Hibernate reverse engineering. That's all for now. Enjoy the movie!

The Java Data Access Object (Java DAO) is an important component in business applications. Business applications almost always need access to data from relational or object databases and the Java platform offers many techniques for accessing this data. The oldest and most mature technique is to use the Java Database Connectivity (JDBC) API, which provides the capability to execute SQL queries against a database and then fetch the results, one column at a time. Although this API provides everything a developer needs to access data and to persist application state, it is a cumbersome API to develop against - which makes a Java DAO code generator particularly useful.

Login Form Example With Struts

noreply@blogger.com (Alex Rabe) — Wed, 28 Mar 2012 01:16:00 -0700

Login Form Example With Struts

This post will show you how a form process in struts 1 framework. We will create a login form and then using struts 1 we will verify the authentication of the user. This example will take following steps :

First of all we will create a form bean (LoginForm.java) that will hold the form values provided by the user.
Create a jsp page (Login.jsp) which will contain the form to be displayed to the user.
Create a success page (Success.jsp) and failure page (Failure.jsp) for providing feedback to the user on their form submission.
Create a controller helper class (LoginAction.java) that will check for the user input and decide which view to be respond to the users (Success.jsp or Failure.jsp).
And finally we will configure our form bean and action classes in struts-config.xml.

LoginForm.java

Following is the code in LoginForm.java file:


package com.demo.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;

public class LoginForm extends ActionForm {

private static final long serialVersionUID = -3491637470205228033L;

private String userName = null;
private String passWord = null;

public String getUsername() {
return username;
}

public void setUsername(String userName {
this.userName = userName;
}

public String getPassword() {
return passWord;
}

public void setPassword(String passWord) {
this.passWord = passWord;
}

@Override
public void reset(ActionMapping mapping, HttpServletRequest request) {
this.passWord = null;
}
}

There are two fields in this form bean “username” and “password”, that will hold the value of two fields in the login form. One new goods here is the method “reset” which is overwritten by our form bean. “reset” method is called at the end of the every request processed by the struts. In reset method we have set the value of password as null which means every time the user will open the login jsp in browser it will show the last username but will not show the value of password.

Login.jsp

Bellow are the content of Login.jsp:

This jsp will render a form with two fields, “userName” and “passWord”. Struts HTML taglib has been used to create the form. will render as a html form with submit url as “/Login.do”, so our action must use this path in configuration to be run. will be render as html input tag and it’s value will be put in the “username” field of the form bean LoginForm. Same with the property “password”.

LoginAction.java

Lets look inside the code in LoginAction.java:


public class LoginAction extends Action {
@Override
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response)
throws Exception {
LoginForm loginForm = (LoginForm)form;
if(loginForm.getUsername() == null || loginForm.getPassword() == null ||
!loginForm.getUsername().equalsIgnoreCase("abc") || !loginForm.getPassword().equals("123")){
    return mapping.findForward("failure");
}
else
    return mapping.findForward("success");
}
}

As you can see first of all the ActionForm instance is typecast to LoginForm in the execute method of LoginAction and then logic to verify the username and password will decide which view to be send back to the user. In this case, username must be “rahul” ans password must be “abc” to go to the view associated with the “success”, otherwise view associated with “failure” will be returned. We can see the jsp files associated with “success” and “failure”.

struts-config.xml

Entries of form beans and actions aer done in struts-config.xml as follows :

Our LoginForm class has been added as a form bean named “loginForm” and associated with the action class LoginAction. Attributes associated with the action class are specified as with the following reason :

name=”loginForm” : Struts will instantiate the LoginForm class will set the value of form properties.
path=”/Login” : The action class will be associated with the request path “/Login.do”. Hence the Login.jsp contains “/Login” as action attribute value.
input=”/Login.jsp” : Form inputs will be taken from Login.jsp.
There are two action forwards also registered with our action which tells struts that if “failure” is return by action then the response view will be “/Failure.jsp” and if “success” is returned by action then the response view will be “/Success.jsp”.

Deploy the war file in Tomcat 6 and hit the url in your browser you will get the following login form:

Struts 1 Taglib

noreply@blogger.com (Alex Rabe) — Sat, 24 Mar 2012 06:10:00 -0700

The Struts Taglib component provides a set of JSP custom tag libraries that help developers create interactive form-based applications. There are tags to help with everything from displaying error messages to dealing with nested ActionForm beans.

Struts Taglib is composed of four distinct tag libraries: Bean, HTML, Logic, and Nested.

Bean: The bean tags are useful in defining new beans (in any scope) from a variety of possible sources, as well as a tag to render a particular bean (or bean property) to the output response.
HTML: The HTML tags are used to create input forms, as well as other tags generally useful in the creation of HTML-based user interfaces. The output is HTML 4.01 compliant or XHTML 1.0 when in XHTML mode.
Logic: The Logic tags that are useful in managing conditional generation of output text, looping over object collections for repetitive generation of output text, and application flow management
Nested: The Nested tags extend the base Struts tags to allow them to relate to each other in a nested nature. The fundamental logic of the original tags doesn't change, except in that all references to beans and bean properties will be managed in a nested context.

Struts: Structuring a Web Application

noreply@blogger.com (Alex Rabe) — Sat, 24 Mar 2012 00:18:00 -0700

Web application as a program that resides on a Web server and produces dynamically or static created pages in a hypertext markup language (most commonly HTML) in response to a user’s request. A user make request by clicking the link or button on the web page. To built the Web application, Java 2 Enterprise Edition (J2EE) must be used.

Web Container :
A web container is a program that manages the components of a Web application, in particular JSP pages and Java Servlets. A Web container provides a number of services, such as

Life-Cycle management: Web container provide the process of starting up and shutting down a component.
Concurrency: Provide the capability to process more than one action at a time.
Security : Provide the restricted access to components, such as username & password protection.
Portability: Access anywhere, taking very less resource.
Apache Tomcat & GlassFish Server are the example of a Web container, — an open-source implementation of the J2EE Java Servlet and JavaServer Pages (JSP) specifications. A specification is a document that describes all the details of a technology. Typically, a Web container also functions as a Web server, providing basic HTTP (Hypertext Transfer Protocol) support for users who want to access information on the site.

Struts Example

noreply@blogger.com (Alex Rabe) — Fri, 23 Mar 2012 04:42:00 -0700

Struts is modeled after the MVC design pattern, you can follow a standard development process for all of your Struts Web applications.

Identificaty of the application Views, the Controller objects that will service those Views, and the Model components being operated on.

1. Define and create all of the Views, in relation to their purpose, that will represent the user interface of our application. Add all ActionForms used by the created Views to the struts-config.xml file.
2. Create the components of the application’s Controller.
3. Define the relationships that exist between the Views and the Controllers (struts-config.xml).
4. Make the appropriate modifications to the web.xml file, describe the Struts components to the Web application.

Lets Start with step one. we will create the view file named index.jsp

index.jsp

<%@ page language="java" %>

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

Sample Struts Application

We have used some Struts-specific Form tag like instead of HTML tags. In the Form tags the attributes you can find some attributes defined in we will go through it. action : Represents the URL to which this form will be submitted. This attribute is also used to find the appropriate ActionMapping in the Struts configuration file, which we will describe later in this section. The value used in our example is Name, which will map to an ActionMapping with a path attribute equal to Name. name :Identifies the key that the ActionForm will be referenced by. We use the value NameForm. An ActionForm is an object that is used by Struts to represent the form data as a JavaBean. It main purpose is to pass form data between View and Controller components. We will discuss NameForm later in this section. type :Names the fully qualified class name of the form bean to use in this request. For this example, we use thevalue example.NameForm, which is an ActionForm object containing data members matching the inputs of this form.

To use the HTML tags, you must first add a taglib entry in the application’s web.xml file that references the URI /WEB-INF/struts-html.tld. This TLD describes all of the tags in the HTML tag library. The following snippet shows the element that must be added to the web.xml file:


	/WEB-INF/struts-html.tld /WEB-INF/struts-html.tld

The struts-html.tld is placed in the /WEB_INF directory. Next Step is to create the action form The ActionForm used in this example contains a single data member that maps directly to the nameinput parameter of the form defined in the index.jsp View. When an is submitted, the Struts framework populates the matching data members of the ActionForm with the values entered into the tags. The Struts framework does this by using JavaBean reflection. The accessors of the ActionForm must follow the JavaBean standard naming convention for example private String name; public void setName(String name); public String getName(); The NameForm.java file is shown below NameForm.java

package example; //import statements import javax.servlet.http.HttpServletRequest; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionMapping;

public class NameForm extends ActionForm {
	private String name = null; public String getName() {
		return (name);
	}
	public void setName(String name) {
		this.name = name;
	}
	public void reset(ActionMapping mapping, HttpServletRequest request) {
		this.name = null;
	}
}

To deploy the NameForm to our Struts application, you need to compile this class, move it to the /WEB-INF/classes/example directory, and add the following line to the section of the /WEB-INF/struts-config.xml file:

This makes the Struts application aware of the NameForm and how it should be referenced. Now we create the out page for the sample application. Lets name it diplayname.jsp displayname.jsp

Sample Struts Display Name

Hello <%= request.getAttribute("NAME") %> !!

Now we move to the step two of creating the application's controller In a Struts application, two components make up the Controller. These two components are theorg.apache.struts.action.ActionServlet and the org.apache. struts.action.Action classes. In most Struts applications, there is one org. apache.struts.action.ActionServlet implementation and can have many org.apache. struts.action.Action implementations. The org.apache.struts.action.ActionServlet is the Controller component that handles client requests and determines which org.apache.struts.action.Action will process the received request. When assembling simple applications, such as the one we are building, the default ActionServlet will satisfy your application needs, and therefore, you do not need to create a specializedorg.apache.struts.action.ActionServlet implementation. The second component of a Struts Controller is the org.apache.struts. action.Action class. As opposed to the ActionServlet, the Action class must be extended for each specialized function in your application. This class is where your application’s specific logic begins. NameAction.java

package example; import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.struts.action.Action; import org.apache.struts.action.ActionForm; import org.apache.struts.action.ActionForward; import org.apache.struts.action.ActionMapping;

public class NameAction extends Action {
	public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
		String target = new String("success"); if ( form != null ) {
			// Use the NameForm to get the request parameters NameForm nameForm = (NameForm)form; String name = nameForm.getName();
		}
		// if no mane supplied Set the target to failure if ( name == null ) {
			target = new String("failure");
		}
		else {
			request.setAttribute("NAME", name);
		}
	return (mapping.findForward(target)); }
}

Moving to step three, to deploy the NameAction to our Struts application, we need to compile the NameAction class and move the class file to /WEB-INF/classes/example directory, and add the following entry to the section of the /WEB-INF/struts-config.xml file:

For step four we modify the web.xml file. We have to to tell the Web application about our ActionServlet. This is accomplished by adding the following servlet definition to the /WEB-INF/web.xml file:


	action org.apache.struts.action.ActionServlet
		config /WEB-INF/struts-config.xml

	1

Once we have told the container about the ActionServlet, we need to tell it when the action should be executed. To do this, we have to add a element to the /WEB-INF/ web.xml file:


	action *.do

You will notice in the previously listed index.jsp that our action does not include a .do at the end of the URL. We do not have to append the .do because it is automatically appended if we use the tag. If you do not use the tag, then you will need to append .do to the action's URL. This mapping tells the Web application that whenever a request is received with .do appended to the URL, the servlet named action should service the request.

Hibernate persist() vs. save()

noreply@blogger.com (Alex Rabe) — Fri, 23 Mar 2012 01:05:00 -0700

Hibernate persist() vs. save()

For persist():

The semantics of this method are defined by JSR-220.

persist() is well defined. It makes a transient instance persistent. However, it doesn’t guarantee that the identifier value will be assigned to the persistent instance immediately, the assignment might happen at flush time. The spec doesn’t say that, which is the problem I have with persist().

persist() also guarantees that it will not execute an INSERT statement if it is called outside of transaction boundaries. This is useful in long-running conversations with an extended Session/persistence context.

save():

For save() it says, it is the hibernate standard.

first assigning a generated identifier.

save() does not guarantee the same, it returns an identifier, and if an INSERT has to be executed to get the identifier (e.g. “identity” generator, not “sequence”), this INSERT happens immediately, no matter if you are inside or outside of a transaction. This is not good in a long-running conversation with an extended Session/persistence context.

DTO, VO, POJO

noreply@blogger.com (Alex Rabe) — Fri, 23 Mar 2012 00:50:00 -0700

POJO: A Plain Old Java Object or POJO is a term initially introduced to designate a simple lightweight Java object, not implementing any javax.ejb interface. POJO is an acronym for Plain Old Java Object. The name is used to emphasize that the object in question is an ordinary Java Object, not a special object, and in particular not an Enterprise JavaBean.

Value Object (VO): A Value Object or VO is an object such as java.lang.Integer that hold values (hence value objects).

Data Transfer Object (DTO): Data transfer object (DTO), formerly known as value objects or VO, is a design pattern used to transfer data between software application subsystems. DTOs are often used in conjunction with data access objects to retrieve data from a database.

The difference between data transfer objects and business objects or data access objects is that a DTO does not have any behaviour except for storage and retrieval of its own data (accessors and mutators).

DTO vs VO

DTO - Data transfer objects are just data containers which is used to transport data between layers and tiers .It mainly contains of attributes ,You can even use public attributes without getters and setters .Data transfer objects do not contain any bussiness logic.
Analogy: Simple Registration form where you have attributes usename,password and email id . when you sumbit this form . In your servlet RegistrationServlet.java file you will get all the attributes from view layer to business layer where you pass the attributes to java beans and then to the DAO or the persistence layer . DTO’s helps in transporting the attributes from view layer to bussiness layer and finally to the persistence layer .
DTO was mainly used to get data transportd across the network efficiently , it may be even from JVM to another JVM .

DTOs are often java.io.Serializable – inorder to transfer data across JVM

VO - A Value Object [1,2] represents itself a fix set of data and is similar to a Java enum. A Value Object’s identity is based on their state rather than on their object identity and is immutable. A real world example would be Color.RED, Color.BLUE, SEX.FEMALE etc.

POJO V/S JavaBeans

The Java-Beanness of a POJO is that it’s public attributes are all accessed via getters and setters that conform to the JavaBeans conventions. e.g. private String foo; public String getFoo(){…} public void setFoo(String foo){…};
JavaBeans must implement Serializable and have a no-argument constructor. where as in POJO doesnot have these restrictions .

Simple ArrayList Example | ArrayList Sample

noreply@blogger.com (Alex Rabe) — Wed, 21 Mar 2012 00:58:00 -0700

package arraylistexample;  


import java.util.ArrayList;  
  
/** 
 * SimpleArrayListExample This is example for simple arraylist. It shows how  
 * to create an array list and also add the value into arraylist as well as 
 * reterive it
 */  
public class SimpleArrayListExample {  
 public static void main(String[] args) {  
  //creating arraylist  
  ArrayList al = new ArrayList();  
    
  //adding values into arraylist  
  al.add(1);  
  al.add(2);  
  al.add(3);  
    
  //Fetching the values from arraylist.  
for(int i=0;i
   System.out.println(al.get(i));  
  }  
 }  
}

Session Tracking Example JSP

noreply@blogger.com (Alex Rabe) — Thu, 1 Mar 2012 05:42:00 -0800

Session Tracking Example

Session tracking is maintain the state of a user through out the application.

There are four typical solutions to this problem.

Session
cookie
Url-rewriting
Hidden field

==================

1.Create a user login page "login-form.jsp"

login-form.jsp

User Login
Login Name
Password

===============

2.create a page to check the valid user.if it exists then it stores in the session forward to the "welcome-home.jsp" else it come back again "login-form.jsp".

login-form-action.jsp

<%@ page language="java" import="java.sql.*;"%>

String userName = request.getParameter("userName");

String password = request.getParameter("password");

System.out.println("MySQL Connect Example.");

Connection con = null;

System.out.println("MySQL Connect Example.");

Connection conn = null;

String url = "jdbc:mysql://localhost:3306/cms";;

String driver = "com.mysql.jdbc.Driver";

String username = "root";

String userPassword = "";

try {

Class.forName(driver).newInstance();

conn = DriverManager.getConnection(url,username,userPassword);

Statement st = conn.createStatement();

String strQuery = "SELECT count(*) FROM user WHERE loginId='"+userName+"' AND empPassword='"+password+"'";

out.println(strQuery);

ResultSet rs = st.executeQuery(strQuery);

if(rs.next())

{

if(rs.getInt(1)>0)

{

session.setAttribute("userid",userName);

response.sendRedirect("welcome-home.jsp");

}

else

{

response.sendRedirect("login-form.jsp");

}

System.out.println("Connected to the database");

conn.close();

System.out.println("Disconnected from database");

}

catch (Exception e) {

e.printStackTrace();

}

===================

welcome-home.jsp

What is Difference Between Statement and PreparedStatement

noreply@blogger.com (Alex Rabe) — Tue, 14 Feb 2012 00:52:00 -0800

There are four steps for the execution of query such as

Query is parsed,
Query is compile,
Query is optimized
Query is executed

In case of statement interface these four steps are performed, each time when query is submitted for execution. But in case of prepared statement first three steps are performed only once, when the query in initially submitted. Only the last step is performed each time query is submitted (in subsequence submissions), i.e if same query is submitted to be execute with different values multiple times then prepared statement interface provides better perfromance as compared to statement interface.

mysql-connector.jar for Connecting Java to MySQL

noreply@blogger.com (Alex Rabe) — Tue, 7 Feb 2012 04:46:00 -0800

This blog helps one how to connect java to mysql database, there are some steps to follow at first check for the java if java is not installed download latest jdk from sun java, This is where you can get latest java development kit http://java.sun.com/javase/downloads/index.jsp be sure that you installed java, you can check that via command prompt or terminal use this command without quote “java -version” so you must see like this java version “1.6.0_16″, Basically java has no jar file or pre built class for mysql connection which is called mysql-connector i mean driver class which supports for mysql connection so its better to download package called mysql connector so this plays a major role during connection so download that from a mysql web site http://www.mysql.com/products/connector/ they given more version look for latest version and download ans place it in a know place say(c:\mysql or /home/mysql) but don’t forget to unzip mysql-connector and i believe that mysql-server service already started in system.

This is program check the connectivity of mysql-server through localhost

import java.sql.*;

public class DatabaseConnectionExample {

public static void main(String args[]) {

System.out.println("Database Connection Example");

Connection con = null;

String url = "jdbc:mysql://localhost:3306/";

//String dbName = "test";

String driver = "com.mysql.jdbc.Driver";

String userName = "root";

String password = "";

try {

Class.forName(driver).newInstance();

//con = DriverManager.getConnection(url + dbName,userName,password);

con = DriverManager.getConnection(url,userName,password);

System.out.println("Database Connected");

con.close();

System.out.println("Connection Colsed.");

}

catch (Exception e){

System.out.println("Error: "+e);

}

Save as DatabaseConnectionExample.java, while compile it you have to include classpath of java to know more about classpath sun java is best guide http://java.sun.com/j2se/1.4.2/docs/tooldocs/solaris/classpath.html

Now it time to compile open command prompt go to the location of DatabaseConnectionExample.java if your your program is under c:\

use c: also may be at /home for tux users now compile it using javac -classpath /home/mysql/mysql-connector.bin.jar DatabaseConnectionExample.java so this command has three part javac, -calsspath, filepath, here javac is a compiler and we included a classpath of mysql-connector jar file locate that wherever it is for an example i given as /home/mysql/mysql-connector.bin.jar and next to that is java file. after compilation program needs to run so java interpreter shall do this job if this command is used java -classpath /home/mysql/mysql-connector.bin.jar: DatabaseConnectionExample. in my second I used colon so its specific for linux user unless windows use ;(semi-colon)

For Eclipse users, use can import mysql-connector.jar file to classpath before creating a class file, right click the project go to properties and choose java build path and then choose libraries tab and add external jar file.

Program shows this output

Database Connected.

Connection Closed.

Creating a Database Table

noreply@blogger.com (Alex Rabe) — Mon, 6 Feb 2012 05:35:00 -0800

package com;

import java.sql.*;

public class CreateTableExample {

public static void main(String args[]){

System.out.println("Creation Table Example");

Connection con = null;

String url = "jdbc:mysql://localhost:3306/";

String dbName = "test_db";

String driver = "com.mysql.jdbc.Driver";

String userName = "root";

String password = "";

try {

Class.forName(driver).newInstance();

con = DriverManager.getConnection(url + dbName, userName, password);

System.out.println("Database Connected");

try {

Statement stmt = con.createStatement();

String table = "CREATE TABLE EMPLOYEE(emp_id integer, emp_name varchar(50) )";

stmt.executeUpdate(table);

System.out.println("Table created successfully");

}

catch (Exception e){

System.out.println("Sorry!! Table already exists.");

}

con.close();

System.out.println("Connection Closed");

}

catch (Exception e){

System.out.println("Error: " +e);

e.printStackTrace();

}

========

Out Put

Creation Table Example

Database Connected

Table created successfully

Connection Closed

MySQL Database Connection in Java

noreply@blogger.com (Alex Rabe) — Mon, 23 Jan 2012 22:04:00 -0800

Description of program:

This program establishes the connection between MySQL database and java files with the help of various types of APIs interfaces and methods. If connection is established then it shows "Connected to the database" otherwise it will displays a message "Disconnected from database".

Description of code:

Connection: This is an interface in java.sql package that specifies connection with specific database like: MySQL, Ms-Access, Oracle etc and java files. The SQL statements are executed within the context of the Connection interface.

Class.forName(String driver): This method is static. It attempts to load the class and returns class instance and takes string type value (driver) after that matches class with given string.

DriverManager: It is a class of java.sql package that controls a set of JDBC drivers. Each driver has to be register with this class.

getConnection(String url, String userName, String password):

This method establishes a connection to specified database url. It takes three string types of arguments like:

url: - Database url where stored or created your database

userName: - User name of MySQL

password: -Password of MySQL

con.close(): This method is used for disconnecting the connection. It frees all the resources occupied by the database.

printStackTrace(): The method is used to show error messages. If the connection is not established then exception is thrown and print the message.

Code of program:

import java.sql.*;

public class MysqlConnect{

public static void main(String[] args) {

System.out.println("MySQL Connect Example.");

Connection conn = null;

String url = "jdbc:mysql://localhost:3306/";

String dbName = "jdbctutorial";

String driver = "com.mysql.jdbc.Driver";

String userName = "root";

String password = "root";

try {

Class.forName(driver).newInstance();

conn = DriverManager.getConnection(url+dbName,userName,password);

System.out.println("Connected to the database");

conn.close();

System.out.println("Disconnected from database");

} catch (Exception e) {

e.printStackTrace();

}

Delete Data Records Using JSP, My Sql

noreply@blogger.com (Alex Rabe) — Sat, 14 Jan 2012 05:06:00 -0800

deleteRecords.jsp

<%@ page language = "java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

<%@ page import = "java.sql.*"%>

Delete Records

<%! boolean success = false; %>

int delID = Integer.parseInt(request.getParameter("deleteID"));

//String sql = "DELETE * FROM EMP_DETAIL WHERE ID = '"+delID+"'";

String sql = "DELETE FROM EMP_DETAIL WHERE ID = ?";

Connection con = null;

PreparedStatement psmt = null;

String url = "jdbc:mysql://localhost:3306/test_db";

String driver = "com.mysql.jdbc.Driver";

String userName = "root";

String password = "";

Class.forName(driver).newInstance();

con = DriverManager.getConnection(url, userName, password);

psmt = con.prepareStatement(sql);

psmt.setInt(1, delID);

int nRows = psmt.executeUpdate();

if(nRows == 0){

success = false;

}

else{

success = true;

}

psmt.close();

con.close();

if(success == true){

One record deleted

View Records

}

else{

Can not delete record now. Please try later...

}

Java J2ee Tutorials

javascript code to alert before delete a record

How to Upload and Take Backup of Large MySql Database File into Local Database Using Command Prompt

How to upload and take backup of large MySql database file into local database using command prompt

Writing the first Struts Application

What Is the Struts Framework?

Differences Between Struts1 and Struts2

Download and Install Hibernate

EClipse Directory Structure

Java Questions

Hibernate's Main Feature

What is a Hibernate?

How does hibernate generate beans and DAO(Data Access Object) from database?

Login Form Example With Struts

Struts 1 Taglib

Struts: Structuring a Web Application

Struts Example

Hibernate persist() vs. save()

DTO, VO, POJO

Simple ArrayList Example | ArrayList Sample

Session Tracking Example JSP

User Login

What is Difference Between Statement and PreparedStatement

mysql-connector.jar for Connecting Java to MySQL

Creating a Database Table

MySQL Database Connection in Java

Delete Data Records Using JSP, My Sql