前言这个小小的数据库操作封装框架是参考IBM开发网上的两篇文章并在其基础上扩充了一些功能而得到的。所以首先要感谢两篇文章的作者。
学习JDBC以来一直想实现一个简单的封装来方便编程但是由于水平有限一直没有较好的办法，看了IBM开发网上的两篇文章以后感觉作者的设计思想很好一定能扩充成一个实用的JDBC封装。所以我在文章提供的源码基础上加了一些功能这些功能包括支持多种数据类型，处理了空值，利用反射方便的在Row对象和值对象之间进行转换，还有加了一个我自认为通用的DAO类来方便用户的操作。
我把源码提供出来有两个目的一个是希望能帮助比我还初学的初学者熟悉JDBC，另外就是请各位高手不吝赐教，改进程序中的错误如果能将你们的对JDBC的封装方法提供出来那就更好了(不要说你们只用EJB或者Hibernate，JDO什么的)。
IBM开发网的那两篇文章分别是《一个简单的 JDBC 包装器》《对一个简单的 JDBC 包装器的扩展及应用》，我的邮箱是xsimple2003@yahoo.com.cn有事请与我联系。
设计思想 把DBMS抽象成类Database，这个类负责管理数据库连接以及提供表对象。
把数据库中的一张或多张表抽象成类Table，这个类中提供对表的添加，修改，删除的JDBC封装。
将数据库表中的一条记录抽象成类Row，这个类用HashMap保存关系数据库中表格中一行数据的字段名和值并提供一些相关操作。另外这个类还提供了两个静态方法用于在Row对象和ValueObject之间进行方便的转换。
把对个Row的集合抽象成RowSet，这个类中用一个vector把多个Row对象保存起来并提供一些相关操作。
代码分析由于已经给出源码所以我只对代码中关键的和需要注意的地方加以说明，大家可以执行源码一边演示一边体会。
Database类源码如下：
package com.gdrj.util.database;
import java.sql.*;
import javax.sql.*;
import com.gdrj.util.servicelocator.*;
public class Database {
/**
* 这个数据库连接成员只有在与数据库直接建立连接的情况下是有效的
*/
private Connection conn = null;
/**
* 当这个参数有效时，表明程序是直接与数据库建立的连接而不是从连接池里取得连接
*/
private String url, user, password;
/**
* 当这个参数有效时，表明程序是从连接池里取得连接。
*/
private String datasource;
/**
* 用数据库地址，用户名，密码初始化数据库对象，这个构造器用于程序是直接
* 与数据库建立连接的情况。
* @param url
* @param user
* @param password
*/
public Database(String url, String user, String password) {
this.url = url;
this.user = user;
this.password = password;
}
/**
* 用JNDI数据源名初始化数据库对象，这个构造器用于从连接池取数据库连接的情况。
* @param datasource
*/
public Database(String datasource) {
this.datasource = datasource;
}
/**
* 得到数据库连接，对于是否从连接池里取连接做了自动处理即根据用户调用了哪个构造器
* 来判断是否直接与数据库建立连接还是从连接池里取连接。
* 对于用户来说不用考虑程序是从那里取得连接，他只管正确的初始化数据库对象。
* @return
* @throws SQLException
*/
public Connection getConnection() throws Exception {
if (datasource == null) { //直接与数据库建立连接
if (conn == null) {
conn = DriverManager.getConnection(url, user, password);
}
}
else { //从应用服务器的连接池里取得连接
ServiceLocator sl = ServiceLocator.getInstance();
DataSource ds = sl.getDataSource(datasource);
return ds.getConnection();//每调用一次都返回一个连接池中的数据库连接
}
return conn;
}
/**
* 释放连接，如果是直接与数据库连接的情况则什么也不做
* 如果是从连接池中取得的连接那么释放传来的连接
* @param conn
*/
public void disConnect(Connection connection) {
if (datasource != null) { //只处理从连接池取连接的情况
try {
if (connection != null) {
connection.close();
}
}
catch (Exception ex) {}
}
}
/**
* 得到与参数名对应的表对象，注意这里不作任何数据库操作
* @param name
* @return
*/
public Table getTable(String name) {
return new Table(this, name);
}
}
这个类是对DBMS的抽象，所以使用时应用程序中只要有一个Database对象就够了，如果你是以与数据库之间建立连接的方式使用那么你用Database(String url, String user, String password)构造器进行初始化。如果是从应用服务器的连接池中取得连接的方式使用那么用Database(String datasource)构造器初始化，这样以后你使用这个对象进行getConnection和disConnection时就不用去考虑始终保持一个连接(C/S方式),还是将连接返回连接池了因为在disConnection中已经做了处理。集体使用方法将Table类。在getConnection中的从连接池中取连接的代码你只要参考以下《J2EE核心模式》中的服务定位器模式就知道是怎么回事了，你在用Database(String url, String user, String password)初始化时其中的代码不起作用。
Table类源码如下：
package com.gdrj.util.database;
import java.sql.*;
import java.util.*;
import com.gdrj.util.*;
public class Table {
/**
* 通过这个数据库对象得到数据库连接
*/
private Database database;
/**
* 数据库中一个或多个(只限查询)表的名
*/
private String name;
/**
* 初始化表对象，此时不作任何数据库相关操作
* 一般通过database的getTable调用
* @param database
* @param name
*/
public Table(Database database, String name) {
this.database = database;
this.name = name;
}
/**
* 查询某一行
* @return
*/
public Row getRow(String fields, String criteria, Object[] args) throws
DBAccessException {
RowSet rows = executeQuery(fields, criteria, args);
if (rows == null) {
return null;
}
return rows.get(0);
}
/**
* 得到一个多行记录
* @param criteria 查询条件
* @param args 查询条件的参数列表
* @return
*/
public RowSet getRows(String fields, String criteria, Object[] args) throws
DBAccessException {
return executeQuery(fields, criteria, args);
}
/**
* 执行SQL查询
* @param fields 要查询的字段，如果传入null则表示查询表中所有字段
* @param criteria用户输入的查询Where条件
* @param args 用到的参数数组
* @return 返回符合结果行集
*/
private RowSet executeQuery(String fields, String criteria, Object[] args) throws
DBAccessException {
Connection conn = null;
RowSet rows = new RowSet();
String sql = null;
if (fields == null) {
fields = "*";
}
try {
conn = database.getConnection(); //取得数据库连接,在方法内部对不同的连接情况进行了处理
sql = "select " + fields + " from " + name +
( (criteria == null) ? "" :
(" where " + criteria));
PreparedStatement pstmt = conn.prepareStatement(sql);
if (args != null) { //如果有查询参数则设置参数
for (int i = 0; i < args.length; i++) {
pstmt.setObject(i + 1, args[i]);
}
}
ResultSet rs = pstmt.executeQuery();
ResultSetMetaData rsmd = rs.getMetaData();
int cols = rsmd.getColumnCount();
/**@todo 判断是否为零*/
if (cols == 0) {
return null;
}
while (rs.next()) {
Row row = new Row();
for (int i = 1; i <= cols; i++) {
String name = rsmd.getColumnName(i);
Object value = rs.getObject(i); //作通用类型处理,这样row中的类型都是Object型的。
/**
* 这里要做空值处理，因为在进行RowToValueObject转换时如果是空值则不能得到值的类型
* 所以如果是空值那么把value设置成类型信息
*/
if (value == null) {
value = Class.forName(rsmd.getColumnClassName(i));
}
// System.out.println(value.getClass());//用于得到数据库中的类型对应Java中的什么类型
row.put(name, value);
}
rows.add(row);
}
rs.close();
pstmt.close();
}
catch (Exception ex) {
throw new DBAccessException(InforGeter.getErrorInfor(this, "executeQuery",
ex, "执行SQL(" + sql + ")查询时出错！"));
}
finally {
database.disConnect(conn); //调用数据库对象的释放连接方法(此方法内对取得连接方式的不同情况做了处理)
}
return rows;
}
/**
* 增加一行
* @param row
*/
public int putRow(Row row) throws DBAccessException {
return putRow(row, null, null);
}
/**
* 修改一行(没有条件就是增加)
* @param row
* @param conditions
*/
public int putRow(Row row, String conditions, Object[] args) throws
DBAccessException {
String ss = "";
int affectableRow = 0; //执行SQL后影响的行数
if (conditions == null) {
ss = "INSERT INTO " + name + "(";
for (int i = 0; i < row.length(); ++i) {
String k = row.getKey(i);
ss += k;
if (i != row.length() - 1) {
ss += ", ";
}
}
ss += ") VALUES (";
for (int j = 0; j < row.length(); ++j) {
ss += (row.get(j) == null) ? "null" : "?"; //如果row中有空值则设置为null，否则设置为查询参数
if (j != row.length() - 1) {
ss += ", ";
}
}
ss += ")";
}
else {
ss = "UPDATE " + name + " SET ";
for (int i = 0; i < row.length(); ++i) {
String k = row.getKey(i);
ss += k + "=" + ( (row.get(i) == null) ? "null" : "?"); //设置查询参数
if (i != row.length() - 1) {
ss += ", ";
}
}
ss += " WHERE ";
ss += conditions;
}
Connection conn = null;
try {
conn = database.getConnection();
PreparedStatement st = conn.prepareStatement(ss);
int j = 0; //查询参数计数器
for (int i = 0; i < row.length(); i++) {
if (row.get(i) != null) { //如果不是空则解析查询参数
st.setObject(++j, row.get(i)); //解析查询参数
}
}
if (args != null) {
for (int i = 0; i < args.length; i++) {
st.setObject(++j, args[i]);//预定的规则，null不能放到查询参数中要以name=null的静态形式存放
}
}
affectableRow = st.executeUpdate();
st.close();
}
catch (Exception ex) {
ex.printStackTrace();
throw new DBAccessException(InforGeter.getErrorInfor(this, "putRow", ex,
"更新表" + name + "中的数据时出错！"));
}
finally {
database.disConnect(conn);
}
return affectableRow;
}
/**
* 删除一行
* @param row
*/
public int delRow(Row row) throws DBAccessException {
String ss = "";
int affectableRow = 0;
ss = "delete from " + name + " where ";
for (int i = 0; i < row.length(); ++i) {
String k = row.getKey(i);
ss += k + ((row.get(i) == null)?" is null":"=?"); //设置查询参数有空值处理
if (i != row.length() - 1) {
ss += " and ";
}
}
Connection conn = null;
try {
conn = database.getConnection();
PreparedStatement st = conn.prepareStatement(ss);
int j = 0;//查询参数计数器
for (int i = 0; i < row.length(); i++) {
if (row.get(i) != null) {
st.setObject(++j, row.get(i)); //解析查询参数
}
}
affectableRow = st.executeUpdate();
st.close();
}
catch (Exception ex) {
throw new DBAccessException(InforGeter.getErrorInfor(this, "delRow", ex,
"删除表" + name + "中的数据时出错！"));
}
finally {
database.disConnect(conn);
}
return affectableRow;
}
/**
* 有条件的删除即删除多行
* @param condition
* @param args
*/
public int delRow(String condition, Object[] args) throws DBAccessException {
String ss = "";
int affectableRow = 0;
ss = "delete from " + name + " where ";
ss += condition;
Connection conn = null;
try {
conn = database.getConnection();
PreparedStatement st = conn.prepareStatement(ss);
if (args != null) {
for (int i = 0; i < args.length; i++) {
st.setObject(i + 1, args[i]);
}
}
affectableRow = st.executeUpdate();
st.close();
}
catch (Exception ex) {
throw new DBAccessException(InforGeter.getErrorInfor(this, "delRow", ex,
"删除表" + name + "中的数据时出错！"));
}
finally {
database.disConnect(conn);
}
return affectableRow;
}
}
使用时可以用Database对象的getTable方法传入数据库表的名称来得到一个Table对象。得到这个对象后就可以对这个数据库表进行操作了，这个类提供了六个方法根据传过来的参数对数据库表进行添加修改删除操作。代码中没有特别难懂的地方，需要注意的是我在原有代码的基础上对空值进行的处理，在查询时如果表中的数据是空值的话那么我把字段对应的Java类型放到Row对象里，因为在进行Row对象到值对象的转换时用到了java反射API必须知道Row中的字段值的类型才能去调用值对象的setXXXX方法(见Row对象的toValueObject方法)。
行对象的源码如下：
package com.gdrj.util.database;
import java.util.*;
import java.math.BigDecimal;
import java.lang.reflect.*;
public class Row {
/**
* 排序,由于Hashtable不提供通过索引取得值的方法，并且其中的键值对也不是按照put上去时的顺序排列的。
* 注意：Vector中加入的对象是有序的，即按加入的顺序排列并且能够根据索引访问，可以看成是可变大小的数组
* List可以取代Vector
*/
private Vector ordering = new Vector();
/**
* 存放键值对（表中字段名称与字段值）
*/
private HashMap map = new HashMap();
public Row() {
}
/**
* 向HashMap中追加键值对，即字段名称与字段值
* @param name
* @param value
*/
public void put(String name, Object value) {
if (!map.containsKey(name)) {
ordering.addElement(name); //将键保存起来
}
map.put(name, value);
}
/**
* 得到行对象中字段的个数
* @return
*/
public int length() {
return map.size();
}
/**
* 根据字段名称取得字段值
* @param name
* @return
*/
public Object get(String name) {
return map.get(name);
}
/**
* 根据字段在HashMap中的编号取得字段值
* @param which
* @return
*/
public Object get(int which) {
String key = (String) ordering.elementAt(which);
return map.get(key);
}
/**
* 根据字段序号取得字段名称
* @param which
* @return
*/
public String getKey(int which) {
String key = (String) ordering.elementAt(which);
return key;
}
/**
* 打印，用于调试
*/
public void dump() {
for (Iterator e = map.keySet().iterator(); e.hasNext(); ) {
String name = (String) e.next();
Object value = map.get(name);
System.out.print(name + "=" + value + ", ");
}
System.out.println("");
}
/**
* 将行对象转换成值对象
* @param row
* @param type值对象类型
* @return
* @throws java.lang.Exception 这里的异常一般在DAO中处理，因为DAO调用
* 这个方法进行Row和ValueObject的转换
*/
public static Object toValueObject(Row row, Class type) throws Exception {
Object vo = type.newInstance(); //创建一个值对象
Field[] fields = type.getDeclaredFields(); //得到值对象中所有字段
for (int i = 0; i < fields.length; i++) {
String name = fields[i].getName(); //得到JavaBean的字段名
String nameInRow = toInRowName(name);//在此进行值对象名称到行对象名称的转换
Object value = row.get(nameInRow); //得到从数据库中取出的与字段名对应的值
String methodName = "set" + Character.toUpperCase(name.charAt(0)) +
name.substring(1); //得到setXXXX方法名
Class argClass = null;
if (value instanceof Class) {
argClass = (Class)value;
value = null;
}else{
argClass = value.getClass();
}
Method method = type.getMethod(methodName, new Class[] {argClass}); //得到set方法
method.invoke(vo, new Object[] {value});//调用setXXXX方法
}
return vo;
}
/**
* 根据传过来的值对象和类型把值对象转换到行对象中
* @param vo
* @return
* @throws java.lang.Exception 这里的异常一般在DAO中处理，因为DAO调用
* 这个方法进行Row和ValueObject的转换
*/
public static Row fromValueObject(Object vo) throws Exception {
Row row = new Row();
Class type = vo.getClass(); //得到Class用于进行反射处理
Field[] fields = type.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
String name = fields[i].getName();
String methodName = "get" + Character.toUpperCase(name.charAt(0)) +
name.substring(1);
Method method = type.getMethod(methodName, new Class[] {});
Object value = method.invoke(vo, new Object[] {});
String nameInRow = toInRowName(name);//在此进行值对象中的名称向行对象中的名称转换
row.put(nameInRow, value);
}
return row;
}
/**
* 将值对象中属性名转换成对应的行对象中的字段名(因为行对象中的字段名
* 在更新数据库时必须与数据库表中字段名完全匹配)
* 一般规则为 fsiId ---> fsi_id(现在假设的情况是如果出现有两个单词
* 以上的值对象属性名则数据库表中的字段名一定是有下划线的)
* @param voName
* @return
*/
public static String toInRowName(String voName) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < voName.length(); i++) { //遍历voName如果有大写字母则将大写字母转换为_加小写
char cur = voName.charAt(i);
if (Character.isUpperCase(cur)) {
sb.append("_");
sb.append(Character.toLowerCase(cur));
}
else {
sb.append(cur);
}
}
return sb.toString();
}
}
Row对象中用了一个HashMap对象存放着对应数据库表中的字段名和对应值，由于Map对象的无序性，所以用了一个vector(当然也可以用List代替)来存放字段名(按用户添加的顺序)这样就可以提供get(int i)方法来顺序取得Map中的值了。要注意的是三个静态辅助方法toValueObject，fromVauleObject，toInRowName。toValueObject方法用于将一个行对象转换为值对象方法中利用了Java的多态和反射机制(请大家参考反射API)。FromValueObject是上一个方法的逆操作，toInRowName方法是实现值对象中的属性名向数据库表中字段名的转换，因为一般在数据库建表时是用的这种形式stu_id，而Java中JavaBean的属性是这样的stuId。
RowSet的代码如下：
package com.gdrj.util.database;
import java.util.*;
public class RowSet {
private Vector vector = new Vector();
public RowSet() {
}
public void add(Row row) {
vector.addElement(row);
}
public int length() {
return vector.size();
}
public Row get(int which) {
if (length() < 1) {
return null;
}
else {
return (Row) vector.elementAt(which);
}
}
public void dump() {
for (Enumeration e = vector.elements(); e.hasMoreElements(); ) {
( (Row) e.nextElement()).dump();
}
}
}
这个类就是把Row对象放到Vector以便操作。就不多说了。
为了方便使用我写了一个GeneralDAO类（我对DAO模式还在理解中请各位高手批评指教）代码如下：
package com.gdrj.util.database;
import java.util.*;
public class GeneralDAO {
/**
* 这个DAO对应的表对象
*/
private Table table;
/**
* 默认构造函数
*/
public GeneralDAO() {
}
/**
* 用数据库对象和表名初始化DAO
* @param db
* @param tableName
*/
public GeneralDAO(Database db, String tableName) {
getTable(db, tableName);
}
private void getTable(Database db, String name) {
table = db.getTable(name);
}
/**
* 根据条件将查找到的数据以值对象集合的形式返回
* @param fields 要查找的字段(*或null表示所有字段)
* @param criteria查询条件
* @param args与查询条件对应的参数数组
* @param voType值对象的类型
* @return
* @throws java.lang.Exception
*/
public Collection findDatas(String fields, String criteria, Object[] args,
Class voType) throws Exception {
RowSet rows = table.getRows(fields, criteria, args);
Collection col = new ArrayList();
for (int i = 0; i < rows.length(); i++) {
Object vo = Row.toValueObject(rows.get(i), voType); //返回一个值对象，注意是voType类型的对象
col.add(vo);
}
return col;
}
/**
* 向表中插入一条数据
* @param vo 与表对象对应的值对象
* @return
* @throws java.lang.Exception
*/
public int insertData(Object vo) throws Exception {
return table.putRow(Row.fromValueObject(vo));
}
/**
* 更新一条数据
* @param vo 与表对象对应的值对象
* @param criteria更新条件
* @param args与更新条件对应的参数数组
* @return
* @throws java.lang.Exception
*/
public int updateData(Object vo, String criteria, Object[] args) throws
Exception {
return table.putRow(Row.fromValueObject(vo), criteria, args);
}
/**
* 删除一条数据(条件比较严格各个字段的值必须与值对象中属性的值匹配)
* @param vo
* @return
* @throws java.lang.Exception
*/
public int deleteData(Object vo) throws Exception {
return table.delRow(Row.fromValueObject(vo));
}
/**
* 删除多条数据
* @param condition 删除条件
* @param args与条件对应的参数数组
* @return
* @throws java.lang.Exception
*/
public int deleteDatas(String condition, Object[] args) throws Exception {
return table.delRow(condition, args);
}
}
这个DAO类是对Table类的一个方便的封装。用户如果向操作数据库只要创建一个Database对象，一个DAO对象，一个值对象(对应表结构)，然后就可以进行方便的数据库操作了，下面给出一个实例来演示这个小小框架的用法。
演示程序
首先建立一个teacher表，语法如下
create table teacher (
id int not null,
name varchar(20) not null,
birthday smalldatetime null,
address varchar(100) null,
income money null,
constraint id PRIMARY KEY NONCLUSTERED ( id )
)
然后建立一个与teacher表对应的值对象类。
public class TeacherVO implements Serializable {
private Integer id;
private String name;
private String address;
private BigDecimal income;
private java.sql.Timestamp birthday;
public TeacherVO() {
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public java.sql.Timestamp getBirthday() {
return birthday;
}
public void setBirthday(java.sql.Timestamp birthday) {
this.birthday = birthday;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public java.math.BigDecimal getIncome() {
return income;
}
public void setIncome(java.math.BigDecimal income) {
this.income = income;
}
public String toString(){
return " 编号：" + id + " 姓名：" + name + " 生日：" + birthday
+ " 地址：" + address + " 收入：" + income;
}
}
最后主程序的源码如下：
package org.together.jdbcwrap.test;
import java.util.*;
import com.gdrj.util.database.*;
public class GeneralDAOExample {
public static void main(String[] args)throws Exception {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Database db = new Database("jdbc:odbc:emmis","sa","815023");
GeneralDAO dao = new GeneralDAO(db,"teacher");
/**
* 利用GeneralDAO进行查询
*/
Collection col = dao.findDatas("*","birthday is null",null,TeacherVO.class);
for (Iterator iter = col.iterator(); iter.hasNext(); ) {
Object item = iter.next();
System.out.println("item = " + item);
}
/**
* 利用GeneralDAO进行添加
*/
TeacherVO vo = new TeacherVO();
vo.setAddress("沈阳");
vo.setBirthday(new java.sql.Timestamp(0));
vo.setId(new Integer(11));
vo.setIncome(new java.math.BigDecimal(1000));
vo.setName("陶小川");
// dao.insertData(vo); //添加一条记录
// dao.updateData(vo,"id=10",null); //更新一条记录
// dao.deleteData(vo); //删除一条记录
// dao.deleteDatas("id>5",null); //添加符合条件记录
}
}
<淘宝热门商品：
来源：
程序员网
1995年，Java还仅仅是一种计算机语言概念；而到了今天，经过8年发展，Java技术已经渗透到了世界的各个角落—小到生活中的电话、烤面包机，大到汽车生产乃至控制“火星漫游者”的临界任务系统中，都有它的身影。
据不完全统计，当今全球已经拥有超过300万的Java开发者，超过2.67亿部支持Java的电话，以及有超过3亿的Java卡在世界各地被配置。
更有甚者，在与其对手“.NET”的竞争中，Java也逐渐站稳了脚跟。
那么，Java将如何加快自己的市场化步伐，带领Sun走出连续几个财季的亏损呢？在下一个8年，Java又将走向何方？它会不会被更新的技术所取代？许多关于Java的问题始终萦绕在关心其发展的人的周围。
初生：一鸣惊人
天下父母皆对子女充满信心，James Gosling对Java的应用前景更是深信不疑。他认为没有任何技术可以取代它，而Java也必将带来技术领域的一次革命。
郭旭：
作为Java语言的创始人，请您为我们的广大读者介绍一下Java的应用前景，特别是与“.NET”的比较。
James Gosling：
作为一种编程语言，Java是目前世界上最为完备的，它有独到的一整套运作环境，那就是J2EE。Java非常适于设计大型的、企业级的系统。
从某种意义上来说要我去评价“.NET”很难，因为作为其一部分的C＃语言只是在复制Java功能上做得很成功。目前看来，“.NET”的市场基本是在小型系统上。
Java与竞争者的最大不同在于：前者首先提供了开放性的竞争市场，比如说用户要购买一台服务器的话，它可以根据行业特点选择最适合的产品，进而与本行业内做得最好的厂商来合作，而不管这产品是IBM的、BEA的，还是Sun的；其次，Java有先进的组织方式（JCP，团体程序），其涵义指的是Java的所有程序都是由使用Java的人来设计的。不同的专家组组成了技术的中坚力量，专家组成员有SUN公司的工程师，同时也有来自其他世界著名公司、大学的相关专家。
郭旭：
但“.NET”也是微软与许多合作伙伴来共同开发的。Java的JCP与微软的合作伙伴开发有什么本质区别吗？
James Gosling：
最大的区别在于微软的合作伙伴和开发群体只允许使用“.NET”一种工具，而Java开发中，各种工具都可以参与进来。
从技术上来说，“.NET”架构更适用于小型的、简单的系统，如果系统运用再成熟、再复杂一点的话，它就不适用了。而Java则有一整套能帮助用户的数据库、交易、集群、分布、表格等功能，它能把网络中不同的资源进行集中，提供端到端的运营体系。
郭旭：
Java技术、“.NET”技术将来会呈怎样的发展趋势，它们会不会随着技术的进步被更新的技术所取代？
James Gosling：
我可以断言：在与“.NET”的竞争中，最后的胜利者一定是Java，几年后Java就将是此领域内的事实标准。目前看来，要找到一种新的技术来全面取代现有技术是非常困难的。
Java已经在所有领域和其他技术展开了全面竞争，且取得了较大的领先优势。比如在嵌入式领域，在网络终端越来越智能化的情况下，我们成功设计了Java智能化手机功能并抢占了巨大市场;而在远程控制、汽车、家电和工业自动化领域中，我们也都取得了巨大的成功。
前不久，我们为巴西医疗系统设计了一个控制软件，使得所有的X光机、CT机，以及其他设备和病人的资料、处方情况都通过Web Service联系起来，并分配到每个医生手中。病人相关资料可以随时被激活，整个医疗系统完全整合在了一起。这些都是几年内其他技术所难以追赶的，更别说取代了。
成长：经风历雨
围绕是否在Windows中捆绑Java，以及如何捆绑的问题，Sun和微软已上了不止10次法庭。但随着微软确定Windows不再带Java“玩”的最后期限，这些争执似乎都快结束了。Java将如何推广自身市场？
郭旭：
一直以来，Sun公司给业界的印象是，技术做得很好但市场做得并不好，这也直接影响了Sun的销售业绩，降低了Sun的竞争力，您怎么看？
James Gosling：
其实我们的每一次市场营销计划都是和我们的产品、技术相结合的。当然，Sun一直以技术见长，这也是我在SUN长期工作的最大原因。SUN始终坚信只有拥有优质的产品才可能占领最大的市场，我们投入更多的资金在产品研发而不是在产品的市场推广上。
郭旭：
目前，微软已经停止在其Windows XP中预置Java，而到明年1月，其他版本Windows系统中也将不再预置Java，这显然给Java在PC市场上的推广出了个不小的难题。那么，Java应该怎样或者已经怎样来进行市场推广呢？
James Gosling：
实际上我个人非常高兴微软宣布对Java虚拟机采取这样的手段，这恰恰说明了Java技术的强大。但应该是微软改变它对Java一些非常过分做法的时候了，因为就为这些做法微软被美国许多法庭判决有罪，现在的微软官司缠身。
微软不预置我们的产品，并不会对我们造成太大影响。因为即使是现在捆绑在Windows上的Java也是6年前的产品了。目前我们很多用户是直接到我们的网站上去下载最新的Java版本的。
我们已和很多的原设备制造商签订了合作协议，在他们的产品中捆绑我们的Java产品。这对Java的市场推广来说是一个更好的消息。而我们的产品也可以在其他系统如Linux中使用，所以我们并不担心市场推广。
郭旭：
我们知道，Java公共平台开发较早，技术、市场也比较成熟。但在一些国家由于受使用习惯的影响，以前经常使用微软的VB、VC等开发软件，所以相比Java来说肯定更多的人会愿意选择微软的“.NET”。那么，是不是在发达地区比如美国等地使用Java的人多一点，而在如中国这样的“IT发展中国家”使用“.NET”的会多一些呢？
James Gosling：
事实恰恰相反。Java在新兴市场做得更好，业绩远远超过“.NET”。这首先是因为“.NET”的许可使用费昂贵，而Java的性价比更高;其次，微软对“.NET”的控制太严格，不允许用户有丝毫改动，而Java则鼓励用户改变;此外，“.NET”是和微软其他系统联在一起的，对于非Windows下的应用开发就没用了，而Java开放性强，适合于开发基于所有其他系统的应用。
郭旭：
您是否满意于目前Java在中国的推广？
James Gosling：
中国的Java推广得非常好，中国应该更快接受这个技术，并对其进行适用性改造，进而开发更多用“.NET”无法开发的应用，迎来中国软件产业发展的契机。
而今：期待反哺
当IBM、HP等利用Java疯狂盈利的时候，作为Java的创始者的Sun却在经历连续几个财季的亏损，这是为什么呢？
郭旭：
作为创造者，Sun虽然不遗余力地推广Java，但却并不是最大的受益者，那么Sun每年从Java直接得来的收益到底有多大？未来又如何？
James Gosling：
目前公司的财务状况的确不像前几年那么好，但这主要是因为公司过去的收入全部来自销售企业级系统和硬件，而受限于全球经济和需求的状况，目前在这一块还有困难。
正因为如此，Sun在加强多样化发展战略，正逐步将注意力转移到其他系统上去。我们正从软件方面得到更多的收入，因为其拥有较高的利润率。同时，我们的多样化战略还包括开发低端的、低成本的产品。只要给我们多一些时间，相信SUN有能力做得更好。
郭旭：
什么样的低成本产品？
James Gosling：
我所说的低成本产品主要是指一些小型服务器，集成子系统等，在这方面我们是和Intel及Linux厂商合作的。
未来：充满希望
郭旭：
您认为近几年都有哪些具有革命性的信息技术？在可以预见的未来是否能有什么新兴的、可以带来产业革命的新技术出现？
James Gosling：
应该说没有单个的革命性创新。其实任何一个革命性的创新技术都是一系列的、不断进化的、渐进性的革新的总和。
近几年有两大较大的发展趋势是比较重要的：首先是计算机的计算能力、功能越来越强大。可以预测的是计算机的能力肯定会以几何级速来增长。这种程度的增长必定会导致应用模式等的变化。其次就是网络的普遍性越来越快，所有的处理器、设备都被联到了网络之中。
郭旭：
怎样看待Linux与开放源代码？
James Gosling：
Sun一直不遗余力地支持着开放源代码软件的开发工作，当然也包括Linux。我想虽然没有人做过财务上的统计，但SUN做的支持开放源代码软件开发的工作肯定比其他任何公司都多。如果说未来会有什么新兴技术出现的话，应该就是Linux带来的，但目前看来这还并不怎么明显。
人物印象*人物印象*人物印象*人物印象*人物印象
“软件之父”还是“软件疯子”？
“叮……”狂燥的电话铃声在一个风雨交加的凌晨3点突然响起，James Gosling的朋友拿起电话破口就嚷：“你疯了吗？Gosling，半夜三更的，还让不让人睡觉呀？！”听着朋友出离愤怒的声音，Gosling笑了，因为他知道他这个想法成功了—今天威风八面的Java就是在这样一个电话中萌芽的，这也是“Java之父”的诞生场景。
对搞软件的人来说，如果能被称为“某某之父”，那显然是对其全身心投身软件事业的最大承认,显然，James Gosling在业界已经获得了这样的荣誉。但从另一个侧面看，他却拥有另一种荣誉：如果让12个Java开发者用一个词语来形容James Gosling的话，则必有一打的人会选择“疯子”这个词—这也是记者与James Gosling长达2小时谈话中的主线。
在James Gosling眼中，一个合格的程序技术人员首先必须具备激情与锲而不舍，并准备时刻发疯。“他们不能容忍发疯式的创造，所以我选择了离开。”很多人不愿谈起自己不成功的经历，但James Gosling却并不在乎，他如此坦然面对仅仅在IBM工作了一年半的经历，实在是因为在他看来，因价值观的不同而离开一个公司没什么丢人的，相反，却值得颂扬。
在James Gosling看来，一个成功的软件人士需要一定的技能，但不是全部，你必须将这些技能与你在正确的时间做正确的事情、与你百折不挠的精神、与你发疯的激情结合在一起。精力充沛、永远有好奇心是必需的，而且必须要时常发疯，做一些别人看来不可思议的事情。当你将你的一个想法告诉朋友，他们都认为你是疯人做疯事的时候，那么你已经成功了一半—这就是James Gosling的终极人生观。
“在最底层的软件开发上，中国和世界上其他国家是一样的，但在上层的应用开发上却有自己鲜明的民族特点，突出个性化是中国软件工程师最最要的，我相信凭中国人的韧劲完全没有问题”，在采访结束时，他还不忘叮嘱记者转告中国软件工程师这段话，当然，他最后还是补充了一句：“多一些发疯！”
<淘宝热门商品：
如下所述，MVC结构可以映射到多层的企业级J2EE应用程序：
所有的企业级数据与用于处理数据的事物逻辑都能用这个模型来 表示。
视图可以通过这个模型存取数据，然后决定如何将数据表达给客 户。当模型改变时，视图必须确认给用户所表达的内容也跟着改变。
控制器可以与视图交互，并且将客户的行为转换为模型可以理解 与执行的行为。控制器也根据最新的客户行为与相关的模型行为来决 定下一个要被显示的视图是什么。
将上述的逻辑应用到金融应用程序例子中，您将这样建造应用程序：
应用程序的事务逻辑由组成MVC结构中的模型的EJB来代表。模型 对来自控制器的要求作出反映，并存取/修改相应的数据。
应用程序界面的不同屏组成MVC结构中的视图。当模型改变时，视 图自动更新。
应用程序的控制器是一些对象的集合，这些对象接收用户的行为， 并且将其转换为模型可理解的请求，一旦模型完成了对请求的处理， 就决定下一个要显示在屏幕上的内容是什么。
想要在一个小例子中将MVC结构完全展示出来是非常困难的。 J2EE蓝图 程序 中的Java宠物商店演示程序是一个很好的基于MVC结构的完整的J2EE应用 程序的例子。
注意事项
MVC结构适合于高
MVC结构适合于高度交互的系统，这种系统需要可扩展性、可维护性与多用 户视图。
MVC 将表述、用户交互与系统模型解耦合。
由于不存在耦合，将多数据集表述在多视图中就变得很容易。同时也使得 为新的客户类型提供支持更为简单。
使用这种结构，代码冗余被最大限度地减少了。
通过将表述、模型、全面的应用程序流程这三者分开，这个结构使得不同 的开发者可以负责不同的模块，于是，产品上市的时间就快了。
<淘宝热门商品：
再说一次，不是所有的Java类都是可序列化的。举个例子，图2表明Socket类是不可序列化的。
序列化用户自己的类
现在，让我们看看如何序列化用户自己写的类。在这个例子中，我们将建立一个用户类UserInfo，见例程3。为了让它可序列化，UserInfo类实现了Serializable接口。
例程 3: UserInfo.java
import java.io.*;
import java.util.*;
public class UserInfo implements Serializable {
String name = null;
public UserInfo(String name) {
this.name = name;
}
public void printInfo() {
System.out.println("The name is: "+name);
}
}
下一步就是建立一个能创建UserInfo类实例的类，然后将对象写入输出流中，如例程4。本例中的输出流是一个名为"name.out"的文件。要注意的是，例程4 中的writeObject方法可以被调用任意多次，将任意多个对象写入输出流。
例程 4: SaveInfo.java
import java.io.*;
import java.util.Date;
public class SaveInfo {
public static void main(String argv[]) throws Exception {
FileOutputStream fos = new FileOutputStream("name.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
// create two objects
UserInfo user1 = new UserInfo("Java Duke");
UserInfo user2 = new UserInfo("Java Blue");
// write the objects to the output stream
oos.writeObject(user1);
oos.writeObject(user2);
oos.flush();
oos.close();
fos.close();
}
}
最后，我们写一个将已经保存的对象读入的类，并且调用一个如例程5所示的方法。和writeObject 一样，readObject方法能被调用任意多次，从输入流中读入任意多个对象。
例程 5: ReadInfo.java
import java.io.*;
import java.util.Date;
public class ReadInfo {
public static void main(String argv[]) throws Exception {
FileInputStream fis = new FileInputStream("name.out");
ObjectInputStream ois = new ObjectInputStream(fis);
// read the objects from the input stream (the file name.out)
UserInfo user1 = (UserInfo) ois.readObject();
UserInfo user2 = (UserInfo) ois.readObject();
// invoke a method on the constructed object
user1.printInfo();
user2.printInfo();
ois.close();
fis.close();
}
}
要测试这个例子，请编译如下源文件：UserInfo.java, SaveInfo.java, 和 ReadInfo.java。运行 SaveInfo，然后运行ReadInfo，将看到类似下面的输出结果：
The name is: Java Duke
The name is: Java Blue
<淘宝热门商品：
这时展现在你眼前的第一个页面，如上图。第一个页面就是你原来将来过的监视Project（就当成一个Project好了）。第二个页面是需要创建新的监视Project。
这时你就可以点击按钮"New session"按钮了。下一个页面将会出现在你的眼帘之中。
第一个就是Session名字了，随便取（不修改也行），
第二个Session type就是监视类型了，我们就选择监视本地的系统吧。
然后选择Java VM。在安装Jprofiler时，搜索出系统已经安装了的jvm，选择一个好了。
Working directory：这个目录启动系统的运行目录，方便于你找那儿些配置文件，以及寻找你classpath中配置的jar文件
VM arguments参数，如果你想配置JVM的系统参数请在此配置，比如么配置内存的最大，最小值，配置方式和常用配置方式类似。
Main class or executable JAR：选择可以直接运行的jar文件或者填上要运行主Class。（如果你的jar文件中META－INF/MANIFEST.MF 包含有Main-Class:就可以直接运行了）
Arguments就是main(String[] args)中要传递的参数
然后就该Additional java file path中加入所有需要的classpath或者jar文件
这些配置搞定后就可以点击ok按钮了，在评估版本中将会弹出一个对话框（就是通知你评估版本还有多长时间过期），不管那么多点击按钮"Evaluate"，然后继续点击按钮"ok"
好了，我们可以看看我们的劳动成果了，倒杯Coffee，享受那浓浓Coffee情。
这是内存使用情况
这是每个class，甚至每个方法的内存使用比率
这是线程使用情况
里面还有更多更多的好东西，等待你的发现哦。
非常愿意和你共享
<淘宝热门商品：
