spring系列之di

最新推荐文章于 2024-07-30 19:40:03 发布
最新推荐文章于 2024-07-30 19:40:03 发布
阅读量207 收藏
点赞数

DI即依赖注入，其实是springIOC中的一种模式，spring的注入方式有三种，构造方法注入、setter方法注入以及注解注入。下面主要讨论一下注解注入，首先，项目启动时，扫描所有的包，然后读取包下的.class文件，将对象实例化之后放入ioc容器。

注解

package annotation;

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

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

}

package annotation;

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 MyComponent {

    //此注解定义为scope属性
    public String scope() default "";
}

package annotation;

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

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

    public String value();
}

实体

package entity;

import annotation.MyComponent;
import annotation.MyValue;

@MyComponent
public class User {

    @MyValue("1")
    private Integer id;
    @MyValue("xiaoming")
    private String name;
    @MyValue("123456")
    private String password;
    
    public User() {
        System.out.println("无参构造方法执行");
    }
    
    public void login(){
        System.out.println("用户登录：id=" + id + ", name=" + name + ", password=" + password);
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
    
}

applicationContext文件，主要逻辑的处理

package applicationContext;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.util.Collection;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import annotation.MyAutowired;
import annotation.MyComponent;
import annotation.MyValue;


public class AnnotationConfigApplicationContext {

    private Map<String,Class<?>> beanDefinationFactory = new ConcurrentHashMap<>();//用于存储类定义对象
    private Map<String,Object> singletonBeanFactory = new ConcurrentHashMap<>();//用于存储单例对象
    
    //有参构造方法，参数类型为指定要加载的包名，此工厂可以接受多个包路径
    public AnnotationConfigApplicationContext(String... packageNames) {
        for(String packageName: packageNames){
            System.out.println("开始扫描包：" + packageName);
            //扫描指定的包路径
            scanPkg(packageName);
        }
        //进行依赖注入
        dependencyInjection();
    }
    
    //扫描指定包，找到包中的类文件，对于标准类文件(类上有注解定义的)，反射加载创建类，定义对象放到容器中
    private void scanPkg(final String packageName) {
        String pkgName = packageName.replaceAll("\\.", "/");
        //获取目录结构在类文件中的位置
        URL url = getClass().getClassLoader().getResource(pkgName);
        //基于这个路径资源，创建一个文件对象
        File file = new File(url.getFile());
        //获取此目录中指定的标准类文件(以.class结尾的文件)
        File[] files = file.listFiles(new FileFilter() {
            
            @Override
            public boolean accept(File file) {
                String name = file.getName();
                //判断该文件是否为目录，若为目录，则继续扫描该文件
                if(file.isDirectory()){
                    scanPkg(packageName + "." + name);
                }else{
                    //判断文件名是否为.class文件
                    if(name.endsWith(".class")){
                        return true;
                    }
                }
                return false;
            }
        });
        
        for(File fs: files){
            String name = fs.getName();
            //获取去除.class之后的文件名
            name = name.substring(0, name.indexOf("."));
            //将类名的第一个字母转换为小写(用它作为key存储在工厂中)
            String beanId = String.valueOf(name.charAt(0)).toLowerCase() + name.substring(1);
            //构建一个全类名
            String claPkg = packageName+ "." + name;
            try {
                //通过反射构建类对象
                Class<?> cls = Class.forName(claPkg);
                //判断这个类上是否有mycomponent注解
                if(cls.isAnnotationPresent(MyComponent.class)){
                    //将类对象存储到容器中
                    beanDefinationFactory.put(beanId, cls);
                }
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
    
    /*此方法用于对属性进行依赖注入，从工厂中获取所有的类对象，
     *如果对象的属性有MyAutowired注解，首先根据属性名获
     *取对象，或者根据对象类型获取对象，最后用该对象对属性进
     *行注入*/
    private void dependencyInjection() {
        //获取容器中所有类定义的对象
        Collection<Class<?>> classes = beanDefinationFactory.values();
        for(Class cls: classes){
            String clsName = cls.getName();
            //获得类名
            clsName = clsName.substring(clsName.indexOf(".") + 1);
            //将类名的第一个字母转换为小写
            String beanId = clsName.valueOf(clsName.charAt(0)).toLowerCase() + clsName.substring(1);
            //获取类中所有的属性
            Field[] fields = cls.getDeclaredFields();
            for(Field filed: fields){
                try {
                    // 如果这个属性上有MyAutowired，进行注入操作
                    if (filed.isAnnotationPresent(MyAutowired.class)) {
                        // 获取属性名
                        String fName = filed.getName();
                        System.out.println("属性名：" + fName);
                        // 定义为属性注入的Bean对象(从容器中取得)
                        Object filedBean = null;
                        // 首先根据属性名从容器中去除对象，如果不为空，则赋值给filedBean对象
                        if (beanDefinationFactory.get(fName) != null) {
                            filedBean = getBean(fName, filed.getType());
                        } else {
                            // 按照属性的类型从容器中取出对象进行注入
                            String type = filed.getType().getName();
                            // 截取最后的类名
                            type = type.substring(type.indexOf(".") + 1);
                            // 将类名的第一个字母转换为小写
                            String filedBeanId = type.valueOf(type.charAt(0)).toLowerCase() + type.substring(1);
                            System.out.println("属性类型ID：" + filedBeanId);
                            // 根据转换后的beanId从容器中获取bean对象，赋值给filedBean
                            filedBean = getBean(filedBeanId, filed.getType());
                        }
                        System.out.println("要注入的属性值：" + filedBean);
                        // 如果filedBean对象不为空，则为该属性进行注入
                        if (filedBean != null) {
                            // 获取此类定义对象的实例
                            Object clsBean = getBean(beanId, cls);
                            // 设置该属性为可访问
                            filed.setAccessible(true);
                            // 为该属性注入值
                            filed.set(clsBean, filedBean);
                            System.out.println("注入成功！");
                        }else{
                            System.out.println("注入失败！");
                        }
                    }
                } catch (IllegalArgumentException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //此方法为重载方法
    public <T>T getBean(String beanId, Class<T> c) {
        return (T)getBean(beanId);
    }
    
    //根据传入的beanId获取容器中的对象，类型为Object
    public Object getBean(String beanId) {
        //根据传入的BeanId获取类对象
        Class<?> cls = beanDefinationFactory.get(beanId);
        //根据类对象获取其定义的注解
        MyComponent annotation = cls.getAnnotation(MyComponent.class);
        String scope = annotation.scope();
        try {
            if ("singleton".equals(scope) || "".equals(scope)) {
                // 判断容器中是否已有该对象的实例，如果没有，就创建一个放到容器中
                if (singletonBeanFactory.get(beanId) == null) {
                    Object instance = cls.newInstance();
                    setFiledValue(cls,instance);
                    singletonBeanFactory.put(beanId, instance);
                }
                return singletonBeanFactory.get(beanId);
            }
            //如果scope为prototype,则创建并返回多例
            if("prototype".equals(scope)){
                Object instance = cls.newInstance();
                setFiledValue(cls,instance);
                return instance;
            }
        } catch (InstantiationException | IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /*此方法用于为对象的属性赋值，内部时通过获取成员属性上注解的值，在转换类型之后，通过反射为对象赋值*/
    private void setFiledValue(Class<?> cls, Object obj) {
        //获取类中所有的成员属性
        Field[] fields = cls.getDeclaredFields();
        for(Field field: fields){
            //如果此属性有MyValue注解，对其进行操作
            if(field.isAnnotationPresent(MyValue.class)){
                String name = field.getName();
                String value = field.getAnnotation(MyValue.class).value();
                //获取属性所定义的类型
                String type = field.getType().getName();
                //将属性名该为以大写字母开头
                name = String.valueOf(name.charAt(0)).toUpperCase() + name.substring(1);
                String setterName = "set" + name;
                try {
                    //根据方法名和参数类型获取对应的set方法对象
                    Method method = cls.getMethod(setterName, field.getType());
                    //判断属性类型，如果类型不一致，则转换类型后调用set方法为其属性赋值
                    if("java.lang.Integer".equals(type) || "int".equals(type)){
                        int intValue = Integer.valueOf(value);
                        method.invoke(obj, intValue);
                    }
                    if("String".equals(type)){
                        method.invoke(obj, value);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //销毁方法，用于释放资源
    public void close(){
        beanDefinationFactory.clear();
        beanDefinationFactory = null;
        
        singletonBeanFactory.clear();
        singletonBeanFactory = null;
    }

service

package service;

import annotation.MyAutowired;
import annotation.MyComponent;
import entity.User;

@MyComponent
public class UserService {

    @MyAutowired
    User user1;
    
    @MyAutowired
    User user2;
    
    public void userLogin(){
        System.out.println("用户1:"+user1);
        user1.login();
        System.out.println("用户2:"+user2);
        user2.login();
    }
}

demo

package test;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import annotation.MyComponent;
import applicationContext.AnnotationConfigApplicationContext;
import service.UserService;

@MyComponent
public class TestSpringDI {

    AnnotationConfigApplicationContext ctx;
    UserService userService;
    
    @Before
    public void init(){
        ctx = new AnnotationConfigApplicationContext("entity","service","test");
        userService = ctx.getBean("userService", UserService.class);
    }
    
    @Test
    public void testSpringDI(){
        userService.userLogin();
    }
    
    @After
    public void close(){
        ctx.close();
    }
}

 

virtualler
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
virtualdj 6 中文破解版
02-15
Virtual DJ是一款最抢手的MP3混音软件
VirtualDJ_7汉化破解版
05-13
VirtualDJ_7汉化破解版
VIRTUALDJ Pro 8.0 Full 完全中文版
08-27
VIRTUALDJ Pro 8.0 Full 完全中文版
virtualdj7.0汉化版
01-28
virtualdj7.0汉化版本模拟打碟机.dj新手歪歪主持必备。
VHD(Virtual Hard Disk)的解析(上篇)——PyVinil的使用
weixin_30367543的博客
11-09 411
前言： 最近接到一个新的任务，是关于虚拟化的中的虚拟磁盘文件(VHD)的。一开始的思路就是去寻找一些相关的源码工具，或是相关的库（C/Java/Python都ok的）。不好找，以下就是关于Python工具源码——PyVinil。版本为PyVinil-0.1.0. 概述： VHD 是Microsoft Virtual Hard Disk format（微软虚拟磁盘文件）...
Spring——IoC和DI
浪漫不死的博客
03-02 3175
目录一、初识Spring为什么要使用Spring什么是SpringSpring框架的核心由哪些模块组成二、Core Container（核心容器）IoC（控制反转）什么是 IoCIoC 的作用IoC 的优点IoC 的缺点DI（依赖注入）什么是DI依赖注入的基本原则依赖注入的优势不同类型的依赖注入实现方式构造器依赖注入和 Setter方法注入的区别顶级接口BeanFactory 和 ApplicationContext 的区别BeanFactory和ApplicationContext的关系详解Applica
Spring IoC & DI（笔记）
最新发布
LHY537200的博客
07-30 806
什么是容器？生活中的水杯,垃圾桶,冰箱等等这些都是容器，我们接触的容器有哪些?List/Map->数据存储容器Tomcat-> Web 容器。什么是IoC？IoC是Spring的核⼼思想，其实IoC我们在前⾯已经使⽤了,我们在前⾯讲到,在类上⾯添加@RestController和@Controller 注解。就是把这个对象交给Spring管理,Spring框架启动时就会加载该类.把对象交给Spring管理,就是IoC思想.
Spring一些基础问题整理
热门推荐
张彦峰的博客
04-07 169万+
Spring相关高频面试题整理
java系列之Spring详解
m0_61027348的博客
11-26 4099
本文主要阐述了spring的IOC和AOP的详细内容，了解IOC的DI依赖注入的各种方法，以及AOP的动态代理实现原理和AOP的详细使用，还讲解了mybatis的整合以及利用AOP整合事务管理等等
理解Spring：DI的原理及手写实现
lixiaoxiong的专栏
12-31 1056
本文转自：https://juejin.im/post/5c18447cf265da61461e1525 目录 Spring系列之IOC的原理及手动实现 Spring系列之DI的原理及手动实现 Spring系列之AOP的原理及手动实现 Spring系列之手写注解与配置文件的解析 Spring系列之手写一个SpringMVC 前言 在上一章中，我们介绍和简单实现了容器的部分功能，但是这...
spring系列笔记之常用注解
08-26
在Spring框架中，注解是实现依赖注入（Dependency Injection, DI）和控制反转（Inversion of Control, IOC）的关键工具，它们极大地简化了配置，提高了开发效率。本篇文章主要探讨Spring常用的注解及其作用。 1. **...
跟我学Spring系列1
08-04
根据给定的信息，本文将重点解析“跟我学Spring系列1”中的关键知识点，特别是与IoC容器、DI、资源管理、SpEL、AOP、JDBC支持、ORM集成、事务管理、Web框架集成以及SSH集成开发相关的技术内容。 ### 一、IoC容器...
JAVA spring 系列案例50个和学习资料
03-01
Spring系列第7篇：依赖注入之手动注入Spring系列第8篇：自动注入（autowire）详解，高手在于坚持Spring系列第9篇：depend-on到底是干什么的？Spring系列第10篇：primary可以解决什么问题？Spring系列第11篇：bean中...
spring ioc di aop详解
11-01
Spring 提供了一系列注解，如 `@Component`、`@Service`、`@Repository` 和 `@Controller` 来标记组件，`@Autowired` 进行依赖注入，以及 `@Aspect`、`@Before`、`@After` 等用于 AOP。这些注解大大减少了 XML 配置...
Spring系列一：Spring基础篇
退役复学在校大学生，目光所至，皆为华夏
07-21 3万+
有人说，“Java程序员都是Spring程序员”，本人不太赞成这个观点，但是这也可以看出Spring在Java世界里举足轻重的作用。
Spring系列学习之Spring IOC
weixin_43973161的博客
08-09 668
Spring框架的IOC容器职责：对象的控制权交由第三方统一管理（IoC控制翻转），利用Java反射技术实现运行时对象创建与关联（DI依赖注入），基于配置提高应用程序的可维护性和扩展性。
手撸Spring系列1：IOC/DI 思想（理论篇）
云丶言的博客
09-05 1489
今天的这一篇博客将会讲述 IOC/DI思想，作为手撸Spring系列的第一篇理论博客，笔者将会从Spring的核心思想IOC开始讲解。为了读者能够更好的理解文章中的内容，在上车前，笔者建议读者们能够拥有以下车票，以防走丢：有Spring使用经验（刚需）、有SpringBoot使用经验（建议），使用Spring写过个人项目（建议），使用过MyBatis（建议）。检查好自己的车票后就自行上车吧！！
【Spring进阶系列丨第三篇】Spring核心技术之 IoC 与 DI 实战案例
陈橘又青的博客
11-20 2万+
在上一篇文章中，我们学习了IoC与DI的相关概念与原理，现在让我们一同感受一下Spring框架带给我们开发的便捷性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值