实现Spring底层机制-01

主要实现：初始化IOC容器+依赖注入+BeanPostProcessor机制+AOP

前面我们实际上已经使用代码简单实现了：

Spring XML 注入 bean （Spring基本介绍02） Spring 注解方式注入 bean （Spring管理Bean-IOC-04） Spring AOP 动态代理实现 （AOP-01）

1.引出问题

1.1原生Spring如何实现依赖注入    
    
    
、singleton和prototype

例子

1.创建新的Maven项目：

2.在pom.xml文件中添加 spring 开发的基本包：

<dependencies> <!--加入 spring 开发的基本包--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.8</version> </dependency> <!--加入spring开发切面编程需要的包--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> <version>5.3.8</version> </dependency> </dependencies>

3.src/main/java/ 目录下创建包 com/li/component    
    
    
，在该包下分别创建UserDao.java   


     


     


   、UserService.java



 




 




 

、UserAction.java

UserDao：

package com.li.component; import org.springframework.stereotype.Component; /** * @author 李 * @version 1.0 */ //也可以使用 @Repository @Component public class UserDao { public void hi() { System.out.println("UserDao-hi()---"); } }

UserService：

package com.li.component; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** * @author 李 * @version 1.0 */ //也可以使用 @Service @Component public class UserService { //定义属性 //也可以使用 @Resource @Autowired private UserDao userDao; public void m1() { userDao.hi(); } }

UserAction：

package com.li.component; import org.springframework.stereotype.Component; /** * @author 李 * @version 1.0 * 一个 Controller */ //也可以使用 @Controller @Component public class UserAction { }

4.在 src/main/resources 目录下创建 spring 的容器文件 beans.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <!--配置自动扫描的包   


     


     


   ，同时引入对应的名称空间--> <!--说明： 1.如果是普通的java项目



 




 




 

，beans.xml 放在src 目录下即可 2.如果是maven项目   

   

   

，beans.xml文件就要放在 src/main/resources 目录下--> <context:component-scan base-package="com.li.component"/> </beans>

5.测试类中获取配置的bean    

     

     

  ，并输出对象的地址值

package com.li; import com.li.component.UserAction; import com.li.component.UserDao; import com.li.component.UserService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * @author 李 * @version 1.0 */ public class AppMain { public static void main(String[] args) { //测试是否可以得到spring容器中的bean ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml"); UserAction userAction = (UserAction) ioc.getBean("userAction"); UserAction userAction2 = (UserAction) ioc.getBean("userAction"); System.out.println("userAction=" + userAction); System.out.println("userAction2=" + userAction2); } }

可以看到通过“userAction    
    
    
”名称获取的对象的地址值相同




  




  




  
，这说明它们实际上是同一个对象

在默认情况下  


  


  


，我们配置的@Component     
     
     
 ，@Controller




   




   




   ，@Service
 



 



 



，@Repository 是单例的               ，即spring的ioc容器只会创建一个bean实例

6.如果我们希望将一个类配置为多例的 




    




    




    ，怎么办呢？

只需要在对应的类头部添加 @Scope(value = "prototype")















，表示以多实例的形式返回该类的bean对象

package com.li.component; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope(value = "prototype") public class UserAction { }

现在我们重新运行测试类               ，可以看到通过“userAction   


     


     


   ”名称获取的对象的地址值不相同  



     



     



    ，这说明它们是不同的对象    
    
    
。

7.我们在测试类中获取userService对象















，并调用m1方法

package com.li; import com.li.component.UserAction; import com.li.component.UserDao; import com.li.component.UserService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * @author 李 * @version 1.0 */ public class AppMain { public static void main(String[] args) { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml"); UserService userService = (UserService) ioc.getBean("userService"); System.out.println("userService=" + userService); //测试依赖注入 System.out.print("userService对象调用m1()="); userService.m1(); } }

输出如下    
    
    
，成功获取到userService对象   


     


     


   ，并且调用m1方法成功   


     


     


   。这说明UserService类中的userDao属性成功通过@AutoWired 注解装配



 




 




 

。

问题一：spring底层是如何通过注解来完成多例或者单例对象的创建的？

问题二：Spring容器如何实现依赖注入？

1.2原生Spring如何实现BeanPostProcessor

BeanPosecessor详见Spring管理Bean-IOC-03-2.16后置处理器

后置处理器会在 bean 初始化方法调用前 和 初始化方法调用后 被调用 后置处理器对象会作用在容器配置文件的所有bean对象中（即使bean对象没有初始化方法）

例子

1.创建一个后置处理器：

package com.li.process; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.stereotype.Component; /** * @author 李 * @version 1.0 * 一个后置处理器 */ @Component public class MyBeanPostProcessor implements BeanPostProcessor { //在 Bean的 init初始化方法前被调用 @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessBeforeInitialization 被调用 " + beanName + " bean= " + bean.getClass()); return bean; } //在 Bean的 init初始化方法后被调用 @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("postProcessAfterInitialization 被调用 " + beanName + " bean= " + bean.getClass()); return bean; } }

要使用后置处理器



 




 




 

，需要进行配置   

   

   

，配置的方式有两种：（1）在xml容器文件中进行配置（2）添加注解

使用注解时    

     

     

  ，还要保证扫描的范围要覆盖到该类

2.在UserService类中添加初始化方法：

package com.li.component; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; /** * @author 李 * @version 1.0 */ //也可以使用 @Service @Component public class UserService { //定义属性 //也可以使用 @Resource @Autowired private UserDao userDao; public void m1() { userDao.hi(); } //初始化方法-名称随意




  




  




  
，需要@PostConstruct指定init为初始化方法 @PostConstruct public void init(){ System.out.println("UserService-init()"); } }

3.在测试类中进行测试：

package com.li; import com.li.component.UserAction; import com.li.component.UserDao; import com.li.component.UserService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * @author 李 * @version 1.0 */ public class AppMain { public static void main(String[] args) { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml"); UserAction userAction = (UserAction) ioc.getBean("userAction"); UserAction userAction2 = (UserAction) ioc.getBean("userAction"); System.out.println("userAction=" + userAction); System.out.println("userAction2=" + userAction2); UserDao userDao = (UserDao) ioc.getBean("userDao"); System.out.println("userDao=" + userDao); UserService userService = (UserService) ioc.getBean("userService"); System.out.println("userService=" + userService); System.out.print("userService对象调用m1()="); userService.m1(); } }

如下  


  


  


，后置处理器对象会作用在容器配置文件的所有bean对象中（即使bean对象没有初始化方法）     
     
     
 ，根据之前的配置




   




   




   ，容器中一共有四个对象（UserAction为多例）
 



 



 



，因此一共调用了八次   

   

   

。

这里userAction对象因为是多例的               ，强制为懒加载 




    




    




    ，因此在被获取时（getBean()）才创建















，因此排在最后    

     

     

  。

问题三：原生Spring如何实现BeanPostProcessor？

1.3原生spring如何实现AOP

例子-在上述代码的基础上添加如下内容

1.SmartAnimal 接口：

package com.li.aop; /** * @author 李 * @version 1.0 */ public interface SmartAnimal { public float getSum(float i, float j); public float getSub(float i, float j); }

2.SmartDog 实现类：

package com.li.aop; import org.springframework.stereotype.Component; /** * @author 李 * @version 1.0 */ @Component public class SmartDog implements SmartAnimal { @Override public float getSum(float i, float j) { float res = i + j; System.out.println("SmartDog-getSum()-res=" + res); return res; } @Override public float getSub(float i, float j) { float res = i - j; System.out.println("SmartDog-getSub()-res=" + res); return res; } }

3.SmartAnimalAspect 切面类：

package com.li.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.Signature; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; import java.util.Arrays; /** * @author 李 * @version 1.0 * 切面类 */ @Component @Aspect public class SmartAnimalAspect { @Pointcut(value = "execution(public float com.li.aop.SmartAnimal.*(float,float))") public void myPointCut() { } //前置通知 @Before(value = "myPointCut()") public void before(JoinPoint joinpoint) { Signature signature = joinpoint.getSignature(); System.out.println("SmartAnimalAspect切面类-before()-" + signature.getName() + "-参数-" + Arrays.toString(joinpoint.getArgs())); } //返回通知 @AfterReturning(value = "myPointCut()", returning = "res") public void afterReturning(JoinPoint joinpoint, Object res) { Signature signature = joinpoint.getSignature(); System.out.println("SmartAnimalAspect切面类-afterReturning()-" + signature.getName() + "-res-" + res); } //异常通知 @AfterThrowing(value = "myPointCut()", throwing = "res") public void afterThrowing(JoinPoint joinpoint, Throwable res) { Signature signature = joinpoint.getSignature(); System.out.println("SmartAnimalAspect切面类-afterThrowing()-" + signature.getName() + "-res-" + res); } //最终通知 @After(value = "myPointCut()") public void after(JoinPoint joinpoint) { Signature signature = joinpoint.getSignature(); System.out.println("SmartAnimalAspect切面类-after()-" + signature.getName()); } }

4.在容器文件中开启基于注解的aop功能：

<!--配置自动扫描的包               ，同时引入对应的名称空间--> <context:component-scan base-package="com.li.aop"/> <!--开启基于注解的 aop 功能--> <aop:aspectj-autoproxy/>

5.进行测试：

package com.li; import com.li.aop.SmartAnimal; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * @author 李 * @version 1.0 */ public class AppMain { public static void main(String[] args) { ApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml"); SmartAnimal smartDogProxy = ioc.getBean(SmartAnimal.class); smartDogProxy.getSum(101, 99); } }

测试结果：

前面的输出是因为之前配置了后置处理器  



     



     



    ，它在创建ioc容器时会被调用















，对所有bean对象生效




  




  




  
。

红框处    
    
    
，后置处理器的 postProcessBeforeInitialization() 方法调用时   


     


     


   ，bean对象的还是原生的类型



 




 




 

，但是到了 postProcessAfterInitialization() 方法调用时   

   

   

，已经变成了代理对象 $Proxy  


  


  


。这说明后置处理器和aop切面编程有着密切的关系     
     
     
 。

简单分析AOP和BeanPostProcessor的关系：

1.AOP实现Spring可以通过一个类加入注解@EnableAspectJAutoProxy来执行

2.我们来追一下@EnableAspectJAutoProxy

3.看一下 AnnotationAwareAspectJAutoProxyCreator 的类图

4.解读：

（1）AOP底层是基于BeanPostProcessor机制的

（2）即在Bean对象创建好后    

     

     

  ，根据是否需要AOP处理




  




  




  
，决定返回代理对象还是原生的Bean对象

（3）在返回代理对象时  


  


  


，就可以根据要代理的类和方法来返回

（4）这个机制并不难     
     
     
 ，本质就是BeanPostProcessor 机制+动态代理技术

2.Spring整体架构分析