Java 类型安全的异构容器

转载自: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. private final Map<Class<?>, Object> values = new HashMap<>();
  3. public <T> void put( Class<T> key, T value ) {
  4. values.put( key, value );
  5. }
  6. public <T> T get( Class<T> key ) {
  7. return key.cast( values.get( key ) );
  8. }
  9. [...]
  10. }

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

[java] view plain copy

  1. Context context = new Context();
  2. Runnable runnable ...
  3. context.put( Runnable.class, runnable );
  4. // several computation cycles later...
  5. Executor executor = ...
  6. context.put( Executor.class, executor );
  7. // even more computation cycles later...
  8. 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. final String identifier;
  3. final Class<T> type;
  4. public Key( String identifier, Class<T> type ) {
  5. this.identifier = identifier;
  6. this.type = type;
  7. }
  8. }

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

[java] view plain copy

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

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

[java] view plain copy

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

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

[java] view plain copy

  1. Context context = new Context();
  2. Runnable runnable1 = ...
  3. Key<Runnable> key1 = new Key<>( "same-id", Runnable.class );
  4. Key<Runnable> key2 = new Key<>( "same-id", Runnable.class );
  5. context.put( key1, runnable1 );//一个用于put
  6. 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. }
时间: 2024-10-09 03:14:56

Java 类型安全的异构容器的相关文章

Item 29 优先考虑类型安全的异构容器

集合API展示了泛型的一般用法.但是它们(Set,HashMap,Map)限制了每个容器只能有固定数目的类型参数. 比如Set集合,HashMap集合: import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; public class NormalUse { public static void main(String[] args) { Set<String>

【Effective Java】8、优先考虑类型安全的异构容器

有的时候我们一个容器只有一个类型或几个类型并不能满足我们的要求,比如set中存放的元素类型都是同一种,map也就指定的两种 这里我们可以将键进行参数化,而不是将容器参数化,也就是我们可以给容器传一个键的类型,然后value用来放对应的实例,这样就可以存放多个不同的类型了 如: package cn.xf.cp.ch02.item29; import java.util.HashMap; import java.util.Map; public class ManyTypeClass { //一个

第29条:优先考虑类型安全的异构容器

一个Set只有一个类型参数,表示它的元素类型,一个Map有两个类型参数,表示它的键和值类型. 但是有时候,需要更多的灵活性,如,数据库行有任意多的列,希望能以类型安全的方式访问所有的列.办法是将键进行参数化而不是将容器参数化,然后将参数化的键提交给容器,来插入或者获取值.用泛型系统来确保值的类型与它的键相符. 例子: public class Favorites { private Map<Class<?>, Object> favorites = new HashMap<C

类型安全的异构容器

原文:http://gafter.blogspot.com/2006/12/super-type-tokens.html 1. 泛型通常用于集合,如Set和Map等.这样的用法也就限制了每个容器只能有固定数目的类型参数,一般来说,这也确实是我们想要的. 然而有的时候我们需要更多的灵活性,如数据库可以用任意多的Column,如果能以类型安全的方式访问所有Columns就好了,幸运的是 有一种方法可以很容易的做到这一点,就是将key进行参数化,而不是将容器参数化,见以下代码 1 public cla

浅析java设计模式(一)----异构容器,可以存储任何对象类型为其他类提供该对象

最近在着手重构一个java UI桌面项目,发现这个项目在一开始的时候由于需求不明确,以及开发人员对swing框架不熟悉等问题造成了页面代码混乱的情况:为了能够在各个类里都可以拿到其他类的引用去进行相应的页面响应操作,在每一个类的构造方法中都传入了主类的引用,在主类中提供了所有类的get()方法,这样的做法显得十分的臃肿,就像这样: 打开主页面后会显示窗体B,窗体B的按钮支持我们打开窗体A,窗体A按钮支持修改B中属性.我们只能通过在主页面的类中使用get(),set()方法来持有A和B的引用,在A

基于纯Java代码的Spring容器和Web容器零配置的思考和实现(3) - 使用配置

经过<基于纯Java代码的Spring容器和Web容器零配置的思考和实现(1) - 数据源与事务管理>和<基于纯Java代码的Spring容器和Web容器零配置的思考和实现(2) - 静态资源.视图和消息器>两篇博文的介绍,我们已经配置好了Spring所需的基本配置.在这边博文中,我们将介绍怎么使用这些配置到实际项目中,并将web.xml文件替换为一个Java类. 我们使用Java代码来配置Spring,目的就是使我们的这些配置能够复用,对于这些配置的复用,我们采用继承和引入来实现

深入浅出 Java Concurrency (17): 并发容器 part 2 ConcurrentMap (2)

本来想比较全面和深入的谈谈ConcurrentHashMap的,发现网上有很多对HashMap和ConcurrentHashMap分析的文章,因此本小节尽可能的分析其中的细节,少一点理论的东西,多谈谈内部设计的原理和思想. 要谈ConcurrentHashMap的构造,就不得不谈HashMap的构造,因此先从HashMap开始简单介绍. HashMap原理 我们从头开始设想.要将对象存放在一起,如何设计这个容器.目前只有两条路可以走,一种是采用分格技术,每一个对象存放于一个格子中,这样通过对格子

深入浅出 Java Concurrency (27): 并发容器 part 12 线程安全的List/Set[转]

本小节是<并发容器>的最后一部分,这一个小节描述的是针对List/Set接口的一个线程版本. 在<并发队列与Queue简介>中介绍了并发容器的一个概括,主要描述的是Queue的实现.其中特别提到一点LinkedList是List/Queue的实现,但是LinkedList确实非线程安全的.不管BlockingQueue还是ConcurrentMap的实现,我们发现都是针对链表的实现,当然尽可能的使用CAS或者Lock的特性,同时都有通过锁部分容器来提供并发的特性.而对于List或者

深入浅出 Java Concurrency (17): 并发容器 part 2 ConcurrentMap (2)[转]

本来想比较全面和深入的谈谈ConcurrentHashMap的,发现网上有很多对HashMap和ConcurrentHashMap分析的文章,因此本小节尽可能的分析其中的细节,少一点理论的东西,多谈谈内部设计的原理和思想. 要谈ConcurrentHashMap的构造,就不得不谈HashMap的构造,因此先从HashMap开始简单介绍. HashMap原理 我们从头开始设想.要将对象存放在一起,如何设计这个容器.目前只有两条路可以走,一种是采用分格技术,每一个对象存放于一个格子中,这样通过对格子