Sealyu

--- 博客已迁移至: http://www.sealyu.com/blog

  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理 ::
  618 随笔 :: 87 文章 :: 225 评论 :: 0 Trackbacks
基于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整合开发，让我们一起期待下一阶段吧！

基于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的注解带到我们的整合开发中来。一起期待吧！
        (*^-^*) 本文原创，转载请注明出处， http://www.blogjava.net/rongxh7谢谢! (*^-^*)
posted on 2009-03-25 14:21 seal 阅读(459) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。
网站导航: