- 浏览: 296907 次
- 性别:
- 来自: 上海
文章分类
最新评论
-
wangweiying123:
import com.sse.monitor.bean.Mes ...
一个项目看java TCP/IP Socket编程(1.3版) -
daxiaoli123:
求源码 448485223@qq.com
一个项目看java TCP/IP Socket编程(1.3版) -
jeromexf:
楼主,求源码,万分感谢(jeromexf@gmail.com) ...
一个项目看java TCP/IP Socket编程(1.3版) -
cuishen:
注意: 网上有人说IE8以下不支持Max-Age, 上面的代码 ...
Response Header Set-Cookie difference in cross browser -
zhunengfei:
刚接触socket,不是太明白,楼主的例子里面工具给的不是很全 ...
一个项目看java TCP/IP Socket编程(1.3版)
spring IOC容器(Inversion of Control container)做项目的时候经常要用到,但是好像感觉不到它的存在,因为代码里面很少用到spring,主要是写配置。但是我不得不说:spring做的确实很巧妙,这种和代码的松耦合很大的提高了代码的灵活性和可扩展性。最近手头的开发任务比较少,于是抽空看了看spring1.2.9的源代码,现在把心得贴出来和网友共享,欢迎大家批评指正。
1. spring IOC容器接口定义
org.springframework.beans.factory 这里是定义spring IOC容器接口的包,在这个包里有我们熟悉的BeanFactory
在BeanFactory里只对IOC容器的基本行为作了定义,根本不关心你的bean是怎样定义怎样加载的,就像我们只关心从这个工厂里能得到什么产品对象,至于工厂是怎么生产这些对象的,这个基本的接口不关心这些。如果要关心工厂是怎样产生对象的,应用程序需要使用具体的IOC容器实现
spring已经为我们准备了丰富的IOC容器的具体实现(当然,有兴趣的朋友也可以尝试实现自己的一套IOC容器来证明自己的实力也未尝不可),现在先让我们看看spring是怎样实现的:
2. spring IOC容器接口的实现
AbstractBeanFactory实现了BeanFactory接口里的getBean()方法,做为抽象的父类为所有继承它的子类提供getBean()的模板服务,getBean()方法是根据bean的名称在缓存--AbstractBeanFactory#singletonCache(IOC容器)里查找其实例,如果找不到则根据用户的配置文件里的bean定义信息(spring背后有一套功能十分强大的xml文件解析工具来完成bean定义文件的解析,有兴趣的朋友可以看看org.springframework.beans.factory.xml.XmlBeanDefinitionReader和org.springframework.beans.factory.xml.DefaultXmlBeanDefinitionParser,解析好后会将bean定义信息放入缓存,限于篇幅这里不再赘述)造bean实例,如果该bean是单例模式,则同时放进缓存---AbstractBeanFactory#singletonCache。getBean()是IOC容器的核心方法。在getBean()里用到了createBean()方法,顾名思义--造bean实例的方法,该方法在子类中得到了实现,现在我们看看子类中到底是怎样createBean的。
其实create bean的过程就是通过bean的定义信息反射bean实例的过程。真正用反射造对象的代码这里没有体现出来,我们注意到了BeanWrapper仅仅是bean实例的包装类,不涉及到造对象的代码;instantiateUsingFactoryMethod()、autowireConstructor()和instantiateBean()方法里都用到了实例化策略类里面的方法--instantiate(),毫无疑问反射对象的代码就应该在instantiate()里面,现在就让我们来揭开实例化策略类的神秘面纱。
原来一部分实例化bean的代码放到BeanUtils.instantiateClass()方法里了,我们现在来看看BeanUtils类
从以上代码我们不难看出,spring如果遇到bean的构造方法是私有的,那么它会去修改bean的访问权限,同样可以反射出bean的对象
3. spring依赖注入(dependence injection)的实现
所谓依赖,举个例子说明,一个类Person,另一个类Car,如果Person的某个方法比如说drive,需要引用Car,则称Person类依赖于Car类,延伸到对象,这种依赖关系依然成立。这其中的依赖关系,就导致了对象Person需要负责对象Car的创建,甚至是整个生命周期的管理,而这样显然会带来耦合度高,不易维护等缺点。spring框架的依赖注入为我们提供了很好的解决方案,将Person依赖的对象Car造好,然后注入到Person中去,而无需Person自己去引用Car,这个注入的过程,由spring IOC容器来完成,无需对象去关心。
Spring提供了3种类型的依赖注入:构造函数注入(constructor injection)、setter注入(setter injection)和方法注入(method injection)。说白了就是反射factoryBean里的方法,把所依赖的对象做为参数传进去完成注入。这里提到了factoryBean的概念,这个factoryBean其实就是IOC容器管理的bean,说白了就是有依赖关系的bean,例如我们上面举的例子里面的Person类,Person需要依赖Car对象,在IOC容器中Person的实例就是一个factoryBean,Car的对象将被注入这个factoryBean
spring究竟是怎样实现依赖注入的,其实上面已经有所提到,我们现在再来仔细看看AbstractAutowireCapableBeanFactory类的instantiateUsingFactoryMethod方法
现在总结下:
spring的IOC容器的功能就是把实例化对象和代码解耦,现在造对象的活完全交给spring IOC容器来做了,如果有需要,spring容器还可以把bean注入到依赖它的其它bean中,方便程序使用。我们要做的仅仅是配置好bean定义文件,并告诉spring定义文件在哪,然后在代码里getBean()就行啦!
IOC容器的载体说白了就是Map,即我们常说的缓存。在spring中IOC缓存主要分bean实例的缓存(单例)和bean定义信息的缓存
spring通过定位资源-->解析bean定义文件并缓存bean定义信息-->根据bean定义造bean实例-->如果是单例模式则把这个bean放进缓存管理,否则直接造对象-->如果有依赖关系,则反射目标bean的方法(setter方法/构造方法/普通方法)并将其依赖的bean做为参数传入,完成注入-->至此,IOC容器就建立起来了。
1. spring IOC容器接口定义
org.springframework.beans.factory 这里是定义spring IOC容器接口的包,在这个包里有我们熟悉的BeanFactory
package org.springframework.beans.factory; public interface BeanFactory { /** *这里是对FactoryBean的转义定义,如果使用bean的名字检索FactoryBean,得到的是工厂生成的对象, *如果需要得到工厂本身,需要转义。For example, if the bean named * <code>myJndiObject</code> is a FactoryBean, getting <code>&myJndiObject</code> * will return the factory */ String FACTORY_BEAN_PREFIX = "&"; /** *这里根据bean的名字,在IOC容器中得到bean实例,这个IOC容器就是一个大的抽象工厂。 */ Object getBean(String name) throws BeansException; /** *这里根据bean的名字和Class类型来得到bean实例,和上面的方法不同在于它会抛出异常:如果 *根据名字取得的bean实例的Class类型和需要的不同的话。 */ Object getBean(String name, Class requiredType) throws BeansException; /** *这里提供对bean的检索,看看是否在IOC容器有这个名字的bean */ boolean containsBean(String name); /** *这里根据bean名字得到bean实例,并同时判断这个bean是不是单例 */ boolean isSingleton(String name) throws NoSuchBeanDefinitionException; /** *这里得到bean实例的Class类型 */ Class getType(String name) throws NoSuchBeanDefinitionException; /** *这里得到bean的别名,如果根据别名检索,那么其原名也会被检索出来 */ String[] getAliases(String name); }
在BeanFactory里只对IOC容器的基本行为作了定义,根本不关心你的bean是怎样定义怎样加载的,就像我们只关心从这个工厂里能得到什么产品对象,至于工厂是怎么生产这些对象的,这个基本的接口不关心这些。如果要关心工厂是怎样产生对象的,应用程序需要使用具体的IOC容器实现
spring已经为我们准备了丰富的IOC容器的具体实现(当然,有兴趣的朋友也可以尝试实现自己的一套IOC容器来证明自己的实力也未尝不可),现在先让我们看看spring是怎样实现的:
2. spring IOC容器接口的实现
package org.springframework.beans.factory.support; public abstract class AbstractBeanFactory implements ConfigurableBeanFactory { /** * 放置单例bean实例的缓存(IOC容器) * Cache of singletons: bean name --> bean instance */ private final Map singletonCache = CollectionFactory.createLinkedMapIfPossible(16); /** * 根据bean名称从缓存(IOC容器)中获得bean实例,如果缓存中没有,则根据bean的定义 * 信息造bean的实例,如果是单例,就放进缓存(IOC容器) */ public Object getBean(String name, Class requiredType, Object[] args) throws BeansException { String beanName = transformedBeanName(name); Object bean = null; // 在缓存中根据名字查找bean实例. Object sharedInstance = null; synchronized (this.singletonCache) { sharedInstance = this.singletonCache.get(beanName); } if (sharedInstance != null) { ... // 如果容器里找的到,则从缓存返回bean bean = getObjectForSharedInstance(name, sharedInstance); } else { ... // Check if bean definition exists in this factory. // 如果当前BeanFactory里没有bean定义信息,则去ParentBeanFactory // 里查找 if (getParentBeanFactory() != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. if (getParentBeanFactory() instanceof AbstractBeanFactory) { // Delegation to parent with args only possible for AbstractBeanFactory. return ((AbstractBeanFactory) getParentBeanFactory()).getBean(name, requiredType, args); } else if (args == null) { // No args -> delegate to standard getBean method. return getParentBeanFactory().getBean(name, requiredType); } else { ... } } // 获得bean定义信息 RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false); checkMergedBeanDefinition(mergedBeanDefinition, beanName, requiredType, args); // Create bean instance. if (mergedBeanDefinition.isSingleton()) { synchronized (this.singletonCache) { // Re-check singleton cache within synchronized block. sharedInstance = this.singletonCache.get(beanName); if (sharedInstance == null) { ... this.currentlyInCreation.add(beanName); try { // 根据bean定义信息造bean的实例 sharedInstance = createBean(beanName, mergedBeanDefinition, args); // 将bean实例放入缓存(IOC容器) addSingleton(beanName, sharedInstance); } catch (BeansException ex) { ... } finally { this.currentlyInCreation.remove(beanName); } } } bean = getObjectForSharedInstance(name, sharedInstance); } else { // 如果不是单例模式 just create a new instance. bean = createBean(beanName, mergedBeanDefinition, args); } } ... return bean; } /** * 抽象方法,在子类中实现 */ protected abstract Object createBean( String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args) throws BeanCreationException; /** * 在缓存中注册bean实例 */ public void registerSingleton(String beanName, Object singletonObject) throws BeanDefinitionStoreException { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(singletonObject, "Singleton object must not be null"); synchronized (this.singletonCache) { Object oldObject = this.singletonCache.get(beanName); if (oldObject != null) { ... } addSingleton(beanName, singletonObject); } } /** * 在缓存中注册bean实例 */ protected void addSingleton(String beanName, Object singletonObject) { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(singletonObject, "Singleton object must not be null"); synchronized (this.singletonCache) { this.singletonCache.put(beanName, singletonObject); } } }
AbstractBeanFactory实现了BeanFactory接口里的getBean()方法,做为抽象的父类为所有继承它的子类提供getBean()的模板服务,getBean()方法是根据bean的名称在缓存--AbstractBeanFactory#singletonCache(IOC容器)里查找其实例,如果找不到则根据用户的配置文件里的bean定义信息(spring背后有一套功能十分强大的xml文件解析工具来完成bean定义文件的解析,有兴趣的朋友可以看看org.springframework.beans.factory.xml.XmlBeanDefinitionReader和org.springframework.beans.factory.xml.DefaultXmlBeanDefinitionParser,解析好后会将bean定义信息放入缓存,限于篇幅这里不再赘述)造bean实例,如果该bean是单例模式,则同时放进缓存---AbstractBeanFactory#singletonCache。getBean()是IOC容器的核心方法。在getBean()里用到了createBean()方法,顾名思义--造bean实例的方法,该方法在子类中得到了实现,现在我们看看子类中到底是怎样createBean的。
package org.springframework.beans.factory.support; public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { /** * 造bean对象 */ protected Object createBean(String beanName, RootBeanDefinition mergedBeanDefinition, Object[] args) throws BeanCreationException { // 实例化并初始化当前bean所依赖的所有bean. if (mergedBeanDefinition.getDependsOn() != null) { for (int i = 0; i < mergedBeanDefinition.getDependsOn().length; i++) { getBean(mergedBeanDefinition.getDependsOn()[i]); } } ... Object bean = null; // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. if (mergedBeanDefinition.hasBeanClass()) { bean = applyBeanPostProcessorsBeforeInstantiation(mergedBeanDefinition.getBeanClass(), beanName); if (bean != null) { return bean; } } BeanWrapper instanceWrapper = null; Object originalBean = null; ... try { ... if (mergedBeanDefinition.getFactoryMethodName() != null) { //反射factoryBean的工厂方法 instanceWrapper = instantiateUsingFactoryMethod(beanName, mergedBeanDefinition, args); } else if (mergedBeanDefinition.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mergedBeanDefinition.hasConstructorArgumentValues() ) { //实例化bean的方法 instanceWrapper = autowireConstructor(beanName, mergedBeanDefinition); } else { //实例化bean的方法 // No special handling: simply use no-arg constructor. instanceWrapper = instantiateBean(beanName, mergedBeanDefinition); } bean = instanceWrapper.getWrappedInstance(); // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. if (isAllowCircularReferences() && isSingletonCurrentlyInCreation(beanName)) { ... addSingleton(beanName, bean); } ... originalBean = bean; bean = applyBeanPostProcessorsBeforeInitialization(bean, beanName); // 调用bean实例里的init方法 invokeInitMethods(beanName, bean, mergedBeanDefinition); bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } catch (BeanCreationException ex) { ... } // Register bean as disposable, and also as dependent on specified "dependsOn" beans. registerDisposableBeanIfNecessary(beanName, originalBean, mergedBeanDefinition); return bean; } /** * 反射factoryBean里的工厂方法,实现依赖注入 */ protected BeanWrapper instantiateUsingFactoryMethod( String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs) throws BeansException { ... BeanWrapperImpl bw = new BeanWrapperImpl(); initBeanWrapper(bw); ... Object beanInstance = this.instantiationStrategy.instantiate( mergedBeanDefinition, beanName, this, factoryBean, factoryMethodToUse, argsToUse); ... bw.setWrappedInstance(beanInstance); return bw; } /** * 匹配bean构造方法来实例化bean */ protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mergedBeanDefinition) throws BeansException { ... BeanWrapperImpl bw = new BeanWrapperImpl(); initBeanWrapper(bw); ... Object beanInstance = this.instantiationStrategy.instantiate( mergedBeanDefinition, beanName, this, constructorToUse, argsToUse); bw.setWrappedInstance(beanInstance); ... return bw; } /** * 用bean的默认构造方法造bean实例 */ protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mergedBeanDefinition) throws BeansException { Object beanInstance = getInstantiationStrategy().instantiate(mergedBeanDefinition, beanName, this); BeanWrapper bw = new BeanWrapperImpl(beanInstance); initBeanWrapper(bw); return bw; } }
其实create bean的过程就是通过bean的定义信息反射bean实例的过程。真正用反射造对象的代码这里没有体现出来,我们注意到了BeanWrapper仅仅是bean实例的包装类,不涉及到造对象的代码;instantiateUsingFactoryMethod()、autowireConstructor()和instantiateBean()方法里都用到了实例化策略类里面的方法--instantiate(),毫无疑问反射对象的代码就应该在instantiate()里面,现在就让我们来揭开实例化策略类的神秘面纱。
package org.springframework.beans.factory.support; public class SimpleInstantiationStrategy implements InstantiationStrategy { public Object instantiate( RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) { // Don't override the class with CGLIB if no overrides. if (beanDefinition.getMethodOverrides().isEmpty()) { // 调用BeanUtils的静态方法实例化bean return BeanUtils.instantiateClass(beanDefinition.getBeanClass()); } else { // Must generate CGLIB subclass. // 抛异常"Method Injection not supported in SimpleInstantiationStrategy" return instantiateWithMethodInjection(beanDefinition, beanName, owner); } } public Object instantiate( RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Constructor ctor, Object[] args) { if (beanDefinition.getMethodOverrides().isEmpty()) { // 调用BeanUtils的静态方法实例化bean return BeanUtils.instantiateClass(ctor, args); } else { return instantiateWithMethodInjection(beanDefinition, beanName, owner, ctor, args); } } public Object instantiate( RootBeanDefinition beanDefinition, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object[] args) { try { // It's a static method if the target is null. if (!Modifier.isPublic(factoryMethod.getModifiers()) || !Modifier.isPublic(factoryMethod.getDeclaringClass().getModifiers())) { // 如果方法不是公有方法,则修改它的访问权限 factoryMethod.setAccessible(true); } // 用反射调用factoryBean实例中的方法 return factoryMethod.invoke(factoryBean, args); } catch (IllegalArgumentException ex) { ... } } }
原来一部分实例化bean的代码放到BeanUtils.instantiateClass()方法里了,我们现在来看看BeanUtils类
package org.springframework.beans; public abstract class BeanUtils { /** * 实例化带默认构造方法的bean */ public static Object instantiateClass(Class clazz) throws BeanInstantiationException { ... try { return instantiateClass(clazz.getDeclaredConstructor((Class[]) null), null); } ... } /** * 根据构造方法实例化bean */ public static Object instantiateClass(Constructor ctor, Object[] args) throws BeanInstantiationException { ... try { if (!Modifier.isPublic(ctor.getModifiers()) || !Modifier.isPublic(ctor.getDeclaringClass().getModifiers())) { //如果是私有构造方法则修改访问权限 ctor.setAccessible(true); } // 反射实例 return ctor.newInstance(args); } ... } }
从以上代码我们不难看出,spring如果遇到bean的构造方法是私有的,那么它会去修改bean的访问权限,同样可以反射出bean的对象
3. spring依赖注入(dependence injection)的实现
所谓依赖,举个例子说明,一个类Person,另一个类Car,如果Person的某个方法比如说drive,需要引用Car,则称Person类依赖于Car类,延伸到对象,这种依赖关系依然成立。这其中的依赖关系,就导致了对象Person需要负责对象Car的创建,甚至是整个生命周期的管理,而这样显然会带来耦合度高,不易维护等缺点。spring框架的依赖注入为我们提供了很好的解决方案,将Person依赖的对象Car造好,然后注入到Person中去,而无需Person自己去引用Car,这个注入的过程,由spring IOC容器来完成,无需对象去关心。
Spring提供了3种类型的依赖注入:构造函数注入(constructor injection)、setter注入(setter injection)和方法注入(method injection)。说白了就是反射factoryBean里的方法,把所依赖的对象做为参数传进去完成注入。这里提到了factoryBean的概念,这个factoryBean其实就是IOC容器管理的bean,说白了就是有依赖关系的bean,例如我们上面举的例子里面的Person类,Person需要依赖Car对象,在IOC容器中Person的实例就是一个factoryBean,Car的对象将被注入这个factoryBean
spring究竟是怎样实现依赖注入的,其实上面已经有所提到,我们现在再来仔细看看AbstractAutowireCapableBeanFactory类的instantiateUsingFactoryMethod方法
package org.springframework.beans.factory.support; public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { protected BeanWrapper instantiateUsingFactoryMethod( String beanName, RootBeanDefinition mergedBeanDefinition, Object[] explicitArgs) throws BeansException { ConstructorArgumentValues cargs = mergedBeanDefinition.getConstructorArgumentValues(); ConstructorArgumentValues resolvedValues = null; int minNrOfArgs = 0; if (explicitArgs == null) { // 如果没有工厂方法的参数直接传入,我们将从bean definition中得到 resolvedValues = new ConstructorArgumentValues(); minNrOfArgs = resolveConstructorArguments(beanName, mergedBeanDefinition, cargs, resolvedValues); } else { minNrOfArgs = explicitArgs.length; } boolean isStatic = true; Class factoryClass = null; Object factoryBean = null; if (mergedBeanDefinition.getFactoryBeanName() != null) { // 获得factoryBean的实例 factoryBean = getBean(mergedBeanDefinition.getFactoryBeanName()); factoryClass = factoryBean.getClass(); isStatic = false; } else { // It's a static factory method on the bean class. factoryClass = mergedBeanDefinition.getBeanClass(); } BeanWrapperImpl bw = new BeanWrapperImpl(); initBeanWrapper(bw); // 尝试调用factoryBean里的方法,如果这个工厂方法里的参数和得到的参数匹配 Method[] candidates = factoryClass.getMethods(); Method factoryMethodToUse = null; Object[] argsToUse = null; int minTypeDiffWeight = Integer.MAX_VALUE; // 对工厂方法和参数做个遍历,挑出合适的方法和参数 for (int i = 0; i < candidates.length; i++) { Method factoryMethod = candidates[i]; if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic && factoryMethod.getName().equals(mergedBeanDefinition.getFactoryMethodName()) && factoryMethod.getParameterTypes().length >= minNrOfArgs) { Class[] argTypes = factoryMethod.getParameterTypes(); ArgumentsHolder args = null; if (resolvedValues != null) { // Resolved contructor arguments: type conversion and/or autowiring necessary. try { args = createArgumentArray( beanName, mergedBeanDefinition, resolvedValues, bw, argTypes, "factory method"); } catch (UnsatisfiedDependencyException ex) { if (logger.isDebugEnabled()) { logger.debug("Ignoring factory method [" + factoryMethod + "] of bean '" + beanName + "': " + ex.getMessage()); } if (i == candidates.length - 1 && factoryMethodToUse == null) { throw ex; } else { // Swallow and try next overloaded factory method. continue; } } } else { // Explicit arguments given -> arguments length must match exactly. if (argTypes.length != explicitArgs.length) { continue; } args = new ArgumentsHolder(explicitArgs); } int typeDiffWeight = args.getTypeDifferenceWeight(argTypes); // Choose this constructor if it represents the closest match. if (typeDiffWeight < minTypeDiffWeight) { factoryMethodToUse = factoryMethod; argsToUse = args.arguments; minTypeDiffWeight = typeDiffWeight; } } } if (factoryMethodToUse == null) { throw new BeanCreationException( mergedBeanDefinition.getResourceDescription(), beanName, "Cannot find matching factory method '" + mergedBeanDefinition.getFactoryMethodName () + "' on class [" + factoryClass.getName() + "]"); } // 反射factoryBean的factory method,把依赖的bean对象做为参数传入,完成注入. Object beanInstance = this.instantiationStrategy.instantiate( mergedBeanDefinition, beanName, this, factoryBean, factoryMethodToUse, argsToUse); ... bw.setWrappedInstance(beanInstance); ... return bw; } }
现在总结下:
spring的IOC容器的功能就是把实例化对象和代码解耦,现在造对象的活完全交给spring IOC容器来做了,如果有需要,spring容器还可以把bean注入到依赖它的其它bean中,方便程序使用。我们要做的仅仅是配置好bean定义文件,并告诉spring定义文件在哪,然后在代码里getBean()就行啦!
IOC容器的载体说白了就是Map,即我们常说的缓存。在spring中IOC缓存主要分bean实例的缓存(单例)和bean定义信息的缓存
spring通过定位资源-->解析bean定义文件并缓存bean定义信息-->根据bean定义造bean实例-->如果是单例模式则把这个bean放进缓存管理,否则直接造对象-->如果有依赖关系,则反射目标bean的方法(setter方法/构造方法/普通方法)并将其依赖的bean做为参数传入,完成注入-->至此,IOC容器就建立起来了。
评论
3 楼
ak_2005
2008-09-21
不错,学习学习 !
2 楼
jgpycj
2008-09-19
非常感谢,讲的非常详细。对spring的IOC又有了新的认识。
1 楼
stephen_chenxifei
2008-09-19
讲的不错,有时候看看源代码确实能学习到不少的东西
发表评论
-
Response Header Set-Cookie difference in cross browser
2014-07-02 21:26 8391如果你项目中需要在server端把cookie写回client ... -
struts1 redirect issue
2014-05-08 23:04 1339近日突然发现struts1 的redirect有很大的限制,它 ... -
Cookie 和 sessionStorage的区别
2014-03-18 23:21 1546expire设为null的cookie是session sco ... -
http https get post 的区别,定义/安全性/性能
2014-02-20 18:19 14639HTTP / HTTPS request 的 get / po ... -
struts1的tiles导致的response cache无法禁止的issue
2014-02-15 00:13 1488近日struts 1项目中遇到一个很怪异的问题,项目中的所有. ... -
XFS攻击一例
2013-08-13 17:50 5997XFS: Cross Frame Script (跨框架脚本) ... -
XSS攻击一例
2013-08-12 17:55 1773XSS 全称(Cross Site Scripting) 跨站 ... -
maven3 compile failed, class file not found issue
2013-07-16 18:31 1432今日maven3 build 老是失败,停在compile,报 ... -
maven plugin for eclipse 3.6+
2013-07-04 18:24 1159this for eclipse 3.6 down http: ... -
JQuery异步提交表单在Firefox button onclick事件下可能导致重复提交
2013-06-04 19:58 4857当我们处理button的onclick事件时,在onclick ... -
AJAX JQuery 提交表单乱码问题解决方案
2012-10-16 13:59 13667最近遇到AJAX/JQuery 提交form表单出现乱码的问题 ... -
hibernate多对多级联删除总结
2010-04-02 07:46 3569A. 应用场景: 一个简单的权限系统的例子: 有三张主表: ... -
iBATIS一对多/多对多N+1问题解决方案
2009-12-08 17:53 13130对于iBATIS一对多/多对多的问题,传统的办法是在一对多/多 ... -
最原始的O/R Mapping,比hibernate轻的多
2009-12-04 17:44 3517hibernate的O/R Mapping确实 ... -
Apache_WebLogic9.2.2安装及集群、SSL配置手册
2009-10-09 17:27 1544Apache_WebLogic9.2.2安装及集群、SSL配置 ... -
浅析Java web程序之客户端和服务器端交互原理
2009-09-16 21:18 47691. 协议 a. TCP/IP整体构 ... -
spring aop 事务配置总结
2009-08-06 13:47 5587以下配置基于spring 1x ... -
从源代码解读spring之DataSource实现和FactoryBean模式
2009-07-22 13:25 8005大家平日使用spring + hibernate做项目的时候大 ... -
从源代码解读hibernate之数据库连接
2009-07-17 15:59 3754大家都知道hibernate是在JDBC基础上的封装,那么它的 ... -
AIX环境下JDK1.5 + WebLogic9.2.2安装配置手册
2009-01-22 13:15 2363项目中用到: 服务器:IBM 64位 小型机 操作系统:AI ...
相关推荐
在源代码中,`org.springframework.beans.factory.BeanFactory` 和 `org.springframework.context.ApplicationContext` 是IoC容器的两个主要接口,它们提供了加载配置、获取Bean和处理依赖注入等功能。通过阅读这些...
下面,我们将从以下几个方面对Spring框架进行深入剖析:Spring AOP(面向切面编程)、Spring Boot、Spring IoC容器以及Spring与MyBatis的集成。 ### Spring AOP(面向切面编程) 面向切面编程(Aspect Oriented ...
本书从源代码的角度对Spring的内核和各个主要功能模块的架构、设计和实现原理进行了深入剖析。你不仅能从本书中参透Spring框架的优秀架构和设计思想,还能从Spring优雅的实现源码中一窥Java语言的精髓。本书在开篇...
在整个源代码分析中,我们可以看到 Spring 实现声明式事务管理有三个部分: 1. 对在上下文中配置的属性的处理,这里涉及的类是 TransactionAttributeSourceAdvisor,这是一个通知器,用它来对属性值进行处理,属性...
#### 一、Spring框架概览及IoC容器的重要性 Spring框架作为一款轻量级的企业级应用开发框架,其核心功能是IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)。其中,IoC...
9、什么是SpringIOC容器? Spring IOC容器是Spring框架的核心,它负责创建对象、装配以及管理这些对象的整个生命周期,从创建到销毁。其核心思想是反转控制(IoC),即控制权由应用代码转移到了Spring容器。 10、...
Spring 源代码分析系列涵盖了多个关键模块,包括事务处理、IoC容器、JDBC、MVC、AOP以及与Hibernate和Acegi安全框架的集成。以下是对这些知识点的详细阐述: 1. **Spring 事务处理**:Spring 提供了声明式事务管理...
4. **AOP**:面向切面编程允许我们在不修改源代码的情况下,插入跨切面关注点,如日志、事务管理等。 5. **ASPECTJ**:Spring支持AspectJ,一种强大的编译时和运行时AOP框架,可以方便地定义切面和通知。 6. **MVC...
1. **依赖注入**:理解Spring如何通过IoC容器管理对象的生命周期和依赖关系。 2. **AOP**:了解Spring如何实现切面,以及何时何地应用切面进行方法拦截。 3. **Bean的生命周期**:学习Bean的初始化、使用和销毁过程...
Spring AOP(面向切面编程)是Spring框架的重要组成部分,它允许程序员在不修改源代码的情况下,通过添加额外的行为(即“切面”)来增强应用程序的功能。在Spring AOP中,主要有三个核心概念:Advice、Pointcut和...
通过对Spring的核心概念如IoC容器、AOP、与MyBatis的集成以及Spring Boot的理解,开发者可以更好地利用这些工具提高开发效率和代码质量。希望以上内容能帮助大家深入理解Spring框架及其相关技术栈。
标题“Spring Src”指的是Spring框架的源代码,这是一份重要的学习资料,特别是对于Java开发者而言,深入理解Spring的工作原理能提升开发技能。Spring是Java企业级应用开发中最广泛使用的框架,它以其依赖注入...
1. **依赖注入(DI)与控制反转(IoC)**:Spring的核心特性是依赖注入,它通过反转应用程序对对象的控制权,使得对象的创建和管理交由Spring容器处理。DI允许我们在不修改代码的情况下更换或扩展组件,提高了代码的可...
在Spring框架中,"interface21"通常指的是Spring 2.1版本的接口和源代码。这个阶段的Spring已经发展得相当成熟,引入了许多关键特性,对于理解Spring的工作原理和设计模式至关重要。以下是对Spring 2.1版本中一些...
6. **Chapter 6:Spring的IoC容器** 详细讲解Spring的Inversion of Control(控制反转)容器,包括Bean的生命周期、初始化、销毁过程以及Bean的装配方式,让读者深刻理解Spring容器的工作原理。 7. **Chapter 13:...
7. **spring高级源码笔记.pdf**:这可能包含了对Spring框架源代码的深入解读,有助于理解Spring的工作原理,对于想要深入了解Spring的开发者非常有价值。 8. **廖雪峰 Java教程.pdf**:廖雪峰的Java教程是初学者的...
1. **spring-core.jar**:这是Spring框架的基础,包含了核心工具类和IoC容器的基本组件。它提供了如Resource接口、BeanUtils工具类以及ClassPathXmlApplicationContext等用于加载和解析配置文件的类。Core模块是其他...
阅读本说明文档时,可以结合源代码示例进行深入学习,逐步掌握Spring.NET的精髓。 总的来说,Spring.NET中文说明为.NET开发者提供了一套全面的指南,帮助他们更好地理解和运用这个强大的框架,提升开发效率和代码...
下面,我们来深入解读Spring 3.0 API中的重要知识点。 首先,文档提到了Spring框架的介绍,其中包含了依赖注入和控制反转(IoC),这是Spring框架的核心概念之一。依赖注入(Dependency Injection, DI)允许我们...