Spring基本使用方法_Bean對象

Struts與Hibernate可以做什么事?
Struts
MVC中控制層解決方案.可以進行請求數據自動封裝,類型轉換,文件上傳,效驗.....
Hibernate
持久層的解決方案
,m.VXZCM可以做到把對象保存到數據庫,從數據中取出的是對象.

傳統的開發模式
基於MVC模式進行項目開發,基於MVC的項目框架結構:Entity/dao/service/action

1.Spring簡單使用

1.1.專業術語了解

1.組件/框架設計
侵入式設計:
引入了框架,對現有的類的結構有影響,即需要實現或繼承某些特定類.例如:Struts框架
非侵入式設計:
引入了框架,對現實有的類結構沒有影響,例如:Hibernate框架/Spring框架

2.控制反轉和依賴注入
Inversion on Control,控制反轉IOC.
對象的創建交給外部容器完成,這個就叫做控制反轉.
依賴注入,dependency injection.處理對象的依賴關系
區別:
控制反轉:解決對象創建的問題.[對象創建交給別人]
依賴注入:在創建完對象后,對象的關系處理就是依賴注入[通過set方法依賴注入]

3.AOP
面向切面編程:切面,簡單來說可以理解為一個類,由很多重復代碼形成的類.
切面舉例:事務,日志,權限.

1.2.Spring概述

Spring是一個非常活躍的開源框架,他是一個基於IOC和AOP來架構多層JavaEE系統的框架,它的主要目的是簡化企業開發.
Spring以一種非侵入式的方式來管理你的代碼,Spring提倡"最少侵入",這也就意味着你可以適當的時候安裝或者卸載Spring.
Spring框架,可以解決對象創建以及對象之間依賴關系的一種框架愛.且可以和其他框架一起使用:Spring和Struts,Spring和Hibernate,起到整合作用的一個框架.
在項目中使用Spring的目的是降低組件之間的耦合度,實現軟件各層之間的解耦.

Spring框架被分為六大模塊,分別用來解決不同的問題.六大模塊如下:

1.Spring Core,Spring的核心功能.

IOC容器,解決對象創建以及依賴關系
包含並管理應用對象的配置和生命周期,可以配置每一個bean如何被創建,也可以配置每一個bean是只有一個實例,還是每次需要時都生成一個新的實例,以及他們是如何相互關聯的

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.Spring JEE,Spring對JavaEE其他模塊的支持.

對java企業級開發提供了一些解決方案,如EJB,JMS等

1.3.開發步驟

Spring各個版本中:
在3.0以上的版本中,源碼有Spring中相關的所有包(Spring功能包+依賴包),如2.5版本
在3.0以上的版本中,源碼只有Spring的核心功能包(沒有依賴包),如果要用到依賴包,需要單獨下載

1.下載源碼:
此處使用3.2的版本:
spring-framework-3.2.5.RELEASE
Spring必須要引入的jar文件有5個,分別是:

• commons-logging-1.1.3.jar 日志管理
• spring-beans-3.2.5.RELEASE.jar bean節點
• spring-context-3.2.5.RELEASE.jar spring上下文節點
• spring-core-3.2.5.RELEASE.jar spring核心功能
• pring-expression-3.2.5.RELEASE.jar spring表達式相關表

2.配置
核心配置文件是:applicationContext.xml或者bean.xml,一般都是前者,JavaBean對象在這里面被創建,然后在java中調用就可以了.
假設已經存在一個User的JavaBean代碼,需要創建對象,然后在java中使用
applicationContext.xml

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

    <!--IOC容器的配置,要創建的所有的對象都在這里配置-->
    <bean id="user" class="a_hello.User"></bean>
</beans>

使用API:

/**
 * 從IOC容器創建對象
 */
public class app {

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

        //現在把對象的創建交給容器
        Resource resource = new ClassPathResource("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("a_hello/applicationContext.xml");
        //從容器中獲取bean
        User user = (User) ac.getBean("user");

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

1.4.bean對象創建的細節

在applicationContext.xml中創建對象,要注意一些細節:

/**
 * Bean對象創建的細節
 */
public class AppBean {

    /**
     *1.對象創建:單例/多例
     * 在applicationContext.xml配置文件中,設置scope參數
     * scope="singleton",默認值,即默認是單例 [service/dao等工具類時使用單例]
     * scope="prototype",多例, [Action對象時用多例]
     */

    /**
     *2.什么時候創建
     * scope="singleton",在啟動時(容器創建之前),就已經創建了bean,且整個應用只有一個對象
     * scope="prototype",先創建容器,只有在用到對象的時候,才創建對象.
     */

    /**
     * 3.是否延遲創建
     * 在applicationContext.xml配置文件中,設置lazy-init參數
     * lazy-init="false" 默認為false,不延遲創建,在啟動的時候就創建對象
     * lazy-init="true" 延遲初始化,在用到對象的時候才創建對象
     * lazy-init參數只對單例有效
     */

    /**
     *4.創建對象之后,初始化/銷毀
     * init-method="init_user",init_user是user中的一個方法,對應對象的init_user方法,在對象創建之后執行
     * destroy-method="destroy_user",destory_user是user中的一個方法,在調用容器對象的destriy方法時執行(容器用類實現)
     */
    @Test
    public void testAc() throws Exception{
        //得到IOC容器對象
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("a_hello/applicationContext.xml");
        System.out.println("容器創建成功");
        //從容器中獲取bean
        User user1 = (User) ac.getBean("user");
        User user2 = (User) ac.getBean("user");

        //scope="singleton"時,返回true
        //scope="prototype"時,返回false
        System.out.println(user1==user2);
        
        //銷毀容器對象,調用了destroy-method參數中的方法
        ac.destroy();
    }
}

applicationContext.xml文件:

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

    <!--IOC容器的配置,要創建的所有的對象都在這里配置-->
    <bean id="user" class="a_hello.User" scope="singleton" lazy-init="false" init-method="init_user" destroy-method="destroy_user"></bean>
</beans>

2.Spring IOC容器功能

Spring IOC容器,是Spring核心內容,屬於Spring Core部分.作用是:創建對象以及處理對象的依賴關系
下面分別看創建對象和依賴關系

2.1.創建對象

IOC容器創建對象的幾種方式:
1.調用無參數構造器
2.帶參數構造器
3.工廠創建對象,分為工廠類的靜態方法創建對象和非靜態方法創建對象

代碼示例:
用java寫一個工廠類:ObjectFactory.java

public class ObjectFactory {

    //實例方法創建對象
    public User getInstance(){
        return new User(100,"調用實例方法");
    }

    //靜態方法創建對象
    public static User getStaticInstance(){
        return new User(100,"調用靜態方法");
    }
}

applicationContext.xml寫法:

<?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: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="user" class="a_hello.User"/>-->

    <!--2.帶參數構造器-->
    <bean id="user1" class="a_hello.User">
        <!--type的值,如果是基本類型用常用的類型就可以,如果是引用類型就用類型的全名-->
        <constructor-arg value="100" index="0" type="int"></constructor-arg>
        <constructor-arg value="Jack" index="1" type="java.lang.String"></constructor-arg>
    </bean>

    <!--定義一個字符串,值是"Jack",String s = new String("Jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jack"/>
    </bean>
    <bean id="user2" class="a_hello.User">
        <constructor-arg index="0" type="int" value="100"/>
        <constructor-arg index="1" type="java.lang.String" ref="str"/>
    </bean>


    <!--3.工廠類創建對象-->
    <!--3.1.工廠類 實例方法-->
    <!--先創建工廠-->
    <bean id="factory" class="a_hello.ObjectFactory"/>
    <!--再創建user對象,用factory的實例方法-->
    <bean id="user3" factory-bean="factory" factory-method="getInstance"/>

    
    <!--3.2.工廠類 靜態方法-->
    <!--class 指定的就是工廠類型-->
    <!--factory-method 一定是工廠里面的靜態方法-->
    <bean id="user4" class="a_hello.ObjectFactory" factory-method="getStaticInstance"/>


</beans>

2.2.對象依賴關系

上面已經可以創建一個對象了,但是如何給對象的屬性賦值呢?
1.通過構造函數(上面已經有例子了)
2.通過set方法給屬性注入值
3.p名稱空間
4.自動裝配(了解)
5.注解

0.通過構造函數

    <!--1.通過構造函數-->
    <bean id="user" class="b_property.User">
        <constructor-arg value="100"></constructor-arg>
        <constructor-arg value="Jack"></constructor-arg>
    </bean>

1.(常用)Set方法注入值

    <!--2.通過set方法給屬性賦值-->
    <bean id="user1" class="b_property.User">
        <!--user.id的賦值-->
        <property name="id" value="99"/>
        <!--user.name的賦值-->
        <property name="name" value="Jerry"/>
    </bean>

測試類:

 @Test
    public void testSet() throws Exception{
        //創建容器對象
        ApplicationContext ac = new ClassPathXmlApplicationContext("b_property/applicationContext.xml");

        //獲取容器中的對象
        User user = (User) ac.getBean("user1");

        System.out.println(user);
    }

案例:在一個項目中,需要在action/service/dao三個地方創建對象.配置如下:

    <!-- dao 對象創建 -->
    <bean id="userDao" class="b_property.UserDao"></bean>

    <!-- service 對象創建,並調用dao-->
    <bean id="userService" class="b_property.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

    <!-- action 對象創建,並調用service -->
    <bean id="userAction" class="b_property.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

2.內部bean
使用內部bean的方法,同樣可以實現action/service/dao

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

與Set注入的達到的效果是一樣的,區別在於如果不同的action要使用service時候,需要再寫一遍.且不易維護

3.p 名稱空間注入屬性值(優化)
使用p名稱空間也可以達到上面同樣的效果,並得到了優化

    <!-- 對象屬性賦值 -->
    <!--
        給對象屬性注入值也可以使用 p 名稱空間給對象的屬性注入值
          注意:spring3.0以上版本才支持
     -->
    <bean id="userDao" class="b_property.UserDao"></bean>

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

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


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

4.自動裝配(了解)

根據名稱自動裝配
autowire="byName"會自動去IOC容器中查找與屬性同名的引用的對象,並自動注入.

代碼示例:

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

也可以把autowire="byName"定義到全局,這樣就不用每個bean節點都去寫autowire="byName"
代碼示例:

<?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: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="d_auto.UserDao"></bean>	
	<bean id="userService" class="d_auto.UserService"></bean>
	<bean id="userAction" class="d_auto.UserAction"></bean>
</beans> 

根據類型自動裝配
除了根據相似的名稱自動裝配外,還可以根據類型自動裝配,使用的參數為:autowire="byType".
此時必須確保該類型在IOC容器中只有一個對象,否則,報錯!

示例代碼:

<?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: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="d_auto.UserDao"></bean>	
	<bean id="userService" class="d_auto.UserService"></bean>
	
	<!-- 如果根據類型自動裝配： 必須確保IOC容器中只有一個該類型的對象 -->
	<bean id="userAction" class="d_auto.UserAction"></bean>
	
	
	<!--   報錯： 因為上面已經有一個該類型的對象，且使用了根據類型自動裝配
	<bean id="userService_test" class="d_auto.UserService" autowire="byType"></bean>
	 -->
</beans>  

總結:
Spring提供的自動專配主要是為了簡化配置;但是不利於后期的維護.一般推薦使用

5.注解
Spring的IOC容器的配置也可以使用注解來簡化操作.
使用注解的步驟:
1.applicationContext.xml文件中引入context名稱空間

mlns:context="http://www.springframework.org/schema/context"
2.開始注解掃描

<!--開始注解掃描-->
    <!--base-package="b_property":掃描b_property包下的所有類-->
    <context:component-scan base-package="b_property"/>

3.使用注解,通過注解的方式,把對象加入

創建對象以及處理對象依賴關系,相關的注解:

• @component:指定把一個對象加入IOC容器
• @Respository:作用同@component;在持久層使用
• @Service:作用同@component;在業務邏輯層使用
• @Controller:作用同@component;在控制層使用
• @Resource:屬性注入

總結:
1.使用注解,可以簡化配置,且可以把對象加入
容器,及處理依賴關系
2.注解可以和xml配置一起是使用.