JVM
jvm是jre里头一个动态连接函数库,jdk里面的jre一般用于运行java本身的程序,比如javac,等等.programfiles下面的jre用于运行用户编写的java程序.
JRE下的bin\client 或者 bin\server 的jvm.dll就是JVM了

当一台机器上有多个jvm可选择的时候,jvm的选择步骤:
1)当前目录有没有jre目录(不准确),
2)父目录下的jre子目录
3)注册表HEKY_LOCAL_MACHINE\SoftWare\Java\Java Runtime Environment\
所以当运行的是jdk\bin\java.exe的时候,用的jre是bin的父目录jdk下面的jre\
运行java.exe找到了jre后有一个验证程序,验证jre和java.exe的版本是否一致,如果不一致则会发生错误

java -verbose:class Main 显示调用的详细信息

classloader的两种载入方式:1)pre-loading预先载入,载入基础类 2)load-on-demand按需求载入
只有实例化一个类才会被classloader载入,仅仅申明并不会载入

java动态载入class的两种方式:
1)implicit隐式,即利用实例化才载入的特性来动态载入class
2)explicit显式方式,又分两种方式:
1)java.lang.Class的forName()方法
2)java.lang.ClassLoader的loadClass()方法

static块在什么时候执行?
1)当调用forName(String)载入class时执行,如果调用ClassLoader.loadClass并不会执行.forName(String,false,ClassLoader)时也不会执行.
2)如果载入Class时没有执行static块则在第一次实例化时执行.比如new ,Class.newInstance()操作
3)static块仅执行一次

Class类的实例.
>>Class类无法手工实例化,当载入任意类的时候自动创建一个该类对应的Class的实例,
>>某个类的所有实例内部都有一个栏位记录着该类对应的Class的实例的位置.,
>>每个java类对应的Class实例可以当作是类在内存中的代理人.所以当要获得类的信息(如有哪些类变量,有哪些方法)时,都可以让类对应的Class的实例代劳.java的Reflection机制就大量的使用这种方法来实现
>>每个java类都是由某个classLoader(ClassLoader的实例)来载入的,因此Class类别的实例中都会有栏位记录他的ClassLoader的实例,如果该栏位为null,则表示该类别是由bootstrap loader载入的(也称root laoder),bootstrap loader不是java所写成,所以没有实例.

原生方法:forName0()等方法,native修饰符

自定义ClassLoader:
如实例化一个URLClassLoader. URLClassLoader ucl = new URLClassLoader(new URL[]{new URL("file:/e:/bin/")}),URLClassLoader优先找当前目录,再在url中找.class加载.URL中别忘在最后加"/"表示目录

各个java类由哪些classLoader加载?
1)java类可以通过实例.getClass.getClassLoader()得知
2)接口由AppClassLoader(System ClassLoader,可以由ClassLoader.getSystemClassLoader()获得实例)载入
3)ClassLoader类由bootstrap loader载入

ClassLoader hierachy:
jvm建立->初始化动作->产生第一个ClassLoader,即bootstrap loader->bootstrap loader在sum.misc.Launcher类里面的ExtClassLoader,并设定其Parent为null->bootstrap loader载入sun.misc.Launcher$AppClassLoader,并设定其parent为ExtClassLoader(但是AppClassLoader也是由bootstrap loader所载入的)->AppClassLoader载入各个xx.class,xx.class也有可能被ExtclassLoader或者bootstrap loader载入.
>>自定义的ClassLoader的.getParent()是AppClassLoader.parent和他的加载器并没有关系
>>ExtClassLoader和AppClassLoader都是URLClassLoader的子类.AppClassLoader的URL是由系统参数java.class.path取出的字符串决定,而java.class.path由 运行java.exe时 的-cp或-classpath或CLASSPATH环境变量决定
>>ExtClassLoader查找的url是系统变量java.ext.dirs,java.ext.dirs默认为jdk\jre\lib\ext
>>Bootstrap loader的查找url是sun.boot.class.path
>>在程序运行后调用System.setProperty()来改变系统变量并不能改变以上加载的路径,因为classloader读取在System.setProperty之前.sun.boot.class.path是在程序中写死的,完全不能修改

委派模型
当classloader有类需要载入时先让其parent搜寻其搜寻路径帮忙载入,如果parent找不到,在由自己搜寻自己的搜寻路径载入,ClassLoader hierachy本来就有这种性质

NoClassDefFoundError和ClassNotFoundException
NoClassDefFoundError:当java源文件已编译成.class文件,但是ClassLoader在运行期间在其搜寻路径load某个类时,没有找到.class文件则报这个错
ClassNotFoundException:试图通过一个String变量来创建一个Class类时不成功则抛出这个异常

1.xtree和xloadtree,总体来说,实现还不错,提供了一次性构建树,和动态加载树(生成指定格式的XML才可以),改变Style,功能中等,用法中等.

2.yui的treeview,这也是不错的实现,是Yahoo提供的,支持一次性构建,动态构建,改变Style,Menu样式等等,功能很多,但用法比较复杂


没用过，只是听说的

3.dtree,比较中规中矩的一个实现,用法简单,不支持动态加载。

还有其他的好的js，大家可以补充。

作者：Kuassi Mensah

利用Java存储过程沟通SQL、XML、Java、J2EE和Web服务。

存储过程（stored procedure）允许将运行于数据库层中的持久性逻辑与运行于中间层中的商务逻辑有效地分离开来。这种分离可以降低整个应用程序的复杂性，并提供其重用性、安全性、性能和可伸缩性。

但是，妨碍存储过程广泛采用的一个主要障碍是不同数据库厂商使用各种专有的、且依赖于数据库的实现语言。使用基于Java的存储过程可以解决这一问题。Oracle已经实现了ANSI标准，这些标准规定了从SQL中将静态Java方法作为过程或函数进行调用的能力。这种实现被简单地称作"Java存储过程"。

在本文中，你将了解基于Java的存储过程如何帮助简化商务逻辑、提高其性能，并扩展数据库的功能。本文将介绍Oracle如何在数据库内启用基于Java的存储过程。还会介绍Java存储过程如何访问数据，以及如何创建基本Java存储过程。

选择PL/SQL还是Java

在考虑Oracle存储过程时，你可能会想到PL/SQL。不过，从Oracle8i开始，Oracle已经在数据库中支持Java，从而为存储过程提供了不同于PL/SQL的开放式和可移植的方法。我可以听到"$64 000问题"："我如何在PL/SQL和Java之间做出选择？我是否应当忘记已经学习的所有PL/SQL相关知识，而变为一个Java天地的新手？"

两种语言都适用于数据库编程，都有自己的优点和弱点。在决定选择哪一种语言时，可以参考下面根据经验得出的通用规则：

对于要求与SQL进行无缝集成的数据库中心来说则逻辑使用PL/SQL，从而完成对数据库对象、类型和特性的访问。

出于与数据库的无关性考虑时，可以选择Java作为开放式的语言来取代PL/SQL，同时也为了集成和沟通SQL、XML、J2EE和Web服务等各个领域。
OralceJVM使得Java可以运行在数据库中

从Oracle8i版本1（Oralce8.1.5）开始，Oracle便提供紧密集成的Java虚拟机（JVM），JVM支持Oralce的数据库会话期结构。任何数据库对话期都可以在第一Java代码调用时启动一个虚拟上专用的JVM，后续的用户可以使用这一已经存在的支持Java的会话期。事实上，所有会话共享同一JVM代码并保持"仅静态"的私有状态，而垃圾则收集在单个对话期空间内，从而为各个Java对话期提供了和SQL操作相同的对话期隔离和数据完整性能力。这里，不需要为了数据完整性而进行单独的Java支持的过程。这一基于对话期的结构提供了较小的内存占用率，并使OracleJVM具有与Oracle数据库一样的线性SMP可伸缩性。

创建Java存储过程

要将Java方法转换为Java存储过程需要几个步骤，包括：用loadjava实用程序将Java类加载到数据库中，利用调用规范（Call Spec）发布Java方法，将Java方法、参数类型和返回类型映射到其SQL的对应部分。下面部分说明如何完成这些步骤。

我将使用一个简单的Hello类，它有一个方法Hello.world()，返回字符串"Hello world"：

public class Hello { public static String world () { return "Hello world"; } }
Loadjava 实用程序

Loadjava是加载Java源文件、Java类文件和Java资源文件的实用程序，它可以用来验证字节码，并将Java类和JAR文件布置到数据库中。它既可以通过命令行调用，也可以通过包含于DBMS_JAVA类中的loadjava()方法调用。为了加载我们的Hello.class示例，输入：

loadjava -user scott/tiger Hello.class

从Oracle9i版本2开始，loadjava允许通过为包含在被处理的类中的方法创建相应的Call Specs来自动将Java类发布为存储过程。Oracle为开发、测试、调试和布置Java存储过程提供了Oracle9i JDeveloper。

The Resolver Spec

基于JDK的JVM在列于CLASSPATH中的目录中查找类引用，并对其进行解析。因为Oracle数据库类存在于数据库模式中，所以OracleJVM利用数据库解析器（resolver）通过列于Resolver Spec中的模式查找并解析类引用。与CLASSPATH不同（CLASSPATH可以应用于所有的类），Resover Spec根据每类的情况进行应用。缺省解析器首先在加载类的模式中搜寻类，然后在公共同义词（public synonyms）中搜索。

 loadjava -resolve <myclass>
你可能需要指定不同的解析器，也可以在使用loadjava时强制进行解析，从而在布置时确定可能在以后运行时发生的任何问题。

loadjava -resolve -resolver "((* SCOTT) (foo/bar/* OTHERS) (* PUBLIC))"
Call Spec和存储过程调用

为了从SQL中调用Java方法（以及从PL/SQl和JDBC中调用），必须首先通过Call Spec发布公共静态方法，它为SQL定义方法采用的参数以及返回的SQL类型。

在我们的例子中，我们将利用SQL＊Plus连接到数据库，并为Hello.world()定义一个顶级Call Spec：

SQL> connect scott/tiger SQL> create or replace function helloworld return VARCHAR2 as language java name 'Hello.world () return java.lang.String'; / Function created.
可以像下面这样调用Java存储过程：

SQL> variable myString varchar2[20]; SQL> call helloworld() into :myString; Call completed. SQL> print myString; MYSTRING --------------------- Hello world
Java存储过程可以通过其Call Spec从以下各项中进行调用：SQL DML语句（INSERT, UPDATE、DELETE、SELECT、CALL、EXPLAIN PLAN、LOCK TABLE和MERGE）、PL/SQL块、子程序、程序包以及数据库触发器。Call Spec的美妙之处在于存储过程实现可以从PL/SQL转换为Java，反之亦可，这一点对于请求者是透明的。

Call Spec从实现语言中（PL/SQL或Java）中抽象出调用界面，因而使之能够在原有应用程序和新的基于Java／J2EE的应用程序之间共享商务逻辑。但是，在从Java客户程序调用在数据库驻留的Java类时，你可能不希望通过PL/SQL包装器(wrapper)。在以后的版本中，Oracle计划提供一种机制，它可以使开发人员略过Call Spec。

高级数据访问控制

Java存储过程可用于控制和限制对Oracle数据的访问，其方法是只允许用户通过存储过程管理数据，而存储过程在其调用者的权限内执行，而不能对表本身进行访问。例如，你可以在特定时间内禁止更新数据，或者使管理者只具有查询工资数据的权利，而不能进行更新，或者记录所有的访问并通知某一安全机构。

原有应用程序与J2EE应用程序之间的数据逻辑共享

因为原有应用程序与J2EE应用程序都通过Call Spec调用存储过程，所以J2EE和非J2EE应用程序可以共享相同的数据逻辑。由于有了Call Spec，所以不用考虑所用的是何种实现语言（无论是PL/SQL还是Java），该数据逻辑都可以共享。

为BMP实体Bean自动生成主关键字

在对EJB实体bean应用BMP时，一个bean实例可以由自动生成的与新插入的数据相关联的主关键字惟一确定，它是ejbCreate()的返回值。可以利用一个插入相应数据的存储过程在一个数据库操作中检索ejbCeater()中的该值，并检索或计算主关键字。作为另一种方法，也可以利用JDBC3.0的RETURN_GENERATED_KEYS特性，以一个SQL语句插入该数据并检索相应的关键字（或ROWID）。但是，存储过程方法在各个JDBC驱动器版本和数据库之间更具可移植性。

可以用以下三个步骤实现这一模式：
>
创建一个Java存储过程，在公共GenPk类中定义一个公共静态Java方法insertAccount()。此方法将插入数据、计算惟一的关键字（通过发出一个序列号），并返回计算出的关键字作为主关键字。

定义Call Spec

CREATE OR REPLACE PROCEDURE insertAccount(owner IN varchar, bal IN number, newid OUT number) AS LANGUAGE JAVA NAME 'GenPK.insertAccount( java.lang.String [])'; /

在ejbCreate()内调用存储过程

Public AccountPK ejbCreate(String ownerName, int balance) throws CreateException { try { CallableStatement call = conn.prepareCall{ "{call insertAccount(?, ?, ?)}"}; return new AccountPK(accountID); } }
为CMP实体Bean定制主关键字查找器

查找器方法（Finder methods）用于检索已存在的EJB实体bean实例。主关键字查找器使你能够检索惟一标识的EJB实例。对于CMP实体bean，EJB容器根据声明描述，自动生成主关键字查找器findByPrimaryKey()方法。但是，在某些情况下，可能需要更多的控制，例如可能需要专门的查找器，如findByStoredProcKey()。在这些情况下，你可以结合使用Java存储过程和对象关系框架（如Oracle9i应用服务器[Oracle9iAS] TopLink）来实现定制的主关键字查找器方法。在将EJB查找器定义为REDIRECT或NAMED查找器后，TopLink将生成一个SQL查询用于检索bean实例。

数据驱动的EJB调用

在数据驱动体系结构中，商务逻辑调用可以作为数据库操作（如插入、更新或删除）的结果来触发。实现该数据逻辑的Java存储过程可以被声明为数据库触发器，用以调用运行于中间层J2EE应用服务器的EJB。EJB的调用既可以采用J2EE1.3兼容的服务器通过Interoperable Inter-ORB Protocol（IIOP）标准远程方法调用（remote method invocation，RMI）实现，也可以通过销售商特定的传输协议（如Oracle9iAS/Oc4J的ORMI，或者通过BEA WebLogic的T3）用RMI来实现。每个应用服务器提供商在提供基于IIOP的RMI，以提供互操作性的同时，都有其自己优化的协议。Oracle9iAS同时支持基于IIOP的RMI调用和基于ORMI协议的RMI调用。

数据驱动的消息传送

Oracle9i数据库嵌入了Advanced Queuing（AQ，高级排队），它是一种集成的、稳定、可靠、安全、可扩展和事务处理式的消息排队框架。Oracle通过标准的Java消息传送系统（Java Messaging System，JMS）API为Java开发人员提供AQ功能。Java存储过程可以通过JMS接口调用AQ操作，从而能够实现快速、在会话期内、可扩展的、数据驱动的消息传送。

Java存储过程可以利用JMS调用AQ操作。可以用以下4个步骤实现这一模式：

创建并启动JMS Queue（为此，可以将以下一些操作嵌入SQL脚本内）：

execute dbms_aqadm.create_queue_table(queue_table => 'queue1', queue_payload_type => 'SYS.AQ$_JMS_TEXT_MESSAGE', comment => 'a test queue', multiple_consumers => false, compatible => '8.1.0'); execute dbms_aqadm.create_queue( queue_name => 'queue1', queue_table => 'queue1' ); execute dbms_aqadm.start_queue(queue_name => 'queue1');

创建Java存储过程（代码摘录如下）：

public static void runTest(String msgBody) { try { // get database connection ora_drv = new OracleDriver(); db_conn = ora_drv.defaultConnection(); // setup sender (cf online code sample) .. // create message s_msg = s_session.createTextMessage(msgBody); // send message sender.send(s_msg); s_session.commit(); // receive message r_msg = (TextMessage) receiver.receive(); r_session.commit(); // output message text String body = r_msg.getText(); System.out.println("message was '"+body+"'"); ..} }

创建Call Spec：

create or replace procedure jmsproc (t1 IN VARCHAR) as language java name 'jmsSample.main (java.lang.String[])'; /

调用存储过程：

call jmsproc('hello');
数据库辅助的Web发布（缓冲失效）

各应用程序结构必须面对的一个共同问题是如果可靠地将数据库信息进行缓存，以提高整个系统的性能。JCACHE是一种即将公布的标准规范（JSR 107），它可以解决这一问题。它说明了一种对Java对象临时在内存中进行缓存的方法，包括对象的创建、共享访问、假脱机（spooling）、失效、各JVM的一致性等。它可被用于缓存JSP内最经常读取的数据，如产品目录和价格列表。利用JCACHE，多数查询的反应时间会因为有缓存的数据而加快（内部测试表明反应时间大约快15倍）。

为了跟踪原始数据的所有变化，并刷新已缓存的数据，Java存储过程会作为一个触发器被附加在一个表上。这个表的任何变化都会自动调用该存储过程，后者再调出一个已定义的JSP使JCACHE对象失效，该对象将其状态映射到该数据库表。在失效时，紧跟其后的查询将强制缓存器根据数据库的数据进行更新。 下面的步骤
阅读关于Java存储过程的更多信息
本文摘自白皮书"释放Java存储过程的能量（Unleash the Power of Java Stored Procedures）"，可以在以下位置找到该白皮书：
otn.oracle.com/tech/java/java_db/pdf/
OW_30820_JAVA_STORED_PROC_paper.PDF

Oracle9i数据库第2版中的新PL/SQL特性
otn.oracle.com/tech/pl_sql/pdf/
Paper_30720_Doc.pdf

Resolver Spec
otn.oracle.com/docs/products/oracle9i/
doc_library/release2/java.920/a96659.pdf

OracleJVM and Java 2 Security
otn.oracle.com/docs/products/oracle9i/
doc_library/release2/java.920/a96656.pdf

下载代码
练习本文中的代码示例：
otn.oracle.com/sample_code/tech/
java/jsp/Oracle9iJSPSamples.html

了解作为Web服务的存储过程
otn.oracle.com/tech/webservices
 

扩展数据库的功能

在数据库中直接运行Java代码的一个妙处就在于要实现新的功能，只需要简单地加载代码或库，并利用Call Spec制作可用于SQL、PL/SQL、Java、J2EE和非Java API的进入点（公共静态方法）。Oracle9i数据库用户可以很容易地扩展数据库

功能。Oracle自己利用这种能力来获得新的应用程序和工具包，如XML Developer Kits（XDKs）。

沟通SQL、PL/SQL、Java、J2EE、.NET和XML

Oracle XDK是用Java编写的，并将其公共方法可用作Java存储过程，从而扩展了数据库的XML可编程能力。SQL、PL/SQL、Java、J2EE和非Java（.NET）商务逻辑都能够访问XML分析器、XSLT处理器、XPath引擎和XML SQL Utility（XSU）。

XML分析器可以通过xmlparser和xmldom包进行访问。XSU是一种Java实用程序，它可以由SQL查询结果或JDBC ResultSet生成XML文档，并将XML文档中的数据写入数据库表或视图中。利用XSU，XML输出可以输出为文本、Dom树或DTS。通过dbms_xmlquery和dbms_xmlsave包，XSU即可用于PL/SQL。

结论

Oracle数据库与Java VM的集成可以创建可移植、功能强大和与数据库无关的数据逻辑和持续性逻辑（persistence logic）。运行于中间层的商务逻辑和运行于数据库层的数据逻辑之间的分离提高了应用程序的可扩展性、灵活性和可维护性。

定义：

      将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来, 那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。

讲到这里,可能有人要问：这么说存储过程就是一堆SQL语句而已啊？

Microsoft公司为什么还要添加这个技术呢?

那么存储过程与一般的SQL语句有什么区别呢?

存储过程的优点：

1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次  就编译一次,所以使用存储过程可提高数据库执行速度。

2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。

3.存储过程可以重复使用,可减少数据库开发人员的工作量

4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权

存储过程的种类：

     1.系统存储过程：以sp_开头,用来进行系统的各项设定.取得信息.相关管理工作,

                               如 sp_help就是取得指定对象的相关信息
  2.扩展存储过程   以XP_开头,用来调用操作系统提供的功能

                              exec master..xp_cmdshell 'ping 10.8.16.1'

   3.用户自定义的存储过程,这是我们所指的存储过程

   常用格式

   Create procedure procedue_name

   [@parameter data_type][output]

   [with]{recompile|encryption}

   as

        sql_statement

解释: 

output：表示此参数是可传回的

with {recompile|encryption}

recompile:表示每次执行此存储过程时都重新编译一次

encryption:所创建的存储过程的内容会被加密

如:

   表book的内容如下

   编号    书名                           价格

   001      C语言入门                   $30

   002      PowerBuilder报表开发  $52

 实例1:查询表Book的内容的存储过程

   create proc query_book

      as

      select * from book

   go

   exec query_book

 实例2:加入一笔记录到表book,并查询此表中所有书籍的总金额

   Create proc insert_book

   @param1 char(10),@param2 varchar(20),@param3 money,@param4 money output

   with encryption  ---------加密

   as

   insert book(编号,书名，价格） Values(@param1,@param2,@param3)
   select @param4=sum(价格) from book
  go

  执行例子:
  declare @total_price money
  exec insert_book '003','Delphi 控件开发指南',$100,@total_price
  print '总金额为'+convert(varchar,@total_price)
  go
存储过程的3种传回值:
   1.以Return传回整数
   2.以output格式传回参数
   3.Recordset
传回值的区别:
       output和return都可在批次程式中用变量接收,而recordset则传回到执行批次的客户端中 

实例3：设有两个表为Product,Order,其表内容如下：
      Product
           产品编号       产品名称    客户订数    
            001             钢笔         30        
            002             毛笔         50        
            003             铅笔         100       
      Order 
           产品编号         客户名     客户订金
            001              南山区      $30
            002              罗湖区      $50
            003              宝安区      $4
请实现按编号为连接条件,将两个表连接成一个临时表,该表只含编号.产品名.客户名.订金.总金额,
总金额=订金*订数,临时表放在存储过程中

代码如下:
     Create proc temp_sale
     as
       select a.产品编号,a.产品名称,b.客户名,b.客户订金,a.客户订数* b.客户订金 as总金额
       into #temptable from Product a inner join Order b on a.产品编号=b.产品编号
    if  @@error=0
       print 'Good'
    else
       print 'Fail'
     go

　　目录的建立/检查与删除

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>目录的建立/检查与删除</title>
</head>
<body>
<%
String path=request.getRealPath("");
path=path + "\\Sub";//将要建立的目录路径
File d=new File(path);//建立代表Sub目录的File对象，并得到它的一个引用
if(d.exists()){//检查Sub目录是否存在
d.delete();
out.println("Sub目录存在，已删除");
}else{
d.mkdir();//建立Sub目录
out.println("Sub目录不存在，已建立");
}
%>
</body>
</html>

　　如何在JSP中处理虚拟目录

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>JSP中如何处理虚拟目录</title>
</head>
<body>
取得虚拟目录对应的磁盘路径<br>
Web站点主目录的位置为<font color=#ff0000><%=request.getRealPath("/")%></font><br>
JSP网页所在的目录位置<font color=#ff0000><%=request.getRealPath("./")%></font><br>
JSP网页所在目录上一层目录的位置<font color=#ff0000><%=request.getRealPath("../")%></font><br>
</body>
</html>

文件属性的取得

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.util.Date,java.io.*"%>
<html>
<head>
<title>文件属性的取得</title>
</head>
<body>
<%
String path=request.getRealPath("/");
File f=new File(path,"ReadData.txt");
if(f.exists()){
%>
<%=f.getName()%>的属性如下：<br><br>
文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%><br>
<%=f.isDirectory()?"是目录":"不是目录"%><br>
<%=f.canRead()?"可读取":"不可读取"%><br>
<%=f.canWrite()?"可写入":"不可写入"%><br>
<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%><br>
文件的最后修改日期为：<%=new Date(f.lastModified())%><br>
<%
}else{
f.createNewFile();//在当前目录下建立一个名为ReaData.txt的文件
%>
<%=f.getName()%>的属性如下：<br><br>
文件长度为：<%=f.length()%>
<%=f.isFile()?"是文件":"不是文件"%><br>
<%=f.isDirectory()?"是目录":"不是目录"%><br>
<%=f.canRead()?"可读取":"不可读取"%><br>
<%=f.canWrite()?"可写入":"不可写入"%><br>
<%=f.isHidden()?"是隐藏文件":"不是隐藏文件"%><br>
文件的最后修改日期为：<%=new Date(f.lastModified())%><br>
<%
}
%>
</body>
</html>

　　取出目录中文件的方法

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>取出目录中文件的方法--列出目录中的文件</title>
</head>
<body>
<%
String path=request.getRealPath("/");
File d=new File(path);//建立当前目录中文件的File对象
File list[]=d.listFiles();//取得代表目录中所有文件的File对象数组
out.println("<font color=#ff0000>" + path + "目录下的文件：</font><br>");
for(int i=0;i<list.length;i++){
if(list<I>.isFile()){
out.println(list<I>.getName() + "<br>");
}
}
out.println("<br><font color=#ff0000>" + path + "目录下的目录：</font><br>");
for(int i=0;i<list.length;i++){
if(list<I>.isDirectory()){
out.println(list<I>.getName() + "<br>");
}
}
%>
</body>
</html>

判断是否为空白文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>判断是否为空白文件</title>
</head>
<body>
<%
String path=request.getRealPath("/");
out.println(path);
FileReader fr=new FileReader(path + "\\AtEnd.txt");//建立FileReader对象，并实例化为fr
//对FileReader类生成的对象使用read()方法，可以从字符流中读取下一个字符。
if(fr.read()==-1)//判断是否已读到文件的结尾
{
out.print("AtEnd.txt文件中没有数据<br>");
}else{
out.println("AtEnd.txt文件中有数据");
}
fr.close();
%>
</body>
</html>
    <B>读取所有的文件数据</B>
<ccid_nobr>
<table width="400" border="1" cellspacing="0" cellpadding="2"
bordercolorlight = "black" bordercolordark = "#FFFFFF" align="center">
<tr>
<td bgcolor="e6e6e6" class="code" style="font-size:9pt">
<pre><ccid_code> <%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*,java.lang.*"%>
<html>
<head>
<title>读取所有的文件数据</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
//关键在于读取过程中，要判断所读取的字符是否已经到了文件的末尾，
并且这个字符是不是文件中的断行符，即判断该字符值是否为13。
int c=fr.read();//从文件中读取一个字符
//判断是否已读到文件结尾
while(c!=-1){
out.print((char)c);//输出读到的数据
c=fr.read();//从文件中继续读取数据
if(c==13){//判断是否为断行字符
out.print("<br>");//输出分行标签
fr.skip(1);//略过一个字符
//c=fr.read();//读取一个字符
}
}
fr.close();
%>
</body>
</html>

　　一行一行读取数据

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>文件读取</title>
</head>
<body>
<%
String path=request.getRealPath("");//取得当前目录的路径
FileReader fr=new FileReader(path + "\\file\\inc\\t.txt");//建立FileReader对象，并实例化为fr
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();//从文件读取一行字符串
//判断读取到的字符串是否不为空
while(Line!=null){
out.println(Line + "<br>");//输出从文件中读取的数据
Line=br.readLine();//从文件中继续读取一行数据
}
br.close();//关闭BufferedReader对象
fr.close();//关闭文件
%>
</body>
</html>
略过文件中的字符不读取

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>略过字节不读取</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileReader fr=new FileReader(path + "\\ReadData.txt");
fr.skip(2);//跳过2个字节
int c=fr.read();//读取一个字节
while(c!=-1){
out.print((char)c);
c=fr.read();
}
fr.close();
%>
</body>
</html>

　　将数据写入文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将数据写入文件</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");//建立FileWriter对象，并实例化fw
//将字符串写入文件
fw.write("大家好！");
fw.write("本书是《JSP编程技巧》");
fw.write("请多多指教！");
fw.write("email:stride@sina.com");
fw.close();

FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//建立BufferedReader对象，并实例化为br
String Line=br.readLine();
//读取一行数据
out.println(Line + "<br>");
br.close();//关闭BufferedReader对象
fr.close();
%>
</body>
</html>

　　将写入文件的数据分行

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
FileWriter fw=new FileWriter(path + "\\WriteData.txt");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大家好！");
bw.write("本书是《JSP编程技巧》。");
bw.newLine();//断行
bw.write("请多多指教！");
bw.newLine();//断行
bw.write("email: stride@sina.com");
bw.flush();//将数据更新至文件
fw.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);
String Line=br.readLine();//读取一行数据
while(Line!=null){
out.println(Line + "<br>");
Line=br.readLine();
}
fr.close();
%>
</body>
</html>

　　如何将数据追加写入到文件

<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.io.*"%>
<html>
<head>
<title>将写入文件的数据分行</title>
</head>
<body>
<%
String path=request.getRealPath(".");
RandomAccessFile rf=new RandomAccessFile(path + "\\WriteData.txt","rw");
//定义一个类RandomAccessFile的对象，并实例化
rf.seek(rf.length());//将指针移动到文件末尾
rf.writeBytes("\nAppend a line to the file!");
rf.close();//关闭文件流
out.println("写入文件内容为：<br>");
FileReader fr=new FileReader(path + "\\WriteData.txt");
BufferedReader br=new BufferedReader(fr);//读取文件的BufferedRead对象
String Line=br.readLine();
while(Line!=null){
out.println(Line + "<br>");
Line=br.readLine();
}
fr.close();//关闭文件
%>
</body>
</html></I></I></I></I>

　　首先我们需要知道Java和J2EE是两个不同概念，Java不只是指一种语言，已经代表与微软不同的另外一个巨大阵营，所以Java有时是指一种软件系统的流派，当然目前主要是.NET和Java两大主流体系。

　　J2EE可以说指Java在数据库信息系统上实现，数据库信息系统从早期的dBase、到Delphi/VB等C/S结构，发展到B/S（Browser浏览器/Server服务器）结构，而J2EE主要是指B/S结构的实现。

　　J2EE又是一种框架和标准，框架类似API、库的概念，但是要超出它们。如果需要详细了解框架，可先从设计模式开始学习。

　　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系统。

　　谈到JavaBeans技术，就涉及到组件构件技术（component），这是Java的核心基础部分，很多软件设计概念（设计模式）都是通过JavaBeans实现的。

　　JavaBeans不属于J2EE概念范畴中，如果一个JavaBeans对象被Web技术（也就是Jsp/Servlet）调用，那么JavaBeans就运行在J2EE的Web容器中；如果它被EJB调用，它就运行在EJB容器中。

　　EJB（企业JavaBeans）是普通JavaBeans的一种提升和规范，因为企业信息系统开发中需要一个可伸缩的性能和事务、安全机制，这样能保证企业系统平滑发展，而不是发展到一种规模重新更换一套软件系统。

　　至此，JavaBeans组件发展到EJB后，并不是说以前的那种JavaBeans形式就消失了，这就自然形成了两种JavaBeans技术：EJB和POJO，POJO完全不同于EJB概念，指的是普通JavaBeans，而且这个JavaBeans不依附某种框架，或者干脆可以说：这个JavaBeans是你为这个应用程序单独开发创建的。

　　J2EE应用系统开发工具有很多：如JBuilder、Eclipse等，这些IDE首先是Java开发工具，也就是说，它们首要基本功能是可以开发出JavaBeans或Java class，但是如果要开发出J2EE系统，就要落实到要么是Web技术或EJB技术，那么就有可能要一些专门模块功能(如eclipse需要lomboz插件)，最重要的是，因为J2EE系统区分为容器和应用两个部分，所以，在任何开发工具中开发J2EE都需要指定J2EE容器。

　　J2EE容器分为WEB容器和EJB容器，Tomcat/Resin是Web容器；JBoss是EJB容器+Web容器等，其中Web容器直接使用Tomcat实现的。所以你开发的Web应用程序可以在上面两种容器运行，而你开发的Web+EJB应用则只可以在JBoss服务器上运行，商业产品Websphere/Weblogic等和JBoss属于同一种性质。

　　J2EE容器也称为J2EE服务器，大部分时它们概念是一致的。

　　如果你的J2EE应用系统的数据库连接是通过JNDI获得，也就是说是从容器中获得，那么你的J2EE应用系统基本与数据库无关，如果你在你的J2EE应用系统耦合了数据库JDBC驱动的配置，那么你的J2EE应用系统就有数据库概念色彩，作为一个成熟需要推广的J2EE应用系统，不推荐和具体数据库耦合，当然这其中如何保证J2EE应用系统运行性能又是体现你的设计水平了。

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

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

　　因此，我们实际编程中，也要将自己的功能向这三个层次上靠，做到大方向清楚，泾渭分明，但是没有技术上约束限制要做到这点是很不容易的，因此我们还是必须借助J2EE具体技术来实现，这时，你可以使用EJB规范实现服务层和持久层，Web技术实现表现层；

　　EJB为什么能将服务层从Jsp/Servlet手中分离出来，因为它对JavaBeans编码有强制的约束，现在有一种对JavaBeans弱约束，使用Ioc模式实现的（当然EJB 3.0也采取这种方式），在Ioc模式诞生前，一般都是通过工厂模式来对JavaBeans约束，形成一个服务层，这也是是Jive这样开源论坛设计原理之一。

　　由此，将服务层从表现层中分离出来目前有两种可选架构选择：管理普通JavaBeans（POJO）框架(如Spring、JdonFramework)以及管理EJB的EJB框架，因为EJB不只是框架，还是标准，而标准可以扩展发展，所以，这两种区别将来是可能模糊，被纳入同一个标准了。　但是，个人认为：标准制定是为某个目的服务的，总要牺牲一些换取另外一些，所以，这两种架构会长时间并存。

　　这两种架构分歧也曾经诞生一个新名词：完全POJO的系统也称为轻量级系统(lightweight)，其实这个名词本身就没有一个严格定义，更多是一个吸引人的招牌，轻量是指容易学习容易使用吗？按照这个定义，其实轻量Spring等系统并不容易学习；而且EJB 3.0（依然叫EJB）以后的系统是否可称为轻量级了呢？

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

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

　　持久层框架目前呈现百花齐放，各有优缺点的现状，所以正如表现层框架一样，目前没有一个框架被指定为标准框架，当然，表现层框架现在又出来了一个JSF，它代表的页面组件概念是一个新的发展方向，但是复杂的实现让人有些忘而却步。

　　在所有这些J2EE技术中，虽然SUN公司发挥了很大的作用，不过总体来说：网络上有这样一个评价：SUN的理论天下无敌；SUN的产品用起来撞墙；对于初学者，特别是那些试图通过或已经通过SUN认证的初学者，赶快摆脱SUN的阴影，立即开溜，使用开源领域的产品来实现自己的应用系统。

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

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

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

　　以上理念可以总结为一句话：
J2EE开发三件宝: Domain Model（域建模）、patterns（模式）和framework（框架）。

　　推荐一套高质量的J2EE开源系统： JPestore
　　
　　如果初学者没有理解，欢迎继续讨论，大胆提出你心中的疑问。

我曾写过一篇叫<<配置Eclpise+tomcat并实现JSP的编写与部署>>，现在写的这些算是它的后续．

一．    软件下载
Mysql
下载版本：4.1.11
http://dev.mysql.com/downloads/mysql/4.1.html

JDBC驱动
下载版本：3.1.8
http://dev.mysql.com/downloads/connector/j/3.1.html

Mysql界面插件:mysql-front
下载版本镜像：HongKong（我下回来安装就是中文版了）
http://www.mysqlfront.de/download.html

二．    软件安装
1.安装mysql
    就如我上面所说的，我是参考了saulzy的文章，现在给出saulzy这篇文章的连接：
http://blog.csdn.net/saulzy/archive/2005/04/23/359648.aspx
里面图文并茂，说得非常清楚
（在这里再一次感谢saulzy）

2.JDBC驱动：mysql-connector-java-3.1.8
这只是一个压缩包，并不需要安装，只要将其解压，我么使用的是文件夹mysql-connector-java-3.1.8里的文件：mysql-connector-java-3.1.8-bin.jar．

3. Mysql界面插件:mysql-front
这是一个安装程序，按照提示安装就可以了．

三．    环境配置
　首先，我要说明的是我现在
tomcat的安装路径是: D:\Program Files\Java\Tomcat
  JDK的安装路径是：D:\Program Files\Java\j2sdk

在这里，需要配置环境变量的是JDBC驱动．在配置前先要把刚才说到的mysql-connector-java-3.1.8-bin.jar本地硬盘某处（我放的地方：D:\Program Files\Java\mysqlforjdbc），然后根据你放的地方，配置classpath，我的配置是这样的：
.;D:\Program files\Java\j2sdk\lib\tools.jar;D:\Program Files\Java\j2sdk\lib\mysql-connector-java-3.1.8-bin-g.jar;D:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.8-bin.jar
配置这个的目的是让你的java应用程序找到连接mysql的驱动．

配置完环境变量后还有很重要一步就是为JSP连接数据库配置驱动，这个其实很简单，就是把mysql-connector-java-3.1.8-bin.jar拷到某些文件夹里就行了，我在网上看了很多资料问了很多人，各种说法都有，我综合了一下，为了保险，我都全做了，呵呵，反正就是拷一个400K的文件而已，现列出要把mysql-connector-java-3.1.8-bin.jar拷进去的文件夹，如下：
D:\Program Files\Java\Tomcat\common\lib
D:\Program Files\Java\Tomcat\shared\lib

四．    数据库的使用

Mysql安装完毕以后，还有一些要注意的地方，这里saulzy也写了篇文章，大家看看就清楚了，连接如下：http://blog.csdn.net/saulzy/archive/2005/04/23/359811.aspx
就象在saulzy的文章力提到的，mysql安装好后最重要一样就是要看数据库有没有作为系统服务启动了，所以在大家进行数据库操作前，应要看看，在操作系统的
开始－＞运行－＞输入services.msc，确定你在安装时你设置的关于mysql的那个服务已经启动，这样你在操作数据库时不会报连接不上的错误．
上面提到了一个较方便的mysql界面插件，但是这个界面是我在已经开始使用mysql后才找到的，刚开始我是在dos下用命令行进行操作的．虽然那个界面也可以进行建库啊，设定权限等操作，但是，我觉得懂得在使用命令行也是一个很重要的技能，所以我先从命令行开始说，怎样简单使用mysql．到后面会谈及mysql－front的使用．

现在我想在mysql里建一个数据库shujuku，以及在数据库里建一个表biao．具体的命令如下（假设mysql我是刚安装好的）

1.    进入dos状态（记住命令行的要运行在mysql的安装目录下的bin目录的）如下图一：
 
2.    连接mysql
输入：mysql ?h localhost ?u root ?p
出现要求输入密码的界面（如图二）
 

输入在安装时已设好的密码，就近入了mysql的命令编辑界面了，如图三：
 
3.    使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号，不然会报错)
显示数据库：show databases;
使用数据库：use 数据库名；
例子如图四：
 

4．建库
命令：create database shujuku;
5.为数据库设置权限（用户和密码）
命令：grant all privileges on shujuku.* to test@localhost identified by  “123456”;
当你执行完这个命令以后，只要你再以用户名：test,密码：123456登录时你就只可以对shujuku这个数据库操作，这样避开使用root，对数据库的安全有很大帮助．如图五
 

6.建表
命令：create table biao(id int(8) primary key,name varchar(10));
如图六

剩下来的与标准sqsl命令基本上是一样的，具体操作略
值得一提的是，你在命令行上输入＂？＂，就会有mysql命令的简单帮助，如图八：
 

呵呵，那样，我们还可以知道退出，就是＂exit＂，呵呵！

五．    关于mysql-front的使用
我找了好几个mysql的界面工具，觉得最简洁方便还是mysql-front，可惜的是要收费，不过还好有试用期，呵呵，可以先感受感受一下，最重要一点是mysql-front有简体中文版的，英文不好的我用起来就舒服多了．下面简单说说使用吧．
首先，安装就不用说了，有向导，而且很简单．安装好后第一次运行时会跳出来一个要求添加对话的框，在这里你可以添加例如上面已经设定好的shujuku，过程如图九，十，十一:
 

当你在注册的复选框里填上你在上面mysql设定好的用户名和密码后，在选择数据库框里就有shujuku 的数据库了，选上，按确定．进入mysql-fron后，你就会看到下面的界面，这是你就可以进行操作了．如图十二
 
 
要说明的是，你还可以把root用户也加进去，这要你在mysql-fron的界面上选
设置－＞对话－＞新建，再按上面进行就可以，出了root你还可以加入更多的用户，方法还是一样的，设置不同的用户，是方便对不同数据库进行管理，呵呵，root是权限最高的，可不要随便让别人使用你的root用户，保正你数据库的安全．

六．    JSP连接mysql
现在就是尝试用jsp连接mysql了
我在eclipse里建了个test_mysql.jsp页面，代码如下：

<%@ page contentType="text/html; charset=gb2312" %>
<%@ page language="java" %>
<%@ page import="com.mysql.jdbc.Driver" %>
<%@ page import="java.sql.*" %>
<%
  //驱动程序名
  String driverName="com.mysql.jdbc.Driver";
  //数据库用户名
  String userName="cl41";
  //密码
  String userPasswd="123456";
  //数据库名
  String dbName="db";
  //表名
  String tableName="dbtest";
  //联结字符串
  String url="jdbc:mysql://localhost/"+dbName+"?user="+userName+"&password="+userPasswd;
  Class.forName("com.mysql.jdbc.Driver").newInstance();
  Connection connection=DriverManager.getConnection(url);
  Statement statement = connection.createStatement();
  String sql="SELECT * FROM "+tableName;
  ResultSet rs = statement.executeQuery(sql);
  //获得数据结果集合
   ResultSetMetaData rmeta = rs.getMetaData();
  //确定数据集的列数，亦字段数
   int numColumns=rmeta.getColumnCount();
  // 输出每一个数据值
 out.print("id");
 out.print("|");
 out.print("num");
 out.print("<br>");
while(rs.next()) {
out.print(rs.getString(1)+" ");  
out.print("|");
out.print(rs.getString(2));
out.print("<br>"); 
}  
out.print("<br>");
out.print("数据库操作成功，恭喜你");
rs.close();  
statement.close();  
connection.close();  
%>  

然后把test¬_mysql.jsp部署到tomcat处，如何部署可参考我的另一篇文章<<配置Eclpise+tomcat并实现JSP的编写与部署>>

在浏览器，你就可以看到如图十三的：
 

呵呵，文章终于写完了，原来写篇简洁清晰，图文并茂的文章真的不容易．还是那句话，希望对度这篇文章的你有帮助吧！Good luck!
由于这里不能贴图片，我把我文章里面的图片都打包了，在附件处！
（如有转载，请注明原作者是cl41,谢谢合作！）

    } catch (Exception e) {
    }

通用惟一标识符是作为tModel 数据结构中的一部分，这种数据结构标识通用描述、发现，和整合（UDDI）注册中的一种服务的类型（注册服务的通用表示法）。这种机制可用来发现网络服务。　　

通用惟一标识符还可以用来指向大多数的可能的物体。微软和其他一些软件公司都倾向使用全球惟一标识符（GUID），这也是通用惟一标识符的一种类型，可用来指向组建对象模块对象和其他的软件组件。第一个通用惟一标识符是在网罗计算机系统（NCS）中创建，并且随后成为开放软件基金会（OSF）的分布式计算环境（DCE）的组件。