手写Spring基于注解配置

冷不防 2024-05-09 16:21 167阅读 0赞

--------------------

#### 文章目录 ####

*  前言
 *  一、IOC是什么？
 *  二、使用步骤
 *   *  1.创建bean组件
     *  2.创建配置类与扫描注解
     *  3.创建容器类
     *  4.传入配置类获得容器
 *  三、总结

--------------------

## 前言 ##

在spring中ioc与aop是两个非常重要的概念，为了方便理解，手动实现一遍可以更好的理解其中编程思想。

--------------------

## 一、IOC是什么？ ##

IOC（Inversion Of Controll，控制反转）是一种设计思想，就是将原本在程序中手动创建对象的控制权，交给IOC容器来管理，并由IOC容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。IOC容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件/注解即可，完全不用考虑对象是如何被创建出来的。

Spring 中的 IoC 的实现原理就是工厂模式加反射机制。

## 二、使用步骤 ##

### 1.创建bean组件 ###

> 代码如下（示例）：

package com.spring.component;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class MyComponent {
        
    
    }

package com.spring.component;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class MySpringAction {
        
    
    }

package com.spring.component;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class MySpringService {
        
    
    }

package com.spring.component;
    
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class MySpringDao {
        
    
    }

### 2.创建配置类与扫描注解 ###

代码如下（示例）：

package com.spring.automatic;
    
    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();
    }

package com.spring.automatic;
    
    @ComponentScan(value="com.spring.component")
    public class SpringConfig {
        
    	
    }

--------------------

### 3.创建容器类 ###

package com.spring.automatic;
    
    import java.io.File;
    import java.net.URL;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    import org.springframework.stereotype.Repository;
    import org.springframework.stereotype.Service;
    import org.springframework.util.StringUtils;
    
    public class SpringApplicationContext {
        
    	private Class<?> configClass;
    	private final ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
    	private final Map<String, String> info = new HashMap<>();
    
    	public SpringApplicationContext(Class<?> configClass) {
        // 传入配置类
    		this.configClass = configClass;
    		ComponentScan scan = this.configClass.getDeclaredAnnotation(ComponentScan.class);// 获取配置类的注解
    		String path = scan.value();// 获取注解路径
    		ClassLoader clazzLoader = configClass.getClassLoader();// 获得类加载器
    //		ClassLoader clazzLoader = SpringApplicationContext.class.getClassLoader();
    		URL resource = clazzLoader.getResource(path.replace(".", "/"));// 目的是为了扫描该路径下的类
    		File file = new File(resource.getFile());
    		if (file.isDirectory()) {
        
    			File[] ff = file.listFiles();
    			for (File file2 : ff) {
        
    				String absolutePath = file2.getAbsolutePath();
    				boolean isClass = absolutePath.endsWith(".class");
    				if (isClass) {
        
    					String className = absolutePath.substring(absolutePath.lastIndexOf("\\") + 1, // 获取最后一个斜杠的索引
    							absolutePath.indexOf(".class"));// 获取.class的索引
    					String classFullPath = path + "." + className;// 拼接全路径
    					try {
        
    						Class<?> clazz = clazzLoader.loadClass(classFullPath);
    						boolean bool = clazz.isAnnotationPresent(Component.class)
    								|| clazz.isAnnotationPresent(Service.class)
    								|| clazz.isAnnotationPresent(Repository.class)
    								|| clazz.isAnnotationPresent(Controller.class);
    						if (bool) {
        
    							Class<?> bean = Class.forName(classFullPath);
    							// bean的id为属性名首字母小写
    							singletonObjects.put(StringUtils.uncapitalize(className), bean.newInstance());
    							info.put(StringUtils.uncapitalize(className), classFullPath);
    						}
    					} catch (Exception e) {
        
    						e.printStackTrace();
    					}
    				}
    			}
    		}
    	}
    
    	public Object getBean(String beanId) {
        
    		return singletonObjects.get(beanId);
    	}
    }

### 4.传入配置类获得容器 ###

package com.spring.solution;
    
    import com.spring.automatic.SpringApplicationContext;
    import com.spring.automatic.SpringConfig;
    import com.spring.component.MyComponent;
    import com.spring.component.MySpringAction;
    import com.spring.component.MySpringDao;
    import com.spring.component.MySpringService;
    
    public class SpringAnnoationMain {
        
    	public static void main(String[] args) {
        
    		SpringApplicationContext ioc = new SpringApplicationContext(SpringConfig.class);
    		Object mySpringService = ioc.getBean("mySpringService");
    		Object mySpringDao = ioc.getBean("mySpringDao");
    		Object mySpringAction = ioc.getBean("mySpringAction");
    		Object myComponent = ioc.getBean("myComponent");
    		System.out.println("mySpringService = " + mySpringService);
    		System.out.println("mySpringDao = " + mySpringDao);
    		System.out.println("mySpringAction = " + mySpringAction);
    		System.out.println("myComponent = " + myComponent);
    	}
    }

控制台输出结果

mySpringService = com.spring.component.MySpringService@108c4c35
    mySpringDao = com.spring.component.MySpringDao@4ccabbaa
    mySpringAction = com.spring.component.MySpringAction@4bf558aa
    myComponent = com.spring.component.MyComponent@2d38eb89

## 三、总结 ##

1.自定义Spring容器  
2.传入 SpringConfig.class  
3.根据传入的 SpringConfig.class 能够解析到@ComponentScan的value 进而扫描到包  
4.通过类的加载器、IO、注解解析 得到包下的加载的资源(class文件)  
5.再看看该类class是不是要被实例化，如果需要实例化，就通过反射，进行操作（此处仅需要@Service、@Repository、@Controller、@Component）  
6.将反射生成的对象，放入到容器singletonObjects  
7.提供getBean(String key)返回容器中的对应的类