S2SH开发环境搭建、框架整合、项目基础环境搭建
1.S2SH框架整合
新建项目s2sh：
1.1添加jar包
1.1.1添加Struts的jar包
添加如下的jar包：
commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar
freemarker-2.3.19.jar
ognl-3.0.5.jar
struts2-core-2.3.4.1.jar
xwork-core-2.3.4.1.jar
疑惑：这些jar可以从哪里获得呢？
对于一个框架来说，别人要使用该框架，那么可以从最原始的官方压缩包中找到，但是其中的jar包有很多，我么可以从它提供的例子程序中找到，如Struts的官方原始压缩包，解压后如下图：
我们要从struts的官方开发包中获取我们需要的jar包，找到它提供给我们的例子，打开apps目录。如下图：
apps里面存放的都是struts官方提供的例子，都是war包，可以直接部署到tomcat中运行的例子程序，那么这里例子里面就有我们需要的jar包，我将其中一个解压出来。
struts2-blank-2.1.8.1目录中：
找到WEB-INF目录中的lib目录，将lib目录中的所有jar包都拷贝到我们项目中的lib目录中。
所以上面的这些jar包也可以这样获得。
上图中使用的是Struts 2.1.8版本，其他版本的都一样。
三大框架整合使用的时候，Struts的Action会交给Spring来管理，因此还需要一个Struts和和Spring整合的jar包：struts2-spring-plugin-2.1.6.jar
1.1.2添加Hibernate的jar包
添加如下的jar包：
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate3.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
slf4j-log4j12-1.6.1.jar
解压从官网下载下来的hibernate-distribution-3.6.0.Final.zip压缩包：
添加hibernate3.jar，lib\required\*.jar，lib\jpa\hibernate-jpa-2.0-api-1.0.0.Final.jar、(实体生成表时需要)、lib\optional\c3p0\c3p0-0.9.1.jar、mysql数据库的驱动包到web-inf/lib目录下。
需要用到数据库的操作，因此我们要用到数据库的驱动jar包，这里用的mysql数据库因此添加：mysql-connector-java-5.0.4-bin.jar
需要用到数据库连接池，这里使用c3p0数据库连接池，因此还需要添加c3p0的jar包：
c3p0-0.9.1.2.jar
1.1.3添加Spring的jar包
这里使用的是Spring3.0的版本，添加Spring的jar包主要包括四个部分：
Spirng3-AOP 面向切面编程jar包
|--com.springsource.net.sf.cglib-2.2.0.jar
|--com.springsource.org.aopalliance-1.0.0.jar
|--com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
|--org.springframework.aop-3.0.1.RELEASE-A.jar
|--org.springframework.aspects-3.0.1.RELEASE-A.jar
|--org.springframework.instrument.tomcat-3.0.1.RELEASE-A.jar
|--org.springframework.instrument-3.0.1.RELEASE-A.jar
Spring3-Core 核心jar包
|--com.springsource.org.apache.commons.logging-1.1.1.jar
|--com.springsource.org.apache.log4j-1.2.15.jar
|--jmxtools-1.2.1.jar
|--org.springframework.asm-3.0.1.RELEASE-A.jar
|--org.springframework.beans-3.0.1.RELEASE-A.jar
|--org.springframework.context-3.0.1.RELEASE-A.jar
|--org.springframework.core-3.0.1.RELEASE-A.jar
|--org.springframework.expression-3.0.1.RELEASE-A.jar
Spring3-Persistence-Core 持久化jar包
|--org.springframework.jdbc-3.0.1.RELEASE-A.jar
|--org.springframework.orm-3.0.1.RELEASE-A.jar
|--org.springframework.transaction-3.0.1.RELEASE-A.jar
|--persistence.jar
Spring3-Web web支持的jar包
|--com.springsource.org.apache.commons.fileupload-1.2.0.jar
|--com.springsource.org.apache.commons.httpclient-3.1.0.jar
|--com.springsource.org.codehaus.jackson.mapper-1.0.0.jar
|--org.springframework.oxm-3.0.1.RELEASE-A.jar
|--org.springframework.web.portlet-3.0.1.RELEASE-A.jar
|--org.springframework.web.servlet-3.0.1.RELEASE-A.jar
|--org.springframework.web.struts-3.0.1.RELEASE-A.jar
|--org.springframework.web-3.0.1.RELEASE-A.jar
添加log4j的日志jar包
commons-lang3-3.1.jar
commons-logging-1.1.1.jar
log4j-1.2.11.jar
将以上三个框架列举的jar添加到项目的WEB-INF/lib目录下即可。
1.2编写项目配置文件
将项目中所有的配置文件都放置到一个Source Folder目录中，Source Folder目录等同于src目录，项目部署后会自动发布到classess目录中。
选择项目邮件 → New → Source Folder，新建一个Source Folder取名为config目录。
1.2.1 Struts的配置文件（struts.xml）
struts.xml的配置文件的写法基本上都是这样固定的，如下：
struts.xml文件的编写如下
<?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>
<!-- 禁用动态方式访问 -->
<constant name="struts.enable.DynamicMethodInvocation" value="false" />
<!-- 开发模式 -->
<constant name="struts.devMode" value="true" />
<!-- 简单主题 -->
<constant name="struts.ui.theme" value="simple" />
<!-- 拓展名为action -->
<constant name="struts.action.extension" value="action" />
<!-- struts package配置 -->
<package name="s2sh" namespace="/" extends="struts-default">
<!-- Action的配置在这里 -->
<action name="test_*" class="testAction" method="{1}">
</action>
</package>
</struts>
修改项目的web.xml配置文件，添加Struts的核心过滤器配置：
添加配置如下：
<!-- 配置Struts的核心过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
1.2.2 Hibernate配置文件（hibernate.cfg.xml和*.hbm.xml）
Hibernate和Spring整合后可以将所有的配置信息都交给Spring配置，因此hibernate.cfg.xml不再需要。使用一个properties文件来配置数据库的连接信息，Spring则从该properties文件中获取数据库的连接信息，该配置文件为：jdbc.properties，编写如下：
##数据库连接地址
jdbcUrl=jdbc:mysql://localhost:3306/oa?useUnicode=true&characterEncoding=utf8
##数据库连接驱动
driverClass=com.mysql.jdbc.Driver
##用户名
user=root
##密码
password=root
##Hibernate使用的数据库方言
hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
##Hibernate自动建表
hibernate.hbm2ddl.auto=update
##显示Sql语句
hibernate.show_sql=true
##格式化SQL语句
hibernate.format_sql=true
*.hbm.xml的配置文件我们将它同样的放置到config目录中，在该目录下建立一个hbm目录，将所有的*.hbm.xml文件都放置到该目录中便于Spring自动扫描所有的*.hbm.xml文件。Hbm文件的示例如下：User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="oa.user.model">
<class name="User" table="t_User">
<id name="id">
<generator class="native"/>
</id>
<property name="name" />
</class>
</hibernate-mapping>
1.2.3 Spring的配置文件（appliactionContext.xml）
appliactionContext.xml的配置文件编写如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!-- 配置扫描注解自动装配bean -->
<context:component-scan base-package="s2sh"></context:component-scan>
<!-- 导入外部properties文件,配置数据库连接信息 -->
<context:property-placeholder location="classpath:jdbc.properties" />
<!-- 配置SessionFactory -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- hibernate的配置信息 -->
<property name="hibernateProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
</props>
</property>
<!-- 配置扫描加载hbm映射文件的位置 -->
<property name="mappingDirectoryLocations">
<!-- list代表所有文件 -->
<list>
<!-- classpath路径下面的hbm文件夹中搜索hbm映射文件 -->
<value>classpath:hbm</value>
</list>
</property>
<!-- 配置c3p0数据库连接池 -->
<property name="dataSource">
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 配置数据库连接信息 -->
<property name="jdbcUrl" value="${jdbcUrl}" />
<property name="driverClass" value="${driverClass}" />
<property name="user" value="${user}" />
<property name="password" value="${password}" />
<!-- 其他配置 -->
<!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
<property name="initialPoolSize" value="3" />
<!--连接池中保留的最小连接数。Default: 3 -->
<property name="minPoolSize" value="3" />
<!--连接池中保留的最大连接数。Default: 15 -->
<property name="maxPoolSize" value="5" />
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
<property name="acquireIncrement" value="3" />
<!--
控制数据源内加载的PreparedStatements数量。如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default:
0
-->
<property name="maxStatements" value="8" />
<!--
maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0
-->
<property name="maxStatementsPerConnection" value="5" />
<!--最大空闲时间,1800秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
<property name="maxIdleTime" value="1800" />
</bean>
</property>
</bean>
<!-- 配置事务管理（采用注解方式） -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
项目中使用的日志管理，因此还添加一个做日志的配置文件：log4j.properties，其配置信息如下：
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
### set log levels - for more verbose logging change 'info' to 'debug' ###
log4j.rootLogger=error, stdout
#log4j.logger.org.hibernate=info
log4j.logger.officeoa=debug
### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug
### log just the SQL
#log4j.logger.org.hibernate.SQL=debug
### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug
### log schema export/update ###
#log4j.logger.org.hibernate.tool.hbm2ddl=debug
### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug
### log cache activity ###
#log4j.logger.org.hibernate.cache=debug
### log transaction activity
#log4j.logger.org.hibernate.transaction=debug
### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug
### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace
修改web.xml文件，添加Spring监听器：
<!-- 配置spring监听器 -->
<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>
最终的web.xml配置信息如下：
<?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">
<!-- 配置spring监听器 -->
<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>
<!-- 配置Struts的核心过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
最终config配置文件目录如下：
1.3整合框架测试
所有的测试类都放置在test目录中。
1.3.1测试Struts
编写测试的Action类：
package test;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import com.opensymphony.xwork2.ActionSupport;
/**
* Action交给Spring管理
* @author Leo.Chen
*
*/
@Controller
@Scope("prototype")
public class TestAction extends ActionSupport {
@Override
public String execute() throws Exception {
return this.SUCCESS;
}
}
在struts.xml配置文件中添加Action的配置：
<!-- struts package配置 -->
<package name="s2sh" namespace="/" extends="struts-default">
<action name="testAction" class="testAction">
<result name="success">/test.jsp</result>
</action>
</package>
编写测试页面：test.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
</head>
<body>
Struts框架测试成功！ <br>
</body>
</html>
部署访问：http://localhost:8080/s2sh/testAction.action
页面成功：
1.3.2测试Spring、Hibernate
编写测试类：SpringHibernateTest.java
package test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* 测试Spring与Hibernate环境搭建
*
* @author Leo.Chen
*
*/
public class SpringHibernateTest {
private ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
/**
* 测试Spring
*/
@Test
public void testSpring() {
/**
* Struts的Action交给Spring的IOC容器管理，这里如果能获取testAction的实例对象，
* 说明Spring的IOC容器环境测试通过
*/
TestAction testAction = ac.getBean("testAction", TestAction.class);
System.out.println(testAction);
}
}
测试结果如下：
在SpringHibernateTest.java类中添加测试方法，测试Hibernate的持久化功能和Spring的事务管理功能。
/**
* 测试Hibernate功能和Spring的事务管理
*/
@Test
public void testHibernate_Tx() {
}
在测试之前需要做一些准备。
准备实体类和实体类对象的映射文件以及Service
User实体类：
package test;
public class User {
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
与之对应的映射文件：User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="test">
<class name="User" table="t_User">
<id name="id">
<generator class="native"/>
</id>
<property name="name" />
</class>
</hibernate-mapping>
编写Service测试添加用户功能，由于是测试环境因此就直接写Service的实现类了，而不写接口了。
package test;
import javax.annotation.Resource;
import org.hibernate.SessionFactory;
import org.hibernate.Session;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@Transactional
public class TestService {
// 将sessionFactory注入
@Resource
private SessionFactory sessionFactory;
/**
* 添加用户
*/
public void save() {
Session session = sessionFactory.getCurrentSession();
session.save(new User());
int i = 1/0;// 这里报异常，事务管理会回滚
session.save(new User());
}
}
在SpringHibernateTest.java的testHibernate_Tx方法中加入测试代码：
/**
* 测试Hibernate功能和Spring的事务管理
*/
@Test
public void testHibernate_Tx() {
TestService testService = ac.getBean("testService", TestService.class);
testService.save();
}
分析测试结果：
把TestService类中的save()方法的异常代码注释掉，则能添加两个用户；如果加上该异常代码，则两个用户都不能添加。因此Spring的事务管理和Hibernate持久化功能测试通过。
test目录下的所有类：
1.3.4整合Struts、Hibernate和Spring综合测试
修改TestAction中的代码，在Action中调用TestService的save方法，将TestService中的save方法中的异常代码注释掉。TestAction代码如下：
@Controller
@Scope("prototype")
public class TestAction extends ActionSupport {
@Resource
private TestService testService;
@Override
public String execute() throws Exception {
testService.save();
return this.SUCCESS;
}
}
重新部署访问：http://localhost:8080/s2sh/testAction.action
数据库中的数据结果：
2.项目基础环境搭建
2.1搭建项目包结构
建立包结构如下图：
暂时先建立上面的包结构，如果还需要用到其他的包，开发过程中再建立。
注意：在实际的开发中，业务逻辑比较少的情况下，可以将Dao和Service层合并为Service层，这里采用的就是这种策略。
2.2编写基础环境Dao数据访问对象的支持类DaoSupport
针对基本的CRUD，我们需要将CRUD的所有公共代码都抽取到DaoSupport中。
在实际开发中我们需要面向接口开发，因此需要建立接口。在core下面的dao包中建立DaoSupport接口，将对应的实现类方法实现包impl中。如下：
DaoSupport接口的定义如下：
package s2sh.core.dao;
import java.util.List;
/**
* 通用Dao数据操作接口
* @author Leo.Chen
*
*/
public interface DaoSupport<T> {
/**
* 保存
* @param t
*/
public void save(T t);
/**
* 删除
* @param id
*/
public void delete(Long id);
/**
* 更新
* @param t
*/
public void update(T t);
/**
* 查询所有
* @return
*/
public List<T> findAll();
/**
* 根据Id查询
* @param id
* @return
*/
public T findById(Long id);
/**
* 根据一组id查询
* @param ids
* @return
*/
public List<T> findByIds(Long[] ids);
}
对应的实现类DaoSupportImpl
package s2sh.core.dao.impl;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Transactional;
import s2sh.core.dao.DaoSupport;
/**
* 通用Dao数据操作实现类
*
* @author Leo.Chen
*
* @param <T>
*/
@SuppressWarnings("unchecked")
@Transactional
public abstract class DaoSupportImpl<T> implements DaoSupport<T> {
private Class<T> clazz;
@Resource
private SessionFactory sessionFactory;
public DaoSupportImpl() {
ParameterizedType pt = (ParameterizedType) this.getClass() .getGenericSuperclass();
clazz = (Class<T>) pt.getActualTypeArguments()[0];
}
public Session getSession() {
return sessionFactory.getCurrentSession();
}
@Override
public void save(T t) {
getSession().save(t);
}
@Override
public void delete(Long id) {
getSession().delete(getSession().get(clazz, id));
}
@Override
public void update(T t) {
getSession().update(t);
}
@Override
public List<T> findAll() {
return getSession().createQuery("FROM " + clazz.getSimpleName()).list();
}
@Override
public T findById(Long id) {
if (id != null) {
return (T) getSession().get(clazz, id);
} else {
return null;
}
}
@Override
public List<T> findByIds(Long[] ids) {
List<T> resultList = new ArrayList<T>();
if (ids != null) {
for (Long id : ids) {
resultList.add((T)this.getSession().get(clazz, id));
}
}
return resultList;
}
}
在基础环境中对Struts的Action做一个基础环境的抽取，使用ModelDriven拦截实现页面数据的封装，将所有的Service实例的声明都定义在BaseAction中，使得具体模块的Action只需要继承BaseAction即可，然后负责处理自己的业务逻辑即可。
BaseAction编写如下：
package s2sh.core.action;
import java.lang.reflect.ParameterizedType;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
/**
* 通用基础Action类
*
* @author Leo.Chen
*
* @param <T>
*/
@SuppressWarnings("unchecked")
public abstract class BaseAction<T> extends ActionSupport implements ModelDriven<T> {
private static final long serialVersionUID = 5412467040546639342L;
protected T model;
public BaseAction() {
ParameterizedType pt = (ParameterizedType) this.getClass() .getGenericSuperclass();
Class<T> clazz = (Class<T>) pt.getActualTypeArguments()[0];
try {
model = clazz.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
public T getModel() {
return model;
}
}
2.3针对基本的CRUD--Action模板代码的编写
基本CRUD在Action中的六个方法：
/**
* 列表展示
*
* @return
* @throws Exception
*/
public String list() throws Exception {
return "list";
}
/**
* 删除
*
* @return
* @throws Exception
*/
public String delete() throws Exception {
return "toList";
}
/**
* 添加页面
*
* @return
* @throws Exception
*/
public String addUI() throws Exception {
return "saveUI";
}
/**
* 添加
*
* @return
* @throws Exception
*/
public String add() throws Exception {
return "toList";
}
/**
* 修改页面
*
* @return
* @throws Exception
*/
public String editUI() throws Exception {
return "saveUI";
}
/**
* 修改
*
* @return
* @throws Exception
*/
public String edit() throws Exception {
return "toList";
}
2.4 struts.xml配置文件的模板编写：
<!-- struts package配置 -->
<package name="s2sh" namespace="/" extends="struts-default">
<!-- 用户管理 -->
<action name="user_*" class="userAction" method="{1}">
<result name="list">/WEB-INF/jsp/user/list.jsp</result>
<result name="toList" type="redirectAction">user_list</result>
<result name="saveUI">/WEB-INF/jsp/user/save.jsp</result>
</action>
</package>
android学习笔记（38）使用ProgressDialog创建进皮对话框
大型网站架构设计-Solr
android学习笔记（39）消息提示使用Toast昱示提示信息輕
android学习笔记（32）网格视图（GridView )和图形切换器（ImageSwi...
android学习笔记（31）可展开的列表组件（ExpandableListView )
更多关于android开发文章
相关推荐
总结，S2SH框架的搭建涉及多个步骤，包括环境配置、库文件管理、配置文件编写以及整合测试。这个过程对于初学者来说可能会有些复杂，但理解并掌握这些步骤对于深入学习Java Web开发至关重要。通过实践，你可以更好地...
通过以上步骤，一个简单的S2SH项目就开发完成了。对于初学者来说，理解每个框架的核心功能和它们之间的协作关系是非常重要的，这将有助于快速掌握企业级Web应用的开发技能。同时，随着经验的积累，还可以进一步探索...
总结来说，S2SH（Struts2+Spring+Hibernate）开发环境的搭建是一个涉及多个步骤的过程，包括添加框架库、创建和配置核心文件，以及确保所有组件之间的协同工作。正确配置这些组件，可以极大地提高开发效率和代码质量...
本教程将详细介绍如何搭建一个完整的S2SH框架环境，并提供源代码供参考。 首先，我们需要了解每个组件的基础： 1. **Struts 2**：这是一个基于MVC设计模式的Java Web框架，主要负责处理用户请求，控制应用程序流程...
本项目以"Maven搭建的S2SH框架"为主题，旨在实现一个简单的易买网CRUD（创建、读取、更新、删除）操作，并整合了事务管理和日志功能。 1. **Struts 2**：Struts 2是一个基于MVC（Model-View-Controller）设计模式的...
S2SH框架结合了Struts2的MVC设计模式、Spring的依赖注入与事务管理以及Hibernate的对象关系映射功能，为开发者提供了高效、稳定且易于维护的Web应用开发环境。 【描述】项目适合初学者学习 对于初学者来说，这个...
**S2SH架构搭建简单实例解析** S2SH架构，全称为Struts2+Spring+Hibernate，是Java Web开发中的经典MVC（Model-View-Controller）架构组合。这个架构结合了Struts2的视图控制、Spring的依赖注入与事务管理以及...
这个压缩包“s2sh整合所需jar包大全”提供了一整套支持S2SH整合所需的库文件，适用于Eclipse开发环境。 1. **Struts 2**: Struts 2 是一个基于MVC设计模式的Web应用框架，它扩展了经典的Struts 1，提供了更强大的...
### S2SH框架搭建步骤详解 #### 一、概述 S2SH框架是Spring、Struts2和Hibernate三种技术的组合应用，它们分别用于业务逻辑层、表示层和...希望本指南能够帮助您顺利搭建起S2SH框架，并在项目开发中发挥重要作用。
下面将详细介绍如何搭建S2SH开发环境。 1. **Struts2**： Struts2是Apache软件基金会的一个开源项目，它是一个基于MVC设计模式的Web应用框架。Struts2的核心是Action，用于处理用户请求并控制应用程序流程。它提供...
描述中的“s2sh开发包整合”提示我们需要将这些JAR文件整合到项目中，以确保所有必要的组件都能协同工作。整合过程通常包括以下步骤： 1. **配置Struts 2**: 添加Struts 2的核心库，如struts2-core.jar，并在web....
通过下载的"mytest"压缩包，开发者可以直接导入IDE进行项目运行，省去了搭建环境和基础配置的步骤，特别适合新手快速上手学习S2SH框架的使用。 总结，S2SH整合提供了一种高效、成熟的Java Web开发解决方案，它简化...
在这个"s2sh三大框架最新版本整合jar包"中，开发者已经预先处理过，去除了重复的jar包，使得这些框架可以直接集成到项目中，避免了版本冲突和手动管理库文件的麻烦。这意味着你可以快速启动一个新的项目，而不必花费...
在开发环境中（如MyEclipse），首先需要创建一个新的Web项目，这是搭建S2SH框架的基础。创建Web项目时，确保选择正确的项目类型和项目依赖，以便后续可以顺利地添加各种框架的库文件和配置。 #### 二、添加...
这种集成方式对于快速搭建s2sh项目非常方便，减少了初始设置的时间和可能出现的配置错误。 【标签】"s2sh整合完全包"强调了这个压缩文件的核心价值，即提供了一个完整的、预配置好的环境，用于整合Struts2、Spring...
### S2SH框架搭建知识点详解 #### 一、项目背景及目标 S2SH框架，即Struts2 + Spring + Hibernate框架的组合，是Java Web开发中常用的MVC架构实现方式之一。它集成了三个强大的开源框架：Struts2用于处理用户请求...
【S2SH项目搭建】是关于使用Struts2、Spring和Hibernate这三大开源框架整合构建Web应用程序的过程。这个项目搭建涉及的技术栈广泛，涵盖了前端控制器、业务层管理和数据持久化等多个层面，对于初学者和开发者来说，...
《S2SH框架搭建登录实例详解》 S2SH框架，即Struts2、Spring和Hibernate的集成，是Java Web开发中的经典组合，它将MVC模式、依赖注入和持久化管理有效地融合在一起，提供了强大的功能和灵活性。本文将详细阐述如何...
S2SH开发环境是指整合了Struts2、Spring以及Hibernate三大框架的Java Web应用开发环境。这种组合利用各自的优势，可以构建出高度灵活且功能强大的应用程序。本文档将详细介绍如何搭建基于Struts2.0.14、Spring2.5、...