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

Spring框架知識復習之一