手动编码搭建ssh框架的步骤

本文介绍如何手动编码搭建此框架。我的环境为jdk1.7.0，Java EE 6 Libraries，myeclipse 10（其他版本也可）。

1.新建web project。工程名为SSH，将index.jsp删掉（没有用到）。

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.   
9. filter>  
10.     filter-name>sshfilter-name>  
11.     filter-class>  
12.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
13.     filter-class>  
14. filter>  
15.   
16. filter-mapping>  
17.     filter-name>sshfilter-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 session;  
26.   
27.     public void setSession(Map 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. nbsp;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. nbsp;HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">  
3. html>  
4.     head>  
5.         title>Welcometitle>  
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.   
8. context-param>  
9.     param-name>contextConfigLocationparam-name>  
10.     param-value>classpath:spring.xmlparam-value>  
11. context-param>  
12.   
13. listener>  
14.     listener-class>  
15.         org.springframework.web.context.ContextLoaderListener  
16.     listener-class>  
17. listener>  
18.   
19.   
20. filter>  
21.     filter-name>sshfilter-name>  
22.     filter-class>  
23.         org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter  
24.     filter-class>  
25. filter>  
26.   
27. filter-mapping>  
28.     filter-name>sshfilter-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. nbsp;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.xmlvalue>  
18.             list>  
19.         property>  
20.         property name="hibernateProperties">  
21.             props>  
22.                 prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop>  
23.                 prop key="hibernate.show_sql">trueprop>  
24.                 prop key="hibernate.format_sql">trueprop>  
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类。

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

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

16.重写struts配置文件

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

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

在浏览器中输入相关链接会显示登录页面，如果成功会显示welcome+UserName。失败则会继续要求登录。

至此，一个基本的ssh架构已经搭建完成，这个架构的强大功能还需要自己去不断发现。

上述手动编码搭建ssh框架的步骤知识点，爱站技术频道小编给大家说到这里就结束了，看完后有哪些地方需要小编详细解答的，可以来私聊处理，本站里面有各种技术文章供大家翻阅。