手写Spring（一）- 扫描并通过容器创建实例 - @Component、@ComponentScann、@Scope、Spring容器、单例和原型

最新推荐文章于 2024-03-22 11:53:57 发布
最新推荐文章于 2024-03-22 11:53:57 发布
阅读量238 收藏 1
点赞数 1
分类专栏： 手写spring框架 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42263473/article/details/120253717
版权

一：创建容器骨架（逐步完善容器类）

package com.zhw.spring;
import java.io.File;
import java.lang.annotation.Annotation;
import java.net.URL;
public class ClassPathApplication {
    private Class AppConfig;
    public ClassPathApplication(Class appConfig) throws Exception {
        AppConfig = appConfig;
    }
       public  Object getBean(String beanName) {
       return null;
    }
}

二：定义@component、@componentScann、@Scope注解
1，@component注解，标记该类的实例需要被Spring容器管理

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
    String value() default "";
}

2，@componentScann注解，指定扫描器扫描的范围；只有在Spring的扫描器的扫描范围之内并且有@component、@Service、@Repository等标记类才会被扫描到并且Spring管理该类的实例

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScann {
    String value() default "";
}

3，@Scope注解，标记在需要被Spring容器管理的类的上面，指定该类在创建对象时是创建单例的的还是原型的

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
    String value();
}

三：扫描需要容器管理实例的类
1，配置类，@component注解标记了扫描的范围

package com.zhw.config;
import com.zhw.spring.ComponentScann;
@ComponentScann("com.zhw.service")
public class AppConfig {
}

2，完善容器类ClassPathApplication，准确扫描到需要被容器管理的类

package com.zhw.spring;
import java.io.File;
import java.lang.annotation.Annotation;
import java.net.URL;
public class ClassPathApplication {
    private Class AppConfig;
    public ClassPathApplication(Class appConfig) throws Exception {
        AppConfig = appConfig;
        // 扫描AppConfig配置类指定的扫描范围
        scanner(appConfig);
    }

    private void scanner(Class appConfig) throws ClassNotFoundException {
        ComponentScann componentScannAnnotation = (ComponentScann)appConfig.getDeclaredAnnotation(ComponentScann.class);
        // value是需要扫描的范围
        String value = componentScannAnnotation.value();
        // 由于在磁盘中都是以文件的形式存贮
        String path = value.replace('.', '/');
        // 该path下所有资源
        ClassLoader classLoader = ClassPathApplication.class.getClassLoader();
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());
        // 判断该文件是否为文件夹
        if (file.isDirectory()) {
            // 该文件夹下所有文件
            File[] files = file.listFiles();
            for (File file1 : files) {
                // 绝对路径
                String absolutePath = file1.getAbsolutePath();
                // 判断是否是.java编译之后的.class文件
                if(absolutePath.endsWith(".class")){
                    String classNamePre = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    // 类的全限定名
                    String className = classNamePre.replace('\\', '.');
                    Class<?> aClass = classLoader.loadClass(className);
                    Component componentAnnotation = aClass.getDeclaredAnnotation(Component.class);
                    if(componentAnnotation.value().length()>0){
                        // className ->该类的实例应该被加入容器
                       
                    }
                }
            }
        }

    }

    public  Object getBean(String beanName) {
        return null;
    }
}

四：根据类的作用域（Scope）,创建实例；BeanDefinition类的使用
1，创建BeanDefinition类定义Bean

package com.zhw.spring;
public class BeanDefinition {
    private Class aClass;
    private String scope;
    public Class getaClass() {
        return aClass;
    }
    public void setaClass(Class aClass) {
        this.aClass = aClass;
    }
    public String getScope() {
        return scope;
    }
    public void setScope(String scope) {
        this.scope = scope;
    }
}

2，完善容器类ClassPathApplication，根据作用域创建实例并加入容器

package com.zhw.spring;

import java.io.File;
import java.net.URL;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class ClassPathApplication {
    private Class AppConfig;
    // 存放所有 BeanDefinition 对象的map
    Map<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    // 单例池
    Map<String,Object> singletonMap = new ConcurrentHashMap<>();
    public ClassPathApplication(Class appConfig) throws Exception {
        AppConfig = appConfig;
        // 扫描AppConfig配置类指定的扫描范围
        scanner(appConfig);
        // 经过扫描之后，所有需要创建对象的类的信息都在 beanDefinitionMap 中
        Set<Map.Entry<String, BeanDefinition>> beanDefinitionEntrySets = beanDefinitionMap.entrySet();
        for (Map.Entry<String, BeanDefinition> beanDefinitionEntrySet : beanDefinitionEntrySets) {
            String className = beanDefinitionEntrySet.getKey();
            BeanDefinition beanDefinition = beanDefinitionEntrySet.getValue();
            if ("singleton".equals(beanDefinition.getScope())){
                // 创建该类的对象并放入单例池中
                Object bean = createBean(beanDefinition);
                singletonMap.put(className,bean);
            }
        }
    }

    private void scanner(Class appConfig) throws ClassNotFoundException {
        ComponentScann componentScannAnnotation = (ComponentScann)appConfig.getDeclaredAnnotation(ComponentScann.class);
        // value是需要扫描的范围
        String value = componentScannAnnotation.value();
        // 由于在磁盘中都是以文件的形式存贮
        String path = value.replace('.', '/');
        // 该path下所有资源
        ClassLoader classLoader = ClassPathApplication.class.getClassLoader();
        URL resource = classLoader.getResource(path);
        File file = new File(resource.getFile());
        // 判断该文件是否为文件夹
        if (file.isDirectory()) {
            // 该文件夹下所有文件
            File[] files = file.listFiles();
            for (File file1 : files) {
                // 绝对路径
                String absolutePath = file1.getAbsolutePath();
                // 判断是否是.java编译之后的.class文件
                if(absolutePath.endsWith(".class")){
                    String classNamePre = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    // 类的全限定名
                    String className = classNamePre.replace('\\', '.');
                    Class<?> aClass = classLoader.loadClass(className);
                    Component componentAnnotation = aClass.getDeclaredAnnotation(Component.class);
                    if(componentAnnotation.value().length()>0){
                        // className ->该类的实例应该被加入容器
                        BeanDefinition beanDefinition = new BeanDefinition();
                        beanDefinition.setaClass(aClass);
                        if(aClass.isAnnotationPresent(Scope.class)){
                            String value1 = aClass.getDeclaredAnnotation(Scope.class).value();
                            beanDefinition.setScope(value1);
                        } else {
                          // 没有标注@Scope注解，就是默认的单例
                          beanDefinition.setScope("singleton");
                        }
                        beanDefinitionMap.put(className,beanDefinition);
                    }
                }
            }
        }

    }
    // 创建实例的方法
    private Object createBean(BeanDefinition beanDefinition) throws InstantiationException, IllegalAccessException {
        Object object = beanDefinition.getaClass().newInstance();
        return object;
    }

    public  Object getBean(String beanName) throws InstantiationException, IllegalAccessException {
        Object object = null;
        // 判断 beanName 是否被扫描到
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        if(beanDefinition!=null){
            if("singleton".equals(beanDefinition.getScope())){
                return singletonMap.get(beanName);
            }else{
                object = beanDefinition.getaClass().newInstance();
            }
        }
        return object;
    }
}

3，测试
3.1 测试(单例)

package com.zhw.service;
import com.zhw.spring.Component;
@Component(value = "quazrtService")
public class QuazrtService {

}

测试
package com.zhw.test;
import com.zhw.config.AppConfig;
import com.zhw.spring.ClassPathApplication;
import com.zhw.spring.ZhanghwApplicationContext;
public class ZhanghwApplicationContextTest {
    public static void main(String[] args) throws Exception {
        ClassPathApplication classPathApplication = new ClassPathApplication(AppConfig.class);
        Object object1 = classPathApplication.getBean("com.zhw.service.QuazrtService");
        Object object2 = classPathApplication.getBean("com.zhw.service.QuazrtService");
        Object object3 = classPathApplication.getBean("com.zhw.service.QuazrtService");
        Object object4 = classPathApplication.getBean("com.zhw.service.QuazrtService");
        System.out.println(object1);
        System.out.println(object2);
        System.out.println(object3);
        System.out.println(object4);
    }
}

结果
"C:\Program Files\Java\jdk1.8.0_172\bin\java.exe" "-javaagent:D:\IntelliJ IDEA spring\target\classes" com.zhw.test.ZhanghwApplicationContextTest
com.zhw.service.QuazrtService@5e2de80c
com.zhw.service.QuazrtService@5e2de80c
com.zhw.service.QuazrtService@5e2de80c
com.zhw.service.QuazrtService@5e2de80c

Process finished with exit code 0

3.2 测试（prototype原型）

package com.zhw.service;
import com.zhw.spring.Component;
import com.zhw.spring.Scope;
@Component(value = "quazrtService")
@Scope(value = "prototype")
public class QuazrtService {

}

结果
"C:\Program Files\Java\jdk1.8.0_172\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2021.1.3\lib\idea_rt.jar=10780:D:\IntelliJ IDEA 2021.1.3\bin" -
com.zhw.service.QuazrtService@1d44bcfa
com.zhw.service.QuazrtService@266474c2
com.zhw.service.QuazrtService@6f94fa3e
com.zhw.service.QuazrtService@5e481248

Process finished with exit code 0
whileTrueIT
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring之注解（三）Component
我的山水
03-21 3万+
上篇文章中比较详细的介绍了依赖注入的相关注解，尤其是@Autowired。但是我们对bean的定义声明还是放在xml的配置文件中。Spring当然提供了机制可以自动的扫描类路径，自动的向容器注册BeanDefinition。这就是Bean级别的注解。以上机制称为类路径扫描（clsspath-sacn），它是有相关注解（如@Component @Named @Bean）和beanFactoryPos
手写一个SpringIoc容器
04-12
仿照Spring写的一个Ioc容器，注释很详细！
Spring中 @Configuration 和 @Component 的区别及原理详解
2301_76607156的博客
05-06 1271
Indexed​/***/​复制代码@Component​​​复制代码从定义来看， @Configuration 注解本质上还是 @Component，因此 @ComponentScan 能扫描到@Configuration 注解的类。@Component在Spring中是代表LITE模式的配置注解，这种模式下的注解不会被Spring所代理，就是一个标准类，如果在这个类中有@Bean标注的方法，那么方法间的相互调用，其实就是普通Java类的方法的调用。
【Spring注解必知必会】深度解析@Component注解实现原理
m0_71777195的博客
08-16 5086
想必@Component注解大家一直在使用，只要类上加上它，就可以被Spring容器管理，那大家有想过它是怎么实现的吗？本篇文章就带领到家揭秘。用来标记的类是一个“组件”或者说是一个Bean，Spring会自动扫描标记@Component注解的类作为一个Spring Bean对象。@Indexed/***/}复制代码value: 自定义当前组件或者说bean的名称，可以不配置， 不配置的话默认为组件的首字母小写的类名。该注解只能使用在类，接口、枚举、其他注解上该注解的生命周期是运行时JVM。...
Spring--@Component的原理
IT利刃出鞘的博客
06-02 1437
@Component原理 其他网址 Spring注解Component原理源码解析 - Griez - 博客园 简介 我们经常使用Spring的@Component、@Service、@Repository以及 @Controller等注解来实现bean托管给Spring容器管理。Spring是怎么样实现的呢？我们一起跟着源码看看整个过程吧！ 先看调用时序图： 概述@Component到Spring bean容器管理过程。 第一步，初始化时设置了Component类型...
【spring】@Component注解学习
最新发布
一个写了10年bug的程序员日常笔记。
03-22 1785
Component 是 Spring 框架中的一个注解，用于将一个类标记为 Spring 上下文中的一个组件。当一个类被标记为 @Component 时，Spring 容器会在启动时自动扫描并实例化这个类，并将其注册到 Spring 上下文中。@Component 注解可以用于任何类，包括控制器、服务、DAO 等。当一个类被标记为 @Component 时，它就成为了 Spring 上下文中的一个 bean，可以被其他 bean 通过依赖注入的方式使用。
【框架源码篇 01】Spring源码-手写IOC
10-21
【框架源码篇 01】Spring源码-手写IOC
Spring5核心原理与30个手写类实战-时序图.zip
09-26
GitHub图片打不开太慢了
行业分类-设备装置-一种手写输入法和终端设备.zip
08-23
行业分类-设备装置-一种手写输入法和终端设备.zip
sping,springMVC @controller @Component 默认单例模式
daxiong0816的博客
12-12 752
看看spring的Scope有哪些？ 这里写代码片spring bean作用域有以下5个： 1.singleton:单例模式，当spring创建applicationContext容器的时候，spring会欲初始化所有的该作用域实例，加上lazy-init就可以避免预处理； 2.prototype：原型模式，每次通过getBean获取该bean就会新产生一个实例，创建后spring将不再对其管理； ====下面是在web项目下才用到的=== 3.request：搞web的大家都应该明白reques.
Spring 之 @Component 和 @Configuration 两者区别以及源码分析
龚小帅的博客
12-20 3320
之前一直搞不清 @Component 和 @Configuration 这两个注解到底有啥区别，一直认为被这两修饰的类可以被 Spring 实例化嘛，不，还是见识太短，直到今天才发现这两玩意有这么大区别。很幸运能够及时发现，后面可以少走点坑，下面就直接通过最简单的案例来说明它两的区别，颠覆你的认知。
14.ioc中的annotation配置(注解)——@Component
weixin_44137201的博客
08-30 608
知识点： 1) @Component使用之后需要在xml文件配置一个标签:`<context:component-scan/>` 2) @Component注解可以直接定义bean,而无需在xml定义bean。但是若两种定义同时存在,xml中的定义会覆盖类中注解的Bean定义(走无参构造) 3) @Component注解`直接写在类上面`即可 4) @Component如果`不指定参数,则bean的名称为当前类的类名首字母小写,其余的不变` @Component//相当于Boss boss
@component与@Configuration创建bean
清华大咖
03-10 954
@configuration配置 针对@configuration，首先@Configuration与@Bean搭配使用，一般在项目中定义配置累才会使用这个注解 @Configuration 代表这个类是一个配置类，可理解为用spring的时候xml里面的<beans>标签 @Bean 用来定义一个bean，可以指定初始、销毁方法，及bean范围等，可理解为用spring的时...
Component 的创建和启动
管子（zero）的杂乱空间
07-08 607
SpringServerServlet继承了ServerServlet， 在web.xml声明了SpringServerServlet。当Tomcat启动的时候，会调用ServerServlet的init()方法。这是Restlet启动的开始点！一、init()方法1、ServerServlet init()方法先获取 component :Component component = getCom...
@ComponentScan 详解
热门推荐
dxyzhbb的博客
11-06 7万+
@ComponentScan 的作用就是根据定义的扫描路径，把符合扫描规则的类装配到spring容器中，注解定义如下。 @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.TYPE}) @Documented @Repeatable(ComponentScans.class) public @interface ComponentScan { @AliasFor("basePackages") String[] value
spring bean singleton和 prototype
oook
06-29 465
spring中bean的scope属性，有如下5种类型：singleton 表示在spring容器中的单例，通过spring容器获得该bean时总是返回唯一的实例prototype表示每次获得bean都会生成一个新的对象在多数情况，我们只会使用singleton和prototype两种scope，如果在spring配置文件内未指定scope属性，默认为singleton。下面我们用一个示例来说明s...
手写实现spring ioc自动注入、包扫描、单例多例模式（@Component @Autowired @Scope）
HumorChen的博客
12-15 1161
提供了两种手动获取bean的方法 Object getBean(String name);源码地址：https://gitee.com/HumorChen/spring_ioc_impl.git。自动注入由@MyAutowired实现（仅支持被ioc容器管理的对象（@Component））@MyAutowired 对应Spring里的@Autowired。@MyComponent 对应Spring里的@Component。@MyScope 对应Spring里的@Scope。
@Component单例与并发（未解决）
weixin_30571465的博客
07-20 955
今天用websocket记录连接的个数； 模拟少量请求到服务器端的websocket，@Component默认是单例的，让其注解到MyWebSocket类上； 每次请求过来都是相同的MyWebSocket对象，但是是不同的内存，修改其中之一对象的某些属性不会改变其他的对象的属性，可以使用static让多个连接请求共享变量的最终值，想要获得实时的值，让写操作与读同步就行。 错误的想法：想象成了...
Spring @Component声明的Bean无法实例化
SonOfWind0311的博客
03-13 2395
@Component声明的bean无法实例化原理剖析
讲一讲Spring Ioc的底层原理 并手写一套
04-04
7. 定义Spring Ioc框架的入口类，启动容器，并扫描指定包下的所有类，实例化为Bean对象，并将其放入Bean工厂中进行管理，最后注入依赖的Bean对象。 ```java public class SpringIoc { public static void run...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值