精华内容
下载资源
问答
  • Spring属性注入方式详解(附源码剖析)
    千次阅读
    2020-02-10 18:51:25

    一、什么是Spring属性注入

    在Java中,万物皆对象,属性注入就是在实例化对象时,同时向对象中的属性进行相应的赋值。通俗点说,属性注入就是给类中的属性赋值。

    二、属性注入的几种方式

    对于类成员变量来说,注入方式有三种:
    1.setter方式注入
    2.构造函数注入
    3.接口注入

    对于Spring来说,Spring支持前面两种,并且还支持:
    1.p名称空间注入
    2.spel属性注入
    3.复杂类型注入

    三、属性注入举例

    第一种:setter方式注入
    1.创建一个SpringBoot项目
    2.编写一个Book.java类,如下:

    package com.mango.properties;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @Component
    /*@PropertySource("classpath:book.properties")*/
    public class Book {
    
        @Value("${book.id}")
        private long id;
        @Value("${book.name}")
        private String name;
        @Value("${book.author}")
        private String author;
    
        @Override
        public String toString() {
            return "Book{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", author='" + author + '\'' +
                    '}';
        }
    
        public long getId() {
            return id;
        }
    
        public void setId(long id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    }
    

    3.在创建SpringBoot项目时自动生成的application.properties中添加如下内容:

    book.id=1
    book.name=三国演义
    book.author=罗贯中
    

    4.编写测试类PropertiesApplicationTests.java,如下:

    package com.mango.properties;
    
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class PropertiesApplicationTests {
    
        @Autowired
        Book book;
    
        @Test
        void contextLoads() {
            System.err.println(book);
        }
    
    }
    

    5.运行结果:

    Book{id=1, name='三国演义', author='罗贯中'}
    

    注意事项:
    1.若使用自己创建的xxx.properties文件进行上述方式进行属性注入(注入内容与上述第3步相同),需要在Book.java上进行添加如下注解:

    @PropertySource("classpath:book.properties")
    

    注:此注解就是指定自己创建的xxx.properties文件

    完整代码如下所示:

    package com.mango.properties;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
    @Component
    @PropertySource("classpath:book.properties")
    public class Book {
    
        @Value("${book.id}")
        private long id;
        @Value("${book.name}")
        private String name;
        @Value("${book.author}")
        private String author;
    
        @Override
        public String toString() {
            return "Book{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", author='" + author + '\'' +
                    '}';
        }
    
        public long getId() {
            return id;
        }
    
        public void setId(long id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    }
    
    更多相关内容
  • Spring属性注入

    2014-04-12 22:25:36
    Spring属性注入:关于Spring的属性注入一共有两种方式,分别为XML方式与注解方式,其中XML方式又分为Set注入与构造方法注入,注解方式分为java注解与Spring注解
  • Spring属性注入的三种方式(超详细)

    千次阅读 多人点赞 2021-01-15 23:07:21
    属性注入的三种方式使用set方法进行注入使用有参构造函数进行注入使用p名称空间注入 首先了解下面两个名词的含义: IOC:控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来...

    首先了解下面两个名词的含义:

    IOC:控制反转(Inversion of Control,缩写为IoC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称DI)。通过控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说,依赖被注入到对象中。

    DI:依赖注入(Dependency Injection,简称DI),就是注入属性。是Spring框架的核心之一。所谓依赖注入,是指程序运行过程中,如果需要调用另一个对象协助时,无须在代码中创建被调用者,而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理。

    DI是IOC中的一种具体实现。

    使用set方法进行注入

    Book类:

    package com.Keafmd.spring5;
    
    /**
     * Keafmd
     *
     * @ClassName: Book
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 21:46
     */
    
    /**
     * 演示使用set方法进行注入属性
     */
    public class Book {
    
    	//创建属性
        private  String bname;
        private String bauthor;
        private String address;
    
        //1、set方法注入
        //创建对应的set方法
        public void setBname(String bname) {
            this.bname = bname;
        }
    
        public void setBauthor(String bauthor) {
            this.bauthor = bauthor;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public void testdemo(){
            System.out.println(bname+" "+bauthor+" "+address);
        }
    
    }
    

    bean1.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">
    
        <!-- 一、set方法注入属性-->
        
        <!-- 1、配置对象的创建-->
        <bean id="book" class="com.Keafmd.spring5.Book">
    
            <!-- 2、使用property完成属性注入
                name:类里面的属性名称
                value:向属性中注入的值
            -->
            <property name="bname" value="书名"></property>
            <property name="bauthor" value="作者"></property>
    
            <!--  向属性注入null值-->
            <!--<property name="address" >
                <null/>
            </property>-->
    
            <!--属性值包含特殊符号
                1.把<>进行转义
                2.把带特殊符号的内容写到CDATA
            -->
            
    		<!-- <property name="address" value="&lt;&lt;北京&gt;&gt;"></property> -->
    
            <property name="address">
                <value><![CDATA[<<北京>>]]></value>
            </property>
        </bean>
    
    </beans>
    

    测试代码:

    package com.Keafmd.spring5.testdemo;
    
    import com.Keafmd.spring5.Book;
    import com.Keafmd.spring5.Orders;
    import com.Keafmd.spring5.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestSpring5
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 20:06
     */
    public class TestSpring5 {
    
        @Test
        public  void testBook(){
    
            //1、载Spring的配置文件
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
    
            //2、获取配置文件中创建的对象  默认是执行无参的构造方法创建
            Book book =applicationContext.getBean("book", Book.class);
            book.testdemo();
        }
    
    }
    

    输出结果:

    书名 作者 <<北京>>
    
    Process finished with exit code 0
    

    使用有参构造函数进行注入

    Orders类:

    package com.Keafmd.spring5;
    
    /**
     * Keafmd
     *
     * @ClassName: Orders
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 22:05
     */
    
    /**
     * 使用有参构造注入
     */
    public class Orders {
        private String oname;
        private String address;
    
        public Orders(String oname, String address) {
            this.oname = oname;
            this.address = address;
        }
    
        public void ordersTest(){
            System.out.println(oname+" "+address);
        }
    }
    

    bean1.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="orders" class="com.Keafmd.spring5.Orders">
            <constructor-arg name="oname" value="电脑"/>
            <constructor-arg name="address" value="China"/>
        </bean>
    
    </beans>
    

    测试代码:

    package com.Keafmd.spring5.testdemo;
    
    import com.Keafmd.spring5.Book;
    import com.Keafmd.spring5.Orders;
    import com.Keafmd.spring5.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestSpring5
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 20:06
     */
    public class TestSpring5 {
    
        @Test
        public  void testOrders(){
    
            //1、载Spring的配置文件
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
    
            //2、获取配置文件中创建的对象  默认是执行无参的构造方法创建
            Orders orders =applicationContext.getBean("orders", Orders.class);
            orders.ordersTest();
        }
    }
    

    输出结果:

    电脑 China
    
    Process finished with exit code 0
    

    使用p名称空间注入

    第一步:添加p名称空间xmlns:p="http://www.springframework.org/schema/p"
    第二步:进行属性注入,在bean标签里。

    Book类:

    package com.Keafmd.spring5;
    
    /**
     * Keafmd
     *
     * @ClassName: Book
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 21:46
     */
    
    /**
     * 演示使用p名称空间注入属性
     */
    public class Book {
    
        private  String bname;
        private String bauthor;
        private String address;
    
    
        //3、p名称空间注入
        public void setBname(String bname) {
            this.bname = bname;
        }
    
        public void setBauthor(String bauthor) {
            this.bauthor = bauthor;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public void testdemo(){
            System.out.println(bname+" "+bauthor+" "+address);
        }
    
    }
    

    bean1.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <!--三、p名称空间注入属性-->
    
        <bean id="book" class="com.Keafmd.spring5.Book" p:bname="书名XXX" p:bauthor="作者XXX" p:address="地址XXX">
        </bean>
    
    </beans>
    

    测试代码:

    package com.Keafmd.spring5.testdemo;
    
    import com.Keafmd.spring5.Book;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * Keafmd
     *
     * @ClassName: TestSpring5
     * @Description:
     * @author: 牛哄哄的柯南
     * @date: 2021-01-14 20:06
     */
    public class TestSpring5 {
    
        @Test
        public  void testBook(){
    
            //1、载Spring的配置文件
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean1.xml");
    
            //2、获取配置文件中创建的对象  默认是执行无参的构造方法创建
            Book book =applicationContext.getBean("book", Book.class);
            book.testdemo();
        }
    
    }
    

    输出结果:

    书名XXX 作者XXX 地址XXX
    
    Process finished with exit code 0
    

    以上就是Spring属性注入的三种方式。

    看完如果对你有帮助,感谢点赞支持!
    如果你是电脑端的话,看到右下角的 “一键三连” 了吗,没错点它[哈哈]

    在这里插入图片描述

    加油!

    共同努力!

    Keafmd

    展开全文
  • Spring属性注入(四种)

    千次阅读 2018-08-02 21:24:00
    Spring属性注入有四种方式,分别为set方法注入、构造函数注入、p名称空间注入、spel注入,前两种为主要的注入方式。 源码 一、set方法注入(最重要) 配置好jar包后先看看项目的框架: 实体类User.java(属性的set...

    Spring属性注入有四种方式,分别为set方法注入构造函数注入、p名称空间注入、spel注入,前两种为主要的注入方式。 源码

    一、set方法注入(最重要)

    配置好jar包后先看看项目的框架:

    实体类User.java(属性的set方法要写):

    package com.rr.bean;
     
    public class User {
    	private String name;
    	private Integer age;
     
    	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;
    	}
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + "]";
    	}
    	
    	  
    }

    配置文件applicationContext.xml(property标签中name属性对应实体类的字段名,value属性表示注入的值):

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">
    	
    	<!-- set方式注入 -->
    	<bean name="user" class="com.rr.bean.User">
    		<property name="name" value="tom"></property>
    		<property name="age" value="20"></property>
    	</bean>
    </beans>

    测试代码段:

    package com.rr.test;
     
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.AbstractApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
     
    import com.rr.bean.User;
     
    public class JunitTest {
    	
    	@Test
    	public void fun1() {
    		// 1.创建容器对象, 类路径xml
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		
    		// 2.向容器要User对象
    		 User user = (User)ac.getBean("user");
    		
    		// 3.打印User对象
    		System.out.println(user);
    	}
    	
    	
    }

    运行结果1:

    如果一个User对象还依赖一个Car对象,让“用户拥有车”,需要做如下改动:

    项目结构:

    bean包下新建Car类:

    package com.rr.bean;
     
    public class Car {
    	private String name;
    	private String color;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getColor() {
    		return color;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	@Override
    	public String toString() {
    		return "Car [name=" + name + ", color=" + color + "]";
    	}
    	
    	
    }

    User类添加Car属性并重新生成toString()方法:

    package com.rr.bean;
     
    public class User {
    	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;
    	}
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + ", car=" + car + "]";
    	}
    	
        
    }

    spring配置文件applicationContext.xml, 值类型用value,引用类型用ref:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">
    	<!-- set方式注入 -->
    	<bean name="user" class="com.rr.bean.User">
    		<!-- 值类型注入:为User对象中名为name的属性注入tom作为值 -->
    		<property name="name" value="tom"></property>
    		<property name="age" value="20"></property>
    		<!-- 引用类型注入:②为car属性注入下方配置的car对象  value要和①中的对象name一致-->
    		<property name="car" ref="car"></property>
    	</bean>
    	
    	<!-- ①将car对象配置到容器中  -->
    	<bean name="car" class="com.rr.bean.Car">
    		<property name="name" value="Porsche"></property>
    		<property name="color" value="pink"></property>
    	</bean>
    </beans>

    运行刚才的测试方法,运行结果二:

    二、构造函数注入:

    修改之前的User类,添加两个构造方法(无参的那个方法主要是为了不影响前面的set注入):

    	public User() {
    		
    	}
    	public User(String name, Car car) {
    		System.out.println("User constructor with 2 parameter method called!");
    		this.name = name;
    		this.car = car;
    	}

    applicationContext.xml文件新增bean元素(constructor-arg属性用于注入构造函数):

           <bean name="user2" class="com.rr.bean.User">
    	   <constructor-arg name="name" value="Tony"></constructor-arg>
    	   <constructor-arg name="car" ref="car"></constructor-arg>
    	</bean>

    测试类中新添测试方法二:

    	@Test
    	public void fun2() {
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		User user = (User)ac.getBean("user2");
    		System.out.println(user);
    	}

    测试结果(在构造函数中没有初始化age字段,所以为null值):

    三、p名称空间注入

    ①修改配置文件applicationContext.xml的约束(中间部分省略):

    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:p ="http://www.springframework.org/schema/p" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">
    <!-- ... -->
    </beans>

    ②以p名称空间方式新建bean:

    <bean name="user3" class="com.rr.bean.User" p:name="Jack" p:age="20" p:car-ref="car" >
    	</bean>

    ③添加测试方法:

    	@Test
    	public void fun3() {
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		User user = (User)ac.getBean("user3");
    		System.out.println(user);
    	}

    运行结果:

    四、SPEL(Spring Expression Language)注入:

    配置文件中加入(这里取到了之前注入对象的值类型的值,不能取引用类型的值):

            <bean name="user4" class="com.rr.bean.User" >
            	<property name="name" value="#{user.name}"></property>
            	<property name="age" value="#{user3.age}"></property>
            	<property name="car" ref="car"></property>
            </bean>
     

    测试方法:

    	@Test
    	public void fun4() {
    		ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    		User user = (User)ac.getBean("user4");
    		System.out.println(user);
    	}

    运行结果:

     

     

    @转载,侵删。 

    展开全文
  • 主要介绍了Spring属性注入的几种方式以及复杂属性的注入详解,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 关于spring属性注入和构造函数注入

    千次阅读 2018-12-14 15:10:03
    本文只关注属性注入与构造函数注入,其他注入方式不涉及。 相关类代码: //测试Bean对象 package com.example.demo; public class BeanVO { private Integer beanField; public Integer getBeanField() { ...

    本文只关注属性注入与构造函数注入,其他注入方式不涉及。

    相关类代码:

    //测试Bean对象
    package com.example.demo;
    
    public class BeanVO {
    
        private Integer beanField;
    
        public Integer getBeanField() {
            return beanField;
        }
    
        public void setBeanField(Integer beanField) {
            this.beanField = beanField;
        }
    }
    
    //在系统中配置bean
    package com.example.demo;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class BeanConfig {
    
        @Bean
        public BeanVO testBean() {
            BeanVO testBean = new BeanVO();
            testBean.setBeanField(5);
            return testBean;
        }
    }
    //构造函数注入
    package com.example.demo.injection;
    
    import com.example.demo.BeanVO;
    import org.springframework.stereotype.Component;
    
    @Component
    public class ConstructInjectBean {
    
        //字段注入已不推荐
        private BeanVO beanVO;
    
        //只有一个参数时构造函数中可以加autowire注解,不加也可以
        public ConstructInjectBean(BeanVO beanVO) {
            this.beanVO = beanVO;
        }
    
        public BeanVO getBeanVO() {
            return beanVO;
        }
    }
    
    //属性注入
    package com.example.demo.injection;
    
    import com.example.demo.BeanVO;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SetInjectBean {
    
        private BeanVO beanVO;
    
        //与方法名无关,这里特意未用setBeanVO方法名
        @Autowired
        public void set111BeanVO(BeanVO beanVO) {
            this.beanVO = beanVO;
        }
    
        public BeanVO getBeanVO() {
            return beanVO;
        }
    }
    

    测试代码如下:

    //测试两种注入方式
    package com.example.demo;
    
    import com.example.demo.injection.ConstructInjectBean;
    import com.example.demo.injection.SetInjectBean;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import static org.junit.Assert.assertEquals;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class DemoApplicationTests {
    
        //test类中可以使用字段注入或属性注入,但不支持构造函数注入(测试类不允许重载构造函数)
        @Autowired
        private ConstructInjectBean constructInjectBean;
    
        @Autowired
        private SetInjectBean setInjectBean;
    
        @Test
        public void testConstructInject() {
            assertEquals((long) constructInjectBean.getBeanVO().getBeanField(), 5);
        }
    
        @Test
        public void testPropertyInject() {
            assertEquals((long) setInjectBean.getBeanVO().getBeanField(), 5);
        }
    }
    

    测试结果:

    已上两种注入方式均已生效且结果正确。

    已上两种方式均正确的前提是ConstructInjectBean类与SetInjectBean类均被@Component注解修饰,如果这两个类本身不是bean的话,bean注入无法实现。

    针对上面这段话,看以下例子:

    //去掉component注解修饰的构造函数注入示例
    package com.example.demo.inherit;
    
    import com.example.demo.BeanVO;
    
    public class ParentConstructInjectBean {
    
        private BeanVO beanVO;
    
        public ParentConstructInjectBean(BeanVO beanVO) {
            this.beanVO = beanVO;
        }
    
        public BeanVO getBeanVO() {
            return beanVO;
        }
    }
    
    //一个正常的bean继承上面的非bean类
    package com.example.demo.inherit;
    
    import com.example.demo.BeanVO;
    import org.springframework.stereotype.Component;
    
    @Component
    public class NormalBean extends ParentConstructInjectBean {
    
        private BeanVO beanVO;
    
        public NormalBean(BeanVO beanVO) {
            super(beanVO);
            this.beanVO = beanVO;
        }
    
        //重写get方法
        public BeanVO getBeanVO() {
            beanVO = new BeanVO();
            beanVO.setBeanField(10);
            return beanVO;
        }
    }
    

    测试代码:

    package com.example.demo;
    
    import com.example.demo.inherit.ParentConstructInjectBean;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import static org.junit.Assert.assertEquals;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class DemoApplicationTests {
    
        @Autowired
        private ParentConstructInjectBean parentConstructInjectBean;
    
        @Test
        public void testInheritInject() {
            assertEquals((long) parentConstructInjectBean.getBeanVO().getBeanField(), 10);
        }
    }

    测试结果:

    测试通过,但此时 ParentConstructInjectBean类依然不是一个bean,测试类中注入的其实是ParentConstructInjectBean类的子类NormalBean,这里可以参考接口注入时其实注入的是接口实现类原理,测试方法testInheritInject中值等于10证明了一点。

    以上论述说明非bean类无法通过继承而成为bean类,也无法为非bean类注入。

    上段结论对于属性注入同样成立(测试代码及结果不变),其他相关代码如下:

    //不带comonent注解的属性注入示例
    package com.example.demo.inherit;
    
    import com.example.demo.BeanVO;
    import org.springframework.beans.factory.annotation.Autowired;
    
    public class ParentSetInjectBean {
    
        private BeanVO beanVO;
    
        //这里的autowire能成功不是因为这个类是bean,而是这个方法会被子类使用,而子类是bean
        //父类接口方法的注解会被继承类继承
        @Autowired
        public void set111BeanVO(BeanVO beanVO) {
            this.beanVO = beanVO;
        }
    
        public BeanVO getBeanVO() {
            return beanVO;
        }
    }
    
    package com.example.demo.inherit;
    
    import com.example.demo.BeanVO;
    import org.springframework.stereotype.Component;
    
    @Component
    public class NormalBean extends ParentSetInjectBean {
    
        //重写get方法
        public BeanVO getBeanVO() {
            BeanVO beanVO = super.getBeanVO(); //这里bean的值是5,注入成功
            beanVO.setBeanField(10);
            return beanVO;
        }
    }

     

    展开全文
  • Spring注解注入属性

    2013-07-26 10:11:04
    Spring注解注入属性
  • Spring可以通过set方法的方式实现属性注入1.需要进行属性注入的类package com.maty.property; /** * @author maty e-mail:512181558@qq.com * @version 创建时间:2018年5月16日 下午3:04:58 * 类说明 该类为有...
  • 主要介绍了Spring不能注入Static变量的原因及Spring注入静态变量,需要的朋友可以参考下
  • Spring属性注入之set方法注入对象

    千次阅读 2018-05-16 15:59:41
    name属性值为需要被注入的Dao的实例名称 ref属性值为对应的bean的id值 --> <property name="dao" ref="dao"></property> 3.测试类的编写 import org.springframework.context.ApplicationContext; ...
  • Spring属性注入的两种方式

    千次阅读 2014-04-12 18:49:36
    关于Spring属性注入一共有两种方式,分别为XML方式与注解方式,其中XML方式又分为Set注入与构造方法注入,注解方式分为java注解与Spring注解。根据需要新建java project,项目结构与源代码如下:(可以通过本文...
  • 本篇文章主要介绍了Spring boot将配置属性注入到bean类中,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Spring属性注入Bean的List属性

    千次阅读 2016-09-20 18:27:06
    属性文件:client.valid.version=1.2,1.1XML配置:<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="systemPropertiesModeName" value="SY
  • -- 构造函数注入 --> < bean name = " user " class = " cn.itcast.bean.User " > <!-- name属性: 构造函数的参数名 --> <!-- index属性: 构造函数的参数索引 --> <!-- type属性: 构造函数的参数...
  • 主要为大家详细介绍了Spring boot工具类静态属性注入,及多环境配置详解,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本篇文章主要介绍了详解Spring通过@Value注解注入属性的几种方式,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • 主要介绍了Spring Bean的属性注入方式的相关资料,需要的朋友可以参考下
  • spring属性注入和构造器注入

    千次阅读 2017-11-19 22:19:12
    spring在向IOC容器中注入Bean的时候,有三种注入方式: ...一、属性注入1、创建一个car类,作为注入的beanpackage com.lzj.spring; public class Car { private String brand; private float price; p
  • Spring Map 注入属性 方法

    千次阅读 2019-08-22 10:55:29
    // Map 属性注入 <entry key="aa" value-ref="car1"></entry> <entry key="bb" value-ref="car3"></entry> main方法 import com.lishimin.Person; import com.lishimin.collection.NewPerson;...
  • Spring基础之属性注入总结

    万次阅读 2016-12-26 20:04:36
    Spring是开源的轻量级框架,核心主要两部分: (1)aop:面向切面编程,扩展功能不是修改源代码实现 (2)ioc:控制反转, - 比如有一个类,在类里面有方法(不是静态的方法),调用类里面的方法,创建类的对象,...
  • 在本篇文章里小编给大家整理的是关于spring为类的静态属性实现注入实例方法,有需要的朋友们可以参考下。
  • SSH与SSM学习之Spring04Spring属性注入之set方法注入 一属性注入 三Car 类 四User类 五配置文件 applicationContextxml 六示例代码 七测试结果 八源码地址 九IOC的参考blog SSH与SSM学习之Spring04——Spring属性...
  • 以前也学习过Spring框架,不过好久没用,当时学完也没做什么总结,都忘的差不多了,今天再从头开始学习一遍。...第一天:Spring的概述、SpringIOC入门(XML)、Spring的Bean管理、Spring属性注入 第...
  • Spring属性注入之有参构造函数

    万次阅读 2018-05-16 12:38:36
    Spring通过有参构造函数的方式可以实现属性注入1.需要进行属性注入的类package com.maty.property; /** * @author maty e-mail:512181558@qq.com * @version 创建时间:2018年5月16日 下午12:14:50 * 类说明 该类...
  • Spring自动注入原理

    千次阅读 2020-05-21 17:00:33
    spring属性注入属于spring bean的生命周期一部分,bean的生命周期首先记住两个概念: spring bean:最终存在spring容器当中的对象 对象:实例化出来的对象,但是一个对象并不一定是spring bean 所谓的bean的生命...
  • Spring静态属性注入

    千次阅读 2019-02-15 16:26:11
    方式一 类定义上添加@Component注解, set方法上添加@Autowired注解 @Component public class ...set方法上添加@Autowired注解, 告诉spring自动注入 set方法不要添加static关键字,否则自动注入失败
  • 主要介绍了Spring中利用配置文件和@value注入属性值代码详解,代码中注释比较详细,具有一定参考价值,需要的朋友可以了解下。
  • spring属性注入必须有默认构造方法

    千次阅读 2017-09-04 19:23:11
    SpringContext利用无参的构造函数创建一个对象,然后利用setter方法赋值
  • java代码中设置属性的三种方式 第一种set方法 public void setUsername(String username) { this.username = username;...第二种 有参构造实现属性注入  public User(String username)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 228,360
精华内容 91,344
关键字:

spring属性注入

spring 订阅