SSH学习之——Spring、Struts和Hibernate整合开发

一、环境

1、测试平台：MyEclipse8.5/JDK1.7（1.5以上都OK）

2、开源框架：Spring3.0/Struts2.1/Hibernate3.3

3、UI界面：HTML/JSP/struts2标签

 

二、具体步骤

1、新建Web项目，此处命名为“ssh”

2、添加Spring的支持。

       1）利用平台自身带有的Spring支持（如果熟悉各个库的作用以及配置文件的作用，最好是采用手动添加库来完成，这样的好处就是避免将过多的没必要的jar文件引入到项目中，造成项目的臃肿），此处我们添加Spring3.0

       2）勾选五个Spring的库。Spring的核心支持库Core、面向方面编程支持库AOP、持久化核心支持库Persistence Core、JDBC持久化支持库Persistence JDBC、支持Web应用的的库Web（当然这次的开发内容中不包含AOP的东西，所以不选这个也行）

       3）此时平台会提示用户自动创建Spring的配置文件“applicationContext.xml”，该文件在src目录下，也就是classpath下

       4）配置Web.xml来使Web项目启动时自动启用Spring，在Web.xml中添加如下配置

[html] view plaincopy

1.  <!-- 配置Spring配置文件的位置，多个可以以逗号分隔 -->  
2.  <context-param>              
3.     <param-name>contextConfigLocation</param-name>   
4.     <!-- 不指定classpath时，默认为加载/WEB_INF/目录下的文件 -->               
5.     <param-value>classpath:applicationContext.xml</param-value>         
6.  </context-param>  
7.  <!-- 项目启动时自动启用Spring -->  
8.  <listener>  
9. <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
10.  </listener>  

       5）Spring的支持基本配置好了

3、添加Struts的支持

       1）这里我们也采用MyEclipse8.5自身的Struts来添加Struts，此处我们添加Struts2.1

       2）勾选Struts的核心支持库Core
       3）整合Spring和Struts。由于Spring是管理业务对象的，Struts的Action对象可以交由Spring来管理，所以这里我们添加一个插件“struts2-spring-plugin-2.1.6.jar”来达到整合Spring和Struts的目的，把该文件拷贝到/WEB-INF/lib目录下即可（这里我们也可以采用勾选MyEclipse8.5平台提供的Struts支持中的Struts-Spring库，但是这里面的很多jar添加Spring时已经有了，一面造成重复和臃肿，我们采用手动添加该文件的方式）。关于Struts是如何于Spring进行整合的，Struts的对象又是如何交由Spring管理的，可以参照该jar文件中的“struts-plugin.xml”以及代码来研究

       4）此时平台在src目录下自动创建了struts的配置文件“struts.xml”

       5）Struts的支持已经和Spring的整合这里就完成了

4、添加Hibernate的支持

       1）采用平台自带的Hibernate，我们这里添加Hibernate3.3

       2）勾选Hibernate的核心支持库Core就行了

       3）整合Spring和Hibernate。Hibernate是用于数据库映射的，映射完后的具体的CURD对象可以交由Spring来管理。此时平台会让我们选择将Hibernate的配置放在“hibernat.cfg.xml”中，还是放在spring的“applicationContext.xml”中，这里我们选择放在Spring的配置文件中。在已经存在的“applicationContext.xml”中配置sessionFactory对象

       4）配置Hibernate所用的数据源。

                a、这里我们采用mysql数据库，所以首先添加mysql的数据库驱动“mysql-connector-java-5.0.7-bin.jar”，将该文件放在/WEB-INF/lib目录下

                b、配置数据源。采用jdbc驱动。URL为“jdbc:mysql://localhost:3306/ssh”，Driver Class为“com.mysql.jdbc.Driver”，Dialect为“MySql”

       5）因为我们将sessionFactory对象已经配置在Spring中，所用我们就不创建SessionFactory类了

       6）Hibernate的支持和与Spring的整合都完成了，此时我们可以看到applicationContext.xml文件中自动创建了如下配置

[html] view plaincopy

1.         <bean id="dataSource"  
2.     class="org.apache.commons.dbcp.BasicDataSource">  
3.     <property name="driverClassName"  
4.         value="com.mysql.jdbc.Driver">  
5.     </property>  
6.     <property name="url" value="jdbc:mysql://localhost:3306/ssh"></property>  
7.     <property name="username" value="root"></property>  
8.     <property name="password" value="111111"></property>  
9. </bean>  
10. <bean id="sessionFactory"  
11.     class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
12.     <property name="dataSource">  
13.         <ref bean="dataSource" />  
14.     </property>  
15.     <property name="hibernateProperties">  
16.         <props>  
17.             <prop key="hibernate.dialect">  
18.                 org.hibernate.dialect.MySQLDialect  
19.             </prop>  
20.         </props>  
21.     </property>  
22. </bean>  

三、开发测试

1、创建数据表user，脚本如下

[sql] view plaincopy

1. CREATE TABLE `user` (  
2.   `id` int(11) NOT NULL auto_increment,  
3.   `username` varchar(255) default NULL,  
4.   `password` varchar(255) default NULL,  
5.   `age` varchar(255) default NULL,  
6.   `sex` enum('男','女') default '男',  
7.   `description` varchar(255) default NULL,  
8.   PRIMARY KEY  (`id`)  
9. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;  

2、创建实体类User，代码如下

[java] view plaincopy

1. package org.cyxl.ssh.entity;  
2.   
3. /** 
4.  * 实体类User 
5.  * @author cyxl 
6.  * 
7.  */  
8. public class User {  
9.     private long id;  
10.     private String username;  
11.     private String password;  
12.     private int age;  
13.     private String sex;  
14.     private String description;  
15.     public long getId() {  
16.         return id;  
17.     }  
18.     public void setId(long id) {  
19.         this.id = id;  
20.     }  
21.     public String getUsername() {  
22.         return username;  
23.     }  
24.     public void setUsername(String username) {  
25.         this.username = username;  
26.     }  
27.     public String getPassword() {  
28.         return password;  
29.     }  
30.     public void setPassword(String password) {  
31.         this.password = password;  
32.     }  
33.     public int getAge() {  
34.         return age;  
35.     }  
36.     public void setAge(int age) {  
37.         this.age = age;  
38.     }  
39.     public String getSex() {  
40.         return sex;  
41.     }  
42.     public void setSex(String sex) {  
43.         this.sex = sex;  
44.     }  
45.     public String getDescription() {  
46.         return description;  
47.     }  
48.     public void setDescription(String description) {  
49.         this.description = description;  
50.     }  
51. }  

3、配置User表的Hibernate映射User.hbm.xml

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3.  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
4.   
5. <hibernate-mapping>  
6.     <class name="org.cyxl.ssh.entity.User" table="user">  
7.         <id name="id" column="id">  
8.             <generator class="identity" />  
9.         </id>  
10.           
11.         <property name="username" column="username" type="string"/>  
12.   
13.         <property  name="password" column="password" type="string"/>  
14.   
15.         <property name="age" column="age" type="int"/>  
16.           
17.         <property  name="sex" column="sex" type="string"/>  
18.           
19.         <property  name="description" column="description" type="string"/>  
20.   
21.     </class>  
22.   
23. </hibernate-mapping>  

4、修改sessionFactory的配置，将上述映射文件添加到hibernate中

[html] view plaincopy

1.        <bean id="sessionFactory"  
2. class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
3. <property name="dataSource">  
4.     <ref bean="dataSource" />  
5. </property>  
6. <property name="mappingResources">    
7.     <list>    
8.         <value>org/cyxl/ssh/entity/User.hbm.xml</value>  
9.     </list>    
10. </property>  
11. <property name="hibernateProperties">  
12.     <props>  
13.         <prop key="hibernate.dialect">  
14.             org.hibernate.dialect.MySQLDialect  
15.         </prop>  
16.     </props>  
17. </property>  
18. lt;/bean>  

 

5、编写数据访问对象的接口和实现类，如下

[java] view plaincopy

1. package org.cyxl.ssh.dao;  
2.   
3. import org.cyxl.ssh.entity.User;  
4. /** 
5.  * 用户数据访问接口 
6.  * @author cyxl 
7.  * 
8.  */  
9. public interface UserDao {  
10.     boolean login(String username,String password);  
11.     boolean add(User user);  
12. }  

[java] view plaincopy

1. package org.cyxl.ssh.dao.hibernate.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.cyxl.ssh.dao.UserDao;  
6. import org.cyxl.ssh.entity.User;  
7. import org.hibernate.Query;  
8. import org.hibernate.Session;  
9. import org.hibernate.SessionFactory;  
10. /** 
11.  * 用户数据访问Hibernate实现 
12.  * @author cyxl 
13.  * 
14.  */  
15. public class UserDaoImpl implements UserDao {  
16.     private SessionFactory factory;  
17.     private Session session;  
18.       
19.     public SessionFactory getFactory() {  
20.         return factory;  
21.     }  
22.   
23.     public void setFactory(SessionFactory factory) {  
24.         this.factory = factory;  
25.         //设置SessionFactory对象后，创建Session对象  
26.         this.session=factory.openSession();  
27.     }  
28.   
29.     public boolean add(User user) {  
30.         session.save(user);  
31.         return true;  
32.     }  
33.   
34.     public boolean login(String username, String password) {  
35.         String hql="from User user where username='"+username+"' and password='"+password+"'";  
36.         Query query=session.createQuery(hql);  
37.         List<User> list=query.list();  
38.           
39.         if(list!=null && list.size()>0)  
40.         {  
41.             return true;  
42.         }  
43.         return false;  
44.     }  
45.   
46. }  

6、编写用户服务接口和实现类，代码如下

[java] view plaincopy

1. package org.cyxl.ssh.service;  
2.   
3. import org.cyxl.ssh.entity.User;  
4. /** 
5.  * 用户服务接口 
6.  * @author cyxl 
7.  * 
8.  */  
9. public interface UserService {  
10.     boolean add(User user);  
11.     boolean login(String username,String password);  
12. }  

 

[java] view plaincopy

1. package org.cyxl.ssh.service.impl;  
2.   
3. import org.cyxl.ssh.dao.UserDao;  
4. import org.cyxl.ssh.entity.User;  
5. import org.cyxl.ssh.service.UserService;  
6. /** 
7.  * 用户服务实现 
8.  * @author cyxl 
9.  * 
10.  */  
11. public class UserServiceImpl implements UserService{  
12.     private UserDao userDao;  
13.       
14.     public UserDao getUserDao() {  
15.         return userDao;  
16.     }  
17.   
18.     public void setUserDao(UserDao userDao) {  
19.         this.userDao = userDao;  
20.     }  
21.   
22.     public boolean add(User user) {  
23.         return userDao.add(user);  
24.     }  
25.   
26.     public boolean login(String username, String password) {  
27.         return userDao.login(username, password);  
28.     }  
29.   
30. }  

7、编写用户动作Action，代码如下

[java] view plaincopy

1. package org.cyxl.ssh.action;  
2.   
3. import org.cyxl.ssh.entity.User;  
4. import org.cyxl.ssh.service.UserService;  
5.   
6. import com.opensymphony.xwork2.ActionSupport;  
7. import com.opensymphony.xwork2.ModelDriven;  
8. /** 
9.  * 用户动作实现 
10.  * @author cyxl 
11.  * 
12.  */  
13. public class UserAction extends ActionSupport implements ModelDriven {  
14.     private User user=new User();  
15.     private UserService userService;  
16.       
17.     public UserService getUserService() {  
18.         return userService;  
19.     }  
20.   
21.     public void setUserService(UserService userService) {  
22.         this.userService = userService;  
23.     }  
24.   
25.     public String login()  
26.     {  
27.         if(user!=null)  
28.         {  
29.             if(userService.login(user.getUsername(), user.getPassword()))  
30.             {  
31.                 return this.SUCCESS;  
32.             }  
33.         }  
34.         return this.INPUT;  
35.     }  
36.   
37.     public Object getModel() {  
38.         return user;  
39.     }  
40. }  

这里有两点需要注意

a、该类实现了ModelDriven接口，该接口只有一个方法getModel。这个接口的作用是使请求的参数（如表单）中的name与实体中的字段自动相匹配。如在请求username时，如果采用模型驱动（ModelDriven）设置name时只要指定username，如果为字段驱动，那就需要指明user.username（这里可以参照login.jsp文件中的表单中的name属性来研究）

b、private User user=new User();这行代码中的user必须实例化，也就是必须new出一个对象来

8、发挥Spring的作用，配置各种对象的创建方式，在applicationContext.xml中添加如下配置

[html] view plaincopy

1.         <bean id="userDao" class="org.cyxl.ssh.dao.hibernate.impl.UserDaoImpl">  
2.     <property name="factory" ref="sessionFactory" />  
3. </bean>  
4.   
5. <bean id="userService" class="org.cyxl.ssh.service.impl.UserServiceImpl">  
6.     <property name="userDao" ref="userDao" />  
7. </bean>  
8.   
9. <bean id="userAction" class="org.cyxl.ssh.action.UserAction">  
10.     <property name="userService" ref="userService" />  
11. </bean>  

自下而上一次配置了userDao、userService、userAction的实现方式和所以来的对象，这里特别注意userDao的factory属性，我们将前面配置sessionFactory对象赋予了它

9、UI界面

       1）index.jsp中写一行代码，作用是转向登陆界面，如下

[html] view plaincopy

1. <% response.sendRedirect("UserLogin.action"); %>  

       2）编写login.jsp的代码，只要为一个提交的表单，如下

[html] view plaincopy

1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>  
2. <%@ taglib prefix="s" uri="/struts-tags" %>  
3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
4. <html>  
5.   <head>  
6.     <title>login page</title>  
7.   </head>  
8.   <body>  
9.     <s:form action="UserLogin.action">  
10.         <s:textfield label="username" name="username"></s:textfield>  
11.         <s:password label="password" name="password"></s:password>  
12.         <s:submit value="提交"></s:submit>  
13.     </s:form>  
14.   </body>  
15. </html>  

从上面的用户名输入框我们来回忆前面的UserAction中实现了ModelDriven接口。实现的情况下name=“username”，不实现的情况下应该为name=“user.username”

       3）编写登陆成功结果页面success.jsp，该页面就一句话提示登陆成功“success”

10、配置struts.xml。代码如下

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">  
3. <struts>  
4.         <package name="cyxl" extends="struts-default">   
5.         <action name="UserLogin" class="userAction" method="login">   
6.             <result name="success">/success.jsp</result>  
7.             <result name="input">/login.jsp</result>  
8.         </action>  
9.     </package>   
10. </struts>      

action为UserLogin的请求使用的类是userAction，该userAction的创建采用Spring管理，具体在applicationContext.xml文件中配置.method指定该请求使用userAction中的哪个方法。登陆成功转向success.jsp页面，失败则继续让用户输入，停留login.jsp页面

四、总结

以上开发内容主要注意一下几点（当然知识点需要查阅其它的相关资料才可能弄明白，这里只是大致引出了该知识点）

1、了解各个依赖的库文件的含义，各个配置文件的含义

2、了解Spring的自动启动方式（Web.xml）的配置

3、Spring整合Struts所依赖的库和struts-plugin.xml的作用

4、Spring整合Hibernate的方式和sessionFactory对象的配置及作用

5、Action实现ModelDriven的作用

6、Spring是如何配置各对象的创建的和创建的时间

7、注意Spring是强制开发者采用接口开发的，如接口UserDao，UserService等等

8、Struts的标签库已经包含在Core库中了，所以用的时候只需要在页面的引入该标签库即可

五、附录

1、Spring的日志记录可以整合log4j来实现，这里需要在web.xml文件中配置。在src目录创建log4j的配置文件log4j.properties

[plain] view plaincopy

1.  ### set log levels ###  
2. log4j.rootLogger = debug,stdout  
3.   
4. ### 输出到控制台 ###  
5. log4j.appender.stdout = org.apache.log4j.ConsoleAppender  
6. log4j.appender.stdout.Target = System.out  
7. log4j.appender.stdout.layout = org.apache.log4j.PatternLayout  
8. log4j.appender.stdout.layout.ConversionPattern =  %d{ABSOLUTE} %5p %c{1}:%L - %m%n  

2、完整的applicationContext.xml文件如下

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  
3.     xmlns="http://www.springframework.org/schema/beans"  
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
5.     xmlns:p="http://www.springframework.org/schema/p"  
6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
7.   
8.   
9.     <bean id="dataSource"  
10.         class="org.apache.commons.dbcp.BasicDataSource">  
11.         <property name="driverClassName"  
12.             value="com.mysql.jdbc.Driver">  
13.         </property>  
14.         <property name="url" value="jdbc:mysql://localhost:3306/ssh"></property>  
15.         <property name="username" value="root"></property>  
16.         <property name="password" value="111111"></property>  
17.     </bean>  
18.     <bean id="sessionFactory"  
19.         class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
20.         <property name="dataSource">  
21.             <ref bean="dataSource" />  
22.         </property>  
23.         <property name="mappingResources">    
24.             <list>    
25.                 <value>org/cyxl/ssh/entity/User.hbm.xml</value>  
26.             </list>    
27.         </property>  
28.         <property name="hibernateProperties">  
29.             <props>  
30.                 <prop key="hibernate.dialect">  
31.                     org.hibernate.dialect.MySQLDialect  
32.                 </prop>  
33.             </props>  
34.         </property>  
35.     </bean>  
36.       
37.     <bean id="userDao" class="org.cyxl.ssh.dao.hibernate.impl.UserDaoImpl">  
38.         <property name="factory" ref="sessionFactory" />  
39.     </bean>  
40.       
41.     <bean id="userService" class="org.cyxl.ssh.service.impl.UserServiceImpl">  
42.         <property name="userDao" ref="userDao" />  
43.     </bean>  
44.       
45.     <bean id="userAction" class="org.cyxl.ssh.action.UserAction">  
46.         <property name="userService" ref="userService" />  
47.     </bean>  
48. </beans>  

3、完整的web.xml文件如下

[html] view plaincopy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="2.5"   
3.     xmlns="http://java.sun.com/xml/ns/javaee"   
4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
5.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
6.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
7.   <welcome-file-list>  
8.     <welcome-file>index.jsp</welcome-file>  
9.   </welcome-file-list>  
10.     
11.   <!-- 配置Spring配置文件的位置，多个可以以逗号分隔 -->  
12.   <context-param>              
13.     <param-name>contextConfigLocation</param-name>   
14.     <!-- 不指定classpath时，默认为加载/WEB_INF/目录下的文件 -->               
15.     <param-value>classpath:applicationContext.xml</param-value>         
16.   </context-param>  
17.     
18.     <!--由Spring载入的Log4j配置文件位置-->  
19.   <context-param>  
20.     <param-name>log4jConfigLocation</param-name>  
21.     <param-value>classpath:log4j.properties</param-value>  
22.   </context-param>  
23.   
24.     
25.   <!-- 项目启动时自动启用Spring -->  
26.   <listener>  
27.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
28.   </listener>  
29.     
30.   <!--Spring log4j Config loader-->  
31.   <listener>  
32.     <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
33.   </listener>  
34.     
35.   <filter>  
36.     <filter-name>struts2</filter-name>  
37.     <filter-class>  
38.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
39.     </filter-class>  
40.   </filter>  
41.   <filter-mapping>  
42.     <filter-name>struts2</filter-name>  
43.     <url-pattern>*.action</url-pattern>  
44.   </filter-mapping></web-app>