spring之HelloWord版

最新推荐文章于 2024-08-14 23:30:00 发布
最新推荐文章于 2024-08-14 23:30:00 发布
阅读量634 收藏 9
点赞数 7
分类专栏： spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48254383/article/details/140041790
版权

目录

基础结构说明

涉及到的功能

执行流程

spring包

引导类

bean定义

注解

回调接口拓展

测试入口

service包

回调接口拓展实现

实体类

自定义注解

基础结构说明

  1. spring子包内，放置spring源码相关类，如注解定义，引导类执行逻辑等

  2. service子包，放置测试类，用于测试spring相关功能，如实体类、自主实现的后处理拓展等

涉及到的功能

  1. componentscan扫描包

  2. component bean注入

  3. Scope bean作用域

  4. beanDefintion bean定义对象

  5. beanDefintionMap bean定义对象集合

  6. getBean 获取容器bean

  7. createBean 创建容器bean

  8. autowird 依赖注入

  9. BeanNameAware 初始化阶段回调拓展

  10. initializingBean 初始化后回调拓展

  11. beanPostProcess bean后置处理器拓展

    1. AOP

    2. vaulue注入

执行流程

引导类构造器（启动入口）

  1. scan扫描（装配BDMap）

    1. 获取引导配置类的扫描注解的路径

    2. 解析处理路径获取类路径下的所有类资源

    3. 遍历所有类

      1. 处理类的相对路径，通过类加载器获取类的class对象

      2. 处理component注解获取beanname

        1. 扫描当前类如果实现了bean后置处理器则加入list

      3. 处理scope注解默认单例

      4. 组装beandeftion对象，组装beanDefinitionMap

  2. 遍历bdMap创建单例对象 多例直接获取的时候创建

    1. createBean创建bean，使用反射获取无参构造器获取对象

    2. aware拓展BeanNameAware拓展 bean初始化的阶段生效

    3. BeanPostProcessor拓展，before处理

    4. InitializingBean初始化后拓展

    5. BeanPostProcessor拓展，after处理

  3. 创建好的bean加入单例池

spring包

引导类

package com.spring;

import com.butch.AppConfig;

import java.beans.Introspector;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

//相当于引导类
public class ButchSpringApplicationContext {

    private Class configClass;

    private Map<String, BeanDefinition> beanDefinitionMap = new HashMap();

    //单例池
    private Map<String, Object> singletonObjects = new HashMap();

    private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();



    //构造器进入spring的启动流程
    public ButchSpringApplicationContext(Class configClass){
        this.configClass = configClass;

        //开启扫描包
        scan(configClass);
        
        //遍历bdMap 创建单例对象 多例直接获取的时候创建
        for (Map.Entry<String,BeanDefinition> map : beanDefinitionMap.entrySet()) {
            String beanName = map.getKey();
            BeanDefinition beanDefinition = map.getValue();
            if ("singleton".equals(beanDefinition.getScope())){
                Object bean = createBean(beanName, beanDefinition);
                singletonObjects.put(beanName,bean);
            }

        }

    }

    //创建Bean
    private Object createBean(String beanName, BeanDefinition beanDefinition) {
        //使用反射
        Class type = beanDefinition.getType();
        Object instance = null;
        try {
            instance = type.getConstructor().newInstance();
            //处理依赖注入

            Field[] declaredFields = type.getDeclaredFields();
            //遍历该类所有属性 是否加了依赖注入注解
            for (Field declaredField : declaredFields) {
                if (declaredField.isAnnotationPresent(Autowired.class)){
                    //进行依赖注入
                    declaredField.setAccessible(true);
                    declaredField.set(instance,getBean(declaredField.getName()));
                }
            }

            //BeanNameAware拓展 bean初始化的阶段生效
            if (instance instanceof BeanNameAware){
                ((BeanNameAware) instance).setBeanName(beanName);
            }

            //后置处理器前扩展
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                beanPostProcessor.postProcessBeforeInitialization(instance,beanName);
            }

            if (instance instanceof InitializingBean){
                ((InitializingBean) instance).afterPropertiesSet();
            }


            //后置处理器后扩展
            for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
                instance = beanPostProcessor.postProcessAfterInitialization(instance,beanName);
            }


        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

        return instance;
    }

        //getbean方法
    public Object getBean(String beanName){
        //主要根据BDMap判断获取
        if (!beanDefinitionMap.containsKey(beanName)){
            throw new NullPointerException();
        }
        BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
        //区分单例多例
        if ("singleton".equals(beanDefinition.getScope())){
            //单例直接从单例池获取
            Object singletonBean = singletonObjects.get(beanName);
            if (singletonBean == null){
                singletonBean = createBean(beanName,beanDefinition);
                singletonObjects.put(beanName,singletonBean);
            }
            return singletonBean;
        }else {
            //多例直接创建
            return createBean(beanName, beanDefinition);
        }

    }

    private void scan(Class configClass){
        //获取配置类的注解
        if (configClass.isAnnotationPresent(ComponentScan.class)){
            ComponentScan componentScan = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
            //处理注解的value路径
            String path = componentScan.value();
            path = path.replaceAll("\\.","/");
            System.out.println("path = " + path);

            //获取应用类加载器
            ClassLoader classLoader = ButchSpringApplicationContext.class.getClassLoader();
            //获取路径下的资源
            URL resource = classLoader.getResource(path);
            //处理资源文件
            File file = new File(resource.getFile());
            if (file.isDirectory()){
                for (File o : file.listFiles()) {
                    String absolutePath = o.getAbsolutePath();
                    //处理类路径 absolutePath = com.butch.serivce.UserService
                    absolutePath = absolutePath.substring(absolutePath.indexOf("com"), absolutePath.indexOf(".class"));
                    absolutePath = absolutePath.replace("\\", ".");
                    System.out.println("absolutePath = " + absolutePath);
                    //开始装配有component注解的对象
                    try {
                        //通过应用类加载器获取类的class对象
                        Class<?> aClass = classLoader.loadClass(absolutePath);
                        if (aClass.isAnnotationPresent(Component.class)) {
                            //加入自主实现的后置处理器
                            if (BeanPostProcessor.class.isAssignableFrom(aClass)){
                                BeanPostProcessor beanPostProcessor = (BeanPostProcessor) aClass.getConstructor().newInstance();
                                beanPostProcessorList.add(beanPostProcessor);
                            }
                            Component annotation = aClass.getAnnotation(Component.class);
                            //获取beanname
                            String beanName = annotation.value();
                            if ("".equals(beanName)) {
                                //jdk提供的默认beanName
                                beanName = Introspector.decapitalize(aClass.getSimpleName());
                            }
                            BeanDefinition beanDefinition = new BeanDefinition();
                            beanDefinition.setType(aClass);
                            //处理bean是否单例
                            if (aClass.isAnnotationPresent(Scope.class)) {
                                Scope scope = aClass.getAnnotation(Scope.class);
                                String value = scope.value();
                                beanDefinition.setScope(value);
                            } else {
                                //默认单例
                                beanDefinition.setScope("singleton");
                            }
                            //放入bean定义map
                            beanDefinitionMap.put(beanName, beanDefinition);

                        }

                    }catch (Exception e){
                        e.printStackTrace();
                    }

                }
            }
        }
    }
    
}

bean定义

package com.spring;

/**
 * bean定义对象 存放一些bean的公共属性
 */
public class BeanDefinition {

    private Class type;
    private String scope;
    private boolean isLazy;

    public Class getType() {
        return type;
    }

    public void setType(Class type) {
        this.type = type;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    public boolean isLazy() {
        return isLazy;
    }

    public void setLazy(boolean lazy) {
        isLazy = lazy;
    }
}

注解

package com.spring;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//依赖注入
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired {


}

package com.spring;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {

    String value() default "";

}

package com.spring;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {

    String value() default "";

}

 

package com.spring;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {

    String value() default "";

}

回调接口拓展

package com.spring;

public interface BeanNameAware {

    void setBeanName(String name);
}

package com.spring;

//bean后置处理器
public interface BeanPostProcessor {

    default Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

    default Object postProcessAfterInitialization(Object bean, String beanName) {
        return bean;
    }
}

package com.spring;

//初始化后
public interface InitializingBean {
    void afterPropertiesSet();
}

测试入口

package com.butch;

import com.butch.serivce.UserInterface;
import com.spring.ButchSpringApplicationContext;

public class TestSpring {


    public static void main(String[] args) {

        //开启扫描配置类 -> 创建单例bean
        ButchSpringApplicationContext butchSpringApplication = new ButchSpringApplicationContext(AppConfig.class);

        UserInterface userService = (UserInterface) butchSpringApplication.getBean("userService");
        userService.test();

    }
}

 

package com.butch;

import com.spring.ComponentScan;

@ComponentScan("com.butch.serivce")
public class AppConfig {


}

service包

回调接口拓展实现

package com.butch.serivce;

public interface UserInterface {

    public void test();
}

package com.butch.serivce;

import com.spring.BeanPostProcessor;
import com.spring.Component;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//使用jdk代理实现一个aop
@Component
public class ButchBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if ("userService".equals(beanName)){
            Object proxyInstance = Proxy.newProxyInstance(ButchBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("==========beanPostProcessAop================");
                    Object invoke = method.invoke(bean, args);
                    return invoke;
                }
            });
            return proxyInstance;
        }
        return bean;
    }
}

package com.butch.serivce;

import com.spring.BeanPostProcessor;
import com.spring.Component;

import java.lang.reflect.Field;

//注入后置处理
@Component
public class ButchValueBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        for (Field field : bean.getClass().getDeclaredFields()) {
            //查看bean属性是否有value注解
            if (field.isAnnotationPresent(ButchValue.class)){
                //注入值
                field.setAccessible(true);
                try {
                    field.set(bean,field.getAnnotation(ButchValue.class).value());
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }

        }

        return bean;
    }
}

 

实体类

package com.butch.serivce;

import com.spring.*;

/**
 */
@Component
@Scope
public class UserService implements BeanNameAware,UserInterface,InitializingBean{


    @Override
    public void afterPropertiesSet() {
        System.out.println("==========InitializingBean==========初始化后处理");
    }

    @Autowired
    private OrderService orderService;

    @ButchValue("butch")
    private String name;

    public void test() {
        System.out.println("===============orderService============" + orderService + "=============" + name);
    }

    public void setBeanName(String name) {
        System.out.println("============BeanNameAwar==========" + name);
    }
}

package com.butch.serivce;


import com.spring.Component;

/**
 */

@Component
public class OrderService {

    public void test() {
        System.out.println("test");
    }
}

自定义注解

package com.butch.serivce;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ButchValue {

    String value() default "";
}

李卫公的开平方机
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring创建HelloWord工程
qq_43366662的博客
05-09 171
Spring创建HelloWord工程 1.创建maven工程 ​ 创建一个新的工程，选择左侧的maven，Next。填入GroupId(组名)和ArtifactId（模块名），Next。填入项目名，Finish即可完成maven工程的创建。 ​ 导入Spring工程所需的依赖，在pom.xml中将下面内容写入。 ​ denpendency节点必须要有dependencies父节点包裹，否则会报错。 <dependency> <groupId>org.spri
java之spring之helloword
weixin_30570101的博客
07-23 56
这篇文章主要讲 spring的基础的使用案例 项目整体目录结构： 1.新建一个java项目：spring_helloworld 2.在项目下创建一个lib文件夹，并把一些必须的jar包复制过去 新建lib文件夹 把需要的jar包复制到lib文件夹下，jar包如下： 　　commons-logging-1.1.1.jar 　　spring-beans-4.1.6....
spring helloWord
JiaWei
03-17 246
第一步：创建一个简单的spring bean public class HelloWord { private String name; public String getName() { return name; } public void setName(String name) { this.name = name...
Spring之HelloWord！（一）
皮皮昌的博客
12-01 92
1.配置web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jc
Spring MVC Helloword代码
08-30
在这个"Spring MVC HelloWord代码"示例中，我们将探讨如何创建一个基本的Spring MVC应用程序。 首先，我们需要理解Spring MVC的基本组成部分： 1. **DispatcherServlet**：这是Spring MVC的前端控制器，负责接收...
spring_helloword
01-25
"spring_helloWord"这个项目是一个入门级别的示例，用于介绍如何在Java项目中配置和使用Spring框架。下面我们将深入探讨Spring框架的基础知识和在这个"spring_helloWord"项目中可能涉及的关键概念。 1. **Spring...
SpringSecurityDemo:Spring Security HelloWord
05-24
在"Spring SecurityDemo: Spring Security HelloWord"这个项目中，我们将会探讨如何使用Spring Security来创建一个简单的Spring MVC应用程序，并实现基本的安全控制。 首先，Spring Security的核心在于提供了一个...
spring-boot入门helloword
01-03
Spring Boot 是一个由 Pivotal 团队开发的框架，旨在简化 Spring 应用程序的初始搭建以及开发过程。它的核心特性是可以内嵌Servlet容器，如Tomcat或Jetty，这样就无需额外的服务器配置即可运行Java应用。在这个...
springmvc 之helloword
08-05
本文将深入探讨"springmvc 之helloworld"这一主题，旨在为初学者提供一个清晰的入门指南。 Spring MVC的核心概念是Model-View-Controller（模型-视图-控制器）架构模式，它简化了Web应用开发，将业务逻辑、数据处理...
SpringMVC快速入门
最新发布
bobplease的博客
08-14 702
文章总结了SpringMVC的使用流程，以及处理请求时的流程和异常处理，拦截器，过滤器以及跨域问题的解决。
SpringBoot的使用的注解以及监控监控和lombok使用
luosuss的博客
08-14 409
我们可以进入源码查看。
spring中的事务
menghuannvxia的专栏
08-13 258
方法发生异常就会触发事务管理，在spring中想进行事务回滚必须加上@Transactional注解，下边是出现异常进行捕获进行回滚的源代码。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 459
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
【JavaEE】深入理解Spring中的IoC与DI：从依赖注入到Bean管理的详解
Hsusan的博客
08-14 524
学习了IoC后, 什么是DI呢?IoC是一种思想，DI是一种实现方式DI: Dependency Injection(依赖注⼊)容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源，称之为依赖注⼊。程序运⾏时需要某个资源，此时容器就为其提供这个资源.从这点来看, 依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。上述代码中, 是通过构造函数的⽅式, 把依赖对象注⼊到需要使⽤的对象中的。
Java面试--框架--Spring MVC
weixin_41624547的博客
08-14 431
Spring MVC是一款由Spring Framework 提供的 web组件，实现mvc设计模式的一款框架，Java web开发者必会框架，前后端不分离。MVC是一种软件架构思想，把软件按照模型，视图，控制器来划分Model:模型层，指工程中的JavaBean，用来处理数据，JavaBean分成两类：一类称为实体类Bean:专门用来存储业务数据(返回和接收数据)，比如Student,User一类称为业务处理Bean:指Servlet或Dao对象，专门用来处理业务逻辑和数据访问。
基于springboot的二手车交易系统的设计与实现
weixin_43213064的博客
08-14 335
【代码】springboot基于springboot的二手车交易系统的设计与实现
SpringBoot优雅开发REST API最佳实践
糖拌西红柿
08-13 1091
SpringBoot接口版本控制、接口动态版本号、参数校验、@validated注解、Controller统一异常拦截、@RestControllerAdvice注解、参数处理、Swagger使用方法、接口文档
SpringBoot中生成条形码的方案实战
2301_76419561的博客
08-14 721
ZXing库是一个用于解析和生成多种格式的一维和二维条形码的开源Java库。ZXing（“zebra crossing”的缩写）库提供了多种条形码格式的支持，包括但不限于QR码、Data Matrix、EAN、UPC和Codabar等。它不仅能够在Java平台上使用，还提供了其他编程语言的端口，如C++、ObjC（用于iOS开发）以及ActionScript等。ZXing的设计旨在支持复杂的条形码识别功能，并能够通过摄像头捕获条形码图像进行解码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值