Maven – Spring – Hibernate – Wicket Entegrasyonu
İzleyeceğimiz adımlar:
1. Maven kurulumu
2. Pom.xml'in oluşturulması, Spring Container'i için gerekli paket bağımlılık ayarlarının yapılması
3. Spring application-context.xml'in oluşturulması ve basit bir uygulama ile injection yönetiminin test
edilmesi
4. Hibernate paket bağımlılık ayarlarının yapılması ve Hibernate konfigurasyonunun gerçekleştirilmesi
5. Wicket için pom.xml üzerinde paket bağımlılık ayarlarının yapılması
6. Spring application-context.xml ve web.xml de Spring ve Wicket ayarlarının yapılması
Maven kurulumu için www.maven.org sitesinden maven paketini indirip açtıktan sonra içerisindeki bin
klasörününü de sistemin “Ortam Değişkenleri”ne tanımlayabilirsiniz.
mvn archetype:create -DgroupId=org.jtpd
-DartifactId=maven_spring_hibernate_wicket
-DpackageName=org.jtpd.mshw
komutunu kullanarak maven projemizi oluşturalım.
Oluşan pom.xml :
<project ...>
<modelVersion>4.0.0</modelVersion>
<groupId>org.jtpd</groupId>
<artifactId>maven_spring_hibernate_wicket</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>maven_spring_hibernate_wicket</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-jdk14</artifactId>
<version>1.4.2</version>
</dependency>
</dependencies>
</project>
Oluşan dizin yapısı:
maven_spring_hibernate_wicket/
maven_spring_hibernate_wicket/pom.xml
/src/
/src/main/
/main/java
/src/test/
/test/java
Log4j, Spring gibi konfigurasyon dosyalarını koymak için /src/main/resources dizinini ve web dosyalarını
koymak için /src/main/webapp oluşturalım. Ve sonrasında pom.xml'i açıp aşağıdaki ayarlamaları yapalım.
<build>
<resources>

<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
</build>
Gelin şimdi Spring & Hibernate paket bağımlılıklarını ayarlayalım:
<dependencies>
...
<!-- SPRING DEPENDENCIES -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- HIBERNATE DEPENDENCIES -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>persistence-api</artifactId>
<version>1.0</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-annotations</artifactId>
<version>3.4.0.GA</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>3.4.0.GA</version>
</dependency>
...
</dependencies>

<properties>
<spring.version>2.5.6</spring.version>
</properties>
Spring konfigurasyonunu gerçekleştirelim. Bunun için src/main/resources altında application-context.xml
dosyasını oluşturalım.
<?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:util="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-2.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.1.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"
>
<context:annotation-config />
<context:component-scan base-package="org.jtpd" />
<aop:aspectj-autoproxy />
<tx:annotation-driven />
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBe
an">
<property name="dataSource" ref="dataSource" />
<property name="annotatedClasses">
<list>
<value>org.jtpd.core.User</value>
<value>...</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop
key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>
<bean id="dataSource"
class="com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource" destroy-
method="close">
<property name="url" value="jdbc:mysql://db.jtpd.org:3306/jtpd" />
<property name="user" value="root" />
<property name="password" value="****" />
</bean>

<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
<property name="dataSource" ref="dataSource"/>
</bean>
</beans>
Yukarıdaki konfigurasyonda, spring injectionlarının ve transaction tanımlarının annotationlar üzerinden
yapılacağı belirtilir.
Uygulama içerisindeki kullanımı
@Entity
@Table(name=”User”)
public class User {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
...
}
@Repository //Spring Annotation
@Transactional
public abstract GenericDAO<T> {
@Autowired //Spring Annotation
private SessionFactory sessionFactory;
public Session getSession(){
return sessionFactory.openSession();
}
public void save(T entity){
getSession().save(entity);
}
}
@Repository //Spring Annotation
@Transactional
public class UserDAO extends GenericDAO<User> {
...
}
@Service //Spring Annotation
@Transactional
public UserService {
@Autowired //Spring Annotation
private IuserDAO userDAO;
//Ornek
public void save(User user){
// Transaction Yönetimi spring tarafindan yapilmakta
userDAO.save(user);
}
}
Şu ana kadar yazmış olduğumuz kod örneğini ve konfigurasyonu test etmek için standalone çalışabilecek bir
kod çalışması yapalım. Öncelikle pom.xml içerisinde aşağıdaki konfigurasyonu yapalım.
<build>

<plugins>
...
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>java</goal>
</goals>
</execution>
</executions>
<configuration>
<mainClass>org.jtpd.App</mainClass>
</configuration>
</plugin>
...
</plugins>
</build>
org.jtpd.App java dosyasını oluşturalım:
package org.jtpd;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class App {
public static void main(String[] args) {
try {
ApplicationContext factory = new
FileSystemXmlApplicationContext(
"targetclassesapplication-context.xml");
IUserService userService = (IUserService) factory
.getBean("userService");
userService.save(new User());
} catch (Exception e) {
e.printStackTrace();
}
}
}
App sınıfını komut satırından
mvn exec:java
komutu ile çalıştırabiliriz.
Herşey istediğimiz gibi ise şimdi geliştirdiğimiz yapıyı web uygulaması haline getirelim. Bunun için
pom.xml'de :
<dependencies>
...
<dependency>
<groupId>org.apache.wicket</groupId>
<artifactId>wicket-spring</artifactId>

<version>${wicket.version}</version>
</dependency>
<dependency>
<groupId>org.apache.wicket</groupId>
<artifactId>wicket</artifactId>
<version>${wicket.version}</version>
</dependency>
<dependency>
<groupId>org.apache.wicket</groupId>
<artifactId>wicket-extensions</artifactId>
<version>${wicket.version}</version>
</dependency>
</dependencies>
...
<properties>
<wicket.version>1.4.0</wicket.version>
<spring.version>2.5.6</spring.version>
</properties>
src/main/webapp altında WEB-INF/web.xml dosyasını oluşturalım ve aşağıdaki konfigurasyonları
tanımlayalım
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
version="2.4">
<display-name>JTPD</display-name>
<filter>
<filter-name>wicket-spring-hibernate</filter-name>
<filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-
class>
<init-param>
<param-name>applicationFactoryClassName</param-name>
<param-value>org.apache.wicket.spring.SpringWebApplicationFactory</
param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>wicket-spring-hibernate</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application-context.xml</param-value>
</context-param>
<listener>
<listener-
class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
</web-app>

Web.xml de Spring ve Wicket çatılarına ait tanımlamaları yaptık.application-context.xml içerisinde de Wicket
uygulamasını tanımlamamız gerekiyor. Web.xml içerisinde WicketFilter konfigurasyonunda Wicket çatısına
aşağıdaki WebApplication sınıfını hangi factory üzerinden alacağımızı belirtiyoruz. Burada Wicket ile Spring
entegrasyonunu gerçekleştirmiş oluyoruz.
...
<bean id="wicketApplication" class="org.jtpd.web.JTPDWicketApplication" />
...
Şu ana kadar Maven, Spring, Hibernate ve Wicket entegrasyonunu bir şekilde gerçekleştirmiş
bulunmaktayız. Fakat Wicket bileşenlerinden Spring bean'lerine injection yöntemiyle erişmek için
JTPDWicketApplication sınıfının yapılandırıcı yordamlarında
addComponentInstantiationListener(new SpringComponentInjector(this));
çağırımlarını yapmamız gerekmektedir.
JTPDWicketApplication sınıfı :
package org.jtpd.web.JTPDWicketApplication;
import org.apache.wicket.protocol.http.WebApplication;
import org.apache.wicket.spring.injection.annot.SpringComponentInjector;
/**
* Application object for your web application.
* <p/>
* If you want to run this application without deploying, run the Start class.
*/
public class JTPDWicketApplication extends WebApplication {
/* (non-Javadoc)
* @see org.apache.wicket.protocol.http.WebApplication#init()
*/
@Override
protected void init() {
// TODO Auto-generated method stub
super.init();
addComponentInstantiationListener(new
SpringComponentInjector(this));
}
@Override
public Class<Index> getHomePage() {
return Index.class;
}
}
WebApplication, WebPage gibi Wicket bileşenleri içerisinden Spring bean'lerini kullanabilmek için
@SpringBean annotation'ını kullanmamız gerekmektedir. JTPDWebApplication içerisinden çağırılan
Index.class yani WebPage'den türeyen Index sınıfını oluşturalım ve buradan userService Spring Bean'ini
nasıl çağırdığımızı görelim.
package org.jtpd.web;
/**
* @author tdiler
*
*/
import org.apache.wicket.PageParameters;

import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.spring.injection.annot.SpringBean;
import org.jtpd.core.IUserService;
import org.jtpd.core.User;
/**
* Homepage
*/
public class Index extends WebPage {
private static final long serialVersionUID = 1L;
@SpringBean
IUserService userService;
public Index(final PageParameters parameters) {
User user = new User();
userService.save(user);
add(new Label("label", "Kullanıcı kaydedildi."));
}
}
Wicket çatısında yazılan WebPage, Panel gibi bileşenler için markup tanımlarını içeren sınıf ile aynı isimde *.html
uzantılı dosyalar bulunmalıdır. Maven ile derleme ve paket oluşturma sonucunda bu html dosyalarınında
değerlendirilmesi için pom.xml’de şu eklemeyi yapacağız:
<resources>
...
<resource>
<filtering>false</filtering>
<directory>src/main/java</directory>
<includes>
<include>**</include>
</includes>
<excludes>
<exclude>**/*.java</exclude>
</excludes>
</resource>
...
</resources>
İlgili çalışmaya ait kodlara buradan ulaşabilirsiniz.