摘要：容器实际上就是存放所有的地方，即以及相关信息对应其实体的容器，为什么称之为呢，因为在中，定义信息和实例的东西叫。了解到这个以后接下来就可以开始编写容器了，在包下创建一个类叫。获取容器实例至此，这个容器就完成了。
项目准备
首先确保你拥有以下环境或者工具
idea
java 8
maven 3.3.X
lombok插件
然后我们创建一个maven工程，编写pom.xml引入一些需要的依赖
1.8 1.8 UTF-8 1.7.25 1.16.20 org.slf4j slf4j-log4j12 ${slf4j-api.version} org.projectlombok lombok ${lombok.version} provided
目前只需要lombok和log4j两个依赖就可以完成前面几个功能的实现，其他需要的依赖等到后面需要的时候再加。
接着把项目一些基本的包结构创建一下，如下图
resources文件夹下的log4j.properties文件为log4j输出格式化参数，大家可以根据自己的喜好和需求编写，我自己的只是为了方便调试使用的，下面是我自己的。
### 设置###
log4j.rootLogger = debug,stdout
### 输出信息到控制抬 ###
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = %c %d{ISO8601} -- %p -- %m%n
创建工具类
为了方便后续代码的编写，我们先创建工具类。
在com.zbw.util包下创建两个工具类：ValidateUtil和ClassUtil。
ValidateUtil主要负责属性的验证，这个类的完整代码就不贴了，就是检查各种类型的值是否为空或者是否不为空。
/**
* 验证相关工具类
*/
public final class ValidateUtil {
/**
* Object是否为null
*/
public static boolean isEmpty(Object obj) {
return obj == null;
}
/**
* String是否为null或""
*/
public static boolean isEmpty(String obj) {
return (obj == null || "".equals(obj));
}
...
/**
* Object是否不为null
*/
public static boolean isNotEmpty(Object obj) {
return !isEmpty(obj);
}
/**
* String是否不为null或""
*/
public static boolean isNotEmpty(String obj) {
return !isEmpty(obj);
}
...
}
ClassUtil主要是Class的一些相关操作。这其中除了一些类常用的实例反射等操作，还有一个重要方法就是getPackageClass()，这个方法会递归遍历传入的包名下的所有类文件，并返回一个Set
/**
* 类操作工具类
*/
@Slf4j
public final class ClassUtil {
/**
* file形式url协议
*/
public static final String FILE_PROTOCOL = "file";
/**
* jar形式url协议
*/
public static final String JAR_PROTOCOL = "jar";
/**
* 获取classLoader
*/
public static ClassLoader getClassLoader() {
return Thread.currentThread().getContextClassLoader();
}
/**
* 获取Class
*/
public static Class loadClass(String className) {
try {
return Class.forName(className);
} catch (ClassNotFoundException e) {
log.error("load class error", e);
throw new RuntimeException(e);
}
}
/**
* 实例化class
*/
@SuppressWarnings("unchecked")
public static T newInstance(String className) {
try {
Class clazz = loadClass(className);
return (T) clazz.newInstance();
} catch (Exception e) {
log.error("newInstance error", e);
throw new RuntimeException(e);
}
}
/**
* 实例化class
*/
@SuppressWarnings("unchecked")
public static T newInstance(Class clazz) {
try {
return (T) clazz.newInstance();
} catch (Exception e) {
log.error("newInstance error", e);
throw new RuntimeException(e);
}
}
/**
* 设置类的属性值
*/
public static void setField(Field field, Object target, Object value) {
setField(field, target, value, true);
}
/**
* 设置类的属性值
*/
public static void setField(Field field, Object target, Object value, boolean accessible) {
field.setAccessible(accessible);
try {
field.set(target, value);
} catch (IllegalAccessException e) {
log.error("setField error", e);
throw new RuntimeException(e);
}
}
/**
* 获取包下类集合
*/
public static Set> getPackageClass(String basePackage) {
URL url = getClassLoader()
.getResource(basePackage.replace(".", "/"));
if (null == url) {
throw new RuntimeException("无法获取项目路径文件");
}
try {
if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)) {
// 若为普通文件夹，则遍历
File file = new File(url.getFile());
Path basePath = file.toPath();
return Files.walk(basePath)
.filter(path -> path.toFile().getName().endsWith(".class"))
.map(path -> getClassByPath(path, basePath, basePackage))
.collect(Collectors.toSet());
} else if (url.getProtocol().equalsIgnoreCase(JAR_PROTOCOL)) {
// 若在 jar 包中，则解析 jar 包中的 entry
JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
return jarURLConnection.getJarFile()
.stream()
.filter(jarEntry -> jarEntry.getName().endsWith(".class"))
.map(ClassUtil::getClassByJar)
.collect(Collectors.toSet());
}
return Collections.emptySet();
} catch (IOException e) {
log.error("load package error", e);
throw new RuntimeException(e);
}
}
/**
* 从Path获取Class
*/
private static Class getClassByPath(Path classPath, Path basePath, String basePackage) {
String packageName = classPath.toString().replace(basePath.toString(), "");
String className = (basePackage + packageName)
.replace("/", ".")
.replace("", ".")
.replace(".class", "");
return loadClass(className);
}
/**
* 从jar包获取Class
*/
private static Class getClassByJar(JarEntry jarEntry) {
String jarEntryName = jarEntry.getName();
// 获取类名
String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/", ".");
return loadClass(className);
}
}
实现Bean容器
现在开始可以实现Bean容器了。
基础注解在spring中我们总是用各种注解去标注我们的组件，如controller等。所以我们也要先写一些注解来标注一些必要的组件。在zbw.core包下再创建一个annotation包，然后再创建四个最基本的组件.
// Component注解，用于标记组件
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}
// Controller注解，用于标记Controller层的组件
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}
// Repository注解，用于标记Dao层的组件
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Repository {
}
// Service注解，用于标记Service层的组件
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Service {
}
这四个注解都是只能标注在类上的，他们实际上没有任何作用，只是用来标记这个类的，我们在后面的类集合中就可以很方便的获取和区分被这些注解标记的类。
BeanContainerBean容器实际上就是存放所有Bean的地方，即Class以及相关信息对应其实体的容器，为什么称之为"Bean"呢，因为在spring中，定义Class信息和实例的东西叫BeanDefinition。这是一个接口，他有一个模板类AbstractBeanDefinition，这里面就有一个beanClass变量存放Class类和propertyValues变量存放类属性，以及很多类相关参数和初始化之类的参数。大家可以去spring中看看，spring的所有都是依赖于这个Bean生成的，可以说这是spring的基石。
了解到这个以后接下来就可以开始编写Bean容器了，在zbw.core包下创建一个类叫BeanContainer。
/**
* Bean容器
*/
@Slf4j
public class BeanContainer {
/**
* 存放所有Bean的Map
*/
private final Map, Object> beanMap = new ConcurrentHashMap<>();
/**
* 获取Bean实例
*/
public Object getBean(Class clz) {
if (null == clz) {
return null;
}
return beanMap.get(clz);
}
/**
* 获取所有Bean集合
*/
public Set
我们不需要像spring那样存放很多的信息，所以用一个Map来存储Bean的信息就好了。Map的Key为Class类，Value为这个Class的实例Object。配合getBean(),addBean()等方法就可以很方便的操作Class和它的实例。
然而现在这个Map里还没有存放任何的Bean数据，所以编写一个loadBeans()方法来初始化加载Bean。
首先在BeanContainer中添加一个变量isLoadBean和一个常量BEAN_ANNOTATION
