Spring框架：核心IOC，使用配置文件

Spring介绍：
1.Spring是分层的轻量级开源框架。
2.Spring核心是IOC（控制反转）和AOP（面向切面编程）。
3.Spring提供了对各种优秀框架的支持和整合。
4.Spring框架采用分层框架，根据不同的功能被划分成了多个模块，结构清晰。

Spring优点：
1.IOC解耦：可以将对象间的依赖关系交由spring管理，避免硬编码造成的程序间过渡耦合。
2.支持AOP：可以使用切面编程思想对方法进行增强。
3.支持声明式事务：可以通过配置或者注解的方式管理事务，不需要硬编码管理事务。

IOC容器概念：
什么是IOC：
1.英文名称：IOC（Inversion Of Control）中文名称：控制反转。
2.将对象的创建（控制）转交给第三方（工厂）完成则称为控制反转

IOC的作用：
1.解耦：利用IOC的工厂模式解耦创建对象的过程。（解决代码耦合度过高问题）
2.存储对象：可以将创建好的对象存储起来重复使用。（解决对象个数问题）
3.管理依赖关系：可以将依赖对象注入需要的对象当中。（解决依赖关系问题）

创建对象：
Spring核心配置文件：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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建对象, 还需要加入到IOC容器中 -->
    <!--
        bean: 创建对象并且加入到IOC容器中
            id: 可选项: 对象名称
            class: 必选项: 对象的字节码路径
    -->
    <bean id="user" class="类全名字符串"></bean>
</beans>

创建IOC容器并从容器中获取对象：
示例代码：

public class IocTests {
    public static void main(String[] args) {
        // 1. 创建容器，这里就已经通过默认的构造方法创建了对象并放入到容器中，加载配置文件里的bean标签时<bean></bean>
        ClassPathXmlApplicationContext ioc =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 使用对象,从容器中拿对象来使用
        Object user = ioc.getBean("user");
        System.out.println(user);// null?没有创建:已经创建
    }
}

Bean标签常用属性：

属性	说明
id	对象的引用名称;一定要唯一； 一次只能定义一个引用名称
name	对象的引用名称; 与id区别是：name一次可以定义多个引用名称。
class	类的全限定名称
destroy-method	指定类中销毁方法名称，在销毁spring容器前执行
init-method	指定类中初始化方法的名称，在构造方法执行完毕后立即执行
lazy-init	设置为true表示在第一次使用对象的时候才创建，只对单例对象有效。

IOC容器单例对象与多例对象的区别：
1.单例对象只会创建一个的对象,多例对象每次请求都会创建新的对象。
2. 单列对象在创建容器时创建，多例对象在使用对象时创建。

IOC容器的三种创建方式：
资源文件创建方式：

ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

系统文件创建方式：

FileSystemXmlApplicationContext context = new FileSystemXmlApplicationContext("配置文件的绝对路径");

注解配置创建方式：
创建配置类，目的用来取代配置文件

@Configuration
public class SpringConfig {
    @Bean
    public User createUser(){
        return new User();
    }
}

测试代码：

@Test
public void testAnnotation() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
}

依赖注入概念：（简称：DI）
简单记忆：就是给对象的成员变量（属性）赋值。
依赖注入的两种方式：通过有参构造方法赋值或者通过setter方法赋值。
通过构造方法赋值：
配置注入：applicationContext.xml

<!-- 第一种: 构造方法注入 -->
<bean class="类全名字符串">
  <!-- constructor-arg: 调用构造方法创建对象(如果不写任何内容表示调用无参构造方法) -->
  <constructor-arg name="id" value="1"/>
  <!--
     name: 属性名称
     index: 索引: 参数列表的下标位置
     value: 赋值的内容
  -->
  <constructor-arg index="1" value="Jason1"/>
  ..........
</bean>

setter方法赋值：(常用)

<!-- 第二种: set方法注入 -->
<bean class="类全名字符串">
  <!-- property: 调用set方法给对象赋值 name="实体类的成员变量名" -->
  <property name="id" value="2"/>
  <property name="name" value="Jason2"/>
  .........
</bean>

DI注入对象：使用：ref=“对象名称”
演示：

<!-- 演示: 注入对象
    1. 需要先准备对象: str
    2. 然后将对象注入到其他对象中
-->
<bean id="str" class="java.lang.String">
  <!-- value: 赋值一个固定的参数值 -->
  <constructor-arg value="Jason6"/>
</bean>
<bean class="entity.Person">
  <!-- ref: 引用一个已经存在的对象 -->
  <property name="name" ref="str"/>
</bean>

ref属性的作用是什么?：引用一个已经存在的对象给成员变量赋值。

DI注入集合：
实体类：

public class Employee {

    private String[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String, String> map;
    private Properties props;

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProps(Properties props) {
        this.props = props;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "array=" + Arrays.toString(array) +
                ", list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", props=" + props +
                '}';
    }
}

演示注入集合：

<!-- 演示: 注入集合的属性值 -->
<bean class="entity.Employee">
  <!-- name： 需要注入的属性名称 -->
  <property name="array">
    <!-- array: 需要注入的属性类型 -->
    <array>
      <value>1</value>
      <value>2</value>
      <value>3</value>
    </array>
  </property>
  <property name="list">
    <list>
      <value>4</value>
      <value>5</value>
    </list>
  </property>
  <property name="set">
    <set>
      <value>6</value>
    </set>
  </property>
  <property name="map">
    <map>
      <entry key="id" value="7"/>
      <entry key="name" value="Jason7"/>
    </map>
  </property>
  <property name="props">
    <props>
      <prop key="id">8</prop>
      <prop key="name">Jason8</prop>
    </props>
  </property>
</bean>

小结：

1. 注入数组语法：

<array>
     <value>具体的值</value>
     .....
	 </array>

2. 注入List集合语法：

<list>
    <value>具体的值</value>
    .....
	</list

3. 注入Set集合语法：

<set>
  <value>具体的值</value>
    .....
	</set>

4. 注入Map集合语法：

<map>
		<entry key="键" value="值"></entry>
    .....
	</map>

5. 注入Properties集合语法：

<props>
		<prop key="键">值</prop>
    ............
	</props>