jxqc_job
- 浏览: 529 次
-
最新评论
收藏列表
- 全部 [175]
- 默认 [46]
- jython [1]
- java泛型编程 [1]
- js正则表达式详解 [1]
- jdbc连接数据库 [1]
- 数据库连接池配置 [1]
- struts.xml [1]
- java读取xml文件 [1]
- java文件读写操作 [1]
- http://china-pub2010.iteye.com/blog/1413544 [1]
- java连接sql server数据库 [1]
- java连接sql server数据库2 [1]
- web.xml中配置404错误页面 [1]
- 自己的java读取xml文件-采用jdom技术 [1]
- 自己写的java读取xml文件-采用jdom技术-2 [1]
- 自己写的java读取xml文件-采用jdom技术-3 [1]
- js 解析xml文件实现省市级联下拉菜单 [1]
- frame框架的应用 [1]
- frame框架的应用2 [1]
- html 第六章 css + div实现整体布局 [1]
- 为div添加滚动条 博客分类： css [1]
- 布局管理 [1]
- java 连接各种数据库 [1]
- 自己的xml_dtree树形菜单的实现 [1]
- spring连接池配置详解 [1]
- spring连接池配置详解2 [1]
- spring连接池配置详解3 [1]
- hibernate数据库连接池配置 [1]
- tomcat配置数据库连接池 [1]
- tomcat配置数据库连接池2 [1]
- commons-fileupload工具的api与开发实例解析(一) [1]
- 利用 commons-fileupload 实现文件上传 [1]
- apache common fileupload api 详解 [1]
- 用java生成word文档 [1]
- java读取与写入excel文件 [1]
- java读写word文档2 [1]
- java poi word 写文档 [1]
- 实现jxl读取excel的demo实例 [1]
- 使用jacob来处理word文档—jacob的使用及下载安装 [1]
- java读取word文档-3 [1]
- js正则表达式访问网址 [1]
- 正则表达式笔记 [1]
- js正则表达式 2 [1]
- javascript与jquery 控制表格行的字体与背景色 [1]
- 给奇偶行分别设置不同的背景色 [1]
- strtus2通常情况下使用以下两种方式来访问上述三种对象，即servlet api解藕和耦合的访问方式。 [1]
- hibernate批处理 hibernatejdbc [2]
- 自己的jquery-dialog [1]
- struts2 上传文件大小设置 [2]
- struts2 上传文件类型限制 [1]
- jquery 异步提交表单并弹出提示结果信息 [1]
- 超级链接中的target关键字 [1]
- 自己的jquery 异步提交表单并弹出提示结果信息22 [1]
- struts2 ognl表达式的应用 [1]
- hibernate批处理2 [1]
- jquery easyui 操作总结 [1]
- jquery 操作总结 [1]
- jmail 简单应用 [1]
- struts2 文件下载 [1]
- 网页上的表格边框设计更多效果变化 [1]
- struts2文件下载 12 [1]
- 部件表与新物料认证表的关联关系 [1]
- js正则表达式验证数字 [1]
- 自己的hibernate批处理 [1]
- hibernate批处理pojo类 [1]
- hibernate批处理action [1]
- newmateappbilldaoimpl.java [1]
- dqdocumentdaoimpl.java [1]
- dqassemblydaoimpl.java [1]
- 文件上传action [1]
- 文件下载action [1]
- 文件下载页面 [1]
- 从word模板生成word文件 [1]
- <s:action>标签的使用 [1]
- 单元测试-junit [1]
- 单元测试-junit-dao层 [1]
- 监听器的创建 [1]
- holdpuke_1 [1]
- holdpuke_2 [1]
- holdpuke_3 [1]
- holdpuke_4 [1]
- holdpuke_5 [1]
- holdpuke_6 [1]
- holdpuke_7 [1]
- holdpuke_8 [1]
- jython-2 [1]
- jython_3 [1]
- 自定义标签和标签库函数的学习--自己的demo [1]
- 自定义标签和标签库函数的学习 [1]
- 手动编译java文件 [1]
- jquery_demo_1 [1]
- jquery批量文件上传 [1]
- 重写hashcode方法和equals方法demo [1]
- 重写hashcode方法和equals方法demo2 [1]
- 重写hashcode和equals方法2 [1]
- java web定时任务 [1]
- java异地备份 [1]
- linux上部署java web应用 [1]
- 异地备份2 [1]
- java读写文件如何避免中文乱码 [1]
- system.data.sqlclient.sqlerror: 备份集中的数据库备份与现有的 'xxx' 数据库不同 [1]
- sql server 日期操作 [1]
- 用java 程序实现二进制像十进制转化 或十进制转化为二进制 [1]
- sql server 2005 及以上版本的sql分页查询 [1]
- sql server 2005-----sql语句分页sql [1]
- sql中的日期操作 [1]
- dwr demo [1]
- 我的校验码生成技术--demo [1]
- log4j--demo [1]
- license系统功能介绍 [1]
- java枚举类型的使用--demo [1]
- 自己的文件批量压缩demo [1]
- java调用mysql存储过程的简单示例 [1]
- jfreechart报表技术的原理简述： [1]
- 多线程demo--生产者与消费者 [1]
- uploadify传参解决方法 [1]
- svn服务器的配置 [1]
- birtdemo.rptdesign文件01 [1]
- birtdemo.rptdesign文件02 [1]
- 获取birt报表引擎对象 [1]
- http://www.iteye.com/topic/611837 [1]
- 表单校验checkform [1]
- html5 canvas平移-示例 [1]
- html5拖动单个图标 [1]
- div拖动、平移 [1]
- 禁用鼠标点击事件 [1]
- 自己实现的下拉多选框 [1]
- idea中tomcat启动时报内存溢出问题处理 [1]
| 标题 | 标签 | 来源 | |
| Commons-fileupload工具的API与开发实例解析(一) | commons-fileupload工具的api与开发实例解析(一) | ||
Commons-fileupload工具的API与开发实例解析(一)
文件上传组件的应用与编写
在许多Web站点应用中都需要为用户提供通过浏览器上传文档资料的功能，例如，上传邮件附件、个人相片、共享资料等。对文件上传功能，在
浏览器端提供了较好的支持，只要将FORM表单的enctype属性设置为“multipart/form-data”即可；但在Web服务器端如何获取浏览器上传的文
件，需要进行复杂的编程处理。为了简化和帮助Web开发人员接收浏览器上传的文件，一些公司和组织专门开发了文件上传组件。本章将详细介
绍如何使用Apache文件上传组件，以及分析该组件源程序的设计思路和实现方法。
1.1 准备实验环境
按下面的步骤为本章的例子程序建立运行环境：
(1)在Tomcat 5.5.12的<tomcat的安装目录>\webapps目录中创建一个名为fileupload的子目录，并在fileupload目录中创建一个名为test.html
的网页文件，在该文件中写上“这是test.html页面的原始内容!”这几个字符。
(2)在<tomcat的安装目录>\webapps\fileupload目录中创建一个名为WEB-INF的子目录，在WEB-INF目录中创建一个名为classes的子目录和一个
web.xml文件，web.xml文件内容如下：
<web-app>
</web-app>
(3)要使用Apache文件上传组件，首先需要安装Apache文件上传组件包。在<tomcat的安装目录>\webapps\fileupload\WEB-INF目录中创建一个
名为lib的子目录，然后从网址http://jakarta.apache.org/commons/fileupload下载到Apache组件的二进制发行包，在本书的附带带光盘中也
提供了该组件的二进制发行包，文件名为commons-fileupload-1.0.zip。从commons-fileupload-1.0.zip压缩包中解压出commons-fileupload
-1.0.jar文件，将它放置进<tomcat的安装目录>\webapps\fileupload\WEB-INF\lib目录中，就完成了Apache文件上传组件的安装。
(4)在<tomcat的安装目录>\webapps\fileupload目录中创建一个名为src的子目录，src目录用于放置本章编写的Java源程序。为了便于对
Servlet源文件进行编译，在src目录中编写一个compile.bat批处理文件，如例程1-1所示。
例程1-1 compile.bat
set PATH=C:\jdk1.5.0_01\bin;%path%
set CLASSPATH=C:\tomcat-5.5.12\common\lib\servlet-api.jar;C:\tomcat-5.5.12\\webapps\
fileupload\WEB-INF\lib\commons-fileupload-1.0.jar;%CLASSPATH%
javac -d ..\WEB-INF\classes %1
pause
在compile.bat批处理文件中要注意将commons-fileupload-1.0.jar文件的路径加入到CLASSPATH环境变量中和确保编译后生成的class文件存放
到<tomcat安装目录>\webapps\fileupload\WEB-INF\classes目录中，上面的CLASSPATH环境变量的设置值由于排版原因进行了换行，实际上不
应该有换行。接着在src目录中为compile.bat文件创建一个快捷方式，以后只要在Windows资源管理器窗口中将Java源文件拖动到compile.bat
文件的快捷方式上，就可以完成Java源程序的编译了。之所以要创建compile.bat文件的快捷方式，是因为直接将Java源程序拖动到
compile.bat批处理文件时，compile.bat批处理文件内编写的相对路径不被支持。创建完的fileupload目录中的文件结构如图1.1所示。
图1.1
(4)启动Tomcat，在本地计算机的浏览器地址栏中输入如下地址：
http://localhost:8080/fileupload/test.html
验证浏览器能够成功到该网页文档。如果浏览器无法访问到该网页文档，请检查前面的操作步骤和改正问题，直到浏览器能够成功到该网页文
档为止。
(5)为了让/fileupload这个WEB应用程序能自动重新装载发生了修改的Servlet程序，需要修改Tomcat的server.xml文件，在该文件的<Host>元
素中增加如下一个<Context>子元素：
<Context path="/fileupload" docBase="fileupload" reloadable="true"/>
保存server.xml文件后，重新启动Tomcat。
1.2 Apache文件上传组件的应用
Java Web开发人员可以使用Apache文件上传组件来接收浏览器上传的文件，该组件由多个类共同组成，但是，对于使用该组件来编写文件上传
功能的Java Web开发人员来说，只需要了解和使用其中的三个类：DiskFileUpload、FileItem和FileUploadException。这三个类全部位于
org.apache.commons.fileupload包中。
1.2.1查看API文档
在准备实验环境时获得的commons-fileupload-1.0.zip文件的解压缩目录中可以看到一个docs的子目录，其中包含了Apache文件上传组件中的
各个API类的帮助文档，从这个文档中可以了解到各个API类的使用帮助信息。打开文件上传组件API帮助文档中的index.html页面，在左侧分栏
窗口页面中列出了文件上传组件中的各个API类的名称，在右侧分栏窗口页面的底部列出了一段示例代码，如图1.2所示。
图1.2
读者不需要逐个去阅读图1.2中列出的各个API类的帮助文档，而应该以图1.2中的示例代码为线索，以其中所使用到的类为入口点，按图索骥地
进行阅读，对于示例代码中调用到的各个API类的方法则应重点掌握。
1.2.2 DiskFileUpload类
DiskFileUpload类是Apache文件上传组件的核心类，应用程序开发人员通过这个类来与Apache文件上传组件进行交互。下面介绍
DiskFileUpload类中的几个常用的重要方法。
1．setSizeMax方法
setSizeMax方法用于设置请求消息实体内容的最大允许大小，以防止客户端故意通过上传特大的文件来塞满服务器端的存储空间，单位为字节
。其完整语法定义如下：
public void setSizeMax（long sizeMax）
如果请求消息中的实体内容的大小超过了setSizeMax方法的设置值，该方法将会抛出FileUploadException异常。
2．setSizeThreshold方法
Apache文件上传组件在解析和处理上传数据中的每个字段内容时，需要临时保存解析出的数据。因为Java虚拟机默认可以使用的内存空间是有
限的（笔者测试不大于100M），超出限制时将会发生“java.lang.OutOfMemoryError”错误，如果上传的文件很大，例如上传800M的文件，在
内存中将无法保存该文件内容，Apache文件上传组件将用临时文件来保存这些数据；但如果上传的文件很小，例如上传600个字节的文件，显然
将其直接保存在内存中更加有效。setSizeThreshold方法用于设置是否使用临时文件保存解析出的数据的那个临界值，该方法传入的参数的单
位是字节。其完整语法定义如下：
public void setSizeThreshold(int sizeThreshold)
3. setRepositoryPath方法
setRepositoryPath方法用于设置setSizeThreshold方法中提到的临时文件的存放目录，这里要求使用绝对路径。其完整语法定义如下：
public void setRepositoryPath(String repositoryPath)
如果不设置存放路径，那么临时文件将被储存在"java.io.tmpdir"这个JVM环境属性所指定的目录中，tomcat 5.5.9将这个属性设置为了
“<tomcat安装目录>/temp/”目录。
4. parseRequest方法
parseRequest 方法是DiskFileUpload类的重要方法，它是对HTTP请求消息进行解析的入口方法，如果请求消息中的实体内容的类型不是
“multipart/form-data”，该方法将抛出FileUploadException异常。parseRequest 方法解析出FORM表单中的每个字段的数据，并将它们分别
包装成独立的FileItem对象，然后将这些FileItem对象加入进一个List类型的集合对象中返回。parseRequest 方法的完整语法定义如下：
public List parseRequest(HttpServletRequest req)
parseRequest 方法还有一个重载方法，该方法集中处理上述所有方法的功能，其完整语法定义如下：
parseRequest(HttpServletRequest req,int sizeThreshold,long sizeMax,
String path)
这两个parseRequest方法都会抛出FileUploadException异常。
5. isMultipartContent方法
isMultipartContent方法方法用于判断请求消息中的内容是否是“multipart/form-data”类型，是则返回true，否则返回false。
isMultipartContent方法是一个静态方法，不用创建DiskFileUpload类的实例对象即可被调用，其完整语法定义如下：
public static final boolean isMultipartContent(HttpServletRequest req)
6. setHeaderEncoding方法
由于浏览器在提交FORM表单时，会将普通表单中填写的文本内容传递给服务器，对于文件上传字段，除了传递原始的文件内容外，还要传递其
文件路径名等信息，如后面的图1.3所示。不管FORM表单采用的是“application/x-www-form-urlencoded”编码，还是“multipart/form-data
”编码，它们仅仅是将各个FORM表单字段元素内容组织到一起的一种格式，而这些内容又是由某种字符集编码来表示的。关于浏览器采用何种
字符集来编码FORM表单字段中的内容，请参看笔者编著的《深入体验java Web开发内幕——核心基础》一书中的第6.9.2的讲解，
“multipart/form-data”类型的表单为表单字段内容选择字符集编码的原理和方式与“application/x-www-form-urlencoded”类型的表单是
相同的。FORM表单中填写的文本内容和文件上传字段中的文件路径名在内存中就是它们的某种字符集编码的字节数组形式，Apache文件上传组
件在读取这些内容时，必须知道它们所采用的字符集编码，才能将它们转换成正确的字符文本返回。
对于浏览器上传给WEB服务器的各个表单字段的描述头内容，Apache文件上传组件都需要将它们转换成字符串形式返回，setHeaderEncoding 方
法用于设置转换时所使用的字符集编码，其原理与笔者编著的《深入体验java Web开发内幕——核心基础》一书中的第6.9.4节讲解的
ServletRequest.setCharacterEncoding方法相同。setHeaderEncoding 方法的完整语法定义如下：
public void setHeaderEncoding(String encoding)
其中，encoding参数用于指定将各个表单字段的描述头内容转换成字符串时所使用的字符集编码。
注意：如果读者在使用Apache文件上传组件时遇到了中文字符的乱码问题，一般都是没有正确调用setHeaderEncoding方法的原因。
1.2.3 FileItem类
FileItem类用来封装单个表单字段元素的数据，一个表单字段元素对应一个FileItem对象，通过调用FileItem对象的方法可以获得相关表单字
段元素的数据。FileItem是一个接口，在应用程序中使用的实际上是该接口一个实现类，该实现类的名称并不重要，程序可以采用FileItem接
口类型来对它进行引用和访问，为了便于讲解，这里将FileItem实现类称之为FileItem类。FileItem类还实现了Serializable接口，以支持序
列化操作。
对于“multipart/form-data”类型的FORM表单，浏览器上传的实体内容中的每个表单字段元素的数据之间用字段分隔界线进行分割，两个分隔
界线间的内容称为一个分区，每个分区中的内容可以被看作两部分，一部分是对表单字段元素进行描述的描述头，另外一部是表单字段元素的
主体内容，如图1.3所示。
图 1.3
主体部分有两种可能性，要么是用户填写的表单内容，要么是文件内容。FileItem类对象实际上就是对图1.3中的一个分区的数据进行封装的对
象，它内部用了两个成员变量来分别存储描述头和主体内容，其中保存主体内容的变量是一个输出流类型的对象。当主体内容的大小小于
DiskFileUpload.setSizeThreshold方法设置的临界值大小时，这个流对象关联到一片内存，主体内容将会被保存在内存中。当主体内容的数据
超过DiskFileUpload.setSizeThreshold方法设置的临界值大小时，这个流对象关联到硬盘上的一个临时文件，主体内容将被保存到该临时文件
中。临时文件的存储目录由DiskFileUpload.setRepositoryPath方法设置，临时文件名的格式为“upload_00000005（八位或八位以上的数字）
.tmp”这种形式，FileItem类内部提供了维护临时文件名中的数值不重复的机制，以保证了临时文件名的唯一性。当应用程序将主体内容保存
到一个指定的文件中时，或者在FileItem对象被垃圾回收器回收时，或者Java虚拟机结束时，Apache文件上传组件都会尝试删除临时文件，以
尽量保证临时文件能被及时清除。
下面介绍FileItem类中的几个常用的方法：
1. isFormField方法
isFormField方法用于判断FileItem类对象封装的数据是否属于一个普通表单字段，还是属于一个文件表单字段，如果是普通表单字段则返回
true，否则返回false。该方法的完整语法定义如下：
public boolean isFormField()
2. getName方法
getName方法用于获得文件上传字段中的文件名，对于图1.3中的第三个分区所示的描述头，getName方法返回的结果为字符串“C:\bg.gif”。
如果FileItem类对象对应的是普通表单字段，getName方法将返回null。即使用户没有通过网页表单中的文件字段传递任何文件，但只要设置了
文件表单字段的name属性，浏览器也会将文件字段的信息传递给服务器，只是文件名和文件内容部分都为空，但这个表单字段仍然对应一个
FileItem对象，此时，getName方法返回结果为空字符串""，读者在调用Apache文件上传组件时要注意考虑这个情况。getName方法的完整语法
定义如下：
public String getName()
注意：如果用户使用Windows系统上传文件，浏览器将传递该文件的完整路径，如果用户使用Linux或者Unix系统上传文件，浏览器将只传递该
文件的名称部分。
3．getFieldName方法
getFieldName方法用于返回表单字段元素的name属性值，也就是返回图1.3中的各个描述头部分中的name属性值，例如“name=p1”中的“p1”
。getFieldName方法的完整语法定义如下：
public String getFieldName()
4. write方法
write方法用于将FileItem对象中保存的主体内容保存到某个指定的文件中。如果FileItem对象中的主体内容是保存在某个临时文件中，该方法
顺利完成后，临时文件有可能会被清除。该方法也可将普通表单字段内容写入到一个文件中，但它主要用途是将上传的文件内容保存在本地文
件系统中。其完整语法定义如下：
public void write(File file)
5．getString方法
getString方法用于将FileItem对象中保存的主体内容作为一个字符串返回，它有两个重载的定义形式：
public java.lang.String getString()
public java.lang.String getString(java.lang.String encoding)
throws java.io.UnsupportedEncodingException
前者使用缺省的字符集编码将主体内容转换成字符串，后者使用参数指定的字符集编码将主体内容转换成字符串。如果在读取普通表单字段元
素的内容时出现了中文乱码现象，请调用第二个getString方法，并为之传递正确的字符集编码名称。
6. getContentType方法
getContentType 方法用于获得上传文件的类型，对于图1.3中的第三个分区所示的描述头，getContentType方法返回的结果为字符串
“image/gif”，即“Content-Type”字段的值部分。如果FileItem类对象对应的是普通表单字段，该方法将返回null。getContentType 方法
的完整语法定义如下：
public String getContentType()
7. isInMemory方法
isInMemory方法用来判断FileItem类对象封装的主体内容是存储在内存中，还是存储在临时文件中，如果存储在内存中则返回true，否则返回
false。其完整语法定义如下：
public boolean isInMemory()
8. delete方法
delete方法用来清空FileItem类对象中存放的主体内容，如果主体内容被保存在临时文件中，delete方法将删除该临时文件。尽管Apache组件
使用了多种方式来尽量及时清理临时文件，但系统出现异常时，仍有可能造成有的临时文件被永久保存在了硬盘中。在有些情况下，可以调用
这个方法来及时删除临时文件。其完整语法定义如下：
public void delete()
1.2.4 FileUploadException类
在文件上传过程中，可能发生各种各样的异常，例如网络中断、数据丢失等等。为了对不同异常进行合适的处理，Apache文件上传组件还开发
了四个异常类，其中FileUploadException是其他异常类的父类，其他几个类只是被间接调用的底层类，对于Apache组件调用人员来说，只需对
FileUploadException异常类进行捕获和处理即可。
|
|||
| tomcat配置数据库连接池2 | tomcat配置数据库连接池2 | ||
华宰
设置tomcat数据库连接池
华宰 发布于 2010年12月21日 21时, 0评/2755阅
分享到
新浪微博腾讯微博
收藏+11
踩 顶 0
首先需要将数据库的jdbc驱动程序jar包拷贝到tomcat的lib目录下
标签： 连接池 Tomcat
代码片段(3)
[代码] server.xml
view source
print?
01 <!-- Oracle 数据库 -->
02 <Context path="/app1" docBase="app1" debug="1" reloadable="true" crossContext="true">
03
04 <Resource name="jdbc/orcldb" auth="Container" type="javax.sql.DataSource"/>
05 <ResourceParams name="jdbc/orcldb">
06 <parameter><name>factory</name><value>org.apache.commons.dbcp.BasicDataSourceFactory</value></parameter>
07 <parameter><name>driverClassName</name><value>oracle.jdbc.driver.OracleDriver</value></parameter>
08 <parameter><name>url</name><value>jdbc:oracle:thin:@localhost:1521:orcl</value></parameter>
09 <parameter><name>username</name><value>user</value></parameter>
10 <parameter><name>password</name><value>pwd</value></parameter>
11 <parameter><name>maxActive</name><value>20</value></parameter>
12 <parameter><name>maxIdle</name><value>10</value></parameter>
13 <parameter><name>maxWait</name><value>10000</value></parameter>
14 </ResourceParams>
15 </Context>
[代码] 接下来要在WEB-INF里的web.xml里加上以下信息
view source
print?
01 <?xml version="1.0" encoding="ISO-8859-1"?>
02 <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
03 "http://java.sun.com/dtd/web-app_2_3.dtd">
04 <web-app>
05 <description>oralceDB</description>
06 <resource-ref>
07 <description>DB Connection</description>
08 <res-ref-name>jdbc/orcldb</res-ref-name>
09 <res-type>javax.sql.DataSource</res-type>
10 <res-auth>Container</res-auth>
11 </resource-ref>
12 </web-app>
[代码] 调用方法
view source
print?
01 /**
02 * 返回Oracle数据库连接 注意：红色的字体表示他要调用的连接池名，同配置
03 * @return Connection
04 * @throws SQLException
05 */
06 public static synchronized Connection getOracleConn() throws SQLException {
07 try {
08 Context jndiCntx = new InitialContext();
09 DataSource ds = (DataSource)jndiCntx.lookup( "java:comp/env/jdbc/orcldb");
10 return ds.getConnection();
11 }catch (NamingException ne) {
12 throw new EJBException(ne);
13 }
14 }
|
|||
| tomcat配置数据库连接池 | tomcat配置数据库连接池 | ||
Tomcat 数据库连接池配置(各种版本)
Tomcat 数据库连接池配置
前言 :
1 准备 mysql 的 jdbc 驱动程序
2 安装 Tomcat 默认全部装在 D:\Server\tomcat5.0 D:\Server\tomcat5.5 D:\Server\tomcat6.0
3 以 TOMCAT_HOME 代替个版本的安装目录
4 将 jdbc 驱动放入 TOMCAT_HOME\ common\lib\ 下面
5 如果是其他数据库的话，就是换一下 jdbc 驱动以及各种参数就可以了的
6 配置 tomcat 数据源时的各种参数的详细介绍
7 其他设置。
1. Tomcat 4.0
待添加
2. Tomcat 5.0
2.1 建一个虚拟目录 test (TOMCAT_HOME\webapps\)
可以通过 http://localhost:8080/test 访问你的网站了
2.2 配置 Context ( 在 TOMCAT_HOME\conf\Catalina\localhost\ 下 建 test.xm,)
test.xml:
<?xml version="1.0" encoding="utf-8"?>
<Context docBase="dbpool" path="/test" workDir="work\Catalina\localhost\test">
</Context>
2.3 配置 server.xml
server.xml 的内容 : 红色表示加入的 ( 或者通过 http://localhost:8080/admin 进行可视化配置 )
<?xml version='1.0' encoding='utf-8'?>
<Server>
<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"/>
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"/>
<GlobalNamingResources>
<Environment name="simpleValue" type="java.lang.Integer" value="30"/>
<Resource auth="Container" description="User database that can be updated and saved" name="UserDatabase" type="org.apache.catalina.UserDatabase"/>
<Resource auth="Container" name="jdbc/mysql" type="javax.sql.DataSource"/>
<ResourceParams name="UserDatabase">
<parameter>
<name>factory</name>
<value>org.apache.catalina.users.MemoryUserDatabaseFactory</value>
</parameter>
<parameter>
<name>pathname</name>
<value>conf/tomcat-users.xml</value>
</parameter>
</ResourceParams>
<ResourceParams name="jdbc/mysql">
<parameter>
<name>maxWait</name>
<value>5000</value>
</parameter>
<parameter>
<name>maxActive</name>
<value>4</value>
</parameter>
<parameter>
<name>password</name>
<value>198395</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:mysql://localhost:3306/study?autoReconnect=true</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>com.mysql.jdbc.Driver</value>
</parameter>
<parameter>
<name>maxIdle</name>
<value>2</value>
</parameter>
<parameter>
<name>username</name>
<value>sa</value>
</parameter>
</ResourceParams>
</GlobalNamingResources>
<Service name="Catalina">
<Connector acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" port="8080" redirectPort="8443" maxSpareThreads="75" maxThreads="150" minSpareThreads="25">
</Connector>
<Connector port="8009" protocol="AJP/1.3" protocolHandlerClassName="org.apache.jk.server.JkCoyoteHandler" redirectPort="8443">
</Connector>
<Engine defaultHost="localhost" name="Catalina">
<Host appBase="webapps" name="localhost">
<Logger className="org.apache.catalina.logger.FileLogger" prefix="localhost_log." suffix=".txt" timestamp="true"/>
</Host>
<Logger className="org.apache.catalina.logger.FileLogger" prefix="catalina_log." suffix=".txt" timestamp="true"/>
<Realm className="org.apache.catalina.realm.UserDatabaseRealm"/>
</Engine>
</Service>
</Server>
2.4 配置 虚拟目录命名的 test.xml
test.xml: 红色表示加入的
<?xml version='1.0' encoding='utf-8'?>
<Context docBase="testds" path="/testds" workDir="work\Catalina\localhost\testds">
<Resource name="jdbc/mysql" type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/mysql">
<parameter>
<name>maxWait</name>
<value>5000</value>
</parameter>
<parameter>
<name>maxActive</name>
<value>4</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:mysql://127.0.0.1:3306/study?useUnicode=true</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>org.gjt.mm.mysql.Driver</value>
</parameter>
<parameter>
<name>maxIdle</name>
<value>2</value>
</parameter>
<parameter>
<name>username</name>
<value>sa</value>
</parameter>
<parameter>
<name>password</name>
<value>198395</value>
</parameter>
</ResourceParams>
</Context>
配置完毕
3. Tomcat 5.5
3.1 建虚拟目录 test( 在 TOMCAT_HOME/webapp 或者其地方 )
可以通过 http://localhost:8080/test 访问你的网站了
3.2 配置 server..xml( 或者可以通过 http://localhost:8080/admin 来可视化界面来完成 )
server.xml 内容 红色是加入的内容
<?xml version="1.0" encoding="UTF-8"?>
<Server>
<Listener className="org.apache.catalina.core.AprLifecycleListener"/>
<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener"/>
<Listener className="org.apache.catalina.storeconfig.StoreConfigLifecycleListener"/>
<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener"/>
<GlobalNamingResources>
<Environment
name="simpleValue"
type="java.lang.Integer"
value="30"/>
<Resource
auth="Container"
description="User database that can be updated and saved"
name="UserDatabase"
type="org.apache.catalina.UserDatabase"
pathname="conf/tomcat-users.xml"
factory="org.apache.catalina.users.MemoryUserDatabaseFactory"/>
<Resource
name="jdbc/mysql"
type="javax.sql.DataSource"
password="198395"
driverClassName="com.mysql.jdbc.Driver"
maxIdle="2"
maxWait="5000"
username="sa"
url="jdbc:mysql://localhost:3306/study?autoReconnect=true"
maxActive="4"/>
</GlobalNamingResources>
<Service
name="Catalina">
<Connector
port="8080"
redirectPort="8443"
minSpareThreads="25"
connectionTimeout="20000"
maxSpareThreads="75"
maxThreads="150">
</Connector>
<Connector
port="8009"
redirectPort="8443"
protocol="AJP/1.3">
</Connector>
<Engine
defaultHost="localhost"
name="Catalina">
<Realm className="org.apache.catalina.realm.UserDatabaseRealm"/>
<Host
appBase="webapps"
name="localhost">
</Host>
</Engine>
</Service>
</Server>
3.3 配置 Context ( 在 TOMCAT_HOME\conf\Catalina\localhost\ 下 建 test.xml 与项目名字一样 )
test.xml 红色表示新加入的
<?xml version="1.0" encoding="UTF-8"?>
<Context path="/test" docBase="test" reloadable="true" crossContext="true" debug="0" >
<Resource name="jdbc/mysql" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="30" maxWait="10000" username="sa" password="198395" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/study?useUnicode=true"/>
</Context>
4. Tomcat 6.0
5. 测试用例
DatasourceCon.jsp
<%@ page language="java" pageEncoding="utf-8"%>
<%@ page import="java.sql.*"%>
<%@ page import="javax.sql.*"%>
<%@ page import="javax.naming.*"%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>Test of Tomcat connection pool</title>
</head>
<body>
<%
out.print("strat test connection pool!<br/>");
try{
Context initCtx = new InitialContext();
Context ctx = (Context) initCtx.lookup("java:comp/env");
Object obj = (Object) ctx.lookup("jdbc/mysql");
DataSource ds = (javax.sql.DataSource)obj;
Connection conn = ds.getConnection();
out.print("tomcat mysql connection pool runs perfectly!");
conn.close();
}
catch(Exception ex){
out.print(ex.getMessage());
ex.printStackTrace();
}
%>
</body>
</html>
6. 总结
好长时间没有写这个了，最近因为项目的需要，根据以前配置过的，现在重新配置一下，然后写成详细文档！
|
|||
| hibernate数据库连接池配置 | hibernate数据库连接池配置 | ||
本文主要内容：
Hibernate 连接池的三种配置方式：dbcp , c3p0 , proxool
URL的多种指定方式
连接池监控
上班第二天，看到公司的Hibernate配置文件在写法上，跟我以前的不一样，就去研究了哈，得出的结果如下。
在hibernate3.0中，已经不再支持dbcp了，hibernate的作者在hibernate.org中，
明确指出在实践中发现dbcp有BUG,在某些种情会产生很多空连接不能释放，
所以抛弃了对dbcp的支持。
1 =================== C3P0 配置 =============================
Xml代码 收藏代码
1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE hibernate-configuration PUBLIC
3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
5. <hibernate-configuration>
6. <session-factory>
7. <!-- 配置事务实现方式 -->
8. <property name="transaction.factory_class">
9. org.hibernate.transaction.JDBCTransactionFactory
10. </property>
11.
12. <!-- 配置JDBC里batch的大小 -->
13. <property name="jdbc.batch_size">50</property>
14. <property name="cache.use_second_level_cache">false</property>
15.
16. <!-- 配置线程安全的session -->
17. <property name="current_session_context_class">thread</property>
18.
19. <!-- 显示SQL -->
20. <property name="show_sql">true</property>
21. <property name="format_sql">true</property>
22.
23. <!-- 配置数据库方言 -->
24. <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
25.
26. <!-- 配置数据库连接 -->
27. <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
28. <property name="connection.username">0804</property>
29. <property name="connection.password">0804</property>
30. <property name="connection.url">jdbc:oracle:thin:@192.168.0.200:1521:orcl</property>
31.
32. <!-- 配置连接池 -->
33. <property name="c3p0.max_size">2</property>
34. <property name="c3p0.min_size">2</property>
35. <property name="c3p0.timeout">5000</property>
36. <property name="c3p0.max_statements">100</property>
37. <property name="c3p0.idle_test_period">3000</property>
38. <property name="c3p0.acquire_increment">2</property>
39. <property name="c3p0.validate">false</property>
40.
41. <!-- 指定hibernate管理的映射文件 -->
42. <mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
43. <mapping resource="com/ket/ruan/so/entity/Product.hbm.xml"/>
44. 。。。。。
45. </session-factory>
46. </hibernate-configuration>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 配置事务实现方式 -->
<property name="transaction.factory_class">
org.hibernate.transaction.JDBCTransactionFactory
</property>
<!-- 配置JDBC里batch的大小 -->
<property name="jdbc.batch_size">50</property>
<property name="cache.use_second_level_cache">false</property>
<!-- 配置线程安全的session -->
<property name="current_session_context_class">thread</property>
<!-- 显示SQL -->
<property name="show_sql">true</property>
<property name="format_sql">true</property>
<!-- 配置数据库方言 -->
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<!-- 配置数据库连接 -->
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.username">0804</property>
<property name="connection.password">0804</property>
<property name="connection.url">jdbc:oracle:thin:@192.168.0.200:1521:orcl</property>
<!-- 配置连接池 -->
<property name="c3p0.max_size">2</property>
<property name="c3p0.min_size">2</property>
<property name="c3p0.timeout">5000</property>
<property name="c3p0.max_statements">100</property>
<property name="c3p0.idle_test_period">3000</property>
<property name="c3p0.acquire_increment">2</property>
<property name="c3p0.validate">false</property>
<!-- 指定hibernate管理的映射文件 -->
<mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
<mapping resource="com/ket/ruan/so/entity/Product.hbm.xml"/>
。。。。。
</session-factory>
</hibernate-configuration>
2 ============= 使用 proxool =============================
Xml代码 收藏代码
1. <hibernate-configuration>
2. <session-factory>
3. <property name="show_sql">true</property>
4. <property name="dialect">
5. org.hibernate.dialect.MySQLDialect
6. </property>
7.
8. <!-- 配置proxool属性 -->
9. <!--- 使用proxoolConf.xml中定义的别名 -->
10. <property name="proxool.pool_alias">pool1</property>
11. <!-- 指定使用的proxoolConf文件的位置（这里在SRC下）-->
12. <property name="proxool.xml">ProxoolConf.xml</property>
13. <property name="connection.provider_class">
14. org.hibernate.connection.ProxoolConnectionProvider
15. </property>
16. ....
17. <!-- 指定hibernate管理的映射文件 -->
18. <mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
19. ....
20. </hibernate-configuration>
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property>
<property name="dialect">
org.hibernate.dialect.MySQLDialect
</property>
<!-- 配置proxool属性 -->
<!--- 使用proxoolConf.xml中定义的别名 -->
<property name="proxool.pool_alias">pool1</property>
<!-- 指定使用的proxoolConf文件的位置（这里在SRC下）-->
<property name="proxool.xml">ProxoolConf.xml</property>
<property name="connection.provider_class">
org.hibernate.connection.ProxoolConnectionProvider
</property>
....
<!-- 指定hibernate管理的映射文件 -->
<mapping resource="com/ket/ruan/so/entity/User.hbm.xml"/>
....
</hibernate-configuration>
------------ProxoolConf.xml--------------------
xml 文件放在同级目录中
需要 proxool-0.8.3.jar
Xml代码 收藏代码
1. <?xml version="1.0" encoding="gb2312"?>
2. <something-else-entirely>
3. <proxool>
4. <alias>pool1</alias>
5. <driver-url>
6. jdbc:mysql://tpdb:3306/tpdb
7. </driver-url>
8. <driver-class>com.mysql.jdbc.Driver</driver-class>
9. <driver-properties>
10. <property name="user" value="username"/>
11. <property name="password" value="password"/>
12. <property name="schema" value="tpdb"/> <!-- ？？？-->
13. <!-- 自动重连 -->
14. <property name="autoReconnect" value="true"/>
15. </driver-properties>
16. <!-- proxool自动侦察各个连接状态的时间间隔(毫秒),
17. 侦察到空闲的连接就马上回收,超时的销毁-->
18. <house-keeping-sleep-time>90000</house-keeping-sleep-time>
19. <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的
20. 用户连接就不会被接受(正式库10，测试库1)-->
21. <maximum-new-connections>10</maximum-new-connections>
22. <!-- 最少保持的空闲连接数(正式库10，测试库1)-->
23. <prototype-count>10</prototype-count>
24. <!-- 连接池允许的最大连接数(正式库700，测试库10)-->
25. <maximum-connection-count>700</maximum-connection-count>
26. <!-- 连接池开启的最小连接数(正式库350，测试库5)-->
27. <minimum-connection-count>350</minimum-connection-count>
28. <!-- 一个活动连接的最长时间15分钟，单位毫秒 -->
29. <maximum-active-time>900000</maximum-active-time>
30. <!-- 一个连接的最长活动时间4小时，单位毫秒 -->
31. <maximum-connection-lifetime>14400000</maximum-connection-lifetime>
32. <!-- 自动检查连接是否断掉开关 -->
33. <test-before-use>true</test-before-use>
34. <!-- 自动检查连接是否断的测试sql语句 -->
35. <house-keeping-test-sql>select sysdate() from dual</house-keeping-test-sql>
36. </proxool>
37. </something-else-entirely>
<?xml version="1.0" encoding="gb2312"?>
<something-else-entirely>
<proxool>
<alias>pool1</alias>
<driver-url>
jdbc:mysql://tpdb:3306/tpdb
</driver-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<driver-properties>
<property name="user" value="username"/>
<property name="password" value="password"/>
<property name="schema" value="tpdb"/> <!-- ？？？-->
<!-- 自动重连 -->
<property name="autoReconnect" value="true"/>
</driver-properties>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),
侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的
用户连接就不会被接受(正式库10，测试库1)-->
<maximum-new-connections>10</maximum-new-connections>
<!-- 最少保持的空闲连接数(正式库10，测试库1)-->
<prototype-count>10</prototype-count>
<!-- 连接池允许的最大连接数(正式库700，测试库10)-->
<maximum-connection-count>700</maximum-connection-count>
<!-- 连接池开启的最小连接数(正式库350，测试库5)-->
<minimum-connection-count>350</minimum-connection-count>
<!-- 一个活动连接的最长时间15分钟，单位毫秒 -->
<maximum-active-time>900000</maximum-active-time>
<!-- 一个连接的最长活动时间4小时，单位毫秒 -->
<maximum-connection-lifetime>14400000</maximum-connection-lifetime>
<!-- 自动检查连接是否断掉开关 -->
<test-before-use>true</test-before-use>
<!-- 自动检查连接是否断的测试sql语句 -->
<house-keeping-test-sql>select sysdate() from dual</house-keeping-test-sql>
</proxool>
</something-else-entirely>
============ 数据库名可以这样指定 ==============
Xml代码 收藏代码
1. <property name="connection.url">
2. jdbc:sqlserver://localhost:1433;DatabaseName=supermarket
3. </property>
<property name="connection.url">
jdbc:sqlserver://localhost:1433;DatabaseName=supermarket
</property>
==============URL 还可以传参数===================
Xml代码 收藏代码
1. <property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
2. <property name="connection.url">
3. jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBK
4. </property>
<property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
<property name="connection.url">
jdbc:mysql://localhost:3306/struts?useUnicode=true&characterEncoding=GBK
</property>
目前，proxool用法，被大部分人认为是最优秀的。
=========== 连接池监控 ===================
1.在web.xml中加上下面这段
Xml代码 收藏代码
1. <servlet>
2. <servlet-name> proxool </servlet-name>
3. <servlet-class> org.logicalcobwebs.proxool.admin.servlet.AdminServlet
4.
5. </servlet-class>
6. </servlet>
7. <servlet-mapping>
8. <servlet-name> proxool </servlet-name>
9. <url-pattern> /Admin/proxool/ </url-pattern>
10. </servlet-mapping>
|
|||
| spring连接池配置详解3 | spring连接池配置详解3 | ||
spring配置详解-连接池配置（转载）
一、连接池概述
数据库连接池概述：
数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个
应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。
数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时
间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些
数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接
数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设
置要考虑到下列几个因素：
1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；
2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之
后的数据库操作。
3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库
连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。
目前常用的连接池有：C3P0、DBCP、Proxool
网上的评价是：
C3P0比较耗费资源，效率方面可能要低一点。
DBCP在实践中存在BUG，在某些种情会产生很多空连接不能释放，Hibernate3.0已经放弃了对其的支持。
Proxool的负面评价较少，现在比较推荐它，而且它还提供即时监控连接池状态的功能，便于发现连接泄漏的情况。
配置如下：
1、在spring配置文件中，一般在applicationContext.xml中
<bean id="proxoolDataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
<property name="driver" value="${jdbc.connection.driverClassName}"/>
<property name="driverUrl" value="${jdbc.connection.url}"/>
<property name="user" value="${jdbc.connection.username}"/>
<property name="password" value="${jdbc.connection.password}"/>
<!-- 测试的SQL执行语句 -->
<property name="houseKeepingTestSql" value="${proxool.houseKeepingTestSql}"/>
<!-- 最少保持的空闲连接数 （默认2个） -->
<property name="prototypeCount" value="${proxool.prototypeCount}"/>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁 默认30秒） -->
<property name="houseKeepingSleepTime" value="${proxool.hourseKeepingSleepTime}"/>
<!-- 最大活动时间(超过此时间线程将被kill,默认为5分钟) -->
<property name="maximumActiveTime" value="${proxool.maximumActiveTime}"/>
<!-- 连接最长时间(默认为4个小时) -->
<property name="maximumConnectionLifetime" value="${proxool.maximumConnectionLifetime}"/>
<!-- 最小连接数 （默认2个） -->
<property name="minimumConnectionCount" value="${proxool.minimumConnectionCount}"/>
<!-- 最大连接数 （默认5个） -->
<property name="maximumConnectionCount" value="${proxool.maximumConnectionCount}"/>
<!-- -->
<property name="statistics" value="${proxool.statistics}"/>
<!-- 别名 -->
<property name="alias" value="${proxool.alias}"/>
<!-- -->
<property name="simultaneousBuildThrottle" value="${proxool.simultaneous-build-throttle}"/>
</bean>
然后注入到sessionFactory中
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="proxoolDataSource"/>
</bean>
Porxool 配置文件
--==--==--==--==--==<proxool.xml>==--==--==--==--==--==--==
<?xml version="1.0" encoding="UTF-8"?>
<proxool>
<alias>WMS</alias>
<driver-url>jdbc:postgresql://192.168.210.184:5432/wms</driver-url>
<driver-class>org.postgresql.Driver</driver-class>
<driver-properties>
<property name="user" value="wms_user" />
<property name="password" value="wms" />
</driver-properties>
<minimum-connection-count>2</minimum-connection-count>
<maximum-connection-count>40</maximum-connection-count>
<simultaneous-build-throttle>20</simultaneous-build-throttle>
<prototype-count>2</prototype-count>
<house-keeping-test-sql>select CURRENT_DATE</house-keeping-test-sql>
</proxool>
--==--==--==--==--==<proxool.xml>==--==--==--==--==--==--==
配置说明：
alias -〉数据库连接别名（程序中需要使用的名称）
driver-url -〉数据库驱动
driver-class -〉驱动程序类
driver-properties -〉联机数据库的用户和密码
minimum-connection-count -〉最小连接数量，建议设置0以上，保证第一次连接时间
maximum-connection-count -〉最大连接数量，如果超过最大连接数量则会抛出异常。连接数设置过多，服务器CPU和内存性能消耗很
大。
simultaneous-build-throttle -〉同时最大连接数
prototype-count -〉一次产生连接的数量。
例：如果现在prototype-count设置为4个，但是现在已经有2个可以获得的连接，那么
将会试图再创建2个连接。
但不能超过最大连接数。
maximum-active-time -〉连接最大时间活动 默认5分钟
maximum-connection-lifetime -〉连接最大生命时间 默认4小时
posted on 2010-08-27 10:25 不高兴 阅读(3750) 评论(0) 编辑 收藏 所属分类: Java
|
|||
| spring连接池配置详解2 | spring连接池配置详解2 | ||
spring中连接池的配置
在默认通过myeclipse生成的配置里，spring使用的是apache的dbcp连接池
<bean id="dataSource"
??class="org.apache.commons.dbcp.BasicDataSource">
??<property name="driverClassName"
???value="com.mysql.jdbc.Driver">
??</property>
??<property name="url"
???value="jdbc:mysql://localhost:3306/mysql">
??</property>
??<property name="username" value="root"></property>
??<property name="password" value="root"></property>
?</bean>
如果改为C3P0则为：
<bean id="propertyConfigurer"
??????? class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
??????? <property name="location">
??????????? <value>classpath:jdbc.properties</value>
??????? </property>
??? </bean>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
??????? <property name="driverClass" value="com.mysql.jdbc.Driver" />
??????? <property name="jdbcUrl" value="${jdbc.url}" />
??????? <property name="user" value="${jdbc.username}" />
??????? <property name="password" value="${jdbc.password}" />
??????? <property name="autoCommitOnClose" value="true"/>
??????? <property name="checkoutTimeout" value="${cpool.checkoutTimeout}"/>
??????? <property name="initialPoolSize" value="${cpool.minPoolSize}"/>
??????? <property name="minPoolSize" value="${cpool.minPoolSize}"/>
??????? <property name="maxPoolSize" value="${cpool.maxPoolSize}"/>
??????? <property name="maxIdleTime" value="${cpool.maxIdleTime}"/>
??????? <property name="acquireIncrement" value="${cpool.acquireIncrement}"/>
??????? <property name="maxIdleTimeExcessConnections" value="${cpool.maxIdleTimeExcessConnections}"/>
??? </bean>
jdbc.properties：
# Database URL
jdbc.url=jdbc:mysql://192.168.0.25"3306/db
# Database login information
jdbc.username=root
jdbc.password=
# Time to wait for an open connection before timing out
# (in milliseconds)
cpool.checkoutTimeout=5000
# Connection pool size
cpool.minPoolSize=5
cpool.maxPoolSize=40
# How long to keep unused connections around(in seconds)
# Note: MySQL times out idle connections after 8 hours(28,800 seconds)
# so ensure this value is below MySQL idle timeout
cpool.maxIdleTime=25200
# How long to hang on to excess unused connections after traffic spike
# (in seconds)
cpool.maxIdleTimeExcessConnections=1800
# Acquiring new connections is slow, so eagerly retrieve extra connections
# when current pool size is reached
cpool.acquireIncrement=5
或者将上面的3部分写成一个：
<bean id="c3p0DataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
????? <property name="driverClass">
??????? <value>${jdbc.driverClassName}</value>
????? </property>
????? <property name="jdbcUrl">
??????? <value>${jdbc.url}</value>
????? </property>
????? <property name="user">
?????? <value>${jdbc.username}</value>
????? </property>
????? <property name="password">
?????? <value>${jdbc.password}</value>
????? </property>
????? <property name="initialPoolSize"><value>10</value></property>
????? <property name="minPoolSize"><value>5</value></property>
????? <property name="maxPoolSize"><value>30</value></property>
????? <property name="acquireIncrement"><value>5</value></property>
????? <property name="maxIdleTime"><value>10</value></property>
????? <property name="maxStatements"><value>0</value></property>
??? </bean>
如果使用的是受管理的J2EE服务器，则在spring中配置为JNDI连接：
<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:comp/env/jndi/xxx</value>
</property>
</bean>
如果在应用里有独自使用hibernate，则在spring中配置hibernate连接池，使用C3P0如下：
<bean?? id="DataSource"???
? class="org.apache.commons.dbcp.BasicDataSource">???
? <property?? name="driverClassName">???
? <value>oracle.jdbc.driver.OracleDriver</value>???
? </property>???
? <property?? name="url">???
? <value>jdbc:oracle:thin:@172.16.20.241:1521:dbsvr</value>???
? </property>???
? <property?? name="username">???
? <value>hl3000</value>???
? </property>???
? <property?? name="password">???
? <value>hldw3101</value>???
? </property>???
? </bean>???
? <bean?? id="SessionFactory"???
? class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">???
? <property?? name="dataSource">???
? <ref?? bean="DataSource"?? />???
? </property>???
? <property?? name="hibernateProperties">???
? <props>???
? <prop?? key="hibernate.dialect">org.hibernate.dialect.OracleDialect</prop>???
? <prop?? key="hibernate.show_s
-
. java判断操作系统
java 判断操作系统 2008-12-08 20:01:46| 分类： java 阅读607评论0 字号：大中小?订阅 freebsd和windows的操作系统的路径不太一样， .class.getResource获得的路径分别是： file:/usr fi
. 第一个java程序（cmd下的调试）
public class Hello{ public static void main(String[] args){ System.out.println(Hello World!); System.exit(0); } }? 上面是我写的第一个 java 程序，并且在cmd下调试的。 注意到以下
. struts2 <s:url><s:a> 联合使用
看了李刚的书 内容太少了 为了使用这个s:a 费了好大劲 终于明白了 ?<!-- 注意一下信息(*^__^*) 嘻嘻…… --> <s:url value=goodDetail.jsp id=detail > <s:param name=id va
. JAVA3D学习
JAVA3D学习系列AUTOCAD的DWG、VRML的WRL及3DS?MAX图形的调用? ****************VRML2.0交互式三维图形编程**************** JAVA3D学习系列中的例题将有非常多的书中的VRML程序与之相比较，
. struts2 result type
收藏。。 chain 用来处理Action链，被跳转的action中仍能获取上个页面的值，如request信息。 com.opensymphony.xwork2.ActionChainResult dispatcher 用来转向页面，通常处理
. hibernate hql总结
. 查询整个映射对象所有字段? Java代码? MSN空间完美搬家到新浪博客!
. 如何准备简历
...ash;— * 改善电子游戏的数值分类算法， 减少了内存要求 10%。 * 用 java 写了 3000 行用户界面程序。 * 每周做两小时的人工测试。你在申请软件工程师的职位时...
. SpringMVC使用
1.@RequestMapping 用法? SpringMVC中,@RequestMapping用来处理请求,比如XXX.do? @RequestMapping ( /aaa ) //类级别,可以不需要,如果要了,下面所有的请求路径前都需要加入
. [转载]Struts之tiles的使用
原文地址： Struts 之tiles的使用 作者： 雷雷小站 今天偶尔在网上看到一篇使用tiles的文章，觉得写的不错，拿来贴给大家： tile英文意思是瓦片，tiles就是一堆瓦片。比如有个系统，顶
. eclipse java web配置|java build path
2009-12-15 15:08 eclipse java web配置--?java_ee_sdk-5_07-jdk-6u16-windows.exe tomcat 6/5u7-6u16-ml/java_ee_sdk-5_07-jdk-6u16-windows.exe?AuthParam=1257127940 _90bf6ab30b793fdc
|
|||
| spring连接池配置详解 | spring连接池配置详解 | ||
spring连接池配置详解 2010-7-28 数据库连接池概述： 数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。 数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。 数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素： 1)最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费； 2)最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。 3)如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。 目前常用的连接池有：C3P0、DBCP、Proxool 网上的评价是： C3P0比较耗费资源，效率方面可能要低一点。 DBCP在实践中存在BUG，在某些种情会产生很多空连接不能释放，Hibernate3.0已经放弃了对其的支持。 Proxool的负面评价较少，现在比较推荐它，而且它还提供即时监控连接池状态的功能，便于发现连接泄漏的情况。 配置如下： 1、在spring配置文件中，一般在applicationContext.xml中 <beanid="DataSource"class="org.logicalcobwebs.proxool.ProxoolDataSource"destroy-method="shutdown"> <propertyname="driver"> <value>oracle.jdbc.driver.OracleDriver</value> </property> <propertyname="driverUrl"> <value>jdbc:oracle:thin:xxxx/xxxx@192.168.0.XX:1521:server</value> </property> <propertyname="user"> <value>xxxx</value> </property> <propertyname="password"> <value>xxxx</value> </property> <propertyname="alias"> <value>server</value> </property> <propertyname="houseKeepingSleepTime"> <value>30000</value> </property> <propertyname="houseKeepingTestSql"> <value>select1fromdual</value> </property> <propertyname="testBeforeUse"> <value>true</value> </property> <propertyname="testAfterUse"> <value>true</value> </property> <propertyname="prototypeCount"> <value>5</value> </property> <propertyname="maximumConnectionCount"> <value>400</value> </property> <propertyname="minimumConnectionCount"> <value>10</value> </property> <propertyname="statistics"> <value>1m,15m,1d</value> </property> <propertyname="statisticsLogLevel"> <value>ERROR</value> </property> <propertyname="trace"> <value>true</value> </property> <propertyname="verbose"> <value>false</value> </property> <propertyname="simultaneousBuildThrottle"> <value>1600</value> </property> <propertyname="maximumActiveTime"> <value>600000</value> </property> <propertyname="jmx"> <value>false</value> </property> </bean> 然后注入到sessionFactory中 <beanid="sessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <propertyname="dataSource"ref="DataSource"/> </bean> 属性列表说明: fatal-sql-exception:它是一个逗号分割的信息片段.当一个SQL异常发生时,他的异常信息将与这个信息片段进行比较.如果在片段中存在,那么这个异常将被认为是个致命错误.这种情况下,数据库连接将要被放弃.无论发生什么,这个异常将会被重掷以提供给消费者.用户最好自己配置一个不同的异常来抛出. fatal-sql-exception-wrapper-class:正如上面所说,你最好配置一个不同的异常来重掷.利用这个属性,用户可以包装SQLException,使他变成另外一个异常.这个异常或者继承QLException或者继承字 RuntimeException.proxool自带了2个实现:'org.logicalcobwebs.proxool.FatalSQLException'和 'org.logicalcobwebs.proxool.FatalRuntimeException'.后者更合适. house-keeping-sleep-time:housekeeper保留线程处于睡眠状态的最长时间,housekeeper的职责就是检查各个连接的状态,并判断是否需要销毁或者创建. house-keeping-test-sql:如果发现了空闲的数据库连接.housekeeper将会用这个语句来测试.这个语句最好非常快的被执行.如果没有定义,测试过程将会被忽略。 injectable-connection-interface:允许proxool实现被代理的connection对象的方法. injectable-statement-interface:允许proxool实现被代理的Statement对象方法. injectable-prepared-statement-interface:允许proxool实现被代理的PreparedStatement对象方法. injectable-callable-statement-interface:允许proxool实现被代理的CallableStatement对象方法. jmx:如果属性为true，就会注册一个消息Bean到jms服务，消息Bean对象名:"Proxool:type=Pool,name=<alias>".默认值为false. jmx-agent-id:一个逗号分隔的JMX代理列表注册的连接池。）这个属性是仅当"jmx"属性设置为"true"才有效。所有注册jmx服务器使用这个属性是不确定的 jndi-name:数据源的名称 maximum-active-time:如果housekeeper检测到某个线程的活动时间大于这个数值.它将会杀掉这个线程.所以确认一下你的服务器的带宽.然后定一个合适的值.默认是5分钟. maximum-connection-count:最大的数据库连接数. maximum-connection-lifetime:一个线程的最大寿命. minimum-connection-count:最小的数据库连接数 overload-without-refusal-lifetime:这可以帮助我们确定连接池的状态。如果我们已经拒绝了一个连接在这个设定值,然后被认为是超载。默认为60秒。 prototype-count:连接池中可用的连接数量.如果当前的连接池中的连接少于这个数值.新的连接将被建立.例如.我们有3个活动连接2个可用连接,而我们的prototype-count是4,那么数据库连接池将试图建立另外2个连接.这和minimum-connection-count 不同.minimum-connection-count把活动的连接也计算在内.prototype-count是spareconnections的数量. recently-started-threshold:这可以帮助我们确定连接池的状态,连接数少还是多或超载。只要至少有一个连接已开始在此值内,或者有一些多余的可用连接,那么我们假设连接池是开启的。默认为60秒 simultaneous-build-throttle:这是我们可一次建立的最大连接数。那就是新增的连接请求,但还没有可供使用的连接。由于连接可以使用多线程,在有限的时间之间建立联系从而带来可用连接，但是我们需要通过一些方式确认一些线程并不是立即响应连接请求的，默认是10。 statistics:连接池使用状况统计。参数“10s,1m,1d” statistics-log-level:日志统计跟踪类型。参数“ERROR”或“INFO” test-before-use:如果为true，在每个连接被测试前都会服务这个连接，如果一个连接失败，那么将被丢弃，另一个连接将会被处理，如果所有连接都失败，一个新的连接将会被建立。否则将会抛出一个SQLException异常。 test-after-use:如果为true，在每个连接被测试后都会服务这个连接，使其回到连接池中，如果连接失败，那么将被废弃。 trace:如果为true,那么每个被执行的SQL语句将会在执行期被log记录.你也可以注册一个ConnectionListener得到这些信息. verbose:详细信息设置。参数bool值 |
|||
| 数据库连接池配置 | 数据库连接池配置 | ||
数据库连接池配置
2012-02-28 11:15:37| 分类： 连接池 | 标签：连接池 jdbc dbcp c3p0 proxoop |字号大中小 订阅
今天遇到了关于数据源连接池配置的问题，发现有很多种方式可以配置，现总结如下，希望对大家有所帮助：（已Mysql数据库为例）
一，Tomcat配置数据源：
方式一：在WebRoot下面建文件夹META-INF，里面建一个文件context.xml，内容如下：
<Context>
<Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource"
maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true"
username="root" password="111111" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/testdb" />
</Context>
方式二：在tomcat6.0的目录conf下面的context.xml中，修改原来的context标签，改成内容如下：
<Context>
<!-- Default set of monitored resources -->
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource"
maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true"
username="root" password="111111" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/testdb" />
</Context>
方式三：在配置虚拟目录时，也就是在配置conf下面的server.xml时，在context标签内改成如下形式：
<Context path="/WebRoot" reloadable="true" docBase="E:\workspace\DataSource\WebRoot" >
<Resource name="jdbc/test" auth="Container" type="javax.sql.DataSource"
maxActive="50" maxIdle="30" maxWait="10000" logAbandoned="true"
username="root" password="111111" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/testdb" />
</Context>
配置文件中Resource标签中各属性的含义：
driverClassName - JDBC 所用到的数据库驱动的类全名.
maxActive - 连接池在同一时刻内所提供的最大活动连接数。
maxIdle - 连接池在空闲时刻保持的最大连接数.
maxWait - 当发生异常时数据库等待的最大毫秒数 (当没有可用的连接时).
password - 连接数据库的密码.
url - 连接至驱动的URL. (为了向后兼容, DRIVERNAME也被允许.)
user - 数据库用户名.
各种配置方式的范围也应该是不一样的。我在这就不细说了，总之就是在Context标签下面配置个Resource标签即可。
测试代码：
Context initContext = new InitialContext();
Context envContext = (Context)initContext.lookup("java:/comp/env");
DataSource ds = (DataSource)envContext.lookup("jdbc/test");
System.out.println(ds.getConnection());
打印出来不是null应该就成功了。
注意，测试的时候要在tomcat内测试，也就是要在TOMCAT这个容器内（不要闲麻烦，写个简单的JSP页面测下，用个<%...%>就可以了，相当简单的）。不在tomcat这个容器里面测，会抛异常：
... javax.naming.NoInitialContextException: Need to specify class name in environment or system property, or as an applet parameter, or in an application resource file: java.naming.factory.initial
二，Hibernate配置连接池有三种方法：
方式1 使用Hibernate自带的连接池。
<hibernate-configuration>
<session-factory >
<!--JDBC驱动程序-->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- 连接数据库的URL-->
<property name="connection.url">
jdbc:mysql://localhost:3306/feifei
</property>
<!--连接的登录名-->
<property name="connection.username">root</property>
<!--登录密码-->
<property name="connection.password"></property>
<!--是否将运行期生成的SQL输出到日志以供调试-->
<property name="show_sql">true</property>
<!--指定连接的语言-->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!--映射资源-->
<mapping resource="/xx/xx.hbm.xml" />
</session-factory>
</hibernate-configuration>
我自己的配置如下，注释的部分，他是公用的，其它的连接池需要用到！
<hibernate-configuration>
<session-factory>
<property name="show_sql">true</property>
<!-- common conf dbcp/c3p0 needed
<property name="connection.username">informix</property>
<property name="connection.password">informix</property>
<property name="connection.driver_class">com.informix.jdbc.IfxDriver</property>
<property name="connection.url">
jdbc:informix-sqli://192.168.0.188:1526/db_crm:informixserver=ol_sx;NEWLOCALE=zh_cn,en_us;NEWCODESET=gbk,8859_1,819;
</property>
<property name="dialect">
com.huatech.sysframe.webapp.common.dao.hibernate.dialet.BaseInformixDialect
</property>
-->
... ... ... ...
</session-factory>
</hibernate-configuration>
=================================================================================
方式2： 使用配置文件指定的数据库连接池。
连接池现在有dbcp、c3p0、proxoop，其实我原来就知道dbcp
其中dbcp、c3p0的配置只需要在 上面 的配置上加入些配置就行，hibernate会自动识别数据库连接池
配置dbcp需要加入：
<!-- dbcp conf
<property name="dbcp.maxActive">100</property>
<property name="dbcp.whenExhaustedAction">1</property>
<property name="dbcp.maxWait">60000</property>
<property name="dbcp.maxIdle">10</property>
<property name="dbcp.ps.maxActive">100</property>
<property name="dbcp.ps.whenExhaustedAction">1</property>
<property name="dbcp.ps.maxWait">60000</property>
<property name="dbcp.ps.maxIdle">10</property>
-->
配置c3p0需要加入：
<!-- c3p0 conf
<property name="c3p0.min_size">5</property>
<property name="c3p0.max_size">30</property>
<property name="c3p0.time_out">1800</property>
<property name="c3p0.max_statement">50</property>
-->
配置proxoop有些不同，不能仅仅加入，还需要改动：
基本配置如下：
<property name="proxool.pool_alias">dbpool</property>
<property name="proxool.xml">test/huatech/conf/ProxoolConf.xml</property>
<property name="connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</property>
特别注意：下面文件的路径要配置正确，否则FileNotFound
关联文件：test/huatech/conf/ProxoolConf.xml配置如下：
<?xml version="1.0" encoding="utf-8"?>
<something-else-entirely>
<proxool>
<alias>dbpool</alias>
<!--proxool只能管理由自己产生的连接-->
<driver-url>
jdbc:informix-sqli://192.168.0.188:1526/db_crm:informixserver=ol_sx;NEWLOCALE=zh_cn,en_us;NEWCODESET=gbk,8859_1,819;
</driver-url>
<driver-class>com.informix.jdbc.IfxDriver</driver-class>
<driver-properties>
<property name="user" value="informix" />
<property name="password" value="informix" />
</driver-properties>
<!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>90000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
<maximum-new-connections>20</maximum-new-connections>
<!-- 最少保持的空闲连接数-->
<prototype-count>5</prototype-count>
<!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
<maximum-connection-count>100</maximum-connection-count>
<!-- 最小连接数-->
<minimum-connection-count>10</minimum-connection-count>
</proxool>
</something-else-entirely>
=================================================================================
方式3： 从容器中获取得到连接池（如：Tomcat）
用服务器本身的连接池：如Tomcat、resin、weblogic等
hibernate配置如下：
<!--
<property name="hibernate.connection.datasource">
java:comp/env/jdbc/crm
</property>
<property name="show_sql">true</property>
<property name="dialect">
com.huatech.sysframe.webapp.common.dao.hibernate.dialet.BaseInformixDialect
</property>
<property name="hibernate.generate_statistics">true</property>
-->
其中java:comp/env/jdbc/crm的jdbc/crm是对应的服务器中数据库连接池名字，需要在对应的环境中配置
Tomcat配置如第一种Tomcat配置方式所描述，注意jndi的name根据情况修改，要与hibernate所使用的名字对应起来。
=================================================================================
上面配置中需要用到各自数据库连接池的jar包，在hibernate包中有，如果需要最新的可以到各自网站下载。
三，Spring配置连接池的方法：
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost:3306/dbname</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>******</value>
</property>
<property name="maxActive">
<value>100</value>
</property>
<property name="maxWait">
<value>1000</value>
</property>
<property name="maxIdle">
<value>30</value>
</property>
<property name="defaultAutoCommit">
<value>true</value>
</property>
<property name="removeAbandoned"> //自动回收连接池，避免连接池泄露
<value>true</value>
</property>
<property name="removeAbandonedTimeout">
<value>60</value>
</property>
</bean>
四，也是我今天要说的最后一种，则是通过代码的编写配置连接池，代码如下：
import java.sql.*;
import java.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSource;
public class ConnectionPool{
private static BasicDataSource dbs = null;
public static DataSource setupDataSource(){
bds = new BasicDataSource();
//设置驱动程序
bds.sestDriverClassName("com.mysql.jdbc.Driver");
//设置连接用户名
bds.setUsername("root");
//设置连接密码
bds.setPassword("root");
//设置连接地址
bds.setUrl("jdbc:mysql://localhost:3306/databasename");
//设置初始化连接总数
bds.setInitialSize(50);
//设置同时应用的连接总数
bds.setMaxActive(-1);
//设置在缓冲池的最大连接数
bds.setMaxIdle(-1);
//设置在缓冲池的最小连接数
bds.setMinIdle(0);
//设置最长的等待时间
bds.setMaxWait(-1);
return (DataSource)bds;
}
//显示连接池的连接个数的方法
public static void printDataSourceStats(DataSource ds) throws SQLException{
bds = (BasicDataSource)ds;
System.out.println();
System.out.println();
}
//关闭连接池的方法
public static void shutdownDataSource(DataSource ds) throws SQLException{
bds = (BasicDataSource)ds;
bds.close();
}
}
|
|||
| 自己的xml_dtree树形菜单的实现 | 自己的xml_dtree树形菜单的实现 | ||
1. tree.xml
<?xml version="1.0" encoding="UTF-8"?>
<treeMenu>
<zeroMenu>
<id>0</id>
<pId>-1</pId>
<name>MINI PDM</name>
<url></url>
<oneMenu>
<id>1</id>
<pId>0</pId>
<name>创建</name>
<url></url>
<twoMenu>
<id>11</id>
<pId>1</pId>
<name>创建鼎桥文档</name>
<url>createDQDocument.jsp</url>
</twoMenu>
<twoMenu>
<id>12</id>
<pId>1</pId>
<name>创建鼎桥部件</name>
<url></url>
</twoMenu>
<twoMenu>
<id>13</id>
<pId>1</pId>
<name>自制件/BOM审核流程</name>
<url></url>
</twoMenu>
</oneMenu>
<oneMenu>
<id>2</id>
<pId>0</pId>
<name>工作空间</name>
<url></url>
<twoMenu>
<id>21</id>
<pId>2</pId>
<name>我的任务</name>
<url></url>
</twoMenu>
<twoMenu>
<id>22</id>
<pId>2</pId>
<name>我已完成的任务</name>
<url></url>
</twoMenu>
</oneMenu>
</zeroMenu>
</treeMenu>
2. QueryTreeAction.java
package com.tdtech.pdm.create.action;
import java.io.FileInputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts2.ServletActionContext;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
import com.opensymphony.xwork2.ActionSupport;
import com.tdtech.pdm.create.pojo.MenuTreePojo;
public class QueryTreeAction extends ActionSupport{
private List<MenuTreePojo> menus;
public List<MenuTreePojo> getMenus() {
return menus;
}
public void setMenus(List<MenuTreePojo> menus) {
this.menus = menus;
}
public String execute() throws Exception{
FileInputStream fis=new FileInputStream("D:\\XML_File\\tree.xml");
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fis);
Element root=doc.getRootElement();
List menusTemp=root.getChildren();
menus=new ArrayList<MenuTreePojo>();
for(int i=0;i<menusTemp.size();i++){
Element zeroMenu=(Element)menusTemp.get(i); //获取每个一级菜单
this.dealResultset(zeroMenu);
List oneMenus=zeroMenu.getChildren("oneMenu");
for(int j=0;j<oneMenus.size();j++){
Element oneMenu=(Element)oneMenus.get(j);
this.dealResultset(oneMenu);
List twoMenus=oneMenu.getChildren("twoMenu");
for(int z=0;z<twoMenus.size();z++){
Element threeMenu=(Element)twoMenus.get(z);
this.dealResultset(threeMenu);
}
}
}
fis.close();
HttpServletResponse response=ServletActionContext.getResponse();
response.setCharacterEncoding("UTF-8");
PrintWriter out=response.getWriter();
out.write(this.packageMenus(menus));
return null;
}
//处理遍历结果的方法
public void dealResultset(Element element) throws Exception{
Element id=element.getChild("id");
Element pId=element.getChild("pId");
Element name=element.getChild("name");
Element url=element.getChild("url");
int nId=Integer.parseInt(id.getText().trim());
int nPId=Integer.parseInt(pId.getText().trim());
String nName=name.getText().trim();
String nUrl=url.getText().trim();
MenuTreePojo menuTreePojo=new MenuTreePojo();
menuTreePojo.setId(nId);
menuTreePojo.setPId(nPId);
menuTreePojo.setName(nName);
menuTreePojo.setUrl(nUrl);
this.menus.add(menuTreePojo);
}
//封装json格式的菜单数据
private String packageMenus(List<MenuTreePojo> list){
StringBuffer temp=new StringBuffer();
MenuTreePojo menuTree=new MenuTreePojo();
temp.append("[");
for(MenuTreePojo m:list){
// temp.append("{\"id\":\""+m.getId()+"\",\"pId\":\""+m.getPId()+"\",\"name\":\""+m.getName()+"\",\"open\":\""+m.getOpen()+"\"},");
temp.append("{\"id\":\""+m.getId()+"\",\"pId\":\""+m.getPId()+"\",\"name\":\""+m.getName()+"\",\"open\":\""+m.getOpen()+"\",\"url\":\""+m.getUrl()+"\"},");
}
int index=temp.lastIndexOf(",");
String s=temp.substring(0, index);
StringBuffer menus=new StringBuffer();
menus.append(s+"]");
System.out.println(menus.toString());
return menus.toString();
}
public static void main(String[] args) throws Exception{
new QueryTreeAction().execute();
}
}
3. struts.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<!-- 配置常量 -->
<constant name="struts.ognl.allowStaticMethodAccess" value="true" />
<constant name="struts.i18n.encoding" value="UTF-8" />
<constant name="struts.enable.DynamicMethodInvocation" value="true" />
<constant name="struts.i18n.reload" value="true" />
<constant name="struts.devMode" value="true" />
<!-- 配置包 -->
<package name="struts-cps" extends="struts-default" namespace="/cps">
<!-- 配置拦截器-->
<!-- 配置Action -->
<action name="menuTree" class="com.tdtech.pdm.create.action.QueryTreeAction">
</action>
</package>
</struts>
4.leftFrame.jsp
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>树形菜单</title>
<script type="text/javascript" src="js/jquery-1.4.4.min.js"></script>
<link rel="StyleSheet" href="css/dtree.css" type="text/css" />
<script type="text/javascript" src="js/dtree.js"></script>
<SCRIPT type="text/javascript">
<!--
d = new dTree('d');
d.config.target="mainFrame";
$.ajax({
type:"POST",
url:"cps/menuTree!execute",
dataType:"json",
async:false,
success:function(data){
$(data).each(function(){
d.add($(this).attr("id"),$(this).attr("pId"),$(this).attr("name"),$(this).attr("url"));
});
},
error:function(data){
alert(data);
}
});
document.write(d);
//-->
</SCRIPT>
<style type="text/css">
a{
text-decoration:none;
}
a:hover{
color:white;
text-decoration:underline;
}
a.visited{
color:red;
}
</style>
</head>
<body style="background:AliceBlue;">
</body>
</html>
|
|||
| java 连接各种数据库 | java 连接各种数据库 | ||
java 连接各种数据库 总结 博客分类： java
JavaJDBCSQL ServerSybaseSQL .
Oracle8/8i/9i数据库（thin模式）
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID String user="test\"; String password="test"; Connection conn= DriverManager.getConnection(url,user,password);
2、DB2数据库
Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance(); String url="jdbc:db2://localhost:5000/sample"; //sample为你的数据库名 String user="admin"; String password=""; Connection conn= DriverManager.getConnection(url,user,password);
3、SqlServer7.0/2000数据库
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance(); String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb"; //mydb为数据库 String user="sa"; String password=""; Connection conn= DriverManager.getConnection(url,user,password);
驱动：
msbase.jar
mssqlserver.jar
msutil.jar
sqlserver 2005
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver").newInstance(); String url="jdbc:sqlserver://localhost:1433;DatabaseName=mydb"; //mydb为数据库 String user="sa"; String password=""; Connection conn= DriverManager.getConnection(url,user,password);
驱动：sqljdbc.jar
4、Sybase数据库
Java连接Sybase数据库
第一步：工欲善其事，必先利其器。（下载驱动）
下载JDBC驱动：
网址：http://www.sybase.com/detail?id=1009726
有jConnect6.0和jConnect5.5两种，我们下载6.0版本。
第二步：得到驱动
释放下载的jConnect-6_0.zip文件，其中有文件夹：devclasses，其下有一jar文件jconn3d。我们将jconn3d.jar也释放，其实可以不释放，为了说明简便，我们将它释放到任意文件夹，比如：c:/Driver.
第三步：设置环境变量
将上述所释放的位置目录，如c:/Driver追加到环境变量classpath的尾部。
第四步：万事俱备，只欠东风
所有的准备工作都已完成，下面就可以开始编程。我们以一个简单的数据库查询为例：
import com.sybase.jdbc3.jdbc.SybDriver;
import java.sql.*;
import java.io.*;
import java.util.*;
public class ConnTest{
public static void main(String[] args){
try{
Class.forName("com.sybase.jdbc3.jdbc.SybDriver").newInstance();
String url ="jdbc:sybase:Tds:192.168.100.252:4500/myDB";//myDB为你的数据库名
Properties sysProps = System.getProperties();
sysProps.put("user","user_id"); //设置数据库访问用户名
sysProps.put("password","user_pwd"); //密码
Connection conn= DriverManager.getConnection(url, sysProps);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from userInfo"; //userInfo为其中的一个表
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {
System.out.println(rs.getString(2)); //取得第二列的值
}
}catch(Exception e)
{
out.println(e.getMessage());
}
}
}
5、Informix数据库
Class.forName("com.informix.jdbc.IfxDriver").newInstance(); String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver; user=testuser;password=testpassword"; //myDB为数据库名 Connection conn= DriverManager.getConnection(url);
6、MySQL数据库
驱动为mysql.jar
String url ="jdbc:mysql://localhost/jpt?user=root&password=root&useUnicode=true&characterEncoding=8859_1" ;
//myDB为数据库名 Connection conn= DriverManager.getConnection(url);
Connection dbConn=null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
dbConn = DriverManager.getConnection(url);
Statement stmt = null; //数据库表达式
ResultSet rs = null; //结果集
stmt = dbConn.createStatement();
//4. 执行SQL
// rs = stmt.executeQuery("SELECT 序号 AS ID , 车号 AS CH,日期 AS RQ, 时间 AS SJ,毛重 AS MZ,皮重 AS PZ,净重 JZ, 发货 AS FZ,收货 AS DZ, 货名 AS RLCP, 扣杂 AS KGL ,台号 AS HQH FROM SAVER where 序号>'300026876' ");
rs = stmt.executeQuery("SELECT * FROM zz_userlist ");
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//5. 现实结果集里面的数据
java.sql.ResultSetMetaData md = rs.getMetaData();
while(rs.next()) {
System.out.print("\n");
for(int i=1; i<= md.getColumnCount(); i++) {
System.out.print(rs.getString(i) + " | ");
}
}
rs.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Connection Successful!");
7、PostgreSQL数据库
Class.forName("org.postgresql.Driver").newInstance(); String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库名 String user="myuser"; String password="mypassword"; Connection conn= DriverManager.getConnection(url,user,password);
8：paradox 数据库
它有很多种连接方式，ftp,共享，IP，本机连接
HXTT Paradox provides a type 4 JDBC driver for Paradox version from 3.0, 3.5, 4.x, 5.x, 7.x to 11.x. It supports JDBC1.2, JDBC2.0, JDBC3.0, and JDBC4.0. It supports Personal Java, JDK1.0.X, JDK1.1.X, JDK1.2.X, JDK1.3.X, JDK1.4.X, JDK1.5.X, and JDK1.6.X. It supports JBuilder's Database Pilot, Oracle's JVM, JDeveloper 10G, Dreamweaver UltraDev, Dreamweaver ColdFusion, ObJectRelationalBridge, DBVisualizer, iSQL-Viewer, AquaDataStudio, Sunopsis, MySQL Migration Toolkit, Tomcat, vqServer, Hibernate, SQuirreL SQL Client, Crystal Reports, Jisql, and DbEdit Database Utilites for Eclipse Platform. It supports transaction, XOPEN SQLState, RMI, Jini, JNDI, and serialization. It supports { UNION | INTERSECT | EXCEPT | MINUS } [ ALL ] query , INNER JOIN, FULL JOIN, LEFT JOIN, RIGHT JOIN, NATURAL JOIN, CROSS JOIN, self join, GROUP_CONCAT, multiple-row VALUES table, PIVOT table, UNPIVOT table, and subquery which includes single-row subquery, multirow subquery, multiple-column subquery, inline views, and correlated subquery. The current version of the HXTT Paradox packages are available here:
Follow Me
First, you need to download JDK1.6.X from www.javasoft.com if you use Paradox JDBC 4.0 package(Paradox_JDBC40.jar). You can download JDK 1.3.X, 1.4.X, JDK1.5.X, or JDK1.6.X if you use Paradox JDBC 3.0 package(Paradox_JDBC30.jar) . You can download JDK1.2.X too if you use Paradox JDBC 2.0 package(Paradox_JDBC20.jar). You can download JDK1.1.X too if you use Paradox JDBC 1.2 package(Paradox_JDBC12.jar).
Secondly, please add Paradox_JDBC30.jar, Paradox_JDBC20.jar or Paradox_JDBC12.jar to your Java class path, for instance, "SET CLASSPATH=c:\javalib\Paradox_JDBC20.jar;%classpath%". You can also use "java -classpath c:\javalib\Paradox_JDBC20.jar yourParadoxclass" to run your class. More information about classpath, please read the "Setting the Classpath" topic in file:///yourdriver|/jdk1.2/docs/tooldocs/tools.html . You can use "java -classpath c:\javalib\Paradox_JDBC20.jar yourParadoxclass" too.
Thirdly, you can use 'Class.forName("com.hxtt.sql.paradox.ParadoxDriver").newInstance();' or Class.forName("com.hxtt.sql.paradox.ParadoxDriver");' to load this driver.
Fourth, if you have used other JDBC driver, you only need to know the correct URL format for DriverManager.getConnection(url,"",""); You can find the Paradox URL format below. If you were a Java novice, please read also other Java examples code in Paradox_JDBC30demo.zip, Paradox_JDBC20demo.zip or Paradox_JDBC12demo.zip.
Paradox URL format:
Embedded:
jdbc:paradox:[//]/[DatabasePath][?prop1=value1[;prop2=value2]] (You can omit that "//" characters sometimes)
For example:
"jdbc:paradox:/."
"jdbc:paradox:/c:/data" for Windows driver
"jdbc:paradox:///c:/data" for Windows driver
"jdbc:paradox:////usr/data" for unix or linux
"jdbc:paradox://///192.168.10.2/sharedir" for UNC path
"jdbc:paradox:/./data"
Remote Access (client/server mode):
jdbc:paradox://host:port/[DatabasePath]
For example: "jdbc:paradox://domain.com:3099/c:/data" if one ParadoxServer is run on the 3099 port of domain.com
Compressed Database:(.ZIP, .JAR, .GZ, .TAR, .BZ2, .TGZ, .TAR.GZ, .TAR.BZ2)
jdbc url format is the same as embedded url and remote url.
For example:
"jdbc:paradox:/c:/test/testparadox.zip
Memory-only Database:
jdbc:paradox:/_memory_/
URL Database:(http protocol, https protocol, ftp protocol)
jdbc:paradox:http://httpURL
jdbc:paradox:https://httpsURL
jdbc:paradox:ftp://ftpURL
For example:
"jdbc:paradox:http://www.hxtt.com/test" ////Note: FTP site's user/password should be set in ftpURL, and cannot be set in JDBC connection property because user/password JDBC connection property belongs to server/client connection.
SAMBA Database:(smb protocol)
jdbc:paradox:smb://[[[domain;]username[:password]@]server[:port]/[[share/[dir/]file]]][?[param=value]]
For example:
"jdbc:paradox:smb://test1:123@100.100.13.94/paradoxfiles".zone" ////Note: SAMBA user/password should be set in SMB URL, and cannot be set in JDBC connection property because user/password JDBC connection property belongs to server/client connection.
Free JDBC url:(Warning: only use it for special project)
jdbc:paradox:/" or "jdbc:paradox:///". Then you can use some full UNC path names in SQL to visit anywhere where your Java VM has right to access.
For instance:
select * from \\amd2500\e$\paradoxfiles\test;
elect * from "\\amd2500\d$\paradoxiles".test;
select * from ".".test;
HXTT Paradox supports seamlessly data mining on memory-only table, physical table, url table, compressed table, SAMBA table in a sql. More details
is in Advanced Programming chapter.
Last, Paradox driver is a standard JDBC driver so that you will find most of valuable information at file:///yourdrive|/jdk1.2/docs/api/java/sql/package-frame.html .
Paradox supports SQL-92. It supports { UNION | INTERSECT | EXCEPT | MINUS } [ ALL ] query , INNER JOIN, FULL JOIN, LEFT JOIN, RIGHT JOIN, NATURAL JOIN, CROSS JOIN, self join, GROUP_CONCAT, and subquery which includes single-row subquery, multirow subquery, multiple-column subquery, inline views, and correlated subquery. The major syntax is listed at here.
Paradox driver will use index to speed up the query which contains some indexed expressions. Paradox supports utilizing index file for LIKE, BETWEEN, IN, DISTINCT, ORDER, and some OR operations.
驱动包 下载地址
地址：http://www.hxtt.com/download.jsp?product=paradox
远程连接的通过IP的它单独有一个JAR包：Paradox_Remote_Access_JDBC40.jar
一个测试类
import java.net.URL; import java.sql.*; import java.util.Properties; import java.applet.Applet; import java.awt.*; import java.awt.event.*; /* A demo show how to use HXTT Paradox in applet */ public class testApplet extends java.applet.Applet implements KeyListener,MouseListener { static { try { Class.forName("com.hxtt.sql.paradox.ParadoxDriver").newInstance(); } catch(Exception e) { e.printStackTrace(); System.out.println(e.getMessage()); } } Button connectButton=null; TextField urlTextField =null; TextField queryTextField =null; TextArea resultSetTextArea =null; Connection con=null; public void init() { GridBagConstraints constraints = new GridBagConstraints(); constraints.weightx=1.0; constraints.weighty=0.0; constraints.anchor = GridBagConstraints.CENTER; constraints.fill = GridBagConstraints.NONE; constraints.gridwidth = GridBagConstraints.REMAINDER; GridBagLayout layout = new GridBagLayout(); setLayout(layout); setFont(new Font("Ariel", Font.PLAIN, 14)); setBackground(Color.gray); connectButton = new Button(" Connect "); connectButton.addMouseListener(this); layout.setConstraints(connectButton, constraints); add(connectButton); add(new Label("Enter URL(e.g., jdbc:Paradox://localhost:8029/datafiles and jdbc:Paradox:/c:/datafiles) ")); urlTextField = new TextField(30); urlTextField.setText("jdbc:Paradox://localhost:8029/."); urlTextField.setEditable(true); urlTextField.setBackground(Color.white); layout.setConstraints(urlTextField, constraints); add(urlTextField); add(new Label("Enter SQL Query Statement:")); queryTextField = new TextField(40); queryTextField.setEditable(false); queryTextField.setBackground(Color.white); queryTextField.addKeyListener(this); layout.setConstraints(queryTextField, constraints); add(queryTextField); Label resultLabel = new Label("Result"); resultLabel.setFont(new Font("Ariel", Font.PLAIN, 16)); resultLabel.setForeground(Color.white); layout.setConstraints(resultLabel, constraints); add(resultLabel); constraints.weighty=1.0; resultSetTextArea = new TextArea(20,120); resultSetTextArea.setEditable(false); layout.setConstraints(resultSetTextArea, constraints); resultSetTextArea.setForeground(Color.blue); resultSetTextArea.setBackground(Color.black); add(resultSetTextArea); setVisible(true); } public void keyPressed(KeyEvent ke) { try { Object target =ke.getSource(); if (target == queryTextField && ke.getKeyCode()==KeyEvent.VK_ENTER) { resultSetTextArea.setText(getResult(queryTextField.getText())); } } catch( Exception e) { e.printStackTrace(); System.out.println(e.getMessage()); resultSetTextArea.setText(e.getMessage()); } } public void keyReleased(KeyEvent e) { } public void keyTyped(KeyEvent e) { } public void mouseClicked(MouseEvent me) { try { Object target =me.getSource(); if (target == connectButton) { if(con==null) { connectButton.setLabel("Connecting"); con = DriverManager.getConnection(urlTextField.getText(), "user","password"); queryTextField.setEditable(true); connectButton.setLabel("Disconnect"); } else { connectButton.setLabel("Connect"); con.close(); con=null; queryTextField.setEditable(false); } } } catch( Exception e) { e.printStackTrace(); System.out.println(e.getMessage()); resultSetTextArea.setText(e.getMessage()); } } public void mousePressed(MouseEvent me) { } public void mouseReleased(MouseEvent me) { } public void mouseEntered(MouseEvent me) { } public void mouseExited(MouseEvent me) { } public String getResult(String queryString) { try { StringBuffer strbuff=new StringBuffer(1000); Statement stmt = con.createStatement(); stmt.setMaxRows(25); ResultSet rs = stmt.executeQuery(queryString); ResultSetMetaData resultSetMetaData = rs.getMetaData(); int iNumCols = resultSetMetaData.getColumnCount(); for (int i = 1; i <= iNumCols; i++) { strbuff.append(resultSetMetaData.getColumnLabel(i)); strbuff.append("\n"); } while (rs.next()) { for(int i=1;i<=iNumCols;i++) strbuff.append(rs.getObject(i)+" "); strbuff.append("\n"); } stmt.close(); return strbuff.toString(); } catch( Exception e) { e.printStackTrace(); System.out.println(e.getMessage()); return e.getMessage(); } } public void destroy() { if(con!=null) { try { con.close(); } catch( Exception e) { e.printStackTrace(); System.out.println(e.getMessage()); } } } }
9:access数据库
转载：http://blog.csdn.net/qwerasdf123/archive/2009/06/30/4309383.aspx
直接在JAVA代码内部与Access数据库连接
注意:jdbc:odbc:driver={Microsoft Access Driver (*.mdb)};这里的空格,不能少!否则会有异常
try{
String url = "jdbc:odbc:driver={Microsoft Access Driver (*.mdb)};PWD=123;DBQ=F:\\ge\\123.MDB"; //如果 没有密码可以不用写pwd
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection conn = DriverManager.getConnection(url);
System.out.println(conn);
Statement sta = conn.createStatement();
ResultSet resu = sta.executeQuery("select * from Roche_position");
if(resu.next()){
System.out.println(resu.getString("cname"));
}
System.out.println("exit");
}catch(Exception e){
e.printStackTrace();
}
2：远程访问数据库
2:使用ODBC建立WINDOW数据源的方法:
开始
>>控制面板
>>管理工具
>>数据源(ODBC)
>>用户DSN或系统DSN
>>点添加
>>找到"Microsoft Access Driver (*.mdb)",选中,再点完成>>自定义数据源名称,可创建一个新的或选择已经有的Access数据库(.mdb)其它可以不选
>>确定>>确定
到此数据源已经建立成功
下一步
1、 从http://forge.ow2.org/project/showfiles.php?group_id=8&release_id=623下载RmiJdbc.jar包。
2、 配置系统环境变量。右键”计算机”——“高级”——“环境变量”，在“系统变量”中，新建变量名为CLASSPATH的系统变量，被配置其值。
CLASSPATH=%CLASSPATH%; E:\RmiJdbc\dist\lib\RmiJdbc.jar;
注意：E:\RmiJdbc\dist\lib\RmiJdbc.jar为Rmijdbc.jar放置的目录
3、 使用”win”+r组合键，输入”cmd”，调出命令提示行对话框，输入：
java org.objectweb.rmijdbc.RJJdbcServer
我写的一个BAT文件后台运行服务
java连接access服务.bat
测试类：
import java.sql.*; import java.net.InetAddress; public class testdemo { public static void main(String[] args) { try { // 注册数据提供程序 Class.forName("org.objectweb.rmijdbc.Driver").newInstance(); // 数据链接字符串 String strurl = "jdbc:rmi://192.168.70.100/jdbc:odbc:test_db";//192.168.70.100为access 数据库所在的服务器地址，test_db为odbc数据源名 java.sql.Connection c = DriverManager.getConnection(strurl, "168168", "168168"); java.sql.Statement st = c.createStatement(); java.sql.ResultSet rs = st.executeQuery("select * from tb_test"); java.sql.ResultSetMetaData md = rs.getMetaData(); while(rs.next()) { System.out.print("\n"); for(int i=1; i<= md.getColumnCount(); i++) { System.out.print(rs.getString(i) + " | "); } } rs.close(); } catch(Exception e) { e.printStackTrace(); } } };
10：sqlite数据库
连接：
Class.forName("org.sqlite.JDBC"); String url="jdbc:sqlite:data/jpt.dat";
String user="test"; String password="test"; Connection conn= DriverManager.getConnection(url,user,password);
</properties>
驱动：sqlitejdbc-v054.jar
|
|||
| 布局管理 | 布局管理 | ||
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<link href="css/css.css" rel="stylesheet" type="text/css" />
<style type="text/javascript">
div{
float:left;
height:90%;
}
</style>
</head>
<body>
<br />
<br />
<script language="javascript">
function qiehuan(num){
for(var id = 0;id<=2;id++)
{
if(id==num)
{
document.getElementById("qh_con"+id).style.display="block";
document.getElementById("mynav"+id).className="nav_on";
}
else
{
document.getElementById("qh_con"+id).style.display="none";
document.getElementById("mynav"+id).className="";
}
}
}
</script>
<div id=menu_out>
<div id=menu_in style="margin-top:-30px;width:986px;">
<div id=menu style="margin-left:-15px;">
<UL id=nav>
<LI><A class=nav_on id=mynav0 onmouseover=javascript:qiehuan(0) href="http://www.niutuku.com/"><SPAN>首 页</SPAN></A></LI>
<LI class="menu_line"></LI>
<li><a href="http://www.niutuku.com/" onmouseover="javascript:qiehuan(1)" id="mynav1" class="nav_off"><span>我的任务</span></a></li>
<li class="menu_line"></li>
<li><a href="http://js.niutuku.com/" onmouseover="javascript:qiehuan(2)" id="mynav2" class="nav_off"><span>我的设置</span></a></li>
<li class="menu_line"></li>
</UL>
<div id=menu_con>
<div id=qh_con0 style="margin-left:-20px;width:900px;height:800px;border:1px black solid;DISPLAY: block">
<div style="width:600px;heigth:300px;border:1px black solid;float:left;">
<div style="height:30px;text-align:left;color:blue;">
TPDM系统上线公告
</div>
<div style="overflow-y:yes;scrollbar-face-color:blue;">
<p>
TPDM（终端产品数据管理）系统将于2013年春节期间正式切换，为确保数据正确迁移，要求涉及终端公司数据的流程全部完成，请终端公司用户注意：
1) 请及时完成工作表中的任务；对于2013年2月8日16:00前未完成的任务，将由管理员手工取消。
2) 要求2013年2月6日起，终端公司用户停止创建 “变更请求”、“EarlyBOM评审流程”和“产品标准发布流程”；要求2013年2月8日起，终端公司用户停止创建 “自制件/BOM审核流程” 、“自制件/BOM审核流程2012”、“一般文件评审流程”、“评审归档流程”、“文档使用范围变更流程”、“制造文档验证流程”、“整机电缆文字文件生产发行流程”、“产品资料生产发行流程”、“进网证申请和发布流程”和“软件和资料光盘包发行流程”。
3) 对于已提交的流程，请跟踪并确保在2013年2月8日16:00前结束流程；未结束的流程将由管理员手工终止。 <br /><br />
由此造成的不便，敬请谅解！<br />
距离终端公司流程关闭还有天；
</p>
</div>
</div>
<div style="width:500px;height:500px;margin-top:220px;border:1px black solid;">
<div style="background-color:pink;height:30px;font-size:14px;color:blue;">
最新公告
</div>
<div style="overflow-y:yes;">
<ul>
<li>系统公告</li>
<li>【自制件BOM审核流程】无法通过部件查看到新自制件BOM审核申请单的临时解决办法！</li>
<li> 2013-06-01 </li>
</ul>
<ul>
<li>新功能上线</li>
<li>【PDM新功能上线宣传】新自制件BOM审核流程全新改版啦！</li>
<li>2013-05-01</li>
</ul>
<ul>
<li>新功能上线</li>
<li>PDM新替代流程电子流说明</li>
<li> 2013-02-28 </li>
</ul>
<ul>
<li>新功能上线</li>
<li>集成与合作选型流程优化说明</li>
<li>2013-02-28</li>
</ul>
<ul>
<li>新功能上线</li>
<li>没有0302编码也可以启动Earlybom评审</li>
<li> 2013-02-01 </li>
</ul>
<ul>
<li>新功能上线</li>
<li>发货制成板规划流程宣传材料</li>
<li>2013-01-31</li>
</ul>
<ul>
<li>新功能上线</li>
<li>New! 【Item 衍生编码功能上线】2013年1月PDM系统已经正式启用“Item衍生编码”。 目前处于小批试点运行阶段。</li>
<li>2013-01-06</li>
</ul>
<ul>
<li>系统公告</li>
<li>！请关注PDM EC优化，非常重要</li>
<li>2013-01-05</li>
</ul>
<ul>
<li>业务宣传</li>
<li>海思芯片正式编码相关流程迁PDM操作指导</li>
<li>2012-11-05</li>
</ul>
<ul>
<li>常见案例</li>
<li>[桌面云]使用PDM打开页面后IE长时间无响应解决办法</li>
<li>2012-09-07</li>
</ul>
<ul>
<li>新功能上线</li>
<li>在首页跟催我的流程</li>
<li> 2012-08-25 </li>
</ul>
</div>
</div>
</div>
<div style="width:200px;heigth:500px;border:1px black solid;float:left;">
<div>121</div>
<div>122</div>
<div>123</div>
</div>
<div id=qh_con1 style="margin-left:-19px;width:979px;height:700px;border:1px black solid;DISPLAY: none">
222
</div>
<div id=qh_con2 style="margin-left:-19px;width:979px;height:700px;border:1px black solid;DISPLAY: none">
333
</div>
</div>
</div>
</div>
</div>
</body>
</html>
|
|||
| 为DIV添加滚动条 博客分类： CSS | 为div添加滚动条 博客分类： css | ||
为DIV添加滚动条 博客分类： CSS . <div style="OVERFLOW:auto; height:100px; width:100px;">1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/>1<br/></div> 滚动条相关颜色属性： face-color：滑块颜色 hightlight-color：高亮颜色 3dlight-color：三维光线颜色 darkshadow-color：暗影颜色 shadow-color：阴影颜色 arrow-color：箭头颜色 tack-color：滑道颜色 滚动条属性： overflow：auto为自动，yes为有，no为无 overflow-x：横向滚动条 //ff不支持 overflow-y：纵向滚动条 |
|||
| HTML 第六章 CSS + DIV实现整体布局 | html 第六章 css + div实现整体布局 | ||
HTML 第六章 CSS + DIV实现整体布局
1、技术目标：
•开发符合W3C标准的Web页面
•理解盒子模型
•实现DIV+CSS整体布局
2、什么是W3C标准？
W3C：World Wide Web Consortium，万维网联盟
W3C的职能：负责制定和维护Web行业标准
W3C标准包括一系列的标准：
•HTML内容方面：XHTML
•样式美化方面：CSS
•结构文档访问方面：DOM
•页面交互方面：ECMAScript
•……等等
3、W3C倡导的Web结构要符合以下要求：
•XHTML负责内容组织
•CSS负责页面样式
4、符合W3C规范页面的结构：
Html代码
1.<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
2. "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3. <html xmlns="http://www.w3.org/1999/xhtml">
4. <head>
5. <meta http-equiv="Content-Type" content="text/html;
6. charset=gb2312" />
7. <title>无标题文档</title>
8. </head>
9. <body>
10. ......页面内容部分
11. </body>
12. </html>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html;
charset=gb2312" />
<title>无标题文档</title>
</head>
<body>
......页面内容部分
</body>
</html>
5、XHTML基本规范
1.标签名和属性名称必须小写
2.HTML标签必须关闭
3.属性值必须用引号括起来
4.标签必须正确嵌套
5.文档必须拥有一个根元素，所有的XHTML元素必须嵌套于<html>根元素中
6.属性不能简写，如：
<input checked="checked" />
<input readonly="readonly" />
<option selected="selected" />
6、页面开发需要注意的地方：
•不要使用淘汰的标签：<b>、<font>、<marquee>等，可参考官方文档(http://www.w3c.org)
•<img />标签的alt属性：为图片增加alt属性
•样式和内容分离：将样式和结构分离，不使用行类样式
•表单的name和id：表单及表单元素要求设置name和id属性
•使用CSS + DIV布局
•页面的浏览器兼容性
7、为什么需要盒子模型？
网页可以看成由一个个"盒子"组成，如图：
由上图可以看出，页面分为上(网站导航)、中、下(版权声明)三个部分，
中间部分又分为左(商品分类)、中(主要部分)、右，这些版块就像一个个
的盒子，这些"盒子"中放置着各种内容，页面就是由这些"盒子"拼凑起来
8、盒子模型的相关属性
•margin（外边距/边界）
•border（边框）
•padding（内边距/填充 ）
我们看图理解一下各属性作用：
以上属性又分为上、右、下、左四个方向
问题：页面元素的宽度width、高度height如何计算？
答案：元素的实际占位尺寸 = 元素尺寸 + padding + 边框宽度
比如：元素实际占位高度 = height属性 + 上下padding + 上下边框宽度
9、盒模型的层次关系
我们通过一个经典的盒模型3D立体结构图来理解，如图：
从上往下看，层次关系如下：
第1层：盒子的边框(border)，
第2层：元素的内容(content)、内边距(padding)
第3层：背景图(background-image)
第4层：背景色(background-color)
第5层：盒子的外边距(margin)
从这个层次关系中可以看出，当同时设置背景图和背景色时，背景
图将在背景色的上方显示
10、margin外边距
可统一设置或四边分开设置，如图：
具体的设置可查看CSS帮助文档(页面下方提供下载)
11、水平居中和垂直居中
水平居中包含两种情况：
块级元素的水平居中：margin:0px auto;
文字内容的水平居中：text-align: center;
垂直居中：
常见的单行文字的垂直居中可设置文字所在行的height与
行高样式属性一致，比如：
div{
width: 400px;
height: 400px;
line-height: 400px;/*行高与div高度一致*/
}
12、案例的首页布局分析
只保留DIV的布局分析：
13、首页布局CSS + DIV代码分析
HTML结构代码：
<div id="container">
<div id="header">顶部（header）</div>
<div id="main">主体部分（main）</div>
<div id="footer">底部（footer）</div>
</div>
CSS样式代码：
/*主面板样式*/
#container {
width:980px;
margin:0px auto;/*主面板DIV居中*/
}
/*顶部面板样式*/
#header {
width:100%;
height:150px;
border:1px #F00 solid;
}
/*中间部分面板样式*/
#main {
width:100%;
height:400px;
border:1px #F00 solid;
}
/*底部面板样式*/
#footer {
width:100%;
height:100px;
border:1px #F00 solid;
}
14、为什么需要float浮动属性？
我们来看看下图：
问题： 如何让商品分类DIV、内容DIV和右侧DIV并排放置？
答案： 使用float(浮动)样式
15、浮动属性
理解浮动属性首先要搞清楚，什么是文档流？
文档流： 浏览器根据元素在html文档中出现的顺序，
从左向右，从上到下依次排列
浮动属性是CSS中的定位属性，用法如下：
float: 浮动方向(left、right、none);
left为左浮动、right为右浮动、none是默认值表示不浮动
，设置元素的浮动，该元素将脱离文档流，向左或向右移动
直到它的外边距碰到父元素的边框或另一个浮动元素的边
框为止
浮动示例，没有使用浮动的3个DIV：
HTML结构代码：
<div id="first">第1块div</div>
<div id="second">第2块div</div>
<div id="third">第3块div</div>
CSS样式代码：
#first, #second, #third{
width:100px;
height:50px;
border:1px #333 solid;
margin:5px;
}
执行效果如图：
样式中加入 float:left;
执行效果如图：
你再修改为 float: right试试右浮动是什么效果
16、让商品分类DIV、内容DIV和右侧DIV并排放置
HTML结构代码：
Java代码
1.<div id="container">
2. <div id="header">顶部（header）</div>
3. <div id="main">
4. <div class="cat">商品分类(cat)</div>
5. <div class="content">内容(content)</div>
6. <div class="sidebar">右侧(sidebar)</div>
7. </div>
8. <div id="footer">底部（footer）</div>
9.</div>
<div id="container">
<div id="header">顶部（header）</div>
<div id="main">
<div class="cat">商品分类(cat)</div>
<div class="content">内容(content)</div>
<div class="sidebar">右侧(sidebar)</div>
</div>
<div id="footer">底部（footer）</div>
</div>
CSS样式代码(在第13节CSS代码基础上加入)：
.cat, .sidebar {
float:left;
width:20%;
height:100%;
}
.content {
float:left;
width:60%;
height:100%;
}
17、clear清除
clear只对块级元素有效，表示如果前一个元素存在左浮动或右浮动，则换行
clear属性的取值：rigth、left、both、none
18、总结
•盒子模型有哪些属性？各属性又分别包含哪些属性？
•float属性的应用场合？有哪些取值？
•clear属性的应用场合？有哪些取值？
HTML 第七章 CSS + DIV实现局部布局
|
|||
| frameset与frame的应用2 | frame框架的应用2 | ||
//1. index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<frameset rows="10%,*">
<frame name="topFrame" src="top.jsp" noresize="noresize" style="background:#99CCCC;" />
<frameset cols="20%,*">
<frame name="leftFrame" src="leftFrame.jsp" scrolling="yes" noresize="noresize"
style="background:#99CCCC;" />
<frame name="mainFrame" src="mainFrame.jsp" scrolling="yes" noresize="noresize"
style="background:#99CCCC;" />
</frameset>
</frameset>
<noframes>
<body>
</body>
</noframes>
</html>
//2.top.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
头部
</body>
</html>
//3. leftFrame.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<style type="text/css">
a{
text-decoration:none;
}
a:hover{
color:green;
text-decoration:underline;
}
a.visited{
color:red;
}
</style>
</head>
<body>
创建<br />
<a href="createDocument.jsp" title="创建鼎桥文档" target="mainFrame">创建鼎桥文档
</a><br />
<a href="createExcel.jsp" title="创建鼎桥表格文件" target="mainFrame">创建鼎桥表格文件
</a><br />
<a href="comeinNewWindow.jsp" title="打开新窗口" target="_blank">进入一个新窗口</a><br
/>
左边左边<br />
左边左边左边左边左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
v
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
v
v
左边<br />左边<br />
左边<br />
左边<br />
左边<br />
v
左边<br />
v
左边<br />
v
左边<br />
v
v
左边<br />
左边<br />
左边<br />
</body>
</html>
//4.mainFrame.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
内容区
</body>
</html>
//5.comeinNewWindow.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
新窗口
</body>
</html>
//6. createDocument.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
创建鼎桥文档
</body>
</html>
//7. createExcel.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
创建鼎桥电子表格
</body>
</html>
|
|||
| frameset与frame的应用 | frame框架的应用 | ||
//1. index.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<frameset rows="10%,*">
<frame src="top.jsp" />
<frameset cols="20%,*">
<frame src="leftFrame.jsp" scrolling="yes"/>
<frame src="mainFrame.jsp" scrolling="yes"/>
</frameset>
</frameset>
<noframes>
<body>
</body>
</noframes>
</html>
//2. top.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
头部
</body>
</html>
//3. leftFrame.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
左边<br />
左边左边<br />
左边左边<br />
左边左边<br />
左边左边左边左边左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
v
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
左边<br />
v
v
左边<br />左边<br />
左边<br />
左边<br />
左边<br />
v
左边<br />
v
左边<br />
v
左边<br />
v
v
左边<br />
左边<br />
左边<br />
</body>
</html>
//4. mainFrame.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
内容区
</body>
</html>
|
|||
| js 解析xml文件实现省市级联下拉菜单 | js 解析xml文件实现省市级联下拉菜单 | ||
js 解析xml文件实现省市级联下拉菜单
写一个省市的XML文档
city.xml
<!--EndFragment-->
Xml代码
1.<?xml version="1.0" encoding="UTF-8"?>
2.<cities>
3. <province name="北京">
4. <city>大兴</city>
5. <city>海淀</city>
6. <city>沙河</city>
7. <city>朝阳</city>
8. <city>昌平</city>
9. <city>西单</city>
10. <city>中关村</city>
11. </province>
12. <province name="河北">
13. <city>石家庄</city>
14. <city>保定</city>
15. <city>承德</city>
16. <city>邢台</city>
17. <city>邯郸</city>
18. <city>廊坊</city>
19. <city>唐山</city>
20. </province>
21. <province name="陕西">
22. <city>西安</city>
23. <city>咸阳</city>
24. <city>铜川</city>
25. <city>渭南</city>
26. <city>汉中</city>
27. <city>商洛</city>
28. <city>延安</city>
29.
30. </province>
31.
32.
33.</cities>
<?xml version="1.0" encoding="UTF-8"?>
<cities>
<province name="北京">
<city>大兴</city>
<city>海淀</city>
<city>沙河</city>
<city>朝阳</city>
<city>昌平</city>
<city>西单</city>
<city>中关村</city>
</province>
<province name="河北">
<city>石家庄</city>
<city>保定</city>
<city>承德</city>
<city>邢台</city>
<city>邯郸</city>
<city>廊坊</city>
<city>唐山</city>
</province>
<province name="陕西">
<city>西安</city>
<city>咸阳</city>
<city>铜川</city>
<city>渭南</city>
<city>汉中</city>
<city>商洛</city>
<city>延安</city>
</province>
</cities>
city.html
Html代码
1. <!DOCTYPEhtmlPUBLIC"-//W3C//DTDHTML4.01Transitional//EN" Http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
2.lt;html>
3.<head>
4. <title>city.html</title>
5. <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
6. <meta http-equiv="description" content="this is my page">
7. <meta http-equiv="content-type" content="text/html; charset=UTF-8">
8. <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
9.</head>
10.
11.<body>
12.
13. <h1>
14. 解析xml文件实现省市级联下拉单
15. </h1>
16.
17. <div>
18. <span> <select id="province" name="province">
19. <option>
20. 请选择省
21. </option>
22. </select> </span>
23. <span> <select id="cities" name="city">
24. <option>请选择相应省下面的市
25. </option>
26. </select> </span>
27. <span> <select id="counties" name="county">
28. <option>请选择相应市下面的县
29. </option>
30. </select> </span>
31. </div>
32.</body>
33.lt;/html>
<!DOCTYPEhtmlPUBLIC"-//W3C//DTDHTML4.01Transitional//EN" Http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<title>city.html</title>
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="this is my page">
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
</head>
<body>
<h1>
解析xml文件实现省市级联下拉单
</h1>
<div>
<span> <select id="province" name="province">
<option>
请选择省
</option>
</select> </span>
<span> <select id="cities" name="city">
<option>请选择相应省下面的市
</option>
</select> </span>
<span> <select id="counties" name="county">
<option>请选择相应市下面的县
</option>
</select> </span>
</div>
</body>
</html>
javascript
Js代码
1.<script>
2.window.onload = function() {
3. var xmlDom;
4. try {
5. //针对的是IE浏览器 创建一个空的微软
6.XML 文档对象
7. xmlDom = new ActiveXObject
8.("Microsoft.XMLDOM");
9. } catch (err) {
10. try {
11. //在 Firefox 及其他浏览器中的 XML 解析器
12. //创建一个空的 XML 文档对象。
13. xmlDom = document.implementation.createDocument("", "", null);
14. } catch (e) {
15. }
16. }
17. //关闭异步加载，这样确保在文档完全加载之前解析器不会继续脚本的执行
18. xmlDom.async = "false";
19. //解析器加载名为 "xxx.xml" 的 XML 文档、
20. xmlDom.load("city.xml");
21. //获取xml文件的根节点
22. var root = xmlDom.documentElement;
23. //获取根节点下面的省节点
24. var provinces = root.childNodes;
25. var province = document.getElementById("province");
26. for ( var i = 0; i < provinces.length; i++)
27.{
28. //获取省节点的name属性的值
29. var name = provinces[i].getAttribute("name");
30. //创建一个option
31. var opt = document.createElement("option");
32. //为option添加文本
33. opt.appendChild(document.createTextNode(name));
34. //添加到父节点中
35. province.appendChild(opt);
36. }
37. var cities = document.getElementById("cities");
38. province.onchange = function() {
39. var pce = document.getElementById("province");
40. var opts = pce.options;
41. var opt1 = opts[pce.selectedIndex];
42. var name = opt1.innerHTML;
43. for ( var i = 0; i <
44.provinces.length; i++) {
45. //获取省节点的name属性的值
46. var name1 = provinces
47.[i].getAttribute("name");
48. if (name == name1) {
49. cities.length=1;//每次改变的时候清空
50. var pros = provinces[i];
51. var citys = pros.childNodes;
52. for ( var j = 0; j < citys.length; j++) {
53. //创建一个option
54. var opt1 = document.createElement("option");
55. //为option添加文本
56.
57.opt1.appendChild(document.createTextNode(citys[j].firstChild.nodeValue));
58. //添加到父节点中
59.
60.cities.appendChild(opt1);
61. }
62. }
63.
64. }
65.
66. }
67.
68.}
69.</script>
|
|||
| 自己写的Java读取XML文件-采用jdom技术-3 | 自己写的java读取xml文件-采用jdom技术-3 | ||
//1. ReadTreeXML3.java
package com.xml.file;
import java.io.FileInputStream;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class ReadTreeXML3 {
/**
* 读取树形菜单
*/
public static void readTree(){
try {
FileInputStream fis=new FileInputStream("d:\\menuTree3.xml");
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fis);
Element root=doc.getRootElement();
List allMenus=root.getChildren();
for(int i=0;i<allMenus.size();i++){
Element menu=(Element)allMenus.get(i); //得到每个menu
List allOneMenus=menu.getChildren("oneMenu");
for(int j=0;j<allOneMenus.size();j++){
Element oneMenu=(Element)allOneMenus.get(j); //获取每个menu下的每个oneMenu
System.out.println(oneMenu.getText().trim());
List allTwoMenus=oneMenu.getChildren("twoMenu"); //获取oneMenu下的所有twoMenu
for(int z=0;z<allTwoMenus.size();z++){
Element twoMenu=(Element)allTwoMenus.get(z);
System.out.println(" "+twoMenu.getText().trim());
List allThreeMenus=twoMenu.getChildren("threeMenu");
for(int m=0;m<allThreeMenus.size();m++){
Element threeMenu=(Element)allThreeMenus.get(m);
System.out.println(" "+threeMenu.getText().trim());
}
}
System.out.println("******************************************************************");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args){
readTree(); //读取树菜单信息
}
}
//2. menuTree3.xml存放在d盘根目录下
<?xml version="1.0" encoding="GBK" ?>
<menusTree>
<menu>
<oneMenu>
菜单1
<twoMenu>
菜单11
<threeMenu>
菜单111
</threeMenu>
</twoMenu>
<twoMenu>
菜单12
<threeMenu>
菜单121
</threeMenu>
<threeMenu>
菜单122
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单2
<twoMenu>
菜单21
<threeMenu>
菜单211
</threeMenu>
<threeMenu>
菜单212
</threeMenu>
</twoMenu>
<twoMenu>
菜单22
<threeMenu>
菜单221
</threeMenu>
<threeMenu>
菜单222
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单3
<twoMenu>
菜单31
<threeMenu>
菜单311
</threeMenu>
<threeMenu>
菜单312
</threeMenu>
</twoMenu>
<twoMenu>
菜单32
<threeMenu>
菜单321
</threeMenu>
<threeMenu>
菜单322
</threeMenu>
<threeMenu>
菜单323
</threeMenu>
</twoMenu>
<twoMenu>
菜单33
<threeMenu>
菜单331
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单4
<twoMenu>
菜单41
<threeMenu>
菜单411
</threeMenu>
</twoMenu>
<twoMenu>
菜单42
<threeMenu>
菜单421
</threeMenu>
</twoMenu>
<twoMenu>
菜单43
<threeMenu>
菜单431
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单5
<twoMenu>
菜单51
<threeMenu>
菜单511
</threeMenu>
<threeMenu>
菜单512
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单6
<twoMenu>
菜单61
<threeMenu>
菜单611
</threeMenu>
</twoMenu>
</oneMenu>
</menu>
</menusTree>
|
|||
| 自己写的Java读取XML文件-采用jdom技术-2 | 自己写的java读取xml文件-采用jdom技术-2 | ||
//1. ReadTreeXML2.java
package com.xml.file;
import java.io.FileInputStream;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class ReadTreeXML2 {
/**
* 读取树形菜单
*/
public static void readTree(){
try {
FileInputStream fis=new FileInputStream("d:\\menuTree2.xml");
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fis);
Element root=doc.getRootElement();
List allMenus=root.getChildren();
for(int i=0;i<allMenus.size();i++){
Element menu=(Element)allMenus.get(i); //得到每个menu
List allOneMenus=menu.getChildren("oneMenu");
for(int j=0;j<allOneMenus.size();j++){
Element oneMenu=(Element)allOneMenus.get(j); //获取每个menu下的每个oneMenu
System.out.println(oneMenu.getText());
List allTwoMenus=oneMenu.getChildren("twoMenu"); //获取oneMenu下的所有twoMenu
for(int z=0;z<allTwoMenus.size();z++){
Element twoMenu=(Element)allTwoMenus.get(z);
System.out.println(twoMenu.getText());
}
System.out.println("******************************************************************");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args){
readTree(); //读取树菜单信息
}
}
//2. menuTree2.xml
<?xml version="1.0" encoding="GBK" ?>
<menusTree>
<menu>
<oneMenu>
菜单1
<twoMenu>
菜单11
</twoMenu>
<twoMenu>
菜单12
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单2
<twoMenu>
菜单21
</twoMenu>
<twoMenu>
菜单22
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单3
<twoMenu>
菜单31
</twoMenu>
<twoMenu>
菜单32
</twoMenu>
<twoMenu>
菜单33
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单4
<twoMenu>
菜单41
</twoMenu>
<twoMenu>
菜单42
</twoMenu>
<twoMenu>
菜单43
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单5
<twoMenu>
菜单51
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
菜单6
<twoMenu>
菜单61
</twoMenu>
</oneMenu>
</menu>
</menusTree>
|
|||
| 自己的Java读取XML文件-采用jdom技术 | 自己的java读取xml文件-采用jdom技术 | ||
//1. java源文件: --需要导入jdom.jar包
package com.xml.file;
import java.io.FileInputStream;
import java.util.List;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class ReadTreeXML {
/**
* 读取树形菜单
*/
public static void readTree(){
try {
FileInputStream fis=new FileInputStream("d:\\menuTree.xml");
SAXBuilder sb=new SAXBuilder();
Document doc=sb.build(fis);
Element root=doc.getRootElement();
List allMenus=root.getChildren();
for(int i=0;i<allMenus.size();i++){
Element menu=(Element)allMenus.get(i); //得到每个menu
List allOneMenus=menu.getChildren("oneMenu");
for(int j=0;j<allOneMenus.size();j++){
Element oneMenu=(Element)allOneMenus.get(j); //获取每个menu下的每个oneMenu
Element oneMenuValue=oneMenu.getChild("value");
System.out.println(oneMenuValue.getText());
List allTwoMenus=oneMenu.getChildren("twoMenu"); //获取oneMenu下的所有twoMenu
for(int z=0;z<allTwoMenus.size();z++){
Element twoMenu=(Element)allTwoMenus.get(z);
System.out.println(twoMenu.getText());
}
System.out.println("******************************************************************");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args){
readTree(); //读取树菜单信息
}
}
//2. XML文件--该文件存放路径d:\\menuTree.xml
<?xml version="1.0" encoding="GBK" ?>
<menusTree>
<menu>
<oneMenu>
<value>菜单1</value>
<twoMenu>
菜单11
</twoMenu>
<twoMenu>
菜单12
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
<value>菜单2</value>
<twoMenu>
菜单21
</twoMenu>
<twoMenu>
菜单22
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
<value>菜单3</value>
<twoMenu>
菜单31
</twoMenu>
<twoMenu>
菜单32
</twoMenu>
<twoMenu>
菜单33
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
<value>菜单4</value>
<twoMenu>
菜单41
</twoMenu>
<twoMenu>
菜单42
</twoMenu>
<twoMenu>
菜单43
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
<value>菜单5</value>
<twoMenu>
菜单51
</twoMenu>
</oneMenu>
</menu>
<menu>
<oneMenu>
<value>菜单6</value>
<twoMenu>
菜单61
</twoMenu>
</oneMenu>
</menu>
</menusTree>
|
|||
| Java读取XML文件 | java读取xml文件 | ||
package demo1; //此处是我的项目包名，您不用复制
/**
* Java读取xml文件，必须要加载jdom.jar程序。
* 您必须有jdom-1.1插件，如果没有，可以在网上搜索下载。
* 加载的jdom.jar位于jdom-1.1/build/jdom.jar
* 这里我准备了一段xml代码，它在这个文档的最底部。
* 您要使用这个xml代码时，不要忘记去掉注释符号。^_^
*/
//以下是导入包
import java.io.FileInputStream;
import java.util.List;
import java.util.Vector;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.input.SAXBuilder;
public class Test {
public static void main(String[] args) {
FileInputStream fi = null;
try {
/**
* 下面代码的"D:\\a.xml"，是我把xml文件保存在D盘，
* 并起名为a.xml，这里您根据您xml文件的实际位置来
* 输入正确的文件路径。
*/
fi = new FileInputStream("D:\\a.xml");
SAXBuilder sb = new SAXBuilder();
Document doc = sb.build(fi);
Element root = doc.getRootElement(); // 得到根元素
List Allstudents = root.getChildren(); // 得到根元素所有子元素的集合
Element student = null;
for (int i = 0; i < Allstudents.size(); i++) {
student = (Element) Allstudents.get(i);
//下面代码根据节点名称获得xml文件节点内的信息并输出。
System.out.println(student.getChild("姓名").getText());
System.out.println(student.getChild("年龄").getText());
System.out.println(student.getChild("性别").getText());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fi.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 这里encoding="GBK"——使得xml文件保存的中文数据
* 被读出的时候不会出现乱码。
* <?xml version="1.0" encoding="GBK"?>
* <学校>
* <学生>
* <姓名>孟星魂</姓名>
* <年龄>18</年龄>
* <性别>男</性别>
* </学生>
* <学生>
* <姓名>冷燕</姓名>
* <年龄>17</年龄>
* <性别>女</性别>
* </学生>
* </学校>
*
*~~最后，如果你使用这个测试类，不要忘记复制该文档的最下面有一个'}'
*/
}
|
|||
| web.xml中配置404错误页面 | web.xml中配置404错误页面 | ||
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<filter>
<filter-name>Set Character Encoding</filter-name>
<filter-class>common.filters.SetCharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>GB2312</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>Set Character Encoding</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>UserFilter</filter-name>
<filter-class>common.filters.UserFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>UserFilter</filter-name>
<url-pattern>*.do</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>UserFilter</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>
<filter-mapping>
<filter-name>UserFilter</filter-name>
<url-pattern>/userservlet</url-pattern>
</filter-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<error-page>
<error-code>404</error-code>
<location>/error.jsp</location>
</error-page>
<servlet>
<servlet-name>log4jinit</servlet-name>
<servlet-class>dmdbSrc.common.Log4JInit</servlet-class>
<init-param>
<param-name>log4j-config-file</param-name>
<param-value>/WEB-INF/classes/log4j.properties</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>userservlet</servlet-name>
<servlet-class>common.user.UserServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>userservlet</servlet-name>
<url-pattern>/userservlet</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>SelectRecordUniformLM</servlet-name>
<servlet-class>
common.crudLM.SelectRecordUniformLM
</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonInsertLM</servlet-name>
<servlet-class>
common.crudLM.CommonInsertServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonUpdateServlet</servlet-name>
<servlet-class>common.crudLM.update.CommonUpdateServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonDeleteServlet</servlet-name>
<servlet-class>common.crudLM.delete.CommonDeleteServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>AddAlarmServlet</servlet-name>
<servlet-class>alarm.lm.AddAlarmServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>ActionServlet</servlet-name>
<servlet-class>common.action.ActionServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonInsertWithApplicantServlet</servlet-name>
<servlet-class>common.action.CommonInsertWithApplicantServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>UpdateAlarmForActionServlet</servlet-name>
<servlet-class>alarm.lm.UpdateAlarmForActionServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonUpdateWithApplicantServlet</servlet-name>
<servlet-class>common.action.CommonUpdateWithApplicantServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>AlarmFaultServlet</servlet-name>
<servlet-class>alarmFault.lm.AlarmFaultServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>AlarmFaultUpdate</servlet-name>
<servlet-class>alarmFault.lm.UpdateAlarmFaultServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>CommonDeleteWithApplicantServlet</servlet-name>
<servlet-class>common.action.CommonDeleteWithApplicantServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>DeleteParameterServlet</servlet-name>
<servlet-class>parameter.DeleteParameterServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>MailServlet</servlet-name>
<servlet-class>common.mail.MailServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>FileUploadServlet</servlet-name>
<servlet-class>common.fileUpload.FileUploadServlet</servlet-class>
</servlet>
<servlet>
<servlet-name>InsertAlarmFaultMultipleLM</servlet-name>
<servlet-class>
alarmFault.lm.InsertAlarmFaultMultipleServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>InsertVersionFaultLM</servlet-name>
<servlet-class>
versionFault.lm.InsertVersionFaultServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>InsertVersionAlarmLM</servlet-name>
<servlet-class>
versionAlarm.lm.InsertVersionAlarmServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>AlarmCopyServlet</servlet-name>
<servlet-class>
versionAlarm.lm.AlarmCopyServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>AlarmSetServlet</servlet-name>
<servlet-class>
versionAlarm.lm.AlarmSetServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>FaultCopyServlet</servlet-name>
<servlet-class>
versionFault.lm.FaultCopyServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>FaultSetServlet</servlet-name>
<servlet-class>
versionFault.lm.FaultSetServlet
</servlet-class>
</servlet>
<servlet>
<servlet-name>AlarmFaultCopyServlet</servlet-name>
<servlet-class>
alarmFault.lm.AlarmFaultCopyServlet
</servlet-class>
</servlet>
<!-- yesiming start time:2009-11-24 -->
<servlet>
<servlet-name>FRServlet</servlet-name>
<servlet-class>faultRelativity.servlet.servlet.FRServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>FRServlet</servlet-name>
<url-pattern>/FRServlet.do</url-pattern>
</servlet-mapping>
<!-- yesiming end time:2009-11-24 -->
<servlet-mapping>
<servlet-name>SelectRecordUniformLM</servlet-name>
<url-pattern>/SelectRecordUniformLM.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonInsertLM</servlet-name>
<url-pattern>/CommonInsertServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonUpdateServlet</servlet-name>
<url-pattern>/CommonUpdateServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonDeleteServlet</servlet-name>
<url-pattern>/CommonDeleteServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AddAlarmServlet</servlet-name>
<url-pattern>/AddAlarmServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>ActionServlet</servlet-name>
<url-pattern>/ActionServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonInsertWithApplicantServlet</servlet-name>
<url-pattern>/CommonInsertWithApplicantServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>UpdateAlarmForActionServlet</servlet-name>
<url-pattern>/UpdateAlarmForActionServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonUpdateWithApplicantServlet</servlet-name>
<url-pattern>/CommonUpdateWithApplicantServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AlarmFaultServlet</servlet-name>
<url-pattern>/AlarmFaultServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AlarmFaultUpdate</servlet-name>
<url-pattern>/UpdateAlarmFaultServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>CommonDeleteWithApplicantServlet</servlet-name>
<url-pattern>/CommonDeleteWithApplicantServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>DeleteParameterServlet</servlet-name>
<url-pattern>/DeleteParameterServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>MailServlet</servlet-name>
<url-pattern>/MailServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>FileUploadServlet</servlet-name>
<url-pattern>/FileUploadServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>InsertAlarmFaultMultipleLM</servlet-name>
<url-pattern>/InsertAlarmFaultMultipleServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>InsertVersionFaultLM</servlet-name>
<url-pattern>/InsertVersionFaultServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>InsertVersionAlarmLM</servlet-name>
<url-pattern>/InsertVersionAlarmServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AlarmCopyServlet</servlet-name>
<url-pattern>/AlarmCopyServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>FaultCopyServlet</servlet-name>
<url-pattern>/FaultCopyServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AlarmSetServlet</servlet-name>
<url-pattern>/AlarmSetServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>FaultSetServlet</servlet-name>
<url-pattern>/FaultSetServlet.do</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>AlarmFaultCopyServlet</servlet-name>
<url-pattern>/AlarmFaultCopyServlet.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>InsertFaultRelativityServlet</servlet-name>
<servlet-class>faultRelativity.servlet.InsertFaultRelativityServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>InsertFaultRelativityServlet</servlet-name>
<url-pattern>/InsertFaultRelativityServlet.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>faultRelativityCopyServlet</servlet-name>
<servlet-class>faultRelativity.servlet.FaultRelativityCopyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>faultRelativityCopyServlet</servlet-name>
<url-pattern>/FaultRelativityCopyServlet.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>FaultRelativityDeleteServlet</servlet-name>
<servlet-class>faultRelativity.servlet.FaultRelativityDeleteServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>FaultRelativityDeleteServlet</servlet-name>
<url-pattern>/FaultRelativityDeleteServlet.do</url-pattern>
</servlet-mapping>
</web-app>
|
|||
| java连接sql server数据库2 | java连接sql server数据库2 | ||
import java.sql.*;
public class Test {
public static void main(String[] srg) {
String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; //加载JDBC驱动
String dbURL = "jdbc:sqlserver://localhost:1433; DatabaseName=test"; //连接服务器和数据库test
String userName = "sa"; //默认用户名
String userPwd = "123456"; //安装sql server 2005时的密码
Connection dbConn;
try {
Class.forName(driverName);
dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
System.out.println("Connection Successful!"); //如果连接成功 控制台输出Connection Successful!
} catch (Exception e) {
e.printStackTrace();
}
}
}
|
|||
| java连接sql server数据库 | java连接sql server数据库 | ||
/*
* date created 2005-5-19
*/
package common.db;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Vector;
import org.apache.log4j.Logger;
/**
* @author Fred
*/
public class ConnManager
{
static Logger logger = Logger.getLogger(ConnManager.class);
//define datasourse name
//private static String strDataSourceName = "jdbc/DMDBDataSource";
static private ConnManager instance; // 唯一实例
static private int clients = 0;
private Vector drivers = new Vector();
private PrintWriter log;
private Hashtable pools = new Hashtable();
/**
* 返回唯一实例.如果是第一次调用此方法,则创建实例
*
* @return ConnManager 唯一实例
*/
static synchronized public ConnManager getInstance()
{
if(instance == null)
{
instance = new ConnManager();
clients++;
}
return instance;
}
/**
* 建构函数私有以防止其它对象创建本类实例
*/
public ConnManager()
{
}
/**
*
* @param name
* 在属性文件中定义的连接池名字
* @return Connection 可用连接或null
*/
public Connection getConn(String dbName)
{
Connection conn=null;
try
{
conn= DBPool.getPool(dbName).getConnection();
//System.out.println("+++Get connection from "+dbName+" successfully!+++");
logger.error("+++Get connection from "+dbName+" successfully!+++");
}
catch(Exception e)
{
//System.out.println("***Get connection from "+dbName+" error!***");
logger.error("Get connection from the database of "+dbName+" error:\n"+ e.getMessage());
e.printStackTrace();
}
return conn;
}
public Connection getConnForTest(String dbName)
{
Connection conn = null;
try
{
Class.forName("net.sourceforge.jtds.jdbc.Driver").newInstance();
String url ="jdbc:jtds:sqlserver://10.23.18.43:1433;DatabaseName="+dbName+";SelectMethod=Cursor";
String user = "sa";
String password = "dmdbtool";
conn = DriverManager.getConnection(url, user, password);
}
catch(Exception e)
{
e.printStackTrace();
}
return conn;
}
/*
* create a connection
*/
/*
public Connection getConn() throws ExceptionInterface
{
Connection conn = null;
try
{
conn = getConnection("infomodel");
//Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
//String url =
// "jdbc:microsoft:sqlserver://CN1D13CC:1433;DatabaseName=DMDB";
//String user = "sa";
//String password = "dmdbtool";
//conn = DriverManager.getConnection(url, user, password);
//String name = "sun.jdbc.odbc.JdbcOdbcDriver";//
// com.ms.jdbc.odbc.JdbcOdbcDriver
// Class.forName(name);
// name = "jdbc:odbc:DMDB";
// conn = DriverManager.getConnection(name);
}
catch(Exception e)
{
throw new ExceptionInterface("database connention is failed:\n"
+ e.getMessage());
}
return conn;
}
*/
/*
* free a connection stmt: conn: a database connection
*/
public void freeConn(Statement stmt, Connection conn,String dbName)
{
try
{
if(stmt != null)
{
stmt.close();
}
}
catch(Exception e)
{
logger.error("close Statement is failed:\n"
+ e.getMessage());
e.printStackTrace();
}
try
{
if(conn!=null)
{
conn.close();
logger.error("---Put connection to pool of "+dbName+" ---");
}
//System.out.println("---Put connection to pool of "+dbName+" ---");
}
catch(Exception e)
{
logger.error(
"close database connention is failed:\n" + e.getMessage());
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception
{
new ConnManager();
}
}
|
|||
| http://china-pub2010.iteye.com/blog/1413544 | http://china-pub2010.iteye.com/blog/1413544 | http://china-pub2010.iteye.com/blog/1413544 | |
http://china-pub2010.iteye.com/blog/1413544 |
|||
| Java文件读写操作 | java文件读写操作 | ||
package com.test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class GetVersionName {
//主方法
public static void main(String[] args){
GetVersionName getVersionName=new GetVersionName();
// List<String> fileList=getVersionName.getAllVersionName();
// System.out.println("所有的版本号--");
// for(String s:fileList){
// System.out.println("版本号:"+s);
// }
//写入文件
//getVersionName.writeDiskOfAlarm();
//读取数据
//getVersionName.readAlarm();
getVersionName.beforeReadAfterWrite();
}
//将从数据库中获取到的所有告警的版本信息写入硬盘文件中--从文件的末尾开始写数据
//--主要用途：
//----1. 可以将日志记录写入到硬盘文件中
//----2. 可以将缓存数据写入到硬盘文件中
public List<String> writeDiskOfAlarm(){
try{
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("d:\\AEDBTool_File\\alarm_info.txt",true));
List<String> list=this.getAllVersionName();
int len=0;
byte[] b=null;
for(String s:list){
len=s.length();
b=s.getBytes();
bos.write(b, 0, len);
bos.write("\n".getBytes());
}
bos.flush();
bos.close();
}catch(FileNotFoundException e){
System.out.println("找不到文件");
}catch(Exception e){
e.printStackTrace();
}
return null;
}
//读取数据
public boolean readAlarm(){
try{
String readPath="d:\\AEDBTool_File\\alarm_info.txt"; //d:\\AEDBTool_File\\alarm_info.txt
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(readPath));
char c=' ';
int b=-1;
StringBuffer s=new StringBuffer();
while((b=bis.read())!=-1){
c=(char)b;
s.append(c);
}
System.out.println("读取的数据如下：\n"+s);
}catch(Exception e){
e.printStackTrace();
}
return true;
}
//先读数据后写数据
/**
* 主要用途有：
* 1. 日志记录等
* 2. 数据缓存等
*/
public boolean beforeReadAfterWrite(){
try {
File f=new File("d:\\AEDBTool_File\\cache_alarm_info.txt");
File f2=new File("d:\\AEDBTool_File\\alarm_log.txt");
if(f.exists()){
f.createNewFile();
}
if(f2.exists()){
f2.createNewFile();
}
//如果文件的大小大于1Kb的话则清空f.length()返回的是文件的大小，单位为字节数
if(f.length()>1024){
f.delete();
f.createNewFile();
}
if(f2.length()>1024){
f2.delete();
f2.createNewFile();
}
BufferedReader br=new BufferedReader(new FileReader("d:\\AEDBTool_File\\alarm_info.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter(new File("d:\\AEDBTool_File\\cache_alarm_info.txt"),true));
BufferedWriter alarmLogInfo=new BufferedWriter(new FileWriter(new File("d:\\AEDBTool_File\\alarm_log.txt"),true));
if(f.length()==0){
bw.write("************************缓存数据**************************");
}
if(f2.length()==0){
alarmLogInfo.write("****************************日志记录*****************************");
}
String s="";
StringBuffer buf=new StringBuffer();
// while((s=br.readLine())!=null){
// buf.append(s);
// bw.write(s);
// }
Date date=new Date();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time=sdf.format(date);
bw.write("\n****************"+time+"****************"+"\n".toString());
alarmLogInfo.write("\n****************"+time+"****************"+"\n");
char c=' ';
int b=-1;
while((b=br.read())!=-1){
c=(char)b;
bw.write(b);
alarmLogInfo.write(b);
}
bw.write("\n".toString());
alarmLogInfo.write("\n");
bw.flush();
alarmLogInfo.flush();
bw.close();
alarmLogInfo.close();
br.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
//获取版本信息
public List<String> getAllVersionName(){
File file=new File("d:\\");
File[] f=file.listFiles();
System.out.println("文件的个数为："+f.length);
String[] vs=null;
String fn="";
String vn="";
List<String> fileList=new ArrayList<String>();
for(int i=0;i<f.length;i++){
//得到每个文件的文件名
fn=f[i].getName();
if(fn.startsWith("告警")){
vs=fn.split("_");
if(vs[1].indexOf(".")>-1){
vn=vs[1].substring(0,vs[1].indexOf("."));
fileList.add(vn);
}
}
}
return fileList;
}
}
|
|||