学习Spring(1)自己简单实现IOC

叁歲伎倆 2022-10-12 00:49 163阅读 0赞

## 创建一个spring项目 ##

刚开始学spring的时候啥也不懂，看很多书或者教程一上来就直接IOC完全云里雾里直接劝退，好歹也先创建一个项目，启动一下，让我知道是怎么回事儿呀，再深入知识点呀，所以我这里先从创建一个项目开始

[创建spring项目的参考文章  
https://blog.csdn.net/jiahanghacker/article/details/88871207  
][spring_ https_blog.csdn.net_jiahanghacker_article_details_88871207]

这个目录结构如下：

*  java
    
     *  dao(包)
        
         *  TestDao.java(接口)
         *  TestDaoImpl.java
         *  TestDaoMySqlImpl.java
     *  service(包)
        
         *  Testservice.java(接口)
         *  TestserviceImpl.java
     *  SpringTest(包)
        
         *  SpringTest.java(测试代码)
 *  resources
    
     *  applicationContext.xml(配置文件)

关于maven：  
如果要查找jar包的maven依赖可以去[https://mvnrepository.com/][https_mvnrepository.com]这里查找，看看最新版本是多少

maven修改源settings.xml：

<mirror>
            <id>alimaven</id>
           <mirrorOf>central</mirrorOf>
            <name>aliyun maven</name>
            <url>https://maven.aliyun.com/repository/central</url>
         </mirror>
    
         
         <mirror>
            <id>alispringmaven</id>
           <mirrorOf>spring</mirrorOf>
            <name>aliyunspring maven</name>
            <url>https://maven.aliyun.com/repository/spring</url>
         </mirror>
     
        
        <mirror>
            <id>repo1</id>
             <mirrorOf>central</mirrorOf>
            <name>Human Readable Name for this Mirror.</name>
            <url>http://repo1.maven.org/maven2/</url>
         </mirror>
     
         
        
         
        <mirror>
          <id>aliyunmaven</id>
          <mirrorOf>public</mirrorOf>
          <name>阿里云公共仓库</name>
          <url>https://maven.aliyun.com/repository/public</url>
        </mirror>
      </mirrors>

如果IDEA中换maven的jar版本失败，去maven设置中的始终更新快照勾选上

这里和参考文章有一些不同，比如maven的pom.xml中的spring依赖只需要一个spring-webmvc

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.3.RELEASE</version>
    </dependency>

其他关于springframework的都可以删掉，然后关于testng  
改为

<dependency>
      <groupId>org.testng</groupId>
      <artifactId>testng</artifactId>
      <version>6.14.2</version>
    </dependency>

然后按照参考文章，run一下SpringTest里的demo方法就可以了

## Spring的IOC理论 ##

[参考文章  
https://blog.csdn.net/qq\_33369905/article/details/106647330?spm=1001.2014.3001.5501  
][https_blog.csdn.net_qq_33369905_article_details_106647330_spm_1001.2014.3001.5501]

在java目录下再创建三个目录：dao，service，SpringTest，其中dao和SpringTest应该在上面的创建Spring项目中就有的

*  java
    
     *  dao(包)
        
         *  TestDao.java(接口)
         *  TestDaoImpl.java
         *  TestDaoMySqlImpl.java
     *  service(包)
        
         *  Testservice.java(接口)
         *  TestserviceImpl.java
     *  SpringTest(包)
        
         *  MaintTest.java(测试代码)
         *  SpringTest.java(之前就有的测试代码)
 *  resources
    
     *  applicationContext.xml(配置文件)

dao中创建三个java文件：  
TestDao.java：

package dao;
    // 定一个接口，假装是取数据的
    public interface TestDao { 
        public void sayHello();
    }

TestDaoImpl.java：

package dao;
    // 假设这是一个数据库实现
    public class TestDaoImpl implements TestDao{ 
        @Override
        public void sayHello() { 
            System.out.println("Hello,Spring!");
        }
    }

TestDaoMySqlImpl.java：

package dao;
    // 假设这是一个mysql的实现
    public class TestDaoMySqlImpl implements TestDao{ 
        @Override
        public void sayHello() { 
            System.out.println("这是新的实现类");
        }
    }

service目录下创建两个Java文件  
Testservice.java

package service;
    // 假装是个服务接口
    public interface Testservice { 
        void getSayHello();
    }

TestserviceImpl.java

package service;
    import dao.TestDao;
    import dao.TestDaoImpl;
    // 实现服务接口，调用获取数据
    public class TestserviceImpl implements Testservice{ 
        // 这里就有一个不方便的地方，如果我们要使用另一个TestDao的实现怎么办呢，只能该这里的代码
        private TestDao td = new TestDaoImpl();
        @Override
        public void getSayHello() { 
            td.sayHello();
        }
    }

SpringTest目录下创建一个测试代码  
MaintTest.java：

package SpringTest;
    import service.Testservice;
    import service.TestserviceImpl;
    import org.testng.annotations.Test;
    public class MainTest { 
        @Test
        public void test() { 
            // 模拟调用服务
            Testservice ts = new TestserviceImpl();
            ts.getSayHello();
        }
    }

通过上面的代码可以看到，如果我们拥有多个数据库实现，但是我们要使用某一个实现的时候必须取修改service实现的代码，这样代码之间的耦合性太高了，那怎么解决呢？

就是在service的实现类中不直接去调用dao的实现类，而是添加一个set方法，动态加载需要的dao实现类，这样就可以在调用服务的地方指定需要的类，而不修改service的代码

package service;
    import dao.TestDao;
    public class TestserviceImpl implements Testservice{ 
        private TestDao td;
        // 利用set方法，动态的加载需要的接口实现类
        public void setTestDao(TestDao newtd){ 
            this.td = newtd;
        }
        @Override
        public void getSayHello() { 
            td.sayHello();
        }
    }

测试代码修改：

package SpringTest;
    import dao.TestDaoMySqlImpl;
    import service.TestserviceImpl;
    import org.testng.annotations.Test;
    public class MainTest { 
        @Test
        public void test() { 
            // 因为set方法定义在service的实现类中，所以这个这里使用service的实现类
            TestserviceImpl ts = new TestserviceImpl();
            ts.setTestDao(new TestDaoMySqlImpl());
            ts.getSayHello();
        }
    }

[看到一篇更简单易懂的IOC文章  
https://www.jianshu.com/p/ad05cfe7868e  
][IOC_ https_www.jianshu.com_p_ad05cfe7868e]

个人理解就是IOC让不同的对象之间没有直接的关联，他们的关联关系都是通过一个单独的容器管理，这个就是IOC容器，这样的好处就是单独修改某个类，不需要再去手动修改需要关联的类

网上说法很多，有的说IOC和DI是一个东西两种说法，有的说IOC是思想，DI是它的一种实现，也有的说是一种思想的两种表现形式

举个例子：

// 这里就能看出注入的好处就是降低耦合性，使得类和类之间的关系不紧密
    // 这个Main类实现了类的对象控制，用户对容器说A需要B，容器就创建一个B的对象注入到A中再给用户
    class Main{ 
        A a = new A();
        B b = new B();
        C c = new C();
        b.set(c);
        a.set(b);
    }
    // 下面三个类是有依赖关系的，通过set注入/构造函数注入等方式实现依赖注入
    class A{ 
        B b;
        // set注入形式
        setB(B newb){ 
            this.b = newb;
        }
        // 这是构造函数注入
        // A(B newb){ 
           // this.b = newb; 
        // }
    }
    
    class B{ 
        C c;
        // 这是set注入
        setC(C newc){ 
            this.c = newc;
        }
        // 这是构造函数注入
        // B(C newc){ 
            // this.c = newc;
        // }
    }
    
    class C{ }

### 简单实现一个xml形式的IOC ###

[简单实现一个IOC的文章  
https://www.jianshu.com/p/78ba8bafb90a  
][IOC_ https_www.jianshu.com_p_78ba8bafb90a]  
他用了jdom，我用dom4j改了一下

maven中添加：

我还是用的是上面那个创建spring项目文章中的项目，所以我在java目录同级的位置新建了一个testioc目录，目录下有TestIoc目录(简单实现IOC的)，TestService(模拟服务的)，MainTest(测试的)

目录结构：

*  testioc
    
     *  TestIoc(包)
        
         *  BeanFactory.java(接口)
         *  ClassPathXmlApplicationContext.java
     *  TestService(包)
        
         *  Animal.java(接口)
         *  Cat.java
         *  Dog.java
     *  MainTest(包)
        
         *  MainTest.java(测试代码)
 *  resources
    
     *  applicationContext.xml(之前就有的配置文件)
     *  bean.xml(新建的配置文件)

TestIoc目录下：

BeanFactory.java：

package TestIoc;
    // 一个工厂类
    public interface BeanFactory { 
        Object getBean(String id);
    }

ClassPathXmlApplicationContext.java：

package TestIoc;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    // IOC实现，IOC容器，就是简单重写一个spring中的 ClassPathXmlApplicationContext 类
    /* 整个流程： 读取xml配置文件，然后遍历所有的bean元素，获取到 id 和 类名， 然后通过反射Class.forName("类名").newInstance()创建一个实例对象，再将id和实例对象存到一个Map中 因为是存储在Map中所以id是唯一的，不然程序就无法根据id找到对应的实例对象 最后通过重写的getBean(id)方法，根据 id 返回实例对象 */
    public class ClassPathXmlApplicationContext implements BeanFactory{ 
        // 容器，用来存放实例对象
        private final Map<String, Object> container = new HashMap<>();
        // 通过xml配置文件，创建实例对象
        public ClassPathXmlApplicationContext(String fileName) throws Exception{ 
            // SAXReader是一个DOM解析器，能将路径中的XML文件解析为Document对象
            SAXReader sb = new SAXReader();
            // class.getResource("/")会查找classpath根目录
            // 因为我是在一个spring的项目下弄了这个程序，所以classpath路径是target/classes/下，xml文件放在resources就可以了
            // read(xml的路径)转成 Document 类型对象
            Document doc = sb.read(ClassPathXmlApplicationContext.class.getResource("/"+fileName));
            // getRootElement()获取根元素标签，根元素就是beans
            Element root = doc.getRootElement();
            // 从根元素下所有的bean元素
            List<Element> list =  root.elements("bean");
            System.out.println(list.toString());
            // 便利所有bean标签元素
            for (Element bean : list) { 
                // 获取每个bean元素
                // 根据属性获取数据
                String id = bean.attributeValue("id");
                String clazz = bean.attributeValue("class");
                // 通过反射Class.forName("类名")找到类，通过newInstance()创建一个新的实例对象
                Object o = Class.forName(clazz).newInstance();
                // System.out.println(id+"/"+clazz);
                // 将实例对象加入容器中
                container.put(id, o);
            }
        }
        @Override
        public Object getBean(String id) { 
            // 根据xml中bean的id找到实例
            return container.get(id);
        }
    // public static void main(String[] args) throws Exception { 
    // BeanFactory a = new ClassPathXmlApplicationContext("bean.xml");
    // }
    }

TestService目录下：

Animal.java：

package TestService;
    public interface Animal { 
        void say();
    }

Cat.java：

package TestService;
    public class Cat implements Animal{ 
        @Override
        public void say() { 
            System.out.println("喵喵喵！！！");
        }
    }

Dog.java：

package TestService;
    public class Dog implements Animal{ 
        @Override
        public void say() { 
            System.out.println("汪汪汪！！！");
        }
    }

因为是个是一个speing项目所以有一个放xml配置文件的resources目录，新建一个bean.xml

bean.xml：

最后是测试类，在MainTest目录下

MainTest.java：

### 根据自己理解实现一个注解形式的IOC ###

因为spring的IOC还能通过注解的形式来实现，这里虽然我还没学过，并且也没见过是怎么用注解的，但是我用自己的想法来实现一下注解形式的IOC，等到学到的时候看看和自己的实现有什么不同

先说说自己实现的原理：

1.  自定义注解：因为 xml 形式的 IOC 中 id 是唯一标识， class 是对应的类，如果是注解的话，应该直接在创建类的上面注解就可以了，这样的话注解接收的参数应该就是一个 id 标识就可以了
2.  获取所有注解：因为上面的程序也是一下子将所有 xml 配置文件中的类存储到 Map 中，所以第二步应该是获取程序下所有注解
3.  重写ClassPathXmlApplicationContext类的构造方法

因为用到一个反射框架reflections，所以需要在maven中添加一下

<dependency>
      <groupId>org.reflections</groupId>
      <artifactId>reflections</artifactId>
      <version>0.9.12</version>
    </dependency>

目录结构：

*  testioc
    
     *  TestIoc(包)
        
         *  BeanFactory.java(接口)
         *  ClassPathXmlApplicationContext.java
         *  MyAnnontationBean.java(注解)
     *  TestService(包)
        
         *  Animal.java(接口)
         *  Cat.java
         *  Dog.java
         *  TestNew(包)
            
             *  Bird.java
     *  MainTest(包)
        
         *  MainTest.java(测试代码)
 *  resources
    
     *  applicationContext.xml(之前就有的配置文件)
     *  bean.xml(新建的配置文件)

先在TestIoc目录下创建自定义注解

MyAnnontationBean.java：

package TestIoc;
    import java.lang.annotation.*;
    // Target 是说明这个注解的使用范围，TYPE是用于描述类、接口(包括注解类型) 或enum声明
    @Target(ElementType.TYPE)
    // Retention 是说明这个注解的保留时间，RUNTIME是在运行时有效（即一直保留到运行时）
    // 注意：这个一定要是运行时，不然反射那边就获取不到参数
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnontationBean { 
        // 只有一个参数可以用value()，使用时就不用加参数名了
        String value();
    }

然后给ClassPathXmlApplicationContext类加一个无参的构造方法，其他的都不变

ClassPathXmlApplicationContext.java：

然后给Cat，Dog类上加上自定义的注解

以Cat.java为例：

package TestService;
    import TestIoc.MyAnnontationBean;
    @MyAnnontationBean("cat")
    public class Cat implements Animal{ 
        @Override
        public void say() { 
            System.out.println("喵喵喵！！！");
        }
    }

为了测试能否找到包下面子包的类，在TestService下新建一个TestNew的包，然后在TestNew包下新建一个Bird类

Bird.java：

package TestService.TestNew;
    import TestIoc.MyAnnontationBean;
    import TestService.Animal;
    @MyAnnontationBean("bird")
    public class Bird implements Animal { 
        @Override
        public void say() { 
            System.out.println("渣渣渣！！！");
        }
    }

然后改写测试代码

MainTest.java：

这样一来就完成了一个我自己认为的注解IOC，当然也不知道和Spring的是不是差不多，等到后面学到再说吧

## DI依赖注入 ##

使用第一个项目的目录结构：

在这个项目的基础上做修改，修改三个文件：

TestserviceImpl.java：

package service;
    import dao.TestDao;
    public class TestserviceImpl implements Testservice{ 
        private TestDao td;
        // 利用set方法，动态的加载需要的接口实现类，这里要用程序生成的set方法
        public void setTd(TestDao td) { 
            this.td = td;
        }
        @Override
        public void getSayHello() { 
            // 这里是调用对应对象的sayHello()方法
            td.sayHello();
        }
    }

然后配置一下applicationContext.xml文件：

最后是修改测试代码SpringTest.java：

package SpringTest;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.testng.annotations.Test;
    import service.TestserviceImpl;
    public class SpringTest { 
        @Test
        public void demo(){ 
            //初始化Spring容器ApplicationContext，加载配置文件
            ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
            //通过容器获取TestserviceImpl实例
            TestserviceImpl testservice = (TestserviceImpl) application.getBean("testserviceImpl");
            // 这里调用TestserviceImpl类的getSayHello()就会指向xml配置中的TestDaoImpl类的sayHello()方法
            testservice.getSayHello();
        }

这样一来所有的对象管理都交给了spring，一些修改可以直接通过修改xml配置文件完成

依赖注入：  
依赖：bean对象的创建依赖容器  
注入：bean对象中的属性由容器注入

#### 各种类型的注入 ####

还是用上面的项目结构：

改写三个文件TestserviceImpl.java，applicationContext.xml，SpringTest.java

TestserviceImpl.java：

package service;
    import dao.TestDao;
    import java.util.*;
    public class TestserviceImpl implements Testservice{ 
        // 弄一堆不同类型的变量来测试注入
        private TestDao td;
        private String name;
        private String[] games;
        private List<String> books;
        private Map<String, String> card;
        private Properties info;
        private Set<String> hobbys;
        private Object ob;
        // 利用set方法，动态的加载需要的接口实现类，这里要用程序生成的set方法
        public void setTd(TestDao td) { 
            this.td = td;
        }
        @Override
        public void getSayHello() { 
            // 这里是调用对应对象的sayHello()方法
            td.sayHello();
        }
        // 下面都是自动生成的set/get方法，还有一个toString方法
        public TestDao getTd() { 
            return td;
        }
        public String getName() { 
            return name;
        }
        public void setName(String name) { 
            this.name = name;
        }
        public String[] getGames() { 
            return games;
        }
        public void setGames(String[] games) { 
            this.games = games;
        }
        public List<String> getBooks() { 
            return books;
        }
        public void setBooks(List<String> books) { 
            this.books = books;
        }
        public Map<String, String> getCard() { 
            return card;
        }
        public void setCard(Map<String, String> card) { 
            this.card = card;
        }
        public Properties getInfo() { 
            return info;
        }
        public void setInfo(Properties info) { 
            this.info = info;
        }
        public Set<String> getHobbys() { 
            return hobbys;
        }
        public void setHobbys(Set<String> hobbys) { 
            this.hobbys = hobbys;
        }
        public Object getOb() { 
            return ob;
        }
        public void setOb(Object ob) { 
            this.ob = ob;
        }
        @Override
        public String toString() { 
            return "TestserviceImpl{" +
                    "td=" + td +
                    ", name='" + name + '\'' +
                    ", games=" + Arrays.toString(games) +
                    ", books=" + books +
                    ", card=" + card +
                    ", info=" + info +
                    ", hobbys=" + hobbys +
                    ", ob=" + ob +
                    '}';
        }
    }

applicationContext.xml：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        
        
        <bean id="testserviceImpl" class="service.TestserviceImpl">
            
            
            
            
            <property name="td" ref="testDaoImpl"/>
            
            <property name="name" value="这是名字"/>
            
            <property name="games">
                <array>
                    <value>马里奥</value>
                    <value>魂斗罗</value>
                    <value>忍者龟</value>
                </array>
            </property>
            
            <property name="books">
                <list>
                    <value>西游</value>
                    <value>水浒</value>
                    <value>三国</value>
                </list>
            </property>
            
            <property name="card">
                <map>
                    <entry key="身份证" value="123456"/>
                    <entry key="银行卡" value="789101"/>
                    <entry key="饭卡" value="43212345"/>
                </map>
            </property>
            
            <property name="ob">
                <null/>
            </property>
            
            <property name="hobbys">
                <set>
                    <value>篮球</value>
                    <value>足球</value>
                    <value>网球</value>
                </set>
            </property>
            
            <property name="info">
                <props>
                    <prop key="性别">男</prop>
                    <prop key="生日">2020.10.01</prop>
                    <prop key="身高">175</prop>
                    <prop key="体重">60</prop>
                </props>
            </property>
        </bean>
        <bean id="testDaoImpl" class="dao.TestDaoImpl"/>
    </beans>

SpringTest.java：

还可以通过构造函数注入，当然必须由构造函数才可以用，就和set注入必须由set方法一样：

<bean id="testDaoImpl" class="dao.TestDaoImpl">
        <constructor-arg ref="这里是指向的bean的id值"/>
    </bean>
    
    
    
    <bean id="testDaoImpl" class="dao.TestDaoImpl">
        <constructor-arg ref="这里是指向的bean的id值"/>
        <constructor-arg ref="这里是指向的bean的id值"/>
    </bean>
    
    
    <bean id="testDaoImpl" class="dao.TestDaoImpl">
        <constructor-arg name="参数名1" ref="这里是指向的bean的id值"/>
        <constructor-arg name="参数名2" ref="这里是指向的bean的id值"/>
    </bean>

## Spring中的Bean ##

xml配置文件中的bean元素其实相当于一个实例对象

bean默认是单例模式，也就是不管getBean()方法获取多少遍都是同一个实例对象，但是bean可以设置为多例，就是每次getBean()的创建不同的对象

<bean id="testDaoImpl" class="dao.TestDaoImpl" scope="prototype"/>

### 自己实现多例模式 ###

先说一下多例的思想，之前创建对象的工作是在ClassPathXmlApplicationContext的构造函数中就完成的，所以getBean()的时候已经是实例对象了，想了一下整个启动代码只有两句话读取配置文件初始化好容器，直接getBean()，既然不能在ClassPathXmlApplicationContext中，那就只能在getBean()中了

这次顺便把无参构造函数干掉

因为就是在上面自己写的IOC上改，所以目录结构一样：

修改五个文件：ClassPathXmlApplicationContext.java，MyAnnontationBean.java，bean.xml，Bird.java，MainTest.java

ClassPathXmlApplicationContext.java，这个文件是主要修改的：

package TestIoc;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import org.reflections.Reflections;
    import java.util.*;
    // IOC实现，IOC容器，就是简单重写一个spring中的 ClassPathXmlApplicationContext 类
    /* xml配置文件整个流程： 读取xml配置文件，然后遍历所有的bean元素，获取到 id 和 类名， 然后通过反射Class.forName("类名").newInstance()创建一个实例对象，再将id和实例对象存到一个Map中 最后通过重写的getBean(id)方法，根据 id 返回实例对象 注解的整个流程： 自定义一个带参数的注解 根据自定义的注解在指定包范围内搜索出所有的类 再将注解的参数当作唯一标识，根据注解找到的类实例对象当作值，存入Map中 */
    public class ClassPathXmlApplicationContext implements BeanFactory{ 
        // 容器，用来存放实例对象
        private final Map<String, Map<Object, String>> container = new HashMap<>();
        private final String SCOPES = "singleton";
        // 通过xml配置文件，创建实例对象，因为可以多个文件配置，所以我这里使用了...的形式
        // 不过下面的代码有一个问题，就是你要么选择xml配置，要么选择注解配置，如果两个一个用的话需要保证两边是一致的，不然因为代码运行的顺序，注解会将xml覆盖掉
        public ClassPathXmlApplicationContext(String... fileNames) throws Exception{ 
            // SAXReader是一个DOM解析器，能将路径中的XML文件解析为Document对象
            SAXReader sb = new SAXReader();
            // 因为String...接收的是一个数组，所以这里使用遍历
            for(String filename: fileNames){ 
                // class.getResource("/")会查找classpath根目录
                // 因为我是在一个spring的项目下弄了这个程序，所以classpath路径是target/classes/下，xml文件放在resources就可以了
                // read(xml的路径)转成Document类型对象
                Document doc = sb.read(ClassPathXmlApplicationContext.class.getResource("/"+filename));
                // getRootElement()获取根元素标签，根元素就是beans
                Element root = doc.getRootElement();
                // 从根元素下所有的bean元素
                List<Element> list =  root.elements("bean");
                // 便利所有bean标签元素
                for (Element bean : list) { 
                    // 获取每个bean元素
                    // 根据属性获取数据
                    String id = bean.attributeValue("id");
                    String clazz = bean.attributeValue("class");
                    String scope = bean.attributeValue("scope");
                    if(scope==null){ 
                        scope = SCOPES;
                    }
                    // 通过反射Class.forName("类名")找到类，通过newInstance()创建一个新的实例对象
                    Object obj;
                    // 如果是singleton就是单例，存进去创建好的实例
                    if(scope.equals(SCOPES)){ 
                        // 将类实例化对象
                        // newInstance()将类实例化
                        obj = Class.forName(clazz).newInstance();
                    }else { 
                        // 如果不是，就直接存进去Class对象
                        obj = Class.forName(clazz);
                    }
                    Map<Object, String> newmap = new HashMap<>();
                    newmap.put(obj, scope);
                    // 将实例对象加入容器中
                    container.put(id, newmap);
                }
                // 查找classpathPackage标签，因为可能是多个所以使用list
                List<Element> packages =  root.elements("classpathPackage");
                // 遍历所有classpathPackage标签
                for (Element newpackage: packages) { 
                    // 查找classpathPackage标签的packagePath属性
                    String packagePath = newpackage.attributeValue("packagePath");
                    if(!packagePath.equals("")) { 
                        // 反射的指定范围，在这个包下面，包下面的子包都是包含的
                        // 其实这里不应该写死哪个包，也应该是一个配置文件读取
                        Reflections reflections = new Reflections(packagePath);
                        // 根据指定的注解获取所有的类
                        // getTypesAnnotatedWith()根据指定的注解搜索所有的类
                        Set<Class<?>> classes = reflections.getTypesAnnotatedWith(MyAnnontationBean.class);
                        // 遍历获取到的类
                        for (Class<?> type : classes) { 
                            // 获取注解的参数，就是相当于xml中的id
                            // getAnnotation()获取注解
                            MyAnnontationBean annon = type.getAnnotation(MyAnnontationBean.class);
                            // 注解的参数，就是唯一标识
                            // value()是自定义注解中的方法
                            String value = annon.value();
                            // 这里不需要判断是否存在是因为自定义注解中，我们给了默认值
                            String scope = annon.scope();
                            Object o;
                            // 如果是singleton就是单例，存进去创建好的实例
                            if (scope.equals(SCOPES)) { 
                                // 将类实例化对象
                                // newInstance()将类实例化
                                o = type.newInstance();
                            } else { 
                                // 如果不是，就直接存进去Class对象
                                o = type;
                            }
                            Map<Object, String> newmap = new HashMap<>();
                            newmap.put(o, scope);
                            // 将id和object存入map中
                            container.put(value, newmap);
                        }
                    }
                }
            }
        }
        @Override
        public Object getBean(String id) { 
            Object newobj = null;
            // 根据xml中bean的id找到对应的实例
            Map<Object,String> newmap = container.get(id);
            // 下面的操作是如果是单例就直接返回实例，如果是多例就新创建一个对象再返回
            for(Object obj: newmap.keySet()){ 
                // 如果不是单例，我们就创建一个新对象
                if(!newmap.get(obj).equals(SCOPES)){ 
                    // 这里需要将原本的Class实例强转回来，因为存在Map中是Object
                    Class clazz = (Class) obj;
                    try { 
                        newobj = clazz.newInstance();
                    } catch (InstantiationException e) { 
                        e.printStackTrace();
                    } catch (IllegalAccessException e) { 
                        e.printStackTrace();
                    }
                }else{ 
                    // 如果是单例，我们直接使用Map里的对象
                    newobj = obj;
                }
            }
            // 返回对象
            return newobj;
        }
    }

然后修改注解，添加默认值，MyAnnontationBean.java：

package TestIoc;
    import java.lang.annotation.*;
    // Target 是说明这个注解的使用范围，TYPE是用于描述类、接口(包括注解类型) 或enum声明
    @Target(ElementType.TYPE)
    // Retention 是说明这个注解的保留时间，RUNTIME是在运行时有效（即一直保留到运行时）
    // 注意：这个一定要是运行时，不然反射那边就获取不到参数
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnontationBean { 
        String value();
        // 添加scope属性，默认单例模式
        String scope() default "singleton";
    }

修改bean.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
    
    <beans>
        <bean id="cat" class="TestService.Cat" />
        <bean id="dog" class="TestService.Dog" />
        
        <bean id="bird" class="TestService.TestNew.Bird" scope="prototype"/>
        
        
        <classpathPackage packagePath="TestService"/>
    </beans>

修改Bird.java：

package TestService.TestNew;
    import TestIoc.MyAnnontationBean;
    import TestService.Animal;
    // 注解形式修改为多例模式
    @MyAnnontationBean(value = "bird", scope = "prototype")
    public class Bird implements Animal { 
        @Override
        public void say() { 
            System.out.println("渣渣渣！！！");
        }
    }

修改测试代码，MainTest.java：

package MainTest;
    import TestIoc.BeanFactory;
    import TestIoc.ClassPathXmlApplicationContext;
    import TestService.Animal;
    import org.testng.annotations.Test;
    public class MainTest { 
        @Test
        void test() throws Exception { 
            // 读取bean.xml文件，这里其实就是拥有所有配置里的对象的容器(按照我们自己实现的，这里其实就是一个Map)
             BeanFactory bf = new ClassPathXmlApplicationContext("bean.xml");
            // 这里使用无参的构造方法，使用注解，现在这个无参构造函数就退出舞台了
            // BeanFactory bf = new ClassPathXmlApplicationContext();
            // getBean(id)，通过 id 获取 对应的实例对象
            Object od = bf.getBean("dog");
            Animal dog = (Animal) od;
            dog.say();
            Object oc = bf.getBean("cat");
            Animal cat = (Animal) oc;
            cat.say();
            Object occ = bf.getBean("cat");
            Animal catt = (Animal) occ;
            // 用getBean获取两次，然后对比两个实例，结果是同一个
            System.out.println(cat==catt);
            // 去修改Bird类xml配置或者注解，加上scope="prototype"
            Object ob = bf.getBean("bird");
            Animal bird = (Animal) ob;
            bird.say();
            Object obb = bf.getBean("bird");
            Animal birdd = (Animal) obb;
            // 使用多例模式以后，就会发现两个对象是不一样的了
            System.out.println(bird==birdd);
        }
    }

这样就简单实现了多例模式，但是这有一个问题，就是存实例对象的容器Map的数据结构太复杂了，我们其实没有必要，写完以后我就直呼自己傻了，有反射干嘛不好好用呢，于是乎：

package TestIoc;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    import org.reflections.Reflections;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.*;
    // IOC实现，IOC容器，就是简单重写一个spring中的 ClassPathXmlApplicationContext 类
    /* xml配置文件整个流程： 读取xml配置文件，然后遍历所有的bean元素，获取到 id 和 类名， 然后通过反射Class.forName("类名").newInstance()创建一个实例对象，再将id和实例对象存到一个Map中 最后通过重写的getBean(id)方法，根据 id 返回实例对象 注解的整个流程： 自定义一个带参数的注解 根据自定义的注解在指定包范围内搜索出所有的类 再将注解的参数当作唯一标识，根据注解找到的类实例对象当作值，存入Map中 */
    public class ClassPathXmlApplicationContext implements BeanFactory{ 
        // 容器，用来存放实例对象
        private final Map<String, Object> container = new HashMap<>();
        // 多例模式的常量
        final String  NOSCOPES = "prototype";
        // 通过xml配置文件，创建实例对象，因为可以多个文件配置，所以我这里使用了...的形式
        // 不过下面的代码有一个问题，就是你要么选择xml配置，要么选择注解配置，如果两个一个用的话需要保证两边是一致的，不然因为代码运行的顺序，注解会将xml覆盖掉
        public ClassPathXmlApplicationContext(String... fileNames) throws Exception{ 
            // SAXReader是一个DOM解析器，能将路径中的XML文件解析为Document对象
            SAXReader sb = new SAXReader();
            // 因为String...接收的是一个数组，所以这里使用遍历
            for(String filename: fileNames){ 
                // class.getResource("/")会查找classpath根目录
                // 因为我是在一个spring的项目下弄了这个程序，所以classpath路径是target/classes/下，xml文件放在resources就可以了
                // read(xml的路径)转成Document类型对象
                Document doc = sb.read(ClassPathXmlApplicationContext.class.getResource("/"+filename));
                // getRootElement()获取根元素标签，根元素就是beans
                Element root = doc.getRootElement();
                // 从根元素下所有的bean元素
                List<Element> list =  root.elements("bean");
                // 便利所有bean标签元素
                for (Element bean : list) { 
                    // 获取每个bean元素
                    // 根据属性获取数据
                    String id = bean.attributeValue("id");
                    String clazz = bean.attributeValue("class");
                    String scope = bean.attributeValue("scope");
                    // 这里是通过反射修改类注解的值
                    Class<?> classes = Class.forName(clazz);
                    MyAnnontationBean anno = classes.getAnnotation(MyAnnontationBean.class);
                    InvocationHandler handler = Proxy.getInvocationHandler(anno);
                    Field field = handler.getClass().getDeclaredField("memberValues");
                    field.setAccessible(true);
                    Map<String,String> annoMap = (Map) field.get(handler);
                    if(scope!=null && scope.equals(NOSCOPES)){ 
                        // 如果读取到xml配置文件历史多例模式，就改写注解的值
                        annoMap.put("scope", NOSCOPES);
                    }
                    // 这里我简单粗暴一点，我都存入实例对象，但是在getBean()方法里，我会将多例的对象转成Class再重新生成对象
                    Object obj = classes.newInstance();
                    // 将实例对象加入容器中
                    container.put(id, obj);
                }
                // 查找classpathPackage标签，因为可能是多个所以使用list
                List<Element> packages =  root.elements("classpathPackage");
                // 遍历所有classpathPackage标签
                for (Element newpackage: packages) { 
                    // 查找classpathPackage标签的packagePath属性
                    String packagePath = newpackage.attributeValue("packagePath");
                    if(!packagePath.equals("")) { 
                        // 反射的指定范围，在这个包下面，包下面的子包都是包含的
                        // 其实这里不应该写死哪个包，也应该是一个配置文件读取
                        Reflections reflections = new Reflections(packagePath);
                        // 根据指定的注解获取所有的类
                        // getTypesAnnotatedWith()根据指定的注解搜索所有的类
                        Set<Class<?>> classes = reflections.getTypesAnnotatedWith(MyAnnontationBean.class);
                        // 遍历获取到的类
                        for (Class<?> type : classes) { 
                            // 获取注解的参数，就是相当于xml中的id
                            // getAnnotation()获取注解
                            MyAnnontationBean annon = type.getAnnotation(MyAnnontationBean.class);
                            // 注解的参数，就是唯一标识
                            // value()是自定义注解中的方法
                            String value = annon.value();
                            // 这里不需要判断是否存在是因为自定义注解中，我们给了默认值
                            String scope = annon.scope();
                            // 这里是通过反射修改类注解的值
                            InvocationHandler handler = Proxy.getInvocationHandler(annon);
                            Field field = handler.getClass().getDeclaredField("memberValues");
                            field.setAccessible(true);
                            Map<String, String> annoMap = (Map) field.get(handler);
                            // 如果是singleton就是单例，存进去创建好的实例
                            if (scope!=null && scope.equals(NOSCOPES)) { 
                                // 如果读取到xml配置文件历史多例模式，就改写注解的值
                                annoMap.put("scope", NOSCOPES);
                            }
                            // 这里我简单粗暴一点，我都存入实例对象，但是在getBean()方法里，我会将多例的对象转成Class再重新生成对象
                            Object obj = type.newInstance();
                            // 将id和object存入map中
                            container.put(value, obj);
                        }
                    }
                }
            }
        }
        @Override
        public Object getBean(String id) { 
            Object newobj = null;
            // 根据xml中bean的id找到对应的实例
            Object obj = container.get(id);
            // 将Object转成Class
            Class<?> clazz = obj.getClass();
            // 获取注解
            MyAnnontationBean annon = clazz.getAnnotation(MyAnnontationBean.class);
            // 获取注解参数
            String scope = annon.scope();
            String SCOPES = "singleton";
            if(scope.equals(SCOPES)){ 
                // 是单例直接返回原来存储的对象
                newobj = obj;
            }else{ 
                try { 
                    // 是多例就现在创建一个新对象
                    newobj = clazz.newInstance();
                } catch (InstantiationException e) { 
                    e.printStackTrace();
                } catch (IllegalAccessException e) { 
                    e.printStackTrace();
                }
            }
            // 返回对象
            return newobj;
        }
    }

[spring_ https_blog.csdn.net_jiahanghacker_article_details_88871207]: https://blog.csdn.net/jiahanghacker/article/details/88871207
[https_mvnrepository.com]: https://mvnrepository.com/
[https_blog.csdn.net_qq_33369905_article_details_106647330_spm_1001.2014.3001.5501]: https://blog.csdn.net/qq_33369905/article/details/106647330?spm=1001.2014.3001.5501
[IOC_ https_www.jianshu.com_p_ad05cfe7868e]: https://www.jianshu.com/p/ad05cfe7868e
[IOC_ https_www.jianshu.com_p_78ba8bafb90a]: https://www.jianshu.com/p/78ba8bafb90a