接口编程
在创建好 Bean 实例后，判断是否要初始化，心得：
- 容器中常用的方法是：根据该类是否实现了某个接口，来判断是否要执行某个业务逻辑
- 这其实就是 java基础的 接口编程的 实际运用
package com.llq.spring.ioc;
/**
* Spring 原生 Ioc 容器
*/
public class LlqSpringApplicationContext {
// 定义属性 BeanDefinitionMap，用于存放 BeanDefinition
private ConcurrentHashMap<String, BeanDefinition> BeanDefinitionMap = new ConcurrentHashMap<>();
// 定义属性 singletonObjects，作为单例池
private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
private Class configClass;
public LlqSpringApplicationContext(Class configClass) {
BeanDefinitionsScan(configClass);
}
public ConcurrentHashMap<String, BeanDefinition> getBeanDefinitionMap() {
return BeanDefinitionMap;
}
public ConcurrentHashMap<String, Object> getSingletonObjects() {
return singletonObjects;
}
public void BeanDefinitionsScan(Class configClass) {
// 这里拿到了自定义配置类的 Class 类型
this.configClass = configClass;
System.out.println("配置类的 Class 类型");
System.out.println("this.configClass= " + this.configClass);
// 1. 先得到 LlqSpringConfig 配置的注解 @ComponentScan(value = "com.llq.spring.component")
ComponentScan declaredAnnotation = (ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
// 2. 通过 ComponentScan的 value ===> 要扫描的包
String path = declaredAnnotation.value();
System.out.println("待扫描的包如下：");
System.out.println(path); // com.llq.spring.component ===> 路径的话，要将 . 替换为 、 ===》com/llq/spring/component
String scanDir = path.replace(".", "/");
System.out.println(scanDir);
// 3. 得到扫描包下的所有资源(类.class) ===> 工作目录的 class
URL resource = configClass.getClassLoader().getResource(scanDir); // URL 对象有许多 API
scanDir = resource.getPath();
System.out.println("我们真正要扫描的路径如下：");
System.out.println(scanDir);
// 4. 将要加载的资源(.class) 路径下的文件进行遍历 ===> IO 知识
File file = new File(scanDir); // 得到目录
File[] files = file.listFiles(); // 列出目录下的所有文件
System.out.println("==============");
for (File f : files) {
String absolutePath = f.getAbsolutePath();
// 注意这里，只处理 .class 文件
if (absolutePath.endsWith(".class")) {
System.out.println(absolutePath); // D:\spring5\out\production\spring5\com\llq\spring\component\UserService.class
// 现在反射需要得到：com.llq.spring.component.UserService
// 1. 先获取类名
String[] split = absolutePath.split("\\\\");
String s = split[split.length - 1];
System.out.println(s);
String className = split[split.length - 1].split("\\.")[0];
// 得到类名
System.out.println("类名：" + className);
// 再将 / 改回成 .
String classFullName = path + "." + className; // 包名 + 类名
System.out.println(classFullName);
// 2. 判断该类是否需要注入到容器中
// 观察该类是否包含以下注解
// @Component、@Service、@Repository、@Controller
try {
Class<?> aClass = Class.forName(classFullName);
if (aClass.isAnnotationPresent(Component.class)) {
// 如果该类使用了 @Component 注解，说明是 Spring Bean
System.out.println("这是一个 Spring Bean= " + aClass + " 类名 " + className);
// 1. 先得到 beanName
String beanName = "";
String value = aClass.getDeclaredAnnotation(Component.class).value();
if ("".equals(value)) { // 是否右 scope 注解
className = className.substring(0, 1).toLowerCase() + className.substring(1); // 首字母小写
beanName = className;
} else {
beanName = value;
}
System.out.println("key：" + beanName);
String scopeValue = "";
// 将 Bean信息封装到 BeanDefinition 对象 ===> 放入到 BeanDefinitionMap中
Scope scope = aClass.getDeclaredAnnotation(Scope.class);
if (scope == null) {
scopeValue = "singleton";
} else {
scopeValue = scope.value();
}
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setaClass(aClass);
beanDefinition.setScope(scopeValue);
BeanDefinitionMap.put(beanName, beanDefinition);
// 初始化单例池
if ("singleton".equals(scopeValue)) {
// 已经创建好 Bean 对象了，还要判断是否要执行 初始化方法
System.out.println("我是单例，直接实例化，放入到单例池 singletonObjects 中");
Object o = aClass.getConstructor().newInstance();
if (o instanceof InitializingBean){
((InitializingBean) o).afterPropertiesSet();
}
singletonObjects.put(beanName, o);
}
System.out.println("---------------------------");
} else {
System.out.println("这不是一个 Spring Bean" + " 类名 " + className);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
public Object createBean(BeanDefinition beanDefinition){
Object o = null;
Class aClass = beanDefinition.getaClass();
Field[] declaredFields = aClass.getDeclaredFields(); // 拿到所有字段
try {
o = aClass.getConstructor().newInstance();
for (Field declaredField : declaredFields) {
if (declaredField.getAnnotation(Autowired.class) != null){ // 字段上是否有 @Autowired 注解
// 1. 先看单例池中有没有，有的话直接 get
// 2. 没有的话，new 一个 新的
String name = declaredField.getName();
Object bean = getBean(name); // 待注入的依赖
declaredField.setAccessible(true);
declaredField.set(o, bean);
}
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
System.out.println("创建好 Bean 实例 " + o);
// 这里判断是否执行 Bean 初始化方法
// 1. 判断当前创建的 Bean 对象是否实现了 InitializingBean 接口
if (o instanceof InitializingBean){
try {
((InitializingBean) o).afterPropertiesSet();
} catch (Exception e) {
e.printStackTrace();
}
}
return o;
}
public Object getBean(String name){
if (singletonObjects.containsKey(name)){ // 单例池中有的话
return singletonObjects.get(name);
}
Object o = null;
if (BeanDefinitionMap.containsKey(name) && "prototype".equals(BeanDefinitionMap.get(name).getScope())){
o = createBean(BeanDefinitionMap.get(name));
}
if (o == null){
throw new NullPointerException("没有该 Bean");
}
return o;
}
}