Spring框架複習之一

1 Spring基本介紹

(1)Spring概述：

        <1>Spring是一個分層的javaSE/EE full-stack(一站式) 輕量級開源框架。
        <2>Spring的核心是控制反轉(IOC)和麵向切面(AOP)，
        <3>IOC和DI:
                * IOC(Inversion Of Control)控制反轉：將物件的建立權交給spring,提高解耦合性
                * DI(Dependency Injection 依賴注入)：
                    在IOC的環境下，spring建立這個類的過程中，spring將類的依賴屬性也設定進去。
        <4>Spring的IOC的實現原理
            * 傳統建立dao物件方式
                &原始方式：UserDaoImpl ud=new UserDaoImpl(); 
                & 面向介面方式：
                    UserDao ud=new UserDaoImpl();
                    此方式 缺點為：介面和實現類有耦合，兩者聯絡過繁，來回切換底層實現類。
                    好的程式設計應滿足OCP原則 Open-Close Principle，
                    對程式擴充套件是Open的，對修改原始碼是close的。
            * Spring的工廠模式：
                    Spring的工廠模式(工廠物件+反射+配置檔案)控制物件的建立，從而完成介面和實現類的耦合
                    UserDao ud=new UserDaoHibernateImpl();
                    此方式，介面和實現類之間沒有耦合，sprig工廠和介面有耦合。
 

(2)spring主要優勢：分層架構。

    分層結構允許使用者選擇哪一個元件，同時為J2EE應用程式開發提供整合的框架。
    JavaEE開發分成三層架構：
        * WEB層:springMVC
        * 業務層：Bean管理(IOC)
        * 持久層：Spring的JDBC模版，ORM模版

(3)spring的優點

    <1>方便解耦，簡化開發
           Spring就是一個大工廠，維護管理所有物件的建立和關係依賴.
    <2>支援AOP程式設計(縱向重複程式碼橫向抽取，Servlet的過濾器filter 和 Action的攔截器interceptor)
           提供AOP面向切面程式設計，方便實現對程式的許可權攔截，執行監控等功能
    <3>支援宣告式事務
            只需通過配置就可以完成對事物的管理，而無需手動進行。
    <4>方便程式測試
          Spring支援Junit4，可通過註解方便測試Spring程式
    <5>方便整合各種優秀框架
          Spring不排斥各種優秀的開源框架，如對Struts2,Hibernate,Mybatis,Quartz等直接支援。
    <6>降低JavaEE API的使用難度
          Spring對JavaEE的一些難用API(JDBC,JavaMail,遠端呼叫等)，都提供封裝，降低這些API的應用難度。
 

2 Spring配置入門

(1)spring開發包目錄分析

    * docs：API規範幫助文件
    * libs：jar包和原始碼
            六個基本包
                & 四個核心包：
                    <1>spring-core-4.2.4.RELEASE.jar        --core
                    <2>spring-context-4.2.4.RELEASE.jar --context
                    <3>spring-beans-4.2.4.RELEASE.jar       --beans
                    <4>spring-expression-4.2.4.RELEASE.jar  --expression
                & 兩個基本包：
                    <1>com.springsource.org.apache.commons.logging-1.1.1.jar    --logging
                    <2>com.springsource.org.apache.log4j-1.2.15.jar --log4j
    * schema：存放約束檔案
 

(2)為applicationContext.xml配置約束和基本配置介紹

            <1>引入約束
                    * 約束宣告獲取路徑：
                     spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html
                    * 約束宣告如下：
                    <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">
                   </beans>
                   值得一提的是此約束匯入也可以在eclipse中進行配置實現。
            <2>設定STS(Spring Tools Suite Spring框架工具套件) 的XML提示，Schema配置。
                    獲取spring-beans-4.2.xsd檔案路徑：
                    spring-framework-4.2.4.RELEASE\schema\beans\spring-beans-4.2.xsd
            <3>什麼是xsd檔案？
                    * XSD ( XML Schemas Definition )XML結構定義， 是DTD的替代品。
                    * XSD是替代DTD的原因：
                            &比DTD可擴充套件性強，豐富和有用。
                            & 用XML書寫，支援資料型別，支援名稱空間。
                    * XML Schema(XSD語言)：
                        Schema本身是一個XML文件，它符合XML語法結構，可以用通用的XML解析器解析它。
                        Schema指定一個XML文件所允許的結構和內容，並可據此檢查一個XML文件是否是有效的。
            <3>基本標籤<bean>介紹：
                    * Bean元素描述需要 被spring容器管理的物件
                       其屬性特性為：
                                  class屬性:被管理物件的完整類名
                                   name屬性:給被管理的物件起一個名字,獲得物件時根據該名稱獲得物件,
                                                    可以重複,命名中可包含特殊字元
                                   id屬性:與name屬性一模一樣(是早期產生的),但名稱不可重複,
                                            不能使用特殊字元，儘量使用name屬性
                    * 模板示例：
                        <beans ..................................>
                            <bean id="" name="" class="">
                            </bean>
                        </beans>
            <4>簡單測試
                        程式碼示例：
                        public interface TestDao {public void sayHello();}
                        public class TestDaoImpl implements TestDao{
                            @Override
                            public void sayHello() {
                                System.out.println("hello spring!");
                            }
                        }
                        配置示例：
                        <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="testDao" class="flower.test.spring.dao.TestDaoImpl"></bean>
                        </beans>
            <5>Spring的IOC控制反轉，管理物件的方式。
                    方式一 空參構造建立：
                        配置檔案：<bean name="user" class="cn.ita.bean.User"></bean>
                        相應的測試程式碼：
                                @Test
                                public void fun1() {
                                    //1 建立容器物件--注意xml檔案路徑是相對於src下的
                                    ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ieate/applicationContext.xml");
                                    //2 向容器要 user物件
                                    User u = (User) ac.getBean("user");
                                    //3 列印user物件
                                    System.out.println(u);
                                }
                    方式二：靜態工廠建立
                        ＆概述：呼叫UserFactory類的靜態方法createUser方法建立名為user2的物件,放入容器中
                        ＆UserFactroy類程式碼
                            public class UserFactory {
                                public static User createUser() {
                                    System.out.println("靜態工廠建立User");
                                    return new User();
                                }
                            }
                        ＆配置檔案書寫
                            <bean name="user2" class="ct.dde.UserFactory" factory-method="createUser">
                            </bean>
                        ＆測試程式碼
                            @Test
                            public void fun2() {
                                //1 建立容器物件--注意xml檔案路徑是相對於src下的
                                ApplicationContext ac=new ClassPathXmlApplicationContext("cn/ithereate/applicationContext.xml");
                                //2 向容器要 user物件
                                User u = (User) ac.getBean("user2");
                                //3 列印user物件
                                System.out.println(u);
                            }
                    方式三：例項工廠建立
                        & 概述：呼叫UserFactory的非靜態方法createUser2方法建立名為user3的物件,放入容器中
                        & UserFactroy類程式碼
                            public class UserFactory {
                                public User createUser2() {
                                    System.out.println("例項工廠建立User");
                                    return new User();
                                }
                            }
                        & 配置檔案書寫    
                            <!--先例項化UserFactory  -->
                            <bean name="userFactory" class="cn.itheima.b_create.UserFactory"></bean>
                            <!--再呼叫UserFactory的成員方法  -->
                            <bean name="user3" factory-bean="userFactory" factory-method="createUser2"></bean>
                        ＆測試程式碼
                            @Test
                            public void fun3() {
                                ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itheima/b_create/applicationContext.xml");
                                User u = (User) ac.getBean("user3");
                                System.out.println(u);
                            }
                <6>Bean元素的scope屬性
                        scope值如下:
                        1 singleton(預設):單例,物件只建立一個例項
                        示例:
                        <bean name="user4" class="cn.ita.bean.User" scope="singleton"></bean>
                        2 prototype:多例,物件建立多個例項，每次獲得才會建立,且每次建立都是新物件 .
                          整合Struts2,ActionBean的配置必須要用多例prototype配置,因為每請求都會建立新的Action物件,struts2是多例的
                        <bean name="user5" class="cn.ita.bean.User" scope="prototype"></bean>
                        3 request:在web專案中,Spring建立一個物件,並把該物件存進request中.
                        4 session:在web專案中,Spring建立一個物件,並把該物件存進session中.
                        5 globalSession:
                            在web專案中,應用Porlet環境,若沒有Porlet環境,那麼globalSession就相當於Session域。
                            Portlet是基於Java的Web元件，Portlet容器處理request並生成動態內容。
                <7>Bean的生命週期
                        1 Bean元素的init-method 屬性作為Bean內物件初始化執行的方法。
                        2 Bena元素的destroy-method屬性作為Bean內物件銷燬執行的方法
                            銷燬方法會在單例建立Bean的工廠關閉時執行。
                        示例如下
                            <bean name="user6" class="cn.itheima.bean.User" init-method="init" destroy-method="destroy">
                            </bean>
                            public class User {
                                private String name;
                                private Integer age;
                                //初始化方法
                                public void init() {
                                System.out.println("初始化方法----");
                                }
                                //銷燬方法
                                public void destroy() {
                                System.out.println("銷燬方法----");
                                }
                            ｝
                <8>Spring的Bean的屬性注入
                      1 通過有參構造方法的方式注入
                        屬性說明
                             name屬性:引數名
                             value屬性：引數值
                             index屬性:引數索引(設定引數的先後位置,從而選擇不同的引數順序的建構函式的配置)
                             type屬性:設定該引數的  型別
                        示例一：
                            <bean name="person" class="cn.ma.bean.Person">
                                <constructor-arg name="name" value="flower" index="0"/>
                                <constructor-arg name="age" value="233" index="1"/>
                            </bean>
                            public class Person {
                                private String name;
                                private Integer age;
                                public Person() {super();}
                                //有引數構造。
                                public Person(String name, Integer age) {
                                    super();
                                    this.name = name;
                                    this.age = age;
                            }
                        示例二：構造方法的引數為某個物件時
                            <bean name="car" class="cn.ia.bean.Car">
                                <property name="name" value="蘭基博尼"></property>
                                <property name="color" value="×××"></property>
                         </bean>
                        <bean name="user3" class="cn.ima.bean.User">
                            <constructor-arg name="name" value="1111" index="0" type="java.lang.Integer"></constructor-arg>
                            <!--ref屬性關聯著物件-->
                            <constructor-arg name="c" ref="car" index="1"></constructor-arg>
                        </bean>
                    2 set方法的方式(需提供getter/setter方法)
                        <bean name="user" class="cn.iima.bean.User">
                            <!-- 為User物件的name，age和Car c屬性注入值-->
                            <property name="name" value="flowerr"></property>
                            <property name="age" value="21"></property>
                            <property name="c" ref="car"></property>
                        </bean>
                        public class User {
                            private String name;
                            public String getName() {return name;}
                            public void setName(String name) {this.name = name;}
                            private Integer age;
                            public void setAge(Integer age) {this.age = age;}
                            public Integer getAge() {return age;}
                            private Car c;
                            public Car getC() {return c;}
                            public void setC(Car c) {this.c = c;}
                        ｝
                    3 名稱空間p的屬性注入
                        * 注入說明：需匯入p名稱空間   xmlns:p="http://www.springframework.org/schema/p"
                        * 格式 --  p:屬性名 或  p:屬性名-ref
                        * 示例：
                            <bean name="user4" class="cn.ima.bean.User" p:name="jack" p:age="20" p:c-ref="car">
                            </bean>
                    4 Spel(Spring Exepression Language)注入方式
                        *格式：name="yyy" value="#{xxx}"
                        *示例一：   
                            <bean name="user" class="cn.itheima.bean.User" >
                                <property name="name" value="#{'flower'}"></property>
                                <property name="age" value="#{22}"></property>
                         </bean>
                        *示例二：從spring容器取值注入屬性裡面
                            下面相當於把 存進spring容器內名為user物件的name屬性值      
                            賦予到本user5物件的name屬性中
                             <bean name="user5" class="cn.ima.bean.User" >
                                    <property name="name" value="#{user.name}"></property>
                                    <property name="age" value="#{user1.age}"></property>
                                    <property name="c" ref="car"></property>
                             </bean>
                         *示例三：把另一個Bean類的屬性注入屬性裡面。
                            <bean name="xxx" class="aa.bb.eeexx"></bean>
                            <bean name="user5" class="cn.it.bean.User" >
                                    <property name="name" value="#{xxx.name}"></property>
                                    <property name="age" value="#{xxx.age}"></property>
                             </bean>
                    5 複雜型別注入        
                        <bean name="cb" class="cn.ithma.d_injection.CollectionBean">
                            <!-- 陣列注入 :如果陣列中只准備註入一個元素(值|物件),直接使用   value|ref 即可 
                            <property name="arr" value="tom"></property> -->
                            <!--陣列的多元素注入  -->
                            <property name="arr">
                                <array>
                                    <value>tom</value>
                                    <value>123</value>
                                    陣列中注入物件
                                    <ref bean="user5"/>
                                </array>
                            </property>
                            <!-- 單列集合 List注入:如果集合中只准備註入一個元素(值|物件),直接使用   value|ref 即可  
                            <property name="list" value="myList"></property> -->
                            <property name="list">
                                <list>
                                    <value>sb</value>
                                    <value>250</value>
                                    <ref bean="user4"/>
                                </list>
                            </property>
                            <!-- 雙列集合 map注入 -->
                            <property name="map">
                                <map>
                                    <entry key="url" value="jdbc:mysql:///crm"></entry>
                                    <entry key="user" value-ref="user3"></entry>
                                    <entry key-ref="user1" value-ref="user3"></entry>
                                </map>
                            </property>
                            <!-- properties型別(配置檔案型別)注入 -->
                            <property name="prop">
                                <props>
                                    <prop key="driverClass">com.jdbc.mysql.Driver</prop>
                                    <prop key="userName">root</prop>
                                    <prop key="password">234</prop>
                                </props>
                            </property>
                     </bean>

3 Spring中的工廠(容器) ApplicationContext和BeanFactory

1 ApplicationContext工廠簡述：

ApplicationContext介面有兩個實現類，
ClassPathXmlApplicationContext：載入類路徑下(src下)的Spring配置檔案
FileSystemXmlApplicationContext：載入本地磁碟下Spring的配置檔案

2 BeanFactory已過時，不在過多講述。

3 ApplicationContext和BeanFactory的區別：

BeanFactory：在呼叫getBean()時才生成類的例項
ApplicationContext：容器啟動，載入applicationContext.xml時便會建立類的例項。

4 Spring配置檔案的分配開發

方式一：建立工廠時載入多個配置檔案
示例： 
ApplicationContext ac=
new ClassPathXmlApplicationContext("a/applicationContext.xml,b/applicationContext.xml");
方式二：在一個配置檔案中包含另一個配置檔案
<import resource="xx/applicationContext.xml"/>

5 Spring與ServletContextListener監聽器

(1)概述：按照原生的Spring的IOC模式管理物件，每次獲取applicationContext.xml配置檔案中的bean物件時
         都需要書寫下面的程式碼
         ApplicationContext ac=new ClassPathXmlApplicationContext("cn/iction/applicationContext.xml");
         User u = (User) ac.getBean("user");
         這樣就會導致每次都會建立一個工廠類，伺服器端的資源就浪費了，一般情況下一個工程只有一個Spring的工廠類.
         解決方案：
            讓spring工廠在伺服器啟動時建立好，將這個工廠放入到ServletContext域中，每次獲取工廠時，
            從ServletContext域中獲取即可，這就需用到ServletContextListener監聽器，
            監聽ServletContext的建立和銷燬。
        配置書寫如下：
        <!--配置監聽器,讓spring工廠隨工程啟動而啟動 -->
              <listener>
                <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
              </listener>
              <context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath:applicationContext.xml</param-value>
              </context-param>

簡述Spring的四大核心元件特點

core   --Spring的核心
context-- 對應Spring的上下文物件環境(applicationContext.xml配置檔案) 
bean ---對應 applicationContext.xml配置檔案的 <bean>元素
spel---對應 <bean>元素中的語法
特點簡記：四大元件層層包含 core>context>bean>spel