</> MV Techbytes

Basic Spring MVC Application

July 13, 2013July 13, 2013Mallik2 Comments

This post explains how to create spring based web application.

Folder Structure:

Typical folder structure of the spring web application contains as below.

web.xml:

Below is the web.xml file which contains the spring configuration. DispatcherServlet is controller of the spring mvc application, all the requests which coming to the application will be passed through it. DispatcherServlet loads the spring-context.xml file during server start up and keeps the all the configurations in servlet context. Action path configured for this applications is *.html.

<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns=”http://java.sun.com/xml/ns/javaee”
xmlns:web=”http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
id=”WebApp_ID” version=”2.5″>

<display-name>Spring Hello World</display-name>

<welcome-file-list>
<welcome-file>/</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

<servlet>
<servlet-name>springDispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/config/spring-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springDispatcher</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</web-app>

index.jsp:

index.jsp file configured in web.xml as a welcome file, so this file will be loaded when user hit the http://localhost:8080/SpringMVC/ url in the browser.

<jsp:forward page=”sayhello.html”></jsp:forward>

HelloWorldController.java:

When ever index.jsp loaded into the browser, it will forward the request to sayhello.html. This sayhello request is mapped to sayHello() method in HelloWorldController class. So, sayHello() method will be executed and it will return the ‘hello’ string after completion of method execution.

package in.javatutorials.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
*
* @author Javatutorials
*
*/
@Controller
public class HelloWorldController {

/**
* Controls the ‘sayhello’ and return to hello.jsp
* @return
*/
@RequestMapping(value = “/sayhello”, method = RequestMethod.GET)
public String sayHello() {

System.out.println(“Sample Spring Application”);

return “hello”;
}

}

spring-context.xml:

Package of HelloWorldController class is configured as a controller package in the spring-context file as mentioned below. This sample application is configured with the InternalResourceViewResolver, when ever sayHello() method returns the hello string, request will be redirected to hello.jsp based upon the InternalResourceViewResolver configuration as mentioned in the below file.

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:mvc=”http://www.springframework.org/schema/mvc”
xmlns:context=”http://www.springframework.org/schema/context”
xsi:schemaLocation=”
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd”>

<context:component-scan base-package=”in.javatutorials.spring.controller” />
<mvc:annotation-driven />

<bean
class=”org.springframework.web.servlet.view.InternalResourceViewResolver”>
<property name=”prefix” value=”/jsp/” />
<property name=”suffix” value=”.jsp” />
</bean>

</beans>

hello.jsp:

Finally ‘Hi, This is Sample Spring MVC Application’ message will be shown to the user as it is mentioned in the below jsp.

<%@ page language=”java” contentType=”text/html; charset=ISO-8859-1″
pageEncoding=”ISO-8859-1″%>
<!DOCTYPE html PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN” “http://www.w3.org/TR/html4/loose.dtd”>
<html>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=ISO-8859-1″>
<title>Sample Spring MVC Application</title>
</head>
<body>Hi, This is Sample Spring MVC Application
</body>
</html>

Access the application in Browser:

http://localhost:8080/SpringMVC/

Please click on the below link to download the complete application : Click here

Other Useful links:

Spring MVC with Tiles framework sample application

differences between DispatchAction and LookupDispatchAction in Struts Framework

Create a Java web service using top down approch

Example programs for SOAP webservice client

Spring MVC with Tiles framework sample application

July 13, 2013July 13, 2013Mallik6 Comments

Below post talks about the Spring MVC integration with the tiles framework.

You can build developer friendly and user friendly web applications using the tiles framework.

Basic Folder structure of the application:

Typical folder structure of the Spring MVC application has mentioned below:

Web.xml:

<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns=”http://java.sun.com/xml/ns/javaee”
xmlns:web=”http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
id=”WebApp_ID” version=”2.5″>
<display-name>Spring Hello World</display-name>
<welcome-file-list>
<welcome-file>/</welcome-file>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

<servlet>
<servlet-name>springDispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/config/spring-context.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springDispatcher</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>
</web-app>

index.jsp:

index.jsp file configured in web.xml as a welcome file, so this file will be loaded when user hit the http://localhost:8080/SpringMVC/ url in the browser.

<jsp:forward page=”contacts.html”></jsp:forward>

HelloWorldController .java:

When ever index.jsp loaded into the browser, it will forward the request to contacts.html. This contacts request is mapped to contollContacts() method in HelloWorldController class. So, contollContacts() method will be executed and it will return the ‘contact’ string after completion of method execution.

package in.javatutorials.spring.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
*
* @author Javatutorials
*
*/
@Controller
public class HelloWorldController {

/**
* Controls the ‘contacts’ and return to respective layout page
* @return
*/
@RequestMapping(value = “/contacts”, method = RequestMethod.GET)
public String contollContacts() {

String message = “Hi, You are in Controller !!!”;
System.out.println(message);

return “contact”;
}

}

spring-context.xml:

As the Tiles framework has been configured in the spring-context file as below with UrlBasedViewResolver, whenever contact will be returned by contollContacts() methods, request will be reached to tiles.xml and contact tile configuration will be loaded.

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:mvc=”http://www.springframework.org/schema/mvc”
xmlns:context=”http://www.springframework.org/schema/context”
xsi:schemaLocation=”
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd”>

<context:component-scan base-package=”in.javatutorials.spring.controller” />
<mvc:annotation-driven />

<bean id=”viewResolver”
class=”org.springframework.web.servlet.view.UrlBasedViewResolver”>
<property name=”viewClass”>
<value>
org.springframework.web.servlet.view.tiles2.TilesView
</value>
</property>
</bean>
<bean id=”tilesConfigurer”
class=”org.springframework.web.servlet.view.tiles2.TilesConfigurer”>
<property name=”definitions”>
<list>
<value>/config/tiles.xml</value>
</list>
</property>
</bean>

</beans>

tiles.xml:

Below will be the tiles configuration made for our sample application. contact tiles definition is extending to base.definition and base definition will be using layout.jsp as the layout file for our application.

<?xml version=”1.0″ encoding=”UTF-8″ ?>
<!DOCTYPE tiles-definitions PUBLIC
“-//Apache Software Foundation//DTD Tiles Configuration 2.0//EN”
“http://tiles.apache.org/dtds/tiles-config_2_0.dtd”>

<tiles-definitions>
<definition name=”base.definition” template=”/jsp/layout.jsp”>
<put-attribute name=”title” value=”” />
<put-attribute name=”header” value=”/jsp/header.jsp” />
<put-attribute name=”menu” value=”/jsp/menu.jsp” />
<put-attribute name=”body” value=”” />
<put-attribute name=”footer” value=”/jsp/footer.jsp” />
</definition>

<definition name=”contact” extends=”base.definition”>
<put-attribute name=”title”
value=”Sample Spring MVC With Tiles Appliacation” />
<put-attribute name=”body” value=”/jsp/contact.jsp” />
</definition>

</tiles-definitions>

layout.jsp:

This layout.jsp is divided the complete application page as header, menu, body, footer. So, once the layout.jsp called, all the other jsps will be included as per the configuration mentioned in the tiles.xml file.

<%@ taglib uri=”http://tiles.apache.org/tags-tiles” prefix=”tiles”%>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”
“http://www.w3.org/TR/html4/loose.dtd”>
<html>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>
<title><tiles:insertAttribute name=”title” ignore=”true” /></title>
</head>
<body>
<table border=”1″ cellpadding=”2″ cellspacing=”2″ align=”center”>
<tr>
<td height=”30″ colspan=”2″><tiles:insertAttribute name=”header” />
</td>
</tr>
<tr>
<td height=”250″><tiles:insertAttribute name=”menu” /></td>
<td width=”350″><tiles:insertAttribute name=”body” /></td>
</tr>
<tr>
<td height=”30″ colspan=”2″><tiles:insertAttribute name=”footer” />
</td>
</tr>
</table>
</body>
</html>

header.jsp:

<h1>Header</h1>

menu.jsp:

<p>Menu</p>

footer.jsp:

<h1>Footer page</h1>

contact.jsp:

<%@taglib uri=”http://www.springframework.org/tags/form” prefix=”form”%>
<html>
<head>
<title>Sample Spring MVC With Tiles Appliacation</title>
</head>
<body>
<h2>Sample Spring MVC With Tiles Appliacation</h2>
<%
System.out.println(“Contact jsp”);
%>

</body>
</html>

Final Output of the Application:

When ever user hits the below url in the browser, application will be loaded as mentioned in the below screenshot.

http://localhost:8080/SpringMVC/

Sample Spring MVC With Tiles framework application

To download complete application , please click on the link below : Click here

Other Useful links:

Basic Spring MVC Application

JDBC Type Driver connection for MS SQL Server

July 13, 2013June 4, 2020MallikLeave a comment

Below is the sample program to connect to MS SQL Sever using JDBC type 4 driver:

package in.javatutorials;

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

/**
* @author JavaTutorials.in
*
*/
public class MSSqlDBConnection {

/**
* initialize the connection object
*/
private static Connection connection = null;

/**
* Create the database connection and return the same
*
* @return connection Connection
*/
public static Connection getDbConnection() {

// if required, below variables can be read from properties file
String username = "sqlusr";
String password = "sqlpasswrd";
String connStr = "jdbc:sqlserver://:1433;instanceName=SQLEXPRESS;databaseName=test";
try {
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

connection = DriverManager.getConnection(connStr, username,
password);
} catch (ClassNotFoundException classNotFoundExcep) {
classNotFoundExcep.printStackTrace();
} catch (SQLException sqlExcep) {
sqlExcep.printStackTrace();
}
return connection;
}

/**
* Close the connection if exists, this method can be called once
* transaction is completed, so that it will close the connection
*/
public static void closeConnection() {
if (connection != null) {
try {
connection.close();
} catch (SQLException sqlExcep) {
sqlExcep.printStackTrace();
}
}
}

public static void main(String[] args) {
System.out.println("Print the Database conn object : "
+ getDbConnection());
}
}

Top Java script Charting Frameworks

June 24, 2013June 24, 2013Mallik4 Comments

Building Business Intelligence applications is always require the lot of effort and time. As all already might aware of that the Charting applications comes under the business intelligence applications.

There are many number of java charting frame works are available in the market. Some of them might be opensource, some of them are freeware and others might be premium based frameworks. As per my opinion, implementing the charting applications using java based frameworks takes lot of time and bringing good look and feel is night mare to developers.

In this post, I am planning to put some points about the Java script based charting libraries. If you feel interesting about this, just learn more details in the particular websites.

FusionCharts Suite XT: You can build delightful JavaScript charts for web and mobile applications. Charts will be rendered in JavaScript (HTML5) Charts using SVG and VML. It accepts the JSON and XML are the input parameters. You can integrate with the JQuery library. It also provides the API for serviside integration for ASP.NET, PHP, ASP, Java, Ruby on Rails etc. It supports zooming, scrolling and pinning. Provides 90+ chart types in both 2D and 3D. Its a licensed and paid library for production environment.
HighCharts : Interactive JavaScript charts for your web projects. These charts will be rendered in JavaScript (HTML5) Charts using SVG and VML. It accepts the JSON as input format. It provides only 2D format charts. It supports zooming and panning support. Its paid for commercial usage and Non-commercial usage is free. It supports 25+ chart types in 2D. Maps and 3D charts are not supported.
Google Chart Tools: Google Chart tools display live data on your site. These charts will be rendered in HTML5 charts using SVG and VML. It is free library for all usages. The JavaScript files are loaded directly from Google’s servers. So your application always has to be online to view the charts. 13 chart types in 2D. Maps available as GeoChart.
Sencha ExtJS Charts: This is Plugin-free Charting (part of the extJS framework). These charts will be rendered in JavaScript Charts using SVG and VML. It doesn’t supports zooming or panning. 13 chart types in 2D. Maps and 3D charts not supported.
Chart.js:It is a easy, object oriented client side graphs for designers and developers. Its a Canvas based charts. It is Free under MIT license. The charts are drawn using Canvas and hence cannot offer any interactivity. 6 chart types are available.
Flot: It is an attractive JavaScript plotting for jQuery. It renders in the charts in the form of HTML5 charts using Canvas and VML. It provides 8 chart types in 2D. Maps and 3D charts not supported.Its a free library.
jqPlot: It is a Versatile and Expandable jQuery Plotting Plugin and renders in HTML5 charts using Canvas. Ability to provide the 25+ chart types in 2D. Maps and 3D charts not supported. It can be used under GPL and MIT licences. Supports Quintile Pyramid Charts, Engel & Lorenz Curves, Multi-level pie, Block plots.
amCharts: It is a Robust JavaScript Charting Tool / Interactive JavaScript Charts. It renders the charts in the format of JavaScript (HTML5) Charts using SVG and VML. It provides the 18 chart types in 2D and 3D. Maps available as part of amMaps package. Only can be used with the paid licence. Support for PDF not available. Zooming and panning support is available.
gRaphaël: You can build stunning charts on your website. It renders the charts in the format of JavaScript (HTML5) Charts using SVG and VML. Supports 4 chart types in 2D. Maps and 3D charts are not supported. It can be used under MIT licence. No support for zooming or panning. Provides the Dot Charts.

Understanding of complete libraries helps us in taking a decision before designing the applications. Lets be let me know your inputs on this post.

Source: http://www.fusioncharts.com/javascript-charting-comparison/?utm_source=Competitor-Mailer&utm_medium=email&utm_content=Main-C2A&utm_campaign=GrownUps

Other Useful links:

List of Java script MVC Frameworks

Enabling javascript in browsers

Decimal Validation in JavaScript

Creation of Dynamic rows in javascript

Conversion of string into uppercase

Avoid nested loops using Collection Framework in Java

June 22, 2013June 16, 2020Mallik2 Comments

High performance is essential for any software implemented in any programming language. And, loops plays major role in this regard. This post explains how to avoid the loops using Java’s Collection framework.

Below are the two Java programs to understand how the performance could be increased using the Collection framework.

Using nested loops

package in.javatutorials;

/**
* Finds out the Duplicates is String Array using Nested Loops.
*/
public class UsingNesteadLoops {
  private static String[] strArray = { "Cat", "Dog", "Tiger",     "Lion", "Lion" };

  public static void main(String[] args) {
   isThereDuplicateUsingLoops(strArray);
  }

  /**
   * Iterates the String array and finds out the duplicates 
   */
   public static void isThereDuplicateUsingLoops(String[]     strArray) {

   boolean duplicateFound = false;
   int loopCounter = 0;

   for (int i = 0; i < strArray.length; i++) {
   String str = strArray[i];
   int countDuplicate = 0;

   for (int j = 0; j < strArray.length; j++) {
      String str2 = strArray[j];
      if (str.equalsIgnoreCase(str2)) {
         countDuplicate++;
      }
      if (countDuplicate > 1) {
         duplicateFound = true;
         System.out.println("Duplicates Found for " + str);
      }
      loopCounter++;
   }// end of inner nested for loop

   if (duplicateFound) {
    break;
   }
}// end of outer for loop

System.out.println("Looped " + loopCounter + " times to find the result");
}

}

If we run the above program, it will be looped 20 times to find out the duplicates in the string array which has the length of 5. Number of loops increases exponentially depending on size of array, hence the performance takes a hit. These are not acceptable to use in applications which require high performance.

Without using nested loops

package in.javatutorials;

import java.util.HashSet;
import java.util.Set;

/**
* Finds out the Duplicates is String Array using Collection.
*/
public class AvoidNesteadLoopsUsingCollections {

private static String[] strArray = { "Cat", "Dog", "Tiger", "Lion", "Lion" };

public static void main(String[] args) {
 isThereDuplicateUsingSet(strArray);
}

/**
* Iterates the String array and finds out the duplicates
*/
public static void isThereDuplicateUsingSet(String[] strArray) {
  boolean duplicateFound = false;
  int loopCounter = 0;
  Set setValues = new HashSet();

  for (int i = 0; i < strArray.length; i++) {
    String str = strArray[i];

    if(setValues.contains(str)){
        duplicateFound = true;
        System.out.println("Duplicates Found for " + str);
    }
    setValues.add(str);
    loopCounter++;

    if (duplicateFound) {
       break;
    }
   }// end of for loop

   System.out.println("Looped " + loopCounter + " times to find the result");
 }

}

Above approach takes only 5 loops to identify the duplicates in the same array.
It is more readable , easier to maintain and performs better.
If you have an array with 1000 items, then nested loops will loop through 999000 times and utilizing a collection will loop through only 1000 times.

Other Useful links:

Explanation of SOAP WSDL

April 20, 2013MallikLeave a comment

Introduction to REST Webservices

April 20, 2013MallikLeave a comment

List of Java script MVC Frameworks

April 13, 2013April 13, 2013Mallik6 Comments

While the Internet is growing up, more demand for Rich Internet applications is growing proportionally. The end user always expecting have the best look and feel, at the same time expecting the larger functionalities with the minor actions made on the application pages.

Java script plays the major role in achieving these goals. When the more logic ends up being executed in the browser, JavaScript front-end code bases grow larger and more difficult to maintain. The way to solve this issue, developers have been turning to MVC frameworks which promise increased productivity and maintainable code.

There are many MVC based java script frameworks have been came into opensource market in the last decade, which helps the developer to build the Rich Internet Applications easy.

Listed below are the few MVC based java script frameworks.

ExtJS: Provides powerful big data grids, a modern theme, and plugin-free charting apart from the basic functionalities.Backbone.js: Provides models with key-value binding and custom events, collections, and connects it all to your existing API over a RESTful JSON interface.
AngularJS: AngularJS is provide by the Google into internet market. It is a toolset based on extending the HTML vocabulary for your application. It is 100% JavaScript, 100% client side and compatible with both desktop and mobile browsers.
Ember.js: As stated on the Ember.js website, Ember.js is “a JavaScript framework for creating ambitious web applications that eliminates boilerplate and provides a standard application architecture”. Provides template written in the Handlebars templating language, views, controllers, models and a router.
Knockout: It aims to simplify JavaScript UIs by applying the Model-View-View Model (MVVM) pattern.
Agility.js: Using Agility JS, you can write maintainable and reusable browser code without the verbose or infrastructural overhead found in other MVC libraries.
CanJS: Focuses on striking a balance between size, ease of use, safety, speed and flexibility. CanJS’s core supports jQuery, Zepto, Dojo, YUI and Mootools.
Spine: Spine js a lightweight framework that strives to have the most friendly documentation for any JavaScript framework available.
ExtJS: Provides powerful big data grids, a modern theme, and plugin-free charting apart from the basic functionalities.
Sammy.js: A small JavaScript framework developed to provide a basic structure for developing JavaScript applications.
rAppid.js: Lets you encapsulate complexity into components which can be easy used like HTML elements in your application. It uses a Shadow DOM, which is rendered as valid HTML in the document body or a specific target.
Serenade.js: Define templates and render them, handing in a controller and a model to the template. It will get the values from the model and update them dynamically as the model changes. It can be integrated into an existing applications, it plays well with all existing JavaScript code.
Kendo UI: Contains the rich jQuery-based widgets, a simple and consistent programming interface, a rock-solid DataSource, validation, internationalization, a MVVM framework, themes, templates and etc.

Advantages of Hibernate over jdbc?

February 24, 2013February 24, 2013Mallik4 Comments

Below are the advantages of Hibernate over JDBC:

JDBC	Hibernate
With JDBC, developer has to write code to map an object model’s data representation to a relational data model and its corresponding database schema.	Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate itself takes care of this mapping using XML files so developer does not need to write code for this.
With JDBC, the automatic mapping of Java objects with database tables and vice versa conversion is to be taken care of by the developer manually with lines of code.	Hibernate provides transparent persistence and developer does not need to write code explicitly to map database tables tuples to application objects during interaction with RDBMS.
JDBC supports only native Structured Query Language (SQL). Developer has to find out the efficient way to access database, i.e. to select effective query from a number of queries to perform same task.	Hibernate provides a powerful query language Hibernate Query Language (independent from type of database) that is expressed in a familiar SQL like syntax and includes full support for polymorphic queries. Hibernate also supports native SQL statements. It also selects an effective way to perform a database manipulation task for an application.
Application using JDBC to handle persistent data (database tables) having database specific code in large amount. The code written to map table data to application objects and vice versa is actually to map table fields to object properties. As table changed or database changed then it’s essential to change object structure as well as to change code written to map table-to-object/object-to-table.	Hibernate provides this mapping itself. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.
With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application. So with JDBC, mapping between Java objects and database tables is done manually.	Hibernate reduces lines of code by maintaining object-table mapping itself and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.
With JDBC, caching is maintained by hand-coding.	Hibernate, with Transparent Persistence, cache is set to application work space. Relational tuples are moved to this cache as a result of query. It improves performance if client application reads same data many times for same write. Automatic Transparent Persistence allows the developer to concentrate more on business logic rather than this application code.
In JDBC there is no check that always every user has updated data. This check has to be added by the developer.	Hibernate enables developer to define version type field to application, due to this defined field Hibernate updates version field of database table every time relational tuple is updated in form of Java class object to that table. So if two users retrieve same tuple and then modify it and one user save this modified tuple to database, version is automatically updated for this tuple by Hibernate. When other user tries to save updated tuple to database then it does not allow saving it because this user does not have updated data.

Other Useful Links:

Caching in Hibernate

Hibernate Interview Questions

Difference between sorted and ordered collection in hibernate

February 24, 2013February 24, 2013Mallik2 Comments

Below are the differences between Sorted collection and Ordered collection in Hibernate.

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 .