Note: All built in webwork result types implement the com.opensymphony.xwork.Result interface, which represents a generic interface for all action execution results, whether that be displaying a webpage, generating an email, sending a JMS message, etc.

Result types define classes and map them to names to be referred in the action configuration results. This serves as a shorthand name-value pair for these classes.

Related Posts

• FreeMarker Result

The FreemarkarManager class configures the template loaders so that the template location can be either

• relative to the web root folder. eg /WEB-INF/views/home.ftl
• a classpath resuorce. eg /com/company/web/views/home.ftl

Parameters

* location (default) – the location of the template to process.

* parse – true by default. If set to false, the location param will not be parsed for Ognl expressions.

* contentType – defaults to “text/html” unless specified.

* writeIfCompleted – false by default, write to stream only if there isn’t any error processing the template. Setting template_exception_handler=rethrow in freemarker.properties will have the same effect.

Examples

<result name="success" type="freemarker">foo.ftl</result>

Of course, we can also omit the 'type' setting by setting the result type
of struts. Please refer to another article of this site - Struts result type.

Related Posts

• Struts2 Result Type

对于get方法来说，都是把数据串联在请求的url后面作为参数，如：http://localhost:8080/servlet?msg=abc
（很常见的一个乱码问题就要出现了，如果url中出现中文或其它特殊字符的话，如：http://localhost:8080 /servlet?msg=杭州，服务器端容易得到乱码），url拼接完成后，浏览器会对url进行URL encode，然后发送给服务器，URL encode的过程就是把部分url做为字符，按照某种编码方式（如：utf-8,gbk等）编码成二进制的字节码，然后每个字节用一个包含3个字符的字符串 “%xy” 表示，其中xy为该字节的两位十六进制表示形式。我这里说的可能不清楚，具体介绍可以看下java.net.URLEncoder类的介绍在这里。了解了 URL encode的过程，我们能看到2个很重要的问题，第一：需要URL encode的字符一般都是非ASCII的字符（笼统的讲），再通俗的讲就是除了英文字母以外的文字（如：中文，日文等）都要进行URL encode，所以对于我们来说，都是英文字母的url不会出现服务器得到乱码问题，出现乱码都是url里面带了中文或特殊字符造成的；第二：URL encode到底按照那种编码方式对字符编码？这里就是浏览器的事情了，而且不同的浏览器有不同的做法，中文版的浏览器一般会默认的使用GBK，通过设置浏览器也可以使用UTF-8，可能不同的用户就有不同的浏览器设置，也就造成不同的编码方式，所以很多网站的做法都是先把url里面的中文或特殊字符用 javascript做URL encode，然后再拼接url提交数据，也就是替浏览器做了URL encode，好处就是网站可以统一get方法提交数据的编码方式。 完成了URL encode，那么现在的url就成了ASCII范围内的字符了，然后以iso-8859-1的编码方式转换成二进制随着请求头一起发送出去。这里想多说几句的是，对于get方法来说，没有请求实体，含有数据的url都在请求头里面，之所以用URL encode，我个人觉的原因是：对于请求头来说最终都是要用iso-8859-1编码方式编码成二进制的101010…..的纯数据在互联网上传送，如果直接将含有中文等特殊字符做iso-8859-1编码会丢失信息，所以先做URL encode是有必要的。
2。服务器端（tomcat）是如何将数据获取到进行解码的。
第一步是先把数据用iso-8859-1进行解码，对于get方法来说，tomcat获取数据的是ASCII范围内的请求头字符，其中的请求url里面带有参数数据，如果参数中有中文等特殊字符，那么目前还是URL encode后的%XY状态，先停下，我们先说下开发人员一般获取数据的过程。通常大家都是request.getParameter(”name”)获取参数数据，我们在request对象或得的数据都是经过解码过的，而解码过程中程序里是无法指定，这里要说下，有很多新手说用 request.setCharacterEncoding(”字符集”)可以指定解码方式，其实是不可以的，看servlet的官方API说明有对此方法的解释：Overrides the name of the character encoding used in the body of this request. This method must be called prior to reading request parameters or reading input using getReader().可以看出对于get方法他是无能为力的。那么到底用什么编码方式解码数据的呢，这是tomcat的事情了，默认缺省用的是 iso-8859-1,这样我们就能找到为什么get请求带中文参数为什么在服务器端得到乱码了，原因是在客户端一般都是用UTF-8或GBK对数据 URL encode，这里用iso-8859-1方式URL decoder显然不行，在程序里我们可以直接
Java代码
1. new String(request.getParameter(”name”).getBytes(”iso-8859-1″),”客户端指定的URL encode编码方式”)
还原回字节码，然后用正确的方式解码数据，网上的文章通常是在tomcat里面做个配置
Xml代码
1.
这样是让tomcat在获取数据后用指定的方式URL decoder，URL decoder的介绍在这里
（一）post提交
1.客户端（浏览器）的form表单用post方法是如何将数据编码后提交给服务器端的。
在post方法里所要传送的数据也要URL encode，那么他是用什么编码方式的呢？
在form所在的html文件里如果有段，那么post就会用此处指定的编码方式编码。一般大家都认为这段代码是为了让浏览器知道用什么字符集来对网页解释，所以网站都会把它放在html代码的最前端，尽量不出现乱码，其实它还有个作用就是指定form表单的post方法提交数据的 URL encode编码方式。从这里可以看出对于get方法来数，浏览器对数据的URL encode的编码方式是有浏览器设置来决定，（可以用js做统一指定），而post方法，开发人员可以指定。
2。服务器端（tomcat）是如何将数据获取到进行解码的。
如果用tomcat默认缺省设置，也没做过滤器等编码设置，那么他也是用iso-8859-1解码的，但是request.setCharacterEncoding(”字符集”)可以派上用场。

我发现上面说的tomcat所做的事情前提都是在请求头里没有指定编码方式，如果请求头里指定了编码方式将按照这种方式编码。
有2篇文章推荐下，地址分别是
深入浅出URL编码：http://www.cnblogs.com/yencain/articles/1321386.html；
表单用post方法提交数据时乱码问题：http://wanghuan8086.javaeye.com/blog/173869

用post很重要的在form所在的html文件里如果有段
强烈建议使用post提交

详细出处参考：http://www.jb51.net/web/12714.html
http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html

Related Posts

• Java中replaceAll和split中的反斜杠
• Documentum API LIST_SESSIONS
• Webtop 6.5 SP1 LoadRunner
• Documentum Data Dictionary
• Get definition for view in Oracle

Remoting Service destinations use Java classes that you write to integrate with Flex clients. By default, BlazeDS creates these instances. If they are application-scoped components, they are stored in the ServletContext attribute space using the destination’s name as the attribute name. If you use session-scoped components, the components are stored in the FlexSession, also using the destination name as the attribute. If you specify an attribute-id element in the destination, you can control which attribute the component is stored in; this lets more than one destination share the same instance.

The following examples shows a destination definition that contains an attribute-id element:

<destination id="WeatherService">
    <properties>
        <source>weather.WeatherService</source>
        <scope>application</scope>
        <attribute-id>MyWeatherService</attribute-id>
    </properties>
</destination>

In this example, BlazeDS creates an instance of the class weather.WeatherService and stores it in the ServletContext object’s set of attributes with the name MyWeatherService. If you define a different destination with the same attribute-id value and the same Java class, BlazeDS uses the same component instance.

BlazeDS provides a factory mechanism that lets you plug in your own component creation and maintenance system to BlazeDS so it integrates with systems like EJB and Spring, which store components in their own namespace. You provide a class that implements the flex.messaging.FlexFactory interface. You use this class to create a FactoryInstance that corresponds to a component configured for a specific destination. Then the component uses the FactoryInstance to look up the specific component to use for a given request. The FlexFactory implementation can access configuration attributes from a BlazeDS configuration file and also can access FlexSession and ServletContext objects. For more information, see the documentation for the FlexFactory class in the public BlazeDS Javadoc documentation.

After you implement a FlexFactory class, you can configure it to be available to destinations by placing a factory element in the factories element in the services-config.xml file, as the following example shows. A single FlexFactory instance is created for each BlazeDS web application. This instance can have its own configuration properties, although in this example, there are no required properties to configure the factory.

<factories>
    <factory id="spring"/>
</factories>

BlazeDS creates one FlexFactory instance for each factory element that you specify. BlazeDS uses this one global FlexFactory implementation for each destination that specifies that factory by its ID; the ID is identified by using a factory element in the properties section of the destination definition. For example, your remoting-config.xml file could have a destination similar to the following one:

<destination id="WeatherService">
    <properties>
        <factory>spring</factory>
        <source>weatherBean</source>
    </properties>
</destination>

When the factory element is encountered at start up, BlazeDS calls the FlexFactory.createFactoryInstance() method. That method gets the source value and any other attributes it expects in the configuration. Any attributes that you access from the ConfigMap parameter are marked as expected and do not cause a configuration error, so you can extend the default BlazeDS configuration in this manner. When BlazeDS requires an instance of the component for this destination, it calls the FactoryInstance.lookup() method to retrieve the individual instance for the destination.

Optionally, factory instances can take additional attributes. There are two places you can do this. When you define the factory initially, you can provide extra attributes as part of the factory definition. When you define an instance of that factory, you can also add your own attributes to the destination definition to be used in creating the factory instance.

The boldface text in the following example shows an attribute added to the factory definition:

<factories>
    <factory id="myFactoryId">
        <properties>
            <myfactoryattributename>
                myfactoryattributevalue
            </myfactoryattributename>
        </properties>
    </factory>
</factories>

You could use this type of configuration when you are integrating with the Spring Framework Java application framework to provide the Spring factory with a default path for initializing the Spring context that you use to look up all components for that factory. In the class that implements FlexFactory, you would include a call to retrieve the values of the myfactoryattributename from the configMap parameter to the initialize() method in the FlexFactory interface, as the following example shows:

public void initialize(String id, ConfigMap configMap){
    System.out.println("**** MyFactory initialized with: " +
        configMap.getPropertyAsString("myfactoryattributename", "not set"));
}

The initialize() method in the previous example retrieves a string value where the first parameter is the name of the attribute, and the second parameter is the default value to use if that value is not set. For more information about the various calls to retrieve properties in the config map, see the documentation for the flex.messaging.config.ConfigMap class in the public BlazeDS Javadoc documentation. Each factory instance can add configuration attributes that are used when that factory instance is defined, as the following example shows:

<destination id="myDestination">
    <properties>
        <source>mypackage.MyRemoteClass</source>
        <factory>myFactoryId</factory>
        <myfactoryinstanceattribute>
            myfoobar2value
        </myfactoryinstanceattribute>
    </properties>
</destination>

In the createFactoryInstance() method as part of the FlexFactory implementation, you access the attribute for that instance of the factory, as the following example shows:

public FactoryInstance createFactoryInstance(String id, ConfigMap properties) {
    System.out.println("**** MyFactoryInstance instance initialized with myfactoryinstanceattribute=" +
    properties.getPropertyAsString("myfactoryinstanceattribute", "not set"));
….
}

All these info are from http://livedocs.adobe.com/blazeds/1/blazeds_devguide

Related Posts

• Flex LC DS FDS and BlazeDS

* Flex 1.5 – Released Nov 2004

* FDS (Flex Data Services) was decoupled from the Flex SDK in Flex 2.0 – Released 2006

* FDS was renamed LiveCycle Data Services – released as LC DS 2.5 in summer 2007

* LC DS 2.5.1 in fall 2007

* An open source version of remoting and messaging was released as Blaze DS in early 2008

* LC DS 2.6 was released in mid 2008

* LC DS 2.6.1 was released in Nov 2008

Related Posts

• BlazeDS factory mechanism

Client Coding

• Can I mix Smart GWT and GWT widgets?

  Yes, with caveats.

  Smart GWT has interoperability support that allows a Smart GWT widget to be added to a GWT
  container and allows a GWT widget to be added to a Smart GWT container, and it’s appropriate to
  use this for:

  • incremental migration to Smart GWT, such as introducing singular, sophisticated Smart GWT
    components like the Calendar or CubeGrid to an existing GWT application
  • using sophisticated third-party GWT widgets within Smart GWT, where Smart GWT doesn’t have
    corresponding built-in functionality

  However it does not make sense to freely intermix Smart GWT and GWT (or other)
  components, that is, for example, you should not place GWT widgets within a Smart GWT container
  that is in turn within a GWT container. In general, don’t intermix widgets unless the need for
  a feature forces you to.

  The reason for this is that there are limits to the maximum degree that two Ajax widget kits
  (including GWT) can interoperate – there are no standards that allow interoperability in the
  areas of management of tab order, zIndex management, pixel-perfect layout, section 508
  accessibility and multi-level modality.

  Note that “bugs” reported when intermixing GWT and Smart GWT inappropriately (that is, in
  contradiction to these guidelines) are generally going to be marked WONTFIX, although we will
  revisit this in the future if core GWT begins to support APIs that would allow better
  interoperability.

• How do I make a Smart GWT widget fill a basic HTML container or GWT container?

  Because Smart GWT’s pixel-perfect layout and auto-sizing support goes beyond the capabilities of
  simple CSS layout, components need to know the actual pixel width they have been allocated;
  they cannot “flow into” an HTML element of unspecified size.

  The issue here is that GWT’s containers do not provide an API similar to Smart GWT’s
  Canvas.getInnerWidth(), which in Smart GWT can be used by child components to find out
  the available space to draw themselves in, and hence recursively lay out out their own
  children. Nor do GWT containers they fire events when they are resized, or when the
  available width changes for various reasons (e.g. scrollbar(s) introduced, or CSS style
  changes add borders and hence reduce space).

  A lot of parent<->child coordination and signaling is required to really create an extensible
  pixel-perfect layout system. Smart GWT/SmartClient has implemented all the necessary hooks to
  allow a third-party widget to be embedded inside a Canvas and participate in a precise layout,
  but GWT is not there yet.

  If you absolutely must place a Smart GWT interface inside a GWT container and you want it to
  fill the container, the best approach is to listen for a window-level resize event and run
  your own layout calculations that ultimately call resizeTo() on your topmost Smart GWT
  widget. All Smart GWT widgets nested under that topmost widget will then handle layout normally.

  NOTE: Don’t bother trying to find a way to insert width:100% into Smart GWT’s rendered HTML,
  this won’t work.

Related Posts

• $wnd and $doc Calling native JavaScript with JSNI
• GWT and Documentum

Reference:
http://www.telio.be/blog/2006/01/06/ajax-upload-progress-monitor-for-commons-fileupload-example/

Related Posts

• JQuery ContextMenu plugin
• Remove Title and Rating on Embeded YouTube Videos
• Cool effect
• Auto Complete
• Chat with website visitors

RFC 1867

Dependencies

The Struts 2 framework leverages add-on libraries to handle the parsing of uploaded files. These libraries are not included in the Struts distribution, you must add them into your project. The libraries needed are:

Library	URL	Struts 2.0.x	Struts 2.1.x
Commons-FileUpload	http://commons.apache.org/fileupload/	1.1.1	1.2.1
Commons-IO	http://commons.apache.org/io/	1.0	1.3.2

References:

http://www.struts2.org/ajax-file-upload-in-struts2-using-ajax-file-upload-plugin/

http://www.javaeye.com/problems/1818

Related Posts

• Interceptors of Struts 2
• Formatting Dates and Numbers in Struts2
• Accessing application, session, request objects in Struts2

Many Actions share common concerns. Some Actions need input validated. Other Actions may need a file upload to be pre-processed. Another Action might need protection from a double submit. Many Actions need drop-down lists and other controls pre-populated before the page displays.

The framework makes it easy to share solutions to these concerns using an “Interceptor” strategy. When you request a resource that maps to an “action”, the framework invokes the Action object. But, before the Action is executed, the invocation can be intercepted by another object. After the Action executes, the invocation could be intercepted again. Unsurprisingly, we call these objects “Interceptors.”

Interceptors can execute code before and after an Action is invoked. Most of the framework’s core functionality is implemented as Interceptors. Features like double-submit guards, type conversion, object population, validation, file upload, page preparation, and more, are all implemented with the help of Interceptors. Each and every Interceptor is pluggable, so you can decide exactly which features an Action needs to support.

Interceptors can be configured on a per-action basis. Your own custom Interceptors can be mixed-and-matched with the Interceptors bundled with the framework. Interceptors “set the stage” for the Action classes, doing much of the “heavy lifting” before the Action executes.

In some cases, an Interceptor might keep an Action from firing, because of a double-submit or because validation failed. Interceptors can also change the state of an Action before it executes.

The Interceptors are defined in a stack that specifies the execution order. In some cases, the order of the Interceptors on the stack can be very important.

References:

http://docs.huihoo.com/apache/struts/apache-struts-2-document/interceptors.html

Related Posts

• Upload files by using Struts2
• Formatting Dates and Numbers in Struts2
• Accessing application, session, request objects in Struts2

Struts2 supports localization (l10n) aware formatting of dates, times and numbers very easily, utilizing Java’s built-in date formatting features.

As seen in the Localization chapter, it is quite easy to define hierarchical resource bundles with Struts2, giving the developer the opportunity to define locale dependent message formats. This is the entry point to define the needed date, time and number formats. Your default properties could contain the following generic formats:

format.time = {0,time}
format.number = {0,number,#0.0##}
format.percent = {0,number,##0.00'%'}
format.money = {0,number,\u00A4##0.00}

An appropriate en_US format definition extension could look like this:

format.date = {0,date,MM/dd/yy}

In parallel, you could add the following to your de_DE bundle:

format.date = {0,date,dd.MM.yyyy}

Read more on how to define message formats in Sun’s Java API docs for MessageFormat.

Now that we have our formats set up, it is quite easy to use them in our views.

Formatting output using the s:text tag

Given you had a Float value myMoneyValue, accessible through the getter getMyMoneyValue in your action, the following code would print out localized representation of the value as a currency amount, using the format.money message format defined above with a s:text tag:

<s:text name="format.money">
    <s:param name="value" value="myMoneyValue"/>

References:
http://struts.apache.org/2.x/docs/formatting-dates-and-numbers.html
</s:text>

The (first) parameter defines the value which is to replace the ‘0′ placeholder in the defined message format.
Another example, formatting a date value:

<s:text name="format.date"><s:param value="dueDate"/></s:text>

While the s:text tag is very useful to format numbers, date formatting has become a lot easier thanks to the s:date tag.

Localizing form data with getText

Placing a textfield in a form like this

<s:textfield key="orderItem.price" />

to input a number, one might have noticed that the number is always shown in the Java default number format. Not only that this is not “nice”, if you are in a non-en locale, it will also cause trouble when submitting the form since type conversion is locale aware. The solution is to again use the message formats as defined above, by using the getText Method of ActionSupport:

<s:textfield key="orderItem.price" value="%{getText('format.number',{'orderItem.price'})}" />

This maps to the method signature getText( String key, Object[] params ) in ActionSupport.

Related Posts

• Upload files by using Struts2
• Interceptors of Struts 2
• Accessing application, session, request objects in Struts2