Spring的依赖注入

1.添加spring的Jar包,还包括spring额外依赖的Jar包

指定创建类的方法(默认使用对应的构造函数创建),在创建类之前调用某个方法。在销毁类之后创建的方法

package com.lubby.test;

public class Single {
	private String id;
	private String something;
	private static Single single;

	private Single() {
		super();
	}
	private Single(String id, String something) {
		super();
		this.id = id;
		this.something = something;
	}
	public static Single getInstance(String id, String something) {
		if (single == null) {
			single = new Single(id, something);
		}
		return single;
	}
	public void init() {
		System.out.println("doSomethingBefor........");
	}
	public void destroy() {
		System.out.println("doSomethingAfter........");
	}
	@Override
	public String toString() {
		return "Single [id=" + id + ", something=" + something + "]";
	}

}

spring中的配置

<bean id="single" class="com.lubby.test.Single" factory-method="getInstance"
		init-method="init" destroy-method="destroy"><pre name="code" class="html"><pre name="code" class="html">factory-method="getInstance" 

指定创建类的方法(默认使用对应的构造函数创建),

init-method="init"

在创建类之前调用某个方法。在销毁类之后创建的方法


<pre name="code" class="html"> destroy-method="destroy"

<constructor-arg value="0100102"></constructor-arg><constructor-arg value="I want to play games...."></constructor-arg></bean>


依赖注入

Course类

package com.lubby.test;

public class Course {
	private String courseName;
	private String teacherName;
	public Course() {
		super();
	}
	public Course(String courseName, String teacherName) {
		super();
		this.courseName = courseName;
		this.teacherName = teacherName;
	}
	public String getCourseName() {
		return courseName;
	}
	public void setCourseName(String courseName) {
		this.courseName = courseName;
	}
	public String getTeacherName() {
		return teacherName;
	}
	public void setTeacherName(String teacherName) {
		this.teacherName = teacherName;
	}
	@Override
	public String toString() {
		return "Course [courseName=" + courseName + ", teacherName=" + teacherName + "]";
	}

}

Student类

package com.lubby.test;

public class Student {
	private String name;
	private String school;
	private int age;
	private Course course;
	private String address;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, String school, int age, Course course) {
		super();
		this.name = name;
		this.school = school;
		this.age = age;
		this.course = course;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSchool() {
		return school;
	}

	public void setSchool(String school) {
		this.school = school;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	public Course getCourse() {
		return course;
	}
	public void setCourse(Course course) {
		this.course = course;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", school=" + school + ", age=" + age + ", course=" + course + ", address="
				+ address + "]";
	}
}

1.通过构造函数注入参数

<bean id="course" class="com.lubby.test.Course">
	<constructor-arg value="lilI Wang" name="teacherName"></constructor-arg>
	<constructor-arg value="Enligsh" name="courseName"></constructor-arg>
<span style="font-family: Arial, Helvetica, sans-serif;"></bean></span>

3.通过setting方法注入参数

	<bean id="stu" class="com.lubby.test.Student">
		<property name="name" value="Lubby"></property>
		<property name="school" value="USTC"></property>
		<property name="course" ref="course"></property>
		<property name="address" value="上海市闸北区广中西路555号"></property>
	</bean>

执行

package com.lubby.test;

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

public class Test {
	public static void main(String[] args) {
              //加载配置文件,获取上下文
		ApplicationContext ctx = new ClassPathXmlApplicationContext("com/lubby/test/test.xml");
//		Single single = (Single) ctx.getBean("single");
//		System.out.println(single);
//		single.destroy();
               //  通过配置文件中bean 的id去创建和取得bean
		 Course course = (Course) ctx.getBean("course");
		 System.out.println(course);

		 Student student = (Student) ctx.getBean("stu");
		 System.out.println(student);
	}
}

Spring的依赖注入

时间: 2024-10-11 17:33:46

Spring的依赖注入的相关文章

spring中依赖注入方式总结

Spring中依赖注入的四种方式 在Spring容器中为一个bean配置依赖注入有三种方式: · 使用属性的setter方法注入  这是最常用的方式: · 使用构造器注入: · 使用Filed注入(用于注解方式). 使用属性的setter方法注入 首先要配置被注入的bean,在该bean对应的类中,应该有要注入的对象属性或者基本数据类型的属性.例如:为UserBiz类注入UserDAO,同时为UserBiz注入基本数据类型String,那么这时,就要为UserDAO对象和String类型设置se

(spring-第3回)spring的依赖注入-属性、构造函数、工厂方法等的注入

Spring要把xml配置中bean的属性实例化为具体的bean,"依赖注入"是关卡.所谓的"依赖注入",就是把应用程序对bean的属性依赖都注入到spring容器中,由spring容器实例化bean然后交给程序员.spring的依赖注入有属性注入.构造函数注入.工厂方法注入等多种方式,下面用几个简单的栗子来一一道来. 一.首先是属性注入: 代码001 1 <?xml version="1.0" encoding="UTF-8&q

第二十七天 春之细雨润物于无形 —Spring的依赖注入

6月11日,晴."夏条绿已密,朱萼缀明鲜.炎炎日正午,灼灼火俱燃." IT人习惯把具体的事物加工成的形状一致的类,正是这样的一致,加上合适的规范,才能彰显对象筋道的牙感和bean清香的味道.Spring比谁都清楚OO的奥妙,让组件之间的依赖关系由容器在运行时期决定,称作依赖注入(Dependency Injection). 下面用一通俗的例子,一探依赖注入奥妙. 设计模式中的一个原则:针对接口编程,不要针对实现编程. 一.设计两个接口: (1)奶制品接口-MilkProductInte

Spring的依赖注入(DI)三种方式

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 {

spring的依赖注入的最常见的两种方法

1 package com.lsz.spring.action; 2 3 public class User { 4 /** 5 * set注入 6 */ 7 private String username; 8 public void setUsername(String username) { 9 this.username=username; 10 } 11 public String getUsername() { 12 return username; 13 } 14 /* 15 <b

spring的依赖注入【NC产品中也用到spring的依赖注入】

下面设计到的类有EditPsndocAction跟RefreshPsndocAction这个两个类, 而我想要的最终效果是: 下面解释一下流程“ 如下图所示:因为NC产品中使用了spring的的依赖注入.所以我这里可以这样子调用.直接调用定刷新按钮的bean . 在EditPsndocAction这个类中,用spring的依赖注入的一个方式.给对象赋值 注意一点就是:RefreshPsndocAction 是刷新按钮对应的ben的名称.也就是 最后在EdictPsndocAction这个类的do

二、Spring的依赖注入

Spring的依赖注入 1.理解依赖注入 (1)A对象需要调用B对象的方法,这种情形被称为依赖注入,即A对象依赖B对象:依赖注入(DI)也被成为控制反转(IoC): (2)依赖注入的两种方式: 1)设值注入:IoC容器通过使用成员变量的setter方法来注入被依赖对象: 2)构造注入:IoC容器通过使用构造器来注入被依赖的对象: 2.设置注入 (1)Bean与Bean之间的依赖关系由Spring管理,Spring采用setter方法为目标Bean注入所需要的值,这种注入方式被称为设值注入: (2

关于Spring IOC (依赖注入)你需要知道的一切

[版权申明]未经博主同意,不允许转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/54561302 出自[zejian的博客] <Spring入门经典>这本书无论对于初学者或者有经验的工程师还是很值一看的,最近花了点时间回顾了Spring的内容,在此顺带记录一下,本篇主要与spring IOC相关 ,这篇博文适合初学者也适合spring有过开发经验的工程师,前者可用于全面了解Spring IOC的知识点,后者且

Spring的依赖注入的2种方式(1天时间)

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