转载

Spring IoC的具体使用及实现

要求:SpringToolSuite4

工程目录:(注意:工程中不需要手动添加依赖)



 

 


 Boy.java

package com.newer.ioc;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("singleton")
public class Boy {

//	对象(自动分配)
	@Autowired
	
//	明确指定要注入资源的标识名字
	@Qualifier("girl")
	Loveable lover;
	
//	public void setLover(Loveable lover) {
//		this.lover = lover;
//	}
	
//	结婚
	void marry() {
		System.out.println("boy marry...");
		lover.kiss();
	}
}


    @Autowired:(自动分配)哪个组件设置@Primary,哪个组件优先显示,不能把@Primary定义到多个组件,不然就会报错。
    @Qualifier("") :明确指定要注入资源的标识名字,前提是组件得命名好,如果一个组件没有命名,程序会默认是该类名的小写。

如果同时存在   @Autowired和  @Qualifier,以  @Qualifier优先


Dog.java

package com.newer.ioc;

import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

@Component("dog")
//首选的
@Primary
public class Dog implements Loveable {

	@Override
	public void kiss() {
		System.out.println("dog kill...");
		
	}

}

Girl.java

package com.newer.ioc;

import org.springframework.stereotype.Component;

@Component("girl")
public class Girl implements Loveable{

	@Override
	public void kiss() {
		System.out.println("Girl kiss...");
		
	}

	
}

Loveable.java

package com.newer.ioc;

import org.springframework.stereotype.Component;

@Component
public interface Loveable {
 
	void kiss();
}

IocApplication.java

package com.newer.ioc;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@SpringBootApplication
public class IocApplication {

	public static void main(String[] args) {
		SpringApplication.run(IocApplication.class, args);
	}
	
	@Bean
	public CommandLineRunner app(BeanFactory factory) {
		return new CommandLineRunner() {
			
			@Override
			public void run(String... args) throws Exception {
				
				Boy boy=factory.getBean(Boy.class);
				boy.marry();
			}
		};
	}
	
//	命令行执行
//	@Bean
	public CommandLineRunner a(BeanFactory beanFactory) {
		
//		匿名内部类
		return new CommandLineRunner() {
			
			@Override
			public void run(String... args) throws Exception {
				
//				创建时需要传递依赖的资源
//				Person p1=new Person();
				
//				把对象的创建任务交给Spring 容器
				Person p1=beanFactory.getBean(Person.class);
				
//				获得第二个Perosn实例
				Person p2=beanFactory.getBean(Person.class);
				
				p1.sayHello("spring");
				p2.sayHello("IoC");
				
//				hashcode 默认一样,散列值(对象的标示,类似指纹)
//				Java 中没有地址(指针)操作
//				Spring Bean工创建的组件对象厂默认是单例
				System.out.println(p1==p2);
				
				System.out.println(p1);
				System.out.println(p2);
			}
		};
	}

	
//	@Bean
	public CommandLineRunner b(BeanFactory beanFactory) {
		
//		接口中只有一个方法,可以简化成拉姆达表达式(js中箭头函数)
		return args->{
			
//			需要资源,向容器申请再获得
			Cat c=beanFactory.getBean(Cat.class);
			System.out.println("b: "+c);
			
			
//			Person p1=beanFactory.getBean(Person.class);
//			System.out.println("b: "+p1);
			
		};
	}
	
	
//	@Bean
	public CommandLineRunner c(ApplicationContext context) {
		return new CommandLineRunner() {
			
			@Override
			public void run(String... args) throws Exception {
				
				Cat c=context.getBean(Cat.class);
				System.out.println("c: "+c);
				
//				Person p2=beanFactory.getBean(Person.class);
//				System.out.println("b: "+p2);
				
//				context.registerShutdownHook();
//				context.close();
			}
		};
	}
}


	

Cat.java

package com.newer.ioc;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//标签,组件,spring容器会管理
@Component

//作用域,生存周期,默认是单例singleton 全局唯一
@Scope("prototype")
public class Cat {

	public  Cat() {
		System.out.println("Cat构造方法");
	}
	
//	构造后(容器回调)callback/vue 也存在钩子函数
	@PostConstruct
	public void init() {
		System.out.println(this +" , init");
	}
	
//	销毁前   自动执行(容器回调)
	@PreDestroy
	public void destory() {
		System.out.println(this +" , destory");
	}
	
	void eat() {
		
	}
	
	void run() {
		
	}
	
	void sleep() {
		
	}
}

Person.java

package com.newer.ioc;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * POJO
 * 
 * Spring IoC容器:管理组件的生命周期
 * @author Admin
 *
 */
@Component

//默认是单例作用域
//原型作用域,从容器每次获得的实例不同(工厂模式)
@Scope("prototype")
public class Person {
	
	/**
	 * 
	 * @param msg
	 */
	void sayHello(String msg) {
		System.out.println(this+" say "+msg);
	}
}

控制台执行:


对于 Spring IoC(依赖注入)的理论知识还不够理解清晰,可以去https://blog.csdn.net/weixin_44364444/article/details/105369103

看看,欢迎有问题的小伙伴留言~!!!

正文到此结束
本文目录