org.apache.cxf.jca.outbound.ManagedConnectionImpl Maven / Gradle / Ivy
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.cxf.jca.outbound;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.security.auth.Subject;
import javax.transaction.xa.XAResource;
import jakarta.resource.NotSupportedException;
import jakarta.resource.ResourceException;
import jakarta.resource.spi.ConnectionEvent;
import jakarta.resource.spi.ConnectionEventListener;
import jakarta.resource.spi.ConnectionRequestInfo;
import jakarta.resource.spi.LocalTransaction;
import jakarta.resource.spi.ManagedConnection;
import jakarta.resource.spi.ManagedConnectionMetaData;
import jakarta.xml.ws.BindingProvider;
import org.apache.cxf.Bus;
import org.apache.cxf.BusFactory;
import org.apache.cxf.bus.spring.SpringBusFactory;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.configuration.Configurer;
import org.apache.cxf.endpoint.Client;
import org.apache.cxf.frontend.ClientProxy;
import org.apache.cxf.frontend.ClientProxyFactoryBean;
import org.apache.cxf.jaxws.EndpointUtils;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.apache.cxf.jca.core.logging.LoggerHelper;
/**
* Represents a "physical" connection to EIS, which provides access to target
* web service. ManagedConnectionImpl creates connection handles for
* applications to use the connection backed by this object.
*/
public class ManagedConnectionImpl implements ManagedConnection {
private static final Logger LOG = LogUtils.getL7dLogger(ManagedConnectionImpl.class);
private Set listeners =
Collections.synchronizedSet(new HashSet<>());
private Map handles =
Collections.synchronizedMap(new HashMap());
private PrintWriter printWriter;
private ManagedConnectionFactoryImpl mcf;
private ConnectionRequestInfo connReqInfo;
private boolean isClosed;
private Bus bus;
private Object associatedHandle;
private Object clientProxy;
public ManagedConnectionImpl(ManagedConnectionFactoryImpl mcf,
ConnectionRequestInfo connReqInfo, Subject subject) {
this.mcf = mcf;
this.connReqInfo = connReqInfo;
}
/* -------------------------------------------------------------------
* ManagedConnection Methods
*/
public void addConnectionEventListener(ConnectionEventListener listener) {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("add listener : " + listener);
}
listeners.add(listener);
}
public void associateConnection(Object connection) throws ResourceException {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("associate handle : " + connection);
}
associatedHandle = connection;
// nothing needs to be done as app gets a copy of client proxy
}
public void cleanup() throws ResourceException {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("cleanup");
}
handles.clear();
isClosed = false;
}
public void destroy() throws ResourceException {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("destroy");
}
Client client = ClientProxy.getClient(clientProxy);
client.destroy();
handles.clear();
isClosed = false;
bus = null;
connReqInfo = null;
}
public Object getConnection(Subject subject,
ConnectionRequestInfo cxRequestInfo) throws ResourceException {
if (LOG.isLoggable(Level.FINER)) {
LOG.finer("get handle for subject=" + subject + " cxRequestInfo="
+ cxRequestInfo);
}
if (isClosed) {
throw new ResourceException("connection has been closed");
}
// check request info
if (!connReqInfo.equals(cxRequestInfo)) {
throw new ResourceException("connection request info: " + cxRequestInfo
+ " does not match " + connReqInfo);
}
CXFConnectionSpec spec = (CXFConnectionSpec)cxRequestInfo;
Object handle = createConnectionHandle(spec);
handles.put(handle, subject);
associatedHandle = handle;
return handle;
}
public LocalTransaction getLocalTransaction() throws ResourceException {
throw new NotSupportedException("LocalTransaction is not supported.");
}
public PrintWriter getLogWriter() throws ResourceException {
return printWriter;
}
public ManagedConnectionMetaData getMetaData() throws ResourceException {
return new CXFManagedConnectionMetaData(getUserName());
}
public XAResource getXAResource() throws ResourceException {
throw new NotSupportedException("XAResource is not supported.");
}
public void removeConnectionEventListener(ConnectionEventListener listener) {
listeners.remove(listener);
}
public void setLogWriter(PrintWriter out) throws ResourceException {
printWriter = out;
if (printWriter != null) {
LoggerHelper.initializeLoggingOnWriter(printWriter);
}
}
/* -------------------------------------------------------------------
* Public Methods
*/
public ConnectionRequestInfo getRequestInfo() {
return connReqInfo;
}
public ManagedConnectionFactoryImpl getManagedConnectionFactoryImpl() {
return mcf;
}
/* -------------------------------------------------------------------
* Private Methods
*/
private void sendEvent(final ConnectionEvent coEvent) {
synchronized (listeners) {
Iterator iterator = listeners.iterator();
while (iterator.hasNext()) {
sendEventToListener(iterator.next(), coEvent);
}
}
}
private void sendEventToListener(ConnectionEventListener listener,
ConnectionEvent coEvent) {
if (coEvent.getId() == ConnectionEvent.CONNECTION_CLOSED) {
listener.connectionClosed(coEvent);
}
if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_COMMITTED) {
listener.localTransactionCommitted(coEvent);
}
if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_ROLLEDBACK) {
listener.localTransactionRolledback(coEvent);
}
if (coEvent.getId() == ConnectionEvent.LOCAL_TRANSACTION_STARTED) {
listener.localTransactionStarted(coEvent);
}
if (coEvent.getId() == ConnectionEvent.CONNECTION_ERROR_OCCURRED) {
listener.connectionErrorOccurred(coEvent);
}
}
private String getUserName() {
if (associatedHandle != null) {
Subject subject = handles.get(associatedHandle);
if (subject != null) {
return subject.toString();
}
}
return null;
}
private Object createConnectionHandle(final CXFConnectionSpec spec) {
Class[] interfaces = {CXFConnection.class, BindingProvider.class,
spec.getServiceClass()};
return Proxy.newProxyInstance(spec.getServiceClass().getClassLoader(),
interfaces, new ConnectionInvocationHandler(
createClientProxy(spec), spec));
}
private synchronized Object createClientProxy(final CXFConnectionSpec spec) {
if (clientProxy == null) {
validateConnectionSpec(spec);
final ClientProxyFactoryBean factory;
if (EndpointUtils.hasWebServiceAnnotation(spec.getServiceClass())) {
factory = new JaxWsProxyFactoryBean();
} else {
factory = new ClientProxyFactoryBean();
}
factory.setBus(getBus(spec.getBusConfigURL()));
factory.setServiceClass(spec.getServiceClass());
factory.getServiceFactory().setEndpointName(spec.getEndpointName());
factory.getServiceFactory().setServiceName(spec.getServiceName());
factory.getServiceFactory().setWsdlURL(spec.getWsdlURL());
if (spec.getAddress() != null) {
factory.setAddress(spec.getAddress());
}
configureObject(spec.getEndpointName().toString() + ".jaxws-client.proxyFactory", factory);
clientProxy = factory.create();
}
return clientProxy;
}
private void validateConnectionSpec(CXFConnectionSpec spec) {
if (spec.getServiceClass() == null) {
throw new IllegalArgumentException("no serviceClass in connection spec");
}
if (spec.getEndpointName() == null) {
throw new IllegalArgumentException("no endpointName in connection spec");
}
if (spec.getServiceName() == null) {
throw new IllegalArgumentException("no serviceName in connection spec");
}
if (spec.getWsdlURL() == null) {
throw new IllegalArgumentException("no wsdlURL in connection spec");
}
}
private void configureObject(String name, Object instance) {
Configurer configurer = bus.getExtension(Configurer.class);
if (null != configurer) {
configurer.configureBean(name, instance);
}
}
private synchronized Bus getBus(URL busConfigLocation) {
if (bus == null) {
if (busConfigLocation != null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Create bus from location " + busConfigLocation);
}
bus = new SpringBusFactory().createBus(busConfigLocation);
} else if (mcf.getBusConfigURL() != null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Create bus from URL " + mcf.getBusConfigURL());
}
URL url = null;
try {
url = new URL(mcf.getBusConfigURL());
} catch (MalformedURLException e) {
LOG.warning("Malformed URL " + mcf.getBusConfigURL());
}
if (url != null) {
bus = new SpringBusFactory().createBus(url);
}
}
if (bus == null) {
if (LOG.isLoggable(Level.FINE)) {
LOG.fine("Create default bus");
}
bus = BusFactory.getDefaultBus();
}
}
return bus;
}
private class ConnectionInvocationHandler implements InvocationHandler {
private Object target;
private CXFConnectionSpec spec;
ConnectionInvocationHandler(Object target, CXFConnectionSpec spec) {
this.target = target;
this.spec = spec;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if (LOG.isLoggable(Level.FINEST)) {
LOG.finest("invoke connection spec:" + spec + " method=" + method);
}
if ("hashCode".equals(method.getName())) {
return method.invoke(Proxy.getInvocationHandler(proxy), args);
}
if ("equals".equals(method.getName())) {
// These are proxies. We don't really care if their targets are equal.
// We do care if these are the same proxy instances that we created.
// Therefore, if their proxy and invocation handler are consistent,
// we believe they are equal.
boolean result = false;
try {
result = proxy == args[0] && this == Proxy.getInvocationHandler(args[0]);
} catch (Exception e) {
// ignore and assume not equal
}
return result;
}
if ("toString".equals(method.getName())) {
return "ManagedConnection: " + spec;
}
if (!handles.containsKey(proxy)) {
throw new IllegalArgumentException("Stale connection");
}
if ("getService".equals(method.getName())) {
return handleGetServiceMethod(proxy, method, args);
} else if ("close".equals(method.getName())) {
return handleCloseMethod(proxy, method, args);
} else {
throw new IllegalArgumentException("Unhandled method " + method);
}
}
private Object handleGetServiceMethod(Object proxy, Method method,
Object[] args) {
if (!spec.getServiceClass().equals(args[0])) {
throw new IllegalArgumentException("serviceClass "
+ args[0] + " does not match " + spec.getServiceClass());
}
return target;
}
private Object handleCloseMethod(Object proxy, Method method,
Object[] args) {
handles.remove(proxy);
associatedHandle = null;
ConnectionEvent event = new ConnectionEvent(ManagedConnectionImpl.this,
ConnectionEvent.CONNECTION_CLOSED);
event.setConnectionHandle(proxy);
sendEvent(event);
return null;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy