Logging 将CMIS查询记录在Alfresco 4.2+；

我想记录alfresco从客户那里得到的CMIS查询

我已尝试将所有cmis类别设置为调试。。。大量信息，但没有查询字符串：

log4j.logger.org.alfresco.opencmis=debug
log4j.logger.org.alfresco.opencmis.AlfrescoCmisServiceInterceptor=debug
log4j.logger.org.alfresco.cmis=debug
log4j.logger.org.alfresco.cmis.dictionary=debug
log4j.logger.org.apache.chemistry.opencmis=debug

---

有人知道这是否可能吗？我一直在寻找源代码，但很难找到任何东西。

我找不到任何有用的日志记录，所以我设置了一个servlet过滤器来记录请求。请记住，查询字符串实际上位于POST请求的有效负载中，因此有必要创建一个请求包装器，以便过滤器可以读取有效负载，而不会干扰下游需要它的服务。在我做这件事的时候，我也记录了内容类型和参数，它们实际上不需要包装器，因为它们可以非破坏性地访问请求信息。要使用这种方法，请创建两个类，一个用于过滤器，另一个用于包装器。将它们都放在/tomcat/webapps/alfresco/WEB-INF/classes中，然后像这样向WEB.xml添加一个过滤器

    <filter>
       <filter-name>post-body-filter</filter-name> 
       <filter-class>filter.PostBodyFilter</filter-class> 
    </filter> 
    <filter-mapping> 
       <filter-name>post-body-filter</filter-name> 
       <url-pattern>/*</url-pattern> 
    </filter-mapping> 

柱体过滤器
过滤器
柱体过滤器
/* 

通过在server.xml中包含一个valve条目，可以将结果放入日志文件，如下所示。在日志中，您将在REQBODY中看到查询。您应该查找的日志前缀是localhost\u access\u log

        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
           prefix="localhost_access_log." suffix=".txt"
           pattern=" %t %r contentType:%{REQCONTENTTYPE}r parameters:%{REQPARAMETERS}r body:%{REQBODY}r %s" />    

这些类本身是这样的。我承认我自由地借用了其他过滤器的例子。如果我只记得在哪里，我会给归因（或责备）。我相信这是可以改进的

package filter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Enumeration;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;

import filter.FilterRequestWrapper

public class PostBodyFilter implements Filter {

    private FilterConfig filterConfig = null;

    public void destroy() { 
        this.filterConfig = null;
    }

    public void doFilter(ServletRequest request, ServletResponse response,
                FilterChain chain) throws IOException, ServletException {
        if (filterConfig == null)
            return;
        FilterRequestWrapper requestWrapper = new FilterRequestWrapper((HttpServletRequest) request);
        String contentType = request.getContentType();
        StringBuffer parameters = getParameters(request);
        StringBuffer body = getBody(requestWrapper);
        request.setAttribute("REQPARAMETERS", parameters);
        request.setAttribute("REQBODY", body);
        request.setAttribute("REQCONTENTTYPE", contentType);
        chain.doFilter(requestWrapper, response);
    }

    private static StringBuffer getParameters(ServletRequest request) {
        Enumeration<String> names = request.getParameterNames();
        StringBuffer parameters = new StringBuffer();
        while (names.hasMoreElements()) {
            String name = (String) names.nextElement();
            parameters.append(name + "=");
            String values[] = request.getParameterValues(name);
            for (int i = 0; i < values.length; i++) {
                if (i > 0)
                    parameters.append("' ");
                parameters.append(values[i]);
            }
            if (names.hasMoreElements())
                parameters.append(" ");
        }
        return parameters;
    }

    private static StringBuffer getBody(ServletRequest request)
            throws IOException {
        StringBuffer body = new StringBuffer();
        BufferedReader bufferedReader = null;
        try {
            InputStream inputStream = request.getInputStream();
            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(
                        inputStream));
                char[] charBuffer = new char[128];
                int bytesRead = -1;
                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    body.append(charBuffer, 0, bytesRead);
                }
            } else {
                body.append("");
            }
        } catch (IOException ex) {
            throw ex;
        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                    throw ex;
                }
            }
        }
        return body;
    }   

    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig = filterConfig;
    }
}

package filter;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;    

public class FilterRequestWrapper extends HttpServletRequestWrapper {

    private final String body;

    public FilterRequestWrapper(HttpServletRequest request) {
        super(request);

        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader bufferedReader = null;

        try {
            InputStream inputStream = request.getInputStream();

            if (inputStream != null) {
                bufferedReader = new BufferedReader(new InputStreamReader(
                        inputStream));

                char[] charBuffer = new char[128];
                int bytesRead = -1;

                while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
                    stringBuilder.append(charBuffer, 0, bytesRead);
                }
            } else {
                stringBuilder.append("");
            }
        } catch (IOException ex) {

        } finally {
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException ex) {
                }
            }
        }

        body = stringBuilder.toString();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(
            body.getBytes());   

        ServletInputStream inputStream = new ServletInputStream() {
            public int read() throws IOException {
                return byteArrayInputStream.read();
            }
        };  

        return inputStream;
    }
}

包过滤器；
导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.util.Enumeration；
导入javax.servlet.*；
导入javax.servlet.http.HttpServletRequest；
导入filter.FilterRequestWrapper
公共类PostBodyFilter实现过滤器{
private FilterConfig FilterConfig=null；
公共无效销毁（）{
this.filterConfig=null；
}
public void doFilter（ServletRequest请求、ServletResponse响应、，
FilterChain链）抛出IOException、ServletException{
if（filterConfig==null）
返回；
FilterRequestWrapper requestWrapper=新的FilterRequestWrapper（（HttpServletRequest）请求）；
String contentType=request.getContentType（）；
StringBuffer参数=getParameters（请求）；
stringbufferbody=getBody（requestWrapper）；
setAttribute（“REQPARAMETERS”，参数）；
setAttribute（“REQBODY”，body）；
setAttribute（“REQCONTENTTYPE”，contentType）；
doFilter（requestWrapper，response）；
}
私有静态StringBuffer getParameters（ServletRequest请求）{
枚举名称=request.getParameterNames（）；
StringBuffer参数=新的StringBuffer（）；
while（names.hasMoreElements（））{
字符串名称=（字符串）名称.nextElement（）；
参数。追加（名称+“=”）；
字符串值[]=request.getParameterValues（名称）；
对于（int i=0；i0）
参数。追加（“”）；
参数。追加（值[i]）；
}
if（names.hasMoreElements（））
参数。追加（“”）；
}
返回参数；
}
私有静态StringBuffer getBody（ServletRequest请求）
抛出IOException{
StringBuffer主体=新的StringBuffer（）；
BufferedReader BufferedReader=null；
试一试{
InputStream InputStream=request.getInputStream（）；
如果（inputStream！=null）{
bufferedReader=新的bufferedReader（新的InputStreamReader(
输入流）；
char[]charBuffer=新字符[128]；
int字节读取=-1；
而（（bytesRead=bufferedReader.read（charBuffer））>0）{
追加（charBuffer，0，字节读取）；
}
}否则{
正文.附加（“”）；
}
}捕获（IOEX异常）{
掷骰子；
}最后{
if（bufferedReader！=null）{
试一试{
bufferedReader.close（）；
}捕获（IOEX异常）{
掷骰子；
}
}
}
返回体；
}   
public void init（FilterConfig FilterConfig）抛出ServletException{
this.filterConfig=filterConfig；
}
}
包装过滤器；
导入java.io.BufferedReader；
导入java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入javax.servlet.ServletInputStream；
导入javax.servlet.http.HttpServletRequest；
导入javax.servlet.http.HttpServletRequestWrapper；
公共类FilterRequestWrapper扩展了HttpServletRequestWrapper{
私有最终字符串体；
公共FilterRequestWrapper（HttpServletRequest请求）{
超级（请求）；
StringBuilder StringBuilder=新的StringBuilder（）；
BufferedReader BufferedReader=null；
试一试{
InputStream InputStream=request.getInputStream（）；
如果（inputStream！=null）{
bufferedReader=新的bufferedReader（新的InputStreamReader(
输入流）；
char[]charBuffer=新字符[128]；
int字节读取=-1；
而（（bytesRead=bufferedReader.read（charBuffer））>0）{
追加（charBuffer，0，字节读取）；
}
}否则{
stringBuilder.append（“”）；
}
}捕获（IOEX异常）{
}最后{
if（bufferedReader！=null）{
试一试{
bufferedReader.close（）；
}捕获（IOEX异常）{
}
  @Bean
  public Session sessionBean() {
    // No connection to Alfresco available, create a new one
    SessionFactory sessionFactory = SessionFactoryImpl.newInstance();
    Map<String, String> parameters = new HashMap<>();
    parameters.put(SessionParameter.USER, username);
    parameters.put(SessionParameter.PASSWORD, password);
    parameters.put(SessionParameter.ATOMPUB_URL, host);
    parameters.put(SessionParameter.BINDING_TYPE, BindingType.ATOMPUB.value());
    parameters.put(SessionParameter.COMPRESSION, "true");
    parameters.put(SessionParameter.CACHE_TTL_OBJECTS, "0"); // Caching is turned off

    parameters.put(SessionParameter.HTTP_INVOKER_CLASS, "my.package.AlfrescoHttpInvoiker");



    // If there is only one repository exposed (e.g. Alfresco), these
    // lines will help detect it and its ID
    List<Repository> repositories = sessionFactory.getRepositories(parameters);
    Repository repository;
    if (repositories != null && repositories.size() > 0) {
      log.debug("Found (" + repositories.size() + ") Alfresco repositories");
      repository = repositories.get(0);
    } else {
      throw new CmisConnectionException(
              "Could not connect to the Alfresco Server, no repository found!");
    }
    return repository.createSession();
  }

    parameters.put(SessionParameter.HTTP_INVOKER_CLASS, "my.package.AlfrescoHttpInvoiker");

OutputStream out = new BufferedOutputStream(connOut, BUFFER_SIZE);
writer.write(out);
out.close();

try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
    writer.write(bos);
    out.write(bos.toByteArray());
    String str = new String(bos.toByteArray());
    LOG.debug("CMIS request body: " + str);
}