语源科技BlogJava-欢迎来到小小家院

命令模式学习笔记

扭转乾坤 — Mon, 05 May 2008 01:28:00 GMT

命令模式：将“请求”封装成对象，以便使用不同得请求，队列或者日志来参数化其他对象，命令模式也支持可撤销得操作！（Head First Design Patterns ）
优点：解耦了发送者和接受者之间联系。发送者调用一个操作，接受者接受请求执行相应的动作，因为使用Command模式解耦，发送者无需知道接受者任何接口。
1. 简单的命令模式
命令接口：

public interface Command {
public void execute();
}

关闭灯命令：

public class LightOffCommand implements Command {
Light light;

public LightOffCommand(Light light) {
this.light = light;
}

public void execute() {
light.off();
}
}

打开灯命令：

public class LightOnCommand implements Command {
    Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void execute() {
        light.on();
    }
}

灯：

public class Light {

    public Light() {
    }

    public void on() {
        System.out.println("Light is on");
    }

    public void off() {
        System.out.println("Light is off");
    }
}

命令调用者：

public class SimpleRemoteControl {
    Command slot;

    public SimpleRemoteControl() {}

    public void setCommand(Command command) {
        slot = command;
    }

    public void buttonWasPressed() {
        slot.execute();
    }
}

测试类：

public class RemoteControlTest {
public static void main(String[] args) {
  SimpleRemoteControl remote = new SimpleRemoteControl();
  Light light = new Light();
  LightOnCommand lightOn = new LightOnCommand(light);

  remote.setCommand(lightOn);
  remote.buttonWasPressed();
    }
}

命令模式得特点：
1》分布登记统一执行：
在作程序时，经常碰到一些需求，先注册一些操作，并不马上执行，等最终确定后统一执行。如一个具体的例子:用户定制自己的报表，可以订阅饼，柱，折线，曲线图，客户选择相应的报表组合，这样对应一个命令集合，在没确定之前用户可以增删这些报表（命令），等最终确定统一交给调用者根据命令执行，生成组合报表。实现了命令分布提出，确定后统一执行的功能。

2》形如流水线操作：还是出书的例子
//先是一本空白的书：
Book book = new Book();
//找几个作者
Author author1 ＝ new Author();
Author author2 ＝ new Author();
//把写1，2章的名类分别给这两个作者
Command writeCommand = new Write1Command (author1，book);
Command writeCommand = new Write2Command (author2，book);
List commands ＝ new List ();
Commands.add(writeCommand);
//调用者
Invoker invoker = new invoker();
Invoker.setCommands(commands);
//流水写书
invoker.action()
实际上在aciton这一方法中，invoker按照命令，让两个作者流水写作这本书。（类似一个书的流水线加工工厂）
这样我们的书就被流水加工成功（当然这本书只有两章）

这样就给了我们一种系统设计的框架，
模型＋工具＋命令
客户端产生命令，命令调用工具操作模型。
Book 相当于模型
Author 相当于和多工具类中的一个
Command 命令

3》系统需要支持命令的撤消(undo)。提供redo()方法【容易扩展】
我们可以和容易的加入undo和redo，这个不难理解

4》在Invoker中我们可以实现跟踪，和日志。

5》当系统需要为某项复制增加形的功能的时候，命令模式使新的功能（表现为一种命令）很容易地被加入到服务种里。
命令联系了工具类即执行类和系统逻辑，

简化/变化的命令模式：
命令模式的角色比较多，在实际应用种我们可以根据所需要的功能和不需要的功能加以简化。

1》去掉调用者
产生命令集合后，我们可以直接在client中迭代执行执行操作
2》变化调用者成为跟踪者
//调用者
public class Invoker{
List commands; //已经执行完毕的命令集合
public void addCommand (Command command,int i){
commands.add(i,command);
}
public void action(Command command){
//执行操作
command. execute();
//
commands.add(command);
}
}
……………
//还可以有丰富的redo和undo操作；(当然一些都给基于命令类提供的相应方法)
}
这样这个类就记录了所有执行过的操作。

3》去掉命令用map替代
我们完全可以用map代替命令，这样无需定义各种命令类
我们改进例子
Author author ＝ new Author();
Publisher publisher ＝ new Publisher ();
Map m = new HashMap;
m.put(author, write);
m.put(author, publisherBook);
在Invoker的action方法：
得代map
运用java反射来调用方法；

4》去掉执行者：
直接在命令中（execute方法种）加业务逻辑。这样只适合于简单的小的系统.

其他要说的内容
1》将某些参数传给某个方发的方式很多，除了当作方法的参数外还可以当作类的成员便俩变量传入：
这就为命令的抽象带来了极大的方便
abstract class Command
{
abstract public void execute();
}
当我们已经有了执行者（类Test）方法execute（args1，args2 ….argsn）
我们不必向Command加入execute（args1，args2 ….argsn）抽象方法，在说即使加了，在我们迭代的时候也无法判断或十分不容易判断哪个命令调用哪个execute方法。
那么我们可以这样
class ConcreteCommand : Command
{
Test test;
args1
args2
…..
argsn
public override void Execute()
{
test. execute (args1，args2 ….argsn);
}
}
2》在想跟踪操作的时候，一般为每一个操作对象分配一个调用者，操作对象在调用者中设置。（可以抽象出一个总的调用者，来协调调用每一个具体的调用者）
3》命令的抽象粒度我觉得是要注意的。
4》理解思想，不要机械的照搬。消化成自己的，加以灵活的运用和创造在是根本出路。
所谓命令模式的根本思想就是在先形成命令，在根据命令执行。

参考：http://blog.csdn.net/baggio785/archive/2006/05/23/750513.aspx

扭转乾坤 2008-05-05 09:28 发表评论

工厂模式学习笔记

扭转乾坤 — Sun, 04 May 2008 06:13:00 GMT

1. 简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。

1.public class CarFactory{
       public static Car getCar(int type){
           if(type == 1){
                  return new Car1();
              } else {
              return new Car2();
           }
       }
}

2. public class CarFactory{
        public static Car getCar(String carClass){
            String className = carClass;
             Class c = Class.forName(className);
             Car car = (Car)c.newInstance();
             return car;
        }
}

3. public class CarFactory{
        public static Car getCar(String carJNDIName){
            InitialContext ic = new InitialContext();
            String className = ic.lookUp(carJNDIName);
            Car car = (Car)Class.forName(className).newInstance();
            return car;
        }
}
方式1～3适合于工厂所产生的对象都是属于同一个父类型的，而从方式1～3来看，方式1无疑是最简单的，也是最容易理解和接受的，而方式2和方式3则相对来说要高级一点。高级在哪里呢？我们可以看到，方式1中对对象的创建是使用Hardcode的形式，也即是程序员需要事先知道系统里面存在多少个类型的对象及其对应的编号，一旦增加或删除、修改了对象的类型，则必然引起if-else块的改变，造成了维护的困难。

而方式2则采用了动态类加载的方式，方式3在方式2的基础上使用了JNDI，更进了一步，其好处是不用出现HardCode的方式，即便你后面的应用增加、删除了对象的类型，我的程序还是保持现在的样子，跟进一步来说：可以去掉那些讨厌的if-else语句。
2. 工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。【实质上它是让工厂实现了抽象的工厂接口，它把具体怎么生产一种东西，放在具体的工厂去实现了，所谓”延迟到子类中实现“】
示例一：
public interface Driver{
       public Car driverCar();
}
public class BenzDriver implements Driver{
       public Car driverCar(){
              return new Benz();
       }
}
public class BmwDriver implements Driver{
       public Car driverCar()   {

return new Bmw();
}
}

// 应该和具体产品形成对应关系 ...
// 有请暴发户先生
public class Magnate

{

public static void main(String[] args)

{

try{
Driver driver = new BenzDriver();

Car car = driver.driverCar();

car.drive();

}

……

}
示例二：

public interface Creator
{
public Prouct factory();
}

public SubCreator1 implent Creator
{
   public Prouct factory()
{
   return new ConcreteProduct1();
   }
}

public SubCreator2 implent Creator
{
   public Prouct factory()
{
    return new ConcreteProduct2();
   }
}

请注意：返回类型是Product型的！！
这样客户端调用是直接new 一个具体工厂的实例，然后命令它去生产，而对于具体工厂的父类（既工厂接口，接口完全可以改成子类继承父类来实现，只是这样不好，不符合OO的原则），它完全不知道什么产品被生产了，甚至它连那个具体工厂被实例化它都不知道！
3. 抽象工厂
public abstract class AbstractFactory{
        public abstract Car getCar(String carClass);
        public abstract Plane getPlane(String planeClass);
}

public class Factory1 extends AbstractFactory{
      public Car getCar(String carClass){
          // 参考上面的方式1～3
          return car1;
      }

      public Plane getPlane(String planeClass){
          // 参考上面的方式1～3
          return plane1;
      }
}

public class Factory2 extends AbstractFactory{
     public Car getCar(String carClass){
          // 参考上面的方式1～3
          return car2;
     }

     public Plane getPlane(String planeClass){
          // 参考上面的方式1～3
          return plane2;
     }
}

方式4是最为复杂而且也是最为强大的一种，它在实现了对象工厂抽象的基础上，又集成了工厂方法。使到不同的工厂可以生产相同类型的产品，但产品的子类可能有所不同。就像上面的工厂1和工厂2都可以生产汽车和飞机一样，他们各自之间可以生产不同系列的产品(抽象工厂)，而且每个系列下面可能有不同的型号(工厂方法)。

参考资料：http://www.blogjava.net/pengpenglin/archive/2008/01/02/172325.html
http://www.blogjava.net/killme2008/archive/2007/03/15/104031.html
http://www.blogjava.net/alex/archive/2006/08/29/66479.html

扭转乾坤 2008-05-04 14:13 发表评论

单实例模式学习笔记

扭转乾坤 — Sun, 04 May 2008 00:38:00 GMT

1. 经典的单实例模式例子（非线程安全）：
public class Singleton {
    private static Singleton uniqueInstance;

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
        if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
     }
         return uniqueInstance;
    }

    // other useful methods here
}
本例是最经典的单实例模式例子，但是在多线程的情况下就会产生多个实例！

2. 线程安全的例子：
public class Singleton {
private static Singleton uniqueInstance;

// other useful instance variables here

private Singleton() {}

public static synchronized Singleton getInstance() {
  if (uniqueInstance == null) {
   uniqueInstance = new Singleton();
  }
  return uniqueInstance;
}

// other useful methods here
}
增加synchronized，会让该方法是线程安全的，但是会引起每个线程在调用该方法时的等待，如果getInstance的性能对应用程序不是很关键（记住，同步方法可能会使getInstance方法得运行效率降低100倍），本方法是最好得方法！
3. 提前实例化，不适用延迟实例化（使用于创建和运行时负担不太繁重或者应用程序总是创建并使用单件实例），它是线程安全得：
public class Singleton {
    private static Singleton uniqueInstance = new Singleton();

    // other useful instance variables here

    private Singleton() {}

    public static Singleton getInstance() {
            return uniqueInstance;
    }

    // other useful methods here
}
采用这种方法，我们依赖JVM在加载这个类时候马上创建此唯一实例，JVM保证在任何线程访问它之前，一定先创建它!
4. 在java1.5及以后的版本，增加了volatile关键字，可以采用双重检查加锁！
public class Singleton {
private volatile static Singleton uniqueInstance;

private Singleton() {}

public static Singleton getInstance() {
  if (uniqueInstance == null) {
   synchronized (Singleton.class) {
    if (uniqueInstance == null) {
     uniqueInstance = new Singleton();
    }
   }
  }
  return uniqueInstance;
}
}
volatile关键字确保：当unigueInstance变量在被初始化成实例时，多个线程能够正确的处理它！（对于关注性能的程序，这种做法可以大大减少时耗）

扭转乾坤 2008-05-04 08:38 发表评论

简单的oracle备份恢复批处理文件

扭转乾坤 — Fri, 26 Jan 2007 03:54:00 GMT

写个简单的批处理文件备份恢复：
备份：
@echo off　　　　　　　　　　　             不显示命令行
　　　　
echo 开始备份表.....　　　　　　                 打印信息　　　　　　　　　　　　　　　
D:                                                                      DOS切换到D: 盘
cd oracle\ora92\bin　　　　　　                    切换到cd oracle\ora92\bin目录
exp 用户名/密码@数据库 file=d:\config_bak.dmp tables=(table1,table2)      备份表一表二到d:\config_bak.dmp
echo 备份完毕！

恢复：
@echo off　　　　　　　　　　　
　　　　
echo 开始恢复表.....　　　　　　　　　　　　　　　　　　　　　
D:
cd oracle\ora92\bin
imp 用户名/密码@数据库 file=d:\config_bak.dmp tables=(table1,table2) ignore=y
sqlplus /nolog @oraStartup.sql>>oraStartup.log 调用sql文件
pause                                                                 执行完sql文件以后暂停，看信息
echo 恢复完毕！

编写oraStartup.sql
conn 用户名/密码@数据库 as sysdba
select * from table1；
quit；
　　　　　　

　　　　　　

　执行环境：可以在SQLPLUS.EXE或者DOS（命令行）中执行，
　　DOS中可以执行时由于在oracle 8i 中安装目录\ora81\BIN被设置为全局路径，
　　该目录下有EXP.EXE与IMP.EXE文件被用来执行导入导出。
　　oracle用java编写，我想SQLPLUS.EXE、EXP.EXE、IMP.EXE这俩个文件是被包装后的类文件。
　　SQLPLUS.EXE调用EXP.EXE、IMP.EXE他们所包裹的类，完成导入导出功能。

　　下面介绍的是导入导出的实例，向导入导出看实例基本上就可以完成，因为导入导出很简单。
　　数据导出：
　　1 将数据库TEST完全导出,用户名system 密码manager 导出到D:\daochu.dmp中
　　exp system/manager@TEST file=d:\daochu.dmp full=y
　　2 将数据库中system用户与sys用户的表导出
　　exp system/manager@TEST file=d:\daochu.dmp owner=(system,sys)
　　3 将数据库中的表table1 、table2导出
　　exp system/manager@TEST file=d:\daochu.dmp tables=(table1,table2)
　　4 将数据库中的表table1中的字段filed1以"00"打头的数据导出
　　exp system/manager@TEST file=d:\daochu.dmp tables=(table1) query=\" where filed1 like '00%'\"
　　
　　上面是常用的导出，对于压缩我不太在意，用winzip把dmp文件可以很好的压缩。
　　不过在上面命令后面加上 compress=y 就可以了

　　数据的导入
　　1 将D:\daochu.dmp 中的数据导入 TEST数据库中。
　　imp system/manager@TEST file=d:\daochu.dmp
　　上面可能有点问题，因为有的表已经存在，然后它就报错，对该表就不进行导入。
　　在后面加上 ignore=y 就可以了。
　　2 将d:\daochu.dmp中的表table1 导入
　　imp system/manager@TEST file=d:\daochu.dmp tables=(table1)

导入
　　基本上上面的导入导出够用了。不少情况我是将表彻底删除，然后导入。

Oracle数据库备份与恢复的三种方法

Oracle数据库有三种标准的备份方法，它们分别是导出／导入（EXP/IMP）、热备份和冷备份。导出备件是一种逻辑备份，冷备份和热备份是物理备份。

一、导出／导入（Export／Import）

利用Export可将数据从数据库中提取出来，利用Import则可将提取出来的数据送回到Oracle数据库中去。

１、简单导出数据（Export）和导入数据（Import）

Oracle支持三种方式类型的输出：

（１）、表方式（T方式），将指定表的数据导出。

（２）、用户方式（U方式），将指定用户的所有对象及数据导出。

（３）、全库方式（Full方式），瘵数据库中的所有对象导出。

数据导入（Import）的过程是数据导出（Export）的逆过程，分别将数据文件导入数据库和将数据库数据导出到数据文件。

２、增量导出／导入

增量导出是一种常用的数据备份方法，它只能对整个数据库来实施，并且必须作为SYSTEM来导出。在进行此种导出时，系统不要求回答任何问题。导出文件名缺省为export.dmp，如果不希望自己的输出文件定名为export.dmp，必须在命令行中指出要用的文件名。

增量导出包括三种类型：

（１）、“完全”增量导出（Complete）

即备份三个数据库，比如：

																exp system/manager inctype=complete file=040731.dmp

（２）、“增量型”增量导出

备份上一次备份后改变的数据，比如：

																exp system/manager inctype=incremental file=040731.dmp

（３）、“累积型”增量导出

累计型导出方式是导出自上次“完全”导出之后数据库中变化了的信息。比如：

																exp system/manager inctype=cumulative file=040731.dmp

数据库管理员可以排定一个备份日程表，用数据导出的三个不同方式合理高效的完成。

比如数据库的被封任务可以做如下安排：

星期一：完全备份（A）

星期二：增量导出（B）

星期三：增量导出（C）

星期四：增量导出（D）

星期五：累计导出（E）

星期六：增量导出（F）

星期日：增量导出（G）

如果在星期日，数据库遭到意外破坏，数据库管理员可按一下步骤来回复数据库：

第一步：用命令CREATE DATABASE重新生成数据库结构；

第二步：创建一个足够大的附加回滚。

第三步：完全增量导入A：

																imp system/manager inctype=RESTORE FULL=y FILE=A

第四步：累计增量导入E：

																imp system/manager inctype=RESTORE FULL=Y FILE=E

第五步：最近增量导入F：

																imp system/manager inctype=RESTORE FULL=Y FILE=F

二、冷备份

冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份时将关键性文件拷贝到另外的位置的一种说法。对于备份Oracle信息而言，冷备份时最快和最安全的方法。冷备份的优点是：

１、是非常快速的备份方法（只需拷文件）

２、容易归档（简单拷贝即可）

３、容易恢复到某个时间点上（只需将文件再拷贝回去）

４、能与归档方法相结合，做数据库“最佳状态”的恢复。

５、低度维护，高度安全。

但冷备份也有如下不足：

１、单独使用时，只能提供到“某一时间点上”的恢复。

２、再实施备份的全过程中，数据库必须要作备份而不能作其他工作。也就是说，在冷备份过程中，数据库必须是关闭状态。

３、若磁盘空间有限，只能拷贝到磁带等其他外部存储设备上，速度会很慢。

４、不能按表或按用户恢复。

如果可能的话（主要看效率），应将信息备份到磁盘上，然后启动数据库（使用户可以工作）并将备份的信息拷贝到磁带上（拷贝的同时，数据库也可以工作）。冷备份中必须拷贝的文件包括：

１、所有数据文件

２、所有控制文件

３、所有联机REDO LOG文件

４、 Init.ora文件（可选）

值得注意的使冷备份必须在数据库关闭的情况下进行，当数据库处于打开状态时，执行数据库文件系统备份是无效的。

下面是作冷备份的完整例子。

（1）关闭数据库

																sqlplus /nolog 
sql>;connect /as sysdba 
sql>;shutdown normal;

（2）用拷贝命令备份全部的时间文件、重做日志文件、控制文件、初始化参数文件

																sql>;cp ; ;

（3）重启Oracle数据库

																sql>;startup

三、热备份

热备份是在数据库运行的情况下，采用archivelog mode方式备份数据库的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。热备份的命令文件由三部分组成：

1．数据文件一个表空间一个表空间的备份。

（1）设置表空间为备份状态

（2）备份表空间的数据文件

（3）回复表空间为正常状态

2．备份归档log文件

（1）临时停止归档进程

（2） log下那些在archive rede log目标目录中的文件

（3）重新启动archive进程

（4）备份归档的redo log文件

3．用alter database bachup controlfile命令来备份控制文件

热备份的优点是：

1．可在表空间或数据库文件级备份，备份的时间短。

2．备份时数据库仍可使用。

3．可达到秒级恢复（恢复到某一时间点上）。

4．可对几乎所有数据库实体做恢复

5．恢复是快速的，在大多数情况下爱数据库仍工作时恢复。

热备份的不足是：

1．不能出错，否则后果严重

2．若热备份不成功，所得结果不可用于时间点的恢复

3．因难于维护，所以要特别仔细小心，不允许“以失败告终”。

参考资料：http://publish.it168.com/2006/0601/20060601045701.shtml?positioncode=1545
http://bbs.zol.com.cn/index20061024/index_124_11079.html
http://community.csdn.net/Expert/TopicView3.asp?id=5276764
http://bbs.gdei.edu.cn/faster.php?id=t-55261
http://www.dvbbs.net/tech/data/2006031819272.asp
http://study.feloo.com/computer/data/Oracle/200509/121026.html

扭转乾坤 2007-01-26 11:54 发表评论

一哥们写的日期处理类，很棒

扭转乾坤 — Thu, 25 Jan 2007 05:52:00 GMT

import java.util.Calendar;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;

/**
* Utility to date time
* @version 0.1
* @author Super Zhao
*/
public class DateTimeUtil {

/**
* 由java.util.Date到java.sql.Date的类型转换
* @param date
* @return Date
*/
public static Date getSqlDate(java.util.Date date){
return new Date(date.getTime());
}

public static Date nowDate(){
Calendar calendar=Calendar.getInstance();
return getSqlDate(calendar.getTime());
}

/**
* 获得某一日期的后一天
* @param date
* @return Date
*/
public static Date getNextDate(Date date){
Calendar calendar=Calendar.getInstance();
calendar.setTime(date);
int day=calendar.get(Calendar.DATE);
calendar.set(Calendar.DATE,day+1);
return getSqlDate(calendar.getTime());
}

/**
* 获得某一日期的前一天
* @param date
* @return Date
*/
public static Date getPreviousDate(Date date){
Calendar calendar=Calendar.getInstance();
calendar.setTime(date);
int day=calendar.get(Calendar.DATE);
calendar.set(Calendar.DATE,day-1);
return getSqlDate(calendar.getTime());
}

/**
* 获得某年某月第一天的日期
* @param year
* @param month
* @return Date
*/
public static Date getFirstDayOfMonth(int year,int month){
Calendar calendar=Calendar.getInstance();
calendar.set(Calendar.YEAR,year);
calendar.set(Calendar.MONTH,month-1);
calendar.set(Calendar.DATE,1);
return getSqlDate(calendar.getTime());
}

/**
* 获得某年某月最后一天的日期
* @param year
* @param month
* @return Date
*/
public static Date getLastDayOfMonth(int year,int month){
Calendar calendar=Calendar.getInstance();
calendar.set(Calendar.YEAR,year);
calendar.set(Calendar.MONTH,month);
calendar.set(Calendar.DATE,1);
return getPreviousDate(getSqlDate(calendar.getTime()));
}

/**
* 由年月日构建java.sql.Date类型
* @param year
* @param month
* @param date
* @return Date
*/
public static Date buildDate(int year,int month,int date){
Calendar calendar=Calendar.getInstance();
calendar.set(year,month-1,date);
return getSqlDate(calendar.getTime());
}

/**
* 取得某月的天数
* @param year
* @param month
* @return int
*/
public static int getDayCountOfMonth(int year,int month){
Calendar calendar=Calendar.getInstance();
calendar.set(Calendar.YEAR,year);
calendar.set(Calendar.MONTH,month);
calendar.set(Calendar.DATE,0);
return calendar.get(Calendar.DATE);
}

/**
* 获得某年某季度的最后一天的日期
* @param year
* @param quarter
* @return Date
*/
public static Date getLastDayOfQuarter(int year,int quarter){
int month=0;
if(quarter>4){
return null;
}else{
month=quarter*3;
}
return getLastDayOfMonth(year,month);

}

/**
* 获得某年某季度的第一天的日期
* @param year
* @param quarter
* @return Date
*/
public static Date getFirstDayOfQuarter(int year,int quarter){
int month=0;
if(quarter>4){
return null;
}else{
month=(quarter-1)*3+1;
}
return getFirstDayOfMonth(year,month);
}

/**
* 获得某年的第一天的日期
* @param year
* @return Date
*/
public static Date getFirstDayOfYear(int year){
return getFirstDayOfMonth(year,1);
}

/**
* 获得某年的最后一天的日期
* @param year
* @return Date
*/
public static Date getLastDayOfYear(int year){
return getLastDayOfMonth(year,12);
}

/**
* String到java.sql.Date的类型转换
* @param param
* @return Date
*/
public static java.sql.Date StringToDate(String param) {
if(StringUtil.nullOrBlank(param)) {
return null;
} else {
java.util.Date date =null;
try {
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
date = sdf.parse(param);
return new Date(date.getTime());
}
catch (ParseException ex) {
//ex.printStackTrace();
return null;
}
}
}
}

扭转乾坤 2007-01-25 13:52 发表评论

好玩的眼睛

扭转乾坤 — Sat, 30 Dec 2006 09:30:00 GMT

扭转乾坤 2006-12-30 17:30 发表评论

javascript打印

扭转乾坤 — Tue, 14 Nov 2006 04:26:00 GMT

问题：去除页眉页脚，设置打印的横纵向方式！
解决方案一：
修改注册表：
  var HKEY_Root,HKEY_Path,HKEY_Key;
  HKEY_Root = "HKEY_CURRENT_USER\\";
  HKEY_Path="Software\\Microsoft\\Internet Explorer\\PageSetup\\";

  function PageSetup_Null(){
   var Wsh = new ActiveXObject("WScript.Shell");
   HKEY_Key = "header";
   //Wsh.RegRead(HKEY_Root+HKEY_Path+HKEY_Key);
   Wsh.RegWrite(HKEY_Root+HKEY_Path+HKEY_Key,"");
   HKEY_Key = "footer";
   //Wsh.RegRead(HKEY_Root+HKEY_Path+HKEY_Key);
   Wsh.RegWrite(HKEY_Root+HKEY_Path+HKEY_Key,"");
  }

  window.onload=PageSetup_Null();

  function PageSetup_Reset(){
   var Wsh = new ActiveXObject("WScript.Shell");
   HKEY_Key = "header";
   Wsh.RegWrite(HKEY_Root+HKEY_Path+HKEY_Key,"&w&b页码,&p/&P");
   HKEY_Key = "footer";
   Wsh.RegWrite(HKEY_Root+HKEY_Path+HKEY_Key,"&u&b&d");
  }

window.unonload=PageSetup_Reset();

由于注册表位置跟操作系统有关，不推荐使用。

解决方案二：
使用控件：
－－－－－－－－－－－－－http://www.7say.com/article.asp?id=112－－－－－－－－－－
利用ScriptX.cab控件进行WEB打印，可以控制"纵打"、横打”和“页面的边距。打印代码如下：

classid="clsid:1663ed61-23eb-11d2-b92f-008048fdd814"
codebase="http://www.meadroid.com/scriptx/ScriptX.cab#Version=6,2,433,14">

关于ScriptX的下载和该控件的使用方法请登陆 http://www.meadroid.com/scriptx/index.asp 查看.
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
具体应用：
     classid="clsid:1663ed61-23eb-11d2-b92f-008048fdd814"
   codebase="" viewastext>

  function reset() {
   factory.printing.header   =   "&w&b页码,&p/&P";
         factory.printing.footer   =   "&u&b&d";
   factory.printing.portrait = true;
  }

window.unonload=reset();

扭转乾坤 2006-11-14 12:26 发表评论

java中split使用简介

扭转乾坤 — Tue, 14 Nov 2006 04:25:00 GMT

java.lang.string.split
split 方法
将一个字符串分割为子字符串，然后将结果作为字符串数组返回。
string.split([separator，[limit]])
参数
string 必选项。要被分解的 String 对象或文字。该对象不会被 split 方法修改。
separator 可选项。字符串或正则表达式对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽略该选项，返回包含整个字符串的单一元素数组。
limit 可选项。该值用来限制返回数组中的元素个数。
说明
split 方法的结果是一个字符串数组，在 sting 中每个出现 separator 的位置都要进行分解。

separator 不作为任何数组元素的部分返回。

，+ * 不是有效的模式匹配规则表达式，用"\\*" "\\+"转义后即可得到正确的结果。
"|" 分隔串时虽然能够执行，但是却不是预期的目的，"\\|"转义后即可得到正确的结果。
还有如果想在串中使用"\"字符，则也需要转义.首先要表达"aaaa\bbbb"这个串就应该用"aaaa\\bbbb",如果要分隔就应该这样才能得到正确结果：
String[] aa = "aaa\\bbb\\bccc".split(\\\\);

\\也可用[]代替，如：[|] [*]

扭转乾坤 2006-11-14 12:25 发表评论

存储过程的一些用法

扭转乾坤 — Tue, 14 Nov 2006 03:27:00 GMT

最近在用存储过程,在网上找了很多的资料,下面就参考各种资料整理的一些小例子做些阐述：
1. Oralce TO_NUMBER() function 的改进：
用Oracle TO_NUMBER进行类型转换的时候，如果有无效数字，将返回错误。遗憾的是，Oralce TO_NUMBER并不是在query运行开始就报错，而是到碰到无效数字的纪录才报错，而且只是说无效输入，并不提示是哪条纪录，也没有任何输出。如果是一张大表，query运行很久才来这么一下，而且根本不知道那里出的错，是什么值，岂不痛苦？偶就经常跟这样的表打交道，遂自建一个函数，GET_NUM：

CREATE OR REPLACE FUNCTION GET_NUM(IN_TXT in VARCHAR2) RETURN NUMBER IS
RETRUN_VALUE NUMBER;
BEGIN
select to_number(IN_TXT) into RETRUN_VALUE from dual;
RETURN RETRUN_VALUE;

EXCEPTION
WHEN others
THEN
RETURN null;
END GET_NUM;
/
这样无效数字全转换成 Null,纠错容易多了。

写个存储过程测试一下：
CREATE OR REPLACE PROCEDURE TestFun IS
    v_name varchar2(10);/***** 存放cursor_para中的name *****/
    CURSOR cursor_name IS select name from test;
    cursor cursor_para(p_num number) is select name from test where num = p_num;
begin
/******* t_name为循环的临时变量******/
FOR t_name IN cursor_name LOOP

if (get_num(t_name.name) is not null) then

   open cursor_para(get_num(t_name.name));

   fetch cursor_para into v_name;

   DBMS_OUTPUT.PUT_LINE('Name:'|| v_name);

   close cursor_para;

   end if;

END LOOP;
END TestFun;
/
存储过程也用到了带参数的游标和游标For循环,稍后介绍.

其中测试表的创建：
create table test
(
name varchar2(10),
num number
)

测试数据:
insert into test(name) values ('12_');
insert into test(name) values ('123');

2.带参数的游标

　　与存储过程和函数相似，可以将参数传递给游标并在查询中使用。这对于处理在某种条件下打开游标的情况非常有用。它的语法如下：

CURSOR cursor_name[(parameter[,parameter],...)] IS select_statement;

　　定义参数的语法如下：

Parameter_name [IN] data_type[{:=|DEFAULT} value]

　　与存储过程不同的是，游标只能接受传递的值，而不能返回值。参数只定义数据类型，没有大小。

　　另外可以给参数设定一个缺省值，当没有参数值传递给游标时，就使用缺省值。游标中定义的参数只是一个占位符，在别处引用该参数不

一定可靠。

　　在打开游标时给参数赋值，语法如下：

OPEN cursor_name[value[,value]....];

3.游标FOR循环

　　在大多数时候我们在设计程序的时候都遵循下面的步骤：

　　1、打开游标

　　2、开始循环

　　3、从游标中取值

　　4、检查那一行被返回

　　5、处理

　　6、关闭循环

　　7、关闭游标

　　可以简单的把这一类代码称为游标用于循环。但还有一种循环与这种类型不相同，这就是FOR循环，用于FOR循环的游标按照正常的声明方

式声明，它的优点在于不需要显式的打开、关闭、取数据，测试数据的存在、定义存放数据的变量等等。游标FOR 循环的语法如下：

FOR record_name IN
(corsor_name[(parameter[,parameter]...)]
| (query_difinition)
LOOP
statements
END LOOP;

上面的这两个用法也在例子中提到了！

同理类推，也可以将TO_DATE()函数改进。

下面的例子自http://www.nikicn.com/bbs/dispbbs.asp?boardid=23&id=908
没有测试，留作备份之用：
4. 将Oracle 的Last_Day()函数改写到DB2上：
DROP SPECIFIC FUNCTION LAST_DAYDATE
;
CREATE FUNCTION LAST_DAY(D DATE)
RETURNS     DATE
    SPECIFIC LAST_DAYDATE
    LANGUAGE SQL
    DETERMINISTIC
    CONTAINS SQL
    CALLED ON NULL INPUT
    NO EXTERNAL ACTION
    RETURN
D + 1 month - day(D + 1 month) day

;

同理，DB2下的first day:
DROP SPECIFIC FUNCTION FIRST_DAYDATE
;
CREATE FUNCTION FIRST_DAY(D DATE)
RETURNS     DATE
    SPECIFIC FIRST_DAYDATE
    LANGUAGE SQL
    DETERMINISTIC
    CONTAINS SQL
    CALLED ON NULL INPUT
    NO EXTERNAL ACTION
    RETURN
D - day(D) day + 1 day

扭转乾坤 2006-11-14 11:27 发表评论

[转]Jsp运行环境的配置方法

扭转乾坤 — Thu, 24 Aug 2006 02:54:00 GMT

http://soft.etcell.com/topicView.aspx?Id=5692
配置server.xml ------ Tomcat的全局配置文件
当你打开Tomcat这个目录时，你将可以看到在这个目录下有个conf文件夹，打开该目录下server.xml文件的源码，我们会看到里面有很多xml代码，是用来描述Tomcat的全局配置，在此我们只关心跟我们有密切关系的部分。
<1>设置路径映射
大概在第264至267行中你可以看到

其中是说明部分，没任何作用，我们不理它。
docBase="ROOT"就是指定我们项目的物理地址，如果用上面所建的项目htdocs，那就是docBase=" E:/Tomcat41/htdocs"。

path=""是指定在URL的相对路径，如设置为path="TEST",那么在URL中输入http://127.0.0.1:80/TEST ，它将能读到E:/Tomcat41/htdocs下的文件。
但一般我们设置为path=""，而且在安装Tomcat时端口设置为80，那么
在URL中输入http://127.0.0.1/就可以读到E:/Tomcat41/htdocs下的文件了。

为了每次网页刷新能有效的读到最新的文件，在此我们增加了一个设置，
reloadable=”true”。
最后的结果是：

web.xml -----在Tomcat中配置不同的关系环境
跟server.xml同一目录下还有一个web.xml，打开该文件的源码,我们看看一些常用的配置方法
A.隐藏跟目录下的文件夹
出于安全的考虑，为了不让客户端能看到服务器端跟目录下的文件，必须把listings从true改为false,具体如下：

        …………

            listings
            false

        ……………

B.开放servlet和jsp
由于在应用程序中会用到servlet和jsp,为了在URL中检索并处理servlet和jsp，必须把servlet和jsp开放出来，就是去掉 “”,具体如下：

        invoker
        /servlet/*



        jsp
        *.jsp

C.设置默认文件
   由于客户通常只知道网站的名称，而不该知道网站的入口文件名称。为了客户在输入网址时能够找到默认的入口文件，必须把文件名加入到中，如：

        index.html
        index.htm
        index.jsp

这时如果输入http://127.0.0.1就等于输入http://127.0.0.1/index.html

扭转乾坤 2006-08-24 10:54 发表评论