前言一、SpringIOC介绍二、Spring原生XML实现IOC三、dom4j解析xml四、手写SpringIOC-XML注入对象五、手写SpringIOC-注解注入对象六、手写SpringIOC-依赖注入
前言本篇先介绍通过使用SpringIOC的XML和注解的方式来实现对象注入然后我们使用手写的方式，自定义XML和注解的方式来实现IOC对象注入最后再通过手写实现SpringIOC的依赖注入通过手写的方式，让我们加深对SpringIOC的理解和思想 一、SpringIOC介绍
IOC：控制反转
比如说有一个类，我们想要调用类里面的方法(不是静态方法)，就要创建类的对象，使用对象调用方法实现对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的 二、Spring原生XML实现IOC
SpringIOC原生XML的实现原理
XML解析使用dom4j，反射机制创建对象 1.service
public interface UserService {
public void add();
public void del();
}
@Service
public class UserServiceImpl implements UserService {
public UserServiceImpl(){
System.out.println("无参构造函数.....反射初始化");
}
//...省略
}
2.spring.xml
3.MainTest
new ClassPathXmlApplicationContext("spring.xml");运行后对象就已经被创建好了，而不是在getBean("UserService")的时候才创建对象
public static void main(String[] args) {
ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService)app.getBean("UserService");
System.out.println(userService);
}
三、dom4j解析xml
1.pom依赖
dom4j dom4j 1.6.1 commons-lang commons-lang 2.6
2.resources路径下新建student.xml
<微信公众号>A大学 <学号>201326 <地址>北京海淀区 <座右铭>要么强大，要么听话 <新浪微博>B大学 <学号>205812 <地址>北京朝阳区 <座右铭>在哭泣中学会坚强
3.XmlUtils
public class XmlUtils {
public static void main(String[] args) throws SAXException, documentException {
XmlUtils xmlUtils = new XmlUtils();
xmlUtils.test001();
}
public void test001() throws documentException {
SAXReader saxReader = new SAXReader();
document read = saxReader.read(getClassPath("student.xml"));
// 获取根节点
Element rootElement = read.getRootElement();
getNodes(rootElement);
}
public InputStream getClassPath(String xmlPath) {
InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(xmlPath);
return resourceAsStream;
}
public static void getNodes(Element rootElement) {
System.out.println("获取当前名称:" + rootElement.getName());
// 获取属性信息
List attributes = rootElement.attributes();
for (Attribute attribute : attributes) {
System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
}
// 获取属性value
String value = rootElement.getTextTrim();
if (!StringUtils.isEmpty(value)) {
System.out.println("value:" + value);
}
// 使用迭代器遍历,继续遍历子节点
Iterator elementIterator = rootElement.elementIterator();
while (elementIterator.hasNext()) {
Element next = elementIterator.next();
getNodes(next);
}
}
}
四、手写SpringIOC-XML注入对象
1.实现思路
a）使用dom4j解析xml文件b）使用方法参数beanId查找配置文件中bean节点的id信息是否一致c）获取class的信息地址，使用反射机制初始化对象，实现对象注入 2.自定义实现ExtClassPathXmlApplicationContext
public class ExtClassPathXmlApplicationContext{
// xml路径地址
private String xmlPath;
public ClassPathXmlApplicationContext(String xmlPath) {
this.xmlPath = xmlPath;
}
public Object getBean(String beanId) throws Exception {
// 1. 解析xml文件
List elements = readerXml();
if (elements == null) {
throw new Exception("beanId不能为空");
}
// 2. 使用beanId查找对应的class地址
String beanClass = findXmlByIDClass(elements, beanId);
if (StringUtils.isEmpty(beanClass)) {
throw new Exception("配置文件中，没有配置bean信息");
}
// 3. 使用反射机制初始化，对象
Class forName = Class.forName(beanClass);
return forName.newInstance();
}
// 解析xml文件
public List readerXml() throws documentException {
SAXReader saxReader = new SAXReader();
if (StringUtils.isEmpty(xmlPath)) {
new Exception("xml路径为空...");
}
document read = saxReader.read(getClassXmlInputStream(xmlPath));
// 获取根节点信息
Element rootElement = read.getRootElement();
// 获取子节点
List elements = rootElement.elements();
if (elements == null || elements.isEmpty()) {
return null;
}
return elements;
}
// 使用beanid查找该Class地址
public String findXmlByIDClass(List elements, String beanId) throws Exception {
for (Element element : elements) {
// 读取节点上是否有value
String beanIdValue = element.attributevalue("id");
if (beanIdValue == null) {
throw new Exception("使用该beanId未查找到元素");
}
if (!beanIdValue.equals(beanId)) {
continue;
}
// 获取Class地址属性
String classPath = element.attributevalue("class");
if (!StringUtils.isEmpty(classPath)) {
return classPath;
}
}
return null;
}
// 读取xml配置文件
public InputStream getClassXmlInputStream(String xmlPath) {
InputStream resourceAsStream = getClass().getClassLoader().getResourceAsStream(xmlPath);
return resourceAsStream;
}
}
3.MainTest
public class App {
public static void main(String[] args) throws Exception {
ExtClassPathXmlApplicationContext app = new ExtClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService)app.getBean("UserService");
System.out.println(userService);
}
}
五、手写SpringIOC-注解注入对象
1.思路
使用Java反射机制扫包，获取当前包下所有的类判断类上是否存在注入bean的注解使用Java反射机制进行初始化 2.自定义注解ExtService
//自定义注解 service 注入bean容器
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtService {
}
3.service
public interface UserService {
public void add();
}
@ExtService
public class UserServiceImpl implements UserService {
public UserServiceImpl(){
System.out.println("无参构造函数.....反射初始化");
}
public void add() {
System.out.println("add方法调用");
}
}
4.工具类
这个直接使用，不需要深究
import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
public class ClassUtil {
public static List getAllClassByInterface(Class c) {
List returnClassList = null;
if (c.isInterface()) {
// 获取当前的包名
String packageName = c.getPackage().getName();
// 获取当前包下以及子包下所以的类
List> allClass = getClasses(packageName);
if (allClass != null) {
returnClassList = new ArrayList();
for (Class classes : allClass) {
// 判断是否是同一个接口
if (c.isAssignableFrom(classes)) {
// 本身不加入进去
if (!c.equals(classes)) {
returnClassList.add(classes);
}
}
}
}
}
return returnClassList;
}
public static String[] getPackageAllClassName(String classLocation, String packageName) {
// 将packageName分解
String[] packagePathSplit = packageName.split("[.]");
String realClassLocation = classLocation;
int packageLength = packagePathSplit.length;
for (int i = 0; i < packageLength; i++) {
realClassLocation = realClassLocation + File.separator + packagePathSplit[i];
}
File packeageDir = new File(realClassLocation);
if (packeageDir.isDirectory()) {
String[] allClassName = packeageDir.list();
return allClassName;
}
return null;
}
public static List> getClasses(String packageName) {
// 第一个class类的集合
List> classes = new ArrayList>();
// 是否循环迭代
boolean recursive = true;
// 获取包的名字 并进行替换
String packageDirName = packageName.replace('.', '/');
// 定义一个枚举的集合 并进行循环来处理这个目录下的things
Enumeration dirs;
try {
dirs = Thread.currentThread().getContextClassLoader().getResources(packageDirName);
// 循环迭代下去
while (dirs.hasMoreElements()) {
// 获取下一个元素
URL url = dirs.nextElement();
// 得到协议的名称
String protocol = url.getProtocol();
// 如果是以文件的形式保存在服务器上
if ("file".equals(protocol)) {
// 获取包的物理路径
String filePath = URLDecoder.decode(url.getFile(), "UTF-8");
// 以文件的方式扫描整个包下的文件 并添加到集合中
findAndAddClassesInPackageByFile(packageName, filePath, recursive, classes);
} else if ("jar".equals(protocol)) {
// 如果是jar包文件
// 定义一个JarFile
JarFile jar;
try {
// 获取jar
jar = ((JarURLConnection) url.openConnection()).getJarFile();
// 从此jar包 得到一个枚举类
Enumeration entries = jar.entries();
// 同样的进行循环迭代
while (entries.hasMoreElements()) {
// 获取jar里的一个实体 可以是目录 和一些jar包里的其他文件 如meta-INF等文件
JarEntry entry = entries.nextElement();
String name = entry.getName();
// 如果是以/开头的
if (name.charAt(0) == '/') {
// 获取后面的字符串
name = name.substring(1);
}
// 如果前半部分和定义的包名相同
if (name.startsWith(packageDirName)) {
int idx = name.lastIndexOf('/');
// 如果以"/"结尾 是一个包
if (idx != -1) {
// 获取包名 把"/"替换成"."
packageName = name.substring(0, idx).replace('/', '.');
}
// 如果可以迭代下去 并且是一个包
if ((idx != -1) || recursive) {
// 如果是一个.class文件 而且不是目录
if (name.endsWith(".class") && !entry.isDirectory()) {
// 去掉后面的".class" 获取真正的类名
String className = name.substring(packageName.length() + 1, name.length() - 6);
try {
// 添加到classes
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return classes;
}
public static void findAndAddClassesInPackageByFile(String packageName, String packagePath, final boolean recursive,
List> classes) {
// 获取此包的目录 建立一个File
File dir = new File(packagePath);
// 如果不存在或者 也不是目录就直接返回
if (!dir.exists() || !dir.isDirectory()) {
return;
}
// 如果存在 就获取包下的所有文件 包括目录
File[] dirfiles = dir.listFiles(new FileFilter() {
// 自定义过滤规则 如果可以循环(包含子目录) 或则是以.class结尾的文件(编译好的java类文件)
public boolean accept(File file) {
return (recursive && file.isDirectory()) || (file.getName().endsWith(".class"));
}
});
// 循环所有文件
for (File file : dirfiles) {
// 如果是目录 则继续扫描
if (file.isDirectory()) {
findAndAddClassesInPackageByFile(packageName + "." + file.getName(), file.getAbsolutePath(), recursive,
classes);
} else {
// 如果是java类文件 去掉后面的.class 只留下类名
String className = file.getName().substring(0, file.getName().length() - 6);
try {
// 添加到集合中去
classes.add(Class.forName(packageName + '.' + className));
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
}
}
5.ExtClassPathXmlApplicationContext
import org.apache.commons.lang.StringUtils;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
// 手写SpringIOC 注解版本
public class ExtClassPathXmlApplicationContext {
//扫包的范围
private String packageName;
//Spring bean容器
private ConcurrentHashMap> beans = null;
public ExtClassPathXmlApplicationContext(String packageName) throws Exception {
this.packageName = packageName;
beans = new ConcurrentHashMap<>();
initBeans();
}
// 使用beanID查找对象
public Object getBean(String beanId) throws Exception {
if(StringUtils.isEmpty(beanId)){
throw new Exception("beanId参数不能为空");
}
// 1.从Spring容器获取bean
Class classInfo = beans.get(beanId);
if(classInfo == null){
throw new Exception("class not found");
}
// 2.使用反射机制初始化对象
return newInstance(classInfo);
}
public Object newInstance(Class classInfo) throws IllegalAccessException, InstantiationException {
return classInfo.newInstance();
}
//初始化对象
public void initBeans() throws Exception {
// 1.使用Java反射机制扫包，获取当前包下所有的类
List> classes = ClassUtil.getClasses(packageName);
// 2.判断类上是否存在注入bean的注解
ConcurrentHashMap> classExitAnnotation = findClassExitAnnotation(classes);
if(classExitAnnotation == null || classExitAnnotation.isEmpty()){
throw new Exception("该包下没有任何类有加上注解");
}
}
public ConcurrentHashMap> findClassExitAnnotation(List> classes) {
for (Class classInfo : classes) {
//判断该类上是否有注解
ExtService annotation = classInfo.getAnnotation(ExtService.class);
if (annotation != null) {
// beanid 类名小写 获取当前类名
String className = classInfo.getSimpleName();
String beanId = toLowerCaseFirstOne(className);
beans.put(beanId, classInfo);
}
}
return beans;
}
// 首字母转小写
public static String toLowerCaseFirstOne(String s) {
if (Character.isLowerCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
}
6.MainTest
"com.sjyl.service"：这个是扫包的地址userServiceImpl：getBean这个需要类名的首字母小写
public class App {
public static void main(String[] args) throws Exception {
ExtClassPathXmlApplicationContext app = new ExtClassPathXmlApplicationContext("com.sjyl.service");
UserService userService = (UserService)app.getBean("userServiceImpl");
System.out.println(userService);
}
}
六、手写SpringIOC-依赖注入
1.什么是依赖注入
第五点，我们已经通过ExtService实现了对象的注入而如果UserService中还有其他的对象，我们也需要进行对象的注入，这个就称为依赖注入（如下第3点的新增的OrderService） 2.依赖注入原理：
使用反射机制，获取当前类的所有属性判断当前类属性是否存在注解默认使用属性名称，查找bean容器对象 3.service
public interface UserService {
public void add();
}
@ExtService
public class UserServiceImpl implements UserService {
@ExtResource
private OrderService orderServiceImpl;
public void add() {
orderServiceImpl.addOrder();
System.out.println("add方法调用");
}
}
public interface OrderService {
public void addOrder();
}
@ExtService
public class OrderServiceImpl implements OrderService {
@Override
public void addOrder() {
System.out.println("addOrder调用....");
}
}
4.ExtResource
@Target({ ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ExtResource {
}
5.ExtClassPathXmlApplicationContext
// 手写SpringIOC 注解版本
public class ExtClassPathXmlApplicationContext {
//扫包的范围
private String packageName;
//Spring bean容器
private ConcurrentHashMap beans = null;
public ExtClassPathXmlApplicationContext(String packageName) throws Exception {
this.packageName = packageName;
beans = new ConcurrentHashMap<>();
initBeans();
initEntryField();
}
// 初始化类属性
private void initEntryField() throws Exception {
// 1.遍历所有的bean容器对象
for (Map.Entry entry : beans.entrySet()) {
// 2.判断类属性上面是否有加注解
Object bean = entry.getValue();
attriAssign(bean);
}
}
// 使用beanID查找对象
public Object getBean(String beanId) throws Exception {
if (StringUtils.isEmpty(beanId)) {
throw new Exception("beanId参数不能为空");
}
// 1.从Spring容器获取bean
Object object = beans.get(beanId);
// 2.使用反射机制初始化对象
return object;
}
public Object newInstance(Class classInfo) throws IllegalAccessException, InstantiationException {
return classInfo.newInstance();
}
//初始化对象
public void initBeans() throws Exception {
// 1.使用Java反射机制扫包，获取当前包下所有的类
List> classes = ClassUtil.getClasses(packageName);
// 2.判断类上是否存在注入bean的注解
ConcurrentHashMap classExitAnnotation = findClassExitAnnotation(classes);
if (classExitAnnotation == null || classExitAnnotation.isEmpty()) {
throw new Exception("该包下没有任何类有加上注解");
}
}
public ConcurrentHashMap findClassExitAnnotation(List> classes) throws InstantiationException, IllegalAccessException {
for (Class classInfo : classes) {
//判断该类上是否有注解
ExtService annotation = classInfo.getAnnotation(ExtService.class);
if (annotation != null) {
// beanid 类名小写 获取当前类名
String className = classInfo.getSimpleName();
String beanId = toLowerCaseFirstOne(className);
Object newInstance = newInstance(classInfo);
beans.put(beanId, newInstance);
}
}
return beans;
}
// 首字母转小写
public static String toLowerCaseFirstOne(String s) {
if (Character.isLowerCase(s.charAt(0)))
return s;
else
return (new StringBuilder()).append(Character.toLowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
public void attriAssign(Object object) throws Exception {
// 1.使用反射机制，获取当前类的所有属性
Class classInfo = object.getClass();
Field[] declaredFields = classInfo.getDeclaredFields();
// 2.判断当前类属性是否存在注解
for (Field field : declaredFields) {
ExtResource extResource = field.getAnnotation(ExtResource.class);
if (extResource != null) {
String beanId = field.getName();
Object bean = getBean(beanId);
if (bean != null) {
// 3.默认使用属性名称，查找bean容器对象
field.setAccessible(true);//允许访问私有属性
field.set(object, bean);//参数1：当前对象；参数2：参数给属性赋值
}
}
}
}
}
6.MainTest
public class App {
public static void main(String[] args) throws Exception {
ExtClassPathXmlApplicationContext app = new ExtClassPathXmlApplicationContext("com.sjyl.service");
UserService userService = (UserService)app.getBean("userServiceImpl");
userService.add();
}
}
