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

一般来说，开发人员偶尔会遇到这样的情形： 在一个特定容器中映射任意类型的值。然而Java 集合API只提供了参数化的容器。这限制了类型安全地使用HashMap，如单一的值类型。但如果想混合苹果和梨，该怎样做呢？

考虑一个例子，你需要提供某种应用程序的上下文，它可以将特定的键绑定到任意类型的值。利用String作为键的HashMap，一个简单的、非类型安全（type safe）的实现可能是这样的：

public class Context {
 private final Map<String,Object> values = new HashMap<>();
 public void put( String key, Object value ) {values.put( key, value );}
 public Object get( String key ) {return values.get( key );}
} 

接下来的代码片段展示了怎样在程序中使用Context ：

Context context = new Context();
Runnable runnable = ...
context.put( "key", runnable );
 
// several computation cycles later...
Runnable value = ( Runnable )context.get( "key" ); 

可以看出，这种方法的缺点是在第6行需要进行向下转型（down cast）。如果替换键值对中值的类型，显然会抛出一个ClassCastException异常:

Context context = new Context();
Runnable runnable = ...
context.put( "key", runnable );
 
// several computation cycles later...
Executor executor = ...
context.put( "key", executor );
 
// even more computation cycles later...
Runnable value = ( Runnable )context.get( "key" ); // runtime problem 

产生这种问题的原因是很难被跟踪到的，因为相关的实现步骤可能已经广泛分布在你的程序各个部分中。

为了改善这种情况，貌似将value和它的key、它的value都进行绑定是合理的。

public class Context {
 private final <String, Object> values = new HashMap<>();
 public <T> void put( String key, T value, Class<T> valueType ) {values.put( key, value );}
 public <T> T get( String key, Class<T> valueType ) {return ( T )values.get( key );}
} 

同样的基本用法可能是这样的：

Context context = new Context();
Runnable runnable = ...
context.put( "key", runnable, Runnable.class );
 
// several computation cycles later...
Runnable value = context.get( "key", Runnable.class ); 

乍一看，这段代码可能会给你更类型安全的错觉，因为其在第6行避免了向下转型（down cast）。但是运行下面的代码将使我们重返现实，因为我们仍将在最后一行赋值语句处跌入ClassCastException 的怀抱：

Context context = new Context();
Runnable runnable = ...
context.put( "key", runnable, Runnable.class );
 
// several computation cycles later...
Executor executor = ...
context.put( "key", executor, Executor.class );
 
// even more computation cycles later...
Runnable value = context.get( "key", Runnable.class ); 

哪里出问题了呢？首先，Context.get中的向下转型是无效的，因为类型擦除会使用静态转型的Object来代替无界参数（unbonded parameters）。此外更重要的是，这个实现根本就没有用到由Context.put提供的类型信息。这充其量是多此一举的美容罢了。静态转型

Object obj; // may be an integer
if (obj instanceof Integer) {Integer objAsInt = (Integer) obj;// do something with 'objAsInt'
} 

这里使用了 instanceof 和转型操作符，这些操作符已经融入到语言当中了。对象转换的类型（这个例子中是Integer）必须是在编译期静态确定的，所以我们将这种转型称为静态转型。

类型安全的异构容器

虽然上面Context 的变种不起作用，但却指明了方向。接下来的问题是：怎样合理地参数化这个key？ 为了回答这个问题，让我们先看看一个根据Bloch所描述的类型安全异构容器模式（typesafe heterogenous container pattern）的简装实现吧。

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

public class Context {
 private final Map<Class<?>, Object> values = new HashMap<>();
 public <T> void put( Class<T> key, T value ) {values.put( key, value );}
 public <T> T get( Class<T> key ) {return key.cast( values.get( key ) );}
} 

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

Context context = new Context();
Runnable runnable ...
context.put( Runnable.class, runnable );
 
// several computation cycles later...Executor executor = ...
context.put( Executor.class, executor );
 
// even more computation cycles later...
Runnable value = context.get( Runnable.class ); 

这次客户端的代码将可以正常工作，不再有类转换的问题，因为不可能通过一个不同的值类型来交换某个键值对。Bloch指出这种模式有两个局限性。“首先，恶意的客户端可以通过以原生态形式（raw form）使用class对象轻松地破坏类型安全。”为了确保在运行时类型安全可以在Context#put中使用动态转换（dynamic cast）。

Paste_Image.png

public <T> void put( Class<T> key, T value ) {values.put( key, key.cast( value ) );
} 

第二个局限在于它不能用在不可具体化（non-reifiable ）的类型中（见《Effective Java》第25项）。换句话说，你可以保存Runnable 或Runnable[]，但是不能保存List<Runnable>。

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

但是，假如你需要存储两个具有相同值类型的条目该怎么办呢？如果仅为了存入类型安全的容器，可以考虑创建新的类型扩展，但这显然不是最好的设计。使用定制的Key也许是更好的方案。

多条同类型容器条目

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

public class Key<T> {
 final String identifier;final Class<T> type;
 public Key( String identifier, Class<T> type ) {this.identifier = identifier;this.type = type;}
} 

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

public class Context {
 private final Map<Key<?>, Object> values = new HashMap<>();
 public <T> void put( Key<T> key, T value ) {values.put( key, value );}
 public <T> T get( Key<T> key ) {return key.type.cast( values.get( key ) );}
} 

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

Context context = new Context();
 
Runnable runnable1 = ...
Key<Runnable> key1 = new Key<>( "id1", Runnable.class );
context.put( key1, runnable1 );
 
Runnable runnable2 = ...
Key<Runnable> key2 = new Key<>( "id2", Runnable.class );
context.put( key2, runnable2 );
 
// several computation cycles later...
Runnable actual = context.get( key1 );
 
assertThat( actual ).isSameAs( runnable1 ); 

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

//译者附代码片段
Context context = new Context();
 
Runnable runnable1 = ...
Key<Runnable> key1 = new Key<>( "same-id", Runnable.class );
Key<Runnable> key2 = new Key<>( "same-id", Runnable.class );
context.put( key1, runnable1 );//一个用于put
 
context.get(key2); //另一个用于get --> return null; 

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

public staticKey key( String identifier, Class type ) {return new Key( identifier, type );
} 

结论“集合API说明了泛型的一般用法，限制你每个容器只能有固定数目的类型参数。你可以通过将类型参数放在键上而不是容器上来避开这个限制。对于这种类型安全的 异构容器，可以用Class对应作为键。”（Joshua Bloch，《Effective Java》第29项）。

网络安全入门学习路线

其实入门网络安全要学的东西不算多，也就是网络基础+操作系统+中间件+数据库，四个流程下来就差不多了。

1.网络安全法和了解电脑基础

其中包括操作系统Windows基础和Linux基础，标记语言HTML基础和代码JS基础，以及网络基础、数据库基础和虚拟机使用等...

别被这些看上去很多的东西给吓到了，其实都是很简单的基础知识，同学们看完基本上都能掌握。计算机专业的同学都应该接触了解过，这部分可以直接略过。没学过的同学也不要慌，可以去B站搜索相关视频，你搜关键词网络安全工程师会出现很多相关的视频教程，我粗略的看了一下，排名第一的视频就讲的很详细。 当然你也可以看下面这个视频教程仅展示部分截图： 学到http和https抓包后能读懂它在说什么就行。

2.网络基础和编程语言

3.入手Web安全

web是对外开放的，自然成了的重点关照对象，有事没事就来入侵一波，你说不管能行吗！ 想学好Web安全，咱首先得先弄清web是怎么搭建的，知道它的构造才能精准打击。所以web前端和web后端的知识多少要了解点，然后再学点python，起码得看懂部分代码吧。

最后网站开发知识多少也要了解点，不过别紧张，只是学习基础知识。

等你用几周的时间学完这些，基本上算是具备了入门合格渗透工程师的资格，记得上述的重点要重点关注哦！ 再就是，要正式进入web安全领域，得学会web渗透，OWASP TOP 10等常见Web漏洞原理与利用方式需要掌握，像SQL注入/XSS跨站脚本攻击/Webshell木马编写/命令执行等。

这个过程并不枯燥，一边打怪刷级一边成长岂不美哉，每个攻击手段都能让你玩得不亦乐乎，而且总有更猥琐的方法等着你去实践。

学完web渗透还不算完，还得掌握相关系统层面漏洞，像ms17-010永恒之蓝等各种微软ms漏洞，所以要学习后渗透。可能到这里大家已经不知所云了，不过不要紧，等你学会了web渗透再来看会发现很简单。

其实学会了这几步，你就正式从新手小白晋升为入门学员了，真的不算难，你上你也行。

4.安全体系

不过我们这个水平也就算个渗透测试工程师，也就只能做个基础的安全服务，而这个领域还有很多业务，像攻防演练、等保测评、风险评估等，我们的能力根本不够看。

所以想要成为一名合格的网络工程师，想要拿到安全公司的offer，还得再掌握更多的网络安全知识，能力再更上一层楼才行。即便以后进入企业，也需要学习很多新知识，不充实自己的技能就会被淘汰。

从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。

尾言

因为入门学习阶段知识点比较杂，所以我讲得比较笼统，最后联合CSDN整理了一套【282G】网络安全从入门到精通资料包，需要的小伙伴可以点击链接领取哦！ 网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！