int  **p1;  //指向指针的指针
    int  *p2;    //指向指针的变量  其中所存储的值为变量的地址，或者变量的地址的地址
    int  i=3;
    p2=&i;
    p1=&p2;
 printf("Hello World!\n"); 
 printf("%d\n",i);  //3
 printf("%d\n",**p1); //3
 printf("%d\n",*p2); //3
 printf("%d\n",&i);  //1245044
 printf("%d\n",*p1);  //1245044
 printf("%d\n",p2);   //1245044
 printf("%d\n",p1);   //1245048
 printf("%d\n",&p2);  //1245048
 printf("%d\n",&p1);  //1245052
 return 0;

架构设计是一个非常大的话题，不管写几篇文章，接触到的始终只是冰山一角，更多的是实践中去体会。这篇文章主要介绍面向对象OO、面向方面AOP和面向服务SOA这三个要素在架构设计中的位置与作用。

架构设计有三个维度，或者说是我们在考虑架构时需要思考三个方向。

这三个维度分别为面向对象、面向方面、面向服务。

这三个维度可以看作是正交的，但不同维度会互相印证，互相支撑，整个架构的示意图如图所示。

图：架构三维度结构图

面向对象

面向对象技术最初是从面向对象的程序设计开始的，它的出现以上世纪60年代Simula语言为标志，并在Smalltalk语言的完善和标准化过程中得到更多的扩展和对以前思想的重新注解。

上世纪80年代中后期，面向对象程序设计逐渐成熟，被计算机界理解和接受，人们又开始进一步考虑面向对象的开发问题。直到现在，面向对象已经成为一种非常流行的编程方式，以及软件设计的架构。

面向对象提出有三个主要目标:重用性、灵活性和扩展性，强调对象的“抽象”、“封装”、“继承”和“多态”。它能让人们以更加接近于现实世界的方式来思考程序，这点可以说是面向对象最大的进步。

在OO思想的运用上，业界出现了很多好的经验与技巧，从而涌现出大量的设计模式，可以说面向对象是系统分析与设计时的一个很重要的方面。

面向方面

面向方面最初来源于hook技术，本质上就是满足扩展的需求，可以在程序中自由扩展功能。

面向方面不仅仅是一门编程技术，同样也是一种架构设计的思路。如果说OO是纵向地分析、切割整个系统，那么可以认为AOP是横向地对系统作切片。

简单地理解，OO与AOP分别从两个不同的角度给我们提供了分析系统的思路。面向方面可以弥补面向对象的缺陷，两种方式有机的结合在一起，可以更加有效地对系统进行分析。

我们认为OO是接近于人类认识自然的思维方式，但对于东方而言却并不一定是这样的。

当西方人看到一个复杂系统的时候，只会有一种思路，就是“分解”，将系统分解成一块一块，然后每个部分进行研究。

当东方人看到一个复杂系统的时候，更多地会关注系统中存在的关系，将系统作为一个有机的整体进行研究，这也是东方和西方在事物看法上存在的差异。

这两种思维方式都没有问题，如果结合起来分析问题，解决问题会更好。面向对象与面向方面也同样如此，都能对应到人类认识自然的思维方式上。

面向服务

面向服务可以说是最近炒得比较火热的概念。包括现在提到的SaaS（Software as a service），软件即服务。准确而言，面向服务不仅仅是软件行业的概念，这个要从社会的产业结构说起。

社会产业总共分为三个，第一产业农业，第二产业工业，第三产业服务业。最早社会的主要产业是第一产业农业，将近有几万年的历史。

十八世纪下半叶在英国开始的工业革命，对人们的生活产生了根本性的影响，社会的主要产业成了第二产业工业。

现在仍然属于工业时代，或者有人说的“后工业时代”。而在后工业时代，社会的经济体制必定要向第三产业服务业逐渐转型。面向服务其实是社会经济体制重心的一种迁移。

还是说回到软件行业，社会的主要产业将转变成服务业，自然软件行业也会出现对应的变化，那就是这里提到的面向服务。面向服务今后会影响到软件的交付模式，会对整个软件行业的体制产生影响。

而说到架构层面，面向服务是系统发布功能的一种方式。并且基于这种方式下不同的系统之间能有效地通信、协作。常见的实现技术就是Web Service。

软件全局观

软件架构设计的三个维度：面向对象、面向方面、面向服务。

最年长的一个维度就是面向对象，发展了好几十年，也是相对而言比较成熟的一个维度。它解决的问题是系统内部结构的设计。

面向方面思想的提出能够弥补面向对象的缺陷。面向对象的方式不能实现横切关注点的分离，而面向方面正是为了解决这个问题。面向方面与面向对象一样都是解决系统内部结构的设计。

面向服务更多的是涉及到系统的外部，简单地说就是发布功能。它并不关注系统内部结构的实现，所以说面向服务与面向对象或者面向方面并不冲突。

这三个维度并不是绝对孤立的，它们之间会互相影响、制约，相互发展的。我们在分析架构的时候需要同时考虑到这三个维度的问题，这样有助于我们设计出更加优秀的架构。

    if(!/^[a-zA-Z0-9]{6,15}$/.test($('oldpwd').value)){  正则，6-15 位的字母或者数字

(^$)|(^\w{5,11}$)   为空或者 5-10为字符

十几年软件研发的沧桑岁月，和一度险濒于破产的痛苦经历，让俺对软件产品开发有了更深层的体会。新年到来之际，写出来和大家作个交流。

一、农业境界

　　刚参加工作，朋友问我，你能用电脑干啥？我口出狂言，只要你想得出来的，我都能做得到。其实，我说这话相当无知。

　　柏拉图曾经说过，人的知识犹如一个圆，圆内是你已经知道的，圆外是你还不知道的，圆周就是你已经知道的还没解决的问题。你的知识越丰富，这个圆就越大，圆的周长也越长，也就是你知道的没解决的问题也越多。

　　如果你觉得自己没有啥问题，就说明你很无知。

　　无数年轻人就是凭自己的热情，初生牛犊不怕虎的冲劲，在完全没有经验和章法的情况下，投入了不会取得胜利的第一场战斗。通俗一点讲，就是试图用垒狗窝的技术建高楼大厦。

　　企业在这个阶段，充其量就是个手工作坊。有人说，我的研发团队上百号人呢。对不起，您是否出于这个阶段和企业人数没多大关系。

二、工业境界

　　了解到软件产品设计研发是一个复杂的系统工程，很多人会尝试运用一些必要的技术把复杂系统分解成简单子系统。在这个阶段，一些软件工程理论开始逐步被吸收。这包括：

　　面向对象的设计思想

　　UML、RUP、XP编程、设计模式等软件工程理论和工具

　　组件化系统设计——COM、DCOM、ActiveX、Corba、WebServices等技术开始进入产品设计

　　简单地讲，已经知道如何把高楼大厦拆解成多个狗窝，化繁为简；已经懂得遵循软件工业标准开发能重用的系统组件。

　　很多人以为已经到达软件研发的终点，掌握了终极的技术手段。然而，这只是软件产品研发的启蒙阶段，随着发现更多并解决深层次的问题，你需要更有效的理论提升你对软件产品开发的驾驭能力。

三、数学境界

　　工业化境界提供了化繁为简的技术支撑和思路，但是，好的工具并不能保证出现正确的设计。

　　我们学习解一元二次方程的时候，什么十字相乘法、配方法等等，开始会学习很多技巧性的解法。这类似工业化境界——让你把复杂问题分解转化成更简单的问题。但是，这些技巧不总是有效，最终的解决方案还是推导出求解公式，彻底解决此类问题。

　　软件产品设计是否存在从需求到代码的求解公式呢？这是一个已经被研究半个世纪的课题了，可惜国内99%的软件研发人员并不了解这方面的进展。等到洋人的坚船利炮打到你家门口的时候，你才发现人家用这么好的技术武装自己，那就为时太晚了。

　　在这个阶段，你会用数学方法保障软件系统设计的正确性。你可能会把下面这些理论引入你的设计过程：

　　在系统设计中自觉运行有限状态机、Petri网等数学模型去设计、分析系统结构。

　　引进诸如净室技术、B方法、Z语言等形式化软件工程技术，确保系统设计的正确性。

　　最后你会发现，软件产品设计真正是一件严格科学过程，如果以山野村夫的心态做这件事情，最终必然一塌糊涂。

四、艺术境界

　　人本质上是非理性的动物，我们为人类设计产品的最终目标不是为了正确，因此，数学境界并未把你带到最终目的地。

　　人类还没解决温饱问题的时候，就学会了在岩石上涂鸦，在脖子上挂项链，为人类设计产品，得满足他们这些貌似毫无价值的癖好。

　　因此，在能熟练驾驭正确设计产品的技能之后，软件产品设计将为艺术而战——我们不是在替客户设计干活的工具，相反，我们是在为他们设计一个吸引眼球的超级玩具，一件艺术品。

　　软件产品设计师——你不仅仅是工程师，更进一步，你应该是一名驾驭高科技技术的艺术家！

五、宗教境界

　　阿克毛被枪毙了，他不是为科学而来，亦不是为艺术而来，而是为夺取我们的心灵而来！

　　之所以被枪毙，是因为他采取了文明社会不认可的手段和产品——海洛因。

　　异曲同工，软件产品设计的最高境界亦是征服客户的心灵，让客户像崇拜上帝一样被您的软件所征服。似乎除了海洛因，能做到这一点的就是宗教了。

　　看看IBM、看看微软、看看Intel、看看苹果，这些超级商业巨人，为了让你把口袋的钱老老实实地掏出来，是不是一个个俨然一副布道者的模样？

 

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/quicmous/archive/2010/01/03/5125373.aspx

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URLDecoder;
import java.util.StringTokenizer;

/*
用Java语言实现HTTP服务器,首先启动一个java.net.ServerSocket在提供服务的端口上监听连接.向客户返回文本时,可以用
PrintWriter,但是如果返回二进制数据,则必须使用OutputStream.write(byte[])方法,返回的应答消息字符串可以使用
String.getBytes()方法转换为字节数组返回,或者使用PrintStream的print()方法写入文本,用
write(byte[])方法写入二进制数据.

以工程所在目录为web的根目录。 在工程的根目录下放一个大概如下的index.html

<!DOCTYPE html PUBLIC "-//WDTD HTML  Transitional//EN"
 * "http://www.wg/TR/htmlose.dtd"> <html> <head> <meta
 * http-equiv="Content-Type" content="text/html; charset=gbk">
 * <title>简单的测试</title> </head> <body> 你好！这是一个 简单的web服务器。<br>
 * 这是一个图片！br>
 *
 * <form action="/index.html"> <img alt="" src="images/test.gif"><br>
 * 姓名：<input type="text" name="name" /><br>
 * 密码：<input type="password" name="pass"></input><br>
 * <input type="submit"/> </form> </body> </html>
 *
 * 放入图片位置： 工程根目录/images/test.gif <br>
 * 打开浏览器输入http://localhost/index.html 可以展示index.html
 *
 * @author guazi
 */
public class SimpleHttpServer implements Runnable {

    ServerSocket serverSocket;// 服务器Socket
    /**
     * 服务器监听端口, 默认为
     */
    public static int PORT = 81; // 标准HTTP端口

    /**
     * 开始服务器 Socket 线程.
     */
    public SimpleHttpServer() {
        try {
            serverSocket = new ServerSocket(PORT);
        } catch (Exception e) {
            System.out.println("无法启动HTTP服务器:" + e.getMessage());
        }
        if (serverSocket == null) {
            System.exit(0);
        }

        new Thread(this).start();
        System.out.println("HTTP服务器正在运行,端口:" + PORT);
    }

    /**
     * 运行服务器主线程, 监听客户端请求并返回响应.
     */
    public void run() {
        while (true) {
            try {
                Socket client = null;// 客户Socket
                client = serverSocket.accept();// 客户机(这里是 IE 等浏览器)已经连接到当前服务器
                if (client != null) {
                    System.out.println("连接到服务器的用户:" + client);
                    try {
                        // 第一阶段: 打开输入流
                        BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));

                        System.out.println("客户端发送的请求信息: ***************");
                        // 读取第一行, 请求地址
                        System.out.println("http协议头部信息：");

                        String line = in.readLine();
                        System.out.println("开始："+line+"结束");
                        String resource = line.substring(line.indexOf('/'), line.lastIndexOf('/') - 5);
                        // 获得请求的资源的地址
                        resource = URLDecoder.decode(resource, "gbk");// 反编码

                        String method = new StringTokenizer(line).nextElement().toString();// 获取请求方法, GET 或者 POST

                        // 读取浏览器发送过来的请求参数头部信息
                        while ((line = in.readLine()) != null) {
                            System.out.println(line);

                            if (line.equals("")) {
                                break;
                            }
                        }

                        System.out.println("http协议头部结束 ***************");
                        System.out.println("用户请求的资源是:" + resource);
                        System.out.println("请求的类型是: " + method);

                        String params = null;

                        if (resource.indexOf("?") > -1) {
                            params = resource.substring(resource.indexOf("?") + 1);
                            resource = resource.substring(0, resource.indexOf("?"));
                        }

                        // 显示 POST 表单提交的内容, 这个内容位于请求的主体部分
                        if ("POST".equalsIgnoreCase(method)) {
                            if (params != null) {
                                params += "&" + in.readLine();
                            } else {
                                params = in.readLine();
                            }
                        }

                        System.out.println("打印提交的数据：");
                        printParams(params);

                        // 读取资源并返回给客户端
                        fileReaderAndReturn(resource, client);
                        // 关闭客户端链接
                        client.close();
                        System.out.println("客户端返回完成！");
                    } catch (Exception e) {
                        System.out.println("HTTP服务器错误:" + e.getMessage());
                    }
                }

            } catch (Exception e) {
                System.out.println("HTTP服务器错误:" + e.getMessage());
            }
        }
    }

    /**
     * 读取一个文件的内容并返回给浏览器端.
     *
     * @param fileName
     *            文件名
     * @param socket
     *            客户端 socket.
     * @throws IOException
     */
    void fileReaderAndReturn(String fileName, Socket socket) throws IOException {
        if ("/".equals(fileName)) {// 设置欢迎页面，呵呵！
            fileName = "/index.html";
        }
        fileName = fileName.substring(1);
        PrintStream out = new PrintStream(socket.getOutputStream(), true);
        File fileToSend = new File(fileName);

        String fileEx = fileName.substring(fileName.indexOf(".") + 1);
        String contentType = null;
        // 设置返回的内容类型
        // 此处的类型与tomcat/conf/web.xml中配置的mime-mapping类型是一致的。测试之用，就写这么几个。
        if ("htmlhtmxml".indexOf(fileEx) > -1) {
            contentType = "text/html;charset=GBK";
        } else if ("jpegjpggifbpmpng".indexOf(fileEx) > -1) {
            contentType = "application/binary";
        }
        if (fileToSend.exists() && !fileToSend.isDirectory()) {
            // http 协议返回头
            out.println("HTTP/1.0 200 OK");// 返回应答消息,并结束应答
            out.println("Content-Type:" + contentType);
            out.println("Content-Length:" + fileToSend.length());// 返回内容字节数
            out.println();// 根据 HTTP 协议, 空行将结束头信息

            FileInputStream fis = null;
            try {
                fis = new FileInputStream(fileToSend);
            } catch (FileNotFoundException e) {
                out.println("<h1>404错误！</h1>" + e.getMessage());
            }
            byte data[];
            try {
                data = new byte[fis.available()];

                fis.read(data);
                out.write(data);
            } catch (IOException e) {
                out.println("<h1>500错误!</h1>" + e.getMessage());
                e.printStackTrace();
            } finally {
                out.close();
                try {
                    fis.close();
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        } else {
            out.println("<h1>404错误！</h1>" + "文件没有找到");
            out.close();

        }

    }

    void printParams(String params) throws IOException {
        if (params == null) {
            return;
        }
        String[] maps = params.split("&");
        for (String temp : maps) {
            String[] map = temp.split("=");
            System.out.println(map[0] + "==" + map[1]);
        }
    }

    /**
     * 启动 HTTP 服务器
     *
     * @param args
     */
    public static void main(String[] args) {
        try {
            if (args.length != 1) {
                System.out.println("这是一个简单的web服务器 ，端口是： 80.");
            } else if (args.length == 1) {
                PORT = Integer.parseInt(args[0]);
            }
        } catch (Exception ex) {
            System.err.println("服务器初始化错误" + ex.getMessage());
        }

        new SimpleHttpServer();

    }
}

在python中import this就会展示出The Zen of Python如下： The Zen of Python, by Tim Peters Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. Special cases aren't special enough to break the rules. Although practicality beats purity. Errors should never pass silently. Unless explicitly silenced. In the face of ambiguity, refuse the temptation to guess. There should be one-- and preferably only one --obvious way to do it. Although that way may not be obvious at first unless you're Dutch. Now is better than never. Although never is often better than *right* now. If the implementation is hard to explain, it's a bad idea. If the implementation is easy to explain, it may be a good idea. Namespaces are one honking great idea -- let's do more of those! 从网上搜寻了一下，这被称为python之禅，以下是翻译 Python之禅 赖勇浩翻译 优美胜于丑陋（Python 以编写优美的代码为目标） 明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似） 简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现） 复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁） 扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套） 间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题） 可读性很重要（优美的代码是可读的） 即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上） 不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写 except:pass 风格的代码） 当存在多种可能，不要尝试去猜测 而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法） 虽然这并不容易，因为你不是 Python 之父（这里的 Dutch 是指 Guido ） 做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量） 如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准） 命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）   The Zen of Python, 蛇宗三字经 作者：Tim Peters 翻译：元创 Beautiful is better than ugly. 美胜丑 Explicit is better than implicit. 明胜暗 Simple is better than complex. 简胜复 Complex is better than complicated. 复胜杂 Flat is better than nested. 浅胜深 Sparse is better than dense. 疏胜密 Readability counts. 辞达意 Special cases aren't special enough to break the rules. 不逾矩 Although practicality beats purity. 弃至清 Errors should never pass silently. 无阴差 Unless explicitly silenced. 有阳错 In the face of ambiguity, refuse the temptation to guess. 拒疑数 There should be one-- and preferably only one --obvious way to do it. 求完一 Although that way may not be obvious at first unless you're Dutch. 虽不至，向往之 Now is better than never. 敏于行 Although never is often better than *right* now. 戒莽撞 If the implementation is hard to explain, it's a bad idea. 差难言 If the implementation is easy to explain, it may be a good idea. 好易说 Namespaces are one honking great idea -- let's do more of those! 每师出，多有名 比较恶搞的是，其实 this 模块的代码完全违背了这些原则，为了方便你查看它的代码，我把它贴出来： s = """Gur Mra bs Clguba, ol Gvz Crgref Ornhgvshy vf orggre guna htyl. Rkcyvpvg vf orggre guna vzcyvpvg. Fvzcyr vf orggre guna pbzcyrk. Pbzcyrk vf orggre guna pbzcyvpngrq. Syng vf orggre guna arfgrq. Fcnefr vf orggre guna qrafr. Ernqnovyvgl pbhagf. Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf. Nygubhtu cenpgvpnyvgl orngf chevgl. Reebef fubhyq arire cnff fvyragyl. Hayrff rkcyvpvgyl fvyraprq. Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff. Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb qb vg. Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgpu. Abj vf orggre guna arire. Nygubhtu arire vf bsgra orggre guna *evtug* abj. Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn. Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn. Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!""" d = {} for c in (65, 97):     for i in range(26):         d[chr(i+c)] = chr((i+13) % 26 + c) print "".join([d.get(c, c) for c in s]) 这段晦涩、复杂、凌乱的代码，莫非是 Tim Peters 提供的反例？

再谈如何成为技术领袖

——技术不是充分条件

被访者：IBM软件集团两岸三地大中华区
总工程师  寇卫东

文/卢鸫翔

要想成为一名优秀的技术领袖，需要具备哪些方面的素质？我在IBM辅导很多年轻同事，如何才能帮助他们在职业生涯中成长为技术领军人物？是否只要拥有了过硬的技术本领，就能成为技术领袖？许多年轻的朋友技术拔尖，然而却觉得没有得到领导的赏识， 这又是什么原因呢？我常常都在思考这些问题。去年这个时候，我同读者朋友们分享了一些心得，我想结合自己多年的高校教育和IT从业经验，再同大家谈谈这一话题。

1.我很清楚地告诉大家，要成为技术领袖，技术是必要条件，但不是充分条件。如果一个人技术基础不够扎实，他几乎等同外行，领导其他技术人员不说没有可能，但至少会相当困难。另一方面我们在国内外都能看到不少拔尖的技术人员，有的是一流的科学家，有的是一流的技术专才，可一旦把他们放在领导岗位上，却都以失败告终。他们虽然技术出色，但是没有当领袖的能力，工作中四处碰壁，缺乏凝聚力，不得人心。

2.要成为技术领袖就要清楚公司的业务，知道技术应当如何配合业务需求。作为技术领袖，只有做到这点，才能使公司业务有大的发展，才会得到高层领导的认同。如果你只懂技术而不懂公司业务，或者你在大学工作而不懂领导教学科研，是没有办法胜任技术领袖的。我们钻研技术的朋友往往忽略了这一点，对某项技术非常专注，但是两耳不闻窗外事，没有把注意力放到公司的发展需求上来。

为了更好地协调个人职业发展与企业业务发展，需要处理好工作的优先级，分清主次。在日常工作当中，我常常为同事画下面这幅图，帮助他们进行分析。

如果有一项工作摆在面前，我们如何定义它的重要性，应该花多少力气去做？我们可以通过象限分析找出答案。第I象限表示此项工作对企业业务发展和个人职业发展都很重要，这是最完美的结合，优先级应该放在最高级。我们在企业中应该多做此类工作。第II象限表示此项工作对企业业务非常重要，但是对个人目前的职业发展看似并不特别重要。我们要以企业的利益为重，所以优先级应该放在第二位。第III象限表示此项工作对个人职业发展很重要，但是对企业业务发展不那么重要，我们应该把它放在第三位。第IV象限表示此项工作对企业业务发展和个人职业发展都不重要，优先级应该是最低的。对这类工作，自己最好不做或者少做；就是做，也应该尽可能少花时间去做；或是请其他同事去做，因为对你的个人职业发展不重要的工作不等于对其他同事的个人职业发展也不重要，换言之，此项工作可能对其他同事的个人职业发展很重要呢。

许多企业都在创造一种文化，希望能将企业业务发展和员工的个人职业发展紧密结合起来，尽管有时候很难兼顾。作为一名领袖人物，他一定更多地在关注大局，而不是仅仅看到自己。关注大局的人会处处从公司的业务、公司的需求出发。在实际工作中我们常常可以看到，一个真正把大局放在第一位的人，即便今天不是领袖，明天也一定非他莫属。现在的领导不欣赏，将来必会为其他领导所赏识。

3.一个能把握大局的人需要具备很多能力，其中非常重要的一项就是我下面要谈到的第三点——决策力。作为技术领袖，要有坚强的领导能力，敢于面对各种困难的挑战，敢于决断。有些人天生就有准确的决策能力，而更多人需要靠后天来培养。

在我的孩子还小的时候，我就给他灌输这种思想，培养锻炼他。如果他要问我，我就让他自己做决定，不论决定是对是错、是好是坏，在我看来都是正确的。因为最大的错误是该做决定时你举棋不定。再举一个例子，美国前总统布什刚刚上任的时候，很多人批评他没有总统的风范，但是经过几年的洗礼他的确拥有了总统的气质。原因又是什么呢？因为那个职位训练了他，很多情况他必须要做出决策。

对于程序员来说，虽然无法像领导那样做重大的决定，但仍然可以在自己的范围内做出决策。例如使用什么样的技术手段， 采用何种算法实现， 选择哪种数据结构，如何撰写文档，同谁一起合作，这些并不一定非要等老板或者构架师来判断。大家应该有意识地锻炼自己，慢慢成长，直到将来能够领导大的项目。每个人不可能一开始就能对一个完整的系统做出决策，可是如果不从当程序员的时候就开始锻炼自己，将来也做不了。

面对决策失败可能带来的后果，我们应该学会坦然面对，学会承担。如果不去做决策，不愿承担责任，就永远无法取得进步，无法获得做技术领袖的能力。

4.要想成为技术领袖必须有远见，有智慧。有远见有智慧的人才能有承担。我有一个在加拿大的同事，开始的时候只是一般的技术人员，很短的时间内就变成经理，再后来没有经过多长时间又被提升为主管。原因很简单：他有远见，并且有足够的智慧知道应该如何去做。像他这样的员工虽然刚开始的职位很低，但是公司领导觉得这样的人才对公司将来的发展大有帮助，另外，如果这样的员工离职，不但是公司的损失，还会助长竞争对手的实力。所以公司一旦有职位就会提升这样的员工。我们作为技术人员也是一样的道理，面对一套大的系统方案，只有穿透障碍看到未来，才有机会获得提升，成为技术领袖。

5.成为技术领袖需要自信、自觉和自律。自信，这和领导能力有关，没自信怎么来领导别人呢？自觉包含两个方面的内容：自我感知和自我解嘲。自我感知是要对自己有一个正确的评价，“人贵有自知之明”——我们老祖宗都这样讲。有些人不知道自己的情况，要么估计过低，要么估计过高，对自己没有一个公正的评价。很多事情要靠下意识的感觉，你可能并不知道具体发生了什么事情，但是凭感觉就能判断出对错。自嘲是能给自己台阶下，这很重要，往往很多人都做不到，一不小心就陷入骑虎难下的境地。另外对自己有一个正确的评价，才不会弄得自己下不来台。

自律就是要约束自己，保持良好的品行。自律不是做给别人看，也不是做给领导看，而是为自己而做。每个人心中都应该有把标尺，衡量什么事情该做，什么事情不该做。自律很关键，年轻人尤其应该加以重视。有好的人品才会得到大家信任，如果不自律，没有良好的品行，有谁会对他心悦诚服，又怎样来做大家的榜样呢？

6.勇于承担，敢于付出。也就是说一个人的工作既不是为了金钱，也不是为了名誉，单单只是为了实现自己人生的价值，获得成功。自己驱动自己，不畏艰难险阻，不达目的誓不罢休。不愿意承担，不愿意付出，处处计较得失的人是没有办法成为领袖的。

这里所说的成功，并非单纯的职位上的成功，还包括技术上的成功，做人的成功等。其中做人的成功最重要，往往却被最多的人所忽视。职位只不过是领导给的一个头衔，技术领袖所具有的影响力并不是单单靠领导所给的头衔就能获得的。不管大公司小公司，很重要的一点就是先做人。我认为衡量一个人是否成功，首先看做人，然后看技术，最后才是职位、名誉、金钱。而且往往人和技术做好了，金钱名誉就会随之而来。正如诺贝尔奖得主们无一人不是勤勤恳恳做事，假使一开始就想着名誉、奖金，或许他们永远都无法取得举世瞩目的成就。

成功是一个很宽泛的概念，如何衡量成功是因人而异的。一般来说，成功是一个正态分布的频谱，不是一个单脉冲。有些人拥有很高的职位、很丰厚的收入，但却没有家庭、没有生活，因为他们把所有心思都放在了工作上，最终获得了事业上的成功，一个脉冲式的成功。相对他们的度量标准来说是成功了，然而对另一些人来说，他们并不成功、或者不值得效仿。因为事业成功只是一方面，除了工作，我们还有生活，还有家庭的维系、子女的教育、八小时后的个人爱好。一个和谐的成功是一个频谱式的成功：也许没有哪一方面是特别突出的，但是有几个方面是相当好的，其他方面也还可以，这样综合来看是最好的。

7.能领会别人的感觉和想法，会与他人相处。一个拥有领袖潜质的人，往往能够很快感知周围的氛围，别人的感受，他能够通过简单的语言、位置调整，使大家轻松舒服地投入工作。

8.能把大家团结起来，人气旺。很多时候，某个人并不是领导，但是大家都愿意听他的话，成了无冕之王，这样的人即便现在不是，将来也必然会成为领袖，这只是时间的问题。

读者朋友们大多都是技术人员，但是大家不要被技术所束缚。我年轻的时候也走过弯路，希望这些心得体会能对年轻的朋友们有所帮助。成为技术领袖并非遥不可及，只需要比别人多付出一点坚定和执著，多注重先做人后做事。

观察者模式可以参考邮件订阅的例子 邮件订阅设计到2个主要角色，一个是订阅者(观察者)，一个是发布者 发布者可以拥有一个观察者的集合，可以添加，删除观察者，当发布者发布一个新的消息时，要邮件通知观察者集合中的每一个。 所以，发布者实现的接口至少应具备三个方法，即注册观察者，注销观察者，通知观察者。 通知有两种方式，一种是推(push)，一种是拉（pull）. 推，即发布者通过调用观察者提供的接口，来告之所有的变动（比如新增一个消息），主动推送给观察者。 拉，及观察者可以按需提取所要接受的数据，而不是全盘接受，主要体现在程序自己主动调用观察者的传值接口，而区别于推由发布者来调用，此时，需要这个借口中的参数包含发布者对象，让程序知道扫描变动来自于哪个发布者。 JDK中内置了观察者模式，位于java.util包中，一个接口Observer，一个类Observable，将这两个类组合起来使用，既可以推，又可以拉。 一个普通的类，如果继承了Observable，就成了一个发布者，实现了Observer接口，就成了观察者。 JDK中的观察者模式有一个弊端，就是发布者需要继承一个类，而不是实现一个接口，如果需要成为发布者的类已经集成了一个类，就不能再继承Observable了。这时候，就需要自己来设计一种观察者模式了。 JDK 中Swing包中，大量运用了观察者模式，所有的组件都继承了JComponent,这就是一个发布者，它里面包含一个监听器的集合：EventListenerList，用户可以自定义一个监听器，然后添加到一个组件中的时候，该组件就会把这个监听器注册到 EventListenerList中，相当于添加了一个发布者，当用户对组件做出反映时，所有的监听器（发布者）都会收到信息并作出反应。 网上商店中的商品在名称、价格发生变化时，必须自动通知会员，Java的API为我们提供了    Observer接口和Observable类来实现所谓观察者模式。Observable(可观察者）类允许在自身发生改变时，通知其它对象（实现接口Observer，观察者）。    下面是一个可观察者（产品类）： import java.util.*; public class product extends Observable{ 　　 private String name;////产品名 　　 private float price;////价格 　　 public String getName(){ return name;} 　　 public void setName(String name){ 　　 this.name=name; 　　 ////设置变化点 　　 setChanged(); 　　 notifyObservers(name);////通知观察者 　　 }　　　 　　 public float getPrice(){ return price;} 　　 public void setPrice(float price){ 　　 this.price=price; 　　 ////设置变化点 　　 setChanged(); 　　 notifyObservers(new Float(price)); 　　 } 　　 ////以下可以是数据库更新 插入命令. 　　 public void saveToDb(){ 　　 System.out.println("saveToDb");      } } 下面是两个观察者： import java.util.*; public class NameObserver implements Observer{ 　　 private String name=null; 　　 public void update(Observable obj,Object arg){ 　　　　 if (arg instanceof String){ 　　　　 name=(String)arg; 　　　　 ////产品名称改变值在name中 　　　　 System.out.println("NameObserver :name changet to "+name); 　　　　 }         } 　　 } import java.util.*; public class PriceObserver implements Observer{ 　　 private float price=0; 　　 public void update(Observable obj,Object arg){ 　　　　 if (arg instanceof Float){ 　　　　 price=((Float)arg).floatValue(); 　　 　　　　 System.out.println("PriceObserver :price changet to "+price); 　　　　 } 　　 } } 下面是测试类： public class Test { 　　 public static void main(String args[]){       Product product=new Product();       NameObserver nameobs=new NameObserver();       PriceObserver priceobs=new PriceObserver();       ////加入观察者       product.addObserver(nameobs);       product.addObserver(priceobs);       product.setName("applet");       product.setPrice(9.22f); 　　 } } 运行结果： C:\java>java    Test NameObserver :name changet to applet

     摘要:   Struts2架构图         请求首先通过Filter chain，Filter主要包括ActionContextCleanUp，它主要清理当前线程的ActionContext和Dispatcher；FilterDispatcher主要通过AcionMapper来决定需要调用哪个Action。  &nb...  阅读全文 1、父子二人经过五星级饭店门口，看到一辆十分豪华的进口轿车。 儿子不屑地对他的父亲说：「坐这种车的人，肚子里一定没有学问！」 父亲则轻描淡写地回答：说这种话的人，口袋里一定没有钱 （注：你对事情的看法，是不是也反映出你内心真正的态度？） 2、晚饭后，母亲和女儿一块儿洗碗盘，父亲和儿子在客厅看电视。 突然，厨房里传来打破盘子的响声，然后一片沉寂。 儿子望着他父亲，说道：「一定是妈妈打破的。」 「你怎么知道？」 「她没有骂人」 （注：我们习惯以不同的标准来看人看己，以致往往是责人以严，待己以宽。） 3、有两个台湾观光团到日本伊豆半岛旅游，路况很坏，到处都是坑洞。 其中一位导游连声抱歉，说路面简直像麻子一样。 而另一个导游却诗意盎然地对游客说：诸位先生，我们现在走的这条道路，正是赫赫有名的伊豆迷人酒窝大道。」 （注：虽是同样的情况，然而不同的意念，就会产生不同的态度。思想是何等奇妙的事，如何去想，决定权在你。） 4、同样是小学三年级的学生，在作文中说他们将来的志愿是当小丑。 中国的老师斥之为：「胸无大志，孺子不可教也！」 外国的老师则会说：「愿你把欢笑带给全世界！」 （注：身为长辈的我们，不但容易要求多于鼓励，更狭窄的界定了成功的定义。） 5、有一个欧巴桑在首饰店里看到二只一模一样的手环。一个标价五百五十元，另一个却只标价二百五十元。 她大为心喜，立刻买下二百五十元的手环，得意洋洋的走出店门。 临出去前，听到里面的店员悄悄对另一个店员说：「看吧，这一招屡试不爽。」 (注：试探如饵，可以轻而易举的使许多人显露出贪婪的本性，然而那常常是吃亏受骗的开始。) 6、乞丐：「能不能给我一百块钱？」 路人：「我只有八十块钱。」 乞丐：「那你就欠我二十块钱吧」 （注：有些人总以为是上苍欠他的，老觉得老天爷给的不够多、不够好，贪婪之欲早已取代了感恩之心。） 7、在故宫博物院中，有一个太太不耐烦地对她先生说： 「我说你为甚么走得这么慢。原来你老是停下来看这些东西。」 （注：有人只知道在人生的道路上狂奔，结果失去了观看两旁美丽花朵的机会。） 8、妻子正在厨房炒菜。丈夫在她旁边一直唠叨不停：慢些。小心！火太大了。 赶快把鱼翻过来。快铲起来，油放太多了！把豆腐整平一下。哎唷，锅子歪了！」 「请你住口！」妻子脱口而出，「我懂得怎样炒菜。」 「你当然懂，太太，」丈夫平静地答道：「我只是要让你知道，我在开车时，你在旁边 喋喋不休，我的感觉如何。」 （注：学会体谅他人并不困难，只要你愿意认真地站在对方的角度和立场看问题。） 9、第一名 毕业典礼上，校长宣布全年级第一名的同学上台领奖，可是连续叫了好几声之後，那位学生才慢慢的走上台。 後来，老师问那位学生说：＂怎麽了？是不是生病了？还是没听清楚？＂ 学生答：＂不是的，我是怕其他同学没听清楚。＂ (名与利是多少人的捆绑、多少人的心结？我们被教育要争气、要出头，但是争气出头的，不过是少数人，沉默的大众毕竟还多数。想一想，有那麽多人都和你我一样，不也是很兴奋的一件事吗？） 10、理由充份 一辆载满乘客的公共汽车沿着下坡路快速前进着，有一个人後面紧紧地追赶着这辆车子。 一个乘客从车窗中伸出头来对追车子的人：＂老兄！算啦，你追不上的！＂ ＂我必须追上它，＂这人气喘吁吁地说：＂我是这辆车的司机＂ (有些人必须非常认真努力，因为不这样的话，後果就十分悲惨了！然而也正因为必须全力以赴，潜在的本能和不为人知的特质终将充份展现出来。） 11、原来如此 甲：「新搬来的邻居好可恶，昨天晚上三更半夜、夜深人静之时然跑来猛按我家的门。」 乙：「的确可恶！你有没有马上报警？」「没有。我当他们是疯子，继续吹我的小喇 叭。」 （事出必有因，如果能先看到自己的不是，答案就会不一样。在你面对冲突和争执时,先想一想是否心中有亏，或许很快就能释怀了。） 12、误会 某日，张三在山间小路开车。 正当他悠哉地欣赏美丽风景时，突然迎面开来一辆货车，而且满囗黑牙的司机还摇下窗 户对他大骂一声：＂猪＂ 张三越想越纳闷，也越想越气，於是他也摇下车窗回头大骂：＂你才是猪！＂ 才刚骂完，他便迎头撞上一群过马路的猪。 （不要错误的诠释别人的好意，那只会让自己吃亏，并且使别人受辱。 在不明所以之前，先学会按捺情绪，耐心观察，以免事後生发悔意。） 13、後生可畏 小男孩问爸爸：＂是不是做父亲的总比做儿子的知道得多？＂ 爸爸回答：＂当然啦！＂ 小男孩问：＂电灯是谁发明的？＂ 爸爸：＂是爱迪生。＂ 小男孩又问：＂那爱迪生的爸爸怎麽没有发明电灯？＂ （很奇怪，喜欢倚老卖老的人，特别容易栽跟斗。权威往往只是一个经不起考验的空壳子，尤其在现今这个多元开放的时代。） 14、不必紧张 小明洗澡时不小心吞下一小块肥皂，他的妈妈慌慌张张地打电话向家庭医生求助。 医生说：＂我现在还有几个病人在，可能要半小时後才能赶过去。＂ 小明妈妈说：＂在你来前，我该做甚麽？＂ 医生说：＂给小明喝一杯白开水，然後用力跳一跳，你就可以让小明用嘴巴吹泡泡消磨时间了。＂ （Take it easy!放轻松些，生活何必太紧张？事情既然已经发生了，何不坦然自在的面对。担心不如宽心，穷紧张不如穷开心。） 15、钥匙 一把坚实的大锁挂在大门上，一根铁杆费了九牛二虎之力，还是无法将它撬开。 钥匙来了，他瘦小的身子钻进锁孔，只轻轻一转，大锁就＂啪＂地一声打开了。 铁杆奇怪地问：＂为什麽我费了那麽大力气也打不开，而你却轻而易举地就把它打开了呢？＂ 钥匙说：＂因为我最了解他的心。＂ （每个人的心，都像上了锁的大门，任你再粗的铁棒也撬不开。唯有关怀，才能把自己变成一只细腻的钥匙，进入别人的心中，了解别人。) 中国民企的行销中的沟通，主要是语言方面的沟通，如何与客户有效地交谈是一项很重要的商业技能。 孔子说过：“言不顺，则事不成”。 鬼谷子人际兵法是古代游说技术的集大成者，古代纵横家们就是凭借出色的口才来说服那些帝王将相们的。 据历史记载，苏秦、张仪等纵横家们的口才都是非常出众、且富有煽动性，他们甚至能够将黑的说成白的，没有的说成有的，充满了诡辩的色彩。 今天的商业，以诚信为本无疑是企业发展的根本动力。 行销中与人沟通，完全不讲策略性是不够的，但是颠倒黑白，混淆视听也是不足取的。 语言才华与个人天赋有关，也与一个人的自身修养、知识积累有关，本章重点不是讨论如何提高语言表达的才华，而是从策略性方面来讨论如何提高语言沟通的效果。 对于绝大多数的行销人员来说，如何说话似乎是一件简单得不能够再简单的事情了，但实际上，我们经常会遇到一些行销人员在与客户交谈中所表现出来的幼稚性。 一次，某公司的行销人员拜访一位客户，这位行销人员问客户：“什么时候讨论我们的产品啊？” 客户说：“要下个月。” 行销人员说：“这么久哇，能不能这个月就讨论呢？” 客户说：“这是我们自己的事情，我们愿意什么时候讨论就什么时候讨论！” 这位行销人员并不气馁，又谈起了别的话题：“某某客户已经与我们合作了，你们也应该与我们合作。” 客户说：“某某客户是个小公司，我们是大公司，请你不要用小公司与我们比较！” 也许你会说这是新手们常犯的毛病，那么我曾经听说过这样一个故事：一次，某经理请客户甲吃饭，由于客户甲与客户乙关系很好，于是一起邀来吃饭。 席间，某经理夸夸其谈，说他们公司多大多大，他本人多有本事，如何会做生意云云。 客户乙属于那种爱较真的性情中人，当某经理说道“没有我搞不定的客户”时，客户乙一拍桌子，指着某经理说道：“如果这样说，我你就搞不定！” 果然，到现在某经理也没有搞定客户乙。 某经理不是没有能力，但是讲话太不注意小节，结果造成了不必要的麻烦，实在应该引以为诫。 鬼谷子认为，嘴巴是用来吃饭的，而不是用来乱讲话的，因为言多必失。 在古代，政治斗争十分残酷，因此，官僚们都是以无事少言、缄默其口作为安身立命的准则。 今天，与客户沟通交谈时，注重说话的策略更显重要，因为你说的每一句话，都可能会使客户产生不同的心理反应。 客户是上帝，甚至是被宠坏的上帝，不恰当的话语：——可以令和睦的关系转为生疏；——可以令生疏的关系转为紧张；——可以令紧张的关系转为破裂。 鬼谷子对于语言的沟通提出了许多充满智慧的见解，对于我们从事行销工作很有帮助。 鬼谷子认为，人之常情是：——说出来的话就希望被别人接受；——做出来的事就希望能够成功。 因此，游说的关键在于掌握扬长避短的策略，例如：——我们极力宣传某种行为的利益，是因为我们可以提供这方面的利益；——我们极力宣传某种行为的危害，是因为我们不擅长这种行为的操作；掌握了扬长避短的沟通策略，就可以有针对性地游说人物了：——与精明的人交谈，要思路广博，多方论证，避免纠缠一点不放；——与知识广博的人交谈，要善于抓住重点，辨析事理；——与地位高的人交谈，不要表现出一种自卑的气势；——与自觉富有的人交谈，要从人生意义、社会价值等方面来发挥；——与自觉贫穷的人交谈，要从如何获利的角度来探讨；——与地位低下的交谈，要表现出充分的尊重来；——与有魄力的人交谈，要表现出果敢的一面来；——与愚蠢的人交谈，要从最有说服力的几个要点来反复阐述；针对不同的目标对象，有策略地沟通，东西方自古以来都有类似的看法。 古希腊哲学家亚里士多德认为，说服别人就要研究：——“人类性格”的类型与人类感情之间的关系；——“人类性格”的类型与人类道德之间的关系；——“人类性格”的类型与人物年龄之间的联系；——“人类性格”的类型与人类“命运”如：出身、财产、地位之间的联系；等等。 因此，亚里士多德将人物分为：——“青年型”、——“壮年型”、——“老年型”、——“富人型”、——“权贵型”等类型。 并分别对这些类型的人物进行了详细的心理特征描述，与鬼谷子的观点十分相似。 按照人物的：——性格特征；——社会地位；——职业特点；——年龄状况；——智力水平；——气质风格；——经济条件，等内容。 将这些特征、条件综合起来，针对不同的目标个体，采取个性化的沟通策略，无疑是古今不变的沟通秘诀。 除了针对不同的目标人物，采劝看人下菜碟”式的沟通策略外，鬼谷子对于语言沟通的表达形式也做了深入的研究。 例如，语言沟通的三种常见形式是：——陈述观点、——回答问题、——提出反驳。 对于这三种常见的沟通形式，掌握了基本的操作要领，可以有效地与人物沟通，而不会犯下无谓的错误。 下面分别介绍：1、陈述观点鬼谷子认为，与人物沟通，是为了说服别人接受自己的观点，并认同自己。而要达到这样的目的，一定要注意采取有利于对方的沟通方式，令对方觉得所陈述的观点、主张确实有利于对方，是对方所需要的。 这一观点在今天看来，是行销常识了。 诉诸利益，是行销过程中最关键的环节，如果你所诉诸的利益确实是对方所需要的、或最感兴趣的，那么行销就成功一大半了。 然而，对于利益的陈述，不是简单地将利益讲清楚就可以了，还需要在沟通中作进一步地修饰。 鬼谷子式语言沟通的特点是，与人物交谈犹如炒菜，加减佐料，完全视人物的口味来调整，但是菜的性质并没有改变。 现在一些公司要求行销人员学会背诵固定的销售台词，如果行销人员不会临场发挥，只是一味机械地照本宣科，其行销效果如何就不必多说了。 2、回答问题鬼谷子认为，回答问题的要领在于简单明了，尽量不要过于随便地发挥，更不要轻易地表态。 在鬼谷子智能行销工具中，回答客户问题的内容完全是策略上的需要，而不是想怎么说就怎么说，要注意说话的场合与背景。 例如，在回答客户的问题时，有的人生怕回答得不够详细，恨不得把所知道的全都讲出来，这其实是很愚蠢的：——一方面言多必失，话说多了，可能会导致相反的效果；——另一方面，讲得越多，客户对你的心理透视也越深入，就会很被动。 因此，行销中点到为止式的回答技巧是鬼谷子所推崇的。观察那些行销高手们说话，虽然表面上看起来似乎轻松随意，但是仔细分析，你会发现：他们所讲的每句话，并不是随随便便地脱口而说的，而是设下了很多前提，埋下了很多伏笔。 3、提出反驳在鬼谷子看来，提出反驳，目的不在于因此而说服对方，相反，却是一种试探人物心理虚实的策略。 鬼谷子认为，反驳别人的观点，不是说服别人的最好办法，却是了解别人真实想法的有效办法。 行销中，与客户沟通不是举行辩论赛，说服客户不是靠论理明确、论据充分，而是靠客户心甘情愿的认同。 记住，与客户洽谈生意，谈的不是道理，而是合作。道理只是形式，合作才是根本。你把客户说服了并不能够获得合作，你把客户说得心动了才能够获得合作。 因此，鬼谷子反对用反驳的方式来证明自己、打击客户（当然，与竞争对手较量时适当的反驳会很重要），却主张用反驳的方式来刺激对方，从而获得更多的信息。 需要说明的是，鬼谷子的这些语言表达的要领，只适合特定情形下的沟通，而不适合学术辩论会等形式的沟通，因而其特殊的沟通思维方式，与人们平时的习惯性思维是有区别的。 一些人总搞不清楚的是：在不同的环境与情形中，语言沟通的特点是不同的。 甚至有些人以为只要掌握了辩论赛式的口才就足以应付行销工作了，殊不知，有时候这种辩论赛式的语言表达不但于事无补，反而可能会“火上浇油”，令沟通无法有效展开。 鬼谷子式语言表达形式的另一个特点，就是强调语言表达方式的策略性，这种策略性根据我们在行销中的体会，主要表现为：——幽默性、——奇特性等内容。 正如有学者说所言：“当谋略靠幽默的语言来实现时，这幽默的语言本身就是谋略，谋略就是幽默的语言，二者是统一的……幽默的语言必定是精炼含蓄的语言，妙趣横生的语言。”（刘建国《谋略初论》）鬼谷子也认为：——语言的表达贵在奇特性。 下面，我们从将从语言表达的——幽默性、——奇特性两方面来具体分析：1、行销言语的幽默性行销中，与客户沟通，语言的幽默性是十分重要的，因为幽默具有艺术性的含蓄与夸张等特点：——含蓄是幽默的深层；——夸张则是幽默的表层。 含蓄的语言往往暗示性较强，更容易令客户在心里上接受，许多难以用道理说明的事情，用含蓄的幽默表达方式会更方便些。 夸张的语言风格，虽然会导致逻辑上的荒谬，但是却更容易启发客户领悟到荒谬背后的真相，而不至于伤害彼此感情。 同时，夸张还带有某种证明性，可以更吸引他人的注意。 记得有一部外国电影，其中有这样一个情节：一个人当街推销领带，这位老兄在大街上侃侃而谈：“女士们，先生们，现在是卫星发射的时代！”（观众笑）这位老兄更加得意了：“我的领带质量非常的好，昨天我就发射了一条，到现在还没有回收呢！”（观众大笑）幽默感强的行销高手们，往往以自我嘲讽的方式来回避客户的刁难，既避免了难堪，却又不伤和气。 2、行销言语的奇特性策略性语言的另一个特点是语言的奇特性，这种语言风格的奇特性虽然也部分地包含在幽默当中了，却具有更广阔的发挥空间。 语言的奇特性，是指与人们的习惯思维、常识认知等相违背的，一种非常规的、独特的表达方式，其目的是制造出一种出人意料的戏剧性效果。 这种戏剧性的效果，可以令客户的兴趣指数在极短的时间内迅速扩大数倍，将客户的重视程度迅速放大数倍，从而为工作的开展打下良好的基矗需要注意的是，实践中语言的幽默性与奇特性发挥是有一定限度的，过分地追求语言的幽默性与奇特性，有时候反而会影响沟通的效果。 某公司的经理与业务员拜访客户，这位经理开玩笑说：“我代表我们公司来贵单位拜访，是想关心关心你们。” 不料，这位客户今天的心情并不好，于是脸一沉地说：“我很忙，你们给我出去！” 搞得这位经理一脸的难堪。 鬼谷子不愧是语言表达的专家，除了针对不同的语言表达方式提出了应对策略外，还提出了几种可以产生不同效果的语言表达系列套餐。 鬼谷子认为，运用语言来获得他人的喜欢与重视，需要学会：——佞言；——谀言；——平言；——戚言；——静言等五种表达技巧。 因为：——佞言可以表现你的忠诚；——谀言可以表现你的智慧；——平言可以表现你的果断；——戚言可以表现你的可信性；——静言可以表现你的权威性。 对于今天的人们来说，佞言、谀言等都带有贬义色彩，其实鬼谷子的思维方式与今天的思维方式是有所区别的，正如鬼谷子强调“阴谋”，在鬼谷子的字典里“阴谋”是隐性策略的意思，而不是今天汉语中“阴谋诡计”的贬义解释。 上述的五种语言技巧，其功能主要是表现出你的：——忠诚；——智慧；——果断；——可信性；——权威性。 这是五种含有浓厚包装色彩的语言表达技巧，目的是获得他人的好感，或者展示个人魅力以及能力。 当然，究竟向客户表达出你的哪些优点，还需要视具体情况来定。 例如：——如果客户需要你是个忠诚、可信的人，就需要运用语言的策略性来表现出这方面的优点；——如果客户需要你的建议具有权威性，就需要运用语言的策略性来表现出你这方面的优点；等等。 那么，如何具体操作呢？ 1、“忠诚”的语言表达技巧操作要领：预先知道客户的意图、需求，只要顺着客户的意图、需求来说话，经过一段时间后，就可以令客户欣赏你的为人了，因为你们的想法与需求是如此的一致。 回顾一下你周围的朋友，你觉得对你最忠诚的朋友是哪些？他们有什么样的特征？ 经过思考，你会发现，你认为对你最忠心的朋友，一定是那些最能理解你、并总是和你的行事意图相一致的人。 他们凭什么获得了你的好感呢？ 很简单，他们的想法总是与你保持高度的一致，而很少会违背你的意愿。 2、“智慧”的语言表达技巧操作要领：在论述、发表意见时，要表现出你的知识渊博来。虽然你的智慧程度与你的知识面可能无法划等号，但是，在你的客户看来，你广博的知识往往会给客户留下智慧的印象。 行销中，智慧的表现方式不是要求你就某个人生命题讲解得十分透彻，这样很难，而且你的大多数客户也没有这个雅兴，他们中很多是普通人。 因此，只要平时能够表现出你广博的知识面来，就可以给客户一个充满智慧的印象，并开始重视你的为人。 3、“果断”的语言表达技巧操作要领：果断是自信的表现；优柔寡断是不自信的表现。 你的果断表现在：——你的是非观念是否分明？ ——你的判断依据是否符合逻辑？ ——你的分析能力是否可以洞察问题的本质？ 等等。 你平时与客户交流中，如果所作的分析，常常可以洞察事物的本质，并且针对这些分析，可以做出较明确的判断。 那么一段时间后，你在客户心目中无疑会留下十分果断的印象。 4、“可信性”的语言表达技巧操作要领：你的观点是否可信，在于你的证据是否可信，你的论证是否符合逻辑。这需要你列举出一些有说服力的证据，通过论证的方式，将各种方案的优劣、长短逐一比较分析，并从中优选出最佳的方案来。 摆事实，讲道理，这是说服客户最有效的办法。 任何客户都具有精明、理智的一面，如果你能够通过有力证据、有说服力的方案而获得客户的认可，一段时间后，客户对于你的建议的可信性自然提高许多。 5、“权威性”的语言表达技巧操作要领：树立权威的最好办法就是找出其他待选方案的缺点与不足，通过这些比较，自然可以建立起自己的权威性来。当然，有时候如果能够找出权威性的依据自然更好。 所谓“打击别人，抬高自己”。 古代纵横家们，往往善于玩弄诡辩伎俩，无限夸大竞争对手或竞争方案的缺点，同时无限夸大自己方案的优点，通过对于异己力量的打击与自我吹捧，达到树立权威的目的。 当然，这种作法即使一时得逞，终究会被人揭穿的。 行销中，我们主张以诚信为本，对于一些有根有据的东西，可以适当地宣传，但不要超出一个度，否则适得其反。 以上，我们介绍了鬼谷子式语言策略的五个自我表现技巧，对于我们从事行销工作有很大帮助，因为从：——忠诚；——智慧；——果断；——可信性；——权威性五个方面来表现自己，可以在一定程度上获得客户的欣赏与重视，这也是你提高个人魅力的一个有效办法。 但是，客户是很现实的，他们最终还是要通过行动来考核你。 因此，语言表达的威力充其量只是你行销的一个辅助性工具，你还需要不断地用你的行动来“说话”。 以上，我们从策略性的角度将鬼谷子的语言表达艺术做了一点总结，中国古代纵横家们的口才是中华民族文学宝库中的奇葩，许多脍炙人口的文章都出自于纵横家之口，对于纵横家们口才的研究是一个具有相当深度与广度的课题，显然本文只是沧海一粟，难窥全貌，希望有机会与大家共同探讨、切磋。 1. 当艺术评论家聚在一起的时候他们谈论的都是关于版式结构以及意蕴之类的话题，而真正的艺术家在一起的时候谈论的则是到哪里才能买到便宜的松节油。 2.软件开发的过程： 1)定义问题 2）需求分析 3）规划构架 4）软件构件 5）详细设计 6)编码与调试 7）单元测试 8）集成测试 9）集成 10）系统测试 11）保障维护 3.重要的研发成果产出产自类比。通常把不理解的东西和一些较为理解的且十分相似的东西作比较，可以对理解不深刻的东西产生更深刻的理解。这种隐喻的方法叫做建模。 4. 文字写作编程模式这一隐喻暗示着软件开发过程是一种代价昂贵的试错过程，而非仔细的 规划和设计。 5.三思而后行。 6.有一些程序员确实知道如何进行这些前期工作，但是他们并没有这么做。因为他们不能抵抗'尽快开始编码'的欲望。为什么会这样？是一种基于什么样的心理状态才导致了这种近似幼稚的情况的出现呢？ 文档流是文档中可显示对象在排列时所占用的位置。比如网页的div标签它默认占用的宽度位置是一整行，p标签默认占用宽度也是一整行，因为div标签和p标签是块状对象。 网页中大部分对象默认是占用文档流，也有一些对象是不占文档流的，比如表单中隐藏域。当然我们也可以让占用文档流的元素转换成不占文档流，这就要用到CSS中属性position来控制。 看看CSS 2.0对position的定义：检索对象的定位方式。共有4种取值。 static：默认值，无特殊（静态）定位。对象遵循HTML定位规则 。 absolute：绝对定位。将对象从文档流中拖出，使用left，right，top，bottom等属性相对于其最接近的一个最有定位设置的父对象进行绝对定位。如果不存在这样的父对象，则依据body对象。而其层叠通过z-index属性定义 。当对象定位在浏览器窗口以外，浏览器因此显示滚动条。 fixed：固定定位。对象定位遵从绝对(absolute)方式。但是要遵守一些规范。当对象定位在浏览器窗口以外，浏览器不会因此显示滚动条，而当滚动条滚动时，对象始终固定在原来位置。 relative：相对定位。对象不可层叠，但将依据left，right，top，bottom等属性在正常文档流中偏移位置。当对象定位在浏览器窗口以外，浏览器因此显示滚动条。 inherit：继承值，对象将继承其父对象相应的值 发现一个不错的养生网站 养生之道 www.yszd.org ，希望大家喜欢。 hessian http://xstream.codehaus.org/json-tutorial.html /* CSS Reset for Taobao 注意：这里是 ONLY for Taobao 的 reset rules 维护：玉伯(lifesinger@gmail.com), 正淳(ragecarrier@gmail.com) */ /* require(reset.css) */ html { color: #404040; /* 淘宝文字默认色 */ background: #fff; /* 覆盖掉用户在不知情的情况下，设置的页面背景 */ } /* 淘宝链接默认色 */ a { color: #404040; } a:hover { color: #f60; } /* 重置 hr */ hr { color: #ccc; background-color: #ccc; } /* misc */ html { /* 让非ie浏览器默认也显示垂直滚动条，防止因滚动条引起的闪烁 */ overflow-y: scroll; } javascript的继承机制并不是明确规定的,而是通过模仿实现的,意味着继承不是由解释程序处理,开发者有权决定最适合的继承方式. 下面我给出几种常用的方法: 1 .对象冒充 原理: 构造函数使用this关键字给所有属性和方法赋值, 因为构造函数只是一个函数,所以可以使ClassA的构造函数成为classB的方法,然后调用它.这样classB就会收到classA的构造函数中定义的属性和方法.例子: function classA(name) { this.name=name; this.showName=function(){alert(this.name);} } function classB(name) { this.newMethod = classA; this.newMethod(name); } obj = new classA("hero"); objB = new classB("dby"); obj.showName(); // print hero objB.showName(); // print dby 说明classB 继承了classA的方法. 对象冒充可以实现多重继承 例如 function classz(){ this.newMethod = classX; this.newMethod(); delete this.newMethod; this.newMethod=classY; this.newMethod(): delete this.newMethod; } 但是如果classX和classY有相同的属性或者方法,classY具有高优先级. 2.call()方法 call方法使与经典的对象冒充法就相近的方法,它的第一个参数用作this的对象,其他参数都直接传递给函数自身. function sayName(perfix) { alert(perfix+this.name); } obj= new Object(); obj.name="hero"; sayName.call(obj,"hello," ); function classA(name) { this.name=name; this.showName=function(){alert(this.name);}; } function classB(name) { classA.call(this,name); } objB = new classB("bing"); objB.showName();////说明classB继承classA的showName方法 3.apply()方法 aplly()方法有2个参数,一个用作this对象,一个使传递给函数的参数数组. function sayName(perfix) { alert(perfix+this.name); } obj= new Object(); obj.name="hero"; sayName.aplly(obj,new Array("hello,") ); 4. 原型链 prototype对象的任何属性和方法都会被传递给对应类的所有实例,原型链就是用这种方式来显现继承. function classA (){} classA.prototype.name="hero"; classA.prototype.showName=function(){alert(this.name)} function classB(){} classB.prototype=new classA(); objb = new classB() objb.showName();//print hero 说明b继承了a的方法 这里需要注意 调用classA的构造函数时,没有给它传递参数,这是原型链的标准做法,确保函数的构造函数没有任何参数. 并且 子类的所有属性和方法,必须出现在prototype属性被赋值后,应为在它之前赋的值会被删除.因为对象的prototype属性被替换成了新对象,添加了新方法的原始对象将被销毁. 5 混和方式 就是用冒充方式 定义构造函数属性,用原型法定义对象方法. function classA(name) { this.name=name; } classA.prototype.showName=function(){alert(this.name)} function classB(name) { classA.call(this,name); } classB.prototype = new classA(); classB.prototype.showName1=function(){alert(this.name+"*****");}; obj = new classB("hero"); obj.showName(); obj.showName1(); 在classB的构造函数中通过调用call方法 继承classA中的name属性,用原型链来继承classA的showName方法. 1）Sun的JVM在实现Selector上，在Linux和Windows平台下的细节。 2）Selector类的wakeup()方法如何唤醒阻塞在select()系统调用上的细节。 先给大家做一个简单的回顾，在Windows下，Sun的Java虚拟机在Selector.open()时会自己和自己建立loopback的TCP链接；在Linux下，Selector会创建pipe。这主要是为了Selector.wakeup()可以方便唤醒阻塞在select()系统调用上的线程（通过向自己所建立的TCP链接和管道上随便写点什么就可以唤醒阻塞线程） 我们知道，无论是建立TCP链接还是建立管道都会消耗系统资源，而在Windows上，某些Windows上的防火墙设置还可能会导致Java的Selector因为建立不起loopback的TCP链接而出现异常。 而在我的另一篇文章《用GDB调试Java程序》中介绍了另一个Java的解释器——GNU的gij，以及编译器gcj，不但可以比较高效地运行Java程序，而且还可以把Java程序直接编译成可执行文件。 GNU的之所以要重做一个Java的编译和解释器，其一个重要原因就是想解释Sun的JVM的效率和资源耗费问题。当然，GNU的Java编译/解释器并不需要考虑太多复杂的平台，他们只需要专注于Linux和衍生自Unix System V的操作系统，对于开发人员来说，离开了Windows，一切都会变得简单起来。在这里，让我们看看GNU的gij是如何解释Selector.open()和Selector.wakeup()的。 同样，我们需要一个测试程序。在这里，为了清晰，我不会例出所有的代码，我只给出我所使用的这个程序的一些关键代码。 我的这个测试程序中，和所有的Socket程序一样，下面是一个比较标准的框架，当然，这个框架应该是在一个线程中，也就是一个需要继承Runnable接口，并实现run()方法的一个类。（注意：其中的s是一个成员变量，是Selector类型，以便主线程序使用） //生成一个侦听端 ServerSocketChannel ssc = ServerSocketChannel.open(); //将侦听端设为异步方式 ssc.configureBlocking(false); //生成一个信号监视器 s = Selector.open(); //侦听端绑定到一个端口 ssc.socket().bind(new InetSocketAddress(port)); //设置侦听端所选的异步信号OP_ACCEPT ssc.register(s,SelectionKey.OP_ACCEPT); System.out.println("echo server has been set up ......"); while(true){ int n = s.select(); if (n == 0) { //没有指定的I/O事件发生 continue; } Iterator it = s.selectedKeys().iterator(); while (it.hasNext()) { SelectionKey key = (SelectionKey) it.next(); if (key.isAcceptable()) { //侦听端信号触发 …… …… …… …… …… …… } if (key.isReadable()) { //某socket可读信号 …… …… …… …… …… …… } it.remove(); } } 而在主线程中，我们可以通过Selector.wakeup()来唤醒这个阻塞在select()上的线程，下面是写在主线程中的唤醒程序： new Thread(this).start(); try{ //Sleep 30 seconds Thread.sleep(30000); System.out.println("wakeup the select"); s.wakeup(); }catch(Exception e){ e.printStackTrace(); } 这个程序在主线程中，先启动一个线程，也就是上面那个Socket线程，然后休息30秒，为的是让上面的那个线程有阻塞在select()，然后打印出一条信息，这是为了我们用strace命令查看具体的系统调用时能够快速定位。之后调用的是Selector的wakeup()方法来唤醒侦听线程。 接下来，我们可以通过两种方式来编译这个程序： 1）使用gcj或是sun的javac编译成class文件，然后使用gij解释执行。 2）使用gcj直接编译成可执行文件。 （无论你用那种方法，都是一样的结果，本文使用第二种方法，关于gcj的编译方法，请参看我的《用GDB调试Java程序》） 编译成可执行文件后，执行程序时，使用lsof命令，我们可以看到没有任何pipe的建立。可见GNU的解释更为的节省资源。而对于一个Unix的C程序员来说，这意味着如果要唤醒select()只能使用pthread_kill()来发送一个信号了。下面就让我们使用strace命令来验证这个想法。 下图是使用strace命令来跟踪整个程序运行时的系统调用，我们利用我们的输出的“wakeup the select”字符串快速的找到了wakeup的实际系统调用。 很早就听说tomcat6使用nio了，这几天突然想到一个问题，使用nio代替传统的bio，ThreadLocal岂不是会存在冲突？ 　　如果读者有socket的编程基础，应该会接触过堵塞socket和非堵塞socket，堵塞socket就是在accept、read、write等IO操作的的时候，如果没有可用符合条件的资源，不马上返回，一直等待直到有资源为止。而非堵塞socket则是在执行select的时候，当没有资源的时候堵塞，当有符合资源的时候，返回一个信号，然后程序就可以执行accept、read、write等操作，这个时候，这些操作是马上完成，并且马上返回。而windows的winsock则有所不同，可以绑定到一个EventHandle里，也可以绑定到一个HWND里，当有资源到达时，发出事件，这时执行的io操作也是马上完成、马上返回的。一般来说，如果使用堵塞socket，通常我们时开一个线程accept socket，当有socket链接的时候，开一个单独的线程处理这个socket；如果使用非堵塞socket，通常是只有一个线程，一开始是select状态，当有信号的时候马上处理，然后继续select状态。 　按照大多数人的说法，堵塞socket比非堵塞socket的性能要好。不过也有小部分人并不是这样认为的，例如Indy项目（Delphi一个比较出色的网络包），它就是使用多线程＋堵塞socket模式的。另外，堵塞socket比非堵塞socket容易理解，符合一般人的思维，编程相对比较容易。　　 　　nio其实也是类似上面的情况。在JDK1.4，sun公司大范围提升Java的性能，其中NIO就是其中一项。Java的IO操作集中在java.io这个包中，是基于流的阻塞API（即BIO，Block IO）。对于大多数应用来说，这样的API使用很方便，然而，一些对性能要求较高的应用，尤其是服务端应用，往往需要一个更为有效的方式来处理IO。从JDK 1.4起，NIO API作为一个基于缓冲区，并能提供非阻塞O操作的API（即NIO，non-blocking IO）被引入。　　BIO与NIO一个比较重要的不同，是我们使用BIO的时候往往会引入多线程，每个连接一个单独的线程；而NIO则是使用单线程或者只使用少量的多线程，每个连接共用一个线程。 　　这个时候，问题就出来了：我们非常多的java应用是使用ThreadLocal的，例如JSF的FaceContext、Hibernate的session管理、Struts2的Context的管理等等，几乎所有框架都或多或少地应用ThreadLocal。如果存在冲突，那岂不惊天动地？ 　　　后来终于在Tomcat6的文档（http://tomcat.apache.org/tomcat-6.0-doc/aio.html）找到答案。根据上面说明，应该Tomcat6应用nio只是用在处理发送、接收信息的时候用到，也就是说，tomcat6还是传统的多线程Servlet，我画了下面两个图来列出区别： 　　tomcat5：客户端连接到达 -> 传统的SeverSocket.accept接收连接 -> 从线程池取出一个线程 -> 在该线程读取文本并且解析HTTP协议 -> 在该线程生成ServletRequest、ServletResponse，取出请求的Servlet -> 在该线程执行这个Servlet -> 在该线程把ServletResponse的内容发送到客户端连接 -> 关闭连接。 　　 　　我以前理解的使用nio后的tomcat6：客户端连接到达 -> nio接收连接 -> nio使用轮询方式读取文本并且解析HTTP协议（单线程） -> 生成ServletRequest、ServletResponse，取出请求的Servlet -> 直接在本线程执行这个Servlet -> 把ServletResponse的内容发送到客户端连接 -> 关闭连接。 实际的tomcat6：客户端连接到达 -> nio接收连接 -> nio使用轮询方式读取文本并且解析HTTP协议（单线程） -> 生成ServletRequest、ServletResponse，取出请求的Servlet -> 从线程池取出线程，并在该线程执行这个Servlet -> 把ServletResponse的内容发送到客户端连接 -> 关闭连接。 　 　从上图可以看出，BIO与NIO的不同，也导致进入客户端处理线程的时刻有所不同：tomcat5在接受连接后马上进入客户端线程，在客户端线程里解析HTTP协议，而tomcat6则是解析完HTTP协议后才进入多线程，另外，tomcat6也比5早脱离客户端线程的环境。 　　实际的tomcat6与我之前猜想的差别主要集中在如何处理servlet的问题上。实际上即使抛开ThreadLocal的问题，我之前理解tomcat6只使用一个线程处理的想法其实是行不同的。大家都有经验：servlet是基于BIO的，执行期间会存在堵塞的，例如读取文件、数据库操作等等。tomcat6使用了nio，但不可能要求servlet里面要使用nio，而一旦存在堵塞，效率自然会锐降。 　　所以，最终的结论当然是tomcat6的servlet里面，ThreadLocal照样可以使用，不存在冲突 我就拿一个房子来做一个比方吧，服务器好比就是一幢房子，黑客最直接的方式就是带着一些撬锁的工具，去把房子的锁给撬掉，然后夺门而入，这种方式被称为服务器入侵。还有一类就是它直接撬大门锁撬不开，它就把这个房子的窗打破，从窗子里面钻进去，来进行破坏，这种方式叫做网站入侵。还有一类就是黑客带着一只训练有素的小猴子，让小猴子爬到房子的房顶，从烟囱里面钻进去，然后把大门打开，这种方式叫做特洛伊木马入侵。还有一类就是我们前面讲到那个事件的DDOS攻击这个技术，这个相当于黑客带着一大帮人过来把房子的大门给堵住了，让房子里面的人出不来，让外面的人也进不去，这就是DDOS攻击。 SELECT DATEADD(mm,DATEDIFF(mm,0,getdate()),0) //首先选出当前月，然后把他转换为日期 select (2009-1900)*12 select DATEDIFF(mm,0,getdate())  #define   WINVER   0x0050  
#define   WINVER   0x0500，这个表示是为Windows   2000编译，不保证Windows   98/NT4可以正常运行  

Windows   Server   2003  
  WINVER>=0x0502  
     
  Windows   XP    
  WINVER>=0x0501  
     
  Windows   2000  
  WINVER>=0x0500  
     
  Windows   NT   4.0  
  WINVER>=0x0400  
     
  Windows   Me  
  WINVER>=0x0500  
     
  Windows   98  
  WINVER>=0x0410  
     
  Windows   95  
  WINVER>=0x0400