郁闷啊，刚刚发了一篇Spring注入属性值，一提交，页面无法显示，接着微软来啦，提示IE出现错误！一大堆话！幸好blogjava可以恢复上次的内容， 要不我哭死！对啦，刚刚忘记写了，校内搞了个编程大赛，可以用JAVA噢！这跟myspace不同，很好，我也要试试！有2个想法！不知道能不能实现，加油！

        注入属性值
               通过PropertyPathFactoryBean类，可以注入某个实例的属性值。PropertyPathFactoryBean用来获取目标bean的属性值。获得的值可注入给其他bean,也可以直接定义成新的bean.
            看例子：
-----------------------------------------------------------------------------------------

package org.viking.spring.imp;

public class Person
{
 private int age;
 
 private Son son;

 public void setAge(int age) {
  this.age = age;
 }

 public void setSon(Son son) {
  this.son = son;
 }

 public int getAge() {
  return age;
 }

 public Son getSon() {
  return son;
 }
 
}
-----------------------------------------------------------------------------------------

package org.viking.spring.imp;

public class Son
{
 private int age;

 public void setAge(int age) {
  this.age = age;
 }

 public int getAge() {
  return age;
 }
}
-----------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 <bean id="person" class="org.viking.spring.imp.Person" scope="prototype">
  <property name="age">
   <value>30</value>
  </property>
  <property name="son">
   <bean class="org.viking.spring.imp.Son">
    <property name="age">
     <value>11</value>
    </property>
   </bean>
  </property>
 </bean>
 
 <bean id="son2" class="org.viking.spring.imp.Son">
  <property name="age">
   <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
   </bean>
  </property>
 </bean>

</beans>
-----------------------------------------------------------------------------------------

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.imp.Son;

import junit.framework.TestCase;

public class testInject extends TestCase
{
 public void testInjectAttribute()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  System.out.println("son2的age属性值：" + ((Son)app.getBean("son2")).getAge());
}
}

-----------------------------------------------------------------------------------------
        一个bean实例的属性值，不仅可以注入另一个bean,还可将bean实例的属性值直接定义成bean实例，也是通过PropertyPathFactoryBean完成的。对上面ApplicationContext.xml文件做下修改！
-----------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 <bean id="person" class="org.viking.spring.imp.Person" scope="prototype">
  <property name="age">
   <value>30</value>
  </property>
  <property name="son">
   <bean class="org.viking.spring.imp.Son">
    <property name="age">
     <value>11</value>
    </property>
   </bean>
  </property>
 </bean>
 
 <bean id="son2" class="org.viking.spring.imp.Son">
  <property name="age">
   <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
   </bean>
  </property>
 </bean>
 
 <bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetBeanName">
   <value>person</value>
  </property>
  <property name="propertyPath">
   <value>son</value>
  </property>
 </bean>
</beans>
-----------------------------------------------------------------------------------------

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.imp.Son;

import junit.framework.TestCase;

public class testInject extends TestCase
{
 public void testInjectAttribute()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  System.out.println("son2的age属性值：" + ((Son)app.getBean("son2")).getAge());
  System.out.println("系统获取的SON1：" + app.getBean("son1"));

}
}
-----------------------------------------------------------------------------------------
    使用PropertyPathFactoryBean必须指定以下两个属性。
        1.targetBeanName:用于指定目标bean,确定获取哪个bean的属性值。
        2.propertyPath：用于指定属性，确定获取目标bean的哪个属性值，此处的属性可直接使用属性表达式。
       可以将基本数据类型的属性值定义成bean实例。在配置文件中再增加如下代码：
-----------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 <bean id="person" class="org.viking.spring.imp.Person" scope="prototype">
  <property name="age">
   <value>30</value>
  </property>
  <property name="son">
   <bean class="org.viking.spring.imp.Son">
    <property name="age">
     <value>11</value>
    </property>
   </bean>
  </property>
 </bean>
 
 <bean id="son2" class="org.viking.spring.imp.Son">
  <property name="age">
   <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
   </bean>
  </property>
 </bean>
 
 <bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetBeanName">
   <value>person</value>
  </property>
  <property name="propertyPath">
   <value>son</value>
  </property>
 </bean>
 
 <bean id="theAge" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetBeanName">
   <value>person</value>
  </property>
  <property name="propertyPath">
   <value>son.age</value>
  </property>
 </bean>
</beans>
-----------------------------------------------------------------------------------------

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.imp.Son;

import junit.framework.TestCase;

public class testInject extends TestCase
{
 public void testInjectAttribute()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  System.out.println("son2的age属性值：" + ((Son)app.getBean("son2")).getAge());
  System.out.println("系统获取的SON1：" + app.getBean("son1"));
  System.out.println("系统获取的theAge的值：" + app.getBean("theAge"));

}
}
-----------------------------------------------------------------------------------------
        目标bean既可以是容器中已有的bean实例，也可以是嵌套bean实例。
-----------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 <bean id="person" class="org.viking.spring.imp.Person" scope="prototype">
  <property name="age">
   <value>30</value>
  </property>
  <property name="son">
   <bean class="org.viking.spring.imp.Son">
    <property name="age">
     <value>11</value>
    </property>
   </bean>
  </property>
 </bean>
 
 <bean id="son2" class="org.viking.spring.imp.Son">
  <property name="age">
   <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
   </bean>
  </property>
 </bean>
 
 <bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetBeanName">
   <value>person</value>
  </property>
  <property name="propertyPath">
   <value>son</value>
  </property>
 </bean>
 
 <bean id="theAge" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetBeanName">
   <value>person</value>
  </property>
  <property name="propertyPath">
   <value>son.age</value>
  </property>
 </bean>
 
 <bean id="theAge2" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
  <property name="targetObject"><!-- 要注意，这里不是targetBeanName了噢！ -->
   <bean class="org.viking.spring.imp.Person">
    <property name="age">
     <value>12</value>
    </property>
   </bean>
  </property>
  <property name="propertyPath">
   <value>age</value>
  </property>
 </bean>
 
</beans>
-----------------------------------------------------------------------------------------

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.imp.Son;

import junit.framework.TestCase;

public class testInject extends TestCase
{
 public void testInjectAttribute()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  System.out.println("son2的age属性值：" + ((Son)app.getBean("son2")).getAge());
  System.out.println("系统获取的SON1：" + app.getBean("son1"));
  System.out.println("系统获取的theAge的值：" + app.getBean("theAge"));
  System.out.println("系统获取的theAge2的值：" + app.getBean("theAge2"));
 }
}
-----------------------------------------------------------------------------------------
        注意上面配置文件，定义嵌套bean实例时采用的时targetObject，而不时targetBeanName，如果这填错了，可是要报异常的噢！


-------以上的文字以及代码摘录于李刚写的《轻量级J2EE开发企业应用实战》，代码有少许变动！

    连标题都不知道取什么了！算是日记吧！恩，还是首先说说今天练舞的情况，今天下了雨，但是我还是风雨无阻，这点值得鼓励，现在再接再厉，而且单手蹦有了进步，呵呵，昨天那100个单手蹦没白做，今天可以蹦2下了，最高记录3下！还有今天的100个单手蹦也完成的，而且感觉完成的比昨天轻松啦！练舞时还跟沈鹏聊了会，他最近想找工作，听了听他的想法，说了说我的看法！
     今天又看了一章《做最好的自己》，哎，才看了一章，进度好慢啊，我的阅读量这么小？看来一个星期要看完它，必须得多花时间啦！上面有写话，在面试的时候拿来用，我觉得不错！
       for example:
            如果面试官问你：你对跳槽怎么看？（这时候有2种情况噢，第1.是你现在是跳槽到人家公司，第2.是你刚刚找工作，公司想看看你的想法！） 
            我觉得可以引用书上说的话：作为员工有义务保守公司机密，执行公司的计划（即便是在自己不同意的情况下），敬业等。然而，一名诚信的员工更应该是一个人格独立，思想独立的人，而不是依附与雇主的苔藓类植物。雇主与员工之间的关系是介于两个独立，平等的主体之间的契约，只有当追求各自的发展最大化的雇主和员工都认为对方是自己的最佳选择时，这个契约的效果才时双赢的。人和企业都在时刻改变着，对于企业而言，随着公司的发展变迁，过去适合的员工未来可能不在有适合他的职位；对于个人来说，一个公司过去可能是他最佳的选择，随着时间的流逝，选择可能已经无法激发他最大限度地发挥他的激情和才干。所以只要一个人保持进取精神，谋求职业上的发展，“跳槽”的可能性就永远存在。
        我觉得这段话说得非常好，一开始并没有正面的回答跳槽的问题，而是说出自己是一个诚信的人，不论在哪，都会保守以前公司的机密，诚信的人应该是有自己想法的人，然而公司选择员工，跟员工选择公司都是在各自发展最大化的前提下进行的，如果你没有公司所需要的技能，公司肯定不会要你，公司没有你向往的企业文化或者给你满意的薪酬你也不会去公司，接着用世间万物时刻都在变的原理说明了跳槽的可能性，我觉得这样说非常客观，也非常聪明，既没说跳槽好，也没说跳槽不好，而是从侧面给面试官一个无法反驳的答案！
      还有就是些说的不错的句子，一块摘录下来：
            1.许多年轻人并不是没有积极主动的态度来做出自己的决定，而是不习惯在重大问题上自己做决定。（自己想想，有吗？）
            2.自己只做无关紧要的决定，而任由他人做出对自己的一生有重大影响的决定，这明显是不合逻辑的。此外，有些人就算自己做出了决定，也不见得在事先已经花足够的时间做调查研究。而一个鲁莽的决定或草率的决定可能会让你后悔一辈子！（自己想想，考大学的时候，选的学校，专业，是否是你自己喜欢的！你在选择的时候，是否有详细的调查过？）
            3.被动就是弃权，不做决定也是一种决定。（这句话，可能有些人一时间不能理解，时候到了就明白了。前不久我久犯过这样的错！）
            4.在任何极端恶劣的环境里，人们还会拥有一种最后的自由，那就是选择自己的态度的自由！
            5.生命中随处是机遇，许多机遇就藏在一个又一个挫折之中，如果在挫折面前气馁，就可能会与机遇擦肩而过。
            6.当知道机遇来临的时候，要积极把握；当尚未看到机遇的时候，要时刻准备。

   依赖注入--如果A依赖于B，则B实例不再由A负责生成，而有容器负责生成，并注入给A实例，因此称为依赖注入，也称为控制反转。
  
   配置依赖
     根据注入方式的不同，bean的依赖注入通常表现为如下两种形式：
        1，属性：通过property属性来指定对应的设值注入。
        2，构造器参数：通过constructor-arg属性来指定对应的构造注入。
   在Spring在实例化BeanFactory时，通常会校验BeanFactory中的每一个Bean的配置。这些校验包括：
        1.bean引用的合作者指向一个合法的bean.
        2.对于被设置为pre-instantiated的bean的singleton行为，Spring会在创建BeanFactory时，同时实例化bean.实例化bean时，也会将它所依赖的bean一起实例化。
        此外，BeanFactory与ApplicationContext实例化容器中的bean的时机不同：前者在程序需要bean实例时才创建Bean;而后者在加载ApplicationContext实例时，会自动实例化容器中的全部bean.
        ApplicationContext是默认预实例化singleton bean。ApplicationContext实例化过程比BeanFactory时间和内存占用率大，但可以在ApplicationContext创建时就检验出配置错误。当然可以通过lazy-load属性为“true”来改变ApplicationContext的默认行为！
        bean的依赖通常可以接受如下元素指定值：
            1.value.
            2.ref.
            3.bean.
            4.list.set.map.以及props.

    首先来看看value元素。
        value元素用于确定字符串参数。XML文档解析器解析以String解析出这些数据，然后将这些参数由PropertyEditors完成转换（从java.lang.String类型转换为所需的参数类型）。
        for example:
-------------------------------------------------------------------------------------------

package org.viking.spring.itf;

public interface ValueElementItf
{
 public void shows();
}

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

package org.viking.spring.imp;

import org.viking.spring.itf.ValueElementItf;

public class ValueElement implements ValueElementItf {

 private int integerProperty;
 
 private double doubleProperty;
 
 private String email;
 
 public void shows()
 {
  System.out.println(integerProperty);
  System.out.println(doubleProperty);
  System.out.println(email);
 }

 public void setIntegerProperty(int integerProperty) {
  this.integerProperty = integerProperty;
 }

 public void setDoubleProperty(double doubleProperty) {
  this.doubleProperty = doubleProperty;
 }

 public void setEmail(String email) {
  this.email = email;
 }

 

}

-------------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
 <bean id="value" class="org.viking.spring.imp.ValueElement">
  <property name="integerProperty">
   <value>1</value>
  </property>
  <property name="doubleProperty">
   <value>2.3</value>
  </property>
 </bean>
</beans>
-------------------------------------------------------------------------------------------
 

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.itf.Person;
import org.viking.spring.itf.ValueElementItf;

import junit.framework.TestCase;

public class TestElement extends TestCase
{
 public void testValueElement()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  ValueElementItf value = (ValueElementItf)app.getBean("value");
  value.shows();
 }

}
-------------------------------------------------------------------------------------------
   value元素的值可以通过<null/>元素指定为空。
    把上面的applicationContext.xml文件代码改一下。
-------------------------------------------------------------------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
 <bean id="value" class="org.viking.spring.imp.ValueElement">
  <property name="integerProperty">
   <value>1</value>
  </property>
  <property name="doubleProperty">
   <value>2.3</value>
  </property>
  <property name="email">
   <value></value>
  </property>
 </bean>
</beans>
-------------------------------------------------------------------------------------------
改过之后的测试打印出了Null.

        接着是ref元素
            如果需要为bean注入的属性是容器中的某个bean实例，推荐使用ref。
             ref元素通常有两个属性：
                1.bean
                2.local
            bean用于指定在不同一个xml配置文件中的bean,而local用于指定同一个xml配置文件中的其他bean,并且local属性值只能是其他bean的id属性，让Spring在解析XML时，验证bean的名称。

        bean元素
            如果某个bean的依赖bean不想被Spring容器直接访问，则可以使用嵌套bean。
            嵌套bean只对嵌套它的外部bean有效，而Spring容器无法直接访问嵌套bean，因此嵌套bean无需id属性。
            嵌套bean的配置形式，保证嵌套bean不能被容器访问，提高了程序的内聚性。
            嵌套bean的例子会在下一个元素讲解中使用到！
        list，set，map，以及props元素
            list,set,map和props元素分别用来设置类型为List,Set,Map和Properties的属性值，用来为bean注入集合值。
            for example：
-------------------------------------------------------------------------------------------

package org.viking.spring.itf;

public interface Person
{
 public void shows();
}
-------------------------------------------------------------------------------------------

package org.viking.spring.imp;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import org.viking.spring.itf.Person;

public class Chinese implements Person
{

 private List  schools = new ArrayList();
 
 private Map score = new HashMap();
 
 private Properties  health = new Properties();
 
 private Set axes = new HashSet();
 
 public void shows()
 {
  System.out.println(schools);
  System.out.println(score);
  System.out.println(health);
  System.out.println(axes);
 }

 public void setSchools(List schools) {
  this.schools = schools;
 }

 public void setScore(Map score) {
  this.score = score;
 }

 public void setHealth(Properties health) {
  this.health = health;
 }

 public void setAxes(Set axes) {
  this.axes = axes;
 }

}
-------------------------------------------------------------------------------------------
package org.viking.spring.imp;
public class ValueElement
{
    public ValueElement()
    {
        System.out.println("嵌套bean的测试！");
    }
}
-------------------------------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<beans
 xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<bean id="chinese" class="org.viking.spring.imp.Chinese">
  <property name="schools">
   <list>
    <value>小学</value>
    <value>中学</value>
    <value>大学</value>
   </list>
  </property>
  <property name="score">
   <map>
    <entry key="数学">
     <value>87</value>
    </entry>
     <entry key="英语">
     <value>89</value>
    </entry>
     <entry key="语文">
     <value>82</value>
    </entry>
   </map>
  </property>
  <property name="health">
   <props>
    <prop key="血压">正常</prop>
    <prop key="身高">175</prop>
   </props>
  </property>
  <property name="axes">
   <set>
    <value>字符串斧子</value>
    <ref local="value"/>
    <bean class="org.viking.spring.imp.ValueElement"></bean>
    <!--这就是嵌套bean-->
   </set>
  </property>
 </bean>

</beans>

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

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.itf.Person;
import org.viking.spring.itf.ValueElementItf;

import junit.framework.TestCase;

public class TestElement extends TestCase
{

public void testCollection()
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  Person p1 =  (Person)app.getBean("chinese");
  p1.shows();
 }
}
-------------------------------------------------------------------------------------------
    map元素entry的值以及set元素的值都可以使用如下元素：
        1.vlaue:确定基本数据类型值或字符串类型值。
        2.ref:确定另外一个bean为属性值。
        3.bean：确定一个嵌套bean为属性值。
        4.list,set，map,以及props：确定集合值为属性值。
    这么说可能有点抽象，大家运行一下以上代码，就一清二楚了！

    在实际应用中，某个实例的属性可能是某个方法的返回值，类的field值，或者属性值。这种非常规的方法Spring同样支持！Spring甚至支持将bean实例的属性值，方法返回值及field值直接赋给一个变量。
       好了，今天就到这，明天接着写注入属性值！

-------以上的文字以及代码摘录于李刚写的《轻量级J2EE开发企业应用实战》，代码有少许变动！

  哈，一天又过去啦，先来总结一下今天发生的事情，今天住在北京的室友回宿舍看我了，与其说是看我，还不如说是回学校看美女！他听说良乡校区的军事理论课上完了，而他喜欢的那个MM，回到本部参加奥运自愿者的培训了！所以特意从朝阳区赶回来！他还跟一前一样，做事冒冒失失，哎，才分别也没几天，要他改变什么也是不可能的，况且古语有言---江山易改本性难移啊！
  昨天把《墨迹，曾子墨》看完了，今天开始看李开复先生的《做最好的自己》，这本书，买了有一段时间了，买它的原因是以为去年对他非常的仰慕，而且去年看了他写的给家长的一封信，内容是讲关于对孩子的教育的!觉得写得不错，所以也买了后来的这本书！本书260页，打算一个星期看完！今天看了一章，发现没有了以前的感觉了！觉得这本书，从第1-第2章都是以说教的方式进行的！（因为我只看完了这2章），而且相关的理念不够新颖，甚至有点老套了，而且文章的排版让我想起了教科书，第1章，来个总结性的讲解，然后把内容一部分一部分的拿出来！虽然这种方式的思路比较清晰，但是我总觉得在看一本政治书！当然虽然没有一口气读完的欲望，我还是得坚持的读下去，人家子墨在达特茅斯时，1000多页的尼采如是说都看完了，相比之下，这点难度不值得一提！2008年7月13日我会准时的写这本书的读后感！
  今天晚上去中教练舞了，去的时候沈鹏也在（师兄），经过他的指定我的单手蹦有了进步，原来我以前做的姿势跟方法都是错的，难怪我的手不能离地！现在我的手已经可以离开地面了!为此我还为自己计划了特别的训练！每次看我猜的时候，总能看见人家跳舞或者其他方面成就的人，在练习的时候都说上千次的失败换来了今天的成功！对，我也要用上千次的失败来换取！所以我决定在接下来的10天里，会完成1000个单手蹦的训练，具体是每天100个单手蹦，前500个单手蹦扶着墙，后500个单手蹦离开墙！今天我已经做了100个了！今天是第1天，我将在2008年7月16日完成1000个单手蹦的训练，我相信那天，我的单手蹦也将练成！这是我第1次为自己详细的策划训练项目！我只能成功！如果失败就会打击我的自信心，当然这种事情在我这是绝对不会发生的！因为我对上千次的失败换来今天的成功这句话深信不以！只要我坚持下去，这10天里，风雨无阻的去训练，一定可以的！10天后，我将会在这里把这个好消息告诉大家！至于90’s的训练我还没有具体的计划，因为我还不知道这个到底该怎么去练！
  在我练舞的时候旁边有3个人，2男一女，一直在那，一会打电话，一会就在那哈哈大笑！他们说的一段话被我无意中听见了（应该不算是偷听吧！谁叫他们说那么大声啊！）一开始是那女孩先说的：“哎，开始还说我今天有事，估计要晚来，谁知道我才是第1个来的！”，接着两个男的说话了：“我还不是说今天有事，可能会迟到，谁知道我也是最先来的！还得在这等！”听到这里，我思考了一下，为什么会这样呢？其实很简单，有事的人怕自己迟到太久所以急忙赶来，而没事的人认为他们都有事，我晚一点去也没关系，所以就后来了！事情就这样，结果是往往有事的人先到，在等没事的人！当我练累了打算走的时候，才来的差不多，大概还差2个人没来，结果他们坐在地上玩起了杀人，哎，看来杀人还真流行，可惜我还不会玩！
  在回家的路上，路过小公园，听见2个老爷爷在说话，1个老爷爷说：“前几天去旅游啊，看见墙上用毛笔写了一段话，‘某某某到此一游！’，这句话下面，又刻了一段字，估计是后来的人给添上的‘在此留下一蛋！’”另外一个老爷爷似乎没听明白，我刚刚路过，也没听清楚后一句话，当老爷爷又重复了一遍以后，我明白了，原来是“某某某到此一游，在此留下一蛋！”哈哈，看来老人们聊天也是挺有意思的！
  每天一个人走，没事听听人家的谈论，我该不会步入了校园里的“偷听者”行业吧？
 

    先声明一下，估计接下来会有点文不对题，是这样的，由于时间太晚，所以就把这几天发生的事集中在一起，一块写啦！
       嗯。。。昨天晚上又看了《铁齿铜牙--纪晓岚》，其实纪晓岚这人我非常喜欢，非常的有才！虽然电视剧里跟历史有不符合，但是他的才气也是公认的！前不就在网上搜到了一本书《纪晓岚随机应变方圆之道》。看了开头2章，发现其实纪晓岚也算是“风流”才子啊，跟唐伯虎有一拼，对于风流2字的意思，如果想了解我这里指的是什么，可以去看看百家讲堂里孙丹林教授讲的唐伯虎风流吗？那里面给风流2字下了明确的定义！好了，不咬文嚼字了！这里摘录一段《纪晓岚随机应变方圆之道》中的内容：
    一次，纪晓岚陪同乾隆皇帝南巡，坐在江边一座茶楼喝茶。那时正是秋天，这日下着蒙蒙细雨。推窗远眺，只见江面上烟雨霏霏，朦胧一片，江心有只小船坐着一位渔夫，正在垂钓，双脚拍打着水面，嘴里哼着渔歌，四周船只很少，远处青山叠翠，那画面十分诱人。乾隆皇帝看得出神，纪晓岚见乾隆皇帝不说话，凑趣道：“圣上，江中好景致。”
　　“江色佳绝，卿可赋七言绝句一首，内藏十个‘一’字，如何？”乾隆皇帝沉浸在景色观赏之中，慢吞吞地说。
　　“遵旨。”纪晓岚展望江中景色，立即吟道：
　　一篱一橹一渔舟，
　　一个艄公一钓钩，
　　一拍一呼还一笑，
　　一人独占一江秋。
　　纪晓岚吟罢，乾隆皇帝算算四句中正好十个“一”字，细细品味诗意，那意境如眼前的一模一样，只是更加有韵味，尤其是“一人独占一江秋”之句，写尽了江中的寂静。
　　乾隆皇帝很高兴，禁不住夸赞：“卿真诗才横溢。”
　　这种一字诗，清代还有人写过，据传有一位少女诗人，写过一首这样的诗：
　　一花一柳一石矶，
　　一抹斜阳一鸟飞，
　　一水一山中一寺，
　　一林黄叶一僧归。
　　此诗也别开生面，一字虽然如此之多，但并不感到重复。
　　相传有人择婿，也以十“一”诗为条件，若能在诗中嵌入十个“一”字，而且情景自然，就允许娶自己的女儿，并奉上丰厚的嫁妆。
　　有一年轻人前来应试，在试卷上题道：
　　一横一竖正相交。
　　一偏一斜一剪刀，
　　一子一女成一对，
　　一个一个比天高。
　　这是第一首，是七言诗，还有第二首，九言诗：
　　一横一竖十字路相交，
　　一偏一斜分明一剪刀，
　　一子一女好成一对儿，
　　一个一个笑声比天高。
　　这两首诗，都含有十个“一”字，而且，后首藏有一个谜底：十分好笑。不过，比较起来，那位女诗人和这位应试者之诗，虽然符合写作要求，而在意境上却不如纪诗，尤其是应试者两首，为暗含谜底，显得牵强，谈不上诗的韵味了。


      怎么样？看了上面这段摘录的文字，是否感觉到了纪晓岚的才气？
           好了，不谈纪晓岚了，今年晚上去跳舞了，在路上遇见班上的一女同学，过后才发现忘记要手机号码了！
            我的手又受伤了，都怪自己忍不住，伤口是练风车时受伤的，现在已经是连续4次流血，连续的意思是，差不都好了，我又去来一风车，又出血了，就这样连续4次！我把血留在了我的护肘上，4个血印，代表着我从练风车开始的4次流血事故，被我妈看见了，肯定又要心疼了，但是我却觉得现在受伤未必是坏事，跳breaking受伤是绝对的，不受伤还真练不出来，我再想，不受伤就练成功的是最恐怖的，因为没经历过挫折就成功了，万一哪天出了其他的状况都不知道怎么处理，而我现在是受伤了，但是我可以从失败中获取教训，以后在真正的表演中就不会再出现类似的情况！吼吼，我的心态还是比较积极的！这2天练90’s跟单手蹦都没什么见长！90’s我就是不知道怎么用腰力，到现在我还郁闷！单手蹦我的手还是不能离地，我估计这可能是我的手臂力量不够！回家的路上一直想，路过京工，进去买瓶矿泉水，本来打算买宝矿力水特的，后来我做出了一个“惊人”的计划，当我练好了无限风车，就赏自己一瓶绿茶，当练好了单手蹦就奖励佳得乐，当练好了90's就奖励宝矿力水特，当练好托马斯就奖励宝矿力水特+冰淇淋，当练好托马斯接风车接UFO就奖励矿力水特+冰淇淋+绿茶+红茶，练好托马斯接风车接90’s就奖励矿力水特+冰淇淋+西瓜.恩，就先这些吧！在这之前，一律和矿泉水！
            好啦，该回正题了，今天看完了《墨迹，曾子墨》，算是自传吧，写得不错，让我感受到了不一样的人生！跟着作者从人民大学到华尔街到香港，学到了很多以前从来没想过的东西，也想像不到的东西，之前完全不知道出国是怎么回事，该办理什么东西！流程是怎么样的！也了解到了很多美国人的思想，这种思想我非常喜欢，从达特茅斯录取子墨时问的问题，和达特茅斯的历史文化让我动容。
            你能忍受在天寒地冻零下20摄氏度的森林木屋里住2个月吗？
            你敢从几米高的木桥上跳进湍急的河水中吗？
            你有本事在考试前一天晚上一口气读完300多页的课本吗？
            你愿意在早晨7：45爬起来去上外语口语课吗？
            你可以在20秒内灌下一整罐啤酒吗？
            在达特茅斯里还有裸奔的文化，他们的裸奔已经不能用有色的眼光去看待了，这是一种非常神圣的仪式！如果你在场相信你也能感受得到！
            在读到子墨因为想找一点回北京，恳求教授让他提前考试时，教授的做法让我非常的敬佩！教授同意了，而且安排她在期末周的第一天！文中是这样写的：
                “期末周”第一天，我如期的来到平时上课的教室。
                    Bowdoin教授拿出试卷，说：“你有两个小时的时间，结束后，把试卷放到我办公室外的邮箱里，明天我会去取。”
                    我迟疑了一下："没有人留在这里吗？”
                    Bowdoin教授皱了眉头，似乎不太明白我的问题：“只有你一个人提前考试，为什么需要别人在这里？抓紧时间，赶快开始吧！”停了停，他又补充道：“祝你考试好运！一路平安！”
                    记忆中，我在达特茅斯的所有考试，无论大小，也不分专业，几乎很少有人监考。但每次，教室里都秩序井然，连“刷刷”的写字声都听得一清二楚。同学们埋头答卷，互不干扰，看笔记，写纸条或者打手势从未出现过。似乎每一个人都懂得，诚信和荣誉远比成绩更值得珍惜和维护。

            这就是达特茅斯啊！达特茅斯的外语教学方法也堪称一绝啊！看了子墨在美国的生活，我也忍不住想出过留学，但是估计出国留学这辈子与我无缘了！但是我想像子墨一样在华尔街上拼杀！华尔街世界商业聚聚地，大家都向往的地方！我想以后的路还很长，我也会像这方面努力的，只有我还没死，就存在着希望！
            在子墨记录华尔街的文章里，我也学到了许多投行的相关知识，什么杠杆收购啊，道琼斯，纳斯达克等，还知道了原来副总裁有很多个，还了解到了一些贵族品牌！明白了，个性与品味比潮流重要！还知道了，点击科技原来是王志东的第2次创业！
            看了此书，感触挺多了，以后我也得学习子墨，每星期都看一本书，写下评语！这算是第1篇吧！对于子墨，我非常的欣赏她，靠自己的努力创造美好的人生！而且能追逐自己的梦想，不想用自己的生命，去点亮别人罩在她身上的光环！非常有魄力的一个女孩，从当年在人民大学附属中学拿到北京市前3可以保送到任何学校，清华北大是国内最好的学校，她却选择了人民大学，在摩根斯坦力这种人人都向往的生活中，她却放弃了！非常有主见的女孩，与众不同的女孩！

从追MM谈Java的23种设计模式

　　1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯 德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory.

　　　　工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点 是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

　　程序代码

　　以下是引用片段：

以下是引用片段： public class Factory{ 　　　　　　public String Boy = "boy" ; 　　　　 　　public String Girl = "girl" ; 　　　　　　public People getPeople (String people){ 　　　　　　　　if (people.equals("boy")){ 　　　　　　　　　　return new Boy(); 　　　　　　　　}else if(people.equals("girl")){ 　　　　　　　　　　return new Girl(); 　　　　　 　　　} 　　　　　　} 　　　　}

　　2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译 机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这 就是我的“我爱你”builder。(这一定比美军在伊拉克用的翻译机好卖)

　　 建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得 产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

　　3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模 式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。

　　　　工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出 具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

　　4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是 我的情话prototype了。(100块钱一份，你要不要)

　　　　原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。 原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每 一个类都必须配备一个克隆方法。

　　5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个 人，那就是我(刚才做了个梦啦，哪有这么好的事)

 

　　　　单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的 “单一实例”的需求时才可使用。

　　以下是引用片段：

以下是引用片段： 　　　　public　class SingLeton{ 　　　　　　private static SingLeton instance = new SingLeton(); 　　　　　　public static SingLeton getInstance(){ 　　　　　　　　return instance; 　　　　　　} 　　　　}

　　6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他 作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)

　　　　适配器(变压器)模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类 能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

　　7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好;碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型， 要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了

　　桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的 抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

　　8、COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T恤挺漂亮，买，这 条裙子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么呀，T恤加裙子加包包，正好配成一套呀， 小姐，麻烦你包起来。”“……”，MM都会用Composite模式了，你会了没有?

　　　　合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成 模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。

　　9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片， 在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框(卖礼品的MM也很漂亮哦)，再找隔壁搞美术设计的Mike设计了一 个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗?

　　　　装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。动态给一个 对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。

　　10、FAÇADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也 不会。幸好相机有Façade设计模式，把相机调整到自动档，只要对准目标按快门就行了，一切由相机自动调整，这样MM也可以用这个相机给我 拍张照片了。

 

　　　　门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用 。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但整个系统可以有多个门面类。

　　11、FLYWEIGHT—每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里，要用的时候，直接拿出来 ，在前面加上MM的名字就可以发送了，再不用一个字一个字敲了。共享的句子就是Flyweight，MM的名字就是提取出来的外部特征，根据上下文 情况使用。

　　　　享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关 键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能 影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户 端不可以直接创建被共享的对象，而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。

　　12、PROXY—跟MM在网上聊天，一开头总是“hi,你好”,“你从哪儿来呀?”“你多大了?”“身高多少呀?”这些话，真烦人，写个程序 做为我的Proxy吧，凡是接收到这些话都设置好了自动的回答，接收到其他的话时再通知我回答，怎么样，酷吧。

　　　　代理模式：代理模式给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个 人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象直接起到中介的作用。客户 端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象，而仅仅持有一个被代理对象的接口，这时候代理对象不 能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。

以下是引用片段： 　　　　public interface FactoryProxy{ 　　　　　　public People createBoy(); 　　　　　　 public People creteGirl(); 　　　　}

　　13、CHAIN OF RESPONSIBLEITY—晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的MM哎，找张纸条，写上 “Hi,可以做我的女朋友吗?如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的MM把纸条传给老师了，听说是个老处 女呀，快跑!

　　　　责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接

　　　　起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请 求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终 不被任何接收端对象所接受。

　　14、COMMAND—俺有一个MM家里管得特别严，没法见面，只好借助于她弟弟在我们俩之间传送信息，她对我有什么指示，就写一张纸条 让她弟弟带给我。这不，她弟弟又传送过来一个COMMAND，为了感谢他，我请他吃了碗杂酱面，哪知道他说：“我同时给我姐姐三个男朋友送 COMMAND，就数你最小气，才请我吃面。”，

　　　　命令模式：命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的 对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以 及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。

15、INTERPRETER—俺有一个《泡MM真经》，上面有各种泡MM的攻略，比如说去吃西餐的步骤、去看电影的方法等等，跟MM约会时，只 要做一个Interpreter，照着上面的脚本执行就可以了。

 

　　　　解释器模式：给定一个语言后，解释器模式可以定义出其文法的一种表示，并同时提供一个解释器。客户端可以使用这个解释器来 解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后，使用模式设计解释这些语句。在解释器模式里面提到的语言是指任 何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构，也就是一系列的组合规则。每一个命令对象 都有一个解释方法，代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。

　　16、ITERATOR—我爱上了Mary，不顾一切的向她求婚。

　　　　Mary：“想要我跟你结婚，得答应我的条件”

　　　　我：“什么条件我都答应，你说吧”

　　　　Mary：“我看上了那个一克拉的钻石”

　　　　我：“我买，我买，还有吗?”

　　　　Mary：“我看上了湖边的那栋别墅”

　　　　我：“我买，我买，还有吗?”

　　　　Mary：“我看上那辆法拉利跑车”

　　　　我脑袋嗡的一声，坐在椅子上，一咬牙：“我买，我买，还有吗?”

　　　　……

　　　　迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集， 聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代子模式简化了聚集 的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色 变化。

　　17、MEDIATOR—四个MM打麻将，相互之间谁应该给谁多少钱算不清楚了，幸亏当时我在旁边，按照各自的筹码数算钱，赚了钱的从我这 里拿，赔了钱的也付给我，一切就OK啦，俺得到了四个MM的电话。

　　　　调停者模式：调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些 对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用 转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。

　　18、MEMENTO—同时跟几个MM聊天时，一定要记清楚刚才跟MM说了些什么话，不然MM发现了会不高兴的哦，幸亏我有个备忘录，刚才与 哪个MM说了什么话我都拷贝一份放到备忘录里面保存，这样可以随时察看以前的记录啦。

　　　　备忘录模式：备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下，将一 个对象的状态捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。

　　19、OBSERVER—想知道咱们公司最新MM情报吗?加入公司的MM情报邮件组就行了，tom负责搜集情报，他发现的新情报不用一个一个通知 我们，直接发布给邮件组，我们作为订阅者(观察者)就可以及时收到情报啦

　　　　观察者模式：观察者模式定义了一种一队多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生 变化时，会通知所有观察者对象，使他们能够自动更新自己。
　　20、STATE—跟MM交往时，一定要注意她的状态哦，在不同的状态时她的行为会有不同，比如你约她今天晚上去看电影，对你没兴趣的 MM就会说“有事情啦”，对你不讨厌但还没喜欢上的MM就会说“好啊，不过可以带上我同事么?”，已经喜欢上你的MM就会说“几点钟?看完电 影再去泡吧怎么样?”，当然你看电影过程中表现良好的话，也可以把MM的状态从不讨厌不喜欢变成喜欢哦。

 

　　　　状态模式：状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究 的对象的行为包装在不同的状态对象里，每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变 的时候，其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时，系统便改变所选的子 类。

　　21、STRATEGY—跟不同类型的MM约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，单目 的都是为了得到MM的芳心，我的追MM锦囊中有好多Strategy哦。

　　　　策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得 算法可以在不影响到客户端的情况下发生变化。策略模式把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供 。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

　　22、TEMPLATE METHOD——看过《如何说服女生上床》这部经典文章吗?女生从认识到上床的不变的步骤分为巧遇、打破僵局、展开追求 、接吻、前戏、动手、爱抚、进去八大步骤(Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦(具 体实现);

　　　　模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子的形式实现，然后声明一些抽象方法来迫使 子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻 辑的细节留给具体的子类去实现。

　　23、VISITOR—情人节到了，要给每个MM送一束鲜花和一张卡片，可是每个MM送的花都要针对她个人的特点，每张卡片也要根据个人的 特点来挑，我一个人哪搞得清楚，还是找花店老板和礼品店老板做一下Visitor，让花店老板根据MM的特点选一束花，让礼品店老板也根据每个 人特点选一张卡，这样就轻松多了;？

　　　　访问者模式：访问者模式的目的是封装一些施加于某种数据结构元素之上的操作。一旦这些操作需要修改的话，接受这个操作的数 据结构可以保持不变。访问者模式适用于数据结构相对未定的系统，它把数据结构和作用于结构上的操作之间的耦合解脱开，使得操作集合可 以相对自由的演化。访问者模式使得增加新的操作变的很容易，就是增加一个新的访问者类。访问者模式将有关的行为集中到一个访问者对象 中，而不是分散到一个个的节点类中。当使用访问者模式时，要将尽可能多的对象浏览逻辑放在访问者类中，而不是放到它的子类中。访问者 模式可以跨过几个类的等级结构访问属于不同的等级结构的成员类。

---------转自：http://www.javass.cn/javapeixundesign/023.html

    最近看的spring,不管内容多少，记下来吧！
    
    创建bean通常有如下方法：
    1.调用构造器创建一个bean实例。
    2.BeanFactory调用某个类的静态工厂方法创建bean.
    3.BeanFactory调用实例工厂方法创建bean.
    
    先来说说---调用构造器创建一个bean实例。
        通过“new”关键字创建bean实例是最常见的情形，如果采用设值注入的方式，则要求该类提供无参数的构造器。
        BeanFactory将调用该构造器来创建bean实例，该实例是个默认的实例。
        接下来，BeanFactory会根据配置文件来决定依赖关系：首先实例化依赖的bean，然后为bean注入依赖关系；最后将一个完整的Bean实例返回给程序。

        for example：
---------------------------------------------------------------------------------    

            package org.viking.spring.itf;

            public interface Person 
            {
                 public void useAxe();
            }

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

package org.viking.spring.imp;

import org.viking.spring.itf.Axe;
import org.viking.spring.itf.Person;

public class Chinese implements Person {

 private Axe axe;
 
 public Chinese()
 {
  System.out.println("Spring 实例化主调bean: chinese实例....");
 }
 
 public void useAxe()
 {
  System.out.println(axe.chop());
 }

 public void setAxe(Axe axe)
 {
  System.out.println("spring 执行依赖关系注入....");
  this.axe = axe;
 }

 public Axe getAxe() {
  return axe;
 }

}
----------------------------------------------------------------------------------

package org.viking.spring.itf;

public interface Axe
{
 public String chop();
}

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

package org.viking.spring.imp;

import org.viking.spring.itf.Axe;

public class SteelAxe implements Axe {

 public SteelAxe()
 {
  System.out.println("Spring 实例化依赖bean: SteelAxe实例...");
 }
 
 public String chop()
 {
  return "钢斧砍材真快";
 }

}

----------------------------------------------------------------------------------
applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
 
 <bean id="chinese" class="org.viking.spring.imp.Chinese">
  <property name="axe">
      <ref local="steelAxe"/>
  </property>
 </bean>
</beans>
----------------------------------------------------------------------------------

package org.viking.spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.viking.spring.itf.Being;
import org.viking.spring.itf.People;
import org.viking.spring.itf.Person;

import junit.framework.TestCase;

public class BeanTest extends TestCase
{
 public void testNewBean()throws Exception
 {
  ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
  System.out.println("程序已经实例化BeanFactory...");
  Person p = (Person)app.getBean("chinese");
  System.out.println("程序中已经完成了chinese bean 的实例化...");
  p.useAxe();
 }

}
----------------------------------------------------------------------------------
执行结果清楚地反应了执行过程：
    （1）创建BeanFactory实例。
    （2）调用Chinese类的默认构造器创建默认实例。
    （3）根据配置文件注入依赖关系：先实例化依赖bean,然后将依赖bean注入。
    （4）返回一个完整的javabean实例。

    接下来说说---使用静态工厂方法创建bean
        反正这种方法，按书上我是没验证通过，去CSDN上求解，也毫无结果！但是还是写出来吧！
        
        使用静态工厂方法创建bean实例时，class属性也时必须的，但此时class属性并不是该实现类，而是静态工厂类。由于spring需要知道由哪个静态工厂方法来创建bean实例，因此使用factory-method属性来确定静态工厂方法名，在之后的过程中，spring的处理步骤与采用其他方法的创建完全一样。
        注意：这个Bean定义并没有指定返回对象的类型，只指定静态工厂类。该方法必须是静态的，如果静态工厂方法需要参数，则使用<constructor-arg>元素将其导入。
        下面是书上的代码---我没成功！
---------------------------------------------------------------------------------
package   org.viking.spring.itf;

public   interface   Being  
{
public   void   testBeing();
}
-----------------------------------------------------------------------------------
package   org.viking.spring.imp;

import   org.viking.spring.itf.Being;

public   class   Cat   implements   Being   {

private   String   msg;


public   void   testBeing()  
{
System.out.println(msg   +   "猫爱吃鱼！ ");
}


public   void   setMsg(String   msg)  
{
this.msg   =   msg;
}

}
-------------------------------------------------------------------------
package   org.viking.spring.imp;

import   org.viking.spring.itf.Being;

public   class   Dog   implements   Being   {

private   String   msg;

public   void   setMsg(String   msg)   {
this.msg   =   msg;
}

public   void   testBeing()
{
System.out.println(msg   +   "狗爱啃骨头！ ");
}

}
--------------------------------------------------------------
package   org.viking.spring.factory;

import   org.viking.spring.imp.Cat;
import   org.viking.spring.imp.Dog;
import   org.viking.spring.itf.Being;

public   class   BeingFactory
{
public   static   Being   getBeing(String   arg)
{
if(arg.equalsIgnoreCase( "dog "))
return   new   Dog();
else
return   new   Cat();
}
}
-----------------------------------------------------------
applicationContext.xml:

<?xml   version= "1.0 "   encoding= "UTF-8 "?>
<!DOCTYPE   beans   PUBLIC   "-//SPRING//DTD   BEAN//EN "   "http://www.springframework.org/dtd/spring-beans.dtd ">
<beans>
        <bean   id= "dog "   class= "org.viking.spring.factory.BeingFactory "   factory-method= "getBeing ">
<constructor-arg>
<value> dog </value>
</constructor-arg>
<property   name= "msg ">
<value> 我是狗 </value>
</property>
</bean>

<bean   id= "cat "   class= "org.viking.spring.factory.BeingFactory "   factory-method= "getBeing ">
<constructor-arg>
<value> cat </value>
</constructor-arg>
<property   name= "msg ">
<value> 我是猫 </value>
</property>
</bean>
</beans>
---------------------------------------------------------------------------------------------------------
package   org.viking.spring.test;

import   java.io.FileInputStream;
import   java.io.InputStream;

import   org.springframework.beans.factory.xml.XmlBeanFactory;
import   org.springframework.context.ApplicationContext;
import   org.springframework.context.support.ClassPathXmlApplicationContext;
import   org.springframework.core.io.InputStreamResource;
import   org.viking.spring.itf.Being;
import   org.viking.spring.itf.Person;

import   junit.framework.TestCase;

public   class   BeanTest   extends   TestCase  
{
public   void   testStaticFactoryBean()
{
ApplicationContext   context=   new   ClassPathXmlApplicationContext( "applicationContext.xml ");
System.out.println( "程序已经实例化BeanFactory... ");
Being   b1   =   (Being)context.getBean( "dog ");
b1.testBeing();
Being   b2   =   (Being)context.getBean( "cat ");
b2.testBeing();
}
}
-------------------------------------------------------------------------
吼吼，还请高手指点一下，看看上面的代码要怎么改？
对了，是applicationContext.xml出现小红叉，提示：
No setter found for property 'msg' in class 'org.viking.spring.factory.BeingFactory'

好，来说说最后一种方式---调用实例工厂方法创建bean
        实例工厂方法必须提供工厂实例，因此必须在配置文件中配置工厂实例，而bean元素无需class属性。
        采用实例工厂方法创建bean的配置需要如下两个属性：
           1、factory-bean:该属性的值为工厂bean的id.
           2、factory-method:该方法负责生成bean实例。

           for example:
-----------------------------------------------------------------------------

package org.viking.spring.itf;

public interface People
{
 public void sayHello();
 
 public void sayGoodBye();
}

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

package org.viking.spring.imp;

import org.viking.spring.itf.People;

public class AmericanPeople implements People {

 private String name;
 
 public void sayGoodBye()
 {
  System.out.println(name + " , Hello!");
 }

 public void sayHello()
 {
  System.out.println(name + ", GoodBye!");
 }

 public void setName(String name) {
  this.name = name;
 }

}

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

package org.viking.spring.imp;

import org.viking.spring.itf.People;

public class ChinesePeople implements People {
 
 private String name;
 
 public void sayGoodBye()
 {
  System.out.println(name + ",您好！");
 }

 public void sayHello()
 {
  System.out.println(name + ",再见！");
 }

 public void setName(String name) {
  this.name = name;
 }

}

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

package org.viking.spring.factory;

import org.viking.spring.imp.AmericanPeople;
import org.viking.spring.imp.ChinesePeople;
import org.viking.spring.itf.People;

public class PeopleFactory
{
 public People getPeople(String people)
 {
  if(people.equalsIgnoreCase("china"))
   return new ChinesePeople();
  else
   return new AmericanPeople();
 }
}
-----------------------------------------------------------------------------
applicationContext.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   
 <bean id="peopleFactory" class="org.viking.spring.factory.PeopleFactory"></bean>
 
 <bean id="getChinesePeople" factory-bean="peopleFactory" factory-method="getPeople">
  <constructor-arg>
   <value>china</value>
  </constructor-arg>
  <property name="name">
   <value>张三</value>
  </property>
 </bean>
 
 <bean id="getAmericanPeople" factory-bean="peopleFactory" factory-method="getPeople">
  <constructor-arg>
   <value>1</value>
  </constructor-arg>
  <property name="name">
   <value>sum</value>
  </property>
 </bean>
</beans>
-----------------------------------------------------------------------------
调用实例工厂方法创建bean，与调用静态工厂方法创建bean的用法基本相似。区别如下：
    1.调用实例工厂方法创建bean时，必须将实例工厂配置成bean实例。而静态工厂方法则无需配置工厂bean.
    2.调用实例工厂方法创建bean时，必须使用factory-bean属性来确定工厂bean.而静态工厂方法则使用class元素确定静态工厂类。
相同之处：
    1.都需要使用factory-method属性指定生产bean实例的工厂方法。
    2.工厂方法如果需要参数，都使用constructor-arg属性确定参数值。
    3.其他依赖注入属性，都使用property元素确定参数值。


-------以上的文字以及代码摘录于李刚写的《轻量级J2EE开发企业应用实战》，代码有少许变动！

  2006年1月27日，是沃尔夫冈·阿玛迪乌斯·莫扎特250周年诞辰。35年的生命短暂，却如烟花般灿烂。在这个奥地利人身后，留下的是后人代代咏 叹的传世音乐。而近十几年，据称“能够提高人的智商，改善人体机能和空间感知能力”的“莫扎特效应”则让人们了悟：原来莫扎特，不仅仅是用来享受的。
    卡蒂亚·伊利亚德是生活在巴黎的一位艺术家。在相当长的时间里，伊利亚德曾陷入茫然无措的困境。她觉得缺乏创造力，整个人失去了艺术灵感，而且因为某种她自己也无法解释的原因，她甚至不能在抽象画里使用蓝色或绿色。
    于是从去年春天开始，伊利亚德接受了一项非常规治疗：用一个特制的、可筛掉某些低音部的震动耳机，连续三周每天听莫扎特的音乐两小时。这位33岁的艺术家 说，疗效是非凡的。“当我独处、与别人相处，或是做任何事情时，都轻松自如得多。就好像我在几个月里完成了别人10年的心理治疗。”蓝色和绿色也重新回到 了她的画布上。“现在对我来说，莫扎特就像是一个当你半夜从噩梦中惊醒后，能宽慰你重新安然入眠的老祖父。”伊利亚德说。
    他写出的音乐就是处方
    1756年1月27日，莫扎特在奥地利的萨尔茨堡出生。正如他的名字阿玛迪乌斯在拉丁语中意为“上帝的宠儿”，他不可思议的天赋的音乐才华，让他即使身处那个没有“传媒”的时代，也声名赫赫。
    这位200多年前被父亲利奥波德在欧洲皇室到处展示其天才的少年，这个喜欢黄色笑话的口出狂言的小子，最近十多年来被冠以一个最具争议性的全新角色：他是 位医生，他写出的音乐就是处方。外科医生说，听莫扎特的音乐，能降低癫痫病者发病的频率和强度；儿科医生说，莫扎特能治疗您童年时期的各种障碍，比如口 吃；甚至老年痴呆者听了他的音乐都不那么痴呆，更重要的是，莫扎特还能让你的孩子更聪明。
    “无所不能”的美国科学家据说发现了“莫扎特效应”的“分子基础”。1999年，美国神经生物学家利用核磁共振绘出了受试者大脑中对莫扎特音乐、20世纪 30年代流行音乐和贝多芬音乐发出反应的区域。所有音乐都刺激了大脑的听觉皮质，“但莫扎特的音乐使整个大脑皮层都兴奋起来”，而且也刺激了大脑中分管运 动协调、视觉的区域。
    加州大学的研究者还发现，某些老年痴呆症患者在听莫扎特的音乐10分钟后，在智力测试中会有较好的表现。美国著名临床神经科学家丹尼尔·阿门所著的《大脑 处方》一书中也提到，一项研究发现，聆听莫扎特的音乐对治疗儿童多动症有帮助。听莫扎特音乐的那组儿童的“西他”脑电波（多动症患者的这种脑电波往往过 多）明显减少，同时变得更为专注，控制情绪的能力也大为提高，社交技巧也有较大改善。
    “听莫扎特能提高智商”
    目前为止流传最广、也最受争议的是所谓“莫扎特音乐能提高人的智商”，使孩子变得更聪明。支持这个观点的科学依据首次出现在1993年的《自然》杂志上， 有篇文章写到，给大学生们播放莫扎特《D大调双钢琴奏鸣曲》第一乐章后，他们的空间推理能力有很大提高。比如，与听放松指令和不听音乐时相比，听了音乐的 大学生智商得分提高了8－9分。这种现象就是后来被广泛传播的“莫扎特效应”。这篇论文的主要作者、美国威斯康辛州立大学副教授弗朗西丝·劳舍尔本身也是 一位大提琴演奏家。
    此后十多年，劳舍尔的研究引发了一场学术风暴，她的同行们对新发现或修正或抨击，并衍生了许多相关研究，还导致了一场流行心理学热潮，“莫扎特音乐使人更 聪明”的观点开始流行。现在莫扎特曲子已经成了最受欢迎的胎教音乐。“莫扎特效应”也引起了美国政府的极大关注，1998年，美国佐治亚州政府开始向每位 新生儿免费发放古典音乐CD，在科罗拉多州等地也有类似计划。
    不过，对于自己的研究成果被曲解，劳舍尔愤怒得像只刺猬，“从来没人说过听莫扎特会让人变得更聪明。”她说，她的研究只表明试验对象的空间推理能力得到暂 时和有限的提高，而非在智商上有根本提升。劳舍尔最近甚至开始修正自己最初的结论，她认为听莫扎特对大脑的好处可能只不过与做某种令人享受的事情时所得到 的一般性反应相当。但借“莫扎特效应”发了财的坎贝尔先生毫不慌乱地“见招拆招”：科学证明不了什么，也反驳不了什么。我们不理解为什么音乐会对大脑产生 影响，但听音乐总是有好处。
    坎贝尔先生这句话算是说到点子上。人们十多年来一直希望解开大脑与音乐之间的迷团。有研究显示，当一个人听音乐时大脑的许多不同部分都处于活跃状态，其中 一些最活跃的部分与人们进行空间推理时的活跃部分是相交叠的。但科学无法解释的是，为什么有些音乐片段对人脑的刺激明显强于其他部分。另一个问题是，为什 么是莫扎特、而不是其他人的音乐引发这么多争论？

“他的音乐直接作用于大脑”
    有人相信，莫扎特的音乐被神话了，从印度船歌到海潮扑岸，各种令人愉悦的声音都能在病理学上对病人起到安慰作用，巴黎歌剧院的艺术总监杰拉尔德·莫迪耶就 是持这种观点的人。“每个人都有属于自己最适合的音乐。有人可以听《勃兰登堡协奏曲》（巴赫），有人可以听《特里斯坦和伊索尔德》（瓦格纳的歌剧），有人 的药是舒伯特，有人的药是莫扎特。”莫迪耶说。
    尽管如此，位于芝加哥的美国伊利诺斯大学医学中心专攻癫痫症的神经外科专家约翰·休斯还是认为，莫扎特音乐的治疗效果最好。休斯曾抱着尝试心态给他的一名 癫痫病人播放了与劳舍尔试验中相同的莫扎特乐曲《D大调双钢琴奏鸣曲》，结果他惊讶地发现，病人的癫痫发作频率大幅降低。他又对另外36名病人进行尝试， 其中29人的症状得到减轻。“效果是毋庸置疑的，莫扎特音乐对80％的癫痫病人都产生了良好的疗效。”休斯也用其他古典音乐做过试验，但他发现只有莫扎特 的音乐疗效明显且持续。
    休斯认为，关键在于莫扎特音乐重复的频率。“他的音乐比较简单，总是让某一旋律多次重复，而且是以大脑喜欢的模式。”巴赫的某些音节很高，门德尔松和海顿 的音乐亦然。而莫扎特的音乐相对和缓，音乐模式平均每20－30秒会重复一次，这与脑电波和中枢神经系统的某些活动时间相一致；这一频率恰好中和了癫痫病 人脑部不规则的活动，可能这就是莫扎特音乐神奇效果的奥秘所在。休斯说：“我的病人大多数都处于昏迷中，因此莫扎特音乐的效果不能用那套抚慰情绪的理论解 释。他的音乐能直接作用于大脑。”对于莫扎特音乐的神奇效果，米歇尔·珂泉不知道原因，却至少看到了结果，因为它真实地发生在了她患有自闭症的6岁女儿露 西身上。“她以前常常独自坐在角落，一声不吭。”珂泉说。两年前，她带着女儿去了刘易斯市（英格兰东苏赛克斯郡首府）的一个音乐治疗中心。珂泉承认自己一 开始充满怀疑，但现在完全改变了想法。“第一个让我吃惊的转变就是露西竟然能坐在那里，安安静静地听两个小时的莫扎特，而且一听就是连续14天。”随着治 疗次数的增多，女儿一天天好转的病情让珂泉简直惊喜得发抖。“露西开始交朋友。她与外界的眼神交流增多，语言能力也提高得很快，就好像一夜之间她把自己打 开了。”
    催熟葡萄催产奶牛的奇迹
    不过在正式的音乐疗法界，“莫扎特效应”却被视为一种经由过分炒作而形成的接近迷信的现象。注册音乐治疗师通常会让自闭儿或残障儿童自己作曲，以表达自我 和与他人沟通。在英国，“音乐治疗师”作为一个新行当在1999年获得政府正式承认。作为专业的音乐治疗人士，伦敦罗宾斯音乐治疗中心的加里·安斯戴尔代 表不少同行表达了对“莫扎特效应”的不屑。“音乐疗法的重点是主动地创作音乐，而非被动地听音乐。实际情况要复杂得多，我们不能简单地将之归因为所谓的‘ 莫扎特效应’。”
    但在这个属于莫扎特的诞辰纪念时刻，任何有关他的奇迹似乎都是可能的。意大利托斯卡纳大区的一名葡萄园主卡洛·卡格诺兹宣称，莫扎特的音乐对种植葡萄也有 神奇效果，在过去五年里，他都坚持给葡萄播放莫扎特音乐。卡格诺兹说，当他还是个小伙子的时候就兴起了这个念头。“我当时就想，要是能用手风琴给葡萄演奏 莫扎特就好了。”成了葡萄种植园主后，他实现了梦想：昼夜不停地在他的葡萄园播放莫扎特。“这产生了戏剧性效果，葡萄成熟得更快，而且还能驱走害虫和鸟 类。”德国北莱茵-威斯特法伦州牛奶业协会也作了一项调查：听了莫扎特《小夜曲》的奶牛，产奶量增加了0.6%。
    即使莫扎特真的如传闻中繁华一世、却最终潦倒地葬在维也纳一个公墓中的话，他也应该能在九泉下偷笑了：200多年了，他创造的神话从未中断———先是他的音乐，现在是关于他音乐的奇迹。

莫扎特年表

    奥地利作曲家沃尔夫冈·阿玛迪乌斯·莫扎特（WolfgangA－madeusMozart），与海顿、贝多芬并称为维也纳古典乐派三大作曲家。
    莫扎特3岁起显露音乐才能，4岁跟随父亲学习钢琴，5岁作曲，6岁又随父亲学小提琴，8岁创作了一批奏鸣曲和交响曲，11岁写了第一首歌剧。繁重的创作、演出和贫困的生活损害了他的健康，使他在35岁时就离开了人世。
    以平均每年20部作品的速度，莫扎特总共创作了626部音乐作品，涉及几乎所有的音乐体裁，最重要的成就当推歌剧。代表作有歌剧《费加罗的婚礼》、《唐· 璜》、《魔笛》；交响乐《降E调第39号交响曲》(帝王)、《G小调第40号交响曲》、《C大调第41号交响曲》(丘比特);协奏曲《D大调小提琴协奏曲 第4号》、《降B大调小提琴协奏曲第5号》、《C大调钢琴协奏曲第21号》、《A大调钢琴协奏曲第23号》等。

    1756.1.27生于奥地利萨尔茨堡。1761办音乐会，创作第一支作品，钢琴短曲。
    1762父亲开始带莫扎特姐弟俩到欧洲旅行演出，为期十年。
    1768歌剧《巴斯蒂安与巴斯蒂安娜》在维也纳首演。
    1769在萨尔茨堡大主教府工作。
    1781遭萨尔茨堡大主教府解雇。到维也纳，写作、演出和授课使他生活奢华。
    1782与20岁的康施坦莎·韦伯结婚。歌剧《后宫诱逃》在维也纳首演。
    1786歌剧《费加罗的婚礼》在维也纳首演。
    1787歌剧《唐·璜》在布拉格首演。
    1790歌剧《女人心》在维也纳首演。
    1791歌剧《魔笛》在维也纳首演。1791125卒于维也纳贫民窟。《安魂曲》未完成。

原载美国《时代》周刊 彼得·康贝尔撰文 早报记者 王靓 编译

一、ARP病毒分析
     arp病 毒，一种地址欺骗的病毒。当局域网内某台主机运行ARP欺骗的木马程序时，会骗欺局域域网内所有主机和路由器，让所有上网的流量必须经过病毒主机。其他用 户原来直接通过路由器上网现在转由通过病毒主机上网，切换的时候用户会断一次线。切换到病毒主机上网后，如果用户已经登陆了游戏服务器，那么病毒主机就会 经常伪造断线的假像，那么用户就得重新登录游戏服务器，这样病毒主机就可以盗号了。
     感染arp病毒故障现象：机器以前可正常上网的，突然出现可认证，不能上网的现象（无法ping通网关），重启机器或在MSDOS窗口下运行命令ARP -d后，又可恢复上网一段时间。

     二、ARP病毒故障原因：这是arp病毒欺骗攻击造成的。
     引起问题的原因一般是由传奇外挂携带的ARP病毒木马攻击。当在局域网内使用上述外挂时，外挂携带的病毒会将该机器的MAC地址映射到网关的IP地址上，向局域网内大量发送ARP包，从而致使同一网段地址内的其它机器误将其作为网关，这就是为什么掉线时内网是互通的，计算机却不能上网的原因。

    三、arp病毒临时处理对策：

步骤一. 在能上网时，进入MS-DOS窗口，输入命令：arp –a 查看网关IP对应的正确MAC地址，将其记录下来。
注：如果已经不能上网，则先运行一次命令arp –d将arp缓存中的内容删空，计算机可暂时恢复上网（攻击如果不停止的话），一旦能上网就立即将网络断掉（禁用网卡或拔掉网线），再运行arp –a。
     步骤二. 如果已经有网关的正确MAC地址，在不能上网时，手工将网关IP和正确MAC绑定，可确保计算机不再被攻击影响。手工绑定可在MS-DOS窗口下运行以下 命令： arp –s 网关IP 网关MAC 例如：假设计算机所处网段的网关为218.197.192.254，本机地址为218.197.192.1在计算机上运行arp –a后输出如下：
C:\Documents and Settings>arp -a Interface: 218.197.192.1 --- 0x2 Internet Address Physical Address Type
218.197.192.254 00-01-02-03-04-05 dynamic 其中00-01-02-03-04-05就是网关218.197.192.254对应的MAC地址，类型是动态（dynamic）的，因此是可被改变。被 攻击后，再用该命令查看，就会发现该MAC已经被替换成攻击机器的MAC，如果大家希望能找出攻击机器，彻底根除攻击，可以在此时将该MAC记录下来，为 以后查找做准备。 手工绑定的命令为： arp –s 218.197.192.254 00-01-02-03-04-05 绑定完，可再用arp –a查看arp缓存， C:\Documents and Settings>arp -a Interface: 218.197.192.1 --- 0x2 Internet Address Physical Address Type 218.197.192.254 00-01-02-03-04-05 static 这时，类型变为静态（static），就不会再受攻击影响了。但是，需要说明的是，手工绑定在计算机关机重开机后就会失效，需要再绑定。所以，要彻底根除 攻击，只有找出网段内被病毒感染的计算机，令其杀毒，方可解决。找出病毒计算机的方法： 如果已有病毒计算机的MAC地址，可使用NBTSCAN软件找出网段内与该MAC地址对应的IP，即病毒计算机的IP地址，然后可报告校网络中心对其进行 查封。 NBTSCAN的使用方法：下载nbtscan.rar到硬盘后解压，然后将cygwin1.dll和nbtscan.exe两文件拷贝到 c:\windows\system32(或system)下，进入MSDOS窗口就可以输入命令： nbtscan -r 218.197.192.0/24 （假设本机所处的网段是218.197.192，掩码是255.255.255.0；实际使用该命令时，应将斜体字部分改为正确的网段） 。
注：使用nbtscan时，有时因为有些计算机安装防火墙软件，nbtscan的输出不全，但在计算机的arp缓存中却能有所反应，所以使用nbtscan时，还可同时查看arp缓存，就能得到比较完全的网段内计算机IP与MAC的对应关系。
补充一下：
Anti ARP Sniffer 使用说明
1、功能说明: 使用Anti ARP Sniffer可以防止利用ARP技术进行数据包截取以及防止利用ARP技术发送地址冲突数据包。
2、使用说明：
1、ARP欺骗： 填入网关IP地址，点击［获取网关mac地址］将会显示出网关的MAC地址。点击[自动防护]即可保护当前网卡与该网关的通信不会被第三方监听。 注意：如出现ARP欺骗提示，这说明攻击者发送了ARP欺骗数据包来获取网卡的数据包，如果您想追踪攻击来源请记住攻击者的MAC地址，利用MAC地址扫 描器可以找出IP 对应的MAC地址。
2、IP地址冲突 首先点击“恢复默认”然后点击“防护地址冲突”。 如频繁的出现IP地址冲突，这说明攻击者频繁发送ARP欺骗数据包，才会出现IP冲突的警告，利用Anti ARP Sniffer可以防止此类攻击。 首先您需要知道冲突的MAC地址，Windows会记录这些错误。查看具体方法如下：
右击[我的电脑]-->[管理]-->点击[事件查看器]-->点击[系统]-->查看来源为[TcpIP]--->双击 事件可以看到显示地址发生冲突，并记录了该MAC地址，请复制该MAC地址并填入Anti ARP Sniffer的本地MAC地址输入框中(请注意将:转换为-)，输入完成之后点击[防护地址冲突]，为了使MAC地址生效请禁用本地网卡然后再启用网 卡，在CMD命令行中输入Ipconfig /all，查看当前MAC地址是否与本地MAC地址输入框中的MAC地址相符。如果成功将不再会显示地址冲突。 注意:如果您想恢复默认MAC地址,请点击[恢复默认],为了使MAC地址生效请禁用本地网卡然后再启用网卡。

     四、定位arp病毒攻击源头和防御方法
1．定位arp病毒攻击源头
主动定位方式：因为所有的arp病毒攻击源都会有其特征——网卡会处于混杂模式，可以通过ARPKiller这样的工具扫描网内有哪台机器的网卡是处于混杂模式的，从而判断这台机器有可能就是“元凶”。定位好机器后，再做病毒信息收集，提交给趋势科技做分析处理。
标注：网卡可以置于一种模式叫混杂模式（promiscuous），在这种模式下工作的网卡能够收到一切通过它的数据，而不管实际上数据的目的地址是不是它。这实际就是Sniffer工作的基本原理：让网卡接收一切它所能接收的数据。

被动定位方式：在局域网发生arp病毒攻击时，查看交换机的动态ARP表中的内容，确定攻击源的MAC地址；也可以在局域居于网中部署Sniffer工具，定位arp病毒攻击源的MAC。
也可以直接Ping网关IP，完成Ping后，用ARP –a查看网关IP对应的MAC地址，此MAC地址应该为欺骗的MAC。
使用NBTSCAN可以取到PC的真实IP地址、机器名和MAC地址，如果有”ARP攻击”在做怪，可以找到装有ARP攻击的PC的IP、机器名和MAC地址。

命令：“nbtscan -r 192.168.16.0/254”（搜索整个192.168.16.0/254网段, 即192.168.16.1-192.168.16.254）；或“nbtscan 192.168.16.25-137”搜索192.168.16.25-137 网段，即192.168.16.25-192.168.16.137。输出结果第一列是IP地址，最后一列是MAC地址。
NBTSCAN的使用范例：
假设查找一台MAC地址为“000d870d585f”的病毒主机。
1）将压缩包中的nbtscan.exe 和cygwin1.dll解压缩放到c:下。
2）在Windows开始—运行—打开，输入cmd（windows98输入“command”），在出现的DOS窗口中输入：C: btscan -r 192.168.16.1/24（这里需要根据用户实际网段输入），回车。
3）通过查询IP--MAC对应表，查出“000d870d585f”的病毒主机的IP地址为“192.168.16.223”。
通过上述方法，我们就能够快速的找到病毒源，确认其MAC——〉机器名和IP地址。
2．防御方法
a.使用可防御arp病毒攻击的三层交换机，绑定端口-MAC-IP，限制ARP流量，及时发现并自动阻断ARP攻击端口，合理划分VLAN，彻底阻止盗用IP、MAC地址，杜绝ARP的攻击。
b.对于经常爆发病毒的网络，进行Internet访问控制，限制用户对网络的访问。此类ARP攻击程序一般都是从Internet下载到用户终端，如果能够加强用户上网的访问控制，就能极大的减少该问题的发生。

c.在发生ARP攻击时，及时找到病毒攻击源头，并收集病毒信息，可以使用趋势科技的SIC2.0，同时收集可疑的病毒样本文件，一起提交到趋势科技的TrendLabs进行分析，TrendLabs将以最快的速度提供病毒码文件，从而可以进行ARP病毒的防御。


ARP病毒运作基理:
1.LOADHW.EXE 执行时会释放两个组件npf.sys 和msitinit.dll .
LOADHW.EXE释放组件后即终止运行.
注意: 病毒假冒成winPcap的驱动程序,并提供winPcap的功能. 客户若原先装有winPcap,
npf.sys将会被病毒文件覆盖掉.
2.随后msitinit.dll将npf.sys注册(并监视)为内核级驱动设备: "NetGroup Packet Filter Driver"
msitinit.dll 还负责发送指令来操作驱动程序npf.sys (如发送arp欺骗包, 抓包, 过滤包等)
以下从病毒代码中提取得服务相关值:
BinaryPathName = "system32\drivers\npf.sys"StartType = SERVICE_AUTO_STARTServiceType= SERVICE_KERNEL_DRIVERDesiredAccess= SERVICE_ALL_ACCESSDisplayName = "NetGroup Packet Filter Driver"ServiceName = "Npf"
3. npf.sys 负责监护msitinit.dll. 并将LOADHW.EXE注册为自启动程序:
[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce]
dwMyTest =LOADHW.EXE
注: 由于该项位于RunOnce下,该注册表启动项在每次执行后,即会被系统自动删除.

------------------------------------------------------
转自 中国协议分析网 http://www.cnpaf.net/forum/thread-24200-1-4.html