day39-Spring 13-Spring的JDBC模板：默认连接池的配置

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Spring内置的连接池DriverManagerDataSource的源码.

/*
* Copyright 2002-2008 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.jdbc.datasource;import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;/**
* Simple implementation of the standard JDBC {@link javax.sql.DataSource} interface,
* configuring the plain old JDBC {@link java.sql.DriverManager} via bean properties, and
* returning a new {@link java.sql.Connection} from every <code>getConnection</code> call.
*
* NOTE: This class is not an actual connection pool; it does not actually
* pool Connections. It just serves as simple replacement for a full-blown
* connection pool, implementing the same standard interface, but creating new
* Connections on every call.
*
* Useful for test or standalone environments outside of a J2EE container, either
* as a DataSource bean in a corresponding ApplicationContext or in conjunction with
* a simple JNDI environment. Pool-assuming <code>Connection.close()</code> calls will
* simply close the Connection, so any DataSource-aware persistence code should work.
*
* NOTE: Within special class loading environments such as OSGi, this class
* is effectively superseded by {@link SimpleDriverDataSource} due to general class
* loading issues with the JDBC DriverManager that be resolved through direct Driver
* usage (which is exactly what SimpleDriverDataSource does).
*
* In a J2EE container, it is recommended to use a JNDI DataSource provided by
* the container. Such a DataSource can be exposed as a DataSource bean in a Spring
* ApplicationContext via {@link org.springframework.jndi.JndiObjectFactoryBean},
* for seamless switching to and from a local DataSource bean like this class.
* For tests, you can then either set up a mock JNDI environment through Spring's
* {@link org.springframework.mock.jndi.SimpleNamingContextBuilder}, or switch the
* bean definition to a local DataSource (which is simpler and thus recommended).
*
* If you need a "real" connection pool outside of a J2EE container, consider
* <a href="http://jakarta.apache.org/commons/dbcp">Apache's Jakarta Commons DBCP</a>
* or <a href="http://sourceforge.net/projects/c3p0">C3P0</a>.
* Commons DBCP's BasicDataSource and C3P0's ComboPooledDataSource are full
* connection pool beans, supporting the same basic properties as this class
* plus specific settings (such as minimal/maximal pool size etc).
*
* @author Juergen Hoeller
* @since 14.03.2003
* @see SimpleDriverDataSource
*/
public class DriverManagerDataSource extends AbstractDriverBasedDataSource { /**
* Constructor for bean-style configuration.
*/
public DriverManagerDataSource() {
} /**
* Create a new DriverManagerDataSource with the given JDBC URL,
* not specifying a username or password for JDBC access.
* @param url the JDBC URL to use for accessing the DriverManager
* @see java.sql.DriverManager#getConnection(String)
*/
public DriverManagerDataSource(String url) {
setUrl(url);
} /**
* Create a new DriverManagerDataSource with the given standard
* DriverManager parameters.
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @see java.sql.DriverManager#getConnection(String, String, String)
*/
public DriverManagerDataSource(String url, String username, String password) {
setUrl(url);
setUsername(username);
setPassword(password);
} /**
* Create a new DriverManagerDataSource with the given JDBC URL,
* not specifying a username or password for JDBC access.
* @param url the JDBC URL to use for accessing the DriverManager
* @param conProps JDBC connection properties
* @see java.sql.DriverManager#getConnection(String)
*/
public DriverManagerDataSource(String url, Properties conProps) {
setUrl(url);
setConnectionProperties(conProps);
} /**
* Create a new DriverManagerDataSource with the given standard
* DriverManager parameters.
* @param driverClassName the JDBC driver class name
* @param url the JDBC URL to use for accessing the DriverManager
* @param username the JDBC username to use for accessing the DriverManager
* @param password the JDBC password to use for accessing the DriverManager
* @deprecated since Spring 2.5. DriverManagerDataSource is primarily
* intended for accessing pre-registered JDBC drivers.
* If you need to register a new driver, consider using
* {@link SimpleDriverDataSource} instead.
*/
@Deprecated
public DriverManagerDataSource(String driverClassName, String url, String username, String password) {
setDriverClassName(driverClassName);
setUrl(url);
setUsername(username);
setPassword(password);
} /**
* Set the JDBC driver class name. This driver will get initialized
* on startup, registering itself with the JDK's DriverManager.
* NOTE: DriverManagerDataSource is primarily intended for accessing
* pre-registered JDBC drivers. If you need to register a new driver,
* consider using {@link SimpleDriverDataSource} instead. Alternatively, consider
* initializing the JDBC driver yourself before instantiating this DataSource.
* The "driverClassName" property is mainly preserved for backwards compatibility,
* as well as for migrating between Commons DBCP and this DataSource.
* @see java.sql.DriverManager#registerDriver(java.sql.Driver)
* @see SimpleDriverDataSource
*/
public void setDriverClassName(String driverClassName) {
Assert.hasText(driverClassName, "Property 'driverClassName' must not be empty");
String driverClassNameToUse = driverClassName.trim();
try {
Class.forName(driverClassNameToUse, true, ClassUtils.getDefaultClassLoader());
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException("Could not load JDBC driver class [" + driverClassNameToUse + "]", ex);
}
if (logger.isInfoEnabled()) {
logger.info("Loaded JDBC driver: " + driverClassNameToUse);
}
} @Override
protected Connection getConnectionFromDriver(Properties props) throws SQLException {
String url = getUrl();
if (logger.isDebugEnabled()) {
logger.debug("Creating new JDBC DriverManager Connection to [" + url + "]");
}
return getConnectionFromDriverManager(url, props);
} /**
* Getting a Connection using the nasty static from DriverManager is extracted
* into a protected method to allow for easy unit testing.
* @see java.sql.DriverManager#getConnection(String, java.util.Properties)
*/
protected Connection getConnectionFromDriverManager(String url, Properties props) throws SQLException {
return DriverManager.getConnection(url, props);
}}

DriverManagerDataSource的父类AbstractDriverBasedDataSource的源码
/*
* Copyright 2002-2008 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.jdbc.datasource;import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;import org.springframework.util.Assert;/**
* Abstract base class for JDBC {@link javax.sql.DataSource} implementations
* that operate on a JDBC {@link java.sql.Driver}.
*
* @author Juergen Hoeller
* @since 2.5.5
* @see SimpleDriverDataSource
* @see DriverManagerDataSource
*/
public abstract class AbstractDriverBasedDataSource extends AbstractDataSource { private String url; private String username; private String password; private Properties connectionProperties; /**
* Set the JDBC URL to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setUrl(String url) {
Assert.hasText(url, "Property 'url' must not be empty");
this.url = url.trim();
} /**
* Return the JDBC URL to use for connecting through the Driver.
*/
public String getUrl() {
return this.url;
} /**
* Set the JDBC username to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setUsername(String username) {
this.username = username;
} /**
* Return the JDBC username to use for connecting through the Driver.
*/
public String getUsername() {
return this.username;
} /**
* Set the JDBC password to use for connecting through the Driver.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setPassword(String password) {
this.password = password;
} /**
* Return the JDBC password to use for connecting through the Driver.
*/
public String getPassword() {
return this.password;
} /**
* Specify arbitrary connection properties as key/value pairs,
* to be passed to the Driver.
* Can also contain "user" and "password" properties. However,
* any "username" and "password" bean properties specified on this
* DataSource will override the corresponding connection properties.
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
public void setConnectionProperties(Properties connectionProperties) {
this.connectionProperties = connectionProperties;
} /**
* Return the connection properties to be passed to the Driver, if any.
*/
public Properties getConnectionProperties() {
return this.connectionProperties;
} /**
* This implementation delegates to <code>getConnectionFromDriver</code>,
* using the default username and password of this DataSource.
* @see #getConnectionFromDriver(String, String)
* @see #setUsername
* @see #setPassword
*/
public Connection getConnection() throws SQLException {
return getConnectionFromDriver(getUsername(), getPassword());
} /**
* This implementation delegates to <code>getConnectionFromDriver</code>,
* using the given username and password.
* @see #getConnectionFromDriver(String, String)
*/
public Connection getConnection(String username, String password) throws SQLException {
return getConnectionFromDriver(username, password);
} /**
* Build properties for the Driver, including the given username and password (if any),
* and obtain a corresponding Connection.
* @param username the name of the user
* @param password the password to use
* @return the obtained Connection
* @throws SQLException in case of failure
* @see java.sql.Driver#connect(String, java.util.Properties)
*/
protected Connection getConnectionFromDriver(String username, String password) throws SQLException {
Properties props = new Properties(getConnectionProperties());
if (username != null) {
props.setProperty("user", username);
}
if (password != null) {
props.setProperty("password", password);
}
return getConnectionFromDriver(props);
} /**
* Obtain a Connection using the given properties.
* Template method to be implemented by subclasses.
* @param props the merged connection properties
* @return the obtained Connection
* @throws SQLException in case of failure
*/
protected abstract Connection getConnectionFromDriver(Properties props) throws SQLException;}

public void setDriverClassName(String driverClassName) {
Assert.hasText(driverClassName, "Property 'driverClassName' must not be empty");
String driverClassNameToUse = driverClassName.trim();
try {

public abstract class AbstractDriverBasedDataSource extends AbstractDataSource { private String url; private String username; private String password; private Properties connectionProperties;

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql:///spring3_day02"></property>
<property name="username" value="root"></property>
<property name="password" value="123"></property> </bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

7:26:03,403 INFO XmlBeanDefinitionReader:315 - Loading XML bean definitions from class path resource [applicationContext.xml]
17:26:03,514 INFO GenericApplicationContext:510 - Refreshing org.springframework.context.support.GenericApplicationContext@1fa78298: startup date [Fri May 05 17:26:03 CST 2017]; root of context hierarchy
17:26:03,595 INFO DefaultListableBeanFactory:577 - Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@63a52fe6: defining beans [dataSource,jdbcTemplate,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
17:26:03,633 INFO DriverManagerDataSource:153 - Loaded JDBC driver: com.mysql.jdbc.Driver
17:26:03,998 INFO GenericApplicationContext:1042 - Closing org.springframework.context.support.GenericApplicationContext@1fa78298: startup date [Fri May 05 17:26:03 CST 2017]; root of context hierarchy
17:26:03,999 INFO DefaultListableBeanFactory:444 - Destroying singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@63a52fe6: defining beans [dataSource,jdbcTemplate,org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy

不会把SQL语句打印出来,因为它不是Hibernate.

package cn.itcast.spring3.demo1;import java.sql.DriverManager;import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.jta.SpringJtaSynchronizationAdapter;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringTest1 { @Autowired
@Qualifier("jdbcTemplate")
private JdbcTemplate jdbcTemplate;//注入Jdbc模板
@Test
public void demo2(){
jdbcTemplate.execute("create table user (id int primary key auto_increment,name varchar(20))");
} @Test
public void demo1(){
// 创建连接池:
DriverManagerDataSource dataSource = new DriverManagerDataSource();//Spring自带的连接池
// 设置参数:
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring3_day02");
dataSource.setUsername("root");
dataSource.setPassword(""); //使用JDBC的模板:
//JdbcTemplate jdbcTemplate = new JdbcTemplate();
//jdbcTemplate.setDataSource(dataSource);
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
jdbcTemplate.execute("create table user (id int primary key auto_increment,name varchar(20))");
}
}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql:///spring3_day02"></property>
<property name="username" value="root"></property>
<property name="password" value=""></property> </bean>

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>