Google Guice依赖注入框架使用

最新推荐文章于 2024-06-06 20:33:16 发布
最新推荐文章于 2024-06-06 20:33:16 发布
阅读量2k 收藏 6
点赞数 2
文章标签： java
原文链接：https://blog.csdn.net/JCY1009015337/article/details/101059609
版权

Google Guice是一个轻量级依赖注入框架，和Spring类似。下面结合一些示例来讲解其使用方式。

首先引入maven依赖：

<dependency>
    <groupId>com.google.inject</groupId>
    <artifactId>guice</artifactId>
    <version>4.1.0</version>
</dependency>

示例1：

package com.jingchenyong.boundless.guice.example2;
 
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
 
@Singleton
class HelloPrinter {
    public void print() {
        System.out.println("Hello, World!");
    }
}
 
@Singleton
public class Sample {
 
    @Inject
    private HelloPrinter printer;
 
    public void hello() {
        printer.print();
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Sample sample1 = injector.getInstance(Sample.class);
        sample1.hello();
    }
}

Guice最常用的两个注解就是@Singleton和@Inject，前者表示构建的对象是单例的，后者表示被标注的字段将使用Guice自动注入。示例1中使用Guice创建了一个注射器injector，Guice会自动装配依赖树，然后通过getInstance()方法获取指定的类实例并运行。

如果不使用Singleton标注类，那么每次获取实例时，Guice会重新构造一个，增加性能损耗。如下示例2所示，在Sample类上取消了Singleton注解，那么每次injector.getInstance(Sample.class)调用获取的都是不同的实例（对象堆地址不同）。

示例2：

package com.jingchenyong.boundless.guice.example2;
 
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
 
@Singleton
class HelloPrinter {
    public void print() {
        System.out.println("Hello, World!");
    }
}
 
public class Sample {
 
    @Inject
    private HelloPrinter printer;
 
    public void hello() {
        printer.print();
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Sample sample1 = injector.getInstance(Sample.class);
        System.out.println(sample1);
        Sample sample2 = injector.getInstance(Sample.class);
        System.out.println(sample2);
    }
}
// 运行结果：
com.jingchenyong.boundless.guice.example2.Sample@74650e52
com.jingchenyong.boundless.guice.example2.Sample@15d0c81b

当一个接口有多个实现时，可以通过@ImplementedBy注解指定接口的具体实现类（不太优雅）。

示例3：

package com.jingchenyong.boundless.guice.example3;
 
import com.google.inject.Guice;
import com.google.inject.ImplementedBy;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
 
@ImplementedBy(ComplexHelloPrinter.class)
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
 
}
 
@Singleton
public class Sample {
 
    @Inject
    private IHelloPrinter printer;
 
    public void hello() {
        printer.print();
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector();
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}
 
// 运行结果
Hello, Complex World

为了解决在接口类上添加@ImplementedBy注解不优雅的方式，可以使用Guice Module定义装配规则，它相当于Spring的XML文件，只不过它的装配规则都是使用代码定义的。如下示例4所示：

示例4：

package com.jingchenyong.boundless.guice.example4;
 
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
 
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}
 
class SampleModule extends AbstractModule {
 
    @Override
    protected void configure() {
        bind(IHelloPrinter.class).to(SimpleHelloPrinter.class);
    }
 
}
 
public class Sample {
    @Inject
    private IHelloPrinter printer;
 
    public void hello() {
        printer.print();
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}

我们也可以使用@Named来指定依赖注入的实现（两种方式：字段注入和构造注入）

字段注入：

package com.jingchenyong.boundless.guice.example5;
 
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
 
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}
 
class SampleModule extends AbstractModule {
 
    @Override
    protected void configure() {
        bind(IHelloPrinter.class).annotatedWith(Names.named("simple")).to(SimpleHelloPrinter.class);
        bind(IHelloPrinter.class).annotatedWith(Names.named("complex")).to(ComplexHelloPrinter.class);
    }
 
}
 
public class Sample {
    @Inject
    @Named("simple")
    private IHelloPrinter simplePrinter;
    
    @Inject
    @Named("complex")
    private IHelloPrinter complexPrinter;
    
    public void hello() {
        simplePrinter.print();
        complexPrinter.print();
    }
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}

构造注入：

package com.jingchenyong.boundless.guice.example5;
 
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
 
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}
 
class SampleModule extends AbstractModule {
 
    @Override
    protected void configure() {
        bind(IHelloPrinter.class).annotatedWith(Names.named("simple")).to(SimpleHelloPrinter.class);
        bind(IHelloPrinter.class).annotatedWith(Names.named("complex")).to(ComplexHelloPrinter.class);
    }
 
}
 
public class Sample {
    @Named("simple")
    private IHelloPrinter simplePrinter;
    
    @Named("complex")
    private IHelloPrinter complexPrinter;
    
    @Inject
    public Sample(@Named("simple") IHelloPrinter simplePrinter, @Named("complex") IHelloPrinter complexPrinter) {
        this.simplePrinter = simplePrinter;
        this.complexPrinter = complexPrinter;
    }
    
    public void hello() {
        simplePrinter.print();
        complexPrinter.print();
    }
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}

有时候需要直接注入一个对象实例，而不是从依赖关系中解析。如果我们注入基本类型可以在SampleModule的configure()方法中添加如下语句：

bind(String.class).annotatedWith(Names.named("url")).toInstance("http://www.baidu.com");

那么在Sample中就可以添加如下语句进行自动装配：

@Named("url")
private String url;

当一个对象很复杂，无法使用简单的构造器来生成的时候，我们就可以使用使用实现Provider接口的类来生成复杂对象，然后在SampleModule的configure()方法中配置该复杂对象

（1）使用实现Provider接口的类来生成复杂对象

class LogParam {
    @Override
    public String toString() {
        return "我是test";
    }
}
// Log类为Sample类需要加载的复杂对象的抽象类（说它复杂因为包含了LogParam的实例）
abstract class Log {
    protected LogParam test;
 
    public abstract void setTest(LogParam test);
 
    public abstract LogParam getTest();
}
 
// Log的实现类
class MyLog extends Log {
 
    @Override
    public void setTest(LogParam test) {
        this.test = test;
    }
 
    @Override
    public LogParam getTest() {
        return this.test;
    }
 
}
 
class LogProvider implements Provider<Log> {
 
    private final LogParam test;
    // 这里会自动装配LogParam实例，也可在get方法中自定义构造该实例
    @Inject
    public LogProvider(LogParam test) {
        this.test = test;
    }
 
    @Override
    public Log get() {
        MyLog myLog = new MyLog();
        myLog.setTest(test);
        return myLog;
    }
 
}

（2）在SampleModule的configure()方法中配置该复杂对象

bind(Log.class).toProvider(LogProvider.class);

（3）Sample类中装配使用Log实现类

@Named("simple")
private IHelloPrinter simplePrinter;
    
@Named("complex")
private IHelloPrinter complexPrinter;
    
private Log log;
    
@Inject
public Sample(@Named("simple") IHelloPrinter simplePrinter, @Named("complex") IHelloPrinter complexPrinter, Log log) {
    this.simplePrinter = simplePrinter;
    this.complexPrinter = complexPrinter;
    this.log = log;
}

Guice还可以自动注入Set，Map容器，添加扩展库依赖

<dependency>
    <groupId>com.google.inject.extensions</groupId>
    <artifactId>guice-multibindings</artifactId>
    <version>4.1.0</version>
</dependency>

注入Set

package com.jingchenyong.boundless.guice.example6;
 
import java.util.Set;
 
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import com.google.inject.multibindings.Multibinder;
 
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}
 
class SampleModule extends AbstractModule {
 
    @Override
    protected void configure() {
        Multibinder<IHelloPrinter> printers = Multibinder.newSetBinder(binder(), IHelloPrinter.class);
        printers.addBinding().to(SimpleHelloPrinter.class);
        printers.addBinding().to(ComplexHelloPrinter.class);
    }
 
}
 
public class Sample {
 
    @Inject
    private Set<IHelloPrinter> printers;
 
    public void hello() {
        for (IHelloPrinter printer : printers) {
            printer.print();
        }
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}
// 运行结果
Hello, Simple World
Hello, Complex World

注入Map

package com.jingchenyong.boundless.guice.example6;
 
import java.util.Map;
 
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import com.google.inject.multibindings.MapBinder;
 
interface IHelloPrinter {
    void print();
}
 
@Singleton
class SimpleHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Simple World");
    }
}
 
@Singleton
class ComplexHelloPrinter implements IHelloPrinter {
 
    @Override
    public void print() {
        System.out.println("Hello, Complex World");
    }
}
 
class SampleModule extends AbstractModule {
 
    @Override
    protected void configure() {
        MapBinder<String, IHelloPrinter> printers = MapBinder.newMapBinder(binder(), String.class, IHelloPrinter.class);
        printers.addBinding("simple").to(SimpleHelloPrinter.class);
        printers.addBinding("complex").to(ComplexHelloPrinter.class);
    }
 
}
 
public class Sample {
 
    @Inject
    private Map<String, IHelloPrinter> printers;
 
    public void hello() {
        for (String name : printers.keySet()) {
            printers.get(name).print();
        }
    }
 
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new SampleModule());
        Sample sample = injector.getInstance(Sample.class);
        sample.hello();
    }
}
//运行结果
Hello, Simple World
Hello, Complex World

 

happyzwh
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Google Guice 一个轻量级的依赖注入框架
九师兄
07-03 1593
1.美图 2.概述 2.1 背景 在做项目的时候，看见有段代码直接是使用Google Guice 注入了avaitor表达式。 2.1 官网 Github 主页：https://github.com/google/guice API：http://google.github.io/guice/api-docs/4.0/javadoc/ Guice (pronounced 'juice') is ...
依赖注入框架-Google Guice
duoduozhengqian博客
05-30 593
依赖注入概念 依赖 在讲解依赖注入概念之前，我们可以先了解下依赖的概念，依赖就是当ClassA需要调用ClassB的任意方法时候，我们可以认为ClassA是ClassB的依赖，反之也可以理解为ClassA依赖于ClassB。 public class ClassA { ClassB classB = new ClassB(); double taxes(){ return classB.salary() * 0.45d; } } class ClassB {
Google Guice 注入（@Inject注解）
masterShaw的博客
02-21 9865
上一节介绍通过注解来实现绑定关系，这一节介绍如何通过@Inject来完成依赖注入的功能： （1）属性注入 （2）构造方法注入 （3）setter方法注入 一.属性注入 （1）创建一个接口Hello.Java和一个实现类HelloImpl [java] view plain copy   package guice.di
Google Guice超轻量级依赖注入容器
最新发布
JAVA入门中
06-06 733
Google Guice是Goolge开源的一款超轻量级依赖注入容器，超轻量的特点主要体现在：可与其它依赖注入容器混合使用，例如和Spring/Spring Boot的IOC容器混合使用；不需要任何配置信息，只需要引入几个有限的依赖包即可以使用；使用简单，只需要掌握几个有限的注释就可以使用；相对更重的依赖注入容器，Google Guice运行速度更快，消耗更少的系统资源。
Guice依赖注入(@Inject)
sidongxue2的专栏
05-22 573
package com.ilucky.guice.test3;import com.google.inject.Guice; import com.google.inject.Injector;/** * v1.0:20161114 * 注解:依赖注入@Inject * @author IluckySi */ public class MainTest { public static
Introduce Guice with Example
George's dev dream port
07-12 76
The motivation of Guice Guice alleviates the need for factories and the user of new operator in Java Make youself confident with Java's type safe nature. Helps you design better API Easy tests ...
GoogleGuiceDIExamples:Google Guice依赖注入框架的各种示例
05-07
Google Guice示例。 你学到什么？ 如何实现简单的链接绑定？ 当您对同一个类型有多个实现时，如何...笔记： 我在大多数地方都使用javax.inject.Inject批注指定依赖项，这样我们就可以避免在特定层导入Google Guice库。
DI容器框架Google Guice与Spring框架的区别
04-24
这个标题表明我们要探讨的是两种不同的依赖注入（Dependency Injection，简称DI）容器——Google Guice和Spring框架之间的差异。DI是一种设计模式，它帮助开发者在对象之间解耦，使得代码更加灵活、可测试和可维护。...
Java依赖注入框架Guice2
07-11
Java依赖注入框架Guice2是Google开发的一款轻量级的依赖注入库，它极大地简化了Java应用程序中的对象创建和管理。Guice2以其简洁的API和强大的功能在开发者社区中赢得了广泛的认可。依赖注入（Dependency Injection...
guice超轻量级依赖注入
08-09
总之，Guice作为一款轻量级的依赖注入框架，以其简洁的API和注解驱动的设计，极大地提高了Java应用的可维护性和灵活性。通过合理使用Guice，开发者可以专注于业务逻辑，而无需关心对象的创建和依赖关系的管理。在...
Guice可以匹敌Dagger的轻量级注入框架
08-06
Guice与Dagger都是流行的依赖注入框架，它们都致力于简化Java应用中的对象组装。Dagger相比Guice，更加强调编译时检查和静态类型安全，而Guice则更加轻量级，对代码侵入性较小。选择哪一个取决于项目的需求和团队的...
com.google.inject.source_3.0.0.v201312141243.jar
07-04
com.google.inject.source_3.0.0.v201312141243.jar
Google Guice需要的jar
05-01
Google Guice需要的jar包: Guice-3.0.jar javax.inject.jar
Google Guice + Dependency Injection ( Example)
weixin_34248118的博客
08-09 113
SOURCE: https://code.google.com/p/google-guice/wiki/Motivation?tm=6normal method, dependency injection, dependency injection with GUICE *****************************************************...
google（轻量级依赖注入框架）Guice学习 (一)注入
CoffeeAndIce的博客
05-13 3161
Guice与Spring 相比，属于轻量级框架，更轻，帮助我们解决Java项目中的依赖注入问题。如果仅需要解决依赖和注入问题的话，就应该考虑一下它，而不是直接Spring走起谈论：注入首先来设定场景，假设有一个订单场景，当然，我们只为了展示注入而设定一个微小的代码段；ps: 文中所用maven配置 &lt;properties&gt; &lt;project.build.sourceEncod...
Google开源依赖注入框架-Guice指南
所寫即所思｜一个阿里质量人对测试的所感所悟。
06-26 1087
之前发过一篇文章《浅谈依赖注入的实现》，介绍了依赖注入的实现原理。文中提到高效实现依赖注入的工具Guice，本文就介绍一下这款Google开源的依赖注入框架Guice及其使用方法。Google Guice 是一个轻量级的依赖注入框架，它支持Java 5或者更高版本的JDK，得利于Java 5中提供的泛型 (Generics) 和注解 (Annotations) ，它可以使得代码类型安全 (type-safe) 。.........
依赖注入框架 Google Guice @Inject注解
大雪的博客
12-18 2065
本文介绍 inject 这个依赖注入框架简单以一个demo为示例，演示简单的依赖注入使用。 <dependency> <groupId>com.google.inject</groupId> <artifactId>guice</artifactId> <version>${guice-version}</version> </dependency> 全程无废话，直接上代码： 第.
Googel Guice注入方式
新之助的学习之路
09-22 2355
1.类依赖注入所谓的绑定就是将一个接口绑定到具体的类中，这样客户端不用关心具体的实现，而只需要获取相应的接口完成其服务即可。HelloWorld.java public interface HelloWorld { String sayHello(); }然后是具体的实现，HelloWorldImpl.java public class HelloWorl
谷歌插件inject注入脚本与content script基于Promise+async/await 同步通信实现过程
王森的博客
04-02 1067
因为webpage和contentscript是两个隔离环境，在webpage（普通网页）中有CSP安全机制，而在macm1环境，MV3版本下无法修改response.header这个bug半年前反馈给谷歌，后续也没见结果，所以，想在webpage网页中直接请求远程url是走不通的，只有借助contentscript来协助请求数据，但是这里牵涉到两个步骤，能否实现异步转同步方式来处理这个过程？
Java工具类如何实现依赖注入
04-11
Java工具类可以实现依赖注入的方式有很多，比较常见的包括使用Spring框架提供的注解，在类中使用@Autowired或@Resource注解来自动注入依赖。另外，也可以使用Java的反射机制，通过获取依赖对象的Class对象，并创建对象实例后赋值给工具类中的依赖属性。还有一些第三方工具库例如Google Guice也提供了依赖注入功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值