Follow by Email

Wednesday, 23 November 2011

Sample web project

COMMING SOON

Admin.jsp
Registration.jsp
Login.Jsp
Employee search .jsp
Employee File upload.jsp
Student Registartion.jsp
Student Search.jsp
Student File Upload.jsp



Saturday, 19 November 2011

TYPES OF RELATION'S IN HIBERNATE

COMMING SOON

CASE STUDIES ON SESSION MANAGEMENT

COMMING SOON

THE STRUCTURE AND DEPLOYMENT OF WEB APPLICATION

COMMING SOON

SERVLET TEACHONOLGY MODEL

SERVLET TEACHONOLGY MODEL:
.Http Methods
.Servlet Request
.Servlet Response
.Servlet LifeCycle

COMMING SOON

CASE STUIDES ON WEB CONTAINER MODEL

WEB CONTAINER MODEL:
.ServletContext
.Attributes and Scopes
.Filter
.Listeners
.Request Dispatching Meachnisam

COMMING SOON

J2EE DISGEN PATTRERN

COMMING SOON

JSP (JSP BY USING USING TAG LAIBRARIES)

COMMING SOON

JSP By STANDARAD ACTIONS 2.0

COMMING SOON

JSP TEACHNOLOGY MODEL

COMMINGSOON

Case Stude's On WEB SECURITY

COMMING SOON

Case Studie's On JSP CUSTOMTags

COMMING SOON

ABOUT JUNIT

COMMING SOON

ABOUT TESTNG

COMMING SOON

Case Studie's On String Constant Pool Memmory

COMMING SOON

Java.Lang Package

COOMING SOON

JDBC(JAVA DATABASE CONNECTIVITY)

COMMING SOON

Case Studie's On EL Expression

COMMING SOON

Difference between the TestNG and JUnit

COMMING SOON

JSP(JAVA SERVER PAGES)

COMMING SOON

Servlets FAQ's

COMMING SOON

JAVA KEY WORDS

COMMING SOON

Case Studies On Assertion

COMMING SOON

Case Studies On Flow Control

COMMING SOON

Case Studie's On Garbage Collection

COMMING SOON

Case Studie's On Synchronization

COMMING SOON

JAVA 1.7 Features

COMMING SOON

Case Studies On Serialization

COMMING SOON

Case Studies On Thread's

COMMING SOON

Case Studies On Collection

COMMING SOON

Case Studie's On Array's

COMMING SOON

Case Stude's On InnerClass

Case Stude's On InnerClass

COMMING SOON

Exception's

COMMING SOON

Difference Between instance,Static,Local

COMMING SOON

Case Studies On Static Control Flow

COMMING SOON

Case Studies On Instance Control Flow

Case Studies On Mulitipule Try Catch Blocks

COMMING SOON

OOPS Features On 1.5 Version(Case Studies)

COMMING SOON

Case Studies On Constructr's

Constructors:
a) A constructor is a special method that is used to initialize a newly created object and is called just after the memory is allocated for the object
b) It can be used to initialize the objects, to required, or default values at the time of object creation
c) It is not mandatory for the coder to write a constructor for the class
Rules for Constructors:
a)      The name of the class and name of the Constructor must be same
b)      Return type is not allowed for  the Constructors even  “void” also
c)       If your placing any return type then compiler treats it as method we won’t get any  compiler time error
Eg: Class jagan
       {
Void  jagan()
{
//It is a method but not constructor
}
}
Hence It is legal (Stupid) to a have method name is exactly same as Class name
Case1:
1. If you’re not writing any constructor then the compiler will always generate default Constructor
2. If you’re writing at least one constructor (customized) then compiler won’t generate any default constructor the programmer must should  provide the constructors
Case2:
The only applicable modifiers for the constructors are:
a) Private   c) protected
b) Default   d) public

case3:
proto type of  default constructors:
a)      It is always no argument constructors.
b)      It contains only one line  super() ; It is call to super class constructor and it should be no argument call

Eg: Class jagan
{
Jagan()
{
Super ();
}
}
C) The Access modifiers of the default Constructors is same as class modifier
Case4:
About this() and super():
We can’t use super() or this() any where expect constructor otherwise getting  Compile Time Error(CTE)
Class jagan
Public  void  mohan()                     Conclusion:
{                                                             a) we have use only in constructor
this();                                                    b) As the first Statement only
}                                                              c)but not simentenously
}
Case5:
Every  class in  java including abstract class also can contain “Constructors”
But interface cannot Contain Constructors


Class Test
{                                       abstract  Class Test    {                                       interface T est                                   
Test()                                   Test()                                                              {
{                                      {//ok                                                                  Test()
//ok                            }                                                                             {   //not ok
}                                  }                                                                             }
}                                                                                                                  }


Difference b/w programmer Written Code Compiler Generated Code a)

Programmer Written Code :                                                  
a)Class jagan                                                                         
{
}
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->
Compiler Generated Code:
a)Class jagan
{
super();
}
Programmer Written Code :
b) Class jagan
jagan()
{
System.out.println("jagan mohan paspula");
}
}
Compiler Generated Code:
b) Class jagan
jagan()
{
super();
System.out.println("jagan mohan paspula");
}
}
Programmer Written Code :
c) Class jagan
{
void jagan()
{
}
}
Compiler Generated Code:
c) Class jagan
{
void jagan()
{

}
jagan()
{
super();
}
}
Programmer Written Code :
d) Class jagan
{
jagan(int i)
{
super();
System.out.println("Hai  jagan mohan");
}
Compiler Generated Code:
<!--[if !supportLists]-->a)      <!--[endif]-->no new need code is going to generated
Programmer Written Code :
e)Class jagan
{
jagan()
{
this(10);
system.out.println("Hai jagan ");
}
jagan(int i)
{
System.out.println("mohan")
}
}
Compiler Generated Code:
 e)Class jagan
{
jagan()
{
this(10);
system.out.println("Hai jagan ");
}
jagan(int i)
{
super();
System.out.println("mohan")
}
}

Recursive method calls:
It is always runtime exceptions saying stack over flow “error”
Class Test
{
Public static void  m1()
{
m2 ();
}
Public static void m2 ()
{
m1();
}
Public static void main(String args[])
{
System.out.println(“Hello jagan mohan paspula”);
m1(); “RE”
}
}//stack over flow Error
Recursive Constructor invocation a“CTE”
Case1: class Test
                     {
                 Test()
{
this(10);
}
Test(int i)
{
this();
}
Public static void main(String args[])
{
System.out.println(“Hello”);
}
}
Case 2:
Class  p                                                                       class p
{                                                                                         {
                                                                                      P()
    }                                                                                   {
                                                                                    }                                                                       
Class c extends p                                           Class c extends p              
{                                                                       {
}                 
                                                     }
Class p extends c
{
P(int i)
{
}
Class c                              CTE:p(int p)canot be applied to here should not  p() no argument
{                                   here should  not be terminated both constructor
C()                                  “Conculsion”:If the parent class has some constructor then while child    
{  
//Super();                                 Constructor we should take care
}                                Conculsion:wher ever writing argument constructor it is recommended to place no
}                              argument constructor also












COMMING SOON:
1.constructor over loading
2.useage of this() and super()
3.what type variable intilization possiable in constructors
//.Static control flow -->(HOT)

Thursday, 17 November 2011

Hibernate InterView Questions

SIMPLE CONCLUSION:  Hibernate based persistance logic is database independent persistance logic and JDBC based persistance logic is database dependent logic.
                            There is no Dependency  like :Oracle,MySql
                        
                                   Hibernate FAQs

1.what is the advantage of Hibernate over jdbc?
There are so many
1)    Hibernate is data base independent, your code will work for all ORACLE,MySQL ,SQLServer etc.
In case of JDBC query must be data base specific. So hibernate based persistance logic is database independent persistance logic and JDBC based persistance logic is database dependent logic.
2)    As Hibernate is set of Objects ,
3) No need to learn SQL language.You can treat TABLE as a Object . Only Java knowledge is need.
In case of JDBC you need to learn SQL.
3)    Dont need Query tuning in case of Hibernate. If you use Criteria Quires in Hibernate then hibernate automatically tuned your query and return best result with performance.
In case of JDBC you need to tune your queries.
4)     You will get benefit of Cache. Hibernate support two level of cache. First level and 2nd level. So you can store your data into Cache for better performance.
In case of JDBC you need to implement your java cache .
5)    Hibernate supports Query cache and It will provide the statistics about your query and database status.
JDBC Not provides any statistics.
6)    Development fast in case of Hibernate because you dont need to write queries
7)    No need to create any connection pool in case of Hibernate. You can use c3p0.
In case of JDBC you need to write your own connection pool
8)    In the xml file you can see all the relations between tables in case of Hibernate. Easy readability.
9)    You can load your objects on start up using lazy=false in case of Hibernate.
JDBC Dont have such support.
10 ) Hibernate Supports automatic versioning of rows but JDBC Not.
2.What is Hibernate?
Hibernate is an open source, light weight Object Relational Mapping tool to develop the database independent persistence login in java and j2ee based applications.
Hibernate is a pure Java object-relational mapping (ORM) and persistence framework that allows you to map plain old Java objects to relational database tables using (XML) configuration and mapping files. Its purpose is to relieve the developer from a significant amount of relational data persistence-related programming tasks
3.What is ORM ?
ORM stands for object/relational mapping, means providing the mapping between class with table and member variables with columns is called ORM. ORM is the automated persistence of objects in a Java application to the tables in a relational database.
4.What does ORM consists of ?
An ORM solution consists of the following four pieces:
•API for performing basic CRUD operations
•API to express queries referring to classes
•Facilities to specify metadata
•Optimization facilities : dirty checking,lazy associations fetching


5.What are the ORM levels ?
The ORM levels are:
•Pure relational (stored procedure.)
•Light objects mapping (JDBC)
•Medium object mapping
•Full object Mapping (composition,inheritance, polymorphism, persistence by reachability)
.
6.Why do you need ORM tools like hibernate?
The main advantage of ORM like hibernate is that it can develop the database independent persistence logic. Apart from this, ORM provides following benefits:
•Improved productivity
?High-level object-oriented API
?Less Java code to write
?No SQL to write
•Improved performance
?Sophisticated caching
?Lazy loading
?Eager loading
•Improved maintainability
?A lot less code to write
•Improved portability
•ORM framework generates database-specific SQL for you
7.What Does Hibernate Simplify?
Hibernate simplifies:
•Saving and retrieving your domain objects
•Making database column and table name changes
•Centralizing pre save and post retrieve logic
•Complex joins for retrieving related items
•Schema creation from object model
 8.What is the main difference between Entity Beans and Hibernate ?
1)In Entity Bean at a time we can interact with only one data Base. Where as in Hibernate we can able to establishes the connections to more than One Data Base. Only thing we need to write one more configuration file.
2) EJB need container like Weblogic, WebSphare but hibernate don't nned. It can be run on tomcat.

3) Entity Beans does not support OOPS concepts where as Hibernate does.
4) Hibernate supports multi level cacheing, where as Entity Beans doesn't.
5) In Hibernate C3P0 can be used as a connection pool.
6) Hibernate is container independent. EJB not.


9.What are the Core interfaces and classes of Hibernate framework?
The five core interfaces are used in just about every Hibernate application. Using these interfaces, you can store and retrieve persistent objects and control transactions.
•Configuration class (org.hibernate.cfg package)
•Session interface (org.hibernate package)
•SessionFactory interface  (org.hibernate package)
•Transaction interface (org.hibernate package)
•Query and Criteria interfaces (org.hibernate package)
10.What is the general flow of Hibernate communication with RDBMS?
The general flow of Hibernate communication with RDBMS is :
•Load the Hibernate configuration file and create configuration object. It will automatically load all hbm mapping files because mapping file can be configured in configuration file.
•Create session factory from configuration object
•Get one session from this session factory
•Create HQL Query
•Execute query to get list containing Java objects.
11.What is the need for Hibernate mapping file?
Hibernate mapping file is used to provides the mapping between java class with table member variables with column names of the table. And also we can configure primary key generation algorithm, relations and so on. Typical mapping file look as follows:

12.What are the important tags of hibernate.cfg.xml?
This file can be used to provide the database information like driverclass name, url, database usename, database password, dialect, connection pooling mapping file and so on.
Following are the important tags of hibernate.cfg.xml:

13.What role does the Session interface play in Hibernate?

 The main runtime interface between a Java application and Hibernate The Session interface is the primary interface used by Hibernate applications. It is a single-threaded, short-lived object representing a conversation between the application and the persistent store. It allows you to create query objects to retrieve persistent objects.
 The main function of the Session is to offer create, read and delete operations for instances of mapped entity classes. Instances may exist in one of three states:
transient: never persistent, not associated with any Session
persistent: associated with a unique Session
detached: previously persistent, not associated with any Session
Session session = sessionFactory.openSession();
Session interface role:
•Wraps a JDBC connection
•Factory for Transaction
•Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier
14.What role does the SessionFactory interface play in Hibernate?

SessionFactorys are immutable. The behaviour of a SessionFactory is controlled by properties supplied at configuration time. These properties are defined on Environment.
The application obtains Session instances from a SessionFactory. There is typically a single SessionFactory for the whole application—created during application initialization. The SessionFactory caches generate SQL statements and other mapping metadata that Hibernate uses at runtime. It also holds cached data that has been read in one unit of work and may be reused in a future unit of work
Implementors must be threadsafe.
SessionFactory sessionFactory = configuration.buildSessionFactory();
15.What are the most common ways to specify the  Hibernate configuration properties?
The most common methods of Hibernate configuration are:
•Programmatic configuration
        By using setProperty(-) method of org.hibernate.cfg.Configuration.
•XML configuration (hibernate.cfg.xml)
•By using .properties file
•By Using annotaions.(from Hibernate 3.3 on words)
16.How do you map Java Objects with Database tables?
•First we need to write Java domain objects (beans with setter and getter).
•Write hbm.xml, where we map java class to table and database columns to Java class variables.
Example :
<hibernate-mapping>
  <class name="com.durgasoft.EmployeeBean"  table="EMPLOYEE">
     <id name=”eid” colume=”id”/>
   <property name="ename" column="NAME" length="255"
     not-null="true"  type="java.lang.String"/>
   <property name="address" column="ADDR" length="255"
     not-null="true"  type="java.lang.String"/>
 </class>
</hibernate-mapping>
17.How do you define sequence generated primary key algorithm in hibernate?
By using <id>, <generator> tags we can configure the primary key and primary key generation algorithm.
Example:-
<id name="userid" column="USER_ID" type="java.lang.Long">
   <generator class="sequence">
     <param name="table">SEQ_NAME</param>
   <generator>
</id>
18.What is component mapping in Hibernate?
•A component is an object saved as a value, not as a reference
•A component can be saved directly without needing to declare interfaces or identifier properties
•Required to define an empty constructor
•Shared references not supported
19 . Difference between getCurrentSession() and openSession() in Hibernate ?
getCurrentSession() :
Obtains the current session. The "current session" refers to a Hibernate Session bound by Hibernate behind the scenes, to the transaction scope.
A Session is opened when getCurrentSession() is called for the first time and closed when the transaction ends. It is also flushed automatically before the transaction commits. You can call getCurrentSession() as often and anywhere you want as long as the transaction runs. Only the Session that you obtained with sf.getCurrentSession() is flushed and closed automatically.
openSession() :
If you decide to use manage the Session yourself the go for sf.openSession() , you have to flush() and close() it.
It does not flush and close() automatically.
Example :
Transaction tx =session.berginTransaction();
Session session = factory.openSession();
try {
tx.begin();
// Do some work
session.createQuery(...);
session.persist(...);
session.flush(); // Extra work you need to do
tx.commit();
}
catch (RuntimeException e) {
tx.rollback();
throw e; // or display error message
}
finally {
session.close(); // Extra work you need to do
}
20.What are the types of Hibernate instance states ?
Three types of instance states:
•Transient -The instance is not associated with any persistence context
•Persistent -The instance is associated with a persistence context
•Detached -The instance was associated with a persistence context which has been closed – currently not associated
21.What are the types of inheritance models in Hibernate?
There are three types of inheritance models in Hibernate:
•Table per class hierarchy
•Table per subclass
• Table per concrete class
22.What is Hibernate Query Language (HQL)?
Hibernate Query Language is query language which is used to develop the data independent query language in the application. This HQL queries are not related to any database. Hibernate offers a query language that embodies a very powerful and flexible mechanism to query, store, update, and retrieve objects from a database. This language, the Hibernate query Language (HQL), is an object-oriented extension to SQL.

23.What are the ways to express joins in HQL?
HQL provides four ways of expressing (inner and outer) joins:-
•An implicit association join
•An ordinary join in the FROM clause
•A fetch join in the FROM clause.
•A theta-style join in the WHERE clause.
24 . Transaction with plain JDBC in Hibernate ?
If you don't have JTA and don't want to deploy it along with your application, you will usually have to fall back to JDBC transaction demarcation. Instead of calling the JDBC API you better use Hibernate's Transaction and the built-in session-per-request functionality:
To enable the thread-bound strategy in your Hibernate configuration:
set hibernate.transaction.factory_class to org.hibernate.transaction.JDBCTransactionFactory
set hibernate.current_session_context_class to thread
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
// Do some work
session.load(...);
session.persist(...);
tx.commit(); // Flush happens automatically
}
catch (RuntimeException e) {
tx.rollback();
throw e; // or display error message
}
finally {
session.close();
}
       
25 . What are the general considerations or best practices for defining your Hibernate persistent classes?
1.You must have a default no-argument constructor for your persistent classes and there should be getXXX()and setXXX() methods for all your persistable instance variables.
2.You should implement the equals() and hashCode() methods based on your business key and it is important not to use the id field in your equals() and hashCode() definition if the id field is a surrogate key (i.e. Hibernate managed identifier). This is because the Hibernate only generates and sets the field when saving the object.
3. It is recommended to implement the Serializable interface. This is potentially useful if you want to migrate around a multi-processor cluster.
4.The persistent class should not be final because if it is final then lazy loading cannot be used by creating proxy objects.
26 . Difference between session.update() and session.lock() in Hibernate ?
The session.update method is used to update the persistence object in the in the database.
 The session.lock() method simply reattaches the object to the session without checking or updating the database on the assumption that the database in sync with the detached object. It is the best practice to use either session.update(..) or session.saveOrUpdate(). Use session.lock() only if you are absolutely sure that the detached object is in sync with your detached object or if it does not matter because you will be overwriting all the columns that would have changed later on within the same transaction.
27.What are the Collection types in Hibernate ?
•Set
•List
•Array
•Map
•Bag

28.What is the difference between sorted and ordered collection in hibernate?
sorted collection vs. order collection :-

sorted collection   order collection

A sorted collection is sorting a collection by utilizing the sorting features provided by the Java collections framework. The sorting occurs in the memory of JVM which running Hibernate, after the data being read from database using java comparator.
 Order collection is sorting a collection by specifying the order-by clause for sorting this collection when retrieval.

If your collection is not large, it will be more efficient way to sort it.
 If your collection is very large, it will be more efficient way to sort it .

29.What are the ways to express joins in HQL?

HQL provides four ways of expressing (inner and outer) joins:-
•An implicit association join
•An ordinary join in the FROM clause
•A fetch join in the FROM clause.
•A theta-style join in the WHERE clause.
30.What do you mean by Named – SQL query?
Named SQL queries are defined in the mapping xml document and called wherever required.
Example:
<sql-query name = "empdetails">
   <return alias="emp" class="com.durgasoft.Employee"/>
      SELECT emp.EMP_ID AS {emp.empid},
                 emp.EMP_ADDRESS AS {emp.address},
                 emp.EMP_NAME AS {emp.name}
      FROM Employee EMP WHERE emp.NAME LIKE :name
</sql-query>
Invoke Named Query :
List people = session.getNamedQuery("empdetails")
                     .setString("TomBrady", name)
                     .setMaxResults(50)
                     .list();
31.How do you invoke Stored Procedures?
<sql-query name="selectAllEmployees_SP" callable="true">
 <return alias="emp" class="employee">
   <return-property name="empid" column="EMP_ID"/>      
   <return-property name="name" column="EMP_NAME"/>      
   <return-property name="address" column="EMP_ADDRESS"/>
    { ? = call selectAllEmployees() }
 </return>
</sql-query>


32.Explain Criteria API
The interface org.hibernate.Criteria represents a query against a particular persistent class. The Session is a factory for Criteria instances. Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.
Example :
List employees = session.createCriteria(Employee.class)
                         .add(Restrictions.like("name", "a%") )
                         .add(Restrictions.like("address", "Boston"))
                         .addOrder(Order.asc("name") )
                         .list();



33.What’s the difference between load() and get()?

load()   get()

Only use the load() method if you are sure that the object exists.
 If you are not sure that the object exists, then use one of the get() methods.

load() method will throw an exception if the unique id is not found in the database.
 get() method will return null if the unique id is not found in the database.

load() just returns a proxy by default and database won’t be hit until the proxy is first invoked. 
 get() will hit the database immediately.


34.What is the difference between and merge and update ?
Use update() if you are sure that the session does not contain an already persistent instance with the same identifier, and merge() if you want to merge your modifications at any time without consideration of the state of the session.


35.Define cascade and inverse option in one-many mapping?
cascade - enable operations to cascade to child entities.
cascade="all|none|save-update|delete|all-delete-orphan"
inverse - mark this collection as the "inverse" end of a bidirectional association.
inverse="true|false"
Essentially "inverse" indicates which end of a relationship should be ignored, so when persisting a parent who has a collection of children, should you ask the parent for its list of children, or ask the children who the parents are?

36.Define HibernateTemplate?
org.springframework.orm.hibernate.HibernateTemplate is a helper class which provides different methods for querying/retrieving data from the database. It also converts checked HibernateExceptions into unchecked DataAccessExceptions.


37.What are the benefits does HibernateTemplate provide?
The benefits of HibernateTemplate are :
•HibernateTemplate, a Spring Template class simplifies interactions with Hibernate Session.
•Common functions are simplified to single method calls.
•Sessions are automatically closed.
•Exceptions are automatically caught and converted to runtime exceptions.
38. How do you switch between relational databases without code changes?
Using Hibernate SQL Dialects , we can switch databases. Hibernate will generate appropriate hql queries based on the dialect defined.

39.If you want to see the Hibernate generated SQL statements on console, what should we do?
By using “show_sql” property of the hibernate configuration file
In Hibernate configuration file set as follows:
<property name="show_sql">true</property>

40.What are derived properties?
The properties that are not mapped to a column, but calculated at runtime by evaluation of an expression are called derived properties. The expression can be defined using the formula attribute of the element.
41.Define cascade and inverse option in one-many mapping?
cascade - enable operations to cascade to child entities.
cascade="all|none|save-update|delete|all-delete-orphan"
inverse - mark this collection as the "inverse" end of a bidirectional association.
inverse="true|false"
Essentially "inverse" indicates which end of a relationship should be ignored, so when persisting a parent who has a collection of children, should you ask the parent for its list of children, or ask the children who the parents are?

42 . Explain about transaction file?
Transactions denote a work file which can save changes made or revert back the changes. A transaction can be started by session.beginTransaction() and it uses JDBC connection, CORBA or JTA. When this session starts several transactions may occur.
43 . Difference between session.save() , session.saveOrUpdate() and session.persist()?
All methods are used to store the data in to database
            session.save() : save() method uSave does an insert and will fail if the primary key is already persistent.
session.saveOrUpdate() : saveOrUpdate() insert the data in the database if that primary key data not available and it update the data if primary key data not availabt
session.persist() :it is the same like session.save(). But session.save() return Serializable object but session.persist() return void.
For Example :
         if you do :-
         System.out.println(session.save(question));
         This will print the generated primary key.
         if you do :-
         System.out.println(session.persist(question));
         Compile time error because session.persist() return void.
44 . Explain about the id field?
This id field is used to configure the primary key in the mapping file, and also we can configure primary key generation algorithm.
45.What is the use of dynamic-insert and dynamic-update attributes in a class mapping?
Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.
•dynamic-update (defaults to false): Specifies that UPDATE SQL should be generated at runtime and contain only those columns whose values have changed
•dynamic-insert (defaults to false): Specifies that INSERT SQL should be generated at runtime and contain only the columns whose values are not null.
46.What is automatic dirty checking?
Automatic dirty checking is a feature that saves us the effort of explicitly asking Hibernate to update the database when we modify the state of an object inside a transaction.

47.What are Callback interfaces?
Callback interfaces allow the application to receive a notification when something interesting happens to an object—for example, when an object is loaded, saved, or deleted. Hibernate applications don't need to implement these callbacks, but they're useful for implementing certain kinds of generic functionality.
48.What is Hibernate proxy?
The proxy attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked.

49.How can Hibernate be configured to access an instance variable directly and not through a setter method ?
By mapping the property with access="field" in Hibernate metadata. This forces hibernate to bypass the setter method and access the instance variable directly while initializing a newly loaded object.
50.How can a whole class be mapped as immutable?
Mark the class as mutable="false" (Default is true),. This specifies that instances of the class are (not) mutable. Immutable classes, may not be updated or deleted by the application.
51 .  Explain about transparent persistence of Hibernate?
Transparent persistence is provided for Plain old Java objects or POJOs. For proper functioning of the applications importance should be given to the methods equals () and hash Code methods (). It has a requirement which should be strictly followed in the applications which is a no-argument constructor.
52 .  Explain about the dirty checking feature of Hibernate?
Dirty checking feature of the Hibernate allows users or developers to avoid time consuming data base write actions. This feature makes necessary updations and changes to the fields which require a change, remaining fields are left unchanged or untouched.
53 .  What is the effect when a transient mapped object is passed onto a Sessions save?
When a Sessions save () is passed to a transient mapped object it makes the method to become more persistent. Garbage collection and termination of the Java virtual machine stays as long as it is deleted explicitly. It may head back to its transient state.
54 .  Explain about addClass function?
This function translates a Java class name into file name. This translated file name is then loaded as an input stream from the Java class loader. This addClass function is important if you want efficient usage of classes in your code.


Wednesday, 16 November 2011

Struts FAQS


Struts Advanced Actions - Where to use them
Advanced Actions in Struts -
1. Dispatch Action
2. Lookup Dispatch Action
3. Mapping Dispatch Action
4. Switch Action
5. Forward Action
6. Include Action
1. Dispatch Action -
1 . When you want to write more than 1 action in same action then you can use dispatch action.
2 . Action will extends DisptchAction
public class DispatchAction1 extends DispatchAction
{
public ActionForward add(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)
{
}
public ActionForward delete(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)
{
}
}
3 . In struts-config.xml you have to specify a parameter
<action path="/dispatchtest"
type="com.DispatchAction.DispatchAction1"
name="dispatchform"
input="/pages/DispatchTest.jsp"
parameter="method">
<forward name="add" path="/pages/add.jsp"/>
<forward name="delete" path="/pages/delete.jsp"/>
</action>
4 . In jsp you can call action like this /dispatchtest.do?method='add' or /dispatchtest.do?method='delete'
2. Lookup Dispatch Action -
1 . When you want to have more than one submit button in same form in jsp then you can use dispatch action.
2 . Action will extends LookupDispatchAction and you have to override getKeyMethodMap method like this below.
public class LookupAction extends LookupDispatchAction
{
protected Map getKeyMethodMap() {
Map map=new HashMap();
map.put("submit.add","add");
map.put("submit.delete","delete");
return map;
}
public ActionForward add(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)
{ }
}
3 . In struts-config.xml you have to specify a parameter
<action path="/lookup"
type="com.lookupdispatch.LookupAction"
name="lookupform"
input="/pages/LookupTest.jsp"
parameter="method">
<forward name="add" path="/pages/add.jsp"/>
<forward name="delete" path="/pages/delete.jsp"/>
</action>
4. In jsp
<html:html>
<body>
<html:form action="/lookup">
<h2><u>LookUpForm</u></h2>
Number1:<html:text property="n1" value=""/><br><br>
Number2:<html:text property="n2" value=""/><br><br>
<html:submit property="method" value="add"></html:submit>
<html:submit property="method">delete</html:submit>
</html:form>
</body>
</html:html>

5.In properties file you have to specify these properties which are in getKeyMethodMap method.
submit.add=add
submit.delete=delete

3. Mapping Dispatch Action -
1.When you want to write more than 1 action in same action but you want to call that actions by different url's then you can use Mapping dispatch action.
2. Action will extends MappingDispatchAction
public class MappingAction extends MappingDispatchAction
{
public ActionForward add(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)
{
}
public ActionForward delete(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)
{
}
}
3. In struts-config.xml you can give one url for each action in mapping dispatch action and also you have to specify action name as parameter.
<action path="/mappingtest1"
type="com.mapping.MappingAction"
name="mapform"
input="/pages/MappingTest.jsp"
parameter="add">
<forward name="add" path="/pages/add.jsp"/>
</action>
<action path="/mappingtest2"
type="com.mapping.MappingAction"
name="mapform"
input="/pages/MappingTest.jsp"
parameter="delete">
<forward name="delete" path="/pages/delete.jsp"/>
</action>
4. In jsp
<html:html>
<head>
<script type="text/javascript">
function Addtest()
{
document.testform.action="../mappingtest1.do";
document.testform.submit();
}
function Deletetest()
{
document.testform.action="../mappingtest2.do";
document.testform.submit();
}
</script>
</head>
<body>
<form name="testform">
<h2><u>Mapping Dispatch Form</u></h2>
Number1:<html:text property="n1" value=""/><br><br>
Number2:<html:text property="n2" value=""/><br><br>
<input type="button" value="Add" onclick="Addtest()"/>
<input type="button" value="Delete" onclick="Deletetest()"/>
</form>
</body>
</html:html>
4. Include Action -
Include action works like <jsp:include> main difference between them include action works through controller.
1. In struts-config.xml -
<action path="/includetest"
type="org.apache.struts.actions.IncludeAction"
parameter="/pages/Includehello.jsp"
input="/pages/IncludeTest.jsp">
</action>
Here type is org.apache.struts.actions.IncludeAction and parameter which file you have to include that name and input is from where
you are inlcuding that file.
2.In Jsp -
<html:html>
<BODY>
<H2><u>Include Action</H2></u>
<html:link page="/includetest.do">Go to Include Page</html:link>
</html:html>
5. Forward Action -
Forward action is similar to <jsp:forward> main difference between them forward action works through controller.
1. In struts-config.xml -
<action path="/forwardtest"
type="org.apache.struts.actions.ForwardAction"
parameter="/pages/ForwardSuccess.jsp"
input="/pages/ForwardTest.jsp">
</action>
Here type is org.apache.struts.actions.ForwardAction and parameter which file you have to forward that name and input is from where
you are forwarding that file.
2.In Jsp -
<html:html>
<H2><u>Forward Action</H2></u>
<html:link page="/forwardtest.do">Click to Forward Success Page</html:link>
</html:html>
5.Switch Action -
Switch Action mainly used for switching from one config file to another config file.When you want to call action from one config file which is in other config file then you can use this action.
1. web.xml - How to put 2 config files in struts
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<init-param>
<param-name>config/test</param-name>
<param-value>/WEB-INF/test-config.xml</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
2. In struts-config.xml -
<action path="/switch"
type="org.apache.struts.actions.SwitchAction"/>
<action path="/switchtest"
type="com.switchdispatch.Switchaction"
name="switchform"
input="/pages/SwitchTest.jsp">
<forward name="add" path="/switch.do?page=/test1.do&prefix=/test"
contextRelative="true" redirect="true"/>
</action>
Here we have to define a path for switch action like '/switch' type is "org.apache.struts.actions.SwitchAction" .
When you want to forward success page to another action which is not in struts-config.xml then path is "/switch.do?page=/test1.do&prefix=/test"
Here "/switch" is switch action path and page is where you want to forward which is in other xml and prefix is path of other xml (check in web.xml).
3.In test-config.xml
<struts-config>
<form-beans>
<form-bean name="testform1" type="com.switchdispatch.TestForm"/>
</form-beans>
<action-mappings>
<action path="/test1" name="testform1" input="/pages/test1.jsp" type="com.switchdispatch.TestAction" scope="request">
<forward name="success" path="/pages/hello.jsp" contextRelative="true" redirect="true" />
</action>
</action-mappings>
</struts-config>
4.We can call action like this "/switchtest.do" .
0 comments 
Tiles Example in Struts
Here I am explaining how to use Tiles in Struts .
tiles-defs.xml
<?xml version="1.0"?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Tiles Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/tiles-config_1_1.dtd">
<tiles-definitions>
<!-- Main Layout -->
<definition name=".mainLayout" path="/WEB-INF/layout/layout.jsp">
<put name="header" value="/WEB-INF/layout/header.jsp"/>
<put name="content" value="/WEB-INF/layout/center.jsp"/>
<put name="navigation" value="/WEB-INF/layout/navigation.jsp"/>
</definition>
<definition name=".success" extends=".mainLayout">
<put name="navigation" value="/WEB-INF/layout/tab1.jsp"/>
<put name="content" type="page" value="/WEB-INF/layout/tab1display.jsp"/>
</definition>
<definition name=".tab1" extends=".mainLayout">
<put name="navigation" value="/WEB-INF/layout/tab1.jsp"/>
<put name="content" type="page" value="/WEB-INF/layout/tab1display.jsp"/>
</definition>
<definition name=".tab2" extends=".mainLayout">
<put name="navigation" value="/WEB-INF/layout/tab2.jsp"/>
<put name="content" type="page" value="/WEB-INF/layout/tab2display.jsp"/>
</definition>
</tiles-definitions>
struts-config.xml
<struts-config>
<plug-in className="org.apache.struts.tiles.TilesPlugin">
<set-property property="definitions-config"
value="/WEB-INF/tiles-defs.xml"/>
</plug-in>
</struts-config>
tilessuccess.jsp
<%@ taglib prefix="t" uri="/WEB-INF/struts-tiles.tld" %>
<t:insert definition=".success" />
/WEB-INF/layout/layout.jsp
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<%@ taglib prefix="t" uri="/WEB-INF/struts-tiles.tld" %>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<link rel="stylesheet" type="text/css" href="./css/main.css">
</head>
<body>
<div id="header">
<t:insert attribute="header" flush="false" ignore="false" />
</div>
<div id="left">
<t:insert attribute="navigation" flush="false" ignore="false" />
</div>
<div id="center">
<t:insert attribute="content" flush="false" ignore="false" />
</div>
</body>
</html>
/WEB-INF/layout/header.jsp
<html>
<body> <br>
<a href="tab1.jsp" ><img src="./images/Tab1.GIF"/></a>
<a href="tab2.jsp"><img src="./images/Tab2.GIF"/></a>
</body>
</html>
/WEB-INF/layout/center.jsp
This is Center
/WEB-INF/layout/navigation.jsp
<div class="jive-sidebar">
</div>
<div class="jive-sidebar">
This is Left Tile
</div>
(outside)
tab1.jsp
<%@ taglib prefix="t" uri="/WEB-INF/struts-tiles.tld" %>
<t:insert definition=".tab1" />
tab2.jsp
<%@ taglib prefix="t" uri="/WEB-INF/struts-tiles.tld" %>
<t:insert definition=".tab2" />
/WEB-INF/layout/tab1.jsp
<h2>Tab1</h2>
/WEB-INF/layout/tab2.jsp
<h2>Tab2</h2>
/WEB-INF/layout/tab1display.jsp
<h2>This is Tab1 Content
/WEB-INF/layout/tab2display.jsp
<h2>This is Tab2 Content
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- Action Servlet Mapping -->
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>tilessuccess.jsp</welcome-file>
</welcome-file-list>
<!-- Struts Tag Library Descriptors -->
<taglib>
<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/WEB-INF/struts-tiles.tld</taglib-uri>
<taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>
</taglib>
</web-app>
main.css
body
{ margin-top: 0;
margin-bottom: 0;
margin-left: 0;
margin-right: 0;
padding-left: 0;
padding-right: 0;
background-color: #fff;
font-family: Verdana, Arial, Helvetica, sans-serif;
background-image : url("../images/page-background.gif");
background-repeat : repeat-y;
}
/* header */
#header {
width : 100%;
height : 62px;
border : 0px;
background-image : url("../images/header-background.gif");
background-repeat : repeat-x;
background-color : #369;
font-size : 12pt;
color : white;
padding-left : 2em;
text-align : left;
}
#header LI {
display : inline;
padding : 3px;
margin : 0px;
}
#header LI {
font-family : verdana;
font-size : 8pt;
font-weight : bold;
}
#header A {
color : white;
text-decoration : none;
padding : 3px 5px 3px 5px;
}
#header A:hover {
color : #fff;
text-decoration : underline;
}
#header a.active {
color : #fff;
text-decoration : underline;
}
/* left */
#left {
padding : 0px 5px 5px 5px;
}
#left ul {
margin: 0; /*removes indent IE and Opera*/
padding: 0 0 0 0; /*removes indent Mozilla and NN7*/
list-style-type: none; /*turns off display of bullet*/
font-family: verdana, Arial, Helvetica, sans-serif;
font-size: 8pt;
}
#left li {
margin: 0 15px 2px 0px;
width : 140px;
}
#left a {
display: block;
padding: 2px 2px 2px 10px;
border: 1px solid #fff;
width: 140px;
-moz-border-radius : 3px;
background-color: #fff;
}
#left a.active {
border: 1px solid #369;
background-color: #CBDDEE;
color: #333;
}
#left a:hover {
/*
border: 1px solid #369;
background-color : #CBDDEE;
color: #333;
*/
border : 1px solid #963;
background-color : #ffc;
}
#left .currentlink a,
#left .currentlink a:link,
#left .currentlink a:visited,
#left .currentlink a:hover
{
border: 1px solid #369;
background-color: #CBDDEE;
color: #333;
}
#left .category {
padding-top : 1.5em;
padding-bottom : 0.5em;
font-weight : bold;
}
#left .subitems LI {
margin-left : 10px;
width : 130px;
}
#left .subitems LI A {
margin-left : 10px;
padding : 2px 2px 2px 5px;
width : 120px;
}
/* general anchor colors */
a:link, a:visited { color:#333333; text-decoration:underline; }
a:hover { color:#6C99FF; text-decoration:underline; }
/* center */
#center {
top: 0;
margin-left: 200px;
margin-right: 230px;
height: 400px;
min-height: 400px;
}
*>#center {
height: auto;
}
#center_more {
top: 0;
margin-left: 200px;
margin-right: 10px;
height: 400px;
min-height: 400px;
text-align: left;
}
*>#center_more {
height: auto;
}
#center ul li {
margin-left: 0;
margin-bottom: 5px;
padding-left: 0;
font-size: .75em;
}
#center h1 {
font-size:0.95em;
font-weight:bold;
}
#center h2 {
font-size:0.85em;
font-weight: bold;
}
#center h3 {
font-size: 0.8em;
}
#center p {
font-size:0.75em;
}
#center table {
font-size: 0.75em;
}
#center table td.course {
background-color: #FFFFCC;
border-top-width: 2px;
border-right-width: 2px;
border-bottom-width: 2px;
border-left-width: 2px;
border-top-style: solid;
border-right-style: solid;
border-bottom-style: solid;
border-top-color: #999999;
border-right-color: #999999;
border-bottom-color: #999999;
border-left-color: #999999;
}
#center_more h1 {
font-size:0.95em;
font-weight:bold;
}
#center_more h2 {
font-size:0.85em;
font-weight:bold;
}
#center_more h3 {
font-size: 0.8em;
}
#center_more p {
font-size:0.75em;
}
#center_more table {
font-size: 0.75em;
}
#center_more table td.course {
background-color: #FFFFCC;
border-top-width: 2px;
border-right-width: 2px;
border-bottom-width: 2px;
border-left-width: 2px;
border-top-style: solid;
border-right-style: solid;
border-bottom-style: solid;
border-top-color: #999999;
border-right-color: #999999;
border-bottom-color: #999999;
border-left-color: #999999;
}
#center_more table {
font-size: 0.75em;
}
#navTop li:hover ul {
left: 0;
top: 100%;
}
#navTop li:hover ul, #navTop li.over ul {
left: 0;
top: 100%;
}
0 comments 
How to use Nested Tags in Struts
Here I am explaining how to use Nested Tags in Struts .
College.java
package com.Nested;
import java.util.*;
public class College {
private int id;
private String name;
private Collection Students;
public College() {}
public College(int id, String name, Collection students){
this.id = id;
this.name = name;
this.Students = students;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Collection getStudents() {
return Students;
}
public void setStudents(Collection students) {
Students = students;
}
}
NestedAction.java
package com.Nested;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class NestedAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
NestedForm booksForm = (NestedForm) form;
return mapping.findForward("nested");
}
}
NestedForm.java
package com.Nested;
import java.util.*;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionMapping;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class NestedForm extends ActionForm {
College college;
public College getCollege() {
return college;
}
public void setCollege(College college) {
this.college = college;
}
Students student;
public Students getStudent() {
return student;
}
public void setStudent(Students student) {
this.student = student;
}
public void reset(ActionMapping mapping,HttpServletRequest request) {
Collection Students = new ArrayList();
Students.add(new Students("1", "Santhi","MCA"));
Students.add(new Students("2", "Prasanthi","MBA"));
Students.add(new Students("3", "Madhuri","MBA"));
Students.add(new Students("4", "Harini","MBA"));
Students.add(new Students("5", "Shalini","MCA"));
college = new College(1, "GIPS", Students);
}
}
Students.java
package com.Nested;
/**
* @author Prasanthi
*
*/
public class Students {
private String id;
private String name;
private String course;
public Students(){}
public Students(String id, String name,String course){
this.id = id;
this.name = name;
this.course=course;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getCourse() {
return course;
}
public void setCourse(String course) {
this.course = course;
}
}
NestedTest.jsp
<%@ page language="java"%>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<%@ taglib uri="/tags/struts-html" prefix="html" %>
<%@ taglib uri="/tags/struts-nested" prefix="nested"%>
<html>
<body>
<br><br>
<center>
<h2><u>Nested Example</u></h2>
<html:form action="/nest" method="post">
<nested:nest property="college">
<b>
College Name:<nested:write property="name"/></b><br>
<h3><u>Students Table</u></h3>
<table border="1" cellpadding="1" cellspacing="2" width="40%">
<tr><td align="center">ID</td>
<td align="center">Name</td>
<td align="center">Course</td>
</tr>
<nested:iterate property="students">
<tr> <td align="center"><nested:write property="id"/></td>
<td align="center"><nested:write property="name"/></td>
<td align="center"><nested:write property="course"/></td>
</tr>
</nested:iterate>
</table>
</nested:nest>
</html:form>
</body>
</html>
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>NestedTest.jsp</welcome-file>
</welcome-file-list>
<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-nested</taglib-uri>
<taglib-location>/WEB-INF/struts-nested.tld</taglib-location>
</taglib>
</web-app>
struts-config.xml
<struts-config>
<form-beans>
<form-bean name="Nestedform" type="com.Nested.NestedForm" />
</form-beans>
<action-mappings>
<action
path="/nest"
type="com.Nested.NestedAction"
input="/NestedTest.jsp"
name="Nestedform"
scope="request"
validate="false">
<forward name="nested" path="NestedTest.jsp" />
</action>
</action-mappings>
</struts-config>
0 comments 
How use Bean Tags and Message Resources in Struts
Here I am explaining how use Bean Tags and Message Resources in Struts .
SampleForm.java
package com.MessageResources;
import org.apache.struts.action.ActionForm;
/**
*
* @author Prasanthi
*
*/
public class SampleForm extends ActionForm{
String name=null;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
SampleAction.java
package com.MessageResources;
import org.apache.struts.action.*;
import javax.servlet.http.*;
/**
*
* @author Prasanthi
*
*/
public class SampleAction extends Action{
public ActionForward execute(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)throws Exception
{
SampleForm sample=(SampleForm)form;
String n1=sample.getName();
HttpSession ses=req.getSession(true);
ses.setAttribute("name",n1);
return map.findForward("success");
}
}
ApplicationResources.properties
hello.name=Enter your name
hello.submit=Enter
hello.welcome=Welcome To
beansample.jsp
<%@ taglib uri="/tags/struts-html" prefix="html" %>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<html:html>
<body>
<br><br>
<center><h2><u>Sample Struts Form</h2></u>
<font color="red"> These Text messages from properties see code.<br><br></font>
<html:form action="/sample">
<bean:message key="hello.name" /><html:text property="name" /><br><br>
<html:submit><bean:message key="hello.submit" /></html:submit>
</html:form>
</body>
</html:html>
beansuccess.jsp
<%@ taglib uri="/tags/struts-html" prefix="html" %>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<html>
<body><br><br>
<h2><center>
<bean:message key="hello.welcome" /><%=(String)session.getAttribute("name")%>
</body>
</html>
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-logic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>
<welcome-file-list>
<welcome-file>beansample.jsp</welcome-file>
</welcome-file-list>
</web-app>
struts-config.xml
<struts-config>
<form-beans>
<form-bean name="samplebean" type="com.MessageResources.SampleForm" />
</form-beans>
<action-mappings>
<action path="/sample"
name="samplebean"
type="com.MessageResources.SampleAction"
input="beansample.jsp"
scope="request">
<forward name="success" path="/beansuccess.jsp" />
</action>
</action-mappings>
<message-resources parameter="ApplicationResources"/>
</struts-config>
0 comments 
How To Use Logic Tags in Struts
Here I am explaining how to use Logic Tags in Struts .
CdTest.java
package com.LogicTags;
import java.util.List;
public class CdTest {
String title;
String id;
public void setId(String id) {
this.id = id;
}
public String getTitle() {
return title;
}
public CdTest() {
this.title="pokiri";
this.id="1";
}
}
Cd.java
package com.LogicTags;
import java.util.List;
public class Cd {
String title;
int id;
List actors;
public Cd(String title, int id, List actors) {
this.title = title;
this.id = id;
this.actors = actors;
}
public String getTitle() {return title;}
public int getId() {return id;}
public List getActors() {
return actors;
}
}
CdForm.java
package com.LogicTags;
import java.util.*;
public class CdForm {
List CDList = new LinkedList();
public CdForm() {
List list1 = new LinkedList();
list1.add("Ameer Khan");
list1.add("Kajol");
Cd cd1 = new Cd("Fana", 1, list1);
CDList.add(cd1);
List list2 = new LinkedList();
list2.add("Mahesh Babu");
list2.add("Iliana");
Cd cd2 = new Cd("Pokiri", 2, list2);
CDList.add(cd2);
}
public List getCDList() {
return CDList;
}
}
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<welcome-file-list>
<welcome-file>LogicTest.jsp</welcome-file>
</welcome-file-list>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-logic</taglib-uri>
<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
</taglib>
</web-app>
LogicTest.jsp
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<%@ taglib uri="/tags/struts-logic" prefix="logic" %>
<jsp:useBean id="cds" class="com.LogicTags.CdForm" scope="session" />
<jsp:useBean id="cdt" class="com.LogicTags.CdTest" scope="request"/>
<body>
<center>
<br><br>
<h2><u>Logic Tags Examples</u></h2><br>
<b><u>logic:notEqual Example</u> </b>
<logic:notEqual name="cdt" property="title" value="The Matrix">
This CD The Matrix is not available
</logic:notEqual> <br><br>
<b><u>logic:equal Example</u> </b>
<logic:equal name="cdt" property="title" value="pokiri">
This CD Pokiri available
</logic:equal><br><br>
<b><u>logic:present Example</u> </b>
<logic:present name="cdt" property="title">
title property is available
</logic:present><br><br>
<b><u>logic:notPresent Example</u> </b>
<logic:notPresent name="cdt" property="name">
name property is not available
</logic:notPresent><br><br>
<b><u>logic:iterate Example</u> </b><br>
<b>CdList</b>
<table border=1 >
<tr>
<th>Title</th>
<th>Id</th>
<th>Actors</th>
</tr>
<logic:iterate id="cd" name="cds" property="CDList">
<tr>
<td><bean:write name="cd" property="title" /></td>
<td><bean:write name="cd" property="id" /></td>
<td><bean:write name="cd" property="actors" /></td>
</tr>
</logic:iterate>
</table>
</body>
0 comments 
Internalization in struts
Here I am explaining how to do Internalization in struts .
struts-config.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<form-beans>
<form-bean name="Iform" type="com.Internalization.InternalizeForm"/>
</form-beans>
<action-mappings>
<action name="Iform"
path="/internalize"
type="com.Internalization.InternalizeAction"
scope="session"
input="Internalize.jsp">
<forward name="success" path="/Internalization.jsp" />
</action>
</action-mappings>
<message-resources parameter="ApplicationResources" />
<message-resources parameter="ApplicationResources_de_DE" />
<message-resources parameter="ApplicationResources_sv_SE" />
<message-resources parameter="ApplicationResources_fr_FR" />
</struts-config>
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<init-param>
<param-name>config</param-name>
<param-value>/WEB-INF/struts-config.xml</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<welcome-file-list>
<welcome-file>Internalize.jsp</welcome-file>
</welcome-file-list>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
</web-app>
InternalizeForm.java
package com.Internalization;
import org.apache.struts.action.ActionForm;
public class InternalizeForm extends ActionForm{
public String lang;
public String getLang() {
return lang;
}
public void setLang(String lang) {
this.lang = lang;
}
}
InternalizeAction.java
package com.Internalization;
import java.util.Enumeration;
import java.util.Locale;
import java.util.ResourceBundle;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
public class InternalizeAction extends Action {
public ActionForward execute(ActionMapping map,ActionForm form,HttpServletRequest req,HttpServletResponse res)throws Exception
{
String lang = req.getParameter("lang");
if (lang == null) {
lang="English";
}else {
ResourceBundle bundle=null;
Locale locale=null;
if (lang.equals("German")) {
locale=Locale.GERMANY;
} else if (lang.equals("French")) {
locale=Locale.FRANCE;
} else if (lang.equals("Swedish")) {
locale=new Locale("sv","SE");
} else {
locale=Locale.US;
}
HttpSession session=req.getSession();
session.putValue("myLocale",locale);
bundle = ResourceBundle.getBundle("ApplicationResources",locale);
for (Enumeration e = bundle.getKeys();e.hasMoreElements();) {
String key = (String)e.nextElement();
String s = bundle.getString(key);
session.putValue(key,s);
}
}
return map.findForward("success");
}
}
ApplicationResources.properties
hello.name=Name
hello.password=Password
hello.course=Course
hello.college=College
hello.city=City
hello.submit=submit
ApplicationResources_de_DE.properties
hello.name=Name-de
hello.password=Password-de
hello.course=Course-de
hello.college=College-de
hello.city=City-de
hello.submit=submit-de
ApplicationResources_fr_FR.properties
hello.name=Name-fr
hello.password=Password-fr
hello.course=Course-fr
hello.college=College-fr
hello.city=City-fr
hello.submit=submit-fr
ApplicationResources_sv_SE.properties
hello.name=Name-sv
hello.password=Password-sv
hello.course=Course-sv
hello.college=College-sv
hello.city=City-sv
hello.submit=submit-sv
Internalize.jsp
<%@ taglib uri="/tags/struts-html" prefix="html"%>
<html:html >
<body><br><br>
<center>
<h3><u>
Please select a language </u></h3>
<html:form action="/internalize">
English <input type="radio" name="lang" value="English" checked>
German <input type="radio" name="lang" value="German">
French <input type="radio" name="lang" value="French">
Swedish<input type="radio" name="lang" value="Swedish">
<br><br>
<html:submit />
</html:form>
</body>
</html:html>
Internalization.jsp
<%@ taglib uri="/tags/struts-html" prefix="html" %>
<%@ taglib uri="/tags/struts-bean" prefix="bean" %>
<%@ page import="java.util.*" %>
<html:html>
<body>
<%Locale myLocale = (Locale)session.getValue("myLocale"); %>
<br><br>
<center><h3><u>Sample Messages</u></h3>
<form>
<table>
<tr><td><%=session.getValue("hello.name")%></td>
<td><input type="text" /></td></tr>
<tr><td><%=session.getValue("hello.password")%></td>
<td><input type="text" /></td></tr>
<tr><td><%=session.getValue("hello.course") %></td>
<td><input type="text" /></td></tr>
<tr><td><%=session.getValue("hello.college") %></td>
<td><input type="text" /></td></tr>
<tr><td><%=session.getValue("hello.city") %></td>
<td><input type="text" /></td></tr>
<tr><td></td><td colsapn="2"><html:submit> <%=session.getValue("hello.submit") %></html:submit></td></tr>
</table>
</form>
</body>
</html:html>
1 comments 
Exception handling in struts
Here I am explaining how to handle Exceptions in struts .
struts-config.xml
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">
<struts-config>
<form-beans>
<form-bean name="exceptionform" type="org.apache.struts.validator.DynaValidatorForm">
<form-property name="id" type="java.lang.String"/>
</form-bean>
</form-beans>
<global-exceptions>
<exception
key ="errors.exception1"
type="com.Exception.Exception1"
handler="com.Exception.MyHandler"
path="/Except.jsp"/>
<exception
key ="errors.exception2"
type="com.Exception.Exception2"
handler="com.Exception.MyHandler"
path="/Except.jsp"/>
</global-exceptions>
<action-mappings>
<action path="/exceptiontest"
name="exceptionform"
scope="request"
input="/ExceptionTest.jsp"
validate="true"
type="com.Exception.ExceptionTest">
<forward name="success" path="/ExceptionTest.jsp"/>
<forward name="failure" path="/Except.jsp"/>
</action>
</action-mappings>
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property
property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/validation.xml"/>
</plug-in>
</struts-config>
web.xml
<web-app>
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>ExceptionTest.jsp</welcome-file>
</welcome-file-list>
<taglib>
<taglib-uri>/tags/struts-html</taglib-uri>
<taglib-location>/WEB-INF/struts-html.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>/tags/struts-bean</taglib-uri>
<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
</taglib>
</web-app>
Exception1.java
package com.Exception;
public class Exception1 extends Exception {
public Exception1() {
super();
}
public Exception1(String message) {
super(message);
}
public Exception1(String message, Throwable cause) {
super(message, cause);
}
public Exception1(Throwable cause) {
super(cause);
}
}
Exception2.java
package com.Exception;
public class Exception2 extends Exception {
public Exception2() {
super();
}
public Exception2(String message) {
super(message);
}
public Exception2(String message, Throwable cause) {
super(message, cause);
}
public Exception2(Throwable cause) {
super(cause);
}
}