模拟Spring的实现 —— 注入

最新推荐文章于 2021-04-25 21:24:56 发布
最新推荐文章于 2021-04-25 21:24:56 发布
阅读量159 收藏
点赞数
分类专栏： JAVASE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41949320/article/details/104350236
版权

本篇博文并不是讲Spring的，而是模拟Spring，比如说以前笔者写过的包扫描工具，就可以在此时起到用场。
Spring最基本的两个功能：IOC 、AOP。

  • 控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI）

  • 控制反转 将创建对象的权利 反转给了Spring

  • AOP为 Aspect Oriented Programming 的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

  • 什么叫依赖？
    class B{
    private A a； //B类依赖于A类
    }

有关对IOC的理解，推荐一个文章 IoC 之 2.1 IoC基础 ——跟我学Spring3
本篇博文主要的是 如何注入

首先给出两个注解（xml解析会更好，不用改java代码）

import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

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

@Retention(RUNTIME)
@Target(FIELD)
public @interface Autowired
{
    // 注解属性的默认值不能是null
    String name() default "";

}


import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

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

@Retention(RUNTIME)
@Target(TYPE)
public @interface Component
{
    String name() default "";

    // singelton用在类前，代表是否单例，默认是单例singelton=true;
    boolean singelton() default true;
}

给出两个javaBean

import annotation.Component;

// javaBean
@Component
public class Complex
{
    private double real;
    private double vir;

    public Complex()
    {

    }

    public double getReal()
    {
        return real;
    }

    public void setReal(double real)
    {
        this.real=real;
    }

    public double getVir()
    {
        return vir;
    }

    public void setVir(double vir)
    {
        this.vir=vir;
    }

    @Override
    public String toString()
    {
        return "Complex [" + real + ", " + vir + "]";
    }

}


import annotation.Autowired;
import annotation.Component;

// javaBean
@Component
public class ClassOne
{
    // Autowired后跟的name，需要注入谁，就跟谁
    @Autowired
    private Complex complex;
    // 给八大基本类型上autowired意义不大
    private String str;

    public ClassOne()
    {
        // TODO 自动生成的构造函数存根
    }

    public Complex getComplex()
    {
        return complex;
    }

    public void setComplex(Complex complex)
    {
        this.complex=complex;
    }

    public String getStr()
    {
        return str;
    }

    public void setStr(String str)
    {
        this.str=str;
    }

    @Override
    public String toString()
    {
        return "ClassOne [" + complex + ", " + str + "]";
    }

}

接下来是 注入 的核心所在，另外还有 PackageScanner.java，HasNoBeanException.java 需要读者补充

public class BeanDefinition
{
    private Class<?> klass;
    private Object object;// 用来取对象
    private boolean inject;// 判断是否注入

    // 应该给出包权限，给Spring内部用
    BeanDefinition()
    {
        this.inject=false;
    }

    public boolean isInject()
    {
        return inject;
    }

    public void setInject(boolean inject)
    {
        this.inject=inject;
    }

    public Class<?> getKlass()
    {
        return klass;
    }

    public void setKlass(Class<?> klass)
    {
        this.klass=klass;
    }

    public Object getObject()
    {
        return object;
    }

    public void setObject(Object object)
    {
        this.object=object;
    }

    @Override
    public String toString()
    {
        return "BeanDefinition [klass=" + klass + ", object=" + object + "]";
    }

}


import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

import annotation.Autowired;
import annotation.Component;
import scanner.PackageScanner;

// Bean工厂中的Bean，都是单例的。如果想多例，必须加以声明
public class BeanFactory
{
    private static final Map<String, BeanDefinition> beanpool;
    static
    {
        beanpool=new HashMap<String, BeanDefinition>();
    }

    public BeanFactory()
    {
        // TODO 自动生成的构造函数存根
    }

    // 把相应的东西扫描到beanPool里面
    public static void scanBeanByPackage(String packageName)
    {
        new PackageScanner()
        {

            @Override
            public void dealClass(Class<?> klass)
            {
                if(klass.isPrimitive() || klass.isInterface() || klass.isAnnotation() || klass.isEnum() || klass.isArray()
                        || !klass.isAnnotationPresent(Component.class))
                {
                    return;// 不处理以上类
                }
                try
                {
                    Object object=klass.newInstance();
                    BeanDefinition bd=new BeanDefinition();
                    bd.setKlass(klass);
                    bd.setObject(object);

                    beanpool.put(klass.getName(), bd);
                }
                catch(InstantiationException e)
                {
                    e.printStackTrace();
                }
                catch(IllegalAccessException e)
                {
                    e.printStackTrace();
                }

            }
        }.scanPackage(packageName);
    }

    // 包权限,给内部使用
    BeanDefinition getBeanDefinition(String klassName)
    {
        return beanpool.get(klassName);
    }

    // 包权限,给内部使用
    BeanDefinition getBeanDefinition(Class<?> klass)
    {
        return getBeanDefinition(klass.getName());
    }

    // 注入
    private void injectProperties(BeanDefinition beanDefinition) throws Exception
    {
        Class<?> klass=beanDefinition.getKlass();
        Object object=beanDefinition.getObject();

        Field[] fields=klass.getDeclaredFields();
        for(Field field : fields)
        {
            // 检测成员是否需要注入
            if(!field.isAnnotationPresent(Autowired.class))
            {
                continue;
            }
            field.setAccessible(true);// 保证成员能够被赋值，权限
            // 取出以该成员类型作为Bean关键字的对象
            Object value=getBean(field.getType());
            if(value == null)
            {
                throw new HasNoBeanException("类[" + klass.getName() + "]的[" + field.getName() + "]成员没有对应的Bean");
            }
            field.set(object, value);
            System.out.println("注入过程");
        }
        beanDefinition.setInject(true);// 表示已经注入完毕
    }

    // 用泛型使用方便
    public <T> T getBean(String klassName) throws RuntimeException
    {
        BeanDefinition bd=getBeanDefinition(klassName);
        if(bd == null)
        {
            return null;
        }
        Object result=bd.getObject();
        // 如果没有注入了，那就注入
        if(!bd.isInject())
        {
            try
            {
                injectProperties(bd);
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }

        }
        return (T) result;

    }

    public <T> T getBean(Class<T> klass) throws RuntimeException
    {
        return getBean(klass.getName());
    }

}

在这里插入图片描述

  • 从运行结果的第三行：true，表明了Bean工厂中的Bean，都是单例的！
  • 第四行可以看出我们成功实现注入：
    将Java Bean（Complex.java）组织到一个容器中，就形成所谓的“上下文”或者容器。
  • 模拟实现时采用“懒汉模式”，即只有相关的Bean在被 getBean() 时，才需要注入。
  • 大家可以试着把 Complex.java 的 @Component 去掉，通过自定义异常的方式来处理。
晚点喝可乐z
关注
专栏目录
Spring boot——Actuator 详解
weixin_45985053的博客
07-19 3万+
SpringBoot提供了所谓的endpoints（下文翻译为端点）给外部来与应用程序进行访问和交互。打比方来说，/health端点提供了关于应用健康情况的一些基础信息。metrics端点提供了一些有用的应用程序指标（JVM内存使用、系统CPU使用等）。这些Actuator模块本来就有的端点我们称之为原生端点。应用配置类获取应用程序中加载的应用配置、环境变量、自动化配置报告等与SpringBoot应用密切相关的配置类信息。度量指标类操作控制类提供了对应用的关闭等操作类功能。...
Spring源码——AOP
等一杯咖啡的博客
10-21 2248
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
模拟spring
08-10
NULL 博文链接：https://scgaoll.iteye.com/blog/2199348
模拟spring注入
指尖岁月，“码”的人生
09-06 162
尊重原创：原创和源代码地址 项目中的的spring出现问题，不想使用spring框架进行注入，编写一个简单的spring，实现xml解析和类的注入。所有的框架都可以用java项目，用到了java提供的基础类，所以用到的原理也就呢么多（我刚开始工作2个月，说的不对请谅解）。因此spring用到了注入用到java中的反射机制，aop用到了java的代理机制proxy对象。总结一下自己的设计： 设计...
模拟Spring
m0_46550105的博客
04-20 128
1.常规的类管理方式是：1.使用动态代理将业务逻辑的实现类构建出来,Dao jdkProxy= (Dao) Proxy.newProxyInstance(Test.class.getClassLoader(), new Class[]{Dao.class}, new NiuInvocationHandler(new DaoImpl()));然后执行相应的业务逻辑。 2.将把类放入工厂中，让工厂进行...
模拟spring依赖注入
qq_28852755的博客
09-21 171
1.依赖注入可能会造成循环依赖 解决办法为构造2个map 1个是完整的bean对象 一个是早期暴露出的bean对象 private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>(); private ConcurrentHashMap<String, Object> earlySingletonObjects = new ConcurrentHashM
模拟Spring(一)
rjx20001的专栏
02-28 144
学过Java的人对SSH都不会陌生，其中Spring备受青昧除了它的"轻"之外，还因为他的IOC与AOP两大功能的强大。IOC是Spring的核心概念，全称“Inversion Of Control”，翻译成中文是“控制反转”，很多人都把它叫做“依赖注入(Dependency Injection)”。而它的抽象概念是“[color=red]依赖关系的转移[/color]”。转移是...
Java模拟spring实现
04-27
在本文中，我们将探讨如何通过Java来模拟Spring框架的基本功能。Spring是一个广泛应用的开源框架，它主要为Java应用程序提供依赖注入（Dependency Injection，DI）和面向切面编程（Aspect-Oriented Programming，AOP...
模拟Spring IoC
08-17
自己写了一个Spring IoC的模拟,有详细注释,可供刚入门学习spring的童鞋加深理解.
自己动手模拟spring
06-06
代码详解：http://blog.csdn.net/csh624366188/article/details/7637705
简单模拟spring框架原理
05-28
NULL 博文链接：https://huchunyong1987.iteye.com/blog/836235
模拟Spring实现方法注入
Ailsazxk的博客
04-13 160
模拟Spring实现方法的注入 此篇是模拟Spring框架依赖注入的第一篇文章，主要是先实现对成员，方法的对应的类的注入工作。 基本思路： 将应用所涉及到的类及其对象，都存储到一个集合中，这个集合中的类对应的成员也存储在这个池子(集合)中，成员的初始化由集合中的类对象所给予；以后需要用到这些类的对象，直接从这个集合(池子)中取得。 也就是说，我们需要构建一个容器(上下文)，这个容器中存储类及其对...
Spring（一）：模拟Spring Ioc
PorUnaCabeza
04-06 459
最近重温了一下Spring，还是写点东西出来，帮助自己记忆和加强对Spring的理解，也希望能够帮助大家学习Spring。 首先要提一个Spring框架的核心是思想即IOC（Inversion of Control：控制反转），也称为DI（依赖注入：Dependency Injection），那么IOC究竟是什么呢？ IOC（DI）：其实Spring的这个核心概念并没有那么复杂，我
模拟Spring实现
凛冬将至
04-25 115
我们知道Spring最主要的就是帮我们管理Service，Dao，还有Action。 今天我们就来模拟一下Spring实现的原理，其实就是解析xml和反射机制。 以用户添加为例，直接上代码： 1.User.java public class User { private String username; private String password; publ...
模拟spring的注入和读取配置文件(ApplicationContext.xml)
编程小强
06-17 1595
转载自:http://blog.csdn.net/xiangsuixinsheng/article/details/6539324 场景：用户添加到数据库中 传统方式保存实例3个问题： 1/改动数据保存方式，如保存到XML文件中会造成程序变更 2/UserService无法在单实例情况下被重用，因为它的声明在test.java中 3/UserService引用其它资源
简单模拟Spring容器（一）
qq_34721505的博客
08-25 437
本次模拟非常简单，所以直接上代码！ 一、配置文件bean.xml 二、实体类Test package com.summer.test; public class Test { public void test(){ System.out.println("=======test========="); } } 三、模拟Spring容器SpringConte
手动模拟Spring（一）
了不起的盖茨比的博客
04-25 439
1.写在前面 由于上次看spring的源码的时候已经是半年前了，笔者对spring的源码只记得一个大概了，于是我打算重新看一次spring的源码，看spring的源码之前最好的方式就是模拟一遍spring的，但是奈何我的水平有限，于是就去网上找现成的例子，于是笔者找到了GitHub上的一个项目《tiny-spring》,本系列的博客主要是参考这个开源项目来写的，加上自己的一些理解。 2.step1最基本的容器。 看过我的spring源码的系列的专题，都知道spring的Bean的描述信息都是通过一个类Bea
Spring模拟实现详解：从实体类到数据层接口
这个Java模拟Spring实现的例子展示了Spring的核心特性——依赖注入和控制反转，以及如何通过接口和实现类来组织代码，实现松耦合。在实际项目中，Spring提供了更丰富的功能，如AOP（面向切面编程）、事务管理、数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值