海水正蓝

面朝大海,春暖花开
posts - 145, comments - 29, trackbacks - 0, articles - 1
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

     摘要: 操作系统:WIN7数据库:oracle11g 64bit数据库客户端:32bit在网上找了很多解决方案,很多人说要将应用程序池改为启用32位应用程序。虽然能进入登录页面,但是在连接数据库时报错:尝试加载 Oracle 客户端库时引发 BadImageFormatException。如果在安装 32 位 Oracle 客户端组件的情况下以 64 位模式运行,将出现此问题。正确的解决方案:1.以管理员...  阅读全文

posted @ 2012-07-13 22:07 小胡子 阅读(2773) | 评论 (1)编辑 收藏

http://www.oschina.net/news/30791/opensource-projects-of-chinese?from=20120708
http://www.oschina.net/project/zh

posted @ 2012-07-12 22:54 小胡子 阅读(128) | 评论 (0)编辑 收藏

http://www.oschina.net/news/30661/15-most-popular-jquery-plugins-of-june?from=20120708

posted @ 2012-07-12 22:53 小胡子 阅读(220) | 评论 (0)编辑 收藏

Google 图片搜索功能

        在谷歌图片搜索中, 用户可以上传一张图片, 谷歌显示因特网中与此图片相同或者相似的图片.

        比如我上传一张照片试试效果:

原理讲解

        参考Neal Krawetz博士的这篇文章, 实现这种功能的关键技术叫做"感知哈希算法"(Perceptual Hash Algorithm), 意思是为图片生成一个指纹(字符串格式), 两张图片的指纹越相似, 说明两张图片就越相似. 但关键是如何根据图片计算出"指纹"呢? 下面用最简单的步骤来说明一下原理:

第一步 缩小图片尺寸

        将图片缩小到8x8的尺寸, 总共64个像素. 这一步的作用是去除各种图片尺寸和图片比例的差异, 只保留结构、明暗等基本信息.

       

第二步 转为灰度图片

         将缩小后的图片, 转为64级灰度图片.

       

第三步 计算灰度平均值

         计算图片中所有像素的灰度平均值

第四步 比较像素的灰度

        将每个像素的灰度与平均值进行比较, 如果大于或等于平均值记为1, 小于平均值记为0.

第五步 计算哈希值

         将上一步的比较结果, 组合在一起, 就构成了一个64位的二进制整数, 这就是这张图片的指纹.

第六步 对比图片指纹

        得到图片的指纹后, 就可以对比不同的图片的指纹, 计算出64位中有多少位是不一样的. 如果不相同的数据位数不超过5, 就说明两张图片很相似, 如果大于10, 说明它们是两张不同的图片.

代码实现 (C#版本)

        下面我用C#代码根据上一节所阐述的步骤实现一下.

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
using System;
using System.IO;
using System.Drawing;
 
namespace SimilarPhoto
{
    class SimilarPhoto
    {
        Image SourceImg;
 
        public SimilarPhoto(string filePath)
        {
            SourceImg = Image.FromFile(filePath);
        }
 
        public SimilarPhoto(Stream stream)
        {
            SourceImg = Image.FromStream(stream);
        }
 
        public String GetHash()
        {
            Image image = ReduceSize();
            Byte[] grayValues = ReduceColor(image);
            Byte average = CalcAverage(grayValues);
            String reslut = ComputeBits(grayValues, average);
            return reslut;
        }
 
        // Step 1 : Reduce size to 8*8
        private Image ReduceSize(int width = 8, int height = 8)
        {
            Image image = SourceImg.GetThumbnailImage(width, height, () => { return false; }, IntPtr.Zero);
            return image;
        }
 
        // Step 2 : Reduce Color
        private Byte[] ReduceColor(Image image)
        {
            Bitmap bitMap = new Bitmap(image);
            Byte[] grayValues = new Byte[image.Width * image.Height];
 
            for(int x = 0; x<image.Width; x++)
                for (int y = 0; y < image.Height; y++)
                {
                    Color color = bitMap.GetPixel(x, y);
                    byte grayValue = (byte)((color.R * 30 + color.G * 59 + color.B * 11) / 100);
                    grayValues[x * image.Width + y] = grayValue;
                }
            return grayValues;
        }
 
        // Step 3 : Average the colors
        private Byte CalcAverage(byte[] values)
        {
            int sum = 0;
            for (int i = 0; i < values.Length; i++)
                sum += (int)values[i];
            return Convert.ToByte(sum / values.Length);
        }
 
        // Step 4 : Compute the bits
        private String ComputeBits(byte[] values, byte averageValue)
        {
            char[] result = new char[values.Length];
            for (int i = 0; i < values.Length; i++)
            {
                if (values[i] < averageValue)
                    result[i] = '0';
                else
                    result[i] = '1';
            }
            return new String(result);
        }
 
        // Compare hash
        public static Int32 CalcSimilarDegree(string a, string b)
        {
            if (a.Length != b.Length)
                throw new ArgumentException();
            int count = 0;
            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] != b[i])
                    count++;
            }
            return count;
        }
    }
}

        谷歌服务器里的图片数量是百亿级别的, 我电脑里的图片数量当然没法比, 但以前做过爬虫程序, 电脑里有40,000多人的头像照片, 就拿它们作为对比结果吧! 我计算出这些图片的"指纹", 放在一个txt文本中, 格式如下.

        用ASP.NET写一个简单的页面, 允许用户上传一张图片, 后台计算出该图片的指纹, 并与txt文本中各图片的指纹对比, 整理出结果显示在页面中, 效果如下:

本文地址: http://www.cnblogs.com/technology/archive/2012/07/12/Perceptual-Hash-Algorithm.html





原文:http://www.cnblogs.com/technology/archive/2012/07/12/Perceptual-Hash-Algorithm.html

posted @ 2012-07-12 22:48 小胡子 阅读(274) | 评论 (0)编辑 收藏

Flyweight定义:
避免大量拥有相同内容的小类的开销(如耗费内存),使大家共享一个类(元类).

为什么使用?
面向对象语言的 原则就是一切都是对象,但是如果真正使用起来,有时对象数可能显得很庞大,比如,字处理软件,如果以每个文字都作为一个对象,几千个字,对象数就是几千, 无疑耗费内存,那么我们还是要"求同存异",找出这些对象群的共同点,设计一个元类,封装可以被共享的类,另外,还有一些特性是取决于应用 (context),是不可共享的,这也Flyweight中两个重要概念内部状态intrinsic和外部状态extrinsic之分.

说白点,就是先捏一个的原始模型,然后随着不同场合和环境,再产生各具特征的具体模型,很显然,在这里需要 产生不同的新对象,所以Flyweight模式中常出现Factory模式.Flyweight的内部状态是用来共享的,Flyweight factory负责维护一个Flyweight pool(模式池)来存放内部状态的对象.

Flyweight模式是一个提高程序效率和性能的模式,会大大加快程序的运行速度.应用场合很多:比如你要从一个数据库中读取一系列字符串,这些字符串中有许多是重复的,那么我们可以将这些字符串储存在Flyweight池(pool)中.

如何使用?

我们先从Flyweight抽象接口开始:

public interface Flyweight
{
  public void operation( ExtrinsicState state );
}

//用于本模式的抽象数据类型(自行设计)
public interface ExtrinsicState { }

下面是接口的具体实现(ConcreteFlyweight) ,并为内部状态增加内存空间, ConcreteFlyweight必须是可共享的,它保存的任何状态都必须是内部(intrinsic),也就是说,ConcreteFlyweight必须和它的应用环境场合无关.

public class ConcreteFlyweight implements Flyweight {
  private IntrinsicState state;
  
  public void operation( ExtrinsicState state )
  {
      //具体操作
  }

}

当然,并不是所有的Flyweight具体实现子类都需要被共享的,所以还有另外一种不共享的ConcreteFlyweight:

public class UnsharedConcreteFlyweight implements Flyweight {

  public void operation( ExtrinsicState state ) { }

}

Flyweight factory负责维护一个Flyweight池(存放内部状态),当客户端请求一个共享Flyweight时,这个factory首先搜索池中是否已经 有可适用的,如果有,factory只是简单返回送出这个对象,否则,创建一个新的对象,加入到池中,再返回送出这个对象.池

public class FlyweightFactory {
  //Flyweight pool
  private Hashtable flyweights = new Hashtable();

  public Flyweight getFlyweight( Object key ) {

    Flyweight flyweight = (Flyweight) flyweights.get(key);

    if( flyweight == null ) {
      //产生新的ConcreteFlyweight
      flyweight = new ConcreteFlyweight();
      flyweights.put( key, flyweight );
    }

    return flyweight;
  }
}

至此,Flyweight模式的基本框架已经就绪,我们看看如何调用:

FlyweightFactory factory = new FlyweightFactory();
Flyweight fly1 = factory.getFlyweight( "Fred" );
Flyweight fly2 = factory.getFlyweight( "Wilma" );
......

从调用上看,好象是个纯粹的Factory使用,但奥妙就在于Factory的内部设计上.

Flyweight模式在XML等数据源中应用
我们上面已经提到,当大量从数据源中读取字符串,其中肯定有重复的,那么我们使用Flyweight模式可以提高效率,以唱片CD为例,在一个XML文件中,存放了多个CD的资料.

每个CD有三个字段:
1.出片日期(year)
2.歌唱者姓名等信息(artist)
3.唱片曲目 (title)

其中,歌唱者姓名有可能重复,也就是说,可能有同一个演唱者的多个不同时期 不同曲目的CD.我们将"歌唱者姓名"作为可共享的ConcreteFlyweight.其他两个字段作为UnsharedConcreteFlyweight.

首先看看数据源XML文件的内容:


<?xml version="1.0"?>
<collection>

<cd>
<title>Another Green World</title>
<year>1978</year>
<artist>Eno, Brian</artist>
</cd>

<cd>
<title>Greatest Hits</title>
<year>1950</year>
<artist>Holiday, Billie</artist>
</cd>

<cd>
<title>Taking Tiger Mountain (by strategy)</title>
<year>1977</year>
<artist>Eno, Brian</artist>
</cd>

.......

</collection>


虽然上面举例CD只有3张,CD可看成是大量重复的小类,因为其中成分只有三个字段,而且有重复的(歌唱者姓名).

CD就是类似上面接口 Flyweight:


public class CD {

  private String title;
  private int year;
  private Artist artist;

  public String getTitle() {  return title; }
  public int getYear() {    return year;  }
  public Artist getArtist() {    return artist;  }

  public void setTitle(String t){    title = t;}
  public void setYear(int y){year = y;}
  public void setArtist(Artist a){artist = a;}

}

将"歌唱者姓名"作为可共享的ConcreteFlyweight:

public class Artist {

  //内部状态
  private String name;

  // note that Artist is immutable.
  String getName(){return name;}

  Artist(String n){
    name = n;
  }

}

再看看Flyweight factory,专门用来制造上面的可共享的ConcreteFlyweight:Artist

public class ArtistFactory {

  Hashtable pool = new Hashtable();

  Artist getArtist(String key){

    Artist result;
    result = (Artist)pool.get(key);
    ////产生新的Artist
    if(result == null) {
      result = new Artist(key);
      pool.put(key,result);
      
    }
    return result;
  }

}

当你有几千张甚至更多CD时,Flyweight模式将节省更多空间,共享的flyweight越多,空间节省也就越大.

posted @ 2012-07-11 21:58 小胡子 阅读(201) | 评论 (0)编辑 收藏

     摘要: =============C#.Net 篇目录==============   一、程序集的加载 程序集是 .NET Framework 应用程序的构造块;程序集构成了部署、版本控制、重复使用、激活范围控制和安全权限的基本单元。 绑定是查找与唯一指定的类型相对应的声明(即实现)的过程。根据此过程是发生在编译时还是运行时分为: a)     ...  阅读全文

posted @ 2012-07-11 21:57 小胡子 阅读(515) | 评论 (0)编辑 收藏

1. 概述

  将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化; 对请求排队或记录请求日志,以及支持可撤销的操作。

2. 解决的问题

  在软件系统中,行为请求者与行为实现者通常是一种紧耦合的关系,但某些场合,比如需要对行为进行记录、撤销或重做、事务等处理时,这种无法抵御变化的紧耦合的设计就不太合适。

3. 模式中角色

  3.1 抽象命令(Command):定义命令的接口,声明执行的方法。

  3.2 具体命令(ConcreteCommand):具体命令,实现要执行的方法,它通常是“虚”的实现;通常会有接收者,并调用接收者的功能来完成命令要执行的操作。

  3.3 接收者(Receiver):真正执行命令的对象。任何类都可能成为一个接收者,只要能实现命令要求实现的相应功能。

  3.4 调用者(Invoker):要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。

  3.5 客户端(Client):命令由客户端来创建,并设置命令的接收者。

4. 模式解读

  4.1 命令模式的类图

  

  4.2 命令模式的实现代码


/// <summary>
    /// 接收者类,知道如何实施与执行一个请求相关的操作,任何类都可能作为一个接收者。
    /// </summary>
    public class Receiver
    {
        
/// <summary>
        /// 真正的命令实现
        /// </summary>
        public void Action()
        {
            Console.WriteLine(
"Execute request!");
        }
    }

    
/// <summary>
    /// 抽象命令类,用来声明执行操作的接口
    /// </summary>
    public interface ICommand
    {
        
void Execute();
    }

    
/// <summary>
    /// 具体命令类,实现具体命令。
    /// </summary>
    public class ConcereteCommand : ICommand
    {
        
// 具体命令类包含有一个接收者,将这个接收者对象绑定于一个动作
        private Receiver receiver;

        
public ConcereteCommand(Receiver receiver)
        {
            
this.receiver = receiver;
        }

        
/// <summary>
        /// 说这个实现是“虚”的,因为它是通过调用接收者相应的操作来实现Execute的
        /// </summary>
        public void Execute()
        {
            receiver.Action();
        }
    }

    
/// <summary>
    /// 调度类,要求该命令执行这个请求
    /// </summary>
    public class Invoker
    {
        
private ICommand command;

        
/// <summary>
        /// 设置命令
        /// </summary>
        /// <param name="command"></param>
        public void SetCommand(ICommand command)
        {
            
this.command = command;
        }

        
/// <summary>
        /// 执行命令
        /// </summary>
        public void ExecuteCommand()
        {
            command.Execute();
        }
    }
4.3 客户端代码

class Program
    {
        
static void Main(string[] args)
        {
            Receiver receiver 
= new Receiver();
            ICommand command 
= new ConcereteCommand(receiver);
            Invoker invoker 
= new Invoker();

            invoker.SetCommand(command);
            invoker.ExecuteCommand();

            Console.Read();
        }
    }
执行结果

  

  4.4 模式分析

    4.4.1 本质:对命令进行封装,将发出命令与执行命令的责任分开。

    4.4.2 每一个命令都是一个操作:请求的一方发出请求,要求执行一个操作;接收的一方收到请求,并执行操作。

    4.4.3 请求方和接收方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是怎么被接收,以及操作是否被执行、何时被执行,以及是怎么被执行的。

    4.4.4 使请求本身成为一个对象,这个对象和其它对象一样可以被存储和传递。

    4.4.5 命令模式的关键在于引入了抽象命令接口,且发送者针对抽象命令接口编程,只有实现了抽象命令接口的具体命令才能与接收者相关联。 

5. 模式总结

  5.1 优点

    5.1.1 解除了请求者与实现者之间的耦合,降低了系统的耦合度。

    5.1.2 对请求排队或记录请求日志,支持撤销操作。

    5.1.3 可以容易地设计一个组合命令。

    5.1.4 新命令可以容易地加入到系统中。

  5.2 缺点

    5.2.1 因为针对每一个命令都需要设计一个具体命令类,使用命令模式可能会导致系统有过多的具体命令类。

  5.3 适用场景

    5.3.1 当需要对行为进行“记录、撤销/重做”等处理时。

    5.3.2 系统需要将请求者和接收者解耦,使得调用者和接收者不直接交互。

    5.3.3 系统需要在不同时间指定请求、请求排队和执行请求。

    5.3.4 系统需要将一组操作组合在一起,即支持宏命令。

6. 应用举例:银行帐号的存款、提款

  6.1 类图

  

  6.2 代码实现


/// <summary>
    /// 银行帐号
    /// </summary>
    public class Account
    {
        
/// <summary>
        /// 帐号总金额
        /// </summary>
        private decimal totalAmount { get; set; }

        
/// <summary>
        /// 存钱
        /// </summary>
        /// <param name="amount"></param>
        public void MoneyIn(decimal amount)
        {
            
this.totalAmount += amount;
        }

        
/// <summary>
        /// 取钱
        /// </summary>
        /// <param name="amount"></param>
        public void MoneyOut(decimal amount)
        {
            
this.totalAmount -= amount;
        }

        
public decimal GetTotalAmout()
        {
            
return totalAmount;
        }
    }

    
public abstract class Command
    {
        
protected Account account;

        
public Command(Account account)
        {
            
this.account = account;
        }

        
public abstract void Execute();
    }

    
/// <summary>
    /// 存款命令
    /// </summary>
    public class MoneyInCommand : Command
    {
        
private decimal amount;

        
public MoneyInCommand(Account account, decimal amount)
            : base(account)
        {
            
this.amount = amount;
        }

        
/// <summary>
        /// 实现存钱命令
        /// </summary>
        public override void Execute()
        {
            account.MoneyIn(amount);
        }
    }

    
/// <summary>
    /// 取款命令类
    /// </summary>
    public class MoneyOutCommand : Command
    {
        
private decimal amount;
        
public MoneyOutCommand(Account account, decimal amount)
            : base(account)
        {
            
this.amount = amount;
        }

        
/// <summary>
        /// 实现取钱命令
        /// </summary>
        public override void Execute()
        {
            account.MoneyOut(amount);
        }
    }

    
public class Invoker
    {
        
private Command command;

        
public void SetCommand(Command command)
        {
            
this.command = command;
        }

        
public void ExecuteCommand()
        {
            command.Execute();
        }
    }
6.3 客户端代码

class Program
    {
        
static void Main(string[] args)
        {
            
// 创建银行帐号
            Account account = new Account();
            
// 创建一个存入500元的命令
            Command commandIn = new MoneyInCommand(account,500);
            
// 创建一个调度者
            BankAccount.Invoker invoker = new BankAccount.Invoker();

            
// 设置存钱命令
            invoker.SetCommand(commandIn);
            
// 执行
            invoker.ExecuteCommand();
            Console.WriteLine(
"The current amount is " + account.GetTotalAmout().ToString("N2"));

            
// 再次存入500
            Command commandIn2 = new MoneyInCommand(account, 500);
            invoker.SetCommand(commandIn2);
            invoker.ExecuteCommand();
            Console.WriteLine(
"The current amount is " + account.GetTotalAmout().ToString("N2"));

            
// 取出300
            Command commandOut = new MoneyOutCommand(account, 300);
            invoker.SetCommand(commandOut);
            invoker.ExecuteCommand();
            Console.WriteLine(
"The current amount is " + account.GetTotalAmout().ToString("N2"));

            Console.Read();
        }
    }

 执行结果

  


转自:
http://www.cnblogs.com/wangjq/archive/2012/07/11/2585930.html


posted @ 2012-07-11 21:54 小胡子 阅读(152) | 评论 (0)编辑 收藏

需求场景:

1.  页面内有多级iframe嵌套。

2.  iframe内部某些按钮点击后需要弹出浮层。

3.  浮层需要将整个浏览器窗口遮罩,且浮层位于浏览窗口中部。

 

效果如下: 

 

解决思路:

  1. 顶层页面内预留用于显示浮层的div(命名为popdiv),且该div内有一预留的iframe,该iframe用于加载浮层内容,命名为popiframe
  2. 提供可以直接访问浮层内容的url连接
  3. iframe触发显示浮层事件时,通过window.top 设置顶层窗口的popiframe.src。
  4. 通过计算浮层内容的长宽及当前窗口的长宽设置popdiv的位置,使其在窗口中央显示。

 

 

 

实现:

顶层页面相关html代码:

<div id="mask" style="display:none;"></div>

 

<div id="id_popdiv" style="display:none;" class="popup">

    <iframe id="id_popiframe" src="" frameborder="0" scrolling="no" width="100%" height="100%">

    </iframe>

</div>

 

iframe有点击按钮的html代码

<script type="text/javascript" src="js/popmanager.js"></script>

 

<a href="javascript:pop('popcontenturl',782,600);" class="link" rel="1">show pop content</a><br />

 

popcontenturl 页面中的关闭的主要代码:

<script type="text/javascript" src="js/showhide.js" charset="utf-8"></script>

<div class="pop_container">

         <a href="javascript:unpop();" title="关闭" class="close"></a>

         <h2 class="title">浮层标题</h2>

    <div class="pop_content">

       浮层内容

    </div>

</div>

 

 

主要js代码(popmanager.js)

function getWindowScrollTop(win){

         var scrollTop=0;

         if(win.document.documentElement&&win.document.documentElement.scrollTop){

                   scrollTop=win.document.documentElement.scrollTop;

         }else if(win.document.body){

                   scrollTop=win.document.body.scrollTop;

         }

         return scrollTop;

}

function setWindowScrollTop(win, topHeight)

{

    if(win.document.documentElement)

    {

        win.document.documentElement.scrollTop = topHeight;

    }

    if(win.document.body){

        win.document.body.scrollTop = topHeight;

    }

}

function getWindowScrollLeft(win){

         var scrollLeft=0;

         if(win.document.documentElement&&win.document.documentElement.scrollLeft){

                   scrollLeft=win.document.documentElement.scrollLeft;

         } else if(win.document.body){

                   scrollLeft=win.document.body.scrollLeft;

         }

         return scrollLeft;

}

function getWindowHeight(win){

         var clientHeight=0;

         if(win.document.body.clientHeight&&win.document.documentElement.clientHeight){

                   clientHeight = (win.document.body.clientHeight<win.document.documentElement.clientHeight)?

            win.document.body.clientHeight:win.document.documentElement.clientHeight;

         }else{

                   clientHeight = (win.document.body.clientHeight>win.document.documentElement.clientHeight)?

            win.document.body.clientHeight:win.document.documentElement.clientHeight;

         }

         return clientHeight;

}

function getWindowWidth(win){

         var clientWidth=0;

         if(win.document.body.clientWidth&&win.document.documentElement.clientWidth){

                   clientWidth = (win.document.body.clientWidth<win.document.documentElement.clientWidth)?

            win.document.body.clientWidth:win.document.documentElement.clientWidth;

         }else{

                   clientWidth = (win.document.body.clientWidth>win.document.documentElement.clientWidth)?

            win.document.body.clientWidth:win.document.documentElement.clientWidth;

         }

         return clientWidth;

}

 

function unpop()

{

    try{

        var win = (top && top!=self)?top:window;

    }

    catch(e)

    {

        return ;

    }

   

    win.document.getElementById('mask').style.display = "none";

    win.document.getElementById("id_popdiv").style.display = "none";

    win.document.getElementById("id_iframe_pop").setAttribute('src', '');

   

}

 

function pop(url,width,height)

{

    try{

        var win = (top && top!=self)?top:window;

    }

    catch(e)

    {

        return ;

    }

   

   

    var topWindowHeight = getWindowHeight(win);

    var topWindowWidth = getWindowWidth(win);

 

    var lvTop=parseInt((topWindowHeight-height)/2)+parseInt(getWindowScrollTop(win));

    var lvLeft=parseInt((topWindowWidth-width)/2)+parseInt(getWindowScrollLeft(win));

    lvTop = lvTop<=0?1:lvTop;

    lvLeft = lvLeft<=0?1:lvLeft;

   

 

    win.document.getElementById("id_popdiv").style.top=lvTop+"px";

    win.document.getElementById("id_popdiv").style.left=lvLeft+"px";

    win.document.getElementById("id_popdiv").style.margin="0";

   

    win.document.getElementById("id_iframe_pop").setAttribute('src', url);

 

            

    win.document.getElementById("id_iframe_pop").setAttribute('width', width);

    win.document.getElementById("id_iframe_pop").setAttribute('height', height);

   

    win.document.getElementById('mask').style.display = "block";

    win.document.getElementById("id_popdiv").style.display = "block";

}

 

 

 

 

附:

应用较多的div浮层技术为基于jquery的blockUI技术。详情请参考相关文档。

转自:
http://www.cnblogs.com/zhanghairong/archive/2012/07/11/2586050.html

posted @ 2012-07-11 21:47 小胡子 阅读(816) | 评论 (0)编辑 收藏

    软件测试要求开发人员避免测试自己开发的程序。从心理学角度讲,这是很有道理的。特别是一个相对复杂的系统,开发人员在刚刚开发完成的时候,尚沉浸于对自己设计的回味之中。此时去测试的话往往会侧重于程序本身的功能通过性测试。很难发现错误。
    测试是为发现错误而执行程序的错误。一个人发现别人身上的不足很容易,但发现自己身上的错误便不那么容易了。所谓“吾能指人之失而不能见己之失,吾能指 人之小失而不能见己之大失”者是也。一个软件开发人员需要养成一种习惯,正视自己开发的软件,特别是刚刚完成的软件。要看到它的不足,知道他能做什么,不 能做什么。在不能做的时候是如何处理的。对边界条件是否做了严格的判断及约束。其实大道相通,有没有这样的意识往往跟一个人为人处世的心态,对自己的认知 有密切的联系。一个追求完美,经常反思自己的人往往有一种虚怀若谷的情怀,“战战兢兢、如履薄冰、如临深渊”者是也。所谓的方法、套路仅仅是方便于那些不 怎么思考,只会人云亦云、亦步亦趋的人设计的。
    说了一些心态方面的,再来从方法学上说一下软件测试的要点,对开发人员来说,白盒测试要比黑盒测试更重要,这决定着你的系统上线后你能不能安心的睡觉; 测试的阶段主要在单元测试与集成测试方面。

    先看一张测试相关的图:


 

    按照测试的过程,分为单元测试、集成测试、系统测试、验收测试四点。对于开发人员来说,我只强调前面两点。
    单元测试主要测试编写的类、类中的函数等。这是测试的最小单元。常用的测试工具有java的JUnit、BoostTest等。
    集成测试侧重于系统的整体功能性测试,这需要模拟各种可能的请求情况,特别是边界条件。在多系统中,单个系统的测试完了后还需要各个系统之间的联调。

    测试目标方面,除了一般的功能测试之外还需要稳定性测试、性能测试、可靠性测试、适用性测试、易用性测试、安全性测试。
    下面详细介绍一下各个测试要点的测试内容。
   1.   功能性测试

     在软件测试领域的通用理解是:“功能测试是基于产品功能说明书,是在已知产品所应具有的功能,从用户角度来进行功能验证,以确认每个功能是否都能正常使 用、是否实现了产品规格说明书的要求、是否能适当地接收输入数锯而产生正确的输出结果等。功能测试,包括用户界面测试、各种操作的测试、不同的数据输入、 逻辑思路、数据输出和存储等的测试。”    对于开发人员来说,功能性测试主要是对系统所支持的功能点的测试,对数据的测试,包括数据边界的测试、数据包长度限制的测试、各个功能模块数据的正确性测 试以及容错处理。该项测试要先把系统的功能点全部列出来,对异常数据的处理也算在内。
  2. 稳定性测试

    测试在压力情况下内存使用情况,cpu使用情况,是否有内存泄露,各个模块功能是否正常,能否正常提供服务,是否会在高压情况下卡死等。这也需要用各种可 能数据进行压力测试,要测试边界条件下,收到攻击时还能否正常工作,系统有没有自清理功能等。个人的理解,该项测试类似于可靠性测试,要点在于测试系统在 极端情况下是否正常。比如一个房子在高强度地震下的抗震能力。
 3.  性能测试

    测试程序(一般是服务器),每秒能正常处理的请求数。这项测试一般是寻找系统的性能瓶颈,看看能否满足实际的需求。当下,一个服务器每天处理5000万的请求便可以了。当然,通过优化对性能的追求是没有止境的。
 4.  安全性测试:

    安全性测试的主要目的是 确保软件不会去完成没有预先设计的功能。这一点很重要,需要开发人员在开发时对可能出现的情况作细致的判断。常见的安全性测试内容有:畸形的文件结构、畸 形的数据包、用户输入的验证、验证资源之间的依赖关系、配置文件等的格式等。因为开发人员常常假定他所获取的资源内容是符合一定标准或规则的。附录十常见 的web安全性测试的内容。
  5. 适用性测试:

     在软件测试领域的通用理解是“适用性主要是用户体验的评估活动”。个人理解,对于开发人员,这方面主要跟易用性测试联系起来,开发软件产品是为了更方便的 为人服务,一个系统要尽可能的简单,尽可能减少人工的操作。比如,在配置文件方面,有配置是为了减少代码的改动性,但是配置要尽可能的简单,可以由一个配 置项解决的问题不要再添加另外一项配置。
    

附: WEB安全性测试
一个完整的WEB安全性测试可以从部署与基础结构、输入验证、身份验证、授权、配置管理、敏感数据、会话管理、加密。参数操作、异常管理、审核和日志记录等几个方面入手。
1.        安全体系测试
1)        部署与基础结构
l        网络是否提供了安全的通信
l        部署拓扑结构是否包括内部的防火墙
l        部署拓扑结构中是否包括远程应用程序服务器
l        基础结构安全性需求的限制是什么
l        目标环境支持怎样的信任级别
2)        输入验证
l        如何验证输入
A.        是否清楚入口点
B.        是否清楚信任边界
C.        是否验证Web页输入
D.        是否对传递到组件或Web服务的参数进行验证
E.        是否验证从数据库中检索的数据
F.        是否将方法集中起来
G.        是否依赖客户端的验证
H.       应用程序是否易受SQL注入攻击
I.        应用程序是否易受XSS攻击
l        如何处理输入
3)        身份验证
l        是否区分公共访问和受限访问
l        是否明确服务帐户要求
l        如何验证调用者身份
l        如何验证数据库的身份
l        是否强制试用帐户管理措施
4)        授权
l        如何向最终用户授权
l        如何在数据库中授权应用程序
l        如何将访问限定于系统级资源
5)        配置管理
l        是否支持远程管理
l        是否保证配置存储的安全
l        是否隔离管理员特权
6)        敏感数据
l        是否存储机密信息
l        如何存储敏感数据
l        是否在网络中传递敏感数据
l        是否记录敏感数据
7)        会话管理
l        如何交换会话标识符
l        是否限制会话生存期
l        如何确保会话存储状态的安全
8)        加密
l        为何使用特定的算法
l        如何确保加密密钥的安全性
9)        参数操作
l        是否验证所有的输入参数
l        是否在参数过程中传递敏感数据
l        是否为了安全问题而使用HTTP头数据
10)        异常管理
l        是否使用结构化的异常处理
l        是否向客户端公开了太多的信息
11)        审核和日志记录
l        是否明确了要审核的活动
l        是否考虑如何流动原始调用这身份
2.        应用及传输安全
WEB应用系统的安全性从使用角度可以分为应用级的安全与传输级的安全,安全性测试也可以从这两方面入手。
应用级的安全测试的主要目的是查找Web系统自身程序设计中存在的安全隐患,主要测试区域如下。
l        注册与登陆:现在的Web应用系统基本采用先注册,后登录的方式。
A.        必须测试有效和无效的用户名和密码
B.        要注意是否存在大小写敏感,
C.        可以尝试多少次的限制
D.        是否可以不登录而直接浏览某个页面等。
l        在线超时:Web应用系统是否有超时的限制,也就是说,用户登陆一定时间内(例如15分钟)没有点击任何页面,是否需要重新登陆才能正常使用。
l        操作留痕:为了保证Web应用系统的安全性,日志文件是至关重要的。需要测试相关信息是否写进入了日志文件,是否可追踪。
l        备份与恢复:为了防范系统的意外崩溃造成的数据丢失,备份与恢复手段是一个Web系统的必备功能。备份与恢复根据Web系统对安全性的要求可以采用多种手 段,如数据库增量备份、数据库完全备份、系统完全备份等。出于更高的安全性要求,某些实时系统经常会采用双机热备或多级热备。除了对于这些备份与恢复方式 进行验证测试以外,还要评估这种备份与恢复方式是否满足Web系统的安全性需求。
传输级的安全测试是考虑到Web系统的传输的特殊性,重点测试数据经客户端传送到服务器端可能存在的安全漏洞,以及服务器防范非法访问的能力。一般测试项目包括以下几个方面。
l        HTTPS和SSL测试:默认的情况下,安全HTTP(Soure HTTP)通过安全套接字SSL(Source Socket Layer)协议在端口443上使用普通的HTTP。HTTPS使用的公共密钥的加密长度决定的HTTPS的安全级别,但从某种意义上来说,安全性的保证 是以损失性能为代价的。除了还要测试加密是否正确,检查信息的完整性和确认HTTPS的安全级别外,还要注意在此安全级别下,其性能是否达到要求。
l        服务器端的脚本漏洞检查:存在于服务器端的脚本常常构成安全漏洞,这些漏洞又往往被黑客利用。所以,还要测试没有经过授权,就不能在服务器端放置和编辑脚本的问题。
l        防火墙测试:防火墙是一种主要用于防护非法访问的路由器,在Web系统中是很常用的一种安全系统。防火墙测试是一个很大很专业的课题。这里所涉及的只是对防火墙功能、设置进行测试,以判断本Web系统的安全需求。
转自:
http://hi.baidu.com/yelangdefendou/blog/item/a4ce5c472d8b632b8794738c.html

posted @ 2012-07-11 21:45 小胡子 阅读(149) | 评论 (0)编辑 收藏

最近在给客户做项目的时候客户提出要求要给图片加水印, 在添加文字水印时,让用户自定义自体,当用户在选择字体时,如果勾选了删除线和下划线选项,而java.awt.Font不支持下划线和删除线的style, 这怎么办呢?

字体设置

还好,Java提供了 AttributedString 类, 通过

attributedString.addAttribute(TextAttribute.STRIKETHROUGH, TextAttribute.STRIKETHROUGH_ON);

attributedString.addAttribute(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON);

即可给文字添加删除线和下划线,再通过

graphics2D.drawString(as.getIterator(), x, y);

就可以显示下划线和删除线的效果了。

删除线下划线效果

Java代码
  1. import java.awt.Font;  
  2. import java.awt.Graphics;  
  3. import java.awt.Graphics2D;  
  4. import java.awt.RenderingHints;  
  5. import java.awt.font.TextAttribute;  
  6. import java.text.AttributedString;  
  7.   
  8. import javax.swing.JFrame;  
  9. import javax.swing.JPanel;  
  10.   
  11. public class IteratorUnderStrike extends JPanel{  
  12.   public void paint(Graphics g) {  
  13.     Graphics2D g2 = (Graphics2D) g;  
  14.   
  15.     String s = "/"www.java2s.com/" is great.";  
  16.   
  17.     g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,  
  18.         RenderingHints.VALUE_ANTIALIAS_ON);  
  19.     Font plainFont = new Font("Times New Roman", Font.PLAIN, 24);  
  20.   
  21.     AttributedString as = new AttributedString(s);  
  22.     as.addAttribute(TextAttribute.FONT, plainFont);  
  23.     as.addAttribute(TextAttribute.UNDERLINE, TextAttribute.UNDERLINE_ON, 1, 15);  
  24.     as.addAttribute(TextAttribute.STRIKETHROUGH, TextAttribute.STRIKETHROUGH_ON, 18, 25);  
  25.   
  26.     g2.drawString(as.getIterator(), 24, 70);  
  27.   }  
  28.   
  29.   public static void main(String[] args) {  
  30.     JFrame f = new JFrame();  
  31.     f.getContentPane().add(new IteratorUnderStrike());  
  32.     f.setSize(850, 250);  
  33.     f.show();  
  34.   }  



http://yanghuidang.iteye.com/blog/1203582

posted @ 2012-07-10 13:09 小胡子 阅读(3608) | 评论 (1)编辑 收藏

仅列出标题
共15页: First 上一页 7 8 9 10 11 12 13 14 15 下一页