精华内容
下载资源
问答
  • Spring 考试试题 下面关于 Spring 的说话正确的是 B C选择两项 ASpring 是一个重量级的框架 BSpring 是一个轻量...A控制反转 B对象被动的接受依赖类 C对象主动的去找依赖类 D一定要用接口 3下面关于 AOP的理解正确的是
  • spring的依赖注入理解

    2015-10-21 14:02:37
    (1) 使用Ioc,对象被动的接受依赖类,而不是自己主动去找。容器在实例化的时候主动将它的依赖类注入给它。    亦可以这样理解:控制反转将类的主动权转移到借口上,依赖注入通过xml配置文件在类实例化是将其...
    Java代码  收藏代码
    1.     Sping  框架的核心就是IOC控制反转和DI依赖注入,并通过这两方面实现松耦合。  
    2.   
    3. (1) 使用Ioc,对象是被动的接受依赖类,而不是自己主动去找。容器在实例化的时候主动将它的依赖类注入给它。  
    4.   
    5. 亦可以这样理解:控制反转将类的主动权转移到借口上,依赖注入通过xml配置文件在类实例化是将其依赖注入。  
    6.   
    7. (2) 从UML查看java对象之间的关系即是依赖。   
    8.   
    9. 例如:比如a对象依赖于b对象,那么a类中就会有b类的引用(简单理解就是拥有b类的这么一个属性),也就是说a对象要想执行一个完整的功能,  
    10.   
    11. 必须建立一个前提——a对象中的b类属性已经实例话,并且拥有b类的一切功能;现在可以去了解什么是依赖注入了,就像前面说过的,a对象想完  
    12.   
    13. 成一个完整的功能,要先为自己的b类属性实例化,而在MVC模式中,这种现象很常见,为了简化这种实例化的工作,spring容器就产生了,它可以  
    14.   
    15. 统一管理这种实例化频繁的操作,就是说这种本来应由自己实例化的工作交给Spring容器去控制了,也就是说控制反转了,实现的方案之一是在上  
    16.   
    17. 述a类中提供一个关于b类的setter方法,这个方法会被Spring容器控制。  

    Java代码  收藏代码
    1. (3) 从代码角度看实例:  
    2. 假设有一个需求,类Business需要调用类DependencyClass的方法doMethod(),  
    3. 按照日常的做法,得到如下代码示例:  
    4.   
    5. //*类DependencyClass  
    6. publi class Dependency{  
    7.   
    8.    public void doMethod(){};      
    9. }  
    10.   
    11. //**类Business  
    12. public class Business{  
    13.   DependencyClass  obj;  
    14.   public Business(){  
    15.     obj = new DependencyClass();  
    16.   }  
    17.   public  void doSth(){  
    18.     obj.doMethod();  
    19.   }  
    20. }  


    Java代码  收藏代码
    1.  先将Business里的DependencyClass实例的获得改为setter方式,  
    2. 其次,将DependencyClass 类改为某个接口的实现,故有如下代码:  
    3.   
    4. //**接口IDependency  
    5. public interface IDependency{  
    6.    void doMethod();  
    7. }  
    8.   
    9. //**类Dependency  
    10. public class DependencyClass implements IDpendency{  
    11.   
    12.    public void doMethod(){......}  
    13. }  
    14. //类Business  
    15. public class Business{  
    16.     Idependency obj;  
    17.     public Business(){}  
    18.     public void doSth(){  
    19.        ...  
    20.        obj.doMethod();  
    21.     }  
    22.     public void setObj(Idependency d){  
    23.     this.obj = d;     
    24.    }  
    25. }  
    26. 代码中可以看出:  
    27. (1) Business的变量obj可以接受任何IDenpendency的实例  
    28. (2) DependencyClass 的实例不是通过Business自己new出来,而是通过setter来由外部传给它。  
    29. 此时考虑Business依赖的实例如何从外部注入,就要通过xml定义,spring容器再依据xml来实例化。  
    30.   
    31. 创建一个spring-context.xml  
    32. <beans>  
    33.  <bean id="dependency" class="*****.DependencyClass"> 实体类名包  
    34.  <bean id ="business"  class="****.Business">  
    35.     <proproty name="obj">  
    36.     <ref bean ="dependency"  
    37.     </property>     
    38.  </bean>  
    39. </beans>  
    40. 这里的配置文件将DependencyClass类和Business类加入,并将DependencyClass作为Business的一个 参数。  
    41.  容器加载通过xml来实例化相关的bean.  
    42. 通过上面不难发现:  
    43. (1) Business 是通过接口IDependency来接受DependencyClass实例,所以  
    44. 当我们又有新的IDenpendency的实现是,只需要修改xml文件即可,  


    Java代码  收藏代码
    1. 通过上例可以总结出:  
    2. a. 依赖类是通过spring容器解析xml后来注入的,而不是使用它的类(Business)来自己制造,这就是依赖的注入。  
    3.   
    4. b. Bussiness 对类Dependency 的依赖转移到对接口IDependency的依赖,控制权由类转移到了接口,即由"实现"转移到"抽象"中。  
    5.   
    6. c. 通过将对实例的依赖,改为对接口的依赖。是面向接口编程的一个要义。也是程序解耦的一个措施。  
    展开全文
  • (1) 使用Ioc,对象被动的接受依赖类,而不是自己主动去找。容器在实例化的时候主动将它的依赖类注入给它。 亦可以这样理解:控制反转将类的主动权转移到借口上,依赖注入通过xml配置文件在类实例化是将其依赖...

    Sping 框架的核心就是IOC控制反转和DI依赖注入,并通过这两方面实现松耦合。

    (1) 使用Ioc,对象是被动的接受依赖类,而不是自己主动去找。容器在实例化的时候主动将它的依赖类注入给它。

    亦可以这样理解:控制反转将类的主动权转移到借口上,依赖注入通过xml配置文件在类实例化是将其依赖注入。

    (2) 从UML查看java对象之间的关系即是依赖。

    例如:比如a对象依赖于b对象,那么a类中就会有b类的引用(简单理解就是拥有b类的这么一个属性),也就是说a对象要想执行一个完整的功能,

    必须建立一个前提——a对象中的b类属性已经实例话,并且拥有b类的一切功能;现在可以去了解什么是依赖注入了,就像前面说过的,a对象想完

    成一个完整的功能,要先为自己的b类属性实例化,而在MVC模式中,这种现象很常见,为了简化这种实例化的工作,spring容器就产生了,它可以

    统一管理这种实例化频繁的操作,就是说这种本来应由自己实例化的工作交给Spring容器去控制了,也就是说控制反转了,实现的方案之一是在上

    述a类中提供一个关于b类的setter方法,这个方法会被Spring容器控制。


    (3) 从代码角度看实例:
    假设有一个需求,类Business需要调用类DependencyClass的方法doMethod(),
    按照日常的做法,得到如下代码示例:

    //*类DependencyClass
    publi class Dependency{

    public void doMethod(){};
    }

    //**类Business
    public class Business{
    DependencyClass obj;
    public Business(){
    obj = new DependencyClass();
    }
    public void doSth(){
    obj.doMethod();
    }
    }



    先将Business里的DependencyClass实例的获得改为setter方式,
    其次,将DependencyClass 类改为某个接口的实现,故有如下代码:

    //**接口IDependency
    public interface IDependency{
    void doMethod();
    }

    //**类Dependency
    public class DependencyClass implements IDpendency{

    public void doMethod(){......}
    }
    //类Business
    public class Business{
    Idependency obj;
    public Business(){}
    public void doSth(){
    ...
    obj.doMethod();
    }
    public void setObj(Idependency d){
    this.obj = d;
    }
    }
    代码中可以看出:
    (1) Business的变量obj可以接受任何IDenpendency的实例
    (2) DependencyClass 的实例不是通过Business自己new出来,而是通过setter来由外部传给它。
    此时考虑Business依赖的实例如何从外部注入,就要通过xml定义,spring容器再依据xml来实例化。

    创建一个spring-context.xml
    <beans>
    <bean id="dependency" class="*****.DependencyClass"> 实体类名包
    <bean id ="business" class="****.Business">
    <proproty name="obj">
    <ref bean ="dependency"
    </property>
    </bean>
    </beans>
    这里的配置文件将DependencyClass类和Business类加入,并将DependencyClass作为Business的一个 参数。
    容器加载通过xml来实例化相关的bean.
    通过上面不难发现:
    (1) Business 是通过接口IDependency来接受DependencyClass实例,所以
    当我们又有新的IDenpendency的实现是,只需要修改xml文件即可,



    通过上例可以总结出:
    a. 依赖类是通过spring容器解析xml后来注入的,而不是使用它的类(Business)来自己制造,这就是依赖的注入。

    b. Bussiness 对类Dependency 的依赖转移到对接口IDependency的依赖,控制权由类转移到了接口,即由"实现"转移到"抽象"中。

    c. 通过将对实例的依赖,改为对接口的依赖。是面向接口编程的一个要义。也是程序解耦的一个措施。
    展开全文
  • Spring试题和答案.pdf

    2020-10-30 10:31:25
    对象被动的接受依赖类 )对象主动的去找依赖类 )一定要用接口 )下面关于AOP的理解,正确的是(B C)(选择两项) )面向纵向的开发 )面向横向的开发 )AOP关注是面 )AOP关注的是点
  • Spring知识点整理

    2021-05-12 18:50:21
    对象被动的接受依赖类 AOP的理解:面向横向的开发;关注的是面 Spring的组成一共有7块组成 1.Spring Core Core封装包是框架的最基础部分,提供IOC和依赖注入的特性。这里的基础l概念是BeanFactory,它提供对...
    1. Spring是一个轻量级的框架,是一个IOC和AOP容器
    2. IOC的理解:反转控制;对象被动的接受依赖类
    3. AOP的理解:面向横向的开发;关注的是面
    4. Spring的组成一共有7块组成
    	1.Spring Core
    	    Core封装包是框架的最基础部分,提供IOC和依赖注入的特性。这里的基础l概念是BeanFactory,它提供对Factory模式的经典实现来消除对程序性单例模式的需要,并真正地允许你从程序逻辑中分离出依赖关系和配置。
    	
    	2.Spring Context
    		
    		   构建于Core封装包基础上的Context封装包,提供了一种框架式的对象访问方法,有些像JNDI注册器。Context封装包的特性得自于Beans封装包,并添加了对国际化(I18N)的支持(例如资源绑定),事件传播,资源装载的方式和Context的透明创建,比如说通过Servlet容器。
    	
    	3.Spring DAO 
    		
    		   DAO(Data Access Object)提供了JDBC的抽象层,它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。并且,JDBC封装包还提供了一种比编程性更好的声明性事务管理方法,不仅仅是实现了特定接口,而且对所有的POJOs(plain old Java objects)都适合。
    		
    	4.Spring ORM
    		
    		   ORM封装包提供了常用的“对象/关系”映射APIs的集成层。其中包括JPA、JDO、Hibernate 和myiBatis。利用ORM封装包,可以混合使用所有Spring提供的特性进行“对象/关系”映射,如期边提到的简单声明性事务管理。
    		
    	5.Spring AOP
    		
    		    AOP模块是Spring的AOP库,提供了AOP(拦截器)机制,并提供常用的拦截器,提供用户自定义和配置。
    		
    	6.Spring Web
    		
    		    WEB模块提供对常见框架如Struts1,WEBWORK(Struts2),JSF的支持,Spring能够管理这些框架,将Spring的资源注入给框架,也能在这些框架的前后插入拦截器。
    		
    	7.Spring Web MVC
    		
    		   Spring中的MVC封装包提供了Web应用的Model-View-Controller(MVC)实现。Spring的MVC框架并不是仅仅提供一种传统的实现,它提供了一种清晰的分离模型,在领域模式代码和Web Form 之间。并且,还可以借助Spring框架的其他特性。
    
    1. Spring各模块之间的关系:
      各模块可以单独存在;
      Spring的核心模块是必须的,其它模块是基于核心模块的
    2. Spring的核心模块的作用:做IOC,用来管理Bean容器的
    3. 对Hibernate的支持主要用到Spring的Spring ORM模块
    4. 对Struts的支持主要用到Spring的Spring Web模块
    5. Spring的通知类型有:Before通知、After return 通知、Throws通知和Around通知。
    6. 关于切入点的说法:
      是AOP中一系列连接点的集合;
      在做AOP定义时候切入点不是必须的;
      可以用正则表达式来定义切入点
    7. Spring的依赖注入的方式:set方法注入和构造方法的注入
    8. Spring中配置bean的id属性和name属性:
      都不是必须的,可以没有;
      它们的值不允许重复
    9. Spring中配置bean的init-method方法:
      在依赖注入之后执行
    10. Spring配置文件可以有多个,也可以不叫application.xml
    11. BeanFactory接口是工厂模式的实现,负责管理和创建Bean
    12. ApplicationContext是一个接口,提供一些BeanFactory的扩展类
    13. Bean在Spring容器中有两种管理模式:单一模式和原型模式
    14. 设置注入的优点:对于复杂依赖关系,更简洁直观
    15. 构造注入的优点:
      构造期即创建一个完整、合法的对象
      不需要写繁琐的setter方法
      在构造函数中决定依赖关系的注入顺序
    16. AOP的优点:
      是面向对象的代替品;
      将项目中的公共问题集中解决,减少代码量,提高系统的可维护性
    17. setter注入和构造注入的注入时机不同;
      setter注入方式依赖对象先注入;
    展开全文
  • 所谓DI,就是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给它。我个人理解就是,你在实例化一个类时,它会自动去...

         林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

           本教程使用AngularJs版本:1.5.3

           AngularJs GitHub: https://github.com/angular/angular.js/

           AngularJs下载地址:https://angularjs.org/

             用有过Spring的人都知道,Spring的核心思想就是DI(依赖注入,Dependency Injection)和IOC(控制反转 Invension of Controller),AngularJS的service其实就是用到了这里的DI思想,那么什么叫做DI?所谓DI,就是指对象是被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖的类,而是在容器实例化对象的时候主动将它依赖的类注入给它。我个人的理解就是,你在实例化一个类时,它会自动去实例化它里面所用到的其它实例。所以这就叫依赖注入。在Angular里面,services作为单例对象在需要到的时候被创建,只有在应用生命周期结束的时候(关闭浏览器)才会被清除。而controllers在不需要的时候就会被销毁了。

           AngualrJs中可用来注入的有三种类型,service、factory、provider,这三种写法不样,用法也都不一样。其中,service只实例化一次,其实就是单例模式的思想。无论我们在什么地方注入我们的service,将永远使用同一个实例。所以对很多在controller层中的操作就可以放到serivce层中去。AngularJS提供例如许多内在的服务,如:$http, $route, $window, $location等。每个服务负责例如一个特定的任务,$http是用来创建AJAX调用,以获得服务器的数据。 $route用来定义路由信息等。内置的服务总是前缀$符号。

          其中,三者的关系可以看成是下图:


    一、Service使用详解

    (1)定义

    一个学用的service用法如下:

    一般直接用this来操作数据、定义函数。

    app.service('myService', function() {
        var privateValue = "I am Private";
        this.variable = "This is public";
        this.getPrivate = function() { return privateValue;
    };
    });

    (2)AngularJS中使用DI添加Service的三种方法 
    方式1(内联注解,推荐使用):

    app.controller('myController', ['$scope', 'dateFilter', function ($scope, dateFilter) { }]);
    方式2($inject注解):
     var MyController = function($scope, dateFilter) {}
    MyController.$inject = ['$scope', 'dateFilter'];
    someModule.controller('MyController', MyController);
    方式3(隐式注解,不推荐使用):
    app.controller('myController', function ($scope, dateFilter) { });
    推荐使用方式1的理由是:
    写法上比方法2更简单明了
    比方法3更可靠(由于Javascript可以被压缩,AngularJS又是通过解析服务名称找到对应Service的,因此Javascript压缩之后AngularJS将无法找到指定的Service,但字符串不会被压缩,因此单独以字符串指定Service的名称可以避免这个问题)
    使用方式1或方式2的注意点:
    由于上述第二点原因,AngularJS在编译Html时,由$injector将数组中Service的名称与方法体中的Service进行一一映射。这种映射关系必须遵守由AngularJS的约定:
    数组中Service名称的个数必须与方法体中Service名称的个数一致
    数组中Service的顺序必须与方法体中Serivce的顺序一致

    (3)什么时候适合使用service()方法
    service()方法很适合使用在功能控制比较多的service里面
    注意:需要使用.config()来配置service的时候不能使用service()方法

    (4)service使用实例 

    一个完整实例:

    <!DOCTYPE html>
    <html lang="zh" ng-app="myApp">
    <head>
        <meta charset="UTF-8">
        <title>AngularJS学习</title>
        <script type="text/javascript" src="./1.5.3/angular.min.js"></script>
    </head>
    <body>
        <div ng-controller="myCtrl">
            <button ng-click="getPrivate()">按钮一</button>
            <button ng-click="getPUbluc()">按钮二</button>
        </div>
        <div ng-controller = "myCtrl2">
        </div>
    </body>
    <script type="text/javascript">
    var app = angular.module('myApp', []);
    app.controller('myCtrl', function($scope, myService) {
        $scope.getPrivate = function() {
            alert(myService.getPrivate());
        };
        $scope.getPUbluc = function() {
            alert(myService.variable);
        };
    });
    app.controller('myCtrl2', function($scope, myService) {
    
    });
    app.service('myService', function() {
         console.log('instance myService');
        var privateValue = "I am Private";
        this.variable = "This is public";
        this.getPrivate = function() {
            return privateValue;
        };
    });
    </script>
    </html>
    
    效果如下:

    另外,从这里可以看到两个controller注入同一个service,但是最终只实例化了一次!


    注意:seivce定义的服务不能在.config中使用!只有provider定义的才可以

    二、Factory使用详解

    Factory 一般就是创建一个对象,然后在对这个对象添加方法与数据,最后将些对象返回即可。然后注入到Controller层中即可。

    使用实例:
    <!DOCTYPE html>
    <html lang="zh" ng-app="myApp">
    <head>
        <meta charset="UTF-8">
        <title>AngularJS学习</title>
        <script type="text/javascript" src="./1.5.3/angular.min.js"></script>
    </head>
    <body>
        <div ng-controller="myCtrl">
            <button ng-click="getPrivate()">按钮一</button>
            <button ng-click="getPUbluc()">按钮二</button>
        </div>
        <div ng-controller = "myCtrl2">
        </div>
    </body>
    <script type="text/javascript">
    var app = angular.module('myApp', []);
    app.controller('myCtrl', function($scope, myFactory) {
        $scope.getPrivate = function() {
            alert(myFactory.getPrivate());
        };
        $scope.getPUbluc = function() {
            alert(myFactory.variable);
        };
    });
    app.controller('myCtrl2', function($scope, myFactory) {
    
    });
    app.factory('myFactory', function() {
        console.log('instance myFactory');
        var factory = {};
        var privateValue = "I am Private";
        factory.variable = "This is public";
        factory.getPrivate = function() {
            return privateValue;
        };
        return factory;
    });
    </script>
    </html>
    
    效果:

    从下面可以看到只实例化了一次,两下Controller注入同一个factory,但是最终只实例化了一次!

    记得一定要return一个Object对象,否则会报如下错误:


    AngularJS中的Services:

    三、provider使用详解

        $provide服务负责告诉Angular如何创造一个新的可注入的东西:即服务。服务会被叫做供应商的东西来定义,你可以使用$provide来创建一个供应商。你需要使用$provide中的provider()方法来定义一个供应商,同时你也可以通过要求$provide被注入到一个应用的config函数中来获得$provide服务。使用方法是返回一个$get函数,注意在config阶段,只有provider能被注入。其它用法和service一样。
    下面是一个实例。
    <!DOCTYPE html>
    <html lang="zh" ng-app="myApp">
    <head>
        <meta charset="UTF-8">
        <title>AngularJS学习</title>
        <script type="text/javascript" src="./1.5.3/angular.min.js"></script>
    </head>
    <body>
        <div ng-controller="myCtrl1">
            <button ng-click = "onclick1()">请点击我1</button>
        </div>
        <div ng-controller="myCtrl2">
             <button ng-click = "onclick2()">请点击我2</button>
        </div>
    </body>
    <script type="text/javascript">
    var app = angular.module('myApp', []);
    app.controller('myCtrl1', function($scope, testProvider) {
        $scope.onclick1 = function() {
            testProvider("林炳文Evankaka");
        };
    });
    app.controller('myCtrl2', function($scope , testProvider) {
          $scope.onclick2 = function() {
            testProvider("我到底是谁");
        };
    });
    
    app.provider('testProvider', function(){
        console.log('instance testProvider');
        var f = function(name) {
           alert("Hello, " + name);
        };
        this.$get = function(){ //一定要有!
          return f;
       };
    });
    </script>
    </html>
    
    效果:

    从以下可以看到只实例化了一次:
    再来做一个provider实例化的时间测试:
    <!DOCTYPE html>
    <html lang="zh" ng-app="myApp">
    
    <head>
        <meta charset="UTF-8">
        <title>AngularJS学习</title>
        <script type="text/javascript" src="./1.5.3/angular.min.js"></script>
    </head>
    
    <body>
        <div ng-controller="myCtrl1">
            <button ng-click="onclick1()">请点击我1</button>
        </div>
        <div ng-controller="myCtrl2">
            <button ng-click="onclick2()">请点击我2</button>
        </div>
    </body>
    <script type="text/javascript">
    var app = angular.module('myApp', []);
    app.controller('myCtrl1', function($scope) {
    /*    $scope.onclick1 = function() {
            test("林炳文Evankaka");
        };*/
    });
    app.controller('myCtrl2', function($scope) {
    /*    $scope.onclick2 = function() {
            test("我到底是谁");
        };*/
    });
    app.provider('test', function() {
        console.log('instance test');
        var f = function(name) {
            alert("Hello, " + name);
        };
        this.$get = function() { //一定要有!
            return f;
        };
    });
    /*app.config(function(testProvider) {
        testProvider('I am config');
    });*/
    
    app.config(function($provide) {
        $provide.provider('greeting', function() {
            this.$get = function() {
                return function(name) {
                    alert("Hello," + name);
                };
            };
        });
      /*  greetingProvider('ff');*/
    });
    </script>
    
    </html>
    
    页面刷新后,我们发现即使不注入这个providrer,但也它也进行实例化了,而service/factory则是第一次注入时才会初始化。而也这是为什么它可以注入到config的一个原因吧!
    什么时候使用provider()方法

    (1)当我们希望在应用开始前对service进行配置的时候就需要使用到provider()。比如,我们需要配置services在不同的部署环境里面(开发,演示,生产)使用不同的后端处(2)理的时候就可以使用到了
    当我们打算发布开源provider()也是首选创建service的方法,这样就可以使用配置的方式来配置services而不是将配置数据硬编码写到代码里面。


    四、Service、Factory、Provider三者区别


    1) 用 Factory 就是创建一个对象,为它添加属性,然后把这个对象返回出来。你把 service 传进 controller 之后,在 controller 里这个对象里的属性就可以通过 factory 使用了。
    2) Service 是用"new"关键字实例化的。因此,你应该给"this"添加属性,然后 service 返回"this"。你把 service 传进 controller 之后,在controller里 "this" 上的属性就可以通过 service 来使用了。
    3) Providers 是唯一一种你可以传进 .config() 函数的 service。当你想要在 service 对象启用之前,先进行模块范围的配置,那就应该用 provider。
    4)Factory/service是第一个注入时才实例化,而provider不是,它是在config之前就已实例 化好
    同一函数三种不同写法:
    <!DOCTYPE html>
    <html lang="zh" ng-app="myApp">
    <head>
        <meta charset="UTF-8">
        <title>AngularJS学习</title>
        <script type="text/javascript" src="./1.5.3/angular.min.js"></script>
    </head>
    <body>
        <div ng-controller="myCtrl">
            <p>{{ output1 }}</p>
            <p>{{ output2 }}</p>
            <p>{{ output3 }}</p>
        </div>
        <div ng-controller="myCtrl2">
        </div>
    </body>
    <script type="text/javascript">
    var app = angular.module('myApp', []);
    app.controller('myCtrl', function($scope,testService, testFactory, testProvider) {
        $scope.output1 = testService.lable;
        $scope.output2 = testFactory.lable();
        $scope.output3 = testProvider;
    });
    app.controller('myCtrl2', function($scope,testService, testFactory, testProvider) {
    });
    app.service('testService',function(){
          console.log('instance testService');
         this.lable = 'this is service';
    });
    app.factory('testFactory', function () {
          console.log('instance testFactory');
         return{
            lable: function(){
            return 'this is factory';
            }
        };
    });
    app.provider('testProvider', function(){
        console.log('instance testProvider');
        this.$get = function(){
            return 'this is provider';
        };
    });
    </script>
    </html>
    


    看console的输出,可以知道都只实例 化了一次:


    参考文章:
    http://www.cnblogs.com/wushangjue/p/4533953.html?utm_source=tuicool&utm_medium=referral
    http://www.oschina.net/translate/angularjs-factory-vs-service-vs-provider
    http://my.oschina.net/tanweijie/blog/295067
    http://www.360doc.com/content/15/1010/18/28162318_504719466.shtml

    展开全文
  • DI(Dependency Injection)依赖注入是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给它。 寻找入口 Bean实例创建和...
  • DI(DependencyInjection)依赖注入:就是指对象被动接受依赖类而不是自己主动去找,换句话说就。是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给它。 1.set方法注入 public...
  • DI(DependencyInjection)依赖注入:就是指对象被动接受依赖类而不是自己主动去找,换句话说就。是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给它。 1.set方法注入 public...
  • 一 概念 IOC(Inversion of ... DI(Dependency Injection)依赖注入:就是指对象被动接受依赖类而不是自己主动去找,换句话说 就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依...
  • 前言 1、依赖注入逼格 用有过JAVA spring人都知道,Spring核心思想就是DI(依赖注入,Dependency ...所谓DI,就是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖...
  • 用有过Spring人都知道,Spring核心思想就是DI(依赖注入,Dependency ...所谓DI,就是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将
  • 依赖注入(DI),也就是dependency injection,通过spring容器“宏观调控”,调用者只要被动接受spring容器为调用者成员变量赋值即可,而不需要主动获取被依赖对象。这种被动获取方式就叫做依赖注入 一.构造...
  • DI(Dependency Injection):依赖注入,就是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给他。 完成Be...
  • SpringIoC和DI

    2021-01-24 20:28:21
    反转:过去是对象主动去获取依赖对象,现在通过IoC,变成了对象被动的接受依赖对象,所以称之为反转。 ioc是一种思想,它能指导我们设计出低耦合的程序,传统应用程序都是由我们在内部主动创建依赖对象,从而导致...
  • Spring IOC源码流程

    2019-04-24 10:09:56
    IOC(Inversion of Control)...就是指对象被动接受依赖类而不是自己主动去找,换句话说就是指对象不是从容器中查找它依赖类,而是在容器实例化对象的时候主动将它依赖类注入给它。 Spring IOC容器初始化三部...
  • Spring框架的核心就是控制反转(Inversion of Control)和...使用IoC,对象被动的接受依赖类,而不是自己主动的去找。 容器在实例化的时候主动将它的依赖类注入给它。 可以这样理解:控制反转将类的主动权转移到接口
  • 使用IoC,对象被动的接受依赖类,而不是自己主动的去找。容器在实例化的时候主动将它的依赖类注入给它。 可以这样理解:控制反转将类的主动权转移到接口上,依赖注入通过xml配置文件在类实例化时将其依赖类注入。...
  • IOC/DI IOC(Inversion of Control)控制反转:所谓控制反转,就是把原先我们代码里面需要实现的对象创建、依赖代码,反转给...DI( Dependency Injection )依赖注入:就是指对象被动接受依赖类而不是自己主动去找...
  •  使用IoC,对象被动的接受依赖类,而不是自己主动的去找。容器在实例化的时候主动将它的依赖类注入给它。可以这样理解:控制反转将类的主动权转移到接口上,依赖注入通过xml配置文件在类实例化时将其依赖类注入。...
  • IOC与DI IOC(Inversion of Control)控制反转:把原先我们代码里面需要实现对象创建、依赖代码,反转给容器来帮忙...DI(Dependency Injection)依赖注入:对象被动接受依赖类,而不是主动去找,换句话说...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
热门标签
关键字:

对象被动的接受依赖类