导航:
【Java笔记+踩坑汇总】Java基础+进阶+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud+黑马旅游+谷粒商城+学成在线+MySQL高级篇+设计模式+牛客面试题
目录
一、准备工作
1.0 项目目录
1.1 Spring包下的类
1.1.1 容器类
1.1.2 @ComponentScan注解
1.1.3 @Component注解
1.1.4 @Autowired注解
1.1.5 @Scope注解
1.1.6 Bean的声明类:BeanDefinition
1.1.7 Bean名回调接口:BeanNameAware
1.1.8 初始化接口:InitializingBean
1.1.9 Bean后置处理器接口:BeanPostProcessor
1.2 用户业务相关类
1.2.1 测试类创建容器
1.2.2 配置类AppConfig
1.2.3 UserService
1.2.4 OrderService,用于依赖注入
1.2.5 Bean后置处理器接口实现类:MyBeanPostProcessor
二、完善容器类:VinceApplicationContext
2.0 创建Bean流程
2.1 代码实现
2.1.1 成员变量
2.1.2 构造方法,参数是配置类
2.1.3 createBean()方法
2.1.4 getBean()方法
三、所有代码
com.vince.spring包下的类:
对比一下创建Spring容器的方式,我们需要模拟的是AnnotationConfigApplicationContext类。
- ClassPathXmlApplicationContext:是需要传入一个xml配置文件,告诉Spring需要按照指定的配置创建一个Spring容器ApplicationContext,创建完之后就可以通过getBean从容器中拿到相应的bean对象
- AnnotationConfigApplicationContext :也是一个容器,只是传入的是以Java配置类的形式传入。可以在类上加上@ComponentScan定义Spring等下需要扫描的路径。还可以通过@Bean的方法(等于bean标签),通过这种注解的方式,给容器加入一个Bean
public class Test { public static void main(String[] args) { ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring.xml"); classPathXmlApplicationContext.getBean("user"); AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AppConfig.class); SpringCodeApplicationContext applicationContext = new SpringCodeApplicationContext(AppConfig.class); } }
参考Spring框架可知,这个容器类需要有构造方法、传入参数、
getBean()
方法
package com.vince.spring;
//模拟AnnotationConfigApplicationContext
public class VinceApplicationContext{
private Class configClass;
//构造方法,参数是配置类的字节码文件
public SpringCodeApplicationContext(Class configClass) {
//1.赋值配置类成员变量
this.configClass = configClass;
// 2.解析配置类
// 通过反射,判断配置类字节码有没有注解@ComponentScan
// 如果有,就根据@ComponentScan传入的扫描路径,扫描那个包下的Bean
// 3.实例化bean
}
//容器里拥有getBean()方法,获取Bean
public Object getBean(String beanName){
return null;
}
package com.vince.spring;
/**
* 用于扫描指定包路径的Bean
*/
@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
//@Target用来表示注解作用范围,超过这个作用范围,编译的时候就会报错。
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface ComponentScan {
String value() default "";
}
package com.vince.spring;
/**
* 注解为Bean
*/
@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface Component {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Autowired {
}
@Retention(RetentionPolicy.RUNTIME)//注解生命周期,不仅被保存到class文件中,jvm加载class文件之后,仍然存在
@Target(ElementType.TYPE)//注解范围是:接口、类、枚举、注解
public @interface Scope {
String value() default "";
}
BeanDefinition 定义 Bean 的配置元信息,包含:
- Bean 的类名
- 设置父 bean 名称、是否为 primary、
- Bean 行为配置信息,作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等
- Bean 之间的依赖设置,dependencies
- 构造参数、属性设置
//Bean的声明类,用来描述Bean;里面定义的Bean的类型(Class格式)和作用域
public class BeanDefinition {
private Class type;
private String scope;
@Override
public String toString() {
return "BeanDefinition{" +
"type=" + type +
", scope='" + 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;
}
}
//回调接口,主要setter方法给Bean的beanName变量赋值。Aware译为明白的,意识到的。
public interface BeanNameAware {
public void setBeanName(String beanName);
}
//初始化Bean的接口,有个方法,
public interface InitializingBean {
//在属性填充后执行
public void afterPropertiesSet();
}
本接口的两个方法在初始化之前和之后执行,可以通过实现类使用JDK的Proxy
//Bean后置处理器接口
public interface BeanPostProcessor {
//在Bean 的初始化方法(如 @PostConstruct 注解的方法)被调用之前被自动调用
public Object postProcessBeforeInitialization(String beanName,Object bean);
//在 Bean 的初始化方法被调用之后被自动调用
public Object postProcessAfterInitialization(String beanName,Object bean);
}
com.vince.service包下的类:
package com.vince.spring;
public class Test {
public static void main(String[] args){
//模拟AnnotationConfigApplicationContext容器,构造参数传入配置类
VinceApplicationContext applicationContext = new VinceApplicationContext(AppConfig.class);
UserInterface userService = (UserInterface)applicationContext.getBean("userService");
userService.test();
}
}
package com.vince.spring;
// com/springCode/service/UserService.java
@ComponentScan("com.springCode.service")
public class AppConfig {
}
package com.vince.service;
public interface UserInterface {
public void test();
}
@Component
//@Scope("prototype") //多例
public class UserService implements BeanNameAware , InitializingBean ,UserInterface{
@Autowired
private OrderService orderService;
private String beanName;
@Override
public void test(){
System.out.println(orderService);
}
@Override
public void setBeanName(String beanName) {
this.beanName = beanName;
}
@Override
public void afterPropertiesSet() {
System.out.println("初始化方法");
}
}
@Component
//@Scope("prototype") //多例
public class OrderService {
public void submitOrder(){
System.out.println("下单。。。");
}
}
//Bean后置处理器实现类,两个方法在初始化之前和之后执行,可以通过实现类使用JDK的Proxy.newProxyInstance();基于反射实现aop。
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(String beanName, Object bean) {
if ("userService".equals(beanName)) {
System.out.println("BeanPostProcessor实现类的postProcessBeforeInitialization()方法");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(String beanName, Object bean) {
if ("userService".equals(beanName)) {
//代理对象,通过JDK的Proxy.newProxyInstance();基于反射实现aop。
// 第一个参数类加载器,第二个参数接口的class对象,第三个参数重写invoke()的InvocationHandler实现类
Object proxyInstance = Proxy.newProxyInstance(MyBeanPostProcessor.class.getClassLoader(),
bean.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("切面逻辑,BeanPostProcessor实现类的postProcessAfterInitialization()方法");
return method.invoke(bean,args);
}
});
return proxyInstance;
}
return bean;
}
}
注解容器类构造方法创建Bean:
spring包下的VinceApplicationContext类
private Class configClass;//配置类的Class对象
//Bean名和它对应的BeanDefinition键值对;
private ConcurrentHashMap beanDefinitionMap = new ConcurrentHashMap<>();
//单例池;map存各Bean名所对应的Bean实例
private ConcurrentHashMap singletonObjects = new ConcurrentHashMap<>();
//存放扫描包路径下的所有BeanPostProcessor类
private ArrayList beanPostProcessorList = new ArrayList<>();
//构造方法,参数是配置类的Class对象
public VinceApplicationContext(Class configClass) {
//1.赋值配置类成员变量
this.configClass = configClass;
// 2.通过反射,判断配置类Class对象有没有注解@ComponentScan;如果有,就解析ComponentScan对象
// --->BeanDefinition -->beanDefinitionMap
if (configClass.isAnnotationPresent(ComponentScan.class)) {
//解析ComponentScan对象
ComponentScan componentScanAnnotation = (ComponentScan) configClass.getAnnotation(ComponentScan.class);
// 获取ComponentScan对象的value,也就是用户传入的扫描路径。例如@ComponentScan("com.vince.service"),扫描这个包下的Bean
String path = componentScanAnnotation.value();// com.vince.service
// 将包名中的点号替换为斜杠
path = path.replace(".","/");//com/vince/service
// 获取容器类的类加载器
ClassLoader classLoader = VinceApplicationContext.class.getClassLoader();
// 类加载器获取扫描包的绝对路径
URL resource = classLoader.getResource(path);//file:/D:/xxx/com/vince/service
// 把URL绝对路径对象封装成File对象
File file = new File(resource.getFile());
// 如果File对象是目录,则遍历判断扫描目录下的文件是不是bean;
if (file.isDirectory()) {
File[] files = file.listFiles();
//遍历“扫描路径”下所有文件中,找到Bean,创建对应BeanDefinition对象,并存到map里;
// 判断Bean方式:基于反射,判断该字节码文件对应的类有没有@Component注解
for (File f: files) {
String fileName = f.getAbsolutePath();
if (fileName.endsWith(".class")) {
//将文件名转为类名;D:\xxx\com\vince\service\AppConfig.class ----> AppConfig
//这里其实不应该写死成“com”,只是方便起见,其实应该用更复杂的逻辑截取全名为类名
String className = fileName.substring(fileName.indexOf("com"), fileName.indexOf(".class"));
className = className.replace("\\",".");
try {
//根据类的全限定名加载类
Class> clazz = classLoader.loadClass(className);
//如果该类有@Component注解
if (clazz.isAnnotationPresent(Component.class)) {
System.out.println("容器类构造方法里,扫描@ComponentScan('xx'),发现xx路径下这个类是Bean:"+clazz.getName());
//a.如果@Component("类名")有设置类名,Bean名就是设置的这个类名
Component component = clazz.getAnnotation(Component.class);
String beanName = component.value();
//判断这个Bean类是不是BeanPostProcessor接口的实现类,如果是的话就通过反射创建实例,并放进处理器列表里。
//注意不能用instanceof,因为instanceof是实例与类的关系比较,isAssignableFrom是类和接口的关系比较
if (BeanPostProcessor.class.isAssignableFrom(clazz)) {
BeanPostProcessor instance = (BeanPostProcessor) clazz.newInstance();
beanPostProcessorList.add(instance);
System.out.println("这个Bean是BeanPostProcessor接口的实现类,需要加入list里,以供所有Bean初始化之前和之后增强");
}
//b.如果@Component没有设置类名,就将首字母小写后的Bean类名设为Bean名
if ("".equals(beanName)) {
beanName = Introspector.decapitalize(clazz.getSimpleName());//工具类将字符串校验后首字母小写
}
// 创建一个BeanDefinition对象,用来描述Bean,里面赋值这个Bean的类型和作用域
BeanDefinition beanDefinition = new BeanDefinition();
//反射获取@Scope注解指定的作用域,赋值给BeanDefinition对象的scope变量
if (clazz.isAnnotationPresent(Scope.class)) {
Scope scopeAnnotation = clazz.getAnnotation(Scope.class);
beanDefinition.setScope(scopeAnnotation.value());
}else{
beanDefinition.setScope("singleton");
}
//把这个Bean的Class对象赋值给BeanDefinition对象的type变量
beanDefinition.setType(clazz);
//把所有Bean名和它对应的BeanDefinition对象映射关系,存到map里统一管理
beanDefinitionMap.put(beanName,beanDefinition);
System.out.println("Bean名:"+beanName+",BeanDefinition对象:"+beanDefinition);
}
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
// 3.实例化bean,如果作用域是单例,则从单例池中取;取不到就创建新的Bean对象,并存入单例池
for (String beanName:beanDefinitionMap.keySet()) {
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if ("singleton".equals(beanDefinition.getScope())) {
//实例化Bean
Object bean = createBean(beanName,beanDefinition);
singletonObjects.put(beanName,bean);
}
}
}
//根据Bean名和BeanDefinition对象实例化Bean的方法;私有,只供本类内部调用
//BeanDefinition对象的成员变量type就是Bean的类型(Class格式)
private Object createBean(String beanName,BeanDefinition beanDefinition){
// 获取Bean的Class格式的类型
Class clazz = beanDefinition.getType();
try {
//1.基于反射创建Bean的实例;
Object instance = clazz.getConstructor().newInstance();
//2.依赖注入
//遍历Bean类Class对象的所有属性;
for (Field f : clazz.getDeclaredFields()) {
//找出有@Autowired注解的属性,给这些属性进行填充
if (f.isAnnotationPresent(Autowired.class)) {
//破除 private 修饰符访问限制;这样就可以访问注入的这个依赖里面的私有成员
f.setAccessible(true);
//给该属性填充属性名对应的Bean对象。
// 该属性通过getBean能获得Bean,因为上面构造方法里已经扫描了所有的Bean,并创建了BeanDefinition对象加入到“声明map”里了。
//void set(Object obj, Object value)
//obj 表示要设置属性值的对象;value 表示要为该成员变量设置的新值。
f.set(instance,getBean(f.getName()));
}
}
// 3.Aware回调。如果Bean实例实现了BeanNameAware接口,就调用重写的setter方法,给Bean实例的beanName变量赋值
if (instance instanceof BeanNameAware) {
((BeanNameAware) instance).setBeanName(beanName);
}
// 遍历后置处理器列表,执行后置处理器的before方法,在Bean 的初始化方法(如 @PostConstruct 注解的方法)被调用之前被自动调用
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessBeforeInitialization(beanName,instance);
}
// 初始化
if (instance instanceof InitializingBean) {
((InitializingBean) instance).afterPropertiesSet();
}
//Bean后置处理器接口的after方法,在 Bean 的初始化方法被调用之后被自动调用
for (BeanPostProcessor beanPostProcessor : beanPostProcessorList) {
instance = beanPostProcessor.postProcessAfterInitialization(beanName,instance);
}
return instance;
} catch (InstantiationException e) { //异常处理
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
//容器类的getBean()方法,根据作用域获取Bean
public Object getBean(String beanName){
//从map里获取BeanDefinition对象
BeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition == null) {
//如果BeanDefinition对象为空,说明这个bean没有创建成功,抛异常;
throw new NullPointerException();
}else{
//如果BeanDefinition对象不为空,则判断作用域后获取Bean
String scope = beanDefinition.getScope();
if ("singleton".equals(scope)) {
//如果是单例则从单例池根据Bean名取Bean;
Object bean= singletonObjects.get(beanName);
if (bean == null) {
//如果单例池查到的是null,则新创建Bean,再给单例池赋值
bean = createBean(beanName, beanDefinition);
singletonObjects.put(beanName,bean);
}
//返回Bean
return bean;
}else{
// 多例,每次直接创建新的
return createBean(beanName, beanDefinition);
}
}
}
https://gitee.com/vincewm/spring-master