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

来源：互联网发布：高德地图数据导入编辑：程序博客网时间：2024/05/21 03:57

url: http://www.importnew.com/6761.html

本文由 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
public V get(final K 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; 
}       
  
public void put(finalK key, final V 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();             
  }            
} 
  
public Map<K, V> getAll(Set<? extends K> 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 =new HashMap<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
public V get(final K key)
{ 
  returnexecuteWithMap(newExecutable<V>() { 
      publicV execute(ObjectMap map) throwsObjectGridException 
      {
          return(V) map.get(key); 
      }
  });              
}       
  
public void put(finalK key, final V value) 
{ 
  executeWithMap(newExecutable<Void>() { 
      publicVoid execute(ObjectMap map) throwsObjectGridException 
      {
          map.upsert(key, value);
          returnnull; 
      }
  });              
} 
  
public Map<K, V> getAll(Set<? extends K> 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 =new HashMap<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
public V get(final K key)
{ 
  returnexecuteWithMap((ObjectMap map) -> (V) map.get(key)); 
}       
  
public void put(finalK key, final V value) 
{ 
  executeWithMap((ObjectMap map) -> { map.upsert(key, value);return null; });
} 
  
public Map<K, V> getAll(Set<? extends K> keys) 
{ 
  finalList<K> keyList = newArrayList<K>(); 
  keyList.addAll(keys);
  List<V> valueList = executeWithMap((ObjectMap map) -> map.getAll(keyList));
  
  Map<K, V> map =new HashMap<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
[ 转载请保留原文出处、译者和译文链接。]

0 0