手工搭建SSH框架

1.新建web project。工程名为SSH。

2.引入ssh核定jar包。共27个。

antlr-2.7.6.jar                       asm-attrs.jar
asm.jar                               c3p0-0.9.1.jar
cglib-2.1.3.jar                       commons-collections-3.1.jar
commons-dbcp-1.4.jar                  commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar                  commons-lang3-3.1.jar
commons-logging-1.1.1.jar             commons-pool-1.6.jar
dom4j-1.6.1.jar                       freemarker-2.3.19.jar
hibernate-tools.jar                   hibernate3.jar
javassist-3.11.0.GA.jar               jta.jar
junit-4.4.jar                         log4j-1.2.11.jar
mysql-connector-java-5.1.20-bin.jar   ognl-3.0.5.jar
spring.jar                            struts2-core-2.3.3.jar
struts2-json-plugin-2.3.3.jar         struts2-spring-plugin-2.3.3.jar
xwork-core-2.3.3.jar

下载全部jar包，复制到工程下webroot/WEB-INF/lib下。不要用编译路径引入，否则会导致不能添加到web中。

3.配置struts2核心过滤器。

打开web.xml，添加过滤器和过滤器映射

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="3.0"   
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_3_0.xsd">  
7.   
8. <!-- 配置struts2核心过滤器 -->  
9. <filter>  
10.     <filter-name>ssh</filter-name>  
11.     <filter-class>  
12.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
13.     </filter-class>  
14. </filter>  
15. <!-- 过滤器映射 -->  
16. <filter-mapping>  
17.     <filter-name>ssh</filter-name>  
18.     <url-pattern>/*</url-pattern>  
19. </filter-mapping>  
20. </web-app>  

4.建立BaseAction。

新建包com.dj.ssh.action.base，在其中建立BaseAction，继承ActionSupport，并实现ServletRequestAware,ServletResponseAware,ServletContextAware,SessionAware四个接口，作为基本的Action供其他Action继承。

1. package com.dj.ssh.action.base;  
2.   
3. import java.util.Map;  
4.   
5. import javax.servlet.ServletContext;  
6. import javax.servlet.http.HttpServletRequest;  
7. import javax.servlet.http.HttpServletResponse;  
8.   
9. import org.apache.struts2.interceptor.ServletRequestAware;  
10. import org.apache.struts2.interceptor.ServletResponseAware;  
11. import org.apache.struts2.interceptor.SessionAware;  
12. import org.apache.struts2.util.ServletContextAware;  
13.   
14. import com.opensymphony.xwork2.ActionSupport;  
15.   
16. public class BaseAction extends ActionSupport   
17.                             implements ServletRequestAware,ServletResponseAware,  
18.                             ServletContextAware,SessionAware{  
19.   
20.     private static final long serialVersionUID = 471790417376168550L;  
21.       
22.     protected HttpServletRequest request;  
23.     protected HttpServletResponse response;  
24.     protected ServletContext context;  
25.     protected Map<String, Object> session;  
26.   
27.     public void setSession(Map<String, Object> session) {  
28.         this.session = session;  
29.     }  
30.   
31.     public void setServletContext(ServletContext context) {  
32.         this.context = context;  
33.     }  
34.   
35.     public void setServletResponse(HttpServletResponse response) {  
36.         this.response = response;  
37.     }  
38.   
39.     public void setServletRequest(HttpServletRequest request) {  
40.         this.request = request;  
41.     }  
42.   
43. } 

5.编写测试struts的Action。

在包com.dj.ssh.action中建立LoginAction，继承BaseAction，作为简单的struts测试，由于默认执行execute方法，在此直接返回“success”。

1. package com.dj.ssh.action;  
2.   
3. import com.dj.ssh.action.base.BaseAction;  
4.   
5. public class LoginAction extends BaseAction {  
6.   
7.     private static final long serialVersionUID = 7803370514585593518L;  
8.       
9.     public String execute() throws Exception {  
10.         return "success";  
11.     }  
12.   
13. }  

6.配置struts。

在src下新建struts.xml，这个是struts的配置文件，只能用这个名字。记得要创建包，继承struts-default，之后再内部创建action。

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE struts PUBLIC  
3.     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"  
4.     "http://struts.apache.org/dtds/struts-2.3.dtd">  
5. <struts>  
6.     <package name="login" extends="struts-default">  
7.         <action name="login" class="loginAction">  
8.             <result name="success">  
9.                 /WEB-INF/jsp/welcome.jsp  
10.             </result>  
11.         </action>  
12.     </package>  
13. </struts>

7.建立jsp页面。

在/WEB-INF下建立jsp文件夹，在其中建立welcome.jsp。

1. <%@ page language="java" pageEncoding="UTF-8"%>  
2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
3. <html>  
4.     <head>  
5.         <title>Welcome</title>  
6.     </head>  
7.     <body>  
8.         Welcome!  
9.     </body>  
10. </html>

8.配置spring_context。

在src下新建spring.xml作为spring的配置，这里的名字可以自己取。

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xsi:schemaLocation="http://www.springframework.org/schema/beans   
5.                             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
6.     <bean id="loginAction" class="com.dj.ssh.action.LoginAction"/>  
7.           
8. </beans>

9.配置spring监听器

打开web.xml，添加spring的配置和listener。

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <web-app version="3.0"   
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_3_0.xsd">  
7. <!-- spring 配置文件的位置 -->  
8. <context-param>  
9.     <param-name>contextConfigLocation</param-name>  
10.     <param-value>classpath:spring.xml</param-value>  
11. </context-param>  
12. <!-- spring监听器 -->  
13. <listener>  
14.     <listener-class>  
15.         org.springframework.web.context.ContextLoaderListener  
16.     </listener-class>  
17. </listener>  
18.   
19. <!-- 配置struts2核心过滤器 -->  
20. <filter>  
21.     <filter-name>ssh</filter-name>  
22.     <filter-class>  
23.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
24.     </filter-class>  
25. </filter>  
26. <!-- 过滤器映射 -->  
27. <filter-mapping>  
28.     <filter-name>ssh</filter-name>  
29.     <url-pattern>/*</url-pattern>  
30. </filter-mapping>  
31. </web-app>  

在浏览器中输入http://localhost/SSH/login,则会显示welcome网页。

10.建立数据库和数据表。

这里采用mysql，其他数据库也可以，不同的数据库连接驱动和url不同，jar包也可能不同。

在mysql中建立test数据库，创建t_user表，包括t_id，t_name和t_password三个属性列。插入一条数据。

11.创建持久层实体类。

创建包com.dj.ssh.pojo，创建User类，添加3个私有成员，对应数据表中3个属性，并一定要添加set和get方法。

1. package com.dj.ssh.pojo;  
2.   
3. import java.io.Serializable;  
4.   
5. public class User implements Serializable{  
6.   
7.     private static final long serialVersionUID = 6120793500259112385L;  
8.     private Integer id;  
9.     private String username;  
10.     private String password;  
11.     public Integer getId() {  
12.         return id;  
13.     }  
14.     public void setId(Integer id) {  
15.         this.id = id;  
16.     }  
17.     public String getUsername() {  
18.         return username;  
19.     }  
20.     public void setUsername(String username) {  
21.         this.username = username;  
22.     }  
23.     public String getPassword() {  
24.         return password;  
25.     }  
26.     public void setPassword(String password) {  
27.         this.password = password;  
28.     }  
29.       
30. }  

12.添加映射文件。

在 com.dj.ssh.pojo包下新建User.hbm.xml，作为User与数据表的映射文件。

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC   
3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
5. <hibernate-mapping package="com.dj.ssh.pojo">  
6.     <class name="User" table="t_user">  
7.         <id name="id" type="integer">  
8.             <column name="t_id"/>  
9.             <generator class="identity"/>           
10.         </id>  
11.         <property name="username" type="string">  
12.             <column name="t_name"/>  
13.         </property>  
14.         <property name="password" type="string">  
15.             <column name="t_password"/>  
16.         </property>  
17.     </class>  
18. </hibernate-mapping>  

添加包名是为了下面class的name属性可以直接使用类名，不用带着包名。generator属性为主键生成机制，常用的有3种（native，identity和sequence忘了），mysql使用identity，Oracle只用sequence，如果不知道，可以使用native（根据数据库的默认设定而定）。

注意类型为小写，是hibernate类型。

13.配置spring，添加hibernate支持。

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xsi:schemaLocation="http://www.springframework.org/schema/beans   
5.                             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
6.       
7.     <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource">  
8.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>  
9.         <property name="url" value="jdbc:mysql://localhost:3306/test"/>  
10.         <property name="username" value="root" />  
11.         <property name="password" value="root"/>  
12.     </bean>  
13.     <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
14.         <property name="dataSource" ref="myDataSource"/>  
15.         <property name="mappingResources">  
16.             <list>  
17.                 <value>com/dj/ssh/pojo/User.hbm.xml</value>  
18.             </list>  
19.         </property>  
20.         <property name="hibernateProperties">  
21.             <props>  
22.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
23.                 <prop key="hibernate.show_sql">true</prop>  
24.                 <prop key="hibernate.format_sql">true</prop>  
25.             </props>  
26.         </property>  
27.     </bean>  
28.       
29.     <bean id="loginAction" class="com.dj.ssh.action.LoginAction"/>  
30.           
31. </beans>  

14.重新写LoginAction，加入数据库信息验证。这里采用分层机制，pojo为持久层，dao为模型层，service控制业务。

采用逆序的写法，即从action开始写，需要什么业务就定义出来，然后生成service接口，接着实现接口，用相同的方法生成DAO层。

LoginAction如下：

1. package com.dj.ssh.action;  
2.   
3. import com.dj.ssh.action.base.BaseAction;  
4. import com.dj.ssh.service.UserService;  
5.   
6. public class LoginAction extends BaseAction {  
7.   
8.     private static final long serialVersionUID = 7803370514585593518L;  
9.     private UserService userService;  
10.     private String username;  
11.     private String password;  
12.       
13.     public String execute() throws Exception {  
14.         if(userService.login(username,password))  
15.             return "success";  
16.         return "error";  
17.     }  
18.   
19.     public String getUsername() {  
20.         return username;  
21.     }  
22.   
23.     public void setUsername(String username) {  
24.         this.username = username;  
25.     }  
26.   
27.     public String getPassword() {  
28.         return password;  
29.     }  
30.   
31.     public void setPassword(String password) {  
32.         this.password = password;  
33.     }  
34.   
35.     public void setUserService(UserService userService) {  
36.         this.userService = userService;  
37.     }  
38.   
39. }  

这里有两个私有成员是为了接收用户的输入进而验证，一定要定义get和set方法，还有一个service成员，只有set方法，是需要建立的，其中有一个login方法，用来判断用户名和密码是否正确。生成UserService接口：

1. package com.dj.ssh.service;  
2.   
3. public interface UserService {  
4.   
5.     public boolean login(String username, String password);  
6.   
7. }  

实现接口：

1. package com.dj.ssh.service.impl;  
2.   
3. import com.dj.ssh.dao.UserDAO;  
4. import com.dj.ssh.pojo.User;  
5. import com.dj.ssh.service.UserService;  
6.   
7. public class UserServiceImpl implements UserService {  
8.   
9.     private UserDAO userDAO;  
10.     public boolean login(String username, String password) {  
11.         User user =userDAO.findUserByName(username);  
12.         if(user!=null)  
13.             if(password.equals(user.getPassword()))  
14.                 return true;  
15.         return false;  
16.     }  
17.     public void setUserDAO(UserDAO userDAO) {  
18.         this.userDAO = userDAO;  
19.     }  
20.   
21. }  

同理，生成UserDAO接口：

1. package com.dj.ssh.dao;  
2.   
3. import com.dj.ssh.pojo.User;  
4.   
5. public interface UserDAO {  
6.   
7.     public User findUserByName(String username);  
8.   
9. }  

实现接口：

注意这里要结成hibernate的DAO支持，即HibernateDaoSupport类。

1. package com.dj.ssh.dao.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
6.   
7. import com.dj.ssh.dao.UserDAO;  
8. import com.dj.ssh.pojo.User;  
9.   
10. public class UserDAOImpl extends HibernateDaoSupport implements UserDAO {  
11.   
12.     public User findUserByName(String username) {  
13.         List<User> list;  
14.         String hql="from User u where u.username=?";  
15.         list=this.getHibernateTemplate().find(hql, username);  
16.         if(list!=null&&list.size()>0)  
17.             return list.get(0);  
18.         return null;  
19.     }  
20.   
21. }  

15.添加loginform.jsp页面，供用户登录。

1. <%@ page language="java" pageEncoding="UTF-8"%>  
2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
3. <html>  
4.     <head>  
5.         <title>Login_Form</title>  
6.     </head>  
7.     <body>  
8.         <form action="login" method="post">  
9.             Username:<input type="text" name="username"/><br/>  
10.             Password:<input type="password" name="password"/><br/>  
11.             <input type="submit" value="Submit"/>   
12.         </form>  
13.     </body>  
14. </html>  

表单提交数据，使用login这个action进行处理。

16.重写struts配置文件

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE struts PUBLIC  
3.     "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"  
4.     "http://struts.apache.org/dtds/struts-2.3.dtd">  
5. <struts>  
6.     <constant name="struts.objectFactory" value="spring" />  
7.     <package name="login" extends="struts-default">  
8.         <action name="loginform">  
9.             <result name="success">  
10.                 /WEB-INF/jsp/login_form.jsp  
11.             </result>  
12.         </action>  
13.         <action name="login" class="loginAction">  
14.             <result name="success">  
15.                 /WEB-INF/jsp/welcome.jsp  
16.             </result>  
17.             <result name="error" type="redirect">  
18.                 loginform  
19.             </result>  
20.         </action>  
21.     </package>  
22. </struts>  

用户调用loginform进入登录页面，如果登录成功则进入welcome页面，如果失败返回登录页面。redirect为重定向。

17.重写welcome.jsp页面，使用struts标签显示后天数据。

1. <%@ page language="java" pageEncoding="UTF-8"%>  

• <%@ taglib uri="/struts-tags" prefix="s" %>  
• <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
• <html>  
•     <head>  
•         <title>Welcome</title>  
•     </head>  
•     <body>  
•         Welcome!<s:property value="username"/>  
•     </body>  
• </html>