Spring 就像是我们写代码的一个管家，可能我们在项目中要创建对象，要写单例多例，要加日志，要加事务等等很多功能点。那这些东西如果能有一个现有的框架那就好了，它就是Spring,它不但实现了以上的功能，并且集成容纳各种其他的开源框架。

    自己手写Spring的核心就是springbean的生成。

    1：通过包扫描 获取到哪些类需要加载到spring容器中，加载到spring中到底是单例还是多例。
    2：单例是从单例池（map）中获取，非单例就是每次getBean的时候重新的创建一个新的对象。
    3：因为只有包的名称，所以要通过获取包下面的file来获取file的名称以及全路径，从而通过classload把class信息加载到beanDefinition中

    核心代码

    1. public ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();
    2.     public ConcurrentHashMap<String, Object> singleObjects = new ConcurrentHashMap<String, Object>();
    4.     public AnnotationConfigApplicationContext(Class clazz){
    5.         //1：通过给的类 获取到需要加载的bean的位置
    6.         scan(clazz);
    8.         //2.加载到容器
    9.         instanceSingleBean();
    10.     }
    12.     private void instanceSingleBean(){
    13.         try {
    14.             //1:获取beanDefinitionMap 封装的类信息
    15.             for (String beanName : beanDefinitionMap.keySet()){
    16.                 BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
    18.                 if("singleton".equals(beanDefinition.getScope())){
    19.                     Object bean = doCreateBean(beanDefinition);
    21.                     singleObjects.put(beanName, bean);
    22.                 }
    23.             }
    24.         }catch (Exception e){
    25.             e.printStackTrace();
    26.         }
    27.     }
    29.     private Object doCreateBean(BeanDefinition beanDefinition) throws Exception{
    30.         Class clazz = beanDefinition.getBeanClass();
    31.         Object bean = clazz.getDeclaredConstructor().newInstance();
    33.         Field[] fields = clazz.getDeclaredFields();
    34.         for (Field field : fields){
    35.             String beanName = field.getName();
    36.             if(field.isAnnotationPresent(Autowried.class)){
    37.                 Object fieldBean = getBean(beanName);
    39.                 field.setAccessible(true);
    40.                 field.set(bean, fieldBean);
    41.             }
    42.         }
    43.         return bean;
    44.     }
    46.     private void scan(Class clazz) {
    47.         //1:获取当前类的注解 找到需要扫描的包的路径
    48.         ComponentScan scan = (ComponentScan)clazz.getAnnotation(ComponentScan.class);
    49.         String packagePath = scan.value();
    50.         //获取当前包下的所有的类
    51.         List<Class> packageClass = genBeanClasses(packagePath);
    53.         //2:把类封装为BeanDefinition的map
    54.         toMap(packageClass);
    55.     }
    57.     private void toMap(List<Class> packageClass) {
    58.         for (Class clazz : packageClass){
    59.             if(clazz.isAnnotationPresent(Service.class)){
    60.                 //通过当前clazz封装BeanDefinition
    61.                 BeanDefinition beanDefinition = new BeanDefinition();
    62.                 beanDefinition.setBeanClass(clazz);
    63.                 Service service = (Service) clazz.getAnnotation(Service.class);
    64.                 String beanName = service.value();
    65.                 if(clazz.isAnnotationPresent(Scope.class)){
    66.                     Scope scope = (Scope) clazz.getAnnotation(Scope.class);
    67.                     String scopeValue = scope.value();
    68.                     if("prototype".equals(scopeValue)){
    69.                         beanDefinition.setScope("prototype");
    70.                     }else{
    71.                         beanDefinition.setScope("singleton");
    72.                     }
    73.                 }
    74.                 beanDefinitionMap.put(beanName, beanDefinition);
    75.             }
    77.         }
    78.     }
    80.     /**
    81.      *  通过com.mkb.server -> com/mkb/service 再拼接上 类的全路径  得到file文件  通过file文件 获取到文件名 就是 service名称
    82.      *  然后通过  classLoader.loadClass(className); 获取到class 集合
    83.      */
    84.     private List<Class> genBeanClasses(String packagePath) {
    85.         List<Class> beanClasses = new ArrayList<Class>();
    87.         ClassLoader classLoader = AnnotationConfigApplicationContext.class.getClassLoader();
    88.         packagePath = packagePath.replace(".", "/");
    89.         URL resource = classLoader.getResource(packagePath);
    90.         File file = new File(resource.getFile());
    92.         if (file.isDirectory()) {
    93.             File[] files = file.listFiles();
    94.             for (File f : files) {
    95.                 String fileName = f.getAbsolutePath();
    96.                 if (fileName.endsWith(".class")) {
    97.                     String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
    98.                     className = className.replace("\\", ".");
    99.                     try {
    100.                         Class<?> clazz = classLoader.loadClass(className);
    101.                         beanClasses.add(clazz);
    102.                     } catch (ClassNotFoundException e) {
    103.                         e.printStackTrace();
    104.                     }
    105.                 }
    106.             }
    107.         }
    108.         return beanClasses;
    109.     }
    111.     public Object getBean(String beanName) throws Exception{
    112.         if(!beanDefinitionMap.containsKey(beanName)){
    113.             throw new Exception();
    114.         }
    115.         BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
    116.         if("singleton".equals(beanDefinition.getScope())){
    117.             return singleObjects.get(beanName);
    118.         }else{
    119.             return doCreateBean(beanDefinition);
    120.         }
    121.     }

    码云地址：https://gitee.com/EraserMei/simple-spring.git