带有具名参数功能的JdbcTemplate
applicationContext.xml中配置
<!-- 配置有具名参数功能的 Jdbctemplate -->
<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
<constructor-arg name="dataSource" ref="comboPooledDataSource"></constructor-arg>
</bean>
声明式事务配置：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/tx.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.liuc"></context:component-scan>
<!-- <!–开启基于注解的AOP功能：aop名称空间–>-->
<!-- <aop:aspectj-autoproxy></aop:aspectj-autoproxy>-->
<context:property-placeholder location="classpath:dbconfig.properties"/>
<bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!-- <constructor-arg name="dataSource" ref="comboPooledDataSource"></constructor-arg>-->
<property name="dataSource" ref="comboPooledDataSource"></property>
</bean>
<!-- 事务控制 -->
<!-- 1.配置事务管理器（切面）让其进行事务控制 导入AOP的jar包 -->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
<!-- 控制数据源 -->
<property name="dataSource" ref="comboPooledDataSource"></property>
</bean>
<!-- 2.开启基于注解的事务控制模式，依赖tx命名空间 【必须要同上面的事务管理器的id一致】 -->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
<!-- 3.给事务方法加注解 -->
Spring 源码
1. AOP
环绕通知是以动态代理为基本原理
2. IOC
STEP1:
ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
调用构造器：
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[]{configLocation}, true, (ApplicationContext)null);
}
ClassPathXmlApplicationContext的构造器很多，都调用了以下这个构造器：
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
super(parent);
// 设置配置文件的位置
this.setConfigLocations(configLocations);
if (refresh) {
// 所有的单实例bean创建成功
this.refresh();
}
}
调用的refresh方法：所有的单实例bean创建成功
下面看看refresh():
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 供子类拓展，添加创建前必需属性，校验如果必需属性不存在则抛出MissingRequiredPropertiesException已成
prepareRefresh();
// 调用子类实现方法获取（创建或刷新）BeanFacotry容器，对于ClassPathXmlApplicationContext，主要调用了AbstractRefreshableApplicationContext中实现的方法
// 在这里，将xml配置文件中 的Bean解析成了一个个BeanDefinition,建立一个beanName-> beanDefinition 的 map
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 设定类加载器，spel解析器，属性编辑解析器等，忽略特定接口的依赖注册（在特定时刻相关Bean再完成注入)，注册一些系统Bean供依赖注入使用。
prepareBeanFactory(beanFactory);
try {
// BeanFactory创建完的后置处理。当前为空实现，供子类拓展
postProcessBeanFactory(beanFactory);
// 调用BeanFacotry的相关后置处理器，如果实现了Order相关接口，会先进行排序。
invokeBeanFactoryPostProcessors(beanFactory);
// 注册相关BeanPostProcessor，供Bean生成前后调用。
registerBeanPostProcessors(beanFactory);
// 初始化国际化信息源
initMessageSource();
// 初始化Spring相关上下文时间广播器
initApplicationEventMulticaster();
// 模版方法供子类实现，用于初始化一些特殊Bean配置等
onRefresh();
// 注册实现了ApplicationListener接口的事件监听器，用于后续广播器广播事件
registerListeners();
// BeanFactory初始化完成时调用，初始ConversionService Bean，冻结beanFactory配置，并开始创建BeanFactory中所有非懒加载的单例Bean
finishBeanFactoryInitialization(beanFactory);
// 初始化Lifecycle处理器，调用onRefresh方法，广播ContextRefreshedEvent。
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
}
}
【初始化所有单实例bean的地方】
this.finishBeanFactoryInitialization(beanFactory);
源码如下：
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
this.getBean(weaverAwareName);
}
beanFactory.setTempClassLoader((ClassLoader)null);
beanFactory.freezeConfiguration();
// 【初始化所有单实例】
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons()源码：
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isInfoEnabled()) {
this.logger.info("Pre-instantiating singletons in " + this);
}
List<String> beanNames;
synchronized (this.beanDefinitionMap) {
// 获取容器内加载的所有BeanDefinition
beanNames = new ArrayList<String>(this.beanDefinitionNames);
}
// 遍历初始化所有非懒加载单例Bean
for (String beanName : beanNames) {
// Bean定义公共的抽象类是AbstractBeanDefinition，普通的Bean在Spring加载Bean定义的时候，实例化出来的是GenericBeanDefinition
// 而Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition
// 这时候就使用getMergedLocalBeanDefinition方法做了一次转化，将非RootBeanDefinition转换为RootBeanDefinition以供后续操作。
// 注意如果当前BeanDefinition存在父BeanDefinition，会基于父BeanDefinition生成一个RootBeanDefinition,然后再将调用OverrideFrom子BeanDefinition的相关属性覆写进去。
// 【根据beanid获取到bean的定义信息】
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果Bean不是抽象的，是单例的，不是懒加载的，则开始创建单例对象通过调用getBean(beanName)方法初始化
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 【判断当前Bean是否实现了FactoryBean接口，如果实现了，判断是否要立即初始化】
// 判断是否需要立即初始化，根据Bean是否实现了SmartFactoryBean并且重写的内部方法isEagerInit放回true
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
// 【没有实现FactoryBean，是普通的bean情况下。去创建bean，beanName 就是IOC容器中的id】
getBean(beanName);
}
}
}
}
getBean(beanName)方法 调用了doGetBean(name, null, null, false)
// 具体getBean函数实现如下所示：
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
/*
进一步调用了如下方法，其中有参数：
requiredType=null： 一般情况用不到，如果获取到的字符串，但requiredType是Integer，会在最后进行类型转换。
args=null： 在获取prototype对象时传入，用来初始化原型对象
typeCheckOnly=false： 如果为false，会将Bean标志为已创建,记录在alreadyCreated变量中。
*/
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
// 如果是FactoryBean,会去掉Bean开头的&符号
// 可能存在传入别名且别名存在多重映射的情况，这里会返回最终的名字，如存在多层别名映射A->B->C->D，传入D,最终会返回A
final String beanName = transformedBeanName(name);
Object bean;
// 这里先尝试从缓存中获取，获取不到再走后面创建的流程
// 获取到有两种情况，一种是Bean创建完成存储到最终的缓存中。
// 另一种是未创建完成，但先预存到一个单独的缓存中，这种是针对可能存在循环引用的情况的处理。
// 如A引用B,B又引用了A,因而在初始化A时，A会先调用构造函数创建出一个实例，在依赖注入B之前，现将A实例缓存起来
// 然后在初始化A时，依赖注入阶段，会触发初始化B，B创建后需要依赖注入A时，先从缓存中获取A（这个时候的A是不完整的)，避免循环依赖的问题出现。
// 【从已经注册的单实例bean中（缓存中）看看有没有这个bean】 第一次创建bean是没有的
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//这里主要处理实现了FactoryBean的情况，需要调用重写的getObject()方法来获取实际的Bean实例。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 原型对象不允许循环创建，如果是原型对象则抛异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 如果存在父容器，且Bean在父容器中有定义，则通过父容器返回
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 进行已创建标记
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// 【根据名字获取合并过的对应的RootBeanDefinition 获取bean的定义信息】
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 【检查mbd是否为抽象的或mbd为单例，但存在args的情况（args只有初始化原型对象才允许存在)】
checkMergedBeanDefinition(mbd, beanName, args);
// 【确保当前Bean依赖的相关Bean先完成初始化工作 拿到XML中配置的depend-on属性】
String[] dependsOn = mbd.getDependsOn();
// 【如果有就循环创建】
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
registerDependentBean(dependsOnBean, beanName);
}
}
// 【如果是单例的,开始创建】
if (mbd.isSingleton()) {
// 会先尝试从缓存中获取，获取失败就通过ObjectFactory的createBean方法创建
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
// 创建单例对象
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
//这里主要处理实现了FactoryBean的情况，需要调用重写的getObject()方法来获取实际的Bean实例。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 将正在创建的原型对象进行记录
beforePrototypeCreation(beanName);
// 创建原型对象
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 移除正在创建的原型对象记录
afterPrototypeCreation(beanName);
}
//这里主要处理实现了FactoryBean的情况，需要调用重写的getObject()方法来获取实际的Bean实例。
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; " +
"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 检查是否为要求的类型，如果不是则尝试进行类型转换
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
BeanFactory和ApplicationContext的区别：
1552
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
