首页 > 代码库 > Java 类型安全的异构容器

Java 类型安全的异构容器

2024-10-12 18:18:39   217人阅读

转载自：http://blog.csdn.net/sh_c1991/article/details/45965743

 

我们的想法是用key自身的class 类型作为key。因为Class 是参数化的类型，它可以确保我们使Context方法是类型安全的，而无需诉诸于一个未经检查的强制转换为T。这种形式的一个Class 对象称之为类型令牌（type token）。

 

[java] view plain copy
 
  1. public class Context {  
  2.    
  3.   private final Map<Class<?>, Object> values = new HashMap<>();  
  4.    
  5.   public <T> void put( Class<T> key, T value ) {  
  6.     values.put( key, value );  
  7.   }  
  8.    
  9.   public <T> T get( Class<T> key ) {  
  10.     return key.cast( values.get( key ) );  
  11.   }  
  12.    
  13.   [...]  
  14. }  


请注意在Context#get 的实现中是如何用一个有效的动态变量替换向下转型的。客户端可以这样使用这个context：

 

 

[java] view plain copy
 
  1. Context context = new Context();  
  2. Runnable runnable ...  
  3. context.put( Runnable.class, runnable );  
  4.    
  5. // several computation cycles later...      
  6. Executor executor = ...  
  7. context.put( Executor.class, executor );  
  8.    
  9. // even more computation cycles later...  
  10. Runnable value = context.get( Runnable.class );  
这次客户端的代码将可以正常工作，不再有类转换的问题，因为不可能通过一个不同的值类型来交换某个键值对。

Bloch指出这种模式有两个局限性。“首先，恶意的客户端可以通过以原生态形式（raw form）使用class对象轻松地破坏类型安全。”为了确保在运行时类型安全可以在Context#put中使用动态转换（dynamic cast）。

 

 

[java] view plain copy
 
  1. public <T> void put( Class<T> key, T value ) {  
  2.   values.put( key, key.cast( value ) );  
  3. }  


第二个局限在于它不能用在不可具体化（non-reifiable ）的类型中

 

换句话说，你可以保存Runnable 或Runnable[]，但是不能保存List<Runnable>。

这是因为List<Runnable>没有特定class对象，所有的参数化类型指的是相同的List.class 对象。因此，Bloch指出对于这种局限性没有满意的解决方案。

多条同类型容器条目

为了能够存储多条同类型容器条目，我们可以用自定义key改变Context 类。这种key必须提供我们类型安全所需的类型信息，以及区分不同的值对象（value objects）的标识。一个以String 实例为标识的、幼稚的key实现可能是这样的：

 

[java] view plain copy
 
  1. public class Key<T> {  
  2.    
  3.   final String identifier;  
  4.   final Class<T> type;  
  5.    
  6.   public Key( String identifier, Class<T> type ) {  
  7.     this.identifier = identifier;  
  8.     this.type = type;  
  9.   }  
  10. }  

我们再次使用参数化的Class作为类型信息的钩子，调整后的Context将使用参数化的Key而不是Class。

 

 

[java] view plain copy
 
  1. public class Context {  
  2.    
  3.   private final Map<Key<?>, Object> values = new HashMap<>();  
  4.    
  5.   public <T> void put( Key<T> key, T value ) {  
  6.     values.put( key, value );  
  7.   }  
  8.    
  9.   public <T> T get( Key<T> key ) {  
  10.     return key.type.cast( values.get( key ) );  
  11.   }  
  12.    
  13.   [...]  
  14. }  


客户端将这样使用这个版本的Context：

 

 

[java] view plain copy
 
  1. Context context = new Context();  
  2.    
  3. Runnable runnable1 = ...  
  4. Key<Runnable> key1 = new Key<>( "id1", Runnable.class );  
  5. context.put( key1, runnable1 );  
  6.    
  7. Runnable runnable2 = ...  
  8. Key<Runnable> key2 = new Key<>( "id2", Runnable.class );  
  9. context.put( key2, runnable2 );  
  10.    
  11. // several computation cycles later...  
  12. Runnable actual = context.get( key1 );  
  13.    
  14. assertThat( actual ).isSameAs( runnable1 );  

虽然这个代码片段可用，但仍有缺陷。在Context#get中，Key被用作查询参数。用相同的identifier和class初始化两个不同的Key的实例，一个用于put，另一个用于get，最后get操作将返回null 。这不是我们想要的……

[java] view plain copy
 
  1. Context context = new Context();  
  2.    
  3. Runnable runnable1 = ...  
  4. Key<Runnable> key1 = new Key<>( "same-id", Runnable.class );  
  5. Key<Runnable> key2 = new Key<>( "same-id", Runnable.class );  
  6. context.put( key1, runnable1 );//一个用于put  
  7.    
  8. context.get(key2); //另一个用于get --> return null;  


幸运的是，为Key设计合适的equals 和hashCode 可以轻松解决这个问题，进而使HashMap 查找按预期工作。最后，你可以为创建key提供一个工厂方法以简化其创建过程（与static import一起使用时有用）：

[java] view plain copy
 
  1. public static  Key key( String identifier, Class type ) {  
  2.   return new Key( identifier, type );  
  3. }  



Java 类型安全的异构容器


联系
我们