day1
什么是Spring？
    開源、輕量級

Spring 特征：
    1.B/S 和 C/S，使用資源小
    2.對象間的關系松，高內聚，低耦合
      IOC --- Inverse of control 
         使得業務組件都處在框架的管理之下
         框架可以管理組件的創建和依賴關系
         框架可以提供可以配置的服務
    3.通過AOP技術將業務與非業務分離
      AOP --- Aspect Oreinted Programming
      在不修改組件的前提下，為組件提供擴展的服務
    4.Spring容器管理整個JavaBean生命周期
      簡化對j2ee技術的使用
    5.與Hibernate、Struts一樣是個框架
      (類集合) (框架提供) 
    6.Spring是一個全方位的框架
      SpringMVC 類似 Struts

Spring框架在多層開發中位于那一層？或哪幾層？
    框架簡化開發過程，提供公共服務和便利的工具
    1.業務邏輯層 (Ioc *AoP) 最擅長的一層
    2.表現層    (SpringMVC Web B/S都有) 
    3.數據持久層 (SpringDAO ORM) 

什么是IoC：
    1.IOC --- Inverse of control (控制反轉) 
       A主動創建B的實例：正向控制
      過去：拉模型
           組件決定自己依賴的對象的創建 
           接口沒有在松散耦合中起到太大作用
      IOC：推模型，也叫做依賴注入
           采用工廠模式管理應用組件的創建，管理組件的依賴關系 
           用接口表達組件間的依賴
      依賴注入的方式
        1)構造方法注入
        2)set 方法注入
    2.Spring IoC 容器先創建B的實例，再把B的實例注入A中
    3.執行過程：
      1)執行 BeanFactory 或 ApplicationContext 時，解析 xml 文件
      2)通過反射，執行 JavaBean 的空參構造方法，創建實例
      3)調用 JavaBean 的 set方法，將xml的信息注入到這 JavaBean 實例
        或者執行滿參構造方法創建實例，同時注入 xml 的信息

spring 框架的7個組成部分
    1.BeanFactory -- (低級容器，接口)使用工廠模式實例化組件，裝配組件
       XmlBeanFactory(實現類) 
    2.ApplicationContext (高級容器，接口)--- bean factory 增加事件發布，增加了國際化，資源訪問等的支持
       ClassPathXmlApplicationContext(實現類) 
    3.aop --  提供一種基于聲明方式的AOP
    4.dao 支持--簡化jdbc，聲明的事務
    5.orm 支持-- 簡化使用 Hibernate ,toplink 等持久化框架，方便的事務管理
    6.web 支持-- 在 web 應用中使用 spring 框架的相關支持，協調表現層和業務層的關系
    7.web mvc--- 獨立的 web mvc 框架

    spring 是全方位的框架
    spring 的組成部分相對獨立，可選擇的使用

作業：
    用戶注冊頁面
    要求： Servlet + Spring + JDBC + MySQL
         1.判斷用戶名是否已注冊(保證用戶名唯一性) 
         2.采用B/S架構，使用IoC功能，完成JavaBean的注入。
           在JavaBean不要使用 new 方式創建對象。
         3.連接數據庫時的 driver ，配置在 xml 文件中。








day2
二、控制反轉(inverse of control IOC ) 
    2、Bean 工廠(BeanFactory)的功能和配置
        ClassPathResource
            在類路徑下查找資源
            另有 FileSystemResource
        XmlBeanFactory 
            讀取 xml 文件中的配置信息
            生產bean
            解決bean 依賴
    
    * Bean 的創建
        spring 可調用bean的構造方法，或通過工廠方法生產 bean 對象

    1.利用 bean 的構造方法創建bean
        無參的構造方法
            <bean id="refName" class="foopak.FooClass">
               <property name="username" value="root"/>
               <property name="password" value="123"/>
            </bean>
        有參的構造方法，需指明構造方法的參數列表，通過：
            <bean id="refName" class="foopak.FooClass">
                <construct-arg><value>arg0</value></construct-arg>
                <construct-arg><value>arg1</value></construct-arg>
            </bean>
            表明調用了兩個參數的構造方法

    2.通過工廠方法獲得 bean 對象
        bean 沒有公共的構造方法，需通過工廠類或工廠實例來創建
        分為靜態工廠和實例工廠方法兩種情況
        靜態工廠方法:
            class 指明工廠類，factory-method 指明工廠方法
            如： Connection con=DriverManager.getConnection(url,user,pwd);
            對應的配置：
                <bean id="con" class="java.sql.DriverManager" factory-method="getConnection">
                    <construct-arg><value>jdbc:mysql://localhost/test</value></construct-arg>
                    <construct-arg><value>zhangsan</value></construct-arg>
                    <construct-arg><value>pwd</value></construct-arg>
                </bean>
                工廠方法參數和構造方法參數設置的形式相同
            
             實例工廠方法：    
                要先創建工廠實例，然后再由工廠實例創建產品
                如： Statement stmt = con.createStatement();
                        con 對象是工廠
                        stmt 對象是產品
                配置為：
                 <bean id="con" class="java.sql.DriverManager" factory-method="getConnection">
                       ……
                 </bean>
                 <bean id="stmt" factory-bean="con" factory-method="createStatement"/>
    
    單例 bean
        bean 工廠生產bean 缺省都是單例的
        scope 屬性
            scope="singleton|prototype|request|session"
        后兩者用于web應用中    
         

    通過注入解決bean的依賴

        1 依賴注入的兩種方式
            1) set 注入
                <property name="xxxYy">
                    ……
                </property>
               相當于 setXxxYy(val);
            2) 構造方法注入
                <construtor-arg>……</construtor-arg>
          spring 直接利用了 bean 的 set 或 構造方法
          避免了使用接口注入的侵入性
          
        2 依賴的目標類型分成三種形式：
            1) 基本類型+String  
                <value>data</value>
               類型自動轉化
            2) 對其他bean 的引用  
                <ref bean="target"/>
            3) 集合類型
                list
                props
                set
                map
        
        3 讓spring 自動裝配bean，解決依賴
            autowire 屬性指明自動裝配的依據： 
                    byName--- id=property
                    byType--- 屬性的類型=當前工廠中bean的類型        
                    constructor--構造方法參數的類型=當前工廠中bean的類型
                    autodetect-- constructor ---> byType
            autowire-candidate 屬性
                指明是否作為 autowire 的候選對象
                解決多個候選對象的沖突
                    true --- 
                    false --- 
        4 讓容器檢測 bean 所有的依賴是否都已經滿足
            某個 bean 需要設置好所有屬性
            防止遺漏裝配，在運行后出現莫名奇妙的情況
            dependency-check 屬性指明應檢查的目標類型
                simple -- 基本類型+字符串+集合
                objects --- 對其他bean的依賴
                all 
                none -- 默認值

    管理 Bean 生命周期
        生命周期
            構造
            set
            回調初始化方法
            getBean 返回
        回調方法：
            兩個屬性指明
                init-method 
                destroy-method 
            或實現兩個接口：
                InitiallizingBean
                DisposableBean
            
    重用 bean 定義
        parent -- 繼承 bean 定義
                    bean 之間不一定有繼承關系
        abstract --- 只作為模板，不可以被實例化
    
    補充：
        name
            id=""
            name="/myBean"
            name="a b c"
            
        延遲加載bean
            bean 的加載時機
                預先加載
                    構造 bean 工廠時實例化所有bean
                延遲加載
                    getBean 時構造
                    先構造依賴的bean

                BeanFactory 總是延遲加載的
                ApplicationContext 
                    BeanFactory 的擴展
                    預先加載 單例 bean
                    lazy-init (true|false)

    3、ApplicationContext
     BeanFactory 的擴展，為應用提供國際化和事件框架的支持

    1)I18N(國際化)
    ApplicationContext 可以讀取國際化的消息文件
        getMessage();
    
    實施：
        1)注冊消息源
        <bean id="messageSource" 
            class="ResourceBundelMessageSource">
            <property name="basename">
                <value>MessageResource</value>
            </property>
        </bean>    
        bean 的id 必須是"messageSource"
        2)讀取消息
        ApplicationContext 的方法：
            getMessage(String key,String[] args,Locale l);
                key - 消息的key
                args- 插入到消息中的參數
                l - 區域
                    Locale 語言和區域代碼的封裝對象
                        locale=new Local("zh","CN");
                            local=Locale.getDefault();
    思考：工廠管理的組件怎樣使用獲得國際化消息
    
    注意：因為AppicationContext包含了BeanFactory所有的功能，所以優先選擇 ApplicationContext 

    2)事件框架
    提供了一個觀察者模式的框架,快速實現組件間的事件通知
    
    實施：    
        1 所有想得到通知的對象都實現ApplicationListener
        2 事件源發出事件:applicationContext.publishEvent(event);
    自定義事件類
        什么時候需要？
            被觀察者在需要傳輸數據給觀察者時
        怎么做？
            自定義事件類 extends ApplicationEvent
















day3
三、面向切面編程(Aspect oriented Programming) 
    1、代理模式
    定義
        1 A , B 實現了相同的接口，接口要求方法 m
        2 用戶調用A的m，A又調用B的m
         
    解決什么問題(什么時候考慮使用代理模式)
        1 擴展功能，而不修改現有的類 
        2 職責具有清晰的劃分
        
    怎么用    
        Actale--接口 方法 act
        Actor---實現
        Test --- 客戶
        Broker--實現，Actor 的代理
    
    采用代理實現日志
        IFoo
            doA,doB,doC
        Foo
        
        Test -- Test
        FooLogProxy        
                
    
    注意思考：日志代理的弊端
        相同的代碼散落在每一個方法中

    
    2、使用動態代理解決
        下面方法可以直接為接口 Foo 產生代理實例：
            Foo proxy = (Foo) Proxy.newProxyInstance(
                    Foo.class.getClassLoader(),
                    new Class[] 
            { Foo.class },
            handler);
             對 proxy 調用接口定義的方法，都會被分發給:
                handler.invoke()
             handler 是實現InvocationHandler 接口的實例
             這樣就把對多個方法的調用集中起來了
             handler.invoke()然后再分發請求到目標方法

         實施:
            1) 實現 InvocationHandler 接口
            2)產生代理

    3、Spring 的AOP 采用動態代理實現
    一些別扭的概念：
    切面：當前關注的一個代碼的流程，其中可能調用了多個類的多個方法。
    連接點：一個代碼流程中的某個步驟，也就是這個代碼流程中對某個方法的調用。
    通知(Advice)：對于某個方法(連接點)，進行攔截的攔截規則。
    切入點：對于某個方法(連接點)，是否被攔截的判斷(過濾)規則。
    目標對象：某個連接點所在的對象。
    AOP代理：目標對象的代理。

    代理的生成：ProxyFactoryBean(org.springframework.aop.framework.ProxyFactoryBean)
        工廠類，生產代理
        區別于 BeanFactory
    InvocationHandler 的行為 : Advice