少年阿宾

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.blogjava.net/zhaozhenlin1224/archive/2010/02/03/311783.html

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

Axis2生成客户端方式

基于StockQuoteService类创建客户端的四种方式

构建基于AXIOM的客户端；

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

使用XMLBeans生成客户端；

使用JiBX生成客户端。

ADB：最简单的生成Axis客户端的方法。大部分情况下，这些主要的类都会以内部类的形式创建在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用起来更复杂。他会产成大量的文件，编程模型不如ADB直观。
    JiBX:他是一个数据绑定框架。他不仅提供了WSDL－JAVA的转换，而且提供了JAVA－XML的转换。JiBX相当灵活，允许你选择类来代表你的实体，但是这个却不好做，但还句话说，如果这些都能建好，那么使用JiBX就更使用ADB一样容易。

对于简单应用来说ADB已经够用了，如果想用更加强大更加灵活的功能，那么你可能需要使用其他两种方式。

Axis2提供的四种调用模式

node.selectNodes("//xml");
node.selectNodes("/xml");
node.selectNodes("xml");
这三个写法有什么区别

不是很明白
就举个例子吧
<root>
 <xml>1</xml>
 <node>
  <xml>2</xml>
  <AAA>
   <xml>3</xml>
  </AAA>
 </node>
</root>
从node搜索的话，这三种方法分别能搜到1、2、3中的哪几个？

nodename  选取此节点的所有子节点
/  从根节点选取
//  从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置

参考资料：http://www.w3school.com.cn/xpath/xpath_syntax.asp

      在这里我们首先学习一下公共方法wait,notify,notifyAll。

      wait方法可以使在当前线程的对象等待，直到别的线程调用此对象的notify或notifyAll方法（注意：调用的是此对象的notify和notifyAll），并且当前运行的线程必须具有此对象的对象监视器

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创建多少线程，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));
         }
        
        
         //创建线程池，每次调用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;
  }
}