Spring4深入理解01----Bean配置(依赖注入和控制反转的区别)

原文地址:http://blog.csdn.net/oChangWen/article/details/52513300?locationNum=3&fps=1

spring 是什么?
    Spring 是一个开源框架.
    Spring 为简化企业级应用开发而生.
    使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能. 
    Spring 是一个 IOC(DI) 和 AOP 容器框架.

具体描述 Spring: 
  -- 轻量级:Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的API
  -- 依赖注入(DI --- dependency injection、IOC)
  -- 面向切面编程(AOP --- aspect oriented programming)
  -- 容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
  -- 框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
  -- 一站式:在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库 (实际上 Spring 自身也提供了展现层的 SpringMVC 和 持久层的 Spring JDBC)

Spring4深入理解01----Bean配置(依赖注入和控制反转的区别)_第1张图片

Spring4深入理解01----Bean配置(依赖注入和控制反转的区别)_第2张图片

只要后面是Spring IDE就行了

把以下 jar 包加入到工程的 classpath 下:

Spring4深入理解01----Bean配置(依赖注入和控制反转的区别)_第3张图片

   Spring 的配置文件: 一个典型的 Spring 项目需要创建一个或多个 Bean 配置文件, 这些配置文件用于在 Spring IOC 容器里配置 Bean. Bean 的配置文件可以放在 classpath 下, 也可以放在其它目录下

一、IOC 和 DI

    IOC(Inversion of Control):其思想是反转资源获取的方向. 传统的资源查找方式要求组件向容器发起请求查找资源. 作为回应, 容器适时的返回资源. 而应用了 IOC 之后, 则是容器主动地将资源推送给它所管理的组件, 组件所要做的仅是选择一种合适的方式来接受资源. 这种行为也被称为查找的被动形式
    DI(Dependency Injection) — IOC 的另一种表述方式:即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言,这种表述更直接

配置 bean
  --配置形式:基于 XML 文件的方式;基于注解的方式
  --Bean 的配置方式:通过全类名(反射)、通过工厂方法(静态工厂方法 & 实例工厂方法)、FactoryBean
  --IOC 容器 BeanFactory & ApplicationContext 概述
  --依赖注入的方式:属性注入;构造器注入
  --注入属性值细节
  --自动转配
  --bean 之间的关系:继承;依赖
  --bean 的作用域:singleton;prototype;WEB 环境作用域
  --使用外部属性文件
  --spEL
  --IOC 容器中 Bean 的生命周期
  --Spring 4.x 新特性:泛型依赖注入

1-1.基于 XML 文件的方式配置 bean

[java]  view plain  copy
 
  1. public class HelloWorldBean {  
  2.     private String user;  
  3.   
  4.     public HelloWorldBean() {  
  5.         System.out.println("HelloWorldBean's constructor...");  
  6.     }  
  7.   
  8.     // 如果这里修改为setUser2,刚applicationContext.xml修改为property name="user2"  
  9.     public void setUser(String user) {  
  10.         System.out.println("setUser:" + user);  
  11.         this.user = user;  
  12.     }  
  13.   
  14.     public HelloWorldBean(String user) {  
  15.         this.user = user;  
  16.     }  
  17.   
  18.     public void hello(){  
  19.         System.out.println("Hello: " + user);  
  20.     }  
  21. }  
applicationContext.xml的关键内容如下:
[html]  view plain  copy
 
  1.   
  2.       
  3.     <property name="user" value="Tom2"/>  
  4. bean>  
  5.   
  6. <bean id="helloWorld3" class="Spring4_IOC.bean.HelloWorldBean">  
  7.       
  8.     <constructor-arg value="Mike"/>  
  9. bean>  
2).构造方法注入
  通过构造方法注入Bean 的属性值或依赖的对象,它保证了 Bean 实例在实例化后就可以使用。
  构造器注入在 元素里声明属性, 中没有 name 属性
[java]  view plain  copy
 
  1. public class Car {  
  2.     private String company;  
  3.     private String brand;  
  4.     private int maxSpeed;  
  5.     private float price;  
  6.   
  7.     public Car() {  
  8.     }  
  9.   
  10.     public Car(String brand, float price) {  
  11.         super();  
  12.         this.brand = brand;  
  13.         this.price = price;  
  14.     }  
  15.   
  16.     public Car(String company, String brand, float price) {  
  17.         super();  
  18.         this.company = company;  
  19.         this.brand = brand;  
  20.         this.price = price;  
  21.     }  
  22.   
  23.     public CarCycle(String company, String brand, int maxSpeed) {  
  24.         super();  
  25.         this.company = company;  
  26.         this.brand = brand;  
  27.         this.maxSpeed = maxSpeed;  
  28.     }  
  29.   
  30.     public Car(String company, String brand, int maxSpeed, float price) {  
  31.         super();  
  32.         this.company = company;  
  33.         this.brand = brand;  
  34.         this.maxSpeed = maxSpeed;  
  35.         this.price = price;  
  36.     }  
  37.   
  38.  //省去get,set方法  
  39.   
  40.     @Override  
  41.     public String toString() {  
  42.         return "CarCycle [company=" + company + ", brand=" + brand + ", maxSpeed="  
  43.                 + maxSpeed + ", price=" + price + "]";  
  44.     }  
  45. }  

[html]  view plain  copy
 
  1.   
  2.  <bean name="car" class="Spring4_IOC.bean.Car">  
  3.      <constructor-arg value="KUGA" index="0"/>  
  4.      <constructor-arg value="ChangAnFord" index="1"/>  
  5.      <constructor-arg value="250000" type="float"/>  
  6.  bean>  
  7.   
  8.  <bean id="car2" class="Spring4_IOC.bean.Car">  
  9.        
  10.      <constructor-arg value="ChangAnMazda" type="java.lang.String"/>  
  11.        
  12.      <constructor-arg value="ShangHai" type="java.lang.String"/>  
  13.      "+car);  
  14.   
  15.     //测试car里有多个构造器,如何配置IOC  
  16.     Car car2 = (Car) ctx.getBean("car2");  
  17.     System.out.println("2-->"+car2);  
  18.   
  19. }  
1-->CarCycle [company=KUGA, brand=ChangAnFord, maxSpeed=0, price=250000.0]
2-->CarCycle [company=ChangAnMazda, brand=ShangHai, maxSpeed=180, price=0.0]
3).注入属性值细节
引用其它 Bean

    组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使  Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
    在 Bean 的配置文件中, 可以 通过 元素或 ref  属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
    也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为 内部 Bean
[html]  view plain  copy
 
  1. <bean id="person" class="Spring4_IOC.bean.Person">  
  2.     <property name="name" value="changwen"/>  
  3.     <property name="age" value="24"/>  
  4.       
  5.     <property name="car" ref="car2"/>  
  6.     

你可能感兴趣的:(java)