机械境-信永软件工程师培训学校 » java http://code.oseschool.com 世界：男人、女人、程序员 Sun, 07 Mar 2010 02:43:20 +0000 http://wordpress.org/?v=2.8.4 en hourly 1 java的正则表达式 http://code.oseschool.com/index.php/archives/76 http://code.oseschool.com/index.php/archives/76#comments Fri, 26 Feb 2010 03:47:33 +0000 admin http://code.oseschool.com/index.php/archives/76 1、 Pattern p = Pattern.compile(参数1);
Matcher m = p.matcher(参数2);
参数值分别去null的情况 和 参数值分别取”"

答:
当把参数1或参数2设置成null的时候,都将会抛出空指针异常,原因如下:
首先了解一下静态方法compile里的源代码为
public static Pattern compile(String regex) {
return new Pattern(regex, 0);
}
该方法返回了一个Pattern实例,那么我们再看看该Pattern的构建函数
private Pattern(String p, int f) {tt
pattern = p;
flags = f;

// Reset group index count
capturingGroupCount = 1;
localCount = 0;

if (pattern.length() > 0) {
compile();
} else {
root = new Start(lastAccept);
matchRoot = lastAccept;
}
}

我们会发现,p是我们刚开始传进来的null值,pattern引用了p
当pattern.length的时候,pattern是个null,空指针异常抛出了.
而matcher方法里和上面的方法情况差不多,依然是执行了给参数取length,造成的空指针异常

当把参数1或参数2传“”时,它是一个空字符串,跟其它普通字符串一样.

2、 为什么p.matcher(参数2);要生成Matcher对象。或者说是Matcher有什么用。

答:根据以下的API,我们可以得到答案
public Matcher matcher(CharSequence input)
创建匹配给定输入与此模式的匹配器。
参数：
input – 要匹配的字符序列。
返回：
此模式的新匹配器。

由此得知,Matcher是一个匹配器,可以执行三种不同的匹配操作,也就是
matches 尝试将整个输入序列与该模式匹配
find 扫描输入序列以查找与该模式匹配的下一个子序列
lookingAt 尝试将输入序列从头开始与该模式匹配

并且Matcher对象里提供了很多好用的方法,可供我们实现更高级的查找替换

3、正则表达式 “(bb)?” 匹配 “” ,”b”,”bbb” 的结果，以及解释。

答:
首先,?号代表的是?号前面的字符串出现零次或一次,
那么”(bb)?”表示字符串bb要出现零次或一次
当出现零次的时候,能匹配到的是个空字符串
当出现一次的时候,能匹配到的是”bb”字符串
那么答案很快就出来了
匹配”",答案当然是true
匹配”b”,答案false
匹配”bbb”,答案false

4、正则表达式写成”**” 或者”x**”等类似的情况。

答:
*,?,+都是正则里的特殊字符
标准的写法是X*,X不能是一个空字符串,
所以”**”或”x**”都将会抛出异常

5、有[a-z]的正则表达式，那[z-a] [a-A]或者[A-a]等相类似的表达式。

答:[a-z]表示一个范围,a和z会转换成ASCII码,范围要遵循从小到大的原则

6、字符串 “” 匹配”[a-z&&[ABC]]” ， 以及其他字符串对此正则表达式的匹配。

答:[a-z&&[ABC]]是取a-z与ABC的交集,他们没有任何交集,所以任何字符都不能与他匹配

7、字符串″bbc” 匹配正则表达式 “b^b.”、”b?^b..”等类似的正则表达式。

答:
首先,我们要明白两点:^号在[]外面,表示一行的开头,而在[]里,表示取反
我们可以用下面的一个等式:
“b.”==”^b.”
那么”b^b.”==”^b^b.”,说明是行开头的第一个字符为”bb”,但是”bb”只能表示为两个字符而非一个字符(字符集里应该没有一个字符为”bb”的吧..)
所以任何字符串都不能与它匹配上
而”b?^b..”,b?代表b出现零次或多次,匹配器里为了尽量能让字符串″bbc”与该模式匹配,把b?设定为出现零次,那么后面的^b..就可以与”bbc”相匹配上了

8、email的正则表达式。

答:”[\w[.-]]+@[\w[.-]]+\.[\w]+”

9、用正则区分全角半角。

答:全角范围:[uFF00-uFFFF]
半角范围:[^uFF00-uFFFF](也就是全角的范围取反了)

扩充:
汉字的UNICODE编码范围是4e00-9fa5

汉字范围:[u4E00-u9FA5](那如果取反,就表示不是汉字咯)

]]> http://code.oseschool.com/index.php/archives/76/feed 0 DOM4J官方快速入门（译文）中文详解 http://code.oseschool.com/index.php/archives/70 http://code.oseschool.com/index.php/archives/70#comments Wed, 09 Sep 2009 01:32:17 +0000 admin http://code.oseschool.com/?p=70 官方地址：http://www.dom4j.org/dom4j-1.6.1/guide.html

Dom4j 快速入门

Parsing XML (xml 解析)

以下例子演示了如何使用SAX解析器解析XML，返回一个DOM 模型的对象，即DOCUMENT.

有了DOCUMENT我们就可以进行文档操作了。

import java.net.URL;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
 
public class Foo {
 
public Document parse(URL url) throws DocumentException {
	// 以DOM4J默认的SAX解析器解析
        SAXReader reader = new SAXReader();
	// read函数的形参可以是url 也可以是 File类型，也可以是STRING类型的相对或绝对路径
        Document document = reader.read(url);
        return document;
    }
}
 
 Using Iterators（使用迭代器）
该部分演示了如何使用迭代器（迭代器是一种设计模式，可用于遍历如集合、数组等）进行文档的遍历。以下演示了获得三种的迭代器。
 
public void bar(Document document) throws DocumentException {
	// 获得根节点
	Element root = document.getRootElement();
 
	// i为根节点孩子节点的迭代器
	for ( Iterator i = root.elementIterator(); i.hasNext(); ) {
		Element element = (Element) i.next();
		// do something
		System.out.println(element.getName());
	}
 
	// 名为“student1”节点以下孩子节点的迭代器
	for ( Iterator i = root.elementIterator("student1" ); i.hasNext(); ) {
		Element foo = (Element) i.next();
		// do something
		System.out.println(foo.getText());
	}
 
	// 根节点属性的迭代器
	for ( Iterator i = root.attributeIterator(); i.hasNext(); ) {
		Attribute attribute = (Attribute) i.next();
		// do something
		System.out.println(attribute.getValue());
	}
 }

————————————————————————————————————————

以下是：foo.xml 

<?xml version="1.0" encoding="gb2312"?>
<foo id="1111" fooname="test">
	<student sn="01"><name>张三</name><age>18</age></student>
	<student sn="02"><name>李四</name><age>20</age></student>
	<student1 sn="03">小翁</student1>
</foo>

————————————————————————————————————————

Main函数中执行如下命令：

	Foo foo = new Foo();
		Document doc ;
		//1.2 Using Iterators
		File file = new File("foo.xml");
		try {
			//parse  为以上1.1 部分的方法
			doc = foo.parse(file);
			foo.bar(doc);
		} catch (DocumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
	}

结果：
student
student
student1
小翁
1111
test

Powerful Navigation with Xpath(使用Xpth进行导航)

XPath 使用路径表达式来选取 XML 文档中的节点或节点集。

具体可以参见http://www.w3school.com.cn/xpath/xpath_syntax.asp

注意：使用XPATH进行导航时，有时需要导入一个名jaxen-XXX.jar的包,该包可以在 官方DOM4J文件夹lib目录下有。

Dom4j XPath 表达式也以表示文档或文档树中的节点（如属性，元素，以及处理指令）。可以用一行简单的代码进行复杂的文档遍历。如下：

	public void barWithXPath(Document document) {
			// “//”表示任意路径节点 如 //name 任意名为name 的节点
		List<Node> list = document.selectNodes("//name");
		for (Node nodeTmp : list) {
			System.out.println(nodeTmp.getText());
		}
		//"//foo/student[2]" 表示带有foo路径下第二个student节点
		Node node = document.selectSingleNode("//foo/student[2]");
		// “@”表示属性
		String name = node.valueOf("@sn");
		System.out.println(name);
	}

————————————————————-

以下是：foo.xml

	<?xml version="1.0" encoding="gb2312"?>
<foo id="1111" fooname="test">
	<student sn="01"><name>张三</name><age>18</age></student>
	<student sn="02"><name>李四</name><age>20</age></student>
	<student1 sn="03">小翁</student1>
</foo>

————————————————————————————————————————

Main函数中执行如下命令：

	Foo foo = new Foo();
	Document doc ;
	//1.3 Powerful Navigation with Xpath
	File file = new File("foo.xml");
	try {
		doc = foo.parse(file);
		foo.barWithXPath(doc);
	} catch (DocumentException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

结果：
张三
李四
02

例如，如果你想获取一个XHTML中的所有超级链接，可以采用如下方式：

    public void findLinks(Document document) throws DocumentException {
 
        List list = document.selectNodes( "//a/@href" );
 
        for (Iterator iter = list.iterator(); iter.hasNext(); ) {
            Attribute attribute = (Attribute) iter.next();
            String url = attribute.getValue();
        }
	}

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

MyXhtml.xhtml文件

	<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
	<head>
		<title>MyXhtml.xhtml</title>
	</head>
	<body>
		<a href="1">www.oseschool.com</a>
		<a href="2">2222</a>
		<a href="3">3333</a>
	</body>
</html>

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

注意：若要利用上述findLinks 函数得到MyXhtml.xhtml文件中的a标签中href的属性值，必须对代码进行一定的修改。主要是因为MyXhtml.xhtml文件中带有命名空间。

具体代码如下：

public Document parseWithNameSpace(File file) throws DocumentException {
	SAXReader reader = new SAXReader();
	Map map = new HashMap();
	//把文件中的所以命名空间先放入一个MAP中
	map.put("xmlns1", "http://www.w3.org/1999/xhtml");
	//设置命名空间
	reader.getDocumentFactory().setXPathNamespaceURIs(map);
	Document document = reader.read(file);
	return document;
}
public void findLinks(Document document) throws DocumentException {	//注意对要遍历的元素要加命名空间限制
	List list = document.selectNodes("//xmlns1:a/@href");
 
	for (Iterator iter = list.iterator(); iter.hasNext();) {
		Attribute attribute = (Attribute) iter.next();
		String url = attribute.getValue();
		System.out.println(url);
	}
}

————————————————————————————————————————

Main函数执行：

	Foo foo = new Foo();
	Document doc ;
	//1.3 Powerful Navigation with Xpath
	File file = new File("MyXhtml.xhtml");
	try {
		doc = foo.parseWithNameSpace(file);
		foo.findLinks(doc);
	} catch (DocumentException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

结果：
www.oseschool.com
2
3

Fast Looping（快速循环）

如果你要遍历一个较大的XML文档，那么我们推荐你使用快速循环（递归）方法，这样将避免创建迭代器对象带来的开销。如下：

	public void treeWalk(Document document) {
        treeWalk( document.getRootElement() );
    }
	//采用递归的方式
    public void treeWalk(Element element) {
        for ( int i = 0, size = element.nodeCount(); i < size; i++ ) {
            Node node = element.node(i);
		//判断是否是元素，如<test>11</test>即为元素
            if ( node instanceof Element ) {
                treeWalk( (Element) node );
            }
            else {
                // do something....打印元素中的文本内容
		System.out.println(node.getText());
            }
        }
	}

————————————————————-

以下是：foo.xml

<?xml version="1.0" encoding="gb2312"?>
<foo id="1111" fooname="test">
	<student sn="01"><name>张三</name><age>18</age></student>
</foo>

————————————————————————————————————————

Main函数执行：

	Foo foo = new Foo();
	Document doc ;
	//1.4 Fast Looping
	File file = new File("foo.xml");
	try {
		//parse方法为1.1 中 parse方法
		doc = foo.parse(file);
		foo.treeWalk(doc);
	} catch (DocumentException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

结果：
（空行）
（空行）
张三
18

分析：“（空行）”表示本行内容为空，或许很多人感到疑问，为什么会有两个空行了，由于

<foo id="1111" fooname="test">
	<student sn="01"><name>张三</name><age>18</age></student>
</foo>

在以及后都出现了换行，故解析器认为有两个TEXT类型的节点。也就是把文件改为：

<foo id="1111" fooname="test"><student sn="01"><name>张三</name><age>18</age></student></foo>

所以节点在同一行，结果就不会有空行。

————————————————————————————————————————

 Creating a new XML document（创建一个新的XML文档）
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
 
public class Foo {
 
    public Document createDocument() {
        Document document = DocumentHelper.createDocument();
        Element root = document.addElement( "root" );
 
        Element author1 = root.addElement( "author" )
            .addAttribute( "name", "James" )
            .addAttribute( "location", "UK" )
            .addText( "James Strachan" );
 
        Element author2 = root.addElement( "author" )
            .addAttribute( "name", "Bob" )
            .addAttribute( "location", "US" )
            .addText( "Bob McWhirter" );
 
        return document;
    }
}

Writing a document to a file（写入一个文档到一个文件）

一种快速而简单地把文档写入到一个文件，即调用字符输出流的write方法。

  FileWriter out = new FileWriter( "foo.xml" );
  document.write( out );

如果你想要改变输出的格式，如宽松或紧凑的格式，而且你想要使用一些基本的字节或字符输出流，那么你可以使用XMLWriter类，如下。

import org.dom4j.Document;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
 
public class Foo {
 
    public void write(Document document) throws IOException {
 
        // lets write to a file
        XMLWriter writer = new XMLWriter(
            new FileWriter( "output.xml" )
        );
        writer.write( document );
        writer.close();
 
        // 打印出Pretty的样式。即元素之间有换行。
        OutputFormat format = OutputFormat.createPrettyPrint();
        writer = new XMLWriter( System.out, format );
        writer.write( document );
 
        // 紧凑的格式，所有元素在一行
        format = OutputFormat.createCompactFormat();
        writer = new XMLWriter( System.out, format );
        writer.write( document );
    }
}

注意：如果按上述形式打印输出，是以计算机默认编码，进行写入操作，也就是如果在中文系统下，你读出的DOM，如果是UTF-8编码的，不会正确输出。所以建议用对上面的代码改进，如下：

	OutputFormat outFmt=new OutputFormat();
	outFmt.setEncoding("utf8");
 
	try
	{
		XMLWriter xmlWriter=new XMLWriter(new FileOutputStream("dom4jtest.xml"),outFmt);
		xmlWriter.write(doc);
 
		xmlWriter.flush();
		xmlWriter.close();
	}

上面最大改变是把FileWriter->FileOutputStream.然后使用OutputFormat设定编码。

Converting to and from Strings（转换字符串）

如果你有一个文档对象的引用或任何其他像属性或元素的节点，那么你可以把他们转换为一种默认的XML文本，通过调用 asXML 方法。

	Document document = ...;
	String text = document.asXML();

如果你有些XML的文本字符串，你可以把它再转换回文档对象，通过使用帮助方法DocumentHelper.parseText()

	String text = "<person> <name>James</name> </person>";
	Document document = DocumentHelper.parseText(text);
 Styling a Document with XSLT（使用XSLT格式一个文档）

要想在一个文档对象上运用一个XSLT可以直接调用SUN 的JAXP API（JAVA API FOR XML PROGRAM）。允许使用像Xalan或SAXON这样的任何XSLT引擎。这里有一个使用JAXP来创建transformer对象然后将XSLT运用在一个文档上。

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
 
import org.dom4j.Document;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
 
public class Foo {
 
    public Document styleDocument(
        Document document, 
        String stylesheet
    ) throws Exception {
 
        // load the transformer using JAXP
        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer transformer = factory.newTransformer( 
            new StreamSource( stylesheet ) 
        );
 
        // now lets style the given document
        DocumentSource source = new DocumentSource( document );
        DocumentResult result = new DocumentResult();
        transformer.transform( source, result );
 
        // return the transformed document
        Document transformedDoc = result.getDocument();
        return transformedDoc;
    }
}

———————————————————————————————————————-

Catalog.XML

<?xml version="1.0" encoding="ISO-8859-1"?>
<catalog>
  <cd>
    <title>Empire Burlesque</title>
    <artist>Bob Dylan</artist>
    <country>USA</country>
    <company>Columbia</company>
    <price>10.90</price>
    <year>1985</year>
  </cd>
</catalog>

———————————————————————————————————————

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
  <html>
  <body>
    <h2>My CD Collection</h2>
    <table border="1">
    <tr bgcolor="#9acd32">
      <th align="left">Title</th>
      <th align="left">Artist</th>
    </tr>
    <xsl:for-each select="catalog/cd">
    <tr>
      <td><xsl:value-of select="title"/></td>
      <td><xsl:value-of select="artist"/></td>
    </tr>
    </xsl:for-each>
    </table>
  </body>
  </html>
</xsl:template>
</xsl:stylesheet>

———————————————————————————————————————

Main函数：

	Foo foo = new Foo();
	Document doc ;
	//1.4 Fast Looping
	File file = new File("catalog.xml");
	try {
		doc = foo.parse(file);
		Document newDoc = foo.styleDocument(doc, "catalog.xsl");
		// 1.6 中的write方法
		foo.write(newDoc);
 
	} catch (DocumentException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

———————————————————————————————————————

结果：

<?xml version="1.0" encoding="UTF-8"?>
 
<html>
  <body>
    <h2>My CD Collection</h2>
    <table border="1">
      <tr bgcolor="#9acd32">
        <th align="left">Title</th>
        <th align="left">Artist</th>
      </tr>
      <tr>
        <td>Empire Burlesque</td>
        <td>Bob Dylan</td>
      </tr>
    </table>
  </body>
</html>
<?xml version="1.0" encoding="UTF-8"?>
<html><body><h2>My CD Collection</h2><table border="1"><tr bgcolor="#9acd32"><th align="left">Title</th><th align="left">Artist</th></tr><tr><td>Empire Burlesque</td><td>Bob Dylan</td></tr></table></body></html>

分析：结果中有一个为Pretty的样式，一个为compact的样式。还生成了一个output.xml

]]> http://code.oseschool.com/index.php/archives/70/feed 0 Java中的多维数组 http://code.oseschool.com/index.php/archives/68 http://code.oseschool.com/index.php/archives/68#comments Thu, 27 Aug 2009 02:02:55 +0000 admin http://code.oseschool.com/?p=68 多维数组的声明：

  • 数据类型[] [] 数组名称;
  • 数据类型[] 数组名称 [];
  • 数据类型   数组名称[][];

以上三种都的数组命名方式都是正确的，功能也是等价的

但是我们在JAVA的推荐规范中。推荐使用第一种方式。

既：String[][] args = new String[1][2];

在JAVA中多维数组的初始化也可以分为静态初始化和动态初始化两种。

静态初始化:

String[][] args = {{“a”,” b”,”c”},{“d”,”e”}};

实际等效于

String[][] args2 = new String[2][];

args2[0] = new String[3];

args2[0][0] = “a”;

args2[0][1] = “b”;

args2[0][2] = “c”;

args2[1] = new String[2];

args2[1][0] = “d”;

args2[1][1] = “e”;

动态初始化：

  • 数据类型[][] 数组名称 = new 数据类型[第一维的长度][第二维的长度];
  • 数据类型[][] 数组名称;
  • 数组名称 = new 数据类型[第一维的长度][第二维的长度];

例：String[][] args = new String[2][3];

绝对不能这样写：String[][] args = new String[][3];

必须先初始化第一维的长度后，再初始化后面的长度，才可以。

所以JAVA 的多维数组也称之为 数组中的数组。也就是最后一维的数组才是真正存具体值信息的地方。

]]> http://code.oseschool.com/index.php/archives/68/feed 0 MyEclipse6.0.1配置Tomcat6.0 http://code.oseschool.com/index.php/archives/55 http://code.oseschool.com/index.php/archives/55#comments Wed, 26 Aug 2009 01:26:29 +0000 admin http://code.oseschool.com/?p=55 Servers->Tomcat 6.x(如果是Tomcat5.5版本则选择Tomcat5.x),点Browse后找到Tomcat6.0安装文件夹,点确定,并把Tomcat server设置为Enable,点Apply->OK! 部署j2ee项目： 1.点左边图标 2.选择要部署的项目：Hello,点Add 3.选择Server:Tomcat 6.x，点Finish（刚才配置的Tomcat) 4.出现如下画面：Deployment Status为Successfully deployed，说明部署成功，点ＯＫ！ 启动Tomcat： 点击右边的三角按钮,选择Tomcat 6.x->Start,如下图所示: 在控制台出现如下信息: Server startup in 6824 ms,说明Tomcat成功启动! ]]> 配置Tomcat6.0：

1.点Configure Server

2.如图所示：选择MyEclipse->Servers->Tomcat 6.x(如果是Tomcat5.5版本则选择Tomcat5.x),点Browse后找到Tomcat6.0安装文件夹,点确定,并把Tomcat server设置为Enable,点Apply->OK!

部署j2ee项目：

1.点左边图标

2.选择要部署的项目：Hello,点Add

3.选择Server:Tomcat 6.x，点Finish（刚才配置的Tomcat)

4.出现如下画面：Deployment Status为Successfully deployed，说明部署成功，点ＯＫ！

启动Tomcat：

点击右边的三角按钮,选择Tomcat 6.x->Start,如下图所示:

在控制台出现如下信息: Server startup in 6824 ms,说明Tomcat成功启动!

]]> http://code.oseschool.com/index.php/archives/55/feed 1 JDBC连接后使用篇 http://code.oseschool.com/index.php/archives/51 http://code.oseschool.com/index.php/archives/51#comments Mon, 24 Aug 2009 14:11:13 +0000 admin http://code.oseschool.com/?p=51 准备之一：你已经成功的获取了连接

准备之二：手头一定要有JDK-API

连接使用篇之statemment 与preparedstatement

大多数人都或多或少的听过这两个对象的传言，也应该有印象都是在告诫大家用preparedstatement更好，例如预编译效率快，安全性高，代码更具可读性云云。我们先来看这两个对象的用法（方便起见，我们先假设执行的都是无返回的sql语句，增 删 改）

Statement的使用

	/**
	 * Function : a demo for using Statement
	 *
	 * Product describe:
	 *
	 * @throws SQLException
	 * on Aug 23, 2009 BY Simrina
	 */
	public void sqlExcuteDemo() throws SQLException{
 
		//连接数据库
		this.connectDB();
 
		//当然你也可以换成insert into或者update ..
		String sql = "delete from user where uid = 1";
 
		//获取Statement对象用于执行Sql语句
		Statement stm = this.conn.createStatement();
 
		//执行就这么一句话，简单搞定
		stm.execute(sql);
 
		//好习惯，有开始，有关闭——当然关闭的时机，你可以选一个你认为更适合的
		stm.close();
		this.conn.close();
 
	}

2、PreparedStatement的使用

/**
	 * Function : a demo for using Statement
	 *
	 * Product describe:
	 *
	 * @throws SQLException
	 * on Aug 23, 2009 BY Simrina
	 */
	public void sqlExcuteDemo(int uid) throws SQLException{
 
		//连接数据库
		this.connectDB();
 
		//当然你也可以换成insert into或者update ..
		String sql = "delete from user where uid = ?";
 
		//获取PreparedStatement对象 
		PreparedStatement pstm = this.conn.prepareStatement(sql);
 
		//设置参数 注意设置参数的方法
		pstm.setInt(0, uid);
 
		//关闭
		pstm.close();
		this.conn.close();
 
	}

比较上面两个例子，首先需要注意：Statement和PreparedStatement的获取的方法是不一样的

最后特别关注PreparedStatement设置参数的方法。一般需要对应参数的类型，例如String 类型，则使用setString(parameterIndex,value),同理可证肯定还有setDouble setDate之类的。方法的第一个参数是参数的位置，换句话说，是你sql的问号的位子，从1开始，第一个参数则是参数的value。

所以注意，你可以给语句设置多个参数，当然要类型相对应。

现在我们来谈谈两者的区别，我们一开始说的为什么要推荐PreparedStatement

需要了解prepared的预编译，是需要数据库支持的，不过幸好大部分主流数据库都支持，除了mySQL。所谓的预编译，其实就是相同的Sql语句预先编译并保存起来，之后用到相同的，数据库直接调用已经编译好的语句，节约效率。因此，在相同的一次操作，两者并没有大的性能差异，反而prepared的开销更大一点。

针对有缓存预编译语句的DB而言，预编译的好处在于，如果同一时间有多个用户进行相同语句的操作，或者是打算进行大批量数据处理，或者有一些非常常用的SQL语句，预编译才能明显体现出效率来

最后说一个安全性，举个例子，如果想要查询用户名为Simrina’D的数据，如果你用“select * from user where username = ‘Simrina’D’”，肯定会出错，单引号会提前匹配掉，如果用setString,则可以完整匹配我们整个字符串——姑且当作抛砖引玉

最后，我们来做一个有返回值的查询例子，作为JDBC使用的补完Demo.这个时候不要忘了随时查看，我们准备的API。

	/**
	 * Function : 查询数据 
	 *
	 * Product describe: demo 的数据表 uid username
	 *									1 simrina'D
	 *									2 simrina
	 * @return
	 * @throws SQLException
	 * on Aug 24, 2009 BY Simrina
	 */
	public List excuteDemo() throws SQLException{
 
		//连接数据库
		this.connectDB();
 
		//当然你也可以换成insert into或者update ..
		String sql = "select * from user";
 
		List lst = new ArrayList();
 
		//获取Statement对象用于执行Sql语句
		Statement stm = this.conn.createStatement();
 
		//查询，返回ResultSet——关于ResultSet，自行查询API
		ResultSet rs = stm.executeQuery(sql);
 
		//取数据的简单demo
		while(rs.next()){
 
			String username = rs.getString("username");
			lst.add(username);
		}
 
		//好习惯，有开始，有关闭——当然关闭的时机，你可以选一个你认为更适合的
		stm.close();
		this.conn.close();
 
		return lst;
 
	}
]]> http://code.oseschool.com/index.php/archives/51/feed 1 JDBC连接数据库篇 http://code.oseschool.com/index.php/archives/44 http://code.oseschool.com/index.php/archives/44#comments Mon, 24 Aug 2009 13:59:42 +0000 admin http://code.oseschool.com/?p=44 Java Data Base Connectivity,JDBC——简单来说就是java连接数据库并执行SQL的API，当然不管什么数据库都一样。我们来看看链接代码：

/** @author Sinyee Simrina */
public class DBConnectDemo {
 
	private Connection conn;
 
	/**
	 * Function : just a jdbc connection DEMO
	 *
	 * Product describe: just a jdbc connection DEMO
	 *
	 * on Aug 21, 2009 BY Simrina
	 */
	public void connectDB() {
 
		//connncet messages
		String user = "root";
		String password = "root";
 
		//url for different DB  问题一：连接名是怎么构成的
		String url = "jdbc:mysql://localhost:3306/testDB";
 
		try {
			//driver for mySQL问题二：加载驱动的字符串到底什么意思？
			Class.forName("com.mysql.jdbc.Driver");			
 
			//问题三：为什么我没有用常用Class.forName("XXX").newInstance();
 
			try {
				conn = DriverManager.getConnection(url, user, password);
 
// TODO to do sth after connnect DB 后续问题：连接了数据之后怎么用
 
			} catch (SQLException e) {
 
				e.printStackTrace();
			}
		} catch (ClassNotFoundException e) {
 
			e.printStackTrace();
		}
	}
	}

问题一：连接名是怎么构成的

问题二：加载驱动的字符串到底什么意思？

问题三：为什么我没有用常用Class.forName(”XXX”).newInstance();

后续问题：连接了数据之后怎么用

搞清楚前三个问题，JDBC以后闭着眼睛也可以写出来了

JDBC 连接方式+数据库类别+对应数据库的连接url

所以除了mySQL:

我们看看其他数据库的连接讯息。。

//url = “jdbc:oracle:thin:@localhost:1521:testDB”;

//url = “jdbc:sqlserver://localhost:1433;DatabaseName=testDB”

Class.forName(”com.mysql.jdbc.Driver”); 其实很简单，看看图

jdbc配置

看懂了吧，所谓加载驱动就是找到对应的驱动class而已，不需要死记硬背。所以不要再问为什么sqlServer2000和2005的驱动字符串不一样了，微软刚好改变了Driver的存放的包的包名而已——下次发现ClassNotFoundException时候，直接看看你的classpath下有没有这个驱动——或者是驱动的包名类名是不是正确。

我们看看oracle/sqlserver的，现在知道为什么了吧

//Driver for ORACLE

//Class.forName(”oracle.jdbc.OracleDriver”);

//Driver for sqlSeriver2000

//Class.forName(”com.microsoft.jdbc.sqlserver.SQLServerDriver”);

//Driver for sqlSeriver2005

//Class.forName(”com.microsoft.sqlserver.jdbc.SQLServerDriver”);

为什么没有用常用Class.forName(”XXX”).newInstance();

newInstance方法的作用，是获取该驱动的一个实例，连接JDBC驱动只要加载就足够了，DriverManager就可以获取到连接

前三步做完了，不管哪一个数据库都可以获取到连接，不管是orcale还是sqlServer,DB2或者Sybase，当然写的时候不要忘记抛错。

]]> http://code.oseschool.com/index.php/archives/44/feed 0 SSH开发心得 http://code.oseschool.com/index.php/archives/42 http://code.oseschool.com/index.php/archives/42#comments Mon, 24 Aug 2009 13:53:12 +0000 admin http://code.oseschool.com/?p=42 前段时间开发一个J2EE的Web项目，使用SSH（Struts+Spring+hibernate）框架。开发过程中遇到一个相当郁闷的问题,困扰了我好几天。这里我跟大家分享一下。

问题是这样的：我用Spring的声明式事务管理来管理事务，当出现异常时能回滚事务。于是我做了一个测试，在一个方法里，我先添加了一条数据，然后再删除一条数据，在删除数据的时候我让它强行抛出异常，这时刚添加的那条数据应该回滚掉，可是我查看了一下数据库，发现数据已经插入，根本没有回滚，这是怎么回事呢？我的第一个反应就是Spring配置文件可能出问题了。

以下是我的Spring的事务管理的配置方式：

	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	<propertyname="sessionFactory"ref="sessionFactory"/>
	</bean>
 
	<bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
	<!--事务拦截器bean需要依赖注入一个事务管理器-->
	<property name="transactionManager"ref="transactionManager"/>
	<property name="transactionAttributes">
	<!--下面定义事务传播属性-->
	<props>
	<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
	<prop key="*">PROPAGATION_REQUIRED,-Exception</prop>
	</props>
	</property>
	</bean>
		<!--定义BeanNameAutoProxyCreator-->
		<bean
		class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
			<!--指定对满足哪些beanname的bean自动生成业务代理-->
			<property name="beanNames">
				<!--下面是所有需要自动创建事务代理的bean-->
				<list>
					<value>*Bo</value>
				</list>
				<!--此处可增加其他需要自动创建事务代理的bean-->
			</property>
			<!--下面定义BeanNameAutoProxyCreator所需的事务拦截器-->
			<property name="interceptorNames">
				<list>
					<!--此处可增加其他新的Interceptor-->
					<value>transactionInterceptor</value>
				</list>
			</property>
		</bean>

带着这个问题，我到网络上查了很多关于Spring配置事务的资料，也做了很多次修改，但问题仍然存在。我开始怀疑难道是Spring配置方式根本就是正确的。那这样的话问题到底出在哪里呢？为什么抛出异常后事务没有回滚呢？

快接近崩溃边缘的我还是硬着头皮继续在网络上求教，突然在一篇文章里看到这样一句话“Mysql表的MyISAM类型不支持事务处理，InnoDB类型提供事务支持”。我马上查了一下数据库的表类型，发现我的表就是MyISAM类型的，太兴奋了,难道就这样搞定了?于是我马上将表类型改成InnoDB，重启测试，问题解决。兴奋之余总结一下:原因就是我一直以为是Spring配置文件出问题了，却一直忽略了其他的情况。最后，将Mysql这两种表类型的详细对比跟大家分享一下。

InnoDB和MyISAM是MySQL最常用的表类型，各有各的优缺点，选用哪个视具体应用场景而定。

MyIASM:基于传统的IASM类型,ISAM是Indexed Sequential Access Method(有索引的顺序访问方法)的缩写,IASM是存储记录和文件的标准方法。与其他存储引擎比较,MyISAM具有检查和修复表的大多数工具。MyISAM表可以被压缩,而且它们支持全文搜索。它们不是事务安全的,而且也不支持外键。如果事物回滚将造成不完全回滚，不具有原子性。如果执行大量的SELECT，MyISAM是更好的选择。MyISAM对IASM有如下扩展：

二进制层次的可移植性。

NULL列索引。

对变长行比ISAM表有更少的碎片。

支持大文件。

更好的索引压缩。

更好的键码统计分布。

更好和更快的auto_increment处理。

InnoDB:它是事务安全的,与BDB类型具有相同的特性。它们支持外键。InnoDB表速度很快,具有比BDB还丰富的特性,因此如果需要一个事务安全的存储引擎,建议使用它。如果你的数据执行大量的INSERT或UPDATE,出于性能与事务方面的考虑，应该使用InnoDB类型的表。

以下是InnoDB与MyISAM细节和具体实现的差别：

InnoDB有它自己的缓冲池，能缓冲数据和索引，InnoDB把数据和索引存放在表空间里面，可能包含好几个文件，在MyISAM中，表被存放在单独的文件中，InnoDB表的大小只受限于操作系统文件的大小，一般为2GB。InnoDB不支持FULLTEXT类型的索引。

InnoDB支持行锁，提供和Oracle一样的一致性的不加锁读取，能增加并发读的用户数量并提高性能，不会增加锁的数量。另外，InnoDB表的行锁也不是绝对的，如果在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表，例如update table set num=1 where name like“%aaa%”。

InnoDB中不保存表的具体行数，也就是说，执行selectcount(*)fromtable时，InnoDB要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。要注意的是，当count(*)语句包含where条件时，两种表的操作是一样的。

对于AUTO_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中，可以和其他字段一起建立联合索引。

DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除。

LOAD TABLE FROM MASTER操作对InnoDB是不起作用的，解决方法是首先把InnoDB表改成MyISAM表，导入数据后再改成InnoDB表，但是对于使用的额外的InnoDB特性（例如外键）的表不适用。

任何一种表类型都不是万能的，只能针对具体的应用场景来选择合适的表类型，这样才能最大限度地发挥MySQL的性能。

]]> http://code.oseschool.com/index.php/archives/42/feed 0 J2EE开发三件宝: Domain Model(域建模)、patterns(模式)和framework(框架)。 http://code.oseschool.com/index.php/archives/40 http://code.oseschool.com/index.php/archives/40#comments Mon, 24 Aug 2009 13:49:59 +0000 admin http://code.oseschool.com/?p=40 J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B/S(Browser浏览器/Server服务器)结构，而J2EE主要是指B/S结构的实现。

J2EE是一个虚的大的概念，J2EE标准主要有三种子技术标准：WEB技术、EJB技术和JMS，谈到J2EE应该说最终要落实到这三个子概念上。

这三种技术的每个技术在应用时都涉及两个部分：容器部分和应用部分，Web容器也是指Jsp/Servlet容器，你如果要开发一个Web应用，无论是编译或运行，都必须要有Jsp/Servlet库或API支持(除了JDK/J2SE以外)。

Web技术中除了Jsp/Servlet技术外，还需要JavaBeans或Java Class实现一些功能或者包装携带数据，所以Web技术最初裸体简称为Jsp/Servlet+JavaBeans系统。

衡量J2EE应用系统设计开发水平高低的标准就是：解耦性;你的应用系统各个功能是否能够彻底脱离?是否不相互依赖，也只有这样，才能体现可维护性、可拓展性的软件设计目标。

了达到这个目的，诞生各种框架概念，J2EE框架标准将一个系统划分为WEB和EJB主要部分，当然我们有时不是以这个具体技术区分，而是从设计上抽象为表现层、服务层和持久层，这三个层次从一个高度将J2EE分离开来，实现解耦目的。

因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现

使用服务层框架可以将JavaBeans从Jsp/Servlet中分离出来，而使用表现层框架则可以将Jsp中剩余的JavaBeans完全分离，这部分JavaBeans主要负责显示相关，一般是通过标签库(taglib)实现，不同框架有不同自己的标签库，Struts是应用比较广泛的一种表现层框架。

这样，表现层和服务层的分离是通过两种框架达到目的，剩余的就是持久层框架了，通过持久层的框架将数据库存储从服务层中分离出来是其目的，持久层框架有两种方向：直接自己编写JDBC等SQL语句(如iBatis);使用O/R Mapping技术实现的Hibernate和JDO技术;当然还有EJB中的实体Bean技术。

持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架。

以本公司来说，完全是基于以上几点的考虑采用了如下架构：

表现层：Struts

持久层：Hibernate

服务层：Business Object

Struts完全体现了MVC思想，将一个应用分成三个基本部分：Model（模型）、View（视图）和Controller（控制器），这三个部分以最少的耦合协同工作，从而提高应用的可扩展性及可维护性。在数据库端使用了Hibernate，它使得与关系数据库打交道变得十分轻松，就像您的数据库中包含每天使用的普通Java对象一样，同时不必考虑如何把它们从神秘的数据库表中取出（或放回到数据库表中）。它解放了您，使您可以专注于应用程序的对象和功能，而不必担心如何保存它们或稍后如何找到它们。

最后，你的J2EE应用系统如果采取上面提到的表现层、服务层和持久层的框架实现，基本你也可以在无需深刻掌握设计模式的情况下开发出一个高质量的应用系统了。

还要注意的是: 开发出一个高质量的J2EE系统还需要正确的业务需求理解，那么域建模提供了一种比较切实可行的正确理解业务需求的方法，相关详细知识可从UML角度结合理解。

当然，如果你想设计自己的行业框架，那么第一步从设计模式开始吧，因为设计模式提供你一个实现JavaBeans或类之间解耦参考实现方法，当你学会了系统基本单元JavaBean或类之间解耦时，那么系统模块之间的解耦你就可能掌握，进而你就可以实现行业框架的提炼了，这又是另外一个发展方向了。

以上理念可以总结为一句话：

J2EE开发三件宝: Domain Model(域建模)、patterns(模式)和framework(框架)。

]]> http://code.oseschool.com/index.php/archives/40/feed 0 java获取文件夹下所有子文件夹 http://code.oseschool.com/index.php/archives/5 http://code.oseschool.com/index.php/archives/5#comments Tue, 18 Aug 2009 13:39:48 +0000 admin http://code.oseschool.com/?p=5 
import java.io.File;
public class travelAllFile {
	public static void main(String[] args) {
		String path ="E:/a";
		File f = new File(path);
		if(f.isDirectory()){
			new travelAllFile().getFileName(f);
		}
 
	}
	//递归查找函数，参数为file对象
	public void getFileName(File f){
		//File 数组
		File[] files = f.listFiles();
 
		for (int i = 0; i &lt; files.length; i++) {
			//递归出子目录
			if(files[i].isDirectory()){
				System.out.println("子目录是："+files[i].getName());
				getFileName(files[i]);
			//递归出子文件
			}else{
				System.out.println(files[i].getName());
			}
 
		}
	}
}

isDirectory()方法可以判断当前是否为文件夹

]]> http://code.oseschool.com/index.php/archives/5/feed 0