您當前位置：首頁 > 互聯網 > Spring（一）

Spring（一）

來源：程序員人生發布時間：2016-06-04 16:11:00 閱讀次數：2563次

回顧

Struts與Hibernate可以做甚么事？

Struts
    Mvc中控制層解決方案 
    可以進行要求數據自動封裝、類型轉換、文件上傳、效驗…
Hibernate
    持久層的解決方案； 
    可以做到，
        把對象保存到數據庫， 
        從數據庫中取出的是對象。

傳統的開發模式

基于mvc模式進行項目開發；
基于mvc的項目框架結構：
    Entity / dao / service / action

    // 1. 實體類
    class User{
    }


    //2. dao
    class  UserDao{
       .. 訪問db
    }

    //3. service
    class  UserService{
        UserDao userDao = new UserDao();
    }

    //4. action
    class  UserAction{
        UserService userService = new UserService();

        ..
        拿到數據或結果
    }

    用戶訪問：
    /user.action ---->  Tomcat  (服務器創建Action、Service、dao

    思考：
        1. 對象創建創建能否寫死？
        2. 對象創建細節
            對象數量
                action  多個   【保護成員變量】
                service 1個   【不需要保護公共變量】
                dao     1個   【不需要保護公共變量】
            創建時間
                action    訪問時候創建
                service   啟動時候創建
                dao       啟動時候創建
        3. 對象的依賴關系
            action 依賴 service
            service依賴 dao

    =======================================================
    總結：
        spring就是解決上面的問題的！
    簡單來講，就是處理對象的創建的、和對象的依賴關系！

Spring框架

專業術語了解

組件/框架設計

侵入式設計
        引入了框架，對現有的類的結構有影響；即需要實現或繼承某些特定類。
        例如： Struts框架
非侵入式設計
    引入了框架，對現有的類結構沒有影響。
    例如：Hibernate框架 / Spring框架

控制反轉

Inversion on Control , 控制反轉 IOC
對象的創建交給外部容器完成，這個就做控制反轉.

依賴注入，  dependency injection 
    處理對象的依賴關系

區分：
     控制反轉， 解決對象創建的問題 【對象創建交給他人】
     依賴注入，
        在創建完對象后， 對象的關系的處理就是依賴注入 【通過set方法依賴注入】

AOP

    面向切面編程。切面，簡單來講來可以理解為1個類，由很多重復代碼構成的類。
    切面舉例：事務、日志、權限;

概述

Spring框架，可以解決對象創建和對象之間依賴關系的1種框架。
      且可以和其他框架1起使用；Spring與Struts,  Spring與hibernate
     (起到整合（粘合）作用的1個框架)
Spring提供了1站式解決方案：
    1） Spring Core  spring的核心功能： IOC容器, 解決對象創建及依賴關系
    2） Spring Web  Spring對web模塊的支持。
                        -? 可以與struts整合,讓struts的action創建交給spring
                        -? spring mvc模式
    3） Spring DAO  Spring 對jdbc操作的支持  【JdbcTemplate模板工具類】
    4） Spring ORM  spring對orm的支持： 
                        ? 既可以與hibernate整合，【session】
                        ? 也能夠使用spring的對hibernate操作的封裝
    5）Spring AOP  切面編程
    6）SpringEE   spring 對javaEE其他模塊的支持

開發步驟

    spring各個版本中：
        在3.0以下的版本，源碼有spring中相干的所有包【spring功能 + 依賴包】如2.5版本；
        在3.0以上的版本，源碼中只有spring的核心功能包【沒有依賴包】
            (如果要用依賴包，需要單獨下載！)


    1） 源碼, jar文件：spring-framework⑶.2.5.RELEASE
        commons-logging⑴.1.3.jar             日志
        spring-beans⑶.2.5.RELEASE.jar        bean節點
        spring-context⑶.2.5.RELEASE.jar      spring上下文節點
        spring-core⑶.2.5.RELEASE.jar         spring核心功能
        spring-expression⑶.2.5.RELEASE.jar   spring表達式相干表

    以上是必須引入的5個jar文件，在項目中可以用戶庫管理！

    2） 核心配置文件: applicationContext.xml  
        Spring配置文件：applicationContext.xml / bean.xml

        束縛參考：
    spring-framework⑶.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

    3) Api

public class App {

    // 1. 通過工廠類得到IOC容器創建的對象
    @Test
    public void testIOC() throws Exception {
        // 創建對象
        // User user = new User();

        // 現在，把對象的創建交給spring的IOC容器
        Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");
        // 創建容器對象(Bean的工廠), IOC容器 = 工廠類 + applicationContext.xml
        BeanFactory factory = new XmlBeanFactory(resource);
        // 得到容器創建的對象
        User user = (User) factory.getBean("user");

        System.out.println(user.getId());

    }

    //2. （方便）直接得到IOC容器對象 
    @Test
    public void testAc() throws Exception {
        // 得到IOC容器對象
        ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        // 從容器中獲得bean
        User user = (User) ac.getBean("user");

        System.out.println(user);
    }
}

bean對象創建的細節

/**
     * 1) 對象創建： 單例/多例
     *  scope="singleton", 默許值， 即 默許是單例 【service/dao/工具類】
     *  scope="prototype", 多例；              【Action對象】
     * 
     * 2) 甚么時候創建?
     *    scope="prototype"  在用到對象的時候，才創建對象。
     *    scope="singleton"  在啟動(容器初始化之前)， 就已創建了bean，且全部利用只有1個。
     * 3) 是不是延遲創建
     *    lazy-init="false"  默許為false,  不延遲創建，即在啟動時候就創建對象
     *    lazy-init="true"   延遲初始化， 在用到對象的時候才創建對象
     *    （只對單例有效）
     * 4) 創建對象以后，初始化/燒毀
     *    init-method="init_user"       【對應對象的init_user方法，在對象創建愛以后履行 】
     *    destroy-method="destroy_user"  【在調用容器對象的destriy方法時候履行，(容器用實現類)】
     */
    @Test
    public void testIOC() throws Exception {
        // 得到IOC容器對象  【用實現類，由于要調用燒毀的方法】
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");
        System.out.println("-----容器創建-----");

        // 從容器中獲得bean
        User user1 = (User) ac.getBean("user");
        User user2 = (User) ac.getBean("user");

        System.out.println(user1);
        System.out.println(user2);

        // 燒毀容器對象 
        ac.destroy();
    }

SpringIOC容器

創建對象

SpringIOC容器，是spring核心內容。
作用： 創建對象 & 處理對象的依賴關系

IOC容器創建對象：
創建對象, 有幾種方式：
1） 調用無參數構造器
2） 帶參數構造器
3） 工廠創建對象
        工廠類，靜態方法創建對象
        工廠類，非靜態方法創建對象

<?xml version="1.0" encoding="UTF⑻"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- ###############對象創建############### -->

    <!-- 1. 默許無參數構造器 
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
    -->

    <!-- 2. 帶參數構造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>

    <!-- 定義1個字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>


    <!-- 3. 工廠類創建對象 -->
    <!-- # 3.1 工廠類，實例方法 -->
    <!-- 先創建工廠 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在創建user對象，用factory方的實例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>


    <!-- # 3.2 工廠類： 靜態方法 -->
    <!-- 
        class 指定的就是工廠類型
        factory-method  1定是工廠里面的“靜態方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>

</beans>

對象依賴關系

Spring中，如何給對象的屬性賦值?  【DI, 依賴注入】
    1) 通過構造函數
    2) 通過set方法給屬性注入值
    3) p名稱空間
    4) 自動裝配(了解)
    5) 注解

(經常使用)Set方法注入值

<!-- dao instance -->
    <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

    <!-- service instance -->
    <bean id="userService" class="cn.itcast.c_property.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <!-- action instance -->
    <bean id="userAction" class="cn.itcast.c_property.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

內部bean

<!-- ##############內部bean############## -->
    <bean id="userAction" class="cn.itcast.c_property.UserAction">
        <property name="userService">
            <bean class="cn.itcast.c_property.UserService">
                <property name="userDao">
                    <bean class="cn.itcast.c_property.UserDao"></bean>
                </property>
            </bean>
        </property>
    </bean>

p 名稱空間注入屬性值 (優化)

<?xml version="1.0" encoding="UTF⑻"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- ###############對象屬性賦值############### -->

    <!-- 
        給對象屬性注入值：
            # p 名稱空間給對象的屬性注入值
             (spring3.0以上版本才支持)
     -->
     <bean id="userDao" class="cn.itcast.c_property.UserDao"></bean>

     <bean id="userService" class="cn.itcast.c_property.UserService" p:userDao-ref="userDao"></bean>

     <bean id="userAction" class="cn.itcast.c_property.UserAction" p:userService-ref="userService"></bean>


    <!-- 傳統的注入： 
     <bean id="user" class="cn.itcast.c_property.User" >
        <property name="name" value="xxx"></property>
     </bean>
    -->
    <!-- p名稱空間優化后 -->
    <bean id="user" class="cn.itcast.c_property.User" p:name="Jack0001"></bean>

</beans>

自動裝配(了解)

1. 根據名稱自動裝配：autowire="byName"
    自動去IOC容器中找與屬性名同名的援用的對象，并自動注入

<!-- ###############自動裝配############### -->  
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean> 
    <bean id="userService" class="cn.itcast.d_auto.UserService" autowire="byName"></bean>
    <!-- 根據“名稱”自動裝配： userAction注入的屬性，會去ioc容器中自動查找與屬性同名的對象 -->
    <bean id="userAction" 
class="cn.itcast.d_auto.UserAction" autowire="byName"></bean>

    也能夠定義到全局， 這樣就不用每一個bean節點都去寫autowire=”byName”

<?xml version="1.0" encoding="UTF⑻"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">   根據名稱自動裝配（全局）

    <!-- ###############自動裝配############### -->  
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean> 
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>
</beans>

2. 根據類型自動裝配：autowire="byType"
    必須確保改類型在IOC容器中只有1個對象；否則報錯。

<?xml version="1.0" encoding="UTF⑻"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byType">

    <!-- ###############自動裝配############### -->  
    <bean id="userDao" class="cn.itcast.d_auto.UserDao"></bean> 
    <bean id="userService" class="cn.itcast.d_auto.UserService"></bean>

    <!-- 如果根據類型自動裝配： 必須確保IOC容器中只有1個該類型的對象 -->
    <bean id="userAction" class="cn.itcast.d_auto.UserAction"></bean>


    <!--   報錯： 由于上面已有1個該類型的對象，且使用了根據類型自動裝配
    <bean id="userService_test" class="cn.itcast.d_auto.UserService" autowire="byType"></bean>
     -->
</beans>

總結：
    Spring提供的自動裝配主要是為了簡化配置； 但是不利于后期的保護。
    (1般不推薦使用)

注解

注解方式可以簡化spring的IOC容器的配置!

使用注解步驟：
    1）先引入context名稱空間
        xmlns:context="http://www.springframework.org/schema/context"
    2）開啟注解掃描
        <context:component-scan base-package="cn.itcast.e_anno2"></context:component-scan>
    3）使用注解
        通過注解的方式，把對象加入ioc容器。

       創建對象和處理對象依賴關系，相干的注解：
        @Component   指定把1個對象加入IOC容器

@Repository   作用同@Component； 在持久層使用
@Service      作用同@Component； 在業務邏輯層使用
@Controller    作用同@Component； 在控制層使用 

@Resource     屬性注入

總結：
    1） 使用注解，可以簡化配置，且可以把對象加入IOC容器,及處理依賴關系(DI)
    2） 注解可以和XML配置1起使用。

Spring與Struts框架整合

Spring，負責對象對象創建
Struts， 用Action處理要求

Spring與Struts框架整合，
    關鍵點：讓struts框架action對象的創建，交給spring完成！

Spring與Hibernate整合：

【SSH整合:
        Spring與Struts
            關鍵點： action交給spring創建!
        Spring與Hibernate
            關鍵點： sessionFactory對象交給spring創建！
】

步驟：
    引入jar文件
        1）引入struts .jar相干文件
        2）spring-core  相干jar文件
        3）spring-web 支持jar包
            spring-web⑶.2.5.RELEASE.jar            【Spring源碼】
            struts2-spring-plugin⑵.3.4.1.jar       【Struts源碼】

    配置:
        4）配置XML
            struts.xml      【struts路徑與action映照配置】
            bean.xml        【spring ioc容器配置】
            web.xml         【核心過濾器： 引入struts功能】
                            【初始化spring的ioc容器】

生活不易，碼農辛苦
如果您覺得本網站對您的學習有所幫助,可以手機掃描二維碼進行捐贈
程序員人生