Jena 简介
一般来说，我们在Protege这样的编辑器里构建了本体，就会想在应用程序里使用它，这就需要一些开发接口。用程序操作本体是很必要的，因为在很多情况下，我们要自动生成本体，靠人手通过Protege创建所有本体是不现实的。Jena 是HP公司开发的这样一套API，似乎HP公司在本体这方面走得很靠前，其他大公司还在观望吗？
可以这样说，Jena对应用程序就像Protege对我们，我们使用Protege操作本体，应用程序则是使用Jena来做同样的工作，当然这些应用程序还是得由我们来编写。其实Protege本身也是在Jena的基础上开发的，你看如果Protege 的console里报异常的话，多半会和Jena有关。最近出了一个Protege OWL API，相当于对Jena的包装，据说使用起来更方便，这个API就是Protege
的OWL Plugin所使用的，相信作者经过OWL Plugin的开发以后，说这些话是有一定依据的。
题目是说用Jena处理OWL，其实Jena当然不只能处理OWL，就像Protege 除了能处理OWL外还能处理RDF(S)一样。Jena最基本的使用是处理RDF(S)，但毕竟OWL已经成为W3C的推荐标准，所以对它的支持也是大势所趋。
好了，现在来点实际的，怎样用Jena读我们用Protege创建的OWL本体呢，假设你有一个OWL本体文件（.owl），里面定义了动物类
（https://www.doczj.com/doc/066560662.html,/ont/Animal，注意这并不是一个实际存在的URL，不要试图去访问它），并且它有一些实例，现在看如下代码：
OntModel m = ModelFactory.createOntologyModel();
File myFile = ...;
m.read(new FileInputStream(myFile), "");
ResIterator iter = m.listSubjectsWithProperty(RDF.type, m.getResource("http:// https://www.doczj.com/doc/066560662.html,/ont/Animal"));
while (iter.hasNext()) {
Resource animal = (Resource) iter.next();
System.out.println(animal.getLocalName());
}
和操作RDF(S)不同，com.hp.hpl.jena.ontology.OntModel是专门处理本体（Ontology）的，它是com.hp.hpl.jena.rdf.model.Model的子接口，具有Model的全部功能，同时还有一些Model没有的功能，例如listClasses()、listObjectProperties()，因为只有在本体里才有“类”和“属性”的概念。
上面的代码很简单，从ModelFactory创建一个OntModel，从指定文件把模型读到内存里。再下面的代码是一个例子，作用是取出模型中所有Animal的实例（Individual，也叫个体），并打印它们的名称。要从OntModel里取实例，也可以用listIndividuals()方法，只不过你得在得到的实例中判断它们是不是Animal的实例，我觉得不如用上面这种简易查询的方式来得方便。
Jena里扩展了很多Iterator，比如ResIterator、StmtIterator和NodeIterator等等，刚开始用会觉得很别扭，好象还不如都用java标准的Iterator，不知道Jena的设计者是怎么考虑的。要熟练掌握还是得对整个Jena 的API有全局掌握才好。
在循环里，我们得到的每个元素都是一个Resource，因为本体里的任何东西都是资源，不论你想得到Subject、Property还是Object，在Jena里实际得到的都是资源（Resource），在Jena里，Property是Resource的子接口，而Jena并没有Subject或Object接口。（注：在OWL本体中，
Subject->Property->Object组成一个三元组，例如：张小刚->父亲->张大刚；或者：绵羊多利->rdf:type->动物，rdf:type是一个特殊的属性，表示前者是后者的实例）
暂时先写到这，关于在本体中引入其他本体和使用推理，下次继续。
本文简单介绍Jena（Jena 2.4），使用Protégé 3.1（不是最新版本）创建一个简单的生物（Creature）本体，然后参照Jena文档中的一个例子对本体进行简单的处理，输出本体中的Class、Property等信息。
本文内容安排如下：
?介绍Jena
?运行Jena
?Jena Ontology API
?例子
?参考资料
一、介绍Jena
Jena由HP Labs（https://www.doczj.com/doc/066560662.html,）开发的Java开发工具包, 用于Semantic Web(语义网)中的应用程序开发；Jana是开源的，在下载的文档中有Jena的完整代码。J ena框架主要包括:
a)以RDF/XML、三元组形式读写RDF
资源描述框架是(RDF)是描述资源的一项标准(在技术上是W3C的推荐标准)，Jena文档中有一部分呢详细介绍了RDF和Jena RDF API，其内容包括对Jena RDF包的介绍、RDF模型的创建、读写、查询等操作，以及RDF容器等的讨论。
b)RDFS，OWL，DAML+OIL等本体的操作
Jena框架包含一个本体子系统（Ontology Subsystem），它提供的API允许处理基于RDF的本体数据，也就是说，它支持OWL，DAML+OIL和RDFS。本体API与推理子系统结合可以从特定本体中提取信息，Jena 2还提供文档管理器（OntDocumentManager）以支持对导入本体的文档管理。
c)利用数据库保存数据
Jena 2允许将数据存储到硬盘中，或者是OWL文件，或者是关系数据库中。本文处理的本体就是OWL文件读入的。
d)查询模型
Jena 2提供了ARQ查询引擎，它实现SPARQL查询语言和RDQL，从而支持对模型的查询。另外，查询引擎与关系数据库相关联，这使得查询存储在关系数据库中的本体时能够达到更高的效率。
e)基于规则的推理
Jena 2支持基于规则的简单推理，其推理机制支持将推理器(inference reasoners)导入Jena，创建模型时将推理器与模型关联以实现推理。
Protégé是一个开源的本体编辑器（目前的版本是Protégé 3.2），用户可以在GUI环境下创建本体或者知识库。有一种说法是：Jena对应用程序就像Protégé对我们——我们使用Protégé操作本体，应用程序则是使用Jena来做同样的工作。当然这些应用程序还是得由我们来编写。
二、运行Jena
可以在Jena的主页（https://www.doczj.com/doc/066560662.html,/downloads.html）下载Jena的最新版本，目前是Jena2.4版本。Jena是Java API，所以需要Java运行环境。本文使用的是jdk1.5.0_04和Eclipse3.2。
将下载的Jena-2.4.zip解压到任意路径，解压之后生成Jena2.4文件夹，将Jena2.4 l ib下的jar文件全部加入CLASSPATH，这样就可以在任意的Java编辑器中调用Jena AP I了。在解压目录下有一个test.bat文件，用于配置的测试。在控制台运行此程序，如果你的配置正确，测试将顺利完成。
G:\jade\lib\jade.jar;G:\jade\lib\iiop.jar;G:\jade\lib\commons-codec\commons-codec-1.
3.jar;G:\jade\lib\javaTools.jar;G:\jade\lib\http.jar;G:\jena\lib\antlr-2.7.5.jar;G:\jena\lib\arq.ja r;G:\jena\lib\arq-extra.jar;G:\jena\lib\commons-logging-1.1.jar;G:\jena\lib\concurrent.jar;G: \jena\lib\icu4j_3_
4.jar;G:\jena\lib\iri.jar;G:\jena\lib\jena.jar;G:\jena\lib\jenatest.jar;G:\jena\li b\json.jar;G:\jena\lib\junit.jar;G:\jena\lib\alog4j-1.2.12.jar;G:\jena\lib\lucene-core-2.0.0.jar; G:\jena\lib\stax-api-1.0.jar;G:\jena\lib\wstx-asl-3.0.0.jar;G:\jena\lib\xercesImpl.jar;G:\jena\li b\xml-apis.jar
如果使用Eclipse，则可以通过修改工程的Java创建路径的方法导入Jena jar文件。在Eclipse下创建Java工程，右健单击工程名字，选择“属性/Properties”，在打开的对话框中选择“Java创建路径/Java Build Path”，在右边标签中选择“库/Libraries”,之后选择“添加外部文件/Add Extenal JARs”，找到Jena2.4 lib目录下的所有jar文件并将其添加到工程。这样就可以运行Jean文档中的例子了。
三、Jena Ontology API
Jena2.4的Ontology API包含在ontology包（com.hp.hpl.jena.ontology）中，可以在目录Jena-2.4 src com hp hpl jena ontology下查看所有程序的代码，Jena本体部分的说明网页是Jena-2.4 doc ontology index.html,本部分内容以及程序的编写主要参考这两个文档。
在语义网上有很多表示本体信息的本体语言，其中表达能力最强的是OWL，OWL按复杂程度分为OWL Full、OWL DL和OWL Lite三个版本。其他的本体语言还有RDFS、DAML+OIL。Jena Ontology API为语义网应用程序开发者提供了一组独立于具体语言的一致编程接口。
Jena提供的接口本质上都是Java程序，也就是.java文件经过javac之后生成的.class 文件。显然，class文件并不能提示本体创建使用的语言。为了区别于其他的表示方法，每种本体语言都有一个自己的框架（profile），它列出了这种语言使用的类（概念）和属性的构建方式和URI。因此，在DAML框架里，对象属性（）的URI是daml:ObjectProperty，而在OWL框架里却是owl:ObjectProperty。RDFS并没有定义对象属性，所以在RDFS框架里，对象属性的URI是null。
在Jena中，这种框架通过参数的设置在创建时与本体模型（Ontology Model）绑定在一起。本体模型继承自Jena中的Model类。Model允许访问RDF数据集合中的陈述（St atements），OntModel对此进行了扩展，以便支持本体中的各种数据对象：类（classes）、属性（properties）、实例（个体individuals）。
本部分简单介绍要用到的几个java类或者接口。
1．本体模型OntModel
本体模型（OntModel）是对Jena RDF模型的扩展（继承自RDF模型），提供了处理本体数据的功能。使用Jena处理本体首先就是要建立一个本体模型，之后就能够通过本体模型中所定义的方法操作模型，比如导入子模型（）、获取模型中本体的信息、操作本体属性以及将本体的表示输出到磁盘文件等等。Jena通过model包中的ModelFactory创建本体模型，ModelFactory是Jena提供用来创建各种模型的类，在类中定义了具体实现模型的成员数据以及创建模型的二十多种方法。一个最简单的创建本体模型的语句如下：OntModel ontModel = ModelFactory.createOntologyModel();
该语句不含参数，应用默认设置创建一个本体模型ontModel，也就是说：它使用OWL 语言、基于内存，支持RDFS推理。可以通过创建时应用模型类别（OntModelSpec）参数创建不同的模型，以实现不同语言不同类型不同推理层次的本体操作。例如，下面的语句创建了一个使用DAML语言内存本体模型。直观地讲，内存模型就是只在程序运行时存在的模型，它没有将数据写回磁盘文件或者数据库表。
OntModel ontModel = ModelFactory.createOntologyModel( OntModelSpec.DAML_ME M );
更多类型设置可以参照OntModelSpec类中的数据成员的说明。
我们所使用的本体是从OWL文件获得的，也就是说，是从磁盘读取的。读取的方法是调用Jena OntoModel提供的Read方法。例如
ontModel.read("file:D:/temp/Creatrue/Creature.owl");
就是读取位于D盘相应目录下的Creature.owl文件以建立本体模型。Read方法也有很多重载，上面调用的方法以文件的绝对路径作为参数。其他的方法声明如下
r ead( String url );
read( Reader reader, String base );
read( InputStream reader, String base );
read( String url, String lang );
read( Reader reader, String base, String Lang );
read( InputStream reader, String base, String Lang );
2．文档管理器Document manager
本体文档管理器（OntDocumentManager）是用来帮助管理本体文档的类，它包含了导入本体文档创建本体模型、帮助缓存下载网络上的本体等功能。每个本体模型都有一个相关联的文档管理器。在创建本体模型时，可以创建独立的文档管理器并作为参数传递给模型工厂（ModelFactory）。文档管理器有非常多的配置选项，基本可以满足应用的需求。首先，每个文档管理器的参数都可以通过Java代码来设置（注：OntDocumentManager有五种重载的构造函数）。另外，文档管理器也可以在创建的时候从一个RDF格式的策略文件读取相应设定值。
下面的例子创建一个文档管理器并将它与以创建的本体模型关联。
OntModel m = ModelFactory.createOntologyModel();
OntDocumentManager dm = m.getDocumentManager();
(续)——见“对Jena的简单理解和一个例子_2”
RDF 越来越被认为是表示和处理半结构化数据的一种极好选择。本文中，Web 开发人员Philip McCarthy 向您展示了如何使用Jena Semantic Web Toolkit，以便在Java 应用程序中使用RDF 数据模型。
“资源描述框架（Resource Description Framework，RDF）”最近成为W3C 推荐标准，与XML 和SOAP 等Web 标准并排。RDF 可以应用于处理特殊输入数据（如CRM）的领域，已经广泛用于社会网络和自助出版软件（如LiveJournal 和TypePad）。
Java 程序员将越来越多地得益于具有使用RDF 模型的技能。在本文中，我将带您体验惠普实验室的开放源代码Jena Semantic Web Framework（请参阅参考资料）的一些功能。您将了解如何创建和填充RDF 模型，如何将它们持久存储到数据库中，以及如何使用R DQL 查询语言以程序方式查询这些模型。最后，我将说明如何使用Jena 的推理能力从本体推断模型知识。
本文假设您已经就图形、三元组和模式等概念方面对RDF 比较熟悉，并对Java 编程有基本的了解。
创建简单的RDF 模型
我们从基本操作开始：从头创建模型并向其添加RDF 语句。本节，我将说明如何创建描述一组虚构家庭成员之间关系的模型，如图 1 中所示：
图 1. 虚拟家庭树
将使用来自“关系”词汇表（请参阅参考资料）的属性s i b l i n g O f、s p o u s e O f、p a r e n t O f和c h i l d O f来描述不同的关系类型。为简单起见，家庭成员用来自虚构名称空间的URI（h t t p://f a m i l y/）进行标识。词汇表URI 通常以Jena 代码形式使用，所以将它们声明为Java 常量会非常有用，减少了错误输
入。
Schemagen
当您通过Jena 的API 来使用模
型时，为模型词汇表中的每个属性
定义常量非常有用。如果有词汇表
的RDF、DAML 或OWL 表示，
Jena 的Schemagen 工具可以
自动生成这些常量，使您的工作更
加容易。
Schemagen 在命令行中运行，使
用的参数包括模式或本体文件的
位置、要输出的类的名称和Java
包。然后可以导出生成的Java
类，其P r o p e r t y常量用于访问
模型。
还可以使用Ant 将Schemagen
作为构建处理的一部分来运行，保
持Java 常量类与正在变化的词
Jena 的M o d e l F a c t o r y类是创建不同类型模型的
汇表保持同步。
首选方式。在这种情况下，您想要空的、内存模型，
所以要调用的方法是M o d e l F a c t o r y.c r e a t e D e f a u l t M o d e l()。这种方法返回M o d e l 实例，您将使用它创建表示家庭中每个成员的R e s o u r c e。创建了资源后，可以编写关于这些资源的语句并添加到模型中。
在Jena 中，语句的主题永远是R e s o u r c e，谓词由P r o p e r t y表示，对象是另一个R e s o u r c e或常量值。常量在Jena 中通过L i t e r a l类型表示。所有这些类型共享公共接口R D F N o d e。将需要四个不同的P r o p e r t y实例表示家庭树中的关系。这些实例使用M o d e l.c r e a t e P r o p e r t y()创建。
将语句添加到模型中的最简单方法是通过调用R e s o u r c e.a d d P r o p e r t y()。此方法以R e s o u r c e作为主题在模型中创建语句。该方法使用两个参数，表示语句谓词的P r o p e r t y 和语句的对象。a d d P r o p e r t y()方法被过载：一个过载使用R D F N o d e作为对象，所以可以使用R e s o u r c e或L i t e r a l。还有有益过载，它们使用由Java 原语或S t r i n g 表示的常量。在示例中，语句的对象是表示其他家庭成员的R e s o u r c e。
通过使用三元组的主题、谓词和对象调用M o d e l.c r e a t e S t a t e m e n t()，还可以直接在模型上创建语句。注意以此种方式创建S t a t e m e n t不将其添加到模型中。如果想将其添加到模型中，请使用创建的S t a t e m e n t调用M o d e l.a d d()，如清单 1 所示：
清单 1. 创建模型来表示虚构的家庭
//U R I d e c l a r a t i o n s
S t r i n g f a m i l y U r i="h t t p://f a m i l y/";
S t r i n g r e l a t i o n s h i p U r i="h t t p://p u r l.o r g/v o c a b/r e l a t i o n s h i p/";
//C r e a t e a n e m p t y M o d e l
M o d e l m o d e l=M o d e l F a c t o r y.c r e a t e D e f a u l t M o d e l ();
//C r e a t e a R e s o u r c e f o r e a c h f a m i l y m e m b e r, i d e n t i f i e d b y t h e i r
U R I R e s o u r c e a d a m=m o d e l.c r e a t e R e s o u r c e(f a m i l y U r i+"a d a m");
R e s o u r c e b e t h=m o d e l.c r e a t e R e s o u r c e(f a m i l y U r
i+"b e t h");
R e s o u r c e c h u c k=m o d e l.c r e a t e R e s o u r c e(f a m i l y U r i+"c h u c k");
R e s o u r c e d o t t y=m o d e l.c r e a t e R e s o u r c e(f a m i l y U r i+"d o t t y");
//a n d s o o n f o r o t h e r f a m i l y m e m b e r s
//C r e a t e p r o p e r t i e s f o r t h e d i f f e r e n t t y p e s o f r e l a t i o n s h i p t o r e p r e s e n t
P r o p e r t y c h i l d O f=m o d e l.c r e a t e P r o p e r t y(r e l a t i o n s h i p U r i,"c h i l d O f");
P r o p e r t y p a r e n t O f=m o d e l.c r e a t e P r o p e r t y(r e l a t i o n s h i p U r i,"p a r e n t O f");
P r o p e r t y s i b l i n g O f=m o d e l.c r e a t e P r o p e r t y(r e l a t i o n s h i p U r i,"s i b l i n g O f");
P r o p e r t y s p o u s e O f=m o d e l.c r e a t e P r o p e r t y(r e l a t i o n s h i p U r i,"s p o u s e O f");
//A d d p r o p e r t i e s t o a d a m d e s c r i b i n g r e l a t i o n s h i p s t o o t h e r f a m i l y m e m b e r s
a d a m.a d d P r o p e r t y(s i
b l i n g O f,b e t h);
a d a m.a d d P r o p e r t y(s p o u s e O f,d o t t y);
a d a m.a d d P r o p e r t y(p a r e n t O f,e d w a r d);
//C a n a l s o c r e a t e s t a t e m e n t s d i r e c t l y...
S t a t e m e n t s t a t e m e n t=m o d e l.c r e a t e S t a t e m e n t(a d a m,p a r e n t O f,f r a n);
//b u t r e m e m b e r t o a d d t h e c r e a t e d s t a t e m e n t t o t h e m o d e l
m o d e l.a d d(s t a t e m e n t);
整个代码示例FamilyModel.java 还说明了语句批量如何一次添加到模型中，或者作为一个数组或者作为j a v a.u t i l.L i s t。
构建了家庭模型后，我们看一下如何使用Jena 的查询API 从模型中提取信息。
查询RDF 模型
程序化地查询Jena 模型主要通过l i s t()方法在M o d e l和R e s o u r c e接口中执行。可以使用这些方法获得满足特定条件的主题、对象和S t a t e m e n t。它们还返回j a v a.u t i l.
I t e r a t o r的特殊化，其具有返回特定对象类型的其他方法。
我们返回清单1的家庭模型，看一下可以查询它的不同方法，如清单 2 所示：
清单 2. 查询家庭模型
//L i s t e v e r y o n e i n t h e m o d e l w h o h a s a c h i l d:
R e s I t e r a t o r p a r e n t s=m o d e l.l i s t S u b j e c t s W i t h P r o p e r t y(p a r e n t O f);
//B e c a u s e s u b j e c t s o f s t a t e m e n t s a r e R e s o u r c e s,t h e m e t h o d r e t u r n e d a R e s I t e r a t o r
w h i l e(p a r e n t s.h a s N e x t()){
//R e s I t e r a t o r h a s a t y p e d n e x t R e s o u r c e()m e t h o d
R e s o u r c e p e r s o n=p a r e n t s.n e x t R e s o u r c e();
//P r i n t t h e U R I o f t h e r e s o u r c e
S y s t e m.o u t.p r i n t l n(p e r s o n.g e t U R I());}
//C a n a l s o f i n d a l l t h e p a r e n t s b y g e t t i n g t h e o b j e c t s o f a l l"c h i l d O f"s t a t e m e n t s
//O b j e c t s o f s t a t e m e n t s c o u l d b e R e s o u r c e s o r l i t e r a l s,s o t h e I t e r a t o r r e t u r n e d
//c o n t a i n s R D F N o d e s
N o d e I t e r a t o r m o r e P a r e n t s=m o d e l.l i s t O b j e c t s O f P r o p e r t y(c h i l d O f);
//T o f i n d a l l t h e s i b l i n g s o f a s p e c i f i c p e r s o n,t h e m o d e l i t s e l f c a n b e q u e r i e d
N o d e I t e r a t o r s i b l i n g s=m o d e l.l i s t O b j e c t s O f P r o p e r t y(e d w a r d,s i b l i n g O f);
//B u t i t's m o r e e l e g a n t t o a s k t h e R e s o u r c e d i r e c t l y
//T h i s m e t h o d y i e l d s a n i t e r a t o r o v e r S t a t e m e n t s
S t m t I t e r a t o r m o r e S i b l i n g s=e d w a r d.l i s t P r o p e r t i e s(s i b l i n g O f);
最通用的查询方法是M o d e l.l i s t S t a t e m e n t s(R e s o u r c e s,P r o p e r t y p,R D F N o d e o)，下面说明的便利方法都是以其为基础。所有这些参数都可以保留为n u l l，在这种情况下，它们作为通配符，与任何数据都匹配。清单3 中显示了M o d e l.l i s t S t a t e m e n t s()的一些使用示例：
清单 3. 使用选择器查询模型
//F i n d t h e e x a c t s t a t e m e n t"a d a m i s a s p o u s e o f d o t t y"
m o d e l.l i s t S t a t e m e n t s(a d a m,s p o u s e O f,d o t t y);
//F i n d a l l s t a t e m e n t s w i t h a d a m a s t h e s u b j e c t a n d d o t t y a s t h e o b j e c t
m o d e l.l i s t S t a t e m e n t s(a d a m,n u l l,d o t t y);
//F i n d a n y s t a t e m e n t s m a d e a b o u t a d a m
m o d e l.l i s t S t a t e m e n t s(a d a m,n u l l,n u l l);
//F i n d a n y s t a t e m e n t w i t h t h e s i b l i n g O f p r o p e r t y
m o d e l.l i s t S t a t e m e n t s(n u l l,s i b l i n g O f,n u l l);
导入和持久化模型
不是所有的应用程序都从空模型开始。更常见的是，在开始时从现有数据填充模型。在这种
情况下，使用内存模型的缺点是每次启动应用程序时都要从头重新填充模型。另外，每次关闭应用程序时，对内存模型进行的更改都将丢失。
一种解决方案是使用M o d e l.w r i t e()序列化模型到文件系统，然后在开始时使用M o d e l. r e a d()将其取消序列化。不过，Jena 还提供了持久化模型，它们会被持续而透明地持久
存储到后备存储器。Jena 可以在文件系统中或在关系数据库中持久化它的模型。当前支持
的数据库引擎是PostgreSQL、Oracle 和MySQL。
WordNet
WordNet 是“英文语言的词汇数据
库”。我使用的是Sergey Melnik
和Stefan Decker 的RDF 表
示。它具有四个单独的模型，本文
示例中将使用其中三个模型。
WordNet-nouns 模型包含Word
Net 表示的所有“词汇概念”和用于
表示每个概念的“单词形式”。例如，
它包含由单词形式“domestic do
g”、“dog”和“Canis familiaris”表示
的词汇概念。
第二个模型是WordNet-glossar
y。它提供模型中每个词汇概念的
为了说明如何导入和持久化模型，我将 WordNet 1.6 数据库的 RDF 表示导入到 MySQL 中。因为我使用的 WordNet 表示采用多个单独 RDF 文档的形式，将这些文档导入到一个 Jena 模型中会合并它们的语句。 图 2 说明了 Nouns 和 Glossary 模型合并后 WordNet 模型的片段的结构：
图 2. 合并的 WordNet nouns 和 glossary 模型的结构
创建数据库后台模型的第一步是说明 MySQL 驱动类，并创建 D B C o n n e c t i o n 实例。 D B C o n n e c t i o n 构造函数使用用户的 ID 和密码登录到数据库。它还使用包含 Jena 使用的 MySQL 数据库名称的数据库 URL 参数，格式为 "j d b c :m y s q l ://l o c a l h o s t /d b n a m e " 。Jena 可以在一个数据库内创建多个模型。 D B C o n n e c t i o n 的最后一个参数是数据库类型，对于 MySQL ，该参数为 "M y S Q L "
。 然后 D B C o n n e c t i o n 实例可以与 Jena 的 M o d e l F a c t o r y 一起使用来创建数据库后台模型。
创建了模型后，可以从文件系统中读入 WordNet RDF 文档。不同的 M o d e l .r e a d () 方法可以从 R
e a d e r 、 I n p u t S t r e a m 或 U R L 填充模型。可以通过 Notation3 、N-Triples 或默认情况下通过 RDF/XML 语法解析模型。WordNet 作为 RDF/XML 进行序列化，所以不需要指定语法。读取模型时，可以提供基准 URI 。基准 URI 用于将模型中的任何相对
简短定义。“dog”的词汇概念具有词汇条目“a member of the genus Canis (probably descended fro m the common wolf) that has been domesticated by man sin ce prehistoric times.”
WordNet-hyponyms 是第三个模型。它定义模型中概念的层次结构。概念“dog”是概念“canine”下位词，而“canine” 本身是概念“carni vore”的下位词。
URI 转换成绝对URI。因为WordNet 文档不包含任何相对URI，所以此参数可以指定为n u l l。
清单 4 显示了将WordNet RDF/XML 文件导入到MySQL 持久化模型的完整过程：
清单 4. 导入和持久化WordNet 模型
//I n s t a n t i a t e t h e M y S Q L d r i v e r
C l a s s.f o r N a m e("c o m.m y s q l.j d b c.
D r i v e r");
//C r e a t e a d a t a b a s e c o n n e c t i o n o b j e c t
D B C o n n e c t i o n c o n n e c t i o n=n e w D B C o n n e c t i o n(D B _U R L,D B_U S
E R,D B_P A S S W O R D,D B_T Y P E);
//G e t a M o d e l M a k e r f o r d a t a b a s e-b a c k e d m o d e l s
M o d e l M a k e r m a k e r=M o d e l F a c t o r y.c r e a t e M o d e l R D B M a k e r(c o n n e c t i o n);
//C r e a t e a n e w m o d e l n a m e d"w o r d n e t."S e t t i n g t h e s e c o n d p a r a m e t e r t o"t r u e"c a u s e s a n
//A l r e a d y E x i s t s E x c e p t i o n t o b e t h r o w n i f t h e d b a l r e a d y h a s a m o d e l w i t h t h i s n a m e
M o d e l w o r d n e t M o d e l=m a k e r.c r e a t e M o d e l("w o r d n e t",t r u e);
//S t a r t a d a t a b a s e t r a n s a c t i o n.W i t h o u t o n e, e a c h s t a t e m e n t w i l l b e a u t o-c o m m i t t e d
//a s i t i s a d d e d,w h i c h s l o w s d o w n t h e m o d e l i m p o r t s i g n i f i c a n t l y.
m o d e l.b e g i n();
//F o r e a c h w o r d n e t m o d e l...
I n p u t S t r e a m i n=t h i s.g e t C l a s s().g e t C l a s s L o a d e r().g e t R e s o u r c e A s S t r e a m(f i l e n a m e);
m o d e l.r e a d(i n,n u l l);
//C o m m i t t h e d a t a b a s e t r a n s a c t i o n m o d e l.
c o m m i t();
由于已经填充了wordnet 模型，以后可以通过调用M o d e l M a k e r.o p e n M o d e l("w o r d n e t ",t r u e);来访问该模型。
仅使用Jena 的API 查询像WordNet 这样巨大的模型将有一定的限制性，因为要执行的每类查询都将需要专门编写多行的代码。幸运的是，Jena 以RDQL 形式提供了一种表达通用查询的机制。
RDF 数据查询语言（RDQL）
RDQL 是RDF 的查询语言。虽然RDQL 还不是正是的标准，但已由RDF 框架广泛执行。RDQL 允许简明地表达复杂的查询，查询引擎执行访问数据模型的繁重工作。RDQL 的语法表面上类似SQL 的语法，它的一些概念对已经使用过关系数据库查询的人来说将比较熟悉。在Jena Web 站点中可以找到极好的RDQL 指南，但几个简单的示例会对说明基础知识大有帮助。
使用j e n a.r d f q u e r y工具可以在命令行上对Jena 模型执行RDQL 查询。RDFQuery 从文本文件中获取RDQL 查询，然后对指定的模型运行该查询。对数据库后台模型运行查询需要相当多的参数。清单 5 中显示了运行下列示例需要的完整命令行：
清单 5. 从命令行运行RDQL 查询
$j a v a j e n a.r d f q u e r y--d a t a j d b c:m y s q l://l o c a l h o s t/j e n a--u s e r d b u s e r --p a s s w o r d d b p a s s
--d r i v e r c o m.m y s q l.j d b c.D r i v e r--d b T y p e M y S Q L --d b N a m e w o r d n e t--q u e r y e x a m p l e_q u e r y.r d q l
正如您看到的，这些参数中的大多数参数都提供了创建与MySQL 的连接所需的详细信息。其中重要的部分是--q u e r y e x a m p l e_q u e r y.r d q l，它是RDQL 文件的位置。还要注意运行j e n a.r d f q u e r y需要Jena 的lib 目录中的所有JAR 文件。
清单 6 显示了您将检查的第一个查询：
清单 6. 查找“domestic dog”的WordNet 词汇条目的RDQL 查询
S E L E C T
?d e f i n i t i o n
W H E R E
(?c o n c e p t,
(?c o n c e p t,
U S I N G
w n F O R
S E L E C T部分声明查询要输出的变量— 在本例中，是名为d e f i n i t i o n的变量。W H E R E子句引入第二个变量c o n c e p t并定义与图形匹配的三元组。查询在具有W H E R E子句中的所有三元组的图形中查找语句。所以，在英语中，W H E R E子句的意思为“查找具有'dom estic dog' 作为单词形式的概念，并查找这些概念的词汇条目”，如图3 所示。U S I N G子句提供一种便利，用于声明名称空间的前缀。
图 3. 清单 6 中的WHERE 子句匹配的图形
运行查询的结果为：
d e f i n i t i o n
============================================= ==================================
"a m e m b e r o f t h e g e n u s C a n i s(p r o b a b l y d e s c e n d e d f r o m t h e c o m m o n w o l f)t h a t h a s
b e e n d o m e s t i
c a t e
d b y m a n s i n c
e p r e h i s t o r i c t i m e s;o c c u r s i n m a n y b r e e d s;"t h e
d o g b a r k
e d a l l n i g h t""
所以这种情况仅有一个结果。清单7 中显示的下个查询的意思为“查找单词'bear' 表示的概念，并查找这些概念的词汇条目”。
清单7. 查找“bear”的WordNet 词汇条目的RDQL 查询
S E L E C T
?d e f i n i t i o n
W H E R E
(?c o n c e p t,
(?c o n c e p t,
U S I N G
w n F O R
此查询返回15 个结果，因为此单词形式表示多个不同的概念。结果为：
d e f i n i t i o n
============================================= ==================================
"m a s s i v e p l a n t i g r a d e c a r n i v o r o u s o r o m n i v o r o u s m a m m a l s w i t h l o n g s h a g g y c o a t s
a n d s t r o n g c l a w s"
"a n i n v e s t o r w i t h a p e s s i m i s t i c m a r k e t o u t l o o
k"
"h a v e o n o n e's p e r s o n;"H e w o r e a r e d r i b b o n ";"b e a r a s c a r""
"g i v e b i r t h(t o a n e w b o r n);"M y w i f e h a d t w i n s y e s t e r d a y!""
清单8 中显示了另一个示例，查找其他两个单词的上位词（母词）：
清单8. 查找“panther”和“tiger”的WordNet 上位词的RDQL 查询
S E L E C T
?w o r d f o r m,?d e f i n i t i o n
W H E R E
(?f i r s t c o n c e p t,
(?s e c o n d c o n c e p t,
(?f i r s t c o n c e p t,
(?s e c o n d c o n c e p t,
(?h y p e r n y m,
(?h y p e r n y m,
U S I N G
w n F O R
此处，查询的意思是“查找单词'panther' 和'tiger' 所指的概念；查找第三个概念，前两个概念是其下位词；查找第三个概念的可能的单词和词会条目”，如图 4 所示：
图 4. 清单8 中WHERE 子句匹配的图形
w o r d f o r m和d e f i n i t i o n都在S E L E C T子句中声明，所以它们都是输出。尽管词查询仅匹配了一个WordNet 概念，查询的图形可以以两种方式匹配，因为该概念有两个不同的单词形式：
w o r d f o r m|d e f i n i t i o n
============================================= ========================================
"b i g c a t"|"a n y o f s e v e r a l l a r g e c a t s t y p i c a l l y a b l e t o r o a r a n d l i v i n g i n t h e w i l d"
"c a t"|"a n y o f s e v e r a l l a r g e c a t s t y p i c a l l y a b l e t o r o a r a n d l i v i n g i n t h e w i l d"
使用Jena 中的RDQL
Jena 的c o m.h p.h p l.j e n a.r d q l包包含在Java 代码中使用RDQL 所需的所有类和接口。要创建RDQL 查询，将RDQL 放入S t r i n g中，并将其传送给Q u e r y的构造函
数。通常直接设置模型用作查询的源，除非在RDQL 中使用F R O M子句指定了其他的源。一旦创建了Q u e r y，可以从它创建Q u e r y E n g i n e，然后执行查询。清单9 中说明了此过程：
清单9. 创建和运行RDQL 查询
//C r e a t e a n e w q u e r y p a s s i n g a S t r i n g c o n t a i n i n g t h e R D Q L t o e x e c u t e
Q u e r y q u e r y=n e w Q u e r y(q u e r y S t r i n g);
//S e t t h e m o d e l t o r u n t h e q u e r y a g a i n s t
q u e r y.s e t S o u r c e(m o d e l);
//U s e t h e q u e r y t o c r e a t e a q u e r y e n g i n e
Q u e r y E n g i n e q e=n e w Q u e r y E n g i n e(q u e r y);
//U s e t h e q u e r y e n g i n e t o e x e c u t e t h e q u e r y
Q u e r y R e s u l t s r e s u l t s=q e.e x e c();
使用Q u e r y的一个非常有用的方法是在执行之前将它的一些变量设置为固定值。这种使用模式与j a v a x.s q l.P r e p a r e d S t a t e m e n t的相似。变量通过R e s u l t B i n d i n g对象与值绑定，执行时该对象会传送给Q u e r y E n g i n e。可以将变量与Jena R e s o u r c e或与常量值绑定。在将常量与变量绑定之前，通过调用M o d e l.c r e a t e L i t e r a l将其打包。清单10 说明了预先绑定方法：
清单10. 将查询变量与值绑定
//C r e a t e a q u e r y t h a t h a s v a r i a b l e s x a n d y
Q u e r y q u e r y=n e w Q u e r y(q u e r y S t r i n g);
//A R e s u l t B i n d i n g s p e c i f i e s m a p p i n g s b e t w e e n q u e r y v a r i a b l e s a n d v a l u e s
R e s u l t B i n d i n g i n i t i a l B i n d i n g=n e w R e s u l t B i n d i n g();
//B i n d t h e q u e r y's f i r s t v a r i a b l e t o a r e s o u r c e
R e s o u r c e s o m e R e s o u r c e=g e t S o m e R e s o u r c e();
i n i t i a l B i n d i n g.a d d("x",s o m e R e s o u r c e);
Spring Security-3.0.1 中文官方文档（翻译版） 这次发布的Spring Security-3.0.1 是一个bug fix 版，主要是对3.0 中存在的一些问题进行修 正。文档中没有添加新功能的介绍，但是将之前拼写错误的一些类名进行了修正，建议开发者以这一版本的文档为参考。 另：Spring Security 从2010-01-01 以后，版本控制从SVN 换成了GIT，我们在翻译文档的时候，主要是根据SVN 的变化来进行文档内容的比对，这次换成GIT 后，感觉缺少了之前那种文本比对工具，如果有对GIT 熟悉的朋友，还请推荐一下文本比对的工具，谢谢。 序言 I. 入门 1. 介绍 1.1. Spring Security 是什么？ 1.2. 历史 1.3. 发行版本号 1.4. 获得Spring Security 1.4.1. 项目模块 1.4.1.1. Core - spring-security-core.jar 1.4.1. 2. Web - spring-security-web.jar 1.4.1.3. Config - spring-security-config.jar 1.4.1.4. LDAP - spring-security-ldap.jar 1.4.1.5. ACL - spring-security-acl.jar 1.4.1.6. CAS - spring-security-cas-client.jar 1.4.1.7. OpenID - spring-security-openid.jar 1.4. 2. 获得源代码 2. Security 命名空间配置 2.1. 介绍 2.1.1. 命名空间的设计 2.2. 开始使用安全命名空间配置 2.2.1. 配置web.xml 2.2.2. 最小
2．1、Spring Web MVC是什么 Spring Web MVC是一种基于Java的实现了Web MVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，Spring Web MVC也是要简化我们日常Web开发的。 另外还有一种基于组件的、事件驱动的Web框架在此就不介绍了，如Tapestry、JSF等。 Spring Web MVC也是服务到工作者模式的实现，但进行可优化。前端控制器是DispatcherServlet；应用控制器其实拆为处理器映射器(Handler Mapping)进行处理器管理和视图解析器(View Resolver)进行视图管理；页面控制器/动作/处理器为Controller接口（仅包含ModelAndView handleRequest(request, response) 方法）的实现（也可以是任何的POJO类）；支持本地化（Locale）解析、主题（Theme）解析及文件上传等；提供了非常灵活的数据验证、格式化和数据绑定机制；提供了强大的约定大于配置（惯例优先原则）的契约式编程支持。 2．2、Spring Web MVC能帮我们做什么 √让我们能非常简单的设计出干净的Web层和薄薄的Web层； √进行更简洁的Web层的开发；
√天生与Spring框架集成（如IoC容器、AOP等）； √提供强大的约定大于配置的契约式编程支持； √能简单的进行Web层的单元测试； √支持灵活的URL到页面控制器的映射； √非常容易与其他视图技术集成，如Velocity、FreeMarker等等，因为模型数据不放在特定的API里，而是放在一个Model里（Map数据结构实现，因此很容易被其他框架使用）； √非常灵活的数据验证、格式化和数据绑定机制，能使用任何对象进行数据绑定，不必实现特定框架的API； √提供一套强大的JSP标签库，简化JSP开发； √支持灵活的本地化、主题等解析； √更加简单的异常处理； √对静态资源的支持； √支持Restful风格。 2．3、Spring Web MVC架构
Spring开发教程 Spring教程 (1) Spring框架概述 (2) Spring是什么？ (2) Spring的历史 (3) Spring的使命（Mission Statement） (3) Spring受到的批判 (3) Spring包含的模块 (4) 总结 (5) Spring的IoC容器 (6) 用户注册的例子 (6) 面向接口编程 (7) （用户持久化类）重构第一步——面向接口编程 (8) 重构第二步——工厂（Factory）模式 (9) 重构第三步——工厂（Factory）模式的改进 (9) 重构第四步－IoC容器 (10) 控制反转（IoC）/依赖注入（DI） (10) 什么是控制反转/依赖注入？ (10) 依赖注入的三种实现形式 (11) BeanFactory (13) BeanFactory管理Bean（组件）的生命周期 (14) Bean的定义 (15) Bean的之前初始化 (19) Bean的准备就绪（Ready）状态 (21) Bean的销毁 (21) ApplicationContext (21) Spring的AOP框架 (21) Spring的数据层访问 (21) Spring的声明式事务 (21) Spring对其它企业应用支持 (22)
名词解释 容器： 框架： 框架 容器 组件： 服务： Spring框架概述 主要内容：介绍Spring的历史，Spring的概论和它的体系结构，重点阐述它在J2EE中扮演的角色。 目的：让学员全面的了解Spring框架，知道Spring框架所提供的功能，并能将Spring 框架和其它框架（WebWork/Struts、hibernate）区分开来。 Spring是什么？ Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ?目的：解决企业应用开发的复杂性 ?功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ?范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ■轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ■控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ■面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实
java基础教程:Java基础 疯狂代码 https://www.doczj.com/doc/066560662.html,/ ?:http:/https://www.doczj.com/doc/066560662.html,/BlogDigest/Article75483.html Java简介 Java是由Sun Microsystems公司于1995年5月推出的Java程序设计语言（以下简称Java语言）和Java平台的总称。用Java实现的HotJava浏览器（支持Java applet）显示了Java的魅力：跨平台、动态的Web、Internet计算。从此，Java被广泛接受并推动了Web的迅速发展，常用的浏览器现在均支持Java applet。另一方面，Java技术也不断更新。 Java平台由Java虚拟机（Java Virtual Machine）和Java 应用编程接口（Application Programming Interface、简称API）构成。Java 应用编程接口为Java应用提供了一个独立于操作系统的标准接口，可分为基本部分和扩展部分。在硬件或操作系统平台上安装一个Java平台之后，Java应用程序就可运行。现在Java平台已经嵌入了几乎所有的操作系统。这样Java程序可以只编译一次，就可以在各种系统中运行。Java应用编程接口已经从1.1x版发展到1.2版。目前常用的Java平台基于Java1.4，最近版本为Java1.7。 Java分为三个体系JavaSE(Java2 Platform Standard Edition，java平台标准版 )，JavaEE(Java 2 Platform,Enterprise Edition，java平台企业版)，JavaME(Java 2 Platform Micro Edition，java平台微型版)。 2009年04月20日，oracle（甲骨文)宣布收购sun。 1991年，Sun公司的James Gosling。Bill Joe等人，为电视、控制考面包机等家用电器的交互操作开发了一个Oak（一种橡树的名字）软件，他是Java的前身。当时，Oak并没有引起人们的注意，直到1994年，随着互联网和3W的飞速发展，他们用Java编制了HotJava浏览器，得到了Sun公司首席执行官Scott McNealy的支持，得以研发和发展。为了促销和法律的原因，1995年Oak更名为Java。Java的得名还有段小插曲呢，一天，Java小组成员正在喝咖啡时，议论给新语言起个什么名字的问题，有人提议用Java（Java是印度尼西亚盛产咖啡的一个岛屿），这个提议得到了其他成员的赞同，于是就采用Java来命名此新语言。很快Java被工业界认可，许多大公司如IBM Microsoft.DEC等购买了Java的使用权，并被美国杂志PC Magazine评为1995年十大优秀科技产品。从此，开始了Java应用的新篇章。 Java的诞生时对传统计算机模式的挑战，对计算机软件开发和软件产业都产生了深远的影响： （1）软件4A目标要求软件能达到任何人在任何地方在任何时间对任何电子设备都能应用。这样能满足软件平台上互相操作，具有可伸缩性和重要性并可即插即用等分布式计算模式的需求。 （2）基于构建开发方法的崛起，引出了CORBA国际标准软件体系结构和多层应用体系框架。在此基础上形成了Java.2平台和.NET平台两大派系，推动了整个IT业的发展。 （3）对软件产业和工业企业都产生了深远的影响，软件从以开发为中心转到了以服务为中心。中间提供商，构件提供商，服务器软件以及咨询服务商出现。企业必须重塑自我，B2B的电子商务将带动整个新经济市场，使企业获得新的价值，新的增长，新的商机，新的管理。 （4）对软件开发带来了新的革命，重视使用第三方构件集成，利用平台的基础设施服务，实现开发各个阶段的重要技术，重视开发团队的组织和文化理念，协作，创作，责任，诚信是人才的基本素质。 总之，目前以看到了Java对信息时代的重要性，未来还会不断发展，Java在应用方面将会有更广阔的前景。 ; JAVA-名字起源 Java自1995诞生，至今已经14年历史。Java的名字的来源：Java是印度尼西亚爪哇岛的英文名称，因盛产咖啡而闻名。Java语言中的许多库类名称，多与咖啡有关，如JavaBeans(咖啡豆)、NetBeans(网络豆)以及ObjectBeans (对象豆)等等。SUN和JAVA的标识也正是一杯正冒着热气的咖啡。 据James Gosling回忆，最初这个为TV机顶盒所设计的语言在Sun内部一直称为Green项目。我们的新语言需要一个名字。Gosling注意到自己办公室外一棵茂密的橡树Oak，这是一种在硅谷很常见的树。所以他将这个新语言命名为Oak。但Oak是另外一个注册公司的名字。这个名字不可能再用了。 在命名征集会上，大家提出了很多名字。最后按大家的评选次序，将十几个名字排列成表，上报给商标律师。排在第一位的是Silk(丝绸
spring mvc学习教程(一)-入门实例 引言 1.MVC：Model-View-Control 框架性质的C层要完成的主要工作：封装web请求为一个数据对象、调用业务逻辑层来处理数据对象、返回处理数据结果及相应的视图给用户。 2.简要概述springmvc Spring C 层框架的核心是DispatcherServlet，它的作用是将请求分发给不同的后端处理器，也即使用了一种被称为Front Controller 的模式（后面对此模式有简要说明）。Spring 的C 层框架使用了后端控制器来、映射处理器和视图解析器来共同完成C 层框架的主要工作。并且spring 的C 层框架还真正地把业务层处理的数据结果和相应的视图拼成一个对象，即我们后面会经常用到的ModelAndView 对象。 一、入门实例 1. 搭建环境 在spring的官方API文档中，给出所有包的作用概述，现列举常用的包及相关作用： org.springframework.aop-3.0.5.RELEASE.jar：与Aop编程相关的包 org.springframework.beans-3.0.5.RELEASE.jar：提供了简捷操作bean的接口org.springframework.context-3.0.5.RELEASE.jar：构建在beans包基础上，用来处理资源文件及国际化。 org.springframework.core-3.0.5.RELEASE.jar：spring核心包 org.springframework.web-3.0.5.RELEASE.jar：web核心包，提供了web层接口org.springframework.web.servlet-3.0.5.RELEASE.jar：web 层的一个具体实包，DispatcherServlet也位于此包中。 后文全部在spring3.0 版本中进行，为了方便，建议在搭建环境中导入spring3.0 的所有jar 包（所有jar 包位于dist 目录下）。 2.编写HelloWorld实例 步骤一、建立名为springMVC_01_helloword，并导入上面列出的jar 包。 步骤二、编写web.xml配置文件，代码如下：
Spring基础入门 一、基础知识 1.依赖注入、控制反转 依赖注入：在运行期，由外部容器动态地将依赖对象注入到组件中 控制反转：应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部窗口负责得。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓的反转。 2.spring 的主要特性。 （1）降低组件之间的耦合度，实现软件各层之间的解耦。 （2）可以使用容器提供的众多服务，如：事务管理服务、消息服务、JMS 服务、持久化服务等等。 （3）容器提供单例模式支持，开发人员不再需要自己编写实现代码。 （4）容器提供了AOP 技术，利用它很容易实现如权限拦截，运行期监控等功能。 （5）容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcTemplate、HibernateTemplate. （6）对主流的应用框架提供了集成支持。 3.常用技术 控制反转/依赖注入---面向切入编程---与主流框架的整合、管理--- 二、实例拓展 1.准备搭建环境 dist\spring.jar lib\jakata-commons\commons-loggin.jar 如果使用了切面编程，还需下列jar 文件： lib\aspectj\aspectjweaver.jar 和aspectjrt.jar lib\cglib\cglib-nodep-2.1.3.jar 如果使用了jsr-250 中的注解，还需要下列jar 文件： lib\j2ee\common-annotations.jar 2.搭建并测试环境 建立名为spring_01_base项目，根据需求导入jar包。建立一个Junit测试单元SpringEnvTest，测试代码如下： @Test public void testEnv() { ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); } beans.xml 配置文件在此省略（见下）。运行此测试如无错，则说明环境搭建成功。 说明：beans.xml 可以在类路径下进行配置，也可以在具体的目录下配置。可以是一个配置文件，也可以是多个配置文件组成String 数组传入。 3.实例 作如下准备工作：（1）建立UseDao接口，代码如下： package com.asm.dao; public interface UserDao { void save(); }
MyBatis Spring1.0.0-RC3 参考文档 MyBatis 社区(https://www.doczj.com/doc/066560662.html,) Copyright ? 2010 本文档的拷贝仅允许您个人使用或分发给其他用户，但是不能收取任何费用，后期的发布无论是印刷版或电子版，也会进行版权声明。 本文档由南磊（nanlei1987@https://www.doczj.com/doc/066560662.html,）翻译
目录 第一章介绍 (3) 1.1 整合动机 (3) 1.2 要求 (3) 1.3 感谢 (3) 第二章入门 (4) 2.1 安装 (4) 2.2 快速创建 (4) 第三章SqlSessionFactoryBean (6) 3.1 创建 (6) 3.2 属性 (6) 第四章事务 (8) 4.1 标准配置 (8) 4.2 容器管理事务 (8) 第五章使用SqlSession (9) 5.1 SqlSessionSupport (9) 5.2 SqlSessionTemplate (9) 第六章MapperFactoryBean (11) 6.1 创建 (11) 6.2 注入映射器 (11) 6.3 自动配置 (12) 第七章使用MyBatis API (13) 第八章示例代码 (14)
第一章介绍 1.1 整合动机 正如第二版，Spring仅支持iBatis2。那么我们就想将MyBatis3的支持加入到Spring3.0（参考Spring的Jira的问题）中。不幸的是，Spring 3.0的开发在MyBatis 3.0官方发布前就结束了。因为Spring开发团队不想发布一个基于非发行版的MyBatis的整合支持，那么Spring 官方的支持就不得不等到至少3.1版本了。要在Spring中支持MyBatis，MyBatis社区认为现在应该是自己团结贡献者和有兴趣的人一起来开始进行Spring和MyBatis整合的时候了。 这个小类库就来创建丢失的粘贴Spring和MyBtatis这两个流行框架的胶水。减少用户不得不来配置MyBatis和Spring 3.X上下文环境的样板和冗余代码。它还透明地增加了Spring 对MyBatis事务的支持。 1.2 要求 在开始阅读本手册之前，很重要的一点是你要熟悉Spring和MyBatis这两个框架还有和它们有关的术语，本手册不会提供二者的背景内容，基本安装和配置教程。 和MyBatis一样，MyBatis-Spring也需要Java 5或更高版本。 1.3 感谢 非常感谢那些使得本项目成为现实的人们（按字母顺序排序）。Eduardo Macarron，Hunter Presnall和Putthibong Boonbong的编码工作，测试和文档修改；Andrius Juozapaitis，Giovanni Cuccu，Raj Nagappan和Tomas Pinos的贡献；而Simone Tripodi发现了这些人并把他们带入项目之中。没有他们的努力，这个项目是不可能存在的。
Spring教程 作者：钱安川（Moxie）
Spring教程 (1) Spring框架概述 (3) Spring是什么？ (3) Spring的历史 (4) Spring的使命（Mission Statement） (4) Spring受到的批判 (4) Spring包含的模块 (5) 总结 (6) Spring的IoC容器 (6) 用户注册的例子 (7) 面向接口编程 (8) （用户持久化类）重构第一步——面向接口编程 (8) 重构第二步——工厂（Factory）模式 (9) 重构第三步——工厂（Factory）模式的改进 (10) 重构第四步－IoC容器 (11) 控制反转（IoC）/依赖注入（DI） (11) 什么是控制反转/依赖注入？ (11) 依赖注入的三种实现形式 (12) BeanFactory (14) BeanFactory管理Bean（组件）的生命周期 (15) Bean的定义 (16) Bean的之前初始化 (19) Bean的准备就绪（Ready）状态 (21) Bean的销毁 (21) ApplicationContext (21) Spring的AOP框架 (21) Spring的数据层访问..................................................................................... 错误！未定义书签。Spring的声明式事务..................................................................................... 错误！未定义书签。Spring对其它企业应用支持......................................................................... 错误！未定义书签。 名词解释 容器： 框架： 组件： 服务：
Spring教程
Spring教程 (1) Spring框架概述 (3) Spring是什么？ (3) Spring的历史 (4) Spring的使命（Mission Statement） (4) Spring受到的批判 (4) Spring包含的模块 (4) 总结 (6) Spring的IoC容器 (6) 用户注册的例子 (7) 面向接口编程 (8) （用户持久化类）重构第一步——面向接口编程 (8) 重构第二步——工厂（Factory）模式 (9) 重构第三步——工厂（Factory）模式的改进 (10) 重构第四步－IoC容器 (10) 控制反转（IoC）/依赖注入（DI） (11) 什么是控制反转/依赖注入？ (11) 依赖注入的三种实现形式 (12) BeanFactory (14) BeanFactory管理Bean（组件）的生命周期 (14) Bean的定义 (15) Bean的之前初始化 (18) Bean的准备就绪（Ready）状态 (21) Bean的销毁 (21) ApplicationContext (21) Spring的AOP框架 (21) Spring的数据层访问 (21) Spring的声明式事务 (21) Spring对其它企业应用支持 (21) 名词解释 容器： 框架： 组件： 服务：
Spring框架概述 主要内容：介绍Spring的历史，Spring的概论和它的体系结构，重点阐述它在J2EE中扮演的角色。 目的：让学员全面的了解Spring框架，知道Spring框架所提供的功能，并能将Spring 框架和其它框架（WebWork/Struts、hibernate）区分开来。 Spring是什么？ Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring 的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 ?目的：解决企业应用开发的复杂性 ?功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能 ?范围：任何Java应用 简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 ■轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。 ■控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ■面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ■容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean 可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。 ■框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。 所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它
1 Spring的基本应用 1.1 Spring概述 1.1.1 什么是Spring？ 1）Spring是开源的轻量级框架 2）Spring核心主要两部分： Aop：面向切面编程，扩展功能不是修改源代码实现 IoC：控制反转，比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，需要用new创建类的对象，再使用对象调用方法。控制反转把对象的创建不是通过new方式实现，而是交给Spring配置，创建类对象。 3）Spring是一站式框架 Spring在JavaEE三层结构中，每一层都提供不同的解决技术 Web层：SpringMVC Service层：Spring的IOC dao层：spring的JDBCTemplate、与ORM框架的整合 4）spring版本 Spring4.x
1.1.2 Spring的目录结构 docs文件夹中包含API文档和开发规范 libs文件夹中包含JAR包和源码 Schema文件夹中包含开发所需要的schema（约束）文件
核心jar包： spring-core-4.3.6.RELEASE.jar spring-beans-4.3.6.RELEASE.jar spring-context-4.3.6.RELEASE.jar spring-expression-4.3.6.RELEASE.jar 第三方依赖包：commons.logging的JAR包 1.2 spring的核心容器 1.2.1 BeanFactory 基础类型的IOC容器，主要负责初始化各种Bean，并调用他们的生命周期方法。 创建BeanFactory实例时，需要提供Spring所管理容器的详细配置信息，这些信息通常采用XML文件形式来管理，如：applicationContext.xml 1.2.2 ApplicationContext BeanFactory的子接口，不仅包含了BeanFactory的所有功能，还添加了对国际化、资源访问、事件传播等方面的支持。 通过ClassPathXmlApplicationContext创建 ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation); configLocation参数用于指定spring配置文件的名称和位置。如果其值为“applicationContext.xml”，则spring 会去类路径（classPath）中查找名称为applicationContext.xml的位置文件 在web项目中，ApplicationContext容器的实例化工作会交给web服务器来完成，通常会使用基于ContextLoaderListener实现的方式，只需要在web.xml中添加如下代码，后面讲3大框架整合时将采用此种方式：
Spring3 MVC - 3到Spring MVC框架简介 Spring3 MVC框架简介 Spring MVC是Spring的框架的Web组件。它提供了丰富的功能，为建设强大的Web应用程序。Spring MVC框架的架构，并在这样的高度可配置的方式，每一块的逻辑和功能设计。此外Spring可以毫不费力地与其他流行的Web框架，如Struts，WebWork的，的Java Server Faces和Tapestry集成。这意味着，你甚至可以告诉Spring使用Web框架中的任何一个。比Spring更不紧耦合的servlet或JSP 向客户端呈现视图。喜欢速度与其他视图技术集成，Freemarker的，Excel或PDF现在也有可能。 Spring3.0 MVC系列 ?第1部分：到Spring 3.0 MVC框架简介 ?第2部分：在Spring 3.0 MVC创建Hello World应用程序 ?第3部分：在Spring 3.0 MVC的形式处理 ?第4部分：Spring3 MVC的Tiles Support与Eclipse中的例子插件教程 ?第5部分：Spring3 MVC的国际化及本地化教程与范例在Eclipse ?第6部分：Spring3 MVC示例教程Spring主题 ?第7部分：创建Spring3 MVC Hibernate 3的示例在Eclipse中使用Maven的 在Spring Web MVC，你可以使用任何对象作为命令或表单支持对象，你不需要实现框架特定的接口或基类。Spring的数据绑定是高度灵活的：例如，将验证错误类型不作为应用系统错误，可以通过评估的不匹配。因此，你不必重复你的业务对象的属性，简单的无类型的字符串，在表单对象仅仅是为了处理无效的意见，或正确转换的字符串。相反，它往往是最好直接绑定到业务对象。 请求处理生命周期 Spring的Web MVC框架是，像许多其他Web MVC框架，要求为导向，围绕一个中心的servlet，它把请求分派给控制器，提供其他功能，有利于开发Web应用而设计的。Spring DispatcherServlet DispatcherServlet是Spring IoC容器完全集成，并允许我们使用的每一个Spring的其他功能。
一、理论知识 1.依赖注入、控制反转 依赖注入：在运行期，由外部容器动态地将依赖对象注入到组件中 控制反转：应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部窗口负责得。这样控制权就由应用转移到了外部容器，控制权的转移就是所谓的反转。 2.spring 的主要特性。 （1）降低组件之间的耦合度，实现软件各层之间的解耦。 （2）可以使用容器提供的众多服务，如：事务管理服务、消息服务、JMS 服务、持久化服务等等。 （3）容器提供单例模式支持，开发人员不再需要自己编写实现代码。 （4）容器提供了AOP 技术，利用它很容易实现如权限拦截，运行期监控等功能。 （5）容器提供的众多辅作类，使用这些类能够加快应用的开发，如：JdbcTemplate、HibernateTemplate. （6）对主流的应用框架提供了集成支持。 3.常用技术 控制反转/依赖注入---面向切入编程---与主流框架的整合、管理--- 二、基本实例 1.准备搭建环境 dist\spring.jar lib\jakata-commons\commons-loggin.jar 如果使用了切面编程，还需下列jar 文件： lib\aspectj\aspectjweaver.jar 和aspectjrt.jar lib\cglib\cglib-nodep-2.1.3.jar 如果使用了jsr-250 中的注解，还需要下列jar 文件： lib\j2ee\common-annotations.jar 2.搭建并测试环境 建立名为spring_01_base项目，根据需求导入jar包。建立一个Junit测试单元SpringEnvTest，测试代码如下： @Test public void testEnv() { ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); } beans.xml 配置文件在此省略（见下）。运行此测试如无错，则说明环境搭建成功。 说明：beans.xml 可以在类路径下进行配置，也可以在具体的目录下配置。可以是一个配置文件，也可以是多个配置文件组成String 数组传入。 3.实例 作如下准备工作：（1）建立UseDao接口，代码如下： package com.asm.dao; public interface UserDao { void save(); } （2）建立UserDao接口的实现类，UserDaoImpl package com.asm.dao.impl;
尚学堂马士兵Spring文档 课程内容 1.面向接口（抽象）编程的概念与好处 2.IOC/DI的概念与好处 a)inversion of control b)dependency injection 3.AOP的概念与好处 4.Spring简介 5.Spring应用IOC/DI（重要） a)xml b)annotation 6.Spring应用AOP（重要） a)xml b)annotation 7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合（重要） a)opensessionInviewfilter（记住，解决什么问题，怎么解决） 8.Spring JDBC 面向接口编程（面向抽象编程） 1.场景：用户添加 2.Spring_0100_AbstractOrientedProgramming a)不是AOP:Aspect Oriented Programming 3.好处：灵活 什么是IOC（DI），有什么好处 1.把自己new的东西改为由容器提供 a)初始化具体值 b)装配 2.好处：灵活装配
Spring简介 1.项目名称：Spring_0200_IOC_Introduction 2.环境搭建 a)只用IOC i.spring.jar , jarkata-commons/commons-loggin.jar 3.IOC容器 a)实例化具体bean b)动态装配 4.AOP支持 a)安全检查 b)管理transaction Spring IOC配置与应用 1.FAQ:不给提示： a)window – preferences – myeclipse – xml – xml catalog b)User Specified Entries – add i.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\sprin g-beans-2.5.xsd ii.URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resource s/spring-beans-2.5.xsd iii.Key Type: Schema Location iv.Key: https://www.doczj.com/doc/066560662.html,/schema/beans/spring-beans-2.5.xsd 2.注入类型 a)Spring_0300_IOC_Injection_Type b)setter（重要） c)构造方法（可以忘记） d)接口注入（可以忘记） 3.id vs. name a)Spring_0400_IOC_Id_Name b)name可以用特殊字符 4.简单属性的注入 a)Spring_0500_IOC_SimpleProperty b) 第一章 【思考题】 1、请简述Spring框架的优点。 2、请简述什么是Spring的IoC和DI。。 【答案】 1、Spring框架的优点如下： （1）非侵入式设计：Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。 （2）方便解耦、简化开发：Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大的降低了组件之间的耦合性。 （3）支持AOP：Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。 （4）支持声明式事务处理：只需要通过配置就可以完成对事务的管理，而无需手动编程。 （5）方便程序的测试：Spring提供了对Junit4的支持，可以通过注解方便的测试Spring 程序。 （6）方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。 （7）降低了Java EE API的使用难度：Spring对Java EE开发中非常难用的一些API（如：JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。。 2、IoC的全称是Inversion of Control，中文名称为控制反转。控制反转就是指在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转。 DI的全称是Dependency Injection，中文称之为依赖注入。它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。从Spring容器的角度来看，Spring 容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。 Spring入门教程 中国软件评测中心陈兵1．Spring简介 （1）Spring是什么 Spring是轻量级的J2EE应用程序开源框架。它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。 Spring的核心是个轻量级容器（container），实现了IoC（Inversion of Control）模式的容器，Spring的目标是实现一个全方位的整合框架，在Spring 框架下实现多个子框架的组合，这些子框架之间彼此可以独立，也可以使用其它的框架方案加以替代，Spring希望提供one-stop shop的框架整合方案Spring不会特别去提出一些子框架来与现有的OpenSource框架竞争，除非它觉得所提出的框架够新够好，例如Spring有自己的 MVC框架方案，因为它觉得现有的MVC方案有很多可以改进的地方，但它不强迫您使用它提供的方案，您可以选用您所希望的框架来取代其子框架，例如您仍可以在Spring中整合您的Struts框架。 Spring的核心概念是IoC，IoC的抽象概念是「依赖关系的转移」，像是「高层模块不应该依赖低层模块，而是模块都必须依赖于抽象」是IoC的一种表现，「实现必须依赖抽象，而不是抽象依赖实现」也是IoC的一种表现，「应用程序不应依赖于容器，而是容器服务于应用程序」也是IoC的一种表现。回想一下面向对象的设计原则：OCP原则和DIP原则。 Spring的核心即是个IoC/DI的容器，它可以帮程序设计人员完成组件（类别们）之间的依赖关系注入（连结），使得组件（类别们）之间的依赖达到最小，进而提高组件的重用性，Spring是个低侵入性（invasive）的框架，Spring中的组件并不会意识到它正置身于Spring中，这使得组件可以轻易的从框架中脱离，而几乎不用任何的修改，反过来说，组件也可以简单的方式加入至框架中，使得组件甚至框架的整合变得容易。 Spring最为人重视的另一方面是支持AOP（Aspect-Oriented Programming），《Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)》_课后习题
Spring入门教程
相关主题
文本预览