使用dropwizard(3)-加入DI-dagger2

前言

习惯了Spring全家桶,对spring的容器爱不释手。使用dropwizard,看起来确实很轻,然而,真正使用的时候不得不面临一个问题。我们不可能一个resource就能把所有的业务逻辑囊括!那么,必然就要有负责处理逻辑的代码,有要提取的公共的代码,要做面向接口开发等等。按照简单的用法,Java Bean就自己new,只要通过Jersey提供的web能力发出去就好。这样写下来,到处都需要new,难以测试等等。目前我最care的是,每个request过来都要new一堆重复的对象,垃圾回收频繁。写个单例不就解决了?是的,当然要想到单例,然后发现几乎所有的类都是设计成单例的。然后,一堆单例的代码写的死。这就是样板代码。于是,想到提取工具类,算了,不如用Dagger好了。

什么是Dagger

Dagger是Java里开源的DI框架中最火的之一,主要用在Android领域,很多特性也多针对Android开发的。因为Android开发对省电,性能之类的要求比较高,因此抛弃了反射,直接在编译级别生成工厂。详细学习测试:Dagger2之helloworld原理探究

Demo Source

https://github.com/Ryan-Miao/l4dropwizard

structure

.
├── pom.xml
├── readme.md
└── src
    └── main
        ├── java
        │   └── com
        │       └── test
        │           ├── HelloWorldApplication.java
        │           ├── bundles
        │           │   └── ConnectivityBundle.java
        │           ├── configuration
        │           │   ├── HelloWorldConfiguration.java
        │           │   └── modules
        │           │       ├── ConnectAndReadConfig.java
        │           │       └── GithubApiConfig.java
        │           └── domain
        │               ├── connect
        │               │   ├── FeignClientBuilder.java
        │               │   ├── GithubClient.java
        │               │   └── GithubConnector.java
        │               ├── entiry
        │               │   ├── GithubUser.java
        │               │   └── Saying.java
        │               ├── exception
        │               │   └── UpstreamException.java
        │               ├── health
        │               │   └── TemplateHealthCheck.java
        │               ├── ioc
        │               │   ├── component
        │               │   │   └── GithubComponent.java
        │               │   └── module
        │               │       ├── ConfigurationModule.java
        │               │       ├── ConnectorModule.java
        │               │       └── ServiceModule.java
        │               ├── resource
        │               │   ├── GithubResource.java
        │               │   └── HelloWorldResource.java
        │               └── service
        │                   ├── IGithubService.java
        │                   └── impl
        │                       └── GithubService.java
        └── resources
            └── config
                └── dev.yml

本文基于之前的dropwizard入门演进.

添加dagger依赖

properties结点下新增

<dagger.verion>2.12</dagger.verion>

在dependencies下新增

<dependency>
    <groupId>com.google.dagger</groupId>
    <artifactId>dagger</artifactId>
    <version>${dagger.verion}</version>
</dependency>

build.plugins下新增plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.6.1</version>
    <configuration>
        <source>${java.version}</source>
        <target>${java.version}</target>
        <encoding>UTF-8</encoding>
        <annotationProcessorPaths>
            <path>
                <groupId>com.google.dagger</groupId>
                <artifactId>dagger-compiler</artifactId>
                <version>${dagger.verion}</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

在IDEA设置中,找到Build>Compiler>Annotation Processors, 选择Enable annotation processing.

创建一个Component

下面创建Component,用来包容Resource类,对外提供Resource类。新建com.test.domain.ioc.component.GithubComponent

package com.test.domain.ioc.component;

import com.test.domain.ioc.module.ServiceModule;
import com.test.domain.resource.GithubResource;
import dagger.Component;

import javax.inject.Singleton;

/**
 * Created by Ryan Miao on 10/26/17.
 */
@Singleton
@Component(modules = {ServiceModule.class})
public interface GithubComponent {
     GithubResource gitHubResource();
}

显然,这个GithubResource需要注入一个service,于是声明一个ServiceModule, 创建com.test.domain.ioc.module.ServiceModule

package com.test.domain.ioc.module;

import com.test.domain.service.IGithubService;
import com.test.domain.service.impl.GithubService;
import dagger.Module;
import dagger.Provides;

import javax.inject.Singleton;

/**
 * Created by Ryan Miao on 10/26/17.
 */
@Module(includes = ConnectorModule.class)
public class ServiceModule {

    @Singleton
    @Provides
    public IGithubService githubService(GithubService service) {
        return service;
    }
}

ServiceModule用来提供service注入,service接着依赖connector层,新建com.test.domain.ioc.module.ConnectorModule

package com.test.domain.ioc.module;

import com.test.domain.connect.FeignClientBuilder;
import dagger.Module;
import dagger.Provides;

import javax.inject.Singleton;

/**
 * Created by Ryan Miao on 10/26/17.
 */
@Module(includes = ConfigurationModule.class)
public class ConnectorModule {

    @Provides
    @Singleton
    public FeignClientBuilder feignClientBuilder(){
        return new FeignClientBuilder();
    }
    
}

connecttor层中,需要调用GlobalConfiguration的配置项,所以,单独把配置提出来,引入。新增com.test.domain.ioc.module.ConfigurationModule

package com.test.domain.ioc.module;

import com.test.configuration.HelloWorldConfiguration;
import dagger.Module;
import dagger.Provides;

import javax.inject.Singleton;

/**
 * Created by Ryan Miao on 11/20/17.
 */
@Module
public class ConfigurationModule {
    private final HelloWorldConfiguration configuration;

    public ConfigurationModule(HelloWorldConfiguration configuration) {
        this.configuration = configuration;
    }


    @Provides
    @Singleton
    public HelloWorldConfiguration helloWorldConfiguration(){
        return configuration;
    }
}

这是依赖的最底层,我们通过手动构造函数的方式注入configuration,这样可以在dropwizard启动时生成module,并且得到configuration。

引入我们的Component

这时候,build一下,dagger就会自动生成我们的工厂。

mvn clean install

然后,在IDEA里的maven plugin里,右键,reimport。防止IDEA不认识dagger自动生成的类。dagger自动生成的类位于target/generated-sources/annotations. 点击刷新按钮,刷新下maven依赖。

然后,在com.test.HelloWorldApplication中,新增

private void registerResources(HelloWorldConfiguration configuration, Environment environment) {
    GithubComponent component = DaggerGithubComponent.builder()
            .configurationModule(new ConfigurationModule(configuration))
            .build();
    environment.jersey().register(component.gitHubResource());
}

DaggerGithubComponent要在maven install之后,dagger生成的。完整启动类如下:

public class HelloWorldApplication extends Application<HelloWorldConfiguration> {

    public static void main(String[] args) throws Exception {
        new HelloWorldApplication().run(args);
    }

    @Override
    public String getName() {
        return "hello-world";
    }

    @Override
    public void initialize(Bootstrap<HelloWorldConfiguration> bootstrap) {
        bootstrap.addBundle(new ConnectivityBundle());
    }

    @Override
    public void run(HelloWorldConfiguration configuration, Environment environment) throws Exception {
        final HelloWorldResource resource = new HelloWorldResource(
                configuration.getTemplate(),
                configuration.getDefaultName()
        );
        final TemplateHealthCheck healthCheck =
                new TemplateHealthCheck(configuration.getTemplate());
        environment.healthChecks().register("template", healthCheck);
        environment.jersey().register(resource);
        environment.jersey().register(healthCheck);

        registerResources(configuration, environment);

    }

    private void registerResources(HelloWorldConfiguration configuration, Environment environment) {
        GithubComponent component = DaggerGithubComponent.builder()
                .configurationModule(new ConfigurationModule(configuration))
                .build();
        environment.jersey().register(component.gitHubResource());
    }
}

当然,我们的Resource也要改成Inject模式

public class GithubResource {

    private IGithubService service;

    @Inject
    public GithubResource(IGithubService service) {
        this.service = service;
    }

    @GET
    @Timed
    @Path("/users/{username}")
    public GithubUser getUserProfile(@PathParam("username") final String username) {
        return service.getUserProfile(username);
    }

}

启动,运行。一切OK。以后就可以在需要注入的类的构造器上声明@Inject, 或者在module里@Provide,就可以实现构造解耦。测试不要太方便.

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏安富莱嵌入式技术分享

【RL-TCPnet网络教程】第26章 RL-TCPnet之DHCP应用

本章节为大家讲解RL-TCPnet的DHCP应用,学习本章节前,务必要优先学习第25章的DHCP基础知识。有了这些基础知识之后,再搞本章节会有事半功倍的效果。

11210
来自专栏技术墨客

Hazelcast集群服务(1)——Hazelcast介绍

    “分布式”、“集群服务”、“网格式内存数据”、“分布式缓存“、“弹性可伸缩服务”——这些牛逼闪闪的名词拿到哪都是ITer装逼的不二之选。在Javaer的...

42530
来自专栏Java架构师学习

Spring5都有那些新特性与增强,需要了解的Java程序员来看一看

Spring FrameWork 5.0新的功能 JDK 8+和Java EE7+以上版本 整个框架的代码基于java8 通过使用泛型等特性提高可读性 对j...

40570
来自专栏java系列博客

Java面试通关要点汇总集之框架篇参考答案

23240
来自专栏阿杜的世界

Spring实战5-基于Spring构建Web应用主要内容

写在前面:关于Java Web,首先推荐一篇文章——写给java web一年左右工作经验的人,这篇文章的作者用精练的话语勾勒除了各种Java框架的缘由和最基本的...

13020
来自专栏携程技术中心

干货 | JAVA反序列化安全实例解析

作者简介 迟长峰,携程技术中心信息安全部应用安全工程师。 什么是序列化 序列化 (Serialization)是指将对象的状态信息转换为可以存储或传输的形式的过...

371100
来自专栏用户2442861的专栏

25个经典的Spring面试问答

本人收集了一些在大家在面试时被经常问及的关于Spring的主要问题,这些问题有可能在你下次面试时就会被问到。对于本文中未提及的Spring其他模块,我会单独分...

11520
来自专栏Java学习网

Java开发技术之Spring依赖注入知识学习

不管是构造器、Setter方法还是其他的方法,Spring都会尝试满足方法参数上所声明的依赖。假如有且只有一个bean匹配依赖需求的话,那么这个bean将会被装...

12820
来自专栏Java3y

Spring IOC知识点一网打尽!

20080
来自专栏battcn

一起来学SpringBoot | 第十六篇:定时任务详解

在我们日常开发中,经常会遇到 数据定时增量同步、 定时发送邮件、 爬虫定时抓取 等需求;这时我们可以采用 定时任务的方式去进行工作.....

16220

扫码关注云+社区

领取腾讯云代金券