正文

spring属性依赖注入

leagueandlegends  2022-04-19  660

关键词：

1.1 属性依赖注入

依赖注入方式：手动装配和自动装配

手动装配：一般进行配置信息都采用手动

基于xml装配：构造方法、setter方法

基于注解装配：

自动装配：struts和spring 整合可以自动装配

byType：按类型装配

byName：按名称装配

constructor：构造装配，

auto：不确定装配。

一.构造方法注入

User.java

public class User {
	
	private Integer uid;
	private String username;
	private Integer age;
	
	public User(Integer uid, String username) {
		super();
		this.uid = uid;
		this.username = username;
	}
	
	public User(String username, Integer age) {
		super();
		this.username = username;
		this.age = age;
	}
}

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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- 构造方法注入 
		* <constructor-arg> 用于配置构造方法一个参数argument
			name ：参数的名称
			value：设置普通数据
			ref：引用数据，一般是另一个bean id值
			
			index ：参数的索引号，从0开始 。如果只有索引，匹配到了多个构造方法时，默认使用第一个。
			type ：确定参数类型
		例如：使用名称name
			<constructor-arg name="username" value="jack"></constructor-arg>
			<constructor-arg name="age" value="18"></constructor-arg>
		例如2：【类型type 和  索引 index】
			<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
			<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
	-->
	<bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
		<constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
		<constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
	</bean>
</beans>

二.property属性注入

User.java

package com.zk.myspring;

public class User {
	private Integer uid;
	private String username;
	private Integer age;
	
	public Integer getUid() {
		return uid;
	}
	public void setUid(Integer uid) {
		this.uid = uid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "User [uid=" + uid + ", username=" + username + ", age=" + age
				+ "]";
	}
	public User(Integer uid, String username, Integer age) {
		super();
		this.uid = uid;
		this.username = username;
		this.age = age;
	}
	public User() {
		super();
	}

}

Test.java

package com.zk.myspring;

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

public class Test {
	public static void main(String[]args)
	{
		String path="/com/zk/myspring/ApplicationContext.xml";
		ApplicationContext ac=new ClassPathXmlApplicationContext(path);
		
		User user=(User) ac.getBean("UserId");
		System.out.println(user);
	}
}

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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="UserId" class="com.zk.myspring.User">
<!-- 
setter方法注入：
普通数据：
<property name="" value="值">
等效
<property name="">
<value>
值
</value>
</property>
引用数据
<property name="" ref="另一个bean">
</property>
等效
<property name="">
<ref bean="" />
</property>
 -->

<property name="username" value="jack"></property>
<property name="uid" value="1"></property>
<property name="age" value="24"></property>
<!-- p命名空间，对setter方法注入进行简化，替换<property name="属性名">，而是在<bean 属性名="普通值"> -->
</bean>
</beans>

　ApplicationContext的p命名空间

<?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-3.0.xsd">
<bean id="UserId" class="com.zk.myspring.User" p:uid="1" p:age="24" p:username="zk" p:company-ref="company1"></bean>
<bean id="company1" class="com.zk.myspring.Company" p:name="computer science" p:address="徐州市中国矿业大学计算机科学与技术学院">
</bean>
</beans>

三.集合属性注入

CollData.java

package com.zk.myspringcoll;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class CollData {
	private String[] arrayData;
	private List<String> listData;
	private Set<String> setData;
	private Map<String,String> mapData;
	private Properties propersData;
	public String[] getArrayData() {
		return arrayData;
	}
	public void setArrayData(String[] arrayData) {
		this.arrayData = arrayData;
	}
	public List<String> getListData() {
		return listData;
	}
	public void setListData(List<String> listData) {
		this.listData = listData;
	}
	public Set<String> getSetData() {
		return setData;
	}
	public void setSetData(Set<String> setData) {
		this.setData = setData;
	}
	public Map<String, String> getMapData() {
		return mapData;
	}
	public void setMapData(Map<String, String> mapData) {
		this.mapData = mapData;
	}
	
	public Properties getPropersData() {
		return propersData;
	}
	public void setPropersData(Properties propersData) {
		this.propersData = propersData;
	}
	@Override
	public String toString() {
		return "CollData [arrayData=" + Arrays.toString(arrayData)
				+ ", 
listData=" + listData + ", 
setData=" + setData
				+ ", 
mapData=" + mapData + ", 
properties=" + propersData + "]";
	}
	
	
}

Test.java

package com.zk.myspringcoll;

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

public class TestColl {
	public static void main(String[]args)
	{
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		CollData colldata=(CollData) ac.getBean("CollData");
		
		System.out.println(colldata);
	}
}

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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<!-- 
集合注入都是给<property>添加子标签
数组：<array>
List:<List>
Set:<set>
Map:<map>
Properties:<props><prop key="">value</prop></props>

普通数据:<value>
引用数据：<ref>
 -->
<bean id="CollData" class="com.zk.myspringcoll.CollData">
<property name="arrayData">
<array>
<value>DS</value>
<value>DZD</value>
<value>屌丝</value>
<value>吊中吊</value>
</array>
</property>
<property name="listData">
<list>
<value>list1</value>
<value>list2</value>
<value>list3</value>
<value>list4</value>
<value>list5</value>
</list>
</property>
<property name="setData">
<set>
<value>set1</value>
<value>set2</value>
<value>set3</value>
<value>set4</value>
<value>set5</value>
</set>
</property>
<property name="mapData">
<map>
<entry key="1" value="value1"></entry>
<entry key="2" value="value2"></entry>
<entry key="3" value="value3"></entry>
<entry key="4" value="value4"></entry>
<entry key="5" value="value5"></entry>
<!--
<entry>  
<key><value>6</value></key>
<value>value6</value>
</entry>
-->
</map>
</property>

<property name="propersData">
<props>
<prop key="高富帅">嫐</prop>
<prop key="白富美">嬲</prop>
<prop key="屌丝">挊</prop>
</props>
</property>
</bean>
</beans>

四.自动装配bean

<?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-2.5.xsd">
    <!-- 自动装配(用的不多)：  
         byName按名称自动匹配（即要装配的bean中的属性名称和配置中的bean名称相同就会自动装配，如UserService类中的属性和userDAO的bean名称相同就自动装配）  
         byType按类型自动匹配 （即要装配的bean中的属性类型和配置中的bean的类型相同就会自动装配，如UserService类中的属性类型和userDAO的bean类型相同就自动装配）
    -->
    <bean id="user" class="com.zk.myspring.User" autowire="default">
    </bean>

</beans>

五.使用注解

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    <context:annotation-config></context:annotation-config>
</beans>

六.扫描包名

<?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:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    <context:component-scan base-package="com.bjsxt"></context:component-scan>
</beans>

spring：di依赖注入方式

DI依赖注入　　DI（DependencyInjection）依赖注入，说简单一点就将类里面的属性在创建类的过程中给属性赋值，即将对象依赖属性（简单值，集合，对象）通过配置设值给该对象。　　属性注入的方式　构造方法的方式　set方法的... 查看详情

spring依赖注入的方式

...。③setter方法注入：注入的依赖可以为NULL。使用场景：Spring官方不建议使用变量注入。若注入的属性必需，则通过构造器注入。若注入的属性可选，则通过setter方法注入。查看详情

spring框架--spring依赖注入（di）的方式

Spring框架--Spring依赖注入（DI）的方式　　　　构造方法式：　　　　　　这是我在实体类中写的一个有参构造　　　　　　　　　　　　　　　　　配置applicationContext.xml文件，由于是注入构造方法中属性的值，所以要用cons... 查看详情

spring依赖注入(代码片段)

1.1依赖/属性注入的方式创建对象的时候，向类里面属性里面设置值。1.使用有参构造注入2.使用set方法注入（重点）！！！3.对象类型注入4.复杂数据类型注入1.2有参构造注入前提：在JavaBean中生成有参构造方法<!--构造函数注入... 查看详情

spring四种依赖注入方式

一、Set注入　　这是最简单的注入方式，假设有一个SpringAction，类中需要实例化一个SpringDao对象，那么就可以定义一个private的SpringDao成员变量，然后创建SpringDao的set方法（这是ioc的注入入口）：随后编写spring的xml文件，<bean>... 查看详情

spring的依赖注入

spring依赖注入1.构造器注入2.Set方式注入依赖注入:Set注入? 依赖:bean对象的创建依赖于容器? 注入:bean对象中的所有属性,由容器来注入packagecom.liqiliang.pojo;importjava.util.*;publicclassStudent{privateStringname;privateAddressaddress;privateString[]boo 查看详情

spring的依赖注入

04spring框架依赖注入

...法，而没有包含其他信息（如属性）。之前我们说了Spring的核心是IOC，这是使用Spring其他组件的前提条件。这里我们做一下补充：Spring依赖IOC，而IOC依赖注入。什么是注入？注入就是在S 查看详情

springioc学习_属性注入（依赖注入）(代码片段)

一、应用场景：Spring会帮创建实现类的实例，但是有时候我们还需要在类中设置一些属性用于传入设置值，这些跟类紧密关联的属性就叫依赖，通过spring帮忙设置的过程叫依赖注入。二、依赖注入的实现　A.构造方法的注入。//... 查看详情

spring入门第三课

属性注入属性注入就是通过setter方法注入Bean的属性值或依赖的对象。属性植入使用<property>元素，使用name属性指定Bean的属性名称，value属性或者<value>子节点指定属性值属性注入是实际应用中最常用的注入方式。构造方... 查看详情

spring依赖注入基于xml的di(代码片段)

DI：给属性赋值spring调用类的无参数构造方法，创建对象。对象创建后给属性赋值。给属性赋值可以使用：xml配置文件中的标签和属性使用注解DI分类：set注入，也叫做设值注入构造注入set注入publicclassStudent //... 查看详情

spring之di

...动接收对象，对象的属性值也是被动设置的。这个过程在spring称为注入。所以IOC又叫依赖注入（有容器来创建和管理对象）。2.DI和IOC的区别：DI(依赖注入)更侧重于过程，把对象通过setter、contruct、args 查看详情

spring框架依赖注入

说明：Spring由核心容器IOC降低程序的耦合度（依赖关系），对依赖关系的管理就叫做依赖注入。理解为数据在配置时初始化初值，一般用于数据内容不常修改的情况。如数据库密码等。注入语法：使用construtor-arg标签标签位置：b... 查看详情

spring的依赖注入

...String类型的属性，那么它也就依赖String类型的数据。通过Spring的配置文件，我们可以配置好某个对象的依赖，当该对象被实例化时一并将它的依赖创建好给它，这个过程就是依赖注入。在Spring的配置文件中，我们查看详情

spring总结之三（依赖注入）(代码片段)

DI（重要）：依赖注入（DependencyInjection）.一般情况下，一个类不可能独立完成一个复杂的业务，需要多个类合作共同完成，需要在类中调用其它类的方法，就要给对象赋值，程序在执行过程中动态给组件（属性）赋值，我们把... 查看详情

spring依赖注入

...中最常见的方式叫做依赖注入（DependencyInjection，简称DI）springioc容器初始化好bean的实例对象之后，会对该对象中的属性进行初始化，初始化的过程依然是由容器自动来完成，这个被称为是依赖注入（dependencyinjection缩写是D 查看详情

2.spring依赖注入（dependencyinjection）

依赖：　　在A类中引用了B类，说明A依赖于B。注入：　　使用Spring框架给A类中的B对象的属性赋值。直接上代码：1.只使用IOCpublicclassPerson{privateStringname;privateintage;publicStringgetName(){returnname;}publicvoidsetName(Stringname){this.name=name;}publ 查看详情

spring基于自动装配的依赖注入详解[自动装配模式搞不懂？来看就完了！！！][autowire属性值详解][自动装配的6种模式](代码片段)

...图做到准确和全面，终其一生进行修改补充更新。目录1Spring基于自动装配的依赖注入概述2自动装配的局限性3案例实操，走你3.1案例：byName模式3.2案例：byType模式3.3案例：constructor模式【文章其他地址】微信公众号：码农阿杰CSDN... 查看详情