精华内容
下载资源
问答
  • 2019-12-04 21:54:14

    如何把一个对象放到Spring容器,交由Spring管理? 

     

    1. 加@Component
    2. @Import(xx)导入(用于第三方的类)
    3. 定义一个FactoryBean(实现FactroyBean接口)(用于第三方的类)
    4. 调用BeanFactory的registerSingleton()注册一个对象(用于第三方的类)

     

     @Component

    @Component
    public class B {
    
        public B(){
            System.out.println("B start");
        }
    }

    定义一个FactoryBean(实现FactroyBean接口)

    public class MyFactoryBean implements FactoryBean {
        @Override
        public Object getObject() throws Exception {
            return new B();
        }
    
        @Override
        public Class<?> getObjectType() {
            return B.class;
        }
    
        @Override
        public boolean isSingleton() {
            return true;
        }
    }

    调用BeanFactory的registerSingleton()注册一个对象

     AnnotationConfigApplicationContext applicationContext = new 
     AnnotationConfigApplicationContext(MyConfig.class);
     applicationContext.getBeanFactory().registerSingleton("b",new B());

    此方法也是把一个对象交由Spring容器管理,但这样确实有些鸡肋。之所以把一个对象交由Spring管理,主要是解决对象之间的依赖关系。如果我们手动调用这个API,这个对象,确实放到spring容器当中了,但,之前放到Spring容器中的对象就不能用得到这个对象(API注册的)的依赖,因为他们先一步放到容器中,此时调用API的这个对象还没交由Spring容器管理。

    下面在看一种情况:

     AnnotationConfigApplicationContext applicationContext = new 
     AnnotationConfigApplicationContext();     
     applicationContext.getBeanFactory().registerSingleton("b",new B());
     applicationContext.register(MyConfig.class);
     applicationContext.refresh();

    这样做,只是把调用API方式的时机放到Spring容器初始化之前了,但这个对象却不能用到后面由Spring管理的对象的依赖。

     

    更多相关内容
  • Spring通过Xml配置来装载Bean的的流程: 读取xml配置文件 》解析Xml并找到对应类的配置 》实例化对象 环境准备 这是一个简单的bean public class User { private String name; public String getName() { ...

    Spring通过Xml配置来装载Bean的的流程: 读取xml配置文件 》解析Xml并找到对应类的配置 》实例化对象

    环境准备

    这是一个简单的bean

    public class User {
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    }
    

    这是一个简单的bean配置(web.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"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    	<bean id="user" class="com.example.bean.User"/>
    
    </beans>
    

    这是加载bean的示例代码:

    public class TestBean {
    	@Test
    	public void testBean() {
    		//创建默认bean工厂
    		DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    		//创建bean定义读取器
    		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    		//获取资源
    		ClassPathResource resource = new ClassPathResource("web.xml");
    		//装载资源
    		reader.loadBeanDefinitions(resource);
    		//获取bean
    		User user = factory.getBean("user", User.class);
    		user.setName("小红");
    		System.out.println(user.getName());
    	}
    }
    

    Bean从何来
    下面,我将按以下顺序介绍Spring是如何通过Xml配置装载Bean:

    • ClassPathResource
      对Xml配置文件进行封装
    • XmlBeanDefinitionReader
      把封装好的Xml(Resource)解析为BeanDefinition
    • DefaultListableBeanFactory
      -把BeanDefinition装载在进Bean工厂中

    ClassPathResource

    先看看类图:
    在这里插入图片描述
    再看看源码:

    
    public ClassPathResource(String path) {
    	this(path, (ClassLoader) null);
    }
    
    public ClassPathResource(String path, @Nullable ClassLoader classLoader) {
    	Assert.notNull(path, "Path must not be null");
    	String pathToUse = StringUtils.cleanPath(path);
    	if (pathToUse.startsWith("/")) {
    		pathToUse = pathToUse.substring(1);
    	}
    	this.path = pathToUse;
    	this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
    }
    

    Spring对Xml配置文件的封装,其实就是为了通过ClassPathResource得到java.io.InputStream。可以看到InputStreamSource里面只有一个方法。

    public interface InputStreamSource {
    
    	/**
    	 * Return an {@link InputStream} for the content of an underlying resource.
    	 * <p>It is expected that each call creates a <i>fresh</i> stream.
    	 * <p>This requirement is particularly important when you consider an API such
    	 * as JavaMail, which needs to be able to read the stream multiple times when
    	 * creating mail attachments. For such a use case, it is <i>required</i>
    	 * that each {@code getInputStream()} call returns a fresh stream.
    	 * @return the input stream for the underlying resource (must not be {@code null})
    	 * @throws java.io.FileNotFoundException if the underlying resource doesn't exist
    	 * @throws IOException if the content stream could not be opened
    	 */
    	InputStream getInputStream() throws IOException;
    
    }
    

    Resoure则抽象出了Spring对资源对象操作的各种方法:

    public interface Resource extends InputStreamSource {
    
    	/**
    	 * 确定资源是否存在
    	 */
    	boolean exists();
    
    	/**
    	 * 是否可读
    	 */
    	default boolean isReadable() {
    		return exists();
    	}
    
    	/**
    	 * 判断资源是否已经被打开
    	 */
    	default boolean isOpen() {
    		return false;
    	}
    
    	/**
    	 * 是否为文件
    	 */
    	default boolean isFile() {
    		return false;
    	}
    
    	/**
    	 * 返回此资源的URL
    	 */
    	URL getURL() throws IOException;
    
    	/**
    	 * 返回此资源的URI
    	 */
    	URI getURI() throws IOException;
    
    	/**
    	 * 把资源转换为File
    	 */
    	File getFile() throws IOException;
    
    	/**
    	 * 返回一个可以读取字节的通道
    	 */
    	default ReadableByteChannel readableChannel() throws IOException {
    		return Channels.newChannel(getInputStream());
    	}
    
    	/**
    	 * 确定此资源的内容长度
    	 */
    	long contentLength() throws IOException;
    
    	/**
    	 * 确定此资源的最后修改的时间戳
    	 */
    	long lastModified() throws IOException;
    
    	/**
    	 * 创建与此资源相关的资源
    	 */
    	Resource createRelative(String relativePath) throws IOException;
    
    	/**
    	 * 确定此资源的文件名,通常是路径的最后部分,比如 "myfile.txt"
    	 */
    	@Nullable
    	String getFilename();
    
    	/**
    	 * 返回此资源的描述,用作使用该资源时的错误输出
    	 */
    	String getDescription();
    
    }
    

    对不同来源的资源文件都有相应的 Resource 实现,如 文件( FileSystemResource)、 Classpath 资源( ClassPathResource )、 URL 资源( UrlResource )、 InputStream 资源( InputStreamResource)、Byte 数组( ByteArrayResource )等。
    在这里插入图片描述
    在日常的开发中,也可以用到Spring这些类,比如,在加载ClassPath路径下的文件时,可以使用以下操作:

    ClassPathResource resource = new ClassPathResource("web.xml");
    InputStream inputStream = resource.getInputStream();
    

    XmlBeanDefinitionReader

    当通过Resource完成对Xml配置文件的封装后,文件的读取就交给XmlBeanDefinitionReader了。
    在前面的代码中,reader.loadBeanDefinitions(resource),这个loadBeanDefinitions就是读取Xml。下面看看源码:

    //进来就把Resource封装成EncodedResource,当设置了文件编码属性的时候 Spring会使用相应的编码作为输入流的编码
    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    	//以某种编码读取resource,默认不指定编码
    	return loadBeanDefinitions(new EncodedResource(resource));
    }
    
    
    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    	.......
    	//ThreadLocal,保证加载资源时线程安全和高效
    	Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    	//添加source前判断是否已存在加载过的source,避免循环加载
    	if (!currentResources.add(encodedResource)) {
    		throw new BeanDefinitionStoreException(
    				"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    	}
    	//从EncodedResource中获取对应的 InputStream 并构造 InputSource
    	try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
    		InputSource inputSource = new InputSource(inputStream);
    		if (encodedResource.getEncoding() != null) {
    			inputSource.setEncoding(encodedResource.getEncoding());
    		}
    		//在Spring里面,do方法才是真正干活的
    		return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
    	}
    	......
    	finally {
    		currentResources.remove(encodedResource);
    		if (currentResources.isEmpty()) {
    			//使用ThreadLocal后及时调用remove方法,防止内存泄漏
    			this.resourcesCurrentlyBeingLoaded.remove();
    		}
    	}
    }
    

    而在方法中,就做了两件事:

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
    		throws BeanDefinitionStoreException {
    	try {
    		//把source封装成Document
    		Document doc = doLoadDocument(inputSource, resource);
    		//根据Document注册bean信息
    		int count = registerBeanDefinitions(doc, resource);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Loaded " + count + " bean definitions from " + resource);
    		}
    		return count;
    	}
    	catch (BeanDefinitionStoreException ex) {
    

    下面我们来详细看看这两件事具体是怎么做的:

    1. 首先,doLoadDocument方法把source封装成了Document。
    protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    	return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
    			getValidationModeForResource(resource), isNamespaceAware());
    }
    

    这里面有两个方法需要说明一下:

    • getEntityResolver
      Spring是使用SAX解析XML文档的,在解析XML文档时,SAX首先读取该XML档上的声明,根据声明去寻找相应的DTD定义,以便对文档进行一个验证。默认的寻找规则,就是通过网络(实现上就是声明的DTD URI地址)来下载相应的DTD声明,并进行认证。而下载的过程是一个漫长的过程,而且当网络中断或不可用时,这里会报错,就是因为相应的DTD声明没有被找到的原。而getEntityResolver方法的作用是项目本身就可以提供一个如何寻找DTD声明的方法,比如我们将DTD文件放到项目中某处,在实现时直接将此文档读取并返回给SAX即可,这样就避免了通过网络来找相应的声明。默认情况下,Spring的DTD文件放在此路径: /org/springframework/beans/factory/xml/,Spring会首先从这个目录去获取规范文件,如果找不到去项目路径下载找,再找不到就通过网络下载。
    • getValidationModeForResource
      用来判断xml文件使用DTD模式还是XSD模式校验。先判断使用功能什么验证模式,如果手动指定了验证模式则使用指定的验证模式,如果未指定则使用自动检测,自动检测其实就是判断文件是否具有{DOCTYPE} 定义,有则使用DTD验证,无则采用XSD验证。

    至于loadDocument就是普通的SAX解析 XML文档的套路:通过factory创建builder,再通过builder解析source获取document。

    public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
    		ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
    
    	DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
    	if (logger.isTraceEnabled()) {
    		logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
    	}
    	DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
    	return builder.parse(inputSource);
    }
    
    1. 然后,registerBeanDefinitions才是提取和注册bean的地方。点进去可以发现实际调用的是DefaultBeanDefinitionDocumentReader里面的方法:
    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    	this.readerContext = readerContext;
    	doRegisterBeanDefinitions(doc.getDocumentElement());
    }
    
    /**
     * 在给定的根{@code <beans />}元素中注册每个bean定义。
     * 任何嵌套的<beans>元素都将导致此方法中的递归
     */
    protected void doRegisterBeanDefinitions(Element root) {
    	BeanDefinitionParserDelegate parent = this.delegate;
    	this.delegate = createDelegate(getReaderContext(), root, parent);
    
    	if (this.delegate.isDefaultNamespace(root)) {
    		//处理profile属性,profile=("dev",""test,"prod"),用来区分开发、测试和生产环境的配置:<beans profile="dev"></beans>
    		String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
    		if (StringUtils.hasText(profileSpec)) {
    			String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
    					profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
    			if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
    							"] not matching: " + getReaderContext().getResource());
    				}
    				return;
    			}
    		}
    	}
    	/*模板方法模式*/
    
    	//解析前处理(空方法,留给子类实现)
    	preProcessXml(root);
    	parseBeanDefinitions(root, this.delegate);
    	//解析后处理(空方法,留给子类实现)
    	postProcessXml(root);
    
    	this.delegate = parent;
    }
    
    //解析并注册bean
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    	//如果是默认的命名空间
    	if (delegate.isDefaultNamespace(root)) {
    		NodeList nl = root.getChildNodes();
    		for (int i = 0; i < nl.getLength(); i++) {
    			Node node = nl.item(i);
    			if (node instanceof Element) {
    				Element ele = (Element) node;
    				//解析默认bean配置,如<bean id="test" class="test.TestBean" />
    				if (delegate.isDefaultNamespace(ele)) {
    					parseDefaultElement(ele, delegate);
    				}
    				//解析自定义配置,如<tx :annotation-driven/>
    				else {
    					delegate.parseCustomElement(ele);
    				}
    			}
    		}
    	}
    	else {
    		delegate.parseCustomElement(root);
    	}
    }
    

    至于详细的解析bean标签的过程,请看下回分解。
    下面附上代码流程的UML图。
    在这里插入图片描述

    展开全文
  • 问题报错提示 java.lang.IllegalStateException: Unable to find a @...test文件夹和main文件夹目录结构不一致,导致无法正常启动,同时在test类中也无法正常的注入bean 解决 更改目录结构】 ...

    问题报错提示

    java.lang.IllegalStateException: Unable to find a @SpringBootConfiguration, you need to use @ContextConfiguration or @SpringBootTest(classes=…) with your test
    在这里插入图片描述

    问题原因

    test文件夹和main文件夹目录结构不一致,导致无法正常启动,同时在test类中也无法正常的注入bean
    目录结构不一致
    无法自动装载bean

    解决

    更改目录结构】
    在这里插入图片描述

    展开全文
  • SpringBoot装载bean的几种方式

    千次阅读 2018-05-29 21:31:00
    * @Description: @Import用来导入一个或多个普通类(bean会被spring容器托管),或者配置类(配置类中的bean都会被spring容器托管) * @author Liu * @date 2018年6月10日 下午6:21:28 * */ @ComponentScan @Import...

    一、直接装配

    package com.lh.bean;
    
    /** 
    * @ClassName: MyBean 
    * @Description: 简单直接方式注入bean
    * @author Liu 
    * @date 2018年5月26日 下午6:21:44 
    */
    public class MyBean {
    
    }
    
    	/***
    	* @Title: createMyBean 
    	* @Description: 1、返回bean名称默认为方法名
    	* 				2、同时也可以手动指定bean名称
    	* @param @return  
    	* @return MyBean
    	* @throws
    	 */
    	@Bean(name = "myBean")
    	@Scope("prototype")//指定为原型方式,即多例
    	public MyBean createMyBean() {
    		return new MyBean();
    	}

    二、FactoryBean工厂方式

    package com.lh.bean2;
    
    import org.springframework.beans.factory.FactoryBean;
    
    /** 
    * @ClassName: RunnableFactoryBean 
    * @Description: TODO
    * @author Liu 
    * @date 2018年5月26日 下午6:44:07 
    */
    public class JeepFactoryBean implements FactoryBean<Jeep> {
    
    	@Override
    	public Jeep getObject() throws Exception {
    		return new Jeep();
    	}
    
    	@Override
    	public Class<?> getObjectType() {
    		return Jeep.class;
    	}
    
    	@Override
    	public boolean isSingleton() {
    //		return true;
    		return false;
    	}
    
    }
    
    	@Bean
    	public JeepFactoryBean createJeepFactoryBean() {
    		return new JeepFactoryBean();
    	}

        注:获取FactoryBean本身的方式需要在bean名称前加"&"或直接以类型获取:

    		//获取FactoryBean本身
    		System.out.println(ctx.getBean(JeepFactoryBean.class));//class方式
    		System.out.println(ctx.getBean("&createJeepFactoryBean"));//name方式

    三、普通工厂模式方式

    package com.lh.bean3;
    
    /** 
    * @ClassName: JeepFactory 
    * @Description: TODO
    * @author Liu 
    * @date 2018年5月26日 下午9:59:06 
    */
    public class CarFactory {
    	public Car create() {
    		return new Car();
    	}
    }
    
    package com.lh.bean3;
    
    /** 
    * @ClassName: Car 
    * @Description: 自定义工厂类创建实体,实体创建依赖之前定义的工厂类
    * @author Liu 
    * @date 2018年5月26日 下午10:04:06 
    */
    public class Car {
    
    }
    
    	@Bean
    	public CarFactory createCarFactory() {
    		return new CarFactory();
    	}
    
    	@Bean
    	public Car createCar(CarFactory carFactory) {
    		return carFactory.create();
    	}

    四、注解方式

        @Controller/@Service/@Repository/@Component

    五、@Import方式

    package com.lh;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.context.annotation.ComponentScan;
    
    import com.lh.bean.EnableLog;
    import com.lh.bean.Role;
    import com.lh.bean.User;
    import com.lh.exercise.EnableEcho;
    
    /***
     * 
    * @ClassName: App 
    * @Description: @Import用来导入一个或多个普通类(bean会被spring容器托管),或者配置类(配置类中的bean都会被spring容器托管)
    * @author Liu 
    * @date 2018年6月10日 下午6:21:28 
    *
     */
    
    @ComponentScan
    @Import({User.class,Role.class,MyConfiguration.class})
    public class App2 
    {
        public static void main( String[] args )
        {
        	ConfigurableApplicationContext context = SpringApplication.run(App2.class, args);
        	
        	System.out.println(context.getBean(User.class));
        	System.out.println(context.getBean(Role.class));
        	System.out.println(context.getBeansOfType(Runnable.class));
        	
        	context.close();
        }
    }
    
    package com.lh.bean;
    
    /** 
    * @ClassName: Role 
    * @Description: TODO
    * @author Liu 
    * @date 2018年6月10日 下午6:58:55 
    */
    public class Role {
    
    }
    
    package com.lh.bean;
    
    /** 
    * @ClassName: User 
    * @Description: TODO
    * @author Liu 
    * @date 2018年6月10日 下午6:58:48 
    */
    public class User {
    
    }
    
    package com.lh.bean;
    
    import org.springframework.context.annotation.Bean;
    
    /** 
    * @ClassName: MyConfiguration 
    * @Description: TODO
    * @author Liu 
    * @date 2018年6月10日 下午7:05:38 
    */
    public class MyConfiguration {
    	@Bean
    	public Runnable createRunnable() {
    		return () -> {};
    	}
    	
    	@Bean
    	public Runnable createRunnable2() {
    		return () -> {};
    	}
    }
    

        注:

            1、@Import用来导入一个或多个普通类(bean会被spring容器托管),或者配置类(配置类中的bean都会被spring容器托管

            2、不要在类上加任何注解,否则@Import注解失去意义!

    六、通过扫描指定包装载bean

    package com.lh;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.lh.bean3.Car;
    import com.lh.bean4.Cat;
    import com.lh.bean5.Dog;
    import com.lh.bean6.Animal;
    import com.lh.bean7.User;
    
    /**
     * @ClassName: AnnotationClient
     * @Description: TODO
     * @author Liu
     * @date 2018年5月28日 下午10:42:55
     */
    public class AnnotationClient {
    
    	public static void main(String[] args) {
    		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext("com.lh");
    		System.out.println(ctx.getBean("&createJeepFactoryBean"));// name方式
    
    		System.out.println(ctx.getBean(Car.class));
    
    		System.out.println(ctx.getBean(Cat.class));
    
    		System.out.println(ctx.getBean(Dog.class));
    
    		System.out.println(ctx.getBean(Animal.class));
    		
    		System.out.println(ctx.getBean("myUser"));
    		ctx.close();
    	}
    
    }
    

    七、指定哪些bean可以装配

    package com.lh;
    
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.lh.bean10.UserController;
    import com.lh.bean3.Car;
    import com.lh.bean4.Cat;
    import com.lh.bean5.Dog;
    import com.lh.bean6.Animal;
    
    /**
     * @ClassName: AnnotationClient
     * @Description: TODO
     * @author Liu
     * @date 2018年5月28日 下午10:42:55
     */
    public class AnnotationClient2 {
    
    	public static void main(String[] args) {
    		AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(AnnotationScan.class);
    		System.out.println(ctx.getBean("&createJeepFactoryBean"));// name方式
    
    		System.out.println(ctx.getBean(Car.class));
    
    		System.out.println(ctx.getBean(Cat.class));
    
    		System.out.println(ctx.getBean(UserController.class));
    		
    		System.out.println(ctx.getBean(Dog.class));
    		
    
    		System.out.println(ctx.getBean(Animal.class));
    		ctx.close();
    	}
    
    }
    
    package com.lh;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScan.Filter;
    
    import com.lh.bean10.UserController;
    
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.FilterType;
    
    /** 
    * @ClassName: AnnotationScan 
    * @Description: TODO
    * @author Liu 
    * @date 2018年5月28日 下午10:47:35 
    */
    @ComponentScan(basePackages = "com.lh", excludeFilters = @Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {DogConfig.class,UserController.class}))
    @Configuration
    public class AnnotationScan {
    
    }
    
    package com.lh;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import com.lh.bean5.Dog;
    
    /** 
    * @ClassName: DogConfig 
    * @Description: TODO
    * @author Liu 
    * @date 2018年5月28日 下午10:53:48 
    */
    @Configuration
    public class DogConfig {
    	@Bean(initMethod = "init",destroyMethod="destroy")
    	public Dog createDog() {
    		return new Dog();
    	}
    }
    
    package com.lh.bean10;
    
    import org.springframework.stereotype.Controller;
    
    /** 
    * @ClassName: UserController 
    * @Description: TODO
    * @author Liu 
    * @date 2018年5月28日 下午9:46:28 
    */
    @Controller//一般用于展现层
    public class UserController {
    
    }
    

     

    转载于:https://my.oschina.net/Howard2016/blog/1820786

    展开全文
  • spring IOC反射装载bean

    2017-03-04 15:46:39
    spring基于xml配置加载bean 的demo 了解spring的反射机制
  • 解析XML与装载BeanDefinition 资源定位 resource Spring的配置文件读取是通过ClassPathResource进行封装的,这也正对应了上述方法中的参数,不过 Resource 是一个接口,在此不做过多阐述。 资源预处理 ...
  • 使用注解装载Bean的步骤: 目录 一、扫描 二、装载 三、注入 一、扫描 两种方式: a.使用注解 @ComponentScan ApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationConfi...
  • Spring中,有BeanFactory和ApplicationContext两个容器用来加载Bean,这两个容器都是通过XML文件配置的。区别在于: BeanFactory容器中,若Bean的一个属性没有注入,那么在业务中调用getBean就会报错。但该容器占用...
  • 使用Qualifier指定注入Bean的名称 实例 对类方法进行标注 实例 小结 对集合类进行标注 实例 对延迟依赖注入的支持 实例 对标准注解的支持 实例 小结使用@Autowired进行自动注入Spring通过@Autowired注解实现Bean的...
  • 可以通过@Resource(name="beanName") 指定被注入的bean的名称, 要是未指定name属性, 默认使用成员属性的变量名,一般不用写name属性. @Resource(name="beanName")指定了name属性,按名称注入但没找到bean, 就不会再...
  • 1.新建一个module 选择模板新建框架 ...新建一个maven项目,使用maven...在上述配置过程没有错误的前提下,新建一个resources文件夹,在文件夹下新建一个支持spring的xml文件,在其中配置完对应的bean @Tes..
  • } } 我们就从AnnotationConfigApplicationContext这个类开始,探究下Spring的IOC容器是如何装载Bean的,源码如下: public AnnotationConfigApplicationContext(Class... annotatedClasses) { this(); register...
  • Spring-Boot基于配置按条件装载Bean

    千次阅读 2019-01-04 20:23:12
    背景 同一个接口有多种实现,项目启动时按某种规则来选择性的启用其中...看到这里,我们会想到使用SPI机制,或Spring按条件加载Bean机制来实现,下面主要讨论后者。 定义接口 定义2个Service层接口:OrderService、O...
  • 在上一篇中讲了关于怎么在xml中实例化bean,那么,在本篇中我们来看一下java是怎么配置bean的实例化。 第一步 准备 1、新建接口AnimalService,并提供一个eat方法 2、新建接口AnimalService2并提供一个eat方法...
  • Bean的动态装载

    2021-11-23 23:39:42
    下面是我用spi实现的...Bean的动态装载有两种方式: ImportSelector ImportBeanDefinitionRegistrar 下面我们用两种方式来实现Bean的动态状态。 一、ImportSelector实现bean的动态装载 1.1 自定义类实现ImportS.
  • 先贴spring的开发文档,有助于大家学习http://shouce.jb51.net/spring/beans.html#beans-factory-class一直想研究一下spring bean的控制反转的实现,废话不多说。1、先建了一个WEB工程,导入相关spring的jar包,装载...
  • Springboot错误处理:无法自动装载bean

    千次阅读 2018-12-04 14:22:35
    Idea中开发Springboot应用时,代码编辑器提示:无法自动装载bean。 报错提示 解决方法 在UserDao 类上面,添加@Repository注解 其他附属信息 @Respository 所属包: org.springframework.stereotype.Repository @...
  • 通过前面两节的学习我们已经知道了Spring是如何解析XML与装载BeanDefinition的;在本章节中我们将继续学习bean的装载过程这将会面临更大的挑战,bean加载的功能实现远比bean的解析要复杂得多,不过没关系,步步深入...
  • 装载Bean失败

    2018-01-17 14:45:08
    Error creating bean with name 'activationController': Injection of autowired dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Could not autowi
  • //通过注解的方式去装载bean ApplicationContext context = new AnnotationConfigApplicationContext(StudentConfig.class); Student stu = context.getBean(Student.class); System.out.println(stu);
  • spring中bean装载

    千次阅读 2018-10-26 20:45:21
    一:spring 对bean装载方式 spring 对bean装载方式存在三种: 在xml中进行显式配置; 在java中进行显式配置; 隐式的bean发现机制和自动装配; 二:自动化装配bean spring 从两个角度来实现自动化装配: 组件...
  • xml方式装载bean

    2017-05-10 11:21:02
    bean的属性配置 一直用注解,避免不了读一些代码时别人用配置方式,这里备份下一些用法: bean元素可以有许多属性,其中有两个是必须的:id和class 。如果使用设值注入,则需要使用property子标签,来指定组件的...
  • // DefaultBeanDefinitionDocumentReader.java @Override public void registerBeanDefinitions(Document doc, ... // 执行注册 BeanDefinition doRegisterBeanDefinitions(doc.getDocumentElement()); }
  • bean工厂延迟加载所以bean,直到getBean()方法被调用的时候才会创建bean的实例对象。 ApplicationContext在启动后预载入所有单例bean,需要的时候直接getBean()取出即可,这样可以确保应用不需要等待他们被创建。 ...
  • ![![![图片说明](https://img-ask.csdn.net/upload/201704/15/1492226894_946055.png)图片说明](https://img-ask.csdn.net/upload/201704/15/1492226884_963107.png)图片说明]...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,381
精华内容 13,352
关键字:

装载bean

友情链接: uswm.rar