spring源码解析

① spring源码解析怎么不见了，我已

选中必要的jar包，上面给出的源码jar包中，导入spring3.0.5中的所有jar包。
其中lib内的是spring的jar包，用到哪个导入哪个，不知道的话，全部导入就行了。

② spring源码要怎么讲

《SPRING技术内幕——深入解析SPRING架构与设计原理》

该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。
spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。
其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security，
spring 任务调度都有介绍。
大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。
跟着作都的思路看过来也还是可以的，最好是对照类图分析。

③ 推荐一本关于spring 源码分析的书，要求内容详细，中文 谢谢

《SPRING技术内幕——深入解析SPRING架构与设计原理》

该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。
spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。
其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security，
spring 任务调度都有介绍。
大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。
跟着作都的思路看过来也还是可以的，最好是对照类图分析。

④ 怎么阅读Spring源码

先满足前提：
一，最基本
1. 了解 java语法
2. 了解设计模式
二，项目基础
1. 已经了解 Spring Core 的功能
2. 已经过了一遍 public api
3. 已经根据自己对 IoC container 的理解，实现了一个最简单的 IoC container
满足了之后，
再进入 spring-core 和 spring-beans 的世界吧。

⑤ spring启动过程源码详解

Spring启动过程源代码的介绍，需要根据程序运行数据信息处理。
因为这种启动过程需要源代码的一个提供信息，所以源代码编写程序要根据电源电压来决定。

⑥ 有多少人能读懂spring源码

研究框架的源码： 一、前提: 需要基础很扎实，做过很多项目了之后。 二、作用： 1、为了更好的掌握框架 2、更好的处理代码中出现的问题或者bug 3、为了以后担当系统架构师打下基础 三、好处： 1、为了自己更深入的了解框架的原理

⑦ 如何高效的学习spring源码

首先Java的基础、面向对象的基础和设计模式的基础知识是必不可少的。

关于设计模式我觉得不用学太多，但以下三个模式是学习Spring必不可少的：factory模式（包括简单工厂和抽象工厂）， Strategy模式，Template method模式。如果不掌握这些你就根本没法领悟Spring的精髓，只能依样画葫芦地照搬，这是很可怕的事。

⑧ 如何评价spring源码深度解析

您好，希望以下回答能帮助您 《SPRING技术内幕——深入解析SPRING架构与设计原理》 该书讲了spring的ioc容器原理,在xml的spring配置文件中，对象是如何解析并生成的。 spring的aop，面向切面编程。这两块是比较重要的，属于核心部分。 其他的如spring mvc ，spring jdbc与hibernate,ibatise集成，spring事务，spring security， spring 任务调度都有介绍。 大体来说，属于跟着代码走向，一个类一个类介绍了一下。其实代码都是有英文注释的。 跟着作都的思路看过来也还是可以的，最好是对照类图分析。 如您还有疑问可继续追问。

⑨ 读过完整Spring源码的来领分

不为领分，谈点个人看法

不要过于急于掌握，先明白什么是spring，spring的本质是什么，对象间关系，为什么要通过IoC这样的方式来管理。

学习资料：
spring2.0中文手册 http://www.redsaga.com/spring_ref/2.0/html/

推荐书籍：expert one-on-one J2EE Development without EJB 有中文版

//-------------------------
// www.1x3x.net/blog
//-------------------------

⑩ 看透springmvc源代码分析与实践 怎么样

Tomcat 里的Server由org.apache.catalina.startup.Catalina来管理
，Catalina是整个Tomcat的管理类，它里面的三个方法load,start,stop分别用来管理整个服务器的生命周期，load方法用于根据conf/server.xml文件创建Server并调用
Server的init方法进行初始化，start
方法用于启动服务器，stop方法用于停止服务器，start和stop方法在内部分别调用了Server的start
和stop方法，load方法内部调用了Server的init方法，这三个方法都
会按容器的结构逐层调用相应的方法，比如，Server的start方法中会调用
所有的Service中的start方法，Service中的start方法又会调用所包含的connectors和container的start方法，这样整个服务器就启动了，init和stop方法也一样，这就是tomcat生命周期的管理方式。

Catalina中还有个await方法很重要,此方法直接调用 了Server的await方法，这个方法的作用是进入一个循环，让主线程不会退出。

Tomcat的入口org.apache.catalina.startup.Bootstrap.main(),
Bootstrap的作用类似一个CatalinaAdaptor，具体过程还是使用Catalina来完成，这么做的好处是可以把启动的入口和具体的管理类分开，这样可以就可以方便创建出多种启动方式 ，每种启动方式只需要写一个相应的CatalinaAdaptor就可以了。

Bootstrap是Tomcat的入口，正常情况下启动Tomcat就是调用的Bootstrap的main方法，其代码如下：
// org.apache.catalina.startup.Bootstrap
public static void main(String args[]) {
// 先新建一个Bootstrap
if (daemon == null) {
Bootstrap bootstrap = new Bootstrap();
try {
//初始化了ClassLoader，并用ClassLoader创建了Catalina实例，赋给catalinaDaemon变量
bootstrap.init();
} catch (Throwable t) {

handleThrowable(t);
t.printStackTrace();
return;
}
daemon = bootstrap;
} else {
Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);
}
try {
String command = "start";
if (args.length > 0) {
command = args[args.length - 1];
}
if (command.equals("startd")) {
args[args.length - 1] = "start";

daemon.load(args);
daemon.start();
} else if (command.equals("stopd")) {
args[args.length - 1] = "stop";
daemon.stop();
} else if (command.equals("start")) {
daemon.setAwait(true);
daemon.load(args);
daemon.start();
} else if (command.equals("stop")) {
daemon.stopServer(args);
} else if (command.equals("configtest")) {
daemon.load(args);

if (null==daemon.getServer()) {
System.exit(1);
}
System.exit(0);
} else {
log.warn("Bootstrap: command \"" + command + "\" does not exist.");
}
} catch (Throwable t) {
if (t instanceof InvocationTargetException &&
t.getCause() != null) {
t = t.getCause();
}
handleThrowable(t);
t.printStackTrace();

System.exit(1);
}
}
可以看到这里的main非常简单，只有两部分内容：首先新建了Bootstrap，并执行init方法初始化；然后处理main方法传入的命令，如果args参数为空，默认执行start。
在init方法里初始化了ClassLoader，并用ClassLoader创建了Catalina实例，然后赋给catalinaDaemon变量，后面对命令的操作都要使用catalinaDaemon来具体执行。
对start命令的处理调用了三个方法：setAwait（true）、load（args）和start()。这三个方法内部都调用了Catalina的相应方法进行具体执行，只不过是用反射来调用的。start方法（另外两个方法会处理一些参数，调用方法类似）的代码如下：

// org.apache.catalina.startup.Bootstrap
public void start()
throws Exception {
if( catalinaDaemon==null ) init();

Method method = catalinaDaemon.getClass().getMethod("start", (Class [] )null);
method.invoke(catalinaDaemon, (Object [])null);
}
这里首先判断catalinaDaemon有没有初始化，如果没有则调用init方法对其进行初始化，然后使用Method进行反射调用Catalina的start方法。Method是java.lang.reflect包里的

类，代表一个具体的方法，可以使用其中的invoke方法来执行所代表的方法，invoke方法有两个参数，第一参数是Method方法所在的实体，第二个参数是可变参数用于Method方法执行时所需要的参数，所以上面的调用相当于（（Catalina）catalinaDaemon）.start()。setAwait和load也用类似的方法调用了Catalina中的setAwait和load方法。
7.1.3Catalina的启动过程
从前面的内容可以知道，Catalina的启动主要是调用setAwait、load和start方法来完成的。setAwait方法用于设置Server启动完成后是否进入等待状态的标志，如果为true则进入，否则不进入；load方法用于加载配置文件，创建并初始化Server；start方法用于启动服务器。下面分别来看一下这三个方法。

首先来看setAwait方法，代码如下：
// org.apache.catalina.startup.Catalina
public void setAwait(boolean b) {
await = b;
}
这个方法非常简单，就是设置await属性的值，await属性会在start方法中的服务器启动完之后使用它来判断是否进入等待状态。
Catalina的load方法根据conf/server.xml创建了Server对象，并赋值给server属性（具体解析操作是通过开源项目Digester完成的），然后调用了server的init方法，代码如下：
// org.apache.catalina.startup.Catalina
public void load() {

long t1 = System.nanoTime();
// 省略创建 server代码，创建过程使用Digester完成
try {
getServer().init();
} catch (LifecycleException e) {
if (Boolean.getBoolean("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE")) {
throw new java.lang.Error(e);
} else {
log.error("Catalina.start", e);
}
}

long t2 = System.nanoTime();
if(log.isInfoEnabled()) {

//启动过程中，控制台可以看到
log.info("Initialization processed in " + ((t2 - t1) / 1000000) + " ms");
}
}
Catalina的start方法主要调用了server的start方法启动服务器，并根据await属性判断是否让程序进入了等待状态，代码如下：
//org.apache.catalina.startup.Catalina
public void start() {
if (getServer() == null) {
load();
}
long t1 = System.nanoTime();
try {

// 调用Server的start方法启动服务器
getServer().start();
} catch (LifecycleException e) {
log.fatal(sm.getString("catalina.serverStartFail"), e);
try {
getServer().destroy();
} catch (LifecycleException e1) {
log.debug("destroy() failed for failed Server ", e1);
}
return;
}

long t2 = System.nanoTime();
if(log.isInfoEnabled()) {

log.info("Server startup in " + ((t2 - t1) / 1000000) + " ms");
}
// 此处省略了注册关闭钩子代码
// 进入等待状态
if (await) {
await();
stop();
}
}
这里首先判断Server是否已经存在了，如果不存在则调用load方法来初始化Server，然后调用Server的start方法来启动服务器，最后注册了关闭钩子并根据await属性判断是否进入等待状态，之前我们已将这里的await属性设置为true了，所以需要进入等待状态。进入等待状态会调用await和stop两个方法，await方法直接调用了Server的await方法，Server的await方法内部会执行一个while循环，这样程序就停到了await方法，当await方法里的while循环退出时，就会执行stop方法，从而关闭服务器。
7.1.4Server的启动过程
Server接口中提供addService（Service service）、removeService（Service
service）来添加和删除Service，Server的init方法和start方法分别循环调用了每个Service的init方法和start方法来启动所有Service。
Server的默认实现是org.apache.catalina.core.StandardServer，StandardServer继承自Lifecycle-MBeanBase，LifecycleMBeanBase又继承自LifecycleBase，init和start方法就定义在了LifecycleBase中，LifecycleBase里的init方法和start方法又调用initInternal方法和startInternal方法，这两个方法都是模板方法，由子类具体实现，所以调用StandardServer的init和start方法时会执行StandardServer自己的initInternal和startInternal方法，这就是Tomcat生命周期的管理方式，更详细的过程见7.2节。StandardServer中的initInternal和startInternal方法分别循环调用了每一个service的start和init方法，代码如下：
//org.apache.catalina.core.StandardServer
protected void startInternal() throws LifecycleException {
……
synchronized (servicesLock) {
for (int i = 0; i < services.length; i++) {
services[i].start();
}
}
}
protected void initInternal() throws LifecycleException {
……
for (int i = 0; i < services.length; i++) {
services[i].init();
}
}
除了startInternal和initInternal方法，StandardServer中还实现了await方法，Catalina中就是调用它让服务器进入等待状态的，其核心代码如下：

//org.apache.catalina.core.StandardServer
public void await() {
// 如果端口为-2则不进入循环，直接返回
if( port == -2 ) {