zoukankan      html  css  js  c++  java

  • 避免代码冗余，使用接口和泛型重构Java代码

    本文由 ImportNew - ImportNew读者 翻译自 michaelbrameld。如需转载本文，请先参见文章末尾处的转载要求。

    【感谢 李云涛（@平等的黑）的热心翻译。如果其他朋友也有不错的原创或译文，可以尝试投递到 ImportNew。】

    在使用动态语言和.NET工作了若干年后，我又回到老本行–Java开发。在Ruby中，清除代码冗余是非常方便的，而在Java中则需要结合接口和泛型实现类似的功能。

    原始代码

    以下是这个类中的一些方法用于后续的阐述。为了使例子更简洁，我移除了些代码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    publicV get(finalK key)
    {
      Session s;
      try{
          s = oGrid.getSession();
          ObjectMap map = s.getMap(cacheName);
          return(V) map.get(key);
      }
      catch(ObjectGridException oge)
      {
          thrownew RuntimeException("Error performing cache operation", oge);
      }
      finally
      {
          if(s != null)
              s.close();        
      }   
      returnnull;
    }     
     
    publicvoid put(finalK key, finalV value)
    {
      Session s;
      try{
          s = oGrid.getSession();
          ObjectMap map = s.getMap(cacheName);
          map.upsert(key, value);
      }
      catch(ObjectGridException oge)
      {
          thrownew RuntimeException("Error performing cache operation", oge);
      }
      finally
      {
          if(s != null)
              s.close();            
      }           
    }
     
    publicMap<K, V> getAll(Set<? extendsK> keys)
    {
      finalList<V> valueList = newArrayList<V>();
      finalList<K> keyList = newArrayList<K>();
      keyList.addAll(keys);
     
      Session s;
      try{
          s = oGrid.getSession();
          ObjectMap map = s.getMap(cacheName);
          valueList.addAll(map.getAll(keyList));
      }
      catch(ObjectGridException oge)
      {
          thrownew RuntimeException("Error performing cache operation", oge);
      }
      finally
      {
          if(s != null)
              s.close();            
      }
     
      Map<K, V> map = newHashMap<K, V>();
      for(inti = 0; i < keyList.size(); i++) {
          map.put(keyList.get(i), valueList.get(i));
      }
      returnmap;
    }

    遇到的问题

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    Session s;
    try{
      s = oGrid.getSession();
      ObjectMap map = s.getMap(cacheName);
      // Some small bit of business logic goes here
    }
    catch(ObjectGridException oge)
    {
      thrownew RuntimeException("Error performing cache operation", oge);
    }
    finally
    {
      if(s != null)
          s.close();            
    }

    上面的代码段几乎存在于类的每个方法中，这违反了DRY原则 。将来如果需要改变检索Session 和 ObjectMap实例的方式，或着某天这段代码被发现有缺陷，我们就不得不修改每个(包含这段代码的)方法，因此需要找到一种方式来复用这些执行代码。

    重构后的代码

    为了传递包含了原方法中业务逻辑的实例，我们创建一个带有抽象方法的 Executable 接口 。execute()方法参数为我们欲操作的ObjectMap实例。

    1
    2
    3
    interfaceExecutable<T> {
      publicT execute(ObjectMap map) throwsObjectGridException;
    }

    由于我们的目的仅仅是在每个方法中操作ObjectMap实例，可以创建executeWithMap()方法封装前述的那一大段重复代码。这个方法的参数是Executable接口的实例，实例包含着操作map的必要逻辑(译者注：这样Executable接口的实例中就是纯粹的业务逻辑，实现了解耦合)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    private<T> T executeWithMap(Executable<T> ex)
    {
      Session s;
      try{
          s = oGrid.getSession();
          ObjectMap map = s.getMap(cacheName);
          // Execute our business logic
          returnex.execute(map);
      }
      catch(ObjectGridException oge)
      {
          thrownew RuntimeException("Error performing cache operation", oge);
      }
      finally
      {
          if(s != null)
              s.close();            
      }
    }

    现在，可以用如下形式的模板代码替换掉第一个例子中的代码：这个模板创建了一个匿名内部类，实现了Executable接口和execute()方法。其中execute()方法执行业务逻辑，并以getXXX()的方式返回结果(若为Void方法，返回null)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    publicV get(finalK key)
    {
      returnexecuteWithMap(newExecutable<V>() {
          publicV execute(ObjectMap map) throwsObjectGridException
          {
              return(V) map.get(key);
          }
      });             
    }     
     
    publicvoid put(finalK key, finalV value)
    {
      executeWithMap(newExecutable<Void>() {
          publicVoid execute(ObjectMap map) throwsObjectGridException
          {
              map.upsert(key, value);
              returnnull;
          }
      });             
    }
     
    publicMap<K, V> getAll(Set<? extendsK> keys)
    {
      finalList<K> keyList = newArrayList<K>();
      keyList.addAll(keys);
      List<V> valueList = executeWithMap(newExecutable<List<V>>() {
          publicList<V> execute(ObjectMap map) throwsObjectGridException
          {
              returnmap.getAll(keyList);
          }
      });                             
     
      Map<K, V> map = newHashMap<K, V>();
      for(inti = 0; i < keyList.size(); i++) {
          map.put(keyList.get(i), valueList.get(i));
      }
      returnmap;
    }

    FunctionalInterface Annotation (功能接口注释)

    Java 8 的 @FunctionalInterface annotation 使这一切变的简单。若某接口带有一个抽象方法，这个接口便可以被用作为lambda表达式的参数，称为功能接口。

    1
    2
    3
    4
    @FunctionalInterface
    interfaceExecutable<T> {
      publicT execute(ObjectMap map) throwsObjectGridException;
    }

    只要接口仅仅包含一个抽象方法，便可以使用这个annotation。这样就能减少相当数量的模板代码。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    publicV get(finalK key)
    {
      returnexecuteWithMap((ObjectMap map) -> (V) map.get(key));
    }     
     
    publicvoid put(finalK key, finalV value)
    {
      executeWithMap((ObjectMap map) -> { map.upsert(key, value); returnnull; });
    }
     
    publicMap<K, V> getAll(Set<? extendsK> keys)
    {
      finalList<K> keyList = newArrayList<K>();
      keyList.addAll(keys);
      List<V> valueList = executeWithMap((ObjectMap map) -> map.getAll(keyList));
     
      Map<K, V> map = newHashMap<K, V>();
      for(inti = 0; i < keyList.size(); i++) {
          map.put(keyList.get(i), valueList.get(i));
      }
      returnmap;
    }

    结论

    实现这些重构我很开心。它比原始的代码略复杂一点，但是更简明，更DRY，所以一切都是值得的。 尽管还有提升的空间，但这是一个良好的开始。

    原文链接： michaelbrameld 翻译： ImportNew.com - ImportNew读者
    译文链接： http://www.importnew.com/6761.html
  • 相关阅读:
    RMI、Hessian、Burlap、Httpinvoker、WebService的比较
    分布式事务（两阶段提交）模型详解
    CAP和BASE理论
    两阶段提交协议的异常处理
    到底什么是单元测试
    Fast Paxos 和 Paxos的区别
    Servlet和JSP生命周期概述
    Zookeeper和 Google Chubby对比分析
    优秀开源项目的svn地址
    Explain语法
  • 原文地址：https://www.cnblogs.com/daichangya/p/12958978.html
Copyright © 2011-2022 走看看