精华内容
下载资源
问答
我要提问
  • 对人依赖性是什么意思
    万次阅读
    2020-12-27 09:44:31

    什么是物联网？看到这个问题，相信很多人都是蒙圈状态，虽然物联网已经10周年了，但是经过10年的发展，大多数的人都无法说不清楚物联网，说不清物联网到底是什么，更不用说看清物联网的商业模式，自然也就无法界定谁是物联网公司，同时也规划不了物联网的详细未来，那么，到底什么是物联网呢？物联网又有哪些应用场景呢？下面51好项目网小编就来给他家说说物联网概念，同时也给大家普及一下物联网技术有哪些应用场景。

    什么是物联网？

    物联网(The Internet of Things，简称IOT)是指通过 各种信息传感器、射频识别技术、全球定位系统、红外感应器、激光扫描器等各种装置与技术，实时采集任何需要监控、 连接、互动的物体或过程，采集其声、光、热、电、力学、化 学、生物、位置等各种需要的信息，通过各类可能的网络接入，实现物与物、物与人的泛在连接，实现对物品和过程的智能化感知、识别和管理。物联网是一个基于互联网、传统电信网等的信息承载体，它让所有能够被独立寻址的普通物理对象形成互联互通的网络。

    物联网是指通过信息传感设备，按约定的协议，将任何物体与网络相连接，物体通过信息传播媒介进行信息交换和通信，以实现智能化识别、定位、跟踪、监管等功能。

    物联网有哪些应用场景？

    一、智慧物流

    智慧物流指的是以物联网、大数据、人工智能等信息技术为支撑，在物流的运输、仓储、运输、配送等各个环节实现系统感知、全面分析及处理等功能。当前，应用于物联网领域主要体现在三个方面，仓储、运输监测以及快递终端等，通过物联网技术实现对货物的监测以及运输车辆的监测，包括货物车辆位置、状态以及货物温湿度，油耗及车速等，物联网技术的使用能提高运输效率，提升整个物流行业的智能化水平。

    二、智能交通

    智能交通是物联网的一种重要体现形式，利用信息技术将人、车和路紧密的结合起来，改善交通运输环境、保障交通安全以及提高资源利用率。运用物联网技术具体的应用领域，包括智能公交车、共享单车、车联网、充电桩监测、智能红绿灯以及智慧停车等领域。其中，车联网是近些年来各大厂商及互联网企业争相进入的领域。

    三、智能安防

    安防是物联网的一大应用市场，因为安全永远都是人们的一个基本需求。传统安防对人员的依赖性比较大，非常耗费人力，而智能安防能够通过设备实现智能判断。目前，智能安防最核心的部分在于智能安防系统，该系统是对拍摄的图像进行传输与存储，并对其分析与处理。一个完整的智能安防系统主要包括三大部分，门禁、报警和监控，行业中主要以视频监控为主。

    四、智慧能源环保

    智慧能源环保属于智慧城市的一个部分，其物联网应用主要集中在水能，电能，燃气、路灯等能源以及井盖、垃圾桶等环保装置。如智慧井盖监测水位以及其状态、智能水电表实现远程抄表、智能垃圾桶自动感应等。将物联网技术应用于传统的水、电、光能设备进行联网，通过监测，提升利用效率，减少能源损耗。

    五、智能医疗

    在智能医疗领域，新技术的应用必须以人为中心。而物联网技术是数据获取的主要途径，能有效地帮助医院实现对人的智能化管理和对物的智能化管理。对人的智能化管理指的是通过传感器对人的生理状态(如心跳频率、体力消耗、血压高低等)进行监测，主要指的是医疗可穿戴设备，将获取的数据记录到电子健康文件中，方便个人或医生查阅。除此之外，通过RFID技术还能对医疗设备、物品进行监控与管理，实现医疗设备、用品可视化，主要表现为数字化医院。

    六、智慧建筑

    建筑是城市的基石，技术的进步促进了建筑的智能化发展，以物联网等新技术为主的智慧建筑越来越受到人们的关注。当前的智慧建筑主要体现在节能方面，将设备进行感知、传输并实现远程监控，不仅能够节约能源同时也能减少楼宇人员的运维。亿欧智库根据调查，了解到目前智慧建筑主要体现在用电照明、消防监测、智慧电梯、楼宇监测以及运用于古建筑领域的白蚁监测。

    七、智能制造

    智能制造细分概念范围很广，涉及很多行业。制造领域的市场体量巨大，是物联网的一个重要应用领域，主要体现在数字化以及智能化的工厂改造上，包括工厂机械设备监控和工厂的环境监控。通过在设备上加装相应的传感器，使设备厂商可以远程随时随地对设备进行监控、升级和维护等操作，更好的了解产品的使用状况，完成产品全生命周期的信息收集，指导产品设计和售后服务;而厂房的环境主要是采集温湿度、烟感等信息。

    八、智能家居

    智能家居指的是使用不同的方法和设备，来提高人们的生活能力，使家庭变得更舒适、安全和高效。物联网应用于智能家居领域，能够对家居类产品的位置、状态、变化进行监测，分析其变化特征，同时根据人的需要，在一定的程度上进行反馈。智能家居行业发展主要分为三个阶段，单品连接、物物联动和平台集成。其发展的方向是首先是连接智能家居单品，随后走向不同单品之间的联动，最后向智能家居系统平台发展。当前，各个智能家居类企业正在从单品向物物联动的过渡阶段。

    九、智能零售

    行业内将零售按照距离，分为了三种不同的形式：远场零售、中场零售、近场零售，三者分别以电商、商场/超市和便利店/自动售货机为代表。物联网技术可以用于近场和中场零售，且主要应用于近场零售，即无人便利店和自动(无人)售货机。智能零售通过将传统的售货机和便利店进行数字化升级、改造，打造无人零售模式。通过数据分析，并充分运用门店内的客流和活动，为用户提供更好的服务，给商家提供更高的经营效率。

    十、智慧农业

    智慧农业指的是利用物联网、人工智能、大数据等现代信息技术与农业进行深度融合，实现农业生产全过程的信息感知、精准管理和智能控制的一种全新的农业生产方式，可实现农业可视化诊断、远程控制以及灾害预警等功能。物联网应用于农业主要体现在两个方面：即农业种植和畜牧养殖。

    农业种植通过传感器、摄像头和卫星等收集数据，实现农作物数字化和机械装备数字化(主要指的是农机车联网)发展。畜牧养殖指的是利用传统的耳标、可穿戴设备以及摄像头等收集畜禽产品的数据，通过对收集到的数据进行分析，运用算法判断畜禽产品健康状况、喂养情况、位置信息以及发情期预测等，对其进行精准管理。

    什么是物联网？通过以上介绍，相信大家对于什么是物联网这个问题有了一定的了解，虽然物联网近年来的发展已经渐成规模，各国都投入了巨大的人力、物力、财力来进行研究和开发，但是在技术、管理、成本、政策、安全等方面仍然存在许多需要攻克的难题，比如说成本过高，可以说在成本没有达到普遍可以接受的范围内，物联网的发展只能是空谈，如果想要了解更多相关知识，可以关注链切网，链切网小编后期会持续更新相关报道！

    更多相关内容

  • spring的依赖注入是什么意思

     万次阅读 多人点赞 2015-11-22 21:24:33
    依赖注入式什么意思
    Spring 能有效地组织J2EE应用各层的对象。不管 是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大大减少。

    上面所说的一切都得宜于Spring的核心机制， 依赖注入。 依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解 依赖注入

    依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

    不管 是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。在理解 依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实例，被调用者)。

    (1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

    (2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

    (3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的 依赖注入。

    第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

    第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

    第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调用者都处于Spring的管理下，二者之间的 依赖关系由Spring提供。

    所谓 依赖注入， 是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是 依赖于外部的 注入。Spring的 依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间 依赖关系的管理。 依赖注入通常有两种:

    ·设值 注入。

    ·构造 注入。
    设值注入

    　　设值 注入是指通过setter方法传入被调用者的实例。这种 注入方式简单、直观，因而在Spring的 依赖注入里大量使用。看下面代码， 是Person的接口
    //定义Person接口
    public interface Person
    {
    //Person接口里定义一个使用斧子的方法
    public void useAxe();
    }

    然后 是Axe的接口
    //定义Axe接口
    public interface Axe
    {
    //Axe接口里有个砍的方法
    public void chop();
    }

    Person的实现类
    //Chinese实现Person接口

    public class Chinese implements Person
    {
    //面向Axe接口编程，而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //设值注入所需的setter方法
    public void setAxe(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    Axe的第一个实现类
    //Axe的第一个实现类 StoneAxe

    public class StoneAxe implements Axe
    {
    //默认构造器
    public StoneAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "石斧砍柴好慢";
    }
    }

    下面采用Spring的配置文件将Person实例和Axe实例组织在一起。配置文件如下所示:
    ＜!-- 下面是标准的XML文件头 --＞
    ＜?xml version="1.0" encoding="gb2312"?＞
    ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
    "http://www.springframework.org/dtd/spring-beans.dtd"＞
    ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
    ＜!-- Spring配置文件的根元素 --＞
    ＜BEANS＞
    ＜!—定义第一bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
    ＜BEAN class=lee.Chinese id=chinese＞
    ＜!-- property元素用来指定需要容器注入的属性，axe属性需要容器注入此处是设值注入，因此Chinese类必须拥有setAxe方法 --＞
    ＜property name="axe"＞
    ＜!-- 此处将另一个bean的引用注入给chinese bean --＞
    ＜REF local="”stoneAxe”/"＞
    ＜/property＞
    ＜/BEAN＞
    ＜!-- 定义stoneAxe bean --＞
    ＜BEAN class=lee.StoneAxe id=stoneAxe /＞
    ＜/BEANS＞

    从配置文件中，可以看到Spring管理bean的灵巧性。bean与bean之间的 依赖关系放在配置文件里组织，而不是写在代码里。通过配置文件的 指定，Spring能精确地为每个bean 注入属性。因此，配置文件里的bean的class元素，不能仅仅 是接口，而必须 是真正的实现类。

    Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应 的setter方法为程序 注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的 注入。

    每个bean的id属性 是该bean的惟一标识，程序通过id属性访问bean，bean与bean的 依赖关系也通过id属性完成。

    下面看主程序部分:
    public class BeanTest
    {
    //主方法，程序的入口
    public static void main(String[] args)throws Exception
    {
    //因为是独立的应用程序，显式地实例化Spring的上下文。
    ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
    //通过Person bean的id来获取bean实例，面向接口编程，因此
    //此处强制类型转换为接口类型
    Person p = (Person)ctx.getBean("chinese");
    //直接执行Person的userAxe()方法。
    p.useAxe();
    }
    }

    程序的执行结果如下:

    石斧砍柴好慢

    主程序调用Person的useAxe()方法时，该方法的方法体内需要使用Axe的实例，但程序里没有任何地方将特定的Person实例和Axe实 例耦合在一起。或者说，程序里没有为Person实例传入Axe的实例，Axe实例由Spring在运行期间动态 注入。

    Person实例不仅不需要了解Axe实例的具体实现，甚至无须了解Axe的创建过程。程序在运行到需要Axe实例的时候，Spring创建了Axe 实例，然后 注入给需要Axe实例的调用者。Person实例运行到需要Axe实例的地方，自然就产生了Axe实例，用来供Person实例使用。

    调用者不仅无须关心被调用者的实现过程，连工厂定位都可以省略(真是按需分配啊!)。下面也给出使用Ant编译和运行该应用的简单脚本:
    ＜?xml version="1.0"?＞
    ＜!-- 定义编译该项目的基本信息-->
    ＜PROJECT name="spring" default="." basedir="."＞
    ＜!-- 定义编译和运行该项目时所需的库文件 --＞
    ＜PATH id=classpath＞
    ＜!-- 该路径下存放spring.jar和其他第三方类库 --＞
    ＜FILESET dir=../../lib＞
    ＜INCLUDE name="*.jar" /＞
    ＜/FILESET＞
    ＜!-- 同时还需要引用已经编译过的class文件--＞
    ＜PATHELEMENT path="." /＞
    ＜/PATH＞
    ＜!-- 编译全部的java文件--＞
    ＜TARGET description="Compile all source code" name="compile"＞
    ＜!-- 指定编译后的class文件的存放位置 --＞
    ＜JAVAC debug="true" destdir="."＞
    deprecation="false" optimize="false" failοnerrοr="true"＞
    ＜!-- 指定需要编译的源文件的存放位置 --＞
    ＜SRC path="." /＞
    ＜!-- 指定编译这些java文件需要的类库位置--＞
    ＜CLASSPATH refid="classpath" /＞
    ＜/JAVAC＞
    ＜/TARGET＞
    ＜!-- 运行特定的主程序 --＞
    ＜TARGET description="run the main class" name="run" depends="compile"＞
    ＜!-- 指定运行的主程序:lee.BeanTest。--＞
    ＜JAVA failοnerrοr="true" fork="yes" classname="lee.BeanTest"＞
    ＜!-- 指定运行这些java文件需要的类库位置--＞
    ＜CLASSPATH refid="classpath" /＞
    ＜/JAVA＞
    ＜/TARGET＞
    ＜/PROJECT＞

    如果需要改写Axe的实现类。或者说，提供另一个实现类给Person实例使用。Person接口、Chinese类都无须改变。只需提供另一个Axe的实现，然后对配置文件进行简单的修改即可。

    Axe的另一个实现如下:
    //Axe的另一个实现类 SteelAxe
    public class SteelAxe implements Axe
    {
    //默认构造器
    public SteelAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "钢斧砍柴真快";
    }
    }

    然后，修改原来的Spring配置文件，在其中增加如下一行:
    ＜!-- 定义一个steelAxe bean--＞
    ＜BEAN class=lee.SteelAxe id=steelAxe />

    该行重新定义了一个Axe的实现:SteelAxe。然后修改chinese bean的配置，将原来传入stoneAxe的地方改为传入steelAxe。也就是将
    ＜REF local="”stoneAxe”/"＞

    改成
    ＜REF local="”steelAxe”/"＞

    此时再次执行程序，将得到如下结果:

    钢斧砍柴真快

    Person与Axe之间没有任何代码耦合关系，bean与bean之间的 依赖关系由Spring管理。采用setter方法为目标bean 注入属性的方式，称为设值 注入。

    业务对象的更换变得相当简单，对象与对象之间的 依赖关系从代码里分离出来，通过配置文件动态管理。
    构造注入

    　　所谓构造 注入，指通过构造函数来完成 依赖关系的设定，而不是通过setter方法。对前面代码Chinese类做简单的修改，修改后的代码如下:
    //Chinese实现Person接口
    public class Chinese implements Person
    {
    //面向Axe接口编程，而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //构造注入所需的带参数的构造器
    public Chinse(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    此时无须Chinese类里的setAxe方法，构造Person实例时，Spring为Person实例 注入所 依赖的Axe实例。构造 注入的配置文件也需做简单的修改，修改后的配置文件如下:
    ＜!-- 下面是标准的XML文件头 --＞
    ＜xml version="1.0" encoding="gb2312"?＞
    ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
    "http://www.springframework.org/dtd/spring-beans.dtd"＞
    ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
    ＜!-- Spring配置文件的根元素 --＞
    ＜BEANS＞
    ＜!—定义第一个bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
    ＜BEAN class=lee.Chinese id=chinese>
    ＜/BEAN＞
    ＜!-- 定义stoneAxe bean --＞
    ＜BEAN class=lee.SteelAxe id=steelAxe />
    ＜/BEANS＞

    执行效果与使用steelAxe设值 注入时的执行效果完全一样。区别在于:创建Person实例中Axe属性的时机不同——设值 注入是现创建一个默认的bean实例，然后调用对应的构造方法 注入依赖关系。而构造 注入则在创建bean实例时，已经完成了 依赖关系的

    收起
    展开全文

  • 什么是依赖注入

     万次阅读 多人点赞 2018-06-09 17:48:57
    Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大...
    Spring 能有效地组织J2EE应用各层的对象。不管 是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大大减少。

    上面所说的一切都得宜于Spring的核心机制， 依赖 注入。 依赖 注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解 依赖 注入

    依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

    不管 是 依赖 注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。在理解 依赖 注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实例，被调用者)。

    (1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

    (2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

    (3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的 依赖 注入。

    第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

    第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

    第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调用者都处于Spring的管理下，二者之间的 依赖关系由Spring提供。

    所谓 依赖 注入， 是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是 依赖于外部的 注入。Spring的 依赖 注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间 依赖关系的管理。 依赖 注入通常有两种:

    ·设值 注入。

    ·构造 注入。
    设值注入

    　　设值 注入 是指通过setter方法传入被调用者的实例。这种 注入方式简单、直观，因而在Spring的 依赖 注入里大量使用。看下面代码， 是Person的接口
    //定义Person接口
    public interface Person
    {
    //Person接口里定义一个使用斧子的方法
    public void useAxe();
    }

    然后 是Axe的接口
    //定义Axe接口
    public interface Axe
    {
    //Axe接口里有个砍的方法
    public void chop();
    }

    Person的实现类
    //Chinese实现Person接口

    public class Chinese implements Person
    {
    //面向Axe接口编程，而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //设值注入所需的setter方法
    public void setAxe(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    Axe的第一个实现类
    //Axe的第一个实现类 StoneAxe

    public class StoneAxe implements Axe
    {
    //默认构造器
    public StoneAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "石斧砍柴好慢";
    }
    }

    下面采用Spring的配置文件将Person实例和Axe实例组织在一起。配置文件如下所示:
    ＜!-- 下面是标准的XML文件头 --＞
    ＜?xml version="1.0" encoding="gb2312"?＞
    ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
    "http://www.springframework.org/dtd/spring-beans.dtd"＞
    ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
    ＜!-- Spring配置文件的根元素 --＞
    ＜BEANS＞
    ＜!—定义第一bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
    ＜BEAN class=lee.Chinese id=chinese＞
    ＜!-- property元素用来指定需要容器注入的属性，axe属性需要容器注入此处是设值注入，因此Chinese类必须拥有setAxe方法 --＞
    ＜property name="axe"＞
    ＜!-- 此处将另一个bean的引用注入给chinese bean --＞
    ＜REF local="”stoneAxe”/"＞
    ＜/property＞
    ＜/BEAN＞
    ＜!-- 定义stoneAxe bean --＞
    ＜BEAN class=lee.StoneAxe id=stoneAxe /＞
    ＜/BEANS＞

    从配置文件中，可以看到Spring管理bean的灵巧性。bean与bean之间的 依赖关系放在配置文件里组织，而不是写在代码里。通过配置文件的 指定，Spring能精确地为每个bean 注入属性。因此，配置文件里的bean的class元素，不能仅仅 是接口，而必须 是真正的实现类。

    Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应 的setter方法为程序 注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的 注入。

    每个bean的id属性 是该bean的惟一标识，程序通过id属性访问bean，bean与bean的 依赖关系也通过id属性完成。

    下面看主程序部分:
    public class BeanTest
    {
    //主方法，程序的入口
    public static void main(String[] args)throws Exception
    {
    //因为是独立的应用程序，显式地实例化Spring的上下文。
    ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
    //通过Person bean的id来获取bean实例，面向接口编程，因此
    //此处强制类型转换为接口类型
    Person p = (Person)ctx.getBean("chinese");
    //直接执行Person的userAxe()方法。
    p.useAxe();
    }
    }

    程序的执行结果如下:

    石斧砍柴好慢

    主程序调用Person的useAxe()方法时，该方法的方法体内需要使用Axe的实例，但程序里没有任何地方将特定的Person实例和Axe实 例耦合在一起。或者说，程序里没有为Person实例传入Axe的实例，Axe实例由Spring在运行期间动态 注入。

    Person实例不仅不需要了解Axe实例的具体实现，甚至无须了解Axe的创建过程。程序在运行到需要Axe实例的时候，Spring创建了Axe 实例，然后 注入给需要Axe实例的调用者。Person实例运行到需要Axe实例的地方，自然就产生了Axe实例，用来供Person实例使用。

    调用者不仅无须关心被调用者的实现过程，连工厂定位都可以省略(真是按需分配啊!)。下面也给出使用Ant编译和运行该应用的简单脚本:
    ＜?xml version="1.0"?＞
    ＜!-- 定义编译该项目的基本信息-->
    ＜PROJECT name="spring" default="." basedir="."＞
    ＜!-- 定义编译和运行该项目时所需的库文件 --＞
    ＜PATH id=classpath＞
    ＜!-- 该路径下存放spring.jar和其他第三方类库 --＞
    ＜FILESET dir=../../lib＞
    ＜INCLUDE name="*.jar" /＞
    ＜/FILESET＞
    ＜!-- 同时还需要引用已经编译过的class文件--＞
    ＜PATHELEMENT path="." /＞
    ＜/PATH＞
    ＜!-- 编译全部的java文件--＞
    ＜TARGET description="Compile all source code" name="compile"＞
    ＜!-- 指定编译后的class文件的存放位置 --＞
    ＜JAVAC debug="true" destdir="."＞
    deprecation="false" optimize="false" failοnerrοr="true"＞
    ＜!-- 指定需要编译的源文件的存放位置 --＞
    ＜SRC path="." /＞
    ＜!-- 指定编译这些java文件需要的类库位置--＞
    ＜CLASSPATH refid="classpath" /＞
    ＜/JAVAC＞
    ＜/TARGET＞
    ＜!-- 运行特定的主程序 --＞
    ＜TARGET description="run the main class" name="run" depends="compile"＞
    ＜!-- 指定运行的主程序:lee.BeanTest。--＞
    ＜JAVA failοnerrοr="true" fork="yes" classname="lee.BeanTest"＞
    ＜!-- 指定运行这些java文件需要的类库位置--＞
    ＜CLASSPATH refid="classpath" /＞
    ＜/JAVA＞
    ＜/TARGET＞
    ＜/PROJECT＞

    如果需要改写Axe的实现类。或者说，提供另一个实现类给Person实例使用。Person接口、Chinese类都无须改变。只需提供另一个Axe的实现，然后对配置文件进行简单的修改即可。

    Axe的另一个实现如下:
    //Axe的另一个实现类 SteelAxe
    public class SteelAxe implements Axe
    {
    //默认构造器
    public SteelAxe()
    {}
    //实现Axe接口的chop方法
    public String chop()
    {
    return "钢斧砍柴真快";
    }
    }

    然后，修改原来的Spring配置文件，在其中增加如下一行:
    ＜!-- 定义一个steelAxe bean--＞
    ＜BEAN class=lee.SteelAxe id=steelAxe />

    该行重新定义了一个Axe的实现:SteelAxe。然后修改chinese bean的配置，将原来传入stoneAxe的地方改为传入steelAxe。也就是将
    ＜REF local="”stoneAxe”/"＞

    改成
    ＜REF local="”steelAxe”/"＞

    此时再次执行程序，将得到如下结果:

    钢斧砍柴真快

    Person与Axe之间没有任何代码耦合关系，bean与bean之间的 依赖关系由Spring管理。采用setter方法为目标bean 注入属性的方式，称为设值 注入。

    业务对象的更换变得相当简单，对象与对象之间的 依赖关系从代码里分离出来，通过配置文件动态管理。
    构造注入

    　　所谓构造 注入，指通过构造函数来完成 依赖关系的设定，而不是通过setter方法。对前面代码Chinese类做简单的修改，修改后的代码如下:
    //Chinese实现Person接口
    public class Chinese implements Person
    {
    //面向Axe接口编程，而不是具体的实现类
    private Axe axe;
    //默认的构造器
    public Chinese()
    {}
    //构造注入所需的带参数的构造器
    public Chinse(Axe axe)
    {
    this.axe = axe;
    }
    //实现Person接口的useAxe方法
    public void useAxe()
    {
    System.out.println(axe.chop());
    }
    }

    此时无须Chinese类里的setAxe方法，构造Person实例时，Spring为Person实例 注入所 依赖的Axe实例。构造 注入的配置文件也需做简单的修改，修改后的配置文件如下:
    ＜!-- 下面是标准的XML文件头 --＞
    ＜xml version="1.0" encoding="gb2312"?＞
    ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞
    "http://www.springframework.org/dtd/spring-beans.dtd"＞
    ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞
    ＜!-- Spring配置文件的根元素 --＞
    ＜BEANS＞
    ＜!—定义第一个bean，该bean的id是chinese, class指定该bean实例的实现类 --＞
    ＜BEAN class=lee.Chinese id=chinese>
    ＜/BEAN＞
    ＜!-- 定义stoneAxe bean --＞
    ＜BEAN class=lee.SteelAxe id=steelAxe />
    ＜/BEANS＞

    执行效果与使用steelAxe设值 注入时的执行效果完全一样。区别在于:创建Person实例中Axe属性的时机不同——设值 注入 是现创建一个默认的bean实例，然后调用对应的构造方法 注入 依赖关系。而构造 注入则在创建bean实例时，已经完成了 依赖关系的
    收起
    展开全文

  • 总是听到有人说AndroidX，到底什么是AndroidX？

     万次阅读 多人点赞 2019-08-26 08:06:59
    不知从什么时候开始，总是会时不时听到AndroidX这个名词，这难道又是什么新出技术吗？相信有很多朋友也会存在这样的疑惑，那么今天我就来写一篇科普文章，向大学介绍AndroidX的前世今生。 Android系统在刚刚面世的....

    本文同步发表于我的微信公众号，扫一扫文章底部的二维码或在微信搜索 郭霖 即可关注，每个工作日都有文章更新。

    Android技术迭代更新很快，各种新出的技术和名词也是层出不穷。不知从什么时候开始，总是会时不时听到AndroidX这个名词，这难道又是什么新出技术吗？相信有很多朋友也会存在这样的疑惑，那么今天我就来写一篇科普文章，向大家介绍AndroidX的前世今生。

    Android系统在刚刚面世的时候，可能连它的设计者也没有想到它会如此成功，因此也不可能在一开始的时候就将它的API考虑的非常周全。随着Android系统版本不断地迭代更新，每个版本中都会加入很多新的API进去，但是新增的API在老版系统中并不存在，因此这就出现了一个向下兼容的问题。

    举个例子，当Android系统发布到3.0版本的时候，突然意识到了平板电脑的重要性，因此为了让Android可以更好地兼容平板，Android团队在3.0系统（API 11）中加入了Fragment功能。但是Fragment的作用并不只局限于平板，以前的老系统中也想使用这个功能该怎么办？于是Android团队推出了一个鼎鼎大名的Android Support Library，用于提供向下兼容的功能。比如我们每个人都熟知的support-v4库，appcompat-v7库都是属于Android Support Library的，这两个库相信任何做过Android开发的人都使用过。

    但是可能很多人并没有考虑过support-v4库的名字到底是什么意思，这里跟大家解释一下。4在这里指的是Android API版本号，对应的系统版本是1.6。那么support-v4的意思就是这个库中提供的API会向下兼容到Android 1.6系统。它对应的包名如下：

    类似地，appcompat-v7指的是将库中提供的API向下兼容至API 7，也就是Android 2.1系统。它对应的包名如下：

    可以发现，Android Support Library中提供的库，它们的包名都是以android.support.*开头的。

    但是慢慢随着时间的推移，什么1.6、2.1系统早就已经被淘汰了，现在Android官方支持的最低系统版本已经是4.0.1，对应的API版本号是15。support-v4、appcompat-v7库也不再支持那么久远的系统了，但是它们的名字却一直保留了下来，虽然它们现在的实际作用已经对不上当初命名的原因了。

    那么很明显，Android团队也意识到这种命名已经非常不合适了，于是对这些API的架构进行了一次重新的划分，推出了AndroidX。因此，AndroidX本质上其实就是对Android Support Library进行的一次升级，升级内容主要在于以下两个方面。

    第一，包名。之前Android Support Library中的API，它们的包名都是在android.support.*下面的，而AndroidX库中所有API的包名都变成了在androidx.*下面。这是一个很大的变化，意味着以后凡是android.*包下面的API都是随着Android操作系统发布的，而androidx.*包下面的API都是随着扩展库发布的，这些API基本不会依赖于操作系统的具体版本。

    第二，命名规则。吸取了之前命名规则的弊端，AndroidX所有库的命名规则里都不会再包含具体操作系统API的版本号了。比如，像appcompat-v7库，在AndroidX中就变成了appcompat库。

    一个AndroidX完整的依赖库格式如下所示：

    implementation 'androidx.appcompat:appcompat:1.0.2'

    了解了AndroidX是什么之后，现在你应该放轻松了吧？它其实并不是什么全新的东西，而是对Android Support Library的一次升级。因此，AndroidX上手起来也没有任何困难的地方，比如之前你经常使用的RecyclerView、ViewPager等等库，在AndroidX中都会有一个对应的版本，只要改一下包名就可以完全无缝使用，用法方面基本上都没有任何的变化。

    但是有一点需要注意，AndroidX和Android Support Library中的库是非常不建议混合在一起使用的，因为它们可能会产生很多不兼容的问题。最好的做法是，要么全部使用AndroidX中的库，要么全部使用Android Support Library中的库。

    而现在Android团队官方的态度也很明确，未来都会为AndroidX为主，Android Support Library已经不再建议使用，并会慢慢停止维护。另外，从Android Studio 3.4.2开始，我发现新建的项目已经强制勾选使用AndroidX架构了。

    那么对于老项目的迁移应该怎么办呢？由于涉及到了包名的改动，如果从Android Support Library升级到AndroidX需要手动去改每一个文件的包名，那可真得要改死了。为此，Android Studio提供了一个一键迁移的功能，只需要对着你的项目名右击 → Refactor → Migrate to AndroidX，就会弹出如下图所示的窗口。

    这里点击Migrate，Android Studio就会自动检查你项目中所有使用Android Support Library的地方，并将它们全部改成AndroidX中对应的库。另外Android Studio还会将你原来的项目备份成一个zip文件，这样即使迁移之后的代码出现了问题你还可以随时还原回之前的代码。

    好了，关于AndroidX的内容就讲到这里，相信也是解决了不少朋友心中的疑惑。由于这段时间以来一直在努力赶《第一行代码 第3版》的进度，所以原创文章的数量偏少了一些，也请大家见谅。


    关注我的技术公众号，每个工作日都有优质技术文章推送。

    微信扫一扫下方二维码即可关注：

    收起
    展开全文
    AndroidX

  • DeFi中的De是什么意思？这对区块链行业意味着什么？

     千次阅读 2020-02-26 17:55:02
    该系统对所有人开放，无需许可，也不依赖第三方机构来满足金融需求。例如贷款、交易、支付和各类衍生品。 DeFi是利用区块链基础结构的开放金融 。利用区块链，人们可以验证在其上进行的每笔交易，这同时也就带来了...
    收起

  • Spring中的IOC和AOP是什么意思？

     千次阅读 2022-04-20 13:34:23
    (1) Spring是什么？ IOC(控制反转)和AOP(面向方面编程)作为Spring框架的两个核心，很好地实现了解耦合。所以，简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。 spring的基本框架主要...
    收起
    spring java tomcat

  • r语言library什么意思_关于R语言，你需要知道什么？

     千次阅读 2020-10-22 22:10:10
    由于我们采用逐段的直线来近似一条曲线，因此用沿着x轴均匀分散的点比依赖于原始数据点的分散状态要好。第二，由于没有对height值排序，线段不会自动连接相邻的点，而是会在相隔很远的点间来回连接。 图1.3 pch=2的...
    收起

  • SpringBoot基础的依赖说明

     千次阅读 2020-01-05 17:56:46
    SpringBoot基础的依赖说明前言 前言 前阵子，为了赶进度，项目在构建的时候，没有仔细研究相关依赖的特性、用处，而是囫囵吞枣，这边copy一点，那边copy一点，结果被大佬小小的批了一顿，实在不应该，项目再赶，也...
    收起
    demo druid java

  • Web3.0到底是什么？它关我们普通人什么事？

     万次阅读 2022-04-28 17:14:37
    每天都会发一些文字，有个词出现的频率非常高，这就是Web 3.0，每天说来说去，很多朋友还在问我它到底是什么？Web 3.0算是互联网行业里非常受追捧的一个词汇，可以说它是一个属于未来的新行业类别，甚至现在又很多...
    收起

  • 大数据是什么意思？

     万次阅读 2020-04-29 19:18:58
    大数据是指无法在一定时间内用常规软件工具对其内容进行抓取、管理和处理的数据集合。大数据技术，是指从各种各样类型的数据中，快速获得有价值信息的能力。适用于大数据的技术，包括大规模并行处理（MPP）数据库，...
    收起

  • 面试解答系列：什么是Spring的依赖注入？哪些方法进行依赖注入？

     千次阅读 2019-07-31 16:59:11
    Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大...
    收起
    Spring框架 Java 程序员面试

  • ue4主要是做什么用的

     万次阅读 2021-01-14 04:42:41
    它完善的工具套件以及简易的工作流程能够使开发者快速修改或查看成果，对于代码的依赖性很低。而完整公开的源代码则能让使用者自由修改和扩展引擎功能。UE4开发引擎能够通过实时渲染，从NPC、人物角色、道具、AI等等...
    收起
    ue4是什么意思

  • 编程中遇见的“耦合”“耦合度”“低耦合”是什么意思

     千次阅读 2020-03-17 03:11:49
    那么很多人共同开发，你不能所有人都开发一个模块，一个功能，一个文件对吧，是不是要有个分工呢？比如说做一个程序，有人开发数据库方面的东西，有人开发网络方面的东西，有人开发界面方面的东西，这就是分工。 ...
    收起

  • Maven依赖详解

     万次阅读 多人点赞 2018-03-09 08:56:37
    一、依赖 依赖是Maven 中最关键的部分，我们之所以在工程中使用Maven，就是因为它的依赖管理功能。如果我们想要在工程中引入某个jar 包，只需要在pom.xml 中引入其jar 包的坐标即可。比如引入log4j 的依赖： &...
    收起
    maven依赖 项目管理工具

  • 一文讲透Android依赖注入，简洁全面

     千次阅读 2022-02-08 11:08:43
    有很多介绍依赖注入的文章，看完以后觉得好像懂了，又好像没什么收获。我结合自己多年开发经验，在基本原理的基础上，说一些自己的理解和体会，帮助读者理解、应用这一常用的模式工具，提升编程能能力。
    收起
    设计模式 依赖注入 kotlin

  • R中summary输出结果都是什么意思？

     千次阅读 2020-12-08 14:31:18
    summary和summarize是什么意思？summary的意思是： 人物在变化，压抑自己，在雨的离开，风的追求，尽情旁观不要轻易说爱，许下的承诺就是欠下的债！不喊痛，不一定没感觉。adj.总结性的;概括的;概要的;从速从简的;即...
    收起

  • 软件包的依赖性关系定义

     千次阅读 2009-12-10 11:11:00
    ubuntu@ubuntu-desktop:~$ sudo apt-cache depends dpkg-devdpkg-dev 依赖: dpkg 依赖: perl 依赖: perl-modules 依赖: cpio 依赖: bzip2 依赖: lzma 依赖: patch 依赖: make
    收起
    图形 gtk perl

  • 设计模式之----依赖倒置（Dependency inversion principle）的理解

     千次阅读 2021-04-30 17:57:30
    有人会有疑惑，设计原则有什么用呢？设计原则是前辈们总结出来的经验，你可以把它们看作是内功心法。只要你在平常开发中按照设计原则进行编码，假以时日，你编程的功力将会大增。 2.概念 依赖倒置原则的原始定义为...
    收起
    依赖倒置原则

  • 数据库之依赖

     千次阅读 2020-04-16 16:58:54
    依赖前言概念关系模式类型案例依赖带来的问题规范化函数依赖分类1分类2传递函数依赖码案例范式 前言 我曾经考过两次数据库，每次都过了及格线，但是被无情得抹下去了。这次我要考90我看你怎么让我不及格，哼。 概念 ...
    收起
    mysql

  • 什么是自然语言处理（NLP）？定义+应用一次性看个明白

     万次阅读 2019-03-18 11:33:01
    不懂什么是自然语言处理？它在商业智能中又有哪些应用？带着这样的疑问，慧都网将从定义和应用两个方向，通过3分钟的时间快速了解自然语言处理（NLP）。 语言是一项基本的沟通工具。人类使用语言来传递信息和意义...
    收起
    自然语言处理 商业智能 什么是自然语言处理

  • 依赖倒置原则（Dependecy-Inversion Principle）

     千次阅读 2021-03-23 20:12:47
    依赖倒置原则(Dependence Inversion Principle，DIP)的原始定义：高层模块不应该依赖底层模块，两者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。抽象：即抽象类或接口，两者是不能够实例化的。细节：...
    收起

  • 第一、二、三、四方支付平台是什么意思？

     千次阅读 2019-04-26 15:29:44
    第二方支付是依托银行存在的，在我国，国有银行对国家的经济发展起着很大的作用，因此，第二方支付会逐渐从日常生活和小额市场的支付中淡化并推出，转而在一些巨额的交易和政策性的金融活动中发光发热。 第三方...
    收起
    第四方支付平台

  • 路径依赖

     千次阅读 2017-11-05 22:45:37
    路径依赖(Path－Dependence)，又译为路径依赖性，它的特定含义是指人类社会中的技术演进或制度变迁均有类似于物理学中的惯性，即一旦进入某一路径（无论是“好”还是“坏”）就可能对这种路径产生依赖。一旦人们做了...
    收起

  • 浅谈IOC--说清楚IOC是什么

     万次阅读 多人点赞 2018-03-29 16:22:44
    什么是IOC3.IOC也叫依赖注入(DI)4.IOC的优缺点5.IOC容器的技术剖析6.IOC容器的一些产品7.参考博文本文旨在用语言(非代码)说清楚IOC到底是什么，没有什么高深的技术，园中的老牛、大虾们看到这里可以绕行了，以免浪费...
    收起
    依赖倒置原则

  • 19年数学建模

     千次阅读 2019-10-11 17:28:05
    机场的出租车安排与调度对机场至关重要，本文主要运用了排队论、微分模型，并结合了VISSIM仿真，研究司机的最优决策模型和如何设置最优上车点，使得总的乘车效率最高。 针对问题一，我们通过查阅资料，分析研究出了...
    收起

  • 规范化理论：多值依赖

     万次阅读 多人点赞 2019-05-12 21:04:11
    多值依赖的定义 我们用一个例子来引出多值依赖（Multivalued Dependency，MVD）的含义。 假设学校中一门课程可由多名教师讲授，教学中他们使用相同的一套参考书，这样我们可用下图的非规范化的关系来表示课程C、...
    收起
    数据库原理 多值依赖

  • 数据集市是什么？

     千次阅读 2021-08-31 07:48:59
    依赖数据仓库2.2. 独立数据集市2.3. 混合数据集市三、数据集市的特点 一、数据集市简介 在数据仓库环境中用于检索客户端数据的模式称为数据集市。它是数据仓库特有的结构，供团队中的业务领域使用。每个组织都有一...
    收起

  • 面试官：说说什么是 Java 内存模型（JMM）？

     万次阅读 多人点赞 2021-05-05 23:23:20
    1.2. 缓存一致性问题 1.3. 处理器优化和指令重排序 2. 并发编程的问题 3. Java 内存模型 3.1. Java 运行时内存区域与硬件内存的关系 3.2. Java 线程与主内存的关系 3.3. 线程间通信 4. 有态度的总结 在面试中...
    收起

  • 区块链是什么意思？

     万次阅读 2018-05-31 10:52:02
    区块链是分布式数据存储、点对点传输、共识机制、加密算法等计算机技术的新型应用模式。所谓共识机制是区块链系统中实现不同节点之间建立信任、获取权益的数学算法 。　区块链(Blockchain)是比特币的一个重要概念，...
    收起
    区块链核心技术

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 167,965
精华内容 67,186
热门标签
关键字：

对人依赖性是什么意思