JAVA

2008-06-30T00:14:00.000-07:00

Previous

Spring’s Dispatcher Servlet: test-servlet.xml You can break your xml files as you wish and can import all of them in test-servlet.xml so that during initialization of the application all of them will be loaded by the server as:

You have to give the url Mappings for different request types you want to handle by this servlet as:

The above syntax means, whatever request comes containing text Login.do will be handled by the bean loginController. Bean loginController can be defined there as

<bean id="loginController" class= "com.test.testproject.spring.common.LoginController">                 <property name="methodNameResolver">                                               <ref bean="loginMethodNameResolver">                                        </property>                                                                            <property name="commonUtil">                                                       <ref bean="commonUtil">                                                             </property>                                                                                  </bean>                                                                      <bean id="loginMethodNameResolver" class="org.springframework.web.servlet.mvc.multiaction.PropertiesMethodNameResolver">                                                                                        <property name="mappings">                                                        <props>                                                                                <prop key="/Login.do">login</prop>                                                 <prop key="/LoginSubmit.do">formSubmit</prop>                                      </props>                                                                                       </property>                                                              </bean>

In this definition, bean id is the name of the bean which should be unique among all application xml files. Class signifies the location of the actual java file.

There are mainly two types of controllers which can process request in Spring –

SimpleFormController and MultiActionController. SimpleFormControllers are the controllers can handle only one type of request where as MultiActionControllers can handle different types of request.

Here loginController, which extends MultiActionController, is a MultiActionControllers. In a MultiActionController like loginController there are different methods to handle different requests. To map between them a property provided by Spring “methodNameResolver“ is there which tells the Controller which method is to be invoked for a given request. Here that method name resolver bean is “loginMethodNameResolver”.

It tells that if request type is “/Login.do” then go to “login” method in the loginController and for “/LoginSubmit.do” request go to “formSubmit” method.

There are a lot of mappings of this kind which we have placed in other xml files and then all of them are imported in this test-servlet.xml. This type of break up will help in maintaining the changes in these files.

We have discussed mapping required for MultiActionController above. Following is the example of a SimpleFormController mapping:

This controller, which extends SimpleFormController, handles request “test/update.do” only.Below is the example of a Controller, other than SimpleFormController and MultiAction Controller:

This “forgotPasswordController” handles only one request ”ForgotPassword.do”. This controller, which implements Controller Interface, only redirects the request to another controller or returns a simple model which contains nothing. We will see this Controller class later....

Next

2008-06-30T00:01:00.000-07:00

Previous

The syntax says that any request which ends with .do will be handled by test-servlet that is described by test-servlet.xml.To set the index file, the first jsp to be loaded from the application, can be set as:

In the above case index.jsp file is to be placed directly under the application folder. This jsp redirects the url to another request as:

To include the taglibs (Java Standard Tag Library) into your jsp first add the following lines into the web-xml:

To include spring tags include the following lines:

We have used only a few of them in our project (core and fmt tags). Before you use this tags in your jsp, you must place those .tld files in WEB-INF.

Next

2008-06-29T22:50:00.000-07:00

Previous

Controllers:

Controllers are classes that interpret user input data or handles requests and send a model along with the view to the client after doing some customized processing. Every controller class actually returns a ModelAndView type of object. Controllers even can forward or redirect the request to a URL.
Among various types of controllers we have used:

• Controller – Default and the simplest form of controllers, when no form data is required to be handled at all

• SimpleFormController – For handling a single request by a controller

• MultiActionController – For handling different requests by a single controller
web.xml:

Whatever request comes from the client side first reaches to web.xml. This file was kept in WEB-INF. This file was mapped with the Spring Dispatcher Servlet named as test-servlet.xml as in our project (You can change the first part “test”):

Even you can set the context configuration inside test-servlet.xml as:

Next is how the web.xml will handle different types of request. This can be mapped as:

Next

2008-06-29T22:47:00.000-07:00

Previous

BeanFactory and ApplicationContext:

The BeanFactory is the Spring’s bean container which loads and wires bean at the initial time and supply them when requested for. The ApplicationContext is a BeanFactory which does this work.

You can have separate xml files for defining beans or can have a file such as an applicationContext.xml file to define all bean definition. We have used Spring’s Dispatcher Servlet test-servlet.xml as a bean factory which imports all other xml into it during initialization and loads all beans into the ApplicationContext.

Next

2008-06-29T22:42:00.000-07:00

Previous

Dispatcher Servlet:

Spring's web MVC framework is a request-driven web MVC framework, designed around a servlet that dispatches requests to controllers and offers other functionality facilitating the development of web applications. Spring's DispatcherServlet does that.

The Spring DispatcherServlet has a couple of special beans it uses, in order to be able to process requests and render the appropriate views. These beans are included in the Spring framework and can be configured in the WebApplicationContext, just as any other bean would be configured. Right now, we'll just mention some of them. For most of the beans, defaults are provided so you don't have to worry about configuring them.

• Handler mappings – for matching the URL and send them to a controllers

• Controllers – the actual controller beans

• View resolver – to find the exact location of the view (JSP)

• Theme resolver – capable of resolving themes for the application

• Handlerexceptionresolver – offers functionality to map different exceptions

Next

Spring Framework

2008-06-18T09:00:00.000-07:00

previous

Features of Spring:

• Clear separation of roles – controller, validator, command object, form object, model object, Dispatcher Servlet, handler mapping, view resolver etc. separate objects for each role.

• Powerful and straightforward configuration, easy referencing across contexts of both framework and application classes as beans.

• Separate controllers for different scenarios – plain, form, wizard, simple, multiaction.

• Customizable binding and validation – binding of any object is possible along with validation after submission of form.

• Customizable handler/controller mapping and view resolver – can handle simple requests via URLs or even can intercept a URL, and view resolvers help to locate the actual path of views.

• Map model transfer – transfer of any number of objects is possible via model object, no need to set them as request attributes.

• Supports Theme and JSTL tags with or without Spring tags.

Next

Spring Framework

2008-06-18T08:49:00.000-07:00

Previous

Spring’s MVC Architecture:

Spring’s MVC framework is designed based on Dispatcher Servlet which dispatches requests to respective request-handlers better known as controllers. Spring can bind any object as a command object which will be available directly in the controller class.

To do any validation of the form objects, you need a validation class which is provided by this framework.

After validation, if you want to send some data to the JSP that can be done via referenceData method. The controller class returns a view name (the JSP name) and a model Map.

The model contains all the bean names and corresponding objects you need to send to the view. View names and it’s location is resolved via view Resolver bean provided in the XML mapping.

Next

Spring Framework

2008-06-18T08:43:00.000-07:00

Previous

Introduction:

The content of this document is not a detailed description on Spring or Hibernate. This document contains how we have used Spring and Hibernate in our project.

I have shared most of the learning experiences I have gathered during execution of the project here. Those who have some prior knowledge on J2EE framework would be able to understand these.

Our project got executed using JBoss-3.2 server and Hibernate as back end. We have developed our codes in Eclipse-3 platform using Spring framework.

Finally the war file was deployed in Linux and it was platform independent.

Next

2008-04-15T23:50:00.000-07:00

What is reference ?

A reference to an entity that is substituted for the reference when the XML document is parsed. It can reference a predefined entity such as <>

The DTD can also carve out a segment of DTD specifications and give it a name so that it can be reused (included) at multiple points in the DTD by defining a parameter entity.

2008-04-15T23:34:00.000-07:00

What is resource adapter ?

A system-level software driver that is used by an EJB container or an application client to connect to an enterprise information system.

A resource adapter typically is specific to an enterprise information system. It is available as a library and is used within the address space of the server or client using it. A resource adapter plugs in to a container.

The application components deployed on the container then use the client API (exposed by the adapter) or tool-generated high-level abstractions to access the underlying enterprise information system.

The resource adapter and EJB container collaborate to provide the underlying mechanisms-transactions, security, and connection pooling-for connectivity to the enterprise information system.

2008-04-15T23:27:00.000-07:00

What is role (security) ?

An abstract logical grouping of users that is defined by the application assembler. When an application is deployed, the roles are mapped to security identities, such as principals or groups, in the operational environment.

In the J2EE server authentication service, a role is an abstract name for permission to access a particular set of resources.

A role can be compared to a key that can open a lock. Many people might have a copy of the key; the lock doesn't care who you are, only that you have the right key.

2008-04-15T23:25:00.000-07:00

What is schema ?

A database-inspired method for specifying constraints on XML documents using an XML-based language. Schemas address deficiencies in DTDs, such as the inability to put constraints on the kinds of data that can occur in a particular field.

Because schemas are founded on XML, they are hierarchical. Thus it is easier to create an unambiguous specification, and it is possible to determine the scope over which a comment is meant to apply.

2008-04-15T23:23:00.000-07:00

What is security role ?

An abstract logical grouping of users that is defined by the application assembler.

When an application is deployed, the roles are mapped to security identities, such as principals or groups, in the operational environment.

In the J2EE server authentication service, a role is an abstract name for permission to access a particular set of resources.

A role can be compared to a key that can open a lock.

Many people might have a copy of the key; the lock doesn't care who you are, only that you have the right key.

2008-04-15T23:21:00.000-07:00

What is session bean ?

An enterprise bean that is created by a client and that usually exists only for the duration of a single client-server session.

A session bean performs operations, such as calculations or database access, for the client. Although a session bean can be transactional, it is not recoverable should a system crash occur.

Session bean objects either can be stateless or can maintain conversational state across methods and transactions.

If a session bean maintains state, then the EJB container manages this state if the object must be removed from memory. However, the session bean object itself must manage its own persistent data.

2008-04-15T23:19:00.000-07:00

What is URL path ?

The part of a URL passed by an HTTP request to invoke a servlet. A URL path consists of the context path + servlet path + path info, where Context path is the path prefix associated with a servlet context of which the servlet is a part.

If this context is the default context rooted at the base of the Web server's URL namespace, the path prefix will be an empty string.

Otherwise, the path prefix starts with a / character but does not end with a / character. Servlet path is the path section that directly corresponds to the mapping that activated this request. This path starts with a / character. Path info is the part of the request path that is not part of the context path or the servlet path

2008-04-15T23:18:00.000-07:00

What is value-binding expression ?

A JavaServer Faces EL expression that refers to a property of a backing bean.

A component tag uses this expression to bind the associated component's value or the component instance to the bean property.

If the component tag refers to the property via its value attribute, then the component's value is bound to the property.

If the component tag refers to the property via its binding attribute then the component itself is bound to the property.

2008-04-15T23:16:00.000-07:00

What is Web server ?

Software that provides services to access the Internet, an intranet, or an extranet.

A Web server hosts Web sites, provides support for HTTP and other protocols, and executes server-side programs (such as CGI scripts or servlets) that perform certain functions.

In the J2EE architecture, a Web server provides services to a Web container. For example, a Web container typically relies on a Web server to provide HTTP message handling.

The J2EE architecture assumes that a Web container is hosted by a Web server from the same vendor, so it does not specify the contract between these two entities. A Web server can host one or more Web containers.

2008-04-15T23:13:00.000-07:00

What is Web service ?

An application that exists in a distributed environment, such as the Internet. A Web service accepts a request, performs its function based on the request, and returns a response.

The request and the response can be part of the same operation, or they can occur separately, in which case the consumer does not need to wait for a response.

Both the request and the response usually take the form of XML, a portable data-interchange format, and are delivered over a wire protocol, such as HTTP.

2008-04-15T23:04:00.000-07:00

What is XML ?

Extensible Markup Language. A markup language that allows you to define the tags (markup) needed to identify the content, data, and text in XML documents. It differs from HTML, the markup language most often used to present information on the Internet. HTML has fixed tags that deal mainly with style or presentation. An XML document must undergo a transformation into a language with style tags under the control of a style sheet before it can be presented by a browser or other presentation mechanism.

Two types of style sheets used with XML are CSS and XSL. Typically, XML is transformed into HTML for presentation. Although tags can be defined as needed in the generation of an XML document, a document type definition (DTD) can be used to define the elements allowed in a particular type of document. A document can be compared by using the rules in the DTD to determine its validity and to locate particular elements in the document.

A Web services application's J2EE deployment descriptors are expressed in XML with schemas defining allowed elements. Programs for processing XML documents use SAX or DOM APIs.

JAVA- PLSQL STORED PROCEDURES

2008-04-07T23:30:00.000-07:00

How can I protect my PL/SQL source code?

PL/SQL V2.2, available with Oracle7.2, implements a binary wrapper for PL/SQL programs to protect the source code.
This is done via a standalone utility that transforms the PL/SQL source code into portable binary object code (somewhat larger than the original).
This way you can distribute software without having to worry about exposing your proprietary algorithms and methods.
SQL*Plus and SQL*DBA will still understand and know how to execute such scripts. Just be careful, there is no "decode" command available.

The syntax is: wrap iname=myscript.sql oname=xxxx.plb

Can one print to the screen from PL/SQL?

One can use the DBMS_OUTPUT package to write information to an output buffer. This buffer can be displayed on the screen from SQL*Plus if you issue the SET SERVEROUTPUT ON; command.

For example:
set serveroutput on
Begin
dbms_output.put_line('Look Ma, I can print from PL/SQL!!!');
end;
/

DBMS_OUTPUT is useful for debugging PL/SQL programs. However, if you print too much, the output buffer will overflow.

In that case, set the buffer size to a larger value,

Eg.:
set serveroutput on size 200000

If you forget to set serveroutput on type SET SERVEROUTPUT ON once you remember, and then EXEC NULL;.

If you haven't cleared the DBMS_OUTPUT buffer with the
disable
or
enable procedure,
SQL*Plus will display the entire contents of the buffer when it executes this dummy PL/SQL block.

JAVA- PLSQL STORED PROCEDURES

2008-04-07T23:26:00.000-07:00

How can one see if somebody modified any code?

Code for stored procedures, functions and packages are stored in the Oracle Data Dictionary. One can detect code changes by looking at the LAST_DDL_TIME column in the USER_OBJECTS dictionary view.

Example: SELECT OBJECT_NAME, TO_CHAR (CREATED, 'DD-Mon-RR HH24: MI’) CREATE_TIME, TO_CHAR(LAST_DDL_TIME, 'DD-Mon-RR HH24:MI') MOD_TIME, STATUS FROM USER_OBJECTS WHERE LAST_DDL_TIME > '&CHECK_FROM_DATE';

How can one search PL/SQL code for a string/ key value?

The following query is handy if you want to know where a certain table, field or expression is referenced in your PL/SQL source code.

SELECT TYPE, NAME, LINE FROM USER_SOURCE WHERE UPPER(TEXT) LIKE '%&KEYWORD%';

How can one keep a history of PL/SQL code changes?

One can build a history of PL/SQL code changes by setting up an AFTER CREATE schema (or database) level trigger (available from Oracle 8.1.7). This way one can easily revert to previous code should someone make any catastrophic changes.

Look at this example:

CREATE TABLE SOURCE_HIST -- Create history table

SELECT SYSDATE CHANGE_DATE, USER_SOURCE.* FROM USER_SOURCE

WHERE 1=2;

CREATE OR REPLACE TRIGGER change_hist -- Store code in hist table

AFTER

CREATE

ON SCOTT.SCHEMA -- Change SCOTT to your schema name

DECLARE

BEGIN

if DICTIONARY_OBJ_TYPE

in ('PROCEDURE', 'FUNCTION', 'PACKAGE', 'PACKAGE BODY', 'TYPE')

then -- Store old code in SOURCE_HIST table

INSERT INTO SOURCE_HIST SELECT sysdate, user_source.* FROM

USER_SOURCE WHERE TYPE = DICTIONARY_OBJ_TYPE

AND NAME = DICTIONARY_OBJ_NAME; end if;

EXCEPTION

WHEN OTHERS THEN raise_application_error(-20000, SQLERRM);

END;

/ show errors

JAVA- PLSQL STORED PROCEDURES

2008-04-07T23:22:00.000-07:00

What is PL/SQL and what is it used for?

PL/SQL is Oracle's Procedural Language extension to SQL. PL/SQL's language syntax, structure and data types are similar to that of ADA. The PL/SQL language includes object oriented programming techniques such as encapsulation, function overloading, information hiding (all but inheritance).

PL/SQL is commonly used to write data-centric programs to manipulate data in an Oracle database.

Should one use PL/SQL or Java to code procedures and triggers?

Internally the Oracle database supports two procedural languages, namely PL/SQL and Java. This leads to questions like "Which of the two is the best?" and "Will Oracle ever desupport PL/SQL in favor of Java?”

Many Oracle applications are based on PL/SQL and it would be difficult of Oracle to ever desupport PL/SQL. In fact, all indications are that PL/SQL still has a bright future ahead of it. Many enhancements are still being made to PL/SQL.

For example, Oracle 9iDB supports native compilation of Pl/SQL code to binaries.PL/SQL and Java appeal to different people in different job roles.

The following table briefly describes the difference between these two language environments:

PL/SQL: Data centric and tightly integrated into the databaseProprietary to Oracle and difficult to port to other database systemsData manipulation is slightly faster in PL/SQL than in JavaEasier to use than Java (depending on your background)

Java:Open standard, not proprietary to OracleIncurs some data conversion overhead between the Database and Java type systemsJava is more difficult to use (depending on your background).

2008-04-07T23:17:00.000-07:00

A Simple java program

Let's look into our first program. Save the following text into the file called HelloWorld.java
--------------------------------------------------------------------------------

class HelloWorld {public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
--------------------------------------------------------------------------------

We examine that there is a class called HelloWorld. Since HelloWorld is the only class in the file, it is called the main class. The main class of the file has to be runnable in order to make your program runnable. In order to make your program runnable, you should have a function called main which is defined as:

public static void main(Strings[] args)

The explanation is as follows:

The public qualifier tells you that the function main is callable from outside. You don't have to worry about this one yet as the concept of making a function private or public is later described in Object Oriented Programming (OOP) philosophy.

Then the next qualifier is static. You don't have to worry about this either.Then, void tells you that the function main returns nothing to the system.Then the function's name, main.Then String[] args denotes the argument passed into the program. The arguments are not used in the moment. What is an argument? It is the options or switches you would mention when invoking programs. Like in dir /w or ls -la both /w and -la serve as arguments.

You can consider System.out.println as a command to print some text on the screen. Not that the text has to be surrounded by the double quotes. In this case, "Hello World!" is being printed, without the quotes of course. Remember that almost every command in Java ends with a semicolon(;).

IMPORTANT: The main class name has to be the same as the program file name. Otherwise, your Java program won't compile. In this example the class name is HelloWorld. The program file has to be HelloWorld.java. You have to pay attention that this naming convention is CASE SENSITIVE it means that naming your file into helloworld.java WON'T work. If your program won't compile, pay attention to the capitalization of your file name. This rule also applies even in Windows platform.

How to Compile and Run Your ProgramIn either Windows or UNIX, to compile the program, type the following command at your prompt: Don't forget to change the directory to the directory where your Java program resides. Also, make sure that your JDK installation is correct.

javac HelloWorld.javaIn Macintosh, just drag your HelloWorld.java file into the Java Compiler icon.

If it produces a file called HelloWorld.class, it means that your compilation is successful.

To run it, under Windows or UNIX,

Type the following:

java HelloWorldNotice that there is no .class extension on it.
Under Macintosh, simply double-click your HelloWorld.class file.

Commenting Your ProgramSometimes, it is useful to make some note about your program. Not only making you clear about what's going on your program, but also making others able to read your program based on the comments of your program. The compiler will completely ignore your comment, however. You cannot persuade the compiler to do your program eventhough your program has errors.

In Java, there are three ways of commenting:
Double slash comment.

Example:

// Put your comments hereAfter you put the double slash (//), everything else behind it is considered as comment.Embracing comment.

Example:
/*
My comment is hereNeat huh?
*/
If your comment is pretty long, it is better to embrace it with
/*
and
*/.

Everything within it is considered as a comment.Java doc comment. It is similar to above, except:
/**My comments here will be put intodocumentation by Javadoc program
*/It is embraced with
/**
and
*/.

Notice the double star. Your comments within it will be documented by the Javadoc program, an automatic documentation maker from Java SDK package.

STRING IN JAVA

2008-04-04T05:08:00.001-07:00

Replacing characters in String

The replace method of String can be used to replace all occurrences of the specified character with given character.

String replace(char oldChar, int newchar)

Getting substrings

String class provides substring method to extract specified portion of the given String. This method has been overloaded.

String substring(int startIndex)

String substring(int startIndex, int endIndex)

Note: A new String object containing the substring is created and returned. The original String won’t be affected.

If the index value is not valid, a StringIndexOutOfBoundsException is thrown.

Conversions

String class provides set of static overloaded valueOf method to convert primitives and object into strings.

static String valueOf(Object obj)

static String valueOf(char[] character)

static String valueOf(boolean b)

static String valueOf(char c)

static String valueOf(int i)

static String valueOf(long l)

static String valueOf(float f)

static String valueOf(double d)

Manipulating Character Case

String class provides following methods to manipulate character case in String.

String toUpperCase()

String toUpperCase(Locale locale)

String toLowerCase()

String toLowerCase(Locale locale)

Note : Original String object is returned if none of the characters changed, otherwise new String object is constructed and returned.

Miscellaneous methods

String trim()

This method removes white space from the front and the end of a String.

int length()

Returns length of the String.

String intern()

This method returns interned String object, if already present in the String pool. Otherwise this String is added into the pool, and then interned reference is returned.

STRING IN JAVA

2008-04-04T05:07:00.000-07:00

String Manipulations

Reading characters from String:

char charAt(index i)

Returns char at specified index. An index ranges from 0 to length() -1.

Searching characters in String

String class provides indexOf method which searches for the specified character inside the string object. This method has been overloaded. If the search is successful, then it returns the index of the char otherwise -1 is returned.

int indexOf(int c)

Returns the index of first occurrence of the argument char.

int indexOf(int c, int fromIndex)

Finds the index of the first occurrence of the argument character in a string, starting at the index specified in the second argument.

int indexOf(String str)

Finds the start index of the first occurrence of the substring argument in a String.

int indexOf(String str, int fromIndex)

Finds the start index of the first occurrence of the substring argument in a String, starting at the index specified in the second argument.

The String class also provides methods to search for a character or string in backward direction. These methods are given below.

int lastIndexOf(int ch)

int lastIndexOf(int ch, int fromIndex)

int lastIndexOf(String str)

int lastIndexOf(String str, int fromIndex)

STRING IN JAVA

2008-04-04T05:05:00.000-07:00

Constructors

String class provides various types of constructors to create String objects. Some of them are,

String()

Creates a new String object whose content is empty i.e. “”.

String(String s)

Creates a new String object whose content is same as the String object passed as an argument.

Note: Constructor creates a new string means it does not intern the String. Interned String object reference can be obtained by using intern() method of the String class

String also provides constructors that take byte and char array as argument and returns String object.

String equality

String class overrides the equals() method of the Object class. It compares the content of the two string object and returns the boolean value accordingly.

For example,

String str1=”Hello”;

String str2=”Hello”;

String str3=new String(”Hello”) //Using constructor.

If(str1 == str2)

System.out.println(“Equal 1”);

Else

System.out.println(“Not Equal 1”);

If(str1 == str3)

System.out.println(“Equal 2”);

Else

System.out.println(“I am constructed using constructor, hence

not interned”);

If( str1.equals(str3) )

System.out.println(“Equal 3”);

Else

System.out.println(“Not Equal 3”);

The output would be,

Equal 1

Not Equal 2

Equal 3

Note that == compares the references not the actual contents of the String object; Where as equals method compares actual contents of two String objects.

String class also provides another method equalsIgnoreCase() which ignores the case of contents while comparing.

Apart from these methods String class also provides compareTo methods.

int compareTo(String str2)

This method compares two Strings and returns an int value. It returns value 0, if this string is equal to the string argument a value less than 0, if this string is less than the string argument

a value greater than 0, if this string is greater than the string argument

int compareTo(Object object)

This method behaves exactly like the first method if the argument object is actually a String object; otherwise, it throws a ClassCastException.

String in Java

2008-04-04T05:02:00.000-07:00

Handling character strings in Java is supported through two final classes: String and StringBuffer. The String class implements immutable character strings, which are read-only once the string has been created and initialized, whereas the StringBuffer class implements dynamic character strings. All string literals in Java programs, are implemented as instances of String class. Strings in Java are 16-bit Unicode.

Note : In JDK 1.5+ you can use StringBuilder, which works exactly like StringBuffer, but it is faster and not thread-safe

The easiest way of creating a String object is using a string literal:

String str1 = "I cant be changed once created!";

A string literal is a reference to a String object. Since a string literal is a reference, it can be manipulated like any other String reference. i.e. it can be used to invoke methods of String class.

For example,

Int myLength = “Hello world”.length();

The Java language provides special support for the string concatenation operator ( + ), which has been overloaded for Strings objects. String concatenation is implemented through the StringBuffer class and its append method.

For example,

String finalString = “Hello” + “World”

Would be executed as

String finalString = new StringBuffer().append(“Hello”).append(“World”).toString();

The Java compiler optimizes handling of string literals. Only one String object is shared by all string having same character sequence. Such strings are said to be interned, meaning that they share a unique String object. The String class maintains a private pool where such strings are interned.

For example,

String str1=”Hello”;

String str2=”Hello”;

If(str1 == str2)

System.out.println(“Equal”);

Would print Equal when run.

Since the String objects are immutable. Any operation performed on one String reference will never have any effect on other references denoting the same object.

Variables and Expressions

2008-04-04T04:58:00.000-07:00

Expressions

Of course you can do more in using vaiables.

For example: You can write some math formula here like the excerpt below:


long E;
int m, c;

m = 5;
c = 3000;
E = m * c * c;

Hey, that's the famous E = mc² formula! You bet! :-) Of course you can do more complex equation with Java. These kind of equations will later be called expressions.

Keep in mind that Java doesn't have the ^ operator like BASIC. The power sign for Java will be discussed later.

Oh yes, in case you wonder this line:

      System.out.println("Hi, my name is "+name);
     System.out.println("I am "+age+" years old.");

Well, to print out variables onto the screen, simply put the plus sign after the text quotes you want to display, like the first lane in the above example. In the second line, suppose you want to continue with some more texts, you may add the plus sign, and again put some texts. Don't forget to wrap up the text with double quotes as well. If you just want to print out the variables, then you can do like this:

System.out.println(myvariable);

Hmm... pretty simple, eh?

Summary

To sum up, after following this lesson, you should understand the meaning of variables and how to use them, and how to apply expressions in Java. You should understand program scopes and how it affect variables. Of course, here you also learn how to print out your nice variables.

Variable and Expressions

2008-04-04T04:56:00.000-07:00

Variables

What is a variable anyway? You can consider a variable as a holder for a certain value. There are two kinds of variables: Simple variable, which is to be discussed soon, and complex variable. The difference between the two is that simple variables can only store one scalar value, while the complex ones can store more. If you don't understand what scalar means, don't worry about it. You will understand that anyway later.

How to declare a variable in Java? The variable is declared in the following format: ;

Let's look at the following example(Variables1.java):

class Variables1 {
  public static void main(String[] args)
  {
      int age;         // <-- These are the variables:
      String name;     // variable age of type integer
                       // and variable name of type string

      age = 20;
      name = "John Doe";

      System.out.println("Hi, my name is "+name);
      System.out.println("I am "+age+" years old.");
  }
}

You can examine there are two variables: age and name. Of course you can declare more than two variables. If you want to declare two or more variables of the same type, you can combine the declaration as follows:

int var1, var2, var3;

Well, that declaration says that we declare three variables: var1, var2, and var3. Be careful and keep in mind that Java is case sensitive, so pay attention to capital letters as well. Otherwise your program may not work.

To use variable, i.e. to make the variable store a value, simply put the equal sign after the variable name like the line age = 20; above. Of course, you will be able to use variables ONLY AFTER you declare them. However, it is not necessarily to have the variable declaration on the top of your program like the example above. You can declare them anywhere as long as before you using them.

There are some basic data types you should know. Note that this is not the basic in the technical sense, however, I just point out several data types that is necessary for you to know first.

int is the one that store integer values. Its limit is between about -2 billion to about +2 billion. Pretty much for simple applications.
long is the one you need if int is not sufficient for you.
float is the one that store fractional values like 0.5 and so on. It's practical limit is huge... don't ask me how big it is... :-)
String is the one that store sentences and words. So, the best use for this data type is like to input names, addresses, and so on.
char is the one that store only one character, either it is a letter, a space, or a single punctuation mark, and so on.

Keep in mind that in Java, we must acknowledge the scopes of the program in declaring variables. What is the scope? Well, don't bother on the technical details... simply consider that the scope is anything between the curly braces { ... }. The outer curly braces is called the outer scope, and the inner curly braces is called inner scope. Of course later you would have a lot more complex braces. If you declare variables in the outer scopes, they are visible (i.e. usable) by the program lines inside the inner scopes. However, if you declare variables in the inner scope, you cannot expect the outer scopes to see it. For the example see the illustration below:

{
 :  // Scope A
 :  // Suppose variable i is declared here
 :
    {
       :
       : // Scope B
       : // Suppose variable j is declared here
          {
             : // Scope C
             : // Suppose variable k is declared here
          }
       :
       : // Scope B continued
       :  // Suppose variable l is declared here
          {
             : // Scope D
             : // Suppose variable m is declared here
          }
       : // Scope B continued
    }
 :
 : // Scope A continued
 : // Suppose variable n is declared here
    {
        : // Scope F
    }
}

If you create the variable on the scope A, it will visible on all the scope below it. Like in the case of variable i above, it is visible through all scopes. In the case of variable j, it is only visible for scope C, D, and the rest of scope B, but not scope A and F. In the case of variable k, only scope C can use it, not even scope D. The same case is variable m, which can only be used by scope D. For the case of variable l in scope B, it can only be used by the rest of scope B and scope D. Scope C cannot use it because the variable is declared below scope C. Same case is variable n, which can only be used by the rest of scope A and scope F, but not scope B since the variable is declared below B.

This scope concept is very important to keep in mind. I'd rather to explain it to you pretty early so that you won't find much difficulties later, especially in dealing with methods.

XML (Extensible Markup Language)

2008-04-04T04:51:00.000-07:00

1. Introduction

XML (Extensible Markup Language) is a markup language that is used as a standard format for data. Since XML is structured, platform independent, textual information it is chosen as the best choice for data exchange in Web applications. XML serves the purpose as the tool for data exchange between the disparate applications in our project operating on different platforms. In our project IBM’s XML4J parser for XML has been used for parsing XML documents since it is totally written in Java and hence compatible with the architecture of our project. Our application creates an XML document with credit card information.

The credit card XML document is validated against a Document Type Definition, for all Creditcard information exchange, by a third party application like a dummy banking application. If the XML document is found to be valid, the Banking application retrieves data from the XML document and prints it out in HTML format.

2. Writing XML document through a Servlet

2.1 The user Interface

The data, which is to be written into an XML document is furnished by the user in a screen, meant for the data entry. The Screen is a JSP page that has text fields for entering Credit card Information like

· Credit card Name

· Name on the Credit card

· Creditcard Number

· Expiration Month

· Expiration Year

The user enters the data and presses “Next” button to move ahead in the Registration process (This Screen is a part of New User Registration in our project). But the validity of the data, the user has furnished, need to be validated for verifying the authenticity of the Information provided. Hence the Creditcard Information is sent to a Banking Application. First of all, Let us see how the data entered by the user is put into an XML document.

2.2 Writing the XML Document

The data entered from the page above are posted to a Servlet, CreditcardServlet.class file, the code for which is given below. The comments inserted between the code explain the functionality of the Servlet.

CreditcardServlet
/****************************************************************************************
* Class : CreditcardServlet
*
* Author : Lakshmanan .K
*
* Functionality : This class gets credit card data posted from the
Creditcard details entry screen
and writes the data into an XML file.
*************************************************************************************/

/************************************
Import the required packages for the servlet
*************************************/
import java.io.*;
import java.text.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class CreditcardServlet extends HttpServlet {

public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
{
/*******Get the data from Creditcard Entry Details******/
/******* Gets data for Creditcard Type **************/
String type = request.getParameter ("creditCardType");

/******* Gets data for Creditcard Name **************/
String name = request.getParameter ("creditCardName");

/******* Gets data for Creditcard Number **************/
String cardNumber = request.getParameter ("creditCardNumber");

/******* Gets data for Expiration month of the card **************/
String month = request.getParameter ("expirationMonth");

/******* Gets data for Expiration year of the card **************/
String year = request.getParameter ("expirationYear");

/*******Writes the data posted from the JSP
Page into an XML file ************/

/******* Create a new output file ************/
File outputFile= new File ("examples/CREDITCARD.xml");

/******* Create a new output stream ************/
FileOutputStream fos= new FileOutputStream(outputFile);

/******* The string “s” holds all the contents of the XML document
The XML document is written with conformance to a DTD, the Document
Type definition for the XML document. The discussion about the DTD is
Given at the end of the Servlet code *********************/
String s= new String ("\n"+
/***** DTD Declaration *****/
"\n"+
/***** Root element for the XML Document *******/
"\n"+
/***** USER tag which encapsulates all the other
credit card information for a single user *****/
"\n"+

/*** Card type data put in between CARDTYPE XML tags ***/
""+type+"\n"+

/*** Card name data put in between CARDNAME XML tags ***/
""+name+"\n"+

/*** Card Number data put in between CARDNUMBER XML tags ***/
""+cardNumber+"\n"+

/*** Expiration month data put in between EXPIRATIONMONTH XML tags ***/
""+month+"\n"+

/*** Expiration year data put in between EXPIRATIONYEAR XML tags ***/
""+year+"\n"+

/*** End the user element tag ***/
"\n"+

/*** End the Root element CREDITCARD tag ***/
"");

/***** New string reader initialized *****/
StringReader sr= new StringReader(s);
int c;
/***** Ouputstream writes the string into the file *****/
while((c=sr.read())!=-1)
fos.write(c);

//calls the next page which gives links to the XML document created and
//and the XML to HTML functionality getServletConfig().getServletContext().getRequestDispatcher("/jsp/auction/XMLCreated.jsp").forward(request, response);
}

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

/**
Return servlet information

@return message about this servlet
*/
public String getServletInfo(){
return "CreditcardServlet";
}

}

The servlet , as explained clearly in the comments, writes the posted data into an XML document. While the XML document is written, it is taken care that the document confirms to the Document Type Definition for Credit card XML documents.

The XML document has to be validated against a standard to verify its validity and make it shareable with disparate applications. The DOCTYPE declaration in the XML document refers to a Document Type Definition that is stored in a specific URL.

An XML document is valid if its content conforms to the rules in its DTD. A DTD is a grammar that describes what tags and attributes are valid in an XML document and in what context they are valid. The Document type declaration can make reference to an external DTD or include the DTD internally.

The Document Type Definition (DTD) written exclusively for this credit card information sharing application is given below.

CREDITCARD.dtd

The Document Type Definition is kept in a URL common to the Applications, which share the data. The Document type definition can be In-line too, i.e. it can be part of the XML document itself. The DTD starts with the XML declaration statement. Then it defines the Root element, which encapsulates all other elements. Subsequently all other elements are defined, the content of the elements, their attributes, the other elements which they encapsulate, etc.,

Let us see how the XML document created by the Creditcard servlet looks like

The picture above shows the XML file created, in IE 5.0 Browser. IE 5.0 has an in-built XML parser which does the validation against the document type definition for that XML document and displays the tree structure XML document. If the XML document is not well-formed, i.e. the document is not syntactically correct, or if the XML document is not valid, i.e. it does not confirm with the Document Type Definition, the Parser throws out an error and the IE browser does not display the XML document. It simply displays the error message.

Wrapper Classes

2008-04-04T04:49:00.000-07:00

What are Wrapper Classes?

Describe the wrapper classes in Java.Wrapper classes are classes that allow primitive types to be accessed as objects.

Wrapper class is wrapper around a primitive data type.

Following table lists the primitive types and the corresponding wrapper classes:

Primitive

Wrapper

Boolean

java.lang.Boolean

Byte

java.lang.Byte

Char

java.lang.Character

double

java.lang.Double

Float

java.lang.Float

Intjava.lang.Integer

Longjava.lang.Long

Shortjava.lang.Short

Void

java.lang.Void

History of Java

2008-03-31T23:01:00.001-07:00

But C++ was still complex with things like pointers, memory leak and multiple inheritence. The pointer concept was taken from C and it was very messy! The pointer is special type of variable that points to other variables. Since there was no guidelines as to how to use these pointers, it was very easy loose track of them.

In a typical two thousand lines program, one would frequently end up with hundredes of pointers pointing to thousands, some of them are pointers and some just plain variables. Needless to say this made a large program extremely difficult to read and when the programmer left for another company, they would have no other choice than to just throw away his program! It was sometimes necessary to do this even when the programmer was around and very much alive.

This is because the pointers he created inside his program had taken a life of their own and defy every attempt to predict how the program should behave. Memory management was also another weak point of C and C++. The programmer was responsible for cleaning up the memory their program would allocate and use. Failure to do so will result in a crash of the whole computer.

Multiple inheritence, though sparingly used, was another feature of C++ which made a programmer's life miserable. It, however, had its use, especially in job interviews. This one question, they thought, helped them separate the wheat from the chaff.

But C++ still had some nice and simple features, like inheritence, encapsulation, etc. They are something one can describe in plain english, something one can explain to a layman. So the creator of java decided to take the good features of inherience, encapsulation, and polymorphism from C++, while discarding the bad features such as multiple inherience, pointers etc. The memory management was improved in java where the programmer will not be held responsible for memory management. They can clean up after themselves if they want to get extra credit, but they do not need to. Needless to say all these was great news to the tourists in Indonesia!

Java introduced lot of clarity in notations too. For example, in C++ they would say class doctor:person to mean doctor is derived from person. It is obviously very cryptic. The same situation can be expressed in java as class doctor extends person , which is much easier to understand. But there are few awkward stuff in java too especially when someone says class bum extends person (my last bum joke)!

Java made an important contribution in the graphical user interface (GUI) area. C++ was really lacking in expertise here. They visual C++, but worked only on windows environment. But it did not work in UNIX systems or mackintoshes. Just like other features of java, this was also supposed to be platform independent. This was further necessary because one can put some little GUI on a web page which can be views over the internet. And one cannot control what kind of computers other will have.

After a while, it was necessary to call programs from one computer to another computer. To do this, they created J2EE. I am not sure how they came up with the name J2EE. The 'J' of J2EE, of course, means "Java", and I can be reasonably sure '2' stands for 'To'. But I do not know what the 'EE' part is all about, probably some kind of extension. Or at this point they ran out of names to think of. So they decided to have one of those just another vague acronyms.

History of Java

2008-03-30T00:20:00.000-07:00

History of Java

The java programming language is becoming more and more popular each day. It is the language without which one cannot even hope to a land a job these days. But has somebody even wondered how this language came about? There are many stories about, many books have been written. Here is my version (not approved by Sun Microsystems).

The java programming language originated in Indonesia. It was meant to be used by the tourists that visit that country each year. Why would tourists want to use computer? Well, these are no ordinary tourists. They are rich tourists. Have they not been rich, they would not travel half way around the world to visit this place. Most people would be content to see just what is available near by. For example, if you are a texan living in Dallas, you will visit the stockyards or may be the trinity river park. If you live in New Orleans area, you would see st. mary's bayou. Once in your lifetime, one will probably visit Hawaii or Niagara.

But going to Indonesia and its islands, Bali, Java, etc is not for the ordinary people. Anyway, coming back to the question why these tourists need to use computer programs. They go there not just to have fun and also get some work done in a fun atmosphere as these people are very important people.

From the very start java was supposed to be computer independent. That means if you write a program in java in one computer, it should run in all computers. This was necessary because tourists bring all kinds of computers with them. Some bring Windows machine, some Apple mackintosh. Some of the affluent ones bring Sun server workstations or even a super computer.

Before starting to create java they also sought to see if there have similar stuff done already. Even though they could find none, they found they can use lots of feature from some existing laguages.

One such language they found was C++. C++ was an advancement over the language called C. In fact, ideas of C++ was already hidden in C. In that language, one can increment a variable, say i, by applying the ++ operator e.g. i++. This would increase the value of the variable i by one. If i had a value of 5, it would make it 6, etc. What a vision!

Anyway, coming back to C++, it made an important advancement over C by introducing the idea of a class. To understand class, one has to undestand structure which was already used in C. The structure is a group of variables. For example, you have a name, an address, age etc. for any person.

In stead of using them separately, in C one can group them together and call it a person. The creator of C++ said there is no need to expose these variables (name, address, etc) to the outside world. They said these details should be hidden from the outside world. They called this concept encapsulation.

Another important contribution of C++ was the concept of inheritence. This concept can be best explained by example. Let's go back to the example of the person. A person is very general concept. There can be many different kinds of persons, e.g doctors, lawyers, teachers, or just a bum! But each of these people have a name, an address, age etc.

Even a bum has all these. The creator of C++ thought one can define a base class call person and other classes can be derived from it. In plain english, this would mean, a doctor is special kind of person, lawyer is another special kind of person. Now the common attributes of all these kinds of people can be put in the person class and special attributes can be put in the derived classes, e.g. hospital for the doctor, court for the lawyer, and nothing for the bum.

>>Next>>