一个简单的例子,让你理解依赖注入

一.案例描述

1.案例:开发一个打印机程序,模拟打印程序。

2.需求:可以灵活的配置使用彩色墨盒或灰色墨盒。

可以灵活的配置打印页面的大小。

程序中包括打印机(Printer),墨盒(Ink)和纸张(Paper)3类组件。

3.开发步骤:

01.定义Ink和Paper接口。

02.使用Ink接口和Paper接口开发Printer程序,在开发是并不依赖Ink和Paper的实现类。

03.开发Ink接口和Paper接口的实现类:ColorInk,GreyInk和TextPaper。

04.组装打印机,运行调试。

二.开发案例

1.整体架构

2.搭建接口

墨盒接口:Ink

package cn.ink;

/**
 * 墨盒接口
 * @author hyj
 *
 */
public interface Ink {
    /**
     * 定义打印要采用的颜色
     * @param a
     * @param b
     * @param c
     * @return
     */
    public String getColor(int a,int b,int c);
}

纸张接口:Paper

package cn.paper;
/**
 * 纸张接口
 * @author hyj
 *
 */
public interface Paper {
     //用来换行
     public static final String newLine="\r\n";
      /**
       * 输出一个字符到纸张
       * @param c
       */
      public void putInChar(char c);
      /**
       * 得到输出到纸张的内容
       * @return
       */
      public String getContent();
}

3.搭建接口实现类

彩色墨盒Colorink:

package cn.ink;

import java.awt.Color;
/**
 * 彩色墨盒
 * @author hyj
 *
 */
public class Colorink implements Ink{
    @Override
    public String getColor(int a, int b, int c) {
    Color color=new Color(a,b,c);
    return "#"+Integer.toHexString(color.getRGB()).substring(2);
    }
}

灰色墨盒GreyInk:

package cn.ink;

import java.awt.Color;

/**
 * 灰色墨盒
 * @author hyj
 *
 */
public class GreyInk implements Ink{

    @Override
    public String getColor(int a, int b, int c) {
        int d=(a+b+c)/3;
        Color color=new Color(d,d,d);
        return "#"+Integer.toHexString(color.getRGB()).substring(2);
    }

}

纸张接口实现类:TextParper

package cn.paper;

public class TextParper implements Paper {
    //每行字符数
    private int charPerLine=16;
    //每页行数
    private int linePerPage=5;
    //纸张中的内容
    private String content="";
    //当前横向位置,从0到charPerLine-1
    private int posX=0;
    //当前行数,从0到linePerpage-1
    private int posY=0;
    //当前页数
    private int posP=1;

    @Override
    public void putInChar(char c) {
        content+=c;
        ++posX;
        //判断是否换行
        if(posX==charPerLine){
            content+=Paper.newLine;
            posX=0;
            ++posY;
        }
        //判断是否翻页
        if(posY==linePerPage){
            content+="==第"+posP+"页==";
            content+=Paper.newLine+Paper.newLine;
            posY=0;
            ++posP;

        }

    }

    @Override
    public String getContent() {
        String ret=this.content;
        if(!(posX==0&&posY==0)){
            int count=linePerPage-posY;
            for (int i = 0; i <count; i++) {
                ret+=Paper.newLine;
            }
            ret+="==第"+posP+"页==";
        }
        return ret;
    }

    public int getCharPerLine() {
        return charPerLine;
    }

    public void setCharPerLine(int charPerLine) {
        this.charPerLine = charPerLine;
    }

    public int getLinePerPage() {
        return linePerPage;
    }

    public void setLinePerPage(int linePerPage) {
        this.linePerPage = linePerPage;
    }

    public int getPosX() {
        return posX;
    }

    public void setPosX(int posX) {
        this.posX = posX;
    }

    public int getPosY() {
        return posY;
    }

    public void setPosY(int posY) {
        this.posY = posY;
    }

    public int getPosP() {
        return posP;
    }

    public void setPosP(int posP) {
        this.posP = posP;
    }

    public void setContent(String content) {
        this.content = content;
    }

}

4.组装打印机Printer

package cn.test;

import cn.ink.Ink;
import cn.paper.Paper;

/**
 * 打印机
 * @author hyj
 *
 */
public class Printer {
   //墨盒接口
    private Ink ink=null;
     //纸张接口
    private Paper paper=null;
    /**
     * 打印机打印的方法
     * @param str
     */
    public void print(String str){
        System.out.println("使用"+ink.getColor(255, 200, 0)+"颜色打印\n");
        for (int i = 0; i < str.length(); i++) {
            paper.putInChar(str.charAt(i));
        }
        System.out.print(paper.getContent());
    }

    public Ink getInk() {
        return ink;
    }
    public void setInk(Ink ink) {
        this.ink = ink;
    }
    public Paper getPaper() {
        return paper;
    }
    public void setPaper(Paper paper) {
        this.paper = paper;
    }

}

5.书写Spring配置文件:applicationContext.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是colorInk -->
    <bean id="colorInk" class="cn.ink.Colorink"></bean>
    <!-- 定义灰色墨盒bean,id是greyInk -->
   <bean id="greyInk" class="cn.ink.GreyInk"></bean>
   <!-- 定义A4纸张bean,id是A4Paper -->
   <!-- 通过setcharperLine()方法为charPerLine属性注入每行字符数 -->
   <!-- 通过setLinePerpage()方法为linePerpage属性注入每页行数 -->
    <bean id="a4Paper" class="cn.paper.TextParper">
        <property name="charPerLine" value="10"></property>
        <property name="linePerPage" value="8"></property>
    </bean>

   <!-- 定义A5纸张bean,id是A5Paper -->
   <!-- 通过setcharperLine()方法为charPerLine属性注入每行字符数 -->
   <!-- 通过setLinePerpage()方法为linePerpage属性注入每页行数 -->
    <bean id="a5Paper" class="cn.paper.TextParper">
        <property name="charPerLine" value="8"></property>
        <property name="linePerPage" value="5"></property>
    </bean>

    <!-- 组装打印机,定义打印机的bean,该bean的id是printer -->
    <bean id="printer" class="cn.test.Printer">
       <!-- 通过ref属性注入已经定义好的bean -->
        <!-- 注入彩色墨盒 -->
          <property name="ink" ref="colorInk"></property>
        <!-- 注入a5打印纸 -->
        <property name="paper" ref="a5Paper"></property>
    </bean>

</beans>
        

6.测试类

package cn.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试类
 * @author hyj
 *
 */
public class Test {
  public static void main(String[] args) {
      ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
      //通过Printer bean的id来获取Printer实例
      Printer printer = (Printer)context.getBean("printer");
      String content="就是一个傻帽,在问另一群傻帽最好笑的笑话是傻帽,然后一个不傻帽的人来回答说:就是一个傻帽,在问另一群傻帽最好笑的笑话是傻帽!!!";
      printer.print(content);
  }
}
时间: 2024-11-08 17:05:40

一个简单的例子,让你理解依赖注入的相关文章

一个简单例子带你理解 依赖注入

刚出来工作就遇到了一个棘手的问题:依赖注入 公司的软件需求更新频率较高,所以前辈们为了满足需求,方便更新,就用到了依赖注入这个东西. 在之前都没有听说过那个东西,所以一开始简直是蒙了,然后各种百度,发现依赖注入这个东西还是个热门话题! 可是热门不代表自己能好理解,网上的好文章很多,可是自己慧根不够,看着看着就晕了. 不过文章大豆提到了一个东西  反射  .完了,又是一个没听说过的名字(博主自学开发,可能软件专业的会提到). 于是接着各种百度  反射 ,大概了解了什么叫做 反射.可是这个时候又开始

关于apriori算法的一个简单的例子

apriori算法是关联规则挖掘中很基础也很经典的一个算法,我认为很多教程出现大堆的公式不是很适合一个初学者理解.因此,本文列举一个简单的例子来演示下apriori算法的整个步骤. 下面这个表格是代表一个事务数据库D,其中最小支持度为50%,最小置信度为70%,求事务数据库中的频繁关联规则. Tid 项目集 1  面包,牛奶,啤酒,尿布 2  面包,牛奶,啤酒 3  啤酒,尿布 4  面包,牛奶,花生 apriori算法的步骤如下所示: (1)生成候选频繁1-项目集C1={{面包},{牛奶},{

一个简单的例子让你了解React-Redux

"-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> 一个简单的例子让你了解React-Redux - 小平果的欢乐谷 - 博客频道 - CSDN.NET 小平果的欢乐谷 你的到来会让我很意外,谢谢光临! 目录视图 摘要视图 订阅 [活动]2017 CSDN博客专栏评选 &nbsp [5月书讯]流畅的Python,终于等

一个简单的例子搞懂ES6之Promise

ES5中实现异步的常见方式不外乎以下几种: 1. 回调函数 2. 事件驱动 2. 自定义事件(根本上原理同事件驱动相同) 而ES6中的Promise的出现就使得异步变得非常简单.promise中的异步是这样的: * 每当我需要执行一次异步操作的时候,我都需要new一个promise对象 * 每一个异步操作的Promise对象都需要设定一个成功执行的条件和成功的回调.一个失败的条件和失败的回调 * Promise对象可通过执行then()方法获得成功的回调信息 * Promise对象可通过执行ca

Android Handler的一个简单使用例子

在前面 开启一个线程Thread并用进度条显示进度 这篇文章里,我们用线程实现了这么一个简单的功能,就是点击按钮,加载进度条.但是有没有发现,点击一次之后,再次点击就会没效.我们可是需要每次点击都要显示下一张图片的.永盈会娱乐城 这里就需要引入 Android 的消息机制了,简单来说,就是 Handler.Looper 还有 Message Queue的使用.这里我们用一个简单的例子来说明 Handler 的使用,就是每次点击按钮,给消息队列发送一个数字 5.还是在 PaintingActivi

【Python】一个简单的例子

问题描述: Python基础篇 参考资料: (1)http://www.cnblogs.com/octobershiner/archive/2012/12/04/2801670.html (2)http://www.cnblogs.com/itech/archive/2010/06/20/1760345.html 例子: 求解Fibonacci glb_var.py gl_count=1 path.py # coding:utf-8 ''' Created on 2014-4-28 @autho

Linux内核中的信号机制--一个简单的例子【转】

本文转载自:http://blog.csdn.net/ce123_zhouwei/article/details/8562958 Linux内核中的信号机制--一个简单的例子 Author:ce123(http://blog.csdn.NET/ce123) 信号机制是类UNIX系统中的一种重要的进程间通信手段之一.我们经常使用信号来向一个进程发送一个简短的消息.例如:假设我们启动一个进程通过socket读取远程主机发送过来的网络数据包,此时由于网络因素当前主机还没有收到相应的数据,当前进程被设置

duilib DirectUI库里面的一个简单的例子RichListDemo

http://blog.csdn.net/zengraoli/article/details/9993153 2013-08-16 00:08 3289人阅读 评论(2) 收藏 举报 目录(?)[+] 1.首先来看这里的CRichListWnd 已经不再是从CWindowWnd继承了 classCRichListWnd:publicWindowImplBase 从WindowImplBase中,可以看到有三个抽象函数: virtualCDuiStringGetSkinFolder()=0; vi

理解依赖注入(IOC)和学习Unity

IOC:英文全称:Inversion of Control,中文名称:控制反转,它还有个名字叫依赖注入(Dependency Injection). 作用:将各层的对象以松耦合的方式组织在一起,解耦,各层对象的调用完全面向接口.当系统重构的时候,代码的改写量将大大减少. 理解依赖注入: 当一个类的实例需要另一个类的实例协助时,在传统的程序设计过程中,通常有调用者来创建被调用者的实例.然而采用依赖注入的方式,创建被调用者的工作不再由调用者来完成,因此叫控制反转,创建被调用者的实例的工作由IOC容器

【转】理解依赖注入(IOC)和学习Unity

IOC:英文全称:Inversion of Control,中文名称:控制反转,它还有个名字叫依赖注入(Dependency Injection).作用:将各层的对象以松耦合的方式组织在一起,解耦,各层对象的调用完全面向接口.当系统重构的时候,代码的改写量将大大减少.理解依赖注入:    当一个类的实例需要另一个类的实例协助时,在传统的程序设计过程中,通常有调用者来创建被调用者的实例.然而采用依赖注入的方式,创建被调用者的工作不再由调用者来完成,因此叫控制反转,创建被调用者的实例的工作由IOC容