Spring IOC基础使用

先下载、导入核心jar包

编写Book类和CollectionUse类

 1 package MyPackageOne;
 2
 3 public class Book {
 4     private String title;
 5     private double price;
 6
 7     public Book() {
 8         this("", 0.0);
 9     }
10
11     public Book(String title, double price) {
12         this.title = title;
13         this.price = price;
14     }
15
16     public String getTitle() {
17         return title;
18     }
19
20     public void setTitle(String title) {
21         this.title = title;
22     }
23
24     public double getPrice() {
25         return price;
26     }
27
28     public void setPrice(double price) {
29         this.price = price;
30     }
31
32     @Override
33     public String toString() {
34         return "title: " + title + ", price: " + price;
35     }
36 }

 1 package MyPackageOne;
 2
 3 import java.lang.reflect.Array;
 4 import java.util.Arrays;
 5 import java.util.List;
 6 import java.util.Map;
 7 import java.util.Set;
 8
 9 public class CollectionUse {
10     private List<String> stringList;
11     private String[] strings;
12     private Set<String> stringSet;
13     private Map<String, String> stringStringMap;
14
15     public List<String> getStringList() {
16         return stringList;
17     }
18
19     public void setStringList(List<String> stringList) {
20         this.stringList = stringList;
21     }
22
23     public String[] getStrings() {
24         return strings;
25     }
26
27     public void setStrings(String[] strings) {
28         this.strings = strings;
29     }
30
31     public Set<String> getStringSet() {
32         return stringSet;
33     }
34
35     public void setStringSet(Set<String> stringSet) {
36         this.stringSet = stringSet;
37     }
38
39     public Map<String, String> getStringStringMap() {
40         return stringStringMap;
41     }
42
43     public void setStringStringMap(Map<String, String> stringStringMap) {
44         this.stringStringMap = stringStringMap;
45     }
46
47     @Override
48     public String toString() {
49         return "CollectionUse{" +
50                 "stringList=" + stringList +
51                 ", strings=" + Arrays.toString(strings) +
52                 ", stringSet=" + stringSet +
53                 ", stringStringMap=" + stringStringMap +
54                 ‘}‘;
55     }
56 }

在applicationContext.xml中写好类实例

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 5     <bean id="bookOne" class="MyPackageOne.Book">
 6         <property name="title" value="java"></property>
 7         <property name="price" value="15.2"></property>
 8     </bean>
 9     <bean id="collectionUseOne" class="MyPackageOne.CollectionUse">
10         <property name="stringList">
11             <list>
12                 <value>帅气的我list</value>
13                 <value>勇气的我list</value>
14                 <value>厉害的我list</value>
15                 <value>无敌的我list</value>
16                 <value>666的我list</value>
17             </list>
18         </property>
19         <property name="strings">
20             <array>
21                 <value>帅气的我string</value>
22                 <value>勇气的我string</value>
23                 <value>厉害的我string</value>
24                 <value>无敌的我string</value>
25                 <value>666的我string</value>
26             </array>
27         </property>
28         <property name="stringSet">
29             <set>
30                 <value>帅气的我set</value>
31                 <value>勇气的我set</value>
32                 <value>厉害的我set</value>
33                 <value>无敌的我set</value>
34                 <value>666的我set</value>
35             </set>
36         </property>
37         <property name="stringStringMap">
38             <map>
39                 <entry>
40                     <key><value>name</value></key>
41                     <value>无敌</value>
42                 </entry>
43                 <entry>
44                     <key><value>你好啊</value></key>
45                     <value>enen</value>
46                 </entry>
47             </map>
48         </property>
49     </bean>
50 </beans>

主函数中观察获取结果:

1 ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
2 Book bookOne = (Book) ac.getBean("bookOne");
3 System.out.println(bookOne);
4 CollectionUse cu = (CollectionUse) ac.getBean("collectionUseOne");
5 System.out.println(cu);

原文地址:https://www.cnblogs.com/sqdtss/p/9911191.html

时间: 2024-10-18 00:32:02

Spring IOC基础使用的相关文章

Spring ioc基础内容

1 BeanFactory与ApplicationContext区别 BeanFactory是Spring框架中IoC容器的顶层接?,它只是?来定义?些基础功能,定义?些基础规范,?ApplicationContext是它的?个?接?,所以ApplicationContext是具备BeanFactory提供的全部功能的.通常,我们称BeanFactory为SpringIOC的基础容器,ApplicationContext是容器的?级接?,?BeanFactory要拥有更多的功能,?如说国际化?持

浅析 Spring IoC - 基础概念

1. IoC是什么? IoC(Inversion of Control)即控制反转,不是什么技术,而是一种设计思想.在Java开发中,IoC 意味着将你设计好的对象交给容器去控制,而不是传统的在对象内部直接控制(比如说 new 一个对象).理解好 IoC 的关键是要明确"谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了": 谁控制谁,控制什么:传统Java SE 程序设计,我们直接在对象内部通过 new 创建对象,是程序主动去创建依赖对象:而 IoC 是由 IoC

[spring] Ioc 基础

Ioc的理解:调用类对某一接口的实现类的依赖关系又第三方注入,以移除调用类对接口实现类的依赖.又叫做依赖注入.调用者对接口的选择权利被剥夺,交给了第三方.举个例子,学生本来可以选择哪个老师给他上课的,但是这个权利被学校剥夺了,由学校分配学生的老师是谁. Ioc的类型: 构造函数:将依赖的对象通过构造函数注入.第三方将需要的对象准备好,在创建对象时通过构造函数传参注入所需对象 属性:声明依赖的对象,并提供setter/getter方法.第三方通过set方法注入. 接口:将依赖的对象抽象到接口中,通

Spring IOC基础

2.1.1 IOC是什么IOC—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想.在Java开发中,IOC意味着将你设计好的对象交给容器控制,而不是传统的在你的对 象内部直接控制.如何理解好IOC呢?理解好IOC的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们 来深入分析一下: ●谁控制谁,控制什么:传统Java SE程序设计,我们直接在对象内部通过new进行创建对象,是程序主动去创建依赖对象:而IOC是有专

spring学习——Ioc基础三(Ioc配置使用)

一.XML配置的结构  一般配置文件结构如下: <beans>       <import resource="resource1.xml"/>       <bean id="bean1"class=""></bean>       <bean id="bean2"class=""></bean>   <bean name=&q

Spring -- IOC/DI 基础概念的理解

Spring -- IOC/DI 基础概念 思维导图: ------------------------------------------------------- IoC/DI 的基本概念 IoC是什么 ? IoC -- Inversion of control, 控制反转   在Java开发中,IoC意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制.IoC是一种让服务消费者不直接依赖于服务提供者的组件设计方式,是一种减少类与类之间依赖的设计原则. 理解IoC的关键是明

spring IOC的基础

IOC的基础下面我们从IOC/AOP开始,它们是Spring平台实现的核心部分:虽然,我们一开始大多只是在这个层面上,做一些配置和外部特性的使用工 作,但对这两个核心模块工作原理和运作机制的理解,对深入理解Spring平台,却是至关重要的:因为,它们同时也是Spring其他模块实现的基础.从 Spring要做到的目标,也就是从简化Java EE开发的出发点来看,简单的来说,它是通过对POJO开发的支持,来具体实现的:具体的说,Spring通过为应用开发提供基于POJO的开发模式,把 应用开发和复

spring学习——Ioc基础二

一.IoC容器的概念 IoC容器就是具有依赖注入功能的容器,IoC容器负责实例化.定位.配置应用程序中的对象及建立这些对象间的依赖.应用程序无需直接在代码中new相关的对象,应用程序由IoC容器进行组装.在Spring中BeanFactory是IoC容器的实际代表者. Spring IoC容器如何知道哪些是它管理的对象呢?这就需要配置文件,Spring IoC容器通过读取配置文件中的配置元数据,通过元数据对应用中的各个对象进行实例化及装配.一般使用基于xml配置文件进行配置元数据,而且Sprin

Spring IOC之IOC基础

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) .DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC .DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解. 首先要分享的是Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂,以下内容全部来自原文,原文地址:http://jinnianshilongnian.iteye.com/bl