BEST PRACTICES
- Java
By www.PPTSWorld.com
Configuration
Use global-forwards/results
• Helps to avoid duplicate jsp files and redundancy
forward mapping in all the actions in struts.xml
– E.g
 Global error pages
 Success message pages.
Base class
• Have a Base class for each of the layers used
• This will help – common operations need to be included in all the classes in each layer
can be defined/implemented in the base class to reduce code
redundancy
 E.g. Methods to read data from properties
– Have base class implement multiple interfaces required, so that each
subclass need not implement them.
 E.g. In struts2.0 base action class can implement multiple interfaces like
SessionAware, ServletRequestAware, ServletResponseAware,
ServletRequestAware, etc.
Application start up servlet
• Create a servlet class and have it invoked while
application status up.
• Include methods –
– To load static data from data base which is frequently
accessed. This will reduce the DB calls
– To read properties from property file. This will eliminate
the I/O operation, when ever a property value is need to
be read and used.
Exception handling
• Define a Application level Exception handling mechanism, and configure
struts global exception handler.
• Don’t throw multiple exception to the calling method in other layer’s class
(e.g. business class method calling a DAO class method) to handle, Instead
wrap to a user defined Exception and re throw, so that the calling method
need not to handle multiple exceptions and also it eliminates the layer
coupling.
• Don’t handle any exception other than in action layer Unless if you know
what should be done on the exception condition (e.g it may call another
business case on exception)
• Don’t handle all the exception in action class, let global exception handle
the exception and forward to common error page unless if you want to
catch a specific exception and show custom error message to the user.
Logging
• Reduce unnecessary logger statements. More the logger statement lesser
the performance
• Avoid logging same date in multiple places of a single sequence in same
class
• Use appropriate logger level for logging information.
• Don’t log each data in a separate logger statement instead concat and log
them into a single logger statement.
• Have maximum only one INFO level logger statement in layers other than
DAO to identify data flow
• DAO layer you method start time and end time can be in INFO.
Java Server Pages
• Use a global error page.
• Always link to Actions, never to server pages.
• Use the action attributes tag to avoid embedding
Action extension.
• Use s:url to reference HTML assets.
• Use s:include to include pages
Handle Duplicate Form Submission
• The problem of duplicate form submission arises when a user
clicks the Submit button more than once before the response
is sent back.
• Handle it by using the Token interceptor, tokenSession. This
checks for valid token presence in action, stores the
submitted data in session when handed an invalid token and
prevents double submission.
• Don’t use button type as submit while submitting a form
thorough script to avoid duplicate form submit.
Use html:messages (instead of html:errors)
• For displaying error messages to the end user, use
html:messages instead of html:errors
Errors
• To display the error messages of different categories, define
these categories such as FATAL, ERROR, WARNING, or
INFO, in an interface
• In the Action or form-bean class, you can then use the
following
– errors.add("fatal", new ActionError("....")); or
– errors.add("error", new ActionError("....")); or
– errors.add("warning", new ActionError("....")); or
– errors.add("information", new ActionError("...."));
– saveErrors(request,errors);
Errors (contd..)
• To display them according to those categories, use the
following code:
<logic:messagePresent property="error">
<html:messages property="error" id="errMsg" >
<bean:write name="errMsg"/>
</html:messages>
</logic:messagePresent >
Or use:
<logic:messagePresent property="error">
<html:messages property="error" id="errMsg" >
showError('<bean:write name="errMsg"/>'); // JavaScript Function
</html:messages>
</logic:messagePresent >
Common best practices
• Use static methods for util class which contains
commonly used util methods
• Don’t hardcode any value instead use Constance.
• Constance should be static final.
• Have only one util class for an application
• If server side validation is used for input values, then
use separate util class for action layer to hold only
the validation methods.
Common best practices - (contd..)
Where ever passable use switch case statement then if else
Avoid iterating a collection multiple times
Avoid executing DB call with in a loop.
Don’t use static instance variable in action class (Struts 2.0)
Action Classes should not implement complex business functionalities,
rather delegate these to the Business/Service layer
• Don’t use instance variable to store transactional data in spring Business
Service class
• Don’t use egger fetching (lazy=false) for one-to-many mapping in
hibernate, instead use lazy fetching (lazy=true).
•
•
•
•
•
Common best practices - (contd..)
• Don’t get hibernate session directly using session =
getSession(); to execute query, instead use
HibernateTemplate’s call back method.
Common best practices - (contd..)
Incorrect code
Session session = getSession();
String sqlQuery = "SELECT * FROM employee";
Query query = session.createSQLQuery(sqlQuery);
List list = query.list();
Correct Code
String final sqlQuery = "SELECT * FROM employee";
List list =
getHibernateTemplate().executeFind(
new HibernateCallback(){
List list = null;
public Object doInHibernate(Session session)
throws HibernateException, SQLException{
Query query = session.createSQLQuery(sqlQuery);
list = query.list();
return list;
}
}
);