精华内容
下载资源
问答
  • Guice 依赖注入

    千次阅读 2016-11-22 10:22:53
    有一些方案依赖于模式,另一些则使用框架。所有这些方案都会不同程度 地引入一些难于测试或者程式化代码重复的问题。你马上就会看到,Guice 在这方面是全 世界做得最好的:非常容易进行单元测试,最大程度的灵活性...

    简介
    Java企业应用开发社区在连接对象方面花了很大功夫。你的Web应用如何访问中间层服 务?你的服务如何连接到登录用户和事务管理器?关于这个问题你会发现很多通用的和特 定的解决方案。有一些方案依赖于模式,另一些则使用框架。所有这些方案都会不同程度 地引入一些难于测试或者程式化代码重复的问题。你马上就会看到,Guice 在这方面是全 世界做得最好的:非常容易进行单元测试,最大程度的灵活性和可维护性,以及最少的代 码重复。
    我们使用一个假想的、简单的例子来展示 Guice 优于其他一些你可能已经熟悉的经典 方法的地方。下面的例子过于简单,尽管它展示了许多显而易见的优点,但其实它还远没 有发挥出 Guice 的全部潜能。我们希望,随着你的应用开发的深入,Guice 的优越性也 会更多地展现出来。
    在这个例子中,一个客户对象依赖于一个服务接口。该服务接口可以提供任何服务, 我们把它称为Service。
    public interface Service {

      void go();
    }
    对于这个服务接口,我们有一个缺省的实现,但客户对象不应该直接依赖于这个缺省 实现。如果我们将来打算使用一个不同的服务实现,我们不希望回过头来修改所有的客户 代码。
    public class ServiceImpl implements Service {

      public void go() {

       …

      }

    }
    我们还有一个可用于单元测试的伪服务对象。
    public class MockService implements Service {

      private boolean gone = false;
      public void go() {
       gone = true;
      }
      public boolean isGone() {
       return gone;
      }
    }
    简单工厂模式
    在发现依赖注入之前,最常用的是工厂模式。除了服务接口之外,你还有一个既可以 向客户提供服务对象,也可以向测试程序传递伪服务对象的工厂类。在这里我们会将服务 实现为一个单件对象,以便让示例尽量简化。
    public class ServiceFactory {
      private ServiceFactory() {}

      private static Service instance = new ServiceImpl();
      public static Service getInstance() {
       return instance;
      }

      public static void setInstance(Service service) {
       instance = service;
      }
    }
    客户程序每次需要服务对象时就直接从工厂获取。
    public class Client {
      public void go() {
       Service service = ServiceFactory.getInstance();
       service.go();
      }
    }
    客户程序足够简单。但客户程序的单元测试代码必须将一个伪服务对象传入工厂,同 时要记得在测试后清理。在我们这个简单的例子里,这不算什么难事儿。但当你增加了越 来越多的客户和服务代码后,所有这些伪代码和清理代码会让单元测试的开发一团糟。此 外,如果你忘记在测试后清理,其他测试可能会得到与预期不符的结果。更糟的是,测试 的成功与失败可能取决于他们被执行的顺序。
    public void testClient() {
      Service previous = ServiceFactory.getInstance();
      try {
       final MockService mock = new MockService();
       ServiceFactory.setInstance(mock);
       Client client = new Client();
       client.go();
       assertTrue(mock.isGone());
      }
      finally {
       ServiceFactory.setInstance(previous);
      }
    }
    最后,注意服务工厂的API把我们限制在了单件这一种应用模式上。即便 getInstance() 可以返回多个实例, setInstance() 也会束缚我们的手脚。转换到非单 件模式也意味着转换到了一套更复杂的API。
    手工依赖注入
    依赖注入模式的目标之一是使单元测试更简单。我们不需要特殊的框架就可以实践依 赖注入模式。依靠手工编写代码,你可以得到该模式大约80%的好处。
    当上例中的客户代码向工厂对象请求一个服务时,根据依赖注入模式,客户代码希望 它所依赖的对象实例可以被传入自己。也就是说:不要调用我,我会调用你。
    public class Client {

      private final Service service;
      public Client(Service service) {
       this.service = service;
      }
      public void go() {
       service.go();
      }
    }
    这让我们的单元测试简化了不少。我们可以只传入一个伪服务对象,在结束后也不需 要多做什么。
    public void testClient() {
      MockService mock = new MockService();
      Client client = new Client(mock);
      client.go();
      assertTrue(mock.isGone());
    }
    我们也可以精确地区分出客户代码依赖的API。
    现在,我们如何连接客户和服务对象呢?手工实现依赖注入的时候,我们可以将所有 依赖逻辑都移动到工厂类中。也就是说,我们还需要有一个工厂类来创建客户对象。
    public static class ClientFactory {
      private ClientFactory() {}
      public static Client getInstance() {
       Service service = ServiceFactory.getInstance();
       return new Client(service);
      }
    }
    手工实现依赖注入需要的代码行数和简单工厂模式差不多。
    用 Guice 实现依赖注入
    手工为每一个服务与客户实现工厂类和依赖注入逻辑是一件很麻烦的事情。其他一些 依赖注入框架甚至需要你显式将服务映射到每一个需要注入的地方。
    Guice 希望在不牺牲可维护性的情况下去除所有这些程式化的代码。
    使用 Guice,你只需要实现模块类。Guice 将一个绑定器传入你的模块,你的模块使 用绑定器来连接接口和实现。以下模块代码告诉 Guice 将 Service映射到单件模式的 ServiceImpl:
    public class MyModule implements Module {
      public void configure(Binder binder) {
       binder.bind(Service.class)
        .to(ServiceImpl.class)
        .in(Scopes.SINGLETON);
      }
    }
    模块类告诉 Guice 我们想注入什么东西。那么,我们该如何告诉 Guice 我们想把它 注入到哪里呢?使用 Guice,你可以使用 @Inject 标注你的构造器,方法或字段:
    public class Client {
      private final Service service;
      @Inject
      public Client(Service service) {
       this.service = service;
      }
      public void go() {
       service.go();
      }
    }
    @Inject 标注可以清楚地告诉其他程序员你的类中哪些成员是被注入的。
    为了让 Guice向 Client 中注入,我们必须直接让 Guice 帮我们创建Client 的实例 ,或者,其他类必须包含被注入的Client 实例。
    Guice vs. 手工依赖注入
    如你所见,Guice 省去了写工厂类的麻烦。你不需要编写代码将客户连接到它们所依 赖的对象。如果你忘了提供一个依赖关系,Guice 在启动时就会失败。Guice 也会自动处 理循环依赖关系。
    Guice 允许你通过声明指定对象的作用域。例如,你需要编写相同的代码将对象反复 存入 HttpSession。
    实际情况通常是,只有到了运行时,你才能知道具体要使用哪一个实现类。因此你需 要元工厂类或服务定位器来增强你的工厂模式。Guice 用最少的代价解决了这些问题。
    手工实现依赖注入时,你很容易退回到使用直接依赖的旧习惯,特别是当你对依赖注 入的概念还不那么熟悉的时候。使用 Guice 可以避免这种问题,可以让你更容易地把事 情做对。Guice 使你保持正确的方向。
    更多的标注
    只要有可能,Guice 就允许你使用标注来替代显式地绑定对象,以减少更多的程式化 代码。回到我们的例子,如果你需要一个接口来简化单元测试,而你又不介意编译时的依 赖,你可以直接从你的接口指向一个缺省的实现。
    @ImplementedBy(ServiceImpl.class)
    public interface Service {
      void go();
    }
    这时,如果客户需要一个 Service 对象,且 Guice 无法找到显式绑定,Guice 就会 注入一个 ServiceImpl 的实例。
    缺省情况下,Guice 每次都注入一个新的实例。如果你想指定不同的作用域规则,你 也可以对实现类进行标注。
    @Singleton
    public class ServiceImpl implements Service {
      public void go() {
       …
      }
    }
    架构概览
    我们可以将 Guice 的架构分成两个不同的阶段:启动和运行。你在启动时创建一个注 入器 Injector,在运行时用它来注入对象。
    启动
    你通过实现 Module 来配置 Guice。你传给 Guice 一个模块对象,Guice 则将一个绑 定器 Binder 对象传入你的模块,然后,你的模块使用绑定器来配置绑定。一个绑定通常 包含一个从接口到具体实现的映射。例如:
    public class MyModule implements Module {
      public void configure(Binder binder) {
       // Bind Foo to FooImpl. Guice will create a new
       // instance of FooImpl for every injection.
       binder.bind(Foo.class).to(FooImpl.class);
       // Bind Bar to an instance of Bar.
       Bar bar = new Bar();
       binder.bind(Bar.class).toInstance(bar);
      }
    }
    在这个阶段,Guice 会察看你告诉它的所有类,以及任何与这些类有关系的类,然后 通知你是否有依赖关系的缺失。例如,在一个Struts 2 应用中,Guice 知道你所有的动 作类。Guice 会检查你的动作类以及它们依赖的所有类,如果有问题会及早报错。
    创建一个 Injector 涉及以下步骤:
    首先创建你的模块类实例,并将其传入 Guice.createInjector().
    Guice 创建一个绑定器 Binder 并将其传入你的模块。
    你的模块使用绑定器来定义绑定。
    基于你所定义的绑定,Guice 创建一个注入器 Injector 并将其返回给你。
    你使用注入器来注入对象。
    运行
    现在你可以使用第一阶段创建的注入器来注入对象并内省(introspect)我们的绑定 了。Guice 的运行时模型由一个可管理一定数量绑定的注入器组成。
    键 Key 唯一地确定每一个绑定。Key 包含了客户代码所依赖的类型以及一个可选的标 注。你可以使用标注来区分指向同一类型的多个绑定。Key 的类型和标注对应于注入时的 类型和标注。
    每个绑定有一个提供者 provider,它提供所需类型的实例。你可以提供一个类, Guice 会帮你创建它的实例。你也可以给 Guice 一个你要绑定的类的实例。你还可以实 现你自己的 provider,Guice 可以向其中注入依赖关系。
    每个绑定还有一个可选的作用域。缺省情况下绑定没有作用域,Guice 为每一次注入 创建一个新的对象。一个定制的作用域可以使你控制 Guice 是否创建新对象。例如,你 可以为每一个 HttpSession 创建一个实例。
    自举(Bootstrapping)你的应用
    自举(bootstrapping)对于依赖注入非常重要。总是显式地向 Injector 索要依赖, 这就将 Guice 用作了服务定位器,而不是一个依赖注入框架。
    你的代码应该尽量少地和 Injector 直接打交道。相反,你应该通过注入一个根对象 来自举你的应用。容器可以更进一步地将依赖注入根对象所依赖的对象,并如此迭代下去 。最终,在理想情况下,你的应用中应该只有一个类知道Injector,每个其他类都应该使 用注入的依赖关系。
    例如,一个诸如 Struts 2 的Web 应用框架通过注入你的所有动作类来自举你的应用 。你可以通过注入你的服务实现类来自举一个 Web 服务框架。
    依赖注入是传染性的。如果你重构一个有大量静态方法的已有代码,你可能会觉得你 正在试图拉扯一根没有尽头的线。这是好事情。它表明依赖注入正在帮助你改进代码的灵 活性和可测试性。
    如果重构工作太复杂,你不想一次性地整理完所有代码,你可以暂时将一个 Injector 的引用存入某个类的一个静态的字段,或是使用静态注入。这时,请清楚地命名包含该字 段的类:比如 InjectorHack和 GodKillsAKittenEveryTimeYouUseMe。记住你将来可能不 得不为这些类提供伪测试类,你的单元测试则不得不手工安装一个注入器。记住,你将来 需要清理这些代码。
    绑定依赖关系
    Guice 是如何知道要注入什么东西的呢?对启动器来说,一个包含了类型和可选的标 注的 Key 唯一地指明了一个依赖关系。Guice 将 key和实现之间的映射标记为一个 Binding。一个实现可以包含一个单独的对象,一个需要由 Guice 注入的类,或一个定制 的 provider。
    当注入依赖关系时,Guice 首先寻找显式绑定,即你通过绑定器 Binder指明的绑定。 Binder API 使用生成器(Builder)模式来创建一种领域相关的描述语言。根据约束适用 方法的上下文的不同,不同方法返回不同的对象。
    例如,为了将接口 Service 绑定到一个具体的实现 ServiceImpl,调用:
    binder.bind(Service.class).to(ServiceImpl.class);
    该绑定与下面的方法匹配:
    @Inject
    void injectService(Service service) {
      …
    }
    注: 与某些其他的框架相反,Guice 并没有给 “setter” 方法任何特殊待遇。不管方 法有几个参数,只要该方法含有 @Inject标注,Guice就会实施注入,甚至对基类中实现 的方法也不例外。
    不要重复自己
    对每个绑定不断地重复调用”binder” 似乎有些乏味。Guice 提供了一个支持 Module 的类,名为 AbstractModule,它隐含地赋予你访问 Binder 的方法的权力。例如,我们 可以用扩展 AbstractModule 类的方式改写上述绑定:
    bind(Service.class).to(ServiceImpl.class);
    在本手册的余下部分中我们会一直使用这样的语法。
    标注绑定
    如果你需要指向同一类型的多个绑定,你可以用标注来区分这些绑定。例如,将接口 Service 和标注 @Blue 绑定到具体的实现类 BlueService 的代码如下:
    bind(Service.class)
    .annotatedWith(Blue.class)
    .to(BlueService.class);
    这个绑定会匹配以下方法:
    @Inject
    void injectService(@Blue Service service) {
      …
    }
    注意,标注 @Inject 出现在方法前,而绑定标注(如 @Blue)则出现在参数前。对构 造函数也是如此。使用字段注入时,两种标注都直接应用于字段,如以下代码:
    @Inject @Blue Service service;
    创建绑定标注
    刚才提到的标注 @Blue 是从哪里来的?你可以很容易地创建这种标注,但不幸的是, 你必须使用略显复杂的标准语法:
    /**
    * Indicates we want the blue version of a binding.
    */
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.FIELD, ElementType.PARAMETER})
    @BindingAnnotation
    public @interface Blue {}
    幸运的是,我们不需要理解这些代码,只要会用就可以了。对于好奇心强的朋友,下 面是这些程式化代码的含义:
    @Retention(RUNTIME) 使得你的标注在运行时可见。
    @Target({FIELD, PARAMETER}) 是对用户使用的说明;它不允许 @Blue 被用于方法、 类型、局部变量和其他标注。
    @BindingAnnotation 是 Guice 特定的信号,表示你希望该标注被用于绑定标注。当 用户将多于一个的绑定标注应用于同一个可注入元素时,Guice 会报错。
    有属性的标注
    如果你已经会写有属性的标注了,请跳到下一节。
    你也可以绑定到标注实例,即,你可以有多个绑定指向同样的类型和标注类型,但每 个绑定拥有不同的标注属性值。如果 Guice 找不到拥有特定属性值的标注实例,它会去 找一个绑定到该标注类型的绑定。
    例如,我们有一个绑定标注 @Named,它有一个字符串属性值。
    @Retention(RUNTIME)

    @Target({ FIELD, PARAMETER })

    @BindingAnnotation

    public @interface Named {
     
    String value();

    }
    如果我们希望绑定到 @Named(“Bob”),我们首先需要一个 Named 的实现。我们的实现 必须遵守关于 Annotation 的约定,特别是 hashCode() 和 equals() 的实现。
    class NamedAnnotation implements Named {
     
    final String value;
     
    public NamedAnnotation(String value) {
      
    this.value = value;
     
    }
     
    public String value() {
      
    return this.value;
     
    }
     
    public int hashCode() {
      
    // This is specified in java.lang.Annotation.
      
    return 127 * “value”.hashCode() ^ value.hashCode();
     
    }
     
    public boolean equals(Object o) {
      
    if (!(o instanceof Named))
       
    return false;
      
    Named ther = (Named) o;
      
    return value.equals(other.value());
     
    }
     
    public String toString() {
      
    return “@” + Named.class.getName() + “(value=” + value + “)”;
     
    }
     
    public Class

    展开全文
  • 之前项目中碰到一个问题,使用Maven打包某项目只能在本机打成功,在别人的机子上或用服务器的jenkins都报某个依赖下来的问题,去Maven的私服上查找却又能找到,并且可以下载,但是通过maven命令(jenkins里打包...

    问题

    之前项目中碰到一个问题,使用Maven打包某项目只能在本机打成功,在别人的机子上或用服务器的jenkins都报某个依赖下不下来的问题,去Maven的私服上查找却又能找到,并且可以下载,但是通过maven命令(jenkins里打包其实也是通过maven命令实现的)来打包却又找不到这个依赖

    原因

    后来发现是这个依赖包deploy到私服的问题。
    由于项目中只用到了该依赖包,并未用到它的父包,所以当时在deploy时只把作为子包的该依赖包上传到私服上,并未把该包的父包同时上传,导致本机打包时maven可通过本机代码或本地仓库找到该依赖包及其父包,在别的机子上打包时由于只能从私服里找到该依赖包,不能找到其父包,会报找不到该依赖包的问题(为什么报的是找不到私服中存在的该依赖包,而不是找不到没上传的父包,这点很奇怪,望知道的大佬给解解惑orz)

    解决方法

    将该依赖包的父包也deploy到私服上

    展开全文
  • Spring支持依赖注入static静态变量

    千次阅读 2015-04-28 10:52:35
    在springframework里,我们能@Autowired一个静态变量,使之成为一个spring bean,例如下面这样: ... 可以试一下,yourClass在这种状态下能够被依赖注入,会抛出运行时异常java.lang.NullPointerException,为什么呢

    在springframework里,我们不能@Autowired一个静态变量,使之成为一个spring bean,例如下面这样:

    @Autowired
    private static YourClass yourClass;

             可以试一下,yourClass在这种状态下不能够被依赖注入,会抛出运行时异常java.lang.NullPointerException,为什么呢?静态变量/类变量不是对象的属性,而是一个类的属性,spring则是基于对象层面上的依赖注入.

    而使用静态变量/类变量扩大了静态方法的使用范围.静态方法在spring是不推荐使用的.依赖注入的主要目的,是让容器去产生一个对象的实例,然后在整个生命周期中使用他们,同时也让testing工作更加容易.

             一旦你使用静态方法,就不再需要去产生这个类的实例,这会让testing变得更加困难,同时你也不能为一个给定的类,依靠注入方式去产生多个具有不同的依赖环境的实例.这种static field是隐含共享的,并且是一种global全局状态,spring同样不推荐这样去做.

    展开全文
  • 不依赖链接的新搜索方法

    千次阅读 2010-11-05 08:26:00
    转自http://www.solidot.org《MIT技术评论》报导(中文版),Google著名的PageRank算法是基于页面的超链接,普林斯顿大学研究人员开发出一种不依靠超链接,去评估和衡量页面与文件重要性的方法。 普林斯顿大学开发的...

    转自http://www.solidot.org

    《MIT技术评论》报导中文版),Google著名的PageRank算法是基于页面的超链接,普林斯顿大学研究人员开发出一种不依靠超链接,去评估和衡量页面与文件重要性的方法。 普林斯顿大学开发的软件,能根据文件的存档,衡量文件中的用词随时间的微妙变化。软件通过分析文件中的文本,识别出特定类别中最重要的词与短语——这些词语会出现在不同文档中。然后分辨出最早出现的用词,确定影响其它文件的原始文档。研究人员在三个包含上千篇期刊文章的大型文献集上测试了新算法。他们发现,被软件识别为具有影响力的文章,也是被大量引用的文章。领导这项研究的David Blei认为,这种方法是根据原创思想识别影响力。它可能会促进更好的实时搜索引擎和推荐系统。

    展开全文
  • 依赖倒转原则

    千次阅读 2013-06-26 15:58:56
    抽象应该依赖细节,细节应该依赖于抽象。说白了,就是针对接口编程,不要针对实现编程。 依赖倒置原则包含三层含义: 1)高层模块应该依赖低层模块,两者都应该依赖其抽象; 2)抽象应该依赖细节; 3)...
  • 循环依赖 循环依赖(区别于dependsOn)的现象很简单,A对象在创建的时候依赖于B对象,B对象在创建的时候依赖于A对象
  • MAVEN-依赖传递性

    千次阅读 2019-02-28 07:26:01
    在项目往往需要引入多个依赖引入的依赖又会引入其他的依赖。 例如: 项目中引入了spring-core依赖spring-core又依赖commons-logging。因为项目直接引入了spring-core依赖,则spring-core为项目的第一直接...
  • 迟早你需要用到其他开发人员的抽象成果——即你依靠别人的代码。我喜欢依赖自由(无依赖)的模块,但那是难以实现的。甚至你创建的那些漂亮的黑盒子组件也或多或少会依赖一些东西。这正是依赖注入大显身手的之处。...
  • 玩转 SpringBoot 2.x 之自定义Starter依赖

    千次阅读 2019-02-24 21:16:27
    SpringBoot starter起步依赖介绍 SpringBoot 核心功能就是 start依赖,他默认提供了 spring-boot-starter-web...这个起步依赖依靠自动配置功能来实现的。他的原理就是将一些Bean进行自动配置 需要我们去人工的干预...
  • 依赖包的作用

    千次阅读 2020-10-02 17:47:01
    比如安装python、mysql等软件的时候,我们需要...大部分依赖包都是一些库文件,有动态库也有静态库,一个程序的依赖包如果没有安装,只安装了这个程序本身是能使用 你可以理解为似windows的库文件,譬如DLL 比如我要
  • Spring依赖注入的三种方式

    千次阅读 2015-03-11 11:08:25
    Spring依赖注入(DI)的三种方式,分别为:1. 接口注入 2. Setter方法注入 3. 构造方法注入下面介绍一下这三种依赖注入在Spring中是怎么样实现的。首先我们需要以下几个类:接口 Logic.java接口实现类 ...
  • 设计模式 : 依赖倒转原则

    千次阅读 2018-03-31 17:52:42
     依赖倒转原则的核心在于,在编程中,应该针对接口编程,不是针对实现编程. 面向过程的开发时,为了提高代码的复用率,一般会把常用的代码写成许许多多的程序库.这样做,在开发新项目的时候,只要调用这些低层的函数就...
  • 如果你有过控制依赖版本的这种经历,你可能就会遇到过第三方版本之间的冲突,本文介绍如何解决冲突,但是会提供给你一个基本存在冲突的基础依赖。得益于 Spring ,尤其是 Spring Boot 对第三方集成提供的 ...
  • WPF依赖属性

    千次阅读 2013-06-11 12:59:57
    理解依赖属性 依赖属性支持的特征包括:动画... WPF设计了依赖属性支持其特有的动态特性,并且干扰其他系统的.net代码。 定义依赖属性 public class FrameworkElement: UIElement, ... { public static readonly Dep
  • GoF之依赖倒转原则

    千次阅读 2014-09-04 20:44:10
    依赖倒转原则(Dependence Inversion Principle) 定义:高层模块应该依赖低层模块,二者都应该依赖其... 依赖倒转其实就是谁也不要依靠谁,除了约定的接口,大家都可以灵活自如。依赖倒转可以说是面向对象设计的
  • 什么是Spring的依赖注入?

    千次阅读 2019-03-11 21:27:03
    在生活中,依靠别人或者别的事物而不能独立或者自立,我们称为依赖。那么在应用中,什么叫依赖呢? 依赖指的是两个实例之间的关系。其中一个实例是独立的,另一个实例是非独立的(依赖的),它依靠另外一个实例。...
  • WPF基础——依赖属性

    千次阅读 2019-06-09 16:53:32
    依赖属性的出现是WPF这种特殊的呈现原理派生出来的,与.NET普通属性不同的是,依赖属性的值是依靠多个提供程序来判断的,并且其具有内建的传递变更通知的能力。 依赖属性基本应用在了WPF的所有需要设置属性的元素。...
  • 设计模式--依赖倒转原则

    千次阅读 2015-07-06 09:37:44
    抽象应该依赖细节,细节应该依赖于抽象。说白了,就是针对接口编程,不要针对实现编程。 依赖倒置原则包含三层含义: 1)高层模块应该依赖低层模块,两者都应该依赖其抽象; 2)抽象应该依赖细节; 3)细节...
  • Gradle Dependency Management 依赖管理

    千次阅读 2019-06-10 16:31:05
    依赖管理介绍 什么是依赖管理 Gradle的依赖管理 依赖解决方案是如何工作的 Dependency Types 依赖类型 Module dependencies 模块依赖 File dependencies 文件依赖 Project dependencies 项目依赖 Gradle API...
  • Spring学习之依赖注入

    千次阅读 2014-12-02 10:36:32
    在我平时写的程序中,各个类都是相互依赖的,比如在A中我需要用B类的方法,我就会在A类中new一个B类,这样看起来合情合理,但是耦合度较高,后期维护相当的困难,导致我每次做完一个项目或系统,都忍心
  • 全局的AlertDialog,不依靠activity

    千次阅读 2014-03-05 13:01:16
    情景:后台service接收到某个广播后发出事件,在application中接收到事件,处理事件是要弹出一个dialog,直接显示会报错: android.view.WindowManager$BadTokenException: Unable to add window -- token null is ...
  • 若想找老师,或者是想找人问,这本身就是不对的,程序员是最好的职业,前提是合格的程序员,现在很多人,一有问题,就想依靠别人,这根本能算程序员。真的是代码民工。
  • 依赖注入的javascript实现

    千次阅读 2015-12-14 20:53:54
    前后端终究是要完成合久必分分久必合的趋势。在前后端分离的前提下,后端的一些设计模式慢慢地向前端过渡。...而依赖注入是将服务等实例化后注入到控制器中进行实现。 下面就讲一下angular实现di的主要过程。主要依靠j
  • 数据库函数依赖

    千次阅读 2010-06-28 13:12:00
    一、函数依赖(Functional Dependency)的概念数据依赖的一种,它反映属性或属性组之间相依存,互相制约的关系,即反映现实世界的约束关系。二、定义 设R(U)是属性U上的一个关系模式,X和Y均为U={A1,A2,…,An}...
  • Spring的依赖注入原理浅析

    千次阅读 2019-01-10 12:02:57
    Spring的依赖注入依靠了动态代理和反射 最初我认为Spring的扫包时通过反射实例化了类,但是有个问题一直想不通 就是反射的方式获取实例时有可能会抛出异常,但是在手动获取Spring管理的对象时却需要捕捉异常,...
  • 参考了网上的经验和Java在dos中的语句,实现将jar包解压成文件夹修改其中配置文件,在不依靠开发工具的情况下重新打回jar包。 二.具体步骤 1.如图所示,其他的是lib包,红色标注的是主jar包,也就是最后java -...
  • 在很多情况下,WEB中进行URL重写一般是使用WEB服务器自身提供的组件, 经过几天的研究,终于找到脱离WEB服务器组件来进行URL重写的方法,我的做法是使用Filter对进站的请求进行筛选,然后根据规则进行转发或者...
  • 循环依赖:就是N个类循环(嵌套)引用。 通俗的讲就是N个Bean互相引用对方,最终形成闭环。用一副经典的图示可以表示成这样(A、B、C都代表类,虚线代表引用关系): 注意:其实可以N=1,也就是极限情况的循环依赖:...
  • Spring三级缓存解决循环依赖

    万次阅读 多人点赞 2020-02-28 09:53:05
    循环依赖:就是N个类循环(嵌套)引用。 通俗的讲就是N个Bean互相引用对方,最终形成闭环。用一副经典的图示可以表示成这样(A、B、C都代表对象,虚线代表引用关系): 其实可以N=1,也就是极限情况的循环依赖...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 110,201
精华内容 44,080
关键字:

依靠而不依赖