SpringBoot框架——SpringBoot_注解

springboot默认已经帮助我们整合好了SpringMVC,同时也给我们默认配置了DispathcerServlet 和编码过滤器,同时也给我们配置好了WEB项目开发的常见组件

查看容器中的所有组件

@SpringBootApplication

默认扫描启动类所在包下的所有层级的子包
3.	* 可以通过scanBasePackages属性指定扫描路径
4.	* SpringBootApplication是一个合成注解,可以拆分为以下三个注解
5.	*   @SpringBootConfiguration
6.	*   @EnableAutoConfiguration
7.	*   @ComponentScan(basePackages = "com.msb")
8.	*
9.	*
10.	* */
11.	@SpringBootApplication
12.	public class Springboot04Application {
13.	    public static void main(String[] args) {
14.	        //返回一个spring容器
15.	        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
16.	        // 查看所有组件的名
17.	        String[] names = context.getBeanDefinitionNames();
18.	        for (String name : names) {
19.	            System.out.println(name);
20.	        }
21.	    }
22.	}

@Configuration (表明是配置类)

1.	package com.msb.config;
2.	
3.	import com.msb.pojo.User;
4.	import org.springframework.context.annotation.Bean;
5.	import org.springframework.context.annotation.Configuration;
6.	
7.	/**
8.	 * @Author: Ma HaiYang
9.	 * @Description: MircoMessage:Mark_7001
10.	 * MyConfig配置类本身也是一个spring容器中的bean
11.	 * proxyBeanMethods=true 属性,给MyConfig对象产生一个代理对象
12.	 * 通过代理对象控制反复调用MyConfig里面的方法返回的是容器中的一个单实例
13.	 * 如果proxyBeanMethods=false 那么我们拿到的MyConfig对象就不是一个代理对象
14.	 * 那么这个时候反复调用MyConfig中的方法返回的就是多实例
15.	 *
16.	 * proxyBeanMethods=false 称之为Lite模式  特点启动快
17.	 * proxyBeanMethods=true  称之为Full模式  特点依赖spring容器控制bean单例
18.	 *
19.	 */
20.	@Configuration(proxyBeanMethods = true)
21.	public class MyConfig {
22.	
23.	    /*<bean id = "user1" class ="com.msb.pojo.User">... ...</bean>*/
24.	    @Bean // 向容器中添加一个Bean,以方法名作为Bean的id,返回值类型作为组件的类型
25.	    public User user1(){
26.	        return new User("zhangsan", 10);
27.	    }
28.	
29.	    /*<bean id = "user2" class ="com.msb.pojo.User">... ...</bean>*/
30.	    @Bean("user2") // 向容器中添加一个Bean,手动指定Bean的name属性,返回值类型作为组件的类型
31.	    public User getUser(){
32.	        return new User("lisi", 11);
33.	    }
34.	}

测试代码

1.	package com.msb;
2.	
3.	import com.msb.config.MyConfig;
4.	import com.msb.pojo.User;
5.	import org.springframework.boot.SpringApplication;
6.	import org.springframework.boot.SpringBootConfiguration;
7.	import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
8.	import org.springframework.boot.autoconfigure.SpringBootApplication;
9.	import org.springframework.context.ConfigurableApplicationContext;
10.	import org.springframework.context.annotation.ComponentScan;
11.	
12.	
13.	@SpringBootApplication(scanBasePackages = "com.msb")
14.	public class Springboot04Application {
15.	    public static void main(String[] args) {
16.	        //返回一个spring容器
17.	        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
18.	      
19.	
20.	        System.out.println(context.getBean("user1"));
21.	        System.out.println(context.getBean("user2"));
22.	        User usera = context.getBean(MyConfig.class).getUser();
23.	        User userb = context.getBean(MyConfig.class).getUser();
24.	        System.out.println(usera==userb);
25.	    }
26.	}

@Import

1.	package com.msb.config;
2.	
3.	import com.msb.pojo.User;
4.	import org.springframework.context.annotation.Bean;
5.	import org.springframework.context.annotation.Configuration;
6.	import org.springframework.context.annotation.Import;
7.	
8.	
9.	/*
10.	* @Import({User.class}) 在容器中自动创建Bean的注解
11.	* 通过传入字节码,默认调用bean的无参构造器,向容器中存放一个Bean
12.	* 默认组件的名字就是类的全路径名
13.	* @Import只要放到可以被扫描到的类之上就可以,不必非得是配置类或者Controller
14.	* */
15.	@Import({User.class})
16.	@Configuration(proxyBeanMethods = true)
17.	public class MyConfig {
18.	
19.	}

1.	@SpringBootApplication(scanBasePackages = "com.msb")
2.	public class Springboot04Application {
3.	    public static void main(String[] args) {
4.	        //启动SpringBoot, 返回一个spring容器
5.	        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
6.	        // 根据类型获取Bean
7.	        User bean = context.getBean(User.class);
8.	        System.out.println(bean);
9.	        // 获取属性User类的所有bean的name
10.	        String[] beanNamesForType = context.getBeanNamesForType(User.class);
11.	        for (String s : beanNamesForType) {
12.	            System.out.println(s);
13.	        }
14.	    }
15.	}

@Conditional条件装配

满足Conditional指定的条件,则进行组件注入

@Conditional下还有很多子注解

1.	package com.msb.config;
2.	
3.	import com.msb.pojo.Emp;
4.	import com.msb.pojo.User;
5.	import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
6.	import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
7.	import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
8.	import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
9.	import org.springframework.context.annotation.Bean;
10.	import org.springframework.context.annotation.Conditional;
11.	import org.springframework.context.annotation.Configuration;
12.	import org.springframework.context.annotation.Import;
13.	
14.	
15.	@Configuration
16.	/*
17.	 * 当配置中存在一个aaa.b的配置并且值为x的时候,当前配置中所有的配置才会生效
18.	 * */
19.	//@ConditionalOnProperty( name = "aaa.b",havingValue = "x")
20.	public class MyConfig {
21.	    /*
22.	    * 当配置中存在一个aaa.b的配置并且值为x的时候,容器才会初始化user1
23.	    * */
24.	    @ConditionalOnProperty( name = "aaa.b",havingValue = "x")
25.	    @Bean
26.	    public User user1(){
27.	        return new User("zhangsan", 10);
28.	    }
29.	}

@ImportResource

原生配置文件引入,允许我们自己定义xml配置文件,在文件中配置bean

resources目录下准备一个xml配置文件

配置类中加载该配置文件

1.	package com.msb.config;
2.	
3.	import org.springframework.context.annotation.*;
4.	
5.	@Configuration
6.	@ImportResource("classpath:beans.xml")
7.	public class MyConfig {
8.	}

从容器中获取beans.xml中配置的bean

1.	@SpringBootApplication
2.	public class Springboot04Application {
3.	    public static void main(String[] args) {
4.	        //启动SpringBoot, 返回一个spring容器
5.	        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
6.	        System.out.println(context.getBean("userx"));
7.	
8.	    }
9.	}

@ConfigurationProperties

读取application.properties配置文件中的内容,读取进入bean

1.	/*prefix前缀,为配置文件中对应的前缀
2.	* 通过前缀找到对应的配置信息后,在根据属性名去注入匹配的数据*/
3.	@ConfigurationProperties( prefix = "user")
4.	@Component
5.	public class User {
6.	    private String uname;
7.	    private int age;
8.	}

配置类代码

1.	package com.msb.config;
2.	
3.	import com.msb.pojo.User;
4.	import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
5.	import org.springframework.boot.context.properties.EnableConfigurationProperties;
6.	import org.springframework.context.annotation.Configuration;
7.	
8.	/**
9.	 * @Author: Ma HaiYang
10.	 * @Description: MircoMessage:Mark_7001
11.	 */
12.	@Configuration
13.	/*开启了User的属性自动配置功能并把User自动注册到容器中
14.	* 这个时候,我们的User上就不用加@Component注解了
15.	* 适用于Bean来自于第三方JAR场景
16.	* */
17.	@EnableConfigurationProperties(User.class)
18.	public class MyConfig {
19.	}

测试代码

1.	package com.msb;
2.	
3.	import com.msb.pojo.User;
4.	import org.springframework.boot.SpringApplication;
5.	import org.springframework.boot.autoconfigure.SpringBootApplication;
6.	import org.springframework.context.ConfigurableApplicationContext;
7.	
8.	@SpringBootApplication
9.	public class Springboot04Application {
10.	    public static void main(String[] args) {
11.	        //启动SpringBoot, 返回一个spring容器
12.	        ConfigurableApplicationContext context = SpringApplication.run(Springboot04Application.class, args);
13.	        System.out.println(context.getBean(User.class));
14.	
15.	    }
16.	}