blocks|key|355562|text|正如您从上面的答案中看到的，JAX-WS客户端代理不是线程安全的，所以我只想分享我的实现，让其他人缓存客户端代理。我实际上遇到了同样的问题，并决定创建一个spring+bean来缓存JAX-WS客户端代理。您可以查看更多详细信息http://programtalk.com/java/using-spring-and-scheduler-to-store/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|355563|import+java.util.Map;
import+java.util.concurrent.ConcurrentHashMap;
import+java.util.concurrent.Executors;
import+java.util.concurrent.ScheduledExecutorService;
import+java.util.concurrent.TimeUnit;

import+javax.annotation.PostConstruct;

import+org.apache.commons.lang3.concurrent.BasicThreadFactory;
import+org.apache.logging.log4j.Logger;
import+org.springframework.stereotype.Component;

/**
+*+This+keeps+the+cache+of+MAX_CUNCURRENT_THREADS+number+of
+*+appConnections+and+tries+to+shares+them+equally+amongst+the+threads.+All+the
+*+connections+are+created+right+at+the+start+and+if+an+error+occurs+then+the
+*+cache+is+created+again.
+*
+*/
/*
+*
+*+Are+JAX-WS+client+proxies+thread+safe?+ +According+to+the+JAX-WS+spec,
+*+the+client+proxies+are+NOT+thread+safe.+To+write+portable+code,+you+should
+*+treat+them+as+non-thread+safe+and+synchronize+access+or+use+a+pool+of
+*+instances+or+similar.
+*
+*/
@Component
public+class+AppConnectionCache+{

+private+static+final+Logger+logger+=+org.apache.logging.log4j.LogManager.getLogger(AppConnectionCache.class);

+private+final+Map<Integer,+MyService>+connectionCache+=+new+ConcurrentHashMap<Integer,+MyService>();

+private+int+cachedConnectionId+=+1;

+private+static+final+int+MAX_CUNCURRENT_THREADS+=+20;

+private+ScheduledExecutorService+scheduler;

+private+boolean+forceRecaching+=+true;+//+first+time+cache

+@PostConstruct
+public+void+init()+{
++logger.info("starting+appConnectionCache");
++logger.info("start+caching+connections");+;;
++BasicThreadFactory+factory+=+new+BasicThreadFactory.Builder()
++++.namingPattern("appconnectioncache-scheduler-thread-%25d").build();
++scheduler+=+Executors.newScheduledThreadPool(1,+factory);

++scheduler.scheduleAtFixedRate(new+Runnable()+{
+++@Override
+++public+void+run()+{
++++initializeCache();
+++}

++},+0,+10,+TimeUnit.MINUTES);

+}

+public+void+destroy()+{
++scheduler.shutdownNow();
+}

+private+void+initializeCache()+{
++if+(!forceRecaching)+{
+++return;
++}
++try+{
+++loadCache();
+++forceRecaching+=+false;+//+this+flag+is+used+for+initializing
+++logger.info("connections+creation+finished+successfully!");
++}+catch+(MyAppException+e)+{
+++logger.error("error+while+initializing+the+cache");
++}
+}

+private+void+loadCache()+throws+MyAppException+{
++logger.info("create+and+cache+appservice+connections");
++for+(int+i+=+0;+i+<+MAX_CUNCURRENT_THREADS;+i%2B%2B)+{
+++tryConnect(i,+true);
++}
+}

+public+MyPort+getMyPort()+throws+MyAppException+{
++if+(cachedConnectionId%2B%2B+==+MAX_CUNCURRENT_THREADS)+{
+++cachedConnectionId+=+1;
++}
++return+tryConnect(cachedConnectionId,+forceRecaching);
+}

+private+MyPort+tryConnect(int+threadNum,+boolean+forceConnect)+throws+MyAppException+{
++boolean+connect+=+true;
++int+tryNum+=+0;
++MyPort+app+=+null;
++while+(connect+&&+!Thread.currentThread().isInterrupted())+{
+++try+{
++++app+=+doConnect(threadNum,+forceConnect);
++++connect+=+false;
+++}+catch+(Exception+e)+{
++++tryNum+=+tryReconnect(tryNum,+e);
+++}
++}
++return+app;
+}

+private+int+tryReconnect(int+tryNum,+Exception+e)+throws+MyAppException+{
++logger.warn(Thread.currentThread().getName()+%2B+"+appservice+service+not+available!+:+"+%2B+e);
++//+try+10+times,+if
++if+(tryNum%2B%2B+<+10)+{
+++try+{
++++logger.warn(Thread.currentThread().getName()+%2B+"+wait+1+second");
++++Thread.sleep(1000);
+++}+catch+(InterruptedException+f)+{
++++//+restore+interrupt
++++Thread.currentThread().interrupt();
+++}
++}+else+{
+++logger.warn("+appservice+could+not+connect,+number+of+times+tried:+"+%2B+(tryNum+-+1));
+++this.forceRecaching+=+true;
+++throw+new+MyAppException(e);
++}
++logger.info("+try+reconnect+number:+"+%2B+tryNum);
++return+tryNum;
+}

+private+MyPort+doConnect(int+threadNum,+boolean+forceConnect)+throws+InterruptedException+{
++MyService+service+=+connectionCache.get(threadNum);
++if+(service+==+null+%7C%7C+forceConnect)+{
+++logger.info("app+service+connects+:+"+%2B+(threadNum+%2B+1)+);
+++service+=+new+MyService();
+++connectionCache.put(threadNum,+service);
+++logger.info("connect+done+for+"+%2B+(threadNum+%2B+1));
++}
++return+service.getAppPort();
+}
}|code-block|syntax|javascript|355564|entityMap|0|LINK|mutability|MUTABLE|url|http://programtalk.com/java/using-spring-and-scheduler-to-store/^0|36|1S|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

As you see from above answers that JAX-WS client proxies are not thread safe so I just wanted to share my implementation will others to cache the client proxies.
I actually faced the same issue and decided to create a spring bean that does the caching of the JAX-WS Client proxies. You can see more details <a href="http://programtalk.com/java/using-spring-and-scheduler-to-store/" rel="nofollow noreferrer">http://programtalk.com/java/using-spring-and-scheduler-to-store/</a>

<pre><code>import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Component;

/**
 * This keeps the cache of MAX_CUNCURRENT_THREADS number of
 * appConnections and tries to shares them equally amongst the threads. All the
 * connections are created right at the start and if an error occurs then the
 * cache is created again.
 *
 */
/*
 *
 * Are JAX-WS client proxies thread safe? &lt;br/&gt; According to the JAX-WS spec,
 * the client proxies are NOT thread safe. To write portable code, you should
 * treat them as non-thread safe and synchronize access or use a pool of
 * instances or similar.
 *
 */
@Component
public class AppConnectionCache {

 private static final Logger logger = org.apache.logging.log4j.LogManager.getLogger(AppConnectionCache.class);

 private final Map&lt;Integer, MyService&gt; connectionCache = new ConcurrentHashMap&lt;Integer, MyService&gt;();

 private int cachedConnectionId = 1;

 private static final int MAX_CUNCURRENT_THREADS = 20;

 private ScheduledExecutorService scheduler;

 private boolean forceRecaching = true; // first time cache

 @PostConstruct
 public void init() {
 logger.info("starting appConnectionCache");
 logger.info("start caching connections"); ;;
 BasicThreadFactory factory = new BasicThreadFactory.Builder()
 .namingPattern("appconnectioncache-scheduler-thread-%d").build();
 scheduler = Executors.newScheduledThreadPool(1, factory);

 scheduler.scheduleAtFixedRate(new Runnable() {
 @Override
 public void run() {
 initializeCache();
 }

 }, 0, 10, TimeUnit.MINUTES);

 }

 public void destroy() {
 scheduler.shutdownNow();
 }

 private void initializeCache() {
 if (!forceRecaching) {
 return;
 }
 try {
 loadCache();
 forceRecaching = false; // this flag is used for initializing
 logger.info("connections creation finished successfully!");
 } catch (MyAppException e) {
 logger.error("error while initializing the cache");
 }
 }

 private void loadCache() throws MyAppException {
 logger.info("create and cache appservice connections");
 for (int i = 0; i &lt; MAX_CUNCURRENT_THREADS; i++) {
 tryConnect(i, true);
 }
 }

 public MyPort getMyPort() throws MyAppException {
 if (cachedConnectionId++ == MAX_CUNCURRENT_THREADS) {
 cachedConnectionId = 1;
 }
 return tryConnect(cachedConnectionId, forceRecaching);
 }

 private MyPort tryConnect(int threadNum, boolean forceConnect) throws MyAppException {
 boolean connect = true;
 int tryNum = 0;
 MyPort app = null;
 while (connect &amp;&amp; !Thread.currentThread().isInterrupted()) {
 try {
 app = doConnect(threadNum, forceConnect);
 connect = false;
 } catch (Exception e) {
 tryNum = tryReconnect(tryNum, e);
 }
 }
 return app;
 }

 private int tryReconnect(int tryNum, Exception e) throws MyAppException {
 logger.warn(Thread.currentThread().getName() + " appservice service not available! : " + e);
 // try 10 times, if
 if (tryNum++ &lt; 10) {
 try {
 logger.warn(Thread.currentThread().getName() + " wait 1 second");
 Thread.sleep(1000);
 } catch (InterruptedException f) {
 // restore interrupt
 Thread.currentThread().interrupt();
 }
 } else {
 logger.warn(" appservice could not connect, number of times tried: " + (tryNum - 1));
 this.forceRecaching = true;
 throw new MyAppException(e);
 }
 logger.info(" try reconnect number: " + tryNum);
 return tryNum;
 }

 private MyPort doConnect(int threadNum, boolean forceConnect) throws InterruptedException {
 MyService service = connectionCache.get(threadNum);
 if (service == null || forceConnect) {
 logger.info("app service connects : " + (threadNum + 1) );
 service = new MyService();
 connectionCache.put(threadNum, service);
 logger.info("connect done for " + (threadNum + 1));
 }
 return service.getAppPort();
 }
}
</code></pre>

blocks|key|571255|text|一般的解决方案是在一个池中使用多个客户端对象，然后使用代理作为外观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|571256|import+org.apache.commons.pool2.BasePooledObjectFactory;
import+org.apache.commons.pool2.PooledObject;
import+org.apache.commons.pool2.impl.DefaultPooledObject;
import+org.apache.commons.pool2.impl.GenericObjectPool;

import+java.lang.reflect.InvocationHandler;
import+java.lang.reflect.Method;
import+java.lang.reflect.Proxy;

class+ServiceObjectPool<T>+extends+GenericObjectPool<T>+{
++++++++public+ServiceObjectPool(java.util.function.Supplier<T>+factory)+{
++++++++++++super(new+BasePooledObjectFactory<T>()+{
++++++++++++++++@Override
++++++++++++++++public+T+create()+throws+Exception+{
++++++++++++++++++++return+factory.get();
++++++++++++++++}
++++++++++++@Override
++++++++++++public+PooledObject<T>+wrap(T+obj)+{
++++++++++++++++return+new+DefaultPooledObject<>(obj);
++++++++++++}
++++++++});
++++}

++++public+static+class+PooledServiceProxy<T>+implements+InvocationHandler+{
++++++++private+ServiceObjectPool<T>+pool;

++++++++public+PooledServiceProxy(ServiceObjectPool<T>+pool)+{
++++++++++++this.pool+=+pool;
++++++++}


++++++++@Override
++++++++public+Object+invoke(Object+proxy,+Method+method,+Object[]+args)+throws+Throwable+{
++++++++++++T+t+=+null;
++++++++++++try+{
++++++++++++++++t+=+this.pool.borrowObject();
++++++++++++++++return+method.invoke(t,+args);
++++++++++++}+finally+{
++++++++++++++++if+(t+!=+null)
++++++++++++++++++++this.pool.returnObject(t);
++++++++++++}
++++++++}
++++}

++++@SuppressWarnings("unchecked")
++++public+T+getProxy(Class<?+super+T>+interfaceType)+{
++++++++PooledServiceProxy<T>+handler+=+new+PooledServiceProxy<>(this);
++++++++return+(T)+Proxy.newProxyInstance(interfaceType.getClassLoader(),
++++++++++++++++++++++++++++++++++++++++++new+Class<?>[]{interfaceType},+handler);
++++}
}|code-block|syntax|javascript|571257|要使用代理，请执行以下操作：|571258|ServiceObjectPool<SomeNonThreadSafeService>+servicePool+=+new+ServiceObjectPool<>(createSomeNonThreadSafeService);
nowSafeService+=+servicePool+.getProxy(SomeNonThreadSafeService.class);|571259|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

A general solution for this is to use multiple client objects in a pool, then to use proxy that acts as a facade.

<pre><code>import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

class ServiceObjectPool&lt;T&gt; extends GenericObjectPool&lt;T&gt; {
 public ServiceObjectPool(java.util.function.Supplier&lt;T&gt; factory) {
 super(new BasePooledObjectFactory&lt;T&gt;() {
 @Override
 public T create() throws Exception {
 return factory.get();
 }
 @Override
 public PooledObject&lt;T&gt; wrap(T obj) {
 return new DefaultPooledObject&lt;&gt;(obj);
 }
 });
 }

 public static class PooledServiceProxy&lt;T&gt; implements InvocationHandler {
 private ServiceObjectPool&lt;T&gt; pool;

 public PooledServiceProxy(ServiceObjectPool&lt;T&gt; pool) {
 this.pool = pool;
 }


 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 T t = null;
 try {
 t = this.pool.borrowObject();
 return method.invoke(t, args);
 } finally {
 if (t != null)
 this.pool.returnObject(t);
 }
 }
 }

 @SuppressWarnings("unchecked")
 public T getProxy(Class&lt;? super T&gt; interfaceType) {
 PooledServiceProxy&lt;T&gt; handler = new PooledServiceProxy&lt;&gt;(this);
 return (T) Proxy.newProxyInstance(interfaceType.getClassLoader(),
 new Class&lt;?&gt;[]{interfaceType}, handler);
 }
}
</code></pre>

To use the proxy:

<pre><code>ServiceObjectPool&lt;SomeNonThreadSafeService&gt; servicePool = new ServiceObjectPool&lt;&gt;(createSomeNonThreadSafeService);
nowSafeService = servicePool .getProxy(SomeNonThreadSafeService.class);
</code></pre>

Since initialization of the WS client service and port takes ages I like to initialize them once at startup and reuse the same instance of the port.
Initalization would look something like this:

<pre><code>private static RequestContext requestContext = null;

static
{
 MyService service = new MyService(); 
 MyPort myPort = service.getMyServicePort(); 

 Map&lt;String, Object&gt; requestContextMap = ((BindingProvider) myPort).getRequestContext();
 requestContextMap = ((BindingProvider)myPort).getRequestContext(); 
 requestContextMap.put(BindingProvider.USERNAME_PROPERTY, uName); 
 requestContextMap.put(BindingProvider.PASSWORD_PROPERTY, pWord); 

 rc = new RequestContext();
 rc.setApplication("test");
 rc.setUserId("test");
}
</code></pre>

The call somewhere in my class:

<pre><code>myPort.someFunctionCall(requestContext, "someValue");
</code></pre>

My question: Will this call be thread-safe?

Is this JAX-WS client call thread safe?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

因为初始化WS客户机服务和端口需要很长时间，所以我喜欢在启动时初始化它们一次，然后重用端口的相同实例。初始化看起来像这样：private static RequestContext requestContext = null;static{    MyService service = new MyService();...

问这个JAX-WS客户端调用线程安全吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个JAX-WS客户端调用线程安全吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个JAX-WS客户端调用线程安全吗？
EN