BlogJava-<font color="red">JRen</font><font color="lightgreen">大鹏一曰同风起，扶摇直上九万里</font>-随笔分类-Strutshttp://www.blogjava.net/liaojiyong/category/11436.htmlzh-cnWed, 16 May 2007 07:36:47 GMTWed, 16 May 2007 07:36:47 GMT60Struts ActionForm的优化写法（转）http://www.blogjava.net/liaojiyong/archive/2007/05/16/117833.htmlliaojiyongliaojiyongWed, 16 May 2007 06:25:00 GMThttp://www.blogjava.net/liaojiyong/archive/2007/05/16/117833.htmlhttp://www.blogjava.net/liaojiyong/comments/117833.htmlhttp://www.blogjava.net/liaojiyong/archive/2007/05/16/117833.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/117833.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/117833.html阅读全文

liaojiyong 2007-05-16 14:25 发表评论
]]>tiles-struts(转)http://www.blogjava.net/liaojiyong/archive/2007/03/26/106309.htmlliaojiyongliaojiyongMon, 26 Mar 2007 01:38:00 GMThttp://www.blogjava.net/liaojiyong/archive/2007/03/26/106309.htmlhttp://www.blogjava.net/liaojiyong/comments/106309.htmlhttp://www.blogjava.net/liaojiyong/archive/2007/03/26/106309.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/106309.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/106309.htmlJavaServer Pages (JSPs)-based implementation, where HTML pages are converted into servlets and JSPs, UI developers identify common HTML and JSP view components, such as header, footer, body, menu, and search. This article presents various solutions to effectively and efficiently organize HTML and JSP view components. I evaluate each solution using specific criteria, such as page number, code repetition, and layout control.

To eXPlore templating and layout solutions, we will use the Tiles framework. The Tiles framework's view components are known as tiles. The framework uses an XML configuration file to organize those tiles. This framework not only enables you to reuse tiles, but also the layouts that organize them.

To eXPlore the more powerful and flexible solutions, we will investigate the synergy between the Tiles and Struts frameworks. Struts is an open source framework for developing Web applications using the popular Model-View-Controller (MVC) or Model 2 architectural pattern. Struts comes with a large set of reusable tags for which the Tiles tag library makes an Excellent enhancement.

Evaluation criteria
I will evaluate each solution based on the criteria below. The criteria are not mutually exclusive. For a specific situation and particular application, you must always balance between the strengths and weaknesses of each solution with respect to these factors.

Page number
A solution should strive to minimize the number of HTML and JSP pages. As the page number increases, the complexity of developing, managing, and maintaining an application increases drastically.

Code repetition
Under most circumstances, repetition is bad. The more repeated HTML and JSP code, the more difficult it is to develop and maintain an application. A simple change can result in a cascade of changes in many different pages with unpredictable consequences. A concrete and practical way of attaining reuse is to avoid code repetition.

Layout control
While code repetition is bad, repetition of layout logic and code can be worse. Spreading the logic and behavior of view component organization over several JSPs can be a recipe for disaster. Attaining reuse of templating and layout logic is a better form of reuse than only reusing view components. Thus, you can achieve a higher level of reuse with effective layout control.

Coupling
Coupling is the degree of interactivity between entities. Software engineers are taught again and again to minimize coupling between unrelated classes, packages, and so on. We can apply the same principle to view components. Even though there are distinct view components from a user perspective, in the JSP implementation, the components might be intricately coupled. A solution should reduce coupling between unrelated view components.

Complexity
Complexity brings increased development and maintenance costs, making a more complex solution less suitable. Complexity grows fast as well, and what might originally look simple and innocuous can quickly turn into a big mess as you add more pieces.

Solutions
I'll evaluate several solutions using a basic example of JSPs with common view components, like header and footer. I'll present these solutions in order of increasing complexity, and then I'll measure in detail each one against the evaluation criteria.

Solution 1: Basic JSP
Consider the following JSP for a.jsp:

<html>

<body>

Header
<p>

a's body...
<p>

Footer
<p>

</body>

</html>

Consider the following JSP for b.jsp:

<html>

<body>

Header
<p>

b's body...
<p>

Footer
<p>

</body>

</html>

In many cases, the developers obtain the code from the UI group and literally convert it into a JSP as necessary. As shown above, each JSP has a duplicate header and footer. Solution 1 is undesirable because changes in common view components, like header and footer, require changes in all relevant pages, as each page is responsible for laying out the view components. This simple solution lacks foresight. With so much HTML and JSP code duplication, we minimize the number of pages but at a heavy maintenance cost. There is strong coupling between the different view components, which, as I eXPlained earlier, is undesirable.

Solution 2: JSP include
Consider the following JSP for a.jsp:

<html>
<body>

<%-- include header --%>
<jsp:include page="/header.jsp" />

a's body...
<p>

<%-- include footer --%>
<jsp:include page="/footer.jsp" />

</body>
</html>

Consider the following JSP for b.jsp:

<html>
<body>

<%-- include header --%>
<jsp:include page="/header.jsp" />

b's body...
<p>

<%-- include footer --%>
<jsp:include page="/footer.jsp" />

</body>
</html>

Note that common view components, like header and footer, are split up using the JSP include mechanism.

Consider this header.jsp:

Header
<p>

Consider this footer.jsp:

Footer
<p>

Solution 2 nicely addresses some of Solution 1's major shortcomings. You only need to change common view components once. Hence, this solution greatly eliminates HTML and JSP code repetition, significantly improving application maintainability. It increases the page number a bit, but drastically reduces the tight coupling between common view components and other pages. On the complexity scale, this solution is simple and readily implemented on many real-world applications. However, it has one major drawback: if you change how and where you organize the view components (i.e., by changing the component layout), then you would need to update every page -- resulting in an eXPensive and prohibitive change. Solution 2 achieves view component reuse, but does not achieve the reuse of layout and templating logic.

Solution 3: Tiles insert
Consider this JSP for a.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<html>
<body>

<%-- include header --%>
<tiles:insert page="/header.jsp" flush="true"/>

a's body...
<p>

<%-- include footer --%>
<tiles:insert page="/footer.jsp" flush="true"/>

</body>
</html>

Consider this JSP for b.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<html>
<body>

<%-- include header --%>
<tiles:insert page="/header.jsp" flush="true"/>

b's body...
<p>

<%-- include footer --%>
<tiles:insert page="/footer.jsp" flush="true"/>

</body>
</html>

Instead of using the JSP include mechanism, Solution 3 uses the Tiles insert mechanism. Using the Tiles insert tag, you include the view components in the appropriate positions. In all other ASPects, the solution mirrors the JSP include solution (Solution 2) exactly, with the same advantages and disadvantages.

Solution 4: Splitting bodies
Consider this a.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<html>
<body>

<%-- include header --%>
<tiles:insert page="/header.jsp" flush="true"/>

<%-- include body --%>
<tiles:insert page="aBody.jsp" flush="true"/>

<%-- include footer --%>
<tiles:insert page="/footer.jsp" flush="true"/>

</body>
</html>

Consider this b.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<html>
<body>

<%-- include header --%>
<tiles:insert page="/header.jsp" flush="true"/>

<%-- include body --%>
<tiles:insert page="bBody.jsp" flush="true"/>

<%-- include footer --%>
<tiles:insert page="/footer.jsp" flush="true"/>

</body>
</html>

Solution 4 differs slightly from the Tiles insert solution. Solution 4 separates the core bodies into their individual pages, like aBody.jsp and bBody.jsp.

Consider the following JSP for aBody.jsp:

a's body...
<p>

Consider the following JSP for bBody.jsp:

b's body...
<p>

Solution 4's advantage: it limits body changes to the respective pages. Also, it lets you reuse the bodies in other places, eliminating the need for repetition and duplication. Thus, the solution further diminishes the coupling between common view components and other application components. Creating and managing each body component introduces an additional complexity level. As with other solutions, each page still does its own layout. Hence, there is no overarching layout policy or scheme.

Solution 5: Templating tiles
Using Tiles's templating feature, you can define the following layout (from the layout.jsp file shown below) as a template. Since this is a layout, you insert placeholders instead of the actual view components using the Tiles insert tag. Thus, for all components, this page defines one reusable layout:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<html>
<body>

    <%-- include header --%>
    <tiles:insert attribute="header"/>
    
    <%-- include body --%>
    <tiles:insert attribute="body"/>
    
    <%-- include footer --%>
    <tiles:insert attribute="footer"/>

</body>
</html>

Other content pages, like a.jsp and b.jsp, use the above layout for arranging components. In the actual page, you insert the layout using the Tiles insert tag. Using the Tiles put tag, you can specify the actual view components for all placeholders specified in the layout.

Consider this a.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<tiles:insert page="/layout.jsp" flush="true">
    <tiles:put name="header" value="/header.jsp"/>
    <tiles:put name="body" value="/aBody.jsp"/>
    <tiles:put name="footer" value="/footer.jsp"/>    
</tiles:insert>

Consider this b.jsp:

<%@ taglib uri="/WEB-INF/tiles.tld" prefix="tiles" %>

<tiles:insert page="/layout.jsp" flush="true">
    <tiles:put name="header" value="/header.jsp"/>
    <tiles:put name="body" value="/bBody.jsp"/>
    <tiles:put name="footer" value="/footer.jsp"/>    
</tiles:insert>

Solution 5's most significant advantage is that it encapsulates the layout scheme or mechanism, drastically reducing the coupling between common view components and other content bodies. However, it increases complexity by introducing another layout page. Understanding and implementing templating can also be difficult at first.

Solution 6: Struts and Tiles
The above layout page, layout.jsp, contains the HTML and JSP code for organizing the components. The content pages, a.jsp and b.jsp, do not contain any HTML code; they just contain the Tiles tags to insert the necessary components. Wouldn't it be nice to specify all the content pages in one XML configuration file?

Let's name that file tileDefinitions.XML and specify its pages as:

<?XML version="1.0" encoding="ISO-8859-1"?>
<component-definitions>
    <definition name="aDef" path="/layout.jsp">
        <put name="header" value="/header.jsp"/>
        <put name="footer" value="/footer.jsp"/>
        <put name="body" value="/aBody.jsp"/>
    </definition>
    <definition name="bDef" path="/layout.jsp">
        <put name="header" value="/header.jsp"/>
        <put name="footer" value="/footer.jsp"/>
        <put name="body" value="/bBody.jsp"/>
    </definition>
    <definition name="cDef" path="/layout.jsp">
        <put name="header" value="/header.jsp"/>
        <put name="footer" value="/footer.jsp"/>
        <put name="body" value="/cBody.jsp"/>
    </definition>
</component-definitions>

Solution 6 eliminates all the content pages, like a.jsp and b.jsp, by putting their definitions in the XML file. Since a resource like a.jsp no longer exists, how can we request it? More importantly, how can we request the definitions in the tileDefinitions.XML file?

The powerful and synergistic integration of Struts and Tiles comes to the rescue. Besides the regular Struts configuration parameters, we specify the configuration file's location as another parameter in the web.XML file, as shown below. Specifying the definitions-config parameter enables Struts to find and know about the Tiles definitions:

  <!-- Standard Action Servlet Configuration (with debugging) -->
  <servlet>
    <servlet-name>action</servlet-name>
<!--
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
-->
    <servlet-class>org.apache.struts.tiles.ActionComponentServlet</servlet-class>
    <init-param>
        <param-name>definitions-config</param-name>
        <param-value>/WEB-INF/tileDefinitions.XML</param-value>
    </init-param>
    ...
  </servlet>

Now, we define a Struts action, which returns a definition specified in the configuration file upon success. The Struts action DoFirst is a nonoperational action, as shown below:

package com.malani.struts.action;

import org.apache.struts.action.*;
import Javax.servlet.http.*;

public class DoFirst extends Action {

    public ActionForward perform(
        ActionMapping aMapping,
        ActionForm aForm,
        HttpServletRequest aRequest,
        HttpServletResponse aResponse
    ) {
        return aMapping.findForward("success");
    }

}

You cannot invoke a definition directly from the browser, but you can invoke one from Struts as if it is an actual resource. Define the Struts actions in the struts-config.XML file as shown below:

    <action path="/a"
            type="com.malani.struts.action.DoFirst"
    >
        <forward name="success" path="aDef"/>
    </action>

    <action path="/b"
            type="com.malani.struts.action.DoFirst"
    >
        <forward name="success" path="bDef"/>
    </action>

    <action path="/c"
            type="com.malani.struts.action.DoFirst"
    >
        <forward name="success" path="cDef"/>
    </action>

Now, invoke the Struts action by requesting a.do and b.do actions respectively to return the desired resource.

Solution 6's main advantage is that it consolidates all definitions in an XML configuration file. Eliminating the content pages drastically reduces the total page number. By introducing Struts, we turn up the complexity another notch.

Solution 7: Tiles inheritance
In the definitions configuration file, observe that each page's definition looks similar. Each definition has three components, two of which are fixed as header and footer. A powerful Tiles feature enables inheritance between definitions. Hence, you can define a base definition and let the original definitions inherit from that definition. The original definitions must only supply their unique part. The following shows the XML configuration file with inheritance between definitions:

<?XML version="1.0" encoding="ISO-8859-1"?>
<component-definitions>
    <definition name="baseDef" path="/layout.jsp">
        <put name="header" value="/header.jsp"/>
        <put name="footer" value="/footer.jsp"/>
        <put name="body" value=""/>
    </definition>
    <definition name="aDef" extends="baseDef">
        <put name="body" value="/aBody.jsp"/>
    </definition>
    <definition name="bDef" extends="baseDef">
        <put name="body" value="/bBody.jsp"/>
    </definition>
    <definition name="cDef" extends="baseDef">
        <put name="body" value="/cBody.jsp"/>
    </definition>
</component-definitions>

Elimination of duplicate and redundant information in the configuration file is an advantage of this solution. Overall, the advantages and disadvantages of this solution are identical to the Struts and Tiles solution.

Solution summary
The following table summarizes the different solutions with respect to the evaluation criteria. I encourage you to add other creative solutions as well as other important evaluation criteria, such as extensibility, maintainability, and performance.

Evaluate various solutions per specified criteria

SolutionPage numberCode repetitionLayout controlCouplingComplexity
1: Basic*********
2: JSP include********
3: Tiles insert********
4: Splitting bodies***********
5: Templating tiles**********
6: Struts and Tiles**********
7: Tiles inheritance**********
Scale: High: ***   Medium: **   Low: *

The table shows that each solution's complexity level gradually increases. It also shows that as you increase complexity, you reduce code repetition, increase layout-control flexibility, and diminish coupling between unrelated view components. The page number initially increases as various view components split, but as you define more pages in a definitions configuration file, consolidation will occur.

Divine design
In this article, I evaluated various solutions for organizing view components in HTML and JSPs. I also eXPlored the synergy between the Struts and Tiles frameworks. These strategies and solutions will help you make informed design and architectural decisions regarding your Web applications.

I would sincerely like to thank Max Cooper, Stephen Ditlinger, Dru Jensen, Phillip Lindsay, Roshni Malani, Danny Trieu, and Clare Zhang for reviewing this article.Javaworld/Javaworld/icons/jw-dingbat.gif" width=22>


Printer-friendly versionJavaworld.com/images/jw-print-icon.gif" width=16 align=absMiddle vspace=4 border=0> Javaworld.com/Javaworld/jw-01-2002/jw-0104-tilestrut_p.html">Printer-friendly versionSend this article to a friendJavaworld.com/images/jw-email-icon.gif" width=20 border=0> Javascript:mail2Friend()">Mail this to a friend

About the author
Javascript:openBrWindow()">Prakash Malani has extensive eXPerience in designing and developing object-oriented software using Java and C++. He has been developing software in many application domains, such as e-commerce, retail, medicine, communications, and interactive television. He practices leading technologies, such as object-oriented analysis & design (OOAD), the Unified Modeling Language (UML), XML, Enterprise JavaBeans (EJBs), JavaServer Pages (JSPs), and more. He teaches Java and related technologies at various institutions, including University of California, Irvine and California State Polytechnic University, Pomona.

    Resources
  • Download the complete source code for Solution 1. Basic JSP:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/1_basic.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/1_basic.zip
  • Download the complete source code for Solution 2. JSP include:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/2_JSPinclude.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/2_JSPinclude.zip
  • Download the complete source code for Solution 3. Tiles insert:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/3_tilesInsert.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/3_tilesInsert.zip
  • Download the complete source code for Solution 4. Splitting bodies:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/4_bodies.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/4_bodies.zip
  • Download the complete source code for Solution 5. Templating tiles:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/5_templatingTiles.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/5_templatingTiles.zip
  • Download the complete source code for Solution 6. Struts and Tiles:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/6_struts.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/6_struts.zip
  • Download the complete source code for Solution 7. Tiles inheritance:
    Javaworld.com/Javaworld/jw-01-2002/tilestrut/7_inheritance.zip">http://www.Javaworld.com/Javaworld/jw-01-2002/tilestrut/7_inheritance.zip
  • The Tiles framework:
    http://www.lifl.fr/~dumoulin/tiles/
  • See also "Strut Your Stuff with JSP Tags," Thor Kristmundsson (JavaWorld, December 2000):
    Javaworld.com/Javaworld/jw-12-2000/jw-1201-struts.html">http://www.Javaworld.com/Javaworld/jw-12-2000/jw-1201-struts.html
  • Java Servlet and JavaServer Pages specification:
    Java/communityprocess/final/jsr053/">http://www.jcp.org/aboutJava/communityprocess/final/jsr053/
  • Browse JavaWorld's Servlets Index:
    Javaworld.com/channel_content/jw-servlets-index.shtml">http://www.Javaworld.com/channel_content/jw-servlets-index.shtml
  • Browse JavaWorld's JavaServer Pages Index:
    Javaworld.com/channel_content/jw-jsp-index.shtml">http://www.Javaworld.com/channel_content/jw-jsp-index.shtml
  • Browse JavaWorld's User Interface Design Index:
    Javaworld.com/channel_content/jw-ui-index.shtml">http://www.Javaworld.com/channel_content/jw-ui-index.shtml
  • Subscribe to JavaWorld's free weekly email newsletters:
    Javaworld.com/subscribe">http://www.Javaworld.com/subscribe
  • Speak out in JavaWorld's Java Forum:
    http://forums.devworld.com/webx?13@@.ee6b802
  • You'll find a wealth of IT-related articles from our sister publications at .net/jump?id=1100">IDG.net


liaojiyong 2007-03-26 09:38 发表评论
]]>Struts+Hibernate中解决汉字编码问题（转）http://www.blogjava.net/liaojiyong/archive/2007/03/23/105721.htmlliaojiyongliaojiyongFri, 23 Mar 2007 01:42:00 GMThttp://www.blogjava.net/liaojiyong/archive/2007/03/23/105721.htmlhttp://www.blogjava.net/liaojiyong/comments/105721.htmlhttp://www.blogjava.net/liaojiyong/archive/2007/03/23/105721.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/105721.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/105721.htmlUTF-8格式，至于为什么要采用UTF-8.　　
<%@ page language="java" contentType="text/html; charset=utf-8" %>

2. struts框架提供了资源信息文件，它包含了jsp页面内容的一些文字说明，以及另一些供代码中使用的信息输出等（说白了，就是些文字描述定义，可以当成变量看待）。
ApplicationResources.properties（默认的是英文ApplicationResources.properties一份，命名为：ApplicationResources_zh_CN.properties 简体中文
ApplicationResources_zh_TW.properties 繁体中文
　
然后,执行JDK自带的命令如下：
native2ascii -encoding gb2312 ApplicationResources_demo.properties ApplicationResources_zh_CN.properties
3. struts中，对于中文参数的传递的文字编码处理，一般加个过滤器类就可以了的。
java源代码如下：

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.UnavailableException;


public class SetCharacterEncodingFilter implements Filter
{
 protected String encoding = null;
 protected FilterConfig filterConfig = null;
 protected boolean ignore = true;
 
 public void destroy()
 {
  this.encoding = null;
  this.filterConfig = null;
 }

 public void doFilter(ServletRequest request, ServletResponse response,FilterChain chain)
   throws IOException, ServletException
 {
  if (ignore || (request.getCharacterEncoding() == null))
  {
   String encoding = selectEncoding(request);
   if (encoding != null)
    request.setCharacterEncoding(encoding);
  }
  chain.doFilter(request, response);
 }

 public void init(FilterConfig filterConfig) throws ServletException
 {
  this.filterConfig = filterConfig;
  this.encoding = filterConfig.getInitParameter("encoding");
  String value = filterConfig.getInitParameter("ignore");
  if (value == null)
   this.ignore = true;
  else if (value.equalsIgnoreCase("true"))
   this.ignore = true;
  else if (value.equalsIgnoreCase("yes"))
   this.ignore = true;
  else
   this.ignore = false;
 }

 protected String selectEncoding(ServletRequest request)
 {
  return (this.encoding);
 }
}
4.  配置web.xml文件

  在<web-app>下加下面的代码

<filter>
 <filter-name>Set Character Encoding</filter-name>
 <filter-class>com.zxjsoft.util.SetCharacterEncodingFilter</filter-class>
 <init-param>
  <param-name>encoding</param-name>
  <param-value>utf-8</param-value>
 </init-param>
 <init-param>
  <param-name>ignore</param-name>
  <param-value>true</param-value>
 </init-param>
</filter>

<filter-mapping>
 <filter-name>Set Character Encoding</filter-name>
 <servlet-name>action</servlet-name>
</filter-mapping>

5.对于hibernate如说 还得配置hibernate.cfg.xml文件
 在文件里加入
 <property name="hibernate.connection.useUnicode">true</property>
 <property name="hibernate.connection.characterEncoding">UTF-8(或者gb2312)</property>



liaojiyong 2007-03-23 09:42 发表评论
]]>struts多国语言国际化处理(现以中文英文切换为例) （转）http://www.blogjava.net/liaojiyong/archive/2007/03/23/105717.htmlliaojiyongliaojiyongFri, 23 Mar 2007 01:39:00 GMThttp://www.blogjava.net/liaojiyong/archive/2007/03/23/105717.htmlhttp://www.blogjava.net/liaojiyong/comments/105717.htmlhttp://www.blogjava.net/liaojiyong/archive/2007/03/23/105717.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/105717.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/105717.html1.引言
  因为最近有个英国的项目要求中英文切换，又由于我们开发是用struts+hibernate的，所以我们就把原先做两个版本的构思抛掉，就用struts的国际化处理方案。
2.资料
  首先，我们要准备两份配置文件中文和英文的
  中文:ApplicationResources_zh_CN.properties
  英文:ApplicationResources_en.properties  (千万不要用默认的ApplicationResources.properties myeclipse自动生成，可能会不成功，我起先就是因为这个怎么都不行的，呵呵！)
3.准备开始
1) ApplicationResources_zh_CN.properties的内容
#zh_CN
username=纯冰
2)ApplicationResources_en.properties的内容
#en
username=chunkyo
3)一个action
/*
 * Generated by MyEclipse Struts
 * Template path: templates/java/JavaClass.vtl
 */
package com.lan.struts.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import org.apache.struts.Globals;
import java.util.Locale;

/**
 * MyEclipse Struts
 * Creation date: 02-07-2007
 *
 * XDoclet definition:
 * @struts.action validate="true"
 */
public class ChangeLanguageAction extends Action {
 /*
  * Generated Methods
  */

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  */
 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response) {
  // TODO Auto-generated method stub
  String lan=request.getParameter("lan");
  if(lan.equals("1"))
  {
   request.getSession().setAttribute(Globals.LOCALE_KEY,Locale.CHINA);
  }
  else if(lan.equals("0"))
  {
   request.getSession().setAttribute(Globals.LOCALE_KEY,Locale.ENGLISH);
  }
  else
  {
   request.getSession().setAttribute(Globals.LOCALE_KEY,Locale.CHINA);
  }
  return mapping.findForward("index");
 }
}

4)一个页面
<%@ page language="java" pageEncoding="utf-8"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html" %>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-logic" prefix="logic" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html locale="true">
  <head>
    <html:base />
   
    <title><bean:message key="username"/></title>

 <meta http-equiv="pragma" content="no-cache">
 <meta http-equiv="cache-control" content="no-cache">
 <meta http-equiv="expires" content="0">   
 <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
 <meta http-equiv="description" content="This is my page">
 <!--
 <link rel="stylesheet" type="text/css" href="styles.css">
 -->

  </head>
 
  <body>
    <html:link page="/changeLanguage.do?lan=0">English</html:link>
    <html:link page="/changeLanguage.do?lan=1">Chinese</html:link>
    <bean:message key="username"/>
  </body>
</html:html>
4)配置文件(struts-config.xml)
<?xml version="1.0" encoding="UTF-8"?>
<!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>
  <data-sources />
  <form-beans />
  <global-exceptions />
  <global-forwards >
    <forward name="index" path="/index.jsp" />

  </global-forwards>

  <action-mappings >
    <action path="/changeLanguage" type="com.lan.struts.action.ChangeLanguageAction" />

  </action-mappings><message-resources parameter="com.lan.struts.ApplicationResources" />
</struts-config>

5)结果
 1。默认
http://localhost:8080/lan/
EnglishChinese 纯冰
2。英文
http://localhost:8080/lan/changeLanguage.do?lan=0
EnglishChinese chunkyo
3。中文
http://localhost:8080/lan/changeLanguage.do?lan=1
EnglishChinese 纯冰
6)结论
用struts做国际化处理 多国语言处理很方便 呵呵！



liaojiyong 2007-03-23 09:39 发表评论
]]>Struts2与Struts1的对比 http://www.blogjava.net/liaojiyong/archive/2007/01/12/93428.htmlliaojiyongliaojiyongFri, 12 Jan 2007 06:30:00 GMThttp://www.blogjava.net/liaojiyong/archive/2007/01/12/93428.htmlhttp://www.blogjava.net/liaojiyong/comments/93428.htmlhttp://www.blogjava.net/liaojiyong/archive/2007/01/12/93428.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/93428.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/93428.htmlAction 类:
• Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
• Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现 常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
线程模式:
• Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
• Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存在的JavaBean（仍然会导致有冗余的javabean）。
• Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种ModelDriven 特性简化了taglib对POJO输入对象的引用。

表达式语言：
• Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
• Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).

绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
　
类型转换：
• Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。

校验：
• Struts 1支持在ActionForm的validate方法中手动校验，或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。
• Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性

Action执行的控制：
• Struts1支持每一个模块有单独的Request Processors（生命周期），但是模块中的所有Action必须共享相同的生命周期。
• Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。



liaojiyong 2007-01-12 14:30 发表评论
]]>完全解决java开发中的中文问题（侧重struts（转）http://www.blogjava.net/liaojiyong/archive/2006/09/01/67079.htmlliaojiyongliaojiyongFri, 01 Sep 2006 05:42:00 GMThttp://www.blogjava.net/liaojiyong/archive/2006/09/01/67079.htmlhttp://www.blogjava.net/liaojiyong/comments/67079.htmlhttp://www.blogjava.net/liaojiyong/archive/2006/09/01/67079.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/67079.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/67079.html 

       在做java开发的过程中一开始就碰到中文问题，刚接触到java时用的编译器是JCreate,这是个非常好用简单的java编译器，
但他就在对中文的支持上有很大问题，当时我就在想中国这么大的国家为什么在世界上总是比不过那些小国家，最严重的是有日文开发文档
就是没有中文的，所以我们在开发java的时候总是会碰到中文问题。下面我就来说一下我在开发中是如何来处理中文的。
      首先讲中文的字符的编码，刚开始中文的编码是GB2312后来发现他的常用字根本不能适应现在的需求，所以就在他的基础上增加了很多
生僻字，不常用字得到了新的编码GBK，我们一般来说都用GBK来实现我们的开发，而如果说到国际化就不得不提Unicode （统一码）顾名思
义是一个将世界上各种文字统一在一起的东东。由美国各大电脑厂商组成的Unicode策进会来推动。目的，推广一个世界通用的编码体制，
惊世界上所有常用的文字都涵盖进去，从而减少个电脑商开发国外市场遇到的问题。
        这些编码系统也会互相冲突。也就是说，两种编码可能使用相同的数字代表两个不同的字符，或使用不同的数字代表相同的字符。任何
一台特定的计算机(特别是服务器)都需要支持许多不同的编码，但是，不论什么时候数据通过不同的编码或平台之间，那些数据总会有损坏
的危险。
    Unicode给每个字符提供了一个唯一的数字，不论是什么平台，不论是什么程序，不论什么语言。Unicode标准已经被这些工业界的领导
们所采用，例如：Apple, HP, IBM, JustSystem, Microsoft, Oracle, SAP, Sun, Sybase, Unisys和其它许多公司。最新的标准都需要
Unicode，例如XML, Java, ECMAScript (JavaScript), LDAP, CORBA 3.0, WML等等，并且，Unicode是实现ISO/IEC 10646的正规方式。许多
操作系统，所有最新的浏览器和许多其他产品都支持它。Unicode标准的出现和支持它工具的存在，是近来全球软件技术最重要的发展趋势。
       而Unicode4.0后有了UTF (Unicode/UCS Transformation Format),Unicode推荐使用UTF-8和UTF-16两种格式其中8和16指的是Bits数而不
是Bytes数。
UTF-16基本就是Unicode双字节的实现，加上一个应付未来需要的扩充编码机制（很少用）
UTF-8 是一种不等幅的编码方式，英数字（Ascii字码）保持原状，完全不受影响（因此不需要做转换），而其他汉字资料须透过程序来转换，
会[变胖]，因为每个字需要额外一个或两个Bytes来编码。
       下面我们来看看实战中我是如何做的：
    1.web.xml
 配置过滤器
 

1 <!--  Filter Configuration  -->
2   < filter >
3    < filter - name > Set Character Encoding </ filter - name >
4    < filter - class > cn.redstoneinfo.commons.web.EncodingFilter </ filter - class >   
 5   </ filter >
6

    
    2.EncodingFilter.java：

 1   // 这里设置的默认的编码,可以在web.xml中设置,如果不设就用这里的
 2   protected  String encoding  =   " UTF-8 " ;
  3
 4   protected   boolean  ignore  =   true ;
  5
 6   /*  
  7   * @see javax.servlet.Filter#init(javax.servlet.FilterConfig)
  8    */
 9   public   void  init(FilterConfig filterConfig)  throws  ServletException  {
 10   String paramValue  =  filterConfig.getInitParameter( " encoding " );
 11    if  (paramValue  !=   null )  {
 12     this .encoding  =  paramValue;
 13   }
14   String value  =  filterConfig.getInitParameter( " ignore " );
 15    if  (value  ==   null )
 16     this .ignore  =   true ;
 17    else   if  (value.equalsIgnoreCase( " true " ))
 18     this .ignore  =   true ;
 19    else   if  (value.equalsIgnoreCase( " yes " ))
 20     this .ignore  =   true ;
 21    else
22     this .ignore  =   false ;
 23  }
24

 

    3.Struts-config.xml:
 设置资源文件的路径
 

1 < message - resources
 2   parameter = " cn.redstoneinfo.oss.security.web.security-resource "  key = " SECURITY_RES "   null = " false " />
3   
 4   < message - resources
 5   parameter = " cn.redstoneinfo.oss.web.ApplicationResources "   null = " false " />
6

    4.role-list.jsp
 页面编码和调用资源
 

 1 <% @ page contentType = " text/html; charset=UTF-8 "  language = " java " %>  
  2         
  3   < oss:panel label = " security.role.list.title "  bundle = " SECURITY_RES " >
 4   < table width = " 100% " >
 5   < tr  class = " tr1 "  align = " center "  height = " 25 " >
 6       < td width = " 5% " >
 7       </ td >
 8       < td  >   
  9    < bean:message key = " app.common.name "   />
10       </ td >
11       < td  >
12       < bean:message key = " app.common.activeDate "   />
13       </ td >
14       < td >
15       < bean:message key = " app.common.inactiveDate "   />
16       </ td  >
17       < td >
18       < bean:message key = " app.common.status "   />
19       </ td >    
 20     
 21   </ tr >
22         
 23          < input type = " button "  value = "    <bean:message key= " app.common. new " /> "   class = " buttonnew "  onclick = " javascript:document.forms[0].act.value='add'; goUrlFormTarget('role.do', 'roleForm', 'roleTreeFrame'); " >     
 24


    5.ApplicationResources.properties
 

1 app.common.name  =  名字
 2  app.common.ip  =  IP
 3  app.common.port  =  端口
 4  app.common.status  =  状态 
 5

    6.build.xml
 编译资源文件生成Unicode

1   < native2ascii src = " ${oss.src.dir} "  encoding = " UTF-8 "  dest = " ${target.dir}/WEB-INF/classes " >
2     < include name = " **/*.properties "   />
3    </ native2ascii >   
 4

    7.转换后的ApplicationResources.properties
 

1 app.common.name  =  \u540d\u5b57
 2  app.common.ip  =  IP
 3  app.common.port  =  \u7aef\u53e3
 4  app.common.status  =  \u72b6\u6001
 5

    8.server.xml
 tomcat5.0以后post跟get提交方法不了不同的编码处理，应该用下面的方式来处理
    

1 < Connector
 2   port = " 8080 "                maxHttpHeaderSize = " 8192 "
3                maxThreads = " 150 "  minSpareThreads = " 25 "  maxSpareThreads = " 75 "
4                enableLookups = " false "  redirectPort = " 8443 "  acceptCount = " 100 "
5                connectionTimeout = " 20000 "  disableUploadTimeout = " true "   URIEncoding = " UTF-8 " />
6

    9.界面
11.gif
    以上操作基本实现彻底消灭中文乱码问题，当然还有其他更好的办法和应用，我们这里只讲struts的简单应用中如何避免相应问题的处理办法。



liaojiyong 2006-09-01 13:42 发表评论
]]>MyEclipse+struts+Hibernate配置开发（转）http://www.blogjava.net/liaojiyong/archive/2006/06/05/50452.htmlliaojiyongliaojiyongMon, 05 Jun 2006 04:38:00 GMThttp://www.blogjava.net/liaojiyong/archive/2006/06/05/50452.htmlhttp://www.blogjava.net/liaojiyong/comments/50452.htmlhttp://www.blogjava.net/liaojiyong/archive/2006/06/05/50452.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/50452.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/50452.html

　　建议：

　　如果你还不清楚struts和hibernate的一些基本原理，希望能先去了解一下这方面的相关内容。

　　推荐：

　　Hibernate中文手册》作者认为要学Hibernate看这个就足够了，里面几乎包括了所有的细节，不过可能不太适合快速入门。

　　地址：http://www.hibernate.org/hib_docs/v3/reference/zh- cn/html_single/

　　关于struts的资料就很多了，这里推荐一个可以下载一些入门教程的网站。

　　地址：http://www.wnetw.com/jclub/index.jsp

　　强烈建议入门的朋友先了解一下基本的原理！否则本文可能对你没有任何帮助。

　　相关工具下载：（注意版本）

　　mysql5.0 http://www.mysql.org
　　eclipse 3.1.1 http://www.eclipse.org
　　myeclipse4.0.3 http://www.myeclipseide.com
　　tomcat5.5

　　安装：

　　关于tomcat和mysql的安装就不多说了，需要注意的是最好保证你的 jdk是1.5的版本，并配置好你的环境变量，不然可能会遇到一些问题。

　　把eclipse解开，再去安装刚下载的myeclipse，在安装的时候需要把路径指定到刚才解开的eclipse上，由于myeclipse是个收费软件，所以需要注册。不过一般按照Chinese的习惯，去google一个注册码就可以了:}

　　开发环境部署：

　　好了，现在保证你的mysql和tomcat服务能够正常启动，myeclipse能够正常打开（如果不能，可以去找一下相关的说明或者给作者留言）。下面我们就要开始真正的开始部署一个传说中的tomcat+struts+hibernate+mysql结构的工程了！（faint!前言就写的我好累）

　　首先，在myeclipse里新建一个工程。在左边的Package Exporler面版里点右键选择new->project…

　　在跳出菜单里选择MyEclipse->J2EE Projects->Web Project。

　　点击next后进入如下画面：


　　工程名为：test

　　结束后点击Finish。

　　好了，如果成功的话你就会在 Package Exporler里看到一个新的test工程！现在我们先配置一下数据库方面的东西。首先在你的mysql 里建立一个数据库webases，再在里面新建一个表admin，里面三个字段分别为id,name,password其中id为自动取值的主键（mysql具体的操作可以自己找资料，不是本文涉及范围）。

　　再回到myeclipse ，选中window->Open Perspective->Other…

　　可以看到现在跳出一个名为Select Perspective的菜单，在里面选中MyEclipse Databases Exporler，可以看到现在到了下面的页面。

　　按以上图示输入相关字段后点击Finish便建立了一个数据库连接，在新出现的JDBC for Mysql上点右键，选择Open connection…，确认用户名和密码正确后点OK，如果一切顺利的话你会看到下面的画面：

　　这说明你已经和数据库建立了正确的连接。现在我们再回到window->Open Perspective- >Other…里的MyEclipse，也就是我们刚进来的时候看到的画面。

　　右键点击你刚建立的工程 test并选择MyEclipse->Add struts Capabilities…在跳出的菜单里按照如下输入并确定：

　　好了，现在你已经为你的工程增加了struts，接下来和上面一样在右键工程后选择MyEclipse- >Add Hibernate Capabilities…一路确定下来为你的工程添加Hibernate。（为方便起见我们在选择路径时把HibernateSessionFactory.java放在了src/com下面，其实最好建立个单独的目录如 src/com/hibernate）

　　为了更好的演示我们不建立通常的登陆页面而是建立个注册页面。选择 src目录下的hibernate.cfg.xml文件。照如下填写并保存。这样hibernate就为你建立了数据库的连接池。

　　下面我们再选择WebRoot/WEB-INF/struts-config.xml文件，在画面中点击右键选择new- >Form, Action and JSP。如下填写

　　再选择JSP选项，如下

　　最后选择Finish。

　　再新建一个一个success.jsp的页面，

　　在刚才struts- config.xml文件里右键选择addAdmin选择Properties，在菜单里选择Forwords，再点add，如下图填写

　　最后你的struts-config.xml就是下面这个样子：


　　下面我们转到hibernate。换到刚才我们建立数据库的页面，选择你的admin的表点右键选择Create Hibernate Mapping。选择好打包路径后选择Finish。如图：

　　在你刚才选择的路径下（我为方便是src/com/yourcompanyname/）下新建立的文件 AdminDAOFactory.java文件并输入以下内容：

package com.yourcompanyname;

import java.util.Iterator;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.hibernate.SessionFactory;

public class AdminDAOFactory {
 Session session;
 Transaction tx;
 public void add(Admin admin) throws HibernateException {
  /**
   * Creation Date: 11-17-2005
   * TODO Add a new admin user.
   * @param An object of Admin
   * @return void
   * @author Coder Guo
   */
  try {
   session = SessionFactory.currentSession();
   tx = session.beginTransaction();
   //Add a new admin
   session.save(admin);
   tx.commit ();
  }catch(HibernateException e){
   throw e;
  }finally{
   if (tx!=null) {
    tx.rollback();
   }
   SessionFactory.closeSession();
  }
 }
}

 再打开com.yourcompany.struts.action下的AddAdminAction.java添加（其中如果有错误选中好按ctrl+shift+o自动添加包）

public class AddAdminAction extends Action {

 // --------------------------------------------------------- Instance Variables

 // --------------------------------------------------------- Methods

 /**
  * Method execute
  * @param mapping
  * @param form
  * @param request
  * @param response
  * @return ActionForward
  * @author Coder Guo
  */
 public ActionForward execute(
  ActionMapping mapping,
  ActionForm form,
  HttpServletRequest request,
  HttpServletResponse response) {
  AddAdminForm addAdminForm = (AddAdminForm) form;
  
  // TODO Add a new admin
  Admin admin = new Admin();
  admin.setName(addAdminForm.getName ());
  admin.setPassword(addAdminForm.getPassword ());
  AdminDAOFactory adminDAO = new AdminDAOFactory ();
  adminDAO.add(admin);
  
  return mapping.findForward("success");
 }

}

 再打开com.yourcompanyname.struts.form下的AddAdminForm.java，修改（如果有错误按照上面说的方法导入包）
 public ActionErrors validate(
  ActionMapping mapping,
  HttpServletRequest request) {

  // TODO Auto-generated method stub
  ActionErrors errors = new ActionErrors();
  
  Session session = SessionFactory.currentSession();
  Transaction tx = session.beginTransaction ();
  Query query = session.createQuery("select admin from Admin as admin where admin.name = '" + this.name + "'");
  Iterator it = query.iterate ();
  if (it.hasNext()){
   errors.add ("addAdmin.err.name",new ActionMessage("form.addAdmin.err.name"));
  }
  tx.commit();
  SessionFactory.closeSession ();
  return errors;
 }

 public void reset(ActionMapping mapping, HttpServletRequest request) {

  // TODO Auto-generated method stub
  this.name=null;
  this.password=null;
 }

　　再打开com\yourcompanyname\struts下的ApplicationResource.properties在这里面添加错误信息：

Form.addAdmin.err.name=err

　　最后，（汗，好累啊-_-!）打开addAdmin.jsp修改成如下：

<%@ page contentType="text/html; charset=utf-8"%>
<%@ page language="java"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%>

<script language = "javascript">
<!--
function check(){
 if (loginForm.userName.value == "" || loginForm.password.value == ""){
  alert("请输入完整的信息！");
  loginForm.userName.focus();
  return false;
 }
}
//-->
</script>
 
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html>
  <head>
    <html:base />
   
    <title>login.jsp</title>
    <link href="css/webcss.css" rel="stylesheet" type="text/css">
   
    <meta http-equiv="pragma" content="no- cache">
    <meta http-equiv="cache-control" content="no- cache">
    <meta http-equiv="expires" content="0">   
    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
    <meta http- equiv="description" content="This is my page">
  </head>
 

  <body>
  <center>
   <p>&nbsp;</p>
   <p>&nbsp;</p>
   <table width="300" border="0" cellpadding="0" cellspacing="0">
   <html:form action="/addAdmin" focus="name" method="GET">
     <tr align="center" valign="middle">
       <td colspan="2" class="typt_normal">新增管理员</td>
     </tr>
     <tr>
       <td width="100" align="center" valign="middle" class="typt_normal">名称： </td>
       <td width="200" align="left"><html:text property="name" styleClass="text_s"/><html:errors property="addAdmin.err.name"/></td>
     </tr>
     <tr>
       <td width="100" align="center" valign="middle" class="typt_normal">密码： </td>
       <td width="200" align="left"><html:password property="password" styleClass="text_s"/></td>
     </tr>
     <tr> 
       <td colspan="2" align="center" valign="middle"><html:submit value="提交" onclick="return check ();"/><html:reset value="重置"></html:reset></td>
       </tr>
 </html:form>
   </table>
 </center>
 </body>

</html:html>

　　其中可以看到如何在struts的标签中使用javascript的方法。

　　配置好myeclipse于tomcat的连接。在window->Preferences做如下设定：

　　在项目文件点右键－>“myeclipse”－>“Add and remove project deployment”，如下图：

　　好了，我们的配置工作基本结束了,在myeclipse上开启tomcat服务

　　现在打开浏览器，输入

　　http://127.0.0.1:8080/test/addAdmin.jsp就可以看到你的jsp页面了！



liaojiyong 2006-06-05 12:38 发表评论
]]>在struts框架下实现文件的上传 (转)http://www.blogjava.net/liaojiyong/archive/2006/05/23/47693.htmlliaojiyongliaojiyongTue, 23 May 2006 10:03:00 GMThttp://www.blogjava.net/liaojiyong/archive/2006/05/23/47693.htmlhttp://www.blogjava.net/liaojiyong/comments/47693.htmlhttp://www.blogjava.net/liaojiyong/archive/2006/05/23/47693.html#Feedback0http://www.blogjava.net/liaojiyong/comments/commentRss/47693.htmlhttp://www.blogjava.net/liaojiyong/services/trackbacks/47693.html

由于jspsmartupload上传文件，当前端页面没有file控件时，后端用jspsmartupload控件upload时将会走入一个死循环。现在采用struts自己提供的功能实现文件的上传。
1、前端页面upload.jsp
<html:form action="/filesave.do" styleId="formItem" method="post"  enctype="multipart/form-data">
<INPUT  class='input-file' type="file" name="theFile">
</html:form>
2、struts-config.xml文件配置
<form-bean name="UploadForm" type="yhp.test.web.UploadForm" />
<action input="/upload.jsp" name="UploadForm"   path="/filesave" scope="request" type="yhp.test.web.UploadAction" validate="false">
      <forward name="success" path="/success.jsp" />
      <forward name="error" path="/error.jsp" />
    </action>
3、UploadForm.java文件
package yhp.test.web;

import org.apache.struts.upload.FormFile;
import org.apache.struts.action.ActionForm;

public class UploadForm extends ActionForm {
  protected String theText;   //使用protected ,其它需要上传的form可以继承此form
  protected boolean writeFile = true;
  protected FormFile theFile;
  protected String filePath;

  public String getTheText() {
    return theText;
  }
  public void setTheText(String theText) {
    this.theText = theText;
  }
  public FormFile getTheFile() {
    return theFile;
  }
  public void setTheFile(FormFile theFile) {
    this.theFile = theFile;
  }
  public void setWriteFile(boolean writeFile) {
    this.writeFile = writeFile;
  }
  public boolean getWriteFile() {
    return writeFile;
  }
  public void setFilePath(String filePath) {
    this.filePath = filePath;
  }
  public String getFilePath() {
    return filePath;
  }
  public void reset() {
    writeFile = false;
  }
}

4、UploadAction.java文件
package yhp.test.web;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;


public class UploadAction extends Action {
  public ActionForward execute(ActionMapping actionMapping,
                               ActionForm actionForm,
                               HttpServletRequest httpServletRequest,
                               HttpServletResponse httpServletResponse) throws
      Exception {
    if (actionForm instanceof UploadForm) {
      // 获取上传的目录
      String path = getServlet().getServletContext().getInitParameter("UPLOADPATH");
      File f = new File(path);
      if (!f.isDirectory()) {
        f.mkdir();
      }

      UploadForm theForm = (UploadForm) actionForm;
      String text = theForm.getTheText();
      FormFile file = theForm.getTheFile();
      String fileName = file.getFileName();
      String contentType = file.getContentType();
      boolean writeFile = theForm.getWriteFile();
      String desFileName=path fileName ;
      String size = (file.getFileSize() + " bytes");
      try {
          InputStream stream = file.getInputStream();
   OutputStream bos = new FileOutputStream(strFileName);         
          byte[] buffer = new byte[file.getFileSize()];
          stream.read(buffer);
          bos.write(buffer);
   stream.close(); 
          bos.close();
          return actionMapping.findForward("success");
      }
      catch (FileNotFoundException fnfe) {
          return actionMapping.findForward("success");
      }
      catch (IOException ioe) {
          return actionMapping.findForward("success");
      }
      catch(Exception eo){
          return actionMapping.findForward("error");
      } 
    }else{
      return actionMapping.findForward("error");
    }
  }
}



liaojiyong 2006-05-23 18:03 发表评论
]]>