语源科技BlogJava-我勒个Javahttp://www.blogjava.net/wkkyo/zh-cnWed, 15 Apr 2026 11:58:48 GMTWed, 15 Apr 2026 11:58:48 GMT60Flex中Array和ArrayCollection排序http://www.blogjava.net/wkkyo/archive/2013/03/17/396554.htmlwkkyowkkyoSun, 17 Mar 2013 04:19:00 GMThttp://www.blogjava.net/wkkyo/archive/2013/03/17/396554.htmlhttp://www.blogjava.net/wkkyo/comments/396554.htmlhttp://www.blogjava.net/wkkyo/archive/2013/03/17/396554.html#Feedback0http://www.blogjava.net/wkkyo/comments/commentRss/396554.htmlhttp://www.blogjava.net/wkkyo/services/trackbacks/396554.html
protected function applicationCompleteHandler(event:FlexEvent):void
{
    var array:Array = [];
    array.push(new Vga("a",10));
    array.push(new Vga("c",2));
    array.push(new Vga("f",1.3));
    array.push(new Vga("d",1.1));
    array.push(new Vga("e",16));
    array.push(new Vga("b",0));
    trace(array.toString());
    //output:   [a,10],[c,2],[f,1.3],[d,1.1],[e,16],[b,0]
    var defaultSort:Array = array.sort();//默认排序
    trace(defaultSort.toString());
    //output:   [a,10],[b,0],[c,2],[d,1.1],[e,16],[f,1.3]
    var sortFunArray:Array = array.sort(sortFun);//使用自定义方法排序
    trace(sortFunArray.toString());
    //output:   [b,0],[d,1.1],[f,1.3],[c,2],[a,10],[e,16]
}

/**自定义排序方法*/            
public function sortFun(a:Vga,b:Vga):int{
    if(a.price < b.price){
    return -1; //a在前,b在后
    }else if(a.price == b.price){
    return 0; //ab位置不变
    }else{
    return 1; //b在前,a在后
    }
}



/**排序VO对象*/
public class Vga
{
    public var name:String;
    public var price:Number;
    
    public function Vga(name:String,price:Number)
    {
    this.name = name;
    this.price = price;
    }
        
    public function toString():String{
    return "["+this.name+","+this.price+"]";
    }
}


ArrayCollection排序
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute">
    <mx:Script>
        <![CDATA[
            import mx.collections.SortField;
            import mx.collections.Sort;
            import mx.collections.ArrayCollection;
            private var acSort:ArrayCollection=
            new ArrayCollection([{id:0,userName:"zhangSan",age:21},
                                {id:2,userName:"liSi",age:24},
                                {id:1,userName:"wangWu",age:31}]);
            
            
            private function sortAc():ArrayCollection{
                var sort:Sort=new Sort();
                //按照ID升序排序
                sort.fields=[new SortField("id")];
                
                //按照userName降序排序
                sort.fields=[new SortField("userName",true,true)];
                
                //先按ID升序,再按userName降序
                sort.fields[new SortField("id"),new SortField("userName",true,true)];
                acSort.sort=sort;
                acSort.refresh();//更新
                return acSort;
            }
            
            /*
            其实看看API就一目了然
            SortField () 构造函数 

            public function SortField(name:String = null, 
                        caseInsensitive:Boolean = false, 
                        descending:Boolean = false, 
                        numeric:Object = null)
                                    
            参数  
            name:String (default = null) — 此字段用来进行比较的属性的名称。如果该对象为简单类型，则传递 null。 
            caseInsensitive:Boolean (default = false) — 在对字符串进行排序时，指示比较运算符是否忽略值的大小写。
            descending:Boolean (default = false) — 指示比较运算符是否按降序排列项目。  
                 
            numeric:Object (default = null) — 指示比较运算符是否按编号而不按字母顺序比较排序项目。 
            */            
        ]]>
    </mx:Script>
</mx:Application>


wkkyo 2013-03-17 12:19 发表评论
]]>openfire客户端文件传输学习笔记（一）http://www.blogjava.net/wkkyo/archive/2012/02/13/369827.htmlwkkyowkkyoSun, 12 Feb 2012 16:55:00 GMThttp://www.blogjava.net/wkkyo/archive/2012/02/13/369827.htmlhttp://www.blogjava.net/wkkyo/comments/369827.htmlhttp://www.blogjava.net/wkkyo/archive/2012/02/13/369827.html#Feedback5http://www.blogjava.net/wkkyo/comments/commentRss/369827.htmlhttp://www.blogjava.net/wkkyo/services/trackbacks/369827.html项目中需要用到openfire的文件传输，但是客户端使用flex，官方提供的xiff包中并没有封装文件传输的功能，没办法，研究了几天，在google和官方smock源码的帮助下终于实现了xiff下的文件传输，在这里做个总结。

openfire服务器是基于xmpp协议的，XMPP支持两种文件流传输协议，SOCKS5 Bytestreams和 In-Band Bytestreams，SOCKS5是直接发送二进制流，而IBB是将文件转成base64码进行然后用message的形式进行传输，我这里仅实现了SOCKS5的文件代理传输。
SOCKS5文件传输需要用到两个协议，XEP-0065和XEP-0096
XEP-0096定义文件传输协议，提供了一个模块化框架使能交换被传输文件的信息以及参数的协商，也就是在传输文件之前协商将要传输的文件信息。
XEP-0065定义SOCKS5流传输标准协议，提供用于在任意两个XMPP用户之间建立字节流并进行文件传输。
根据我的理解，文件传输的过程分为协商，建立socks5连接，二进制传输这三个阶段
协商的过程最复杂，然后是建立连接，传输就比较简单，下面一个一个来讲
协商包括初始方、目标方、代理方，初始方就是发送文件方，目标方即文件接收方，代理方是socks5代理服务器，

协商过程就是三方互相发送xml来交换信息的过程，通俗点就是三个人沟通一下传什么文件和怎么传文件。
首先遵循XMP-0096协议，初始方给目标方发送包含文件信息的xml

<iq to="android@192.168.1.113/Spark 2.6.3" type="set" id="iq_13" from="iphone@192.168.1.113/xiff">
    <si profile="http://jabber.org/protocol/si/profile/file-transfer" mime-type="text/plain" id="82B0C697-C1DE-93F9-103E-481C8E7A3BD8" xmlns="http://jabber.org/protocol/si">
        <feature xmlns="http://jabber.org/protocol/feature-neg">
            <x xmlns="jabber:x:data" type="form">
                <field var="stream-method" type="list-single">
                    <option><value>http://jabber.org/protocol/bytestreams</value></option>
                    <option><value>http://jabber.org/protocol/ibb</value></option>
                </field>
            </x>
        </feature>
        <file xmlns="http://jabber.org/protocol/si/profile/file-transfer" name="img0545.png" size="152443"><desc>send</desc></file>
    </si>
</iq>

 
目标方接收到信息后发送回执，表示同意接收文件

 

<iq id="iq_13" to="iphone@192.168.1.113/xiff" from="android@192.168.1.113/Spark 2.6.3" type="result">
    <si xmlns="http://jabber.org/protocol/si">
        <feature xmlns="http://jabber.org/protocol/feature-neg">
            <x xmlns="jabber:x:data" type="submit">
                <field var="stream-method">
                     <value>http://jabber.org/protocol/bytestreams</value>
                     <value>http://jabber.org/protocol/ibb</value>
                </field>
             </x>
        </feature>
     </si>
</iq>

 

这时进入XEP-0065协议阶段
初始方给服务器发送信息，请求提供代理服务器

 

<iq id="iq_15" type="get"><query xmlns="http://jabber.org/protocol/disco#items" /></iq>


服务器回复信息，告知可用的代理

 

<iq type="result" id="iq_15" to="iphone@192.168.1.113/xiff">
    <query xmlns="http://jabber.org/protocol/disco#items">
        <item jid="proxy.192.168.1.113" name="Socks 5 Bytestreams Proxy"/>
        <item jid="pubsub.192.168.1.113" name="Publish-Subscribe service"/>
        <item jid="conference.192.168.1.113" name="公共房间"/>
        <item jid="search.192.168.1.113" name="User Search"/>
    </query>
</iq>

 
这里选择name=“Socks 5 Bytestreams Proxy”的代理，初始方给这个代理发送信息获取代理连接信息

 

<iq id="iq_17" to="proxy.192.168.1.113" type="get"><query xmlns="http://jabber.org/protocol/bytestreams" /></iq>

代理方回复信息，告知初始方代理的jid、IP、端口等信息

 

<iq type="result" id="iq_17" from="proxy.192.168.1.113" to="iphone@192.168.1.113/xiff">
    <query xmlns="http://jabber.org/protocol/bytestreams">
        <streamhost jid="proxy.192.168.1.113" host="192.168.1.113" port="7777"/>
    </query>
</iq>

 
初始方收到代理信息后将代理的信息发送给目标方

 

<iq to="android@192.168.1.113/Spark 2.6.3" type="set" id="iq_19" from="iphone@192.168.1.113/xiff">
    <query xmlns="http://jabber.org/protocol/bytestreams" mode="tcp" sid="82B0C697-C1DE-93F9-103E-481C8E7A3BD8">
        <streamhost port="7777" host="192.168.1.113" jid="proxy.192.168.1.113" />
    </query>
</iq>

 

然后就进入连接阶段，也就是初始方和目标方分别和代理建立socks5连接的过程。（关于SOCKS5协议连接，我之后会补充）。
目标方收到代理信息后和代理建立socket连接(使用SOCKS5协议连接)，连接成功后通知初始方使用的代理jid

 

<iq id="iq_19" to="iphone@192.168.1.113/xiff" type="result" from="android@192.168.1.113/Spark 2.6.3">
    <query xmlns="http://jabber.org/protocol/bytestreams">
        <streamhost-used jid="proxy.192.168.1.113"/>
    </query>
</iq>

 
初始方开始与代理建立socket连接(也使用SOCKS5协议)，连接成功后给代理发送请求，要求激活文件流

 

<iq to="proxy.192.168.1.113" type="set" id="iq_21" from="iphone@192.168.1.113/xiff">
<query xmlns="http://jabber.org/protocol/bytestreams" sid="82B0C697-C1DE-93F9-103E-481C8E7A3BD8">
<activate>android@192.168.1.113/Spark 2.6.3</activate>
</query>
</iq>

 
代理回复激活成功信息

 

<iq type="result" id="iq_21" from="proxy.192.168.1.113" to="iphone@192.168.1.113/xiff"/>

初始方收到回复信息后就进入二进制流传输阶段，这时就可以开始发送二进制流了

等初始方将流发送完毕后把socket流关闭传输就完成了文件的传输。

 

注意：type为result的回复信息使用的id一定要和请求的信息id一样。

 



wkkyo 2012-02-13 00:55 发表评论
]]>解决struts2过滤器冲突的简单方法http://www.blogjava.net/wkkyo/archive/2010/10/15/335219.htmlwkkyowkkyoFri, 15 Oct 2010 03:54:00 GMThttp://www.blogjava.net/wkkyo/archive/2010/10/15/335219.htmlhttp://www.blogjava.net/wkkyo/comments/335219.htmlhttp://www.blogjava.net/wkkyo/archive/2010/10/15/335219.html#Feedback2http://www.blogjava.net/wkkyo/comments/commentRss/335219.htmlhttp://www.blogjava.net/wkkyo/services/trackbacks/335219.htmlstruts2使用FilterDispatcher进行url过滤，默认是所有的url都过滤，但是项目中有些url是不想用struts2进行过滤的，网上搜了不少方法

 

1.修改web.xml文件。

<filter-mapping>   

    <filter-name>struts2</filter-name>   

    <url-pattern>*.action</url-pattern>   

</filter-mapping>

只让过滤器对加有.action后缀的路径有效，如果需要拦截.jsp，加上*.jsp就行了。

但是这样如果有无后缀名的url（如/demo/）就不能过滤了

 

2.修改struts2核心jar中的default.properties文件

把struts.action.extension=action,,

改为struts.action.extension=action,do,jsp,

但我改了之后发现根本没效果，不知为何

 

3.自定义一个继承StrutsPrepareAndExecuteFilter的过滤器，将配置换成自己自定义的过滤器。（推荐此法）

public class ExtendStrutsFilter extends StrutsPrepareAndExecuteFilter {
    
    @Override
    public void doFilter(ServletRequest req, ServletResponse res,FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        //不过滤的url,可以不断添加,如fck可用/fckeditor/editor/filemanager/connectors/fileupload,下面的是flex
        if ("/fpms/messagebroker/amf".equals(request.getRequestURI())) {
            //System.out.println("使用自定义的过滤器");
            chain.doFilter(req, res);
        }else{
            //System.out.println("使用默认的过滤器");
            super.doFilter(req, res, chain);
        }
    }
}

修改web.xml

<!-- sturts2过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
                <!-- 改为自己的过滤器 -->
        <filter-class>
            com.filter.ExtendStrutsFilter
        </filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

这种方法试验成功



wkkyo 2010-10-15 11:54 发表评论
]]>Hibernate缓存学习笔记http://www.blogjava.net/wkkyo/archive/2010/08/22/329601.htmlwkkyowkkyoSun, 22 Aug 2010 15:22:00 GMThttp://www.blogjava.net/wkkyo/archive/2010/08/22/329601.htmlhttp://www.blogjava.net/wkkyo/comments/329601.htmlhttp://www.blogjava.net/wkkyo/archive/2010/08/22/329601.html#Feedback0http://www.blogjava.net/wkkyo/comments/commentRss/329601.htmlhttp://www.blogjava.net/wkkyo/services/trackbacks/329601.htmlHibernate在进行数据读取时会先在缓存里找,缓存中不存在时再去数据库查询,合理使用hibernate缓存能够有效的利用内存,减少物理数据库调用的次数.

 

ORM缓存策略

1.事务级缓存(session level cache)

session生命周期的缓存,关闭session即消亡

2.应用级/进程级缓存(sessionFactory level cache)

某个应用中的共享缓存,多个事务可以共享,在sessionFactory层实现,所有sessionFactory创建的session可以共享.

3.分布式缓存

多个JVM共享的缓存,通过远程机制实现缓存数据同步,任意实例修改数据,所有的JVM都要更新缓存.

 

Hibernate数据缓存

1.内部缓存(session level)一级缓存

是事务级的缓存,session中维护的一个Map,Map的key是包含了数据类型和id,从数据库加载的数据都会进入Map缓存中,通过session加载数据时会先在session缓存里找,一级缓存是session的private数据,session实例消亡就清除了,在应用中就保持在一次请求的开始和结束之间.

一般由Hibernate自动维护,也支持手动维护

session.evit(Object obj) 将持久化对象从一级缓存中清除.

session.clear()  清空一级缓存

session.contains(Object obj) 判断指定的对象是否存在于一级缓存中. 

session.flush() 刷新一级缓存区的内容,使缓存与数据库数据保持同步. 

 

2.二级缓存(sessionFactory level)

包含了应用级和分布式的缓存,由本sessionFactory的所有session实例共享,session操作时会先查一级缓存,然后查二级缓存,最后再查物理数据库.要使用二级缓存必须要进行配置.

 

适合用缓存的数据

1.不会被其他应用修改

包括直接用JDBC修改等,因为其他应用修改了数据之后hibernate并不知道,不能自动更新缓存,不过可以手动更新缓存

2.数据大小可以接受,毕竟内存资源也不多

3.数据更新频率低(比如数据字典等常量数据)

4.可能被系统频繁使用

5.非关键的数据

6.不会被并发访问的数据

 

常用的二级缓存插件

EHCache  org.hibernate.cache.EhCacheProvider 

OSCache  org.hibernate.cache.OSCacheProvider 

SwarmCahe  org.hibernate.cache.SwarmCacheProvider 提供了分布式

JBossCache  org.hibernate.cache.TreeCacheProvider 提供了分布式

 

EHCache二级缓存配置方法

1.启用二级缓存首先要在hibernate.cfg.xml配置

<hibernate-configuration>  

   <session-factory>  

      <!-- 配置二级缓存插件EHCache的Provider类-->  

      <property name="hibernate.cache.provider_class">  

         org.hibernate.cache.EhCacheProvider  

      </property>  

      <!-- 启动"查询缓存" -->  

      <property name="hibernate.cache.use_query_cache">  

         true  

      </property>  

   </session-factory>  

 </hibernate-configuration> 

 

2.然后配置cache的配置文件ehcache.xml

<ehcache>  

  <!-- maxElementsInMemory为缓存对象的最大数目,

eternal设置是否永远不过期,

timeToIdleSeconds对象处于空闲状态的最多秒数,

timeToLiveSeconds对象处于缓存状态的最多秒数,

overflowtodisk内存不足时是否启用磁盘缓存 -->  

  <diskStore path="java.io.tmpdir"/>  

  <defaultCache maxElementsInMemory="10000" eternal="false"  timeToIdleSeconds="300"            timeToLiveSeconds="600" overflowToDisk="true"/>

</ehcache>

 

3.最后要在映射文件***.hbm.xml中指定实体的缓存同步策略

<?xml version="1.0" encoding='UTF-8'?>  

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" 

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >  

<hibernate-mapping>  

   <class>  

       <!-- 设置该持久化类的二级缓存并发访问策略-->  

       <cache usage="read-write"/>

<set name = "xxx">

<cache usage="read-only" />

    </set>

   </class>

</hibernate-mapping>  

 

hibernate提供的缓存同步策略,可以在usage中设置

read-only

只读

nonstrict-read-write

更新频率不高

read-write

严格可读写

transactional(Ecache不支持)

事务型缓存



wkkyo 2010-08-22 23:22 发表评论
]]>