commit -m “commit message.” files
RA layer request failed
svn: Commit failed (details follow):
svn: PROPFIND request failed on ‘/repo/path/!svn/vcc/default’
svn: PROPFIND of ‘/repo/path/!svn/vcc/default’: Could not read status line: connection was closed by server. (http://example.com)

How to fix?

Looking at my SVN configurations I could only find the JavaHL option, no SVNKit available.

Related Posts

• Modifying JBoss for Enhanced Performance
• PowerDesigner Reverse Engineer
• GWT Exception – The style name should be in camelCase
• MyEclipse 6.5 GA
• Why CSV files

1. Install the JDK and Tomcat and set the environment variable.
2. Configure JK
Download JK from http://archive.apache.org/dist/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.14/isapi_redirect-1.2.14.exe
Setup the file. (It’s better that there isn’t blank space in the directory which you choose to install.)
After installing it, you could find the file “workers.properties.minimal” in \Apache Software Foundation\Jakarta Isapi Redirector, and change its name to “workers.properties”.
Open the Registry Editor; Open the “HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0]”
Change the value “workers.properties.minimal”of worker_file to “workers.properties”
The content of worker.properties and uriworkermap.properties is follow:
worker.properties:
worker.list=ajp13
worker.ajp13.type=ajp13
worker.ajp13.host=localhost
worker.ajp13.port=8009
uriworkermap.properties:
# Mapping the URI /admin, /manager, /jsp-examples and /servlets-examples and
# everything under them to Tomcat
# /admin/*=ajp3
# /manager/*=ajp13
# /jsp-examples/*=ajp13
# /servlets-examples/*=ajp13

# Mapping all URI which end with a common suffix .jsp and .do to Tomcat
# /*.jsp=ajp13
# /*.do=ajp13

# Mapping all URI to Tomcat
/*=ajp13

3. Create a new website in IIS which point to your website (such as $CATALINA_HOME\ webapps\ROOT)
4. Configure the Tomcat ISAPI Filter
Rigth click your websitePropertiesISAPI FiltersAddset Filter name “jakarta” and Executable choose the path of “isapi_redirector.dll”OK
Note – If you check on its status, you may notice that the ISAPI filter hasn’t been successfully loaded at this stage, even if you have re-started IIS. This is expected behaviour and is documented in the IIS6 Operations Guide,
“In an effort to optimize resources in IIS 6.0, an ISAPI filter is not loaded until a request is made to a Web site that requires the ISAPI filter. Until this request is made, IIS Manager does not display the status of the ISAPI filter.”
http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/93f23233-2a47-4104-b0b4-a7ec0d3116f3.mspx
However, once IIS has served a successful request to it you will see the status of the ISAPI filter change to ‘Loaded’.
5. Create a virtual directory for the Tomcat connector to use, create a new Web Service Extension in IIS and then enable that web service extension so that it can be used.
Rigth click your websiteNewVirtual Directoryset Alias: jakartaNextset Path: choose the path of “isapi_redirector.dll”.
6. Create and exable the tomcat Web Service Extension
Rigth click “Web Service Extension”  Add a new Web service extension Set name: Tomcat, set Required files:choose your “isapi_redirector.dll” click the “Set extension status to Allowed”OK
7. Add the “.jsp”
Rigth click your websitePropertiesHome DirectoryMappingsAddset Executable: choose your “isapi_redirector.dll”, set Extension: .jsp (Note: if there is blank space in your path, you need to make your path in Double quotes.)
8. Set index.jsp as default content page
Rigth click your websitePropertiesDocumentAdd–>index.jsp
10. Restart tomcat and IIS. You should now be ready to test your Tomcat installation by issuing a request to the sample applications. Visit http://localhost
If show the page as http://localhost:8080, you’re successful.

tomcat5.5 整合 iis6.0
环境：Windows 2003 R2 + IIS 6.0 + JDK 1.5+TOMCAT5.5
1. 安装tomcat

2. 下载jkhttp://archive.apache.org/dist/tomcat/tomcat-connectors/jk/binaries/win32/jk-1.2.14/isapi_redirect-1.2.14.exe
安装的好处就是配置文件都有了。只需做少许修改：
安装目录可以随意（最好让目录不带空格），安装完成后在conf里就是它的配置文件，安装完后找到目录文件\Apache Software Foundation\Jakarta Isapi Redirector 这个可以根据你自己的改动，在conf文件里把workers.properties.minimal它改为
workers.properties，对应找到注册表里的
HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0] 中的worker_file 点右键修改
同样去掉workers.properties.minimal 后的minimal。

3. 以下为两个文件的内容
uriworkermap.properties:

# Mapping the URI /admin, /manager, /jsp-examples and /servlets-examples and
# everything under them to Tomcat
# /admin/*=ajp3
# /manager/*=ajp13
# /jsp-examples/*=ajp13
# /servlets-examples/*=ajp13

# Mapping all URI which end with a common suffix .jsp and .do to Tomcat
# /*.jsp=ajp13
# /*.do=ajp13

# Mapping all URI to Tomcat
/*=ajp13

worker.properties:

worker.list=ajp13
worker.ajp13.type=ajp13
worker.ajp13.host=localhost
worker.ajp13.port=8009

4. 在iis里新建一个站点，指向网站所在的目录（比如$CATALINA_HOME\webapps\ROOT），然后在站点上点右键选“属性”，在弹出的页框里选择“ISAPI筛选器”，点“添加”，筛选器名称填jakarta,可执行文件中填入你的isapi_redirector.dll的绝对路径。“确定”后点“确定”关闭属性页。再在“默认网站”上右键，选择“新建”－>“虚拟目录”，别名填jakarta，下一步，路径选为你的isapi_redirector.dll存放的目录。

5. 在“Internet信息服务管理器”的“网站”中的“Web服务扩展”上点右键选择“添加一个新的Web服务扩展”，弹出的框中扩展名填Tomcat(其实无所谓的)，“要求的文件”选“添加”然后找到你的isapi_redirector.dll后“确定”。“设置扩展状态为允许”也打上勾，确定。

6. 如果要让iis能读取index.jsp这样的jsp默认首页，还需要在IIS6.0右键单击【默认网站】，选择【属性】，单击【主目录】选项卡中的【配置】，单击【映射】选项卡，单击【添加】，将isapi_redirector.dll的全路径写进去，扩展名要写.jsp（注意：如果你的路径包含空格，那么你需要将这个完整路径用英文的双引号括起来才能添加）。
到这里就配置完了

7. 重起tomcat 重启iis 去掉端口后看看能运行了吧

总结：
说到底，这就是两种服务的一种集成，使之外部看起来像一种服务，可以这么理解：
外部访问域名－－＞解析后到IP－－＞IIS查找相应站点－－＞发现jsp文件－－＞转至jk连接处理－－＞将相应文件解释转给Tomcat－－＞将页面返回给IIS－－＞展现给客户端。
那么哪出了问题，就查哪，一步一步来，一定能成功的，希望对大家有所帮助，另外多看官方手册，多想其中的原理，网上流传的各种文档不一定就是正确的，包括本文，只是尽量详尽的给一种引导。

Related Posts

• Ways to Improve Programming Productivity
• Link to Oracle Database
• Chuck steak
• DM_SYSOBJECT_E_NOT_ATTACHABLE_TYPE
• Share files on Windows XP

Note: This procedure requires restarting the JBoss application server.

Steps

1. In the \server\default\deploy\jbossweb-tomcat50.sar directory, locate and open the server.xml file.
2. Locate the block listed under the <!– A HTTP/1.1 Connector on port 8080 –> heading.

   Note: The specific port number and other settings may vary.

   This block should look like this:

   <!-- A HTTP/1.1 Connector on port 8080 -->

   <Connector port="8080" address="${jboss.bind.address}"

   maxThreads="400" minSpareThreads="100" maxSpareThreads="75"

   enableLookups="false" redirectPort="8443" acceptCount="100"

   connectionTimeout="20000" disableUploadTimeout="true"/>

3. Add the following parameters:

   compression="on" 

   socketBuffer="1045576" />

4. Save and close the server.xml file.
5. Restart JBoss.

Related Posts

• Eclipse SVN Error
• PowerDesigner Reverse Engineer
• GWT Exception – The style name should be in camelCase
• MyEclipse 6.5 GA
• Why CSV files

Generate the Java Code
1. Menu Operation
Tools , Generate Object-Oriented Model, Detail, O/R Mapping,
Enable Transformations, Extended Model Definitions, O/R Mapping,      Hibernate

To be continued.

Related Posts

• Hibernate lost timezone when getting timestamp from Oracle
• Eclipse SVN Error
• Get definition for view in Oracle
• Modifying JBoss for Enhanced Performance
• PowerDesigner Non SQLError

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

• DM_QUERY_E_TABLE_NO_ACCESS
• chown – change the owner of a file
• Backup repository by oracle tools
• My favorite films
• Install and Uninstall Lifecycle

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

$wnd 是什么？

GWT provides the $wnd and $doc variables to refer to the window and document objects

GWT使用通过Java Native method使用它，声明一个native方法，将含有JavaScript的方法体注释。编译器将注释块内的内容逐字输出，使之与编译产生的JavaScript整合到一起。

Java调用JavaScript方法：

JSNI方法定义需要使用native关键字，并且需要在参数列表之后，结尾的分号之前定义。JSNI方法的开始使用 /*-{ , 结尾使用}-*/,例如：

public static native void alert(String msg) /*-{

         $wnd.alert(msg);

}-*/;

这是gwt  Window 类中的源码–一个标准的jsni 方法, 我们可以看到,方法实现就是一行简单的javascript 代码. (这里没有用 alert 或者 window.alert 的原因是: gwt 代码运行在一个iframe中,如果直接用alert或者window.alert,引用的是iframe文档,而不是host page 文档). 经过这个方法包装,以后在gwt程序中使用 ” Window.alert”  实际上就是调用了javascript 的 alert 方法,当然你也可以不用这个封装, 直接实用 $wnd.alert .

当上述方法在Java中调用的时候，实际上将调用Window的alert()方法，将传入的内容打印出来。在Hosted Mode下，断点可以调协在上述方法中，可以查看传入的参数。

参考如下：

http://www.javaeye.com/topic/365678

http://www.webreference.com/programming/java/toolkits/

The GWT makes ingenious use of Java’s native methods with something called the JavaScript Native Interface. You declare native methods with commented-out bodies that contain JavaScript. When those native methods are compiled, the GWT incorporates the commented JavaScript. Here’s an example of such a native method:

Calling native JavaScript with JSNI

http://www.ibm.com/developerworks/java/library/j-ajax4/

Visual-effects libraries are becoming increasingly popular in Web application development, whether their effects are used to provide subtle user-interaction cues or just to add polish. I’d like to add some eye-candy to the Weather Reporter application. GWT doesn’t provide this type of functionality, but its JavaScript Native Interface (JSNI) offers a solution. JSNI lets you make JavaScript calls directly from GWT client Java code. This means that I can exploit effects from the Scriptaculous library (see Resources) or from the Yahoo! User Interface library, for example.

JSNI uses a cunning combination of the Java language’s native keyword and JavaScript embedded in a special comment block. It’s probably best explained by example, so Listing 10 shows a method that invokes a given Scriptaculous effect on an Element:

Listing 10. Invoking Scriptaculous effects with JSNI

 private native void applyEffect(Element element, String effectName) /*-{

   // Trigger named Scriptaculous effect
   $wnd.Effect[effectName](element);
}-*/;

This is perfectly valid Java code because the compiler sees only private native void applyEffect(Element element, String effectName);. GWT parses the contents of the comment block and outputs the JavaScript verbatim. GWT provides the $wnd and $doc variables to refer to the window and document objects. In this case, I’m simply accessing the top-level Scriptaculous Effect object and using JavaScript’s square-bracket object-accessor syntax to invoke the named function specified by the caller. The Element type is a “magic” type provided by GWT that represents a Widget’s underlying HTML DOM element in both Java and JavaScript code. Strings are one of the few other types that can be passed transparently between Java code and JavaScript via JSNI.

Now I have a weather report that fades in nicely when the data is returned from the server. The final touch is to re-enable the ZIP code TextBox when the effect has finished. Scriptaculous uses an asynchronous callback mechanism to notify listeners about the life cycle of effects. This is where things get a little more complex because I need to have JavaScript call back into my GWT client Java code. In JavaScript, you can invoke any function with an arbitrary number of arguments, so Java-style method overloading doesn’t exist. This means that JSNI needs to use an unwieldy syntax to refer to Java methods to disambiguate possible overloads. The GWT documentation states this syntax as:

[instance-expr.]@class-name::method-name(param-signature)(arguments)
 
The instance-expr. part is optional because static methods are invoked without the need for an object reference.

Related Posts

• Smart GWT FAQ
• GWT and Documentum