语源科技BlogJava-哎诤

oracle数据库设计中varchar与char类型的区别

哎诤 — Mon, 08 May 2006 09:55:00 GMT

如题

哎诤 2006-05-08 17:55 发表评论

Weblogic域间调用EJB常见事务错误

哎诤 — Sat, 29 Apr 2006 08:21:00 GMT

前言

本人所在项目中，由于我们的系统将业务逻辑单独部署，以下称之为EJB层，和普通的WEB层相对独立。从 WEB 层调用 EJB 层，通过 Command 架构，其包含的 EJB 调用就是事务性质的，所以我们 EJB 层再调用其它第三方提供的 EJB 接口时，就经常会出现一些莫名其妙的错误，以下略作收集。

1 、错误现象（在被调用的 EJB 服务器屏幕上出现）：

<2005-1-20 下午 04 时 14 分 46 秒 CST>

<2005-1-20 下午 04 时 14 分 46 秒 CST> ] is not authorized to invoke startCommit on a transaction branch.>

分析：

这种异常是跨域传播事务造成的 . 一定要传播事务的话 , 必须设置域信任 , 没有其他办法 . 但是域信任有相关的安全隐患 , 当然对于大部分非关键业务应用来说也无所谓了 .

具体设置方法为， domain node --> View Domain-wide Security Settings --> Configuration --> Advanced --> Enable Generated Credential --> 在 Credential 中输入密码，两个 domain 的这个密码要完全一致，然后重新启动 server 就可以了。

2 、错误现象（在调用方的 EJB 屏幕上出现）：

<2005-11-4 下午 01 时 41 分 36 秒 CST>

and.ejb.TaxCommandBean.executeCommand(cn.com.jdls.foundation.architectures.command.commands.BaseCommand)],Xid=BEA1-0021A70EC385C5407B0E(31591114),Status=Committing,numRepliesOwedMe=0,numRepliesOwedOthers=0,seconds since begin=121,seconds left=0,XAServerResourceInfo[weblogic.jdbc.wrapper.JTSXAResourceImpl]=(ServerResourceInfo[weblogic.jdbc.wrapper.JTSXAResourceImpl]=(state=committed,assigned=ejbserver),xar=weblogic.jdbc.wrapper.JTSXAResourceImpl@1326f69,re-Registered = false),SCInfo[mydomain+ejbserver]=(state=committed),SCInfo[dmctais+app1]=(state=committing),properties=({weblogic.transaction.name=[EJB cn.com.jdls.foundation.architectures.command.ejb.TaxCommandBean.executeCommand(cn.com.jdls.foundation.architectures.command.commands.BaseCommand)], weblogic.jdbc=t3://92.16.16.43:6517}),local properties=({modifiedListeners=[]}),OwnerTransactionManager=ServerTM[ServerCoordinatorDescriptor=(CoordinatorURL=ejbserver+92.16.16.43:6517+mydomain+t3+, XAResources={},NonXAResources={})],CoordinatorURL=ejbserver+92.16.16.43:6517+mydomain+t3+): javax.transaction.SystemException: Timeout during commit processing

分析：

这种异常是由于 EJB 被调用方，通常具有记忆功能，对于调用它接口的远程 EJB 服务和相应的 IP 以及 Port 都会记录在内存，如果下次相同的 EJB 服务来调用它的时候，它就会检测内存中该 EJB 服务对应的 IP/Port 是否和当前的实际情况相符，如果不符的话，就会出现这种错误。

这种情况目前在我们系统中，碰到的两种典型的案例就是：一，我们的 EJB 服务器上有双网卡，本来调用某第三方的 EJB 接口很正常，但是有次禁用了其中一个没插网线的网卡后，就出现这种错误，因为被调用方 EJB 服务已经记住了我们的 EJB 服务对应的 IP 和 Port ；二、本来我们的 EJB 服务器，调用另一个第三方 EJB 接口也很正常，但是有次为了测试的需要，又在另外一台服务器上，复制了一份完全一样的系统环境，也连接到同一个第三方EJB 测试服务器进行测试，结果后一台调用的时候就出现了这种错误，因为被调用方 EJB 服务已经记住了我们的 EJB 服务，其对应的 IP/Port 应该是前一台服务器。

对于这种情况，简单的处理办法就是，将被调用方的 EJB 服务重启一下，则它内存中的记录就会清除，下次就会记住最新的 EJB 服务和相应的 IP/Port 。

但是针对我们系统来说，通常我们系统调用的第三方的 EJB 接口，往往不能随便重启第三方服务，所以变通的办法，就是将要使用的我们系统中，将涉及到的每个 WEBLOGIC 域服务器对应的 server 名字都改掉，这样被调用方就不会在内存中找到相应的记录，因此也就不会出现这种莫名的调用出错问题。同时将域根目录下的临时目录全部删除，再重新启动服务应该即可生效。

总结
以上所述都是本人所在项目碰到的问题，可能并不一定具有共性，也不全面，所以大家碰到的莫名其妙的错误，也希望贴出来，共享看看

哎诤 2006-04-29 16:21 发表评论

明天据说要去太湖三山岛

哎诤 — Fri, 21 Apr 2006 09:40:00 GMT

公司一拨人去活动，似乎明天要下雨

哎诤 2006-04-21 17:40 发表评论

不同应用系统间数据交互方式

哎诤 — Wed, 19 Apr 2006 10:46:00 GMT

    其实仔细分析我们开发的各种软件，其实质可以说都是以一定的控制逻辑进行某种数据处理的过程，而数据处理不免涉及到数据的交互问题，一个系统内部当然需要进行数据交互，不同的系统之间也需要进行数据交互，否则就成了一个个的信息孤岛，以下就是分析不同的系统间数据交互的几种典型方式，以及演变过程。
    最早也是最通用的一种方式，就是通过文件方式进行系统间数据交互，通过定义好文件交互的格式，使双方的系统都能识别，来满足交互的要求。这种方式虽然很古老，但确实相当有用，不少的系统都是这么干的，而且这种方式有一个很大的好处，就是可以在异构系统间进行交互，甚至跨越平台的限制。不同的平台间通过文件交互的话，由于无法直接进行文件共享，所以通常采用FTP进行文件交互，但是这会带来一个问题，文件需要以阻塞方式进行读写，否则会引起冲突或者丢失。
    文件交互方式最大的缺点，就是交互不够实时，很难应付同步数据交互，socket方式的出现解决了这个问题，s ocket方式更准确的说应该是一种通信协议，不过确实可以用于数据交互，通过在双方系统指定IP和Port的套接字上进行数据传输。这种方式也是需要系统双方自己定义交互格式，而且是以字节的方式进行定义，发送方需要将数据组织成指定的socket报文，接收方又需要根据报文格式，进行相应的解析，才能转到相应的处理，这也是socket方式最大问题，实现起来相当繁琐。
    在socket基础上，引入成熟的HTTP、UDP等通信协议，作为数据交互的基础，利用这些协议的特点，定义交互格式相对就简单多了，无须纠缠于字节长度，只要按照通用的http报文格式组织数据即可。不过郁于通信层交互方式的特点，还是需要接受方先解析数据后，再转向自己的内部流程进行处理，那有没有一种机制，就是支持一个系统能够直接调用另一个系统提供的方法呢。
    这就是RPC--远程过程调用机制出现的原因，通过RPC一个系统能够直接调用另一个系统提供的方法，其核心就是将数据交互从通信层上身到表示层，让使用者无须关心具体的通信实现。最早的实现方式就是CORBA，然后是微软的COM/COM+机制。前几年ASP流行的时候，就曾经有一种很经典的开发模式:ASP+COM+数据库，在COM中实现对数据库的访问，以及逻辑控制，然后在ASP页面中调用COM提供的方法，这种方式在安全性和可重用性上有明显的提高。
    当JAVA时代到来后，当然不会忘记RPC机制，早先是RMI-远程调用接口，然后随着J2EE规范的成熟，其EJB技术也是大行其道，不过RMI和EJB都有一个显著的缺陷，只能在JAVA构建的应用系统间进行数据交互，对于非JAVA系统则无法使用了。
    因此早两年java开始推出WebSevices机制，引入服务方和客户方的概念，通过标准的服务发布方式，以及标准的调用方式，使得在异构系统间进行实时的数据交互不再有问题，其底层的通信方式还是采用的HTTP协议。
    关于WebServices的具体内容参见4月17日的描述。

哎诤 2006-04-19 18:46 发表评论

周末从书店Get到...

哎诤 — Mon, 17 Apr 2006 11:23:00 GMT

周末无聊到书店去看书，也算有所收获，如下：
1、JSP基础中，不知大家有没有注意到，有两种include其他页面的方法，一种是通过“<%@ include file="" %>”，另一种是通过“”实现的，二者之间的区别在于：首先，前者的包含，只能是静态的包含，也就是说file参数指向的页面不能是表达式，而后者则可以是某个页面也可以是表达式（如<%=Expression%>）；其次，如果想传递参数给要include的页面，前者只能通过在url中传递，而且不能有表达式/变量，而后者则同时还可以通过“”来传递参数。
2、针对WebServices，如果单纯从概念上来说，比较容易让人犯浑，个人觉得有本书上说的特别简明：WebServices可以理解成HTTP+XML+RPC，也就是说底层的传输协议，还是基于http协议的，然后通过将XML作为传输内容，完成远程过程调用，也就是RPC了。换句话说，一个WEB服务就是提供了一组过程或方法，让调用者可以通过internet访问到，并且能够进行远程调用，至于具体的实现方式则是通过http协议传输xml数据来完成的。最常见的WebServices规范就是SOAP--简单对象访问协议，其核心就是将服务的发布通过一个XML文件进行描述-WSDD，调用服务方法传入的参数以及方法返回的结果也用XML实现，如果传入的参数和返回的结果涉及到JAVA对象的话，就需要用到对象序列化（Serialize）和反序列化的概念，只有序列化后才能通过http协议进行传输。另外还有一种常见的规范就是REST，其和SOAP最大的区别就在于，调用远程方法的时候，不能通过XML来传输参数，只能在调用的URI中指定参数，因此我估计这种规范，将不支持对象最为远程方法的参数。
3、关于AJAX，又翻了一遍邮电出版社新出的那本《AJAX 基础》，理解缩写就基本理解了AJAX的应用范围和特点了 --Asyncronize JavaScript and XmlHttpRequest，也就是说通过JavaScript调用XmlHttpRequest来实现异步方式与 Web服务器进行交互的过程。
--
--
这段时间有个感觉越来越强烈：开源软件好是好，但是个人感觉有一个最大的缺点--就是随意性，特别是体现在版本兼容上，如果一个项目需要用到几种开源软件，比如说IDE用Eclipse，然后再来点插件，App Server的版本，然后还要照顾到JDK版本，如果再用到Ant/CVS辅助等等，那就真的有点头大了。所以说开源到统一，统一又演变成垄断，这个过程真的是相当有意思

哎诤 2006-04-17 19:23 发表评论

依赖、依赖倒转原则、IoC/依赖注入、以及在Spring中的实现

哎诤 — Thu, 06 Apr 2006 11:49:00 GMT

    去年火得不行的Spring框架，一般的书籍都会从IoC和AOP开始介绍起，这个IoC概念，个人感觉资料里都写得让人看得有些痛苦，所谓IoC，就是控制反转（Inversion of Control）的缩写，这个大家都知道，但是个人觉得理解这个概念，最好应该从依赖（dependence）开始讲起，以下观点由此展开：
    所谓依赖，举个例子说明，一个类Person，另一个类Car，如果Person的某个方法比如说drive，需要引用Car，则称Person类依赖于Car类，延伸到对象，这种依赖关系依然成立，比如说Person类的对象boy依赖于Car类的对象toyota。再讲讲这个drive方法的实现，假定代码如下：
Public Person{
...
public void drive(){
Car toyota=new Car("TOYOTA");
toyota.挂档;
toyota.踩油门;
toyota.打方向;
}
}
    这其中的依赖关系，就导致了对象boy需要负责对象toyota的创建，甚至是整个生命周期的管理，而这样显然会带来耦合度高，不易维护等缺点，比如说要让这个男孩驾驶一辆Audi，则还需要修改类Person的代码。
    因此在java的设计理论中就提出了一条非常著名的原则，依赖倒转原则（Dependence Inversion），其核心思想就是要将这种具体类之间的依赖，尽量转换成抽象依赖，也就是说类Person应该依赖于抽象类ICar，而不是具体的类Car，这里java就大力推荐了抽象和接口的使用，至于抽象和接口之间的区别，见上一篇blog。
    这个依赖倒转原则在设计模式也体现得非常多，比如说工厂模式和构建模式，个人认为控制反转IoC，其实也可以认为是实现这个原则的一种设计模式。控制反转，其中的控制这个词一直不太理解是什么意思，不过控制反转的另外一种说法也就是依赖注入（dependence injection），个人觉得更易于理解。还是以上文的boy与toyota为例，其核心就是要将boy依赖的对象toyota注入到boy中去，而无需boy自己去引用toyota，这个注入的过程，通常是由一个控制程序来完成的，无需对象去关心，举例如下：
Public Person{
private ICar car;
public Person(ICar onecar){
car=onecar;
}
public void drive(){
car.挂档;
car.踩油门;
car.打方向;
}
}
    这个时候，进行注入并且调用的过程，就很简单了，如下：
Toyota toyota=new Toyota();
Person boy=new Person(toyota);
boy.drive();
    注：这里我们假定，Toyota类是ICar接口类的一个具体实现。
    这个例子就演示一个最简单的注入方式的例子，也就是构造子方式注入，通过将依赖对象注入到对象的构造子中来实现。另外还有一种常用的注入方式，就是属性方式注入，意思就是通过将依赖对象注入到对象的属性中来实现，还是以boy和toyota的例子说明，如下：
Public Person{
private ICar car;
public Person(){
}
public void drive(){
car.挂档;
car.踩油门;
car.打方向;
}
public ICar getCar(){
return this.car;
}
public void setCar(ICar onecar){
car=onecar;
}
}
    这个时候，进行注入并且调用的过程，就变成如下所示：
Toyota toyota=new Toyota();
Person boy=new Person();
boy.setCar(toyota);
boy.drive();
    至此依赖注入的概念应该比较清楚了，再来看看在Spring中如何实现IoC的，看看Spring如何作为一个成熟的IoC容器，Spring中其实主要通过两个概念来实现IoC，首先通过XML配置文件，将对象和依赖对象都配置到某个XML文件中，当然该XML文件需要符合Spring指定的规范，然后通过架构中的BeanFactroy类，来自动实现上文所述注入过程，还是以boy与toyota为例，如下：
首先，Person类还是一样的，
然后xml配置文件增加点东西-（假定为bean.xml）：
xml version="1.0" encoding="GBK"?>
DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
   <bean id="oneCar" class="Toyota">
   bean>
   <bean id="onePerson" class="Person">
       <property name="car">
           <ref bean="oneCar">ref>
       property>
   bean>
beans>
最后，调用的过程，就变成如下：
BeanFactory factory=new XmlBeanFactory("bean.xml");
Person boy=(Person )factory.getBean("onePerson");
boy.drive();
--不知是否讲清楚了，呵呵

哎诤 2006-04-06 19:49 发表评论

抽象类与接口类的区别

哎诤 — Wed, 05 Apr 2006 09:10:00 GMT

随着java社区中，各种框架大行其道，以及各种设计模式思想的深入人心，越来越多的程序员已经不再满足于简单的java class编码，个人观点，我认为很多框架和设计模式其实质都用到了抽象和接口的概念。
所以回头看了看基础理论，关于抽象和接口的内容，其实二者总的来说还是蛮相似的，都是包含了抽象方法，这些方法需要实现类去实现，因此二者都不能被实例化。至于不同点则主要存在于两个方面：首先，由于接口是用来实现的而抽象类只能被继承，又因为java中对继承有限制，不能进行多类继承，也就是说一个类只能继承自某个抽象类，但是可以实现多个接口类；其次好像是，接口类中只能有抽象方法，而抽象类中还可以有一定的具体方法，而且可以供子类调用。

哎诤 2006-04-05 17:10 发表评论

最怕有时间的时候没东西可写，有东西写的时候又没时间

哎诤 — Tue, 04 Apr 2006 06:13:00 GMT

       这两天天气热起来了，大家也都有点思春的意思了，今天办公室，讨论出去活动的方案，结果“众口难调”这个成语再次得到印证，组织者列出了4个可选方案，结果从开始报名的30人，到最后只有10多个人表示要去，而且就其中的两种选择，展开了两轮投票，哈哈，好难。
------------------------------------------------------------------------------
------------------------------------------------------------------------------
       称此机会，我回忆昨天晚上看的书--JSP技术手册，我发现很久没有看基础的理论，原来好多东西都不知道的啊，原来都只会应用，有些以前很清楚的也有点模糊了。
       比如说http请求中，get和post的区别：后者的请求内容不放在url中，而是在http请求的body中，请求参数放在url中，会有长度限制，不能超过255个字符，而且不安全，因为是显式的。
       又比如jsp基础语法中，jsp元素一共有三种：指令元素（directive），脚本元素（scripting），行为元素（a ction）。其中指令元素以“<%@ %>”为标志，也是包含三个：page、include和taglib，其中page元素有11个属性，都是经常用的，比如说什么import等等。脚本元素也是三类：申明、脚本段和表达式，申明以“<%! %>”为标志，脚本段以“<% %>”为标志，表达式以“<%= %>”为标志。最后行为元素以“<%jsp: %>”为标志。
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
       这些大家都知道，但是有两个小问题，却未必都知道，首先针对注释（comments）有几种形式，不同的形式间有什么区别呢？有两种形式，其一是不影响jsp执行结果，纯粹是为了增加页面可读性的注释，但在客户浏览器上可以看到源码，以“<！——     ——>”为标志；另外一种则纯粹是面向程序员的注释，在客户浏览器上看不到的，以“<% --或者/* */ %>”为标志。
       还有一个问题就是“<%! %>”类型的申明元素和普通脚本段中的变量申明有区别吗，有什么区别呢？区别就在于前者申明的变量是在一个jsp页面的全局变量，也就是所有访问这个jsp页面的进程，都共享这个变量，因此一般很少用这种方式来申明变量，哈哈。

哎诤 2006-04-04 14:13 发表评论

java的赋值

哎诤 — Mon, 03 Apr 2006 10:48:00 GMT

在java中，赋值和clone的区别，相信java程序员都知道，就是对于前者，被赋值的变量指向的是内存中的同一块地址，而对于后者，则是为clone的变量分配一块新的内存，也就是指向一个新的对象。
基于此，很容易得出一个结论，就是对于被赋值的变量，如果改变该变量指向的对象，则赋值的变量，也会指向这个新的对象。但是java中有定义了很多类型，这些类型的对象一旦创建，即为只读，也就是不满足上面的结论，最常见的例子就是String类型，譬如如下代码：
String s1="aa";
String s2="aaaa";
s2=s1;
s1="aabb";
System.out.println(s1);
System.out.println(s2);
结果将是：
aabb
aa
而不是想象中的：
aabb
aabb

哎诤 2006-04-03 18:48 发表评论