标签：amp cas 处理 不同 instance string 核心 并且 存在
在没有IOC容器的情况下，如果我们需要某个类具体的操作如下所示:
传统的Bean创建
首先在这里强调一下IOC不是Spring提出来了，在Spring之前就已经有人提出了IOC思想，只不过在Spring之前都是偏理论化没有一个具体的落地方案，Spring在技术层面把IOC思想体现的淋漓尽致。
从上图可知:
在理解控制反转之前我们首先要清楚控制是指什么？ 反转又反转了什么？
将到IOC肯定会有人想到DI(Dependancy Injection)依赖注入，那这两者有什么不同和相同呢？
小伙伴们看到这里其实对IOC容器已经有了一定的了解。那如果在面试的过程中面试官问你如何实现一个自定义的IOC容器。你可以讲出的具体思路嘛？ 可以先想一想在继续往下看，看看是不是和自己的想发不谋而合。
思路大致如下所示:
<?xml version="1.0" encoding="UTF-8" ?>
<!--跟标签beans，里面配置一个又一个的bean子标签，每一个bean子标签都代表一个类的配置-->
<beans>
<!--id标识对象，class是类的全限定类名-->
<bean id="orderDao" class="com.customize.spring.dao.impl.OrderDaoImpl">
</bean>
<bean id="stockDao" class="com.customize.spring.dao.impl.StockDaoImpl">
</bean>
<bean id="orderService" class="com.customize.spring.service.impl.OrderServiceImpl">
<!--通过set方法注入-->
<property name="setOrderDao" ref="orderDao"></property>
<property name="setStockDao" ref="stockDao"></property>
</bean>
</beans>
public class BeanFactory {
/**
* 存放对象
*/
private static Map<String, Object> map = new ConcurrentHashMap<>();
/**
* 对外提供的接口
* @param id
* @return
*/
public static Object getBean(String id) {
return map.get(id);
}
static {
// 只加载一次就是在BeanFactory初始化的时候去加载类
// 任务一：读取解析xml，通过反射技术实例化对象并且存储待用（map集合）
System.out.println("开始加载Bean对象");
// 加载xml
InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
// 解析xml
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(resourceAsStream);
Element rootElement = document.getRootElement();
List<Element> beanList = rootElement.selectNodes("//bean");
for (int i = 0; i < beanList.size(); i++) {
Element element = beanList.get(i);
// 处理每个bean元素，获取到该元素的id 和 class 属性
String id = element.attributeValue("id");
String clazz = element.attributeValue("class");
// 通过反射技术实例化对象
Class<?> aClass = Class.forName(clazz);
Object o = aClass.newInstance();
// 存储到map中待用
map.put(id,o);
}
// 实例化完成之后维护对象的依赖关系，检查哪些对象需要传值进入，根据它的配置，我们传入相应的值
// 有property子元素的bean就有传值需求
List<Element> propertyList = rootElement.selectNodes("//property");
// 解析property，获取父元素
for (int i = 0; i < propertyList.size(); i++) {
Element element = propertyList.get(i);
String name = element.attributeValue("name");
String ref = element.attributeValue("ref");
// 找到当前需要被处理依赖关系的bean
Element parent = element.getParent();
// 调用父元素对象的反射功能
String parentId = parent.attributeValue("id");
Object parentObject = map.get(parentId);
// 遍历父对象中的所有方法，找到set 方法
Method[] methods = parentObject.getClass().getMethods();
for (int j = 0; j < methods.length; j++) {
Method method = methods[j];
// 该方法就是 set 方法
if(method.getName().equalsIgnoreCase(name)) {
method.invoke(parentObject,map.get(ref));
}
}
// 把处理之后的parentObject重新放到map中
map.put(parentId,parentObject);
}
System.out.println("加载完毕,Map中的Bean对象个数为:" + map.size());
} catch (Exception e) {
e.printStackTrace();
}
}
}
public class OrderServiceImpl implements OrderService {
private OrderDao orderDao;
private StockDao stockDao;
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
public void setStockDao(StockDao stockDao) {
this.stockDao = stockDao;
}
@Override
public void order(Order order) {
// 没有IOC容器的情况下
// OrderDao orderDao = new OrderDaoImpl();
// // 保存订单
// orderDao.save(order);
//
// //扣除库存
// StockDao stockDao = new StockDaoImpl();
// stockDao.subStock(order.getName());
// 有IOC容器的基础上
orderDao.save(order);
//扣除库存
stockDao.subStock(order.getName());
System.out.println("下单成功");
}
}
启动
测试
有帮忙到你记得点个小星星哦。
抛开Spring去理解IOC思想 - 原来IOC容器这么简单
标签：amp cas 处理 不同 instance string 核心 并且 存在
原文地址：https://www.cnblogs.com/karlMa/p/12823052.html
