一切皆可抽象

俗話說“沒有規矩，不成方圓。”俗話說“是藥均有三分毒。”俗話說：“創業難，守業更難。” 俗話說：“一分耕耘，一分收獲。” 俗話：“天下無難事，只怕有心人”―――在中國民間，成千上萬條這樣的俗話從出生那天起，就開始耳聞目染，甚至“俗話”已經侵入人的骨髓，成為“大綱文化”，成為我們思考的“定式”。

在辯論中，我們經常“引經據典”，動則以“俗話說的好―――”來加強自己的觀念，實際上這也是“不自信”的一種表現形式。愛引用俗話的人，是希望能拉上老祖宗留下的“至理名言”，來給自己的觀念擂鼓助威。但祖宗的東西未必就是好東西，有些俗話已經隨著時間的推移，與現實生活中的倫理和我們所倡導之風尚相駁，下面筆者列舉的十大俗話，就是害人不淺的“老祖宗遺風”。

１、天下烏鴉一般黑

害人指數：★★★★★

　　天下烏鴉一般黑，主張一竹桿打死一船人，一個活口兒也不留。在管理學上這叫“暈輪效應”，例如：談到東北人，馬上就有人接話道：“我知道，東北人都豪爽。”談到河南人，馬上就有人接話道：“我知道，河南人都愛騙。”談到日本人，馬上就有人接話道：“日本人，沒有一個好東西！”東北人都豪爽嗎？不一定！河南人都愛欺騙別人嗎？不一定！日本人都壞嗎？不一定。這些都是受到“天下烏鴉一般黑”俗話的影響，是這句俗話的變異思維。最慘的就是男人，有句俗話“是貓就愛偷腥吃。”這句俗話實際是“天下烏鴉一般黑”的翻版。主張把天下所有男人形容成“種牛”，如果你不是“種牛”，那一定得找“老軍醫”看看。

２、一個巴掌拍不響

害人指數：★★★★★

　　“一個巴掌拍不響”是中庸之道的產物，主張各打５０大板，誰都不能說吃虧，誰都不能說占便宜。我在南京讀大學那其間，學院規定：只要打架斗毆，一經核實，立即嚴肅處理，不管雙方是哪一方的責任，都要受到處分。這樣的校規制定者，就是受到大俗話“一個巴掌拍不響”的嚴重影響。實際上，有些時候，一個巴掌是能拍響的，例如用這巴掌拍墻，拍桌子，拍馬屁―――不一定非要拍另外那只巴掌。“一個巴掌拍不響”是仲裁方無能的表現，無法做到賞罰分明，只能和稀泥，做老好人，主張各退一步。例如上述那個校規，如果某同學打你，是否就被動等著挨打？打你還是輕的，例如媒體多次報道：某某在街上行走遭受到搶劫，你還能用“一個巴掌拍不響”的方式來處理問題嗎？“一個巴掌拍不響”實際上就是保護“強盜”，打擊“弱者”，向“惡勢力”妥協。

３、蒼蠅不叮無縫蛋

害人指數：★★★★★

　　蒼蠅不叮無縫蛋是散播和加速散播謠言的有力“理論基礎”。據《西部商報》２００５年０７月１４日報道，余某和把某是鄰居，在今年農歷三月份，村子里傳稱把某強*楊某。在謠言散播過程中，鄰居余某相信“蒼蠅不叮無縫蛋”，煽風點火，說把某一定是干了這件見不得人的事情，四處散播。最后把某忍無可忍，竟然用菜刀將鄰居家婦女余某的頭砍下。看，這大俗話“蒼蠅不叮無縫蛋”，不僅能害別人，還能害死相信這句話人的性命。

４、機會面前人人平等

害人指數：★★★☆☆

　　“機會面前人人平等”是成功者欺騙失敗者的有力借口、謊言和工具。在機會面前，不可能是人人平等的。什么是機會？機會就是給予具有某些掌握資源者的選擇和回報。例如招聘，某公司打出招聘總經理的廣告，對應聘者所要具有的條件列出若干。如果把總經理的職位看成一次機會，把看見這則消息的人視為“機會面前的人人”，表面上，大家都有相同的機會，但實際上根本就不是平等的機會。如：在條件上要求：碩士學位，大多數人就沒有機會了；再要求：在同等崗位上工作８年以上，又有一些人掉頭走了；再要求：在同行業內工作５年以上，恐怕所剩下的就那么幾個了；再要求：年齡―――這樣的機會，怎么能用人人平等來詮釋呢？一個市長的兒子和一個普通工人兒子站在同一個機會面前，他們能平等嗎？

５、人挪活，樹挪死

害人指數：★★★★★

　　“人挪活，樹挪死”是目前“跳槽族”自我“鼓勵”有力的理論支撐點。當在某個崗位上干得稍微不順心的時候，一些人就開始想入非非。我的一個堂弟，在長春某名校做老師。幾個月前，他給我打電話，讓我幫助他把他“弄到”長春土地規劃局去，被我拒絕了。他在做老師之前在區政府宣傳部干過幾年。“人挪活，樹挪死”這句大俗話，實際上并不符合現代社會的邏輯推理。生活在城市，街道兩旁的樹都是挪來的，都活得好好的，所以說“樹挪未必死”；人挪就活嗎？也不一定，看見過很多在各單位之間跳來跳去的人，也很少看見“有所突破和提高”，相反，到是有很多踏踏實實在原來崗位上努力勤奮的人，做出了一點成績，所以人挪也未必“活”。如果抱著“此處不留爺自有留爺處”的心態去工作，不管走到哪里，都是很難做出一番成績的。

６、有則改之，無則加勉

害人指數：★★★★★

　　“有則改之，無則加勉”是一把殺人不見血的刀。經常看見一些官狀模樣的人，說話喜歡旁敲側擊，聲東擊西，捕風捉影：“對于最近單位傳聞的咱單位內婚外戀問題，我們要給予足夠的重視，當然了，有則改之，無則加勉―――”，停者往往不知所措，說誰呢？大家猜測不止。本來很安靜的單位，一時間就會滿城風雨，議論紛紛。“有則改之，無則加勉”這句話，是給沒有“真憑實據”說話者找到殺人的“刀和槍”。

７、我過的橋比你走過的路還多

害人指數：★★★★☆

　　“我過的橋比你走過的路還多”通常是年長者對年輕人 “不聽話” 的告誡。判斷問題的對錯，和年齡無關。扯上年齡，就是“拉上虎皮”，為自己的心虛鼓勁壯膽。如果年齡就是一切，那么一個學校的校長一定是該校年齡最大的；一個企業的總經理一定是該公司最老的；一個國家的領導人一定都是百歲以上的老者―――事實是這樣的嗎？顯然不是！筆者說這個，不是對長者的不尊重，只是實事求是地說，對待某個具體問題，誰的觀念最接近“最優”，和年齡關系不大。“我過的橋比你走過的路還多”是對年輕人的不尊重，也是對知識的褻瀆，持有“我過的橋比你走過的路還多”觀念的人主張“論資排輩”。

８、老鄉見老鄉，兩眼淚汪汪

害人指數：★★★★★

　　“老鄉見老鄉，兩眼淚汪汪”，主張以地區為線，畫出友誼的大門。中國警務報道，３月１８日上午，南昌市公安局刑偵支隊三大隊將抓獲的殺人犯罪嫌疑人謝應福移交給廣州警方。據悉，謝應福為２０萬錢財，竟將從小一起長大的老鄉殺死。這里，就不是“老鄉見老鄉，兩眼淚汪汪”，而是“老鄉見老鄉，背后來一槍”了。近幾年來，老鄉謀害老鄉的案件時有發生，網友們一定要保持警惕，即不能見到老鄉就“不設防”，也不要一見老鄉就“談鄉色變”。中國人，要拋開“地域親熱”，了解一個人要全面地去考證，老鄉不是綠色通行證。

９、各掃門前雪

害人指數：★★★★★

　　“各掃門前雪，莫管他人瓦上霜”，主張圈地為牢，倡導“事不關己高高掛起。”各掃門前雪是自私自利的表現。這幾年幾乎每個季度都有媒體報道，有女孩在光天化日之下被強暴了，而且圍觀者數眾。這些圍觀的人實際上就是“各掃門前雪，莫管他人瓦上霜”這句大俗話堅定的支持者。現在小偷猖獗、搶劫犯瘋狂―――不能說跟“各掃門前雪”的信奉無關。在“各掃門前雪”的大俗話前，“見義勇為”正在淪落。

１０、友誼第一，比賽第二

害人指數：★★★☆☆

　　“友誼第一，比賽第二”是具有中國特色的中庸特產。主張把交流情感、加強感情放到第一位，比賽輸贏是次要的。真的能做到嗎？不可能！比賽就是要分輸贏的，就是要爭第一的，否則比賽就成了形式主義和工具。比賽中的參與者人也無法體驗比賽激烈對抗所帶來的精神享受，觀眾也看不見比賽的激情和懸念。這樣的比賽還能叫比賽嗎？“友誼第一，比賽第二”是虛偽的代名詞，實際各隊在比賽前都做了大量的準備工作，在賽場上也是火藥味十足，每一個運動員都打著“友誼第一，比賽第二”的幌子在干“比賽第一，友誼第二”的事業。“友誼第一，比賽第二”這句大俗話，特顯出中國人虛偽、矯揉、造作的一面。

可能大家都碰到過類似的問題  比如 “我國信息化工程發展迅速。”這句話中，出現了信息化 和 化工嵌套的關鍵詞，那么在加鏈接的時候如何處理？當然不可能兩個都加，只能加一個的情況下，只能通過給文檔定義類型，根據類型進行關鍵詞的類型指派。我這里實現了根據關鍵詞的順序進行替換，誰早先換誰。呵呵

關鍵詞實體
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《射雕英雄傳》

后來工作了
給父母買了彩電