SOAP客户端

最新推荐文章于 2024-09-02 08:46:29 发布

weixin_33807284

最新推荐文章于 2024-09-02 08:46:29 发布

阅读量476

点赞数

文章标签： java

原文链接：http://blog.51cto.com/nicaipu/1175244

版权

１.主要是为了加强对SOAP远程方法调用的学习，特意自己写了一个SOAP Client端．
２.要求环境:JDK1.6 以上,Axis2 以上
３.主要代码

package com.googlecode.soap.client;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.net.URL;
import com.googlecode.soap.client.SoapResponse.Status;
import com.googlecode.soap.util.ExecuteThreadPool;
public class SoapServiceClient {
private String address;
private String namespace;
public static long MAX_TIME_OUT = 10000; // 10秒
private SoapResponse response;
static ExecuteThreadPool executor = new ExecuteThreadPool(5);
public final Object lock = new Object();
URL url = null;
Socket socket = null;
private void init(SoapRequest request){
this.response = null;
request.context = this;
}
public SoapServiceClient(String address) throws Exception, IOException {
this.address = address;
if (!this.address.endsWith("?wsdl")) {
thisthis.address = this.address + "?wsdl";
}
this.url = new URL(this.address);
socket = new Socket(url.getHost(), url.getPort());
}
public String getNamespace() {
return namespace;
}
public void setNamespace(String namespace) {
this.namespace = namespace;
}
public void sendRequest(final SoapRequest request) {
this.init(request);
// 多线程环境下发送
executor.execute(new Runnable() {
public void run() {
OutputStream os = null;
InputStream input = null;
PrintStream ps = null;
ByteArrayOutputStream bos = null;
try {
String send = request.toString();
if( socket.isClosed()) {
socket = new Socket(url.getHost(), url.getPort());
}
socket.setSoTimeout((int)MAX_TIME_OUT);
os = socket.getOutputStream();
ps = new PrintStream(os, true, request.getCode());
ps.println(send);
input = socket.getInputStream();
int available = input.available();
if (available <= 0) {
long current= System.currentTimeMillis();
for(;;){
input = socket.getInputStream();
available = input.available();
if(available > 0 ) {
break;
}
if(System.currentTimeMillis()-current >= MAX_TIME_OUT ) {
synchronized(lock) {
response = new SoapResponse("TimeOut Exception", Status.TIMEOUT,null);
return ;
}
}
}
}
bos = new ByteArrayOutputStream();
byte[] buffer = new byte[256];
int totalRead = 0;
while (true) {
int nRead = input.read(buffer);
totalRead += nRead;
bos.write(buffer, 0, nRead);
if (totalRead >= available) {
break;
}
}
String responseString = bos.toString(request.getCode());
System.out.println("response=\r\n" + responseString);
synchronized(lock) {
response = new SoapResponse(responseString,request.getInvocation().getReturnType());
}
} catch (Exception e) {
e.printStackTrace();
synchronized(lock) {
response = new SoapResponse("RequestError", Status.ServerError,null);
}
} finally {
try {
if (ps != null) {
ps.close();
}
if (os != null) {
os.close();
}
if (input != null) {
input.close();
}
if (bos != null) {
bos.close();
}
if (socket != null) {
socket.close();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
ps = null; os =null; input = null; bos =null;
}
}
}
});
}
public SoapResponse getResponse() {
if (this.response == null) {
long current = System.currentTimeMillis();
for (;;) {
if (System.currentTimeMillis() - current >= MAX_TIME_OUT) {
synchronized (lock) {
return this.response;
}
}
if (this.response != null) {
synchronized (lock) {
return this.response;
}
}
}
}
synchronized (lock) {
return this.response;
}
}
}
ackage com.googlecode.soap.util;
import java.util.HashSet;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class ExecuteThreadPool implements Executor {
private final int maxPoolSize ;
private long idelTime = 0 ;
private int realSize = 0 ;
//线程池是否关?
private boolean poolClosed = false;
private final HashSet<Worker> workers = new HashSet<Worker>();
private final ReentrantLock mainLock = new ReentrantLock();
//工作队列
private final BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();;
public ExecuteThreadPool(int maxPoolSize) {
this.maxPoolSize = maxPoolSize;
}
/**
* @param maxPoolSize int 线程池中可用的线程的大小
* @param idelTime 单位毫秒，当线程池所有的线程忙的时??
* ?等待的时?超出这个等待时间，抛出异?
*
* */
public ExecuteThreadPool(int poolSize,long idelTime) {
this.maxPoolSize = poolSize;
this.idelTime = idelTime;
}
@Override
public void execute(Runnable command) {
if (command == null) {
throw new IllegalArgumentException("command argument can't be null");
}
if(this.poolClosed) {
throw new RuntimeException("Current pool was closed.");
}
//线程池还没有满，新建线程直接运行
if (realSize < maxPoolSize) {
this.newThread(command).start();
} else {
//主线程负责workQueue工作队列。准备战斗
this.workQueue.offer(command);
}
}
//强制关闭线程
public void shutdown(){
this.mainLock.lock();
Iterator<Worker> it = workers.iterator();
while(it.hasNext()) {
Worker w = it.next();
ww.status = w.exited;
w.shutdown();
}
workers.clear();
workQueue.clear();
this.poolClosed = true;
this.mainLock.unlock();
}
private Thread newThread(Runnable command){
//用Worker来封?command,因为Worker也继承Runnable.
Worker worker = new Worker(command);
Thread t = new Thread(worker);
worker.thread = t;
thisthis.realSize = this.realSize + 1;
t.setName("pool-" + this.realSize);
workers.add(worker);
return t;
}
// 线程工作执行
private class Worker implements Runnable {
//已准备
public final int ready = 1;
//在工作
public final int working = 2;
//在等待
public final int waiting = 3;
//已退出
public final int exited = 4;
//当前线程工作执行者的状态，默认是 ready
public int status = ready;
private final ReentrantLock runLock = new ReentrantLock();
private Runnable task;
Thread thread = null;
Worker( Runnable task) {
this.task = task;
thisthis.status = this.ready;
}
@Override
public void run() {
Runnable runTask = this.task;
for (;;) {
if (runTask != null) {
try {
this.runTask(runTask);
} catch (RuntimeException e) {
;
}
runTask = null;
}
try {
runTask = getTask();
} catch (InterruptedException ie) {
thisthis.status = this.exited;
break;
}
}
}
void shutdown(){
if ( thread != Thread.currentThread()) {
thread.interrupt();
}
}
private void runTask(Runnable task) {
try {
final ReentrantLock runLock = this.runLock;
runLock.lock();
thisthis.status = this.working;
task.run();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
runLock.unlock();
}
}
private Runnable getTask() throws InterruptedException {
for (;;) {
Runnable task = null;
//工作队列非空，直接调用poll方法获取.
if (!workQueue.isEmpty()) {
task = workQueue.poll();
} else {
try {
//如果设置了idelTime 的?,调用poll方法获取元素，超出idelTime时间，抛?InterruptedException
if( idelTime != 0L ) {
task = workQueue.poll(idelTime, TimeUnit.MILLISECONDS);
} else {
//Worker线程负责获取方法，从工作队列头获取对象并删除队列中要获取的对象，如果队列为空，一直等?
task = workQueue.take();
}
} catch (InterruptedException e) {
throw e;
} catch(Exception e) {
;
}
}
if (task != null) {
return task;
}
thisthis.status = this.waiting;
}
}
}
}
ackage com.googlecode.soap.util;
import java.lang.reflect.Field;
public final class XmlUnitl {
public static final String SPACE_CHAR = "";
public static final String LEFT_SEQ = "<";
public static final String RIGHT_SEQ = ">";
public static String toXml(Object object) {
if (object == null) {
return SPACE_CHAR;
}
if (object.getClass().getName().equals(String.class.getName())) {
return object.toString();
} else if (object.getClass().getName().equals(Integer.class.getName())) {
return object.toString();
} else if (object.getClass().getName().equals(Float.class.getName())) {
return object.toString();
} else if (object.getClass().getName().equals(Double.class.getName())) {
return object.toString();
} else if (object.getClass().getName().equals(Long.class.getName())) {
return object.toString();
} else if (object.getClass().getName().equals(Long.class.getName())) {
return object.toString();
}
Field fields[] = object.getClass().getDeclaredFields();
if (fields == null || fields.length == 0) {
return SPACE_CHAR;
}
StringBuffer buffer = new StringBuffer();
for (Field field : fields) {
String name = field.getName();
field.setAccessible(true);
try {
Object value = field.get(object);
if (value != null) {
buffer.append(LEFT_SEQ + name + RIGHT_SEQ + value
+ LEFT_SEQ + "/" + name + RIGHT_SEQ);
}
} catch (Exception e) {
;
}
}
return buffer.toString();
}
}
package com.googlecode.soap.test;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import com.googlecode.soap.client.MethodInvocation;
import com.googlecode.soap.client.SoapRequest;
import com.googlecode.soap.client.SoapResponse;
import com.googlecode.soap.client.SoapServiceClient;
public class SoapTest {
public static void main(String[] args) throws Exception {
SoapServiceClient client = new SoapServiceClient("http://www.nicaipu.com:8099/axis2/services/SimpleService?wsdl");
MethodInvocation method = new MethodInvocation("getPrice",new Object[]{44},null);
SoapRequest request = new SoapRequest(method);
request.setCode("utf-8");
//client.setNamespace("http://webservice.chapter1.book/client");
BufferedReader systemIn=new BufferedReader(new InputStreamReader(System.in));
boolean flag=true;
while(flag){
String command=systemIn.readLine();
if( command==null || "quit".equalsIgnoreCase(command.trim())){
flag=false;
System.out.println("Client quit!");
continue;
} else if( "send".equalsIgnoreCase(command.trim())) {
System.out.println("send command..");
client.sendRequest(request);
SoapResponse response = client.getResponse();
System.out.println(response.getObject());
}
}
}
}