`
yuanfen860913
  • 浏览: 114556 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
文章分类
社区版块
存档分类
最新评论

基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发

阅读更多

基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (1)
写这个主题的文章在网络上应该暂时没有吧,也看过许多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整合开发,让我们一起期待下一阶段吧!

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/JustANobody/archive/2010/05/30/5634668.aspx




基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (2)

基于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的注解带到我们的整合开发中来。一起期待吧!

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/JustANobody/archive/2010/05/30/5634680.aspx




基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发 (3)
进入我们基于Annotation的Struts2.0+Hibernate3.3+Spring2.5整合开发的最后一个阶段了,这阶段主要为我们的项目引进Struts2的Annotation。相对于带Annotation的Hibernate与带Annotation的Spring整合来说,带Annotation的Struts与带Annotation的Spring整合还是比较容易实现的。
我们先来引进Struts2.0的相关jar包:xwork-2.0.5.jar,struts2-core-2.0.11.2.jar,ognl-2.6.11.jar,commons-logging.jar(这个前面已引进),freemarker-2.3.8.jar,还有Struts2.0与Spring整合所需的struts2-spring-plugin-2.0.11.2.jar。好,马上来开发我们的用户注册小例子。
register.jsp注册页的部分代码如下:

<s:form action="register">
<s:textfield name="username"/>
<s:password name="password"/>
<s:submit value="注册"/>
</s:form>
<s:fielderror></s:fielderror>

success.jsp注册成功页部分代码如下:

注册成功!你好,<s:property value="username"/>!

好,来开发我们的控制层吧。写个RegisterAction.java的类:

package com.rong.action;

import javax.annotation.Resource;
import org.apache.struts2.config.ParentPackage;
import org.apache.struts2.config.Result;
import org.apache.struts2.config.Results;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.validator.annotations.RequiredStringValidator;
import com.rong.entity.User;
import com.rong.service.UserService;

@Controller @Scope("prototype") //声明此类为控制层的类,且为prototype模式调用
@ParentPackage(value="struts-default")
@Results({
@Result(name="success",value="success.jsp"),
@Result(name="input",value="register.jsp")
})
public class RegisterAction extends ActionSupport {

@Resource(name="userService")
private UserService userService;

private String username;
private String password;

@Override
public String execute() throws Exception {
User user = new User();
user.setUsername("rongxinhua");
user.setPassword("blogjava");
userService.save(user);
return SUCCESS;
}

public String getUsername() {
return username;
}

@RequiredStringValidator(message = "请输入用户名!")
public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return password;
}

@RequiredStringValidator(message = "请输入密码!")
public void setPassword(String password) {
this.password = password;
}

}


Spring2.5通过@Controller @Scope("prototype") 这样的注解,将Struts的Action纳为自己的控制范围之内。Struts2.0自带的@ParentPackage和@Results等注解,注明了要继承的父包和响应结果。还有@RequiredStringValidator,@RequiredFieldValidator等注解,大大方便了我们处理表单信息的校验。大家有没有发觉少了什么?我们不需要Struts.xml的配置文件了,也不需要xxx-validation.xml,也不需要写烦杂的验证代码了。岂不是很方便吗?
不过,不要忘记了,我们还得在web.xml中配置Struts2:

<!-- 配置Struts 2.0 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
<init-param>
<param-name>actionPackages</param-name>
<param-value>com.rong.action</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
我们init了一个参数actionPackages,表示我们的请求到哪里寻找我们的action。举例说,我们的用户注册action="register",它默认会在com.rong.action包下寻找RegisterAction类。经过action的处理后,若返回success,则会跳到success.jsp,若校验不通过,则返回input,则请求转发回register.jsp。
好了,试试看看看运行效果吧!


我们基于Annotation的SSH整合开发终于完成了。我所介绍的Annotation注解其实并不多,还得靠大家找资料去学习。而我们侧重点是在用Annotation时三大框架是如何整合起来的。
说点题外话吧,我们在开发过程中,究竟用Annotation还是XML,许多人曾问这样的问题。有培训机构的老师说过一句话,Annotation可以用,但XML配置一定要懂,因为XML配置现在还是主流。他说得也挺有道理的。有些人可能还不能接受Annotation这东西,就像我当初不大喜欢它一样。我的一位教我们Java中间件的老教师说:“Struts,Spring,Hibernate算什么技术?学EJB才是有用的。”他教我们的好像是EJB2版本的,他年轻时用Jbuilder开发过EJB的项目。如果我问他“为什么不选EJB3.0”,他会不会说:“EJB3被改得一塌糊涂,什么注解啊,改得狗屁不通,还是EJB2的最好……”。当然,我没有再问他。有时候,新事物要被人们所接受,是要经历一段时间的,世界在变,知识在变,我们何不用更宽广的心态,去接受那些新生的事物?

文章来源: http://www.blogjava.net/rongxh7

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/JustANobody/archive/2010/05/30/5634687.aspx

分享到:
评论

相关推荐

Global site tag (gtag.js) - Google Analytics