一切皆可抽象

俗话说“没有规矩，不成方圆。”俗话说“是药均有三分毒。”俗话说：“创业难，守业更难。” 俗话说：“一分耕耘，一分收获。” 俗话：“天下无难事，只怕有心人”―――在中国民间，成千上万条这样的俗话从出生那天起，就开始耳闻目染，甚至“俗话”已经侵入人的骨髓，成为“大纲文化”，成为我们思考的“定式”。

在辩论中，我们经常“引经据典”，动则以“俗话说的好―――”来加强自己的观念，实际上这也是“不自信”的一种表现形式。爱引用俗话的人，是希望能拉上老祖宗留下的“至理名言”，来给自己的观念擂鼓助威。但祖宗的东西未必就是好东西，有些俗话已经随着时间的推移，与现实生活中的伦理和我们所倡导之风尚相驳，下面笔者列举的十大俗话，就是害人不浅的“老祖宗遗风”。

１、天下乌鸦一般黑

害人指数：★★★★★

　　天下乌鸦一般黑，主张一竹杆打死一船人，一个活口儿也不留。在管理学上这叫“晕轮效应”，例如：谈到东北人，马上就有人接话道：“我知道，东北人都豪爽。”谈到河南人，马上就有人接话道：“我知道，河南人都爱骗。”谈到日本人，马上就有人接话道：“日本人，没有一个好东西！”东北人都豪爽吗？不一定！河南人都爱欺骗别人吗？不一定！日本人都坏吗？不一定。这些都是受到“天下乌鸦一般黑”俗话的影响，是这句俗话的变异思维。最惨的就是男人，有句俗话“是猫就爱偷腥吃。”这句俗话实际是“天下乌鸦一般黑”的翻版。主张把天下所有男人形容成“种牛”，如果你不是“种牛”，那一定得找“老军医”看看。

２、一个巴掌拍不响

害人指数：★★★★★

　　“一个巴掌拍不响”是中庸之道的产物，主张各打５０大板，谁都不能说吃亏，谁都不能说占便宜。我在南京读大学那其间，学院规定：只要打架斗殴，一经核实，立即严肃处理，不管双方是哪一方的责任，都要受到处分。这样的校规制定者，就是受到大俗话“一个巴掌拍不响”的严重影响。实际上，有些时候，一个巴掌是能拍响的，例如用这巴掌拍墙，拍桌子，拍马屁―――不一定非要拍另外那只巴掌。“一个巴掌拍不响”是仲裁方无能的表现，无法做到赏罚分明，只能和稀泥，做老好人，主张各退一步。例如上述那个校规，如果某同学打你，是否就被动等着挨打？打你还是轻的，例如媒体多次报道：某某在街上行走遭受到抢劫，你还能用“一个巴掌拍不响”的方式来处理问题吗？“一个巴掌拍不响”实际上就是保护“强盗”，打击“弱者”，向“恶势力”妥协。

３、苍蝇不叮无缝蛋

害人指数：★★★★★

　　苍蝇不叮无缝蛋是散播和加速散播谣言的有力“理论基础”。据《西部商报》２００５年０７月１４日报道，余某和把某是邻居，在今年农历三月份，村子里传称把某强*杨某。在谣言散播过程中，邻居余某相信“苍蝇不叮无缝蛋”，煽风点火，说把某一定是干了这件见不得人的事情，四处散播。最后把某忍无可忍，竟然用菜刀将邻居家妇女余某的头砍下。看，这大俗话“苍蝇不叮无缝蛋”，不仅能害别人，还能害死相信这句话人的性命。

４、机会面前人人平等

害人指数：★★★☆☆

　　“机会面前人人平等”是成功者欺骗失败者的有力借口、谎言和工具。在机会面前，不可能是人人平等的。什么是机会？机会就是给予具有某些掌握资源者的选择和回报。例如招聘，某公司打出招聘总经理的广告，对应聘者所要具有的条件列出若干。如果把总经理的职位看成一次机会，把看见这则消息的人视为“机会面前的人人”，表面上，大家都有相同的机会，但实际上根本就不是平等的机会。如：在条件上要求：硕士学位，大多数人就没有机会了；再要求：在同等岗位上工作８年以上，又有一些人掉头走了；再要求：在同行业内工作５年以上，恐怕所剩下的就那么几个了；再要求：年龄―――这样的机会，怎么能用人人平等来诠释呢？一个市长的儿子和一个普通工人儿子站在同一个机会面前，他们能平等吗？

５、人挪活，树挪死

害人指数：★★★★★

　　“人挪活，树挪死”是目前“跳槽族”自我“鼓励”有力的理论支撑点。当在某个岗位上干得稍微不顺心的时候，一些人就开始想入非非。我的一个堂弟，在长春某名校做老师。几个月前，他给我打电话，让我帮助他把他“弄到”长春土地规划局去，被我拒绝了。他在做老师之前在区政府宣传部干过几年。“人挪活，树挪死”这句大俗话，实际上并不符合现代社会的逻辑推理。生活在城市，街道两旁的树都是挪来的，都活得好好的，所以说“树挪未必死”；人挪就活吗？也不一定，看见过很多在各单位之间跳来跳去的人，也很少看见“有所突破和提高”，相反，到是有很多踏踏实实在原来岗位上努力勤奋的人，做出了一点成绩，所以人挪也未必“活”。如果抱着“此处不留爷自有留爷处”的心态去工作，不管走到哪里，都是很难做出一番成绩的。

６、有则改之，无则加勉

害人指数：★★★★★

　　“有则改之，无则加勉”是一把杀人不见血的刀。经常看见一些官状模样的人，说话喜欢旁敲侧击，声东击西，捕风捉影：“对于最近单位传闻的咱单位内婚外恋问题，我们要给予足够的重视，当然了，有则改之，无则加勉―――”，停者往往不知所措，说谁呢？大家猜测不止。本来很安静的单位，一时间就会满城风雨，议论纷纷。“有则改之，无则加勉”这句话，是给没有“真凭实据”说话者找到杀人的“刀和枪”。

７、我过的桥比你走过的路还多

害人指数：★★★★☆

　　“我过的桥比你走过的路还多”通常是年长者对年轻人 “不听话” 的告诫。判断问题的对错，和年龄无关。扯上年龄，就是“拉上虎皮”，为自己的心虚鼓劲壮胆。如果年龄就是一切，那么一个学校的校长一定是该校年龄最大的；一个企业的总经理一定是该公司最老的；一个国家的领导人一定都是百岁以上的老者―――事实是这样的吗？显然不是！笔者说这个，不是对长者的不尊重，只是实事求是地说，对待某个具体问题，谁的观念最接近“最优”，和年龄关系不大。“我过的桥比你走过的路还多”是对年轻人的不尊重，也是对知识的亵渎，持有“我过的桥比你走过的路还多”观念的人主张“论资排辈”。

８、老乡见老乡，两眼泪汪汪

害人指数：★★★★★

　　“老乡见老乡，两眼泪汪汪”，主张以地区为线，画出友谊的大门。中国警务报道，３月１８日上午，南昌市公安局刑侦支队三大队将抓获的杀人犯罪嫌疑人谢应福移交给广州警方。据悉，谢应福为２０万钱财，竟将从小一起长大的老乡杀死。这里，就不是“老乡见老乡，两眼泪汪汪”，而是“老乡见老乡，背后来一枪”了。近几年来，老乡谋害老乡的案件时有发生，网友们一定要保持警惕，即不能见到老乡就“不设防”，也不要一见老乡就“谈乡色变”。中国人，要抛开“地域亲热”，了解一个人要全面地去考证，老乡不是绿色通行证。

９、各扫门前雪

害人指数：★★★★★

　　“各扫门前雪，莫管他人瓦上霜”，主张圈地为牢，倡导“事不关己高高挂起。”各扫门前雪是自私自利的表现。这几年几乎每个季度都有媒体报道，有女孩在光天化日之下被强暴了，而且围观者数众。这些围观的人实际上就是“各扫门前雪，莫管他人瓦上霜”这句大俗话坚定的支持者。现在小偷猖獗、抢劫犯疯狂―――不能说跟“各扫门前雪”的信奉无关。在“各扫门前雪”的大俗话前，“见义勇为”正在沦落。

１０、友谊第一，比赛第二

害人指数：★★★☆☆

　　“友谊第一，比赛第二”是具有中国特色的中庸特产。主张把交流情感、加强感情放到第一位，比赛输赢是次要的。真的能做到吗？不可能！比赛就是要分输赢的，就是要争第一的，否则比赛就成了形式主义和工具。比赛中的参与者人也无法体验比赛激烈对抗所带来的精神享受，观众也看不见比赛的激情和悬念。这样的比赛还能叫比赛吗？“友谊第一，比赛第二”是虚伪的代名词，实际各队在比赛前都做了大量的准备工作，在赛场上也是火药味十足，每一个运动员都打着“友谊第一，比赛第二”的幌子在干“比赛第一，友谊第二”的事业。“友谊第一，比赛第二”这句大俗话，特显出中国人虚伪、矫揉、造作的一面。

可能大家都碰到过类似的问题  比如 “我国信息化工程发展迅速。”这句话中，出现了信息化 和 化工嵌套的关键词，那么在加链接的时候如何处理？当然不可能两个都加，只能加一个的情况下，只能通过给文档定义类型，根据类型进行关键词的类型指派。我这里实现了根据关键词的顺序进行替换，谁早先换谁。呵呵

关键词实体
public class mainkey {

  private String name = "";
  private String url = "";

  public mainkey(String temp_name ,String temp_url) {
      name = temp_name;
      url  = temp_url;
  }

  public void setName(String temp_name)
  {
     name = temp_name;
  }
 
// 
 
  public String getName()
  {
     return name;
  }

  public void setUrl(String temp_url)
  {
     url = temp_url;
  }
  public String getUrl()
  {
    return url;
  }
 

}
内容位置匹配
public class station {

 

  private int starti;
  private int endi;
  private int length;
  private mainkey key;
  private int typei;

  public station(int starti,int endi,int length,mainkey key) {
    this.starti = starti;
    this.endi = endi;
    this.length = length;
    this.key = key;
    this.typei = 1;
  }

  public void setStarti(int temp)
  {
    starti = temp;
  }
  public int getStarti()
  {
    return starti;
  }

  public void setEndi(int temp)
  {
     endi = temp;
  }
  public int getEndi()
  {
    return endi;
  }

  public void setLength(int temp)
  {
    length = temp;
  }
  public int getLength()
  {
    return length;
  }

  public void setKey(mainkey key)
  {
    this.key = key;
  }
  public mainkey getKey()
  {
    return key;
  }

  public void setTypei(int temp)
  {
    typei = temp;
  }
  public int getTypei()
  {
    return typei;
  }

}

具体替换

public class change {
  public change() {
  }

  public static void main(String args[])
  {
     change ch = new change();
     System.out.println(ch.changeStr("我国信息化工程发展迅速，电子化程度很高,国家大力提倡信息化。"));
  }

  public String changeStr(String cs)
  {
    //key
    java.util.ArrayList keylist = new java.util.ArrayList();
    keylist.add(new mainkey("电子","dianzi"));
    keylist.add(new mainkey("信息化","xinxihua"));
    keylist.add(new mainkey("国家","guojia"));
    keylist.add(new mainkey("化工","huagong"));

    //station
    java.util.ArrayList stationlist = new java.util.ArrayList();
    int keyi = 0;
    for (int i=0;i<keylist.size();i++)
    {
      mainkey tempkey = (mainkey)keylist.get(i);
      int length = tempkey.getName().length();
      int starti = cs.indexOf(tempkey.getName());
      int endi = starti+length-1;
      station tempstation = null;
      if (starti  >0)
      {
       tempstation = new station(starti,endi,length,tempkey);
       stationlist.add(tempstation);
      }

    }

    //change
    this.BubbleSort(stationlist);

    //开始比较

    for (int i=0;i<stationlist.size()-1;i++)
    {
      if ((((station)stationlist.get(i)).getStarti())<=(((station)stationlist.get(i+1)).getEndi()))
      {
        ((station)stationlist.get(i)).setTypei(0);
      }
    }

    //
    //开始替换
    for (int i=0;i<stationlist.size();i++)
    {
       station ss = ((station)stationlist.get(i));
       if (ss.getTypei() == 1)
       {
         mainkey key = ss.getKey();
         cs = cs.replaceAll(key.getName(),"<"+key.getUrl()+">"+key.getName()+"</"+key.getUrl()+">");
       }
    }
    return cs;
  }

   void BubbleSort(java.util.ArrayList changelist)
   { //R（l..n)是待排序的文件，采用自下向上扫描，对R做冒泡排序
     int i,j;
     int n = changelist.size()-1;
     boolean exchange; //交换标志
     for(i=0;i<n;i++){ //最多做n-1趟排序
       exchange=false; //本趟排序开始前，交换标志应为假
       for(j=n-1;j>=i;j--) //对当前无序区R[i..n]自下向上扫描
        if(((station)changelist.get(j+1)).getStarti()>((station)changelist.get(j)).getStarti()){//交换记录
          Object tempstation = changelist.get(j+1);
          changelist.set(j+1,changelist.get(j));
          changelist.set(j,tempstation);
          exchange=true; //发生了交换，故将交换标志置为真
         }
       if(!exchange) //本趟排序未发生交换，提前终止算法
             return;
     } //endfor(外循环)
   }
}

抽象类 继承于 Exception
public abstract class AbstractException extends Exception{
    private ErrorInfo info;
    public AbstractException(ErrorInfo message) {
      super(message.getErrorCode()+message.getErrorName()+message.getErrorInfo());
      info = message;
    }
    public String getCode()
    {
      return info.getErrorCode();
    }

}

错误实体
public class ErrorInfo {

  private String ErrorCode;
  private String ErrorName;
  private String ErrorInfo;

  public ErrorInfo(String temp1,String temp2,String temp3) {
    this.ErrorCode = temp1;
    this.ErrorName = temp2;
    this.ErrorInfo = temp3;
  }

  public String getErrorCode()
  {
     return this.ErrorCode;
  }
  public String getErrorName()
  {
     return this.ErrorName;
  }
  public String getErrorInfo()
  {
    return this.ErrorInfo;
  }

}

错误集合
public class ErrorPool {

  private java.util.HashMap errorMap = new java.util.HashMap();
  public ErrorPool() {
    errorMap.put("Center1001",new ErrorInfo("Center1001","严重错误，适配器无效","因为适配器所在前置机网络异常，造成适配器无效"));

  }
  public ErrorInfo getErrorInfo(Object errorCode)
  {
    return (ErrorInfo)errorMap.get(errorCode);
  }

}
异常实现
public  class TestException extends AbstractException {
    private ErrorInfo info;
    public  TestException(ErrorInfo message)
    {
      super(message);
      info = message;
    };
    public String getCode()
    {
      return super.getCode();
    }
    public void LogDebug()
    {
      System.out.println("debug info.....");
    }

}

具体使用代码
public class Test {
  public Test() {
  }

  public void kk(String usename) throws TestException
  {
    if (usename.equals("fuck"))
    {
    }
    else
    {
      throw(new TestException((new ErrorPool()).getErrorInfo("Center1001")));
    }
  }

  public static void main(String[] agrgs)
  {
    try
    {
     Test tt = new Test();
     tt.kk("xxx");
    }
    catch(TestException e)
    {
       System.out.println(e.getCode());
       e.printStackTrace();
       e.LogDebug();
    }
  }

}

public class JmsUtils {

   public static final String HOST_NAME = "192.168.0.63";
   public static final String CHANNELNAME = "chan1";
          public static final int CCSID = 1381;
          public static final String QMGRNAME = "channel1";

}

import javax.jms.JMSException;
import javax.jms.Topic;
import javax.jms.TopicConnection;

public class PubSubUtils extends JmsUtils {

 

 public TopicConnection getConnection()
  throws  JMSException {
              com.ibm.mq.jms.MQTopicConnectionFactory factory = new
              com.ibm.mq.jms.MQTopicConnectionFactory();
              factory.setHostName(this.HOST_NAME);
              factory.setCCSID(this.CCSID);
              factory.setChannel(this.CHANNELNAME);
              factory.setQueueManager(this.QMGRNAME);

        return factory.createTopicConnection();
 }

 public Topic getTopic(String name) throws JMSException {
          return new com.ibm.mq.jms.MQTopic(name);
 }
}

import java.io.IOException;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;
import javax.jms.TopicConnection;
import javax.jms.TopicPublisher;
import javax.jms.TopicSession;
import javax.naming.NamingException;

public class StandalonePublisher {

 private PubSubUtils utils;
 private TopicConnection connection;
 private TopicSession session;
 private TopicPublisher publisher;

 public static void main(String[] args)
  throws NamingException, JMSException, IOException {
  StandalonePublisher publisher = new StandalonePublisher();
  publisher.connect();
  String message = "ignored";
  while (message.length() > 0) {
   byte[] input = new byte[40];
   System.out.print("Enter a message: ");
   System.in.read(input);
   message = (new String(input, 0, input.length)).trim();
   if (message.length() > 0)
    publisher.sendMessage(message);
  }
  publisher.disconnect();
 }

 private StandalonePublisher() {
  utils = new PubSubUtils();
 }

 private void connect() throws NamingException, JMSException {
  connection = utils.getConnection();
  session =
   connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  publisher = session.createPublisher(utils.getTopic("hello"));
  System.out.println("Publisher started.");
 }

 private void sendMessage(String text) throws JMSException {
  Message message = session.createTextMessage(text);
  publisher.publish(message);
  System.out.println(
   "Published message <"
    + text
    + "> with ID <"
    + message.getJMSMessageID()
    + ">");
 }

 private void disconnect() throws JMSException {
  publisher.close();
  session.close();
  connection.close();
  System.out.println("Publisher stopped.");
 }
}

import java.io.IOException;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.TopicConnection;
import javax.jms.TopicSession;
import javax.jms.TopicSubscriber;
import javax.naming.NamingException;

public class StandaloneSubscriber implements MessageListener {

 private PubSubUtils utils;
 private TopicConnection connection;
 private TopicSession session;
 private TopicSubscriber subscriber;

 public static void main(String[] args)
  throws NamingException, JMSException, IOException {
  StandaloneSubscriber subscriber = new StandaloneSubscriber();
  subscriber.connect();
  System.in.read();
  subscriber.disconnect();
 }

 private StandaloneSubscriber() {
  utils = new PubSubUtils();
 }

 private void connect() throws NamingException, JMSException {
  connection = utils.getConnection();
  session =
   connection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
  subscriber = session.createSubscriber(utils.getTopic("hello"));
  subscriber.setMessageListener(this);
  connection.start();
  System.out.println("Subscriber started.");
 }

 public void onMessage(Message message) {
  try {
   TextMessage tMessage = (TextMessage) message;
   String text;
   text = tMessage.getText();
   System.out.println(
    "Received message <"
     + text
     + "> with ID <"
     + message.getJMSMessageID()
     + ">");
  } catch (JMSException e) {
   e.printStackTrace();
  }
 }

 private void disconnect() throws JMSException {
  subscriber.close();
  session.close();
  connection.stop();
  connection.close();
  System.out.println("Subscriber stopped.");
 }
}

public class JmsUtils {

   public static final String HOST_NAME = "192.168.0.63";
   public static final String CHANNELNAME = "chan1";
          public static final int CCSID = 1381;
          public static final String QMGRNAME = "channel1";

}

import javax.jms.JMSException;
import com.ibm.mq.jms.MQQueue;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import com.ibm.mq.jms.MQQueueConnectionFactory;
import com.ibm.mq.*;

public class P2PUtils extends JmsUtils {

 public QueueConnection getConnection()
  throws   JMSException{
               com.ibm.mq.jms.MQQueueConnectionFactory factory = new
               com.ibm.mq.jms.MQQueueConnectionFactory();

               factory.setHostName(this.HOST_NAME);
               factory.setCCSID(this.CCSID);
               factory.setChannel(this.CHANNELNAME);

               factory.setQueueManager(this.QMGRNAME);
               return  factory.createQueueConnection();
 }

 public Queue getQueue(String queuename) throws JMSException,MQException {
          return new com.ibm.mq.jms.MQQueue(queuename);
   }
}

import java.io.IOException;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.QueueConnection;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.naming.NamingException;

import com.ibm.mq.*;

public class StandaloneSender {

 private P2PUtils utils;
 private QueueConnection connection;
 private QueueSession session;
 private QueueSender sender;

 public static void main(String[] args)
  throws NamingException, JMSException, IOException,MQException {
  StandaloneSender sender = new StandaloneSender();
  sender.connect();
  String message = "ignored";
  while (message.length() > 0) {
   byte[] input = new byte[40];
   System.out.print("Enter a message: ");
   System.in.read(input);
   message = (new String(input, 0, input.length)).trim();
   if (message.length() > 0)
    sender.sendMessage(message);
  }
  sender.disconnect();
 }

 private StandaloneSender() {
  utils = new P2PUtils();
 }

 private void connect() throws  JMSException,MQException {
  connection = utils.getConnection();
  session =
   connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
  sender = session.createSender(utils.getQueue("t1"));
          System.out.println("Sender started.");
 }

 private void sendMessage(String text) throws JMSException {

  Message message = session.createBytesMessage();
  sender.send(message);
  System.out.println(
   "Sent message <"
    + text
    + "> with ID <"
    + message.getJMSMessageID()
    + ">");
 }

 private void disconnect() throws JMSException {
  sender.close();
  session.close();
  connection.close();
  System.out.println("Sender stopped.");
 }
}

import java.io.IOException;

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.QueueConnection;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.jms.Session;
import javax.jms.TextMessage;
import javax.jms.BytesMessage;
import javax.naming.NamingException;
import com.ibm.mq.*;

public class StandaloneReceiver implements MessageListener {

 private P2PUtils utils;
 private QueueConnection connection;
 private QueueSession session;
 private QueueReceiver receiver;

 public static void main(String[] args)
  throws NamingException, JMSException, IOException ,MQException{
  StandaloneReceiver receiver = new StandaloneReceiver();
  receiver.connect();
  System.in.read();
  receiver.disconnect();
 }

 private StandaloneReceiver() {
  utils = new P2PUtils();
 }

 private void connect() throws NamingException, JMSException,MQException {
  connection = utils.getConnection();
  session =
   connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
  receiver = session.createReceiver(utils.getQueue("t1"));
  receiver.setMessageListener(this);
  connection.start();
  System.out.println("Receiver started.");
 }

 public void onMessage(Message message) {
  try {
   BytesMessage tMessage = (BytesMessage) message;
   byte[] bytes = null;
   tMessage.readBytes(bytes);

  } catch (JMSException e) {
   e.printStackTrace();
  }
 }

 private void disconnect() throws JMSException {
  receiver.close();
  session.close();
  connection.stop();
  connection.close();
  System.out.println("Receiver stopped.");
 }
}

import com.ibm.mq.*;
import com.ibm.mq.pcf.*;

try
           {
                   PCFMessageAgent agent;
                   PCFMessage  request;
                   PCFMessage []  responses;
                   // Connect a PCFAgent to the specified queue manager

                   agent = new PCFMessageAgent ("channel1");
                   System.out.println ("DEFINE CONNECTION PARMENT....");

                   //agent = new PCFMessageAgent ("xxx");
                   //远程连接的试验一直没有作通，遗憾

                   //agent = new PCFMessageAgent ("channel1");        //本地channel1 是队列管理器的名字

                   //agent = new PCFMessageAgent ("MMM");
                  // SYSTEM.DEF.SVRCONN

                   System.out.println ("Connected.");
                   agent.setCharacterSet(1381);
                   // Build the PCF request

                  /**创建队列管理器   无法创建 没有提供创建命令
                   *
                   */

                   //创建通道

                   request = new PCFMessage (CMQCFC.MQCMD_CREATE_CHANNEL);
                   request.addParameter(CMQCFC.MQCACH_CHANNEL_NAME,"mama");
                   request.addParameter(CMQCFC.MQIACH_CHANNEL_TYPE,CMQXC.MQCHT_SVRCONN);

                   //request.addParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_TYPE,CMQXC.MQXPT_TCP);

                   //创建本地队列
                   /*
                  request = new PCFMessage (CMQCFC.MQCMD_CREATE_Q);
                  request.addParameter(CMQC.MQCA_Q_NAME,"tyty");
                  request.addParameter(CMQC.MQIA_Q_TYPE,CMQC.MQQT_LOCAL);
                  */
                 //创建进程
                  /*
                  request = new PCFMessage (CMQCFC.MQCMD_CREATE_PROCESS);
                  request.addParameter(CMQC.MQCA_PROCESS_NAME,"testtd");
                  request.addParameter(CMQC.MQCA_PROCESS_DESC,"tttt");
                  */

                   // Use the agent to send the request

                   System.out.print ("Sending PCF request... ");
                   //responses =  agent.send (request);
                   //查询队列
                   /*
                        request = new PCFMessage (CMQCFC.MQCMD_INQUIRE_Q_NAMES);
                        request.addParameter (CMQC.MQCA_Q_NAME, "*");
                        request.addParameter (CMQC.MQIA_Q_TYPE, MQC.MQQT_LOCAL);
                   */
                       responses = agent.send (request);
              /*
                       String []  names = (String []) responses [0].getParameterValue (CMQCFC.MQCACF_Q_NAMES);

         for (int i = 0; i < names.length; i++)
         {
                 System.out.println ("Queue: " + names [i]);
         }
          */

 

 

                   System.out.println ("Received reply.");
                   // Disconnect
                   System.out.print ("Disconnecting... ");
                   agent.disconnect ();
                   System.out.println ("Done.");
           }

           catch (ArrayIndexOutOfBoundsException abe)
           {
                   System.out.println ("Usage: \n" +
                           "\tjava PCFMessageListQManagerAttrs queue-manager\n" +
                           "\tjava PCFMessageListQManagerAttrs host port channel");
           }

           catch (NumberFormatException nfe)
           {
                   System.out.println ("Invalid port: " + args [1]);
                   System.out.println ("Usage: \n" +
                           "\tjava PCFMessageListQManagerAttrs queue-manager\n" +
                           "\tjava PCFMessageListQManagerAttrs host port channel");
           }

           catch (PCFException pcfe)
           {
                  // System.err.println ("Error in response: ");
                   //pcfe.printStackTrace();
                   PCFMessage []  responses = (PCFMessage []) pcfe.exceptionSource;

                   for (int i = 0; i < responses.length; i++)
                   {
                           System.out.println (responses [i]);
                   }
           }

           catch (MQException mqe)
           {
                   System.err.println (mqe);
                   mqe.printStackTrace();
           }

           catch (IOException ioe)
           {
                   System.err.println (ioe);
           }

      catch(Exception e)
           {
             e.printStackTrace();
           }

要创建健壮并且可处理所有情况的异步 Web Service 或 Java 控件，建议您同时实现回调和轮询接口。您的设计可能（除了别的以外）包括下列方法：

·                     客户端为了启动请求将调用的 start_request_asynch 缓冲方法。该方法可开始对话，并且将在结果准备就绪时使用回调机制。

·                     在请求完成时向客户端发送结果并结束对话的 callback_results 缓冲回调。

·                     客户端为了启动请求将调用的 start_request_synch 缓冲方法。该方法可开始对话，并在结果准备就绪时使用轮询机制。

·                     客户端将定期调用以检查请求状态的 check_status 非缓冲方法。该方法可继续对话，并返回指示是否已处理完请求的布尔值。

·                     客户端为了获取请求结果将调用的 get_results 非缓冲方法。该方法可结束对话

 

关于回调和轮询另外文章详细介绍。 

高坡黄土
尘飞杨
额上青筋
身上汗泥
光身子
破棉袄
麻绳腰间捆
浑身一抖
狂吼
秦人之腔
八百里传

秦砖汉瓦
墙根下
楚河汉界
车轮马炮
红辣子
一碗面
浇上肉臊子
双脚踏着
凳子
秦人之面
全球享誉

陪我征程3载
风里雨里
南二环长途跋涉
体育场陪我暴晒
朝阳和玉祥穿梭
歇息在潮湿的地下室
尘头封闭了你的风采
头部已经损坏
出租车将你狠狠 撞击
你依然挺立

当再次踏上征程
依然飞快 利索
为你的小主人 省下一口奶粉
你无怨
时间定格在7月18日晨
你不见了
可恶的贼
留下的只有愧疚的心
你在的时候没有好好
拾掇你
最后一天 你的前轮还是不舒服的运转
别了 我的野驴
愿新的主人 不会虐待
给你新生

童年纪事
        --纪念我美好的童年 （铅笔）
小学
铅笔很缺
每次 只能买一根铅笔

能用尾巴带橡皮的铅笔
是奢侈的

买来新的
母亲总是截断 分两次用
怕我丢

（圆珠笔）
没有笔筒
只有笔芯
那时候的油墨很油
蓝得很纯正

父亲找来扫帚
抽出最粗的一根
截取一段
将笔芯 用纸固定在竹筒里
结结实实
用起来很带劲

（作业本）
晚上
买了一大张白纸
父亲开始给我裁开
32开的时候
母亲给我用针线
缝起来
我很仔细的给封面
写下自己的名字

大队的药铺搬家了
和小伙伴去玩
捡到好多旧处方
里面可以寻找到
外公看病的纪录
久远的处方
父亲给我订了来
当验草纸用

（文具盒）
小学的文具盒经历了3个阶段
蒙蒙的 铅笔只有一根 很珍惜
用不到文具盒来保管

等到用圆珠笔的时候
用的是废弃的纸盒
那是打针后剩下的
很容易压碎
不知道因为压碎它 伤心了几次

后来
亲戚的孩子用旧的一个
给我了
我用完了
又给了表弟

（电影）
很小的时候 村里仓库放《人生》
清晰的记得 寻死悯活的找母亲要
了5分钱，看了电影的结尾
没看懂
看我多不懂事

和伙伴们成群结对去临村
冬天 不穿袜子 哆嗦着柴禾垛 看电影
竟然看过好多国外的 佐罗
小时候 就看了大片 幸福吧
散场了 大家结伴狂奔回家
小脚伸进暖被窝 幸福 舒服

从初中到高中毕业
对电影没有印象
只知道4大天王 却不知道是干什么的
不知道国奥队和国家队的区别，光知道是踢足球的
知识贫乏令人震惊

大学的时候
留心着补全了自己的残缺
可以看到电影了
用饭票看电影
好多大片

工作了 就去电影院看过一次电影
还是赠票

（钢笔）
那时候
我的字很臭
我哥上学的时候
还有描红
我那时候没有了

我哥喜欢画画
我也就跟着练字

钢笔 父亲说上初中才能给我买
只有哭了

那时候
孩子的眼泪 是不值钱的

我捡了一个
据为己有 我不是好学生
是红色的 很短 象个小女人
但是我很喜欢
我喜欢用钢笔写字
这是我的处女笔

后来
用了一个很重的钢笔
笔干很粗 钢笔头顶端珠子很大 象个西北汉子
粗矿
后来就养成了
用重笔的习惯

好多年没有用钢笔了

（1年级的同桌）
很瘦小的一个女孩
她的父亲是干公（在县城工作）的
那时候的记忆已经很模糊
只记得
寒冷的冬天 一起打闹

用我那脏兮兮的破棉帽
在教师 转圈
旁边总是小伙伴们善意的笑声

只记得她的眼睛很大
好像是遗传了她妈的基因
我们一直上到小学3年级
后来她就离开村子去城里了

从此再也没有见过面
小学的同桌 你过的好吗？

（学校的花园墙被我撞倒了）
小孩的贪玩
是大人有时候无法理解的

一个大风的下午
课间时刻
大家都编着纸飞机
比着看谁的飞的高

我的升空后
遥遥直上
高兴的雀跃
飞机滑行的很远
飘到了学校的中心花园

这么优秀的飞机
我是要捡回来得
无奈 个子低
花园的围墙 不牢靠
就这样倒了

老师是严厉的
在办公室里
纠的我胸前的肉皮
生疼
“让你父亲来给我砌好”

父亲是慈祥的
在烈日下
我帮父亲搬转头

（我得奖状了）
记忆中
小学就得过两次
二年级得时候
我得奖状了

因为我期中考试不及格
期末得时候 考了平均80多
进步大了

我从来不自信 自己能得奖
小孩得兴奋是激烈得
彻夜不眠

（电视机）
那时候电视很少
村里有个17得黑白电视
到了晚上
大家都去看
记忆中有
《黑奴》
《夜幕下得哈尔滨》
《这里得黎明静悄悄》
《血疑》
《排球女将》

它坏了以后
慢慢有些人家
买了彩电了
我也大了些
这个时期
总是蹭电视看
《再向虎上行》
《霍元甲》
《陈真》
《乌龙山剿匪记》

母亲看到我们总是
冬天很冷得蹭电视
鼓动父亲买了一台
海燕组装黑白电视
这时候得记忆里电视
反而少了
83《射雕英雄传》

后来工作了
给父母买了彩电