數據庫

Spring入門這一篇就夠了

前言

前面已經學習了Struts2和Hibernate框架了。接下來學習的是Spring框架…本博文主要是引入Spring框架…

Spring介紹

Spring誕生:

  • 創建Spring的目的就是用來替代更加重量級的的企業級Java技術
  • 簡化Java的開發
    • 基于POJO輕量級和最小侵入式開發
    • 通過依賴注入和面向接口實現松耦合
    • 基于切面和慣例進行聲明式編程
    • 通過切面和模板**減少樣板式代碼 **

侵入式概念

Spring是一種非侵入式的框架

侵入式

  • 對于EJB、Struts2等一些傳統的框架,通常是要實現特定的接口,繼承特定的類才能增強功能
    • 改變了java類的結構

非侵入式

  • 對于Hibernate、Spring等框架,對現有的類結構沒有影響,就能夠增強JavaBean的功能

松耦合

前面我們在寫程序的時候,都是面向接口編程,通過DaoFactroy等方法來實現松耦合

 ? ?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);

DAO層和Service層通過DaoFactory來實現松耦合

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

而Spring給我們更加合適的方法來實現松耦合,并且更加靈活、功能更加強大!—->IOC控制反轉

切面編程

切面編程也就是AOP編程,其實我們在之前也接觸過…動態代理就是一種切面編程了

當時我們使用動態代理+注解的方式給Service層的方法添加權限.

 ? [email protected] ? [email protected]("添加分類") ? ?/*添加分類*/ ? ?public void addCategory(Category category) { ? ? ? ?categoryDao.addCategory(category); ? ?} ? ?/*查找分類*/ ? [email protected] ? ?public void findCategory(String id) { ? ? ? ?categoryDao.findCategory(id); ? ?} ? [email protected] ? [email protected]("查找分類") ? ?/*查看分類*/ ? ?public List<Category> getAllCategory() { ? ? ? ?return categoryDao.getAllCategory(); ? ?} ? ?/*添加圖書*/ ? [email protected] ? ?public void addBook(Book book) { ? ? ? ?bookDao.addBook(book); ? ?}
  • Controller調用Service的時候,Service返回的是一個代理對象
  • 代理對象得到Controller想要調用的方法,通過反射來看看該方法上有沒有注解
  • 如果有注解的話,那么就判斷該用戶是否有權限來調用 此方法,如果沒有權限,就拋出異常給Controller,Controller接收到異常,就可以提示用戶沒有權限了。

AOP編程可以簡單理解成:在執行某些代碼前,執行另外的代碼

  • Struts2的攔截器也是面向切面編程【在執行Action業務方法之前執行攔截器】

Spring也為我們提供更好地方式來實現面向切面編程!


引出Spring

我們試著回顧一下沒學Spring的時候,是怎么開發Web項目的

  • 1. 實體類—>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

我們來思考幾個問題:

  • ①:對象創建創建能否寫死?
  • ②:對象創建細節
    • action    訪問時候創建
    • service   啟動時候創建
    • dao       啟動時候創建
    • action  多個   【維護成員變量】
    • service 一個   【不需要維護公共變量】
    • dao     一個   【不需要維護公共變量】
    • 對象數量
    • 創建時間
  • ③:對象的依賴關系
    • action 依賴 service
    • service依賴 dao

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

對于第二個問題,我們要控制對象的數量和創建事件就有點麻煩了….

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

IOC控制反轉

Spring的核心思想之一:Inversion of Control , 控制反轉 IOC

那么控制反轉是什么意思呢???對象的創建交給外部容器完成,這個就做控制反轉。

  • Spring使用控制反轉來實現對象不用在程序中寫死
  • 控制反轉解決對象處理問題【把對象交給別人創建】

那么對象的對象之間的依賴關系Spring是怎么做的呢??依賴注入,dependency injection.

  • Spring使用依賴注入來實現對象之間的依賴關系
  • 在創建完對象之后,對象的關系處理就是依賴注入

上面已經說了,控制反轉是通過外部容器完成的,而Spring又為我們提供了這么一個容器,我們一般將這個容器叫做:IOC容器.

無論是創建對象、處理對象之間的依賴關系、對象創建的時間還是對象的數量,我們都是在Spring為我們提供的IOC容器上配置對象的信息就好了。

那么使用IOC控制反轉這一思想有什么作用呢???我們來看看一些優秀的回答…

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

我摘取一下核心的部分:

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

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

在以上的描述中,誕生了兩個專業詞匯,依賴注入和控制反轉所謂的依賴注入,則是,甲方開放接口,在它需要的時候,能夠講乙方傳遞進來(注入)所謂的控制反轉,甲乙雙方不相互依賴,交易活動的進行不依賴于甲乙任何一方,整個活動的進行由第三方負責管理。

參考優秀的博文①:https://www.tianmaying.com/tutorial/spring-ioc

參考優秀的博文②:這里寫鏈接內容

知乎@Intopass的回答:

  1. 不用自己組裝,拿來就用。
  2. 享受單例的好處,效率高,不浪費空間。
  3. 便于單元測試,方便切換mock組件。
  4. 便于進行AOP操作,對于使用者是透明的。
  5. 統一配置,便于修改。

Spring模塊

Spring可以分為6大模塊:

  • Spring Core  spring的核心功能: IOC容器, 解決對象創建及依賴關系
  • Spring Web  Spring對web模塊的支持。
    • 可以與struts整合,讓struts的action創建交給spring
    • spring mvc模式
  • Spring DAO  Spring 對jdbc操作的支持  【JdbcTemplate模板工具類】
  • Spring ORM  spring對orm的支持:
    • 既可以與hibernate整合,【session】
    • 也可以使用spring的對hibernate操作的封裝
  • Spring AOP  切面編程
  • SpringEE   spring 對javaEE其他模塊的支持

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

Core模塊快速入門

搭建配置環境

引入jar包:

本博文主要是core模塊的內容,涉及到Spring core的開發jar包有五個

  • 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核心功能
  • spring-expression-3.2.5.RELEASE.jar    spring表達式相關表

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

編寫配置文件:

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

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

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

我是使用Intellij Idea集成開發工具的,可以選擇自帶的Spring配置文件,它長的是這樣:

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

前面在介紹Spring模塊的時候已經說了,Core模塊是:IOC容器,解決對象創建和之間的依賴關系。

因此Core模塊主要是學習如何得到IOC容器,通過IOC容器來創建對象、解決對象之間的依賴關系、IOC細節。

得到Spring容器對象【IOC容器】

Spring容器不單單只有一個,可以歸為兩種類型

  • **Bean工廠,BeanFactory【功能簡單】 **
  • 應用上下文,ApplicationContext【功能強大,一般我們使用這個】

通過Resource獲取BeanFactory

  • 加載Spring配置文件
  • 通過XmlBeanFactory+配置文件來創建IOC容器
 ? ? ? ?//加載Spring的資源文件 ? ? ? ?Resource resource = new ClassPathResource("applicationContext.xml"); ? ? ? ?//創建IOC容器對象【IOC容器=工廠類+applicationContext.xml】 ? ? ? ?BeanFactory beanFactory = new XmlBeanFactory(resource);

類路徑下XML獲取ApplicationContext

  • 直接通過ClassPathXmlApplicationContext對象來獲取
 ? ? ? ?// 得到IOC容器對象 ? ? ? ?ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); ? ? ? ?System.out.println(ac);

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

  • 使用XML文件配置
  • 使用注解來配置
  • 使用JavaConfig來配置

XML配置方式

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

  • 首先我們先有個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的方法創建對象的….
 ? ?User user = new User();
  • 現在我們有了IOC容器,可以讓IOC容器幫我們創建對象了。在applicationContext.xml文件中配置對應的信息就行了
 ? ? ? <!-- ? ? ? ?使用bean節點來創建對象 ? ? ? ? ? ?id屬性標識著對象 ? ? ? ? ? ?name屬性代表著要創建對象的類全名 ? ? ? ?--> ? ?<bean id="user" class="User"/>

通過IOC容器對象獲取對象:

  • 在外界通過IOC容器對象得到User對象
 ? ? ? ?// 得到IOC容器對象 ? ? ? ?ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); ? ? ? ?User user = (User) ac.getBean("user"); ? ? ? ?System.out.println(user);

上面我們使用的是IOC通過無參構造函數來創建對象,我們來回顧一下一般有幾種創建對象的方式:

  • 無參構造函數創建對象
  • 帶參數的構造函數創建對象
  • 工廠創建對象
    • 靜態方法創建對象
    • 非靜態方法創建對象

使用無參的構造函數創建對象我們已經會了,接下來我們看看使用剩下的IOC容器是怎么創建對象的。

帶參數的構造函數創建對象

首先,JavaBean就要提供帶參數的構造函數:

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

接下來,關鍵是怎么配置applicationContext.xml文件了。

 ? ?<bean id="user" class="User"> ? ? ? ?<!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個--> ? ? ? ?<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg> ? ? ? ?<constructor-arg index="1" name="username" type="java.lang.String" value="zhongfucheng"></constructor-arg> ? ?</bean>

在constructor上如果構造函數的值是一個對象,而不是一個普通類型的值,我們就需要用到ref屬性了,而不是value屬性

比如說:我在User對象上維護了Person對象的值,想要在構造函數中初始化它。因此,就需要用到ref屬性了

 ? ?<bean id="person" class="Person"></bean>  ? ?<bean id="user" class="User" > ? ? ? ?<!--通過constructor這個節點來指定構造函數的參數類型、名稱、第幾個--> ? ? ? ?<constructor-arg index="0" name="id" type="java.lang.String" value="1"></constructor-arg> ? ? ? ?<constructor-arg index="1" name="username" type="java.lang.String" ref="person"></constructor-arg> ? ?</bean>

工廠靜態方法創建對象

首先,使用一個工廠的靜態方法返回一個對象

public class Factory { ? ?public static User getBean() { ? ? ? ?return new User(); ? ?}}

配置文件中使用工廠的靜態方法返回對象

 ? ?<!--工廠靜態方法創建對象,直接使用class指向靜態類,指定靜態方法就行了--> ? ?<bean id="user" class="Factory" factory-method="getBean" > ? ?</bean>

工廠非靜態方法創建對象

首先,也是通過工廠的非非靜態方法來得到一個對象

public class Factory { ? ?public User getBean() { ? ? ? ?return new User(); ? ?}}

配置文件中使用工廠的非靜態方法返回對象

 ? ?<!--首先創建工廠對象--> ? ?<bean id="factory" class="Factory"/> ? ?<!--指定工廠對象和工廠方法--> ? ?<bean id="user" class="User" factory-bean="factory" factory-method="getBean"/>

c名稱空間

我們在使用XML配置創建Bean的時候,如果該Bean有構造器,那么我們使用<constructor-arg>這個節點來對構造器的參數進行賦值…

<constructor-arg>未免有點太長了,為了簡化配置,Spring來提供了c名稱空間…

要想c名稱空間是需要導入xmlns:c="http://www.springframework.org/schema/c"

 ? ?<bean id="userService" class="bb.UserService" c:userDao-ref=""> ? ?</bean>

c名稱空間有個缺點:不能裝配集合,當我們要裝配集合的時候還是需要<constructor-arg>這個節點

裝載集合

如果對象上的屬性或者構造函數擁有集合的時候,而我們又需要為集合賦值,那么怎么辦?

  • 在構造函數上,普通類型
 ? ?<bean id="userService" class="bb.UserService" > ? ? ? ?<constructor-arg > ? ? ? ? ? ?<list> ? ? ? ? ? ? ? ?//普通類型 ? ? ? ? ? ? ? ?<value></value> ? ? ? ? ? ?</list> ? ? ? ?</constructor-arg> ? ?</bean>
  • 在屬性上,引用類型
 ? ? <property name="userDao"> ? ? ? ? <list> ? ? ? ? ? ? <ref></ref> ? ? ? ? </list> ? ? </property>

注解方式

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

通過注解來配置信息就是為了簡化IOC容器的配置,注解可以把對象添加到IOC容器中、處理對象依賴關系,我們來看看怎么用吧:

使用注解步驟:

  • 1)先引入context名稱空間
    • xmlns:context=”http://www.springframework.org/schema/context”
  • 2)開啟注解掃描器
    • <context:component-scan base-package=""></context:component-scan>
    • 第二種方法:也可以通過自定義掃描類以@CompoentScan修飾來掃描IOC容器的bean對象。。如下代碼:
//表明該類是配置類@Configuration//啟動掃描器,掃描bb包下的 ? ?//也可以指定多個基礎包 ? ?//也可以指定類型@ComponentScan("bb")public class AnnotationScan {}

在使用@ComponentScan()這個注解的時候,在測試類上需要@ContextConfiguration這個注解來加載配置類…

  • @ContextConfiguration這個注解又在Spring的test包下..

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

  • @ComponentScan掃描器
  • @Configuration表明該類是配置類
  • @Component   指定把一個對象加入IOC容器—>@Name也可以實現相同的效果【一般少用】
  • @Repository   作用同@Component; 在持久層使用
  • @Service      作用同@Component; 在業務邏輯層使用
  • @Controller    作用同@Component; 在控制層使用
  • @Resource  依賴關系
    • 如果@Resource不指定值,那么就根據類型來找,相同的類型在IOC容器中不能有兩個
    • 如果@Resource指定了值,那么就根據名字來找

測試代碼:

  • UserDao
package aa;import org.springframework.stereotype.Repository;/** * Created by ozc on 2017/5/10. *///把對象添加到容器中,首字母會小寫@Repositorypublic class UserDao { ? ?public void save() { ? ? ? ?System.out.println("DB:保存用戶"); ? ?}}
  • userService
package aa;import org.springframework.stereotype.Service;import javax.annotation.Resource;//把UserService對象添加到IOC容器中,首字母會小寫@Servicepublic class UserService { ? ?//如果@Resource不指定值,那么就根據類型來找--->UserDao....當然了,IOC容器不能有兩個UserDao類型的對象 ? ?//@Resource ? ?//如果指定了值,那么Spring就在IOC容器找有沒有id為userDao的對象。 ? [email protected](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. *///把對象添加到IOC容器中,首字母會小寫@Controllerpublic class UserAction { ? [email protected](name = "userService") ? ?private UserService userService; ? ?public String execute() { ? ? ? ?userService.save(); ? ? ? ?return null; ? ?}}
  • 測試
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) { ? ? ? ?// 創建容器對象 ? ? ? ?ApplicationContext ac = new ClassPathXmlApplicationContext("aa/applicationContext.xml"); ? ? ? ?UserAction userAction = (UserAction) ac.getBean("userAction"); ? ? ? ?userAction.execute(); ? ?}}

通過Java方式

由于Spring的自動裝配并不能將第三方庫組件裝配到應用中,于是需要顯式裝配配置。顯示裝配有兩種方式

  • 通過java代碼裝配bean
  • 通過XML裝配bean

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

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

  • 編寫一個java類,使用@Configuration修飾該類
  • 被@Configuration修飾的類就是配置類

編寫配置類:

 ? [email protected] ? ?public class Configuration { ? ?}

使用配置類創建bean:

  • 使用@Bean來修飾方法,該方法返回一個對象。
  • 不管方法體內的對象是怎么創建的,Spring可以獲取得到對象就行了。
  • Spring內部會將該對象加入到Spring容器中
  • 容器中bean的ID默認為方法名
@org.springframework.context.annotation.Configurationpublic class Configuration { ? [email protected] ? ?public UserDao userDao() { ? ? ? ?UserDao userDao = new UserDao(); ? ? ? ?System.out.println("我是在configuration中的"+userDao); ? ? ? ?return userDao; ? ?}}
  • 測試代碼:要使用@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 { ? [email protected] ? ?public void test33() { ? ? ? ?ApplicationContext ac = ? ? ? ? ? ? ? ?new ClassPathXmlApplicationContext("bb/bean.xml"); ? ? ? ?UserDao userDao = (UserDao) ac.getBean("userDao"); ? ? ? ?System.out.println(userDao); ? ?}}

三種方式混合使用

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

如果JavaConfig的配置類是分散的,我們一般再創建一個更高級的配置類(root),然后使用@Import來將配置類進行組合
如果XML的配置文件是分散的,我們也是創建一個更高級的配置文件(root),然后使用

在JavaConfig引用XML

  • 使用@ImportResource()

在XML引用JavaConfig

  • 使用<bean>節點就行了

bean對象創建細節

在Spring第一篇中,我們為什么要引入Spring提出了這么一些問題:

既然我們現在已經初步了解IOC容器了,那么這些問題我們都是可以解決的。并且是十分簡單【對象寫死問題已經解決了,IOC容器就是控制反轉創建對象】

scope屬性

指定scope屬性,IOC容器就知道創建對象的時候是單例還是多例的了。

屬性的值就只有兩個:單例/多例

  • 當我們使用singleton【單例】的時候,從IOC容器獲取的對象都是同一個
  • 當我們使用prototype【多例】的時候,從IOC容器獲取的對象都是不同的

scope屬性除了控制對象是單例還是多例的,還控制著對象創建的時間!

  • 我們在User的構造函數中打印出一句話,就知道User對象是什么時候創建了。
 ? ?public User() { ? ? ? ?System.out.println("我是User,我被創建了"); ? ?}
  • 當使用singleton的時候,對象在IOC容器之前就已經創建了
  • 當使用prototype的時候,對象在使用的時候才創建

lazy-init屬性

lazy-init屬性只對singleton【單例】的對象有效…..lazy-init默認為false….

有的時候,可能我們想要對象在使用的時候才創建,那么將lazy-init設置為ture就行了


init-method和destroy-method

如果我們想要對象在創建后,執行某個方法,我們指定為init-method屬性就行了。。

如果我們想要IOC容器銷毀后,執行某個方法,我們指定destroy-method屬性就行了。

 ? ?<bean id="user" class="User" scope="singleton" lazy-init="true" init-method="" destroy-method=""/>

Bean創建細節總結

 ? ?/** ? ? * 1) 對象創建: 單例/多例 ? ? * ?scope="singleton", 默認值, 即 默認是單例 【service/dao/工具類】 ? ? * ?scope="prototype", 多例; ? ? ? ? ? ? ?【Action對象】 ? ? *  ? ? * 2) 什么時候創建? ? ? * ? ?scope="prototype" ?在用到對象的時候,才創建對象。 ? ? * ? ?scope="singleton" ?在啟動(容器初始化之前), 就已經創建了bean,且整個應用只有一個。 ? ? * 3)是否延遲創建 ? ? * ? ?lazy-init="false" ?默認為false, ?不延遲創建,即在啟動時候就創建對象 ? ? * ? ?lazy-init="true" ? 延遲初始化, 在用到對象的時候才創建對象 ? ? * ? ?(只對單例有效) ? ? * 4) 創建對象之后,初始化/銷毀 ? ? * ? ?init-method="init_user" ? ? ? 【對應對象的init_user方法,在對象創建之后執行 】 ? ? * ? ?destroy-method="destroy_user" ?【在調用容器對象的destroy方法時候執行,(容器用實現類)】 ? ? */

如果文章有錯的地方歡迎指正,大家互相交流。

我還沒有學會寫個人說明!

徒手教你使用zookeeper編寫服務發現

上一篇

Spring Cloud 上手實戰-架構解析及實作

下一篇

你也可能喜歡

Spring入門這一篇就夠了

長按儲存圖像,分享給朋友

ITPUB 每周精要將以郵件的形式發放至您的郵箱


微信掃一掃

微信掃一掃
天津11选五开奖结果手 河南481遗漏号码查询 贵州十一选五中奖规则 配资炒股找久联优配 彩票app平台 四肖中特期期准免费 四川快乐12 体育彩票6+1中奖规则 新韩国1.5分彩开奖查询 南粤风采36选7最新走势 吉利汽车股票