BlogJava-谈笑有鸿儒，往来无白丁-随笔分类-java命令学习

把你的应用设置为JBOSS的默认应用

坏男孩 — Thu, 06 Dec 2007 07:45:00 GMT

1、删除jbossweb-tomcat55.sar 里面的ROOT.WAR
2、把你的应用放在jboss-4.0.5.GA\server\default\deploy\下面
   比如名称为MYAPP.war
3、新建一个jboss-web.xml

           /

4、重新启动jboss
我的环境是jboss-4.0.5.GA

最近要研究一下JBOSS的一系列产品：

坏男孩 2007-12-06 15:45 发表评论

Nod32与CVSNT不兼容

坏男孩 — Tue, 23 Oct 2007 01:34:00 GMT

具体的错误是这样的：安装完成了CVS服务器以后，客户端登录的时候报

Error reading from server <192.168.0.108>: -1: Unknown error

解决的方法是这样的：NODE 32里面IMON点击后－－>

右边窗口点击SETUp按钮－－>

弹出的窗口里面Miscellaneous－－>

ExcluSion－－>

Edit-->

C:\Program Files\CVSNT\cvsservice.exe－－>添加上就ok了

你的CVS就能登录了！！！

坏男孩 2007-10-23 09:34 发表评论

jira如何配置使用LDAP认证

坏男孩 — Fri, 28 Sep 2007 05:16:00 GMT

今天的手又痒痒了，觉得应该是时候写点东西了。
这一周的时间在忙活LDAP认证，这个已经不是什么新鲜名词了概念就免了；
之所以学LDAP,还是为了SSO和PORTAL。
经过一周的时间，搭建好了LDAP服务器，用的开源的APACHE的DS，还有APACHE的studio；配置起来非常的简单主要掌握几个要点就好了：
1、server.xml的配置
Adding your own partition resp. suffix
添加自己的数据格式




然后查询examplePartitionConfiguration把他的bean配置重新复制一份需要修改几个地方
      class="org.apache.directory.server.core.partition.
                            impl.btree.MutableBTreePartitionConfiguration">
Next give the partition a name and change the suffix to o=mydomain


      objectClass: top
      objectClass: domain
      objectClass: extensibleObject
      dc: example ---> o:mydomaim


重新启动apache ds；

2、LDIF文件的格式
第一步：组织结构以及管理员信息
dn: o=chinantn,dc=com
objectclass: organization
objectclass: top
o: chinantn

dn: cn=manager,o=chinantn,dc=com
objectclass: organizationalPerson
objectclass: person
objectclass: top
cn: manager
sn: badboyryan
userpassword:: c2VjcmV0

dn: ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: departments

dn: ou=market,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: market

dn: ou=developer,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: developer

dn: ou=service,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: service

dn: ou=finance,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: finance

dn: ou=directorate,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: directorate

dn: ou=engineer,ou=departments,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: engineer

dn: ou=partners,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: partners

dn: ou=customers,ou=partners,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: customers

dn: ou=suppliers,ou=partners,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: suppliers

dn: ou=employees,ou=partners,o=chinantn,dc=com
objectclass: organizationalUnit
objectclass: top
ou: employees

第二步：人员信息

dn: uid=scf,ou=developer,ou=departments,o=chinantn,dc=com
objectClass: person
objectClass: uidObject
objectClass: organizationalPerson
objectClass: top
cn: sss
sn: scf
uid: scf
userpassword:: e01ENX1YTXNwY1ZWVFhUbFh1K1M0QllLY0hBPT0=
人员信息就少写一点了，有空你再慢慢的补充上。
第三步：导入LDIF文件，这个时候LDAP服务器里面就有了一棵树（组织结构）
第四步：被指jira让他利用LDAP认证来登录系统，如下图所示：

经过上面的折腾就完成了一个通过LDAP认证的小例子了。
注意转帖的时候带上：
©所有：http://badboyryan.blogjava.net
随意的转帖不受法律约束。

坏男孩 2007-09-28 13:16 发表评论

LDAP:error code 一览表

坏男孩 — Wed, 26 Sep 2007 01:30:00 GMT

0 LDAP_SUCCESS Success
1 LDAP_OPERATIONS_ERROR Operations error
2 LDAP_PROTOCOL_ERROR Protocol error
3 LDAP_TIMELIMIT_EXCEEDED Timelimit exceeded
4 LDAP_SIZELIMIT_EXCEEDED Sizelimit exceeded
5 LDAP_COMPARE_FALSE Compare false
6 LDAP_COMPARE_TRUE Compare true
7 LDAP_STRONG_AUTH_NOT_SUPPORTED Strong authentication not supported
8 LDAP_STRONG_AUTH_REQUIRED Strong authentication required
9 LDAP_PARTIAL_RESULTS Partial results
16 LDAP_NO_SUCH_ATTRIBUTE No such attribute
17 LDAP_UNDEFINED_TYPE Undefined attribute type
18 LDAP_INAPPROPRIATE_MATCHING Inappropriate matching
19 LDAP_CONSTRAINT_VIOLATION Constraint violation
20 LDAP_TYPE_OR_VALUE_EXISTS Type or value exists
21 LDAP_INVALID_SYNTAX Invalid syntax
32 LDAP_NO_SUCH_OBJECT No such object
33 LDAP_ALIAS_PROBLEM Alias problem
34 LDAP_INVALID_DN_SYNTAX Invalid DN syntax
35 LDAP_IS_LEAF Object is a leaf
36 LDAP_ALIAS_DEREF_PROBLEM Alias dereferencing problem
48 LDAP_INAPPROPRIATE_AUTH Inappropriate authentication
49 LDAP_INVALID_CREDENTIALS Invalid credentials
50 LDAP_INSUFFICIENT_ACCESS Insufficient access
51 LDAP_BUSY DSA is busy
52 LDAP_UNAVAILABLE DSA is unavailable
53 LDAP_UNWILLING_TO_PERFORM DSA is unwilling to perform
54 LDAP_LOOP_DETECT Loop detected
64 LDAP_NAMING_VIOLATION Naming violation
65 LDAP_OBJECT_CLASS_VIOLATION Object class violation
66 LDAP_NOT_ALLOWED_ON_NONLEAF Operation not allowed on nonleaf
67 LDAP_NOT_ALLOWED_ON_RDN Operation not allowed on RDN
68 LDAP_ALREADY_EXISTS Already exists
69 LDAP_NO_OBJECT_CLASS_MODS Cannot modify object class
70 LDAP_RESULTS_TOO_LARGE Results too large
80 LDAP_OTHER Unknown error
81 LDAP_SERVER_DOWN Can't contact LDAP server
82 LDAP_LOCAL_ERROR Local error
83 LDAP_ENCODING_ERROR Encoding error
84 LDAP_DECODING_ERROR Decoding error
85 LDAP_TIMEOUT Timed out
86 LDAP_AUTH_UNKNOWN Unknown authentication method
87 LDAP_FILTER_ERROR Bad search filter
88 LDAP_USER_CANCELLED User cancelled operation
89 LDAP_PARAM_ERROR Bad parameter to an ldap routine
90 LDAP_NO_MEMORY Out of memory

坏男孩 2007-09-26 09:30 发表评论

jms消息类型（转）

坏男孩 — Mon, 06 Aug 2007 07:45:00 GMT

在JMS1.1规范中规定了5种JMS消息类型,分别如下:

1.创建一个TextMessage

TextMessage message;

message = session.createTextMessage();

2.解包一个TextMessage

去解包一个TextMessage类型的消息，客户端可以使用Message.getText方法：

String stockInfo;

stockInfo = message.getText();

3.创建一个BytesMessage

byte[] stockData;

BytesMessage message;

message = session.createBytesMessage();

message.writeBytes(stockData);

4.解包一个BytesMessage

当接收到一个ByteMessage时，可以使用下面的方式来解包：

byte[] stockInfo;

int length;
length = message.readBytes(stockData);
消息体被拷贝到字节数组，客户端程序可以读取这个树组来解释数据。

5.创建一个MapMessage

MapMessage message;

message = session.createMapMessage();
...其他代码
message.setString("Name", "CN-Java");

message.setDouble("Value", stockValue);

message.setLong("Time", stockTime);

message.setDouble("Diff", stockDiff);
message.setString("Info", "Recent server announcement causes market interest");

6.解包一个MapMessage

stockName = message.getString("Name");

stockDiff = message.getDouble("Diff");

stockValue = message.getDouble("Value");

stockTime = message.getLong("Time");
如果你想得到整个元素的列表，可以使用MapMessage.getMapNames方法来获得。

7.创建一个StreamMessage

和MapMessage相似，一个应用程序可以按序列发送多个字段到一个消息中，这些字段都是原始类型的，要做这些，你可以使用一个StreamMessage，

message.writeString(stockName);

message.writeDouble(stockValue);

message.writeLong(stockTime);
message.writeDouble(stockDiff);
message.writeString(stockInfo);

8.解包一个StreamMessage

StreamMessage中的元素必须按照被写入的顺序读出：

stockName = message.readString();

stockValue = message.readDouble();

stockTime = message.readLong();

stockDiff = message.readDouble();

stockInfo = message.readString();

9.创建一个ObjectMessage

ObjectMessage message;

message = session.createObjectMessage();

message.setObject(stockObject);

10.解包ObjectMessage

去解包ObjectMessage,使用ObjectMessage.getObject得到对象，一但对象被取出来，客户端程序使用Java造型语句将对象还原成原始对象。
StockObject stockObject;
stockObject = (StockObject)message.getObject();

坏男孩 2007-08-06 15:45 发表评论

今天复习一下Eclipse里面的快捷键

坏男孩 — Tue, 17 Jul 2007 02:35:00 GMT

关于文本编辑，里面常用的快捷键；

1、查看eclipse的快捷键

Ctrl +Shift+L

2、修改

Ctrl+Shilf+L+L

这样就可以自己定义快捷键了！

坏男孩 2007-07-17 10:35 发表评论

Ireport设计jasper报表提高java报表开发效率

坏男孩 — Thu, 05 Jul 2007 03:21:00 GMT

今天发现了小家碧玉，jasper，用ireport2.0设计报表，大致流程是这样的：

1、设置classpath把mysql的jdbc驱动加到里面；

2、连接数据库；

3、设定动态链接

4、报表查询

5、设计报表

6、编译，选择jrviewer

7、在设计报表的时候把字段的属性里面，TExtField里面的stretch with over flow勾上不然不显示啊

common里面的stretch type选择relative to tallest object

8、执行报表（使用动态连结）

9、看到效果了吗？

10、使用的时候在jsp里面调用.jasper文件啊！！！

坏男孩 2007-07-05 11:21 发表评论

JBuilder2007企业版破解及汉化方法

坏男孩 — Thu, 21 Jun 2007 02:08:00 GMT

JBUILDER2007企业版下载

支持迅雷http://altd.borland.com/akdlm/download/jbuilder/JBuilder_2007/Enterprise/JBuilder2007_enttrial.zip

破解补丁的两个文件

http://www.china-polo.com.cn/[JBuilder.2007.].sanct6.jar

http://www.china-polo.com.cn/[JBuilder.2007.].sanctuary.jar

这两个文件放到csdn的下载频道了攒点积分

http://download.csdn.net/user/songchaunfang

破解说明：
将两个jar文件复制到X:\JBuilder2007\jbuilder\eclipse\plugins\com.borland.sanctuary.client.core_6.0.0 目录下（X:\JBuilder2007　为您的安装目录）。

官方中文包下载地址(支持迅雷):
http://eclipse.cdpa.nsysu.edu.tw/downloads/drops/L-3.2.1_Language_Packs-200609210945/NLpack1-eclipse-SDK-3.2.1-win32.zip

中文包安装方法:把中文包里的两个目录:license和features 解压到 X:\JBuilder2007\jbuilder\eclipse\
目录下

坏男孩 2007-06-21 10:08 发表评论

java中的Boxing和unboxing

坏男孩 — Tue, 12 Jun 2007 14:39:00 GMT

邢红瑞发表于 2007-6-8 16:00:58

最近给替一个朋友出的几道java的面试题，主要是面试java高级工程师，报酬就是晚饭，已经沦落的卖艺的境地。
题目很简单
   Integer i1 = 100;
   Integer i2 = 100;
   Integer i3 = 1000;
   Integer i4 = 1000;
   System.out.println(i1==i2);
   System.out.println(i3==i4);
很遗憾，没有一个答对的，正确答案是
true
false
如果面试者写这样的写是错误的，就算通过。
这个的原因要从java5的Boxing和unboxing谈起，boxing就是封装基本类型的对象，unboxing就是转换对象到基本类型。
Integer, Long, Float, Double, Short, Character etc.都是这样的类型他们是immutable。
Boxing
在jdk1.4.2中，
必须是// Assigning primitive type to wrapper type
   Integer iWrapper = new Integer(10);
java5中
// Assigning primitive type to wrapper type
   Integer iWrapper = 10;
unboxing
在jdk1.4.2中，
int iPrimitive = iWrapper.intValue();
java5中
int iPrimitive = iWrapper;
下面是基本类型作为对象存储的范围，
boolean values true and false
All byte values
short values between -128 and 127
int values between -128 and 127
char in the range \u0000 to \u007F
如果int values between -128 and 127，VM使用相同的对象，否则创建新的对象。
所以这段代码，大家不要奇怪
System.out.println(0L == 0);
System.out.println(((Long)0L).equals(0));
第二行代码是0不等于0
因为大家犯这样的一个错误
static private final String LOCK = "LOCK";
void testMethod() {
    synchronized(LOCK) {
    ...
    }
}
应该用new，不要直接=，对于int，最好使用int a[0] ，因为array也是对象，不像Integer，a[0]的值可以改变。

坏男孩 2007-06-12 22:39 发表评论

如何通过java或jsp向数据库存取二进制图片

坏男孩 — Fri, 01 Jun 2007 00:38:00 GMT

前几天突然看到学校音乐站上的图片原来是存储在数据库上的,是二进制而不是使用路径保存的,在网上招了找发现大多介绍的都是hph方式,在这里做个总结,首先要存储二进制文件在数据库中要搞清楚下面几个内容:
1 mysql存储大容量的二进制文件的格式是blob，其实除了图片还可以存别的
2 要向数据库存储二进制的文件一定要把要存储的数据转换成二进制流
废话就不多说了，大家看看代码很容易明白，先来看一个app程序，当然首先您要在数据库中先建立一个用于保存图片的表和相应的列，数据格式为blob
package com.lizhe;
import java.io.*;
import java.sql.*;
public class PutImg {
public void putimg() {
try {
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url = "jdbc:mysql://localhost/img?user=root&password=root&useUnicode=true&characterEncoding=gbk";
Connection conn = DriverManager.getConnection(url);
Statement stmt = conn.createStatement();
//stmt.execute("insert into imgt (id) values (5)");
stmt.close();
PreparedStatement pstmt = null;
String sql = "";
File file = new File("c:\blog.jpg");
InputStream photoStream = new FileInputStream(file);
//sql = " UPDATE imgt SET img = ? ";

sql = "INSERT INTO imgtable (img) VALUES (?)";

pstmt = conn.prepareStatement(sql);
pstmt.setBinaryStream(1, photoStream, (int) file.length());
pstmt.executeUpdate();
pstmt.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String args[]){
PutImg pi=new PutImg();
pi.putimg();
}
}

InputStream photoStream = new FileInputStream(file);
可以很清楚的看到我们首先把一个图片文件(当然也可以是别的什么文件)转换成了一个二进制输入流
pstmt.setBinaryStream(1, photoStream, (int) file.length());
这个方法建议大家去查一下API文档,第一个参数是通配符位置没的说,第二个参数是流,这和以往的string类型的参数不太一样,我刚看到的时候也觉得豁然开朗了,但是到这里还没完,不同于以往的字符串参数,这里我们还需要第三个参数来设置这个流的长度,这里也就是这个文件的长度,导出数据库中的sql,一切都清楚了
INSERT INTO `m_diy` VALUES (2,? JFIF HH?? ExifMM* b j ( 1 r 2 ?i H H Adobe Photoshop CS Windows2007:03:18 23:08:15 ? ??? ? ........等等
其实就是将文件先转换成了二进制的流,然后插入到了sql语言中,向数据库写入了很长很长的一段sql语句

然后我们再来写一个app程序将这个文件读出来,存储成一个图片文件
package com.lizhe;
import java.io.*;
import java.sql.*;
class GetImg {

private static final String URL = "jdbc:mysql://localhost/img?user=root&password=root&useUnicode=true&characterEncoding=gbk";
private Connection conn = null;
private PreparedStatement pstmt = null;
private ResultSet rs = null;
private File file = null;

public void blobRead(String outfile, int picID) throws Exception {
FileOutputStream fos = null;
InputStream is = null;
byte[] Buffer = new byte[4096];
try {
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
conn = DriverManager.getConnection(URL);
pstmt = conn.prepareStatement("select img from imgt where id=?");
pstmt.setInt(1, picID); // 传入要取的图片的ID
rs = pstmt.executeQuery();
rs.next();
file = new File(outfile);
if (!file.exists()) {
file.createNewFile(); // 如果文件不存在，则创建
}
fos = new FileOutputStream(file);
is = rs.getBinaryStream("img");
int size = 0;

while ((size = is.read(Buffer)) != -1) {
// System.out.println(size);
fos.write(Buffer, 0, size);
}
} catch (Exception e) {
System.out.println( e.getMessage());
} finally {
// 关闭用到的资源
fos.close();
rs.close();
pstmt.close();
conn.close();
}
}
public static void main(String[] args) {
try {
GetImg gi=new GetImg();
gi.blobRead("c:/getimgs/1.jpg", 5);
} catch (Exception e) {
System.out.println("[Main func error: ]" + e.getMessage());
}
}
}
这里需要注意的是
is = rs.getBinaryStream("img");
img是数据库中相应的列名,其实和rs.getString()方法差不多,只不过这个方法是读取二进制流的
最后在帖两个bs系统上用的文件给大家参考
通过struts的action向数据库写入二进制图片
/*
* Generated by MyEclipse Struts
* Template path: templates/java/JavaClass.vtl
*/
package com.lizhe.struts.action;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.Statement;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.upload.FormFile;
import com.lizhe.struts.form.UpimgForm;
/**
* MyEclipse Struts
* Creation date: 05-18-2007
*
* XDoclet definition:
* @struts.action path="/upimg" name="upimgForm" input="/userhomepage.jsp"
* @struts.action-forward name="userhome" path="/userhomepage.jsp" redirect="true" contextRelative="true"
*/
public class UpimgAction extends Action {
/*
* Generated Methods
*/
/**
* Method execute
* @param mapping
* @param form
* @param request
* @param response
* @return ActionForward
* @throws IOException
* @throws FileNotFoundException
*/
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) throws FileNotFoundException, IOException {
UpimgForm upimgForm = (UpimgForm) form;// TODO Auto-generated method stub

FormFile file=upimgForm.getFile();
InputStream is=file.getInputStream();

try {
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url = "jdbc:mysql://localhost/blog?user=root&password=root&useUnicode=true&characterEncoding=gb2312";
Connection conn = DriverManager.getConnection(url);
Statement stmt = conn.createStatement();
//stmt.execute("insert into img (id) values (5)");
stmt.close();
PreparedStatement pstmt = null;
String sql = "";
//File file = new File("c:\blog.jpg");
//InputStream photoStream = new FileInputStream(file);
//sql = " UPDATE imgt SET img = ? ";

sql = "INSERT INTO img (img) VALUES (?)";

pstmt = conn.prepareStatement(sql);
pstmt.setBinaryStream(1, is, (int) file.getFileSize());
pstmt.executeUpdate();
pstmt.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
}

return mapping.findForward("userhomepage");
}
}
和app的方式几乎是一样的
第二个文件是通过jsp将数据库中的图片显示在页面上
这个有些不同
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*" %>
<%@ page import="java.util.*"%>
<%@ page import="java.text.*"%>
<%@ page import="java.io.*"%>
<%@ page import="java.awt.*"%>

<%
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url="jdbc:mysql://localhost/img?user=root&password=root";
Connection con = DriverManager.getConnection(url);
String sql = "select * from imgt where id=5";
Statement stmt = con.createStatement();

ResultSet rs = stmt.executeQuery(sql);
if(rs.next()) {
InputStream in = rs.getBinaryStream("img");
ServletOutputStream op = response.getOutputStream();
int len;
byte[] buf=new byte[1024];
while((len= in.read(buf))!=-1) {
op.write(buf, 0, len);
}
op.close();
in.close();
}

rs.close();
stmt.close();
con.close();
%>

坏男孩 2007-06-01 08:38 发表评论

基于WEB应用开发的java程序员必备工具

坏男孩 — Fri, 18 May 2007 01:29:00 GMT

一个好的程序员除了具备扎实的基本功外，还应该具有更为灵活的逻辑思维与判断能力。除此之外，撑握一些行之有效的辅助工具也很重要。工欲善其事,必先利其器。有好的工具辅助，所做的工作将事半功倍。下面向大家推荐基于WEB应用开发的java程序员应该必备的辅助开发工具。

　　1，Java剖析工具　--　profiler
　　是一个全功能的Java剖析工具（profiler），专用于分析J2SE和J2EE应用程序。它把CPU、执行绪和内存的剖析组合在一个强大的应用中。JProfiler可提供许多IDE整合和应用服务器整合用途。JProfiler直觉式的GUI让你可以找到效能瓶颈、抓出内存漏失 (memory leaks)、并解决执行绪的问题。它让你得以对heap walker作资源回收器的root analysis，可以轻易找出内存漏失；heap快照（snapshot）模式让未被参照（reference）的对象、稍微被参照的对象、或在终结（finalization）队列的对象都会被移除；整合精灵以便剖析浏览器的Java外挂功能。
下载地址：http://www.ej-technologies.com/download/overview.html

　
　　2，冗余代码检查　--　Simian
　　Simian UI 是一个用来发现重复代码的eclipse插件，对于改善设计，消除冗余代码很有帮助。
安装方法：使用eclipse的Help->Software Update进行安装。站点地址为:http://www.integility.com/eclipse/
安装后，按照提示重新启动eclipse。在希望进行分析的项目上点击右键，选择Simian->Add Simian to this project，就可以为该项目进行代码检查。

　　3，浏览器端调试工具（IE）　--　Internet Explorer Developer Toolbar
　　微软发布了Internet Explorer Developer Toolbar Beta版。该产品让开发人员能够深入探索和理解Web页面，帮助开发者更好地创建Web应用。浏览和修改Web页的文档对象模型（DOM）。具备以下特性：
－通过多种技术方式定位、选定Web页上的特定元素。
－禁止或激活IE设置。
－查看HTML对象的类名、ID，以及类似链接路径、tab顺序、快捷键等细节。
－描绘表格、单元格、图片或选定标签的轮廓。
－显示图片象素、大小、路径、替代文字等。
－即时重定义浏览器窗口大小到800x600或自定义大小。
－清空浏览器缓存和cookie，被清除项可从所有对象或给定域中选择。
－直接访问关联W3C规范参考、IE开发组blog或其他来源。
－显示设计时标尺，帮助对齐对象。
该工具条可集成在IE窗口，或以浮动窗口形式存在。

下载地址：从微软官方下载

　　4，浏览器端调试工具（Firefox）　--　Firebug
　　JavaScript, CSS, HTML，Ajax调试工具。功能包括HTML/CSS检查，除错工具，错误控制台和命令行等。可对javascript做调试和性能分析，查看html代码的结构，css样式动态提示，检测并显示页面错误，浏览树型结构的DOM数据，可以显示javascript的log等等功能。

下载地址：http://www.getfirebug.com/

坏男孩 2007-05-18 09:29 发表评论

DWR 入門與應用（二）

坏男孩 — Mon, 05 Mar 2007 03:48:00 GMT

假設您要從資料庫中查詢出一些字串，然後填寫到表單的下拉選單中。

例如一個示意的Java程式如下：

package onlyfun.caterpillar;
 
publicclass Option {
public String[] getOptions() {
// 實際上這些字串是從資料庫中查到的啦…
returnnew String[] {"良葛格", "毛美眉", "米小狗"}; 
}
}

傳回的字串陣列，您要填寫到下拉選單中，當然，首先我們要在dwr.xml中開發這個物件…

"1.0" encoding="UTF-8"?>
"-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN""http://www.getahead.ltd.uk/dwr/dwr10.dtd">


  
    "new" javascript="OPT">
        "class" value="onlyfun.caterpillar.Option"/>

這是我們的網頁…

"-//W3C//DTD HTML 4.01 Transitional//EN">


"Content-Type" content="text/html; charset=BIG5">




 

 

    選項:

傳回的字串陣列會填入opts這個select中，我們的option.js如下…

window.onload = function() {
    OPT.getOptions(populate);  
};
 
function populate(list){
    DWRUtil.removeAllOptions("opts");
    DWRUtil.addOptions("opts", list);
}

夠簡單了…不需要解釋了…

看一下結果…

好啦！我知道有人在說了，這個程式有夠無聊…

改一下！就是個不錯的範例了，例如連動方塊，唔！在Ajax in action中叫啥？Dynamic double combo？…

假設一個會去從資料庫中查詢資料的Java程式示意如下：

package onlyfun.caterpillar;
 
import java.util.Map;
import java.util.TreeMap;
 
publicclass Bike {
  private Map bikes;
  
  public Bike() {
    bikes = new TreeMap();
    bikes.put("2000", new String[] {"2000 T1", "2000 T2", "2000 T3"});
    bikes.put("2001", new String[] {"2001 A1", "2001 A2"});
    bikes.put("2002", new String[] {"2002 BW1", "2002 BW2", "2002 BW"});
    bikes.put("2003", new String[] {"2003 S320"});
    bikes.put("2004", new String[] {"2004 TA1", "2004 TA2", "2004 TA3"});
  }
  
  public String[] getYears() {
    String[] keys = new String[bikes.size()];
    int i = 0;
    for(String key : bikes.keySet()) {
      keys[i++] = key;
    }
    return keys; 
  }
  
  public String[] getBikes(String year) {
    return bikes.get(year);
  }
}

getYears()跟getBkies()分別表示產品的年份跟型號，這邊用Map模擬，實際上資料是來自資料庫的查詢。

一樣的，在dwr.xml中設定：

"1.0" encoding="UTF-8"?>
"-//GetAhead Limited//DTD Direct Web Remoting 1.0//EN""http://www.getahead.ltd.uk/dwr/dwr10.dtd">


  
    "new" javascript="Bike" scope="application">
        "class" value="onlyfun.caterpillar.Bike"/>

我們會有個腳踏車年份與型號查詢頁面：

"-//W3C//DTD HTML 4.01 Transitional//EN">


"Content-Type" content="text/html; charset=BIG5">
Insert title here
  
  
  
  

"refreshYearList();">
  年份：


  型號：

注意，在選完第一個年份後，會觸發onchange事件，接著第二個下拉選單會自動填上對應年份的型號，而不是按鈕按下，再去取得第二個下拉選單，然後refresh...blah...blah...

bike.js如下…

function refreshYearList() {
    Bike.getYears(populateYearList);
}
 
function populateYearList(list){
    DWRUtil.removeAllOptions("years");
    DWRUtil.addOptions("years", list);
    refreshBikeList();
}
 
function refreshBikeList() {
    var year = $("years").value;
    Bike.getBikes(year, populateBikeList);
}
 
function populateBikeList(list){
    DWRUtil.removeAllOptions("bikes");
    DWRUtil.addOptions("bikes", list);
}

一樣很簡單…

看個無聊的畫面…XD

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1239538

坏男孩 2007-03-05 11:48 发表评论

IBM Portal的web剪切出现乱码的解决办法！

坏男孩 — Fri, 05 Jan 2007 07:00:00 GMT

文档出处：http://www.blogjava.net/badboyryan/archive/2007/01/05/91997.html

同事在用IBM Portal的WEB剪切的时候，预览效果的时候发现页面全部是乱码why？

其实这个问题是编码的问题，理解了jsp里面的编码是解决问题的关键，看看这段代码：
<%@ page language="java" contentType="text/html; charset=gb2312" pageEncoding="GB18030"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-bean" prefix="bean"%>
<%@ taglib uri="http://jakarta.apache.org/struts/tags-html" prefix="html"%>
<%@ taglib uri="/WEB-INF/struts-tiles.tld" prefix="tiles" %>




      <%-- 带计数器的为/common/jsppage/bottom2.jsp --%>


我们看到：pageEncoding="GB18030"的作用是表示了该JSP文件使用的编码方式，这个属性主要是用于应用服务器在解析JSP文件，并转换为servlet时使用；
contentType="text/html; charset=gb2312" 的作用是：表示该网页采用GB2312国标码,这也是简体中文标准版本,如果不加,部分浏览器会自动选择编码,从而导致乱码出现,所以最好还是要加上；
　　
　　　
因为JSP要经过两次编码, 第一阶段会用到pageEncoding, 第二阶段会用 utf-8 至utf-8, 第三阶段就是由web容器出來的网页, 用的是contentType.

阶段一是 JSPC的 JSP至JAVA(.java)原码的"翻译", 它会根据pageEncoding 的设定读取JSP. 结果是由指定的 pageEncoding(utf-8,Big5,gb2312)的JSP 翻译成统一的utf-8 JAVA原码(.java). 如果pageEncoding设定错了, 或沒设定(预设ISO8859-1), 出来的在这个阶段就已是中文乱码.
阶段二是由 JAVAC的JAVA原码至JAVA BYTECODE的编译. 不论JSP的编写时是用(utf-8,Big5,gb2312),经过阶段一的结果全都是utf-8的ENCODING的JAVA原码.
JAVAC用 utf-8的ENCODING读取AVA原码, 编译成字串是 utf-8 ENCODING的二进制码(.class). 這这是 JAVA VIRTUAL MACNHINE 对常数字串在二进制码(JAVA BYTECODE)內表单的规范.
阶段三是TOMCAT(或其的application container)载入和执行階段二得来的JAVA二进制码, 输出的结果( 也就是BROWSER(客戶端)) 見到的. 这时一早隐藏在階段一和二的参数contentType, 就发挥了功效.
Portal WEB剪切出现乱码是因为原始剪切源的原因而引起的需要注意在页面里面把编码方式写全、写对基本就没有问题了，还有注意如果出现？说明是在字符集中找不到这个字符就是浏览器解析不了，比如；解决的办法把他替换为全角的空格；

坏男孩 2007-01-05 15:00 发表评论

动态类型判定，运行时多态问题

坏男孩 — Fri, 05 Jan 2007 01:53:00 GMT

class A
{
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public void func1()
{
System.out.println("B fun1 is calling");
}
}
class C
{
public static void main(String [] args)
{
B b=new B();
A a=b;
callA(a);
callA(new B());
}
public static void callA(A a)
{
a.func1();
a.func2();
}
}

运行结果：

D:\>javac C.java

D:\>java C
B fun1 is calling
B fun1 is calling
B fun1 is calling
B fun1 is calling

简单来说，就是RTTI，动态类型判定，也就是

B b=new B();
A a=new B();

只要等号右边类型是什么类型，而且已经覆盖父类的方法，那么调用该方法时，会自动知道相应的B中的覆盖方法。这是一定的，运行时多态。

==================================================

只对方法进行动态判定，属性的取值看，等号左边，也就是编译时类型。

将A和B添加一个属性，在索取值，看结果：

class A
{
public String name = "A CLASS";
public void func1()
{
System.out.println("A func1 is calling");
}
public void func2()
{
func1();
}
}
class B extends A
{
public String name = "B CLASS";
public void func1()
{
System.out.println("B fun1 is calling");
}
}
public class C
{
public static void main(String [] args)
{
B b=new B();
A a=b;
callA(a);
callA(new B());

System.out.println(a.name);
System.out.println(b.name);
System.out.println(new B().name);

}
public static void callA(A a)
{
a.func1();
a.func2();
}
}

运行结果：

D:\>javac C.java

D:\>java C
B fun1 is calling
B fun1 is calling
B fun1 is calling
B fun1 is calling
A CLASS
B CLASS
B CLASS

坏男孩 2007-01-05 09:53 发表评论

[转帖]多线程设计要点

坏男孩 — Fri, 05 Jan 2007 01:28:00 GMT

1.多线程中有主内存和工作内存之分，在JVM中，有一个主内存，专门负责所有线程共享数据；而每个线程都有他自己私有的工作内存，主内存和工作内存分贝在JVM的stack区和heap区。

2.线程的状态有'Ready', 'Running', 'Sleeping', 'Blocked', 和 'Waiting'几个状态，
'Ready' 表示线程正在等待CPU分配允许运行的时间。

3.线程运行次序并不是按照我们创建他们时的顺序来运行的，CPU处理线程的顺序是不确定的，如果需要确定，那么必须手工介入，使用setPriority()方法设置优先级。

4.我们无从知道一个线程什么时候运行，两个或多个线程在访问同一个资源时，需要synchronized

5. 每个线程会注册自己，实际某处存在着对它的引用，因此，垃圾回收机制对它就“束手无策”了。

6. Daemon线程区别一般线程之处是：主程序一旦结束，Daemon线程就会结束。

7. 一个对象中的所有synchronized方法都共享一把锁，这把锁能够防止多个方法对通用内存同时进行的写操作。synchronized static方法可在一个类范围内被相互间锁定起来。

8. 对于访问某个关键共享资源的所有方法，都必须把它们设为synchronized，否则就不能正常工作。

9. 假设已知一个方法不会造成冲突，最明智的方法是不要使用synchronized，能提高些性能。

10. 如果一个"同步"方法修改了一个变量，而我们的方法要用到这个变量(可能是只读),最好将自己的这个方法也设为 synchronized。

11. synchronized不能继承，　父类的方法是synchronized，那么其子类重载方法中就不会继承“同步”。

12. 线程堵塞Blocked有几个原因造成：

(1)线程在等候一些IO操作
(2)线程试图调用另外一个对象的“同步”方法，但那个对象处于锁定状态，暂时无法使用。

13.原子型操作(atomic), 对原始型变量(primitive)的操作是原子型的atomic. 意味着这些操作是线程安全的，但是大部分情况下，我们并不能正确使用，来看看 i = i + 1 , i是int型，属于原始型变量：

(1)从主内存中读取i值到本地内存.
(2)将值从本地内存装载到线程工作拷贝中.
(3)装载变量1.
(4)将i 加 1.
(5)将结果给变量i.
(6)将i保存到线程本地工作拷贝中.
(7)写回主内存.

注意原子型操作只限于第1步到第2步的读取以及第6到第7步的写, i的值还是可能被同时执行i=i+1的多线程中断打扰(在第4步)。

double 和long 变量是非原子型的(non-atomic)。数组是object 非原子型。

14. 由于13条的原因，我们解决办法是：

class xxx extends Thread{

//i会被经常修改
private int i;

public synchronized int read(){ return i;}

public synchronized void update(){ i = i + 1;}

..........

}

15. Volatile变量， volatile变量表示保证它必须是与主内存保持一致，它实际是"变量的同步", 也就是说对于volatile变量的操作是原子型的，如用在long 或 double变量前。

16. 使用yield()会自动放弃CPU，有时比sleep更能提升性能。

17. sleep()和wait()的区别是：wait()方法被调用时会解除锁定，但是我们能使用它的地方只是在一个同步的方法或代码块内。

18. 通过制造缩小同步范围，尽可能的实现代码块同步，wait(毫秒数)可在指定的毫秒数可退出wait；对于wait()需要被notisfy()或notifyAll()踢醒。

19. 构造两个线程之间实时通信的方法分几步：
(1). 创建一个PipedWriter和一个PipedReader和它们之间的管道;
PipedReader in = new PipedReader(new PipedWriter())
(2). 在需要发送信息的线程开始之前，将外部的PipedWriter导向给其内部的Writer实例out
(3). 在需要接受信息的线程开始之前，将外部的PipedReader导向给其内部的Reader实例in
(4). 这样放入out的所有东西度可从in中提取出来。

20. synchronized带来的问题除性能有所下降外，最大的缺点是会带来死锁DeadLock，只有通过谨慎设计来防止死锁，其他毫无办法，这也是线程难以驯服的一个原因。不要再使用stop() suspend() resume()和destory()方法

21. 在大量线程被堵塞时，最高优先级的线程先运行。但是不表示低级别线程不会运行，运行概率小而已。

22. 线程组的主要优点是：使用单个命令可完成对整个线程组的操作。很少需要用到线程组。

23. 从以下几个方面提升多线程的性能：

检查所有可能Block的地方，尽可能的多的使用sleep或yield()以及wait();

尽可能延长sleep(毫秒数)的时间;

运行的线程不用超过100个，不能太多；

不同平台linux或windows以及不同JVM运行性能差别很大。

24. 推荐几篇相关英文文章:

Use Threading Tricks to Improve Programs

坏男孩 2007-01-05 09:28 发表评论

准确的掌握 String 类

坏男孩 — Fri, 05 Jan 2007 01:19:00 GMT

public class J0 {
public static void main(String[] args) {
String str1 = new String("strOne");
String str2 = new String("strOne");
String str3 = "strTwo";
String str4 = "strTwo";

System.out.println(str1 == str2);
System.out.println(str3 == str4);

}
}
估计答案是什么？
是不是false,false ？
因为 String 类不能直接 "==" 号比较！new 出来的两个String对象不在同一内存。
应该用 "equals()"。
------------------------------------
可是答案是：false,true;
------------------------------------
怎么理解呢？

String str = new String("string");
与 String str = "string";

声明:以下解释是保证正确的，我会从内存空间上来解释，比较清楚。

区别是，new String是在堆空间上分配一个空间，将指针指向这个空间，每一个new都是新的空间，==判断当然是不等。

而String str = "ssss"，说一下，在每种语言中对于字符串都有特殊的处理。
Java有一个专门的字符串池来保存可以重用的字符串。对于相同的字面值（也就是"双引号里面你看到东西"）相同，多少个变量他们都指向相同的空间，==判断当然相等。

所以最正确的判断字符串内容相等的方法，就是用equals方法。String类这个immuable的类已经覆盖了这个从Object类继承的eqauls方法，达到了对于内容相等的判断。

坏男孩 2007-01-05 09:19 发表评论

SPringInAction配书源代码下载

坏男孩 — Thu, 04 Jan 2007 00:35:00 GMT

真的难找啊，书上说的那个网站把中国的IP给封了；；
因为文件比较大，所以放到我的ftp空间了。
侠客岛的朋友可以去我们的ftp下载啊！
放到侠客岛目录里面了
文件名称：spring_in_action_source.rar
侠客岛群号：26858781

推荐一个网址：

http://secure.manning.com/books/walls2/source

坏男孩 2007-01-04 08:35 发表评论

JAVA 正则表达式4种常用的功能

坏男孩 — Sun, 31 Dec 2006 06:54:00 GMT

正则表达式在字符串处理上有着强大的功能，sun在jdk1.4加入了对它的支持

　　下面简单的说下它的4种常用功能：
　　
　　查询：
　　
以下是代码片段：
String str="abc efg ABC";

String regEx="a|f"; //表示a或f

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

　　
　　如果str中有regEx，那么rs为true，否则为flase。如果想在查找时忽略大小写，则可以写成Pattern p=Pattern.compile(regEx,Pattern.CASE_INSENSITIVE);
　　
　　提取：

以下是代码片段：
String regEx=".+\(.+)$";

String str="c:\dir1\dir2\name.txt";

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher(str);

boolean rs=m.find();

for(int i=1;i<=m.groupCount();i++){

System.out.println(m.group(i));

}

　　
　　以上的执行结果为name.txt，提取的字符串储存在m.group(i)中，其中i最大值为m.groupCount();
　　
　　分割：
　　
以下是代码片段：
String regEx="::";

Pattern p=Pattern.compile(regEx);

String[] r=p.split("xd::abc::cde");

执行后，r就是{"xd","abc","cde"}，其实分割时还有跟简单的方法：

String str="xd::abc::cde";

String[] r=str.split("::");

　　
　　替换（删除）：
　　
以下是代码片段：
String regEx="a+"; //表示一个或多个a

Pattern p=Pattern.compile(regEx);

Matcher m=p.matcher("aaabbced a ccdeaa");

String s=m.replaceAll("A");
　　
　　结果为"Abbced A ccdeA"
　　
　　如果写成空串，既可达到删除的功能，比如：
　　
String s=m.replaceAll("");
　　
　　结果为"bbced ccde"
　　
　　附：
　　
　\D 等於 [^0-9] 非数字
　\s 等於 [ \t\n\x0B\f ] 空白字元
　\S 等於 [^ \t\n\x0B\f ] 非空白字元
　\w 等於 [a-zA-Z_0-9] 数字或是英文字
　　\W 等於 [^a-zA-Z_0-9] 非数字与英文字
　　
　　^ 表示每行的开头
　　$ 表示每行的结尾

坏男孩 2006-12-31 14:54 发表评论

基于RMI的分布式银行自助终端监控系统的研究及实现

坏男孩 — Sun, 31 Dec 2006 06:49:00 GMT

基于RMI的分布式银行自助终端监控系统的研究及实现

张永福¹，张娟²

(1．陕西师范大学计算机科学学院陕西西安 710062；2．西安财经学院陕西西安 710061)

近年来随着我国金融体制改革的不断深人，银行企业不断利用信息技术拓宽业务，其中对于自助银行，使其得到了飞速发展，因此，依托现在计算机技术、网络通信技术、数据安全技术开发出能对各种自助终端进行监控，网络拓展性良好，使用灵活方便，安全的银行自助终端监控系统成为当务之急。利用J2EE系统平台^[1]，能有效地实现分布式多层体系结构的应用程序开发。

1 RMI^[2]

RMI(Remote Method Invocation，远程方法调用)是J2EE技术中的一项，是Java语言实现有力网络功能的固有机制，RMI允许Java编写分布式对象，并允许对象在内存中通信，可跨越Java虚拟机通信^[3-4]，也可跨越物理设备。

RMI实现实际上由3个抽象层建立：

Stubs／Skeletons Layer(存根/主架层)；Remote Reference Layer(远程引用层)；Transport Layer(传输层)。

2 监控系统的设计与实现

2．1 系统网络结构

本系统以中国银行内部Intranet网络为依托，采用集中式网络结构构建而成。如图1所示。

系统采用一台监控服务器，连在中国银行Intranet主干网上，和提供数据源的前置机放入同一网段。服务器主机上运行Web服务器、应用服务器和数据库服务器，为用户提供Web方式访问。监控客户端以浏览器的形式在工作站上通过网络直接访问web服务器，进行信息查询、监控管理、报表打印、系统维护等。Intranet环境内其他用户可通过路由器、DDN专线从相应工作站以web形式访问Web服务器。

2．2 系统逻辑层次结构图

监控系统由数据库服务器、应用服务器、web服务器和浏览器组成，通过Intranet／Internet与综合前置系统连接。

本文将3层结构模式应用于银行自助终端监控系统，这3层分别是：客户层；Web层(应用逻辑层)；数据存储层(见图2)。

这种结构无疑是富有生命力的，监控台使用浏览器直接与银行Intranet连接，监控服务器(监控服务器由Application Server和DB Servet两台服务器组成)在接入Intranet之前与一个Web Server连接，再通过Web Server接入Internet。通过Internet在监控服务器与监控台之间建立物理连接。

2.3 应用系统结构

自助设备监控系统是监控前端自助设备运行状态，交易情况的网上应用系统，他的数据来自于数据采集模块。前端自助设备运行时发送状态交易数据到前置机、主机系统，由前置机、主机系统进行处理，并将状态数据、交易情况记入数据库或LOG文件中。如图3所示，由监控系统数据采集模块定时采集数据库或LOG文件中的数据到监控数据库中，监控应用系统负责对监控数据统一处理，并通过监控客户端实时请求发送到监控客户端进行显示及其他处理。

3 RMI技术在监控系统中的应用

中国银行天津分行在每个地区都下设支行，每个支行负责管理本地区的ATM网点，因此各个支行之间网点ATM自助设备的状态、交易信息不能共享．那么各个地区的监控客户端就只能通过本地区支行的监控服务器实时监控本地区的ATM网点的自助终端设备，为了使身处各个地区的监控客户端都能够监控各个支行所辖的ATM网点自助终端设备，就必须采用分布式的监控系统。每个支行都设置一台监控服务器，与各自所在支行的前置系统相连接，利用RMI技术将实时监控、远程控制、查询统计组件注册为远程对象，监控客户机在任何支行的监控服务器上的注册服务表用远程对象的名字查找相应远程对象，然后调用他的方法，就可以像监控本地区的ATM自助终端设备那样监控其他地区的ATM自助终端设备。

下面本文将以对ATM状态的实时监控如何借助RMI技术实现做以讨论^[5]。

3．1 定义远程接口

在Java中，远程对象是实现远程接口的类的实例，远程接口声明每个要远程调用的方法。在需要创建一个远程对象的时候，通过传递一个接口来隐藏基层的实施细节，客户通过接口句柄发送消息即可。远程接口具有如下特点：

(1)远程接口必须为public属性。

(2)远程接口必须扩展接口java．rmi．Remote。

(3)除与应用程序本身特定的例外之外，远程接口中的每个方法都必须在自己的throws从句中声明java．rmi．RemoteException。

(4)作为参数或返回值传递的一个远程对象(不管是直接，还是本地对象中嵌入)必须声明为远程接口，而不应声明为实施类。

下面是对ATM状态实时监控的远程接口ATM_StatusShow_Interface的定义。

3．2 实现远程接口^[6]

远程对象实现类必须扩展远程对象java．rmi．UnicastRemoteObject类，并实现所定义的远程接口。远程对象的实现类中包含实现每个远程接口所指定的远程方法的代码。这个类也可以含有附加的方法，但客户只能使用远程接口中的方法。因为客户是指向接口的一个句柄，而不是他的哪个类。必须为远程对象定义构造函数，即使只准备定义一个默认构造函数，用他调用基础类构造函数。

3．3 编写服务器类

通过ATM_StatusShow_Server创建一个远程对象的实例，并通过java．rmi．registry．LocateRegistry类的createRegistry方法从指定端口号启动注册服务程序，注册服务程序的缺省运行端口为1099。必须将远程对象名字绑定到对远程对象的引用上。

3．4 编写使用远程服务的客户机类。

客户机类的主要功能有2个：一是通过Naming．lookup方法来构造注册服务程序stub程序实例；二是调用服务器远程对象上的远程方法。

3．5 为远程对象实现创建根和干

要创建存根程序和主架文件，应以包含远程对象实现的已编译类包全名运行rmic编译器。存根(Stub)是远程对象在客户端的代理，他将RMI调用传递给服务器端的主架(Skeleton)，后者负责将该调用传递给实际的远程方法：

运行rmic，RMI目录下就会多出2个新类：

ATM_StatusShow_Impl_Stub．class

ATM_StatusShow_Impl_Skel．class

他们分别对应的是存根(stub)和主架(skeleton)。

4 结论

本系统在中国银行天津分行的支持下已投入使用，经过多次测试和实际运行，用户对于本系统的评价比较满意。在运行速度和运行稳定性上都能达到要求。对于用户的日常工作负担起到了较大减轻的作用，提高了工作效率，简化了沟通手续，丰富了查询能力，使统计结果更加实时、灵活和准确。从技术角度上看，本系统采用RMI技术非常好地解决了分布式应用的问题。

本文摘自《现代电子技术》

坏男孩 2006-12-31 14:49 发表评论

中间件编程之RMI在Java中的应用

坏男孩 — Sun, 31 Dec 2006 06:18:00 GMT

本篇用实例来说明采用Java进行RMI远程方法调用的实现方法，从而为分布应用软件的开发者提供参考和帮助。
　　Internet/Intranet的飞速发展使得Web应用日益广泛而复杂，Web早已不仅仅是超媒体信息的浏览工具，它正逐步发展成为分布异构环境中企业应用的通用前端和事务处理的展现窗口。在分布式环境异构中，各种机器所采用的操作系统、网络通信协议和应用软件千差万别，要实现信息共享和软件资源的整合十分困难，然而一个健壮的分布式计算框架能为可移植的分布式应用软件开发带来巨大的便利和好处。
　　分布式对象技术主要是在分布式异构环境下建立应用系统框架和对象构件。在应用系统框架的支撑下，开发者可以将软件功能封装为更易管理和使用的对象，这些对象可以跨越不同的软、硬件平台进行互操作。目前，分布式互操作标准主要有Microsoft的COM/DCOM标准、Sun公司的Java RMI标准和OMG组织的CORBA标准。
　　Java RMI调用实例
　　Java RMI简介
　　远程方法调用（RMI，Remote Method Invocation）是jdk1.1中引入的分布式对象软件包，它的出现大大简化了分布异构环境中Java应用之间的通信。
　　
　　要使用RMI，必须构建四个主要的类：远程对象的本地接口、远程对象实现、RMI客户机和RMI服务器。RMI服务器生成远程对象实现的一个实例，并用一个专有的URL注册。RMI客户机在远程RMI服务器上查找服务对象，并将它转换成本地接口类型，然后像对待一个本地对象一样使用它。
　　
　　下面是一个简单的RMI实例，RMI客户机通过RMI服务器提供的方法实现对两个双精度浮点数的加减运算。例子虽然很简单，但掌握了Java RMI调用的基本原理和方法，在实现复杂应用时，我们需要做的也只是完善远程对象的实现类而已。
　　
　　RMI实例分析
　　
　　1.远程对象的本地接口声明（RMIOperate.java）
　　
　　该类仅仅是一个接口声明，RMI客户机可以直接使用它，RMI服务器必须通过一个远程对象来实现它，并用某个专有的URL注册它的一个实例。
　　
　　具体代码如下：
　　
　　package wf.rmi;　//包名
　　import java.rmi.*; //导入类包
　　/*RMI本地接口必须从Remote接口派生*/
　　 public interface RMIOperate extends Remote
　　{
　　 /*接口中的具体方法声明，注意必须声明抛出RemoteException*/
　　　public double add(double x, double y) throws RemoteException;
　　//输入两个浮点数，返回其和
　　　public double minus(double x, double y) throws RemoteException;
　　//输入两个浮点数，返回其差
　　}
　　2.远程对象实现类（OperateImpl.java）
　　这个类应实现RMI客户机调用的远程服务对象的本地接口，它必须从UnicastRemoteObject继承，构造函数应抛出RemoteException异常。
　　具体代码如下：
　　
　　package wf.rmi; //包名
　　//导入需要的类包
　　import java.rmi.*;
　　import wf.rmi.RMIOperate;
　　import java.rmi.server.UnicastRemoteObject;
　　public class OperateImpl extends UnicastRemoteObject implements RMIOperate
　　{
　　 /*构造函数*/
　　 public OperateImpl() throws RemoteException
　　 {
　　 }
　　 /*实现本地接口中声明的add方法*/
　　 public double add(double x, double y) throws RemoteException
　　 {
　　　double z = x + y;
　　　return z;
　　 }
　　　/*实现本地接口中声明的minus方法*/
　　 public double minus(double x, double y) throws RemoteException
　　 {
　　　double z = x - y;
　　　return z;
　　 }
　　}
　　3.RMI服务器类（RMIServer.java）
　　该类创建远程对象实现类OperateImpl的一个实例，然后通过一个专有的URL来注册它。所谓注册就是通过Java.rmi.Naming.bind()方法或Java.rmi.Naming.rebind()方法，将OperateImpl实例绑定到指定的URL上。
　　
　　具体实现代码如下：
　　
　　package wf.rmi; //包名
　　//导入需要的类包
　　import java.rmi.Naming;
　　import wf.rmi.OperateImpl;
　　public class RMIServer
　　{
　　 public static void main(String[] args)
　　 {
　　　try
　　　{
　　　 //创建远程对象的实现实例
　　　 OperateImpl operObj = new OperateImpl();
　　　 //提示信息
　　　 System.out.println("RMI Server Starting...");
　　　 //将实例注册到专有的URL
　　　 Naming.rebind("rmi:///RMIOperate", operObj);
　　　 //等待RMI客户机调用的提示信息
　　　 System.out.println("Waiting RMI Client Invoke...");
　　　}
　　　catch(Exception e)
　　　{
　　　 e.printStackTrace();
　　　}
　　 }
　　}
　　4.RMI客户机类（RMIClient.java）
　　
　　RMI客户使用java.rmi.Naming.lookup()方法，在指定的远程主机上查找RMI服务对象，若找到就把它转换成本地接口RMIOperate类型。它与CORBA不同之处在于RMI客户机必须知道提供RMI服务主机的URL，这个URL可以通过rmi://host/path或rmi://host:port/path来指定，如果省略端口号，就默认使用1099。Java.rmi.Naming.lookup()方法可能产生三个异常：Java.rmi.RemoteException、Java.rmi.NotBoundException、java.net. MalformedURLException，三个异常都需要捕获。
　　
　　下面是详细代码：
　　
　　package wf.rmi; //包名
　　//导入需要的类包
　　import java.rmi.*;
　　import java.net.*;
　　import java.io.*;
　　public class RMIClient
　　{
　　　　public static void main(String[] args)
　　　　{
　　　　　　try
　　　　　　{
　　　　　　　　BufferedReader readIn = new BufferedReader(new
　　InputStreamReader(System.in));
　　　　　　　　String host = "localhost"; //默认为本地主机
　　 //带输入参数时，将host设置为指定主机
　　　　　　　　if (args.length > 0)
　　　　　　　　　　host = args[0];
　　　　　　　 //根据指定的URL定位远程实现对象
　　RMIOperate rmiObj = (RMIOperate)Naming.lookup("rmi://" + host +
　　"/RMIOperate");　　　　　　//提示输入运算参数1
　　System.out.println("Please Input Data1: ");
　　　　　　　　String str1 = readIn.readLine(); //读取输入参数1
　　　　　　　　double x = 0;
　　　　　　　　try
　　　　　　　　{
　　　　 x = Double.parseDouble(str1); //分析输入参数1，转换为double类型
　　　　　　　　}
　　　　　　　catch(NumberFormatException nfe)
　　　　　　　　{
　　　　　　　　　　x = 0; //如果转换异常，则重置x为0
　　　　　　　　}
　　 //提示输入运算参数2
　　　　　　　　System.out.println("Please Input Data2: ");
　　　　　　　　String str2 = readIn.readLine();//读取输入参数2
　　　　　　　　double y = 0;
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　y = Double.parseDouble(str2); //分析输入参数2，转换为double类型
　　　　　　　　}
　　　　　　　　catch(NumberFormatException nfe)
　　　　　　　　{
　　　　　　　　　　y = 0; //如果转换异常，则重置y为0
　　　　　　　　}
　　 //调用远程对象的本地接口方法，实现输入参数的加、减运算，并输出结果
　　　　　　　System.out.println("Data1 Add Data2 Result is: " + rmiObj.add(x, y));
　　　　　　　System.out.println("Data1 minus Data2 Result is: " +
　　　rmiObj.minus(x, y));
　　　　　　}
　　　　　　catch(Exception e)
　　　　　　{
　　　　　　　　e.printStackTrace();
　　　　　　}
　　　　}
　　}
　　RMI Server/Client的编译与运行
　　
　　(1).编译所有的源代码(如图1)
　　　
　　图1
　　(2).生成客户端存根和服务器框架(如图2)
　　　
　　图2
　　这将构造OperateImpl_Stub.class和OperateImpl_Skel.class。这时可将所有的Class文件打包成jar，并将其分别置于RMI客户机和RMI服务器的ClassPath中(如图3):
　　　
　　图3
　　当然，也可以只将RMIOperate.class、RMIClient.class和OperateImpl_Stub.class复制到RMI客户机，将RMIOperate.class、OperateImpl.class 、RMIServer.class和OperateImpl_Skel.class复制到RMI服务器。
　　(3).启动RMI注册(如图4)
　　　
　　图4
　　(4).运行和调用
　　● 在服务器上执行RMIServer(如图5)
　　　
　　图5
　　● 在本地客户机上运行RMIClient(如图6)
　　　
　　图6
　　● 在远程客户机上运行RMIClient（须指明RMI服务器主机名或IP地址，如图7）
　　　
　　图7
　　至此，RMI调用完成。

摘自：http://youngyj1982.bokee.com/

坏男孩 2006-12-31 14:18 发表评论

Spring交流学习群建立

坏男孩 — Mon, 25 Dec 2006 01:34:00 GMT

为了系统的学习SPRING的精华思想建立一个QQ群，qq群侠客岛:26858781

欢迎spring的高手进入。

坏男孩 2006-12-25 09:34 发表评论

展示JDBC存取ORACLE大型数据对象LOB几种情况的示范类

坏男孩 — Wed, 20 Dec 2006 02:34:00 GMT

import java.io.*;
import java.util.*;
import java.sql.*;

public class LobPros
{

/**
   * ORACLE驱动程序
   */
private static final String DRIVER = "oracle.jdbc.driver.OracleDriver";

/**
   * ORACLE连接用URL
   */
private static final String URL = "jdbc:oracle:thin:@test2000:1521:orac";

/**
   * 用户名
   */
private static final String USER = "user";

/**
   * 密码
   */
private static final String PASSWORD = "pswd";

/**
   * 数据库连接
   */
private static Connection conn = null;

/**
   * SQL语句对象
   */
private static Statement stmt = null;

/**
   * @roseuid 3EDA089E02BC
   */
public LobPros()
{

}

/**
   * 往数据库中插入一个新的CLOB对象
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA04A902BC
   */
public static void clobInsert(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 插入一个空的CLOB对象 */
         stmt.executeUpdate("INSERT INTO TEST_CLOB VALUES ('111', EMPTY_CLOB())");
         /* 查询此CLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
         while (rs.next()) {
            /* 取出此CLOB对象 */
            oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
            /* 向CLOB对象中写入数据 */
            BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
            BufferedReader in = new BufferedReader(new FileReader(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 修改CLOB对象（是在原CLOB对象基础上进行覆盖式的修改）
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA04B60367
   */
public static void clobModify(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 查询CLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
         while (rs.next()) {
            /* 获取此CLOB对象 */
            oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
            /* 进行覆盖式修改 */
            BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
            BufferedReader in = new BufferedReader(new FileReader(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 替换CLOB对象（将原CLOB对象清除，换成一个全新的CLOB对象）
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA04BF01E1
   */
public static void clobReplace(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 清空原CLOB对象 */
         stmt.executeUpdate("UPDATE TEST_CLOB SET CLOBCOL=EMPTY_CLOB() WHERE ID='111'");
         /* 查询CLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT CLOBCOL FROM TEST_CLOB WHERE ID='111' FOR UPDATE");
         while (rs.next()) {
            /* 获取此CLOB对象 */
            oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
            /* 更新数据 */
            BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
            BufferedReader in = new BufferedReader(new FileReader(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * CLOB对象读取
   *
   * @param outfile - 输出文件名
   * @throws java.lang.Exception
   * @roseuid 3EDA04D80116
   */
public static void clobRead(String outfile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 查询CLOB对象 */
         ResultSet rs = stmt.executeQuery("SELECT * FROM TEST_CLOB WHERE ID='111'");
         while (rs.next()) {
            /* 获取CLOB对象 */
            oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
            /* 以字符形式输出 */
            BufferedReader in = new BufferedReader(clob.getCharacterStream());
            BufferedWriter out = new BufferedWriter(new FileWriter(outfile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            out.close();
            in.close();
         }
      } catch (Exception ex) {
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 向数据库中插入一个新的BLOB对象
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA04E300F6
   */
public static void blobInsert(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 插入一个空的BLOB对象 */
         stmt.executeUpdate("INSERT INTO TEST_BLOB VALUES ('222', EMPTY_BLOB())");
         /* 查询此BLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
         while (rs.next()) {
            /* 取出此BLOB对象 */
            oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
            /* 向BLOB对象中写入数据 */
            BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 修改BLOB对象（是在原BLOB对象基础上进行覆盖式的修改）
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA04E90106
   */
public static void blobModify(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 查询BLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
         while (rs.next()) {
            /* 取出此BLOB对象 */
            oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
            /* 向BLOB对象中写入数据 */
            BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 替换BLOB对象（将原BLOB对象清除，换成一个全新的BLOB对象）
   *
   * @param infile - 数据文件
   * @throws java.lang.Exception
   * @roseuid 3EDA0505000C
   */
public static void blobReplace(String infile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 清空原BLOB对象 */
         stmt.executeUpdate("UPDATE TEST_BLOB SET BLOBCOL=EMPTY_BLOB() WHERE ID='222'");
         /* 查询此BLOB对象并锁定 */
         ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222' FOR UPDATE");
         while (rs.next()) {
            /* 取出此BLOB对象 */
            oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
            /* 向BLOB对象中写入数据 */
            BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
            BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * BLOB对象读取
   *
   * @param outfile - 输出文件名
   * @throws java.lang.Exception
   * @roseuid 3EDA050B003B
   */
public static void blobRead(String outfile) throws Exception
{
      /* 设定不自动提交 */
      boolean defaultCommit = conn.getAutoCommit();
      conn.setAutoCommit(false);

      try {
         /* 查询BLOB对象 */
         ResultSet rs = stmt.executeQuery("SELECT BLOBCOL FROM TEST_BLOB WHERE ID='222'");
         while (rs.next()) {
            /* 取出此BLOB对象 */
            oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
            /* 以二进制形式输出 */
            BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile));
            BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream());
            int c;
            while ((c=in.read())!=-1) {
                  out.write(c);
            }
            in.close();
            out.close();
         }
         /* 正式提交 */
         conn.commit();
      } catch (Exception ex) {
         /* 出错回滚 */
         conn.rollback();
         throw ex;
      }

      /* 恢复原提交状态 */
      conn.setAutoCommit(defaultCommit);
}

/**
   * 建立测试用表格
   * @throws Exception
   */
public static void createTables() throws Exception {
      try {
         stmt.executeUpdate("CREATE TABLE TEST_CLOB ( ID NUMBER(3), CLOBCOL CLOB)");
         stmt.executeUpdate("CREATE TABLE TEST_BLOB ( ID NUMBER(3), BLOBCOL BLOB)");
      } catch (Exception ex) {

      }
}

/**
   * @param args - 命令行参数
   * @throws java.lang.Exception
   * @roseuid 3EDA052002AC
   */
public static void main(String[] args) throws Exception
{
      /* 装载驱动,建立数据库连接 */
      Class.forName(DRIVER);
      conn = DriverManager.getConnection(URL,USER,PASSWORD);
      stmt = conn.createStatement();

      /* 建立测试表格 */
      createTables();

      /* CLOB对象插入测试 */
      clobInsert("c:/clobInsert.txt");
      clobRead("c:/clobInsert.out");

      /* CLOB对象修改测试 */
      clobModify("c:/clobModify.txt");
      clobRead("c:/clobModify.out");

      /* CLOB对象替换测试 */
      clobReplace("c:/clobReplace.txt");
      clobRead("c:/clobReplace.out");

      /* BLOB对象插入测试 */
      blobInsert("c:/blobInsert.doc");
      blobRead("c:/blobInsert.out");

      /* BLOB对象修改测试 */
      blobModify("c:/blobModify.doc");
      blobRead("c:/blobModify.out");

      /* BLOB对象替换测试 */
      blobReplace("c:/blobReplace.doc");
      blobRead("c:/bolbReplace.out");

      /* 关闭资源退出 */
      conn.close();
      System.exit(0);
}
}

坏男孩 2006-12-20 10:34 发表评论