spring4+strust2+hibernate4 环境开发搭建

spring4+strust2+hibernate4 环境开发搭建

    用惯了springmvc,对于ssh这个框架有点以往,今天搭建以下,回顾,现在的说strust2,已经有了很大的改变,通过convention-plugin 可以用来实现 struts2 的零配置。
下面就开始这侧的配置,我们要注意一下的是,spring版本和web版本的兼容性,spring4需要的是web3.0环境和jdk1.8版本,如果不这样配置的话,环境启动报错我们都不知道.

    对于ssh这个框架,下面贴出几个最重要的,源码还请大家下载.

   另外,拦截器已经加入,但是我一直处理不好一个问题,全局异常处理,在本源码中,异常处理后能抓到异常,但是不会条向指定页面,还请各位有明白的能指正出来,共同进步.

    下载源码链接地址: http://download.csdn.net/detail/u014201191/9208027

ssh环境搭建

首先我们先来看一下web.xml和pom.xml文件,再次做一个记录

<?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"
	id="WebApp_ID" version="2.5">

	<display-name>spring_struts2_Hibernate_demo</display-name>

	<!-- spring 和  Hibernate的配置文件 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
		     classpath:spring.xml
		     classpath:spring-hibernate.xml
	    </param-value>
	</context-param>

	<!-- 编码设置 -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>utf-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	<!-- openSessionInView配置 作用是延迟session关闭到view层 -->
	<filter>
		<filter-name>openSessionInViewFilter</filter-name>
		<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
		<init-param>
			<param-name>singleSession</param-name>
			<param-value>true</param-value>
		</init-param>
	</filter>
	
	<filter-mapping>
		<filter-name>openSessionInViewFilter</filter-name>
		<url-pattern>*.action</url-pattern>
	</filter-mapping>
	

	<!-- 监听servletContext，启动contextConfigLocation中的spring配置信息 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- 防止spring内存溢出监听器 -->
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>

	<!-- Struts2 filter -->
	
	<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>*.action</url-pattern>
	</filter-mapping>


	<!-- 配置session超时时间，单位分钟 -->
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>

	<welcome-file-list>
		<welcome-file>/index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.andy.ssh</groupId>
	<artifactId>spring_struts2_Hibernate_demo</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<name>spring_struts2_Hibernate_demo Maven Webapp</name>
	<url>http://maven.apache.org</url>


	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>4.1.4.RELEASE</spring.version>
		<hibernate.version>4.3.8.Final</hibernate.version>
		<struts2.version>2.3.20</struts2.version>
		<jackson.version>2.5.0</jackson.version>
	</properties>

	<dependencies>

		<!-- junit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
			<scope>provided</scope>
		</dependency>

		<!-- 关系型数据库整合时需配置 如hibernate jpa等 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-ehcache</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<!-- struts2 -->
		<dependency>
			<groupId>org.apache.struts</groupId>
			<artifactId>struts2-core</artifactId>
			<version>${struts2.version}</version>

			<exclusions>
				<exclusion>
					<!-- Hibernate已经还有该包的依赖 -->
					<artifactId>javassist</artifactId>
					<groupId>javassist</groupId>
				</exclusion>
			</exclusions>
		</dependency>

		<dependency>
			<groupId>org.apache.struts</groupId>
			<artifactId>struts2-spring-plugin</artifactId>
			<version>${struts2.version}</version>
		</dependency>

		<dependency>
			<groupId>org.apache.struts</groupId>
			<artifactId>struts2-convention-plugin</artifactId>
			<version>${struts2.version}</version>
		</dependency>

		<!-- log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!-- mysql连接 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.34</version>
		</dependency>

		<!-- 数据源 druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>1.0.12</version>
		</dependency>

		<!-- json -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.3</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>${jackson.version}</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-core</artifactId>
			<version>${jackson.version}</version>
		</dependency>

		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.version}</version>
		</dependency>

		<!-- aop -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.8.4</version>
		</dependency>

		<!-- servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>3.0-alpha-1</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>

	</dependencies>

	<build>
		<finalName>spring_struts2_Hibernate_demo</finalName>

		<plugins>
			<!-- Run the JUnit unit tests in an isolated classloader -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<version>2.4.2</version>
				<configuration>
					<skipTests>true</skipTests>
				</configuration>

			</plugin>

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>2.3</version>
				<configuration>
					<webXml>src/main/webapp/WEB-INF/web.xml</webXml>
				</configuration>
			</plugin>

			<!-- generate java doc -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-javadoc-plugin</artifactId>
				<version>2.9.1</version>
				<configuration>
					<javadocDirectory>target/javadoc</javadocDirectory>
					<reportOutputDirectory>target/javadoc</reportOutputDirectory>
					<charset>UTF-8</charset>
					<encoding>UTF-8</encoding>
					<docencoding>UTF-8</docencoding>
					<show>private</show>
				</configuration>
			</plugin>

			<!-- 部署至本机 -->
			<plugin>
				<groupId>org.codehaus.cargo</groupId>
				<artifactId>cargo-maven2-plugin</artifactId>
				<version>1.0</version>
				<configuration>
					<container>
						<containerId>tomcat6x</containerId>
						<home>F:\apache-tomcat-7.0.27</home>
					</container>
					<configuration>
						<type>existing</type>
						<home>F:\apache-tomcat-7.0.27</home>
					</configuration>
				</configuration>
			</plugin>
		</plugins>

	</build>
</project>

这两个对于我们环境来说是最重要的,包括下载jar和环境初始化

下面我们给出spring和strust2的xml配置文件

spring.xml和spring-hibernate.xml以及strust.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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
			http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
			http://www.springframework.org/schema/context
			http://www.springframework.org/schema/context/spring-context-4.1.xsd">
	<!-- 加载配置文件 -->
	
	<context:property-placeholder location="classpath:config.properties"/>
	<!-- 扫描service自动注入为bean -->
	<context:component-scan base-package="org.andy.shop.service.impl,org.andy.shop.dao.impl" />

</beans>

<?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:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans-4.1.xsd 
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-4.1.xsd
		http://www.springframework.org/schema/aop 
		http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">

	<!-- 配置数据源 使用的是Druid数据源 -->
	<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close">
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />

		<!-- 初始化连接大小 -->
		<property name="initialSize" value="0" />
		<!-- 连接池最大使用连接数量 -->
		<property name="maxActive" value="20" />
		
		<!-- 连接池最小空闲 -->
		<property name="minIdle" value="0" />
		<!-- 获取连接最大等待时间 -->
		<property name="maxWait" value="60000" />
		<property name="poolPreparedStatements" value="true" />
		<property name="maxPoolPreparedStatementPerConnectionSize"
			value="33" />
		<!-- 用来检测有效sql -->
		<property name="validationQuery" value="${validationQuery}" />
		<property name="testOnBorrow" value="false" />
		<property name="testOnReturn" value="false" />
		<property name="testWhileIdle" value="true" />
		<!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
		<property name="timeBetweenEvictionRunsMillis" value="60000" />
		<!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
		<property name="minEvictableIdleTimeMillis" value="25200000" />
		<!-- 打开removeAbandoned功能 -->
		<property name="removeAbandoned" value="true" />
		<!-- 1800秒，也就是30分钟 -->
		<property name="removeAbandonedTimeout" value="1800" />
		<!-- 关闭abanded连接时输出错误日志 -->
		<property name="logAbandoned" value="true" />
		<!-- 监控数据库 -->
		<property name="filters" value="mergeStat" />
	</bean>

	<!-- 配置hibernate的SessionFactory -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<!-- 注入数据源 相关信息看源码 -->
		<property name="dataSource" ref="dataSource" />
		<!-- hibernate配置信息 -->
		<property name="hibernateProperties">
			<props>
				<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>
				<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
			</props>
		</property>
		<!-- 扫描hibernate注解配置的entity -->
		<property name="packagesToScan" value="org.andy.shop.entity" />
	</bean>

	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- 配置事务增强处理Bean，指定事务管理器 -->
	<tx:advice id="transactionAdvice" transaction-manager="transactionManager">
		<!-- 配置详细事务处理语义 -->
		<tx:attributes>
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />

			<tx:method name="get*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="find*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="select*" propagation="SUPPORTS" read-only="true" />
			<tx:method name="load*" propagation="SUPPORTS" read-only="true" />

			<!-- 其他采用默认事务方式 -->
			<tx:method name="*" />

		</tx:attributes>
	</tx:advice>

	<!-- Spring aop事务管理 -->
	<aop:config>
		<!-- 配置切入点 -->
		<aop:pointcut id="transactionPointcut"
			expression="execution(* org.andy.shop.service.impl.*Impl.*(..))" />
		<!-- 指定在txAdvice切入点应用txAdvice事务增强处理 -->
		<aop:advisor pointcut-ref="transactionPointcut"
			advice-ref="transactionAdvice" />
	</aop:config>

</beans>

<?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>
	<!-- 指定由spring负责action对象的创建 -->
	<constant name="struts.objectFactory" value="spring" />
	<!-- 所有匹配*.action的请求都由struts2处理 -->
	<constant name="struts.action.extension" value="action,do" />
	<!-- 是否启用开发模式 -->
	<constant name="struts.devMode" value="true" />
	<!-- struts配置文件改动后，是aa否重新加载 -->
	<constant name="struts.configuration.xml.reload" value="true" />
	<!-- 设置浏览器是否缓存静态内容 -->
	<constant name="struts.serve.static.browserCache" value="false" />
	<!-- 请求参数的编码方式 -->
	<constant name="struts.i18n.encoding" value="utf-8" />
	<!-- 每次HTTP请求系统都重新加载资源文件，有助于开发 -->
	<constant name="struts.i18n.reload" value="true" />
	<!-- 文件上传最大值 -->
	<constant name="struts.multipart.maxSize" value="104857600" />
	<!-- 让struts2支持动态方法调用 -->
	<constant name="struts.enable.DynamicMethodInvocation" value="true" />
	<!-- Action名称中是否还是用斜线 -->
	<constant name="struts.enable.SlashesInActionNames" value="false" />
	<!-- 允许标签中使用表达式语法 -->
	<constant name="struts.tag.altSyntax" value="true" />
	<!-- 对于WebLogic,Orion,OC4J此属性应该设置成true -->
	<constant name="struts.dispatcher.parametersWorkaround" value="false" />

	<constant name="struts.convention.result.path" value="/WEB-INF/content/" />

	<!-- 注解方式的请求strust2 -->
	<!-- 定义一个拦截器,并使用 -->
	<package name="custom-default" extends="struts-default">
		<!-- 定义一个拦截器 -->
		<interceptors>
			<interceptor name="authority"
				class="org.andy.shop.intercptor.AuthInterceptor">
			</interceptor>
			<!-- 拦截器栈 -->
			<interceptor-stack name="mydefault">
				<interceptor-ref name="authority" />
				<interceptor-ref name="defaultStack" />
			</interceptor-stack>
		</interceptors>
		<!-- 下面的这种配置,只要继承了这个package,那么该action的所有请求都将会进入拦截器 -->
		<!-- <default-interceptor-ref name="mydefault"></default-interceptor-ref> -->

        <!-- 下面的全局异常处理没有效果 -->
		<global-results>
			<result name="exception">/WEB-INF/content/error/exception.jsp</result>
		</global-results>
		<global-exception-mappings>
			<exception-mapping exception="java.lang.NumberFormatException"
				result="exception" />
		</global-exception-mappings>
	</package>
	
	
    <!-- xml方式的请求strust2 -->
	<package name="myself-default" extends="struts-default" namespace="/login">
		<action name="loginAction_*" class="org.andy.shop.action.LoginAction" method="{1}">
			<result name="view">/WEB-INF/content/login/index.jsp</result>
		</action>
	</package>
	
</struts>

本次项目中的拦截器配置还有待完善,写好后,我会第一时间更新.

下面我们来看一下最基本的两个个action,前者是注解方式,后者是xml方式

package org.andy.shop.action;

import java.util.List;

import org.andy.shop.entity.UserInfo;
import org.andy.shop.service.UserInfoService;
import org.andy.shop.utils.AjaxUtil;
import org.apache.log4j.Logger;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.ExceptionMapping;
import org.apache.struts2.convention.annotation.ExceptionMappings;
import org.apache.struts2.convention.annotation.InterceptorRef;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.ResultPath;
import org.springframework.beans.factory.annotation.Autowired;

import com.opensymphony.xwork2.ActionSupport;


/**
 * @ParentPackage : 对应于 struts.xml 常量配置项的 <constant name="struts.convention.default.parent.package" value="xx"/> 默认值是 convention-default,
 * 拦截器就是在xml中配置好以后才会在这里引用的
 */
@ParentPackage(value="custom-default") 

/**
 * @Namespace 一旦配置,将会在我们配置的根目录(默认为content,也可用@ResultPath来配置)下,找 'user/' 目录下的jsp
 */
@Namespace("/user") 

/**
 * @ResultPath : 对应于 struts.xml 常量配置项的 <constant name="struts.convention.result.path" value="xx" /> 默认值是 /WEB-INF/content/
 */
@ResultPath(value="/WEB-INF/content/")

/**
 * 引入拦截器,要预先在xml中配置好
 */
@InterceptorRef(value="mydefault") 

/**
 * 全局返回
 */
@Result(name = "error_exception",location = "result_false.jsp")
public class UserinfoAction extends ActionSupport  {
    
	private static final long serialVersionUID = -2301203156032690317L;

	private static final Logger LOGGER = Logger.getLogger(UserinfoAction.class);
	private Integer id;
	private UserInfo userInfo;
	private List<UserInfo> userInfos;

	@Autowired
	private UserInfoService userInfoService;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public UserInfo getUserInfo() {
		return userInfo;
	}

	public void setUserInfo(UserInfo userInfo) {
		this.userInfo = userInfo;
	}

	public List<UserInfo> getUserInfos() {
		return userInfos;
	}

	public void setUserInfos(List<UserInfo> userInfos) {
		this.userInfos = userInfos;
	}

	public UserInfo getModel() {
		if (null != id) {
			userInfo = userInfoService.get(id);
		} else {
			userInfo = new UserInfo();
		}
		return userInfo;
	}

	/**
	 * 请求链接:http://localhost:8080/spring_struts2_Hibernate_demo/user/userinfo.action
	 */
	@Override
	public String execute() throws Exception {
		LOGGER.info("查询所有用户");
		userInfos = userInfoService.findAll();
		/**如果是SUCCESS,那么就是说,返回的view视图为:action的名字,userinfo+jsp*/
		return SUCCESS;
		
	}

	/**
     * 请求链接:http://localhost:8080/spring_struts2_Hibernate_demo/user/userinfo!detail.action?id=1
     */
	public void detail() {
		String id = ServletActionContext.getRequest().getParameter("id");
		LOGGER.info("查看用户详情：" + id);
		userInfo = userInfoService.get(Integer.valueOf(id));
		AjaxUtil.ajaxJSONResponse(userInfo);

	}

	/**
	 * 请求链接为:http://localhost:8080/spring_struts2_Hibernate_demo/user/doIt.action
	* @author 高国藩
	* @date 2015年10月23日 下午5:28:34
	* @return
	* @throws Exception
	 */
    @Action(value = "doIt", 
	         results = {
	             @Result(name = "isTrue", location = "result_true.jsp"),
	             @Result(name = "isFalse", location = "result_false.jsp")
	         }
	     )
	public String doIt() throws NumberFormatException {
		LOGGER.info("view action has been call ...");
		return "isTrue";
	}
    
}

package org.andy.shop.action;

import org.apache.log4j.Logger;

public class LoginAction {

    private static final Logger LOGGER = Logger.getLogger(LoginAction.class);

    /**
     * 下面方法为xml方式进行请求struts,不适用注解方式
     * 请求方式:http://localhost:8080/spring_struts2_Hibernate_demo/login/loginAction_viewAction.action
    * @author 高国藩
    * @date 2015年10月23日 下午8:59:20
    * @return
     */
    public String viewAction() {
        LOGGER.info("viewAction | 通配符请求方法");
        Integer.parseInt("throw one exception ....");
        return "view";
    }
}

其中最基本的配置要看下面,有很多默认的配置.

注意 默认 请求action的方式和返回view的方式,action请求舍去了Action,而view则会配置根目录,success的返回结果则会返回action的默认名称+jsp的形式,例如UserAction,请求则会是user.action,而view则是web-inf/content/user.jsp.但这些配置都可以在convention这个插件中配置,详细都在下面看strust2的常量配置.

struts2注解convention插件

struts.xml

< struts >

   < constant  name ="struts.devMode"  value ="true" />                                                                       <!--  开发模式  -->
   < constant  name ="struts.i18n.encoding"  value ="UTF-8" />                                                         <!--  Web运用编码  -->
   < constant  name ="struts.convention.result.path"  value ="/view/"   />                                    <!--  搜索视图资源的路径  -->
   < constant  name ="struts.convention.action.name.separator"  value ="_"   />                       <!--  Action类名分隔符  -->
   < constant  name ="struts.convention.classes.reload"  value ="true"   />                                   <!--  convention类重加载  -->
   < constant  name ="struts.convention.action.suffix"  value ="Action"   />                                 <!--  Action后缀名  -->
   < constant  name ="struts.action.extension"  value ="action,do,html,htm,php,aspx"   />   <!--  Action扩展名  -->
   < constant  name ="struts.convention.package.locators"  value ="action,actions"   />         <!--  搜索Action资源的包路径  -->
  
</ struts >

convention 几项重要配置 :

Action 类后缀名 : <constant name="struts.convention.action.suffix" value="Action" />

继承了 struts2 的 ActionSupport 类的类不是一个普通的类，它具有能够处理请求和对请求作出响应的能力，

通常，开发者常常为这种特殊的类起一个后缀名，以区分一般普通的类。例如，xxAction，xxController，

这里的类名的后缀 Action，Controller 就是对应上面配置中的 value 的值，这个值会在发起 URL 请求的时候被截去。例如 : TestAction ---> test

Action类扩展名 [多项以逗号隔开]  :   <constant name="struts.action.extension" value="action,do,html,htm,php,aspx" />

与文件的扩展名相似的，例如 : TestAction ---> test.action 或 test.do 或 test.html 或 test.php 或 test.aspx 或 ...

注意 : 若该项被配置，则，访问所有的 Action 都需带上 Action 的扩展名，否则客户端将抛出 404 ERROR

Action类名分隔符 : <constant name="struts.convention.action.name.separator" value="_" />

若 Action 类名中出现驼峰标识的串，则用分隔符来切割串，如 HelloWorldAction ---> hello_world

搜索 Action 资源的包路径 [多项以逗号隔开] : <constant name="struts.convention.package.locators" value="action,actions" />

只有当包名含有以上配置中 value 值中至少一项时，convention plugin 才能搜索找得到该 Action，

否则就算访问的 Action 是存在的，convention plugin 也无法找得到该 Action

注意 : 若包名不是以上列出现过的串结束，则后面的串相当于该包下所有 Action 访问的命名空间 ( 以下面的 LoginAction 作为示例 )。

搜索视图资源(JSP,freemarker,等)的路径 : <constant name="struts.convention.result.path" value="/view/" />

所有的视图资源都需放在配置指定的文件夹路径下，否则，就算结果视图是真实存在的，convention plugin 也无法找得到该视图。默认值是 /WEB-INF/content/

convention 约定 :

1. [ Action 不存在的情况 ] 若 convention plugin 在包搜索路径中搜索不到与请求的 URL 相匹配的 Action，则会到视图的搜索路径下搜索

与请求的 URL 相匹配的视图资源，若还搜索不到，则抛出 no Action mapped Exception 

示例 : 

view/hello_world.jsp [ 没有与之匹配的 Action 类 ]

< html >
  < body >
   < h2 > Hello World!! </ h2 >
  </ body >
</ html >

2. [ Action 的 execute 方法或动态方法调用的情况 ] 如请求 name!method.action，若 NameAction 存在，且 NameAction 中存在 method 这样一个方法，

则根据 method 方法返回的字符串，结果的视图资源名称规则 ( 视图以 JSP 文件为例 ) :

① success  ----->  name.jsp 或 name_success.jsp ; 若这两个视图同时存在，则 convention plugin 会选择 name_success.jsp 作为视图来展示

② 非 success 的任意串 string  ----->  name_string.jsp

示例 : 

package  net.yeah.fancydeepin.action;

import  com.opensymphony.xwork2.ActionSupport;
/**
 * -----------------------------------------
 * @描述  TODO
 * @作者  fancy
 * @邮箱  fancydeepin@yeah.net
 * @日期  2012-10-26 <BR>
 * -----------------------------------------
  */
public   class  SayHelloAction  extends  ActionSupport{

     private   static   final   long  serialVersionUID  =   1L ;

     private  String message;
    
     public  String execute(){
        
        message  =   " Hello struts2 convention plugin! " ;
         return  SUCCESS;
    }
    
     public  String say(){
        
        message  =   " SayHelloAction, say " ;
         return   " world " ;
    }
    
     public  String sayHello(){
        
        message  =   " SayHelloAction, sayHello " ;
         return   " conventionPlugin " ;
    }

     public  String getMessage() {
         return  message;
    }
    
}

view/say_hello.jsp

< html >
  < body >
   < h2 > say_hello.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

view/say_hello_world.jsp

< html >
  < body >
   < h2 > say_hello_world.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

view/say_hello_conventionPlugin.jsp

< html >
  < body >
   < h2 > say_hello_conventionPlugin.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

convention 注解 :

@ParentPackage  : 对应于 struts.xml 常量配置项的  < constant  name ="struts.convention.default.parent.package"  value ="xx" />   默认值是 convention-default

@ResultPath  : 对应于 struts.xml 常量配置项的  < constant  name ="struts.convention.result.path"  value ="xx"   />  默认值是 /WEB-INF/content/

@Namespace  : Action 访问的命名空间，该注解一旦声明，结果的视图资源需放在 : 视图搜索目录/命名空间 ( 如 : view/simple/demo.jsp )

package  net.yeah.fancydeepin.action;

import  org.apache.struts2.convention.annotation.Namespace;
import  org.apache.struts2.convention.annotation.ParentPackage;
import  org.apache.struts2.convention.annotation.ResultPath;
import  com.opensymphony.xwork2.ActionSupport;
/**
 * -----------------------------------------
 * @描述  TODO
 * @作者  fancy
 * @邮箱  fancydeepin@yeah.net
 * @日期  2012-10-26 <BR>
 * -----------------------------------------
  */
@ParentPackage( " convention-default " )
@Namespace( " /simple " )
@ResultPath( " /view/ " )
public   class  DemoAction  extends  ActionSupport{

     private   static   final   long  serialVersionUID  =   1L ;
     private  String message;
    
     public  String execute(){
        
        message  =   " DemoAction " ;
         return  SUCCESS;
    }

     public  String getMessage() {
         return  message;
    }
}

view/simple/demo.jsp

< html >
  < body >
   < h2 > demo.jsp  &rarr;  Hello World ${message}! </ h2 >
  </ body >
</ html >

@Action

package  net.yeah.fancydeepin.action;

import  org.apache.struts2.convention.annotation.Action;
import  com.opensymphony.xwork2.ActionSupport;
/**
 * -----------------------------------------
 * @描述  TODO
 * @作者  fancy
 * @邮箱  fancydeepin@yeah.net
 * @日期  2012-10-26 <BR>
 * -----------------------------------------
  */
public   class  ActionannotationAction  extends  ActionSupport{

     private   static   final   long  serialVersionUID  =   1L ;
     private  String message;
    
    @Action( " invoke " )
     public  String invokeMethod(){
        
        message  =   " ActionannotationAction, invokeMethod " ;
         return  SUCCESS;
    }

     public  String getMessage() {
         return  message;
    }
}

view/invoke.jsp

< html >
  < body >
   < h2 > invoke.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

@Result，@Results

package  net.yeah.fancydeepin.action;

import  java.util.Random;
import  org.apache.struts2.convention.annotation.Action;
import  org.apache.struts2.convention.annotation.Result;
import  org.apache.struts2.convention.annotation.Results;
import  com.opensymphony.xwork2.ActionSupport;
/**
 * -----------------------------------------
 * @描述  TODO
 * @作者  fancy
 * @邮箱  fancydeepin@yeah.net
 * @日期  2012-10-26 <BR>
 * -----------------------------------------
  */
@Results({@Result(name  =   " success " , location  =   " result.jsp " )})
public   class  ResultAction  extends  ActionSupport{

     private   static   final   long  serialVersionUID  =   1L ;
     private  String message;
    
     public  String execute(){
        
        message  =   " ResultAction, execute " ;
         return  SUCCESS;
    }
    
    @Action(value  =   " doIt " , 
        results  =  {
            @Result(name  =   " isTrue " , location  =   " result_true.jsp " ),
            @Result(name  =   " isFalse " , location  =   " result_false.jsp " )
        }
    )
     public  String doExecute(){

        message  =   " doExecute isFalse. " ;
         if ( new  Random().nextBoolean()){
            message  =   " doExecute isTrue. " ;
             return   " isTrue " ;
        }
         return   " isFalse " ;
    }

     public  String getMessage() {
         return  message;
    }
}

view/result.jsp

< html >
  < body >
   < h2 > result.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

view/result_true.jsp

< html >
  < body >
   < h2 > result_true.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

view/result_false.jsp

< html >
  < body >
   < h2 > result_false.jsp  &rarr;  Message : ${message} </ h2 >
  </ body >
</ html >

The last example

package  net.yeah.fancydeepin.action.admin;

import  com.opensymphony.xwork2.ActionSupport;
/**
 * -----------------------------------------
 * @描述  TODO
 * @作者  fancy
 * @邮箱  fancydeepin@yeah.net
 * @日期  2012-10-26 <BR>
 * -----------------------------------------
  */
public   class  LoginAction  extends  ActionSupport{

     private   static   final   long  serialVersionUID  =   1L ;
     private  String username;
     private  String password;

     public  String log(){
        
        username  =  username.intern();
        password  =  password.intern();
         if (username  ==   " admin "   &&  password  ==   " fancy " ){
             return  SUCCESS;
        }
         return  ERROR;
    }

     public   void  setUsername(String username) {
         this .username  =  username;
    }

     public   void  setPassword(String password) {
         this .password  =  password;
    }
}

view/admin/login_success.jsp

< html >
  < body >
   < h2 > Welcome!! </ h2 >
  </ body >
</ html >

view/admin/login_error.jsp

< html >
  < body >
   < h2 > Login Failed!! </ h2 >
  </ body >
</ html >

全局异常处理方式

<global-results>定义全局结果处理
一般发生异常之后 结果返回errHandler
因为errHandler是由<global-exception-mappings>关联到Exception这个类了
然后处理结果
<result name="errHandler" type="chain">
然后它就根据
<param name="actionName">errorProcessor</param>
找action
<action name="errorProcessor" class="cn.itcast.sh.error.ErrorProcess">
<result>/error.jsp</result>
</action>
处理了 然后 返回到 error.jsp

注解方式

package com.xiaoji.ssh.action;

import javax.annotation.PostConstruct;

import org.apache.log4j.Logger;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.ExceptionMapping;
import org.apache.struts2.convention.annotation.ExceptionMappings;
import org.apache.struts2.convention.annotation.Namespace;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;

import com.opensymphony.xwork2.ActionSupport;

@Namespace("/book") 
@Results( { @Result(name = "success", location = "/views/main.jsp"), 
        @Result(name = "error", location = "/views/error.jsp") }) 
@ExceptionMappings( { @ExceptionMapping(exception = "java.lang.Exception", result = "error") }) 
public class BookAction extends ActionSupport{
    /** @Fields serialVersionUID : */
    private static final long serialVersionUID = 1L;
    private Logger logger = Logger.getLogger(BookAction.class);
    private String username;
    
    public String getUsername() {
        return username;
    }


    public void setUsername(String username) {
        this.username = username;
    }
    
    @Action(value="test")
    public String test() throws Exception{
        logger.info("抛出异常处理");
        Integer.parseInt("error");
        this.setUsername("strutsTest");
        return SUCCESS;
    }
    
}

在这样的配置下,如果跑出了异常,就会跳转到error这个result中,在项目跟路径下,/views/error.jsp,同样可以传递参数,将错误信息输出

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.devMode" value="true" />
    <constant name="struts.enable.DynamicMethodInvocation" value="false"></constant>
    <!-- <constant name="struts.custom.i18n.resources" value="itcast"></constant> -->
    <package name="struts-global" namespace="/" extends="struts-default">
        <global-results>
            <result name="errHandler" type="chain">
                <param name="actionName">errorProcessor</param>
            </result>
        </global-results>
        <global-exception-mappings>
            <exception-mapping result="errHandler" exception="java.lang.Exception">
            </exception-mapping>
        </global-exception-mappings>
        
        <action name="errorProcessor" class="cn.itcast.sh.error.ErrorProcess">
            <result>/error.jsp</result>
        </action>
    </package>

package cn.itcast.sh.error;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

public class ErrorProcess extends ActionSupport {
    private Exception exception;

    public Exception getException() {
        return exception;
    }

    public void setException(Exception exception) {
        this.exception = exception;
    }
    @Override
    public String execute()
    {
        ActionContext.getContext().getValueStack().push(this.exception.getMessage());　　　　　　//放到值栈顶
        return this.SUCCESS;
    }
}

<?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="user" namespace="/" extends="struts-global">
        <action name="UserAction_*" method="{1}" class="cn.itcast.sh.action.UserAction">
            <result name="userList">/user/list.jsp</result>
        </action>
    </package>
</struts>

然后 如果页面异常 都会转向 error.jsp中 显示,error.jsp可以进行错误显示,因为信息被放到栈顶了 所以可以取到,<s:property />