真实的国产乱ⅩXXX66竹夫人,五月香六月婷婷激情综合,亚洲日本VA一区二区三区,亚洲精品一区二区三区麻豆

成都創(chuàng)新互聯(lián)網(wǎng)站制作重慶分公司

Spring入門這一篇就夠了

前言

前面已經(jīng)學(xué)習(xí)了Struts2和Hibernate框架了。接下來學(xué)習(xí)的是Spring框架…本博文主要是引入Spring框架…

成都創(chuàng)新互聯(lián)公司成立于2013年，我們提供高端網(wǎng)站建設(shè)公司、重慶網(wǎng)站制作、成都網(wǎng)站設(shè)計(jì)公司、網(wǎng)站定制、成都全網(wǎng)營(yíng)銷推廣、微信小程序、微信公眾號(hào)開發(fā)、成都網(wǎng)站營(yíng)銷服務(wù)，提供專業(yè)營(yíng)銷思路、內(nèi)容策劃、視覺設(shè)計(jì)、程序開發(fā)來完成項(xiàng)目落地，為成都被動(dòng)防護(hù)網(wǎng)企業(yè)提供源源不斷的流量和訂單咨詢。

Spring介紹

Spring誕生：

  • 創(chuàng)建Spring的目的就是用來替代更加重量級(jí)的的企業(yè)級(jí)Java技術(shù)

  • 簡(jiǎn)化Java的開發(fā)

    • 基于POJO輕量級(jí)和最小侵入式開發(fā)

    • 通過依賴注入和面向接口實(shí)現(xiàn)松耦合

    • 基于切面和慣例進(jìn)行聲明式編程

    • 通過切面和模板**減少樣板式代碼 **

侵入式概念

Spring是一種非侵入式的框架…

侵入式

  • 對(duì)于EJB、Struts2等一些傳統(tǒng)的框架，通常是要實(shí)現(xiàn)特定的接口，繼承特定的類才能增強(qiáng)功能

    • 改變了java類的結(jié)構(gòu)

非侵入式

  • 對(duì)于Hibernate、Spring等框架，對(duì)現(xiàn)有的類結(jié)構(gòu)沒有影響，就能夠增強(qiáng)JavaBean的功能

松耦合

前面我們?cè)趯懗绦虻臅r(shí)候，都是面向接口編程，通過DaoFactroy等方法來實(shí)現(xiàn)松耦合

    private CategoryDao categoryDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.CategoryDAOImpl", CategoryDao.class);

   private BookDao bookDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.BookDaoImpl", BookDao.class);

   private UserDao userDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.UserDaoImpl", UserDao.class);

   private OrderDao orderDao = DaoFactory.getInstance().createDao("zhongfucheng.dao.impl.OrderDaoImpl", OrderDao.class);
Spring入門這一篇就夠了

DAO層和Service層通過DaoFactory來實(shí)現(xiàn)松耦合

  • 如果Serivce層直接new DaoBook()，那么DAO和Service就緊耦合了【Service層依賴緊緊依賴于Dao】。

而Spring給我們更加合適的方法來實(shí)現(xiàn)松耦合，并且更加靈活、功能更加強(qiáng)大！---->IOC控制反轉(zhuǎn)

切面編程

切面編程也就是AOP編程，其實(shí)我們?cè)谥耙步佑|過…動(dòng)態(tài)代理就是一種切面編程了…

當(dāng)時(shí)我們使用動(dòng)態(tài)代理+注解的方式給Service層的方法添加權(quán)限.

    @Override
   @permission("添加分類")
   /*添加分類*/
   public void addCategory(Category category){
       categoryDao.addCategory(category);
   }


   /*查找分類*/
   @Override
   public void findCategory(String id){
       categoryDao.findCategory(id);
   }

   @Override
   @permission("查找分類")
   /*查看分類*/
   public List getAllCategory(){
       return categoryDao.getAllCategory();
   }

   /*添加圖書*/
   @Override
   public void addBook(Book book){
       bookDao.addBook(book);

   }

  • Controller調(diào)用Service的時(shí)候，Service返回的是一個(gè)代理對(duì)象

  • 代理對(duì)象得到Controller想要調(diào)用的方法，通過反射來看看該方法上有沒有注解

  • 如果有注解的話，那么就判斷該用戶是否有權(quán)限來調(diào)用 此方法，如果沒有權(quán)限，就拋出異常給Controller，Controller接收到異常，就可以提示用戶沒有權(quán)限了。

AOP編程可以簡(jiǎn)單理解成：在執(zhí)行某些代碼前，執(zhí)行另外的代碼

  • Struts2的攔截器也是面向切面編程【在執(zhí)行Action業(yè)務(wù)方法之前執(zhí)行攔截器】

Spring也為我們提供更好地方式來實(shí)現(xiàn)面向切面編程！

引出Spring

我們?cè)囍仡櫼幌聸]學(xué)Spring的時(shí)候，是怎么開發(fā)Web項(xiàng)目的

  • 1. 實(shí)體類--->class User{ }

  • 2. daoclass-->  UserDao{  .. 訪問db}

  • 3. service--->class  UserService{  UserDao userDao = new UserDao();}

  • 4. actionclass  UserAction{UserService userService = new UserService();}

用戶訪問：

  • Tomcat->action->service->dao

我們來思考幾個(gè)問題：

  • ①：對(duì)象創(chuàng)建創(chuàng)建能否寫死？

  • ②：對(duì)象創(chuàng)建細(xì)節(jié)

    • action    訪問時(shí)候創(chuàng)建

    • service   啟動(dòng)時(shí)候創(chuàng)建

    • dao       啟動(dòng)時(shí)候創(chuàng)建

    • action  多個(gè)   【維護(hù)成員變量】

    • service 一個(gè)   【不需要維護(hù)公共變量】

    • dao     一個(gè)   【不需要維護(hù)公共變量】

    • 對(duì)象數(shù)量

    • 創(chuàng)建時(shí)間

  • ③：對(duì)象的依賴關(guān)系

    • action 依賴 service

    • service依賴 dao

對(duì)于第一個(gè)問題和第三個(gè)問題，我們可以通過DaoFactory解決掉(雖然不是比較好的解決方法)

對(duì)于第二個(gè)問題，我們要控制對(duì)象的數(shù)量和創(chuàng)建事件就有點(diǎn)麻煩了….

而Spring框架通過IOC就很好地可以解決上面的問題….

IOC控制反轉(zhuǎn)

Spring的核心思想之一：Inversion of Control , 控制反轉(zhuǎn) IOC

那么控制反轉(zhuǎn)是什么意思呢？？？對(duì)象的創(chuàng)建交給外部容器完成，這個(gè)就做控制反轉(zhuǎn)。

  • Spring使用控制反轉(zhuǎn)來實(shí)現(xiàn)對(duì)象不用在程序中寫死

  • 控制反轉(zhuǎn)解決對(duì)象處理問題【把對(duì)象交給別人創(chuàng)建】

那么對(duì)象的對(duì)象之間的依賴關(guān)系Spring是怎么做的呢？？依賴注入，dependency injection.

  • Spring使用依賴注入來實(shí)現(xiàn)對(duì)象之間的依賴關(guān)系

  • 在創(chuàng)建完對(duì)象之后，對(duì)象的關(guān)系處理就是依賴注入

上面已經(jīng)說了，控制反轉(zhuǎn)是通過外部容器完成的，而Spring又為我們提供了這么一個(gè)容器，我們一般將這個(gè)容器叫做：IOC容器.

無論是創(chuàng)建對(duì)象、處理對(duì)象之間的依賴關(guān)系、對(duì)象創(chuàng)建的時(shí)間還是對(duì)象的數(shù)量，我們都是在Spring為我們提供的IOC容器上配置對(duì)象的信息就好了。

那么使用IOC控制反轉(zhuǎn)這一思想有什么作用呢？？？我們來看看一些優(yōu)秀的回答…

來自知乎：https://www.zhihu.com/question/23277575/answer/24259844

我摘取一下核心的部分：

ioc的思想最核心的地方在于，資源不由使用資源的雙方管理，而由不使用資源的第三方管理，這可以帶來很多好處。第一，資源集中管理，實(shí)現(xiàn)資源的可配置和易管理。第二，降低了使用資源雙方的依賴程度，也就是我們說的耦合度。

也就是說，甲方要達(dá)成某種目的不需要直接依賴乙方，它只需要達(dá)到的目的告訴第三方機(jī)構(gòu)就可以了，比如甲方需要一雙襪子，而乙方它賣一雙襪子，它要把襪子賣出去，并不需要自己去直接找到一個(gè)賣家來完成襪子的賣出。它也只需要找第三方，告訴別人我要賣一雙襪子。這下好了，甲乙雙方進(jìn)行交易活動(dòng)，都不需要自己直接去找賣家，相當(dāng)于程序內(nèi)部開放接口，賣家由第三方作為參數(shù)傳入。甲乙互相不依賴，而且只有在進(jìn)行交易活動(dòng)的時(shí)候，甲才和乙產(chǎn)生聯(lián)系。反之亦然。這樣做什么好處么呢，甲乙可以在對(duì)方不真實(shí)存在的情況下獨(dú)立存在，而且保證不交易時(shí)候無聯(lián)系，想交易的時(shí)候可以很容易的產(chǎn)生聯(lián)系。甲乙交易活動(dòng)不需要雙方見面，避免了雙方的互不信任造成交易失敗的問題。因?yàn)榻灰子傻谌絹碡?fù)責(zé)聯(lián)系，而且甲乙都認(rèn)為第三方可靠。那么交易就能很可靠很靈活的產(chǎn)生和進(jìn)行了。這就是ioc的核心思想。生活中這種例子比比皆是，支付寶在整個(gè)淘寶體系里就是龐大的ioc容器，交易雙方之外的第三方，提供可靠性可依賴可靈活變更交易方的資源管理中心。另外人事代理也是，雇傭機(jī)構(gòu)和個(gè)人之外的第三方。
==========================update===========================

在以上的描述中，誕生了兩個(gè)專業(yè)詞匯，依賴注入和控制反轉(zhuǎn)所謂的依賴注入，則是，甲方開放接口，在它需要的時(shí)候，能夠講乙方傳遞進(jìn)來(注入)所謂的控制反轉(zhuǎn)，甲乙雙方不相互依賴，交易活動(dòng)的進(jìn)行不依賴于甲乙任何一方，整個(gè)活動(dòng)的進(jìn)行由第三方負(fù)責(zé)管理。

參考優(yōu)秀的博文①：https://www.tianmaying.com/tutorial/spring-ioc

參考優(yōu)秀的博文②：這里寫鏈接內(nèi)容

知乎@Intopass的回答：

  1. 不用自己組裝，拿來就用。

  2. 享受單例的好處，效率高，不浪費(fèi)空間。

  3. 便于單元測(cè)試，方便切換mock組件。

  4. 便于進(jìn)行AOP操作，對(duì)于使用者是透明的。

  5. 統(tǒng)一配置，便于修改。

Spring模塊

Spring可以分為6大模塊：

  • Spring Core  spring的核心功能： IOC容器, 解決對(duì)象創(chuàng)建及依賴關(guān)系

  • Spring Web  Spring對(duì)web模塊的支持。

    • 可以與struts整合,讓struts的action創(chuàng)建交給spring

    • spring mvc模式

  • Spring DAO  Spring 對(duì)jdbc操作的支持  【JdbcTemplate模板工具類】

  • Spring ORM  spring對(duì)orm的支持：

    • 既可以與hibernate整合，【session】

    • 也可以使用spring的對(duì)hibernate操作的封裝

  • Spring AOP  切面編程

  • SpringEE   spring 對(duì)javaEE其他模塊的支持

Spring入門這一篇就夠了

上面文主要引出了為啥我們需要使用Spring框架，以及大致了解了Spring是分為六大模塊的….下面主要講解Spring的core模塊！

Core模塊快速入門

搭建配置環(huán)境

引入jar包:

本博文主要是core模塊的內(nèi)容，涉及到Spring core的開發(fā)jar包有五個(gè)：

  • commons-logging-1.1.3.jar           日志

  • spring-beans-3.2.5.RELEASE.jar        bean節(jié)點(diǎn)

  • spring-context-3.2.5.RELEASE.jar       spring上下文節(jié)點(diǎn)

  • spring-core-3.2.5.RELEASE.jar         spring核心功能

  • spring-expression-3.2.5.RELEASE.jar    spring表達(dá)式相關(guān)表

我主要使用的是Spring3.2版本…

編寫配置文件:

Spring核心的配置文件applicationContext.xml或者叫bean.xml

那這個(gè)配置文件怎么寫呢？？一般地，我們都知道框架的配置文件都是有約束的…我們可以在spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html找到XML配置文件的約束

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

  

我是使用Intellij Idea集成開發(fā)工具的，可以選擇自帶的Spring配置文件,它長(zhǎng)的是這樣：


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


前面在介紹Spring模塊的時(shí)候已經(jīng)說了，Core模塊是：IOC容器，解決對(duì)象創(chuàng)建和之間的依賴關(guān)系。

因此Core模塊主要是學(xué)習(xí)如何得到IOC容器，通過IOC容器來創(chuàng)建對(duì)象、解決對(duì)象之間的依賴關(guān)系、IOC細(xì)節(jié)。

得到Spring容器對(duì)象【IOC容器】

Spring容器不單單只有一個(gè)，可以歸為兩種類型

  • **Bean工廠，BeanFactory【功能簡(jiǎn)單】 **

  • 應(yīng)用上下文，ApplicationContext【功能強(qiáng)大，一般我們使用這個(gè)】

通過Resource獲取BeanFactory

  • 加載Spring配置文件

  • 通過XmlBeanFactory+配置文件來創(chuàng)建IOC容器

        //加載Spring的資源文件
       Resource resource = new ClassPathResource("applicationContext.xml");

       //創(chuàng)建IOC容器對(duì)象【IOC容器=工廠類+applicationContext.xml】
       BeanFactory beanFactory = new XmlBeanFactory(resource);

類路徑下XML獲取ApplicationContext

  • 直接通過ClassPathXmlApplicationContext對(duì)象來獲取

        // 得到IOC容器對(duì)象
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

       System.out.println(ac);

在Spring中總體來看可以通過三種方式來配置對(duì)象:

  • 使用XML文件配置

  • 使用注解來配置

  • 使用JavaConfig來配置

XML配置方式

在上面我們已經(jīng)可以得到IOC容器對(duì)象了。接下來就是在applicationContext.xml文件中配置信息【讓IOC容器根據(jù)applicationContext.xml文件來創(chuàng)建對(duì)象】

  • 首先我們先有個(gè)JavaBean的類

/**
* Created by ozc on 2017/5/10.
*/
public class User{

   private String id;
   private String username;


   public String getId(){
       return id;
   }

   public void setId(String id){
       this.id = id;
   }

   public String getUsername(){
       return username;
   }

   public void setUsername(String username){
       this.username = username;
   }
}

  • 以前我們是通過new User的方法創(chuàng)建對(duì)象的….

    User user = new User();

  • 現(xiàn)在我們有了IOC容器，可以讓IOC容器幫我們創(chuàng)建對(duì)象了。在applicationContext.xml文件中配置對(duì)應(yīng)的信息就行了

       
   

通過IOC容器對(duì)象獲取對(duì)象:

  • 在外界通過IOC容器對(duì)象得到User對(duì)象

        // 得到IOC容器對(duì)象
       ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

       User user = (User) ac.getBean("user");

       System.out.println(user);
Spring入門這一篇就夠了

上面我們使用的是IOC通過無參構(gòu)造函數(shù)來創(chuàng)建對(duì)象，我們來回顧一下一般有幾種創(chuàng)建對(duì)象的方式：

  • 無參構(gòu)造函數(shù)創(chuàng)建對(duì)象

  • 帶參數(shù)的構(gòu)造函數(shù)創(chuàng)建對(duì)象

  • 工廠創(chuàng)建對(duì)象

    • 靜態(tài)方法創(chuàng)建對(duì)象

    • 非靜態(tài)方法創(chuàng)建對(duì)象

使用無參的構(gòu)造函數(shù)創(chuàng)建對(duì)象我們已經(jīng)會(huì)了，接下來我們看看使用剩下的IOC容器是怎么創(chuàng)建對(duì)象的。

帶參數(shù)的構(gòu)造函數(shù)創(chuàng)建對(duì)象

首先，JavaBean就要提供帶參數(shù)的構(gòu)造函數(shù)：

    public User(String id, String username){
       this.id = id;
       this.username = username;
   }

接下來，關(guān)鍵是怎么配置applicationContext.xml文件了。

    

       
       
       
   
Spring入門這一篇就夠了

在constructor上如果構(gòu)造函數(shù)的值是一個(gè)對(duì)象，而不是一個(gè)普通類型的值，我們就需要用到ref屬性了，而不是value屬性

比如說：我在User對(duì)象上維護(hù)了Person對(duì)象的值，想要在構(gòu)造函數(shù)中初始化它。因此，就需要用到ref屬性了

    

   

       
       
       
   

工廠靜態(tài)方法創(chuàng)建對(duì)象

首先，使用一個(gè)工廠的靜態(tài)方法返回一個(gè)對(duì)象

public class Factory{

   public static User getBean(){

       return new User();
   }

}

配置文件中使用工廠的靜態(tài)方法返回對(duì)象

    
   

   
Spring入門這一篇就夠了

工廠非靜態(tài)方法創(chuàng)建對(duì)象

首先，也是通過工廠的非非靜態(tài)方法來得到一個(gè)對(duì)象

public class Factory{


   public User getBean(){

       return new User();
   }


}

配置文件中使用工廠的非靜態(tài)方法返回對(duì)象

    
   

   
   
Spring入門這一篇就夠了

c名稱空間

我們?cè)谑褂肵ML配置創(chuàng)建Bean的時(shí)候，如果該Bean有構(gòu)造器，那么我們使用這個(gè)節(jié)點(diǎn)來對(duì)構(gòu)造器的參數(shù)進(jìn)行賦值…

未免有點(diǎn)太長(zhǎng)了，為了簡(jiǎn)化配置，Spring來提供了c名稱空間…

要想c名稱空間是需要導(dǎo)入xmlns:c="http://www.springframework.org/schema/c"的

    

   

c名稱空間有個(gè)缺點(diǎn)：不能裝配集合，當(dāng)我們要裝配集合的時(shí)候還是需要這個(gè)節(jié)點(diǎn)

裝載集合

如果對(duì)象上的屬性或者構(gòu)造函數(shù)擁有集合的時(shí)候，而我們又需要為集合賦值，那么怎么辦？

  • 在構(gòu)造函數(shù)上，普通類型

    
       
           
               //普通類型
               
           
       
   

  • 在屬性上,引用類型

     

        
            
        
   

注解方式

自從jdk5有了注解這個(gè)新特性，我們可以看到Struts2框架、Hibernate框架都支持使用注解來配置信息…

通過注解來配置信息就是為了簡(jiǎn)化IOC容器的配置，注解可以把對(duì)象添加到IOC容器中、處理對(duì)象依賴關(guān)系，我們來看看怎么用吧：

使用注解步驟：

  • 1）先引入context名稱空間

    • xmlns:context="http://www.springframework.org/schema/context"

  • 2）開啟注解掃描器

    • 第二種方法:也可以通過自定義掃描類以@CompoentScan修飾來掃描IOC容器的bean對(duì)象。。如下代碼:

//表明該類是配置類
@Configuration

//啟動(dòng)掃描器，掃描bb包下的
   //也可以指定多個(gè)基礎(chǔ)包
   //也可以指定類型
@ComponentScan("bb")
public class AnnotationScan{

}

在使用@ComponentScan()這個(gè)注解的時(shí)候，在測(cè)試類上需要@ContextConfiguration這個(gè)注解來加載配置類…

  • @ContextConfiguration這個(gè)注解又在Spring的test包下..

創(chuàng)建對(duì)象以及處理對(duì)象依賴關(guān)系，相關(guān)的注解：

  • @ComponentScan掃描器

  • @Configuration表明該類是配置類

  • @Component   指定把一個(gè)對(duì)象加入IOC容器--->@Name也可以實(shí)現(xiàn)相同的效果【一般少用】

  • @Repository   作用同@Component； 在持久層使用

  • @Service      作用同@Component； 在業(yè)務(wù)邏輯層使用

  • @Controller    作用同@Component； 在控制層使用

  • @Resource  依賴關(guān)系

    • 如果@Resource不指定值，那么就根據(jù)類型來找，相同的類型在IOC容器中不能有兩個(gè)

    • 如果@Resource指定了值，那么就根據(jù)名字來找

測(cè)試代碼:

  • UserDao

package aa;

import org.springframework.stereotype.Repository;

/**
* Created by ozc on 2017/5/10.
*/

//把對(duì)象添加到容器中,首字母會(huì)小寫
@Repository
public class UserDao{

   public void save(){
       System.out.println("DB:保存用戶");
   }


}

  • userService

package aa;


import org.springframework.stereotype.Service;

import javax.annotation.Resource;


//把UserService對(duì)象添加到IOC容器中,首字母會(huì)小寫
@Service
public class UserService{

   //如果@Resource不指定值，那么就根據(jù)類型來找--->UserDao....當(dāng)然了，IOC容器不能有兩個(gè)UserDao類型的對(duì)象
   //@Resource

   //如果指定了值，那么Spring就在IOC容器找有沒有id為userDao的對(duì)象。
   @Resource(name = "userDao")
   private UserDao userDao;

   public void save(){
       userDao.save();
   }
}

  • userAction

package aa;

import org.springframework.stereotype.Controller;

import javax.annotation.Resource;

/**
* Created by ozc on 2017/5/10.
*/

//把對(duì)象添加到IOC容器中,首字母會(huì)小寫
@Controller
public class UserAction{

   @Resource(name = "userService")
   private UserService userService;

   public String execute(){
       userService.save();
       return null;
   }
}

  • 測(cè)試

package aa;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* Created by ozc on 2017/5/10.
*/
public class App{

   public static void main(String[] args){

       // 創(chuàng)建容器對(duì)象
       ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml");

       UserAction userAction = (UserAction) ac.getBean("userAction");

       userAction.execute();
   }
}
Spring入門這一篇就夠了

通過Java方式

由于Spring的自動(dòng)裝配并不能將第三方庫組件裝配到應(yīng)用中，于是需要顯式裝配配置。顯示裝配有兩種方式

  • 通過java代碼裝配bean

  • 通過XML裝配bean

Spring In Action作者首推使用自動(dòng)裝配的功能，而后是通過java代碼配置bean，最后才用XML文件配置的方式..

那么怎么通過java代碼來配置Bean呢？？

  • 編寫一個(gè)java類，使用@Configuration修飾該類

  • 被@Configuration修飾的類就是配置類

編寫配置類:

    @org.springframework.context.annotation.Configuration
   public class Configuration{

   }

使用配置類創(chuàng)建bean:

  • 使用@Bean來修飾方法，該方法返回一個(gè)對(duì)象。

  • 不管方法體內(nèi)的對(duì)象是怎么創(chuàng)建的，Spring可以獲取得到對(duì)象就行了。

  • Spring內(nèi)部會(huì)將該對(duì)象加入到Spring容器中

  • 容器中bean的ID默認(rèn)為方法名

@org.springframework.context.annotation.Configuration
public class Configuration{

   @Bean
   public UserDao userDao(){

       UserDao userDao = new UserDao();
       System.out.println("我是在configuration中的"+userDao);
       return userDao;
   }

}

  • 測(cè)試代碼：要使用@ContextConfiguration加載配置類的信息【引入test包】

package bb;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;

/**
* Created by ozc on 2017/5/11.
*/
//加載配置類的信息
@ContextConfiguration(classes = Configuration.class)
public class Test2{

   @Test
   public void test33(){

       ApplicationContext ac =
               new ClassPathXmlApplicationContext("bb/bean.xml");

       UserDao userDao = (UserDao) ac.getBean("userDao");

       System.out.println(userDao);
   }
}
Spring入門這一篇就夠了

三種方式混合使用

注解和XML配置是可以混合使用的，JavaConfig和XML也是可以混合使用的…

如果JavaConfig的配置類是分散的，我們一般再創(chuàng)建一個(gè)更高級(jí)的配置類（root），然后使用@Import來將配置類進(jìn)行組合
如果XML的配置文件是分散的，我們也是創(chuàng)建一個(gè)更高級(jí)的配置文件（root），然后使用

在JavaConfig引用XML

  • 使用@ImportResource()

在XML引用JavaConfig

  • 使用節(jié)點(diǎn)就行了

bean對(duì)象創(chuàng)建細(xì)節(jié)

在Spring第一篇中，我們?yōu)槭裁匆隨pring提出了這么一些問題：

Spring入門這一篇就夠了

既然我們現(xiàn)在已經(jīng)初步了解IOC容器了，那么這些問題我們都是可以解決的。并且是十分簡(jiǎn)單【對(duì)象寫死問題已經(jīng)解決了，IOC容器就是控制反轉(zhuǎn)創(chuàng)建對(duì)象】

scope屬性

指定scope屬性，IOC容器就知道創(chuàng)建對(duì)象的時(shí)候是單例還是多例的了。

屬性的值就只有兩個(gè)：?jiǎn)卫?多例

Spring入門這一篇就夠了

  • 當(dāng)我們使用singleton【單例】的時(shí)候，從IOC容器獲取的對(duì)象都是同一個(gè)：

Spring入門這一篇就夠了

  • 當(dāng)我們使用prototype【多例】的時(shí)候，從IOC容器獲取的對(duì)象都是不同的：

Spring入門這一篇就夠了

scope屬性除了控制對(duì)象是單例還是多例的，還控制著對(duì)象創(chuàng)建的時(shí)間！

  • 我們?cè)赨ser的構(gòu)造函數(shù)中打印出一句話，就知道User對(duì)象是什么時(shí)候創(chuàng)建了。

    public User(){

       System.out.println("我是User，我被創(chuàng)建了");
   }

  • 當(dāng)使用singleton的時(shí)候，對(duì)象在IOC容器之前就已經(jīng)創(chuàng)建了

    • Spring入門這一篇就夠了

  • 當(dāng)使用prototype的時(shí)候，對(duì)象在使用的時(shí)候才創(chuàng)建

    • Spring入門這一篇就夠了

lazy-init屬性

lazy-init屬性只對(duì)singleton【單例】的對(duì)象有效…..lazy-init默認(rèn)為false….

有的時(shí)候，可能我們想要對(duì)象在使用的時(shí)候才創(chuàng)建，那么將lazy-init設(shè)置為ture就行了

Spring入門這一篇就夠了

init-method和destroy-method

如果我們想要對(duì)象在創(chuàng)建后，執(zhí)行某個(gè)方法，我們指定為init-method屬性就行了。。

如果我們想要IOC容器銷毀后，執(zhí)行某個(gè)方法，我們指定destroy-method屬性就行了。

    

Bean創(chuàng)建細(xì)節(jié)總結(jié)

    /**
    * 1) 對(duì)象創(chuàng)建： 單例/多例
    *  scope="singleton", 默認(rèn)值， 即 默認(rèn)是單例 【service/dao/工具類】
    *  scope="prototype", 多例；              【Action對(duì)象】
    *
    * 2) 什么時(shí)候創(chuàng)建?
    *    scope="prototype"  在用到對(duì)象的時(shí)候，才創(chuàng)建對(duì)象。
    *    scope="singleton"  在啟動(dòng)(容器初始化之前)， 就已經(jīng)創(chuàng)建了bean，且整個(gè)應(yīng)用只有一個(gè)。
    * 3)是否延遲創(chuàng)建
    *    lazy-init="false"  默認(rèn)為false,  不延遲創(chuàng)建，即在啟動(dòng)時(shí)候就創(chuàng)建對(duì)象
    *    lazy-init="true"   延遲初始化， 在用到對(duì)象的時(shí)候才創(chuàng)建對(duì)象
    *    （只對(duì)單例有效）
    * 4) 創(chuàng)建對(duì)象之后，初始化/銷毀
    *    init-method="init_user"       【對(duì)應(yīng)對(duì)象的init_user方法，在對(duì)象創(chuàng)建之后執(zhí)行 】
    *    destroy-method="destroy_user"  【在調(diào)用容器對(duì)象的destroy方法時(shí)候執(zhí)行，(容器用實(shí)現(xiàn)類)】
    */

如果文章有錯(cuò)的地方歡迎指正，大家互相交流。


網(wǎng)站欄目：Spring入門這一篇就夠了
轉(zhuǎn)載注明：http://weahome.cn/article/pjppip.html

其他資訊

在線咨詢

微信咨詢

電話咨詢

028-86922220（工作日）

18980820575（7×24）

提交需求

返回頂部