精华内容
下载资源
问答
  • 依赖注入的三种方式

    2021-03-16 19:32:37
    依赖注入的三种方式 1. 构造器注入(前边已讲) 2. Set方式注入【重点】 2.1 依赖注入含义 依赖:bean对象的创建依赖于容器 注入:bean对象的所有属性,由容器来注入 2.2 环境搭建 复杂类型 创建引用类型Address ...

    1. 构造器注入(前边已讲)

    2. Set方式注入【重点】

    2.1 依赖注入含义

    1. 依赖:bean对象的创建依赖于容器
    2. 注入:bean对象的所有属性,由容器来注入

    2.2 环境搭建

    1. 复杂类型
      创建引用类型Address
    public class Address {
    
        private String address;
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    }
    
    1. 真实测试对象
      创建类Student
    package com.kuang.pojo;
    
    import lombok.Data;
    import java.util.*;
    
    @Data
    public class Student {
        private String name;
        private Address address;/*引用类型*/
        private String[] books;/*数组类型*/
        private List<String> hobbys;/*集合类型*/
        private Map<String, String> card;
        private Set<String> games;
        private String wife;/*空指针类型,有没有妻子*/
        private Properties info;/*配置类*/
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", address=" + address.toString() +
                    ", books=" + Arrays.toString(books) +
                    ", hobbys=" + hobbys +
                    ", card=" + card +
                    ", games=" + games +
                    ", wife='" + wife + '\'' +
                    ", info=" + info +
                    '}';
        }
    }
    
    
    1. beans.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="student" class="com.kuang.pojo.Student">
            <!--String类型的注入: 使用value-->
            <property name="name" value="星时"></property>
        </bean>
        
    </beans>
    
    1. 测试类
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
            Student student = (Student) context.getBean("student");
            System.out.println(student.getName());
        }
    }
    

    2.3 完善注入

    1. 注入
    <?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="address" class="com.kuang.pojo.Address">
            <property name="address" value="东胜神洲花果山水帘洞"></property>
        </bean>
    
        <bean id="student" class="com.kuang.pojo.Student">
            <!--String注入: 使用value-->
            <property name="name" value="星时"></property>
            <!--bean注入: 使用ref-->
            <property name="address" ref="address"></property>
            <!--数组注入-->
            <property name="books">
                <array>
                    <value>杀死一只知更鸟</value>
                    <value>醒来觉得甚是爱你</value>
                    <value>明朝那些事儿</value>
                </array>
            </property>
            <!--list注入-->
            <property name="hobbies">
                <list>
                    <value>象棋</value>
                    <value>羽毛球</value>
                    <value>跑步</value>
                </list>
            </property>
            <!--map注入-->
            <property name="card">
                <map>
                    <entry key="身份证" value="2394872394382472935482"></entry>
                    <entry key="银行卡" value="4357293854729384752398"></entry>
                    <entry key="饭卡" value="294723945735732854548557"></entry>
                </map>
            </property>
            <!--Set注入-->
            <property name="games">
                <set>
                    <value>王者荣耀</value>
                    <value>和平精英</value>
                    <value>红色警戒</value>
                </set>
            </property>
            <!--null注入-->
            <property name="wife">
                <null/>
            </property>
            <!--properties(配置)注入-->
            <property name="info">
                <props>
                    <prop key="姓名">星时</prop>
                    <prop key="年龄">232</prop>
                    <prop key="智商">250</prop>
                    <prop key="email">23424729@qq.com</prop>
                </props>
            </property>
        </bean>
    </beans>
    
    1. 测试
    public class MyTest {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
            Student student = (Student) context.getBean("student");
            System.out.println(student.toString());
    
            /*运行结果:
            * Student{
            * name='星时',
            * address=Address{address='东胜神洲花果山水帘洞'},
            * books=[杀死一只知更鸟, 醒来觉得甚是爱你, 明朝那些事儿],
            * hobbys=[象棋, 羽毛球, 跑步],
            * card={
            *       身份证=2394872394382472935482,
            *       银行卡=4357293854729384752398,
            *       饭卡=294723945735732854548557
            *       },
            * games=[王者荣耀, 和平精英, 红色警戒],
            * wife='null',
            * info={
            *       智商=250,
            *       email=23424729@qq.com,
            *       姓名=星时,
            *       年龄=232
            *      }
            * }
            * */
        }
    }
    

    3. 拓展方式注入

    3.1 p命名空间注入——主要针对无参构造方法

    1. User类
    @Data
    public class User {
        private String name;
        private int age;
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    1. userBean.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"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--
            xmlns:p="http://www.springframework.org/schema/p":导入p命名空间
            xmlns:c="http://www.springframework.org/schema/c":导入c命名空间
        -->
        <!--p命名空间注入,可以直接注入属性的值: property-->
        <bean id="user" class="com.kuang.pojo.User" p:name="阿飞" p:age="14"/>
    </beans>
    
    1. 测试方法
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("userBean.xml");
        User user = context.getBean("user", User.class);/*第二个参数表示的是user的类型*/
        System.out.println(user.toString());
    }
    
    <!--
        运行结果:
                User{name='阿飞', age=14}
    -->
    

    3.2 c命名空间注入——主要针对有参构造方法

    1. User类(相比上边多了两个构造方法)
    @Data
    public class User {
        private String name;
        private int age;
    
        public User() {
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    
    1. userBean.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"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!--
            xmlns:p="http://www.springframework.org/schema/p":导入p命名空间
            xmlns:c="http://www.springframework.org/schema/c":导入c命名空间
        -->
        <!--p命名空间注入,可以直接注入属性的值: property-->
        <bean id="user" class="com.kuang.pojo.User" p:name="阿飞" p:age="14"/>
    
        <!--c命名空间注入,通过构造器注入: constructs-args-->
        <bean id="user2" class="com.kuang.pojo.User" c:name="星时" c:age="123"/>
    </beans>
    
    1. 测试方法
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("userBean.xml");
        User user = context.getBean("user2", User.class);/*第二个参数表示的是user的类型*/
        System.out.println(user.toString());
    }
    
    <!--
        运行结果:
                User{name='星时', age=123}
    -->
    

    注意:使用p命名空间和c命名空间需要导入约束

    展开全文
  • 主要介绍了Spring依赖注入的三种方式的相关资料,希望通过本文能帮助到大家,让大家理解掌握这部分内容,需要的朋友可以参考下
  • 本篇文章主要介绍了Spring依赖注入的三种方式小结,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • php依赖注入的三种方式

    千次阅读 2019-12-30 17:54:02
    控制反转(Inversion of Control,...下面我们就为大家介绍一下php依赖注入的三种方式。 一、构造器注入  将被依赖对象通过构造函数的参数注入给依赖对象,并且在初始化对象的时候注入。 优点:  对象初始化完...

    控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI)。下面我们就为大家介绍一下php依赖注入的三种方式。

    一、构造器注入

      将被依赖对象通过构造函数的参数注入给依赖对象,并且在初始化对象的时候注入。

    优点:

      对象初始化完成后便可获得可使用的对象。

    缺点:

      ●当需要注入的对象很多时,构造器参数列表将会很长;

      ●不够灵活。若有多种注入方式,每种方式只需注入指定几个依赖,那么就需要提供多个重载的构造函数,麻烦

    二、setter方法注入

      IoC Service Provider通过调用成员变量提供的setter函数将被依赖对象注入给依赖类。

    优点:

      灵活。可以选择性地注入需要的对象。

    缺点:

      依赖对象初始化完成后由于尚未注入被依赖对象,因此还不能使用。

    三、接口注入

      依赖类必须要实现指定的接口,然后实现该接口中的一个函数,该函数就是用于依赖注入。该函数的参数就是要注入的对象。

    优点

      接口注入中,接口的名字、函数的名字都不重要,只要保证函数的参数是要注入的对象类型即可。

    缺点

      侵入行太强,不建议使用。

    PS:什么是侵入行?

      如果类A要使用别人提供的一个功能,若为了使用这功能,需要在自己的类中增加额外的代码,这就是侵入性。

    以上就是php依赖注入的三种方式的详细内容,更多请关注php中文网其它相关文章!

    展开全文
  • spring依赖注入的三种方式以及优缺点 一.依赖注入的三种方式 1.通过构造器注入。(spring4.3之后,推荐使用) 2.通过setter注入。(spring4.3之前,推荐使用) 3通过filed注入。 二.三种方式的代码示例: ...

    spring依赖注入的三种方式以及优缺点

    一.依赖注入的三种方式

    1.通过构造器注入。(spring4.3之后,推荐使用)

    2.通过setter注入。(spring4.3之前,推荐使用)

    3通过filed注入。

    二.三种方式的代码示例:

    Constructor注入

        private AlarmContactService alarmContactService;
    
    	private final AlarmService alarmService;
    
    	private final SysUserService sysUserService;
    
        @Autowired
    	public AlarmContactController(AlarmContactService alarmContactService, AlarmService alarmService,
    			SysUserService sysUserService) {
    		this.alarmContactService = alarmContactService;
    		this.alarmService = alarmService;
    		this.sysUserService = sysUserService;
    	}

    Setter注入

    private AlarmContactService alarmContactService;
    
    	private AlarmService alarmService;
    
    	private SysUserService sysUserService;
    
    	@Autowired
    	public void setAlarmContactService(AlarmContactService alarmContactService) {
    		this.alarmContactService = alarmContactService;
    	}
    
    	@Autowired
    	public void setAlarmService(AlarmService alarmService) {
    		this.alarmService = alarmService;
    	}
    
    	@Autowired
    	public void setSysUserService(SysUserService sysUserService) {
    		this.sysUserService = sysUserService;
    	}

    Field注入

        @Autowired
    	private AlarmContactService alarmContactService;
    
    	@Autowired
    	private AlarmService alarmService;
    
    	@Autowired
    	private SysUserService sysUserService;

    三.3种方式的各优点和缺点

    三种方式的优点分析

    1.基于构造器注入,会固定依赖注入的顺序,不允许我们创建的bean对象之间存在循环依赖关系,这样Spring能解决循环依赖的问题。

    2.基于setter注入,只有对象是需要被注入的时候,才会注入依赖,而不是在初始化的时候就注入。

    3.在成员变量上写上注解来注入,这种方式,精短,可读性高,不需要多余的代码,也方便维护。

    三种方式的缺点分析

    1.使用构造器注入的缺点是,当我们构造器需要注入的对象比较多时,会显得我们的构造器,冗余,不美观,可读性差,也不易维护。

    2.当我们选择setter方法来注入的时候,我们不能将对象设为final的;

    3.当我们在field变量上来实现注入的时候

        a.这样不符合JavaBean的规范,而且很有可能引起空指针;

        b.同时也不能将对象标为final的;

      c.类与DI容器高度耦合,我们不能在外部使用它;

        d.类不通过反射不能被实例化(例如单元测试中),你需要用DI容器去实例化它,这更像集成测试;

     

    来自Spring官方文档的建议:  
    在Spring 3.x 中,Spring团队建议我们使用setter来注入:

    而在Spring 4.x 中,Spring团队不再建议我们使用setter来注入,改为了constructor:

    Spring团队通常建议使用构造器来注入,因为它允许一个应用程序组件实现为不可变对象,并确保所需的依赖项不是空。此外构造器注入组件总是返回一个完全初始化状态的client客户端(调用)。附注,大量的构造函数参数是一个糟糕的代码习惯,看起来也很坏,这意味着类可能有太多的责任,应该被重构,以更好地解决适当的关注点分离。

     

    三.解释下什么是循环依赖:

    1. 循环依赖是什么?

    Bean A 依赖 B,Bean B 依赖 A这种情况下出现循环依赖。

    Bean A → Bean B → Bean A     或者 Bean A → Bean B → BeanC → Bean A

    2. 循环依赖会产生什么结果?

    当Spring正在加载所有Bean时,Spring尝试以能正常创建Bean的顺序去创建Bean。

    例如,有如下依赖:

    Bean A → Bean B → Bean C

    Spring先创建beanC,接着创建bean B(将C注入B中),最后创建bean A(将B注入A中)。

    假如,有如下循环依赖:

    Bean A → Bean B → Bean C → BeanD → Bean A  

     

    但当存在循环依赖时,Spring将无法决定先创建哪个bean。这种情况下,Spring将产生异常BeanCurrentlyInCreationException。

     

    一条Spring 4.3 的新特征:

    在Spring 4.3 以后,如果我们的类中只有单个构造函数,那么Spring就会实现一个隐式的自动注入:

    就是我去掉了构造器上的@Autowired注解,经测试后发现,程序能正常运行。alarmContactService,alarmService,sysUserService的依赖也被成功注入了。

        private AlarmContactService alarmContactService;
    
    	private final AlarmService alarmService;
    
    	private final SysUserService sysUserService;
    
    	public AlarmContactController(AlarmContactService alarmContactService, AlarmService alarmService,
    			SysUserService sysUserService) {
    		this.alarmContactService = alarmContactService;
    		this.alarmService = alarmService;
    		this.sysUserService = sysUserService;
    	}

    使用构造注入允许加入final,这也表示以后不能再被更改了。

     

     

    展开全文
  • 下面我们就为大家介绍一下php依赖注入的三种方式。一、构造器注入将被依赖对象通过构造函数的参数注入给依赖对象,并且在初始化对象的时候注入。优点:对象初始化完成后便可获得可使用的对象...

    8f80b76c2dfff2ef140394c811e3920b.png

    控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI)。下面我们就为大家介绍一下php依赖注入的三种方式。

    一、构造器注入

    将被依赖对象通过构造函数的参数注入给依赖对象,并且在初始化对象的时候注入。

    优点:

    对象初始化完成后便可获得可使用的对象。

    缺点:

    ●当需要注入的对象很多时,构造器参数列表将会很长;

    ●不够灵活。若有多种注入方式,每种方式只需注入指定几个依赖,那么就需要提供多个重载的构造函数,麻烦

    二、setter方法注入

    IoC Service Provider通过调用成员变量提供的setter函数将被依赖对象注入给依赖类。

    优点:

    灵活。可以选择性地注入需要的对象。

    缺点:

    依赖对象初始化完成后由于尚未注入被依赖对象,因此还不能使用。

    三、接口注入

    依赖类必须要实现指定的接口,然后实现该接口中的一个函数,该函数就是用于依赖注入。该函数的参数就是要注入的对象。

    优点

    接口注入中,接口的名字、函数的名字都不重要,只要保证函数的参数是要注入的对象类型即可。

    缺点

    侵入行太强,不建议使用。

    PS:什么是侵入行?

    如果类A要使用别人提供的一个功能,若为了使用这功能,需要在自己的类中增加额外的代码,这就是侵入性。

    展开全文
  • 文章目录Spring学习笔记(四)一、依赖注入的三种方式1.构造器注入2.setter设值注入3.p命名空间的注入 一、依赖注入的三种方式 1.构造器注入   构造器方法注入简单来说就是通过对象的构造方法来进行注入,只要在...
  • 依赖注入的三种方式是构造器注入,setter注入,接口注入,下面就来介绍一下这三种依赖注入。 一、构造器注入 构造器注入依赖于构造方法实现,而构造方法可以是有参数或者无参数的都可以。 构造器注入的实例 实体类 ...
  • Spring IOC(依赖注入的三种方式)

    千次阅读 2018-07-09 16:38:51
    Spring IOC(依赖注入的三种方式):1、Setter方法注入。2、构造方法注入。3、P命名空间注入。Spring IOC(依赖注入的五种不同数据类型):1、注入直接量(基本数据类型、字符串)2、引用其他Bean组件。3、使用内部...
  • 在开发过程中突然对Spring的依赖注入种方式出现混交,打算做个简单小结,方便大家和自己以后参考借鉴,如有总结不对地方,请大家不吝指教!下面来一起看看吧。
  • 依赖注入三种方式:属性注入,构造方法注入,工厂方法注入
  • 一、概述 实际环境中实现IoC容器的方式有两种:一是依赖查找,二是依赖注入。对于spring配置一个bean时,如果...二、依赖注入的三种方式 1.使用属性注入 属性注入即通过setXxx()方法注入Bean的属性值或依赖对...
  • Spring--IOC控制反转与DI依赖注入的三种方式1. setter方法注入2.构造器注入3.接口注入 Spring的核心思想是IOC和AOP,IOC即控制反转,包括依赖注入和依赖查找,最主要使用的即依赖注入DI。通常情况下,我们创建对象时...
  • Java依赖注入的三种方式

    千次阅读 2019-09-10 09:33:46
    Spring通过DI(依赖注入)实现IOC(控制反转),常用注入方式主要有三种:构造方法注入,setter注入,基于注解注入。 构造方法注入 通过Spring配置文件,标签 <constructor-arg ref="" private UserDao ...
  • Spring提出了依赖注入的思想,即依赖不由程序员控制,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。接下来就具体的看看Spring容器依赖的注入的几种方式
  • DI:Dependency Injection(依赖注入) 从字面上分析: IoC:指将对象创建权,反转给了Spring容器; DI :指Spring创建对象过程中,将对象依赖属性(简单...依赖注入三种方式 1.setter注入,(属性注入) 使用se

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,039
精华内容 815
关键字:

依赖注入的三种方式