Spring注解开发之自动装配

最新推荐文章于 2023-06-16 14:12:16 发布

深蓝海威

最新推荐文章于 2023-06-16 14:12:16 发布

阅读量187

点赞数

分类专栏： java 文章标签： Spring注解开发自动装配

本文链接：https://blog.csdn.net/Mokyskury/article/details/90168802

版权

java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Spring注解开发之自动装配

自动装配：

Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值；

1、@Autowired & @Qualifier & @Primary

1）、@Autowired：自动注入：

1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋

值
2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找

applicationContext.getBean(“bookDao”)
3）、@Qualifier(“bookDao”)：使用@Qualifier指定需要装配的组件的id，而不是使用属性名
4）、自动装配默认一定要将属性赋值好，没有就会报错；
```
   可以使用@Autowired(required=false);
```
5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；

也可以继续使用@Qualifier指定需要装配的bean的名字，如果这两个同时使用，@Qualifier的优先级高于@Primary

/名字默认是类名首字母小写
@Repository
public class BookDao {
	
	private String lable = "1";

	public String getLable() {
		return lable;
	}

	public void setLable(String lable) {
		this.lable = lable;
	}

	@Override
	public String toString() {
		return "BookDao [lable=" + lable + "]";
	}

}

@Configuration
@ComponentScan({"com.atguigu.service","com.atguigu.dao",
   "com.atguigu.controller","com.atguigu.bean"})
public class MainConifgOfAutowired {
   
   @Primary
   @Bean("bookDao2")
   public BookDao bookDao(){
      BookDao bookDao = new BookDao();
      bookDao.setLable("2");
      return bookDao;
   }

@Service
public class BookService {
	
	@Qualifier("bookDao")
	@Autowired(required=false)
	//@Autowired
	private BookDao bookDao2;
	
	public void print(){
		System.out.println(bookDao2);
	}

	@Override
	public String toString() {
		return "BookService [bookDao=" + bookDao2 + "]";
	}
}

	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConifgOfAutowired.class);
		
		BookService bookService = applicationContext.getBean(BookService.class);
		System.out.println(bookService);
		
		BookDao bean = applicationContext.getBean(BookDao.class);
		System.out.println(bean);

		applicationContext.close();
	}

2、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]

@Resource:

可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；

没有能支持@Primary功能没有支持@Autowired（reqiured=false）;

@Service
public class BookService {
	
	//@Qualifier("bookDao")
	//@Autowired(required=false)
	@Resource(name="bookDao2")
	//@Autowired
	//@Resource
	private BookDao bookDao;
	
	public void print(){
		System.out.println(bookDao);
	}

	@Override
	public String toString() {
		return "BookService [bookDao=" + bookDao + "]";
	}

}

@Inject:

需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；

<!-- https://mvnrepository.com/artifact/javax.inject/javax.inject -->
		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>

@Service
public class BookService {
   
   //@Qualifier("bookDao")
   //@Autowired(required=false)
   //@Resource(name="bookDao2")
   @Inject
   //@Autowired
   //@Resource
   private BookDao bookDao;
   
   public void print(){
      System.out.println(bookDao);
   }

   @Override
   public String toString() {
      return "BookService [bookDao=" + bookDao + "]";
   }
}

@Autowired:Spring定义的； @Resource、@Inject都是java规范
AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；

3、@Autowired:构造器、参数、方法、属性都是从容器中获取参数组件的值

 1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;**默认不写@Autowired效果是一样的；都能自动装配**

 2）、[标在构造器上]：**如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略**，参数位置的组件还是可以自动从容器中获取

```
 3）、放在参数位置：
```

//默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss {
	
	
	private Car car;
	
	//构造器要用的组件，都是从容器中获取
//	public Boss(Car car){
//		this.car = car;
//		System.out.println("Boss...有参构造器");
//	}
	
	

	public Car getCar() {
		return car;
	}



	//标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值；
	//方法使用的参数，自定义类型的值从ioc容器中获取
	@Autowired
	public void setCar(Car car) {
		this.car = car;
	}



	@Override
	public String toString() {
		return "Boss [car=" + car + "]";
	}

}

//默认加在ioc容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作
@Component
public class Boss {
	
	
	private Car car;
	
	//构造器要用的组件，都是从容器中获取
	public Boss(Car car){
		this.car = car;
		System.out.println("Boss...有参构造器");
	}
	
	

	public Car getCar() {
		return car;
	}


	//标注在方法，Spring容器创建当前对象，就会调用方法，完成赋值；
	//方法使用的参数，自定义类型的值从ioc容器中获取
	public void setCar(Car car) {
		this.car = car;
	}



	@Override
	public String toString() {
		return "Boss [car=" + car + "]";
	}
}

@Configuration
@ComponentScan({"com.atguigu.service","com.atguigu.dao",
	"com.atguigu.controller","com.atguigu.bean"})
public class MainConifgOfAutowired {
	
	/**
	 * @Bean标注的方法创建对象的时候，方法参数的值从容器中获取
	 * @param car
	 * @return
	 */
	@Bean
	public Color color(Car car){
		Color color = new Color();
		color.setCar(car);
		return color;
	}

}

public class Color {
	
	private Car car;

	public Car getCar() {
		return car;
	}

	public void setCar(Car car) {
		this.car = car;
	}

	@Override
	public String toString() {
		return "Color [car=" + car + "]";
	}

4、Aware注入Spring底层组件&原理

自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）：

 自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；

 把Spring底层一些组件注入到自定义的Bean中；

 xxxAware：功能使用xxxProcessor；

 	ApplicationContextAware==》ApplicationContextAwareProcessor；

原理：Bean在创建对象的时候后置处理器会查看是否实现了XXXAware接口，如果实现了，会调用对应的方法将组件注入到方法中

@Component
public class Red implements ApplicationContextAware,BeanNameAware,EmbeddedValueResolverAware {
	
	private ApplicationContext applicationContext;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("传入的ioc："+applicationContext);
		this.applicationContext = applicationContext;
	}

	@Override
	public void setBeanName(String name) {
		// TODO Auto-generated method stub
		System.out.println("当前bean的名字："+name);
	}

	@Override
	public void setEmbeddedValueResolver(StringValueResolver resolver) {
		// TODO Auto-generated method stub
		String resolveStringValue = resolver.resolveStringValue("你好 ${os.name} 我是 #{20*18}");
		System.out.println("解析的字符串："+resolveStringValue);
	}

}

例如在ApplicationContextAwareProcessor中：

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
        AccessControlContext acc = null;
        if (System.getSecurityManager() != null && (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    ApplicationContextAwareProcessor.this.invokeAwareInterfaces(bean);
                    return null;
                }
            }, acc);
        } else {
            this.invokeAwareInterfaces(bean);
        }

        return bean;
    }

private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof EnvironmentAware) {
                ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
            }

            if (bean instanceof EmbeddedValueResolverAware) {
                ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
            }

            if (bean instanceof ResourceLoaderAware) {
                ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
            }

            if (bean instanceof ApplicationEventPublisherAware) {
                ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
            }

            if (bean instanceof MessageSourceAware) {
                ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
            }

            if (bean instanceof ApplicationContextAware) {
                ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
            }
        }

    }

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext var1) throws BeansException;
}

5、@Profile 根据环境注册bean

@Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件

1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境
2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效
3）、没有标注环境标识的bean在，任何环境下都是加载的；

dbconfig.properties

db.user=root
db.password=root
db.driverClass=com.mysql.jdbc.Driver

@PropertySource("classpath:/dbconfig.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware{
	
	@Value("${db.user}")
	private String user;
	
	private StringValueResolver valueResolver;
	
	private String  driverClass;

	@Bean
	public Yellow yellow(){
		return new Yellow();
	}
	
	@Profile("test")
	@Bean("testDataSource")
	public DataSource dataSourceTest(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mytest");
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}
	
	
	@Profile("dev")
	@Bean("devDataSource")
	public DataSource dataSourceDev(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/mydev");
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}
	
	@Profile("prod")
	@Bean("prodDataSource")
	public DataSource dataSourceProd(@Value("${db.password}")String pwd) throws Exception{
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		dataSource.setUser(user);
		dataSource.setPassword(pwd);
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/myprod");
		
		dataSource.setDriverClass(driverClass);
		return dataSource;
	}

	@Override
	public void setEmbeddedValueResolver(StringValueResolver resolver) {
		// TODO Auto-generated method stub
		this.valueResolver = resolver;
		driverClass = valueResolver.resolveStringValue("${db.driverClass}");
	}

}

public class IOCTest_Profile {
	
	//1、使用命令行动态参数: 在虚拟机参数位置加载 -Dspring.profiles.active=test
	//2、代码的方式激活某种环境；
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = 
				new AnnotationConfigApplicationContext();
		//1、创建一个applicationContext
		//2、设置需要激活的环境
		applicationContext.getEnvironment().setActiveProfiles("dev");
		//3、注册主配置类
		applicationContext.register(MainConfigOfProfile.class);
		//4、启动刷新容器
		applicationContext.refresh();
		
		
		String[] namesForType = applicationContext.getBeanNamesForType(DataSource.class);
		for (String string : namesForType) {
			System.out.println(string);
		}
		
		Yellow bean = applicationContext.getBean(Yellow.class);
		System.out.println(bean);
		applicationContext.close();
	}

}

深蓝海威

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring注解开发之自动装配

Spring注解开发之自动装配自动装配：Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值；1、@Autowired & @Qualifier & @Primary1）、@Autowired：自动注入：1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋...
复制链接

扫一扫