SpringIOC实战篇

IoC（控制反转）是Spring框架的核心，通过DI（依赖注入）实现对象创建和依赖管理的自动化。Spring本质上就是一个Bean容器，负责完成对象的创建和依赖的注入

Spring

所谓控制反转，就是把原先我们代码里面需要实现的对象（bean）创建、依赖的代码，反转给ioc容器来帮忙实现，也就是 ioc 容器帮我们做了原本应该我门自己实现的对象创建和依赖的内容。

我们有一个业务逻辑模块 UserService 和一个实体类 User 还有一个持久层模块 UserDAO 和它的实现 UserDAOImpl。
他们之间 UserService 调用（依赖）UserDAO 来操作数据库。我们在test 中运行的时候呢，要创建 UserService 和 UserDAO 并将 UserDAO set 到 UserService 中，这是我门正常的逻辑。

好了、现在我们要用自己编写的简单的ioc 来处理这些关系。

一、项目结构

1	### 二、导入Maven依赖的jar包(pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<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>com.study</groupId>
    <artifactId>simple-springioc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>jdom</groupId>
            <artifactId>jdom</artifactId>
            <version>1.0</version>
        </dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
    </dependencies>
</project>

`### 三、编写bean.xml```xml
<beans>
    <bean id="u" class="com.study.dao.impl.UserDAOImpl" />
   <!--依赖注入，自动装配-->
    <bean id="userService" class="com.study.service.UserService" >
        <property name="userDAO" bean="u"/>
    </bean>

</beans>

三、创建BeanFactory接口

创建一个BeanFactory接口用来创建bean （模拟spring）

package com.study.spring;

/**
 * @author Howe Hsiang
 */
public interface BeanFactory {
    Object getBean(String name);
}

四、创建ClassPathXmlApplicationContext实现类

创建一个用来处理xml的类ClassPathXmlApplicationContext （也是模拟spring）

1
2
3

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

1 2	/** * @author Howe Hsiang

1 2	public class ClassPathXmlApplicationContext implements BeanFactory { private Map<String, Object> beans = new HashMap<String, Object>();

public ClassPathXmlApplicationContext() throws Exception {
    //解析xml 利用反射生成 bean
    SAXBuilder sb = new SAXBuilder();
    Document doc = sb.build("src/main/resources/bean.xml"); //构造文档对象
    Element root = doc.getRootElement(); //获取根元素
    List list = root.getChildren("bean");//取名字为disk的所有元素
    for (int i = 0; i < list.size(); i++) {
        Element element = (Element) list.get(i);
        String id = element.getAttributeValue("id");
        String className = element.getAttributeValue("class");//取disk子元素capacity的内容
        System.out.println("id : " + id + " className : " + className);
        Object o = Class.forName(className).newInstance();
        beans.put(id, o);

//依赖注入，自动装配 xml 的第二层
for (Element propertyElement : (List<Element>) element.getChildren("property")) {
    String name = propertyElement.getAttributeValue("name"); //userDAO
    String bean = propertyElement.getAttributeValue("bean"); //u
    Object beanObj = beans.get(bean);//UserDAOImpl instance

1
2
3

//拼出setUserDAO方法名字
String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
System.out.println("methodName : " + methodName);

// methodName 为方法名  beanObj.getClass().getInterfaces()[0]  为方法的参数 反射取出方法
// beanObj.getClass().getInterfaces()[0] 为 beanObj  实现的第一个接口 也就是 UserDao 为方法的参数
// beanObj 为 UserDAOImpl.class 因为xml 中 bean u 配置的 class 为 UserDAOImpl
Method m = o.getClass().getMethod(methodName, beanObj.getClass().getInterfaces()[0]);

// 进行注入
// 代理执行 m 方法， 也就是用 o 这个对象 调用 m 方法 参数 为 beanObj
// o.m(beanObj) 等价于 userService.setUserDao(userDao)
m.invoke(o, beanObj);

1 2	public Object getBean(String name) { return beans.get(name);

`### 六、测试类UserServiceTest```java

1	package com.study.service;

import com.study.aop.LogInterceptor;
import com.study.dao.UserDAO;
import com.study.dao.impl.UserDAOImpl;
import com.study.model.User;
import com.study.spring.BeanFactory;
import com.study.spring.ClassPathXmlApplicationContext;
import org.junit.Test;

1	import java.lang.reflect.Proxy;

/**

1	public class UserServiceTest {

1 2	@Test public void testAdd() throws Exception {

        BeanFactory factory = new ClassPathXmlApplicationContext();
        // 自动创建 bean
//		UserDAO userDAO = (UserDAO)factory.getBean("u");
//		UserService userService = new UserService(userDAO);

1
2
3

//依赖注入，自动装配
UserService userService = (UserService) factory.getBean("userService");
userService.add(new User());

//通过jdk 的动态代理实现
@Test
public void testProxy() {
    //被代理对象
    UserDAO userDAO = new UserDAOImpl();
    LogInterceptor li = new LogInterceptor();
    li.setTarget(userDAO);
    //newProxyInstance 产生一个代理对象 ，三个参数
    //1.classloader 代理对象和被代理对象应该处于同一个 classloader
    //2.接口 产生的代理对象应该实现那些接口
    //3.handel 执行代理对象方法时，应用那个handel 处理。
    //(接口中有什么方法，代理中就有什么方法 代理中的每个方法在调用的时候都会把 方法自身传给 handel, 并把 代理对象和参数都传递过去 )

//UserDAO userDAOProxy = (UserDAO) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
 Class[] cl = new Class[1];
 cl[0] = UserDAO.class;
 UserDAO userDAOProxy = (UserDAO) Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), cl, li);
 System.out.println(userDAOProxy.getClass());
 userDAOProxy.detele();
 userDAOProxy.save(new User());

/**
 * 代理对象 实现 UserDAO 接口， 实现了 UserDAO 的所有方法。
 * 执行的时候，
 * class $Proxy4 implements UserDAO
 * {
 * 	save(User u) {
 * 	//得到当前的 save 方法
 * 	Method m = UserDAO.getclass.getmethod
 * 	使用代理对象调用invoke 传递代理自身 this ，传递得到的 method 和 参数
 * li.invoke(this, m, u)
 * }

     */
}



*注：* [简单的Spring-IOC](https://github.com/Hosiang1026/simple-springioc)

本文标题： SpringIOC实战篇

本文作者：狂欢马克思

发布时间： 2019年03月03日 00:00

最后更新： 2025年12月30日 08:54

原始链接： https://haoxiang.eu.org/ce756b0e/

赏