MyEclipse-10.0下Struts2.1+Spring3.0+Hibernate3.3整合过程

新建web project：



命名为SSH，做如下设置：



新建后的工程目录如下：



然后开始添加SSH框架，这里我按照struts-spring-hibernate顺序进行添加。

首先添加struts2.1支持：



做如下设置后点next。



选择jar包，至少选择下图中选择的两个：



然后添加Spring3.0支持，做如下设置：





然后是添加hibernate3.3。为了在添加hibernate时，可以自动在配置文件里加入数据库的连接信息而不用再去手动写，需要在添加hibernate前配置一下数据库连接。我用的是mysql5.5，在mysql中新建数据库ssh，然后新建两张表：

CREATE TABLE `user` ( `id` int(100) NOT NULL auto_increment, `username` varchar(500) NOT NULL, `password` varchar(500) NOT NULL, PRIMARY KEY (`id`) );

CREATE TABLE `_log` ( `id` int(100) NOT NULL auto_increment, `msg` varchar(500) NOT NULL, PRIMARY KEY (`id`) );

然后在MyEclipse里打开DB Browser视图，在视图下空白区右键新建一个数据库连接：





做如下设置：





接下来正式添加hibernate3.3：



在下面的设置上选择spring的配置文件，这样hibernate就交给spring进行管理：









至此，SSH框架添加完成。工程结构如下：



至此，整合完毕，接下来创建一个项目测试一下。

一、model层

新建两个实体类：User.java和Log.java，并生成相应的get、set方法，然后使用Annotation注解相应属性与数据库表中的字段的对应关系：





User.java

package com.ecs610.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "user")
public class User {
private int id;
private String userName;
private String password;

@Id
@GeneratedValue
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;
}

}

Log.java

package com.ecs610.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="_log")
public class Log {
private int id;
private String msg;

@Id
@GeneratedValue
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}

}

二、 DAO 层

利用MyEclipse的反向工程功能创建DAO接口及实现（以创建UserDAO及UserDAOImpl为例，Log的使用在本文并未实现），在表上右键，反向工程：









会在com.ecs610.dao.impl下得到一个名为UserDAO.java的文件，并且该文件有错误提示，引入User，删除冗余代码，并将UserDAO.java的文件名rename为UserDAOImpl.java。然后在UserDAOImpl.java中提取出（extract）接口，将接口命名为UserDAO.java，并将UserDAO.java移动到com.ecs610.dao包下：





项目结构图如下：



UserDAO.java

package com.ecs610.dao;

import java.util.List;

import com.ecs610.model.User;

public interface UserDAO {

public abstract void save(User transientInstance);

public abstract void delete(User persistentInstance);

public abstract User findById(java.lang.Integer id);

public abstract List findByUserName(Object userName);

public abstract List findAll();

public abstract User merge(User detachedInstance);

}

UserDAOImpl.java

package com.ecs610.dao.impl;

import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.ecs610.dao.UserDAO;
import com.ecs610.model.User;

public class UserDAOImpl extends HibernateDaoSupport implements UserDAO {
private static final Logger log = LoggerFactory.getLogger(UserDAOImpl.class);
// property constants
public static final String PASSWORD = "password";
public static final String USER_NAME = "userName";

protected void initDao() {
// do nothing
}

public void save(User transientInstance) {
log.debug("saving User instance");
try {
getHibernateTemplate().save(transientInstance);
log.debug("save successful");
} catch (RuntimeException re) {
log.error("save failed", re);
throw re;
}
}

public void delete(User persistentInstance) {
log.debug("deleting User instance");
try {
getHibernateTemplate().delete(persistentInstance);
log.debug("delete successful");
} catch (RuntimeException re) {
log.error("delete failed", re);
throw re;
}
}

public User findById(java.lang.Integer id) {
log.debug("getting User instance with id: " + id);
try {
User instance = (User) getHibernateTemplate().get(
"com.ecs610.dao.impl.User", id);
return instance;
} catch (RuntimeException re) {
log.error("get failed", re);
throw re;
}
}

public List findByProperty(String propertyName, Object value) {
log.debug("finding User instance with property: " + propertyName
+ ", value: " + value);
try {
String queryString = "from User as model where model."
+ propertyName + "= ?";
return getHibernateTemplate().find(queryString, value);
} catch (RuntimeException re) {
log.error("find by property name failed", re);
throw re;
}
}

public List findByUserName(Object userName) {
return findByProperty(USER_NAME, userName);
}

public List findAll() {
log.debug("finding all User instances");
try {
String queryString = "from User";
return getHibernateTemplate().find(queryString);
} catch (RuntimeException re) {
log.error("find all failed", re);
throw re;
}
}

public User merge(User detachedInstance) {
log.debug("merging User instance");
try {
User result = (User) getHibernateTemplate().merge(detachedInstance);
log.debug("merge successful");
return result;
} catch (RuntimeException re) {
log.error("merge failed", re);
throw re;
}
}
}

三、Service层

按照下图的结构新建Service层的类：



UserService是接口类，UserServiceImpl是对应的实现类。各类的内容如下：

UserService.java

package com.ecs610.service;

import com.ecs610.model.User;

public interface UserService {

public abstract void add(User user);

}

UserServiceImpl.java

package com.ecs610.service.impl;

import com.ecs610.dao.UserDAO;
import com.ecs610.model.User;
import com.ecs610.service.UserService;

public class UserServiceImpl implements UserService {

private UserDAO userDAO;

public UserDAO getUserDAO() {
return userDAO;
}

public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}

public void add(User user) {
this.userDAO.save(user);
}

}

然后，修改applicationContext.xml文件，实现“注入”：

applicationContext.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:p="http://www.springframework.org/schema/p"
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-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"> 
<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver">
</property>
<property name="url" value="jdbc:mysql://localhost:3306/ssh" />
<property name="username" value="root" />
<property name="password" value="hel610" />
</bean>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<property name="annotatedClasses">
<list>
<value>com.ecs610.model.User</value>
<value>com.ecs610.model.Log</value>
</list>
</property>
</bean>

<bean id="userDAO" class="com.ecs610.dao.impl.UserDAOImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="logDAO" class="com.ecs610.dao.impl.LogDAOImpl">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="userService" class="com.ecs610.service.impl.UserServiceImpl">
<property name="userDAO" ref="userDAO" />
</bean>

</beans>

关于“注入”的理解：



关于ref=”userDAO”的理解是在UserServiceImpl类中新建或者引用了名为userDAO的对象。在Spring下的含义是将id为userDAO的对象(bean)注入给了当前类(对象)。（上文的.xml文件中的下划线为横线的userDAO为同一个对象，即同一个bean）



“注入”：配置文件指定了当前bean新建了哪一个对象（指定了当前bean的名称）、该对象属于哪个类、该对象是否有set方法、引用了哪个bean等信息，这样是一种灵活的方式，通过不同的配置可以实现不同的功能（通过引用不同的bean）。

然后新建类UserServiceImpl的JUnit test类。首先新建一个和目录src同一级别的Source Folder，起名为test，用于存放测试类。然后在UserServiceImpl.java类上单击右键—>new—>other：











然后将UserServiceImplTest.java的内容修改为如下：

UserServiceImplTest.java

package com.ecs610.service.impl;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ecs610.model.User;
import com.ecs610.service.UserService;

public class UserServiceImplTest {

@Test
public void testAdd() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService service = (UserServiceImpl)applicationContext.getBean("userService");
User u = new User();
u.setId(1);
u.setUserName("zhangsan");
u.setPassword("admin");
service.add(u);
}
}

接下来进行测试，在UserServiceImplTest.java 文件内右键— >Run As — >JUnit Test ：



运行状态和结果如下图：