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.springframework.org/schema/p"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 <!-- scope属性,表示创建对象的方式,
 值:prototype表示获取的是多实例 ,每次执行一次,都会创建一个新的对象
 一旦换成  singleton 表示成一个单实例,只有唯一的一个实例,内存地址不变
 -->
 <bean id="per" class="com.demo.dao.Person"></bean>
 <bean id="dao" class="com.demo.dao.PersonDAOImpl">
 <property name="name" value="张三"></property>
 <property name="age" value="23"></property>
  
 <property name="pc" >
 <!-- Person pc= new com.demo.dao.Person() -->
 <bean class="com.demo.dao.Person"></bean>
 </property>
 <property name="list">
 <list>
 <bean class="com.demo.dao.PersonDAOImpl"></bean>
 <value>1</value>
 <value>2</value>
 <value>3</value>
 <value>4</value>
 <value>5</value>
 </list>
 </property>
 
 <property name="obj">
 <list>
 <value>112</value>
 <value>120</value>
 <value>114</value>
 <value>113</value>
 </list>
 </property>
 
 <property name="set">
 <set>
  <value>5</value>
  <value>6</value>
  <value>5</value>
  <value>6</value>
  <ref bean="per"/>
 </set>
 </property>
 
 <property name="map">
 <map>
 <entry key="key01" value-ref="per"></entry>
 <entry key="key02" value="12"></entry>
 <entry key="key03">
 <value>13</value>
 </entry>
 </map>
 </property>
 
 <property name="prop">
 <props>
 <prop key="prop1">123</prop>
 <prop key="prop2">1234</prop>
 
 </props>
 </property>
 
 <property name="listNull">
 <null></null>
 </property>
 <!--
 Person per=new Person();
 person=per;
  -->
 <property name="person" ref="per"></property>
</bean>
</beans>

-------------------------------------

【ReadApplicationContext.java】

public class ReadApplicationContext {
 public static void main(String[] args) {
  //spring 配置文件的路径,从类路径下加载
  String url="applicationContext.xml";
  //String url1="ioc/applicationContext.xml";
  //读取spring 的配置文件,获取唯一对象名
 ApplicationContext act= new ClassPathXmlApplicationContext(url);
  //ClassPathXmlApplicationContext act= new ClassPathXmlApplicationContext(url);
  //从spring容器中获取boy 的对象
  PersonDAO dao1=(PersonDAO)act.getBean("dao");
  dao1.save();
 
 }
}

--------------------------------------

【PersonDAOImpl.java】

public class PersonDAOImpl implements PersonDAO {
 //属性
 private String name;
 private Integer age;
 private Person person;
 private Person pc;
 //设置集合
 private Set set;
 
 
 public Set getSet() {
  return set;
 }
 public void setSet(Set set) {
  this.set = set;
 }
 private List list;
 private Object[] obj;
 private Map map;
 private Properties prop;
 //list给空值
 private List listNull;
 public void save(){
  System.out.println("我要 insert 数据--------");
  System.out.println("名字是:"+this.name+"年龄是:"+this.age);
 if(pc!=null){
   //spring 自己使用了bean标签创建了一个对象,假设名字叫a 然后spring 自己讲创建的对象a
   //传递给了内部需要的属性
   System.out.println("spring 使用自己的方式创建了bean对象,但是使用的是spring内部创建对象的方式"+pc.getPname()+"==="+pc.getPtel());
  }
 
 if(person!=null){
  
  System.out.println(person.getPname()+"==="+person.getPtel());
 }
 System.out.println("========集合类,数组,属性类");
 if(list.size()>0){
  for (int i = 0; i < list.size(); i++) {
   System.out.println("list:"+list.get(i));
  }
 }
 
 if(obj.length>0){
  for (int i = 0; i <obj.length; i++) {
   System.out.println("obj数组:"+obj[i]);
  }
  
 }
 
 if(map!=null){
  System.out.println("map对象:"+map.get("key01"));
  System.out.println(map.get("key02"));
 }
 
 if(set!=null && set.size()>0){
  Iterator it=set.iterator();
  while(it.hasNext()){
   System.out.println(it.next());
  }
  
 }
 
 if(prop!=null){
  System.out.println("prop1:"+prop.getProperty("prop1"));
  System.out.println(prop.getProperty("prop2"));
 }
 System.out.println("listNUll的 空值:"+listNull);
}
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Integer getAge() {
  return age;
 }
 public void setAge(Integer age) {
  this.age = age;
 }
 public Person getPerson() {
  return person;
 }
 public void setPerson(Person person) {
  this.person = person;
 }
 public Person getPc() {
  return pc;
 }
 public void setPc(Person pc) {
  this.pc = pc;
 }
 public List getList() {
  return list;
 }
 public void setList(List list) {
  this.list = list;
 }
 public Object[] getObj() {
  return obj;
 }
 public void setObj(Object[] obj) {
  this.obj = obj;
 }
 public Map getMap() {
  return map;
 }
 public void setMap(Map map) {
  this.map = map;
 }
 public Properties getProp() {
  return prop;
 }
 public void setProp(Properties prop) {
  this.prop = prop;
 }
 public List getListNull() {
  return listNull;
 }
 public void setListNull(List listNull) {
  this.listNull = listNull;
 }
 
 
}

-----------------------------------

时间: 2025-01-14 05:32:04

spring -di依赖注入,seter方法的相关文章

Spring DI - 依赖注入

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

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详解(三)------DI依赖注入

上一篇博客我们主要讲解了IOC控制反转,也就是说IOC 让程序员不在关注怎么去创建对象,而是关注与对象创建之后的操作,把对象的创建.初始化.销毁等工作交给spring容器来做.那么创建对象的时候,有可能依赖于其他的对象,即类的属性如何赋值?这也是我们这篇博客讲解 Spring 另一个核心要点:DI依赖注入. PS:本篇博客源码下载链接:http://pan.baidu.com/s/1c2xVUDi密码:v1h3 1.什么是DI依赖注入? spring动态的向某个对象提供它所需要的其他对象.这一点

初识Spring框架实现IOC和DI(依赖注入)

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的, IoC是什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想. 在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转

Spring:(二)DI依赖注入方式

DI 依赖注入 DI(Dependency Injection)依赖注入,说简单一点就将类里面的属性在创建类的过程中给属性赋值,即将对象依赖属性(简单值,集合,对象)通过配置设值给该对象. 属性注入的方式 构造方法的方式 set方法的方式 工厂方法注入 主要学习前两种方式 构造方法的方式 当是构造方法时注入Bean的属性值(简单值,集合,对象) 利用<constructor-arg>标签进行属性的注入 name:被设置属性的名 value:被设置属性的值 编写用构造方法的pojo 1 pack

Spring学习三、Spring配置与DI依赖注入

五.Spring配置 5.1别名 <!-- 别名--> <alias name="user" alias="user2"/> 5.2 Bean的配置 <!-- id : bean的唯一标识符,相当于对象名 class : 全限定名 包名 + 类名 name : 也是别名,name可以同时起多个别名 --> <bean id="userT" class="cn.imut.pojo.User&quo

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

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

【Spring】DI 依赖注入传递参数的方式

DI依赖注入传入参数的方式,这里介绍了基本数据类型,集合,符合数据类型的传递(String类型比较特殊,其传递值和基本数据类型的方法一致) 注入基本数据类型和String类型 通过setter方法注入基本数据类型与String 案例: <bean id="book" class="cn.xdl.bean.Book"> <!-- 对于基本数据类型 与 String的注入操作 通过set方法 ,完成注入 name: 属性的名称 value: 属性要赋的

Spring.NET依赖注入框架学习--注入对象常见方法

Spring.NET依赖注入框架学习---实例化容器常用方法 本篇学习实例化Spring.NET容器的俩种方式 1.通过XmlObjectFactory创建一个Spring.NET容器 IResource input = new FileSystemResource ("objects.xml"); IObjectFactory factory = new XmlObjectFactory(input); 这样就可以通过factory的GetObject(“objectName”);获