Spring的DI初步

DI:依赖注入

第一个DEMO:域属性注入

  java类:(Car类和Stu类,学生有一辆小汽车)

 1 package cn.dawn.day02di;
 2 /**
 3  * Created by Dawn on 2018/3/3.
 4  *///小汽车类public class Car {
 5     private String type;
 6     private String color;
 7
 8     public String getType() {
 9         return type;
10     }
11
12     public void setType(String type) {
13         this.type = type;
14     }
15
16     public String getColor() {
17         return color;
18     }
19
20     public void setColor(String color) {
21         this.color = color;
22     }
23 }
package cn.dawn.day02di;
/**
 * Created by Dawn on 2018/3/3.
 *///学生类public class Stu {
    private String name;
    private Integer age;
    private Car car;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }
}

配置xml中

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

    <!--汽车-->
    <bean id="car" class="cn.dawn.day02di.Car">
        <property name="type" value="奔驰"></property>
        <property name="color" value="红色"></property>
    </bean>
    <!--学生-->
    <!--这儿的小汽车不能用value,用ref引用上面的那个汽车car-->
    <bean id="stu" class="cn.dawn.day02di.Stu">
        <property name="name" value="孟六"></property>
        <property name="age" value="20"></property>
        <property name="car" ref="car"></property>
    </bean>

</beans>

 测试类

package cn.dawn.day02;

import cn.dawn.day02di.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Created by Dawn on 2018/3/3.
 */public class test20180303 {
    @Test
    /*域属性*/
    public void t01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("ApplicationContext-day02.xml");
        Stu stu = (Stu) context.getBean("stu");
        System.out.println(stu.getName()+"开"+stu.getCar().getType());
    }
}

第二个Demo:打印机案例

  项目架构

 1 package cn.dawn.day03printer.ink;
 2 /**
 3  * Created by Dawn on 2018/3/3.
 4  *//*墨盒*/public interface Ink {
 5     public String getInkColor();
 6 }
 7
 8
 9 package cn.dawn.day03printer.ink;
10 /**
11  * Created by Dawn on 2018/3/3.
12  *//*彩色墨盒*/public class ColorInk implements Ink {
13     public String getInkColor() {
14         return "彩色墨盒";
15     }
16 }
17
18
19
20 package cn.dawn.day03printer.ink;
21 /**
22  * Created by Dawn on 2018/3/3.
23  *//*黑白墨盒*/public class BlackInk implements Ink {
24     public String getInkColor() {
25         return "黑白墨盒";
26     }
27 }
28
29
30
31 package cn.dawn.day03printer.paper;
32 /**
33  * Created by Dawn on 2018/3/3.
34  *//*纸张*/public interface Paper {
35     public String getPagerSize();
36 }
37
38
39
40 package cn.dawn.day03printer.paper;
41 /**
42  * Created by Dawn on 2018/3/3.
43  *//*B5纸张*/public class B5Paper implements Paper{
44
45     public String getPagerSize() {
46         return "B5纸";
47     }
48 }
49
50
51
52 package cn.dawn.day03printer.paper;
53 /**
54  * Created by Dawn on 2018/3/3.
55  *//*A4纸张*/public class A4Paper implements Paper {
56     public String getPagerSize() {
57         return "A4纸";
58     }
59 }
60
61
62
63 package cn.dawn.day03printer.printer;
64
65 import cn.dawn.day03printer.ink.Ink;
66 import cn.dawn.day03printer.paper.Paper;
67 /**
68  * Created by Dawn on 2018/3/3.
69  *//*打印机*/public class Printer {
70     /*墨盒*/
71     private Ink ink;
72     /*纸张*/
73     private Paper paper;
74     /*打印方法*/
75     public void print(){
76         System.out.println("我们的喷墨打印机,用"+ink.getInkColor()+"和"+paper.getPagerSize()+"打印出了------》我爱Spring");
77     }
78
79
80     public Ink getInk() {
81         return ink;
82     }
83
84     public void setInk(Ink ink) {
85         this.ink = ink;
86     }
87
88     public Paper getPaper() {
89         return paper;
90     }
91
92     public void setPaper(Paper paper) {
93         this.paper = paper;
94     }
95 }

  配置文件中:

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

    <!--墨盒-->
    <bean id="ink" class="cn.dawn.day03printer.ink.ColorInk"></bean>
    <!--纸张-->
    <bean id="paper" class="cn.dawn.day03printer.paper.A4Paper"></bean>
    <!--打印机-->
    <bean id="printer" class="cn.dawn.day03printer.printer.Printer">
        <property name="ink" ref="ink"></property>
        <property name="paper" ref="paper"></property>
     </bean>
</beans>

  单测方法

package cn.dawn.day03;

import cn.dawn.day02di.Stu;
import cn.dawn.day03printer.printer.Printer;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * Created by Dawn on 2018/3/3.
 */public class test20180303 {
    @Test
    /*打印机案例*/
    public void t01(){
        ApplicationContext context=new ClassPathXmlApplicationContext("ApplicationContext-day03.xml");
        Printer printer = (Printer) context.getBean("printer");
        printer.print();
    }
}

原文地址:https://www.cnblogs.com/wh1520577322/p/9379779.html

时间: 2024-08-30 16:08:41

Spring的DI初步的相关文章

Spring+IOC(DI)+AOP概念及优缺点

Spring pring是一个轻量级的DI和AOP容器框架. 说它轻量级有一大部分原因是相对与EJB的(虽然本人从没有接触过EJB的应用),重要的是,Spring是非侵入式的,基于spring开发的应用一般不依赖于spring的类. 容器:Spring是个容器,因为它包含并且管理应用对象的生命周期和配置.如对象的创建.销毁.回调等. 框架:Spring作为一个框架,提供了一些基础功能,(如事务管理,持久层集成等),使开发人员更专注于开发应用逻辑. Spring的优点1.降低了组件之间的耦合性 ,

Spring -- IOC/DI 基础概念的理解

Spring -- IOC/DI 基础概念 思维导图: ------------------------------------------------------- IoC/DI 的基本概念 IoC是什么 ? IoC -- Inversion of control, 控制反转   在Java开发中,IoC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.IoC是一种让服务消费者不直接依赖于服务提供者的组件设计方式,是一种减少类与类之间依赖的设计原则. 理解IoC的关键是明

[Spring系列01]Spring IOC/DI模拟

本文以一个简单的实例大致模拟Spring IOC/DI的运行原理,代码简单分dao,model,service三层.即:dao 与数据库的操作,增删改查等方法model 一般都是javabean对象,例如与数据库的某个表相关联.service 供外部调用,等于对dao,model等进行了包装. 程序结构图如下: 先粘贴部分代码,再进行解释: UserDAO.java package com.ctsh.dao; import com.ctsh.model.User; public interfac

Spring IOC/DI/注解

一.定义:Spring 是一个开源的控制反转(Inversion of Control,IoC/DI)和面向切面(AOP)的容器框架,它的主要目的是简化企业开发 二.实例化Spring容器: 方法一:在类路径下寻找配置文件来实例化容器 1 ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"}); 方法二:在文件系统路径下寻找配置文件来实例化容器 1 Applicatio

Spring IoC/DI

前言 假设项目层次划分包括logic层和dao层,logic层调用dao层完成业务逻辑,dao层一般与数据库交互.定义两个组件,TestLogic和TestDao,分别操作接口ILogic和IDao,这样程序开发时需要考虑怎样管理这两个组件. 传统方式 这种方式中,当TestLogic组件需要调用TestDao组件时,直接使用关键字new IDao testDao = new TestDao(); 这种方式简单直观,但造成了对外部组件的严重依赖,程序高度耦合,效率低下.当项目需要更换组件时需要修

Spring中di配合接口编程

一:DI基本概念 依赖注入(DI),是spring容器实现的基础,在spring-core模块中实现的.所谓DI,就是指对象是被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖的类,而是在容器实例化对象的时候主动将它依赖的类注入给它. DI作用: di配合接口编程,的确可以减少层(web层) 和 业务层的耦合度. 二:DI配合接口编程案例 1.项目截图 2.基本代码 package com.cloud.inter; public interfaceChangeLetter

spring 之 DI

1. DI:dependency injection:依赖注入.依赖注入和IOC是一件事不同的说法,对象的创建是依赖于容器的,对象属性的设置也是依赖于容器的.程序中被动接收对象,对象的属性值也是被动设置的.这个过程在spring称为注入.所以IOC又叫依赖注入(有容器来创建和管理对象). 2.DI 和 IOC的区别: DI (依赖注入) 更侧重于过程, 把对象通过setter.contruct.args等方式 注入到另一个对象中作为这个对象的一个成员变量(也可能是其他):IOC(控制反转): 侧

Spring特性--DI

DI:Dependency Injection(依赖注入),通俗的讲就是一种通过xml配置文件,为交给sping容器的对象初始化参数.又称做控制反转:Inversion of Control(IoC) 依赖注入主要分为两种形式: |-:基于构造方法的依赖注入 |-:基于setter方法的依赖注入  基于构造方法的依赖注入又可以分为以下几种: ·复杂数据类型: ·简单数据类型: |- 基于属性类型(type) |-基于索引(index) |-基于参数名称(name) 复杂数据类型实例 packag

spring ioc DI 理解

下面是我从网上找来的一些大牛对spring ioc和DI的理解,希望也能让你对Spring ioc和DI的设计思想有更进一步的认识. 一.分享Iteye的开涛对Ioc的精彩讲解 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想.在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们