@Configuration:指明当前类是一个配置类，就是来替代spring的配置文件
@Configuration
public class MyConfigFile {
@Bean
public HelloService helloService(){
return new HelloService();
}
}
使用@Bean添加组件
@SpringBootTest
class SpringBoot02ApplicationTests {
@Autowired
ApplicationContext ioc;
@Test
public void testHelloService(){
boolean helloService = ioc.containsBean("helloService");
System.out.println(helloService);
}
}
测试：true
@Configuration注解进阶内容
1.创建一个User实体类
package com.hao.springbooton.bean;
/**
* @author:抱着鱼睡觉的喵喵
* @date:2020/12/22
* @description:
*/
public class User {
private String username;
private String password;
private int age;
public User() {
}
public User(String username, String password, int age) {
this.username = username;
this.password = password;
this.age = age;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
'}';
}
}
2.编写一个MyConfig的配置类
/**
* @author:抱着鱼睡觉的喵喵
* @date:2020/12/22
* @description:配置类
*/
@Configuration
public class MyConfig {
@Bean("hao")
public User user(){
return new User("tom","123",20);
}
}
3.在主配置文件从容器中获取user
@SpringBootApplication
public class SpringBootOnApplication {
public static void main(String[] args) {
ConfigurableApplicationContext run=SpringApplication.run(SpringBootOnApplication.class, args);
//判断从容器中获取的是否是单实例
User tom = run.getBean("hao", User.class);
User tom1 = run.getBean("hao",User.class);
System.out.println(tom==tom1);
//通过配置类调用查看两次调用的结果
MyConfig co = run.getBean(MyConfig.class);
System.out.println(co);
User user = co.user();
User user1 = co.user();
System.out.println(user==user1);
}
}
结果：
我们编写的MyConfig配置类也是一个组件，配置类中注入的对象也是组件，我们发现通过配置类调用完这个user方法，两者是同一个user对象；所以无论是从另外一个组件中获取(比如MyConfig是一个组件）组件（对象），Spring都会从容器中进行查看是否存在该组件（从一个组件中调用另外一个组件也叫做组件依赖，具体看下面）
我们可以查看@Configuration注解源码
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(
annotation = Component.class
)
String value() default "";
boolean proxyBeanMethods() default true;
}
其中的proxyBeanMethods()方法默认值是true,这就保证了单实例
接下来我们引进组件依赖
编写Admin类
public class Admin {
private String name;
private String img;
public Admin() {
}
public Admin(String name, String img) {
this.name = name;
this.img = img;
}
@Override
public String toString() {
return "admin{" +
"name='" + name + '\'' +
", img='" + img + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
修改User类，增加Admin属性
public class User {
private String username;
private String password;
private int age;
private Admin admin;
public Admin getAdmin() {
return admin;
}
public void setAdmin(Admin admin) {
this.admin = admin;
}
public User() {
}
public User(String username, String password, int age) {
this.username = username;
this.password = password;
this.age = age;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
", admin=" + admin +
'}';
}
}
MyConfig的修改(相关说明已在注释中表明）
/**
* @author:抱着鱼睡觉的喵喵
* @date:2020/12/22
* @description:配置类
*/
/**
* Spring 5提供了Full模式和Lite模式
* 组件依赖：容器中一个组件调用另外一个组件的情况
* Lite：容器中组件没有依赖的情况：使用Lite模式能使容器快速启动
* Full：容器中的组件存在依赖的情况，使用Full模式，由于在一个组件中存在调用另外一个组件的情况，所以会查看该组件在容器中是否存在，当然也就降低了容器启动的速度
*/
@Configuration(proxyBeanMethods = true)
public class MyConfig {
@Bean("hao")
public User user(){
User tom = new User("tom", "123", 20);
//hao组件依赖了admin组件
tom.setAdmin(admin());
return tom;
}
@Bean("admin")
public Admin admin(){
return new Admin("jerry","@the");
}
}
@SpringBootApplication
public class SpringBootOnApplication {
public static void main(String[] args) {
ConfigurableApplicationContext run=SpringApplication.run(SpringBootOnApplication.class, args);
MyConfig co = run.getBean(MyConfig.class);
User hao = run.getBean("hao", User.class);
Admin admin = run.getBean("admin", Admin.class);
System.out.println(hao.getAdmin()==admin);
}
}
此时运行结果：true
此时我把MyConfig类中的注解改为@Configuration(proxyBeanMethods = false）
@Configuration(proxyBeanMethods = false)
public class MyConfig {
@Bean("hao")
public User user(){
User tom = new User("tom", "123", 20);
//hao组件依赖了admin组件
tom.setAdmin(admin());
return tom;
}
@Bean("admin")
public Admin admin(){
return new Admin("jerry","@the");
}
}
继续测试
结果：false
这说明当proxyBeanMethods = false时，Spring帮我们执行了Lite模式；
总结：假设我在配置类中，注入了两个组件（A和B）到容器中，组件A调用了组件B
Lite(proxyBeanMethods =false）模式：程序运行时Spring不会检查B组件是否存在，即上面举的例子中调用之后直接new个对象。
Full(proxyBeanMethods =true）模式：程序运行时，当A调用B时，Spring会检查容器中是否存在B组件，如果存在就从容器中拿
Lite和Full适用于的情况：当配置类中没有出现组件依赖的情况，使用Lite模式可以提高容器的启动速度。当配置中出现组件依赖的时候，使用Full模式最合适。
===========================================================
@Import是向容器中导入组件，需要和@Configuration注解一块使用
@Import({User.class,Admin.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
}
