Struts2的工作机制分析及实例
一、概述
本章讲述Struts2的工作原理。
读者如果曾经学习过Struts1.x或者有过Struts1.x的开发经验，那么千万不要想当然地以为这一章可以跳过。实际上Struts1.x 与Struts2并无我们想象的血缘关系。虽然Struts2的开发小组极力保留Struts1.x的习惯，但因为Struts2的核心设计完全改变，从思想到设计到工作流程，都有了很大的不同。
Struts2是Struts社区和WebWork社区的共同成果，我们甚至可以说，Struts2是WebWork的升级版，他采用的正是WebWork 的核心，所以，Struts2并不是一个不成熟的产品，相反，构建在WebWork基础之上的Struts2是一个运行稳定、性能优异、设计成熟的WEB框架。
本章主要对Struts的源代码进行分析，因为Struts2与WebWork的关系如此密不可分，因此，读者需要下载xwork的源代码，访问https://www.doczj.com/doc/307873572.html,/xwork/download.action即可自行下载。
下载的Struts2源代码文件是一个名叫struts-2.1.0-src.zip的压缩包，里面的目录和文件非常多，读者可以定位到
struts-2.1.0-src\struts-2.0.10\src\core\src\main\java目录下查看Struts2的源文件，如图14所示。
（图14）
二、主要的包和类
Struts2框架的正常运行，除了占核心地位的xwork的支持以外，Struts2本身也提供了许多类，这些类被分门别类组织到不同的包中。从源代码中发现，基本上每一个Struts2类都访问了WebWork提供的功能，从而也可以看出Struts2与WebWork千丝万缕的联系。但无论如何，Struts2的核心功能比如将请求委托给哪个Action处理都是由xwork完成的，Struts2只是在WebWork 的基础上做了适当的简化、加强和封装，并少量保留Struts1.x中的习惯。
以下是对各包的简要说明：
包名说明
org.apache.struts2. components 该包封装视图组件，Struts2在视图组件上有了很大加强，不仅增加了组件的属性
个数，更新增了几个非常有用的组件，如updownselect、doubleselect、
datetimepicker、token、tree等。
另外，Struts2可视化视图组件开始支持主题(theme)，缺省情况下，使用自带的
缺省主题，如果要自定义页面效果，需要将组件的theme属性设置为simple。org.apache.struts2. config 该包定义与配置相关的接口和类。实际上，工程中的xml和properties文件的读
取和解析都是由WebWork完成的，Struts只做了少量的工作。
org.apache.struts2.dispatcher Struts2的核心包，最重要的类都放在该包中。
org.apache.struts2.impl 该包只定义了3个类，他们是StrutsActionProxy、StrutsActionProxyFactory、
StrutsObjectFactory，这三个类都是对xwork的扩展。
org.apache.struts2.interceptor 定义内置的截拦器。
org.apache.struts2.util 实用包。
org.apache.struts2.validators 只定义了一个类：DWRValidator。
org.apache.struts2.views 提供freemarker、jsp、velocity等不同类型的页面呈现。
下表是对一些重要类的说明：
类名说明
org.apache.struts2.dispatcher. Dispatcher 该类有两个作用：
1、初始化
2、调用指定的Action的execute()方法。
org.apache.struts2.dispatcher. FilterDispatcher 这是一个过滤器。文档中已明确说明，如果没有经验，配
置时请将url-pattern的值设成/*。
该类有四个作用：
1、执行Action
2、清理ActionContext，避免内存泄漏
3、处理静态内容（Serving static content）
4、为请求启动xwo rk’s的截拦器链。
com.opensymphony.xwork2. ActionProxy Action的代理接口。
com.opensymphony.xwork2. ctionProxyFactory 生产ActionProxy的工厂。
com.opensymphony.xwork2.ActionInvocation 负责调用Action和截拦器。
负责Struts2的配置文件的解析。
com.opensymphony.xwork2.config.providers.
XmlConfigurationProvider
三、 Struts2的工作机制
3.1 Struts2体系结构图
Strut2的体系结构如图15所示：
（图15）
3.2 Struts2的工作机制
从图15可以看出，一个请求在Struts2框架中的处理大概分为以下几个步骤：
1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；
2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；
3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；
4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；
5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；
6、ActionProxy创建一个ActionInvocation的实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper。
注：以上步骤参考至网上，具体网址已忘记。在此表示感谢！
3.3 Struts2源代码分析
和Struts1.x不同，Struts2的启动是通过FilterDispatcher过滤器实现的。下面是该过滤器在web.xml文件中的配置：
代码清单6：web.xml（截取）
org.apache.struts2.dispatcher.FilterDispatcher
Struts2建议，在对Struts2的配置尚不熟悉的情况下，将url-pattern配置为/*，这样该过滤器将截拦所有请求。
实际上，FilterDispatcher除了实现Filter接口以外，还实现了StrutsStatics接口，继承代码如下：
代码清单7：FilterDispatcher结构
publicclass FilterDispatcher implements StrutsStatics, Filter {
}
StrutsStatics并没有定义业务方法，只定义了若干个常量。Struts2对常用的接口进行了重新封装，比如HttpServletRequest、HttpServletResponse、HttpServletContext等。以下是StrutsStatics的定义：
代码清单8：StrutsStatics.java
publicinterface StrutsStatics {
/**
* Constant for the HTTP request object.
*/
publicstaticfinal String HTTP_REQUEST = "com.opensymphony.xwork2.dispatcher.HttpServletRequest";
/**
* Constant for the HTTP response object.
*/
publicstaticfinal String HTTP_RESPONSE = "com.opensymphony.xwork2.dispatcher.HttpServletResponse";
/**
* Constant for an HTTP request dispatcher}.
*/
publicstaticfinal String SERVLET_DISPATCHER = "com.opensymphony.xwork2.dispatcher.ServletDispatcher";
/**
* Constant for the servlet context} object.
*/
publicstaticfinal String SERVLET_CONTEXT = "com.opensymphony.xwork2.dispatcher.ServletContext";
/**
* Constant for the JSP page context}.
*/
publicstaticfinal String PAGE_CONTEXT = "com.opensymphony.xwork2.dispatcher.PageContext";
/** Constant for the PortletContext object */
publicstaticfinal String STRUTS_PORTLET_CONTEXT = "struts.portlet.context";
}
容器启动后，FilterDispatcher被实例化，调用init(FilterConfig filterConfig)方法。该方法创建Dispatcher类的对象，并且将FilterDispatcher配置的初始化参数传到对象中（详情请参考代码清单10），并负责Action的执行。然后得到参数packages，值得注意的是，还有另外三个固定的包和该参数进行拼接，分别是org.apache.struts2.static、template、和org.apache.struts2.interceptor.debugging，中间用空格隔开，经过解析将包名变成路径后存储到一个名叫pathPrefixes的数组中，这些目录中的文件会被自动搜寻。
代码清单9：FilterDispatcher.init()方法
publicvoid init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
dispatcher = createDispatcher(filterConfig);
dispatcher.init();
String param = filterConfig.getInitParameter("packages");
String packages = "org.apache.struts2.static template org.apache.struts2.interceptor.debugging";
if (param != null) {
packages = param + " " + packages;
}
this.pathPrefixes = parse(packages);
}
代码清单10：FilterDispatcher.createDispatcher()方法
protected Dispatcher createDispatcher(FilterConfig filterConfig) {
Map
for (Enumeration e = filterConfig.getInitParameterNames(); e.hasMoreElements(); ) {
String name = (String) e.nextElement();
String value = filterConfig.getInitParameter(name);
params.put(name, value);
}
returnnew Dispatcher(filterConfig.getServletContext(), params);
}
当用户向Struts2发送请求时，FilterDispatcher的doFilter()方法自动调用，这个方法非常关键。首先，Struts2对请求对象进行重新包装，此次包装根据请求内容的类型不同，返回不同的对象，如果为multipart/form-data类型，则返回MultiPartRequestWrapper类型的对象，该对象服务于文件上传，否则返回StrutsRequestWrapper类型的对象，MultiPartRequestWrapper是StrutsRequestWrapper的子类，而这两个类都是HttpServletRequest接口的实现。包装请求对象如代码清单11所示：
代码清单11：FilterDispatcher.prepareDispatcherAndWrapRequest()方法
protected HttpServletRequest prepareDispatcherAndWrapRequest(
HttpServletRequest request,
HttpServletResponse response) throws ServletException {
Dispatcher du = Dispatcher.getInstance();
if (du == null) {
Dispatcher.setInstance(dispatcher);
dispatcher.prepare(request, response);
} else {
dispatcher = du;
}
try {
request = dispatcher.wrapRequest(request, getServletContext());
} catch (IOException e) {
String message = "Could not wrap servlet request with MultipartRequestWrapper!";
LOG.error(message, e);
thrownew ServletException(message, e);
}
return request;
}
request对象重新包装后，通过ActionMapper的getMapping()方法得到请求的Action，Action的配置信息存储在ActionMapping对象中，该语句如下：mapping = actionMapper.getMapping(request,
dispatcher.getConfigurationManager());。下面是ActionMapping接口的实现类DefaultActionMapper的getMapping()方法的源代码：
代码清单12：DefaultActionMapper.getMapping()方法
public ActionMapping getMapping(HttpServletRequest request,
ConfigurationManager configManager) {
ActionMapping mapping = new ActionMapping();
String uri = getUri(request);//得到请求路径的URI，如：testAtcion.action或testAction!method
uri = dropExtension(uri);//删除扩展名，默认扩展名为action，在代码中的定义是List extensions = new ArrayList() {{ add("action");}};
if (uri == null) {
returnnull;
}
parseNameAndNamespace(uri, mapping, configManager);//从uri变量中解析出Action的name和namespace handleSpecialParameters(request, mapping);//将请求参数中的重复项去掉
//如果Action的name没有解析出来，直接返回
if (mapping.getName() == null) {
returnnull;
}
//下面处理形如testAction!method格式的请求路径
if (allowDynamicMethodCalls) {
// handle "name!method" convention.
String name = mapping.getName();
int exclamation = https://www.doczj.com/doc/307873572.html,stIndexOf("!");//!是Action名称和方法名的分隔符
if (exclamation != -1) {
mapping.setName(name.substring(0, exclamation));//提取左边为name
mapping.setMethod(name.substring(exclamation + 1));//提取右边的method
}
}
return mapping;
}
该代码的活动图如下：
（图16）
从代码中看出，getMapping()方法返回ActionMapping类型的对象，该对象包含三个参数：Action的name、namespace和要调用的方法method。
如果getMapping()方法返回ActionMapping对象为null，则FilterDispatcher认为用户请求不是Action，自然另当别论，FilterDispatcher会做一件非常有意思的事：如果请求以/struts开头，会自动查找在web.xml文件中配置的packages初始化参数，就像下面这样(注意粗斜体部分)：
代码清单13：web.xml(部分)
org.apache.struts2.dispatcher.FilterDispatcher
FilterDispatcher会将com.lizanhong.action包下的文件当作静态资源处理，即直接在页面上显示文件内容，不过会忽略扩展名为class的文件。比如在com.lizanhong.action包下有一个aaa.txt的文本文件，其内容为“中华人民共和国”，访问http://localhost:8081/Struts2Demo/struts/aaa.txt时会有如图17的输出：
（图17）
查找静态资源的源代码如清单14：
代码清单14：FilterDispatcher.findStaticResource()方法
protectedvoid findStaticResource(String name, HttpServletRequest request, HttpServletResponse response) throws IOException {
if (!name.endsWith(".class")) {//忽略class文件
//遍历packages参数
for (String pathPrefix : pathPrefixes) {
InputStream is = findInputStream(name, pathPrefix);//读取请求文件流
if (is != null) {
……（省略部分代码）
// set the content-type header
String contentType = getContentType(name);//读取内容类型
if (contentType != null) {
response.setContentType(contentType);//重新设置内容类型
}
……（省略部分代码）
try {
//将读取到的文件流以每次复制4096个字节的方式循环输出
copy(is, response.getOutputStream());
} finally {
is.close();
}
return;
}
}
}
}
如果用户请求的资源不是以/struts开头——可能是.jsp文件，也可能是.html文件，则通过过滤器链继续往下传送，直到到达请求的资源为止。
如果getMapping()方法返回有效的ActionMapping对象，则被认为正在请求某个Action，将调用
Dispatcher.serviceAction(request, response, servletContext, mapping)方法，该方法是处理Action的关键所在。上述过程的源代码如清单15所示。
代码清单15：FilterDispatche r.doFilter()方法
publicvoid doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
ServletContext servletContext = getServletContext();
String timerKey = "FilterDispatcher_doFilter: ";
try {
UtilTimerStack.push(timerKey);
request = prepareDispatcherAndWrapRequest(request, response);//重新包装request
ActionMapping mapping;
try {
mapping = actionMapper.getMapping(request, dispatcher.getConfigurationManager());//得到存储Action信息的ActionMapping对象
} catch (Exception ex) {
……（省略部分代码）
return;
}
if (mapping == null) {//如果mapping为null，则认为不是请求Action资源
String resourcePath = RequestUtils.getServletPath(request);
if ("".equals(resourcePath) &&null != request.getPathInfo()) {
resourcePath = request.getPathInfo();
}
//如果请求的资源以/struts开头，则当作静态资源处理
if (serveStatic&& resourcePath.startsWith("/struts")) {
String name = resourcePath.substring("/struts".length());
findStaticResource(name, request, response);
} else {
//否则，过滤器链继续往下传递
chain.doFilter(request, response);
}
// The framework did its job here
return;
}
//如果请求的资源是Action，则调用serviceAction方法。
dispatcher.serviceAction(request, response, servletContext, mapping);
} finally {
try {
ActionContextCleanUp.cleanUp(req);
} finally {
UtilTimerStack.pop(timerKey);
}
}
}
这段代码的活动图如图18所示：
（图18）
在Dispatcher.serviceAction()方法中，先加载Struts2的配置文件，如果没有人为配置，则默认加载struts-default.xml、struts-plugin.xml和struts.xml，并且将配置信息保存在形如com.opensymphony.xwork2.config.entities.XxxxConfig的类中。
类com.opensymphony.xwork2.config.providers.XmlConfigurationProvider负责配置文件的读取和解析， addAction()方法负责读取
代码清单16：XmlConfigurationProvider.addPackage()方法
protected PackageConfig addPackage(Element packageElement) throws ConfigurationException {
PackageConfig newPackage = buildPackageContext(packageElement);
if (newPackage.isNeedsRefresh()) {
return newPackage;
}
if (LOG.isDebugEnabled()) {
LOG.debug("Loaded " + newPackage);
}
// add result types (and default result) to this package
addResultTypes(newPackage, packageElement);
// load the interceptors and interceptor stacks for this package
loadInterceptors(newPackage, packageElement);
// load the default interceptor reference for this package
loadDefaultInterceptorRef(newPackage, packageElement);
// load the default class ref for this package
loadDefaultClassRef(newPackage, packageElement);
// load the global result list for this package
loadGlobalResults(newPackage, packageElement);
// load the global exception handler list for this package
loadGlobalExceptionMappings(newPackage, packageElement);
// get actions
NodeList actionList = packageElement.getElementsByTagName("action");
for (int i = 0; i < actionList.getLength(); i++) {
Element actionElement = (Element) actionList.item(i);
addAction(actionElement, newPackage);
}
// load the default action reference for this package
loadDefaultActionRef(newPackage, packageElement);
configuration.addPackageConfig(newPackage.getName(), newPackage);
return newPackage;
}
活动图如图19所示：
（图19）
配置信息加载完成后，创建一个Action的代理对象——ActionProxy引用，实际上对Action的调用正是通过ActionProxy 实现的，而ActionProxy又由ActionProxyFactory创建，ActionProxyFactory是创建ActionProxy的工厂。
注：ActionProxy和ActionProxyFactory都是接口，他们的默认实现类分别是DefaultActionProxy和DefaultActionProxyFactory，位于com.opensymphony.xwork2包下。
在这里，我们绝对有必要介绍一下com.opensymphony.xwork2.DefaultActionInvocation类，该类是对ActionInvocation 接口的默认实现，负责Action和截拦器的执行。
在DefaultActionInvocation类中，定义了invoke()方法，该方法实现了截拦器的递归调用和执行Action的execute()方法。其中，递归调用截拦器的代码如清单17所示：
代码清单17：调用截拦器，DefaultActionInvocation.invoke()方法的部分代码
if (interceptors.hasNext()) {
//从截拦器集合中取出当前的截拦器
final InterceptorMapping interceptor = (InterceptorMapping) interceptors.next();
UtilTimerStack.profile("interceptor: "+interceptor.getName(),
new UtilTimerStack.ProfilingBlock
public String doProfiling() throws Exception {
//执行截拦器（Interceptor）接口中定义的intercept方法
resultCode = interceptor.getInterceptor().intercept(DefaultActionInvocation.this);
returnnull;
}
});
}
从代码中似乎看不到截拦器的递归调用，其实是否递归完全取决于程序员对程序的控制，先来看一下Interceptor接口的定义：
代码清单18：Interceptor.java
publicinterface Interceptor extends Serializable {
void destroy();
void init();
String intercept(ActionInvocation invocation) throws Exception;
}
所有的截拦器必须实现intercept方法，而该方法的参数恰恰又是ActionInvocation，所以，如果在intercept方法中调用invocation.invoke()，代码清单17会再次执行，从Action的Intercepor列表中找到下一个截拦器，依此递归。下面是一个自定义截拦器示例：
代码清单19：CustomIntercepter.java
publicclass CustomIntercepter extends AbstractInterceptor {
@Override
public String intercept(ActionInvocation actionInvocation) throws Exception
{
actionInvocation.invoke();
return "李赞红";
}
}
截拦器的调用活动图如图20所示：
（图20）
如果截拦器全部执行完毕，则调用invokeActionOnly()方法执行Action，invokeActionOnly()方法基本没做什么工作，只调用了invokeAction()方法。
为了执行Action，必须先创建该对象，该工作在DefaultActionInvocation的构造方法中调用init()方法早早完成。调用过程是：DefaultActionInvocation()->init()->createAction()。创建Action的代码如下：
代码清单20：DefaultActionInvocation.createAction()方法
protectedvoid createAction(Map contextMap) {
try {
action = objectFactory.buildAction(proxy.getActionName(), proxy.getNamespace(), proxy.getConfig(), contextMap);
} catch (InstantiationException e) {
……异常代码省略
}
}
Action创建好后，轮到invokeAction()大显身手了，该方法比较长，但关键语句实在很少，用心点看不会很难。
代码清单20：DefaultActionInvocation.invokeAction()方法
protected String invokeAction(Object action, ActionConfig actionConfig) throws Exception {
//获取Action中定义的execute()方法名称,实际上该方法是可以随便定义的
String methodName = proxy.getMethod();
String timerKey = "invokeAction: "+proxy.getActionName();
try {
UtilTimerStack.push(timerKey);
Method method;
try {
//将方法名转化成Method对象
method = getAction().getClass().getMethod(methodName, new Class[0]);
} catch (NoSuchMethodException e) {
// hmm -- OK, try doXxx instead
try {
//如果Method出错,则尝试在方法名前加do,再转成Method对象
String altMethodName = "do" + methodName.substring(0, 1).toUpperCase() + methodName.substring(1);
method = getAction().getClass().getMethod(altMethodName, new Class[0]);
} catch (NoSuchMethodException e1) {
// throw the original one
throw e;
}
}
//执行方法
Object methodResult = method.invoke(action, new Object[0]);
//处理跳转
if (methodResult instanceof Result) {
this.result = (Result) methodResult;
returnnull;
} else {
return (String) methodResult;
}
} catch (NoSuchMethodException e) {
……省略异常代码
} finally {
UtilTimerStack.pop(timerKey);
}
}
刚才使用了一段插述，我们继续回到ActionProxy类。
我们说Action的调用是通过ActionProxy实现的，其实就是调用了ActionProxy.execute()方法，而该方法又调用了ActionInvocation.invoke()方法。归根到底，最后调用的是DefaultActionInvocation.invokeAction()方法。
以下是调用关系图：
其中：
? ActionProxy：管理Action的生命周期，它是设置和执行Action的起始点。
? ActionInvocation：在ActionProxy层之下，它表示了Action的执行状态。它持有Action实例和所有的Interceptor 以下是serviceAction()方法的定义：
代码清单21：Dispatcher.serviceAction()方法
publicvoid serviceAction(HttpServletRequest request, HttpServletResponse response, ServletContext context,
ActionMapping mapping) throws ServletException {
Map
// If there was a previous value stack, then create a new copy and pass it in to be used by the new Action ValueStack stack = (ValueStack) request.getAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY);
if (stack != null) {
extraContext.put(ActionContext.VALUE_STACK,
ValueStackFactory.getFactory().createValueStack(stack));
}
String timerKey = "Handling request from Dispatcher";
try {
UtilTimerStack.push(timerKey);
String namespace = mapping.getNamespace();
String name = mapping.getName();
String method = mapping.getMethod();
Configuration config = configurationManager.getConfiguration();
ActionProxy proxy = config.getContainer().getInstance(ActionProxyFactory.class).createActionProxy( namespace, name, extraContext, true, false);
proxy.setMethod(method);
request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, proxy.getInvocation().getStack());
// if the ActionMapping says to go straight to a result, do it!
if (mapping.getResult() != null) {
Result result = mapping.getResult();
result.execute(proxy.getInvocation());
} else {
proxy.execute();
}
// If there was a previous value stack then set it back onto the request
if (stack != null) {
request.setAttribute(ServletActionContext.STRUTS_VALUESTACK_KEY, stack);
}
} catch (ConfigurationException e) {
LOG.error("Could not find action or result", e);
sendError(request, response, context, HttpServletResponse.SC_NOT_FOUND, e);
} catch (Exception e) {
thrownew ServletException(e);
} finally {
UtilTimerStack.pop(timerKey);
}
}
最后，通过Result完成页面的跳转。
3.4 本小节总结
总体来讲，Struts2的工作机制比Struts1.x要复杂很多，但我们不得不佩服Struts和WebWork开发小组的功底，代码如此优雅，甚至能够感受看到两个开发小组心神相通的默契。两个字：佩服。
以下是Struts2运行时调用方法的顺序图：
（图21）
四、总结
阅读源代码是一件非常辛苦的事，对读者本身的要求也很高，一方面要有扎实的功底，另一方面要有超强的耐力和恒心。本章目的就是希望能帮助读者理清一条思路，在必要的地方作出简单的解释，达到事半功倍的效果。
当然，笔者不可能为读者解释所有类，这也不是我的初衷。Struts2+xwork一共有700余类，除了为读者做到现在的这些，已无法再做更多的事情。读者可以到Struts官方网站下载帮助文档，慢慢阅读和理解，相信会受益颇丰。
本章并不适合java语言初学者或者对java博大精深的思想理解不深的读者阅读，这其中涉及到太多的术语和类的使用，特别不要去钻牛角尖，容易使自信心受损。基本搞清楚Struts2的使用之后，再回过头来阅读本章，对一些知识点和思想也许会有更深的体会。
如果读者的java功底比较浑厚，而且对Struts2充满兴趣，但又没太多时间研究，不妨仔细阅读本章，再对照Struts的源代码，希望对您有所帮助。
一、准备工作及实例
1.解压struts-
2.1.6-all.zip
apps目录:struts2自带的例子程序
docs目录：官方文档。
lib 目录：存放所有jar文件。
Src 目录：源文件存放地
2.六个基本包
struts2-core-2.1.6.jar ：开发的核心类库
freemarker-2.3.13.jar ：struts2的UI标签的模板使用freemarker编写
commons-logging-1.0.4.jar ：日志包
ognl-2.6.11.jar ：对象图导航语言，通过它来读写对象属性
xwork-2.1.2.jar ：xwork类库，struts2在其上进行构建
commons-fileupload-1.2.1.jar：文件上传组件，2.1.6版本后必须加入此jar包
特别需要说明的是目前strust2的最新版本是struts-2.1.6，它作为 2.1.X的正式版。特别要注意导入commons-fileupload-1.2.1.jar包，在此jar包中包含了RequestContext类，如果不导入该jar包将会报异常。
3.初识struts2配置文件
（1）．web.xml文件
主要完成对StrutsPrepareAndExecuteFilter的配置（在以前的版本中是对FilterDispatcher配置，新版本同样支持用FilterDispatcher配置），它的实质是一个过滤器，它负责初始化整个Struts框架并且处理所有的请求。这个过滤器可以包括一些初始化参数，有的参数指定了要加载哪些额外的xml配置文件，还有的会影响struts框架的行为。除了StrutsPrepareAndExecuteFilter外，Struts还提供了一个ActionContexCleanUp类，它的主要任务是当有其它一些过滤器要访问一个初始化好了的struts框架的时候，负责处理一些特殊的清除任务。
（2）．struts.xml文件
框架的核心配置文件就是这个默认的struts.xml文件，在这个默认的配置文件里面我们可以根据需要再包括其它一些配置文件。在通常的应用开发中，我们可能想为每个不同的模块单独配置一个struts.xml文件，这样也利于管理和维护。这也是我们要配置的主要文件。
SSH框架搭建 Struts2.3.12+Spring3.2.2+Hibernate4.2.0 编号：SSH-S2-S3-H4 版本：V1.1 级别：公开 编写时间：2013-03-18
目录 1 导言 (1) 1.1 目的 (1) 1.2 范围 (1) 1.3 说明 (1) 2 搭建Struts2 (2) 2.1 搭建所需jar包 (2) 2.2 整合步骤 (2) 2.2.1 创建项目 (2) 2.2.2 导入jar包 (2) 2.2.3 配置web.xml (4) 2.2.4 创建web (4) 2.2.5 创建jsp页面 (5) 2.2.6 配置struts.xml (6) 2.2.7 配置Tomcat (6) 2.2.8 部署项目 (7) 2.3 测试 (8) 2.3.1 启动Tomcat (10) 2.3.2 测试Tomcat (10) 2.3.3 测试Struts (11) 3 整合Spring3 (12) 3.1 整合所需jar包 (12) 3.2 整合步骤 (12) 3.2.1 导入jar包 (12) 3.2.2 配置web.xml (12) 3.2.3 配置struts.xml (13) 3.2.4 配置spring.xml (13) 3.3 测试 (14)
3.3.1 启动Tomcat (14) 3.3.2 测试登录 (14) 4 整合Hibernate4 (15) 4.1 整合所需jar包 (15) 4.2 整合步骤 (15) 4.2.1 导入jar包 (15) 4.2.2 创建数据库ccc (15) 4.2.3 创建对象User (16) 4.2.4 生成映射文件User.hbm.xml (17) 4.2.5 创建dao (18) 4.2.6 创建service (19) 4.2.7 创建web (20) 4.2.8 配置jdbc.properties (21) 4.2.9 配置db.xml (22) 4.2.10 配置spring.xml (24) 4.2.11 配置struts.xml (24) 4.3 测试 (25) 4.3.1 启动Tomcat (25) 4.3.2 测试登录 (25)
Struts2技术 在本教程中使用的工具和程序库的版本如下： ●开发工具：MyEclipse6 ●Web服务器：Tomcat6 ●Struts版本：Struts2.0.11.1 ●JDK版本：JDK1.5.0_12 ●J2EE版本：Java EE5.0 在本系列教程中Web工程的上下文路径都是struts2，如果在Web根目录有一个index.jsp文件，则访问路径如下： http://localhost:8080/struts2/index.jsp 由于MyEclipse6目前并不支持Struts2，所以我们需要到 https://www.doczj.com/doc/307873572.html,去下载Struts2安装包。要想正常使用Struts2，至少需要 如下五个包（可能会因为Struts2的版本不同，包名略有差异，但包名的前半部 是一样的）。 ●struts2-core-2.0.11.1.jar ●xwork-2.0.4.jar ●commons-logging-1.0.4.jar ●freemarker-2.3.8.jar ●ognl-2.6.11.jar (将%TOMCAT_HONE%\common\endorsed\xml-apis.jar删除) Struts2虽然在大版本号上是第二个版本，但基本上在配置和使用上已经完 全颠覆了Struts1.x的方式（当然，Struts2仍然是基于MVC模式的，也是动作 驱动的，可能这是唯一没变的东西）。Struts2实际上是在Webwork基础上构建 起来的MVC框架。我们从Struts2的源代码中可以看到，有很多都是直接使用的xwork(Webwork的核心技术)的包。既然从技术上来说Struts2是全新的框架， 那么就让我们来学习一下这个新的框架的使用方法。
软件项目主要阶段及各个阶段主要工作 Document number：WTWYT-WYWY-BTGTT-YTTYU-2018GT
软件项目主要分为哪些阶段各个阶段主要做哪些工作 本人在两个中小型软件开发企业工作过几年，也做过几年的项目管理工作。走过一些弯路也得出一些项目管理方面的体会，在此进行总结，希望能够与其他一些项目管理人员或对项目管理有兴趣的同事共同探讨一些中小型项目管理的问题及方法。？ 大部分中小型软件开发企业的软件项目经常遇到的一些问题可能包括：项目时间紧、项目组成员经常加班；项目需求变更频繁；项目进行过程中可能就有项目团队成员离职或调离到其他项目组；项目重复性建设问题严重，每个项目都需要从框架开始重新开发，难以重用已有项目的成果等等。我觉得通过较好的规划和管理能够在一定程度上提高项目的成功率或者说提高项目的质量，降低开发成本，缩短项目开发时间。？ 我理解项目管理有两个大的划分方法一是通用的项目管理体系，也就是PMP 中所说的5个项目管理过程组9个知识领域44个项目管理过程；二是具体业务领域的按项目生命期划分的各阶段的管理。本文主要从项目生命期各阶段的管理方面进行总结。？ 我个人分析一个软件项目生命期大体需要经过的流程（这只是我个人的一个划分，有可能不是很全面）：可行性分析、需求、设计、开发、测试、实施、维护、总结。？ 下面我针对每个阶段谈一下自己的体会。？ 一、可行性分析？ 一般的项目都是通过外部招标的形式得到的。对于有些公司在应标的时候对项目就要有个取舍。如果在特殊时期为了生存可能只要不是太赔的项目都会尽量承接。？ 但是一般项目在承接前最好在经济、技术等方面进行可行性分析，而且这种可行性分析最好是管理者、市场、技术等人员都参与，因为市场人员一般不懂（或不通）技术，技术不懂（或不通）市场，因此只有大家在一起共同分析讨论才能够得出比较可行的结果。可行性分析的结果一方面可以作为是否承接项目的依据，另一方面也可以作为承接项目方式或与客户谈判的依据。比如经分析项目工作量很大，如果按标书金额开发有可能会赔，那么可以与用户探讨是否将来能有个二期的项目；另外如果用户要求的时间比较紧，可是经分析很难按标书时间完成，那么也可以和用户同共探讨是否可以在正式签定合同时延长系统交付时间等。当然这些与用户的探讨工作一般是需要公司高层领导出面协调的，有时单独靠项目组是没有能力达成理想的结果的。？ 另外在此阶段最好对项目的成本和需要的资源进行一下估算。？ 二、需求？ 需求实际要细分为需求调研、需求分析、需求确认、需求管理等。？ 因为对于需求要想说清楚可能需要较长的篇幅，所以在此不进行展开。？ 在此只是先强调一下需要相当重要，如果早期需求做的不够仔细会给项目的后期工作带来很多的隐患。？
2012年第11卷第6期 产业与科技论坛2012.（11）.6 Industrial &Science Tribune Struts2框架工作原理及应用体会 □宋 君 张家爱 【摘要】通过针对特定用户的分析，搭建以Struts2为技术核心的旅行社管理系统。本文简单的介绍了MVC 、 Struts2的工作原理，同时总结了在项目制作过程中所得到的心得。 【关键词】 Struts2；MVC ；FilterDispatcher ；Action 【基金项目】本文为大学生科技创新院级基金项目（编号：2011070）成果 【作者单位】宋君，吉林农业科技学院信息工程学院；张家爱，吉林农业科技学院信息工程学院教师 本着锻炼自我与积极参与到实用性技术的目标，以发掘自身创新意识为前提。利用空闲时间，在老师的指导下，进行了一次大学生创新项目的实践性活动。本着实用原则，以某中小旅行社为客户（根据用户需求，匿名），以Struts2框架为基点，进行了一次旅行社管理系统的开发。在项目结束之余， 特将在项目过程中经历的种种认识进行了简单的总结，希望让阅读本文的朋友们，更多的参与到此类活动中。 一、基础思想— ——MVC 简述作为时下经典框架之一， MVC 具有其独特的价值。MVC 框架简单的说，就是将数据模型与用户视图进行分离。通过控制器进行协调处理的一种结构是框架。同时，也是本文中要讨论的Sturts2框架的基础思想。 M 是指模型层（Model ），V 是指用户视图（View ），C 则是指控制器 （Controller ）。这种划分方式是以将模型层与视图层进行代码分离，从而降低两者之间的耦合性，使同一程序可以使用不同形式进行表现。不同层之间的修改不会或尽量少的印象到其他层功能的史前为前提。有效的提高的代码的维护性和设计难度。 图1 二、 Struts2工作原理（一）Struts2框架组成。Struts2框架由三个主要部分组成：核心控制器、业务控制器，以及由用户实现的业务逻辑组件。这里我们将侧重于核心控制器与业务控制器的理解与说明。 （二）核心控制器：FilterDispatcher 。FilterDispatcher 是Struts2框架的核心控制器，在此，我们可以将FilterDispatcher 看作一个类似于过滤网的过滤器。当用户发出请求，并到达Web 硬哟那种时，该过滤器会过滤用户请求。如果用户请求的结尾为action ，则将该请求转入Struts2框架进行处理。当Struts2框架获得了*．actio 请求后，会根据请求前面“*”的那部分内容，决定调用哪个业务逻辑组件作为响应单位。这里需要说明的是Struts2用来处理用户请求的Action 实例并不是业务控制器，而是作为Action 的代理———正因为Struts2的一大特点，与Servlet API 的非耦合性，使得用户实现的业务控制器无法直接处理用户请求。有效的提高了后期调试维护的效率。而Struts2框架再次提供了了一系列的拦截器。这些拦截器负责将HttpServletRequest 请求的参数解析出来，传入Action 中，并毁掉Action 的Execute 方法来处理用户请求。用户实现的Action 类仅作为Struts2的Action 代理的代理目标。用户实现的业务控制器则包含了对用户请求的处理。用户的请求数据包含在HttpServletRequest 对象中，而用户的Action 类无需访问HttpServletRequest 对象。拦截器负责将HttpServletRequest 里的请求数据解析出来，并传给业务逻辑组件Action 实例。 （三）业务控制器。业务控制器就是前文提到的用来实现用户Action 的实力，这里的每个Action 类通常包含有一个execute 方法，当业务控制器处理完用户的请求后，该方法将会针对此次处理返回一个字符串— ——该字符串就是一个逻辑树图名。当程序开发人员开发出系统所需要的业务控制器后，还需要针对性的配置Struts2的Action ，即需要配置Ac- tion 的以下三个部分：（1）Action 所处理的URl 。（2）Action 组件所对应的实现类。（3）Action 里包含的逻辑试图和物理资源之间的对应关系。每个Action 都要处理一个用户请求，而用户请求则总是包含有指定的URL 。当核心控制器过滤用户请求，并调用后，根据请求的URL 和Action 处理URL 之间的对应关系来处理转发。 · 342·
Struts2复习题 1.以下属于struts2的控制器组件是： A.Action B.ActionForm C.ActionServlet D.dispatchAction 2.以下属于struts2的体系结构的是：(多选) A.struts2控制器组件 B.struts2配置文件 C.FilterDispathcer D.Action 3.以下属于struts2配置文件中的配置元素是：(多选) A.
Struts2原理 上图来源于Struts2官方站点，是Struts 2 的整体结构。 Struts2框架由3个部分组成：核心控制器FilterDispatcher、业务控制器和用户实现的业务逻辑组件。在这3个部分里，Struts 2框架提供了核心控制器FilterDispatcher，而用户需要实现业务控制器和业务逻辑组件。 (1)核心控制器：FilterDispatcher
FilterDispatcher是Struts2框架的核心控制器，该控制器作为一个Filter运行在Web应用中，它负责拦截所有的用户请求，当用户请求到达时，该Filter 会过滤用户请求。如果用户请求以action结尾，该请求将被转入Struts2框架处理。 Struts2框架获得了*.action请求后，将根据*.action请求的前面部分决定调用哪个业务逻辑组件，例如，对于login.action请求，Struts2调用名为login的Action来处理该请求。 Struts2应用中的Action都被定义在struts.xml文件中，在该文件中定义Action 时，定义了该Action的name属性和class属性，其中name属性决定了该Action 处理哪个用户请求，而class属性决定了该Action的实现类。 Struts2用于处理用户请求的Action实例，并不是用户实现的业务控制器，而是Action代理——因为用户实现的业务控制器并没有与Servlet API耦合，显然无法处理用户请求。而Struts2框架提供了系列拦截器，该系列拦截器负责将HttpServletRequest请求中的请求参数解析出来，传入到Action中，并回调Action 的execute方法来处理用户请求。 (2)一个请求在Struts2框架中的处理大概分为以下几个步骤 1 .客户端初始化一个指向Servlet容器（例如Tomcat）的请求,即HttpServletRequest请求。 2 .这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin） 3. 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action 4 .如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy 5 .ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类 6 .ActionProxy创建一个ActionInvocation的实例。 7 .ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。 8 .一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper
软件建模与UML 实训报告 实训项目：________________________ 小组名称：________________________ 小组成员：________________________ 联系方式：________________________
目录 一、摘要 (1) 二、BBS论坛系统的可行性分析 (2) 三、BBS论坛系统的需求分析 (3) 四、系统的UML建模设计 (6) 五、BBS系统的数据库建模 (14) 六、心得 (19)
一、摘要 随着Internet技术的快速发展，人与人之间交流方式逐渐增多。网络视频、网络聊天、博客已成为人们彼此沟通、交流信息的主要方式。此外，为了方便人们在某一专业领域探讨问题和发表意见，Internet上还出现了在线论坛。在论坛上，人们可以对某一领域提出自己遇到的问题，即发表某一主题，随后，论坛上的其他人会根据自己的学识、经验发表意见或提出问题的方法。 开发BBS论坛系统的目的是提供一个供用户交流的平台，为广大用户提供交流经验、探讨问题的网上社区。因此，BBS论坛系统最基本的功能首先是发表主题，其次是其他人员根据主题发表自己的看法。此外，为了记录主题的发表者和主题的回复者信息，系统还需要提供用户注册和登录的功能。只有注册的用户登录后才能够发表和回复主题，浏览者（游客）只能浏览主题信息。 本论坛系统是基于是Struts1.2+SQL Server 2000实现的，它具有使用方便、操作灵活、运行稳定、安全可靠等特点。 关键词在线论坛，BBS，网上社区
二、BBS论坛系统的可行性分析 可行性分析是在系统调查的基础上，针对新系统的开发是否具备必要性和可能性，对新系统的开发从技术、经济、社会的方面进行分析和研究，以避免投资失误，保证新系统的开发成功。可行性研究的目的就是用最小的代价在尽可能短的时间内确定问题是否能够解决。 2.1、技术可行性 技术上的可行性分析主要分析技术条件能否顺利完成开发工作，硬、软件能否满足开发者的需要等。该BBS论坛管理系统采用了流行的JSP语言和当前新兴的Browser/Server （浏览器/服务器）模式进行开发。三层的B/S体系结构具有许多传统Client/Server（客户机/服务器）体系结构不具备的优点，而且又紧密的结合了Internet/Intranet（国际互联网/企业内部互联网）技术，是技术发展的大势所趋，它把应用系统带入了一个崭新的发展时代。数据库服务器选用SQL Server 2000数据库，它能够处理大量数据，同时保持数据的完整性并提供许多高级管理功能。它的灵活性、安全性和易用性为数据库编程提供了良好的条件。因此，系统的软件开发平台已成熟可行。硬件方面，科技飞速发展的今天，硬件更新的速度越来越快，容量越来越大，可靠性越来越高，价格越来越低，其硬件平台能满足此系统的需要。 2.2、经济可行性 主要是对项目的经济效益进行评估，本系统模拟的是提供一个供用户交流的平台，为广大用户提供交流经验、探讨问题的社区。但实际只是用于个人的毕业设计，只是模拟，也不存在资金的流动，故在经济上是可行的。 2.3、社会可行性 随着Internet技术的快速发展，BBS论坛已成为人们彼此沟通、交流信息的主要方式。在论坛上，人们可以对某一领域提出自己遇到的问题，随后，论坛上的其他人会根据自己的学识、经验发表意见或提出问题的方法。BBS论坛接近了人们之间的距离，它早已成为人们网上生活的必备工具。所以说BBS论坛对当今社会是相当重要的。
1.系统分析与设计 1.1 系统功能描述 本系统是个非常简单的注册、登录系统。本系统的实现是基于Struts2、Spring、Hibernate 三个框架，系统功能单一，业务逻辑简单。 当用户注册信用户时，就是向系统中增加一个新用户，对应的数据库增加一条记录。 当用户输入注册信息时，系统提供了基本的输入验证判断用户输入是否合法，只有当用户输入满足基本输入要求时，才会被提交到实际的登录系统，进行实际的登录处理。 系统还使用了随机产生的图形验证码来防止刷新，防止用户通过单击浏览器的书安心按钮来重复注册多个用户。 系统还提供了一种Ajax方式来验证用户输入的注册名是否有效，系统要求所有的用户名不能重复。故当用户输完用户名后，系统立即在页面上方提示用户该用户名是否可用，如果系统中没有该用户名，则系统提示该用户名可用；否则提示用户该用户名重复，用户必须重新选择用户名注册。 当用户注册一个新用户名之后，就可以使用系统的登录功能来登录系统了，用户输入登录用的用户名、密码后，系统一样提供了基本的输入校验。 除此之外，系统还采用了随机产生图形验证码来防止恶意用户的暴力破解，系统随机生成一个图形验证码，而用户登录必须输入图形验证码中显示的字符串，只有用户输入的字符串和系统随机生成的验证码字符相同时，系统才允许用户登录。 1.2 系统功能流程
1.3 数据库设计 相关的映射文件：
Struts2的工作机制分析及实例 一、概述 本章讲述Struts2的工作原理。 读者如果曾经学习过Struts1.x或者有过Struts1.x的开发经验，那么千万不要想当然地以为这一章可以跳过。实际上Struts1.x 与Struts2并无我们想象的血缘关系。虽然Struts2的开发小组极力保留Struts1.x的习惯，但因为Struts2的核心设计完全改变，从思想到设计到工作流程，都有了很大的不同。 Struts2是Struts社区和WebWork社区的共同成果，我们甚至可以说，Struts2是WebWork的升级版，他采用的正是WebWork 的核心，所以，Struts2并不是一个不成熟的产品，相反，构建在WebWork基础之上的Struts2是一个运行稳定、性能优异、设计成熟的WEB框架。 本章主要对Struts的源代码进行分析，因为Struts2与WebWork的关系如此密不可分，因此，读者需要下载xwork的源代码，访问https://www.doczj.com/doc/307873572.html,/xwork/download.action即可自行下载。 下载的Struts2源代码文件是一个名叫struts-2.1.0-src.zip的压缩包，里面的目录和文件非常多，读者可以定位到 struts-2.1.0-src\struts-2.0.10\src\core\src\main\java目录下查看Struts2的源文件，如图14所示。 （图14） 二、主要的包和类 Struts2框架的正常运行，除了占核心地位的xwork的支持以外，Struts2本身也提供了许多类，这些类被分门别类组织到不同的包中。从源代码中发现，基本上每一个Struts2类都访问了WebWork提供的功能，从而也可以看出Struts2与WebWork千丝万缕的联系。但无论如何，Struts2的核心功能比如将请求委托给哪个Action处理都是由xwork完成的，Struts2只是在WebWork 的基础上做了适当的简化、加强和封装，并少量保留Struts1.x中的习惯。
Struts2的工作流程及配置文件--- https://www.doczj.com/doc/307873572.html, --- Struts2.0的流程图
从图中看到Struts2的工作流程如下： 1.服务器接收到的请求首先经过一组过滤器链（实际中的其他过滤器可能还包括诸如Spring 的字符过滤器CharactorEncodingFilter、V elocity的过滤器等，一般FilterDispatcher位于过滤器的最后一个执行），过滤器链按照你在web.xml中的配置顺序在接收客户请求时顺序执行，在向客户发送响应时反序执行，Struts2的核心FilterDispatcher在web.xml中的配置如下：
Yaio 4 一、准备工作及实例 4 1.解压struts- 2.1.6-all.zip 4 2.六个基本包 4 3.初识struts2配置文件 4 （1）．web.xml文件 4 （2）．struts.xml文件 4 （3）．struts.properties（参default.properties） 4 （4）struts-default.xml 5 （5）其它配置文件 5 4.让MyEclipse提示xml信息 5 5.如何使用alt+/提示 5 6.实例 5 7.开启struts2自带的开发模式常量 7 8.vo传参模式 8 9.ModerDriven传参模式(不建议采用) 8 10.为什么要使用struts2代替struts1.x 9
二、struts.xml配置及例程 9 1.配置文件的优先级 9 2.配置形式 9 3.package配置相关 10 4.分工合作include:指定多个配置文件 12 5.tomcat认证访问 12 6.初识拦截器 13 7.Action中的method属性 15 8.使用ForwardAction实现页面屏蔽。 17 8.使用default-Action配置统一访问 17 小结Action 18 9.使用通配符 18 10.使用0配置：ZERO Annotation 19 11.Result配置详解 19 12.异常处理 24 三、在Action获取Scope对象 25 方式一、与Servlet解耦合的非IOC方式 25
方式二、与Servlet解耦合的IOC方式 27 方式三、与Servlet耦合的非IOC方式 27 方式四、与Servlet耦合的IOC方式 28 四、OGNL与ValueStack(VS) 29 1.值栈入门 29 2.OGNL入门 31 3.普通方法访问 31 4.静态方法访问 31 5.默认类Math的访问 32 6.调用普通类的构造方法 32 7.集合对象初步 32 8.集合对象进阶 33 9.N语法top语法 34 10.获取Stack Context中的信息 35 11.总结$ # %的区别 35 12.总结OGNL[重点] 35 五、拦截器 36
1.Eclipse是IMB公司向开放源代码社区捐献的Java程序开发平台，是一个成熟的、可扩展的体系结构。 2.Eclipse主要包含3个子项目：平台子项目，Java开发工具子项目，插件开发环境子项目。 3.MVC是Model（模型）业务逻辑层，View（试图）表述层，Controller（控制）控制层。 4.Struts是Apache Jakarta项目于2001年推出的一个开元的Java Web框架，通过一个配置文件，把各个层面的应用组件联系起来，使组件在程序层面上联系较少，耦合度较低，提高了应用程序的可维护性和扩展性。 5. Struts框架有两种发行包：源代码（source）和二进制（binary）。 6. Struts框架大约由300个Java类组成，可分为8个核心包：config，action，actions，tiles，upload，taglib，util，validator。 7. Struts的核心API包括ActionServlet，ActionForm，Action，ActionMapping及ActionForward，它们构成了Struts框架中的控制器组件，视图组件，模型组件 8.Hibernate是对象/关系映射（ORM）的解决方案，就是将Java对象与对象关系映射成关系数据库中表格与表格之间的关系。 9. Cache就是缓存，它往往是提高系统性能的在最重要手段，对数据起到一个蓄水池和缓冲的作用。 10. Session实现了第一级Cache，它属于事务级数据缓冲，二级Cache是SessionFactory范围内的缓冲，所有的Session共享同一个二级Cache。 11.设置Hibernate的二级Cache需要分两部进行：首先确认使用什么数据并发策略，然后设置缓存过期时间和设置Cache提供器。 12.Spring是指一个用于构造Java应用程序的轻量级框架。13.IoC是一种将组件依赖关系的创建和管理置于程序外部的技术。 1.MVC设计模式的J SP Model1和JSPModel2的区别？答：对Model1而言，JSP页面会完成请求的所有处理事项，负责向客户显示输出，整个流程并没有Servlet的参与，客户请求直接送往JSP页面，JSP页调用JavaBean组件或其他业务组件处理请求，并把结果在另一个页面显示出来。对Model2而言，客户请求不是直接送给JSP页面，而是送给一个Servlet 进行前端处理。一旦请求处理完毕，Servlet会把请求重定向到适当的JSP页面。 2. Struts 的基本原理？答：首先从struts-config.xml文件中读取信息，根据这些信息，它的控制器ActionServlet知道把视图中的请求转发给哪个业务逻辑组件处理。视图组件、控制器与业务逻辑组件之间没有代码上的联系，它们之间的关系在struts-config.xml中声明，这样大大提高了Web应用程序的可移植性和可维护性。 3. S truts的核心组件？答：ActionServlet的类扩展了javax.servlet.http.HttpServlet类，其职责是把HTTP消息打包起来并路由传送到框架中合适的处理器。Struts框架中的org.apache.struts.action.Action类是控制器组件的一个扩展。struts-config.xml是整个Struts 应用程序的枢纽。ActionMapping，控制器要通过查看请求信息并使用一组动作映射对象来作出决定。ActionForward，在Action完成之后，控制器要转交控制权的地方。ActionForm 对象可用来在用户和业务层之间传输客户的输入数据。 4. Struts框架如何处理每个请求相应的ActionForm对象？答：①检查该项动作的相应映射，查看是否已经有某个ActionForm得到配置②如果对应这个动作配置了某个ActionForm，则使用action元素中的name属性来查找FormBean的配置信息③查看是否已经创建了ActionForm的一个实例④如果在适当的作用域内已经存在一个ActionForm实例，而且这个实例的类型正是这个新请求所需要的类型，则重用这个实例⑤否则，创建所需ActionForm 的一个新实例，并存储在适当的作用域。⑥调用ActionForm实例的reset()方法⑦反复处理请求参数，如果参数名在ActionForm实例中具有对应的设置方法，就为它填上请求参数的
Struts2基础知识 Struts2概述 1.Struts2框架应用javaee三层结构中的web层框架。 2.Struts2框架在struts1和webwork基础之上发展的全新框架。 3.Struts2所解决的问题： 在以往实现一个功能时，都需要写很多的servlet，从而造成后期维护上的不方便。 图解： 4.现在比较稳定的Struts2版本 struts-2.3.24-all.zip 5.web层常见框架 1.struts 2.springMVC Struts2框架入门 1.导入jar包 1.在lib里面有jar包，但不能全部导入，因为里面含有一些spring 包，是不能使用的，导入会导致程序不能运行。 2.到app目录里面复制案例的jar包是最好的方法。 2.创建action 3.配置action类的访问路径
1.创建struts2核心配置文件，该核心配置文件位置和名称是固定的， 位置必须在src下面，名称为struts.xml 。 2.引入dtd约束，可以在案例文件中找到，复制在struts.xml文件中即 可。 3.action的配置 *注意访问路径： http://域名/端口号/项目名/action名.action 注意：.action可以省略，但建议不要省略，为了兼容一些老版本的浏览器。 4.配置Struts2的过滤器，可以在案例中的web.xml文件中找到，复制粘贴 即可。 Struts2执行过程 图解：
Struts2配置
1.是一种常量标签 2.修改Struts2的默认常量值 1.常用方式 在struts.xml中进行配置。 2.其它两种方式 1.在src下面创建struts.properties文件并修改。 2.在web.xml文件中进行修改。 3.Struts2最常用的常量 struts.il8n.encoding=UTF-8,解决表单在通过post方式提交中文时，中文乱码的问题。
struts2核心工作流程与原理 做为一名技术人员，听到太多关于.net和java的比较的话题。我想对那些技术人员说，请先了解一下什么是java（或者.net）吧，其实你根本不了解。
这是Struts2官方站点提供的Struts 2 的整体结构。 一个请求在Struts2框架中的处理大概分为以下几个步骤
1.客户端提起一个（HttpServletRequest）请求,如上文在浏览器中输 入”http://localhost:8080/TestMvc/add.action”就是提起一个（HttpServletRequest）请求。 2.请求被提交到一系列（主要是三层）的过滤器（Filter），如（ActionContextCleanUp、 其他过滤器（SiteMesh等）、 FilterDispatcher）。注意这里是有顺序的，先 ActionContextCleanUp，再其他过滤器（SiteMesh等）、最后到 FilterDispatcher。 3.FilterDispatcher是控制器的核心，就是mvc中c控制层的核心。下面粗略的分析下我理 解的FilterDispatcher工作流程和原理： FilterDispatcher进行初始化并启用核心doFilter 其代码如下： public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain ) throws IOException, ServletException { HttpServletRequest request = (HttpServletRequest) req; HttpServletResponse response = (HttpServletResponse) res; ServletContext servletContext = filterConfig.getServletContext(); // 在这里处理了HttpServletRequest和HttpServletResponse。 DispatcherUtils du = DispatcherUtils.getInstance(); du.prepare(request, response);//正如这个方法名字一样进行locale、encoding 以及特殊request parameters设置 try { request = du.wrapRequest(request, servletContext);//对request进行包装 } catch (IOException e) { String message = "Could not wrap servlet request with MultipartReques tWrapper!"; LOG.error(message, e); throw new ServletException(message, e); } ActionMapperIF mapper = ActionMapperFactory.getMapper();//得到action的mapper
第一章lectery的学习笔记 1.1Eclipse下搭建Struts2开发环境 博客分类： Java EclipseTomcatJSPStrutsJDK 作者：bukebushuo 来源：https://www.doczj.com/doc/307873572.html,/bukebushuo/archive/2007/03/29/1545728.aspx 最近下载了最新的struts 2.06,在使用其中附带的例子时，在配置上遇到了一些问题。 经过很多次的努力后，终于配置成功。现在把配置过程写出来供大家参考！ 一软件：1 Eclipse+lomboz 3.2 下载地址： https://www.doczj.com/doc/307873572.html,/project/showfiles.php?group_id=97&release_id= 1864（网页） https://www.doczj.com/doc/307873572.html,/project/download.php?group_id=97&file_id=7714（文件），不保证一直有效。 2 Tomcat 5.5 下载地址：https://www.doczj.com/doc/307873572.html,/download-55.cgi https://www.doczj.com/doc/307873572.html,/mirrors/apache/tomcat/tomcat-5/v5.5.23/bin/apache -tomcat-5.5.23.zip 3 JDK 6 下载地址:https://www.doczj.com/doc/307873572.html,/javase/downloads/index.jsp 4 Struts2.06
下载地址:https://www.doczj.com/doc/307873572.html,/download.cgi#struts201 二安装： 1 安装JDK6，按照自己喜欢的安装即可。JDK一定要在Eclipse之前安装，因为Eclipse的启动需要JDK。 2 安装Tomcat，我下载的Tomcat是直接解压缩版的，解压缩后拷贝到一个地方就可以了，拷贝后需要注意的是需要把JDK6目录中的 tools.jar拷贝到Tomcat中具体是JDK的lib目录下的tools.jar拷贝到Tomcat下common\lib中。 3 安装Eclipse，重点来了，解压缩下载的lomboz，应该得到一个eclipse目录，把这个目录拷贝到一个比较容易找的地方。 解压缩的时候需要注意，在解压缩过程中可能遇到文件路径过长的问题，我的解决方法是把下载下来的压缩包名重命名为1.zip，也就是尽量缩短文件名长度。然后解压缩的时候直接解压缩到某个硬盘的根目录下，解压缩完后再拷贝到自己想要的地方。 4, 解压缩Struts2.06，把下载下来的Struts2.06压缩包解压缩到一个目录中在他的APPS目录下有几个.war文件。 可以使用WINRAR打开，这里我们仅仅使用winrar把struts2-blank-2.0.6.war文件解压缩到本目录中就可以了。 三、配置 1：配置工作目录 第一次打开Eclipse时会要求你指定你的工作目录，请选择好你的工作目录，今后你的Eclipse的相关项目的配置就放在这个目录里。 2：配置JREs 打开配置对话框