spring的bean手写代码实现（单例bean和多例bean）

文件架构

 

package com.server.server01;

import com.server.spring.wsq_componentScan;

@wsq_componentScan("com.server.server01")
public class Appconfig {
}

 test类

package com.server.server01;

import com.server.spring.wsqapplicationcontext;

public class Test {
    public static void main(String[] args) {

        wsqapplicationcontext wsqapplicationcontext = new wsqapplicationcontext(Appconfig.class);

        //userserver userserver = (com.server.server01.userserver) wsqapplicationcontext.getBean("userserver");

        System.out.println(wsqapplicationcontext.getBean("userserver"));
        System.out.println(wsqapplicationcontext.getBean("userserver"));
        System.out.println(wsqapplicationcontext.getBean("userserver"));
        System.out.println(wsqapplicationcontext.getBean("userserver"));
        System.out.println(wsqapplicationcontext.getBean("userserver"));
    }
}

userserver类

package com.server.server01;

import com.server.spring.component;
import com.server.spring.scope;

@component("userserver")
@scope("singleton")
public class userserver {
}

beandefinition类

package com.server.spring;

public class BeanDefinition {
    private Class type;
    private String scope;

    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;
    }
}

component注解

package com.server.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.TYPE)
public @interface component {
    String value() default "";
}

scope注解

package com.server.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.TYPE)
public @interface scope {
    String value() default "";
}

wsq_componentScan注解

package com.server.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.TYPE)
public @interface wsq_componentScan {
    String value() default "";
}

wsqapplicationcontext类

package com.server.spring;

import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;

public class wsqapplicationcontext {

    private Class Classconfig;
    private  ConcurrentHashMap<String,BeanDefinition> ConcurrentHashMap01 = new ConcurrentHashMap<>();
    private  ConcurrentHashMap<String,Object> singlebenamap = new ConcurrentHashMap<>();

    public wsqapplicationcontext(Class classconfig) {
        Classconfig = classconfig;

        if(classconfig.isAnnotationPresent(wsq_componentScan.class)){
            wsq_componentScan annotation = (wsq_componentScan) classconfig.getAnnotation(wsq_componentScan.class);
            String path = annotation.value();
            //System.out.println(path);

            path=path.replace(".","/");
            ClassLoader classLoader = wsqapplicationcontext.class.getClassLoader();
            URL resource = classLoader.getResource(path);

            File file = new File(resource.getFile());

           // System.out.println(file);
            if (file.isDirectory()){
                for (File listFile : file.listFiles()) {
                    String filename = listFile.getAbsolutePath();
                    //System.out.println(filename);
                    if (filename.endsWith(".class")){
                        String classname = filename.substring(filename.indexOf("com"), filename.indexOf(".class"));

                        classname = classname.replace("\\", ".");


                        try {
                            Class<?> Clazz = classLoader.loadClass(classname);
                           // System.out.println(Clazz);
                            if(Clazz.isAnnotationPresent(component.class)){

                                component component = Clazz.getAnnotation(component.class);
                                String benaname=component.value();
                                // System.out.println(Clazz);
                                BeanDefinition beanDefinition = new BeanDefinition();
                                beanDefinition.setType(Clazz);
                                //System.out.println(beanDefinition.getType());
                                if(Clazz.isAnnotationPresent(scope.class)){
                                    scope annotation1 = Clazz.getAnnotation(scope.class);
                                    beanDefinition.setScope(annotation1.value());
                                }else {
                                    beanDefinition.setScope("singleton");
                                }

                                ConcurrentHashMap01.put(benaname,beanDefinition);
                                //System.out.println(beanDefinition.getScope());
                            }
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }
        }
        for (String s : ConcurrentHashMap01.keySet()) {
            BeanDefinition beanDefinition = ConcurrentHashMap01.get(s);
            if (beanDefinition.getScope().equals("singleton")){
                Object bean =  createbena(s, beanDefinition);
                singlebenamap.put(s,bean);

            }
        }
    }


   public Object createbena(String name,BeanDefinition beanDefinition){

       Class type = beanDefinition.getType();
       try {
           Object newInstance = type.getConstructor().newInstance();
           return newInstance;
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       } catch (NoSuchMethodException e) {
           e.printStackTrace();
       }
       return null;
   }


    public Object getBean(String benaName){

        BeanDefinition beanDefinition = ConcurrentHashMap01.get(benaName);
        if (beanDefinition==null){
            System.out.println("没有找到这个bean");

        }else {
            String scope = beanDefinition.getScope();

            if (scope.equals("singleton")){
                //单例
                if (singlebenamap.get(benaName)==null){
                    Object o = createbena(benaName, beanDefinition);
                    singlebenamap.put(benaName,o);
                }else {
                    return singlebenamap.get(benaName);
                }
            }else {
                //多例
                return createbena(benaName,beanDefinition);
            }
        }

        return null;
    }
}

演示

有这个单例注解时

 

 输出的bean是一个

没有这个单例注解的时候或者单例注解里面写的不是

singleton

 

输出就是不同的bean