Attraper le SAVON d'erreur de défaillance dans la coutume de l'intercepteur (Soap12FaultOutInterceptor)

Donc, à mon personnalisée intercepteur j'écris le code suivant:

Fault fault = new Fault(message.getContent(Exception.class));

Maintenant, c'est dans un code existant était de lever des exceptions de Java et de laisser le cadre de la convertir en une faute. Je ne rentrerai pas dans mes sentiments, mais cela vous aidera à la faute qui est généré.

Maintenant, si vous jetez une erreur à partir de votre méthode de service, ne

Fault fault = message.getContect(Fault.class);

J'espère que ce sera vous aider à obtenir la réponse à ce que vous voulez. Assurez-vous d'enregistrer l'intercepteur comme ci-dessous

<jaxws:endpoint
  id="fooService" implementor="com.bar.FooService" address="/FooServices">
  <jaxws:outFaultInterceptors>
        <ref class="com.bar.interceptor.DbLogOutInterceptor"/>
  </jaxws:outFaultInterceptors>
</jaxws:endpoint>
<jaxws:endpoint

OriginalL'auteur fpmoles

La Meilleure façon est de mettre en œuvre la Faute de l'écouteur et l'utilisation org.slf4j.Enregistreur de journal le message d'erreur au lieu d'utiliser l'enregistrement de java.

Il serait judicieux de remplacer le LoggingInInterceptor et écrire ur custome intercepteur pour obtenir la demande de la charge utile.

public class CxfInputFaultInterceptor extends AbstractLoggingInterceptor {
private static final Logger LOG = LogUtils.getLogger(CxfInputFaultInterceptor.class);

public CxfInputFaultInterceptor() {
    super(Phase.RECEIVE);
}

L'étape 1: cxf-beans.xml

    <cxf:bus>
    <cxf:inInterceptors>
        <ref bean="cxfInputFaultInterceptor"/>
    </cxf:inInterceptors>
    <cxf:inFaultInterceptors>
        <ref bean="cxfInputFaultInterceptor"/>
    </cxf:inFaultInterceptors>
    <cxf:properties>
        <entry key="org.apache.cxf.logging.FaultListener">
            <bean id="cxfFaultListener" class="pkg.common.ws.interceptor.CxfFaultListenerImpl" >
                <property name="loggedUser" ref="loggedUser"/>
            </bean> 
        </entry>
    </cxf:properties>
</cxf:bus>

Étape 2 : votre auditeur qui doit implémente org.apache.cxf.la journalisation.FaultListener

import java.io.InputStream;
import org.apache.cxf.interceptor.LoggingMessage;
import org.apache.cxf.logging.FaultListener;
import org.apache.cxf.message.Message;
import org.apache.cxf.service.model.EndpointInfo;
import org.apache.cxf.service.model.InterfaceInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/*
* Listener to faults on the processing of messages by CXF intercepter chain. Here we      override 
* java.util.logging.Logger and use  org.slf4j.Logger to print error to console.
*/
public class CxfFaultListenerImpl implements FaultListener{
private static final Logger logger = LoggerFactory.getLogger(CxfFaultListenerImpl.class);
private static final String NEWLINE="\n";
public boolean faultOccurred(final Exception exception,final String description,final Message message) {
createErrorLog(message);
logger.error(" --------------------------------------------------------------------------------------------------");
logger.error(" Stack Trace  :         ");
logger.error(" --------------------------------------------------------------------------------------------------");
logger.error(NEWLINE,exception);
logger.error(" --------------------------------------------------------------------------------------------------");
return true;
}
private void createErrorLog(final Message message){
final Message inMessage = message.getExchange().getInMessage();
final InputStream is = inMessage.getContent(InputStream.class);
final EndpointInfo endpoint = message.getExchange().getEndpoint().getEndpointInfo();
String logName=null;
if(endpoint!=null && endpoint.getService()!=null){
final String serviceName = endpoint.getService().getName().getLocalPart();
final InterfaceInfo iface = endpoint.getService().getInterface();
final String portName = endpoint.getName().getLocalPart();
final String portTypeName = iface.getName().getLocalPart();
logName =  serviceName + "."  + portName + "." + portTypeName;
}
final LoggingMessage buffer
= new LoggingMessage("Error occured on Service Call  : "+NEWLINE +"----------------------------", logName);
final Integer responseCode = (Integer)message.get(Message.RESPONSE_CODE);
if (responseCode != null) {
buffer.getResponseCode().append(responseCode);
}
final String encoding = (String)message.get(Message.ENCODING);
if (encoding != null) {
buffer.getEncoding().append(encoding);
}
final String httpMethod = (String)message.get(Message.HTTP_REQUEST_METHOD);
if (httpMethod != null) {
buffer.getHttpMethod().append(httpMethod);
}
final String ct = (String)message.get(Message.CONTENT_TYPE);
if (ct != null) {
buffer.getContentType().append(ct);
}
final Object headers = message.get(Message.PROTOCOL_HEADERS);
if (headers != null) {
buffer.getHeader().append(headers);
}
final String uri = (String)message.get(Message.REQUEST_URL);
if (uri != null) {
buffer.getAddress().append(uri);
final String query = (String)message.get(Message.QUERY_STRING);
if (query != null) {
buffer.getAddress().append("?").append(query);
}
}
final String requestXml= is.toString();
if(requestXml !=null){
buffer.getMessage().append("LoggedIn User:  ");
buffer.getMessage().append(getCurrentUsername()+NEWLINE);
buffer.getMessage().append("Request payload  : "+NEWLINE);
buffer.getMessage().append(requestXml);
}else{
buffer.getMessage().append("LoggedIn User:  ");
buffer.getMessage().append(getCurrentUsername()+NEWLINE);
buffer.getMessage().append("No inbound request message to append.");
}
logger.error(buffer.toString());
}

}

Espère que ça aide quelqu'un qui veut juste la trace de la pile et la charge utile lorsqu'une erreur se produit lors de l'appel de service et ainsi éviter d'énormes fichiers de log.

OriginalL'auteur kumarn