Spring之路----Chapter01 Spring之旅

1. Spring应用组件：指的是bean或者JavaBean(POJO--普通或者简单java对象)

2.Spring降低Java开发的复杂性的4种策略：

     .基于POJO的轻量级和最小侵入性编程

      通过依赖注入(DI)和面向接口实现松耦合

      基于切面和惯例进行声明式编程

      通过切面(AOP)和模板减少样板式代码

里面的几个问题留待学习中来解决：

     (1) 什么叫最小侵入式编程

               1）不强迫你实现Spring规范的接口或者继承Spring规范的类；

               2）Spring中的类没有任何痕迹显示你使用了Spring

               3）这个类在Spring应用和非Spring应用都可以发挥相同的作用

     (2) 什么叫面向接口实现松耦合？

     (3) 什么叫惯例？

     (4) 什么叫模板？如何用模板来减少样板式代码？

3. 依赖注入(DI)---帮助应用对象(Java对象)保持松耦合；用来装配【什么叫装配，就是创建应用逐渐之间协作的行为，装配的方式之一就是.xml文件】POJO

    (1) 传统做法:每个对象负责管理与自己相互协作的对象(即它所依赖的对象)的引用

           缺点：导致高度耦合和难以测试的代码

package com.springinaction.knights;

public class DamselRescuingKnight implements Kight{

  private RescueDamselQuest quest;
  
  public DamselRescuingKnight (){

        this.quest = new RescueDamseQuest();
   }  

   public void embarkOnQuest (){
             
         quest.embark():
   }
}

存在的问题：

      1). this.quest = new RescueDamseQuest();使得新创建的RescueDamselQuest和DamselRescuingKnight紧密的耦合到了一起

      2).测试代码难

  (2) 依赖注入作为第三方组件负责各个类对象之间的关系，并在创建对象时进行设定。

  (3) 依赖注入会将所依赖的关系自动交给目标对象，而不是让对象自己去获取；

package com.springinaction.knights;
  
  public class BraveKnnight implements Kight{
 
    private Quest quest;
    
    public DamselRescuingKnight (Quest quest){
 
         this.quest = quest;
   }  
 
    public void embarkOnQuest (){
              
         quest.embark():
    }
}

优点:

       1)  BraveKnight没有自行创建任务，而是在构造的时候把探险任务作为构造器参数传入---依赖注入的方式之一-构造器注入

       2)只要实现了Quest接口的请求都可以注入，也就是说现在BraveKnight可以相应RescueDamelQuest、SlayDrag等quest，而没有写死，像第一个代码例子只能接受一种请求。

【如果一个对象智通过接口，而不是具体实现或者初始化过程来表明依赖关系，那么这种依赖就能够在对象毫不知情的情况下用具体的实例进行替换】----用于mock测试

Spring 通过应用上下文(Application Context)装载bean的定义，并把他们组装起来，应用上下文全权负责对象的创建和组装。

package sia.knights;

import org.springframework.context.support.
                   ClassPathXmlApplicationContext;

public class KnightMain {

  public static void main(String[] args) throws Exception {
    ClassPathXmlApplicationContext context = 
        new ClassPathXmlApplicationContext(
            "META-INF/spring/knight.xml");
    Knight knight = context.getBean(Knight.class);
    knight.embarkOnQuest();
    context.close();
  }

}

main()方法基于knights.xml文件创建了Spring应用上下文(容器)：

ClassPathXmlApplicationContext context = 
         new ClassPathXmlApplicationContext(
             "META-INF/spring/knight.xml");

随后它调用该应用上下文(容器对象)获取一个ID为knight的bean；创建bean对象的任务交给容器了

 Knight knight = context.getBean(Knight.class); 

相应的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.xsd">

  <bean id="knight" class="sia.knights.BraveKnight">
    <constructor-arg ref="quest" />
  </bean>

  <bean id="quest" class="sia.knights.SlayDragonQuest">
    <constructor-arg value="#{T(System).out}" />
  </bean>

</beans>

bean元素的作用是，当我们的spring框架加载时候，Spring就会自动的创建一个bean对象，并放入内存

<bean id="userService" class="com.service.UserService">
            //这里体现出注入概念，将属性的值注入到bean中去了
           <property name = "name">
                     <value>韩顺平</value>
           </property>
             //Spring维护两个bean组件之间的关系
             <property name = "byeService" ref="bybService"/>

</bean>

//等价于
UserService userService = new UserService（）；
userService.setName("韩顺平")；

1. 使用spring，

1. Spring容器入则创建对象，装配他们，配置它们并管理它们的整个生命周期，从生存到死亡.

2. Spring自带了对个容器实现，分为bean工厂(BeanFactory，由org.springframework. beans.
factory.eanFactory接口定义)-最简单的容器和应用上下文（由org.springframework.context.ApplicationContext
接口定义）

3.应用上下文的分类：

      AnnotationConfigApplicationContext

      AnnotationConfigWebApplicationContext

      ClassPathXmlApplicationContext

       FileSystemXmlapplicationcontext

       XmlWebApplicationContext