精华内容
下载资源
问答
  • spring 控制反转

    千次阅读 2019-06-06 21:27:14
    简单说一下什么控制反转。 一般我们创建类的时候是 A a = new A(); 我们自己创建的对吧。但是控制反转的意思是我们把控制权让出来。本来创建对象的控制权是在我们的手中。这里我们把控制权给了spring 如 @...

    简单说一下什么是控制反转。

    一般我们创建类的时候是 

    A a = new A();

    我们自己创建的对吧。但是控制反转的意思是我们把控制权让出来。本来创建对象的控制权是在我们的手中。这里我们把控制权给了spring

    @autowrite

    A a;

    然后我们就可以直接使用a对象了。很神奇吧。

    这里的过程是spring new了A ,把对象放进ioc容器中,最后在依赖注入到 a。

    展开全文
  • 控制反转IOC(Inversion of Control): 是一个重要的面向对象编程的法则,来消减计算机程序的耦合的问题;也是轻量级的Spring框架的核心。 控制反转的两种类型:依赖注入;依赖查找。 控制反转实质指的是: 之前创建...

    控制反转IOC(Inversion of Control): 是一个重要的面向对象编程的法则,来消减计算机程序的耦合的问题;也是轻量级的Spring框架的核心。

    控制反转的两种类型:依赖注入;依赖查找。

    控制反转实质指的是: 之前创建对象的时候,在action里创建service,在service里创建DAO,都得自己new。使用Spring框架后,将对象的创建权反转给Spring。

    展开全文
  • 浅析Spring——控制反转IoC

    千次阅读 多人点赞 2020-09-06 10:10:16
    IoC:Inversion of Control(控制反转) 接下来我们以一个示例,讲述Ioc的本质 程序结构图: dao:数据访问层 service:服务层,用来调用dao层 1、编写UserDao接口 package dao; public interf


    1. IoC理论推导

    IoC:Inversion of Control(控制反转)

    接下来我们以一个示例,讲述Ioc的本质

    程序结构图:

    • dao:数据访问层
    • service:服务层,用来调用dao层
      image-20200729233429225

    1、编写UserDao接口

    package dao;
    
    public interface UserDao {
        public void getUser();
    }
    

    2、编写UserDao接口实现类UserDaoImpl

    package dao;
    
    //业务一:默认获取用户数据
    public class UserDaoImpl implements UserDao {
        public void getUser() {
            System.out.println("默认获取用户的数据");
        }
    }
    

    3、编写UserService接口

    package service;
    
    public interface UserService {
        public void getUser();
    }
    

    4、编写UserService接口业务实现类UserServiceImpl

    package service;
    
    import dao.UserDao;
    import dao.UserDaoImpl;
    
    public class UserServiceImpl implements UserService {
        //内置UserDaoImpl实例化对象
        private UserDao userDao = new UserDaoImpl();
    
        public void getUser() {
            userDao.getUser();
        }
    }
    

    5、编写测试类,实现业务一

    import dao.UserDaoImpl;
    import service.UserServiceImpl;
    
    public class MyTest {
        public static void main(String[] args) {
            //用户实际调用的是业务层,dao层不需要接触
            UserServiceImpl userService = new UserServiceImpl();
            userService.getUser();
        }
    }
    

    6、新增业务:新增业务二:MySQL获取用户数据

    新增UserDao接口实现类UserDaoMysqlImpl

    package dao;
    
    public class UserDaoMysqlImpl implements UserDao{
        public void getUser() {
            System.out.println("MySQL获取用户数据");
        }
    }
    

    如果我们要实现业务二,就必须修改UserServiceImpl业务实现类里的代码为:

    package service;
    
    import dao.UserDao;
    import dao.UserDaoImpl;
    
    public class UserServiceImpl implements UserService {
        //将对象变为UserDaoMysqlImpl实例化的对象
        private UserDao userDao = new UserDaoMysqlImpl();
    
        public void getUser() {
            userDao.getUser();
        }
    }
    
    • 如果我们要增加其他的业务,就得增加对应的Dao层实现类,就需要去UserServiceImpl业务实现类里面修改对应的代码

    • 业务需求量非常大的情况下 , 每次变动 , 都需要修改大量代码耦合性太高

    解决问题:在UserServiceImpl业务实现类中增加set方法

    import dao.UserDao;
    import dao.UserDaoImpl;
    
    public class UserServiceImpl implements UserService {
        private UserDao userDao;
    
        //利用set进行动态实现值的注入
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void getUser() {
            userDao.getUser();
        }
    }
    

    此后,我们需要用到什么业务的时候,只需要在测试类中选择对应的业务实现类对象注入即可

    import dao.UserDaoImpl;
    import service.UserServiceImpl;
    
    public class MyTest {
        public static void main(String[] args) {
            //用户实际调用的是业务层,dao层不需要接触
            UserServiceImpl userService = new UserServiceImpl();
            //选择业务二
            userService.setUserDao(new UserDaoImpl());
            //选择业务一
            userService.getUser();
        }
    }
    

    这就是Ioc的本质:控制反转

    • 移交了主动权,大大降低了系统的耦合性,更加专注于业务的实现

    通过控制反转,对象在被创建的时候,由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说,依赖被注入到对象中。

    • 改进前,主动权在程序员手中,程序员修改相关代码来实例化不同的业务实现类对象,以此来调用不同的业务
    • 改进后,主动权掌握在用户手中,用户可以选择不同的业务实现类实例对象直接进行注入,直接进行调用,而不需要程序员进行代码的修改


    2. 什么是IoC?

    控制反转(Inversion of Control,缩写为IoC

    • 面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度
    • 有两种常见的实现方式
      • 最常见:依赖注入(Dependency Injection,简称DI
      • 依赖查找(Dependency Lookup)
    • IoC可以认为是一种全新的设计模式,但是理论和时间成熟相对较晚,并没有包含在GoF中。
    • IoC中最基本的Java技术就是“反射”编程,根据给出的类名(字符串)来生成对象


    3. 引入DI

    上述理论推导例子在一定程度上缓解了问题,但实质上这种代码耦合并没有改变!

    这就引入了我们接下来的Ioc模式的实现方式之一:DI就是最常见的一种方式

    依赖注入(DI):把耦合从代码中移出去,放到统一的XML文件中,通过一个容器在需要的时候把这个依赖关系形成,即把需要的接口实现注入到需要它的类中

    • 这里的容器就是IoC容器
    • 可以把IoC模式看作工厂模式的升华,把IoC容器看作是一个大工厂,只不过这个大工厂里要生成的对象都是在XML文件中给出定义的


    4. IoC容器

    IoC模式,系统中通过引入实现了IoC模式的IoC容器

    • IoC容器用来来管理对象的生命周期、依赖关系等,从而使得应用程序的配置和依赖性规范与实际的应用程序代码分离。
    • **特点:**就是通过文本的配置文件进行应用程序组件间相互关系的配置,而不用重新修改并编译具体的代码。
    • 常见的IoC容器:Pico Container、Avalon 、Spring、JBoss、HiveMind、EJB等。


    5. 注入对象的四种方法

    使用IoC模式后,我们不用再写死创建指定对象的代码,而是灵活的动态注入所需的对象,有三种常见的注入方式:

    1、基于接口

    • 可服务的对象需要实现一个专门的接口,该接口提供了一个对象,可以重用这个对象查找依赖(其它服务)。
    • 早期的容器Excalibur使用这种模式。
    • 接口方式注入显得比较霸道,因为它需要被依赖的对象实现不必要的接口,带有侵入性。一般都不推荐这种方式

    2、基于setter

    • 通过JavaBean的属性(setter方法)为可服务对象指定服务。(上述例子就是通过此形式注入)
    • HiveMindSpring采用这种方式。

    3、基于构造函数

    • 通过构造函数的参数为可服务对象指定服务。
    • PicoContainer只使用这种方式,HiveMindSpring也使用这种方式。

    4、基于注解

    • Spring2.5开始支持注解,从此我们可以通过注解简单高效的实现注入
    • 这是我们开发中最常使用的方法


    6. 两种IoC实现方式

    1、依赖查找

    • 容器提供回调接口上下文条件给组件。
    • 组件使用容器提供的API来查找资源和协作对象,仅有的控制反转只体现在那些回调方法上(基于接口):容器将调用这些回调方法,从而让应用代码获得相关资源。

    2、依赖注入

    • 组件不做定位查询,只提供普通的Java方法让容器去决定依赖关系。
    • 容器全权负责的组件的装配,它会把符合依赖关系的对象通过JavaBean属性或者构造函数传递给需要的对象。
      • 通过JavaBean属性注射依赖关系的做法称为设值方法注入(Setter Injection)
      • 将依赖关系作为构造函数参数传入的做法称为构造器注入Constructor Injection


    7. 总结

    控制反转IoC是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。

    在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)。

    • 了解IoC以前,我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全写死子在程序中,对象的创建由程序自己控制

    • 控制反转后将对象的创建转移给第三方,所谓控制反转就是:获得依赖对象的方式反转了。

    IoC是Spring框架的核心内容,使用多种方式完美的实现了IoC

    • 可以使用XML配置
    • 也可以使用注解
    • 新版本的Spring也可以零配置实现IoC

    Spring容器在初始化时先读取配置文件,根据配置文件或元数据创建与组织对象存入容器中,程序使用时再从Ioc容器中取出需要的对象。

    采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。

    展开全文
  • spring——控制反转

    万次阅读 多人点赞 2012-03-09 16:44:19
    像前面博客中提到struts框架,Hibernate框架似的,spring同样也是一个开源的框架。使用框架的的优势在于分层结构,每层有相应的框架,减少开发工作量,减少组件之间的耦合。struts框架应用web层,Hibernate框架应用...
         像前面博客中提到struts框架,Hibernate框架似的,spring同样也是一个开源的框架。使用框架的的优势在于分层结构,每层有相应的框架,减少开发工作量,减少组件之间的耦合。struts框架应用web层,Hibernate框架应用持久层,spring应用两者之间。
    

       我觉得,框架是出于聪明的赖人之手。聪明是说他们开发封装每层框架,把复杂的操作全部封装在框架中。而赖人是说他所有复杂的操作实现全部交给计算机来实现,减少人们的开发工作量,把工作的注意力集中在业务逻辑上。

       那我们来介绍一下struts框架。

           spring框架是一个开源的轻量级的基于IOCAOP核心技术的容器框架,主要是解决企业的复杂操作实现。

       那IOCAOP,到底如何解释呢,在看spring视频中,两个专业术语一定必须要懂得。

           IOCinverse of Control:控制反转。意思是程序中的之间的关系,不用代码控制,而完全是由容器来控制。在运行阶段,容器会根据配置信息直接把他们的关系注入到组件中。同样,这也是依赖注入的含义。依赖注入和控制反转其实是一个概念。只不过强调的不同而已,依赖注入强调关系的注入是由容器在运行时完成,而控制反转强调关系是由容器控制。其实本质是一样的。

       用代码演示一下控制反转是如何实现的。

    1。新建一个普通的java项目。

    2。引入相应的jar包。Spring.jar,log4j-1.2.14.jar(提供日志功能的),commons-logging.jar

    3。提供log4j.properties配置文件。(日志jar包可以不用添加)

    4。提供配置文件ApplicationContext.xml文件

    5。开始写代码。

    package ioc.iocsample;
    /**
     * 学校类
     * @author lhy
     *
     */
    public class School {
       private String name;
       public School(String name)
       {
    	   this.name=name;
       }
       public void printInfo()
       {
    	   System.out.println("该学校的名称是:"+name);
       }
    }
    package ioc.iocsample;
    /**
     * 学生类
     * @author lhy
     *
     */
    public class Student {
      public int id;
      public String name;
      private School school;
    public int getId() {
    	return id;
    }
    public void setId(int id) {
    	this.id = id;
    }
    public String getName() {
    	return name;
    }
    public void setName(String name) {
    	this.name = name;
    }
    public School getSchool() {
    	return school;
    }
    public void setSchool(School school) {
    	this.school = school;
    }  
    }

     
         配置文件:

    <?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:aop="http://www.springframework.org/schema/aop"
    	     xmlns:tx="http://www.springframework.org/schema/tx"
    	     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
               http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
     <bean id="school" class="ioc.iocsample.School">
    	   <constructor-arg index="0">
    	     <value>廊坊师院</value>
    	   </constructor-arg>
     </bean>
     <bean id="student" class="ioc.iocsample.Student">
    	 <property name="id"      value="001"/>
    	 <property name="name" value="张三"/>
    	 <property name="school"  ref ="school"/>
     </bean>
    </beans>


        客户端进行测试,其中学生类Student中有School中的引用,测试该学生就读的学校的名称如下:

    package ioc.iocsample;
    
    import org.springframework.beans.factory.BeanFactory;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Client {
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");
    		Student student=(Student)factory.getBean("student");
    		student.getSchool().printInfo();
    	}
    }


        其中,在程序中不用实例化学生类,学校类,直接由容器中的beanFactory直接创建,隐藏了创建了细节。同时,程序中也不用关心学生类与学校类之间的依赖关系,而由容器来进行负责,在运行的时候,容器会把属性值及依赖关系注入学生类和学校类中的javabean中(其实在此School和Student就是一个javaBean。javaBean就是一个按照一定的原则封装的java类而已。)

       其中依赖注入包括两种:一种赋值注入(使用getter和setter方法);另一种使用构造器注入。

       看程序中student中的ID,name都是使用get,set来赋值的:那在配置文件是如下配置:

           <property name="id"      value="001"/>
           <property name="name" value="张三"/>

       并且Student中的school属性是School类型,则在容器中是如下配置的:

           <property name="school"  ref ="school"/>

       而在程序中的School中的name是构造器赋值的,则容器中是如下配置的:

          <constructor-arg index="0">
             <value>廊坊师院</value>
          </constructor-arg>

       构造器中一个参数,则索引值是从0开始,若是有多个,依次递增。

        若构造器中的是一个类,则使用bean标签

       <constructor-arg index="0">

        <bean class="具体的类">

      </constructor-arg>

      

       PS:当再次看博客,有了新的感触。2012年8月7日 15:06:52

       spring中的依赖注入DI(dependence injection)共有三种方式:第一种是接口注入(Interface Injection)第二种是get set注入(set/get Injection)第三种是构造器注入(Constructor Injection)

       三种注入方式的区别:

       1.接口注入:组件需要依赖特定接口的实现,其中的加载接口实现和接口实现的具体对象都是由容器来完成。这样,接口必须依赖容器,这样的组件具有侵入性,降低了重用性。其中如J2EE开发中常用的Context.lookup(ServletContext.getXXX),都是接口注入的表现形式。(这种注入方式不是常用的)

      

       2.getter/setter方式注入:对于需要注入的东西比较明确。符合java的设计规则。更适合java开发人员,使用起来更加自然,更加方便。

     

       3.构造器方式注入:在类加载的时候,就已经注入依赖的组件。但是若是参数多的话,使用起来不方便。

     

      但是后两种注入方式是spring常用的,而第一种接口注入方式不常用。

         

    展开全文
  • 几位轻量级容器的作者曾骄傲地对我说:这些容器非常有用,因为它们实现了“控制反转”。这样的说辞让我深感迷惑:控制反转是框架所共有的特征,如果仅仅因为使用了控制反转就认为这些轻量级容器与众不同,就好象在说...
  • Spring的作用之一是控制反转(依赖注入),要说清反转控制需要依次说清三个问题:1.控制反转的目的是什么控制反转的目的是——解耦2.控制反转是如何实现的解耦?没有控制反转之前我们实现解耦的一个重要手段是使用...
  • Spring 基础 控制反转和依赖注入

    千次阅读 2016-04-28 15:14:56
    1.IOC(控制反转)/DI(依赖注入):把整个项目中的所有对象交给Spring容器管理  IOC:取到对象  DI:对象的装配  依赖注入有两种方式: 1. 属性值注入方式 a. 普通类型 注入方式 b.bean注入方式 测试结果
  • 为什么要使用Spring为什么要使用控制反转(IOC)和依赖注入(DI),为什么要使用AOP Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE ...
  • Spring控制反转IOC

    千次阅读 2016-05-11 21:26:44
    spring控制反转(IOC)思想,对象实例不再是由调用者来创建,改为spring容器来创建。spring容器会负责控制程序之间的关系,不再由程序代码直接控制,控制权由应用的代码转向了外部容器,所谓控制反转spring有两...
  • Spring IOC控制反转(Inverse of Control ) IOC概念 IOC是一种设计思想,就是指将原本在程序中手动创建对象的控制权,交由Spring框架来管理。 IOC容器是具有依赖注入功能的容器,负责对象的实例化,对象的初始化,...
  • Ioc 全名Inversion of Control ,翻译过来就是控制反转的意思.上一篇文章中,我们学习了依赖注入. Spring能有效地组织J2EE应用各层的对象.不管是控制层的Action对象,还是业务层的Service对象,还是持久层的DAO层对象,...
  • 什么控制反转?什么是依赖注入? 1.spring是一个轻量级开源框架 2.ioc:控制反转,控制权的转移,应用程序本身不负责依赖对象的创建和维护,而是外部容器负责创建和维护,也就是不显示进行new创建对象 3.dl:依赖注入:是...
  • 周末在网上逛的时候看到了一篇Spring的视频,翻到了控制反转讲解那一篇发现听后豁然开朗,因为之前学习的时候都是...首先控制反转就是IOC是Spring两大核心之一,其次想知道IOC是什么,需要思考一下两个为什么? ...
  • Spring控制反转和依赖注入

    千次阅读 2014-10-22 18:21:16
    (1)为什么使用控制反转和依赖注入 调用者不用去关心被调用者的实现,不需要调用者亲自创建被调用者的实例,这些操作都交给框架去完成。 这种设计思想就是控制反转(Inversion of Control, IoC),同时,它还有...
  • Spring中到底什么控制反转

    千次阅读 2016-05-11 20:02:35
    从接触spring框架开始,控制反转这个名词也不算陌生了,一直模模糊糊没用弄清楚它真正的含义,知道今天算是比较清楚地明白了。 讲spring中的控制反转,我们先要从一个例子说起: 比如一个类A中,需要用到另一个类B...
  • Spring底层控制反转解耦合(IOC)

    千次阅读 2017-07-26 11:40:05
    简单的例子解释IOC控制反转进行解耦合一、相关概念 (1)解耦合 解耦合就是把程序中互相不相关或有限相关的模块分割开来,把不同模块互相之间的关系用接口进行准确定义,解耦前,两个模块之间共享所有信息;(2)...
  • spring——控制反转简单例子

    千次阅读 2016-05-16 12:37:37
    控制反转,和依赖注入是同一个意思,我觉得应该重点去了解什么是依赖,而后控制反转、依赖注入就有体会了;关于依赖,可以查看UML相关的书籍,重点去看java对象之间的关系是怎样的,而所谓的依赖就是对象之间的一种...
  • Spring中,所有的对象都不用程序员去创建的,而是由Spring框架来完成,将创建对象的控制权交给了Spring框架,这就叫做“控制反转”。  那么控制反转是怎么做到的呢?  利用Java的反射机制和依赖注入,当程序...
  • Spring控制反转(IOC)和依赖注入(DI)详解
  • Spring控制反转的三种方式

    千次阅读 2016-03-23 10:43:20
    Ioc(控制反转) :Spring的基本思想之一。将A和B之间的管理交由C管理。通常使用一下三种方式: 1、构造方法注入 2、setter注入 3、接口注入
  • 初识spring——控制反转

    千次阅读 热门讨论 2013-11-25 09:35:31
     在这里,spring控制反转就很好的我们实现了该功能。 控制反转 什么控制反转(IoC)  控制反转( Inversion of Control ,英文缩写 IoC )是一个重要的面向对象编程的法则来削减计算机程序的耦合...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,496
精华内容 26,198
关键字:

为什么spring可以控制反转

spring 订阅