亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

bean屬性的繼承

1. extend 父類

2. 多個bean具有相同屬性，但是沒有繼承關系，將配置文件class去掉

bean屬性的初始化和銷毀

1. bean標簽

2. 實現接口
   

構造ioc容器的約定

通過Spring的xml文件配置Bean作用域：（Spring默認作用域是Singleton）

1、Singleton作用域（單例模式：通過Spring容器實現單例模式，具有局限性：保證在一個Spring上下文(ApplicationContext）是單例模式，多個AppliactionContext單例模式就失效了。

定義：如果一個<bean>的作用域為Singleton，則該<bean>只會被實例化一次，只有一個Bean會被創建。（每次向Spring上下文（ApplicationContext生命周期存活）請求這個實例時，Spring都會返回同一個實例）。

代碼：

public class Bean1 {

private Bean2 bean2;

public Bean1(){

}

public Bean2 getBean2() {

return bean2;

}

public void setBean2(Bean2 bean2) {

this.bean2 = bean2;

}

}

public class Bean2 {

}

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1">

<property name="bean2" ref="bean2"></property>

</bean>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean2 bean2_1=context.getBean("bean2", Bean2.class);

System.out.println(bean2_1);

Bean2 bean2_2=context.getBean("bean2", Bean2.class);

System.out.println(bean2_2);

Bean1 bean1=context.getBean("bean1",Bean1.class);

System.out.println(bean1);

}

測試結果：

main.java.com.Bean作用域.Singleton.Bean2@a690707

main.java.com.Bean作用域.Singleton.Bean2@a690707

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

2、prototype作用域（多例模式）

定義：如果一個<bean>的作用域為prototype，則該<bean>會被實例化多次，有多個Bean會被創建（每次向Spring上下文請求該Bean都會new一個新的實例）。

代碼：

public class Bean1 {

private Bean2 bean2;

public Bean1(){

}

public Bean2 getBean2() {

return bean2;

}

public void setBean2(Bean2 bean2) {

this.bean2 = bean2;

}

}

public class Bean2 {

}

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1">

<property name="bean2" ref="bean2"></property>

</bean>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean2 bean2_1=context.getBean("bean2", Bean2.class);

System.out.println(bean2_1);

Bean2 bean2_2=context.getBean("bean2", Bean2.class);

System.out.println(bean2_2);

Bean1 bean1=context.getBean("bean1",Bean1.class);

System.out.println(bean1);

}

測試結果：

main.java.com.Bean作用域.Singleton.Bean2@34dfdf92

main.java.com.Bean作用域.Singleton.Bean2@55cf055c

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

拓展：bean1和bean2分別設置單例模式和多例模式進行不同組合使用。

1：bean1和bean2都是單例模式，則bean1的實例相等，bean1的屬性bean2相等。

代碼：

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

<property name="bean2" ref="bean2"></property>

</bean>

Bean1 bean1_1=context.getBean("bean1",Bean1.class);

System.out.println(bean1_1);

Bean1 bean1_2=context.getBean("bean1",Bean1.class);

System.out.println(bean1_2);

System.out.println(bean1_1==bean1_2);

結果：

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@34dfdf92]

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@34dfdf92]

true

2：bean1是單例模式和bean2都是多例模式，則bean1的實例相等，bean1的屬性bean2也相等（因為bean1是單例模式，Spring只實例化一次bean1，bean2只需要被實例化一次）。

代碼：

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

<property name="bean2" ref="bean2"></property>

</bean>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean1 bean1_1=context.getBean("bean1",Bean1.class);

System.out.println(bean1_1);

Bean1 bean1_2=context.getBean("bean1",Bean1.class);

System.out.println(bean1_2);

System.out.println(bean1_1==bean1_2);

}

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@55cf055c]

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@55cf055c]

true

3：bean1是多例模式和bean2都單例模式，則bean1的實例不相等，bean1的屬性bean2相等

代碼：

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="singleton"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="prototype">

<property name="bean2" ref="bean2"></property>

</bean>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean1 bean1_1=context.getBean("bean1",Bean1.class);

System.out.println(bean1_1);

Bean1 bean1_2=context.getBean("bean1",Bean1.class);

System.out.println(bean1_2);

System.out.println(bean1_1==bean1_2);

}

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@a690707]

false

4：bean1是多例模式和bean2都多例模式，則bean1的實例不相等，bean1的屬性bean2不相等

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="prototype">

<property name="bean2" ref="bean2"></property>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean1 bean1_1=context.getBean("bean1",Bean1.class);

System.out.println(bean1_1);

Bean1 bean1_2=context.getBean("bean1",Bean1.class);

System.out.println(bean1_2);

System.out.println(bean1_1==bean1_2);

}

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@66e376e1]

Bean1 [bean2=main.java.com.Bean作用域.Singleton.Bean2@5f91e28c]

false

方法注入：聲明一個protected、抽象、返回值為被依賴Bean類型的方法。(protected abstract Bean2 createBean2();)

適用于如下場景——

bean1是Singleton，bean2是Prototype，Bean1依賴Bean2，每次獲得Bean1的時候，正常情況下Bean2是相同的，方法注入則使Bean2不同。

代碼：

public abstract class Bean1 {

public abstract Bean2 createBean2();

public void printBean2(){

System.out.println(createBean2());

}

public Bean1(){

}

}

<bean id="bean2" class="main.java.com.Bean作用域.Singleton.Bean2" scope="prototype"></bean>

<bean id="bean1" class="main.java.com.Bean作用域.Singleton.Bean1" scope="singleton">

<lookup-method name="createBean2" bean="bean2"/>

</bean>

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-singleton.xml");

Bean1 bean1_1=context.getBean("bean1",Bean1.class);

System.out.println(bean1_1.createBean2());

System.out.println(bean1_1.createBean2());

System.out.println(bean1_1.createBean2());

}

測試結果：

main.java.com.Bean作用域.Singleton.Bean2@2467149d

main.java.com.Bean作用域.Singleton.Bean2@6b7a6216

main.java.com.Bean作用域.Singleton.Bean2@2fbdc97a

3、Web環境作用域（request作用域、session作用域、application作用域、websocket作用域）

4、自定義作用域（Spring內置的自定義SimpleThreadScope作用域）

課程內容：ioc

java web 發展2

java web 發展

懶加載lazy-init在被需要的時候才進行實例化的創建，僅對單例模式起作用，否則在spring上下文的進行初始化的時候進行實例的創建

通過xml注入Bean：

1、通過有參構造方法注入Bean?

步驟1：創建Bean的類（包括創建AnotherBean，作為Bean的依賴屬性），并提供有參的構造方法。

public class Bean {

private AnotherBean anotherBean;

private String string;

public Bean(AnotherBean anotherBean, String string) {

super();

this.anotherBean = anotherBean;

this.string = string;

}

}

步驟2：配置Spring.xml，通過<constructor-arg>標簽注入Bean，該標簽在<bean>標簽里編寫。

<constructor-arg>標簽屬性：

index——表示當前參數在構造方法中是第幾個。

name——Bean的屬性名。

type——表示參數的類型（如果為簡單類型則寫簡單類型（java.lang.int）,如果為依賴類型一般為類型的路徑）。

value——適合簡單的應用類型（int、String、float等）

ref——該Bean依賴另一Bean，它的值一般為被依賴Bean(AnotherBean)的<bean>的唯一標識Id。

代碼：<bean id="anotherbeanId" class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

? ? ? ? <bean class="main.java.com.Bean注入.構造器注入.Bean" id="beanId">

? ? ? ? <constructor-arg index="0" name="anotherBean" type="main.java.com.Bean注入.構造器注入.AnotherBean" ref="anotherbeanId"></constructor-arg>

? ? ? ? <constructor-arg index="1" name="string" type="java.lang.String" value="哈哈"></constructor-arg>

? ? ? ? </bean>

2、通過set方法注入Bean（注意:使用Set方法注入Bean，一定要提供無參構造函數）

步驟1：創建Bean的類（包括創建AnotherBean，作為Bean的屬性），并提供get/set方法。

public class Bean {

private AnotherBean anotherBean1;

private String string1;

public AnotherBean getAnotherBean1() {

return anotherBean1;

}

public void setAnotherBean1(AnotherBean anotherBean1) {

this.anotherBean1 = anotherBean1;

}

public String getString1() {

return string1;

}

public void setString1(String string1) {

this.string1 = string1;

}

步驟2：配置Spirng.xml，通過<property>標簽注入Bean，該標簽在<bean>標簽里。

<property>標簽屬性:

name——Bean的屬性名

ref——該Bean依賴另一Bean，它的值一般為被依賴Bean(AnotherBean)的<bean>的唯一標識Id。

value——適合簡單的應用類型（int、String、float等）

?<bean id="anotherbeanId" class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

? ? ? ? <bean class="main.java.com.Bean注入.構造器注入.Bean" id="beanId">

? ? ? ? <property name="anotherBean1" ref="anotherbeanId"></property>

? ? ? ? <property name="string1" value="嘿嘿"></property>

? ? ? ? </bean>

如果把Bean依賴的<bean>標簽放在<property>里邊則不會創建實例。

<bean class="main.java.com.Bean注入.構造器注入.Bean" id="beanId">

? ? ? ? <property name="anotherBean1">

? ? ? ? <bean id="" class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

? ? ? ? </property>

? ? ? ? <property name="string1" value="嘿嘿"></property>

? ? ? ? </bean> ?

注入Bean的簡單寫法：不需要<constructor-arg>和<property>標簽。

步驟1：<beans>標簽描述里添加兩條描述——

? ? xmlns:c="http://www.springframework.org/schema/c"

? ? xmlns:p="http://www.springframework.org/schema/p"

代碼：

?<!-- c代表通過構造方法注入Bean,Constructor的首字母?

? ? ? ? ? ? ?c:_0中的0代表構造方法中第一個參數,c:_0-ref中的ref代表value和ref的區分

? ? ? ? ? ? ?c:anotherBean中的anotherBean代表Bean屬性名,c:anotherBean-ref中的ref代表ref和value的區分

? ? ? ? ? ? ?p代表通過set方法注入Bean,property的首字母

? ? ? ? <bean id="anotherbeanId" class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

? ? ?<bean class="main.java.com.Bean注入.構造器注入.Bean" id="beanId" c:anotherBean-ref="anotherbeanId" c:string="嘻嘻" p:anotherBean1-ref="anotherbeanId" p:string1="呵呵"></bean>

3、集合類型屬性的Bean的注入（List、Set、Map、Properties，通過set方式注入）

步驟1：創建注入Bean的類（包括創建集合類型的屬性、包括基本和依賴類型，作為Bean的屬性）。

步驟2：配置spring.xml(通過set方式注入Bean)

? ? ?<bean id="anotherbeanId" class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

? ? ? ? <bean class="main.java.com.Bean注入.構造器注入.Bean" id="beanId">

? ? ? ? <property name="stringList">

? ? ? ? <list>

? ? ? ? <value>哈哈</value>

? ? ? ? <value>嘿嘿</value>

? ? ? ? </list>

? ? ? ? </property>

? ? ? ? <property name="anotherbeanList">

? ? ? ? <list>

? ? ? ? <ref bean="anotherbeanId"></ref>

? ? ? ? <ref bean="anotherbeanId"></ref>

? ? ? ? </list>

? ? ? ? </property>

? ? ? ? ? <property name="stringSet">

? ? ? ? <set>

? ? ? ? <value>哈哈</value>

? ? ? ? <value>嘿嘿</value>

? ? ? ? </set>

? ? ? ? </property>

? ? ? ? <property name="anotherbeanSet">

? ? ? ? <set>

? ? ? ? <ref bean="anotherbeanId"></ref>

? ? ? ? <ref bean="anotherbeanId"></ref>

? ? ? ? </set>

? ? ? ? </property>

? ? ? ? <property name="stringMap">

? ? ? ? <map>

? ? ? ? <entry key="aaa" value="張三"></entry>

? ? ? ? <entry key="bbb" value="李四"></entry>

? ? ? ? </map>

? ? ? ? </property>

? ? ? ? <property name="anotherbeanMap">

? ? ? ? <map>

? ? ? ? <entry key-ref="anotherbeanId" value-ref="anotherbeanId"></entry>

? ? ? ? </map>

? ? ? ? </property>

? ? ? ? <property name="properties">

? ? ? ? <props>

? ? ? ? <prop ?key="ccc">王五</prop>

? ? ? ? </props>

? ? ? ? </property>

? ? ? ? </bean>?

測試:

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-zhuru.xml");

Bean bean=context.getBean("beanId",Bean.class);

System.out.println(bean.getStringList());

System.out.println(bean.getAnotherbeanList());

System.out.println(bean.getStringSet());

System.out.println(bean.getAnotherbeanSet());

System.out.println(bean.getStringMap());

System.out.println(bean.getAnotherbeanMap());

System.out.println(bean.getProperties());

}

4、null值注入

步驟1：創建Bean的類（創建一個Bean的屬性）。

public class Bean {

private AnotherBean anotherBean2;

public Bean(){

}

public AnotherBean getAnotherBean2() {

return anotherBean2;

}

public void setAnotherBean2(AnotherBean anotherBean2) {

this.anotherBean2 = anotherBean2;

}

}

步驟2：配置spring.xml。

<property name="anotherBean2">

? ? ? ? <null></null>

? ? ? ? </property>

測試：

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-zhuru.xml");

Bean bean=context.getBean("beanId",Bean.class);

System.out.println(bean.getAnotherBean2());

}

5、注入時創建內部Bean

解釋:<property>標簽里可以不適用ref這個屬性去使用<bean>的id，而是在<property>標簽里使用如下在注入Bean時才去實例化該屬性，并進行注入。

<property name="anotherBean1">

<bean class="main.java.com.Bean注入.構造器注入.AnotherBean"></bean>

</property>

通過Spring的xml文件實現Bean：（注意：只要Spring.xml中配置了bean標簽，則就會根據class創建這個bean的實例）

1、通過構造方法實例化Bean。

步驟1：創建要實例化的類，并提供無參構造方法。

public class Bean {

public Bean(){

System.out.println("Bean被創建了");

}

步驟2：spring.xml中配置

<bean id="bean的唯一標識" class="要實例化bean的路徑"></bean>

測試:ApplicationContext context=new ClassPathXmlApplicationContext(spring.xml的路徑);

Bean bean=context.getBean("bean",Bean.class);

System.out.println(bean);

2、通過靜態方法實例化Bean。（通過Bean2的工廠的靜態方法實例化Bean）

步驟1：創建Bean2的工廠Bean2Factory類以及Bean2類，并且提供一個靜態、返回值類型為Bean2的方法,返回new Bean2()。

public class Bean2Factory {

public static Bean2 getBean2(){

return new Bean2();

}

}

public class Bean2 {

public Bean2(){

System.out.println("Bean2被創建了。");

}

步驟2：配置Spring.xml

<bean class="Bean2工廠的路徑" factory-method="Bean2工廠的靜態方法名" id="Bean2工廠的唯一標識"></bean>

測試:

ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc2.xml");

Bean2 bean=context.getBean("bean2factoryId",Bean2.class);

System.out.println(bean);

3、通過實例方法實例化Bean。（通過Bean2的工廠的實例方法實例化Bean）

步驟1：創建Bean3的工廠Bean3Factory類以及Bean3類，并且提供一個返回值類型為Bean3的方法，方法返回new Bean3()。

public class Bean3Factory {

public ?Bean3 getBean3(){

return new Bean3();

}

}

public class Bean3 {

public Bean3(){

System.out.println("Bean3被創建了。");

}

}

步驟2：配置Spring.xml

<bean class="main.java.com.imooc2.Bean3Factory" id="bean3Factory"></bean>

<bean class="main.java.com.imooc2.Bean3" factory-bean="bean3Factory" factory-method="getBean3" id="bean3"></bean>

給bean取別名：有類Bean1，并且通過bean標簽實例化Bean1，給Bean1的實例取多個名字。

例如：方式一：bean標簽里添加name屬性

<bean id="bean" class="main.java.com.imooc1.Bean" name="bean1_1,bean1_2"></bean>

? ? ? ? ? ?方式二:添加<alias>標簽

<bean id="bean" class="main.java.com.imooc2.Bean1" name="bean1_1,bean1_2"></bean>

<alias name="bean" alias="bean1_3"/><!-- alias只支持一個別名 -->

使用Spring管理Bean：

前提：導入相應包。

步驟：1、創建xml文件，并定義bean標簽（id屬性和class屬性）。

? ? ? ? ? 2、通過ApplicationContext讀取xml文件，獲取spring上下文。

? ? ? ? ? 3.通過ApplicationContext對象的getBean方法獲取Bean。

Spring.xml文件：

<bean id="bean的唯一標識" ?class="實例化bean的路徑"/>

測試類Test:

public class TestBean {

@Test

public void test(){

ApplicationContext context=new ClassPathXmlApplicationContext("spring-ioc.xml");

//第一個參數是xml中的唯一Id,第二個參數是返回的bean的類型。

Bean bean=context.getBean("bean",Bean.class);

System.out.println(bean);

}

}

編寫自己的IoC的約定: ?簡化IoC的業務邏輯，（對IOC容器的要求）。

1. 所有Bean的生命周期交由IoC容器管理

2. 所有被依賴的Bean通過構造方法執行注入（還可以通過set方式進行注入）

3. 被依賴的Bean需要優先創建（例如張三依賴于奧迪，如果想要創建張三這個對象，則一定先創建奧迪這個對象）

使用Ioc的好處：1、所有依賴關系被統一管理。

? ? ? ? ? ? ? ? ? ? ? ? ?2、每個類只需要管理自己的業務邏輯。

? ? ? ? ? ? ? ? ? ? ? ? ?3、修改依賴關系變得容易。

IOC容器的編寫:

/*

?* 1、實例化bean(包括依賴對象和被依賴對象)

?* 2、保存bean(要有一個私有域來保存創建好的bean,用Map集合來保存bean)

?* 3、提供bean

?* 4、每一個bean要產生一個Id與之相對應

?*/

public class IocContainer {

//保存Bean——Id對應String類型,bean對應Object類型,考慮線程安全問題沒用HashMap實現類。

private Map<String,Object> beans=new ConcurrentHashMap<String,Object>();

//提供Bean

public Object getBean(String beanId){

return beans.get(beanId);

}

/*實例化Bean——方法的參數：1、參數一：IOC要實例化的Bean來源哪個類(用到類的反射知識)

* ? ? ? ? ? ? ? ? ? ? ? 2、參數二：IOC要實例化的Bean的Id是什么

* ? ? ? ? ? ? ? ? ? ? ? 3、參數三：依賴奧迪的BeanId，通過方法參數告訴Ioc張三依賴于奧迪

* ? ? ? ? ? ? ? ? ? ? ??

*/

public void setBean(Class<?> clazz,String beanId,String...paramsBeanId){

//String類型的可變長度的數組:String...paramsBeanId

// 實現分為3步：1、因為通過構造方法創建bean，所以組裝構造方法所需要的參數值

Object [] paramsValue=new Object[paramsBeanId.length];

for(int i=0;i<paramsBeanId.length;i++){

//將方法傳過來的依賴的屬性Bean的Id通過集合beans獲取該對象(可以多個)的實例

paramsValue[i]=beans.get(paramsBeanId[i]);

}

? ? ? ? ? ?// 2、調用構造方法實例化bean

// clazz.getConstructors(),拿到該bean的所有構造方法

Object bean=null;

for (Constructor<?> constructor : clazz.getConstructors()) {

try {

bean=constructor.newInstance(paramsValue);

} catch (InstantiationException e) {

} catch (IllegalAccessException e) {

} catch (IllegalArgumentException e) {

} catch (InvocationTargetException e) {

}/*所有的異常都不處理:如果這個bean有多個構造方法，

那么至少有一個構造方法能通過這些參數值完成實例化。

*/

}

if(bean==null){//一個構造方法都沒能通過的情況

throw new RuntimeException("找不到合適的構造方法去實例化Bean");

}

// 3、將實例化的bean放入集合beans

beans.put(beanId, bean);

?

}

}

測試類的編寫:

public class TestIocContainer {

private IocContainer iocContainer=new IocContainer();

@Before

//創建Bean和使用Bean是兩個不同的業務邏輯

public void before(){

iocContainer.setBean(AoDi.class,"aodi");

iocContainer.setBean(BieKe.class,"bieke");

iocContainer.setBean(ZhangSan.class,"zhangsan","aodi");

iocContainer.setBean(LiSi.class,"lisi","bieke");

}

@Test

public void test(){

Humen zhangsan=(Humen) iocContainer.getBean("zhangsan");

zhangsan.goHome();

Humen lisi=(Humen) iocContainer.getBean("lisi");

lisi.goHome();

}

}

IoC概念:Inversion of Control控制反轉，控制:控制JavaBean對象的創建及銷毀(生命周期),反轉:將對象的控制權交給IoC容器（在如果對象之間有依賴關系，使用依賴對象時則要創建被依賴對象，被依賴對象的控制權在依賴對象手里，使用IoC則把控制權交給容器手里)。

控制反轉和依賴注入：是兩個不同的概念，但確實相輔相成的兩個概念，是解釋ioc兩個不同的角度。

耦合性：1、把聲明對象放在類的屬性域里，降低了耦合性，減少了對象的重復創建和銷毀。

符合類型設計的規范：一般對屬性通過構造方法傳入，或者是set方法傳入。（抽象的想，一個類自己不創建對象）

個人理解：控制反轉——》被依賴對象的創建交給IOC容器負責，當使用依賴對象時，IOC創建被依賴對象。

? ? ? ? ? ? ? ? ?依賴注入——》被依賴對象創建完成后，通過構造器注入或者是set方法方式注入對依賴對象進行 ? ? ? ? ? ? ? ? ?賦值。

Java?Web發展史：
第一階段:JavaBean+Servlet+Jsp逐步發展
第二階段:面對EJB重量級框架帶來的種種麻煩
第三階段:SpringMVC/Struts+Spring+Hibernate/myBatis
第四階段:享受SpringBoot"約定大于配置"的種種樂趣，很多繁瑣的配置都變成了約定
第五階段:以Dubbo為代表的SOA為服務架構體系(Dubbo是阿里創建的)
第六階段:比較前沿的技術，SpringCloud微服務架構技術生態圈(基于SpringBoot,保證了開箱即用，需要什么SpringCloud保證都有)