Google C++ Mocking Cookbook
Version: 0.32
作者：Adrian Alexander
译者：Koala++ / 屈伟
你来对地方了，这里你可以找到Google Mock的使用方法，但如果你还没有读过启蒙篇，建议你还是先去读一下吧，了解些基本知识。
注意，Google Mock定义在testing命名空间中。你可以用using ::testing::Foo 来让代码有更好的可读性。在本文中为了简洁起见，并不采用这种写法，但是在你自己的代码中应该用using。
Create Mock Classes
Mocking Private or Protected Methods
你必须将Mock函数定义( MOCK_METHOD* )放到Mock类的public:部分中，无论被Mock的函数在基类中是public，protected，还是private。这样做是为了让ON_CALL 和EXPECT_CALL可以从Mock类外引用Mock函数。( 是的，C++允许子类改变一个基类虚函数的访问权限)。比如：
class Foo {
public:
...
virtual bool Transform(Gadget* g) = 0;
protected:
virtual void Resume();
private:
virtual int GetTimeOut();
};
class MockFoo : public Foo {
public:
...
MOCK_METHOD1(Transform, bool(Gadget* g));
// The following must be in the public section, even though the
// methods are protected or private in the base class.
MOCK_METHOD0(Resume, void());
MOCK_METHOD0(GetTimeOut, int());
};
Mocking Overloaded Methods
Mock重载函数的方法也是一样的，不需要使用别的方式：
class Foo {
...
// Must be virtual as we'll inherit from Foo.
virtual ~Foo();
// Overloaded on the types and/or numbers of arguments.
virtual int Add(Element x);
virtual int Add(int times, Element x);
// Overloaded on the const-ness of this object.
virtual Bar& GetBar();
virtual const Bar& GetBar() const;
};
class MockFoo : public Foo {
...
MOCK_METHOD1(Add, int(Element x));
MOCK_METHOD2(Add, int(int times, Element x);
MOCK_METHOD0(GetBar, Bar&());
MOCK_CONST_METHOD0(GetBar, const Bar&());
};
注意：如果你并不Mock所有的重载函数，编译器会警告你基类中的一些函数被隐藏了。修正的方法是用using将它们引入域中：
class MockFoo : public Foo {
...
using Foo::Add;
MOCK_METHOD1(Add, int(Element x));
// We don't want to mock int Add(int times, Element x);
...
};
Mocking Class Templates
Mock一个模板类，需要在MOCK_*宏后加上_T：
template
class StackInterface {
...
// Must be virtual as we'll inherit from StackInterface.
virtual ~StackInterface();
virtual int GetSize() const = 0;
virtual void Push(const Elem& x) = 0;
};
template
class MockStack : public StackInterface
...
MOCK_CONST_METHOD0_T(GetSize, int());
MOCK_METHOD1_T(Push, void(const Elem& x));
};
Mocking Non-virtual Methods
Google Mock可以Mock非虚函数用在hi-perf dependency injection中。
Mock非虚函数时并不与真实的类共享一个公共的基类，你的Mock类与真实类将毫无关系，但两者所定义的函数却是一致的。Mock非虚函数与Mock虚函数的语法是一致的：
// A simple packet stream class. None of its members is virtual. class ConcretePacketStream {
public:
void AppendPacket(Packet* new_packet);
const Packet* GetPacket(size_t packet_number) const;
size_t NumberOfPackets() const;
...
};
// A mock packet stream class. It inherits from no other, but defines // GetPacket() and NumberOfPackets().
class MockPacketStream {
public:
MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number)); MOCK_CONST_METHOD0(NumberOfPackets, size_t());
...
};
注意与真实类不同的是Mock类没有定义AppenPacket()，但只要测试中没有调用到这个函数，这种写法是没有问题的。
接下来，你需要想出一种在正式代码中使用ConcretePacketStream，在测试代码中使用MockPacketStream的方法。因为函数是非虚的，而两个类也是毫无关系的，所以你必须在编译时( 而不是运行时 )决定你使用的类。
其中一种方法是模板化需要用Packet Stream的代码。具体一点，你在代码中使用一个针对packet stream模板参数。在正式代码中，你可以用ConcretePacketStream来实例化，在测试中你用MockPacketStream来实例化。下面是一个例子：
template
void CreateConnection(PacketStream* stream) { ... }
template
class PacketReader {
public:
void ReadPackets(PacketStream* stream, size_t packet_num);
};
然后你可以在正式代码中使用CreateConnection
EXPECT_CALL(mock_stream, ...)...;
.. set more expectations on mock_stream ...
PacketReader
... exercise reader ...
Mocking Free Functions
可以使用Google Mock来Mock一个自由函数( 比如，普通C风格函数或是静态函数 )。但你需要一个接口( 抽象类 )重写你的代码。
Mock并不直接调用自由函数( 暂且称之为OpenFile )，而是为它引入一个接口，并需要针对这个接口实现对函数对自由函数的调用：
class FileInterface {
public:
...
virtual bool Open(const char* path, const char* mode) = 0;
};
class File : public FileInterface {
public:
...
virtual bool Open(const char* path, const char* mode) {
return OpenFile(path, mode);
}
};
你的代码可以通过FileInterface打开一个文件，现在函数更容易被Mock。
这看起来太麻烦了，但在现实中你通常可以将多个相关的函数放到一个接口中，所以为每个函数定义一个接口这种额外工作会少很多。
Nice Mocks and Strict Mocks
如果一个没有指定EXPECT_CALL的Mock函数被调用了，Google Mock会打印一个”uninteresting call”警告。这样做的合理性如下：
●当测试写完之后，可能有新的函数加入到接口中。而我们不能仅因为一个测试它不知道
某个函数要被调用就失败。
●但是，这种情况也可能意味着测试中有bug，所以Google Mock也不能什么都不提示。
如果用户认为这些调用是无关的，它可以加入一个EXPECT_CALL来消除警告。
但是，有时你可能想消除所有的”uninteresting call”警告，但有时你可能想做刚好相反的事，即认为所有的”uninteresting call”都是错误。Google Mock能让你在Mock 对象这个级别上选择你的决定。
TEST(...) {
MockFoo mock_foo;
EXPECT_CALL(mock_foo, DoThis());
... code that uses mock_foo ...
}
如果mock_foo中一个不是DoThis的函数被调用了，Google Mock会给出一个警告，但是你用NiceMock
TEST(...) {
NiceMock
EXPECT_CALL(mock_foo, DoThis());
... code that uses mock_foo ...
}
NiceMock是MockFoo的一个子类，所以它在任何接受MockFoo类型的地方使用。
在MockFoo的构造函数是有参数的时候也是可以用的，因为NiceMock
using ::testing::NiceMock;
TEST(...) {
NiceMock
EXPECT_CALL(mock_foo, DoThis());
... code that uses mock_foo ...
}
StickMock的用法也是相似的，只是它的目的是让所有“uninteresting call”失败：
using ::testing::StrictMock;
TEST(...) {
StrictMock
EXPECT_CALL(mock_foo, DoThis());
... code that uses mock_foo ...
// The test will fail if a method of mock_foo other than DoThis()
// is called.
}
下面还有一些说明( 我不太喜欢这些说明，但遗憾的是它们是C++限制的副作用 ): 1.NiceMock
MOCK_METHOD*定义的Mock函数。如果一个Mock函数在MockFoo的基类中定义，那么“nice”或是“strict”是否会影响它则取决于编译器。特别要指出的是，嵌套的NiceMock和StrickMock是不支持的( 比如，NiceMock
2.Mock基类( MockFoo )不能传递非常量引用给构造函数，因为这种做法被Google C++
编码规范禁止了。
3.在构造函数和析构函数运行中，Mock对象不是nice也不是strict。如果在这个对象
的构造函数或是析构函数中调用一个Mock函数，可能会因为这个原因造成意外。( 译注：Effective C++ Item 8)。
最后，你必须在使用这个特性时特别小心，因为你所做的这个决定会应用到Mock类未来所有的改动上。如果你所Mock的接口做了一个重要的改变，它会让你的测试( 如果你用StrictMock )失败或是在没有警告提示的情况下让bug溜过( 如果你使用NiceMock )。所以，应该显式地调用EXPECT_CALL来指定mock的行为，仅在最后将Mock对象换为NiceMock或是StrictMock的。
Simplifying the Interface without Breaking Existing Code
有时候一个函数有相当长的参数列表，那Mock的时候是相当无趣的，比如：
class LogSink {
public:
...
virtual void send(LogSeverity severity, const char* full_filename,
const char* base_filename, int line,
const struct tm* tm_time,
const char* message, size_t message_len) = 0;
};
这个函数的参数列表很长且难用( 这么说吧，message参数甚至都不是以’\0’结尾的 )。如果我们执意要Mock它，那结果必是不雅的。然而如果我们试着简化这个接口，又需要将所有使用这个接口的代码全部改了，这通常是不可行的。
技巧就是在Mock类中修改这个函数：
class ScopedMockLog : public LogSink {
public:
...
virtual void send(LogSeverity severity, const char* full_filename,
const char* base_filename, int line, const tm*
tm_time,
const char* message, size_t message_len) { // We are only interested in the log severity, full file name, and // log message.
Log(severity, full_filename, std::string(message, message_len)); }
// Implements the mock method:
//
// void Log(LogSeverity severity,
// const string& file_path,
// const string& message);
MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
const string& message));
};
通过定义一个新有较少参数的Mock函数，我们让Mock类更易用。Alternative to Mocking Concrete Classes
你经常会发现你正在用一些没有针对接口实现的类。你为了可以用这种类( 且称为Concrete类 )来测试自己的代码，你可能会试着将Concrete的函数变为虚函数，然后再去Mock它。
请不要这样做。
将非虚函数改为虚函数是一个重大决定。这样做之后，子类会改变父类的行为。这样就会更难保持类的不变性，而从降低了你对类的控制力。你只应在一个合理的理由下将非虚函数变为虚函数。
直接Mock具体的类会产生类和测试的高度耦合，任何对类的小的改动都会让你测试失效，这会让你陷入维护测试的痛苦中。
为了避免这种痛苦，许多程序员开始了“针对接口”的实践：并不直接调用Concrete 类，而是定义一个接口去调用Concrete类。然后你在Concrete类之上实现这个接口，即配接器。
这种技术可能会带来一些负担：
●你要为虚函数的调用买单( 通常不是问题 )
●程序员需要掌握更多的抽象
但是，它同时也能巨大的好处，当然也有更好的可测性：
●Concrete的API也许并不是很适合你的问题领域，因为你可能不是这个API唯一的调
用方。通过设计你自己的接口，你有一个将这个类修改成自己所需的类的机会，你可加入一些特定功能，重命名接口函数，等等，你可以做的不是只是减少几个自己不使用的API。这可以让你自己以更自然的方式实现你的代码，因为它有更好的可读性，更好的可维护性，你也会有更高的编程效率。
●如果Concrete的实现改变了，你不需要重写与改动相关的所有测试。相反你可以将改
动在你自己的接口中隐藏，使你的调用代码和测试与Concrete改动绝缘。
有些人会担心如果每个人都在实践这个技术，将会产生大量的重复代码。这个担心是可以理解的。但是，有两个理由可以证明这种情况可能不会发生。
●不同的工程可能会以不同的方式使用Concrete，所以最适合每个工程的接口是不同的。
所以每个工程都有在Concrete之上的自己的领域相关的接口，这些接口是各不相同的。
●如果有很多的工程用相同的接口，它们可以共用一个接口，就像它们共用Concrete一
样。你可以在Concrete类的旁边提交接口和配接器的代码( 也许是在一个contrib 子目录中 )并让许多工程使用它。
你需要仔细衡量针对你特定问题这种做法的优缺点，但我可以向你保证的是：Java世界的人已经实践这种方法很久了，并且它已经被证明在很广泛的领域中是一种有效的技术。
Delegating Calls to a Fake
有时你已经有一个对某一接口的Fake实现了。比如：
class Foo {
public:
virtual~Foo() {}
virtual char DoThis(int n) = 0;
virtual void DoThat(const char* s, int* p) = 0;
};
class FakeFoo : public Foo {
public:
virtual char DoThis(int n) {
return (n > 0) ? '+' :
(n < 0) ? '-' : '0';
}
virtual void DoThat(const char* s, int* p) {
*p = strlen(s);
}
};
现在你想要Mock这个接口，比如你想在它上面设置期望。但是你还想用FakeFoo作为Mock类函数的默认行为，当然你可以选择将代码复制到Mock对象里，但是这会有很大的工作量。
当你用Google Mock来定义Mock类，你可以代理对象的默认行为给你已经有的Fake 类，用下面的方法：
using ::testing::_;
using ::testing::Invoke;
class MockFoo : public Foo {
public:
// Normal mock method definitions using Google Mock.
MOCK_METHOD1(DoThis, char(int n));
MOCK_METHOD2(DoThat, void(const char* s, int* p));
// Delegates the default actions of the methods to a FakeFoo object. // This must be called *before* the custom ON_CALL() statements. void DelegateToFake() {
ON_CALL(*this, DoThis(_))
.WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
ON_CALL(*this, DoThat(_, _))
.WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
}
private:
FakeFoo fake_; // Keeps an instance of the fake in the mock.
};
你现在可以像以前一样在你的测试中使用MockFoo。只是你要记得如果你没有明确地设置ON_CALL或是EXPECT_CALL()的行为，那Fake函数就会被调用：
using ::testing::_;
TEST(AbcTest, Xyz) {
MockFoo foo;
foo.DelegateToFake(); // Enables the fake for delegation.
// Put your ON_CALL(foo, ...)s here, if any.
// No action specified, meaning to use the default action.
EXPECT_CALL(foo, DoThis(5));
EXPECT_CALL(foo, DoThat(_, _));
int n = 0;
EXPECT_EQ('+', foo.DoThis(5)); // FakeFoo::DoThis() is invoked.
foo.DoThat("Hi", &n); // FakeFoo::DoThat() is invoked.
EXPECT_EQ(2, n);
}
一些技巧：
●如果你不想用FakeFoo中的函数，你仍然可以通过在ON_CALL或是在EXPECT_CALL
中用.WillOnce() / .WillRepeated()覆盖默认行为。
●在DelegateToFake()中，你只需要代理那些你要用的函数的Fake实现。
●这里所讲的技术对重载函数也是适用的，但你需要告诉编译器你是指重载函数中的哪一
个。消除一个Mock函数的歧义( 即你在ON_CALL中指定的 )，参见“Selecting Between Overloaded Functions”一节，消除一个Fake函数的歧义( 即在Invoke 中的 )，使用static_cast来指定函数的类型。
●将一个Mock和一个Fake搅在一起通常是某种错误的信号。也许你还没有习惯基于交
互方式的测试。或是你的接口融合了过多的角色，应该把这个接口分开。所以别滥用这个技术。我们建议这仅应该用做你重构你代码时的中间步骤。
再思考一个Mock和一个Fake混在一起的问题，这里有一个例子来说明为什么这是一个错误信号：假设你有一个System类，它实现了一些低层的系统操作。具体一些，它处理文件操作和I/O操作。假设你想测试你的代码是如何使用System来进行I/O操作，你只是想让文件操作工作正常就可以了。如果你想要Mock整个System类，你就必须提供一个关于文件操作的Fake实现，这表明System拥有了太多的角色。
相反，你可以定义一个FileOps和一个IOOps接口来拆分System的功能。然后你可以Mock IOOps而不用Mock FileOps。
Delegating Calls to a Real Object
当使用测试doubles( 替身的意思 mocks, fakes, stubs 等等 )时，有时它们的行为与真实对象的行为不一样。这种差别可能是有意为之( 比如模拟一个错误，假设你的代码
中有错误处理逻辑 )或是无意的。如果你的Mock与真实对象的差别是错误造成的，你可能会得到能通过测试，却在正式代码中失败的代码。
你可以使用delegating-to-real技术来保证你的Mock与真实对象有着相同的行为，并且拥有验证调用的能力。这个技术与delegating-to-fake技术很相似，区别在于我们使用真实对象而不是一个Fake。下面是一个例子：
using ::testing::_;
using ::testing::AtLeast;
using ::testing::Invoke;
class MockFoo : public Foo {
public:
MockFoo() {
// By default, all calls are delegated to the real object.
ON_CALL(*this, DoThis())
.WillByDefault(Invoke(&real_, &Foo::DoThis));
ON_CALL(*this, DoThat(_))
.WillByDefault(Invoke(&real_, &Foo::DoThat));
...
}
MOCK_METHOD0(DoThis, ...);
MOCK_METHOD1(DoThat, ...);
...
private:
Foo real_;
};
...
MockFoo mock;
EXPECT_CALL(mock, DoThis())
.Times(3);
EXPECT_CALL(mock, DoThat("Hi"))
.Times(AtLeast(1));
... use mock in test ...
用上面的代码，Google Mock会验证你的代码是否做了正确的调用( 有着正确的参数，以正确的顺序，有着正确的调用次数 )，并且真实的对象会处理这些调用( 所以行为将会和正式代码中表现一致 )。这会让你在两个世界都表现出色。
Delegating Calls to a Parent Class
理想中，你应该针接口编程，并接口的函数都是虚函数。现实中，有时候你需要Mock
一个非纯虚函数( 比如，它已经有了实现 )。比如：
class Foo {
public:
virtual ~Foo();
virtual void Pure(int n) = 0;
virtual int Concrete(const char* str) { ... }
};
class MockFoo : public Foo {
public:
// Mocking a pure method.
MOCK_METHOD1(Pure, void(int n));
// Mocking a concrete method. Foo::Concrete() is shadowed.
MOCK_METHOD1(Concrete, int(const char* str));
};
有时你想调用Foo::Concrete()而不是MockFoo::Concrete()。也许你想将它做为Stub行为的一部分，或是也许你的测试根本不需要Mock Concrete() (当你不需要Mock 一个新的Mock类的任何一个函数时候，而定义一个新的Mock类时，将会是出奇的痛苦)。
解决这个问题的技巧就是在你的Mock类中留下一个后门，可以通过它去访问基类中的真实函数：
class MockFoo : public Foo {
public:
// Mocking a pure method.
MOCK_METHOD1(Pure, void(int n));
// Mocking a concrete method. Foo::Concrete() is shadowed.
MOCK_METHOD1(Concrete, int(const char* str));
// Use this to call Concrete() defined in Foo.
int FooConcrete(const char* str) { return Foo::Concrete(str); } };
现在你可以在一个动作中调用Foo::Concrete()：
using ::testing::_;
using ::testing::Invoke;
...
EXPECT_CALL(foo, Concrete(_))
.WillOnce(Invoke(&foo, &MockFoo::FooConcrete));
或是告诉Mock对象你不想MockConcrete()：
using ::testing::Invoke;
...
ON_CALL(foo, Concrete(_))
.WillByDefault(Invoke(&foo, &MockFoo::FooConcrete));
( 为什么我们不只写Invoke(&foo, &Foo::Concrete)？如果你这样做，MockFoo::Concrete会被调用( 从而导致无穷递归)，因为Foo::Concrete()是虚函数。这就是C++的工作方式 )。
Using Matchers
Matching Argument Values Exactly
你可以精确指定一个Mock函数期望的参数是什么：
using ::testing::Return;
...
EXPECT_CALL(foo, DoThis(5))
.WillOnce(Return('a'));
EXPECT_CALL(foo, DoThat("Hello", bar));
Using Simple Matchers
你可以用Matchers去匹配有一定特征的参数：
using ::testing::Ge;
using ::testing::NotNull;
using ::testing::Return;
...
EXPECT_CALL(foo, DoThis(Ge(5))) // The argument must be >= 5.
.WillOnce(Return('a'));
EXPECT_CALL(foo, DoThat("Hello", NotNull()));
// The second argument must not be NULL.
一个常用的Matcher是_，它表示匹配任何参数：
using ::testing::_;
using ::testing::NotNull;
...
EXPECT_CALL(foo, DoThat(_, NotNull()));
Combining Matchers
你可以使用已有的AllOf()，AnyOf()，Not()，组合产生一些复杂的Matchers：
using ::testing::AllOf;
using ::testing::Gt;
using ::testing::HasSubstr;
using ::testing::Ne;
using ::testing::Not;
...
// The argument must be > 5 and != 10.
EXPECT_CALL(foo, DoThis(AllOf(Gt(5),
Ne(10))));
// The first argument must not contain sub-string "blah".
EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")),
NULL));
Casting Matchers
Google Matchers都是静态类型的，即如果你错误地使用Matcher的类型( 比如，如果你使用Eq(5)去匹配一个string参数 )，编译器会报错。这也是为你好。
但有时，你知道你自己在做什么，并希望编译器放你一马。举例来说：如果你有一个针对long类型的Matcher，但你想匹配的是int。虽然这两个类型不同，但实际上用Matcher
为了支持这种需求，Google Mock提供了SafeMatcherCast
1.T类型可以隐式地转换为U类型。
2.当T和U都是内置数值类型时( bool，integers，float )，从T到U的转换是无损
的( 换句话说，用T类型的任何值都可以用U类型表示 )。
3.当U是一个引用，T必须也是一个引用( 因为底层的Matcher也许会对U类型参数的地
址感兴趣 )。
如果上述条件中任何一个没满足，是不会通过编译的。
下面是一个例子：
using ::testing::SafeMatcherCast;
// A base class and a child class.
class Base { ... };
class Derived : public Base { ... };
class MockFoo : public Foo {
public:
MOCK_METHOD1(DoThis, void(Derived* derived));
};
...
MockFoo foo;
// m is a Matcher
EXPECT_CALL(foo, DoThis(SafeMatcherCast
如果你发现SafeMatcherCast
MatcherCast对你凌驾于C++类型系统之上很重要的( static_cast不总是安全的，比如它可以丢弃一部分信息 )，所以要小心不要误用/滥用它。
Selecting Between Overloaded Functions
如果你期望一个重载函数被调用，编译器需要你来指明你指的是重载函数中的哪一个。
消除一个对象上关于常量的重载的歧义，使用Const()来指明。
using ::testing::ReturnRef;
class MockFoo : public Foo {
...
MOCK_METHOD0(GetBar, Bar&());
MOCK_CONST_METHOD0(GetBar, const Bar&());
};
...
MockFoo foo;
Bar bar1, bar2;
EXPECT_CALL(foo, GetBar()) // The non-const GetBar().
.WillOnce(ReturnRef(bar1));
EXPECT_CALL(Const(foo), GetBar()) // The const GetBar().
.WillOnce(ReturnRef(bar2));
( Const()由Google Mock定义，并返回它的参数的const引用。 )
消除函数个数相同，但参数类型不同重载函数的歧义，你也许需要精确指定一个Matcher的匹配类型，在Matcher
using ::testing::An;
using ::testing::Lt;
using ::testing::Matcher;
using ::testing::TypedEq;
class MockPrinter : public Printer {
public:
MOCK_METHOD1(Print, void(int n));
MOCK_METHOD1(Print, void(char c));
};
TEST(PrinterTest, Print) {
MockPrinter printer;
EXPECT_CALL(printer, Print(An
Print(int);
EXPECT_CALL(printer, Print(Matcher
Print(int);
EXPECT_CALL(printer, Print(TypedEq
Print(char);
printer.Print(3);
printer.Print(6);
printer.Print('a');
}
Performing Different Actions Based on the Arguments
当一个Mock函数被调用时，最后一个有效的期望会被匹配( “新规则覆盖老规则” )。所以你可以让一个函数根据它的参数值去做不同的事，如下：
using ::testing::_;
using ::testing::Lt;
using ::testing::Return;
...
// The default case.
EXPECT_CALL(foo, DoThis(_))
.WillRepeatedly(Return('b'));
// The more specific case.
EXPECT_CALL(foo, DoThis(Lt(5)))
.WillRepeatedly(Return('a'));
现在，如果foo.DoThis()被调用时参数值小于5，就会返回’a’，否则返回’b’。
Matching Multiple Arguments as a Whole
有时候只能单独去匹配参数是不够的。比如，我们想设置第一个参数的值必须小于第二个参数的值。With子句可以让我们将Mock函数的参数做为一个整体去匹配。比如：
using ::testing::_;
using ::testing::Lt;
using ::testing::Ne;
...
EXPECT_CALL(foo, InRange(Ne(0), _))
.With(Lt());
上面代码意为InRange第一个参数必须非0，并且必须小于第二个参数。
在With内的语句必须是一个Match
你还可以用AllArgs(m)来代替将m写在.With()里的写法。两种形式意义相同，但是.With(AllArgs(Lt()))比.With(Lt())更具有可读性。
你可以用Args
using ::testing::_;
using ::testing::AllOf;
using ::testing::Args;
using ::testing::Lt;
...
EXPECT_CALL(foo, Blah(_, _, _))
.With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt())));
为了方便和举例起见，Google Mock提供了关于2-tuples的Matchers，包括上面的Lt() Matcher。可以到CheatSheet中找到完整的列表。
注意如果你想将这些参数传递给你自己的Predicate( 比如.With(0, 1)(Truly(&MyPredicate)))，你的必须以tr1::tuple做为它的参数。Google Mock会将n个选中的参数作为单个tuple传递给Predicate。
Using Matchers as Predicates
你是否注意到Matcher只是一个好看一些的Pridicate，许多已有的算法可将Predicates作为参数( 比如，那些在STL的
幸运的地，你可以将一元Predicate仿函数放到Matches()函数中来使用Matcher，比如：
#include
#include
std::vector
...
// How many elements in v are >= 10?
const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
因为你可通过将简单的matchers组合来产生复杂的matchers，那么这就给你了一种构造组合Predicates的方便方法( 与在STL中使用
Matches(AllOf(Ge(0), Le(100), Ne(50)))
Using Matchers in Google Test Assertions
因为Matchers基本上就是Predicates，所以这就提供了一种在Google Test中使用它们的好方法。它叫ASSERT_THAT和EXPECT_THAT：
ASSERT_THAT(value, matcher); // Asserts that value matches matcher. EXPECT_THAT(value, matcher); // The non-fatal version.
例如，在Google Test中你可以写：
#include"gmock/gmock.h"
using ::testing::AllOf;
using ::testing::Ge;
using ::testing::Le;
using ::testing::MatchesRegex;
using ::testing::StartsWith;
...
EXPECT_THAT(Foo(), StartsWith("Hello"));
EXPECT_THAT(Bar(), MatchesRegex("Line \\d+"));
ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10)));
上面的代码( 正如你所猜测的 )执行Foo()，Bar()，和Baz()，并验证：
●Foo()返回一个以”Hello”开头的字符串。
●Bar()返回一个匹配”Line \\d+”的正则表达式。
●Baz()返回一个在[5, 10]区间内的数字。
这些宏带来的好处是它们读起来像是英语。它们也会产生提示消息。比如，如果第一个
EXPECT_THAT失败，消息会类似下面的：
Value of: Foo()
Actual: "Hi, world!"
Expected: starts with "Hello"
荣誉：(ASSERT|EXPECT)_THAT的想来是从Hamcrest中获取的，它以assertThat加入JUnit中。
Using Predicates as Matchers
Google Mock提供了一系列的内置Matchers。如果发现它们还是不够，你可以用一个任意的一元Predicate函数或是仿函数作为一个Matcher，只要它能接受你想用的类型。你就可以将这个Predicate入到Truly()函数中，比如：
using ::testing::Truly;
int IsEven(int n) { return (n % 2) == 0 ? 1 : 0; }
...
// Bar() must be called with an even number.
EXPECT_CALL(foo, Bar(Truly(IsEven)));
注意Predicate函数/仿函数不需要一定返回bool类型。它只要求返回值可以用于if (condition)语句中的condition。
Matching Arguments that Are Not Copyable
当你设置一个EXPECT_CALL(mock_obj, Foo(bar))时，Google Mock会保存bar的一个拷贝。当Foo()被调用时之后时，Google Mock会比较传递给Foo的参数和所保存的bar的拷贝。通过这种方式，你不需要担心在EXPECT_CALL()执行之后bar被修改了或是被销毁了。当你使用如Eq(bar)，Le(bar)等等Matcher时也是这样。
但如果bar对象不能拷贝( 比如，没有拷贝构造函数 )？你可以定义自己的Matcher 并将它放到Truly()中，前几小节已经介绍过如何去做了。或是如果你自己可以保证bar 不会在调用EXPECT_CALL之后改变，这样你可以轻松点。只需要告诉Google Mock它应该保存bar的引用，而不是去拷贝它。下面是一个例子：
using ::testing::Eq;
using ::testing::ByRef;
using ::testing::Lt;
...
// Expects that Foo()'s argument == bar.
EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar))));
// Expects that Foo()'s argument < bar.
EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar))));
切记：如果你这样做，不要在调用EXPECT_CALL之后改变bar对象，否则结果是未定义的。Validating a Member of an Object
通常Mock函数将一个对象的引用作为参数。当匹配这个参数时，你可能不想将整个对象与一个固定的对象比较，因为这样过于精确了。相反，你可能想验证几个特定的对象成员或是几个特定的getter函数的结果。你可以用Field()和Property来实现这个功能。具体地讲：
Field(&Foo::bar, m)
这是一个匹配Foo对象的bar成员满足Machter m的一个Matcher。
Property(&Foo::baz, m)
这是一个匹配Foo对象的baz()函数返回的值满足Matcher m的一个Matcher。
例如：
Field(&Foo::number, Ge(3))
Property(&Foo::name, StartsWith("John "))
分别表示：
匹配x.number >=3 的x对象。
匹配https://www.doczj.com/doc/1c19057967.html,()以”John ”开头的x对象。
注意，在Property(&Foo::baz, ...)中，函数baz()必须是无参的，而且需要声明为const。
随便提一下，Field()和Property()同样可以匹配指向对象的普通指针，比如：
Field(&Foo::number, Ge(3))
它的意思是匹配一个p->number>=3的普通指针p，如果p是NULL，匹配总是会失败。
如果你想一次验证多个成员呢？切记你可以使用AllOf()。
Validating the Value of Pointed to by a Pointer Argument C++函数经常使用指针型参数。你可以用如NULL，NotNULL()以及其它的一些比较
云计算的关键技术及发展现状 周小华 摘要：本文主要对云计算技术的应用特点、发展现状、利处与弊端以及对云计算的应用存在的主要问题进行了探讨分析，最后是关于云计算的挑战及其展望。 关键词：云计算；数据存储；编程模型 1.云计算定义 云计算是由分布式计算、并行处理、网格计算发展而来的，是一种新兴的商业计算模型。目前，对于云计算的认识在不断地发展变化，云计算仍没有普遍一致的定义。计算机的应用模式大体经历了以大型机为主体的集中式架构、以pc机为主体的c/s分布式计算的架构、以虚拟化技术为核心面向服务的体系结构（soa）以及基于web2.0应用特征的新型的架构。云计算发展的时代背景是计算机的应用模式、技术架构及实现特征的演变。“云计算”概念由google提出，一如其名，这是一个美妙的网络应用模式。在云计算时代，人们可以抛弃u盘等移动设备，只要进入google docs页面，新建一个文档，编辑其内容，然后直接把文档的url分享给朋友或上司，他们就可以直接打开浏览器访问url。我们再也不用担心因pc硬盘的损坏而发生资料丢失事件。 IBM公司于2007年底宣布了云计算计划，云计算的概念出现在大众面前。在IBM的技术白皮书“Cloud Computing”中的云计算定义：“云计算一词用来同时描述一个系统平台或者一种类型的应用程序。一个云计算的平台按需进行动态地部署(provision)、配置
(configuration)、重新配置(reconfigure)以及取消服务(deprovision)等。在云计算平台中的服务器可以是物理的服务器或者虚拟的服务器。高级的计算云通常包含一些其他的计算资源，例如存储区域网络(SANs)。网络设备，防火墙以及其他安全设备等。云计算在描述应用方面，它描述了一种可以通过互联网Intemet进行访问的可扩展的应用程序。“云应用”使用大规模的数据中心以及功能强劲的服务器来运行网络应用程序与网络服务。任何一个用户可以通过合适的互联嘲接入设备以及一个标准的浏览器就能够访问一个云计 算应用程序。” 云计算是基于互联网的超级计算模式，包含互联网上的应用服务及在数据中心提供这些服务的软硬件设施，进行统一的管理和协同合作。云计算将IT 相关的能力以服务的方式提供给用户，允许用户在不了解提供服务的技术、没有相关知识以及设备操作能力的情况下，通过Internet 获取需要的服务。 通过对云计算的描述，可以看出云计算具有高可靠性、高扩展性、高可用性、支持虚拟技术、廉价以及服务多样性的特点。现有的云计算实现使用的技术体现了以下3个方面的特征： （1）硬件基础设施架构在大规模的廉价服务器集群之上．与传统的性能强劲但价格昂贵的大型机不同，云计算的基础架构大量使用了廉价的服务器集群，特别是x86架构的服务器．节点之间的巨联网络一般也使用普遍的千兆以太网． （2）应用程序与底层服务协作开发，最大限度地利用资源．传
Google 出口易产品 出口易计划TradeYep------足不出户，营销全球！ Google 是全球最大的搜索引擎，2007年品牌价值 600多亿美元，世界排名第一。Google 关键字广告已成为众多搜索网站的范本，为全球上千万企业用户所接受，成为推动企业发展的首选。 Google 覆盖250个国家， 拥有 113 个国际域名， 支持 109 种语言，关键字广告可以选择 41 种语言发布，占领了全球70%以上的市场。可以迅速帮助企业扩大全球影响力，打造的全球概念。 Google AdWords 关键字广告出口易计划 Google AdWords 关键字出口易计划是Google （谷歌）及其正式授权代理商为满足出口贸易企业海外推广需要而推出的英文关键字广告计划。 北美洲 * Google 网络覆盖 80% 的互联网用户 * Google 是美国和加拿大No.1的 澳洲 * 81.6%当地搜索流量来自Google 欧洲 * 85% 当地搜索流量来自Google 拉丁美洲 * 75% 当地搜索流量来自Google 亚洲 * 54% 当地搜索流量来自Google * 在中国及香港地区是No. 2 大搜索引擎, 在印度处于No. 1位置 非洲与中东 * 66% 当地搜索流量来自Google 近70%的全球 搜索流量！
为什么选择出口易计划 TradeYep？ 全面解决出口企业面临的推广困境 出口企业面临的推广困境出口易解决方案 规模有限 需要多渠道投放覆盖目标人群有限全球投放 全球最庞大的网络营销平台精准投放广告 语言障碍 缺乏外文营销专家 难以有效跟踪和调整推广沟通无障碍 提供英文广告撰写/投放和中文报告 推广无针对性 广告不能仅针对意向客户投资回报有限广告只针对目标客户 相关关键字触发广告 强烈意向客户带来更多成交机会 效果不明显 海外推广受众不精准难以看到明显客户转化投资回报高 广告观众怀有强烈潜在意愿客户转化几率高 花钱不“明白” 资金投入后，无法跟踪效果无法看到回报清楚广告投资花费 广告按点击收费,且企业自主决定预算专业工具跟踪投资效果 市场应对慢 广告内容/投放区域/投放时间无法修改难以应对市场快速变化应需而动 可随时根据市场策略随时更改 包括广告内容/投放区域/时段/不同语言受众 成本高/风险高 企业没有看到效果就必须提前大笔投入低成本起步 进入门槛较低 广告按点击收费，展示不收费,不点击不收费
1简介 1.1什么是google云计算？ Google的云计算技术实际上是针对Google特定的网络应用程序而定制的。针对内部网络数据规模超大的特点，Google提出了一整套基于分布式并行集群方式的基础架构，利用软件的能力来处理集群中经常发生的节点失效问题。 1.2Google云计算平台 Google 提供了一个名为App Engine 的云计算平台，它基于的是Google 早就建立起来的底层平台。这个平台包括GFS（Google File System）和Bigtable（构建于GFS 之上的数据库系统）。Google App Engine 内的编程采用的是Python。程序员用Python 编写应用程序，然后再在App Engine 框架上运行。除Python 外的其他语言在将来也会得到支持。出于开发的需要，可以下载App Engine 环境的一个本地仿真程序。App Engine 可免费使用并且包括多达500 MB 的存储及足够的CPU 带宽来满足每天5 百万次页面浏览。 Google App Engine 提供了一些有用的基础设施，比如源自GFS 的数据存储和一个memcache实现。然而，它并不提供开箱即用的排队机制。不过，有了这样一个纯Python 的编程环境，就可以在App Engine 之上很容易地创建您自已的JMS 替代。这个数据存储很适合于混合应用程序，并且只需很少的Python 编程就可以打造出一个面向您的队列的RESTful式接口。 2原理 2.1 GFS（Google文件系统） 2.1.1特点 采用廉价的商用机器构建分布式文件系统，将容错的任务交由文件系统来完成，利用软件的方法解决系统可靠性问题，从而使存储的成本下降；保证在频繁的故障中确保数据存储的安全，保证提供不间断的数据存储服务。
绩效与薪酬管理 教学号：11130133 姓名：刘明慧专业：人力资源管理 谷歌公司薪酬激励分析 一、谷歌公司简介 谷歌（Google）是一家美国上市的公司，于1998年9月以私有股份公司的创立，不久之后它就成为了全球搜索领域的先驱。2004年8月，谷歌公司的股票在纳斯达克（Nasdaq）上市，成为公有股份公司。谷歌公司的总部称作“Googleplex”，位于美国加州圣克拉拉县的芒廷维尤。“Googol”是一个数学术语，表示 1 后面带有100个零，它是由美国数学家爱德华·卡斯纳的侄子米尔顿·西洛塔所创造，因出现在凯斯纳和詹姆士·纽曼合著的“数学与想象力”一书中而得到普及。谷歌（Google）公司对这个词作了微小改变，借以反映公司的使命，意在组织网上无边无际的信息资。谷歌的实用性及便利性赢得了众多用户的青睐，它几乎完全是在用户的交口称颂下成为全球最知名的品牌之一的。 目前谷歌被公认为全球规模最大的搜索引擎，它提供了简单易用的免费服务。谷歌将自己定位为创新的源泉，在这里IT人士可以找到充满挑战的工作以及改变世界的机遇。 二、谷歌公司薪酬管理现状及优势 薪酬管理是人力资源管理乃至整个企业管理的核心内容之一，不仅涉及企业的经济核算与效益，而且与员工切身利益息息相关。科学有效的薪酬激励机制能够让员工发挥出最佳的潜能，为企业创造出更大的价值。 在《财富》杂志的2012年美国100家最佳雇主排行榜上，谷歌排名第一，并非浪得虚名。高福利、高薪酬，再加上贴心的人文关怀，谷歌公司无可厚非的受到人才们的青睐。 ㈠谷歌公司的薪酬体系 据调查，2012年谷歌公司平均薪水为：106,104美元；薪水最高的职位；高级软件工程师（140,481美元）；薪水最低职位：客户策略师（60,909美元）。 谷歌推出以绩效为导向的富有竞争力的全面薪酬：谷歌的全面薪酬包括工资、津贴、奖金、福利、保险、股票期权等。在对员工的短期、中期、和长期激励上，各自发挥着不同的作用。 对外，谷歌整体薪酬保持着市场上的强大竞争力；对内，充分考虑不同岗位，职级以及员工工作表现的差异性，建立了全方位的以业绩为导向的薪资理念。谷歌为所有正式员工发放股票期权，并且每年都会根据员工上一年度的业绩表现再授予股票期权。业
从整体来看，Google的云计算平台包括了如下的技术层次。 ●网络系统：包括外部网络(Exterior Network) ，这个外部网络并不是指运营商自己的骨干网，也是指在Google 云计算服务器中心以外，由Google 自己搭建的由于不同地区/国家，不同应用之间的负载平衡的数据交换网络。内部网络（Interior Network），连接各个Google自建的数据中心之间的网络系统。 ●硬件系统：从层次上来看，包括单个服务器、整合了多服务器机架和存放、连接各个服务器机架的数据中心（IDC）。 ●软件系统：包括每个服务器上面的安装的单机的操作系统经过修改过的Redhat Linux。Google 云计算底层软件系统（文件系统GFS、并行计算处理算法Mapreduce、并行数据库Bigtable，并行锁服务Chubby Lock，云计算消息队列GWQ） ●Google 内部使用的软件开发工具Python、Java、C++ 等 ●Google 自己开发的应用软件Google Search 、Google Email 、Google Earth 外部网络系统介绍 当一个互联网用户输入的时候，这个URL请求就会发到Google DNS 解析服务器当中去，Google 的DNS 服务器会根据用户自身的IP 地址来判断，这个用户请求是来自哪个国家、哪个地区。根据不同用户的IP地址信息，解析到不同的Google的数据中心。 进入第一道防火墙，这次防火墙主要是根据不同端口来判断应用，过滤相应的流量。如果仅仅接受浏览器应用的访问，一般只会开放80 端口http，和443 端口https （通过SSL加密）。将其他的来自互联网上的非Ipv4 /V6 非80/443 端口的请求都放弃，避免遭受互联网上大量的DOS 攻击。 在大量的web 应用服务器群（Web Server Farm）前，Google使用反向代理（Reverse Proxy）的技术。反向代理（Reverse Proxy）方式是指以代理服务器来接受internet 上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给Internet 上请求连接的客户端，此时代理服务器对外就表现为一个服务器。
企业战略管理案例-Google的企业战略 目录 、（SWOT分析） 、Google的SPACE分析 、Google的外部因素评价矩阵EFE 、Google的竞争态势矩阵CPM
1、Google公司简介 Google是一家美国上市公司（公有股份公司），于1998年9月7 日以私有股份公司的形式创立，以设计并管理一个互联网搜索引擎。Google 网站于1999年下半年启动；2004年8月19日,Google公司的股票在纳斯达克上市,成为公有股份公司。Google公司的总部称作“Googleplex”，它位于加利福尼亚山景城。Google目前被认为是全球规模最大的搜索引擎，它提供了简单易用的免费服务。“不作恶（Don’t be evil）”是谷歌公司的一项非正式的公司口号，最早是由Gmail服务创始人在一次会议中提出。目前，Google公司旗下的业务种类繁多，主要分为四大类： 搜索类产品是Google的主要产品，包括网页搜索、视频搜索、地图搜索等； 网络应用产品主要是注入Google talk、Gmail、Google chrome 等； 手机系统产品是Google新推出的手机系统Android； 盈利产品Google Adwords 是关键字搜索广告。 2、Google 企业文化 尽管自 1998 年创立以来，Google 的规模已经扩大了很多，但他们仍坚持营造一种小公司的氛围。午餐的时候，几乎所有人都在公司的餐厅随意就座用餐，与各个不同部门的同事一起愉快地畅谈。Google 秉承一贯的创新理念，而这有赖于每位员工都能够毫无顾忌地交流想法和观点。这就意味着每个员工都是功不可没的贡献者，而且每个人都要在公司身兼
Google各类产品简介 1.Google Adwords（关键词竞价排名） 1.产品简介：通过设置关键词，进行排查某些无必要不精准或者价值不高的关键词后，在后台进行上线推广，当用户搜索这些关键词的时候可以检索到我们公司网站的信息，然后进行一个跳转，可以自己设定着陆页。（着陆页可以是我们的官网，也可以是产品的详细页面）。关键词可以根据不同的地区设置不同的关键词组，跳转的页面也可以不同（图2位跳转位置）。 2.广告投放位置： 左上方三个广告，左下方四个广告。
2.Google Gmail广告 1.产品简介：展示在国外邮箱上的广告，根据用户的搜索习惯（自己设置客户群体信息），将某些会产生询盘的客户进行标记，对这些客户进行广告投放。(点击后的样式可以是全屏，也可以单一的介绍产品信息） 2.广告投放位置： 展示在右侧以及上方 3.Google再营销 1.产品简介：当客户进入你的网站产品详情页点击后，但是当时没有产生购买（可能因为价格等问题），这个产品可以将这些客户进行一个保留，然后针对这些客户投放相应广告。 2.广告投放位置： 主要根据针对的客户群体投放广告，当客户浏览网站时，会看到相应的广告。 4.Google展示广告（联盟） 1.产品简介：根据关键词，主题等方式定位网站，或者通过用户的兴趣等定位人群投放广告。（一个跟人走，一个跟着网站走） 2.广告投放位置： 定位网站根据客户的LED灯等情况建议投放到以下网站，或者获取人群信息以及展示的位置：
5.Google产品列表广告 1.产品简介：主要以介绍单一产品为主，实现在线购买的过程。（如果没有在线购买无法使用这个广告功能） 2.广告投放位置：显示在Google搜索引擎左上方以及右上方的广告，点击后会进入一个产品的购买页面
第1章绪论 很少有一种技术能够像“云计算”这样，在短短的两年间就产生巨大的影响力。Google、亚马逊、IBM和微软等IT巨头们以前所未有的速度和规模推动云计算技术和产品的普及，一些学术活动迅速将云计算提上议事日程，支持和反对的声音不绝于耳。那么，云计算到底是什么？发展现状如何？它的实现机制是什么？它与网格计算是什么关系？。本章将分析这些问题，目的是帮助读者对云计算形成一个初步认识。 1.1 云计算的概念 云计算（Cloud Computing）是在2007年第3季度才诞生的新名词，但仅仅过了半年多，其受到关注的程度就超过了网格计算（Grid Computing），如图1-1所示。 搜索量指数Google Tronds 云计算 网格计算 图1-1 云计算和网格计算在Google中的搜索趋势 然而，对于到底什么是云计算，至少可以找到100种解释，目前还没有公认的定义。本书给出一种定义，供读者参考。 云计算是一种商业计算模型，它将计算任务分布在大量计算机构成的资源池上，使用户能够按需获取计算力、存储空间和信息服务。 这种资源池称为“云”。“云”是一些可以自我维护和管理的虚拟计算资源，通常是一些大型服务器集群，包括计算服务器、存储服务器和宽带资源等。云计算将计算资源集中起来，并通过专门软件实现自动管理，无需人为参与。用户可以动态申请部分资源，支持各种应用程序的运转，无需为烦琐的细节而烦恼，能够更加专注于自己的业务，有利于提高效率、降低成本和技术创新。云计算的核心理念是资源池，这与早在2002年就提出的网格计算池（Computing Pool）的概念非常相似[3][4]。网格计算池将计算和存储资源虚拟成为一个可以任意组合分配的集合，池的规模可以动态扩展，分配给用户的处理能力可以动态回收重用。这种模式能够大大提高资源的利用率，提升平台的服务质量。 之所以称为“云”，是因为它在某些方面具有现实中云的特征：云一般都较大；云的
Google 云计算技术架构: Google 云计算技术架构应用均依赖于四个基本组件1.分布式文件存储(GFS),2,并行数据处理模型(MapReduce).3分布式锁(Chubby).4,结构化数据表(BigTable). Chubby的作用:1.为GFS提供锁服务,选择Master节点:记录Master的相关描述信息;2:通过独占锁记录Chunk Server 的活跃情况;3:为BigTable提供锁服务,记录子表信息(如子表文件信息,子表分类信息,子表服务信息);4:记录MapReduce的任务信息;5:为第三方提供锁服务与文件存储. GFS的作用:1.存储Bigtable的子表文件,2:为第三方应用提供大尺寸文件存储功能;3:文件读操作流程(API与Mater 通信,获取文件元信息,根据指定的读取位置与读取长度,API发动兵发起操作,分别从若干ChunkServer上读取数据,API组装所得数据,返回结果. BigT able的作用:1.为Google云计算应用(或第三方应用)提供数据结构化存储功能;2:类似于数据库;3:为应用提供简单数据查询功能(不支持联合查询);4:为MapReduce提供数据源或者数据结果存储. BigT able的存储于服务请求的响应:1.换分为子表存储,每一个子表对应一个子表文件,子表文件存储于GFS 上;2:bigTable通过元数据组织子集;3:每个子集都被分配给一个子表服务器;4:一个子表服务器可同时分配多个子表;4:子表服务器负责对外提供服务,响应查询请求. MapReduce的作用:对BigTable中的数据进行并行计算处理;2使用BigTable或者GFS存储计算结果 Google Analytics:免费的企业级网络分析解决方案;2:帮助企业了解网站流量和营销效果;3:能以灵活的反噬(各类报表)查看并分析流量数据 Google网站流量分析的基本功能:统计网站的基本数据,包括会话,综合浏览量,点击量和字节流量;2:分析网站页面关注度,帮助企业调整或者增删页面;3:分析用户浏览路径,优化页面布局;4:分析用户访问来源连接,提供广告投资回报;5:分析用户访问环境,帮助美化页面 EC2:Eastic Compute Cloud)简言之,EC2就是一部具有无限采集能力的虚拟计算机,用户能够用来执行一些处理任务EC2的主要特征:1:灵活性,可以自行配置的实例类型,数量,还可以选择实例运行的地理位置,可以根据影虎的需求随时改变实例的使用数量;2:低成本:SSH,可配置的防火墙机制,监控等;3:易用性:用户可以根据亚马逊提供的模块自由构建自己的应用程序,同时EC2还会对用户的服务请求自动进行负载均衡;3:容错性,弹性IP 简单队列服务SQS:目标:解决低耦合系统间的通信问题,支持分布式计算机系统之间的工作流, 简单队列服务SQS:特点:简单,无处不在 简单队列服务SQS:的机制:冗余存储,给予加权随机分布的消息取样,并发管理和故障排除,消息的可见性超时值与生命周期 SDB与S3的区别:S3是专为大型,费结构化的数据块设计的;SimpleDB是为复杂的,结构化数据建立的,支持数据的查找,删除,插入等操作
谷歌云计算的现状与发展
摘要：Google作为世界云计算的“领头人”，它在云计算的研究与开发方面做得非常出色，从Google 的整体的技术构架来看，Google计算系统依然是边做科学研究，边进行商业部署，依靠系统冗余和良好的软件构架来低成本的支撑庞大的系统运作的，大型的并行计算，超大规模的IDC 快速部署，通过系统构架来使廉价PC 服务器具有超过大型机的稳定性都已经不在是科学实验室的故事，已经成为了互联网时代，IT 企业获得核心竞争力发展的基石。尽管云计算是个刚刚出现没多久的新词汇，尽管我们还处在在云计算的起跑阶段，但是，我们从Google的与计算技术构架里，就可以获得很多信息，那些信息可能就是我们通向未来互联网全新格局的钥匙。 关键词：云计算 Google 技术构架 云计算是一种商业计算模型。它将计算任务分布在大量计算机构成的资源池上，使各种应用系统能够根据需要获取计算力、存储空间和信息服务。 我们可以认为：云计算是通过网络按需提供可动态伸缩的廉价计算服务。 提供资源的网络被称为“云”。“云”中的资源在使用者看来是可以无限扩展的，并且可以随时获取，按需使用，随时扩展，按使用付费。这种特性经常被称为像水电一样使用IT基础设施。
有人打了个比方：这就好比是从古老的单台发电机模式转向了电厂集中供电的模式。它意味着计算能力也可以作为一种商品进行流通，就像煤气、水电一样，取用方便，费用低廉。最大的不同在于，它是通过互联网进行传输的。 云计算是并行计算、分布式计算和网格计算的发展，或者说是这些计算机科学概念的商业实现。云计算是虚拟化、公用计算、IaaS(基础设施即服务)、PaaS(平台即服务)、SaaS(软件即服务)等概念混合演进并跃升的结果。 总的来说，云计算可以算作是网格计算的一个商业演化版。 “Google”是美国一家上市公司，于1998年9月7日以私有股份公司的形式创立，以设计并管理一个互联网搜索引擎。Google公司的总部称作“Googleplex”，它位于加利福尼亚山景城。Google公司致力于互联网的应用与高新产业的开发。它在云计算的研发与发展方面，同样走在世界的前列。2006年8月9日，Google首席执行官埃里克·施密特在搜索引擎大会首次提出“云计算”的概念。Google“云端计算”源于Google工程师克里斯托弗·比希利亚所做“Google 101”项目。 2007年10月，Google与IBM开始在美国大学校园，包括卡内基梅隆大学、麻省理工学院、斯坦福大学、加州大学柏克莱分校及马里兰大学等，推广云计算的计划，这项计划
谷歌公司战略的分析/选择 公司简介 ???????公司名称：谷歌外文名称：Google 总部地点：美国加利福尼亚州山景城成立时间：1998年9月7日经营范围：网络信息服务例如搜索引擎等公司性质：美国上市公司，外商独资公司口号：完美的搜索引擎、不作恶(Don't be evil) ?年营业额：380亿美元（2011年）?员工数：32467（2011年12月31日 愿景把服务延伸到所有终端装置使命整合全球信息，使人人皆可访问并从中受益名称来历 ? Google公司选用“Google”一词用来代表在互联网上可以获得的海量的资源。“Google”源于单词“Googol”，指的是10的100次幂。 Google 企业文化 每位员工都能够毫无顾忌地交流想法和观点要求工程师们每天都有20%时间在个人感 兴趣的项目上公司提供员工免费餐点，早中晚餐全包巧克力、懒人球以及巨型积木随处可见，使这里更像是托儿所公司里面设有牙医与家庭医师请育婴假的员工 可照领75%的薪水 Google公司旗下的业务种类繁多，主要分为四大类：?搜索类产品是Google的主要产 品，包括 网页搜索、视频搜索、地图搜索等； ?网络应用产品主要是注入Google talk、 Google公司旗下的业务种类繁多，主要分为四大类： Gmail、Google chrome 等； ?手机系统产品Android是Google推出的 手机系统 ?盈利产品Google Adwords 是关键字搜 索广告。 Google搜索服务 网页图片Google公司一直以来致力于为广大用户提供快速、整合相关性高的搜索服
新闻音乐搜索务。2007年底，在垂直搜索的基础上，Google首先推出视频图书“整合搜索”。 Google搜索服务 Google搜索引擎较早引入云计算，大大提高了搜索速度和信息量。 “Google靠云计算成就最好的搜索引擎。” ——李开复 Google软件与在线服务 Google利用其搜索功能的优势，开发出多种在线功能性服务和软件，涉及各领域，PC版本和手机版本更大地方便了用户。 日程管理软件照片管理软件3D绘图软件 Google 地图 翻译软件 Gmail Google广告服务 关键字广告 广告 广告联盟 Google拥有两种不同的广告方案，考虑到不同广告主的需要。让广告得到快速、广 泛的传播，使得广告效果最大化。 关键字广告 广告联盟 swot 分析 ? S（strength） ?? 1.企业文化、目标和管理模式，帮助谷歌吸引顾客和高素质人才。2.技术。谷歌在搜索算法与硬件创新运作方面具有优势。Google的每一个搜索结果都是“纯技术选择”，是计算机程序按照点击率规则自动排列出来的3.品牌形象，顾客忠诚度。G oogle杰出的形象-代表创新、互联网、诚信。不进行推销、不追求快速致富的形象深入人心，也使得Google
Computer Knowledge and Technology电脑知识与技术第5卷第25期(2009年9月) 基于Google的云计算实例分析 蔡键1，王树梅2 （1.徐州师范大学现代教育技术中心，江苏徐州221116；2.徐州师范大学计算机科学与技术学院，江苏徐州221116） 摘要：首先介绍了云计算产生的背景、概念、基本原理和体系结构，然后以Google系统为例详细阐述了云计算的实现机制。云计算是并行计算、分布式计算和网格计算等计算机科学概念的商业实现。Google拥有自己云计算平台，提供了云计算的实现机制和基础构架模式。该文阐述了Google云计算平台：GFS分布式文件、分布式数据库BigTable及Map/Reduce编程模式。最后分析了云计算发展所面临的挑战。 关键词：云计算；集群；谷歌文件系统；大表；映射/化简 中图分类号：TP311文献标识码：A文章编号：1009-3044(2009)25-7093-03 Cloud Computing System Instances Based on Google CAI Jian1,WANG Shu-mei2 (1.Xuzhou Normal University Modern Educational Technology Center,Xuzhou221116,China;2.Xuzhou Normal University,School of Computer Science&Technology,Xuzhou221116,China) Abstract:This paper introduces the backgrounds,concept,basic principle and infrastructure of cloud computing firstly.Then it surveys im-plementation mechanism of clouding computing based on the instances of Google.Cloud computing is the system in enterprises based on the concepts of computer science.These concepts include parallel computing,distributed computing and grid computing.Google has his own platform of cloud computing.It provides implementation mechanism and infrastructure of cloud computing.This paper surveys the platform of cloud computing:Google File System,Distributed database-BigTable and Map/Reduce.Finally the paper analyse the challenge of cloud computing. Key words:cloud computing;cluster;GFS;bigtable;map/reduce 自2007年第4季度开始，“云计算”变成了IT领域新的热点。而2008年被称为云计算的元年，Google、Amazon、IBM、微软等IT 巨头们以前所未有的速度和规模推动云计算技术和产品的普及。本文介绍一些关于云计算的一些基本概念及Google提出的云计算模型及实现机制。 1云计算综述 云计算是并行计算(Parallel Computing)、分布式计算(Distributed Computing)和网格计算(Grid Computing)的发展，或者说是这些计算机科学概念的商业实现。 云计算是虚拟化(Virtualization)、效用计算(Utility Computing)、IaaS(基础设施即服务)、PaaS(平台即服务)、SaaS(软件即服务)等概念混合演进并跃升的结果。 1.1云计算的概念 云计算现在还没有统一标准的定义，一些大公司在自己的技术文档里给出了自己的定义。例如云计算在IBM的文档中对云计算的定义是：云计算一词用来描述一个系统平台或者一种类型的应用程序。一个云计算的平台按需进行动态的部署、配置、重新配置以及撤销服务等。 而对云计算更加通用的的定义是：云计算是一种商业计算模型。它 将计算任务分布在大量计算机构成的资源池上，使各种应用系统能够根 据需要获取计算力、存储空间和各种软件服务。从这个定义上讲可把云 计算看成是“存储云”与“计算云”的有机结合。存储云对第三方用户公 开存储接口，用户通过这个接口可以把数据存储到“云”。计算云通过并 行计算和虚拟化技术给用户提供计算力，它的商业模式是给用户提供计 算力。 1.2云计算实现机制 图1简单的描述了云计算的实现机制。用户通过用户交互接口 (User interaction interface)来请求服务云。一个用户能够请求的所有服务 目录存放在服务目录（Services catalog）里。系统管理（System manage- ment）是用户管理计算机资源是否可用。服务提供工具（Provisioning tool）用来处理请求的服务，需要部署服务配置。监控统计（Monitoring 收稿日期：2009-05-07 作者简介：蔡键，硕士，讲师，主研领域为图形图像处理，网格技术。图1云计算实现机制 ISSN1009-3044 Computer Knowledge and Technology电脑知识与技术Vol.5,No.25,September2009,pp.7093-7095，7107 E-mail:info@https://www.doczj.com/doc/1c19057967.html, https://www.doczj.com/doc/1c19057967.html, Tel:+86-551-56909635690964
深度#16 : 由Google新的组织架构Alphabet产生的联想 字数666阅读149评论0喜欢0 Google新格局
近日，Google对旗下所有的业务线做了一次重大的梳理和调整。简单来讲，将所有资产重新梳理规整到新的集团公司Alphabet旗下。 布局现在 Google Ventures vs. Google ? Google Ventures：中短线战略投资（资本），为公司现有业务线寻找重要的战略投资项目 ? ? Google：传统互联网核心业务（业务） ? Google Ventures是弹药，为Google现在的核心业务提供战略投资项目的机会。 布局未来 Google Capital vs. Google X Google Capital：长线天使投资布局（资本），为公司未来业务线寻找重要的战略投资项目 ? Google X：内部创新实验室（业务）
? ? Google Capital是弹药，为Google未来的产品线提供战略投资项目的机会。 ? 产业布局 Calico vs. Nest ?未来医疗：Calico ?智能家居：Nest 整体规划 Alphabet整体可以划归三部分：资本、现有业务、未来实验室。Google Ventures和Google Capital是资本。Google、Calico和Nest是现有业务。Google X是未来实验室（孵化器）。 本质上是一家广告公司 Google对于产业的整体大局把握是令人赞叹的，Google创始人在公司上市之前并没有更多被资本左右，在公司上市之后还能够主动做出重大调整的行动力更是令人敬佩。Google本身的搜索业务为公司带来最大的现金流，但是看上去更多像是一家广告公司。 Alphabet重组的意义 Google Ventures和Google Capital能够通过战略投资，持续为公司带来新鲜血液。Google X能够保持公司对于最新科技的敏感性。但是如何平衡在资本
Google云计算的关键技术（一） Google云计算的关键技术主要包括：Google文件系统GFS、分布式计算编程模型MapReduce、分布式锁服务Chubby和分布式结构化数据存储系统BigTable等。其中： 1）GFS提供了海量数据存储和访问的能力； 2）MapReduce使得海量信息的并行处理变得简单易行； 3）Chubby保证了分布式环境下并发操作的同步问题； 4）BigTable使得海量数据的管理和组织十分方便。 ●GFS GFS是一个面向海量数据密集型应用的、可伸缩的分布式文件系统，它为Google云计算提供了海量存储的能力，处于整个Google云计算技术体系的最底层。 GFS使用廉价的商用机器构建分布式文件系统，将容错的任务交由文件系统来完成，利用软件的方法解决系统可靠性的问题，不但使得存储的成本成倍下降，更是很好地在频繁的故障中确保了数据存储的安全和数据存储服务的连续性，从整体上确保了整个系统的可靠性，进而可以为大量客户机提供高性能的服务。 一、架构 一个GFS集群包含一个单独的Master逻辑节点、多台Chunk服务器，并且同时被多个客户端访问，如下图所示。
GFS存储的文件都被分割成固定大小的Chunk。在Chunk创建的时候，Master服务器会给每个Chunk分配一个不变的、全球唯一的64位的Chunk标识。Chunk服务器把Chunk以linux文件的形式保存在本地硬盘上，并且根据指定的Chunk标识和字节范围来读写块数据。出于可靠性的考虑，每个块都会复制到多个块服务器上。缺省情况下，我们使用3个存储复制节点，不过用户可以为不同的文件命名空间设定不同的复制级别。 Master节点管理所有的文件系统元数据，在逻辑上只有一个。这些元数据包括名字空间、访问控制信息、文件和Chunk的映射信息、以及当前Chunk的位置信息；Master节点还管理着系统范围内的活动，比如Chunk在Chunk服务器之间的迁移等。Master节点使用心跳信息周期地和每个Chunk服务器通讯，发送指令到各个Chunk服务器并接收Chunk服务器的状态信息。 GFS客户端代码以库的形式被链接到客户程序里。客户端代码实现了GFS文件系统的API 接口函数、应用程序与Master节点和Chunk服务器通讯、以及对数据进行读写操作。客户端和Master节点的通信只获取元数据，所有的数据操作都是由客户端直接和Chunk服务器进行交互的。 无论是客户端还是Chunk服务器都不需要缓存文件数据（客户端会缓存元数据）。客户端缓存数据几乎没有什么用处，因为大部分程序要么以流的方式读取一个巨大文件，要么工作集太大根本无法被缓存。Chunk服务器不需要缓存文件数据的原因是：Chunk以本地文件的方式保存，Linux操作系统的文件系统缓存会把经常访问的数据缓存在内存中。 设计思路：集中+分布。单一的Master节点便于通过全局的信息精确定位Chunk的位置以及进行复制决策。同时，为了避免Master节点成为系统的瓶颈，必须减少对Master节点的读写：客户端并不通过Master节点读写文件数据，只是通过其询问应该联系的Chunk服务器，后续的操作将直接和Chunk服务器进行数据读写操作。 二、客户端访问GFS流程 首先，客户端把文件名和程序指定的字节偏移，根据固定的Chunk大小，转换成文件的Chunk 索引。然后，它把文件名和Chunk索引发送给Master节点。Master节点将相应的Chunk 标识和副本的位置信息发还给客户端。客户端用文件名和Chunk索引作为key缓存这些信息。 之后客户端发送请求到其中的一个副本处，一般会选择最近的。请求信息包含了Chunk的标识和字节范围。在对这个Chunk的后续读取操作中，客户端不必再和Master节点通讯了，除非缓存的元数据信息过期或者文件被重新打开。 三、Chunk尺寸的设定 Chunk的大小是关键的设计参数之一。选择64MB这个较大尺寸有几个重要的优点。首先，它减少了客户端和Master节点通讯的需求，因为只需要一次和Mater节点的通信就可以获
云计算实例分析：Google的云计算平台 2010-01-10 17:23 Google的云计算技术实际上是针对Google特定的网络应用程序而定制的。针对内部网络数据规模超大的特点，Google提出了一整套基于分布式并行集群方式的基础架构，利用软件的能力来处理集群中经常 发生的节点失效问题。 从2003年开始，Google连续几年在计算机系统研究领域的最顶级会议与杂志上发表论文，揭示其内部的分布式数据处理方法，向外界展示其使用的云计算核心技术。从其近几年发表的论文来看，Google使用的云计算基础架构模式包括四个相互独立又紧密结合在一起的系统。包括Google建立在集群之上的文件系统Google File System，针对Google应用程序的特点提出的Map/Reduce编程模式，分布式的锁机制Chubby以及Google开发的模型简化的大规模分布式数据库BigTable。 Google File System 文件系统 为了满足Google迅速增长的数据处理需求，Google设计并实现了Google文件系统（GFS，Google File System）。GFS与过去的分布式文件系统拥有许多相同的目标，例如性能、可伸缩性、可靠性以及可用性。然而，它的设计还受到Google应用负载和技术环境的影响。主要体现在以下四个方面: 1. 集群中的节点失效是一种常态，而不是一种异常。由于参与运算与处理的节点数目非常庞大，通常会使用上千个节点进行共同计算，因此，每时每刻总会有节点处在失效状态。需要通过软件程序模块，监视系统的动态运行状况，侦测错误，并且将容错以及自动恢复系统集成在系统中。 2. Google系统中的文件大小与通常文件系统中的文件大小概念不一样，文件大小通常以G字节计。另外文件系统中的文件含义与通常文件不同，一个大文件可能包含大量数目的通常意义上的小文件。所以，设计预期和参数，例如I/O操作和块尺寸都要重新考虑。 3. Google文件系统中的文件读写模式和传统的文件系统不同。在Google应用（如搜索）中对大部分文件的修改，不是覆盖原有数据，而是在文件尾追加新数据。对文件的随机写是几乎不存在的。对于这类巨大文件的访问模式，客户端对数据块缓存失去了意义，追加操作成为性能优化和原子性（把一个事务看做是一个程序。它要么被完整地执行，要么完全不执行）保证的焦点。 4. 文件系统的某些具体操作不再透明，而且需要应用程序的协助完成，应用程序和文件系统API 的协同设计提高了整个系统的灵活性。例如，放松了对GFS一致性模型的要求，这样不用加重应用程序的负担，就大大简化了文件系统的设计。还引入了原子性的追加操作，这样多个客户端同时进行追加的时候，就不需要额外的同步操作了。 总之，GFS是为Google应用程序本身而设计的。据称，Google已经部署了许多GFS集群。有的集群拥有超过1000个存储节点，超过300T的硬盘空间，被不同机器上的数百个客户端连续不断地频繁访问着。
Google 一、企业简介 Google公司（中文译名：谷歌），是一家美国的跨国科技企业，致力于互联网搜索、云计算、广告技术等领域，开发并提供大量基于互联网的产品与服务，其主要利润来自于AdWords等广告服务。 谷歌的使命是整合全球信息，使人人皆可访问并从中受益。谷歌是第一个被公认为全球最大的搜索引擎，在全球围拥有无数的用户。 二、企业发展 1997年到1998年间，谷歌联合创始人拉里·佩奇和尔盖·布林在学生宿舍里共同开发了全新的在线搜索引擎，之后他们募集了100万美元，在美国加门罗帕克的一间车库筹备公司。成立数天后，公司注册了https://www.doczj.com/doc/1c19057967.html,域名。 1999年6月7日，谷歌获得了两家风险投资公司的投资，一共是2500万美元，这成为谷歌发展的最重要的开始。 2000年，谷歌与雅虎公司达成合作协议，谷歌为雅虎提供搜索引擎服务，使得谷歌开始崭露头角。在此之前，谷歌还未成为搜索行业的主流，当时的行业领头羊仍是雅虎。 2001年，谷歌的网页评级机制PageRank被授予了美国专利。但在互联网激烈的竞争下，仅仅靠出售技术，没有其他盈利方式是远远不够的，于是埃克里·施密特被风投家介绍空降到谷歌，成为公司CEO。
谷歌开始了一个新的时代。谷歌创新的推出了Adwords文字广告——在搜索结果右边附加相关广告，使得谷歌在保持主页简明朴素的同时又能增加广告收入，这是谷歌最核心最成功的赚钱方式。 2006年10月，谷歌公司以16.5亿美元，收购影音容分享YouTube，是谷歌有史以来最大的并购。 2007年11月05日，谷歌宣布基于Linux平台的开源手机操作系统的名称为android。 2008年9月7日，Google Map卫星升空，将为Google Earth提供50厘米分辨率高清照片。同年，谷歌与金融集团汇丰银行（HSBC）以及国际有线电视集团Liberty Global组成名为“O3b Networks”的网络计划，通过发射16颗卫星将网络服务带入地球上还未连上网络的地区，取名为O3b就是指地球上另外未有网络建设的30亿人口，希望借这样的网络计划工程，真正建立在地球上任何区域皆有连网能力的环境。 2012年2月14日，谷歌收购Motorola获欧盟和美国批准。