带你简化理解Spring 基于注解配置的原理

已于 2022-10-27 11:24:34 修改
阅读量875 收藏 2
点赞数 3
分类专栏： Spring 文章标签： 1024程序员节 spring 后端
于 2022-10-24 23:04:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Baridhu/article/details/127503681
版权

1 需求说明

  1. 自己写一个简单的 Spring 容器, 通过读取类的注解 (@Component @Controller @Service @Reponsitory)，将对象注入到 IOC 容器

bean id= MyComponent bean 对象=
com.hj.spring.component.MyComponent@13221655

bean id= UserDao bean 对象= com.hj.spring.component.UserDao@2f2c9b19
bean id= UserService bean 对象=
com.hj.spring.component.UserService@31befd9f

bean id= UserController bean 对象=
com.hj.spring.component.UserController@1c20c684 i am user da

  1. 我们不使用 Spring 原生框架，自己手写 IO+Annotaion+反射+集合 技术实现, 打通 Spring 注解方式开发的技术难点

2 思路分析

  1. 思路分析+程序结构

    • 我们使用注解方式完成, 不使用 xml 来配置

    • 程序框架图
      在这里插入图片描述

3 代码实现

● 应用实例

  1. 手动实现注解的方式来配置 Controller / Service / Respository / Component
  2. 我们使用自定义注解来完成.

● 代码实现
代码结构：
在这里插入图片描述

  1. 创建 ComponentScan.java
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 解读
 * 1. @Target(ElementType.TYPE)指定我们的ComponentScan注解可以修饰 Type程序元素
 * 2. @Retention(RetentionPolicy.RUNTIME) 指定ComponentScan注解 保留范围
 * 3. String value() default ""; 表示ComponentScan 可以传入 value
 */

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
    String value() default "";
}
  1. 创建 HJSpringConfig.java
/**
 * @author hj
 * @version 1.0
 * 这是一个配置类, 作用类似我们原生spring的 beans.xml 容器配置文件
 */
@ComponentScan(value = "com.hj.springboot_06_ssmp.component")
public class HJSpringConfig {
}
  1. 创建 SpringApplicationContext.java
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author hj
 * SpringApplicationContext 类的作用类似Spring原生ioc容器
 */
public class SpringApplicationContext {
    private Class configClass;
    //ioc我存放的就是通过反射创建的对象(基于注解方式)
    private final ConcurrentHashMap<String, Object> ioc = new ConcurrentHashMap<>();

    public SpringApplicationContext(Class configClass) {
        this.configClass = configClass;

        //获取要扫描的包
        //1. 先得到HJSpringConfig配置的的@ComponentScan(value = "com.hj.springboot_06_ssmp.component")
        ComponentScan componentScan =(ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);//注解
        System.out.println("注解内容= " + componentScan);

        //2. 通过componentScan的value=> 即要扫描的包
        String path = componentScan.value();
        System.out.println("要扫描的包= " + path);
    }

    public static void main(String[] args) {
        SpringApplicationContext springApplicationContext = new SpringApplicationContext(HJSpringConfig.class);

    }
}

第一步：获取要扫描的包

//1. 先得到HJSpringConfig配置的的@ComponentScan(value = "com.hj.springboot_06_ssmp.component")
ComponentScan componentScan =(ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);//注解
System.out.println("注解内容= " + componentScan);

//2. 通过componentScan的value=> 即要扫描的包
String path = componentScan.value();
System.out.println("要扫描的包= " + path);

运行结果：

注解内容= @com.hj.springboot_06_ssmp.annotation.ComponentScan(value=com.hj.springboot_06_ssmp.component)
要扫描的包= com.hj.springboot_06_ssmp.component

第二步：得到要扫描的包下的所有资源(类.class)

//1.得到类的加载器
ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();

//2. 通过类的加载器获取到要扫描的包的资源 url=》类似一个路径
path = path.replace(".", "/");//一定要把. 替换成 /
URL resource = classLoader.getResource(path);
System.out.println("resource=" + resource);

运行结果：

resource=file:/F:/hspJava/SpringBoot/springboot/springboot_06_ssmp/target/classes/com/hj/springboot_06_ssmp/component

注意这里得到的资源路径是对应target文件下的：
在这里插入图片描述

//3. 将要加载的资源(.class) 路径下的文件进行遍历=>io
File file = new File(resource.getFile());//目录也是一个文件
System.out.println(file.isDirectory());
if(file.isDirectory()) {
    File[] files = file.listFiles();
    for (File f : files) {
        System.out.println("=======================");
        System.out.println(f.getAbsolutePath());
      //F:\hspJava\SpringBoot\springboot\springboot_06_ssmp\target\classes\com\hj\springboot_06_ssmp\component\UserService.class
        //获取到 com.hj.spring.component.UserService
        String fileAbsolutePath = f.getAbsolutePath();
    }
}

运行结果：
在这里插入图片描述

//这里我们只处理.class文件
if (fileAbsolutePath.endsWith(".class")) {
    //1. 获取到类名
    String className =
            fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
    System.out.println("className=" + className);

    //2. 获取类的完整的路径(全类名)
    //老师解读 path.replace("/",".") => com.hspedu.spring.component.
    String classFullName = path.replace("/", ".") + "." + className;
    System.out.println("classFullName=" + classFullName);

    //3. 判断该类是不是需要注入容器, 就看该类是不是有注解 @Component @Service..
    try {
        //这时，我们就得到该类的Class对象
        //Class clazz = Class.forName(classFullName)
        //老师说一下
        //1. Class clazz = Class.forName(classFullName) 可以反射加载类
        //2. classLoader.loadClass(classFullName); 可以反射类的Class
        //3. 区别是 : 上面方式后调用该类的静态方法, 下面方法不会
        //4. aClass.isAnnotationPresent(Component.class) 判断该类是否有 @Component
        Class<?> aClass = classLoader.loadClass(classFullName);
        if (aClass.isAnnotationPresent(Component.class) ||
                aClass.isAnnotationPresent(Controller.class) ||
                aClass.isAnnotationPresent(Service.class) ||
                aClass.isAnnotationPresent(Repository.class)) {

            //这里老师演示一个Component注解指定value,分配id
            //老师就是演示了一下机制.
            if(aClass.isAnnotationPresent(Component.class)) {
                //获取到该注解
                Component component = aClass.getDeclaredAnnotation(Component.class);
                String id = component.value();
                if(!"".endsWith(id)) {//不为空
                    className = id;//替换
                }
            }

            //这时就可以反射对象，并放入到容器中
            Class<?> clazz = Class.forName(classFullName);
            Object instance = clazz.newInstance();

            //放入到容器中, 将类名的首字母小写作为id
            //StringUtils
            ioc.put(StringUtils.uncapitalize(className) , instance);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

4. 总代码

/**
 * @author hj
 * SpringApplicationContext 类的作用类似Spring原生ioc容器
 */
public class SpringApplicationContext {
    private Class configClass;
    //ioc我存放的就是通过反射创建的对象(基于注解方式)
    private final ConcurrentHashMap<String, Object> ioc = new ConcurrentHashMap<>();

    public SpringApplicationContext(Class configClass) {
        this.configClass = configClass;

        //获取要扫描的包
        //1. 先得到HJSpringConfig配置的的@ComponentScan(value = "com.hj.springboot_06_ssmp.component")
        ComponentScan componentScan =(ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);//注解
        System.out.println("注解内容= " + componentScan);

        //2. 通过componentScan的value=> 即要扫描的包
        String path = componentScan.value();
        System.out.println("要扫描的包= " + path);

        //得到要扫描的包下的所有资源(类.class)
        //1.得到类的加载器
        ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();

        //2. 通过类的加载器获取到要扫描的包的资源 url=》类似一个路径
        path = path.replace(".", "/");//一定要把. 替换成 /
        URL resource = classLoader.getResource(path);//得到全路径
        System.out.println("resource=" + resource);
        System.out.println(resource.getFile());

        //3. 将要加载的资源(.class) 路径下的文件进行遍历=>io
        File file = new File(resource.getFile());//目录也是一个文件
        System.out.println(file.isDirectory());
        if(file.isDirectory()) {
            File[] files = file.listFiles();
            for (File f : files) {
                System.out.println("=======================");
                System.out.println(f.getAbsolutePath());
                //F:\hspJava\SpringBoot\springboot\springboot_06_ssmp\target\classes\com\hj\springboot_06_ssmp\component\UserService.class
                //获取到 com.hj.spring.component.UserService
                String fileAbsolutePath = f.getAbsolutePath();

                //这里我们只处理.class文件
                if (fileAbsolutePath.endsWith(".class")) {
                    //1. 获取到类名
                    String className =
                            fileAbsolutePath.substring(fileAbsolutePath.lastIndexOf("\\") + 1, fileAbsolutePath.indexOf(".class"));
                    System.out.println("className=" + className);

                    //2. 获取类的完整的路径(全类名)
                    //老师解读 path.replace("/",".") => com.hspedu.spring.component.
                    String classFullName = path.replace("/", ".") + "." + className;
                    System.out.println("classFullName=" + classFullName);

                    //3. 判断该类是不是需要注入容器, 就看该类是不是有注解 @Component @Service..
                    try {
                        //这时，我们就得到该类的Class对象
                        //Class clazz = Class.forName(classFullName)
                        //老师说一下
                        //1. Class clazz = Class.forName(classFullName) 可以反射加载类
                        //2. classLoader.loadClass(classFullName); 可以反射类的Class
                        //3. 区别是 : 上面方式后调用该类的静态方法, 下面方法不会
                        //4. aClass.isAnnotationPresent(Component.class) 判断该类是否有 @Component
                        Class<?> aClass = classLoader.loadClass(classFullName);
                        if (aClass.isAnnotationPresent(Component.class) ||
                                aClass.isAnnotationPresent(Controller.class) ||
                                aClass.isAnnotationPresent(Service.class) ||
                                aClass.isAnnotationPresent(Repository.class)) {

                            //这里老师演示一个Component注解指定value,分配id
                            //老师就是演示了一下机制.
                            if(aClass.isAnnotationPresent(Component.class)) {
                                //获取到该注解
                                Component component = aClass.getDeclaredAnnotation(Component.class);
                                String id = component.value();
                                if(!"".endsWith(id)) {//不为空
                                    className = id;//替换
                                }
                            }

                            //这时就可以反射对象，并放入到容器中
                            Class<?> clazz = Class.forName(classFullName);
                            Object instance = clazz.newInstance();

                            //放入到容器中, 将类名的首字母小写作为id
                            //StringUtils
                            ioc.put(StringUtils.uncapitalize(className) , instance);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }

    //编写方法返回对容器中对象
    public Object getBean(String name) {
        return ioc.get(name);
    }

    public static void main(String[] args) {
        SpringApplicationContext springApplicationContext = new SpringApplicationContext(HJSpringConfig.class);

    }
}

最后如果你觉得这篇文章对你有帮助的话，请转发、收藏和点赞哦！谢谢支持！👍👍👍
纸上得来终觉浅，绝知此事要躬行。希望大家不要光看，还要多练，自己去实现比你想明白更加的有趣！😜😜😜

Baridhu
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一步步深入理解Spring内部原理-带源码
11-10
为了深入理解Spring的内部原理，我们可以从以下几个关键知识点入手。 1. **依赖注入（Dependency Injection, DI）**：这是Spring的核心特性之一，允许对象之间的依赖关系在运行时被外部容器管理，而不是由对象自身...
基于注解的Spring_mvc增删改DEMO源码
08-25
在本项目中，"基于注解的Spring_mvc增删改DEMO源码"是一个针对初学者和开发者设计的学习资源，旨在深入理解Spring MVC框架如何使用注解进行 CRUD（创建、读取、更新、删除）操作。Spring MVC是Spring框架的一个模块...
Spring学习第一章、第三节：基于注解的配置
Wnliam的博客
11-07 150
Spring基于注解的配置前言使用Spring表达式什么是注解？正文基于Xml的配置组件扫描指定作用域 @ScopeSpring 生命周期延迟加载 @LazySpring关于注入的注解Spring @Required注解自动装配/依赖注入 @Autowired注解**Setter方法上的@Autowired****属性中的@Autowired****构造函数中的 @Autowired****@Au...
Spring 基于注解的配置
m0_51756019的博客
09-14 220
基于注解的配置 从 Spring 2.5 开始就可以使用注解来配置依赖注入。而不是采用 XML 来描述一个 bean 连线，你可以使用相关类，方法或字段声明的注解，将 bean 配置移动到组件类本身。 在 XML 注入之前进行注解注入，因此后者的配置将通过两种方式的属性连线被前者重写。 注解连线在默认情况下在 Spring 容器中不打开。因此，在可以使用基于注解的连线之前，我们将需要在我们的 Spring 配置文件中启用它。所以如果你想在 Spring 应用程序中使用的任何注解，可以考虑到下面的配置文件。
Spring基于注解配置
哈哈哈
06-30 203
前言 ​ 基于注解的方式配置在实际开发中使用更加广泛，一般只有非自己编写的类，需要将对象放入到IOC容器中管理才会使用到xml的配置，相比XML配置来说，注解更加简单。 一. 注解的类型 ​ 并不是说使用了注解之后，就可以不用使用xml文件，使用注解也需要配置xml文件，但是xml文件配置的不再是bean，而是配置扫描，扫描的配置指的是，Spring能够从配置的指定的classpath中自动扫描，侦测和实例化具有特定的Spring注解的组件【类】。Spring的特定的注解有哪些呢？ @Component：
spring--基础--05--基于注解的配置
zhou920786312的博客
09-20 197
五 基于注解的配置 @Required:应用于bean属性的setter方法。 @Autowired:应用到bean属性的setter方法,非setter方法,构造函数和属性。 @Qualifier：指定确切的的bean, @Autowired和@Qualifier注解可以用来删除混乱。 JSR-250Annotations:支持JSR-250的基础的注解 @Resource @PostConstruct @PreDestroy <?xml version="1.0" encoding=
SpringMVC的注解配置原理
IT_10的博客
05-28 605
META-INF\services\javax.servlet.ServletContainerInitializer web容器启动的时候，会扫描每个jar包中META-INF\services\javax.servlet.ServletContainerInitializer文件， 加载其中指定的ServletContainerInitializer的实现类，并调用onStartup方法。@HandlesTypes(value = {HelloServlet.class})用于指定一个接口，所有该接口的
深入理解Spring与Dubbo整合原理与源码分析：从启动类配置到注解解析.rar
最新发布
03-18
《深入理解Spring与Dubbo整合原理与源码分析：从启动类配置到注解解析》是一本专注于探讨Spring和Dubbo两大开源框架整合的技术书籍。本文将基于书中的主题，结合标签“spring”、“dubbo”和“软件/插件”，深入解析...
222-手把手带你写一个MiniSpring
05-06
7. **基于注解的配置**：让MiniSpring支持注解驱动的开发，如同Spring一样，开发者可以使用@Component、@Service、@Repository和@Controller等注解来标记类。 8. **单元测试**：编写测试用例，确保我们的MiniSpring...
Spring MVC工作原理 及注解说明1
08-03
通过上述讲解，我们可以理解Spring MVC的工作原理以及如何通过注解进行配置和控制。在实际开发中，结合Spring框架的其他组件，如IoC容器和AOP，Spring MVC能够提供强大的功能和灵活性，帮助开发者构建高效、可维护的...
【Spring（四）】Spring基于注解的配置方式
喃灬疯的博客
11-23 626
前面的三节，我们已经对Spring基于XML方式配置做了一个完整的讲解。从这节开始，我们开始对Spring基于注解的配置方式做一个讲解。
Spring基于注解的IoC配置
Demon的博客
09-20 2615
基于注解的IoC配置，与在xml中配置目的是一样的，都是降低代码之间的耦合度的，只是配置的形式不一样。 使用注解的步骤：     1、添加context的名称控件和约束     2、开启注解扫描：由spring扫描指定的包及其子包下的所有类，如果类上使用了@Component注解，就将该类装配到容器中     3、在类上使用@Component注解 使用注解之前一定要先开启注解扫描 &lt...
07-spring基于注解的配置
SO
09-05 204
一、简介 spring 虽然可以通过xml配置，来实现对bean的管理，但是xml的配置还是太过繁琐，所以实际开发中更多的是基于注解的模式。spring提供了4个注解，用来注入bean(代替<bean id =“xx” class=“xxx.xxx.xx”>这种xml配置)；分别为: @Controller 这个注解用来标识spring web工程的controller(控制器)层 @Service 用来标识业务逻辑的处理类 @Repository 用来标识dao层 @Component 这个
spring—使用注解配置Bean
永远不会懂
09-07 4950
从Spring2.5开始，出现了注解装配JavaBean的新方式。注解可以减少代码的开发量，spring提供了丰富的注解功能，现在项目中注解的方式使用的也越来越多了。   ** 开启注解扫描          Spring容器默认是禁用注解配置的。打开注解扫描的方式主要有两种: 组件扫描和注解配置。          一般选择第一种，因为第一种的功能比第二种强大的多。用于激活那些已经在Sp
基于注解配置的spring实例
weixin_37711738的博客
05-13 194
Spring（四）基于注解配置IOC容器&基于注解实现声明式事务
mrdu_somefun的博客
06-19 614
一、使用注解实现IOC配置 1.定义Bean——@Component [java] view plain copy package com.wzj.dao.impl;  import org.springframework.stereotype.Component;    @Component("userDao")  public class UserDaoImpl
spring 配置的两种方式：JAVA配置和注解配置
热门推荐
杜仁栋的专栏
01-16 2万+
众所周知，spring自从3.0开始以后，就全面推荐使用配置的方式进行代码编写了，这种方式确实可以避免了之前一个项目里面一大堆XML的情况，毕竟XML的可读性实在不怎么样，而且一会写JAVA，一会写XML，确实还是蛮麻烦的 就目前来说spring的配置方式一般为两种：JAVA配置和注解配置。那么什么的是注解配置呢？什么是JAVA配置呢?
注解配置与xml配置
m0_57725823的博客
05-19 424
注解配置与xml配置： xml配置：书写灵活，修改方便，单修改xml时不需要修改源码，不用重新编译和部署。但维护起来相对麻烦。是一种集中式的的元数据，与源代码无绑定。 注解配置：写起来比较简单方便，配置、维护简单，但是修改很麻烦。是一种分散式的的元数据，与源代码紧绑定。 xml优点： 1.使用xml配置可以让软件更具有扩展性； 比如，我们在spring中，我们不想使用接口而是想用接口的实现类，这个时候只需要修改xml配置中bean的class值就可以了。 2.对象之间的关系一目了然； 3.xml定义
（1）第一个程序（使用配置文件和注解）
墨白凉茶的博客
07-13 329
使用配置文件建立Hibernate程序 1. 建立实体类Student  public class Student { private int id; private String name; private int age; } 2. 建立数据库表student 3. 建立映射文件 student.hbm.xml, 建立实体类和表以及字段的对应关系 4. 建立Hib
springboot自动化配置原理.pdf
11-11
总之，深入理解Spring Boot的自动配置原理对于开发人员来说是非常重要的。它不仅可以帮助我们在面试时表现出色，还能在工作中帮助我们更好地使用Spring Boot，更快地完成项目开发。通过掌握自动配置原理，我们可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值