寫
這個主題的文章在網絡上應該暫時沒有吧，也看過許多SSH整合開發的書，許多都是舊版本的框架整合，而且大部分都是以XML配置文件的方式，即使談到
Annotation也是針對其中一個框架而言的。隨著開源框架更新版本中不斷引進對Annotation的支持，使得我們可以用單方面去管理我們的類與
關系，而不用像以往那樣，一旦遇到問題，就要不斷在Java視圖和XML視圖中切換。好，開始吧，既然網絡中暫時沒有這方面的文章，我就來開創個先例。自
己探索學習一下，也讓大家來學習和提出批評和建議。
首選說一下我們的開發準備吧！
開發環境：Tomcat 6.0，JDK1.6，MySQL5.0
開發工具：Eclipse-jee(Eclipse的官網上下載)
所要下載的框架包：struts-2.0.11.2-all.zip，spring-framework-2.5.5-with-dependencies.zip，hibernate-distribution-3.3.1.GA-dist.zip，這三個壓縮包在其官方網站都可以下載。當然，這個小項目所要用到不止這些，我們用到的時候再去下載。
好，我們來開始第一階段的探索——Hibernate3.3的Annotation的實現。
新建我們的Dynamic Web Project，取名為"ssh_annotation”，配置Tomcat6.0的支持，打開MySQL，建立一個空數據庫，取名為"ssh_annotation"。記得，要引進MySQL的JDBC驅動包mysql-connector-java-5.0.8-bin.jar。
在解壓縮的hibernate-distribution-3.3.1.GA目錄中，把hibernate.jar，和"lib"required"下的所用jar包引進到我們項目的lib目錄下。
不知道用過Hibernate3.3開發的朋友會不會遇到過這樣的問題：把上面的包都準備好的，開發Hibernate測試類時，會報Caused by: java.lang.NoClassDefFoundError: org/slf4j/impl/StaticLoggerBinder 或者Caused by: java.lang.NoClassDefFoundError: org/apache/log4j/LogManager的錯誤。這是因為Hibernate3.3提供的jar包，缺少了slf4j-log4j12.jar這個包。解決辦法是：在Hibernate的官方網站上下載hibernate-annotations-3.4.0.GA.zip，解壓縮，把其"lib"下的slf4j-log4j12.jar引進我們項目的lib目錄下。而我們引進這個jar包后，若我們沒有引進log4j.jar的話，就會報java.lang.NoClassDefFoundError: org/apache/log4j/LogManager的錯誤，可能是slf4j-log4j12.jar要用調用log4j的類吧。我們也引進log4j.jar即行。
當然，
hibernate-annotations-3.4.0.GA.zip 是我們開發Hibernate Annotation所要用到的，除以上面那些jar包外，我們還要引進其
hibernate-annotations.jar，及其"lib"下的
hibernate-commons-annotations.jar，
ejb3-persistence.jar。好，暫時就這些，我們接下來需要用到哪些jar包時再引進。
好，第一步，來開發我們的實體類User。代碼如下：
package com.rong.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="tb_user")
public class User {
@Id @GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
@Column(name="username", length=15)
private String username;
@Column(name="password", length=15)
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
簡單解釋一下吧：
@Entity定義User類為實體類，@Id定義該屬性對應的列為主
鍵，@GeneratedValue(strategy=GenerationType.IDENTITY)定義主鍵生成策略為Indentity，適用
于MySQL和MS SQL等數據庫。@Column(name="username", length=15)定義列名和取值長度。
應該不難的，更多有關Hibernate的注解，請下載并參考我整理的Hibernate Annotation幫助文檔
/Files/rongxh7/hibernateAannotations.rar 。慢慢學吧！
當然，必要的XML配置文件還是要有的：
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/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/ssh_annotation</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<!-- 數據庫言 -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- 將Session扔到線程里去處理 -->
<property name="current_session_context_class">thread</property>
<!-- 在控制臺打印SQL語句 -->
<property name="show_sql">true</property>
<!-- 自動把實體類與屬性映射成數據庫中的表與列 -->
<property name="hbm2ddl.auto">update</property>
<!--
<mapping resource="com/rong/entity/User.hbm.xml"/>
-->
<!-- 在Hibernate中注冊User實體類,區別于上面注釋掉的resource寫法 -->
<mapping class="com.rong.entity.User"/>
</session-factory>
</hibernate-configuration>
到這里，我們可以運行Tomcat，Hibernate會根據hbm2ddl.auto自動地把實體類與屬性轉變成數據庫中的表與列。但
這一步，要事先在數據庫中建立一個名為"ssh_annotation"的空數據庫。好了，看一下，你的數據庫中是否有"tb_user"的表生成了？！
接下來，我們來開發一個包裝器類，取名HibernateUtil，代碼如下：
package test.rong.hibernate;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
//用xxx.hbm.xml形式配置實體映射
//sessionFactory = new Configuration().configure().buildSessionFactory();
//用Annotation形式配置實體映射
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
學過Hibernate的朋友們，應該對這個類不陌生吧。在此，我就不多解釋啦，注意一下我注釋的地方就行。下面，我們來進行測試，下載最新版本的Junit4.5.jar，試一下感覺如何。當然，舊版本的應該也沒問題的啦！寫測試代碼如下：
package test.rong.hibernate;
import java.util.Iterator;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Before;
import org.junit.Test;
import com.rong.entity.User;
public class EntityTest {
private Session session;
@Before
public void initSession(){
this.session = HibernateUtil.getSessionFactory().getCurrentSession();
}
@Test //測試添加用戶
public void testSave(){
session.beginTransaction();
User user = new User();
user.setUsername("rongxh7");
user.setPassword("blogjava");
session.save(user);
session.getTransaction().commit();
}
@Test //測試查詢用戶列表
@SuppressWarnings("unchecked")
public void testQuery(){
session.beginTransaction();
Query query = session.createQuery("from User u");
List<User> users = query.list();
for(Iterator<User> it = users.iterator() ; it.hasNext() ; ){
User user = it.next();
System.out.println("username = " + user.getUsername());
}
session.beginTransaction().commit();
}
@Test //測試查詢單個用戶
public void testGet(){
session.beginTransaction();
User user = (User)session.get(User.class, 1);
System.out.println("username = " + user.getUsername());
session.getTransaction().commit();
}
@Test //測試查詢修改用戶
public void testUpdate(){
session.beginTransaction();
User user = (User)session.load(User.class, 1);
user.setPassword("hello blogjava");
session.update(user);
session.getTransaction().commit();
}
@Test //測試刪除用戶
public void testDelete(){
session.beginTransaction();
session.delete(session.load(User.class, 1));
session.getTransaction().commit();
}
}
到此，我們的Hibernate Annotation開發完成了。你成功了沒？如果有什么問題，請回復，我盡力為你解答！好，第一階段暫告一段落。不要忘記，我們是要做的是基于Annotatioln的SSH整合開發，讓我們一起期待下一階段吧！
基于Annotation的SSH整合開發，其實，并沒有我當初想像中那么順利。真正去做的時候，才發覺有許多問題。但不要緊，探索一下吧。在探索過程中學到知識，才是最重要的。
言歸正傳，現在，我們加入Spring的支持：把spring-framework-2.5.5"dist中的spirng.jar引進我們項目的lib目錄來，還要添加"lib"aspectj"下的兩個jar包，以支持切面編程。
必要的配置文件還是要的：
applicationContext-common.xml
<?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:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!-- 配置SessionFactory,由Spring容器來管理Hibernate -->
<!-- 非Annotation時,使用org.springframework.orm.hibernate3.LocalSessionFactoryBean,
它注入實體類的方式是setMappingResources(),而Hibernate Annotation所用的映射方式
不是mapping resource,而是mapping class,這就要用到LocalSessionFactoryBean的子類
AnnotationSessionFactoryBean了.因為AnnotationSessionFactoryBean它支持實體的注入
方式setAnnotatedClasses,即對應Hibernate中的mapping class.參見這兩個類的源代碼. -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 配置事務管理器 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory" />
</property>
</bean>
<!-- 配置事務的傳播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED" />
<tx:method name="update*" propagation="REQUIRED" />
<tx:method name="delete*" propagation="REQUIRED" />
<tx:method name="*" read-only="true" />
</tx:attributes>
</tx:advice>
<!-- 那些類的哪些方法參與事務 -->
<aop:config>
<aop:pointcut id="allServiceMethod" expression="execution(* com.rong.dao.*.*.*(..))" />
<aop:advisor pointcut-ref="allServiceMethod" advice-ref="txAdvice" />
</aop:config>
<!-- 使Spring關注Annotation -->
<context:annotation-config/>
<!-- 讓Spring通過自動掃描來查詢和管理Bean -->
<context:component-scan base-package="com.rong"/>
<!--
<bean id="userDao" class="com.rong.dao.UserDaoBean">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="userService" class="com.rong.service.UserServiceBean">
<property name="userDao" ref="userDao"/>
</bean>
-->
</beans>
關鍵的兩點：
<!-- 使Spring關注Annotation -->
<context:annotation-config/>
<!-- 讓Spring通過自動掃描來查詢和管理Bean -->
<context:component-scan base-package="com.rong"/>
這樣配置之后，就省去了上面注釋掉的DAO層和Service層等配置代碼。是不是很方便呢。
關于這一部分的XML代碼，我們下面還會作解釋。
來開發我們的DAO層吧,接口如下：
package com.rong.dao;
import java.util.List;
import com.rong.entity.User;
public interface UserDao {
public void save(User user);
public void delete(int id);
public void update(User user);
public List<User> query();
public User get(int id);
}
DAO層的實現類：
package com.rong.dao;
import java.util.List;
import org.springframework.stereotype.Repository;
import com.rong.entity.User;
@Repository("userDao") //聲明此類為數據持久層的類
public class UserDaoBean extends MyHibernateDaoSupport implements UserDao {
public void save(User user){
super.getHibernateTemplate().save(user);
}
public void delete(int id){
super.getHibernateTemplate().delete(super.getHibernateTemplate().load(User.class, id));
}
public void update(User user){
super.getHibernateTemplate().update(user);
}
@SuppressWarnings("unchecked")
public List<User> query(){
return super.getHibernateTemplate().find("from User");
}
public User get(int id){
return (User)super.getHibernateTemplate().get("from User", id);
}
}
大家可以看到，我們這里繼承的不是HibernateDaoSupport,而是我自己編寫的一個類MyHibernateDaoSupport。其代碼如下：
package com.rong.dao;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class MyHibernateDaoSupport extends HibernateDaoSupport {
@Resource(name="sessionFactory") //為父類HibernateDaoSupport注入sessionFactory的值
public void setSuperSessionFactory(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}
}
我們之所以要改寫HibernateDaoSupport，是因我為，我們要為DAO層的類注入SessionFactory這個屬性。
以后，我們開發的DAO類，就可以直接重用這個MyHibernateDaoSupport了。其實，這樣做是相當于配置文件方式的代
碼：
<bean id="userDao" class="com.rong.dao.UserDaoBean">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
我
們既然要用annotation代替XML文件的，就要讓它也能像原來那樣使用sessionFactory,故為
MyHibernateDaoSupport注入SessionFactory。子類繼承這個類時，也繼承其Annotation。這樣，我們就可以實現
SessionFactory的注入了。
到現在，我們再回過頭來看applicationContext-common.xml中的
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
我們平時開發Hibernate與Spring整合時，常常會用到
org.springframework.orm.hibernate3.LocalSessionFactoryBean來提供
SessionFactory，而我們這里卻要改成
org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean。
其實是這樣的，我們在Hibernate.cfg.xml中配置的實體類映射的方式如下：（詳見
基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合開發 (1) ）
<!--
<mapping resource="com/rong/entity/User.hbm.xml"/>
-->
<!-- 在Hibernate中注冊User實體類,區別于上面注釋掉的resource寫法 -->
<mapping class="com.rong.entity.User"/>
要使Hibernate的實體類支持注解，去掉xxx.hbm.xml的文件，故我們所用的是mapping
class方式，不是mapping
resource的方法。然而，LocalSessionFactoryBean這個類，它采用的實體類映射方式是mapping
resource，（詳情可參見LocalSessionFactoryBean這個類的源代碼）。如果我們在配置中仍然用這個類的
話，Hibernate與Spring整合時，就會報錯。而AnnotationSessionFactoryBean這個類在
LocalSessionFactoryBean的基礎上添加了mapping
class方式實現實體類映射（詳見AnnotationSessionFactoryBean類的源代碼）。
我們再來看Service層的代碼：（接口比較簡單，節約篇幅就不列出了）
package com.rong.service;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.rong.dao.UserDao;
import com.rong.entity.User;
@Service("userService") //聲明此類為業務邏輯層的類
public class UserServiceBean implements UserService {
@Autowired
private UserDao userDao;
public void save(User user){
userDao.save(user);
}
}
我們用到的注解上面一般都作了注釋，就不多敘。@Autowired和@Resource功能差不多，就是把對象注入，相當于<bean>配置的功能。
好，就開發到這樣，是不是忘記了什么？記得要配置web.xml，部分代碼如下：
<!-- 修改Spring配置文件的路徑 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext-*.xml</param-value>
</context-param>
<!-- 配置Spring -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
是不是真的成功了？用Junit測試一下吧，我測試過是沒問題的，由于篇幅，Junit的測試代碼就不貼出來了。自己練習一下吧！
其實，到現在為止，我們發覺我們的XML配置文件還是很多。其實，這樣想想，上一階段我們省去了xxx.hbm.xml這類的文件，這一
階段，我們少去了<bean id="" class=""><property name=""
ref="">這樣的配置項。而這些，正是我們項目開發中，大量使用的配置。而只要書寫簡單的Annotation注解，就可以省去這樣，我們何樂
而不用。而那些我們保留的XML配置文件（如：數據庫連接，事務），這樣是寫死的，一個項目就寫一次或復制過來用，我們保留它又何妨？
好，暫時到這里，我們還有下一階段的基于Annotation的SSH整合開發，我們將會以一個用戶注冊的例子，把Struts2的注解帶到我們的整合開發中來。一起期待吧！
(*^-^*) 本文原創，轉載請注明出處， http://www.tkk7.com/rongxh7謝謝! (*^-^*)