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 构造逻辑及其复杂

最新文章

  1. 遍历迭代map的集中方法
  2. 单点登录与消息队列以及在J2EE中的实现方案
  3. bzoj1079
  4. Python操作Excel_随机点菜脚本
  5. C++ STL中的常用容器浅谈
  6. hdu1114小猪抢劫银行
  7. wireshark查看sip协议流
  8. C—动态内存分配之malloc与realloc的区别
  9. Dynamics CRM2013/2015 检索实体属性的两种方式
  10. 『cURL』curl: (6) Could not resolve host无法解析主机地址
  11. ASP.NET SignalR介绍
  12. PDF裁剪页面，PDF怎么裁剪页面的方法
  13. 关于wincc与博图的安装问题
  14. 修改Tomcat的默认访问目录
  15. Qt_QTabWidget_多行
  16. 算法笔记--STL中的各种遍历及查找(待增)
  17. 【BZOJ】【3612】【HEOI 2014】平衡
  18. Merge Interval leetcode java
  19. ftp 命令行操作 经常使用命令
  20. 玩转树莓派《三》——Scratch

热门文章

  1. 怎样查出SQLServer的性能瓶颈
  2. UISlider控件属性及方法（转）
  3. 数字转表格标题 Excel Sheet Column Title
  4. PHP数组的一些常用函数
  5. java 堆栈 静态
  6. 使用crontab不能正常执行的问题
  7. javaScript数组循环删除
  8. JAVA中int、String的类型相互转换
  9. hdu 1061 Rightmost Digit
  10. JavaScript中创建类，赋值给ajax中的data参数