目录
EasyAnnotationConfigApplicationContext
EasyDefaultListableBeanFactory
EasySpring
注解
包：easy.spring.annotations
@EasyAutowired
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.CONSTRUCTOR})
public @interface EasyAutowired {
}
@EasyComponent
package easy.spring.annotations;
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EasyComponent {
String value() default "";
}
@EasyComponentScan
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EasyComponentScan {
String[] value() default {};
}
@EasyLazy
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EasyLazy {
}
@EasyPostConstruct
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface EasyPostConstruct {
}
@EasyProtoType
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface EasyProtoType {
}
@EasyValue
package easy.spring.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface EasyValue {
String value();
}
Bean定义信息
包：easy.spring.beandefinition
EasyBeanDefinition
package easy.spring.beandefinition;
public class EasyBeanDefinition {
// bean名称
private String beanName;
// bean类型
private Class<?> beanType;
// bean的全限定名
private String packageClassName;
// 是否懒加载
private boolean isLazy;
// 是否单例
private boolean isSingleton = true;
public String getBeanName() {
return beanName;
}
public void setBeanName(String beanName) {
this.beanName = beanName;
}
public Class<?> getBeanType() {
return beanType;
}
public void setBeanType(Class<?> beanType) {
this.beanType = beanType;
}
public String getPackageClassName() {
return packageClassName;
}
public void setPackageClassName(String packageClassName) {
this.packageClassName = packageClassName;
}
public boolean isLazy() {
return isLazy;
}
public void setLazy(boolean lazy) {
isLazy = lazy;
}
public boolean isSingleton() {
return isSingleton;
}
public void setSingleton(boolean singleton) {
isSingleton = singleton;
}
}
管理Bean定义信息
EasyBeanDefinitionRegister
包：easy.spring.register
package easy.spring.register;
import easy.spring.beandefinition.EasyBeanDefinition;
/**
* 管理BeanDefinition
*/
public interface EasyBeanDefinitionRegister {
/**
* 注册BeanDefinition
*/
void registerBeanDefinition(String beanName, EasyBeanDefinition beanDefinition);
}
Aware
包：easy.spring.aware
EasyAware
package easy.spring.aware;
public interface EasyAware {
}
EasyBeanFactoryAware
package easy.spring.aware;
import easy.spring.container.EasyBeanFactory;
public interface EasyBeanFactoryAware extends EasyAware {
/**
* 传递Bean工厂
*/
void setEasyBeanFactory(EasyBeanFactory easyBeanFactory);
}
EasyBeanNameAware
package easy.spring.aware;
public interface EasyBeanNameAware extends EasyAware {
/**
* 传递beanName
*/
void setBeanName(String beanName);
}
初始化
包：easy.spring.init
EasyInitializingBean
package easy.spring.init;
public interface EasyInitializingBean {
/**
* Bean属性填充后的方法回调
*/
void afterPropertiesSet();
}
后置处理器
包：easy.spring.postprocessor
EasyBeanFactoryPostProcessor
package easy.spring.postprocessor;
import easy.spring.container.EasyDefaultListableBeanFactory;
/**
* Bean工厂后处理器
*/
@FunctionalInterface
public interface EasyBeanFactoryPostProcessor {
/**
* 此回调方法传递了Bean工厂
*/
void postProcessBeanFactory(EasyDefaultListableBeanFactory beanFactory);
}
EasyBeanPostProcessor
package easy.spring.postprocessor;
/**
* Bean后置处理器
*/
public interface EasyBeanPostProcessor {
/**
* 初始化前回调方法
*/
default Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}
/**
* 初始化后回调方法
*/
default Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
工具类
包：easy.spring.utils
EasySpringUtil
package easy.spring.utils;
import easy.spring.annotations.*;
import easy.spring.beandefinition.EasyBeanDefinition;
import easy.spring.container.EasyDefaultListableBeanFactory;
import easy.spring.postprocessor.EasyBeanFactoryPostProcessor;
import easy.spring.postprocessor.EasyBeanPostProcessor;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
public class EasySpringUtil {
// 资源是文件
private static final String FILE = "file";
/**
* 获取basePackage
*/
public static String[] getBasePackage(Class<?> componentClass) {
if (componentClass == null) return null;
if (!componentClass.isAnnotationPresent(EasyComponentScan.class)) return null;
String[] basePackages = componentClass.getAnnotation(EasyComponentScan.class).value();
if (basePackages == null || basePackages.length == 0) return null;
return basePackages;
}
/**
* 获取指定包及其子包下的组件
*/
public static void componentClassInPackage(String basePackage, EasyDefaultListableBeanFactory beanFactory) throws Exception {
if (basePackage == null || basePackage.equals("")) return;
// 路径转换
String path = basePackage.replace(".", "/");
// 获取类加载器
ClassLoader classLoader = getClassLoader();
Enumeration<URL> resources = classLoader.getResources(path);
while (resources.hasMoreElements()) {
URL resource = resources.nextElement();
if (!FILE.equals(resource.getProtocol())) continue;
// 目录
String directory = URLDecoder.decode(resource.getFile(), StandardCharsets.UTF_8.name());
scanDirectory(new File(directory), basePackage, beanFactory, classLoader);
}
}
private static void scanDirectory(File directory, String packageName, EasyDefaultListableBeanFactory beanFactory, ClassLoader classLoader) {
File[] files = directory.listFiles();
if (files == null) return;
for (File file : files) {
// 还是目录
if (file.isDirectory()) {
// 继续扫描子目录
String newPackage = packageName.isEmpty() ? file.getName() : packageName + "." + file.getName();
// 递归扫描
scanDirectory(file, newPackage, beanFactory, classLoader);
} else if (file.getName().endsWith(".class")) {
// 文件名
String fileName = file.getName();
int length = fileName.length();
fileName = fileName.substring(0, length - 6);
// 全限定名
String className = packageName + "." + fileName;
loadClass(className, classLoader, fileName, beanFactory);
}
}
}
private static void loadClass(String className, ClassLoader classLoader, String fileName, EasyDefaultListableBeanFactory beanFactory) {
try {
Class<?> cls = classLoader.loadClass(className);
if (!cls.isAnnotationPresent(EasyComponent.class)) {
return;
}
// 保存组件类
String componentName = cls.getAnnotation(EasyComponent.class).value();
if (componentName == null || "".equals(componentName)) {
// 组件默认名称为类名首字母小写
componentName = fileName.substring(0, 1).toLowerCase() + fileName.substring(1);
}
EasyBeanDefinition beanDefinition = buildBeanDefinition(className, componentName, cls);
registerBeanDefinition(beanFactory, beanDefinition);
// BeanFactory后处理器
if (EasyBeanFactoryPostProcessor.class.isAssignableFrom(cls)) {
beanFactory.addBeanFactoryPostProcessor((EasyBeanFactoryPostProcessor) instantiateBean(beanDefinition));
}
// Bean后处理器
if (EasyBeanPostProcessor.class.isAssignableFrom(cls)) {
beanFactory.addBeanPostProcessor((EasyBeanPostProcessor) instantiateBean(beanDefinition));
}
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
/**
* 构建BeanDefinition
*/
public static EasyBeanDefinition buildBeanDefinition(String className, String componentName, Class<?> cls) {
EasyBeanDefinition beanDefinition = new EasyBeanDefinition();
beanDefinition.setBeanName(componentName);
beanDefinition.setBeanType(cls);
beanDefinition.setPackageClassName(className);
if (cls.isAnnotationPresent(EasyLazy.class)) {
beanDefinition.setLazy(true);
}
if (cls.isAnnotationPresent(EasyProtoType.class)) {
beanDefinition.setSingleton(false);
}
return beanDefinition;
}
public static void registerBeanDefinition(EasyDefaultListableBeanFactory beanFactory, EasyBeanDefinition beanDefinition) {
beanFactory.registerBeanDefinition(beanDefinition.getBeanName(), beanDefinition);
}
/**
* 获取类加载器
*/
public static ClassLoader getClassLoader() {
return Thread.currentThread().getContextClassLoader();
}
/**
* Bean的实例化
*/
public static Object instantiateBean(EasyBeanDefinition beanDefinition) {
try {
if (beanDefinition == null) return null;
Class<?> beanType = beanDefinition.getBeanType();
Constructor<?> constructor = beanType.getConstructor();
return constructor.newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Bean的属性填充
*/
public static void populateBean(Object bean, EasyDefaultListableBeanFactory beanFactory) {
if (bean == null) return;
Class<?> clz = bean.getClass();
Field[] fields = clz.getDeclaredFields();
if (fields.length == 0) {
return;
}
// 处理@EasyAutowired
handleAutowired(bean, fields, beanFactory);
// 处理@EasyValue
handleValue(bean, fields);
System.out.println("处理属性注入完成...");
}
private static void handleAutowired(Object bean, Field[] fields, EasyDefaultListableBeanFactory beanFactory) {
for (Field field : fields) {
field.setAccessible(true);
if (!field.isAnnotationPresent(EasyAutowired.class)) {
continue;
}
Class<?> type = field.getType();
Object propertyBean = beanFactory.getBean(type);
if (propertyBean == null) {
throw new RuntimeException(String.format("no such type bean:[%s]", type.getName()));
}
try {
field.set(bean, propertyBean);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
private static void handleValue(Object bean, Field[] fields) {
for (Field field : fields) {
try {
field.setAccessible(true);
if (!field.isAnnotationPresent(EasyValue.class)) {
continue;
}
EasyValue easyValue = field.getAnnotation(EasyValue.class);
String value = easyValue.value();
if (value == null) {
field.set(bean, null);
return;
}
Class<?> type = field.getType();
if (type == Integer.class || type == int.class) {
field.set(bean, Integer.valueOf(value));
} else if (type == Long.class || type == long.class) {
field.set(bean, Long.valueOf(value));
} else if (type == Double.class || type == double.class) {
field.set(bean, Double.valueOf(value));
} else if (type == BigDecimal.class) {
field.set(bean, new BigDecimal(value));
} else {
field.set(bean, value);
}
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
/**
* 执行初始化方法
*/
public static void invokeInitMethod(Object bean) {
if (bean == null)
return;
Method[] methods = bean.getClass().getDeclaredMethods();
for (Method method : methods) {
if (!method.isAnnotationPresent(EasyPostConstruct.class)) {
continue;
}
try {
method.invoke(bean);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
容器
包：easy.spring.container
EasyBeanFactory
package easy.spring.container;
/**
* Bean工厂，顶级接口
*/
public interface EasyBeanFactory {
/**
* 通过beanName获取bean对象
*
* @param beanName：bean的名字
* @return：bean对象
*/
Object getBean(String beanName);
/**
* 通过beanType获取bean对象
*
* @param beanType：bean的类型
* @return：bean对象
*/
<T> T getBean(Class<T> beanType);
/**
* 通过beanName和beanType获取bean对象
*
* @param beanName：bean的名字
* @param beanType：bean的类型
*/
<T> T getBean(String beanName, Class<T> beanType);
}
EasyAnnotationConfigApplicationContext
package easy.spring.container;
import easy.spring.beandefinition.EasyBeanDefinition;
import easy.spring.postprocessor.EasyBeanFactoryPostProcessor;
import easy.spring.utils.EasySpringUtil;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class EasyAnnotationConfigApplicationContext implements EasyBeanFactory {
// 维护了Bean工厂的引用
private final EasyDefaultListableBeanFactory beanFactory;
public EasyAnnotationConfigApplicationContext(Class<?>... componentClasses) {
// check
if (componentClasses == null || componentClasses.length == 0)
throw new RuntimeException("no component class!");
// 刷新bean工厂
beanFactory = refreshBeanFactory();
// 注册Bean定义信息
register(componentClasses);
// BeanFactoryPostProcessor的方法回调
invokeBeanFactoryPostProcessors();
// 创建所有非懒加载的单例Bean放入单例池子中
doCreateBean();
}
private EasyDefaultListableBeanFactory refreshBeanFactory() {
return new EasyDefaultListableBeanFactory();
}
private void register(Class<?>... componentClasses) {
// 用于存放所有要扫描的包
List<String> basePackages = new ArrayList<>();
for (Class<?> component : componentClasses) {
String[] packages = EasySpringUtil.getBasePackage(component);
if (packages == null) {
continue;
}
basePackages.addAll(Arrays.asList(packages));
}
// 没有解析到要扫描的base包
if (basePackages.size() == 0) {
throw new RuntimeException("no basePackages!");
}
// 遍历所有base包
for (String basePackage : basePackages) {
try {
EasySpringUtil.componentClassInPackage(basePackage, beanFactory);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
private void invokeBeanFactoryPostProcessors() {
List<EasyBeanFactoryPostProcessor> beanFactoryPostProcessors = beanFactory.getBeanFactoryPostProcessors();
// 执行每一个BeanFactory后置处理器
for (EasyBeanFactoryPostProcessor beanFactoryPostProcessor : beanFactoryPostProcessors) {
beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
}
}
public void doCreateBean() {
// 遍历所有的beanName
List<String> beanNames = beanFactory.getBeanNames();
for (String beanName : beanNames) {
Map<String, EasyBeanDefinition> beanDefinitionMap = beanFactory.getBeanDefinitionMap();
EasyBeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
if (beanDefinition.isLazy() || !beanDefinition.isSingleton()) {
continue;
}
Object bean = beanFactory.getBean(beanName);
// 放入单例池
beanFactory.registerSingletonBean(beanName, bean);
}
}
@Override
public Object getBean(String beanName) {
return this.beanFactory.getBean(beanName);
}
@Override
public <T> T getBean(Class<T> beanType) {
return this.beanFactory.getBean(beanType);
}
@Override
public <T> T getBean(String beanName, Class<T> beanType) {
return this.beanFactory.getBean(beanName, beanType);
}
}
EasyDefaultListableBeanFactory
package easy.spring.container;
import easy.spring.aware.EasyAware;
import easy.spring.aware.EasyBeanFactoryAware;
import easy.spring.aware.EasyBeanNameAware;
import easy.spring.beandefinition.EasyBeanDefinition;
import easy.spring.init.EasyInitializingBean;
import easy.spring.postprocessor.EasyBeanFactoryPostProcessor;
import easy.spring.postprocessor.EasyBeanPostProcessor;
import easy.spring.register.EasyBeanDefinitionRegister;
import easy.spring.utils.EasySpringUtil;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 功能最强大的Bean容器
*/
public class EasyDefaultListableBeanFactory implements EasyBeanFactory, EasyBeanDefinitionRegister {
// 单例池
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(64);
//Bean定义信息
private final Map<String, EasyBeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(64);
//Bean Names
private final List<String> beanNames = new CopyOnWriteArrayList<>();
// Bean后处理器
private final List<EasyBeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
// Bean工厂后处理器
private final List<EasyBeanFactoryPostProcessor> beanFactoryPostProcessors = new CopyOnWriteArrayList<>();
public Object getBean(String beanName) {
if (!beanNames.contains(beanName)) {
throw new RuntimeException(String.format("no such beanName:[%s]", beanName));
}
// 单例池中存在，直接返回
Object bean = getBeanFromSingletonObjects(beanName);
if (bean != null) {
return bean;
}
EasyBeanDefinition beanDefinition = beanDefinitionMap.get(beanName);
// 实例化
bean = EasySpringUtil.instantiateBean(beanDefinition);
// 属性填充
EasySpringUtil.populateBean(bean, this);
// InitializingBean#afterPropertiesSet
if (bean instanceof EasyInitializingBean) {
((EasyInitializingBean) bean).afterPropertiesSet();
}
// Aware接口的方法回调
if (bean instanceof EasyAware) {
if (bean instanceof EasyBeanFactoryAware) {
((EasyBeanFactoryAware) bean).setEasyBeanFactory(this);
}
if (bean instanceof EasyBeanNameAware) {
((EasyBeanNameAware) bean).setBeanName(beanName);
}
}
// BeanPostProcessor#postProcessBeforeInitialization
for (EasyBeanPostProcessor beanPostProcessor : beanPostProcessors) {
bean = beanPostProcessor.postProcessBeforeInitialization(bean, beanName);
}
// 执行@PostConstruct注解标记的初始化方法
EasySpringUtil.invokeInitMethod(bean);
// BeanPostProcessor#postProcessAfterInitialization
for (EasyBeanPostProcessor beanPostProcessor : beanPostProcessors) {
bean = beanPostProcessor.postProcessAfterInitialization(bean, beanName);
}
// 懒加载的单例Bean
if (beanDefinition.isLazy()) {
registerSingletonBean(beanName, bean);
}
return bean;
}
@Override
@SuppressWarnings("all")
public <T> T getBean(Class<T> beanType) {
if (beanType == null) {
throw new RuntimeException("the bean type is null!");
}
String beanName = null;
for (Map.Entry<String, EasyBeanDefinition> entry : beanDefinitionMap.entrySet()) {
EasyBeanDefinition beanDefinition = entry.getValue();
if (beanDefinition.getBeanType() == beanType || beanType.isAssignableFrom(beanDefinition.getBeanType())) {
beanName = entry.getKey();
break;
}
}
if (beanName == null) {
throw new RuntimeException(String.format("no such type bean:[%s]!", beanType.getName()));
}
return (T) getBean(beanName);
}
@Override
@SuppressWarnings("all")
public <T> T getBean(String beanName, Class<T> beanType) {
return (T) getBean(beanName);
}
@Override
public void registerBeanDefinition(String beanName, EasyBeanDefinition beanDefinition) {
if (beanNames.contains(beanName)) {
throw new RuntimeException("exists beanName!");
}
beanDefinitionMap.put(beanName, beanDefinition);
beanNames.add(beanName);
}
public void registerSingletonBean(String beanName, Object bean) {
singletonObjects.put(beanName, bean);
}
/**
* 从单例池中获取Bean实例
*/
public Object getBeanFromSingletonObjects(String beanName) {
return singletonObjects.get(beanName);
}
public List<String> getBeanNames() {
return beanNames;
}
public Map<String, EasyBeanDefinition> getBeanDefinitionMap() {
return beanDefinitionMap;
}
public List<EasyBeanPostProcessor> getBeanPostProcessors() {
return beanPostProcessors;
}
public List<EasyBeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return beanFactoryPostProcessors;
}
public void addBeanPostProcessor(EasyBeanPostProcessor beanPostProcessor) {
beanPostProcessors.add(beanPostProcessor);
}
public void addBeanFactoryPostProcessor(EasyBeanFactoryPostProcessor beanFactoryPostProcessor) {
beanFactoryPostProcessors.add(beanFactoryPostProcessor);
}
}
测试案例
package test.config;
import easy.spring.annotations.EasyComponentScan;
@EasyComponentScan("test")
public class EasySpringConfig {
}案例一
测试单例Bean
package test.bean;
import easy.spring.annotations.EasyComponent;
import easy.spring.annotations.EasyValue;
@EasyComponent
public class Account {
}
package test.main;
import easy.spring.container.EasyAnnotationConfigApplicationContext;
import easy.spring.container.EasyBeanFactory;
import test.bean.Account;
import test.config.EasySpringConfig;
public class TestMain {
public static void main(String[] args) {
EasyBeanFactory easyBeanFactory = new EasyAnnotationConfigApplicationContext(EasySpringConfig.class);
// 通过beanName获取
Object accountBean1 = easyBeanFactory.getBean("account");
// 再次通过beanName获取
Object accountBean2 = easyBeanFactory.getBean("account");
// 通过beanType获取
Object accountBean3 = easyBeanFactory.getBean(Account.class);
// 通过beanName+beanType获取
Object accountBean4 = easyBeanFactory.getBean("account", Account.class);
// test.bean.Account@27abe2cd
System.out.println(accountBean1);
// test.bean.Account@27abe2cd
System.out.println(accountBean2);
// test.bean.Account@27abe2cd
System.out.println(accountBean3);
// test.bean.Account@27abe2cd
System.out.println(accountBean4);
}
}
案例二
测试原型Bean
package test.bean;
import easy.spring.annotations.EasyComponent;
import easy.spring.annotations.EasyProtoType;
@EasyComponent
@EasyProtoType
public class User {
}
package test.main;
import easy.spring.container.EasyAnnotationConfigApplicationContext;
import test.config.EasySpringConfig;
public class TestMain {
public static void main(String[] args) {
EasyAnnotationConfigApplicationContext applicationContext = new EasyAnnotationConfigApplicationContext(EasySpringConfig.class);
Object user1 = applicationContext.getBean("user");
// test.bean.User@5f5a92bb
System.out.println(user1);
Object user2 = applicationContext.getBean("user");
// test.bean.User@6fdb1f78
System.out.println(user2);
}
}
案例三
测试属性注入：@EasyValue
package test.bean;
import easy.spring.annotations.EasyComponent;
import easy.spring.annotations.EasyValue;
@EasyComponent
public class Account {
@EasyValue("账户A")
private String name;
@EasyValue("18")
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Account{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package test.main;
import easy.spring.container.EasyAnnotationConfigApplicationContext;
import test.bean.Account;
import test.config.EasySpringConfig;
public class TestMain2 {
public static void main(String[] args) {
EasyAnnotationConfigApplicationContext applicationContext = new EasyAnnotationConfigApplicationContext(EasySpringConfig.class);
Account account = applicationContext.getBean("account", Account.class);
// Account{name='账户A', age=18}
System.out.println(account);
}
}
案例四
测试属性注入：@EasyAutowired
package test.service;
public interface AccountService {
void showAllAccounts();
}
package test.service.impl;
import easy.spring.annotations.EasyComponent;
import test.service.AccountService;
@EasyComponent
public class AccountServiceImpl implements AccountService {
@Override
public void showAllAccounts() {
System.out.println("展示所有账户信息...");
}
}
package test.controller;
import easy.spring.annotations.EasyAutowired;
import easy.spring.annotations.EasyComponent;
import test.service.AccountService;
@EasyComponent
public class AccountController {
@EasyAutowired
private AccountService accountService;
public void showAccounts() {
accountService.showAllAccounts();
}
}
package test.main;
import easy.spring.container.EasyAnnotationConfigApplicationContext;
import test.config.EasySpringConfig;
import test.controller.AccountController;
public class TestMain {
public static void main(String[] args) {
EasyAnnotationConfigApplicationContext applicationContext = new EasyAnnotationConfigApplicationContext(EasySpringConfig.class);
AccountController accountController = applicationContext.getBean(AccountController.class);
// 展示所有账户信息...
accountController.showAccounts();
}
}
案例五
测试Bean的生命周期
- 生成BeanDefinition
- BeanFactoryPostProcessor#postProcessBeanFactory方法回调
- 实例化前的后置处理器方法回调
- Bean的实例化
- 实例化后的后置处理器方法回调
- 处理属性注入
- InitializingBean#afterPropertiesSet方法回调
- Aware的方法回调(BeanNameAware、BeanClassLoaderAware、BeanFactoryAware)
- BeanPostProcessor#postProcessBeforeInitialization方法回调
- 执行初始化方法
- BeanPostProcessor#postProcessAfterInitialization方法回调
package test.bean;
import easy.spring.annotations.EasyComponent;
import easy.spring.annotations.EasyPostConstruct;
import easy.spring.annotations.EasyValue;
import easy.spring.aware.EasyBeanNameAware;
import easy.spring.init.EasyInitializingBean;
@EasyComponent
public class LifeCycle implements EasyInitializingBean, EasyBeanNameAware {
@EasyValue("defaultValue")
private String field;
public void showField() {
System.out.println("the field is: " + field);
}
@Override
public void afterPropertiesSet() {
System.out.println("执行InitializingBean#afterPropertiesSet方法...");
}
@Override
public void setBeanName(String beanName) {
System.out.println("执行BeanNameAware的setBeanName方法...beanName is: " + beanName);
}
@EasyPostConstruct
public void initMethod() {
System.out.println("执行初始化方法...");
}
}
package test.bean;
import easy.spring.annotations.EasyValue;
import java.math.BigDecimal;
// 这里只是一个普通的Java类，并没有加@EasyComponent，将通过Bean工厂后处理器将其放入容器中
public class Normal {
@EasyValue("field1")
private String field1;
@EasyValue("99.99")
private BigDecimal field2;
@Override
public String toString() {
return "Normal{" +
"field1='" + field1 + '\'' +
", field2=" + field2 +
'}';
}
}
package test.postprocessor;
import easy.spring.annotations.EasyComponent;
import easy.spring.beandefinition.EasyBeanDefinition;
import easy.spring.container.EasyDefaultListableBeanFactory;
import easy.spring.postprocessor.EasyBeanFactoryPostProcessor;
import test.bean.Normal;
@EasyComponent
public class CustomBeanFactoryPostProcessor implements EasyBeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(EasyDefaultListableBeanFactory beanFactory) {
System.out.println("执行BeanFactoryPostProcessor#postProcessBeanFactory方法...");
// 这里通过Bean工厂后处理器将Normal放入Bean容器
EasyBeanDefinition beanDefinition = new EasyBeanDefinition();
beanDefinition.setBeanType(Normal.class);
beanFactory.registerBeanDefinition("normal",beanDefinition);
}
}
package test.postprocessor;
import easy.spring.annotations.EasyComponent;
import easy.spring.postprocessor.EasyBeanPostProcessor;
@EasyComponent
public class CustomBeanPostProcessor implements EasyBeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
System.out.println("执行BeanPostProcessor#postProcessBeforeInitialization方法...");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
System.out.println("执行BeanPostProcessor#postProcessAfterInitialization方法...");
return bean;
}
}
package test.main;
import easy.spring.container.EasyAnnotationConfigApplicationContext;
import test.bean.LifeCycle;
import test.bean.Normal;
import test.config.EasySpringConfig;
public class TestMain {
public static void main(String[] args) {
EasyAnnotationConfigApplicationContext applicationContext = new EasyAnnotationConfigApplicationContext(EasySpringConfig.class);
LifeCycle lifeCycle = applicationContext.getBean(LifeCycle.class);
//the field is: defaultValue
lifeCycle.showField();
Normal normal = applicationContext.getBean("normal", Normal.class);
//Normal{field1='field1', field2=99.99}
System.out.println(normal);
}
}