Code-StandUp

IOS delegate你必須知道的事情

2011-11-28T18:47:00.000-08:00

ios delegate你必須知道的事情

當你開始寫iOS程式不久，應該開始面對到很多的delegate，
不管是用別人的library或是自己寫library，可能都逃不了delegate。
為了怕有些人不知道什麼是delegate，在這邊簡單的介紹一下，
delegate中文叫做委託，通常會用在class內部把一些事件處理"委託"給別人去完成。
舉個例子，XML Parser可能他知道怎麼parse xml，但是parse到的東西要怎麼處理xml parser可能不知道。
所以NSXMLParser就提供了一個NSXMLParserDelegate給client去實作，
當parse到某個element的時候，就callback delegate所定義的message，
讓他client自己去決定怎麼去處理這個element。
好吧，我承認我解釋的很模糊，不過我這篇本來就不是要你搞懂什麼是delegate，
而是針對使用或是設計delegate的時候，可能會要注意的事情。

在我們的class中設計delegate的時候，我們通常會有幾個注意事項。
假設我的class叫做MyClass，那我們可能會有定義一個MyClassDelegate這個protocol當作我的delegate protocol。
而MyClass中我們可能是這樣寫。

@protocol MyClassDelegate  - (void) myClassOnSomeEvent:(MyClass*)myClass; @end  @interface MyClass {     id _delegate; } @property (nonatomic, assign) delegate; @end

上面的code我們注意到delegate此property是定義為@property (assign)。
為什麼我們不用retain而要用assign呢?
原因就是在於iOS的reference counting的環境中，我們必須解決circular count的問題。
讓我們來寫寫我們平常都怎麼用delegate的，下面的code我想大家應該不陌生

- (void)someAction {    myClass = [MyClass new];    myClass.delegate = self;    .... }

這邊很快的就出現circular reference了
假設上面的code是寫在一個myViewController的物件當中，
之後一旦myViewController的reference count變成1的時候，
myViewController跟myClass這兩個兄弟兩只剩下互相retain，那就變成了孤島，也就因此造成了memory leak!!!

也因為這樣，iOS官方文件才會要建議我們所以的delegate都要用assign property。
也就是所謂"weak reference"的property，他的特色就是雖然會持有對方的reference，但是不會增加retain count。
如此下來，當myViewController的retain count變成0，則會dealloc。
同時在dealloc中，也一併把myClass release，則myClass也跟著被release。

- (void)dealloc {    [myClass release];    [super dealloc]; }

事情就結束了嗎? 還沒有唷...
這邊還有一個大家常常忘記的重點，那就是上面的dealloc這樣寫會有潛在危險。
應該要改成這樣

- (void)dealloc {    myClass.delegate = nil;    [myClass release];    [super dealloc]; }

你可能會很納悶，myClass不是馬上就會被release了嗎? 幹嘛要先把他的delegate設成nil?
那是因為我們假設myClass會馬上會被dealloc，但是現實狀況這個是不一定的，
有可能裡面內部有建個NSURLConnection，或是正在做某件事情而讓其他物件也retain myClass。
如果myClass沒有馬上dealloc，那他的myClass.delegate不就正指向一個不合法的位置了嗎? (此種pointer稱作dangling pointer)

解決方法是在MyViewController的dealloc中，在release myClass之前，
要先把原本指向自己的delegate改設成nil，這樣才可以避免crash發生。
在我之前寫的project，很大一部份的crash都是這樣造成的，因為這個問題通常不是每次都發生，
但是發生的時候確很難在重新複製，所以不可不慎啊。

但是很興奮的是到了iOS5中的Automatic Reference Counting這個問題可以有所改善。
在ARC中提出了一個新的weak reference的概念來取代原本的assign，
weak reference指到的物件若是已經因retain count歸零而dealloc了，則此weak reference也自動設成nil。
而原本舊的這種assign的作法，在ARC中叫做__unsafe_unretained，這只是為了相容iOS4以下的版本。

回顧重點:
如果你是寫library給別人用的，記得把你的delegate設成assign property，這樣才不會造成circular reference
當你是要始用別人的library，記得在你自己dealloc的時候，把delegate設成nil，以避免crash的事情發生。

source: http://webcache.googleusercontent.com/search?q=cache:dv0DZ9ilW3oJ:popcornylu.blogspot.com/2011/07/delegate.html+&cd=4&hl=zh-TW&ct=clnk&lr=lang_zh-CN%7Clang_zh-TW

IOS UITableView 重用机制浅析

2011-11-07T02:53:00.000-08:00

iphone重用机制是苹果为了实现大量数据显示而采用的一种节省内存的机制，但是在实际使用过程中，会有以下问题：

1、使用addSubView在每项上添加视图的时候会有重叠的现象。例如，UITableView中的Cell ，如果在cell上添加视图，则在使用苹果的重用机制的时候，会重现重叠的现象。刚开始学习的时候，觉得这个重用不太合适，原因：在数据不是很多的时候，个人觉得使用不使用重用机制都可以，于是乎，干脆放弃使用这套机制。代码如下：

UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell != nil) {
[cell release];
}

但是在数据多的时候，感觉使用重用机制会好对你的程序的内存使用和优化都有很重要的作用。但是这样的话，如果想再cell上添加东西的话，重叠现象会很严重。偶然间，使用xib给cell添加视图，发现不会出现重叠的现象。

具体步骤：

（1）新建一个基于UITableViewCell的类A和一个空白的xib。

（2）在A类中声明要添加的视图，例如IBOutlet UILabel *nameLabel,*timeLabel; ，注意：一要是使用IBOutlet。

（3）将xib中的view删除，拖一个 UITableViewCell，然后将这个UITableViewCell的类改为基于A。再把相应的视图添在UITableViewCell上，并且与A类内定义的变量进行连接。这样准备工作就完成了。

（4）使用方法：

A* cell = (A*)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
NSArray* nib = [[NSBundle mainBundle] loadNibNamed:@"VideoCell" owner:self options:nil];
cell = [nib objectAtIndex:0];
}

然后只需在下面改变cell相应视图的属性就可以了。

补充：在使用地图MKMapView一会使用到重用机制，如果想要在MKPinAnnotationView添加视图的话，最好放弃那个重用机制，要不然效果会乱七八糟的～～

2、我相信很多人都会好奇这套重用机制怎么实现的？我也很好奇，一直没找到相关的文档。不过有些认为就是建一个队列或者池子，如果UITableViewCell过多的话，它就会自动清除一些cell，然后如果比较少，它就会自动在这个队列或池子里面添加元素，这样避免了许多使用相同的Style 的Cell。

PS：还是好好研究下C语言的内存管理吧，我觉得那个才是真真意义上的内存管理。OC内存管理还是比较简单的。

更正：今天查别的问题的时候偶尔看到一个老外写的UITableView的代码，发现了一种新的实现方式。实现方式如下：

1、cell的释放使用默认的释放：

UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
cell = [[[UITableViewCell alloc] init....] autorelease];

UITextField *field = ...;//初始化

[cell addSubView:field];//添加

[field release];//释放

}

2、通过遍历修改UILabel属性

UITextField*field = nil;

for(UIView *v in cell.contentView.subviews)

{

if([v isMemberOfClass:[UILabel class]])

field = (UITextField *)v;

}

......//修改field的属性

这种方法不敢说有多好，但是给我们提供了一种解决方案，看大家的喜好了｀｀｀例如不喜欢xib的，可以尝试下.

source: http://hi.baidu.com/%CB%E6%B7%E7_1989/blog/item/077c8a944ae7a69ca877a41d.html

IOS内存管理

2011-11-07T02:00:00.001-08:00

内存管理

我一直惊叹iOS和Objective-C内存处理能力，例如iPad版本的iWork，Pages应用就是一个内存处理技术应用的鬼斧神工之作。想想256M内存的iPad，可以带来如此的华丽的界面同时获得如此流畅的用户体验，真是不简单。原因就是iOS一直提倡开发者在有限硬件资源内写出最优化的代码，使用CPU最少，占用内存最小。（以下代码适用于iOS SDK 4.1, 由于新SDK 4.2对内存使用有新改动，所以可能有不同。。。）

尽量少的UIView层
通常我们喜欢把很多控件层（UILabel，UIButton，UIView等）一起放到一个大的UIView容器来显示我们的内容，这个方法一般是可以的，但是如果要经常重新刷新内容的大区域界面，多数发生在iPad的应用中，这个方法会带来过多的内存使用和动画的延迟（比较卡），例如，scrollview的动画比较卡，又或者，经常收到内存警告。其中一个重要原因是每个控件，特别是透明底的，会多次重新绘制（drawRect）过多。其解决办法是，尽量将几个控件合并到一个层上来显示，这样系统会减少系统调用drawRect，从而带来性能上的提升。
很简单的一个例子，就是iNotes提供手写功能，用户可以在iPad屏幕上写出不同的笔画，开始的设计是，用户每写一划，iNotes就会生成一个新的透明底UIView来保持这个笔画，用户写了10笔，系统就生产了10个UIView，每个view的大小都是整个屏幕的，以便用户的undo操作。这个方案带来严重的内存问题，因为系统将每个层都保持一个bitmap图，一个像素需要4bit来算，一个层的大小就是 4x1024x768 ~ 3M, 10个层就是 10x3M = 30M，很明显，iPad很快爆出内存警告。
这个例子最后的方案是，所有笔画都画在同一个层，iNotes可以保存笔画的点进行undo操作。这样的方案就是无论用户画多少笔画，界面重画需要的资源都是一样的。
显示最佳尺寸的图片
很多程序员比较懒，网络上拿下来的图片，直接就用UIImageView将其显示给用户，这样的后果就是，程序需要一直保存着大尺寸的图片到内存。解决办法应该是先将图片缩小到需要显示的尺寸，释放大尺寸图片的内存，然后再显示到界面给用户。
尽量使用图片pattern，而不是一张大的图片
例如，很多界面设计者喜欢在界面上放一个大底图，但这个底图是老是占用着内存的，最佳方案是，设计出一个小的pattern图，然后用这个方案显示成底图。
UIImage *smallImage = [[UIImage alloc] initWithContentsOfFile:path];
backgroundView.backgroundColor = [UIColor colorWithPatternImage:smallImage];
[smallImage release];
使用完资源后，立即释放
一般objective-c的习惯是，用完的资源要立即释放，因为明白什么时候用完某个资源的是程序员你自己。例如，我们要读较大的图片，把它缩小后，显示到界面去。当大图片使用完成后，应该立即释放。代码如下：
UIImage *fullscreenImage = [[UIImage alloc] initWithContentOfFile:path];
UIImage *smallImage = [self resizeImage:fullscreenImage];
[fullscreenImage release];
imageView.image = smallImage;

......
循环中大量生成的自动释放autorelease对象，可以考虑使用autorelease pool封装。代码范例：
for(UIView *subview in bigView.subviews) {
// 使用autorelease pool自动释放对象池
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

UIImageView *imageView = (UIImageView *)subview;

// subview处理代码
.......

// 销毁自动释放对象
[pool drain];
}
自动释放对象池把每个循环内生成的临时对象使用完后立即释放

以上的意见是本人多年来编写iPad/iPhone程序的经验，另外iOS4.0的multi-tasking特性发布后，程序可以被调入后台运行，苹果工程师的意见是，进入后台运行时，你的应用应该释放掉能释放的对象，尽量保持在16M左右，这样别的程序运行时才不容易把你的应用挤掉。

source: http://www.cocoachina.com/iphonedev/sdk/2011/0621/2962.html

iPhone/Mac Objective-C內存管理教程和原理剖析

2011-11-06T23:11:00.000-08:00

前言

初学objectice-C的朋友都有一个困惑，总觉得对objective-C的内存管理机制琢磨不透，程序经常内存泄漏或莫名其妙的崩溃。我在这里总结了自己对objective-C内存管理机制的研究成果和经验，写了这么一个由浅入深的教程。希望对大家有所帮助，也欢迎大家一起探讨。

此文涉及的内存管理是针对于继承于NSObject的Class。

一基本原理

Objective-C的内存管理机制与.Net/Java那种全自动的垃圾回收机制是不同的，它本质上还是C语言中的手动管理方式，只不过稍微加了一些自动方法。

1 Objective-C的对象生成于堆之上，生成之后，需要一个指针来指向它。

ClassA *obj1 = [[ClassA alloc] init];

2 Objective-C的对象在使用完成之后不会自动销毁，需要执行dealloc来释放空间（销毁），否则内存泄露。

[obj1 dealloc];

这带来了一个问题。下面代码中obj2是否需要调用dealloc？

ClassA *obj1 = [[ClassA alloc] init];

ClassA *obj2 = obj1;

[obj1 hello]; //输出hello

[obj1 dealloc];

[obj2 hello]; //能够执行这一行和下一行吗？

[obj2 dealloc];

不能，因为obj1和obj2只是指针，它们指向同一个对象，[obj1 dealloc]已经销毁这个对象了，不能再调用[obj2 hello]和[obj2 dealloc]。obj2实际上是个无效指针。

如何避免无效指针？请看下一条。

3 Objective-C采用了引用计数(ref count或者retain count)。对象的内部保存一个数字，表示被引用的次数。例如，某个对象被两个指针所指向（引用）那么它的retain count为2。需要销毁对象的时候，不直接调用dealloc，而是调用release。release会让retain count减1，只有retain count等于0，系统才会调用dealloc真正销毁这个对象。

ClassA *obj1 = [[ClassA alloc] init]; //对象生成时，retain count = 1

[obj1 release]; //release使retain count减1，retain count = 0，dealloc自动被调用,对象被销毁

我们回头看看刚刚那个无效指针的问题，把dealloc改成release解决了吗？

ClassA *obj1 = [[ClassA alloc] init]; //retain count = 1

ClassA *obj2 = obj1; //retain count = 1

[obj1 hello]; //输出hello

[obj1 release]; //retain count = 0，对象被销毁

[obj2 hello];

[obj2 release];

[obj1 release]之后，obj2依然是个无效指针。问题依然没有解决。解决方法见下一条。

4 Objective-C指针赋值时，retain count不会自动增加，需要手动retain。

ClassA *obj1 = [[ClassA alloc] init]; //retain count = 1

ClassA *obj2 = obj1; //retain count = 1

[obj2 retain]; //retain count = 2

[obj1 hello]; //输出hello

[obj1 release]; //retain count = 2 – 1 = 1

[obj2 hello]; //输出hello

[obj2 release]; //retain count = 0，对象被销毁

问题解决！注意，如果没有调用[obj2 release]，这个对象的retain count始终为1，不会被销毁，内存泄露。(1-4可以参考附件中的示例程序memman-no-pool.m)

这样的确不会内存泄露，但似乎有点麻烦，有没有简单点的方法？见下一条。

source: http://www.aiw3.com/iphone/0521988.html

Xcode 4.2 中的Automatic Reference Counting (ARC)

2011-10-26T03:24:00.000-07:00

Automatic Reference Counting (ARC), 自动引用计数，是开发Cocoa程序时的一个编译级别的特性，用于自动内存管理。

在XCode 4.2中，使用模板新建一个工程，该工程将使用ARC特性。

如果你的iOS SDK是iOS5 seed release 2，需要做如下修改，才能避免编译时的错误：

● 在System/Library/Frameworks/CoreFoundation.framework/Headers/CFBase.h中, 将:

CFTypeRef CFMakeCollectable(CFTypeRef cf) CF_AUTOMATED_REFCOUNT_UNAVAILABLE;

修改成:

CFTypeRef CFMakeCollectable(CFTypeRef cf);

●在System/Library/Frameworks/Foundation.framework/Headers/NSObject.h中, 将:

return (__bridge_retain CFTypeRef)X;

修改成：

return (__bridge_retained CFTypeRef)X;

使用ARC将让你远离烦人且容易遗漏的retain，release和autorelease等操作。

ARC的工作原理是，在你编译程序时，将内存操作的代码（retain，release或autorelease）自动添加到需要的位置。即底层上使用和Manual Reference Counting（手工引用计数）一样的内存管理机制，但由于XCode自动帮你在编译时添加内存操作的代码，从而简化了编程的工作。

启用ARC，编译选项中需加上-fobjc-arc，不过这个由XCode在创建工程模板时帮你完成。

4.2以前版本的XCode都不支持ARC。

对操作系统也有要求：Mac OS X v10.6 或 v10.7 (64-bit applications)， iOS4或iOS5。注意：其中Mac OS X v10.6和iOS4不支持weak references(弱引用，后面会说明什么是weak references)。

Xcode 4.2提供了一个名为“Convert to Objective-C Automatic Reference Counting”的工具，在Edit->Convert menu下，可以帮你自动将使用Manual Reference Counting的老代码转换成使用ARC的新代码（例如去掉对retain和release的调用）。

一个使用ARC的代码例子：

@interface Person : NSObject

@property (nonatomic, strong) NSString *firstName;

@property (nonatomic, strong) NSString *lastName;

@property (nonatomic, strong) NSNumber *yearOfBirth;

@property (nonatomic, strong) Person *spouse;

@end

@implementation Person

@synthesize firstName, lastName, yearOfBirth, spouse; @end

注意：不再需要重载dealloc函数,因为没有release操作。（strong的语义后面会介绍。）

例子2：

(void)contrived {
Person *aPerson = [[Person alloc] init];
[aPerson setFirstName:@"William"];
[aPerson setLastName:@"Dudney"];
[aPerson:setYearOfBirth:[[NSNumber alloc] initWithInteger:2011]];
NSLog(@"aPerson: %@", aPerson);

}

注意：没有了release操作。

例子3：

(void)takeLastNameFrom:(Person *)person {
NSString *oldLastname = [self lastName];
[self setLastName:[person lastName]];
NSLog(@"Lastname changed from %@ to %@", oldLastname, [self lastName]);

}

注意：ARC会保证 oldLastname引用的对象在NSLog执行结束之前，不会被释放掉。

使用ARC的一些规则：

不能直接调用dealloc方法，不能重载或直接调用retain, release, retainCount, 或 autorelease等方法。
但可以通过@selector(retain), @selector(release)这样的形式调用。
用户自定义的dealloc方法，不能调用[super dealloc] ，编译器会自动帮你添加这个代码。
对Core Foundation-style 的对象，仍可以使用CFRetain, CFRelease等方法。
不能使用NSAllocateObject或NSDeallocateObject去创建对象，请使用alloc方法。
在c语言中的结构体中，不能再使用对象指针。请放弃C结构体，使用Objective-C的类。
id和void*之间没有隐式的类型转换，请使用显式类型转换。
不能使用NSAutoreleasePool，ARC提供了@autoreleasepool语句块。
例如：
@autoreleasepool {
// Code, such as a loop that creates a large number of temporary objects.

}

不能使用NSZone。
方法和变量的命名不能以“new”开头。

关于对象的生命周期：

weak引用：设置成weak的属性，不会影响对象的生命周期，如果引用的对象已经被释放，引用会指向nil。
strong引用：设置成strong的属性，会影响对象的生命周期。

例如：

@property(strong) MyClass *myObject; 和 @property(retain) MyClass *myObject; 是等效的。

又例如：

@property(weak) MyClass *myObject; 和 @property(assign) MyClass *myObject; 在多数情况下等效，但当instance被释放时，设置为weak的引用会指向nil。

可用的限定词：

__strong，默认的
__weak
__unsafe_unretained，和weak的区别是当对象被释放时，引用不指向nil。
__autoreleasing，当方法的参数是id*，且希望方法返回时对象被autoreleased，可以添加__autoreleasing限定词。

使用__weak时要特别小心，例如

NSString __weak *string = [[NSString alloc] initWithFormat:@"First Name: %@", [self firstName]];

NSLog(@"string: %@", string); //此时 string为空，因为weak类型不影响对象的生命周期，对象刚创建就释放了。

其他特性：

使用strong, weak, autoreleasing限定的变量会被隐式初始化为nil。
例如：
- (void)myMethod { NSString *name;

NSLog(@"name: %@", name); //会输出null

}

source: http://blog.sina.com.cn/s/blog_4c4c79950100t3uy.html

Error Handling Best Practice in IOS Dev

2011-10-26T02:50:00.000-07:00

Exception Handling

The Objective-C language has an exception-handling syntax similar to that of Java and C++. By using this syntax with the NSException, NSError, or custom classes, you can add robust error-handling to your programs. This chapter provides a summary of exception syntax and handling; for more details, see Exception Programming Topics.

Enabling Exception-Handling

Using GNU Compiler Collection (GCC) version 3.3 and later, Objective-C provides language-level support for exception handling. To turn on support for these features , use the -fobjc-exceptions switch of the GNU Compiler Collection (GCC) version 3.3 and later. (Note that this switch renders the application runnable only in Mac OS X v10.3 and later because runtime support for exception handling and synchronization is not present in earlier versions of the software.)

Exception Handling

An exception is a special condition that interrupts the normal flow of program execution. There are a variety of reasons why an exception may be generated (exceptions are typically said to beraised or thrown), by hardware as well as software. Examples include arithmetical errors such as division by zero, underflow or overflow, calling undefined instructions (such as attempting to invoke an unimplemented method), and attempting to access a collection element out of bounds.

Objective-C exception support involves four compiler directives: @try, @catch, @throw, and @finally:

Code that can potentially throw an exception is enclosed in a @try{} block.
A @catch{} block contains exception-handling logic for exceptions thrown in a @try{} block. You can have multiple @catch{} blocks to catch different types of exception. (For a code example, see “Catching Different Types of Exception.”)
You use the @throw directive to throw an exception, which is essentially an Objective-C object. You typically use an NSException object, but you are not required to.
A @finally{} block contains code that must be executed whether an exception is thrown or not.

This example depicts a simple exception-handling algorithm:

Cup *cup = [[Cup alloc] init];

@try {

    [cup fill];

@catch (NSException *exception) {

    NSLog(@"main: Caught %@: %@", [exception name], [exception reason]);

@finally {

    [cup release];

Catching Different Types of Exception

To catch an exception thrown in a @try{} block, use one or more @catch{}blocks following the @try{} block. The @catch{} blocks should be ordered from most-specific to least-specific. That way you can tailor the processing of exceptions as groups, as shown in Listing 10-1.

Listing 10-1 An exception handler

@try {

...

@catch (CustomException *ce) {   // 1

...

@catch (NSException *ne) {       // 2

    // Perform processing necessary at this level.

...

@catch (id ue) {

...

@finally {                       // 3

    // Perform processing necessary whether an exception occurred or not.

...

The following list describes the numbered code lines:

Catches the most specific exception type.
Catches a more general exception type.
Performs any clean-up processing that must always be performed, whether exceptions were thrown or not.

Throwing Exceptions

To throw an exception, you must instantiate an object with the appropriate information, such as the exception name and the reason it was thrown.

NSException *exception = [NSException exceptionWithName: @"HotTeaException"

                                                 reason: @"The tea is too hot"

                                               userInfo: nil];

@throw exception;

Inside a @catch{} block, you can rethrow the caught exception using the @throw directive without providing an argument. Leaving out the argument in this case can help make your code more readable.

You are not limited to throwing NSException objects. You can throw any Objective-C object as an exception object. The NSException class provides methods that help in exception processing, but you can implement your own if you so desire. You can also subclass NSException to implement specialized types of exceptions, such as file-system exceptions or communications exceptions.

source: link

Oracle Hint

2011-10-19T19:57:00.000-07:00

在SQL中增加/*ordered */
會使查詢效能顯著提升
原來這叫做Oracle Hint

常見Oracle HINT的用法：
1. /*+ALL_ROWS*/
表明對語句塊選擇基於開銷的優化方法,並獲得最佳吞吐量,使資源消耗最小化.
例如:
SELECT /*+ALL+_ROWS*/ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO=’SCOTT’;

2. /*+FIRST_ROWS*/
表明對語句塊選擇基於開銷的優化方法,並獲得最佳響應時間,使資源消耗最小化.
例如:
SELECT /*+FIRST_ROWS*/ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO=’SCOTT’;

3. /*+CHOOSE*/
表明如果數據字典中有訪問表的統計資料,將基於開銷的優化方法,並獲得最佳的吞吐量;
表明如果數據字典中沒有訪問表的統計資料,將基於規則開銷的優化方法;
例如:
SELECT /*+CHOOSE*/ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO=’SCOTT’;

4. /*+RULE*/
表明對語句塊選擇基於規則的優化方法.
例如:
SELECT /*+ RULE */ EMP_NO,EMP_NAM,DAT_IN FROM BSEMPMS WHERE EMP_NO=’SCOTT’;

5. /*+FULL(TABLE)*/
表明對表選擇全局掃描的方法.
例如:
SELECT /*+FULL(A)*/ EMP_NO,EMP_NAM FROM BSEMPMS A WHERE EMP_NO=’SCOTT’;

6. /*+ROWID(TABLE)*/
提示明確表明對指定表根據ROWID進行訪問.
例如:
SELECT /*+ROWID(BSEMPMS)*/ * FROM BSEMPMS WHERE ROWID>=’AAAAAAAAAAAAAA’
AND EMP_NO=’SCOTT’;

7. /*+CLUSTER(TABLE)*/
提示明確表明對指定表選擇簇掃描的訪問方法,它只對簇對像有效.
例如:
SELECT /*+CLUSTER */ BSEMPMS.EMP_NO,DPT_NO FROM BSEMPMS,BSDPTMS
WHERE DPT_NO=’TEC304′ AND BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

8. /*+INDEX(TABLE INDEX_NAME)*/
表明對錶選擇索引的掃描方法.
例如:
SELECT /*+INDEX(BSEMPMS SEX_INDEX) USE SEX_INDEX BECAUSE THERE ARE FEWMALE BSEMPMS */ FROM BSEMPMS WHERE SEX=’M';

9. /*+INDEX_ASC(TABLE INDEX_NAME)*/
表明對錶選擇索引升序的掃描方法.
例如:
SELECT /*+INDEX_ASC(BSEMPMS PK_BSEMPMS) */ FROM BSEMPMS WHERE DPT_NO=’SCOTT’;

10. /*+INDEX_COMBINE*/
為指定表選擇位圖訪問路經,如果INDEX_COMBINE中沒有提供作為參數的索引,將選擇出位圖索引的布爾組合方式.
例如:
SELECT /*+INDEX_COMBINE(BSEMPMS SAL_BMI HIREDATE_BMI)*/ * FROM BSEMPMS
WHERE SAL<5000000 emp_no="SCOTT" sex="M" dpt_no="V.DPT_NO">V.AVG_SAL;

20. /*+NO_MERGE(TABLE)*/
對於有可合併的視圖不再合併.
例如:
SELECT /*+NO_MERGE(V) */ A.EMP_NO,A.EMP_NAM,B.DPT_NO FROM BSEMPMS A (SELECT DPT_NO,AVG(SAL) AS AVG_SAL FROM BSEMPMS B GROUP BY DPT_NO) V WHERE A.DPT_NO=V.DPT_NO AND A.SAL>V.AVG_SAL;

21. /*+ORDERED*/
根據表出現在FROM中的順序,ORDERED使ORACLE依此順序對其連接.
例如:
SELECT /*+ORDERED*/ A.COL1,B.COL2,C.COL3 FROM TABLE1 A,TABLE2 B,TABLE3 C WHERE A.COL1=B.COL1 AND B.COL1=C.COL1;

22. /*+USE_NL(TABLE)*/
將指定表與嵌套的連接的行源進行連接,並把指定表作為內部表.
例如:
SELECT /*+ORDERED USE_NL(BSEMPMS)*/ BSDPTMS.DPT_NO,BSEMPMS.EMP_NO,BSEMPMS.EMP_NAM FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

23. /*+USE_MERGE(TABLE)*/
將指定的表與其他行源通過合併排序連接方式連接起來.
例如:
SELECT /*+USE_MERGE(BSEMPMS,BSDPTMS)*/ * FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

24. /*+USE_HASH(TABLE)*/
將指定的表與其他行源通過hash連接方式連接起來.
例如:
SELECT /*+USE_HASH(BSEMPMS,BSDPTMS)*/ * FROM BSEMPMS,BSDPTMS WHERE BSEMPMS.DPT_NO=BSDPTMS.DPT_NO;

25. /*+DRIVING_SITE(TABLE)*/
強制與ORACLE所選擇的位置不同的表進行查詢執行.
例如:
SELECT /*+DRIVING_SITE(DEPT)*/ * FROM BSEMPMS,DEPT@BSDPTMS WHERE BSEMPMS.DPT_NO=DEPT.DPT_NO;

26. /*+LEADING(TABLE)*/
將指定的表作為連接次序中的首表.

27. /*+CACHE(TABLE)*/
當進行 full scan 時,CACHE提示能夠將表的檢索塊放置在緩衝區緩存中最近最少列表LRU的最近使用端
例如:
SELECT /*+FULL(BSEMPMS) CAHE(BSEMPMS) */ EMP_NAM FROM BSEMPMS;

28. /*+NOCACHE(TABLE)*/
當進行 full scan 時,CACHE提示能夠將表的檢索塊放置在緩衝區緩存中最近最少列表LRU的最近使用端
例如:
SELECT /*+FULL(BSEMPMS) NOCAHE(BSEMPMS) */ EMP_NAM FROM BSEMPMS;

29. /*+APPEND*/
直接插入到表的最後,可以提高速度.
insert /*+append*/ into test1 select * from test4 ;

30. /*+NOAPPEND*/
通過在插入語句生存期內停止並行模式來啟動常規插入.
insert /*+noappend*/ into test1 select * from test4 ;

source: http://iqloss.blogspot.com/2011/04/oracle-hint.html

五种提高 SQL 性能的方法

2011-10-18T01:49:00.000-07:00

五种提高 SQL 性能的方法

发布日期： 4/1/2004 | 更新日期： 4/1/2004

Johnny Papa

Data Points Archive

有时，为了让应用程序运行得更快，所做的全部工作就是在这里或那里做一些很小调整。啊，但关键在于确定如何进行调整！迟早您会遇到这种情况：应用程序中的 SQL 查询不能按照您想要的方式进行响应。它要么不返回数据，要么耗费的时间长得出奇。如果它降低了报告或您的企业应用程序的速度，用户必须等待的时间过长，他们就会很不满意。就像您的父母不想听您解释为什么在深更半夜才回来一样，用户也不会听你解释为什么查询耗费这么长时间。（“对不起，妈妈，我使用了太多的 LEFT JOIN。”）用户希望应用程序响应迅速，他们的报告能够在瞬间之内返回分析数据。就我自己而言，如果在 Web 上冲浪时某个页面要耗费十多秒才能加载（好吧，五秒更实际一些），我也会很不耐烦。

为了解决这些问题，重要的是找到问题的根源。那么，从哪里开始呢？根本原因通常在于数据库设计和访问它的查询。在本月的专栏中，我将讲述四项技术，这些技术可用于提高基于 SQL Server? 的应用程序的性能或改善其可伸缩性。我将仔细说明 LEFT JOIN、CROSS JOIN 的使用以及 IDENTITY 值的检索。请记住，根本没有神奇的解决方案。调整您的数据库及其查询需要占用时间、进行分析，还需要大量的测试。这些技术都已被证明行之有效，但对您的应用程序而言，可能其中一些技术比另一些技术更适用。

本页内容

	从 INSERT 返回 IDENTITY
	内嵌视图与临时表
	避免 LEFT JOIN 和 NULL
	灵活使用笛卡尔乘积
	拾遗补零

从 INSERT 返回 IDENTITY

我决定从遇到许多问题的内容入手：如何在执行 SQL INSERT 后检索 IDENTITY 值。通常，问题不在于如何编写检索值的查询，而在于在哪里以及何时进行检索。在 SQL Server 中，下面的语句可用于检索由最新在活动数据库连接上运行的 SQL 语句所创建的 IDENTITY 值：

SELECT @@IDENTITY

这个 SQL 语句并不复杂，但需要记住的一点是：如果这个最新的 SQL 语句不是 INSERT，或者您针对非 INSERT SQL 的其他连接运行了此 SQL，则不会获得期望的值。您必须运行下列代码才能检索紧跟在 INSERT SQL 之后且位于同一连接上的 IDENTITY，如下所示：

INSERT INTO Products (ProductName) VALUES ('Chalk')  SELECT @@IDENTITY

在一个连接上针对 Northwind 数据库运行这些查询将返回一个名称为 Chalk 的新产品的 IDENTITY 值。所以，在使用 ADO 的 Visual Basic? 应用程序中，可以运行以下语句：

Set oRs = oCn.Execute("SET NOCOUNT ON;INSERT INTO Products _ (ProductName) VALUES ('Chalk');SELECT @@IDENTITY")  lProductID = oRs(0)

此代码告诉 SQL Server 不要返回查询的行计数，然后执行 INSERT 语句，并返回刚刚为这个新行创建的 IDENTITY 值。SET NOCOUNT ON 语句表示返回的记录集有一行和一列，其中包含了这个新的 IDENTITY 值。如果没有此语句，则会首先返回一个空的记录集（因为 INSERT 语句不返回任何数据），然后会返回第二个记录集，第二个记录集中包含 IDENTITY 值。这可能有些令人困惑，尤其是因为您从来就没有希望过 INSERT 会返回记录集。之所以会发生此情况，是因为 SQL Server 看到了这个行计数（即一行受到影响）并将其解释为表示一个记录集。因此，真正的数据被推回到了第二个记录集。当然您可以使用 ADO 中的 NextRecordset 方法获取此第二个记录集，但如果总能够首先返回该记录集且只返回该记录集，则会更方便，也更有效率。

此方法虽然有效，但需要在 SQL 语句中额外添加一些代码。获得相同结果的另一方法是在 INSERT 之前使用 SET NOCOUNT ON 语句，并将 SELECT @@IDENTITY 语句放在表中的 FOR INSERT 触发器中，如下面的代码片段所示。这样，任何进入该表的 INSERT 语句都将自动返回 IDENTITY 值。

CREATE TRIGGER trProducts_Insert ON Products FOR INSERT AS      SELECT @@IDENTITY  GO

触发器只在 Products 表上发生 INSERT 时启动，所以它总是会在成功 INSERT 之后返回一个 IDENTITY。使用此技术，您可以始终以相同的方式在应用程序中检索 IDENTITY 值。

返回页首

内嵌视图与临时表

某些时候，查询需要将数据与其他一些可能只能通过执行 GROUP BY 然后执行标准查询才能收集的数据进行联接。例如，如果要查询最新五个定单的有关信息，您首先需要知道是哪些定单。这可以使用返回定单 ID 的 SQL 查询来检索。此数据就会存储在临时表（这是一个常用技术）中，然后与 Products 表进行联接，以返回这些定单售出的产品数量：

CREATE TABLE #Temp1 (OrderID INT NOT NULL, _                      OrderDate DATETIME NOT NULL)  INSERT INTO #Temp1 (OrderID, OrderDate) SELECT     TOP 5 o.OrderID, o.OrderDate FROM Orders o ORDER BY o.OrderDate DESC  SELECT     p.ProductName, SUM(od.Quantity) AS ProductQuantity FROM     #Temp1 t      INNER JOIN [Order Details] od ON t.OrderID = od.OrderID     INNER JOIN Products p ON od.ProductID = p.ProductID  GROUP BY p.ProductName ORDER BY p.ProductName  DROP TABLE #Temp1

这些 SQL 语句会创建一个临时表，将数据插入该表中，将其他数据与该表进行联接，然后除去该临时表。这会导致此查询进行大量 I/O 操作，因此，可以重新编写查询，使用内嵌视图取代临时表。内嵌视图只是一个可以联接到 FROM 子句中的查询。所以，您不用在 tempdb 中的临时表上耗费大量 I/O 和磁盘访问，而可以使用内嵌视图得到同样的结果：

SELECT p.ProductName,      SUM(od.Quantity) AS ProductQuantity FROM     (     SELECT TOP 5 o.OrderID, o.OrderDate     FROM     Orders o      ORDER BY o.OrderDate DESC     ) t      INNER JOIN [Order Details] od ON t.OrderID = od.OrderID     INNER JOIN Products p ON od.ProductID = p.ProductID  GROUP BY     p.ProductName ORDER BY     p.ProductName

此查询不仅比前面的查询效率更高，而且长度更短。临时表会消耗大量资源。如果只需要将数据联接到其他查询，则可以试试使用内嵌视图，以节省资源。

返回页首

避免 LEFT JOIN 和 NULL

当然，有很多时候您需要执行 LEFT JOIN 和使用 NULL 值。但是，它们并不适用于所有情况。改变 SQL 查询的构建方式可能会产生将一个花几分钟运行的报告缩短到只花几秒钟这样的天壤之别的效果。有时，必须在查询中调整数据的形态，使之适应应用程序所要求的显示方式。虽然 TABLE 数据类型会减少大量占用资源的情况，但在查询中还有许多区域可以进行优化。SQL 的一个有价值的常用功能是 LEFT JOIN。它可以用于检索第一个表中的所有行、第二个表中所有匹配的行、以及第二个表中与第一个表不匹配的所有行。例如，如果希望返回每个客户及其定单，使用 LEFT JOIN 则可以显示有定单和没有定单的客户。

此工具可能会被过度使用。LEFT JOIN 消耗的资源非常之多，因为它们包含与 NULL（不存在）数据匹配的数据。在某些情况下，这是不可避免的，但是代价可能非常高。LEFT JOIN 比 INNER JOIN 消耗资源更多，所以如果您可以重新编写查询以使得该查询不使用任何 LEFT JOIN，则会得到非常可观的回报（请参阅图 1 中的图）。

图 1：查询

加快使用 LEFT JOIN 的查询速度的一项技术涉及创建一个 TABLE 数据类型，插入第一个表（LEFT JOIN 左侧的表）中的所有行，然后使用第二个表中的值更新 TABLE 数据类型。此技术是一个两步的过程，但与标准的 LEFT JOIN 相比，可以节省大量时间。一个很好的规则是尝试各种不同的技术并记录每种技术所需的时间，直到获得用于您的应用程序的执行性能最佳的查询。

测试查询的速度时，有必要多次运行此查询，然后取一个平均值。因为查询（或存储过程）可能会存储在 SQL Server 内存中的过程缓存中，因此第一次尝试耗费的时间好像稍长一些，而所有后续尝试耗费的时间都较短。另外，运行您的查询时，可能正在针对相同的表运行其他查询。当其他查询锁定和解锁这些表时，可能会导致您的查询要排队等待。例如，如果您进行查询时某人正在更新此表中的数据，则在更新提交时您的查询可能需要耗费更长时间来执行。

避免使用 LEFT JOIN 时速度降低的最简单方法是尽可能多地围绕它们设计数据库。例如，假设某一产品可能具有类别也可能没有类别。如果 Products 表存储了其类别的 ID，而没有用于某个特定产品的类别，则您可以在字段中存储 NULL 值。然后您必须执行 LEFT JOIN 来获取所有产品及其类别。您可以创建一个值为“No Category”的类别，从而指定外键关系不允许 NULL 值。通过执行上述操作，现在您就可以使用 INNER JOIN 检索所有产品及其类别了。虽然这看起来好像是一个带有多余数据的变通方法，但可能是一个很有价值的技术，因为它可以消除 SQL 批处理语句中消耗资源较多的 LEFT JOIN。在数据库中全部使用此概念可以为您节省大量的处理时间。请记住，对于您的用户而言，即使几秒钟的时间也非常重要，因为当您有许多用户正在访问同一个联机数据库应用程序时，这几秒钟实际上的意义会非常重大。

返回页首

灵活使用笛卡尔乘积

对于此技巧，我将进行非常详细的介绍，并提倡在某些情况下使用笛卡尔乘积。出于某些原因，笛卡尔乘积 (CROSS JOIN) 遭到了很多谴责，开发人员通常会被警告根本就不要使用它们。在许多情况下，它们消耗的资源太多，从而无法高效使用。但是像 SQL 中的任何工具一样，如果正确使用，它们也会很有价值。例如，如果您想运行一个返回每月数据（即使某一特定月份客户没有定单也要返回）的查询，您就可以很方便地使用笛卡尔乘积。图 2 中的 SQL 就执行了上述操作。

虽然这看起来好像没什么神奇的，但是请考虑一下，如果您从客户到定单（这些定单按月份进行分组并对销售额进行小计）进行了标准的 INNER JOIN，则只会获得客户有定单的月份。因此，对于客户未订购任何产品的月份，您不会获得 0 值。如果您想为每个客户都绘制一个图，以显示每个月和该月销售额，则可能希望此图包括月销售额为 0 的月份，以便直观标识出这些月份。如果使用图 2 中的 SQL，数据则会跳过销售额为 0 美元的月份，因为在定单表中对于零销售额不会包含任何行（假设您只存储发生的事件）。

图 3 中的代码虽然较长，但是可以达到获取所有销售数据（甚至包括没有销售额的月份）的目标。首先，它会提取去年所有月份的列表，然后将它们放入第一个 TABLE 数据类型表 (@tblMonths) 中。下一步，此代码会获取在该时间段内有销售额的所有客户公司的名称列表，然后将它们放入另一个 TABLE 数据类型表 (@tblCus-tomers) 中。这两个表存储了创建结果集所必需的所有基本数据，但实际销售数量除外。第一个表中列出了所有月份（12 行），第二个表中列出了这个时间段内有销售额的所有客户（对于我是 81 个）。并非每个客户在过去 12 个月中的每个月都购买了产品，所以，执行 INNER JOIN 或 LEFT JOIN 不会返回每个月的每个客户。这些操作只会返回购买产品的客户和月份。

笛卡尔乘积则可以返回所有月份的所有客户。笛卡尔乘积基本上是将第一个表与第二个表相乘，生成一个行集合，其中包含第一个表中的行数与第二个表中的行数相乘的结果。因此，笛卡尔乘积会向表 @tblFinal 返回 972 行。最后的步骤是使用此日期范围内每个客户的月销售额总计更新 @tblFinal 表，以及选择最终的行集。

如果由于笛卡尔乘积占用的资源可能会很多，而不需要真正的笛卡尔乘积，则可以谨慎地使用 CROSS JOIN。例如，如果对产品和类别执行了 CROSS JOIN，然后使用 WHERE 子句、DISTINCT 或 GROUP BY 来筛选出大多数行，那么使用 INNER JOIN 会获得同样的结果，而且效率高得多。如果需要为所有的可能性都返回数据（例如在您希望使用每月销售日期填充一个图表时），则笛卡尔乘积可能会非常有帮助。但是，您不应该将它们用于其他用途，因为在大多数方案中 INNER JOIN 的效率要高得多。

返回页首

拾遗补零

这里介绍其他一些可帮助提高 SQL 查询效率的常用技术。假设您将按区域对所有销售人员进行分组并将他们的销售额进行小计，但是您只想要那些数据库中标记为处于活动状态的销售人员。您可以按区域对销售人员分组，并使用 HAVING 子句消除那些未处于活动状态的销售人员，也可以在 WHERE 子句中执行此操作。在 WHERE 子句中执行此操作会减少需要分组的行数，所以比在 HAVING 子句中执行此操作效率更高。HAVING 子句中基于行的条件的筛选会强制查询对那些在 WHERE 子句中会被去除的数据进行分组。

另一个提高效率的技巧是使用 DISTINCT 关键字查找数据行的单独报表，来代替使用 GROUP BY 子句。在这种情况下，使用 DISTINCT 关键字的 SQL 效率更高。请在需要计算聚合函数（SUM、COUNT、MAX 等）的情况下再使用 GROUP BY。另外，如果您的查询总是自己返回一个唯一的行，则不要使用 DISTINCT 关键字。在这种情况下，DISTINCT 关键字只会增加系统开销。

您已经看到了，有大量技术都可用于优化查询和实现特定的业务规则，技巧就是进行一些尝试，然后比较它们的性能。最重要的是要测试、测试、再测试。在此专栏的将来各期内容中，我将继续深入讲述 SQL Server 概念，包括数据库设计、好的索引实践以及 SQL Server 安全范例。

http://www.microsoft.com/china/MSDN/library/data/sqlserver/FiveWaystoRevupYourSQLPerformanCE.mspx?mfr=true

source:

Combine Multiple Columns And Records In MSSQL

2011-10-17T00:29:00.000-07:00

source: http://csharpdotnetfreak.blogspot.com/2009/07/mssql-combine-columns-comma-separated.html

In this example i am going to describe how to combine multiple columns and records in one column in MS SQL.

Here is the scenario

I have a table having Employees names and their respective Department names, now i want to show Employees names separated by comma into one column and respective Department name in another column.

My table schema is shown in the image below

And this is Data into table

I want output in following format

Department FirstName
IT amiT,Emp1,Emp5
Admin Shobhit, Emp3,Emp7

and so on

To get this desired result we need to write below mentioned query

SELECT DISTINCT Department, EmpNames = substring( ( SELECT ', ' + FirstName  FROM Employees e2 WHERE e2.Department = e1.Department FOR XML path(''), elements  ),2,500) FROM Employees e1

And the output of this SQL Query would be

[iOS開發] 如何做一個Username/Password彈跳視窗(UIAlertView)?

2011-10-12T08:57:00.000-07:00

首先，你要初始化一個UIAlertView物件。然後你必須將message的參數值設為@”\n\n\n”，這是用來多留幾行空白以便擺放輸入框欄位。
建立兩個UITextField物件，將他們加至UIAlertView裡成為subview。別忘了設定輸入框的背景色(setBackgroundColor)、預設文字(setPlaceholder)、安全表示(setSecureTextEntry，輸入文字時會變成星號，用於密碼欄)。
最後，在呈現UIAlertView時，在垂直位移加上一點Shift值並且有需要的話將之設定為FirstResponder。

Source Code:

view sourceprint?

UITextField *textField;
UITextField *textField2;

UIAlertView *prompt = [[UIAlertView alloc] initWithTitle:@"Username and password"
message:@"\n\n\n" // IMPORTANT
delegate:nil
cancelButtonTitle:@"Cancel"
otherButtonTitles:@"Enter", nil];

textField = [[UITextField alloc] initWithFrame:CGRectMake(12.0, 50.0, 260.0, 25.0)];
[textField setBackgroundColor:[UIColor whiteColor]];
[textField setPlaceholder:@"username"];
[prompt addSubview:textField];

textField2 = [[UITextField alloc] initWithFrame:CGRectMake(12.0, 85.0, 260.0, 25.0)];
[textField2 setBackgroundColor:[UIColor whiteColor]];
[textField2 setPlaceholder:@"password"];
[textField2 setSecureTextEntry:YES];
[prompt addSubview:textField2];

// set place
[prompt setTransform:CGAffineTransformMakeTranslation(0.0, 110.0)];
[prompt show];
[prompt release];

// set cursor and show keyboard
[textField becomeFirstResponder];

Reference:

http://iphone-dev-tips.alterplay.com/2009/12/username-and-password-uitextfields-in.html

http://fstoke.me/blog/?p=2643

oracle查询效率积累

2011-08-29T01:53:00.000-07:00

（1）选择最有效率的表名顺序(只在基于规则的优化器中有效)：

ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理，在FROM子句中包含多个表的情况下,你必须选择记录条数最少的表作为基础表。如果有3个以上的表连接查询, 那就需要选择交叉表(intersection table)作为基础表, 交叉表是指那个被其他表所引用的表.

（2）WHERE子句中的连接顺序．：

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.

（3）SELECT子句中避免使用 ‘ * ‘：

ORACLE在解析的过程中, 会将'*' 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间

（4）减少访问数据库的次数：

ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等；

（5）在SQL*Plus , SQL*Forms和Pro*C中重新设置ARRAYSIZE参数, 可以增加每次数据库访问的检索数据量 ,建议值为200

（6）使用DECODE函数来减少处理时间：

使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.

（7）整合简单,无关联的数据库访问：

如果你有几个简单的数据库查询语句,你可以把它们整合到一个查询中(即使它们之间没有关系)

（8）删除重复记录：

最高效的删除重复记录方法 ( 因为使用了ROWID)例子：

DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN(X.ROWID)
FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

（9）用TRUNCATE替代DELETE：

当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短. (译者按: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)

（10）尽量多使用COMMIT：

只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:
COMMIT所释放的资源:
a. 回滚段上用于恢复数据的信息.
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费

（11）用Where子句替换HAVING子句：

避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销. (非oracle中)on、where、having这三个都可以加条件的子句中，on是最先执行，where次之，having最后，因为on是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，where也应该比having快点的，因为它过滤数据后才进行sum，在两个表联接时才用on的，所以在一个表的时候，就剩下where跟having比较了。在这单表查询统计的情况下，如果要过滤的条件没有涉及到要计算字段，那它们的结果是一样的，只是where可以使用rushmore技术，而having就不能，在速度上后者要慢如果要涉及到计算的字段，就表示在没计算之前，这个字段的值是不确定的，根据上篇写的工作流程，where的作用时间是在计算之前就完成的，而having就是在计算后才起作用的，所以在这种情况下，两者的结果会不同。在多表联接查询时，on比where更早起作用。系统首先根据各个表之间的联接条件，把多个表合成一个临时表后，再由where进行过滤，然后再计算，计算完后再由having进行过滤。由此可见，要想过滤条件起到正确的作用，首先要明白这个条件应该在什么时候起作用，然后再决定放在那里

（12）减少对表的查询：

在含有子查询的SQL语句中,要特别注意减少对表的查询.例子：

SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT

TAB_NAME,DB_VER FROM TAB_COLUMNS WHERE VERSION = 604)

（13）通过内部函数提高SQL效率.：

复杂的SQL往往牺牲了执行效率. 能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的

（14）使用表的别名(Alias)：

当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误.

（15）用EXISTS替代IN、用NOT EXISTS替代NOT IN：

在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率. 在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.

例子：

（高效）SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X' FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')

(低效)SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')

（16）识别'低效执行'的SQL语句：

虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法：

SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,
SQL_TEXT
FROM V$SQLAREA
WHERE EXECUTIONS>0
AND BUFFER_GETS > 0
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8
ORDER BY 4 DESC;

（17） 用索引提高效率：

索引是表的一个概念部分,用来提高检索数据的效率，ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证.。那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率. 虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.。定期的重构索引是有必要的.：

ALTER INDEX REBUILD

（18）用EXISTS替换DISTINCT：

当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换, EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果. 例子：

(低效):
SELECT DISTINCT DEPT_NO,DEPT_NAME FROM DEPT D , EMP E

WHERE D.DEPT_NO = E.DEPT_NO
(高效):
SELECT DEPT_NO,DEPT_NAME FROM DEPT D WHERE EXISTS ( SELECT ‘X'
FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

（19）sql语句用大写的；因为oracle总是先解析sql语句，把小写的字母转换成大写的再执行

（20）在java代码中尽量少用连接符“＋”连接字符串！

source:

http://blog.csdn.net/dongdongsdo0310/article/details/6729698

Beginning with Digital Signatures in .NET Framework

2011-07-10T20:31:00.000-07:00

This article explains how to get started with digital signatures, using X509 certificates in .NET.

The purpose of digital signatures is to identify data in a way that cannot easily be faked. Phishing, infected software and illegal contents published by unknown subjects can be prevented with digital signatures. Digital signatures will allow data and digital documents to be used as if they were signed paper. Browsers are now able to recognize X.509 certificates and know which Certificate Authorities are trusted. The X.509 system has grown to be the standard format for public key certificates, and is therefore the best way of proving that a document comes from the source it claims to come from.

This article will introduce X509 certificates, explain a little about the asymmetric cryptography that is at their heart, and end by describing how to use and manage these certificates within the .NET Framework classes.

Asymmetric Cryptography and Digital Signatures

Digital signatures are created using asymmetric cryptography, the approach on which digital signatures are based. Asymmetric Cryptography is distinguished by having two different keys, a private key to encrypt messages and a public key to decrypt them. The cryptographic private key K₀ (a suitable array of bytes) is used with an appropriate algorithm to transform the initial human-readable message into a different message that is encrypted.

A second public cryptographic key K₁, which is related to the private one, is used to change the encrypted message back to its original decrypted form via a second related algorithm.

With this mechanism, your recipient is sure that the message that she/he received is your message, because only you hold the private key that is related to the public, shared, key. You digitally ‘sign’ your message.

In practice, you will hash the message beforehand (with hash algorithm such as MD5 or SHA1), obtaining the hashed message M₁. Then you will encrypt M1 with your private key K₀, digitally signing your message, and, finally, you will send your message M, the encrypted hash M₁ (the signature) and the public key K₁ to your recipient. Your recipient will compute the hash of your message M and will compare it with the decrypted value of M₁. If the two hashes matches, the signature is valid.

You will notice that the signature is obtained by encrypting the hash of a message, rather than the message itself. This is done for performance reasons. Asymmetric cryptography is a slow process and the time required to encrypt, or decrypt, a message is directly related to the message length. You can make better use of the processor by reducing the amount of data to be processed. Sometimes, a very large (in bytes) message, can be reduced, by hashing it, to a much smaller hashed message. It is more convenient to transmit a the bulk of the data as clear text and just attach less than a hundred encrypted bytes attached to it than to encrypt the entire message and send it in the encrypted form.

Asymmetric key encryption by itself is not enough because it is necessary to trust the public key received. An attacker can deceive you by signing a message with his private key and send you a digitally confirmed message with its (related) public key, whilst pretending he is someone else.

The public-key infrastructure (PKI) avoids this by utilizing a third-party entity, called Certification Authority that, under its responsibility, binds a public key to its owner. The binding occurs when the Certification Authority digitally sign a message that contains the public key and the identity of its owner. A digital certificate is obtained.

The X509 Standard for Digital Certificate

Today, the standard that has been adopted for digital certificate format is the X509 standard. Over the years since X.509 was developed in 1988, the initial X509 certificate format has evolved beyond the simple purpose of associating the identity of the subject with the public key, since it allows extended information to be held. The current certificate format is X509 v3 format, defined on RFC 5280. The most important information fields that it holds and stores is

Issuer: The identity of the certification authority that signed the certificate, validating it. It is expressed in ITU-T X.501 Distinguished Name format.
Validity: it defines the dates between which the certificate can be used.
Subject: it defines the identity of the public key owner. It is expressed as ITU-T X.501 Distinguished Name format.
SubjectPublicKeyInfo: it contains an encoded version of the public key.
X509 v3 extensions: it defines a set of extensions that establishes the purpose of the certificate and set some properties related to its management. Each extension can be critical (e.g. cannot be ignored) or not.

Among the X509 v3 extensions, the two most important are
- Key Usage: it defines the usage allowed for the private key, for example digitalSignature (allow the digital signature), keyCertSign (allow the signature of certificates by a certification authority), keyAgreement (allow the key exchange on protocol such as TLS/SSL).
- Extended Key Usage: it defines extended properties in relation to the usage of the private key. For example Server Authentication (for TLS/SSL certificate), Code Signing (for authenticode signature), Email Protection (for protocol such as S/MIME).

You can view the certificates installed on a Windows® machine by using certmgr.msc

In the details tab, you can see the binding between the subject identity (Subject field) and the Public Key (Public Key field). This is highlighted to show its content. It consists of a sequence of bytes in hexadecimal form.

An important feature of the X509 standard is the assignment of a unique identifier to each entity inside a X509 certificate which is in the form of a sequence of numbers organized hierarchically; For example, the sequence 1.3.6.1.5.5.7.3.1 identifies the Server Authentication extended-key usage. Those sequences, called OIDs (object identifiers) are assigned by the authorized organization (IANA, ISO and ITU-T).

The most commonly used Certificate file format today is the PKCS#12 (personal information exchange standard) format. This standard permits you to prepare a X509 certificate file that may contain the private key as well, encrypted with a secret password. This is easiest imagined as a bag that contains the X509 certificate and the encrypted private key.

Manage X509 Certificates Stores with .NET Framework

The .NET classes involved on the X509 certificate management are those under the System.Security.Cryptography.X509Certificates namespace.

Before it can be used, a digital certificate must be located and loaded. X509 certificates are stored on Microsoft® Windows machines in a container that can be browsed with certmgr.msc command. Launching the command, you will see something like this:

This shows the so called “current user” certificate container, the container associated with the user currently logged on the machine. The “Personal” subfolder contains one certificate with a ‘friendly name’ given by webmail.

X509 certificates can be stored on a ‘per machine’ basis too. To open the certificate container for a local or remote machine, run mmc.exe and add the certificates snap-in, selecting the computer you want to administer.

Within the .NET Framework base classes, a subfolder is called “store”. A certificates store can be opened utilizing the X509Store class:

X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
store.Open(OpenFlags.OpenExistingOnly);

In this example, the “current user” container is opened and the certificates that reside on the “Personal” store are loaded.

To open a store on the “local machine” container, you must change the StoreLocation enumeration value with the value:

StoreLocation.LocalMachine

The store that you wish to open is set with the StoreName enumeration. Others enumeration values allow you to select other stores inside the container. These are stores related to the X509 certificates that are issued to other entities involved in the PKI system. Those are beyond the scope of this article.

Notice now the Open method. This accepts, as an input parameter, an OpenFlags enumeration value given by OpenExistingOnly. This states that the Open method can only open an existing store inside the container. It might seem to imply to you that stores can be created too. And you’d be right. Using the appropriate override of theX509Store class constructor, a new store can be created:

X509Store store = new X509Store(“MyStore”, StoreLocation.CurrentUser);
store.Open(OpenFlags.ReadWrite);

In this example, a new store named “MyStore” is created and opened for read write operations.

Notice that, if a new store is created, the .NET Framework doesn’t allow you to remove it anymore. There is no method that permits a store deletion. It can be deleted only with another tool such as CAPICOM or by using Microsoft® CryptoAPI directly.

It’s time now to work with certificates on the stores. To do so, the X509Store class provides a Certificates property of type X509Certificate2Collection:

X509Certificate2Collection certificates = store.Certificates;

The certificates object now contains all the certificates stored on the opened store. A certificate can be retrieved from the collection with the following code:

X509Certificate2 certificate = certificates[n];

with n being the selected index.

A certificate can also be loaded from a certificate file:

X509Certificate2 myCertificate = new X509Certificate2(“c:\....\mycertificate.pfx”);

and then saved into the opened store:

store.Add(myCertificate);

Finally, a certificate can be removed from a store with the method:

store.Remove(certificates[n]);

Manage X509 Certificates with .NET Framework

The X509Certificate2 class allows you to manage the “certificate data units” programmatically. First of all, notice the suffix 2 on the class name. This happens because the X509Certificate2 class extends methods and properties of its base class, the X509Certificate class. It extends the X509Certificate class by allowing, above all, the management of the private key (if present, as seen for the PKCS#12 certificate format), and the browsing of the X509 v3 extensions.

The X509Certificate2 class allows you to retrieve, from the certificate that is loaded, its representative data through a set of properties. Among them:

Name	Type	Description
Issuer	string	Identify the issuer of the certificate (the certification authority that signed the certificate).
Subject	string	Identify the subject, owner of the private key.
NotBefore	DateTime	It states that the certificate can be used only after the NotBefore data.
NotAfter	DateTime	It states that the certificate can be used until the NotAfter data.
PublicKey	PublicKey	Represents the Public Key associated to the subject.
Extensions	X509ExtensionCollection	Collection of X509 v3 extensions.

In those, the public key is retrieved as a PublicKey object. This object contains all the information related to the public key itself, but this information are not easy to explain in this article because the reader would require a knowledge of asymmetric cryptographic algorithms, ASN.1 encoding rules and OID assignment.

You can however get a string representation of the public hey by utilizing a X509Certificate class method, from which X509CertificateClass2 derives:

string publicKey = certificate.GetPublicKeyString();

The publicKey string now contains the same string representation of the public key seen on the first image proposed on this article (without white spaces).

The X509 v3 Extensions can be analyzed through browsing on the collection elements. Those are of type X509Extension. This type defines the OID assigned to the related extension and its ASN.1 encoded value.

Performing Signatures with the .NET Framework

To perform a signature using an X509 certificate and .NET Framework base classes, the X509 certificate must have the private key too. In fact, as stated previously, a signature consists of an encryption with the private key (that must be present) of hashes computed on messages to sign. If an object of type X509Certificate2 has the private key (due to the fact that the PKCS#12 file imported on the store has the private key). This can be retrieved with the following code:

AsymmetricAlgorithm privateKey = certificate.PrivateKey;

You'll have noticed the type of PrivateKey property. It is of type AsymmetricAlgorithm, a class that can be found under the System.Security.Cryptography namespace. Is seems to have nothing to do with private keys. But remember that the private key is an element, inside the PKI elements, that require an high level of protection. When importing a PKCS#12 file into your X509 store, the private key became a more complex “object” inside the store, in the sense that it is saved “keeping in mind the purpose of the same and its protection requirements”. It need an unique identifier to search for it, it need protection against attacker, it need access control, it need a suitable, but flexible, storage. Without entering more deeply on the argument, think of this object as a sort of “pipeline” between your code and the cryptographic subsystem of your operating system that manages, in a secure way, all the cryptographic operation based on your key pairs.

In reality, the AsymmetricAlgorithm class is only a base class of more complex classes. It is the base class for all the classes that implement specific asymmetric algorithms standards. Today, a widely-adopted standard for digital signature is RSA asymmetric encryption with SHA-1 hash algorithm. If the certificate contains RSA asymmetric keys pairs, the previous method does not, as one might expect, return an AsymmetricAlgorithm object, but an RSACryptoServiceProvider object, whose class derives from the AsymmetricAlgorithm class. The RSACryptoServiceProvider class contains all the properties and methods that are related to what we said previously.

So, the next step is to cast the privateKey object to a RSACryptoServiceProvider object, or, in more elegant way:

RSACryptoServiceProvider privateKey
                          =  certificate.PrivateKey as RSACryptoServiceProvider;

Now a signature can be performed. To do so, the SignData method of the privateKey object can be used. It accepts, as input, (1) the data to sign, as array of bytes, and (2) the object that represents the hash algorithm to use:

byte[] buffer = Encoding.Default.GetBytes("Hello World ... !");
byte[] signature = privateKey.SignData(buffer, new SHA1Managed());

The signature can also be verified. To do so you must utilize the public key of the certificate.

RSACryptoServiceProvider publicKey
                        =  certificate.PublicKey.Key as RSACryptoServiceProvider;
 
bool verify = publicKey.VerifyData
                        (buffer, new SHA1Managed(), signature);

From the above example you see that the certificate.PublicKey.Key property is again an object of type AsymmetricAlgortihm. This is for the same reasons seen for the private key.

The certificate to use for the verification can be the same certificate used for the generation of the signature but even a version of it that contains only the public key. No private key is required. And this is what always happens. Remember that the recipient receive only the signed message plus the certificate without the private key, that remain secret and accessible only by its owner. This means that verifications occurs always with the utilization of the public key “extracted” from a certificate that doesn’t have private key.

Another way to perform signature is to use the class RSAPKCS1SignatureFormatter. It brings to the same result of the previous method. To do so, the hash of data to sign must be computed first:

byte[] buffer = Encoding.Default.GetBytes("Hello World ... !");
byte[] hash = SHA1Managed.Create().ComputeHash(buffer);
RSAPKCS1SignatureFormatter formatter
                    = new  RSAPKCS1SignatureFormatter(certificate.PrivateKey);
formatter.SetHashAlgorithm("SHA1");
signature = formatter.CreateSignature(hash);

To verify the signature, use the RSAPKCS1SignatureDeformatter class:

RSAPKCS1SignatureDeformatter deformatter
                    = new RSAPKCS1SignatureFormatter(certificate.PublicKey.Key);
deformatter.SetHashAlgorithm("SHA1");
bool verify = formatter.VerifySignature(hash,signature);

Conclusion

This article gave an outline of what a digital signature is, and how to digitally sign data with the .NET Framework. Digital signatures, and cryptographic services in general, are very complex subjects and are not easy to summarize. If you feel we haven't really helped to make it clearer for you, please say so by leaving a comment to this article and even ask the author for other articles on the subject, indicating what you would like to read more about.

If you would like to experiment digital signatures with X509 certificate, probably you need some X509 certificate for testing. We end this paper by providing you some way to gets digital certificates:

You can download the openssl projects files at The OpenSSL Project and set up a smart certification authority.
You can use makecert.exe command (see Certificate Creation Tool (Makecert.exe) ) that you can find on Microsoft® Windows SDK.
You can generate X509 certificate on-line using X509 Builder web application at the author’s site wecoffee.

source: http://www.simple-talk.com/content/print.aspx?article=833

x509,pkcs7和Pkcs12之間關係

2011-07-07T21:40:00.000-07:00

x.509,是x500那套網絡協議（好像是目錄協議吧）的一個子集，專門定義了在目錄訪問中需要身份認證的證書的格式。後來被rfc收錄3280。

PKCS#12是“個人信息交換語法”。它可以用來將x.509的證書和證書對應的私鑰打包，進行交換。比如你在windows下，可以將IE裡的證書連帶私鑰導出，並設置一個口令保護。這個pfx格式的文件，就是按照pkcs#12的格式打包的。當然pkcs#12不僅僅只是作以上用途的。它可以用來打包交換任何信息。你可以和張三李四用PKCS#12來交換私人數據，包括x.509證書和私鑰。
你在交換x.509證書和私鑰可以採用任何數據格式，例如PKCS#12。

PKCS#7麼，舉個例子，你給張三李四發了一封籤名郵件，同時你將你的個人證書隨郵件一起發給了張三李四，這個時候，你可以按照PKCS#7的格式來打包。

P7一般是把證書分成兩個文件，一個公鑰一個私鑰，有PEM和DER兩種編碼方式。PEM比較多見，就是純文本的，P7一般是分發公鑰用，看到的就是一串可見字符串，擴展名經常是.crt,.cer,.key等。 DER是二進制編碼。
P12是把證書壓成一個文件，.pfx 。主要是考慮分發證書，私鑰是要絕對保密的，不能隨便以文本方式散播。所以P7格式不適合分發。 .pfx中可以加密碼保護，所以相對安全些。
在實踐中要中，用戶證書都是放在USB Key中分發，服務器證書經常還是以文件方式分發。服務器證書和用戶證書，都是X509證書，就是裡面的屬性有區別.

X509 是證書規範
PKCS#7 是消息語法（常用於數字簽名與加密）
PKCS#12 個人消息交換與打包語法（如.PFX .P12）打包成帶公鑰與私鑰
還有其它常用的是PKCS#10 是證書請求語法。

通過CA產生的出來的證書格式文件一般是以PFX P12格式發布給使用者（公鑰與私鑰），用戶拿到證書後，
可以通過IE來導入或直接雙擊嚮導安裝證書，此時私鑰安裝到系統的私有密鑰庫中。使用時系統會自動查找到
私鑰。而最安全的方式還是使用其它USB硬件來存儲，私鑰將無法再從硬件鎖只導出，並且支持硬件訪問需要
用戶的密鑰才能訪問到硬件內的私鑰，永遠保證了私鑰不出硬件鎖！提高了安全性，靈活性，且可以移動的方便性。如ETOKEN產品，一些硬件信息可參考www.dztech.cn.
而相互雙方通迅時使用且交換的是帶公鑰的證書如CER文件。

PKI標準可以分為第一代和第二代標準[12]。

第一代PKI標準主要包括美國RSA公司的公鑰加密標準（Public Key Cryptography Standards，PKCS）系列、國際電信聯盟的ITU-T X.509、IETF組織的公鑰基礎設施X.509（Public Key Infrastructure X .509，PKIX）標準系列、無線應用協議（Wireless Application Protocol ,WAP）論壇的無線公鑰基礎設施（Wireless Public Key Infrastructure，WPKI）標準等。第一代PKI標準主要是基於抽象語法符號（Abstract Syntax Notation One，ASN.1）編碼的，實現比較困難，這也在一定程度上影響了標準的推廣。
第二代PKI標準是在2001年，由微軟、VeriSign和webMethods三家公司發布了XML密鑰管理規範（XML Key Management Specification，XKMS），被稱為第二代PKI標準。 XKMS由兩部分組成：XML密鑰信息服務規範（XML Key Information Service Specification，X-KISS）和XML密鑰註冊服務規範（XML Key Registration Service Specification，X-KRSS）。 X-KISS定義了包含在XML-SIG元素中的用於驗證公鑰信息合法性的信任服務規範；使用X-KISS規範，XML應用程序可通過網絡委託可信的第三方CA處理有關認證簽名、查詢、驗證、綁定公鑰信息等服務。 X-KRSS則定義了一種可通過網絡接受公鑰註冊、撤銷、恢復的服務規範；XML應用程序建立的密鑰對，可通過X-KRSS規範將公鑰部分及其它有關的身份信息發給可信的第三方CA註冊。 X-KISS和X-KRSS規範都按照XML Schema 結構化語言定義，使用簡單對象訪問協議（SOAP V1.1）進行通信，其服務與消息的語法定義遵循Web服務定義語言（WSDL V1.0）。目前XKMS已成為W3C的推薦標準，並已被微軟、VeriSign等公司集成於他們的產品中（微軟已在ASP.net中集成了XKMS，VeriSign已發布了基於Java的信任服務集成工具包TSIK）。
CA中心普遍採用的規範是X.509[13]系列和PKCS系列，其中主要應用到了以下規範：
1． X.209（1988）
ASN.1是描述在網絡上傳輸信息格式的標準方法。它有兩部分：第一部份（ISO 8824/ITU X.208）描述信息內的數據、數據類型及序列格式，也就是數據的語法；第二部分（ISO 8825/ITU X.209）描述如何將各部分數據組成消息，也就是數據的基本編碼規則。
ASN.1原來是作為X.409的一部分而開發的，後來才獨立地成為一個標準。這兩個協議除了在PKI體系中被應用外，還被廣泛應用於通信和計算機的其他領域。
2． X.500（1993）
X.500是一套已經被國際標準化組織（ISO）接受的目錄服務系統標準，它定義了一個機構如何在全局範圍內共享其名字和與之相關的對象。 X.500是層次性的，其中的管理域（機構、分支、部門和工作組）可以提供這些域內的用戶和資源信息。在PKI體系中，X.500被用來惟一標識一個實體，該實體可以是機構、組織、個人或一台服務器。 X.500被認為是實現目錄服務的最佳途徑，但X.500的實現需要較大的投資，並且比其他方式速度慢;而其優勢具有信息模型、多功能和開放性。
3． X.509（1993）
X.509是由國際電信聯盟（ITU-T）制定的數字證書標準。在X.500確保用戶名稱惟一性的基礎上，X.509為X.500用戶名稱提供了通信實體的鑑別機制，並規定了實體鑑別過程中廣泛適用的證書語法和數據接口。
X.509的最初版本公佈於1988年。 X.509證書由用戶公共密鑰和用戶標識符組成。此外還包括版本號、證書序列號、CA標識符、簽名算法標識、簽發者名稱、證書有效期等信息。這一標準的最新版本是X.509 v3，它定義了包含擴展信息的數字證書。該版數字證書提供了一個擴展信息字段，用來提供更多的靈活性及特殊應用環境下所需的信息傳送。
4． PKCS系列標準
PKCS是由美國RSA數據安全公司及其合作夥伴制定的一組公鑰密碼學標準，其中包括證書申請、證書更新、證書作廢表發布、擴展證書內容以及數字簽名、數字信封的格式等方面的一系列相關協議。到1999年底，PKCS已經公佈了以下標準：
PKCS#1：定義RSA公開密鑰算法加密和簽名機制，主要用於組織PKCS#7中所描述的數字簽名和數字信封。
PKCS#3：定義Diffie-Hellman密鑰交換協議。
PKCS#5：描述一種利用從口令派生出來的安全密鑰加密字符串的方法。使用MD2或MD5 從口令中派生密鑰，並採用DES-CBC模式加密。主要用於加密從一個計算機傳送到另一個計算機的私人密鑰，不能用於加密消息。
PKCS#6：描述了公鑰證書的標準語法，主要描述X.509證書的擴展格式。
PKCS#7：定義一種通用的消息語法，包括數字簽名和加密等用於增強的加密機制，PKCS#7與PEM兼容，所以不需其他密碼操作，就可以將加密的消息轉換成PEM消息。
PKCS#8：描述私有密鑰信息格式，該信息包括公開密鑰算法的私有密鑰以及可選的屬性集等。
PKCS#9：定義一些用於PKCS#6證書擴展、PKCS#7數字簽名和PKCS#8私鑰加密信息的屬性類型。
PKCS#10：描述證書請求語法。
PKCS#11：稱為Cyptoki，定義了一套獨立於技術的程序設計接口，用於智能卡和PCMCIA卡之類的加密設備。
PKCS#12：描述個人信息交換語法標準。描述了將用戶公鑰、私鑰、證書和其他相關信息打包的語法。
PKCS#13：橢圓曲線密碼體制標準。
PKCS#14：偽隨機數生成標準。
PKCS#15：密碼令牌信息格式標準。
5． OCSP在線證書狀態協議
OCSP（Online Certificate Status Protocol）[14]是IETF頒布的用於檢查數字證書在某一交易時刻是否仍然有效的標準。該標準提供給PKI用戶一條方便快捷的數字證書狀態查詢通道，使PKI體系能夠更有效、更安全地在各個領域中被廣泛應用。
6． LDAP 輕量級目錄訪問協議
LDAP規範（RFC1487）簡化了笨重的X.500目錄訪問協議，並且在功能性、數據表示、編碼和傳輸方面都進行了相應的修改。 1997年，LDAP第3版本成為互聯網標準。目前，LDAP v3已經在PKI體系中被廣泛應用於證書信息發布、CRL信息發布、CA政策以及與信息發布相關的各個方面。

source:

http://topic.csdn.net/u/20071015/18/37a2bffb-2354-493e-b5a9-b96ab28063ae.html

http://hi.baidu.com/twmp/blog/item/661e9e3fa78764c97d1e71d1.html

JAVA和C＃3DES加密解密

2011-06-30T20:53:00.000-07:00

一個項目.net 要調用JAVA的WEB
SERVICE，數據採用3DES加密，涉及到兩種語言3DES一致性的問題，
下面分享一下，
這裡的KEY採用Base64編碼，便用分發，因為Java的Byte範圍為-128至127，c#的Byte範圍是0-255
核心是確定Mode和Padding，關於這兩個的意思可以搜索3DES算法相關文章
一個是C#採用CBC
Mode，PKCS7 Padding,Java採用CBC Mode，PKCS5Padding Padding,
另一個是C#採用ECB
Mode，PKCS7 Padding,Java採用ECB Mode，PKCS5Padding
Padding,
Java的ECB模式不需要IV
對字符加密時，雙方採用的都是UTF-8編碼.

主要差異如下：

1、對於待加密解密的數據，各自的填充模式不一樣
C#的模式有：ANSIX923、ISO10126、None、PKCS7、Zero，而Java有：NoPadding、PKCS5Padding、SSL3Padding

2、各自默認的3DES實現，模式和填充方式不一樣
C#的默認模式為CBC,默認填充方式為PKCS7; java的默認模式為ECB，默認填充方式為PKCS5Padding

3、各自的key的size不一樣
C#中key的size為16和24均可；java中要求key的size必須為24；對於CBC模式下的向量iv的size兩者均要求必須為8

翻看了3DES的原理：

DES主要採用替換和移位的方法,用56位密鑰對64位二進制數據塊進行加密,每次加密可對64位的輸入數據進行16輪編碼,
經一系列替換和移位後,輸入的64位轉換成安全不同的64的輸出數據.

3DES:是在DES的基礎上採用三重DES,即用兩個56位的密鑰K1,K2,發送方用K1加密,K2解密,再使用K1加密.接收方使用K1解密,K2加密,再使用K1解密,

其效果相當於密鑰長度加倍.

於是嘗試在java中，對key進行補位，即用前8個字節作為byte[24] 中的byte[16]~byte[23];發現與c#中加密的結果相同！於是大膽假設C#中可能是檢查key的size為16的時候

自動將前8個字節作為k3進行了補位，而java沒有實現這一點（因為java的3DES算法中強制要求key的size必須為24）。這樣的情況下，可能就是發送方用k1加密、k2解密、k3再加密；接受方k3解密、k2加密、再k1解密來實現。

最終經過編碼驗證，確認key大小為24時，java和c#的加密解密結果相一致。

Java中實現時，只要注意對大小不足24的key進行補位，和採用CBC模式，填充模式為PKCS5Padding即可。

還有一種讓Java和.Net兼容的方式,在.Net中指定模式為ECB，填充為PKCS7,然後在Java中採用其默認的模式（DESede/ECB/PKCS5Padding）即可,注意雙方約定key的size為24個字節。建議雙方對key以base64編碼字符串進行告知，因為java和.net中byte字節的範圍不相同(前者-128~127,後者0~255)，避免不必要的處理。

下面是C#代码

  /// 
  /// DES3加密解密
  /// 
    public class Des3
  {
      #region CBC模式**

      /// 
      /// DES3 CBC模式加密
      /// 
      /// 密钥
      /// IV
      /// 明文的byte数组
      /// 密文的byte数组
        public static byte[] Des3EncodeCBC( byte[] key, byte[] iv, byte[] data )
      {
          //复制于MSDN

          try
          {
              // Create a MemoryStream.
                MemoryStream mStream = new MemoryStream();

              TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider();
              tdsp.Mode = CipherMode.CBC;             //默认值
                tdsp.Padding = PaddingMode.PKCS7;       //默认值

              // Create a CryptoStream using the MemoryStream
              // and the passed key and initialization vector (IV).
                CryptoStream cStream = new CryptoStream( mStream,
                  tdsp.CreateEncryptor( key, iv ),
                  CryptoStreamMode.Write );

              // Write the byte array to the crypto stream and flush it.
                cStream.Write( data, 0, data.Length );
              cStream.FlushFinalBlock();

              // Get an array of bytes from the
              // MemoryStream that holds the
              // encrypted data.
                byte[] ret = mStream.ToArray();

              // Close the streams.
                cStream.Close();
              mStream.Close();

              // Return the encrypted buffer.
                return ret;
          }
          catch ( CryptographicException e )
          {
              Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
              return null;
          }
      }

      /// 
      /// DES3 CBC模式解密
      /// 
      /// 密钥
      /// IV
      /// 密文的byte数组
      /// 明文的byte数组
        public static byte[] Des3DecodeCBC( byte[] key, byte[] iv, byte[] data )
      {
          try
          {
              // Create a new MemoryStream using the passed
              // array of encrypted data.
                MemoryStream msDecrypt = new MemoryStream( data );

              TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider();
              tdsp.Mode = CipherMode.CBC;
              tdsp.Padding = PaddingMode.PKCS7;

              // Create a CryptoStream using the MemoryStream
              // and the passed key and initialization vector (IV).
                CryptoStream csDecrypt = new CryptoStream( msDecrypt,
                  tdsp.CreateDecryptor( key, iv ),
                  CryptoStreamMode.Read );

              // Create buffer to hold the decrypted data.
                byte[] fromEncrypt = new byte[data.Length];

              // Read the decrypted data out of the crypto stream
              // and place it into the temporary buffer.
                csDecrypt.Read( fromEncrypt, 0, fromEncrypt.Length );

              //Convert the buffer into a string and return it.
                return fromEncrypt;
          }
          catch ( CryptographicException e )
          {
              Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
              return null;
          }
      }

      #endregion

      #region ECB模式

      /// 
      /// DES3 ECB模式加密
      /// 
      /// 密钥
      /// IV(当模式为ECB时，IV无用)
      /// 明文的byte数组
      /// 密文的byte数组
        public static byte[] Des3EncodeECB( byte[] key, byte[] iv, byte[] data )
      {
          try
          {
              // Create a MemoryStream.
                MemoryStream mStream = new MemoryStream();

              TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider();
              tdsp.Mode = CipherMode.ECB;
              tdsp.Padding = PaddingMode.PKCS7;
              // Create a CryptoStream using the MemoryStream
              // and the passed key and initialization vector (IV).
                CryptoStream cStream = new CryptoStream( mStream,
                  tdsp.CreateEncryptor( key, iv ),
                  CryptoStreamMode.Write );

              // Write the byte array to the crypto stream and flush it.
                cStream.Write( data, 0, data.Length );
              cStream.FlushFinalBlock();

              // Get an array of bytes from the
              // MemoryStream that holds the
              // encrypted data.
                byte[] ret = mStream.ToArray();

              // Close the streams.
                cStream.Close();
              mStream.Close();

              // Return the encrypted buffer.
                return ret;
          }
          catch ( CryptographicException e )
          {
              Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
              return null;
          }

      }

      /// 
      /// DES3 ECB模式解密
      /// 
      /// 密钥
      /// IV(当模式为ECB时，IV无用)
      /// 密文的byte数组
      /// 明文的byte数组
        public static byte[] Des3DecodeECB( byte[] key, byte[] iv, byte[] data )
      {
          try
          {
              // Create a new MemoryStream using the passed
              // array of encrypted data.
                MemoryStream msDecrypt = new MemoryStream( data );

              TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider();
              tdsp.Mode = CipherMode.ECB;
              tdsp.Padding = PaddingMode.PKCS7;

              // Create a CryptoStream using the MemoryStream
              // and the passed key and initialization vector (IV).
                CryptoStream csDecrypt = new CryptoStream( msDecrypt,
                  tdsp.CreateDecryptor( key, iv ),
                  CryptoStreamMode.Read );

              // Create buffer to hold the decrypted data.
                byte[] fromEncrypt = new byte[data.Length];

              // Read the decrypted data out of the crypto stream
              // and place it into the temporary buffer.
                csDecrypt.Read( fromEncrypt, 0, fromEncrypt.Length );

              //Convert the buffer into a string and return it.
                return fromEncrypt;
          }
          catch ( CryptographicException e )
          {
              Console.WriteLine( "A Cryptographic error occurred: {0}", e.Message );
              return null;
          }
      }

      #endregion

      /// 
      /// 类测试
      /// 
        public static void Test()
      {
          System.Text.Encoding utf8 = System.Text.Encoding.UTF8;

          //key为abcdefghijklmnopqrstuvwx的Base64编码
            byte[] key = Convert.FromBase64String( "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4" );
          byte[] iv = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };      //当模式为ECB时，IV无用
            byte[] data = utf8.GetBytes( "中国ABCabc123" );

          System.Console.WriteLine( "ECB模式:" );
          byte[] str1 = Des3.Des3EncodeECB( key, iv, data );
          byte[] str2 = Des3.Des3DecodeECB( key, iv, str1 );
          System.Console.WriteLine( Convert.ToBase64String( str1 ) );
          System.Console.WriteLine( System.Text.Encoding.UTF8.GetString( str2 ) );

          System.Console.WriteLine();

          System.Console.WriteLine( "CBC模式:" );
          byte[] str3 = Des3.Des3EncodeCBC( key, iv, data );
          byte[] str4 = Des3.Des3DecodeCBC( key, iv, str3 );
          System.Console.WriteLine( Convert.ToBase64String( str3 ) );
          System.Console.WriteLine( utf8.GetString( str4 ) );

          System.Console.WriteLine();

      }

  }

接着是Java代码

import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.IvParameterSpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class Des3 {
  public static void main(String[] args) throws Exception {

      byte[] key=new BASE64Decoder().decodeBuffer("YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4");
      byte[] keyiv = { 1, 2, 3, 4, 5, 6, 7, 8 };

      byte[] data="中国ABCabc123".getBytes("UTF-8");
   
      System.out.println("ECB加密解密");
      byte[] str3 = des3EncodeECB(key,data );
      byte[] str4 = ees3DecodeECB(key, str3);
      System.out.println(new BASE64Encoder().encode(str3));
      System.out.println(new String(str4, "UTF-8"));

      System.out.println();

      System.out.println("CBC加密解密");
      byte[] str5 = des3EncodeCBC(key, keyiv, data);
      byte[] str6 = des3DecodeCBC(key, keyiv, str5);
      System.out.println(new BASE64Encoder().encode(str5));
      System.out.println(new String(str6, "UTF-8"));

  }

  /**
   * ECB加密,不要IV
   * @param key 密钥
   * @param data 明文
   * @return Base64编码的密文
   * @throws Exception
   */
  public static byte[] des3EncodeECB(byte[] key, byte[] data)
          throws Exception {

      Key deskey = null;
      DESedeKeySpec spec = new DESedeKeySpec(key);
      SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
      deskey = keyfactory.generateSecret(spec);

      Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");

      cipher.init(Cipher.ENCRYPT_MODE, deskey);
      byte[] bOut = cipher.doFinal(data);

      return bOut;
  }

  /**
   * ECB解密,不要IV
   * @param key 密钥
   * @param data Base64编码的密文
   * @return 明文
   * @throws Exception
   */
  public static byte[] ees3DecodeECB(byte[] key, byte[] data)
          throws Exception {

      Key deskey = null;
      DESedeKeySpec spec = new DESedeKeySpec(key);
      SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
      deskey = keyfactory.generateSecret(spec);

      Cipher cipher = Cipher.getInstance("desede" + "/ECB/PKCS5Padding");

      cipher.init(Cipher.DECRYPT_MODE, deskey);

      byte[] bOut = cipher.doFinal(data);

      return bOut;

  }

  /**
   * CBC加密
   * @param key 密钥
   * @param keyiv IV
   * @param data 明文
   * @return Base64编码的密文
   * @throws Exception
   */
  public static byte[] des3EncodeCBC(byte[] key, byte[] keyiv, byte[] data)
          throws Exception {

      Key deskey = null;
      DESedeKeySpec spec = new DESedeKeySpec(key);
      SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
      deskey = keyfactory.generateSecret(spec);

      Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
      IvParameterSpec ips = new IvParameterSpec(keyiv);
      cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);
      byte[] bOut = cipher.doFinal(data);

      return bOut;
  }

  /**
   * CBC解密
   * @param key 密钥
   * @param keyiv IV
   * @param data Base64编码的密文
   * @return 明文
   * @throws Exception
   */
  public static byte[] des3DecodeCBC(byte[] key, byte[] keyiv, byte[] data)
          throws Exception {

      Key deskey = null;
      DESedeKeySpec spec = new DESedeKeySpec(key);
      SecretKeyFactory keyfactory = SecretKeyFactory.getInstance("desede");
      deskey = keyfactory.generateSecret(spec);

      Cipher cipher = Cipher.getInstance("desede" + "/CBC/PKCS5Padding");
      IvParameterSpec ips = new IvParameterSpec(keyiv);

      cipher.init(Cipher.DECRYPT_MODE, deskey, ips);

      byte[] bOut = cipher.doFinal(data);

      return bOut;

  }

}

下面是运行结果

ECB模式:
rmWB4+r9Ug93WI0KAEuMig==
中国ABCabc123

CBC模式:
4aabWF8UFour/vNfnzJrjw==
中国ABCabc123

source:

http://www.cnblogs.com/neil-zhao/archive/2011/06/01/2066058.html

http://gaoge2000.blog.hexun.com/18731819_d.html

Certificate Encryption/Decryption Example on C#

2011-06-14T19:35:00.000-07:00

The following are example functions using a PKCS12 cert. (It has both public and private keys) and the result is encoded/decoded by base64.

static string Decrypt(string data)
{
X509Certificate2 myCertificate = new X509Certificate2("c:\\temp\\mycerts.p12","123456");
RSACryptoServiceProvider provider1 = (RSACryptoServiceProvider)myCertificate.PrivateKey;
byte[] buffer1 = Convert.FromBase64String(data);
byte[] result = provider1.Decrypt(buffer1,false);

return Encoding.UTF8.GetString(result);
//return (new UnicodeEncoding()).GetString(result);
}
static string Encrypt(string data)
{
X509Certificate2 myCertificate = new X509Certificate2("c:\\temp\\mycerts.p12", "123456");
RSACryptoServiceProvider provider1 = (RSACryptoServiceProvider)myCertificate.PublicKey.Key;
//byte[] buffer1 = (new UnicodeEncoding()).GetBytes(data);

byte[] buffer1 = Encoding.UTF8.GetBytes(data);
byte[] result = provider1.Encrypt(buffer1, false);
string b64s = Convert.ToBase64String(result);
return b64s;
}

static bool VerifyData(string data, string signature)
{
X509Certificate2 myCertificate = new X509Certificate2("c:\\temp\\mycerts.p12", "123456");
RSACryptoServiceProvider provider1 = (RSACryptoServiceProvider)myCertificate.PublicKey.Key;
byte[] sb = Convert.FromBase64String(signature);

//byte[] db = (new ASCIIEncoding()).GetBytes(data);

byte[] db = Encoding.UTF8.GetBytes(data);

return provider1.VerifyData(db, new SHA1CryptoServiceProvider(), sb);
}

static string SignData(string data)
{
X509Certificate2 myCertificate = new X509Certificate2("c:\\temp\\mycerts.p12", "123456");
RSACryptoServiceProvider provider1 = (RSACryptoServiceProvider)myCertificate.PrivateKey;
//byte[] db = (new ASCIIEncoding()).GetBytes(data);

byte[] db = Encoding.UTF8.GetBytes(data);

byte[] sb = provider1.SignData(db, new SHA1CryptoServiceProvider());
return Convert.ToBase64String(sb);
}

Java的編碼問題匯總

2011-05-25T21:21:00.001-07:00

問題一：在JAVA中讀取文件時應該採用什麼編碼？

Java的讀取文件的方式總體可以分為兩類：按字節讀取和按字符讀取。按字節讀取就是採用 InputStream.read（）執行方法來讀取字節，然後保存到一個字節 []數組中，最後經常用新的字符串（字節 []）;把字節數組轉換成字符串。在最後一步隱藏了一個編碼的細節，新的字符串（字節 []）;會使用操作系統默認的字符集來解碼字節數組，中文操作系統就是GBK的。而我們從輸入流裡讀取的字節很可能就不是GBK的編碼的，因為從輸入流裡讀取的字節編碼取決於被讀取的文件自身的編碼。舉個例子：我們在ð：盤新建一個名為 demo.txt的文件，寫入“我們。”並保存。此時 demo.txt編碼是ANSI和中文操作系統下就是GBK的。此時我們用輸入字節流讀取該文件所得到的字節就是使用GBK的方式編碼的字節。那麼我們最終新的字符串（字節 []）;時採用平台默認的GBK的來編碼成字符串也是沒有問題的（字節編碼和默認解碼一致）。試想一下，如果在保存demo.txt文件時，我們選擇的UTF - 8編碼，那麼該文件的編碼就不在是的ANSI了，而變成了UTF - 8的。仍然採用輸入字節流來讀取，那麼此時讀取的字節和上一次就不一樣了，這次的字節是使用UTF - 8編碼的字節。兩次的字節顯然不一樣，一個很明顯的區別就是：GBK的每個漢字兩個字節，而UTF - 8的每個漢字三個字節。如何我們最後還使用新字符串（字節 []）;來構造字符串對象，則會出現亂碼，原因很簡單，因為構造時採用的默認解碼 GBK的，而我們的字節是使用UTF - 8字節。正確的辦法就是使用新的字符串（字節 []“的UTF - 8”）;來構造的String對象。此時我們的字節編碼和構造使用的解碼是一致的，不會出現亂碼問題了。

說完字節輸入流，再來說說字節輸出流。

我們知道如果採用字節輸出流把字節輸出到某個文件，我們是無法指定生成文件的編碼的（假設文件以前不存在），那麼生成的文件是什麼編碼的呢？經過測試發現，其實這取決於寫入的字節編碼格式。比如以下代碼：

OutputStream的輸出 =新FileOutputStream（為“D：\ \ demo.txt”）;

out.write（“我們”。getBytes（）構造）;

getBytes（）構造會採用操作系統默認的字符集來編碼字節，這裡就是GBK的，所以我們寫入文件的是GBK的demo.txt編碼的字節。那麼這個文件的編碼就是GBK的。如果稍微修改一下程序： out.write（“我們”。的GetBytes（“使用UTF - 8”））;此時我們寫入的字節就是使用UTF - 8的，那麼 demo.txt文件編碼就是使用UTF - 8。這裡還有一點，如果把“我們”換成 123或農業銀行之類的的ASCII碼字符，那麼無論是採用的GetBytes（）或者的GetBytes（“使用UTF - 8”），那麼生成的文件都將是GBK的編碼的。

這裡可以總結一下，輸入流中的字節編碼取決文件本身的編碼，而OutputStream的生成文件的編碼取決於字節的編碼。

下面說說採用字符輸入流來讀取文件。

首先，我們需要理解一下字符流。其實字符流可以看做是一種包裝流，它的底層還是採用字節流來讀取字節，然後它使用指定的編碼方式將讀取字節解碼為字符。說起字符流，不得不提的就是的InputStreamReader。以下是Java API的對它的說明：的InputStreamReader是字節流通向字符流的橋樑：它使用指定的字符集讀取字節並將其解碼為字符。它使用的字符集可以由名稱指定或顯式給定，否則可能接受平台默認的字符集。說到這裡其實很明白了，的InputStreamReader在底層還是採用字節流來讀取字節，讀取字節後它需要一個編碼格式來解碼讀取的字節，如果我們在構造的InputStreamReader沒有傳入編碼方式，那麼會採用操作系統默認的GBK的來解碼讀取的字節。demo.txt還用上面的例子，假設編碼方式為 GBK的demo.txt，我們使用如下代碼來讀取文件：

在新的InputStreamReader的InputStreamReader =（新FileInputStream的（“demo.txt”））;

那麼我們讀取不會產生亂碼，因為文件採用 GBK的編碼，所以讀出的字節也是GBK的編碼的，而的InputStreamReader默認採用解碼也是GBK的。如果把demo.txt編碼方式換成 UTF - 8的，那麼我們採用這種方式讀取就會產生亂碼。這是因為字節編碼（使用UTF - 8）和我們的解碼編碼（GBK的）造成的。解決辦法如下：

在新的InputStreamReader的InputStreamReader =（新FileInputStream的（“demo.txt”），“使用UTF - 8”）;

給的InputStreamReader指定解碼編碼，這樣二者統一就不會出現亂碼了。

下面說說字符輸出流。

字符輸出流的原理和字符輸入流的原理一樣，也可以看做是包裝流，其底層還是採用字節輸出流來寫文件。只是字符輸出流根據指定的編碼將字符轉換為字節的。字符輸出流的主要類是：OutputStreamWriter。Java API的解釋如下：OutputStreamWriter是字符流通向字節流的橋樑：使用指定的字符集將要向其寫入的字符編碼為字節。它使用的字符集可以由名稱指定或顯式給定，否則可能接受平台默認的字符集。說的很明白了，它需要一個編碼將寫入的字符轉換為字節，如果沒有指定則採用 GBK的編碼，那麼輸出的字節都將是GBK的編碼，生成的文件也是GBK的編碼的。如果採用以下方式構造 OutputStreamWriter：

OutputStreamWriter輸出 =新OutputStreamWriter（新FileOutputStream（“dd.txt”），“使用UTF - 8”）;

那麼寫入的字符將被編碼為 UTF - 8編碼的字節，生成的文件也將是使用UTF - 8格式的。

問題二：既然讀文件要使用和文件編碼一致的編碼，那麼 javac的編譯文件也需要讀取文件，它使用什麼編碼呢？

這個問題從來就沒想過，也從沒當做是什麼問題。正是因為問題一而引發的思考，其實這裡還是有東西可以挖掘的。下面分三種情況來探討，這三種情況也是我們常用的編譯的Java源文件的方法。

1.javac在控制台編譯的Java類文件。

通常我們手動建立一個 java的文件Demo.java，並保存。此時 Demo.java文件的編碼為 ANSI和中文操作系統下就是GBK的。然後使用javac的命令來編譯該源文件。“javac的Demo.java”。javac的也需要讀取的Java文件，那麼 javac的是使用什麼編碼來解碼我們讀取的字節呢？其實 javac的採用了操作系統默認的GBK的編碼解碼我們讀取的字節，這個編碼正好也是Demo.java文件的編碼，二者一致，所以不會出現亂碼情況。讓我們來做點手腳，在保存Demo.java文件時，我們選擇的UTF - 8保存。此時 Demo.java文件編碼就是UTF - 8的了。我們再使用“javac的Demo.java”來編譯，如果Demo.java裡含有中文字符，此時控制台會出現警告信息，也出現了亂碼。究其原因，就是因為採用了GBK的javac的編碼解碼我們讀取的字節。因為我們的字節是使用UTF - 8編碼的，所以會出現亂碼。如果不信的話你可以自己試試。那麼解決辦法呢？解決辦法就是使用的javac的編碼參數來制定我們的解碼編碼。如下： javac的編碼的UTF - 8 Demo.java。這裡我們指定了使用的UTF - 8來解碼讀取的字節，由於這個編碼和Demo.java文件編碼一致，所以不會出現亂碼情況了。

2.Eclipse中編譯的Java文件。

我習慣把Eclipse中的編碼設置成UTF - 8的。那麼每個項目中的Java的源文件的編碼就是使用UTF - 8。這樣編譯也從沒有問題，也沒有出現過亂碼。正是因為這樣才掩蓋了使用javac的可能出現的亂碼。那麼 Eclipse的是如何正確編譯文件編碼為 UTF - 8編碼的Java的源文件的呢？唯一的解釋就是Eclipse的自動識別了我們的Java源文件的文件編碼，然後採取了正確的編碼參數來編譯我們的Java的源文件。功勞都歸功於 IDE中的強大了。

3。使用的Ant來編譯的Java文件。

螞蟻也是我常用的編譯的Java文件的工具。首先，必須知道螞蟻在後台其實也是採用的javac來編譯的Java源文件的，那麼可想而知，一會出現的問題在螞蟻中也會存在。如果我們使用螞蟻來編譯的UTF - 8編碼的Java的源文件，並且不指定如何編碼，那麼也會出現亂碼的情況。所以螞蟻的編譯命令有一個屬性“編碼”允許我們指定編碼，如果我們要編譯源文件編碼為 UTF - 8編碼的java的文件，那麼我們的命令應該如下：

“>

指定了編碼也就相當於“javac的編碼”了，所以不會出現亂碼了。

問題三：tomcat的中編譯的JSP的情況。

這個話題也是由問題二引出的。既然javac的編譯的Java源文件需要採用正確的編碼，那麼 Tomcat的編譯的JSP時也要讀取文件，此時的Tomcat採用什麼編碼來讀取文件？會出現亂碼情況嗎？下面我們來分析。

我們通常會在jsp的開頭寫上如下代碼：

<％@網頁的語言 =“爪哇”的contentType =“text / html的，字符集= UTF - 8”pageEncoding =“的UTF - 8”％>

我常常不寫 pageEncoding這個屬於，也不明白它的作用，但是不寫也沒出現過亂碼情況。其實這個屬性就是告訴 tomcat的採用什麼編碼來讀取 JSP的文件的。它應該和jsp的文件本身的編碼一致。比如我們新建個 jsp的文件，設置文件編碼為 GBK的，那麼此時我們的pageEncoding應該設置為 GBK的，這樣我們寫入文件的字符就是GBK的編碼的，Tomcat的讀取文件時採用也是GBK的編碼，所以能保證正確的解碼讀取的字節。不會出現亂碼。如果把pageEncoding設置為 UTF - 8的，那麼讀取的jsp文件過程中轉碼就出現了亂碼。上面說我常常不寫 pageEncoding這個屬性，但是也沒出現過亂碼，這是怎麼回事呢？那是因為如果沒有 pageEncoding屬性中，Tomcat會採用的contentType中字符集編碼來讀取 jsp的文件，我的jsp的文件編碼通常設置為 UTF - 8編碼，字符集的contentType的也設置為使用UTF -8，這樣的Tomcat使用的UTF - 8編碼來解碼讀取的jsp的文件，二者編碼一致也不會出現亂碼。這只是中的contentType字符集的一個作用，它還有兩個作用，後面再說。可能有人會問：如果我既不設置 pageEncoding屬性，也不設置的contentType的字符集屬性，那麼 Tomcat的會採取什麼編碼來解碼讀取的jsp的文件呢？答案是異 - 8859 - 1，這是Tomcat的讀取文件採用的默認編碼，如果用這種編碼來讀取文件顯然會出現亂碼。

問題四：輸出。

問題二和問題三分析的過程其實就是從源文件àclass文件過程中的轉碼情況。最終的類文件都是以Unicode的編碼的，我們前面所做的工作就是把各種不同的編碼轉換為 Unicode的編碼，比如從 GBK的轉換為 Unicode編碼，從使用UTF - 8轉換為 Unicode的。因為只有採用正確的編碼來轉碼才能保證不出現亂碼。在jvm在運行時其內部都是採用的Unicode編碼的，其實在輸出時，又會做一次編碼的轉換。讓我們分兩種情況來討論。

1.java中採用 Sysout.out.println輸出。

比如：Sysout.out.println（“我們”）。經過正確的解碼後“我們”是unicode的保存在內存中的，但是在向標準輸出（控制台）輸出時，jvm的又做了一次轉碼，它會採用操作系統默認編碼（中文操作系統是GBK的），將內存中的Unicode的編碼轉換為 GBK的編碼，然後輸出到控制台。因為我們操作系統是中文系統，所以往終端顯示設備上打印字符時使用的也是GBK的編碼。因為終端的編碼無法手動改變，所以這個過程對我們來說是透明的，只要編譯時能正確轉碼，最終的輸出都將是正確的，不會出現亂碼。在Eclipse中中可以設置控制台的字符編碼，具體位置在運行配置對話框的通用標籤裡，我們可以試著設置為 UTF - 8的，此時的輸出就是亂碼了。因為輸出時是採用 GBK的編碼的，而顯示卻是使用使用UTF - 8，編碼不同，所以出現亂碼。

2.jsp中使用out.println（）輸出到客戶端瀏覽器。

JSP的編譯成類後，如果輸出到客戶端，也有個轉碼的過程。爪哇會採用操作系統默認的編碼來轉碼，那麼 Tomcat的採用什麼編碼來轉碼呢？其實 tomcat的是根據 <％@網頁的語言=“爪哇”的contentType =“text / html的，字符集= UTF - 8”pageEncoding =“的UTF - 8”％>中的contentType的字符集參數來轉碼的，用來設置的contentType Tomcat的往瀏覽器發送的HTML內容所使用的編碼。Tomcat的根據這個編碼來轉碼內存中的Unicode的。經過轉碼後的Tomcat輸出到客戶端的字符編碼就是utf - 8的了。那麼瀏覽器怎麼知道採取什麼編碼格式來顯示接收到的內容呢？這就是contentType中的字符集屬性的第三個作用了：這個編碼會在HTTP的響應頭中指定以通知瀏覽器。瀏覽器使用的HTTP響應頭的contentType中的字符集屬性來顯示接收到的內容。

總結一下的contentType字符集的三個作用：

1）。在沒有 pageEncoding屬性時，Tomcat的使用它來解碼讀取的jsp的文件。

2）。Tomcat的向客戶端輸出時，使用它來編碼發送的內容。

3）。通知瀏覽器，應該以什麼編碼來顯示接收到的內容。

為了能更好的理解上面所說的解碼和轉碼過程，我們舉一個例子。

新建一個 index.jsp的文件，該文件編碼為 GBK的，在jsp的開頭我們寫上如下代碼：

<％@網頁的語言 =“爪哇”的contentType =“text / html的，字符集= UTF - 8”pageEncoding =“GBK的”％>

這裡的字符集和pageEncoding不同，但是也不會出現亂碼，我來解釋一下。首先Tomcat的讀取 jsp的內容，並根據 pageEncoding指定的GBK的編碼將讀取的GBK的字節解碼並轉換為 Unicode的字節碼保存在類文件中。然後 tomcat的在輸出時（out.println（））使用字符集屬性將內存中的Unicode的轉換為 UTF - 8的編碼，並在響應頭中通知瀏覽器，瀏覽器以UTF - 8的顯示接收到的內容。整個過程沒有一次轉碼錯誤，所以就不會出現亂碼情況。

問題五：屬性和ResourceBundle的使用的解碼編碼。

以上兩個是我們常用的類，他們在讀取文件過程中並不允許我們指定解碼編碼，那麼它們採取什麼解碼方式呢？查看源碼後發現都是採用異 - 8859 - 1編碼來解碼
的。這樣的話我們也不難理解我們寫的屬性文件為什麼都是異 - 8859 - 1的了。因為採取任何一個別的編碼都將產生亂碼。因為異 - 8859 - 1編碼是沒
有中文的，所以我們輸入的中文要轉換為 unicode的，通常我們使用插件來完成，也可以使用的JDK自帶的native2ascii的工具。

source : http://www.blogjava.net/zhangchao/archive/2011/05/26/351051.html

iOS開發中常用代碼解釋

2011-04-25T03:57:00.000-07:00

#include /* 说明 malloc, NULL, size_t */

#include /* 说明 va_ 相关类型和函数 */

#include /* 说明 strcat 等 */

char *vstrcat(const char *first, ...)

{

size_t len;

char *retbuf;

va_list argp;

char *p;

if(first == NULL)

return NULL;

len = strlen(first);

va_start(argp, first);

while((p = va_arg(argp, char *)) != NULL)

len += strlen(p);

va_end(argp);

retbuf = malloc(len + 1); /* +1 包含终止符 \0 */

if(retbuf == NULL)

return NULL; /* 出错 */

(void)strcpy(retbuf, first);

va_start(argp, first); /* 重新开始扫描 */

while((p = va_arg(argp, char *)) != NULL)

(void)strcat(retbuf, p);

va_end(argp);

retbuf = malloc(len + 1); /* +1 包含终止符 \0 */

if(retbuf == NULL)

return NULL; /* 出错 */

(void)strcpy(retbuf, first);

va_start(argp, first); /* 重新开始扫描 */

while((p = va_arg(argp, char *)) != NULL)

(void)strcat(retbuf, p);

va_end(argp);

return retbuf;

}

%c 一个单一的字符

%d 一个十进制整数

%i 一个整数

%e, %f, %g 一个浮点数

%o 一个八进制数

%s 一个字符串

%x 一个十六进制数

%p 一个指针

%n 一个等于读取字符数量的整数

%u 一个无符号整数

%[] 一个字符集

%% 一个精度符号

//一、NSString

/*----------------创建字符串的方法----------------*/

1、创建常量字符串。

NSString *astring = @"This is a String!";

2、创建空字符串，给予赋值。

NSString *astring = [[NSString alloc] init];

astring = @"This is a String!";

NSLog(@"astring:%@",astring);

[astring release];

3、在以上方法中，提升速度:initWithString方法

NSString *astring = [[NSString alloc] initWithString:@"This is a String!"];

NSLog(@"astring:%@",astring);

[astring release];

4、用标准c创建字符串:initWithCString方法

char *Cstring = "This is a String!";

NSString *astring = [[NSString alloc] initWithCString:Cstring];

NSLog(@"astring:%@",astring);

[astring release];

5、创建格式化字符串:占位符（由一个%加一个字符组成）

int i = 1;

int j = 2;

NSString *astring = [[NSString alloc]

initWithString:[NSString stringWithFormat:@"%d.This is %i string!",i,j]];

NSLog(@"astring:%@",astring);

[astring release];

6、创建临时字符串

NSString *astring;

astring = [NSString stringWithCString:"This is a temporary string"];

NSLog(@"astring:%@",astring);

/*----------------从文件读取字符串:initWithContentsOfFile方法 ----------------*/

NSString *path = @"astring.text";

NSString *astring = [[NSString alloc] initWithContentsOfFile:path];

NSLog(@"astring:%@",astring);

[astring release];

/*----------------写字符串到文件:writeToFile方法 ----------------*/

NSString *astring = [[NSString alloc] initWithString:@"This is a String!"];

NSLog(@"astring:%@",astring);

NSString *path = @"astring.text";

[astring writeToFile: path atomically: YES];

[astring release];

/*---------------- 比较两个字符串----------------*/

用C比较:strcmp函数

char string1[] = "string!";

char string2[] = "string!";

if(strcmp(string1, string2) = = 0)

{

NSLog(@"1");

}

isEqualToString方法

NSString *astring01 = @"This is a String!";

NSString *astring02 = @"This is a String!";

BOOL result = [astring01 isEqualToString:astring02];

NSLog(@"result:%d",result);

compare方法(comparer返回的三种值)

NSString *astring01 = @"This is a String!";

NSString *astring02 = @"This is a String!";

BOOL result = [astring01 compare:astring02] = = NSOrderedSame;

NSLog(@"result:%d",result);

NSOrderedSame 判断两者内容是否相同

NSString *astring01 = @"This is a String!";

NSString *astring02 = @"this is a String!";

BOOL result = [astring01 compare:astring02] = = NSOrderedAscending;

NSLog(@"result:%d",result);

//NSOrderedAscending 判断两对象值的大小(按字母顺序进行比较，astring02大于astring01为真)

NSString *astring01 = @"this is a String!";

NSString *astring02 = @"This is a String!";

BOOL result = [astring01 compare:astring02] = = NSOrderedDescending;

NSLog(@"result:%d",result);

//NSOrderedDescending 判断两对象值的大小(按字母顺序进行比较，astring02小于astring01为真)

不考虑大小写比较字符串1

NSString *astring01 = @"this is a String!";

NSString *astring02 = @"This is a String!";

BOOL result = [astring01 caseInsensitiveCompare:astring02] = = NSOrderedSame;

NSLog(@"result:%d",result);

//NSOrderedDescending判断两对象值的大小(按字母顺序进行比较，astring02小于astring01为真)

不考虑大小写比较字符串2

NSString *astring01 = @"this is a String!";

NSString *astring02 = @"This is a String!";

BOOL result = [astring01 compare:astring02

options:NSCaseInsensitiveSearch | NSNumericSearch] = = NSOrderedSame;

NSLog(@"result:%d",result);

//NSCaseInsensitiveSearch:不区分大小写比较 NSLiteralSearch:进行完全比较，区分大小写 NSNumericSearch:比较字符串的字符个数，而不是字符值。

/*----------------改变字符串的大小写----------------*/

NSString *string1 = @"A String";

NSString *string2 = @"String";

NSLog(@"string1:%@",[string1 uppercaseString]);//大写

NSLog(@"string2:%@",[string2 lowercaseString]);//小写

NSLog(@"string2:%@",[string2 capitalizedString]);//首字母大小

/*----------------在串中搜索子串 ----------------*/

NSString *string1 = @"This is a string";

NSString *string2 = @"string";

NSRange range = [string1 rangeOfString:string2];

int location = range.location;

int leight = range.length;

NSString *astring = [[NSString alloc]

initWithString:[NSString stringWithFormat:@"Location:%i,Leight:%i"

,location,leight]];

NSLog(@"astring:%@",astring);

[astring release];

/*----------------抽取子串 ----------------*/

-substringToIndex: 从字符串的开头一直截取到指定的位置，但不包括该位置的字符

NSString *string1 = @"This is a string";

NSString *string2 = [string1 substringToIndex:3];

NSLog(@"string2:%@",string2);

-substringFromIndex: 以指定位置开始（包括指定位置的字符），并包括之后的全部字符

NSString *string1 = @"This is a string";

NSString *string2 = [string1 substringFromIndex:3];

NSLog(@"string2:%@",string2);

-substringWithRange: //按照所给出的位置，长度，任意地从字符串中截取子串

NSString *string1 = @"This is a string";

NSString *string2 = [string1 substringWithRange:NSMakeRange(0, 4)];

NSLog(@"string2:%@",string2);

const char *fieldValue = [value cStringUsingEncoding:NSUTF8StringEncoding];

const char *fieldValue = [value UTF8String];

NSString 转 NSData

NSString* str= @"kilonet";

NSData* data=[str dataUsingEncoding:NSUTF8StringEncoding];

Date format用法：

-(NSString *) getDay:(NSDate *) d

{

NSString *s ;

NSDateFormatter *format = [[NSDateFormatter alloc] init];

[format setDateFormat:@"YYYY/MM/dd hh:mm:ss"];

s = [format stringFromDate:d];

[format release];

return s;

}

各地时区获取：

NSDate *nowDate = [NSDate new];

NSDateFormatter *formatter = [[NSDateFormatter alloc] init];

[formatter setDateFormat:@"yyyy/MM/dd HH:mm:ss"];

// 根据时区名字获取当前时间，如果该时区不存在，默认获取系统当前时区的时间

// NSTimeZone* timeZone = [NSTimeZone timeZoneWithName:@"Europe/Andorra"];

// [formatter setTimeZone:timeZone];

//获取所有的时区名字

NSArray *array = [NSTimeZone knownTimeZoneNames];

// NSLog(@"array:%@",array);

//for循环

// for(int i=0;i<[array count];i++)

// {

// NSTimeZone* timeZone = [NSTimeZone timeZoneWithName:[array objectAtIndex:i]];

// [formatter setTimeZone:timeZone];

// NSString *locationTime = [formatter stringFromDate:nowDate];

// NSLog(@"时区名字:%@ : 时区当前时间: %@",[array objectAtIndex:i],locationTime);

// //NSLog(@"timezone name is:%@",[array objectAtIndex:i]);

// }

//快速枚举法

for(NSString *timeZoneName in array){

[formatter setTimeZone:[NSTimeZone timeZoneWithName:timeZoneName]];

NSLog(@"%@,%@",timeZoneName,[formatter stringFromDate:nowDate]);

}

[formatter release];

[nowDate release];

NSCalendar用法：

-(NSString *) getWeek:(NSDate *) d {

NSCalendar *calendar = [[NSCalendar alloc] initWithCalendarIdentifier:NSGregorianCalendar];

unsigned units = NSYearCalendarUnit | NSMonthCalendarUnit | NSDayCalendarUnit | NSWeekdayCalendarUnit;

NSDateComponents *components = [calendar components:units fromDate:d];

[calendar release];

switch ([components weekday]) {

case 2:

return @"Monday";

break;

case 3:

return @"Tuesday";

break;

case 4:

return @"Wednesday";

break;

case 5:

return @"Thursday";

break;

case 6:

return @"Friday";

break;

case 7:

return @"Saturday";

break;

case 1:

return @"Sunday";

break;

default:

return @"No Week";

break;

}

// 用components，我们可以读取其他更多的数据。

}

4. 用Get方式读取网络数据：

将网络数读取为字符串

- (NSString *) getDataByURL:(NSString *) url {

return [[NSString alloc] initWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:[url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]]] encoding:NSUTF8StringEncoding];

}

//读取网络图片

- (UIImage *) getImageByURL:(NSString *) url {

return [[UIImage alloc] initWithData:[NSData dataWithContentsOfURL:[NSURL URLWithString:[url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding]]]];

}

多线程

[NSThread detachNewThreadSelector:@selector(scheduleTask) toTarget:self withObject:nil];

-(void) scheduleTask {

//create a pool

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

//release the pool;

[pool release];

}

//如果有参数，则这么使用：

[NSThread detachNewThreadSelector:@selector(scheduleTask:) toTarget:self withObject:[NSDate date]];

-(void) scheduleTask:(NSDate *) mdate {

//create a pool

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

//release the pool;

[pool release];

}

//注意selector里有冒号。

//在线程里运行主线程里的方法

[self performSelectorOnMainThread:@selector(moveToMain) withObject:nil waitUntilDone:FALSE];

6. 定时器NSTimer用法:

代码

// 一个可以自动关闭的Alert窗口

UIAlertView *alert = [[UIAlertView alloc] initWithTitle:nil

message:[@"一个可以自动关闭的Alert窗口"

delegate:nil

cancelButtonTitle:nil //NSLocalizedString(@"OK", @"OK") //取消任何按钮

otherButtonTitles:nil];

//[alert setBounds:CGRectMake

(alert.bounds.origin.x, alert.bounds.origin.y,

alert.bounds.size.width, alert.bounds.size.height+30.0)];

[alert show];

UIActivityIndicatorView *indicator = [[UIActivityIndicatorView alloc] initWithActivityIndicatorStyle:UIActivityIndicatorViewStyleWhiteLarge];

// Adjust the indicator so it is up a few pixels from the bottom of the alert

indicator.center = CGPointMake(alert.bounds.size.width/2, alert.bounds.size.height-40.0);

[indicator startAnimating];

[alert insertSubview:indicator atIndex:0];

[indicator release];

[NSTimer scheduledTimerWithTimeInterval:3.0f

target:self

selector:@selector(dismissAlert:)

userInfo:[NSDictionary dictionaryWithObjectsAndKeys:alert,

@"alert", @"testing ", @"key" ,nil] //如果不用传递参数，那么可以将此项设置为nil.

repeats:NO];

NSLog(@"release alert");

[alert release];

-(void) dismissAlert:(NSTimer *)timer{

NSLog(@"release timer");

NSLog([[timer userInfo] objectForKey:@"key"]);

UIAlertView *alert = [[timer userInfo] objectForKey:@"alert"];

[alert dismissWithClickedButtonIndex:0 animated:YES];

}

定时器停止使用：

[timer invalidate];

timer = nil;

7. 用户缺省值NSUserDefaults读取：

//得到用户缺省值

NSUserDefaults *defs = [NSUserDefaults standardUserDefaults];

//在缺省值中找到AppleLanguages, 返回值是一个数组

NSArray* languages = [defs objectForKey:@"AppleLanguages"];

NSLog(@"all language语言 is %@", languages);

//在得到的数组中的第一个项就是用户的首选语言了

NSLog(@"首选语言 is %@",[languages objectAtIndex:0]);

//get the language & country code

NSLocale *currentLocale = [NSLocale currentLocale];

NSLog(@"Language Code is %@", [currentLocale objectForKey:NSLocaleLanguageCode]);

NSLog(@"Country Code is %@", [currentLocale objectForKey:NSLocaleCountryCode

8. View之间切换的动态效果设置：

SettingsController *settings = [[SettingsController alloc]initWithNibName:@"SettingsView" bundle:nil];

settings.modalTransitionStyle = UIModalTransitionStyleFlipHorizontal; //水平翻转

[self presentModalViewController:settings animated:YES];

[settings release];

9.NSScrollView 滑动用法：

-(void) scrollViewDidScroll:(UIScrollView *)scrollView{

NSLog(@"正在滑动中...");

}

//用户直接滑动NSScrollView，可以看到滑动条

-(void) scrollViewDidEndDecelerating:(UIScrollView *)scrollView {

}

// 通过其他控件触发NSScrollView滑动，看不到滑动条

- (void) scrollViewDidEndScrollingAnimation:(UIScrollView *)scrollView {

}

11.键盘处理系列

//set the UIKeyboard to switch to a different text field when you press return

//switch textField to the name of your textfield

[textField becomeFirstResponder];

srandom(time(NULL)); //随机数种子

id d = random(); // 随机数

4. iPhone的系统目录:

//得到Document目录：

NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);

NSString *documentsDirectory = [paths objectAtIndex:0];

//得到temp临时目录：

NSString *tempPath = NSTemporaryDirectory();

//得到目录上的文件地址：

NSString *文件地址 = [目录地址 stringByAppendingPathComponent:@"文件名.扩展名"];

5. 状态栏显示Indicator：

[UIApplication sharedApplication].networkActivityIndicatorVisible = YES;

6.app Icon显示数字：

- (void)applicationDidEnterBackground:(UIApplication *)application{

[[UIApplication sharedApplication] setApplicationIconBadgeNumber:5];

}

7.sqlite保存地址：

代码

NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);

NSString *thePath = [paths objectAtIndex:0];

NSString *filePath = [thePath stringByAppendingPathComponent:@"kilonet1.sqlite"];

NSString *dbPath = [[[NSBundle mainBundle] resourcePath]

stringByAppendingPathComponent:@"kilonet2.sqlite"];

8.Application退出：exit(0);

9. AlertView，ActionSheet的cancelButton点击事件：

代码

-(void) actionSheet :(UIActionSheet *) actionSheet didDismissWithButtonIndex:(NSInteger) buttonIndex {

NSLog(@"cancel actionSheet........");

//当用户按下cancel按钮

if( buttonIndex == [actionSheet cancelButtonIndex]) {

exit(0);

}

// //当用户按下destructive按钮

// if( buttonIndex == [actionSheet destructiveButtonIndex]) {

// // DoSomething here.

// }

}

- (void)alertView:(UIAlertView *)alertView willDismissWithButtonIndex:(NSInteger)buttonIndex {

NSLog(@"cancel alertView........");

if (buttonIndex == [alertView cancelButtonIndex]) {

exit(0);

}

10.给Window设置全局的背景图片：

window.backgroundColor = [UIColor colorWithPatternImage:[UIImage imageNamed:@"coolblack.png"]];

11. UITextField文本框显示及对键盘的控制:

代码

#pragma mark -

#pragma mark UITextFieldDelegate

//控制键盘跳转

- (BOOL)textFieldShouldReturn:(UITextField *)textField {

if (textField == _txtAccount) {

if ([_txtAccount.text length]==0) {

return NO;

}

[_txtPassword becomeFirstResponder];

} else if (textField == _txtPassword) {

[_txtPassword resignFirstResponder];

}

return YES;

}

//输入框背景更换

-(BOOL) textFieldShouldBeginEditing:(UITextField *)textField{

[textField setBackground:[UIImage imageNamed:@"ctext_field_02.png"]];

return YES;

}

-(void) textFieldDidEndEditing:(UITextField *)textField{

[textField setBackground:[UIImage imageNamed:@"ctext_field_01.png"]];

}

12.UITextField文本框前面空白宽度设置以及后面组合按钮设置：

代码

//给文本输入框后面加入空白

_txtAccount.rightView = _btnDropDown;

_txtAccount.rightViewMode = UITextFieldViewModeAlways;

//给文本输入框前面加入空白

CGRect frame = [_txtAccount frame];

frame.size.width = 5;

UIView *leftview = [[UIView alloc] initWithFrame:frame];

_txtAccount.leftViewMode = UITextFieldViewModeAlways;

_txtAccount.leftView = leftview;

13. UIScrollView 设置滑动不超出本身范围：

[fcScrollView setBounces:NO];

14. 在drawRect里画文字：

UIFont * f = [UIFont systemFontOfSize:20];

[[UIColor darkGrayColor] set];

NSString * text = @"hi \nKiloNet";

[text drawAtPoint:CGPointMake(center.x,center.y) withFont:f];

15. NSArray查找是否存在对象时用indexOfObject,如果不存在则返回为NSNotFound.

16. NString与NSArray之间相互转换：

array = [string componentsSeparatedByString:@","];

string = [[array valueForKey:@"description"] componentsJoinedByString:@","];

17. TabController随意切换tab bar：

[self.tabBarController setSelectedIndex:tabIndex];

或者 self.tabBarController.selectedIndex = tabIndex;

或者实现下面的delegate来扑捉tab bar的事件：

代码-(BOOL) tabBarController:(UITabBarController *)tabBarController

shouldSelectViewController:(UIViewController *)viewController

{ if ([viewController.tabBarItem.title isEqualToString: NSLocalizedString(@"Logout",nil)])

{ [self showLogout]; return NO; } return YES;}

18. 自定义View之间切换动画：

代码

- (void) pushController: (UIViewController*) controller

withTransition: (UIViewAnimationTransition) transition

{

[UIView beginAnimations:nil context:NULL];

[self pushViewController:controller animated:NO];

[UIView setAnimationDuration:.5];

[UIView setAnimationBeginsFromCurrentState:YES];

[UIView setAnimationTransition:transition forView:self.view cache:YES];

[UIView commitAnimations];

}

CATransition *transition = [CATransition animation];

transition.duration = kAnimationDuration;

transition.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut];

transition.type = kCATransitionPush;

transition.subtype = kCATransitionFromTop;

transitioning = YES;

transition.delegate = self;

[self.navigationController.view.layer addAnimation:transition forKey:nil];

self.navigationController.navigationBarHidden = NO;

[self.navigationController pushViewController:tableViewController animated:YES];

20.计算字符串长度：

CGFloat w = [title sizeWithFont:[UIFont fontWithName:@"Arial" size:18]].width;

23.在使用UISearchBar时，将背景色设定为clearColor，或者将translucent设为YES，都不能使背景透明，经过一番研究，发现了一种超级简单和实用的方法：

[[searchbar.subviews objectAtIndex:0]removeFromSuperview];

背景完全消除了，只剩下搜索框本身了。

24. 图像与缓存 :

UIImageView *wallpaper = [[UIImageView alloc] initWithImage:

[UIImage imageNamed:@"icon.png"]]; // 会缓存图片

UIImageView *wallpaper = [[UIImageView alloc] initWithImage:

[UIImage imageWithContentsOfFile:@"icon.png"]]; // 不会缓存图片

25. iphone-常用的对视图图层(layer)的操作

对图层的操作：

(1.给图层添加背景图片：

myView.layer.contents = (id)[UIImage imageNamed:@"view_BG.png"].CGImage;

(2.将图层的边框设置为圆脚

myWebView.layer.cornerRadius = 8;

myWebView.layer.masksToBounds = YES;

(3.给图层添加一个有色边框

myWebView.layer.borderWidth = 5;

myWebView.layer.borderColor = [[UIColor colorWithRed:0.52 green:0.09 blue:0.07 alpha:1] CGColor];

source: http://www.codeios.com/forum.php?mod=viewthread&tid=98&page=1

關於.NET Framework / ASP.NET這條路

2011-04-22T10:59:00.000-07:00

.NET Framework歷史版本及功能，第6點是我自己整理。
.NET Framework 1.0
.NET Framework 1.1
.NET Framework 2.0
CLR + Windows forms + Web Services + ASP.NET
.NET Framework 3.0
.NET Framework 2.0 + WCF + WF + WPF + CardSpace
.NET Framework 3.5
.NET Framework 3.0 + LINQ + AJAX + REST
.NET Framework 4.0
.NET Framework 3.5 + Entity Framework + ASP.NET MVC + Parallel
先說結論，再說故事。

結論
通常第一版都是實驗性質或有很大的改進空間，不管是多好的東西都一樣。從第二版開始，似乎是個不錯的開始。

故事1--.NET Framework 2.0

現在的資訊爆炸，但這些資訊你可以不看。但就資訊技術人員而言，技術更新的速度才是一大挑戰，以前一個技術能讓你十年有飯吃，現在一個技術能讓你三年有飯吃就很不錯了，技術更新的速度讓人「怕怕的」，我實在很敬佩那些永遠走在資訊前端的前輩，有著過人的領悟力與學習力。

話說從前，我是學習Visual Basic 6與ASP，為什學這兩樣？也沒有什麼特別的原因，學校教什麼，我們就學什麼，而且從Visual Basic 6接ASP(VB Script)還很順，所以在使用ASP上還算順手。

後來，微軟登高一呼：「我們要進入.NET的世界！」然後推出了.NET Framework 1.0，那時的ASP由2.0到3.0，ASP 3.0之後微軟也很明確表示，ASP不再更新維護了，因為微軟要全力推「.NET」這個…產品嗎？概念嗎？程式語言嗎？反正那時候認為是新一代的ASP就是了。

我還很認真的去買書來看，結果一個月後我就放棄了，那ASP.NET 1.0是什麼鬼東西，看不懂，結果我又回到ASP的身邊，反正工作上也只用的到ASP，會不會ASP.NET也不影響工作。

一段時間又過去了，突然發現，怎麼大家又在推「ASP.NET 2.0」，而且這一次好像又不一樣了，Survey之後發現，.NET Framework 2.0是個全新的改版，不同於.NET Framework 1.0 / 1.1，而且微軟似乎也發現開發人員的辛苦，承諾未來的改版會使用「積木式」方式來改版，就是說，你學了.NET Framework 2.0的東西，拿到.NET Framework 3.0 / 3.5 / 4.0上一樣都可以使用，讓你不會天天做打掉重練的工作。就是這一點，讓我試著相信它，開始學習著ASP.NET 2.0。

另外在.NET Framework 2.0還有一項重要事，那就是開發工具的完備，那是在.NET Framework 1.0 / 1.1所沒有的。在.NET Framework 2.0有Visual Studio 2005 / 2008兩個版本，我學ASP.NET 2.0時已經是Visual Studio 2008版本，就Visual Studio 2008來開發ASP.NET 2.0而言，還蠻快樂的。

[Key Point 1].NET Framework → .NET Framework 2.0

故事2--LINQ to SQL

時間飛快，在學習.NET Framework 2.0不久，.NET Framwork 3.0推出，3.0還沒有什麼感覺，又不久之後，馬上再推出.NET Framework 3.5，這個3.5版的推出又是一個高潮，因為它提供了幾個重要的元素「LINQ + AJAX + REST」，其中最紅的就是LINQ(Language-Integrated Query)，LINQ是個統稱，內容幾項重要的技術內容LINQ to Object、LINQ to ADO.NET(LINQ to DataSet、LINQ to SQL)、LINQ to XML、LINQ to Entities。

如果有學LINQ，我相信其中的LINQ to SQL會是你的一項主力。不過，就在2008一篇「Update on LINQ to SQL and LINQ to Entities Roadmap」的微軟官方文章，給所有有學LINQ to SQL的人一顆炸彈，他們的一句「他們會很認真的聽取 LINQ to SQL 社群的聲音，然後好好的來加強我們的 Entity Framework 產品」嚇死了一堆人。

很明顯，他們將主力放在Entity Framework上面(可看成LINQ to Entities這一項)，那LINQ to SQL呢？在.NET Framework 4.0有做一些錯誤修正，但請注意，他們已經很明顯未來會不斷加強的是Entity Framework，目前在.NET Framework 4.0裡的是Entity Framework 4.0，現在已經有Entity Framework 4.1版本可以下載安裝使用。

[Key Point 2] LINQ to SQL → LINQ to Entities → Entity Famework

故事3--Web Service

在ASP.NET 2.0時，提供了一個很棒的Web Services服務，也就是說，我可以把相關Function透過伺服器分享出來，分享給網路上其他需要的人使用。使用者只要引用我的Web Services，就可以立即擁有我所提供的服務。

Web Services好是好，但也是有一些問題，所以Microsoft在.NET Framework 3.5又提出了一個 REST，董大偉老師有篇介紹 REST 文章，可以知一二。

[Key Point 3] Web Service → REST

故事4-- ASP.NET MVC 2.0

在Visual Studio 2008 + .NET Framework 3.5時，微軟還推出了一個很重要的Web技術，即ASP.NET MVC 1.0，老實說，ASP.NET MVC 1.0我連碰都沒碰過，但我碰了ASP.NET MVC 2.0。ASP.NET MVC 2.0對我而言，感覺又回到寫ASP，再強調一下，是「感覺」，不是「回到寫ASP」，什麼感覺，是一種「操之在我」的感覺，但靈活度是ASP及ASP.NET完全比不上的感覺。

ASP.NET Web Form入門而言，實在好學好用，但當你要深入一些時，會發現就沒那怎容易，當你想把你的魔手伸的越深入，你就會發現Web Form的控制項越複雜。但一切一切問題在ASP.NET MVC身上都沒有，因為它根本沒有控制項！

不過想要學習、使用ASP.NET MVC，就我個人認為，不是件簡單的事，因為有許多觀念必須先行建立，物件導向程式設計、Visual Basic 9/10語法熟悉度、LINQ、.NET Framework Class…這些都會了，再學習ASP.NET MVC會比較輕鬆，不然走一步算一步是比較辛苦點。

最近，ASP.NET MVC 3又正式推出，在ASP.NET MVC 3裡有一個重點Razor View Engine，Razor是一個新的View Engine，在我們撰寫ASP.NET MVC 3時，它提供了更簡潔的語法。不過馬上就有人指出，使用Razor怪怪的，因為它會破壞MVC的規則，將Controller的內容放到View裡。但Razor也讓我們在撰寫View提供了很好的規範，不會整個畫面裡都是<% ~ %>的符號。

Razor最早是與另一套微軟免費入門網頁開發軟體WebMatrix所採用，後來可能覺的很不錯，所以在ASP.NET MVC 3.0也加入了Razor的支援。所以到了ASP.NET MVC 3.0你可以選擇使用<% ~ %>的Visual Basic語法，也可以使用Razor的@Code ~ End Code或@ViewData()之類的語法。

[Key Point 4] ASP.NET MVC 1.0 → ASP.NET MVC 2.0 / 3.0, Razor View Engine

整理一下Key Point

[Key Point 1] .NET Framework 1.0 → .NET Framework 2.0
[Key Point 2] LINQ to SQL → LINQ to Entities
[Key Point 3] Web Services → REST
[Key Point 4] Web Form → ASP.NET MVC
每個技術背景都有故事，在.NET Framework的裡的每個進步，都是為了解決一些前一代的一些問題或提供更好的解決方案。我們不能怪微軟說，為什麼說放就放，說改就改，而是要去思考及了解前因後果，當然不是每件事的回答或解釋都讓開發人員滿意。

由以上來看，.NET Framework到目前為止，所推出的第一代技術都會被第二代技術替代，其實這是必然的結果，只是改的太兇，苦的是這是程式開發人員。但我們在每一項新技術推出之時，每篇文章、專欄、ABC大會、XYZ研討會…你都只會聽到「優點」，但我在意的是「缺點」呢？例如，這一篇「對Entity Framework Performance 抱怨以及建議」，說明Entity Framework 1.0版實在不怎麼樣，但現在的Entity Framework 4.0到是沒聽到這種聲音了，原因前提過了，Entity Framework是現在的主力。而缺點，通常會在一段時間，實際使用於專案上之後，才會出現。

如果你現在才要進入.NET Framework的世界，我個人是建議，如果是那種「最新」的技術，有精力再去研究，如果是第二版之後改進的技術，通常是可以上場見世面了。了解每一項技術所提供的優點及缺點，所以當我聽完優點後，會靜一靜，等等看市場上有沒有其他聲音。以上是我個人就我在.NET Framework/ASP.NET的學習上的驗經談。我的時間、精力有限，所以在.NET Framework/ASP.NET這條路，我是選擇走「老二哲學」。

source: http://kkbruce.blogspot.com/2011/04/net-framework-aspnet.html?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+KingkongBruce+%28KingKong+Bruce%E8%A8%98%E4%BA%8B%29&utm_content=Google+Reader

Moving SQL NVarchar to ORACLE NVarchar2

2011-02-25T00:01:00.000-08:00

之前用SSIS在做ORACLE與SQL間資料搬移時，最痛恨遇到NVarchar跟Unicode Code問題了。

明明是NVarchar(SQL)搬到NVarchar2(ORACLE)，兩邊都Support Unicode，但SSIS都老會要求指定Data Flow Destination的Code Page，接著又會嚷著SQL中得到的Unicode不能直接轉成Non-Unicode，所以就得很可笑地在Nvarchar與NVarchar2兩個Unicode欄位中加上一個Data Conversion。如下圖:

不過，苦難還沒有結束... 如果很不幸地，NVarchar中還真的放了Unicode字元，則在轉換時，會出現以下的錯誤訊息。

Error: 0xC02020C5 at Data Flow Task Failure Sample, Data Conversion [543]: Data conversion failed while converting column "UnicodeField" (505) to column "UnicodeFieldMapping" (557). The conversion returned status value 4 and status text "Text was truncated or one or more characters had no match in the target code page.".
Error: 0xC020902A at Data Flow Task Failure Sample, Data Conversion [543]: The "output column "UnicodeFieldMapping" (557)" failed because truncation occurred, and the truncation row disposition on "output column "UnicodeFieldMapping" (557)" specifies failure on truncation. A truncation error occurred on the specified object of the specified component.

這問題讓我很困擾，不過因為遇到時都是做些一次性的資料搬移，所以我都很鄉愿地繞路解決(最愛用的一招是回去改用SQL 2000 DTS，很奇怪，用DTS搬資料時，幾乎不曾為Enocding傷過腦筋)，未曾認真與它對決過。

最近同事想用SSIS來做重要的日常資料搬移，就卡在這個問題上，由於搬移是每天要跑的，繞路的成本就會高出許多，這回我總算被迫要收服這隻妖怪。東試西試之餘，忽然想到之前使用Query Express的經驗，Oracle的OLE DB Driver才能正確顯示Unicode，Microsft的OLE DB for Oracle反而不行，所以我試著把Data Flow Destination的OLE DB換成Oracle版。

美妙的事出現了!! 使用Oracle Provider for OLE DB後，連Data Conversion都不用了，直接對Unicode對Unicode，一次搞定。

看一下令人興奮的結果，SQL裡的六頭牛被搬到ORACLE裡了，NVarchar --> NVarchar2，萬牛奔騰的感覺豈是一個爽字可以形容，哈!!

source: http://blog.darkthread.net/post-2007-05-17-kb-ssis-moving-sql-nvarchar-to-oracle-nvarchar2.aspx

Google App Engine for Java下的URL編碼轉換問題

2011-02-19T06:53:00.000-08:00

URL编码问题

此部分参考英文资料：

在HTTP客户端使用get方法通过URL向服务器发送参数里，由于URL里面只可以包含允许的字符（也称为合法字符），所以一旦参数里面存在非法字符，就必须通过某种手段对其进行合法化转换，在服务器端再将其转换回来，

在RFC1738：Uniform Resource Locators (URL) 规范中，指出URL只能包含AscII集中的一个子集中的字符，这个子集也称作AscII character-set，原文写道：

"...Only alphanumerics [0-9a-zA-Z], the special characters "$-_.+!*'()," [not including the quotes - ed], and reserved characters used for their reserved purposes may be used unencoded within a URL."

实际上URL规范中，字符包括保留字符，非保留字符两种，RFC2396中定义了URL中的保留(reserved)字符为：

Reserved

reserved = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |

"$" | ","

非保留字符为：

Unreserved

unreserved = alphanum | mark

mark = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"

实际上非保留字符就是AscII character-set，此集合之外的字符都被称为非法字符（invalid character)或不安全字符(unsafe character)，这些字符都将被编码转换为合法字符(valid character)或叫安全字符(safe charactor)，转换的动作在英文常表示为escape。

escape的方式如下规范中所述：

Escaped Encoding

An escaped octet is encoded as a character triplet, consisting of the

percent character "%" followed by the two hexadecimal digits

representing the octet code. For example, "%20" is the escaped

encoding for the US-ASCII space character.

escaped = "%" hex hex

hex = digit | "A" | "B" | "C" | "D" | "E" | "F" |

"a" | "b" | "c" | "d" | "e" | "f"

转换时使用的字符集为ISO-8859-1也称为ISO-Latin或Latin-1，注意不是Unicode，这就引起了新的问题，对于不在ISO-Latin中的符号，就没有一个安全的途径进行编码，因为根据RFC2396（注意这是URI规范，但是对URL适用，因为URL是URI的子集，有兴趣的读者请查阅URL和URI之间的关系），URL里还无法指定自定义的字符集(比如UTF-8)。

虽然根据标准，在URL中我们无法使用非ISO-Latin字符集以外的字符，但是在现实中，为了解决实际问题，大家都有事实上的标准那就是Unicode编码，现行的为UTF-8，现在浏览器都支持UTF-8的URL编码转换，当然，这个时候的转换动作不再叫escape，而是称为URIEncode。另外，UTF-8与Latin-1是兼容的，相关的信息可参考：

PHP与Javascript相关的URIEncode操作请参见：http://blog.verymore.com/show-989-1.html

GWT的URL编码与解码

使用URL类中的静态方法URL.decode 和 URL.encode来进行。

java.lang.Object

com.google.gwt.http.client.URL

Method Summary
static java.lang.String	decode(java.lang.String encodedURL) Returns a string where all URL escape sequences have been converted back to their original character representations.
static java.lang.String	decodeComponent(java.lang.String encodedURLComponent) Returns a string where all URL component escape sequences have been converted back to their original character representations.
static java.lang.String	encode(java.lang.String decodedURL) Returns a string where all characters that are not valid for a complete URL have been escaped.
static java.lang.String	encodeComponent(java.lang.String decodedURLComponent) Returns a string where all characters that are not valid for a URL component have been escaped.

GAE4Java的编码与解码

实际上，由于写本文的初衷是作者在这个环境下开发程序时想理清这个问题，所以将服务器环境定位为GAE，实际上就是Java下的URL编码问题，可以参考：http://china.manufacturer.com/article/study_for_character_encoding_java.htm。

Java中URI Encoding的相关类为URLEncoder，URLDecoder

示例：

1 String text = java.net.URLEncoder.encode("编码转换", "utf-8");

java.lang.Object
java.net.URLEncoder

Method Summary

static String

encode(String s, String enc)

使用指定的编码机制将字符串转换为 application/x-www-form-urlencoded 格式。

URLDecoder此处略去，同上。

【完】

source:

http://www.cnblogs.com/dengfanxin/archive/2009/04/16/GAE_UrlEncoding.html

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

2011-02-15T19:01:00.000-08:00

以前的房产地图一直都是使用有道地图，虽然有道地图是很好，但是为了更好，还是决定使用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);
searchMap(point,keyWord);
}

function searchMap(point,keyWord){
var searcher = new google.search.LocalSearch();
searcher.setCenterPoint(point);
searcher.setResultSetSize(8);
//searcher.setRestriction(google.search.Search.RESTRICT_TYPE, google.search.LocalSearch.TYPE_KMLONLY_RESULTS)
searcher.setSearchCompleteCallback(this, function() {
parent.MapApi.showSearch_Markers(searcher.results,keyWord);
});
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等继续封装。

source: http://www.blogjava.net/dongbule/archive/2011/02/12/344141.html

Oracle migrate to MySQL

2011-01-11T18:25:00.000-08:00

一、從Oracle移植到MySQL主要有六個方面的內容需要移植，一是表Table，包括表結構和數據，二是觸發器Trigger，三是存儲過程Procedure，函數function和包Package，四是任務Job ，五是用戶等其他方面的移植，六是具體應用程序通過SQL語句訪問時的細節差異克服。筆者用來移植測試的數據庫是：Oracle 9i ，MySQL 6.0，Windows 2000環境。

二、經過映射轉換，比如number會轉換為double，date轉換為timestamp等，請小心處理日期字段的默認值等，表的主鍵，表的索引(Oracle的位圖索引會被轉成BTree索引，另外表和字段的註釋會丟失)等信息。需要特別注意的是，Oracle的自增字段的處理。提供字段自增屬性。
三、觸發器的移植首先，MySQL在6.0以後才支持觸發器！觸發器的移植沒有現成工具，因為兩者之間的語法差異較大，您只能通過手工對照著原來的邏輯一個一個添加。
四、存儲過程，函數和程序包的移植程序包是Oracle用來組織邏輯功能的一個Object，MySQL不支持，因此需要將包裡的存儲過程﹑函數等全部放到該數據庫公有過程和函數里面。

五、Job的移植Job是Oracle的定時任務實現的方法，MySQL6中用Event實現，具體語法請參考MySQL手冊。

六、用戶的移植Oracle的用戶管理和MySQL下有較大區別，請分別建立用戶，並賦予合適的權限。

七、應用程序的移植由於語法細節上的差異，導致很多SQL語句需要改寫。筆者記下了所有移植過程中碰到的SQL語句細節差異,列出來以供參考：
1）Oracle的to_char函數不能再使用，換用如CONCAT(14.3)的形式，為了提高應用程序兼容性，建議手工寫一個
2）Oracle的to_date函數不能再使用，建議手工寫一個添加到MySQL數據庫
eg:
to_char(sysdate,'yyyy-mm-dd')-->date_format(sysdate(),'%Y-%m-%d');
to_date(sysdate,'yyyy-mm-dd')-->STR_TO_DATE(sysdate(),'%Y-%m-%d');
to_char(add_months(to_date ('20000101','yyyymmdd'),1),'yyyy-mm-dd')-->date_add('2000-01-01',interval 1 month);

3）Oracle的decode函數不能再使用，換用SELECT CASE 1 WHEN 1 THEN 'one' WHEN 2 THEN 'two' ELSE 'more' END 的形式
4)nvl這樣的一些專用函數，MySQL是沒有的，可以把select nvl(to_char(num),'nothing') from t_equipment轉換成select case num when num then num else 'nothing' end from t_equipment
5）instr之類的函數，函數名相同，但參數個數不同
6）Oracle的sysdate要寫成sysdate()的形式
7）包的形式已經取消，所以原來以包的方式調用的過程如xx_pack.xxx要寫成xxx()
8）帶進製字符轉數字Oracle風格：TO_NUMBER(strTmp,'XX') TO_NUMBER（'9'）MySQL風格：CONV(strTmp,16,10) CONV('9',10,10) 如果字符串前後有加減操作，會隱含轉換成數字
9) 不能再有直接調用序列的形式，如果一定需要，可以模擬實現一個
10）日期直接加減的含義不同了，比如Oracle中sysdate + 1 變成了sysdate() + interval 1 day（注意如果寫成sysdate() + 1 語法還是正確的，但含義是錯誤的）查詢select sysdate() + 1 from dual 在MySQL得到比如20080223153234（= 20080223153233 + 1）的數而在Oracle中會得到第二天當前時刻。
11) MySQL單純的date類型只是日期不帶時間，DATETIME或TIMESTAMP帶有時間，用DATE_FORMAT函數可以控制顯示形式
12）select 'abc' || 'd' from dual 兩個數據執行的結果不同（語法都能通過），MySQL要寫成select concat('abc' , 'd')的形式
13) Oracle高級功能，如帶有暗示索引的select語句，MySQL是不支持的（語法可以通過）
14）有些MySQL的保留字不能直接用在SQL語句裡,要加表名或別名限制，如select RIGHT FROM XX要改成select a.RIGHT FROM XX a
15) Oracle的子查詢可以不起別名，但MySQL是必須的，比如下面的別名aa：select field1 from (select sysdate() as field1 from dual) as aa
16）很多系統表名都是不同的,比如，列出某個表的信息：select * from tab where TName='T_TEST'改成select table_name,table_type from information_schema.tables where table_schema = 'user' and table_name= ' T_TEST '
17）MySQL下update時不能有本身的子查詢update T_TEST set Flag = 0 where field1 in
(select distinct b.field1 from T_TEST b where b.flag=1)
18）Oracle下''和null等價，而MySQL則不然select 1 from dual where '' is null在Oracle下可以取到記錄，在MySQL下不能dual表的使用，substr、trim等函數的主要使用方式和Oracle類似

八、小結和建議看起來，Oracle移植到MySQL似乎挺麻煩，有沒有一鍵完成的簡單辦法？呵呵，我沒有找到，除非您只使用基本表，只使用基本SQL語句訪問它。

source: http://shshy39.javaeye.com/blog/342512

ORA-00031: session marked for kill 處理Oracle中殺不掉的鎖

2011-01-06T18:47:00.000-08:00

一些ORACLE中的進程被殺掉後，狀態被置為"killed"，但是鎖定的資源很長時間不釋放，有時實在沒辦法，只好重啟數據庫。現在提供一種方法解決這種問題，那就是在ORACLE中殺不掉的，在OS一級再殺。

1.下面的語句用來查詢哪些對像被鎖：

select object_name,machine,s.sid,s.serial#
from v$locked_object l,dba_objects o ,v$session s
where l.object_id　=　o.object_id and l.session_id=s.sid;
2.下面的語句用來殺死一個進程：
alter system kill session '24,111'; (其中24,111分別是上面查詢出的sid,serial#)
【注】以上兩步，可以通過Oracle的管理控制台來執行。
3.如果利用上面的命令殺死一個進程後，進程狀態被置為"killed"，但是鎖定的資源很長時間沒有被釋放，那麼可以在os一級再殺死相應的進程（線程），首先執行下面的語句獲得進程（線程）號：
select p.spid, osuser, s.program
from v$session s,v$process p
where s.paddr=p.addr and s.sid=24 （24是上面的sid）
4.在OS上殺死這個進程（線程）：
1)在unix上，用root身份執行命令:
#kill -9 12345（即第3步查詢出的spid）
2)在windows（unix也適用）用orakill殺死線程，orakill是oracle提供的一個可執行命令，語法為：
orakill sid thread
其中：
sid：表示要殺死的進程屬於的實例名
thread：是要殺掉的線程號，即第3步查詢出的spid。
例：c:>orakill orcl 12345

ORA-00031: session marked for kill

Cause: The session specified in an ALTER SYSTEM KILL SESSION command cannot be killed immediately (because it is rolling back or blocked on a network operation), but it has been marked for kill. This means it will be killed as soon as possible after its current uninterruptible operation is done.
Action: No action is required for the session to be killed, but further executions of the ALTER SYSTEM KILL SESSION command on this session may cause the session to be killed sooner.

kill -9 12345

source: http://unixboy.javaeye.com/blog/168346
http://www.oracle-base.com/articles/misc/KillingOracleSessions.php

T-SQL While Loop

2011-01-05T00:06:00.000-08:00

declare @Part_Id int
declare @Category_Id int
declare @Desc varchar(50)
create table PART (Part_Id int, Category_Id int, Description varchar(50))
set @Part_Id = 0
set @Category_Id = 0
while @Part_Id < 2
begin
set @Part_Id = @Part_Id + 1
while @Category_Id < 3
begin
set @Category_Id = @Category_Id + 1
set @Desc = 'Part_Id is ' + cast(@Part_Id as char(1)) +
' Category_Id ' + cast(@Category_Id as char(1))
insert into PART values(@Part_Id,
@Category_Id,
@Desc )
end
set @Category_Id = 0
end
select * from PART
drop table PART
Here is the output from the SELECT statement at the bottom of this nested WHILE loop example.

Part_Id Category_Id Description
----------- ----------- -----------------------------------------
1 1 Part_Id is 1 Category_Id 1
1 2 Part_Id is 1 Category_Id 2
1 3 Part_Id is 1 Category_Id 3
2 1 Part_Id is 2 Category_Id 1
2 2 Part_Id is 2 Category_Id 2
2 3 Part_Id is 2 Category_Id 3

SQL Server日期函數CONVERT範例

2011-01-04T23:59:00.000-08:00

MS SQL Server中文版的預設日期datetime格式是yyyy-mm-dd hh:mm:ss.mmm

例如:
select getdate()

2011-01-05 11:06:08.177

SQL Server常用到日期格式轉換方式如下：

select CONVERT(varchar, getdate(), 120 )
2004-09-12 11:06:08

select replace(replace(replace(CONVERT(varchar, getdate(), 120 ),’-',”),’ ‘,”),’:',”)
20040912110608

select CONVERT(varchar(12) , getdate(), 111 )
2004/09/12

Text Convert to Datetime
SELECT convert(datetime, '09/02/2010', 103)
here 103->英國/法國標準

source: http://technet.microsoft.com/zh-tw/library/ms187928.aspx