Spring的IOC实现原理
什么是SpringIOC
spring ioc指的是控制反转，IOC容器负责实例化、定位、配置应⽤程序中的对象及建⽴这些对象间的依赖。交由Spring容器统⼀进⾏管理，从⽽实现松耦合
“控制反转”，不是什么技术，⽽是⼀种设计思想。
在Java开发中，Ioc意味着将你设计好的对象交给容器控制，⽽不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些⽅⾯反转了”，那我们来深⼊分析⼀下：
●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进⾏创建对象，是程序主动去创建依赖对象；⽽IoC是有专门⼀个容器来创建这些对象，即由Ioc容器来控制对象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括⽐如⽂件等）。
●为何是反转，哪些⽅⾯反转了：有反转就有正转，传统应⽤程序是由我们⾃⼰在对象中主动控制去直接获取依赖对象，也就是正转；⽽反转则是由容器来帮忙创建及注⼊依赖对象；为何是反转？因为由容器
帮我们查及注⼊依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些⽅⾯反转了？依赖对象的获取被反转了。
IOC实现原理
使⽤反射机制+XML技术
理解了这些基本概念后，我们通过⼀个简单的⽰意图来简单描述⼀下整个流程，
从⽰意图可以看出，当web容器启动的时候，spring的全局bean的管理器会去xml配置⽂件中扫描的包下⾯获取到所有的类，并根据你使⽤的注解，进⾏对应的封装，封装到全局的bean容器中进⾏管理，⼀旦容器初始化完毕，beanID以及bean实例化的类对象信息就全部存在了，现在我们需要在某个service⾥⾯调⽤另⼀个bean的某个⽅法的时候，我们只需要依赖注⼊进来另⼀个bean的Id即可，调⽤的时
候，spring会去初始化完成的bean容器中获取即可，如果存在就把依赖的bean的类的实例化对象返回给你，你就可以调⽤依赖的bean的相关⽅法或属性等；
下⾯通过实例代码来模拟⼀下整个IOC的原理和执⾏流程，
1、demo结构如下，
2、pom依赖⽂件，这⾥只需要spring的基本依赖即可，
<properties>
<spring.version>5.1.2.RELEASE</spring.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
&porting.outputEncoding>UTF-8</porting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
</dependencies>
3、⾸先我们⾃定义两个注解，我们知道在业务类中经常使⽤ @Service来标记这个类是bean管理的类，⽽@Autowired或者@Resource⽤于bean之间相互依赖使⽤，
// ⾃定义注解 service 注⼊bean容器
@Target({ ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
public @interface SelfService {
}
//模拟@Autowired注解
@Target({ TYPE, FIELD, METHOD })
@Retention(RUNTIME)
public @interface SelfAutowired {
}
4、模拟spring的bean容器类，想必使⽤过spring框架在进⾏整合测试的时候，都使⽤到下⾯这段代码，这段代码的作⽤其实就是模拟在spring启动加载的时候，通过这个类去初始化⼀个bean 的容器管理类，所有的bean的信息解析和保存都会在这个类⾥⾯进⾏，下⾯我们写⼀个这样的类来还原⼀下这个过程，
SelfPathXmlApplicationContext app = new SelfPathXmlApplicationContext("service.impl");
1
⾃定义spring的bean容器类，
/**
⾃定义bean管理器
@author asus
*/
public class SelfPathXmlApplicationContext {
private String packageName;
// 封装所有的bean容器
private ConcurrentHashMap<String, Object> beans = null;
/**
* 该类被创建出来的时候加载
* @param packageName
* @throws Exception
*/
public SelfPathXmlApplicationContext(String packageName) throws Exception {
beans = new ConcurrentHashMap<String, Object>();
this.packageName = packageName;
initBeans();
initEntryField();
}
/**
* 初始化bean的实例对象的所有属性
* @throws Exception
*/
private void initEntryField() throws Exception {
// 1.遍历所有的bean容器对象
for (Entry<String, Object> entry : Set()) {
// 2.判断属性上⾯是否有加注解
Object bean = Value();
attriAssign(bean);
}
}
/**
* 根据beanId获取bean名称
* @param beanId
* @return
* @throws Exception
*/
public Object getBean(String beanId) throws Exception {
if (StringUtils.isEmpty(beanId)) {
throw new Exception("beanId参数不能为空");
}
// 1.从spring容器获取bean
Object object = (beanId);
/
/ attriAssign(object);
return object;
}
/**
resource和autowired注解的区别* 获取扫描包下⾯的所有bean
*/
private void initBeans() throws Exception {
// 1.使⽤java的反射机制扫包,[获取当前包下所有的类]
List<Class<?>> classes = Classes(packageName);
// 2、判断类上⾯是否存在注⼊的bean的注解
ConcurrentHashMap<String, Object> classExisAnnotation = findClassExisAnnotation(classes);
if (classExisAnnotation == null || classExisAnnotation.isEmpty()) {
throw new Exception("该包下没有任何类加上注解");
}
}
/**
* 判断类上是否存在注⼊⾃定义的bean的注解
* @param classes
* @return
* @throws Exception
*/
public ConcurrentHashMap<String, Object> findClassExisAnnotation(List<Class<?>> classes) throws Exception { for (Class<?> classInfo : classes) {
// 判断类上是否有注解 [获取⾃定义的service注解]
SelfService annotation = Annotation(SelfService.class);
if (annotation != null) {
// 获取当前类的类名
String className = SimpleName();
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()).LowerCase(s.charAt(0))).append(s.substring(1)).toString();
}
/**
* 通过class名称获取类的实例化对象
* @param classInfo
* @return
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public Object newInstance(Class<?> classInfo)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
wInstance();
}
/**
* 依赖注⼊注解原理
* @param object
* @throws Exception
*/
public void attriAssign(Object object) throws Exception {
// 1.使⽤反射机制，获取当前类的所有属性
Class<? extends Object> classInfo = Class();
Field[] declaredFields = DeclaredFields();
// 2.判断当前类属性是否存在注解
for (Field field : declaredFields) {
SelfAutowired extResource = Annotation(SelfAutowired.class);
if (extResource != null) {
/
/ 获取属性名称
String beanId = Name();
Object bean = getBean(beanId);
if (bean != null) {
// 3.默认使⽤属性名称，查bean容器对象 1参数当前对象 2参数给属性赋值
field.setAccessible(true); // 允许访问私有属性
field.set(object, bean);
}
}
}
}
}
当这个类被初始化的时候，通过构造函数⾥⾯的两个⽅法，通过外部传⼊指定的包名，解析该包下⾯的所有类和相关注解，其实现原理主要是使⽤了反射，
通过⼀个⼯具类获取到了所有的类的实例化集合后，我们对这个集合进⾏遍历，具体的执⾏⽅法可以看findClassExisAnnotation 这个⽅法，
在findClassExisAnnotation这个⽅法⾥⾯，可以看到，我们使⽤⾃定义的注解去到这个实例类对象去匹配，如果匹配到了相应的注解，就把这个bean封装到全局的集合中，这⾥使⽤了concurrentHashMap进⾏封装，
这⼀步完成之后，包含了⾃定义注解[@Service]的相关类对象就存在了内存集合中了，如果在web容器启动完毕之后，使⽤⾃⼰的bean的时候就可以直接通过getBean这个⽅法去容器⾥⾯直接获取就可以了，通过这个⽅法就可以拿到当前beanId对应的类的实例化对象，可以使⽤⾥⾯的相关⽅法，
但是到这⾥并没有完事啊，假如在我们某个标注了@Service的类⾥⾯有下⾯这样的注解，即依赖了其他的某个bean,⽐如，在我们的userService类⾥⾯依赖了orderService，就形成了所谓的依赖注⼊，
同样，依赖注⼊也是通过上⾯相同的⽅式，在initBean()⽅法结束之后⽴即执⾏，我们来看看这个⽅法，
在initEntryField（）这个⽅法⾥，要做的事情就是遍历上述初始化好的所有bean，然后再去每个bean的实例对象中解析并封装属性相关的对应信息，下⾯看⼀下initEntryField（）这个⽅法，
通过这个⽅法，就可以将某个bean中依赖的其他bean信息进⾏封装，
/**
* 依赖注⼊注解实现原理
* @param object
* @throws Exception
*/
public void attriAssign(Object object) throws Exception {
// 1.使⽤反射机制，获取当前类的所有属性
Class<? extends Object> classInfo = Class();
Field[] declaredFields = DeclaredFields();

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。