伊人成人在线视频,国产专区一区,久久影院一区二区三区

偉��Spring MVC

improviser — Sun, 04 Nov 2007 02:44:00 GMT

个�h认�ؓSpring其核心是其IOC和AOP斚w��Q�对其SpirngMVC框架�q�不��x��Q�我看好的是JSF�Q�简单易懂。但最�q�由于工作上需要，所以有需要对SpringMVC做个了解学习�Q�因此，本次对SpirngMVC的相遇纯属偶�?...
SpingMVC的架构其实也很简单，它通过一个共通的入门DispatcherServlet来接收所有的request�Q�接下来�Ҏ��request要求的页面通过handler转送给Controller处理�Q�处理结果返回View�l�用��P��因此对SpringMVC来说�Q�其核心为DispatcherServlet�?br /> DispatcherServlet作�ؓ一扇门�Q�我们要使用�q�个门，首先得安装上�q�个门，安装在哪呢？没错�Q�就安装在web.xml�q�个大屋子，象其他servlet一��P��描述servlet的名字和�c�，再给他一个mapping描述对应映射的网��c��在下例中，我们�l�DispatcherServlet的�v名�ؓSpringMVCDemo�Q?/font>�q�让container知道所�?do�l�尾的request都丟�l�dispatcher�?/span>

     < servlet >
         < servlet-name > SpringMVCDemo servlet-name >
         < servlet-class >
            org.springframework.web.servlet.DispatcherServlet
         servlet-class >
         < load-on-startup > 1 load-on-startup >
     servlet >

     < servlet-mapping >
         < servlet-name > SpringMVCDemo servlet-name >
         < url-pattern > *.do url-pattern >
     servlet-mapping >

门安装好了之后，我们需要定义门能打开的范��_��在哪定义呢？��在门的上面贴上一张“入门指导”，介绍从哪斚w��(hello.do)�q�门需要��用何�U�交通方�?springmvcController)�q�去�Q��ƈ定义该交通方式�?/font>

     < bean id ="urlMapping"
        class ="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
         < property name ="mappings" >
             < props >
                 < prop key ="/hello.do" > springmvcController prop >
             props >
         property >
     bean >


     < bean id ="springmvcController"
        class ="org.improviser.webapp.controller.SpringmvcController" >
     bean >

接下来该渲染一下页面了�Q�下面�ؓ渲染所有以 WEB-INF/pages/ 开�?/font>�Q?font color="#0000ff">�q�以.jsp�l�尾的页面�?/font>

     < bean id ="viewResolver"
        class ="org.springframework.web.servlet.view.InternalResourceViewResolver" >
         < property name ="viewClass" >
             < value > org.springframework.web.servlet.view.JstlView value >
         property >
         < property name ="prefix" >
             < value > /WEB-INF/pages/ value >
         property >
         < property name ="suffix" >
             < value > .jsp value >
         property >
     bean >

上面提到的SpringmvcController�Q?/font>现在该作个定义了�Q�该�c�需要实现Controller接口�?/font>

public class SpringmvcController implements Controller {
    /** Logger for this class and subclasses */
    protected final Log logger = LogFactory.getLog(getClass());

    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {

        Map model = new HashMap();

        String str = "卛_��诗�h";
        logger.info("returning hello view with " + currTime);
        model.put("coldice", str);

        return new ModelAndView("hello", "message", model);
    }

�~�写jsp��试��面�?/font>

<html>
    <head>
        <title>Spring Applicationtitle>
    head>
    <body>
        <h1>
            <br />
            Hello
            <c:out value="${message.coldice}" />

            Spring MVC ��试成功�Q?br />        h1>
    body>
html>

现在对以上内容作个�ȝ��Q�正如上面所叙述�Q�SpringMVC框架的处理过�E�机制如下图所�C�，接收��h��面�Q�通过DispatcherServlet映射到相应规则处理，�q�找到相应的控制器，�l�果控制器处理后�q�回相应的页面最后返回给用户�?/font>

improviser 2007-11-04 10:44 发表评论

improviser — Sat, 29 Sep 2007 02:07:00 GMT

   通过�q�几天对Spring的研读，剖析了Spring的基本核心模块——IoC和AOP。今天将对其作个基础性的�ȝ��?br />
     Spring 是一个开源框�Ӟ��是�ؓ了解决企业应用程序开发复杂性而创建的。框架的主要优势之一��是其分层架构，分层架构允许您选择使用哪一个组�Ӟ��模块构徏在核心容器之上，核心容器定义了创建、配�|�和��理 bean 的方�?同时�?J2EE 应用�E�序开发提供集成的框架。其中作为Spring的核心模块即是Spring面向斚w��~�程(AOP)和控制反�?IOC)容器。Spring 设计的核心是 org.springframework.beans 包，BeanFactoryBeanFactory 支持两个对象模型单态和原型�?code>BeanFactory是Spring作�ؓIOC 容器的基��?br />
控制反�{模式�Q�不创徏对象�Q�但是描�q�创建它们的方式。在代码中不直接与对象和服务�q�接�Q�但在配�|�文件中描述哪一个组仉��要哪一��Ҏ��务。容器（�?Spring 框架中是 IOC 容器�Q�负责将�q�些联系在一赗��在典型�?IOC 场景中，容器创徏了所有对象，�q�设�|�必要的属性将它们�q�接在一��P��军_��什么时间调用方法。IOC 的一个实现模�?通过接口、通过 JavaBean 的属性、依赖性以构造函数的形式提供�?br />
    面向斚w��的编�E�，�?AOP�Q�是一�U�编�E�技术，它允许程序员�Ҏ��切关注点或横切典型的职责分界�U�的行�ؓ�Q�例如日志和事务��理�Q�进行模块化。AOP 的核心构造是斚w��Q�它��那些媄响多个类的行为封装到可重用的模块中。AOP �?IOC 是补充性的技术，它们都运用模块化方式解决企业应用�E�序开发中的复杂问题。在典型的面向对象开发方式中�Q�可能要��日志记录语句放在所有方法和 Java �c�M��才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，�q�以声明的方式将它们应用到需要日志的�l��g上。当�Ӟ��优势��是 Java �c�M��需要知道日志服务的存在�Q�也不需要考虑相关的代码。所以，�?Spring AOP �~�写的应用程序代码是松散耦合的。AOP 的功能完全集成到�?Spring 事务��理、日志和其他各种�Ҏ��的上下文中�?/font>

improviser 2007-09-29 10:07 发表评论

improviser — Fri, 28 Sep 2007 17:50:00 GMT

Spring IoC�?Spring AOP�l�合�Q�一起�Ş成了Spring�Q�这样一个有机整体，使得构徏轻量�U�的J2EE架构成�ؓ可能�Q�而且事实证明�Q�非常有效。没有Spring IoC的Spring AOP是不完善的，没有Spring AOP的Spring IoC是不健壮的�?本文研究Spring框架中的面向斚w��~?Aspect-Oriented Programming�Q�AOP)�Q�进而通过例子解析如何�q�用Spring中的所有通知�c�d��和切入点来实现更实用的方面和面向斚w��设计模式�?/font>

    AOP概念�Q?/font>
    Advice�Q?/b>如何��before通知、afterReturning通知和afterThrowing通知声明为bean�?/font>
　Pointcut�Q?/b>如何声明静态切入点逻辑以将XML Spring Bean Configuration文�g中的所有内容联�p�d��一赗��?
　Advisor�Q?/b>兌��切入点定义与通知bean的方式�?/font>

    Spring AOP是��用代理来完成的，Spring 两种方式�Q?span lang="EN-US">JDK动态代理，需要设定一�l�代理接口；CGLIB 代理�Q�可代理接口和类�?span lang="EN-US">Spring提供�?�U�Advice�c�d��Q�Interception Around、Before、After Returning、Throw和Introduction。它们分别在以下情况下被调用�Q�在JointPoint前后、JointPoint前�? JointPoint后、JointPoint抛出异常时、JointPoint调用完毕后�?br />
配置文�g�Q?/b>
1 <beans>
2     <bean id="myAOPProxy"
             class="org.springframework.aop.framework.ProxyFactoryBean">
3         <property name="proxyInterfaces">
4             <value>ITestvalue>
5         property>
6         <property name="target">
7             <ref local = "test"/>
8         property>
9         <property name="interceptorNames">
10             <value>myPotincutAdvisorvalue>
11         property>
12     bean>
13
14     <bean id="test" class="Test"/>
15
16     <bean id="MyInterceptor" class="MethodTimeCostInterceptor"/>
17
18     <bean id="myPotincutAdvisor"
             class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
19         <property name="advice">
20             <ref local="MyInterceptor"/>
21         property>
22         <property name="patterns">
23             <list>
24                 <value>.*value>
25                 <value>.*value>
26             list>
27         property>
28     bean>
29 beans>

分析代码�Q?/font>
1�?span style="color: rgb(0, 0, 0);"><bean id="myAOPProxy"
     class="org.springframework.aop.framework.ProxyFactoryBean">声明注入了代理实例myAOPProxy�?
2�?proxyInterfaces声明��被代理接口ITest�?/span>
3�?target声明被代理目的类�?br />4�?interceptorNames讄��拦截器�ؓmyPotincutAdvisor�?br />5�?patterns为拦截器讄��配匹方式�Q�即在所被配�Ҏ��功的�Ҏ��被调用时执行拦截器内宏V�?/font>

    该配�|�文�Ӟ��指定要加载一个接口与ITest相匹配的bean。该bean随后被关联到Test实现�c�R��看��h��好像是费了很大力气只��Z��加蝲一个简单的bean�q�调用一个方法，但是�q�个配置文�g只是�? Spring框架可以透明地对应用�E�序应用其组件的众多�Ҏ��的一个体�?/font>�?/font>

improviser 2007-09-29 01:50 发表评论

improviser — Wed, 26 Sep 2007 17:00:00 GMT
    国际化支持在实际开发中可能是最常用的特性，本文分析Spring�?/font> ApplicationContext 提供国际化支持，其提供了更加强大的功能，如信息的自动装配以及热部�|�功能（配置文�g修改后自动读取，而无需重新启动应用�E�序�Q��?span lang="EN-US">
    目前Spring中提供了两个 MessageSource接口的实玎ͼ��?span lang="EN-US">ResourceBundleMessageSource�?span lang="EN-US">ReloadableResourceBundleMessageSource�Q�后者提供了无需重启卛_��重新加蝲配置信息的特性�?/font>

    在下面的配置文�g中，通过MessageResource的一个实现类org.springframework.context.support.ResourceBundleMessageSource来获得国际化的信息�?/font>
1 <beans>
2 <description>Spring Quick Startdescription>
3 <bean id="messageSource"
     class="org.springframework.context.support.ResourceBundleMessageSource">
4 <property name="basenames">
5 <list>
6 <value>messagesvalue>
7 list>
8 property>
9 bean>
10 beans>
11

�q�里声明了一个名�?/span> messageSource �?span lang="EN-US">Bean�Q?/span> 注意�Q?/span> 对于Message定义�Q?span lang="EN-US">Bean ID必须�?span lang="EN-US">messageSource�Q�这是目�?span lang="EN-US">Spring的编码规�U�）�Q�对应类�?span lang="EN-US">ResourceBundleMessageSource�?/font>

而其中的basename属性用來设定资源信息文件的前置文�g名称�Q�在本例中�ؓmessages�?span lang="EN-US">Spring会自动在CLASSPATH根�\径中按照如下��序搜寻资源信息文�g�q�进行加载（�?span lang="EN-US">Locale�?span lang="EN-US">zh_CN��Z��Q�其�?span lang="EN-US">Spring在实际上调用�?span lang="EN-US">JDK�?span lang="EN-US">ResourceBundle��d��配置文�g�Q?/font> :

messages_zh_CN.properties

messages_zh.properties

messages.properties

messages_zh_CN.class

messages_zh.class

messages.class

资源配置信息文�g中的内容

1 messages_zh_CN.properties�Q?br />2 userinfo=当前��d��用户: [{0}] ��d��旉��:[{1}]
3 messages_en_US.properties�Q?br />4 userinfo=Current Login user: [{0}] Login time:[{1}]
5

  ��试代码�Q?/font>
1 ApplicationContext ctx =
                new FileSystemXmlApplicationContext("bean.xml");
2 Object[] arg = new Object[]
3 { "Erica", Calendar.getInstance().getTime()
4 };
5 //以系�l�默认Locale加蝲信息(对于中文WinXP而言�Q�默认�ؓzh_CN)
6 String msg = ctx.getMessage("userinfo", arg);
7 System.out.println("Message is ===> "+msg);
8

代码中，我们��一�?span lang="EN-US">Object数组arg作�ؓ参数传递给ApplicationContext.getMessage�Ҏ��Q�这个参��C��包含了出现在最�l�文字信息中的可变内容，ApplicationContext ��根据参��C��?span lang="EN-US">Locale信息对其�q�行处理�Q�如针对不同   Locale讑֮�日期输出格式�Q�，�q�用其替换配�|�文件中�?span lang="EN-US">{n}标识�Q?span lang="EN-US">n代表参数数组中的索引�Q�从1 开始）�?span lang="EN-US">
�q�行上面的代码，得到以下输出的内容：
   Message is ===> |ì〃�?span lang="EN-US">?��|ì???�t???�?span lang="EN-US">: [Erica] |ì???�to〃�?span lang="EN-US">??:[07-9-27 上午1:27]
针对ResourceBundle的编码过�E�中发生的问题。这是由于�{码过�E�中产生的编码问题引发的。比较简单的解决办法是通过JDK提供的�{码工�?span lang="EN-US">native2ascii.exe �q�行转换。执行：native2ascii messages_zh_CN.properties msg.txt�?o:p>再用msg.txt文�g替换Messages_zh_CN.properties       文�g�?/font>
   再次�q�行�C�Z��代码�Q�得到正��输出：
   Message is ===> 当前��d��用户: [Erica] ��d��旉��:[07-9-27 上午1:30]
��试在代码中指定不同�?span lang="EN-US">Locale参数�Q?span lang="EN-US">
String msg = ctx.getMessage("userinfo", arg, Locale.US);再次�q�行�Q�可以看刎ͼ�
Message is ===> Current Login user: [Erica] Login time::[9/27/07 1:35AM]
可见�Q�前者根据当前默�?span lang="EN-US">Locale"zh_CN"�Q?span lang="EN-US">getMessage�Ҏ��自动加蝲�?span lang="EN-US">messages_zh_CN.properties文�g�Q�后�?/span>getMessage�Ҏ��Ҏ��指定�~�码"en_US"加蝲�?span lang="EN-US">messages_en_US.properties文�g�?/span>

improviser 2007-09-27 01:00 发表评论

improviser — Wed, 26 Sep 2007 15:59:00 GMT

本文研究Spring的三�U�依赖注入实现类�?/b>—�?b style="">接口注入�Q?span lang="EN-US">Interface Injection�Q��?/span>讑ր�注入（Setter Injection�Q��?/span>构造子注入�Q?span lang="EN-US">Constructor Injection�Q��?/span>

Type1 接口注入�Q?/span> 传统的创建接口对象的�Ҏ��Q?/span> 借助接口来将调用者与实现者分��R��如下面的代码所�C�：

1 public class ClassA
2 {
3 private InterfaceB clzB;
4 public doSomething()
5 {
6 Ojbect obj = Class.forName(Config.BImplementation).newInstance();
7 clzB = (InterfaceB)obj;
8 clzB.doIt();
9 }
10 …�?br />11 }
12

在代码中创徏InterfaceB实现�cȝ��实例�Q��ƈ��该对象赋予clzB。也��是依据Java中的对象动态多态技术：InterfaceB clzB=new InterfaceBImpleClass();��Z��调用者与实现者在�~�译期分��，于是有了上面的代码，我们�Ҏ��预先在配�|�文件中讑֮�的实现类的类�?span lang="EN-US">(Config.BImplementation)�Q�动�?span lang="EN-US">加蝲实现�c�，�q��过InterfaceB强制转型后�ؓ ClassA所用�?/span>

Type2 讑ր�注入： 在各�U�类型的依赖注入模式中，讑ր�注入模式在实际开发中得到了最�q�泛的应用（其中很大一部分得力�?span lang="EN-US">Spring框架�?/span>
影响�Q��?span lang="EN-US">使用IoC�?span lang="EN-US">Setter注射�Q�一些外部元数据被用于解决依赖性问题。�ƈ且在Spring中，�q�种元数据采取了��单的XML配置文�g的�Ş式�?/font>

下面为某个类的示例代�?span lang="EN-US">
(其中包含有一�?span lang="EN-US">message属性，该类通过�?span lang="EN-US">setMessage()�Ҏ��获得叛_��器所提供的倹{�?

1 public class UpperAction  implements Action
2 {
3   private String message;
4   public String getMessage()
5   {
6     return message;
7   }
8   public void setMessage(String string)
9   {
10     message = string;
11   }
12 }
13

其中message 属性的值通过配置文�g来提�?

1 <bean id="theUpperAction"  class="springj2seapp.UpperAction">
2      <property name="message">
3         <value>HeLLo,UpperAction value>
4     property>
5 bean>
6

Type3 构造子注入�Q?/span> �?span lang="EN-US">Type3�c�d��的依赖注入机制中�Q�依赖关�p�L��通过�c�L��造函数徏立，容器通过调用�cȝ��构造方法，��其所需的依赖关�p�L��入其中�?/font>

�C�Z��代码�Q?br />配置文�g如下
1 <bean id="exampleBean" class="examples.ExampleBean">
2
3   <constructor-arg>
4
5 <ref bean="anotherExampleBean"/>
6 constructor-arg>
7   <constructor-arg><ref bean="yetAnotherBean"/>constructor-arg>
8   <constructor-arg type="int">
9 <value>1value>
10 constructor-arg>
11 bean>
12 <bean id="anotherExampleBean" class="examples.AnotherBean"/>
13 <bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
14

ExampleBean代码�Q?/span>

1 public class ExampleBean
2 {
3     private AnotherBean beanOne;
4     private YetAnotherBean beanTwo;
5     private int i;
6     public ExampleBean(AnotherBean anotherBean, YetAnotherBean yetAnotherBean,
                                                                    int i)
7 {
8         this.beanOne = anotherBean;
9         this.beanTwo = yetAnotherBean;
10         this.i = i;
11     }
12 }
13

当构造方法中带多个不同的基本数据�c�d��的参数时�Q��ؓ了避免��生二义性，可以采用type或�?span lang="EN-US">index来指定构造方法的参数的类型和��序�?/font>
如：
   type�Ҏ��
1 <constructor-arg type="int">
2 <value>7500000value>
3 constructor-arg>
4   <constructor-arg type="java.lang.String">
5 <value>42value>
6 constructor-arg>
7

    index�Ҏ��
1 <bean id="exampleBean" class="examples.ExampleBean">
2   <constructor-arg index="0">
3 <value>7500000value>
4 constructor-arg>
5   <constructor-arg index="1">
6 <value>42value>
7 constructor-arg>
8 bean>
9

�ȝ��Q?/b>
     type1在灵�z�L��、易用性上不如其他两种注入模式�Q?/font> Type2 �?span lang="EN-US">Type3型的依赖注入实现则是目前��L��?span lang="EN-US">IOC实现模式�Q?/span> Type3 �?span lang="EN-US">Type2模式各有千秋�Q��?span lang="EN-US">Spring都对Type3�?span lang="EN-US">Type2�c�d��的依赖注入机制提供了良好支持�?/span> �?span lang="EN-US">Type3�c�d��Z��Q�辅之以Type2�c�d��机制作�ؓ补充�Q�可以达到最好的依赖注入效果�Q�不�q�对于基�?span lang="EN-US">Spring Framework开发的应用而言�Q?span lang="EN-US">Type2使用更加�q�泛�?span lang="EN-US">

improviser 2007-09-26 23:59 发表评论

improviser — Wed, 26 Sep 2007 05:22:00 GMT

   Spring中BeanFactory支持两个对象模型

单态： 模型提供了具有特定名�U�的对象的共享实例，可以在查询时对其�q�行��索�?span lang="EN-US">Singleton 是默认的也是最常用的对象模型。对于无状态 �?服务对象很理惟�?/font>

原型�Q?/span> 模型��保每次��索都会创建单独的对象。在每个用户都需要自��q��对象�Ӟ��原型模型最适合�?/span>

实例�Q?/font>

1  <  beans  >
2
3
4      <bean id="nonSingleton" class="java.lang.String" singleton="true">
5          <constructor-arg>
6               <value>Valuevalue>
7          constructor-arg>
8       bean>
9
10  beans>
11
12 singleton�Q�指定此JavaBean是否采用单例�Q�Singleton�Q�模式，如果设�ؓ"true"�Q�则在BeanFactory作用范围内，只维护此JavaBean  的一个实例，代码通过BeanFactory   获得此JavaBean  实例的引用。反之，如果设�ؓ"false"�Q�则通过BeanFactory获取此Java Bean  实例�Ӟ��BeanFactory每次都将创徏一个新的实例返回�?/span>



     1 public class NonSingleton {
2
3 public static void main(String[] args) {
4
5 BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
6                     "build/beans.xml"));
7
8    String s1 = (String)factory.getBean("nonSingleton");
9    String s2 = (String)factory.getBean("nonSingleton");
10    System.out.println("Identity Equal?: " + (s1 ==s2));
11    System.out.println("Value Equal:? " + s1.equals(s2));
12    System.out.println(s1);
13    System.out.println(s2);
14  }
15 }

   分析�l�果�Q?/font>

   Identity Equal?: true
Value Equal:? true
Value
Value

   ��q��果可以看出由fantory产生的bean对象只有一个�?br />

注意�Q?/span> �?span lang="EN-US">Spring中消除了��q��戯��己来实现Singleton模式的应用，Spring Bean的缺省行为就�?span lang="EN-US">Singleton�Q�不必再��Z��Singleton�~�码�?/font>

improviser 2007-09-26 13:22 发表评论

improviser — Mon, 24 Sep 2007 16:05:00 GMT
本文研究Spring分层Bean Factory用法�Q�先看有关代码：

1 parent.xml
2
3 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
      "http://www.springframework.org/dtd/spring-beans.dtd">
4 <beans>
5     <bean id="injectBean" class="java.lang.String">
6            <constructor-arg>
7                <value>Bean In Parentvalue>
8            constructor-arg>
9     bean>
10     <bean id="injectBeanParent" class="java.lang.String">
11            <constructor-arg>
12                <value>Bean In Parentvalue>
13            constructor-arg>
14     bean>
15 beans>

1 beans.xml
2
3 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
4 <beans>
5
6     <bean id="target1" class="SimpleTarget">
7         <property name="val">
8             <ref bean="injectBeanParent"/>
9         property>
10     bean>
11
12     <bean id="target2" class="SimpleTarget">
13         <property name="val">
14             <ref local="injectBean"/>
15         property>
16     bean>
17
18     <bean id="target3" class="SimpleTarget">
19         <property name="val">
20             <ref parent="injectBean"/>
21         property>
22     bean>
23
24     <bean id="injectBean" class="java.lang.String">
25            <constructor-arg>
26                <value>Bean In Childvalue>
27            constructor-arg>
28     bean>
29 beans>
30

SimpleTarget中只有一属性String val

1 public static void main(String[] args) {
2         BeanFactory parent = new XmlBeanFactory(new FileSystemResource(
3                 "build/parent.xml"));
4         BeanFactory child = new XmlBeanFactory(new FileSystemResource(
5                 "build/beans.xml"), parent);
6
7         SimpleTarget target1 = (SimpleTarget) child.getBean("target1");
8         SimpleTarget target2 = (SimpleTarget) child.getBean("target2");
9         SimpleTarget target3 = (SimpleTarget) child.getBean("target3");
10
11         System.out.println(target1.getVal());
12         System.out.println(target2.getVal());
13         System.out.println(target3.getVal());
14     }

�q�行�l�果�Q?/span>
Bean In Parent
Bean In Child
Bean In Parent

分析�q�程�Q?/b>
在bean factory被加载过�E�中分别加蝲各层Bean Factory�Q?/font> BeanFactory parent = new XmlBeanFactory(new FileSystemResource("build/parent.xml"));
BeanFactory child = new XmlBeanFactory(new FileSystemResource("build/beans.xml" ), parent);
其中parent参数指定了bean factory间的父子关系�?/font>

分析�l�果�Q?/b>
�W�一行结果�ؓ在父factory中定义的参数�Q�说明在子fantory中可以直接调用父fantory元素�Q�类��g��java中的�l�承关系�?br /> �W�二行结果说�?/font> < ref local ="injectBean" />中local指向本fantory元素�?br /> �W�三行结果�ؓBean In Parent�Q�说�?/span> < ref parent ="injectBean" />中parent指向父fantory中元素�?/span>

improviser 2007-09-25 00:05 发表评论

improviser — Mon, 24 Sep 2007 14:38:00 GMT
     摘要: Spring中提供一些Aware相关的接口，BeanFactoryAware�?ApplicationContextAware、ResourceLoaderAware、ServletContextAware�{�等�Q�其中最常用到的是ApplicationContextAware。实现ApplicationContextAware的Bean�Q�在Bean被初始后�Q�将会被注入 ApplicationContext的实例。ApplicationContextAware提供了publishEvent()�Ҏ��Q�实现Observer(观察�?设计模式的事件传播机�Q�提供了针对Bean的事件传播功能。通过Application.publishEvent�Ҏ��Q�我们可以将事�g通知�pȝ��内所有的ApplicationListener�?nbsp; 阅读全文

improviser 2007-09-24 22:38 发表评论

improviser — Mon, 24 Sep 2007 05:51:00 GMT
     摘要: 本文内容演示属性文件用法的��单例子�?
首先定义模型接口Model�Q�视图接口View�Q�以及它们实现类ImpModel�Q�ImpView.
Model中定义方法getString();View中定义Model实例为其属性，在实现类ImpView中实现方�?
disPlay(),其方法体为Model实例的getString()�Ҏ��Q��ƈ��其打印出来�?nbsp; 阅读全文

improviser 2007-09-24 13:51 发表评论

improviser — Mon, 24 Sep 2007 02:23:00 GMT
     摘要: 通过,,以及元素定义和设�|�与java collection�c�d��对应的List�Q�Set�Q�Map�Q�Rproperties的倹{�?nbsp; 阅读全文

improviser 2007-09-24 10:23 发表评论

improviser — Sun, 23 Sep 2007 17:31:00 GMT
   初探Spring�E�序�Q�程序如下：


1 BeanNaming.java
2     package spring.beantest;
3
4     import org.springframework.beans.factory.BeanFactory;
5     import org.springframework.beans.factory.xml.XmlBeanFactory;
6     import org.springframework.core.io.FileSystemResource;
7
8     public class BeanNaming {
9     public static void main(String []args)
10     {
11         BeanFactory factory = new XmlBeanFactory(new FileSystemResource("src/applicationContext.xml"));
12
13         String s1 = (String)factory.getBean("name1");
14         String s2 = (String)factory.getBean("name2");
15         String s3 = (String)factory.getBean("name3");
16         String s4 = (String)factory.getBean("name4");
17
18         System.out.println((s1 == s2));
19         System.out.println((s2 == s3));
20         System.out.println((s3 == s4));
21
22         String[] x = factory.getAliases("name3");
23         for(String str:x)
24         {
25             System.out.println(str);
26         }
27
28       }
29     }
30
31       applicationContext.xml
32      xml version="1.0" encoding="UTF-8"?>
33      DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
34      <beans>
35
36      <bean id="name1" name="name2,name3,name4" class="java.lang.String"/>
37      beans>

    输出�l�果为：
    true
    true
    true
    name1
    name4
    name2

    可以看出�Q��用中id属性和name属性几乎没有�Q何区别。调用beanfactory.getAliases(string)的方法时�Q�传入的参数可以是�Q意一个bean名字�Q�输出的别名则是除去作�ؓ参数本��n之外的所�? bean名�?/span>


   �?/span>�Q?span style="color: rgb(74, 48, 255);">在写 applicationContxt.xml文�g�Ӟ��如果没有定义�Q�则会抛�?/span>Cannot find the declaration of element 'beans'异常�?/span>

      以上使用BeanFactory寚w��|�文件进行加载，BeanFactory�Q�是�Ҏ��配置文�g负责创徏Bean的实例，�q�负责Bean的生命周期的��理- --�Q�包括Bean的生成与销毁、Bean的创建方式的识别�Q�是否�ؓsingleton�Q�、Bean的各个属性的讑֮�、依赖关�pȝ��建立�{��?br />     ApplicationContext接口�Q�提供了国际化、事件处理及beans在context中的自查能力。它也可创徏��h��层次�l�构context�? 境，��bean的作用域和可讉K��区域限制在应用程序的一个特定部分中。下面演�C�如何��用ApplicationContext接口�?/span>


1 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-    beans.dtd">
2     <beans>
3     <bean id="bean_1" class="BeanTest"/>
4     <bean id="bean_2" class="BeanTest"/>
5     beans>
6
7
8     public class BeanTest {
9     public void test() {
10         System.out.println("test..");
11     }
12    }
13
14
15    import org.springframework.context.ApplicationContext;
16    import org.springframework.context.support.FileSystemXmlApplicationContext;
17
18    public class BeanNameExample {
19
20     public static void main(String[] args) {
21         ApplicationContext ctx = new FileSystemXmlApplicationContext(
22         "build/applicationContext.xml");
23
24         BeanTest beanOne = (BeanTest)ctx.getBean("bean_1");
25         BeanTest beanTwo = (BeanTest)ctx.getBean("bean_2");
26
27         beanOne.test();
28         beanTwo.test();
29       }
30    }
31
  �l�g��Q�ApplicationContext与BeanFactory的不同点
   BeanFactory提供了针对JavaBean的管理功能，而ApplicationContext提供了一个更为框架化的实玎ͼ�从上面的�C�Z��中可�? 看出�Q�BeanFactory的��用方式更加类��g��个API�Q�而非Framework style�Q�。ApplicationContext覆盖了BeanFactory的所有功能，�q�提供了更多的特性。此外， ApplicationContext��Z��现有应用框架相整合，提供了更为开攑ּ�的实玎ͼ�如对于Web应用�Q�我们可以在web.xml中对 ApplicationContext�q�行配置�Q��?/strong>

improviser 2007-09-24 01:31 发表评论

伊人成人在线视频,国产专区一区,久久影院一区二区三区

偉���Spring MVC

SimpleTarget中只有一属性String val

偉��Spring MVC

`SimpleTarget中只有一属性String val`