root
/
spring-boot
mirror of https://github.com/spring-projects/spring-boot.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch '2.0.x'

This commit is contained in:
Stephane Nicoll 2018-11-26 10:35:37 +01:00
parent ee2107c91b 5f0ac46d78
commit ae1979f1ff
6 changed files with 328 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceJmxConfiguration.java
View File

@ -31,6 +31,7 @@ import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.jdbc.DataSourceUnwrapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jmx.export.MBeanExporter;
@ -62,22 +63,14 @@ class DataSourceJmxConfiguration {
@PostConstruct
public void validateMBeans() {
HikariDataSource hikariDataSource = unwrapHikariDataSource();
HikariDataSource hikariDataSource = DataSourceUnwrapper
.unwrap(this.dataSource, HikariDataSource.class);
if (hikariDataSource != null && hikariDataSource.isRegisterMbeans()) {
this.mBeanExporter
.ifUnique((exporter) -> exporter.addExcludedBean("dataSource"));
}
}
private HikariDataSource unwrapHikariDataSource() {
try {
return this.dataSource.unwrap(HikariDataSource.class);
}
catch (SQLException ex) {
return null;
}
}
}
@Configuration
@ -89,9 +82,11 @@ class DataSourceJmxConfiguration {
@Bean
@ConditionalOnMissingBean(name = "dataSourceMBean")
public Object dataSourceMBean(DataSource dataSource) {
if (dataSource instanceof DataSourceProxy) {
DataSourceProxy dataSourceProxy = DataSourceUnwrapper.unwrap(dataSource,
DataSourceProxy.class);
if (dataSourceProxy != null) {
try {
return ((DataSourceProxy) dataSource).createPool().getJmxPool();
return dataSourceProxy.createPool().getJmxPool();
}
catch (SQLException ex) {
logger.warn("Cannot expose DataSource to JMX (could not connect)");

24
spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/metadata/DataSourcePoolMetadataProvidersConfiguration.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012-2017 the original author or authors.
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -20,6 +20,7 @@ import com.zaxxer.hikari.HikariDataSource;
import org.apache.commons.dbcp2.BasicDataSource;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.jdbc.DataSourceUnwrapper;
import org.springframework.boot.jdbc.metadata.CommonsDbcp2DataSourcePoolMetadata;
import org.springframework.boot.jdbc.metadata.DataSourcePoolMetadataProvider;
import org.springframework.boot.jdbc.metadata.HikariDataSourcePoolMetadata;
@ -44,9 +45,10 @@ public class DataSourcePoolMetadataProvidersConfiguration {
@Bean
public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() {
return (dataSource) -> {
if (dataSource instanceof org.apache.tomcat.jdbc.pool.DataSource) {
return new TomcatDataSourcePoolMetadata(
(org.apache.tomcat.jdbc.pool.DataSource) dataSource);
org.apache.tomcat.jdbc.pool.DataSource tomcatDataSource = DataSourceUnwrapper
.unwrap(dataSource, org.apache.tomcat.jdbc.pool.DataSource.class);
if (tomcatDataSource != null) {
return new TomcatDataSourcePoolMetadata(tomcatDataSource);
}
return null;
};
@ -61,9 +63,10 @@ public class DataSourcePoolMetadataProvidersConfiguration {
@Bean
public DataSourcePoolMetadataProvider hikariPoolDataSourceMetadataProvider() {
return (dataSource) -> {
if (dataSource instanceof HikariDataSource) {
return new HikariDataSourcePoolMetadata(
(HikariDataSource) dataSource);
HikariDataSource hikariDataSource = DataSourceUnwrapper.unwrap(dataSource,
HikariDataSource.class);
if (hikariDataSource != null) {
return new HikariDataSourcePoolMetadata(hikariDataSource);
}
return null;
};
@ -78,9 +81,10 @@ public class DataSourcePoolMetadataProvidersConfiguration {
@Bean
public DataSourcePoolMetadataProvider commonsDbcp2PoolDataSourceMetadataProvider() {
return (dataSource) -> {
if (dataSource instanceof BasicDataSource) {
return new CommonsDbcp2DataSourcePoolMetadata(
(BasicDataSource) dataSource);
BasicDataSource dbcpDataSource = DataSourceUnwrapper.unwrap(dataSource,
BasicDataSource.class);
if (dbcpDataSource != null) {
return new CommonsDbcp2DataSourcePoolMetadata(dbcpDataSource);
}
return null;
};

50
spring-boot-project/spring-boot-autoconfigure/src/test/java/org/springframework/boot/autoconfigure/jdbc/DataSourceJmxConfigurationTests.java
View File

@ -38,6 +38,7 @@ import org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DelegatingDataSource;
import static org.assertj.core.api.Assertions.assertThat;
@ -45,6 +46,7 @@ import static org.assertj.core.api.Assertions.assertThat;
* Tests for {@link DataSourceJmxConfiguration}.
*
* @author Stephane Nicoll
* @author Tadaya Tsuyukubo
*/
public class DataSourceJmxConfigurationTests {
@ -155,6 +157,7 @@ public class DataSourceJmxConfigurationTests {
this.contextRunner.withPropertyValues(
"spring.datasource.type=" + DataSource.class.getName(),
"spring.datasource.jmx-enabled=true").run((context) -> {
assertThat(context).hasBean("dataSourceMBean");
assertThat(context).hasSingleBean(ConnectionPool.class);
assertThat(context.getBean(DataSourceProxy.class).createPool()
.getJmxPool())
@ -162,6 +165,32 @@ public class DataSourceJmxConfigurationTests {
});
}
@Test
public void tomcatProxiedCanExposeMBeanPool() {
this.contextRunner.withUserConfiguration(DataSourceProxyConfiguration.class)
.withPropertyValues(
"spring.datasource.type=" + DataSource.class.getName(),
"spring.datasource.jmx-enabled=true")
.run((context) -> {
assertThat(context).hasBean("dataSourceMBean");
assertThat(context).getBean("dataSourceMBean")
.isInstanceOf(ConnectionPool.class);
});
}
@Test
public void tomcatDelegateCanExposeMBeanPool() {
this.contextRunner.withUserConfiguration(DataSourceDelegateConfiguration.class)
.withPropertyValues(
"spring.datasource.type=" + DataSource.class.getName(),
"spring.datasource.jmx-enabled=true")
.run((context) -> {
assertThat(context).hasBean("dataSourceMBean");
assertThat(context).getBean("dataSourceMBean")
.isInstanceOf(ConnectionPool.class);
});
}
@Configuration
static class DataSourceProxyConfiguration {
@ -177,13 +206,28 @@ public class DataSourceJmxConfigurationTests {
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof javax.sql.DataSource) {
return wrap((javax.sql.DataSource) bean);
return new ProxyFactory(bean).getProxy();
}
return bean;
}
private static javax.sql.DataSource wrap(javax.sql.DataSource dataSource) {
return (javax.sql.DataSource) new ProxyFactory(dataSource).getProxy();
}
@Configuration
static class DataSourceDelegateConfiguration {
@Bean
public static DataSourceBeanPostProcessor dataSourceBeanPostProcessor() {
return new DataSourceBeanPostProcessor() {
@Override
public Object postProcessAfterInitialization(Object bean,
String beanName) {
if (bean instanceof javax.sql.DataSource) {
return new DelegatingDataSource((javax.sql.DataSource) bean);
}
return bean;
}
};
}
}

97
spring-boot-project/spring-boot/src/main/java/org/springframework/boot/jdbc/DataSourceUnwrapper.java Normal file
View File

@ -0,0 +1,97 @@
/*
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.jdbc;
import java.sql.Wrapper;
import javax.sql.DataSource;
import org.springframework.aop.framework.AopProxyUtils;
import org.springframework.aop.support.AopUtils;
import org.springframework.jdbc.datasource.DelegatingDataSource;
import org.springframework.util.ClassUtils;
/**
* Unwraps a {@link DataSource} that may have been proxied or wrapped in a custom
* {@link Wrapper} such as {@link DelegatingDataSource}.
*
* @author Tadaya Tsuyukubo
* @author Stephane Nicoll
* @since 2.0.7
*/
public final class DataSourceUnwrapper {
private static final boolean DELEGATING_DATA_SOURCE_PRESENT = ClassUtils.isPresent(
"org.springframework.jdbc.datasource.DelegatingDataSource",
DataSourceUnwrapper.class.getClassLoader());
private DataSourceUnwrapper() {
}
/**
* Return an object that implements the given {@code target} type, unwrapping delegate
* or proxy if necessary.
* @param dataSource the datasource to handle
* @param target the type that the result must implement
* @param <T> the target type
* @return an object that implements the target type or {@code null}
*/
public static <T> T unwrap(DataSource dataSource, Class<T> target) {
if (target.isInstance(dataSource)) {
return target.cast(dataSource);
}
T unwrapped = safeUnwrap(dataSource, target);
if (unwrapped != null) {
return unwrapped;
}
if (DELEGATING_DATA_SOURCE_PRESENT) {
DataSource targetDataSource = DelegatingDataSourceUnwrapper
.getTargetDataSource(dataSource);
if (targetDataSource != null) {
return unwrap(targetDataSource, target);
}
}
if (AopUtils.isAopProxy(dataSource)) {
Object proxyTarget = AopProxyUtils.getSingletonTarget(dataSource);
if (proxyTarget instanceof DataSource) {
return unwrap((DataSource) proxyTarget, target);
}
}
return null;
}
private static <S> S safeUnwrap(Wrapper wrapper, Class<S> target) {
try {
return wrapper.unwrap(target);
}
catch (Exception ex) {
return null;
}
}
private static class DelegatingDataSourceUnwrapper {
private static DataSource getTargetDataSource(DataSource dataSource) {
if (dataSource instanceof DelegatingDataSource) {
return ((DelegatingDataSource) dataSource).getTargetDataSource();
}
return null;
}
}
}

61
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/jdbc/DataSourceUnwrapperNoSpringJdbcTests.java Normal file
View File

@ -0,0 +1,61 @@
/*
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.jdbc;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.tomcat.jdbc.pool.DataSourceProxy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.boot.testsupport.runner.classpath.ClassPathExclusions;
import org.springframework.boot.testsupport.runner.classpath.ModifiedClassPathRunner;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for {@link DataSourceUnwrapper} when spring-jdbc is not available.
*
* @author Stephane Nicoll
*/
@RunWith(ModifiedClassPathRunner.class)
@ClassPathExclusions("spring-jdbc-*.jar")
public class DataSourceUnwrapperNoSpringJdbcTests {
@Test
public void unwrapWithProxy() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInProxy(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapDataSourceProxy() {
org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
DataSource actual = wrapInProxy(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, DataSourceProxy.class))
.isSameAs(dataSource);
}
private DataSource wrapInProxy(DataSource dataSource) {
return (DataSource) new ProxyFactory(dataSource).getProxy();
}
}

102
spring-boot-project/spring-boot/src/test/java/org/springframework/boot/jdbc/DataSourceUnwrapperTests.java Normal file
View File

@ -0,0 +1,102 @@
/*
* Copyright 2012-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.boot.jdbc;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
import org.apache.tomcat.jdbc.pool.DataSourceProxy;
import org.junit.Test;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.jdbc.datasource.DelegatingDataSource;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link DataSourceUnwrapper}.
*
* @author Stephane Nicoll
*/
public class DataSourceUnwrapperTests {
@Test
public void unwrapWithTarget() {
DataSource dataSource = new HikariDataSource();
assertThat(DataSourceUnwrapper.unwrap(dataSource, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapWithWrongTarget() {
DataSource dataSource = new HikariDataSource();
assertThat(
DataSourceUnwrapper.unwrap(dataSource, SingleConnectionDataSource.class))
.isNull();
}
@Test
public void unwrapWithDelegate() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInDelegate(wrapInDelegate(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapWithProxy() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInProxy(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapWithProxyAndDelegate() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInProxy(wrapInDelegate(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapWithSeveralLevelOfWrapping() {
DataSource dataSource = new HikariDataSource();
DataSource actual = wrapInProxy(wrapInDelegate(
wrapInDelegate((wrapInProxy(wrapInDelegate(dataSource))))));
assertThat(DataSourceUnwrapper.unwrap(actual, HikariDataSource.class))
.isSameAs(dataSource);
}
@Test
public void unwrapDataSourceProxy() {
org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
DataSource actual = wrapInDelegate(wrapInProxy(dataSource));
assertThat(DataSourceUnwrapper.unwrap(actual, DataSourceProxy.class))
.isSameAs(dataSource);
}
private DataSource wrapInProxy(DataSource dataSource) {
return (DataSource) new ProxyFactory(dataSource).getProxy();
}
private DataSource wrapInDelegate(DataSource dataSource) {
return new DelegatingDataSource(dataSource);
}
}