`
lanqiaoyeyu
  • 浏览: 25085 次
  • 性别: Icon_minigender_1
  • 来自: 广州
社区版块
存档分类
最新评论

Spring学习(四) 注入依赖对象

    博客分类:
  • Java
 
阅读更多
依赖注入(Dependency Injection)
所谓的依赖注入就是指:在运行期间,由外部容器动态地将依赖对象注入到组件中。
一、注入方式
1、通过构造方法注入
package com.bill.impl;
import com.bill.PersonService;
import com.bill.dao.PersonDao;
/**
 * @author Bill
 */
public class PersonServiceBean implements PersonService {
	private PersonDao personDao;
	private String name;
	
	public PersonServiceBean(PersonDao personDao, String name) {
		this.personDao = personDao;
		this.name = name;
	}
	public void save(){
		personDao.add();
		System.out.println(name);
	}	
}

	<bean id="personDao" class=" com.bill.dao.impl.PersonDaoBean"/>
	<bean id="personService" class="com.bill.impl.PersonServiceBean">
		<constructor-arg index="0" type="com.bill.dao.PersonDao" ref="personDao"></constructor-arg>
		<constructor-arg index="1" value="good"></constructor-arg>
	</bean>

测试代码:
		AbstractApplicationContext act = new ClassPathXmlApplicationContext("beans.xml");
		PersonService personService = (PersonService)act.getBean("personService");
		personService.save();
	    act.close();

2、通过属性setter方法注入
如二.1

3、使用注解方式注入
在java代码中使用@Autowired或者@Resource注解方式进行装配。这两个注解的区别是:@Autowired默认按类型装配,@Resource默认按名称装配,当找不到与名称匹配的bean才会按类型装配。需配置xml文件如下:
<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/>
	<bean id="personDao" class=" com.bill.dao.impl.PersonDaoBean"></bean>
	<bean id="personService" class="com.bill.impl.PersonServiceBean"></bean>
</beans>

这种配置隐式注册了多个对注解解析处理的处理器AutowriedAnnotationBeanPostProcessor,CommonAnnotationBeanPostProcessor,PersistenceAnnotationBeanPostProcessor,RequiredAnnotationBeanPostProcessor

使用@Resource注解的业务代码如下:
1)标注在字段上的方式
package com.bill.impl;
import javax.annotation.Resource;

import com.bill.PersonService;
import com.bill.dao.PersonDao;
/**
 * @author Bill
 */
public class PersonServiceBean implements PersonService {
	@Resource private PersonDao personDao;
	//@Resource(name="personDao") private PersonDao personDao;//采用指定name属性的方式,寻找xml中指定的bean
	public void save(){
		personDao.add();
	}
}

2)标注在setter方法上的方式
package com.bill.impl;

import javax.annotation.Resource;
import com.bill.PersonService;
import com.bill.dao.PersonDao;
/**
 * @author Bill
 */
public class PersonServiceBean implements PersonService {
	private PersonDao personDao;

	@Resource
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}


	public void save(){
		personDao.add();
	}
}

在@Resource中没有指定name属性时,Spring会根据该字段的名称personDao去xml中寻找匹配的bean,假如找不到,再去根据该字段的类型去寻找匹配的bean。

注意:@Resource注解在Spring安装目录的lib\j2ee\common-annotations.jar

使用@Autowired注解的业务代码如下:
package com.bill.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

import com.bill.PersonService;
import com.bill.dao.PersonDao;
/**
 * @author Bill
 */
public class PersonServiceBean implements PersonService {
	//默认按类型装配
	@Autowired private PersonDao personDao;
	//使用@Qualifier("personDao")将@Autowired装配方式改为按名称装配
	//@Autowired @Qualifier("personDao") private PersonDao personDao;
	public void save(){
		personDao.add();
	}
}


二、注入类型
1、基本类型以及集合类型对象注入
public class PersonServiceBean implements PersonService {
	private String name;
	private Integer id;
	private Set<String> sets = new HashSet<String>();
	private Map<String, String> maps = new HashMap<String, String>();
	private Properties properties = new Properties();
	
	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public Properties getProperties() {
		return properties;
	}

	public void setProperties(Properties properties) {
		this.properties = properties;
	}

	public Map<String, String> getMaps() {
		return maps;
	}

	public void setMaps(Map<String, String> maps) {
		this.maps = maps;
	}

	public Set<String> getSets() {
		return sets;
	}

	public void setSets(Set<String> sets) {
		this.sets = sets;
	}
}

	<bean id="personService" class="com.bill.impl.PersonServiceBean">
		<property name="name" value="bill"/>
		<property name="id" value="88"/>
		<property name="sets">
			<set>
				<value>set1</value>
				<value>set2</value>
				<value>set3</value>
			</set>
		</property>
		<property name="maps">
			<map>
				<entry key="key1" value="value1"></entry>
				<entry key="key2" value="value2"></entry>
				<entry key="key3" value="value3"></entry>
			</map>
		</property>
		
		<property name="properties">
			<props>
				<prop key="key-1">propValue1</prop>
				<prop key="key-2">propValue2</prop>
				<prop key="key-3">propValue3</prop>
			</props>
		</property>
	</bean>

测试代码:
		System.out.println("===========set============");
		for(String value : personService.getSets()){
			System.out.println(value);
		}
		System.out.println("===========map============");
		for(String key : personService.getMaps().keySet()){
			System.out.println(key + "=" + personService.getMaps().get(key));
		}
		System.out.println("===========properties========");
		for(Object propsKey : personService.getProperties().keySet()){
			System.out.println(propsKey + "=" + personService.getProperties().getProperty((String) propsKey));
		}


2、注入其他bean类型
1)方式一
	<bean id="personDao" class=" com.bill.dao.impl.PersonDaoBean"/>
	<bean id="personService" class="com.bill.impl.PersonServiceBean">
		<property name="personDao" ref="personDao"></property>
	</bean>

2)方式二(使用内部bean的方式进行注入,但该bean不能被其他bean使用)
	<bean id="personService" class="com.bill.impl.PersonServiceBean">
		<property name="personDao">
			<bean class=" com.bill.dao.impl.PersonDaoBean"/>
		</property>
	</bean>
分享到:
评论

相关推荐

    spring学习:依赖注入的几种方式讨论

    在类或方法上使用`@Autowired`注解可以自动匹配并注入依赖。例如: ```java @Service public class Service { @Autowired private Repository repository; } ``` `@Service`是Spring的组件注解,标记此类为一个...

    spring依赖注入

    其次,setter注入是通过在类中声明setter方法,Spring容器会调用这些方法来注入依赖。这种方式更灵活,允许在对象创建后改变依赖,但可能导致对象在不完整状态下被初始化。 为了实现这些注入,我们需要在Spring配置...

    Spring 学习笔记《依赖注入》源文件

    这种方式更为灵活,可以在对象创建后任何时候注入依赖。例如: ```java public class UserService { private UserDao userDao; public void setUserDao(UserDao userDao) { this.userDao = userDao; } } ``` ...

    Spring Ioc 注解 依赖注入

    1. **构造器注入**:通过类的构造方法来注入依赖项。 2. **设值注入**:通过setter方法来注入依赖项。 #### 四、使用注解进行依赖注入 随着Spring框架的发展,除了XML配置之外,Spring还引入了注解的方式来简化...

    spring依赖注入底层详解

    1. 构造器注入:通过在类的构造函数中传递依赖对象来完成注入。这种方式在创建对象时就确保了所有依赖都已就绪,适合于对象的依赖关系不可变的情况。 2. 设值注入:通过setter方法将依赖对象注入到已经创建的对象中...

    spring依赖注入三种方式 测试源码

    接口注入在Spring中较少使用,主要是通过实现特定的接口,由Spring提供实现该接口的方法来注入依赖。这种方式对类的侵入性较大,但可以避免使用setter方法。在实际应用中,更多地会采用构造器注入和设值注入。 ...

    Spring的依赖注入,与前置通知的实例

    1. **构造器注入**:通过在类的构造函数中传递依赖对象的实例,Spring容器会在创建目标对象时调用合适的构造函数并注入依赖。 2. **setter注入**:在类中定义setter方法,Spring容器可以通过调用这些setter方法来...

    Spring 控制反转 依赖注入

    3. **接口注入**:较少使用,通过实现特定接口来注入依赖,但Spring并不直接支持,通常需要自定义实现。 **Spring的配置方式** Spring提供了多种配置方式: 1. **XML配置**:传统的Spring配置方式,通过`&lt;bean&gt;`...

    Spring学习笔记(6)----编码剖析Spring依赖注入的原理

    2. 使用`@Autowired`注解自动匹配和注入依赖。 3. Bean工厂和ApplicationContext管理bean生命周期,BeanDefinition存储bean的元信息。 4. `DefaultListableBeanFactory`和`AutowiredAnnotationBeanPostProcessor`...

    第三章 Spring4 依赖注入

    Spring会自动调用setter方法来注入依赖。例如: ```java public class UserService { private UserRepository userRepository; @Autowired public void setUserRepository(UserRepository userRepository) { ...

    模拟Spring的依赖注入

    1. **构造器注入**:通过在构造函数中传递依赖对象的实例来实现。 ```java public class MyClass { private Dependency dependency; public MyClass(Dependency dependency) { this.dependency = dependency; ...

    spring依赖注入的实现原理

    Spring可以通过调用setter方法或构造器来注入依赖。 7. **AOP代理(AOP Proxy)** Spring通过AOP代理来实现对Bean的增强,提供事务管理、日志记录等服务。有JDK动态代理和CGLIB代理两种方式,前者适用于接口,后者...

    Spring依赖注入的方式

    接口注入在Spring中相对较少使用,主要是通过实现特定的接口并由Spring提供实现来注入依赖。这种方式通常适用于需要动态地改变对象的行为,比如AOP代理。 ```java public interface ApplicationContextAware { ...

    Spring学习笔记(5)----依赖注入的简单实现

    这种方式更为灵活,因为即使对象已经被创建,也可以动态注入依赖: ```java public class Service { private Repository repository; @Autowired public void setRepository(Repository repository) { this...

    使用反射和注解模拟Spring的依赖注入

    在Spring框架中,依赖注入就是利用反射来找到并实例化所需的对象,然后将它们注入到其他对象中。 接下来,我们谈谈注解。注解是元数据的一种形式,可以向编译器或运行时环境提供有关代码的信息。Java中的注解是以`@...

    Spring依赖注入检查.

    对于非POJO对象或者有特殊初始化需求的对象,Spring提供工厂方法来创建并注入依赖。 6. **@Qualifier注解**: 当有多个相同类型的bean,而我们需要指定具体哪一个时,`@Qualifier`注解可以用来明确指定。 7. **@...

    java Spring DI依赖注入.rar

    Spring框架通过DI来管理对象的生命周期和对象间的依赖关系,使得开发者无需在代码中硬编码依赖对象的创建和获取。 在Spring框架中,依赖注入有两种主要实现方式:构造器注入和setter注入。 1. 构造器注入:通过在...

    如何实现Spring依赖注入 AOP.rar

    3. **接口注入**:Spring通过实现一个接口并在接口中定义setter方法来注入依赖。这种方式相对较少使用,通常用于特殊场景。 **面向切面编程(AOP)** AOP是一种编程范式,它允许程序员定义“切面”,这些切面可以...

    Spring三种注入方式(三)

    这种方式是通过实现特定的接口,由Spring在运行时动态调用接口方法注入依赖。Spring没有内置的接口注入机制,但可以通过实现`InitializingBean`或`DisposableBean`接口来自定义初始化和销毁逻辑。例如: ```java ...

Global site tag (gtag.js) - Google Analytics