Flex: TextInput Focus issues

1. add a initial function on Flex app

mx:application initialize="onLoad(event)"

...

import flash.external.ExternalInterface;


private function onLoad(event:Event):void {
ExternalInterface.call('setBrowserFocus');
this.myCanvas.setFocus();
}

2. add javascript "setBrowserFocus ()" into index.template.html

function setBrowserFocus(){

document.getElementById('${application}').focus();

}

3. test again.

source: http://carrythezero.net/blog/2009/01/20/flex-textinput-focus-issues/

Flex: TextInput Focus issues

1. add a initial function on Flex app

import flash.external.ExternalInterface;


private function onLoad(event:Event):void {
ExternalInterface.call('setBrowserFocus');
this.myCanvas.setFocus();
}

]]>

2. add javascript "setBrowserFocus ()" into index.template.html

function setBrowserFocus(){

document.getElementById('${application}').focus();

}

3. test again.

source: http://carrythezero.net/blog/2009/01/20/flex-textinput-focus-issues/

Java與Flex區別一：使用自定義事件

Java和Flex都支持自定义事件，但是在使用上还是有些区别。

注：本文仅讨论如何在Java和Flex中分别添加一个自定义事件，暂不讨论Flex的事件机制。

Java
在Java中，如果一个类需要发布自定义事件，通常需要如下步骤：

1. 创建一个自定义Listener的接口，比如

1: public interface IListener {
2: public void onValueChange();
3: }
2. 在发布事件的那个类中，提供管理listener的功能，包括，

一个保存listener的容器，通常使用ArrayList,
添加和移除listener的方法，addListener/removeListener，
内部通知listener的相关代码
注：当然也可以继承自java.util.Observable. 但是Java不支持多继承，如果你的类正好需要继承自另外一个类，那就不行了。个人还是喜欢自己去管理这些listener，这样addListener/removeListener这些方法的名字可以取的更加具体，以增强可读性。

3. 在需要处理事件的类实现对应的Listener接口，并将其注册到发布事件的类的对象上（通过调用其addListener方法）。

Flex
在Flex中增加一个新的事件，通常需要如下步骤：

1. 创建一个自定义的事件类，该类继承自flash.events.Event，比如

1: package mypackage
2: {
3: import flash.events.Event;
4:
5: public class ValueChangedEvent extends Event
6: {
7: // event name
8: public static const VALUE_CHANGED:String = "valueChanged";
9: public var value:Number; // customized filed for the event
10:
11: public function ValueChangedEvent(type:String, newValue:Number)
12: {
13: super(type);
14: this.value = newValue
15: }
16:
17: override public function clone():Event {
18: return new ValueChangedEvent(type, value);
19: }
20: }
21: }
2. 在需要发布事件的组件里面，创建一个事件的metadata标签，这样Flex Builder就能自动提示该组件支持这个事件。

比如，在action script里面：

1: [Event(name="valueChange", type="mypackages.ValueChangeEvent")]
2: public class MyComponent extends TextArea
3: {
4: ...
5: }
6:
在mxml里面：

1:
2: [Event(name="valueChanged", type="mypackage.ValueChangeEvent")]
3:
4:
3. 注册事件
在MXML里面处理事件很简单。如果要把多个对象作为事件的接受者，该怎么办呢？在Flex里面，多数Components都继承了EventDispatcher，该类提供了管理、通知事件的功能。从这点上看，Flex比Java要方便些。

如果要把一个对象注册为某个事件的接受者，只需下面这段代码：

1: addEventListener(ValueChangedEvent.VALUE_CHANGED,listener);
[注意]上面方法中的listener是一个Function对象。如果你需要myobj里面的handleValueChanged方法能响应该事件，那么你需要将myobj.handleValueChanged传给addEventListener方法，注意handleValueChanged后面没有"()"。

这是Flex与Java在处理自定义事件上较大的一个的区别：

Java是传一个对象进去， 该对象必须实现对应的Listener接口；
Flex是传一个Function对象进去，对方法的名字没有任何限制，这是Flex的灵活之处。
4. 通知事件

在发布事件的组件里面，通过调用如下代码就能把相应的事件发布出去：

1: var e:ValueChangedEvent = new ValueChangedEvent(
2: ValueChangedEvent.VALUE_CHANGED, newValue);
3: dispatchEvent(e);
Flex里面，创建自定义事件需要两个参数，一个代表事件类型的String对象，一个是特定于这个事件的信息（比如这里的newValue）。

这是Flex与Java在处理自定义事件上另外的一个区别：

Java通知事件时是调用事件接受者上的一个接口方法，
Flex是通过调用dispatchEvent，由Flex的框架来发布事件。
也许，这里应该与Swing里面的事件比较一下。

阅读更多。


source:
http://blog.csdn.net/jewes/archive/2010/05/04/5557139.aspx

Java/J2EE中文問題解決之道

Java中文問題一直困擾著很多初學者，如果了解了Java系統的中文問題原理，我們就可以對中文問題能夠採取根本的解決之道。
最古老的解決方案是使用String的字節碼轉換，這種方案問題是不方便，我們需要破壞對象封裝性，進行字節碼轉換。

還有一種方式是對J2EE容器進行編碼設置，如果J2EE應用系統脫離該容器，則會發生亂碼，而且指定容器配置不符合J2EE應用和容器分離的原則。

在Java內部運算中，涉及到的所有字符串都會被轉化為UTF-8編碼來進行運算。那麼，在被Java轉化之前，字符串是什麼樣的字符集？ Java總是根據操作系統的默認編碼字符集來決定字符串的初始編碼，而且Java系統的輸入和輸出的都是採取操作系統的默認編碼。

因此，如果能統一Java系統的輸入、輸出和操作系統3者的編碼字符集合，將能夠使Java系統正確處理和顯示漢字。這是處理Java系統漢字的一個原則，但是在實際項目中，能夠正確抓住和控制住Java系統的輸入和輸出部分是比較難的。 J2EE中，由於涉及到外部瀏覽器和數據庫等，所以中文問題亂碼顯得非常突出。

J2EE應用程序是運行在J2EE容器中。在這個系統中，輸入途徑有很多種：一種是通過頁面表單打包成請求（request）發往服務器的；第二種是通過數據庫讀入；還有第3種輸入比較複雜，JSP在第一次運行時總是被編譯成Servlet，JSP中常常包含中文字符，那麼編譯使用javac時，Java將根據默認的操作系統編碼作為初始編碼。除非特別指定，如在Jbuilder/eclipse中可以指定默認的字符集。

輸出途徑也有幾種：第一種是JSP頁面的輸出。由於JSP頁面已經被編譯成Servlet，那麼在輸出時，也將根據操作系統的默認編碼來選擇輸出編碼，除非指定輸出編碼方式；還有輸出途徑是數據庫，將字符串輸出到數據庫。

由此看來，一個J2EE系統的輸入輸出是非常複雜，而且是動態變化的，而Java是跨平台運行的，在實際編譯和運行中，都可能涉及到不同的操作系統，如果任由Java自由根據操作系統來決定輸入輸出的編碼字符集，這將不可控制地出現亂碼。

正是由於Java的跨平台特性，使得字符集問題必須由具體系統來統一解決，所以在一個Java應用系統中，解決中文亂碼的根本辦法是明確指定整個應用系統統一字符集。

指定統一字符集時，到底是指定ISO8859_1 、GBK還是UTF-8呢？

（1）如統一指定為ISO8859_1，因為目前大多數軟件都是西方人編制的，他們默認的字符集就是ISO8859_1，包括操作系統Linux和數據庫MySQL等。這樣，如果指定Jive統一編碼為ISO8859_1，那麼就有下面3個環節必須把握：

開發和編譯代碼時指定字符集為ISO8859_1。

運行操作系統的默認編碼必須是ISO8859_1，如Linux。

。">在JSP頭部聲明：<%@ page contentType="text/html;charset=ISO8859_1" %>。

（2）如果統一指定為GBK中文字符集，上述3個環節同樣需要做到，不同的是只能運行在默認編碼為GBK的操作系統，如中文Windows。

統一編碼為ISO8859_1和GBK雖然帶來編制代碼的方便，但是各自只能在相應的操作系統上運行。但是也破壞了Java跨平台運行的優越性，只在一定範圍內行得通。例如，為了使得GBK編碼在linux上運行，設置Linux編碼為GBK。

那麼有沒有一種除了應用系統以外不需要進行任何附加設置的中文編碼根本解決方案呢？

將Java/J2EE系統的統一編碼定義為UTF-8。 UTF-8編碼是一種兼容所有語言的編碼方式，惟一比較麻煩的就是要找到應用系統的所有出入口，然後使用UTF-8去“結紮”它。

一個J2EE應用系統需要做下列幾步工作：

1. 開發和編譯代碼時指定字符集為UTF-8。 JBuilder和Eclipse都可以在項目屬性中設置。
2. 使用過濾器，如果所有請求都經過一個Servlet控制分配器，那麼使用Servlet的filter執行語句，將所有來自瀏覽器的請求（request）轉換為UTF-8，因為瀏覽器發過來的請求包根據瀏覽器所在的操作系統編碼，可能是各種形式編碼。關鍵一句：
request.setCharacterEncoding("UTF-8")。
網上有此filter的源碼，Jdon框架源碼中 com.jdon.util.SetCharacterEncodingFilter
需要配置web.xml 激活該Filter。
3. 在JSP頭部聲明：<%@ page contentType="text/html;charset= UTF-8" %>。

4. 在JSP的html代碼中，聲明UTF-8:
" style="background-color: rgb(255, 255, 255); ">
5. 設定數據庫連接方式是UTF-8。例如連接MYSQL時配置URL如下：

jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
一般數據庫都可以通過管理設置設定UTF-8
6. 其他和外界交互時能夠設定編碼時就設定UTF-8，例如讀取文件，操作XML等。

筆者以前在Jsp/Servlet時就採取這個原則，後來使用Struts、Tapestry、EJB、Hibernate、Jdon等框架時，從未被亂碼困擾過，可以說適合各種架構。希望本方案供更多初學者分享，減少Java/J2EE的第一個攔路虎，也避免因為採取一些臨時解決方案，導致中文問題一直出現在新的技術架構中。

相關J2EE中文問題解決的源碼系統可參考：http://www.jdon.com/jdonframework/app.htm

source: http://blog.csdn.net/kerry365/archive/2005/11/05/523271.aspx

如何簡化 JDBC的代碼

问题的提出

在一个应用程序中，处理JDBC的操作是一个重复率较高的工作。当你在一个JDBC数据源上执行SQL查询时，你通常需要执行下面几个步骤：

1.生成SQL语句

2.获得连接

3.获得一个PreparedStatement对象

4.在PreparedStatement对象中设定需要送入到数据库的值

5.执行SQL语句

6.处理查询结果

除此之外，你还需要处理SQLException异常。如果上面列出的这些步骤分散在程序的各个部分的话，程序中需要多个try/catch块来处理异常。

如果我们仔细看看上面列出的步骤，就会发现在执行不同的SQL语句时，上面这些步骤中涉及到的程序代码变化不会很大：我们使用同样的方法获得数据库连接和PreperedStatement对象；使用setXXX方法来设定PreperedStatement对象中的值；处理SQL查询结果的过程也是基本不变的。在这篇文章中，我们通过定义三个JDBC模型，去除了上述六个步骤中的三个步骤，这样使得整个过程更加简单，而且具有更好的通用性。

查询模型

我们定义了一个名叫SQLProcessor的类，在该类中定义了一个executeQuery（）方法来执行SQL语句，我们在实现这个方法的时候尽量保持代码的简洁性，并且传递尽可能少的参数给该方法。下面是该方法的定义：

public Object[] executeQuery(String sql, Object[] pStmntValues, ResultProcessor processor);

我们知道在执行SQL语句的JDBC过程中，变化的因素有三个：SQL语句，PreparedStatement对象和如何解释和处理查询结果。在上面的方法定义中，sql中保存的就是SQL语句；pStmntValues对象数组保存的是需要放入preparedStatement对象中的值；processor参数是一个能够处理查询结果的对象，于是我们把JDBC程序涉及到的对象分成了三个部分。下面让我们来看一下executeQuery（）和与它相关的一些方法的实现：

public class SQLProcessor { public Object[] executeQuery(String sql, Object[] pStmntValues, ResultProcessor processor) { //获得连接 Connection conn = ConnectionManager.getConnection(); //将SQL语句的执行重定向到handlQuery（）方法 Object[] results = handleQuery(sql, pStmntValues, processor, conn); //关闭连接 closeConn(conn); //返回结果 return results; } protected Object[] handleQuery(String sql, Object[] pStmntValues, ResultProcessor processor, Connection conn) { //获得一个preparedStatement对象 PreparedStatement stmnt = null; try { //获得preparedStatement stmnt = conn.prepareStatement(sql); //向preparedStatement中送入值 if(pStmntValues != null) { PreparedStatementFactory.buildStatement(stmnt, pStmntValues); } //执行SQL语句 ResultSet rs = stmnt.executeQuery(); //获得查询结果 Object[] results = processor.process(rs); //关闭preparedStatement对象 closeStmnt(stmnt); //返回结果 return results; //处理异常 } catch(SQLException e) { String message = "无法执行查询语句 " + sql; //关闭所有资源 closeConn(conn); closeStmnt(stmnt); //抛出DatabaseQueryException throw new DatabaseQueryException(message); } } } ... }

程序中有两个方法需要说明：PreparedStatementFactory.buildStatement（）和processor.process（）。buildStatement（）方法把在pStmntValues对象数组中的所有对象送到prepareStatement对象中的相应位置。例如：

... //取出对象数组中的每个对象的值， //在preparedStatement对象中的相应位置设定对应的值 for(int i = 0; i < values.length; i++) { //如果对象的值为空, 设定SQL空值 if(value instanceof NullSQLType) { stmnt.setNull(i + 1, ((NullSQLType) value).getFieldType()); } else { stmnt.setObject(i + 1, value); } }

因为stmnt.setOject（int index, Object value）方法不能接受一个空对象作为参数。为了使程序能够处理空值，我们使用了自己设计的NullSQLType类。当一个NullSQLType对象被初始化的时候，将会保存数据库表中相应列的SQL类型。在上面的例子中我们可以看到，NULLSQLType对象的属性中保存了一个SQL NULL实际对应的SQL类型。我们用NULLSQLType对象的getFieldType（）方法来向preparedStatement对象填入空值。

下面让我们来看一看processor.process（）方法。Processor类实现了ResultProcessor接口，该接口是用来处理SQL查询结果的，它只有一个方法process（），该方法返回了处理SQL查询结果后生成的对象数组。

public interface ResultProcessor { public Object[] process(ResultSet rs) throws SQLException; }

process（）的典型实现方法是遍历查询后返回的ResultSet对象，将保存在ResultSet对象中的值转化为相应的对象放入对象数组。下面我们通过一个例子来说明如何使用这些类和接口。例如当我们需要从数据库的一张用户信息表中取出用户信息，表名称为User：

列名	数据类型
ID	NUMBER
UserName	VARCHAR2
Email	VARCHAR2

我们需要在程序中定义一个类User来映射上面的表：

public User(int id, String userName, String email)

如果我们使用常规方法来读取User表中的数据，我们需要一个方法来从数据库表中读取数据，然后将数据送入User对象中。而且一旦查询语句发生变化，我们需要修改大量的代码。让我们看一看采用本文描述的解决方案情况会如何。

首先构造一个SQL语句。

private static final String SQL_GET_USER = "SELECT * FROM USERS WHERE ID = ?";

然后创建一个ResultProcessor接口的实例类，通过它我们可以从查询结果中获得一个User对象。

public class UserResultProcessor implements ResultProcessor { // 列名称定义（省略） ... public Object[] process(ResultSet rs) throws SQLException { // 使用List对象来保存所有返回的User对象 List users = new ArrayList(); User user = null; // 如果查询结果有效，处理查询结果 while(rs.next()) { user = new User(rs.getInt(COLUMN_ID), rs.getString(COLUMN_USERNAME), rs.getString(COLUMN_EMAIL)); users.add(user); } return users.toArray(new User[users.size()]);

最后，将执行SQL查询和返回User对象的指令放入getUser（）方法中。

public User getUser(int userId) { // 生成一个SQLProcessor对象并执行查询 SQLProcessor processor = new SQLProcessor(); Object[] users = processor.executeQuery(SQL_GET_USER_BY_ID, new Object[] {new Integer(userId)}, new UserResultProcessor()); // 返回查询到的第一个User对象 return (User) users[0]; }

这就是我们需要做的全部工作：只需要实现一个processor类和一个getUser（）方法。与传统的JDBC程序相比，在本文描述的模型中，我们不需要处理数据库连接操作，生成prepareStatement对象和异常处理部分的代码。如果需要在同一张表中根据用户名查用户ID，我们只需要在代码中申明新的查询语句，然后重用UserResultProcessor类中的大部分代码。

更新模型

如果SQL语句中涉及到更新，情况又会怎样呢？我们可以用类似于设计查询模型的方法来设计更新模型，我们需要向SQLProcessor类中增加一些新的方法。这些方法同executeQuery（）和handleQuery（）方法有相似之处，只是我们需要改变一下处理ResultSet对象的代码，并且把更新的行数作为方法的返回值。

public void executeUpdate(String sql, Object[] pStmntValues, UpdateProcessor processor) { // 获得数据库连接 Connection conn = ConnectionManager.getConnection(); // 执行SQL语句 handleUpdate(sql, pStmntValues, processor, conn); // 关闭连接 closeConn(conn); } protected void handleUpdate(String sql, Object[] pStmntValues, UpdateProcessor processor, Connection conn) { PreparedStatement stmnt = null; try { stmnt = conn.prepareStatement(sql); // 向prepareStatement对象中送入值 if(pStmntValues != null) { PreparedStatementFactory.buildStatement(stmnt, pStmntValues); } // 执行更新语句 int rows = stmnt.executeUpdate(); // 统计有多少行数据被更新 processor.process(rows); closeStmnt(stmnt); // 异常处理 } catch(SQLException e) { String message = "无法执行查询语句 " + sql; closeConn(conn); closeStmnt(stmnt); throw new DatabaseUpdateException(message); } }

上面的两个方法和处理查询的方法不同之处在于他们如何处理返回值。由于更新语句只需要返回被更新了的行数，所以我们不需要处理SQL操作返回的结果。实际上有些情况下连被更新了的行数都不需要返回，我们这样做的原因是在某些情况下需要确认更新操作已经完成。

我们设计了UpdateProcessor接口来处理Update操作返回的更新行数。

public interface UpdateProcessor { public void process(int rows); }

例如在程序中需要保证更新操作，更新表中的至少一条记录。在UpdateProcessor接口的实现类中就可以加入对修改行数的检测，当没有记录被更新时，processor（）方法可以抛出自定义的异常；也可以将更新的行数记录到日志文件中；或者激发一个自定义的更新事件。总而言之，你可以在其中做任何事。

下面是一个使用更新模型的例子：

首先生成SQL语句

private static final String SQL_UPDATE_USER = "UPDATE USERS SET USERNAME = ?, EMAIL = ? WHERE ID = ?";

实现UpdateProcessor接口。在Processor（）方法中，检查Update操作是否更新了数据。如果没有，抛出IllegalStateException异常。

public class MandatoryUpdateProcessor implements UpdateProcessor { public void process(int rows) { if(rows < 1) { String message = "更新操作没有更新数据库表中的数据。"; throw new IllegalStateException(message); } } }

最后在updateUser（）方法中执行Update操作并处理结果。

public static void updateUser(User user) { SQLProcessor sqlProcessor = new SQLProcessor(); sqlProcessor.executeUpdate(SQL_UPDATE_USER, new Object[] {user.getUserName(), user.getEmail(), new Integer(user.getId())}, new MandatoryUpdateProcessor()); }

事务模型

在数据库中，事务和独立的SQL语句的区别在于事务在生命期内使用一个数据库连接，并且AutoCommit属性必须被设为False。因此我们需要指定事务何时开始，何时结束，并且在事务结束时提交事务。我们可以重用SQLProcessor中的大部分代码来处理事务。也许在最开始读者会问为什么要把执行更新和处理更新的工作放在 executeUpdate（）和handleUpdate（）两个函数中完成--实际上它们是可以被合并到同一个函数中的。这样做的原因是把处理数据库连接的代码和处理SQL操作的代码分离开来。对于需要在多个SQL操作间共用数据库连接的事务模型来说，这种方案便于编码。

在事务中，我们需要保存事务的状态，特别是数据库连接的状态。前面的SQLProcessor中没有保存状态的属性，为了保证对SQLProcessor类的重用，我们设计了一个包装类，该类包装了SQLProcessor类，并且可以维护事务在生命周期内的状态。

public class SQLTransaction { private SQLProcessor sqlProcessor; private Connection conn; // 缺省构造方法，该方法初始化数据库连接，并将AutoCommit设定为False ... public void executeUpdate(String sql, Object[] pStmntValues, UpdateProcessor processor) { // 获得结果。如果更新操作失败，回滚到事务起点并抛出异常 try { sqlProcessor.handleUpdate(sql, pStmntValues, processor, conn); } catch(DatabaseUpdateException e) { rollbackTransaction(); throw e; } } public void commitTransaction() { // 事务结束，提交更新并回收资源 try { conn.commit(); sqlProcessor.closeConn(conn); // 如果发生异常，回滚到事务起点并回收资源 } catch(Exception e) { rollbackTransaction(); throw new DatabaseUpdateException("无法提交当前事务"); } } private void rollbackTransaction() { // 回滚到事务起点并回收资源 try { conn.rollback(); conn.setAutoCommit(true); sqlProcessor.closeConn(conn); // 如果在回滚过程中发生异常，忽略该异常 } catch(SQLException e) { sqlProcessor.closeConn(conn); } } }

SQLTransaction中出现了一些新方法，这些方法主要是用来处理数据库连接和进行事务管理的。当一个事务开始时，SQLTransaction对象获得一个新的数据库连接，并将连接的AutoCommit设定为False，随后的所有SQL语句都是用同一个连接。

只有当commitTransaction（）被调用时，事务才会被提交。如果执行SQL语句的过程中发生了异常，程序会自动发出一个回滚申请，以恢复程序对数据库所作的改变。对于开发人员来说，不需要担心在出现异常后处理回滚或关闭连接的工作。下面是一个使用事务模型的例子。

public static void updateUsers(User[] users) { // 开始事务 SQLTransaction trans = sqlProcessor.startTransaction(); // 更新数据 User user = null; for(int i = 0; i < users.length; i++) { user = users[i]; trans.executeUpdate(SQL_UPDATE_USER, new Object[] {user.getUserName(), user.getFirstName(), user.getLastName(), user.getEmail(), new Integer(user.getId())}, new MandatoryUpdateProcessor()); } // 提交事务 trans.commitTransaction(); }

在例子中我们只使用了更新语句（在大多数情况下事务都是由更新操作构成的），查询语句的实现方法和更新语句类似。

问题

在实际使用上面提到的这些模型时，我遇到了一些问题，下面是这些问题的小结，希望对大家有所帮助。

自定义数据库连接

在事务处理的时候，有可能发生在多个事务并存的情况下，它们使用的数据库连接不同的情况。ConnectionManager需要知道它应该从数据库连接池中取出哪一个连接。你可以简单修改一下模型来满足上面的要求。例如在executeQuery（）和executeUpdate（）方法中，你可以把数据库连接作为参数，然后将它们传送给ConnectionManager对象。请记住所有的连接管理都应该放在executeXXX（）方法中。另外一种解决方案，也是一种更面向对象化的解决方案，是将一个连接工厂作为参数传递给SQLProcessor的构造函数。对于不同的连接工厂类型，我们需要不同的SQLProcessor对象。

ResultProcessor类的返回值：对象数组还是List？

为什么ResultProcessor接口中的process（）方法返回的是对象数组呢？怎么不使用List类呢？这是由于在很多实际的应用中，SQL查询在大多数情况下值返回一行数据，在这种情况下，使用List对象会有些多余了。但是如果你确信SQL查询将返回多行结果，你可以使用List对象。

数据库操作异常

我们可以用多个自定义的数据库操作异常类来替代运行时发生的SQLException异常。最好在这些自定义的异常类时继承RuntimeException类，这样可以将这些异常进行集中处理。也许你会认为因该将异常处理放在发生异常的地方。但是我们设计这个的模型的目的之一是在JDBC应用程序开发中去掉或弱化异常处理的部分，只有使用RuntimeException我们才可能达到这个目的。

source: http://blog.csdn.net/kerry365/archive/2005/09/29/491918.aspx

Flex的HttpSession的簡單示例

REMOTEOBJECT:

package com.test;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import flex.messaging.*;
public class GETSESSION {

public GETSESSION() {
// TODO Auto-generated constructor stub
}
public void setSession(String atr,Object val){
HttpServletRequest request = FlexContext.getHttpRequest();
HttpSession session = request.getSession();
session.setAttribute(atr,val);
}
public Object getSession(String atr){
HttpServletRequest request = FlexContext.getHttpRequest();
HttpSession session = request.getSession();
return session.getAttribute(atr);
}

}

PS1:我的remoting-config.xml:

com.test.GETSESSION
application

PS2:返回的OBJECT如果想要與AS3的OBJECT轉化的話這個類要實現序列化(Serializable),還必須有get set方法, maybe flex access to the object with this javacode

mxml:

http://www.adobe.com/2006/mxml" layout="absolute">




http://bjutren.spaces.live.com/");
}
]]>

source:

http://bjutren.spaces.live.com/blog/cns!B6940F2EF5F948FC!162.entry?sa=588346105

reference:

Flex Remote Object中直接使用HttpSession的方法

http://blog.csdn.net/kerry365/archive/2005/09/23/488217.aspx

用JavaScript發出Post Request

function post_to_url(path, params, method) {
method = method || "post"; // Set method to post by default, if not specified.

// The rest of this code assumes you are not using a library.
// It can be made less wordy if you use one.
var form = document.createElement("form");
form.setAttribute("method", method);
form.setAttribute("action", path);

for(var key in params) {
var hiddenField = document.createElement("input");
hiddenField.setAttribute("type", "hidden");
hiddenField.setAttribute("name", key);
hiddenField.setAttribute("value", params[key]);

form.appendChild(hiddenField);
}

document.body.appendChild(form); // Not entirely sure if this is necessary
form.submit();
}

post_to_url('http://example.com/', {'q':'a'});



source: http://ubuntu-rubyonrails.blogspot.com