依赖注入的两种方式并附上例子

1.依赖注入：就是指程序在运行过程中，如果需要另外一个对象协助完成时，无需在代码中创建被调用者，而是依赖外部的注入获取。

2.依赖注入的两种方式：

设置注入：设置注入是通过setter方法注入被调用者的实例。

构造注入：利用构造方法来设置依赖注入的方式称为构造注入。

3.接下来附上例子来说明设置注入

(1).首先，附上设置注入的例子，新建一个Java项目，配置好Spring后，即可，项目结构图如下图所示：

(2).首先，新建2个接口，一个Animal接口，一个Person接口，其中Animal接口有一个抽象的用途方法，就是动物是用来干嘛的，其中Person接口有一个饲养的方法。

Animal.java文件代码如下：

package com.inter;

public interface Animal {
	void use();//定义抽象的用途方法
}

Person.java文件代码如下：

package com.inter;

public interface Person {
	void raise();//定义抽象的饲养方法
}

(3).接着新建3个类，放在com.bean包下，分别为Dog、Cat、Businessman类，其中Dog、Cat类的use方法只输出一句话，Businessman类中有个Animal对象属性，并有其对应的setter方法，有一个raise方法，也是简单的输出和调用方法。

Dog.java文件代码如下：

package com.bean;

import com.inter.Animal;

public class Dog implements Animal{

	@Override
	public void use() {
		// TODO Auto-generated method stub
		System.out.println("狗的用途是看家");
	}

}

Cat.java文件代码如下：

package com.bean;

import com.inter.Animal;

public class Cat implements Animal{

	@Override
	public void use() {
		// TODO Auto-generated method stub
		System.out.println("猫的用途是捉老鼠");
	}

}

Businessman.java文件代码如下：

package com.bean;

import com.inter.Animal;
import com.inter.Person;

public class Businessman implements Person {

	private Animal animal;

	public Businessman() {

	}

	public void setAnimal(Animal animal) {
		this.animal = animal;
	}

	@Override
	public void raise() {
		// TODO Auto-generated method stub
		System.out.println("人饲养动物");
		animal.use();
	}

}

(4).对上面的类在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="bus" class="com.bean.Businessman">
		<property name="animal">
			<ref bean="dog"/>
		</property>
	</bean>

	<bean id="dog" class="com.bean.Dog"></bean>
	<bean id="cat" class="com.bean.Cat"></bean>
</beans>

其中定义一个Businessman类的bean中，有个属性property标签，其中name对应Businessman类的Animal对象属性，并且使用ref标签引用了下面定义的Dog对象的id， 就这样设置注入了dog对象。

(5).最后编写测试类Test，代码如下：

package com.test;

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

import com.inter.Person;

public class Test {
	public static void main(String[] args){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Person p=(Person) ac.getBean("bus");
		p.raise();
	}
}

通过查找配置文件来找到有id为bus的bean，然后把这个bean强制转换为一个Person对象，再调用这个Person对象的raise方法，此时raise方法即为Businessman的raise方法，因为在Businessman类中使用了Animal对象属性，并通过设置注入到了配置文件中。

(6).运行后效果如下：

为什么输出的是狗的用途呢，因为我们把对象属性通过设置注入的方式注入到配置文件中，而配置文件中的对象属性引用的为Dog这个类。

4.接下来附上构造注入的例子，来说明构造注入

(1).首先，新建一个Java项目，配置好Spring环境，先附上这个项目的文件结构图：

(2).首先，定义两个接口，分别为Axe和Person接口，放在com.inter包下，其中Axe(斧头)接口定义了一个抽象的chop(砍)方法，其中Person(人)接口定义了一个使用斧头的方法。

Axe.java文件的代码如下：

package com.inter;

public interface Axe {
	 String chop();
}

Person.java文件代码如下：

package com.inter;

public interface Person {
	void useAxe();
}

(3).接着新建3个类，分别为Chinese、SteelAxe、StoneAxe类，放在com.bean包下，其中Chinese类实现Person接口，SteelAxe和StoneAxe类实现Axe接口，其中Chinese类有一个对象属性，一个普通属性，并通过构造方法传入两个属性作为参数，其中SteelAxe、StoneAxe类里有一个返回值为字符串的方法。

Chinese.java文件代码如下：

package com.bean;

import com.inter.Axe;
import com.inter.Person;

public class Chinese implements Person {
	private Axe axe;
	private String name;

	public Chinese() {

	}

	public Chinese(Axe axe,String name){
		this.axe=axe;
		this.name=name;
	}

	public String getName() {
		return name;
	}

	@Override
	public void useAxe() {
		// TODO Auto-generated method stub
		System.out.println(axe.chop());
	}

}

SteelAxe.java文件代码如下：

package com.bean;

import com.inter.Axe;

public class SteelAxe implements Axe{

	@Override
	public String chop() {
		// TODO Auto-generated method stub
		return "钢斧砍柴好快";
	}

}

StoneAxe.java文件代码如下：

package com.bean;

import com.inter.Axe;

public  class StoneAxe implements Axe{

	@Override
	public String chop() {
		// TODO Auto-generated method stub
		return "石斧砍柴好慢";
	}

}

(4).其中在applicationContext.xml配置文件配置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"
	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="chinese" class="com.bean.Chinese">
		<constructor-arg>
			<ref bean="stoneAxe"/>
		</constructor-arg>
		<constructor-arg name="name" value="A-Lin">
		</constructor-arg>
	</bean>
	<bean id="steelAxe" class="com.bean.SteelAxe"></bean>
	<bean id="stoneAxe" class="com.bean.StoneAxe"></bean>
</beans>

其中Chinese对象中使用constructor-arg标签，直接引用stoneAxe这个id的StoneAxe类，就可以给对象属性axe这个注入值 ，这种方式就为构造注入，其中为普通属性注入值，就像配置文件的constructor-arg标签的name属性一样，并赋给value属性一个值，其中name属性对应的为Chinese类的name属性！

(5).最后，编写测试类Test，代码如下：

package com.test;

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

import com.bean.Chinese;
import com.inter.Person;

public class Test {
	public static void main(String[] args){
		ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
		Chinese c=(Chinese) ac.getBean("chinese");
		System.out.println(c.getName());
		c.useAxe();
	}
}

其中使用类路径的方式查找到applicationContext.xml文件，生成一个ApplicationContext应用上下文环境对象，利用这个对象在配置文件中获得Chinese这个类的对象，调用其方法。

(6).运行后，效果如下图所示：

5.以上内容仅供大家学习参考，写得不好，请见谅，如有错误，请指出，谢谢！



时间： 2024-12-09 23:02:43

依赖注入的两种方式并附上例子的相关文章

【SSH进阶之路】Spring的IOC逐层深入——依赖注入的两种实现类型(四)

上篇博文,我们介绍了为什么使用IOC容器,和IOC的设计思想以及IOC容器的优缺点,并且给大家转载了一篇介绍IOC原理的博文,我们这篇主要给大家依赖注入的两种方式,以及他们的优缺点. 我们这篇博文还是使用上篇博客中添加用户的实力,只是给大家在注入对象的方式上发生一点点变化,为了让大家更加容易接受.下面我们开始: 构造器注入 构造器注入,即通过构造函数完成依赖关系的设定.我们看一下spring的配置文件: <?xml version="1.0" encoding="UTF

IoC(控制反转)的主要组件和注入的两种方式

一.IoC的主要组件: (1).Spring框架的两个最基本和最重要的包是org.springframework.beans.factory(该包中的主要接口是BeanFactory)和org.springframework.context包(该包中的主要接口是ApplicationFactory).这两个包中的代码提供了Spring IoC特性的基础. (2).Spring IoC框架的主要组件有:Beans.配置文件(beans.xml或applicationContext.xml).Bea

spring学习一——基本搭建，属性注入的两种方式

今天用spring 3.2.5搭建了基本的环境,spring出的太快了,前段时间才3.2.5,今儿个一瞧已经上了4的版本了,稍后给出spring的jar下载地址,毕竟现在官网上找不到了啊. 废话少说了,spring 3.2.5已经将所有的依赖包都放在了dist的lib下面,并且都有doc包和源码包,很是方便.先导入所需的jar包:core,context,beans,expression 四个jar包,除此之外,还需导入commons-logging. 下一步,新建xml文件,建议名称为 app

SSH深度历险（八） 剖析SSH核心原理+Spring依赖注入的三种方式

在java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理,spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是"控制反转",通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员,而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做. Spring依赖注入(

峰Spring4学习（2）依赖注入的几种方式

一.装配一个bean 二.依赖注入的几种方式 com.cy.entity   People.java: package com.cy.entity; public class People { private int id; private String name; private int age; public People() { super(); // TODO Auto-generated constructor stub } public People(int id, String n

Spring的依赖注入的2种方式（1天时间）

今天花了一天的时间才调试出来 private      接口   实现类的那个bean; 最后面的那个名字不能随便的写,必须是配置文件中,实现类的那个bean 就是后面的那个名字写错了,花了整整一天 必须有这句注解扫描才能扫描到注解 进行注解的配置,不需要get方法和set方法,小龙儿说xml文件配置才需要set方法 package com.baobaotao1; import org.springframework.context.ApplicationContext; import org.

【SSH三大框架】Spring基础第二篇：Spring依赖注入的三种方式

控制反转(Inversion of Control)和依赖注入(Dependency Injection): 应用控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它.也可以说,依赖被注入到对象中.所以,控制反转是,关于一个对象如何获取他所依赖的对象的引用,这个责任的反转. 对于依赖注入,有三种方式: 1.使用属性的setter方法注入 2.使用构造器注入 3.使用注解注入 下面我们介绍下这三种方式: 一.使用属性的setter方法注入 首先,我们写一个

spring4之依赖注入的三种方式

1.Setter注入 <bean id="helloWorld" class="com.jdw.spring.beans.HelloWorld"> <property name="name" value="Spring"></property> </bean> 从这给最简单的配置可以得出以下两个结论:一.class属性需要全类名进行配置,说了ioc容器是通过反射进行创建bean的

Spring依赖注入的三种方式

Spring依赖注入(DI)的三种方式,分别为: 1． 接口注入 2． Setter方法注入 3． 构造方法注入 下面介绍一下这三种依赖注入在Spring中是怎么样实现的. 首先我们需要以下几个类: 接口 Logic.java 接口实现类 LogicImpl.java 一个处理类 LoginAction.java 还有一个测试类 TestMain.java Logic.java如下: package com.spring.test.di; public interface Logic { pub