自我复习spring的ioc实现

本文详细介绍了如何通过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();
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小小刘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值