SSH学习实例
1、下载SSH相关的所有依赖的Jar包，导入引用
2、spring整合struts 2
在Web容器中添加spring核心监听器及Struts过滤器
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<display-name>ssh-demo</display-name>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!-- Struts2 的核心过滤器的配置 -->
<filter>
<filter-name>struts</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
<welcome-file>index.htm</welcome-file>
<welcome-file>index.jsp</welcome-file>
<welcome-file>default.html</welcome-file>
<welcome-file>default.htm</welcome-file>
<welcome-file>default.jsp</welcome-file>
</welcome-file-list>
</web-app>
</pre>
3、创建包结构，如图
包结构
4、编写简单的添加商品的业务功能，编写action,service,dao,domain类
domain类即entity类是数据实体类
action类是Struts 2的action类，响应的前端的请求，会调用业务层service类的方法，传入domain类给service类操作
service类是Spring的service类，会调用数据层的dao类，传入domain类给dao类操作
dao类是Spring的dao类，会调用Hibernate的方法写入或读取等动作操作数据库。
Domain 创建表示商品的实体类：
<pre>
package com.ctmold.ssh.domain;
public class Product {
private Integer pid;
private String pname;
private Double price;
/**
* @return the pid
/
public Integer getPid() {
return pid;
}
/*
* @param pid the pid to set
/
public void setPid(Integer pid) {
this.pid = pid;
}
/*
* @return the pname
/
public String getPname() {
return pname;
}
/*
* @param pname the pname to set
/
public void setPname(String pname) {
this.pname = pname;
}
/*
* @return the price
/
public Double getPrice() {
return price;
}
/*
* @param price the price to set
*/
public void setPrice(Double price) {
this.price = price;
}
}
</pre>
Dao 创建访问实体类的Dao类，实际项目中应该先设计一个Dao类的interface，然后再实现该接口
<pre>
package com.ctmold.ssh.dao;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.ctmold.ssh.domain.Product;
public class ProductDao extends HibernateDaoSupport {
public boolean save(Product product)
{
System.out.println("Dao层的save方法执行了。。。");
//执行Hibernate的getHibernateTemplate的save方法
//this.getHibernateTemplate().save(product);
return true;
}
}
</pre>
Serivce 创建调用Dao类的业务层类， 实际项目中应该先设计一个业务层类的interface，然后再实现该接口
<pre>
package com.ctmold.ssh.service;
import com.ctmold.ssh.dao.ProductDao;
import com.ctmold.ssh.domain.Product;
public class ProductService {
private ProductDao productDao;
/**
* @param productDao the productDao to set
*/
public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}
public boolean save(Product product)
{
System.out.println("service层的save 方法执行了。。。");
//执行dao层的save方法
return productDao.save(product);
}
}
</pre>
Action 创建控制层的类，用于调用业务层的类
<pre>
package com.ctmold.ssh.action;
import com.ctmold.ssh.domain.Product;
import com.ctmold.ssh.service.ProductService;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
public class ProductAction extends ActionSupport implements ModelDriven<Product> {
//模型驱动的使用的类
private Product product=new Product();
@Override
public Product getModel() {
// TODO Auto-generated method stub
return product;
}
private ProductService productService;
/**
* @param productService the productService to set
*/
public void setProductService(ProductService productService) {
this.productService = productService;
}
public String save()
{
System.out.println("action 的save方法执行了。。。");
//执行spring的service业务层的save方法
productService.save(product);
return NONE;
}
}
</pre>
5、在SRC目录下添加spring配置文件applicationContext.xml，用于注入bean等 ,配置action、service、dao
5.1:
<pre>
<bean id="productDao" class="com.ctmold.ssh.dao.ProductDao">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</pre>
5.2:
<pre>
<bean id="productService" class="com.ssh.service.ProductService" scope="prototype">
<property name="productDao" ref="productDao"></property>
</bean>
</pre>
5.3:
<pre>
<bean id="productAction" class="com.ctmold.ssh.action.ProductAction" scope="prototype">
<property name="productService" ref="productService"></property>
</bean>
</pre>
6、在src目录下添加struts2配置文件struts.xml
<pre>
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="ssh" extends="struts-default" namespace="/" >
<action name="product_*" class="productAction" method="{1}"></action>
</package>
</struts>
</pre>
7、在WebContent目录下创建默认访问页面
<pre>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>欢迎进入到SSH框架的首页</title>
</head>
<body>
<h1>欢迎进入到SSH框架的首页</h1>
</body>
</html>
</pre>
8、在WebContent目录下添加用于添加商品的addProduct.jsp页面
<pre>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>保存商品</title>
</head>
<body>
<h1>保存商品的页面</h1>
<s:form action="product_save" method="post" namespace="/" theme="simple">
<table border="1" width="400">
<tr>
<td>商品名称</td>
<td>
<s:textfield name="pname"></s:textfield>
</td>
</tr>
<tr>
<td>商品价格</td>
<td>
<s:textfield name="price"></s:textfield>
</td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="添加"/>
</td>
</tr>
</table>
</s:form>
</body>
</html>
</pre>
9、测试Struts2和Spring框架是否整合成功
保存商品页面
控制台显示的信息
10、整合Spring和Hiberate框架
这里使用的是mysql数据库，首先在mysql中创建数据库，名为”ssh”。
在src目录下创建jdbc.properties，主要配置jdbc的连接信息，其中jdbc.username的值为你使用的mysql的用户名，jdbc.password的值为密码
<pre>
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssh
jdbc.user=root
jdbc.passwod=testxxx
</pre>
如果使用日志，也要配置日志文件
<pre>
Log4J Settings for log4j 1.2.x (via jakarta-commons-logging)
The five logging levels used by Log are (in order):
1. DEBUG (the least serious)
2. INFO
3. WARN
4. ERROR
5. FATAL (the most serious)
Set root logger level to WARN and append to stdout
log4j.rootLogger=INFO, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%d %5p (%c:%L) - %m%n
Print only messages of level ERROR or above in the package noModule.
log4j.logger.noModule=FATAL
log4j.logger.com.opensymphony.xwork2=DEBUG
log4j.logger.org.apache.struts2=DEBUG
</pre>
在实体类对应的包下创建实体类的映射文件hbm.xml，将实体类与数据库中的一张表建立映射关系
<pre>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.ctmold.ssh.domain.Product" table="product">
<id name="pid" column="pid">
<generator class="native"></generator>
</id>
<property name="pname" column="pname" length="20"></property>
<property name="price" column="price" ></property>
</class>
</hibernate-mapping>
</pre>
在spring配置文件applicationContext.xml中添加Hibernate的配置信息（也可以使用Hibernate的配置文件hibernate.cfg.xml中） ，完成真正的连接数据
其中Dao类，配置注入productDao bean
<pre>
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- 配置c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}"/>
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.user}" />
<property name="password" value="${jdbc.passwod}"/>
</bean>
<!-- 配置Hibernate的相关属性 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 注入连接池 -->
<property name="dataSource" ref="dataSource"></property>
<!-- 配置Hibernate相关属性 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<!-- 可更新表结构，没表就创建表 -->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!-- 加载Hibernate映射文件 -->
<property name="mappingResources">
<list>
<value>com/ctmold/ssh/domain/Product.hbm.xml</value>
</list>
</property>
</bean>
<!-- 配置DAO的类 -->
<!-- 配置注入productDao bean -->
<bean id="productDao" class="com.ctmold.ssh.dao.ProductDao">
<!-- 继承hibernateDaoSupport直接注入 -->
<!-- 注入sessionFactory，这样就可以使用hibernate框架操作数据库 -->
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
</pre>
测试下自动创建表是否成功，启动项目，然后看表是否建立OK
添加数据Dao持久层代码，将商品信息保存到数据库
ProductDao.java
<pre>
package com.ctmold.ssh.dao;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.ctmold.ssh.domain.Product;
public class ProductDao extends HibernateDaoSupport {
public boolean save(Product product)
{
System.out.println("Dao层的save方法执行了。。。");
//调用getHibernateTemplate()方法，该方法直接封装了读取配置文件configuration，读取映射文件，创建session工厂sessionFactory，获得session等步骤，简化了我们的操作
this.getHibernateTemplate().save(product);
return true;
}
}
</pre>
在spring配置文件applicationContext.xml中添加数据库操作的事务处理
<pre>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" ></property>
</bean>
<!-- 开启注解事务 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
</pre>
ProductService.java --注入spring提供的的事务管理
<pre>
package com.ctmold.ssh.service;
import org.springframework.transaction.annotation.Transactional;
import com.ctmold.ssh.dao.ProductDao;
import com.ctmold.ssh.domain.Product;
@Transactional //该注解表示注入spring提供的的事务管理
public class ProductService {
private ProductDao productDao;
/**
* @param productDao the productDao to set
* spring框架中的构造的方式注入bean： productDao
*/
public void setProductDao(ProductDao productDao) {
this.productDao = productDao;
}
public boolean save(Product product)
{
System.out.println("service层的save 方法执行了。。。");
//执行dao层的save方法
return productDao.save(product);
}
}
</pre>
这样整合就完成了，整个项目的结构图如下
整体图
以上完工！
有问题和建议欢迎留言，一起学习交流！
2017-04-26 17:57
