机械境-信永软件工程师培训学校

spring tips!

admin — Fri, 05 Mar 2010 02:40:29 +0000

1、关于Spring的xml配置文件，文件命名是否固定，文件位置可以放在什么地方？
文件名可以随便书写，只要是文件名就可以，不能包含特殊符号。文件位置可以放置在src，web路径，系统路径，ftp，http等。。只要可能是一个url就可以进行装载。
具体查看spring文档第四章的resource

2、在用xml配置bean的时候，用指定方法注入，方法参数为可变长的的可以不？
不可，属性注入只能为单一属性注入。
具体查看spring文档的3.3.1.2

3、注入数组？
使用list节点具体查看spring文档的3.3.2.4 collections

4、节点的local属性和name属性的区别？
local必须指定同一文件下的bean的id ，如果不为同一个xml文件会报错。
name为指定同一容器下或者父容器的bean的name（包含id）且可以不为同一个xml文件。
具体查看spring文档的3.3.2.2

5、关于监听器和事件（具体的题目没听清楚，记得是阎总问的）
applicationContext有5个默认事件，程序员也可以自定义事件和驱动事件，实现ApplicationEvent接口，和
使用ctx.publishEvent(event)方法。监听事件的类必须实现ApplicationListener接口，而且为spring管理的类。
具体查看spring文档的3.8.3

6、注解可以直接作用在属性上？注解都可以作用在什么地方？
根据不同的注解有不同的域，详细可以看java 注解的使用。注解可以使用在类，属性，方法等。

7、使用注解注入，scope是单例还是？
默认为单例，也可以是用@scope指定
具体查看spring文档的3.12.5

8、在xml配置的时候， exclude-filter 和include-filter 所是使用的表达式是同一个的时候，结果如何。（
具体的标签名我不知道，你自己补充完整下）

当加入一个bean和去除一个bean冲突的时候，去除一个bean为优先。
具体查看spring文档的3.12.3

9.如果一个bean是person，他在构造函数中注入自己（person对象）是不是不能注入。有时候在外部建了一个
person，赋值过去，spring可以吗？

在构造函数中注入自己是不行的，因为会导致死锁。
外部建了一个person是什么意思？

可以考虑这么做
在xml中配置两个person的bean ，比如 a 和b ， a需要注入一个person ， b 不要求注入person，这样子，就注入b就可以了，

10.属性注入时，能不能利用spring传参，在setter里做很多操作，这样子像印象了bean的规范，是不是可以骗
过spring，它只是传参。
可以，spring只是负责调用你的方法，把属性注入进去而已，你里面想写任何操作都可以，不影响javabean规
范，只要有setter方法就行。。

11.在工学项目里每次修改配置文件都需要重启tomcat，如果项目已上线，所有人都在用，又不得不改里头的类

1-》类2，那怎么办，配置文件不是在启动时就加载吗，spring可以设置修改xml的监听器吗。
第一个：现阶段的框架只能进行修改后重新启动，不过spring3.0已经实现了osgi，分模块管理，使用osgi就可
以实现模块的热插拔，不用重新启动服务器，如淘宝就是一个例子。如果我们想简单的实现的话，可以操作
webapplicationContext进行close和重新加载。。这个比较土。
第二个：现在spring还没有能直接扫描xml改变的组件，也没有这个事件，如果时间允许，也可以自己写个。
有兴趣可以去研究一下spring3.0。

12.spring事件方面可以补充讲下。
详细内容在spring文档的3.8.3，第三章，第8节的第三小节，application节下。

12.是否可以注入空值？若可以，注入空值，@request是什么效果。
可以注入空值。使用的话效果等于 setName(”) 。使用的话效果等于 setName(null);
@Required 注解不会报错，因为它只要有调用到方法就已经满足了。。不管是注入null还是”
详细内容查看spring文档的3.3.2.5

13.aop的原理，与hibernate的集成，在项目中是否常用
技术原理底层使用了AspectJ 组件。与hibernate的集成可以具体查看spring文档12.2
aop最常用使用在事务等。

14.spring 与 struts2.X的集成。

具体查看struts2文档的Plugin Developers Guide下的spring Plugin

JAVA正则表达式与 JS的正则表达式有何区别

admin — Fri, 05 Mar 2010 01:56:00 +0000

1.[a-z]在java中匹配一个英文字母。在javascript中，被测试字符串中包含一个英文字幕都被被接受。
2。[a-z]*java匹配纯英文字母。^[a-z]$在javascript中匹配纯英文字母。
主要区别为，一个正则表达式，在java中要求被测试字符串完全匹配，在javascript中要求，只要字符串中有一部分匹配就可以。
上边的这个结论对java和javascript中的理解不透彻：
javascript:
match和exec的函数的目的是找到字符串中，符合模式的字符串
match和exec找到尽可能多的字符串
对字符串!取得的是false，对null进行!取得的是true
而java直接得到的就是true或false。

关于javascript的正则表达式。
field.value.match(’[a-z]‘)与（Struts2 Validation这么使用的）
field.value.match([a-z])含义相同（有的资料上这么说的）
有的资料在讲的时候说正则表达式必须包含在\之间，有的没说。

关于转义字符
javascript
field = ‘_jimjimf112gds’
alert(field.match(/w+/))这样匹配所有字符串。但当使用”时，必须对\进行转义。也就是说 alert(field.match(’\w+’))匹配所有字符串。alert(field.match(’w+’))匹配的是w字母。这是因为字符串使用斜线作为转义字符。’w'中的被忽略。也就是：alert(field.match(’w+’))匹配的是w字母。这就体现出在使用\包含表达式时的优势了——不必转义
在java中也有字符串转义的问题：
System.out.println(Pattern.matches(’\w+’,'dfsasdf’));
为true，而System.out.println(Pattern.matches(’w+’,'dfsasdf’));是不能被编译的。

所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。
限定符可以指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。
定位符用于规定匹配模式在目标对象中的出现位置。

field = ‘jimwtoo,totooaztA3213142jimtof112gds’
alert(field.match(/[^a-c]+/))=jimwtoo,totoo
而alert(field.match(/[^a-c]/))=j
结论是：匹配尽可能多的字符串，是在含有+或*的情况下。

关于javascript优先级：
1．转义符
2．(), (?:), (?=), [] 圆括号和方括号
3．*, +, ?, {n}, {n,}, {n,m} 限定符
4．^, $, anymetacharacter 位置和顺序
5．|“或”操作

java的正则表达式

admin — Fri, 26 Feb 2010 03:47:33 +0000

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](那如果取反,就表示不是汉字咯)

SQL查询与优化

admin — Tue, 23 Feb 2010 03:14:51 +0000

精彩回答问题一:
exists的用法?
答:EXISTS的执行流程
select * from t1 where exists ( select null from t2 where y = x )
可以理解为:
for x in ( select * from t1 )
loop
if ( exists ( select null from t2 where y = x.x )
then
OUTPUT THE RECORD
end if
end loop
对于in 和 exists的性能区别:
如果子查询得出的结果集记录较少，主查询中的表较大且又有索引时应该用in,反之如果外层的主查询记录较少，子查询中的表大，又有索引时使用exists。
其实我们区分in和exists主要是造成了驱动顺序的改变（这是性能变化的关键），如果是exists，那么以外层表为驱动表，先被访问，如果是IN，那么先执行子查询，所以我们会以驱动表的快速返回为目标，那么就会考虑到索引及结果集的关系了
另外IN是不对NULL进行处理
如：
select 1 from dual where null in (0,1,2,null) 为空

精彩回答问题二:
如何处理空值排序?
答:
例:select * from emp order by comm desc nulls last(first);
使用nulls last,把将要排序的列,凡是空值的排在最后面
使用nulls first,把将要排序的列,凡是空值的排在最前面

精彩回答问题三:
如何得到当前行上一行或者下一行的数据?
答:
例:select ename,sal,lead(sal) over(order by sal) aaa ,lag(sal) over(order by sal) bbb from emp;
这些函数为oracle的窗口函数,在mysql不适用,但是mysql会有这种功能的函数吗??(疑问)

疑问一:如果没有索引,id!=0与id<0 or id>0,哪个速度更快?

疑问二:检索字符串与数值时,哪个速度比较快?例:dy=”1KV以下” and dy_2=1与 dy_2=1 and dy=”1KV以下”

———————update———————

B树索引速度的问题

我们都知道，用索引快，可是为什么快，到底会快多少？
比如：有100000条记录，需要定位name=‘yannaiyong’的这条记录，在没有索引的情况下，可能最大要查询10W次，才能定位到该记录，如果有了索引，最多要查询多少次？这样比较一下，就知道有索引和无索引查询速度不是同一个数量级的。
请问：如果有了索引，最多要查询多少次？同时讲解下B树索引定位或排序的原理？

———————update———————

若在索引列在使用函数或者进行计算，则在查询的时候，不会用到该索引。如：student表（id,name,age),在age字段上有索引。则
select * from student where age>30 (会用到索引）
select * from student where age-20>10(不会用到索引）

但如果在age字段上建立这样的索引
create index age_index on student(age-20);则：
select * from student where age-20>10(就会用到索引）

备注：在字段上建立这样的索引，需要比较高的权限。比如sys或者system

———————update———————

MYSQL没有查到有这样的函数。
在Oracle中，窗口函数其实还有很多，比如:sum(sal) over(),sum(sal) over(order by deptno),sum(sal) over(partition by deptno)等都存在细微差别，大家可以执行下，看看结果就知道差别了。

———————update———————

疑问一:如果没有索引,id!=0与id<0 or id>0,哪个速度更快?

回答：

没有索引，检索表都是全表扫描，速度并没有明显差别。

实验：

1000条的数据，用id!=0 用时17.1m
id<0 or id>0 用时16.8m

建议没有索引的情况，用id!=0,因为毕竟看起来比较舒服。

———————update———————

疑问二:检索字符串与数值时,哪个速度比较快?例:dy=”1KV以下” and dy_2=1与 dy_2=1 and dy=”1KV以下”

回答：

与上面的回答一样，没有索引的情况下。都是全表扫描，而Oracle在数据排序优化上已经比较成熟，检索字符串与数值，可能会有略微差别，但速度基本一致。

SQL的性能最重要的因素还是取决于是否有充分利用索引。

DOM4J官方快速入门（译文）中文详解

admin — Wed, 09 Sep 2009 01:32:17 +0000

官方地址：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

 version="1.0" encoding="gb2312"?>
 id="1111" fooname="test">
	 sn="01">>张三>>18>>
	 sn="02">>李四>>20>>
	 sn="03">小翁>
>

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

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

	 version="1.0" encoding="gb2312"?>
 id="1111" fooname="test">
	 sn="01">>张三>>18>>
	 sn="02">>李四>>20>>
	 sn="03">小翁>
>

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

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文件

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

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

注意：若要利用上述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);
		//判断是否是元素，如11即为元素
            if ( node instanceof Element ) {
                treeWalk( (Element) node );
            }
            else {
                // do something....打印元素中的文本内容
		System.out.println(node.getText());
            }
        }
	}

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

以下是：foo.xml

 version="1.0" encoding="gb2312"?>
 id="1111" fooname="test">
	 sn="01">>张三>>18>>
>

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

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

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

 id="1111" fooname="test">
	 sn="01">>张三>>18>>
>

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

 id="1111" fooname="test"> sn="01">>张三>>18>>>

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

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

 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 = " James ";
	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

 version="1.0" encoding="ISO-8859-1"?>
>
  >
    >Empire Burlesque>
    >Bob Dylan>
    >USA>
    >Columbia>
    >10.90>
    >1985>
  >
>

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

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 Collectionh2>
    <table border="1">
    <tr bgcolor="#9acd32">
      <th align="left">Titleth>
      <th align="left">Artistth>
    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 Collectionh2>
    <table border="1">
      <tr bgcolor="#9acd32">
        <th align="left">Titleth>
        <th align="left">Artistth>
      tr>
      <tr>
        <td>Empire Burlesquetd>
        <td>Bob Dylantd>
      tr>
    table>
  body>
html>
xml version="1.0" encoding="UTF-8"?>
<html><body><h2>My CD Collectionh2><table border="1"><tr bgcolor="#9acd32"><th align="left">Titleth><th align="left">Artistth>tr><tr><td>Empire Burlesquetd><td>Bob Dylantd>tr>table>body>html>

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

Java中的多维数组

admin — Thu, 27 Aug 2009 02:02:55 +0000

多维数组的声明：

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

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

但是我们在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 的多维数组也称之为数组中的数组。也就是最后一维的数组才是真正存具体值信息的地方。

MyEclipse6.0.1配置Tomcat6.0

admin — Wed, 26 Aug 2009 01:26:29 +0000

配置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成功启动!

鲜果来吧

admin — Mon, 24 Aug 2009 14:15:40 +0000

BANG67D9B58B528B0DDFCE678FE3XIANGUO

JDBC连接后使用篇

admin — Mon, 24 Aug 2009 14:11:13 +0000

准备之一：你已经成功的获取了连接

准备之二：手头一定要有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;
 
	}

JDBC连接数据库篇

admin — Mon, 24 Aug 2009 13:59:42 +0000

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”); 其实很简单，看看图

看懂了吧，所谓加载驱动就是找到对应的驱动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，当然写的时候不要忘记抛错。

机械境-信永软件工程师培训学校

spring tips!

JAVA正则表达式 与 JS的正则表达式有何区别

java的正则表达式

SQL查询与优化

DOM4J官方快速入门（译文）中文详解

Java中的多维数组

MyEclipse6.0.1配置Tomcat6.0

鲜果来吧

JDBC连接后使用篇

JDBC连接数据库篇

JAVA正则表达式与 JS的正则表达式有何区别