SSH学习实例

作者: 李东浩 | 来源:发表于2017-04-26 17:58 被阅读256次

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>

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

SSH学习实例

1、下载SSH相关的所有依赖的Jar包，导入引用

2、spring整合struts 2

3、创建包结构，如图

4、编写简单的添加商品的业务功能，编写action,service,dao,domain类

5、在SRC目录下添加spring配置文件applicationContext.xml，用于注入bean等 ,配置action、service、dao

6、在src目录下添加struts2配置文件struts.xml

7、在WebContent目录下创建默认访问页面

8、在WebContent目录下添加用于添加商品的addProduct.jsp页面

9、测试Struts2和Spring框架是否整合成功

10、整合Spring和Hiberate框架

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

Pattern to output the caller's file name and line number.

Print only messages of level ERROR or above in the package noModule.

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读