Spirng 痛苦源码学习（一）——总起spring（一）

最新推荐文章于 2024-09-10 17:22:42 发布
最新推荐文章于 2024-09-10 17:22:42 发布
阅读量317 收藏 1
点赞数 1
分类专栏： Spring 文章标签： 学习 spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46643875/article/details/128058350
版权

文章目录

前言

对于spring来说最重要的两个特性就是老生常谈的IOC和AOP，这两个大哥先放一放。那我就先其中的一个重要小零件Bean来说，来看看spring是对Bean进行多牛逼的管理

一、总览Spring的bean

1）bean的过程【先了解具体的生命周期后面弄】

=》1、Spring底层会调用类的构造方法来完成对象创建
（这里先不管他是怎么拿到构造方法的，反正就是拿构造方法，默认是无参构造器。这里其实有一个推断构造方法的过程）

1 稍微解释一下构造方法推断

多个构造方法，直接报错（没有构造器被找到）
在这里插入图片描述

解决方法在你需要的构造器上加上@Autowired指定spring用；因为spring比较笨所以你要教他做事

2 Spring的设计思想是这样的：
  1. 如果一个类只有一个构造方法，那么没得选择，只能用这个构造方法
  2. 如果一个类存在多个构造方法，Spring不知道如何选择，就会看是否有无参的构
    造方法，因为无参构造方法本身表示了一种默认的意义
  3. 不过如果某个构造方法上加了@Autowired注解，那就表示程序员告诉Spring就
    用这个加了注解的方法，那Spring就会用这个加了@Autowired注解构造方法了
    需要重视的是，如果Spring选择了一个有参的构造方法，Spring在调用这个有参构造方法
    时，需要传入参数，那这个参数是怎么来的呢？
    Spring会根据入参的类型和入参的名字去Spring中找Bean对象（以单例Bean为例，
    Spring会从单例池那个Map中去找）：
  4. 先根据入参类型找，如果只找到一个，那就直接用来作为入参
  5. 如果根据类型找到多个，则再根据入参名字来确定唯一一个
  6. 最终如果没有找到，则会报错，无法创建当前Bean对象
    确定用哪个构造方法，确定入参的Bean对象，这个过程就叫做推断构造方法。

=》 2、对象依赖注入（属性赋值）

=》 3、初始化前 （）

=》 4、初始化

=》 5、初始化后（AOP）

=》 5.1 代理对象【只有当有AOP织入的时候，才会产生代理对象】

=》 6、bean

注：从源码的大的角度出发，就是先读取配置=》生成bean的定义信息（放到一个map里）=》按照bean的定义信息生成bean（也放到map里，要用的时候自取）

spring架构原理
在这里插入图片描述

2）hello spring 简单bean操作

  • 1、通过注解的方式

// 扫描该包下的所有组件

@ComponentScan("com.xusj")
public class AppConfig {

}

// 组件一、二如下

package com.xusj.future.service;

import org.springframework.stereotype.Service;

/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:59
 */
@Service
public class DogService {
}

// 这里有一个点值得我们在以后业务需求中可以使用，当项目一启动你要给对应的bean属性赋值，implements InitializingBean 重写afterPropertiesSet，在初始化bean的时候就直接赋值了

package com.xusj.future.service;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:58
 */
@Service
public class PeopleService implements InitializingBean {
	@Autowired
	private DogService dogService;

	private String initStr;


	public void testMethod() {
		System.out.println("111");
	}
	
	// 这里就是你想在bean创建的时候给他赋值implements InitializingBean
	@Override
	public void afterPropertiesSet() throws Exception {
		initStr = "直接在bean初始化的时候就创建了";
		System.out.println("在创建bean的时候自动和初始化一些值");
	}
}

// main 函数直接getBean

package com.xusj.future;

import com.xusj.future.bean.Person;
import com.xusj.future.config.AppConfig;
import com.xusj.future.service.PeopleService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author xusj
 * <br>CreateDate 2022/5/9 22:15
 */
public class MainTest {
	public static void main(String[] args) {
	// xml方式
//		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean1.xml");
//		Person bean = classPathXmlApplicationContext.getBean(Person.class);
//		System.out.println(bean);
	// 注释方式
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		PeopleService peopleService = (PeopleService) context.getBean("peopleService");
		peopleService.testMethod();

	}
}
  • 2、对于以上的一些代码我们放如下问题【希望学完，我自己能解决】
  1. 第一行代码，会构造一个ClassPathXmlApplicationContext对象，
    ClassPathXmlApplicationContext该如何理解，调用该构造方法除开会实例化得到
    一个对象，还会做哪些事情？
  2. 第二行代码，会调用ClassPathXmlApplicationContext的getBean方法，会得到
    一个UserService对象，getBean()是如何实现的？返回的UserService对象和我们自
    己直接new的UserService对象有区别吗？
  3. 第三行代码，就是简单的调用bean的test()方法，不难理解。

二、总览AOP

- 1、test coding

package com.xusj.future.aspect;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**
 * 切面bean 交给ioc管理
 *
 * @author xusj
 * <br>CreateDate 2022/11/27 0:31
 */
@Aspect // 切面
@Component // 切面也是一个bean
public class TestAspect {


	@Pointcut("execution(public void com.xusj.future.service.PeopleService.testMethod())")
	public void mypoint() {
		//切面定义
	}

	@Before("mypoint()")
	public void doAround() {
		System.out.println("before logic");
	}

}


package com.xusj.future.service;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:58
 */
@Service
public class PeopleService implements InitializingBean {
	@Autowired
	private DogService dogService;

	private String initStr;

	// 构造 二

//	public PeopleService(String initStr) {
//		this.initStr = initStr;
//	}
//	// 构造一
//	@Autowired
//	public PeopleService(DogService dogService) {
//		this.dogService = dogService;
//	}

	public void testMethod() {
		System.out.println("111");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		initStr = "直接在bean初始化的时候就创建了";
		System.out.println("在创建bean的时候自动和初始化一些值");
	}
}

// 这里很重要开启AOP代理

package com.xusj.future.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:58
 */
@ComponentScan("com.xusj")
@EnableAspectJAutoProxy // 开启Aop代理
public class AppConfig {
//	@Bean
//	public PeopleService getPeople() {
//		return new PeopleService();
//	}
}

// 启动类

package com.xusj.future;

import com.xusj.future.config.AppConfig;
import com.xusj.future.service.PeopleService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author xusj
 * <br>CreateDate 2022/5/9 22:15
 */

public class MainTest {
	public static void main(String[] args) {
//		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean1.xml");
//		Person bean = classPathXmlApplicationContext.getBean(Person.class);
//		System.out.println(bean);
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		PeopleService peopleService = (PeopleService) context.getBean("peopleService");
		peopleService.testMethod();

	}
}

- 2、- debug

  1. 在有AOP的情况下，我们getBean拿到是cglib的代理对象，代理对象是怎么调普通对象的方法的
    在这里插入图片描述

  2. 先走前置通知在这里插入图片描述

  3. 当正在去调用方法的时候，并不是通过代理对象去调的，而是原普通对象来弄的
    在这里插入图片描述

- 3、- 总结debug

// 对于cglib代理来说，就是代理对象去继承被代理对象；为代码如下，这样代理对象就能使用bean中的方法和属性了【代理对象里面是没有值的】

public A extends B{
	// spring 中
	private B b;
	
	// 这是继承父类的方法
	public void test(){
		// 怎么去调用父类的方法
		// 1、直接去super.test
		// 2、将B做为属性干到代理类中，spring是这么干的
		b.test();
	}
}

在这里插入图片描述
对于代理对象来说，以AOP为例子，我们只关注切到对应的方法上面，我们对被代理对象中的属性没有太大关注，所以代理对象是没有值得。

Object target = joinPoint.getTarget();这个完全可以拿到被代理得对象

@Aspect // 切面
@Component // 切面也是一个bean
public class TestAspect {


	@Pointcut("execution(public void com.xusj.future.service.PeopleService.testMethod())")
	public void mypoint() {
		//切面定义
	}

	@Before("mypoint()")
	public void doAround(JoinPoint joinPoint) {
		// 拿到得是普通对象（被代理对象得值，我们就可以通过这个去得到其中得属性）
		Object target = joinPoint.getTarget();
		System.out.println("before logic");
	}

}

三、总览事务

- 1、- test coding

// 拿到数据库连接，然后给到事务管理器和jdbc进行操作

/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:58
 */
@ComponentScan("com.xusj")
@EnableAspectJAutoProxy // 开启Aop代理
@EnableTransactionManagement // 开启事务
@Configuration
public class AppConfig {
//	@Bean
//	public PeopleService getPeople() {
//		return new PeopleService();
//	}

	// 拿jdbc
	@Bean
	public JdbcTemplate jdbcTemplate() {
		// 将连接交给他
		return new JdbcTemplate(dataSource());
	}
	// 创建数据库连接
	@Bean
	public DataSource dataSource() {
		DriverManagerDataSource dataSource = new DriverManagerDataSource();
		dataSource.setUrl("jdbc:mysql://localhost:3306/study?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai&useInformationSchema=true");
		dataSource.setUsername("root");
		dataSource.setPassword("root");
		return dataSource;
	}
	// 交给事务管理
	@Bean
	public PlatformTransactionManager transactionManager(){
		DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
		dataSourceTransactionManager.setDataSource(dataSource());
		return dataSourceTransactionManager;
	}
}

// 添加注解


/**
 * @author xusj
 * <br>CreateDate 2022/11/26 22:58
 */
@Service
public class PeopleService implements InitializingBean {
	@Autowired
	private DogService dogService;



	@Autowired
	private JdbcTemplate jdbcTemplate;


	@Transactional// 事务注解
	public void execute() {
		jdbcTemplate.execute("insert student values (3,s,1)");
		System.out.println("zhix ");
		throw new NullPointerException();
	}

}

// 主方法调用

/**
 * @author xusj
 * <br>CreateDate 2022/5/9 22:15
 */

public class MainTest {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		PeopleService peopleService = (PeopleService) context.getBean("peopleService");

		peopleService.execute();

	}
}

- 2、 debugging

这里也是用过代理对象完成事务的，流程如下，类似aop的代理，里面逻辑不一样

public A extends B{
	// spring 中
	private B b;
	
	// 这是继承父类的方法
	public void test(){
		// 1先判断有没有@Transactional这个注解
		// 2有的话，将conn置为false（默认是true自动提交，这里将他置为手动提交）
		b.执行sql();
		// 3没有异常直接commit
		// 4有异常rollback
	}
}

- 3、 事务失效

  • 一个经典的事务失效（方法里面调用方法，事务失效）
  1. 由上面分析代理对象我们可以知道，只有当代理对象去调用方法的时候，事务ok
  2. 但是你在方法中调用方法的时候，一开始第一个方法你是代理对象调用过来的，但是后面第二个方法是普通对象搞来的，那么就失效了
@Transactional// 事务注解
	public void execute() {
		jdbcTemplate.execute("insert student values (3,s,1)");
		System.out.println("zhix ");
		a();
	}

	public void a() {
		jdbcTemplate.execute("insert student values (3,s,1)");
		System.out.println("zhix ");
		throw new NullPointerException();
	}

// 解决方法,我们可以注入自己，然后调用方法，这样的话，我们在ioc拿出来的都是一个代理对象，所以就解决了

@Autowired
	private PeopleService peopleService;
	@Transactional// 事务注解
	public void execute() {
		jdbcTemplate.execute("insert student values (3,s,1)");
		System.out.println("zhix ");
		peopleService.execute();;
//		a();
	}

- 4、事务总结

Spring事务的代理对象执行某个方法时的步骤：

  1. 判断当前执行的方法是否存在@Transactional注解
  2. 如果存在，则利用事务管理器（TransactionMananger）新建一个数据库连接
  3. 修改数据库连接的autocommit为false
  4. 执行target.test()，执行程序员所写的业务逻辑代码，也就是执行sql
  5. 执行完了之后如果没有出现异常，则提交，否则回滚
    Spring事务是否会失效的判断标准：某个加了@Transactional注解的方法被调用时，要判断到底是不是直接被代理对象调用的，如果是则事务会生效，如果不是则失效。
甲乙Rocket
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码学习（一）——准备工作
G_luomo的博客
03-20 667
spring源码学习（一）准备工作 以下步骤皆基于Windows，Mac和Linux只做参考 一、下载Spring源码 Spring Github源码下载地址 目前最新5.3.17版本 下载好后解压到相应目录 二、下载Gradle 如果对于自己的网速比较信任可以跳过此步骤 从spring源码中找到当前Spring依赖的gradle管理版本 \spring-framework-5.3.17\gradle\wrapper\gradle-wrapper.properties Gradle 下载地址 下载
Spring源码私家笔记——Spring启动流程概述
fuhua_chou的博客
05-03 583
在分析Spring源码之前，很容易陷入的一个误区就是，debugger一路点进去，然后迷失在茫茫的源码之中。 其实分析源码跟我们做系统开发一样，不会上来就开始撸代码，而是先做好系统的设计，然后才开始分工合作。正所谓“胸中有大纲，心中不慌张”，无论我们debugger到了何处，想想我们在地图的何处，就可以导航回去。 ...
Spring源码学习系列——源码下载和环境
wei爱努力的博客
05-12 975
Spring源码学习目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录Spring源码学习目录前言一、Spring源码下载二、Spring源码所需环境配置1.修改setting.gradle文件2.修改gradle.properties文件3.修改build.gradle文件4.gradlew :spring-oxm:compileTestJava
Spirng 痛苦源码学习（二）——手写spring大致总框架（一）
weixin_46643875的博客
11-29 873
Spirng 痛苦源码学习（二）——手写spring大致总框架（一） 1、容器 2、前置后置处理器 3、依赖注入
Spring源码学习四——FactoryBean的作用
yx444535180的专栏
05-09 3718
一、FactoryBean 二、源码中的作用 三、使用示例 四、总结
Spring源码学习一——容器启动过程上
yx444535180的专栏
04-24 564
一、启动容器 启动一个注解配置的容器 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); 进入构造方法 AbstractApplicationContext.refresh()方法将刷新启动容器 public void refresh() throws BeansException, IllegalStateException { synchroni
小读spring ioc源码（一）——整体介绍
04-07
《Spring IOC源码解析（一）——整体介绍》 在深入理解Spring框架的过程中，源码分析是不可或缺的一环。本文将对Spring的IOC（Inversion of Control，控制反转）...希望本文能为你开启Spring源码探索之旅的第一步。
java8集合源码分析-mini-spring:手写Spring——从头实现一个小型Spring框架
06-04
但由于Spring源码体系较为庞大，且源码大部分用于处理多线程和效率优化，因此本仓库试图简化Spring的处理逻辑，以方便各编码者对源码的认知和理解，故仅对核心部分进行了实现。同时也希望能够通过源码更进一步加深...
二、Spring源码分析——BeanFactory
08-11
《Spring源码分析——BeanFactory》 在Java的IoC（Inversion of Control）和DI（Dependency Injection）领域，Spring框架扮演着至关重要的角色。BeanFactory是Spring的核心组件之一，它是容器的基石，负责管理应用...
iomuxc、pinctrl子系统、gpio子系统（学习总结）
weixin_61385844的博客
09-04 964
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
区块链学习笔记2--区块链技术的形成 以太坊
最新发布
weixin_61074128的博客
09-10 250
以太坊的定义：以太坊是运行在一个计算机网络中的软件，他确保数据以及智能合约的小程序可以在没有宗信协调者的情况下，被所有网络中的计算机复制和处理。以太坊的改进： 交易速度加快；pow+pos算法，逐步向pos算法过渡；智能合约：不受人为因素影响，没有黑幕；比特币的出现让经济贸易变得简单，而比特币系统的不足，也同样被人诟病。于是出现了致力解决比特币不足的“V神”。以太坊的愿景是创建一个无法停止，抗屏蔽（审查）和自我维持的去中心化世界计算机。比特币的不足：交易速度慢；仅仅完成了货币的去中心化。
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 836
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 547
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
Android Fragment 学习备忘
sdaujz的博客
09-08 374
1.fragment的动态添加与管理：
9.6学习记录+三场笔试
m0_62956971的博客
09-07 1153
短作业优先。
EmguCV学习笔记 C# 第10章 人脸识别
UruseiBest 的技术专栏
09-05 614
EmguCV是一个基于OpenCV的开源免费的跨平台计算机视觉库,它向C#和VB.NET开发者提供了OpenCV库的大部分功能。10.1 人脸检测 CascadeClassifier类。10.2.2.1 EigenFaceRecgnizer类。10.2.1 LBPHFaceRecgnizer类。10.2 人脸识别 FaceRecgnizer类。教程配套文件及相关说明。
《数字信号处理》学习05-单位冲击响应与系统响应
码到成龚的博客
09-08 1190
一，单位冲激响应二，LTI系统对任意序列的系统响应三，LTI系统的性质​ 在《信号与系统》中，离散时间线性时不变系统用 唯一表征： ：单位冲击响应（或称为单位抽样响应）。输入序列是单位冲击序列，输出序列是初始状态为0时系统的输出。 1，h虽然不是特定单词的缩写，但在信号处理领域的使用已经成为一种约定，代表了系统的单位冲击响应，因此，一般用来代表离散时间LTI系统的单位冲击响应。 2，之所以强调输出序列是在初始状态为0时的系统输出，是因为在“初始状态为0”时输出序列完全基于输入序列和单
Vue响应式进阶常用API学习
weixin_44072254的博客
09-06 863
reactive()的浅层浅层响应式，和reactive()不同，这里没有深层级的转换：一个浅层响应式对象里只有根级别的属性是响应式的。readonly()的浅层作用形式,只有根级别是只读不可更改的，根级别以下的可更改，只是视图不会更新，但值改变了。shallowRef是浅层引用,只会跟踪原始对象的引用,不会跟踪原始对象的属性。创建一个自定义的 ref，显式声明对其依赖追踪和更新触发的控制方式。的副作用，这通常在对浅引用的内部值进行深度变更后使用。代理对象，并返回该代理对象对应的原始对象。
【C++深入学习】日期类函数从无到有实现
Harper.Lee的博客
09-04 1312
本文主要是通过之前所学的类和对象等的知识从无到有地实现一个简单的日期计算机程序！
Spring源码深度解析：IOC容器探秘
Spring的源码解析是一次深入学习之旅，它涵盖了BeanFactory接口、ApplicationContext接口、FactoryBean、依赖注入机制以及容器的实现等多个方面。通过这样的学习，开发者不仅可以提升对Spring的理解，还能进一步提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值