自我复习spring的ioc实现_2、使用核心容器获取userservice的对象, 并调用printuser方法输出user信息。(-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_55604133/article/details/116243007

本文详细介绍了如何通过XML配置文件和注解方式实现Spring的IoC/DI控制反转与依赖注入，并演示了如何自定义IoC框架，包括通过`ClasspathXmlApplicationContext`和`AnnotationConfigurationApplicationContext`。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Spring

IoC/DI：控制反转/依赖注入

自定义IoC框架理解IoC/DI

需求：模拟通过配置文件实现IoC/DI、通过注解实现IoC/DI。

1.通过xml配置文件实现自定义IoC框架

//模拟三层架构
//dao
public class UserDao {
    public void dao(){
        System.out.println("dao层方法执行！！！");
    }
}
//service
public class UserService {
    private UserDao userDao=new UserDao();
    public void service(){
        System.out.println("service层方法执行！！！");
        userDao.dao();
    }
}
//servlet
public class UserServlet {
    public static void main(String[] args) {
        UserService service = new UserService();
        userService.service();
    }
}

2.理解IoC框架要实现的功能

3.创建对应的类

//PropertyDifinition
public class PropertyDifinition {
    private String name;
    private String ref;
	//setter/getter......
}

//BeanDifinition
public class BeanDifinition {
    private String id;
    private String className;
    private List<PropertyDifinition> propertyDifinitions;
    //setter/getter......
}

//ApplicationContext：容器类型有多种，通过读取数据方式不同而不同，此处需要使用两种：xml或注解
public interface ApplicationContext {
    void addBean(String id,Object object);//将实例存入容器
    Object getBean(String id);//根据实例唯一标识从容器中取出实例
}

//ClasspathXmlApplicatonContext：先实现读取xml文件完成IoC
public class ClasspathXmlApplicationContext implements ApplicationContext{
    private Map<String,Object> beans=new HashMap<>();//容器

    public ClasspathXmlApplicationContext() {
        BeanFactory beanFactory = new BeanFactory(this);//将容器传入BeanFactory，方便调用
        beanFactory.initBean();//初始化bean--控制反转
        beanFactory.dependencyInjection();//依赖注入
    }
    public void addBean(String id,Object object){
        beans.put(id,object);//向容器中存放实例
    }

    public Object getBean(String id){
        return beans.get(id);//从容器中取出实例
    }
}


//BeanFactory
public class BeanFactory {
    private List<BeanDifinition> beanDifinitions=new ArrayList<>();//存放所有的<bean>标签信息
    private ApplicationContext ApplicationContext;//

    /**
     * 在构造方法中读取配置文件，将配置文件内容存入beanDifinitions
     * IoC容器分为两种类型：一种通过读取配置文件构建，一种通过读取类的注解构建
     * 使用接口类型实现多态
     * 需要注意的是：此处只为简单实现以理解IoC原理，没有去考虑xml与注解混用的情况
     */
    public BeanFactory(ApplicationContext ApplicationContext) {
        this.applicationContext=applicationContext;
        String path = this.getClass().getResource("/").getPath();//获取项目根目录
        //项目根目录以“/”开头时，可使用subString()用于去除，否则不必执行截取操作，但replace()操作必须有
        path=path.substring(1).replace("/",File.separator);
        //如果传入的容器是读取xml配置时，读取配置文件信息
        if (applicationContext instanceof ClasspathXmlApplicationContext) {
            try {
                SAXReader saxReader = new SAXReader();
                Document document = saxReader.read(path+"applicationContext.xml");
                Element root = document.getRootElement();
                List<Element> beanElements = root.elements("bean");
                //遍历所有bean标签，将bean标签信息存入BeanDifinition
                beanElements.forEach(element -> {
                    BeanDifinition beanDifinition = new BeanDifinition();
                    String id = element.attributeValue("id");
                    String className = element.attributeValue("class");
                    beanDifinition.setId(id);
                    beanDifinition.setClassName(className);
                    //获取bean标签中所有property标签
                    List<Element> propertyElements = element.elements("property");
                    ArrayList<PropertyDifinition> propertyDifinitions = new ArrayList<>();
                    //遍历所有property标签，将property标签信息存入PropertyDifinition
                    propertyElements.forEach(element1 -> {
                        PropertyDifinition propertyDifinition = new PropertyDifinition();
                        String name = element1.attributeValue("name");
                        String ref = element1.attributeValue("ref");
                        propertyDifinition.setName(name);
                        propertyDifinition.setRef(ref);
                        propertyDifinitions.add(propertyDifinition);
                    });
                    beanDifinition.setPropertyDifinitions(propertyDifinitions);
                    beanDifinitions.add(beanDifinition);
                });
            } catch (DocumentException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 根据beanDifinitions内容反射构建类实例
     */
    public void initBean(){
        //遍历所有BeanDifinition，生成对应的Bean实例，存入IoC容器
        beanDifinitions.forEach(beanDifinition -> {
            try {
                String id = beanDifinition.getId();
                String className = beanDifinition.getClassName();
                //反射：根据类的全限定名字符串创建类的实例
                Class<?> c = Class.forName(className);
                Object instance = c.newInstance();
                //存入容器
                applicationContext.addBean(id,instance);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 实现依赖注入
     */
    public void dependencyInjection(){
        beanDifinitions.forEach(beanDifinition -> {
            String id = beanDifinition.getId();
            String className = beanDifinition.getClassName();
            List<PropertyDifinition> propertyDifinitions = beanDifinition.getPropertyDifinitions();
            propertyDifinitions.forEach(propertyDifinition -> {
                String name = propertyDifinition.getName();
                String ref = propertyDifinition.getRef();
                //需要注入的实例
                Object originBean = applicationContext.getBean(id);
                //用于注入的实例
                Object refBean = applicationContext.getBean(ref);
                try {
                    //反射获取需要注入属性
                    Class<?> c = Class.forName(className);
                    Field field = c.getDeclaredField(name);
                    //强制放开私有属性赋值操作
                    field.setAccessible(true);
                    //给私有属性赋值
                    field.set(originBean,refBean);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            });
        });
    }
}

4.在Servlet类中测试

//测试之前应将UserService类中创建UserDao实例的代码去掉
public class UserService {
    private UserDao userDao;
    public void service(){
        System.out.println("service层方法执行！！！");
        userDao.dao();
    }
}

//使用自定义IoC框架中的容器获取UserService实例
public class UserServlet {
    public static void main(String[] args) {
//        UserService service = new UserService();
        ApplicationContext applicationContext = new ClasspathXmlApplicationContext();
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.service();
    }
}

5.增加注解配置

<?xml version="1.0" encoding="UTF-8" ?>
<beans>
    <!--指定框架启动后，扫描当前项目中所有com.woniu包下所有类上的注解-->
     <component-scan package="com.woniu"/>
</beans>

6.修改BeanFactory，增加扫描注解的代码

//创建注解
@Target(ElementType.TYPE)//作用于类上，为创建实例做准备
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String value() default "";
}

@Target(ElementType.FIELD)//作用于属性上，为依赖注入做准备
@Retention(RetentionPolicy.RUNTIME)
public @interface Resource {
}

//在UserDao、UserService类上加@Component注解，在UserService类中的userDao属性上增加@Resource注解

//增加容器类，用于注解配置
public class AnnotationConfigurationApplicationContext implements ApplicationContext{
    private Map<String,Object> beans=new HashMap<>();

    public AnnotationConfigurationApplicationContext() {
        BeanFactory beanFactory = new BeanFactory(this);
        beanFactory.initBean();
        beanFactory.dependencyInjection();
    }
    public void addBean(String id,Object object){
        beans.put(id,object);
    }

    public Object getBean(String id){
        return beans.get(id);
    }
}

//修改BeanFactory
public class BeanFactory {
    private List<BeanDifinition> beanDifinitions=new ArrayList<>();
    private ApplicationContext applicationContext;

    /**
     * 在构造方法中读取配置文件，将配置文件内容存入beanDifinitions
     */
    public BeanFactory(ApplicationContext applicationContext) {
        this.applicationContext=applicationContext;
        String path = this.getClass().getResource("/").getPath();//获取项目根目录
        path=path.substring(1).replace("/",File.separator);
        //如果是纯XML配置
        if (applicationContext instanceof ClasspathXmlApplicationContext) {
            ......
        }else if(applicationContext instanceof AnnotationConfigurationApplicationContext){//如果是注解配置
            try {
                //解析配置文件，获取扫描范围
                SAXReader saxReader = new SAXReader();
                Document document = saxReader.read(path+"applicationContext.xml");
                Element root = document.getRootElement();
                Element element = root.element("component-scan");
                String packageName = element.attributeValue("package");
                packageName=packageName.replace(".",File.separator);
                //递归扫描path所在路径下的所有文件
                File directory = new File(path+packageName);
                loopDirectory(directory,path);
            } catch (DocumentException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 递归遍历包下所有类，将被注解的类生成实例
     */
    
    public void loopDirectory(File file,String path){
        if (file.isDirectory()) {//如果是目录，递归遍历
            File[] files = file.listFiles();
            if (files != null && files.length > 0) {
                for (File child : files) {
                    loopDirectory(child,path);
                }
            }
        }else{//如果是文件，获取文件的绝对路径，从中筛选出所有以.class结尾的文件
            String absolutePath = file.getAbsolutePath();
            if (absolutePath.endsWith(".class")) {
                //从绝对路径中获取类的全限定名
                //示例：绝对路径为E:\a\b\c\com\woniu\dao\UserDao.class，path为E:\a\b\c\
                //链式操作，replace(path,"")====》  com\woniu\dao\UserDao.class
                //replace(".class","")====》  com\woniu\dao\UserDao
                //replace(File.separator,".")====>  com.woniu.dao.UserDao
                String className=absolutePath.replace(path,"").replace(".class","").replace(File.separator,".");
                try {
                    Class<?> c = Class.forName(className);
                    //查看类上是否有@Component注解
                    if (c.isAnnotationPresent(Component.class)) {
                        BeanDifinition beanDifinition = new BeanDifinition();
                        beanDifinition.setClassName(className);
                        String id=null;
                        //如果@Component注解没有指定value，使用的默认值(即类名首字母小写)
                        if (!"".equals(c.getDeclaredAnnotation(Component.class))) {                            id=c.getSimpleName().substring(0,1).toLowerCase()+c.getSimpleName().substring(1);
                        }else{//如果指定了value，以指定值为准
                            id=c.getDeclaredAnnotation(Component.class).value();
                        }
                        beanDifinition.setId(id);
                        //获取类中所有属性
                        Field[] fields = c.getDeclaredFields();
                        ArrayList<PropertyDifinition> propertyDifinitions = new ArrayList<>();
                        //如果属性上有@Resource注解，则进行依赖注入
                        if (fields != null && fields.length > 0) {
                            for (Field field : fields) {
                                if (field.isAnnotationPresent(Resource.class)) {
                                    PropertyDifinition propertyDifinition = new PropertyDifinition();
                                    propertyDifinition.setName(field.getName());
                                    propertyDifinition.setRef(field.getName());
                                    propertyDifinitions.add(propertyDifinition);
                                }
                            }
                        }
                        beanDifinition.setPropertyDifinitions(propertyDifinitions);
                        beanDifinitions.add(beanDifinition);
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }

            }
        }
    }
	......
}

测试

public class UserServlet {
    public static void main(String[] args) {
//        UserService service = new UserService();
        AnnotationConfigurationApplicationContext applicationContext = new AnnotationConfigurationApplicationContext();
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.service();
    }
}