target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void testCanInitNullAddress() throws IOException { new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = null; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertTrue(transport.canInit()); }
|
@Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testCanInitListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = "0.0.0.0:" + port; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertFalse(transport.canInit()); ss.close(); }
|
@Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testCanInitNotListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); ss.close(); new Expectations(TransportConfig.class) { { TransportConfig.getAddress(); result = "0.0.0.0:" + port; } }; VertxRestTransport transport = new VertxRestTransport(); Assert.assertTrue(transport.canInit()); }
|
@Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
VertxRestTransport extends AbstractTransport { @Override public boolean canInit() { setListenAddressWithoutSchema(TransportConfig.getAddress()); URIEndpointObject ep = (URIEndpointObject) getEndpoint().getAddress(); if (ep == null) { return true; } if (!NetUtils.canTcpListen(ep.getSocketAddress().getAddress(), ep.getPort())) { LOGGER.warn( "Can not start VertxRestTransport, the port:{} may have been occupied. You can ignore this message if you are using a web container like tomcat.", ep.getPort()); return false; } return true; } @Override String getName(); @Override int getOrder(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void createBodyHandlerUploadNull() { AbstractVertxHttpDispatcher dispatcher = new AbstractVertxHttpDispatcherForTest(); RestBodyHandler bodyHandler = (RestBodyHandler) dispatcher.createBodyHandler(); Assert.assertTrue(Deencapsulation.getField(bodyHandler, "deleteUploadedFilesOnEnd")); Assert.assertNull(Deencapsulation.getField(bodyHandler, "uploadsDir")); }
|
protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
@Test public void createBodyHandlerUploadNormal() { config.setProperty("servicecomb.uploads.directory", "/path"); AbstractVertxHttpDispatcher dispatcher = new AbstractVertxHttpDispatcherForTest(); RestBodyHandler bodyHandler = (RestBodyHandler) dispatcher.createBodyHandler(); Assert.assertTrue(Deencapsulation.getField(bodyHandler, "deleteUploadedFilesOnEnd")); Assert.assertEquals("/path", Deencapsulation.getField(bodyHandler, "uploadsDir")); }
|
protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
AbstractVertxHttpDispatcher implements VertxHttpDispatcher { protected BodyHandler createBodyHandler() { RestBodyHandler bodyHandler = new RestBodyHandler(); UploadConfig uploadConfig = new UploadConfig(); bodyHandler.setUploadsDirectory(uploadConfig.getLocation()); bodyHandler.setDeleteUploadedFilesOnEnd(true); bodyHandler.setBodyLimit(uploadConfig.getMaxSize()); if (uploadConfig.toMultipartConfigElement() != null) { LOGGER.info("set uploads directory to \"{}\".", uploadConfig.getLocation()); } return bodyHandler; } }
|
@Test public void testStartFutureAddressEmpty() { boolean status = false; try { instance.start(startFuture); } catch (Exception ex) { status = true; } Assert.assertFalse(status); }
|
@SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
@Test public void testStartFutureAddressNotEmpty() { boolean status = false; MockForRestServerVerticle.getInstance().mockTransportConfig(); MockForRestServerVerticle.getInstance().mockRestServerVerticle(); try { instance.start(startFuture); } catch (Exception ex) { status = true; } Assert.assertFalse(status); }
|
@SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
RestServerVerticle extends AbstractVerticle { @SuppressWarnings("deprecation") @Override public void start(Future<Void> startFuture) throws Exception { try { super.start(); if (endpointObject == null) { LOGGER.warn("rest listen address is not configured, will not start."); startFuture.complete(); return; } Router mainRouter = Router.router(vertx); mountAccessLogHandler(mainRouter); mountCorsHandler(mainRouter); initDispatcher(mainRouter); mountGlobalRestFailureHandler(mainRouter); HttpServer httpServer = createHttpServer(); httpServer.requestHandler(mainRouter); httpServer.connectionHandler(connection -> { DefaultHttpServerMetrics serverMetrics = (DefaultHttpServerMetrics) ((ConnectionBase) connection).metrics(); DefaultServerEndpointMetric endpointMetric = serverMetrics.getEndpointMetric(); long connectedCount = endpointMetric.getCurrentConnectionCount(); int connectionLimit = DynamicPropertyFactory.getInstance() .getIntProperty("servicecomb.rest.server.connection-limit", Integer.MAX_VALUE).get(); if (connectedCount > connectionLimit) { connection.close(); endpointMetric.onRejectByConnectionLimit(); } }); httpServer.exceptionHandler(e -> { if (e instanceof ClosedChannelException) { LOGGER.debug("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } else { LOGGER.error("Unexpected error in server.{}", ExceptionUtils.getExceptionMessageWithoutTrace(e)); } }); startListen(httpServer, startFuture); } catch (Throwable e) { LOGGER.error("", e); throw e; } } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
@Test public void testMountCorsHandler() { ArchaiusUtils.setProperty("servicecomb.cors.enabled", true); ArchaiusUtils.setProperty("servicecomb.cors.allowedMethod", "GET,PUT,POST"); ArchaiusUtils.setProperty("servicecomb.cors.allowedHeader", "abc,def"); ArchaiusUtils.setProperty("servicecomb.cors.exposedHeader", "abc2,def2"); ArchaiusUtils.setProperty("servicecomb.cors.maxAge", 1); Set<HttpMethod> methodSet = new HashSet<>(3); methodSet.add(HttpMethod.GET); methodSet.add(HttpMethod.PUT); methodSet.add(HttpMethod.POST); AtomicInteger counter = new AtomicInteger(0); CorsHandler corsHandler = new MockUp<CorsHandler>() { @Mock CorsHandler allowCredentials(boolean allow) { Assert.assertFalse(allow); counter.incrementAndGet(); return null; } @Mock CorsHandler allowedHeaders(Set<String> headerNames) { Assert.assertThat(headerNames, Matchers.containsInAnyOrder("abc", "def")); counter.incrementAndGet(); return null; } @Mock CorsHandler exposedHeaders(Set<String> headerNames) { Assert.assertThat(headerNames, Matchers.containsInAnyOrder("abc2", "def2")); counter.incrementAndGet(); return null; } @Mock CorsHandler allowedMethod(HttpMethod method) { Assert.assertTrue(methodSet.contains(method)); counter.incrementAndGet(); methodSet.remove(method); return null; } @Mock CorsHandler maxAgeSeconds(int maxAgeSeconds) { Assert.assertEquals(1, maxAgeSeconds); counter.incrementAndGet(); return null; } }.getMockInstance(); new MockUp<RestServerVerticle>() { @Mock CorsHandler getCorsHandler(String corsAllowedOrigin) { Assert.assertEquals("*", corsAllowedOrigin); return corsHandler; } }; Router router = Mockito.mock(Router.class); Mockito.when(router.route()).thenReturn(Mockito.mock(Route.class)); RestServerVerticle server = new RestServerVerticle(); Deencapsulation.invoke(server, "mountCorsHandler", router); Assert.assertEquals(7, counter.get()); }
|
void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); }
|
RestServerVerticle extends AbstractVerticle { void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); } }
|
RestServerVerticle extends AbstractVerticle { void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); } }
|
RestServerVerticle extends AbstractVerticle { void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
RestServerVerticle extends AbstractVerticle { void mountCorsHandler(Router mainRouter) { if (!TransportConfig.isCorsEnabled()) { return; } CorsHandler corsHandler = getCorsHandler(TransportConfig.getCorsAllowedOrigin()); corsHandler.allowCredentials(TransportConfig.isCorsAllowCredentials()); corsHandler.allowedHeaders(TransportConfig.getCorsAllowedHeaders()); Set<String> allowedMethods = TransportConfig.getCorsAllowedMethods(); for (String method : allowedMethods) { corsHandler.allowedMethod(HttpMethod.valueOf(method)); } corsHandler.exposedHeaders(TransportConfig.getCorsExposedHeaders()); int maxAge = TransportConfig.getCorsMaxAge(); if (maxAge >= 0) { corsHandler.maxAgeSeconds(maxAge); } LOGGER.info("mount CorsHandler"); mainRouter.route().handler(corsHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
@Test public void mountGlobalRestFailureHandler() { Router mainRouter = Mockito.mock(Router.class); Holder<Handler<RoutingContext>> handlerHolder = new Holder<>(); Holder<Route> routeHolder = new Holder<>(); Route route = new MockUp<Route>() { @Mock Route failureHandler(Handler<RoutingContext> failureHandler) { handlerHolder.value = failureHandler; return null; } @Mock Route handler(io.vertx.core.Handler<io.vertx.ext.web.RoutingContext> requestHandler) { return routeHolder.value; } }.getMockInstance(); routeHolder.value = route; Mockito.when(mainRouter.route()).thenReturn(route); RestServerVerticle restServerVerticle = new RestServerVerticle(); Deencapsulation.invoke(restServerVerticle, "mountGlobalRestFailureHandler", mainRouter); Assert.assertNotNull(handlerHolder.value); RoutingContext routingContext = Mockito.mock(RoutingContext.class); HttpServerResponse response = Mockito.mock(HttpServerResponse.class); Mockito.when(response.setStatusCode(500)).thenReturn(response); Mockito.when(response.putHeader("Content-Type", "application/json")).thenReturn(response); Mockito.when(routingContext.response()).thenReturn(response); handlerHolder.value.handle(routingContext); Mockito.verify(response).end("{\"message\":\"unknown error\"}"); }
|
private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); }
|
RestServerVerticle extends AbstractVerticle { private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); } }
|
RestServerVerticle extends AbstractVerticle { private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); } }
|
RestServerVerticle extends AbstractVerticle { private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
RestServerVerticle extends AbstractVerticle { private void mountGlobalRestFailureHandler(Router mainRouter) { GlobalRestFailureHandler globalRestFailureHandler = SPIServiceUtils.getPriorityHighestService(GlobalRestFailureHandler.class); Handler<RoutingContext> failureHandler = null == globalRestFailureHandler ? ctx -> { if (ctx.response().closed() || ctx.response().ended()) { LOGGER.error("get a failure with closed response", ctx.failure()); return; } HttpServerResponse response = ctx.response(); if (ctx.failure() instanceof InvocationException) { InvocationException exception = (InvocationException) ctx.failure(); response.setStatusCode(exception.getStatusCode()); response.setStatusMessage(exception.getReasonPhrase()); response.end(exception.getErrorData().toString()); return; } LOGGER.error("unexpected failure happened", ctx.failure()); try { CommonExceptionData unknownError = new CommonExceptionData("unknown error"); ctx.response().setStatusCode(500).putHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON) .end(RestObjectMapperFactory.getRestObjectMapper().writeValueAsString(unknownError)); } catch (Exception e) { LOGGER.error("failed to send error response!", e); } } : globalRestFailureHandler; mainRouter.route() .handler(RoutingContext::next) .failureHandler(failureHandler); } @Override void init(Vertx vertx, Context context); @SuppressWarnings("deprecation") // TODO: vert.x 3.8.3 does not update startListen to promise, so we keep use deprecated API now. update in newer version. @Override void start(Future<Void> startFuture); }
|
@Test public void getOrder() { Assert.assertEquals(Integer.MAX_VALUE, dispatcher.getOrder()); }
|
@Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { @Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { @Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { @Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { @Override public int getOrder() { return DynamicPropertyFactory.getInstance().getIntProperty(KEY_ORDER, Integer.MAX_VALUE).get(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
@Test @SuppressWarnings("deprecation") public void init() { registryInitializer.init(globalRegistry, new EventBus(), new MetricsBootstrapConfig()); Assert.assertEquals(-10, registryInitializer.getOrder()); Assert.assertThat(globalRegistry.getDefaultRegistry(), Matchers.instanceOf(com.netflix.spectator.servo.ServoRegistry.class)); Assert.assertEquals(1, registries.size()); Assert.assertEquals(1, DefaultMonitorRegistry.getInstance().getRegisteredMonitors().size()); registryInitializer.destroy(); Assert.assertEquals(0, registries.size()); Assert.assertEquals(0, DefaultMonitorRegistry.getInstance().getRegisteredMonitors().size()); }
|
@Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); } }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); } }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override @SuppressWarnings("deprecation") public void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config) { this.globalRegistry = globalRegistry; System.setProperty("spectator.api.gaugePollingFrequency", Duration.ofMillis(config.getMsPollInterval()).toString()); System.setProperty(SERVO_POLLERS, String.valueOf(config.getMsPollInterval())); registry = new com.netflix.spectator.servo.ServoRegistry(); globalRegistry.add(registry); } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); static final String SERVO_POLLERS; }
|
@Test public void onRequest(@Mocked Vertx vertx, @Mocked Context context, @Mocked HttpServerRequest request, @Mocked SocketAddress socketAdrress) { Map<String, Object> map = new HashMap<>(); RoutingContext routingContext = new MockUp<RoutingContext>() { @Mock RoutingContext put(String key, Object obj) { map.put(key, obj); return null; } @Mock HttpServerRequest request() { return request; } }.getMockInstance(); new Expectations() { { Vertx.currentContext(); result = context; } }; Deencapsulation.invoke(dispatcher, "onRequest", routingContext); Assert.assertEquals(VertxRestInvocation.class, map.get(RestConst.REST_PRODUCER_INVOCATION).getClass()); Assert.assertTrue(invoked); }
|
protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { protected void onRequest(RoutingContext context) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } HttpServletRequestEx requestEx = new VertxServerRequestToHttpServletRequest(context); HttpServletResponseEx responseEx = new VertxServerResponseToHttpServletResponse(context.response()); if (SCBEngine.getInstance().isFilterChainEnabled()) { InvocationCreator creator = new RestVertxProducerInvocationCreator(context, microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } VertxRestInvocation vertxRestInvocation = new VertxRestInvocation(); context.put(RestConst.REST_PRODUCER_INVOCATION, vertxRestInvocation); vertxRestInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
@Test public void testWrapResponseBody() { VertxRestDispatcher vertxRestDispatcher = new VertxRestDispatcher(); String message = "abcd"; String bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"abcd\"}", bodyString); message = "\"abcd\""; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"\\\"abcd\\\"\"}", bodyString); message = ".01ab\"!@#$%^&*()'\\cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\".01ab\\\"!@#$%^&*()'\\\\cd\"}", bodyString); message = new JsonObject().put("key", new JsonObject().put("k2", "value")).toString(); bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"key\":{\"k2\":\"value\"}}", bodyString); message = "ab\"23\n@!#cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"ab\\\"23\\n@!#cd\"}", bodyString); message = "ab\"23\r\n@!#cd"; bodyString = vertxRestDispatcher.wrapResponseBody(message); Assert.assertNotNull(bodyString); Assert.assertEquals("{\"message\":\"ab\\\"23\\r\\n@!#cd\"}", bodyString); }
|
String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); } }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
VertxRestDispatcher extends AbstractVertxHttpDispatcher { String wrapResponseBody(String message) { if (isValidJson(message)) { return message; } JsonObject jsonObject = new JsonObject(); jsonObject.put("message", message); return jsonObject.toString(); } @Override int getOrder(); @Override boolean enabled(); @Override void init(Router router); }
|
@Test public void testGetConfigLocationsEmpty() { String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers.arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE)); }
|
@Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testGetConfigLocationsComma() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a,b"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
|
@Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testGetConfigLocationsPartEmpty() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a,,b"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
|
@Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testGetConfigLocationsLine() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a\r\nb"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b")); }
|
@Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testGetConfigLocationsMix() { new Expectations() { { servletContext.getInitParameter(CseXmlWebApplicationContext.KEY_LOCATION); result = "a\r\nb,,c"; } }; String[] result = context.getConfigLocations(); Assert.assertThat(result, Matchers .arrayContaining(BeanUtils.DEFAULT_BEAN_CORE_RESOURCE, BeanUtils.DEFAULT_BEAN_NORMAL_RESOURCE, "a", "b", "c")); }
|
@Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override public String[] getConfigLocations() { String contextConfigLocation = getServletContext().getInitParameter(KEY_LOCATION); String[] locationArray = splitLocations(contextConfigLocation); LOGGER.info("init spring context: {}.", Arrays.toString(locationArray)); return locationArray; } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testInjectServlet(@Mocked ConfigurableListableBeanFactory beanFactory) { Holder<Boolean> holder = new Holder<>(); new MockUp<RestServletInjector>() { @Mock public Dynamic defaultInject(ServletContext servletContext) { holder.value = true; return null; } }; context.invokeBeanFactoryPostProcessors(beanFactory); Assert.assertTrue(holder.value); }
|
@Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); } }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
CseXmlWebApplicationContext extends XmlWebApplicationContext { @Override protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { super.invokeBeanFactoryPostProcessors(beanFactory); ServletUtils.init(getServletContext()); } CseXmlWebApplicationContext(); CseXmlWebApplicationContext(ServletContext servletContext); void setDefaultBeanResource(String[] defaultBeanResource); @Override String[] getConfigLocations(); }
|
@Test public void testCheckUrlPatternNormal() { ServletUtils.checkUrlPattern("/*"); ServletUtils.checkUrlPattern("/abc/*"); ServletUtils.checkUrlPattern("/abc/def/*"); }
|
static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testCheckUrlPatternMiddleWideChar() { try { ServletUtils.checkUrlPattern("/abc/*def"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
|
static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void destroy_notInit() { registryInitializer.destroy(); }
|
@Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } } }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } } }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); }
|
DefaultRegistryInitializer implements MetricsInitializer { @Override public void destroy() { if (registry != null) { DefaultMonitorRegistry.getInstance().unregister(registry); globalRegistry.remove(registry); } } @Override int getOrder(); @Override @SuppressWarnings("deprecation") void init(GlobalRegistry globalRegistry, EventBus eventBus, MetricsBootstrapConfig config); @Override void destroy(); static final String SERVO_POLLERS; }
|
@Test public void testCheckUrlPatternNoWideChar() { try { ServletUtils.checkUrlPattern("/abcdef"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
|
static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testCheckUrlPatternNotStartWithSlash() { try { ServletUtils.checkUrlPattern("abcdef/*"); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
|
static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void checkUrlPattern(String urlPattern) { if (!urlPattern.startsWith("/")) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } int idx = urlPattern.indexOf("/*"); if (idx < 0 || (idx >= 0 && idx != urlPattern.length() - 2)) { throw new ServiceCombException("only support rule like /* or /path/* or /path1/path2/* and so on."); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testFilterUrlPatternsNormal() { String urlPattern = "/r1/*"; Collection<String> urlPatterns = Arrays.asList(urlPattern); String[] result = ServletUtils.filterUrlPatterns(urlPatterns); Assert.assertThat(result, Matchers.arrayContaining("/r1/*")); result = ServletUtils.filterUrlPatterns(urlPattern); Assert.assertThat(result, Matchers.arrayContaining("/r1/*")); }
|
static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testFilterUrlPatternsEmpty() { Collection<String> urlPatterns = Arrays.asList(" ", "\t"); String[] result = ServletUtils.filterUrlPatterns(urlPatterns); Assert.assertThat(result, Matchers.emptyArray()); }
|
static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testFilterUrlPatternsInvalid() { Collection<String> urlPatterns = Arrays.asList("/abc"); try { ServletUtils.filterUrlPatterns(urlPatterns); Assert.fail("must throw exception"); } catch (ServiceCombException e) { Assert.assertEquals("only support rule like /* or /path/* or /path1/path2/* and so on.", e.getMessage()); } }
|
static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static String[] filterUrlPatterns(String... urlPatterns) { return filterUrlPatterns(Arrays.asList(urlPatterns)); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testcollectUrlPatternsNoRestServlet(@Mocked ServletContext servletContext, @Mocked ServletRegistration servletRegistration) { new Expectations() { { servletRegistration.getClassName(); result = "test"; servletContext.getServletRegistrations(); result = Collections.singletonMap("test", servletRegistration); } }; String[] result = ServletUtils.collectUrlPatterns(servletContext, RestServlet.class); Assert.assertThat(result, Matchers.emptyArray()); }
|
static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testcollectUrlPatternsNormalMapping(@Mocked ServletContext servletContext, @Mocked ServletRegistration r1, @Mocked ServletRegistration r2) { Map<String, ServletRegistration> servletRegistrationMap = new LinkedHashMap<>(); servletRegistrationMap.put("r1", r1); servletRegistrationMap.put("r2", r2); new Expectations() { { r1.getClassName(); result = RestServlet.class.getName(); r1.getMappings(); result = Arrays.asList("/r1/*", "/r1/1/*"); r2.getClassName(); result = RestServlet.class.getName(); servletContext.getServletRegistrations(); result = servletRegistrationMap; } }; String[] result = ServletUtils.collectUrlPatterns(servletContext, RestServlet.class); Assert.assertThat(result, Matchers.arrayContaining("/r1/*", "/r1/1/*")); }
|
static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static String[] collectUrlPatterns(ServletContext servletContext, Class<?> servletCls) { List<ServletRegistration> servlets = findServletRegistrations(servletContext, servletCls); if (servlets.isEmpty()) { return new String[] {}; } ServletRegistration servletRegistration = servlets.get(0); Collection<String> mappings = servletRegistration.getMappings(); if (servlets.size() > 1) { LOGGER.info("Found {} {} registered, select the first one, mappings={}.", servlets.size(), servletCls.getName(), mappings); } return filterUrlPatterns(mappings); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testSaveUrlPrefixNull(@Mocked ServletContext servletContext) { ClassLoaderScopeContext.clearClassLoaderScopeProperty(); ServletUtils.saveUrlPrefix(servletContext); Assert.assertNull(ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX)); ClassLoaderScopeContext.clearClassLoaderScopeProperty(); }
|
public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void testSaveUrlPrefixNormal(@Mocked ServletContext servletContext, @Mocked ServletRegistration servletRegistration) { ClassLoaderScopeContext.clearClassLoaderScopeProperty(); new Expectations() { { servletContext.getContextPath(); result = "/root"; servletRegistration.getClassName(); result = RestServlet.class.getName(); servletRegistration.getMappings(); result = Arrays.asList("/rest/*"); servletContext.getServletRegistrations(); result = Collections.singletonMap("test", servletRegistration); } }; ServletUtils.saveUrlPrefix(servletContext); Assert.assertThat(ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX), Matchers.is("/root/rest")); ClassLoaderScopeContext.clearClassLoaderScopeProperty(); }
|
public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { public static void saveUrlPrefix(ServletContext servletContext) { String urlPrefix = collectUrlPrefix(servletContext, RestServlet.class); if (urlPrefix == null) { LOGGER.info("RestServlet not found, will not save UrlPrefix."); return; } ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, urlPrefix); LOGGER.info("UrlPrefix of this instance is \"{}\".", urlPrefix); } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void createUploadDir_relative(@Mocked ServletContext servletContext) throws IOException { File tempDir = Files.createTempDirectory("temp").toFile(); new Expectations() { { servletContext.getAttribute(ServletContext.TEMPDIR); result = tempDir; } }; File expectDir = new File(tempDir, "upload"); Assert.assertFalse(expectDir.exists()); File dir = ServletUtils.createUploadDir(servletContext, "upload"); Assert.assertTrue(expectDir.exists()); Assert.assertEquals(expectDir.getAbsolutePath(), dir.getAbsolutePath()); dir.delete(); Assert.assertFalse(expectDir.exists()); tempDir.delete(); Assert.assertFalse(tempDir.exists()); }
|
static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void manualTask() throws InterruptedException { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); CountDownLatch latch = new CountDownLatch(1); eventBus.register(new Object() { @Subscribe public void onChecked(InstanceCacheSummary instanceCacheSummary) { result = instanceCacheSummary; latch.countDown(); } }); task.init(); ArchaiusUtils.setProperty(InstanceCacheCheckTask.MANUAL, UUID.randomUUID().toString()); latch.await(); Assert.assertEquals("{\"status\":null,\"producers\":[],\"timestamp\":0}", Json.encode(result)); }
|
@Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; }
|
@Test public void createUploadDir_absolute(@Mocked ServletContext servletContext) throws IOException { File tempDir = Files.createTempDirectory("temp").toFile(); File expectDir = new File(tempDir, "upload"); Assert.assertFalse(expectDir.exists()); File dir = ServletUtils.createUploadDir(servletContext, expectDir.getAbsolutePath()); Assert.assertTrue(expectDir.exists()); Assert.assertEquals(expectDir.getAbsolutePath(), dir.getAbsolutePath()); dir.delete(); Assert.assertFalse(expectDir.exists()); tempDir.delete(); Assert.assertFalse(tempDir.exists()); }
|
static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static File createUploadDir(ServletContext servletContext, String location) { File dir = new File(location); if (!dir.isAbsolute()) { dir = new File((File) servletContext.getAttribute(ServletContext.TEMPDIR), location).getAbsoluteFile(); } if (!dir.exists()) { dir.mkdirs(); } return dir; } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void setServletParameters_notSupportUpload() { ServletUtils.setServletParameters(null); }
|
static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void setServletParameters_supportUpload(@Mocked ServletContext servletContext, @Mocked Dynamic d1, @Mocked ServletRegistration d2) throws IOException { Map<String, ServletRegistration> servletRegistrations = new HashMap<>(); servletRegistrations.put("d1", d1); servletRegistrations.put("d2", d2); new Expectations() { { servletContext.getServletRegistrations(); result = servletRegistrations; d1.getClassName(); result = RestServlet.class.getName(); d2.getClassName(); result = HttpServlet.class.getName(); } }; List<MultipartConfigElement> multipartConfigs = new ArrayList<>(); new MockUp<Dynamic>(d1) { @Mock void setMultipartConfig(MultipartConfigElement multipartConfig) { multipartConfigs.add(multipartConfig); } }; File tempDir = Files.createTempDirectory("temp").toFile(); File uploadDir = new File(tempDir, "upload"); ArchaiusUtils.setProperty(RestConst.UPLOAD_DIR, uploadDir.getAbsolutePath()); ServletUtils.setServletParameters(servletContext); Assert.assertEquals(1, multipartConfigs.size()); MultipartConfigElement multipartConfigElement = multipartConfigs.get(0); Assert.assertEquals(uploadDir.getAbsolutePath(), multipartConfigElement.getLocation()); Assert.assertEquals(-1, multipartConfigElement.getMaxFileSize()); Assert.assertEquals(-1, multipartConfigElement.getMaxRequestSize()); Assert.assertEquals(0, multipartConfigElement.getFileSizeThreshold()); uploadDir.delete(); tempDir.delete(); Assert.assertFalse(tempDir.exists()); }
|
static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
ServletUtils { static void setServletParameters(ServletContext servletContext) { UploadConfig uploadConfig = new UploadConfig(); MultipartConfigElement multipartConfig = uploadConfig.toMultipartConfigElement(); if (multipartConfig == null) { return; } File dir = createUploadDir(servletContext, multipartConfig.getLocation()); LOGGER.info("set uploads directory to \"{}\".", dir.getAbsolutePath()); List<ServletRegistration> servlets = findServletRegistrations(servletContext, RestServlet.class); for (ServletRegistration servletRegistration : servlets) { if (!Dynamic.class.isInstance(servletRegistration)) { continue; } Dynamic dynamic = (Dynamic) servletRegistration; dynamic.setMultipartConfig(multipartConfig); } } static boolean canPublishEndpoint(String listenAddress); static void saveUrlPrefix(ServletContext servletContext); static void init(ServletContext servletContext); }
|
@Test public void onTimeoutCommitted() throws IOException { committed = true; listener.onTimeout(event); Assert.assertNull(request.getAttribute(RestConst.REST_REQUEST)); Assert.assertFalse(flushed); }
|
@Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } @Override void onComplete(AsyncEvent event); @Override void onTimeout(AsyncEvent event); @Override void onError(AsyncEvent event); @Override void onStartAsync(AsyncEvent event); }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } @Override void onComplete(AsyncEvent event); @Override void onTimeout(AsyncEvent event); @Override void onError(AsyncEvent event); @Override void onStartAsync(AsyncEvent event); }
|
@Test public void onTimeoutNotCommitted() throws IOException { committed = false; listener.onTimeout(event); Assert.assertNull(request.getAttribute(RestConst.REST_REQUEST)); Assert.assertEquals(MediaType.APPLICATION_JSON, contentType); Assert.assertEquals(500, statusCode); Assert.assertTrue(flushed); Assert.assertEquals("{\"message\":\"Timeout when processing the request.\"}", writer.toString()); }
|
@Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } @Override void onComplete(AsyncEvent event); @Override void onTimeout(AsyncEvent event); @Override void onError(AsyncEvent event); @Override void onStartAsync(AsyncEvent event); }
|
RestAsyncListener implements AsyncListener { @Override public void onTimeout(AsyncEvent event) throws IOException { ServletRequest request = event.getSuppliedRequest(); HttpServletRequestEx requestEx = (HttpServletRequestEx) request.getAttribute(RestConst.REST_REQUEST); LOGGER.error("Rest request timeout, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); synchronized (requestEx) { ServletResponse response = event.getAsyncContext().getResponse(); if (!response.isCommitted()) { response.setContentType(MediaType.APPLICATION_JSON); ((HttpServletResponse) response).setStatus(Status.INTERNAL_SERVER_ERROR.getStatusCode()); PrintWriter out = response.getWriter(); out.write(TIMEOUT_MESSAGE); response.flushBuffer(); } request.removeAttribute(RestConst.REST_REQUEST); } LOGGER.error("Rest request timeout committed, method {}, path {}.", requestEx.getMethod(), requestEx.getRequestURI()); } @Override void onComplete(AsyncEvent event); @Override void onTimeout(AsyncEvent event); @Override void onError(AsyncEvent event); @Override void onStartAsync(AsyncEvent event); }
|
@Test public void testInit() throws ServletException { restservlet.init(); Assert.assertTrue(true); }
|
@Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); }
|
RestServlet extends HttpServlet { @Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); } }
|
RestServlet extends HttpServlet { @Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); } }
|
RestServlet extends HttpServlet { @Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); }
|
RestServlet extends HttpServlet { @Override public void init() throws ServletException { super.init(); LOGGER.info("Rest Servlet inited"); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); }
|
@Test public void testService() { Holder<Boolean> holder = new Holder<>(); ServletRestDispatcher servletRestServer = new MockUp<ServletRestDispatcher>() { @Mock void service(HttpServletRequest request, HttpServletResponse response) { holder.value = true; } }.getMockInstance(); Deencapsulation.setField(restservlet, "servletRestServer", servletRestServer); restservlet.service(null, null); Assert.assertTrue(holder.value); }
|
@Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); }
|
RestServlet extends HttpServlet { @Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); } }
|
RestServlet extends HttpServlet { @Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); } }
|
RestServlet extends HttpServlet { @Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); }
|
RestServlet extends HttpServlet { @Override public void service(final HttpServletRequest request, final HttpServletResponse response) { servletRestServer.service(request, response); } @Override void init(); @Override void service(final HttpServletRequest request, final HttpServletResponse response); }
|
@Test public void testInitNotPublish(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = null; } }; Assert.assertTrue(transport.init()); Assert.assertNull(transport.getPublishEndpoint()); }
|
@Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testInitPublishNoUrlPrefix(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "1.1.1.1:1234"; } }; Assert.assertTrue(transport.init()); Assert.assertEquals("rest: }
|
@Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testInitPublishWithUrlPrefix(@Mocked RestTransportClient restTransportClient) { new MockUp<RestTransportClientManager>() { @Mock public RestTransportClient getRestTransportClient(boolean sslEnabled) { return restTransportClient; } }; new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "1.1.1.1:1234"; } }; ClassLoaderScopeContext.setClassLoaderScopeProperty(DefinitionConst.URL_PREFIX, "/root"); Assert.assertTrue(transport.init()); Assert.assertEquals("rest: }
|
@Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean init() { String urlPrefix = ClassLoaderScopeContext.getClassLoaderScopeProperty(DefinitionConst.URL_PREFIX); Map<String, String> queryMap = new HashMap<>(); if (!StringUtils.isEmpty(urlPrefix)) { queryMap.put(DefinitionConst.URL_PREFIX, urlPrefix); } String listenAddress = ServletConfig.getLocalServerAddress(); setListenAddressWithoutSchema(listenAddress, queryMap); restClient = RestTransportClientManager.INSTANCE.getRestClient(); return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void autoTask_normal() throws InterruptedException { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 1); CountDownLatch latch = new CountDownLatch(1); eventBus.register(new Object() { @Subscribe public void onChecked(InstanceCacheSummary instanceCacheSummary) { result = instanceCacheSummary; ((ScheduledFuture<?>) Deencapsulation.getField(task, "scheduledFuture")).cancel(false); latch.countDown(); } }); task.init(); latch.await(); Assert.assertNotNull(Deencapsulation.getField(task, "scheduledFuture")); Assert.assertEquals("{\"status\":null,\"producers\":[],\"timestamp\":0}", Json.encode(result)); }
|
@Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; }
|
@Test public void testCanInitNullAddress() throws IOException { new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = null; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertTrue(transport.canInit()); }
|
@Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testCanInitListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "0.0.0.0:" + port; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertTrue(transport.canInit()); ss.close(); }
|
@Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testCanInitNotListened() throws IOException { ServerSocket ss = new ServerSocket(0); int port = ss.getLocalPort(); ss.close(); new Expectations(ServletConfig.class) { { ServletConfig.getLocalServerAddress(); result = "0.0.0.0:" + port; } }; ServletRestTransport transport = new ServletRestTransport(); Assert.assertFalse(transport.canInit()); }
|
@Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
ServletRestTransport extends AbstractTransport { @Override public boolean canInit() { String listenAddress = ServletConfig.getLocalServerAddress(); if (listenAddress == null) { return true; } if (!ServletUtils.canPublishEndpoint(listenAddress)) { LOGGER.info("ignore transport {}.", this.getClass().getName()); return false; } return true; } @Override String getName(); @Override boolean canInit(); @Override boolean init(); @Override void send(Invocation invocation, AsyncResponse asyncResp); }
|
@Test public void testDefaultInjectEmptyUrlPattern(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) { new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = null; } }; Assert.assertEquals(null, RestServletInjector.defaultInject(servletContext)); }
|
public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); static final String SERVLET_NAME; }
|
@Test public void testDefaultInjectNotListen(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) throws UnknownHostException, IOException { try (ServerSocket ss = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1"))) { int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = "/*"; ServletConfig.getLocalServerAddress(); result = "127.0.0.1:" + port; } }; } Assert.assertEquals(null, RestServletInjector.defaultInject(servletContext)); }
|
public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); static final String SERVLET_NAME; }
|
@Test public void testDefaultInjectListen(@Mocked ServletContext servletContext, @Mocked Dynamic dynamic) throws UnknownHostException, IOException { try (ServerSocket ss = new ServerSocket(0, 0, InetAddress.getByName("127.0.0.1"))) { int port = ss.getLocalPort(); new Expectations(ServletConfig.class) { { ServletConfig.getServletUrlPattern(); result = "/rest/*"; ServletConfig.getLocalServerAddress(); result = "127.0.0.1:" + port; } }; Assert.assertEquals(dynamic, RestServletInjector.defaultInject(servletContext)); } }
|
public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); }
|
RestServletInjector { public static Dynamic defaultInject(ServletContext servletContext) { RestServletInjector injector = new RestServletInjector(); String urlPattern = ServletConfig.getServletUrlPattern(); return injector.inject(servletContext, urlPattern); } static Dynamic defaultInject(ServletContext servletContext); Dynamic inject(ServletContext servletContext, String urlPattern); static final String SERVLET_NAME; }
|
@Test public void findRestOperationCacheTrue(@Mocked HttpServletRequest request, @Mocked HttpServerFilter f1) { HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); Deencapsulation.setField(restInvocation, "requestEx", requestEx); new MockUp<RestProducerInvocation>() { @Mock void findRestOperation() { Deencapsulation.setField(getMockInstance(), "restOperationMeta", restOperationMeta); } }; List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = true; } }; restInvocation.setHttpServerFilters(httpServerFilters); restInvocation.findRestOperation(); Assert.assertTrue(Deencapsulation.getField(requestEx, "cacheRequest")); }
|
@Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); }
|
RestServletProducerInvocation extends RestProducerInvocation { @Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); } }
|
RestServletProducerInvocation extends RestProducerInvocation { @Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); } }
|
RestServletProducerInvocation extends RestProducerInvocation { @Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); } }
|
RestServletProducerInvocation extends RestProducerInvocation { @Override protected void findRestOperation() { super.findRestOperation(); boolean cacheRequest = collectCacheRequest(restOperationMeta.getOperationMeta()); ((StandardHttpServletRequestEx) requestEx).setCacheRequest(cacheRequest); } }
|
@Test public void collectCacheRequestCacheTrue(@Mocked HttpServerFilter f1) { List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = true; } }; restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertTrue(restInvocation.collectCacheRequest(operationMeta)); }
|
protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
@Test public void collectCacheRequestCacheFalse(@Mocked HttpServerFilter f1) { List<HttpServerFilter> httpServerFilters = Arrays.asList(f1); new Expectations() { { f1.needCacheRequest(operationMeta); result = false; } }; restInvocation.setHttpServerFilters(httpServerFilters); Assert.assertFalse(restInvocation.collectCacheRequest(operationMeta)); }
|
protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
RestServletProducerInvocation extends RestProducerInvocation { protected boolean collectCacheRequest(OperationMeta operationMeta) { for (HttpServerFilter filter : httpServerFilters) { if (filter.needCacheRequest(operationMeta)) { return true; } } return false; } }
|
@Test public void service() { Holder<Boolean> handled = new Holder<>(); new MockUp<RestServletProducerInvocation>() { @Mock void invoke(Transport transport, HttpServletRequestEx requestEx, HttpServletResponseEx responseEx, List<HttpServerFilter> httpServerFilters) { handled.value = true; } }; dispatcher.service(request, response); Assert.assertTrue(handled.value); }
|
public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); }
|
ServletRestDispatcher { public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } }
|
ServletRestDispatcher { public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } }
|
ServletRestDispatcher { public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } void service(HttpServletRequest request, HttpServletResponse response); }
|
ServletRestDispatcher { public void service(HttpServletRequest request, HttpServletResponse response) { if (transport == null) { transport = SCBEngine.getInstance().getTransportManager().findTransport(Const.RESTFUL); microserviceMeta = SCBEngine.getInstance().getProducerMicroserviceMeta(); } AsyncContext asyncCtx = request.startAsync(); asyncCtx.addListener(restAsyncListener); asyncCtx.setTimeout(ServletConfig.getAsyncServletTimeout()); HttpServletRequestEx requestEx = new StandardHttpServletRequestEx(request); HttpServletResponseEx responseEx = new StandardHttpServletResponseEx(response); if (SCBEngine.getInstance().isFilterChainEnabled()) { ((StandardHttpServletRequestEx) requestEx).setCacheRequest(true); InvocationCreator creator = new RestServletProducerInvocationCreator(microserviceMeta, transport.getEndpoint(), requestEx, responseEx); new RestProducerInvocationFlow(creator, requestEx, responseEx) .run(); return; } RestServletProducerInvocation restProducerInvocation = new RestServletProducerInvocation(); restProducerInvocation.invoke(transport, requestEx, responseEx, httpServerFilters); } void service(HttpServletRequest request, HttpServletResponse response); }
|
@Test public void autoTask_clearOldTask() { Holder<Boolean> cancelResult = new Holder<>(); ScheduledFuture<?> scheduledFuture = new MockUp<ScheduledFuture<?>>() { @Mock boolean cancel(boolean mayInterruptIfRunning) { cancelResult.value = true; return true; } }.getMockInstance(); ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); Deencapsulation.setField(task, "scheduledFuture", scheduledFuture); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); Assert.assertTrue(cancelResult.value); }
|
@Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; }
|
@Test public void testcontextInitializedException() { boolean status = true; RestServletContextListener listener = new RestServletContextListener(); ServletContextEvent sce = Mockito.mock(ServletContextEvent.class); try { listener.contextInitialized(sce); } catch (Exception | Error e) { status = false; } Assert.assertFalse(status); }
|
@Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } }
|
RestServletContextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } } }
|
RestServletContextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } } }
|
RestServletContextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); }
|
RestServletContextListener implements ServletContextListener { @Override public void contextInitialized(ServletContextEvent sce) { try { initSpring(sce); } catch (Exception e) { throw new Error(e); } } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); }
|
@Test public void testInitSpring() { boolean status = true; RestServletContextListener listener = new RestServletContextListener(); ServletContextEvent sce = Mockito.mock(ServletContextEvent.class); ServletContext context = Mockito.mock(ServletContext.class); Mockito.when(sce.getServletContext()).thenReturn(context); Mockito.when(sce.getServletContext().getInitParameter("contextConfigLocation")).thenReturn("locations"); try { listener.initSpring(sce); } catch (Exception e) { status = false; } Assert.assertFalse(status); }
|
public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; }
|
RestServletContextListener implements ServletContextListener { public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; } }
|
RestServletContextListener implements ServletContextListener { public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; } }
|
RestServletContextListener implements ServletContextListener { public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); }
|
RestServletContextListener implements ServletContextListener { public AbstractApplicationContext initSpring(ServletContextEvent sce) { context = new CseXmlWebApplicationContext(sce.getServletContext()); context.refresh(); return context; } @Override void contextInitialized(ServletContextEvent sce); AbstractApplicationContext initSpring(ServletContextEvent sce); @Override void contextDestroyed(ServletContextEvent sce); }
|
@Test public void testGetLocalServerAddress() { Assert.assertNull(ServletConfig.getLocalServerAddress()); }
|
public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); }
|
ServletConfig { public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); } }
|
ServletConfig { public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); } private ServletConfig(); }
|
ServletConfig { public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); }
|
ServletConfig { public static String getLocalServerAddress() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(SERVICECOMB_REST_ADDRESS, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; }
|
@Test public void testGetServerTimeout() { Assert.assertEquals(ServletConfig.DEFAULT_ASYN_SERVLET_TIMEOUT, ServletConfig.getAsyncServletTimeout()); }
|
public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); }
|
ServletConfig { public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); } }
|
ServletConfig { public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); } private ServletConfig(); }
|
ServletConfig { public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); }
|
ServletConfig { public static long getAsyncServletTimeout() { return asyncServletTimeoutProperty.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; }
|
@Test public void testGetServletUrlPattern() { DynamicPropertyFactory.getInstance(); Configuration configuration = (Configuration) DynamicPropertyFactory.getBackingConfigurationSource(); configuration.setProperty(ServletConfig.KEY_SERVLET_URL_PATTERN, "/*"); Assert.assertEquals("/*", ServletConfig.getServletUrlPattern()); }
|
public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); }
|
ServletConfig { public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); } }
|
ServletConfig { public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); } private ServletConfig(); }
|
ServletConfig { public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); }
|
ServletConfig { public static String getServletUrlPattern() { DynamicStringProperty address = DynamicPropertyFactory.getInstance().getStringProperty(KEY_SERVLET_URL_PATTERN, null); return address.get(); } private ServletConfig(); static long getAsyncServletTimeout(); static String getLocalServerAddress(); static String getServletUrlPattern(); static final long DEFAULT_ASYN_SERVLET_TIMEOUT; static final String KEY_SERVLET_URL_PATTERN; static final String SERVICECOMB_REST_ADDRESS; static final String KEY_SERVICECOMB_ASYC_SERVLET_TIMEOUT; static final String DEFAULT_URL_PATTERN; }
|
@Test public void testCseRestTemplate() { Assert.assertEquals(CseRestTemplate.class, new CseRestTemplate().getClass()); }
|
public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); }
|
CseRestTemplate extends AcceptableRestTemplate { public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); } }
|
CseRestTemplate extends AcceptableRestTemplate { public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); } CseRestTemplate(); }
|
CseRestTemplate extends AcceptableRestTemplate { public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); } CseRestTemplate(); @Override @Nullable T getForObject(String url, Class<T> responseType, Object... uriVariables); @Override @Nullable T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables); @Override @Nullable T getForObject(URI url, Class<T> responseType); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T postForObject(URI url, @Nullable Object request, Class<T> responseType); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T patchForObject(URI url, @Nullable Object request, Class<T> responseType); @Override ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType); @Override RequestCallback httpEntityCallback(Object requestBody); @Override RequestCallback httpEntityCallback(Object requestBody, Type responseType); @Override boolean isAcceptable(String uri); @Override boolean isAcceptable(URI uri); }
|
CseRestTemplate extends AcceptableRestTemplate { public CseRestTemplate() { setMessageConverters(Arrays.asList(new CseHttpMessageConverter())); setRequestFactory(new CseClientHttpRequestFactory()); setUriTemplateHandler(new CseUriTemplateHandler()); } CseRestTemplate(); @Override @Nullable T getForObject(String url, Class<T> responseType, Object... uriVariables); @Override @Nullable T getForObject(String url, Class<T> responseType, Map<String, ?> uriVariables); @Override @Nullable T getForObject(URI url, Class<T> responseType); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T postForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T postForObject(URI url, @Nullable Object request, Class<T> responseType); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Object... uriVariables); @Override @Nullable T patchForObject(String url, @Nullable Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override @Nullable T patchForObject(URI url, @Nullable Object request, Class<T> responseType); @Override ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType); @Override RequestCallback httpEntityCallback(Object requestBody); @Override RequestCallback httpEntityCallback(Object requestBody, Type responseType); @Override boolean isAcceptable(String uri); @Override boolean isAcceptable(URI uri); }
|
@Test public void getOrder() { Assert.assertEquals(Integer.MIN_VALUE, filter.getOrder()); }
|
@Override public int getOrder() { return Integer.MIN_VALUE; }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MIN_VALUE; } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MIN_VALUE; } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MIN_VALUE; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public int getOrder() { return Integer.MIN_VALUE; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void beforeSendRequestNoHeader(@Mocked Invocation invocation) { Map<String, Object> context = new HashMap<>(); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertFalse(requestEx.getHeaderNames().hasMoreElements()); }
|
@Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void beforeSendRequestWithNullHeader(@Mocked Invocation invocation) { Map<String, Object> context = new HashMap<>(1); HttpHeaders httpHeaders = new HttpHeaders(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); httpHeaders.add("headerName0", "headerValue0"); httpHeaders.add("headerName1", null); httpHeaders.add("headerName2", "headerValue2"); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertEquals("headerValue0", requestEx.getHeader("headerName0")); Assert.assertEquals("headerValue2", requestEx.getHeader("headerName2")); Assert.assertNull(requestEx.getHeader("headerName1")); }
|
@Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void beforeSendRequestHaveHeader(@Mocked Invocation invocation) { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.add("name", "value"); Map<String, Object> context = new HashMap<>(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertThat(Collections.list(requestEx.getHeaders("name")), Matchers.contains("value")); }
|
@Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void autoTask_invalidIntervalZero() { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, 0); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); }
|
@Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; }
|
@Test public void beforeSendRequestSkipContentLength(@Mocked Invocation invocation) { HttpHeaders httpHeaders = new HttpHeaders(); httpHeaders.add(HttpHeaders.CONTENT_LENGTH, "0"); Map<String, Object> context = new HashMap<>(); context.put(RestConst.CONSUMER_HEADER, httpHeaders); new Expectations() { { invocation.getHandlerContext(); result = context; } }; HttpServletRequestEx requestEx = new CommonToHttpServletRequest(null, null, new HttpHeaders(), null, false); filter.beforeSendRequest(invocation, requestEx); Assert.assertNull((requestEx.getHeader(HttpHeaders.CONTENT_LENGTH))); }
|
@Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx) { HttpHeaders httpHeaders = (HttpHeaders) invocation.getHandlerContext().get(RestConst.CONSUMER_HEADER); if (httpHeaders == null) { return; } httpHeaders.forEach((key, values) -> { if (HttpHeaders.CONTENT_LENGTH.equalsIgnoreCase(key)) { LOGGER.debug("skip copy content-length into request"); return; } for (String value : values) { if (null == value) { LOGGER.debug("header value is null, key = [{}]. Will not set this header into request", key); continue; } requestEx.addHeader(key, value); } }); } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void afterReceiveResponse() { Assert.assertNull(filter.afterReceiveResponse(null, null)); }
|
@Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; } }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
RestTemplateCopyHeaderFilter implements HttpClientFilter { @Override public Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx) { return null; } @Override int getOrder(); @Override void beforeSendRequest(Invocation invocation, HttpServletRequestEx requestEx); @Override Response afterReceiveResponse(Invocation invocation, HttpServletResponseEx responseEx); }
|
@Test public void testCseClientHttpRequestFactory() { CseClientHttpRequestFactory lCseClientHttpRequestFactory = new CseClientHttpRequestFactory(); try { Assert.assertEquals(HttpMethod.GET, lCseClientHttpRequestFactory.createRequest(URI.create("/test"), HttpMethod.GET).getMethod()); } catch (IOException e) { Assert.assertNotNull(e); } }
|
@Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); }
|
CseClientHttpRequestFactory implements ClientHttpRequestFactory { @Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); } }
|
CseClientHttpRequestFactory implements ClientHttpRequestFactory { @Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); } }
|
CseClientHttpRequestFactory implements ClientHttpRequestFactory { @Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); } @Override ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod); }
|
CseClientHttpRequestFactory implements ClientHttpRequestFactory { @Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException { return new CseClientHttpRequest(uri, httpMethod); } @Override ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod); }
|
@Test public void headForHeadersWithUnderlyingRestTemplate() { HttpHeaders expected = new HttpHeaders(); HttpHeaders actual; when(underlying.headForHeaders(url, param1, param2)).thenReturn(expected); actual = wrapper.headForHeaders(url, param1, param2); assertThat(actual, is(expected)); verify(underlying).headForHeaders(url, param1, param2); when(underlying.headForHeaders(url, paramsMap)).thenReturn(expected); actual = wrapper.headForHeaders(url, paramsMap); assertThat(actual, is(expected)); verify(underlying).headForHeaders(url, paramsMap); when(underlying.headForHeaders(uri)).thenReturn(expected); actual = wrapper.headForHeaders(uri); assertThat(actual, is(expected)); verify(underlying).headForHeaders(uri); }
|
@Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public HttpHeaders headForHeaders(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).headForHeaders(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void optionsForAllowWithUnderlyingRestTemplate() { Set<HttpMethod> expected = new HashSet<>(this.httpMethods); Set<HttpMethod> actual; when(underlying.optionsForAllow(url, param1, param2)).thenReturn(expected); actual = wrapper.optionsForAllow(url, param1, param2); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(url, param1, param2); when(underlying.optionsForAllow(url, paramsMap)).thenReturn(expected); actual = wrapper.optionsForAllow(url, paramsMap); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(url, paramsMap); when(underlying.optionsForAllow(uri)).thenReturn(expected); actual = wrapper.optionsForAllow(uri); assertThat(actual, is(expected)); verify(underlying).optionsForAllow(uri); }
|
@Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public Set<HttpMethod> optionsForAllow(String url, Object... urlVariables) throws RestClientException { return getRestTemplate(url).optionsForAllow(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void getForObjectWithUnderlyingRestTemplate() { String actual; when(underlying.getForObject(url, String.class, param1, param2)).thenReturn(response); actual = wrapper.getForObject(url, String.class, param1, param2); assertThat(actual, is(response)); verify(underlying).getForObject(url, String.class, param1, param2); when(underlying.getForObject(url, String.class, paramsMap)).thenReturn(response); actual = wrapper.getForObject(url, String.class, paramsMap); assertThat(actual, is(response)); verify(underlying).getForObject(url, String.class, paramsMap); when(underlying.getForObject(uri, String.class)).thenReturn(response); actual = wrapper.getForObject(uri, String.class); assertThat(actual, is(response)); verify(underlying).getForObject(uri, String.class); }
|
@Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T getForObject(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForObject(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void getForEntityWithUnderlyingRestTemplate() { ResponseEntity<String> actual; when(underlying.getForEntity(url, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.getForEntity(url, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(url, String.class, param1, param2); when(underlying.getForEntity(url, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.getForEntity(url, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(url, String.class, paramsMap); when(underlying.getForEntity(uri, String.class)).thenReturn(responseEntity); actual = wrapper.getForEntity(uri, String.class); assertThat(actual, is(responseEntity)); verify(underlying).getForEntity(uri, String.class); }
|
@Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> getForEntity(String url, Class<T> responseType, Object... urlVariables) throws RestClientException { return getRestTemplate(url).getForEntity(url, responseType, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void postForObjectWithUnderlyingRestTemplate() { String actual; when(underlying.postForObject(url, requestEntity, String.class, param1, param2)).thenReturn(response); actual = wrapper.postForObject(url, requestEntity, String.class, param1, param2); assertThat(actual, is(response)); verify(underlying).postForObject(url, requestEntity, String.class, param1, param2); when(underlying.postForObject(url, requestEntity, String.class, paramsMap)).thenReturn(response); actual = wrapper.postForObject(url, requestEntity, String.class, paramsMap); assertThat(actual, is(response)); verify(underlying).postForObject(url, requestEntity, String.class, paramsMap); when(underlying.postForObject(uri, requestEntity, String.class)).thenReturn(response); actual = wrapper.postForObject(uri, requestEntity, String.class); assertThat(actual, is(response)); verify(underlying).postForObject(uri, requestEntity, String.class); }
|
@Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T postForObject(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForObject(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void postForEntityWithUnderlyingRestTemplate() { ResponseEntity<String> actual; when(underlying.postForEntity(url, requestEntity, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.postForEntity(url, requestEntity, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(url, requestEntity, String.class, param1, param2); when(underlying.postForEntity(url, requestEntity, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.postForEntity(url, requestEntity, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(url, requestEntity, String.class, paramsMap); when(underlying.postForEntity(uri, requestEntity, String.class)).thenReturn(responseEntity); actual = wrapper.postForEntity(uri, requestEntity, String.class); assertThat(actual, is(responseEntity)); verify(underlying).postForEntity(uri, requestEntity, String.class); }
|
@Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).postForEntity(url, request, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void postForLocationWithUnderlyingRestTemplate() { URI actual; when(underlying.postForLocation(url, requestEntity, param1, param2)).thenReturn(uri); actual = wrapper.postForLocation(url, requestEntity, param1, param2); assertThat(actual, is(uri)); verify(underlying).postForLocation(url, requestEntity, param1, param2); when(underlying.postForLocation(url, requestEntity, paramsMap)).thenReturn(uri); actual = wrapper.postForLocation(url, requestEntity, paramsMap); assertThat(actual, is(uri)); verify(underlying).postForLocation(url, requestEntity, paramsMap); when(underlying.postForLocation(uri, requestEntity)).thenReturn(uri); actual = wrapper.postForLocation(uri, requestEntity); assertThat(actual, is(uri)); verify(underlying).postForLocation(uri, requestEntity); }
|
@Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public URI postForLocation(String url, Object request, Object... urlVariables) throws RestClientException { return getRestTemplate(url).postForLocation(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void autoTask_invalidIntervalLessThanZero() { ArchaiusUtils.setProperty(InstanceCacheCheckTask.AUTO_INTERVAL, -1); task.init(); Assert.assertNull(Deencapsulation.getField(task, "scheduledFuture")); }
|
@Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); }
|
InstanceCacheCheckTask implements ServiceRegistryTaskInitializer { @Override public void init(RemoteServiceRegistry remoteServiceRegistry) { taskPool = remoteServiceRegistry.getTaskPool(); eventBus = remoteServiceRegistry.getEventBus(); init(); } void setTimeUnit(TimeUnit timeUnit); void setTaskPool(ScheduledThreadPoolExecutor taskPool); void setEventBus(EventBus eventBus); DynamicStringProperty getManualCheckProperty(); DynamicIntProperty getAutoCheckIntervalProperty(); @Override void init(RemoteServiceRegistry remoteServiceRegistry); static final String MANUAL; static final String AUTO_INTERVAL; }
|
@Test public void executeWithUnderlyingRestTemplate() { RequestCallback requestCallback = clientHttpRequest -> { }; ResponseExtractor<ResponseEntity<String>> responseExtractor = clientHttpResponse -> responseEntity; ResponseEntity<String> actual; for (HttpMethod method : httpMethods) { when(underlying.execute(url, method, requestCallback, responseExtractor, param1, param2)) .thenReturn(responseEntity); actual = wrapper.execute(url, method, requestCallback, responseExtractor, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).execute(url, method, requestCallback, responseExtractor, param1, param2); when(underlying.execute(url, method, requestCallback, responseExtractor, paramsMap)).thenReturn(responseEntity); actual = wrapper.execute(url, method, requestCallback, responseExtractor, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).execute(url, method, requestCallback, responseExtractor, paramsMap); when(underlying.execute(uri, method, requestCallback, responseExtractor)).thenReturn(responseEntity); actual = wrapper.execute(uri, method, requestCallback, responseExtractor); assertThat(actual, is(responseEntity)); verify(underlying).execute(uri, method, requestCallback, responseExtractor); } }
|
@Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException { return getRestTemplate(url).execute(url, method, requestCallback, responseExtractor, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void exchangeWithUnderlyingRestTemplate() { ResponseEntity<String> actual; for (HttpMethod method : httpMethods) { when(underlying.exchange(url, method, requestEntity, String.class, param1, param2)).thenReturn(responseEntity); actual = wrapper.exchange(url, method, requestEntity, String.class, param1, param2); assertThat(actual, is(responseEntity)); verify(underlying).exchange(url, method, requestEntity, String.class, param1, param2); when(underlying.exchange(url, method, requestEntity, String.class, paramsMap)).thenReturn(responseEntity); actual = wrapper.exchange(url, method, requestEntity, String.class, paramsMap); assertThat(actual, is(responseEntity)); verify(underlying).exchange(url, method, requestEntity, String.class, paramsMap); when(underlying.exchange(uri, method, requestEntity, String.class)).thenReturn(responseEntity); actual = wrapper.exchange(uri, method, requestEntity, String.class); assertThat(actual, is(responseEntity)); verify(underlying).exchange(uri, method, requestEntity, String.class); RequestEntity<String> request = new RequestEntity<>(method, uri); when(underlying.exchange(request, String.class)).thenReturn(responseEntity); actual = wrapper.exchange(request, String.class); assertThat(actual, is(responseEntity)); verify(underlying).exchange(request, String.class); } }
|
@Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void exchangeUsingParameterizedTypeWithUnderlyingRestTemplate() { ParameterizedTypeReference<List<String>> typeReference = new ParameterizedTypeReference<List<String>>() { }; ResponseEntity<List<String>> actual; for (HttpMethod method : httpMethods) { when(underlying.exchange(url, method, requestEntity, typeReference, param1, param2)).thenReturn(typedResponse); actual = wrapper.exchange(url, method, requestEntity, typeReference, param1, param2); assertThat(actual, is(typedResponse)); verify(underlying).exchange(url, method, requestEntity, typeReference, param1, param2); when(underlying.exchange(url, method, requestEntity, typeReference, paramsMap)).thenReturn(typedResponse); actual = wrapper.exchange(url, method, requestEntity, typeReference, paramsMap); assertThat(actual, is(typedResponse)); verify(underlying).exchange(url, method, requestEntity, typeReference, paramsMap); when(underlying.exchange(uri, method, requestEntity, typeReference)).thenReturn(typedResponse); actual = wrapper.exchange(uri, method, requestEntity, typeReference); assertThat(actual, is(typedResponse)); verify(underlying).exchange(uri, method, requestEntity, typeReference); RequestEntity<String> request = new RequestEntity<>(method, uri); when(underlying.exchange(request, typeReference)).thenReturn(typedResponse); actual = wrapper.exchange(request, typeReference); assertThat(actual, is(typedResponse)); verify(underlying).exchange(request, typeReference); } }
|
@Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public <T> ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables) throws RestClientException { return getRestTemplate(url).exchange(url, method, requestEntity, responseType, uriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void putWithUnderlyingRestTemplate() { wrapper.put(url, requestEntity, param1, param2); verify(underlying).put(url, requestEntity, param1, param2); wrapper.put(url, requestEntity, paramsMap); verify(underlying).put(url, requestEntity, paramsMap); wrapper.put(uri, requestEntity); verify(underlying).put(uri, requestEntity); }
|
@Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void put(String url, Object request, Object... urlVariables) throws RestClientException { getRestTemplate(url).put(url, request, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void deleteWithUnderlyingRestTemplate() { wrapper.delete(url, param1, param2); verify(underlying).delete(url, param1, param2); wrapper.delete(url, paramsMap); verify(underlying).delete(url, paramsMap); wrapper.delete(uri); verify(underlying).delete(uri); }
|
@Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void delete(String url, Object... urlVariables) throws RestClientException { getRestTemplate(url).delete(url, urlVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void setInterceptorsWithUnderlying() { ClientHttpRequestInterceptor interceptor1 = mock(ClientHttpRequestInterceptor.class); ClientHttpRequestInterceptor interceptor2 = mock(ClientHttpRequestInterceptor.class); List<ClientHttpRequestInterceptor> interceptors = asList(interceptor1, interceptor2); wrapper.setInterceptors(interceptors); assertThat(wrapper.getInterceptors(), contains(interceptor1, interceptor2)); assertThat(wrapper.defaultRestTemplate.getInterceptors(), contains(interceptor1, interceptor2)); verify(underlying, never()).setInterceptors(interceptors); }
|
@Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) { super.setInterceptors(interceptors); defaultRestTemplate.setInterceptors(interceptors); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void doNotSetRequestFactoryWithUnderlying() { ClientHttpRequestFactory requestFactory = mock(ClientHttpRequestFactory.class); wrapper.setRequestFactory(requestFactory); assertThat(wrapper.getRequestFactory(), is(requestFactory)); assertThat(wrapper.defaultRestTemplate.getRequestFactory(), is(requestFactory)); verify(underlying, never()).setRequestFactory(requestFactory); }
|
@Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setRequestFactory(ClientHttpRequestFactory requestFactory) { super.setRequestFactory(requestFactory); defaultRestTemplate.setRequestFactory(requestFactory); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void setErrorHandlerWithUnderlying() { ResponseErrorHandler errorHandler = mock(ResponseErrorHandler.class); wrapper.setErrorHandler(errorHandler); assertThat(wrapper.getErrorHandler(), is(errorHandler)); assertThat(wrapper.defaultRestTemplate.getErrorHandler(), is(errorHandler)); verify(underlying).setErrorHandler(errorHandler); }
|
@Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setErrorHandler(ResponseErrorHandler errorHandler) { super.setErrorHandler(errorHandler); acceptableRestTemplates.forEach(template -> template.setErrorHandler(errorHandler)); defaultRestTemplate.setErrorHandler(errorHandler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void setDefaultUriVariablesWithUnderlying() { Map<String, Object> uriVariables = new HashMap<>(); wrapper.setDefaultUriVariables(uriVariables); assertThat(defaultUriVariablesOf(wrapper), is(uriVariables)); assertThat(defaultUriVariablesOf(wrapper.defaultRestTemplate), is(uriVariables)); verify(underlying).setDefaultUriVariables(uriVariables); }
|
@Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setDefaultUriVariables(Map<String, ?> defaultUriVariables) { super.setDefaultUriVariables(defaultUriVariables); acceptableRestTemplates.forEach(template -> template.setDefaultUriVariables(defaultUriVariables)); defaultRestTemplate.setDefaultUriVariables(defaultUriVariables); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void dotNotSetUriTemplateHandlerWithUnderlying() { UriTemplateHandler uriTemplateHandler = mock(UriTemplateHandler.class); wrapper.setUriTemplateHandler(uriTemplateHandler); assertThat(wrapper.getUriTemplateHandler(), is(uriTemplateHandler)); assertThat(wrapper.defaultRestTemplate.getUriTemplateHandler(), is(uriTemplateHandler)); verify(underlying, never()).setUriTemplateHandler(uriTemplateHandler); }
|
@Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setUriTemplateHandler(UriTemplateHandler handler) { super.setUriTemplateHandler(handler); defaultRestTemplate.setUriTemplateHandler(handler); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void testGetRemoteRegistryClient(@Mocked ServiceRegistryClientImpl registryClient) { Configuration configuration = ConfigUtil.createLocalConfig(); EventBus eventBus = new EventBus(); ServiceRegistryConfig serviceRegistryConfig = ServiceRegistryConfig.INSTANCE; ServiceRegistry serviceRegistry = ServiceRegistryFactory.create(eventBus, serviceRegistryConfig, configuration); serviceRegistry.init(); ServiceRegistryClient client = serviceRegistry.getServiceRegistryClient(); Assert.assertTrue(client instanceof ServiceRegistryClientImpl); serviceRegistry = ServiceRegistryFactory.create(eventBus, serviceRegistryConfig, configuration); Assert.assertTrue(serviceRegistry instanceof RemoteServiceRegistry); serviceRegistry = LocalServiceRegistryFactory.createLocal(eventBus, serviceRegistryConfig, configuration); serviceRegistry.init(); client = serviceRegistry.getServiceRegistryClient(); Assert.assertTrue(client instanceof LocalServiceRegistryClientImpl); Assert.assertTrue(LocalServiceRegistryFactory.createLocal(eventBus, serviceRegistryConfig, configuration) instanceof LocalServiceRegistry); }
|
public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); }
|
ServiceRegistryFactory { public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); } }
|
ServiceRegistryFactory { public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); } private ServiceRegistryFactory(); }
|
ServiceRegistryFactory { public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); } private ServiceRegistryFactory(); static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); static ServiceRegistry create(EventBus eventBus, ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); }
|
ServiceRegistryFactory { public static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig, Configuration configuration) { return create(null, serviceRegistryConfig, configuration); } private ServiceRegistryFactory(); static ServiceRegistry create(ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); static ServiceRegistry create(EventBus eventBus, ServiceRegistryConfig serviceRegistryConfig,
Configuration configuration); }
|
@SuppressWarnings("unchecked") @Test public void setMessageConvertersWithUnderlying() { ByteArrayHttpMessageConverter messageConverter = mock(ByteArrayHttpMessageConverter.class); wrapper.setMessageConverters(singletonList(messageConverter)); assertThat(wrapper.getMessageConverters(), contains(messageConverter)); assertThat(wrapper.defaultRestTemplate.getMessageConverters(), contains(messageConverter)); verify(underlying, never()).setMessageConverters(singletonList(messageConverter)); }
|
@Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); } }
|
RestTemplateWrapper extends RestTemplate { @Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { @Override public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) { super.setMessageConverters(messageConverters); defaultRestTemplate.setMessageConverters(messageConverters); } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void getsAcceptableRestTemplate() { assertThat(wrapper.getRestTemplate(uri), is(underlying)); assertThat(wrapper.getRestTemplate(url), is(underlying)); }
|
RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void getsDefaultRestTemplate() { reset(underlying); assertThat(wrapper.getRestTemplate(uri), is(wrapper.defaultRestTemplate)); assertThat(wrapper.getRestTemplate(url), is(wrapper.defaultRestTemplate)); }
|
RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
RestTemplateWrapper extends RestTemplate { RestTemplate getRestTemplate(String url) { for (AcceptableRestTemplate template : acceptableRestTemplates) { if (template.isAcceptable(url)) { return template; } } return defaultRestTemplate; } RestTemplateWrapper(); @Override T getForObject(String url, Class<T> responseType, Object... urlVariables); @Override T getForObject(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override T getForObject(URI url, Class<T> responseType); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Object... urlVariables); @Override ResponseEntity<T> getForEntity(String url, Class<T> responseType,
Map<String, ?> urlVariables); @Override ResponseEntity<T> getForEntity(URI url, Class<T> responseType); @Override T postForObject(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override T postForObject(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override T postForObject(URI url, Object request, Class<T> responseType); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Object... uriVariables); @Override ResponseEntity<T> postForEntity(String url, Object request, Class<T> responseType,
Map<String, ?> uriVariables); @Override ResponseEntity<T> postForEntity(URI url, Object request,
Class<T> responseType); @Override void put(String url, Object request, Object... urlVariables); @Override void put(String url, Object request, Map<String, ?> urlVariables); @Override void put(URI url, Object request); @Override void delete(String url, Object... urlVariables); @Override void delete(String url, Map<String, ?> urlVariables); @Override void delete(URI url); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables); @Override ResponseEntity<T> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(RequestEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType); @Override ResponseEntity<T> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType); @Override HttpHeaders headForHeaders(String url, Object... urlVariables); @Override HttpHeaders headForHeaders(String url, Map<String, ?> urlVariables); @Override HttpHeaders headForHeaders(URI url); @Override URI postForLocation(String url, Object request, Object... urlVariables); @Override URI postForLocation(String url, Object request, Map<String, ?> urlVariables); @Override URI postForLocation(URI url, Object request); @Override Set<HttpMethod> optionsForAllow(String url, Object... urlVariables); @Override Set<HttpMethod> optionsForAllow(String url, Map<String, ?> urlVariables); @Override Set<HttpMethod> optionsForAllow(URI url); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables); @Override T execute(String url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables); @Override T execute(URI url, HttpMethod method, RequestCallback requestCallback,
ResponseExtractor<T> responseExtractor); @Override void setInterceptors(List<ClientHttpRequestInterceptor> interceptors); @Override void setRequestFactory(ClientHttpRequestFactory requestFactory); @Override void setErrorHandler(ResponseErrorHandler errorHandler); @Override void setDefaultUriVariables(Map<String, ?> defaultUriVariables); @Override void setUriTemplateHandler(UriTemplateHandler handler); @Override void setMessageConverters(List<HttpMessageConverter<?>> messageConverters); }
|
@Test public void testGetReferenceConfig() { ReferenceConfig value = requestmeta.getReferenceConfig(); Assert.assertNotNull(value); }
|
public ReferenceConfig getReferenceConfig() { return referenceConfig; }
|
RequestMeta { public ReferenceConfig getReferenceConfig() { return referenceConfig; } }
|
RequestMeta { public ReferenceConfig getReferenceConfig() { return referenceConfig; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); }
|
RequestMeta { public ReferenceConfig getReferenceConfig() { return referenceConfig; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
RequestMeta { public ReferenceConfig getReferenceConfig() { return referenceConfig; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
@Test public void testGetPathParams() { Map<String, String> value = requestmeta.getPathParams(); Assert.assertNotNull(value); }
|
public Map<String, String> getPathParams() { return pathParams; }
|
RequestMeta { public Map<String, String> getPathParams() { return pathParams; } }
|
RequestMeta { public Map<String, String> getPathParams() { return pathParams; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); }
|
RequestMeta { public Map<String, String> getPathParams() { return pathParams; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
RequestMeta { public Map<String, String> getPathParams() { return pathParams; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
@Test public void testGetSwaggerRestOperation() { RestOperationMeta value = requestmeta.getSwaggerRestOperation(); Assert.assertNotNull(value); }
|
public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; }
|
RequestMeta { public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; } }
|
RequestMeta { public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); }
|
RequestMeta { public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
RequestMeta { public RestOperationMeta getSwaggerRestOperation() { return swaggerRestOperation; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
@Test public void testGetOperationMeta() { Assert.assertNull(requestmeta.getOperationMeta()); }
|
public OperationMeta getOperationMeta() { return operationMeta; }
|
RequestMeta { public OperationMeta getOperationMeta() { return operationMeta; } }
|
RequestMeta { public OperationMeta getOperationMeta() { return operationMeta; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); }
|
RequestMeta { public OperationMeta getOperationMeta() { return operationMeta; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
RequestMeta { public OperationMeta getOperationMeta() { return operationMeta; } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
@Test public void testGetOperationQualifiedName() { Mockito.when(operationMeta.getSchemaQualifiedName()).thenReturn("value"); String qualifiedName = operationMeta.getSchemaQualifiedName(); Assert.assertEquals("value", qualifiedName); }
|
public String getOperationQualifiedName() { return operationMeta.getSchemaQualifiedName(); }
|
RequestMeta { public String getOperationQualifiedName() { return operationMeta.getSchemaQualifiedName(); } }
|
RequestMeta { public String getOperationQualifiedName() { return operationMeta.getSchemaQualifiedName(); } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); }
|
RequestMeta { public String getOperationQualifiedName() { return operationMeta.getSchemaQualifiedName(); } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
RequestMeta { public String getOperationQualifiedName() { return operationMeta.getSchemaQualifiedName(); } RequestMeta(ReferenceConfig referenceConfig, RestOperationMeta swaggerRestOperation,
Map<String, String> pathParams); ReferenceConfig getReferenceConfig(); Map<String, String> getPathParams(); RestOperationMeta getSwaggerRestOperation(); OperationMeta getOperationMeta(); String getOperationQualifiedName(); }
|
@Test public void testNormal() { CseAsyncClientHttpRequest request = new CseAsyncClientHttpRequest(); CseAsyncRequestCallback<HttpEntity<?>> cb = new CseAsyncRequestCallback<>(null); cb.doWithRequest(request); Assert.assertEquals(null, request.getContext()); }
|
@Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
@Test public void testHttpEntity(@Injectable HttpEntity<String> entity) { CseAsyncRequestCallback<String> cb = new CseAsyncRequestCallback<>(entity); CseAsyncClientHttpRequest request = new CseAsyncClientHttpRequest(); cb.doWithRequest(request); Assert.assertEquals(entity.getBody(), request.getBody()); }
|
@Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
@Test public void find_service_instances() { MicroserviceCache microserviceCache = serviceRegistryCache .findServiceCache(MicroserviceCacheKey.builder().serviceName("svc").appId("app").env("env").build()); Assert.assertEquals(MicroserviceCacheStatus.REFRESHED, microserviceCache.getStatus()); Assert.assertEquals(0, microserviceCache.getInstances().size()); Assert.assertEquals(1, serviceRegistryCache.microserviceCache.size()); Entry<MicroserviceCacheKey, RefreshableMicroserviceCache> cacheEntry = serviceRegistryCache.microserviceCache.entrySet().iterator().next(); Assert.assertEquals(MicroserviceCacheKey.builder().serviceName("svc").appId("app").env("env").build(), cacheEntry.getKey()); }
|
@Override public MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey) { microserviceCacheKey.validate(); RefreshableMicroserviceCache targetCache = microserviceCache .computeIfAbsent(microserviceCacheKey, pk -> { RefreshableMicroserviceCache microserviceCache = createMicroserviceCache(microserviceCacheKey); microserviceCache.refresh(); return microserviceCache; }); removeCacheIfServiceNotFound(targetCache); return targetCache; }
|
RefreshableServiceRegistryCache implements ServiceRegistryCache { @Override public MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey) { microserviceCacheKey.validate(); RefreshableMicroserviceCache targetCache = microserviceCache .computeIfAbsent(microserviceCacheKey, pk -> { RefreshableMicroserviceCache microserviceCache = createMicroserviceCache(microserviceCacheKey); microserviceCache.refresh(); return microserviceCache; }); removeCacheIfServiceNotFound(targetCache); return targetCache; } }
|
RefreshableServiceRegistryCache implements ServiceRegistryCache { @Override public MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey) { microserviceCacheKey.validate(); RefreshableMicroserviceCache targetCache = microserviceCache .computeIfAbsent(microserviceCacheKey, pk -> { RefreshableMicroserviceCache microserviceCache = createMicroserviceCache(microserviceCacheKey); microserviceCache.refresh(); return microserviceCache; }); removeCacheIfServiceNotFound(targetCache); return targetCache; } RefreshableServiceRegistryCache(Microservice consumerService, ServiceRegistryClient srClient); }
|
RefreshableServiceRegistryCache implements ServiceRegistryCache { @Override public MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey) { microserviceCacheKey.validate(); RefreshableMicroserviceCache targetCache = microserviceCache .computeIfAbsent(microserviceCacheKey, pk -> { RefreshableMicroserviceCache microserviceCache = createMicroserviceCache(microserviceCacheKey); microserviceCache.refresh(); return microserviceCache; }); removeCacheIfServiceNotFound(targetCache); return targetCache; } RefreshableServiceRegistryCache(Microservice consumerService, ServiceRegistryClient srClient); void refreshCache(); void forceRefreshCache(); @Override MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey); RefreshableServiceRegistryCache setEmptyInstanceProtectionEnabled(boolean emptyInstanceProtectionEnabled); @Override ServiceRegistryCache setCacheRefreshedWatcher(
Consumer<List<MicroserviceCache>> cacheRefreshedWatcher); void onMicroserviceInstanceChanged(MicroserviceInstanceChangedEvent event); void onSafeModeChanged(SafeModeChangeEvent modeChangeEvent); @Override Map<MicroserviceCacheKey, MicroserviceCache> getMicroserviceCaches(); }
|
RefreshableServiceRegistryCache implements ServiceRegistryCache { @Override public MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey) { microserviceCacheKey.validate(); RefreshableMicroserviceCache targetCache = microserviceCache .computeIfAbsent(microserviceCacheKey, pk -> { RefreshableMicroserviceCache microserviceCache = createMicroserviceCache(microserviceCacheKey); microserviceCache.refresh(); return microserviceCache; }); removeCacheIfServiceNotFound(targetCache); return targetCache; } RefreshableServiceRegistryCache(Microservice consumerService, ServiceRegistryClient srClient); void refreshCache(); void forceRefreshCache(); @Override MicroserviceCache findServiceCache(MicroserviceCacheKey microserviceCacheKey); RefreshableServiceRegistryCache setEmptyInstanceProtectionEnabled(boolean emptyInstanceProtectionEnabled); @Override ServiceRegistryCache setCacheRefreshedWatcher(
Consumer<List<MicroserviceCache>> cacheRefreshedWatcher); void onMicroserviceInstanceChanged(MicroserviceInstanceChangedEvent event); void onSafeModeChanged(SafeModeChangeEvent modeChangeEvent); @Override Map<MicroserviceCacheKey, MicroserviceCache> getMicroserviceCaches(); }
|
@Test public void testCseEntity(@Injectable CseHttpEntity<String> entity) { CseAsyncClientHttpRequest request = new CseAsyncClientHttpRequest(); entity.addContext("c1", "c2"); CseAsyncRequestCallback<String> cb = new CseAsyncRequestCallback<>(entity); cb.doWithRequest(request); Assert.assertEquals(entity.getContext(), request.getContext()); }
|
@Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
CseAsyncRequestCallback implements org.springframework.web.client.AsyncRequestCallback { @Override @SuppressWarnings("deprecation") public void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request) { CseAsyncClientHttpRequest cseAsyncClientHttpRequest = (CseAsyncClientHttpRequest) request; if (requestBody != null) { cseAsyncClientHttpRequest.setRequestBody(requestBody.getBody()); cseAsyncClientHttpRequest.setHttpHeaders(requestBody.getHeaders()); } if (!CseHttpEntity.class.isInstance(requestBody)) { return; } CseAsyncClientHttpRequest req = (CseAsyncClientHttpRequest) request; CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody; req.setContext(entity.getContext()); } CseAsyncRequestCallback(HttpEntity<T> requestBody); @Override @SuppressWarnings("deprecation") // TODO : upgrade to spring 5 will having warning's , we'll fix it later void doWithRequest(org.springframework.http.client.AsyncClientHttpRequest request); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.