--- title: Spring常用注解 tags: - Spring - 注解 categories: - Spring - 用法 keywords: Spriong，框架 description: 一些常用的注解 cover: 'https://cdn.jsdelivr.net/gh/youthlql/youthlql/img/spring.png' abbrlink: 1a003b7b date: 2021-10-06 00:21:58 --- > 参考了尚硅谷注解版，注解版后面的源码没看，雷神讲的太散了 ## Spring注解 ### AnnotationConfigApplicationContext ### 组件添加 #### @Configuration+@Bean ##### XML文件方式 ###### Person ```java public class Person { private String name; private Integer age; private String nickName; public String getNickName() { return nickName; } public void setNickName(String nickName) { this.nickName = nickName; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Person(String name, Integer age) { super(); this.name = name; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]"; } } ``` ###### beans.xml-配置文件 ```xml ``` ###### MainTest ```java public class MainTest { @SuppressWarnings("resource") public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); Person bean = (Person) applicationContext.getBean("person"); System.out.println(bean); } } ``` 输出 ``` Person [name=zhangsan, age=18, nickName=null] ``` ##### 注解方式 ```java //配置类==配置文件 @Configuration //告诉Spring这是一个配置类 public class MainConfig { //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id(就是bean的名字)，在这里就是person01 @Bean public Person person01(){ return new Person("lisi", 20); } } ``` 或者以下面的这种方式 ```java //配置类==配置文件 @Configuration //告诉Spring这是一个配置类 public class MainConfig { //这里bean的name就是person @Bean("person") public Person person01(){ return new Person("lisi", 20); } } ``` #### @ComponentScans ```java //配置类==配置文件 @Configuration //告诉Spring这是一个配置类 @ComponentScans( value = { @ComponentScan(value="com.atguigu",includeFilters = { /* @Filter(type=FilterType.ANNOTATION,classes={Controller.class}), @Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class}),*/ @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class}) },useDefaultFilters = false) } ) //@ComponentScan value:指定要扫描的包 //excludeFilters = Filter[] ：指定扫描的时候按照什么规则排除那些组件 //includeFilters = Filter[] ：指定扫描的时候只需要包含哪些组件 //FilterType.ANNOTATION：按照注解 //FilterType.ASSIGNABLE_TYPE：按照给定的类型； //FilterType.ASPECTJ：使用ASPECTJ表达式 //FilterType.REGEX：使用正则指定 //FilterType.CUSTOM：使用自定义规则 public class MainConfig { //给容器中注册一个Bean;类型为返回值的类型，id默认是用方法名作为id @Bean("person") public Person person01(){ return new Person("lisi", 20); } } ``` ##### 自定义TypeFilter指定包扫描规则 ```java public class MyTypeFilter implements TypeFilter { /** * metadataReader：读取到的当前正在扫描的类的信息 * metadataReaderFactory:可以获取到其他任何类信息的 */ @Override public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException { // TODO Auto-generated method stub //获取当前类注解的信息 AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata(); //获取当前正在扫描的类的类信息 ClassMetadata classMetadata = metadataReader.getClassMetadata(); //获取当前类资源（类的路径） Resource resource = metadataReader.getResource(); String className = classMetadata.getClassName(); System.out.println("--->"+className); if(className.contains("er")){ return true; } return false; } } ``` #### @Scope ```java @Configuration public class MainConfig2 { /** * @see ConfigurableBeanFactory#SCOPE_PROTOTYPE 任何环境都可以使用 * @see ConfigurableBeanFactory#SCOPE_SINGLETON 任何环境都可以使用 * @see org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST request 只能在web容器里用 * @see org.springframework.web.context.WebApplicationContext#SCOPE_SESSION sesssion 只能在web容器里用 * * @Scope:调整作用域 * prototype：多实例的：ioc容器启动并不会去调用方法创建对象放在容器中。 * 每次获取的时候才会调用方法创建对象； * singleton：单实例的（默认值）：ioc容器启动会调用方法创建对象放到ioc容器中。 * 以后每次获取就是直接从容器（map.get()）中拿， * request：同一次请求创建一个实例 * session：同一个session创建一个实例 * * 默认是单实例的 * */ @Scope("prototype") @Lazy @Bean("person") public Person person(){ System.out.println("给容器中添加Person...."); return new Person("张三", 25); } } ``` #### @Lazy ```java @Configuration public class MainConfig2 { /** * * 懒加载： * 单实例bean：默认在容器启动的时候创建对象； * 懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化； * */ @Lazy @Bean("person") public Person person(){ System.out.println("给容器中添加Person...."); return new Person("张三", 25); } ``` #### @Conditional ##### MainConfig2 ```java //类中组件统一设置。满足当前条件，这个类中配置的所有bean注册才能生效； @Conditional({WindowsCondition.class}) @Configuration public class MainConfig2 { /** * @Conditional({Condition}) ： 按照一定的条件进行判断，满足条件给容器中注册bean * * 如果系统是windows，给容器中注册("bill") * 如果是linux系统，给容器中注册("linus") */ @Bean("bill") public Person person01(){ return new Person("Bill Gates",62); } @Conditional(LinuxCondition.class) @Bean("linus") public Person person02(){ return new Person("linus", 48); } } ``` ##### LinuxCondition ```java //判断是否linux系统 public class LinuxCondition implements Condition { /** * ConditionContext：判断条件能使用的上下文（环境） * AnnotatedTypeMetadata：注释信息 */ @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { // TODO是否linux系统 //1、能获取到ioc使用的beanfactory ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); //2、获取类加载器 ClassLoader classLoader = context.getClassLoader(); //3、获取当前环境信息 Environment environment = context.getEnvironment(); //4、获取到bean定义的注册类 BeanDefinitionRegistry registry = context.getRegistry(); String property = environment.getProperty("os.name"); //可以判断容器中的bean注册情况，也可以给容器中注册bean boolean definition = registry.containsBeanDefinition("person"); if(property.contains("linux")){ return true; } return false; } ``` ##### WindowsCondition ```java //判断是否windows系统 public class WindowsCondition implements Condition { @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { Environment environment = context.getEnvironment(); String property = environment.getProperty("os.name"); if(property.contains("Windows")){ return true; } return false; } } ``` #### @Import ##### MainConfig2 ```java @Configuration @Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class}) //@Import导入组件，id默认是组件的全类名 public class MainConfig2 { /** * 给容器中注册组件； * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[只能注册自己写的类] * 2）、@Bean[导入的第三方包里面的组件] * 3）、@Import[快速给容器中导入一个组件] * 1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名 * 2）、ImportSelector:返回需要导入的组件的全类名数组； * 3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中 */ @Bean public ColorFactoryBean colorFactoryBean(){ return new ColorFactoryBean(); } } ``` ##### MyImportSelector ```java //自定义逻辑返回需要导入的组件 public class MyImportSelector implements ImportSelector { //返回值，就是到导入到容器中的组件全类名 //AnnotationMetadata:@Import引入MyImportSelector的类的所有注解信息 @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { //importingClassMetadata.get //方法不要返回null值，不然会报错 return new String[]{"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"}; } } ``` ##### MyImportBeanDefinitionRegistrar ```java public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { /** * AnnotationMetadata：当前类的注解信息 * BeanDefinitionRegistry:BeanDefinition注册类； * 把所有需要添加到容器中的bean；调用 * BeanDefinitionRegistry.registerBeanDefinition手工注册进来 */ @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red"); boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue"); if(definition && definition2){ //指定Bean定义信息；（Bean的类型，Bean。。。） RootBeanDefinition beanDefinition = new RootBeanDefinition(RainBow.class); //注册一个Bean，指定bean名 registry.registerBeanDefinition("rainBow", beanDefinition); } } } ``` ```java 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 + "]"; } } ``` ```java public class Blue { public Blue(){ System.out.println("blue...constructor"); } public void init(){ System.out.println("blue...init..."); } public void detory(){ System.out.println("blue...detory..."); } } ``` #### FactoryBean ##### MainConfig2 ```java @Configuration public class MainConfig2 { /** * 给容器中注册组件； * 1）、包扫描+组件标注注解（@Controller/@Service/@Repository/@Component）[自己写的类] * 2）、@Bean[导入的第三方包里面的组件] * 3）、@Import[快速给容器中导入一个组件] * 1）、@Import(要导入到容器中的组件)；容器中就会自动注册这个组件，id默认是全类名 * 2）、ImportSelector:返回需要导入的组件的全类名数组； * 3）、ImportBeanDefinitionRegistrar:手动注册bean到容器中 * 4）、使用Spring提供的 FactoryBean（工厂Bean）; * 1）、默认获取到的是工厂bean调用getObject创建的对象 * 2）、要获取工厂Bean本身，我们需要给id前面加一个& * &colorFactoryBean * * 虽然这里装配的是ColorFactoryBean，但实际上beand的类型是Color */ @Bean public ColorFactoryBean colorFactoryBean(){ return new ColorFactoryBean(); } } ``` ##### ColorFactoryBean ```java //创建一个Spring定义的FactoryBean public class ColorFactoryBean implements FactoryBean { //返回一个Color对象，这个对象会添加到容器中 @Override public Color getObject() throws Exception { // TODO Auto-generated method stub System.out.println("ColorFactoryBean...getObject..."); return new Color(); } @Override public Class getObjectType() { // TODO Auto-generated method stub return Color.class; } //是单例？ //true：这个bean是单实例，在容器中保存一份 //false：多实例，每次获取都会创建一个新的bean； @Override public boolean isSingleton() { // TODO Auto-generated method stub return false; } } ``` ##### IOCTest ```java public class IOCTest { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class); @Test public void testImport(){ printBeans(applicationContext); Blue bean = applicationContext.getBean(Blue.class); System.out.println(bean); //工厂Bean获取的是调用getObject创建的对象 Object bean2 = applicationContext.getBean("colorFactoryBean"); System.out.println("bean的类型："+bean2.getClass()); //pos_1 输出：bean的类型：class com.atguigu.bean.Color Object bean4 = applicationContext.getBean("&colorFactoryBean"); System.out.println(bean4.getClass()); //pos_2 输出：class com.atguigu.bean.ColorFactoryBean } private void printBeans(AnnotationConfigApplicationContext applicationContext){ String[] definitionNames = applicationContext.getBeanDefinitionNames(); for (String name : definitionNames) { System.out.println(name); } } } ``` 输出: ```java //前面无关的输出省略 colorFactoryBean ColorFactoryBean...getObject... bean的类型：class com.atguigu.bean.Color class com.atguigu.bean.ColorFactoryBean ``` ### 生命周期 #### @Bean指定初始化和销毁方法 ##### IOCTest_LifeCycle > 后面的几个用的都是这个测试类 ```java public class IOCTest_LifeCycle { @Test public void test01(){ //1、创建ioc容器 AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfLifeCycle.class); System.out.println("容器创建完成..."); //applicationContext.getBean("car"); //关闭容器 applicationContext.close(); } } ``` ##### MainConfigOfLifeCycle ```java package com.atguigu.config; import org.springframework.context.ApplicationListener; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Scope; import com.atguigu.bean.Car; /** * bean的生命周期： * bean创建---初始化----销毁的过程 * 容器管理bean的生命周期； * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 * * 构造（对象创建） * 单实例：在容器启动的时候创建对象 * 多实例：在每次获取的时候创建对象\ * 初始化： * 对象创建完成，并赋值好，调用初始化方法。。。 * BeanPostProcessor.postProcessAfterInitialization * 销毁： * 单实例：容器关闭的时候 * 多实例：容器不会管理这个bean；容器不会调用销毁方法； * * 1）、指定初始化和销毁方法； * 通过@Bean指定init-method和destroy-method； * @author lfy * */ @ComponentScan("com.atguigu.bean") @Configuration public class MainConfigOfLifeCycle { //@Scope("prototype") @Bean(initMethod="init",destroyMethod="detory") public Car car(){ return new Car(); } } ``` ```java @Component public class Car { public Car(){ System.out.println("car constructor..."); } public void init(){ System.out.println("car ... init..."); } public void detory(){ System.out.println("car ... detory..."); } } ``` ##### 输出 ```java car constructor... car ... init... 容器创建完成 car ... detory... ``` #### InitializingBean和DisposableBean ##### MainConfigOfLifeCycle ```java /** * bean的生命周期： * bean创建---初始化----销毁的过程 * 容器管理bean的生命周期； * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 * * 构造（对象创建） * 单实例：在容器启动的时候创建对象 * 多实例：在每次获取的时候创建对象\ * * BeanPostProcessor.postProcessBeforeInitialization * 初始化： * 对象创建完成，并赋值好，调用初始化方法。。。 * BeanPostProcessor.postProcessAfterInitialization * 销毁： * 单实例：容器关闭的时候 * 多实例：容器不会管理这个bean；容器不会调用销毁方法； * * * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization， * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization * * BeanPostProcessor原理 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值 * initializeBean * { * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); *} * * * * 1）、指定初始化和销毁方法； * 通过@Bean指定init-method和destroy-method； * 2）、通过让Bean实现InitializingBean（定义初始化逻辑）， * DisposableBean（定义销毁逻辑）; * * @author lfy * */ @ComponentScan("com.atguigu.bean") @Configuration public class MainConfigOfLifeCycle { //@Scope("prototype") @Bean(initMethod="init",destroyMethod="detory") public Car car(){ return new Car(); } } ``` ##### Cat ```java @Component public class Cat implements InitializingBean,DisposableBean { public Cat(){ System.out.println("cat constructor..."); } @Override public void destroy() throws Exception { // TODO Auto-generated method stub System.out.println("cat...destroy..."); } @Override public void afterPropertiesSet() throws Exception { // TODO Auto-generated method stub System.out.println("cat...afterPropertiesSet..."); } } ``` ##### 输出 ```java cat constructor... cat...afterPropertiesSet... car constructor... car ... init... 容器创建完成 car ... detory... cat...destroy... ``` #### @PostConstruct和@PreDestroy ##### MainConfigOfLifeCycle ```java /** * bean的生命周期： * bean创建---初始化----销毁的过程 * 容器管理bean的生命周期； * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 * * 构造（对象创建） * 单实例：在容器启动的时候创建对象 * 多实例：在每次获取的时候创建对象\ * * BeanPostProcessor.postProcessBeforeInitialization * 初始化： * 对象创建完成，并赋值好，调用初始化方法。。。 * BeanPostProcessor.postProcessAfterInitialization * 销毁： * 单实例：容器关闭的时候 * 多实例：容器不会管理这个bean；容器不会调用销毁方法； * * * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization， * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization * * BeanPostProcessor原理 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值 * initializeBean * { * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); *} * * * * 1）、指定初始化和销毁方法； * 通过@Bean指定init-method和destroy-method； * 2）、通过让Bean实现InitializingBean（定义初始化逻辑）， * DisposableBean（定义销毁逻辑）; * 3）、可以使用JSR250； * @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法 * @PreDestroy：在容器销毁bean之前通知我们进行清理工作 * * @author lfy * */ @ComponentScan("com.atguigu.bean") @Configuration public class MainConfigOfLifeCycle { //@Scope("prototype") @Bean(initMethod="init",destroyMethod="detory") public Car car(){ return new Car(); } } ``` ##### Dog ```java @Component public class Dog implements ApplicationContextAware { //@Autowired private ApplicationContext applicationContext; public Dog(){ System.out.println("dog constructor..."); } //对象创建并赋值之后调用 @PostConstruct public void init(){ System.out.println("Dog....@PostConstruct..."); } //容器移除对象之前 @PreDestroy public void detory(){ System.out.println("Dog....@PreDestroy..."); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { // TODO Auto-generated method stub this.applicationContext = applicationContext; } } ``` ##### 输出 ```java cat constructor... cat...afterPropertiesSet... dog constructor... Dog....@PostConstruct... car constructor... car ... init... 容器创建完成 car ... detory... Dog....@PreDestroy... cat...destroy... ``` #### BeanPostProcessor ```java /** * bean的生命周期： * bean创建---初始化----销毁的过程 * 容器管理bean的生命周期； * 我们可以自定义初始化和销毁方法；容器在bean进行到当前生命周期的时候来调用我们自定义的初始化和销毁方法 * * 构造（对象创建） * 单实例：在容器启动的时候创建对象 * 多实例：在每次获取的时候创建对象\ * * BeanPostProcessor.postProcessBeforeInitialization * 初始化： * 对象创建完成，并赋值好，调用初始化方法。。。 * BeanPostProcessor.postProcessAfterInitialization * 销毁： * 单实例：容器关闭的时候 * 多实例：容器不会管理这个bean；容器不会调用销毁方法； * * * 遍历得到容器中所有的BeanPostProcessor；挨个执行beforeInitialization， * 一但返回null，跳出for循环，不会执行后面的BeanPostProcessor.postProcessorsBeforeInitialization * * BeanPostProcessor原理 * populateBean(beanName, mbd, instanceWrapper);给bean进行属性赋值 * initializeBean * { * applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); * invokeInitMethods(beanName, wrappedBean, mbd);执行自定义初始化 * applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); *} * * * * 1）、指定初始化和销毁方法； * 通过@Bean指定init-method和destroy-method； * 2）、通过让Bean实现InitializingBean（定义初始化逻辑）， * DisposableBean（定义销毁逻辑）; * 3）、可以使用JSR250； * @PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法 * @PreDestroy：在容器销毁bean之前通知我们进行清理工作 * 4）、BeanPostProcessor【interface】：bean的后置处理器； * 在bean初始化前后进行一些处理工作； * postProcessBeforeInitialization:在初始化之前工作 * postProcessAfterInitialization:在初始化之后工作 * * Spring底层对 BeanPostProcessor 的使用； * bean赋值，注入其他组件，@Autowired，生命周期注解功能，@Async,xxx BeanPostProcessor; * * @author lfy * */ @ComponentScan("com.atguigu.bean") @Configuration public class MainConfigOfLifeCycle { //@Scope("prototype") @Bean(initMethod="init",destroyMethod="detory") public Car car(){ return new Car(); } } ``` ##### MyBeanPostProcessor ```java /** * 后置处理器：初始化前后进行处理工作 * 将后置处理器加入到容器中 * @author lfy */ @Component public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { // TODO Auto-generated method stub System.out.println("postProcessBeforeInitialization..."+beanName+"=>"+bean); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { // TODO Auto-generated method stub System.out.println("postProcessAfterInitialization..."+beanName+"=>"+bean); return bean; } } ``` 输出 > 自己写的组件输出内容 ```java car constructor... postProcessBeforeInitialization...car=>com.atguigu.bean.Car@5ef60048 car ... init... postProcessAfterInitialization...car=>com.atguigu.bean.Car@5ef60048 cat constructor... postProcessBeforeInitialization...cat=>com.atguigu.bean.Cat@780cb77 cat...afterPropertiesSet... postProcessAfterInitialization...cat=>com.atguigu.bean.Cat@780cb77 dog constructor... postProcessBeforeInitialization...dog=>com.atguigu.bean.Dog@4034c28c Dog....@PostConstruct... postProcessAfterInitialization...dog=>com.atguigu.bean.Dog@4034c28c 容器创建完成... Dog....@PreDestroy... cat...destroy... car ... detory... ``` > 1. BeanPostProcessor在Spring源码里大量被使用到，仅凭这里雷丰阳老师讲的一点点原理，是无法体会的，建议自己去看看Spring源码。所以这里的原理部分我也就直接省略了，在本视频中讲的太浅了。 ### 属性赋值 #### @Value和@PropertySource ##### Person ```java public class Person { //使用@Value赋值； //1、基本数值 //2、可以写SpEL； #{} //3、可以写${}；取出配置文件【properties】中的值（在运行环境变量里面的值） @Value("张三") private String name; @Value("#{20-2}") private Integer age; @Value("${person.nickName}") private String nickName; public String getNickName() { return nickName; } public void setNickName(String nickName) { this.nickName = nickName; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public Person(String name, Integer age) { super(); this.name = name; this.age = age; } public Person() { super(); // TODO Auto-generated constructor stub } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", nickName=" + nickName + "]"; } } ``` ##### person.properties ```java person.nickName=\u5C0F\u674E\u56DB ``` ##### MainConfigOfPropertyValues ```java //使用@PropertySource读取外部配置文件中的k/v保存到运行的环境变量中;加载完外部的配置文件以后使用${}取出配置文件的值 @PropertySource(value={"classpath:/person.properties"}) @Configuration public class MainConfigOfPropertyValues { @Bean public Person person(){ return new Person(); } } ``` ##### IOCTest_PropertyValue ```java public class IOCTest_PropertyValue { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfPropertyValues.class); @Test public void test01(){ printBeans(applicationContext); System.out.println("============="); Person person = (Person) applicationContext.getBean("person"); System.out.println(person); ConfigurableEnvironment environment = applicationContext.getEnvironment(); String property = environment.getProperty("person.nickName"); System.out.println(property); applicationContext.close(); } private void printBeans(AnnotationConfigApplicationContext applicationContext){ String[] definitionNames = applicationContext.getBeanDefinitionNames(); for (String name : definitionNames) { System.out.println(name); } } } ``` ##### 输出 ```java mainConfigOfPropertyValues person ============= Person [name=张三, age=18, nickName=小李四] 小李四 ``` ### 自动装配 #### @Autowired-@Qualifier-@Primary-@Resource-@Inject ```java @Controller public class BookController { @Autowired private BookService bookService; } ``` ```java @Service public class BookService { //@Qualifier("bookDao") //@Autowired(required=false) //@Resource(name="bookDao2") @Inject private BookDao bookDao; public void print(){ System.out.println(bookDao); } @Override public String toString() { return "BookService [bookDao=" + bookDao + "]"; } } ``` ```java //名字默认是类名首字母小写 @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 + "]"; } } ``` ##### MainConifgOfAutowired ```java /** * 自动装配; * Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值； * * 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）、放在参数位置： public Boss(@Autowired Car car){ this.car = car; System.out.println("Boss...有参构造器"); } * * 4）、自定义组件想要使用Spring容器底层的一些组件（ApplicationContext，BeanFactory，xxx）； * 自定义组件实现xxxAware；在创建对象的时候，会调用接口规定的方法注入相关组件；Aware； * 把Spring底层一些组件注入到自定义的Bean中； * xxxAware：功能使用xxxProcessor； * ApplicationContextAware==》ApplicationContextAwareProcessor； * * * @author lfy * */ @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; } /** * @Bean标注的方法创建对象的时候，方法参数的值默认从容器中获取 * @param car * @return */ @Bean public Color color(Car car){ Color color = new Color(); color.setCar(car); return color; } } ``` ##### IOCTest_Autowired ```java public class IOCTest_Autowired { @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); Boss boss = applicationContext.getBean(Boss.class); System.out.println(boss); Car car = applicationContext.getBean(Car.class); System.out.println(car); Color color = applicationContext.getBean(Color.class); System.out.println(color); System.out.println(applicationContext); applicationContext.close(); } } ``` #### @Profle ##### MainConfigOfProfile ```java /** * Profile： * Spring为我们提供的可以根据当前环境，动态的激活和切换一系列组件的功能； * * 开发环境、测试环境、生产环境； * 数据源：(/A)(/B)(/C)； * * * @Profile：指定组件在哪个环境的情况下才能被注册到容器中，不指定，任何环境下都能注册这个组件 * * 1）、加了环境标识的bean，只有这个环境被激活的时候才能注册到容器中。默认是default环境 * 2）、写在配置类上，只有是指定的环境的时候，整个配置类里面的所有配置才能开始生效 * 3）、没有标注环境标识的bean在，任何环境下都是加载的； */ @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/test"); 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/ssm_crud"); 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/scw_0515"); dataSource.setDriverClass(driverClass); return dataSource; } @Override public void setEmbeddedValueResolver(StringValueResolver resolver) { // TODO Auto-generated method stub this.valueResolver = resolver; driverClass = valueResolver.resolveStringValue("${db.driverClass}"); } } ``` ##### dbconfig.properties ```properties db.user=root db.password=123456 db.driverClass=com.mysql.jdbc.Driver ```