BlogJava-OpenStudio Weblog-随笔分类-Java开发

开发小经验汇总

阿卜 — Mon, 17 Sep 2007 03:30:00 GMT

1.回车转换行：onkeypress="if(event.keyCode == 13){//do script!}
2.Tomcat-linux环境图形显示问题：JAVA_OPTS="$JAVA_OPTS -Djava.awt.headless=true"
3.Eclipse启动参数：D:\eclipse3.2\eclipse.exe -data D:\workspace -product com.genuitec.myeclipse.product.ide -vmargs -Duser.language=en -Xms128M -Xmx512M -XX:PermSize=256M -XX:MaxPermSize=512M
4.eclipse生成javadoc乱码解决：加入参数“-encoding UTF-8 -charset UTF-8”
5.jsp页面禁止缓存代码：
    response.setHeader("Pragma","No-cache");
    response.setHeader("Cache-Control","no-cache");
    response.setDateHeader("Expires", 0);

6.linux－mount samba
   mount -t smbfs -o codepage=cp936 远程路径本地路径

7.查看端口对应PID
lsof -i tcp:PORT-NO, eg, lsof -i tcp:80
lsof -i udp:PORT-NO, eg, lsof -i udp:53

8.RH5.0下smbmount的代替方法
mount -t cifs //ip/f /location/dir ...

阿卜 2007-09-17 11:30 发表评论

工厂方法模式Factory Method

阿卜 — Tue, 27 Feb 2007 16:51:00 GMT

1. 模式定义

工厂方法模式 (Factory Method) 是创建模式的一种，也叫虚拟构造子 (Virture Constractor) 模式或多态性工厂 (Polymorphic Factory) 模式。

工厂方法模式定义一个抽象的对象创建类或接口，将实际的对象创建工作交给子类来实现。

2. 模式介绍

2.1. 简单类图

2.2. 类图对应示例代码

2.2.1. 抽象产品： AbstractProduct

public interface AbstractProduct{

public void printName();

}

2.2.2. 具体产品： ConcreteProduct1 和 ConcreteProduct2

public class ConcreteProduct1 implements AbstractProduct{

public void printName(){

System.out.println(“ConcreteProduct1”);

}

public class ConcreteProduct2 implements AbstractProduct{

public void printName(){

System.out.println(“ConcreteProduct2”);

}

2.2.3. 抽象工厂： AbstractFactory

public interface AbstractFactory {

public AbstractProduct factoryMethod();

}

2.2.4. 具体工厂： ConcreteFactory1 和 ConcreteFactory2

public class ConcreteFactory1 implements AbstractFactory{

public AbstractProduct factoryMethod(){

//do something.

return new ConcreteProduct1();

}

public class ConcreteFactory2 implements AbstractFactory{

public AbstractProduct factoryMethod(){

//do something.

return new ConcreteProduct2();

}

3. 模式特点

3.1. 开闭原则（优点）

工厂方法模式解决了简单工厂模式的一些缺陷，是在简单工厂模式的基础上发展的。

简单工厂模式把所有的重心放到工厂类上，一旦向系统增加新的产品，就必须修改工厂类，不满足开闭原则；工厂方法模式提供一个抽象的工厂接口，在不同的产品结构上实现不同的产品工厂具体类来创建该层次中的产品，通常一个具体工厂创建一个具体产品。在新增产品的时候，只需要实现新的对应工厂就可以满足需要，是符合开闭原则的。

3.2. 缺点

相比简单工厂模式，工厂方法模式客户端编程复杂，每个产品的创建都需要实例化对应的工厂类。
相对的扩展性，当需要修改产品结构中的对各产品的时候，需要修改各个工厂（当然也可以直接新加入很多新的产品和工厂，但这样不是又增加了很多无用的遗留类吗，而且现实中很可能要修改客户端代码了。），而简单工厂模式仍然只要修改一个工厂类。
现实中常常要使用退化模式，失去多态性。实际设计中经常会有子类新增功能，那么在对应工厂生产该类的时候就需要直接返回该具体类，而不是抽象产品，不然就要向下转型了。

4. 与其它模式的关系

工厂方法模式与模板模式

5. 参考

《 java 设计模式》阎宏电子工业出版社

阿卜 2007-02-28 00:51 发表评论

简单工厂模式Simple Factory

阿卜 — Tue, 27 Feb 2007 15:32:00 GMT

简单工厂模式也叫静态工厂方法模式（Static Factory Method），是由一个工厂对象隐藏并决定产品类的具体创建的一种创建模式。是工厂方法模式的一种特例。

什么时候使用？
1、创建一类有公共接口或父类的对象，并要求隐藏具体实现。
2、隐藏子类的创建，提高扩展性。

优点：隐藏具体产品的创建，客户端独立的创建产品而不用关心具体的创建过程，并在引入新的产品类时不用修改客户调用类。
缺点：所用产品的创建集中到factory上，成为系统的中心，一旦factory出现问题整个系统崩溃。

标准简单工厂模式

工厂类

package pattern.simplefactory;

/**
* 简单工厂模式－工厂类
@author ZhangPu
*/

public class ProductFactory {
     /**
     * 简单工厂方法：通过类全路径创建产品
     * @param className
     * @return
      */
     public static Product factory(String className) {
        Product product = null ;
         try {
            product = (Product)Class.forName(className).newInstance();
        } catch (Exception e) {
             throw new RuntimeException(e);
        }
         return product;
    }

}

抽象产品接口

package pattern.simplefactory;

/**
* 产品接口
*/
public interface Product {
public String getName();
}

具体产品类

package pattern.simplefactory;

/**
* 普通产品
@author ZhangPu
*/

public class ConcreteProduct implements Product {
    private String name = "普通产品";

    public String getName() {
        return name;
    }
}

客户端类

package pattern.simplefactory;

/**
* client class
@author ZhangPu
*/

public class Client {
    public static void main(String[] args) {
        Product product = ProductFactory.factory("pattern.simplefactory.ConcreteProduct");
        System.out.println(product.getName());
    }
}

合并抽象产品和产品的简单工厂模式

合并产品和工厂的模式

请注意与单例模式的区别：
1.单例模式构造函数是私有的，不允许外界创建。
2.单例模式只有一个实例。

阿卜 2007-02-27 23:32 发表评论

多例模式Multiton

阿卜 — Thu, 22 Feb 2007 13:45:00 GMT

多例模式Multiton基本特性同单例Singleton,由自己创建和管理自身实例，并向系统提供自身实例。不同之处是多例类在同一容器（类加载器）或JVM中可以存在多个实例。

应用实例：序列键值生成器

本例采用hqldb作为演示数据库。表结构如下：

CREATE TABLE KEYTABLE(
KEYNAME VARCHAR(32) NOT NULL PRIMARY KEY,
KEYVALUE int NOT NULL
)

package pattern.multiton;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

/*
* Key service

* table strunction:

* CREATE TABLE KEYTABLE(

* KEYNAME VARCHAR(32) NOT NULL PRIMARY KEY,

* KEYVALUE int NOT NULL

* )

@author ZhangPu
Feb 22, 2007 4:30:47 PM
*/

public class KeyService {

    private int cache;
    private String keyName;

    private int maxValue;
    private int nextValue;

    public KeyService(int cache,String keyName) {
      this.cache = cache;
      this.keyName = keyName;
      retrieveKey();
    }

    /**
     * get next key form keyinfo
     *
     * @return
     */
    public int getNextKey() {
        if(nextValue >= maxValue){
            retrieveKey();
        }
        return nextValue++;
    }

    /**
     * retrieve current value form db.
     * @return
     */
    private void retrieveKey(){
        System.out.println("retrieve database!");

        String sqlUpdate = "update KEYTABLE set KEYVALUE = KEYVALUE + " + cache + " where KEYNAME = '"+keyName+"'";
        String sqlSelete = "select KEYVALUE from KEYTABLE where KEYNAME = '"+keyName+"'";

        Connection conn = null;
        Statement stmt = null;
        int keyFormDb = 0;
        try{
            Driver driver = (Driver)Class.forName("org.hsqldb.jdbcDriver").newInstance();
            DriverManager.registerDriver(driver);

            String url = "jdbc:hsqldb:hsql://localhost/pattern";
            String user = "sa";
            String passwd = "";
            conn = DriverManager.getConnection(url,user,passwd);
            stmt = conn.createStatement();
            stmt.executeUpdate(sqlUpdate);
            ResultSet rs = stmt.executeQuery(sqlSelete);
            if(rs != null && rs.next()){
                keyFormDb = rs.getInt(1);
            }

        }catch(Exception e){
            try {
                stmt.close();
                conn.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }

        maxValue = keyFormDb;
        nextValue = keyFormDb - cache;

    }


}

package pattern.multiton;

import java.util.HashMap;
import java.util.Map;

/*
* KeyGenerator with multiton pattern
@author ZhangPu
Feb 22, 2007 5:55:24 PM
*/

public class KeyGenerator {

    /**
     * save keyServices
     */
    private static Map<String,KeyGenerator> KeyGenerators = new HashMap<String,KeyGenerator>();
    /**
     * the current instance.
     */
    private KeyService keyService;
    /**
     * cache pool size
     */
    private static final int KEY_CACHE = 20;

    private KeyGenerator(){}

    private KeyGenerator(String keyName){
         keyService = new KeyService(KEY_CACHE,keyName);
    }

    /**
     * Multiton instance
     * @param keyName
     * @return
     */
    public synchronized static KeyGenerator getInstance(String keyName){

        KeyGenerator keyGenerator;
        if(KeyGenerators.containsKey(keyName)){
            keyGenerator = KeyGenerators.get(keyName);
        }else{
            keyGenerator = new KeyGenerator(keyName);
            KeyGenerators.put(keyName, keyGenerator);
        }
        return keyGenerator;
    }

    /**
     * business method.
     * @return
     */
    public int getNextKey(){
        return keyService.getNextKey();
    }


}

package pattern.multiton;

/*
@author ZhangPu
Feb 22, 2007 6:27:22 PM
*/

public class Client {

    public static void main(String[] args) {
        String keyName = "SYS_RESOURCE";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(keyName);

        for(int i=0;i<20;i++){
            System.out.println("time"+(i+1)+":"+keyGenerator.getNextKey());
        }
    }
}

阿卜 2007-02-22 21:45 发表评论

单例模式Singleton

阿卜 — Thu, 22 Feb 2007 10:48:00 GMT

摘要: 单例模式(singleton)在很多系统中都比较常用。我用得最多的就是用来做缓存。最新重新学习设计模式，想整理一下开发中的一些经验和资料上的讲解以备以后查看。Singleton模式要点1.单例类在一个容器中只有一个实例。2.单例类使用静态方法自己提供向客户端提供实例，自己拥有自己的引用。3.必须向整个容器提供自己的实例。单例类的状态1、无状态单例类可以在多个容器或JVM中存在多个实例而正常运行，因... 阅读全文

阿卜 2007-02-22 18:48 发表评论

[原]JAVA关键字-final

阿卜 — Sat, 10 Feb 2007 15:56:00 GMT

在 JAVA 语言中，有很多特殊的关键字（ final,static,super,supert,this 等）是每个 JAVA 程序员必须应该搞清楚的，不仅在实际开发中会用到，而起也是面试或考试题里面青睐的考点之一。

本文是自己关于关键字 final 的一些总结。 final 关键字主要应用在标志和声明类，成员变量和方法为不可变，通过这个基本定义可以扩展到 final 可以限制类和方法的继承关系。

final 变量

final 变量分为简单变量和对象变量。声明 final 的简单变量，表示该变量从初始化后其值（简单变量直接存储值，而不是引用）就不会改变，需要注意的是在使用其他类提供的 public 的 final 简单变量的时候，就算其他类改变了其定义并重新编译，使用的类在重新编译前该值是不会改变的（参考： http://blog.csdn.net/daniel112/archive/2006/10/11/1330255.aspx ）。声明为 final 的对象变量表示一旦初始化其引用不会改变。

final 变量初始化化可以在声明时或构造函数中完成。

Public class MyFinalTest{

   /** 声明时候直接初始化 */

  Public final String FINAL_STR = “final_str”;

   /** 在构造函数中初始化 */

  Private final String FINAL_STR1;

  Public MyFinalTest(){

    FINAL_STR1 = “asdfasd”;

}

}

final 类

定义为 final 的类表示该类不能被继承，也就是说该类是一个功能设计完成，不在需要扩展的类。同时该成员方法也对应默认标志为 final ，成员变量随定义而定。

Public final class FinalClass{

  Public void method1(){}

   /**

  * 没有必要加关键字final

   */

  Public final void method2(){}

}

final 方法

定义为 final 的方法表示该方法不能被子类覆写（ override ）。

阿卜 2007-02-10 23:56 发表评论