SpringIOC实战篇

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

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

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

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

一、项目结构


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

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


### 三、创建BeanFactory接口

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

package com.study.spring;

/**

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


### 四、创建ClassPathXmlApplicationContext实现类

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

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;

/**

@author Howe Hsiang
1
*/
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.getChildren(“property”)) {
String name = propertyElement.getAttributeValue(“name”); //userDAO
String bean = propertyElement.getAttributeValue(“bean”); //u
Object beanObj = beans.get(bean);//UserDAOImpl instance

//拼出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

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;

import java.lang.reflect.Proxy;

/**

public class UserServiceTest {
java
    @Test
    public void testAdd() throws Exception {

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

//依赖注入，自动装配
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, 并把 代理对象和参数都传递过去 )
java
       //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());
java
/**
* 代理对象 实现 UserDAO 接口， 实现了 UserDAO 的所有方法。
* 执行的时候，
* class $Proxy4 implements UserDAO
* {
*   save(User u) {
*   //得到当前的 save 方法
*   Method m = UserDAO.getclass.getmethod
*   使用代理对象调用invoke 传递代理自身 this ，传递得到的 method 和 参数
* li.invoke(this, m, u)
* }

*/
}

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

本文标题： SpringIOC实战篇

本文作者：狂欢马克思

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

最后更新： 2026年09月16日 05:40

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

赏