BlogJava-于吉吉的技术博客-随笔分类-web开发

《lua & ngx_lua 的介绍与应用》

陈于喆 — Mon, 19 Mar 2012 08:33:00 GMT

上段时间使用ngx_lua效果还真不错

lua这门语言让人耳目一新，跟一般的脚本语言如php，perl不同，lua被称为一种嵌入式的语言，当然lua也可以单独的进行编程，但如果你这么做的话，那么lua只是一片浮云，当然了，lua还有高执行效率和无平台无关等特点。

ngx_lua的搭配更是一次架构的进化，把我们的业务逻辑提前到web server，当然这样做是否合理，这个还有很大的争论，最起码taobao的量子统计使用ngx_lua取代了php还是带来了很多亮点，值得我们关注和学习。

上周做了个交流讲座，做了份ppt，参考和摘录了淘宝的《打造安全易运维的高性能web平台》http://lych.yo2.cn的《走近lua》

《lua & ngx_lua 的介绍与应用》 --> ppt 下载
/Files/dongbule/ngx_lua.pptx

目前使用lua搭配tt，和lua搭配memcached，做用户轨迹的收录的高并发工作，效率非常好，为我们解决了机器的问题还有现成开发框架一些不足的到地方，lua还有很多地方需要再进行研究，相信以后在一些高并发，小业务的方面会继续发挥作用

----------------------------------------

by 陈于喆
QQ:34174409
Mail: dongbule@163.com

陈于喆 2012-03-19 16:33 发表评论

对setTimeout的误差堆积测试和简单分析

陈于喆 — Tue, 10 Jan 2012 07:15:00 GMT

前段时间做了一个团购秒杀倒计时的js展现的例子（http://www.blogjava.net/dongbule/archive/2011/12/06/365687.html），倒计时的方式主要使用setTimeout的函数进行递归实现，由于是使用setTimeout，所以根据js的引擎，这其中将可能存在一定的时间误差，一个误差不要紧，两个误差无所谓，但长时间的误差堆积将出现较大的偏离值，所以根据秒杀倒计时的例子，做了一个简单的模拟的误差堆积测试，并在各个浏览器中进行测试。

鉴于秒杀倒计时都是以一秒为单位，所以下面的例子也都以1000毫秒为计算，当然各个浏览器的实现和附加代码的编写也会造成一定的时间误差，这部分误差也合并在setTimeout的实现里面计算误差。

<div id="show" style="width:500px;">div>
<script>
var w = 1000;
var second = 0;
function showtime(){
showtime.curr=  +new Date();
setTimeout('showtime()',1000);
document.getElementById("show").innerHTML+=second +"    "+(showtime.curr-(showtime.last||showtime.curr)-1000)+"
";
showtime.last=showtime.curr;
second++;
}
showtime();
script>

可以看到在各个不同的浏览器在不同的秒数中出现不同的误差，当然这个跟我本机的浏览器和环境有关

下面再将这些误差值进行叠加测试

<div>
<div id="show" style="width:500px;">div>
div>
<script>
var w = 1000;
var i = 0;
function showtime(){
    showtime.curr=  +new Date();
    f = setTimeout('showtime()',1000);
    w+=(showtime.curr-(showtime.last||showtime.curr)-1000);
    document.getElementById("show").innerHTML+=i+"   "+(showtime.curr-(showtime.last||showtime.curr)-1000)  +"    "+w+"

";
    showtime.last=showtime.curr;
    i++;
}
showtime();
script>

IE和chrome相对较为稳定，不知道是不是我本机环境的原因，firefox出现了很多大偏差，可以选择定时清空这个误差值来处理，或是采用链式的setTimeOut()来处理。

<div id="show" style="width:300px;">div>
<script>
var w = 1000;
var i = 0;
var f ;
var t ;
var k = 0;
function showtime(){
    showtime.curr=  +new Date();
    f = setTimeout('showtime()',1000);
    w+=(showtime.curr-(showtime.last||showtime.curr)-1000);
    document.getElementById("show").innerHTML+=i+"   "+w+"  "+(showtime.curr-(showtime.last||showtime.curr)-1000)  +"
";
    showtime.last=showtime.curr;
    i++;
}
function round(){
    if(k!=0){
        clearTimeout(f);
        showtime();
        document.getElementById("show").innerHTML+="  clear
";
        w=0;
    }
    setTimeout('round()',10000);
    k++;
}
showtime();
round();
script>

其实为什么javascript的定时器会出现所谓的不可靠或偏差的情况，这是可以理解的，最主要的问题是它们并不是所谓的线程，其实

javascript是运行于单线程的环境中，而定时器只是计划代码在未来某个执行的时间，执行的时间点是不能被保证的，因为在页面的生命周期中，不同时间可能存在其他代码，或各个浏览器的内核控制住javascript进程。

settimeout几个见解

1、setTimeOut != thread | 时间片的并发调用

2、javascript以单线程的方式运行于浏览器的javascript引擎中

3、setTimeout 只是把要执行的代码在设定的时间点插入js引擎维护的代码队列

4、setTimeout 插入代码队列并不意味着代码就会立马执行的

function showtime(){

// code 1...

f = setTimeout('showtime()',200); //200毫秒后要插入执行代码对浏览器的js队列

// code 2...

}

以上面面的代码为例，说说它的执行流程

Code 1 -> 200毫秒后通知浏览器有队列插入 -> Code 2 -> showtime() -> …

这个种重复递归可能会造成2个问题：

1 . 时间间隔可能小于定时调用的代码的执行时间

2 . 时间间隔或许会跳过

时间间隔或许会跳过

5ms : code1 代码执行完毕，200ms后有定时器进入队列

205ms : 定时器进入队列，code2继续

300ms : function代码结束，定时器从队列中取出，执行

405ms : 第二个定时器进入队列,第一个定时器的代码在执行中

605ms : 第三个定时器意图进入队列失败，这个点的settimeout丢失

为了避免这2个问题，可以采用链式setTimeOut()进行调用

setTimeOut(function(){

code处理...

setTimeOut(arguments.callee,interval);

},interval);

这个模式链式条用setTimeOut(),每次函数执行的时候都会创建一个新的定时器，第二个setTimeOut调用使用了arguments.callee来获取当前执行的函数引用，并为其设置另外一个定时器，这样的好处在于，在前一个定时器执行完之前不会向队列中插入新的定时器代码，确保不会有任何的确实间隔，而且它可以保证在下一次定时器代码执行前，至少等待指定的间隔，避免连续的运行。

//-------------//

秒杀的定时器已经通过检测正式运行了，博客记录得不好，表达不是很清楚，关于setTimeOut的函数主要参考了《JavaScript高级程序设计(第2版)》的第18章。

陈于喆 2012-01-10 15:15 发表评论

javascript 实现'秒杀，团购'倒计时展示的记录

陈于喆 — Tue, 06 Dec 2011 08:22:00 GMT

摘要: 最近做了一个房产的秒杀，团购的电子商务网站(房子也有秒杀，出手不小啊)，其中里面有一个秒杀的倒计时展示，主要是判断当前时间距离秒杀开始还有多少时间，还有秒杀开始和秒杀结束的各种展示。其中最主要的一点就是所谓的当前时间不能使用浏览器通过new Date()获取的客户端时间，这样只要用户修改了自己的机器时间那么倒计时就会乱透了，所以这个当前时间必须使用的是服务器时间，所以采用的是静态缓存页面所以这个当... 阅读全文

陈于喆 2011-12-06 16:22 发表评论

简单分析cglib引起的PermSize Space内存溢出

陈于喆 — Sun, 21 Aug 2011 07:55:00 GMT

上段时间有台机器发生了 java.lang.OutOfMemoryError: PermGen space 内存溢出的异常，当时大概判断了原因后就把 MaxPermSize 配置调高后，就把问题解决了，不过空下时间后还是需要继续把review代码。

一般来说PermSize Space OOM的话，第一种可能就是方法区溢出，第二种就是运行时常量池溢出，第二种查看后基本排除掉，问题就应该出现在方法区的溢出，方法区用于存放class的相关信息，如类名，访问修饰符，常量池，字段描述，方法描述等等，对于这个区域的溢出，基本上都是运行时产生大量的类填满了整个方法区，直到溢出。

spring aop中都是使用到了cglib这类字节码的技术，动态代理的类越多，就需要越多的方法区来保证动态生成的class可以加载入到内存中去，

不过spring框架导致的不会因为这种原因。撑爆perm的应该是各种methodaccessorX和constructoracccessorX等等。本来这些accessor也有缓存，但它们使用内存大小敏感的reference引用着的，且使用的是堆内存。当你堆内存吃紧的时候，这些缓存就摧毁了，就必然会不断产生新的methodAccessor字节码，是这个撑爆了perm。所以除增大permsize还应该看看平时运行时堆内存是不是经常用光。

下面的例使用cglib直接进行动态代理产生大量的动态类，然后使用jconsole进行观察。

首先将本机的jvm配置为 -XX:PermSize=64M -XX:MaxPermSize=64M ，给到PermSize最大为64M的内存

public class PermgenOOM {

    public static void main(String[] args) throws InterruptedException {
        int i=0;
        while(true){
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(Product.class);
            enhancer.setUseCache(false);// 关闭CGLib缓存，否则总是生成同一个类
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] args,
                        MethodProxy methodproxy) throws Throwable {
                    // TODO Auto-generated method stub
                    return methodproxy.invokeSuper(obj,args);
                }
            });
            enhancer.create();
            Thread.sleep(100);
        }
    }
}

很快，系统就抛出了 java.lang.OutOfMemoryError: PermGen space
内存池peimgen的情况

加载类的情况

并且在方法区中，一个类如果要被垃圾收集器回收掉，判断的条件是非常苛刻的，很多人都把方法区称为“永久区”(Permanent Generation),但据说2者在本质上是不一致的，另外还有称呼为“非堆区”，不纠结这个了。

再看看enhancer.setUseCache(false)，如果选择为true的话，那么就使用和更新一类具有相同属性生成的类的静态缓存，而不会在同一个类文件还继续被动态加载并视为不同的类，这个其实跟类的equals()和hashCode()有关，它们是与cglib内部的class cache的key相关的。

将上面的程序 enhancer.setUseCache(false) 改为 enhancer.setUseCache(ture)

public class PermgenOOM {

    public static void main(String[] args) throws InterruptedException {
        int i=0;
        while(true){
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(Product.class);
            enhancer.setUseCache(true);// 或者不写，默认值就是true
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object obj, Method method, Object[] args,
                        MethodProxy methodproxy) throws Throwable {
                    // TODO Auto-generated method stub
                    return methodproxy.invokeSuper(obj,args);
                }
            });
            enhancer.create();
            Thread.sleep(100);
        }
    }
}

内存池peimgen的情况

加载类的情况

可以发现内存池peimgen和加载类的情况并没有呈现直线上涨，已经他们一直都使用者动态类生成类的静态缓存，但是这种动态创建类使用静态缓存在一些情况下并不适合需求。

陈于喆 2011-08-21 15:55 发表评论

js全局/局部变量的乌龙问题

陈于喆 — Thu, 02 Jun 2011 08:11:00 GMT

今天在写个一段js代码出现了变量值出现异常的问题，把代码做了提取，简单的如下面

在第一次alert(i)是 0 first
在第二次alert(i)是 name second

为什么会出现这样的情况，明明在a2函数传进去的是实参，并且也没有对参数a[i]进行改写
在反复查看问题后发现是i变量的问题，在函数a1()中，i被定义成为了全局变量，而在函数a2()中，i又是一个全局变量，所以在a2的for (i in obj) 循环中i被重新赋值成"name"
这个乌龙是没有养成在一些临时函数定义成局部变量造成的，特别是在一些for，while，if的操作中，临时变量必须定义成局部变量否则会出现全局变量被改写的情况。

再回顾一下定义全局变量／局部变量的规则
在函数外部，使用var，或直接使用变量，如var a=1;或 a=1; 就定义了全局变量
在函数内部，直接使用变量，如a=1;也定义了全局变量
在函数内部，使用var进行定义就是局部变量

修改一下上面的代码

陈于喆 2011-06-02 16:11 发表评论

房产地图google map的初步应用点滴.4)

陈于喆 — Thu, 02 Jun 2011 06:01:00 GMT

房产地图google map的初步应用点滴.1)

房产地图google map的初步应用点滴.2)

房产地图google map的初步应用点滴.3)

房产地图google map的初步应用点滴.4)

google map测距的实现和分析

不断有传闻google map在今年的7月1号之后在大陆停止运营，具体原因是因为天朝的牌照问题，这个就不多讲了，可以发现现在搜房网的地图，和安居客等的地图纷纷都撤下 google map，而重新选择了mapabc或baidu，当然网易房产地图也不例外，现在也在使用mapabc作为网易房产地图的开发，预计将在6月底前上线，到时再跟大家分享一下mapabc的一些开发实践。

还是说回google map的开发，自从上次建了个qq群就有不少人在问测距怎么实现，当然很多人想的是拿来主义的，当时是拿http://xf.house.163.com /gz/map/000B.html的例子出来，但确实页面上进行了封装也写得比较乱，所以还是比较难以抽离，先给个简单实现的例子：

DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=GBK"/>
<title>163网易房产title>
<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false">script>
<script type="text/javascript">
  var map;
  function initialize() {
    var myLatlng = new google.maps.LatLng(23.116193,113.374525);
    var myOptions = {
      zoom: 15,
      center: myLatlng,
      mapTypeId: google.maps.MapTypeId.ROADMAP
    }
    map = new google.maps.Map(document.getElementById("map_canvas"), myOptions);
  }
var polyline;
var polylinesArray = [];
//距离标记数组
var lenArray = [];
var rule = null;
//距离
function getDistance(){
    //启动整个地图的click侦听
    rule = google.maps.event.addListener(map,"click",function(event){
        addMarker(event.latLng);
    });
}
//添加新标记
function addMarker(location){
    //标记选项
    var myOptions = {
        position : location,
        draggable :false,
        map : map,
    };
    marker = new google.maps.Marker(myOptions);
    //将标记压入数组
    lenArray.push(marker);
    //计算距离
    drawOverlay();
}
//画出路径覆盖层
    function drawOverlay(){
    //路线数组
    var flightPlanCoordinates = [];
    //将坐标压入路线数组
    if (lenArray) {
        for (i in lenArray) {
            flightPlanCoordinates.push(lenArray[i].getPosition());
        }
    }
    //路径选项
    var polylineOptions = {
        path : flightPlanCoordinates,
        map : map,
        strokeColor : "#FF0000",
        strokeOpacity : 1.0,
        strokeWeight : 2
    };
    polyline = new google.maps.Polyline(polylineOptions);
    //清除原有折线路径
    if (polylinesArray) {
        for (i in polylinesArray) {
            polylinesArray[i].setMap(null);
        }
        polylinesArray = [];
    }
    polyline.setMap(map);
    polylinesArray.push(polyline);
    alert((polyline.getLength()/1000).toFixed(3) + "km");
}
google.maps.LatLng.prototype.distanceFrom = function(latlng) {
    var lat = [this.lat(), latlng.lat()]
    var lng = [this.lng(), latlng.lng()]
    var R = 6378137;
    var dLat = (lat[1] - lat[0]) * Math.PI / 180;
    var dLng = (lng[1] - lng[0]) * Math.PI / 180;
    var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat[0] * Math.PI / 180) * Math.cos(lat[1] * Math.PI / 180) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
    var d = R * c;
    return Math.round(d);
}
google.maps.Marker.prototype.distanceFrom = function(marker) {
    return this.getPosition().distanceFrom(marker.getPosition());
}
google.maps.Polyline.prototype.getLength = function() {
    var d = 0;
    var path = this.getPath();
    var latlng;
    for (var i = 0; i < path.getLength() - 1; i++) {
        latlng = [path.getAt(i), path.getAt(i + 1)];
        d += latlng[0].distanceFrom(latlng[1]);
    }
    return d;
}
script>
head>
<body onload="initialize()">
  <div id="map_canvas" style="width: 500px; height: 400px">div>
  <a href="#this" onclick="getDistance();">开始测距a>
body>
html>

例子给完了，其中测距的计算是抄了google的示例，想简单拿来应用的到这里就可以结束了，还有点兴趣的可以看看下面的简单分析：

说到测距无非就是线的计算，根据google map api，测距的线性实现我们采用Polyline类，Polyline是折线是地图上的连接线段的线性叠加层，扩展自MVCObject。

测距是由线组成，然后根据一组线的长短计算出线的启动和终点线的距离，根据这个思路，我们定义出
var polyline;
var polylinesArray = [];
其中polyline是当前画出来这条线，polylinesArray是一个数组，当每话出一条线就将这条线push到polylinesArray这个数组中去。

另外一条线其实是由两个点，始点和终点所组成，所以我们也定义一个
var lenArray = [];
lenArray是一个数组，用来记录鼠标点过的每一个点的信息
也就是说整个测距是由每一条线所组成，而一条线是由2个点组成。

思路理清楚了，接着一步一步看

当我们点击了开始测距时，就需要启动一个事件的监听，对整个map的click事件监听
   rule = google.maps.event.addListener(map,"click",function(event){
       addMarker(event.latLng);
   });
当我们在地图上进行点击时，就会新增一个maker点，并且将这个maker压入lenArray数组，以便于后面的计算
function addMarker(location){
...
marker = new google.maps.Marker(myOptions);
...
lenArray.push(marker);
drawOverlay();
接着会调用drawOverlay();使用polyline来画线
   var flightPlanCoordinates = [];
   //将坐标压入路线数组
   if (lenArray) {
       for (i in lenArray) {
           flightPlanCoordinates.push(lenArray[i].getPosition());
       }
   }
   var polylineOptions = {
       path : flightPlanCoordinates,
       map : map,
       strokeColor : "#FF0000",
       strokeOpacity : 1.0,
       strokeWeight : 2
   };
   polyline = new google.maps.Polyline(polylineOptions);

其中polylineOptions的path参数是折线坐标的有序序列。可以使用一个简单的 LatLng 数组或者 LatLng 的 MVCArray 指定此路径。请注意，如果您传

递简单的数组，则它会转换为 MVCArray。在 MVCArray 中插入或删除 LatLng 将自动更新地图上的折线。
flightPlanCoordinates数组用于存储在上面我们定义的lenArray数组的坐标值，每点击一次就压入一对坐标值。
strokeColor和strokeOpacity，strokeWeight是一些样式的参数，如指定线条的宽度等等。
最后我们将定义的polyline进行setMap，在地图上展现，并将polyline压入到polylinesArray数组中去。
   polyline.setMap(map);
   polylinesArray.push(polyline);
到这里，线和点的展现已经完成了，接下来是需要将这些点线转换成我们需要的距离值。

google.maps.Polyline.prototype.getLength = function() {
   var d = 0;
   var path = this.getPath();
   var latlng;
   for (var i = 0; i < path.getLength() - 1; i++) {
       latlng = [path.getAt(i), path.getAt(i + 1)];
       d += latlng[0].distanceFrom(latlng[1]);
   }
   return d;
}

这里需要讲明的是this.getPath();它的说明是检索第一条路径。并且返回值是一组MVCArray.，也就是实际存储了一条线的坐标值，在这里取出这些坐标的数组，并且进行循环distanceFrom计算

google.maps.LatLng.prototype.distanceFrom = function(latlng) {
   var lat = [this.lat(), latlng.lat()]
   var lng = [this.lng(), latlng.lng()]
   var R = 6378137;
   var dLat = (lat[1] - lat[0]) * Math.PI / 180;
   var dLng = (lng[1] - lng[0]) * Math.PI / 180;
   var a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(lat[0] * Math.PI / 180) * Math.cos(lat[1] * Math.PI / 180) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
   var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
   var d = R * c;
   return Math.round(d);
}
这段计算实际上是抄自google map示例的，是将我们的坐标值转换成我们需要计算的距离值，这里就不分析，有兴趣可以玩玩，没兴趣就直接抄过去吧。

结果出来了，这个就是我们需要的测距的距离，当然你也可以用其他方式进行展现

alert((polyline.getLength()/1000).toFixed(3) + "km");

只要阅读google api和自己思路清楚，一个测距的demo很快就完成了，稍加装饰基本就可以应用于生产上

如果你也在进行google map的开发，欢迎赐教和讨论，建了个qq群：11029590

陈于喆 2011-06-02 14:01 发表评论

解答一下几道笔试题

陈于喆 — Thu, 21 Apr 2011 09:23:00 GMT

有朋友去一家大型的互联网公司参加了java程序员的笔试，抄下了一些笔试题，可能有的抄的并不全，试了解答一下，有些还真的答不出来

    1.cookie和session的作用以及他们的应用场合
    2.怎样让jvm加载一个Class的同时执行一段代码
    3.post和get区别
    4.事务的属性有哪些？写出spring或jdbc管理事务的例子
    5.实现一个高并发、高性能的hashmap。写出伪代码
    6.解析一段xml，拼接成一个url。
    7.怎么解决并发？怎么解决集群环境下的并发?
    8.java GC的原理.
    9.mysql支持事务吗？mysql存储引擎有哪些？
    10.数据库数据查找比较慢的时候，如何解决？
    11.学生课程选课的一个sql语句书写
    12.查找日志文件中某一个信息出现的次数
    13.32位linux操作系统中，最多支持多少个线程？
    14.关于TreeMap操作的
    15.重写类A的equals和hascode方法。类A有个属性private B b；
    16.实现一个mysql的sequence。

下面是我的一点解答，也不知道对不对，现在的笔试要你白纸黑字写出这些东西真是难啊！

1)cookie和session的作用以及他们的应用场合
两者都是记录用户访问网站信息，但他们的保持状态不同，cookie是采用客户端保持，而session是采用服务端保持，一般来说cookie不是很安全，因为别人可以分析本地的cookie进行cookie欺骗，考虑到安全的问题应该使用session，session是保持在服务端，但当访问增多时，会增加服务器的压力。
在应用场合中，建议建用户登录，交易重要信息存放session，其他信息可以存放在cookie中，根据实际需求两者可以交替搭配使用。

2)怎样让jvm加载一个Class的同时执行一段代码
使用Class.forName()动态加载类（题目中有"同时"，是否启用另一线程？）

3)post和get区别
从http动词协议来看，get是从服务器获取数据，post是向服务器上传数据
get方式会把数据出现在url中，post则不会
get提交的数据有大小限制，post则无

4)事务的属性有哪些？写出spring或jdbc管理事务的例子
有原子性，一致性，隔离性，持久性
spring提供了丰富的事务模型，主要是针对jdbc事务，jta事务，还有一些自定义事务（如果有人能从一张白纸写出spring transaction的例子，那真是佩服之极）
还是写一个简单jdbc事务
try{
class.forName("***");
...
conn=DriverManager.getConnection(url,user,password);
conn.createStartement().executeUpdate("****");//更新操作
conn.commit();//事务提交
}catch(Exception e){
..
conn.rollback();//事务回滚
..
}

5)实现一个高并发、高性能的hashmap。写出伪代码
什么叫做高性能，高并发的hashmap? 是要考hashmap的数据结构??

6)解析一段xml，拼接成一个url
xml,url???这两者有什么联系吗?

7)怎么解决并发？怎么解决集群环境下的并发?
（有很多点可以并发，web请求可以并发，数据库请求可以并发，怎么那么空泛）
高并发最重要的还是考虑到锁的问题，如数据库该用表锁用表锁，该用排他锁用排它锁，程序中要注意非线程安全的问题
高并发还有带来性能问题，缓存，负载均衡，这些看情况而定

8)java GC的原理.
又来，不回答你

9)mysql支持事务吗？mysql存储引擎有哪些？
支持，常用的是inndb和myisam

10)数据库数据查找比较慢的时候，如何解决？
假如是mysql
1.漏了索引,用explain看看查询语句是不是没使用索引或者索引使用有问题
2.使用show processlist看看是不是有sql卡住了
3.还有一种情况就是sql写得过于复杂，如goroupby，多表关联等等，使用desc来进行分析
4.还有就是配置的问题，如key_buffer等参数，这个看文档吧
5.最后一种就是机器负荷过高，调整结构来解决吧，比如使用mysql-proxy代理等等

11)学生课程选课的一个sql语句书写
??

12)查找日志文件中某一个信息出现的次数
cat 日志 | grep 信息 | wc -l

13) 32位linux操作系统中，最多支持多少个线程？
上网查了，写得很复杂，附上文章
http://www.517sou.net/Article/Linux-maximum-number-of-threads-and-the-maximum-number-of-processes.aspx

14)关于TreeMap操作的
TreeMap就是一颗平衡排序二叉树，操作的。。后面是什么??

15)重写类A的equals和hascode方法。类A有个属性private B b；
??

16)实现一个mysql的sequence
mysql的last_insert_id()大致可以满足，如果不行就写触发器吧

陈于喆 2011-04-21 17:23 发表评论

房产地图google map的初步应用点滴.3)

陈于喆 — Wed, 30 Mar 2011 08:58:00 GMT

摘要: 房产地图google map的初步应用点滴.1) 房产地图google map的初步应用点滴.2) 房产地图google map的初步应用点滴.3)房产地图google map的初步应用点滴.4) google Map的交互基本都是事件驱动的，这表示js是通过生成时间来响应交互的，并且处于监听我们设定的事件，每个 Google Maps API 对象都可导出大量已命名的事件。如果程序想要... 阅读全文

陈于喆 2011-03-30 16:58 发表评论

房产地图google map的初步应用点滴.2)

陈于喆 — Sat, 05 Mar 2011 08:02:00 GMT

摘要: 房产地图google map的初步应用点滴.1) 房产地图google map的初步应用点滴.2) 房产地图google map的初步应用点滴.3)房产地图google map的初步应用点滴.4) 本来是想将房产地图google map的应用记录一个系列，但继1)记录完之后总找不到时间继续记录下去，1)中主要解决了Google Maps JavaScript API V3 与 Googl... 阅读全文

陈于喆 2011-03-05 16:02 发表评论

房产地图google map的初步应用点滴.1)

陈于喆 — Sat, 12 Feb 2011 07:57:00 GMT

房产地图google map的初步应用点滴.1)
房产地图google map的初步应用点滴.2)
房产地图google map的初步应用点滴.3)

房产地图google map的初步应用点滴.4)

以前的房产地图一直都是使用有道地图，虽然有道地图是很好，但是为了更好，还是决定使用google地图来重新开发^_^，下面是一个开发完毕的简单应用http://xf.house.163.com/gz/map/000B.html

1)整合Google Maps JavaScript API V3 与 Google Local Search API

Google Maps JavaScript API V3
地址 http://code.google.com/intl/zh-CN/apis/maps/documentation/javascript/

Google Maps JavaScript API V3 文档读起来真的是很清晰，各种demo也很齐全，并且论坛的拥有巨大的论坛支持，对比了一下Google Maps JavaScript API V3 和 V2 的版本，虽然第3版的 Google Maps API 看上去跟第2版挺相识，但在内在机制上有了较大的变化，尤其在对移动浏览器的支持上，专门针对iphone和android设备的开发。V2版本google已经宣布不再予以继续支持，所以还是选择了V3版本。

Google Local Search API
地址 http://code.google.com/intl/zh-CN/apis/maps/documentation/localsearch/index.html

上面的地址是目前Local Search的最新地址，但郁闷的是居然挂上了 Deprecated ，一样的文档也相当齐全，在应用之前需要先为你的域名申请一个API key，这个是注册地址http://code.google.com/intl/zh-CN/apis/maps/signup.html，很简单，按照提示很快就搞定了。

在整合Google Maps JavaScript API V3和Google Local Search API发现这两个版本是不兼容的，Local Search API实际上还是沿用了Maps V2的接口，为了解决这个问题，需要中间一个跳板使得两者兼容，所以选择了iframe，父页面使用Google Maps V3，子页面使用Local Search API，当需要应用到本地搜索时，父页面向子页面传递查询条件，子窗口应用Local Search API获得查询的result后返回给父页面，这样就形成一个跳板，避免了两者因为版本问题而产生的冲突，当然还有其他的办法，不过iframe应该是比较简单处理，下面是一个demo

父页面 : 使用的是Google Maps JavaScript API V3，http://maps.google.com/maps/api/js 网址指向 Javascript 文件所在的位置，该文件会载入使用第 3 版 Google Maps API 所需的全部符号和定义。

DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=GBK"/>
<title>Google AJAX Search API Sampletitle>
<style type="text/css">
@import url("http://www.google.com/uds/css/gsearch.css");
@import url("http://www.google.com/uds/solutions/localsearch/gmlocalsearch.css");
@import url("http://www.google.com/uds/css/gsearch.css");
@import url("http://www.google.com/uds/solutions/localsearch/gmlocalsearch.css");

style>
<script type="text/javascript" src="http://xf.house.163.com/product/js/jquery.js">script>
<script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false">script>
<script type="text/javascript">
      var map;
      var lat = 23.116193;
      var lng = 113.374525;
      var markersArray = [];
      var windowArray = [];
      function initialize() {
        var mapDiv = document.getElementById('map-canvas');
          map = new google.maps.Map(mapDiv, {
          center: new google.maps.LatLng(lat,lng),
          zoom: 15,
          mapTypeId: google.maps.MapTypeId.ROADMAP
        });
      }

      //删除叠加层
      function deleteOverlays() {
          if (markersArray) {
            for (i in markersArray) {
              markersArray[i].setMap(null);
            }
            markersArray.length = 0;
          }
      }

      //关闭信息提示窗口
      function closeWindows() {
          if (windowArray) {
            for (i in windowArray) {
                windowArray[i].close();
            }
          }
         }

      function show(results){
          parent.deleteOverlays();
          windowArray.length = 0;
          for (var i = 0; results && i < results.length; i++) {
              showOne(results[i]);
          }
      }
      function showOne(result){
          //console.debug(result.title+","+result.lat+":" + result.lng +","+result.streetAddress+","+result.city+","+result.url);
          var infowindow = new google.maps.InfoWindow({
              content: result.html
            });
            var marker = new google.maps.Marker({
                position: new google.maps.LatLng(result.lat,result.lng),
              map: map
            });
            markersArray.push(marker);
            windowArray.push(infowindow);
            google.maps.event.addListener(marker, 'click', function() {
              closeWindows();
                infowindow.open(map,marker);
            });
      }

      function searchMap(){
          var keyWord = document.getElementById("keyWord").value;
          mapIframe.window.loadMap(23.116193,113.374525,keyWord);
      }
      google.maps.event.addDomListener(window, 'load', initialize);
    script>
head>
<body style="">
<div id="map-canvas" style="width: 600px; height: 500px">div>
<input type="text" name="keyWord" id="keyWord"/>
<input type="button" onclick="searchMap();" value="查询" id="btn"/>
<iframe name="mapIframe" id="mapIframe" style="display:none" src="local.html">iframe>
body>
html>

子页面：http://www.google.com/jsapi?key 需要在google进行申请与域名绑定

DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html; charset=GBK"/>
<script src="http://www.google.com/jsapi?key=ABQIAAAAtV_DTJOYJT-9cvTO-5KJ2BSnjw5qeDlzCnItJoREFggHbBwu_RQBEyFqvq_vMlzqsS4afIB8ZIvMkw" type="text/javascript">script>
<script type="text/javascript">
    google.load('search', '1');
    google.load('maps', '2');

    function loadMap(lat,lng,keyWord) {
        var point = new GLatLng(lat,lng);
        console.debug(keyWord+"-"+lat+","+lng);
        searchMap(point,keyWord);
    }

    function searchMap(point,keyWord){
        var searcher = new google.search.LocalSearch();
        searcher.setCenterPoint(point);
        searcher.setResultSetSize(GSearch.LARGE_RESULTSET);
        searcher.setSearchCompleteCallback(this, function() {
          parent.show(searcher.results);
        });
        searcher.execute(keyWord);
    }
script>
head>
<body>body>
html>

摘录几个常用的Local Search API Reference

new google.search.LocalSearch() : 创建了一个LocalSearch的Service

searcher.setCenterPoint(point) : 它接受单一变量，该变量可以是字符串、google.maps.Map2 或google.maps.LatLng。如果是字符串，会尝试将字符串解析为 google.maps.LatLng

searcher.setResultSetSize(8) : 调用此方法以选择由每个搜索器返回的结果数

searcher.setRestriction() : 设置搜索结构类型

searcher.setSearchCompleteCallback() :　此方法用于注册对象和方法以通知搜索完成。应用程序可以通过使用 opt_arguments之后随意传入环境参数

searcher.execute(keyWord) : 调用此方法以开始新的搜索　

第一步解决了map和local search的版本冲突后，下面可以进行全部的开发，Google Maps JavaScript API提供的UI，EVENT相关接口非常之多，但不一定就能直接适用我们的需求，还需要使用继承基类MVCObject，OverlayView等继续封装。

如果你也在进行google map的开发，欢迎赐教和讨论，建了个qq群：11029590

----------------------------------------

by 陈于喆
QQ:34174409
Mail: dongbule@163.com

陈于喆 2011-02-12 15:57 发表评论

Minimal POM

陈于喆 — Wed, 29 Dec 2010 09:50:00 GMT

The minimum requirement for a POM are the following:

project root
modelVersion - should be set to 4.0.0
groupId - the id of the project's group.
artifactId - the id of the artifact (project)
version - the version of the artifact under the specified group

Here's an example:

<project>
   <modelVersion>4.0.0modelVersion>
   <groupId>com.juvenxu.mvnbookgroupId>
   <artifactId>hello-worldartifactId>
   <version>1.0-SNAPSHOTversion>
project>

A POM requires that its groupId, artifactId, and version be configured. These three values form the project's fully qualified artifact name.

modelVersion指定了当前POM模型的版本，对于Maven2及Maven 3来说，它只能是4.0.0
groupId定义了项目属于哪个组，这个组往往和项目所在的组织或公司存在关联,如果你的公司是mycom，有一个项目为myapp，那么groupId就应该是com.mycom.myapp
artifactId定义了当前Maven项目在组中唯一的ID
version指定了项目当前的版本,SNAPSHOT意为快照，说明该项目还处于开发中，是不稳定的版本
此外,如果配置的其他细节没有被指定,Maven会使用它们的默认值
Furthermore,你可以看到,在Minimal POM中未指定仓库,如果你的项目是采用最小的pom,那么它是会继承所谓的Super POM,所以就算你没有指定仓库,maven也知道所有的依赖直接从网上(http://repo1.maven.org/maven2)下载

陈于喆 2010-12-29 17:50 发表评论

解决hessian远程调用连接超时的问题

陈于喆 — Thu, 16 Dec 2010 06:46:00 GMT

目前几套系统中主要使用的hessian进行远程调用webservice服务的有hessian的HessianProxyFactory(com.caucho.hessian.client.HessianProxyFactory)和spring的HessianProxyFactoryBean(org.springframework.remoting.caucho.HessianProxyFactoryBean).

1.HessianProxyFactory
查看HessianProxyFactory源码后发现,hessian在创建http请求连接webservice服务并没有对连接超时进行相关的参数设置,所以当网络出现问题就会造成整个hessian处理的阻塞,进而阻塞整个线程后续的处理
以下是HessianProxyFactory对连接处理的源码

protected URLConnection openConnection(URL url)
    throws IOException
  {
    URLConnection conn = url.openConnection();

    conn.setDoOutput(true);

    if (_readTimeout > 0) {
      try {
    conn.setReadTimeout((int) _readTimeout);
      } catch (Throwable e) {
      }
    }

    conn.setRequestProperty("Content-Type", "x-application/hessian");

    if (_basicAuth != null)
      conn.setRequestProperty("Authorization", _basicAuth);
    else if (_user != null && _password != null) {
      _basicAuth = "Basic " + base64(_user + ":" + _password);
      conn.setRequestProperty("Authorization", _basicAuth);
    }

    return conn;
  }

所以我们针对此逻辑继承并重写该openConnection方法,在创建http连接的时候通过设置连接超时时间来解决因网络问题阻塞程序继续的问题

public class MyHessianProxyFactory extends HessianProxyFactory {

    private int connectTimeOut = 10000;

    private int readTimeOut = 10000;

    public int getConnectTimeOut() {
        return connectTimeOut;
    }

    public void setConnectTimeOut(int connectTimeOut) {
        this.connectTimeOut = connectTimeOut;
    }

    public int getReadTimeOut() {
        return readTimeOut;
    }

    public void setReadTimeOut(int readTimeOut) {
        this.readTimeOut = readTimeOut;
    }

    protected URLConnection openConnection(URL url) throws IOException {
        URLConnection conn = url.openConnection();
        conn.setDoOutput(true);
        if (this.connectTimeOut > 0) {
            conn.setConnectTimeout(this.connectTimeOut);
        }
        if (this.readTimeOut > 0) {
            conn.setReadTimeout(this.readTimeOut);
        }
        conn.setRequestProperty("Content-Type", "x-application/hessian");
            if (_basicAuth != null)
                  conn.setRequestProperty("Authorization", _basicAuth);
            else if (_user != null && _password != null) {
                  _basicAuth = "Basic " + base64(_user + ":" + _password);
                  conn.setRequestProperty("Authorization", _basicAuth);
            }
        return conn;
    }
}

2.HessianProxyFactoryBean
查看spring的HessianProxyFactoryBean源码发现,它在封装hessian是直接创建一个HessianProxyFactory实例,然后利用该实例完成创建远程服务

public class HessianProxyFactoryBean extends HessianClientInterceptor implements FactoryBean {

    private Object serviceProxy;

    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        this.serviceProxy = ProxyFactory.getProxy(getServiceInterface(), this);
    }


    public Object getObject() {
        return this.serviceProxy;
    }

    public Class getObjectType() {
        return getServiceInterface();
    }

    public boolean isSingleton() {
        return true;
    }

}

所以对此的解决方法与上面差不多,继承HessianProxyFactoryBean然后加入相应的连接超时和读取超时的变量,重写afterPropertiesSet方法,并且同时完成上面第一步对HessianProxyFactory的改造,这样就能保证连接远程webserver服务器时不会因为网络原因阻塞程序的执行

public class MyHessianProxyFactoryBean extends HessianProxyFactoryBean {

    private MyHessianProxyFactory proxyFactory = new MyHessianProxyFactory();

    private int readTimeOut = 10000;

    private int connectTimeOut = 10000;

    public int getReadTimeOut() {
        return readTimeOut;
    }

    public void setReadTimeOut(int readTimeOut) {
        this.readTimeOut = readTimeOut;
    }

    public int getConnectTimeOut() {
        return connectTimeOut;
    }

    public void setConnectTimeOut(int connectTimeOut) {
        this.connectTimeOut = connectTimeOut;
    }

    public void afterPropertiesSet() {
        proxyFactory.setReadTimeout(readTimeOut);
        proxyFactory.setConnectTimeOut(connectTimeOut);
        setProxyFactory(proxyFactory);
        super.afterPropertiesSet();
    }
}

陈于喆 2010-12-16 14:46 发表评论

Javascript eval()使用上需要注意的安全问题

陈于喆 — Wed, 15 Dec 2010 03:31:00 GMT

对很久以前的一个bug进行分析和总结

     function parsePost(data, action) {
         try {
             var postData = eval("(" + data + ")");

             // TO DO1
         } catch (e) {

             // TO DO2
         }
     }

这是一段页面的老代码,data是数据库body字段,既是用户录入并取出的数据,由于业务的关系,data是以json格式保存的,为了使数据能实现兼容,这里使用try...catch...方式处理,如果变量data能被转换成对象,则执行TO DO1,否则执行TO DO2.
我们知道eval的作用很简单,就是把一段字符串传递给js解析器,由javascript解析器将这段字符串解释成为javascript代码,并且执行.不过这也是非常危险,尤其是在给它传递用户输入的数据时,这往往就是恶意用户的一个切入点.
安装上面的代码,如果用户输入的data是一段js代码,如"alert('hello')",那么这段代码用数据库出来后显示部分就会eval("alert('hello')"),这时我的页面就会以alert提示框的方式弹了出来.

好了,这个就是大家都知道的 Cross-site scripting (XSS)，中文翻译是跨站脚本攻击。

Cross-site scripting (XSS) is a type of computer security vulnerability typically found in web applications which allow code injection by malicious web users into the web pages viewed by other users. Examples of such code include HTML code and client-side scripts. （摘自《Cross-site scripting》http://en.wikipedia.org/wiki/Cross- site_scripting）这里介绍了 XSS 的背景，类型，利用和防范等几方面内容。

下面开始修复工作。这段代码显然没能对 data 作好严格的判断工作，data 不但是用户输入的内容，还要被似乎万恶的 eval() 函数执行，而整个过程没有对用户输入的 data 进行一个校验工作，这就是问题所在，而且问题相当严重。

针对跟贴系统此段代码的业务逻辑，可以通过判断 data 的数据类型来确定其逻辑结构，更改后的代码如下∶

     function parsePost(data, action) {
         if (typeof(data) == 'string') {

             // TO DO2
         }
         else {
             // TO DO1
         }
     }

代码在主体上修改如上，我们的选择是，绕开 eval() 函数，把 body 的原型赋给 Javascript 的变量 data，然后使用 typeof() 来对 data 作判断处理，并且根据此判断继续下一步的处理。
另外也可以是使用 JSON 解析器对 JSON 进行解析，可从http: //www.json.org/json.js 下载的参考实现脚本。JSON 是一种基于文本的开放式数据交换格式（请参见 RFC 4627）。

ps:此bug发生在2008年,跟帖受xss攻击

陈于喆 2010-12-15 11:31 发表评论

memcached一些应用点滴

陈于喆 — Wed, 08 Dec 2010 07:00:00 GMT

大名鼎鼎的分布式缓存系统memcached，在开源社区中可谓是无人不知无人不晓，memcached支持分布式的横向扩展，但memcached的服务端却是单实例，并无"分布式"的功能，所谓的分布式只是客户端在存储的主键做分布的存储；还有memcached组件缓存对象，如果组件无进行序列化必定无法正确取得数据；如何使用memcached的java组件来监控memcached的运行状态；以上等等的问题是我在日常的工作中碰到并解决的,拿出来跟大家做个分享^_^

对象的序列化
首先memcached是独立的服务器组件,独立于应用系统,从客户端保存和读取对象到memcached是必须通过网络传输,因为网络传输都是二进制的数据,所以所有的对象都必须经过序列化,否则无法存储到memcahced的服务器端.
正如我们以往在集群中应用的序列化一样,memcached的序列化的性能也是往往让大家头疼,如果我们对我们的domain类进行对象的序列化,第一次序列化时间会比较长,但后续会优化,也就是说序列化最大的消耗不是对象的序列化,而是类的序列化,如果存储的只是一个String对象,这种情况是最理想的,省去了序列化的操作.实际上String对象本身已经实现了序列化接口,无法我们再次去进行序列化操作.

memcached的原子加法
记录一下上次犯得一个错误

<%
static int count = 0;
count++;
MemCachedClient mcc = new MemCachedClient();
mcc.add("test.html", count);
%>

这段代码的作用是将test.html的用户访问次数保存到memcached中,粗劣一看好像并无错误,但在高并发时的出来的访问数据一定是小于实际的访问数量,当然这里并不是memcached对象锁的问题,主要还是程序中线程的同步问题,但是如果使用java的synchronized或lock那么在性能上肯定是无法忍受的,memcached客户端组件带有原子性的加法和减法

<%
MemCachedClient mcc = new MemCachedClient();
System.out.println(mcc.addOrIncr("test.html",1));
%>

long addORIncr(String key,long inc)为计数器值增加inc,如果计数器不存在,则保存inc为计数器的值,必须注意的是服务器端不会对超过2的32次方的行为进行检查

分布式的mencached
memcached虽然是属于分布式的缓存服务器,但实际上memcached服务端之间并无分布式的功能,不会互相通信共享数据,如何进行分布式,这完全是取决于客户端的实现

假设我们现在有三台memcached服务器分别为node1，node2，node3，应用程序要保存键名分别为"test1","test2","test3",客户端实现的算法就是根据键名来决定保存数据的memcached服务器,我们将"test1"保存到node1，"test2"保存到node2，"test3"保存到node3，并且在读取缓存数据也是通过一样的算法从各台服务器上读取相应的key,这样通过一个最简单的算法将不同的键保存到不同的服务器上,实现了memcached的分布式.
但是这种算法很难确保每台服务器得到较为平均的数据量,我们需要改变一下客户端的算法,简单来说,就是根据服务器的台数的余数进行分散

<%
"test1".hashCode()%3
%>

根据key的java.lang.String.hashCode()取得散列值,再将值模服务器的台数得到余数值,我们再根据这个余数值来判定这个key要存入哪一台服务器,当key的数量越来越大,对key的散列取模也会趋向平均,基本可以保证几台memcached服务器所存储的缓存量趋向平均
似乎很完美,余数计算的方法很简单,数据的分散性也很优秀,但也有其缺点,就是当需要添加或移除服务器时,缓存的重组代价是相当巨大的,添加或移除服务器时,余数就会发生变化,这样就无法取到与原来缓存时相同的服务器.
网上介绍的Consistent Hashing算法基本上可以解决这个问题,这里做个简单的说明,首先是求出memcached服务器节点的哈希值,并将其配置到0-2的32次方的圆上,然后用同样的方法求出存储数据的键的哈希值,并映射到圆上.然后从数据映射到的位置开始顺时针查找,将数据保存到找到的第一个服务器上.如果超过2的32次方仍然找不到服务器,就会保存到第一台memcached服务器上

从上图的状态中添加一台memcached服务器。余数分布式算法由于保存键的服务器会发生巨大变化而影响缓存的命中率，但Consistent Hashing中，只有在continuum上增加服务器的地点逆时针方向的第一台服务器上的键会受到影响

几种连接客户端的对比
目前java的memcached主要有Java-Memcached-Client,Xmemached,Spymemcached三种,这三个客户端的性能测试可以看
http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html

请求的资源为64Bytes,在低并发Java-Memcached-Client是占有一定的优势,但在并发数超过100以后,Java-Memcached-Client是呈现直线下跌,并发数达到300已经无法承受,Spymemcached和Xmemached表现相对稳定,特别是Xmemached无论在低并发或高并发都保持优秀的性能表现

并发数固定为100时,在小文件的请求Java-Memcached-Client还是占有优势,当随着请求的size越来越大,三者趋向于同一点
如果你对memcached访问的负载不高,那么Java-Memcached-Client是一个不错的选择,如果你对memcached访问的负载要求较高,推荐使用Xmemached,如果需要异步的批量处理,可以选择Spymemcached,如果你什么都不知道,那么建议使用Xmemached,因为无论在何种情况,它都可以表现出较好的性能,虽然不是最好

监控memcached
推荐使用nagios或cactis进行监控,nagios没有配置过,cactis是需要下载一个脚本插件
这里推荐一个从网上淘来的php,只要把它放到你的机器中,当然你的机器要支持php环境,将此php放入你的网页访问网络就可以访问
下载
http://www.blogjava.net/Files/dongbule/cacti/memcache.rar
修改php以下几个选项

define('ADMIN_USERNAME','memcache'); // Admin Username
define('ADMIN_PASSWORD','password'); // Admin Password

$MEMCACHE_SERVERS[] = '192.168.1.100:11211'; // add more as an array
#$MEMCACHE_SERVERS[] = 'mymemcache-server2:11211'; // add more as an array

监控的平台

理解memcached的删除机制
memcached内部不会监视记录是否过期,而是在get时查看记录的时间戳,检查记录是否过期, 这种技术被称为lazy(惰性)expiration.因此,memcached不会在过期监视上耗费CPU时间
memcached会优先使用已超时的记录的空间,并使用LRU算法来分配空间,因此当memcached的内存空间不足,就从最近违背使用的记录中搜索,并将空间分配给新的记录
不过在某些情况下LRU机制会造成某些麻烦,如你并不想要淘汰已被缓存过的记录,可以在memcached启动时添加 -M 参数来禁止LRU,但这样在memcached的内存用尽时,memcached会返回错误,是否使用LRU,在于你的需求

----------------------------------------

by 陈于喆
QQ:34174409
Mail: dongbule@163.com

陈于喆 2010-12-08 15:00 发表评论

读<代码大全>的一点记录之1

陈于喆 — Tue, 07 Dec 2010 09:59:00 GMT

很久以前就见过这本1000页的书<代码大全>,觉得应该是说些写代码的东西,没怎么又兴趣去读它,一次偶然的机会,发现自己是误解了它,<代码大全>觉得应该叫软件百科好像更合适一点,因为它里面涵盖了架构,分析,设计,编程,测试,重构,面向对象,调试,规范,管理,软件质量控制,协作,优化,开发工具,注释,甚至个性,开发艺术等等等,让人感觉就是一本软件百科全书.

书读的不多,不过刚开始读了100多页有一点感悟,所以做了一点记录,叫读<代码大全>的一点记录之1.

利用隐喻
隐喻通过把软件开发与你所熟知的事情联系在一起,从而使你对其更有深刻的理解,正是因为如此在计算机中的发展不过仅有数十年的历史,却拥有着所有科学最为丰富多彩的语言

盖房子的隐喻
狗屋
霹雳啪啦,木材加铁钉,犯错了怎么办?无所谓,拆了再来过

盖一栋房子
决定什么类型的房子-->问题定义
和某个建筑师探讨总体的设计-->软件架构设计
画出详细的蓝图-->详细设计
打地基,搭建房屋框架,砌墙,盖好屋顶,同水,电,煤气-->软件构建(编程)
油漆工和装修工把新盖的家进行美化-->软件的优化
监查人员来检查工地,地基,布线-->软件的复查

我们会发现很多软件工程学的名称就是从建筑学演变而来的如
软件架构(建筑学 architecture)
支撑性测试代码(脚手架,scaffolding)
构建(建设,construction)
基础类(foundation classes)

摘录
P70：使用隐喻又是件说不清楚的事情。你需要适当地引申它的含义，才能从其中蕴含的深刻启发中受益。但若你过分地或者在错误的方向上引申了它的含义，它也会误导你。正如人们会误用任何强大的工具一样，你也可能误用隐喻，但它的强大的功效，还是会成为你智慧工具箱中的一个宝贵部分

两条食物链
* 健康的生态环境中，海鸥吃新鲜的鲑鱼，鲑鱼吃新鲜的青鱼，青鱼吃新鲜的水蝽。这是一条健康的食物链。
* 软件开发中，架构师吃掉需求，设计师吃掉架构，程序员，软件食物链的最后一环，消化掉设计。
我们知道毒素是往上递增的,如果在软件开发中,从一开始就被污染了,那么每级的污染程度将递增,而程序员在处在食物链的最高层,也是毒素累积的最高层,就必须抗下所有犯下的错误

需求的 checklist
我们是否一定要做需求checklist?书中作者告诉我们并不一定要写需求分析树,但需求分析必须在大脑中,口头交流上完成,落下文字固然是好的,但并不是重点,关键在于做不做,一份checklist就想事一次"心智健全"的检查,看看你的地基是否坚固
详细的checklist包括是否详细定义了系统的全部输入，包括来源、精度、取值范围、出现频率。是否详细定义了系统全部输出，包括目的，精度，取值范围、出现频率，格式？是否定义了机器内存和剩余磁盘空间的最小值？是否详细定义了系统的可维护性，包括适应特定功能的变更、操作环境的变更、与其他软件的接口的变更能力？…..

构建高质量的子程序
书中作者用大篇幅去介绍如何构建高质量的子程序,在此章,作者用一个有问题的子程序罗列出他所指出的所有引发低质量子程序问题,我把以下的一个子程序认为是作者最好的总结

Procedure HandleStuff ( Var InputRec:CORP_DATA,CrntQtr:integer,
EmpRec:Emp_DATA, Var EstimRevenue:Real, YTDRevenue:Real,
ScreenX:integer,ScreenY:integer,Var NewColor:Color_TYPE,
Var PrevColor:COLOR_TYPE,Var Status:STATUS_TYPE,
ExpenseType:integer);
begin
for i := 1 to 100 do begin
InputRec.revenue[1]:= 0;
InputRec.expense[i]:=CorpExpensse[CrntQtr,i]
end;
UpdateCorpDatabase(EmpRec);
EstimRevenue:=YTDRevenue * 4.0 /real(CrntQtr)
NewColor:=PrevColor;
status:=Success;
if ExpenseType＝1 then begin
for i:= 1 to 12 do
Profit[i]:= Revenue[i]-Expense.Type[i]
end
else If ExpneseType= 2 then begin
Peofit[i]:=Revenue[i] - Expense.Type2[i]
end
else if ExpenseType= 3 then
begin
Profit[i]:=Revenue[i] - Expense.Type3[i]
end
end

下面的问题囊括了作者在此章说明的问题

1.程序的名字让人困惑。HandleStuff()能告诉我们程序是干什么的吗？
2.程序没有被说明
3.子程序的布局不好。代码的物理组织形式几乎没有给出其逻辑组织形式的任何信息。
4.布局的使用过于随心所欲，程序每一部分的布局都是不一样的。关于这一点。只要比较一下 ExpenseType=2 和 ExpenseType=3 两个地方的风格就清楚了
5.子程序的输入变量值 InputRec 被改变过。如果它作为输入变量，那它的值就不该变化。如果要变化它的值，就不该称之为输入变量 InputRec。
6.子程序进行了全局变量的读写操作。它从 CorpExpense中读入变量并写给 Profit。它应该与存取子程序通信，而不应直接读写全局变量。
7.这个子程序的功用不是单一的。它初始化了某些变量。对一个数据库进行写操作，又进行了某些计算工作，而它们又看不出任何联系。一个子程序的功用应该是单一，明了的。
8.子程序中没有采取预防非法数据的措施。如果 CrntQtr 的值为“0” ，那么，表达式YTDRevenue*4.0／real(CrntQtr)就会出现被零除的错误。
9.程序中使用了几个常数：100, 4.0, 12, 2 和 3。关于“神秘”(magic)数的问题见 11.1节“常数”
10.在程序中仅使用了域的 CORP_DATA 型参数的两个域。如果仅仅使用两个域，那就该仅仅传入特定的域而不是整个结构化变量。
11.子程序中的一些参数没有使用过。ScreenX和 ScreenY在程序中没有涉及。
12.程序中的一个参数被错误标定了。PrevColor被标定为变量型参数，然而在程序中又没有对其赋值。
13.程序中的参数太多。程序中参数个数的合理上限应该是七个左右。而这个程序中则多达11个。程序中的参数多得怕人，恐怕没谁会仔细检查它们，甚至连数一下都不愿意。

高扇入和低扇出
摘录
高内聚，低耦合很容易被重视。但是高扇入低扇出有时候会被忽略。这里是说，我们应该尽量的大量的使用某个低层次上给定的类(high fan-in) 而每个类都应该尽量少使用其他的类(控制在7个之下)。

小结
书中分别很详细的写了架构,设计,编程等等方面的内容,还不分巨细的讨论了函数,变量,语句等编程要点,这些内容基本上都是围绕着软件构建的核心就是管理复杂度来展开的,产生这个根源就在于人脑智力同软件项目复杂度的矛盾.
而解决这矛盾从作者书中总结可能有以下几点:
1.分割
系统分割,设计分割,代码分割....
2.清晰理解
抽象,封装
3.清晰表达

----------------------------------------

by 陈于喆
QQ:34174409
Mail: dongbule@163.com

陈于喆 2010-12-07 17:59 发表评论

开发人员与软件测试

陈于喆 — Fri, 03 Dec 2010 08:00:00 GMT

上个月参加的网易游戏部QA组的黑盒测试培训,觉得挺有意思的,不过最让我感兴趣的是,能和真正专业的测试人员做了一点讨论,发现站在开发人员的角度看待测试和站在测试人员看待测试时完全不同的一种东西.

程序员和测试人员的心理差别
程序员和测试人员的心理差别可以简单的归纳为以下几种

成功 / 不成功
什么才是一次成功的测试,大多数的开发人员对自己的程序测试完没发现错误,就会说"这是一个成功的测试",如果发现某些新的错误则称"这是不成功的测试";而测试人员刚好相反,当然这也是因为双方的职责不同而引起的

维护 / 破坏,施虐
开发人员对测试往往是一种维护性的测试,目标在于证明自己开发的程序没有错误,可能跟我们开发人员经常做建设性工作,更倾向创造事物,而不是将事物破坏有关;而测试人员在测试更多是一种破坏的过程,甚至是一种施虐,摆出一种把鸡蛋打碎搅黄来挑骨头的姿态

做了应该做的 / 做了不该做的
开发人员在做测试更多倾向于对实现的功能进行检查,当测试证明了该完成的功能全部通过时就认为测试完毕了,但程序即使能够完成预定的功能,也可能隐藏了错误,如做了应该做的东西,同时也做了不应该做的东西

建立一种信心 / 必须做
测试这个东西对于开发人员来说,更多的是建立一种信心的保证,例如我们尽可能多的单元测试,很多时候就是让我们确信程序的正确性,并让我们建立信心,而对于测试人员来说,测试是他们的职责所在,只有尽可能多的把系统挖出错误来才证明他们的存在价值

测试的态度
测试是一项技术性的工作,但同时也涉及到了心里学的一些重要的因素.
作为程序员的我们也经常会对我们的程序进行相关的测试,但你想想我们为什么要对我们的系统做测试,原因大概有以下的几种

1.测试就是为了证明我们的系统是不存在错误的.
2.测试的目的是想证明系统能够正确完成预定的功能.
3.测试是保证一个系统强壮性的信心过程.
4.测试是上级规定要做的.

站在测试人员的角度来看,除了最后一点,其他的都是本末倒置(难怪他们会抱怨我们做的测试很差)

"测试就是为了证明我们的系统是不存在错误的",试想一下,如果我们的目标是证明程序中不存在错误,那么我们的潜意识就会倾向于这个目标,我们会倾向选择可能较少导致出现程序失效的测试数据,如果我们的测试目标证明程序中存在错误,我们设计的测试数据就可能更多的发现问题.于前一种方法相比,后一种方法会更多地增加程序的价值.
每当测试一个程序,都是想为程序增加多一些的价值,通过测试发现系统的更多错误来增加程序的可靠性质量,提高了程序的可靠性,是指出并最终修改程序的错误.与"测试就是为了证明我们的系统是不存在错误的"比较,更适合的定义是
测试时为了发现错误而执行的过程

"测试的目的是想证明系统能够正确完成预定的功能",这个定义又会带来另一个问题,程序即使能够完成预定的功能,也依然可能隐藏错误,也就是说,当程序没有实现预期的功能,错误时能够清晰显示出来,但程序做了不应该做的呢,这同样也是一个错误,如我们程序实现了一个除法计算器,即使我们通过各种数据正确的完成了计算任务,但在完成了不应执行的任务(除数为0),程序依然是错误的,如果我们将软件测试作为发现错误的过程,而不是只是证明"系统能够正确完成预定的功能",我们发现这类的错误可能性会打很多,所以更好的定义是
测试就是建立程序即使能完成预定功能,也发现存在完成非预定功能

ps:当然了,测试更多是跟软件成本方面相关,这里就不细想了,附上讲座的ppt<实用的黑盒测试方法>

----------------------------------------

陈于喆 2010-12-03 16:00 发表评论

[整理]工程中jar功能对照表

陈于喆 — Wed, 03 Nov 2010 06:59:00 GMT

把我上次的工程所用到的jar包做了一个整理,也加了一些简单的描述,下面图是上次工程用到的所有jar吧

JAR包与描述对照表	注：jar包尾后的版本号不代表当前最高版本
activation-1.1.jar	Sun的JavaBeans Activation Framework（JAF）,JavaMail要运行必须依赖于它的支持
asm-3.0.jar asm-commons-2.2.3.jar asm-util-2.2.3.jar	asm是一个轻量级字节码处理和分析框架
alveole-struts2.jar alveole-tools.jar
aspectjtools-1.5.3.jar	Aspect提供的注释类库和相应的解析类库
atomikos-util.jar	数据库提供分布式事务支持
c3p0-0.8.5.2.jar	C3PO是一个数据库连接池
cglib-nodep-2.2.jar	CGLIB是一个强大的高质量高性能的代码生成库,在运行时可以用它来扩展Java类
commons-attributes-api.jar	Apache Commons包中的一个,包含了一些属性的api
commons-beanutils-1.6.jar	Apache Commons包中的一个，包含了一些Bean工具类类
commons-chain-1.1.jar
commons-codec-1.3.jar
commons-collections-3.2.jar	Apache Commons包中的一个,包含了一些Apache开发的集合类，功能比java.util.*强大
commons-configuration.jar	Apache Commons包中的一个,用于协助读取配置和首选项文件
commons-digester-1.8.jar	Apache Commons包中的一个,通过它可以很方便的解析xml文件生成java对象
commons-fileupload.jar	Apache Commons包中的一个,是一个通过Http接收上传的文件并处理结果文件的库
commons-lang-2.1.jar	Apache Commons包中的一个,包含了一些数据类型工具类，是java.lang.*的扩展
commons-httpclient-3.0.jar	Apache Commons包中的一个,提供一个框架啊处理http客户端的扩展
commons-io.jar	Apache Commons包中的一个,java.io.*的扩展,输入输出,支持文件上传
commons-logging-1.1.1.jar	Apache Commons包中的一个,包含日志功能
commons-logging-api-1.1.jar	Apache Commons包中的一个,Commons Logging应用接口,一种超薄适配器允许其他可配置桥连接
commons-validator-1.3.0.jar	Apache Commons包中的一个,struts使用它进行表单验证
dom4j-1.6.1.jar	dom4j XML 解析器
ezmorph-1.0.4.jar	json和java转化的辅助工具
freemarker-2.3.8.jar	freemarker表现层模板工具
hessian-3.1.3.jar	一个轻量级的remoting onhttp工具，使用简单的方法提供了RMI的功能
htmlparser.jar	强大的html解析器
httpsqs4j.jar	一款基于 HTTP GET/POST 协议的轻量级开源简单消息队列服务
ibatis-2.3.3.720.jar	iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAO）
jamon-2.7.jar	一个小巧的，免费的，高性能的，线程安全的性能监测工具
java_memcached-release.jar	memcached连接的java客户端
jfreechart-1.0.1.jar	使用java生成图表的工具
jcommon-1.0.8.jar	使用java生成图表的工具
json-lib-2.2-jdk15.jar	json和java转化的辅助工具
jta.jar	Java事务API,为J2EE平台提供了分布式事务服务
junit-3.8.1.jar	是一个开放源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例
jxl.jar	通过java操作excel表格的工具类库
log4j-1.2.9.jar	通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器
lucene-core-2.3.2.jar	是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎
mongo-2.2.jar	java连接mongodb客户端接口
morphia.jar	是一个轻量级的类型安全的Java类库，用来将在MongoDB和Java对象之间进行映射
mysql-connector-java.jar	mysql连接驱动
ognl-2.6.11.jar	OGNL表达式,支持EL
oscache-2.3.2.jar	Java对象的缓存工具,比ehcache的优势在于页面缓存
poi-3.0.1.jar	apache工具,用于操作pdf和excel的工具类
quartz-1.6.0.jar	自动任务处理功能类包
proxool-0.9.1.jar	Proxool JDBC 连接池工具
servlet.jar
spring-2.0.2.jar
spring-2.0.2.jar
velocity-1.6.3-dep.jar velocity-tools-1.4.jar	velocity基于java的模板引擎,允许用简单的模板语言来引用java定义的对象
xwork-core-2.1.6.jar	web work的核心库

下载<http://download.csdn.net/source/2806071>

注:blogjava上传不了,我传到csdn

----------------------------------------

by 陈于喆
QQ:34174409
Mail: dongbule@163.com

陈于喆 2010-11-03 14:59 发表评论

浏览器的缓存协商

陈于喆 — Tue, 24 Aug 2010 16:03:00 GMT

记得问过身边的一些开发工程师(非前端)缓存要分几个层次，从哪里做起，答案很多，比如反向代理缓存，DNS缓存，memcached，数据库缓存等等，确实很完整，不过好像漏掉了我们用户跟我们联通的最根本的工具浏览器，确实好似很少有人把用户的浏览器当作是web站点的组成部分来看待

缓存协商
现在我们需要将用户的浏览器也纳入我们构建网站各个缓存层次中的其中一个重要层次，网站信息和内容在由web服务器生成，而将这些信息和内容作为一段二进制的文件作为本地缓存文件存放在用户的浏览器，是两个独立个体共同完成的任务，所以两者之间需要一种沟通的机制，也就是HTTP的缓存协商

Last-Modified和If-Modified-Since协商
Last-Modified和If-Modified-Since分别位于响应头信息和请求头信息中，都是记录请求的页面最后的修改时间
在第一次访问web服务器会返回200状态，并在浏览器的响应头Last-Modified上写上此页面最后修改的时间戳
使用firebug进行查看

在再次访问时，浏览器会把第一次返回Last-Modified的时间戳记录到If-Modified-Since，并作为请求头信息发送到服务区，web服务器会通过If-Modified-Since上的时间戳来判断用户的页面是否是最新的，如果不是最新的，则返回新的页面并修改响应头Last-Modified时间戳给用户，如果判断是最新的，则返回304状态并告诉浏览器本地的cache页面是最新的，浏览器可以直接加载本地页面，这样可以减少网络上传输的数据，并且也减少服务器的负担。

这里需要注意的是，HTTP协议中规定使用的是GMT时间(格林威治)，而我们国家使用的是GMT+8的时间，所以我们从firebug中看到的时间是比我们早了8个小时，不过这没关系，它并不影响到缓存的对比工作

Etag协商
如果我们的一个文件存放在多台web服务器上，用户的请求在这些服务器上之间轮询，实现负载均衡，那些这个文件在各台web服务器的最后修改时间很可能是不一样，这样用户每次请求到的web服务器都可能是不同，Last-Modified和If-Modified-Since则无法对应，导致每次都需要重新获取内容，这时候采用直接标记内容的Etag算法，就可以避免上述的问题
Etag是由Web服务器生成的，如Apache为一个静态文件新增响应头为
Etag "e3af4060-5-472bedf076880"
浏览器获得这个Etag后，便会在下次请求该页面时，在HTTP的请求头附上If-None-Match "e3af4060-5-472bedf076880"，与web服务器上的Etag值相比较，如果是相同的话，便返回304状态，不同则重新返回新页面信息

当然啦，这里要指出浏览器缓存只针对HTML和HTM进行而动态文件则无法缓存，浏览器并不在乎你的文件是否动态还是静态，浏览器只认准和web服务器通讯的HTTP协商，所以只要动态页面HTTP头信息包含的缓存协商信息，动态内容也是可以一样被浏览器进行缓存的，和静态页面无什么两样，只是你确定你需要这样做，让动态页面被缓存？
以下是对一个jsp进行写头信息

response.addHeader("Last-Modified",DateUtl.format(new java.util.Date())+" GMT");
response.addHeader("ETag","e3af4060-5-472bedf076880");

同样，这样两个设置会写入浏览器的响应头，这个动态文件跟静态文件一样会被浏览器缓存

Expires
Expires标记告诉浏览器该页面何时过期，并且在此过期前不需要再访问web服务器，直接使用本地的缓存文件即可，这样请求响应头都不需要，确实节省了带宽和服务器的开销，但是就算页面在web服务器上更新后在Expires过期前也不会出现在用户面前，究竟是否应该在于我们的实际应用和取舍
下面是Apache中提供的mod_expires模块

<IfModule mod_expires.c>
ExpiresActive On
ExpiresDefault A600
ExpiresByType image/x-icon A2592000
ExpiresByType application/x-javascript A604800
ExpiresByType text/css A604800
ExpiresByType image/gif A2592000
ExpiresByType image/png A2592000
ExpiresByType image/jpeg A2592000
ExpiresByType text/plain A86400
ExpiresByType application/x-shockwave-flash A2592000
ExpiresByType video/x-flv A2592000
ExpiresByType application/pdf A2592000
ExpiresByType text/html A600
IfModule>

或者

<IfModule mod_expires.c>
ExpiresActive On
ExpiresDefault "access plus 12 hours"
ExpiresByType text/html "access plus 3 days"
ExpiresByType text/plain "access plus 3 days"
ExpiresByType text/css "access plus 7 days"
ExpiresByType image/gif "access plus 30 days"
ExpiresByType image/png "access plus 30 days"
ExpiresByType image/jpeg "access plus 30 days"
ExpiresByType image/x-icon "access plus 30 days"
ExpiresByType video/x-flv "access plus 30 days"
ExpiresByType application/x-shockwave-flash "access plus 30 days"
IfModule>

我们在jsp文件也可以指定expires的过期时间

response.addHeader("Expires",DateUtl.format(new java.util.Date())+" GMT");

当然啦，你再刷新也不会返回304状态，因为浏览器已经不用想web服务器发出请求

----------------------------------------

by 陈于喆
Mail: chenyz@corp.netease.com

参考文章
郭欣《构建高新能web站点》
中文版《HTTP协议(RFC2616)》

陈于喆 2010-08-25 00:03 发表评论

BlogJava-于吉吉的技术博客-随笔分类-web开发

《lua & ngx_lua 的介绍与应用 》

对setTimeout的误差堆积测试和简单分析

javascript 实现'秒杀，团购'倒计时展示的记录

简单分析cglib引起的PermSize Space内存溢出

js全局/局部变量的乌龙问题

房产地图google map的初步应用点滴.4)

解答一下几道笔试题

房产地图google map的初步应用点滴.3)

房产地图google map的初步应用点滴.2)

房产地图google map的初步应用点滴.1)

Minimal POM

解决hessian远程调用连接超时的问题

Javascript eval()使用上需要注意的安全问题

memcached一些应用点滴

读<代码大全>的一点记录之1

开发人员与软件测试

[整理]工程中jar功能对照表

浏览器的缓存协商

《lua & ngx_lua 的介绍与应用》