ssh三大框架整合

发表于 | 阅读量 次 | 分类于 |

前言

ssh三大框架整合主要指的是structs2+hibernate+spring，利用mvc分层思想实现解耦，其中structs2负责业务控制和跳转，hibernate负责持久层，spring管理各层

ssh

下面将以一个简单的登录功能搭建整合环境

  1. 首先建立一个web工程，取名ssh2

  2. 导入jar包，由于ssh2整合包过多，可以自行官网下载

  3. 导入相关配置文件
    Spring核心文件：applicationcontent.xml放在web-inf下
    web工程核心文件：web.xml也放在web-inf下
    structs2核心文件：structs.xml放在src目录下
    里面暂时什么都不配置

  4. 数据库
    为了方便，设置三个字段，id（int）、name（varchar）、age（int），其中id为主键，且是自增长的

  5. 配置核心文件初始化
    Web.xml配置

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
    	xmlns="http://java.sun.com/xml/ns/javaee" 
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
    	<filter>
    		<filter-name>struts2</filter-name>
    	//启动structs2框架	<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    	</filter>
    //允许后缀名为.action或者.jsp的请求通过
    	<filter-mapping>
    		<filter-name>struts2</filter-name>
    		<url-pattern>*.action</url-pattern>
    	</filter-mapping>
    	<filter-mapping>
    		<filter-name>struts2</filter-name>
    		<url-pattern>*.jsp</url-pattern>
    	</filter-mapping>
    //启动spring监听，即开启spring框架
    	<listener>
    		<listener-class>
    			org.springframework.web.context.ContextLoaderListener
    		</listener-class>
    	</listener>
    </web-app>

Applicationcontent.xml文件配置（目前没有实现任何功能，给出原始配置）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
	<!-- 定义数据源 ，即连接数据库所需的配置-->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mysql://localhost:mysql端口/数据库名</value>
		</property>
		<property name="username">
			<value>你的用户名</value>
		</property>
		<property name="password">
			<value>你的密码</value>
		</property>
	</bean>
<!-- 定义SessionFactory -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource"/>
		</property>
		<property name="hibernateProperties">
			<props>
//hibernate的方言，决定用哪个数据库
				<prop key="hibernate.dialect">
					org.hibernate.dialect.MySQLDialect
				</prop>
            //是否启动显示sql语句
				<prop key="hibernate.show_sql">false</prop>
			</props>
		</property>
//声明hibernate的映射文件，目前没有，后续步骤在此处加上
		<property name="mappingResources">
			<list>
				<value></value>
			</list>
		</property>
	</bean>
	
	<!-- 定义HibernateTemplate，相当于纯hibernate的session -->
	<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory">
			<ref bean="sessionFactory"/>
		</property>
	</bean>
	省略具体的业务代码注入配置
</beans>

Structs.xml文件配置

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
//防止乱码
<constant name="struts.i18n.encoding" value="utf-8"/>
</struts>
目前该文件里面什么功能都没配置，只是个声明
  1. 编写业务代码
    按照mvc思想，先从持久层开始，即编写hibernate的orm对象user.java
1
2
3
4
5
6
public class User {
	private int age;
	private int id;
	private String name;
此处省略set。Get方法}

映射文件User.hbm.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.zwl.pojo">
<class name="User" >
<id name="id">
<generator class="increment"></generator>
</id>
<property name="name"></property>
<property name="age"></property>
</class>
</hibernate-mapping>

注意这里普通属性有时为了方便，只要声明一个name，其他属性hibernate会自动识别并补充

接下来要在spring中声明该映射文件

1
2
3
4
5
<property name="mappingResources">
			<list>
				<value>com/zwl/pojo/User.hbm.xml</value>
			</list>
		</property>

至此，持久层完成

接下来是dao层

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public interface dengludao {
//登录功能
public User denglu(User u);
}
Dao层的实现类
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.zwl.pojo.User;
public class dengludaoimpl extends HibernateDaoSupport implements dengludao{
	//这里用了spring提供的操作hibernate的模板方法
	@Override
	public User denglu(User u) {
    //find里可以写sql语句
		List<User> list=this.getHibernateTemplate().find("select user from User as user where user.id=?",u.getId());
		if(list.size()==0){
			return null;}
					else{
						return (User) list.get(0);
					}
	}}
	
接下来要在spring中注入到组件
<!-- 配置DAO组件 -->
	<bean id="dengludao" class="com.zwl.dao.dengludaoimpl">
		<property name="hibernateTemplate">
			<ref bean="hibernateTemplate"/>
		</property>
	</bean>

接下来是业务层：
首先是接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public interface dengluservice {
public boolean isdenglu(User u);
}
然后是实现类
public class dengluserviceimpl implements dengluservice{
 //引用dao层组建
	private dengludao denglu;
	
	public dengludao getDenglu() {
		return denglu;
	}
	public void setDenglu(dengludao denglu) {
		this.denglu = denglu;
	}
	@Override
	public boolean isdenglu(User u) {
		if(denglu.denglu(u)!=null)
		return true;
		else{
		return false;
		}
	}}
接下来就要在spring中注入业务层组件
<!-- 配置业务逻辑组件 -->
	<bean id="dengluservice" class="com.zwl.dao.dengluserviceimpl">
		<property name="denglu">
			<ref bean="dengludao"/>
		</property>
	</bean>
  1. 表现层
    首先是两个页面
    Index.Jsp主要提交表单
1
2
3
4
5
<form action="userdenglu.action" method="post">
   id:<input name="id" type="text">
   <br/>
   <input type="submit"/>
   </form>

Success.jsp
主要就是一句success提示

  1. 控制层
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class userdenglu extends ActionSupport{
	private dengluservice dengluservic;
	private int id;
省略set与get方法。。
	@Override
	public String execute() throws Exception {
		User u=new User();
		u.setId(id);
//如果id存在，返回成功
		if(dengluservic.isdenglu(u)){
			return SUCCESS;
		}
		return ERROR;
	}

接下来需要在spring中注入action

1
2
3
4
5
6
<!-- 配置userdengluAction -->
	<bean id="userdenglu" class="com.zwl.action.userdenglu">
		<property name="dengluservic">
			<ref bean="dengluservice"/>
		</property>
	</bean>

同时在structs.xml中配置跳转

1
2
3
4
<action name="userdenglu" class="userdenglu">
			<result name="success">/success.jsp</result>
			<result name="error">/error.jsp</result>
		</action>

最后通过在浏览器输入到index.jsp，然后输入id，数据库中可以预先插入数据，最后跳转，如果成功则跳到success.jsp，否则产生错误

至此：ssh2框架环境搭建成功，最后提醒的是，这只是一个框架环境，我们可以在此基础上按照mvc思想，可以进行我们想要功能的开发

快乐源于分享，总结溢于提高

热评文章