Programming|Tutorials|Interview Questions

Session Management

2012-09-23T00:00:00.002-07:00

What is a session?

A session is pretty much what it sounds, when a user makes a page request to the server, the server creates a temporary session to identify that user. So when that same user goes to another page on that site, the server identifies that user. So a session is a small and temporary unique connection between a server and the user enabling it to identify that user across multiple page requests or visits to that site.

Why should a session be maintained?

When there is a series of continuous request and response from a same client to a server, the server cannot identify from which client it is getting requests. Because HTTP is a stateless protocol.

When there is a need to maintain the conversational state, session tracking is needed. For example, in a shopping cart application a client keeps on adding items into his cart using multiple requests. When every request is made, the server should identify in which client’s cart the item is to be added. So in this scenario, there is a certain need for session tracking.

Solution is, when a client makes a request it should introduce itself by providing unique identifier every time. There are five different methods to achieve this.

Session tracking methods:

1. User authorization

2. Hidden fields

3. URL rewriting

4. Cookies

5. Session tracking API

The first four methods are traditionally used for session tracking in all the server-side technologies. The session tracking API method is provided by the underlying technology (java servlet or PHP or likewise). Session tracking API is built on top of the first four methods.

1. User Authorization

Users can be authorized to use the web application in different ways. Basic concept is that the user will provide username and password to login to the application. Based on that the user can be identified and the session can be maintained.

2. Hidden Fields

<INPUT TYPE=”hidden” NAME=”technology” VALUE=”servlet”>
Hidden fields like the above can be inserted in the webpages and information can be sent to the server for session tracking. These fields are not visible directly to the user, but can be viewed using view source option from the browsers. This type doesn’t need any special configuration from the browser of server and by default available to use for session tracking. This cannot be used for session tracking when the conversation included static resources lik html pages.

3. URL Rewriting:
When a request is made, additional parameter is appended with the url. In general added additional parameter will be sessionid or sometimes the userid. It will suffice to track the session. This type of session tracking doesn’t need any special support from the browser.

Original URL: http://server:port/servlet/ServletName
Rewritten URL: http://server:port/servlet/ServletName?sessionid=7456

Disadvantage is, implementing this type of session tracking is tedious. We need to keep track of the parameter as a chain link until the conversation completes and also should make sure that, the parameter doesn’t clash with other application parameters.

4. Cookies

Cookies are the mostly used technology for session tracking. Cookie is a key value pair of information, sent by the server to the browser. This should be saved by the browser in its space in the client computer. Whenever the browser sends a request to that server it sends the cookie along with it. Then the server can identify the client using the cookie.
In java, following is the source code snippet to create a cookie:

Cookie cookie = new Cookie(“userID”, “7456″);
res.addCookie(cookie);

Session tracking is easy to implement and maintain using the cookies. Disadvantage is that, the users can opt to disable cookies using their browser preferences. In such case, the browser will not save the cookie at client computer and session tracking fails.

5. Session tracking API

Session tracking API is built on top of the first four methods. This is inorder to help the developer to minimize the overhead of session tracking. This type of session tracking is provided by the underlying technology. Lets take the java servlet example. Then, the servlet container manages the session tracking task and the user need not do it explicitly using the java servlets. This is the best of all methods, because all the management and errors related to session tracking will be taken care of by the container itself.

Every client of the server will be mapped with a javax.servlet.http.HttpSession object. Java servlets can use the session object to store and retrieve java objects across the session. Session tracking is at the best when it is implemented using session tracking api.

Methods of HttpSession Interface:

getAttribute(), getAttributeNames(), setAttribute(), removeAttribute(): These methods are used to set, get and remove objects from a user session. We will see later how to use them.
getId() : Every session created by the server has a unique 'id' associated with it in order to identify this session from other sessions. This method returns the 'id' of this session.
getCreationTime(): Simple returns a long value indicating the date and time this session was created, meaning there by that you get the time this user first accessed your site.
getLastAccessedTime(): Returns a long value indicating the last time user accessed any resource on this server.
getMaxInactiveInterval(), setMaxInactiveInterval(): Return and set the maximum inactive interval in seconds for this session respectively. Note that every session has a maximum inactive interval during which if user doesn't make request to the server, his session is invalidated.
isNew(): Returns a boolean value indicating if the session is new. It means that either it is the first page of the site user has hit so his session is new and has just been created or that user is not accepting cookies required for managing sessions so this value will then always return true.
invalidate() : Simply invalidates a session. You can use this method on a 'logout' page allowing user to end his session. If after invalidation of his session user accesses some resource on the site then a new session will be created for it. You must have seen this 'logout' feature which ends your session on some of the free email sites on the web, so you understand how useful this method is.

SERVLET FILTERS

2012-09-22T23:41:00.000-07:00

Filters are powerful tools in servlet environment.It process request before it reaches a servlet and can process response before it leaves to a servlet.

You can map filters to a URL or a servlet name. When a filter is mapped to a URL (path-mapped), the filter applies to every servlet and JSP in the Web application. When a filter is mapped to a servlet name (servlet-mapped), it applies to a single servlet or JSP.

Filters may be used for large number of tasks like compressing response, modifying request and response headers, logging, change the content type, authenticating the user etc. For eg: suppose you want to check whether the user is already logged in or not. If you are using JSP, you have to write the authentication check in another JSP and include it in all JSP pages. Rather than including it in all pages, you may create an authentication filter class and attach it to all JSP pages.

Filters are configured in the deployment descriptor(web.xml) of a web application so that your JSP or Servlet will remain much clean containing code for specific purposes.

There are three interfaces defined in javax.servlet package.

FilterConfig – This object acts as configuration object for filter which pass information to filter during initialization. For eg, you may set initialization parameters in web.xml file for filter which could be accessed from this object. It also allow us to get a reference to ServletContext object. Every servlet container has its own implementation of FilterConfig interface.
FilterChain – This object is again created by servlet container which provides a convenient method to invoke next filter in the chain or final resource. The method is doFilter (ServletRequest request, ServletResponse response). Suppose one servlet is attached with two filters. In first filter calling doFilter() method of FilterChain object invokes second filter and calling the method in second filter invokes servlet itself.
Filter – This is the filter object which actually performs filtering tasks. For creating Filter you have to declare a class which implements this interface.

Servlet filters must implement the javax.servlet.Filter interface and define these methods:

Method Summary
void	destroy() Called by the web container to indicate to a filter that it is being taken out of service.
void	doFilter(ServletRequest request, ServletResponse response, FilterChain chain) The doFilter method of the Filter is called by the container each time a request/response pair is passed through the chain due to a client request for a resource at the end of the chain.
void	init(FilterConfig filterConfig) Called by the web container to indicate to a filter that it is being placed into service.

In doFilter() method, the following steps are executed.

When a client makes HTTP request to a resource, the servlet container checks whether it is associated with filter.
If yes, the filter’s doFilter method is called.
Inside doFilter() method we may intercept request object and may modify the same. After that we call doFilter() method of FilterChain object. Here it invokes next filter in chain. If no more filters are available, final resource (Servlet, JSP etc) is called.
The resource like Servlet or JSP process the request and send response back to client. This again is passed through doFilter method of filter object. All statements written after doFilter() method of chain object is executed again.
Finally the response is sent back to client

The skeleton of doFilter() method is given below.:

public void doFilter (ServletRequest request, ServletResponse response, FilterChain chain)

throws IOException, ServletException{

//preprocess statements for request/response objects

..................................................................

//call doFilter() of chain object, invoke next filter or resource

chain.doFilter (request, response);

//post-processing of request/response objects

..................................................................

}

ServletConfig and ServletContext

2012-09-22T22:43:00.002-07:00

Both ServletConfig and ServletContext are configuration objects used by servlet container to initialize various init parameters for a web application. However they differ in terms of the scope and availability of init parameters defined by both of them

ServletConfig

The parameter scope is limited to the scope of the servlet in which the parameter is defined. For example, shopping cart of a user is specific to a particular user so servletconfig params can be used.

One ServletConfig per servlet
It is used to pass deploy-time info to servlet and configured in the deployment descriptor file.
It is used to access ServletContext
It is within the Servlet element in Deployment descriptor.
It is accessed by using getServletConfig().getInitParameter("myname");
It is available only to the servlet in which init-param is configured.

<servlet>

<display-name>InitParamTest</display-name>

<servlet-name>InitParamTest</servlet-name>

<servlet-class> test.InitParamTest</servlet-class>

<init-param>

<description>test parameter</description>

<param-name>myname</param-name>

<param-value>DummyValue</param-value>

</init-param>

</servlet>

ServletContext :

The parameter scope is application wide and the parameter can be use to store application session info/ application initialization parameters,etc not specific to a servlet.

It returns the current context of a web application running in a particular JVM.
If the web application is distributed,it is one per JVM.
It is used to access the <context-param> elements configured in deployment descriptor.
It is accessed by using getServletContext().getInitParameter("myname");
It is available to any servlet or jsp that is part of web application.

<context-param>

<param-name>myname</param-name>

<param-value>DummyValue</param-value>

</context-param>

JDBC PROGRAMS

2012-09-20T20:45:00.002-07:00

INDEX

JDBC Connecting to Oracle 11g Database

JAVA SERVLET PROGRAMS

2012-09-20T07:48:00.002-07:00

1)Configuring Tomcat7 with Eclipse Juno

Configuring Tomcat 7 with Eclipse Juno

2012-09-20T07:32:00.000-07:00

1)First download the latest Eclipse IDE for Java EE Developers and Tomcat 7

Note:You just need to extract both Eclipse and Apache Tomcat

2)Start Eclipse! The first thing that Eclipse will do is ask you to create a new Workspace.

Select a Folder which you want to be your workspace.All your project will be created here

3)Make sure you are in Java EE perspective :Go to Window->Open Perspective->Java EE

4)Add Server:In“Servers” area, right click -> New -> Server.

5)Here you will see list of servers that can be configured in the installed Eclipse IDE version. You will find Tomcat v7.0 Server under “Apache” folder as shown below.

Select “Tomcat v7.0 Server” and click Next.

6)Configuring Apache Tomcat installation location

7)Select the Tomcat Root folder which has bin folder and click Next.

There are no resources to be configured and hence click Finish.

8)The configured Apache Tomcat Server will be displayed in the “Servers” view.

Start Server:It is easy to manage the server instance. Right-click on the server and start and stop it to ensure its proper working.

9)Test your installation

After starting the Tomcat, open browser and type http://localhost:8080. You should see the Apache Tomcat home page as shown below.

Servlet Lifecycle

2012-09-20T04:08:00.001-07:00

Servlet Life Cycle

The life cycle of the servlet is controlled by the Servlet container.

Basically there are three methods in servlet lyfe cycle which servlet calls

1. init()- This method is called to initialize a servlet. In servlet 2.4 specification if you do not call init() method in your servlet program then the container call it implicitly.

2. service()- This method is called to execute the business logic written in servlet. This is the method which you must have to override, when you are writing a servlet.

3. destroy()- This method is called to finalize the servlet.

Note- The servlet call init() and destroy() method only once called during its life cycle.

During initialization stage of the Servlet life cycle, the web container initializes the Servlet instance by calling the init() method, passing an object implementing the ServletConfig interface. This configuration object allows the Servlet to access name-valueinitialization parameters from the web application.
After initialization, the Servlet can service client requests. Each request is serviced in its own separate thread. The web container calls the service() method of the Servlet for every request. The service() method determines the kind of request being made and dispatches it to an appropriate method to handle the request. The developer of the Servlet must provide an implementation for these methods. If a request for a method that is not implemented by the Servlet is made, the method of the parent class is called, typically resulting in an error being returned to the requester.
Finally, the web container calls the destroy() method that takes the Servlet out of service. The destroy() method, likeinit(), is called only once in the lifecycle of a Servlet.

Therefore, three methods are central to the life cycle of a Servlet. These are init(), service(), and destroy(). They are implemented by every Servlet and are invoked at specific times by the server.

The following is a typical user scenario of these methods.

1. Assume that a user enters a URL to a web browser.

§ The browser then generates an HTTP request for this URL.

§ This request is then sent to the appropriate server.

2. The HTTP request is received by the web server and forwarded to the Servlet container.

§ The Servlet container maps this request to a particular Servlet.

§ The Servlet is dynamically retrieved and loaded into the address space of the Servlet container.

3. The Servlet container invokes the init() method of the Servlet.

§ This method is invoked only when the Servlet is first loaded into memory.

§ It is possible to pass initialization parameters to the Servlet so it may configure itself.

4. The Servlet container invokes the service() method of the Servlet.

§ This method is called to process the HTTP request.

§ You will see that it is possible for the Servlet to read data that has been provided in the HTTP request.

§ It may also formulate an HTTP response for the client.

5. The Servlet remains in the Servlet container’s address space and is available to process any other HTTP requests received from clients.

§ The service() method is called for each HTTP request.

6. The Servlet container may, at some point, decide to unload the Servlet from its memory.

§ The algorithms by which this decision is made are specific to each Servlet container.

7. The Servlet container calls the Servlet's destroy() method to relinquish any resources such as file handles that are allocated for the Servlet; important data may be saved to a persistent store.

8. The memory allocated for the Servlet and its objects can then be garbage collected.

Servlet Types

2012-09-20T04:08:00.000-07:00

There are mainly two types of servlets -

Generic Servlet - Generic servlet is protocol independent servlet. It implements the Servlet and ServletConfig interface. It may be directly extended by the servlet. Writing a servlet in in GenericServlet is very easy. It has only init() and destroy() method of ServletConfig interface in its life cycle. It also implements the log method of ServletContext interface.
Http Servlet - HttpServlet is HTTP (Hyper Text Transfer Protocol ) specific servlet. It provides an abstract class HttpServlet for the developers for extend to create there own HTTP specific servlets. The sub class of HttpServlet must overwrite at least one method given below- doGet(),doPost(),doTrace(),doDelete(),init(),destroy(),getServiceInfo().

There is no need to overrride service() method. All the servlet either Generic Servlet or Http Servlet passes there config parameter to the Servlet interface.

Servlet Heirarchy

The Deployment Descriptor: web.xml

2012-09-20T04:07:00.004-07:00

Before I explain what a deployment descriptor is, we should first understand the web application directory structure

WEB APPLICATION DIRECTORY STRUCTURE:

A Web application contains a structure hierarchy of directories and files in a standard layout. Such a hierarchy can be accessed in its "unpacked" form, where each directory and file exists in the filesystem separately(This format is more useful during development), or in its "packed" WAR file(This format is used when you distribute your application to be installed). Any Web Application that is to be deployed in Tomcat has to conform to this directory structure. The format of the structure can be seen in the figure below:

Web Application Directory Structure

Application Root Directory - This is the root directory of the Web Application. The name of this directory is named by the developer - for example the default context we created for this module was called "student". All JSP, HTML and image files are stored here. Typically, there would be an index.html or index.jsp file in this directory. The "other directories" could be, for example, "images" (containing gifs and jpgs for the html pages and servlets used in the Application), "style" (containing the .css or other style files used) or simply subdirectories of HTML or JSP pages.
/WEB-INF - This directory contains all resources related to the application that are not in the document root of the application. It should be noted that the WEB-INF directory is not part of the public document (ie. paths beginning in http://localhost:8080/student/WEB-INF cannot be viewed in a browser) and no files contained in this directory can be served directly to the client. The WEB-INF directory also contains the Web Application Deployment Descriptor.
/WEB-INF/classes - contains the application Java Servlets, class files, JavaBeans and utility classes.
/WEB-INF/lib - The lib directory contains the Java ARchive (JAR) files (or ZIP) that the web application depends upon. For example, this directory might contain a JDBC Database Connectivity driver in JAR or Zip format.
/WEB-INF/web.xml - The deployment descriptor is an XML file named web.xml and forms the heart of the Web Application. This file is discussed below.

Web Application Deployment Descriptor:

A web application's deployment descriptor describes the classes, resources and configuration of the application and how the web server uses them to serve web requests. When the web server receives a request for the application, it uses the deployment descriptor to map the URL of the request to the code that ought to handle the request. This file is named web.xml, and resides in the app's WAR under the WEB-INF/ directory. web.xml is part of the servlet standard for web applications.

1. Configuring and Mapping a Servlet

2. Servlet Init Parameters

3. Servlet Load-on-Startup

4. Context Parameters

Configuring and Mapping a Servlet

To configure a servlet in the web.xml file, you write this:

<?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>

<servlet>

<servlet-name>HelloWorld</servlet-name>

<servlet-class>servletexample.createHelloWorldExample

</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>HelloWorld</servlet-name>

<url-pattern>/HelloWorldExample/*</url-pattern>

</servlet-mapping>

</web-app>

Servlet-mapping has two child tags, url-pattern and servlet-name. url-pattern specifies the type of urls for which, the servlet given in servlet-name should be called. Be aware that, the container will use case-sensitive for string comparisons for servlet matching.

Servlet Init Parameters

You can pass parameters to a servlet from the web.xml file. The init parameters of a servlet can only be accessed by that servlet. Here is how you configure them in the web.xml file:

<servlet>

<servlet-name>HelloWorld</servlet-name>

<servlet-class>servletexample.createHelloWorldExample

</servlet-class>

<init-param>

<param-name>myParam</param-name>

<param-value>paramValue</param-value>

</init-param>

</servlet>

Here is how you read the init parameters from inside your servlet - in the servlets init() method:

public class createHelloWorldExample extends GenericServlet {

protected String myParam = null;

public void init(ServletConfig servletConfig) throws ServletException{

this.myParam = servletConfig.getInitParameter("myParam");

}

public void service(ServletRequest request, ServletResponse response)

throws ServletException, IOException {

response.getWriter().write("<html><body>myParam = " +

this.myParam + "</body></html>");

}

A servlets init() method is called when the servlet container loads the servlet for the first time. No one can access the servlet until the servlet has been loaded, and the init() method has been called successfully.

Servlet Load-on-Startup

The <servlet> element has a subelement called <load-on-startup> which you can use to control when the servlet container should load the servlet. If you do not specify a <load-on-startup> element, the servlet container will typically load your servlet when the first request arrives for it.

By setting a <load-on-startup> element, you can tell the servlet container to load the servlet as soon as the servlet container starts. Remember, the servlets init() method is called when the servlet is loaded.

Here is an example <load-on-startup> configuration:

<servlet>

<servlet-name>HelloWorld</servlet-name>

<servlet-class>servletexample.createHelloWorldExample

</servlet-class>

<init-param><param-name>container.script.static</param-name>

<param-value>/WEB-INF/container.script</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

The number inside the <load-on-startup>1</load-on-startup> element tells the servlet container in what sequence the servlets should be loaded. The lower numbers are loaded first. If the value is negative, or unspecified, the servlet container can load the servlet at any time.

Context Parameters

You can also set some context parameters which can be read from all servlets in your application. Here is how you configure a context parameter:

<context-param>

<param-name>myParam</param-name>

<param-value>the value</param-value>

</context-param>

Here is how you access the parameter from inside an HttpServlet subclass:

String myContextParam

=request.getSession().getServletContext().getInitParameter("myParam");

Servlet Advantages and Disadvantages

2012-09-20T03:28:00.002-07:00

Servlet Advantage

1. Servlets provide a way to generate dynamic documents that is both easier to write and faster to run.

2. provide all the powerfull features of JAVA, such as Exception handling and garbage collection.

3. Servlet enables easy portability across Web Servers.

4. Servlet can communicate with different servlet and servers.

5. Since all web applications are stateless protocol, servlet uses its own API to maintain session

Servlet Disadvantage

1. Designing in servlet is difficult and slows down the application.

2. Writing complex business logic makes the application difficult to understand.

3. You need a Java Runtime Environment on the server to run servlets. CGI is a completely language independent protocol, so you can write CGIs in whatever languages you have available (including Java if you want to).

Advantages over CGI

The advantages of using Servlets are their fast performance and ease of use combined with more power over traditional CGI (Common Gateway Interface). Traditional CGI scripts written in Java have a number of disadvantages when it comes to performance:

When an HTTP request is made, a new process is created for each call of the CGI script. This overhead of process creation can be very system-intensive, especially when the script does relatively fast operations. Thus, process creation will take more time than CGI script execution. Java Servlets solve this, as a Servlet is not a separate process. Each request to be handled by a Servlet is handled by a separate Java thread within the web server process.
Simultaneous CGI request causes the CGI script to be copied and loaded into memory as many times as there are requests. However, with Servlets, there are the same amount of threads as requests, but there will only be one copy of the Servlet class created in memory that stays there also between requests.
Only a single instance answers all requests concurrently. This reduces memory usage and makes the management of persistent data easy.
A Servlet can be run by a Servlet container in a restrictive environment, called a sandbox. This is similar to an applet that runs in the sandbox of the web browser. This makes a restrictive use of potentially harmful Servlets possible.

SERVLET CONTAINER

2012-09-20T03:28:00.001-07:00

WEB CONTAINER
Web container (also known as a Servlet container) is the component of a web server that interacts with Java servlets. A web container is responsible for managing the lifecycle of servlets, mapping a URL to a particular servlet and ensuring that the URL requester has the correct access rights. A web container implements the web component contract of the Java EE architecture, specifying a runtime environment for web components that includes security, concurrency, lifecycle management, transaction, deployment, and other services.

A servlet container is nothing but a compiled, executable program. The main function of the container is to load, initialize and execute servlets. The servlet container is the official Reference Implementation for the Java Servlet and JavaServer Pages technologies.

A Container have the capacity of containing many servlets and can handle large number of requests. The Container and the Objects of the container both are multi-threaded. It can handle multiple requests concurrently. All the servlets are managed by servlet container.So each object must be thread safe in a container as the multiple requests are being handled by the container due to the entrance of more than one thread to an object at a time.

Note : A Servlet container may run stand alone i.e. without a web server or even on another host.

Servlet Container

The Container does the following thing-

When the request comes at first for the servlet, then it load the servlet, initialize it by calling servlet init() method.
Makes a thread of the requested servlet
Makes an instance of ServletRequest and ServletResponse of javax.servlet.*; package
Passes the ServletRequest and ServletResponse reference variables to the servlet service method
Take the ServletResponse object from the servlet and passes to the web server
And finally destroy the reference variables and destroy the servlet when the is shut down.

Servlet

2012-09-19T23:43:00.002-07:00

INTRODUCTION:

Over the last few years, Java has become the predominant language for server-side

programming. This is due in no small part to the Java Servlet API, which provides

a standard way to extend web servers to support dynamic content generation.

With the introduction of the J2EE specification for enterprise applications, servlets

have taken over as the primary interface for thin-client applications. In terms of

enterprise computing, servlets are a natural fit if you are using the Web as your

deployment platform. You can take advantage of web browsers as universally

available thin clients using the web server as middleware for running application

logic. Under this model, the user makes a request of the web server, the server

invokes a servlet designed to handle the request, the servlet fulfills the request,

and the result is returned to the user for display in the web browser.

While this sounds like every other dynamic content technology (such CGI, ISAPI,

ASP, PHP, and the like), servlets have some major advantages. For one, servlets

are persistent between invocations, which dramatically improves performance relative

to CGI-style programs. Servlets are also 100% portable across operating

systems and servers, unlike any of the alternatives. Finally, servlets have access to

all the APIs of the Java platform, so, for example, it is easy to create a servlet that

interacts with a database, using the JDBC API.

What are we going to learn in this tutorial??

1 Servlets

2 Servlet Lifecycle

3 Web Container(Servlet Container)

4 Deployment Descriptor:web.xml

5 Servlet Types

6 Servlet Context and Servlet Config

7 Session management

8 Servlet Filters

9 Database Connectivity in servlet

10 Advantage and disadvantage of servlet

11 Advantages over CGI
12)Servlet Container

Servlets:

A Servlet is a Java-based server-side web technology. As the name implies, it serves a client request and receives a response from the server. Technically speaking, a Servlet is a Java class in Java EE that conforms to the Java Servlet API, a protocol by which a Java class may respond to requests. They are not tied to a specific client–server protocol, but are most often used with the HTTP protocol. Therefore, the word "Servlet" is often used in the meaning of "HTTP Servlet". Thus, a software developer may use a servlet to add dynamic content to a web server using the Java platform. The generated content is commonly HTML, but may be other data such as XML. Servlets are the Java counterpart to non-Java dynamic Web content technologies such as PHP and ASP.NET. Servlets can maintain state in session variables across many server transactions by using HTTP cookies, or URL rewriting.

To deploy and run a Servlet, a web container must be used. A web container (also known as a Servlet container) is essentially the component of a web server that interacts with the Servlets. The web container is responsible for managing the lifecycle of Servlets, mapping a URL to a particular Servlet and ensuring that the URL requester has the correct access rights.

The Servlet API, contained in the Java package hierarchy javax.servlet, defines the expected interactions of the web container and a servlet.

JDBC INTERVIEW QUESTIONS

2012-09-19T09:59:00.000-07:00

1)What is the JDBC?

Java Database Connectivity (JDBC) is a standard Java API to interact with relational databases form Java.The JDBC driver gives out the connection to the database and implements the protocol for transferring the query and result between client and database.

2)Explain Basic Steps in writing a Java program using JDBC?

JDBC makes the interaction with RDBMS simple and intuitive. When a Java application needs to access database :

Load the RDBMS specific JDBC driver because this driver actually communicates with the database (Incase of JDBC 4.0 this is automatically loaded).
Open the connection to database which is then used to send SQL statements and get results back.
Create JDBC Statement object. This object contains SQL query.
Execute statement which returns resultset(s). ResultSet contains the tuples of database table as a result of SQL query.
Process the result set.
Close the connection.

For detailed Answer refer JDBC Tutorials--->here

3)What are the main components of JDBC ?

The life cycle of a servlet consists of the following phases:

DriverManager: Manages a list of database drivers. Matches connection requests from the java application with the proper database driver using communication subprotocol. The first driver that recognizes a certain subprotocol under JDBC will be used to establish a database Connection.

Driver: The database communications link, handling all communication with the database. Normally, once the driver is loaded, the developer need not call it explicitly.

Connection : Interface with all methods for contacting a database.The connection object represents communication context, i.e., all communication with database is through connection object only.

Statement : Encapsulates an SQL statement which is passed to the database to be parsed, compiled, planned and executed.

ResultSet: The ResultSet represents set of rows retrieved due to query execution.

4)How many types of JDBC Drivers are present and what are they?

JDBC drivers are divided into four types or levels. The different types of jdbc drivers are:

Type 1: JDBC-ODBC Bridge driver (Bridge)

Type 2: Native-API/partly Java driver (Native)

Type 3: All Java/Net-protocol driver (Middleware)

Type 4: All Java/Native-protocol driver (Pure)

For detailed Answer refer JDBC Tutorials--->here

5)What Class.forName will do while loading drivers?

It is used to create an instance of a driver and register it with the Driver Manager. When you have loaded a driver, it is available for making a connection with a DBMS.

6)What are the different types of statements in JDBC?

The JDBC API has 3 Statements:

1. Statement, 2. PreparedStatement, 3. CallableStatement.

The key features of these are as follows:

Statement

1. This interface is used for executing a static SQL statement and returning the results it produces.

2. The object of Statement class can be created using Connection.createStatement() method.

PreparedStatement

1. A SQL statement is pre-compiled and stored in a PreparedStatement object.

2. This object can then be used to efficiently execute this statement multiple times.

3. The object of PreparedStatement class can be created using Connection.prepareStatement() method. This extends Statement interface.

CallableStatement

1. This interface is used to execute SQL stored procedures.

2. This extends PreparedStatement interface.

3. The object of CallableStatement class can be created using Connection.prepareCall() method.

For detailed Answer refer JDBC Tutorials--->here

7)What does setAutoCommit do?

When a connection is created, it is in auto-commit mode. This means that each individual SQL statement is treated as a transaction and will be automatically committed right after it is executed. The way to allow two or more statements to be grouped into a transaction is to disable auto-commit mode:

con.setAutoCommit(false)

8)How can you make the connection?

Connection is made using following Method:

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

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

url: Database url where stored or created your database

userName: User name of your DB

password: Password of DB

Include following code block to make a connection and create Statement.

try {

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

Connection con = DriverManager.getConnection("jdbc:odbc:dumy"; "user", "pass");

Statement stmt = con.createStatement();

}catch( Exception e ) {

e.printStackTrace();

}

9)What is the fastest type of JDBC driver?

Type 4 (JDBC Net pure Java Driver) is the fastest JDBC driver. Type 1 and Type 3 drivers will be slower than Type 2 drivers (the database calls are make at least three translations versus two), and Type 4 drivers are the fastest (only one translation).

10)Is the JDBC-ODBC Bridge multi-threaded?

No. The JDBC-ODBC Bridge does not support multi threading. The JDBC-ODBC Bridge uses synchronized methods to serialize all of the calls that it makes to ODBC. Multi-threaded Java programs may use the Bridge, but they won't get the advantages of multi-threading.

11)How do you handle your own transaction ?

Connection Object has a method called setAutocommit ( boolean flag) . For handling our own transaction we can set the parameter to false and begin your transaction . Finally commit the transaction by calling the commit method.

12)What is a ResultSet ?

A table of data representing a database result set, which is usually generated by executing a statement that queries the database.A ResultSet object maintains a cursor pointing to its current row of data. Initially the cursor is positioned before the first row. The next method moves the cursor to the next row, and because it returns false when there are no more rows in the ResultSet object, it can be used in a while loop to iterate through the result set.

13)What is the difference between executeupdate() and executequery() in JDBC ?

executeQuery() is used for Select statements.

executeUodate() is used for insert,update,delete statements..

14)How do I get runtime information about the JDBC Driver?

Use the following DatabaseMetaData methods:

getDriverMajorVersion()

getDriverMinorVersion()

getDriverName()

getDriverVersion()

15)How do I create an updatable ResultSet?

Just as is required with a scrollable ResultSet, the Statement must be capable of returning an updatable ResultSet. This is accomplished by asking the Connection to return the appropriate type of Statement using Connection.createStatement(int resultSetType, int resultSetConcurrency). The resultSetConcurrency parameter must be ResultSet.CONCUR_UPDATABLE. The actual code would look like this:

Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_SENSITIVE,

ResultSet.CONCUR_UPDATABLE );

Note that the spec allows a driver to return a different type of Statement/ResultSet than that requested, depending on capabilities and circumstances, so the actual type returned should be checked with ResultSet.getConcurrency().

16)What causes the "No suitable driver" error?

"No suitable driver" is an error that usually occurs during a call to the DriverManager.getConnection method. The cause can be failing to load the appropriate JDBC drivers before calling the getConnection method, or it can be specifying an invalid JDBC URL--one that isn't recognized by your JDBC driver. Your best bet is to check the documentation for your JDBC driver or contact your JDBC driver vendor if you suspect that the URL you are specifying is not being recognized by your JDBC driver.

In addition, when you are using the JDBC-ODBC Bridge, this error can occur if one or more the the shared libraries needed by the Bridge cannot be loaded. If you think this is the cause, check your configuration to be sure that the shared libraries are accessible to the Bridge.

Connection and Transaction

2012-09-19T04:32:00.048-07:00

Connection Interface

A Connection is the session between your java program and database. SQL statements are executed and results are returned within the context of a connection.A Connection object's database is able to provide information describing its tables, its supported SQL grammar, its stored procedures, the capabilities of this connection, and so on. This information is obtained with the getMetaData method.

Using Transactions

A transaction is a set of one or more statements that is executed as a unit, so either all of the statements are executed, or none of the statements is executed.

Disabling Auto-Commit Mode

When a connection is created, it is in auto-commit mode. This means that each individual SQL statement is treated as a transaction and is automatically committed right after it is executed.The way to allow two or more statements to be grouped into a transaction is to disable the auto-commit mode. This is demonstrated in the following code, where con is an active connection:

con.setAutoCommit(false);

Committing Transactions

After the auto-commit mode is disabled, no SQL statements are committed until you call the method commit explicitly. All statements executed after the previous call to the method commit are included in the current transaction and committed together as a unit.This is demonstrated in the following code, where con is an active connection:

con.commit();

Whenever the commit method is called (either automatically when auto-commit mode is enabled or explicitly when it is disabled), all changes resulting from statements in the transaction are made permanent

Setting and Rolling Back to Savepoints:

SAVEPOINT is a marker within a transaction that allows for a partial rollback.

The method Connection.setSavepoint, sets a Savepoint object within the current transaction.

Savepoint save1 = con.setSavepoint();

TheConnection.rollback method is overloaded to take a Savepoint argument.

The method checks if the new price is greater than the maximumPrice value. If so, the method rolls back the transaction with the following statement:

con.rollback(save1);

Consequently, when the method commits the transaction by calling the Connection.commit method, it will not commit any rows whose associated Savepoint has been rolled back; it will commit all the other updated rows.

Releasing Savepoints:

The method Connection.releaseSavepoint takes a Savepoint object as a parameter and removes it from the current transaction.
con.releaseSavepoint(save1);
After a savepoint has been released, attempting to reference it in a rollback operation causes a SQLException to be thrown.
Any savepoints that have been created in a transaction are automatically released and become invalid when the transaction is committed, or when the entire transaction is rolled back.
Rolling a transaction back to a savepoint automatically releases and makes invalid any other savepoints that were created after the savepoint in question.

When to Call Method rollback

Calling the method rollback terminates a transaction and returns any values that were modified to their previous values. If you are trying to execute one or more statements in a transaction and get a SQLException, call the method rollback to end the transaction and start the transaction all over again. That is the only way to know what has been committed and what has not been committed. Catching a SQLException tells you that something is wrong, but it does not tell you what was or was not committed. Because you cannot count on the fact that nothing was committed, calling the method rollback is the only way to be certain.

Using Transactions to Preserve Data Integrity:

In addition to grouping statements together for execution as a unit, transactions can help to preserve the integrity of the data in a table. To avoid conflicts during a transaction, a DBMS uses locks, mechanisms for blocking access by others to the data that is being accessed by the transaction. (Note that in auto-commit mode, where each statement is a transaction, locks are held for only one statement.) After a lock is set, it remains in force until the transaction is committed or rolled back. For example, a DBMS could lock a row of a table until updates to it have been committed. The effect of this lock would be to prevent a user from getting a dirty read, that is, reading a value before it is made permanent. (Accessing an updated value that has not been committed is considered a dirty read because it is possible for that value to be rolled back to its previous value. If you read a value that is later rolled back, you will have read an invalid value.)

How locks are set is determined by what is called a transaction isolation level, which can range from not supporting transactions at all to supporting transactions that enforce very strict access rules.

The interface Connection includes five values that represent the transaction isolation levels you can use in JDBC:

Isolation Level	Transactions	Dirty Reads	Non-Repeatable Reads	Phantom Reads
`TRANSACTION_NONE`	Not supported	Not applicable	Not applicable	Not applicable
`TRANSACTION_READ_COMMITTED`	Supported	Prevented	Allowed	Allowed
`TRANSACTION_READ_UNCOMMITTED`	Supported	Allowed	Allowed	Allowed
`TRANSACTION_REPEATABLE_READ`	Supported	Prevented	Prevented	Allowed
`TRANSACTION_SERIALIZABLE`	Supported	Prevented	Prevented	Prevented

TRANSACTION_READ_COMMITED:If the application needs only committed records, then TRANSACTION_READ_COMMITED isolation is the good choice.
TRANSACTION_REPEATABLE_READ:If the application needs to read a row exclusively till you finish your work, then TRANSACTION_REPEATABLE_READ is the best choice.
TRANSACTION_SERIALIZABLE:If the application needs to control all of the transaction problems (dirty read, phantom read and unrepeatable read), you can choose TRANSACTION_SERIALIZABLE for maximum safety.
TRANSACTION_NONE:If the application doesn’t have to deal with concurrent transactions, then the best choice is TRANSACTION_NONE to improve performance.
TRANSACTION_READ_UNCOMMITED:If the application is searching for records from the database then you can easily choose TRANSACTION_READ_UNCOMMITED because you need not worry about other programs that are inserting records at the same time.

A non-repeatable read occurs when transaction A retrieves a row, transaction B subsequently updates the row, and transaction A later retrieves the same row again. Transaction A retrieves the same row twice but sees different data.

A phantom read occurs when transaction A retrieves a set of rows satisfying a given condition, transaction B subsequently inserts or updates a row such that the row now meets the condition in transaction A, and transaction A later repeats the conditional retrieval. Transaction A now sees an additional row. This row is referred to as a phantom.

ResultSet Interface

2012-09-19T01:41:00.000-07:00

When you create a ResultSet there are three attributes you can set. These are:

Type
Concurrency
Holdability

SNIPPET:

 Statement stmt = con.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE,

                                      ResultSet.CONCUR_UPDATABLE

                                      ResultSet.HOLD_CURSORS_OVER_COMMIT);

ResultSet rs = stmt.executeQuery("SELECT a, b FROM TABLE2");

// rs will be scrollable, will not show changes made by others,

// and will be updatable and ResultSet is not closed when the commit()

method of the underlying connection is called

ResultSet Types

A ResultSet can be of a certain type. The type of a ResultSet object determines the level of its functionality in two areas: the ways in which the cursor can be manipulated, and how concurrent changes made to the underlying data source are reflected by the ResultSet object.

There are three ResultSet types:

ResultSet.TYPE_FORWARD_ONLY: The ResultSet can only be navigated forward. That is, you can only move from row 1, to row 2, to row 3 etc. You cannot move backwards in the ResultSet..
ResultSet.TYPE_SCROLL_INSENSITIVE :The ResultSet can be navigated (scrolled) both forward and backwards. You can also jump to a position relative to the current position, or jump to an absolute position. The ResultSet is sensitive to changes in the underlying data source while theResultSet is open. That is, if a record in the ResultSet is changed in the database by another thread or process, it will be reflected in already opened ResulsSet's of this type.
ResultSet.TYPE_SCROLL_SENSITIVE:The ResultSet can be navigated (scrolled) both forward and backwards. You can also jump to a position relative to the current position, or jump to an absolute position. The ResultSet is sensitive to changes in the underlying data source while theResultSet is open. That is, if a record in the ResultSet is changed in the database by another thread or process, it will be reflected in already opened ResulsSet's of this type.

The default type is TYPE_FORWARD_ONLY

Note: Not all databases and JDBC drivers support all ResultSet types. The method DatabaseMetaData.supportsResultSetType returns true if the specified ResultSet type is supported andfalse otherwise

ResultSet Concurrency

The ResultSet concurrency determines whether the ResultSet can be updated, or only read.

A ResultSet can have one of two concurrency levels:

ResultSet.CONCUR_READ_ONLY:Creates a read-only result set. This is the default
ResultSet.CONCUR_UPDATABLE:Creates an updateable result set.

Note: Not all JDBC drivers and databases support concurrency. The method DatabaseMetaData.supportsResultSetConcurrency returns true if the specified concurrency level is supported by the driver and false otherwise.

ResultSet Holdability

The ResultSet holdability determines if a ResultSet is closed when the commit() method of the underlying connection is called.

There are two types of holdability:

HOLD_CURSORS_OVER_COMMIT: It means that all ResultSet instances are closed when connection.commit() method is called on the connection that created the ResultSet.
CLOSE_CURSORS_AT_COMMIT: It means that the ResultSet is kept open when theconnection.commit() method is called on the connection that created the ResultSet.

The HOLD_CURSORS_OVER_COMMIT holdability might be useful if you use the ResultSet to update values in the database. Thus, you can open a ResultSet, update rows in it, callconnection.commit() and still keep the same ResultSet open for future transactions on the same rows.

Note:Not all holdability modes are supported by all databases and JDBC drivers. TheDatabaseMetaData.supportsResultSetHoldability(int holdability) returns true or false depending on whether the given holdability mode is supported or not

Navigating a Result Set:

There are several methods in the ResultSet interface that involve moving the cursor, including:

public void beforeFirst() throws SQLException:Moves the cursor to just before the first row
public void afterLast() throws SQLException:Moves the cursor to just after the last row.
public boolean first() throws SQLException:Moves the cursor to the first row
public void last() throws SQLException:Moves the cursor to the last row.
public boolean absolute(int row) throws SQLException:Moves the cursor to the specified row
public boolean relative(int row) throws SQLException:Moves the cursor the given number of rows forward or backwards from where it currently is pointing.
public boolean previous() throws SQLException:Moves the cursor to the previous row. This method returns false if the previous row is off the result set
public boolean next() throws SQLException:Moves the cursor to the next row. This method returns false if there are no more rows in the result set
public int getRow() throws SQLException:Returns the row number that the cursor is pointing to.
public void moveToInsertRow() throws SQLException:Moves the cursor to a special row in the result set that can be used to insert a new row into the database. The current cursor location is remembered.
public void moveToCurrentRow() throws SQLException:Moves the cursor back to the current row if the cursor is currently at the insert row; otherwise, this method does nothing

Viewing a Result Set:

The ResultSet interface contains dozens of methods for getting the data of the current row.

There is a get method for each of the possible data types, and each get method has two versions:

1. One that takes in a column name.

2. One that takes in a column index.

For example, if the column you are interested in viewing contains an int, you need to use one of the getInt() methods of ResultSet:

public int getInt(String columnName) throws SQLException:Returns the int in the current row in the column named columnName
public int getInt(int columnIndex) throws SQLException:Returns the int in the current row in the specified column index. The column index starts at 1, meaning the first column of a row is 1, the second column of a row is 2, and so on.

Similarly there are get methods in the ResultSet interface for each of the eight Java primitive types, as well as common types such as java.lang.String, java.lang.Object, and java.net.URL

There are also methods for getting SQL data types java.sql.Date, java.sql.Time, java.sql.TimeStamp, java.sql.Clob, and java.sql.Blob. Check the documentation for more information about using these SQL data types.

Updating a Result Set:

The ResultSet interface contains a collection of update methods for updating the data of a result set.

As with the get methods, there are two update methods for each data type:

1. One that takes in a column name.

2. One that takes in a column index.

For example, to update a String column of the current row of a result set, you would use one of the following updateString() methods:

public void updateString(int columnIndex, String s) throws SQLException:Changes the String in the specified column to the value of s.
public void updateString(String columnName, String s) throws SQLException:Similar to the previous method, except that the column is specified by its name instead of its index.

There are update methods for the eight primitive data types, as well as String, Object, URL, and the SQL data types in the java.sql package.

Updating a row in the result set changes the columns of the current row in the ResultSet object, but not in the underlying database. To update your changes to the row in the database, you need to invoke one of the following methods.

public void updateRow():Updates the current row by updating the corresponding row in the database.
public void deleteRow():Deletes the current row from the database
public void refreshRow():Refreshes the data in the result set to reflect any recent changes in the database.
public void cancelRowUpdates():Cancels any updates made on the current row.
public void insertRow():Inserts a row into the database. This method can only be invoked when the cursor is pointing to the insert row.

JDBC Metadata

2012-09-19T00:07:00.002-07:00

The simple meaning of metadata is data about data. There are two metadata available in the JDBC API - ResultSetMetaData and DatabaseMetaData.

ResultSetMetaData

It is used to make descriptive information about ResultSetobject, like; number of columns, name of columns and dataype of columns. It does not provide any information regarding database and how many rows are available in the ResultSet object. Whether ResultSet is read only, updatable or scrollable.
This is useful when you don't have any information about the columns of the table.
First we have to create object of ResultSetMetadata by calling getMetaData() method from ResultSet object.
Syntax :

ResultSetMetaData rsmd=res.getMetaData();

The following are common methods in ResultSetMetadata interface -

int getColumnCount()
String getColumnName()
int getColumnType()
String getTableName()

The following is the source code to demostrates ResultSetMetaData interface. Here we will display the contents of Locations table along with column heading:

PROGRAM:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

class JDBCMetaData
{
public static void main( String args[] )
{
Statement stmt=null;
Connection conn=null;
try
{
Class.forName("oracle.jdbc.driver.OracleDriver");
conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr");
// Get a statement from the connection
stmt = conn.createStatement() ;
// Execute the query
ResultSet rs = stmt.executeQuery( "SELECT * FROM Locations" ) ;
// Get the metadata
ResultSetMetaData md = rs.getMetaData() ;
// Print the column labels
for( int i = 1; i <= md.getColumnCount(); i++ )
System.out.print( md.getColumnLabel(i) + " " ) ;
System.out.println() ;
// Loop through the result set
while( rs.next() )
{
for( int i = 1; i <= md.getColumnCount(); i++ )
System.out.print( rs.getString(i) + " " ) ;
System.out.println() ;
}
// Close the result set, statement and the connection
rs.close() ;
stmt.close() ;
conn.close() ;
}
catch( SQLException se )
{
System.out.println( "SQL Exception:" ) ;
// Loop through the SQL Exceptions
while( se != null )
{
System.out.println( "State : " + se.getSQLState() ) ;
System.out.println( "Message: " + se.getMessage() ) ;
System.out.println( "Error : " + se.getErrorCode() ) ;
se = se.getNextException() ;
}
}
catch( Exception e )
{
System.out.println( e ) ;
}
}
}

DatabaseMetaData

The java.sql.DatabaseMetaData interface provide comprehensive information about the database. It contains the information about Database Management System (DBMS) and all the objects in the database, like; all the tables, cataloge name, view, stored procedure etc.

Through the java.sql.DatabaseMetaData interface you can obtain meta data about the database you have connected to. For instance, you can see what tables are defined in the database, and what columns each table has, whether given features are supported etc.

PROGRAM:
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;

public class JDBCDatabaseMetaData {
Connection con;

public JDBCDatabaseMetaData() {
try {
// Load the database driver
Class.forName("oracle.jdbc.driver.OracleDriver");
// Get a connection to the database
con=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr");
} catch (Exception e) {
System.out.println("Error in connection" + e);
}
}

public void useMetaData() {
try {
// to obtain DatabaseMetadata object
DatabaseMetaData dm = con.getMetaData();
System.out.println("Get database Major Version : - "+ dm.getDatabaseMajorVersion());
System.out.println("Get database Minor Version : - "+ dm.getDatabaseMinorVersion());
System.out.println("get Database Product name : - " + dm.getDatabaseProductName());
System.out.println("get Database Product Version : - "+ dm.getDatabaseProductVersion());
System.out.println("Get JDBC Driver Major Version :- "+ dm.getDriverMajorVersion());
System.out.println("Get JDBC Driver Minor Version :- "+ dm.getDriverMinorVersion());
System.out.println("Get driver Name : -" + dm.getDriverName());
System.out.println("get driver version :- " + dm.getDriverVersion());
System.out.println("Get JDBC Major version :- "+ dm.getJDBCMajorVersion());
System.out.println("Get JDBC Minor version :- "+ dm.getJDBCMinorVersion());
System.out.println("===========");
String[] types = { "TABLE" };
String catalog = con.getCatalog();
String schema = "test"; // name of the database
DatabaseMetaData dmd = con.getMetaData();
ResultSet rset = dmd.getTables(catalog, schema, null, types);
while (rset.next()) {
System.out.println(rset.getString(3));
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
JDBCDatabaseMetaData obj = new JDBCDatabaseMetaData();
obj.useMetaData();
}
}

NOTE:For more methods of ResultSetMetaData and DatabaseMetaData refer javadocs

JDBC Statements

2012-09-18T23:39:00.000-07:00

There are three main types of Statement objects: the base class Statement, the PreparedStatement, and the CallableStatement. These objects are instantiated from your JDBC Connection object.

Following table provides a summary of each interface's purpose to understand how do you decide which interface to use:

Interfaces	Recommended Use
Statement	Use for general-purpose access to your database. Useful when you are using static SQL statements at runtime. The Statement interface cannot accept parameters.
PreparedStatement	used to run Pre compiled sql. Use when you plan to use the SQL statements many times. The PreparedStatement interface accepts input parameters at runtime.
CallableStatement	used to execute the stored procedures. The CallableStatement interface can also accept runtime input parameters.

Note:For simplicity, in the following examples we will use the Locations table in hr schema that we used earlier

JDBC Statement

JDBC Statement is an interface of java.sql.*; package. It is used for execution of SQL statements. It returns a ResultSet object. This result set object contains the result of the query. Statement interface provides basic method for SELECT, INSERT, UPDATE, DELETE operations in the database. Its query is compiled every time when request is made, therefore is little slower in comparison to PreparedStatement.

It’s example has been explained already here

PreparedStatement

Executes a pre-compiled SQL statement with or without IN parameters. The PreparedStatement interface extends the Statement interface which gives you added functionality with a couple of advantages over a generic Statement object.It is useful because it avoids manual conversion of Java types to SQL types. PreparedStatement objects are precompiled.
PROGRAM:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
class JDBCPreparedStatement
{
public static void main( String args[] )
{
try
{
// Load the database driver
Class.forName("oracle.jdbc.driver.OracleDriver");

// Get a connection to the database
Connection conn=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr");

// Prepare a statement
PreparedStatement ps = conn.prepareStatement( "SELECT * FROM Locations WHERE LOCATION_ID = ? and POSTAL_CODE=?" ) ;

// Set the first parameter of the statement
ps.setInt( 1, 3100);
// Set the second parameter of the statement
ps.setString(2, "3029SK");

// Execute the query
ResultSet rs = ps.executeQuery() ;

// Loop through the result set
while( rs.next() )
System.out.println( rs.getString("LOCATION_ID") + " " + rs.getString("STREET_ADDRESS") ) ;

// Close the result set, statement and the connection
rs.close() ;
ps.close() ;
conn.close() ;
}
catch( SQLException se )
{
System.out.println( "SQL Exception:" ) ;

// Loop through the SQL Exceptions
while( se != null )
{
System.out.println( "State : " + se.getSQLState() ) ;
System.out.println( "Message: " + se.getMessage() ) ;
System.out.println( "Error : " + se.getErrorCode() ) ;

se = se.getNextException() ;
}
}
catch( Exception e )
{
System.out.println( e ) ;
}
}
}

Callable Statements

A java.sql.CallableStatement is used to call stored procedures in a database.

A stored procedure is like a function or method in a class, except it lives inside the database. Some database heavy operations may benefit performance-wise from being executed inside the same memory space as the database server, as a stored procedure.

OUT Parameters

A stored procedure may return OUT parameters. That is, values that are returned instead of, or in addition to, a ResultSet. After executing the CallableStatement you can then access these OUTparameters from the CallableStatement object.

See a full JDBC CallableStatement example for OUT parameter.
STORED PROCEDURE:

CREATE OR REPLACE PROCEDURE getLocationById(

p_locationId IN Locations .LOCATION_ID%TYPE,

o_street_address OUT Locations .STREET_ADDRESS%TYPE,

o_postal_code OUT Locations .POSTAL_CODE%TYPE,

o_country_id OUT Locations .COUNTRY_ID%TYPE)

BEGIN

SELECT STREET_ADDRESS, POSTAL_CODE, COUNTRY_ID

INTO o_street_address, o_postal_code, o_country_id

FROM Locations WHERE LOCATION_ID= p_locationId;

END;

Commit;

Program:

import java.sql.CallableStatement;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class JDBCCallableStatement {

public static void main(String[] argv) {
try {

callOracleStoredProcOUTParameter();

} catch (SQLException e) {

System.out.println(e.getMessage());

}
}

private static void callOracleStoredProcOUTParameter() throws SQLException {

Connection dbConnection = null;
CallableStatement callableStatement = null;
try
{
// Load the database driver
Class.forName("oracle.jdbc.driver.OracleDriver");

// Get a connection to the database
dbConnection =DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr");

String getDBUSERByUserIdSql = "{call getLocationById(?,?,?,?)}";

//preparing callable statement
callableStatement = dbConnection.prepareCall(getDBUSERByUserIdSql);

callableStatement.setInt(1, 3100);
//registering Out parameters
callableStatement.registerOutParameter(2, java.sql.Types.VARCHAR);
callableStatement.registerOutParameter(3, java.sql.Types.VARCHAR);
callableStatement.registerOutParameter(4, java.sql.Types.VARCHAR);

// execute getDBUSERByUserId store procedure
callableStatement.executeUpdate();
//accessing out parameters
String streetAddress = callableStatement.getString(2);
String postalCode = callableStatement.getString(3);
String countryId = callableStatement.getString(4);

System.out.println("Street Address : " + streetAddress);
System.out.println("Postal Code : " + postalCode);
System.out.println("Country Id : " + streetAddress);

} catch( SQLException se )
{
System.out.println( "SQL Exception:" ) ;

// Loop through the SQL Exceptions
while( se != null )
{
System.out.println( "State : " + se.getSQLState() ) ;
System.out.println( "Message: " + se.getMessage() ) ;
System.out.println( "Error : " + se.getErrorCode() ) ;

se = se.getNextException() ;
}
}
catch( Exception e )
{
System.out.println( e ) ;
}
finally {

if (callableStatement != null) {
callableStatement.close();
}

if (dbConnection != null) {
dbConnection.close();
}
}
}
}

Introduction : All about Programming

2012-09-16T07:16:00.003-07:00

Hello, friends this is my first post(or i should say my first blog).
This post is just to let you guys know what this blog is going to be really about.

But before that i would like to tell something about me.I am an IT engineer graduated last year(2011).I have recently joined a company.It is a new learning experience for me and i have learned a lot.Every day we are given a new task and at times it becomes really difficult to understand the concepts. we have to put in lot of hours of R&D (being a fresher) to understand it. So i thought why not share it with you guyz, who knows may be someday a fresher might find it useful.

So friends , Lets begin this journey and i hope it is going to be a memorable one.

2012-09-15T23:16:00.002-07:00

STEPS TO CONNECT TO DATABASE USING JDBC (Type 4 driver)

In this post I will show you how to connect to a database using JDBC.

STEP 1) Load the Database driver

In this step of the jdbc connection process, we load the driver class by calling Class.forName() with the Driver class name as an argument. Once loaded, the Driver class creates an instance of itself and registers it with the DriverManager. A client can connect to Database Server through JDBC Driver. The return type of the Class.forName (String ClassName) method is “Class”. Class is a class in java.lang package

try{ Class.forName(”oracle.jdbc.Driver.OracleDriver”); // This is type 4 driver

}

catch(Exception x) {

System.out.println( “Unable to load the driver class!” );

}

STEP 2) Establish Connection using getConnection() method of Driver Manager

The JDBC DriverManager class defines objects which can connect Java applications to a JDBC driver. DriverManager is considered the backbone of JDBC architecture. DriverManager class manages the JDBC drivers that are installed on the system. Its getConnection() method is used to establish a connection to a database. It uses a username, password, and a jdbc url to establish a connection to the database and returns a connection object. A jdbc Connection represents a session/connection with a specific database. An application can have one or more connections with a single database, or it can have many connections with different databases.

try{

Connection conn=DriverManager.getConnection(url,”loginName”,”Pwd”);

}

catch( SQLException x ){

System.out.println( “Couldn’t get connection!” );

}

The DriverManager provides registerDriver() and deregisterDriver() methods, which allow a Driver implementation to register itself with the DriverManager or remove itself from that list. You can get an enumeration of registered drivers through the getDrivers() method.

STEP 3) Create and execute SQL statements

Once a connection is obtained we can interact with the database. Connection interface defines methods for interacting with the database via the established connection. To execute SQL statements, you need to instantiate a Statement object from your connection object by using the createStatement() method.

Statement statement = dbConnection.createStatement();

A statement object is used to send and execute SQL statements to a database.

Three types of statements are:

1.Statement which is used to run simple sqlstatements like select and update

2. PrepareStatment is used to run Pre compiled sql.

3. CallableStatement is used to execute the stored procedures.

Creating Statement Object:

Before you can use a Statement object to execute a SQL statement, you need to create one using the Connection object's createStatement( ) method, as in the following example:

Statement stmt = null;

try {

stmt = conn.createStatement( );

. . .

}

catch (SQLException e) {

. . .

}

finally {

. . .

}

Once you've created a Statement object, you can then use it to execute a SQL statement with one of its three execute methods.

1.boolean execute(String SQL) : It is used for situations in which you do not know whether the SQL being executed is a query or update .Returns a boolean value of true if a ResultSet object can be retrieved; otherwise, it returns false. Use this method to execute SQL DDL statements or when you need to use truly dynamic SQL.

2.int executeUpdate(String SQL) : Returns the numbers of rows affected by the execution of the SQL statement. Use this method to execute SQL statements for which you expect to get a number of rows affected - for example, an INSERT, UPDATE, or DELETE statement.

3.ResultSet executeQuery(String SQL) : Returns a ResultSet object. Use this method when you expect to get a result set, as you would with a SELECT statement.

Note:More about JDBC Statements refer this tutorial-->LINK

STEP 4)Getting results

Create Resultset object using the statement created above:

ResultSet rs = s.executeQuery("sql statement");

The ResultSet interface provides methods for retrieving and manipulating the results of executed queries. Iterate the result set to get all the values from the database.

ResultSet interface provides access to a table of data generated by executing a Statement. The table rows are retrieved in sequence. A ResultSet maintains a cursor pointing to its current row of data. The next() method is used to successively step through the rows of the tabular results.

If next() returns true, you have another row to process and any subsequent calls you make to theResultSet object will be in reference to that next row. If there are no rows left, it returns false. . Please note that ResultSet objects allow only one-way navigation through rows from a query--there is no previous() counterpart to thenext() method.

Viewing a Result Set:

The ResultSet interface contains dozens of methods for getting the data of the current row.

There is a get method for each of the possible data types, and each get method has two versions:

1.One that takes in a column name.

public int getInt(String columnName) throws SQLException
Returns the int in the current row in the column named columnName

2.One that takes in a column index.

public int getInt(int columnIndex) throws SQLException
Returns the int in the current row in the specified column index. The column

index starts at 1, meaning the first column of a row is 1, the second column of a

row is 2, and so on.

Similarly there are get methods in the ResultSet interface for each of the eight Java primitive types, as well as common types such as java.lang.String, java.lang.Object, and java.net.URL

ResultSet rs=stmt.executeQuery(“select * from emp”);

while(rs.next())

{

out.println(rs.getInt(1));

out.println(rs.getString(2));

}

STEP 5)Clean Up (Closing open connections)

In the examples provided so far, you may have noticed many of the objects being closed through a close() method. The Connection, Statement, and ResultSet classes all have close(). A given JDBC implementation may or may not require you to close these objects before reusing. But some might, since they likely are holding precious database resources. It is therefore always a good idea to close any instance of the above objects when you are done with them. If you do manage to close a Connection before committing with auto-commit off, any uncommitted transactions will be lost.

finally{ //finally block used to close resources

try{

if(stmt!=null)

stmt.close();

}catch(SQLException se2){

} // nothing we can do

try{

if(conn!=null)

conn.close();

}catch(SQLException se){

se.printStackTrace();

}
} //end finally try

PREV NEXT

2012-09-15T23:12:00.003-07:00

STEPS TO CONNECT TO DATABASE USING JDBC (Type 4 driver)

Software Required:

1)Oracle 11g Express Edition: For downloading and installing refer-->LINK
2) Eclipse IDE: I have used Juno,you can use any other version.For download link and information refer--->LINK
3) Oracle Driver (ojdbc6.jar file): download from here--->LINK

NOTE:
For JDBC we need a table in the database to work with.When you install 11g, HR schema is automatically created.We will use the LOCATIONS table for this tutorial.
HR schema is locked by default. To unlock it you can login as system

(When you started installing oracle ,it asked for global database name and database password that password is used for the sys, system, sysman, dbsnmp account.)

1. Try to login as "system" - pass

SQL> conn system/password;

2. Unlock "hr"

SQL> alter user hr account unlock;

3. Can change password to "hr":

SQL> alter user hr identified by hr;

4. Now you can connect to hr

SQL> conn hr/hr;
-Success

You can use Locations table for JDBC example.It has following columns

LOCATION_ID NUMBER

STREET_ADDRESS VARCHAR

POSTAL_CODE VARCHAR

CITY VARCHAR

STATE_PROVINCE VARCHAR

COUNTRY_ID CHAR

STEPS:
1)Start Eclipse and create a new Java project.
File-->New-->Java Project
2)Add the ojdbc6.jar file to the Build path of the project
Right Click on Project-->Build Path--->Configure Build Path
Go to Library tab and Select Add External Jars-->Locate the jar file and click open.
For Snapshots refer Eclipse document
3)Add a new java class and Name it as JDBCProgram
Type the following program:

import java.sql.*;
public class JDBCProgram {
public static void main(String[] args) {
Statement stmt=null;
Connection con=null;
try
{
Class.forName("oracle.jdbc.driver.OracleDriver");
con=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe",
"hr","hr");
stmt=con.createStatement();
ResultSet rs=stmt.executeQuery("select * from locations");
while(rs.next())
{
System.out.print(rs.getInt(1)+"\t");
System.out.print(rs.getString(2)+"\t");
System.out.print(rs.getString(3)+"\t");
System.out.print(rs.getString(4)+"\t");
System.out.println(rs.getString(5)+"\t");

}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally{
//finally block used to close resources
try{
if(stmt!=null)
stmt.close();
}
catch(SQLException se2){
}// nothing we can do
try{
if(con!=null)
con.close();
}catch(SQLException se){
se.printStackTrace();
}//end finally try
}
}
}

Now Run the project to get entire data of Locations table

Note: In con=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","hr","hr") ;
xe is the Oracle SID, hr is the username and hr is the password.

To know your oracle Sid you can use following command

SQL>select instance from v$thread;

JDBC Drivers Types

2012-09-15T09:12:00.002-07:00

JDBC driver implementations vary because of the wide variety of operating systems and hardware platforms in which Java operates. Sun has divided the implementation types into four categories, Types 1, 2, 3, and 4, which is explained below:

Type 1: JDBC-ODBC Bridge Driver:

The JDBC type 1 driver, also known as the JDBC-ODBC bridge, is a database driver implementation that employs the ODBC driver to connect to the database. The driver converts JDBC method calls into ODBC function calls.

ODBC:Open Database Connectivity is a standard C programming language middleware API for accessing database management systems (DBMS).

When Java first came out, this was a useful driver because most databases only supported ODBC access but now this type of driver is recommended only for experimental use or when no other alternative is available.

Fig1:Type1 Driver

Advantages

Almost any database for which ODBC driver is installed, can be accessed.

Disadvantages

Performance overhead since the calls have to go through the jdbc Overhead bridge to the ODBC driver, then to the native db connectivity interface (thus may be slower than other types of drivers).
The ODBC driver needs to be installed on the client machine.
It is platform dependent

Example:

The JDBC-ODBC bridge that comes with JDK 1.2 is a good example of this kind of driver.

Type 2: JDBC-Native API:

The JDBC type 2 driver, also known as the Native-API driver,

In a Type 2 driver, JDBC API calls are converted into native C/C++ API calls which are unique to the database. These drivers typically provided by the database vendors and used in the same manner as the JDBC-ODBC Bridge, the vendor-specific driver must be installed on each client machine.

If we change the Database we have to change the native API as it is specific to a database and they are mostly obsolete now but you may realize some speed increase with a Type 2 driver, because it eliminates ODBC's overhead.

Type 2:Driver

Advantages

As there is no implementation of jdbc-odbc bridge, its considerably faster than a type 1 driver.

Disadvantages

The vendor client library needs to be installed on the client machine.
Not all databases have a client side library
This driver is platform dependent

Example:

The Oracle Call Interface (OCI) driver is an example of a Type 2 driver.

Type 3: JDBC-Net pure Java:

The JDBC type 3 driver, also known as the Pure Java Driver for Database Middleware. In a Type 3 driver, a three-tier approach is used to accessing databases. The JDBC clients use standard network sockets (TCP/IP) to communicate with an middleware application server (hence known as network protocol driver). The socket information is then translated by the middleware application server into the call format required by the DBMS, and forwarded to the database server.The same driver can be used for connecting to multiple databases. It depends on the number of databases the middleware has been configured to support. Also, making use of the middleware provides additional advantages of security and firewall access.

Advantages

Type3:Driver

Since the communication between client and the middleware server is database independent, there is no need for the database vendor library on the client. The client need not be changed for a new database.
The middleware server (which can be a full fledged J2EE Application server) can provide typical middleware services like caching (of connections, query results, etc.), load balancing, logging, and auditing.
A single driver can handle any database, provided the middleware supports it.

Disadvantages

Requires database-specific coding to be done in the middle tier.
The middleware layer added may result in additional latency, but is typically overcome by using better middleware services.

Example

IDA Server

Type 4 Driver - Native-Protocol Driver(Pure Java Driver):

The JDBC type 4 driver, also known as the Direct to Database Pure Java Driver, is a database driver implementation that converts JDBC calls directly into a vendor-specific database protocol (hence also known as Native-Protocol driver).This is the highest performance driver available for the database and is usually provided by the vendor itself.This kind of driver is extremely flexible, you don't need to install special software on the client or server. Further, these drivers can be downloaded dynamically.

Type4:Driver

Advantages

Completely implemented in Java to achieve platform independence.
These drivers don't translate the requests into an intermediary format (such as ODBC).
The client application connects directly to the database server. No translation or middleware layers are used, improving performance.
The JVM can manage all aspects of the application-to-database connection; this can facilitate debugging.
Provides a way to manage copies of the database for each user.

Disadvantages

Drivers are database dependent, as different database vendors use wildly different (and usually proprietary) network protocol

Example:

The widely used Oracle thin driver

Differences Between JDBC Drivers:

Driver Type	Driver Name	Function	Pure Java	Platform dependent
Type I	JDBC-ODBC Bridge	JDBC method calls into ODBC function calls	NO	YES
Type II	Native -API	JDBC method calls into native calls of Database API	NO	YES
Type III	Network-Protocol Driver	Middle tier converts JDBC calls directly or indirectly into vendor specific database protocol	YES	NO
Type IV	Native Protocol Driver	JDBC calls directly into vendor specific database Protocol	YES	NO

Which Driver should be used?

If you are accessing one type of database, such as Oracle, Sybase, or IBM, the preferred driver type is 4.
If your Java application is accessing multiple types of databases at the same time, type 3 is the preferred driver.
Type 2 drivers are useful in situations where a type 3 or type 4 driver is not available yet for your database.
The type 1 driver is not considered a deployment-level driver and is typically used for development and testing purposes only.

Prev Next

Installing Oracle 11g Database

2012-09-15T09:07:00.001-07:00

Here’s the Oracle Database 11g Express Edition step-by-step installation.

When you download the software from Oracle, you’ll need an account and you’ll need to accept the license agreement.
DOWNLOAD LINK

1. You’re prompted to accept the license agreement and can’t proceed without doing it.

2. After accepting the license agreement you can download the software.

3. You have downloaded a compressed (OracleXE112_Win32.zip) file, and you’ll need to extract the zip file and write it to a directory. When you write it to a directory, it looks like the following and you double click on the setup.msi file.

It’s recommended that you right click on the setup.msi program and run it as the Administrator. If you’ve not disabled Microsoft User Access Controls (UAC), I’d do that first.

4. After launching the setup.msi file, you see the Install Shield wizard screen while the file loads, like this:

After launching the setup.msi file, and loading the MSI file, you see the first dialog box of the installation. Click the Next button to start the installation.

5. The second dialog box is the license for the installation. Click the I accept the terms in the license agreement. radio button and then the Next button.

6. The third dialog box lets you accept the default location or provide an override location. If you accept the default location, click the Next button to continue.

7. The fourth dialog box lets you specify the TNS, MTS, and HTTP Ports. The default values are shown. Click the Next button to continue.

8. The fifth dialog box lets you enter the password for the SYS and SYSTEM users. You must enter it twice and naturally they must match each other. Click the Next button to continue.

9. The sixth dialog box lets you see the configuration options you’ve chosen. Click the Next button to continue.

10. The seventh dialog box lets you see the progress bar, take a break it can run for two or three minutes. Click the Next button to continue.

11. The last dialog box lets you see that you’ve installed the product. Click the Finish button to complete the installation.

You’ve now installed Oracle Database 11g Express Edition. You can start the command line by typing sqlplus system/password in command shell or the Get Started option in your Program Menus, as shown below.

You should see this console when you launch Get Started or manually type http://localhost:8080/apex. There’s more to the web page but I scrunched it to fit into the blog. Alas, space is always at a premium.

Hope this helps folks.

JDBC TUTORIAL

2012-09-15T09:06:00.023-07:00

What is JDBC?

A JDBC driver is a software component enabling a Java application to interact with a database.It is a specification that tells vendor how to write a driver program to interface java program with their database. The JDBC driver gives out the connection to the database and implements the protocol for transferring the query and result between client and database.

JDBC helps you to write Java applications that manage these three programming activities:

1. Connect to a data source, like a database

2. Send queries and update statements to the database

3. Retrieve and process the results received from the database in answer to your query

What are we going to cover in this tutorial??
*JDBC Architecture *Types Of JDBC Drivers
*Steps to connect to Database using JDBC *JDBC Implementation program
*JDBC Metadata *JDBC Statements with Example
*ResultSet Interface *Connection and Transaction

JDBC Architecture

The JDBC API supports both two-tier and three-tier processing models for database

access.

Figure 1: Two-tier Architecture for Data Access.

In the two-tier model, a Java application talks directly to the data source. This requires a JDBC driver that can communicate with the particular data source being accessed. A user's commands are delivered to the database or other data source, and the results of those statements are sent back to the user. The data source may be located on another machine to which the user is connected via a network. This is referred to as a client/server configuration, with the user's machine as the client, and the machine housing the data source as the server.

Figure 2: Three-tier Architecture for Data Access.

In the three-tier model, commands are sent to a "middle tier" of services, which then sends the commands to the data source. The data source processes the commands and sends the results back to the middle tier, which then sends them to the user. MIS directors find the three-tier model very attractive because the middle tier makes it possible to maintain control over access and the kinds of updates that can be made to corporate data. Another advantage is that it simplifies the deployment of applications. Finally, in many cases, the three-tier architecture can provide performance advantages.

Prev Next

Eclipse IDE

2012-09-15T09:05:00.001-07:00

Eclipse Overview

Eclipse an open source community whose projects building tools and frameworks for creating general purpose application.The most popular usage of Eclipse is as a Java development environment.

This tutorial describes the usage of Eclipse as a Java IDE. It describes the installation of Eclipse, the creation of Java programs, the usage of external jars

Getting started

1)Installation:

Download Link: http://www.eclipse.org/downloads/

Download "Eclipse IDE for Java Developers" from the website Eclipse Downloads and unpack it to a directory. This is sufficient for Eclipse to be used; no additional installation procedure is required.

Use a directory path which does not contain spaces in its name.

Eclipse requires an installed Java Runtime. I recommended to use Java 6 (also known as Java 1.6).

Download Page

2) Start Eclipse

To start Eclipse double-click on the file eclipse.exe in your installation directory.

The system will prompt you for a workspace. The workspace is the place there you store your Java projects (more on workspaces later). Select a suitable (empty) directory and press Ok.

Eclipse will start and show the Welcome page.

Eclipse UI Overview:

Eclipse provides perspectives, views and editors. Views and editors are grouped into perspectives. All projects are located in a workspace.

1) Workspace

The workspace is the physical location (file path) you are working in. You can choose the workspace during startup of eclipse or via the menu (File-> Switch Workspace-> Others).

All your projects, sources files, images and other artifacts will be stored and saved in your workspace.

To predefine the workspace you can use the startup parameter -data path_to_workspace, e.g. c:\eclipse.exe -data "c:\temp". Please note that you have to put the path name into brackets. To see the current workspace directory in the title of Eclipse use -showLocation as additional parameter.

2) Perspective

A perspective is a visual container for a set of views and editors.You can change the layout within a perspective (close / open views, editors, change the size, change the position, etc.). A common problem is that you closed a view and don't know how to re-open this view. You can reset a perpective it to it original state via the menu "Window" -> "Reset Perspective".

Eclipse allow you to switch to another perspective via the menu Window->Open Perspective -> Other.For Java development you usually use the "Java Perspective".

3) Views and EditorsEclipse Java IDE - Tutorial

A view is typically used to navigate a hierarchy of information or to open an editor. Changes in a view are directly applied.

Editors are used to modify elements. Editors can have code completion, undo / redo, etc. To apply the changes in an editor to the underlying

resources, e.g. Java source file, you usually have to save.

Create your first Java program

The following will describe how to create a minimal Java program using Eclipse. It will be the classical " Hello World" program. Our program will write “This is my first Program” to the console.

1) Create project

Select from the menu File -> New-> Java project. Maintain "HelloWorld" as the project name. Select "Create separate source and output folders".

Press finish to create the project. A new project is created and displayed as a folder. Open the folder "HelloWorld"

4.2. Create package

Create now a package. A good convention is to use the same name for the top package as the project. Create therefore the package "com.src".

Select the folder src, right mouse click on it and select New -> Package

3) Create Java class

Right click on your package and select New -> Class

Create MyFirstProgram, select the flag "public static void main (String[] args)"

Maintain the following code.

Write a simple System.out.print Statement

4) Run your project in Eclipse

Now run your code. There are two ways by which you can run your application.

1)Right click on your Java class and select Run-as-> Java application

2)Click on Run button in your toolbar

Finished! You should see the output in the console.

5. Using jars (libraries)

1) Adding external library (.jar ) to the Java classpathEclipse Java IDE - Tutorial

The following describes how to add external jars to your project.

The following assumes you have a jar available.

Right Click on the ProjectàBuild Path -àConfigure Build Path

Select Libraries Tab -->Add External Jars

Select the Jar File you want to add and click Open

The following example shows how the result would look like if ojdbc6.jar would be added to a project.

CONCLUSION

Here we have seen how to install Eclipse IDE and how to run a basic Java program using Eclipse