gubai

  1.什么是IOC,其是干什么的 有何作用

Spring核心思想,控制反转或依赖注入,把所有的javaBean都交给spring容器来管理,是通过.xml的形式对javaBean之间的依赖关系进行管理。所谓的反转是相对正传而言,假如有两个类A 和B,

若是在A类中需要调用B类的方法,正向是直接new获得。ioc 中就是把所有的控制权交给了Spring容器,不在主动的去获取是被动的等待,等待容器把建好的对象给他。

spring的ioc解决的就是各个bean之间的耦合关系,其是可以简单理解成在不同的bean之间添加了一个中间层(IOC容器)由它去处理bean之间的关系,这样就达到了松散耦合的效果了。

     控制反转(IOC)也可以理解成依赖注入(DI),如 上面所说A类中用到了B类中的方法,就是所A依赖与B所以在需要把B对象通过spring容器注入导A的bean中,我的理解是bean之间通过依赖spring容器来注

入一些需要的资源。这个也可以说是和ioc是一样的吧,只是以不同的角度去理解的。

2.常用的IOC的注入方式

  2.1 setter方法注入 这种方式运用广泛

       2.2 构造器注入

       2.3 接口注入

setter注入:若有两个类 A类和B类 ,我需要在A类中调用B类的方法 ,B就是一个简单的类 其只有一个方法bb();

 

 1 public class A{
 2     private B b;
 3     public void setB(B b) {
 4         this.b = b;
 5     }
 6     
 7     public void  amethod(){
 8         //这里边调用B对象的dem01方法 ,若是不用IOC的方式 直接可以new对象调用就可以
 9         b.bb();
10     }
11     
12 }

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"
>
<!--set方法注入 把B对象注入到了A中-->
<bean id="a" class="com.myspring.A">
<!-- 解释一下property标签 ,其中的name指的事在A中声明的B 的名字,ref指的是B对应的bean的唯一id -->
<property name="b" ref="b"></property>
<!-- A类找那个定义了B这个属性,有其setter方法,这样spring容器就会在初始化的时候把把通过setter方法注入到A中 -->
</bean>
<bean id="b" class="com.myspring.B">
</bean>

</beans>

测试代码:

1 public static void main(String[] args) {
2         ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");        
3       A a=(A)ac.getBean("a");
4       a.amethod();
5     }//结果成功调用了B类的方法

  构造方法注入:

 1 public class A{
 2     private B b;
 3     //注意这里边没有生成seter方法,因此不能用setter注入
 4 public A(B b){
 5     this.b=b;
 6 }    
 7     public void  amethod(){
 8         //这里边调用B对象的dem01方法 ,若是不用IOC的方式 直接可以new对象调用就可以
 9         b.bb();
10     }
11 }
 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns:util="http://www.springframework.org/schema/util"
 5     xmlns:p="http://www.springframework.org/schema/p"
 6     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"
 8         >
 9      <bean id="a"  class="com.myspring.A">
10 <constructor-arg ref="b"></constructor-arg>  
11     </bean>
12     <bean id="b"  class="com.myspring.B">
13     </bean>
14  </beans>

  这两种注入方式,比较容易理解 ,配置起来也很简便,但是假如我需要在A对象中注入很多个对象那,难道还是向上边那样一个一个的写property或constructor-arg 标签吗 答案肯定是否定的

其实Spring 有自动装配这种机制,更加的实用。

3.Spring 的自动装配

    为了提高开发的效率spring提供了自动装配,其默认是不开启的,我们可以通过配置autowire属性来设置适合自己的装配方式,autowire可以在beans里配置,也可以直接在bean里配置

 常用的自动装配方式有:byname  bytype   by constructor    autudetect    no  5种。其中最常用的就是 byname  和 bytype。

 通过byName自动装配

 1 public class A{
 2     
 3     private B ss;
 4     
 5     public void setSs(B ss) {
 6         this.ss = ss;
 7     }
 8     public void  amethod(){
 9         ss.bb();
10     }
11 }
12 <?xml version="1.0" encoding="UTF-8"?>
13 <beans xmlns="http://www.springframework.org/schema/beans"
14     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
15     xmlns:util="http://www.springframework.org/schema/util"
16     xmlns:p="http://www.springframework.org/schema/p"
17     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
18         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"
19         default-autowire="byName">
20   <!-- spring的自动装配,其实就是为了解决 property标签过多带来的不便 -->
21  <bean id ="a"   class="com.myspring.A"  ></bean>
22   <bean id ="ss"   class="com.myspring.B"></bean> 
23 </beans>

代码解释:A类的setter方法是必须要有的,Spring会自动寻找与属性名字“ss”相同的bean(就是在A类中声明的那个属性名),找到id为ss的那个bean ,通过setter方法注入到A类中。

  byType:

 1 public class A{
 2     
 3     private B ss;
 4     
 5     public void setSs(B ss) {
 6         this.ss = ss;
 7     }
 8     public void  amethod(){
 9         ss.bb();
10     }
11 }
12 <?xml version="1.0" encoding="UTF-8"?>
13 <beans xmlns="http://www.springframework.org/schema/beans"
14     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
15     xmlns:util="http://www.springframework.org/schema/util"
16     xmlns:p="http://www.springframework.org/schema/p"
17     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
18         http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd"
19         default-autowire="byType">
20   <!-- spring的自动装配,其实就是为了解决 property标签过多带来的不便 -->
21  <bean id ="a"   class="com.myspring.A"  ></bean>
22   <bean    class="com.myspring.B"></bean> 
23 </beans>

代码解释:Spring会总动寻找与属性类型相同的bean,找到后,通过调用setter将其注入。这里边我没有给B类的bean 设置id ,就是为了强调 是通过类型去查找的,不需要name.

一旦有两种相同数据类型的bean被配置,将抛出UnsatisfiedDependencyException异常.

constructor: 设置 default-autowire="constructor" ,其他写法都是和上边的一样,Spring会寻找与参数数据类型相同的bean,通过带参数的构造函数public A(B b)将其注入。

autodetect:spring首先会寻找是否有带参的构造函数,若有就会和constructor一样用 构造器注入,否则就和byype一样 setter注入:

最常用的是byName 和byType. 

 

 

posted on 2018-06-07 16:21 古白 阅读(...) 评论(...) 编辑 收藏

分类:

技术点:

spring

相关文章: