底层注解

柔光的暖阳◎ 2022-11-05 00:53 211阅读 0赞

### 文章目录 ###

*   *  @Component & @Service & @Controller & @Repository
     *  @AutoWired & @Qualifier & @Resource & @Value
     *  @Configuration & @Bean
     *  @Import
     *  @Conditional
     *  @ImportResource
     *  @ConfigurationProperties

## @Component & @Service & @Controller & @Repository ##

Spring 针对bean对象管理提供的注解，这几个效果都是一样的，都可以用来创建bean实例，并没有严格规定哪个注解用在哪一层，只是为了开发方便提供这几个注解。

@Component(value = "car01") // 创建一个id为"car01"的bean，value可以不写，默认id为类名（首字母小写）：“car”
    public class Car { 
       private String brand;
       private Integer price;
    }

## @AutoWired & @Qualifier & @Resource & @Value ##

`@AutoWired` ：根据**属性类型**自动注入  
`@Qualifier` ：根据**属性名称**进行注入  
`@Resource` ：即可根据**属性类型**进行注入，也可以根据**属性名称**进行注入

`@Value` ：注入普通类型的属性，上面三个是注入类的属性

例子：

public interface TestDao { 
        public void add();
    }
    
    @Controller(value = "testDaoImpl") //id
    public class TestDaoImpl implements TestDao { 
        @Override
        public void add() { 
                System.out.println("dao add.....");
        }
    }
    
    @Service
    public class TestService { 
    
        @Autowired //自动查找bean容器，根据类型注入
        private TestDao testDao; 
    
        public void add()
        { 
            testDao.add();
            System.out.println("service add ...");
        }
    
    }
    
    
    //===============主程序=======================
    @SpringBootApplication
    public class MainApplication { 
        public static void main(String[] args) { 
                
            ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);// 返回IOC容器
    
    
    TestService service = run.getBean("testService", TestService.class);
    service.add(); 
    }

如果现在有类型一样的bean，那么自动注入需要用`@Qualifier`指定id注入。例子：

public interface TestDao { 
        public void add();
    }
    
    @Controller
    public class TestDaoImpl1 implements TestDao { 
        @Override
        public void add() { 
                System.out.println("dao1 add.....");
        }
    }
    
    @Repository
    public class TestDaoImpl2 implements TestDao{ 
        @Override
        public void add() { 
            System.out.println("dao2 add .....");
        }
    }
    
    
    @Service
    public class TestService { 
    
        @Autowired
        @Qualifier(value = "testDaoImpl2")
        private TestDao testDao;
    
        public void add()
        { 
            testDao.add();
            System.out.println("service add ...");
        }
    }
    
    
    TestService testService = run.getBean("testService", TestService.class);
    testService.add(); // dao2 add ..... service add ...

`@Resource` 可以整合上面两种。例子：

@Service
    public class TestService { 
    
       //@Resource // 啥都没有根据类型注入
        @Resource(name = "testDaoImpl2") // 指定名字根据 名字注入
        private TestDao testDao;
    
        public void add()
        { 
            testDao.add();
            System.out.println("service add ...");
        }
    }

@Value注入普通类型，例子：

@Service
    public class TestService { 
        @Value("kerr")
        private String name;
    }

注意：通过注解的注入 比 直接 在变量名后赋值优先级更高。

## @Configuration & @Bean ##

`@Configuration`用于定义配置类，可替换xml配置文件，和`@Bean`注解的同时使用，添加对象到IOC容器。

/* 1. @Bean标注在方法上，在容器中注册组件，默认是单例 2. 配置类MyConfig本身也是一个组件 3. 有个proxyBeanMethods属性:代理bean方法 ：true （full模式），默认模式，每次都会检查容器中是否有特定组件，单实例，配置类之间有依赖 ：false（lite模式），无依赖，不做判断，直接给new新的 */
    @Configuration//告诉sping boot这是一个配置类，相当于spring的xml配置,
    public class MyConfig { 
    
        @Bean//给容器中添加组件，方法名就是组件id，返回类型就是组件类型，返回值就是组件在容器中的实例
        public User user01()
        { 
            return new User("julian",27);
        }
    
        @Bean("petxx") //手动配置组件名称"petxx"，默认组件名是方法名
        public Pet pet01()
        { 
            return new Pet();
        }
    }

Pet xx = run.getBean("petxx",Pet.class);
            User xx01 = run.getBean("user01",User.class);

## @Import ##

可以通过`@Import`注解快速将类加入IOC容器，这个注解可以使用在任何配置类或者能扫描的组件前都可。注意类需要有无参构建。

@Import({ User.class})
    @Configuration//告诉sping boot这是一个配置类，相当于spring的xml配置,
    public class MyConfig { 
    }

String[] xx1 = run.getBeanNamesForType(User.class);
         for(String s:xx1)
             System.out.println(s);

默认在容器中bean名称是该类的**全类名**，如果同时存在@bean @Import同时导入一个类，则生成不同的实例对象。

## @Conditional ##

条件装载，根据不同的条件决定是否加载该bean到spring IOC容器中去。条件装配注解是一个大家族，都是继承`@Conditional`。

例子：@ConditionalOnBean :表示容器中有某个对象则就添加该对象到IOC容器中

@Configuration//告诉sping boot这是一个配置类，相当于spring的xml配置,
    public class MyConfig { 
    
        @ConditionalOnBean(name = "petxx") //如果IOC容器中有 petxx实例，则装配，没有则不装配
        @Bean
        public User user01()
        { 
            return new User("julian",27);
        }
    
    
    
        //@Bean("petxx") 
        public Pet pet01()
        { 
            return new Pet();
        }
    }

boolean hasUser01 = run.containsBean("user01");
            System.out.println(hasUser01); //false

也可以放在类上表示：当满足条件的时候，下面生效。举例：

@Configuration
    @ConditionalOnMissingBean(name = "petxx") //当容器中没有 petxx实例 下面配置生效
    public class MyConfig { 
    
    
        @Bean
        public User user01()
        { 
            return new User("julian",27);
        }
    
        @Bean("petxx")
        public Pet pet01()
        { 
            return new Pet();
        }
    }

boolean has_user01 = run.containsBean("user01");
        System.out.println(has_user01); // true
    
        boolean has_petxx = run.containsBean("petxx");
        System.out.println(has_petxx); // true

## @ImportResource ##

在配置类上面使用`@ImportResource`导入配置文件，

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="haha" class="com.julian.boot.entity.User">
            <property name="age" value="18"></property>
            <property name="name" value="julian"></property>
        </bean>
    
    </beans>

@ImportResource("classpath:bean.xml")
    public class MyConfig { 
    }

boolean has_haha = run.containsBean("haha");
    System.out.println(has_haha); //true

## @ConfigurationProperties ##

将java bean和配置文件进行绑定，这个配置文件只能是`application.properties`。

application.properties

mycar.brand = BYD
    mycar.price = 100000

Car:

@Component
    @ConfigurationProperties(prefix = "mycar") //将当前的car和配置文件进行绑定，前缀是mycar
    public class Car { 
       private String brand;
       private Integer price;
    }

Controller

@RestController
    public class TestController { 
    
        @Autowired
        Car car;
    
        @RequestMapping("/hi")
        public Car test()
        { 
            return car;
        }
    }

--------------------

第二种方式：

在配置类中加`@EnableConfigurationProperties(Car.class)`注解，它有两个功能：

1.  为Car 开启属性绑定功能
2.  将Car 组件自动注册到容器中

@Configuration
    @EnableConfigurationProperties(Car.class)
    public class MyConfig { 
    }

@ConfigurationProperties(prefix = "mycar") //将当前的car和配置文件进行绑定，前缀是mycar
    public class Car { 
       private String brand;
       private Integer price;