为对象创建私用成员是任何面向对象语言中最基本和有用的特性之一。通过将一个方法或属性声明为私用的，可以让对象的实现细节对其他对象保密以降低对象之间的耦合程度，可以保持数据的完整性并对其修改方式加以约束。在代码有许多人参与设计的情况下，这也可以使代码更可靠、更易于调试。简而言之，封装是面向对象的设计的基石。
尽管JavaScript是一种面向对象的语言，它并不具备用以将成员声明为公用或私用的任何内置机制。目前有几种办法可以用来创建具有公用、私用和特权方法的对象，它们各有优缺点。

3.1 信息隐藏原则

3.1.1 封装与信息隐藏

可以把封装和信息隐藏视为同一个概念的两种表述。信息隐藏是目的，封装是达到这个目的的技术。
封装可以被定义为对对象的内部数据表现形式和实现细节进行隐藏。要想访问封装过的对象中的数据，只有使用已定义的操作这一种办法。通过封装可以强制实施信息隐藏。许多面向对象语言都使用关键字来说明某些方法和属性应被隐藏。但在JavaScript中没有这样的关键字，我们将使用闭包的概念来创建只允许从对象内部访问的方法和属性。这比使用关键字的办法更复杂。

3.1.2 接口扮演的角色

在向其他对象隐藏信息的过程中接口是如何发挥作用的呢？
接口提供了一份记载着可供公众访问的方法的契约。它定义了两个对象间可以具有的关系。只要接口不变，这个关系的双方都是可替换的。大多数情况下，你将发现对可以使用的方法加以记载会很有好处。不是有了接口就万事大吉，你应该避免公开未定义于接口中的方法。否则其他对象可能会对那些并不属于接口的方法产生依赖，这是不安全的。因为这些方法随时都可能发生改变或被删除，从而导致整个系统失灵。
一个理想的软件系统应该为所有类定义接口。这些类只向外界提供它们实现的接口中规定的方法，任何别的方法都留作自用。其所有属性都是私有的，外界只能通过接口中定义的存取操作与之打交道。但实际的系统很少能真正达到这样的境界。优质的代码应尽量向这个目标靠拢，但又不能过于刻板，把那些并不需要这些特性的简单项目复杂化。

3.2 创建对象的基本模式

JavaScript创建对象的基本模式有3种

1. 门户大开型，这是最简单的一种，但它只能提供公用成员。
2. 使用下划线表示私用方法或属性。
3. 使用闭包来创建真正的私用成员，这些成员只能通过一些特权方法访问。

以Book为例，该类满足这样的需求：存储关于一本书的数据，并实现一个以HTML形式显示这些数据的方法。
你只负责创建这个Book类，别人会创建并使用其实例。它会被这样使用：

// Book (isbn, title, author)
var theHobbit = new Book('0-395-07122-4', 'The Hobbit', 'J. R. R. Tolkien');
theHobbit.display();//通过创建HTML element显示数据

3.2.1 门户大开型对象

用一个函数来做其构造器，它的所有属性和方法都是公开的、可访问的。这些公用属性需要使用this关键字来创建。

var Book = function(isbn, title, author) {
	if(isbn == undefined) throw new Error('Book constructor requires an isbn.');
	this.isbn = isbn;
	this.title = title || 'No title specified';
	this.author = author || 'No author specified';
};
Book.prototype.display = function () {
	...
}

好像提供了ISBN就可以查到书籍了，可是这里有一个最大的问题，你无法检验ISBN数据的完整性，而不完整的ISBN数据有可能导致display方法失灵。如果Book对象在创建的时候没有什么问题，那么在display时也能正常工作才对，但是由于没有进行完整性检查，就不一定了。下面的版本强化了对ISBN的检查。

var Book = function(isbn, title, author) {
	if(!this.checkIsbn(isbn)) throw new Error('Book: Invalid ISBN.');
	this.isbn = isbn;
	this.title = title || 'No title specified';
	this.author = author || 'No author specified';
}
Book.prototype = {
	checkIsbn: function(isbn) {
		if(isbn == undefined || typeof isbn != 'string'){
			return false;
		}
		isbn = isbn.replace(/-/,'');
		if(isbn.length != 10 && isbn.length !=13) {
			return false;
		}
		var sum = 0;
		if(isbn.length === 10) {//10位的ISBN
			if(!isbn.match(/^\d{9}/)) {
				return false;
			}
			for(var i = 0; i < 9; i++) {
				sum += isbn.charAt(i) * (10-i);
			}
			var checksum = sum % 11;
			if(checksum === 10) checksum = 'X';
			if(isbn.charAt(9) != checksum) {
				return false;
			}
		}
		else {//13位的ISBN
			if(!isbn.match(/^\d{12}/)) {
				return false;
			}
			for(var i = 0; i < 12; i++) {
				sum += isbn.charAt(i) * ((i % 2 === 0) ? 1 : 3);
			}
			var checksum = sum % 10;
			if(isbn.charAt(12) != checksum) {
				return false;
			}		
		}
		return true;
	},
	display: function() {
		...
	}
};

checkIsbn保证ISBN是一个具有正确的位数和校验和的字符串。这样在创建对象的时候可以对ISBN的有效性进行检查，这可以确保display方法能正常工作。

但问题又来了，即使在构造的时候能对ISBN进行检验，如果后续其他程序员把其他值赋给isbn，这时就检验不了了，

theHobbit.isbn = '978-0261103283';
theHobbit.display();

为了保护内部数据，为每一个属性都提供了取值器和赋值器方法。

• 取值器方法用于获取属性值，通常以getAttributeName这种形式命名；
• 赋值器方法用于设置属性值，通常以setAttributeName这种形式命名。

通过使用赋值器，你可以在把一个新值真正赋给属性之前进行各种检验。

var Publication = new Interface('Publication', ['getIsbn', 'setIsbn', 'getTitle', 'setTitle', 'getAuthor', 'setAuthor', 'display']);

var Book = function(isbn, title, author) {
	this.setIsbn(isbn);
	this.setTitle(title);
	this.setAuthor(author);
}

Book.prototype = {
	checkIsbn: function(isbn) {
		...
	},
	getIsbn: function() {
		return this.isbn;
	},
	setIsbn: function(isbn) {
		if(!this.checkIsbn()) throw new Error('Book: Invalid ISBN.');
		this.isbn = isbn;
	},
	getTitle: function() {
		return this.title;
	},
	setTitle: function(title) {
		this.title = title || 'No title specified.';
	},
	getAuthor: function() {
		return this.author;
	},
	setAuthor: function(author) {
		this.author = author || 'No author specified.';
	},
	display: function() {
		...
	}
};

这是使用门户大开型对象创建方式所能得到的最好结果。

这里明确定义了接口、一些对数据具有保护作用的取值器和赋值器方法，以及一些有效性检验方法。

这里还是有一个漏洞，虽然我们为设置属性提供了赋值器方法，但那些属性仍然是公开的，可以被直接设置的，而在这种方案中却无法阻止这种行为。

不过这种方法易于使用，创建这样的对象不要求你深入理解作用域或调用链的概念。由于所有方法和属性都是公开的，派生子类和进行单元测试也很容易。唯一的弊端在于无法保护内部数据，而且取值器和赋值器也引入了额外的代码。

3.2.2 用命名规范区别私用成员

从本质上来说，这种模式与门户大开型对象创建模式如出一辙，只不过在一些方法和属性的名称前加了下划线以示其私用性而已。这种方法可以解决上一种方法带来的问题：无法阻止其他程序员无意中绕过的所有检验步骤。

var Book = function(isbn, title, author) {
	this.setIsbn(isbn);
	this.setTitle(title);
	this.setAuthor(author);
}

Book.prototype = {
	checkIsbn: function(isbn) {
		...
	},
	getIsbn: function() {
		return this._isbn;
	},
	setIsbn: function(isbn) {
		if(!this.checkIsbn()) throw new Error('Book: Invalid ISBN.');
		this._isbn = isbn;
	},
	getTitle: function() {
		return this._title;
	},
	setTitle: function(title) {
		this._title = title || 'No title specified.';
	},
	getAuthor: function() {
		return this._author;
	},
	setAuthor: function(author) {
		this._author = author || 'No author specified.';
	},
	display: function() {
		...
	}
};

这种命名规范也可以应用于方法，例如checkIson方法应该是类私有的方法：

	_checkIsbn: function(isbn) {
		...
	},

下划线的这种用法是一个众所周知的命名规范，它表明一个属性或方法仅供对象内部使用，直接访问它或设置它可能会导致意想不到的后果。这有助于防止程序员对它的无意使用，却不能防止对它的有意使用。

这并不是真正可以用来隐藏对象内部数据的解决方法，它主要适用于非敏感性的内部方法和属性。

3.2.3 作用域、嵌套函数和闭包

在讨论真正的私用性方法和属性的实现技术之前，我们先花点时间解释一下这种技术背后的原理。
在JavaScript中，只有函数具有作用域。也就是说，在一个函数内部声明的变量在函数外部无法访问。私用属性就其本质而言就是希望在对象外部无法访问的变量，所以为实现这种拒访性而求助于作用域这个概念是合乎情理的。

定义在一个函数中的变量在该函数的内嵌函数中是可以访问的：

function foo() {
	var a = 10;
	function bar() {
		a *= 2;
	}
	bar();
	return a;
}
foo();//20

一个简单的闭包例子：

function foo() {
	var a = 10;
	function bar() {
		a *= 2;
		return a;
	}
	return bar;
}
var baz = foo();
baz(); // 20
baz(); // 40
baz(); // 80

可以看到，函数是在foo外部被调用，但它依然能够访问a，这是因为JavaScript中的作用域是词法性的。函数是运行在定义它们的作用域中，而不是运行在调用它们的作用域中。所以，bar被定义在foo的作用域中，就能访问foo中定义的变量，即使foo的执行已经结束。

3.2.4 用闭包实现私用成员

var Book = function (newIsbn, newTitle, newAuthor) {
	// Private attributes.
	var isbn, title, author;

	// Private method.
	function checkIsbn(isbn) {
		...
	}

	// Privileged methods.
	this.getIsbn = function () {
		return isbn;
	};
	this.setIsbn = function (newIsbn) {
		if(!checkIsbn(newIsbn)) throw new Error('Book: Invalid ISBN.');
		isbn = newIsbn;
	};

	this.getTitle = function () {
		return title;
	};
	this.setTitle = function (newTitle) {
		title = newTitle || 'No title specified';
	};

	this.getAuthor = function () {
		return author;
	};
	this.setAuthor = function (newAuthor) {
		author = newAuthor || 'No author specified';
	};

	// Constructor code.
	this.setIsbn(newIsbn);
	this.setTitle(newTitle);
	this.setAuthor(newAuthor);
};

// Public, non-privileged methods.
Book.prototype = {
	display: function() {
		...
	}
}

代码解读：

• 使用var声明的变量或方法是私有的，因为没有用this关键字，这意味着它们只存在于Book构造器中
• 要访问这些私有的变量和方法，需在Book中使用this关键字声明方法，这些方法被称为特权方法(privileged method)，它们是公用的方法，因为声明在Book内部，所以在对象外部可以访问到私用属性和方法。
• 任何不需要直接访问私用属性的方法都可以在Book.prototype中声明。
• 每生成一个新的对象实例都将为每一个私用方法和特权方法生成一个新的副本。这会比其他做法更耗内存。
• 不利于派生子类，因为所派生出的子类不能访问超类的任何私用属性或方法。相比之下，在大多数语言中，子类都能访问超类的所有私用属性和方法。故在JavaScript中用闭包实现私用成员导致的派生问题被称为“继承破坏封装”

3.3 更多高级对象创建模式

前面学习了创建对象的3种基本模式，下面再对一些高级一点的模式做一个简介。

3.3.1 静态方法和属性

静态成员是在类的层次上操作的，而不是在实例的层次上操作。每个静态成员都只有一份。
下面是添加了静态属性和方法的Book类：

var Book = (function() {
	// Private static attributes.
	var numOfBooks = 0;

	// Private static method.
	function checkIsbn(isbn) {
		...
	}

	// Return the constructor.
	return function (newIsbn, newTitle, newAuthor) {
		// Private attributes.
		var isbn, title, author;
	
		// Private method.
		function checkIsbn(isbn) {
			...
		}
	
		// Privileged methods.
		this.getIsbn = function () {
			return isbn;
		};
		this.setIsbn = function (newIsbn) {
			if(!checkIsbn(newIsbn)) throw new Error('Book: Invalid ISBN.');
			isbn = newIsbn;
		};
	
		this.getTitle = function () {
			return title;
		};
		this.setTitle = function (newTitle) {
			title = newTitle || 'No title specified';
		};
	
		this.getAuthor = function () {
			return author;
		};
		this.setAuthor = function (newAuthor) {
			author = newAuthor || 'No author specified';
		};
	
		// Constructor code.
		numOfBooks++;
		if(numOfBooks > 50) throw new Error('Book: Only 50 instances of Book can be created.');
		this.setIsbn(newIsbn);
		this.setTitle(newTitle);
		this.setAuthor(newAuthor);	
	}
})();

// 创建Public static method.
Book.convertToTitleCase = function(inputString) {
	...
};

// Public, non-privileged methods.
Book.prototype = {
	display: function() {
		...
	}
}

这里创建了一个闭包，将构造器从原来的普通函数变成了一个内嵌函数，并且作为返回值赋给变量Book。外层的函数只是用于创建一个可以用来存放静态私用成员的闭包，这些静态私用成员不会为Book的每一个实例都创建一个新的副本。
如何判断一个私用方法是否应该被设计为静态方法？
看它是否需要访问任何实例数据。如果它不需要，则设计为静态方法会更有效率，因为它只会被创建一份。

3.3.2 常量

常量是一些不能被修改的变量。在JavaScript中，可以通过创建只有取值器而没有赋值器的私有变量来模仿常量。

var Class = (function() {
	// Constants (created as private static attributes.).
	var UPPER_BOUND	= 100;
	// Constructor.
	var ctor = function (constructorArgument) {
		...
	};
	// Privileged static method.
	ctor.getUPPER_BOUND = function() {
		return UPPER_BOUND;
	};
	...
	// Return the constructor
	return ctor;
})();

如果需要使用许多常量，但你不想为每个常量都创建一个取值器方法，那么可以创建一个通用的取值器方法，如下：

var Class = (function() {
	// Constants (created as private static attributes.).
	var constants ={
		UPPER_BOUND: 100,
		LOWER_BOUND: -100
	};
	// Constructor.
	var ctor = function (constructorArgument) {
		...
	};
	// Privileged static method.
	ctor.getConstant = function(name) {
		return constants[name];
	};
	...
	// Return the constructor
	return ctor;
})();
Class.getConstant('UPPER_BOUND');

3.3.3 单体和对象工厂

单体模式和工厂模式也使用闭包来创建受保护的变量空间，后面部分会详细讨论这两种模式。在此简单介绍一下：

• 单体模式使用一个由外层函数返回的对象字面量来公开特权成员，而私用成员则被保护性地封装在外层函数的作用域中。它使用的技术是：外层函数在定义之后立即执行，其结果被赋给一个变量。本章的例子中外层函数返回的都是一个函数，而单体模式返回的则是一个对象字面量。
• 对象工厂也可以使用闭包来创建具有私用成员的对象。其最简形式就是一个类构造。

3.4 封装之利

要是在创建对象时不用操心闭包和特权方法，事情就会简单得多。那么，不厌其烦的隐藏实现细节究竟有什么好处？
封装保护了内部数据的完整性。通过将数据的访问途径设置为取值器和赋值器这两个方法，可以获得对取值和赋值的完全控制。这可以减少其他函数所需的错误检查代码的数量，并确保数据不会处于无效状态。
封装提高了对象的可重用性，使其在必要的时候可以被替换。使用私用变量也有助于避免命名空间冲突。
封装还使你可以大幅改动对象的内部细节，而不会影响到其他部分的代码。总的来说，代码的修改变得更轻松，如果对象的内部数据都是公开的话，你不可能完全清楚代码的修改会带来什么结果。

3.5 封装之弊

私用方法很难进行单元测试。因为他们及其内部变量都是私用的，在对象外部无法访问到它们。要么通过使用公用方法来提供访问途径（这样一来就葬送了使用私用方法所带来的大多数好处），要么设法在对象内部定义并执行所有测试单元。最好的解决办法是只对公用方法进行单元测试。这是一种广为接受的处理方式。
使用封装意味着不得不与复杂的作用域链打交道，而这会使错误调试变得更加困难。有时候会很难区分来自不同作用域的大批同名变量。这个问题不是经过封装的对象所特有的，但实现私用方法和属性所需的闭包会让它变得更复杂。
过度封装也是一个潜在的问题。
最大的问题在于JavaScript中实现封装的困难。JavaScript本来就是一门与多数面向对象语言大相径庭的语言，而封装技术设计的调用链和定义后立即执行的匿名函数等概念更是加大了学习难度。此外，封装技术的应用还使不熟悉特定模式的人难以理解既有代码。注释和程序文档可以提供一些帮助，但并不能完全解决这个问题。

3.6 小结

本章讨论了信息隐藏的概念以及如何用封装这种手段来实现它。因为JavaScript没有对封装提供内置的支持，所以其实现必须依赖于一些其他技术。本书后面的多数章节都依赖于这些基本技术，因此你得好好品味一下本节的内容。只要理解了JavaScript中作用域的特点，你就能模仿出各种面向对象的技术。

一、有关概念

当前，较为常见的信息安全问题主要表现为：计算机病毒泛滥、恶意软件的入侵、黑客攻击、利用计算机犯罪、网络有害信息泛滥、个人隐私泄露。钓鱼网站、电信诈骗、社交软件诈骗等犯罪活动，已经成为直接骗取民众钱财的常见形式；网上有害信息泛滥，个人隐私泄露严重，严重危害网民的身心健康，危害社会的安定团结。

1.信息安全概念
信息安全强调信息（数据）本身的安全属性，主要包括一下内容。

• 秘密性（Confiidentiality）：信息不被未授权者知晓的属性。
• 完整性（Integrity）：信息时正确的、真实的、未被篡改的、完整无缺的属性。
• 可用性（Availability）：信息可以随时正常使用的属性。

信息必须依赖其存储、传输、处理及应用的载体（媒介）而存在，因此针对信息系统，安全可以划分为以下四个层次：设备安全、数据安全、内容安全、行为安全。其中数据安全即是传统的信息安全。

1）设备安全
信息系统设备的安全是信息系统安全的首要问题，这里主要包括三个方面：

• 设备的稳定性：设备在一定时间内不出故障的概率。
• 设备的可靠性：设备能在一定时间内正常执行任务的概率。
• 设备的可用性：设备随时可以正常使用的概率。

信息系统的设备安全是信息系统安全的物质基础。除了硬件设备外，软件系统也是一种设备，也要确保软件设备的安全。

2）数据安全
其安全属性包括秘密性、完整性和可用性。
很多情况下，即使信息系统设备没有收到破坏，但其数据安全也可能已经收到危害，如数据泄露、数据篡改等。由于危害数据安全的行为具有较高的隐蔽性，数据应用用户往往并不知情，因此，危害性很高。

3）内容安全
内容安全是信息安全在政治、法律、道德层次上的要求。

• 信息内容在政治上是健康的。
• 信息内容符合国家的法律法规。
• 信息内容符合中华民族优良的道德规范。

除此之外，广义的内容安全还包括信息内容保密、知识产权保护、信息隐藏和隐私等诸多方面。
如果数据中充斥着不健康的、违法的、违背道德的内容，即使它是保密的、未被篡改的，也不能说是安全的。因为这会危害国家安全、危害社会稳定、危害精神文明。因此，必须在确保信息系统设备安全和数据安全的基础上，进一步确保信息内容的安全。

4）行为安全
数据安全本质上是一种静态的安全，而行为安全是一种动态安全。

• 行为的秘密性：行为的过程和结果不能危害数据的秘密性。必要时，行为的过程和结果也应是秘密的。
• 行为的完整性：行为的过程和结果不能危害数据的完整性，行为的过程和结果是预期的。
• 行为的可控性：当行为的过程出现偏离预期时，能够发现、控制和纠正。

行为安全强调的是过程安全，体现在组成信息系统的硬件设备、软件设备和应用系统协调工作的程序（执行序列）符合系统设计的预期，这样才能保证信息系统的“安全可控”。

2.信息安全技术

保障信息安全的技术包括：硬件系统安全技术、操作系统安全技术、数据库安全技术、软件安全技术、网络安全技术、密码技术、而已软件防治技术、信息隐藏技术、信息设备可靠性技术等。其中，硬件系统安全和操作系统安全是信息系统安全的基础，密码和网络安全等是关键技术。网络安全技术主要包括防火墙、VPN、IDS、防病毒、身份认证、数据加密、安全审计、网络隔离等。

3.信息安全法律法规

确保信息安全是复杂的系统工程，仅仅靠技术措施是不够的的，还应有健全的法律体系，完善的信息系统安全管理制度，另外对信息行业的从业人员的职业道德要求及培训也是非常重要的，信息系统用户也要有很强的信息安全意识。

我国信息安全的法律体系可分为四个层面：
（1）一般性法律法规。
（2）规范和惩罚信息网络犯罪的法律。
（3）直接针对信息安全的特别规定。
（4）具体规范信息安全技术、信息安全管理等方面的规定。

国务院于1994年2月18日颁布《中华人民共和国计算机信息系统安全保护条例》，这是一个标志性、基础性的法规。

4.信息安全等级保护

信息系统的安全保护等级应当根据信息系统在国家安全、、经济建设、社会生活中的重要程度，信息系统遭到破坏后对国家安全、社会秩序、公共利益以及公民、法人和其他组织的合法权益的危害程度等因素确定。

《信息安全等级保护管理办法》将信息系统的安全保护等级分为以下五级：（或者关系）

	公民、法人和其他组织	公共利益	社会秩序	国家安全
第一级	造成损害	不损害	不损害	不损害	用户自主保护级
第二级	严重损害	造成损害	造成损害	不损害	系统审计保护级
第三级		严重损害	严重损害	造成损害	安全标记保护级
第四级		严重损害	严重损害	严重损害	结构化保护级
第五级				严重损害	访问验证保护级

GB 17859-1999标准规定了计算机系统安全保护能力的五个等级，即：用户自主保护级、系统审计保护级、安全标记保护级、结构化保护级、访问验证保护级。 计算机信息系统安全保护能力随着安全保护等级的增高，逐渐增强。

二、信息加密、解密与常用算法

1.信息加密概念

为了保证信息的安全性（即秘密性、完整性和可用性）需要采用信息加密技术对信息进行伪装，使得信息非法窃取者无法理解信息的真实含义；需要采用加密算法提取信息的特征码（校验码）或特征矢量，并与有关信息封装在一起，信息的合法拥有者可以利用特征码对信息的完整性进行校验；需要采用加密算法对信息使用者的身份进行认证、识别和确认，以对信息的使用进行控制。

2.对称加密技术

对称加密采用了对称密码编码技术，它的特点是文件加密和解密使用相同的密钥，即加密密钥也可以用作解密密钥，这种方法在密码学中叫做对称加密算法，对称加密算法使用起来简单快捷，密钥较短，且破译困难。

3.非对称加密技术

公开密钥密码的基本思想是将传统密码的密钥K一分为二，分为加密钥Ke和解密钥Kd，用加密钥Ke控制加密，用解密钥Kd控制解密，而且由计算负责性确保由加密钥Ke在计算上不能推出解密钥Kd。这样，即使是将Ke公开也不会暴露Kd，也不会损害密码的安全。于是便可将Ke公开，而只对Kd保密。由于Ke是公开的，只有Kd是保密的，所以变从根本上克服了传统密码在密钥分配上的困难。

4.Hash函数的概念
Hash函数将任意长的报文M映射为定长Hash码h。Hash函数的目的就是要产生文件、报文或其他数据块的“指纹”——Hash码。Hash码也称为报文摘要，它是所有报文位的函数。它具有错误检测能力，即改变报文的任何一位或多位，都会导致Hash码的改变。在实现认证过程中发送方将Hash码附于要发送的报文之后发送给接收方，接收方通过重新计算Hash码来认证报文。Hash函数可提供可保密性、报文认证以及数字签名功能。

5.数字签名的概念
签名是证明当事者的身份和数据真实性的一种信息。在以信息化环境下，以网络为信息传输基础的事物处理中，事物处理各方应采用电子形式的签名，即数字签名。目前，数字签名已得到一些国家的法律支持。完善的数字签名体系应满足以下三个条件：
（1）签名者时候不能抵赖自己的签名。
（2）任何其他人必能伪造签名。
（3）如果当时的双方关于签名的真伪发生争执，能够在公正的仲裁者面前通过验证签名来确认其真伪。
利用RSA密码可以同时实现数字签名和数据加密。

6.认证的概念

认证又称鉴别、确认，它是正式某事是否名副其实或是否有效的一个过程。
认证和加密的区别在于：加密用以确保数据的保密性，阻止对手的被动攻击，如载取、窃听等；而认证用以确保报文发送者和接受者的真实性以及 报文的完整性，阻止对手的主动攻击，如冒充、篡改、重播等。认证往往是许多应用系统中安全保护的第一道设防，因而极为重要。

pImpl编译器封装技术 C++

---

一.pimpl总结

pImpl(Pointer to implementation)实质上就是一个可以替代完成Line功能的指针，当程序员看到Line.h整个函数的时候，在调用Line(int,int,int,int),printLine()这样的成员函数的过程中，实际上都是用_pimpl来替代完成的。

pImpl设计的好处：
1.信息隐蔽性：
只能通过Line函数来了解到Line函数的用法，但是内部实现被隐藏，利用pimpl来替代完成，程序员只看到API,却看不到内部实现；
2.编译依赖减小，降低了耦合性：
当想要对函数实现进行修改的时候，不用修改头文件，直接修改pimpl的实现文件，这样减小了编译依赖，同时在对函数功能进行修改的过程也变简单了。

二.代码

Line.h:

#ifndef _WD_LINE_H_
#define _WD_LINE_H_
#include <iostream>
using std::cout;
using std::endl;

namespace wd{

class Line{
public:
    Line(int,int,int,int);
    ~Line();
    void printLine()const;

private:
    class LinepImpl;   
    LinepImpl *_pimpl;
};


}//end of namespace wd

#endif

Line.cpp:

#include "Line.h"
using namespace wd;

class Line::LinepImpl{
public:
    class Point{
    public:
        Point(int x, int y)
        :_x(x), _y(y)
        {
            cout << "Point(int,int)" << endl;
        }
        ~Point(){
            cout << "~Point()" << endl;
        }
        void print()const{
            cout << "(" << _x << "," << _y << ")";
        }

    private:
        int _x;
        int _y;
    };

    LinepImpl(int x1, int y1, int x2, int y2)
    :_p1(new Point(x1,y1))
    ,_p2(new Point(x2,y2))
    {
        cout << "LinepImpl(int,int,int,int)" << endl;
    }

    ~LinepImpl(){
        delete _p1;
        delete _p2;
        cout << "~LinepImpl()" << endl;
    }

    void printLine()const{
        _p1->print();
        cout << "-->";
        _p2->print();
        cout << endl;
    }

private:
    Point *_p1;
    Point *_p2;
};



Line::Line(int x1, int y1, int x2, int y2)
:_pimpl(new LinepImpl(x1, y1, x2, y2))
{
    cout << "Line(int,int,int,int)" << endl;
}

Line::~Line(){
    if(_pimpl){
        delete _pimpl;
        _pimpl = NULL;
    }
}

void Line::printLine()const{
    _pimpl->printLine();
}