Micheal

1.<a   href="javascript:self.focus();self.print();">打印</a>

2.selected from :http://www.chinaue.com/html/2006-4-20/20064201622421.htm

javascript. 打印大全  —— selected from：http://jerrie.9hy.com/contents/1155176737.phtml

conn = getConnection();
stmt = conn.prepareCall(sql);
stmt.registerOutParameter(1,OracleTypes.CURSOR);
stmt.execute();
rs = ((OracleCallableStatement)stmt).getCursor(1);
while(rs.next()){
String country = rs.getString(1);
String pno = rs.getString(2);
System.out.println(“country:“+country+“|pno:”+pno);

2.multi result return by procedure

Multiple ResultSets at a glance
(http://www.javaworld.com/javaworld/jw-02-2000/jw-02-ssj-jdbc2.html)
The theory behind handling multiple ResultSets is very simple. The database driver handles a set of ResultSets instead of the single 
ResultSet you may be used to. Thus, the logical (and simplified) structure returned by a database call of either the multiple SQL 
queries scenario or the CallableStatement multiple ResultSet scenario can be thought of as a java.util.List. The elements of that 
List are the ResultSets returned by the database as a response to the SQL query. 
You can retrieve the current element in the results list by using the getResultSet() or getUpdateCount() method. There is no method 
in the JDBC that will tell you what type of result you are currently examining (for example, a ResultSet object or updateCount int 
primitive). Instead, the two getter methods return special results (null or -1) to indicate that the current result is of an unexpected 
type. Both getter methods return special results when the end of the results list has been reached. You can use the getMoreResults() 
method to move the current result reference forward in the list of database results. Note that the getMoreResults() method should close 
any ResultSet it previously opened -- but I recommend testing the JDBC driver implementation before assuming that this is the case. 

import java.sql.*;

public abstract class MultipleResultsets
{
  // Logger helper class
  public static Logger log;

  public static Connection setupConnection() throws Exception
  {
      // Load the database driver
      Class.forName(<databaseDriverClass>);

      // The Logger directs output to the file "log.txt"
      log = new Logger("log.txt");
      log.log("Time: " + new Timestamp(System.currentTimeMillis()));

      // Open a connection to the database
      return DriverManager.getConnection(<jdbcURL>, <login>, <password>);
  }

  public static void processStatement(PreparedStatement stmnt) 
  throws Exception
  {
      // Execute the statement. The boolean return parameter
      // denotes the kind of result obtained from execution.
      boolean returnedResultSet = stmnt.execute();
      int rsIndex = 0;

      while(true)
      {
          // Did we get a ResultSet?
          if(! returnedResultSet )
          {
               // This might be an update count 
               int updateCount = stmnt.getUpdateCount();

               if(updateCount == -1)
               {
                  System.out.println("\nDone handling all results.");
                  break;
               }

               // This IS an update count
               log.log("Updated " + updateCount + " database rows.");
          }
          else
          {
               // This should be a ResultSet
               ResultSet rs = stmnt.getResultSet();
               ResultSetMetaData rsmd = rs.getMetaData();

               // Log ResultSet geometry here, so that we may 
               // see  the number of columns in the ResultSet
               log.log("Got ResultSet[" + (++rsIndex) + "]: " 
                                        + rsmd.getColumnCount() + " columns.");

               // Do not forget to close the ResultSet and 
               // release the database resources owned by it!
               // 
               // Since we use the getMoreResults() method to
               // obtain the next ResultSet or updateCount, the
               // explicit close is not required. However, I do
               // recommend closing explicitly at all times to
               // eliminate bad driver behavior/implementation.
               // 
               // Check, for instance, the JDBC/ODBC bridge driver here....
               rs.close();
          }

          // Get the next ResultSet returned from the Statement.
          // If there are no more Results, the getMoreResults method
          // will return false.
          if(!stmnt.getMoreResults()) break;
      }
  }
}

http://lthu.javaeye.com/blog/147601