A web application has the directory structureas shown in below figure.

The root directory of the application is called the document root. Root directory is mapped to the context path. Root directory contains a directory named WEB-INF. Anything under the root directory excepting the WEB-INF directory is publically available, and can be accessed by URL from browser. WEB-INF directory is a private area of the web application, any files under WEB-INF directory cannot be accessed directly from browser by specifying the URL like http://somesite/WEB-INF/someresource.html. Web container will not serve the content of this directory. However the content of the WEB-INF directory is accessible by the classes within the application. So if there are any resources like JSPs or HTML document that you don’t wish to be accessible directly from web browser, you should place it under WEB-INF directory.

WEB-INF directory structure

WEB-INF directory contains

• WEB-INF/web.xml deployment descriptor
• WEB-INF/classes directory
• WEB-INF/lib directory

/WEB-INF/web.xml

web.xml is called the web application deployment descriptor. This is a XML file that defines servlets, servlet mappings, listeners, filters, welcome files etc. Deployment descriptor is a heart of any J2EE web application, so every web application must have a web.xml deployment descriptor directly under WEB-INF folder.

/WEB-INF/classes

The classes directory is used to store compiled servlet and other classes of the application. If your classes are organized into packages, the directory structure must be reflected directly under WEB-INF/classes directory. The classes directory is automatically included in CLASSPATH.

/WEB-INF/lib

Lib directory is used to store the jar files. If application has any bundled jar files, or if application uses any third party libraries such as log4j, JDBC drivers which is packaged in jar file, than these jar files should be placed in lib directory.

All unpacked classes and resources in the /WEB-INF/classes directory, plus classes and resources in JAR files under the /WEB-INF/lib directory are included in classpath and made visible to the containing web application.
Note Directory and file names are case sensitive.

Download and install Mysql binary file. It will be automatically configured during installation.

For succesfull connection between Java and MySQL, MySQL-J connector should be installed and configured. For that, do the following steps.

Download MySQL-J connector from Mysql website. Unpack it. Select mysql connector .jar file. Copy and paste it to jdk/jre/lib/ext folder. You should also add the complete path to this JAR file in your CLASSPATH environment variable. In case if you don’t know how to do that, go to Start -> Settings -> Control Panel -> System -> Advanced (tab) -> Environment Variables. Double-click ‘CLASSPATH’ if it is already listed there or click ‘New’ to create one with the name of ‘CLASSPATH’. If you already had a ‘CLASSPATH environment variable listed, simply type in (or paste) the complete path including file name in the window that opens up *at the end of* existing CLASSPATH values. If you are creating a new ‘CLASSPATH’ environment variable then simple enter ‘.;’ and then append the complete path to Connector/J’s JAR file.

Then run the following program to check the connection.

import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;
public class JdbcExample2 {
public static void main(String args[]) {    Connection con = null;
try {      Class.forName(“com.mysql.jdbc.Driver”).newInstance();      con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/test”,        ”root”, “root”);
if(!con.isClosed())        System.out.println(“Successfully connected to ” +          ”MySQL server using TCP/IP…”);
} catch(Exception e) {      System.err.println(“Exception: ” + e.getMessage());    } finally {      try {        if(con != null)          con.close();      } catch(SQLException e) {}    }  }}

Window – Environment Variables

Window – Edit System Variable

If you’ve correctly added the path to Connector/J JDBC driver’s JAR file in your CLASSPATH environment variable then you are done with installing MySQL Connector/J JDBC driver.

Download and install the binary distribution for windows. After sucessfull installation of tomcat server, edit the file tomcat-users.xml in installed_directory/conf directory. Add the following lines.

<user username=”root” password=”root” roles=”admin-gui”/>

<user username=”root” password=”root” roles=”manager-gui”/>

The username and passoword are arbitary. You can change these to suit you.

Start the server. Open your browser. Type in http://localhost:8080 .

10. Accessing non-static member variables from static methods (such as main)

Many programmers, particularly when first introduced to Java, have problems with accessing member variables from their main method. The method signature for main is marked static – meaning that we don’t need to create an instance of the class to invoke the main method. For example, a Java Virtual Machine (JVM) could call the class MyApplication like this :-

MyApplication.main ( command_line_args );

This means, however, that there isn’t an instance of MyApplication – it doesn’t have any member variables to access! Take for example the following application, which will generate a compiler error message.

public class StaticDemo
{
        public String my_member_variable = "somedata";
        public static void main (String args[])
        {
		// Access a non-static member from static method
                System.out.println ("This generates a compiler error" +
			my_member_variable );
        }
}

If you want to access its member variables from a non-static method (like main), you must create an instance of the object. Here’s a simple example of how to correctly write code to access non-static member variables, by first creating an instance of the object.

public class NonStaticDemo
{
        public String my_member_variable = "somedata";

        public static void main (String args[])
        {
                NonStaticDemo demo = new NonStaticDemo();

		// Access member variable of demo
                System.out.println ("This WON'T generate an error" +
                        demo.my_member_variable );
        }
}

9. Mistyping the name of a method when overriding

Overriding allows programmers to replace a method’s implementation with new code. Overriding is a handy feature, and most OO programmers make heavy use of it. If you use the AWT 1.1 event handling model, you’ll often override listener implementations to provide custom functionality. One easy trap to fall into with overriding, is to mistype the method name. If you mistype the name, you’re no longer overriding a method – you’re creating an entirely new method, but with the same parameter and return type.

public class MyWindowListener extends WindowAdapter {
	// This should be WindowClosed
	public void WindowClose(WindowEvent e) {
		// Exit when user closes window
		System.exit(0);
	}
});

Compilers won’t pick up on this one, and the problem can be quite frustrating to detect. In the past, I’ve looked at a method, believed that it was being called, and taken ages to spot the problem. The symptom of this error will be that your code isn’t being called, or you think the method has skipped over its code. The only way to ever be certain is to add a println statement, to record a message in a log file, or to use good trace debugger (like Visual J++ or Borland JBuilder) and step through line by line. If your method still isn’t being called, then it’s likely you’ve mistyped the name.

8. Comparison assignment (  = rather than == )

This is an easy error to make. If you’re used other languages before, such as Pascal, you’ll realize just how poor a choice this was by the language’s designers. In Pascal, for example, we use the := operator for assignment, and leave = for comparison. This looks like a throwback to C/C++, from which Java draws its roots.

Fortunately, even if you don’t spot this one by looking at code on the screen, your compiler will. Most commonly, it will report an error message like this : “Can’t convert xxx to boolean”, where xxx is a Java type that you’re assigning instead of comparing.

7. Comparing two objects ( == instead of .equals)

When we use the == operator, we are actually comparing two object references, to see if they point to the same object. We cannot compare, for example, two strings for equality, using the == operator. We must instead use the .equals method, which is a method inherited by all classes from java.lang.Object.

Here’s the correct way to compare two strings.

String abc = "abc"; String def = "def";

// Bad way
if ( (abc + def) == "abcdef" )
{
    ......
}
// Good way
if ( (abc + def).equals("abcdef") )
{
   .....
}

6. Confusion over passing by value, and passing by reference

This can be a frustrating problem to diagnose, because when you look at the code, you might be sure that its passing by reference, but find that its actually being passed by value. Java usesboth, so you need to understand when you’re passing by value, and when you’re passing by reference.

When you pass a primitive data type, such as a char, int, float, or double, to a function then you are passing by value. That means that a copy of the data type is duplicated, and passed to the function. If the function chooses to modify that value, it will be modifying the copy only. Once the function finishes, and control is returned to the returning function, the “real” variable will be untouched, and no changes will have been saved. If you need to modify a primitive data type, make it a return value for a function, or wrap it inside an object.

When you pass a Java object, such as an array, a vector, or a string, to a function then you arepassing by reference. Yes – a String is actually an object, not a primitive data type.  So that means that if you pass an object to a function, you are passing a reference to it, not a duplicate. Any changes you make to the object’s member variables will be permanent – which can be either good or bad, depending on whether this was what you intended.

On a side note, since String contains no methods to modify its contents, you might as well be passing by value.

5. Writing blank exception handlers

I know it’s very tempting to write blank exception handlers, and to just ignore errors. But if you run into problems, and haven’t written any error messages, it becomes almost impossible to find out the cause of the error. Even the simplest exception handler can be of benefit. For example, put a try { .. } catch Exception around your code, to catch ANY type of exception, and print out the message. You don’t need to write a custom handler for every exception (though this is still good programming practice). Don’t ever leave it blank, or you won’t know what’s happening.

For example

public static void main(String args[])
{
    try {
	// Your code goes here..
    }
    catch (Exception e)
    {
	System.out.println ("Err - " + e );
    }
}

4. Forgetting that Java is zero-indexed

If you’ve come from a C/C++ background, you may not find this quite as much a problem as those who have used other languages. In Java, arrays are zero-indexed, meaning that the first element’s index is actually 0. Confused? Let’s look at a quick example.

// Create an array of three strings
String[] strArray = new String[3];

// First element's index is actually 0
strArray[0] = "First string";

// Second element's index is actually 1
strArray[1] = "Second string";

// Final element's index is actually 2
strArray[2] = "Third and final string";

In this example, we have an array of three strings, but to access elements of the array we actually subtract one. Now, if we were to try and access strArray[3], we’d be accessing the fourth element. This will case an ArrayOutOfBoundsException to be thrown – the most obvious sign of forgetting the zero-indexing rule.

Other areas where zero-indexing can get you into trouble is with strings. Suppose you wanted to get a character at a particular offset within a string. Using the String.charAt(int) function you can look this information up – but under Java, the String class is also zero-indexed. That means than the first character is at offset 0, and second at offset 1. You can run into some very frustrating problems unless you are aware of this – particularly if you write applications with heavy string processing. You can be working on the wrong character, and also throw exceptions at run-time. Just like the ArrayOutOfBoundsException, there is a string equivalent. Accessing beyond the bounds of a String will cause a StringIndexOutOfBoundsException to be thrown, as demonstrated by this example.

public class StrDemo
{
 public static void main (String args[])
 {
        String abc = "abc";

        System.out.println ("Char at offset 0 : " + abc.charAt(0) );
        System.out.println ("Char at offset 1 : " + abc.charAt(1) );
        System.out.println ("Char at offset 2 : " + abc.charAt(2) );

	// This line should throw a StringIndexOutOfBoundsException
        System.out.println ("Char at offset 3 : " + abc.charAt(3) );
 }
}

Note too, that zero-indexing doesn’t just apply to arrays, or to Strings. Other parts of Java are also indexed, but not always consistently. The java.util.Date, and java.util.Calendar classes start their months with 0, but days start normally with 1. This problem is demonstrated by the following application.

import java.util.Date;
import java.util.Calendar;

public class ZeroIndexedDate
{
        public static void main (String args[])
        {
                // Get today's date
                Date today = new Date();

		// Print return value of getMonth
		System.out.println ("Date.getMonth() returns : " +
			 today.getMonth());

		// Get today's date using a Calendar
		Calendar rightNow = Calendar.getInstance();

		// Print return value of get ( Calendar.MONTH )
		System.out.println ("Calendar.get (month) returns : " +
			rightNow.get ( Calendar.MONTH ));
        }
}

Zero-indexing is only a problem if you don’t realize that its occurring. If you think you’re running into a problem, always consult your API documentation.

3. Preventing concurrent access to shared variables by threads

When writing multi-threaded applications, many programmers (myself included) often cut corners, and leave their applications and applets vulnerable to thread conflicts. When two or more threads access the same data concurrently, there exists the possibility (and Murphy’s law holding, the probability) that two threads will access or modify the same data at the same time. Don’t be fooled into thinking that such problems won’t occur on single-threaded processors. While accessing some data (performing a read), your thread may be suspended, and another thread scheduled. It writes its data, which is then overwritten when the first thread makes its changes.

Such problems are not just limited to multi-threaded applications or applets. If you write Java APIs, or JavaBeans, then your code may not be thread-safe. Even if you never write a single application that uses threads, people that use your code WILL. For the sanity of others, if not yourself, you should always take precautions to prevent concurrent access to shared data.

How can this problem be solved? The simplest method is to make your variables private (but you do that already,  right?) and to use synchronized accessor methods. Accessor methods allow access to private member variables, but in a controlled manner. Take the following accessor methods, which provide a safe way to change the value of a counter.

public class MyCounter
{
	private int count = 0; // count starts at zero

	public synchronized void setCount(int amount)
	{
		count = amount;
	}

	public synchronized int getCount()
	{
		return count;
	}
}

2. Capitalization errors

This is one of the most frequent errors that we all make. It’s so simple to do, and sometimes one can look at an uncapitalized variable or method and still not spot the problem. I myself have often been puzzled by these errors, because I recognize that the method or variable does exist, but don’t spot the lack of capitalization.

While there’s no silver bullet for detecting this error, you can easily train yourself to make less of them. There’s a very simple trick you can learn :-

• all methods and member variables in the Java API begin with lowercase letters
• all methods and member variables use capitalization where a new word begins e.g – getDoubleValue()

If you use this pattern for all of your member variables and classes, and then make a conscious effort to get it right, you can gradually reduce the number of mistakes you’ll make. It may take a while, but it can save some serious head scratching in the future.

(drum roll)

And the number one error that Java programmers make !!!!!

1. Null pointers!

Null pointers are one of the most common errors that Java programmers make. Compilers can’t check this one for you – it will only surface at runtime, and if you don’t discover it, your users certainly will.

When an attempt to access an object is made, and the reference to that object is null, a NullPointerException will be thrown. The cause of null pointers can be varied, but generally it means that either you haven’t initialized an object, or you haven’t checked the return value of a function.

Many functions return null to indicate an error condition – but unless you check your return values, you’ll never know what’s happening. Since the cause is an error condition, normal testing may not pick it up – which means that your users will end up discovering the problem for you. If the API function indicates that null may be returned, be sure to check this before using the object reference!

Another cause is where your initialization has been sloppy, or where it is conditional. For example, examine the following code, and see if you can spot the problem.

public static void main(String args[])
{
	// Accept up to 3 parameters
	String[] list = new String[3];

	int index = 0;

	while ( (index < args.length) && ( index < 3 ) )
	{
		list[index++] = args[index];
	}

	// Check all the parameters
	for (int i = 0; i < list.length; i++)
	{
		if (list[i].equals "-help")
		{
			// .........
		}
		else
		if (list[i].equals "-cp")
		{
			// .........
		}
		// else .....
	}
}

This code (while a contrived example), shows a common mistake. Under some circumstances, where the user enters three or more parameters, the code will run fine. If no parameters are entered, you’ll get a NullPointerException at runtime. Sometimes your variables (the array of strings) will be initialized, and other times they won’t. One easy solution is to check BEFORE you attempt to access a variable in an array that it is not equal to null.

Summary

These errors represent but some of the many that we all make. Though it is impossible to completely eliminate errors from the coding process, with care and practice you can avoid repeating the same ones. Rest assured, however, that all Java programmers encounter the same sorts of problems. It’s comforting to know, that while you work late into the night tracking down an error, someone, somewhere, sometime, will make the same mistake!

Java Certification

There are many myths about sun certification to various java courses. Here is  full details about sun certification.

- Sun Certified Java Associate (SCJA)
- Sun Certified Java Programmer (SCJP)
- Sun Certified Java Developer (SCJD)
- Sun Certified Web Component Developer (SCWCD)
- Sun Certified Business Component Developer (SCBCD)
- Sun Certified Developer For Java Web Services (SCDJWS)
- Sun Certified Mobile Application Developer (SCMAD)
- Sun Certified Enterprise Architect (SCEA)

Sun Certified Java Associate (SCJA)

This certification provides an ideal entry into an application development or a software project management career using Java technologies. It validates basic knowledge of OO concepts, the Java programming language and general knowledge of Java platforms and technologies.

To achieve this certification, candidates must successfully complete one exam.

Sun Certified Java Programmer (SCJP)

This foundation certification is for programmers interested in demonstrating proficiency in the fundamentals of the Java programming language.

To achieve this certification, candidates must successfully complete one exam. It is not necessary to be a Sun Certified Java Associate prior to taking this exam.

Sun Certified Web Component Developer (SCWCD)

This certification is for developers specializing in the application of JavaServer Pages and servlet technologies used to present Web services and dynamic Web content.

To achieve this certification, candidates must successfully complete one exam. Prior to attempting certification, candidates must be certified as a Sun Certified Programmer (SCJP), any edition.

Sun Certified Business Component Developer (SCBCD)

This certification is for Enterprise JavaBeans (EJB) technology business component developers who are responsible for designing, developing, testing, deploying and integrating EJB applications.

To achieve certifications, candidates must successfully complete one exam. Prior to attempting certification, candidates must be certified as a Sun Certified Programmer (SCJP), any edition.

Sun Certified Developer For Java Web Services (SCDJWS)

This certification is for developers who create Web service for applications using Java technology components.

To achieve this certification, candidates must complete one exam. Prior to attempting certification, candidates must be certified as a Sun Certified Programmer (SCJP), any edition.

Sun Certified Mobile Application Developer (SCMAD)

This certification is for developers who create mobile applications using Java technologies for cell phones or “smart” devices.

To achieve this certification, candidates must succesfully complete one exam. Prior to attempting certification, candidates must be certified as a Sun Certified Programmer (SCJP), any edition.

Sun Certified Enterprise Architect (SCEA)

“The act of getting certified will make you a better architect.” (Humphrey Sheil, CTO, SCEA, and SCEA examiner)

This certification is for enterprise architects responsible for architecting and designing Java EE compliant applications with an emphasis on making the best use of Java EE features to create flexible, scalable, secure designs.

The SCEA certification “signifies that its holders can handle advanced design responsibilities and lead roles in creating applications. To succeed, SCEA candidates must demonstrate a deep understanding of appropriate uses of modern design architecture and current Java EE technologies for business applications.” (Ed Tittel and Dr. Bill Brogden)

The Process

To achieve this certification, candidates must successfully complete three elements: a knowledge-based multiple choice exam, an assignment and essay exam.

So path is set according to the .exe files & .bat files And classpath is set according to the .jar files & .class files.

Operating system tries to find .exe and .bat files in path and JVM tries to find all classes in classpath.

DELETE * FROM table_name
(Note: Deletes the entire table!!) DROP DATABASE DROP DATABASE database_name DROP INDEX DROP INDEX table_name.index_name (SQL Server)
DROP INDEX index_name ON table_name (MS Access)
DROP INDEX index_name (DB2/Oracle)
ALTER TABLE table_name
DROP INDEX index_name (MySQL) DROP TABLE DROP TABLE table_name GROUP BY SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name HAVING SELECT column_name, aggregate_function(column_name)
FROM table_name
WHERE column_name operator value
GROUP BY column_name
HAVING aggregate_function(column_name) operator value IN SELECT column_name(s)
FROM table_name
WHERE column_name
IN (value1,value2,..) INSERT INTO INSERT INTO table_name
VALUES (value1, value2, value3,….)orINSERT INTO table_name
(column1, column2, column3,…)
VALUES (value1, value2, value3,….) INNER JOIN SELECT column_name(s)
FROM table_name1
INNER JOIN table_name2
ON table_name1.column_name=table_name2.column_name LEFT JOIN SELECT column_name(s)
FROM table_name1
LEFT JOIN table_name2
ON table_name1.column_name=table_name2.column_name RIGHT JOIN SELECT column_name(s)
FROM table_name1
RIGHT JOIN table_name2
ON table_name1.column_name=table_name2.column_name FULL JOIN SELECT column_name(s)
FROM table_name1
FULL JOIN table_name2
ON table_name1.column_name=table_name2.column_name LIKE SELECT column_name(s)
FROM table_name
WHERE column_name LIKE pattern ORDER BY SELECT column_name(s)
FROM table_name
ORDER BY column_name [ASC|DESC] SELECT SELECT column_name(s)
FROM table_name SELECT * SELECT *
FROM table_name SELECT DISTINCT SELECT DISTINCT column_name(s)
FROM table_name SELECT INTO SELECT *
INTO new_table_name [IN externaldatabase]
FROM old_table_nameorSELECT column_name(s)
INTO new_table_name [IN externaldatabase]
FROM old_table_name SELECT TOP SELECT TOP number|percent column_name(s)
FROM table_name TRUNCATE TABLE TRUNCATE TABLE table_name UNION SELECT column_name(s) FROM table_name1
UNION
SELECT column_name(s) FROM table_name2 UNION ALL SELECT column_name(s) FROM table_name1
UNION ALL
SELECT column_name(s) FROM table_name2 UPDATE UPDATE table_name
SET column1=value, column2=value,…
WHERE some_column=some_value WHERE SELECT column_name(s)
FROM table_name
WHERE column_name operator value
]]> http://javarocks.wordpress.com/2009/08/18/sql-quick-reference/feed/ 0 ashokmohan http://javarocks.wordpress.com/2009/08/18/using-prepared-statements/ http://javarocks.wordpress.com/2009/08/18/using-prepared-statements/#comments Tue, 18 Aug 2009 16:53:48 +0000 ashokmohan http://javarocks.wordpress.com/?p=24 ]]> To prevent SQL Injection Hacking with JDBC, you simply just need to use Prepared Statements, this is pretty easy to, just use a PreparedStatement object instead of a Statement Object, in your SQL replace your variables with ?‘s, and use the setString, setInt, etc methods on the perpared statement object.

Description of program:

In this program we are going to insert data in the database by using the setObject method of PreparedStatement interface. Before going into the details of the program we should firstly need to establish the connection with MySQL database by the help of JDBC driver. After establishing the connection now we will  insert the data in setObject method. If the data gets added in the database table then it will display a message “Record is added in the table.” otherwise it will show “SQL statement is not executed!“.

Description of code:

prepareStatement(String sql):
This method returns the PreparedStatement object for sending the parameterized SQL statement to the database that contains the pre-compiled SQL statement. Here the pre- compiled means once the statement has been compiled then it will not compile the same thing again. It takes the string type arguments which contains one or more ‘?‘ parameter placeholders.

setObject(int par_index, object obj):
It is used for setting the values of parameterized index by using the given object in this method. It takes two arguments to given below:
par_index: It specifies the parameter like: the first is 1, second is 2, ……
object obj: It contains the parameter values to given by the users.

Here is the code of program:

import java.sql.*;

public class PreparedStatementSetObject{
public static void main(String[] args) {
System.out.println(“Prepared Statement Set Array Example!”);
Connection con = null;
try{
Class.forName(“com.mysql.jdbc.Driver”);
con = DriverManager.getConnection
(“jdbc:mysql://localhost:3306/jdbctutorial”,“root”,“root”);
try{
PreparedStatement prest = con.prepareStatement(“insert into emp_sal values(?,?)”);
prest.setObject(1,“Sushil”);
prest.setObject(2,15000);
int n = prest.executeUpdate();
System.out.println(n + “ Record is added in the table.”);
con.close();
}
catch (SQLException s){
System.out.println(“SQL statement is not executed!”);
}
}
catch (Exception e){
e.printStackTrace();
}
}
}