|
|
2010年3月6日
1、http://www.jar114.com/site.html
该网站可以提供我们项目中经常需要的jar包，如果缺少包，就可以在这里查找。
流程定义文件*.jpdl.xml中如果有中文乱码，肯定是task中有中文。
需要在eclipse安装软件下，即E:\eclipse\eclipse.ini增加
-Dfile.encoding=UTF-8
然后重启eclipse即可解决。
配置jbpm4工程的运行环境：
1、添加依赖库。
E:\JBPM\jbpm-4.3\jbpm.jar
E:\JBPM\jbpm-4.3\lib下的jar包。
2、添加配置文件。
E:\JBPM\jbpm-4.3\examples\src下的配置文件拷贝到自己java工程的src下。
---------------------------------------------------------------
管理流程定义：发布流程定义、查看流程定义、删除流程定义。
RepositoryService repositoryService = processEngine.getRepositoryService();
String deploymentId = repositoryService.createDeployment().addResourceFromClasspath
("helloworld.jpdl.xml").deploy();
List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery().list();
repositoryService.deleteDeploymentCascade(deploymentId);
---------------------------------------------------------------
管理流程实例：发起新流程、执行等待的流程、查看流程实例、终止流程实例、删除流程实例。
ExecutionService executionService = processEngine.getExecutionService();
ProcessInstance pi = executionService.startProcessInstanceByKey("helloworld");
ProcessInstance pi = executionService.signalExecutionById(pi.getId()); //执行等待的流程.
List<ProcessInstance> list = executionService.createProcessInstanceQuery().list();
executionService.endProcessInstance(pi.getId(), "cancel");
executionService.deleteProcessInstanceCascade(pi.getId());
TaskService taskService = processEngine.getTaskService();
taskService.completeTask(taskId, map);
控制流程的活动：Start、End、Decision、Fork、Join、Sub-process、State、task.
原子活动：java、script、sql、hql、email。
配置开发环境：
1、jbpm4：http://sourceforge.net/projects/jbpm/files/ 下选择jbpm-4.3.zip 137.9M
2、eclipse3.5版本以上 : http://www.eclipse.org/downloads/ 下选择 Eclipse IDE for Java EE 190M
3、GPD (Graphical Process Designer)插件，路径：E:\jbpm-4.3\install\src\gpd\jbpm-gpd-site.zip。
通过Eclipse-->help-->Install New Software-->Add-->Archive到插件所在路径。
java.lang.NullPointerException
at jxl.read.biff.File.<init>(File.java:77)
at jxl.Workbook.getWorkbook(Workbook.java:250)
at jxl.Workbook.getWorkbook(Workbook.java:235)
at org.drools.decisiontable.parser.xls.ExcelParser.parseFile(ExcelParser.java:76)
at org.drools.decisiontable.SpreadsheetCompiler.compile(SpreadsheetCompiler.java:89)
at org.drools.decisiontable.SpreadsheetCompiler.compile(SpreadsheetCompiler.java:68)
at com.sample.DecisionTableTest.readDecisionTable(DecisionTableTest.java:59)
at com.sample.DecisionTableTest.main(DecisionTableTest.java:36)
Drools调用readDecisionTable()方法里面一处为：
InputStream is = DecisionTableTest.class.getResourceAsStream("rules\\Sample.xls");
final String drl = converter.compile( is, InputType.XLS );
需改为如下，取的class即错误解决。
InputStream is = DecisionTableTest.class.getClassLoader().getResourceAsStream("rules\\Sample.xls");
final String drl = converter.compile( is, InputType.XLS );
org.mvel.CompileException: can not resolve identifier: 'declr'
at org.mvel.ASTNode.getReducedValue(ASTNode.java:315)
at org.mvel.ast.PropertyASTNode.getReducedValue(PropertyASTNode.java:29)
at org.mvel.MVELInterpretedRuntime.parseAndExecuteInterpreted(MVELInterpretedRuntime.java:103)
at org.mvel.MVELInterpretedRuntime.parse(MVELInterpretedRuntime.java:51)
at org.mvel.TemplateInterpreter.execute(TemplateInterpreter.java:428)
at org.mvel.TemplateInterpreter.parse(TemplateInterpreter.java:320)
at org.drools.rule.builder.dialect.java.AbstractJavaBuilder.generatTemplates(AbstractJavaBuilder.java:113)
at org.drools.rule.builder.dialect.java.JavaConsequenceBuilder.build(JavaConsequenceBuilder.java:95)
at org.drools.rule.builder.RuleBuilder.build(RuleBuilder.java:67)
at org.drools.compiler.PackageBuilder.addRule(PackageBuilder.java:446)
at org.drools.compiler.PackageBuilder.addPackage(PackageBuilder.java:304)
at org.drools.compiler.PackageBuilder.addPackageFromDrl(PackageBuilder.java:167)
at com.sample.DecisionTableTest.readDecisionTable(DecisionTableTest.java:63)
at com.sample.DecisionTableTest.main(DecisionTableTest.java:36)
替换mvel.jar为mvel14-1.2.10.jar后不再报错，好像是jar包的问题。
看了下jar包里面的org.mvel.ASTNode.getReducedValue方法已经注释掉了。
WARNING: Wasn't able to correctly close stream for decision table. nulljava.lang.NullPointerException
at jxl.read.biff.File.<init>(File.java:77)
at jxl.Workbook.getWorkbook(Workbook.java:250)
at jxl.Workbook.getWorkbook(Workbook.java:235)
at org.drools.decisiontable.parser.xls.ExcelParser.parseFile(ExcelParser.java:76)
at org.drools.decisiontable.SpreadsheetCompiler.compile(SpreadsheetCompiler.java:89)
at org.drools.decisiontable.SpreadsheetCompiler.compile(SpreadsheetCompiler.java:68)
at org.drools.decisiontable.SpreadsheetCompiler.compile(SpreadsheetCompiler.java:110)
at com.sample.DecisionTableTest.readDecisionTable(DecisionTableTest.java:57)
at com.sample.DecisionTableTest.main(DecisionTableTest.java:35)
在web项目中的原先的写法为：
final String drl = converter.compile( "rules\\Sample.xls", InputType.XLS );
参考了下别人的写法，改为下面的方式进行处理：
InputStream is = DecisionTableTest.class.getClassLoader().getResourceAsStream("rules\\Sample.xls");
final String drl = converter.compile( is, InputType.XLS );
由于drools有新版本了，所以与MyEclipse整合进行了解下。
整合步骤如下：
1、下载MyEclipse 8.5；
2、在http://www.jboss.org/drools/downloads.html下载Drools Eclipse 3.5 Workbench 5.1 插件；
3、在E:\MyEclipse8.5下新建2个文件：links、myplugins。
E:\MyEclipse 8.5\links：放drools.link配置文件，内容为path=E:\\MyEclipse 8.5\\myplugins\\drools\\
E:\MyEclipse 8.5\myplugins：放drools文件，该E:\MyEclipse 8.5\myplugins\drools\eclipse下放置从网上下载的drools插件的features和plugins。
4、重启MyEclipse 8.5即可看见drools图标。
5、安装Jboss：下载jboss-5.0.0.GA，解压即可。
打开MyEclipse->window->Preference->MyEclipse->Servers->JBoss->JBoss 5.x进行jre及相关配置。
在命令行下运行java程序，出现如上异常Exception in thread "main" java.lang.UnsupportedClassVersionError。
主要是jdk的版本被oracle给换成低版本了。
可以在命令行下输入：javac -version 查看版本，最后把%JAVA_HOME%\bin;添加到Oracle之前，再重开启电脑，编译，运行即可。
可以查考：http://hi.baidu.com/tianxingacer/blog/item/e628b947ffc54f016a63e5ac.html/cmtid/1fe1e9ae1dc5b9f6faed50d9
我的机器以前装的是offices2003自带的js调试工具，昨天按照上IE8后，js调试工具有时候是ie8的调试界面，有时是ie6的调试界面，经网上查找已找到原因。
主要是我把IE8的‘脚本’下的“启动调试”给关了，所以最后只出现ie6的调试界面。
解决方法：打开IE8后，点击"工具"->"开发人员工具",或者快捷键F12，会打开页面调试窗口。
今天用反编译工具查看java源代码，发现反编译的java文件有错误，在网上了解了下，是原先开发人员对代码做了一下加密处理。下面介绍一下java的混淆器Proguard。
ProGuard 是一个免费的 Java类文件的压缩，优化，混肴器。它删除没有用的类，字段，方法与属性。使字节码最大程度地优化，使用简短且无意义的名字来重命名类、字段和方法 。eclipse已经把Proguard集成在一起了。
其他地方也有介绍，如下：http://blog.csdn.net/alex197963/archive/2008/07/07/2620603.aspx
1、当处理多个访问相同数据的用户时，通常可能出现三种问题:
脏读
当应用程序使用了被另一个应用程序修改过的数据，而这个数据处于未提交状态时，就会发生脏读。第二个应用程序随后会请求回滚被其修改的数据。第一个事务使用的数据就会被损坏，或者“变脏”。
不可重复的读
当一个事务获得了数据，而该数据随后被一个单独的事务所更改时，若第一个事务再次读取更改后的数据，就会发生不可重复的读。这样，第一个事务进行了一个不可重复的读。
虚读
当事务通过某种查询获取了数据，另一个事务修改了部分该数据，原来的事务第二次获取该数据时，就会发生虚读。第一个事务现在会有不同的结果集，它可能包含虚读。
2、Java.sql.Connection接口定义的隔离级别
TRANSACTION_NONE 说明不支持事务
TRANSACTION_READ_UNCOMMITTED 说明在提交前一个事务可以看到另一个事务的变化。这样脏读、不可重复的读和虚读都是允许的。
TRANSACTION_READ_COMMITTED 说明读取未提交的数据是不允许的。这个级别仍然允许不可重复的读和虚读产生。
TRANSACTION_REPEATABLE_READ 说明事务保证能够再次读取相同的数据而不会失败，但虚读仍然会出现。
TRANSACTION_SERIALIZABLE 是最高的事务级别，它防止脏读、不可重复的读和虚读。
3、事务的隔离级别
在J2EE中，通过java.sql.Connection接口设置事务隔离级别，这一接口为连接的隔离级别提供了getter()和setter()
Int getTransactionIsolation() throws SQLException
void setTransactionIsolation() throws SQLException
Connection对象负责事务，一旦收到事务请求，事务将自动提交，因为Connection对象已定义为自动提交方式，可通过setAutoCommit(false)禁用自动提交模式
另外java.sql.DatabaseMetaData接口为数据存储提供支持的隔离级别查找方法：getTransactionIsolation(),supportsTransactionIsolationLevel()
对多个库操作的分布式事务必须在所有库中执行同一个隔离级别，否则会出现意想不到的结果
4、事务提交和回滚
为了完成提交事务和回滚事务，JDBC API包括了两个方法作为 Connection 接口的一部分。若将 Connection 对象名称指定为 con，通过调用 con.commit(); 可以保存程序状态；
通过调用 con.rollback(); 可以返回到以前保存的状态。如果数据库实际运行操作时有错误发生，这两个方法都会抛出 SQLExceptions，所以您需要在 try ... catch 块中包装它们。
5、批处理和事务
缺省情况下，JDBC 驱动程序运行在被称为自动提交的模式下,可禁用自动提交模式
con.setAutoCommit(false);
批处理操作中通过在一次单独的操作（或批处理）中执行多个数据库更新操作
{con.setAutoCommit(false) ;
Statement stmt = connection.createStatement() ; stmt.addBatch("INSERT INTO people VALUES('Joe Jackson', 0.325, 25, 105) ; stmt.addBatch("INSERT INTO people
VALUES('Jim Jackson', 0.349, 18, 99) ; stmt.addBatch("INSERT INTO people VALUES('Jack Jackson', 0.295, 15, 84) ;
int[] updateCounts = stmt.executeBatch() ; con.commit() ;
Initial Capacity：池的连接数量，在启动时创建
Maximun Capacity：这是池可以打开的连接的最大数量
Capacity Increment：成组地打开增量连接
Login Delay Seconds：池驱动程序在启动时打开每一个新的连接需要等待的时间
Refresh Period(刷新周期)
Supports Local Transaction：只用于XA连接池
Allow Shrinking and Shrink Period(允许收缩和收缩期)：如果池的数量太大，超过了初始，且如果任何一个连接在收缩期内空闲，那么空闲的连接将在收缩期末关闭
监控JDBC连接池：
Waiters Hight字段指明了最多有多少客户等待数据库连接
Waiters字段告诉你当前有多少客户正在等待连接
Connections Hight字段给出最大的并发连接数。
Wait Seconds Hight字段显示了客户等待数据库连接的最长时间
1、连接：
直接连接(direct connection)
池连接(pooled connection)
连接复用 ,避免了数据库连接频繁建立、关闭的开销 ；
对JDBC中的原始连接进行了封装 ,隔离了应用的本身的处理逻辑和具体数据库访问逻辑 。
2、什么是连接池？
连接池是在Weblogic启动时候预先建立的数据库连接，由Weblogic在运行时负责维护。
可以减少程序每次数据库请求都要新创建数据库物理连接的时间及资源。
对数据库属性的更改只需通过控制台进行，不需改动客户端代码
MultiPool
可以使用MultiPool为高用户访问量提供数据库负载均衡，它使用简单的循环算法将连接请求平衡分配MultiPool中的每一个池。
多池的作用：为防数据库连接失败提供冗余,备份或高有效池；为高用户访问量提供数据库负载均衡，负载均衡池。
备份池：一个备份池由一个有顺序的连接池列表组成。
负载均衡池：使用简单的循环算法将连接请求平衡地分到在列表中的每一个池。
3、DataSource
数据源对应一个数据库连接池。客户程序可以通过数据源绑定的JNDI名字得到该数据源的引用，并通过数据源对象得到数据库连接。
JDBC的API：
java.sql.DriverManager
java.sql.Connection
java.sql.ResultSet
Javax.sql.RowSet:
javax.sql.Statement
java.sql.PreparedStatement:用于执行预编译的SQL语句
java.sql.CallableStatement:用于执行在数据库中定义的存储过程
Javax.sql.DataSource是java.sql.Connectioin对象的工厂并使用一个JNDI服务注册它.
1、Type 1类型驱动，JDBC-ODBC桥
通常运行Windows平台，需要在客户端安装ODBC驱动，早期Java访问数据库的主要方式，效率较低。
适用于快速的原型系统，没有提供JDBC驱动的数据库如Access ,由于包含多个驱动程序层，其性能一般不适合生产系统
Java-->JDBC-ODBC Bridge---->JDBC-ODBC Library--->ODBC Driver-->Database
驱动程序的类名称是 sun.jdbc.odbc.JdbcOdbcDriver
JDBC URL 的形式为 jdbc:odbc:dsn(dsn 是使用 ODBC 管理员注册数据库的数据源名称)
不是100%JAVA程序，与ODBC之间的接口采用非JAVA方式调用，因此不能在APPLET中使用
{
String url = "jdbc:odbc:jdbc" ;
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection(url, "java", "sun");
}
2、Type 2类型驱动，需要在客户端安装数据库的本地驱动，JDBC请求会转换为对数据库本地API的调用。
利用开发商提供的本地库来直接与数据库通信。
Java-->JDBC-Driver-->DB Client Library-->Database
绕过了ODBC层，性能优于Type1
也称为部分 Java 驱动程序，因为它们直接将 JDBC API 翻译成具体数据库的API
使用第二种模型将开发者限制在数据库厂商的客户机库支持的客户机平台和操作系统
Oracle的OCI驱动就属于Type2
3、Type 3类型驱动，DBC请求通过网络服务器层实现，在网络服务器层可以实现负载均衡，连接池管理等。
第三种驱动程序是纯 Java 驱动程序，它将 JDBC API 转换成独立于数据库的协议。JDBC 驱动程序并没有直接和数据库进行通讯；它和一个中间件服务器通讯，然后这个中间件服务器和数据库进行通讯。这种额外的中间层次提供了灵活性：可以用相同的代码访问不同的数据库，因为中间件服务器隐藏了 Java 应用程序的细节。要转到不同的数据库，您只需在中间件服务器上改变参数。（有一点需要注意：中间件服务器必须支持您访问的数据库格式。）
第三种驱动程序的缺点是，额外的中间层次可能有损整体系统性能。另一方面，如果应用程序需要和不同的数据库格式进行交互，第三种驱动程序是个有效的方法，因为不管底层的数据库是什么，都使用同样的 JDBC 驱动程序。另外，因为中间件服务器可以安装在专门的硬件平台上，可以利用总的结果进行一些优化。
Java--->Jdbc Driver(Type3 jdbc driver)----->java middleware--->JDBC Driver---->Database
Weblogic的Pool驱动程序就是一个Type3的JDBC驱动程序。
4、Type 4类型驱动，为纯Java实现，不需要任何客户端设置。
OCI驱动程序利用Java本地化接口（JNI），通过Oracle客户端软件与数据库进行通讯。Thin驱动程序是纯Java驱动程序，它直接与数据库进行通讯。
JDBC应用的两种架构
两层架构：客户程序直接对数据库发起JDBC请求，Type1、2、4支持两层架构。
多层架构：客户程序将JDBC请求发送到中间层，中间层再将请求发送到数据库。
通常应用系统会根据用户数、并发数、用户的行为等等来确定具体的性能目标，如果确定应用程序不能满足性能目标，那么就需要优化、重构程序并调整JVM、应用服务器、数据库、OS 或者改变硬件配置等等。
影响Java 性能的主要因素：
硬件，如CPU、内存、体系结构等等
操作系统
数据库系统
JVM
应用服务器
数据库服务器
网络环境
应用架构及程序编写水平
性能调整的步骤：
1、 使用工具测试系统是否满足性能目标
2、 发现性能瓶颈
3、 假设瓶颈的原因
4、 测试你的假设
5、 如果假设成立，更改这一部分
6、 测试确定更改是否可以提高性能，衡量性能提高的程度
7、重复以上步骤，直到获得可以接受的性能。
J2EE性能不好时的现象，主要表现在对客户端的请求响应很慢：
一向很慢：应用的响应总是很慢，改变环境(如应用负载、数据库的连接池数量等等)，对响应时间的影响不大。
越来越慢：在相同的负载情况下，随着系统运行的时间的增长，系统越来越慢，这可能是系统已到达极限或是系统死锁和错误引起的。
低于负载时会越来越慢(Slower and slower under load):.
偶尔的挂起或异常错误(Sporadic hangs or aberrant errors):有时这可能是由于负载的变化或其他情况引起的可以预测的死锁(Foreseeable lock ups): 挂起或最初只有少量错误，但随着时间的推移整个系统都锁上了，典型地这可能是为的适应"management by restarts.“
突发性的混乱(Sudden chaos): 系统已运行了一段时间(如一个小时或可能是三、四天)，性能稳定并可以接受, 突然没有任何理由，开始出错或死锁了。
监控工具：
WebLogic Server的控制台
cpu
内存
JDBC
辅助的工具
Jprobe
Optimizit
Vtune
TowerJ Performance
WebLogic Server 10的下载地址：
http://www.oracle.com/technology/software/products/ias/htdocs/wls_main.html
1、域（Domains）
域是管理的单元或边界；
作为一个单元来管理的，并相互关联的一组Weblogic 服务器资源被称为域；
域由单一的管理服务器来管理。
2、机器（Machines）
可以对应到服务器所在的物理硬件；
可以是Unix或non-Unix类型；
可以用来远程管理和监控；
3、服务器（Servers）
服务器是执行在单一Java虚拟机 （JVM）中weblogic.Server类的实例。
服务器：最多和一个WLS机器关联；占用一定数量的RAM ；是多线程的。
4、管理服务器(Administration server)
对整个域的集中控制
XML配置存储库的保存者
日志信息的集中保存
5、被管理服务器(Managed Server)
WebLogicServer的一个实例；
从管理服务器远程加载配置信息‘；
可以是也可以不是集群的一部分。
6、集群 （Clustering）
WebLogic集群技术指通过一组服务器共同 工作，在多台机器间复制应用表示层和应用逻辑层的能力，实现关键业务系统的负载分布，消除个别故障点；集群用来实现负载均衡和容错。
1、J2EE应用开发的核心组件。
Servlet： 处理HTTP请求，产生响应。
JSP：Java Server Pages ，同Servlet。其中包含了HTML和JSP标签、Java代码和其他信息。
EJB：EJB服务端组件模型简化了具有交互性、扩展性和移植性中间组件的开发。EJB一般用于实现系统的业务逻辑。
2、J2EE的相关技术
核心：Servlet 、JSP、EJB
数据库：JDBC
命名和目录服务：JNDI
消息服务：JMS( Java Message Service )
Email：Java Mail
分布式计算：RMI、RMI-IIOP
事务：JTA（Java Transaction API）
数据格式化：XML、HTML、XSL
协议：TCP/IP、HTTP(S)、IIOP、SSL
安全：JAAS
3、J2EE的4层结构
客户层（浏览器）
Web层（HTML、Servlet、JSP）
业务层（EJB）
EIS层（关系数据库）
4、J2EE的Application Server：
Tomcat
BEA Weblogic
IBM Websphere
Oracle Application Server
Sun Java System
Jboss
Borland AppServer
Sybase Application Server
HP Application Server
Apusic
5、集成开发工具：
Borland：JBuilder
Oracle ：JDeveloper
Bea ：WebLogic Workshop
IBM：Websphere Studio
Sun：NetBeans
MyEclipse
在小型的应用系统或者有特殊需要的系统中，可以使用一个免费的Web服务器Tomcat，该服务器支持全部JSP以及Servlet规范，但是目前还不支持EJB。
在Java相关的开发领域中，常用的是3种数据库：Oracle、DB2和MySQL。有时候也使用微软公司的SQL Server数据库服务器 。
DateUtils.compareYear(regDate, base.getTInsrncBgnTm()) // 新旧车标志【保险起期 - 初登年月】 单位：年
//显示输入框录入的字符位数。 ztf 10.07.19
function displayLength(obj) {
var lenSpan = document.getElementById("lenSpan");
if (lenSpan == null) {
lenSpan = document.createElement("SPAN");
lenSpan.id = "lenSpan";
obj.parentNode.appendChild(lenSpan);
}
lenSpan.innerText = "已输入" + obj.value.length + "位";
}
onkeyup="displayLength(this)"进行js调用。
--情况1：多个参数的传递，由于多个文件编码不一致，可能出现乱码。
window.open(base+"/policy/universal/pop/flat_vhl_inf_query.jsp?
cLcnNo="+objPlateNo.value+"&cEngNo="+objEngNo.value+"&cVhlFrm="+objFrmNo.value+"&cPlateTy
p="+objPlateTyp+"&cProdNo="+objCProdNo+"&cDptCde="+objCDptCde+"&cNewMrk="+objNewMrk.value
+"&cEcdemicMrk="+objEcdemicMrk.value,"","scrollbars=yes,left=100,top=150,Toolbar=no,Locat
ion=no,Direction=no,Resizeable=no,Width="+800+" ,Height="+400);
--相应的jsp获得参数
<%
String CProdNo = request.getParameter("prodNo");
String CDptCde = request.getParameter("dptCde");
String CPlateNo = request.getParameter("plateNo");
String CFrmNo = request.getParameter("frmNo");
if("".equals(CPlateNo)&&"".equals(CFrmNo)){
return;
}
String dwName = "policy.pub.flat_vhl_inf_DW";
%>
--情况2：解决乱码的问题。
function tool_uploadFile(clmNo,billType,maxFileNum,fileType,singleLimit,totalLimit) {//解决乱码的问题，增加变量paramObj。ztf 10.06.01
var paramObj = {
"clmNo" : clmNo,
"billType" : billType,
"maxFileNum" : maxFileNum,
"fileType" : fileType,
"singleLimit" : singleLimit,
"totalLimit" : totalLimit
};
var r = window.showModalDialog(global.WEB_APP_NAME+"/core/jsp/common/uploadFile.jsp",paramObj,"dialogHeight:610px;dialogWidth:530px;center:1;help: 0; status: 0;");
return r;
}
--在相应的jsp页面通过js获得参数：
<html>
<head>
<title>文件上传</title>
</head>
<script type="text/javascript" src="<%=webApp%>/core/js/core/Tool.js"></script>
<body bgcolor="#85b7ec">
<script>
var paramObj = window.dialogArguments;
var clmNo = paramObj.clmNo;
var billType = paramObj.billType;
var maxFileNum = paramObj.maxFileNum;
var fileType = paramObj.fileType;
var singleLimit = paramObj.singleLimit;
var totalLimit = paramObj.totalLimit;
tool.loadApplet('<%=agentIp%>','<%=agentPort%>','<%=orgId%>',clmNo,billType,maxFileNum,fileType,singleLimit,totalLimit);
</script>
</body>
</html>
vReturnValue = window.showModalDialog(sURL [, vArguments] [, sFeatures])
1、具体业务中用到的sql，这个是查找最近标志为1，且有多条记录的数据。 (这个sql查找错误比较有用。)
select a.c_ply_no ,count(1) from web_ply_base a
where a.c_latest_mrk='1'
group by a.c_ply_no
having count(1)>1
背景count(*) count(1) 两者比较，主要还是要count(1)所相对应的数据字段：
如果你的数据表没有主键，那么count(1)比count(*)快
如果有主键的话，那主键（联合主键）作为count的条件也比count(*)要快
如果你的表只有一个字段的话那count(*)就是最快的啦
如果count(1)是聚索引,id,那肯定是count(1)快。但是差的很小的。
因为count(*),自动会优化指定到那一个字段。所以没必要去count(?)，用count(*),sql会帮你完成优化的.
其他语句：select * from 表名 where 条件 order by 字段名 asc\desc // asc 升序 desc 降序
2、C_Nme_En匹配多个 like 查询。
select distinct C_Spec_No
from WEB_Prd_Fix_Spec
WHERE C_Spec_No in (SELECT C_Spec_No
FROM web_Prd_Prod_Spec_Rel
WHERE C_Prod_No = '0326'
and C_Spec_No like '89%')
and (C_Nme_En like '%000000%' or C_Nme_En like '%030006%' or
C_Nme_En like '%030061%')
--递归，树状结构的存储与展示
drop table article;
create table article
(
id number primary key,
count varchar2(4000),
pid number,
isleaf number(1), --0 代表非叶子节点，1代表叶子节点
alevel number(2)
);
insert into article values(1,'蚂蚁大战大象',0,0,0);
insert into article values(2,'大象被打趴下',1,0,1);
insert into article values(3,'蚂蚁也不好过',2,1,2);
insert into article values(4,'瞎说',2,0,2);
insert into article values(5,'没有瞎说',4,1,3);
insert into article values(6,'怎么可能',1,0,1);
insert into article values(7,'怎么没有可能',6,1,2);
insert into article values(8,'可能性是很大的',6,1,2);
insert into article values(9,'大象进医院了',2,0,2);
insert into article values(10,'护士是蚂蚁',9,1,3);
commit;
蚂蚁大战大象
大象被打趴下了
蚂蚁也不好过
瞎说
没有瞎说
大象进医院了
护士是蚂蚁
怎么可能
怎么没有可能
可能性是很大的
--用存储过程展现树状结构。
create or replace procedure p(v_pid article.pid%type,v_level binary_integer) is
cursor c is select * from article where pid = v_pid;
v_preStr varchar2(1024) := '';
begin
for i in 0..v_level loop
v_preStr := v_preStr || '****';
end loop;
for v_article in c loop
dbms_output.put_line(v_preStr ||v_article.cont);
if(v_article.isleaf=0) then
p(v_artile.id,v_levle +1);
end if;
end loop;
end;
--触发器
create table emp2_log
(
uname varchar2(20);
action varchar2(10);
atime date
);
create or replace trigger trig
after insert or delete or update on emp2 for each row
begin
if inserting then
insert into emp2_log values (USER,'insert',sysdate); --USER关键字，用户。
elsif updating then
insert into emp2_log values (USER,'update',sysdate);
elsif deleting then
insert into emp2_log values (USER,'delete',sysdate);
end if;
end;
update emp2 set sal = sal*2 where deptno = 30;
select * from emp2_log;
drop trigger trig;
--直接执行时，出现违反完整约束条件，已找到子记录。
update dept set deptno = 99 where deptno = 10;
--使用下面的，把子表一起更新。
create or replace trigger trig
after update on dept for each row
begin
update emp set deptno =:NEW.deptno where deptno =:OLD.deptno;
end;
update dept set deptno = 99 where deptno = 10;
select * from emp;
rollback;
--函数
create or replace function sal_tax
(v_sal number)
return number
is
begin
if(v_sal < 2000) then
return 0.10;
elsif(v_sal < 2750) then
return 0.15;
else
return 0.20;
end if;
end;
数据库定义的函数money_to_chinese ，把数字转换正中文输出。
create or replace function money_to_chinese(money in VARCHAR2)
return varchar2 is
c_money VARCHAR2(12);
m_string VARCHAR2(60) := '分角圆拾佰仟万拾佰仟亿';
n_string VARCHAR2(40) := '壹贰叁肆伍陆柒捌玖';
b_string VARCHAR2(80);
n CHAR;
len NUMBER(3);
i NUMBER(3);
tmp NUMBER(12);
is_zero BOOLEAN;
z_count NUMBER(3);
l_money NUMBER;
l_sign VARCHAR2(10);
BEGIN
l_money := abs(money);
IF money < 0 THEN
l_sign := '负' ;
ELSE
l_sign := '';
END IF;
tmp := round(l_money, 2) * 100;
c_money := rtrim(ltrim(to_char(tmp, '999999999999')));
len := length(c_money);
is_zero := TRUE;
z_count := 0;
i := 0;
WHILE i < len LOOP
i := i + 1;
n := substr(c_money, i, 1);
IF n = '0' THEN
IF len - i = 6 OR len - i = 2 OR len = i THEN
IF is_zero THEN
b_string := substr(b_string, 1, length(b_string) - 1);
is_zero := FALSE;
END IF;
IF len - i = 6 THEN
b_string := b_string || '万';
END IF;
IF len - i = 2 THEN
b_string := b_string || '圆';
END IF;
IF len = i THEN
IF (len = 1) THEN
b_string := '零圆整';
ELSE
b_string := b_string || '整';
END IF;
END IF;
z_count := 0;
ELSE
IF z_count = 0 THEN
b_string := b_string || '零';
is_zero := TRUE;
END IF;
z_count := z_count + 1;
END IF;
ELSE
b_string := b_string || substr(n_string, to_number(n), 1) ||
substr(m_string, len - i + 1, 1);
z_count := 0;
is_zero := FALSE;
END IF;
END LOOP;
b_string := l_sign || b_string ;
RETURN b_string;
exception
--异常处理
WHEN OTHERS THEN
RETURN(SQLERRM);
END;
--创建存储过程：
create or replace procedure p
is
cursor c is
select * from emp2 for update;
begin
for v_temp in c loop
if(v_temp.deptno = 10) then
update emp2 set sal = sal+10 where current of c;
elsif(v_temp.deptno = 20) then
update emp2 set sal = sal+20 where current of c;
else
update emp2 set sal = sal+50 where current of c;
end if;
end loop;
commit;
end;
--执行：
exec p;
begin
p;
end;
--带参数的存储过程，in传入参数，默认为传入，out传出。
create or replace procedure p
(v_a in number,v_b number,v_ret out number,v_temp in out number)
is
begin
if(v_a >v_b) then
v_ret := v_a;
else
v_ret := v_b;
end if;
v_temp :=v_temp +1;
end;
declare
v_a number := 3;
v_b number := 4;
v_ret number;
v_temp number := 5;
begin
p(v_a,v_b,v_ret,v_temp);
dbms_output.put_line(v_ret);
dbms_output.put_line(v_temp);
end;
--游标
declare
cursor c is
select * from emp;
v_emp c%rowtype;
begin
open c;
loop
fetch c into v_emp;
exit when(c%notfound);
dbms_output.put_line(v_emp.ename);
end loop;
close c;
end;
declare
cursor c is
select * from emp;
v_emp emp%rowtype;
begin
open c;
fetch c into v_emp;
while(c%found) loop
dbms_output.put_line(v_emp.ename);
fetch c into v_emp;
--fetch c into v_emp; 导致第一条没有打印，最后一条打印2遍。
--dbms_output.put_line(v_emp.ename);
end loop;
close c;
end;
declare
cursor c is
select * from emp;
begin
for v_emp in c loop
dbms_output.put_line(v_emp.ename);
end loop;
end;
--带参数的游标
declare
cursor c(v_deptno emp.deptno%type,v_job emp.job%type)
is
select ename,sal from emp where deptno =v_deptno and job= v_job;
--v_temp c%rowtype;
begin
for v_temp in c(30,'CLERK') loop --for自动打开游标。
dbms_output.put_line(v_temp.ename);
end loop;
end;
--可更新的游标
declare
cursor c
is
select * from emp2 for update;
--v_temp c%rowtype;
begin
for v_temp in c loop
if(v_temp.sal <2000) then
update emp2 set sal = sal*2 where current of c;
elsif(v_temp.sal = 5000) then
delete from emp2 where current of c;
end if;
end loop;
commit;
end;
PLSql是SQL的补充，PL过程语言procedure language，SQL：Structured Query Language。
PLSql 带有分支、循环的语言，SQL没有分支、循环的语言。
set serveroutput on;
-- 简单的PL/SQL语句块
declare
v_name varchar2(20);
begin
v_name :='myname';
dbms_output.put_line(v_name);
end;
/
--语句块的组成
declare
v_num number := 0 ;
begin
v_num := 2/v_num;
dbms_output.put_line(v_num);
exception
when others then
dbms_output.put_line('error');
end;
/
--变量声明的规则
1、变量名不能够使用保留字，如from、select等
2、第一个字符必须是字母
3、变量名最多包含30个字符
4、不要与数据库的表或者列同名
5、每一行只能声明一个变量
--常用变量类型
1、binary_integer：整数，主要用来计数而不是用来表示字段类型
2、number：数字类型
3、char：定长字符串
4、varchar2：变长字符串
5、date：日期
6、long：长字符串，最长2GB
7、boolean：布尔类型，可以取值true、false和null值
--变量声明
declare
v_temp number(1);
v_count binary_integer :=0;
v_sal number(7,2):= 4000.00;
v_date date:= sysdate;
v_pi constant number(3,2) := 3.14; --constant相当java的final常量
v_valid boolean := false;
v_name varchar2(20) not null :='MyName';
begin
dbms_output.put_line('v_temp value:'|| v_temp);
end;
--变量声明，使用%type属性
declare
v_empno number(4);
v_empno2 emp.empno%type;
v_empno3 v_empno2%type;
begin
dbms_output.put_line('Test');
end;
--简单变量赋值
declare
v_name varchar2(20);
v_sal number(7,2);
v_sal2 number(7,2);
v_valid boolean :=false;
v_date date;
begin
va_name :='MyName';
v_sal :=23.77;
v_sal2 :=23.77;
v_valid:=(v_sal = v_sal2);
v_date:=to_date('1999-08-12 12:23:38','YYYY-MM-DD HH24:MI:SS');
end;
--Table变量类型，定义一种新的类型，是数组。
declare
type type_table_emp_empno is table of emp.empno%type index by binary_integer;
v_empno type_table_emp_empno;
begin
v_empnos(0) := 7369;
v_empnos(2) := 7839;
v_empnos(-1) := 9999;
dbms_output.put_line(v_empnos(-1));
end;
--Record变量类型,类似java的类的概念。
declare
type type_record_dept is record
(
deptno dept.deptno%type,
dname dept.dname%type,
loc dept.loc%type
);
v_tmp type_record_dept;
begin
v_tmp.deptno := 50;
v_tmp.dname := 'aaaa';
v_tmp.loc := 'bj';
dbms_output.put_line(v_temp.deptno||''||v_temp.dname);
end;
--使用%rowtype声明Record变量
declare
v_temp dept%rowtype;
begin
v_tmp.deptno := 50;
v_tmp.dname := 'aaaa';
v_tmp.loc := 'bj';
dbms_output.put_line(v_temp.deptno||''||v_temp.dname);
end;
--SQL语句的运用，返回数据有且只有一条记录。
declare
v_ename emp.ename%type;
v_sal emp.sal%type;
begin
select ename,sal into v_ename,v_sal from emp where empno = 7369;
dbms_output.put_line(v_ename||''||v_sal);
end;
declare
v_emp emp%rowtype;
begin
select * into v_emp from emp where empno = 7369;
dbms_output.put_line(v_emp.ename);
end;
declare
v_deptno dept.deptno%type := 50;
v_dname dept.dname%type := 'aaaa';
v_loc dept.loc%type := 'bj';
begin
insert into dept2 values (v_deptno,v_dname,v_loc);
commit;
end;
declare
v_deptno emp2.deptno%type := 10;
v_count number ;
begin
--update emp2 set sal = sal/2 where deptno = v_deptno;
--select deptno into v_deptno from emp2 where empno = 7369;
select count(*) into v_count from emp2;
dbms_output.put_line(sql%rowcount||'条记录被影响');
commit;
end;
DDL语句：
begin
execute immediate 'create table T(nnn varchar2(20) default ''aaa'')';
end;
--if语句：取出7369的薪水，如果<1200，则输出'low'，如果<2000则输出'middle'，否则'high'
declare
v_sal emp.sal%type;
begin
select sal into v_sal from emp where empno = 7369;
if(v_sal < 1200) then
dbms_output.put_line('low');
elsif(v_sal < 2000) then
dbms_output.put_line('middle');
else
dbms_output.put_line('high');
end if;
end;
--循环
declare
i binary_integer := 1;
begin
loop
dbms_output.put_line(i);
i := i+ 1;
exit when (i >= 11);
end loop;
end;
declare
j binary_integer := 1;
begin
while j< 11 loop
dbms_output.put_line(j);
j := j+ 1;
end loop;
end;
begin
for k in 1..10 loop
dbms_output.put_line(k);
end loop;
for k in reverse 1..10 loop
dbms_output.put_line(k);
end loop;
end;
--错误处理
declare
v_temp number(4);
begin
select empno into v_temp from emp where deptno = 10;
exception
when too_many_rows then
dbms_output.put_line('太多记录了');
when others then
dbms_output.put_line('error');
end;
declare
v_temp number(4);
begin
select empno into v_temp from emp where empno = 2222;
exception
when no_data_found then
dbms_output.put_line('没数据');
end;
create table errorlog
(
id number primary key,
errcode number,
errmsg varchar2(1024),
errdate date
);
create sequence seq_errorlog_id start with 1 increment by 1;
declare
v_deptno dept.deptno%type := 10;
v_errmsg varchar2(1024);
begin
delete from dept where deptno = v_deptno;
commit;
exception
when others then
rollback;
v_errcode := SQLCODE; --关键字，代表出错的代码。
v_errmsg := SQLERRM;
insert into errorlog values (seq_errorlog_id.nextval,v_errcode,v_errmsg,sysdate);
commit;
end;
构造数据库必须遵循一定的规则。在关系数据库中，这种规则就是范式。关系数据库中的关系必须满足一定的要求，即满足不同的范式。目前关系数据库有六种范式：第一范式（1NF）、第二范式（2NF）、第三范式（3NF）、第四范式（4NF）、第五范式（5NF）和第六范式（6NF）。满足最低要求的范式是第一范式（1NF）。在第一范式的基础上进一步满足更多要求的称为第二范式（2NF），其余范式以次类推。一般说来，数据库只需满足第三范式（3NF）就行了。
第一范式（1NF）：无重复的列。
所谓第一范式（1NF）是指数据库表的每一列都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。如果出现重复的属性，就可能需要定义一个新的实体，新的实体由重复的属性构成，新实体与原实体之间为一对多关系。在第一范式（1NF）中表的每一行只包含一个实例的信息。简而言之，第一范式就是无重复的列。
数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。
说明：在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。
第二范式（2NF）：属性完全依赖于主键[消除部分子函数依赖]。
第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被惟一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。例如员工信息表中加上了员工编号（emp_id）列，因为每个员工的员工编号是惟一的，因此每个员工可以被惟一区分。这个惟一属性列被称为主关键字或主键、主码。
第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是属性完全依赖于主键。
第三范式（3NF）：属性不依赖于其它非主属性[消除传递依赖]。
满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。例如，存在一个部门信息表，其中每个部门有部门编号（dept_id）、部门名称、部门简介等信息。那么在的员工信息表中列出部门编号后就不能再将部门名称、部门简介等与部门有关的信息再加入员工信息表中。如果不存在部门信息表，则根据第三范式（3NF）也应该构建它，否则就会有大量的数据冗余。简而言之，第三范式就是属性不依赖于其它非主属性。
所谓传递函数依赖，指的是如果存在"A → B → C"的决定关系，则C传递函数依赖于A。
序列：sequence，产生一个独一无二的序列，是oracle特有的。
create table article
(
id number,
title varchar2(1024),
cont long
);
insert into article values(seq.nextval,'a','b');
select * from user_sequences; --查询序列
create sequence seq; --创建序列seq对象
select seq.nextval from dual;
drop sequence seq;
视图：一个虚表，也是一个子查询，是存储在数据字典里的一条select语句。
视图：基于一个表或多个表或视图的逻辑表，本身不包含数据，通过它可以对表里面的数据进行查询和修改，视图基于的表称为基表。
视图的优点：
1、对数据库的访问，可以有选择性的选取数据库里的一部分信息，整张表的信息不对外开放。2.用户通过简单的查询可以从复杂查询中得到结果。
视图的缺点：
如果一个表的结构改了，相应的视图如果用到了该表的字段，也要进行修改，增加维护工作量。
简单视图：只从单表里获取数据，不包含函数和数据组，可以实现DML操作。
复杂视图：从多表获取数据，包含函数和数据组，不可以DML操作。
视图的创建：
CREATE [OR REPLACE] [FORCE|NOFORCE] VIEW view_name
[(alias[, alias]...)]
AS subquery
[WITH CHECK OPTION [CONSTRAINT constraint]]
[WITH READ ONLY]
其中：
OR REPLACE：若所创建的试图已经存在，ORACLE自动重建该视图；
FORCE：不管基表是否存在ORACLE都会自动创建该视图；
NOFORCE：只有基表都存在ORACLE才会创建该视图：
alias：为视图产生的列定义的别名；
subquery：一条完整的SELECT语句，可以在该语句中定义别名；
WITH CHECK OPTION ：插入或修改的数据行必须满足视图定义的约束；
WITH READ ONLY ：该视图上不能进行任何DML操作。
例如：
CREATE OR REPLACE VIEW dept_sum_vw
(name,minsal,maxsal,avgsal)
AS SELECT d.dname,min(e.sal),max(e.sal),avg(e.sal)
FROM emp e,dept d
WHERE e.deptno=d.deptno
GROUP BY d.dname;
查询视图：select * from user_views;
修改视图：通过OR REPLACE 重新创建同名视图即可。
删除视图：DROP VIEW VIEW_NAME;
视图的定义原则：
1.视图的查询可以使用复杂的SELECT语法，包括连接/分组查询和子查询；
2.在没有WITH CHECK OPTION和 READ ONLY 的情况下，查询中不能使用ORDER BY 子句；
3.如果没有为CHECK OPTION约束命名，系统会自动为之命名，形式为SYS_Cn;
4.OR REPLACE选项可以不删除原视图便可更改其定义并重建，或重新授予对象权限。
视图上的DML操作，应遵循的原则：
1.简单视图可以执行DML操作；
2.在视图包含GROUP 函数，GROUP BY子句，DISTINCT关键字时不能删除数据行；
3.在视图不出现下列情况时可通过视图修改基表数据或插入数据：
a.视图中包含GROUP 函数，GROUP BY子句，DISTINCT关键字；
b.使用表达式定义的列；
c .ROWNUM伪列。
d.基表中未在视图中选择的其他列定义为非空且无默认值。
WITH CHECK OPTION 子句限定：
通过视图执行的INSERTS和UPDATES操作不能创建该视图检索不到的数据行，因为它会对插入或修改的数据行执行完整性约束和数据有效性检查。
例如：
CREATE OR REPLACE VIEW vw_emp20
AS SELECT * FROM emp
WHERE deptno=20
WITH CHECK OPTION constraint vw_emp20_ck;
视图 已建立。
查询结果：
SELECT empno,ename,job FROM vw_emp20;
EMPNO ENAME JOB
--------------------- -------------- -------------
7369 SMITH CLERK
7566 JONES MANAGER
7902 FORD ANALYST
修改：
UPDATE vw_emp20
SET deptno=20
WHERE empno=7902;
将产生错误：
UPDATE vw_emp20
*
ERROR 位于第一行：
ORA-01402：视图WITH CHECK OPTION 违反WHERE 子句
索引：--像字典里面的索引。
表建立索引后在插入数据时，一要把数据写入表里，二要把该数据记入索引里面，因此查询效率高、但插入效率低。
create index idx_stu_email on stu(email,class); --组合索引，查询效率高。
drop index idx_stu_email;
select * from user_indexes; -- 查询索引
Oracle的数据库对象分为五种：表，视图，序列，索引和同义词。
select * from user_tables -- 当前用户下有多少张表
select * from user_views -- 当前用户下有多少张视图
select * from user_sequences; --查询序列
select * from user_indexes; -- 查询索引
select * from user_constraints -- 当前用户下有多少约束
select * from dictionary --数据字典表的表
DDL（data definition language）：DDL比DML要多，主要的命令有CREATE、ALTER、DROP等，DDL主要是用在定义或改变表（TABLE）的结构，数据类型，表之间的链接和约束等初始化工作上，他们大多在建立表时使用。
数据类型：VARCHAR2(50)最大4K(4096字节)、CHAR(1)最大2k、NUMBER(10,6)、NUMBER(6)、DATE、
LONG 变长字符串，最大长度达2G。
约束条件有5个：非空、唯一、主键、外键、check。
create table stu
(
id number(6), --primary key
name varchar2(20) constraint stu_name_nn not null, --stu_name_nn别名
sex number(1),
age number(3),
sdate date,
grade number(2) default 1,
class number(4), --references class(id)
email varchar2(50),
--email varchar2(50) unique --字段级约束，不能有重复值
constraint stu_name_email_uni unique(name,email), --表级约束
constraint stu_id_pk primary key(id), --表级约束
constraint stu_class_fk foreign key(class) references class(id) --被参考字段必须是主键
);
create table class
(
id number(4) primary key,
name varchar2(20) not null
)
alter table stu add(addr varchar2(100)); --对已存在的表新增字段
alter table stu modify(addr varchar2(150)); --对字段修改
alter table stu drop (addr); --删除一个字段
alter table stu drop constraint stu_class_fk;
delete from class;
drop table class;
SQL语言共分为四大类：数据查询语言DQL，数据操纵语言DML，数据定义语言DDL，数据控制语言DCL。
DML（data manipulation language）：它们是SELECT、UPDATE、INSERT、DELETE，就象它的名字一样，这4条命令是用来对数据库里的数据进行操作的语言。
conn sys/sys as sysdba;
drop user pcisv6 cascade;
exp --备份scott用户下的表
--创建用户,identified为认证相当是密码，quota配额就是分配空间。
create user pcisv6 identified by 11 default tablespace core6 quota 10M on corev6
grant create session,create table,create view to pcisv6; --授权，session是用于登录的
imp --导入scott用户下的表
SELECT：
select rownum r,ename from emp; --rownum行数，目前只能使用<、<=, 而没有直接>、=的写法。
select ename, sal --求薪水最高的前5人
from (select ename, sal from emp order by sal desc)
where rownum <= 5;
--求薪水最高的前6到10人
select ename,sal,rownum r from emp order by sal desc; --r 排序混乱
select ename,sal,rownum r from (select ename,sal from emp order by sal desc); --此时r序号按新表排序
select ename, sal -- 此处为结果
from (select ename, sal, rownum r
from (select ename, sal from emp order by sal desc))
where r >= 6
and r <= 10;
INSERT：
insert into dept values(50,'game','bj'); --整条记录
rollback;
create table dept2 as selet * from emp; --创建dept2表
insert into dept2(deptno,dname) values(60,'game2'); --有选择的字段插入
insert into dept2 select * from dept; --插入一个表, 2个表结构一样
UPDATE：
update emp2 set sal=sal*12,ename=ename||'-' where deptno=10;
DELETE：
delete from dept2 where deptno<25;
rollback;
TRANSACTION：
transaction 起始一条dml语句，在commit、rollback时完成。
transaction 在执行dml后，在其后有执行了ddl、dcl时，事务自动提交。
在正常退出exit时，事务自动提交。
在非正常退出时，事务回滚。
------------------------------------------------------------
例子：
有3个表S，C，SC
S（SNO，SNAME）代表（学号，姓名）
C（CNO，CNAME，CTEACHER）代表（课号，课名，教师）
SC（SNO，CNO，SCGRADE）代表（学号，课号成绩）
问题：
1，找出没选过“黎明”老师的所有学生姓名。
2，列出2门以上（含2门）不及格学生姓名及平均成绩。
3，即学过1号课程有学过2号课所有学生的姓名。
请用标准SQL语言写出答案，方言也行（请说明是使用什么方言）。
1.
select sname froms
join sc on (s.sno = sc.sno)
join c(c.cno = sc.cno)
where c.cteacher <> 'liming';
2.
select sname
where sno in (select sno
from sc
where scgrade < 60
group by sno
having count(*) >= 2);
3.
select sname
where sno in (select sno
from sc
where cno = 1
and sno in (select sno from sc where cno = 2));
错误原因：在Oracle新建了一个表，名为“QueryHistory",用来保存用户的查询记录，这时，再用"Select * from QueryHistory"来查询,报 "ORA-00942: 表或视图不存在 "。
错误分析：利用Google搜索找到了原因，
oracle是大小写敏感的，如果定义表名称或列名称的时候没有用引号引起来的话 oracle会把他们全部转换为大写，这时就会出现错误了。
解决方法：将语句改为"Select * from "QueryHistory" 或是语句全部大写。
PCIS[2010-07-08 18:08:02,531]>> ERROR>> [BizControllerImpl异常堆栈{事务ID/用户代码}:[1278583679437325]/[00000210]:com.fwk.service.BusinessServiceException: com.fwk.dao.DaoException: 保存保单， saveOrUpdatePolicy()时出错; nested exception is org.springframework.dao.DataIntegrityViolationException: Could not execute JDBC batch update; nested exception is org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
at com.pcis.policy.dm.PolicyDAO.saveOrUpdatePolicy(PolicyDAO.java:193)
at com.pcis.policy.app.newbusiness.service.PolicyAppService.savePolicy(PolicyAppService.java:343)
at com.pcis.policy.app.underwrite.bm.UnderwriteBM.submitUnderwrite(UnderwriteBM.java:139)
at com.pcis.policy.app.underwrite.action.UnderwriteBizAction.submitUnderwrite(UnderwriteBizAction.java:548)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
...
Caused by: org.springframework.dao.DataIntegrityViolationException: Could not execute JDBC batch update; nested exception is org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update
at org.springframework.orm.hibernate3.SessionFactoryUtils.convertHibernateAccessException(SessionFactoryUtils.java:624)
at org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:412)
at org.springframework.orm.hibernate3.HibernateTemplate.execute(HibernateTemplate.java:379)
at org.springframework.orm.hibernate3.HibernateTemplate.flush(HibernateTemplate.java:841)
at com.fwk.dao.BaseDao.flush(Unknown Source)
at com.pcis.policy.dm.PolicyDAO.saveOrUpdatePolicy(PolicyDAO.java:174)
... 80 more
Caused by: java.sql.BatchUpdateException: ORA-00001: unique constraint (PCISV6_TS.UI_PLY_CVRG) violated
at oracle.jdbc.driver.DatabaseError.throwBatchUpdateException(DatabaseError.java:602)
at oracle.jdbc.driver.OraclePreparedStatement.executeBatch(OraclePreparedStatement.java:9350)
at oracle.jdbc.driver.OracleStatementWrapper.executeBatch(OracleStatementWrapper.java:210)
at org.apache.commons.dbcp.DelegatingStatement.executeBatch(DelegatingStatement.java:297)
at org.hibernate.jdbc.BatchingBatcher.doExecuteBatch(BatchingBatcher.java:48)
at org.hibernate.jdbc.AbstractBatcher.executeBatch(AbstractBatcher.java:246)
... 90 more
分析及解决：
在页面保存的时候，后台提示是违反唯一索引，通过UI_PLY_CVRG 查询相应的表，
select * from user_indexes where index_name='UI_PLY_CVRG'
该表是WEB_PLY_CVRG ，而该表的唯一索引UI_PLY_CVRG 是由该表的3个字段组成 C_PLY_NO、N_EDR_PRJ_NO、 N_SEQ_NO，然后看下页面发现是N_SEQ_NO有4个重复，删除多余的记录即可保存成功。
在项目中经常需要处理一些输入字符，往往我们也需要对其进行校验，而使用正则表达式是一个很好的处理方法。下面介绍一款处理正则表达式的软件 Match Tracer v2.0，MTracer最有用的特性是中文的正则式分析树。
下载地址：http://www.52z.com/down/30160.Html
官网：http://www.regexlab.com/zh/mtracer/
在平时的项目中，经常需要开一下别人写的源码，而此时别人提供的往往是jar文件，根本看不了，很是不爽。最近很偶然的看见一个同事在eclipse下查看class文件，很是兴奋。下面讲下是如何安装下插件的。
打开class文件，我目前了解的有2种类型的软件：
一、 在eclipse外部打开jar文件。
Java Decompiler.exe，主页JD home page: http://java.decompiler.free.fr ，该软件可以打开整个jar包，功能很强大。
二、 在eclipse内部打开jar文件。
net.sf.jadclipse_3.3.0.jar、jad158g.win.zip，需要这两个文件。
准备工作：
1、下载jad.exe文件： http://www.varaneckas.com/jad
2、下载jadeclipse插件： http://sourceforge.net/projects/jadclipse/files/
安装如下：
1、将jadeclipse插件net.sf.jadclipse_3.3.0.jar 拷贝到myeclipse安装目录E:\MyEclipse 6.0\eclipse\myplugins\jad\eclipse\plugins目录下，并在目录E:\MyEclipse 6.0\eclipse\links下新建文件jad.link，内容如下path=E:\\MyEclipse 6.0\\eclipse\\myplugins\\jad\\
2、将jad.exe解压到指定目录。如:D:\tools
3、在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Path to Decompiler。（设置jad的绝对路径，如 D:\tools\jad\jad.exe)。Use Eclipse code formatter(overrides Jad formatting instructions)选项打勾，与格式化出来的代码样式一致。
4、在eclipse窗口下，点击Window > Preferences > Java > JadClipse > Misc，将Convert Unicode strings into ANSI strings选项打勾，避免反编译后可能出现的中文乱码。
5、重新启动myeclipse，eclipse自动将JadClipse Class File Viewer设置成class文件的缺省打开方式。如果没有默认，可以在Eclipse的Window > Preferences >General >Editors> File Associations中修改“*.class”默认关联的编辑器为“JadClipse Class File Viewer”。设置完成后，双击*.class文件，eclipse将自动反编译。
select e1.ename,e2.ename from emp e1 join emp e2 on (e1.mgr=e2.empno); --自连接，从e2中取出e1的经理人。
select ename,dname from emp e left join dept d on (e.deptno=d.deptno); --左外连接
select ename,dname from emp e right outer join dept d on (e.deptno=d.deptno); --右外连接
select ename,dname from emp e full join dept d on (e.deptno=d.deptno); --全连接
--求部门中哪些人的薪水最高
select ename,sal from emp
join (select max(sal) max_sal,deptno from emp group by deptno) t
on (emp.sal = t.max_sal and emp.deptno = t.deptno);
--求部门平均薪水的等级
select deptno,avg_sal,grade from
(select deptno,avg(sal) avg_sal from emp group by deptno) t
join salgrade s on (t.avg_sal between s.losal and s.hisal);
--求部门平均的薪水等级
select avg(grade) from
(select deptno,ename,grade from emp join salgrade s on (emp.sal between s.losal and s.hisal )) t
group by deptno;
--雇员中有哪些人是经理人
select ename from emp where empno in (select distinct mgr from emp);
--不准用组函数，求薪水的最高值。采用的是自连接。
select distinct sal from emp where sal not in
(select distinct e1.sal from emp e1 join emp e2 on (e1.sal < e2.sal));
--求平均薪水最高的部门的部门编号。嵌套的组函数。
select deptno,avg_sal from
(select avg(sal) avg_sal,deptno from emp group by deptno)
where avg_sal =
(select max(avg(sal)),deptno from emp group by deptno;
--求平均薪水的等级最低的部门的部门名称。
select dname,t1.deptno,grade,avg_sal from
(
select deptno,grade,avg_sal from
(select deptno,avg(sal) avg_sal from emp group by deptno) t
join salgrade s on (t.avg_sal between s.losal and s.hisal)
)
t1
join dept on (t1.deptno = dept.deptno)
)
where t1.grade =
(
select min(grade) from
(select deptno,grade,avg_sal from
(select deptno,grade,avg(sal) avg_sal from emp group by deptno) t
join salgrade s on (t.avg_sal between s.losal and s.hisal)
)
)
--求平均薪水的等级最低的部门的部门名称。采用视图。
conn sys/sys as sysdba;
grant create table,create view to scott;
create view v$_dept_avg_sal_info as
select deptno,grade,avg_sal from
(select deptno,grade,avg(sal) avg_sal from emp group by deptno) t
join salgrade s on (t.avg_sal between s.losal and s.hisal);
select dname,t1.deptno,grade,avg_sal from
v$_dept_avg_sal_info t1
join dept on (t1.deptno = dept.deptno)
)
where t1.grade =
(
select min(grade) from v$_dept_avg_sal_info
)
-- 比普通员工的最高薪水还要高的经理人名称。
select ename from emp
where empno in (select distinct mgr from emp where mgr is not null)
and sal >
(
select max(sal) from emp where empno not in
(select distinct mgr from emp where mgr is not null)
)
--1992年sql标准，连接条件和过滤条件写在一起。
select ename,dname,grade
from emp e,dept d,salgrade s
where e.deptno = d.deptno and e.sal between s.losal and s.hisal and job<>'CLERK';
--1999年sql标准,连接条件和过滤条件分开
select ename,dname,grade
from emp e join dept d on (e.deptno = d.deptno)
join salgrade s on (e.sal between s.losal and s.hisal)
where ename not like '_A%';
increase the size of the pool and retry..] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>> WARN>> [SQL Error: 0, SQLState: null] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>>ERROR>> [Cannot obtain connection: driverURL = jdbc:weblogic:pool:pcis_ts, props = {EmulateTwoPhaseCommit=false, connectionPoolID=pcis_ts, jdbcTxDataSource=true, LoggingLastResource=false, dataSourceName=pcis_ts}] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>> WARN>> [SQL Error: 0, SQLState: null] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>>ERROR>> [weblogic.common.resourcepool.ResourceLimitException: No resources currently available in pool pcis_ts to allocate to applications, please increase the size of the pool and retry..] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>> WARN>> [SQL Error: 0, SQLState: null] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
PCIS[2010-07-01 12:51:47,456]>>ERROR>> [Cannot obtain connection: driverURL = jdbc:weblogic:pool:pcis_ts, props = {EmulateTwoPhaseCommit=false, connectionPoolID=pcis_ts, jdbcTxDataSource=true, LoggingLastResource=false, dataSourceName=pcis_ts}] - [org.hibernate.util.JDBCExceptionReporter] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kerne
l.Default (self-tuning)']
[com.pcis.premium.service.PremiumService] -950125750 [[ACTIVE] ExecuteThread: '3' for queue: 'weblogic.kernel.Default (self-tuning)']
org.springframework.jdbc.UncategorizedSQLException: Hibernate operation: Cannot open connection; uncategorized SQLException for SQL [???]; SQL state [null]; error code [0]; weblogic.common.resourcepool.ResourceLimitException: No resources currently available in pool pcis_ts to allocate to applications, please increase the size of the pool and retry..; nested exception is weblogic.jdbc.extensions.PoolLimitSQLException: weblogic.common.resourcepool.ResourceLimitException: No resources currently available in pool pcis_ts to allocate to applications, please increase the size of the pool and retry..
at org.springframework.jdbc.support.SQLStateSQLExceptionTranslator.translate(SQLStateSQLExceptionTranslator.java:124)
at org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator.translate(SQLErrorCodeSQLExceptionTranslator.java:322)
at org.springframework.orm.hibernate3.HibernateAccessor.convertJdbcAccessException(HibernateAccessor.java:424)
at org.springframework.orm.hibernate3.HibernateAccessor.convertHibernateAccessException(HibernateAccessor.java:410)
at org.springframework.orm.hibernate3.HibernateTemplate.execute(HibernateTemplate.java:379)
at org.springframework.orm.hibernate3.HibernateTemplate.find(HibernateTemplate.java:872)
at org.springframework.orm.hibernate3.HibernateTemplate.find(HibernateTemplate.java:868)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:727)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:820)
at weblogic.servlet.internal.StubSecurityHelper$ServletServiceAction.run(StubSecurityHelper.java:226)
at weblogic.servlet.internal.StubSecurityHelper.invokeServlet(StubSecurityHelper.java:124)
at weblogic.servlet.internal.ServletStubImpl.execute(ServletStubImpl.java:283)
at weblogic.servlet.internal.TailFilter.doFilter(TailFilter.java:26)
at weblogic.servlet.internal.FilterChainImpl.doFilter(FilterChainImpl.java:42)
at org.springframework.security.util.FilterChainProxy.doFilter(FilterChainProxy.java:168)
at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:183)
at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:138)
at weblogic.servlet.internal.FilterChainImpl.doFilter(FilterChainImpl.java:42)
at org.jasig.cas.client.session.SingleSignOutFilter.doFilter(SingleSignOutFilter.java:99)
at weblogic.servlet.internal.FilterChainImpl.doFilter(FilterChainImpl.java:42)
at com.isoftstone.iaeap.web.filter.SetCharacterEncodingFilter.doFilter(Unknown Source)
at weblogic.servlet.internal.FilterChainImpl.doFilter(FilterChainImpl.java:42)
at weblogic.servlet.internal.WebAppServletContext$ServletInvocationAction.run(WebAppServletContext.java:3393)
at weblogic.security.acl.internal.AuthenticatedSubject.doAs(AuthenticatedSubject.java:321)
at weblogic.security.service.SecurityManager.runAs(Unknown Source)
at weblogic.servlet.internal.WebAppServletContext.securedExecute(WebAppServletContext.java:2140)
at weblogic.servlet.internal.WebAppServletContext.execute(WebAppServletContext.java:2046)
at weblogic.servlet.internal.ServletRequestImpl.run(ServletRequestImpl.java:1366)
at weblogic.work.ExecuteThread.execute(ExecuteThread.java:200)
at weblogic.work.ExecuteThread.run(ExecuteThread.java:172)
Caused by: weblogic.jdbc.extensions.PoolLimitSQLException: weblogic.common.resourcepool.ResourceLimitException: No resources currently available in pool pcis_ts to allocate to applications, please increase the size of the pool and retry..
at weblogic.jdbc.common.internal.JDBCUtil.wrapAndThrowResourceException(JDBCUtil.java:242)
at weblogic.jdbc.pool.Driver.connect(Driver.java:160)
at weblogic.jdbc.jts.Driver.getNonTxConnection(Driver.java:642)
at weblogic.jdbc.jts.Driver.connect(Driver.java:124)
at weblogic.jdbc.common.internal.RmiDataSource.getConnection(RmiDataSource.java:339)
at org.springframework.orm.hibernate3.LocalDataSourceConnectionProvider.getConnection(LocalDataSourceConnectionProvider.java:82)
at org.hibernate.jdbc.ConnectionManager.openConnection(ConnectionManager.java:423)
at org.hibernate.jdbc.ConnectionManager.getConnection(ConnectionManager.java:144)
at org.hibernate.jdbc.AbstractBatcher.prepareQueryStatement(AbstractBatcher.java:139)
at org.hibernate.loader.Loader.prepareQueryStatement(Loader.java:1547)
at org.hibernate.loader.Loader.doQuery(Loader.java:673)
at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:236)
at org.hibernate.loader.Loader.doList(Loader.java:2213)
at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2104)
at org.hibernate.loader.Loader.list(Loader.java:2099)
at org.hibernate.loader.hql.QueryLoader.list(QueryLoader.java:378)
at org.hibernate.hql.ast.QueryTranslatorImpl.list(QueryTranslatorImpl.java:338)
at org.hibernate.engine.query.HQLQueryPlan.performList(HQLQueryPlan.java:172)
at org.hibernate.impl.SessionImpl.list(SessionImpl.java:1121)
at org.hibernate.impl.QueryImpl.list(QueryImpl.java:79)
at org.springframework.orm.hibernate3.HibernateTemplate$30.doInHibernate(HibernateTemplate.java:881)
at org.springframework.orm.hibernate3.HibernateTemplate.execute(HibernateTemplate.java:374)
... 31 more
原因：主要是weblogic的连接池已满，需要重新设置或者重启weblogic的AdminServer服务器进行释放连接。
操作：进入weblogic控制台，选择：域-->Services-->JDBC-->Data Source-->点击control-->选中AdminServer，对其重启即可。
select chr(65) from dual;
select ascii('A') from dual; --求编码
select ename from emp where lower(ename) like '_a%' -- upper大写
select round(23.652,2) from dual; -- 四舍五入 23.65,round(23.652)为24
select substr(ename,1,3) from emp; --从第一个开始，总接取3个。
select ename,sal,deptno from emp where length(sal)>3;
select to_char(sal,'$99,999.9999') from emp; --'L00000.0000'千位不够补0
select to_char(sysdate,'YYYY-MM-DD HH24:MI:SS') from dual;
select ename,hiredate from emp where hiredate>to_date('1981-2-20 12:34:56','YYYY-MM-DD HH24:MI:SS');
select sal from emp where sal>to_number('$1,250.00','$9,999.99');
select ename,sal*12 + nvl(comm,0) from emp; --对空值处理
组函数：
select max(sal) from emp;
select min(sal) from emp;
select avg(sal) from emp;
select sum(sal) from emp;
select count(*) from emp; -- *求出总记录数, count(comm)求出该列不为空的值。
select deptno,job,max(sal) from emp group by deptno,job; --按照条件组合分组
select ename from emp where sal =(select max(sal) from emp); --子查询
update Web_Bas_Edr_Rsn set c_rsn_txt=REPLACE(c_rsn_txt,'天津','北京') where c_rsn_txt like '%天津%' --批量替换
-- having对分组进行限制，where对单行限制
select avg(sal) from emp where sal>1000 group by deptno having avg(sal) >1500 order by avg(sal) desc;
sqlplus sys/sys as sysdba;
alert user scott account unlock;
desc emp;
select ename,sal*12 from emp;
select sysdate from dual; --dual为空表
select ename,sal*12 annual_sal from emp; --别名
--数值+null 为null
select ename||sal from emp; --拼串
select ename||'aaa''bbb' from emp; --含'的拼串,''替换为'
select distinct deptno,job from emp; --去掉2个字段值的组合
select * from emp where deptno=10 and ename='CLARK';
select ename,sal from emp where sal>1500;
select ename,sal from emp where deptno<>10;
select ename,sal from emp where sal between 800 and 1500; -- sal>=800 and sal<=1500
select ename,sal,comm from emp where comm is null; --is not null
select ename,sal,comm from emp where sal in (800,1500); -- not in (800,1500)
select ename from emp where ename like '_A%' -- %为0个或多个，-为1个
select ename from emp where ename like '%\%%' -- 名字含有%，需要\为转义字符处理
select ename from emp where ename like '%$%%' escape '$' -- 可以使用$作为转义字符
select ename,sal,deptno from emp order by deptno asc,ename desc; -- 升序asc，降序 desc
今天想把tomcat下的程序迁移到weblogic92上，可是程序在发布到weblogic92时报下面的异常：
Home > Summary of Deployments > Summary of JDBC Data Sources > myDataSource > Summary of Deployments :
Messages
An error occurred during activation of changes, please see the log for details.
[HTTP:101064][WebAppModule(nonvhl:WebRoot)] Error parsing descriptor in Web appplication "E:\workspace\nonvhl_policy_TS\WebRoot"
weblogic.application.ModuleException: VALIDATION PROBLEMS WERE FOUND E:\workspace\nonvhl_policy_TS\WebRoot\WEB-INF\web.xml:133:5:133:5: problem: cvc-complex
-type.2.4a: Expected elements 'servlet-class@http://java.sun.com/xml/ns/j2ee jsp-file@http://java.sun.com/xml/ns/j2ee' instead of 'display-
name@http://java.sun.com/xml/ns/j2ee' here in element servlet@http://java.sun.com/xml/ns/j2ee: at weblogic.servlet.internal.WebAppModule.loadDescriptor
(WebAppModule.java:784) at weblogic.servlet.internal.WebAppModule.prepare(WebAppModule.java:275) at
weblogic.application.internal.flow.ScopedModuleDriver.prepare(ScopedModuleDriver.java:176) at
weblogic.application.internal.flow.ModuleListenerInvoker.prepare(ModuleListenerInvoker.java:93) at
weblogic.application.internal.flow.DeploymentCallbackFlow$1.next(DeploymentCallbackFlow.java:360) at weblogic.application.utils.StateMachineDriver.nextState
(StateMachineDriver.java:26) at weblogic.application.internal.flow.DeploymentCallbackFlow.prepare(DeploymentCallbackFlow.java:56) at
weblogic.application.internal.flow.DeploymentCallbackFlow.prepare(DeploymentCallbackFlow.java:46) at weblogic.application.internal.BaseDeployment$1.next
(BaseDeployment.java:621) at weblogic.application.utils.StateMachineDriver.nextState(StateMachineDriver.java:26) at
weblogic.application.internal.BaseDeployment.prepare(BaseDeployment.java:208) at weblogic.application.internal.DeploymentStateChecker.prepare
(DeploymentStateChecker.java:147) at weblogic.deploy.internal.targetserver.AppContainerInvoker.prepare(AppContainerInvoker.java:61) at
weblogic.deploy.internal.targetserver.operations.ActivateOperation.createAndPrepareContainer(ActivateOperation.java:189) at
weblogic.deploy.internal.targetserver.operations.ActivateOperation.doPrepare(ActivateOperation.java:87) at
weblogic.deploy.internal.targetserver.operations.AbstractOperation.prepare(AbstractOperation.java:217) at
weblogic.deploy.internal.targetserver.DeploymentManager.handleDeploymentPrepare(DeploymentManager.java:718) at
weblogic.deploy.internal.targetserver.DeploymentManager.prepareDeploymentList(DeploymentManager.java:1185) at
weblogic.deploy.internal.targetserver.DeploymentManager.handlePrepare(DeploymentManager.java:247) at
原因：经过分析是web.xml配置的问题，有些servlet上面配置了'display-name'，这个weblogic是不支持的。
解决：在web.xml中把'display-name'删除掉，工程就可以在weblogic下成功发布。
在配置weblogic的数据源时，提示一下信息：
Home > Summary of Deployments > Summary of JDBC Data Sources:
Messages
An error occurred during activation of changes, please see the log for details.
weblogic.application.ModuleException:
weblogic.common.ResourceException: Could not create pool connection. The DBMS driver exception was: Io 异常: The Network Adapter could not establish the connection
解决：主要是我在配置数据源时没有把Oracle的服务启动造成的。
1、今天到客户现场，输入系统地址，发现登录不上，后来查了下是DNS域名的问题。
原因：客户的机器域名解析地址是：google的DNS，首选DNS服务器和备用DNS服务器分别设置为 8.8.8.8和8.8.4.4。由于我们是在本地局域网设置的域名，公网的域名解析器不识别，导致登录不了系统。
解决：设置自动获取DNS。
2、登录系统后，打来相关的页面，又出现页面加载失败
原因：主要是域名解析后，对相应的ip地址有限制。
解决：把域名、ip地址都加入为可信任站点，调低安全级别即可。
1、声明式事务配置
* 配置SessionFactory
* 配置事务管理器
* 事务的传播特性
* 那些类那些方法使用事务
2、编写业务逻辑方法
* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是
Hibernate Session的轻量级封装
* 默认情况下运行期异常才会回滚（包括继承了RuntimeException子类），普通异常是不会滚的
* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层（struts）处理
* 关于事务边界的设置，通常设置到业务层，不要添加到Dao上
3、了解事务的几种传播特性
1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,
则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
4、Spring事务的隔离级别
1. ISOLATION_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
另外四个与JDBC的隔离级别相对应
2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
这种隔离级别会产生脏读，不可重复读和幻像读。
3. ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据
4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
除了防止脏读，不可重复读外，还避免了幻像读。
对于出现的乱码有2种解决方法：
1、在JS中，window.showModalDialog传递对象。
  function tool_uploadFile(clmNo,billType,maxFileNum,fileType,singleLimit,totalLimit)  {//解决乱码的问题，增加变量paramObj。10.06.01
  var paramObj = {
 "clmNo" : clmNo,
"billType" : billType,
"maxFileNum" : maxFileNum,
"fileType" : fileType,
"singleLimit" : singleLimit,
"totalLimit" : totalLimit
 };
var r = window.showModalDialog(global.WEB_APP_NAME+"/core/jsp/common/uploadFile.jsp",paramObj,"dialogHeight:610px;dialogWidth:530px;center:1;help: 0; status: 0;");
return r;
 }
在uploadFile.jsp中，通过js获得参数。
 <script>
var paramObj = window.dialogArguments;
var clmNo = paramObj.clmNo;
var billType = paramObj.billType;
var maxFileNum = paramObj.maxFileNum;
var fileType = paramObj.fileType;
var singleLimit = paramObj.singleLimit;
var totalLimit = paramObj.totalLimit;
tool.loadApplet('<%=agentIp%>','<%=agentPort%>','<%=orgId%>',clmNo,billType,maxFileNum,fileType,singleLimit,totalLimit);
</script>
2、在JS中，window.showModalDialog通过？传递参数。
function tool_uploadFile(clmNo,billType,maxFileNum,fileType,singleLimit,totalLimit) {
billType = encodeURIComponent(billType);
var r = window.showModalDialog(global.WEB_APP_NAME+"/core/jsp/common/uploadFile.jsp?clmNo="+clmNo+"&billType="+billType+"&maxFileNum="+maxFileNum+"&fileType="+fileType+"&singleLimit="+singleLimit+"&totalLimit="+totalLimit,"","dialogHeight:610px;dialogWidth:530px;center:1;help: 0; status: 0;");
return r;
}
在uploadFile.jsp中，通过java解析获得参数。
String paramStr = request.getQueryString();
if (paramStr == null || paramStr.equals("")) {
return;
}
HashMap<String, ArrayList<String>> parameter = new HashMap<String, ArrayList<String>>();
String[] paramArr = paramStr.split("&+");
String[] arr = null;
for (int i = 0; i < paramArr.length; i++) {
arr = paramArr[i].split("=", 2);
ArrayList<String> lst = parameter.get(arr[0]);
if (lst == null) {
lst = new ArrayList<String>();
parameter.put(arr[0], lst);
}
if (arr.length < 2) {
lst.add("");
} else {
lst.add(URLDecoder.decode(arr[1], "UTF-8"));
}
}
ArrayList<String> paramlst = parameter.get("billType");
String billType = paramlst.get(0);
以上两种方法，对应用服务器设置的url编码没有关系。
还有一种方法，就是转换成GB2312，不过此种方法跟服务器编码设置还有关系，有时还会出现乱码：
billType = new String(billType.getBytes(" ISO-8859-1"),"GB2312");
一：WebLogic配置问题：
由于WebLogic的配置问题，我们的系统运行出现了失败情况。原因是为WebLogic分配的内存太少了。通过修改commom\bin\commEnv.cmd文件来增加内存分配。
修改的部分如下：
:bea
if "%PRODUCTION_MODE%" == "true" goto bea_prod_mode
set JAVA_VM=-jrockit
set MEM_ARGS=-Xms768m -Xmx1024m
set JAVA_OPTIONS=%JAVA_OPTIONS% -Xverify:none
goto continue
:bea_prod_mode
set JAVA_VM=-jrockit
set MEM_ARGS=-Xms768m -Xmx1024m //原来是128M~256M，太小了，数据太大
goto continue
结果修改后，没有效果。还是有失败的情况。
发现，原来，在：bea下面还有一段配置信息如下：
:sun
if "%PRODUCTION_MODE%" == "true" goto sun_prod_mode
set JAVA_VM=-client
set MEM_ARGS=-Xms768m -Xmx1024m -XX:MaxPermSize=256m
set JAVA_OPTIONS=%JAVA_OPTIONS% -Xverify:none
goto continue
:sun_prod_mode
set JAVA_VM=-server
set MEM_ARGS=-Xms768m -Xmx1024m -XX:MaxPermSize=256m
goto continue
将这里的内存分配修改后见效。
原因是，上面对第一段代码是为bea自己的JVM设置的，下面的是为Sun的设置的。而WebLogic默认的是Sun的，所以出了毛病。
二,domain中的相关配置:
1,修改bea\user_projects\domains\base_domain\bin\setDomainEnv.cmd文件.
2,修改如下几个位置:以下蓝色部分是需修改的内存大小
set MEM_ARGS=-Xms256m -Xmx512m @最主要将这两个值改大,这是此域启动后,虚拟机可使用的内存
if "%JAVA_VENDOR%"=="Sun" ( @使用sun服务器开发模式下的JVM配置
if "%PRODUCTION_MODE%"=="" (
set MEM_DEV_ARGS=-XX:CompileThreshold=8000 -XX ermSize=48m
)
)
if "%JAVA_VENDOR%"=="Sun" ( @使用sun服务器生产模式下的JVM配置
set MEM_ARGS=%MEM_ARGS% %MEM_DEV_ARGS% -XX:MaxPermSize=128m
)
if "%JAVA_VENDOR%"=="HP" ( @使用hp服务器生产模式下的JVM配置
set MEM_ARGS=%MEM_ARGS% -XX:MaxPermSize=128m
)
weblogic在运行一段时间后，出现以下的错误：
<2010-5-28 上午11时46分17秒 CST> <Error> <HTTP> <BEA-101017> <[weblogic.servlet.internal.WebAppServletContext@
1b0d235 - appName: 'rules', name: 'rules', context-path: '/rules'] Root cause of ServletException.
java.lang.OutOfMemoryError: PermGen space
>
解决方法：
重新启动weblogic，系统恢复正常。
这里以tomcat环境为例，其它WEB服务器如jboss,weblogic等是同一个道理。
一、java.lang.OutOfMemoryError: PermGen space PermGen space的全称是Permanent Generation space,是指内存的永久保存区域, 这块内存主要是被JVM存放Class和Meta信息的,Class在被Loader时就会被放到PermGen space中, 它和存放类实例(Instance)的Heap区域不同,GC(Garbage Collection)不会在主程序运行期对 PermGen space进行清理，所以如果你的应用中有很多CLASS的话,就很可能出现PermGen space错误, 这种错误常见在web服务器对JSP进行pre compile的时候。如果你的WEB APP下都用了大量的第三方jar, 其大小超过了jvm默认的大小(4M)那么就会产生此错误信息了。
解决方法： 手动设置MaxPermSize大小修改TOMCAT_HOME/bin/catalina.sh 在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行： JAVA_OPTS="-server -XX:PermSize=64M -XX:MaxPermSize=128m
建议：将相同的第三方jar文件移置到tomcat/shared/lib目录下，这样可以达到减少jar 文档重复占用内存的目的。
二、java.lang.OutOfMemoryError: Java heap space Heap size 设置 JVM堆的设置是指java程序运行过程中JVM可以调配使用的内存空间的设置.JVM在启动的时候会自动设置Heap size的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)是物理内存的1/4。可以利用JVM提供的-Xmn -Xms -Xmx等选项可进行设置。Heap size 的大小是Young Generation 和Tenured Generaion 之和。提示：在JVM中如果98％的时间是用于GC且可用的Heap size 不足2％的时候将抛出此异常信息。提示：Heap Size 最大不要超过可用物理内存的80％，一般的要将-Xms和-Xmx选项设置为相同，而-Xmn为1/4的-Xmx值。
解决方法：手动设置Heap size 修改TOMCAT_HOME/bin/catalina.sh 在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行： JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"
三、实例，以下给出1G内存环境下java jvm 的参数设置参考：
JAVA_OPTS="-server -Xms800m -Xmx800m -XX:PermSize=64M -XX:MaxNewSize=256m -XX:MaxPermSize=128m -Djava.awt.headless=true "
四、 可以配置下Tomcat。
修改TOMCAT_HOME/bin/tomcat6w.exe 双击打开，在“Java "下设置如下：
Initial memory pool：768 MB
Maximum memory pool：1024 MB
Thread stack size：64KB
Java 堆 － 这是 JVM 用来分配 java 对象的内存。
如果JVM不能在java堆中获得更多内存来分配更多java对象，将会抛出java内存不足(java.lang.OutOfMemoryError)错误。默认情况下，应用程序崩溃。
本地内存 － 这是 JVM 用于其内部操作的内存。
如果 JVM 无法获得更多本地内存，它将抛出本地内存不足（本地 OutOfMemoryError）错误。当进程到达操作系统的进程大小限值，或者当计算机用完 RAM 和交换空间时，通常会发生这种情况。
进程大小 － 进程大小将是 java 堆、本地内存与加载的可执行文件和库所占用内存的总和。在 32 位操作系统上，进程的虚拟地址空间最大可达到 4 GB。从这 4 GB 内存中，操作系统内核为自己保留一部分内存（通常为 1 - 2 GB）。剩余内存可用于应用程序。
--项目中的用法。
1、StringUtils.join
List dwVoListInTab = this.prodService.getPicTabVOList(picId);
List dwNameListInTab = new ArrayList();
for (PrdTabVO dwVo : dwVoListInTab) {
String dwName = this.prodService.cvtTabNo2DWName(useProdNo, picId,
dwVo.getCTabNo());
dwNameListInTab.add(dwName);
dwNameMap.put(dwVo.getCNmeEn(), dwName);
}
((List)plyDwNameList).addAll(dwNameListInTab);
String dwNameListStr = "['" + StringUtils.join(dwNameListInTab.toArray(), "','") + "']";
其它：
StringUtils.join(new String[]{"cat","dog","carrot","leaf","door"}, ":")
// cat:dog:carrot:leaf:door
2、StringUtils.isNotEmpty //Checks if a String is not empty ("") and not null.
if (StringUtils.isNotEmpty(onload))
onload = sub.replace(onload);
else {
onload = "";
}
public String replace(char oldChar,char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
如果 oldChar 在此 String 对象表示的字符序列中没有出现，则返回对此 String 对象的引用。
3、StringUtils.equals //StringUtils.equals(null, null) = true
if (!StringUtils.equals(prodKindNo, "00")) {
}
4、StringUtils.isBlank //Checks if a String is whitespace, empty ("") or null.
if (StringUtils.isBlank(taskId))
jsBuffer.append("var taskId='';\n");
else {
jsBuffer.append("var taskId='" + taskId + "';\n");
}
5、StringUtils.leftPad(String str, int size,String padStr) --左填充
//投保年度【保险起期 - 初登年月】 单位：年
String ply_year = StringUtils.leftPad(String.valueOf(DateUtils.compareYear(regDate,base.getTInsrncBgnTm())), 2, '0');
/**
4260 * <p>Left pad a String with a specified String.</p>
4261 *
4262 * <p>Pad to a size of <code>size</code>.</p>
4263 *
4264 * <pre>
4265 * StringUtils.leftPad(null, *, *) = null
4266 * StringUtils.leftPad("", 3, "z") = "zzz"
4267 * StringUtils.leftPad("bat", 3, "yz") = "bat"
4268 * StringUtils.leftPad("bat", 5, "yz") = "yzbat"
4269 * StringUtils.leftPad("bat", 8, "yz") = "yzyzybat"
4270 * StringUtils.leftPad("bat", 1, "yz") = "bat"
4271 * StringUtils.leftPad("bat", -1, "yz") = "bat"
4272 * StringUtils.leftPad("bat", 5, null) = " bat"
4273 * StringUtils.leftPad("bat", 5, "") = " bat"
4274 * </pre>
4275 *
4276 * @param str the String to pad out, may be null
4277 * @param size the size to pad to
4278 * @param padStr the String to pad with, null or empty treated as single space
4279 * @return left padded String or original String if no padding is necessary,
4280 * <code>null</code> if null String input
4281 */
4282 public static String leftPad(String str, int size, String padStr) {
4283 if (str == null) {
4284 return null;
4285 }
4286 if (isEmpty(padStr)) {
4287 padStr = " ";
4288 }
4289 int padLen = padStr.length();
4290 int strLen = str.length();
4291 int pads = size - strLen;
4292 if (pads <= 0) {
4293 return str; // returns original String when possible
4294 }
4295 if (padLen == 1 && pads <= PAD_LIMIT) {
4296 return leftPad(str, size, padStr.charAt(0));
4297 }
4298
4299 if (pads == padLen) {
4300 return padStr.concat(str);
4301 } else if (pads < padLen) {
4302 return padStr.substring(0, pads).concat(str);
4303 } else {
4304 char[] padding = new char[pads];
4305 char[] padChars = padStr.toCharArray();
4306 for (int i = 0; i < pads; i++) {
4307 padding[i] = padChars[i % padLen];
4308 }
4309 return new String(padding).concat(str);
4310 }
4311 }
---------------------------------------------
详见：http://commons.apache.org/lang/api/org/apache/commons/lang/StringUtils.html
isEmpty
public static boolean isEmpty(CharSequence str)
Checks if a String is empty ("") or null.
StringUtils.isEmpty(null) = true
StringUtils.isEmpty("") = true
StringUtils.isEmpty(" ") = false
StringUtils.isEmpty("bob") = false
StringUtils.isEmpty(" bob ") = false
NOTE: This method changed in Lang version 2.0. It no longer trims the String. That
functionality is available in isBlank().
Parameters:
str - the String to check, may be null
Returns:
true if the String is empty or null
isNotEmpty
public static boolean isNotEmpty(CharSequence str)
Checks if a String is not empty ("") and not null.
StringUtils.isNotEmpty(null) = false
StringUtils.isNotEmpty("") = false
StringUtils.isNotEmpty(" ") = true
StringUtils.isNotEmpty("bob") = true
StringUtils.isNotEmpty(" bob ") = true
Parameters:
str - the String to check, may be null
Returns:
true if the String is not empty and not null
isBlank
public static boolean isBlank(CharSequence str)
Checks if a String is whitespace, empty ("") or null.
StringUtils.isBlank(null) = true
StringUtils.isBlank("") = true
StringUtils.isBlank(" ") = true
StringUtils.isBlank("bob") = false
StringUtils.isBlank(" bob ") = false
Parameters:
str - the String to check, may be null
Returns:
true if the String is null, empty or whitespace
Since:
2.0
isNotBlank
public static boolean isNotBlank(CharSequence str)
Checks if a String is not empty (""), not null and not whitespace only.
StringUtils.isNotBlank(null) = false
StringUtils.isNotBlank("") = false
StringUtils.isNotBlank(" ") = false
StringUtils.isNotBlank("bob") = true
StringUtils.isNotBlank(" bob ") = true
Parameters:
str - the String to check, may be null
Returns:
true if the String is not empty and not null and not whitespace
Since:
2.0
trim
public static String trim(String str)
Removes control characters (char <= 32) from both ends of this String, handling null by
returning null.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32.
To strip whitespace use strip(String).
To trim your choice of characters, use the strip(String, String) methods.
StringUtils.trim(null) = null
StringUtils.trim("") = ""
StringUtils.trim(" ") = ""
StringUtils.trim("abc") = "abc"
StringUtils.trim(" abc ") = "abc"
Parameters:
str - the String to be trimmed, may be null
Returns:
the trimmed string, null if null String input
trimToNull
public static String trimToNull(String str)
Removes control characters (char <= 32) from both ends of this String returning null if
the String is empty ("") after the trim or if it is null.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32.
To strip whitespace use stripToNull(String).
StringUtils.trimToNull(null) = null
StringUtils.trimToNull("") = null
StringUtils.trimToNull(" ") = null
StringUtils.trimToNull("abc") = "abc"
StringUtils.trimToNull(" abc ") = "abc"
Parameters:
str - the String to be trimmed, may be null
Returns:
the trimmed String, null if only chars <= 32, empty or null String input
Since:
2.0
trimToEmpty
public static String trimToEmpty(String str)
Removes control characters (char <= 32) from both ends of this String returning an empty
String ("") if the String is empty ("") after the trim or if it is null.
The String is trimmed using String.trim(). Trim removes start and end characters <= 32.
To strip whitespace use stripToEmpty(String).
StringUtils.trimToEmpty(null) = ""
StringUtils.trimToEmpty("") = ""
StringUtils.trimToEmpty(" ") = ""
StringUtils.trimToEmpty("abc") = "abc"
StringUtils.trimToEmpty(" abc ") = "abc"
Parameters:
str - the String to be trimmed, may be null
Returns:
the trimmed String, or an empty String if null input
Since:
2.0
equals
public static boolean equals(String str1,
String str2)
Compares two Strings, returning true if they are equal.
nulls are handled without exceptions. Two null references are considered to be equal. The
comparison is case sensitive.
StringUtils.equals(null, null) = true
StringUtils.equals(null, "abc") = false
StringUtils.equals("abc", null) = false
StringUtils.equals("abc", "abc") = true
StringUtils.equals("abc", "ABC") = false
Parameters:
str1 - the first String, may be null
str2 - the second String, may be null
Returns:
true if the Strings are equal, case sensitive, or both null
See Also:
String.equals(Object)
startsWith
public static boolean startsWith(String str,
String prefix)
Check if a String starts with a specified prefix.
nulls are handled without exceptions. Two null references are considered to be equal. The
comparison is case sensitive.
StringUtils.startsWith(null, null) = true
StringUtils.startsWith(null, "abc") = false
StringUtils.startsWith("abcdef", null) = false
StringUtils.startsWith("abcdef", "abc") = true
StringUtils.startsWith("ABCDEF", "abc") = false
Parameters:
str - the String to check, may be null
prefix - the prefix to find, may be null
Returns:
true if the String starts with the prefix, case sensitive, or both null
Since:
2.4
See Also:
String.startsWith(String)
1.去除尾部换行符，使用函数：StringUtils.chomp(testString)
函数介绍:去除testString尾部的换行符
例程:
String input = "Hello\n";
System.out.println( StringUtils.chomp( input ));
String input2 = "Another test\r\n";
System.out.println( StringUtils.chomp( input2 ));
输出如下:
Hello
Another test
2.判断字符串内容的类型，函数介绍：
StringUtils.isNumeric( testString ) :如果testString全由数字组成返回True
StringUtils.isAlpha( testString ) :如果testString全由字母组成返回True
StringUtils.isAlphanumeric( testString ) :如果testString全由数字或数字组成返回True
StringUtils.isAlphaspace( testString ) :如果testString全由字母或空格组成返回True
例程:
String state = "Virginia";
System.out.println( "Is state number? " + StringUtils.isNumeric(state ) );
System.out.println( "Is state alpha? " + StringUtils.isAlpha( state ));
System.out.println( "Is state alphanumeric? " +StringUtils.isAlphanumeric( state ) );
System.out.println( "Is state alphaspace? " + StringUtils.isAlphaSpace( state ) );
输出如下:
Is state number? false
Is state alpha? true
Is state alphanumeric? true
Is state alphaspace? true
3.查找嵌套字符串，使用函数：
StringUtils.substringBetween(testString,header,tail)
函数介绍：在testString中取得header和tail之间的字符串。不存在则返回空
例程：
String htmlContent = "ABC1234ABC4567";
System.out.println(StringUtils.substringBetween(htmlContent, "1234", "4567"));
System.out.println(StringUtils.substringBetween(htmlContent, "12345", "4567"));
输出如下：
ABC
null
4.颠倒字符串，使用函数：StringUtils.reverse(testString)
函数介绍:得到testString中字符颠倒后的字符串
例程:
System.out.println( StringUtils.reverse("ABCDE"));
输出如下:
EDCBA
5.部分截取字符串，使用函数：
StringUtils.substringBetween(testString,fromString,toString ):取得两字符之间的字符串
StringUtils.substringAfter( ):取得指定字符串后的字符串
StringUtils.substringBefore( )：取得指定字符串之前的字符串
StringUtils.substringBeforeLast( )：取得最后一个指定字符串之前的字符串
StringUtils.substringAfterLast( )：取得最后一个指定字符串之后的字符串
函数介绍：上面应该都讲明白了吧。
例程：
String formatted = " 25 * (30,40) [50,60] | 30";
System.out.print("N0: " + StringUtils.substringBeforeLast( formatted, "*" ) );
System.out.print(", N1: " + StringUtils.substringBetween( formatted, "(", "," ) );
System.out.print(", N2: " + StringUtils.substringBetween( formatted, ",", ")" ) );
System.out.print(", N3: " + StringUtils.substringBetween( formatted, "[", "," ) );
System.out.print(", N4: " + StringUtils.substringBetween( formatted, ",", "]" ) );
System.out.print(", N5: " + StringUtils.substringAfterLast( formatted, "|" ) );
输出如下：
N0: 25 , N1: 30, N2: 40, N3: 50, N4: 40) [50,60, N5: 30
MethodUtils的简单用法。
package com.ztf;
import java.util.Map;
import org.apache.commons.beanutils.MethodUtils;
import org.apache.commons.beanutils.PropertyUtils;
public class TestMethodUtils {
public static void main(String[] args) throws Exception{
Entity entity = new Entity();
entity.setId(1) ;
entity.setName("断点");
// 通过MethodUtils的invokeMethod方法,执行指定的entity中的方法(无参的情况)
MethodUtils.invokeMethod(entity, "sayHello", null);
// 通过MethodUtils的invokeMethod方法,执行指定的entity中的方法（1参的情况）
MethodUtils.invokeMethod(entity, "sayHello", "断点");
// 通过MethodUtils的invokeMethod方法,执行指定的entity中的方法（多参的情况）
Object[] params = new Object[]{new Integer(10),new Integer(12)};
MethodUtils.invokeMethod(entity, "sayHello", params);
}
}
实体：
package com.ztf;
public class Entity {
private Integer id;
private String name;
public void sayHello(){
System.out.println("sayHello()---> 无参");
}
public void sayHello(String s){
System.out.println("sayHello()---> 有1个参数" );
}
public void sayHello(Integer a,Integer b){
System.out.println("sayHello()---> 有2个参数");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
输出：
sayHello()---> 无参
sayHello()---> 有1个参数
sayHello()---> 有2个参数
实体bean。
package com.ztf;
public class Entity {
private Integer id;
private String name;
public void sayHello(){
System.out.println("sayHello()---> 无参");
}
public void sayHello(String s){
System.out.println("sayHello()---> 有1个参数" );
}
public void sayHello(Integer a,Integer b){
System.out.println("sayHello()---> 有2个参数");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
}
package com.ztf;
import java.util.Map;
import org.apache.commons.beanutils.MethodUtils;
import org.apache.commons.beanutils.PropertyUtils;
public class TestPropertyUtils {
public static void main(String[] args) throws Exception{
Entity entity = new Entity();
entity.setId(1) ;
entity.setName("断点");
// 通过PropertyUtils的getProperty方法获取指定属性的值
Integer id = (Integer)PropertyUtils.getProperty(entity, "id");
String name = (String)PropertyUtils.getProperty(entity, "name");
System.out.println("id = " + id + " name = " + name);
// 调用PropertyUtils的setProperty方法设置entity的指定属性
PropertyUtils.setProperty(entity, "name", "每天进步一点");
System.out.println("name = " + entity.getName());
// 通过PropertyUtils的describe方法把entity的所有属性与属性值封装进Map中
Map map = PropertyUtils.describe(entity);
System.out.println("id = " + map.get("id") + " name = " + map.get("name"));
}
}
输出：
id = 1 name = 断点
name = 每天进步一点
id = 1 name = 每天进步一点
其它例子：
import org.apache.commons.beanutils.PropertyUtils;
List<Map<String, Object>> data = new ArrayList<Map<String, Object>>();
for(BaseGrpMemberVO member : MemberVO){
Map m = new HashMap();
for(Map.Entry<String, String> entry: fieldMap.entrySet()){
String key = entry.getKey();
fieldList.add(key); //记录字段名
String[] keyArray = key.split("\\.");
if(keyArray.length == 2){//成员信息
Object o =PropertyUtils.getProperty(member, keyArray[1]);
m.put(key, o==null?"":o.toString());
}else if(keyArray.length == 3){//险别信息
List<BaseGrpCvrgVO> cvrgVoList = mgr.getRelCvrgById(member.getCPkId());
String cvrgNo = keyArray[0];
for(BaseGrpCvrgVO cvrgVo : cvrgVoList){
if(cvrgNo.equals(cvrgVo.getCCvrgNo())){
Object o =PropertyUtils.getProperty(cvrgVo, keyArray[2]);
m.put(key, o==null?"":o.toString());
}
}
}
}
data.add(m);
}
apache.commons.beanutils.BeanUtils
该class提供了一系列的静态方法操作已存在的符合JavaBean规范定义的Java Class.这里强调的JavaBean规范,简单来说就是一个Java Class通过一系列getter和setter的方法向外界展示其内在的成员变量(属性)。
通过BeanUtils的静态方法,我们可以:
复制一个JavaBean的实例--BeanUtils.cloneBean();
在一个JavaBean的两个实例之间复制属性--BeanUtils.copyProperties(),BeanUtils.copyProperty();
为一个JavaBean的实例设置成员变量(属性)值--BeanUtils.populate(),BeanUtils.setProperty();
从一个JavaBean的实例中读取成员变量(属性)的值--BeanUtils.getArrayProperty(),BeanUtils.getIndexedProperty(),BeanUtils.getMappedProperty(),BeanUtils.getNestedProperty(),BeanUtils.getSimpleProperty(),BeanUtils.getProperty(),BeanUtils.describe();
1、BeanUtils.cloneBean(java.lang.object bean)
为bean创建一个clone对象,方法返回类型为Object.此方法的实现机制建立在bean提供的一系列的getters和setters的基础之上.此方法的正常使用代码非常简单,故略掉.
2、BeanUtils.copyProperties(java.lang.Object dest, java.lang.Object orig)
一个bean class有两个实例:orig和dest,将orig中的成员变量的值复制给dest,即将已经存在的dest变为orig的副本.与BeanUtils.cloneBean(java.lang.object bean)的区别就在于是不是需要创建新的实例了.
原文如下:Copy property values from the origin bean to the destination bean for all cases where the property names are the same.
3、BeanUtils.setProperty(java.lang.Object bean,java.lang.String name,java.lang.Object value)
这个方法简单的说就是将bean中的成员变量name赋值为value.
BeanUtils.populate(java.lang.Object bean, java.util.Map properties)
使用一个map为bean赋值,该map中的key的名称与bean中的成员变量名称相对应.注意:只有在key和成员变量名称完全对应的时候,populate机制才发生作用;但是在数量上没有任何要求,如map中的key如果是成员变量名称的子集,那么成员变量中有的而map中不包含的项将会保留默认值;同样,如果成员变量是map中key的子集,那么多余的key不会对populate的结果产生任何影响.恩,结果就是populate只针对map中key名称集合与bean中成员变量名称集合的交集产生作用。
4、BeanUtils.getArrayProperty(java.lang.Object bean,java.lang.String name)
获取bean中数组成员变量(属性)的值.
如果我们指定的name不是数组类型的成员变量,结果会如何?会不会抛出类型错误的exception呢?回答是不会,仍然会返回一个String的数组,数组的第一项就是name对应的值(如果不
是String类型的话,JVM会自动的调用toString()方法的).
BeanUtils.getIndexedProperty(java.lang.Object bean,java.lang.String name)
BeanUtils.getIndexedProperty(java.lang.Object bean,java.lang.String name,int index)
这两个方法都是获取数组成员变量(属性)中的单一元素值的方法.
比如,我想得到SampleObject中words[1]的值,用法如下:
BeanUtils.getIndexedProperty(sampleOjbectInstance,"words[1]");
BeanUtils.getIndexedProperty(sampleOjbectInstance,"words",1);
BeanUtils.getMappedProperty(java.lang.Object bean,java.lang.String name)
BeanUtils.getMappedProperty(java.lang.Object bean,java.lang.String name,java.lang.String key)
BeanUtils.describe(java.lang.Object bean)
将一个bean以map的形式展示。
来源：http://www.chinaitpower.com/A/2005-07-03/150232.html
原因：在这两天的时间里，weblogic92把我很是郁闷了一把，原因是我本地的工程走业务流程没有问题，而到它上面去跑流程就是 处理失败！真正的问题就是2个jar包的有冲突，一样的class文件，名字分别为pcis_reinsure.jar、pcis_reinsure_open.jar 。在我提交svn的时候，把pcis_reinsure.jar删除了，把pcis_reinsure_open.jar 新增了，结果weblogic92的缓存中含有pcis_reinsure.jar、pcis_reinsure_open.jar 。
注：pcis_reinsure.jar 旧包、pcis_reinsure_open.jar 新包，其中一个类IRiskUnitService有方法divideRiskUnit，而另一个没有这个方法，所以老是提示
Caused by: java.lang.NoSuchMethodError: com..pcis.riskunit.service.IRiskUnitService.divideRiskUnit(L
com/isoftstone/pcis/policy/dm/bo/PolicyApplication;)V
解决：
在Tomcat中，我们知道%catalina_home%\work是存放缓存文件的地方，可以通过删除这里面的文件，让它重新编译，以便代码生效。
weblogic92的缓存文件存放在哪里呢？
weblogic92的发布项目缓存临时文件路径是
D:\bea\user_projects\domains\nonvhl_policy\servers\AdminServer\tmp\_WL_user\nonvhl_policy\4huf50\war\WEB-INF\lib，在此路径下把pcis_reinsure.jar删除就可以了。
注意：
1、要停服务后再删除缓存文件，运行时它已经加载到内存了。
2、缓存只加载新增的文件，对于工程删除的jar文件它不做删除。
.
JAVA Memory arguments: -Xms512m -Xmx768m -XX:CompileThreshold=8000 -XX:PermSize=48m -XX:MaxPermSize=256m
.
WLS Start Mode=Development
.
CLASSPATH=D:\bea\weblogic_crack.jar;;d:\bea\patch_weblogic920\profiles\default\sys_manifest_classpath\weblogic
_patch.jar;d:\bea\JDK150~1\lib\tools.jar;D:\bea\WEBLOG~1\server\lib\weblogic_sp.jar;D:\bea\WEBLOG~1\server\lib
\weblogic.jar;D:\bea\WEBLOG~1\server\lib\webservices.jar;;D:\bea\WEBLOG~1\common\eval\pointbase\lib\pbclient51
.jar;D:\bea\WEBLOG~1\server\lib\xqrl.jar;;
.
PATH=d:\bea\patch_weblogic920\profiles\default\native;D:\bea\WEBLOG~1\server\native\win\32;D:\bea\WEBLOG~1\ser
ver\bin;d:\bea\JDK150~1\jre\bin;d:\bea\JDK150~1\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;D:
\bea\WEBLOG~1\server\native\win\32\oci920_8
.
***************************************************
* To start WebLogic Server, use a username and *
* password assigned to an admin-level user. For *
* server administration, use the WebLogic Server *
* console at http:\\hostname:port\console *
***************************************************
starting weblogic with Java version:
java version "1.5.0_04"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_04-b05)
Java HotSpot(TM) Client VM (build 1.5.0_04-b05, mixed mode)
Starting WLS with line:
d:\bea\JDK150~1\bin\java -client -Xms512m -Xmx768m -XX:CompileThreshold=8000 -XX:PermSize=48m -XX:MaxPermSi
ze=256m -Xverify:none -da -Dplatform.home=D:\bea\WEBLOG~1 -Dwls.home=D:\bea\WEBLOG~1\server -Dwli.home=D:\be
a\WEBLOG~1\integration -Dweblogic.management.discover=true -Dwlw.iterativeDev= -Dwlw.testConsole= -Dwlw.logE
rrorsToConsole= -Dweblogic.ext.dirs=d:\bea\patch_weblogic920\profiles\default\sysext_manifest_classpath -Dwebl
ogic.Name=AdminServer -Djava.security.policy=D:\bea\WEBLOG~1\server\lib\weblogic.policy weblogic.Server
<2010-5-24 上午09时42分56秒 CST> <Notice> <WebLogicServer> <BEA-000395> <Following extensions directory conten
ts added to the end of the classpath:
D:\bea\weblogic92\platform\lib\p13n\p13n-schemas.jar;D:\bea\weblogic92\platform\lib\p13n\p13n_common.jar;D:\be
a\weblogic92\platform\lib\p13n\p13n_system.jar;D:\bea\weblogic92\platform\lib\wlp\netuix_common.jar;D:\bea\web
logic92\platform\lib\wlp\netuix_schemas.jar;D:\bea\weblogic92\platform\lib\wlp\netuix_system.jar;D:\bea\weblog
ic92\platform\lib\wlp\wsrp-common.jar>
<2010-5-24 上午09时42分56秒 CST> <Info> <WebLogicServer> <BEA-000377> <Starting WebLogic Server with Java HotS
pot(TM) Client VM Version 1.5.0_04-b05 from Sun Microsystems Inc.>
<2010-5-24 上午09时42分57秒 CST> <Info> <Management> <BEA-141107> <Version: WebLogic Server 9.2 Fri Jun 23 20
:47:26 EDT 2006 783464 >
<2010-5-24 上午09时43分00秒 CST> <Info> <WebLogicServer> <BEA-000215> <Loaded License : d:\bea\license.bea>
<2010-5-24 上午09时43分00秒 CST> <Notice> <WebLogicServer> <BEA-000365> <Server state changed to STARTING>
<2010-5-24 上午09时43分00秒 CST> <Info> <WorkManager> <BEA-002900> <Initializing self-tuning thread pool>
<2010-5-24 上午09时43分00秒 CST> <Notice> <Log Management> <BEA-170019> <The server log file D:\bea\user_proje
cts\domains\nonvhl_policy\servers\AdminServer\logs\AdminServer.log is opened. All server side log events will
be written to this file.>
<2010-5-24 上午09时43分00秒 CST> <Error> <Socket> <BEA-000438> <Unable to load performance pack. Using Java I/
O instead. Please ensure that wlntio.dll is in: 'd:\bea\JDK150~1\bin;.;C:\WINDOWS\system32;C:\WINDOWS;d:\bea\p
atch_weblogic920\profiles\default\native;D:\bea\WEBLOG~1\server\native\win\32;D:\bea\WEBLOG~1\server\bin;d:\be
a\JDK150~1\jre\bin;d:\bea\JDK150~1\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;D:\bea\WEBLOG~1
\server\native\win\32\oci920_8'
>
<2010-5-24 上午09时43分02秒 CST> <Notice> <Security> <BEA-090082> <Security initializing using security realm
myrealm.>
<2010-5-24 上午09时43分03秒 CST> <Critical> <Deployer> <BEA-149618> <Unable to deploy an internal management W
eb application - bea_wls_management_internal2. Managed servers may be unable to start.
weblogic.management.DeploymentException: weblogic.management.DeploymentException:
at weblogic.deploy.internal.InternalAppProcessor.stageFilesAndCreateBeansForInternalApp(InternalAppPro
cessor.java:258)
at weblogic.deploy.internal.InternalAppProcessor.updateConfiguration(InternalAppProcessor.java:196)
at weblogic.management.deploy.internal.DeploymentServerService.init(DeploymentServerService.java:144)
at weblogic.management.deploy.internal.DeploymentPreStandbyServerService.start(DeploymentPreStandbySer
verService.java:32)
at weblogic.t3.srvr.SubsystemRequest.run(SubsystemRequest.java:64)
Truncated. see log file for complete stacktrace
java.util.zip.ZipException: Error opening file - D:\bea\WEBLOG~1\server\lib\bea_wls_management_internal2.war M
essage - 系统找不到指定的文件。
at weblogic.servlet.utils.WarUtils.existsInWar(WarUtils.java:65)
at weblogic.servlet.utils.WarUtils.isWar(WarUtils.java:44)
at weblogic.servlet.internal.WarDeploymentFactory.findOrCreateComponentMBeans(WarDeploymentFactory.jav
a:54)
at weblogic.application.internal.MBeanFactoryImpl.findOrCreateComponentMBeans(MBeanFactoryImpl.java:48
)
at weblogic.application.internal.MBeanFactoryImpl.createComponentMBeans(MBeanFactoryImpl.java:110)
Truncated. see log file for complete stacktrace
>
<2010-5-24 上午09时43分03秒 CST> <Critical> <WebLogicServer> <BEA-000362> <Server failed. Reason:
There are 1 nested errors:
weblogic.management.provider.UpdateException: [Deployer:149616]A critical internal application bea_wls_managem
ent_internal2 was not deployed. Error: weblogic.management.DeploymentException:
at weblogic.deploy.internal.InternalAppProcessor.handleErr(InternalAppProcessor.java:211)
at weblogic.deploy.internal.InternalAppProcessor.updateConfiguration(InternalAppProcessor.java:198)
at weblogic.management.deploy.internal.DeploymentServerService.init(DeploymentServerService.java:144)
at weblogic.management.deploy.internal.DeploymentPreStandbyServerService.start(DeploymentPreStandbySer
verService.java:32)
at weblogic.t3.srvr.SubsystemRequest.run(SubsystemRequest.java:64)
at weblogic.work.ExecuteThread.execute(ExecuteThread.java:209)
at weblogic.work.ExecuteThread.run(ExecuteThread.java:181)
Caused by: java.util.zip.ZipException: Error opening file - D:\bea\WEBLOG~1\server\lib\bea_wls_management_inte
rnal2.war Message - 系统找不到指定的文件。
at weblogic.servlet.utils.WarUtils.existsInWar(WarUtils.java:65)
at weblogic.servlet.utils.WarUtils.isWar(WarUtils.java:44)
at weblogic.servlet.internal.WarDeploymentFactory.findOrCreateComponentMBeans(WarDeploymentFactory.jav
a:54)
at weblogic.application.internal.MBeanFactoryImpl.findOrCreateComponentMBeans(MBeanFactoryImpl.java:48
)
at weblogic.application.internal.MBeanFactoryImpl.createComponentMBeans(MBeanFactoryImpl.java:110)
at weblogic.application.inter
解决方法：
1、把自己以前安装的bea目录下的
D:\bea\WEBLOG~1\server\lib\bea_wls_management_internal2.war Message 文件重新复制一份放在当前bea下即可。
2、还有一种就是重新装下bea。
ArrayUtils类帮我们完成数组的打印、查找、克隆、倒序、以及值型/对象数组之间的转换等操作。
1import org.apache.commons.lang.ArrayUtils;
2
3public class TestArrayUtils {
4
5 public static void main(String[] args) {
6 /** *//**
7 * 打印数组中的内容
8 */
9 int[] intArray = new int[] { 2, 3, 4, 5, 6 };
10 int[][] multiDimension = new int[][] { { 1, 2, 3 }, { 2, 3 }, {5, 6, 7} };
11
12 System.out.println( "intArray: " + ArrayUtils.toString( intArray ) );
13 System.out.println( "multiDimension: " + ArrayUtils.toString( multiDimension ) );
14 }
15}
输出：
intArray: {2,3,4,5,6}
multiDimension: {{1,2,3},{2,3},{5,6,7}}
CollectionUtils 中四个方法对集合操作： union()，intersection()，disjunction();，subtract()。
1import java.util.Arrays;
2import java.util.Collection;
3import java.util.Collections;
4import java.util.List;
5
6import org.apache.commons.collections.CollectionUtils;
7import org.apache.commons.lang.ArrayUtils;
8
9public class TestCollectionUtils {
10 @SuppressWarnings("unchecked")
11 public static void main(String[] args) {
12 String[] arrayA = new String[] { "1", "2", "3", "3", "4", "5" };
13 String[] arrayB = new String[] { "3", "4", "4", "5", "6", "7" };
14
15 List<String> a = Arrays.asList(arrayA);
16 List<String> b = Arrays.asList(arrayB);
17 // 并集
18 Collection<String> union = CollectionUtils.union(a, b);
19 // 交集
20 Collection<String> intersection = CollectionUtils.intersection(a, b);
21 // 交集的补集
22 Collection<String> disjunction = CollectionUtils.disjunction(a, b);
23 // 集合相减
24 Collection<String> subtract = CollectionUtils.subtract(a, b);
25
26 Collections.sort((List<String>) union);
27 Collections.sort((List<String>) intersection);
28 Collections.sort((List<String>) disjunction);
29 Collections.sort((List<String>) subtract);
30
31 System.out.println("A: " + ArrayUtils.toString(a.toArray()));
32 System.out.println("B: " + ArrayUtils.toString(b.toArray()));
33 System.out.println("--------------------------------------------");
34 System.out.println("Union(A, B): " + ArrayUtils.toString(union.toArray()));
35 System.out.println("Intersection(A, B): " + ArrayUtils.toString(intersection.toArray()));
36 System.out.println("Disjunction(A, B): " + ArrayUtils.toString(disjunction.toArray()));
37 System.out.println("Subtract(A, B): " + ArrayUtils.toString(subtract.toArray()));
38 }
39}
输出：
A: {1,2,3,3,4,5}
B: {3,4,4,5,6,7}
--------------------------------------------
Union(A, B): {1,2,3,3,4,4,5,6,7}
Intersection(A, B): {3,4,5}
Disjunction(A, B): {1,2,3,4,6,7}
Subtract(A, B): {1,2,3}
转载：http://blog.csdn.net/ofofw/archive/2009/06/26/4300964.aspx
2010-5-4 9:55:00 org.apache.catalina.session.StandardManager doLoad
严重: IOException while loading persisted sessions: java.io.EOFException
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2228)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2694)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:761)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:277)
at org.apache.catalina.util.CustomObjectInputStream.<init>(CustomObjectInputStream.java:58)
at org.apache.catalina.session.StandardManager.doLoad(StandardManager.java:362)
at org.apache.catalina.session.StandardManager.load(StandardManager.java:321)
at org.apache.catalina.session.StandardManager.start(StandardManager.java:637)
at org.apache.catalina.core.ContainerBase.setManager(ContainerBase.java:438)
at org.apache.catalina.core.StandardContext.start(StandardContext.java:4258)
at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:791)
at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:771)
at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:525)
at org.apache.catalina.startup.HostConfig.deployDirectory(HostConfig.java:920)
at org.apache.catalina.startup.HostConfig.deployDirectories(HostConfig.java:883)
at org.apache.catalina.startup.HostConfig.deployApps(HostConfig.java:492)
at org.apache.catalina.startup.HostConfig.start(HostConfig.java:1138)
at org.apache.catalina.startup.HostConfig.lifecycleEvent(HostConfig.java:311)
at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:117)
at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1053)
at org.apache.catalina.core.StandardHost.start(StandardHost.java:719)
at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1045)
at org.apache.catalina.core.StandardEngine.start(StandardEngine.java:443)
at org.apache.catalina.core.StandardService.start(StandardService.java:516)
at org.apache.catalina.core.StandardServer.start(StandardServer.java:710)
at org.apache.catalina.startup.Catalina.start(Catalina.java:566)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:585)
at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:288)
at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:413)
解决：
删除Tomcat里面的work\Catalina\localhost下的内容即可解决。
今天测试工程的时候，我用本地“承保工程”调用另外一个同事的“规则工程”，也报了上面的错误。
网上相关解决如下：
java.lang.UnsupportedClassVersionError: Bad version number in .class file异常，检查了一下我的myEclipse，发现不知道啥时候不小心将编译器改成JDK6.0了，那个工程是从同事的机上拷贝过来的，用的编译器是JDK5.0，试了一下，果然是这个问题引起。
那次在Linux上部署工程时也出现过因为版本不同引起的问题，那时我们用的IDE的编译器是JDK5.0，而那台Linux装的是JDK6.0，部署后发现很多功能都出错，看来有些东西还是得注意一下啊。
附，在myEclipse中改变编译器的方法：Project->Properties->Java Compiler->Configure Workspace Setting，在弹出的页面中可以进行设置。
在操作Drools的测试例子时，Eclipse后台报以下错误：
org.drools.RuntimeDroolsException: Unable to load dialect 'org.drools.rule.builder.dialect.java.JavaDialectConfiguration:java'
at org.drools.compiler.PackageBuilderConfiguration.addDialect(PackageBuilderConfiguration.java:160)
at org.drools.compiler.PackageBuilderConfiguration.buildDialectConfigurationMap(PackageBuilderConfiguration.java:146)
at org.drools.compiler.PackageBuilderConfiguration.init(PackageBuilderConfiguration.java:121)
at org.drools.compiler.PackageBuilderConfiguration.<init>(PackageBuilderConfiguration.java:98)
at org.drools.compiler.PackageBuilder.<init>(PackageBuilder.java:124)
at org.drools.compiler.PackageBuilder.<init>(PackageBuilder.java:86)
at com.sample.DecisionTableTest.readDecisionTable(DecisionTableTest.java:58)
at com.sample.DecisionTableTest.main(DecisionTableTest.java:35)
Caused by: java.lang.RuntimeException: The Eclipse JDT Core jar is not in the classpath
at org.drools.rule.builder.dialect.java.JavaDialectConfiguration.setCompiler(JavaDialectConfiguration.java:91)
at org.drools.rule.builder.dialect.java.JavaDialectConfiguration.init(JavaDialectConfiguration.java:52)
at org.drools.compiler.PackageBuilderConfiguration.addDialect(PackageBuilderConfiguration.java:156)
... 7 more
主要是缺少一个jar包：org.eclipse.jdt.core_3.3.1.v_780_R33x.jar而引起的。
package org.jbpm.helloworld;
import junit.framework.TestCase;
import org.jbpm.graph.def.ProcessDefinition;
import org.jbpm.graph.exe.ProcessInstance;
import org.jbpm.graph.exe.Token;
public class HelloWorldTest extends TestCase {
public void testHelloWorldProcess() {
ProcessDefinition processDefinition = ProcessDefinition.parseXmlResource("helloWorld.xml");
/* 从这里可以看出，是对流程定义的XML进行解析*/
ProcessInstance processInstance = new ProcessInstance(processDefinition);
Token token = processInstance.getRootToken();
assertSame(processDefinition.getStartState(), token.getNode());
token.signal();
assertSame(processDefinition.getNode("s"), token.getNode());
token.signal();
assertSame(processDefinition.getNode("end"), token.getNode());
}
流程定义文件：helloWorld.xml
<?xml version="1.0" encoding="UTF-8"?>
<process-definition xmlns="urn:jbpm.org:jpdl-3.1" name="Helloworld">
<start-state>
<transition to='s' />
</start-state>
<state name='s'>
<transition to='end' />
</state>
<end-state name='end' />
</process-definition>
package rules;
import java.io.InputStream;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import org.drools.RuleBase;
import org.drools.RuleBaseFactory;
import org.drools.WorkingMemory;
import org.drools.compiler.PackageBuilder;
import org.drools.decisiontable.InputType;
import org.drools.decisiontable.SpreadsheetCompiler;
import org.drools.rule.Package;
public class TestPremium {
public static final String path = "rules\\premium\\0326\\02\\030006\\rate.xls";
public static void main(String[] args) throws Exception {
try {
RuleBase ruleBase = readDecisionTable();
WorkingMemory workingMemory = ruleBase.newStatefulSession();
int flag = path.indexOf("FormulaOrder");
ElementResultVO r = new ElementResultVO();
PremiumHelper helper = new PremiumHelper();
workingMemory.setGlobal("r", r);
workingMemory.setGlobal("helper", helper);
AppBaseVO base = new AppBaseVO();
AppVhlVO vhl = new AppVhlVO();
AppPrmCoefVO prmCoef = new AppPrmCoefVO();
base.setCAmtCur("01");
base.setNAmt(4000000d);
workingMemory.insert(base);
workingMemory.insert(vhl);
workingMemory.insert(prmCoef);
workingMemory.fireAllRules();
System.out.println("==========compile success!===========");
} catch (Exception e) {
System.out.println("==========compile failure!===========");
e.printStackTrace();
}
}
private static RuleBase readDecisionTable() throws Exception {
final SpreadsheetCompiler converter = new SpreadsheetCompiler();
InputStream is = TestPremium.class.getClassLoader().getResourceAsStream(path);
final String drl = converter.compile( is, InputType.XLS );
PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new StringReader( drl ) );
Package pkg = builder.getPackage();
RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage( pkg );
return ruleBase;
}
}
++++++++++++++++++++++++++++++++++++++
执行后的一部分：
#From row number: 369
rule "_369"
salience 65167
activation-group "x"
when
vhl:AppVhlVO(CUsageCde == "374015", CVhlTyp == "365012",
eval(helper.getVhlYear(vhl.getCFstRegYm())>=4 && helper.getVhlYear(vhl.getCFstRegYm())<1000))
then
r.putCoef("rate",0.67);
r.putField("Table.col","Cvrg.NRate");
end
package com.premium.rules;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.apache.log4j.Logger;
import org.drools.compiler.DroolsParserException;
import org.drools.compiler.PackageBuilder;
import org.drools.decisiontable.InputType;
import org.drools.decisiontable.SpreadsheetCompiler;
import org.drools.rule.Package;
public class DrlPackageManager {
// 用于缓存Drools的Package，key为Excel的完整路径，value为此文件编译过后的Package
static Map<String, Package> pkgMap = new HashMap<String, Package>();
private static Logger logger = Logger.getLogger(DrlPackageManager.class);
/**
* 通过Excel的文件名缓存Drools的Package
*
* @param fileName
* @return
* @throws Exception
*/
public static Package getPackageByXsl(String fileName) throws Exception {
Package pkg = (Package) pkgMap.get(fileName);
if (pkg != null)
return pkg;
final SpreadsheetCompiler converter = new SpreadsheetCompiler();
InputStream is = null;
try {
is = DrlPackageManager.class.getResourceAsStream(fileName);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
is.close();
throw new Exception("====读取规则的资源文件" + fileName + "出错，请检查文件"+ fileName + "=====", e);
}
String drl = null;
try {
drl = converter.compile(is, InputType.XLS);
logger.debug("Drools Excel规则文件：" + fileName + "编译成.drl文件的结果："+ drl);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
is.close();
throw new Exception("xls文件编译成drl文件出错", e);
}
PackageBuilder builder = new PackageBuilder();
StringReader srd = new StringReader(drl);
builder.addPackageFromDrl(srd);
pkg = builder.getPackage();
pkgMap.put(fileName, pkg);
is.close();
return pkg;
}
}
1、Drools是什么?
Drools 是一个基于Charles Forgy's的Rete算法的，专为Java语言所设计的规则引擎。Rete算法应用于面向对象的接口将使基于商业对象的商业规则的表达更为自然。Drools是用Java写的，但能同时运行在Java和.Net上。
一路到底的框架：
大多数开发者都有自己喜爱的框架。无特定顺序，它们包括表现层框架（Struts, JSF, Cocoon和Spring）,持久化框架（JDO, Hibernate, Cayenne and Entity Beans）以及结构框架(EJB, 又是Spring, Pico和Excalibur), 还有其它很多。每种框架都各有所长，给开发者提供子许多“即开即用”的功能。使用框架来部署应用意味着你避免了许多让人厌烦的细节，让你集中注意力到关键之处。
到目前为直，在框架所能做的事中仍然有一个缺口，那就是商业逻辑没有框架。像EJB和Spring这样的工具虽好，但它们却几乎没有提及怎么组织你的那些if …then语句。把Drools加到你的开发工具箱中意味着现在你可以“一路到底”的使用框架来构建你的应用程序。
2.Drools4.0版本：
JBoss Drools是一款开源的业务规则引擎，目前已经发布了4.0版本。在4.0版本中主要的特色和改进如下：
1.更高的性能：较之于之前的版本，Drools 4.0更为高效并且占用更少的内存空间。内部的性能测试表明，性能的提升已经从几分钟缩减为若干秒钟。
2.提升的表达能力：当前的发布版引入了更为强大且的业务行为脚本语言（MVFlex表达式语言）。
3.友好的业务分析工具：一个具备向导功能的规则编辑器的增加，使得非程序员用户可以设计复杂的业务规则，并在没有编写任何代码的情况下自动绑定企业数据。提供带有菜单提示和下拉列表的向导来帮助用户完成设计过程。
4.规则流的能力：可视化的建模技术可以使用户声明式地为相应规则的执行路径建立访问模型。它同样还允许在单个工作内存中存在多个并发工作流，并根据控制典型的业务处理过程的需求，从根本上组织规则的执行。 5.多应用支撑：对于有状态和无状态处理过程增强的支持以及全面的线程安全性，辅助Drools更轻易的嵌入在Java平台，JavaEE以及面向服务的商业应用之中。
6.直接可和Hibernate集成：用户可以直接在Hibernate驱动的RDBMS查询中对数据（facts）进行判断。现有的Hibernate组件可以直接用在规则引擎里，减少编码的工作量。
7.为非程序员设计的BRMS：从技术角度来看，新的BRMS基于Web开发，使用AJAX呈现，便于协作，是一个编写、版本化控制和管理规则的系统。业务分析师目前可以交互式的授权或修改自动转换的规则。管理员目前具备完全的生命周期控制能力，包含何种规则在QA阶段，分段（staging），以及实施（production）阶段等等。
3.Drools的总体架构：
我们使用Drools就是为了让它处理数据与规则的关系，因此Drools要获得数据和获得规则，然后进行执行。因此Drools分为编制和运行时两个部分。
编制是指产生rule的过程，Drools用DRL，或者XML来描述规则。编制的过程包括为规则建立DRL 或XML 文件，传入一个由Antlr 3 文法器定义的解析器中。解析器对文件中规则文法的正确性进行检查并为descr 建立一个中间结构，在AST 中的descr 代表规则的描述。AST 然后将descr 传入Package Builder中，由其进行打包。Package Builder 同时负责包括打包中用到的所有代码产生器和编译器。Package 对象是自包含并可配置的，它是一个包含规则的序列化的对象。
RuleBase 是运行时组件，包含一个或多个Package。Package 在任何时候都可以向RuleBase中添加或删除。一个RuleBase 可以同时初始化多个Working Memory，在其间维护着一个弱引用，除非重新进行配置。Working Memory 包含许多子组件，如Working Memory Event Support(事件支持),Truth Maintenance System(真值维护系统), Agenda 和 Agenda Event Support(事件支持)。向Working Memory 中设置对象的工作可能要在建立了一个或多个激活的规则后才结束。Agenda 负有规划激活规则运行的责任。
4.Drools主要有以下类实现：
编制：
XmlParser,DrlParser 分别用来解析XML描述的规则文件和DRL描述的规则文件。
PackageBuilder 创建package实例。
例如：
PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream( "package1.drl" ) ) );
builder.addPackageFromXml( new
InputStreamReader( getClass().getResourceAsStream( "package2.xml" ) ) );
Package pkg = builder.getPackage();
运行时的类：
RuleBase 使用RuleBaseFactory 实例化，默认情况下返回一个ReteOO 的RuleBase。Package通过使用addPackage 方法按顺序加入。你可以指定任何名称空间的Packages 或者同一名称的多个包加入RuleBase。
RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage( pkg );
事实数据相关类：
WorkingMemory 保存运行时事实数据的地方。
由ruleBase产生：WorkingMemory wm= ruleBase.newStatefulSession();
加载事实数据：
wm.insert(object );
insert方法返回一个FactHandle对象指向workingMemory中对象的引用。如果要对Object进行修改删除等操作都要通过FactHander对象来完成。
在准备好Rule，和Fact后 就可以调用 WorkingMemory对象的 fireAllRules（）方法执行规则引擎。
Agenda上面提到过它负有规划激活规则运行的责任。
它运行过程分两个阶段：
1） WorkingMemory Actions ： assert 新的 facts ，修改存在的 facts 和 retract facts 都是 WorkingMemory Actions 。通过在应用程序中调用 fireAllRules() 方法，会使引擎 转换到 Agenda Evaluatioin 阶段。
2） Agenda Evaluation ：尝试选择一条规则进行激发（ fire ）。如果规则没有找到就 退出，否则它就尝试激发这条规则，然后转换到 WorkingMemory Actions 阶段，直到 Agenda中为空。
Eval 是Javascript 中一个非常有用而奇特的预定义函数，它的概念和作用也像C 语言中的指针一样较难理解，因而在实际应用中常常不能运用得当。函数Eval的功能是把一个字符串参数转换成Javascript的代码，这个被转换的代码可以是一个变量名，也可以是一个算术表达式，甚至是一个函数表达式。如i ＝ eval("name1")是把名为name1 的变量赋值给变量i；i=eval("3+2")是把表达式3+2 的值5 赋给变量i ； i ＝ eval("funname(n)")是把函数funname(n)返回值传给变量i。这时，你也许要问了，这不是多此一举吗？直接写成i=name1；i＝3+2；i=funname(n)不就行了吗？是的，如果我们仅仅把字符串值当作参数，是一点作用都不起。但如果我们把字符串变量作为参数，Eval 的作用就大了。如i=eval(str)（其中，str 是字符串变量），str 作为一个变量，其值可以动态地发生变更，从而使i ＝ eval(str)产生不同的结果。这时str是不是像C语言的指针？它“指”向name1(即str 的值是"name1" 字串），i得到的是变量name1 的值。它“指”向一个函数名，就调用该函数并返回值给i（但该函数必须事先定义好，Javascript 引擎要找得到才行）。此外，它比“指针”更有用的是，还可解析执行动态生成的运算表达式。
下面通过一个Web仿真计算器实例来描述它的这个作用。这是一个基于Web的计算器仿真程序。用户可以像操作一个现实世界中的计算器一样，通过单击按钮输入数据和运算符号，当输入等号后在文本框中得到最终结果。它的原理很简单，就是记录用户输入的运算式字串，然后用Eval 函数把该字串转成运算式交给Javascript 执行即可。先手动建立一个简单的HTML 文件，只要<html>、head>和<body>元素即可。接着在<body></body>间插入以下html 代码，设置好该程序界面。
<input type="text" name=textdisp value="" ><br>
<input type="button" name=leftk value="(" onclick="yunsuan(value)">
<input type="button" name=rightk value=")" onclick="yunsuan(value)">
<input type="button" name=op1 value="1" onclick="yunsuan(value)">
<input type="button" name=op2 value="2" onclick="yunsuan(value)">
<input type="button" name=op3 value="3" onclick="yunsuan(value)">
<input type="button" name=op4 value="4" onclick="yunsuan(value)">
<br><p>
<input type="button" name=op5 value="5" onclick="yunsuan(value)">
<input type="button" name=op6 value="6" onclick="yunsuan(value)">
<input type="button" name=op7 value="7" onclick="yunsuan(value)">
<input type="button" name=op8 value="8" onclick="yunsuan(value)">
<input type="button" name=op9 value="9" onclick="yunsuan(value)">
<input type="button" name=op0 value="0" onclick="yunsuan(value)">
<br><p>
<input type="button" name=oppoint value="." onclick="yunsuan(value)">
<input type="button" name=opadd value="+" onclick="yunsuan(value)">
<input type="button" name=opsub value="-" onclick="yunsuan(value)">
<input type="button" name=opmul value="*" onclick="yunsuan(value)">
<input type="button" name=opdiv value="/" onclick="yunsuan(value)">
<input type="button" name=opeql value="=" onclick="yunsuan(value)">
<br><p>
<input type="button" name=cle value="restar" onclick="res()">
现在用IE6 打开它，就会得到如图所示的效果。再接再厉，现在在<head></head>中输入以下Javascript
代码：
<TITLE>test</TITLE>
<script language="javascript">
var expstring="";
var numstring="";
function yunsuan(btn){
if(btn=="=")
textdisp.value=eval(expstring);
else
{if(((btn>="0")&&(btn<="9"))||(btn=="."))
{numstring=numstring+btn;
textdisp.value=numstring;
}
else
numstring="";
expstring=expstring+btn;
}
}
function res(){
expstring="";
textdisp.value="";
numstring="";
}
</script>
这样，我们利用Eval 函数，仅仅十几行代码就做好了这个计算器。
转载：http://school.cfan.com.cn/pro/pother/2006-08-28/1156732532d14455.shtml
目前来看，JS框架以及一些开发包和库类有如下几个：Dojo 、Scriptaculous 、Prototype 、yui-ext 、Mochikit、mootools 、moo.fx 、jQuery。
Dojo （JS library and UI component ）：
Dojo是目前最为强大的j s框架，它在自己的Wiki上给自己下了一个定义，dojo是一个用JavaScript编写的开源的DHTML工具箱。dojo很想做一个“大一统”的 工具箱，不仅仅是浏览器层面的，野心还是很大的。Dojo包括ajax, browser, event, widget等跨浏览器API，包括了JS本身的语言扩展，以及各个方面的工具类库，和比较完善的UI组件库，也被广泛 应用在很多项目中，他的UI组件的特点是通过给html标签增加tag的方式进行扩展，而不是通过写JS来生成，dojo的API模仿Java类库的组织 方式。 用dojo写Web OS可谓非常方便。dojo现在已经4.0了，dojo强大的地方在于界面和特效的封装，可以让开发者快速构建一些兼容标准的界面。
优点：库相当完善，发展时间也比较长，功能强大，据说利用dojo的io.bind()可以实现comet，看见其功能强大非一般，得到IBM和SUN的支持。
缺点：文件体积比较大，200多KB，初次下载相当慢，此外，dojo的类库使用显得不是那么易用，j s语法增强方面不如prototype。
Prototype （JS OO library）：
是一个非常优雅的JS库，定义了JS的面向对象扩展，DOM操作API，事件等等，以prototype为核心，形成了一个外围的各种各样 的JS扩展库，是相当有前途的JS底层框架，值得推荐，感觉也是现实中应用最广的库类（RoR集成的AJAX JS库），之上还有 Scriptaculous 实现一些JS组件功能和效果。
优点：基本底层，易学易用，甚至是其他一些js特效开发包的底层，体积算是最小的了。
缺点：如果说缺点，可能就是功能是他的弱项
Scriptaculous （JS UI component based on prototype）：
Scriptaculous是基于prototype.js框架的JS效果。包含了6个js文件，不同的文件对应不同的js效果，所以说，如果底层用 prototype的话，做js效果用Scriptaculous那是再合适不过的了，连大名鼎鼎的digg都在用他。
优点：基于prototype是最大的优点，由于使用prototype的广泛性，无疑对用户书锦上添花，并且在《ajax in action》中就拿Scriptaculous来讲述js效果。
缺点：刚刚兴起，需要时间的磨练。
yui-ext (JS UI component)：
基于Yahoo UI的扩展包yui-ext是具有CS风格的Web用户界面组件 能实现复杂的Layout布局，界面效果可以和backbase媲美，而且使用纯javascript代码开发。真正的可编辑的表格Edit Grid，支持XML和Json数据类型，直接可以迁入grid。许多组件实现了对数据源的支持，例如动态的布局，可编辑的表格控件，动态加载的Tree 控件、动态拖拽效果等等。1.0 beta版开始同Jquery合作，推出基于jQuery的Ext 1.0，提供了更多有趣的功能。
优点：结构化，类似于java的结构，清晰明了，底层用到了Jquery的一些函数，使整合使用有了选择，最重要的一点是界面太让让人震撼了。
缺点：太过复杂，整个界面的构造过于复杂。
Mochikit ：
MochiKit自称为一个轻量级的js框架。MochiKit 主要受到 Python 和 Python 标准库提供的很多便利之处的启发，另外还缓解了浏览器版本之间的不一致性。其中的 MochiKit.DOM 尤其方便，能够以比原始 JavaScript 更友好的方式处理 DOM 对象。MochiKit.DOM 大部分都是针对 XHTML 文档定制的，如果与 MochiKit 和 Ajax 结合在一起，使用 XHTML 包装的微格式尤其方便。Mochikit可以直接对字符串或者数字格式化输出，比较实用和方便。它还有自己的 js 代码解释器。
优点：MochiKit.DOM这部分很实用，简介也是很突出的。
缺点：轻量级的缺点。
mootools ：
MooTools是一个简洁，模块化，面向对象的JavaScript框架。它能够帮助你更快，更简单地编写可扩展和兼容性强的JavaScript代码。Mootools跟prototypejs相类似，语法几乎一样。但它提供的功能要比prototypejs多，而且更强大。比如增加了动画特效、拖放操作等等。
优点：可以定制自己所需要的功能，可以说是prototypejs的增强版。
缺点：不大不小，具体应用具体分析。
moo.fx ：
moo.fx是一个超级轻量级的javascript特效库（7k）,能够与prototype.js或mootools框架一起使用。它非常快、易于使用、跨浏览器、符合标准，提供控制和修改任何HTML元素的CSS属性，包括颜色。它内置检查器能够防止用户通过多次或疯狂点击来破坏效果。moo.fx整体采用模块化设计，所以可以在它的基础上开发你需要的任何特效。
优点：小块头有大能耐。
缺点：这么小了，已经不错了。
jQuery：
jQuery是一款同prototype一样优秀js开发库类，特别是对css和XPath的支持，使我们写js变得更加方便！如果你不是个js高手又想写出优秀的js效果，jQuery可以帮你达到目的！并且简介的语法和高的效率一直是jQuery追求的目标。
优点：注重简介和高效，js效果有yui-ext的选择，因为yui-ext 重用了很多jQuery的函数。
缺点：据说太嫩，历史不悠久。
IMP-00017: 由于 ORACLE 的 600 错误，以下的语句失败
"CREATE PACKAGE BODY quest_soo_util wrapped"
IMP-00003: 遇到 ORACLE 错误 600
ORA-00600: 内部错误代码，参数: [16201], [], [], [], [], [], [], []
IMP-00017: 由于 ORACLE 的 600 错误，以下的语句失败
"CREATE PACKAGE BODY QUEST_SOO_PKG wrapped"
以上是imp导入Oracle是出现的错误。
转载，其他情况出现的ORACLE 的 600 错误：
这个错误是 drop 用户时产生的，用户无法 drop。既然如此，登录该用户删除其中的procedure，结果也出现了该错误。有个帖子介绍说这是 Oracle 的一个 bug（No. 2422726），并给出了解决办法。这里记录一下：
1. 错误现象：
SQL> show user
USER 为"SYS"
SQL> select * from v$version;
BANNER
------------------------------------------------------------
Oracle8i Release 8.1.6.0.0 - Production
PL/SQL Release 8.1.6.0.0 - Production
CORE 8.1.6.0.0 Production
TNS for 32-bit Windows: Version 8.1.6.0.0 - Production
NLSRTL Version 3.4.1.0.0 - Production
SQL> drop user hos_kf_hl cascade;
drop user hos_kf_hl cascade
*
ERROR 位于第 1 行:
ORA-00600: 内部错误代码，自变量: [16201], [], [], [], [], [], [], []
SQL> conn hos_kf_hl/test@qmyb
已连接。
SQL> drop procedure kill_session;
drop procedure kill_session
*
ERROR 位于第 1 行:
ORA-00600: 内部错误代码，自变量: [16201], [], [], [], [], [], [], []
2. 查询视图 procedure$，确认该错误：
SQL> select obj#,owner#,type# from sys.obj$ where name ='KILL_SESSION' and owner#=96;
OBJ# OWNER# TYPE#
---------- ---------- ----------
55491 96 7
SQL> select * from procedure$ where obj# = 55491;
OBJ# AUDIT$ STORAGESIZE OPTIONS
---------- -------------------------------------- ----------- ----------
3. 解决
SQL> insert into procedure$ values (55491, '----------------', null, 2);
1 row inserted
SQL> commit;
Commit complete
SQL> drop procedure kill_session;
过程已丢弃。
SQL> conn sys/password@s177 as sysdba
已连接。
SQL> drop user hos_kf_hl cascade;
用户已丢弃
|