4.spring di

spring di,即依赖注入,从应用的浅显意义来讲就是对属性赋值

1.用setter赋值,在spring的applicationContext.xml配置文件的bean下的property标签

属性name指定属性名,属性value指定值,一般用于基本数据 类型的包装类型

属性ref指定值,一般用于引用类型,还有list标签,下面value标签,

set标签下面value标签,map标签下面entry,下面分别有key,value,

还有props,下面prop,key

public class Student {
	public void say(){
		System.out.println("student");
	}
}
public class Person {
	private Long pid;//包装类型
	private String pname;//String类型
	private Student student;//引用类型

	private List lists;

	private Set sets;

	public Long getPid() {
		return pid;
	}

	public void setPid(Long pid) {
		this.pid = pid;
	}

	public String getPname() {
		return pname;
	}

	public void setPname(String pname) {
		this.pname = pname;
	}

	public Student getStudent() {
		return student;
	}

	public void setStudent(Student student) {
		this.student = student;
	}

	public List getLists() {
		return lists;
	}

	public void setLists(List lists) {
		this.lists = lists;
	}

	public Set getSets() {
		return sets;
	}

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

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

	public Properties getProperties() {
		return properties;
	}

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

	private Map map;

	private Properties properties;
}

  

<?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">
    <bean id="person" class="cn.di.xml.set.Person">
    	<!--
    		property就是代表属性
    		  在spring中基本类型(包装类型和String)都可以用value来赋值
    		                         引用类型用ref赋值
    	 -->
    	<property name="pid" value="5"></property>
    	<property name="pname" value="王五"></property>
    	<property name="student">
    		<ref bean="student"/>
    	</property>
    	<property name="lists">
    		<list>
    			<value>list1</value>
    			<value>list2</value>
    			<ref bean="student"/>
    		</list>
    	</property>
    	<property name="sets">
    		<set>
    			<value>set1</value>
    			<value>set2</value>
    			<ref bean="student"/>
    		</set>
    	</property>
    	<property name="map">
    		<map>
    			<entry key="map1">
    				<value>map1</value>
    			</entry>
    			<entry key="map2">
    				<value>map2</value>
    			</entry>
    			<entry key="map3">
    				<ref bean="student"/>
    			</entry>
    		</map>
    	</property>
    	<property name="properties">
    		<props>
    			<prop key="prop1">
    				prop1
    			</prop>
    		</props>
    	</property>
    </bean>
	<bean id="student" class="cn.di.xml.set.Student"></bean>
</beans>

  

@Test
	public void test(){
               ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		Person person = (Person)context.getBean("person");
		person.getStudent().say();
		System.out.println(person.getPid());
		System.out.println(person.getPname());
		List lists = person.getLists();
		for(int i=0;i<lists.size();i++){
			System.out.println(lists.get(i).toString());
		}
	}

  

2.利用构造函数赋值

在bean下有constructor-arg标签,里面有index,type,ref,value属性

public class Person {
	private Long pid;
	public Long getPid() {
		return pid;
	}

	public String getPname() {
		return pname;
	}

	public Student getStudent() {
		return student;
	}

	private String pname;
	private Student student;

	public Person(Long pid,String pname){
		this.pid = pid;
		this.pname = pname;
	}

	public Person(String pname,Student student){
		this.pname = pname;
		this.student = student;
	}
}

  

<?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">
    <bean id="person" class="cn.di.xml.constructor.Person">
    	<!--
    		构造函数的参数
    		  index  第几个参数,下标从0开始
    		  type   参数的类型
    		  ref    如果类型是引用类型,赋值
    		  value  如果类型是基本类型,赋值
    		 说明:
    		    只能指定一个构造函数
    	 -->
    	<constructor-arg index="0"  type="java.lang.String" value="王五"></constructor-arg>
    	<constructor-arg index="1"  ref="student"></constructor-arg>
    </bean>

    <bean id="student" class="cn.di.xml.constructor.Student"></bean>
</beans>

  

时间: 2024-10-14 12:32:30

4.spring di的相关文章

Spring DI基础实例解析

1.        在程序中提供需要依赖Spring为其注入属性的属性名和类型 package com.hao947.ioc; public class UserService { private String name; private String year; public void setName(String name) { this.name = name; } public void setYear(String year) { this.year = year; } public

Spring DI模式 小例子

今儿跟同事讨论起来spring早期的,通过大篇幅xml的配置演变到今天annotation的过程,然后随手写了个小例子,感觉还不错,贴到这里留个纪念. 例子就是用JAVA API的方式,演示了一下DI的注入模式,但因我对设计模式了解的比较少,那本书躺了很久都没时间去看,所以理解的有些幼稚,随后等复习到spring那的时候,详细会有更好的答案. Spring DI模式 小例子

Spring DI - 依赖注入

1.IOC(DI) - 控制反转(依赖注入) 所谓的IOC称之为控制反转,简单来说就是将对象的创建的权利及对象的生命周期的管理过程交由Spring框架来处理,从此在开发过程中不再需要关注对象的创建和生命周期的管理,而是在需要时由Spring框架提供,这个由spring框架管理对象创建和生命周期的机制称之为控制反转.而在创建对象的过程中Spring可以依据配置对对象的属性进行设置,这个过称之为依赖注入,也即DI. 2.set方法注入 通常的javabean属性都会私有化,而对外暴露setXxx()

Spring简介即Spring Ioc和Spring Di

Spring框架简介 Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅限于服务器端的开发.从简单性.可测试性和松耦合的角度而言,任何Java应用都可以从S

spring -di依赖注入,seter方法

[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.sprin

Spring IOC/DI/注解

一.定义:Spring 是一个开源的控制反转(Inversion of Control,IoC/DI)和面向切面(AOP)的容器框架,它的主要目的是简化企业开发 二.实例化Spring容器: 方法一:在类路径下寻找配置文件来实例化容器 1 ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"}); 方法二:在文件系统路径下寻找配置文件来实例化容器 1 Applicatio

Spring中IOC与DI的的区别

依赖注入的前提: 有IOC的环境,也就是将必须对象的创建权交给了Spring. DI 介绍 Dependency Injection 依赖注入.需要有IOC 的环境,Spring 创建这个类的过程中,Spring 将类的依赖的属性设置进去. IOC与DI的的区别: IOC:  控制反转,将类的对象的创建交给Spring类管理创建. DI:    依赖注入,将类里面的属性在创建类的过程中给属性赋值. DI和IOC的关系: DI不能单独存在,DI需要在IOC的基础上来完成. 这样做得好处:做到了单一

Spring的Ioc与DI

一.前言 Spring框架的核心基于控制反转的原理. IoC是一种将组件依赖关系的创建和管理外部化的技术. 考虑一个示例,其中Foo类依赖于Bar类的实例来执行某种处理. 传统上,Foo使用new运算符创建Bar的实例,或者从某种工厂类中获取一个实例. 使用IoC方法,运行时某些外部进程会将Bar的实例(或子类)提供给Foo. 这种行为,即在运行时注入依赖项,导致IoC被Martin Fowler重命名为更具描述性的依赖项注入(DI).依赖注入是IoC的一种特殊形式,尽管您经常会发现这两个术语可

spring beans源码解读

spring beans下面有如下源文件包: org.springframework.beans, 包含了操作java bean的接口和类.org.springframework.beans.annotation, 支持包,提供对java 5注解处理bean样式的支持.org.springframework.beans.factory, 实现spring轻量级IoC容器的核心包.org.springframework.beans.factory.access, 定位和获取bean工程的辅助工具类