一、什么是IoC
IOC（Inversion of Control）控制反转，是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
传统的创建对象是根据关键字new来创建，而Spring则通过IOC容器来创建，也就是我们将对象的控制权交给了IOC容器，IOC 让程序员不在关注怎么去创建对象，而是关注与对象创建之后的操作，把对象的创建、初始化、销毁等工作交给spring容器来做。
**DI(Dependency Injection) **— IOC 的另一种表述方式：即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言，这种表述更直接。
二、IOC实现原理
IOC--采用反转控制
原理图
三、Spring开发环境的搭建
1.创建工程，导入相应的jar包（如下图）
项目结构图
2.Spring入门项目
（1）创建HelloWorld类
package com.sunbx.cn;
public class HelloWorld {
private String user;
public void setUser(String user) {
public void hello() {
System.out.println("Hello: " + user);
}
}
(2)利用默认的构造方法，在 src 目录下新建 applicationContext.xml 文件，这是 spring 配置文件，添加代码如下：
<?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-4.0.xsd">
<!--id:类的唯一标识符，具有唯一性
class：类的全类名
-->
<bean id="helloworld" class="com.sunbx.cn.HelloWorld">
<property name="user" value="Spring"></property>
</bean>
</beans>
(3)测试类HelloWorldTest，代码如下：
package com.test.cn;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.sunbx.cn.Car;
import com.sunbx.cn.HelloWorld;
public class HelloWorldTest {
public static void main(String[] args) {
ApplicationContext ctx =
new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorld helloworld = (HelloWorld) ctx.getBean(HelloWorld.class);
System.out.println(helloworld);
}
}
测试结果
Spring依赖注入的方式
1.Spring支持的依赖注入方式有三种
（1）属性注入
（2）构造方法注入
（3）工厂方法注入（很少使用，不推荐）
2.前两种方法举例
（1）属性注入
属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象,属性注入使用 <property> 元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 <value> 子节点指定属性值 。
创建一个Person类，代码如下：
package com.sunbx.cn;
public class Person {
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class Person {
private Long pid;
private String pname;
private Student students;
private List lists;
private Set sets;
private Map maps;
private Properties properties;
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 getStudents() {
return students;
}
public void setStudents(Student students) {
this.students = students;
}
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 getMaps() {
return maps;
}
public void setMaps(Map maps) {
this.maps = maps;
}
public Properties getProperties() {
return properties;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
}
在 applicationContext.xml 中进行赋值
<!--
property是用来描述一个类的属性
基本类型的封装类、String等需要值的类型用value赋值
引用类型用ref赋值
-->
<bean id="person" class="com.sunbx.Person">
<property name="pid" value="1"></property>
<property name="pname" value="vae"></property>
<property name="students">
<ref bean="student"/>
</property>
<property name="lists">
<list>
<value>1</value>
<ref bean="student"/>
<value>vae</value>
</list>
</property>
<property name="sets">
<set>
<value>1</value>
<ref bean="student"/>
<value>vae</value>
</set>
</property>
<property name="maps">
<map>
<entry key="m1" value="1"></entry>
<entry key="m2" >
<ref bean="student"/>
</entry>
</map>
</property>
<property name="properties">
<props>
<prop key="p1">p1</prop>
<prop key="p2">p2</prop>
</props>
</property>
</bean>
<bean id="student" class="com.sunbx.Student"></bean>
测试代码：
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) context.getBean("person");
System.out.println(person.getPname());
}
（2）构造方法注入
通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。
构造器注入在 <constructor-arg> 元素里声明属性, <constructor-arg> 中没有 name 属性。
创建Car类，代码如下：
package com.sunbx.cn;
public class Car {
private String name;
private String count;
private int monery;
private float monery2;
public Car(String name,String count,int monery ){
super();
this.name = name;
this.count = count;
this.monery = monery;
}
public Car(String name,String count,float monery2 ){
super();
this.name = name;
this.count = count;
this.monery2 = monery2;
}
public Car(String name,String count, int monery, float monery2 ){
super();
this.name = name;
this.count = count;
this.monery = monery;
this.monery2 = monery2;
}
@Override
public String toString() {
return "Car [name=" + name + ", count=" + count + ", monery=" + monery + ", monery2=" + monery2 + "]";
}
}
在 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-4.0.xsd">
<!-- 构造法注入 -->
<bean id="car" class="com.sunbx.cn.Car">
<constructor-arg value="Audi" type="java.lang.String"></constructor-arg>
<constructor-arg value="China" type="java.lang.String"></constructor-arg>
<constructor-arg value="123" type="int"></constructor-arg>
</bean>
</beans>
测试代码如下：
package com.test.cn;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.sunbx.cn.Car;
import com.sunbx.cn.HelloWorld;
public class CarTest {
public static void main(String[] args) {
ApplicationContext ctx =
new ClassPathXmlApplicationContext("applicationContext.xml");
Car car = (Car) ctx.getBean("car");
System.out.println(car);
}
}
技术菜鸟，希望慢慢提高，持续进步！
