Advantages of Hibernate over jdbc?


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

Difference between sorted and ordered collection in hibernate


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 .

 

Other Useful Links:

Caching in Hibernate

Hibernate Interview Questions

Advantages of Hibernate over jdbc

Create a Java web service using top down approch


In the bottom up approach, we will write the java class and generates the WSDL file and other dependent components. The same will be deployed into the web containers.

In Top down approach, Architects will write the WSDL file based on the requirements. Developer need to make the corresponding service implementation using the WSDL provided. This post will explain how to create a service using the WSDL file.

Step 1: Create a dynamic or java project as mentioned here

Here, I have created a sample web dynamic project with the name SampleWS as given below.

Dyanmic web project

Step 2: generate the service using top down approach

Right click on the SamplWS project name -> New -> Other

SelectOther

Select the Web Service from the wizard as below and click on Finish button.

select webservice

Select the Web service type as ‘Top down Java bean Web service’ and provide the WSDL url in the Service definition drop down and click on Finish button.

Sample WSDL URL is: http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl

providethewsdl

Your Web service is ready with the Java bean methods as below and the Final folder structure looks like below:

service Folder structure

Write the business logic into the Service class as given below:

Generated class:

/**
* CalculatorSoapBindingImpl.java
*
* This file was auto-generated from WSDL
* by the Apache Axis 1.4 Apr 22, 2006 (06:55:48 PDT) WSDL2Java emitter.
*/

package in.malliktalksjava;

public class CalculatorSoapBindingImpl implements in.malliktalksjava.Calculator{
public int addition(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

public int multiplication(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

public int division(int var1, int var2) throws java.rmi.RemoteException {
return -3;
}

}

Implemented class:

/**
* CalculatorSoapBindingImpl.java
*
* This file was auto-generated from WSDL
* by the Apache Axis 1.4 Apr 22, 2006 (06:55:48 PDT) WSDL2Java emitter.
*/

package in.malliktalksjava;

public class CalculatorSoapBindingImpl implements in.malliktalksjava.Calculator{
public int addition(int var1, int var2) throws java.rmi.RemoteException {
return var1+var2;
}

public int multiplication(int var1, int var2) throws java.rmi.RemoteException {
return var1*var2;
}

public int division(int var1, int var2) throws java.rmi.RemoteException {
return var1/var2;
}

}

Deploy the application into server and use the below url as a WSDL for this to have the client.

http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl

 

Other Useful Links:

 Click here to know more about webservices

Click here to know more about RESTfull web services.

Click here for Web services Question and Answers.

Click here to know how to write web service client suing java.

Write a Client for web service


Below steps explains how to write a web service client in java using STS IDE.

Step 1: Create a Java project using the steps mentioned here.

Step 2: Generate the stubs for the Java web service using below steps

Mouse Right click on Client project and select New -> Other

select other option

Select the Web service client from the wizard

Select webservice cliet

Provide the service WSDL url in the Service Definition text box and click on finish button.

Enterwsdl into service defination

Web service client stubs will be generated into the package and final folder structure looks below.

Client stubs generated

Write the Client class using the stubs and test the client project.

Write a client

 

Use the below sample code to write the client:

 

package in.malliktalksjava.client;

import java.rmi.RemoteException;

import in.malliktalksjava.Calculator;
import in.malliktalksjava.CalculatorServiceLocator;
import javax.xml.namespace.QName;
import javax.xml.rpc.ServiceException;

/**
* @author Javatutorials
* @since version 1.0
*
*/
public class SampleWSClient {

/**
* @param args
*/
public static void main(String[] args) {

SampleWSClient sc = new SampleWSClient();
sc.callCalculatorWebservice();
}

/**
* used to call web service
*/
public void callCalculatorWebservice(){

String wsdl = “http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl”;
QName queue = new QName(“http://malliktalksjava.in”, “CalculatorService”);

try {
//create the servicelocator object
CalculatorServiceLocator calServiceLoc = new CalculatorServiceLocator(wsdl, queue);
//create the service object
Calculator calculator = calServiceLoc.getCalculator();
//call the service methods
System.out.println(“addition result : “+calculator.addition(10, 11));
System.out.println(“division result : “+calculator.division(10, 5));
System.out.println(“multiplication result : “+calculator.multiplication(10, 10));
} catch (ServiceException e) {
e.printStackTrace();
} catch (RemoteException e) {
e.printStackTrace();
}
}
}

 

With this your client application is ready to use.

 

Other Useful links:

Click here to know how to create the web service project.

Click here to know the difference between SOAP and RESTfull web services.

Create a java webservice using STS


Below steps explains the how to create a web-service in java in bottom-up approach using the STS(Spring tool suite) IDE. In the bottom-up approach, first we will create a template class, using the template class we will generate the WSDL and deploy the service in servers. Follow the below steps to create a webservice.

Step 1: Create a new java project using the steps mentioned here

Step 2 : Create a template Java class as service

Create a Java class in src folder of the in.javatutorials package as below

Writeaclass

Provide the package name and class name into respective fields and click on finish button.

Namethetheclass

Implement the Java methods as give below:

write the class

Use the below source code to write the class:

package in.malliktalksjava;

/**
* Calculator class exposed as a webservice
* @author malliktalksjava
* @since Version 1.0
*
*/
public class Calculator {

/**
* adds the two input parameters and return the result
* @param var1
* @param var2
* @return
*/
public Integer addition(int var1, int var2) {

Integer result = var1 + var2;
System.out.println(“addition result in service : ” + result);
return result;
}

/**
* multiply the two input parameters and return the result
* @param var1
* @param var2
* @return
*/
public Integer multiplication(int var1, int var2) {

Integer result = var1 * var2;
System.out.println(“multiplication result in service : ” + result);
return result;
}

/**
* divide the two input parameters and return the result
* @param var1
* @param var2
* @return
*/
public Integer division(int var1, int var2) {

Integer result = var1 / var2;
System.out.println(“division result in service : ” + result);
return result;
}

}

Step 3: make the java class as web service

Select the Java class as below

maketheclassas service

Choose Web Service from the  and click on Next button

createservice

Select the ‘Bottom up Java bean Web Service’  from the Web service type and service implementation class as mentioned in the below picture and click on Next button.

bottomup webservice

Select the service methods from the menu and click on Finish button. The Service implementation style used is document/literal as shown in below picture.

choose service methods

The folder structure of the web application looks like below:

webservice folder structure

Deploy the service into tomcat web server and access the WSDL file using the below url:

http://localhost:8080/SampleWebService/wsdl/Calculator.wsdl

wsdlfile

Finally your web service is ready to use and WSDL url is the end point url for your web service.

 

Other Useful links:

 Click here to know more about webservices

Click here to know more about RESTfull web services.

Click here for Web services Question and Answers.

Click here to know how to write web service client suing java.

Create a Dynamic web project using STS


Below steps explain the creating a dynamic web project using STS.

Step 1 : Select File -> New -> Other.

CreateWebproject

Step 2:  Select the Dynamic web project from the menu and click on Next button.

dynamixwebproject

 

Step 3: Give a name to Dynamic web project and click on Finish button.

namewbproject

 

Step 4: A new project will be created as below with web project structure

webprojectstructure

Java Source files can be kept into src folder other files can will be kept into the sub folders of the WebContent folder.