Spring框架IOC，DI概念理解

1.什麼是框架？

 框架是一種重複使用的解決方案，針對某個軟件開發的問題提出的。

 Spring框架，它是一個大型的包含不少重複使用的某個領域的解決方案。

 Spring的理念：不要重複發明輪子。

 

2.Spring的理解？

 

 首先，Spring是一個容器。它是裝對象的。主要就是經過搜索class的路徑。找出bean對象，實際就是根據反射來獲取這個bean對象的：

 

Class<?> classit=Class.forName("com.jinglin.model.Person");
         Person p =(Person)classit.newInstance();

 

3.IOC的理解？

 控制反轉的容器。

 把對象的獲取的主動權交出去

4.DI:

 依賴注入，經過在構建bean對象的時候，把數據加入到對象中，所謂的依賴的意思就是這裏的數據有多是經過其它的bean對象獲得的。

5.對於Spring中的bean的注入方式

1）set方式注入，注入數據的前提是必需要有一個set方法，在bean的類裏。是經過屬性的注入方式：

java類：

 

public class Boy {
    public String name;
    public Girl girlfriend;
    public List<String> habbies;
    public Map<String,Float> subject;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Girl getGirlfriend() {
        return girlfriend;
    }
    public void setGirlfriend(Girl girlfriend) {
        this.girlfriend = girlfriend;
    }
    public List<String> getHabbies() {
        return habbies;
    }
    public void setHabbies(List<String> habbies) {
        this.habbies = habbies;
    }
    public Map<String, Float> getSubject() {
        return subject;
    }
    public void setSubject(Map<String, Float> subject) {
        this.subject = subject;
    }
    
}

 

public class Girl {
    public String name;
    public Boy boyfriend;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Boy getBoyfriend() {
        return boyfriend;
    }
    public void setBoyfriend(Boy boyfriend) {
        this.boyfriend = boyfriend;
    }
    
}

 

配置文件：

<!-- 把全部的類都生成bean對象,scope默認做用域是共享模式(prototype爲非共享模式，生成的對象的地址不同 )-->
    <bean id="boy" class="com.jinglin.model.Boy">
        <!-- 屬性注入值 -->
        <property name="name" value="zhangsan"></property>
        <!-- 關聯到另一個bean對象 -->
        <property name="girlfriend" ref="girl"></property>
        <!-- 集合屬性注入 -->
        <property name="habbies">
            <!--注入的list的集合值  -->
            <list>
                <value>網球</value>
                <value>乒乓球</value>
                <value>網遊</value>
            </list>
        </property>
        <!-- 鍵值對的集合的數據注入 -->
        <property name="subject">
            <!-- 給map這種集合數據類型注入 -->
            <map>
                <entry>
                    <!-- 表示鍵 -->
                    <key><value>英語</value></key>
                    <!-- 表示值 -->
                    <value>98</value>
                </entry>
                <entry>
                    <key><value>數學</value></key>
                    <value>99</value>
                </entry>
            </map>
        </property>
    </bean>
    <bean id="girl" class="com.jinglin.model.Girl">
        <!-- 屬性注入值 -->
        <property name="name" value="lily"></property>
        <!-- 關聯到另一個bean對象 -->
        <property name="boyfriend" ref="boy"></property>
    </bean>

2）構造函數的注入，初始化對象的時候經過構造函數傳入數據：

有參構造：

public Person(String name, String age) {
        this.name = name;
        this.age = age;
    }

配置文件：

<!-- bean至關因而一個裝對象的容器 -->
    <bean id="person" class="com.jinglin.model.Person">
        <!--經過構造參數的方式注入值  -->
        <constructor-arg value="zhangsan"></constructor-arg>
        <constructor-arg value="14"></constructor-arg>
    </bean>

6.那麼由spring給咱們提供的bean對象的做用域？

 1）默認狀況下，spring提供的bean對象是共享模式的。

在內存中只出現一個實例化對象。

默認的bean的做用域：scope="singleton"

2）若是更改bean的做用域，就是非共享模式，

scope="prototype"

7.自動裝配+註解，簡化spring中的bean對象的開發。

 Spring中的bean對象自動從容器裏搜索和本身的屬性字段名一致的狀況，若是有，就自動匹配。

 開發步驟，首先明確，要將全部的包掃描的spring容器裏。

 1）在applicationContext.xml裏作spring的beans的聲明。

 

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

 

2)將各個包掃描到spring裏。

 

<!-- 將包掃描到spring組件裏 -->
    <context:component-scan base-package="com.jinglin.dao">
    </context:component-scan>
    <context:component-scan base-package="com.jinglin.service">
    </context:component-scan>

 

3）給每一個類加入註解，告訴spring。將其加入到spring的容器裏。

 

@Component("goodsInfoDao")
public class GoodsInfoDao {
   public void insertitem(){
       System.out.println("這是商品信息的數據插入");
   }
}

 

4）爲了簡化配置，採起的自動裝配。通常都是經過名字自動裝配的：

在配置頭文件末尾加上

 

default-autowire="byName"

 

5）在開發的時候，對於同spring中相同的bean的id，那麼採起自動裝配：

 

@Component("userInfoService")
public class UserInfoService {
    
    @Autowired
    private UserInfoDao userInfoDao;

    public void additem(){
        System.out.println("這是用戶調用的業務層");
        userInfoDao.insertitem();
    }
}

 

8.Spring的延遲加載，當咱們須要這個spring提供的bean對象的時候，這個時候spring纔會去生成這個對象（默認狀況下，當spring加載它的文件的時候，就所有將spring裏配置的bean對象生成）。

 1）在applicationContext配置頭文件末尾加上

 

default-lazy-init="true"

 

缺點：沒法對單個的bean對象提供延遲加載配置。

2）針對單個的bean對象：

 

<bean id="person" lazy-init="true"  class="com.jinglin.model.Person">
        <!-- 經過構造參數的方式注入值 -->
        <constructor-arg value="zhangsan"></constructor-arg>
        <constructor-arg value="14"></constructor-arg>
    </bean>

 

3）直接在類中加註解，表示就是延遲加載。

 

@Component("goodsInfoService")
@Lazy
public class GoodsInfoService {
    @Autowired
    private GoodsInfoDao goodsInfoDao;
    public void additem(){
        System.out.println("這是商品信息的業務處理方法");
       goodsInfoDao.insertitem();
    }
    
    public GoodsInfoService(){
        System.out.println("這是goodsInfoService的無參構造函數");
    }
   
}

 

 

 

 

 

 

 

 

 

 

 

 

 

default-lazy-init="true"