我们都知道,Spring框架的IOC是基于Java反射机制实现的,下面我们先回顾一下java反射。
1 回顾Java反射
Java
反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为Java
语言的反射机制。简单来说,反射机制指的是程序在运行时能够获取自身的信息。
要想解剖一个类,必须先要获取到该类的Class对象。而剖析一个类或用反射解决具体的问题就是使用相关API(1)java.lang.Class(2)java.lang.reflect,所以,Class对象是反射的根源。
自定义类
package com.atguigu.reflect;
public class Car {
//属性
private String name;
private int age;
private String color;
//无参数构造
public Car() {
}
//有参数构造
public Car(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
//普通方法
private void run() {
System.out.println("私有方法-run.....");
}
//get和set方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
编写测试类
package com.atguigu.reflect;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestCar {
//1、获取Class对象多种方式
@Test
public void test01() throws Exception {
//1 类名.class
Class clazz1 = Car.class;
//2 对象.getClass()
Class clazz2 = new Car().getClass();
//3 Class.forName("全路径")
Class clazz3 = Class.forName("com.atguigu.reflect.Car");
//实例化
Car car = (Car)clazz3.getConstructor().newInstance();
System.out.println(car);
}
//2、获取构造方法
@Test
public void test02() throws Exception {
Class clazz = Car.class;
//获取所有构造
// getConstructors()获取所有public的构造方法
// Constructor[] constructors = clazz.getConstructors();
// getDeclaredConstructors()获取所有的构造方法public private
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor c:constructors) {
System.out.println("方法名称:"+c.getName()+" 参数个数:"+c.getParameterCount());
}
//指定有参数构造创建对象
//1 构造public
// Constructor c1 = clazz.getConstructor(String.class, int.class, String.class);
// Car car1 = (Car)c1.newInstance("夏利", 10, "红色");
// System.out.println(car1);
//2 构造private
Constructor c2 = clazz.getDeclaredConstructor(String.class, int.class, String.class);
c2.setAccessible(true);
Car car2 = (Car)c2.newInstance("捷达", 15, "白色");
System.out.println(car2);
}
//3、获取属性
@Test
public void test03() throws Exception {
Class clazz = Car.class;
Car car = (Car)clazz.getDeclaredConstructor().newInstance();
//获取所有public属性
//Field[] fields = clazz.getFields();
//获取所有属性(包含私有属性)
Field[] fields = clazz.getDeclaredFields();
for (Field field:fields) {
if(field.getName().equals("name")) {
//设置允许访问
field.setAccessible(true);
field.set(car,"五菱宏光");
System.out.println(car);
}
System.out.println(field.getName());
}
}
//4、获取方法
@Test
public void test04() throws Exception {
Car car = new Car("奔驰",10,"黑色");
Class clazz = car.getClass();
//1 public方法
Method[] methods = clazz.getMethods();
for (Method m1:methods) {
//System.out.println(m1.getName());
//执行方法 toString
if(m1.getName().equals("toString")) {
String invoke = (String)m1.invoke(car);
//System.out.println("toString执行了:"+invoke);
}
}
//2 private方法
Method[] methodsAll = clazz.getDeclaredMethods();
for (Method m:methodsAll) {
//执行方法 run
if(m.getName().equals("run")) {
m.setAccessible(true);
m.invoke(car);
}
}
}
}
2 实现Spring的IoC
我们知道,IoC(控制反转)和DI(依赖注入)是Spring里面核心的东西,那么,我们如何自己手写出这样的代码呢?下面我们就一步一步写出Spring框架最核心的部分。
2.1 实现步骤分析
- 第一步,创建子模块:guigu-spring;
- 第二步,创建测试类:service,dao;
- 第三步,创建两个注解,@Bean:创建对象,@DI:属性注入;
- 第四步,创建bean容器接口ApplicationContext,定义方法,返回对象;
- 第五步,实现bean容器接口:(1)返回对象;(2)根据包规则加载bean。
比如包com.atguigu,扫描com.atguigu这个包和它的子包里面所有类,看类上面是否有@Bean注解,如果有,就把这个类通过反射实例化。
2.2 实现Bean创建
2.2.1 搭建子模块
搭建模块:guigu-spring,搭建方式如其他spring子模块
2.2.2 准备测试需要的bean
添加依赖
<dependencies>
<!--junit5测试-->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.3.1</version>
</dependency>
</dependencies>
创建UserDao接口
package com.atguigu.spring6.test.dao;
public interface UserDao {
public void print();
}
创建UserDaoImpl实现
package com.atguigu.spring6.test.dao.impl;
import com.atguigu.spring.dao.UserDao;
public class UserDaoImpl implements UserDao {
@Override
public void print() {
System.out.println("Dao层执行结束");
}
}
创建UserService接口
package com.atguigu.spring6.test.service;
public interface UserService {
public void out();
}
创建UserServiceImpl实现类
package com.atguigu.spring.test.service.impl;
import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.service.UserService;
@Bean
public class UserServiceImpl implements UserService {
// private UserDao userDao;
@Override
public void out() {
//userDao.print();
System.out.println("Service层执行结束");
}
}
2.2.3 定义注解
我们通过注解的形式加载bean与实现依赖注入
bean注解
package com.atguigu.spring.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Bean {
}
依赖注入注解
package com.atguigu.spring.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Di {
}
说明:上面两个注解可以随意取名
2.2.4 定义bean容器接口
package com.atguigu.spring.core;
public interface ApplicationContext {
Object getBean(Class clazz);
}
2.2.5 编写注解bean容器接口实现
AnnotationApplicationContext基于注解扫描bean
package com.atguigu.spring.core;
import java.util.HashMap;
public class AnnotationApplicationContext implements ApplicationContext {
//存储bean的容器
private HashMap<Class, Object> beanFactory = new HashMap<>();
//返回bean对象
@Override
public Object getBean(Class clazz) {
return beanFactory.get(clazz);
}
/**
* 根据包扫描加载bean
* 创建有参构造,传递包路径,设置包扫描规则;
* 当前包及其子包,哪个类有@Bean注解,把这个类通过反射实例化
* @param basePackage
*/
public AnnotationApplicationContext(String basePackage) {
}
}
2.2.6 编写扫描bean逻辑
我们通过构造方法传入包的base路径,扫描被@Bean注解的java对象,完整代码如下:
- 代码逻辑如下:
- 把包路径中
.
替换成\
;- 获取包绝对路径;
- 获取包前面路径部分,字符串截取;
- 包扫描过程,实例化;
- 包扫描过程,代码逻辑如下:
- 判断当前是否文件夹;
- 获取文件夹里面所有内容;
- 判断文件夹里面为空,直接返回;
- 如果文件夹里面不为空,遍历文件夹所有内容;
4.1 遍历得到每个File对象,继续判断,如果还是文件夹,递归;
4.2 遍历得到File对象不是文件夹,是文件;
4.3 得到包路径+类名称部分,字符串截取;
4.4 判断当前文件类型是否.class
;
4.5 如果是.class
类型,把路径\
替换成.
,把.class
去掉,例如:com.atguigu.service.UserServiceImpl
4.6 判断类上面是否有注解@Bean,如果有,实例化过程;
4.6.1 获取类的Class;
4.6.2 判断不是接口;
4.6.3 判断类上面是否有注解@bean;
4.6.4 实例化
4.7 把对象实例化之后,放到map集合beanFactory;
4.7.1 判断当前类如果有接口,让接口class作为map的key;
4.7.2 判断当前类如果没有接口,让类自己的class作为map的key;
package com.atguigu.spring.core;
import com.atguigu.spring.core.annotation.Bean;
import java.io.File;
import java.util.HashMap;
public class AnnotationApplicationContext implements ApplicationContext {
//存储bean的容器
private HashMap<Class, Object> beanFactory = new HashMap<>();
private static String rootPath;
@Override
public Object getBean(Class clazz) {
return beanFactory.get(clazz);
}
/**
* 根据包扫描加载bean
* @param basePackage
*/
public AnnotationApplicationContext(String basePackage) {
try {
// 1.把包路径中`.`替换成`\`
String packageDirName = basePackage.replaceAll("\\.", "\\\\");
// 2.获取包绝对路径;
Enumeration<URL> dirs =Thread.currentThread().getContextClassLoader().getResources(packageDirName);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String filePath = URLDecoder.decode(url.getFile(),"utf-8");
// 3.获取包前面路径部分,字符串截取
rootPath = filePath.substring(0, filePath.length()-packageDirName.length());
// 4.包扫描
loadBean(new File(filePath));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
// 4.包扫描过程,实例化
private void loadBean(File fileParent) {
// 1.判断当前是否文件夹;
if (fileParent.isDirectory()) {
// 2.获取文件夹里面所有内容
File[] childrenFiles = fileParent.listFiles();
// 3.判断文件夹里面为空,直接返回;
if(childrenFiles == null || childrenFiles.length == 0){
return;
}
// 4.如果文件夹里面不为空,遍历文件夹所有内容;
for (File child : childrenFiles) {
if (child.isDirectory()) {
// 4.1.遍历得到每个File对象,继续判断,如果还是文件夹,递归;
loadBean(child);
} else {
// 4.2 遍历得到File对象不是文件夹,是文件;
// 4.3 得到包路径+类名称部分,字符串截取;
String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
// 4.4 判断当前文件类型是否.class
if (pathWithClass.contains(".class")) {
// 4.5 如果是.class类型,把路径\替换成.,把.class去掉
// com.atguigu.service.UserServiceImpl
String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
try {
// 4.6 判断类上面是否有注解@Bean,如果有,实例化过程
// 4.6.1 获取类的Class;
Class<?> aClass = Class.forName(fullName);
// 4.6.2 判断不是接口;
if(!aClass.isInterface()){
// 4.6.3 判断类上面是否有注解@bean;
Bean annotation = aClass.getAnnotation(Bean.class);
if(annotation != null){
// 4.6.4 实例化
Object instance = aClass.newInstance();
//判断一下有没有接口
if(aClass.getInterfaces().length > 0) {
//如果有接口把接口的class当成key,实例对象当成value
System.out.println("正在加载【"+ aClass.getInterfaces()[0] +"】,实例对象是:" + instance.getClass().getName());
beanFactory.put(aClass.getInterfaces()[0], instance);
}else{
//如果没有接口把自己的class当成key,实例对象当成value
System.out.println("正在加载【"+ aClass.getName() +"】,实例对象是:" + instance.getClass().getName());
beanFactory.put(aClass, instance);
}
}
}
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
e.printStackTrace();
}
}
}
}
}
}
}
2.2.7 java类标识Bean注解
@Bean
public class UserServiceImpl implements UserService
@Bean
public class UserDaoImpl implements UserDao
2.2.8 测试Bean加载
package com.atguigu.spring;
import com.atguigu.spring.core.AnnotationApplicationContext;
import com.atguigu.spring.core.ApplicationContext;
import com.atguigu.spring.test.service.UserService;
import org.junit.jupiter.api.Test;
public class SpringIocTest {
@Test
public void testIoc() {
ApplicationContext applicationContext = new AnnotationApplicationContext("com.atguigu.spring.test");
UserService userService = (UserService)applicationContext.getBean(UserService.class);
userService.out();
System.out.println("run success");
}
}
控制台打印测试
2.3 依赖注入
只要userDao.print();调用成功,说明就注入成功
package com.atguigu.spring.test.service.impl;
import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.core.annotation.Di;
import com.atguigu.spring.dao.UserDao;
import com.atguigu.spring.service.UserService;
@Bean
public class UserServiceImpl implements UserService {
@Di
private UserDao userDao;
@Override
public void out() {
userDao.print();
System.out.println("Service层执行结束");
}
}
执行第八步:报错了,说明当前userDao是个空对象
2.3.1 依赖注入实现
@Di注解实现步骤:
- 遍历beanFactory的map集合;
- 获取map集合每个对象(value),每个对象属性获取到;
- 遍历得到每个对象属性数组,得到每个属性;
- 判断属性上面是否有@Di注解;
- 如果有@DI注解,把对象进行设置(注入)。
package com.atguigu.spring.core;
import com.atguigu.spring.core.annotation.Bean;
import com.atguigu.spring.core.annotation.Di;
import java.io.File;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class AnnotationApplicationContext implements ApplicationContext {
//存储bean的容器
private HashMap<Class, Object> beanFactory = new HashMap<>();
private static String rootPath;
@Override
public Object getBean(Class clazz) {
return beanFactory.get(clazz);
}
/**
* 根据包扫描加载bean
* @param basePackage
*/
public AnnotationApplicationContext(String basePackage) {
try {
String packageDirName = basePackage.replaceAll("\\.", "\\\\");
Enumeration<URL> dirs =Thread.currentThread().getContextClassLoader().getResources(packageDirName);
while (dirs.hasMoreElements()) {
URL url = dirs.nextElement();
String filePath = URLDecoder.decode(url.getFile(),"utf-8");
rootPath = filePath.substring(0, filePath.length()-packageDirName.length());
loadBean(new File(filePath));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
//依赖注入
loadDi();
}
private void loadBean(File fileParent) {
if (fileParent.isDirectory()) {
File[] childrenFiles = fileParent.listFiles();
if(childrenFiles == null || childrenFiles.length == 0){
return;
}
for (File child : childrenFiles) {
if (child.isDirectory()) {
//如果是个文件夹就继续调用该方法,使用了递归
loadBean(child);
} else {
//通过文件路径转变成全类名,第一步把绝对路径部分去掉
String pathWithClass = child.getAbsolutePath().substring(rootPath.length() - 1);
//选中class文件
if (pathWithClass.contains(".class")) {
// com.xinzhi.dao.UserDao
//去掉.class后缀,并且把 \ 替换成 .
String fullName = pathWithClass.replaceAll("\\\\", ".").replace(".class", "");
try {
Class<?> aClass = Class.forName(fullName);
//把非接口的类实例化放在map中
if(!aClass.isInterface()){
Bean annotation = aClass.getAnnotation(Bean.class);
if(annotation != null){
Object instance = aClass.newInstance();
//判断一下有没有接口
if(aClass.getInterfaces().length > 0) {
//如果有接口把接口的class当成key,实例对象当成value
System.out.println("正在加载【"+ aClass.getInterfaces()[0] +"】,实例对象是:" + instance.getClass().getName());
beanFactory.put(aClass.getInterfaces()[0], instance);
}else{
//如果有接口把自己的class当成key,实例对象当成value
System.out.println("正在加载【"+ aClass.getName() +"】,实例对象是:" + instance.getClass().getName());
beanFactory.put(aClass, instance);
}
}
}
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
e.printStackTrace();
}
}
}
}
}
}
private void loadDi() {
// 1.遍历beanFactory的map集合;
for(Map.Entry<Class,Object> entry : beanFactory.entrySet()){
// 2.获取map集合每个对象(value),每个对象属性获取到;
Object obj = entry.getValue();
// 获取对象Class
Class<?> aClass = obj.getClass();
// 获取每个对象属性
Field[] declaredFields = aClass.getDeclaredFields();
// 3.遍历得到每个对象属性数组,得到每个属性;
for (Field field : declaredFields){
// 4.判断属性上面是否有@DI注解;
Di annotation = field.getAnnotation(Di.class);
if( annotation != null ){
// 如果私有属性,设置可以设置值
field.setAccessible(true);
try {
// 5.如果有@Di注解,把对象进行设置(注入)
System.out.println("正在给【"+obj.getClass().getName()+"】属性【" + field.getName() + "】注入值【"+ beanFactory.get(field.getType()).getClass().getName() +"】");
field.set(obj,beanFactory.get(field.getType()));
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}
}
执行第八步:执行成功,依赖注入成功。