spring框架：IOC、AOP详解

一、IOC

1.IOC的介绍

IOC：（Inverse of Control）控制反转，也叫依赖注入，指的是将对象的创建权交给spring容器创建，利用了工厂模式将对象交给容器管理，只需要在spring配置文件配置相应的bean，以及设置相关的属性，让spring容器来生成类的实例对象以及管理对象。不需要我们自己动手去创建对象，大大的降低了代码之间的耦合度，使资源更加容易管理。

2.IOC容器Bean对象实例化模拟

思路 :

1. 定义 Bean ⼯⼚接⼝，提供获取 bean ⽅法

2. 定义 Bean ⼯⼚接⼝实现类，解析配置⽂件，实例化 Bean 对象

3. 实现获取 Bean ⽅法

2.1定义bean属性对象

package com.itheima.pojo;

public class BeanObject {
    private String id; // bean对象的id属性值
    private String clazz; // bean对象的类路径

    public BeanObject(String id, String clazz) {
        this.id = id;
        this.clazz = clazz;
    }

    public BeanObject() {
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getClazz() {
        return clazz;
    }

    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
}

2.2 添加dom4j坐标依赖

<!-- dom4j -->
<dependency>
 <groupId>dom4j</groupId>
 <artifactId>dom4j</artifactId>
 <version>1.6.1</version>
</dependency>
<!-- XPath -->
<dependency>
 <groupId>jaxen</groupId>
 <artifactId>jaxen</artifactId>
 <version>1.1.6</version>
</dependency>

2.3 准备自定义配置文件

spring.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans>
 <bean id="userService" class="com.itheima.service.UserService"></bean>
 <bean id="accountService" class="com.itheima.service.AccountService"></bean>
</beans>

2.4 定义Bean工厂接口

package com.itheima.spring;

public interface MyFactory {
 // 通过id值获取对象
 public Object getBean(String id);
}

2.5 定义Bean接口的实现类

package com.xxxx.spring;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
    * 模拟Spring的实现
    * 1、通过构造器得到相关配置⽂件
    * 2、通过dom4j解析xml⽂件，得到List 存放id和class
    * 3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过Map<id,Class>             
      存储
    * 4、得到指定的实例化对象
*/
 public class MyClassPathXmlApplicationContext implements BeanFactory {
    private Map beans = new HashMap(); // 实例化后的对象放⼊map
    private List<MyBean> myBeans; // 存放已读取bean 配置信息
   /* 1、通过构造器得到相关配置⽂件 */
    public MyClassPathXmlApplicationContext(String fileName) {
   /* 2、通过dom4j解析xml⽂件，得到List （存放id和class） */
      this.parseXml(fileName);
   /* 3、通过反射实例化得到对象Class.forName(类路径).newInstance(); 通过Map存储 */
      this.instanceBean();
   }
 /**
     * 通过dom4j解析xml⽂件，得到List 存放id和class
     * 1、获取解析器
     * 2、得到配置⽂件的URL
     * 3、通过解析器解析xml⽂件（spring.xml）
     * 4、通过xpath语法，获取beans标签下的所有bean标签
     * 5、通过指定语法解析⽂档对象，返回集合
     * 6、判断集合是否为空，遍历集合
     * 7、获取标签元素中的属性
     * 8、得到Bean对象，将Bean对象设置到集合中
     * @param fileName
 */
  private void parseXml(String fileName) {
   // 1、获取解析器
   SAXReader reader = new SAXReader();
   // 2、得到配置⽂件的URL
   URL url = this.getClass().getClassLoader().getResource(fileName);
   try {
   // 3、通过解析器解析xml⽂件（spring.xml）
     Document document = reader.read(url);
    // 4、通过xpath语法，获取beans标签下的所有bean标签
    XPath xPath = document.createXPath("beans/bean");
    // 通过指定语法解析⽂档对象，返回集合
    List<Element> list = xPath.selectNodes(document);
    // 判断集合是否为空，遍历集合
    if (list != null && list.size() > 0) {
      myBeans = new ArrayList<>();
      for(Element el : list) {
      // 获取标签元素中的属性
      String id = el.attributeValue("id"); // id 属性值
      String clazz = el.attributeValue("class"); // class 属性值
      System.out.println(el.attributeValue("id"));
      System.out.println(el.attributeValue("class"));
      // 得到Bean对象
      MyBean bean = new MyBean(id, clazz);
      // 将Bean对象设置到集合中
      myBeans.add(bean);
      }
    }
  } catch (DocumentException e) {
   e.printStackTrace();
 }

 /**
     * 通过反射实例化得到对象 
     * Class.forName(类的全路径).newInstance(); 
     * 通过Map<id,Class>存储
 */
  private void instanceBean() {
   // 判断bean集合是否为空，不为空遍历得到对应Bean对象
    if (myBeans != null && myBeans.size() > 0) {
      for (MyBean bean : myBeans){ 
        try {
           // 通过类的全路径实例化对象
           Object object = Class.forName(bean.getClazz()).newInstance();
           // 将id与实例化对象设置到map对象中
           beans.put(bean.getId(), object);
       } catch (Exception e) {
          e.printStackTrace();
      }
    }
   }
 }
 /**
 * 通过key获取map中的指定value
 * @param id
 * @return
 */
 @Override
 public Object getBean(String id) {
     Object object = beans.get(id);
     return object;
   }
}

2.6 测试自定义IOC容器

 1. 创建与配置文件中对应的Bean对象