Java 使用log4j日志记录2.25

我正在使用Log4j日志记录

由于Jersey 2.25使用java util日志记录，因此不会记录请求和响应

在旧的泽西岛，我有定制的过滤器

有人有办法修理它吗

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.List;
 import java.util.Map;

 import javax.ws.rs.container.ContainerRequestFilter;
 import javax.ws.rs.container.ContainerResponseFilter;
 import javax.ws.rs.core.Context;
 import javax.ws.rs.core.HttpHeaders;
 import javax.ws.rs.core.MediaType;
 import javax.ws.rs.core.MultivaluedMap;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.http.protocol.HttpContext;
 import org.glassfish.jersey.message.internal.ReaderWriter;
 import org.glassfish.jersey.server.ContainerException;
 import org.glassfish.jersey.server.ContainerRequest;
 import org.glassfish.jersey.server.ContainerResponse;
 import org.glassfish.jersey.server.ResourceConfig;
 import org.glassfish.jersey.server.spi.ContainerResponseWriter;



 public class LoggingFilter implements ContainerRequestFilter, ContainerResponseFilter {
 /**
 * If true the request and response entities (if present) will not be logged. If false the request
 * and response entities will be logged.
 * <p>
 * The default value is false.
 */
 public static final String FEATURE_LOGGING_DISABLE_ENTITY =
 "com.sun.jersey.config.feature.logging.DisableEntitylogging";

 private static final Log LOGGER = LogFactory.getLog(LoggingFilter.class.getName());

 private static final String NOTIFICATION_PREFIX = "* ";

 private static final String REQUEST_PREFIX = "> ";

 private static final String RESPONSE_PREFIX = "< ";

 private final Log logger;

 private @Context HttpContext hc;

 private @Context ResourceConfig rc;

 private long id = 0;

 /**
 * Create a logging filter logging the request and response to a default JDK logger, named as the
 * fully qualified class name of this class.
 */
 public LoggingFilter() {
 this(LOGGER);
 }

 /**
 * Create a logging filter logging the request and response to a JDK logger.
 *
 * @param logger the logger to log requests and responses.
 */
 public LoggingFilter(Log logger) {
 this.logger = logger;
 }

 private synchronized void setId() {
 if (hc.getAttribute("request-id") == null) {
 hc.setAttribute("request-id", Long.toString(++id));
 }
 }

 private StringBuilder prefixId(StringBuilder b) {
 b.append(hc.getAttribute("request-id").toString()).append(" ");
 return b;
 }

 public ContainerRequest filter(ContainerRequest request) {
 setId();

 final StringBuilder b = new StringBuilder();
 printRequestLine(b, request);
 printRequestHeaders(b, request.getRequestHeaders());

 if (rc.getProperties().get(FEATURE_LOGGING_DISABLE_ENTITY)) {
 logger.debug(b.toString());
 return request;
 } else {
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 InputStream in = request.getEntityInputStream();
 try {
 if (in.available() > 0) {
 ReaderWriter.writeTo(in, out);

 byte[] requestEntity = out.toByteArray();
 try {
 String contentType = request.getRequestHeaders().getFirst(HttpHeaders.CONTENT_TYPE);
 if (contentType != null && (contentType.startsWith("image")
 || contentType.equals("application/octet-stream"))) {
 b.append("Binary content: " + contentType).append("\n");
 } else {
 printEntity(b, requestEntity);
 }
 } catch (Exception e) {
 logger.warn("Failed to log request", e);
 }
 request.setEntityInputStream(new ByteArrayInputStream(requestEntity));
 }
 return request;
 } catch (IOException ex) {
 throw new ContainerException(ex);
 } finally {
 logger.debug(b.toString());
 }
 }
 }

 private void printRequestLine(StringBuilder b, ContainerRequest request) {
 prefixId(b).append(NOTIFICATION_PREFIX).append("Server in-bound request").append('\n');
 prefixId(b).append(REQUEST_PREFIX).append(request.getMethod()).append(" ")
 .append(request.getRequestUri().toASCIIString()).append('\n');
 }

 private void printRequestHeaders(StringBuilder b, MultivaluedMap<String, String> headers) {
 for (Map.Entry<String, List<String>> e : headers.entrySet()) {
 String header = e.getKey();
 for (String value : e.getValue()) {
 prefixId(b).append(REQUEST_PREFIX).append(header).append(": ").append(value).append('\n');
 }
 }
 prefixId(b).append(REQUEST_PREFIX).append('\n');
 }

 private void printEntity(StringBuilder b, byte[] entity) throws IOException {
 if (entity.length == 0) {
 return;
 }
 b.append(new String(entity)).append("\n");
 }

 private final class Adapter implements ContainerResponseWriter {
 private final ContainerResponseWriter crw;

 private final boolean disableEntity;

 private long contentLength;

 private ContainerResponse response;

 private ByteArrayOutputStream baos;

 private StringBuilder b = new StringBuilder();

 Adapter(ContainerResponseWriter crw) {
 this.crw = crw;
 this.disableEntity = rc.getFeature(FEATURE_LOGGING_DISABLE_ENTITY);
 }

 public OutputStream writeStatusAndHeaders(long contentLength, ContainerResponse response)
 throws IOException {
 printResponseLine(b, response);
 printResponseHeaders(b, response.getHttpHeaders());

 if (disableEntity) {
 logger.debug(b.toString());
 return crw.writeStatusAndHeaders(contentLength, response);
 } else {
 this.contentLength = contentLength;
 this.response = response;
 return this.baos = new ByteArrayOutputStream();
 }
 }

 public void finish() throws IOException {
 if (!disableEntity) {
 byte[] entity = baos.toByteArray();

 try {
 MediaType mediaType =
 (MediaType) response.getHttpHeaders().getFirst(HttpHeaders.CONTENT_TYPE);

 if (mediaType != null && "application".equals(mediaType.getType())
 && "pdf".equals(mediaType.getSubtype()) == false) {
 printEntity(b, entity);
 } else {
 b.append("Binary content: ");
 if (mediaType != null && mediaType.getType() != null
 && mediaType.getSubtype() != null) {
 b.append(mediaType.getType());
 b.append("/");
 b.append(mediaType.getSubtype());
 }
 b.append("\n");
 }
 } catch (Exception e) {
 logger.error("Failed to log response", e);
 }

  //Output to log
 logger.debug(b.toString());

 // Write out the headers and buffered entity
 OutputStream out = crw.writeStatusAndHeaders(contentLength, response);
 out.write(entity);
 }
 crw.finish();
 }
 }

 public ContainerResponse filter(ContainerRequest request, ContainerResponse response) {
 setId();
 response.setContainerResponseWriter(new Adapter(response.getContainerResponseWriter()));
 return response;
 }

 private void printResponseLine(StringBuilder b, ContainerResponse response) {
 prefixId(b).append(NOTIFICATION_PREFIX).append("Server out-bound response").append('\n');
 prefixId(b).append(RESPONSE_PREFIX).append(Integer.toString(response.getStatus())).append('\n');
 }

 private void printResponseHeaders(StringBuilder b, MultivaluedMap<String, Object> headers) {
 for (Map.Entry<String, List<Object>> e : headers.entrySet()) {
 String header = e.getKey();
 for (Object value : e.getValue()) {
 prefixId(b).append(RESPONSE_PREFIX).append(header).append(": ")
 .append(ContainerResponse.getHeaderValue(value)).append('\n');
 }
 }
 prefixId(b).append(RESPONSE_PREFIX).append('\n');
 }

 }

import java.io.ByteArrayInputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.OutputStream；
导入java.util.List；
导入java.util.Map；
导入javax.ws.rs.container.ContainerRequestFilter；
导入javax.ws.rs.container.ContainerResponseFilter；
导入javax.ws.rs.core.Context；
导入javax.ws.rs.core.HttpHeaders；
导入javax.ws.rs.core.MediaType；
导入javax.ws.rs.core.MultivaluedMap；
导入org.apache.commons.logging.Log；
导入org.apache.commons.logging.LogFactory；
导入org.apache.http.protocol.HttpContext；
导入org.glassfish.jersey.message.internal.ReaderWriter；
导入org.glassfish.jersey.server.ContainerException；
导入org.glassfish.jersey.server.ContainerRequest；
导入org.glassfish.jersey.server.ContainerResponse；
导入org.glassfish.jersey.server.ResourceConfig；
导入org.glassfish.jersey.server.spi.ContainerResponseWriter；
公共类LoggingFilter实现ContainerRequestFilter、ContainerResponseFilter{
/**
*如果为true，则不会记录请求和响应实体（如果存在）。如果为false，则记录请求
*和响应实体将被记录。
*
*默认值为false。
*/
公共静态最终字符串功能\u日志记录\u禁用\u实体=
“com.sun.jersey.config.feature.logging.DisableEntitylogging”；
私有静态最终日志记录器=LogFactory.getLog（LoggingFilter.class.getName（））；
私有静态最终字符串通知_PREFIX=“*”；
私有静态最终字符串请求_PREFIX=“>”；
私有静态最终字符串响应_PREFIX=“<”；
私人最终日志记录器；
private@Context-HttpContext-hc；
private@Context ResourceConfig rc；
私有长id=0；
/**
*创建一个日志过滤器，将请求和响应记录到名为
*此类的完全限定类名。
*/
公共日志过滤器（）{
这个（记录器）；
}
/**
*创建一个日志过滤器，将请求和响应记录到JDK记录器。
*
*@param logger用于记录请求和响应的记录器。
*/
公共日志过滤器（日志记录器）{
this.logger=记录器；
}
私有同步的void setId（）{
if（hc.getAttribute（“请求id”）==null）{
setAttribute（“请求id”，Long.toString（++id））；
}
}
专用StringBuilder prefixId（StringBuilder b）{
b、 append（hc.getAttribute（“请求id”）.toString（））.append（“”）；
返回b；
}
公共ContainerRequest筛选器（ContainerRequest请求）{
setId（）；
最终StringBuilder b=新StringBuilder（）；
打印请求行（b，请求）；
printRequestHeaders（b，request.getRequestHeaders（））；
if（rc.getProperties（）.get（功能\日志\禁用\实体））{
debug（b.toString（））；
返回请求；
}否则{
ByteArrayOutputStream out=新建ByteArrayOutputStream（）；
InputStream in=request.getEntityInputStream（）；
试一试{
如果（in.available（）>0）{
ReaderWriter.writeTo（输入，输出）；
字节[]requestEntity=out.toByteArray（）；
试一试{
字符串contentType=request.getRequestHeaders（）.getFirst（HttpHeaders.CONTENT\u类型）；
if（contentType！=null&（contentType.startsWith（“图像”）
||contentType.equals（“应用程序/八位字节流”））{
b、 追加（“二进制内容：“+contentType”）。追加（“\n”）；
}否则{
打印实体（b，请求实体）；
}
}捕获（例外e）{
logger.warn（“记录请求失败”，e）；
}
setEntityInputStream（新的ByteArrayInputStream（requestEntity））；
}
返回请求；
}捕获（IOEX异常）{
抛出新的ContainerException（ex）；
}最后{
debug（b.toString（））；
}
}
}
私有void打印请求行（StringBuilder b、ContainerRequest请求）{
prefixId（b）.append（通知前缀）.append（“绑定请求中的服务器”）.append（'\n'）；
prefixId（b）.append（请求前缀）.append（请求方法（））.append（“”）
.append（request.getRequestUri（）.toASCIIString（））.append（'\n'）；
}
私有void printRequestHeaders（StringBuilder b，多值映射头）{
对于（Map.Entry e:headers.entrySet（））{
字符串头=e.getKey（）；
for（字符串值：e.getValue（））{
prefixId（b）.append（请求前缀）.append（头）.append（“：”）.append（值）.append（'\n'）；
}
}
prefixId（b）.append（请求前缀）.append（'\n'）；
}
私有void打印实体（StringBuilder b，字节[]实体）引发IOException{
if（entity.length==0）{
返回；
}
b、 append（新字符串（实体））.append（“\n”）；
}
私有最终类适配器实现ContainerResponseWriter{
专用最终容器响应器crw；
私有最终布尔不可分实体；
私人长裤；
专用容器响应；
私人ByteArrayOutputStream；
私有StringBuilder b=新StringBuilder（）；
适配器（ContainerResponseWriter crw）{
this.crw=crw；
this.disableEntity=rc.getFeature（FEATURE\u LOGGING\u DISABLE\u ENTITY）；
}
public OutputStream writeStatusAndHeaders（长contentLength，ContainerResponse响应）
抛出IOException{
打印响应线（b，响应）；
printResponseHeaders（b，response.getHttpHeaders（））；
if（禁用实体）{
debug（b.toString（））；
返回crw.writeStatusAndHeaders（contentLength，response）；
}否则{
this.contentLength=contentLength；
这个。反应=反应；
返回this.bas=newbytearrayoutputstream（）；
}
}
public void finish（）引发IOException{
如果（！disableEntity）{
byte[]entity=baos.toByteArray（）；
试一试{
媒体类型媒体类型=
（MediaType）response.getHttpHeaders（）.getFirst（HttpHeaders.CONTENT_TYPE）；
if（mediaType！=null&&“application”.equals（mediaType.getType（））
&&“pdf”.equals（mediaType.getSubtype（））==false）{
印刷实体（b，实体）；
}否则{
b、 追加（“二进制内容：”）；
if（mediaType！=null&&mediaType.getType（）！=null
&&mediaType.getSubtype（）！=null）{
b、 追加（mediaType.getType（））；
b、 附加（“/”）；
b、 附加（媒体类型）