更多详情请参见：我的博客 我的生活

说明：具体案例的分析，详细的分析在讲解的过程中再阐述（这份案例大约在04年已经完成，所以现在看起来难免有些不符合时代潮流，领会精神即可）

概要

主要针对表department操作，创建、更新、删除、选择

层次结构说明

共分为四层:mid、midimpl、application、presentation

一般开发基于MVC结构的应用来说，层次的划分是很重要的，三层结构、于至于多层结构的演变有其一定的道理。MVC本身就是模型、视图、控制的层次划分，这样有助于职能的明确，加快开发效率，最重要的是系统的把握度和可扩展的能力。

当然这里的四层划分，不是绝对的，根据不同的项目可以有不同的调整，只是作为一个参考，这是一个实际项目中保留下来的，有其一定的科学性。

mid：接口和抽象类部分，是相对系统底层的功能的集中体现，相对共通性部分

midimpl：是对mid层的具体现实

application：具体业务逻辑、模型

presentation：表述层，struts的具体实现部分

具体为何如此划分层次，会具体讲解，也请大家考虑一下。

下面具体讲解StrutsSample的各个组成

类

mid

DAOFactory：是采用了工厂模式来实现的，其间又有DAO模式。

功能：得到DAOFactoryImpl（DAOFactory的具体实现）实例，并提供了两个abstract

方法，在DAOFactoryImpl必须得以实现。

DepartmentDAO：操作表department的接口，定义了一些对表的基本操作

midimpl

DAOFactoryImpl: DAOFactory的具体实现，在DAOFactory中的两个abstract方法也得以实

现：init（）方法，取得数据源。getDepartmentDAO（）方法，得到接口DepartmentDAO的具体实例DepartmentDAOImpl。除了要必须实现的方法外，还定义了getConnection（）方法，以取得对数据源的连接。

DepartmentDAOImpl：接口DepartmentDAO的具体实现，表的操作具体实现。

application

Department：定义了一个数据bean，可以对照数据表department，发现是对应它的一个对

象的实现。

DepartmentBO：定义了这个应用程序中所需要的业务逻辑，比如selectDepartment（String depid）方法，根据一个部门的ID来获得该部门的详细数据、createDepartment（）、updateDepartment（）、 deleteDepartment（）分别对应创建、更新、删除

presentation

DepartmentForm:Form Bean表单，收集JSP页面上的元素。可以发现它和application层的Department类是类似的，因为Form表单所收集的数据真好是对 应数据库中的字段的。（这只是个比较特殊的例子而已，开发中不一定都是这样的，这里同时引申出一个问题，居然两个类是类似的，为什么不合并一下，就用其中 的一个类的，这样不是还可以节省一个类吗？）

CreateDepartmentAction：创建部门的Action类

DeleteDepartmentAction：删除部门的Action类

ListDepartmentAction：所有部门的一个列表

SelectDepartmentAction：选择一个部门

UpdateDepartmentAction：更新部门的Action类

资源文件

ApplicationResources.properties

JSP

index.jsp

Create

–register.jsp

–success.jsp

–failure.jsp

list

–departmentList.jsp

–failure.jsp

update

–update.jsp

–failure.jsp

struts-config.xml

<?xml version=”1.0″ encoding=”ISO-8859-1″ ?>

<!DOCTYPE struts-config PUBLIC

“-//Apache Software Foundation//DTD Struts Configuration 1.1//EN”

“http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd”>

<struts-config>

<!– ========== Form Bean Definitions =================================== –>

<form-beans>

<!– Logon form bean –>

<form-bean   name=”departmentForm”

type=”cn.haose.struts.presentation.DepartmentForm”>

</form-bean>

</form-beans>

<!– ========== Action Mapping Definitions ============================== –>

<action-mappings>

<action  path=”/create”

type=”cn.haose.struts.presentation.CreateDepartmentAction”

name=”departmentForm”

scope=”request”

input=”/create/register.jsp”>

<forward name=”success”   path=”/create/success.jsp”/>

<forward name=”failure”   path=”/create/failure.jsp”/>

</action>

<action  path=”/list”

type=”cn.haose.struts.presentation.ListDepartmentAction”

>

<forward name=”success”   path=”/list/departmentList.jsp”/>

<forward name=”failure”   path=”/list/failure.jsp”/>

</action>

<action  path=”/select”

type=”cn.haose.struts.presentation.SelectDepartmentAction”

>

<forward name=”success”   path=”/update/update.jsp”/>

<forward name=”failure”   path=”/update/failure.jsp”/>

</action>

<action  path=”/delete”

type=”cn.haose.struts.presentation.DeleteDepartmentAction”

>

<forward name=”success”   path=”/list.do”/>

<forward name=”failure”   path=”/update/failure.jsp”/>

</action>

<action  path=”/update”

type=”cn.haose.struts.presentation.UpdateDepartmentAction”

name=”departmentForm”

scope=”request”

input=”/update/update.jsp”>

<forward name=”success”   path=”/list.do”/>

<forward name=”failure”   path=”/update/failure.jsp”/>

</action>

</action-mappings>

<!– ========== Message Resources Definitions =========================== –>

<message-resources parameter=”ApplicationResources”/>

</struts-config>

web.xml.

<?xml version=”1.0″ encoding=”UTF-8″?>

<!DOCTYPE web-app PUBLIC “-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN” “http://java.sun.com/dtd/web-app_2_3.dtd”>

<web-app id=”WebApp”>

<display-name>sample</display-name>

<servlet>

<servlet-name>action</servlet-name>

<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

<init-param>

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

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<!– Action Servlet Mapping –>

<servlet-mapping>

<servlet-name>action</servlet-name>

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

</servlet-mapping>

<welcome-file-list>

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

</welcome-file-list>

<!– Struts Tag Library Descriptors –>

<taglib>

<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>

</taglib>

<taglib>

<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-html.tld</taglib-location>

</taglib>

<taglib>

<taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>

</taglib>

<resource-ref>

<description>DB Connection</description>

<res-ref-name>jdbc/SAMPLE</res-ref-name>

<res-type>javax.sql.DataSource</res-type>

<res-auth>Container</res-auth>

</resource-ref>

</web-app>

数据源

Tomcat 中的 server.xml

<Context path=”/sample” docBase=”sample” debug=”0″

reloadable=”true” crossContext=”true”>

<Resource name=”jdbc/SAMPLE”

auth=”Container”

type=”javax.sql.DataSource”/>

<ResourceParams name=”jdbc/SAMPLE”>

<parameter>

<name>factory</name>

<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>

</parameter>

<parameter>

<name>driverClassName</name>

<value>oracle.jdbc.OracleDriver</value>

</parameter>

<parameter>

<name>url</name>

<value>jdbc:oracle:thin:@hao-se:1521:haose</value>

</parameter>

<parameter>

<name>username</name>

<value>test1</value>

</parameter>

<parameter>

<name>password</name>

<value>test1</value>

</parameter>

<parameter>

<name>maxActive</name>

<value>10</value>

</parameter>

<parameter>

<name>maxIdle</name>

<value>1</value>

</parameter>

<parameter>

<name>maxWait</name>

<value>-1</value>

</parameter>

</ResourceParams>

</Context>

最后附上运行画面

Index.jsp

Create   register.jsp

Create   success.jsp

Create   failure.jsp

list    departmentList.jsp

list    failure.jsp

update     update.jsp

一、    为了更好的理解struts，首先讲解FrontController模式
1、    阅读并尽可能的理解FrontController.doc这份文档
2、    提问关于前一阶段有关MVC的学习情况
3、    结合MVC的学习，谈谈FrontController在这里起到什么样的作用
4、    文档中关于请求类型的通信，映射的理解
5、    文档中关于映射，只是做了一个简单的封装，如果采用映射外部化（如XML）,那么具体如何现实，请说出大体方案（不要求具体代码的实现）
6、    有关文档中提及的几个问题，你是如何理解的

二、    struts实例讲解
1、    在集成开发环境中，创建新的工程
2、    一般应用的层次结构
3、    重点说明在这个实例中接口和抽象的重要性
4、    接上一话题，mid和midimpl层的具体实现
5、    有关application的一般概念，具体在这个实例中的实现
6、    presentation层（struts的集中实现部分）的讲解
7、    有关实例中用到的资源文件的说明
8、    struts-config.xml文件的配置
9、    web.xml文件的配置
10、jsp的制作，三种常标签库的应用
11、有关数据源的一般介绍
12、如何在集成开发环境中运行这个实例（需掌握前一阶段有关IDE的学习）

三、发布实例到应用服务器中去（Tomcat）
1、    Tomcat相关基础
2、    Tomcat安装、配置
3、    web.xml
4、    server.xml
5、    如何发布一个具体的实例

更多详情请参见：我的博客 我的生活

概要：Front Controller（模式）

说明：
讲解struts具体例子之前，先说明一下Front Controller模式(前端控制器模式)。struts就是它的具体实现，得以扩展，并且是Model2结构的完整实现。

Model2结构通过一个控制组件来接受请求，这个控制组件本身可以为请求提供服务，也可以把这项任务分配给其他一些组件。生成响应信息的任务接着被分配给适当的视图组件。实现这种要求的方式很多，Front Controller就是其中一种。

实现前端控制器可以采取不同的策略，一种典型的策略是使用一个servlet
问题：如果把所有的功能集中起来会出现一个大而臃肿的控制器组件，它将负责整个Web的
相关处理。
解决：办法之一是使用多个前端控制器，分别负责某一方面的处理任务
另一种解决方案是使用Command and Controller（命令与控制器）（稍候介绍）

下面是这种Front Controller模式示例程序框架实现：
public class FrontController extends HttpServlet {
protected void processRequest(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
RequestDispatcher dispatcher =
getServletContext().getRequestDispatcher(nextView);
dispatcher.forward(req, res);
}

protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
processRequest(req, res);
}

protected void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
processRequest(req, res);
}
}

在这里，它只是HttpServlet一个简单的扩充，默认实现了doGet()和doPost()方法，这两个方法负责把请求分配给另一个叫processRequest()的方法。这是为了保证不论发出什么请求，前端控制器都能为之提供服务。
在processRequest()的方法中我们省去主要部分，但实际上前端控制器将先执行与请求关联的处理，然后再把它分配给一个视图组件来生成相关的 响应信息。视图组件一般是JSP页面。控制器完成了自己的业务逻辑之后，它就可以通过RequestDispatcher把处理分配给一个JSP。
到此你可能会提出一个问题。如果控制器要负责处理所有的请求，那么它怎么知道各请求都是什么以及如何处理呢？（Command and Controller，上面问题所提到的，现在开始讲解）

Command and Controller策略
在Command and Controller策略中，处理每个具体请求的逻辑被转移到了一个单独的组件中。

这些额外组件各表示一个具体的命令（或操作，既action），并且组件中封装着执行相关操作的逻辑。
前端控制器把对请求的处理分配给适当的命令组件。
操作类
为了实现Command and Controller策略，首先需要定义位于控制器和操作组件之间的接口。
public abstract class Action {
public abstract String process(HttpServletRequest req, HttpServletResponse res);
}

关于请求类型的通信
这里的处理如下：FrontController Servlet和URI/controller/*之间定义了一个映射
<servlet>
<servlet-name>FrontController</servlet-name>
<servlet-class>com.wxhx.controller.FrontController</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>FrontController</servlet-name>
<url-pattern>/controller/*</url-pattern>
</servlet-mapping>

为了从附加路径信息中获得的字符串映射到一个特定的操作实例上，当然，同样有很多策略可供选择，其中最灵活的就是把这种映射外部化，例如可以通过一个XML文件。
为了简单起见，我们在这里建立一个单独的组件，用于封装这种映射。
public class ActionHelper {
private static HashMap actions = new HashMap();
static {
actions.put(”Login”, “com.sample.LoginAction”);
}
public static Action getAction(String name) {
Action action = null;
try {
Class c = Class.forName((String) actions.get(name));
action = (Action) c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return action;
}
}
好了，以上就是要实现的一个简单的框架类FrontController，Action以及辅助的ActionHelper类

下一步是把所有这些处理插入到FrontController的processRequest方法中，这将是Web应用程序中所有请求的单一入口：
public class FrontController extends HttpServlet {
protected void processRequest(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {

String actionName =req.getPathInfo().substring(1);
Action action =ActionHelper.getAction(actionName);

String nextView =action.process(req, res);

RequestDispatcher dispatcher =
getServletContext().getRequestDispatcher(nextView);
dispatcher.forward(req, res);
}

protected void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
processRequest(req, res);
}

protected void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
processRequest(req, res);
}
}

具体相关内容可参见实例！

源码下载(index.rar)： 资源下载中心

更多详情请参见 我的博客 我的生活

说明：代码的结构和风格延续上一篇，更好的读懂代码

action：SendMailAction 和ActiveMQ那份代码基本相同，简单的用于控制邮件的发送

util：还是Constants常量数据

service：MailService结合Spring的配置文件mail.xml，注入了JavaMail和velocity模板引擎，在内部类MailThread（线程类）中来发送邮件

就三个类，其它的配置信息mail.properties、mailtemplate、action.xml、struts-config.xml、web.xml和ActiveMQ发送邮件中的是类似的，可以参考一下。

备注：考虑到包的大小，把lib中spring的架包去除了，自己去下载一份2.5的即可

更多详情请参见：我的博客 我的生活

缓存（CACHE）
定义：在本地放置、隐藏或存储常用信息以供快速检索
A memory area where frequently accessed data can be stored for rapid access.
好处：提高系统响应速度、改善系统运行性能的技术。

面临的问题
1、被处理的内容短时间不变，所以短时间内可以作为静态内容进行处理
2、在一个不太长的时间内，被处理的内容可能或者必定产生变化，所以必须将他们作为动态内容进行处理
3、在合理的时间区段内可以忽略被处理内容变化后带来的影响
4、对这些内容的处理动作比较消耗系统性能，影响系统响应时间 基础数据的变更问题
例子：系统中需要处理的基础数据；统计报表。

解决方法
1、缓存信息
当上述的基础数据或者统计报表第一次被访问时，被处理的内容被当作动态信息，基础数库从数据库中获得，统计报表也会被生成符合要求的图形、文件，然后这些信息都会被放入缓存信息中

2、响应信息由缓存提供
当上述的基础数据或者统计报表继续被访问时，系统将会首先检查缓存信息中是否有对应的内容和我们设定的缓存规则，如果符合缓存信息存在而且符合缓存规则，给出的响应将来自于缓存信息，如果没有或者缓存信息已经不符合设定的要求，系统将重复上一步的动作。

在步骤2中，多数情况下，当用户请求到达时，被处理的内容将来自于缓存，所以大大的减少了与数据库的交互，或者不再需要为每个请求都生成一次报表图形或者文件，这部分工作的减少对于降低系统性能消耗、提高系统稳定性和并发处理能力是非常有益的

OSCACHE
OSCache是OpenSymphony组织提供的一个J2EE架构中Web应用层的缓存技术实现组件
特点
兼容多种支持JSP的web服务器：已经通过兼容测试的web服务器包括OrionServer 、Macromedia JRun 、BEA Weblogic 、IBM Websphere 、Silverstream 、Caucho Resin 、Tomcat (4.x及以上版本) 
可选的缓存区：你可以使用内存、硬盘空间、同时使用内存和硬盘或者提供自己的其他资源（需要自己提供适配器）作为缓存区。
使用内存作为缓存区将可以提供更好的性能 
使用硬盘作为缓存区可以在服务器重起后迅速恢复缓存内容 
同时使用内存和硬盘作为缓存区则可以减少对内存的占用 
OSCache中按照缓存范围的不同分为两种不同的方式：一种是缓存JSP页面中部分或者全部内容，一种是基于整个页面文件的缓存

另外OSCHACHE还支持：POJO 缓存 、O/R Data Access 缓存 。

JSP部分内容缓存
第一次请求到达时，标签中的内容被处理并且缓存起来，当下一个请求到达时，缓存系统会检查这部分内容的缓存是否已经失效，主要是以下几项：
1. 缓存时间超过了cache标签设置的time或者duration属性规定的超时时间 
2. cron属性规定的时间比缓存信息的开始时间更晚 
3. 标签中缓存的内容在缓存后又被重新刷新过 
4. 其他缓存超期设定 

JSP部分内容缓存－一个例子
/*因为OSCache使用key值来标识缓存内容，使用相同的key值将会被认为使用相同的的缓存内容，所以使用动态的key值可以自由的根据不同的角色、不同的要求决定使用不同的缓存内容 */
<cache:cache key="<%= product.getId() %>" time="1800" refresh="<%= needRefresh %>">
 /* JSP代码内容 或jsp tag*/
 <% 代码%>
</cache:cache>

CashFilter实现页面级缓存
1、在OSCache组件中提供了一个CacheFilter用于实现页面级的缓存，主要用于对web应用中的某些动态页面进行缓存，尤其是那些需要生成pdf格式文件/报表、图片文件等的页面，不仅减少了数据库的交互、减少数据库服务器的压力，而且对于减少web服务器的性能消耗有很显著的效果。
2、这种功能的实现是通过在web.xml中进行配置来决定缓存哪一个或者一组页面，而且还可以设置缓存的相关属性，这种基于配置文件的实现方式对于J2EE来说应该是一种标准的实现方式了
3、
<filter>
<filter-name>CacheFilter</filter-name>
<filter-class>com.opensymphony.oscache.web.filter.CacheFilter</filter-class>
<init-param>
<param-name>time</param-name>
<param-value>60</param-value></init-param>
<init-param>
<param-name>scope</param-name>
<param-value>session</param-value>
</init-param>
</filter>

<filter-mapping>
<filter-name>CacheFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>