您的位置：首页 > 其它

SSH2框架搭建

2013-04-15 11:04 225 查看

转载：http://www.open-open.com/lib/view/open1338338871558.html

SSH框架，当今最为流行的项目开发框架，那么掌握他的第一步自然是学习如何配置环境，java Web开发的无论哪种框架都离不开各种xml配置，虽然说配置在网上到处都有，但是要成为高手，必须要明白配置中每一部分的意义，分析它的规律，因此走好这第一步至关重要。
SSH分为SSH1和SSH2，区别主要在于Struts的版本，即Struts1和Struts2，Struts1与Struts2在配置上有所差别，但每一步配置的意义区别不大。对于Struts1框架的搭建我已经在之前的文章介绍过了：/article/7603507.html
这回主要为大家介绍的是基于Struts2的SSH2框架搭建。
我们在搭建框架之前，首先一定要注意各个框架的版本，不同的版本集成方式和所需的jar包是有区别的。
SSH2框架的版本为：struts-2.2.3 + spring-2.5.6 + hibernate-3.6.8
1.所需jar包
struts2：
struts2-core-2.2.3.jar
struts2-spring-plugin-2.2.3.jar
xwork-core-2.2.3.jar
commons-io-2.0.1.jar
commons-lang-2.5.jar
commons-fileupload-1.2.2.jar
freemarker-2.3.16.jar
ognl-3.0.1.jar
javassist-3.12.0.GA.jar（hibernate同样需要）
spring：
spring.jar
commons-logging-1.1.1.jar
common-annotations.jar
aspectjrt.jar
aspectjweaver.jar
cglib-nodep-2.1_3.jar
（如果用BasicDataSource来配置数据库连接，还要加入以下2个包）
commons-dbcp.jar
commons-pool.jar
hibernate：
hibernate3.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
slf4j-nop-1.6.4.jar（这个jar包要去slf4j官网下载slf4j-1.6.4集成包）
jdbc：
ojdbc14.jar（oracle）
2. web.xml配置

001	<? xml version = "1.0" encoding = "UTF-8" ?>

web-app

xmlns:xsi

"http://www.w3.org/2001/XMLSchema-instance"

xmlns

"http://java.sun.com/xml/ns/javaee"

xmlns:web

"http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

xsi:schemaLocation

"http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"[/code] id
=
"WebApp_ID"

version
=
"2.5"
>

003	< display-name >testSSH</ display-name >

004	< welcome-file-list >

005	< welcome-file >index.jsp</ welcome-file >

006	</ welcome-file-list >

009	<!-- 配置资源 -->

010	< context-param >

011	< param-name >contextConfigLocation</ param-name >

012	< param-value >classpath:config/applicationContext.xml</ param-value >

013	</ context-param >

015	<!-- 配置自定义filter，并由spring管理 -->

<!--

<filter>

018	<filter-name>myFilter</filter-name>

019	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

020	<init-param>

021	<param-name>targetFilterLifecycle</param-name>

022	<param-value>true</param-value>

023	</init-param>

024	<init-param>

025	<param-name>encoding</param-name>

026	<param-value>UTF-8</param-value>

027	</init-param>

</filter>

031	<filter-mapping>

032	<filter-name>myFilter</filter-name>

033	<url-pattern>/*</url-pattern>

034	</filter-mapping>

-->

038	<!-- 配置CharacterEncoding，设置字符集 -->

039	< filter >

040	< filter-name >characterEncodingFilter</ filter-name >

041	< filter-class >org.springframework.web.filter.CharacterEncodingFilter</ filter-class >

042	< init-param >

043	< param-name >encoding</ param-name >

044	< param-value >UTF-8</ param-value >

045	</ init-param >

046	< init-param >

047	< param-name >forceEncoding</ param-name >

048	< param-value >true</ param-value >

049	</ init-param >

050	</ filter >

052	< filter-mapping >

053	< filter-name >characterEncodingFilter</ filter-name >

054	< url-pattern >/*</ url-pattern >

055	</ filter-mapping >

057	<!-- 将HibernateSession开关控制配置在Filter，保证一个请求一个session，并对lazy提供支持 -->

058	< filter >

059	< filter-name >hibernateFilter</ filter-name >

060	< filter-class >org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</ filter-class >

061	< init-param >

062	< param-name >singleSession</ param-name >

063	< param-value >true</ param-value >

064	</ init-param >

065	</ filter >

067	< filter-mapping >

068	< filter-name >hibernateFilter</ filter-name >

069	< url-pattern >*.do</ url-pattern >

070	</ filter-mapping >

073	<!-- 配置struts2 -->

074	< filter >

075	< filter-name >struts2</ filter-name >

076	< filter-class >org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</ filter-class >

077	< init-param >

078	< param-name >config</ param-name >

079	< param-value >struts-default.xml,struts-plugin.xml,/config/struts.xml</ param-value >

080	</ init-param >

081	</ filter >

083	< filter-mapping >

084	< filter-name >struts2</ filter-name >

085	< url-pattern >/*</ url-pattern >

086	</ filter-mapping >

089	<!-- 配置spring -->

090	< listener >

091	< listener-class >org.springframework.web.context.ContextLoaderListener</ listener-class >

092	</ listener >

095	<!-- 页面session配置 -->

096	< session-config >

097	< session-timeout >20</ session-timeout >

098	</ session-config >

101	<!-- 错误页面 -->

102	< error-page >

103	< error-code >404</ error-code >

104	< location >/error404.html</ location >

105	</ error-page >

106	</ web-app >

注意：
① 配置自定义filter即DelegatingFilterProxy时，参数targetFilterLifecycle设为true是将filter放入web容器中成为真正意义上的filter。否则只是个代理filter，不具有filter的生命周期，因此无法执行filter的init、destroy方法。因为统一交由spring管理，所以在spring资源配置文件（如applicationContext.xml）中必须相应的并且名称为myFilter的bean。
② OpenSessionInViewFilter要将参数singleSession设置为true，否则意义不大。
③ 配置struts2建议采用StrutsPrepareAndExecuteFilter。struts.xml默认放在src根目录下，若想放置到其他地方还要将struts-default.xml和struts-plugin.xml一同配置下，否则在于其他框架结合时（如spring）就会报错。配置struts2的filter标签要放到所有filter标签的最下面，否则会有问题。
3. struts.xml配置

01	<!DOCTYPE struts PUBLIC

02	"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

03	"http://struts.apache.org/dtds/struts-2.0.dtd">

04	< struts >

05	<!-- 将Action的创建交给spring来管理 -->

06	< constant name = "struts.objectFactory" value = "spring" />

08	<!-- 更改struts2请求Action的后缀名，默认为action。若想去掉后缀，设为","即可 -->

09	< constant name = "struts.action.extension" value = "do" ></ constant >

11	< package name = "struts" namespace = "/" extends = "struts-default" >

12	<!-- 配置拦截器 -->

13	< interceptors >

14	< interceptor name = "myInterceptor" class = "myInterceptor" ></ interceptor >

15	< interceptor-stack name = "myDefult" >

16	< interceptor-ref name = "myInterceptor" ></ interceptor-ref >

17	< interceptor-ref name = "defaultStack" ></ interceptor-ref >

18	</ interceptor-stack >

19	</ interceptors >

21	< action name = "myLogin" class = "loginAction" >

22	< result name = "success" >/success.jsp</ result >

23	< result name = "error" type = "redirect" >/index.jsp</ result >

24	</ action >

26	< action name = "testSession" class = "sessionAction" >

27	< interceptor-ref name = "myDefult" ></ interceptor-ref >

28	< result name = "success" >/success.jsp</ result >

29	< result name = "error" type = "redirect" >/login.jsp</ result >

30	</ action >

31	</ package >

32	</ struts >

注意：
① 执行完自定义拦截器后，还要执行struts2默认的拦截器defaultStack，否则可能会出错。
② action标签的class属性，与spring结合后要写成spring中bean的名称name。
4. applicationContext.xml

01	<? xml version = "1.0" encoding = "UTF-8" ?>

02	< beans xmlns = "http://www.springframework.org/schema/beans"

03	xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"

04	xmlns:aop = "http://www.springframework.org/schema/aop"

05	xmlns:context = "http://www.springframework.org/schema/context"

06	xmlns:tx = "http://www.springframework.org/schema/tx"

07	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd[/code]

08	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd[/code]

09	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd[/code]

10	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">[/code]

11	<!-- 启用spring注解支持 -->

12	< context:annotation-config />

14	<!-- 第一种方法配置sessionFactory -->

15	< bean id = "sessionFactory" class = "org.springframework.orm.hibernate3.LocalSessionFactoryBean" >

16	< property name = "configLocation" value = "classpath:config/hibernate.cfg.xml" ></ property >

</

bean

19	<!-- 第二种方法配置sessionFactory

20	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

21	<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>

22	<property name="url" value="jdbc:oracle:thin:@localhost:1521:wang"/>

23	<property name="username" value="wang"/>

24	<property name="password" value="wang"/>

</bean>

27	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

28	<property name="dataSource" ref="dataSource"/>

30	<property name="hibernateProperties">

<props>

32	<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>

33	<prop key="hibernate.show_sql">true</prop>

</props>

35	</property>

37	<property name="mappingLocations">

<list>

39	<value>classpath:test/entity/User.hbm.xml</value>

</list>

41	</property>

</bean>

-->

45	<!-- 第一种方法配置事务 -->

46	< bean id = "transactionManager" class = "org.springframework.orm.hibernate3.HibernateTransactionManager" >

47	< property name = "sessionFactory" ref = "sessionFactory" />

</

bean

50	< tx:advice id = "txadvice" transaction-manager = "transactionManager" >

51	< tx:attributes >

52	< tx:method name = "add*" propagation = "REQUIRED" rollback-for = "Exception" />

53	< tx:method name = "del*" propagation = "REQUIRED" no-rollback-for = "MyException" />

54	< tx:method name = "update*" propagation = "REQUIRED" />

55	< tx:method name = "*" propagation = "REQUIRED" read-only = "true" />

56	</ tx:attributes >

57	</ tx:advice >

59	< aop:config >

60	< aop:pointcut id = "daoMethods" expression = "execution(* test.dao..(..))" />

61	< aop:advisor advice-ref = "txadvice" pointcut-ref = "daoMethods" />

62	</ aop:config >

64	<!-- 第二种方法配置事务

65	<bean id="transactionProxy" class= "org.springframework.transaction.interceptor.TransactionProxyFactoryBean" abstract="true">

66	必须为true时CGLIB才不用强制编写DAO接口

67	<property name="proxyTargetClass" value="true" />

68	<property name="transactionManager" ref="transactionManager" />

69	<property name="transactionAttributes">

<props>

71	<prop key="add*">PROPAGATION_REQUIRED, -Exception</prop>

72	<prop key="del*">PROPAGATION_REQUIRED, +MyException</prop>

73	<prop key="update">PROPAGATION_REQUIRED</prop>

74	<prop key="*">PROPAGATION_REQUIRED, readOnly</prop>

</props>

76	</property>

</bean>

79	<bean id="userService" parent="transactionProxy">

80	<property name="target" ref="iUserService"></property>

</bean>

83	<bean id="iUserService" class="test.service.UserServiceImpl"></bean>

-->

86	< bean id = "userService" class = "test.service.UserServiceImpl" ></ bean >

88	< bean id = "userDao" class = "test.dao.UserDaoImpl" >

89	< property name = "sessionFactory" ref = "sessionFactory" />

</

bean

92	<!-- spring管理的自定义filter -->

93	< bean id = "myFilter" class = "test.service.MyFilter" ></ bean >

95	<!-- spring管理struts2的Action -->

96	< bean id = "loginAction" class = "test.action.LoginAction" scope = "prototype" ></ bean >

97	< bean id = "sessionAction" class = "test.action.SessionAction" scope = "prototype" ></ bean >

98	< bean id = "myInterceptor" class = "test.service.MyInterceptor" scope = "prototype" ></ bean >

99	</ beans >

注意：
① 配置事务时，如果事务是与含有sessionFactory的DAO层关联的话，要将<aop:config>标签的proxy-target-class属性设为true（第二种方法是proxyTargetClass属性），否则就会报错
② 采用Resource或Autowired注解时，bean中无需配置property属性标签。
③ 采用第二种方法配置sessionFactory时，还需要另外引入两个包（详见上述“所需jar”部分）。
5. filter与拦截器
● MyFilter.java

01	package test.service;

03	import java.io.IOException;

05	import javax.servlet.Filter;

06	import javax.servlet.FilterChain;

07	import javax.servlet.FilterConfig;

08	import javax.servlet.ServletException;

09	import javax.servlet.ServletRequest;

10	import javax.servlet.ServletResponse;

12	public class MyFilter implements Filter {

14	private String encoding;

@Override

17	public void destroy() {

@Override

22	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

23	request.setCharacterEncoding(encoding);

24	response.setCharacterEncoding(encoding);

25	chain.doFilter(request, response);

@Override

29	public void init(FilterConfig config) throws ServletException {

30	System.out.println( "========" + config.getInitParameter( "encoding" ) + "========" );

31	encoding = config.getInitParameter( "encoding" );

● MyInterceptor.java

01	package test.service;

03	import java.util.Map;

05	import com.opensymphony.xwork2.ActionInvocation;

06	import com.opensymphony.xwork2.interceptor.Interceptor;

08	@SuppressWarnings ( "serial" )

09	public class MyInterceptor implements Interceptor{

@Override

12	public void destroy() {

@Override

17	public void init() {

@Override

22	public String intercept(ActionInvocation invocation) throws Exception {

23	Map sessionMap = invocation.getInvocationContext().getSession();

24	String username = (String)sessionMap.get( "username" );

26	if (username != null ) {

27	return invocation.invoke();

29	return "error" ;

filter与拦截器（interceptor）的区别：
二者不论从结构还是功能都非常相似，但是二者是有区别的,：
① filter是基于servlet容器的，而interceptor仅限于struts2，因此filter的作用域要远大于interceptor。
② filter中doFilter方法是基于回调函数，而interceptor中intercept方法则是基于java反射。
③ filter的功能要远大于interceptor，filter除了过滤请求外通过通配符可以保护页面，图片，文件，还可以进行加密、安全过滤、权限管理等等，而Interceptor基本只能过滤请求。
④ filter拦截请求的粒度较粗，interceptor拦截请求的粒度较细。
6. action层
● LoginAction.java

01	package test.action;

03	import javax.annotation.Resource;

04	import javax.servlet.http.HttpServletRequest;

06	import org.apache.struts2.ServletActionContext;

08	import test.entity.User;

09	import test.service.IUserService;

11	import com.opensymphony.xwork2.ActionSupport;

13	@SuppressWarnings ( "serial" )

14	public class LoginAction extends ActionSupport {

@Resource

17	private IUserService userService;

19	private String username;

21	private String password;

23	public String getUsername() {

24	return username;

27	public void setUsername(String username) {

28	this .username = username;

31	public String getPassword() {

32	return password;

35	public void setPassword(String password) {

36	this .password = password;

@Override

40	public String execute() throws Exception {

41	User user = new User();

42	user.setUsername(username);

43	user.setPassword(password);

try

45	userService.addUser(user);

46	HttpServletRequest request = ServletActionContext.getRequest();

47	request.getSession().setAttribute( "username" , username);

48	return "success" ;

49	} catch (Exception e) {

50	e.printStackTrace();

52	return "error" ;

7. service层
● UserServiceImpl.java

01	package test.service;

03	import java.util.List;

05	import javax.annotation.Resource;

07	import test.dao.IUserDao;

08	import test.entity.User;

10	public class UserServiceImpl implements IUserService{

@Resource

13	private IUserDao userDao;

@Override

16	public void addUser(User user) throws Exception {

17	userDao.addUser(user);

18	if (! "admin" .equals(user.getUsername()) \|\| ! "admin" .equals(user.getPassword())) {

19	throw new Exception();

@Override

24	public boolean updateUser(User user) {

25	return false ;

@Override

29	public boolean delUser(String username) {

30	return false ;

@Override

34	public List<User> findAllUser() {

35	return null ;

接口因为很简单，就不展示了，这里我将filter和拦截器也放到了service层，仅是个示例而已，filter或interceptor最好单独放在一层。
8. dao层
● UserDaoImpl.java

01	package test.dao;

03	import java.util.Date;

05	import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

07	import test.entity.User;

09	public class UserDaoImpl extends HibernateDaoSupport implements IUserDao{

@Override

12	public void addUser(User user){

13	user.setName( "wang" );

14	user.setCreateTime( new Date());

15	user.setModifyTime( new Date());

16	this .getHibernateTemplate().save(user);

9. entity层

01	package test.entity;

03	import java.util.Date;

05	public class User {

07	private String username;

09	private String password;

11	private String name;

13	private String email;

15	private String tell;

17	private Date createTime;

19	private Date modifyTime;

21	public String getUsername() {

22	return username;

25	public void setUsername(String username) {

26	this .username = username;

29	public String getPassword() {

30	return password;

33	public void setPassword(String password) {

34	this .password = password;

37	public String getName() {

38	return name;

41	public void setName(String name) {

42	this .name = name;

45	public String getEmail() {

46	return email;

49	public void setEmail(String email) {

50	this .email = email;

53	public String getTell() {

54	return tell;

57	public void setTell(String tell) {

58	this .tell = tell;

61	public Date getCreateTime() {

62	return createTime;

65	public void setCreateTime(Date createTime) {

66	this .createTime = createTime;

69	public Date getModifyTime() {

70	return modifyTime;

73	public void setModifyTime(Date modifyTime) {

74	this .modifyTime = modifyTime;

这里其实提到用到了很多的知识点，需要学习和深入的地方很多，希望通过本篇的引领的为大家打开一扇窗户。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航