Spring之IOC

1、Spring的概述

（spring是什么）

（spring的两大核心）
AOP、IOC
（spring的发展和优势）


（spring体系结构）

2、JDBC程序分析

耦合：程序之间的依赖关系（类之间的依赖、方法之间的依赖）
解耦：降低程序之间的依赖性
实际开发：编译期不依赖 运行期才依赖
解耦的思路：使用反射创建对象避免用new的方式、读取配置文件来获取要创建对象的权限类名

package com.leyou.httpdemo.com.huke.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

/**
 * 程序的耦合
 */
public class JDBC {
  public static void main(String[] args) throws Exception {
    //注册驱动
    //DriverManager.registerDriver(new com.mysql.jdbc.Driver());
    Class.forName("com.mysql.jdbc.Driver");
    //获取连接
    Connection connection = DriverManager.getConnection("jdbc:mysql:localhost:///","root","root");
    //获取操作数据库的预处理对象
    PreparedStatement preparedStatement = connection.prepareStatement("select * from user");
    //执行SQL,得到结果集
    ResultSet resultSet = preparedStatement.executeQuery();
    while(resultSet.next()){
      System.out.println(resultSet.getString("name"));
    }
    //遍历结果集关闭资源
    resultSet.close();
    preparedStatement.close();
    connection.close();
  }
}

3、工厂类

package com.leyou.httpdemo.factory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * bean:在计算机英语中有可重用组件的含义
 * <p>
 * javBean 用java语言编写的可重用组件
 * <p>
 * 它就是创建我们的service和dao对象
 * 1、需要一个配置文件来配置我们的service和dao
 * 配置类容唯一标志：==权限类名（key=value)
 * 2、通过读取配置文件中的配置内容，反射创建对象
 * 配置文件可以是xml也可以是properties
 */
public class BeanFactory {
  //定义一个properties对象
  private static Properties properties;
 //定义一个Map 用于存放我们要创建的对象，我们把他称为容器
  private static Map<String,Object> beans;
  static {
    properties = new Properties();
    InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanFactory.properties");
    try {
      properties.load(resourceAsStream);
      //实例化容器
      beans = new HashMap<>();
      //取出配置文件中的key
      Enumeration<Object> keys = properties.keys();
      while(keys.hasMoreElements()){
        String key = keys.nextElement().toString();
        //根据key获取value
        String property = properties.getProperty(key);
        Object value = Class.forName(property).newInstance();
        beans.put(key,value);
      }
    } catch (IOException | ClassNotFoundException e) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (InstantiationException e) {
      e.printStackTrace();
    }
  }

  /**
   * 根据名称获取对象
   * @param beanName
   * @return
   * @throws ClassNotFoundException
   * @throws IllegalAccessException
   * @throws InstantiationException
   */
  public static Object getBean2(String beanName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {

    return beans.get(beanName);
  }
  public static Object getBean(String beanName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
    Object bean = null;
    String property = properties.getProperty(beanName);
     bean = Class.forName(property).newInstance();
    return bean;
  }
}

4、Spring工厂中的类结构图

BeanFactory与ApplicationContext

5、Spring中Bean的创建方式、作用范围、生命周期

（Bean的创建方式）
使用默认构造函数创建
使用普通工厂中的方法创建

使用工厂中的静态方法创建对象

（Bean的作用范围）
Bean标签的scope属性singleton、prototype、request、session、gloabl-session

（Bean的生命周期）
init、destroy

6、Spring中的依赖注入

（构造函数注入）
constructor-args


（set方法注入）
property标签

（复杂类型注入）