Java – 第2页 – PHPor 的Blog

3,655

12月 062013

一、什么是嵌套类及内部类

可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：
其一、在一个类（外部类）中直接定义的内部类；
其二、在一个方法（外部类的方法）中定义的内部类；
其三、匿名内部类。

下面，我将说明这几种嵌套类的使用及注意事项。

二、静态嵌套类

如下所示代码为定义一个静态嵌套类，

public class StaticTest {   
        private static String name = "javaJohn";　          
　　private String id = "X001";  
　　static class Person{  
　　　　private String address = "swjtu,chenDu,China";  
　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员  
　　　　public void display(){  
　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员  
　　　　　　System.out.println(name);//只能直接访问外部类的静态成员  
　　　　　　System.out.println("Inner "+address);//访问本内部类成员。  
　　　　}  
　　}  

　　public void printInfo(){  
　　　　Person person = new Person();  
　　　　person.display();  
　　　　//System.out.println(mail);//不可访问  
　　　　//System.out.println(address);//不可访问  
　　　　System.out.println(person.address);//可以访问内部类的私有成员  
　　　　System.out.println(person.mail);//可以访问内部类的公有成员  

　　}  
　　public static void main(String[] args) {  
　　StaticTest staticTest = new StaticTest();  
　　staticTest.printInfo();  
}  
}

public class StaticTest {

private static String name = "javaJohn";　

　　private String id = "X001";

　　static class Person{

　　　　private String address = "swjtu,chenDu,China";

　　　　public String mail = "josserchai@yahoo.com";//内部类公有成员

　　　　public void display(){

　　　　　　//System.out.println(id);//不能直接访问外部类的非静态成员

　　　　　　System.out.println(name);//只能直接访问外部类的静态成员

　　　　　　System.out.println("Inner "+address);//访问本内部类成员。

　　　　}

　　public void printInfo(){

　　　　Person person = new Person();

　　　　person.display();

　　　　//System.out.println(mail);//不可访问

　　　　//System.out.println(address);//不可访问

　　　　System.out.println(person.address);//可以访问内部类的私有成员

　　　　System.out.println(person.mail);//可以访问内部类的公有成员

　　}

　　public static void main(String[] args) {

　　StaticTest staticTest = new StaticTest();

　　staticTest.printInfo();

}

在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中”静态方法不能直接访问非静态成员”所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。

三、在外部类中定义内部类

如下所示代码为在外部类中定义两个内部类及它们的调用关系：

public class Outer {   
         　　int outer_x = 100;  
　　　　class Inner{  
　　　　　　public int y = 10;  
　　　　　　private int z = 9;  
　　　　　　int m = 5;  
　　　　　　public void display(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　　　private void display2(){  
　　　　　　　　System.out.println("display outer_x:"+ outer_x);  
　　　　　　}  
　　　　}  
　　　　void test(){  
　　　　　　Inner inner = new Inner();  
　　　　　　inner.display();  
　　　　　　inner.display2();  
　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量  
　　　　　　System.out.println("Inner y:" + inner.y);//可以访问  
　　　　　　System.out.println("Inner z:" + inner.z);//可以访问  
　　　　　　System.out.println("Inner m:" + inner.m);//可以访问  
　　　　　　InnerTwo innerTwo = new InnerTwo();  
　　　　　　innerTwo.show();  
　　　　}  
　　　　class InnerTwo{  
　　　　　　Inner innerx = new Inner();  
　　　　　　public void show(){  
　　　　　　　　//System.out.println(y);//不可访问Innter的y成员  
　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法  
　　　　　　　　innerx.display();//可以访问  
　　　　　　　　innerx.display2();//可以访问  
　　　　　　　　System.out.println(innerx.y);//可以访问  
　　　　　　　　System.out.println(innerx.z);//可以访问  
　　　　　　　　System.out.println(innerx.m);//可以访问  
　　　　　　}  
　　　　}  
　　　　public static void main(String args[]){  
　　　　　　Outer outer = new Outer();  
　　　　　　outer.test();  
　　　　}  
　　} 
}

public class Outer {

　　int outer_x = 100;

　　　　class Inner{

　　　　　　public int y = 10;

　　　　　　private int z = 9;

　　　　　　int m = 5;

　　　　　　public void display(){

　　　　　　　　System.out.println("display outer_x:"+ outer_x);

　　　　　　}

　　　　　　private void display2(){

　　　　　　　　System.out.println("display outer_x:"+ outer_x);

　　　　　　}

　　　　void test(){

　　　　　　Inner inner = new Inner();

　　　　　　inner.display();

　　　　　　inner.display2();

　　　　　　//System.out.println("Inner y:" + y);//不能访问内部内变量

　　　　　　System.out.println("Inner y:" + inner.y);//可以访问

　　　　　　System.out.println("Inner z:" + inner.z);//可以访问

　　　　　　System.out.println("Inner m:" + inner.m);//可以访问

　　　　　　InnerTwo innerTwo = new InnerTwo();

　　　　　　innerTwo.show();

　　　　}

　　　　class InnerTwo{

　　　　　　Inner innerx = new Inner();

　　　　　　public void show(){

　　　　　　　　//System.out.println(y);//不可访问Innter的y成员

　　　　　　　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法

　　　　　　　　innerx.display();//可以访问

　　　　　　　　innerx.display2();//可以访问

　　　　　　　　System.out.println(innerx.y);//可以访问

　　　　　　　　System.out.println(innerx.z);//可以访问

　　　　　　　　System.out.println(innerx.m);//可以访问

　　　　　　}

　　　　public static void main(String args[]){

　　　　　　Outer outer = new Outer();

　　　　　　outer.test();

　　　　}

以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量

原文链接：https://phpor.net/blog/post/2253

关于JAVA内存

Java No Responses »

1,737

5月 122013

JAVA 内存模型

参考资料：

http://developer.51cto.com/art/201009/225071.htm

http://www.infoq.com/cn/articles/java-memory-model-1

http://baike.baidu.com/view/8657411.htm

JAVA内存大小设置：

http://www.rsky.com.cn/Article/java/201002/11289.html

http://developer.51cto.com/art/200907/135038.htm

问题：如果设置的内存大小超过了系统的物理内存大小，则数据放到何处？

这样的话，虚拟机就跑不起来的

原文链接：https://phpor.net/blog/post/1857

关于JAVA线程和线程池的学习

Java No Responses »

2,207

5月 122013

Java线程：

Java线程不等于系统线程，Java线程和系统线程也没有必然的映射关系。

java线程管理是JVM的一部分，虽然大部分JVM直接映射java线程到底层系统线程，但是还是java的线程管理决定谁有机会运行
The thread scheduler is the part of the JVM (although most JVMs map Java threads directly to native threads on the underlying OS) that decides which thread should run at any given moment, and also takes threads out of the run state. Assuming a single processor machine, only one thread can actually run at a time. Only one stack can ever be executing at one time. And it's the thread scheduler that decides which thread—of all that are eligible—will actually run.

java线程管理是JVM的一部分，虽然大部分JVM直接映射java线程到底层系统线程，但是还是java的线程管理决定谁有机会运行

The thread scheduler is the part of the JVM (although most JVMs map Java threads directly to native threads on the underlying OS) that decides which thread should run at any given moment, and also takes threads out of the run state. Assuming a single processor machine, only one thread can actually run at a time. Only one stack can ever be executing at one time. And it's the thread scheduler that decides which thread—of all that are eligible—will actually run.

参考文档：

http://wenku.baidu.com/view/2ffaac1fa8114431b90dd8fe.html

java的线程概念与操作系统的线程概念是不同的，java的线程概念差不多与windows线程概念一致，但是java既然目标是跨平台语言，那么它的线程机制概念是在所有平台上都是一样的，但是实际实现又不是如此，这要从进程与线程的概念中谈起：
首先在windows系列系统中，进程所拥有的内存空间都是独立的，此进程所持有的内存其它进程是不可以直接访问的，而且在windows系统内部一个进程就是一个运行的运用程序，而为了解决应用程序内部的并行问题便有了线程的概念，线程没有自我独立的内存空间，在一个进程中所有的线程共享这个进程所持有的内存空间。
而在某些Unix系统当中，进程所持有的内存空间是可以被其他进程进行访问的，而且一个运用程序可能不止一个进程，这样的系统没有线程的概念，运用的并行问题有多个进程协调来解决。
java为了实现平台无关性，必须解决这样一个问题，因此java建立了一套自己的进程与线程机制，这套机制与windows系统的颇为相似，但是底层实现确实根据不同平台的机制进行实现，比如windows下的线程机制就是利用windows本身的线程机制加上某些改进进行处理的，而某些没有线程的Unix系统则是用进程来替代线程进行实现的，然后在其中确立一个主进程来替代自身进程。虽然这样的实现解决了大部分的线程平台无关性，但是也有些无法解决的，比如线程优先级，windows下线程是有优先级的，但是某些Linux系统，某些Unix系统，进程与线程直接不区分优先级，因此优先级在每个系统下的表现形式就不一样，例如低优先级的进程可能在windows下被饿死，但是在linux下，根本就无法感觉它优先级较低，还有，在建立一个线程与杀死一个线程运用所带来的开销也会不同，在windows下建立或杀死线程可能是不需要什么开销的，但是在没有线程概念的进程行操作系统中，杀死或者建立线程可能带来巨大开销

—————————————————————————————————————————————–

Java自带的线程池ThreadPoolExecutor详细介绍说明和实例应用

http://fulong258.blog.163.com/blog/static/17895044201082951820935/
http://www.cnblogs.com/jersey/archive/2011/03/30/2000231.html

Java线程示例

http://www.cnblogs.com/rollenholt/archive/2011/08/28/2156357.html

原文链接：https://phpor.net/blog/post/1855

ubuntu12.04安装JDK7

Java, Linux & Unix No Responses »

1,687

5月 112013

参考资料：

http://dawndiy.com/archives/155/

http://c04s31602.iteye.com/blog/1558732

http://openjdk.java.net/

jdk下载地址：

http://www.oracle.com/technetwork/java/javase/downloads/index.html

OpenJDK 与 JDK 的区别：

http://fgh2011.iteye.com/blog/1771649

原文链接：https://phpor.net/blog/post/1849

JAVA与C之间的关系

Java No Responses »

2,726

4月 282013

java可以直接编译成可执行的二进制文件，参考：http://xieruilin.iteye.com/blog/728940
- 这种方案成熟吗？很少见到把JAVA编译成二进制文件后运行的
java可以通过jni的方式来访问C编译后的程序的（如：so），当然，这种so和普通的so有稍许的不同，需要通过jni的方式包装一下的，参考： http://hubingforever.blog.163.com/blog/static/17104057920115218559186/
javah命令就是为jni而生的
Android.mk简介： http://hubingforever.blog.163.com/blog/static/171040579201152185542166/
http://hubingforever.blog.163.com/blog/static/1710405792011656434982/
NDK
Android NDK 是在SDK前面又加上了“原生”二字，即Native Development Kit，因此又被Google称为“NDK”。

众所周知，Android程序运行在Dalvik虚拟机中，NDK允许用户使用类似C / C++之类的原生代码语言执行部分程序。

NDK包括了：
- 从C / C++生成原生代码库所需要的工具和build files。
- 将一致的原生库嵌入可以在Android设备上部署的应用程序包文件（application packages files ，即.apk文件）中。
- 支持所有未来Android平台的一些列原生系统头文件和库
为何要用到NDK?

概括来说主要分为以下几种情况：

1. 代码的保护，由于apk的java层代码很容易被反编译，而C/C++库反汇难度较大。

2. 在NDK中调用第三方C/C++库，因为大部分的开源库都是用C/C++代码编写的。

3. 便于移植，用C/C++写得库可以方便在其他的嵌入式平台上再次使用。

参考：http://www.cnblogs.com/hibraincol/archive/2011/05/30/2063847.html

原文链接：https://phpor.net/blog/post/1830

JAVA使用openssl生成的公私钥做加密解密

Java, 算法, 网络安全, 默认分类 No Responses »

6,162

1月 262013

使用openssl生成密钥对：

>openssl genrsa -out private.key
>openssl rsa -in private.key -pubout -outform PEM -out public.key
// 因为java里面不识别x509格式的私钥，所以必须转换为 pkcs8格式方可使用
// java异常描述为： java.security.spec.InvalidKeySpecException: Only RSAPrivate(Crt)KeySpec and PKCS8EncodedKeySpec supported for RSA private keys
// 虽然RSAPrivate(Crt)KeySpec 也支持，但是目前还不知道怎么用
>openssl pkcs8 -topk8 -inform PEM -outform PEM -in private.key -out pkcs8_priv.pem -nocrypt

>openssl genrsa -out private.key

>openssl rsa -in private.key -pubout -outform PEM -out public.key

// 因为java里面不识别x509格式的私钥，所以必须转换为 pkcs8格式方可使用

// java异常描述为： java.security.spec.InvalidKeySpecException: Only RSAPrivate(Crt)KeySpec and PKCS8EncodedKeySpec supported for RSA private keys

// 虽然RSAPrivate(Crt)KeySpec 也支持，但是目前还不知道怎么用

>openssl pkcs8 -topk8 -inform PEM -outform PEM -in private.key -out pkcs8_priv.pem -nocrypt

java代码：

1. 注意： java 语言本身没有实现base64编码，而openssl生成的密钥对一般做base64编码，便于维护，所以这里引用了 org.apache.commons.codec.binary.Base64;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;
//下载地址： http://commons.apache.org/codec/download_codec.cgi

public static class MyRsa {
	/**
	 * String to hold name of the encryption algorithm.
	 */
	public static final String ALGORITHM = "RSA";

	/**
	 * String to hold the name of the private key file.
	 */
	public static final String PRIVATE_KEY_FILE = "D:/rsa/pkcs8_priv.pem";

	/**
	 * String to hold name of the public key file.
	 */
	public static final String PUBLIC_KEY_FILE = "D:/rsa/public.key";

	/**
	 * Encrypt the plain text using public key.
	 * 
	 * @param text
	 *            : original plain text
	 * @param key
	 *            :The public key
	 * @return Encrypted text
	 * @throws java.lang.Exception
	 */
	public static byte[] encrypt(String text, PublicKey key) {
		byte[] cipherText = null;
		try {
			// get an RSA cipher object and print the provider
			final Cipher cipher = Cipher.getInstance(ALGORITHM);
			// encrypt the plain text using the public key
			cipher.init(Cipher.ENCRYPT_MODE, key);
			cipherText = cipher.doFinal(text.getBytes());
		} catch (Exception e) {
			e.printStackTrace();
		}
		return cipherText;
	}

	/**
	 * Decrypt text using private key.
	 * 
	 * @param text
	 *            :encrypted text
	 * @param key
	 *            :The private key
	 * @return plain text
	 * @throws java.lang.Exception
	 */
	public static String decrypt(byte[] text, PrivateKey key) {
		byte[] dectyptedText = null;
		try {
			// get an RSA cipher object and print the provider
			final Cipher cipher = Cipher.getInstance(ALGORITHM);

			// decrypt the text using the private key
			cipher.init(Cipher.DECRYPT_MODE, key);
			dectyptedText = cipher.doFinal(text);

		} catch (Exception ex) {
			ex.printStackTrace();
		}

		return new String(dectyptedText);
	}

	public static void test() {
		String s = "Hello world";
		try {
			BufferedReader privateKey = new BufferedReader(new FileReader(
					PRIVATE_KEY_FILE));
			BufferedReader publicKey = new BufferedReader(new FileReader(
					PUBLIC_KEY_FILE));	
			String strPrivateKey = "";
			String strPublicKey = "";
			String line = "";
			while((line = privateKey.readLine()) != null){
				strPrivateKey += line;
			}
			while((line = publicKey.readLine()) != null){
				strPublicKey += line;
			}
			privateKey.close();
			publicKey.close();

			// 私钥需要使用pkcs8格式的，公钥使用x509格式的
			String strPrivKey = strPrivateKey.replace("-----BEGIN PRIVATE KEY-----", "")
					.replace("-----END PRIVATE KEY-----", "");				
			String strPubKey = strPublicKey.replace("-----BEGIN PUBLIC KEY-----", "")
					.replace("-----END PUBLIC KEY-----", "");
			//System.out.print(strPrivKey);
			//System.out.println(strPubKey);	

			byte [] privKeyByte = Base64.decodeBase64(strPrivKey);
			byte [] pubKeyByte = Base64.decodeBase64(strPubKey);
			PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyByte);
			//PKCS8EncodedKeySpec pubKeySpec = new PKCS8EncodedKeySpec(pubKeyByte);

			//X509EncodedKeySpec 	privKeySpec = new X509EncodedKeySpec(privKeyByte);
			X509EncodedKeySpec 	pubKeySpec = new X509EncodedKeySpec(pubKeyByte);

			KeyFactory kf = KeyFactory.getInstance("RSA");

			PrivateKey privKey = kf.generatePrivate(privKeySpec);
			PublicKey pubKey = kf.generatePublic(pubKeySpec);

			byte [] encryptByte = encrypt(s, pubKey);
			System.out.println(decrypt(encryptByte, privKey));

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvalidKeySpecException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.security.KeyFactory;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.Arrays;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;

//下载地址： http://commons.apache.org/codec/download_codec.cgi

public static class MyRsa {

/**

* String to hold name of the encryption algorithm.

public static final String ALGORITHM = "RSA";

/**

* String to hold the name of the private key file.

public static final String PRIVATE_KEY_FILE = "D:/rsa/pkcs8_priv.pem";

/**

* String to hold name of the public key file.

public static final String PUBLIC_KEY_FILE = "D:/rsa/public.key";

/**

* Encrypt the plain text using public key.

* @param text

* : original plain text

* @param key

* :The public key

* @return Encrypted text

* @throws java.lang.Exception

public static byte[] encrypt(String text, PublicKey key) {

byte[] cipherText = null;

try {

// get an RSA cipher object and print the provider

final Cipher cipher = Cipher.getInstance(ALGORITHM);

// encrypt the plain text using the public key

cipher.init(Cipher.ENCRYPT_MODE, key);

cipherText = cipher.doFinal(text.getBytes());

} catch (Exception e) {

e.printStackTrace();

}

return cipherText;

}

/**

* Decrypt text using private key.

* @param text

* :encrypted text

* @param key

* :The private key

* @return plain text

* @throws java.lang.Exception

public static String decrypt(byte[] text, PrivateKey key) {

byte[] dectyptedText = null;

try {

// get an RSA cipher object and print the provider

final Cipher cipher = Cipher.getInstance(ALGORITHM);

// decrypt the text using the private key

cipher.init(Cipher.DECRYPT_MODE, key);

dectyptedText = cipher.doFinal(text);

} catch (Exception ex) {

ex.printStackTrace();

}

return new String(dectyptedText);

}

public static void test() {

String s = "Hello world";

try {

BufferedReader privateKey = new BufferedReader(new FileReader(

PRIVATE_KEY_FILE));

BufferedReader publicKey = new BufferedReader(new FileReader(

PUBLIC_KEY_FILE));

String strPrivateKey = "";

String strPublicKey = "";

String line = "";

while((line = privateKey.readLine()) != null){

strPrivateKey += line;

}

while((line = publicKey.readLine()) != null){

strPublicKey += line;

}

privateKey.close();

publicKey.close();

// 私钥需要使用pkcs8格式的，公钥使用x509格式的

String strPrivKey = strPrivateKey.replace("-----BEGIN PRIVATE KEY-----", "")

.replace("-----END PRIVATE KEY-----", "");

String strPubKey = strPublicKey.replace("-----BEGIN PUBLIC KEY-----", "")

.replace("-----END PUBLIC KEY-----", "");

//System.out.print(strPrivKey);

//System.out.println(strPubKey);

byte [] privKeyByte = Base64.decodeBase64(strPrivKey);

byte [] pubKeyByte = Base64.decodeBase64(strPubKey);

PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyByte);

//PKCS8EncodedKeySpec pubKeySpec = new PKCS8EncodedKeySpec(pubKeyByte);

//X509EncodedKeySpec privKeySpec = new X509EncodedKeySpec(privKeyByte);

X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pubKeyByte);

KeyFactory kf = KeyFactory.getInstance("RSA");

PrivateKey privKey = kf.generatePrivate(privKeySpec);

PublicKey pubKey = kf.generatePublic(pubKeySpec);

byte [] encryptByte = encrypt(s, pubKey);

System.out.println(decrypt(encryptByte, privKey));

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (NoSuchAlgorithmException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (InvalidKeySpecException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

稍后提供一个PHP加密Java解密的实现

参考资料：

http://stackoverflow.com/questions/11787571/how-to-read-pem-file-to-get-private-and-public-key

http://stackoverflow.com/questions/8647165/how-to-sign-a-generic-text-with-rsa-key-and-encode-with-base64-in-java

http://www.javamex.com/tutorials/cryptography/rsa_encryption.shtml

http://snowolf.iteye.com/blog/381767

密钥结构及格式： https://polarssl.org/kb/cryptography/asn1-key-structures-in-der-and-pem

原文链接：https://phpor.net/blog/post/1771

ANT构建和部署项目

Java No Responses »

1,842

1月 212013

概述：

参考资料：

ANT简明教程[转载]: http://www.cnblogs.com/philander/articles/1782254.html

ANT命令总结： http://www.blogjava.net/sutao/articles/133961.html

ANT基本使用指南： http://www.iteye.com/topic/78973

Eclipse中配置ANT: http://www.cnblogs.com/QQParadise/articles/1622154.html

原文链接：https://phpor.net/blog/post/1766

JSP中response.addCookie的问题

Java No Responses »

2,500

1月 172013

脚本：

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class CookieExample extends HttpServlet {

    public void doGet(HttpServletRequest request, HttpServletResponse response)
    throws IOException, ServletException
    {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();

        // print out cookies

        Cookie[] cookies = request.getCookies();
        for (int i = 0; i < cookies.length; i++) {
            Cookie c = cookies[i];
            String name = c.getName();
            String value = c.getValue();
            out.println(name + " = " + value);
        }

        // set a cookie

        String name = request.getParameter("cookieName");
        if (name != null && name.length() > 0) {
            String value = request.getParameter("cookieValue");
            Cookie c = new Cookie(name, value);
            response.addCookie(c);
        }
    }
}

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class CookieExample extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws IOException, ServletException

{

response.setContentType("text/html");

PrintWriter out = response.getWriter();

// print out cookies

Cookie[] cookies = request.getCookies();

for (int i = 0; i < cookies.length; i++) {

Cookie c = cookies[i];

String name = c.getName();

String value = c.getValue();

out.println(name + " = " + value);

}

// set a cookie

String name = request.getParameter("cookieName");

if (name != null && name.length() > 0) {

String value = request.getParameter("cookieValue");

Cookie c = new Cookie(name, value);

response.addCookie(c);

}

如果cookie的name中含有 “;” 则会抛出异常，出现500错误，这个是没有问题的，但是，如果value中含有 “;” 会怎么处理呢？在PHP中setcookie()函数会将value做url编码，如果是setrawcookie()则会报错误。而在JSP中却出现了如下现象：

Content-Length:779
Content-Type:text/html;charset=ISO-8859-1
Date:Thu, 17 Jan 2013 15:01:41 GMT
Server:Apache-Coyote/1.1
Set-Cookie:m="M;n"; Version=1

Content-Length:779

Content-Type:text/html;charset=ISO-8859-1

Date:Thu, 17 Jan 2013 15:01:41 GMT

Server:Apache-Coyote/1.1

Set-Cookie:m="M;n"; Version=1

浏览器会因为给value添加了双引号而将cookie m的只是为 “M;n”吗？不会的：

原文链接：https://phpor.net/blog/post/1750

java线程

Java No Responses »

2,126

1月 162013

java线程和操作系统线程之间的关系：

java线程管理是JVM的一部分，虽然大部分JVM直接映射java线程到底层系统线程，但是还是java的线程管理决定谁有机会运行

The thread scheduler is the part of the JVM (although most JVMs map Java threads directly to native threads on the underlying OS) that decides which thread should run at any given moment, and also takes threads out of the run state. Assuming a single processor machine, only one thread can actually run at a time. Only one stack can ever be executing at one time. And it's the thread scheduler that decides which thread—of all that are eligible—will actually run.