BlogJava-ann-文章分类-javahttp://www.blogjava.net/ann/category/36039.html冰是没有未来的，因为它的永恒zh-cnWed, 16 Jun 2010 01:28:40 GMTWed, 16 Jun 2010 01:28:40 GMT60spring中配置jms（jms服务器----openMQ）http://www.blogjava.net/ann/articles/267311.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Fri, 24 Apr 2009 02:56:00 GMThttp://www.blogjava.net/ann/articles/267311.htmlhttp://www.blogjava.net/ann/comments/267311.htmlhttp://www.blogjava.net/ann/articles/267311.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/267311.htmlhttp://www.blogjava.net/ann/services/trackbacks/267311.html      
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
       http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms-2.5.xsd">

    <!-- ***************************  连接openMQ server ******************************** -->
     <bean id="connectionfactoryfactory" class="com.fg114.customercenter.jms.factory.OpenMqConnectionFactory">
        <property name="properties">
            <props>
                <prop key="imqAddressList">localhost:7676</prop>
            </props>
        </property>
     </bean>

     <bean id="connectionfactory" factory-bean="connectionfactoryfactory" factory-method="createConnectionFactory"/>

     <bean id="springconnectionfactory" class="org.springframework.jms.connection.SingleConnectionFactory">
        <property name="targetConnectionFactory" ref="connectionfactory" />
     </bean>
     
     <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
        <property name="connectionFactory" ref="springconnectionfactory" />
     </bean>

 <!-- ***************************  topic 和 queue TOPIC通道可以有消息消费者, QUEUE只能一个消息消费者******************************** -->
     <bean name="mytopic1" class="com.sun.messaging.Topic">
         <constructor-arg type="java.lang.String" value="mytopic1"/>
     </bean>

     <bean name="mytopic2" class="com.sun.messaging.Topic">
         <constructor-arg type="java.lang.String" value="mytopic2"/>
     </bean>

     <bean name="myqueue" class="com.sun.messaging.Queue">
         <constructor-arg type="java.lang.String" value="myqueue"/>
     </bean>

   <!--*************************  有几个MessageListener既有几个MessageListenerContainer **********-->

    <bean name="topicListenerMytopic1" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
        <constructor-arg ref="messageReceiver"/>
        <property name="messageConverter" ref="springMessageConverter" />
        <property name="defaultListenerMethod" value="receiveTopic"/>
    </bean>

    <bean id="topicListenerContainerMytopic1" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="springconnectionfactory" />
        <property name="destination" ref="mytopic1" />
        <property name="messageListener" ref="topicListenerMytopic1" />
    </bean>

     <bean name="topicListenerMytopic2"  class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
        <constructor-arg ref="messageReceiver"/>
        <property name="messageConverter" ref="springMessageConverter" />
        <property name="defaultListenerMethod" value="receiveTopic"/>
    </bean>

    <bean id="topicListenerContainerMytopic2"   class="org.springframework.jms.listener.DefaultMessageListenerContainer">
        <property name="connectionFactory" ref="springconnectionfactory" />
        <property name="destination" ref="mytopic2" />
        <property name="messageListener" ref="topicListenerMytopic2" />
    </bean>

    <bean name="queueListenerMyqueue1" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
        <constructor-arg ref="messageReceiver"/>
        <property name="messageConverter" ref="springMessageConverter" />
        <property name="defaultListenerMethod" value="receiveTopic"/>
    </bean>

    <bean id="queueListenerContainerMyqueue1"  class="org.springframework.jms.listener.DefaultMessageListenerContainer">
       <property name="connectionFactory" ref="springconnectionfactory" />
        <property  name="destination" ref="myqueue"/>
        <property name="messageListener" ref="queueListenerMyqueue1" />
    </bean>

     <bean name = "springMessageConverter" class="org.springframework.jms.support.converter.SimpleMessageConverter"/>

</beans>

 2. 接收
  
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.test.jms.receive;

import com.test.jms.model.Customer;
import java.io.Serializable;
import javax.annotation.Resource;
import javax.jms.Destination;
import javax.jms.Topic;
import org.springframework.stereotype.Component;
/**
 *
 * @author ann
 */
@Component(value = "messageReceiver")
public class MessageReceiver {

    public void receive(String msg) {
        System.out.println(msg);
    }

    public void receive(Serializable msg) {
          if(msg instanceof Customer){
              Customer c = (Customer) msg;
              System.out.println("c = " + c.getName());
          }else {
               String s = (String) msg;
               System.out.println("s = " + s);
          }
    }

    public void receiveTopic(String msg){
              //String s = (String) msg;
               System.out.println("s = " + msg);

    }


}
   

3.发送
  
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.fg114.test.jms.service.impl;


import java.io.Serializable;
import javax.jms.Destination;
import javax.jms.Topic;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session ;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

/**
 *
 * @author ann
 */
//@Component
public class MessageSendServiceImpl {

//    @Resource(name = "jmsTemplate")
//    private JmsTemplate jmsTemplate;
//
//    @Resource(name = "mytopic1")
//    private Destination desctination;

    @Override
    public void sendString(String queueName, final String msg) {
//        jmsTemplate.send(queueName, new MessageCreator() {
//            public Message createMessage(Session session) throws JMSException {
//                return session.createTextMessage(msg);
//            }
//        });
    }

    @Override
    public void sendObject(String queueName, final Serializable obj) {
//        jmsTemplate.send(queueName, new MessageCreator() {
//            public Message createMessage(Session session) throws JMSException {
//                return session.createObjectMessage (obj);
//            }
//        });
    }

    public void sendTopic(final String message){
//        jmsTemplate.send(desctination, new MessageCreator() {
//            public Message createMessage(Session session) throws JMSException {
//                return session.createTextMessage(message);
//            }
//        });
    }



}
  









冰是没有未来的，因为它的永恒 2009-04-24 10:56 发表评论
]]>简单的jms客户端（jms服务器 --- openMQ）http://www.blogjava.net/ann/articles/267297.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Fri, 24 Apr 2009 02:42:00 GMThttp://www.blogjava.net/ann/articles/267297.htmlhttp://www.blogjava.net/ann/comments/267297.htmlhttp://www.blogjava.net/ann/articles/267297.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/267297.htmlhttp://www.blogjava.net/ann/services/trackbacks/267297.html
   首先,创建jms Listener 
  
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.test.jms;



import com.sun.messaging.ConnectionConfiguration;
import com.sun.messaging.ConnectionFactory;
import com.sun.messaging.Queue;
import com.sun.messaging.Topic;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageListener;
import javax.jms.QueueConnection;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnection;


/**
 *
 * @author ann
 */
public class JMSListener  implements MessageListener {

    String topicName = "mytopic" ;     //要监听的topic名字
    String queueName = "myqueue" ;     //要监听的queue的名字
    String brokerHost = "localhost" ;  //OpenMQ server （broker）的ip
    String brokerPort = "7676" ;  //OpenMQ server （broker）的port
    String username = "test";          //test账号必须有可以接受此queue或者topic的权限
    String password = "test";
    ConnectionFactory       connectionFactory = null;
   // TopicConnection              connection = null;
    QueueConnection              connection = null;
    Destination  destination = null;
    Session                 session = null;
    MessageConsumer               consumer = null;
    TextMessage                  message = null;

    public JMSListener(){
    }

    public void onMessage(Message msg){
        if(msg instanceof TextMessage){
            TextMessage txt = (TextMessage)msg;
            try {
                System.out.println("msg : " + txt.getText());
            } catch (JMSException ex) {
                Logger.getLogger(JMSListener.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    private void init() throws Exception{
        connectionFactory =  new ConnectionFactory();
        connectionFactory.setProperty(ConnectionConfiguration.imqBrokerHostName, brokerHost);
        connectionFactory.setProperty(ConnectionConfiguration.imqBrokerHostPort, brokerPort);
 //       connectionFactory.setProperty(ConnectionConfiguration.imqBrokerServiceName,brokerName);
        connectionFactory.setProperty(ConnectionConfiguration.imqDefaultUsername,username);
        connectionFactory.setProperty(ConnectionConfiguration.imqDefaultPassword,password);
//        connection = connectionFactory.createTopicConnection();
        connection = connectionFactory.createQueueConnection();
        session =  connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        //destination =  new Topic(topicName);
        destination =  new Queue(queueName);
        consumer = session.createConsumer(destination);
        connection.start();
    }

   // 消费消息
    public void consumeMessage() throws JMSException, Exception {
        init();
        connection.start();

        System.out.println("Consumer:->Begin listening");
        // 开始监听
        consumer.setMessageListener(this);
        // Message message = consumer.receive();
    }

    public void destory() throws JMSException{
        consumer.close();
        session.close();
        connection.close();
        System.out.println("Consumer:->stop listening");
    }
//启动listen
public static void main(String[] args) throws Exception {
        JMSListener listen = new JMSListener();
        listen.consumeMessage();
        //五秒后关闭监听
        try {
            Thread.sleep(5000);
        } catch (Exception e) {
        }
        listen.destory();

    }
}


2. 创建jms发送端
  
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.test.jms;

import com.sun.messaging.ConnectionConfiguration;
import com.sun.messaging.ConnectionFactory;
import com.sun.messaging.Queue;
import com.sun.messaging.Topic;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.jms.Destination;
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.QueueConnection;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnection;

/**
 *
 * @author ann
 */
public class Send {
    
    String topicName = "mytopic" ;     //要监听的topic名字
    String queueName = "myqueue" ;     //要监听的queue的名字
    String brokerHost = "localhost" ;  //OpenMQ server （broker）的ip
    String brokerPort = "7676" ;  //OpenMQ server （broker）的port
    String username = "customer";          //customer账号必须有可以发送此queue或者topic的权限
    String password = "customer";
    ConnectionFactory       connectionFactory = null;
    //TopicConnection              connection = null;
    QueueConnection              connection = null;
    Destination  destination = null;
    Session                 session = null;
    MessageProducer               producer = null;
    TextMessage                  message = null;

    public Send(){
        try {
            init();
        } catch (Exception ex) {
           ex.printStackTrace();
        }

    }
     private void init() throws Exception{
        connectionFactory =  new ConnectionFactory();
        //connectionFactory.setProperty("imqAddressList","localhost:7676");
        connectionFactory.setProperty(ConnectionConfiguration.imqBrokerHostName, brokerHost);
        connectionFactory.setProperty(ConnectionConfiguration.imqBrokerHostPort, brokerPort);
        connectionFactory.setProperty(ConnectionConfiguration.imqDefaultUsername,username);
        connectionFactory.setProperty(ConnectionConfiguration.imqDefaultPassword,password);
        //connection = connectionFactory.createTopicConnection();

        connection = connectionFactory.createQueueConnection();

       session =  connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
       // destination =  new Topic(topicName);
       destination =  new Queue(queueName);
        //session.createTopic(topicName);
        producer = session.createProducer(destination);

        connection.start();
    }
     public void send(String msg) throws JMSException{
        try {
            message = session.createTextMessage();
            message.setText(msg);
            System.out.println("Producer:->Sending message: " + msg);
            producer.send(message);
            System.out.println("Producer:->Message sent complete!");
           
        } catch (JMSException ex) {
            ex.printStackTrace();
        }finally{
             connection.close();
        }
     }

     public static void main(String[] args)throws JMSException {
        
        Send send = new Send();
        send.send("test user : ann");
    }



}



  



冰是没有未来的，因为它的永恒 2009-04-24 10:42 发表评论
]]>spring的注解介绍http://www.blogjava.net/ann/articles/265582.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Tue, 14 Apr 2009 10:10:00 GMThttp://www.blogjava.net/ann/articles/265582.htmlhttp://www.blogjava.net/ann/comments/265582.htmlhttp://www.blogjava.net/ann/articles/265582.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/265582.htmlhttp://www.blogjava.net/ann/services/trackbacks/265582.html 1. @Autowired注解
     @Autowired可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。@Autowired的标注位置不同，它们都会在Spring在初始化这个bean时，自动装配这个属性。要使@Autowired能够工作，还需要在配置文件中加入以下           Java代码 <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  
               <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />

2. @Qualifier
    @Autowired是根据类型进行自动装配的。例如，如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常；如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。我们可以使用@Qualifier配合@Autowired来解决这些问题。 如下：
   1). 可能存在多个UserDao实例
       

@Autowired  
public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
    this.userDao = userDao;   
}  

@Autowired
public void setUserDao(@Qualifier("userDao") UserDao userDao) {
  this.userDao = userDao;
}
        
   这样，Spring会找到id为userDao的bean进行装配。
   2). 可能不存在UserDao实例
   

@Autowired(required = false)   
public void setUserDao(UserDao userDao) {   
    this.userDao = userDao;   
}  

@Autowired(required = false)
public void setUserDao(UserDao userDao) {
  this.userDao = userDao;
}

3. @Resource
   JSR-250标准注解，推荐使用它来代替Spring专有的@Autowired注解。@Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将 @Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自 动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动 注入策略。
    @Resource装配顺序
       如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
       如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常
       如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常
       如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配；

4. @PostConstruct（JSR-250）
    在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。
它的一个典型的应用场景是，当你需要往Bean里注入一个其父类中定义的属性，而你又无法复写父类的属性或属性的setter方法时，如：
   
public class UserDaoImpl extends HibernateDaoSupport implements UserDao {   
    private SessionFactory mySessionFacotry;   
    @Resource  
    public void setMySessionFacotry(SessionFactory sessionFacotry) {   
        this.mySessionFacotry = sessionFacotry;   
     }   
    @PostConstruct  
    public void injectSessionFactory() {   
        super.setSessionFactory(mySessionFacotry);   
     }   
        
}  
    这里通过@PostConstruct，为UserDaoImpl的父类里定义的一个sessionFactory私有属性，注入了我们自己定义的 sessionFactory（父类的setSessionFactory方法为final，不可复写），之后我们就可以通过调用 super.getSessionFactory()来访问该属性了。


5. @PreDestroy（JSR-250）
    在方法上加上注解@PreDestroy，这个方法就会在Bean初始化之后被Spring容器执行。其用法同@PostConstruct。和@PostConstruct 区别在于：@PostConstruct注释的方法将在类实例化后调用 ，而标注了 @PreDestroy 的方法将在类销毁之前调用。

6. @Component（不推荐使用）
    只需要在对应的类上加上一个@Component注解，就将该类定义为一个Bean了。Spring还提供了更加细化的注解形式：@Repository、@Service、@Controller，它们分别对应存储层Bean，业务层Bean，和展示层Bean。目前版本（2.5）中，这些注解与@Component的语义是一样的，完全通用，在Spring以后的版本中可能会给它们追加更多的语义。所以，我们推荐使用@Repository、@Service、@Controller来替代@Component。

7.@Scope
    在使用XML定义Bean时，我们可能还需要通过bean的scope属性来定义一个Bean的作用范围，我们同样可以通过@Scope注解来完成这项工作：
   
@Scope("session")   
@Component()   
public class UserSessionBean implements Serializable{
。。。。。。。。。。。。
}

二。配置

 1. 使用<context:annotation-config />简化配置
      Spring2.1添加了一个新的context的Schema命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们 知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。
    AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor就是处理这些注释元数据的处理器。但是直接在Spring配置文件中定义这些Bean显得比较笨拙。Spring为我们提供了一种方便的注册这些BeanPostProcessor的方式，这就是<context:annotation-config />。<context:annotation-config />将隐式地向Spring容器注册 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、 PersistenceAnnotationBeanPostProcessor以及 RequiredAnnotationBeanPostProcessor这4个BeanPostProcessor。

2. 使用<context:component-scan />让Bean定义注解工作起来
    <context:component-scan />的base-package属性指定了需要扫描的类包，类包及其递归子包中所有的类都会被处理。
   注意 ： <context:component-scan />配置项不但启用了对类包进行扫描以实施注释驱动Bean定义的功能，同时还启用了注释驱动自动注入的功能（即还隐式地在内部注册了 AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor），因此当使用<context:component-scan />后，就可以将<context:annotation-config />移除了。

3.<tx:annotation-driven/>
   <context:annotation-config />是不支持spring的@Transcation和EJB的Spring's @Transactional or EJB3's @TransactionAttribute annotation。用此配置可以达到目的。





冰是没有未来的，因为它的永恒 2009-04-14 18:10 发表评论
]]>windows xp下 glassfish安装及部署http://www.blogjava.net/ann/articles/260260.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Tue, 17 Mar 2009 07:44:00 GMThttp://www.blogjava.net/ann/articles/260260.htmlhttp://www.blogjava.net/ann/comments/260260.htmlhttp://www.blogjava.net/ann/articles/260260.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/260260.htmlhttp://www.blogjava.net/ann/services/trackbacks/260260.html 一. 下载解压glassfish
      1. 下载地址:
                       https://glassfish.dev.java.net/public/downloadsindex.html

      2. 解压glassfish :
                   java -Xmx256m -jar glassfish-installer-v2.1-b57-windows.jar（只要配置好java环境都可以执行）
          注意: 必须将协议滚动条从上拖到下，接受按钮就可以点击了。
           你的目录下面将会有个glassfish目录。

      3. 安装glassfish。

            1）. 修改配置:  ........../glassfish/setup.xml(在解压后的glassfish目录下面有setup.xml)，不修改也可以。
            2）. 执行命令:  ant -f setup.xml

      4.启动glassfish server
            asadmin start-domain domain1 这个是默认的domain
  
      5. 测试是否正常启动： 在浏览器里输入：http://localhost:8080
          看看是否能正常显示

      6. 创建domain
           执行命令asadmin create-domain --adminport 4849 customerCenter
  
二. 部署
   
     1. 直接把war或者ear 文件 放在 glassfish/domain/domain1/autodeploy下面，系统会自动部署。

     2. 是通过命令asadmin deploy部署应用, 另外 asadmin updeploy 卸载应用
        通过asadmin deploy --help 和 asadmin undeploy --help 获得更多帮助
    
     3. 通过glassfish管理控制台
         http://localhost：4848
     
     4. 目录部属方式：直接把WEB应用目录直接copy到glassfish/domains/domain1/applications/下
        然后通过命令：glassfish/bin/asadmin deploydir full_path/applications/your_app
 
      
   
   


冰是没有未来的，因为它的永恒 2009-03-17 15:44 发表评论
]]>memcache链接收藏http://www.blogjava.net/ann/articles/241110.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Tue, 18 Nov 2008 03:41:00 GMThttp://www.blogjava.net/ann/articles/241110.htmlhttp://www.blogjava.net/ann/comments/241110.htmlhttp://www.blogjava.net/ann/articles/241110.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/241110.htmlhttp://www.blogjava.net/ann/services/trackbacks/241110.html               http://q.sohu.com/forum/5/topic/640252
              http://www.nauto.net/post/120（spring+memcache）

冰是没有未来的，因为它的永恒 2008-11-18 11:41 发表评论
]]>activeMQ的链接http://www.blogjava.net/ann/articles/241107.html冰是没有未来的，因为它的永恒冰是没有未来的，因为它的永恒Tue, 18 Nov 2008 03:38:00 GMThttp://www.blogjava.net/ann/articles/241107.htmlhttp://www.blogjava.net/ann/comments/241107.htmlhttp://www.blogjava.net/ann/articles/241107.html#Feedback0http://www.blogjava.net/ann/comments/commentRss/241107.htmlhttp://www.blogjava.net/ann/services/trackbacks/241107.html                  https://svn.apache.org/repos/asf/activemq/trunk/activemq-core/src/test/resources/

2.ActiveMQ 实践之路(二) 使用Queue或者Topic发送/接受消息
                 http://www.blogjava.net/hk2000c/archive/2007/11/16/161069.html

3.activeMQ的简单实例
                 http://jinguo.javaeye.com/blog/234311
                 http://fangjh.javaeye.com/blog/64591
                 http://www.javaeye.com/topic/110220（spring+activeMQ）
                 http://whitesock.javaeye.com/blog/monthblog/2008-02?show_full=true

4.Stomp Protocol Specification
                 http://stomp.codehaus.org/Protocol
                 http://stomp.codehaus.org/PHP（activeMQ + PHP）


冰是没有未来的，因为它的永恒 2008-11-18 11:38 发表评论
]]>