项目使用技术
使用java基础技术栈完成,包括但不限于:反射、集合、String等
项目完成效果
基于Spring框架通过在类上配置注解(@Component, @Controller等注解),在xml中配置扫描包,完成直接在容器中获取对象的特性。本项目使用java基础模拟实现该特性。
解读输出内容:
monsterService类和monsterDao两个类被扫描进SpringApplicationContext容器中,monsterService的Scope为prototype,所以两次获取monsterService是两个不同的类对象(多例),monsterDao的Scope默认值为singleton,所以两次获取的monsterDao是同一个的对象(单例), 单例也是Spring框架在获取Bean的默认配置。monsterDao的@Component注解中配置Bean的名字,默认名为类名小写 作为key存在SpringApplicationContext的map中。
SpringApplicationContext ioc = new SpringApplicationContext(SpringConfig.class);
MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
MonsterService monsterService2 = (MonsterService) ioc.getBean("monsterService");
System.out.println("monsterService:" + monsterService);
System.out.println("monsterService2:" + monsterService2);
MonsterDao monsterDao = (MonsterDao) ioc.getBean("monsterDao");
MonsterDao monsterDao2 = (MonsterDao) ioc.getBean("monsterDao");
System.out.println("monsterDao:" + monsterDao);
System.out.println("monsterDao2:" + monsterDao2);
System.out.println("ok");
项目结构
结构说明
@Component
加上该注解可以加载类到容器, 其value属性指定对象的名字
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
//通过value可以给注入的bean/对象指定名字
String value() default "";
}
@ComponentScan
在value属性中写上包路径,指明要扫描的包
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ComponentScan {
//指定要扫描的包
String value() default "";
}
@Scope
指定Bean的作用范围[singleton, prototype], singleton为单例,在扫描时创建,prototype为多例,在获取Bean时创建。
// Scope 可以指定Bean的作用范围[singleton, prototype]
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Scope {
String value() default "";
}
MonsterDao和MonsterService
是我们要加载到容器中的类对象
@Component
public class MonsterDao {
}
@Component(value = "monsterService")
@Scope(value = "prototype")
public class MonsterService {
}
SpringConfig
模拟Spring框架中的xml文件,可以在该类上加上@ComponentScan来指定要扫描的包
@ComponentScan(value = "com.cwh.spring.component")
public class SpringConfig {
}
BeanDefinition
记录bean信息(单例还是多例),反射生成对应对象
package com.cwh.spring.ioc;
//记录bean信息(单例还是多例),反射生成对应
public class BeanDefinition {
private String scope;
private Class clazz;
public BeanDefinition() {
}
public BeanDefinition(String scope, Class clazz) {
this.scope = scope;
this.clazz = clazz;
}
public String getScope() {
return scope;
}
public void setScope(String scope) {
this.scope = scope;
}
public Class getClazz() {
return clazz;
}
public void setClazz(Class clazz) {
this.clazz = clazz;
}
@Override
public String toString() {
return "BeanDefinition{" +
"scope='" + scope + '\'' +
", clazz=" + clazz +
'}';
}
}
SpringApplicationContext
最重要的容器类,模拟Spring中的 ClassPathXmlApplicationContext。SpringApplicationContext完成 存放被扫描进来的Bean(封装成BeanDefinition对象)放入map中,存放singleton类型的bean放入map, createBean, getBean等方法。
public class SpringApplicationContext {
private Class configClass;
//存放BeanDefinition对象
// 先把 有 Bean注解的类 生成 BeanDefinition对象,再放入beanDefinitionMap
private ConcurrentHashMap<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
//存放单例对象
private ConcurrentHashMap<String, Object> singletonObjects = new ConcurrentHashMap<>();
public SpringApplicationContext(Class configClass) {
beanDefinitionByScan(configClass);
//将Scope是singleton(默认)的放到singletonObjects
Enumeration<String> keys = beanDefinitionMap.keys();
while (keys.hasMoreElements()) {
String beanName = keys.nextElement();
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
//将该bean实例放入到singletonObjects 集合
Object bean = createBean(beanDefinition);
singletonObjects.put(beanName, bean);
}
}
//System.out.println("single:" + singletonObjects);
//System.out.println("map:" + beanDefinitionMap);
}
//扫描指定包,创建BeanDefinition对象,并放入Map
private void beanDefinitionByScan(Class configClass) {
this.configClass = configClass;
ComponentScan componentScan =
(ComponentScan) this.configClass.getDeclaredAnnotation(ComponentScan.class);
String path = componentScan.value(); //得到要扫描的包
System.out.println("path:" + path);
//得到类加载器
ClassLoader classLoader = SpringApplicationContext.class.getClassLoader();
path = path.replace(".", "/");
URL resource = classLoader.getResource(path);
File file = new File(resource.getFile());
if (file.isDirectory()) {
File[] files = file.listFiles();
for (File f : files) {
String absolutePath = f.getAbsolutePath();
if (absolutePath.endsWith(".class")) {
String className = absolutePath.substring(
absolutePath.lastIndexOf("\\") + 1,
absolutePath.lastIndexOf(".class"));
String classFullName = path.replace("/", ".") + "." + className;
try {
Class<?> aClass = classLoader.loadClass(classFullName);
//如果该类使用了@Component, 说明是Spring bean
if (aClass.isAnnotationPresent(Component.class)) {
System.out.println("可以加载到容器:" + className);
//得到beanName
Component component = aClass.getDeclaredAnnotation(Component.class);
String beanName = component.value();
//value可以没有设置,是默认值 "", 需要再处理一下
if ("".equalsIgnoreCase(beanName)) {
// 类名首字母小写作为key, 放入map
beanName = StringUtils.uncapitalize(className);
}
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setClazz(aClass);
if (aClass.isAnnotationPresent(Scope.class)) {
//如果配置了Scope, 获取他配置的值
Scope scope = aClass.getDeclaredAnnotation(Scope.class);
beanDefinition.setScope(scope.value());
} else {
//如果没有配置Scope, 就用默认的值singleton
beanDefinition.setScope("singleton");
}
//将beanDefinition 对象放入到Map
beanDefinitionMap.put(beanName, beanDefinition);
} else {
System.out.println("不可以加载到容器:" + className);
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
//完成createBean,因为map中还是BeanDefinition对象
private Object createBean(BeanDefinition beanDefinition) {
Class clazz = beanDefinition.getClazz();
try {
Object instance = clazz.getDeclaredConstructor().newInstance();
return instance;
} 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 name) {
if (beanDefinitionMap.containsKey(name)) {
BeanDefinition beanDefinition = beanDefinitionMap.get(name);
if ("singleton".equalsIgnoreCase(beanDefinition.getScope())) {
return singletonObjects.get(name); //在单例map中获取
} else {
return createBean(beanDefinition);
}
} else {
throw new NullPointerException("没有该bean");
}
}
}
TestSpirng
创建SpringApplicationContext对象,然后获取Bean, 测试效果
public class TestSpring {
public static void main(String[] args) {
SpringApplicationContext ioc = new SpringApplicationContext(SpringConfig.class);
MonsterService monsterService = (MonsterService) ioc.getBean("monsterService");
MonsterService monsterService2 = (MonsterService) ioc.getBean("monsterService");
System.out.println("monsterService:" + monsterService);
System.out.println("monsterService2:" + monsterService2);
MonsterDao monsterDao = (MonsterDao) ioc.getBean("monsterDao");
MonsterDao monsterDao2 = (MonsterDao) ioc.getBean("monsterDao");
System.out.println("monsterDao:" + monsterDao);
System.out.println("monsterDao2:" + monsterDao2);
System.out.println("ok");
}
}