少年阿賓

http://blog.csdn.net/leo821031/article/details/1545974

http://zhangjunhd.blog.51cto.com/113473/25592/

http://hi.baidu.com/lennydou/item/b57032c0ceb6f5b00c0a7b08

http://www.cnblogs.com/markxue/archive/2012/09/01/2667123.html

http://www.aygfsteel.com/zhaozhenlin1224/archive/2010/02/03/311783.html

http://blog.csdn.net/yhhah/article/details/4158487

Axis2生成客戶端方式

基于StockQuoteService類創(chuàng)建客戶端的四種方式

構(gòu)建基于AXIOM的客戶端；

使用Axis2 Databinding Frame work(ADB)生成客戶端；

使用XMLBeans生成客戶端；

使用JiBX生成客戶端。

ADB：最簡單的生成Axis客戶端的方法。大部分情況下，這些主要的類都會以內(nèi)部類的形式創(chuàng)建在stub類中。It is not meant to be a full schema bindingapplication, and has difficulty with structures such as XML Schema element extensions and restrictions。 be meant to：有意要、打算
    XMLBeans:與ADB不同，他是一個全功能的schema編譯器。他沒有ADB的限制。然而，他也比ADB用起來更復雜。他會產(chǎn)成大量的文件，編程模型不如ADB直觀。
    JiBX:他是一個數(shù)據(jù)綁定框架。他不僅提供了WSDL－JAVA的轉(zhuǎn)換，而且提供了JAVA－XML的轉(zhuǎn)換。JiBX相當靈活，允許你選擇類來代表你的實體，但是這個卻不好做，但還句話說，如果這些都能建好，那么使用JiBX就更使用ADB一樣容易。

對于簡單應用來說ADB已經(jīng)夠用了，如果想用更加強大更加靈活的功能，那么你可能需要使用其他兩種方式。

Axis2提供的四種調(diào)用模式

node.selectNodes("http://xml");
node.selectNodes("/xml");
node.selectNodes("xml");
這三個寫法有什么區(qū)別

不是很明白
就舉個例子吧
<root>
 <xml>1</xml>
 <node>
  <xml>2</xml>
  <AAA>
   <xml>3</xml>
  </AAA>
 </node>
</root>
從node搜索的話，這三種方法分別能搜到1、2、3中的哪幾個？

nodename  選取此節(jié)點的所有子節(jié)點
/  從根節(jié)點選取
//  從匹配選擇的當前節(jié)點選擇文檔中的節(jié)點，而不考慮它們的位置

參考資料：http://www.w3school.com.cn/xpath/xpath_syntax.asp

      在這里我們首先學習一下公共方法wait,notify,notifyAll。

      wait方法可以使在當前線程的對象等待，直到別的線程調(diào)用此對象的notify或notifyAll方法（注意：調(diào)用的是此對象的notify和notifyAll），并且當前運行的線程必須具有此對象的對象監(jiān)視器

package com.abin.lee.thread.thread;

public class CarryTask extends Thread {
 public void run() {
        try {
            synchronized (this) {
                Thread t = Thread.currentThread();
                System.out.println(t.getId() + t.getName() + ":task start, wait for notify...");
                this.wait();
                System.out.println(t.getId() + t.getName() + ":task continue...");
            }
        } catch (InterruptedException ex) {
           System.out.println(CarryTask.class.getName());
        }
    }

}

package com.abin.lee.thread.thread;

public class CarryWait {
 public static void main(String[] args) throws InterruptedException {
  CarryTask task = new CarryTask();
  Thread t = Thread.currentThread();
  System.out.println(t.getId() + t.getName() + ":task start...");
  task.start();
  Thread.sleep(2000);
  synchronized (task) {
   System.out.println("id="+Thread.currentThread().getId()+",Name="+Thread.currentThread().getName()+",task="+task+",notify");
   task.notify();
  }
 }

}

package com.abin.lee.junit.httpasyncclient.example;

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
 import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import org.junit.Test;
 
 public class ThreadPoolHttpClient {
     // 線程池
     private ExecutorService exe = null;
     // 線程池的容量
     private static final int POOL_SIZE = 20;
     private HttpClient client = null;
     String[] urls=null;
     public ThreadPoolHttpClient(String[] urls){
         this.urls=urls;
     }
     @Test
     public void test() throws Exception {
         exe = Executors.newFixedThreadPool(POOL_SIZE);
         HttpParams params =new BasicHttpParams();
         /* 從連接池中取連接的超時時間 */
         ConnManagerParams.setTimeout(params, 1000);
        /* 連接超時 */
         HttpConnectionParams.setConnectionTimeout(params, 2000);
         /* 請求超時 */
         HttpConnectionParams.setSoTimeout(params, 4000);
         SchemeRegistry schemeRegistry = new SchemeRegistry();
        schemeRegistry.register(
                 new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
 
         //ClientConnectionManager cm = new PoolingClientConnectionManager(schemeRegistry);
         PoolingClientConnectionManager cm=new PoolingClientConnectionManager(schemeRegistry);
         cm.setMaxTotal(10);
         final HttpClient httpClient = new DefaultHttpClient(cm,params);
 
         // URIs to perform GETs on
         final String[] urisToGet = urls;
         /* 有多少url創(chuàng)建多少線程，url多時機子撐不住
56         // create a thread for each URI
57         GetThread[] threads = new GetThread[urisToGet.length];
58         for (int i = 0; i < threads.length; i++) {
59             HttpGet httpget = new HttpGet(urisToGet[i]);
60             threads[i] = new GetThread(httpClient, httpget);           
61         }
62         // start the threads
63         for (int j = 0; j < threads.length; j++) {
64             threads[j].start();
65         }
66
67         // join the threads，等待所有請求完成
68         for (int j = 0; j < threads.length; j++) {
69             threads[j].join();
70         }
71         使用線程池*/
         for (int i = 0; i < urisToGet.length; i++) {
             final int j=i;
             System.out.println(j);
             HttpGet httpget = new HttpGet(urisToGet[i]);
             exe.execute( new GetThread(httpClient, httpget));
         }
        
        
         //創(chuàng)建線程池，每次調(diào)用POOL_SIZE
         /*
         for (int i = 0; i < urisToGet.length; i++) {
             final int j=i;
             System.out.println(j);
             exe.execute(new Thread() {
                 @Override
                 public void run() {
                     this.setName("threadsPoolClient"+j);
                    
                         try {
                             this.sleep(100);
                             System.out.println(j);
                         } catch (InterruptedException e) {
                             // TODO Auto-generated catch block
                             e.printStackTrace();
                         }
                        
                         HttpGet httpget = new HttpGet(urisToGet[j]);
                         new GetThread(httpClient, httpget).get();
                     }
                    
                    
                
             });
         }
        
         */
         //exe.shutdown();
         System.out.println("Done");
     }
     static class GetThread extends Thread{
        
         private final HttpClient httpClient;
         private final HttpContext context;
         private final HttpGet httpget;
        
         public GetThread(HttpClient httpClient, HttpGet httpget) {
             this.httpClient = httpClient;
             this.context = new BasicHttpContext();
             this.httpget = httpget;
         }
         @Override
         public void run(){
             this.setName("threadsPoolClient");
             try {
                 Thread.sleep(5000);
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             get();
         }
        
         public void get() {
             try {
                 HttpResponse response = this.httpClient.execute(this.httpget, this.context);
                 HttpEntity entity = response.getEntity();
                 if (entity != null) {
                     System.out.println(this.httpget.getURI()+": status"+response.getStatusLine().toString());
                 }
                 // ensure the connection gets released to the manager
                 EntityUtils.consume(entity);
             } catch (Exception ex) {
                 this.httpget.abort();
             }finally{
                 httpget.releaseConnection();
             }
         }
     }
 }

package com.abin.lee.junit.httpasyncclient.service;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.util.Map;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HttpAsyncClientService extends HttpServlet{
 private static final long serialVersionUID = 807336917776643578L;

 @SuppressWarnings("rawtypes")
 public void service(HttpServletRequest request,HttpServletResponse response) throws IOException{
  Map map=request.getParameterMap();
  String id=(String)((Object[])map.get("id"))[0].toString();
  if(null!=id&&!"".equals(id)){
   String result=id+" is response";
   System.out.println("result="+result);
   ServletOutputStream out=response.getOutputStream();
   BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out,"UTF-8"));
   writer.write(result);
   writer.flush();
   writer.close();
  }else{
   String result=id+" is null";
   System.out.println("result="+result);
   ServletOutputStream out=response.getOutputStream();
   BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out,"UTF-8"));
   writer.write(result);
   writer.flush();
   writer.close();
  }
 }
}

package com.abin.lee.junit.httpasyncclient.example;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Future;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.concurrent.FutureCallback;
import org.apache.http.impl.nio.client.DefaultHttpAsyncClient;
import org.apache.http.nio.client.HttpAsyncClient;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.util.EntityUtils;

public class CreateAsyncClientHttpExchangeFutureCallback {
  public static void main(String[] args) throws Exception {
         HttpAsyncClient httpclient = new DefaultHttpAsyncClient();
         httpclient.getParams()
             .setIntParameter(CoreConnectionPNames.SO_TIMEOUT, 3000)
             .setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 3000)
             .setIntParameter(CoreConnectionPNames.SOCKET_BUFFER_SIZE, 8 * 1024)
             .setBooleanParameter(CoreConnectionPNames.TCP_NODELAY, true);

         httpclient.start();
         try {
             HttpGet[] requests = new HttpGet[] {
                     new HttpGet("http://localhost:7000/global/HttpAsyncClientService?id=6"),
                     new HttpGet("http://localhost:7000/global/HttpAsyncClientService?id=8"),
                     new HttpGet("http://localhost:7000/global/HttpAsyncClientService?id=5")
             };
             final CountDownLatch latch = new CountDownLatch(requests.length);
             for (final HttpGet request: requests) {
                 httpclient.execute(request, new FutureCallback<HttpResponse>() {

                     public void completed(final HttpResponse response) {
                         latch.countDown();
                         System.out.println(request.getRequestLine() + "->" + response.getStatusLine());
                     }

                     public void failed(final Exception ex) {
                         latch.countDown();
                         System.out.println(request.getRequestLine() + "->" + ex);
                     }

                     public void cancelled() {
                         latch.countDown();
                         System.out.println(request.getRequestLine() + " cancelled");
                     }

                 });
                 Future<HttpResponse> future = httpclient.execute(request, null);
                 HttpResponse response = future.get();
                 System.out.println("Response: " + response.getStatusLine());
                 System.out.println("Response1: " + EntityUtils.toString(response.getEntity()));
             }
             latch.await();
             System.out.println("Shutting down");
         } finally {
             httpclient.shutdown();
         }
         System.out.println("Done");
     }
  public static String AsyncHttp(){
  
   return null;
  }
}