MyArchiBook

Archive for the ‘Spring’ Category

Spring + JPA – Example with Exception/Error – Fixing

with 7 comments

In this post ,I have given a  simple example on how to use JPA in Spring Framework.
You can find the source code of the below example in my Github link here.

I have considered a MusicStore example, where i just get the list of Songs from the database.

TOOLS USED:

Framework: Spring
Persistence API : JPA 2.0
Build : Maven
Database : MySQL
JPA Provider : Hibernate-JPA Provider

While I was working on integrating JPA into Spring , I felt that, the most important part to concentrate on , is the CONFIGURATION area.

So,let’s get started with application-context.xml and persistence.xml

app-context.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:p="http://www.springframework.org/schema/p"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:jdbc="http://www.springframework.org/schema/jdbc"
  xsi:schemaLocation="
   http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.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-3.0.xsd
   http://www.springframework.org/schema/jdbc
   http://www.springframework.org/schema/jdbc/spring-jdbc-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="aish.vaishno.*" />    
 
<tx:annotation-driven transaction-manager="transactionManager"/>
 
<bean id="transactionManager"
  class="org.springframework.orm.jpa.JpaTransactionManager">
     <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>

 <bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:dataSource-ref="dataSource" p:persistenceUnitName="simple-jpa">
 </bean>
 
 <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/MUSIC_STORE"/>
        <property name="username" value="music_store"/>
        <property name="password" value="music_store"/>  
    </bean>
    
</beans>

  • DIFFERENCE BETWEEN <context:annotation-config> AND <context:component-scan base-package=”…..”>

<context:annotation-config> -Enables the usage of JPA annotations(@Service, @Component, @Repository, @Controller  and etc.,)
<context:component-scan base-package=”…..”> – This component-scan tag also enables the usage of JPA annotations.

Then the difference ???

(i) annotation-config —> enables the usage of JPA annotations , only in the beans specified in the context.xml whereas (ii) component-scan —> scans through all the packages specified, records all the  project beans having JPA annotations, into this context.xml. Therefore it enables JPA annotaion usage in (beans specified in context.xml)+(Project Beans).

Inshort, <component-scan> extends <annotation-config>.

When we use <component-scan> in the app-context.xml, it’s not necessary to use  <annotation-config> again.

Even if both  the tags are specified, it’s not a problem because, the spring container would take care of running the process only once.

  • <tx:annotation-driven transaction-manager=”transactionManger”/> – It checks for @Transactional annotation  in any of the classes. This tag is like a Transactional Switch that turns on the transactional behaviour.Here Transaction Manager is being injected .
  • <bean id=”transactionManager”>– Here Transaction Manager is setup.

Here EntityManagerFactory is being injected.

  • <bean id=”entityManagerFactory”>– Here EntityManagerFactory is setup .Data Source reference and Persistence UnitName Reference is specified.
  • <bean id=”dataSource”> – DB connection details are specified.
  • Persistence UnitName Reference – Based on the PersistenceUnit name, the corresponding portion of persistence.xml is accessed (a Project can have multiple persistenceUnitNames)

persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="simple-jpa" transaction-type="RESOURCE_LOCAL">
    <provider>org.hibernate.ejb.HibernatePersistence</provider>
    <class>aish.vaishno.musicstorespringjpa.pojo.MusicDetails</class>
    <exclude-unlisted-classes>true</exclude-unlisted-classes>
    <properties>
      <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/> 
      <property name="hibernate.show_sql" value="true"/>
      <property name="hibernate.max_fetch_depth" value="3"/> 
    </properties>
  </persistence-unit>
</persistence>

Here in persistence.xml,

  • persistence-unitName is declared
  • provider – In this example, I have used Hibernate provider.
  • Entity Bean Class is specified
  • properties- Few settings(like showSQL=true) required are specified.

Configuration part is over. Now that, it’s time to use the annotations in our Dao class to make the Spring – JPA work.

POJO : MusicDetails.java

DaoInterface :

public interface IMusicStoreDao {
   public List getMusicList();
}

DaoImplementation :

@Service(value = "MusicCollections")
@Repository(value = "MusicCollections")
@Transactional
public class MusicStoreDaoImpl implements IMusicStoreDao{

  @PersistenceContext(unitName = "simple-jpa")
    private EntityManager entityManager;

   @Override
     public List getMusicList(){
     List musicDetailsList= entityManager.createQuery("select c from MusicDetails c").getResultList();
     return musicDetailsList;
    }
}

Executer:

public class Executer {
   public static void main(String[] args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("META-INF/app-context.xml");
        IMusicStoreDao musicStoreDao=(IMusicStoreDao) applicationContext.getBean("MusicCollections");
        System.out.println("MusicList: \n"+musicStoreDao.getMusicList());
    }
}

Now , when you run this main class, for sure , you would only get Errors and Exceptions :-P.
Because, we have not yet added the DEPENDENCY JARS.
Below , I have given a note on the Errors and Exceptions that would arise and the corresponding jars to be added to clear that particular problem.

You can find the Maven dependency tags for the below jars in my Github pom.xml

ERRORS/EXCEPTIONS AND THE CORRESPONDING JARS TO BE ADDED:

  • ERRORException in thread “main” java.lang.ClassFormatError: Absent Code attribute in method that is not native or abstract in class file javax/transaction/SystemException. 
  • JAR: javaee5-api.jar . Do not forget to specify the scope as “provided”, otherwise the error will still persist.
  • ERROR: Exception in thread “main” java.lang.ClassFormatError: Absent Code attribute in method that is not native or abstract in class file javax/persistence/EntityManager.
  • JAR: hibernate-jpa2-api.jar
  • EXCEPTION: ClassNotFoundException : org.hibernate.ejb.HibernatePersistence
  • JAR: hibernate-entitymanager.jar
  • ERROR: NoClassDefFoundError: org/slf4j/impl/StaticLoggerBinder
  • JARS: slf4j-api.jar, slf4j-jcl-over.jar ( scope-RUNTIME ), slf4j-log4j12.jar ( scope-RUNTIME )
  • Do not forget to add the respective JDBC jar.

Now the program can be executed.

RESULT:

Result

Have a great day 🙂

Advertisements

(Spring – MVC+Hibernate –> Annotation based), MySql , Maven, JSON – Simple Example

with 20 comments

Hi! For the past few days, I have been trying out on Spring – MVC, Hibernate, Maven, MySql and JSON . So I thought, if I could blog about it today with a simple example.

In this post , I have used Hibernate to persist data in the back end  and JSON to display results in the front end.

You can get the below example’s complete source code from my GitHub link here —> https://github.com/AishwaryaThangavelu/Spring-Repository/tree/master/MusicStore.

Let’s take a look at it now.

INFORMATION:

  •  Tool used : NetBeans 7.3
  •  Framework : Spring-mvc-archetype – 3.X
  •  JPA: Hibernate
  •  Build : Maven 2.2
  •  Database Server : MySql
  •  WebApp Server :Tomcat 7

I have considered MusicStore example where I Add Songs and display a list of Songs.

OVERVIEW :

Flow

Flow of Application

STEPS:

1. TO CREATE A TABLE IN MySQL: 

  • Create DB – “CREATE DATABASE MUSIC_STORE;”
  • Create Table 
CREATE TABLE MUSIC_COLLECTIONS(
MC_ID INTEGER(50),
MC_LANGUAGE VARCHAR(50),
MC_TYPE VARCHAR(50),
MC_SONG_NAME VARCHAR(50)
);
  • To give Grant permission for accessing the Database- 

GRANT ALL PRIVILEGES ON MUSIC_STORE.* TO ‘music_store’@’localhost’ IDENTIFIED BY ‘music_store’;

Folder Structure

Folder Structure

2. CREATA A NEW SPRING-MVC PROJECT:

I have used Maven coupled Spring-mvc-archetype.

This Spring-mvc-archetype makes me too comfortable providing me the template as such.My duty is to just to work on the main coding part.

3.CREATE A POJO CLASS(Here MusicDetails.java):

@Entity
@Table(name = "MUSIC_COLLECTIONS")
public class MusicDetails implements Serializable {

 @Id
 @Column(name = "MC_ID")
 private Integer musicID;

@Column(name = "MC_LANGUAGE")
 private String musicLanguage;

 @Column(name = "MC_TYPE")
 private String musicType;

 @Column(name = "MC_SONG_NAME")
 private String songName;

public Integer getMusicID() {
 return musicID;
 }

public void setMusicID(Integer musicID) {
 this.musicID = musicID;
 }

public String getMusicLanguage() {
 return musicLanguage;
 }

public void setMusicLanguage(String musicLanguage) {
 this.musicLanguage = musicLanguage;
 }

public String getMusicType() {
 return musicType;
 }

public void setMusicType(String musicType) {
 this.musicType = musicType;
 }

public String getSongName() {
 return songName;
 }

public void setSongName(String songName) {
 this.songName = songName;
 }
}

Now let’s connect our applicationProject with the database.

4. CONFIGURATION:

Hibernate.cfg.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
                                         "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <!-- Database connection settings -->
  <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="connection.url">jdbc:mysql://localhost:3306/MUSIC_STORE</property>
  <property name="connection.username">music_store</property>
  <property name="connection.password">music_store</property>
  <!-- JDBC connection pool (use the built-in) -->
  <!--<property name="connection.pool_size">20</property>-->
  <property name="hibernate.c3p0.acquire_increment">3</property>
<property name="hibernate.c3p0.idle_test_period">14400</property>
<property name="hibernate.c3p0.timeout">25200</property>
<property name="hibernate.c3p0.max_size">15</property>
<property name="hibernate.c3p0.min_size">3</property>
<property name="hibernate.c3p0.max_statements">0</property>
<property name="hibernate.c3p0.preferredTestQuery">select 1;</property>
  <!-- SQL dialect -->
  <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
  <!-- Enable Hibernate's automatic session context management, in this case the session will be close after each transaction! -->
  <property name="current_session_context_class">thread</property>
  <!-- Disable the second-level cache -->
  <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
  <!-- Echo all executed SQL to stdout -->
  <property name="show_sql">true</property>
  <!-- auto create tables -->
  <property name="hbm2ddl.auto">update</property>
  <!-- Mappings -->
  <mapping class="aish.vaishno.musicstore.pojo.MusicDetails"/>
</session-factory>
</hibernate-configuration>
  • line 8 , connection with the particular DB with specific grant permitted username and password is specified
  • In line 31 POJO class maping is specified.

5.HIBERNATE SESSION MANAGER:

public class HibernateSessionManager {

 private static SessionFactory sessionFactory = buildSessionFactory();

 private static SessionFactory buildSessionFactory(){
 try{
   sessionFactory=new Configuration().configure("/hibernate.cfg.xml").buildSessionFactory();
   return sessionFactory;
 }
 catch(Throwable ex){
   System.err.println("Session Factory Initialization error"+ex);
   throw new ExceptionInInitializerError(ex);
  }
 }

 public static SessionFactory getSessionFactory() {
   return sessionFactory;
 }

 public static void shutdownConnection(){
   getSessionFactory().close();
 }
}

Specify mySql-connector-java.jar and javassist.jar dependency in pom.xml to establish connection with DB

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.15</version>
</dependency>

<dependency>
  <groupId>javassist</groupId>
  <artifactId>javassist</artifactId>
  <version>3.12.0.GA</version>
</dependency>

6.PERSISTENCE LAYER:

    • MusicStore DAO Interface creation:

Here I have created 2 methods as specified earlier,
 One method:  to add new songs
Second method: to get the List of Songs available

public interface IMusicStoreDao {

   public String addSong(MusicDetails musicDetails);
   public List getSongList();

}
  • Music Store Dao Implementation Class:

Here I have specified @Service inorder to inject it into Service Layer class.

@Service
public class MusicStoreDaoImpl implements IMusicStoreDao{

 @Override
 public String addSong(MusicDetails musicDetails) {
   SessionFactory sessionFactory= HibernateSessionManager.getSessionFactory();
   Session session=sessionFactory.openSession();
   Transaction transaction=session.beginTransaction();
   try{
     transaction.begin();
     session.save(musicDetails);
     session.flush();
     transaction.commit();
     return "Music Details has been entered";
   }catch(HibernateException hb){
     transaction.rollback();
     System.err.println("error"+hb);
     return "Sorry some problem has occured. Try Again";
   }finally{
     session.close();
   }
 }

 @Override
 public List getSongList() {
   SessionFactory sessionFactory=HibernateSessionManager.getSessionFactory();
   Session session=sessionFactory.getCurrentSession();
   Transaction transaction=session.beginTransaction();
   try{
     transaction.begin();
     List songList=session.createQuery("from MusicDetails").list();
     return songList;
   }finally{
     session.close();
   }
  }
 }

7.SERVICE LAYER:

  •     Service Layer Interface Creation :
public interface IMusicStoreService {
  public String addSong(MusicDetails musicDetails);
  public List getSongList();
}
  •    Music Service Implemetation Class Creation :

I have annotated this class with @Service because later , in the controller I will be Injecting this class.You can see that IMusicStoreDao is Autowired which means I have injected it in this class and that is why I specified @Service annotation in MusicStoreDao class.

@Service
public class MusicStoreServiceImpl implements IMusicStoreService{

 @Autowired
 private IMusicStoreDao musicStoreDao;

@Override
 public String addSong(MusicDetails musicDetails) {
   return musicStoreDao.addSong(musicDetails);
 }

@Override
 public List getSongList() {
    return musicStoreDao.getSongList();
 }
 }

I have also specified @ComponentScan in Configuration class to scan through the packages containing the respective classes with @Service annotation.

8.PRESENTATION LAYER:

Controller:

I have Autowired IMusicStoreService class

@Controller
public class HomeController {

@Autowired
 private IMusicStoreService musicStoreService;

 @RequestMapping(value="/")
 public ModelAndView test(HttpServletResponse response) throws IOException{
    return new ModelAndView("home","musicDetForm",new MusicDetails());
 }

 @RequestMapping(value="AddSong",method = RequestMethod.POST)
 @ResponseBody
 public String addSong(@ModelAttribute("musicDetForm") MusicDetails musicDetails){
    return musicStoreService.addSong(musicDetails);
 }

 @RequestMapping(value="SongList/",method = RequestMethod.GET)
 @ResponseBody
 public List<MusicDetails> getSongList(){
    return musicStoreService.getSongList();
 }
}

RUNTIME DEPENDENCY JAR’S TO BE ADDED:
Below are few runtime dependencies to be added in pom.xml to avoid Logging Factory and Load Class error.

<dependency>
   <groupId>org.slf4j</groupId>
   <artifactId>jcl-over-slf4j</artifactId>
   <version>1.6.1</version>
   <scope>runtime</scope>
 </dependency>
 <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.6.1</version>
    <scope>runtime</scope>
 </dependency>
 <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.16</version>
    <scope>runtime</scope>
</dependency>

RESULTS:

1.ADD SONG :  I created the form using Simple-Spring Form Handling.You can find details about it in this link, refer to

https://aishwaryavaishno.wordpress.com/2013/06/22/simple-form-handling-and-performing-dependency-injection-in-spring-mvc-framework-using-netbeans/ 

and I have displayed the result .

AddSongResult

AddSongResult

MusicStoreForm

MusicStoreForm

2.SONG LIST DISPLAY :Here I have used JSON format to display result.
JSON:

  •   JSON(Java Script Object Notation) is a data transfer format,used for exchanging data between client and server-side application.
  • It is much like XML. No, actually it is easier than XML bcoz it is easy to understand, language independent and has parsers available for most of the languages(one eg: eval()).
  • It provides me the flexibility of writing just one application and runnning it on any type of application.

For this application, all that u need to know about JSON is, just

  • add the below Jackson Library dependency into the pom.xml
<dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-mapper-asl</artifactId>
    <version>1.9.12</version>
</dependency>
 
  • Specify @ResponseBody JSON-REST Service.
  • Specify the Mapping properly in the Controller .

The “REST” JSON will take care.

Now when you hit the URL link, the JSON result will be as below for SongList.
SongList

That’s it.. 🙂

Hope it’s informative.. Have a great day !!!!

Written by thangaveluaishwarya

July 12, 2013 at 10:09 AM

Simple Form Handling and Performing Dependency Injection in Spring MVC Framework using NetBeans

with 6 comments

  I thought  working on Spring MVC Framework– to handle xml, configurations etc.,was a geeky kindaa job.  But I also recently learnt that , working on it using an IDE like NetBeans which provides the Spring MVC Template(pom.xml, MVC Configurations etc.,) and also the Maven build  has made me focus mainly on the design and coding part of my project , thus saving my time and leaving me unstrained .

Below I have created Simple Form Handling Application using Spring MVC Framwork(3.X).In this sample,I have also implemented Dependency Injection – annotation based .

IDE used:NetBeans 7.3

Build used:Maven 2.2

JspConsider 2 Jsp’s

Jsp 1  : MusicForm.jsp contains the text boxes to be entered.

Jsp 2 : Output.jsp conatins the TEXTS of,

  •          Object transferred from Jsp 1
  •          Object got through DEPENDENCY INJECTION

FLOW:

1.Bean : SongDetails Bean with setters and getters is created

2.Interface : IMusicService Interface is created. It has three unimplemented methods play(), pause(), stop();

3.Service Implementation class :MusicServiceImpl class that implements the above interface and its unimplemented methods is created.

@Service
public class MusicServiceImpl implements IMusicService{
@Override
 public String play() {
 return "Music is played on!!!";
 }

@Override
 public String pause() {
 return "Music has been PAUSED !";
 }

@Override
 public String stop() {
 return "Music Stopped";
 }
}

Note  that there is @Service annotation before the class name… Please have it in mind.Will tell you why, when it’s time of usage has come.

4. Jsp and Controller:

4.a) HomePage(MusicForm) Jsp and Controller :

MusicForm

Here in MusicForm.jsp, the details to be transferred is enclosed in a form.Form has the following attributes,

  • Method type – GET/POST is specified here.
  • commandName -Here we can specify name of the Object , that carries the SongDetails (above commandName is songDetForm )
  • action- Here OutCome jsp name, where the details are to be transferred is specified.

For the above Jsp , controller method has to be written.The flow goes like this,

  • ModelAndView object is created
  • ViewName is set
  • SongDetails Object is initialised and set as songDetForm (must be same as commandName in jsp).

4.b)Output jsp and Controller:

Output

Here in this Controller,

  • Output jsp name is given as the Request mapping value
  • Request method is POST as specified in First Jsp
  • View Name is set.
  • Then Two Objects are set—->1.songDetForm, 2.object got through dependency injection
  • To set songDetForm obj,
  1. Object is got from HomePageController method via @ModelAttribute(“songDetForm”)SongDetails songDetails. This means , object or attribute in the name “songDetForm” is assigned to songDetails object.
  2. This object is then added in a HashMap
  • To set Dependency injection object,
  1. IMusicService private instance is created .It is annotated with @Autowired.
  2. Apart from this, @Service annotation has to be specified on the ServiceImplementation class . This means, MusicServiceImpl class is at Service which can be injected ,when @Autowired annotation is used over its Interface instance.
  3.  In MVC Configuration, the package be scanned is specified and Component Scan is done.
  4. then dependencyObject is  added in the Controller method map.
  • Both these objects along with viewName are set in mv and mv is returned.

The controller sourcecode will look like,

@Controller
public class HomeController {

 @Autowired
 private IMusicService iMusicService;

 @RequestMapping(value="/")
 public ModelAndView homePage(){
 //Method 1:
 ModelAndView mv=new ModelAndView();
 mv.setViewName("MusicForm");
 mv.addObject("songDetForm",new SongDetails());
 return mv;

 //Method 2:                  viewName      Obj Key        Obj Value
 // return new ModelAndView("MusicForm","songDetForm",new SongDetails());
 }

 @RequestMapping(value ="/Output", method = RequestMethod.POST)
 public ModelAndView processSongDetails (@ModelAttribute("songDetForm") SongDetails songDetails){
 Map<String,Object> obj=new HashMap<String,Object>();
 obj.put("songDetails",songDetails);
 obj.put("iMusicService", iMusicService);
//                                            viewName  Obj
 ModelAndView modelAndView = new ModelAndView("Output", obj);
 return modelAndView;
 }
}
  • In the respective Output.jsp , the respective objects are got.

5. Clean the project.

6.Build it using Maven… The most advantageous part about Maven is , I needn’t have to strain myself to provide any dependency jars, specify its classpath etc.,  everytime. Maven took care of that part by itself, thus making my code-writing easy and simple.

7.Run it.

The output will be as follows…

WebPageResult

That’s it about Form Handling and Dependecy Injection in Spring MVC Framework.

You can find and download the above source code from this link.  https://github.com/AishwaryaThangavelu/Spring-Repository

Written by thangaveluaishwarya

June 22, 2013 at 3:49 AM