Java Examples

Struts Interview Questions And Answers

noreply@blogger.com (LakshmiNarayana Gorantla) — Mon, 10 Sep 2012 21:37:18 PDT

Q) What is MVC? 
Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from business logic and data. 
Model : The model contains the core of the application's functionality. The model encapsulates the business logic of the application.It knows nothing about the view or controller.
View: The view provides the presentation to the user. It will show the view components to the user.
Controller:The controller reacts to the user input. It creates and sets the model.

Q) What is a framework? 
A framework is made up of the set of classes and interfaces which allow us to use a library in a best possible way for a specific requirement.Framework provides facilities to do the common functionality in the application development.

Q) What is Struts framework? 
Struts framework is an open-source framework for developing the web applications in Java EE, based on MVC-2 architecture. It uses and extends the Java Servlet API. Struts is robust architecture and can be used for the development of application of any size. Struts framework makes it much easier to design scalable, reliable Web applications with Java.


Q) What are the components of Struts? 
Struts components can be categorize into Model, View and Controller: 
     Model: Components like business logic /business processes and data are the part of model. 
     View: HTML, JSP are the view components. 
     Controller: Action Servlet of Struts is part of Controller components which works as front controller to handle all the requests.


Q) What are the core classes of the Struts Framework? 
Struts is a set of classes, servlets, and JSP tags that make up a reusable design. 
     Java Beans components for managing application state and behavior. 
     Event-driven development (via listeners as in traditional GUI development). 
     Pages that represent MVC-style views; pages reference view roots via the JSF component tree.


Q) What is ActionServlet class? 
ActionServlet is a simple servlet which is the backbone of all Struts applications. It is the main Controller component that handles client requests and determines which Action will process each received request. It serves as an Action factory – creating specific Action classes based on user’s request.

Q) What is role of ActionServlet class? 
ActionServlet performs the role of Controller:
     Process user requests 
     Determine what the user is trying to achieve according to the request 
     Pull data from the model (if necessary) to be given to the appropriate view, 
     Select the proper view to respond to the user 
     Delegates most of this grunt work to Action classes 
     Is responsible for initialization and clean-up of resources 

Q) What is the ActionForm class? 
Action Form is javabean which represents the form inputs containing the request parameters from the View referencing the Action bean.

Q) What are the important methods of ActionForm class? 
The important methods of ActionForm are : validate() & reset().

Q)Describe validate() and reset() methods in Action form class? 
validate() : Used to validate properties after they have been populated; Called before FormBean is handed to Action. Returns a collection of ActionError as ActionErrors. Following is the method signature for the validate() method.

public ActionErrors validate(ActionMapping mapping,HttpServletRequest request)

reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The purpose of this method is to reset all of the ActionForm's data members prior to the new request values being set. 
public void reset() {}

Q).What is ActionMapping in struts-config.xml file? 
Action mapping contains all the deployment information for a particular Action bean. This class is to determine where the results of the Action will be sent once its processing is complete.

Q) How is the Action Mapping specified ? 
We can specify the action mapping in the configuration file called struts-config.xml. Struts framework creates ActionMapping object from  configuration element of struts-config.xml file 

<action-mappings>

<

action path="/mySubmit"
    type="submit.MySubmitAction"
         name="MySubmitForm"
         input="/MySubmit.jsp"
         scope="request"
         validate="true">

<

forward name="success" path="/success.jsp"/>

<

forward name="failure" path="/error.jsp"/>



Q) What is role of Action Class? 
An Action Class performs a role of an adapter between the contents of an incoming HTTP request and the corresponding business logic that should be executed to process this request. 

Q) In which method of Action class the business logic is executed ? 
In the execute() method of Action class the business logic is executed.

public ActionForward execute( 
        ActionMapping mapping,
             ActionForm form,
             HttpServletRequest request,
             HttpServletResponse response)
          throws Exception ;

execute() method of Action class: 
     Perform the processing required to deal with this request 
     Update the server-side objects (Scope variables) that will be used to create the next page of the user interface 
     Return an appropriate ActionForward object

Q) Can we have more than one struts-config.xml file for a single Struts application?
Yes, we can have more than one struts-config.xml for a single Struts application. They can be configured as follows:

<servlet>
    <servlet-name>action
    <servlet-class>org.apache.struts.action.ActionServlet
    < /servlet-class>
           < init-param>
           < param-name>config</param-name>
                  <param-value>
                               /WEB-INF/struts-config.xml,
                              /WEB-INF/struts-admin.xml,
                             /WEB-INF/struts-config-forms.xml


.....
<servlet>

Q) What is the directory structure of Struts application?
The directory structure of Struts application :

Q) What is the difference between session scope and request scope when saving formbean ?
when the scope is request,the values of formbean would be available for the current request.
when the scope is session,the values of formbean would be available throughout the session.

Q) What are the important tags of struts-config.xml ?
The five important sections are:
Form Bean Definition
Global Forward Definition
Action Mapping Definition
Controller Configuration Definition
Message Resource Definition

Q) What are the different kinds of actions in Struts?
The different kinds of actions in Struts are:
DispatchAction
LookupDispatchAction
ForwardAction
IncludeAction
SwitchAction

Q) What is DispatchAction?
The DispatchAction class is used to group related actions into one class.Using the Dispatchaction we can reduce number of action class in the application . you can have a method for each logical action compared than a single execute method. The DispatchAction dispatches to one of the logical actions represented by the methods. It picks a method to invoke based on an incoming request parameter. The value of the incoming parameter is the name of the method that the DispatchAction will invoke.

Q) How to use DispatchAction?
To use the DispatchAction, follow these steps :
Create a class that extends DispatchAction (instead of Action)
In a new class, add a method for every function you need to perform on the service – The method has the same signature as the execute() method of an Action class.
Do not override execute() method – Because DispatchAction class itself provides execute() method.
Add an entry to struts-config.xml

<action input="/index.jsp" parameter="method" name="UserForm" path="/UserAction" scope="session" type="com.vaannila.UserAction">

Q).What is the use of ForwardAction?
The ForwardAction class is useful when you’re trying to integrate Struts into an existing application that uses Servlets to perform business logic functions. You can use this class to take advantage of the Struts controller and its functionality, without having to rewrite the existing Servlets. Use ForwardAction to forward a request to another resource in your application, such as a Servlet that already does business logic processing or even another JSP page. By using this predefined action, you don’t have to write your own Action class. You just have to set up the struts-config file properly to use ForwardAction.

Q)What is IncludeAction?
The IncludeAction class is useful when you want to integrate Struts into an application that uses Servlets. Use the IncludeAction class to include another resource in the response to the request being processed.

Q) What is LookupDispatchAction?
The LookupDispatchAction is a subclass of DispatchAction. It does a reverse lookup on the resource bundle to get the key and then gets the method whose name is associated with the key into the Resource Bundle.LookupDispatchAction is useful if the method name in the Action is not driven by its name in the front end, but by the Locale independent key into the resource bundle. Since the key is always the same, the LookupDispatchAction shields your application from the side effects of I18N.

Q) What is difference between LookupDispatchAction and DispatchAction?
The difference between LookupDispatchAction and DispatchAction is that the actual method that gets called in LookupDispatchAction is based on a lookup of a key value instead of specifying the method name directly.

Q) What is SwitchAction?
The SwitchAction class provides a means to switch from a resource in one module to another resource in a different module. SwitchAction is useful only if you have multiple modules in your Struts application. The SwitchAction class can be used as is, without extending.

Q) What is DynaActionForm?
A specialized subclass of ActionForm that allows the creation of form beans with dynamic sets of properties (configured in configuration file), without requiring the developer to create a Java class for each type of form bean.

Q) What are the steps need to use DynaActionForm?
Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward. You need to make changes in two places:

In struts-config.xml: change your

to be an org.apache.struts.action.DynaActionForm instead of some subclass of ActionForm
<form-bean name="loginForm"type="org.apache.struts.action.DynaActionForm" >

<form-property name="userName" type="java.lang.String"/>
<form-property name="password" type="java.lang.String" />
</form-bean>

In your Action subclass that uses your form bean:
import org.apache.struts.action.DynaActionForm
downcast the ActionForm parameter in execute() to a DynaActionForm
access the form fields with get(field) rather than getField()

Q) How to display validation errors on jsp page?
<html:errors/> tag displays all the errors. <html:errors/> iterates over ActionErrors request attribute.

Q) What are the various Struts tag libraries?
The various Struts tag libraries are:

HTML Tags
Bean Tags
Logic Tags
Template Tags
Nested Tags
Tiles Tags

Q) What is the use of logic:iterate?
logic:iterate> repeats the nested body content of this tag over a specified collection.

< table border=1>
< logic:iterate id="customer" name="customers">
< tr>
< td>< bean:write name="customer" property="firstName"/>< /td>
< td>< bean:write name="customer" property="lastName"/>< /td>
< td>< bean:write name="customer" property="address"/>< /td>
< /tr>
< /logic:iterate>
< /table>

Q) What are differences between bean:message and bean:write
< bean:message>: is used to retrive keyed values from resource bundle. It also supports the ability to include parameters that can be substituted for defined placeholders in the retrieved string.

< bean:message key="prompt.customer.firstname"/>

< bean:write>: is used to retrieve and print the value of the bean property. has no body.

< bean:write name="customer" property="firstName"/>

Q) How the exceptions are handled in struts?
Exceptions in Struts are handled in two ways:

Programmatic exception handling : Explicit try/catch blocks in any code that can throw exception. It works well when custom value (i.e., of variable) needed when error occurs.

Declarative exception handling :You can either define handling tags in your struts-config.xml or define the exception handling tags within tag. It works well when custom page needed when error occurs. This approach applies only to exceptions thrown by Actions.

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

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

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

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

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

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

Q) How can we make message resources definitions file available to the Struts framework environment?
We can make message resources definitions file (properties file) available to Struts framework environment by adding this file to struts-config.xml.

< message-resources parameter="com.login.struts.ApplicationResources"/>

Q) What is the life cycle of ActionForm?
The lifecycle of ActionForm invoked by the RequestProcessor is as follows:

Retrieve or Create Form Bean associated with Action
"Store" FormBean in appropriate scope (request or session)
Reset the properties of the FormBean
Populate the properties of the FormBean
Validate the properties of the FormBean
Pass FormBean to Action

Servlet interview questions with answers

noreply@blogger.com (LakshmiNarayana Gorantla) — Tue, 01 Nov 2011 05:58:40 PDT

What is the servlet?
Servlets are modules that extend request/response-oriented servers, such as Java-enabled web servers. For example, a servlet may be responsible for taking data in an HTML order-entry form and applying the business logic used to update a company's order database.
-Servlets are used to enhance and extend the functionality of Webserver.
Servlets handles Java and HTML separately.

What are the uses of Servlets?
A servlet can handle multiple requests concurrently, and can synchronize requests. This allows servlets to support systems such as on-line conferencing. Servlets can forward requests to other servers and servlets. Thus servlets can be used to balance load among several servers that mirror the same content, and to partition a single logical service over several servers, according to task.

What are the characters of Servlet?
As Servlet are written in java, they can make use of extensive power of the JAVA API,such as networking and URL access,multithreading,databaseconnectivity,RMI object serialization.
Efficient : The initilazation code for a servlet is executed only once, when the servlet is executed for the first time.
Robest : provide all the powerfull features of JAVA, such as Exception handling and garbage collection.
Portable: This enables easy portability across Web Servers.
Persistance : Increase the performance of the system by executing features data access.

What is the difference between JSP and SERVLETS
Servlets : servlet tieup files to independitently handle the static presentation logic and dynamic business logic , due to this a changes made to any file requires recompilation of the servlet.
- The servlet is Pre-Compile.

JSP : Facilities segregation of work profiles to Web-Developer and Web-Designer , Automatically incorporates changes made to any file (PL & BL) , no need to recompile.
Web-Developer write the code for Bussiness logic whereas Web-Designer designs the layout for the WebPage by HTML & JSP.
- The JSP is Post-Compile.

What are the advantages using servlets than using CGI?
Servlets provide a way to generate dynamic documents that is both easier to write and faster to run. It is efficient, convenient, powerful, portable, secure and inexpensive. Servlets also address the problem of doing server-side programming with platform-specific APIs. They are developed with Java Servlet API, a standard Java extension.

What is the difference between servlets and applets?
Servlets are to servers. Applets are to browsers. Unlike applets, however, servlets have no graphical user interface.

What is the difference between GenericServlet and HttpServlet?
GenericServlet is for servlets that might not use HTTP, like for instance FTP service.As of only Http is implemented completely in HttpServlet. The GenericServlet has a service() method that gets called when a client request is made. This means that it gets called by both incoming requests and the HTTP requests are given to the servlet as they are.
GenericServlet belongs to javax.servlet package
GenericServlet is an abstract class which extends Object and implements Servlet, ServletConfig and java.io.Serializable interfaces.
The direct subclass to GenericServlet is HttpServlet.It is a protocol-independent servlet

What are the differences between GET and POST service methods?
Get Method : Uses Query String to send additional information to the server.
-Query String is displayed on the client Browser.
Query String : The additional sequence of characters that are appended to the URL ia called Query String. The length of the Query string is limited to 255 characters.
-The amount of information you can send back using a GET is restricted as URLs can only be 1024 characters.

POST Method : The Post Method sends the Data as packets through a separate socket connection. The complete transaction is invisible to the client. The post method is slower compared to the Get method because Data is sent to the server as separate packates.
--You can send much more information to the server this way - and it's not restricted to textual data either. It is possible to send files and even binary data such as serialized Java objects!
What is the servlet life cycle?
In Servlet life cycles are,
init(),services(),destory().
Init( ) : Is called by the Servlet container after the servlet has ben Instantiated.
--Contains all information code for servlet and is invoked when the servlet is first loaded.
-The init( ) does not require any argument , returns a void and throws Servlet Exception.
-If init() executed at the time of servlet class loading.And init() executed only for first user.
-You can Override this method to write initialization code that needs to run only once, such as loading a driver , initializing values and soon, Inother case you can leave normally blank.
Public void init(ServletConfig Config) throws ServletException

Service( ) : is called by the Servlet container after the init method to allow the servlet to respond to a request.
-Receives the request from the client and identifies the type of request and deligates them to doGet( ) or doPost( ) for processing.
Public void service(ServletRequest request,ServletResponce response) throws ServletException, IOException

Destroy( ) : The Servlet Container calls the destroy( ) before removing a Servlet Instance from Sevice.
-Excutes only once when the Servlet is removed from Server.
Public void destroy( )

If services() are both for get and post methods.
-So if u want to use post method in html page,we use doPost() or services() in servlet class.
-if want to use get methods in html page,we can use doGet() or services() in servlet calss.
-Finally destory() is used to free the object.

What is the difference between ServletContext and ServletConfig?
Both are interfaces.
Servlet Config():The servlet engine implements the ServletConfig interface in order to pass configuration information to a servlet. The server passes an object that implements the ServletConfig interface to the servlet's init() method.
A ServletConfig object passes configuration information from the server to a servlet. ServletConfig also includes ServletContext object.
getParameter( ) , getServletContext( ) , getServletConfig( ), GetServletName( )

Servlet Context(): The ServletContext interface provides information to servlets regarding the environment in which they are running. It also provides standard way for servlets to write events to a log file.
ServletContext defines methods that allow a servlet to interact with the host server. This includes reading server-specific attributes, finding information about particular files located on the server, and writing to the server log files. I f there are several virtual servers running, each one may return a different ServletContext.
getMIMEType( ) , getResourse( ), getContext( ),getServerInfo( ),getServletContetName( )
11. Can I invoke a JSP error page from a servlet?
Yes, you can invoke the JSP error page and pass the exception object to it from within a servlet. The trick is to create a request dispatcher for the JSP error page, and pass the exception object as a javax.servlet.jsp.jspException request attribute. However, note that you can do this from only within controller servlets.

Can I just abort processing a JSP?
Yes.Because your JSP is just a servlet method,you can just put (whereever necessary) a < % return; %>

What is a better approach for enabling thread-safe servlets and JSPs? SingleThreadModel Interface or Synchronization?
Although the SingleThreadModel technique is easy to use, and works well for low volume sites, it does not scale well. If you anticipate your users to increase in the future, you may be better off implementing explicit synchronization for your shared data. The key however, is to effectively minimize the amount of code that is synchronzied so that you take maximum advantage of multithreading.
Also, note that SingleThreadModel is pretty resource intensive from the server's perspective. The most serious issue however is when the number of concurrent requests exhaust the servlet instance pool. In that case, all the unserviced requests are queued until something becomes free - which results in poor performance. Since the usage is non-deterministic, it may not help much even if you did add more memory and increased the size of the instance pool.

If you want a servlet to take the same action for both GET and POST request, what should you do?
Simply have doGet call doPost, or vice versa.

Which code line must be set before any of the lines that use the PrintWriter?
setContentType() method must be set before transmitting the actual document.

How HTTP Servlet handles client requests?
An HTTP Servlet handles client requests through its service method. The service method supports standard HTTP client requests by dispatching each request to a method designed to handle that request.

What is the Servlet Interface?
The central abstraction in the Servlet API is the Servlet interface. All servlets implement this interface, either directly or, more commonly, by extending a class that implements it such as HttpServlet.
Servlets-->Generic Servlet-->HttpServlet-->MyServlet.
The Servlet interface declares, but does not implement, methods that manage the servlet and its communications with clients. Servlet writers provide some or all of these methods when developing a servlet.

When a servlet accepts a call from a client, it receives two objects. What are they?
ServeltRequest: which encapsulates the communication from the client to the server.
ServletResponse: which encapsulates the communication from the servlet back to the
Client.
ServletRequest and ServletResponse are interfaces defined by the javax.servlet package.

What information that the ServletRequest interface allows the servlet access to?
Information such as the names of the parameters passed in by the client, the protocol (scheme) being used by the client, and the names of the remote host that made the request and the server that received it. The input stream, ServletInputStream.Servlets use the input stream to get data
from clients that use application protocols such as the HTTP POST and PUT methods.

What information that the ServletResponse interface gives the servlet methods for replying to the client?
It Allows the servlet to set the content length and MIME type of the reply. Provides an output stream, ServletOutputStream and a Writer through which the servlet can send the reply data.

Difference between single thread and multi thread model servlet
A servlet that implements SingleThreadModel means that for every request, a single servlet instance is created. This is not a very scalable solution as most web servers handle multitudes of requests. A multi-threaded servlet means that one servlet is capable of handling many requests which is the way most servlets should be implemented.
a. A single thread model for servlets is generally used to protect sensitive data ( bank account operations ).
b. Single thread model means instance of the servlet gets created for each request recieved. Its not thread safe whereas in multi threaded only single instance of the servlet exists for what ever # of requests recieved. Its thread safe and is taken care by the servlet container.
c. A servlet that implements SingleThreadModel means that for every request, a single servlet instance is created. This is not a very scalable solution as most web servers handle multitudes of requests. A multi-threaded servlet means that one servlet is capable of handling many requests which is the way most servlets should be implemented.

A single thread model for servlets is generally used to protect sensitive data ( bank account operations ).

What is servlet context and what it takes actually as parameters?
Servlet context is an object which is created as soon as the Servlet gets initialized.Servlet context object is contained in Servlet Config. With the context object u can get access to specific
resource (like file) in the server and pass it as a URL to be displayed as a next screen with the help of RequestDispatcher
eg :-
ServletContext app = getServletContext();
RequestDispatcher disp;
if(b==true)
disp = app.getRequestDispatcher
("jsp/login/updatepassword.jsp");
else
disp = app.getRequestDispatcher
("jsp/login/error.jsp");
this code will take user to the screen depending upon the value of b.
in ServletContext u can also get or set some variables which u would
like to retreive in next screen.
eg
context.setAttribute("supportAddress", "temp@temp.com");
Better yet, you could use the web.xml context-param element to
designate the address, then read it with the getInitParameter method
of ServletContext.

Can we call destroy() method on servlets from service method?
destroy() is a servlet life-cycle method called by servlet container to kill the instance of the servlet. "Yes". You can call destroy() from within the service(). It will do whatever logic you have in destroy() (cleanup, remove attributes, etc.) but it won't "unload" the servlet instance itself. That can only be done by the container
What is the use of ServletConfig and ServletContext..?
An interface that describes the configuration parameters for a servlet. This is passed to the servlet when the web server calls its init() method. Note that the servlet should save the reference to the ServletConfig object, and define a getServletConfig() method to return it when asked. This interface defines how to get the initialization parameters for the servlet and the context under which the servlet is running.
An interface that describes how a servlet can get information about the server in which it is running. It can be retrieved via the getServletContext() method of the ServletConfig object.

What is difference between forward() and sendRedirect().. ? Which one is faster then other and which works on server?
Forward( ) : javax.Servlet.RequestDispatcher interface.
-RequestDispatcher.forward( ) works on the Server.
-The forward( ) works inside the WebContainer.
-The forward( ) restricts you to redirect only to a resource in the same web-Application.
-After executing the forward( ), the control will return back to the same method from where the forward method was called.
-the forward( ) will redirect in the application server itself, it does’n come back to the client.
- The forward( ) is faster than Sendredirect( ) .
To use the forward( ) of the requestDispatcher interface, the first thing to do is to obtain RequestDispatcher Object. The Servlet technology provides in three ways.
1. By using the getRequestDispatcher( ) of the javax.Servlet.ServletContext interface , passing a String containing the path of the other resources, path is relative to the root of the ServletContext.

RequestDispatcher rd=request.getRequestDispatcher(“secondServlet”);
Rd.forward(request, response);

2. getRequestDispatcher( ) of the javax.Servlet.Request interface , the path is relative to current HtpRequest.
RequestDispatcher rd=getServletContext( ).getRequestDispatcher(“servlet/secondServlet”);
Rd.forward(request, response);

3. By using the getNameDispatcher( ) of the javax.Servlet.ServletContext interface.
RequestDispatcher rd=getServletContext( ).getNameDispatcher(“secondServlet”);
Rd.forward(request, response);

Sendredirect( ) : javax.Servlet.Http.HttpServletResponce interface
-RequestDispatcher.SendRedirect( ) works on the browser.
-The SendRedirect( ) allows you to redirect trip to the Client.
-The SendRedirect( ) allows you to redirect to any URL.
-After executing the SendRedirect( ) the control will not return back to same method.
-The Client receives the Http response code 302 indicating that temporarly the client is being redirected to the specified location , if the specified location is relative , this method converts it into an absolute URL before redirecting.

-The SendRedirect( ) will come to the Client and go back,.. ie URL appending will happen.
Response. SendRedirect( “absolute path”);
Absolutepath – other than application , relative path - same application.

When you invoke a forward request, the request is sent to another resource on the server, without the client being informed that a different resource is going to process the request. This process occurs completely with in the web container. When a sendRedirtect method is invoked, it causes the web container to return to the browser indicating that a new URL should be requested. Because the browser issues a completely new request any object that are stored as request attributes before the redirect occurs will be lost. This extra round trip a redirect is slower than forward.

do we have a constructor in servlet ? can we explictly provide a constructor in servlet programme as in java program ?
We can have a constructor in servlet .

Session : A session is a group of activities that are performed by a user while accesing a particular website.
Session Tracking :The process of keeping track of settings across session is called session tracking.
Hidden Form Fields : Used to keep track of users by placing hidden fields in the form.
-The values that have been entered in these fields are sent to the server when the user submits the Form.
URL-rewriting : this is a technique by which the URL is modified to include the session ID of a particular user and is sent back to the Client.
-The session Id is used by the client for subsequent transactions with the server.
Cookies : Cookies are small text files that are used by a webserver to keep track the Users.
A cookie is created by the server and send back to the client , the value is in the form of Key-value pairs. Aclient can accept 20 cookies per host and the size of each cookie can be maximum of 4 bytes each.
HttpSession : Every user who logs on to the website is autometacally associated with an HttpSession Object.
-The Servlet can use this Object to store information about the users Session.
-HttpSession Object enables the user to maintain two types of Data.
ie State and Application.

How to communicate between two servlets?
Two ways:
a. Forward or redirect from one Servlet to another.
b. Load the Servlet from ServletContext and access methods.
29. How to get one Servlet's Context Information in another Servlet?
Access or load the Servlet from the Servlet Context and access the Context Information

JDBC FAQS

noreply@blogger.com (LakshmiNarayana Gorantla) — Tue, 18 Oct 2011 02:13:46 PDT

What is JDBC?
Ans: JDBC is a set of Java API for executing SQL statements. This API consists of a set of classes and interfaces to Java Database applications. The database vendors like Oracle,MySql ,TeraData ….are provided the implementations for some of the classes in JDBC API.

What are drivers available?
Ans: Type 1- JDBC-ODBC Bridge driver
Type 2- Native API Partly-Java driver
Type 3 -JDBC-Net Pure Java driver
Type 4 -Native-Protocol Pure Java driver

What is the difference between JDBC and ODBC?
Ans: a) ODBC(Open Data Base Connectivity) is for Microsoft and JDBC is for Java applications.
b) ODBC can’t be directly used with Java because it uses a C interface.
c) ODBC makes use of pointers which have been removed totally from Java.
d) ODBC mixes simple and advanced features together and has complex options for simple queries. But JDBC is designed to keep things simple while allowing advanced capabilities when required.
e) ODBC requires manual installation of the ODBC driver manager and driver on all client machines. JDBC drivers are written in Java and JDBC code is automatically installable, secure, and portable on all platforms.
f) JDBC API is a natural Java interface and is built on ODBC. JDBC retains some of the basic features of ODBC.

What are the types of JDBC Driver Models and explain them?
Ans: There are two types of JDBC Driver Models and they are:
a) Two tier model and b) Three tier model
Two tier model: In this model, Java applications interact directly with the database. A JDBC driver is required to communicate with the particular database management system that is being accessed. SQL statements are sent to the database and the results are given to user. This model is referred to as client/server configuration where user is the client and the machine that has the database is called as the server.
Three tier model: A middle tier is introduced in this model. The functions of this model are:
a) Collection of SQL statements from the client and handing it over to the database,
b) Receiving results from database to the client and
c) Maintaining control over accessing and updation of the above.

What are the steps involved for making a connection with a database or how do you connect to a database?
Ans:
a) Loading the driver : To load the driver, Class.forName( ) method is used.
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
When the driver is loaded, it registers itself with the java.sql.DriverManager class as an available database driver.
b) Making a connection with database : To open a connection to a given database,
DriverMnaager.getConnection( ) method is used.
Connection con = DriverManager.getConnection(“jdbc:odbc:somedb”, “user”, ”password”);
c) Executing SQL statements : To execute a SQL query, java.sql.statements class is used.
createStatement( ) method of Connection to obtain a new Statement object.
Statement stmt = con.createStatement( );
A query that returns data can be executed using the executeQuery( ) method of Statement. This method
executes the statement and returns a java.sql.ResultSet that encapsulates the retrieved data:
ResultSet rs = stmt.executeQuery(“SELECT * FROM some table”);
d) Process the results : ResultSet returns one row at a time. Next( ) method of ResultSet object can be called to move to the next row. The getString( ) and getObject( ) methods are used for retrieving column values:
while(rs.next( ) ) {
String event = rs.getString(“event”);
Object count = (Integer) rs.getObject(“count”);

What type of driver did you use in project?
Ans: JDBC-ODBC Bridge driver (is a driver that uses native(C language) libraries and makes calls to an existing ODBC driver to access a database engine).

What are the types of statements in JDBC?
Ans: Statement -- To be used createStatement( ) method for executing single SQL statement
PreparedStatement -- To be used preparStatement( ) method for executing same SQL statement over and over.
CallableStatement -- To be used prepareCall( ) method for multiple SQL statements over and over

What is stored procedure?
Ans: Stored procedure is a group of SQL statements that forms a logical unit and performs a particular task. Stored Procedures are used to encapsulate a set of operations or queries to execute on database. Stored procedures can be compiled and executed with different parameters and results and may have any combination of input/output parameters.

How to create and call stored procedures?
Ans: To create stored procedures:
Create procedure procedure name (specify in, out and in out parameters)
BEGIN
Any multiple SQL statement;
END;

To call stored procedures:
CallableStatement csmt = con.prepareCall(“{call procedure name(?,?)}”);
csmt.registerOutParameter(column no., data type);
csmt.setInt(column no., column name)
csmt.execute( );

What are the differences between executeQuery(…), executeUpdate(…) and execute(…) methods?
Ans:
public ResultSet executeQuery(String sqlquery)

where executeQuery() can be used to execute selection group sql queries to fetch the data from database.When we use selection group sql query with executeQuery() then JVM will send that sql query to the database engine, database engine will execute it, by this database engine(DBE) will fetch the data from database and send back to the java application.

public int executeUpdate(String sqlquery)

where executeUpdate() can be used to execute updation group sql query to update the database. When we provide updation group sql query as a parameter to executeUpdate(), then JVM will send that sql query to DBE, here DBE will execute it and perform updations on the database, by this DBE will identify the number of records got updated value called as “records updated count” and return back to the java application.

public boolean execute(String sqlquery)

where execute() can be used to execute either selection group sql queries or updation group queries. But this method is renturn value is Boolean to get the ResultSet object to call the statement.get ResultSet() method . If we want to get Update count we have to use the statement.getUpdateCount() method.

What is a transaction ?
transaction is collection of logical operation that perform a task
Transaction should ACID properties.
A for Automicity
C for Consistency
I for Isolation
D for Durability.
A transaction can be termed as any operation such as storing, retrieving, updating or deleting records in the table that hits the database.

What is the purpose of setAutoCommit( )
It is set as ConnectionObject.setAutoComit(boolean val);
after any updates through the program cannot be effected to the database.We have to commit the transctions then only it reflect on Database .For this puprpose we can set AutoCommit flag to Connection Object.

Online Java Training

noreply@blogger.com (LakshmiNarayana Gorantla) — Tue, 25 Sep 2012 18:34:59 PDT

This is LakshmiNarayana Gorantla. I am sun certified java programmer.

I am having 5 years of IT experience, Involved in developing the Software applications using

Java, J2ee and related frameworks like Struts, Spring, Hibernate. Good experience in XML and

Web Services.

I am providing Certification level Online training courses on below technologies.

Core Java,

JDBC,

Servlets,

JSP,

RMI,

EJB

Struts,

Hibernate,

Spring,

XML,

Web Services.

We will provide the certificate from our end at the end of the course.

If anyone interested Please mail me laxman.scjp@gmail.com or call me on 9885 9883 11.

Thanks.....

My own ConnectionPool implementation

noreply@blogger.com (LakshmiNarayana Gorantla) — Fri, 09 Jul 2010 22:49:26 PDT

By seeing this example we can get the two things

1- how to implement our own connection
2-why sun gives wait , notify methods in object class.

import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Vector;
public class MyConnectionPool {
Vector connections= null;
static MyConnectionPool instance=null;
public static final int MAX_CONNECTIONS=10;

//removeAllConnections objects
public synchronized void removeAllConnections() {
if (connections==null) {
return;
}
try {
int sz= connections.size();
for (int i=0; i < sz/2; i++) {
Connection c= (Connection) connections.elementAt(i);
c= null;
connections.remove(i);
}
if (connections!= null && connections.size() > 0) {
connections.removeAllElements();
}
connections= null;
}catch (Exception e) {
System.out.println( "Error "+ e);
}
instance =null;
}

//getInstance...
public static MyConnectionPool getInstance() {
if (instance ==null)
instance= new MyConnectionPool();
return instance;
}

//initializing all connections upto max limit i.e upto 10 connections...
public synchronized void initialize() {
if (connections ==null) {
try {
Class.forName(" com.mysql.jdbc.Driver ");
connections= new Vector();
int count =0;
while (count < MAX_CONNECTIONS) {
Connection connection=DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe","scott","tiger");
connections.addElement(connection);
count++;
}
System.out.println( "total connections created r:" + count);
} catch (Exception e) {
System.out.println( "initialise:Exception ");
e.printStackTrace();
instance.removeAllConnections();
initialize();
}
}
}
//getting connection....
public synchronized Connection getConnection() {
System.out.println( "getConnection ");
Connection c =null;
System.out.println("connections"+connections.size());
if (connections== null)
return null;
if (connections.size() > 0) {
System.out.println("i am in if");
c =(Connection) connections.elementAt(0);
connections.removeElementAt(0);
}else
{
System.out.println("i am in else");
try {
wait();
c =(Connection) connections.elementAt(0);
connections.removeElementAt(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return c;
}
//put connection obj into vector.
public synchronized void putConnection(Connection c) {
if (c != null) {
connections.addElement(c);
notifyAll();
}
}
}

Java Tutorial with Examples Home Page

noreply@blogger.com (LakshmiNarayana Gorantla) — Sat, 04 Jul 2009 02:56:08 PDT

Fundamentals
-------------------------------------------------------------------------------------------------------------------
DataTypes                             Identifiers                        Literals                        JavaKeyords

Variable                                Arrays                                Operators                   TypeCasting

FlowControl                        Coding Standards           imports,package      mainMethod,args

Access Modifiers                var-argMethod               AbstructClass          GarbageCollection

InnerClass                            Interface                           Assertions                java execution flow

super,this

java.lang
-------------------------------------------------------------------------------------------------------------------
Class,Object Classes          Enum                                  String                          StringBuffer,StringBuilder

Cloneable,Comparable      Wrapper Classes           Math class                Autoboxing,Autounboxing

System class

OOPS
-------------------------------------------------------------------------------------------------------------------
class,object                          Encapsulation                 Abstraction              Inheritance

Method Overloading        Method Overriding      Constructors

Collections
-------------------------------------------------------------------------------------------------------------------
All List Classes                   All Set Classes                   All Map Classes       Collections Class

Iterator,ListIterator        Comparator                        Generics                  Timer,TimerTask

StringTokenizer              Locale class

Exceptions
-------------------------------------------------------------------------------------------------------------------
DefaultException             Checked,UnChecked      try,catch,finally      throw , throws
Handler

Threads
-------------------------------------------------------------------------------------------------------------------
Thread Creation               Thread Class Methods      Synchronization     wait,notify,notifyAll

Daemon Threads              Thread group                     Thread Deadlock

java.io
-------------------------------------------------------------------------------------------------------------------
File                                         All Reader Classes          All Writer Classes       All Stream Classes

Serialization

servlet-interface

noreply@blogger.com (LakshmiNarayana Gorantla) — Wed, 08 Jul 2009 05:23:25 PDT

In javax.servlet.Servlet Interface contains the following methods:

public void init (Servletconfig config) throws ServletException.

This method called by servlet container to indicate to a servlet that the servlet is being placed into the service.
The init () method called by servlet container exactly once after instantiating the servlet.
We can override init () method if we have initialization code like getting database connection.
The servlet container can not place the servlet into service of the init () methods.

In the following situation the web container destroys that servlet object.
If it throws a servlet exception
If it doesn't return with in a time period defined by the web server.

public void service (servlet Request req, Servlet Response res) throws ServletException, IOException :

Called by servlet container to allow to respond to the client request.
It should be called after the servlet’s init()method completion

public void destroy() :

The servlet container call the destroy () method before removing a servlet instance from service.
This normally happens when the servlet container is shut down of the servlet container needs some free memory.
This method is only called once all the thread with in the servlet service () method have exited.
We can keep cleanup code inside destroy () method.

public servlet config getservletconfig() :
It returns servlet config object which contain initialization and start of information of the servlet object.

public string getServletInfo() :
It returns a string containing information about the servlet such as author version and copy right.

Sample servlet program by implement Servlet interface :

import javax.servlet.*;
import java.io.*;
class BasicServlet implements Servlet
{
public void init ()(Servlet config conf) throws ServletException
{
System.out.println (“input method”);
}

public void service (ServletRequest req, ServletResponse res) throws ServletException, IOException
{
System.out.println (“service method”);
}

public void destroy ()
{
System.out.println (“destroy method”);
}

public ServletConfig getServletConfig ()
{
return null;
}

public String getServletInfo ()
{
return null;
}

public String getServletInfo ()
{
return null;
}
}

javax servlet package

noreply@blogger.com (LakshmiNarayana Gorantla) — Wed, 01 Jul 2009 04:32:26 PDT

Javax.servlet: It defines several basic classes and interfaces to build servlets from the scratch irrespective of any protocol.
Javax.servlet.http: This package contain several more convenient classes and interfaces (which extends classes and interfaces of javax.servlet package) to build servlets specific to http. It also contain several extra utility classes and interfaces like cookies http session(interface for developing web applications efficiently.

JAVAX.SERVLET PACKAGE:
This package contains the following important interfaces:
1.Servlet Interface: It defines several methods which must be implemented by every servlet in java either directly or indirectly.
- this is the interface which define life cycle methods of interface.
2.Servlet Request : The servlet Request object contain client information which can be used by servlet to generate response.
3.Servlet Response : servlet response object contain the response which can sent to the client . ex:servlet uses servlet response object it send response to the client.
4.Servlet config : it contains the configuration or deployment information of start up information of the servlet.Web container creates a separate servlet and pass configuration information to the server by using this object.
5.Servlet context : Servlet context in the object which can be used by servlet to communicate with web server.For every web application one servlet context object will create by using the servlet context object servlet can get servlet context object.
6. Request Dispatcher: This object can be used by servlet to redirect the requests for another web component (servlet/jsp). This interface contain forward and include methods.
7. Single Thread Model: This interface can be implementing by servlet to generate that it can process only one request at a time.This is the deprecated interface and there is no replacement control 2.4. version.It does not contain any methods. So this is a MARKER INTERFACE.

These packages contain the following important classes.

GenericServlet: to implement Generic protocol independent servlets.
ServletInputStream: provides an input stream for reading binary data from a client request.
ServletOutputStream: provides an output stream for reading binary data from a client request.This package defined the following Exception
ServletException: Defines a general Exception. A servlet can throw when it fare some difficulty whose processing client request.
UnavailableException: Defines an Exception that a servlet throws to indicate that the servlet is unavailable permanently or temporally.

Serialization Inheritence

noreply@blogger.com (LakshmiNarayana Gorantla) — Thu, 04 Jun 2009 05:44:52 PDT

Serialization in case of Inheritence:
class Animal implements Serializable
{
int i=10;
}
class Dog extends Animal
{
int j=20;

}

When ever we are adding a child class object to a file ,parent class object will not save to the file .Because parent class objects are not part of state of the child class object.

If any variable is inherited from the perent that variable will also add to the file as a part of child class object.

example:

class SerialDemo

{
public static void main(String arg[])
{
Dog d=new Dog();
System.out.println(d.i+”……..”+d.j);

FileOutputStream fos=new FileOutputStream(“abc.txt”);
ObjectOutputStream oos=new ObjectOutputStream(fos);
Oos.writeObject(d);
FileInputStream fis=new FileInputStream(“abc.txt’);
ObjectInputStream ois=new ObjectInputStream(fis);
Dog d1=9Dog)ois.readObject();
System.out.println(d.i+”……..”+d.j);
}
}

If the parent class is serializable by default every child class is also serializable.
If we are writing any servlet by extending GenericServlet or HttpServlet it is always Serializable because GenericServlet already implements serializable interface

Note: By just simply seeing a class we can’t tell whether it is serializable or not .We have to check any parent class of this class of this class is serializable or not .If none of the parent class is not serializable then then only we can decode the given class is not serializable.

Serialization in case of Inheritence example:

class Animal
{
int i=10;
}
class Dog extends Animal implements serializable
{
int j=20;
}
class SerialDemo
{
public static void main(String arg[])throws Exception
{
Dog d=new Dog();
d.i=1000;
d.j=2000;

FileOutputStream fos=new FileOutputStream(“abc.txt”);
ObjectOutputStream oos=new ObjectOutputStream(fos);
Oos.writeObject(d);
FileInputStream fis=new FileInputStream(“abc.txt’);
ObjectInputStream ois=new ObjectInputStream(fis);
Dog d1=9Dog)ois.readObject();
System.out.println(d.i+”……..”+d.j);
}
}

If the child class is serializable and the parent is non serializable still we are allowed to save the child class objects to the file.
If any variable is inherited from the non-serializable parent its value is not allowed to save to the file as its corresponding class is non- serializable.
Instead of original value ,default values will save to the file.
At the time of de serialization to perform initialization for instance variable which are inherited from non- serializable parents its objects will create .After creation of parent class object ,the values of inherited values will be assigned.
At the time of deserialization of an object if any variable is inherited from non- serializable parent then the JVM creates parent class object by calling default no argument constructor.
If the parent class doesn’t contain any no argument constructor we can get a RTE saying Java.io.invalidClassException Dog :novalid constructor.

jdbc-data-types-tutorial

noreply@blogger.com (LakshmiNarayana Gorantla) — Wed, 20 May 2009 23:10:04 PDT

Data Types and Conversions :
For the getXXX methods, the JDBC driver attempts to convert the underlying data to the specified Java type and then returns a suitable Java value. For example, if the getXXX method is getString, and the data type of the data in the underlying database is VARCHAR, the JDBC driver will convert VARCHAR to Java String. The return value of getString will be a Java String object.

The following table shows which JDBC types a getXXX method is allowed to retrieve and which JDBC types (generic SQL types) are recommended for it to retrieve. A small x indicates a legal getXXX method for a particular data type; a large X indicates the recommended getXXX method for a data type. For example, any getXXX method except getBytes or getBinaryStream can be used to retrieve the value of a LONGVARCHAR, but getAsciiStream or getUnicodeStream are recommended, depending on which data type is being returned.

The method getObject will return any data type as a Java Object and is useful when the underlying data type is a database-specific abstract type or when a generic application needs to be able to accept any data type.

Use of ResultSet.getXXX methods to retrieve common JDBC data types.
An "x" indicates that the getXXX method may legally be used to retrieve the given JDBC type.

An "X" indicates that the getXXX method is recommended for retrieving the given JDBC type

Using Streams for Very Large Row Values :
ResultSet makes it possible to retrieve arbitrarily large LONGVARBINARY or LONGVARCHAR data. The methods getBytes and getString return data as one large chunk (up to the limits imposed by the return value of Statement.getMaxFieldSize). However, it may be more convenient to retrieve very large data in smaller, fixed-size chunks. This is done by having the ResultSet class return java.io.Input streams from which data can be read in chunks. Note that these streams must be accessed immediately because they will be closed automatically on the next getXXX call on ResultSet. (This behavior is imposed by underlying implementation constraints on large blob access.)

The JDBC API has three separate methods for getting streams, each with a different return value:

getBinaryStream returns a stream which simply provides the raw bytes from the database without any conversion.
getAsciiStream returns a stream which provides one-byte ASCII characters.
getUnicodeStream returns a stream which provides two-byte Unicode characters.

Note that this differs from Java streams, which return untyped bytes and can (for example) be used for both ASCII and Unicode characters.

The following code gives an example of using getAsciiStream:

java.sql.Statement stmt = con.createStatement();
ResultSet r = stmt.executeQuery("SELECT x FROM Table2");
// Now retrieve the column 1 results in 4 K chunks:
byte buff = new byte[4096];
while (r.next()) {
Java.io.InputStream fin = r.getAsciiStream(1);
for (;;) {
int size = fin.read(buff);
if (size == -1) { // at end of stream
break;
}
// Send the newly-filled buffer to some ASCII output stream:
output.write(buff, 0, size);
}
}

JDBC-Result-Set

noreply@blogger.com (LakshmiNarayana Gorantla) — Wed, 15 Apr 2009 18:30:44 PDT

ResultSet :
A ResultSet contains all of the rows which satisfied the conditions in an SQL statement, and it provides access to the data in those rows through a set of get methods that allow access to the various columns of the current row. The ResultSet.next method is used to move to the next row of the ResultSet, making the next row become the current row.
The general form of a result set is a table with column headings and the corresponding values returned by a query. For example, if your query is SELECT a, b, c FROM Table1, your result set will have the following form:

The following code fragment is an example of executing an SQL statement that will return a collection of rows, with column 1 as an int, column 2 as a String, and column 3 as an array of bytes:

java.sql.Statement stmt = conn.createStatement();
ResultSet r = stmt.executeQuery("SELECT a, b, c FROM Table1");
while (r.next())
{
// print the values for the current row.
int i = r.getInt("a");
String s = r.getString("b");
float f = r.getFloat("c");
System.out.println("ROW = " + i + " " + s + " " + f);
}

Rows and Cursors
A ResultSet maintains a cursor which points to its current row of data. The cursor moves down one row each time the method next is called. Initially it is positioned before the first row, so that the first call to next puts the cursor on the first row, making it the current row. ResultSet rows are retrieved in sequence from the top row down as the cursor moves down one row with each successive call to next. A cursor remains valid until the ResultSet object or its parent Statement object is closed.

In SQL, the cursor for a result table is named. If a database allows positioned updates or positioned deletes, the name of the cursor needs to be supplied as a parameter to the update or delete command. This cursor name can be obtained by calling the method getCursorName.

Note that not all DBMSs support positioned update and delete. The DatabaseMetaData.supportsPositionedDelete and supportsPositionedUpdate methods can be used to discover whether a particular connection supports these operations. When they are supported, the DBMS/driver must ensure that rows selected are properly locked so that positioned updates do not result in update anomalies or other concurrency problems.

Columns :
The getXXX methods provide the means for retrieving column values from the current row. Within each row, column values may be retrieved in any order, but for maximum portability, one should retrieve values from left to right and read column values only once.

Either the column name or the column number can be used to designate the column from which to retrieve data. For example, if the second column of a ResultSet object rs is named "title" and stores values as strings, either of the following will retrieve the value stored in that column:

String s = rs.getString("title");
String s = rs.getString(2);

Note that columns are numbered from left to right starting with column 1. Also, column names used as input to getXXX methods are case insensitive.
The option of using the column name was provided so that a user who specifies column names in a query can use those same names as the arguments to getXXX methods. If, on the other hand, the select statement does not specify column names (as in "select * from table1" or in cases where a column is derived), column numbers should be used. In such situations, there is no way for the user to know for sure what the column names are.

In some cases, it is possible for a SQL query to return a result set that has more than one column with the same name. If a column name is used as the parameter to a getXXX method, getXXX will return the value of the first matching column name. Thus, if there are multi0ple columns with the same name, one needs to use a column index to be sure that the correct column value is retrieved. It may also be slightly more efficient to use column numbers.

Information about the columns in a ResultSet is available by calling the method ResultSet.getMetaData. The ResultSetMetaData object returned gives the number, types, and properties of its ResultSet object's columns.
If the name of a column is known, but not its index, the method findColumn can be used to find the column number.

JDBC-CallableStatement

noreply@blogger.com (LakshmiNarayana Gorantla) — Tue, 14 Apr 2009 18:48:17 PDT

CallableStatement :
A CallableStatement object provides a way to call stored procedures in a standard way for all DBMSs. A stored procedure is stored in a database; the call to the stored procedure is what a CallableStatement object contains. This call is written in an escape syntax that may take one of two forms: one form with a result parameter, and the other without one. A result parameter, a kind of OUT parameter, is the return value for the stored procedure. Both forms may have a variable number of parameters used for input (IN parameters), output (OUT parameters), or both (INOUT parameters). A question mark serves as a placeholder for a parameter.
The syntax for invoking a stored procedure in JDBC is shown below. Note that the square brackets indicate that what is between them is optional; they are not themselves part of the syntax.

{call procedure_name[(?, ?, ...)]}

The syntax for a procedure that returns a result parameter is:

{? = call procedure_name[(?, ?, ...)]}

The syntax for a stored procedure with no parameters would look like this:

{call procedure_name}

Normally, anyone creating a CallableStatement object would already know that the DBMS being used supports stored procedures and what those procedures are. If one needed to check, however, various DatabaseMetaData methods will supply such information. For instance, the method supportsStoredProcedures will return true if the DBMS supports stored procedure calls, and the method getProcedures will return a description of the stored procedures available.
CallableStatement inherits Statement methods, which deal with SQL statements in general, and it also inherits PreparedStatement methods, which deal with IN parameters. All of the methods defined in CallableStatement deal with OUT parameters or the output aspect of INOUT parameters: registering the JDBC types (generic SQL types) of the OUT parameters, retrieving values from them, or checking whether a returned value was JDBC NULL.

Creating a CallableStatement Object
CallableStatement objects are created with the Connection method prepareCall. The example below creates an instance of CallableStatement that contains a call to the stored procedure getTestData, which has two arguments and no result parameter:

CallableStatement cstmt = con.prepareCall(
"{call getTestData(?, ?)}");

Whether the ? placeholders are IN, OUT, or INOUT parameters depends on the stored procedure getTestData.

PreparedStatement

noreply@blogger.com (LakshmiNarayana Gorantla) — Thu, 09 Apr 2009 08:34:43 PDT

PreparedStatement : The PreparedStatement interface inherits from Statement and differs from it in two ways:

Instances of PreparedStatement contain an SQL statement that has already been compiled. This is what makes a statement "prepared."
The SQL statement contained in a PreparedStatement object may have one or more IN parameters. An IN parameter is a parameter whose value is not specified when the SQL statement is created. Instead the statement has a question mark ("?") as a placeholder for each IN parameter. A value for each question mark must be supplied by the appropriate setXXX method before the statement is executed.

Because PreparedStatement objects are precompiled, their execution can be faster than that of Statement objects. Consequently, an SQL statement that is executed many times is often created as a PreparedStatement object to increase efficiency. Being a subclass of Statement, PreparedStatement inherits all the functionality of Statement. In addition, it adds a whole set of methods which are needed for setting the values to be sent to the database in place of the placeholders for IN parameters. Also, the three methods execute, executeQuery, and executeUpdate are modified so that they take no argument. The Statement forms of these methods (the forms that take an SQL statement parameter) should never be used with a PreparedStatement object.

Creating PreparedStatement Objects :
The following code fragment, where con is a Connection object, creates a PreparedStatement object containing an SQL statement with two placeholders for IN parameters:

PreparedStatement pstmt = con.prepareStatement(
"UPDATE table4 SET m = ? WHERE x = ?");

The object pstmt now contains the statement "UPDATE table4 SET m = ? WHERE x = ?", which has already been sent to the DBMS and been prepared for execution.

jdbc

noreply@blogger.com (LakshmiNarayana Gorantla) — Sat, 04 Jul 2009 02:55:11 PDT

JDBC TUTORIAL

JDBC Introduction?

JDBC - ODBC Introduction

Types Of JDBC Drivers

JDBC - URL format tutorial

JDBC Statement

JDBC execute Method

JDBC Prepare Statement

JDBC CallableStatement

JDBC Result Set

JDBC Data types

JDBC EXAMPLES

1. JDBC connection Example code?

2. JDBC code to create a table ?

3. JDBC code ti insert data in DataBase?

4.

jdbc-execute-method

noreply@blogger.com (LakshmiNarayana Gorantla) — Tue, 07 Apr 2009 23:01:44 PDT

execute method:
The execute method should be used only when it is possible that a statement may return more than one ResultSet object, more than one update count, or a combination of ResultSet objects and update counts. These multiple possibilities for results, though rare, are possible when one is executing certain stored procedures or dynamically executing an unknown SQL string (that is, unknown to the application programmer at compile time). For example, a user might execute a stored procedure and that stored procedure could perform an update, then a select, then an update, then a select, and so on. Typically, someone using a stored procedure will know what it returns.

Because the method execute handles the cases that are out of the ordinary, it is no surprise that retrieving its results requires some special handling. For instance, suppose it is known that a procedure returns two result sets. After using the method execute to execute the procedure, one must call the method getResultSet to get the first result set and then the appropriate getXXX methods to retrieve values from it. To get the second result set, one needs to call getMoreResults and then getResultSet a second time. If it is known that a procedure returns two update counts, the method getUpdateCount is called first, followed by getMoreResults and a second call to getUpdateCount.

Those cases where one does not know what will be returned present a more complicated situation. The method execute returns true if the result is a ResultSet object and false if it is a Java int. If it returns an int, that means that the result is either an update count or that the statement executed was a DDL command. The first thing to do after calling the method execute, is to call either getResultSet or getUpdateCount. The method getResultSet is called to get what might be the first of two or more ResultSet objects; the method getUpdateCount is called to get what might be the first of two or more update counts.

When the result of an SQL statement is not a result set, the method getResultSet will return null. This can mean that the result is an update count or that there are no more results. The only way to find out what the null really means in this case is to call the method getUpdateCount, which will return an integer. This integer will be the number of rows affected by the calling statement or -1 to indicate either that the result is a result set or that there are no results. If the method getResultSet has already returned null, which means that the result is not a ResultSet object, then a return value of -1 has to mean that there are no more results. In other words, there are no results (or no more results) when the following is true:

((stmt.getResultSet() == null) && (stmt.getUpdateCount() == -1))

If one has called the method getResultSet and processed the ResultSet object it returned, it is necessary to call the method getMoreResults to see if there is another result set or update count. If getMoreResults returns true, then one needs to again call getResultSet to actually retrieve the next result set. As already stated above, if getResultSet returns null, one has to call getUpdateCount to find out whether null means that the result is an update count or that there are no more results.

When getMoreResults returns false, it means that the SQL statement returned an update count or that there are no more results. So one needs to call the method getUpdateCount to find out which is the case. In this situation, there are no more results when the following is true:

((stmt.getMoreResults() == false) && (stmt.getUpdateCount() == -1))

The code below demonstrates one way to be sure that one has accessed all the result sets and update counts generated by a call to the method execute:

stmt.execute(queryStringWithUnknownResults);
while (true) {
int rowCount = stmt.getUpdateCount();
if (rowCount > 0) { // this is an update count
System.out.println("Rows changed = " + count);
stmt.getMoreResults();
continue;
}
if (rowCount == 0) { // DDL command or 0 updates
System.out.println(" No rows changed or statement was DDL
command");
stmt.getMoreResults();
continue;
}

// if we have gotten this far, we have either a result set
// or no more results

ResultSet rs = stmt.getResultSet;
if (rs != null) {
. . . // use metadata to get info about result set columns
while (rs.next()) {
. . . // process results
stmt.getMoreResults();
continue;
}
break; // there are no more results

jdbc-statement-tutorial

noreply@blogger.com (LakshmiNarayana Gorantla) — Mon, 06 Apr 2009 23:07:13 PDT

Statement:
A Statement object is used to send SQL statements to a database. There are actually three kinds of Statement objects, all of which act as containers for executing SQL statements on a given connection: Statement, PreparedStatement, which inherits from Statement, and CallableStatement, which inherits from PreparedStatement. They are specialized for sending particular types of SQL statements: a Statement object is used to execute a simple SQL statement with no parameters; a PreparedStatement object is used to execute a precompiled SQL statement with or without IN parameters; and a CallableStatement object is used to execute a call to a database stored procedure.

The Statement interface provides basic methods for executing statements and retrieving results. The PreparedStatement interface adds methods for dealing with IN parameters; CallableStatement adds methods for dealing with OUT parameters.

Creating Statement Objects
Once a connection to a particular database is established, that connection can be used to send SQL statements. A Statement object is created with the Connection method createStatement, as in the following code fragment:

Connection con = DriverManager.getConnection(url, "sunny", "");
Statement stmt = con.createStatement();

The SQL statement that will be sent to the database is supplied as the argument to one of the methods for executing a Statement object:

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

Executing Statements Using Statement objects:
The Statement interface provides three different methods for executing SQL statements, executeQuery, executeUpdate, and execute. The one to use is determined by what the SQL statement produces.

The method executeQuery is designed for statements that produce a single result set, such as SELECT statements.

The method executeUpdate is used to execute INSERT, UPDATE, or DELETE statements and also SQL DDL (Data Definition Language) statements like CREATE TABLE and DROP TABLE. The effect of an INSERT, UPDATE, or DELETE statement is a modification of one or more columns in zero or more rows in a table. The return value of executeUpdate is an integer indicating the number of rows that were affected (referred to as the update count). For statements such as CREATE TABLE or DROP TABLE, which do not operate on rows, the return value of executeUpdate is always zero.

The method execute is used to execute statements that return more than one result set, more than one update count, or a combination of the two. Because it is an advanced feature that most programmers will never need, it is explained in its own section later in this overview.

All of the methods for executing statements close the calling Statement object's current result set if there is one open. This means that one needs to complete any processing of the current ResultSet object before re-executing a Statement object.

It should be noted that the PreparedStatement interface, which inherits all of the methods in the Statement interface, has its own versions of the methods executeQuery, executeUpdate and execute. Statement objects do not themselves contain an SQL statement; therefore, one must be provided as the argument to the Statement.execute methods. PreparedStatement objects do not supply an SQL statement as a parameter to these methods because they already contain a precompiled SQL statement. CallableStatement objects inherit the PreparedStatement forms of these methods. Using a query parameter with the PreparedStatement or CallableStatement versions of these methods will cause an SQLException to be thrown.

Statement Completion:
When a connection is in auto-commit mode, the statements being executed within it are committed or rolled back when they are completed. A statement is considered complete when it has been executed and all its results have been returned. For the method executeQuery, which returns one result set, the statement is completed when all the rows of the ResultSet object have been retrieved. For the method executeUpdate, a statement is completed when it is executed. In the rare cases where the method execute is called, however, a statement is not complete until all of the result sets or update counts it generated have been retrieved.

Some DBMSs treat each statement in a stored procedure as a separate statement; others treat the entire procedure as one compound statement. This difference becomes important when auto-commit is enabled because it affects when the method commit is called. In the first case, each statement is individually committed; in the second, all are committed together.

Closing Statement Objects:
Statement objects will be closed automatically by the Java garbage collector. Nevertheless, it is recommended as good programming practice that they be closed explicitly when they are no longer needed. This frees DBMS resources immediately and helps avoid potential memory problems.
Using the Method execute

generic-class-generic-method

noreply@blogger.com (LakshmiNarayana Gorantla) — Mon, 06 Apr 2009 03:22:58 PDT

Generic classes:
We are allowed to define type parameter for the classes.such type of parametrized classes are called generic classes.

//Type parameter T
class Generictest<T,X>
{
T ob; //Generic variable

Generictest(T ob) //Generic constructor
{
this.ob=ob;
}
void show()
{
System.out.println(the type is:ob.getClass().getName());
}
T getob() //Generic method
{
return ob;
}
}
class GenericDemo
{
public static void main(Strin arg[])
{
Generictest<Integer> g=new Generictest<Integer>(10);
g.show(); //java.lang.Integer
System.out.println(g.getob()); // 10

Generictest<String> g=new Generictest<String>(“Laxman”);
g.show(); //java.lang.String
System.out.println(g.getob()); // Laxman
}
}

Bound Types:
We can bound the type parameter I the generic classes by using extends keyword.

Example:
Gen<T>
{
}
We are allowed to create an instance of class by passing any parameter type.
Gen<T extends Number>
{
}

we can create a gen object by passing the type parameter which must be child class of number violation leads to error.

i.e Gen<String> g=new Gen<String>();
CTE saying type parameter java.lang.String is not with in its bound.
Extends means both extends as well as implements.

class Gen<T extends X>
{
}
If X is a class any child class of X (including X) is allowed as T.
If X is any interface Any implemented class of X is allowed as T.

Generic Methods:
class
{
public static void main(String arg[])
{
ArrayList<String> st=new ArrayList<String>();
st.add(“aaa”);
st.add(“bbb”);
st.add(“ccc”);
show(s1);

ArrayList<Integer> st=new ArrayList<Integer>();
st.add(10);
st.add(20);
st.add(30);
show(s2);
public static void main(String arg[])
{
System.out.println(s);
}
}
}
wild card(?)character in generic conclusions:
1.m1(ArrayList<String> l)
This can be applied only for ArrayList of String type only.
2.m1(ArrayList<?> l)
This can be applied for ArrayList of any type ? means unknown type.which is known as wild card character .
3.m1(ArrayList<? Extends X> l)
If X is class this method can be applied for ArrayList of any class ,which is the child class of X is allowed.
If X is interface then any class which implements X is allowed .
4.m1(ArrayList <? Super X> l)
any class which is super class of X is allowed as the type parameter.

Conclusions:
class Test
{
public static void main(Strin arg[])
{
ArrayList<String> l=new ArrayList<String>();
l.add(“a”);
l.add(“b”);
l.add(“c”);
show(l);
//If type is string
show(ArrayList<String> l)
{
l.add(“e”);
l.add(10); // invalid (error: we are only allowed to add String objects)
System.out.println(l); // [a,b,c,e]
}
//If type is wild char (?)
show(ArrayList<?> l)
{
l.add(“e”); // error
l.add(“null”); // valid
System.out.println(l);
}
}

Here we doesn’t know what kind of parameter is coming for this method.Because this method is applicable for Arraylist of any type of parameter.
If we use wild card character ‘?’ in the method declaration ,then we are allowed to perform only READ operation with in that method.
we are not allowed to add any element because what kind of arraylist is coming as argument we can’t give any assurance.
But we can add null because null is a valid value for any object type.
We are allowed to use wild card character ? in the declaration part but we are not allowed to use in the construction part (Right hand side)

Example:
ArrayList<?> l=new ArrayList<String>(); //valid
ArrayList<?> l=new ArrayList<Integer>(); //valid
ArrayList<? Extends Number> l=new ArrayList<Integer>(); //valid
ArrayList<? Extendes Number> l=new ArrayList<Integer>(); // not valid
CTE:incompatable types
Found:ArrayList<string>
Reqire:ArrayList<Number>

ArrayList<String> l=new ArrayList<?>(); //not valid
CTE: unexcepetedtype found:?
Req: class or interface with out bounds.

On the right hand side we are not allowed to impose any boundaries by using extends or super key words.

Communication with legacy code:
To provide support for legacy code Sun people compromised some rules of generics.
class Test
{
public static void main(String arg[])
{
ArrayList <String> l=new ArrayList<String> ();
l.add(“a”);
l.add(“b”);
l.add(“c”);
show(l);
}
public static void show(ArrayList l)
{
l.add(“e”);
l.add(new Integer(10));
System.out.println(l); // [ a,b,c ,d,e,10]
}

Here we won’t get any errors but we get some warning.
To sport 1.4 version methods Sun people some how compromised in this generics area in 1.5 version.

ArrayList l=new ArrayLiat<String>(); // valid

try-catch

noreply@blogger.com (LakshmiNarayana Gorantla) — Sat, 04 Apr 2009 10:03:48 PDT

We can handle exceptions by using the fallowing keywords.
1). try 2). catch 3). finally
try
{
//Risky code
}
catch(XException e)
{
//Define the handler
}

Example:
try
{
System.out.println(10/0);
}
catch(ArithematicException e)
{
System.out.println(“caught”);
System.out.println(10/2);
}
System.out.println(“hello”);
output:
caught
5
hello

Example: try {
Statement 1;
Stmt 2;
Stmt 3;
}
catch(XException e){ Statement 4; }
stmt5;

See the below cases:
Case 1:- If there is no Exception ->1,2,3,5 are executes. So normal termination.
Case 2:- If an Exception raised at stmt2 and the corresponding catch block found then 1 fallowed 4,5 are executes. So, normal termination.
Case 3:- If an Exception is raised at stmt2, but the corresponding catch block not found. Then stmt1 fallowed by abnormal termination.
Case 4:- If an Exception raised at stmt2 and the corresponding catch block found; but while executing catch block raises another Execution then stmt1 fallowed by abnormal termination.

Methods For Displaying Error Information :
The class Throwable contains the fallowing methods for displaying Error information.

1. printStackTrace():
Name of the Exception: Description of Exception Stack trace.
catch(ArithmaticException e)
{
e.printStackTrace();
}
System.out.println(“hai..”);
output:
java.lang.ArithmaticException: /by zero at sample.main(Sample.java)
Hai

2. public String toString():
Name of the Exception: Description of Exception

catch(ArithmaticException e)
{
System.out.println(e.toString());
}
System.out.println(“hai..”);
output:
java.lang.ArithmaticException: /by zero
Hai

3. public String getMessage():
Description of Exception
catch(ArithmaticException e)
{
System.out.println(e.getMessage());
}
System.out.println(“hai..”);
output: /by zero
hai

Try with Multiple catch blocks:
• The way of handling the exception is varied from exception to exception, hence it is a good programming practice to keep separate catch block for every exception.
Example:
try
{
System.out.println(10/0);
}
catch(ArithmeticException e) //child
{
//code
}
catch(Exception e) //parent
{
//code
}
Here in the above example ArithmeticException is the child class of Exception class.It is Valid since child --> to ---> parent hierarchy.

Example:
try
{
System.out.println(10/0);
}
catch(Exception e) //parent
{
//code
}
catch(ArithmeticException e) //child
{
//code
}

Here in the above example Exception class is the child class of ArithmeticException class.It is InValid since parent -->to ---> child hierarchy.compile time error(CTE) : Exception has already been caught by catch (ArithmeticException e).

• If multiple catch blocks are defined for the try statement, the order of the catch blocks is important. We should take the catch blocks from child to parent, violation leads to CTE saying “Exception” has already been caught”.

Control Flow in try with multiple catch blocks:
try
{
Statement 1;
Stmt2;
Stmt3;
}
catch(XException e)
{
Stmt 4;
}
catch(YException e1)
{
Stmt 5;
}
Stmt6;

see the below cases:
Case 1:- If there is no Exception ->1,2,3,6 is executes. So normal termination.
Case 2:- If an Exception raised at stmt2 and the corresponding catch block(Y Exception e1) is matches then 1,5,6 are executes. So, normal termination.
Case 3:- If an Exception is raised at stmt2, but the corresponding catch block not found. Then stmt1 fallowed by abnormal termination.

Control Flow in Nested try catch :
try
{
Statement 1;
Stmt2;
Stmt3;
try
{
Stmt4;
Stmt5;
Stmt6;
}
catch(XException e)
{
Stmt7;
}
Stmt8;
}
catch(YException e)
{
Stmt9;
}
Stmt10;

See the below cases:
Case 1:- If there is no Exception ->1, 2, and 3,4,5,6,8,10 is executes. So normal termination.
Case 2:- If an Exception raised at stmt2 and the corresponding catch block is matches then 1,9,10 are executes. So, normal termination.
Case 3:- If an Exception raised at stmt2 and the corresponding catch block not found. 1 fallowed by abnormal termination.
Case 4:- If an Exception raised at stmt5 and the corresponding catch block is matches then 1,2,3,4,7,10 and Normal Termination.
Case 5:- If an Exception raised at stmt5 and the corresponding catch block is not matched but outer catch block has matched 1,2,3,4,9,10 and Normal Termination.
Case 6:- An Exception raised at stmt2 and the corresponding catch block has matched but while executing that catch block another exception raised then fallowed by abnormal termination.
Case 7:- An Exception raised at stmt8 and the corresponding catch block has matched then 1,2,3,9,10 fallowed by Normal Termination. If the catch block has not matched abnormal termination.

array-length-string-length()

noreply@blogger.com (LakshmiNarayana Gorantla) — Fri, 03 Apr 2009 22:09:05 PDT

length Vs length():
length:This is a variable.applicable for only for array objects represents the number of elements or the size of the array.

Example:
int a=new int[6];
System.out.println(a.length); ------------------> output: 6

length variable Can’t apply to String

int a=new int[6]; Here 6 is length,But the index is starts with 0,1,2,3,4,5.If we are try to access the index a[6] we will get a ArrayIndexOutOfBoundsException.
Array length example:
public class LengthExample {
public static void main(String arg[])
{
int a[]=new int[6];
for(int i=0;i <a.length;i++)
{
a[i]=i;
System.out.print(a[i]);
// System.out.println(a[6]); //exception
}

System.out.println(".....length="+a.length);
}
}
output:012345 length=6

Example:
String s=”Laxman”;
System.out.println(s.length); //error
Given CTE because length variable applicable only for array objects.

length(): It is a final method applicable for string objects.
It represents the number of characters present in the String Object.

Ex:
String s=”Laxman”;
System.out.println(s.length()); ---------> 6
System.out.println(s.length); ----------> //error

In case string also index value start with zero only.

String length() example:
public class StringlengthEx {
public static void main(String arg[])
{
String mystring="abcde";
System.out.println(mystring.length()); //5
System.out.println(mystring.charAt(3)); //d
System.out.println(mystring.indexOf('4')); //2
}
}

Array of strings Example:
public class ArrayStrings {
public static void main(String arg[])
{
String stringarray[]=new String[6];
stringarray[0]="corejava";
stringarray[1]="jdbc";
stringarray[2]="hibernate";
stringarray[3]="servlets";
stringarray[4]="jsp";
stringarray[5]="ejb";
System.out.println("Array length"+stringarray.length);
for(int i=0;i
{
System.out.println(stringarray[i]+"....length="+stringarray[i].length());

}

}
}

output:
Array length6
corejava....length=8
jdbc....length=4
hibernate....length=9
servlets....length=8
jsp....length=3
ejb....length=3

java-instanceof-Shortcircuit-Relational-operators

noreply@blogger.com (LakshmiNarayana Gorantla) — Fri, 03 Apr 2009 20:35:09 PDT

Instanceof operator :
Thread t =new Thread();
System.out.println(t instanceof thread); // true
System.out.println(t instanceof object); //true
System.out.println(t instanceof runnable); //true
System.out.println(t instanceof string); // compile time error saying convertible type found java .lang .thread Required: java. .lang .string a instanceof x
The type of a and x must be related, otherwise compile time error saying convertible type.

Ex: Object o= new Object();
System.out.println(o instanceof string); // false

Ex: null instanceof x;
The result always false

Short-circuit operator( && , || ) :
In the normal logical operator (& or |) we have to calculate both arguments compulsory, some times it may creates performance problems ,to improve the performance short-circuit operators were introduce.

Comparison between bitwise and short-circuit operators

Bitwise operators can be applicable for both Boolean, integral types,Short - circute operators can be applicable only for Boolean type .
Bitwise operators Both operands must be evaluated,Short - circute operators evaluation of second argument is optional.
Bitwise operators performance is low ,Short - circute operators performance is high.

x && y ----> If x is true then y will evaluate.
x || y ------> If x is false then y will evaluate.

Example:
int x=10,y=20;
if( (x <y)||(y gt; x/0))
{
System.out.println(“hi”); // hi
else
{
System.out.println(“hello”);
}

Equality operator:
We can use equality operators for the comparision of primitive numbers , characters,boolean values. Return type is Boolean.
Ex: 10 = = 10; // true
10 = = 10.0; // true
‘a’ = = 97 // true

We can apply these two operators = = and!= both for primitive types and object references. In the case of primitives these operators via check magnitudes or the values.Smaller data type promote bigger data type automatically. In the case of object references double equal operator always cheeks for address comparison.i.e s1= =s2 true iff and only if both s1 and s2 pointing to the same object.

Ex: Sample s1= new sample( );
Sample s2=new sample( );
Sample s3=s1;
System.out.println (s1= =s2); // false
System.out.println (s1= =s3); // true
System.out.println (s1= =”durga”); // compile time error

We can not use double equeal operator for different types of objects, violation leads compile time error saying incomparable types.

Ex: “java”==new Integer(10); // incompatible types
Ex: Sample s=new Sample();
s=null;
s = = null; // the result always false.

Ex: “java”=null ; // false
new Integer(10) = = null; // false
null==null ; // true

Ex:System.out.println( 10 = = 10 = = 10.0); // Compile time error
In the above example 10==10 returns true,true = = 10.0 ---> this shows error

System.out.println( 10 = = 10 = = true) ; // now it returns true

Relational operator ( < , < = , > , >= ) :
These operators applicable for primitives, except Boolean
Ex:10<20 ----> true
20<=50 ----> true
”Java “<”Laxman” -----> Compile time error saying operator java.lang.String,java.lang.String.
Ex:10<=true; compile time error saying can not be applied to boolean , int

Bitwise operator:
AND(&):- If both are true then only the result is true
OR( |):- if at least one is true , then only the result is true
X-OR( ^):- If both are different then only the result is true.

Ex: true & false ----> false
true | false ---> true
true ^ false----> true

Ex: 4& 5 ---> 4
4 | 5 --->5
4^ 5 ----> 1
& , | , ^ ------>

we can apply these operator only for Boolean and integral types . we can’t apply these operator for the floating point data types.

Ex:- 4.5 ^5.5----- compile time error saying operator X-oR can’t be applied to double, double.

Bitwise Compliment Operator :
We can apply bitwise compliment operator only for integral types, but not fir Boolean types i.e, ~4 valied
i.e, ~true invalied ---> Compile time error saying operator ~ can’t be applied to Boolean.
boolean compliment operator:
! true ----> false
!false -----> true
! 3 -----> compile time error saying operator ! can’t be applied to int.
conclusion:-
& , | , ^ -------------> we can apply both integral and Boolean.
~ -----------------> only for integral type
! -----------------> only for Boolean type.

Conditional operator :
The only available ternary operator is the conditional operator.
int a=Boolean expression ? value if true : value if false;
int a=(true)?10:12; //10
We can perform nesting of conditional operator also possible.
Ex:- int a=( false) ? 10 : ( true) ? 20 : 40 ; )
Ex:- byte x=( a <>

New operator:
This can be used for create of objects.
new and instanceof are acts as both keywords and operators.
[ ]-----> This can be used for declaration and construction of arrays.

Assignment operator:
(1)simple assignment:
int x=10;
int y=x;

(2) compound assignment:-
In the case of compound assignment operator compiler will take care about type casting problems . i.e it can perform internal automatic typecasting .
i.e Ex:- byte a=10;
a+=10;
System.out.println(a); // 20

Ex:- byte a=10;
a=a+10;
System.out.println(a); //CE saying PLP.
The following are all possible compound assignment operator :
=,+=,-=,*=,%=,>>=,<<=,>>>=,&=,|=,^=,!=

(3)chained assignment operator:-
Ex:- int a ,b ,c ,d ;
int a=b=c=d=40;//valid
int a=b=c=d=40; //invalid
Why because chained assignment is not allowed at the time of declaration.
Ex: int a ,b ,c ,d;
a=b=c=d=40;
a+=b*c/d-=10;
System.out.println(a+”……..”+b+”….”+c+”……”+d); //80….40…..1….30

Precedence of java operator:
(1)Unary ---------- [], x++, x--,++x,--x, ~,!,new,
(2)arithmetic -----*,/,%,+,-
(3) shift operator --- >>,<=,>,>=,>>>
(4)comparison:-<,<=,>,>=,instsnceof
(5)equality:- ==,!=
(6) bitwise :- &,^ ,|
(7) short-circuit:- &&,||
(8) Conditional : - ?,:
(9) assignment:-=,+=,-=,*=,%=,>>=,<<=,>>>-,&=,|=,^=,!=

Evaluation order of operators:
class EvaluationOrder
{
public static void main(String arg[])
{
System.out.println(m1(1) +m1(2)*m1(3)/m1(4)-m1(5)* m1(6));
}
public static int m1(int i)
{
System.out.println(i);
return i;
}
}

1. 1+2*3/4-5*6
2. 1+6/4-5*6
3. 1+1-5*6
4. 1+1-30= -28(result)

Before applying any operator , first we have to evaluate all the operands .The order of evaluation of operands is always from left to right . And then after evaluation of operands we have to apply the operators according to precedence

jdbc-connection-url-tutorial

noreply@blogger.com (LakshmiNarayana Gorantla) — Fri, 03 Apr 2009 10:24:06 PDT

Connection:
A Connection object represents a connection with a database. A connection session includes the SQL statements that are executed and the results that are returned over that connection. A single application can have one or more connections with a single database, or it can have connections with many different databases.
Opening a Connection :
The standard way to establish a connection with a database is to call the method DriverManager.getConnection. This method takes a string containing a URL. The DriverManager class, referred to as the JDBC management layer, attempts to locate a driver than can connect to the database represented by that URL. The DriverManager class maintains a list of registered Driver classes, and when the method getConnection is called, it checks with each driver in the list until it finds one that can connect to the database specified in the URL. The Driver method connect uses this URL to actually establish the connection.

A user can bypass the JDBC management layer and call Driver methods directly. This could be useful in the rare case that two drivers can connect to a database and the user wants to explicitly select a particular driver. Normally, however, it is much easier to just let the DriverManager class handle opening a connection.
The following code exemplifies opening a connection to a database located at the URL "jdbc:oracle:thin:@localhost:1521:xe" with a user ID of "oracle" and "tiger" as the password :
String url = "jdbc:oracle:thin:@localhost:1521:xe";
Connection con = DriverManager.getConnection(url, "oracle", "tiger");

URLs in General Use :
Since URLs often cause some confusion, we will first give a brief explanation of URLs in general and then go on to a discussion of JDBC URLs.
A URL (Uniform Resource Locator) gives information for locating a resource on the Internet. It can be thought of as an address.

The first part of a URL specifies the protocol used to access information, and it is always followed by a colon. Some common protocols are "ftp", which specifies "file transfer protocol," and "http," which specifies "hypertext transfer protocol." If the protocol is "file," it indicates that the resource is in a local file system rather than on the Internet.

ftp://javasoft.com/docs/JDK-1_apidocs.zip
http://java.sun.com/products/JDK/CurrentRelease
file:/home/haroldw/docs/tutorial.html

The rest of a URL, everything after the first colon, gives information about where the data source is located. If the protocol is file, the rest of the URL is the path to a file. For the protocols ftp and http, the rest of the URL identifies the host and may optionally give a path to a more specific site. For example, below is the URL for the JavaSoft home page. This URL identifies only the host:
http://www.javasoft.com
By navigating from this home page, one can go to many other pages, one of which is the JDBC home page. The URL for the JDBC home page is more specific and looks like this:
http://www.javasoft.com/products/jdbc

JDBC URLs :
A JDBC URL provides a way of identifying a database so that the appropriate driver will recognize it and establish a connection with it. Driver writers are the ones who actually determine what the JDBC URL that identifies their particular driver will be. Users do not need to worry about how to form a JDBC URL; they simply use the URL supplied with the drivers they are using. JDBC's role is to recommend some conventions for driver writers to follow in structuring their JDBC URLs.

Since JDBC URLs are used with various kinds of drivers, the conventions are of necessity very flexible. First, they allow different drivers to use different schemes for naming databases. The odbc subprotocol, for example, lets the URL contain attribute values (but does not require them).

Second, JDBC URLs allow driver writers to encode all necessary connection information within them. This makes it possible, for example, for an applet that wants to talk to a given database to open the database connection without requiring the user to do any system administration chores.

Third, JDBC URLs allow a level of indirection. This means that the JDBC URL may refer to a logical host or database name that is dynamically translated to the actual name by a network naming system. This allows system administrators to avoid specifying particular hosts as part of the JDBC name. There are a number of different network name services (such as DNS, NIS, and DCE), and there is no restriction about which ones can be used.

The standard syntax for JDBC URLs is shown below. It has three parts, which are separated by colons:
jdbc::
The three parts of a JDBC URL are broken down as follows:

jdbc-the protocol. The protocol in a JDBC URL is always jdbc.
-the name of the driver or the name of a database connectivity mechanism, which may be supported by one or more drivers. A prominent example of a subprotocol name is "odbc", which has been reserved for URLs that specify ODBC-style data source names. For example, to access a database through a JDBC-ODBC bridge, one might use a URL such as the following:

jdbc:odbc:fred
In this example, the subprotocol is "odbc", and the subname "fred" is a local ODBC data source.

If one wants to use a network name service (so that the database name in the JDBC URL does not have to be its actual name), the naming service can be the sub protocol. So, for example, one might have a URL like:
jdbc:dcenaming:accounts-payable

In this example, the URL specifies that the local DCE naming service should resolve the database name "accounts-payable" into a more specific name that can be used to connect to the real database.

-a way to identify the database. The subname can vary, depending on the subprotocol, and it can have a subsubname with any internal syntax the driver writer chooses. The point of a subname is to give enough information to locate the database. In the previous example, "fred" is enough because ODBC provides the remainder of the information. A database on a remote server requires more information, however. If the database is to be accessed over the Internet, for example, the network address should be included in the JDBC URL as part of the subname and should follow the standard URL naming convention of
//hostname:port/subsubname

Supposing that "dbnet" is a protocol for connecting to a host on the Internet, a JDBC URL might look like this:

jdbc:dbnet://wombat:356/fred

The "odbc" Subprotocol :
The sub protocol odbc is a special case. It has been reserved for URLs that specify ODBC-style data source names and has the special feature of allowing any number of attribute values to be specified after the surname (the data source name). The full syntax for the odbc sub protocol is:
jdbc:odbc:[;=]*
Thus all of the following are valid jdbc:odbc names:
jdbc:odbc:qeor7
jdbc:odbc:wombat
jdbc:odbc:wombat;CacheSize=20;ExtensionCase=LOWER
jdbc:odbc:qeora;UID=kgh;PWD=fooey

Registering Subprotocols :
A driver developer can reserve a name to be used as the subprotocol in a JDBC URL. When the DriverManager class presents this name to its list of registered drivers, the driver for which this name is reserved should recognize it and establish a connection to the database it identifies. For example, odbc is reserved for the JDBC- ODBC Bridge. If there were, for another example, a Miracle Corporation, it might want to register "miracle" as the subprotocol for the JDBC driver that connects to its Miracle DBMS so that no one else would use that name.
JavaSoft is acting as an informal registry for JDBC subprotocol names. To register a subprotocol name, send email to:
jdbc@wombat.eng.sun.com

java-switch-break-if-else

noreply@blogger.com (LakshmiNarayana Gorantla) — Thu, 02 Apr 2009 11:19:37 PDT

Control Flow(Flow-control ):
Flow control describes the order of execution of code at runtime.
i.e it describes the order in which the statement will execute.
Selection statement
(1)if-else
(2)switch
Iteration statement
(1)for (2)while
(3)do-while
Transfer statement
(1)break
(2)continue
(3)return
(4)try-catch-finally
(5)assertion
(1)if –else :
if: {} and else part both are optional. The valid argument for if statement is always Boolean otherwise compile time error.
If Examples:
if(boolean)
Example: int i=10;
if (i) //This is valid in c++, but invalid java
{
System.out.println(“hi”);
}
else
{
System.out.println(“hello”);
}
Ex : int i=10;
if (i==10)
{
System.out.println(“hi”); //hi
}
else
{
System.out.println(“hello”);
}
Ex : int i=10;
if (i=20)
{
System.out.println(“hi”);
else
{
System.out.println(“hello”);
} // Compile time error
Ex: boolean b =true;
if (b=false)
{
System.out.println(“hi”);
else
{
System.out.println(“hello”);
} // hello
Ex : boolean b=true;
if(b)
int i=10; //invalid
System.out.println(i); //Compile time error
Under if with out curly braces only one statement is allowed ,but that statement never be declarative statement violation leads to compile time error.
Ex:- boolean b= true;
if(b)
int i=10; // invalid
Ex:- boolean b=true;
if(b)
{
int i=10; // valid
}

Switch statement:In switch statement {} are mandatory, violation leads to compile time error.
Both case and default are optional.
Eg:- int i=10;
switch(x)
{
……………
……………no case and default statements.
}

The valid arguments of switch statement are byte, int, short, char until 1.4 version, from 1.5 version onwards the corresponding wrapper class objects Byte, Short, Integer, Character are also allowed.switch can take an enum object are also as argument.If we want keep any statement inside switch it must under some case or default, otherwise COMPILE TIME ERROR.
Eg:- int x=4;
switch(x)
{
System.out.println (“hello”); //hello
}
case-labels : All the case –labels must be compile time Constance, otherwise COMPILE TIME ERROR saying Constance expression required.
Ex: int x=40;
int y=10
switch(x)
{
case y: // CE saying Constance expression required.
}
Ex:final int x=40;
int y=10
switch(x)
{
case y: // valid
}
All the case labels must be in the range of switch arguments otherwise compile time error.
Ex: byte b=10;
switch(b)
{
case 10:
case20:
case100:
case10000://CE saying PLP found: int but required: byte
}
The case label should not be duplicated ,violation leads to COMPILE TIME ERROR
Ex:- int x=10;
switch(x)
{
case 98:
case98:
case a:
}//CE
Hence the case labels
(1)must be compile time Constance
(2) must be in the range of switch arguments
(3)must not be duplicated
default case:- The default case we can keep any where, but it is conversion to keep default case is always at last place.
Ex:
switch(x)
case 0:
System.out.println(“0”);
case 1:
System.out.println(“1”);
case 2:
System.out.println(“2”);
default:
System.out.println(“default”);
}
Once any case are default are matched , all the statements will execute from top to bottom until break or end of switch statements. This is called fall-through inside switch.
Ex:- int x=1;
switch(x)
{
default:
System.out.println(“default”);
case 0:
System.out.println(“0”);
case 1:
System.out.println(“1”);
break;
case 2:
System.out.println(“2”);
}

java-for-foreach-while-dowhile

noreply@blogger.com (LakshmiNarayana Gorantla) — Thu, 02 Apr 2009 11:10:42 PDT

Iteration statement :
while:-if we don’t know the number of iteration in advance then we should go for while loop. The valid argument for the while loop is Boolean
{ } are optional , without { } only one statement is allow, that statement never be declarative statement .
Syntax:- while(true) {
System.out.println (“hello”);
}
System.out.println (“hi”); //Compile time error unreachable statement ex:-while(false)
{
System.out.println (“hello”) ;//CE Unreachable statement
}
System.out.println(“hi”)
Ex:- int a=10;
int b=20;
while (b>a)
{
System.out.println(“hello”); hello hello hello …........
}
System.out.println (“hi”);
ex:- final int a=10;
final int b =20;
while (b>a)
{
System.out.println (“hi”) ;
}
System.out.println (“hello”);//CE saying unreachable statement

do..while statement:-
If the loop body as to execute at least once ,then we should go for while loop
syntax:-
do{
………………..
}
while (b);// mandatory .
without { } we should give exactly one statement between do and while . that may be empty statement .
ex:- do
;
while (b); // valid
without { } only one statement is allowed but it should not be declarative statement
ex:- do
;
while (b); // valid
ex:-
do
{
System.out.println(“hi”);
} while (true);
System.out.println(“hello”); // compile time error unreachable statement
Ex: int x = 10;
do
while(x >0);
System.out.println("hai"); // compile time error saying since after do there is no loop In the while continue statement will shift the transfer conditional checking.
Eg:- int a=10;
int b=20;
do{
System.out.println(“hi”);
}
while(a<b)
{
System.out.println(”hello”);
}
Eg:-final int a=10;
final int b=20;
do {
System.out.println(“hi”);
}
while (a<b)
{
System.out.println(”hello”);
}//CE saying unreachable statement because here a and b are constants

for loop:The most commonly used loop, if we know the iteration in advance, then we should go for for loop
syntax:-
for(initialization part; conditional check; inc/ dec)
{
//loop body
}
initialization part:- Here more than one variable of different data type are not allowed to declare. i.e we have to declare all the variable of the same type and the data type must be mention only one time.
i.e int i=0,j=0; right
int i=0,int j=0; wrong
int i=0,float f=10.0; wrong
More than one data type declaration is not allowed.
As the initialization part we are allowed to take any valid java statement including sop also. initialization part is optional
conditional expression:- As the conditional expression we can take any expression ,but it should boolean value.
The default value for condition expression is true if we are not providing. But default values are not applicable for while and do. .while loops.
Inc/ dec part:- Here we are allowed to any valid java statement including sop also .
All the 3 parts of for loop are optional i.e for(;;); is valid
Ex:-for (int i=0;true; i++){
System.out.println(i);
}
System.out.println(“hello”);//CE unreachable statement
Ex:- :-for (int i=0;false; i++)
{
System.out.println(i); //CE unreachable statement
}
System.out.println(“hello”);
Ex:-
for(int i=0;a<b; i++){
System.out.println(i);
}
System.out.println(“hello”);
Output:-1 2 3 4 5 6 7 8…….
Eg:-
final int a=10;
final int b=20;
for(int i=0;a<b;i++)
{
System.out.println(i);
}System.out.println(“hello”);// invalid

For-each loop:- introduce 1.5 version. More convenient loop for iterating the elements of arrays and collections.
for Example:-int [] a={10,20,30,40};
for(i=0;i<=a.length;i++)
{
System.out.println(a[i]); // 10,20,30,40
}
foreach example:-int [] a={10,20,30,40};
for(int x: a)
{
System.out.println(x); // 10, 20,30,40
}
The main limitation of for-each loop is we can’t use in general and it is applicable only for arrays and collections.
Write the code to display the two dimensional array use for-each loop.
int[] [] a={{10,2030,40},{50,60}}
for(int x : a)
{
for(int y: a){
for(int y : x){
System.out.println(y);{
}

Transfer statement:
Break statement:- we can use the break statement in the following cases .
(i) with in the ioops
(ii) in the switch statement
(iii) in the lable blocks
if we can use any where else we will get a compile time error saying break out side switch (or) loop.
continue statement:-
We can use continue statement only in loops to skip the current iteration and continue for the next iteration.
int i=10;
do{i++;
System.out.println(i);
if(i<=16)
continue;
System.out.println(i);
}
while(++i<20);
In the while continue statement will shift the transfer conditional checking.
Ex:-class sample {
Public static void main(string args[])
{
int x=10;
if(x>10)
continue; //CE saying continue out side of loop
Labeled break and labeled continue:-In the nested loop, if you want to break or continue a particular loop then we should go for labeled break and continue statements.
Ex:-for(int i=0;i<5;i++)
{
for(int j=0;j<5;j++)
{
if(i==j)
break;
System.out.println(i+”……”+j);
}
}

Types-of-Jdbc-Drivers

noreply@blogger.com (LakshmiNarayana Gorantla) — Thu, 02 Apr 2009 09:26:08 PDT

JavaSoft provides three JDBC product components as part of the Java Development Kit (JDK):

The JDBC driver manager,
The JDBC driver test suite, and
The JDBC-ODBC bridge.

The JDBC driver manager is the backbone of the JDBC architecture. It actually is quite small and simple; its primary function is to connect Java applications to the correct JDBC driver and then get out of the way.

The JDBC driver test suite provides some confidence that JDBC drivers will run your program. Only drivers that pass the JDBC driver test suite can be designated JDBC COMPLIANTTM.

The JDBC-ODBC bridge allows ODBC drivers to be used as JDBC drivers. It was implemented as a way to get JDBC off the ground quickly, and long term will provide a way to access some of the less popular DBMSs if JDBC drivers are not implemented for them.

JDBC Driver Types : The JDBC drivers that we are aware of at this time fit into one of four categories:

1.JDBC-ODBC bridge plus ODBC driver: The JavaSoft bridge product provides JDBC access via ODBC drivers. Note that ODBC binary code, and in many cases database client code, must be loaded on each client machine that uses this driver. As a result, this kind of driver is most appropriate on a corporate network where client installations are not a major problem, or for application server code written in Java in a three-tier architecture.

2.Native-API partly-Java driver: This kind of driver converts JDBC calls into calls on the client API for Oracle, Sybase, Informix, DB2, or other DBMS. Note that, like the bridge driver, this style of driver requires that some binary code be loaded on each client machine.

3.JDBC-Net pure Java driver: This driver translates JDBC calls into a DBMS- independent net protocol which is then translated to a DBMS protocol by a server. This net server middleware is able to connect its pure Java clients to many different databases. The specific protocol used depends on the vendor. In general, this is the most flexible JDBC alternative. It is likely that all vendors of this solution will provide products suitable for Intranet use. In order for these products to also support Internet access, they must handle the additional requirements for security, access through firewalls, and so on, that the Web imposes. Several vendors are adding JDBC drivers to their existing database middle ware products.

4.Native-protocol pure Java driver: This kind of driver converts JDBC calls into the network protcol used by DBMSs directly. This allows a direct call from the client machine to the DBMS server and is a practical solution for Intranet access. Since many of these protocols are proprietary, the database vendors themselves will be the primary source, and several database vendors have these in progress.

Eventually, we expect that driver categories 3 and 4 will be the preferred way to access databases from JDBC. Driver categories 1 and 2 are interim solutions where direct pure Java drivers are not yet available. There are possible variations on categories 1 and 2 (not shown in the table below) that require a connector, but these are generally less desirable solutions. Categories 3 and 4 offer all the advantages of Java, including automatic installation (for example, downloading the JDBC driver with an applet that uses it).

Collection-Interface

noreply@blogger.com (LakshmiNarayana Gorantla) — Wed, 01 Apr 2009 03:05:27 PDT

The 1.2 release of the Java platform includes a new collections framework. A collection is an object that represents a group of objects. A collections framework is a unified architecture for representing and manipulating collections, allowing them to be manipulated independently of the details of their representation. The Collection interface is the root of the collection hierarchy. A Collection represents a group of objects, known as its elements. Some Collection implementations allow duplicate elements and others do not. Some are ordered and others unordered. The JDK doesn't provide any direct implementations of this interface: It provides implementations of more specific subinterfaces like Set and List. This interface is the least common denominator that all collections implement.

Collection is used to pass collections around and manipulate them when maximum generality is desired.Collection frame work define a set classes and interfaces which can be used for representing a group of objects as single entity.In the case of c++ the corresponding collection frame work is known as STL(Standered template library) and collection is known as container.

There are six collection interfaces. The most basic interface is Collection. Three interfaces extend Collection: Set, List, and SortedSet. The other two collection interfaces, Map and SortedMap, do not extend Collection, as they represent mappings rather than true collections. However, these interfaces contain collection-view operations, which allow them to be manipulated as collections.

Collection Interface:
It defines general methods ,which can be used for a group of individual objects.i.e a collection represents a group of individual ibjects.
Note:
Collection is an interface to represent a group of individual objects where as collections is an utility class for defining utility methods like sorting,searching… etc.
Collection Interface Methods:
This Interface defines general methods which can be applied on any collection object.
1.boolean add(Object obj)
2.boolean addAll(collection c)
3.boolean remove(Object o)
4.boolean removeAll(Collection c)
5.void clear()
6.boolean retainAll(Collection c)
removes all the elements in the collection except those present in c.
7.boolean contains(Object o)
8.boolean containsAll(Collection c)
9.boolean isEmpty()
10.int size()
returns the number of objects present in the collection
11.Object[] toArray()
mainly for improving the performance of the system.
12. Iterator iterator()
to return the objects one by one.

The primary advantages of a collections framework are that it:
• Reduces programming effort by providing useful data structures and algorithms so you don't have to write them yourself.
• Increases performance by providing high-performance implementations of useful data structures and algorithms. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations.
• Provides interoperability between unrelated APIs by establishing a common language to pass collections back and forth.
• Reduces the effort required to learn APIs by eliminating the need to learn multiple ad hoc collection APIs.
• Reduces the effort required to design and implement APIs by eliminating the need to produce ad hoc collections APIs.
• Fosters software reuse by providing a standard interface for collections and algorithms to manipulate them.