Spring依赖注入(dependency injection)

最新推荐文章于 2023-06-17 12:45:29 发布
最新推荐文章于 2023-06-17 12:45:29 发布
阅读量481 收藏
点赞数
分类专栏： spring 文章标签： Spring依赖注入 构造器注入 set注入 p命名空间注入 c命名空间注入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011159417/article/details/76653294
版权

Spring的依赖注入包括两方面：


1、依赖：指bean对象创建依赖于容器；Bean对象的依赖资源。


2、注入：指bean对象依赖的资源由容器来设置和装配。


Spring的注入有两类：


1、构造器的注入：使用的是constructor-arg，如图：




2、setter注入：


要求被注入的属性，必须有set方法，set方法生成的方法名，由set+属性（首字母大写），如果属性是boolean类型，没有get方法，是is方法。


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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
	</bean>

</beans>


2）bean的注入：



给Address配置值之后如图：




Address类代码：


package com.myspring.vo;

public class Address {

	private String address ;

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}
	
	
}


Student类代码：


package com.myspring.vo;

public class Student {

	private String name;
	private Address addr ;

	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
	}

}


3）数组注入：


在Student类中加入字符串数组，代码如：


package com.myspring.vo;

public class Student {

	private String name;
	private Address addr ;
	private String[] books ;
	
	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i]+"  ");
		}
		System.out.println();
	}

}


beans.xml代码增加了输入注入，如图：




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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
	</bean>

</beans>


测试代码Test： 


package com.myspring.test;

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

import com.myspring.vo.Student;

public class Test {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml") ;
		Student student = (Student) ac.getBean("student") ;
		student.show() ;
	}
	
}


运行后控制台打印信息：




4）List注入：


在Student实体类中增加集合属性hobbies，代码如：


package com.myspring.vo;

import java.util.List;

public class Student {

	private String name;
	private Address addr ;
	private String[] books ;
	private List<String> hobbies ;
	
	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}
	
	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i]+"  ");
		}
		System.out.println();
		System.out.println("hobbies = "+ hobbies);
	}

}


在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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
		<!-- List注入 -->
		<property name="hobbies">
			<list>
				<value>羽毛球</value>
				<value>乒乓球</value>
				<value>足球</value>
				<value>台球</value>
			</list>
		</property>
		
	</bean>

</beans>

运行test测试类代码： 


package com.myspring.test;

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

import com.myspring.vo.Student;

public class Test {

	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml") ;
		Student student = (Student) ac.getBean("student") ;
		student.show() ;
	}
	
}


控制台打印如下：




5）map注入：


实体类Student中增加map属性cards，代码如：


package com.myspring.vo;

import java.util.List;
import java.util.Map;

public class Student {

	private String name;
	private Address addr ;
	private String[] books ;
	private List<String> hobbies ;
	private Map<String , String> cards ;
	
	public void setCards(Map<String, String> cards) {
		this.cards = cards;
	}
	
	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}
	
	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i]+"  ");
		}
		System.out.println();
		System.out.println("hobbies = "+ hobbies);
		System.out.println("cards = "+ cards);
	}

}

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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
		<!-- List注入 -->
		<property name="hobbies">
			<list>
				<value>羽毛球</value>
				<value>乒乓球</value>
				<value>足球</value>
				<value>台球</value>
			</list>
		</property>
		
		<!-- map注入 -->
		<property name="cards">
			<map>
				<entry key="中国银行" value="11010102020202002" />
				<entry>
					<key><value>建设银行</value></key>
					<value>20200300039399292992</value>
				</entry>
			</map>
		</property>
	</bean>

</beans>


运行test类，代码同上面的test，控制台打印信息如下：





6）Set集合注入：


实体类Student代码如下：


package com.myspring.vo;

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

public class Student {

	private String name;
	private Address addr ;
	private String[] books ;
	private List<String> hobbies ;
	private Map<String , String> cards ;
	private Set<String> games ;
	
	public void setGames(Set<String> games) {
		this.games = games;
	}
	
	public void setCards(Map<String, String> cards) {
		this.cards = cards;
	}
	
	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}
	
	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i]+"  ");
		}
		System.out.println();
		System.out.println("hobbies = "+ hobbies);
		System.out.println("cards = "+ cards);
		System.out.println("games = " + games);
	}

}


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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
		<!-- List注入 -->
		<property name="hobbies">
			<list>
				<value>羽毛球</value>
				<value>乒乓球</value>
				<value>足球</value>
				<value>台球</value>
			</list>
		</property>
		
		<!-- map注入 -->
		<property name="cards">
			<map>
				<entry key="中国银行" value="11010102020202002" />
				<entry>
					<key><value>建设银行</value></key>
					<value>20200300039399292992</value>
				</entry>
			</map>
		</property>
		
		<!-- Set集合注入 -->
		<property name="games">
			<set>
				<value>lol</value>
				<value>dota</value>
				<value>cs</value>
				<value>cf</value>
			</set>
		</property>
		
	</bean>

</beans>


测试类代码test同上面，运行后控制台打印信息：




7）Null注入：


实体类Student代码：


package com.myspring.vo;

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

public class Student {

	private String name;
	private Address addr ;
	private String[] books ;
	private List<String> hobbies ;
	private Map<String , String> cards ;
	private Set<String> games ;
	private String wife ;
	
	public void setWife(String wife) {
		this.wife = wife;
	}
	
	public void setGames(Set<String> games) {
		this.games = games;
	}
	
	public void setCards(Map<String, String> cards) {
		this.cards = cards;
	}
	
	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}
	
	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name +"---addr="+addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i]+"  ");
		}
		System.out.println();
		System.out.println("hobbies = "+ hobbies);
		System.out.println("cards = "+ cards);
		System.out.println("games = " + games);
		System.out.println("wife = "+ wife );
	}

}

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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
		<!-- List注入 -->
		<property name="hobbies">
			<list>
				<value>羽毛球</value>
				<value>乒乓球</value>
				<value>足球</value>
				<value>台球</value>
			</list>
		</property>
		
		<!-- map注入 -->
		<property name="cards">
			<map>
				<entry key="中国银行" value="11010102020202002" />
				<entry>
					<key><value>建设银行</value></key>
					<value>20200300039399292992</value>
				</entry>
			</map>
		</property>
		
		<!-- Set集合注入 -->
		<property name="games">
			<set>
				<value>lol</value>
				<value>dota</value>
				<value>cs</value>
				<value>cf</value>
			</set>
		</property>
		
		<!-- Null 注入 -->
		<property name="wife">
			<null></null>
		</property>
		
	</bean>

</beans>


运行test测试类，控制台打印信息如下：




8）Properties注入


实体类Student代码：


package com.myspring.vo;

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

public class Student {

	private String name;
	private Address addr;
	private String[] books;
	private List<String> hobbies;
	private Map<String, String> cards;
	private Set<String> games;
	private String wife;
	private Properties info;

	public void setInfo(Properties info) {
		this.info = info;
	}

	public void setWife(String wife) {
		this.wife = wife;
	}

	public void setGames(Set<String> games) {
		this.games = games;
	}

	public void setCards(Map<String, String> cards) {
		this.cards = cards;
	}

	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}

	public void setAddr(Address addr) {
		this.addr = addr;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void setBooks(String[] books) {
		this.books = books;
	}

	public void show() {
		System.out.println("name=" + name + "---addr=" + addr.getAddress());
		System.out.print("books=");
		for (int i = 0; i < books.length; i++) {
			System.out.print(books[i] + "  ");
		}
		System.out.println();
		System.out.println("hobbies = " + hobbies);
		System.out.println("cards = " + cards);
		System.out.println("games = " + games);
		System.out.println("wife = " + wife);
		System.out.println("info = " + info);
	}

}

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就是java对象 ， 由spring容器创建和管理 -->
	<bean id="addr" class="com.myspring.vo.Address">
		<property name="address" value="北京市长安街1号"></property>
	</bean>
	<bean id="student" class="com.myspring.vo.Student">
		<!-- 常量注入 -->
		<property name="name" value="张三丰"></property>
		<property name="addr" ref="addr"></property>
		<!-- 注入数组 -->
		<property name="books">
			<array>
				<value>傲慢与偏见</value>
				<value>仲夏夜之梦</value>
				<value>雾都孤儿</value>
			</array>
		</property>
		<!-- List注入 -->
		<property name="hobbies">
			<list>
				<value>羽毛球</value>
				<value>乒乓球</value>
				<value>足球</value>
				<value>台球</value>
			</list>
		</property>
		
		<!-- map注入 -->
		<property name="cards">
			<map>
				<entry key="中国银行" value="11010102020202002" />
				<entry>
					<key><value>建设银行</value></key>
					<value>20200300039399292992</value>
				</entry>
			</map>
		</property>
		
		<!-- Set集合注入 -->
		<property name="games">
			<set>
				<value>lol</value>
				<value>dota</value>
				<value>cs</value>
				<value>cf</value>
			</set>
		</property>
		
		<!-- Null 注入 -->
		<property name="wife">
			<null></null>
		</property>
		
		<!-- Properties注入 -->
		<property name="info">
			<props>
				<prop key="学号">11020039398</prop>
				<prop key="sex">男</prop>
				<prop key="name">小明</prop>
			</props>
		</property>
		
	</bean>

</beans>


运行测试类test结果如下：




9）、p命名空间注入：


我们从下面的文档截图中可以看到这是p命名空间的头文件，该文档所在路径可以从图中看到，



p命名空间的头文件部分和普通的头文件部分唯一的不同就是p命名空间的头文件多了xmlns:p="" 这部分，如图：




下面来看一下p命名怎么注入：

新建一个实体类User，代码如下：


package com.myspring.vo;

public class User {

	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}

}

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"
    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">

	<!-- bean就是java对象 ， 由spring容器创建和管理 -->
	
	<!-- p命名空间注入 -->
	<bean id="user" class="com.myspring.vo.User" p:name="小明" p:age="11"></bean>

</beans>

其中name和age是对应的实体类User中的name和age属性




测试类test代码如下：


package com.myspring.test;

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

import com.myspring.vo.Student;
import com.myspring.vo.User;

public class Test {

	public static void main(String[] args) {
		
		//p命名注入测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml") ;
		User user = (User) ac.getBean("user") ;
		System.out.println(user);
	}
	
}


控制台打印的运行结果如下：





3、c命名空间注入（其实就是构造方法注入）


c命名空间注入需要现在beans.xml头文件部分增加

    xmlns:c="http://www.springframework.org/schema/c"


实体类User代码如下：


package com.myspring.vo;

public class User {

	private String name;
	private int age;

	public User() {
		// TODO Auto-generated constructor stub
	}

	public User(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}

}


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" 
	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">

	<!-- bean就是java对象 ， 由spring容器创建和管理 -->
	
	<!-- c命名空间注入 -->
	<bean id="c_user" class="com.myspring.vo.User" c:name="小王" c:age="22"></bean>
	
</beans>


测试类Test代码：


package com.myspring.test;

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

import com.myspring.vo.Student;
import com.myspring.vo.User;

public class Test {

	public static void main(String[] args) {
		
		//p命名注入测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml") ;
		User user = (User) ac.getBean("c_user") ;
		System.out.println(user);
	}
	
}

控制台打印运行结果如下：




























Java红桃峰峰日拱一卒
关注
专栏目录
【Spring依赖注入的三种方式】
学无止境
03-05 398
【spring依赖注入的三种方式】
Spring黑马：依赖注入(Dependency Injection)
JH灰色的博客
02-16 512
文章目录1.依赖注入的3种方式(获取bean对象)1.1 构造函数注入1.2 使用set方法注入1.3 注解注入2. 依赖注入的3类数据(其实就是设定参数值)3. 案例 1.IOC的作用：降低程序之间的耦合(依赖关系) 2.依赖关系的管理：以后都交给spring来维护。 在当前类需要用到其他类的对象，由spring来提供，我们只需要在配置文件中说明依赖关系的维护，称为依赖注入。 3.依赖注入： 能...
Spring 依赖注入的学习
DCTM + SAP
08-14 144
首先我们来看看 Spring 参考文档的 11.2.6. 执行SQL语句 这里有个代码片断： import javax.sql.DataSource; import org.springframework.jdbc.core.JdbcTemplate; public class ExecuteAStatement { private Jdbc...
Spring的核心机制：依赖注入(Dependency Injection)
虽然我很菜
08-31 2625
本文摘自：李刚 著 《轻量级 Java EE企业应用实战 Struts2+Spring+hibernate整合开发》             依赖注入（Dependency Injection） 是时下的"流行语"，也是目前最优秀的解耦方式。使用依赖注入时，J2EE中的各种
spring依赖注入（dependency injection）
想念的专栏
08-20 657
spring依赖注入包括两个方面：       依赖：指bean对象创建依赖于容器。bean对象的依赖资源       注入：bean对象的依赖资源由容器来设置和装配 Spring的注入有两类： 1、构造器的注入：使用constructor-arg 2、setter注入 要求被注入的属性，必须有set方法，set方法生成的方法名，由se
依赖注入（Dependency Injection）
最新发布
Nancy_0802的博客
06-17 1033
构造方法注入可以保证依赖对象的不变性和可见性，属性注入和字段注入提供了更简洁的语法和代码风格。在目标对象的构造方法中声明依赖对象的参数，Spring容器在创建目标对象时会自动解析并提供相应的依赖对象。在Spring框架中，依赖注入（Dependency Injection）是一种通过容器自动将依赖对象注入到目标对象中的机制。需要注意的是，无论是构造方法注入、属性注入还是字段注入，都需要将依赖对象所在的类标注为Spring容器管理的组件，例如使用。类型的参数，Spring容器会自动调用该方法并注入依赖对象。
Java 中的Dependency Injection 依赖注入
nolike666的博客
10-12 336
1.Constructor Injection构造函数注入 TaxReport.java package com.company; public class TaxReport { private TaxCalculator calculator; public TaxReport(TaxCalculator calculator){ this.calculator = calculator; } public void show(){ v
Java依赖注入(Dependency Injection,DI )
modige_hm的博客
08-19 1380
DI
dependency-injection-spring:Spring依赖注入的最简单示例
04-28
没有XML的Spring Dependency Injection示例 最简单的示例Spring Dependency示例如何工作。 对于所有配置，都使用没有任何XML文件的注释。 描述 所有配置都在pooky.projects.AppConfig中 此类需要使用@Configuration...
依赖注入：Dependency injection-英文书签文字版
12-06
本资源“依赖注入：Dependency injection-英文书签文字版”提供了一份关于Spring框架中依赖注入的详细讲解，以英文文本的形式呈现，并且带有书签，方便读者快速定位和学习。 依赖注入的核心思想是将组件之间的依赖...
spring依赖注入知识点分享
08-25
IoC 有两种方式：DL（Dependency Lookup）依赖查找和 DI（Dependency Injection）依赖注入。 DL 依赖查找 DL 依赖查找是一种 IoC 方式，它通过容器查找对象的依赖关系，典型的是 JNDI（Java Naming and Directory ...
spring 随笔（一） bean & Dependency Injection
liuhenghui5201的专栏
02-25 4564
1，一切都是Bean Bean是Spring应用程序中(其实是Spring容器中)的基本元素，在Spring框架上运行的应用程序，就是由一个又一个的Bean组合在一起、像搭积木一样堆出来的。所有的Bean都由Spring的核心容器负责管理、创建、销毁，同时Bean之间的相互依赖也由Spring容器中的依赖注入功能自动管理。 1.1bean的作用域 lsingleton：定义b
Spring的DI（Dependency Injection）
void
01-19 138
依赖注入(dependency Injection) 程序间的耦合即依赖。依赖注入时spring框架核心ioc的具体体现。 依赖关系的管理： 业务层和持久层的依赖关系，以后都交给Spring来维护。在当前类需要用到其他类的对象，由Spring为我们提供，我们只需要在配置文件中说明。 依赖关系的维护：依赖注入 依赖注入的数据有三类： 基本类型和String 其它bean类型（在配置文件中或者注解配...
Spring_依赖注入（Dependency Injection)
weixin_36957504的博客
12-11 158
Spring_依赖注入（Dependency Injection) 使用Spring框架后，Spring将会对类间的依赖关系进行管理，而这就叫做依赖注入。 注意：经常变化的数据，并不适合使用依赖注入 一、依赖注入的三种方式： 1）使用构造函数 2）使用setter方法 3）使用注解 一、依赖注入的数据： 1）在配置文件中配置的bean类 2）基本类型和String 3）复杂类型/集合类型 ...
Java开发两年，连Spring的依赖注入的方式都搞不清楚，你工作可能有点悬！
weixin_49723683的博客
11-22 233
Spring依赖注入 常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我们程序员，而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。 构造函数注入 在be
Spring依赖注入Dependency Injection(DI)
csdn_hmt的博客
06-13 271
Spring出现无法读取文档问题： 原因：系统自带的打包插件只能把代码打包，不能把项目的依赖打包，导致无法加载本地的xsd文件，然后到网上找，但也不能找到就会报错，无法启动项目。 解决方法： 1、在pom.xml中<build>标签下引入新的打包插件： <plugins> <plugin> <groupId>org.apa...
Spring--依赖注入(Dependency Injection)
天行健 君子以自强不息，地势坤 君子以厚德载物。
04-21 978
1.Spring–依赖注入(Dependency Injection) 依赖注入（Dependency Injection,DI）。 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 . 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 . 1.1 构造器注入 前面的beans.xml一直用的构造器注入 1.2 Set 注入 （重点） 1.2.1 测试pojo类 Address.java package com.tian.pojo; public class Add
Spring第四篇_依赖注入(Dependency Injection)
weixin_44086832的博客
04-18 466
4. 依赖注入 Spring中的依赖注入: 依赖注入: Dependency Injection IOC的作用: 降低程序间的依赖耦合(依赖关系) 依赖关系的管理: 以后都交给Spring来维护 在当前类需要用到其它类的对象的时候, 由Spring为我们提供, 我们只需要在配置文件中说明 依赖关系的维护, 就称之为依赖注入 依赖注入: 能注入的数据 有三类: 基本类型和String 其他bea...
深入理解Spring依赖注入
"本文主要介绍Spring框架中的依赖注入(Dependency Injection, DI)概念，以及如何通过XML配置实现DI的两种方式：设值注入和构造注入。" 在Spring框架中，依赖注入是核心特性之一，它有助于降低组件之间的耦合度，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值