第一章--Spring之旅

時間 2019-12-07

原文原文鏈接

完整代碼請見：https://github.com/codercuixi...
爲了下降Java開發的複雜性，Spring採用瞭如下4種策略：java

基於pojo的輕量級和最小侵入式編程
經過依賴注入和麪向接口實現鬆耦合
基於切面和慣例進行聲明式編程
經過切面和模板減小樣本式代碼

一. 依賴注入

（利用面向接口編程的思想，由Spring應用上下文負責依賴注入）
經過依賴注入（DI ,Dependency Inject),對象的依賴關係由系統中負責協調各對象的第三方組件在建立對象的時候進行設定。對象無需自行建立或管理他們的依賴關係，如圖1.1所示，依賴關係被自動注入到須要他們的對象中去。

Spring經過應用上下文（Application Context)來裝在bean定義並把組裝起來。Spring自帶了不少不少應用上下文，他們之間的區別僅僅在於如何加載配置。git

兩種方式來表示Spring的應用上下文。

1.註解（牆裂推薦使用）

1經過@Configuration來聲明這個類是Java Bean的配置類，經過在具體的方法前面添加@Bean註解來聲明一個Bean

package sia.knights;

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;

    import java.io.PrintStream;

    /**
     * Create by cuixin on 2018/8/25 
     **/ 
    @Configuration public class KnightConfig {
        @Bean
      public Knight knight() {
            return new BraveKnight(quest());
        }

        @Bean
      public Quest quest() {
            return new SlayDragonQuest(stream());
        }

        @Bean
      public PrintStream stream() {
            return new FakePrintStream();
        }
    }

1.2. 經過@ContextConfiguration來配置Spring應用上文下信息github

package sia.knights;

    import org.junit.After;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    import org.springframework.test.context.support.AnnotationConfigContextLoader;

    import javax.annotation.Resource;

    /**
     * Create by cuixin on 2018/8/25 
     **/ 
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = KnightConfig.class, loader = AnnotationConfigContextLoader.class)
    public class KnightJavaConfigInjectionTest {
        @Autowired
      private Knight knight;
        @Resource
      private FakePrintStream printStream;

        @After
      public void clearPrintStream() {
            printStream.clear();
        }

        @Test
      public void shuoldInjectKnightWithSlayDragonQuest() {
            knight.embarkOnQuest();
            assert "Embarking on quest to slay the dragon!\n".equals(printStream.getPrintedString());
        }
    }

2.xml配置文件（基本已經棄用）

2.1. knigh.xmlweb

<?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>

2.2 經過Spring提供的ClassPathXmlApplicationContext或者FileSystemXmlApplicationContext來尋找xml配置文件spring

package sia.knights;

    import org.springframework.context.support.ClassPathXmlApplicationContext;

    /**
     * Create by cuixin on 2018/8/24
     **/ 
     public class KnightMain {
        public static void main(String args[]){
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/knight.xml");
            Knight knight = context.getBean(Knight.class);
            knight.embarkOnQuest();
            context.close();
        }
    }

二.面向切面編程 AOP

面向切面編程(aspect-oriented programming,AOP)容許你把遍及應用各處的功能分離出來造成可重用的組件。express

系統由多個組件組成，好比核心業務，日誌，事務管理和安全。編程

日誌，事務管理和安全這樣的系統服務常常融入到具備核心業務邏輯的組件中去，這些系統服務經過被稱爲橫切關注點。安全

若是無論不問，那麼這些橫切關注點會重複出如今多個組件中，也會增長每個組件的複雜性。框架

AOP可以使這些服務模塊化，而且以聲明的方式將他們須要影響的組件中去。咱們能夠將切面想象成爲覆蓋在不少組件之上的一個外殼。
模塊化

2.1. 利用xml配置aop

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

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

   <aop:config>
     <aop:aspect ref="minstrel">
        <aop:pointcut id="embark" expression="execution(* *.embarkOnQuest(..))"/>
        <aop:before pointcut-ref="embark" method="singBeforeQuest"/>
        <aop:after pointcut-ref="embark" method="singAfterQuest"/>
    </aop:aspect>
   </aop:config>
 </beans>

三. 使用模板消除樣本式代碼

樣板代碼：爲了實現通用的和簡單的任務，不得不一遍遍重複寫的代碼。

3.1 容納你的Bean

在基於Spring的應用中，你的應用對象存在於Spring容器（container）中，如圖1.4所示，Sring容器負責建立帝鄉，裝配他們，配置他們並管理他們的整個生命週期，從生存到死亡（在這裏，可能就是new到finalize）。

容器是Spring的核心。Spring容器使用DI管理構成應用的組件，他會建立相互協做的組件之間的關聯。

3.2 Spring容器的兩種實現類型實現

3.2.1. bean工廠不經常使用。
由org.springframework.benas.factory.BeanFactory接口定義，是簡單的容器，提供最簡單的DI支持。應用上下文由orgspringframework.context.ApplicationContext接口定義）基於BeanFactory構建，並提供應用框架級別的

3.2.2.使用應用上下文

AnnotationConfigApplicationContext: 從一個或多個基於Java的配置類中加載Spring應用上下文
ApplicationContext context = new AnnotationConfigApplicationContext(KnightConfig.class)

AnnotationConfigWebApplicationContext:從一個或多個基於Java的配置類中加載Spring Web應用上下文
ClassPathXmlApplicationContext:從類路徑下的一個或多個xml配置文件中加載上下文定義，把應用上下文的定義文件做爲類資源

ApplicationContext context = new ClassPathXmlApplicationContext("knight.xml")

FileSystemXmlApplicationContext:從文件系統的一個或多個xml配置文件中加載上下文定義

ApplicationContext context = new FileSystemXmlApplicationContext("c://knight.xml")

XmlWebApplicationContext:從Web應用的一個或多個xml配置文件中加載上下文定義。