1.springbean初始化和实例化？
2.学习编程｜Spring源码深度解析 读书笔记 第4章：bean的加载
3.php,jsp,asp三者优缺点...
4.如何理解@Resource和@Reference的区别
5.Spring系列随笔1-Bean(小白入门篇)

springbean初始化和实例化？

       spring配置bean实例化有哪些方式

       1.实例化bean的三种方法:

       （1）构造器

       !--体验1--

       beanid="personService"class="com.persia.PersonServiceBean"

       !--index代表方法的参数序号，由0开始，基本的类型Type可以不声明--

       constructor-argindex="0"value="构造注入的name"/

       constructor-argindex="1"type="com.persia.IDaoBean"ref="personDao"/

       /bean

       对应类

       publicPersonServiceBean(Stringname,IDaoBeanpersonDao){

       this.name=name;

       this.personDao=personDao;

       }

       !--体现2--

       beanid="personDao"class="cn.itcast.dao.impl.PersonDaoBean"/

       beanid="personServiceBean"class="cn.itcast.service.impl.PersonServiceBean"

       lazy-init="true"init-method="init"destroy-method="destory"

       !--ref属性对应idpersonDao值name属性对应接口的getter方法名称--

       propertyname="personDao"ref="personDao"/

       !--体验3--

       !--注入属性值--

       propertyname="name"value=""/

       !--Set的注入--

       propertyname="sets"

       set

       valuesets：第一个值/value

       valuesets：第二个值/value

       valuesets：第三个值/value

       /set

       /property

       !--List的注入--

       propertyname="lists"

       list

       valuelists：第一个值/value

       valuelists：第二个值/value

       valuelists：第三个值/value

       /list

       /property

       !--Properties的注入--

       propertyname="properties"

       props

       propkey="props-key1"：第一个值/prop

       propkey="props-key2"：第二个值/prop

       propkey="props-key3"：第三个值/prop

       /props

       /property

       !--Map的注入--

       propertyname="maps"

       map

       entrykey="maps-key1"value="：第一个值"/

       entrykey="maps-key2"value="：第二个值"/

       entrykey="maps-key3"value="：第三个值"/

       /map

       /property

       /bean

       （2）静态工厂：

       !--静态工厂获取bean--

       beanid="personService2"class="com.persia.PersonServiceBeanFactory"factory-method="createInstance"/

       对应类

       publicstaticPersonServiceBeancreateInstance(){

       returnnewPersonServiceBean();

       }

       （3）实例工厂：

       没有静态方法，因此配置时，先实例化工厂，在实例化需要的源码编辑器素材下载bean。

       !--实例工厂获取bean，先实例化工厂再实例化bean--

       beanid="fac"class="com.persia.PersonServiceBeanInsFactory"/

       beanid="personService3"factory-bean="fac"factory-method="createInstance"/

       对应类

       publicPersonServiceBeancreateInstance(){

       returnnewPersonServiceBean();

       }

       2.bean的作用域

       默认情况为单例方式：scope=”singleton”

       singleton

       单实例作用域，这是Spring容器默认的作用域，使用singleton作用域生成的是单实例，在整个Bean容器中仅保留一个实例对象供所有调用者共享引用。单例模式对于那些无会话状态的Bean（如辅助工具类、DAO组件、业务逻辑组件等）是最理想的选择。

       prototype

       原型模式，这是多实例作用域，针对每次不同的请求，Bean容器均会生成一个全新的Bean实例以供调用者使用。prototype作用域非常适用于那些需要保持会话状态的Bean实例，有一点值得注意的就是，Spring不能对一个prototype

       Bean的整个生命周期负责，容器在初始化、装配好一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。因此，客户端要负责prototype实例的生命周期管理。

       request

       针对每次HTTP请求，Spring容器会根据Bean的定义创建一个全新的Bean实例，

       且该Bean实例仅在当前HTTPrequest内有效，因此可以根据需要放心地更改所建实例的内部状态，

       而其他请求中根据Bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。

       当处理请求结束，checkstyle 源码request作用域的Bean实例将被销毁。该作用域仅在基于web的Spring

       ApplicationContext情形下有效。

       session

       针对某个HTTP

       Session，Spring容器会根据Bean定义创建一个全新的Bean实例，且该Bean实例仅在当前HTTPSession内有效。

       与request作用域一样，我们可以根据需要放心地更改所创建实例的内部状态，而别的HTTPSession中根据Bean定义创建的实例，

       将不会看到这些特定于某个HTTPSession的状态变化。当HTTPSession最终被废弃的时候，在该HTTP

       Session作用域内的Bean实例也会被废弃掉。该作用域仅在基于Web的SpringApplicationContext情形下有效。

       globalsession

       global

       session作用域类似于标准的HTTP

       Session作用域，不过它仅仅在基于portlet的Web应用中才有意义。portlet规范定义了全局Session的概念，它被所有构成某个portlet

       Web应用的各种不同的portlet所共享。在globalsession作用域中定义的Bean被限定于全局portlet

       Session的生命周期范围内。如果我们是在编写一个标准的基于Servlet的Web应用，并且定义了一个或多个具有global

       session作用域的Bean，系统会使用标准的HTTPSession作用域，并且不会引起任何错误。该作用域仅在基于Web的Spring

       ApplicationContext情形下有效。

       3.bean的生命周期

       （1）什么时候实例化？

       对于单例的形式，在容器实例化的时候对bean进行实例化的。

       ApplicationContextctx=newClassPathXmlApplicationContext(newString[]{ "applicationContext.xml"});

       单实例可以通过lazy-init=”true”，在getBean时进行实例化。

       在beans里面default-lazy-init=”true”对所有bean进行延迟处理。

       对于prototype，则是在getBean的时候被实例化的。

       （2）在bean被实例化之后执行资源操作等方法：

       Init-method=””

       （3）在bean销毁之前执行的方法：

       Destroy-method=””

       什么时候被销毁？随着spring容器被关闭时被销毁。

       调用spring容器的close方法来正常关闭。以前是随着应用程序执行完而关闭。

       在Spring装载配置文件后，postdelay源码Spring工厂实例化完成，开始处理

       （1）使用默认构造方法或指定构造参数进行Bean实例化。

       （2）根据property标签的配置调用Bean实例中的相关set方法完成属性的赋值。

       （3）如果Bean实现了BeanNameAware接口，则调用setBeanName()方法传入当前Bean的ID。

       （4）如果Bean实现了BeanFactoryAware接口，则调用setBeanFactory()方法传入当前工厂实例的引用。

       （5）如果Bean实现了ApplicationContextAware接口，则调用setApplicationContext()方法传入当前ApplicationContext实例的引用。

       （6）如果有BeanPostProcessor与当前Bean关联，则与之关联的对象的postProcess-BeforeInitialzation()方法将被调用。

       （7）如果在配置文件中配置Bean时设置了init-method属性，则调用该属性指定的初始化方法。

       （8）如果有BeanPostProcessor与当前Bean关联，则与之关联的对象的postProcess-AfterInitialzation()方法将被调用。

       （9）Bean实例化完成，处于待用状态，可以被正常使用了。

       （）当Spring容器关闭时，如果Bean实现了DisposableBean接口，则destroy()方法将被调用。

       （）如果在配置文件中配置Bean时设置了destroy-method属性，则调用该属性指定的方法进行销毁前的一些处理。

       （）Bean实例被正常销毁。

       Spring系列（一）SpringMVCbean解析、注册、实例化流程源码剖析

       最近在使用SpringMVC过程中遇到了一些问题，网上搜索不少帖子后虽然找到了答案和解决方法，但这些答案大部分都只是给了结论，并没有说明具体原因，感觉总是有点不太满意。

       更重要的是这些所谓的结论大多是抄来抄去，基本源自一家，powerdns源码真实性也有待考证。

       那作为程序员怎么能知其所以然呢？

       此处请大家内心默读三遍。

       用过Spring的人都知道其核心就是IOC和AOP，因此要想了解Spring机制就得先从这两点入手，本文主要通过对IOC部分的机制进行介绍。

       在开始阅读之前，先准备好以下实验材料。

       IDEA是一个优秀的开发工具，如果还在用Eclipse的建议切换到此工具进行。

       IDEA有很多的快捷键，在分析过程中建议大家多用Ctrl+Alt+B快捷键，可以快速定位到实现函数。

       Springbean的加载主要分为以下6步：

       查看源码第一步是找到程序入口，再以入口为突破口，一步步进行源码跟踪。

       JavaWeb应用中的入口就是web.xml。

       在web.xml找到ContextLoaderListener，此Listener负责初始化SpringIOC。

       contextConfigLocation参数设置了bean定义文件地址。

       下面是ContextLoaderListener的官方定义：

       翻译过来ContextLoaderListener作用就是负责启动和关闭SpringrootWebApplicationContext。

       具体WebApplicationContext是什么？开始看源码。

       从源码看出此Listener主要有两个函数，一个负责初始化WebApplicationContext，一个负责销毁。

       继续看initWebApplicationContext函数。

       在上面的代码中主要有两个功能：

       进入CreateWebAPPlicationContext函数

       进入determineContextClass函数。

       进入configureAndReFreshWebApplicaitonContext函数。

       WebApplicationContext有很多实现类。但从上面determineContextClass得知此处wac实际上是XmlWebApplicationContext类，因此进入XmlWebApplication类查看其继承的refresh()方法。

       沿方法调用栈一层层看下去。

       获取beanFactory。

       beanFactory初始化。劳务 源码

       加载bean。

       读取XML配置文件。

       XmlBeanDefinitionReader读取XML文件中的bean定义。

       继续查看loadBeanDefinitons函数调用栈，进入到XmlBeanDefinitioReader类的loadBeanDefinitions方法。

       最终将XML文件解析成Document文档对象。

       上一步完成了XML文件的解析工作，接下来将XML中定义的bean注册到webApplicationContext，继续跟踪函数。

       用BeanDefinitionDocumentReader对象来注册bean。

       解析XML文档。

       循环解析XML文档中的每个元素。

       下面是默认命名空间的解析逻辑。

       不明白Spring的命名空间的可以网上查一下，其实类似于package，用来区分变量来源，防止变量重名。

       这里我们就不一一跟踪，以解析bean元素为例继续展开。

       解析bean元素，最后把每个bean解析为一个包含bean所有信息的BeanDefinitionHolder对象。

       接下来将解析到的bean注册到webApplicationContext中。接下继续跟踪registerBeanDefinition函数。

       跟踪registerBeanDefinition函数，此函数将bean信息保存到到webApplicationContext的beanDefinitionMap变量中，该变量为map类型，保存Spring容器中所有的bean定义。

       Spring实例化bean的时机有两个。

       一个是容器启动时候，另一个是真正调用的时候。

       相信用过Spring的同学们都知道以上概念，但是为什么呢？

       继续从源码角度进行分析，回到之前XmlWebApplication的refresh（）方法。

       可以看到获得beanFactory后调用了finishBeanFactoryInitialization()方法，继续跟踪此方法。

       预先实例化单例类逻辑。

       获取bean。

       doGetBean中处理的逻辑很多，为了减少干扰，下面只显示了创建bean的函数调用栈。

       创建bean。

       判断哪种动态代理方式实例化bean。

       不管哪种方式最终都是通过反射的形式完成了bean的实例化。

       我们继续回到doGetBean函数，分析获取bean的逻辑。

       上面方法中首先调用getSingleton(beanName)方法来获取单例bean，如果获取到则直接返回该bean。方法调用栈如下：

       getSingleton方法先从singletonObjects属性中获取bean对象,如果不为空则返回该对象，否则返回null。

       那singletonObjects保存的是什么？什么时候保存的呢？

       回到doGetBean（）函数继续分析。如果singletonObjects没有该bean的对象，进入到创建bean的逻辑。处理逻辑如下：

       下面是判断容器中有没有注册bean的逻辑，此处beanDefinitionMap相信大家都不陌生，在注册bean的流程里已经说过所有的bean信息都会保存到该变量中。

       如果该容器中已经注册过bean，继续往下走。先获取该bean的依赖bean，如果镩子依赖bean，则先递归获取相应的依赖bean。

       依赖bean创建完成后，接下来就是创建自身bean实例了。

       获取bean实例的处理逻辑有三种，即Singleton、Prototype、其它(request、session、globalsession)，下面一一说明。

       如果bean是单例模式，执行此逻辑。

       获取单例bean，如果已经有该bean的对象直接返回。如果没有则创建单例bean对象，并添加到容器的singletonObjectsMap中，以后直接从singletonObjects直接获取bean。

       把新生成的单例bean加入到类型为MAP的singletonObjects属性中，这也就是前面singletonObjects（）方法中获取单例bean时从此Map中获取的原因。

       Prototype是每次获取该bean时候都新建一个bean，因此逻辑比较简单，直接创建一个bean后返回。

       从相应scope获取对象实例。

       判断scope，获取实例函数逻辑。

       在相应scope中设置实例函数逻辑。

       以上就是Springbean从无到有的整个逻辑。

       从源码角度分析bean的实例化流程到此基本接近尾声了。

       回到开头的问题，ContextLoaderListener中初始化的WebApplicationContext到底是什么呢？

       通过源码的分析我们知道WebApplicationContext负责了bean的创建、保存、获取。其实也就是我们平时所说的IOC容器，只不过名字表述不同而已。

       本文主要是讲解了XML配置文件中bean的解析、注册、实例化。对于其它命名空间的解析还没有讲到，后续的文章中会一一介绍。

       希望通过本文让大家在以后使用Spring的过程中有“一切尽在掌控之中”的感觉，而不仅仅是稀里糊涂的使用。

SpringBean的初始化

       本文基于上一篇文章进行续写

       上一篇文章地址:SpringBean实例化及构造器选择

       1.BeanPostProcessor

       查看源码发现BeanPostProcessor提供了两个初始化前后的方法,新建一个接口并重写该接口的这两个方法

       1.新建一个InstantiationAwareBeanPostProcessorSpring方法并实现InstantiationAwareBeanPostProcessor接口

       InstantiationAwareBeanPostProcessor实现了BeanPostProcessor,所以此处使用InstantiationAwareBeanPostProcessorSpring也可以调用上述2个接口方法

       2.UserService类实现InitializingBean接口,并重写afterPropertiesSet方法

       3.利用客户端进行调用

       4.运行结果

spring的bean到底在什么时候实例化

       spring的bean在被依赖的时候实例化；

       分为以下几种Bean：

       1.如果指定的是convertrService,beanPostProcessor等实例的时候，则会在ApplicationContext初始化的时候就实例化；

       2.如果指定的是自定义的Bean，那么会在第一次访问的时候实例化；

       [被依赖的时候实例化,更明确的说是第一次访问]

springioc容器之Bean实例化和依赖注入 spring中的bean对象和java对象是有些许差别的，spring中的bean包含了java对象，并且是基于java对象在spring中做了一些列的加工，所以说spring中的bean比java对象更加丰富。在spring中bean的实例化有2个时机：

下面从springioc容器初始化的时候，预实例化的bean为线索来追溯bean的实例化和依赖注入过程，这个过程涵盖了getBean方法。

在springioc容器初始化的时候，触发了所有预实例化的bean的加载，这里必须是非抽象、单例和非懒加载的bean才符合条件进行预实例化。具体bean的实例化是在getBean方法中。

这里通过getSingleton先从缓存中获取bean实例。

从缓存中获取很好理解，分别从spring容器的一级缓存singletonObjects、二级缓存earlySingletonObjects和三级缓存singletonFactories中获取bean实例。在初次获取bean的时候，这里的缓存肯定为空的，但是对于存在循环依赖的bean，这里的一级或二级缓存就不是空的。在有循环依赖的bean中，这里一级缓存会存在不为空的情况，这个时候通过singletonFactory.getObject的时候，返回的可能是一个bean实例，也有可能是一个提前进行aop的代理对象(正常情况下aop是发生在bean初始化的时候完成的)，对于有循环依赖并且需要进行aop的bean，在这里会进行提前aop代理对象的生成。

当缓存中没有找到bean实例的时候：

通过singletonFactory.g

学习编程｜Spring源码深度解析 读书笔记 第4章：bean的加载

       在Spring框架中，bean的加载过程是一个精细且有序的过程。首先，当需要加载bean时，Spring会尝试通过转换beanName来识别目标对象，可能涉及到别名或FactoryBean的识别。

       加载过程分为几步：从缓存查找单例，Spring容器内单例只创建一次，若缓存中无数据，会尝试从singletonFactories寻找。接着是bean的实例化，从缓存获取原始状态后，可能需要进一步处理以符合预期状态。

       原型模式的依赖检查是单例模式特有的，用来避免循环依赖问题。然后，如果缓存中无数据，会检查parentBeanFactory，递归加载配置。BeanDefinition会被转换为RootBeanDefinition，合并父类属性，确保依赖的正确初始化。

       Spring根据不同的scope策略创建bean，如singleton、prototype等。类型转换是后续步骤，可能将返回的bean转换为所需的类型。FactoryBean的使用提供了灵活的实例化逻辑，用户自定义创建bean的过程。

       当bean为FactoryBean时，getBean()方法代理了FactoryBean的getObject()，允许通过不同的方式配置bean。缓存中获取单例时，会执行循环依赖检测和性能优化。最后，通过ObjectFactory实例singletonFactory定义bean的完整加载逻辑，包括回调方法用于处理单例创建前后的状态。

php,jsp,asp三者优缺点...

       JSP ASP PHP

       è¿è¡Œé€Ÿåº¦ å¿« 较快 较快

       è¿è¡Œè€—损 较小 较大 较大

       éš¾æ˜“程度 容易掌握 简单 简单

       è¿è¡Œå¹³å° 绝大部分平台均可 Windows平台 Windows/UNIX平台

       æ‰©å±•æ€§ 好 较好 较差

       å®‰å…¨æ€§ 好 较差 好

       å‡½æ•°æ€§ 多 较少 多

       æ•°æ®åº“支持 多 多 多

       åŽ‚商支持 多 较少 较多

       å¯¹XML的支持 支持 不支持 支持

       å¯¹ç»„件的支持 支持 支持 不支持

       å¯¹åˆ†å¸ƒå¼å¤„理的支持 支持 支持 不支持

       åº”用程序 较广 较广 较广

       ----------------------------------------------------

       è½¬è½½:

        慢慢看吧!

        ASP、JSP与PHP的比较

        目前，最常用的三种动态网页语言有ASP(Active Server Pages),JSP(Java Server Pages),

        PHP (Hypertext Preprocessor)。

        简 介

        ASP全名Active Server Pages，是一个WEB服务器端的开发环境， 利用它可以产生和运

        行动态的、交互的、高性能的WEB服务应用程序。ASP采用脚本语言VB Script（Java script

        ）作为自己的开发语言。

        PHP是一种跨平台的服务器端的嵌入式脚本语言. 它大量地借用C,Java和Perl语言的语法

        , 并耦合PHP自己的特性,使WEB开发者能够快速地写出动态生成页面.它支持目前绝大多数数

        据库。还有一点，PHP是完全免费的，不用花钱，你可以从PHP官方站点(

        t)自由下载。而且你可以不受限制地获得源码，甚至可以从中加进你自己需要的特色。

        JSP 是Sun公司推出的新一代站点开发语言，他完全解决了目前ASP,PHP的一个通病－－

        脚本级执行（据说PHP4 也已经在Zend 的支持下，实现编译运行）.Sun 公司借助自己在Jav

        a 上的不凡造诣，将Java 从Java 应用程序 和 Java Applet 之外，又有新的硕果，就是Js

        p－－Java Server Page。Jsp 可以在Serverlet和JavaBean的支持下，完成功能强大的站点

        程序。

        三者都提供在 HTML 代码中混合某种程序代码、由语言引擎解释执行程序代码的能力。

        但JSP代码被编译成 Servlet 并由 Java 虚拟机解释执行，这种编译操作仅在对 JSP 页面的

        第一次请求时发生。在 ASP 、PHP、JSP 环境下， HTML 代码主要负责描述信息的显示样式

        ，而程序代码则用来描述处理逻辑。普通的 HTML 页面只依赖于 Web 服务器，而 ASP 、PH

        P、JSP 页面需要附加的语言引擎分析和执行程序代码。程序代码的执行结果被重新嵌入到

        HTML 代码中，然后一起发送给浏览器。 ASP 、PHP、 JSP三者都是面向 Web 服务器的技术

        ，客户端浏览器不需要任何附加的软件支持。

        技术特点

        ASP:

        1. 使用 VBScript 、 JScript 等简单易懂的脚本语言，结合 HTML 代码，即可快速地完成

        网站的应用程序。

        2. 无须 compile 编译，容易编写，可在服务器端直接执行。

        3. 使用普通的文本编辑器，如 Windows 的记事本，即可进行编辑设计。

        4. 与浏览器无关 (Browser Independence), 用户端只要使用可执行 HTML 码的浏览器，即

        可浏览 Active Server Pages 所设计的网页内容。 Active Server Pages 所使用的脚本语

        言 (VBScript 、 Jscript) 均在 WEB 服务器端执行，用户端的浏览器不需要能够执行这些

        脚本语言。

        5.Active Server Pages 能与任何 ActiveX scripting 语言相容。除了可使用 VBScript

        或 JScript 语言来设计外，还通过 plug－in 的方式，使用由第三方所提供的其他脚本语言

        ，譬如 REXX 、 Perl 、 Tcl 等。脚本引擎是处理脚本程序的 COM(Component Object Mod

        el) 物件。

        6. 可使用服务器端的脚本来产生客户端的脚本。

        7.ActiveX Server Components(ActiveX 服务器元件 ) 具有无限可扩充性。可以使用 Vi

        sual Basic 、 Java 、 Visual C＋＋ 、 COBOL 等编程语言来编写你所需要的ActiveX Se

        rver Component 。

        PHP:

        1．数据库连接

        PHP可以编译成具有与许多数据库相连接的函数。PHP与MySQL是现在绝佳的组合。你还可

        以自己编写外围的函数取间接存取数据库。通过这样的途径当你更换使用的数据库时，可以

        轻松地更改编码以适应这样的变。PHPLIB就是最常用的可以提供一般事务需要的一系列基库

        。但PHP提供的数据库接口支持彼此不统一，比如对Oracle, MySQL， Sybase的接口，彼此

        都不一样。这也是PHP的一个弱点。

        2．面向对象编程

        PHP提供了类和对象。基于web的编程工作非常需要面向对象编程能力。PHP支持构造器、

        提取类等。

        JSP:

        1．将内容的生成和显示进行分离

        使用JSP技术，Web页面开发人员可以使用HTML或者XML标识来设计和格式化最终页面。使

        用JSP标识或者小脚本来生成页面上的动态内容。生成内容的逻辑被封装在标识和JavaBeans

        组件中，并且捆绑在小脚本中，所有的脚本在服务器端运行。如果核心逻辑被封装在标识和

        Beans中，那么其他人，如Web管理人员和页面设计者，能够编辑和使用JSP页面，而不影响内

        容的生成。

        在服务器端，JSP引擎解释JSP标识和小脚本，生成所请求的内容（例如，通过访问Java

        Beans组件，使用JDBCTM技术访问数据库，或者包含文件），并且将结果以HTML（或者XML）

        页面的形式发送回浏览器。这有助于作者保护自己的代码，而又保证任何基于HTML的Web浏览

        器的完全可用性。

        2．强调可重用的组件

        绝大多数JSP页面依赖于可重用的，跨平台的组件（JavaBeans或者Enterprise JavaBea

        nsTM组件）来执行应用程序所要求的更为复杂的处理。开发人员能够共享和交换执行普通操

        作的组件，或者使得这些组件为更多的使用者或者客户团体所使用。基于组件的方法加速了

        总体开发过程，并且使得各种组织在他们现有的技能和优化结果的开发努力中得到平衡。

        3．采用标识简化页面开发

        Web页面开发人员不会都是熟悉脚本语言的编程人员。JavaServer Page技术封装了许多

        功能，这些功能是在易用的、与JSP相关的XML标识中进行动态内容生成所需要的。标准的JS

        P标识能够访问和实例化JavaBeans组件，设置或者检索组件属性，下载Applet，以及执行用

        其他方法更难于编码和耗时的功能。

        通过开发定制化标识库，JSP技术是可以扩展的。今后，第三方开发人员和其他人员可以

        为常用功能创建自己的标识库。这使得Web页面开发人员能够使用熟悉的工具和如同标识一样

        的执行特定功能的构件来工作。

        JSP技术很容易整合到多种应用体系结构中，以利用现存的工具和技巧，并且扩展到能够

        支持企业级的分布式应用。作为采用Java技术家族的一部分，以及Java 2（企业版体系结构

        ）的一个组成部分，JSP技术能够支持高度复杂的基于Web的应用。

        由于JSP页面的内置脚本语言是基于Java编程语言的，而且所有的JSP页面都被编译成为

        Java Servlet，JSP页面就具有Java技术的所有好处，包括健壮的存储管理和安全性。

        作为Java平台的一部分，JSP拥有Java编程语言“一次编写，各处运行”的特点。随着越

        来越多的供应商将JSP支持添加到他们的产品中，您可以使用自己所选择的服务器和工具，更

        改工具或服务器并不影响当前的应用。

        应用范围

        ASP是Microsoft开发的动态网页语言，也继承了微软产品的一贯传统——只能运行于微软

        的服务器产品,IIS (Internet Information Server) (windows NT)和PWS(Personal Web Se

        rver)(windows )上。Unix下也有ChiliSoft的插件来支持ASP，但是ASP本身的功能有限，

        必须通过ASP＋COM的组合来扩充，Unix下的COM实现起来非常困难。

        PHP3可在Windows,Unix,Linux的Web服务器上正常运行,还支持IIS,Apache等通用Web服务器

        ,用户更换平台时,无需变换PHP3代码,可即拿即用.

        JSP同PHP3类似，几乎可以运行于所有平台。如Win NT,Linux,Unix. NT下IIS通过一个插

        件，例如JRUN或者ServletExec，就能支持JSP。著名的Web服务器Apache已经能够支持JSP。

        由于Apache广泛应用在NT、Unix和Linux上，因此JSP有更广泛的运行平台。虽然现在NT操作

        系统占了很大的市场份额，但是在服务器方面Unix的优势仍然很大，而新崛起的Linux更是来

        势不小。从一个平台移植到另外一个平台，JSP和JavaBean甚至不用重新编译，因为Java字节

        码都是标准的与平台无关的。

        性能比较

        有人做过试验，对这三种语言分别做循环性能测试及存取Oracle数据库测试。

        在循环性能测试中，JSP只用了令人吃惊的四秒钟就结束了＊的循环。而ASP

        、PHP测试的是＊循环（少一个数量级），却分别用了秒和秒。（参考PHPLIB）

        。

        数据库测试中，三者分别对 Oracle 8 进行 次 Insert,Update,Select,和Delete

        ： Jsp 需要 秒，Php 需要 秒，ASP则 需要 秒。

        前景分析

        目前在国内PHP与ASP应用最为广泛。而JSP由于是一种较新的技术，国内采用的较少。但在

        国外，JSP已经是比较流行的一种技术，尤其是电子商务类的网站，多采用JSP。

        采用PHP的网站如新浪网（sina）、中国人（Chinaren）等,但由于PHP本身存在的一些缺

        点，使得它不适合应用于大型电子商务站点，而更适合一些小型的商业站点。

        首先，PHP缺乏规模支持。其次，缺乏多层结构支持。对于大负荷站点，解决方法只有一

        个：分布计算。数据库、应用逻辑层、表示逻辑层彼此分开，而且同层也可以根据流量分开

        ，组成二维阵列。而PHP则缺乏这种支持。还有上面提到过的一点，PHP提供的数据库接口支

        持不统一，这就使得它不适合运用在电子商务中。

        ASP和JSP则没有以上缺陷，ASP可以通过Microsoft Windowsd的COM/DCOM获得ActiveX规

        模支持，通过DCOM和Transcation Server获得结构支持；JSP可以通过SUN Java的Java Clas

        s和EJB获得规模支持，通过EJB/CORBA以及众多厂商的Application Server获得结构支持。

        三者中，JSP应该是未来发展的趋势。世界上一些大的电子商务解决方案提供商都采用J

        SP/Servlet。比较出名的如IBM的E－business，它的核心是采用JSP/Servlet的WebSphere；

        西方另外一个非常著名的电子商务软件提供商，Intershop。它原来的产品Intershop1 2, 3

        , 4占据了主要的电子商务软件份额。它们都是通过CGI来提供支持 的。但去年月后它推出

        了Enfinity，一个采用JSP/Servlet的电子商务Application Server，而且声言不再开发传统

        软件。

        总之

        ASP，PHP,JSP三者都有相当数量的支持者，由此也可以看出三者各有所长。正在学习或

        使用动态页面的朋友可根据三者的特点选择一种适合自己的语言。

如何理解@Resource和@Reference的区别

       1，定义：

        @Resource：spring的注解，作用：spring中获取已经注入到spring中的Bean

        @Reference: dubbo的注解，作用：注入duboo服务的对象

        2，遇到问题：

        本地配置：

        报错：No provider available from registry **** for service ------------

        哇，经典报错，一看错误就以为是生产者没有启动喽，去zk上面看dubbo生产者情况，真的没有，问题好像已经找到了，，等等，忽然发现他为什么去的是 registry 1呢，不应该去1和2都找吗？ 对了，@Reference 注册dubbo不管是什么方式，无非是registry 和 version等指定，由于我没有指定，那按照spring的理解肯定是走自动装配喽，那我这边配置了两个注册中心，是不是他会智能的都找找呢？（不是的，dubbo生产者如果指定多个registry，然后<dubbo:service/>声明的服务会注册到多个注册中心，<dubbo:reference/>消费端多注册中心时是需要指定去哪个注册中心的）我不想在@Reference后面写一大堆，就想走自动化装配，最后找到可以在registry声明时 default 的属性的，

        根据一系列的猜测、我把配置改为了：

        自此问题解决了，，，，，

        我发现新的问题：使用@Reference来注入dubbo服务，那如果我项目中多个地方想使用，我在多个类中使用@Reference ，岂不是注入多个bean了（这个理解是有问题的，这时未意识到）。这显然是有问题的，因此我想将dubbo服务以单例注入到spring中，换成 spring自己的@Resource标签来获取，因此我将配置改成了一下：

        测试一下：确实好使，，自此配置使用方面没什么问题了，符合一个人的正常逻辑了，

        但是还有一个问题，就是：

        “我发现新的问题：使用@Reference来注入dubbo服务，那如果我项目中多个地方想使用，我在多个类中使用@Reference ，岂不是注入多个bean了 ”  è¿™ä¸ªé—®é¢˜çœŸçš„存在吗？

        下面来解答这个问题：

        spring的配置 使用 xml 或者注解 只是 使用方式的不同，@Reference 和 <dubbo:reference/> 的效果应该是是一样的, spring默认注入Bean,scope应该是singleton ,  那我在多个类中使用@Reference 注入同一个dubbo服务应该是在spring中只存在一个了，，事实上的是的，

        多个@Reference 标签 注入配置信息完全相同的 服务 ，是会有服务Bean缓存的，保证只会有一个 服务Bean ,源码如下：  这个方法 generateReferenceBeanCacheKey  是缓存key的获取。。

       private ReferenceBean<?> buildReferenceBean(Reference reference, Class<?> referenceClass) throws Exception {         // 获取服务引用对象的缓存key        String referenceBeanCacheKey = generateReferenceBeanCacheKey(reference, referenceClass);        // 从缓存map中获取服务引用对象        ReferenceBean<?> referenceBean = referenceBeansCache.get(referenceBeanCacheKey);        if (referenceBean == null) {             // 如果引用对象为空，则需要当场创建一个            ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder                    .create(reference, classLoader, applicationContext)                    .interfaceClass(referenceClass);            referenceBean = beanBuilder.build();            //并且放入到缓存map中。            referenceBeansCache.putIfAbsent(referenceBeanCacheKey, referenceBean);        }        return referenceBean;    } private String generateReferenceBeanCacheKey(Reference reference, Class<?> beanClass) {         // 获取接口名称        String interfaceName = resolveInterfaceName(reference, beanClass);        // 通过引用的URl+接口名+接口版本号+接口分组，用来做缓存key        String key = reference.url() + "/" + interfaceName +                "/" + reference.version() +                "/" + reference.group();        Environment environment = applicationContext.getEnvironment();        key = environment.resolvePlaceholders(key);        return key;    }

        自此问题说明完毕。。

        问题整理：

        1，多注册中心时，spring 自动化装配时，需要自己指定 某一个注册中心 或者 将某个注册中心 default设置为true.

        2, @Resource 和 @Reference 都可 注入 dubbo服务但是 概念是不一样的。

        3，@Reference 注解可以在多个类中注入 相同服务Bean 不会造成服务Bean 存在多个。。

        注：源码参考 文章 /article/

Spring系列随笔1-Bean(小白入门篇)

       Spring是Java开发中的重要框架，它作为Java的顶层实现，简化了软件开发工作。在实际项目中，Spring充当成熟的框架基础，提供统一的对象管理和切面编程功能，大大减少了开发量和复杂性。

       Spring的核心在于它的Bean管理机制。一个对象在Spring中就等同于一个Bean，通过“反射+注入+容器”的依赖注入DI方式管理。有三种常见的配置方式：XML配置，XML核心配置加注解扫描，以及完全注解开发。Spring Boot中广泛使用完全注解的方式，比如通过@Configuration和@Bean注解来创建和注入对象。

       自动注入是Bean管理的另一个重要部分，开发者可以通过类型或名称从Spring容器中获取对象，最常见的是使用@Autowired注解，它能根据类型自动绑定对象。默认情况下，Spring的Bean是单例模式，但可通过scope属性调整为多例。

       Spring Bean的生命周期涉及多个步骤，虽然深入理解可能需要阅读源码，但主要可以分为创建、初始化、使用、销毁等阶段，开发者可以在这些阶段插入自定义代码来扩展Bean的行为。