第四章 bean定义

最新推荐文章于 2023-07-10 10:20:49 发布
最新推荐文章于 2023-07-10 10:20:49 发布
阅读量160 收藏
点赞数 1
分类专栏： spring源码分析 文章标签： bean分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30561643/article/details/101033839
版权

org.springframework.context.support.AbstractRefreshableApplicationContext#createBeanFactory

// beanFactory主要用于获取bean
DefaultListableBeanFactory beanFactory = createBeanFactory();

org.springframework.context.support.AbstractRefreshableApplicationContext#createBeanFactory
在这里插入图片描述
BeanFactory: 这个获取bean的配置信息
ListableBeanFactory: 这个类是对beanFactory进一步对接口的补充。
HierarchicalBeanFactory: 该接口提供了两个方法一个是获取父容器。第二是否包含bean

protected DefaultListableBeanFactory createBeanFactory() {
   // 创建一个默认的bean工厂
		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

在这里插入图片描述

org.springframework.context.support.AbstractApplicationContext#getInternalParentBeanFactory

/**
	 * Return the internal bean factory of the parent context if it implements
	 * ConfigurableApplicationContext; else, return the parent context itself.
	 * @see org.springframework.context.ConfigurableApplicationContext#getBeanFactory
	 */
	 //  返回bean工厂的父上下文，如果实现了ConfigurableApplicationContext
	@Nullable
	protected BeanFactory getInternalParentBeanFactory() {
		return (getParent() instanceof ConfigurableApplicationContext ?
		   // 获取spring容器对象 applicationContext
				((ConfigurableApplicationContext) getParent()).getBeanFactory() : getParent());
	}

回到前面源码实现接着分析源码

在这里插入图片描述

org.springframework.context.support.AbstractRefreshableApplicationContext#customizeBeanFactory

 对 IOC 容器进行定制化，如设置启动参数，开启注解的自动装
			customizeBeanFactory(beanFactory);

org.springframework.context.support.AbstractRefreshableApplicationContext#customizeBeanFactory

/**
	 * Customize the internal bean factory used by this context.
	 * Called for each {@link #refresh()} attempt.
	 * <p>The default implementation applies this context's
	 * {@linkplain #setAllowBeanDefinitionOverriding "allowBeanDefinitionOverriding"}
	 * and {@linkplain #setAllowCircularReferences "allowCircularReferences"} settings,
	 * if specified. Can be overridden in subclasses to customize any of
	 * {@link DefaultListableBeanFactory}'s settings.
	 * @param beanFactory the newly created bean factory for this context
	 * @see DefaultListableBeanFactory#setAllowBeanDefinitionOverriding
	 * @see DefaultListableBeanFactory#setAllowCircularReferences
	 * @see DefaultListableBeanFactory#setAllowRawInjectionDespiteWrapping
	 * @see DefaultListableBeanFactory#setAllowEagerClassLoading
	 */
	protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		//    是否允许bean定义覆盖
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}{
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		//    是否允许bean之间循环引用
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

在这里插入图片描述

org.springframework.context.support.AbstractRefreshableApplicationContext#loadBeanDefinitions

// 调用载入 Bean 定义的方法，主要这里又使用了一个委派模式，在当前类中只定义了抽象的
			// loadBeanDefinitions 方法，具体的实现调用子类容器
			loadBeanDefinitions(beanFactory);

org.springframework.context.support.AbstractRefreshableApplicationContext#loadBeanDefinitions

	/**
	 * Load bean definitions into the given bean factory, typically through
	 * delegating to one or more bean definition readers.
	 * @param beanFactory the bean factory to load bean definitions into
	 * @throws BeansException if parsing of the bean definitions failed
	 * @throws IOException if loading of bean definition files failed
	 * @see org.springframework.beans.factory.support.PropertiesBeanDefinitionReader
	 * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
	 */
	protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
			throws BeansException, IOException;

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		//第一步: 创建 XmlBeanDefinitionReader，即创建 Bean 读取器，并通过回调设置到容器中去，容器使用该读取器读
		//取 Bean 定义资源
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
		// Configure the bean definition reader with this context's
		//第二步: resource loading environment.
		//为 Bean 读取器设置 Spring 资源加载器，AbstractXmlApplicationContext 的
        //祖先父类 AbstractApplicationContext 继承 DefaultResourceLoader，因此，容器本身也是一个资源加载器
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		//为 Bean 读取器设置 SAX xml 解析器
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
	    // 当 Bean 读取器读取 Bean 定义的 Xml 资源文件时，启用 Xml 的校验机
		initBeanDefinitionReader(beanDefinitionReader);
		// /Bean 读取器真正实现加载的方法
		loadBeanDefinitions(beanDefinitionReader);
}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#setEnvironment

beanDefinitionReader.setEnvironment(this.getEnvironment());

org.springframework.beans.factory.xml.ResourceEntityResolver

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

org/springframework/beans/factory/xml/ResourceEntityResolver.java:66

 */
	public ResourceEntityResolver(ResourceLoader resourceLoader) {
		super(resourceLoader.getClassLoader());
		this.resourceLoader = resourceLoader;
	}

org.springframework.beans.factory.xml.DelegatingEntityResolver#DelegatingEntityResolver(java.lang.ClassLoader)

/**
	 * Create a new DelegatingEntityResolver that delegates to
	 * a default {@link BeansDtdResolver} and a default {@link PluggableSchemaResolver}.
	 * <p>Configures the {@link PluggableSchemaResolver} with the supplied
	 * {@link ClassLoader}.
	 * @param classLoader the ClassLoader to use for loading
	 * (can be {@code null}) to use the default ClassLoader)
	 */
	public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {
	    创建DTD解析器
		this.dtdResolver = new BeansDtdResolver();
		// schema解析器
		this.schemaResolver = new PluggableSchemaResolver(classLoader);
	}

org.springframework.beans.factory.xml.BeansDtdResolver

public class BeansDtdResolver implements EntityResolver {

	private static final String DTD_EXTENSION = ".dtd";

	private static final String DTD_NAME = "spring-beans";

..............................
}

org.springframework.beans.factory.xml.PluggableSchemaResolver#PluggableSchemaResolver(java.lang.ClassLoader)

public PluggableSchemaResolver(@Nullable ClassLoader classLoader) {
		this.classLoader = classLoader;
		this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION;
	}

org.springframework.beans.factory.xml.PluggableSchemaResolver


	/**
	 * The location of the file that defines schema mappings.
	 * Can be present in multiple JAR files.
	 */
	public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = "META-INF/spring.schemas";

org.springframework.context.support.AbstractXmlApplicationContext#initBeanDefinitionReader

// 当 Bean 读取器读取 Bean 定义的 Xml 资源文件时，启用 Xml 的校验机
		initBeanDefinitionReader(beanDefinitionReader);

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)

loadBeanDefinitions(beanDefinitionReader);

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		//获取 Bean 定义资源的定位
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			//Xml Bean 读取器调用其父类 AbstractBeanDefinitionReader 读取定位
            //的 Bean 定义资源
			reader.loadBeanDefinitions(configResources);
		}
		//如果子类中获取的 Bean 定义资源定位为空，则获取 FileSystemXmlApplicationContext 构造方法中
		// setConfigLocations 方法设置的资源
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			//Xml Bean 读取器调用其父类 AbstractBeanDefinitionReader 读取定位
			// //的 Bean 定义资源
			reader.loadBeanDefinitions(configLocations);
		}
	}

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#getConfigLocations

// 获取配置文件的地址
@Nullable
	protected String[] getConfigLocations() {
		return (this.configLocations != null ? this.configLocations : getDefaultConfigLocations());
	}

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#setConfigLocation加载配置文件

public void setConfigLocation(String location) {
		setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
	}

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#setConfigLocations
设置location地址

public void setConfigLocations(@Nullable String... locations) {
		// 遍历配置文件、configLocations
		if (locations != null) {
			Assert.noNullElements(locations, "Config locations must not be null");
			this.configLocations = new String[locations.length];
			for (int i = 0; i < locations.length; i++) {
				this.configLocations[i] = resolvePath(locations[i]).trim();
			}
		}
		else {
			this.configLocations = null;
		}
	}

org.springframework.web.context.ConfigurableWebApplicationContext#setConfigLocation

// 第四步: 获取配置文件路径 contextConfigLocation，配置文件可以是多个的，用，换行分开，可以用占位符
		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
		if (configLocationParam != null) {
			wac.setConfigLocation(configLocationParam);
		}

org.springframework.web.context.ContextLoader#CONFIG_LOCATION_PARAM

	/**
	 * Name of servlet context parameter (i.e., {@value}) that can specify the
	 * config location for the root context, falling back to the implementation's
	 * default otherwise.
	 * @see org.springframework.web.context.support.XmlWebApplicationContext#DEFAULT_CONFIG_LOCATION
	 */
	public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";

在web.xml里面配置的是servlet，那么启动的时候就会从servlet读取配置信息（参数）
，如何加载多参数

public void setConfigLocation(String location) {
		setConfigLocations(StringUtils.tokenizeToStringArray(location, CONFIG_LOCATION_DELIMITERS));
	}

org.springframework.context.ConfigurableApplicationContext#CONFIG_LOCATION_DELIMITERS

String CONFIG_LOCATION_DELIMITERS = ",; \t\n";

bean定义配置文件可以是,或;或空格或换行符分开都可以，为了证明这个结论、可以添加

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#setConfigLocations

public void setConfigLocations(@Nullable String... locations) {
		// 遍历配置文件、configLocations
		if (locations != null) {
			Assert.noNullElements(locations, "Config locations must not be null");
			this.configLocations = new String[locations.length];
			for (int i = 0; i < locations.length; i++) {
				this.configLocations[i] = resolvePath(locations[i]).trim();
			}
		}
		else {
			this.configLocations = null;
		}
	}

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#resolvePath 解析配置文件的地址

this.configLocations[i] = resolvePath(locations[i]).trim();

org.springframework.context.support.AbstractRefreshableConfigApplicationContext#resolvePath
解析配置文件后把配置文件路径放到spring上下文中

	protected String resolvePath(String path) {
		return getEnvironment().resolveRequiredPlaceholders(path);
	}

org.springframework.core.env.PropertyResolver#resolveRequiredPlaceholders

String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;

org.springframework.core.env.AbstractPropertyResolver#resolveRequiredPlaceholders

public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
		if (this.strictHelper == null) {
			this.strictHelper = createPlaceholderHelper(false);
		}
		return doResolvePlaceholders(text, this.strictHelper);
	}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String…)

public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int count = 0;
		for (String location : locations) {
			count += loadBeanDefinitions(location);
		}
		return count;
	}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String)

count += loadBeanDefinitions(location);

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String)

public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String, java.util.Set<org.springframework.core.io.Resource>)

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		//第一步: 获取资源加载器
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
		}
        // 
		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				int count = loadBeanDefinitions(resources);
				if (actualResources != null) {
					Collections.addAll(actualResources, resources);
				}
				if (logger.isTraceEnabled()) {
					logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
				}
				return count;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			Resource resource = resourceLoader.getResource(location);
			int count = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isTraceEnabled()) {
				logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
			}
			return count;
		}
	}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(java.lang.String, java.util.Set<org.springframework.core.io.Resource>)

Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

org.springframework.context.support.AbstractApplicationContext#getResources

public Resource[] getResources(String locationPattern) throws IOException {
		return this.resourcePatternResolver.getResources(locationPattern);
	}

org.springframework.core.io.support.PathMatchingResourcePatternResolver#getResources

public Resource[] getResources(String locationPattern) throws IOException {
		//1、 检测参数不能为空
		Assert.notNull(locationPattern, "Location pattern must not be null");
		if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
			// a class path resource (multiple resources for same name possible)
			// 2、 提取"classpath*:下面的资源文件
			if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
				// a class path resource pattern
				// 3、 规则配置
				return findPathMatchingResources(locationPattern);
			}
			else {
				// all class path resources with the given name
				// 4、所有classpath
				return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
			}
		}
		else {
			// Generally only look for a pattern after a prefix here,
			// and on Tomcat only after the "*/" separator for its "war:" protocol.
			int prefixEnd = (locationPattern.startsWith("war:") ? locationPattern.indexOf("*/") + 1 :
					locationPattern.indexOf(':') + 1);
			if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
				// a file pattern
				return findPathMatchingResources(locationPattern);
			}
			else {
				// a single resource with the given name
				return new Resource[] {getResourceLoader().getResource(locationPattern)};
			}
		}
	}

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource…)

	int count = loadBeanDefinitions(resources);

org.springframework.beans.factory.support.AbstractBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource…)

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int count = 0;
		for (Resource resource : resources) {
			count += loadBeanDefinitions(resource);
		}
		return count;
	}

org.springframework.beans.factory.support.BeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.Resource)

int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException;

org.springframework.beans.factory.xml.XmlBeanDefinitionReader#loadBeanDefinitions(org.springframework.core.io.support.EncodedResource)

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Loading XML bean definitions from " + encodedResource);
		}
		//
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}
享知
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
什么是bean
盖丽男
06-20 3万+
什么是bean？ bean是计算机自动生成的类，bean是一个由Spring IoC容器实例化、组装和管理的对象。也就是说，bean并不是程序员编辑的，而是程序运行时，由spring通过反射生成的。在程序中，我们并不使用代码去new一个类（service，dao层等），那么谁来new呢？又是如何new的呢？ 让我们看一下spring是如何做的， xml配置 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www
Bean的概述
weixin_54211278的博客
02-10 246
Spring IOC 容器管理一个或多个 bean。这些 bean 是使用你提供给容器的配置元数据创建的（例如，以 XML定义的形式）。在容器本身中，这些 Bean 定义被表示为对象，其中包含（除其他信息外）以下元数据：包限定类名称：通常是正在定义的 Bean 的实际实现类。Bean 行为配置元素，它说明 Bean 在容器中应该如何表现（作用域、生命周期回调，等等）。引用 Bean 完成其工作所需的其他 bean。这些引用也被称为协作者或依赖项。
bean的定义
m0_48134027的博客
04-08 994
Bean 定义 被称作 bean 的对象是构成应用程序的支柱也是由 Spring IoC 容器管理的。bean 是一个被实例化，组装，并通过 Spring IoC 容器所管理的对象。这些 bean 是由用容器提供的配置元数据创建的，例如，已经在先前章节看到的，在 XML 的表单中的 定义。 bean 定义包含称为配置元数据的信息，下述容器也需要知道配置元数据： 如何创建一个 bean bean 的生命周期的详细信息 bean 的依赖关系 上述所有的配置元数据转换成一组构成每...
bean到底是什么？（简单易懂）
wuqiahao的博客
06-06 3413
Bean通常用于封装数据，以便在应用程序之间传递和处理。例如，在Web开发中，可以将表单数据存储在一个Bean对象中，然后将该对象传递给服务器端的Java代码进行处理。另一个例子是在数据库访问中使用Bean对象映射数据库表中的行数据。简单来说，bean就是一个类对象，把接收到的数据封装成所需要的类对象来存储。bean是一种特殊的类，但是不是每个类都是bean。
Spring第4篇：bean定义详解
chenzoff的专栏
04-11 908
本文内容 1. bean xml配置文件 2. bean元素详解 2. 名称和别名详解 4. alias元素详解 5. 通过import元素引入外部配置 环境 1. jdk1.8 2. idea 3. maven-3.6.1 4. spring-5.2.3.RELEASE bean概念回顾 我们再来回顾一下，被spring管理的对象统称为bean，我们程序中需要用到很多对象，我们将这些对象让spring去帮我们创建和管理，我们可以通过bean xml配置文件告诉spring容器需要管
Spring（01）——bean定义
weixin_33717117的博客
06-28 131
1 bean定义 1.1 命名 给bean命名不是必须的，但是如果如果有其它bean需要引用该bean，那么就需要给该bean命名。当我们没有给bean命名时，Spring将自动为该bean生成一个唯一的名称。 1.1.1 id和name属性 可以通过id和name给bean命名，如果只需要给bean指定一个名称则使用id和name都可以。...
Spring Bean的几种定义方式
m0_71777195的博客
05-27 461
这是一种稍微有些“传统”的定义方式了！不过在部分项目以及框架配置中，还是需要使用这种方式定义Spring Bean的，这里进行总结。xml复制代码
Spring的12种bean定义方式
weixin_42694511的博客
06-16 393
在庞大的java体系中，spring有着举足轻重的地位，它给每位开发者带来了极大的便利和惊喜。我们都知道spring是创建和管理bean的工厂，它提供了多种定义bean的方式，能够满足我们日常工作中的多种业务场景。那么问题来了，你知道spring中有哪些方式可以定义bean？我估计很多人会说出以下三种：没错，但我想说的是以上三种方式只是开胃小菜，实际上spring的功能远比你想象中更强大。各位看官如果不信，请继续往下看。
Spring 注解开发（六.Bean定义、作用范围以及生命周期）
weixin_61620939的博客
08-31 242
注解开发定义bean 和纯注解开发配置文件。并在纯注解环境下实现bean生命周期设置
java中bean的定义有哪些_详解Java的Spring框架中bean的定义以及生命周期
weixin_36371504的博客
02-25 586
bean的定义形成应用程序的骨干是由Spring IoC容器所管理的对象称为bean。bean被实例化，组装，并通过Spring IoC容器所管理的对象。这些bean由容器提供，例如，在XML的定义，已经看到了前几章的形式配置元数据创建。bean定义包含所需要的容器要知道以下称为配置元数据的信息：如何创建一个beanBean 生命周期的详细信息Bean 依赖关系上述所有配置元数据转换成一组的下列属...
Bean是什么
最新发布
weixin_54715318的博客
07-10 590
JavaBeans是一种用于构建可重用组件的约定和规范，它定义了一组命名约定、属性访问方法、事件处理机制和其他标准，以便Java对象可以被统一地使用和操作。一个JavaBean是一个符合JavaBeans规范的普通Java类，它具有私有的属性（成员变量）以及公共的访问方法（getter和setter方法）来访问和修改这些属性。通过遵循JavaBeans规范，开发人员可以创建可重用的、可插拔的组件，这些组件可以在不同的应用程序中进行组合和重用，提高了代码的可维护性和扩展性。
惊呆了，spring中竟然有12种定义bean的方法
码农小胖哥
07-13 1421
前言在庞大的java体系中，spring有着举足轻重的地位，它给每位开发者带来了极大的便利和惊喜。我们都知道spring是创建和管理bean的工厂，它提供了多种定义bean的方式，能够满足...
三种定义bean的方式
weixin_30436101的博客
04-29 632
方法一：基于XML的bean定义（需要提供setter方法） 1.首先编写student.java和teacher.java两个类 Student.java: public class Student { private String name; private Teacher teacher; public String getName() ...
JavaBean的定义
aerf5sd的博客
03-30 3798
在读文章之前，我想告诉大家三点1.本文介绍的JavaBean与企业JavaBeans（EJB）没有任何关系。2.本文介绍JavaBean是结合 标准的JavaBean（现在用的很少）与我们日常web开发所说的JavaBean，二者在集合属性的定义上还是有不同的。3.只所以介绍一下与客户端开发相关的标准JavaBean，是想为介绍JavaBean的持久化技术做一下铺垫。JavaBean的定义sun对J
Spring：如何完整定义一个Bean
u013361010的专栏
10-16 2633
每当我们需要使用一个类时，我们最常见的操作是在spring的配置文件中加上如下配置： <bean id = "fsx" class = "org.fsx.BeanDemo"/> OK, 这样定义完成后我们就可以从bean工厂中直接根据id获取所定义的对象，并任性的使用它，于是有人不由的发出"spring真是强大或是简单”的感慨。这样的确可以起作用，但如果认为spring中定义一个Bean只有
SpringBoot基础篇Bean之基本定义与使用
weixin_34357962的博客
10-14 1454
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring定义Bean的两种方式：＜bean＞和@Bean
恐龙弟旺仔的博客
05-02 2万+
前言： Spring中最重要的概念IOC和AOP，实际围绕的就是Bean的生成与使用。 什么叫做Bean呢？我们可以理解成对象，每一个你想交给Spring去托管的对象都可以称之为Bean。 今天通过Spring官方文档来了解下，如何生成bean，如何使用呢？ 1.通过XML的方式来生成一个bean 最简单也是最原始的一种方式，通过XML来定义一个be...
org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: Can
热门推荐
:)一位靓仔偶然路过的博客
06-01 4万+
org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: Cannot locate BeanDefinitionDecorator for element [annotation-driven] Offending resource: class path
zkclient相关的bean如何正确地定义和配置
03-29
3. 在上面的bean定义中，第一个参数是Zookeeper服务器的地址，第二个参数是会话超时时间。 4. 可以在bean定义中添加更多的属性来配置zkclient，例如： ```xml <bean id="zkClient" class=...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值