语源科技BlogJava-yutian727

loadrunner监控linux和weblogic安装文档

牛宝雷 — Mon, 25 Feb 2008 03:10:00 GMT

       很久没上来活动了，一来没什么新的学习东西，这一年有些堕落了，二来嘛，工作就是重复，可能是太笨了，没什么新的领悟
       不过这两天有意思了，我学习了一下压力测试的东西，loadRunner，以前听同事们说过，感觉是个很有意思的东西，可是一直没有机会学。现在好了，给别人做了回助手，也了解了一下loadRunner的一些使用。
       不想在这里讨论使用，我还不够资格，讲些安装吧，说一下如何用lr来监控linux和weblogic，这可是我自己的安装心得哦。
        对linux的安装有些来自网上，出处有些记不清了，反正查了很多，可是多少有些问题，我做了下说明，可以参考。

一、loadrunner监控linux安装文档

1．安装rsh，和rsh-server两个服务包。
a. 卸载rsh
rpm –q rsh----------查看版本号

说明：如果版本存在，则直接安装rpc.rstatd-4.0.1.tar.gz
　　　如果版本不存在，则在linux安装包下找rsh-0.17-14.i386.rpm rsh-server-0.17-14.i386.rpm
　　　可能版本不一致，但是均可使用

B．安装

rpm –ivh rsh-0.17-14.i386.rpm rsh-server-0.17-14.i386.rpm

2．下载并安装rstatd（这个包在我的共享目录下也有）
gunzip rpc.rstatd-4.0.1.tar.gz

tar –cvf rpc.rstatd-4.0.1.tar

./configure ---配置
make ---编译

说明：a.如果在linux下不能解压，则在window下解压，然后拷到linux下，目录不定，用户为root用户
　　　b.修改configure文件的使用权限
　　　 chmod 777 configure
c.按照上面的步骤操作

3。打开/etc/xinetd.conf
里面内容是：
# Simple configuration file for xinetd
#
# Some defaults, and include /etc/xinetd.d/
defaults
{
        instances               = 60
        log_type                = SYSLOG authpriv
        log_on_success                = HOST PID
        log_on_failure                = HOST
        cps                        = 25 30
}
includedir /etc/xinetd.d

4．重启xinetd：

A:
service xinetd reload

说明：可能会有提示出现，不用处理，直接进入下一步

6．在启动rstatd：
　　进入你rpc.rstatd-4.0.1.tar.gz的解压文件目录
　　rpc.rstatd

7.查看rstatd是否启动：

rpcinfo –p

如果能看到：

100001 5 udp 618 rstatd

100001 3 udp 618 rstatd

100001 2 udp 618 rstatd

100001 1 udp 618 rstatd

就说明rstatd服务已经启动。可以用LR去监视了。

二、loadrunner监控weblogic8.1

1.拷贝weblogic.jar到${lr_home}/classes下，同时，删除jmxri.jar或者修改jmxri.jar为任何名称
2.修改${lr_home}/dat/monitors下的WebLogicMon.ini文件，内容如下：
原始内容为：JVM=javaw.exe JavaVersion=1.4;JavaVendor=Sun Microsystems Inc.
　修改后内容为：JVM=D:\bea\jdk141_03\bin\javaw.exe JavaVersion=1.4;JavaVendor=Sun Microsystems Inc.
　其中D:\bea\jdk141_03\bin\javaw.exe为自己本地weblogic的jdk所在位置
　javaVersion为weblogic所用的jdk版本号
　
　在网上有的要求修改Weblogic=weblogic.jar　Port=1112，要求把PORT修改为7001，但在这里的实际安装过程中，没有做修改。
3.配置如何监控lr的weblogic(jmx)
　打开weglogic(jmx),添加度量
　其中监控的计算机名称为：ip:7001，如192.168.1.88:7001，平台选择所写ip的OS
然后点击下面的资源度量的添加，输入登录的用户名和密码，此处的用户名和密码为：ip所在OS上的weblogic的登录用户名和密码
　在点击确定后会出现需要监控的资源信息，可以选择自己感兴趣的方面进行监控

牛宝雷 2008-02-25 11:10 发表评论

java.lang.String中，match()的用法，即String.match(String pattern)

牛宝雷 — Mon, 03 Dec 2007 10:04:00 GMT

摘要: String.match()方法阅读全文

牛宝雷 2007-12-03 18:04 发表评论

JAVA 处理时间 - java.sql.Date、java.util.Date与数据库中的Date字段的转换方法[转]

牛宝雷 — Mon, 12 Nov 2007 02:16:00 GMT

１、如何将java.util.Date转化为java.sql.Date?
转化：

java.sql.Date sd;
java.util.Date ud;
//initialize the ud such as ud = new java.util.Date();

sd = new java.sql.Date(ud.getTime());

２、如果要插入到数据库并且相应的字段为Date类型
那么可以用PreparedStatement.setDate(int ,java.sql.Date)方法
其中的java.sql.Date可以用上面的方法得到

也可以用数据库提供TO_DATE函数
比如现有 ud
TO_DATE(new SimpleDateFormat().format(ud,"yyyy-MM-dd HH:mm:ss"),
"YYYY-MM-DD HH24:MI:SS")
注意java中表示格式和数据库提供的格式的不同

一个实际的例子

sql="update tablename set timer=to_date('"+t+"','yyyymmddhh24miss') where ....."

这里的t为变量为类似:20051211131223

３、如何将"yyyy-mm-dd"格式的字符串转换为java.sql.Date

方法１

SimpleDateFormat bartDateFormat =
        new SimpleDateFormat("yyyy-MM-dd");
       String dateStringToParse = "2007-7-12";
       try {
        java.util.Date date = bartDateFormat.parse(dateStringToParse);
        java.sql.Date sqlDate = new java.sql.Date(date.getTime());
        System.out.println(sqlDate.getTime());
       }
       catch (Exception ex) {
        System.out.println(ex.getMessage());
       }

------------------------------------------------------------
方法２
       String     strDate     =     "2002-08-09";
       StringTokenizer     st     =     new     StringTokenizer(strDate,     "-");
       java.sql.Date     date     =     new     java.sql.Date(Integer.parseInt(st.nextToken()),
                Integer.parseInt(st.nextToken()),
                 Integer.parseInt(st.nextToken()));

java.util.Date和java.sql.Date的异同

java.sql.Date,java.sql.Time和java.sql.Timestamp三个都是java.util.Date的子类（包装类）。

但是为什么java.sql.Date类型的值插入到数据库中Date字段中会发生数据截取呢？

java.sql.Date是为了配合SQL DATE而设置的数据类型。“规范化”的java.sql.Date只包含年月日信息，时分秒毫秒都会清零。格式类似：YYYY-MM-DD。当我们调用ResultSet的getDate()方法来获得返回值时，java程序会参照"规范"的java.sql.Date来格式化数据库中的数值。因此，如果数据库中存在的非规范化部分的信息将会被劫取。

在sun提供的ResultSet.java中这样对getDate进行注释的：
Retrieves the of the designated column in the current row of this ResultSet object as a “java.sql.Date” object in the Java programming language.

同理。如果我们把一个java.sql.Date值通过PrepareStatement的setDate方法存入数据库时，java程序会对传入的java.sql.Date规范化，非规范化的部分将会被劫取。然而，我们java.sql.Date一般由java.util.Date转换过来，如：java.sql.Date sqlDate=new java.sql.Date(new java.util.Date().getTime()).
显然，这样转换过来的java.sql.Date往往不是一个规范的java.sql.Date.要保存java.util.Date的精确值，
我们需要利用java.sql.Timestamp.

Calendar

Calendar   calendar=Calendar.getInstance();
//获得当前时间，声明时间变量
int   year=calendar.get(Calendar.YEAR);
//得到年
int   month=calendar.get(Calendar.MONTH);
//得到月，但是，月份要加上1
month=month+1;
int   date=calendar.get(Calendar.DATE);
//获得日期
String   today=""+year+"-"+month+"-"+date+"";

牛宝雷 2007-11-12 10:16 发表评论

[转]JSF的学习笔记提纲

牛宝雷 — Fri, 28 Sep 2007 08:03:00 GMT

最近开始学习JSF了，有网上找了一个学习的提纲，以为不错

使用JSF
一、入门
1. hello world
2. Navigation
3. Navigation rules configuration
4. JSF Expression Language
   #{param.name}   隐含对象
5. I18N

二、Managed Beans
1. Backing Bean（Glue Bean）
2. Beans的状态与设置
3. Beans上的List、Map

三、数据转换与验证
1. 标准转换器


2. 自定义转换器
3. 标准验证器
   语法检验、语意检验

4. 自定义验证器
5. 错误信息处理
   messages.properties
6. 自定义转换、验证标签
   Tag Library

四、事件处理
1. 动作事件
   ActionEvent
   actionListener
2. 即时事件
   immediate="true"
3. 值变事件
   valueChangeListener
4. phase（分阶段）事件

JSF标签
一、标签入门
1. 简介JSF标准标签
2. 输出类标签
   1) outputLabel
   2) outputLink
   3) outputFormat
   4) outputText
3. 输入类标签
   1) inputText
   2) inputTextarea
   3) inputSecret
   4) inputHidden
4. 命令类标签
   1) commandButton
   2) commandLink
5. 选择类标签
   1)
   2) 、、
   3) 、、
   4) 、

二、表格处理
1. 简单的表格
   、
2. 表头、表尾


   CSS
3. TableModel类别
   数组
   java.util.List
   java.sql.ResultSet
   javax.servlet.jsp.jstl.sql.Result
   javax.faces.model.DataModel

参考资料：
http://caterpillar.onlyfun.net/Gossip/JSF/JavaServerFaces.htm

牛宝雷 2007-09-28 16:03 发表评论

利用Jakarta Commons组件beanutils、dbutils简化JDBC数据库操作（二）

牛宝雷 — Thu, 20 Sep 2007 03:09:00 GMT

二、Jakarta Commons dbutils：
    用JDBC API时最令人讨厌的就是异常处理，也很烦琐，而且很容易出错，本人曾考虑过利用模板进行处理，后来看到了dbutils，之后就采用那个dbutils，采用模板的方式各位朋友可以参考Spring，Spring的JdbcTemplate不灵活而强大，呵呵，说句闲话，实在太佩服Rod Johnson了，Rod Johnson真的很令人尊敬。
    Dbutils的QueryRunner把大多数与关闭资源相关的封装起来，另外，你也可以使用DbUtils进行关闭，当然DbUtils提供的功能当然不止这些，它提过了几个常用的静态方法，除了上述的关闭资源外，DbUtils. commitAndClose(Connection conn)还提供事务提及等操作。
还是以一个例子来说说吧，毕竟我不是搞业务的，小嘴巴吧嗒吧哒不起来啊，呵呵。
    为了和采用Beanutils更好的进行对比，这个例子还是实现同样的功能，数据库同样采用前一篇文章中提到的publish。
同样的，用你喜欢的编辑器建立一个类DbutilsJDBCTest，示例代码如下所示:
package cn.qtone.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapListHandler;
public class DbutilsJDBCTest{
    public static void main(String[] args) {
        Connection conn = null;
        String jdbcURL = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
        String jdbcDriver = "com.mysql.jdbc.Driver";
        try {
            DbUtils.loadDriver(jdbcDriver);
            // Username "root". Password "root"
            conn = DriverManager.getConnection(jdbcURL, "root", "root");
            QueryRunner qRunner = new QueryRunner();
            System.out.println("***Using MapListHandler***");
            //以下部分代码采用Map存储方式，可以采用Bean的方式代替进行处理
            List lMap = (List) qRunner.query(conn,
                    "select title,authors  from books", new MapListHandler());
            //以下是处理代码，可以抽取出来
System.out.println("title ------------- authors ");
                for (int i = 0; i < lMap.size(); i++) {
                        Map vals = (Map) lMap.get(i);
                        System.out.println(vals.get("title")+"-------------"+ vals.get("authors"));
                }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
    }
}

怎么样?是不是比采用Beanutils的ResultSetDynaTrial和RowSetDynaClass好多了？采用Beanutils令人难缠的是关闭那些资源以及处理那些异常，而这里采用Dbutils显然代码量减少了很多。
上例在处理结果集时，它把数据库中的每一行映射成一个Map，其中列名作为Key，该列对应的值作为Value存放，查询的所有的数据一起放在一个List里，然后进行处理，当然，一个更明智的处理是直接返回List然后再单独进行处理。
事实上上例返回的结果集中的每一行不必放在一个Map里，你可以放在一个Bean里，当然如果你真的很懒，你也可以使用Beanutils的LazyDynaClass和LazyDynaBean，不过也许没有必要那么做，至于原因请看下文。

如果使用Bean而不是用Map，那么，你也许需要建立一个Bean，如下：
package cn.qtone.test;
public class Book {
    public int id;
    public String title;
    public String authors ;
    public StudentBean() {
    }
    public String getAuthors() {
        return authors;
    }
    public void setAuthors(String authors) {
        this.authors = authors;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
}

然后简单修改一下DbutilsJDBCTest 中的部分代码即可，代替之后的源代码如下：

package cn.qtone.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanListHandler;

public class DbutilsJDBCTest{
    public static void main(String[] args) {
        Connection conn = null;
        String jdbcURL = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
        String jdbcDriver = "com.mysql.jdbc.Driver";
        try {
            DbUtils.loadDriver(jdbcDriver);
            // Username "root". Password "root"
            conn = DriverManager.getConnection(jdbcURL, "root", "root");
            QueryRunner qRunner = new QueryRunner();
            System.out.println("***Using BeanListHandler ***");
            //以下部分代码采用Map存储方式，可以采用Bean的方式代替进行处理
List lBeans = (List) qRunner.query(conn," select title,authors from books ", new BeanListHandler(Book.class));
    //以下是处理代码，可以抽取出来
System.out.println("title ------------- authors ");
    for (int i = 0; i < lBeans.size(); i++) {
            Book vals = (Book) lBeans.get(i);
          System.out.println(vals.getTitle ()+"-------------"+ vals. getAuthors ());
                }
        } catch (SQLException ex) {
            ex.printStackTrace();
        } finally {
            DbUtils.closeQuietly(conn);
        }
    }
}
    这两种法输出的结果应该是一样的。两种处理方式都差不多，但我更愿意采用第一种，因为第一种少写一个bean，而且我测试过采用Map的方式即第一种方式性能要好的多，采用Bean性能比较低可能是因为采用反射的缘故，采用反射的东东性能和不采用反射的还是有点差距。也是这个原因，不推荐采用LazyDynaClass和LazyDynaBean，因为采用这二者是在运行期动态创建Bean类和Bean属性，然后再创建Bean对象的，其性能可想而知了（不过我没有测试过啊，所以我说这个话可说是没有根据的，感兴趣的朋友自己测试一下，记得告诉我结果哦，呵呵），除了MapListHandler以及BeanListHandler之外，DButils还提供了其他的Handler，如果这些不能满足你的需求，你也可以自己实现一个Handler。
    最后，也是最大的体会,也许是最大的收获吧，那就是:对于每一个项目,在根据每一个需求获取相应解决方案时,先寻找开源组件,看是否已经有满足某些功能需求的开源组件,如果没有,再考虑自主开发或者向第三方购买，否则尽量采用开源组件.
    请尽量享用开源的魅力，尽情的拥抱开源吧。

牛宝雷 2007-09-20 11:09 发表评论

利用Jakarta Commons组件beanutils、dbutils简化JDBC数据库操作（一）

牛宝雷 — Thu, 20 Sep 2007 03:08:00 GMT

好久没有写过blog了，因为这段时间做的也就是这些，job,dblink,procedure,view等等吧，项目刚刚做完，我有幸调到金融行情的服务器部门工作，现在正在学习JAKARTA的东西．现在网上找了一下相关资料，现放在此处，以后常学习

关键字：beanutils、dbutils、JDBC 数据库
摘要：本文简单介绍了Jakarta Commons旗下beanutils、dbutils在基于JDBC API数据库存取操作中的运用。
   虽然现在出现了很多ORM框架，可是还是有很多朋友也许还在使用JDBC，就像我现在一样，除了学习的时候在使用Hibernate、Spring类似这些优秀的框架，工作时一直都在使用JDBC。本文就简单介绍一下利用Jakarta Commons旗下beanutils、dbutils简化JDBC数据库操作，以抛砖引玉，希望对像我一样在使用JDBC的朋友有所帮助。
    下面就分两部分简单介绍beanutils、dbutils在基于JDBC API数据库存取操作中的运用。第一部分显介绍beanutils在JDBC数据库存取操作中的运用，第二部分介绍dbutils在JDBC数据库存取操作中的运用，最后看看他们的优缺点，谈谈本人在项目运用过程中对他们的一点心得体会，仅供参考，其中有错误的地方希望大虾不吝赐教，大家多多交流共同进步。
一、Jakarta Commons beanutils
    Beanutils是操作Bean的锐利武器，其提过的BeanUtils工具类可以简单方便的读取或设置Bean的属性，利用Dyna系列，还可以在运行期创建Bean，符合懒人的习惯，正如LazyDynaBean，LazyDynaClass一样，呵呵。这些用法已经有很多文章提及，也可以参考apache的官方文档。
    对于直接利用JDBC API访问数据库时（这里针对的是返回结果集ResultSet的查询select），大多数都是采用两种方式，一种是取出返回的结果集的数据存于Map中，另一种方式是Bean里。针对第二种方式，Beanutils里提供了ResultSetDynaClass结合DynaBean以及RowSetDynaClass结合DynaBean来简化操作。下面用以个简单的例子展示一下beanutils的这两个类在JDBC数据库操作中的运用。
    请在本机建立数据库publish，我用的是MySQL，在publish数据库中建立表book,脚本如下：
CREATE TABLE book(
  id int(11) NOT NULL auto_increment,
  title varchar(50) character set latin1 NOT NULL,
  authors varchar(50) character set latin1 default NULL,
  PRIMARY KEY  (id)
)

    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:
    然后用你喜欢的编辑器建立一个类BeanutilsJDBCTest，我们先用ResultSetDynaClass来处理，然后再用RowSetDynaClass来实现同样的类，之后看看他们之间有什么不同，用ResultSetDynaClass处理的源代码如下所示:
package cn.qtone.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.ResultSetDynaClass;
public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     ResultSetDynaClass rsDynaClass = new ResultSetDynaClass(rs);
                     Iterator itr = rsDynaClass.iterator();
                     System.out.println("title-------------authors");
                     while (itr.hasNext()) {
                            DynaBean dBean = (DynaBean) itr.next();
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"title")+ "-------"+ PropertyUtils.getSimpleProperty(dBean, "authors"));

                     }
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
       }
}

用RowSetDynaClass处理的源代码如下所示:

package cn.qtone.test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.Iterator;
import java.util.List;
import org.apache.commons.beanutils.DynaBean;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.beanutils.RowSetDynaClass;

public class BeanutilsJDBCTest{
       public static void main(String[] args) {
              List rsDynaClass = rsTest();
              System.out.println("title ------------- authors ");
              Iterator itr = rsDynaClass.iterator();
              while (itr.hasNext()) {
                     DynaBean dBean = (DynaBean) itr.next();
                     try {
                            System.out.println(PropertyUtils.getSimpleProperty(dBean,"name")  + "-----"+ PropertyUtils.getSimpleProperty(dBean, "mobile"));
                     } catch (Exception e) {
                            // TODO 自动生成 catch 块
                            e.printStackTrace();
                     }
              }
       }
       private static List rsTest() {
              Connection con = null;
              Statement st = null;
              ResultSet rs = null;
              try {
                     Class.forName("com.mysql.jdbc.Driver");
                     String url = "jdbc:mysql://127.0.0.1:3306/publish?useUnicode=true&characterEncoding=GBK";
                     con = DriverManager.getConnection(url, "root", "hyys");
                     st = con.createStatement();
                     rs = st.executeQuery("select * from book");
                     RowSetDynaClass rsdc = new RowSetDynaClass(rs);
                     return rsdc.getRows();
              } catch (Exception e) {
                     e.printStackTrace();
              } finally {
                     try {
                            if (rs != null) {
                                   rs.close();
                            }
                            if (st != null) {
                                   st.close();
                            }
                            if (con != null) {
                                   con.close();
                            }
                     } catch (Exception e) {
                            e.printStackTrace();
                     }
              }
              return null;
       }
}

     这两个方法输出的结果应该是一样的。但是很显然第二种方式比第一种方式要好，它把数据访问部分抽取出来放到一个方法中，显得简单清晰。
     其实在利用ResultSetDynaClass时，必须在ResultSet等数据库资源关闭之前，处理好那些数据，你不能在资源关闭之后使用DynaBean，否则就会抛出异常，异常就是说不能在ResultSet之后存取数据（具体的异常名我也忘了），当然你也可以采用以前的方式一个一个的把数据放到Map里，如果你一定要那样做，建议还是别用Beanutils，因为这没带给你什么好处。总之利用ResultSetDynaClass你的程序的扩展性非常部好。
    从第二中方式可以看出，利用RowSetDynaClass可以很好的解决上述ResultSetDynaClass遇到的问题，RowSetDynaClass的getRows()方法，把每一行封装在一个DynaBean对象里，然后，把说有的行放到一个List里，之后你就可以对返回的List里的每一个DynaBean进行处理，此外对于DynaBean你还可以采用标准的get/set方式处理，当然你也可以用PropertyUtils. getSimpleProperty(Object bean, String name)进行处理。
    从上面的分析中，你应该可以决定你应该使用ResultSetDynaClass还是RowSetDynaClass了。

未完待续……

牛宝雷 2007-09-20 11:08 发表评论

存储过程生成临时表用从临时表中取数据

牛宝雷 — Fri, 06 Jul 2007 08:37:00 GMT

这两天工作还行,工作的内容就是写存储过程,对于我这个没有写过存储近程的人来说,还是有一定困难的.不过还好,在众多资源的帮助下,万事OK呀,哈哈.下面就是我写的两个存储过程.

其一:对数据库中的原表进行每天的备份;

其二:通过对最新的备份表进行取值操作,通过判断,向原表中插入数据.

其实这两个存储过程也没有什么难的,一方面我是这方面的新手,另一方面要操作一个临时表,而且要从中取得数据(没有传入值),我在网上找了一下,没有什么成功的例子,所以,把我这两天的成果晒一下.

先说几个关键词(我用的时候,没少为这几个词费脑子)

1. execute Immediate,一个执行动态SQL的东东,在每天生成备份表时,立下了汉马功劳.我的表名为:原表名+yyyymmdd

2. creat table 表名 as select * from 已有表.这是一个创建表,我认为最快的一种方法,在创建表的同时,也可以直接把已有表中的数据也一起copy过来,呵呵,很是神奇

3. sys_refcursor,这是一个cursor,很怪异的一个cursor,能够生成动态的cursor,可以多用一些,

下面我写的存储过程,主要地业务逻辑去掉了,主要说一下过程

1. 每天生成表备份的存储过程

create or replace procedure P_HOLD_COPY Is
--每天结算时,为当天的持股做备份
--得到表名为原表名+yyyymmdd的格式
table_name Varchar2(20) := 'test'||To_char(Sysdate,'yyyymmdd');
Begin
execute Immediate 'Create Table '||table_name||' As Select * From T_STOC_HOLD';
Commit;
end P_HOLD_COPY;

2. 从备份表中取得数据,然后根据数据,对原表进行操作

create or replace procedure P__SHARE is
--******************************************************************
--存储过程名称：P_SHARE
--功能描述：对备份表进行数据操作
--******************************************************************
balance Number;
totalmoney Number;
h_amount Number;

allot_stock Number;
allot_money Number;

str Varchar2(1);
v_product_oid Varchar2(32);

table_name Varchar2(20);
sqlstr Varchar2(1000);

v_allot_row t_stoc_allot%rowtype;
v_hold_row t_stoc_hold%rowtype;

Cursor c_allot is select * from t_stoc_allot where to_char(t_stoc_allot.regdate,'yymmdd') < to_char(sysdate+1,'yymmdd') And (t_stoc_allot.is_allot Is Null Or t_stoc_allot.is_allot='1');

c_hold sys_refcursor ;
Begin

open c_allot;
loop
      fetch c_allot into v_allot_row;

      table_name := 'T_STOC_HOLD'||To_char(v_allot_row.regdate,'yyyymmdd');

      v_product_oid := v_allot_row.product_oid;
      sqlstr := 'select * from '||table_name||' where stock_code='||v_product_oid;
      exit when c_allot%NOTFOUND;

        open c_hold For sqlstr ;
        loop
            fetch c_hold into v_hold_row;
            exit when c_hold%NOTFOUND;

                   end loop;
        close c_hold;
          end loop;
close c_allot;

Commit;
end P_SHARE;

牛宝雷 2007-07-06 16:37 发表评论

eclipse的远程调试(jboss+tomcat),已成功

牛宝雷 — Fri, 06 Jul 2007 07:22:00 GMT

何为远程调试？我们一般调试一个web项目的java代码时，需要将你的web服务器和你的开发工具（比如eclipse）集成，或需要工具的一些插件支持(比如Eclipse下的myclipse等)，这些方式都是在本地进行，即你的开发工具和web服务器运行在同一台服务器上，如果你的开发工具和服务器不再一台机器上那就需要实现远程调试功能了。

下面说明一下在tomcat中的远程调试实现:

在tomcat的catalina.bat文件中加入下面的设置，当然SET CATALINA_OPTS 变量应该在使用它之前。这是在tomcat启动时设置一些虚拟机参数，使服务器允许远程连接功能，address=5888表示远程连接的端口号，可以设置成任意其他不冲突端口。
SET CATALINA_OPTS=-server -Xdebug -Xnoagent -Djava.compiler=NONE -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5888

然后说明一下在jboss中的远程调试实现:

在jobss中配置远程调试比较简单,他的原理和tomcat一样,也是修改一下他的虚拟机参数,形式为:端口为8787,注意端口不要重复
JAVA_OPTS="$JAVA_OPTS -Xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n"

这样就Ok了，重启动web服务器,可以直接独立启动，而不用在eclipes的插件中启动。打开eclipse中的debug设置窗口，选择Remote Java Application ，新建一个debug项，输入服务器IP和刚才设置端口号，点ok就可以进入debug状态了。Jbuilder中同样可以设置Remote Java Application。

牛宝雷 2007-07-06 15:22 发表评论

java.util.TimeTask例子

牛宝雷 — Fri, 01 Jun 2007 08:30:00 GMT

java.util.Timer定时器，实际上是个线程，定时调度所拥有的TimerTasks。
一个TimerTask实际上就是一个拥有run方法的类，需要定时执行的代码放到run方法体内，TimerTask一般是以匿名类的方式创建。

一个完整的Timer：

java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。

TimerTask task = new TimerTask() {
public void run() {
... //每次需要执行的代码放到这里面。
}
};

//以下是几种调度task的方法：

timer.schedule(task, time);
// time为Date类型：在指定时间执行一次。

timer.schedule(task, firstTime, period);
// firstTime为Date类型,period为long
// 从firstTime时刻开始，每隔period毫秒执行一次。

timer.schedule(task, delay)
// delay 为long类型：从现在起过delay毫秒执行一次

timer.schedule(task, delay, period)
// delay为long,period为long：从现在起过delay毫秒以后，每隔period
// 毫秒执行一次。

下面是一个完整的例子,由两个类组成,一个定制任务,一个调用java.util.Timer

定制任务:
import java.util.Timer;

public class TimerTaskTest extends java.util.TimerTask{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("start");
}
}
2.调用java.util.Timer
import java.util.Timer;

public class Test {
public static void main(String[] args){
  Timer timer = new Timer();
  timer.schedule(new TimerTaskTest(), 1000, 2000);
  try{
   Thread.sleep(1000);
  }catch(Exception ex){
   timer.cancel();
  }
}
}
根据上面的介绍,便可以在1秒后,每隔2秒执行一次程序
建议:在使用Timer timer = new Timer()时,不要用Timer timer = new Timer(true).因为这样,在程序结束后,timer也自动结束了,不利于使用

牛宝雷 2007-06-01 16:30 发表评论

定时执行任务的三种方法(转)

牛宝雷 — Fri, 01 Jun 2007 07:49:00 GMT

1）java.util.Timer
这个方法应该是最常用的，不过这个方法需要手工启动你的任务：
Timer timer=new Timer();
timer.schedule(new ListByDayTimerTask(),10000,86400000);
这里的ListByDayTimerTask类必须extends TimerTask里面的run()方法。

2）ServletContextListener
这个方法在web容器环境比较方便，这样，在web server启动后就可以
自动运行该任务，不需要手工操作。
将ListByDayListener implements ServletContextListener接口，在
contextInitialized方法中加入启动Timer的代码，在contextDestroyed
方法中加入cancel该Timer的代码；然后在web.xml中，加入listener:

com.qq.customer.ListByDayListener

3)org.springframework.scheduling.timer.ScheduledTimerTask
如果你用spring，那么你不需要写Timer类了，在schedulingContext-timer
.xml中加入下面的内容就可以了：

http://www.springframework.org/dtd/spring-beans.dtd">

       10000


       86400000

牛宝雷 2007-06-01 15:49 发表评论