Spring 一二事(5) - 依赖注入

 1     <!-- 依赖注入的装配过程 -->
 2     <bean id="person" class="com.lee.spring007.di.xml.setter.Person">
 3         <property name="pid" value="1001"></property>
 4
 5         <property name="name" value="nathan"></property>
 6
 7         <property name="stu" ref="student"></property>
 8
 9         <property name="list">
10             <list>
11                 <value>a</value>
12                 <value>b</value>
13                 <value>c</value>
14                 <value>d</value>
15                 <value>e</value>
16             </list>
17         </property>
18
19         <property name="map">
20             <map>
21                 <entry key="number" value="111"></entry>
22                 <entry key="bean" value-ref="student"></entry>
23             </map>
24         </property>
25
26         <property name="properties">
27             <props>
28                 <prop key="one">111</prop>
29                 <prop key="two">222</prop>
30                 <prop key="three">333</prop>
31             </props>
32         </property>
33
34         <property name="sets">
35             <set>
36                 <value>11</value>
37                 <ref bean="student" />
38             </set>
39         </property>
40
41         <property name="obj">
42             <list>
43                 <value>a</value>
44                 <value>b</value>
45                 <value>c</value>
46                 <value>d</value>
47                 <value>e</value>
48             </list>
49         </property>
50
51     </bean>
52     <bean id="student" class="com.lee.spring007.di.xml.setter.Student"></bean>
 1 package com.lee.spring007.di.xml.setter;
 2
 3 import java.util.List;
 4 import java.util.Map;
 5 import java.util.Properties;
 6 import java.util.Set;
 7
 8 public class Person {
 9     private int pid;
10     private String name;
11     private Student stu;
12     private List list;
13     private Set sets;
14     private Map map;
15     private Properties properties;
16     private Object[] obj;
17     public int getPid() {
18         return pid;
19     }
20     public void setPid(int pid) {
21         this.pid = pid;
22     }
23     public String getName() {
24         return name;
25     }
26     public void setName(String name) {
27         this.name = name;
28     }
29     public Student getStu() {
30         return stu;
31     }
32     public void setStu(Student stu) {
33         this.stu = stu;
34     }
35     public List getList() {
36         return list;
37     }
38     public void setList(List list) {
39         this.list = list;
40     }
41     public Map getMap() {
42         return map;
43     }
44     public void setMap(Map map) {
45         this.map = map;
46     }
47     public Properties getProperties() {
48         return properties;
49     }
50     public void setProperties(Properties properties) {
51         this.properties = properties;
52     }
53     public Object[] getObj() {
54         return obj;
55     }
56     public void setObj(Object[] obj) {
57         this.obj = obj;
58     }
59     public Set getSets() {
60         return sets;
61     }
62     public void setSets(Set sets) {
63         this.sets = sets;
64     }
65
66 }
1 package com.lee.spring007.di.xml.setter;
2
3 public class Student {
4
5     public static void say() {
6         System.out.println("I am a student!");
7     }
8 }

github地址:https://github.com/leechenxiang/maven-spring001-helloworld

时间: 2024-09-29 18:57:09

Spring 一二事(5) - 依赖注入的相关文章

采用Spring管理Bean和依赖注入

1.实例化spring容器 和 从容器获取Bean目标 实例化Spring容器常用的两种办法: 办法一: 在类途径下寻觅配置文件来实例化容器 [引荐运用] ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"}); 办法二: 在文件体系途径下寻觅配置文件来实例化容器 [这种办法能够在开发期间运用] ApplicationContext ctx = new FileSyst

Spring quartz Job不能依赖注入,Spring整合quartz Job任务不能注入

Spring quartz Job不能依赖注入,Spring整合quartz Job任务不能注入 Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ©Copyright 蕃薯耀 2017年9月6日 http://ww

(转)Spring读书笔记-----Spring核心机制:依赖注入

Java应用(从applets的小范围到全套n层服务端企业应用)是一种典型的依赖型应用,它就是由一些互相适当地协作的对象构成的.因此,我们说这些对象间存在依赖关系.加入A组件调用了B组件的方法,我们就可以称A组件依赖于B组件.我们通过使用依赖注入,Java EE应用中的各种组件不需要以硬编码方式耦合在一起,甚至无需使用工厂模式.当某个Java 实例需要其他Java 实例时,系统自动提供所需要的实例,无需程序显示获取,这种自动提供java实例我们谓之为依赖注入,也可以称之为控制反转(Inversi

回客科技 面试的 实现ioc 容器用到的技术,简述BeanFactory的实现原理,大搜车面试的 spring 怎么实现的依赖注入(DI)

前言:这几天的面试,感觉自己对spring 的整个掌握还是很薄弱.所以需要继续加强. 这里说明一下spring的这几个面试题,但是实际的感觉还是不对的,这种问题我认为需要真正读了spring的源码后说出来的东西才有意义.这种面试的问法,也只能是面试的问法,对实际的掌握还是没有丝毫意义的.所以我认为 有机会一定要读下spring的源码 来过一遍 具体实现,这样的才是有意义的做法.同意的请举手. 这里说明一下这三个spring 面试问题: 1.回客科技 面试的 实现ioc 容器用到的技术 第1种 说

如何把对象手动注入Spring容器并实现依赖注入

将对象注入到Spring容器并实现依赖注入 public class UserDao { @Resource AccountService accountService; public void print(){ System.out.println(accountService); } } 比如有以上这个类,实现将new UserDao()放入Spring容器中(放入工作由DefaultListableBeanFactory完成),并且AccountService会自动注入(注入工作由Auto

Spring学习一(依赖注入/Bean/注解等)

1.Spring依赖注入的方式. 2.依赖注入的类型 3.Bean的作用域 4.自动注入 5.使用注解的方式 6.在spring配置文件中引入属性文件 1.Spring依赖注入的方式 平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理. spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是“

Spring控制反转与依赖注入(IOC、DI)

IOC: 反转控制   Inverse Of Control DI:依赖注入 Dependency Injection 目的:完成程序的解耦合 解释:在应用系统的开发过程中,有spring负责对象的创建,对象依赖关系的组装,对象属性的初始化,程序员只需要在程序接收spring创建的对象即可. Object obj= new Object(); IOC :  Object obj;  等着接收spring容器创建好的对象,在程序中将对象的创建的权限交出,反转到spring容器中. DI:  某个对

Spring初学之泛型依赖注入

主要讲泛型依赖注入,所以核心在java文件,配置文件中只需配置扫描包即可,如下: <?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:context

Spring它不支持依赖注入static静态变量

在springframework在,我们不能@Autowired静态变量,制作spring bean,例如,没有那么: @Autowired private static YourClass yourClass; 可以试一下,yourClass在这样的状态下不可以被依赖注入,会抛出执行时异常java.lang.NullPointerException,为什么呢?静态变量/类变量不是对象的属性,而是一个类的属性,spring则是基于对象层面上的依赖注入. 而使用静态变量/类变量扩大了静态方法的使用