bean包
Aware类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/26 10:23
*/
public interface Aware {
}
BeanDefinition类
package com.lv.spring.bean;
import org.springframework.util.StringUtils;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.List;
/**
* Created by lvyanghui
* 2018/11/28 9:35
*/
public interface BeanDefinition {
String SCOPE_SINGLETON = "singleton";
String SCOPE_PROTOTYPE = "prototype";
Class<?> getBeanClass();
String getScope();
boolean isSingleton();
boolean isPrototype();
String getFactoryBeanName();
String getFactoryMethodName();
String getInitMethodName();
String getDestroyMethodName();
List<?> getConstructorArgumentValues();
List<PropertyValue> getPropertyValues();
public Object[] getConstructorArgumentRealValues();
public void setConstructorArgumentRealValues(Object[] values);
public Constructor getConstructor();
public void setConstructor(Constructor constructor);
public Method getFactoryMethod();
public void setFactoryMethod(Method factoryMethod);
default boolean validate(){
if(this.getBeanClass() == null){
if(StringUtils.isEmpty(this.getFactoryBeanName()) || StringUtils.isEmpty(this.getFactoryMethodName())){
return false;
}
}else{
if(!StringUtils.isEmpty(this.getFactoryBeanName())){
return false;
}
}
return true;
}
}
BeanDefinitionRegistry类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/19 14:23
*/
public interface BeanDefinitionRegistry {
void registerBeanDefinition(String beanName,BeanDefinition beanDefinition)throws BeanDefinitionRegistryException;
BeanDefinition getBeanDefinition(String beanName);
boolean containsBeanDefinition(String beanName);
}
BeanDefinitionRegistryException类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/20 11:07
*/
public class BeanDefinitionRegistryException extends Exception{
public BeanDefinitionRegistryException(){
super();
}
public BeanDefinitionRegistryException(Throwable cause){
super(cause);
}
public BeanDefinitionRegistryException(String message){
super(message);
}
public BeanDefinitionRegistryException(String message,Throwable cause){
super(message,cause);
}
}
BeanFactory类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/19 14:21
*/
public interface BeanFactory {
Object getBean(String beanName) throws Exception;
void registryBeanPostProcessor(BeanPostProcessor beanPostProcessor);
}
BeanFactoryAware类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/26 10:24
*/
public interface BeanFactoryAware extends Aware{
void setBeanFactory(BeanFactory beanFactory);
}
BeanPostProcessor类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/26 10:25
*/
public interface BeanPostProcessor {
default Object postProcessBeforeInitialization(String beanName,Object bean){
return bean;
}
default Object postProcessAfterInitialization(String beanName,Object bean){
return bean;
}
}
BeanRefernerce类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/21 10:10
*/
public class BeanRefernerce {
private String beanName;
public BeanRefernerce(String beanName) {
this.beanName = beanName;
}
public String getBeanName() {
return beanName;
}
public void setBeanName(String beanName) {
this.beanName = beanName;
}
}
DefaultBeanFactory类
package com.lv.spring.bean;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import java.io.Closeable;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* Created by lvyanghui
* 2018/12/19 14:50
*/
public class DefaultBeanFactory implements BeanFactory,BeanDefinitionRegistry,Closeable {
private Map<String,BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
private Map<String,Object> beanMap = new ConcurrentHashMap<String,Object>(256);
private ThreadLocal<Set<String>> buildingBeans = new ThreadLocal<>();
private List<BeanPostProcessor> beanPostProcessorList = new ArrayList<>();
@Override
public void registryBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
beanPostProcessorList.add(beanPostProcessor);
if(beanPostProcessor instanceof BeanFactoryAware){
((BeanFactoryAware) beanPostProcessor).setBeanFactory(this);
}
}
@Override
public void registerBeanDefinition(String beanName,BeanDefinition beanDefinition) throws BeanDefinitionRegistryException{
Objects.requireNonNull(beanName,"beanName不能为空!");
Objects.requireNonNull(beanDefinition,"beanDefinition不能为空!");
if(!beanDefinition.validate()){
throw new BeanDefinitionRegistryException("验证beanDefinition参数不合法");
}
if(beanDefinitionMap.containsKey(beanName)){
throw new BeanDefinitionRegistryException("已经存在beanDefinition");
}
beanDefinitionMap.put(beanName,beanDefinition);
}
@Override
public BeanDefinition getBeanDefinition(String beanName) {
return beanDefinitionMap.get(beanName);
}
@Override
public boolean containsBeanDefinition(String beanName) {
return beanDefinitionMap.containsKey(beanName);
}
@Override
public Object getBean(String beanName) throws Exception{
return doGetBean(beanName);
}
protected Object doGetBean(String beanName) throws Exception {
Objects.requireNonNull(beanName,"beanName不能为空");
Object instance = beanMap.get(beanName);
if(null != instance){
return instance;
}
BeanDefinition beanDefinition = getBeanDefinition(beanName);
Objects.requireNonNull(beanDefinition, "beanDefinition不能为空");
Set<String> ingBeans = this.buildingBeans.get();
if(null == ingBeans){
ingBeans = new HashSet<>();
this.buildingBeans.set(ingBeans);
}
if(ingBeans.contains(beanName)){
throw new Exception(beanName + " 循环依赖!" + ingBeans);
}
ingBeans.add(beanName);
Class<?> classType = beanDefinition.getBeanClass();
if(classType != null){
if(beanDefinition.getFactoryMethodName() == null){
instance = createInstanceByConstructor(beanDefinition);
}else{
instance = createInstanceByStaticFactoryMethod(beanDefinition);
}
}else{
instance = createInstanceByFactoryMethod(beanDefinition);
}
ingBeans.remove(beanName);
setPropertyDIValues(beanDefinition,instance);
instance = applyPostProcessBeforeInitialization(beanName,instance);
doInitMethod(beanDefinition,instance);
instance = applyPostProcessAfterInitialization(beanName,instance);
if(beanDefinition.isSingleton()){
beanMap.put(beanName,instance);
}
return instance;
}
public Object createInstanceByConstructor(BeanDefinition beanDefinition)throws Exception{
try{
Object[] args = getConstructorArgumentValues(beanDefinition);
if (null == args) {
return beanDefinition.getBeanClass().newInstance();
}else{
return determinConstructor(beanDefinition,args).newInstance(args);
}
}catch (Exception e){
throw new Exception("创建bean的实例异常,beanDefinition:" + beanDefinition + e.getMessage());
}
}
public Object createInstanceByStaticFactoryMethod(BeanDefinition beanDefinition)throws Exception{
Class<?> classType = beanDefinition.getBeanClass();
Object[] args = getRealValues(beanDefinition.getConstructorArgumentValues());
Method method = determinMethod(beanDefinition,args,null);
return method.invoke(classType,args);
}
public Object createInstanceByFactoryMethod(BeanDefinition beanDefinition)throws Exception{
Object factoryBean = doGetBean(beanDefinition.getFactoryBeanName());
Object[] args = getRealValues(beanDefinition.getConstructorArgumentValues());
Method method = determinMethod(beanDefinition, args,factoryBean.getClass());
return method.invoke(factoryBean,args);
}
public Object[] getRealValues(List<?> defs)throws Exception{
if(CollectionUtils.isEmpty(defs)){
return null;
}
Object[] realValues = new Object[defs.size()];
Object realValue = null;
int i = 0;
for(Object rv : defs){
realValue = resolvePropertyValue(rv);
realValues[i++] = realValue;
}
return realValues;
}
private Object[] getConstructorArgumentValues(BeanDefinition bd) throws Exception {
return this.getRealValues(bd.getConstructorArgumentValues());
}
public void doInitMethod(BeanDefinition beanDefinition,Object instance) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
String initMethod = beanDefinition.getInitMethodName();
if(StringUtils.isNotBlank(initMethod)){
Method method = instance.getClass().getMethod(initMethod, null);
method.invoke(instance,null);
}
}
public Constructor<?> determinConstructor(BeanDefinition beanDefinition,Object[] args)throws Exception{
Constructor ctr = null;
if(null == args){
return beanDefinition.getBeanClass().getConstructor();
}
ctr = beanDefinition.getConstructor();
if(null != ctr){
return ctr;
}
Class[] paramTypes = new Class[args.length];
for (int i = 0, len = args.length; i < len; i++) {
paramTypes[i] = args[i].getClass();
}
try{
ctr = beanDefinition.getBeanClass().getConstructor(paramTypes);
}catch (Exception e){
}
if(null == ctr){
Constructor<?>[] constructors = beanDefinition.getBeanClass().getConstructors();
outer: for(Constructor constructor : constructors){
Class[] parameterTypes = constructor.getParameterTypes();
if(parameterTypes.length == args.length){
for (int j = 0,leng = parameterTypes.length; j < leng; j++) {
if(!parameterTypes[j].isAssignableFrom(args[j].getClass())){
continue outer;
}
}
ctr = constructor;
break outer;
}
}
}
if(null != ctr){
beanDefinition.setConstructor(ctr);
return ctr;
}else{
throw new Exception("找不到构造器");
}
}
public Method determinMethod(BeanDefinition beanDefinition,Object[] args,Class<?> classType)throws Exception{
if(null == classType){
classType = beanDefinition.getBeanClass();
}
Method method = null;
String methodName = beanDefinition.getFactoryMethodName();
if(null == args){
return classType.getMethod(methodName);
}
method = beanDefinition.getFactoryMethod();
if(null != method){
return method;
}
Class[] paramTypes = new Class[args.length];
for (int i = 0, len = args.length; i < len; i++) {
paramTypes[i] = args[i].getClass();
}
try{
method = classType.getMethod(methodName,paramTypes);
}catch (Exception e){
}
if(null == method){
Method[] methods = classType.getMethods();
outer: for(Method me : methods){
if(!me.getName().equals(methodName)){
continue ;
}else{
Class<?>[] parameterTypes = me.getParameterTypes();
if(parameterTypes.length == args.length){
for (int j = 0,leng = parameterTypes.length; j < leng; j++) {
if(!parameterTypes[j].isAssignableFrom(args[j].getClass())){
continue outer;
}
}
method = me;
break outer;
}
}
}
}
if(null != method){
beanDefinition.setFactoryMethod(method);
return method;
}else{
throw new Exception("找不到方法");
}
}
public void setPropertyDIValues(BeanDefinition beanDefinition,Object intance)throws Exception{
List<PropertyValue> propertyValues = beanDefinition.getPropertyValues();
if(!CollectionUtils.isEmpty(propertyValues)){
for(PropertyValue propertyValue : propertyValues){
if(StringUtils.isEmpty(propertyValue.getName())){
continue;
}
Class<?> clazz = intance.getClass();
Field field = clazz.getDeclaredField(propertyValue.getName());
field.setAccessible(true);
Object realValue = resolvePropertyValue(propertyValue.getValue());
field.set(intance,realValue);
}
}
}
public Object resolvePropertyValue(Object value)throws Exception{
Object realValue = null;
if(null != value){
if(value instanceof BeanRefernerce){
realValue = getBean(((BeanRefernerce) value).getBeanName());
} else if (value instanceof Object[]) {
} else if (value instanceof Collection) {
} else if (value instanceof Properties) {
} else if (value instanceof Map) {
} else {
realValue = value;
}
}
return realValue;
}
public Object applyPostProcessBeforeInitialization(String beanName,Object instance){
for(BeanPostProcessor beanPostProcessor : beanPostProcessorList){
instance = beanPostProcessor.postProcessBeforeInitialization(beanName,instance);
}
return instance;
}
public Object applyPostProcessAfterInitialization(String beanName,Object instance){
for(BeanPostProcessor beanPostProcessor : beanPostProcessorList){
instance = beanPostProcessor.postProcessAfterInitialization(beanName,instance);
}
return instance;
}
@Override
public void close() throws IOException {
//执行单例实例的销毁方法
for(Map.Entry<String,BeanDefinition> entry : beanDefinitionMap.entrySet()){
String beanName = entry.getKey();
BeanDefinition beanDefinition = entry.getValue();
if(beanDefinition.isSingleton() && !StringUtils.isEmpty(beanDefinition.getDestroyMethodName())){
Object instance = beanMap.get(beanName);
try {
Method method = instance.getClass().getMethod(beanDefinition.getDestroyMethodName(),null);
method.invoke(instance,null);
} catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
e.printStackTrace();
}
}
}
}
}
GenericBeanDefinition类
package com.lv.spring.bean;
import org.apache.commons.lang3.StringUtils;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.List;
/**
* Created by lvyanghui
* 2018/12/19 14:42
*/
public class GenericBeanDefinition implements BeanDefinition{
private Class<?> beanClass;
private String scope=SCOPE_SINGLETON;
private String factoryBeanName;
private String factoryMethodName;
private String initMethodName;
private String destroyMethodName;
private Constructor constructor;
private Method factoryMethod;
private List<?> constructorArgumentValues;
private List<PropertyValue> propertyValues;
private ThreadLocal<Object[]> realConstructorArgumentValues = new ThreadLocal<>();
@Override
public Object[] getConstructorArgumentRealValues() {
return realConstructorArgumentValues.get();
}
@Override
public void setConstructorArgumentRealValues(Object[] values) {
realConstructorArgumentValues.set(values);
}
public void setBeanClass(Class<?> beanClass) {
this.beanClass = beanClass;
}
public void setScope(String scope) {
if(StringUtils.isNotBlank(scope)){
this.scope = scope;
}
}
public void setFactoryBeanName(String factoryBeanName) {
this.factoryBeanName = factoryBeanName;
}
public void setFactoryMethodName(String factoryMethodName) {
this.factoryMethodName = factoryMethodName;
}
public void setInitMethodName(String initMethodName) {
this.initMethodName = initMethodName;
}
public void setDestroyMethodName(String destroyMethodName) {
this.destroyMethodName = destroyMethodName;
}
public void setConstructorArgumentValues(List<?> constructorArgumentValues) {
this.constructorArgumentValues = constructorArgumentValues;
}
public void setPropertyValues(List<PropertyValue> propertyValues) {
this.propertyValues = propertyValues;
}
@Override
public Class<?> getBeanClass() {
return beanClass;
}
@Override
public String getScope() {
return scope;
}
@Override
public boolean isSingleton() {
return SCOPE_SINGLETON.equals(scope);
}
@Override
public boolean isPrototype() {
return SCOPE_PROTOTYPE.equals(scope);
}
@Override
public String getFactoryBeanName() {
return factoryBeanName;
}
@Override
public String getFactoryMethodName() {
return factoryMethodName;
}
@Override
public String getInitMethodName() {
return initMethodName;
}
@Override
public String getDestroyMethodName() {
return destroyMethodName;
}
@Override
public List<?> getConstructorArgumentValues() {
return constructorArgumentValues;
}
@Override
public List<PropertyValue> getPropertyValues() {
return propertyValues;
}
public Constructor getConstructor() {
return constructor;
}
public void setConstructor(Constructor constructor) {
this.constructor = constructor;
}
public Method getFactoryMethod() {
return factoryMethod;
}
public void setFactoryMethod(Method factoryMethod) {
this.factoryMethod = factoryMethod;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GenericBeanDefinition that = (GenericBeanDefinition) o;
if (beanClass != null ? !beanClass.equals(that.beanClass) : that.beanClass != null) return false;
if (destroyMethodName != null ? !destroyMethodName.equals(that.destroyMethodName) : that.destroyMethodName != null)
return false;
if (factoryBeanName != null ? !factoryBeanName.equals(that.factoryBeanName) : that.factoryBeanName != null)
return false;
if (factoryMethodName != null ? !factoryMethodName.equals(that.factoryMethodName) : that.factoryMethodName != null)
return false;
if (initMethodName != null ? !initMethodName.equals(that.initMethodName) : that.initMethodName != null)
return false;
if (scope != null ? !scope.equals(that.scope) : that.scope != null) return false;
return true;
}
@Override
public int hashCode() {
int result = beanClass != null ? beanClass.hashCode() : 0;
result = 31 * result + (scope != null ? scope.hashCode() : 0);
result = 31 * result + (factoryBeanName != null ? factoryBeanName.hashCode() : 0);
result = 31 * result + (factoryMethodName != null ? factoryMethodName.hashCode() : 0);
result = 31 * result + (initMethodName != null ? initMethodName.hashCode() : 0);
result = 31 * result + (destroyMethodName != null ? destroyMethodName.hashCode() : 0);
return result;
}
}
PreBuildBeanFactory类
package com.lv.spring.bean;
import java.util.ArrayList;
import java.util.List;
/**
* Created by lvyanghui
* 2018/12/25 14:14
*/
public class PreBuildBeanFactory extends DefaultBeanFactory{
private List<String> beanNames = new ArrayList<>();
@Override
public void registerBeanDefinition(String beanName,BeanDefinition beanDefinition) throws BeanDefinitionRegistryException{
super.registerBeanDefinition(beanName,beanDefinition);
synchronized (beanNames){
beanNames.add(beanName);
}
}
public void preInstantiateSingletons()throws Exception{
synchronized (beanNames){
for(String beanName : beanNames){
BeanDefinition beanDefinition = getBeanDefinition(beanName);
if(beanDefinition.isSingleton()){
doGetBean(beanName);
}
}
}
}
}
PropertyValue类
package com.lv.spring.bean;
/**
* Created by lvyanghui
* 2018/12/21 9:47
*/
public class PropertyValue {
private String name;
private Object value;
public PropertyValue(String name, Object value) {
this.name = name;
this.value = value;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}