Spring IOC

什么是Spring IOC

     控制反转(Inversion of Control)IOC,简单来说，就是由容器控制程序之间的依赖关系，而非传统的实现，由程序代码之间操作。
     控制反转的概念：（依赖）控制权由应用代码转到了外部容器，控制权的转移，这就是所谓的反转。
     IOC还有一个名字，依赖注入(Dependency Injection)DI:由容器动态的将依赖关系注入到组件中。

案例：实现Spring IOC

(注意 我是没有用Spring IDE插件的)
第一步：配置Spring相关依赖，pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>Tsp_Demo</groupId>
  <artifactId>tsp</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>tsp</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.1.RELEASE</version>
    </dependency>
   
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.1.RELEASE</version>
    </dependency>
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.0.1.RELEASE</version>
    </dependency>
 
    <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.1.RELEASE</version>
    </dependency>
  
  </dependencies>
</project>

第二步：插件Spring的XML文件(需要添加beans/tx/aop/context的支持)

<?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="http://www.springframework.org/schema/context"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd  
        http://www.springframework.org/schema/task
        http://www.springframework.org/schema/task/spring-task-3.0.xsd">


</beans>

第三步：创建一个User类

package com.action;

public class User {
	
	private int id;
	private String name;
	
	
	public User(){
		System.out.println("holle world");
	}
	
	public int getId(){
		return this.id;
	}
	
	public void setId(int id){
		this.id = id;
	}
	
	public String getName(){
		return this.name;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
}

配置一个JavaBean

       在JavaBean文章中我们就讲过了，要创建一个JavaBean类，该类必须是公共的，属性私有的，属性方法是公共的，必须是无参构造函数，修改属性的方法以set小写开头，读取属性的方法必须以get小写开头。

如何在spring中定义

• id：在容器中查找Bean（对象）的id；（唯一，不能以/开头）
• class：Bean（对象）完整类名；
• name：在容器中查找Bean（对象）的名字；（唯一，可以以/开头，可以设置多个名字，多个名字以逗号或者空格分开）
• scope：(singleton|prototype)默认为singleton。
• • singleton(单例模式)：在每个Spring Ioc容器中一个Bean定义对应一个对象实例。
• • prototype(原型模式/多列模式)：一个Bean定义对应多个对象实例。
• abstract：将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean
• parent：指定一个父bean(必须要有继承关系才行)
• init-method：指定bean对象（）的初始化方法
• 使用有参数构造方法创建javaBean（java对象）：constructor-arg

第四步：在xml文件中创建一个bean（不懂bean属性的看上面）

<bean id="User" class="com.action.User" scope="singleton" autowire="byName" lazy-init="true">
    <property name = "id" value="1"/>
    <property name = "name" value="二傻"/>
</bean>

第五步：写一个测试类

public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/config/spring.xml");
		User user = (User)applicationContext.getBean("User");
		User user1 = (User)applicationContext.getBean("User");
		System.out.println(user.getName());
		System.out.println(user1.getName());
}

结果：

holle world	
二傻
二傻

我是用的singleton（单例模式），当我第二次注入bean的时候没有打印 holle world 这说明第二次没有再创建对象了。

JavaBean的属性配置

简单的属性配置

• 八大基本数据类型
• String
• java.util.Date java.sql.Date java.sql.Time java.sql.Timestamp

这用value赋值就行了

复杂的属性配置

• JavaBena ref bean = “”;
• 数组和List
• Map
• Properties

例子：

package com.action;

import java.util.List;
import java.util.Map;

import com.sun.xml.internal.fastinfoset.sax.Properties;

public class Text {
	
	private String []arr;
	private List list;
	private Map map;
	private Properties properties;
	public String[] getArr() {
		return arr;
	}
	public void setArr(String[] arr) {
		this.arr = arr;
	}
	public List getList() {
		return list;
	}
	public void setList(List list) {
		this.list = list;
	}
	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;
	}
}

xml:

<bean id = "Text" class="com.action.Text">
    <property name="arr">
        <list>
            <value>aa</value>
            <value>bb</value>
        </list>
    </property>
    <property name="list">
        <list>
            <value>cc</value>
            <value>dd</value>
        </list>
    </property>
    
    <property name="map">
        <map>
            <entry>
                <key>
                    <value>t1</value>
                </key>
                <value>二傻</value>
            </entry>
        </map>
    </property>
    
</bean>

测试类:

public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/config/spring.xml");

		Text text = (Text)applicationContext.getBean("Text");
		List list = text.getList();
		System.out.println("list:"+list.toString());
		
		Map map = text.getMap();
		System.out.println("map:"+map.toString());
		
		String[] arr = text.getArr();
		System.out.println("arr:"+arr[0]);
	}

结果：

list:[cc, dd]
map:{t1=二傻}
arr:aa