CXF拦截请求和发送时的报⽂
cxf 可以对请求和发送时的报⽂进⾏拦截，然后对其进⾏加⼯成我们想要的格式，然后再放到回去
我实现的是⾃定义
1.在需要拦截的⽅法上⾯加上这个注解，注解⾥⾯是我们的⾃定义
@OutInterceptors(interceptors = { "s.sult1.CDATAOutInterceptor" })
@InInterceptors(interceptors="s.sult1.ArtifactOutInterceptor")
2.对返回时的格式进⾏拦截实例，如果
public CDATAOutInterceptor() {
//这⾥代表流关闭之前的阶段，这很重要！可以到官⽹去看，拦截的阶段分为很多种
super(Phase.PRE_STREAM);
}
Phase.PRE_STREAM写的阶段不对可能会对想要的结果有影响，我开始写的Send和Write都是不⽣效的，⽹上也有好多博⽂写的是这种踩到坑了！import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import f.helpers.IOUtils;
import f.io.CachedOutputStream;
import f.message.Message;
import f.phase.AbstractPhaseInterceptor;
import f.phase.Phase;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class CDATAOutInterceptor extends AbstractPhaseInterceptor<Message> {
private static final Logger log = Logger(ArtifactOutInterceptor.class);
public CDATAOutInterceptor() {
//这⾥代表流关闭之前的阶段，这很重要！可以到官⽹去看，拦截的阶段分为很多种
super(Phase.PRE_STREAM);
}
@Override
public void handleMessage(Message message) {
/*这⾥是通过注解的⽅式来加<!CDATA[[]]>的格式
* message.put("disable.outputstream.optimization", Boolean.TRUE);
* XMLStreamWriter writer =
* Content(OutputStream.class
* )); message.setContent(XMLStreamWriter.class, new
* CDATAXMLStreamWriter(writer));
*/
try {
OutputStream os = Content(OutputStream.class);
CachedStream cs = new CachedStream();
message.setContent(OutputStream.class, cs);
CachedOutputStream csnew = (CachedOutputStream) Content(OutputStream.class);
InputStream in = InputStream();
String xml = String(in);
System.out.println("replaceBegin" + xml);
//转换的⽅式
xml = place("<body>", "<![CDATA[<?xml version=\"1.0\" encoding=\"UTF-8\"?><body>")
.replace("<returnMessage>", "<returnMessage><![CDATA[")
.replace("</returnMessage>", "]]></returnMessage>").replace("<returnCode>", "<returnCode><![CDATA[")
.replace("</returnCode>", "]]></returnCode>");
// 这⾥对xml做处理，处理完后同理，写回流中
System.out.println("replaceAfter" + xml);
cs.close();
os.flush();
message.setContent(OutputStream.class, os);
} catch (Exception e) {
<("Error when split original inputStream. CausedBy : " + "\n" + e);
}
}
private class CachedStream extends CachedOutputStream {
public CachedStream() {
super();
}
protected void doFlush() throws IOException {
currentStream.flush();
}
protected void doClose() throws IOException {
}
protected void onWrite() throws IOException {
}
}
}
如果上请求的数据量过⼤的话：会出现传输的xml获取不到数据的情况。需要将CachedStream换成ByteArrayOutputStream，如下的⽅式：
1 @Override
2public void handleMessage(Message message) {
3try {
4
log4j2xml配置5 OutputStream os = Content(OutputStream.class);
6 ByteArrayOutputStream cs=new ByteArrayOutputStream();
7
8 message.setContent(OutputStream.class, cs);
9
10 InterceptorChain().doIntercept(message);
11
12//ByteArrayOutputStream csnew = (ByteArrayOutputStream) Content(ByteArrayOutputStream.class);
13//InputStream in = String(charsetName);
14//String xml = String(in);
15 String xml=new ByteArray(), "utf-8");
16 log.info("replaceBegin"+xml);
17 xml = place(""0;
18// 这⾥对xml做处理，处理完后同理，写回流中
19 log.info("replaceAfter"+xml);
20 py(new Bytes()), os);
21 cs.close();
22 os.flush();
23 log.info("将参数设置会cxf框架中------------");
24 message.setContent(OutputStream.class, os);
25
26 } catch (Exception e) {
27 ("Error when split original inputStream. CausedBy : " + "\n" + e);
28 }
29 }
3.对请求进⾏拦截
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import f.binding.soap.SoapMessage;
import f.helpers.IOUtils;
import f.phase.AbstractPhaseInterceptor;
import f.phase.Phase;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class ArtifactOutInterceptor extends AbstractPhaseInterceptor<SoapMessage>{
private static final Logger log = Logger(ArtifactOutInterceptor.class);
public ArtifactOutInterceptor() {
//这⼉使⽤pre_stream，意思为在流关闭之前
super(Phase.PRE_STREAM);
}
@Override
public void handleMessage(SoapMessage message) {
InputStream is = Content(InputStream.class);
if (is != null) {
try {
String str = String(is);
log.info("原格式--传⼊的xml格式为："+str);
place("<", "<");
place(">", ">");
place("<?xml version=\"1.0\" encoding=\"UTF-8\"?>","");
InputStream ism = new Bytes());
message.setContent(InputStream.class, ism);
log.info("解析后的格式--传⼊的xml格式为："+str);
}
catch(IOException e){
<("WebService消息处理异常！",e);
}
}
}
}
4.1.对输出加<CADATA[[]]>的另外⼀种⽅法
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
l.stream.XMLStreamWriter;
import f.helpers.IOUtils;
import f.io.CachedOutputStream;
import f.message.Message;
import f.phase.AbstractPhaseInterceptor;
import f.phase.Phase;
import f.staxutils.StaxUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class CDATAOutInterceptor extends AbstractPhaseInterceptor<Message> {
private static final Logger log = Logger(ArtifactOutInterceptor.class);
public CDATAOutInterceptor() {
super(Phase.PRE_STREAM);
}
@Override
public void handleMessage(Message message) {
message.put("disable.outputstream.optimization", Boolean.TRUE);
XMLStreamWriter writer =
Content(OutputStream.class
)); message.setContent(XMLStreamWriter.class, new
CDATAXMLStreamWriter(writer));
}
}
import java.util.Arrays;
l.stream.XMLStreamException;
l.stream.XMLStreamWriter;
import f.staxutils.DelegatingXMLStreamWriter;
public class CDATAXMLStreamWriter extends DelegatingXMLStreamWriter{
private String currentElementName;
private static String[] CDATA_ELEMENTS = { "returnCode", "returnMessage",
"fpdm", "fphm","code",
"smrq","kpfsh","kprq","fpje","fpse", "sl","spfsh", "spfmc","fply","fplx", "xgrq","zfbz"
, "rzrq","rzzt","body","start_time","end_time"};
public CDATAXMLStreamWriter(XMLStreamWriter writer) {
super(writer);
}
@Override
public void writeCharacters(String text) throws XMLStreamException {
boolean useCData = isNeedCData();
if (useCData) {
super.writeCData(text);
} else {
super.writeCharacters(text);
}
}
private boolean isNeedCData() {
if(currentElementName.equals("body")||currentElementName.equals("data")){ System.out.println("-------");
}
if (Arrays.asList(CDATA_ELEMENTS).contains(currentElementName)) {
return true;
} else {
return false;
}
}
public void writeStartElement(String prefix, String local, String uri)
throws XMLStreamException {
currentElementName = local;
super.writeStartElement(prefix, local, uri);
}
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论