spring源码初体验01 从对象到bean的生命历程

首先我们创建context容器 然后进行测试

/**
 * @Author: xzc
 * @Date: 2021/8/20 23:50
 * @Version 1.0
 */
public class XzcSpringBeanLearnMain {

	public static void main(String[] args) {
		/**
		 * userService.class -> 推断构造（默认无参构造方法 有参构造方法会去ioc里根据类型 名字 拿入参 没有报错） -> 对象 -> 依赖注入（属性赋值）-> 初始化前(@PostConstruct) -> 初始化（实现InitializingBean接口） ->初始化后(aop->代理对象) -> baen
		 * note 有参构造方法赋值的成员 在后面的依赖注入这些流程中同成员变量会被覆盖
		 */
		ApplicationContext context=new AnnotationConfigApplicationContext(AppConfig.class);
		UserService userService = context.getBean(UserService.class);
		userService.test();
		userService.orderService.test();

	}
}

context容器需要传入配置类去配置扫描包路径 这些好扫描bean

@ComponentScan("com.xzc.sourcelearn.basebeanlife")
@EnableTransactionManagement
@Configuration
public class AppConfig {
	
	@Bean
	public OrderService orderService6(){
		System.out.println("ioc input orderService2");
		return new OrderService(6);
	}

	@Bean
	public OrderService orderService1(){
		System.out.println("ioc input orderService1");
		return new OrderService(1);
	}
//...............
}

我们需要创建我们做实验的类userService

/**
 * @Author: xzc
 * @Date: 2021/9/2 23:56
 * @Version 1.0
 */
@Component
public class UserService implements InitializingBean {

	@Autowired
	OrderService orderService;


	/**
	 * 原始方式一 依赖注入
	 */
//	@Autowired
	User loginUser;


	/**
	 * 原始方式0 推断构造  默认无参
	 */
//	public UserService(OrderService orderService, User loginUser) {
//		System.out.println("1");
//		this.orderService = orderService;
//		this.loginUser = loginUser;
//	}

	public UserService(OrderService orderService6) {
		System.out.println(" 有参构造 自定义 order2 "+orderService6.order);
		this.orderService = orderService6;
	}

//	public UserService() {
//		System.out.println("123");
//	}

	/**
	 * 方法二  初始化前
	 */
	@PostConstruct
	public void redefindUser(){
		this.loginUser = new User();
//		this.loginUser.setName("xzc");
		this.orderService = new OrderService(3);
		System.out.println("redefindUser 自定义 order user "+orderService.order);
	}

	public void test(){
		System.out.println("UserService test 哈哈哈  orderService" +orderService);
		orderService.test();
	}

	/**
	 * 方法三: 初始化 实现InitializingBean接口 afterPropertiesSet 详细看源码注解
	 */
	@Override
	public void afterPropertiesSet() throws Exception {
		this.loginUser = new User();
		this.orderService = new OrderService(3);
		System.out.println("afterPropertiesSet 自定义 order user " +orderService.order);
	}

	public void setOrderService(OrderService orderService) {
		this.orderService = orderService;
	}
}

userService里面包含我们的orderService

@Component
public class OrderService {
	Integer order = 0;

	public OrderService(Integer order) {
		this.order = order;
	}

	public OrderService() {
	}

	public void test(){
		System.out.println("OrderService test 哈哈哈  "+order);
	}
}

debug看过程

 我们写一个动态代理类

@Component
@Aspect
public class XzcAspect {

	@Before("execution(public void com.xzc.sourcelearn.basebeanlife.UserService.test())")
	public void xzcBefore(JoinPoint joinPoint) {
		UserService target = (UserService)joinPoint.getTarget();
		target.setOrderService(new OrderService(99));
		System.out.println("xzcBefore");
	}
}

判断当前Bean对象需不需要进行AOP流程:

1. 找出所有的切面Bean

2. 遍历切面中的每个方法，看是否写了@Before、@After等注解

3. 如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配

4. 如果匹配则表示当前Bean对象有匹配的的Pointcut，表示需要进行AOP

利用cglib进行AOP的大致流程：

1. 生成代理类UserServiceProxy，代理类继承UserService

2. 代理类中重写了父类的方法，比如UserService中的test()方法

3. 代理类中还会有一个target属性，该属性的值为被代理对象（也就是通过 UserService类推断构造方法实例化出来的对象，进行了依赖注入、初始化等步骤的 对象）

4. 代理类中的test()方法被执行时的逻辑如下： a. 执行切面逻辑（@Before） b. 调用target.test() 当我们从Spring容器得到UserService的Bean对象时，拿到的就是UserServiceProxy所生 成的对象，也就是代理对象。 UserService代理对象.test()--->执行切面逻辑--->target.test()，

注意target对象不是代理 对象，而是被代理对象。

运行中的结果

 结论

userService.class -> 推断构造（默认无参构造方法 有参构造方法会去ioc里根据类型 名字 拿入参 没有报错） -> 对象 -> 依赖注入（属性赋值）-> 初始化前(@PostConstruct) -> 初始化（实现InitializingBean接口） ->初始化后(aop->代理对象) -> baen

需要注意的是覆盖关系对象内的同一成员变量 后面的流程会覆盖前面的