spring boot的一些简单源码随笔

最新推荐文章于 2023-12-28 20:08:08 发布
最新推荐文章于 2023-12-28 20:08:08 发布
阅读量145 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c1523456/article/details/115218923
版权

目录

 

目的 

代码分析

流程总结 

springboot 的属性配置

SpringApplication中的prepareEnvironment() 方法

SpringApplication的prepareEnvironment（）方法

spring profile

banner 的设置方式一共分为以下几种方式

  1. 兜底banner   
  2. 图片banner 
  3.  txt banner 
  4. 关闭banner

目的 

我们来查看源码分析banner的基本实现，从原理上把banner的配置弄明白，以后就不用死记硬背banner的配置了

代码分析

首先进到SpringApplication  的run() 方法，printBanner（）这是我们banner的获取逻辑也是我们重点分析的地方。

public ConfigurableApplicationContext run(String... args) {
		StopWatch stopWatch = new StopWatch();
		stopWatch.start();
		ConfigurableApplicationContext context = null;
		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
		configureHeadlessProperty();
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting();
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			configureIgnoreBeanInfo(environment);
            //这是我们banner的获取逻辑也是我们重点分析的地方
			Banner printedBanner = printBanner(environment);
			context = createApplicationContext();
			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
					new Class[] { ConfigurableApplicationContext.class }, context);
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			stopWatch.stop();
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
			}
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, listeners);
			throw new IllegalStateException(ex);
		}

		try {
			listeners.running(context);
		}
		catch (Throwable ex) {
			handleRunFailure(context, ex, exceptionReporters, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}

 如果banner为关闭模式则直接返回null  配置方式是在配置文件中使用spring.main.banner-mod=off进行关闭，下面判断是打印到控制台还是打印到日志,这里打印到日志和打印到控制台的逻辑基本上是一致的，故我们择一去探究即可。

private Banner printBanner(ConfigurableEnvironment environment) {
        //如果banner为关闭模式则直接返回null  配置方式是在配置文件中使用spring.main.banner-mod=off进行关闭
		if (this.bannerMode == Banner.Mode.OFF) {
			return null;
		}
//创建资源加载器
		ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader
				: new DefaultResourceLoader(getClassLoader());
//创建对象
		SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
//是否打印到日志
		if (this.bannerMode == Mode.LOG) {
			return bannerPrinter.print(environment, this.mainApplicationClass, logger);
		}
//打印到控制台，这里打印到日志和打印到控制台的逻辑基本上是一致的，故我们择一去探究即可
		return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
	}

print（） 这段代码简单明了，无非就是 获取banner   打印banner  将banner作为参数返回，我们了解了如何获取banner，我们自然而然的也就知道怎么配置banner了

//这段代码简单明了，无非就是 获取banner   打印banner  将banner作为参数返回，我们了解了如何获取banner，我们自然而然的也就知道怎么配置banner了

public Banner print(Environment environment, Class<?> sourceClass, PrintStream out) {
        
		Banner banner = getBanner(environment);
		banner.printBanner(environment, sourceClass, out);
		return new PrintedBanner(banner, sourceClass);
	}
private Banner getBanner(Environment environment) {
        //构造banner实例
		Banners banners = new Banners();
        //获取图片banner并添加到队列中
		banners.addIfNotNull(getImageBanner(environment));
        //获取textbanner 并添加到队列中
		banners.addIfNotNull(getTextBanner(environment));
    //返回封装所有banner的代理banner
		if (banners.hasAtLeastOneBanner()) {
			return banners;
		}
.        //如果没有设置banner返回兜底的banner
		if (this.fallbackBanner != null) {
			return this.fallbackBanner;
		}
        //否则返回默认的banner
		return DEFAULT_BANNER;
	}
//逻辑简单明了获取BANNER_IMAGE_LOCATION_PROPERTY 属性的value属性值，属性名称为spring.banner.image.location，根据value加载资源并构造banner 如果没有设置  BANNER_IMAGE_LOCATION_PROPERTY 属性则 查找classpath下banner.xxx的资源如果有则返回,xxx是什么呢， 具体如下{ "gif", "jpg", "png" };
private Banner getImageBanner(Environment environment) {
		String location = environment.getProperty(BANNER_IMAGE_LOCATION_PROPERTY);
		if (StringUtils.hasLength(location)) {
			Resource resource = this.resourceLoader.getResource(location);
			return resource.exists() ? new ImageBanner(resource) : null;
		}
		for (String ext : IMAGE_EXTENSION) {
			Resource resource = this.resourceLoader.getResource("banner." + ext);
			if (resource.exists()) {
				return new ImageBanner(resource);
			}
		}
		return null;
	}

/text 的也简单明了，如果设置了BANNER_LOCATION_PROPERTY 则获取该value属性值，如果没有设置则有默认值 banner.txt,之后根据 location 进行资源的加载并返回
private Banner getTextBanner(Environment environment) {
		String location = environment.getProperty(BANNER_LOCATION_PROPERTY, DEFAULT_BANNER_LOCATION);
		Resource resource = this.resourceLoader.getResource(location);
		if (resource.exists()) {
			return new ResourceBanner(resource);
		}
		return null;
	}

到此banner的获取基本上就分析返程了，

流程总结 

  1. 首先获取imagebanner    1 是否配置有spring.banner.image.location属性，如果有使用该属性值获取banner  2 根据banner.xxx 后缀名称可以是"gif", "jpg", "png"获取banner
  2. 获取text banner  1是否配置有spring.banner.location 属性 如果有根据该路径获取banner 2如果没有根据banner.txt 获取banner
  3. 否则           如果text  或 image 类型都查找不到banner  查看我们兜底的banner有没有设置，如果有使用兜底banner 如果没有使用SpringBootBanner

 

springboot 的属性配置

首先我们先明确一下springBoot中都定义了那些配置方式，这里我们直接粘贴处官网给出的列表清单

  1. Devtools global settings properties on your home directory (~/.spring-boot-devtools.properties when devtools is active).
  2. @TestPropertySource annotations on your tests.
  3. properties attribute on your tests. Available on @SpringBootTest and the test annotations for testing a particular slice of your application.
  4. Command line arguments.
  5. Properties from SPRING_APPLICATION_JSON (inline JSON embedded in an environment variable or system property).
  6. ServletConfig init parameters.
  7. ServletContext init parameters.
  8. JNDI attributes from java:comp/env.
  9. Java System properties (System.getProperties()).
  10. OS environment variables.
  11. A RandomValuePropertySource that has properties only in random.*.
  12. Profile-specific application properties outside of your packaged jar (application-{profile}.properties and YAML variants).
  13. Profile-specific application properties packaged inside your jar (application-{profile}.properties and YAML variants).
  14. Application properties outside of your packaged jar (application.properties and YAML variants).
  15. Application properties packaged inside your jar (application.properties and YAML variants).
  16. @PropertySource annotations on your @Configuration classes. Please note that such property sources are not added to the Environment until the application context is being refreshed. This is too late to configure certain properties such as logging.* and spring.main.* which are read before refresh begins.
  17. Default properties (specified by setting SpringApplication.setDefaultProperties).

一共17中属性配置方式，下面我们从代码角度分析，这些属性是从哪里加载进入environment的

 

SpringApplication中的prepareEnvironment() 方法

springapplication 的run 方法中，我们忽略掉与本次脉络无关的代码直接看下面的代码，进入prepareEnvironment,首先创建Environment 的实例,并依次根据如下逻辑将 6,7,8,9,10 属性配置填充到enviroment 中。

//springapplication 的run 方法中，我们忽略掉与本次脉络无关的代码直接看下面的代码
public ConfigurableApplicationContext run(String... args) {
	。。。。
//我们进入该方法
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			。。。。
	}
//environment 的核心处理方法就是在这里了	
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		// 首先创建Environment 的实例
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		ConfigurationPropertySources.attach(environment);
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
					deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}
//进入该方法逻辑也很简单就是查找当前是什么环境，如果是web环境就构建StandardServletEnvironment，web环境配置还多一些我们直接分析这个
private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}
//在实例化该类对象的时候首先会依次调用父类的构造函数，我们直接看AbstractEnvironment的构造函数
public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {
    public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";
    public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";
    public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";

    public StandardServletEnvironment() {
    }

    protected void customizePropertySources(MutablePropertySources propertySources) {
        propertySources.addLast(new StubPropertySource("servletConfigInitParams"));
        propertySources.addLast(new StubPropertySource("servletContextInitParams"));
        if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
            propertySources.addLast(new JndiPropertySource("jndiProperties"));
        }

        super.customizePropertySources(propertySources);
    }

   
    }
}
public abstract class AbstractEnvironment implements ConfigurableEnvironment {

	//我们看到该构造函数会回调customizePropertySources函数
	public AbstractEnvironment() {
		customizePropertySources(this.propertySources);
	}
}

//视野回到 StandardServletEnvironment类的该函数，这是在父类构造函数中进行的回调我们看到进行了servletConfigInitParams，servletContextInitParams，Jndi相关属性的填充工作,之后调用父类的customizePropertySource() 函数
protected void customizePropertySources(MutablePropertySources propertySources) {
        propertySources.addLast(new StubPropertySource("servletConfigInitParams"));
        propertySources.addLast(new StubPropertySource("servletContextInitParams"));
        if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
            propertySources.addLast(new JndiPropertySource("jndiProperties"));
        }

        super.customizePropertySources(propertySources);
    }
//这里又依次加载了	systemEnvironment   systemProperties的属性配置
protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(
				new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(
				new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}

到此为止，enviroment 中一共有了  6,7,8,9,10 属性配置。

 

SpringApplication的prepareEnvironment（）方法

我们将视野回到SpringApplication 类的 prepareEnvironment（）方法中去进入configureEnvironment()中

	protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
		if (this.addConversionService) {
			ConversionService conversionService = ApplicationConversionService.getSharedInstance();
			environment.setConversionService((ConfigurableConversionService) conversionService);
		}
        //该方法将defaultProperties和 commandLineArgs 设置进入enviroment 中
		configurePropertySources(environment, args);
        
		configureProfiles(environment, args);
	}


protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
		MutablePropertySources sources = environment.getPropertySources();
		if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
			sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));
		}
		if (this.addCommandLineProperties && args.length > 0) {
			String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
			if (sources.contains(name)) {
				PropertySource<?> source = sources.get(name);
				CompositePropertySource composite = new CompositePropertySource(name);
				composite.addPropertySource(
						new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
				composite.addPropertySource(source);
				sources.replace(name, composite);
			}
			else {
				sources.addFirst(new SimpleCommandLinePropertySource(args));
			}
		}
	}

最后调用监听器触发environmentPrepared() 事件

	public void environmentPrepared(ConfigurableEnvironment environment) {
		for (SpringApplicationRunListener listener : this.listeners) {
			listener.environmentPrepared(environment);
		}
	}

会依次调用如下  ApplicationListener的实现类

//我们重点分析第一个监听器的回调接口，属性的填充逻辑基本上再该方法中
0 = {ConfigFileApplicationListener@1707}    
1 = {AnsiOutputApplicationListener@1708} 
2 = {LoggingApplicationListener@1696} 
3 = {ClasspathLoggingApplicationListener@1709} 
4 = {BackgroundPreinitializer@1710} 
5 = {DelegatingApplicationListener@1711} 
6 = {ParentContextCloserApplicationListener@1712} 
7 = {ClearCachesApplicationListener@1713} 
8 = {FileEncodingApplicationListener@1714} 
9 = {LiquibaseServiceLocatorApplicationListener@1715}

 

这是 applicationlistener 的回调接口	
@Override
	public void onApplicationEvent(ApplicationEvent event) {
		if (event instanceof ApplicationEnvironmentPreparedEvent) {
            //
			onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
		}
		if (event instanceof ApplicationPreparedEvent) {
			onApplicationPreparedEvent(event);
		}
	}


	private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        //从 spring.factories 文件中加载EnvironmentPostProcessor的类并实例化
		List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
		postProcessors.add(this);
		AnnotationAwareOrderComparator.sort(postProcessors);
    //依次调用该刚发进行环境的处理，我们留意，本类也是一个EnvironmentPostProcessor 这个类型的的子类所以也会回调该子类的该方法,我们下面紧接着分析
		for (EnvironmentPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication());
		}
	}

 

配置文件中现有的EnvironmentPostProcessor
CloudFoundryVcapEnvironmentPostProcessor (org.springframework.boot.cloud)
SpringApplicationJsonEnvironmentPostProcessor (org.springframework.boot.env)   
SystemEnvironmentPropertySourceEnvironmentPostProcessor (org.springframework.boot.env)          
ConfigFileApplicationListener (org.springframework.boot.context.config)   
SpringBootTestRandomPortEnvironmentPostProcessor (org.springframework.boot.test.web)

这里我们重点分析两个，第一个 SpringApplicationJsonEnvironmentPostProcessor (org.springframework.boot.env)   ，第二个  ConfigFileApplicationListener (org.springframework.boot.context.config)  .

//将SPRING_APPLICATION_JSON的配置属性添加进环境

public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
		MutablePropertySources propertySources = environment.getPropertySources();
		propertySources.stream().map(JsonPropertyValue::get).filter(Objects::nonNull).findFirst()
				.ifPresent((v) -> processJson(environment, v));
	}

public class ConfigFileApplicationListener implements EnvironmentPostProcessor, SmartApplicationListener, Ordered {
     @Override
	public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
           //进入该方法
		addPropertySources(environment, application.getResourceLoader());

	}

}

protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
          //第一个方法进行随机值配置属性的填充
		RandomValuePropertySource.addToEnvironment(environment);
//  第二个方法的代码我们已经粘贴到下面了，这是进行properties 和yml 配置文件属性的填充
		new Loader(environment, resourceLoader).load();
	}

public void load() {
			this.profiles = new LinkedList<>();
			this.processedProfiles = new LinkedList<>();
			this.activatedProfiles = false;
			this.loaded = new LinkedHashMap<>();
			initializeProfiles();
			while (!this.profiles.isEmpty()) {
				Profile profile = this.profiles.poll();
				if (profile != null && !profile.isDefaultProfile()) {
					addProfileToEnvironment(profile.getName());
				}
				load(profile, this::getPositiveProfileFilter, addToLoaded(MutablePropertySources::addLast, false));
				this.processedProfiles.add(profile);
			}
			resetEnvironmentProfiles(this.processedProfiles);
			load(null, this::getNegativeProfileFilter, addToLoaded(MutablePropertySources::addFirst, true));
			addLoadedPropertySources();
		}

到此为止又有5， 11，12,13,14,15添加进入 enviroment 中,关于16  这个是在解析配置的时候进行的加载,到此为止基本上除了1,2,3外，属性配置都已经加载进入了enviroment中

spring profile

我们现在来分析一下spring profile 的加载机制，通过上面的分析，我们应该可以看出一些蛛丝马迹，我们直接到ConfigFileApplicationListener 的addPropertySources（）方法中

protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
		RandomValuePropertySource.addToEnvironment(environment);
           //此处进行profile文件属性的具体加载工作
		new Loader(environment, resourceLoader).load();
	}

进入load方法

public void load() {
			this.profiles = new LinkedList<>();
			this.processedProfiles = new LinkedList<>();
			this.activatedProfiles = false;
			this.loaded = new LinkedHashMap<>();
//首先进入该方法
			initializeProfiles();
            //遍历profile
			while (!this.profiles.isEmpty()) {
				Profile profile = this.profiles.poll();
				if (profile != null && !profile.isDefaultProfile()) {
					addProfileToEnvironment(profile.getName());
				}
                //加载配置文件
				load(profile, this::getPositiveProfileFilter, addToLoaded(MutablePropertySources::addLast, false));
				this.processedProfiles.add(profile);
			}
			resetEnvironmentProfiles(this.processedProfiles);
			load(null, this::getNegativeProfileFilter, addToLoaded(MutablePropertySources::addFirst, true));
			addLoadedPropertySources();
		}
	private void initializeProfiles() {
			//首先添加一个null的profile 我们可以把它当做 application.propreties 或application.yml
			this.profiles.add(null);
//查看环境变量中是否存在spring.profiles.active或spring.profiles.include属性如果有的话封装为对象返回
			Set<Profile> activatedViaProperty = getProfilesActivatedViaProperty();
			this.profiles.addAll(getOtherActiveProfiles(activatedViaProperty));
			
			addActiveProfiles(activatedViaProperty);
		
//如果没有spring.profiles.active或spring.profiles.include的profile的话，添加一个defalut profile,名字为default,并设置为默认profile
	if (this.profiles.size() == 1) { // only has null profile
				for (String defaultProfileName : this.environment.getDefaultProfiles()) {
					Profile defaultProfile = new Profile(defaultProfileName, true);
					this.profiles.add(defaultProfile);
				}
			}
		}

那么剩下的问题就是我们在配置文件中使用的spring.profiles.include  和spring.profiles.active 引入的profile 是在哪里加载进来的,我们进入load()方法

private void load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
//这里会在指定的路径下面去查找指定名称的配置问价进行加载,可以通过spring.config.location和spring.config.additional-location属性修改配置文件位置,默认是classpath:/,classpath:/config/,file:./,file:./config/
			getSearchLocations().forEach((location) -> {
				boolean isFolder = location.endsWith("/");
                //获取要查找的name  可以通过spring.config.name进行配置,默认是application
				Set<String> names = isFolder ? getSearchNames() : NO_SEARCH_NAMES;
				names.forEach((name) -> load(location, name, profile, filterFactory, consumer));
			});
		}

我们进入load方法中

private void load(String location, String name, Profile profile, DocumentFilterFactory filterFactory,
				DocumentConsumer consumer) {
		...
			Set<String> processed = new HashSet<>();
			for (PropertySourceLoader loader : this.propertySourceLoaders) {
				for (String fileExtension : loader.getFileExtensions()) {
					if (processed.add(fileExtension)) {
//进入该方法
						loadForFileExtension(loader, location + name, "." + fileExtension, profile, filterFactory,
								consumer);
					}
				}
			}
		}
//最终都会调用load方法，我们进入该方法
private void loadForFileExtension(PropertySourceLoader loader, String prefix, String fileExtension,
				Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
			DocumentFilter defaultFilter = filterFactory.getDocumentFilter(null);
			DocumentFilter profileFilter = filterFactory.getDocumentFilter(profile);
			if (profile != null) {
				// Try profile-specific file & profile section in profile file (gh-340)
				String profileSpecificFile = prefix + "-" + profile + fileExtension;
				load(loader, profileSpecificFile, profile, defaultFilter, consumer);
				load(loader, profileSpecificFile, profile, profileFilter, consumer);
				// Try profile specific sections in files we've already processed
				for (Profile processedProfile : this.processedProfiles) {
					if (processedProfile != null) {
						String previouslyLoaded = prefix + "-" + processedProfile + fileExtension;
						load(loader, previouslyLoaded, profile, profileFilter, consumer);
					}
				}
			}
			// Also try the profile-specific section (if any) of the normal file
			load(loader, prefix + fileExtension, profile, profileFilter, consumer);
		}
private void load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter,
				DocumentConsumer consumer) {
			try {
				Resource resource = this.resourceLoader.getResource(location);
			
				String name = "applicationConfig: [" + location + "]";
				List<Document> documents = loadDocuments(loader, name, resource);
				//此处将配置文件中的ActiveProfiles  和 IncludeProfiles分别加入到profiles中进行下次循环的调用
				List<Document> loaded = new ArrayList<>();
				for (Document document : documents) {
					if (filter.match(document)) {
						addActiveProfiles(document.getActiveProfiles());
						addIncludedProfiles(document.getIncludeProfiles());
						loaded.add(document);
					}
				}
				Collections.reverse(loaded);
				if (!loaded.isEmpty()) {
					loaded.forEach((document) -> consumer.accept(profile, document));
					if (this.logger.isDebugEnabled()) {
						StringBuilder description = getDescription("Loaded config file ", location, resource, profile);
						this.logger.debug(description);
					}
				}
			}
			catch (Exception ex) {
				throw new IllegalStateException("Failed to load property " + "source from location '" + location + "'",
						ex);
			}
		}

 

奋斗的小面包
关注
专栏目录
SpringBoot源码解析（十九）Spring事务tx源码分析(二)
lz710117239的博客
01-08 1020
最近想提升，苦逼程序猿，想了想还是拿最熟悉，之前也一直想看但没看的spring源码来看吧，正好最近在弄事务这部分的东西，就看了下，同时写下随笔记录下，以备后查。 spring tx源码分析 这里只分析简单事务也就是DataSourceTransactionManager 首先肯定找入口了，看过spring源码的同学一定都会找spring tx的入口就是在TxAdviceBeanDefinit
mybatis mysql回滚_spring boot 使用 mybatis 开启事务回滚 的总结
weixin_36368715的博客
02-07 1785
1.前言以前没有使用mybatis,可以关闭自动提交，然后做sql操作，对操作进行catch捕获异常，如果没有异常则commit 提交 ，有异常则 rollback 回滚，新增的数据则删除 ，修改的数据则修改回去，删除的则新增，这就是事务操作。事务有四大特性(1)原子性：要么全部执行成功，要么不执行。(2)一致性：事务执行的结果，必须使数据库从一个一致性状态变到另一个一致性状态。(3)隔离性：并发...
SpringBoot入门学习(含代码)
小气鬼Sweet的博客
10-05 457
SpringBoot入门学习(含代码) - SpringBoot是什么： 是什么并没有具体概念，自我理解像是一种工具，帮助开发者更容易的创建基于Spring的应用程序和服务，简化了开发过程。
Spring 以及 Spring Boot源码简单分析
努力努力小张的博客
11-25 428
1、SpringIOC的执行流程和扩展点 1）创建一个新鲜的BeanFactory工厂 2）读取和解析配置文件，若想读取必须实现BeanDefinitionReader接口，通过beanDefinition定义bean信息 3）BeanFactoryPostProcesser对引用外部文件的值进行赋值。比如配置数据源引用properties时，它的赋值就是在这 4）通过反射创建对象 5）创建对象的过程为实例化—>填充属性—>设置Aware接口属性—>执行BeanPo...
这是我见过最全的SpringBoot运行教程（附源码+实例）
程序员闪充宝
08-17 1077
Spring Boot这个框架到底有好用？从诞生之初被奉为Spring家族的头牌王者，到现在短短几年，就成了Java新人的必备技能，可见用它来开发有多方便了。同时，Spring Boot也...
springboot 报错has been compiled by a more recent version of the Java Runtime
最新发布
m0_58498702的博客
12-28 774
解决办法，把boot父亲工程的版本降低。把3.1.2改为2.6.6。
SpringBoot 启动原理
qq_44182694的博客
07-27 405
Springboot application 启动原理
单点登录源码
01-09
└── zheng-demo -- 示例模块(包含一些示例代码等) ├── zheng-demo-rpc-api -- rpc接口包 ├── zheng-demo-rpc-service -- rpc服务提供者 └── zheng-demo-web -- 演示示例[端口:8888] ``` ### 技术...
nacos、gateway、sentinel相关的demo源码实现，初学的同学可以参考
09-27
在源码中，你会看到如何在Spring Boot应用中引入Sentinel，如何定义资源并设置流量规则，以及如何利用Sentinel Dashboard进行实时监控和管理。 结合这个压缩包，初学者可以通过实际运行和调试代码，深入理解这三个...
CORS跨域处理心得随笔
qq_38951990的博客
10-03 1063
现如今大多数项目都是前后端开发的，前端项目和后端接口服务部署在不同的机器下，且一般部署机器的ip也不相同。那么在大环境的驱使下跨域问题就成为了前后端开发必须面对的首要问题。那到底什么是跨域请求呢，又要如何解决跨域问题呢？
spring5/springboot2源码学习 -- Environment及PropertySource相关
yuxiuzhiai的博客
12-09 707
基本介绍 Environment是spring中一个非常核心的接口，代表当前应用运行的环境。 可以分为两个方面： profiles：设置profiles properties：查找属性配置 接口定义 public interface Environment extends PropertyResolver { String[] getActiveProfiles();...
spring boot properties【翻译】
chunliu5969的博客
03-27 137
https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-profile-specific-pr...
Spring Boot配置文件详解
weixin_33758863的博客
04-09 125
2019独角兽企业重金招聘Python工程师标准>>> ...
Idea中 javaweb 运行报错：has been compiled by a more recent version of the Java Runtime 。HTTP状态500的解决方法。
热门推荐
m0_50958694的博客
04-15 2万+
1、在idea中运行jsp文件，并提交jsp文件中的内容到servlet中，出现HTTP状态500-内部服务器。 类型：异常报告 消息：实例化Servlet类[com.lagou.servlet.loginServlet]异常 描述：服务器遇到一个意外的情况，阻止它完成请求。 如下图： 2、控制台日志显示出现错误的主要原因是： has been compiled by a more recent version of the Java Runtime (class file versio
Spring Boot：基本应用，源码解析，数据访问和视图技术
qq_40286307的博客
11-07 800
SpringBoot 基本应用 约定优于配置 约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式。 本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为 User 的类，那么数据库中对应的表就会默认命名为 User。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进行开发
SpringBoot（三）使用EnvironmentPostProcessor接口加载外部配置文件
yhahaha_的博客
03-15 7828
SpringBoot版本：2.1.1 接上一篇博文。 编写EnvironmentPostProcessor接口实现，重写postProcessEnvironment方法。 @Component public class MyEnvironmentPropertySource implements EnvironmentPostProcessor { @Override public ...
SpringBoot之Banner解析(五)
青鸟飞鱼
07-14 478
banner输出的方式 1、默认banner输出 就是spring boot 2、文字banner。修改banner图 在resources下创建banner.txt 。内容为 /* _ooOoo_ o8888888o 88" . "88 (| -_- |) O\ = /O _.
springBoot的EnvironmentPostProcessor使用
weixin_43827985的博客
03-04 9028
springBoot的EnvironmentPostProcessor使用，根据生产环境，加载指定环境所有properties配置文件，并放入自定义工具类PropertiesUtil 文章目录springBoot的EnvironmentPostProcessor使用，根据生产环境，加载指定环境所有properties配置文件，并放入自定义工具类PropertiesUtil前言一、EnvironmentPostProcessor是什么？二、使用步骤1.实现EnvironmentPostProcessor2.读
spring.context 随笔0 概述
hyoka的博客
03-29 268
0. 面试前顺手回顾一下 源码走读通过xml配置的方式注入bean 一位大佬关于Spring的系列博客 1. 几个需要关注的类 DefaultListableBeanFactory BeanFactory的实现类，扩展了维护多个bean的能力(BeanFactory的api是管理单个bean的) 集成了xml、注解方式的bean注入能力 ApplicationContext 内部维护了DefaultListableBeanFactory refresh() 初始化BeanFactory 调用
深度解析：Spring Boot启动源码分析
"本文将深入探讨Spring Boot的运行机制，主要关注其源码层面的解析。我们将从Spring Boot的入口程序开始，了解如何自定义SpringApplication，以及在准备阶段SpringApplication如何进行初始化设置。" 在Spring Boot...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值