1.属性赋值
使用@Value赋值：
1.基本数值
2.可以写SpEL； #{}
3.可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值）
public class Person {
//@Value注解既1.可以完成基本的变量赋值
// 2.spEL 取值例如 @Value("#{20-2}")
//3.读取配置文件的值并赋值 @Value("${XX}")
@Value("zhangsan")
private String name;
@Value("#{20-2}")
private int age;
private String grader;
@Value("${person.nickName}")
private String nikName;
public Person(String name, int age, String grader) {
this.name = name;
this.age = age;
this.grader = grader;}
}
配置类：
@PropertySource：读取外部配置文件中的 K / V 保存到运行环境变量中；加载完外部的配置文件以后使用${}取出配置文件的值。
@PropertySource(value = {"classpath:/person.properties"})//可以导入外部的配置文件
@Configuration
public class MainConfigOfValue {
@Bean
public Person person(){
return new Person();
}
}
测试类
public class TestProperties {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfValue.class);
@Test
public void test1(){
printName(context);
System.out.println("======");
Person person = (Person) context.getBean("person");
System.out.println(person);
//可以通过运行环境来获取配置文件中的数据
ConfigurableEnvironment environment = context.getEnvironment();
String property = environment.getProperty("person.nickName");
System.out.println("运行环境取配置文件中的值： "+property);
context.close();
}
public void printName(AnnotationConfigApplicationContext annotationConfigApplicationContext){
String[] names = annotationConfigApplicationContext.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
}
2.自动装配
2.1什么是自动装配？
Spring利用依赖注入（DI），完成对IOC容器中各个组件的依赖关系赋值；
2.2@Autowired基本使用
-默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class) 找到就赋值；
@Service
public class BookService {
@Autowired//将BookDao组件装配到当前组件中，找到就赋值
BookDao bookDao;(1)
}
public class AutowiredTest {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfigAutowired.class);
@Test
public void test1(){
printName(context);
Object bookService = context.getBean(BookService.class);
System.out.println(bookService);
BookDao bean = context.getBean(BookDao.class);
System.out.println(bean);
}
public void printName(AnnotationConfigApplicationContext annotationConfigApplicationContext){
String[] names = annotationConfigApplicationContext.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
}
}
-如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找 applicationContext.getBean(“bookDao”)
@ComponentScan({"com.zy.service","com.zy.dao"})
@Configuration
public class MainAutowiredConfig {
@Bean("bookDao2") (2)
public BookDao bookDao(){
BookDao bookDao = new BookDao();
bookDao.setTag("2");
return bookDao;
}
}
那么上面的两段代码都有相同类型BookDao组件，这种情况下按照属性名称找对应的组件，找到就赋值；
如上面代码①处 ，属性名是bookDao，则找该组件，如果①处 属性名改为成 ②处的名字( bookDao2) ，这种情况则找id为bookDao2的组件。
@Autowired 详解
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
/**
* Declares whether the annotated dependency is required.
* <p>Defaults to {@code true}.
*/
boolean required() default true;
}
从@Autowired定义来看，该注解可修饰 构造器、方法、参数、属性、注解
标注在方法上：根据方法的形参，从容器中查找
2.3@Qualifler
@Qualifier指定需要装配的组件的id，而不是使用属性名
@Service
public class BookService {
@Qualifier("bookDao2")
@Autowired
private BookDao bookDao;
public void print(){
System.out.println(bookDao);
}
@Override
public String toString() {
return "BookService{" + "bookDao=" + bookDao + '}';
}
}
2.4@Primary
让Spring进行自动装配的时候，默认使用首选的bean；
也可以继续使用@Qualifier指定需要装配的bean的名字；
@ComponentScan({"com.zy.service","com.zy.dao"})
@Configuration
public class MainAutowiredConfig {
@Primary
@Bean("bookDao2")
public BookDao bookDao(){
BookDao bookDao = new BookDao();
bookDao.setTag("2");
return bookDao;
}
}//在没有使用@Qualifier指定装配的情况下，上面的代码则会，首选装配 bookDao2组件
--------------------------------------------------------------------
@Service
public class BookService {
@Qualifier("bookDao")
@Autowired
private BookDao bookDao;
}
@Primary和 @Qualifier("bookDao") 都在使用的话，则 使用@Qualifier("bookDao")指定的组件
2.5@Aurowired(required=fasle)
因为 required=false，如果spring找不到对应的组件的话会赋空值进去；
@Service
public class BookService {
@Autowired(required = false)//如果容器中没有BookDao组件的话， 则bookDao=null
private BookDao bookDao;
public void print(){
System.out.println(bookDao);
}
@Override
public String toString() {
return "BookService{" + "bookDao=" + bookDao + '}';
}
}
2.6 @Resource(JSR250)
@Resource：默认是按照组件名称进行装配的；
@Service
public class BookService {
// @Qualifier("bookDao2")
// @Autowired(required = false)
@Resource
private BookDao bookDao;
public void print(){
System.out.println(bookDao);
}
@Override
public String toString() {
return "BookService{" + "bookDao=" + bookDao + '}';
}
}
//@Resource和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；没有能支持@Primary功能，
//没有支持@Autowired（reqiured=false）和 Qualifier@Resource(name = "bookDao2"),则装配bookDao2组件
2.7 @Inject(JSR330)
@Inject：需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能，加@Named注解指定bean 的Id；
@Service
public class BookService {
// @Qualifier("bookDao2")
@Inject
@Named("bookDao2")
private BookDao bookDao;
public void print(){
System.out.println(bookDao);
}
@Override
public String toString() {
return "BookService{" + "bookDao=" + bookDao + '}';
}
}//@Inject 和 @Qualifier 、@Primary 、@Named 可组合使用
2.8 @Autoried注入spring的底层组件
自定义组件想要使用Spring容器底层的组件(ApplicationContext、BeanFactory、 …)
思路: 自定义组件实现xxxAware, 在创建对象的时候, 会调用接口规定的方法注入到相关组件:XXXAware
public class Read implements ApplicationContextAware, BeanNameAware, EmbeddedValueResolverAware {
private ApplicationContext applicationContext;
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("注入的ioc容器是"+applicationContext);
this.applicationContext=applicationContext;
}
public void setBeanName(String s) {
System.out.println("注入的bean的名字是："+s);
}
public void setEmbeddedValueResolver(StringValueResolver stringValueResolver) {
String s = stringValueResolver.resolveStringValue(("你好 ${os.name} ,我是 #{20*18}");
System.out.println("解析出来的的值是"+s);
}
}
分析：Aware注入Spring底层组件原理
把Spring底层的组件可以注入到自定义的bean中，ApplicationContextAware是利用ApplicationContextAwareProcessor来处理的，
其它XXXAware也类似， 都有相关的Processor来处理，其实就是后置处理器来处理。
XXXAware---->功能使用了XXXProcessor来处理的，这就是后置处理器的作用；
ApplicaitonContextAware—>ApplicationContextProcessor后置处理器来处理的
2.9@Profile
Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能;
指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件
package com.zy.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.EmbeddedValueResolverAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.util.StringValueResolver;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
/**
* Created by MR.ZHANG on 2020/8/5 11:44
*/
@PropertySource("classpath:/db.properties")
@Configuration
public class MainConfigOfProfile implements EmbeddedValueResolverAware {
@Value("${db.user}")
private String user;
private StringValueResolver valueResolver;
private String driverClass;
@Profile("test")
@Bean("TestDateSource")
public DataSource TestDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
ComboPooledDataSource source = new ComboPooledDataSource();
source.setUser(user);
source.setPassword(pwd);
source.setJdbcUrl("jdbc:mysql://localhost:3306/db_bbs");
source.setDriverClass(driverClass);
return source;
}
@Profile("dev")
@Bean("DevDataSource")
public DataSource DevDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
ComboPooledDataSource source2 = new ComboPooledDataSource();
source2.setUser(user);
source2.setPassword(pwd);
source2.setJdbcUrl("jdbc:mysql://localhost:3306/jsp_bbs");
source2.setDriverClass(driverClass);
return source2;
}
@Profile("prod")
@Bean("ProductDataSource")
public DataSource ProductDataSource(@Value("${db.password}") String pwd) throws PropertyVetoException {
ComboPooledDataSource source1 = new ComboPooledDataSource();
source1.setUser(user);
source1.setPassword(pwd);
source1.setJdbcUrl("jdbc:mysql://localhost:3306/doudou");
source1.setDriverClass(driverClass);
return source1;
}
public void setEmbeddedValueResolver(StringValueResolver resolver) {
this.valueResolver=resolver;
driverClass = valueResolver.resolveStringValue("${db.jdbcDriver}");
}
}
测试
public class ProfilerTest {
@Test
public void test(){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfigOfProfile.class);
String[] names = context.getBeanNamesForType(DataSource.class);
for (String name : names) {
System.out.println(name);
}
}
}
结果
3。总结
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的名字
BookService{
@Autowired
BookDao bookDao;
}
2）、Spring还支持使用@Resource(JSR250)和@Inject(JSR330)[java规范的注解]
@Resource:
可以和@Autowired一样实现自动装配功能；默认是按照组件名称进行装配的；
没有能支持@Primary功能没有支持@Autowired（reqiured=false）;
@Inject:
需要导入javax.inject的包，和Autowired的功能一样。没有required=false的功能；
@Autowired:Spring定义的； @Resource、@Inject都是java规范
AutowiredAnnotationBeanPostProcessor:解析完成自动装配功能；
3）、 @Autowired:构造器，参数，方法，属性；都是从容器中获取参数组件的值
1）、[标注在方法位置]：@Bean+方法参数；参数从容器中获取;默认不写@Autowired效果是一样的；都能自动装配
2）、[标在构造器上]：如果组件只有一个有参构造器，这个有参构造器的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取
3）、放在参数位置：
4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）；
自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware；
把Spring底层一些组件注入到自定义的Bean中；
xxxAware：功能使用xxxProcessor；ApplicationContextAware==》ApplicationContextAwareProcessor；
3402
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
