Spring/spring-boot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch '1.5.x'

Browse Source
This commit is contained in:
Phillip Webb
2017-07-24 13:02:12 -07:00
parent 2ae39fce8a dca463c7d9
commit 7b2b8dc4a3
9 changed files with 170 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/ImportAutoConfiguration.java
View File

@@ -46,7 +46,6 @@ import org.springframework.core.annotation.AliasFor;
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(ImportAutoConfigurationImportSelector.class)
public @interface ImportAutoConfiguration {

20
spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQConnectionFactoryConfiguration.java
View File

@@ -49,8 +49,8 @@ class ActiveMQConnectionFactoryConfiguration {
public ActiveMQConnectionFactory jmsConnectionFactory(ActiveMQProperties properties,
ObjectProvider<List<ActiveMQConnectionFactoryCustomizer>> factoryCustomizers) {
return new ActiveMQConnectionFactoryFactory(properties,
factoryCustomizers.getIfAvailable()).createConnectionFactory(
ActiveMQConnectionFactory.class);
factoryCustomizers.getIfAvailable())
.createConnectionFactory(ActiveMQConnectionFactory.class);
}
@ConditionalOnClass(PooledConnectionFactory.class)
@@ -67,21 +67,21 @@ class ActiveMQConnectionFactoryConfiguration {
ActiveMQConnectionFactory.class));
ActiveMQProperties.Pool pool = properties.getPool();
pooledConnectionFactory.setBlockIfSessionPoolIsFull(pool.isBlockIfFull());
pooledConnectionFactory.setBlockIfSessionPoolIsFullTimeout(
pool.getBlockIfFullTimeout());
pooledConnectionFactory.setCreateConnectionOnStartup(
pool.isCreateConnectionOnStartup());
pooledConnectionFactory
.setBlockIfSessionPoolIsFullTimeout(pool.getBlockIfFullTimeout());
pooledConnectionFactory
.setCreateConnectionOnStartup(pool.isCreateConnectionOnStartup());
pooledConnectionFactory.setExpiryTimeout(pool.getExpiryTimeout());
pooledConnectionFactory.setIdleTimeout(pool.getIdleTimeout());
pooledConnectionFactory.setMaxConnections(pool.getMaxConnections());
pooledConnectionFactory.setMaximumActiveSessionPerConnection(
pool.getMaximumActiveSessionPerConnection());
pooledConnectionFactory.setReconnectOnException(
pool.isReconnectOnException());
pooledConnectionFactory
.setReconnectOnException(pool.isReconnectOnException());
pooledConnectionFactory.setTimeBetweenExpirationCheckMillis(
pool.getTimeBetweenExpirationCheck());
pooledConnectionFactory.setUseAnonymousProducers(
pool.isUseAnonymousProducers());
pooledConnectionFactory
.setUseAnonymousProducers(pool.isUseAnonymousProducers());
return pooledConnectionFactory;
}

7
spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java
View File

@@ -158,8 +158,8 @@ public class ActiveMQProperties {
private boolean blockIfFull = true;
/**
* Blocking period, in milliseconds, before throwing an exception if the pool
* is still full.
* Blocking period, in milliseconds, before throwing an exception if the pool is
* still full.
*/
private long blockIfFullTimeout = -1;
@@ -265,7 +265,8 @@ public class ActiveMQProperties {
return this.maximumActiveSessionPerConnection;
}
public void setMaximumActiveSessionPerConnection(int maximumActiveSessionPerConnection) {
public void setMaximumActiveSessionPerConnection(
int maximumActiveSessionPerConnection) {
this.maximumActiveSessionPerConnection = maximumActiveSessionPerConnection;
}

6
spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQXAConnectionFactoryConfiguration.java
View File

@@ -54,7 +54,7 @@ class ActiveMQXAConnectionFactoryConfiguration {
XAConnectionFactoryWrapper wrapper) throws Exception {
ActiveMQXAConnectionFactory connectionFactory = new ActiveMQConnectionFactoryFactory(
properties, factoryCustomizers.getIfAvailable())
.createConnectionFactory(ActiveMQXAConnectionFactory.class);
.createConnectionFactory(ActiveMQXAConnectionFactory.class);
return wrapper.wrapConnectionFactory(connectionFactory);
}
@@ -64,8 +64,8 @@ class ActiveMQXAConnectionFactoryConfiguration {
ActiveMQProperties properties,
ObjectProvider<List<ActiveMQConnectionFactoryCustomizer>> factoryCustomizers) {
return new ActiveMQConnectionFactoryFactory(properties,
factoryCustomizers.getIfAvailable()).createConnectionFactory(
ActiveMQConnectionFactory.class);
factoryCustomizers.getIfAvailable())
.createConnectionFactory(ActiveMQConnectionFactory.class);
}
}

15
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/ImportAutoConfigurationImportSelectorTests.java
View File

@@ -37,6 +37,7 @@ import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.util.ClassUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verifyZeroInteractions;
@@ -125,7 +126,6 @@ public class ImportAutoConfigurationImportSelectorTests {
public void exclusionsAliasesAreApplied() throws Exception {
AnnotationMetadata annotationMetadata = getAnnotationMetadata(
ImportWithSelfAnnotatingAnnotationExclude.class);
String[] imports = this.importSelector.selectImports(annotationMetadata);
assertThat(imports).isEmpty();
}
@@ -182,6 +182,19 @@ public class ImportAutoConfigurationImportSelectorTests {
assertThat(set1).isNotEqualTo(set2);
}
@Test
public void determineImportsShouldNotSetPackageImport() throws Exception {
Class<?> packageImportClass = ClassUtils.resolveClassName(
"org.springframework.boot.autoconfigure.AutoConfigurationPackages.PackageImport",
null);
Set<Object> selectedImports = this.importSelector
.determineImports(getAnnotationMetadata(
ImportMetaAutoConfigurationExcludeWithUnrelatedOne.class));
for (Object selectedImport : selectedImports) {
assertThat(selectedImport).isNotInstanceOf(packageImportClass);
}
}
private AnnotationMetadata getAnnotationMetadata(Class<?> source) throws IOException {
return new SimpleMetadataReaderFactory().getMetadataReader(source.getName())
.getAnnotationMetadata();

199
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQAutoConfigurationTests.java
View File

@@ -67,116 +67,131 @@ public class ActiveMQAutoConfigurationTests {
@Test
public void defaultsConnectionFactoryAreApplied() {
this.context.withUserConfiguration(EmptyConfiguration.class)
.withPropertyValues("spring.activemq.pool.enabled=false").run((loaded) -> {
assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class)).hasSize(1);
ActiveMQConnectionFactory connectionFactory = loaded.getBean(
ActiveMQConnectionFactory.class);
ActiveMQConnectionFactory defaultFactory = new ActiveMQConnectionFactory(
"vm://localhost?broker.persistent=false");
assertThat(connectionFactory.getUserName()).isEqualTo(
defaultFactory.getUserName());
assertThat(connectionFactory.getPassword()).isEqualTo(
defaultFactory.getPassword());
assertThat(connectionFactory.getCloseTimeout()).isEqualTo(
defaultFactory.getCloseTimeout());
assertThat(connectionFactory.isNonBlockingRedelivery()).isEqualTo(
defaultFactory.isNonBlockingRedelivery());
assertThat(connectionFactory.getSendTimeout()).isEqualTo(
defaultFactory.getSendTimeout());
assertThat(connectionFactory.isTrustAllPackages()).isEqualTo(
defaultFactory.isTrustAllPackages());
assertThat(connectionFactory.getTrustedPackages()).containsExactly(
defaultFactory.getTrustedPackages().toArray(new String[] {}));
});
.withPropertyValues("spring.activemq.pool.enabled=false")
.run((loaded) -> {
assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class))
.hasSize(1);
ActiveMQConnectionFactory connectionFactory = loaded
.getBean(ActiveMQConnectionFactory.class);
ActiveMQConnectionFactory defaultFactory = new ActiveMQConnectionFactory(
"vm://localhost?broker.persistent=false");
assertThat(connectionFactory.getUserName())
.isEqualTo(defaultFactory.getUserName());
assertThat(connectionFactory.getPassword())
.isEqualTo(defaultFactory.getPassword());
assertThat(connectionFactory.getCloseTimeout())
.isEqualTo(defaultFactory.getCloseTimeout());
assertThat(connectionFactory.isNonBlockingRedelivery())
.isEqualTo(defaultFactory.isNonBlockingRedelivery());
assertThat(connectionFactory.getSendTimeout())
.isEqualTo(defaultFactory.getSendTimeout());
assertThat(connectionFactory.isTrustAllPackages())
.isEqualTo(defaultFactory.isTrustAllPackages());
assertThat(connectionFactory.getTrustedPackages()).containsExactly(
defaultFactory.getTrustedPackages().toArray(new String[] {}));
});
}
@Test
public void customConnectionFactoryAreApplied() {
this.context.withUserConfiguration(EmptyConfiguration.class)
.withPropertyValues("spring.activemq.pool.enabled=false",
"spring.activemq.brokerUrl=vm://localhost?useJmx=false&broker.persistent=false",
"spring.activemq.user=foo",
"spring.activemq.password=bar",
"spring.activemq.closeTimeout=500",
"spring.activemq.nonBlockingRedelivery=true",
"spring.activemq.sendTimeout=1000",
"spring.activemq.packages.trust-all=false",
"spring.activemq.packages.trusted=com.example.acme").run((loaded) -> {
assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class)).hasSize(1);
ActiveMQConnectionFactory connectionFactory = loaded.getBean(
ActiveMQConnectionFactory.class);
assertThat(connectionFactory.getUserName()).isEqualTo("foo");
assertThat(connectionFactory.getPassword()).isEqualTo("bar");
assertThat(connectionFactory.getCloseTimeout()).isEqualTo(500);
assertThat(connectionFactory.isNonBlockingRedelivery()).isEqualTo(true);
assertThat(connectionFactory.getSendTimeout()).isEqualTo(1000);
assertThat(connectionFactory.isTrustAllPackages()).isFalse();
assertThat(connectionFactory.getTrustedPackages()).containsExactly(
"com.example.acme");
});
"spring.activemq.brokerUrl=vm://localhost?useJmx=false&broker.persistent=false",
"spring.activemq.user=foo", "spring.activemq.password=bar",
"spring.activemq.closeTimeout=500",
"spring.activemq.nonBlockingRedelivery=true",
"spring.activemq.sendTimeout=1000",
"spring.activemq.packages.trust-all=false",
"spring.activemq.packages.trusted=com.example.acme")
.run((loaded) -> {
assertThat(loaded.getBeansOfType(ActiveMQConnectionFactory.class))
.hasSize(1);
ActiveMQConnectionFactory connectionFactory = loaded
.getBean(ActiveMQConnectionFactory.class);
assertThat(connectionFactory.getUserName()).isEqualTo("foo");
assertThat(connectionFactory.getPassword()).isEqualTo("bar");
assertThat(connectionFactory.getCloseTimeout()).isEqualTo(500);
assertThat(connectionFactory.isNonBlockingRedelivery())
.isEqualTo(true);
assertThat(connectionFactory.getSendTimeout()).isEqualTo(1000);
assertThat(connectionFactory.isTrustAllPackages()).isFalse();
assertThat(connectionFactory.getTrustedPackages())
.containsExactly("com.example.acme");
});
}
@Test
public void defaultsPooledConnectionFactoryAreApplied() {
this.context.withUserConfiguration(EmptyConfiguration.class)
.withPropertyValues("spring.activemq.pool.enabled=true").run((loaded) -> {
assertThat(loaded.getBeansOfType(PooledConnectionFactory.class)).hasSize(1);
PooledConnectionFactory connectionFactory = loaded.getBean(
PooledConnectionFactory.class);
PooledConnectionFactory defaultFactory = new PooledConnectionFactory();
assertThat(connectionFactory.isBlockIfSessionPoolIsFull()).isEqualTo(
defaultFactory.isBlockIfSessionPoolIsFull());
assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout()).isEqualTo(
defaultFactory.getBlockIfSessionPoolIsFullTimeout());
assertThat(connectionFactory.isCreateConnectionOnStartup()).isEqualTo(
defaultFactory.isCreateConnectionOnStartup());
assertThat(connectionFactory.getExpiryTimeout()).isEqualTo(
defaultFactory.getExpiryTimeout());
assertThat(connectionFactory.getIdleTimeout()).isEqualTo(
defaultFactory.getIdleTimeout());
assertThat(connectionFactory.getMaxConnections()).isEqualTo(
defaultFactory.getMaxConnections());
assertThat(connectionFactory.getMaximumActiveSessionPerConnection()).isEqualTo(
defaultFactory.getMaximumActiveSessionPerConnection());
assertThat(connectionFactory.isReconnectOnException()).isEqualTo(
defaultFactory.isReconnectOnException());
assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis()).isEqualTo(
defaultFactory.getTimeBetweenExpirationCheckMillis());
assertThat(connectionFactory.isUseAnonymousProducers()).isEqualTo(
defaultFactory.isUseAnonymousProducers());
});
assertThat(loaded.getBeansOfType(PooledConnectionFactory.class))
.hasSize(1);
PooledConnectionFactory connectionFactory = loaded
.getBean(PooledConnectionFactory.class);
PooledConnectionFactory defaultFactory = new PooledConnectionFactory();
assertThat(connectionFactory.isBlockIfSessionPoolIsFull())
.isEqualTo(defaultFactory.isBlockIfSessionPoolIsFull());
assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout())
.isEqualTo(
defaultFactory.getBlockIfSessionPoolIsFullTimeout());
assertThat(connectionFactory.isCreateConnectionOnStartup())
.isEqualTo(defaultFactory.isCreateConnectionOnStartup());
assertThat(connectionFactory.getExpiryTimeout())
.isEqualTo(defaultFactory.getExpiryTimeout());
assertThat(connectionFactory.getIdleTimeout())
.isEqualTo(defaultFactory.getIdleTimeout());
assertThat(connectionFactory.getMaxConnections())
.isEqualTo(defaultFactory.getMaxConnections());
assertThat(connectionFactory.getMaximumActiveSessionPerConnection())
.isEqualTo(defaultFactory
.getMaximumActiveSessionPerConnection());
assertThat(connectionFactory.isReconnectOnException())
.isEqualTo(defaultFactory.isReconnectOnException());
assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis())
.isEqualTo(
defaultFactory.getTimeBetweenExpirationCheckMillis());
assertThat(connectionFactory.isUseAnonymousProducers())
.isEqualTo(defaultFactory.isUseAnonymousProducers());
});
}
@Test
public void customPooledConnectionFactoryAreApplied() {
this.context.withUserConfiguration(EmptyConfiguration.class)
.withPropertyValues("spring.activemq.pool.enabled=true",
"spring.activemq.pool.blockIfFull=false",
"spring.activemq.pool.blockIfFullTimeout=64",
"spring.activemq.pool.createConnectionOnStartup=false",
"spring.activemq.pool.expiryTimeout=4096",
"spring.activemq.pool.idleTimeout=512",
"spring.activemq.pool.maxConnections=256",
"spring.activemq.pool.maximumActiveSessionPerConnection=1024",
"spring.activemq.pool.reconnectOnException=false",
"spring.activemq.pool.timeBetweenExpirationCheck=2048",
"spring.activemq.pool.useAnonymousProducers=false").run((loaded) -> {
assertThat(loaded.getBeansOfType(PooledConnectionFactory.class)).hasSize(1);
PooledConnectionFactory connectionFactory = loaded.getBean(
PooledConnectionFactory.class);
assertThat(connectionFactory.isBlockIfSessionPoolIsFull()).isEqualTo(false);
assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout()).isEqualTo(64);
assertThat(connectionFactory.isCreateConnectionOnStartup()).isEqualTo(false);
assertThat(connectionFactory.getExpiryTimeout()).isEqualTo(4096);
assertThat(connectionFactory.getIdleTimeout()).isEqualTo(512);
assertThat(connectionFactory.getMaxConnections()).isEqualTo(256);
assertThat(connectionFactory.getMaximumActiveSessionPerConnection())
.isEqualTo(1024);
assertThat(connectionFactory.isReconnectOnException()).isEqualTo(false);
assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis())
.isEqualTo(2048);
assertThat(connectionFactory.isUseAnonymousProducers()).isEqualTo(false);
});
"spring.activemq.pool.blockIfFull=false",
"spring.activemq.pool.blockIfFullTimeout=64",
"spring.activemq.pool.createConnectionOnStartup=false",
"spring.activemq.pool.expiryTimeout=4096",
"spring.activemq.pool.idleTimeout=512",
"spring.activemq.pool.maxConnections=256",
"spring.activemq.pool.maximumActiveSessionPerConnection=1024",
"spring.activemq.pool.reconnectOnException=false",
"spring.activemq.pool.timeBetweenExpirationCheck=2048",
"spring.activemq.pool.useAnonymousProducers=false")
.run((loaded) -> {
assertThat(loaded.getBeansOfType(PooledConnectionFactory.class))
.hasSize(1);
PooledConnectionFactory connectionFactory = loaded
.getBean(PooledConnectionFactory.class);
assertThat(connectionFactory.isBlockIfSessionPoolIsFull())
.isEqualTo(false);
assertThat(connectionFactory.getBlockIfSessionPoolIsFullTimeout())
.isEqualTo(64);
assertThat(connectionFactory.isCreateConnectionOnStartup())
.isEqualTo(false);
assertThat(connectionFactory.getExpiryTimeout()).isEqualTo(4096);
assertThat(connectionFactory.getIdleTimeout()).isEqualTo(512);
assertThat(connectionFactory.getMaxConnections()).isEqualTo(256);
assertThat(connectionFactory.getMaximumActiveSessionPerConnection())
.isEqualTo(1024);
assertThat(connectionFactory.isReconnectOnException())
.isEqualTo(false);
assertThat(connectionFactory.getTimeBetweenExpirationCheckMillis())
.isEqualTo(2048);
assertThat(connectionFactory.isUseAnonymousProducers())
.isEqualTo(false);
});
}
@Test

24
spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQPropertiesTests.java
View File

@@ -40,37 +40,38 @@ public class ActiveMQPropertiesTests {
@Test
public void getBrokerUrlIsInMemoryByDefault() {
assertThat(createFactory(this.properties).determineBrokerUrl()).isEqualTo(
DEFAULT_EMBEDDED_BROKER_URL);
assertThat(createFactory(this.properties).determineBrokerUrl())
.isEqualTo(DEFAULT_EMBEDDED_BROKER_URL);
}
@Test
public void getBrokerUrlUseExplicitBrokerUrl() {
this.properties.setBrokerUrl("vm://foo-bar");
assertThat(createFactory(this.properties).determineBrokerUrl()).isEqualTo(
"vm://foo-bar");
assertThat(createFactory(this.properties).determineBrokerUrl())
.isEqualTo("vm://foo-bar");
}
@Test
public void getBrokerUrlWithInMemorySetToFalse() {
this.properties.setInMemory(false);
assertThat(createFactory(this.properties).determineBrokerUrl()).isEqualTo(
DEFAULT_NETWORK_BROKER_URL);
assertThat(createFactory(this.properties).determineBrokerUrl())
.isEqualTo(DEFAULT_NETWORK_BROKER_URL);
}
@Test
public void getExplicitBrokerUrlAlwaysWins() {
this.properties.setBrokerUrl("vm://foo-bar");
this.properties.setInMemory(false);
assertThat(createFactory(this.properties).determineBrokerUrl()).isEqualTo(
"vm://foo-bar");
assertThat(createFactory(this.properties).determineBrokerUrl())
.isEqualTo("vm://foo-bar");
}
@Test
public void setTrustAllPackages() {
this.properties.getPackages().setTrustAll(true);
assertThat(createFactory(this.properties).createConnectionFactory(
ActiveMQConnectionFactory.class).isTrustAllPackages()).isEqualTo(true);
assertThat(createFactory(this.properties)
.createConnectionFactory(ActiveMQConnectionFactory.class)
.isTrustAllPackages()).isEqualTo(true);
}
@Test
@@ -84,7 +85,8 @@ public class ActiveMQPropertiesTests {
assertThat(factory.getTrustedPackages().get(0)).isEqualTo("trusted.package");
}
private ActiveMQConnectionFactoryFactory createFactory(ActiveMQProperties properties) {
private ActiveMQConnectionFactoryFactory createFactory(
ActiveMQProperties properties) {
return new ActiveMQConnectionFactoryFactory(properties,
Collections.<ActiveMQConnectionFactoryCustomizer>emptyList());
}

8
spring-boot-test-autoconfigure/src/test/java/org/springframework/boot/test/autoconfigure/cache/ImportsContextCustomizerFactoryWithAutoConfigurationTests.java vendored
View File

@@ -24,6 +24,7 @@ import org.junit.runner.notification.RunNotifier;
import org.junit.runners.model.InitializationError;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigurationPackage;
import org.springframework.boot.autoconfigure.ImportAutoConfiguration;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
@@ -94,8 +95,8 @@ public class ImportsContextCustomizerFactoryWithAutoConfigurationTests {
}
@ContextConfiguration(classes = EmptyConfig.class)
@DataJpaTest
@ContextConfiguration(classes = EmptyConfig.class)
@Unrelated2
public static class DataJpaTest2 {
@@ -109,8 +110,8 @@ public class ImportsContextCustomizerFactoryWithAutoConfigurationTests {
}
@ContextConfiguration(classes = EmptyConfig.class)
@DataJpaTest
@ContextConfiguration(classes = EmptyConfig.class)
@Unrelated1
public static class DataJpaTest3 {
@@ -124,8 +125,8 @@ public class ImportsContextCustomizerFactoryWithAutoConfigurationTests {
}
@ContextConfiguration(classes = EmptyConfig.class)
@DataJpaTest(showSql = false)
@ContextConfiguration(classes = EmptyConfig.class)
@Unrelated1
public static class DataJpaTest4 {
@@ -151,6 +152,7 @@ public class ImportsContextCustomizerFactoryWithAutoConfigurationTests {
@Configuration
@EntityScan(basePackageClasses = ExampleEntity.class)
@AutoConfigurationPackage
static class EmptyConfig {
}

18
spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/jar/Handler.java
View File

@@ -71,8 +71,6 @@ public class Handler extends URLStreamHandler {
rootFileCache = new SoftReference<>(null);
}
private final Logger logger = Logger.getLogger(getClass().getName());
private final JarFile jarFile;
private URLStreamHandler fallbackHandler;
@@ -105,10 +103,10 @@ public class Handler extends URLStreamHandler {
}
catch (Exception ex) {
if (reason instanceof IOException) {
this.logger.log(Level.FINEST, "Unable to open fallback handler", ex);
log(false, "Unable to open fallback handler", ex);
throw (IOException) reason;
}
this.logger.log(Level.WARNING, "Unable to open fallback handler", ex);
log(true, "Unable to open fallback handler", ex);
if (reason instanceof RuntimeException) {
throw (RuntimeException) reason;
}
@@ -116,6 +114,18 @@ public class Handler extends URLStreamHandler {
}
}
private void log(boolean warning, String message, Exception cause) {
try {
Logger.getLogger(getClass().getName())
.log((warning ? Level.WARNING : Level.FINEST), message, cause);
}
catch (Exception ex) {
if (warning) {
System.err.println("WARNING: " + message);
}
}
}
private URLStreamHandler getFallbackHandler() {
if (this.fallbackHandler != null) {
return this.fallbackHandler;