一个六年经验的python后端是怎么学习用java写API的（5） Service 和 google 依赖注入

头像
D咄咄
    阅读 8 分钟

    描述

    上一篇（一个六年经验的python后端是怎么学习用java写API的（4） RestAPI，dropwizard 的第一组API）写完第一组API后发现，每次实现一个resource，都需要在 Application.java里面的sessionFactory的config里面addMapper，然后在具体使用mybatis查询的时候也需要先拿到 session 然后再把这个mapper类拿出来，非常不方便 session.getMapper(ArticleMapper.class)

    查阅资料发现java的一些web框架是通过一种叫做依赖注入的方式减少这些操作的，google-guice的这个wiki就讲解了依赖注入的核心。大概就是说，代码不需要导出new东西了，通过@inject注解减少很多代码。

    代码

    parrot tag: google_injector

    依赖注入实现

    https://github.com/google/gui...

    大概就是需要继承 AbstractModule 然后 通过 configure 将各种类注册，然后需要的地方可以直接使用 injector.getInstance(注册的类.class);，或者直接在构造方法等地方使用 @Inject 等注解。

    代码结构如下，可以看到主要是添加了module 和 service

     $ tree
.
└── com
    ├── loginbox
    │   └── dropwizard
    │       └── mybatis
    │           └── EnhancedMybatisBundle.java
    └── reworkplan
        ├── ParrotApplication.java
        ├── bundles
        │   ├── CorsBundle.java
        │   ├── GuiceBundle.java
        │   └── MysqlBundle.java
        ├── common
        │   ├── Constants.java
        │   └── response
        │       ├── MetaListResponse.java
        │       └── MetaMapperResponse.java
        ├── config
        │   └── ParrotConfiguration.java
        ├── mappers
        │   ├── ArticleMapper.java
        │   └── handlers
        │       └── DateTimeTypeHandler.java
        ├── models
        │   └── Article.java
        ├── modules
        │   ├── ApplicationModule.java
        │   ├── InjectorFactory.java
        │   ├── MysqlMapperModule.java
        │   ├── ServiceModule.java
        │   └── provider
        │       └── MysqlMapperProvider.java
        ├── resources
        │   ├── ArticlesResource.java
        │   └── BasePath.java
        └── service
            ├── ArticleService.java
            └── ArticleServiceImpl.java

    InjectorFactory 的 createInjector 里面添加需要注册的各个Module，有些需要拿到config上下文。

    public class InjectorFactory {  
    public Injector get(ParrotConfiguration configuration, Environment environment) {  
        Injector intjector = Guice.createInjector(  
                new ApplicationModule(configuration, environment),  
                new MysqlMapperModule(configuration, environment),  
                new ServiceModule()  
        );  
        return intjector ;  
    }  
}

    先说简单的 service module，django的api的重逻辑是建议直接写在models.py里面的，跟django的逻辑不同的是，java除了直接操作数据库的dao层外，还需要一个service 层，而且很烦的一点在于要先实现一个service 抽象类，在实现一个serviceImpl的实现类，所以这个model主要就是将抽象类和实现类绑定。

    public class ServiceModule extends AbstractModule {

    @Override
    protected void configure() {
        bindService(ArticleService.class, ArticleServiceImpl.class);
    }

    private <T> void bindService(Class<T> interfaceClass, Class<? extends T> implClass) {
        bind(interfaceClass).to(implClass).in(Scopes.SINGLETON);
    }
}

    写完这个之后再 Application.java 里面就可以直接这么写，environment.jersey().register(injector.getInstance(ArticlesResource.class));，然后在Resource初始化的时候直接使用 @Inject注解就完事了。

    public class ArticlesResource {
    private final ArticleService articleService;

    @Inject
    public ArticlesResource(ArticleService articleService) {
        this.articleService = articleService;
    }
    ...
}

    MysqlMapperModule类似，核心逻辑在于将 Mapper类在 config上注册，而之前知道在注册mapper的时候其实还用到了sessionFactory，所以还要在写一个实现了javax.inject.Provider的 MysqlMapperProvider

    public class MysqlMapperModule extends AbstractModule {
    private final ParrotConfiguration configure;
    private final Environment enviroment;

    public MysqlMapperModule(ParrotConfiguration configuration, Environment environment) {
        this.configure = configuration;
        this.enviroment = environment;
    }

    @Override
    protected void configure() {
        addMapper(ArticleMapper.class);
    }

    @Provides
    @Singleton
    @Named("mysql")
    public SqlSessionManager getMysqlSqlSessionManager(@Named("mysql") SqlSessionFactory sqlSessionFactory) {
        return SqlSessionManager.newInstance(sqlSessionFactory);
    }

    @Provides
    @Singleton
    @Named("mysql")
    public SqlSessionFactory getMysqlSqlSessionFactory() {
        return this.configure.getMysqlSqlSessionFactory();
    }

    private <T> void addMapper(Class<T> mapperType) {
        bind(mapperType).toProvider(guicify(new MysqlMapperProvider<>(mapperType))).in(Scopes.SINGLETON);
    }
}

import javax.inject.Provider;

public class MysqlMapperProvider <T> implements Provider<T> {

    private final Class<T> mapperType;

    @Inject
    @Named("mysql")
    private SqlSessionManager sqlSessionManager;

    public MysqlMapperProvider(Class<T> mapperType) {
        this.mapperType = mapperType;
    }

    public void setSqlSessionManager(SqlSessionManager sqlSessionManager) {
        this.sqlSessionManager = sqlSessionManager;
    }

    @Override
    public T get() {
        return this.sqlSessionManager.getMapper(mapperType);

    }
}

    写完这个之后对应的 serviceImpl 和 resouce这么写,

    public class ArticleServiceImpl implements ArticleService {
    private final ArticleMapper articleMapper;

    @Inject
    public ArticleServiceImpl(ArticleMapper articleMapper) {
        this.articleMapper = articleMapper;
    }

    @Override
    public List<Article> getList(Boolean isActive, Integer offset, Integer limit) {
        List<Article> articles = articleMapper.selectAll(isActive, offset, limit);
        return articles;
    }

    @Override
    public Article get(Integer id, Boolean isActive) {
        return articleMapper.select(id, isActive);
    }

    @Override
    public Integer count(Boolean isActive) {
        return articleMapper.countAll(isActive);
    }
}

@Path(BasePath.ARTICLE_API)
@Produces(APPLICATION_JSON)
public class ArticlesResource {
    private final ArticleService articleService;

    @Inject
    public ArticlesResource(ArticleService articleService) {
        this.articleService = articleService;
    }

    @GET
    @Timed
    public MetaListResponse get(@DefaultValue(Constants.DEFAULT_PARAM_OFFSET) @QueryParam("offset") Integer offset,
                                @DefaultValue(Constants.DEFAULT_PARAM_LIMIT) @QueryParam("limit") Integer limit){
        MetaListResponse response = new MetaListResponse();
        response.putMeta("count", 0);
        Boolean isActive = true;
        Integer count = articleService.count(isActive);
        List<Article> articles = articleService.getList(isActive, offset, limit);
        response.putMeta("count", count);
        response.setData(articles);
        return response;
    }

    @Path("/{id}")
    @GET
    @Timed
    public MetaMapperResponse get(@NotNull @PathParam("id") Integer articleId) {
        MetaMapperResponse response = new MetaMapperResponse();
        Boolean isActive = true;
        Article article = articleService.get(articleId, isActive);
        response.setData(article);
        return response;
    }
}

    对比下之前版本的Resource可以发现明显代码干净多了, 不用每次都在sessionFactory去拿Mapper.class了，之后实现完mapper、service后只要在对应的module的config里面添加一行即可。

    @Path(BasePath.ARTICLE_API)
@Produces(APPLICATION_JSON)
public class ArticlesResource {
    private final SqlSessionFactory sessionFactory;

    public ArticlesResource(SqlSessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }   

    @GET
    @Timed
    public MetaListResponse get(@DefaultValue(Constants.DEFAULT_PARAM_OFFSET) @QueryParam("offset") Integer offset,
                                @DefaultValue(Constants.DEFAULT_PARAM_LIMIT) @QueryParam("limit") Integer limit){
        MetaListResponse response = new MetaListResponse();
        response.putMeta("count", 0); 
        try (SqlSession session = sessionFactory.openSession()) {
            ArticleMapper articleMapper = session.getMapper(ArticleMapper.class);
            Boolean isActive = true;
            Integer count = articleMapper.countAll(isActive);
            List<Article> articles = articleMapper.selectAll(isActive, offset, limit);
            response.putMeta("count", count);
            response.setData(articles);
        }
        return response;
    }

    @Path("/{id}")
    @GET
    @Timed
    public MetaMapperResponse get(@NotNull @PathParam("id") Integer articleId) {
        MetaMapperResponse response = new MetaMapperResponse();
        try (SqlSession session = sessionFactory.openSession()) {
            ArticleMapper articleMapper = session.getMapper(ArticleMapper.class);
            Boolean isActive = true;
            Article article = articleMapper.select(articleId, isActive);
            response.setData(article);
        }
        return response;
    }
}

    一些感悟

    至于为什么java要多出一层service和serviceImpl，看到目前我的感受就是静态语言太过于笨重，语言上有private、public本身的设计模式，model上要实现一个Bean就要写一大堆的东西，而这堆东西仅仅是基本的字段赋值取值，即使用了mybatis做orm，这个model层已然很重了，不适合做多个model之间的数据柔和等逻辑。

    而django的model在orm拿出即用，可以说所有属性都是public的，所以不需要封装bean，全public的特性就使得直接揉其他model在语言特性上就轻的多。

    当然java可以说我定义了一个service就不用关心具体子类是怎么实现的，但是写工程代码多了可能会听说过这句话，约定大于配置，同样的轻语言在各个不同子方法（类或者直接就是方法）实现的时候只要遵循约定的接口即可。

    另外虽然java有强编译的特性，但是很多时候依然会遇到运行时各种空指针问题，所以说大工程下java天生强于轻语言是很蠢的一种说法，工程项目靠的还是大量的测试（单元、集成），部署监控策略（测试环境、灰度、放量上线）。

    接下来

    todo: 一个六年经验的python后端是怎么学习用java写API的（6） 基本的Auth

    javadropwizard依赖注入
    D咄咄
    1.7k 声望257 粉丝

    Life is to short, please use python.

    « 上一篇
    一个六年经验的python后端是怎么学习用java写API的（4） RestAPI，dropwizard 的第一组API
    下一篇 »
    一个六年经验的python后端是怎么学习用java写API的（6） 基本的Auth

    引用和评论

    被 2 篇内容引用
    推荐阅读
    头像
    一个六年经验的python后端是怎么学习用java写API的（6） 基本的Auth

    D咄咄阅读 2.2k

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 10阅读 4.6k评论 1

    头像
    Jerry和您聊聊Chrome开发者工具

    注销赞 9阅读 4.8k评论 3

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 6阅读 2.4k

    头像
    💢线上高延迟请求排查

    crossoverJie赞 6阅读 3.9k评论 5

    头像
    Spring Boot起步，CRUD、错误处理与宝塔部署

    微芒不朽赞 3阅读 3.8k

    头像
    这些年

    注销赞 2阅读 4k

    0 条评论
    得票最新