子夜的魂
子夜的魂

CXF客户端请求服务流程

CXF(使用版本2.7.6)对Web服务封装度已经非常高了，你只需要像正常写代码一样，附加几个额外的注解直接发布，服务端差不多就完成了；对于客户端更简单，只需要知道Web服务的URL地址和接口，就能如调用本地代码一样，几乎感觉不到与本地代码有什么区别。这就是封装的威力，虽然高度封装简化了我们对Web服务的使用，但也间接地阻挡了我们对其深入了解。本文就将源码层面来分析CXF其内部是如何完成客户端对Web服务的调用封装的，但并不包含服务端对服务请求的处理过程，如有需要可参看上篇，CXF中Web服务请求处理流程。

以SOAP协议服务为例，当我们使用代码调用Web服务时，一般情况如下：

JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();
String address = "...";//Web服务发布地址
factoryBean.setAddress(address);
factoryBean.setServiceClass(HelloService.class);//Web服务接口
HelloService helloService = factoryBean.create(HelloService.class);
helloService.sayHello("xtayfjpk");

最重要的当然是factoryBean.create()方法了，从代码表面上看，只知道其返回了一个实现了HelloService接口类实例，但它具体到底是什么呢？这当然就得去看看源码了： 


public  ProxyServiceType create(Class serviceClass) {
	setServiceClass(serviceClass);
	//看上去很简单啊，别急，操作都是create()方法中呢
	return serviceClass.cast(create());
}

public synchronized Object create() {
	ClassLoaderHolder orig = null;
	try {
		if (getBus() != null) {
			ClassLoader loader = getBus().getExtension(ClassLoader.class);
			if (loader != null) {
				orig = ClassLoaderUtils.setThreadContextClassloader(loader);
			}
		}
		//配置this，即JaxWsProxyFactoryBean对象
		configureObject();
		
		if (properties == null) {
			properties = new HashMap();
		}

		if (username != null) {
			AuthorizationPolicy authPolicy = new AuthorizationPolicy();
			authPolicy.setUserName(username);
			authPolicy.setPassword(password);
			properties.put(AuthorizationPolicy.class.getName(), authPolicy);
		}
		
		//为clientFactoryBean与ServiceFactory设置features
		initFeatures();
		clientFactoryBean.setProperties(properties);

		if (bus != null) {
			clientFactoryBean.setBus(bus);
		}

		if (dataBinding != null) {
			clientFactoryBean.setDataBinding(dataBinding);
		}

		//由工厂类创建出Client对象，实现类为ClientImpl，并且创建出了Endpoint、Service对象
		Client c = clientFactoryBean.create();
		//将各种拦截器设置进Client中
		if (getInInterceptors() != null) {
			c.getInInterceptors().addAll(getInInterceptors());
		}
		if (getOutInterceptors() != null) {
			c.getOutInterceptors().addAll(getOutInterceptors());
		}
		if (getInFaultInterceptors() != null) {
			c.getInFaultInterceptors().addAll(getInFaultInterceptors());
		}
		if (getOutFaultInterceptors() != null) {
			c.getOutFaultInterceptors().addAll(getOutFaultInterceptors());
		}
		
		//创建客户端代理对象
		ClientProxy handler = clientClientProxy(c);
		//获取代理需要实现的接口，包含Web服务接口与java.io.Closeable
		Class classes[] = getImplementingClasses();
		
		//这里是最关键代码，使用JDK提供的Proxy类创建出一个代理对象，该代理对象实现了Web服务接口与java.io.Closeable接口
		//而调用处理器(InvocationHandler)对象就是刚创建的ClientProxy对象
		Object obj = Proxy.newProxyInstance(clientFactoryBean.getServiceClass().getClassLoader(),
											classes,
											handler);

		this.getServiceFactory().sendEvent(FactoryBeanListener.Event.PROXY_CREATED,
										   classes, handler, obj);
		return obj;
	} finally {
		if (orig != null) {
			orig.reset();
		}
	}
}

因为调用处理器为ClientProxy，则客户端所有的Web服务调用都是调用ClientProxy的invoke方法，Web服务返回值就是invoke方法返回值，如下： 

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	//省略...
	MethodDispatcher dispatcher = (MethodDispatcher)endpoint.getService().get(MethodDispatcher.class
																				  .getName());
	BindingOperationInfo oi = dispatcher.getBindingOperation(method, endpoint);
	//省略...

	Object[] params = args;
	if (null == params) {
		params = new Object[0];
	}
	
	//进行同步调用
	Object o = invokeSync(method, oi, params);
	//call a virtual method passing the object.  This causes the IBM JDK
	//to keep the "this" pointer references and thus "this" doesn't get 
	//finalized in the midst of an invoke operation
	return adjustObject(o); 
}

通过create()方法，可以知道在创建ClientProxy时传入了Client对象，而在invokeSync(method, oi, params);中主要就是调用了Client的invoke方法，其invoke方法经过多个重的invoke方法调用，最后调用的是doInvoke()方法： 


private Object[] doInvoke(ClientCallback callback,
                              BindingOperationInfo oi,
                              Object[] params,
                              Map context,
                              Exchange exchange) throws Exception {
	Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
	ClassLoaderHolder origLoader = null;
	try {
		ClassLoader loader = bus.getExtension(ClassLoader.class);
		if (loader != null) {
			origLoader = ClassLoaderUtils.setThreadContextClassloader(loader);
		}
		if (exchange == null) {
			//创建Exchange对象
			exchange = new ExchangeImpl();
		}
		exchange.setSynchronous(callback == null);
		Endpoint endpoint = getEndpoint();
		if (LOG.isLoggable(Level.FINE)) {
			LOG.fine("Invoke, operation info: " + oi + ", params: " + Arrays.toString(params));
		}
		//创建Out消息
		Message message = endpoint.getBinding().createMessage();
		
		// Make sure INVOCATION CONTEXT, REQUEST_CONTEXT and RESPONSE_CONTEXT are present
		// on message
		//将调用上下文、请求上下文、响应上下文三个Map放置在Message与Exchange相应位置
		Map reqContext = null;
		Map resContext = null;
		if (context == null) {
			context = new HashMap();
		}
		reqContext = CastUtils.cast((Map)context.get(REQUEST_CONTEXT));
		resContext = CastUtils.cast((Map)context.get(RESPONSE_CONTEXT));
		if (reqContext == null) { 
			reqContext = new HashMap(getRequestContext());
			context.put(REQUEST_CONTEXT, reqContext);
		}
		if (resContext == null) {
			resContext = new HashMap();
			context.put(RESPONSE_CONTEXT, resContext);
		}
		
		message.put(Message.INVOCATION_CONTEXT, context);
		setContext(reqContext, message);
		exchange.putAll(reqContext);
		
		//设置参数，将参数包装成一个MessageContentsList对象
		//CXF中，Web服务的参数与返回结果都会包装成这种数据类型
		setParameters(params, message);

		if (null != oi) {
			//设置Exchange是否为单向的
			exchange.setOneWay(oi.getOutput() == null);
		}
		//将Message作为Exchange的输出消息
		exchange.setOutMessage(message);
		//设置回调接口，一般情况为null
		exchange.put(ClientCallback.class, callback);
		
		//设置消息属性
		setOutMessageProperties(message, oi);
		//设置Exchange属性，设置的属性有很多，具体的要看源码，其中一个最重要的属性是MessageObserver对象
		//exchange.put(MessageObserver.class, this);即把ClientImpl作为Message观察者，也就是当Web服务响应
		//结果返回后将调用ClientImpl的onMessage方法
		setExchangeProperties(exchange, endpoint, oi);

		//收集Bus、Client、Endpoint、Binding、DataBinding的输出拦截器至拦截器链中
		PhaseInterceptorChain chain = setupInterceptorChain(endpoint);
		//将拦截器链设置进Message中
		message.setInterceptorChain(chain);
		//为拦截器链设置错误观察者，即处理器
		chain.setFaultObserver(outFaultObserver);
		//准备ConduitSelector对象，其内部维护了一个Conduit列表，如果你在JaxWsProxyFactoryBean没有设置ConduitSelector
		//则默认会使用org.apache.cxf.endpoint.UpfrontConduitSelector，ConduitSelector会根据Message的设置情况选取或创建一个Conduit
		//Conduit对象是CXF中传输层用作客户端与服务端之间传输数据的管道，封装也客户端与服务端之间数据通信协议
		//对于JaxWsProxyFactoryBean调用Web服务，使用的是org.apache.cxf.transport.http.URLConnectionHTTPConduit，是一种基于
		//java.net.URLConnection的管道，客户端与服务端之间的数据通信最终都是通过URLConnection对象来完成的。
		prepareConduitSelector(message);

		//添加一些额外的拦截器，根据消息中是否含有拦截器提供者
		modifyChain(chain, message, false);
		try {
			//调用拦截器链doIntercept()方法，依赖调用链中各个拦截器中的handleMessage()方法 
			chain.doIntercept(message);
		} catch (Fault fault) {
			enrichFault(fault);
			throw fault;
		}
		
		if (callback != null) {
			return null;
		} else {
			//处理执行结果
			return processResult(message, exchange, oi, resContext);
		}
	} finally {
		if (origLoader != null) {
			origLoader.reset();
		}
		if (origBus != bus) {
			BusFactory.setThreadDefaultBus(origBus);
		}
	}
}

在客户端的输出拦截器链中默认含有的拦截器如下：
1. org.apache.cxf.ws.policy.PolicyOutInterceptor
2. org.apache.cxf.jaxws.interceptors.HolderOutInterceptor
3. org.apache.cxf.jaxws.interceptors.SwAOutInterceptor
4. org.apache.cxf.jaxws.interceptors.WrapperClassOutInterceptor
5. org.apache.cxf.binding.soap.interceptor.SoapHeaderOutFilterInterceptor
6. org.apache.cxf.binding.soap.interceptor.SoapPreProtocolOutInterceptor
7. org.apache.cxf.interceptor.MessageSenderInterceptor
8. org.apache.cxf.interceptor.AttachmentOutInterceptor
9. org.apache.cxf.interceptor.StaxOutInterceptor
10. org.apache.cxf.binding.soap.interceptor.SoapOutInterceptor
11. org.apache.cxf.interceptor.WrappedOutInterceptor
12. org.apache.cxf.interceptor.BareOutInterceptor
13. org.apache.cxf.management.interceptor.ResponseTimeMessageOutInterceptor
14. org.apache.cxf.binding.soap.interceptor.SoapOutInterceptor$SoapOutEndingInterceptor
15. org.apache.cxf.interceptor.StaxOutEndingInterceptor
16. org.apache.cxf.interceptor.MessageSenderInterceptor$MessageSenderEndingInterceptor

上面的序号也是拦截器被执行的顺序，其中第7、9、12、16号拦截器非常重要，这里将作详细解释，由于拦截器太多，其它的就得自己看了。
org.apache.cxf.interceptor.MessageSenderInterceptor：

public void handleMessage(Message message) {
	try {
		getConduit(message).prepare(message);
	} catch (IOException ex) {
		throw new Fault(new org.apache.cxf.common.i18n.Message("COULD_NOT_SEND", BUNDLE), ex);
	}    
	
	//添加org.apache.cxf.interceptor.MessageSenderInterceptor$MessageSenderEndingInterceptor到链中
	message.getInterceptorChain().add(ending);
}

看上去是不是特别简单呢?这么想可就错了,现在我们就去看一看prepare()方法，从doInvoke方法的注释中可以知道Conduit的实现类为URLConnectionHTTPConduit，prepare()方法就定义在其父类HTTPConduit中： 

public void prepare(Message message) throws IOException {
	// This call can possibly change the conduit endpoint address and 
	// protocol from the default set in EndpointInfo that is associated
	// with the Conduit.
	URI currentURI;
	try {
		//获取要访问的URI
		currentURI = setupURI(message);
	} catch (URISyntaxException e) {
		throw new IOException(e);
	}       

	// The need to cache the request is off by default
	boolean needToCacheRequest = false;
	
	HTTPClientPolicy csPolicy = getClient(message);
	//获取并配置Connection，该方法为抽象方法，实现在URLConnectionHTTPConduit中
	setupConnection(message, currentURI, csPolicy);
	
	//获取请求方法，GET或POST，默认使用POST
	String httpRequestMethod = 
		(String)message.get(Message.HTTP_REQUEST_METHOD);
	if (httpRequestMethod == null) {
		httpRequestMethod = "POST";
		message.put(Message.HTTP_REQUEST_METHOD, "POST");
	}
	
	//省略...
	
	//创建OutputStream对象，用于向服务端发送请求，并将其放置在Message中
	//createOutputStream也是一抽象方法，实现在URLConnectionHTTPConduit中
	message.setContent(OutputStream.class, 
					   createOutputStream(message,
										  needToCacheRequest, 
										  isChunking,
										  chunkThreshold));
	//至此，所有准备工作都已经OK，可以发送消息了
}

现在去看看那两个抽象方法，即setupConnection与createOutputStream： 

protected void setupConnection(Message message, URI currentURL, HTTPClientPolicy csPolicy) throws IOException {
	//创建出HttpURLConnection
	HttpURLConnection connection = createConnection(message, currentURL, csPolicy);
	//设置输出标志
	connection.setDoOutput(true);       
	//计算连接超时时间
	int ctimeout = determineConnectionTimeout(message, csPolicy);
	connection.setConnectTimeout(ctimeout);
	//计算读取超时时间
	int rtimeout = determineReceiveTimeout(message, csPolicy);
	connection.setReadTimeout(rtimeout);
	//不使用缓存
	connection.setUseCaches(false);
	//因为URLConnectionHTTPConduit自己实现了重定向功能，所以不再使用HttpURLConnection的重定向
	connection.setInstanceFollowRedirects(false);

	// 如果HTTP_REQUEST_METHOD没有设置，则默认为POST
	String httpRequestMethod = 
		(String)message.get(Message.HTTP_REQUEST_METHOD);
	if (httpRequestMethod == null) {
		httpRequestMethod = "POST";
		message.put(Message.HTTP_REQUEST_METHOD, "POST");
	}
	//设置请求方法
	connection.setRequestMethod(httpRequestMethod);
	
	//将HttpURLConnection放置在Message中，给创建输出流的时候使用
	message.put(KEY_HTTP_CONNECTION, connection);
}

protected OutputStream createOutputStream(Message message, 
                                              boolean needToCacheRequest, 
                                              boolean isChunking,
                                              int chunkThreshold) throws IOException {
	//取出在setupConnection方法中放置在Message中的HttpURLConnection对象
	HttpURLConnection connection = (HttpURLConnection)message.get(KEY_HTTP_CONNECTION);
	
	if (isChunking && chunkThreshold <= 0) {
		chunkThreshold = 0;
		connection.setChunkedStreamingMode(-1);                    
	}
	try {
		//返回一个包装好的输出流
		return new URLConnectionWrappedOutputStream(message, connection,
									   needToCacheRequest, 
									   isChunking,
									   chunkThreshold,
									   getConduitName());
	} catch (URISyntaxException e) {
		throw new IOException(e);
	}
}


org.apache.cxf.interceptor.StaxOutInterceptor：

public void handleMessage(Message message) {
	OutputStream os = message.getContent(OutputStream.class);
	XMLStreamWriter xwriter = message.getContent(XMLStreamWriter.class);
	Writer writer = null;
	if (os == null) {
		writer = message.getContent(Writer.class);
	}
	if ((os == null && writer == null) || xwriter != null) {
		return;
	}

	String encoding = getEncoding(message);
	
	try {
		XMLOutputFactory factory = getXMLOutputFactory(message);
		if (factory == null) {
			if (writer == null) {
				os = setupOutputStream(message, os);
				xwriter = StaxUtils.createXMLStreamWriter(os, encoding);
			} else {
				xwriter = StaxUtils.createXMLStreamWriter(writer);
			}
		} else {
			synchronized (factory) {
				if (writer == null) {
					os = setupOutputStream(message, os);
					xwriter = factory.createXMLStreamWriter(os, encoding);
				} else {
					xwriter = factory.createXMLStreamWriter(writer);
				}
			}
		}
		if (MessageUtils.getContextualBoolean(message, FORCE_START_DOCUMENT, false)) {
			xwriter.writeStartDocument(encoding, "1.0");
			message.removeContent(OutputStream.class);
			message.put(OUTPUT_STREAM_HOLDER, os);
			message.removeContent(Writer.class);
			message.put(WRITER_HOLDER, writer);
		}
	} catch (XMLStreamException e) {
		throw new Fault(new org.apache.cxf.common.i18n.Message("STREAM_CREATE_EXC", BUNDLE), e);
	}
	//将XMLStreamWriter设置进Message中
	message.setContent(XMLStreamWriter.class, xwriter);

	// Add a final interceptor to write end elements
	message.getInterceptorChain().add(ENDING);
}

该拦截器所做的工作就是取得Message中的OutputStream将其封装成一个XMLStreamWriter对象，方便对XML内容的操作，因为客户端与服务端通信的媒介就是XML格式。


org.apache.cxf.interceptor.BareOutInterceptor：

public void handleMessage(Message message) {
	Exchange exchange = message.getExchange();
	BindingOperationInfo operation = (BindingOperationInfo)exchange.get(BindingOperationInfo.class.getName());
	
	if (operation == null) {
		return;
	}
	
	//获取参数列表
	MessageContentsList objs = MessageContentsList.getContentsList(message);
	if (objs == null || objs.size() == 0) {
		return;
	}
	
	List parts = null;
	BindingMessageInfo bmsg = null;
	//现在是客户端，则为true
	boolean client = isRequestor(message);

	if (!client) {
		if (operation.getOutput() != null) {
			bmsg = operation.getOutput();
			parts = bmsg.getMessageParts();
		} else {
			// partial response to oneway
			return;
		}
	} else {
		bmsg = operation.getInput();
		//获取消息内容
		parts = bmsg.getMessageParts();
	}
	//将消息内容通过XMLStreamWriter以XML格式写入输出流，最终通过URLConnection写给服务端
	writeParts(message, exchange, operation, objs, parts);
}

org.apache.cxf.interceptor.MessageSenderInterceptor$MessageSenderEndingInterceptor，该拦截器是在执行MessageSenderInterceptor时添加到拦截器链中的。

public void handleMessage(Message message) throws Fault {
	try {
		getConduit(message).close(message);
	} catch (IOException e) {
		throw new Fault(new org.apache.cxf.common.i18n.Message("COULD_NOT_SEND", BUNDLE), e);
	}
}

Conduit的实现类为URLConnectionHTTPConduit，调用其close(message)方法，该方法定义在URLConnectionHTTPConduit基类AbstractConduit中，从Message中取出OutputStream，也就是被包装过的URLConnectionWrappedOutputStream对象，再调用其close()方法其定义在org.apache.cxf.transport.http.HTTPConduit.WrappedOutputStream中，最终调用了handleResponseInternal()用于处理响应请求： 


protected void handleResponseInternal() throws IOException {
	//获取Exchage对象
	Exchange exchange = outMessage.getExchange();
	//获取响应状态码
	int responseCode = getResponseCode();
	if (responseCode == -1) {
		LOG.warning("HTTP Response code appears to be corrupted");
	}
	if (exchange != null) {
		exchange.put(Message.RESPONSE_CODE, responseCode);
	}
			   
	//处理异常
	boolean noExceptions = MessageUtils.isTrue(outMessage.getContextualProperty(
		"org.apache.cxf.http.no_io_exceptions"));
	if (responseCode >= 400 && responseCode != 500 && !noExceptions) {
		throw new HTTPException(responseCode, getResponseMessage(), url.toURL());
	}

	InputStream in = null;
	
	//创建in message，即响应消息，因为请求已经提交，接下来就是要接收服务端的响应消息
	Message inMessage = new MessageImpl();
	inMessage.setExchange(exchange);
	//更新响应头
	updateResponseHeaders(inMessage);
	inMessage.put(Message.RESPONSE_CODE, responseCode);

	if (isOneway(exchange) || HttpURLConnection.HTTP_ACCEPTED == responseCode) {
		//省略...	因为Exchange不是单向的
	} else {
		//not going to be resending or anything, clear out the stuff in the out message
		//to free memory
		//将输出流移出outMessage，释放输出消息，输出消息的工作到此完成
		outMessage.removeContent(OutputStream.class);
		if (cachingForRetransmission && cachedStream != null) {
			cachedStream.close();
		}
		cachedStream = null;
	}
	
	//获取编码
	String charset = HttpHeaderHelper.findCharset((String)inMessage.get(Message.CONTENT_TYPE));
	String normalizedEncoding = HttpHeaderHelper.mapCharset(charset);
	if (normalizedEncoding == null) {
		String m = new org.apache.cxf.common.i18n.Message("INVALID_ENCODING_MSG",
														   LOG, charset).toString();
		LOG.log(Level.WARNING, m);
		throw new IOException(m);   
	} 
	inMessage.put(Message.ENCODING, normalizedEncoding);
	if (in == null) {
		//获取输入流，实现在URLConnectionWrappedOutputStream中，由URLConnection返回一个InputStream对象
		in = getInputStream();
	}
	if (in == null) {
		// Create an empty stream to avoid NullPointerExceptions
		in = new ByteArrayInputStream(new byte[] {});
	}
	//将输出流放置在输出消息中，以供后用
	inMessage.setContent(InputStream.class, in);
	
	//调用输入消息观察者的onMessage方法(观察者模式的使用)
	incomingObserver.onMessage(inMessage);
}

在上面的doInvoke方法解释中说到，输出消息的观察者就是ClientImpl对象，所以调用的就是ClientImpl的onMessage方法： 

public void onMessage(Message message) {

	Endpoint endpoint = message.getExchange().getEndpoint();
	//省略...

	//将MessageImpl包装成SOAPMessage
	message = endpoint.getBinding().createMessage(message);
	message.getExchange().setInMessage(message);
	message.put(Message.REQUESTOR_ROLE, Boolean.TRUE);
	message.put(Message.INBOUND_MESSAGE, Boolean.TRUE);
	
	//省略...

	InterceptorChain chain;
	//与输出拦截器链类似，收集Bus、Client、Endpoint、Binding、DataBinding的输入拦截器
	message.setInterceptorChain(chain);

	chain.setFaultObserver(outFaultObserver);
	modifyChain(chain, message, true);
	modifyChain(chain, message.getExchange().getOutMessage(), true);
	
	Bus origBus = BusFactory.getAndSetThreadDefaultBus(bus);
	// execute chain
	ClientCallback callback = message.getExchange().get(ClientCallback.class);

	
	try {
		//省略很多代码...

		if(callback!=null) {
			//do something with callback
		}
		//调用输入拦截器链的doIntercept，依次调用链中的各个拦截器的handleMessage方法
		chain.doIntercept(message);
	} finally {
		//省略...
	}
}

在输入拦截器链中最主要的工作就是完成了从InputStream中获取服务端的响应，然后将XML格式的内容反序列化为java对象，即得到Web服务实现的返回值。在上面的doInvoke方法中，当输入拦截器链也执行完成后，接下来执行的就是processResult方法： 

protected Object[] processResult(Message message,
                                   Exchange exchange,
                                   BindingOperationInfo oi,
                                   Map resContext) throws Exception {
	//异常处理...
	
	//处理202响应
	Integer responseCode = (Integer)exchange.get(Message.RESPONSE_CODE);
	if (null != responseCode && 202 == responseCode) {
		Endpoint ep = exchange.getEndpoint();
		if (null != ep && null != ep.getEndpointInfo() && null == ep.getEndpointInfo().
			getProperty("org.apache.cxf.ws.addressing.MAPAggregator.decoupledDestination")) {
			return null;
		}
	}

	// Wait for a response if we need to
	if (oi != null && !oi.getOperationInfo().isOneWay()) {
		synchronized (exchange) {
			//等待服务端响应
			waitResponse(exchange);
		}
	}

	//是否保存输出入为打开状态，默认为否
	Boolean keepConduitAlive = (Boolean)exchange.get(Client.KEEP_CONDUIT_ALIVE);
	if (keepConduitAlive == null || !keepConduitAlive) {
		//关闭输入流
		getConduitSelector().complete(exchange);
	}

	// Grab the response objects if there are any
	List resList = null;
	Message inMsg = exchange.getInMessage();
	if (inMsg != null) {
		if (null != resContext) {
			resContext.putAll(inMsg);
			// remove the recursive reference if present
			resContext.remove(Message.INVOCATION_CONTEXT);
			responseContext.put(Thread.currentThread(), resContext);
		}
		//获取消息中的List类型对象，也就是MessageConentList
		resList = CastUtils.cast(inMsg.getContent(List.class));
	}

	//处理异常...

	if (resList != null) {
		//返回Object[]
		return resList.toArray();
	}

	return null;
} 
  
 
  现在回到ClientProxy的invokeSync方法，该方法的返回值就是服务端返回的结果，ClientProxy的invoke方法的返回值，而ClientProxy又是调用Proxy.newInstance时的InvocationHandler，所以该返回值也就是调用客户端服务方法的返回结果；下面是invokeSync方法源码： 
  
 
  
 
  
public Object invokeSync(Method method, BindingOperationInfo oi, Object[] params)
	throws Exception {
	if (client == null) {
		throw new IllegalStateException("The client has been closed.");
	}
	//client实现类就是ClientImpl
	Object rawRet[] = client.invoke(oi, params);

	if (rawRet != null && rawRet.length > 0) {
		//取返回结果Object[]中的第一个元素，得到最终的返回结果
		return rawRet[0];
	} else {
		return null;
	}
}
 
  
 至此，CXF客户端调用流程也就完成了，这其中重要的是涉及了两个拦截器链的执行，输出链执行完成后，在其关闭时又触发了输入链的执行。输出链完成服务请求(部分而非所有)，输出链完成对服务端响应处理(部分而非所有)，得到返回结果。那么，剩下的就是你对返回结果的处理了，如有错误之处，尽请指正。 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java相关,CXF)

        

            

                
    
                    
  • JAVA相关知识
                        M_灵均
javajvm开发语言
                        
    JAVA基础知识说一下对象创建的过程？类加载检查：当Java虚拟机（JVM）遇到一个类的new指令时，它首先检查这个类是否已经被加载、链接和初始化。如果没有，JVM会通过类加载器（ClassLoader）加载这个类。分配内存：JVM为新对象分配内存。这个内存分配是在堆（Heap）上进行的，堆是JVM用来存储对象实例的地方。分配内存的大小在类加载时就已经确定，因为类的结构（包括字段和方法）已经确定。
    
                    
    • 
                    
  • python操作docx文件
                        liulanba
python业务类python
                        
    1.安装pipinstallpython_docx2.引入importdocxfromdocximportDocument3.新建和打开文件#新建文档并保存importdocxfromdocximportDocumentdocument=Document()document.save('test.docx')importdocxfromdocximportDocumentdocument=Docu
    
                    
    • 
                    
  • Python 全栈系列266 Kafka服务的Docker搭建
                        yukai08008
全栈pythonkafkadocker
                        
    说明在大量数据处理任务下的缓存与分发这个算是来自顾同学的助攻+1，我有点java绝缘体的体质，碰到和java相关的安装部署总会碰到点奇怪的问题，不过现在已经搞定了。测试也接近了kafka官方标称的性能。考虑到网络、消息的大小等因素，可以简单认为kafka的速度是10万/秒级的。本次文章的目的是：1搭建一个平时工作中常用的队列服务2方便自己或者其他同事再次搭建内容1搭建过程共要搭建两个服务：zook
    
                    
    • 
                    
  • SautinSoft HTML to RTF .Net Crack
                        SEO-狼术
DelphinetCrackhtml.net前端
                        
    SautinSoftHTMLtoRTF.NetCrackKeyFeaturesofSautinSoftHTMLtoRTF.Net:HTMLtoDOCXConversion:ConvertHTMLcontentintoDOCXfileswithfullsupportforCSSandsimpleJavaScript,creatingwell-formattedWorddocuments.HTMLto
    
                    
    • 
                    
  • Java、Python、信息安全毕设、大作业、小作业
                        KogRow(接毕设和大作业版)
杂项java课程设计开发语言
                        
    马上就要做毕业设计啦，编程相关的大作业和小作业开学也要做起来了，计算机专业的小伙伴们终于开始紧张啦~但是Java相关的毕业设计，真的太难啦，都不知道做什么选题！！！如果你平时没认真学，那么很可能根本就不知道怎么做毕业设计！尤其是对于摸鱼上瘾的同学，稍不注意就容易挂掉！大家现在担心的无非下面几点！我没认真学，毕业设计连选题都看不懂！作为学Java的计算机专业的学生，做过的项目的项目太少了，论文都不知
    
                    
    • 
                    
  • 解决——》maven打包时缺少文件
                        小仙。
SpringBootSpringCloud开发工具mavenxml打包resource
                        
    maven打包时缺少文件1、操作2、现象（错误信息）3、原因4、解决1、操作maven项目打包2、现象（错误信息）maven项目打包时，src/main/java目录下的xml等资源文件打包不进去3、原因默认maven在src/main/java中只编译java文件，其他的文件会被忽略。4、解决建议：非java相关的资源，写在src/main/resources中比较好，这样条理清晰通过配置pom
    
                    
    • 
                    
  • Vue3实现word预览
                        淑子啦
wordvue.js前端
                        
    1.安装依赖pnpminstall@vue-office/docx2.页面导入//导入依赖importVueOfficeDocxfrom"@vue-office/docx";//导入样式文件import"@vue-office/docx/lib/index.css";3.使用（这里使用是文件上传方式）可以直接是在线地址importVueOfficeDocxfrom"@vue-office/docx
    
                    
    • 
                    
  • 深入解析 Linux 网络管理：带宽查询、防火墙配置与端口管理
                        码农阿豪@新空间代码工作室
包罗万象linux运维服务器
                        
    个人名片作者简介：java领域优质创作者个人主页：码农阿豪工作室：新空间代码工作室（提供各种软件服务）个人邮箱：[[email protected]]个人微信：15279484656个人导航网站：www.forff.top座右铭：总有人要赢。为什么不能是我呢？专栏导航：码农阿豪系列专栏导航面试专栏：收集了java相关高频面试题，面试实战总结️Spring5系列专栏：整理了Spring5重要知识点与
    
                    
    • 
                    
  • python3.x使用cxfreeze将.p打包成.exe
                        weixin_30596343
python开发工具
                        
    之前写了一个使用ffplay批量查看格式为h264的图片，每次抽帧后都要打开pycharm编译器来运行程序，然后才能正常查看图片，或者在其他没有安装python环境的电脑中运行，很不方便。为此，在网上找了些方法，发现也是说的一知半解的。因此，自己通过实践记录python3.x下怎么样把.py文件打包成.exe可执行文件，这样就可以直接修改文件内的图片个数就可以双击.exe程序来查看图片了。一、.p
    
                    
    • 
                    
  • java动态编程脚本研究(springboot)
                        熊出没
springjavapython开发语言
                        
    一、学习背景核心代码gitee地址：ScriptDemo:java脚本语言实现动态编程最近学习了下动态编程的java相关技术，针对日常开发中经常有业务规则变换的场景，频繁修改代码发布极为不便，这时候可以利用java支持的动态编程技术，把不停变换的业务规则封装成其他语言的逻辑函数(或者java类本身也可以)，作为不同的脚本模板，以字符串的形式存储在数据库中，甚至可以直接在前端界面编写脚本语言，不需要
    
                    
    • 
                    
  • JNotify
                        liuhailong

                        
    FilesystemeventslibraryforJava相关站点http://jnotify.sourceforge.nethttp://jnotify.sourceforge.net/sample.htmlhttp://jnotify.sourceforge.net/linux.htmlhttps://sourceforge.net/projects/jnotify/files/原理JNot
    
                    
    • 
                    
  • python word 创建超链接
                        P01114245
python学习pythonword
                        
    importdocxfromdocx.enum.textimportWD_ALIGN_PARAGRAPHfromdocx.oxml.nsimportqnfromdocx.sharedimportCm,Pt#document=Document()#设置一个空白样式#style=document.styles['Normal']#设置西文字体#style.font.name='TimesNewRoma
    
                    
    • 
                    
  • Android Framework实战开发视频--跨进程通信之Unix Socket通信
                        千里马android

                        
    在线学习课程，课程咨询答疑和新课信息：QQ交流群：422901085进行课程讨论转自于：https://blog.csdn.net/learnframework/article/details/1190463181专门用于跨进程通信的UnixSocket做过java相关app开发肯定学过socket通信等一些小程序来实现局域网通信，学会了通过ip地址来进行一种网络通信，但这种通信一般用于跨设备访问
    
                    
    • 
                    
  • 在VSCode中创建Java项目
                        Keven__Java
Javavscodejavaide开发语言
                        
    在VSCode中创建Java项目首先，保证安装了Java的JDK.Win+R->输入cmd->输入java-version->然后可以看到安装的JDK版本，如果没安装可以去找教程。JDK安装参考教程打开VSCode，打开扩展（Ctrl+Shift+S），安装插件Chinese(Simplified)(简体中文)ExtensionPackforJava（会自动下载其他Java相关插件）创建Java项
    
                    
    • 
                    
  • JavaGuide
                        .:::.
javaguide
                        
    JavaGuide（Java学习&面试指南）|JavaGuideJavaGuide是一个面向Java开发者的知识整合平台，它提供了Java相关的学习资源、面试题、开发工具、框架和库等内容。JavaGuide的目标是帮助Java开发者更好地学习和应用Java技术。JavaGuide的内容包括但不限于以下几个方面：1.Java核心知识：Java基础语法、面向对象编程、集合框架、并发编程、IO操作等核心
    
                    
    • 
                    
  • Java面试题大全带答案
                        程序一逸
java开发语言后端
                        
    本人发现网上虽然有不少Java相关的面试题，但第一未必全，第二未必有答案，第三虽然有答案，但未必能在面试中说，所以在本文里，会不断收集各种面试题，并站在面试官的立场上，给出我自己的答案。第一部分、Java基础1.JDK和JRE有什么区别？JDK是java的开发工具包，有JDK8,9甚至到14的差别，安装以后，不仅包含了java的开发环境，比如java.exe，还包含了运行环境（jre）相关包。JR
    
                    
    • 
                    
  • 2023-09-25 html页面导出word
                        丁夏叮当

                        
    1、安装依赖,，因为我的项目中用的typescript，所以要安装此版本npmihtml-docx-js-typescriptnpmifile-saver2、引入依赖import*ashtmlDocxfrom'html-docx-js-typescript'import{saveAs}from'file-saver'3、给需要导出的元素设置id属性{{schemeInfo?.scYear}}年{{
    
                    
    • 
                    
  • linux怎么安装java教程
                        Hero.Lin
工作技巧开发javalinux服务器java
                        
    方式一：yum方式下载安装1、查找java相关的列表yum-ylistjava*或者yumsearchjdk2、安装jdkyuminstalljava-1.8.0-openjdk.x86_643、完成安装后验证java-version4、通过yum安装的默认路径为：/usr/lib/jvm5、将jdk的安装路径加入到JAVA_HOMEvi/etc/profile在文件最后加入：#setjavaen
    
                    
    • 
                    
  • SAP Spartacus B2B页面的List Component
                        JerryWang_汪子熙

                        
    需求如下：不管选择左边的view里列表行项目的哪一条，右边页面第一个可以被focus的元素，即Edit按钮，需要自动被focus：如果像上图这样，将cxFocus直接施加到a标签页上，一个sideeffect就是，a标签的tabindex将会被设置成默认的-1，这样没办法接收接下来的tab事件了：如下图Budgets列表页面所示：其Spartacus里的Component实现：ListCompon
    
                    
    • 
                    
  • python将Word页面纸张方向设置为横向
                        小龙在山东
pythonword前端javascript
                        
    通过python-docx的章节属性，就可以更改纸张方向、纸张尺寸。importdocxfromdocx.enum.sectionimportWD_ORIENTfromdocx.sharedimportCmdocument=docx.Document()section=document.sections[0]#设置纸张大小为A4大小section.page_width=Cm(21)section.
    
                    
    • 
                    
  • Python操作Word表格对齐、单元格对齐
                        小龙在山东
pythonword开发语言
                        
    通过Table的alignment可以设置表格居左对齐、居中对齐、居右对齐。通过Cell的vertical_alignment可以设置垂直位置。通过单元格里段落的alignment可以设置文本的左右对齐方式。importdocxfromdocx.enum.tableimportWD_TABLE_ALIGNMENT,WD_CELL_VERTICAL_ALIGNMENTfromdocx.enum.te
    
                    
    • 
                    
  • CXF与jdk1.6兼容问题
                        若离
jdkclassloaderexceptionjaxbnestedconstructor
                        
    转自：http://lxj8495138.javaeye.com/blog/338384Contextinitializationfailedorg.springframework.beans.factory.BeanCreationException:Errorcreatingbeanwithname'org.apache.cxf.wsdl.WSDLManager'definedinclassp
    
                    
    • 
                    
  • [VulnHub靶机渗透] MHZ_CXF: C1F
                        hacker-routing
web【精选】VulnHub渗透测试靶场练习平台网络windows安全测试工具vulnhubssh
                        
    博主介绍‍博主介绍：大家好，我是hacker-routing，很高兴认识大家~✨主攻领域：【渗透领域】【应急响应】【python】【VulnHub靶场复现】【面试分析】点赞➕评论➕收藏==养成习惯（一键三连）欢迎关注一起学习一起讨论⭐️一起进步文末有彩蛋作者水平有限，欢迎各位大佬指点，相互学习进步！目录前言一、信息收集1、主机探测2、端口扫描3、漏洞扫描二、渗透测试1、web渗透2、ssh远程登录
    
                    
    • 
                    
  • Java多线程并发01——线程的创建与终止，你会几种方式
                        Java面典

                        
    本文开始将开始介绍Java多线程与并发相关的知识，多谢各位一直以来的关注与支持。关注我的公众号「Java面典」了解更多Java相关知识点。线程的创建方式在Java中，用户常用的主动创建线程的方式有三种，分别是继承Thread类、实现Runnable接口、通过Callable和Future。继承Thread类定义Thread类的子类，并重写该类的run方法；调用线程对象的start()方法来启动该线
    
                    
    • 
                    
  • 【前端必备技能java之若依框架认证(登录注册)模块梳理】
                        铁锅炖大鹅(e)
学java前端java开发语言
                        
    详解若依框架微服务登录注册认证模块ruoyi-auth认证模块目录结构为什么需要认证模块控制器（controller）业务实现（Service）登录业务注册业务必备技能java系列梳理的文章并不涉及造轮子，以若依框架为基础，分析微服务SpringCloud的能力，并理清微服务在业务处理上搭建的应用层架构，不会追问技术实践的底层细节，目标是可以让有后端经验的非java相关的程序员可以使用Spring
    
                    
    • 
                    
  • 学习前端web的心路历程-----web服务器软件Tomcat以及Servlet入门
                        铅华殿
JavaWebtomcat前端
                        
    Tomcat&Servletweb服务器软件Tomcat百度百科步骤Servlet快速入门:Servlet中的生命周期方法web服务器软件常用概念:服务器：安装了服务器软件的计算机服务器软件：接收用户的请求，处理请求，做出响应web服务器软件：接收用户的请求，处理请求，做出响应。在web服务器软件中，可以部署web项目，让用户通过浏览器来访问这些项目web容器常见的java相关的web服务器软件：
    
                    
    • 
                    
  • java相关优秀博文收藏
                        阿布2

                        
    java相关优秀博文收藏转载请注明出处：http://blog.csdn.net/u014731752/article/details/72932036把本人最近阅读的优秀java书籍、浏览的优秀博文、以及优秀公众号分享给大家。如有更好的书籍和微信公众号以及博文，欢迎大家在评论区引荐。另外求份工作，邮箱：[email protected]深入理解JavaG1垃圾收集器-OPEN开发经验库使用CMS
    
                    
    • 
                    
  • 【React】React预览docx文件
                        郭_昊
react.jsjavascriptecmascript
                        
    React预览docx文件封装DocxView组件，用于显示docx文件的预览，支持加载loading效果安装依赖npmi docx-previewimportReact,{useEffect,useRef,useState}from'react'import*asdocxfrom'docx-preview'import{Spin}from'antd'import{askDocApiUrls}fr
    
                    
    • 
                    
  • docker kali 安装 xfce4 桌面 + tigervnc + novnc
                        赵丙双
linuxdockerkalixfcetigervncnovnc
                        
    dockerkali安装xfce4桌面+tigervnc+novnc启动容器环境变量准备工作安装xfce4桌面tigervnc安装tigervnc启动tigervncnovncxfce4启动弹窗如何关闭？参考启动容器dockerrun--namekali-p5901:5901-p6080:6080-i-tkalilinux/kali-rolling环境变量exportDISPLAY=:1expor
    
                    
    • 
                    
  • 【Tomcat与网络1】史前时代—没有Spring该如何写Web服务
                        纵横千里，捭阖四方
一个项目征服JavaHTTP与Tomcattomcatspring前端
                        
    在前面我们介绍了网络与Java相关的问题，最近在调研的时候发现这块内容其实非常复杂，设计的内容多而且零碎，想短时间梳理出整个体系是不太可能的，所以我们还是继续看Tomcat的问题，后面有网络的内容继续补充吧。目录1搭建一个本地web服务2Javaweb是如何工作的Servlet是JavaWeb的核心机制，而实现Servlet最好的服务器无疑就是Tomcat。在前面我们介绍了如何用Java实现网络通
    
                    
    • 
                                
  • SQL的各种连接查询
                                    xieke90
UNION ALLUNION外连接内连接JOIN
                                    
    一、内连接 
  概念：内连接就是使用比较运算符根据每个表共有的列的值匹配两个表中的行。 
                内连接（join 或者inner join ） 
      SQL语法： 
      select * fron
    
                                
    • 
                                
  • java编程思想--复用类
                                    百合不是茶
java继承代理组合final类
                                    
          复用类看着标题都不知道是什么,再加上java编程思想翻译的比价难懂,所以知道现在才看这本软件界的奇书 
  
一:组合语法:就是将对象的引用放到新类中即可 
    代码: 
    
package com.wj.reuse;

/**
 * 
 * @author Administrator 组
    
                                
    • 
                                
  • [开源与生态系统]国产CPU的生态系统
                                    comsci
cpu
                                    
     
 
      计算机要从娃娃抓起...而孩子最喜欢玩游戏.... 
 
      要让国产CPU在国内市场形成自己的生态系统和产业链,国家和企业就不能够忘记游戏这个非常关键的环节.... 
 
      投入一些资金和资源,人力和政策,让游
    
                                
    • 
                                
  • JVM内存区域划分Eden Space、Survivor Space、Tenured Gen，Perm Gen解释
                                    商人shang
jvm内存
                                    
    jvm区域总体分两类，heap区和非heap区。heap区又分：Eden Space（伊甸园）、Survivor Space(幸存者区)、Tenured Gen（老年代-养老区）。 非heap区又分：Code Cache(代码缓存区)、Perm Gen（永久代）、Jvm Stack(java虚拟机栈)、Local Method Statck(本地方法栈)。 
HotSpot虚拟机GC算法采用分代收
    
                                
    • 
                                
  • 页面上调用 QQ
                                    oloz
qq
                                    
    <A href="tencent://message/?uin=707321921&amp;Site=有事Q我&amp;Menu=yes">   
<img style="border:0px;" src=http://wpa.qq.com/pa?p=1:707321921:1></a>
    
                                
    • 
                                
  • 一些问题
                                    文强chu
问题
                                    
    1.eclipse 导出 doc  出现“The Javadoc command does not exist.” javadoc command 选择 jdk/bin/javadoc.exe 2.tomcate 配置 web 项目 ..... 
SQL:3.mysql  * 必须得放前面 否则  select&nbs
    
                                
    • 
                                
  • 生活没有安全感
                                    小桔子
生活孤独安全感
                                    
           圈子好小，身边朋友没几个，交心的更是少之又少。在深圳，除了男朋友，没几个亲密的人。不知不觉男朋友成了唯一的依靠，毫不夸张的说，业余生活的全部。现在感情好，也很幸福的。但是说不准难免人心会变嘛，不发生什么大家都乐融融，发生什么很难处理。我想说如果不幸被分手(无论原因如何)，生活难免变化很大，在深圳，我没交心的朋友。明
    
                                
    • 
                                
  • php 基础语法
                                    aichenglong
php 基本语法
                                    
    1 .1 php变量必须以$开头 
<?php 
$a=” b”; 
echo 
?> 
1 .2 php基本数据库类型 Integer  float/double Boolean string 
1 .3 复合数据类型 数组array和对象 object 
1 .4 特殊数据类型  null 资源类型(resource)    $co
    
                                
    • 
                                
  • mybatis tools 配置详解
                                    AILIKES
mybatis
                                    
    MyBatis Generator中文文档 
MyBatis Generator中文文档地址： 
 
 http://generator.sturgeon.mopaas.com/ 
 
该中文文档由于尽可能和原文内容一致，所以有些地方如果不熟悉，看中文版的文档的也会有一定的障碍，所以本章根据该中文文档以及实际应用，使用通俗的语言来讲解详细的配置。 
本文使用Markdown进行编辑，但是博客显示效
    
                                
    • 
                                
  • 继承与多态的探讨
                                    百合不是茶
JAVA面向对象 继承 对象
                                    
    继承 extends   多态 
继承是面向对象最经常使用的特征之一：继承语法是通过继承发、基类的域和方法 //继承就是从现有的类中生成一个新的类，这个新类拥有现有类的所有extends是使用继承的关键字： 
  
  
在A类中定义属性和方法； 
class A{
//定义属性
int age；
//定义方法
public void go
    
                                
    • 
                                
  • JS的undefined与null的实例
                                    bijian1013
JavaScriptJavaScript
                                    
    <form name="theform" id="theform">
</form>

<script language="javascript">
    var a
    alert(typeof(b));    //这里提示undefined
    if(theform.datas
    
                                
    • 
                                
  • TDD实践（一）
                                    bijian1013
java敏捷TDD
                                    
    一.TDD概述 
        TDD：测试驱动开发，它的基本思想就是在开发功能代码之前，先编写测试代码。也就是说在明确要开发某个功能后，首先思考如何对这个功能进行测试，并完成测试代码的编写，然后编写相关的代码满足这些测试用例。然后循环进行添加其他功能，直到完全部功能的开发。 
    
    
                                
    • 
                                
  • [Maven学习笔记十]Maven Profile与资源文件过滤器
                                    bit1129
maven
                                    
    什么是Maven Profile 
Maven Profile的含义是针对编译打包环境和编译打包目的配置定制，可以在不同的环境上选择相应的配置，例如DB信息，可以根据是为开发环境编译打包，还是为生产环境编译打包，动态的选择正确的DB配置信息 
  
Profile的激活机制 
1.Profile可以手工激活，比如在Intellij Idea的Maven Project视图中可以选择一个P
    
                                
    • 
                                
  • 【Hive八】Hive用户自定义生成表函数(UDTF)
                                    bit1129
hive
                                    
    1. 什么是UDTF 
  
UDTF，是User Defined Table-Generating Functions，一眼看上去，貌似是用户自定义生成表函数，这个生成表不应该理解为生成了一个HQL Table， 貌似更应该理解为生成了类似关系表的二维行数据集 
  2. 如何实现UDTF 
 
 继承org.apache.hadoop.hive.ql.udf.generic
    
                                
    • 
                                
  • tfs restful api 加auth 2.0认计
                                    ronin47

                                    
    　　目前思考如何给tfs的ngx-tfs api增加安全性。有如下两点： 
　　一是基于客户端的ip设置。这个比较容易实现。 
　　二是基于OAuth2.0认证，这个需要lua，实现起来相对于一来说，有些难度。 
　　现在重点介绍第二种方法实现思路。 
　　 
前言：我们使用Nginx的Lua中间件建立了OAuth2认证和授权层。如果你也有此打算，阅读下面的文档，实现自动化并获得收益。SeatGe
    
                                
    • 
                                
  • jdk环境变量配置
                                    byalias
javajdk
                                    
    进行java开发，首先要安装jdk，安装了jdk后还要进行环境变量配置： 
 
1、下载jdk（http://java.sun.com/javase/downloads/index.jsp），我下载的版本是：jdk-7u79-windows-x64.exe 
 
2、安装jdk-7u79-windows-x64.exe 
 
3、配置环境变量：右击"计算机"-->&quo
    
                                
    • 
                                
  • 《代码大全》表驱动法-Table Driven Approach-2
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.uti
    
                                
    • 
                                
  • SQL 数值四舍五入 小数点后保留2位
                                    chicony
四舍五入
                                    
      
1.round() 函数是四舍五入用，第一个参数是我们要被操作的数据，第二个参数是设置我们四舍五入之后小数点后显示几位。 
2.numeric 函数的2个参数，第一个表示数据长度，第二个参数表示小数点后位数。 
例如： 
　　select   cast(round(12.5,2)   as   numeric(5,2))  
    
                                
    • 
                                
  • c++运算符重载
                                    CrazyMizzz
C++
                                    
    一、加+，减-，乘*，除/ 的运算符重载 
 
Rational operator*(const Rational &x) const{ 
 return Rational(x.a * this->a); 
 } 
在这里只写乘法的，加减除的写法类似 
 
二、<<输出,>>输入的运算符重载 
     &nb
    
                                
    • 
                                
  • hive DDL语法汇总
                                    daizj
hive修改列DDL修改表
                                    
    hive DDL语法汇总 
１、对表重命名 
hive> ALTER TABLE table_name RENAME TO new_table_name; 
  
2、修改表备注 
hive> ALTER TABLE table_name SET TBLPROPERTIES ('comment' = new_comm
    
                                
    • 
                                
  • jbox使用说明
                                    dcj3sjt126com
Web
                                    
    参考网址：http://www.kudystudio.com/jbox/jbox-demo.html   jBox v2.3 beta    [ 
点击下载]  
 
技术交流QQGroup：172543951 100521167   
 
 [2011-11-11] jBox v2.3 正式版 
 - [调整&修复] IE6下有iframe或页面有active、applet控件
    
                                
    • 
                                
  • UISegmentedControl 开发笔记
                                    dcj3sjt126com

                                    
      //    typedef NS_ENUM(NSInteger, UISegmentedControlStyle) { 
    //        UISegmentedControlStylePlain,     // large plain 
  &
    
                                
    • 
                                
  • Slick生成表映射文件
                                    ekian
scala
                                    
    Scala添加SLICK进行数据库操作，需在sbt文件上添加slick-codegen包 
 
"com.typesafe.slick"    %% "slick-codegen"      % slickVersion 
因为我是连接SQL Server数据库，还需添加slick-extensions，jtds包 
 

"com.typesa
    
                                
    • 
                                
  • ES-TEST
                                    gengzg
test
                                    
    package com.MarkNum;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.ServletException;
import javax.servlet.annotation
    
                                
    • 
                                
  • 为何外键不再推荐使用
                                    hugh.wang
mysqlDB
                                    
    表的关联，是一种逻辑关系，并不需要进行物理上的“硬关联”，而且你所期望的关联，其实只是其数据上存在一定的联系而已，而这种联系实际上是在设计之初就定义好的固有逻辑。 
 
在业务代码中实现的时候，只要按照设计之初的这种固有关联逻辑来处理数据即可，并不需要在数据库层面进行“硬关联”，因为在数据库层面通过使用外键的方式进行“硬关联”，会带来很多额外的资源消耗来进行一致性和完整性校验，即使很多时候我们并不
    
                                
    • 
                                
  • 领域驱动设计
                                    julyflame
VODAO设计模式DTOpo
                                    
    概念： 
 
VO（View Object）：视图对象，用于展示层，它的作用是把某个指定页面（或组件）的所有数据封装起来。 
 
DTO（Data Transfer Object）：数据传输对象，这个概念来源于J2EE的设计模式，原来的目的是为了EJB的分布式应用提供粗粒度的数据实体，以减少分布式调用的次数，从而提高分布式调用的性能和降低网络负载，但在这里，我泛指用于展示层与服务层之间的数据传输对
    
                                
    • 
                                
  • 单例设计模式
                                    hm4123660
javaSingleton单例设计模式懒汉式饿汉式
                                    
           单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。 
     &nb
    
                                
    • 
                                
  • logback
                                    zhb8015
loglogback
                                    
    一、logback的介绍 
     Logback是由log4j创始人设计的又一个开源日志组件。logback当前分成三个模块：logback-core,logback- classic和logback-access。logback-core是其它两个模块的基础模块。logback-classic是log4j的一个 改良版本。此外logback-class
    
                                
    • 
                                
  • 整合Kafka到Spark Streaming——代码示例和挑战
                                    Stark_Summer
sparkstormzookeeperPARALLELISMprocessing
                                    
    作者Michael G. Noll是瑞士的一位工程师和研究员，效力于Verisign，是Verisign实验室的大规模数据分析基础设施（基础Hadoop）的技术主管。本文，Michael详细的演示了如何将Kafka整合到Spark Streaming中。 期间， Michael还提到了将Kafka整合到 Spark Streaming中的一些现状，非常值得阅读，虽然有一些信息在Spark 1.2版
    
                                
    • 
                                
  • spring-master-slave-commondao
                                    王新春
DAOspringdataSourceslavemaster
                                    
    互联网的web项目，都有个特点：请求的并发量高，其中请求最耗时的db操作，又是系统优化的重中之重。 
 
为此，往往搭建 db的 一主多从库的 数据库架构。作为web的DAO层，要保证针对主库进行写操作，对多个从库进行读操作。当然在一些请求中，为了避免主从复制的延迟导致的数据不一致性，部分的读操作也要到主库上。（这种需求一般通过业务垂直分开，比如下单业务的代码所部署的机器，读去应该也要从主库读取数
    
                                
    •