Tech Trek: A Software Engineer's Guide to Code and Beyond

Wednesday, August 29, 2012

How to integrate Liquibase with Spring and Hibernate ?

A sample tutorial on how to integrate Liquibase with Spring and Hibernate.

While writing this tutorial, I have added javadoc in the code for better understanding and I believe You already have good knowledge on Spring and Hibernate. The main motto of this tutorial is to give an idea on how you can integrate Liquibase with Spring and Hibernate.

If you are new to Liquibase : Click Here

To integrate liquibase into your project, you need liquibase jars, So download it before starting the project.

I have created an application named "SHLIntegration". The Structure of the project is as follows :

The dependencies are also listed here:

Lets start with Employee class :

1. Create Employee class having getter/setter and add proper JPA annotation to each variable as below.

public class Employee {

    @Id
    @GeneratedValue
    @Column(name="EMPLOYEE_ID")
    private long id;

    @Column(name="NAME")
    private String name;

    @Column(name="GENDER")
    private String gender;

    @Column(name="COUNTRY")
    private String country;

    @Column(name="ABOUT_YOU")
    private String aboutYou;
.....
....
.... // getter setter of each object

}

2. Create liquibase file i,e db-changelog.xml file

<?xml version="1.0" encoding="UTF-8"?>
<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">

    <changeSet author="waheed" id="123456789-1">
        <createTable tableName="EMPLOYEE">
            <column autoIncrement="true" name="EMPLOYEE_ID" type="BIGINT">
                <constraints nullable="false" primaryKey="true" />
            </column>
            <column name="NAME" type="VARCHAR(255)" />
            <column name="GENDER" type="VARCHAR(2)" />
            <column name="COUNTRY" type="VARCHAR(255)" />
            <column name="ABOUT_YOU" type="VARCHAR(255)" />
        </createTable>
    </changeSet>
</databaseChangeLog>

3. Add liquibase bean in your bean :

    <bean id="LiquibaseUpdater" class="liquibase.integration.spring.SpringLiquibase">
        <property name="dataSource" ref="dataSource" />
        <property name="changeLog" value="classpath:db-changelog.xml" />
    </bean>

and others beans which are required for Spring/Hibernate. Check bean file

The complete tutorial :
https://github.com/abdulwaheed18/SHLIntegration

Please feel free to do comment or drop me a mail regarding any suggestion/Feedback.
Email : waheedtechblog@gmail.com

Some ANT task

1. How to build project from another build.

<target name="project2"
            description="Builds project2 project, required depedency">
        

        <subant target="dist" verbose="yes" inheritall="false">
            <filelist dir="../com.waheed.project2"
                      files="build.xml" />
        </subant>
    </target>

2. How to read SVN revision and write into some file

<loadfile property="revision" srcFile="./.svn/entries">
       <filterchain>
            <headfilter skip="3" lines="1"/>
                 </filterchain>
        </loadfile>
            <tstamp>
               <format property="date" pattern="dd/MM/yyyy hh:mm:ss" />
            </tstamp>
           <echo append="true" file="<FILE_NAME>" >revision=${revision}${line.separator}</echo>

3. How to generate Keystore

4. How to get current time

<target name="time">
        <tstamp>
            <format property="build-time" pattern="yyyy-MM-dd-HH-mm" />
        </tstamp>
        <echo>${build-start-time}</echo>
    </target>

5 . How to create jar with manifest

6. How to compile source



        <javac destdir="bin" debug="true">
            <src path="src" />
            <classpath>
                <pathelement location="../dependency/bin" />
                <fileset dir="../lib">
                    <include name="*.jar" />
                </fileset>
            </classpath>
        </javac>

7. How to compile source with dependency class path

8. How to build Zip file

9. How to build tar file

10 . How to check OS

11. How to set permission to file

12 .How to read property file

Suppose I have following data in my filename1.properties file and want to read it and write it to another file lets say name filename2.properties.

filename1.properties

REVISION 777

<property file="${dist}/filename1.properties" prefix="version"/>
<echo file="${dist}/filename2.properties" append="true">revision ${version.REVISION}${line.separator}</echo>

Spring MVC tutorial

Before Starting, I believe you must have basic idea about JAVA, SPRING and Spring MVC.

For Spring MVC : http://waheedtechblog.blogspot.in/2012/08/spring-mvc.html

In this tutorial , I will just tell you what are the basic thing that you need to start MVC.

Step 1 : Create a class

@Controller

public class HelloWorld {

@RequestMapping("/hello")

public String helloWorld() {

return = "Hello World, Spring 3.0!";

}

1 . The class HelloWorld has the annotation @Controller and @RequestMapping("/hello"). When Spring scans this class, it will recognize this bean as being a Controller bean for processing requests. 2 .The @RequestMapping annotation tells Spring that this Controller should process all requests beginning with /hello in the URL path.

Step 2. Mapping Spring MVC in WEB.xml

The entry point of Spring 3.0 MVC is the DispatcherServlet. DispatcherServlet is a normal servlet class which implements HttpServlet base class. Thus we need to configure it in web.xml.


    
    

    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/rest/*</url-pattern>
    </servlet-mapping>


    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:beans.xml</param-value>
    </context-param>

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

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

Note that I have mapped /rest/* url pattern with example DispatcherServlet. Thus any url with /rest/* pattern will call Spring MVC Front controller.

                  The REST call would be http://ip:port/rest/hello

If your controller class has some dependency which you have defined in your spring context file.Then you have to load it in <context-param>.(red line).
Once the DispatcherServlet is initialized, it will looks for a file name [servlet-name]-servlet.xml in WEB-INF folder of web application. I have created the file named spring-servlet.xml

3 . Spring Configuration file

Create a file spring-servlet.xml in WEB-INF folder and copy following content into it.
<?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:task="http://www.springframework.org/schema/task"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/task
    http://www.springframework.org/schema/task/spring-task-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
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util-2.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        ">

    
    
    

    <context:annotation-config />
    <mvc:annotation-driven />
    <mvc:default-servlet-handler />

    
    <bean class="com.waheed.spring.hibernate.HelloWorld" />
</beans>

The highlighted red line allow Spring to load the components from class. This will load our HelloWorld class.

Congratulation..!!! You are done here...

Download source code : https://github.com/abdulwaheed18/SpringMVC-Hibernate-Integration

Spring MVC

Spring MVC helps in building flexible and loosely coupled web applications. The Model-view-controller design pattern helps in seperating the business logic, presentation logic and navigation logic. Models are responsible for encapsulating the application data. The Views render response to the user with the help of the model object . Controllers are responsible for receiving the request from the user and calling the back-end services.

When a request is sent to the Spring MVC Framework the following sequence of events happen.

The DispatcherServlet first receives the request.
The DispatcherServlet consults the HandlerMapping and invokes the Controller associated with the request.
The Controller process the request by calling the appropriate service methods and returns a ModeAndView object to the DispatcherServlet. The ModeAndView object contains the model data and the view name.
The DispatcherServlet sends the view name to a ViewResolver to find the actual View to invoke.
Now the DispatcherServlet will pass the model object to the View to render the result.
The View with the help of the model data will render the result back to the user.

The new Servlet
•DispatcherServlet requests are mapped to @Controller methods
–@RequestMapping annotation used to define mapping rules
–Method parameters used to obtain request input
–Method return values used to generate responses
•Simplest possible @Controller

@Controller
public class HelloController {
    @RequestMapping(“/”)
    public @ResponseBody String hello() {
        return “Hello World”;
    }
}

Mapping Requests
•By path
–@RequestMapping(“path”)
•By HTTP method
–@RequestMapping(“path”,method=RequestMethod.GET)
–POST,PUT,DELETE,OPTIONS and TRACE are also supported
•By presence of query parameter
–@RequestMapping(“path”,method=RequestMethod.GET,params=“foo”)
–Negation also supported: params={“foo”,”!bar”}
•By presence of request header
–@RequestMapping(“path”,header=“content-type=text/*”)
–Negation also supported

For more details : Click Here

For tutorial: http://waheedtechblog.blogspot.in/2012/08/spring-mvc-tutorial.html

Sending Email Via JavaMail API Example

From last one month, My internet device is missing from my terrace. So, Mostly I use mobile to access my mail but accessing mail via mobile is very irritating thing because of the slow bandwidth. To send one single mail I have to wait till the mailbox get opened.

This is very simple way to send mail without opening your account. :)

This is the example to show you how to use JavaMail API method to send an email via Gmail SMTP server.

You need mail.jar library to run this code.

import java.util.Properties;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* @author abdul
*
*/
public class SendEmail {

    public static void main(String[] args) {

        final String username="YOUR_USER_NAME"; //abdulwaheed18
        final String password="YOUR_PASSWORD";   //*******
final String to = "SENDER_EMAIL"; // abdulwaheed143@yahoo.co.in
final String from = "YOUR_EMAIL"; // abdulwaheed18@gmail.com


        Properties props = new Properties();
        props.put("mail.smtp.host", "smtp.gmail.com");
        props.put("mail.smtp.socketFactory.port", "465");
        props.put("mail.smtp.socketFactory.class",
        "javax.net.ssl.SSLSocketFactory");
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.port", "465");

        Session session = Session.getDefaultInstance(props,
                new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(username,password);
            }
        });

        try {
            Message message = new MimeMessage(session);
            message.setFrom(new InternetAddress(to));
            message.setRecipients(Message.RecipientType.TO,
                    InternetAddress.parse(from));
            message.setSubject("Hi");
            message.setText("Hi User,\n Surprise Message.\n Regards,\nWaheed");
            Transport.send(message);
            System.out.println(“Message sent Successfully");
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

Gmail SMTP Detail : http://support.google.com/mail/bin/answer.py?hl=en&answer=13287

Friday, August 24, 2012

Spring Auto-Wiring Beans with @Autowired annotation

In Spring, you can use @Autowired annotation to auto wire bean on the setter method, constructor or a field.

There are two ways to can achieve it :
1.Using <context:annotation-config />
Just Add Spring context and <context:annotation-config /> in bean configuration file

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <context:annotation-config />

</beans>

2. Using AutowiredAnnotationBeanPostProcessor
Add 'AutowiredAnnotationBeanPostProcessor' directly in your bean configuration file.

<bean 
class="org.springframework.beans.factory.annotation

.AutowiredAnnotationBeanPostProcessor"/>

And in Class, Just add annotation @Autowired above the setter function as seen below , You can do the same on constructor too:
class A {
private B b;

   @Autowired
   public void setB(B b) {
      this.b = b;
   }
}

Error:No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

To solve this problem. You have to do two things:

1. mark the DAO as transactional or function which is doing database call like:

@Transactional
   public class EmployeeDaoImpl extends DaoImpl implements EmployeeDao{
/////
}
           OR
@Transactional
    public long addEmployee(Employee employee) {
        System.out.println("Employee:"+employee );
        long id = employeeDao.addEmployee(employee);
        System.out.println("Id1: " );
        return id;
    }

2. Enable the annotation driven transcation management in applicationContext.xml (where your beans are defined):

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="transactionManager"
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    
<tx:annotation-driven transaction-manager="transactionManager"/>

That's it. Hope it works for other too.