阅读spring 源码

对spring框架不是很熟悉，想学习一下spring的源码，虽然不知道能不能坚持，但是起码今天是一个开始。fighting！

昨天看了几个类，今天看的第一个类是，不对应该说接口是

/*

* Copyright 2002-2012 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.context;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.Aware;

/**

* Interface to be implemented by any object that wishes to be notified

* of the {@link ApplicationContext} that it runs in.

*

* <p>Implementing this interface makes sense for example when an object

* requires access to a set of collaborating beans. Note that configuration

* via bean references is preferable to implementing this interface just

* for bean lookup purposes.

*

* <p>This interface can also be implemented if an object needs access to file

* resources, i.e. wants to call {@code getResource}, wants to publish

* an application event, or requires access to the MessageSource. However,

* it is preferable to implement the more specific {@link ResourceLoaderAware},

* {@link ApplicationEventPublisherAware} or {@link MessageSourceAware} interface

* in such a specific scenario.

*

* <p>Note that file resource dependencies can also be exposed as bean properties

* of type {@link org.springframework.core.io.Resource}, populated via Strings

* with automatic type conversion by the bean factory. This removes the need

* for implementing any callback interface just for the purpose of accessing

* a specific file resource.

*

* <p>{@link org.springframework.context.support.ApplicationObjectSupport} is a

* convenience base class for application objects, implementing this interface.

*

* <p>For a list of all bean lifecycle methods, see the

* {@link org.springframework.beans.factory.BeanFactory BeanFactory javadocs}.

*

* @author Rod Johnson

* @author Juergen Hoeller

* @author Chris Beams

* @see ResourceLoaderAware

* @see ApplicationEventPublisherAware

* @see MessageSourceAware

* @see org.springframework.context.support.ApplicationObjectSupport

* @see org.springframework.beans.factory.BeanFactoryAware

*/

public interface ApplicationContextAware extends Aware {

/**

* Set the ApplicationContext that this object runs in.

* Normally this call will be used to initialize the object.

* <p>Invoked after population of normal bean properties but before an init callback such

* as {@link org.springframework.beans.factory.InitializingBean#afterPropertiesSet()}

* or a custom init-method. Invoked after {@link ResourceLoaderAware#setResourceLoader},

* {@link ApplicationEventPublisherAware#setApplicationEventPublisher} and

* {@link MessageSourceAware}, if applicable.

* @param applicationContext the ApplicationContext object to be used by this object

* @throws ApplicationContextException in case of context initialization errors

* @throws BeansException if thrown by application context methods

* @see org.springframework.beans.factory.BeanInitializationException

*/

void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

当我看到 Aware 我知道它的中文意思是意识的意思，ApplicationContextAware继承Aware这个接口，那么Aware又是怎么样子的呢

于是我打开源码

package org.springframework.beans.factory;

/**

* Marker superinterface indicating that a bean is eligible to be

* notified by the Spring container of a particular framework object

* through a callback-style method. Actual method signature is

* determined by individual subinterfaces, but should typically

* consist of just one void-returning method that accepts a single

* argument.

*

* <p>Note that merely implementing {@link Aware} provides no default

* functionality. Rather, processing must be done explicitly, for example

* in a {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}.

* Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor}

* and {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory}

* for examples of processing {@code *Aware} interface callbacks.

*

* @author Chris Beams

* @since 3.1

*/

public interface Aware {

}

看到这里我惊呆了，定义这么一个接口啥意思，什么都没有，就一个名字，有啥用啊，让我想不明白。注释意思是：

标记超表明Bean可以

由特定框架对象的Spring容器通知的

通过回调样式方法。实际方法签名是

由个人完成确定，但通常应该

仅包含一个空返回方法，该方法接受单个

争论。

这个是百度给的意思。。。。

我的理解：

Aware是意识的意思，是一个超级抽象的一个东西，在现实生活中，问意识是什么，估计会有各种各样的回答，因为它太抽象了。作为一名程序员，相当于一个造物主，你想定义什么就定义什么，于是Aware就是我们用程序定义“意识”的类。意识有什么用，意识用来感知，当意识感知到某件事情发生了，我们可以做相应的操作。在现实生活中，我们意识到太胖了，我们就知道要减肥了，意识到没钱，就知道要吃土了。这就是意识的作用。具体在spring 这个框架中有什么用，这个需要进一步研究。每天看一点点，希望有一天能学懂。

定义一个接口时，是一个抽象过程，其实也是一个具体化过程，大家怎么理解。