Java LoggingFilter類代碼示例

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
void start() {
    try {
        Config config = core.getConfig();
        String urlStr = config.getString("networking.rest-url");
        ResourceConfig rc = new ResourceConfig();
        rc.register(LoggingFilter.class);
        rc.register(JacksonFeature.class);
        rc.register(CatchAllExceptionMapper.class);
        rc.register(SerializationExceptionMapper.class);
        rc.register(AdminResourceImpl.class);
        rc.register(new KBResourceImpl(core));
        rc.register(new QueryResourceImpl(core));
        httpServer = GrizzlyHttpServerFactory.createHttpServer(URI.create(urlStr), rc, true);
        logger.info(marker, "Stargraph listening on {}", urlStr);
    } catch (Exception e) {
        throw new StarGraphException(e);
    }
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
@Override
public void run(S3SrvConfiguration configuration, Environment environment) {
    final Credentials credentials = configuration.buildCredentials();
    credentials.print();
    final StorageBackend storageBackend = configuration.getStorageBackend().build(credentials);

    environment.healthChecks().register("StorageBackend", new StorageBackendHealthCheck(storageBackend));

    environment.jersey().register(new S3OperationsFacade(storageBackend));

    if (configuration.isJerseyLoggingFilterEnabled()) {
        // print request / response headers
        // printEntity=false because printing consumes the input stream and breaks object creation (PUT Bucket)
        environment.jersey().register(new LoggingFilter(Logger.getLogger("InboundRequestResponse"), false));
    }

    environment.jersey().disable(ServerProperties.WADL_FEATURE_DISABLE);
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
/**
 * Start Hopsworks jobs with given IDs.
 *
 * @param jobIds
 * @return
 * @throws CredentialsNotFoundException
 */
public static String startJobs(Integer... jobIds) throws CredentialsNotFoundException {
  String uri = HopsUtil.getRestEndpoint() + "/" + Constants.HOPSWORKS_REST_RESOURCE + "/"
      + Constants.HOPSWORKS_REST_APPSERVICE
      + "/jobs/executions";

  ClientConfig config = new ClientConfig().register(LoggingFilter.class);
  Client client = ClientBuilder.newClient(config);
  WebTarget webTarget = client.target(uri);
  JSONObject json = new JSONObject();
  json.put(Constants.JSON_JOBIDS, jobIds);
  json.put(Constants.JSON_KEYSTOREPWD, keystorePwd);
  try {
    json.put(Constants.JSON_KEYSTORE, keystoreEncode());
  } catch (IOException ex) {
    LOG.log(Level.SEVERE, null, ex);
    throw new CredentialsNotFoundException("Could not initialize HopsUtil properties.");
  }
  Invocation.Builder invocationBuilder = webTarget.request(MediaType.APPLICATION_JSON);
  Response blogResponse = invocationBuilder.post(Entity.entity(json.toString(), MediaType.APPLICATION_JSON));
  final String response = blogResponse.readEntity(String.class);
  return response;
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
/**
 * Start simple http server.
 * 
 * @param debug - if set to true prints out all request and respone headers. That can produce a lot debug informations.
 */
public void startServer(boolean debug) {
    if (debug) {
        server = JdkHttpServerFactory.createHttpServer(jobProxyServerUri,
            new ResourceConfig(Ping.class, Submit.class, State.class, Delete.class)
            .property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true)
            .property(ServerProperties.BV_DISABLE_VALIDATE_ON_EXECUTABLE_OVERRIDE_CHECK, true)
            .register(new LoggingFilter(java.util.logging.Logger.getAnonymousLogger(), true))
            .packages(MODEL_PACKAGE));
    } else {
        server = JdkHttpServerFactory.createHttpServer(jobProxyServerUri,
            new ResourceConfig(Ping.class, Submit.class, State.class, Delete.class)
            .property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true)
            .property(ServerProperties.BV_DISABLE_VALIDATE_ON_EXECUTABLE_OVERRIDE_CHECK, true)
            .packages(MODEL_PACKAGE));
    }
   
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
public TestApplication() {
  // Bean Validation error messages in the response entity.
  property(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true);

  // X-Jersey-Tracing-nnn diagnostic response headers
  property(ServerProperties.TRACING, "ALL");

  // Server-side request logging, including entities
  register(new LoggingFilter(getAnonymousLogger(), true));

  // Validation configuration
  register(ValidationConfigurationContextResolver.class);

  // JSON configuration
  register(JsonConfiguration.class);
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
public SwiftProxy(Properties properties, BlobStoreLocator locator, URI endpoint) {
    this.endpoint = requireNonNull(endpoint);

    rc = new BounceResourceConfig(properties, locator);
    if (logger.isDebugEnabled()) {
        rc.register(new LoggingFilter(java.util.logging.Logger.getGlobal(), false));
    }
    server = GrizzlyHttpServerFactory.createHttpServer(endpoint, rc, false);
    server.getListeners().forEach(listener -> {
        listener.registerAddOn(new ContentLengthAddOn());
    });

    // allow HTTP DELETE to have payload for multi-object delete
    server.getServerConfiguration().setAllowPayloadForUndefinedHttpMethods(true);

    RuntimeDelegate.setInstance(new RuntimeDelegateImpl(RuntimeDelegate.getInstance()));
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
public Client build(final Configuration config) {
    // setup client
    ClientConfig clientConfig = new ClientConfig();

    if (config.isVerbose()) {
        clientConfig.register(new LoggingFilter(logger("jersey"), false));
    }

    clientConfig.property(ClientProperties.CONNECT_TIMEOUT, config.getTimeout() * 1000);
    clientConfig.property(ClientProperties.READ_TIMEOUT, config.getTimeout() * 1000);

    javax.ws.rs.client.Client client;

    if (config.isVerifySSL()) {
        client = ClientBuilder.newBuilder().withConfig(clientConfig).hostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String s, SSLSession sslSession) {
                return config.isVerifySSL();
            }
        }).build();
    } else {
        client = ClientBuilder.newClient(clientConfig);
    }

    return client;
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
public static WebTarget create(final String baseAddress, final Cache cache) {

		Client client = ClientBuilder.newBuilder().register(JacksonFeature.class)
				.register(LoggingFilter.class)
				.register(JWSJerseyFilter.class)
				.build();

		/*
		IMPORTANT:: This should be active in REAL client module
		
		if (cache != null)
			client = client.register(new RestRequestCachingFilter(cache));

		 */

		WebTarget target = client.target(baseAddress);
		return target;
	}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
/**
 * Create a JWS authentication client
 * @param baseAddress
 * @param cache
 * @param clientKey
 * @return webtarget
 */
public static WebTarget create(final String baseAddress, final Cache cache, final Key clientKey) {

    JWSJerseyFeature authFeature =  JWSJerseyFeature
                    .basicBuilder()
                    .credentials(clientKey)
                    .build();
    Client client = ClientBuilder.newBuilder()
            .register(JacksonFeature.class)
            .register(LoggingFilter.class)
            .register(authFeature)
            .build();

    if (cache != null)
        client = client.register(new RestRequestCachingFilter(cache));

    WebTarget target = client.target(baseAddress);
    return target;
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
@Override
protected void serviceInit(Configuration conf) throws Exception {
  GsonFeature gsonFeature = new GsonFeature(PlanGsonHelper.registerAdapters());
  
  ClientApplication clientApplication = new ClientApplication(masterContext);
  ResourceConfig resourceConfig = ResourceConfig.forApplication(clientApplication)
      .register(gsonFeature)
      .register(LoggingFilter.class)
      .property(ServerProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true)
      .property(ServerProperties.METAINF_SERVICES_LOOKUP_DISABLE, true);
  TajoConf tajoConf = (TajoConf) conf;

  InetSocketAddress address = tajoConf.getSocketAddrVar(TajoConf.ConfVars.REST_SERVICE_ADDRESS);
  URI restServiceURI = new URI("http", null, address.getHostName(), address.getPort(), "/rest", null, null);
  int workerCount = TajoConf.getIntVar(tajoConf, TajoConf.ConfVars.REST_SERVICE_RPC_SERVER_WORKER_THREAD_NUM);
  restServer = NettyRestServerFactory.createNettyRestServer(restServiceURI, resourceConfig, workerCount, false);

  super.serviceInit(conf);
  
  LOG.info("Tajo Rest Service initialized.");
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
@Test
public void should_return_client_with_configuration() throws Exception {

    //  Given
    suppress(method(SessionStorage.class, "init"));
    doReturn("http").when(configurationMock).getJasperReportsServerUrl();
    SessionStorage sessionStorage = Mockito.spy(new SessionStorage(configurationMock, credentialsMock, null, null));
    Whitebox.setInternalState(sessionStorage, "client", clientMock);
    Whitebox.setInternalState(sessionStorage, "sessionId", "sessionId");
    doReturn(targetMock).when(clientMock).target(anyString());
    doReturn(targetMock).when(targetMock).register(JacksonFeature.class);
    doReturn(targetMock).when(targetMock).register(MultiPartWriter.class);
    doReturn(targetMock).when(targetMock).register(any(JacksonJsonProvider.class));
    doReturn(targetMock).when(targetMock).register(any(SessionOutputFilter.class));
    doReturn(true).when(configurationMock).getLogHttp();
    doReturn(targetMock).when(targetMock).register(any(LoggingFilter.class));
    when(sessionStorage.getConfiguredClient()).thenReturn(targetMock);

    // When

    // When
    WebTarget configuredClient = sessionStorage.getConfiguredClient();

    // Then
    assertEquals(configuredClient, targetMock);
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
@PostConstruct
public void initIcingaClient() {
    icingaClient = ClientBuilder.newBuilder()
            //disable hostname verification
            .hostnameVerifier((s, sslSession) -> true)
            //ignore SSLHandshakes
            .sslContext(getTrustEverythingSSLContext())
            .build()
            .register(HttpAuthenticationFeature.basic(properties.getApiUsername(), properties.getApiPassword()))
            .register(new ErrorResponseFilter())
            .register(JacksonFeature.class);

    if (LOGGER.isDebugEnabled()) {
        icingaClient.register(LoggingFilter.class);
    }
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
/**
 * Produces a HTTPS client with client certificate-based authentication.
 *
 * @param keyStorePath
 *            Key store where client certificate is stored.
 * @param keyStorePassword
 *            Key store password.
 * @param keystoreType
 *            The type of key store.
 * @return
 * @throws RuntimeException
 */
public static Client httpsCertAuth(String keyStorePath, String keyStorePassword, SslKeyStoreType keystoreType)
        throws RuntimeException {

    SSLContext sslContext;
    try (InputStream keystoreFile = new FileInputStream(keyStorePath)) {
        KeyStore keystore = KeyStore.getInstance(keystoreType.name());
        keystore.load(keystoreFile, keyStorePassword.toCharArray());
        sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustSelfSignedStrategy())
                .loadKeyMaterial(keystore, keyStorePassword.toCharArray()).build();
    } catch (Exception e) {
        throw new RuntimeException("failed to set up an SSL context: " + e.getMessage(), e);
    }

    Client client = ClientBuilder.newBuilder().sslContext(sslContext).hostnameVerifier(allowAnyVerifier()).build();

    client.register(new LoggingFilter());
    return client;
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
@Override
public Set<Class<?>> getClasses() {
  final Set<Class<?>> classes = new HashSet<>();
  // register root resource
  classes.add(getResource());
  classes.add(MultiPartFeature.class);
  classes.add(LensJAXBContextResolver.class);
  classes.add(LensJAXBValidationExceptionMapper.class);
  classes.add(LensRequestLoggingFilter.class);
  classes.add(LoggingFilter.class);
  classes.add(LensApplicationListener.class);
  classes.add(MoxyJsonConfigurationContextResolver.class);
  classes.add(MoxyJsonFeature.class);
  classes.add(GenericExceptionMapper.class);
  return classes;
}
 

import org.glassfish.jersey.filter.LoggingFilter; //導入依賴的package包/類
private ResourceConfig getResourceConfig() {
    ResourceConfig rs = new ResourceConfig();

    if (packages.isPresent()) {
        log.debug("RestServer: adding packages " + packages.get());
        rs.packages(packages.get());
    }

    for (Class<?> intf : this.getInterfaces()) {
        log.debug("RestServer: adding interface " + intf.getCanonicalName());
        rs.register(intf);
    }

    return rs.registerClasses(SecurityFilter.class)
            .register(new MoxyXmlFeature())
            .register(new LoggingFilter(java.util.logging.Logger.getLogger(RestServer.class.getName()), true));
}