Spring框架IOC,DI概念理解

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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的注入方式

1set方式注入,注入数据的前提是必须要有一个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里做springbeans的声明。

 

<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中相同的beanid,那么采取自动装配:

 

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

以上是关于Spring框架IOC,DI概念理解的主要内容,如果未能解决你的问题,请参考以下文章

对IoC和DI的理解

依赖注入(DI)和控制反转(IOC)

如何理解Spring IOC

Spring IOC的理解

谈谈对Spring IOC的理解

谈谈对Spring IOC的理解