05_IOC容器装配Bean(注解方式)

IOC容器装配Bean(注解方式)

1.使用注解方式进行Bean注册

xml 方式： <bean id="" class="">

spring2.5版本 提供一组注解，完成Bean注册

* @Component 描述Spring框架中Bean

导入jar 和 xml方式开发是相同的

第一步 编写Class，在声明上 添加 @Component

1. /**
2. * 使用Spring2.5注解 注册Bean
3. */
4. @Component("helloService")
5. // <bean id="helloService" class="...." />
6. publicclassHelloService{
7. publicvoid sayHello(){
8. System.out.println("hello, spring annotation!");
9. }
10. }

 

第二步 编写applicationContext.xml 通知Spring注解类所在包

* 需要引入 context 名称空间

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beansxmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xsi:schemaLocation="
6. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
8. <!-- 配置 注解Bean 所在包 -->
9. <context:annotation-config/>
10. <context:component-scanbase-package="cn.itcast.spring.a_beandefinition"></context:component-scan>
11. </beans>

进行测试：

1. publicclassSpringTest{
2. @Test
3. // 测试 注解Bean 注册
4. publicvoid demo1(){
5. ApplicationContext applicationContext =newClassPathXmlApplicationContext("applicationContext.xml");
6. //bean的名称来自@Component("helloService")
7. HelloService helloService =(HelloService) applicationContext.getBean("helloService");
8. helloService.sayHello();
9. }
10. }

spring2.5 引入@Component 等效三个衍生注解 

* @Repository 用于对DAO实现类进行标注 （持久层）

* @Service 用于对Service实现类进行标注 （业务层）

* @Controller 用于对Controller实现类进行标注 (表现层)

2.属性依赖注入

1） 简单属性的注入 通过 @Value注解完成，不需要提供setter方法

1. @Service("userService")
2. public class UserService {
3.     // 注入name属性
4.     @Value("itcast")
5.     private String name;
6. }

 

2） 复杂属性注入，通过@Autowired注解 完成Bean自动装配

@Autowired 默认按照类型进行注入

1. /**
2. * 用户操作数据层
3. */
4. @Repository("userDAO")
5. publicclassUserDAO{
7. }

 

1. /**
2. * 用户业务层
3. */
4. @Service("userService")
5. publicclassUserService{
6. // 注入name属性
7. @Value("itcast")
8. // 简单属性
9. privateString name;
10.  
11. //@Autowired默认按照类型
    
12. @Autowired
13. privateUserDAO userDAO;
15. @Override
16. publicString toString(){
17. return"UserService [name="+ name +", userDAO="+ userDAO +"]";
18. }
20. }

@Value @Autowired注解都可以修饰 成员变量 或者 setter方法，如果修饰成员变量，不需要提供setter方法

@Autowired注解 结合 @Qualifer注解按照名称注入

1. @Service("userService")
2. public class UserService {
3.     @Autowired
4.     @Qualifier("uDAO")
5.     // 复杂对象
7.     private UserDAO userDAO;
9. }

@Qualifier("userDAO")注解的名称必须与@Repository("userDAO")名称一致，就会报错！

1. @Repository("uDAO")
2. public class UserDAO {
4. }

 

3） 使用@Resource注解 完成复杂对象Bean装配

@Resource和@Autowired注解功能相似

1. @Autowired
2. @Qualifer("userDAO")
3. private UserDAO userDAO ; 

等价于 

1. @Resource(name="userDAO")
2. private UserDAO userDAO ;

 

3.Bean其它属性设置

1) 指定Bean的初始化方法和销毁方法(注解)  <bean init-method="" destroy-method="" />

@PostConstruct  作用 init-method

@PreDestroy  作用 destroy-method

1. @Component("lifeBean")
2. publicclassLifeCycleBean{
3. @PostConstruct
4. publicvoid setup(){
5. System.out.println("初始化...");
6. }
8. @PreDestroy
9. publicvoid teardown(){
10. System.out.println("销毁...");
11. }
12. }

进行测试：

1. @Test
2. // 测试初始化和销毁
3. publicvoid demo1(){
4.     ClassPathXmlApplicationContext applicationContext =newClassPathXmlApplicationContext("applicationContext.xml");
5.     LifeCycleBean lifeCycleBean =(LifeCycleBean) applicationContext.getBean("lifeBean");
6.     System.out.println(lifeCycleBean);
8.     // 销毁方法执行，必须销毁ApplicationContext
9.     applicationContext.close();
10. }

 

2) Bean的作用范围  <bean scope="" />

@Scope 注解 ，默认作用域 singleton 单例

1. @Component("scopeBean")
2. // 如果没有指定scope 是 singleton 单例
3. @Scope("prototype")
4. publicclassScopeBean{
6. }

进行测试：

1. @Test
2. // 测试Bean 范围
3. publicvoid demo2(){
4. ApplicationContext applicationContext =newClassPathXmlApplicationContext("applicationContext.xml");
5. ScopeBean scopeBean =(ScopeBean) applicationContext.getBean("scopeBean");
6. System.out.println(scopeBean);
7. ScopeBean scopeBean2 =(ScopeBean) applicationContext.getBean("scopeBean");
8. System.out.println(scopeBean2);
9. }

 

4.Spring3.0 提供 注册Bean的注解

@Configuration 指定POJO类为Spring提供Bean定义信息

@Bean 提供一个Bean定义信息

先定义2个JavaBean:

1. // 轿车
2. publicclassCar{
3. privateString name;
4. privatedouble price;
6. publicString getName(){
7. return name;
8. }
10. publicvoid setName(String name){
11. this.name = name;
12. }
14. publicdouble getPrice(){
15. return price;
16. }
18. publicvoid setPrice(double price){
19. this.price = price;
20. }
22. @Override
23. publicString toString(){
24. return"Car [name="+ name +", price="+ price +"]";
25. }
27. }

 

1. // 商品
2. publicclassProduct{
3. privateString pname;
4. privateint pnum;
6. publicString getPname(){
7. return pname;
8. }
10. publicvoid setPname(String pname){
11. this.pname = pname;
12. }
14. publicint getPnum(){
15. return pnum;
16. }
18. publicvoid setPnum(int pnum){
19. this.pnum = pnum;
20. }
22. @Override
23. publicString toString(){
24. return"Product [pname="+ pname +", pnum="+ pnum +"]";
25. }
27. }

此类需要我们自己编写，好比一个大的工厂。

1. /**
2. * 配置Bean （工厂）
3. */
4. @Configuration
5. publicclassBeanConfig{
6. // 提供两个方法 获得Car和Product对象
7. @Bean(name ="car")
8. //方法名称随意
9. publicCar initCar(){
10. Car car =newCar();
11. car.setName("大众");
12. car.setPrice(10000);
13. return car;
14. }
16. @Bean(name ="product")
17. publicProduct showProduct(){
18. Product product =newProduct();
19. product.setPname("空调");
20. product.setPnum(100);
21. return product;
22. }
23. }

进行测试：

1. @Test
2. // 获得配置Bean 工厂创建Bean对象
3. publicvoid demo(){
4. ApplicationContext applicationContext =newClassPathXmlApplicationContext("applicationContext.xml");
5. Car car =(Car) applicationContext.getBean("car");
6. System.out.println(car);
8. Product product =(Product) applicationContext.getBean("product");
9. System.out.println(product);
10. }

使用配置Bean被Spring扫描到，就可以了

5.xml和注解混合使用

很多企业开发者 还是采用xml作为主流配置

* Bean 注册 通过XML完成

* 注入使用 @Autowired 注解完成

将2个Dao注入到Service

1. // 客户DAO
2. publicclassCustomerDAO{
4. }

 

1. // 订单DAO
2. publicclassOrderDAO{
4. }

Service类(注入)：

1. // 客户Service
2. publicclassCustomerService{
3. // xml注入
4. privateCustomerDAO customerDAO;
6. publicvoid setCustomerDAO(CustomerDAO customerDAO){
7. this.customerDAO = customerDAO;
8. }
10. @Override
11. publicString toString(){
12. return"CustomerService [orderDAO="+ orderDAO +", customerDAO="
13. + customerDAO +"]";
14. }
16. }

配置(注册)：

1. <bean id="customerDAO"class="cn.itcast.spring.e_xmluseannotaion.CustomerDAO"></bean>
2. <bean id="orderDAO" class="cn.itcast.spring.e_xmluseannotaion.OrderDAO"></bean>
4. <!--将DAO 注入Service-->
5. <bean id="customerService"class="cn.itcast.spring.e_xmluseannotaion.CustomerService">
6. <property name="customerDAO" ref="customerDAO"></property>
7. </bean>

测试：

1. @Test
2. // 完成 DAO 注入到Service测试
3. publicvoid demo(){
4. ApplicationContext applicationContext =newClassPathXmlApplicationContext("applicationContext2.xml");
5. CustomerService customerService =(CustomerService) applicationContext.getBean("customerService");
6. System.out.println(customerService);
7. }

***************************************************************************************************************************************

此时，我们发现，在注册的时候使用xml比较方便，而在注入的时候使用xml方式比较麻烦，需要提供setter方法，下面使用注解方式注入

1. // 客户Service
2. publicclassCustomerService{
3. // 注解注入
4. @Autowired
5. privateOrderDAO orderDAO;
6. // xml注入
7. privateCustomerDAO customerDAO;
9. publicvoid setCustomerDAO(CustomerDAO customerDAO){
10. this.customerDAO = customerDAO;
11. }
13. @Override
14. publicString toString(){
15. return"CustomerService [orderDAO="+ orderDAO +", customerDAO="
16. + customerDAO +"]";
17. }
19. }

 

<context:annotation-config/> 启用四个注解 使@Resource、@ PostConstruct、@ PreDestroy、@Autowired注解生效

结论 ：

1、 xml配置 和 注解配置 效果完全相同

2、 如果Bean 来自第三方(源码无法改动)， 必须使用xml

3、 Spring3.0 Bean注册方式， 使用比较少，主要用于Bean 构造逻辑及其复杂

来自为知笔记(Wiz)