Spring核心原理解析

最新推荐文章于 2024-07-23 10:48:19 发布
最新推荐文章于 2024-07-23 10:48:19 发布
阅读量152 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nickel369/article/details/131506088
版权

1.Bean的生命周期底层原理

AppConfig

package com.zhouyu;

import com.zhouyu.service.OrderService;
import org.springframework.context.annotation.*;

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

	@Bean
	public OrderService orderService1(){
		return new OrderService();
	}

	@Bean
	public OrderService orderService2(){
		return new OrderService();
	}

}

OrderService

package com.zhouyu.service;

import org.springframework.stereotype.Component;

@Component
public class OrderService {

}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
说明：在spring容器中存在多个bean对象时，bean在无参构造方法中引入某个bean，更改参数名称决定具体引入那一个bean，当参数的名称在bean中不存在时，此时程序就会报错。

2.依赖注入底层原理

2.1 通过spring.xml方式进行注入

spring.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"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	   https://www.springframework.org/schema/beans/spring-beans.xsd
	   http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd"
	   >

	<context:component-scan base-package="com.zhouyu"/>



	<bean id="user1" class="com.zhouyu.service.User" scope="prototype"/>

	<bean id="user2" class="com.zhouyu.service.User" parent="user1"/>
</beans>

java获取对象

package com.zhouyu;

import com.zhouyu.service.User;
import com.zhouyu.service.UserService;
import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.springframework.aop.Pointcut;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.support.AbstractPointcutAdvisor;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import javax.annotation.PostConstruct;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {

	public static void main(String[] args) {

		ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.test();

	}
}

2.2 通过注解方式进行注入

AppConfig

package com.zhouyu;

import org.springframework.context.annotation.*;
import org.springframework.scheduling.annotation.EnableScheduling;

@ComponentScan("com.zhouyu")
@EnableScheduling
@PropertySource("classpath:spring.properties")
public class AppConfig {
	
}

java获取对象

package com.zhouyu;

import com.zhouyu.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test {

	public static void main(String[] args) {
		
		// 创建一个Spring容器
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.test();
	}
}

说明：spring通过解析appConfig.class得到扫描路径，然后遍历该路径下的含有@Component、@Service注解对象记录下来，放在一个map集合中，通过beanName作为key，当前类作为value。

3.初始化底层原理

3.1 初始化前

User对象

package com.zhouyu.service;

import org.springframework.stereotype.Component;

@Component
public class User {
	private String name;
	private String password;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
}

UserService 对象的test方法

package com.zhouyu.service;

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;

@Component
public class UserService{

    @Autowired
	private OrderService orderService;

	@Autowired
    private User admin;



	public void test(){
       System.out.println(admin.getName());
	}


	@PostConstruct
	public User getAdmin(){
		admin.setPassword("123");
		admin.setName("LiMing");
		return admin;
	}

}

在这里插入图片描述

在这里插入图片描述

说明：User对象必须加上Component注解，这样才能被Spring容器进行管理，此时在getAdmin方法中加上PostConstruct注解后，此时对admin进行赋值，才其他方法中就能获取admin赋值的对象。

3.2 初始化

package com.zhouyu.service;

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.util.Date;

@Component
public class UserService implements InitializingBean{

    @Autowired
	private OrderService orderService;

	@Autowired
	private User user;



	public void test(){
       System.out.println(user);
	}


	@Override
	public void afterPropertiesSet() throws Exception {
		user.setPassword("123");
		user.setName("LiMing");
	}
}

在这里插入图片描述

说明：初始化时，查看方法是否实现了InitializingBean接口，假如实现了该方法，将会执行afterPropertiesSet方法。

3.3 初始化后实现AOP

ZhouyuAspect.java对象

package com.zhouyu.aspect;

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

@Aspect
@Component
public class ZhouyuAspect {

	@Before("execution(public void com.zhouyu.service.UserService.test())")
	public void a(){
        System.out.println("test Before");
	}

	@After("execution(public void com.zhouyu.service.UserService.test())")
	public void b(){
		System.out.println("test After");
	}



}

test.java对象

package com.zhouyu;


import com.zhouyu.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;


import java.lang.reflect.InvocationTargetException;


public class Test {

	public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {

		// 创建一个Spring容器
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);


		UserService userService = (UserService) applicationContext.getBean("userService");
		userService.test();


	}
}

UserService.java对象

package com.zhouyu.service;

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

@Component
public class UserService implements InitializingBean{

    @Autowired
	private OrderService orderService;

	@Autowired
    private User admin;



	public void test(){
       System.out.println(admin.getName());
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		admin.setName("LiMing123");
		admin.setPassword("123");
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

说明：当引用切面后，userService将会在底层生成一个userServiceProxy代理方法，代理对象此时也有test方法，在执行test方法之前执行切面@before方法，然后执行test方法，test方法将会调用父类里面test方法，所有当进去test方法里面时，此时属性又有值了。

4.推断构造方法底层原理

存在多个构造方法，其中一个是无参构造方法
在这里插入图片描述
存在多个构造方法，无无参构造方法
在这里插入图片描述
存在多个构造方法，其中一个构造方法含有Autowired注解
在这里插入图片描述
说明：创建对象时，通过该类的构造方法进行创建对象，假如该类只有一个构造方法时候，就采用这个构造方法，假如有多个构造方法，存在无参构造方法就用无参构造方法进行构造，假如不存在无参构造方法，存在多个有参构造方法就会报错，但是存在多个有参构造方法，其中一个构造方法有@Autowired，将会采用这个构造方法。同时也会判断是否有被Autowired注解的属性，有的话也会把属性找出来并由spring进行赋值。

nickel369
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Spring源码】Spring核心原理解析
金鳞踏雨
04-06 2036
那么Spring到底是如何来创建一个Bean的呢，这个就是Bean创建的生命周期，大致过程如下：利用该类的构造方法来实例化得到一个对象（但是如何一个类中有多个构造方法，Spring则会进行选择，这个叫做推断构造方法得到一个对象后，Spring会判断该对象中是否存在被@Autowired注解了的属性，把这些属性找出来并由Spring进行赋值（依赖注入。
Spring核心容器IOC原理实例解析
08-25
Spring核心容器IOC原理实例解析 Spring核心容器是IOC容器的核心组件，负责管理Bean对象及其相互依赖关系。在Spring框架中，IOC容器是通过BeanFactory接口来定义的，这个接口提供了许多方法来管理Bean对象，例如获取...
【Spring】Spring底层核心原理解析
haohaoxuexiyai的博客
02-18 3575
本文内容索引： 1.Bean的生命周期底层原理 2.依赖注入底层原理 3.初始化底层原理 4.推断构造方法底层原理 5.AOP底层原理 6.Spring事务底层原理 ​但都只是大致流程，后续会针对每个流程详细深入的分析源码实现。 先来看看入门使用Spring的代码： ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); UserService userService = (Use
Spring 核心原理解析
w2ndong的专栏
03-07 662
作者：王奕然链接：https://www.zhihu.com/question/21346206/answer/101789659来源：知乎著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。基本原理其实就是通过反射解析类及其类的各种信息，包括构造器、方法及其参数，属性。然后将其封装成bean定义信息类、constructor信息类、method信息类、property信息类，最终...
Spring框架(一) 底层核心原理解析
刘跃辉的博客
06-13 9万+
本系列文章以spring-framework-5.3.10为例 ， 本篇文章的目的就是使各位读者能在使用Spring的基础上对Spring的一些比较核心的内容有一个大概的认识，并不是特别全面，会在后续的文章中一一讲解，不仅仅是停留在Spring简单的使用 ， 而是方便后面源码的阅读以及实现方式的理解 ， 文章仅是作者自己在学习Spring过程中的案例演示以及知识总结 ， 如果表达不当 ， 还请及时指教首先我们来看一段代码 APPConfig代码 从代码实现方式不难看出 , ClassPathXmlAppl
Spring 核心原理
tealala的博客
03-08 2660
Java Bean (java bean 是由Applet Bean演变而来) ------------> EJB（Enterprise java beans）--------->POJO(plain ordinary java Obect，简单的java bean) Spring 简化开发的四个基本策略 1、基于POJO的轻量级和最小侵入性编程 2、通过依赖注入和面向......
Spring Cloud原理详解
热门推荐
Java笔记
11-07 17万+
概述 毫无疑问，Spring Cloud是目前微服务架构领域的翘楚，无数的书籍博客都在讲解这个技术。不过大多数讲解还停留在对Spring Cloud功能使用的层面，其底层的很多原理，很多人可能并不知晓。因此本文将通过大量的手绘图，给大家谈谈Spring Cloud微服务架构的底层原理。 实际上，Spring Cloud是一个全家桶式的技术栈，包含了很多组件。本文先从其最核心的几个组件入手，来剖...
spring 核心原理
Android 系统开发
12-01 594
Spring核心原理 Spring是一个轻量级控制反转(IOC)和面向切面(AOP)的容器框架 一、spring容器的主要核心： 1.IOC（Inversion of Control）控制反转： 简单地说，由spring来负责控制对象的生命周期和对象间的关系。传统的Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IOC是有专门一个容器来创建这些对象，即由Ioc容器来控制对象的创建；就是把new对象实例化的工作交给spring容器来完成，spring.
Spring核心原理
weixin_41761540的博客
02-17 544
spring源码学习
Mybatis整合Spring核心原理
sermonlizhi的博客
11-27 1740
一、Mybatis集成Spring原理 Mybatis是一个单独的半ORM框架，可以与Spring集成使用，也可以单独使用，单独使用代码如下: 加载mybatis.xml的配置文件，然后解析配置文件，创建一个DefaultSqlSessionFactory的工厂对象，通过openSession()打开一个数据库连接的会话，通过getMapper()方法可以为对应的Mapper接口生成一个MapperProxy的代理对象，然后直接调用这个Mybatis的代理对象，就可以执行其中定义的SQL方法 InputSt
Spring Boot核心原理
Itmastergo的博客
12-12 2130
Spring Boot的目标是使Spring应用程序的开发变得更加容易和快速。它采用了“习惯优于配置”的理念，通过提供一组默认的配置，让开发者可以零配置地快速搭建项目。Spring Boot并不是一种全新的框架，而是在Spring框架的基础上构建的，它利用Spring框架的众多功能，同时通过简化配置和提供新的功能来提高开发效率。
Spring Validation方法实现原理分析
08-27
Spring Validation方法实现原理分析 Spring Validation是Spring框架中的一种校验机制，用于验证JavaBean的属性是否符合JSR-303规范。该机制可以在应用程序中自动验证JavaBean的属性，从而确保数据的正确性和完整性...
Spring事务处理原理步骤详解
08-19
事务管理器是Spring事务处理的核心组件，它负责事务的创建、提交和回滚。事务管理器可以是DataSourceTransactionManager、HibernateTransactionManager等。 DataSourceTransactionManager是最常用的事务管理器，它...
简单谈谈Spring Ioc原理解析
08-26
Spring容器在启动时解析配置文件，根据配置信息创建并初始化对象，然后在运行时根据对象的依赖关系，通过反射调用setter方法或构造器来注入依赖。例如，如果我们有一个`Animal`类需要依赖一个`Connection`对象，我们...
Spring整合Mybatis与SpringBoot整合Mybatis原理分析
04-16
**Spring整合Mybatis原理分析** 在Java Web开发中，Spring框架以其强大的依赖注入和面向切面编程能力，成为了事实上的核心框架。Mybatis则是一个轻量级的持久层框架，它简化了数据库操作，提供了直观的SQL映射。将...
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 326
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 337
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
最新发布
小哇
07-23 124
zookeeper安装并成功运行。
SpringMVC 控制层框架-下
woai3364的博客
07-20 993
因此，在开发过程中，合理处理异常、避免异常产生、以及对异常进行有效的调试是非常重要的。如果张三负责的模块按照 A 方案处理异常，李四负责的模块按照 B 方案处理异常...各个模块处理异常的思路、代码、命名细节都不一样，那么就会让整个项目非常混乱。在Web 应用三层架构体系中，表述层负责接收浏览器提交的数据，业务逻辑层负责数据的处理。一个网站有 5、6个资源，其中有一个为登录资源，两个无需登录即可访问，另外三个需要登录后才能访问，如果不登录就访问那三个资源，需要拦截，并且提示登录后访问。
Spring核心原理：IoC与AOP详解
Java常见原理解析深入探讨了Spring框架的核心原理和设计思想。Spring是一个强大的轻量级开源应用框架，其核心包括Inversion of Control (IoC)和Aspect-Oriented Programming (AOP)。 1. **IoC (控制反转)**: 这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值