2010年6月29日随笔档案 - 风故故，也依依

2010年6月29日

> 引言
在Jorm中，主键的生成策略主要有AUTO、UUID、GUID、FOREIGN、SEQUENCE、INCREMENT、IDENTITY、ASSIGNED，下面分别来讲述这几种策略的应用场景

> GenerationType.AUTO
Jorm的默认主键策略，自动增长型，自增步长为1，适用数据类型int,long,如：
private int id // 默认策略就是AUTO，故可以不写主键策略
或
@Id(GenerationType.AUTO) // 默认策略可以省去不写的哦~
private int id

> GenerationType.INCREMENT
顾名思义，增长型，适用数据类型int,long。自增步长为1
1> 使用默认自增步长1，如：
     @Id(GenerationType.INCREMENT)
     @Column("item_id")
     private long id;
2> 使用自定义步长，如：
     @Id(value = GenerationType.INCREMENT, incrementBy=3) // 这里自增步长为3，注意写法
     private int id;

> GenerationType.IDENTITY
对于那些实现了自动增长的数据库，可以使用IDENTITY，如MySQL,SQL Server,PostreSQL,前提是
MySQL数据库中建表语句定义了主键为：id(你的主键列名) int NOT NULL AUTO_INCREMENT 或
id(你的主键列名) bigint NOT NULL AUTO_INCREMENT
SQL Server数据库中建表语句定义了主键为：id int identity(xx, xx) 如此类似
PostreSQL数据库中建表语句定义了主键为：id bigserial 或 id serial
使用例子
@Id(GenerationType.IDENTITY)
@Column("id")
private long sid;

> GenerationType.UUID
与数据库无关的策略，适用数据类型：字符串类型，适用所有数据库，长度须大于或等于32
@Id(GenerationType.UUID)
private String id;

> GenerationType.GUID
与UUID有点类似，不过这个id值是又数据库来生成的，适用于数据库MySQL、PostgreSQL、SQL Server、Oracle等
@Id(GenerationType.GUID)
private String id;

> GenerationType.FOREIGN
适用于一对一关系中引用了另一个对象的主键作为自己的主键的情形，如：
@Id(GenerationType.FOREIGN)
@Column("identity_number")
private String identity;

> GenerationType.SEQUENCE
这个不用多说，应用于Oracle、H2、PostgreSQL等有sequence序列功能的数据库

> GenerationType.ASSIGNED
用户自定义生成，需要由程序员手工给主键主动赋值

项目地址:http://javaclub.sourceforge.net/jorm.html
下载地址:http://sourceforge.net/projects/javaclub/files/jorm/

posted @ 2011-10-10 15:17 jadmin 阅读(1490) | 评论 (3) | 编辑收藏

使用Jorm进行批量操作

直接上代码吧：

> Demo one
public void batch_op_one() {

    session = Jorm.getSession();
    JdbcBatcher batcher = session.createBatcher();
    batcher.addBatch("delete from t_id_auto");
    batcher.addBatch("delete from t_incre");
    batcher.addBatch("delete from t_user");
    batcher.execute();

    session.beginTransaction();
    long start;
    try {
        start = System.currentTimeMillis();
        String sql = "INSERT INTO t_user(sex,age,career,name,id) VALUES(?,?,?,?,?)";
        for (int i = 0; i < 100000; i++) {
            batcher.addBatch(sql, new Object[] {"男", Numbers.random(98), Strings.random(10), Strings.fixed(6), (i+1) });}
            String sqlx = "INSERT INTO t_id_auto(name, id) VALUES(?, ?)";
            for (int i = 0; i < 100000; i++) {
                batcher.addBatch(sqlx, new Object[] {Strings.fixed(6), (i+1)});
                if(i > 200) {
                    //Integer.parseInt("kkk");
                }
            }
            batcher.execute();
            System.out.println(System.currentTimeMillis() - start);
    } catch (Exception e) {
        session.rollback();
    } finally {
        session.endTransaction();
        session.close();
    }
}

> Demo two
public void batch_op_two() {

    session = Jorm.getSession();
    session.beginTransaction();
    session.clean(User.class);
    JdbcBatcher batcher = session.createBatcher();
    batcher.setBatchSize(500);// 指定每批处理的记录数

    User u;
    int times = 20 * 100;
    long start = System.currentTimeMillis();
    for(int i = 0; i < times; i++) {
    String sex = (i % 2 == 0 ? "男" : "女");
    u = new User(Strings.fixed(6), sex, Numbers.random(100), Strings.random(16));
    batcher.save(u);
    }
    batcher.execute();
    session.endTransaction();
    long cost = (System.currentTimeMillis() - start);
    System.out.println("Total：" + cost);
    System.out.println("Each：" + (float) cost / times);
    session.close();
}

项目地址：http://javaclub.sourceforge.net/jorm.html
下载地址: http://sourceforge.net/projects/javaclub/files/jorm/

posted @ 2011-10-09 20:09 jadmin 阅读(1288) | 评论 (0) | 编辑收藏

关系型数据库对对象继承关系的解决方案

关系数据库不支持继承，我们可以做如下的映射，这些映射都是牺牲关系模式的范式基础的

1，用一个表包含所有继承层次的所有字段，然后标识列来标示是哪个类。这种映射方法最简单，但是是违反规范化的，而且有些字段要强制为NULL值，无法保证关系数据模型的数据完整性，这种映射方式性能最高，最简单。

2，每个具体类一张表（意思就是父类不需要表），所有父属性在具体类表中重复，这种映射如果要查询父类要全部扫描子类表，而且一旦父类变化，这些字表要全部变化。

3，每个类一张表，表里只包含所属类的属性，然后子类和父类共享外键，这种映射避免了第2种的可怕的修改，但是查询的时候要执行连接。

posted @ 2011-09-27 09:38 jadmin 阅读(197) | 评论 (0) | 编辑收藏

高并发数据库自增主键分析

      在一般情况下，在新增领域对象后，都需要获取对应的主键值。使用应用层来维护主键，在一定程度上有利于程序性能的优化和应用移植性的提高。在采用数据库自增主键的方案里，如果JDBC驱动不能绑定新增记录对应的主键，就需要手工执行查询语句以获取对应的主键值，对于高并发的系统，这很容易返回错误的主键。通过带缓存的DataFieldMaxValueIncrementer，可以一次获取批量的主键值，供多次插入领域对象时使用，它的执行性能是很高的。

      我们经常使用数据的自增字段作为表主键，也即主键值不在应用层产生，而是在新增记录时，由数据库产生。这样，应用层在保存对象前并不知道对象主键值，而必须在保存数据后才能从数据库中返回主键值。在很多情况下，我们需要获取新对象持久化后的主键值。在Hibernate等ORM框架，新对象持久化后，Hibernate会自动将主键值绑定到对象上，给程序的开发带来了很多方便。

      在JDBC 3.0规范中，当新增记录时，允许将数据库自动产生的主键值绑定到Statement或PreparedStatement中。

使用Statement时，可以通过以下方法绑定主键值： int executeUpdate(String sql, int autoGeneratedKeys)

也可以通过Connection创建绑定自增值的PreparedStatement： PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)

当autoGeneratedKeys参数设置为Statement.RETURN_GENERATED_KEYS值时即可绑定数据库产生的主键值，设置为Statement.NO_GENERATED_KEYS时，不绑定主键值。下面的代码演示了Statement绑定并获取数据库产生的主键值的过程：

      Statement stmt = conn.createStatement();
      String sql = "INSERT INTO t_topic(topic_title,user_id) VALUES(‘测试主题’,’123’)";
      stmt.executeUpdate(sql,Statement.RETURN_GENERATED_KEYS); // ①指定绑定表自增主键值
      ResultSet rs = stmt.getGeneratedKeys();
      if( rs.next() ) {
           intkey = rs.getInt(); // ②获取对应的表自增主键值
      }

      Spring利用这一技术，提供了一个可以返回新增记录对应主键值的方法： int update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder) ，其中第二个参数类型org.springframework.jdbc.support.KeyHolder，它是一个回调接口，Spring使用它保存新增记录对应的主键，该接口的接口方法描述如下：

Number getKey() throws InvalidDataAccessApiUsageException;

当仅插入一行数据，主键不是复合键且是数字类型时，通过该方法可以直接返回新的主键值。如果是复合主键，或者有多个主键返回时，该方法抛出 InvalidDataAccessApiUsageException。该方法是最常用的方法，因为一般情况下，我们一次仅插入一条数据并且主键字段类型为数字类型；

如果是复合主键，则列名和列值构成Map中的一个Entry。如果返回的是多个主键，则抛出InvalidDataAccessApiUsageException异常；

Map getKeys() throws InvalidDataAccessApiUsageException;

如果返回多个主键，即PreparedStatement新增了多条记录，则每一个主键对应一个Map，多个Map构成一个List。

List getKeyList()：

Spring为KeyHolder接口指代了一个通用的实现类GeneratedKeyHolder，该类返回新增记录时的自增长主键值。假设我们希望在新增论坛板块对象后，希望将主键值加载到对象中，则可以按以下代码进行调整：

      public voidaddForum(final Forum forum) {
            final String sql = "INSERT INTO t_forum(forum_name,forum_desc) VALUES(?,?)";
            KeyHolder keyHolder = newGeneratedKeyHolder(); // ①创建一个主键执有者
            getJdbcTemplate().update(newPreparedStatementCreator() {
                  public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
                        PreparedStatement ps = conn.prepareStatement(sql);
                        ps.setString(1, forum.getForumName());
                        ps.setString(2, forum.getForumDesc());
                        returnps;
                  }
            }, keyHolder);
            forum.setForumId(keyHolder.getKey().intValue()); // ②从主键执有者中获取主键
      }

这样，在调用addForum(Forum forum)新增forum领域对象后，forum将拥有对应的主键值，方便后继的使用。在JDBC 3.0之前的版本中，PreparedStatement不能绑定主键，如果采用表自增键（如MySQL的auto increment或SQLServer的identity）将给获取正确的主键值带来挑战——因为你必须在插入数据后，马上执行另一条获取新增主键的查询语句。下面给出了不同数据库获取最新自增主键值的查询语句：

posted @ 2011-09-25 14:27 jadmin 阅读(987) | 评论 (0) | 编辑收藏

Hibernate 中的 IdentifierGenerator

1) Assigned
主键由外部程序负责生成，无需Hibernate参与。

2) hilo
通过hi/lo 算法实现的主键生成机制，需要额外的数据库表保存主键生成历史状态。

3) seqhilo
与hilo 类似，通过hi/lo 算法实现的主键生成机制，只是主键历史状态保存在Sequence中，适用于支持Sequence的数据库，如Oracle。

4) increment
主键按数值顺序递增。此方式的实现机制为在当前应用实例中维持一个变量，以保存着当前的最大值，之后每次需要生成主键的时候将此值加1作为主键。这种方式可能产生的问题是：如果当前有多个实例访问同一个数据库，那么由于各个实例各自维护主键状态，不同实例可能生成同样的主键，从而造成主键重复异常。因此，如果同一数据库有多个实例访问，此方式必须避免使用。

5) identity
采用数据库提供的主键生成机制。如DB2、SQL Server、MySQL中的主键生成机制。

6) sequence
采用数据库提供的sequence 机制生成主键。如Oralce 中的Sequence。

7) native
由Hibernate根据底层数据库自行判断采用identity、hilo、sequence其中一种作为主键生成方式。

8) uuid.hex
由Hibernate基于128 位唯一值产生算法生成16 进制数值（编码后以长度32 的字符串表示）作为主键。

9) uuid.string
与uuid.hex 类似，只是生成的主键未进行编码（长度16）。在某些数据库中可能出现问题（如PostgreSQL）。

10) foreign
使用外部表的字段作为主键。一般而言，利用uuid.hex方式生成主键将提供最好的性能和数据库平台适应性。
另外由于常用的数据库，如Oracle、DB2、SQLServer、MySql 等，都提供了易用的主键生成机制（Auto-Increase 字段或者Sequence）。我们可以在数据库提供的主键生成机制上，采用generator-class=native的主键生成方式。不过值得注意的是，一些数据库提供的主键生成机制在效率上未必最佳，

大量并发insert数据时可能会引起表之间的互锁。数据库提供的主键生成机制，往往是通过在一个内部表中保存当前主键状态（如对于自增型主键而言，此内部表中就维护着当前的最大值和递增量），之后每次插入数据会读取这个最大值，然后加上递增量作为新记录的主键，之后再把这个新的最大值更新回内部表中，这样，一次Insert操作可能导致数据库内部多次表读写操作，同时伴随的还有数据的加锁解锁操作，这对性能产生了较大影响。因此，对于并发Insert要求较高的系统，推荐采用uuid.hex 作为主键生成机制。

如果需要采用定制的主键生成算法，则在此处配置主键生成器，主键生成器须实现org.hibernate.id.IdentifierGenerator 接口

关键词： Hibernate 主键主键生成方式 IdentifierGenerator

posted @ 2011-09-25 13:47 jadmin 阅读(1000) | 评论 (0) | 编辑收藏

使用Jorm处理Oracle存储过程返回多个游标

摘要: 阅读全文

posted @ 2011-09-23 16:17 jadmin 阅读(1270) | 评论 (1) | 编辑收藏

JDBC ORM Framework 1.0.6 发布

http://www.oschina.net/news/21642/jdbc-orm-framework-1-0-6

主要更新：
----------------------------------------
* [35] fix: oracle下一个分页取limit数错误的bug.
* [34] fix: oracle下检测是否支持Savepoints时，一个未捕获的异常.
* [33] add: 对bonecp的支持
* [32] add: 对proxool的支持
* [31] add: 对commons-dbcp的支持
* [30] fix: classpath没有config.properties文件会报错

posted @ 2011-09-23 10:53 jadmin 阅读(193) | 评论 (0) | 编辑收藏

使用Jorm处理特殊字段

> 引言
有时候我们有这样的需求，对象有一个属性可能有多个值，需要在数据库中作为一个字段存储

还是以User为例，career存储多个职业

> 建表

以MySQL为例，执行下面的sql建立数据表
CREATE TABLE `t_user` (
        `id` int(11) NOT NULL,
        `name` varchar(50) DEFAULT NULL,
        `sex` char(4) DEFAULT NULL,
        `age` int(11) DEFAULT NULL,
        `career` varchar(100) DEFAULT NULL,
        PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

> 代码

实体类 User.java

@Entity(table = "t_user")
@PK(value = "id")
public class User implements Serializable {

    /** desc */
    private static final long serialVersionUID = -4750351638245912867L;

    @Id
    private int id;

    private String name;

    private String sex;

    private Integer age;

    @Basic(processor=DefinedFieldProcessor.class)
    private String[] career;

    @NoColumn
    private int kvalue;

    public JawaUser() {
        super();
    }

    public JawaUser(String name, String sex, Integer age, String[] career) {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.career = career;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String[] getCareer() {
        return career;
    }

    public void setCareer(String[] career) {
        this.career = career;
    }

    public int getKvalue() {
        return kvalue;
    }

    public void setKvalue(int kvalue) {
        this.kvalue = kvalue;
    }

    public String toString() {
        return "User [age=" + age + ", career=" + Arrays.toString(career)
                + ", id=" + id + ", kvalue=" + kvalue + ", name=" + name
                + ", sex=" + sex + "]";
    }
}

属性字段处理类 DefinedFieldProcessor.java

import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.javaclub.jorm.Session;
import org.javaclub.jorm.common.CommonUtil;
import org.javaclub.jorm.common.Reflections;
import org.javaclub.jorm.jdbc.process.FieldProcessor;

public class DefinedFieldProcessor implements FieldProcessor {

    public Object insert(Session session, Object entity, Field field) {
        String[] crs = (String[]) Reflections.getFieldValue(entity, field);
        if(!CommonUtil.isEmpty(crs)) {
            StringBuilder sbf = new StringBuilder();
            for (int i = 0; i < crs.length; i++) {
                if(i > 0) {
                    sbf.append(",");
                }
                sbf.append(crs[i]);
            }
            return sbf.toString();
        }
        return "";
    }

    public void load(Session session, Object entity, Field field, ResultSet rs,
            int idx) throws SQLException {
        String str = rs.getString(idx);
        String[] crs = str.split(",");
        Reflections.setFieldValue(entity, field, crs);
    }

}

> 测试

import org.javaclub.jorm.Jorm;
import org.javaclub.jorm.Session;
import org.javaclub.jorm.common.Numbers;
import org.javaclub.jorm.common.Strings;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

public class FieldProcessorTest {

    static Session session;

    @BeforeClass
    public static void setUpBeforeClass() {
        session = Jorm.getSession();
    }

    @AfterClass
    public static void destroy() {
        Jorm.free();
    }

    @Test
    public void test_save() {

        session.clean(User.class);
        User u;
        for (int i = 0; i < 100; i++) {
            String sex = (i % 2 == 0 ? "男" : "女");
            String[] cr = {};
            if(i % 3 == 0) {
                cr = new String[] {Strings.fixed(2), Strings.random(5), Strings.fixed(6)};
            } else if(i % 3 == 1) {
                cr = new String[] {Strings.fixed(2), Strings.random(5)};
            } else {
                cr = new String[] {Strings.fixed(2)};
            }
            u = new User(Strings.fixed(6), sex, Numbers.random(100), cr);
            session.save(u);
        }

        for (int i = 0; i < 10; i++) {
            u = session.read(User.class, i + 1);
            System.out.println(u);
        }
    }
}

posted @ 2011-09-22 20:16 jadmin 阅读(1214) | 评论 (0) | 编辑收藏

使用Jorm简单的增删查改数据库

> 准备
以MySQL为例，执行下面的sql建立数据表
CREATE TABLE `t_user` (
        `id` int(11) NOT NULL,
        `name` varchar(50) DEFAULT NULL,
        `sex` char(4) DEFAULT NULL,
        `age` int(11) DEFAULT NULL,
        `career` varchar(100) DEFAULT NULL,
        PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

> 引入jar或maven依赖，需要jar包
gerald-jorm-1.0.5.jar 最新版本下载：http://sourceforge.net/projects/javaclub/files
commons-logging-1.1.1.jar
log4j-1.2.14.jar
mysql-connector-java-5.1.6.jar
javassist-3.11.0.GA.jar 或 cglib-nodep-2.2.2.jar (根据实际情况选择性加入)

> 配置文件
在你的java工程的classpath下建立config.properties和jdbc.cfg.xml文件
config.properties内容：
# 下面路径可以根据实际情况指定，为相对classpath的路径地址
jdbc.config.path=jdbc.cfg.xml

jdbc.cfg.xml内容：
<?xml version='1.0' encoding="UTF-8"?>
<jdbc-configuration>

<constant name="show_sql" value="true" />
<constant name="jdbc.batch_size" value="600" />
<constant name="bytecode.provider" value="cglib" />

<connections default="simple">

    <connection name="simple">
      <property name="connection.implementation">org.javaclub.jorm.jdbc.connection.impl.SimpleConnection</property>
      <property name="connection.dialect">MySQLDialect</property>
      <property name="connection.driver">com.mysql.jdbc.Driver</property>
      <property name="connection.jdbcurl">jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8</property>
      <property name="connection.database">test</property>
      <property name="connection.username">root</property>
      <property name="connection.password">root</property>
    </connection>

    <connection name="c3p0">
      <property name="connection.implementation">org.javaclub.jorm.jdbc.connection.impl.PooledConnection</property>
      <property name="connection.dialect">MySQLDialect</property>
      <property name="connection.driver">com.mysql.jdbc.Driver</property>
      <property name="connection.jdbcurl">jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8</property>
      <property name="connection.database">test</property>
      <property name="connection.username">root</property>
      <property name="connection.password">root</property>
      <property name="connection.pool.min">1</property>
      <property name="connection.pool.max">8</property>
      <property name="connection.test.sql">select 1</property>
    </connection>

</connections>

</jdbc-configuration>

> 实体类User.java
@PK(value = "id")
@Entity(table="t_user")
public class User {

   @Id
   private int id;

   private String name;

   private String sex;

   private Integer age;

   private String career;

   @NoColumn
   private int kvalue;

   public User() {
       super();
   }

   public User(String name, String sex, Integer age, String career) {
       super();
       this.name = name;
       this.sex = sex;
       this.age = age;
       this.career = career;
   }

   public User(Integer id, String name, String sex, Integer age, String career) {
       super();
       this.id = id;
       this.name = name;
       this.sex = sex;
       this.age = age;
       this.career = career;
   }

   public int getId() {
       return id;
   }

   public void setId(int id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getSex() {
       return sex;
   }

   public void setSex(String sex) {
       this.sex = sex;
   }

   public Integer getAge() {
       return age;
   }

   public void setAge(Integer age) {
       this.age = age;
   }

   public String getCareer() {
       return career;
   }

   public void setCareer(String career) {
       this.career = career;
   }

   public int getKvalue() {
       return kvalue;
   }

   public void setKvalue(int kvalue) {
       this.kvalue = kvalue;
   }

   public String toString() {
       StringBuffer sb = new StringBuffer();
       sb.append("[" + id + ", " + name + ", " + sex + ", " + age + ", " + career + "]");
       return sb.toString();
   }

}

这里数据库字段和java实体类User的属性在命名上是一致的，如果不一致，比如如果表创建sql为：
CREATE TABLE `t_user` (
        `user_id` int(11) NOT NULL,
        `user_name` varchar(50) DEFAULT NULL,
        `sex` char(4) DEFAULT NULL,
        `col_age` int(11) DEFAULT NULL,
        `career_job` varchar(100) DEFAULT NULL,
        PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

那么对应的实体User应该写成：
@PK(value = "id")
@Entity(table="t_user")
public class User {

   @Id
   @Column("user_id")
   private int id;

   @Column("user_name")
   private String name;

   // 与数据库字段命名一致，可以不指定@Column
   private String sex;

    @Column("col_age")
   private Integer age;

    @Column("career_job")
   private String career;

   @NoColumn
   private int kvalue;

   public User() {
       super();
   }

   public User(String name, String sex, Integer age, String career) {
       super();
       this.name = name;
       this.sex = sex;
       this.age = age;
       this.career = career;
   }

   public User(Integer id, String name, String sex, Integer age, String career) {
       super();
       this.id = id;
       this.name = name;
       this.sex = sex;
       this.age = age;
       this.career = career;
   }

   public int getId() {
       return id;
   }

   public void setId(int id) {
       this.id = id;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getSex() {
       return sex;
   }

   public void setSex(String sex) {
       this.sex = sex;
   }

   public Integer getAge() {
       return age;
   }

   public void setAge(Integer age) {
       this.age = age;
   }

   public String getCareer() {
       return career;
   }

   public void setCareer(String career) {
       this.career = career;
   }

   public int getKvalue() {
       return kvalue;
   }

   public void setKvalue(int kvalue) {
       this.kvalue = kvalue;
   }

   public String toString() {
       StringBuffer sb = new StringBuffer();
       sb.append("[" + id + ", " + name + ", " + sex + ", " + age + ", " + career + "]");
       return sb.toString();
   }

}

> 对User的增删查改，UserCrudTest.java，记得引入junit-4.8.2.jar
public class UserCrudTest {

   static Session session;

   @BeforeClass
   public static void before() {
       session = Jorm.getSession();
   }

   @AfterClass
   public static void after() {
       Jorm.free();
   }

   @Test
   public void save_user() {
       session.clean(User.class);
       User user = null;
       for (int i = 0; i < 600; i++) {
           String sex = (i % 2 == 0 ? "男" : "女");
           user = new User(Strings.fixed(5), sex, Numbers.random(98), Strings.random(8));
           session.save(user);
       }
   }

   @Test // 批量保存
   public void batch_save_user() {
       session.clean(User.class);
       JdbcBatcher batcher = session.createBatcher();
       User user = null;
       for (int i = 0; i < 600; i++) {
           String sex = (i % 2 == 0 ? "男" : "女");
           user = new User(Strings.fixed(5), sex, Numbers.random(98), Strings.random(8));
           batcher.save(user);
       }
       batcher.execute();
   }

   @Test
   public void loadUser() {
       User user = session.read(User.class, 1);
       // 这里user是一个代理对象，因为@Entity(table="t_user", lazy = true)
       System.out.println(user.getCareer());// 发出查询sql
   }

   @Test
   public void deletUser() {
       User user = session.read(User.class, 1);
       if(null != user) {
           session.delete(user);
       }
       user = session.read(User.class, 1);
       System.out.println(user);
   }

   @Test
   public void test_update_proxy() {

       User u;
       u = session.read(User.class, 2);
       Assert.assertNotNull(u);
       Assert.assertTrue(u instanceof JormProxy);

       u.setName("Gerald.Chen");
       session.update(u);
       System.out.println(u.getName());
       u = session.read(User.class, 2);
       Assert.assertTrue("Gerald.Chen".equals(u.getName()));
   }

   @Test
   public void queryUser() {
       SqlParams<User> params = new SqlParams<User>();
       params.setObjectClass(User.class);
       params.setFirstResult(8);
       params.setMaxResults(20);
       List<User> users = session.list(params);
       System.out.println(users.size());
       System.out.println(users);
   }

}

posted @ 2011-09-21 18:42 jadmin 阅读(1407) | 评论 (5) | 编辑收藏

发布一款精巧的Java ORM Framework

> 特点
1.支持多数据源管理和配置
2.自动封装Entity
3.支持事务
4.支持存储过程的方便调用
5.支持lazy加载
6.支持分页查询
7.支持多种数据库H2,MySQL,Oracle,PostgrSQL,SQLServer

> 要求
1.JDK 1.5 or later
2.如需要lazy加载，需要引入cglib或javaassit，具体可配置

> 示例
1.添加
Session session = Jorm.getSession();
User u = new User("Gerald.Chen", "男", 21, "job");;
session.save(u);

2.删除
session.clean(User.class);// 清空表
session.delete(User.class, "id > 100");// 指定条件删除

session.delete(user);

3.查询
User user = session.read(User.class, 1);// 根据主键加载

// 加载第一个
User user = session.loadFirst(User.class, "(SELECT * FROM t_user WHERE id > ?)", 88);

// 分页查询
SqlParams<User> params = new SqlParams<User>("SELECT * FROM t_user WHERE id > ?", new Object[] { 6 });
params.setObjectClass(User.class);
params.setFirstResult(3);
params.setMaxResults(10);
List<User> users = session.list(params);

// 查询单个属性
String sql = "SELECT name FROM t_user WHERE id = 28";
String name = session.queryUniqueObject(sql);

// 查询属性列表
List<String> names = session.list(String.class, "SELECT name FROM t_user WHERE id > ?", 200);
List<Integer> ages = session.list(int.class, "SELECT age FROM t_user WHERE age > 18");

4.存储过程
final String pro = "{? = call hello_proc(?)}";
String r = session.call(new ProcedureCaller() {

     public CallableStatement prepare() throws SQLException {
   CallableStatement cs = this.getSession().getConnection().prepareCall(pro);
   cs.setString(2, "World");
   cs.registerOutParameter(1, Types.CHAR);
   return cs;
     }

     public String callback(CallableStatement cs) throws SQLException {
   cs.execute();
   return cs.getString(1);
     }
});

5.事务
session.clean(User.class);
User u;
session.beginTransaction();
try {
   for(int i = 0; i < 1000; i++) {
       String sex = (i % 2 == 0 ? "男" : "女");
       u = new User(Strings.fixed(6), sex, Numbers.random(100), Strings.random(16));
       session.save(u);
       if(i == 886) {
            Integer.parseInt("kkk");
       }
   }
   session.commit();
} catch (Exception e) {
   session.rollback();
} finally {
   session.endTransaction();
}

这是一个完全基于JDBC的轻量java orm framework, 目标定位于使用方便,简单，后续会增加许多新的特性

项目地址：http://javaclub.sourceforge.net/jorm.html

下载地址：http://sourceforge.net/projects/javaclub/files

posted @ 2011-09-20 18:52 jadmin 阅读(256) | 评论 (0) | 编辑收藏

基于HTTP协议的断点续传

> 原理

其实断点续传的原理很简单，就是在 Http 的请求上和一般的下载有所不同而已。
打个比方，浏览器请求服务器上的一个文时，所发出的请求如下：
假设服务器域名为 wwww.sjtu.edu.cn，文件名为 down.zip。
GET /down.zip HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-
excel, application/msword, application/vnd.ms-powerpoint, */*
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)
Connection: Keep-Alive

服务器收到请求后，按要求寻找请求的文件，提取文件的信息，然后返回给浏览器，返回信息如下：

200
Content-Length=106786028
Accept-Ranges=bytes
Date=Mon, 30 Apr 2001 12:56:11 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT

所谓断点续传，也就是要从文件已经下载的地方开始继续下载。所以在客户端浏览器传给 Web 服务器的时候要多加一条信息 -- 从哪里开始。
下面是用自己编的一个"浏览器"来传递请求信息给 Web 服务器，要求从 2000070 字节开始。
GET /down.zip HTTP/1.0
User-Agent: NetFox
RANGE: bytes=2000070-
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔细看一下就会发现多了一行 RANGE: bytes=2000070-
这一行的意思就是告诉服务器 down.zip 这个文件从 2000070 字节开始传，前面的字节不用传了。
服务器收到这个请求以后，返回的信息如下：
206
Content-Length=106786028
Content-Range=bytes 2000070-106786027/106786028
Date=Mon, 30 Apr 2001 12:55:20 GMT
ETag=W/"02ca57e173c11:95b"
Content-Type=application/octet-stream
Server=Microsoft-IIS/5.0
Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT

和前面服务器返回的信息比较一下，就会发现增加了一行：
Content-Range=bytes 2000070-106786027/106786028

返回的代码也改为 206 了，而不再是 200 了。

> 关键点

(1) 用什么方法实现提交 RANGE: bytes=2000070-。
当然用最原始的 Socket 是肯定能完成的，不过那样太费事了，其实 Java 的 net 包中提供了这种功能。代码如下：

URL url = new URL("http://www.sjtu.edu.cn/down.zip");
HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();

// 设置 User-Agent
httpConnection.setRequestProperty("User-Agent","NetFox");
// 设置断点续传的开始位置
httpConnection.setRequestProperty("RANGE","bytes=2000070");
// 获得输入流
InputStream input = httpConnection.getInputStream();

从输入流中取出的字节流就是 down.zip 文件从 2000070 开始的字节流。大家看，其实断点续传用 Java 实现起来还是很简单的吧。接下来要做的事就是怎么保存获得的流到文件中去了。

(2)保存文件采用的方法。
我采用的是 IO 包中的 RandAccessFile 类。
操作相当简单，假设从 2000070 处开始保存文件，代码如下：
RandomAccess oSavedFile = new RandomAccessFile("down.zip","rw");
long nPos = 2000070;
// 定位文件指针到 nPos 位置
oSavedFile.seek(nPos);
byte[] b = new byte[1024];
int nRead;
// 从输入流中读入字节流，然后写到文件中
while((nRead=input.read(b,0,1024)) > 0) {
oSavedFile.write(b,0,nRead);

}

posted @ 2011-09-08 21:51 jadmin 阅读(105) | 评论 (0) | 编辑收藏

数据同步和复制解决方案SymmetricDS

SymmetricDS是一个平台独立的数据同步和复制的解决方案。

配置数据模型：

运行时数据模型：

posted @ 2011-09-02 09:15 jadmin 阅读(231) | 评论 (0) | 编辑收藏

判断指定数字是否存在于海量数据中

> 问题：给40亿个不重复的unsigned int的整数，没排过序的，然后再给几个数，如何快速判断这几个数是否在那40亿个数当中?

> 解决：unsigned int 的取值范围是0到2^32-1。我们可以申请连续的2^32/8=512M的内存，用每一个bit对应一个unsigned int数字。首先将512M内存都初始化为0，然后每处理一个数字就将其对应的bit设置为1。当需要查询时，直接找到对应bit，看其值是0还是1即可。

posted @ 2011-08-30 21:01 jadmin 阅读(137) | 评论 (0) | 编辑收藏

Hibernate的lazy策略属性extra

lazy的属性有false、true、extra

false和true用得比较多，extra属性是不大容易重视的,其实它和true差不多

extra有个小的智能的地方是,即调用集合的size/contains等方法的时候，hibernate并不会去加载整个集合的数据，而是发出一条聪明的SQL语句，以便获得需要的值，只有在真正需要用到这些集合元素对象数据的时候，才去发出查询语句加载所有对象的数据

posted @ 2011-08-30 20:00 jadmin 阅读(107) | 评论 (0) | 编辑收藏

Hadoop集群搭建

本文将介绍在Linux(Red Hat 9)环境下搭建Hadoop集群，此Hadoop集群主要由三台机器组成，主机名分别为：
linux 192.168.35.101
linux02 192.168.35.102
linux03 192.168.35.103

从map reduce计算的角度讲，linux作为master节点，linux02和linux03作为slave节点。
从hdfs数据存储角度讲，linux作为namenode节点，linux02和linux03作为datanode节点。

一台namenode机，主机名为linux，hosts文件内容如下：
127.0.0.1       linux          localhost.localdomain          localhost
192.168.35.101     linux          linux.localdomain              linux
192.168.35.102     linux02
192.168.35.103     linux03

两台datanode机，主机名为linux02和linux03
>linux02的hosts文件
127.0.0.1         linux02       localhost.localdomain       localhost
192.168.35.102     linux02       linux02.localdomain         linux02
192.168.35.101     linux
192.168.35.103     linux03
>inux03的hosts文件
127.0.0.1             linux03          localhost.localdomain          localhost
192.168.35.103          linux03            linux03.localdomain            linux03
192.168.35.101     linux
192.168.35.102     linux02

1.安装JDK
> 从java.cun.com下载jdk-6u7-linux-i586.bin

> ftp上传jdk到linux的root目录下

> 进入root目录，先后执行命令
chmod 755 jdk-6u18-linux-i586-rpm.bin
./jdk-6u18-linux-i586-rpm.bin

一路按提示下去就会安装成功

> 配置环境变量
cd进入/etc目录，vi编辑profile文件，将下面的内容追加到文件末尾
export JAVA_HOME=/usr/java/jdk1.6.0_18
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

注意：三台机器都要安装JDK~

2.设置Master/Slave机器之间可以通过SSH无密钥互相访问
最好三台机器的使用相同的账户名，我是直接使用的root账户

操作namenode机linux:
以用户root登录linux，在/root目录下执行下述命令：
ssh-keygen -t rsa
一路回车下去即可在目录/root/.ssh/下建立两个文件id_rsa.pub和id_rsa。

接下来，需要进入/root/.ssh目录，执行如下命令：
cd .ssh

再把is_rsa.pub文件复制到linux02和linux03机器上去。
scp -r id_rsa.pub root@192.168.35.102:/root/.ssh/authorized_keys_01
scp -r id_rsa.pub root@192.168.35.103:/root/.ssh/authorized_keys_01

操作datanode机linux02:
以用户root登录linux02，在目录下执行命令：
ssh-keygen -t rsa
一路回车下去即可在目录/root/.ssh/下建立两个文件 id_rsa.pub和id_rsa。

接下来，需要进入/root/.ssh目录，执行如下命令：
cd .ssh

再把is_rsa.pub文件复制到namenode机linux上去。
scp -r id_rsa.pub root@192.168.35.101:/root/.ssh/authorized_keys_02

操作datanode机linux03:
以用户root登录linux03，在目录下执行命令：
ssh-keygen -t rsa
一路回车下去即可在目录/root/.ssh/下建立两个文件 id_rsa.pub和id_rsa。

接下来，需要进入/root/.ssh目录，执行如下命令：
cd .ssh

再把is_rsa.pub文件复制到namenode机linux上去。
scp -r id_rsa.pub root@192.168.35.101:/root/.ssh/authorized_keys_03

*******************************************************************************

上述方式分别为linux\linux02\linux03机器生成了rsa密钥，并且把linux的id_rsa.pub复制到linux02\linux03上去了，而把linux02和linux03上的id_rsa.pub复制到linux上去了。

接下来还要完成如下步骤：

linux机:
以root用户登录linux，并且进入目录/root/.ssh下，执行如下命令：
cat id_rsa.pub >> authorized_keys
cat authorized_keys_02 >> authorized_keys
cat authorized_keys_03 >> authorized_keys
chmod 644 authorized_keys

linux02机:
以root用户登录linux02，并且进入目录/root/.ssh下，执行如下命令：
cat id_rsa.pub >> authorized_keys
cat authorized_keys_01 >> authorized_keys
chmod 644 authorized_keys

linux03机:
以root用户登录linux03，并且进入目录/root/.ssh下，执行如下命令：
cat id_rsa.pub >> authorized_keys
cat authorized_keys_01 >> authorized_keys
chmod 644 authorized_keys

通过上述配置，现在以用户root登录linux机，既可以无密钥认证方式访问linux02和linux03了，同样也可以在linux02和linux03上以ssh linux方式连接到linux上进行访问了。

3.安装和配置Hadoop
> 在namenode机器即linux机上安装hadoop
我下载的是hadoop-0.20.2.tar.gz，ftp上传到linux机的/root目录上，解压到安装目录/usr/hadoop，最终hadoop的根目录是/usr/hadoop/hadoop-0.20.2/

编辑/etc/profile文件，在文件尾部追加如下内容：
export HADOOP_HOME=/usr/hadoop/hadoop-0.20.2
export PATH=$HADOOP_HOME/bin:$PATH

> 配置Hadoop
core-site.xml:
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>


<configuration>
   <property>
                <name>fs.default.name</name>
                <value>hdfs://192.168.35.101:9000</value>
        </property>
        <property>
                <name>hadoop.tmp.dir</name>
                <value>/tmp/hadoop/hadoop-${user.name}</value>
        </property>
</configuration>

hdfs-site.xml:
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>


<configuration>
        <property>
                <name>dfs.name.dir</name>
                <value>/home/hadoop/name</value>
        </property>
        <property>
                <name>dfs.data.dir</name>
                <value>/home/hadoop/data</value>
        </property>
        <property>
                <name>dfs.replication</name>
                <value>2</value>
        </property>
</configuration>

mapred-site.xml
<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>


<configuration>
        <property>
                <name>mapred.job.tracker</name>
                <value>192.168.35.101:9001</value>
        </property>
</configuration>

masters
192.168.35.101

slaves
192.168.35.102
192.168.35.103

至此，hadoop的简单配置已经完成

> 将在namenode机器上配置好的hadoop部署到datanode机器上
这里使用scp命令进行远程传输，先后执行命令
scp -r /usr/hadoop/hadoop-0.20.2 root@192.168.35.102:/usr/hadoop/
scp -r /usr/hadoop/hadoop-0.20.2 root@192.168.35.103:/usr/hadoop/

4.测试
以root用户登入namenode机linux，进入目录/usr/hadoop/hadoop-0.20.2/
cd /usr/hadoop/hadoop-0.20.2

> 执行格式化
[root@linux hadoop-0.20.2]# bin/hadoop namenode -format
11/07/26 21:16:03 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG:   host = linux/127.0.0.1
STARTUP_MSG:   args = [-format]
STARTUP_MSG:   version = 0.20.2
STARTUP_MSG:   build = https://svn.apache.org/repos/asf/hadoop/common/branches/branch-0.20 -r 911707; compiled by 'chrisdo' on Fri Feb 19 08:07:34 UTC 2010
************************************************************/
Re-format filesystem in /home/hadoop/name ? (Y or N) Y
11/07/26 21:16:07 INFO namenode.FSNamesystem: fsOwner=root,root,bin,daemon,sys,adm,disk,wheel
11/07/26 21:16:07 INFO namenode.FSNamesystem: supergroup=supergroup
11/07/26 21:16:07 INFO namenode.FSNamesystem: isPermissionEnabled=true
11/07/26 21:16:07 INFO common.Storage: Image file of size 94 saved in 0 seconds.
11/07/26 21:16:07 INFO common.Storage: Storage directory /home/hadoop/name has been successfully formatted.
11/07/26 21:16:07 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at linux/127.0.0.1
************************************************************/

> 启动hadoop
[root@linux hadoop-0.20.2]# bin/start-all.sh
starting namenode, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-namenode-linux.out
192.168.35.102: starting datanode, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-datanode-linux02.out
192.168.35.103: starting datanode, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-datanode-linux03.out
192.168.35.101: starting secondarynamenode, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-secondarynamenode-linux.out
starting jobtracker, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-jobtracker-linux.out
192.168.35.103: starting tasktracker, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-tasktracker-linux03.out
192.168.35.102: starting tasktracker, logging to /usr/hadoop/hadoop-0.20.2/bin/../logs/hadoop-root-tasktracker-linux02.out
[root@linux hadoop-0.20.2]#

> 用jps命令查看进程
[root@linux hadoop-0.20.2]# jps
7118 SecondaryNameNode
7343 Jps
6955 NameNode
7204 JobTracker
[root@linux hadoop-0.20.2]#

posted @ 2011-08-25 16:01 jadmin 阅读(125) | 评论 (0) | 编辑收藏

Hadoop架构设计

引言

Hadoop分布式文件系统(HDFS)被设计成适合运行在通用硬件(commodity hardware)上的分布式文件系统。它和现有的分布式文件系统有很多共同点。但同时，它和其他的分布式文件系统的区别也是很明显的。HDFS是一个高度容错性的系统，适合部署在廉价的机器上。HDFS能提供高吞吐量的数据访问，非常适合大规模数据集上的应用。HDFS放宽了一部分POSIX约束，来实现流式读取文件系统数据的目的。HDFS在最开始是作为Apache Nutch搜索引擎项目的基础架构而开发的。HDFS是Apache Hadoop Core项目的一部分。这个项目的地址是http://hadoop.apache.org/core/。

前提和设计目标

硬件错误

硬件错误是常态而不是异常。HDFS可能由成百上千的服务器所构成，每个服务器上存储着文件系统的部分数据。我们面对的现实是构成系统的组件数目是巨大的，而且任一组件都有可能失效，这意味着总是有一部分HDFS的组件是不工作的。因此错误检测和快速、自动的恢复是HDFS最核心的架构目标。

流式数据访问

运行在HDFS上的应用和普通的应用不同，需要流式访问它们的数据集。HDFS的设计中更多的考虑到了数据批处理，而不是用户交互处理。比之数据访问的低延迟问题，更关键的在于数据访问的高吞吐量。POSIX标准设置的很多硬性约束对HDFS应用系统不是必需的。为了提高数据的吞吐量，在一些关键方面对 POSIX的语义做了一些修改。

大规模数据集

运行在HDFS上的应用具有很大的数据集。HDFS上的一个典型文件大小一般都在G字节至T字节。因此，HDFS被调节以支持大文件存储。它应该能提供整体上高的数据传输带宽，能在一个集群里扩展到数百个节点。一个单一的HDFS实例应该能支撑数以千万计的文件。

简单的一致性模型

HDFS应用需要一个“一次写入多次读取”的文件访问模型。一个文件经过创建、写入和关闭之后就不需要改变。这一假设简化了数据一致性问题，并且使高吞吐量的数据访问成为可能。Map/Reduce应用或者网络爬虫应用都非常适合这个模型。目前还有计划在将来扩充这个模型，使之支持文件的附加写操作。

“移动计算比移动数据更划算”

一个应用请求的计算，离它操作的数据越近就越高效，在数据达到海量级别的时候更是如此。因为这样就能降低网络阻塞的影响，提高系统数据的吞吐量。将计算移动到数据附近，比之将数据移动到应用所在显然更好。HDFS为应用提供了将它们自己移动到数据附近的接口。

异构软硬件平台间的可移植性

HDFS在设计的时候就考虑到平台的可移植性。这种特性方便了HDFS作为大规模数据应用平台的推广。

Namenode 和 Datanode

HDFS采用master/slave架构。一个HDFS集群是由一个Namenode和一定数目的Datanodes组成。Namenode是一个中心服务器，负责管理文件系统的名字空间(namespace)以及客户端对文件的访问。集群中的Datanode一般是一个节点一个，负责管理它所在节点上的存储。HDFS暴露了文件系统的名字空间，用户能够以文件的形式在上面存储数据。从内部看，一个文件其实被分成一个或多个数据块，这些块存储在一组 Datanode上。Namenode执行文件系统的名字空间操作，比如打开、关闭、重命名文件或目录。它也负责确定数据块到具体Datanode节点的映射。Datanode负责处理文件系统客户端的读写请求。在Namenode的统一调度下进行数据块的创建、删除和复制。

Namenode和Datanode被设计成可以在普通的商用机器上运行。这些机器一般运行着GNU/Linux操作系统(OS)。 HDFS采用Java语言开发，因此任何支持Java的机器都可以部署Namenode或Datanode。由于采用了可移植性极强的Java语言，使得 HDFS可以部署到多种类型的机器上。一个典型的部署场景是一台机器上只运行一个Namenode实例，而集群中的其它机器分别运行一个Datanode 实例。这种架构并不排斥在一台机器上运行多个Datanode，只不过这样的情况比较少见。

集群中单一Namenode的结构大大简化了系统的架构。Namenode是所有HDFS元数据的仲裁者和管理者，这样，用户数据永远不会流过Namenode。

文件系统的名字空间 (namespace)

HDFS支持传统的层次型文件组织结构。用户或者应用程序可以创建目录，然后将文件保存在这些目录里。文件系统名字空间的层次结构和大多数现有的文件系统类似：用户可以创建、删除、移动或重命名文件。当前，HDFS不支持用户磁盘配额和访问权限控制，也不支持硬链接和软链接。但是HDFS架构并不妨碍实现这些特性。

Namenode负责维护文件系统的名字空间，任何对文件系统名字空间或属性的修改都将被Namenode记录下来。应用程序可以设置HDFS保存的文件的副本数目。文件副本的数目称为文件的副本系数，这个信息也是由Namenode保存的。

数据复制

HDFS被设计成能够在一个大集群中跨机器可靠地存储超大文件。它将每个文件存储成一系列的数据块，除了最后一个，所有的数据块都是同样大小的。为了容错，文件的所有数据块都会有副本。每个文件的数据块大小和副本系数都是可配置的。应用程序可以指定某个文件的副本数目。副本系数可以在文件创建的时候指定，也可以在之后改变。HDFS中的文件都是一次性写入的，并且严格要求在任何时候只能有一个写入者。

Namenode全权管理数据块的复制，它周期性地从集群中的每个Datanode接收心跳信号和块状态报告(Blockreport)。接收到心跳信号意味着该Datanode节点工作正常。块状态报告包含了一个该Datanode上所有数据块的列表。

副本存放: 最最开始的一步

副本的存放是HDFS可靠性和性能的关键。优化的副本存放策略是HDFS区分于其他大部分分布式文件系统的重要特性。这种特性需要做大量的调优，并需要经验的积累。HDFS采用一种称为机架感知(rack-aware)的策略来改进数据的可靠性、可用性和网络带宽的利用率。目前实现的副本存放策略只是在这个方向上的第一步。实现这个策略的短期目标是验证它在生产环境下的有效性，观察它的行为，为实现更先进的策略打下测试和研究的基础。

大型HDFS实例一般运行在跨越多个机架的计算机组成的集群上，不同机架上的两台机器之间的通讯需要经过交换机。在大多数情况下，同一个机架内的两台机器间的带宽会比不同机架的两台机器间的带宽大。

通过一个机架感知的过程，Namenode可以确定每个Datanode所属的机架id。一个简单但没有优化的策略就是将副本存放在不同的机架上。这样可以有效防止当整个机架失效时数据的丢失，并且允许读数据的时候充分利用多个机架的带宽。这种策略设置可以将副本均匀分布在集群中，有利于当组件失效情况下的负载均衡。但是，因为这种策略的一个写操作需要传输数据块到多个机架，这增加了写的代价。

在大多数情况下，副本系数是3，HDFS的存放策略是将一个副本存放在本地机架的节点上，一个副本放在同一机架的另一个节点上，最后一个副本放在不同机架的节点上。这种策略减少了机架间的数据传输，这就提高了写操作的效率。机架的错误远远比节点的错误少，所以这个策略不会影响到数据的可靠性和可用性。于此同时，因为数据块只放在两个（不是三个）不同的机架上，所以此策略减少了读取数据时需要的网络传输总带宽。在这种策略下，副本并不是均匀分布在不同的机架上。三分之一的副本在一个节点上，三分之二的副本在一个机架上，其他副本均匀分布在剩下的机架中，这一策略在不损害数据可靠性和读取性能的情况下改进了写的性能。

当前，这里介绍的默认副本存放策略正在开发的过程中。

副本选择

为了降低整体的带宽消耗和读取延时，HDFS会尽量让读取程序读取离它最近的副本。如果在读取程序的同一个机架上有一个副本，那么就读取该副本。如果一个HDFS集群跨越多个数据中心，那么客户端也将首先读本地数据中心的副本。

安全模式

Namenode启动后会进入一个称为安全模式的特殊状态。处于安全模式的Namenode是不会进行数据块的复制的。Namenode从所有的 Datanode接收心跳信号和块状态报告。块状态报告包括了某个Datanode所有的数据块列表。每个数据块都有一个指定的最小副本数。当 Namenode检测确认某个数据块的副本数目达到这个最小值，那么该数据块就会被认为是副本安全(safely replicated)的；在一定百分比（这个参数可配置）的数据块被Namenode检测确认是安全之后（加上一个额外的30秒等待时间），Namenode将退出安全模式状态。接下来它会确定还有哪些数据块的副本没有达到指定数目，并将这些数据块复制到其他Datanode上。

文件系统元数据的持久化

Namenode上保存着HDFS的名字空间。对于任何对文件系统元数据产生修改的操作，Namenode都会使用一种称为EditLog的事务日志记录下来。例如，在HDFS中创建一个文件，Namenode就会在Editlog中插入一条记录来表示；同样地，修改文件的副本系数也将往Editlog插入一条记录。Namenode在本地操作系统的文件系统中存储这个Editlog。整个文件系统的名字空间，包括数据块到文件的映射、文件的属性等，都存储在一个称为FsImage的文件中，这个文件也是放在Namenode所在的本地文件系统上。

Namenode在内存中保存着整个文件系统的名字空间和文件数据块映射(Blockmap)的映像。这个关键的元数据结构设计得很紧凑，因而一个有4G 内存的Namenode足够支撑大量的文件和目录。当Namenode启动时，它从硬盘中读取Editlog和FsImage，将所有Editlog中的事务作用在内存中的FsImage上，并将这个新版本的FsImage从内存中保存到本地磁盘上，然后删除旧的Editlog，因为这个旧的 Editlog的事务都已经作用在FsImage上了。这个过程称为一个检查点(checkpoint)。在当前实现中，检查点只发生在Namenode 启动时，在不久的将来将实现支持周期性的检查点。

Datanode将HDFS数据以文件的形式存储在本地的文件系统中，它并不知道有关HDFS文件的信息。它把每个HDFS数据块存储在本地文件系统的一个单独的文件中。Datanode并不在同一个目录创建所有的文件，实际上，它用试探的方法来确定每个目录的最佳文件数目，并且在适当的时候创建子目录。在同一个目录中创建所有的本地文件并不是最优的选择，这是因为本地文件系统可能无法高效地在单个目录中支持大量的文件。当一个Datanode启动时，它会扫描本地文件系统，产生一个这些本地文件对应的所有HDFS数据块的列表，然后作为报告发送到Namenode，这个报告就是块状态报告。

通讯协议

所有的HDFS通讯协议都是建立在TCP/IP协议之上。客户端通过一个可配置的TCP端口连接到Namenode，通过ClientProtocol协议与Namenode交互。而Datanode使用DatanodeProtocol协议与Namenode交互。一个远程过程调用(RPC)模型被抽象出来封装ClientProtocol和Datanodeprotocol协议。在设计上，Namenode不会主动发起RPC，而是响应来自客户端或 Datanode 的RPC请求。

健壮性

HDFS的主要目标就是即使在出错的情况下也要保证数据存储的可靠性。常见的三种出错情况是：Namenode出错, Datanode出错和网络割裂(network partitions)。

磁盘数据错误，心跳检测和重新复制

每个Datanode节点周期性地向Namenode发送心跳信号。网络割裂可能导致一部分Datanode跟Namenode失去联系。 Namenode通过心跳信号的缺失来检测这一情况，并将这些近期不再发送心跳信号Datanode标记为宕机，不会再将新的IO请求发给它们。任何存储在宕机Datanode上的数据将不再有效。Datanode的宕机可能会引起一些数据块的副本系数低于指定值，Namenode不断地检测这些需要复制的数据块，一旦发现就启动复制操作。在下列情况下，可能需要重新复制：某个Datanode节点失效，某个副本遭到损坏，Datanode上的硬盘错误，或者文件的副本系数增大。

集群均衡

HDFS的架构支持数据均衡策略。如果某个Datanode节点上的空闲空间低于特定的临界点，按照均衡策略系统就会自动地将数据从这个Datanode 移动到其他空闲的Datanode。当对某个文件的请求突然增加，那么也可能启动一个计划创建该文件新的副本，并且同时重新平衡集群中的其他数据。这些均衡策略目前还没有实现。

数据完整性

从某个Datanode获取的数据块有可能是损坏的，损坏可能是由Datanode的存储设备错误、网络错误或者软件bug造成的。HDFS客户端软件实现了对HDFS文件内容的校验和(checksum)检查。当客户端创建一个新的HDFS文件，会计算这个文件每个数据块的校验和，并将校验和作为一个单独的隐藏文件保存在同一个HDFS名字空间下。当客户端获取文件内容后，它会检验从Datanode获取的数据跟相应的校验和文件中的校验和是否匹配，如果不匹配，客户端可以选择从其他Datanode获取该数据块的副本。

元数据磁盘错误

FsImage和Editlog是HDFS的核心数据结构。如果这些文件损坏了，整个HDFS实例都将失效。因而，Namenode可以配置成支持维护多个FsImage和Editlog的副本。任何对FsImage或者Editlog的修改，都将同步到它们的副本上。这种多副本的同步操作可能会降低 Namenode每秒处理的名字空间事务数量。然而这个代价是可以接受的，因为即使HDFS的应用是数据密集的，它们也非元数据密集的。当 Namenode重启的时候，它会选取最近的完整的FsImage和Editlog来使用。

Namenode是HDFS集群中的单点故障(single point of failure)所在。如果Namenode机器故障，是需要手工干预的。目前，自动重启或在另一台机器上做Namenode故障转移的功能还没实现。

快照

快照支持某一特定时刻的数据的复制备份。利用快照，可以让HDFS在数据损坏时恢复到过去一个已知正确的时间点。HDFS目前还不支持快照功能，但计划在将来的版本进行支持。

数据组织

数据块

HDFS被设计成支持大文件，适用HDFS的是那些需要处理大规模的数据集的应用。这些应用都是只写入数据一次，但却读取一次或多次，并且读取速度应能满足流式读取的需要。HDFS支持文件的“一次写入多次读取”语义。一个典型的数据块大小是64MB。因而，HDFS中的文件总是按照64M被切分成不同的块，每个块尽可能地存储于不同的Datanode中。

Staging

客户端创建文件的请求其实并没有立即发送给Namenode，事实上，在刚开始阶段HDFS客户端会先将文件数据缓存到本地的一个临时文件。应用程序的写操作被透明地重定向到这个临时文件。当这个临时文件累积的数据量超过一个数据块的大小，客户端才会联系Namenode。Namenode将文件名插入文件系统的层次结构中，并且分配一个数据块给它。然后返回Datanode的标识符和目标数据块给客户端。接着客户端将这块数据从本地临时文件上传到指定的 Datanode上。当文件关闭时，在临时文件中剩余的没有上传的数据也会传输到指定的Datanode上。然后客户端告诉Namenode文件已经关闭。此时Namenode才将文件创建操作提交到日志里进行存储。如果Namenode在文件关闭前宕机了，则该文件将丢失。

上述方法是对在HDFS上运行的目标应用进行认真考虑后得到的结果。这些应用需要进行文件的流式写入。如果不采用客户端缓存，由于网络速度和网络堵塞会对吞估量造成比较大的影响。这种方法并不是没有先例的，早期的文件系统，比如AFS，就用客户端缓存来提高性能。为了达到更高的数据上传效率，已经放松了POSIX标准的要求。

流水线复制

当客户端向HDFS文件写入数据的时候，一开始是写到本地临时文件中。假设该文件的副本系数设置为3，当本地临时文件累积到一个数据块的大小时，客户端会从Namenode获取一个Datanode列表用于存放副本。然后客户端开始向第一个Datanode传输数据，第一个Datanode一小部分一小部分(4 KB)地接收数据，将每一部分写入本地仓库，并同时传输该部分到列表中第二个Datanode节点。第二个Datanode也是这样，一小部分一小部分地接收数据，写入本地仓库，并同时传给第三个Datanode。最后，第三个Datanode接收数据并存储在本地。因此，Datanode能流水线式地从前一个节点接收数据，并在同时转发给下一个节点，数据以流水线的方式从前一个Datanode复制到下一个。

可访问性

HDFS给应用提供了多种访问方式。用户可以通过Java API接口访问，也可以通过C语言的封装API访问，还可以通过浏览器的方式访问HDFS中的文件。通过WebDAV协议访问的方式正在开发中。

DFSShell

HDFS以文件和目录的形式组织用户数据。它提供了一个命令行的接口(DFSShell)让用户与HDFS中的数据进行交互。命令的语法和用户熟悉的其他shell(例如 bash, csh)工具类似。下面是一些动作/命令的示例：

动作	命令
创建一个名为/foodir的目录	bin/hadoop dfs -mkdir /foodir
创建一个名为/foodir的目录	bin/hadoop dfs -mkdir /foodir
查看名为/foodir/myfile.txt的文件内容	bin/hadoop dfs -cat /foodir/myfile.txt

DFSShell 可以用在那些通过脚本语言和文件系统进行交互的应用程序上。

DFSAdmin

DFSAdmin 命令用来管理HDFS集群。这些命令只有HDSF的管理员才能使用。下面是一些动作/命令的示例：

动作	命令
将集群置于安全模式	bin/hadoop dfsadmin -safemode enter
显示Datanode列表	bin/hadoop dfsadmin -report
使Datanode节点datanodename退役	bin/hadoop dfsadmin -decommission datanodename

浏览器接口

一个典型的HDFS安装会在一个可配置的TCP端口开启一个Web服务器用于暴露HDFS的名字空间。用户可以用浏览器来浏览HDFS的名字空间和查看文件的内容。

存储空间回收

文件的删除和恢复

当用户或应用程序删除某个文件时，这个文件并没有立刻从HDFS中删除。实际上，HDFS会将这个文件重命名转移到/trash目录。只要文件还在/trash目录中，该文件就可以被迅速地恢复。文件在/trash中保存的时间是可配置的，当超过这个时间时，Namenode就会将该文件从名字空间中删除。删除文件会使得该文件相关的数据块被释放。注意，从用户删除文件到HDFS空闲空间的增加之间会有一定时间的延迟。

只要被删除的文件还在/trash目录中，用户就可以恢复这个文件。如果用户想恢复被删除的文件，他/她可以浏览/trash目录找回该文件。/trash目录仅仅保存被删除文件的最后副本。/trash目录与其他的目录没有什么区别，除了一点：在该目录上HDFS会应用一个特殊策略来自动删除文件。目前的默认策略是删除/trash中保留时间超过6小时的文件。将来，这个策略可以通过一个被良好定义的接口配置。

减少副本系数

当一个文件的副本系数被减小后，Namenode会选择过剩的副本删除。下次心跳检测时会将该信息传递给Datanode。Datanode遂即移除相应的数据块，集群中的空闲空间加大。同样，在调用setReplicationAPI结束和集群中空闲空间增加间会有一定的延迟。

参考资料

HDFS Java API:http://hadoop.apache.org/core/docs/current/api/

HDFS 源代码:http://hadoop.apache.org/core/version_control.html

posted @ 2011-08-24 12:59 jadmin 阅读(128) | 评论 (0) | 编辑收藏

php验证email拼写的正确性

function is_email($email) {
       $exp = "^[a-z'0-9]+([._-][a-z'0-9]+)*@([a-z0-9]+([._-][a-z0-9]+))+$";
       if(eregi($exp,$email)) {
           return true;
       }
       return false;
}

posted @ 2011-08-22 19:37 jadmin 阅读(98) | 评论 (0) | 编辑收藏

php去掉字符串前后的引号

posted @ 2011-08-22 19:36 jadmin 阅读(424) | 评论 (0) | 编辑收藏

PHP判断字符串是中文还是英文

posted @ 2011-08-22 10:14 jadmin 阅读(216) | 评论 (0) | 编辑收藏

DML、DDL、DCL区别

DML（data manipulation language）：
       它们是SELECT、UPDATE、INSERT、DELETE，就象它的名字一样，这4条命令是用来对数据库里的数据进行操作的语言
DDL（data definition language）：
       DDL比DML要多，主要的命令有CREATE、ALTER、DROP等，DDL主要是用在定义或改变表（TABLE）的结构，数据类型，表之间的链接和约束等初始化工作上，他们大多在建立表时使用
DCL（Data Control Language）：
       是数据库控制功能。是用来设置或更改数据库用户或角色权限的语句，包括（grant,deny,revoke等）语句。在默认状态下，只有sysadmin,dbcreator,db_owner或db_securityadmin等人员才有权力执行DCL

详细解释：
一、DDL is Data Definition Language statements. Some examples:数据定义语言，用于定义和管理 SQL 数据库中的所有对象的语言
      1.CREATE - to create objects in the database   创建
      2.ALTER - alters the structure of the database   修改
      3.DROP - delete objects from the database   删除
      4.TRUNCATE - remove all records from a table, including all spaces allocated for the records are removed
      TRUNCATE TABLE [Table Name]。
　　下面是对Truncate语句在MSSQLServer2000中用法和原理的说明：
　　Truncate table 表名速度快,而且效率高,因为:
　　TRUNCATE TABLE 在功能上与不带 WHERE 子句的 DELETE 语句相同：二者均删除表中的全部行。但 TRUNCATE TABLE 比 DELETE 速度快，且使用的系统和事务日志资源少。
　　DELETE 语句每次删除一行，并在事务日志中为所删除的每行记录一项。TRUNCATE TABLE 通过释放存储表数据所用的数据页来删除数据，并且只在事务日志中记录页的释放。
　　TRUNCATE TABLE 删除表中的所有行，但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。如果想保留标识计数值，请改用 DELETE。如果要删除表定义及其数据，请使用 DROP TABLE 语句。
　　对于由 FOREIGN KEY 约束引用的表，不能使用 TRUNCATE TABLE，而应使用不带 WHERE 子句的 DELETE 语句。由于 TRUNCATE TABLE 不记录在日志中，所以它不能激活触发器。
　　TRUNCATE TABLE 不能用于参与了索引视图的表。
       5.COMMENT - add comments to the data dictionary 注释
       6.GRANT - gives user's access privileges to database 授权
       7.REVOKE - withdraw access privileges given with the GRANT command   收回已经授予的权限

二、DML is Data Manipulation Language statements. Some examples:数据操作语言，SQL中处理数据等操作统称为数据操纵语言
       1.SELECT - retrieve data from the a database           查询
       2.INSERT - insert data into a table                    添加
       3.UPDATE - updates existing data within a table    更新
       4.DELETE - deletes all records from a table, the space for the records remain   删除
       5.CALL - call a PL/SQL or Java subprogram
       6.EXPLAIN PLAN - explain access path to data
       Oracle RDBMS执行每一条SQL语句，都必须经过Oracle优化器的评估。所以，了解优化器是如何选择(搜索)路径以及索引是如何被使用的，对优化SQL语句有很大的帮助。Explain可以用来迅速方便地查出对于给定SQL语句中的查询数据是如何得到的即搜索路径(我们通常称为Access Path)。从而使我们选择最优的查询方式达到最大的优化效果。
       7.LOCK TABLE - control concurrency 锁，用于控制并发

三、DCL is Data Control Language statements. Some examples:数据控制语言，用来授予或回收访问数据库的某种特权，并控制数据库操纵事务发生的时间及效果，对数据库实行监视等
       1.COMMIT - save work done 提交
       2.SAVEPOINT - identify a point in a transaction to which you can later roll back 保存点
       3.ROLLBACK - restore database to original since the last COMMIT   回滚
       4.SET TRANSACTION - Change transaction options like what rollback segment to use   设置当前事务的特性，它对后面的事务没有影响．

posted @ 2011-08-17 19:40 jadmin 阅读(106) | 评论 (0) | 编辑收藏

Eclipse启动莫名报错处理

今天启动Eclipse时，弹出错误提示：

解决办法：将Eclipse下的eclipse.ini文件做如下改动

posted @ 2011-08-16 17:09 jadmin 阅读(105) | 评论 (0) | 编辑收藏

MySQL海量数据查询优化策略

1.对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。

2.应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：

　　select id from t where num is null

　　可以在num上设置默认值0，确保表中num列没有null值，然后这样查询：

　　select id from t where num=0

3.应尽量避免在 where 子句中使用!=或<>操作符，否则将引擎放弃使用索引而进行全表扫描。

4.应尽量避免在 where 子句中使用 or 来连接条件，否则将导致引擎放弃使用索引而进行全表扫描，如：

　　select id from t where num=10 or num=20

　　可以这样查询：

　　select id from t where num=10

　　union all

　　select id from t where num=20

5.in 和 not in 也要慎用，否则会导致全表扫描，如：

　　select id from t where num in(1,2,3)

　　对于连续的数值，能用 between 就不要用 in 了：

　　select id from t where num between 1 and 3

6.下面的查询也将导致全表扫描：

　　select id from t where name like '%abc%'

　　若要提高效率，可以考虑全文检索。

7.如果在 where 子句中使用参数，也会导致全表扫描。因为SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然而，如果在编译时建立访问计划，变量的值还是未知的，因而无法作为索引选择的输入项。如下面语句将进行全表扫描：

　　select id from t where num=@num

　　可以改为强制查询使用索引：

　　select id from t with(index(索引名)) where num=@num

8.应尽量避免在 where 子句中对字段进行表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：

　　select id from t where num/2=100

　　应改为:

　　select id from t where num=100*2

9.应尽量避免在where子句中对字段进行函数操作，这将导致引擎放弃使用索引而进行全表扫描。如：

　　select id from t where substring(name,1,3)='abc'--name以abc开头的id

　　select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id

　　应改为:

　　select id from t where name like 'abc%'

　　select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

10.不要在 where 子句中的“=”左边进行函数、算术运算或其他表达式运算，否则系统将可能无法正确使用索引。

11.在使用索引字段作为条件时，如果该索引是复合索引，那么必须使用到该索引中的第一个字段作为条件时才能保证系统使用该索引，否则该索引将不会被使用，并且应尽可能的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如需要生成一个空表结构：

　　select col1,col2 into #t from t where 1=0

　　这类代码不会返回任何结果集，但是会消耗系统资源的，应改成这样：

　　create table #t(...)

13.很多时候用 exists 代替 in 是一个好的选择：

　　select num from a where num in(select num from b)

　　用下面的语句替换：

　　select num from a where exists(select 1 from b where num=a.num)

14.并不是所有索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即使在sex上建了索引也对查询效

率起不了作用。

15.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。

16.应尽可能的避免更新 clustered 索引数据列，因为 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将导致整个表记录的顺序的调整，会耗费相当大的资源。若应用系统需要频繁更新 clustered 索引数据列，那么需要考虑是否应将该索引建为 clustered 索引。

17.尽量使用数字型字段，若只含数值信息的字段尽量不要设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

18.尽可能的使用 varchar/nvarchar 代替 char/nchar ，因为首先变长字段存储空间小，可以节省存储空间，其次对于查询来说，在一个相对较小的字段内搜索效率显然要高些。

19.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

20.尽量使用表变量来代替临时表。如果表变量包含大量数据，请注意索引非常有限（只有主键索引）。

21.避免频繁创建和删除临时表，以减少系统表资源的消耗。

22.临时表并不是不可使用，适当地使用它们可以使某些例程更有效，例如，当需要重复引用大型表或常用表中的某个数据集时。但是，对于一次性事件，最好使用导出表。

23.在新建临时表时，如果一次性插入数据量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果数据量不大，为了缓和系统表的资源，应先create table，然后insert。

24.如果使用到了临时表，在存储过程的最后务必将所有的临时表显式删除，先 truncate table ，然后 drop table ，这样可以避免系统表的较长时间锁定。

25.尽量避免使用游标，因为游标的效率较差，如果游标操作的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法之前，应先寻找基于集的解决方案来解决问题，基于集的方法通常更有效。

27.与临时表一样，游标并不是不可使用。对小型数据集使用 FAST_FORWARD 游标通常要优于其他逐行处理方法，尤其是在必须引用几个表才能获得所需的数据时。在结果集中包括“合计”的例程通常要比使用游标执行的速度快。如果开发时间允许，基于游标的方法和基于集的方法都可以尝试一下，看哪一种方法的效果更好。

28.在所有的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每个语句后向客户端发送 DONE_IN_PROC 消息。

29.尽量避免大事务操作，提高系统并发能力。

30.尽量避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理。

> sql优化方法

1、使用索引来更快地遍历表。

　　缺省情况下建立的索引是非群集索引，但有时它并不是最佳的。在非群集索引下，数据在物理上随机存放在数据页上。合理的索引设计要建立在对各种查询的分析和预测上。一般来说：

　　a.有大量重复值、且经常有范围查询( > ,< ，> =,< =)和order by、group by发生的列，可考虑建立群集索引;

　　b.经常同时存取多列，且每列都含有重复值可考虑建立组合索引;

　　c.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。索引虽有助于提高性能但不是索引越多越好，恰好相反过多的索引会导致系统低效。用户在表中每加进一个索引，维护索引集合就要做相应的更新工作。

2、在海量查询时尽量少用格式转换。

3、ORDER BY和GROPU BY：使用ORDER BY和GROUP BY短语，任何一种索引都有助于SELECT的性能提高。

4、任何对列的操作都将导致表扫描，它包括数据库教程函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

5、IN、OR子句常会使用工作表，使索引失效。如果不产生大量重复值，可以考虑把子句拆开。拆开的子句中应该包含索引。

6、只要能满足你的需求，应尽可能使用更小的数据类型：例如使用MEDIUMINT代替INT

7、尽量把所有的列设置为NOT NULL，如果你要保存NULL，手动去设置它，而不是把它设为默认值。

8、尽量少用VARCHAR、TEXT、BLOB类型

9、如果你的数据只有你所知的少量的几个。最好使用ENUM类型

10、正如graymice所讲的那样，建立索引。

posted @ 2011-08-13 15:50 jadmin 阅读(115) | 评论 (0) | 编辑收藏

MySQL数据库LIMIT查询优化策略

SELECT * FROM table LIMIT [offset,] rows | rows OFFSET offset

LIMIT子句可以被用于强制SELECT语句返回指定的记录数。LIMIT接受一个或两个数字参数，参数必须是一个整数常量。
如果给定两个参数，第一个参数指定第一个返回记录行的偏移量，第二个参数指定返回记录行的最大数目。
初始记录行的偏移量是0(而不是1)：为了与 PostgreSQL 兼容，MySQL 也支持句法： LIMIT # OFFSET #。

mysql> SELECT * FROM table LIMIT 5, 10; // 检索记录行 6-15

//为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：
mysql> SELECT * FROM table LIMIT 95, -1; // 检索记录行 96-last.

//如果只给定一个参数，它表示返回最大的记录行数目：
mysql> SELECT * FROM table LIMIT 5; //检索前 5 个记录行

//换句话说，LIMIT n 等价于 LIMIT 0,n。

sql-1.
SELECT * FROM table WHERE id >= (
    SELECT MAX(id) FROM (
       SELECT id FROM table ORDER BY id limit 90001
    ) AS tmp
) limit 100;

sql-2.
SELECT * FROM table WHERE id >= (
    SELECT MAX(id) FROM (
       SELECT id FROM table ORDER BY id limit 90000, 1
    ) AS tmp
) limit 100;

同样是取90000条后100条记录,第1句快还是第2句快?
第1句是先取了前90001条记录,取其中最大一个id值作为起始标识,然后利用它可以快速定位下100条记录
第2句择是仅仅取90000条记录后1条,然后取id值作起始标识定位下100条记录
第1句执行结果.100 rows in set (0.23) sec
第2句执行结果.100 rows in set (0.19) sec

很明显第2句胜出.看来limit好像并不完全像我之前想象的那样做全表扫描返回limit offset+length条记录,
这样看来limit比起MS-SQL的Top性能还是要提高不少的.

其实sql-2完全可以简化成：

SELECT * FROM table WHERE id >= (
SELECT id FROM table limit 90000, 1
) limit 100;

直接利用第90000条记录的id,不用经过MAX函数运算,这样做理论上效率因该高一些,但在实际使用中几乎看不到效果,
因为本身定位id返回的就是1条记录,MAX几乎不用运作就能得到结果,但这样写更清淅明朗,省去了画蛇那一足.

可是,既然MySQL有limit可以直接控制取出记录的位置,为什么不干脆用SELECT id FROM table limit 90000, 1呢?岂不更简洁?

posted @ 2011-08-13 15:47 jadmin 阅读(116) | 评论 (0) | 编辑收藏

MySQL优化配置

tmp_table_size = 500mb //临时表大小设置

//指定用于索引的缓冲区大小，增加它可得到更好的索引处理性能。
//对于内存在4GB左右的服务器该参数可设置为256M或384M。
//注意：该参数值设置的过大反而会是服务器整体效率降低！
key_buffer_size = 384m

sort_buffer_size = 17mb //排序缓存

read_buffer_size=4m //读取缓存

table_cache=256 //表缓存

ft_min_word_len //全文搜索

query_cache_size 查询缓存

<?
#!/bin/sh
#######检查mysql状态
PORT=`netstat -na | grep "LISTEN" | grep "3306" | awk '{print $4}' | awk -F. '{print $2}'`
if [ "$PORT" -eq "3306" ]
        then
#######检查mysql占CPU负载
        mysql_cpu=`top -U root -b -n 1 | grep mysql | awk '{print $10}'|awk -F. '{print $1}'`
##如果mysql cpu负载大于80，则重启mysql
        if [ "$mysql_cpu" -ge "80" ]
                then
                ps xww |grep 'bin/mysqld_safe' |grep -v grep | awk '{print $1}' | xargs kill -9
                ps xww |grep 'libexec/mysqld' |grep -v grep | awk '{print $1}' | xargs kill -9
                sleep 5
                /usr/local/mysql/bin/mysqld_safe --user=root > /dev/null &
        else
                exit 0
        fi
else
         /usr/local/mysql/bin/mysqld_safe --user=root > /dev/null &
fi
?>

影响列数： 4999 (查询花费 0.1756 秒)
UPDATE `jobs_faces` SET postime = '1250784000' WHERE jid <505000 AND jid >500000

jobs_faces字段
字段类型整理属性 Null 默认额外操作
jid int(10)   UNSIGNED 否 auto_increment
oid int(10)   UNSIGNED 否 0
cid mediumint(8)   UNSIGNED 否 0
requests smallint(4)   UNSIGNED 否 0
views mediumint(6)   UNSIGNED 是 0
checked tinyint(1)   UNSIGNED 否 0
istoped tinyint(1)   UNSIGNED 否 0
postime int(10)   UNSIGNED 否 0
losetime int(10)   UNSIGNED 否 0
toped tinyint(1)   UNSIGNED 否 0
toptime int(10)   UNSIGNED 否 0
bold tinyint(1)   UNSIGNED 否 0
highlight varchar(7) gbk_chinese_ci 否
lightime int(10)   UNSIGNED 否 0
people smallint(4)   UNSIGNED 否 0
sex tinyint(1)   UNSIGNED 否 0
djobskinds varchar(30) gbk_chinese_ci 否
jname varchar(60) gbk_chinese_ci 否

影响列数： 4999 (查询花费 0.2393 秒)
UPDATE `jobs_faces` SET postime = '1250784000' WHERE jid <455000 AND jid >450000

posted @ 2011-08-13 15:45 jadmin 阅读(115) | 评论 (0) | 编辑收藏

PHP判断字符串的编码

注意：要把php.ini中 extension=php_mbstring.dll 前的;号去掉，重启apache就可以了。
我创建三个文件：text1.txt text2.txt text3.txt
分别以ASCII UTF-8 UNICODE 的编码方式保存

<?php
define ('UTF32_BIG_ENDIAN_BOM', chr(0x00) . chr(0x00) . chr(0xFE) . chr(0xFF));
define ('UTF32_LITTLE_ENDIAN_BOM', chr(0xFF) . chr(0xFE) . chr(0x00) . chr(0x00));
define ('UTF16_BIG_ENDIAN_BOM', chr(0xFE) . chr(0xFF));
define ('UTF16_LITTLE_ENDIAN_BOM', chr(0xFF) . chr(0xFE));
define ('UTF8_BOM', chr(0xEF) . chr(0xBB) . chr(0xBF));

function detect_utf_encoding($text) {
    $first2 = substr($text, 0, 2);
    $first3 = substr($text, 0, 3);
    $first4 = substr($text, 0, 3);

    if ($first3 == UTF8_BOM) return 'UTF-8';
    elseif ($first4 == UTF32_BIG_ENDIAN_BOM) return 'UTF-32BE';
    elseif ($first4 == UTF32_LITTLE_ENDIAN_BOM) return 'UTF-32LE';
    elseif ($first2 == UTF16_BIG_ENDIAN_BOM) return 'UTF-16BE';
    elseif ($first2 == UTF16_LITTLE_ENDIAN_BOM) return 'UTF-16LE';
}

function getFileEncoding($str){
    $encoding=mb_detect_encoding($str);
    if(empty($encoding)){
        $encoding=detect_utf_encoding($str);
    }
    return $encoding;
}

$file = 'text1.txt';
echo getFileEncoding(file_get_contents($file)); // 输出ASCII
echo '<br />';

$file = 'text2.txt';
echo getFileEncoding(file_get_contents($file)); // 输出UTF-8
echo '<br />';

$file = 'text3.txt';
echo getFileEncoding(file_get_contents($file)); // 输出UTF-16LE
echo '<br />';
?>

posted @ 2011-08-12 20:16 jadmin 阅读(160) | 评论 (0) | 编辑收藏

Windows环境zip版PostgreSQL数据库安装

1. 下载PostgreSQL数据库zip版本

2. 解压到D盘，例如：D:\database\postgresql

3. cmd窗口进入D:\database\postgresq\bin，依次执行如下命令：
set PGHOME=D:\database\postgresq
set PGDATA=%PGHOME%\data
set PGLIB=%PGHOME%\lib
set PGHOST=localhost
set PATH=%PGHOME%\bin;%PATH%

4. 添加用户

> 添加windows用户，用于启动PostgreSQL的windows服务

D:\database\postgresql>net user postgres pgsqlpw /add /expires:never /passwordchg:no

> 为保证安全，此用户不允许本地登录
D:\database\postgresql>net localgroup users postgres /del

> 赋于windows用户postgres访问PostgreSQL安装目录的权限
D:\database\postgresql>cacls . /T /E /P postgres:R

5. 初始化数据库

> 切换到windows用户postgres的命令行环境
D:\database\postgresql>runas /noprofile /env /user:postgres "cmd"

> 初始化数据库,若不使用-U admin,则数据库里自动添加当前windows用户(即postgres)为数据库帐号
D:\database\postgresql>bin\initdb -D "D:\database\postgresql\data" -E UTF-8 --locale=chs -A md5 -U admin -W

6. 启动PostgreSQL服务：
pg_ctl -D D:\database\postgresql\data -l D:\database\postgresql\pglog.txt start

7. 创建并连接数据库：
createdb test
psql -h localhost -w -d test

8. 关闭PostgreSQL服务：
pg_ctl -D D:\database\postgresql\data stop

9. 注册为Windows服务：

> 注册为windows服务,当前windows用户(即postgres)将作为PostgreSQL服务的登录用户
D:\pgsql>bin\pg_ctl register -N PostgreSQL -D “D:\database\postgresql\data”

> 启动PostgreSQL服务
D:\pgsql> sc start PostgreSQL

posted @ 2011-08-11 20:46 jadmin 阅读(230) | 评论 (0) | 编辑收藏

PostgreSQL数据库uuid函数

postgres=# select uuid_generate_v1();
uuid_generate_v1
--------------------------------------
86811bd4-22a5-11df-b00e-ebd863f5f8a7
(1 row)

postgres=# select uuid_generate_v4();
uuid_generate_v4
--------------------------------------
5edbfcbb-1df8-48fa-853f-7917e4e346db
(1 row)

主要就是uuid_generate_v1和uuid_generate_v4，当然还有uuid_generate_v3和uuid_generate_v5。

其他使用可以参见PostgreSQL官方文档 http://www.postgresql.org/docs/8.3/static/uuid-ossp.html

posted @ 2011-08-05 18:20 jadmin 阅读(586) | 评论 (0) | 编辑收藏

Memcache

> memcache介绍
Memcached是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提供动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。但是它并不提供冗余（例如，复制其hashmap条目）；当某个服务器S停止运行或崩溃了，所有存放在S上的键/值对都将丢失。

Memcached官方：http://danga.com/memcached/

> memcache下载安装
下载Windows的Server端，下载地址：http://code.jellycan.com/memcached/

安装Memcache Server(也可以不安装直接启动)
1. 下载memcached的windows稳定版，解压放某个盘下面，比如在c:\memcached
2. 在CMD下输入 "c:\memcached\memcached.exe -d install" 安装.
3. 再输入："c:\memcached\memcached.exe -d start" 启动。NOTE: 以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

如果下载的是二进制的版本，直接运行就可以了，可以加上参数来加以设置。

常用设置：
-p <num>          监听的端口
-l <ip_addr>      连接的IP地址, 默认是本机
-d start          启动memcached服务
-d restart        重起memcached服务
-d stop|shutdown 关闭正在运行的memcached服务
-d install        安装memcached服务
-d uninstall      卸载memcached服务
-u <username>     以<username>的身份运行 (仅在以root运行的时候有效)
-m <num>          最大内存使用，单位MB。默认64MB
-M                内存耗尽时返回错误，而不是删除项
-c <num>          最大同时连接数，默认是1024
-f <factor>       块大小增长因子，默认是1.25
-n <bytes>        最小分配空间，key+value+flags默认是48
-h                显示帮助

然后就可以用java的memcached客户端来试一下了。

posted @ 2011-08-01 10:41 jadmin 阅读(92) | 评论 (0) | 编辑收藏

php常用函数

1 echo()
可以同时输出多个字符串,可以多个参数,并不需要圆括号,无返回值。

2 print()
只可以同时输出一个字符串，一个参数,需要圆括号,有返回值,当其执行失败时返flase .    print 的用法和C语言很像，所以会对输出内容里的%做特殊解释。
$a=print('hi');
echo $a;
//----------------------------
hi 1   //1是$a的值。
//-----------------------------

3 die();  // 和exit()区别。
有两个功能：先输出内容，然后退出程序。（常用在链接服务器，数据库）
mysql_connect("locahost","root","root") or die("链接服务器失败！");

4 printf();    //f指format格式化
printf("参数1",参数2)：
参数1=按什么格式输出；参数2=输出的变量。
(%s:按字符串;%d:按整型;%b:按二进制；%x:按16进制；%X：按16进制大写输出；%o:按八进制; %f:按浮点型)

对于参数1，其格式如下：
%[ 'padding_character][-][width][.precision]type

说明：
所有转换都以%开头，如果想打印一个%，则必须用“%%”；
参数padding_character是可选的，用来填充变量直至指定的宽度，如：printf ("$%'a10.2f" , 43.2); //$aaaaa43.20，默认是填充一个空格，如果指定了一个空格或0就不需要使用“'”做为前缀。对于任何其它前缀则必须指定单引号。
【-】是可选的，添加它则表明数据应该左对齐。而不是默认的右对齐，如上例加一个-则为：printf ("$%'a-10.2f" , 43.2); //$43.20aaaaa
whidth 表示在这里为将被替换的变量留下多少空间（按字符计算）。如上例的10(包括小数点).
precision则必须是一个小数点开始，表示小数位后面要显示的位数。

函数，返回输出字符个数，把文字格式化以后输出，如：

printf ("$%01.2f" , 43.2); //$43.20

$表示填充的字符

0表示位数不够在不影响原值的情况下补0
1表示输出的总宽度
2表示小数位数，有四舍五入

%f 是表示显示为一个浮点数

格式化命令及说明：

%% 印出百分比符号，不转换。
%b 整数转成二进位。
%c 整数转成对应的 ASCII 字符。如：printf ("$%c" , 65); // 输出：A
%d 整数转成十进位。如：printf ("$%d" , 65.53); // 输出：65
%f 倍精确度数字转成浮点数。
%o 整数转成八进位。
%s 整数转成字符串。
%x 整数转成小写十六进位。
%X 整数转成大写十六进位

对于printf(),还可以使用带序号并以$符号结束的参数方式来指定参数转换的顺序。如：
printf ("the total is $%2$.2f and subtotal: %1$.2f" , 65.55,37.2); //the total is $37.20 and subtotal: 65.55
如上：%2$.2f指定了使用第二个参数65.55，%1$.2f则指定用第一个参数37.20。

   <?php
     $num=100.001;
     printf("%d",$num); //100
     printf("%s",$num); //100.001
     printf("%s---%d---%b---%x---%o---%f",$num,$num,$num,$num,$num,$num)
     //100.001---100---1100100---64---144---1001.00100
     printf("%.2f",$num); //100.00 (小数点保留2位)
     printf("%.1f",$num); //100.0 (小数点保留1位)
     printf("%`#10s",$num); // #10s
     printf("%#10s",$num); //10s
   ?>

5 sprintf();
此并不能直接输出,先赋给一个变量，然后再输出变量。
<?php
$num=100.001;
$a=sprintf("%d",$num);
echo $a; //100
?>

6 print_r();
功能：只用于输出数组。
$a = array (1, 2, array ("a", "b", "c"));
print_r ($a);

返回：
Array ( [0] => 1 [1] => 2 [2] => Array ( [0] => a [1] => b [2] => c ) )

7 var_dump();
功能: 输出变量的内容，类型或字符串的内容，类型，长度。常用来调试。
<?php
$a=100;
var_dump($a); //int(100)

$a=100.356;
var_dump($a); //float(100.356)
?>

8.var_export ();
返回关于传递给该函数的变量的结构信息，它和 var_dump() 类似，不同的是其返回的表示是合法的 PHP 代码。
您可以通过将函数的第二个参数设置为 TRUE，从而返回变量的值。
<?php
$a = array (1, 2, array ("a", "b", "c"));
var_export ($a);
/* 输出：
array (
0 => 1,
1 => 2,
2 =>
array (
   0 => 'a',
   1 => 'b',
   2 => 'c',
),
)
*/

$b = 3.1;
$v = var_export($b, TRUE);
echo $v;
/* 输出：
3.1
*/
?>

posted @ 2011-07-26 10:09 jadmin 阅读(78) | 评论 (0) | 编辑收藏

mb_convert_encoding与iconv函数

mb_convert_encoding这个函数是用来转换编码的。原来一直对程序编码这一概念不理解，不过现在好像有点开窍了。
不过英文一般不会存在编码问题，只有中文数据才会有这个问题。比如你用Zend Studio或Editplus写程序时，用的是gbk编码，如果数据需要入数据库，而数据库的编码为utf8时，这时就要把数据进行编码转换，不然进到数据库就会变成乱码。

mb_convert_encoding的用法见官方：
http://cn.php.net/manual/zh/function.mb-convert-encoding.php

做一个GBK To UTF-8
< ?php
header("content-Type: text/html; charset=Utf-8");
echo mb_convert_encoding("妳係我的友仔", "UTF-8", "GBK");
?>

再来个GB2312 To Big5
< ?php
header("content-Type: text/html; charset=big5");
echo mb_convert_encoding("你是我的朋友", "big5", "GB2312");
?>
不过要使用上面的函数需要安装但是需要先enable mbstring 扩展库。

PHP中的另外一个函数iconv也是用来转换字符串编码的，与上函数功能相似。

下面还有一些详细的例子：
iconv — Convert string to requested character encoding
(PHP 4 >= 4.0.5, PHP 5)
mb_convert_encoding — Convert character encoding
(PHP 4 >= 4.0.6, PHP 5)

用法：
string mb_convert_encoding ( string str, string to_encoding [, mixed from_encoding] )
需要先enable mbstring 扩展库，在 php.ini里将; extension=php_mbstring.dll 前面的 ; 去掉
mb_convert_encoding 可以指定多种输入编码，它会根据内容自动识别,但是执行效率比iconv差太多；

string iconv ( string in_charset, string out_charset, string str )
注意：第二个参数，除了可以指定要转化到的编码以外，还可以增加两个后缀：//TRANSLIT 和 //IGNORE，其中 //TRANSLIT 会自动将不能直接转化的字符变成一个或多个近似的字符，//IGNORE 会忽略掉不能转化的字符，而默认效果是从第一个非法字符截断。
Returns the converted string or FALSE on failure.

使用：
发现iconv在转换字符”—”到gb2312时会出错，如果没有ignore参数，所有该字符后面的字符串都无法被保存。不管怎么样，这个”—”都无法转换成功，无法输出。另外mb_convert_encoding没有这个bug.

一般情况下用 iconv，只有当遇到无法确定原编码是何种编码，或者iconv转化后无法正常显示时才用mb_convert_encoding 函数.

from_encoding is specified by character code name before conversion. it can be array or string - comma separated enumerated list. If it is not specified, the internal encoding will be used.
/* Auto detect encoding from JIS, eucjp-win, sjis-win, then convert str to UCS-2LE */
$str = mb_convert_encoding($str, “UCS-2LE”, “JIS, eucjp-win, sjis-win”);
/* “auto” is expanded to “ASCII,JIS,UTF-8,EUC-JP,SJIS” */
$str = mb_convert_encoding($str, “EUC-JP”, “auto”);

例子：
$content = iconv(”GBK”, “UTF-8″, $content);
$content = mb_convert_encoding($content, “UTF-8″, “GBK”);

posted @ 2011-07-23 13:01 jadmin 阅读(96) | 评论 (0) | 编辑收藏

Eclipse的"Ctrl+鼠标左键"的智能化链接配置

选择【Window】菜单
Preferences ——>General——>Editors——>Text Editors——>Hyperlinking

posted @ 2011-07-22 10:17 jadmin 阅读(179) | 评论 (0) | 编辑收藏

php中用get方式获取网络资源内容

<?php
$photo = 'http://www.xxx.com/uploads/5908618d80559a594164d984c5ca2b01_32.png';
if ($photo) {
        $http = new HttpRequest($photo, HTTP_METH_GET);
        try {
                $http->send();
        } catch(Exception $e) {
                try {
                        $http->send();
                } catch (Exception $e) {
                        try {
                                $http->send();
                        } catch (Exception $e) {
                                echo 'error occured while loading file.';
                                exit;
                        }
                }
        }
        if ($http->getResponseCode() == 200) {
                $header = $http->getResponseHeader();
                if (strstr($header['Content-Type'], 'image') !== FALSE) {
                     echo base64_encode($http->getResponseBody());
                }
        }
}
?>

posted @ 2011-07-22 09:45 jadmin 阅读(104) | 评论 (0) | 编辑收藏

MySQL列命名问题

今天在MySQL中建立了一张表，其中一个字段是order，通过jdbc往里面插数据一直报错，好长时间找不到原因

结果把order字段的名称改成别的，居然成功插入数据，看来是MySQL字段列名不能使用insert、order等关键字

posted @ 2011-07-12 20:40 jadmin 阅读(101) | 评论 (0) | 编辑收藏

用php内置函数抓取网页数据

> 添加curl扩展

1.在C\windows里的php.ini中我打开了extension=php_curl.dll的功能

2.把php目录中的libeay32.dll,ssleay32.dll拷到c:\windows\system32里

3.重新启动Apache

> 代码

<?php
   //初始化curl
   $ch = curl_init() or die (curl_error());
   echo "Test for searching 'php' in baidu.";
   //设置URL参数
   curl_setopt($ch,CURLOPT_URL,"http://www.baidu.com/s?wd=php");
   //要求CURL返回数据
   curl_setopt($ch,CURLOPT_RETURNTRANSFER,1);
   //执行请求
   $result = curl_exec($ch) or die (curl_error());
   //取得返回的结果，并显示
   echo $result;
   echo curl_error($ch);
   //关闭CURL
   curl_close($ch);
?>

> 效果

>CURL函数库(Client URL Library Function)

curl_close — 关闭一个curl会话
curl_copy_handle — 拷贝一个curl连接资源的所有内容和参数
curl_errno — 返回一个包含当前会话错误信息的数字编号
curl_error — 返回一个包含当前会话错误信息的字符串
curl_exec — 执行一个curl会话
curl_getinfo — 获取一个curl连接资源句柄的信息
curl_init — 初始化一个curl会话
curl_multi_add_handle — 向curl批处理会话中添加单独的curl句柄资源
curl_multi_close — 关闭一个批处理句柄资源
curl_multi_exec — 解析一个curl批处理句柄
curl_multi_getcontent — 返回获取的输出的文本流
curl_multi_info_read — 获取当前解析的curl的相关传输信息
curl_multi_init — 初始化一个curl批处理句柄资源
curl_multi_remove_handle — 移除curl批处理句柄资源中的某个句柄资源
curl_multi_select — Get all the sockets associated with the cURL extension, which can then be "selected"
curl_setopt_array — 以数组的形式为一个curl设置会话参数
curl_setopt — 为一个curl设置会话参数
curl_version — 获取curl相关的版本信息

关键词：php抓取 php库函数 curl php常用函数

posted @ 2011-07-08 18:19 jadmin 阅读(109) | 评论 (0) | 编辑收藏

php格式化时间

> 函数date(format,timestamp)
format 必需。规定时间戳的格式。
timestamp 可选。规定时间戳。默认是当前的日期和时间。
<?php
echo date("Y/m/d");
echo "<br />";
echo date("Y.m.d");
echo "<br />";
echo date("Y-m-d");
?>

> 格式化当前时间

<?php echo $showtime=date("Y-m-d H:i:s");?>
显示的格式: 年-月-日小时:分钟:妙
相关时间参数:
a - "am" 或是 "pm"
A - "AM" 或是 "PM"
d - 几日，二位数字，若不足二位则前面补零; 如: "01" 至 "31"
D - 星期几，三个英文字母; 如: "Fri"
F - 月份，英文全名; 如: "January"
h - 12 小时制的小时; 如: "01" 至 "12"
H - 24 小时制的小时; 如: "00" 至 "23"
g - 12 小时制的小时，不足二位不补零; 如: "1" 至 12"
G - 24 小时制的小时，不足二位不补零; 如: "0" 至 "23"
i - 分钟; 如: "00" 至 "59"
j - 几日，二位数字，若不足二位不补零; 如: "1" 至 "31"
l - 星期几，英文全名; 如: "Friday"
m - 月份，二位数字，若不足二位则在前面补零; 如: "01" 至 "12"
n - 月份，二位数字，若不足二位则不补零; 如: "1" 至 "12"
M - 月份，三个英文字母; 如: "Jan"
s - 秒; 如: "00" 至 "59"
S - 字尾加英文序数，二个英文字母; 如: "th"，"nd"
t - 指定月份的天数; 如: "28" 至 "31"
U - 总秒数
w - 数字型的星期几，如: "0" (星期日) 至 "6" (星期六)
Y - 年，四位数字; 如: "1999"
y - 年，二位数字; 如: "99"
z - 一年中的第几天; 如: "0" 至 "365"

关键词： php学习 php教程 php格式化时间 php函数 date()

posted @ 2011-07-08 14:58 jadmin 阅读(106) | 评论 (0) | 编辑收藏

php调试工具xdebug相关参数

C:\windows\php.ini

extension=php_xdebug.dll
xdebug.profiler_enable=on
xdebug.trace_output_dir="C:/www/test/xdebug"
xdebug.profiler_output_dir="C:/www/test/xdebug"

xdebug.default_enable = On
xdebug.show_exception_trace = On // 设置为On后，即使捕捉到异常,代码行仍将强制执行异常跟踪.
xdebug.show_local_vars = 1 // 将打印每个函数调用的最外围中的所有局部变量,包括尚未初始化的变量
xdebug.max_nesting_level = 50
xdebug.var_display_max_depth = 6 // 表示转储复杂变量的深度.

xdebug.dump_once = On
xdebug.dump_globals = On

// 如果进一步将 xdebug.dump_undefined 设为 On 并且不设定指定的超全局变量,则仍用值 undefined 打印变量.
xdebug.dump_undefined = On
xdebug.dump.REQUEST = *

// 将打印 PHP 超全局变量 $_SERVER['REQUEST_METHOD']、$_SERVER['REQUEST_URI'] 和 $_SERVER['HTTP_USER_AGENT'].
xdebug.dump.SERVER = REQUEST_METHOD,REQUEST_URI,HTTP_USER_AGENT

xdebug.trace_format 设为 0则输出将符合人类阅读习惯(将参数设为 1 则为机器可读格式).
xdebug.show_mem_delta = 1 则可以查看内存使用量是在增加还是在减少,
xdebug.collect_params = 4 则可以查看传入参数的类型和值.要监视每个函数返回的值,请设定 xdebug.collect_return = 1.

PHP Warning: Xdebug MUST be loaded as a Zend extension in Unknown on line 0 出错解决

;extension=php_xdebug.dll
zend_extension_ts="C:/php/ext/php_xdebug.dll" //以zend方式加载
xdebug.profiler_enable=on
xdebug.trace_output_dir="C:/www/test/xdebug"
xdebug.profiler_output_dir="C:/www/test/xdebug"

posted @ 2011-07-07 14:31 jadmin 阅读(136) | 评论 (0) | 编辑收藏

PHP中dirname的用法

比如当前文件是放在(d:\www\)下，文件名是test.php。

<?php echo __FILE__ ; // 取得当前文件的绝对地址，结果：D:\www\test.php echo dirname(__FILE__); // 取得当前文件所在的绝对目录，结果：D:\www\ echo dirname(dirname(__FILE__)); //取得当前文件的上一层目录名，结果：D:\?>

使用方法提示,
dirname(__FILE__) 取到的是当前文件的绝对路径，也就是说，比起相对路径，查找速度是最快的。
如果重复一次可以把目录往上提升一个层次:
比如：$d = dirname(dirname(__FILE__));
其实就是把一个目录给dirname()做参数了．因为dirname()返回最后的目录不带\\或者是/
所以重复使用的时候可以认为　dirname()　把最下层的目录当成文件名来处理了．照常返回
当前目录的上级目录.这样重复就得到了它的上一级的目录.

包含得到上一级目录的文件
include(dirname(__FILE__).’/../filename.php’);

posted @ 2011-07-07 13:18 jadmin 阅读(94) | 评论 (0) | 编辑收藏

PHP运行环境搭建

本文主要介绍PHP5.2.11 + Apache2.2.19 + MySQL5.1.45的PHP集成运行环境的搭建(Windows XP SP3操作系统环境)

> 安装并配置APACHE(安装到C:\apache)

   1、安装时默认安装，Network Domain, Server Name 我填写我的计算机名，Administrator's Email Address区域填你的邮件地址
   2、安装完后在安装目录下有个conf文件夹，打开httpd.conf文件进行配置
        ·找到 DocumentRoot ，将其设置为你所要存放php, htm等网页文件的文件夹，如 "D:\phpapache\Apache2.2\htdocs"；
        ·找到 DirectoryIndex ，在index.html后添加index.php, index.htm等，以单个空格将其分开；
        ·重启Apache，用http://localhost或http://127.0.0.1或http://yourcompanyname测试是否成功。成功的话屏幕会有个It works!

> 安装配置PHP(解压PHP压缩包到C:\php)

   1、将php.ini-recommended文件重命名为php.ini并将其剪到系统所在目录下(如放在2000/NT的WINNT, XP的Windows目录下),
   2、将extension_dir 改为php/ext所在目录，如 "C:\php\ext"；
   3、将doc_root 改为第一步中的同样目录，如 "C:\apache\htdocs"；
   4、找到 ;session.save_path = "/tmp" ,将';'去掉,设置你保存session的目录，如session.save_path = "C:/php/tmp"；
   5、然后把下面几句前面的分号去掉,以更好支持Mysql and PHPmyadmin
        extension=php_mbstring.dll
        extension=php_gd2.dll
        extension=php_mysql.dll
        extension=php_pdo.dll
        extension=php_pdo_mysql.dll

> PHP+APACHE整合

   1、允许Apache将PHP程序作为模块来运行:
           打开httpd.conf,添加下面内容(位置任意)：
             LoadModule php5_module "C:/php/php5apache2_2.dll"

             AddType application/x-httpd-php .php
             AddType application/x-httpd-php .htm
            （.htm, .php为可执行php语言的扩展名，也可加html, php3, php4,甚至txt）
           （以下两步可以不需要）
   2、如果你出于某种原因而需要在CGI模式中运行PHP程序（使用Php.exe），
          请将上面这一行变成注释（各行头加#即可），添加下面这些行：
           # ScriptAlias /php/ "C:/php/"
           # AddType application/x-httpd-php .php
           #Action application/x-httpd-php "/php/php-cgi.exe"
   3、现在apache 2 支持HTML而不支持PHP,先把下面几句加到C:\apache\conf\httpd.conf去:
           # ScriptAlias /php/ "C:/php/"
           # AddType application/x-httpd-php .php
           #Action application/x-httpd-php "/php/php-cgi.exe"

> 重启服务，测试环境

   1、在C:\php里找到php5ts.dll,libmysql.dll将其复制到C:\winnt\system32下(winNT/2000的机器),而winXP/2003是复制到C:\windows\system32下
   2、测试Apache与php是否连接成功：
          启动start apache服务或者正在运行的就重新启动restart apache
   3、在Web根目录下新建test.php（即C:\apache\htdocs目下）
           <html>
           <head><title>test</title></head>
           <body>
            <?php
              phpinfo();
            ?>
         </body>
          </html>

   4、运行http://localhost/test.php
         如果成功，则应该看到一个含有PHP徽标的网页，其中包含大量设置和其他信息
         那么恭喜你，环境已经搭建成功！

关键词：PHP PHP5 Apache MySQL PHP运行环境

posted @ 2011-07-07 12:05 jadmin 阅读(80) | 评论 (0) | 编辑收藏

Hibernate OGM项目

　　Hibernate 团队对外宣布了一个新的家族成员，Hibernate OGM， OGM 是 Object Grid Mapping的缩写，它的目标是试图使用 JPA 来操作 NoSQL数据库，目前似乎局限于Infinispan 。

　　目前支持的特性：

CRUD operations for entities
properties with simple (JDK) types
embeddable objects
entity hierarchy
identifier generators (TABLE and all in-memory based generators today)
optimistic locking
@ManyToOne,@OneToOne,@OneToManyand@ManyToManyassociations
bi-directional associations
Set,ListandMapsupport for collections
most Hibernate native APIs (likeSession) and JPA APIs (likeEntityManager)
same bootstrap model found in JPA or Hibernate Core: in JPA, set<provider>toorg.hibernate.ogm.jpa.HibernateOgmPersistenceand you're good to go

　　下载：http://www.hibernate.org/subprojects/ogm/download

　　参考手册：http://docs.jboss.org/hibernate/ogm/3.0/reference/en-US/html_single/

　　PS：从目前情况看，不支持流行的 MongoDB 等等。与DataNucleus(http://www.datanucleus.org)在Backend的存储技术方面，还不能相提并论，DataNucleus支持JDO，JPA标准，支持目前几乎所有的流行的存储方式，Google的APPEngine也是基于DataNucleus的。

posted @ 2011-06-21 12:58 jadmin 阅读(147) | 评论 (0) | 编辑收藏

领域驱动设计(Domain Driven Design)

　　”…在很多领域，专家的作用体现在他们的专业知识上而不是智力上。“

　　--Don Reinertsen

　　领域驱动设计(Domain Driven Design)是一种软件开发方法，目的是让软件系统在实现时准确的基于对真实业务过程的建模并根据真实业务过程的调整而调整。

　　传统的开发工作趋向于一种以技术为先导的过程，需求从业务方传递到开发团队，开发人员依据需求上的描述创造出最有可能的假想。

　　在瀑布开发过程中，这导致了大量的需要频繁校对，分析，复核和审批的需求文档。之后这些文档被交给开发团队去变成能够运行的软件。

　　敏捷开发方法同样可以采纳瀑布模式过程中产生的需求文档，但敏捷方法在实际的处理过程中会把它们分成很小的任务和“故事”，之后的开发工作将依据这些任务的排序。

　　领域驱动设计很大程度上使你从这两种截然不同的结果中抽身出来，让你能看到需求是如何在第一现场被收集到——如果你愿意看的话，它在动手先做的方式和在最后一分钟才做的方式之间做了弥补。

　　领域驱动设计方式知道需求是永远不会“完成”的，需求就像一个活的文档。更重要的是，这些仍待讨论的活文档实际上就是软件自身——所有的文档都是程序代码的一种影像，一种演示品。

　　随着软件系统的开发和发展，你对各种问题的理解也会更深——领域驱动设计就是要通过深入的理解问题来找到问题的解决方案。

　　然而，领域驱动设计真正的不同之处却是，它把软件系统当作业务过程的一个影射，是使能动，而不是驱动。领域驱动设计是要你深入到业务过程中，了解业务术语和实践方法。技术方面的事被放在了第二位，只是最终的一种手段而已。

　　Ubiquitous语言(UL)是领域驱动设计的中心——这是一种共有的不断成长的语言。它是一种来源于业务术语、经过开发团队的补充而产生的协商后的语言。如果一个业务人员不懂得UL里的一个术语，有可能是UL需要改进发展。如果一个技术人员不懂得UL里的一个术语，有可能是他们需要跟领域专家进行交流。

　　领域专家是领域驱动设计里第二重要的组成部分——这些人能够对这个领域有深入的了解，包括这个业务本身。这些人构成了开发过程中必要的组成部分。他们也许像一些敏捷开发方法里传统的产品拥有者那样不需要“全天候”的在职，但他们必须在开发过程中能被持续的接触到，而且随时准备好参与到开发过程中。领域专家不能被当作门外人，而应被当作领域驱动设计过程中的核心——他们非常像是开发团队中的一部分，就像普通的开发者和测试者一样。

　　领域驱动设计没有开始和结束——它是一个不断的再评估，再重构，再建模，再设计的持续过程——每一次的对话都会使你对问题有更进一步的理解。领域驱动设计没有“完成”点——它永远都在进行；Ubiquitous语言会不断发展和成长，领域模型随着对业务理解的改变而改变，代码不断的再组织和重构来更好的表现你的理解。

　　各种模拟产物产生又抛弃，而唯一真正有意义的只有代码。它是解决方案的唯一表达，是一种不再抽象的表达。文档是用来解释和描述系统的，而只有代码能不失分毫的做到这些。这就是说，在领域驱动设计里，代码必须保持高质量，要清晰，要有表达力，没有技术上省略和专门用语，尽可能的要让代码能够在被解释时对领域专家有些意义。

　　领域驱动设计里没有精巧的代码，也没有奇特的处理过程，或“你不需要知道”的模块。领域专家不需要成为开发人员来理解软件系统里用来做这些工作的关键部分是什么。他们同样也不需要考虑数据库或批处理任务或其他技术相关的方面。

　　领域驱动设计是敏捷方法的终极表达——它是用来处理不断变化和发展的需求的——正如任何一个从未涉足软件项目的人都知道——一个项目的需求从开始到结束保持一成不变是极其罕见的，绝大多数情况是它会随着业务的增长和变化而变化。

　　通过不断的交流，领域驱动设计会指导你用软件最精确的表达你的业务过程。

关键词：领域模型设计领域驱动设计

posted @ 2011-06-11 02:26 jadmin 阅读(92) | 评论 (0) | 编辑收藏

MongoDB学习——介绍一款MongoDB连接管理工具

这是一款开源PHP5写的MongoDB管理工具，项目地址：http://code.google.com/p/rock-php

具体安装使用可参考wiki --->http://code.google.com/p/rock-php/wiki/rock_mongo_zh

关键词：数据库 database MongoDB 数据库连接数据库管理工具 MongoDB管理工具

posted @ 2011-06-10 15:07 jadmin 阅读(118) | 评论 (0) | 编辑收藏

Java中天、时、分、秒之间的高效换算

TimeUnit是一个枚举类型,可以将时间方便快捷的转换为(天、时、分、秒、纳秒)day,hour,minute,second,millli...
有了这个类我们可以方便将时间进行转换

1、我们将1个小时转换为多少分钟、多少秒
1小时转换分钟数为60分钟
TimeUnit.HOURS.toMinutes(1) =>60
1小时转换分钟数为3600秒
TimeUnit.HOURS.toSeconds(1) =>3600
2、如果将秒转换为小时、分钟呢
3600秒转换分钟数为60分钟
TimeUnit.SECONDS.toMinutes(3600) =>60
3600秒转换小时数为1小时
TimeUnit.SECONDS.toHours(3600) =>1

posted @ 2011-06-10 09:23 jadmin 阅读(149) | 评论 (0) | 编辑收藏

去掉空格和换行，提高页面打开速度

怎么有效的提高页面的打开速度，提高网站性能，发现查看网站页面源代码的时候，页面上充斥了无数的空格跟换行，

增加了页面的体积，这样会影响页面性能，为了有效的解决这个问题，现提供方法如下：

1、在工程的web.xml上加上如下配置

<web-app
   xmlns="http://java.sun.com/xml/ns/javaee"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
   metadata-complete="false"
   version="2.5">

<jsp-config>
       <jsp-property-group>
           <url-pattern>*.jsp</url-pattern>
           <trim-directive-whitespaces>true</trim-directive-whitespaces>
       </jsp-property-group>
</jsp-config>

2、在每个JSP的头上加上一段代码 <%@ page trimDirectiveWhitespaces="true" %>

以上两种方法取其一即可，建议使用第一种。

PS:

第一种方式要求：web.xml 中的配置需在servlet2.5、tomcat6.0以上使用才会有效。
第二种方式要求：jsp版本需要在jsp2.1及以上版本使用才会有效。
低版本的环境下，使用仅无效果，不会对应用功能造成影响。

JSP、SERVLET版本查看方式：

找到tomcat下的lib目录，查看jsp-api.jar和servlet-api.jar两个jar包，jar包里面的META-INF文件夹下的MANIFEST.MF文件，里面有相应的版本号
   如（jsp2.1）：
   Name: javax/servlet/jsp/
   Specification-Title: Java API for JavaServer Pages
   Specification-Version: 2.1
   Specification-Vendor: Sun Microsystems, Inc.
   Implementation-Title: javax.servlet.jsp
   Implementation-Version: 2.1.FR
   Implementation-Vendor: Apache Software Foundation

原理： tomcat在将JSP解释成JAVA文件时，会根据trim-directive-whitespaces来判断，生成的代码在遇到jsp标签时，是否需要输出一段代码：

out.write("\r\n");

所以这种去空格的方式是在tomcat每次编译JSP时，就一次处理的，一旦jsp生成了对应的JAVA，后续的处理过程中，即不再去处理空格的问题，有效的节省资源。

posted @ 2011-06-09 18:29 jadmin 阅读(131) | 评论 (0) | 编辑收藏

详解Spring 3.0 基于Annotation 的依赖注入实现

简介： Spring 的依赖配置方式与 Spring 框架的内核自身是松耦合设计的。然而，直到 Spring 3.0 以前，使用 XML 进行依赖配置几乎是唯一的选择。Spring 3.0 的出现改变了这一状况，它提供了一系列的针对依赖注入的注解，这使得 Spring IoC 在 XML 文件之外多了一种可行的选择。本文将详细介绍如何使用这些注解进行依赖配置的管理。

使用 @Repository、@Service、@Controller 和 @Component 将类标识为 Bean

Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository 注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO 类上即可。同时，为了让 Spring 能够扫描类路径中的类并识别出 @Repository 注解，需要在 XML 配置文件中启用 Bean 的自动扫描功能，这可以通过 <context:component-scan/> 实现。如下所示：

posted @ 2011-06-09 16:17 jadmin 阅读(109) | 评论 (0) | 编辑收藏

关于JVM的Thin Lock, Fat Lock, SPIN Lock与Tasuki Lock

Java很多ThreadDump中，都可以看到Thin Lock, Fat Lock, Spin Lock，这些Lock都与Java语言、OS有密切的关系。
回到一个简单的问题，在Java中，如何实现Synchronizd？
最简单的一种做法是，利用OS的mutex机制，把Java的同步（基于Object），翻译成OS相关的monitor_enter和monitor_exit原语。

回到Java锁本身，锁在不同的应用下有着不同的统计表现，而大部分的统计数据表明，其实线程抢锁，即锁竞争，都是短暂的，在大部分的情况下，几乎都不会发生锁竞争的现象。
也就是说，Java锁，从安全性的角度来看，是有点累赘。
因此，大量的专家都在锁上针对这样的统计特性对Java锁进行优化。
其中一种优化方案是，我们对所有的锁都需要monitor_enter和monitor_exit吗？事实上不需要。

如果我们把monitor_enter/monitor_exit看成是Fat Lock方式，则可以把Thin Lock看成是一种基于CAS（Compare and Swap）的简易实现。
这两种锁，简单一点理解，就是：

而基于CAS方式的实现，线程进入竞争状态的，获得锁的线程，会让其他线程处于自旋状态（也称之为Spin Mode，即自旋），这是一种while(Lock_release) doStuff()的Busy-Wait方式，是一种耗CPU的方式；而Fat Lock方式下，一个线程获得锁的时候，其他线程可以先sleep，等锁释放后，再唤醒（Notify）。
CAS的优点是快，如果没有线程竞争的情况下，因为CAS只需要一个指令便获得锁，所以称之为Thin Lock，缺点也是很明显的，即如果频繁发生线程竞争，CAS是低效，主要表现为，排斥在锁之外的线程是Busy Wait状态；而monitor_enter/monitor_exit/monitor_notify方式，则是重量级的，在线程产生竞争的时候，Fat Lock在OS mutex方式下，可以实现no busy-wait。

于是，JVM早期版本的做法是，如果T1, T2，T3，T4...产生线程竞争，则T1通过CAS获得锁(此时是Thin Lock方式)，如果T1在CAS期间获得锁，则T2，T3进入SPIN状态直到T1释放锁；而第二个获得锁的线程，比如T2，会将锁升级（Inflation）为Fat Lock，于是，以后尝试获得锁的线程都使用Mutex方式获得锁。

这种设计为锁提供了两条路径：Thin Lock路径和Fat Lock路径，大部分情况下，可能都是走Thin Lock路径，而可能少部分情况，是走Fat Lock路径，这种方式提供了锁升级，但是避免不了Busy Wait，而且Thin-Lock升级Fat-Lock之后，没有办法回退到Thin-Lock（性能比Fat-Lock更好）。

Tasuki锁为这种方式做了2个优化：
1) 避免CAS导致Busy wait
2) Fat Lock可以deflate(与Inflate刚好相反)为Thin Lock(之前是Thin Lock变成Fat Lock之后便不能再回退)。

经过这样的改造后，锁性能提高了10%以上。

目前，Oracle的BEA JRockit与IBM的JVM都实现了Tasuki锁机制，唯一的不同是，在锁实现上都做了不同启发式的设计，即根据运行时采样的数据，动态调整一些权值数据，一边左右Lock Inflation/Lock Defaltion的过程（一颗树的两个分支），获取更好的锁性能。

关键词：JAVA 对象锁 JVM 锁机制 JVM锁 LOCK

posted @ 2011-06-09 01:06 jadmin 阅读(116) | 评论 (0) | 编辑收藏

spring执行同步任务和异步任务

顾名思义：同步任务是指事情需要一件一件的做，做完当前的任务，才能开始做下一任务；异步任务是指做当前任务的同时，后台还可以在执行其他任务，可理解为可同时执行多任务，不必一件一件接着去做，下面开始上例子了

1.同步任务

/*
* @(#)SyncTaskExecutorTest.java   2011-4-27
*
* Copyright (c) 2011. All Rights Reserved.
*
*/

package org.jsoft.opensource.demos.spring.task;

import org.junit.Test;
import org.springframework.core.task.SyncTaskExecutor;

/**
* Spring同步任务处理
*
* @author <a href="mailto:hongyuan.czq@taobao.com">Gerald Chen</a>
* @version $Id: SyncTaskExecutorTest.java,v 1.1 2011/05/30 08:58:07 gerald.chen Exp $
*/
public class SyncTaskExecutorTest {

   @Test
   public void test() throws InterruptedException {
       SyncTaskExecutor executor = new SyncTaskExecutor();
       executor.execute(new OutThread());
       System.out.println("Hello, World!");
       Thread.sleep(10000 * 1000L);
   }

   static class OutThread implements Runnable {

       public void run() {
           for (int i = 0; i < 1000; i++) {
               System.out.println(i + " start ...");
               try {
                   Thread.sleep(2 * 1000L);
               } catch (InterruptedException e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
           }
       }

   }

}

必须在线程任务执行完毕之后，"Hello,World!"才会被打印出来

2.异步任务

/*
* @(#)AsyncTaskExecutorTest.java   2011-4-27
*
* Copyright (c) 2011. All Rights Reserved.
*
*/

package org.jsoft.opensource.demos.spring.task;

import org.junit.Test;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.core.task.SimpleAsyncTaskExecutor;

/**
* Spring异步任务处理
*
* @author <a href="mailto:hongyuan.czq@taobao.com">Gerald Chen</a>
* @version $Id: AsyncTaskExecutorTest.java,v 1.1 2011/05/30 08:58:07 gerald.chen Exp $
*/
public class AsyncTaskExecutorTest {

   @Test
   public void test() throws InterruptedException {
       AsyncTaskExecutor executor = new SimpleAsyncTaskExecutor("sys.out");
       executor.execute(new OutThread(), 50000L);
       System.out.println("Hello, World!");
       Thread.sleep(10000 * 1000L);
   }

   static class OutThread implements Runnable {

       public void run() {
           for (int i = 0; i < 100; i++) {
               System.out.println(i + " start ...");
               try {
                   Thread.sleep(2 * 1000L);
               } catch (InterruptedException e) {
                   // TODO Auto-generated catch block
                   e.printStackTrace();
               }
           }
       }

   }
}

"Hello,World!"被正常打印出来，线程任务在后台静静地执行.

关键词：JAVA Spring 任务同步异步软件工程师程序员编程

posted @ 2011-06-08 20:53 jadmin 阅读(761) | 评论 (0) | 编辑收藏

MongoDB学习——命令操作

一、DB Shell数据库操作

数据库

1、Help查看命令提示
help
db.help();
db.yourColl.help();
db.youColl.find().help();
rs.help();

2、切换/创建数据库
>use yourDB;
当创建一个集合(table)的时候会自动创建当前数据库

3、查询所有数据库
show dbs;

4、删除当前使用数据库
db.dropDatabase();

5、从指定主机上克隆数据库
db.cloneDatabase(“127.0.0.1”);
将指定机器上的数据库的数据克隆到当前数据库

6、从指定的机器上复制指定数据库数据到某个数据库
db.copyDatabase("mydb", "temp", "127.0.0.1");
将本机的mydb的数据复制到temp数据库中

7、修复当前数据库
db.repairDatabase();

8、查看当前使用的数据库
db.getName();
db;
db和getName方法是一样的效果，都可以查询当前使用的数据库

9、显示当前db状态
db.stats();

10、当前db版本
db.version();

11、查看当前db的链接机器地址

db.getMongo();

Collection聚集集合

1、创建一个聚集集合（table）
db.createCollection(“collName”, {size: 20, capped: 5, max: 100});

2、得到指定名称的聚集集合（table）
db.getCollection("account");

3、得到当前db的所有聚集集合
db.getCollectionNames();

4、显示当前db所有聚集索引的状态
db.printCollectionStats();

用户相关

1、添加一个用户
db.addUser("name");
db.addUser("userName", "pwd123", true);
添加用户、设置密码、是否只读

2、数据库认证、安全模式
db.auth("userName", "123123");

3、显示当前所有用户
show users;

4、删除用户
db.removeUser("userName");

其他

1、查询之前的错误信息
db.getPrevError();

2、清除错误记录
db.resetError();

二、Collection聚集集合操作

查看聚集集合基本信息

1、查看帮助
db.yourColl.help();

2、查询当前集合的数据条数
db.yourColl.count();

3、查看数据空间大小
db.userInfo.dataSize();

4、得到当前聚集集合所在的db
db.userInfo.getDB();

5、得到当前聚集的状态
db.userInfo.stats();

6、得到聚集集合总大小
db.userInfo.totalSize();

7、聚集集合储存空间大小
db.userInfo.storageSize();

8、Shard版本信息
db.userInfo.getShardVersion()

9、聚集集合重命名
db.userInfo.renameCollection("users");
将userInfo重命名为users

10、删除当前聚集集合
db.userInfo.drop();

聚集集合查询
1、查询所有记录
db.userInfo.find();
相当于：select * from userInfo;
默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；”
但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize = 50;这样每页就显示50条记录了。

2、查询去掉后的当前聚集集合中的某列的重复数据
db.userInfo.distinct("name");
会过滤掉name中的相同数据
相当于：select distict name from userInfo;

3、查询age = 22的记录
db.userInfo.find({"age": 22});
相当于： select * from userInfo where age = 22;

4、查询age > 22的记录
db.userInfo.find({age: {$gt: 22}});
相当于：select * from userInfo where age > 22;

5、查询age < 22的记录
db.userInfo.find({age: {$lt: 22}});
相当于：select * from userInfo where age < 22;

6、查询age >= 25的记录
db.userInfo.find({age: {$gte: 25}});
相当于：select * from userInfo where age >= 25;

7、查询age <= 25的记录
db.userInfo.find({age: {$lte: 25}});

8、查询age >= 23 并且 age <= 26
db.userInfo.find({age: {$gte: 23, $lte: 26}});

9、查询name中包含 mongo的数据
db.userInfo.find({name: /mongo/});
//相当于%%
select * from userInfo where name like ‘%mongo%’;

10、查询name中以mongo开头的
db.userInfo.find({name: /^mongo/});
select * from userInfo where name like ‘mongo%’;

11、查询指定列name、age数据
db.userInfo.find({}, {name: 1, age: 1});
相当于：select name, age from userInfo;
当然name也可以用true或false,当用ture的情况下河name:1效果一样，如果用false就是排除name，显示name以外的列信息。

12、查询指定列name、age数据, age > 25
db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1});
相当于：select name, age from userInfo where age > 25;

13、按照年龄排序
升序：db.userInfo.find().sort({age: 1});
降序：db.userInfo.find().sort({age: -1});

14、查询name = zhangsan, age = 22的数据
db.userInfo.find({name: 'zhangsan', age: 22});
相当于：select * from userInfo where name = ‘zhangsan’ and age = ‘22’;

15、查询前5条数据
db.userInfo.find().limit(5);
相当于：select top 5 * from userInfo;

16、查询10条以后的数据
db.userInfo.find().skip(10);
相当于：select * from userInfo where id not in (
select top 10 * from userInfo
);

17、查询在5-10之间的数据
db.userInfo.find().limit(10).skip(5);
可用于分页，limit是pageSize，skip是第几页*pageSize

18、or与查询
db.userInfo.find({$or: [{age: 22}, {age: 25}]});
相当于：select * from userInfo where age = 22 or age = 25;

19、查询第一条数据
db.userInfo.findOne();
相当于：select top 1 * from userInfo;
db.userInfo.find().limit(1);

20、查询某个结果集的记录条数
db.userInfo.find({age: {$gte: 25}}).count();
相当于：select count(*) from userInfo where age >= 20;

21、按照某列进行排序
db.userInfo.find({sex: {$exists: true}}).count();
相当于：select count(sex) from userInfo;

索引

1、创建索引
db.userInfo.ensureIndex({name: 1});
db.userInfo.ensureIndex({name: 1, ts: -1});

2、查询当前聚集集合所有索引
db.userInfo.getIndexes();

3、查看总索引记录大小
db.userInfo.totalIndexSize();

4、读取当前集合的所有index信息
db.users.reIndex();

5、删除指定索引
db.users.dropIndex("name_1");

6、删除所有索引索引
db.users.dropIndexes();

修改、添加、删除集合数据
1、添加
db.users.save({name: ‘zhangsan’, age: 25, sex: true});
添加的数据的数据列，没有固定，根据添加的数据为准

2、修改
db.users.update({age: 25}, {$set: {name: 'changeName'}}, false, true);
相当于：update users set name = ‘changeName’ where age = 25;

db.users.update({name: 'Lisi'}, {$inc: {age: 50}}, false, true);
相当于：update users set age = age + 50 where name = ‘Lisi’;

db.users.update({name: 'Lisi'}, {$inc: {age: 50}, $set: {name: 'hoho'}}, false, true);
相当于：update users set age = age + 50, name = ‘hoho’ where name = ‘Lisi’;

3、删除
db.users.remove({age: 132});

4、查询修改删除
db.users.findAndModify({
    query: {age: {$gte: 25}},
    sort: {age: -1},
    update: {$set: {name: 'a2'}, $inc: {age: 2}},
    remove: true
});

db.runCommand({ findandmodify : "users",
    query: {age: {$gte: 25}},
    sort: {age: -1},
    update: {$set: {name: 'a2'}, $inc: {age: 2}},
    remove: true
});
update 或 remove 其中一个是必须的参数; 其他参数可选。

参数                                                                                详解                                                默认值
query                                                                  查询过滤条件                                                                       {}
sort         如果多个文档符合查询过滤条件，将以该参数指定的排列方式选择出排在首位的对象，该对象将被操作           {}
remove                                                     若为true，被选中对象将在返回前被删除                                                  N/A
update                                                     一个修改器对象                                                     N/A
new                                  若为true，将返回修改后的对象而不是原始对象。在删除操作中，该参数被忽略。                      false
fields                                                     参见Retrieving a Subset of Fields (1.5.0+)                                                      All fields
upsert                                                  创建新对象若查询结果为空。示例 (1.5.4+)                                       false

语句块操作
1、简单Hello World
print("Hello World!");
这种写法调用了print函数，和直接写入"Hello World!"的效果是一样的；

2、将一个对象转换成json
tojson(new Object());
tojson(new Object('a'));

3、循环添加数据
> for (var i = 0; i < 30; i++) {
db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
};
这样就循环添加了30条数据，同样也可以省略括号的写法
> for (var i = 0; i < 30; i++) db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
也是可以的，当你用db.users.find()查询的时候，显示多条数据而无法一页显示的情况下，可以用it查看下一页的信息；

4、find 游标查询
>var cursor = db.users.find();
> while (cursor.hasNext()) {
printjson(cursor.next());
}
这样就查询所有的users信息，同样可以这样写
var cursor = db.users.find();
while (cursor.hasNext()) { printjson(cursor.next); }
同样可以省略{}号

5、forEach迭代循环
db.users.find().forEach(printjson);
forEach中必须传递一个函数来处理每条迭代的数据信息

6、将find游标当数组处理
var cursor = db.users.find();
cursor[4];
取得下标索引为4的那条数据
既然可以当做数组处理，那么就可以获得它的长度：cursor.length();或者cursor.count();
那样我们也可以用循环显示数据
for (var i = 0, len = c.length(); i < len; i++) printjson(c[i]);

7、将find游标转换成数组
> var arr = db.users.find().toArray();
> printjson(arr[2]);
用toArray方法将其转换为数组

8、定制我们自己的查询结果
只显示age <= 28的并且只显示age这列数据
db.users.find({age: {$lte: 28}}, {age: 1}).forEach(printjson);
db.users.find({age: {$lte: 28}}, {age: true}).forEach(printjson);
排除age的列
db.users.find({age: {$lte: 28}}, {age: false}).forEach(printjson);

9、forEach传递函数显示信息
db.things.find({x:4}).forEach(function(x) {print(tojson(x));});
上面介绍过forEach需要传递一个函数，函数会接受一个参数，就是当前循环的对象，然后在函数体重处理传入的参数信息。

posted @ 2011-06-08 20:13 jadmin 阅读(88) | 评论 (0) | 编辑收藏

google code获取密码页打不开

解决办法：

设置host，在文件 C:\Windows\System32\drivers\etc\hosts 中加入 66.249.89.99 code.google.com

posted @ 2011-06-08 15:45 jadmin 阅读(124) | 评论 (0) | 编辑收藏

五个最给力的Hadoop项目

SD Times高级编辑Alex Handy日前列出了当前使用Hadoop的项目中他认为最成功的五个。

posted @ 2011-06-06 23:10 jadmin 阅读(181) | 评论 (0) | 编辑收藏

Javascript生成GUID

posted @ 2011-06-01 21:06 jadmin 阅读(102) | 评论 (0) | 编辑收藏

如何学习一门新的语言

这两天在看《编程人生》，这本书确实非常不错。而且看得也特别的轻松。其中有几个人都谈到了如何学习新的语言，但是给我最深刻的是google的首席java架构师joshua bloch。正好最近我也在学习python，所以顺便总结一下如何学习一门新的语言。希望你能补充一些。

心态

这不但是学习一门新的语言最重要的，而是对任何的学习都是最重要的。下面是书中的描述，非常的精彩，特别是那个比喻：

“学习一门新的语言的时候，要利用以前所学的语言的功底，但是也要保持开放的心态。有些人执着于一种理念：“这就是写所有程序必须遵循的方法”。我不是说那种语言，但是某些语言，令人执着于这样的理念。当开始学习新语言的时候，他们会批评这种语言跟真正神的语言的所有的不同之处。当使用新语言时，他们极力使用神的语言的方法去写。这样，你就会错过这个新语言真正的独特之处。
这就像你本来只有一个榔头，有人给了你一个螺丝刀，你说“哎，这不是一把好榔头，但是我应该可以倒着拿螺丝刀，用螺丝刀来砸东西。”你得到了一个很烂的榔头，但事实上它确实一把很不错的螺丝刀。所以你应该对所有的事物保持开放和积极的心态。”

如果你的杯子满了，那他永远再也装不进水了。如果你认为你找到了银弹，那么你可能就要固步自封了。

对新的事物，方法保持一个开发而积极的心态，才能真正了解他，了解他的独特之处。

这一点相对来说比较难，程序员一般对他们的语言有一种近乎固执的偏爱。Paul Graham在《黑客与画家》中好像提到过，开发语言是程序员的宗教信仰，贬低一种语言对使用这种语言的程序员是一种侮辱。

了解他的历史，哲学观

选择一门语言，往往选择了一种思维方式和哲学观。所以，了解一门语言的历史和哲学观非常重要。你要知道这门语言是谁创建的，为什么创建，如何发展起来的，适合那些领域，以及解决问题的哲学是什么。

那python来说，他的设计哲学是“用一种方法，最好是只有一种方法来做一件事”，而perl的设计哲学是“总有多种方法来做同一件事”。所以，我选择的是python。

了解这方面的知识的一个非常好的来源是百科网站。

代码，代码，还是代码

代码是学习一门语言的必经之路，可能也是最快的一种方法。

你不但要找一些优秀的代码来阅读，还要亲自动手来写代码。这个过程对学习语言来说是非常快的。另外，你一定要用语言去解决实际的问题，而不仅仅是写代码来验证语法。在解决问题的过程中，你可以学习它是如何解决问题的，而且会积累语言的经验。

在工作中使用一门新的语言来开发新项目的风险相对较大，所以，如果再工作中尝试使用新的语言，可以选择一些小的项目来积累经验。如果工作中无法使用这个语言，那么就在业余使用这个语言解决问题吧。

社区

多去这个语言的社区逛逛吧，这里有很多人在讨论这种语言，和他们一起讨论你能够学到更多。

本文转自CSDN博客

posted @ 2011-06-01 12:48 jadmin 阅读(74) | 评论 (0) | 编辑收藏

MongoDB学习——安全登录

/**
* Java + MongoDB in Secure Mode
*
* @author <a href="mailto:gerald.chen@qq.com">Gerald Chen</a>
* @version $Id: AuthTest.java,v 1.1 2011/05/27 07:24:04 gerald.chen Exp $
*/
public class AuthTest {

/** 数据库连接IP */
public static final String DB_HOST ="192.168.35.101";

/** 数据库连接端口 */
public static final int DB_PORT =27017;

public static void main(String[] args) throws Exception, MongoException {
      Mongo mongo =new Mongo(DB_HOST, DB_PORT);
      DB db = mongo.getDB("test_db");

      boolean auth = db.authenticate("gerald", "123456".toCharArray());
      System.out.println(auth);

      DBCollection collection = db.getCollection("test_collection");
      System.out.println(collection.getFullName());

}

}

posted @ 2011-05-27 15:42 jadmin 阅读(96) | 评论 (0) | 编辑收藏

MongoDB学习——数据库管理命令

1.进入mongodb命令行管理
C:\Documents and Settings\Administrator>mongo
MongoDB shell version: 1.8.1
connecting to: test

2.显示数据库
> show dbs
admin (empty)
local (empty)
test_db 0.03125GB

3.使用数据库
> use test_db
switched to db test_db

4.添加数据库用户
> db.users.save({username:"gerald"})

5.查找数据库用户
> db.users.find()
{ "_id" : ObjectId("4ddf396e641b4986d346fe89"), "username" : "gerald" }

6.添加隶属于某个数据库的用户
> use test_db
switched to db test_db
> db.addUser("gerald","123456")
{
        "user" : "gerald",
        "readOnly" : false,
        "pwd" : "f528f606b8635241c7f060408973b5b9"
}

7.以用户验证的身份登录数据库
> use test_db
switched to db test_db
> db.auth("gerald","123456")
1

PS: 1代表验证成功, 0代表验证失败

关键词：数据库 NoSQL MongoDB Database

posted @ 2011-05-27 15:38 jadmin 阅读(105) | 评论 (0) | 编辑收藏

MongoDB学习——程序开篇之Hello World

1.准备

下载Mongo Java Driver，下载地址：https://github.com/downloads/mongodb/mongo-java-driver/mongo-2.5.3.jar

如果是使用maven编译，可在pom.xml文件中加入如下依赖

     <dependency>
          <groupId>org.mongodb</groupId>
          <artifactId>mongo-java-driver</artifactId>
          <version>2.5.3</version>
     </dependency>

2.上程序

/**
* MongoDB学习之HelloWorld
*
* @author <a href="mailto:gerald.chen@qq.com">GeraldChen</a>
* @version $Id: HelloWorldTest.java,v 1.1 2011/05/26 12:42:45 gerald.chen Exp $
*/
public class HelloWorldTest {

/** 数据库连接IP */
public static final String DB_HOST = "192.168.35.101";

/** 数据库连接端口 */
public static final int DB_PORT = 27017;

     public static void main(String[] args) throws Exception {
         // connect to mongoDB, ip and port number
         Mongo mongo = new Mongo(DB_HOST, DB_PORT);

         // get database from MongoDB,
         // if database doesn't exists, mongoDB will create it automatically
         DB db = mongo.getDB("test_db");

         // Get collection from MongoDB, database named "yourDB"
         // if collection doesn't exists, mongoDB will create it automatically
         DBCollection collection = db.getCollection("test_collection");

         // create a document to store key and value
         BasicDBObject document = new BasicDBObject();
         document.put("id", 1001);
         document.put("message", "hello world mongoDB in Java");

// save it into collection named "yourCollection"
collection.insert(document);

         // search query
         BasicDBObject searchQuery = new BasicDBObject();
         searchQuery.put("id", 1001);

// query it
DBCursor cursor = collection.find(searchQuery);

         // loop over the cursor and display the retrieved result
         while (cursor.hasNext()) {
                  System.out.println(cursor.next());
         }
         System.out.println("Done");
   }

}

2.程序输出

关键词：HelloWorld MongoDB NoSQL JAVA 程序软件数据库程序员

posted @ 2011-05-26 20:47 jadmin 阅读(95) | 评论 (0) | 编辑收藏

MongoDB学习——将MongoDB服务化

继上一篇MongoDB学习——安装与配置，我们接着来看下如何将MongoDB安装为Windows的服务：

1.服务化

在命令窗口运行如下命令即可：

#>mongod --dbpath "G:\database\mongodb\data" --logpath "G:\database\mongodb\logs.txt" --install --serviceName "MongoDB"

其中"G:\database\mongodb\data"为MongoDB的数据目录

2.卸载服务

执行命令：

#>mongod --remove --serviceName "MongoDB"

关键词：HelloWorld MongoDB NoSQL JAVA 程序软件数据库程序员

posted @ 2011-05-25 20:57 jadmin 阅读(113) | 评论 (0) | 编辑收藏

MongoDB学习——安装配置

1.MongoDB介绍

　　MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
　　它的特点是高性能、易部署、易使用，存储数据非常方便。主要功能特性有：
　　*面向集合存储，易存储对象类型的数据。
　　*模式自由。
　　*支持动态查询。
　　*支持完全索引，包含内部对象。
　　*支持查询。
　　*支持复制和故障恢复。
　　*使用高效的二进制数据存储，包括大型对象（如视频等）。
　　*自动处理碎片，以支持云计算层次的扩展性
　　*支持RUBY，PYTHON，JAVA，C++，PHP等多种语言。
　　*文件存储格式为BSON（一种JSON的扩展）
　　*可通过网络访问

　　所谓“面向集合”（Collenction-Oriented），意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。每个集合在数据库中都有一个唯一的标识名，并且可以包含无限数目的文档。集合的概念类似关系型数据库（RDBMS）里的表（table），不同的是它不需要定义任何模式（schema)。
　　模式自由（schema-free)，意味着对于存储在mongodb数据库中的文件，我们不需要知道它的任何结构定义。如果需要的话，你完全可以把不同结构的文件存储在同一个数据库里。
　　存储在集合中的文档，被存储为键-值对的形式。键用于唯一标识一个文档，为字符串类型，而值则可以是各种复杂的文件类型。我们称这种存储形式为BSON（Binary Serialized dOcument Format）。

2.下载MongoDB

　　下载地址http://www.mongodb.org/downloads 至本文成文之时，版本号为：1.8.1

　　 http://downloads.mongodb.org/win32/mongodb-win32-i386-1.8.1.zip

3.安装

　　将zip文件解压至某个磁盘目录，如：G:\database\mongodb

4.配置

　　建立数据存储目录G:\database\mongodb\data

　　启动命令窗口，进到目录G:\>cd database\mongodb\bin

　　执行命令mongod --dbpath G:\database\mongodb\data，出现如下信息：

G:\database\mongodb\bin>mongod --dbpath G:\database\mongodb\data
Wed May 25 20:03:06 [initandlisten] MongoDB starting : pid=3244 port=27017 dbpath=G:\database\mongodb\data 32-bit

** NOTE: when using MongoDB 32 bit, you are limited to about 2 gigabytes of data

** see http://blog.mongodb.org/post/137788967/32-bit-limitations
** with --dur, the limit is lower

Wed May 25 20:03:06 [initandlisten] db version v1.8.1, pdfile version 4.5
Wed May 25 20:03:06 [initandlisten] git version: a429cd4f535b2499cc4130b06ff7c26f41c00f04
Wed May 25 20:03:06 [initandlisten] build sys info: windows (5, 1, 2600, 2, 'Service Pack 3') BOOST_LIB_VERSION=1_35
Wed May 25 20:03:06 [initandlisten] waiting for connections on port 27017
Wed May 25 20:03:06 [websvr] web admin interface listening on port 28017

5.查看管理后台

　　打开浏览器，登入地址：http://localhost:28017
　　出现如下内容：

关键词：HelloWorld MongoDB NoSQL JAVA 程序软件数据库程序员

posted @ 2011-05-25 20:20 jadmin 阅读(110) | 评论 (0) | 编辑收藏

MySQL设置默认时间

       由于MySQL目前字段的默认值不支持函数的形式设置默认值是不可能的。
       代替的方案是使用TIMESTAMP类型代替DATETIME类型。
       CURRENT_TIMESTAMP ：当我更新这条记录的时候，这条记录的这个字段不会改变。
       CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ：当我更新这条记录的时候，这条记录的这个字段将会改变。即时间变为了更新时候的时间。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。）如果有多个TIMESTAMP列，只有第一个自动更新。
      TIMESTAMP列类型自动地用当前的日期和时间标记INSERT或UPDATE的操作。
      如果有多个TIMESTAMP列，只有第一个自动更新。
      自动更新第一个TIMESTAMP列在下列任何条件下发生：
      列值没有明确地在一个INSERT或LOAD DATA INFILE语句中指定。
      列值没有明确地在一个UPDATE语句中指定且另外一些的列改变值。（注意一个UPDATE设置一个列为它已经有的值，这将不引起TIMESTAMP列被更新，因为如果你设置一个列为它当前的值，MySQL为了效率而忽略更改。）
      你明确地设定TIMESTAMP列为NULL.
      除第一个以外的TIMESTAMP列也可以设置到当前的日期和时间，只要将列设为NULL，或NOW()。
      另外在5.0以上版本中也可以使用trigger来实现此功能。

      create table test_time (
      id int(11),
      create_time datetime
      );
      delimiter |
            create trigger default_datetime before insert on test_time
      for each row
            if new.create_time is null then
            set new.create_time = now();
      end if;|
      delimiter ;

posted @ 2011-05-23 11:57 jadmin 阅读(90) | 评论 (0) | 编辑收藏

分库分表

单库单表

单库单表是最常见的数据库设计，例如，有一张用户(user)表放在数据库db中，所有的用户都可以在db库中的user表中查到。

单库多表

随着用户数量的增加，user表的数据量会越来越大，当数据量达到一定程度的时候对user表的查询会渐渐的变慢，从而影响整个DB的性能。如果使用mysql, 还有一个更严重的问题是，当需要添加一列的时候，mysql会锁表，期间所有的读写操作只能等待。

可以通过某种方式将user进行水平的切分，产生两个表结构完全一样的user_0000,user_0001等表，user_0000 + user_0001 + …的数据刚好是一份完整的数据。

多库多表

随着数据量增加也许单台DB的存储空间不够，随着查询量的增加单台数据库服务器已经没办法支撑。这个时候可以再对数据库进行水平区分。

分库分表规则

设计表的时候需要确定此表按照什么样的规则进行分库分表。例如，当有新用户时，程序得确定将此用户信息添加到哪个表中；同理，当登录的时候我们得通过用户的账号找到数据库中对应的记录，所有的这些都需要按照某一规则进行。

路由

通过分库分表规则查找到对应的表和库的过程。如分库分表的规则是user_id mod 4的方式，当用户新注册了一个账号，账号id的123,我们可以通过id mod 4的方式确定此账号应该保存到User_0003表中。当用户123登录的时候，我们通过123 mod 4后确定记录在User_0003中。

分库分表产生的问题，及注意事项

1. 分库分表维度的问题

假如用户购买了商品,需要将交易记录保存取来，如果按照用户的纬度分表，则每个用户的交易记录都保存在同一表中，所以很快很方便的查找到某用户的购买情况，但是某商品被购买的情况则很有可能分布在多张表中，查找起来比较麻烦。反之，按照商品维度分表，可以很方便的查找到此商品的购买情况，但要查找到买人的交易记录比较麻烦。

所以常见的解决方式有：

a.通过扫表的方式解决，此方法基本不可能，效率太低了。

b.记录两份数据，一份按照用户纬度分表，一份按照商品维度分表。

c.通过搜索引擎解决，但如果实时性要求很高，又得关系到实时搜索。

2. 联合查询的问题

联合查询基本不可能，因为关联的表有可能不在同一数据库中。

3. 避免跨库事务

避免在一个事务中修改db0中的表的时候同时修改db1中的表，一个是操作起来更复杂，效率也会有一定影响。

4. 尽量把同一组数据放到同一DB服务器上

例如将卖家a的商品和交易信息都放到db0中，当db1挂了的时候，卖家a相关的东西可以正常使用。也就是说避免数据库中的数据依赖另一数据库中的数据。

一主多备

在实际的应用中，绝大部分情况都是读远大于写。Mysql提供了读写分离的机制，所有的写操作都必须对应到Master，读操作可以在Master和Slave机器上进行，Slave与Master的结构完全一样，一个Master可以有多个Slave,甚至Slave下还可以挂Slave,通过此方式可以有效的提高DB集群的QPS.

所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave机器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重。

此外，可以看出Master是集群的瓶颈，当写操作过多，会严重影响到Master的稳定性，如果Master挂掉，整个集群都将不能正常工作。

所以，1. 当读压力很大的时候，可以考虑添加Slave机器的分式解决，但是当Slave机器达到一定的数量就得考虑分库了。 2. 当写压力很大的时候，就必须得进行分库操作。

另外，可能会因为种种原因，集群中的数据库硬件配置等会不一样，某些性能高，某些性能低，这个时候可以通过程序控制每台机器读写的比重，达到负载均衡。

posted @ 2011-05-19 16:52 jadmin 阅读(122) | 评论 (0) | 编辑收藏

JAVA并发编程

1,保证线程安全的三种方法:
    a,不要跨线程访问共享变量
    b,使共享变量是final类型的
    c,将共享变量的操作加上同步

2,一开始就将类设计成线程安全的,比在后期重新修复它,更容易.

3,编写多线程程序,首先保证它是正确的,其次再考虑性能.

4,无状态或只读对象永远是线程安全的.

5,不要将一个共享变量裸露在多线程环境下(无同步或不可变性保护)

6,多线程环境下的延迟加载需要同步的保护,因为延迟加载会造成对象重复实例化

7,对于volatile 声明的数值类型变量进行运算,往往是不安全的(volatile 只能保证可见性, 不能保证原子性).
详见volatile 原理与技巧中,脏数据问题讨论.

8,当一个线程请求获得它自己占有的锁时( 同一把锁的嵌套使用),我们称该锁为可重入锁.
在jdk1.5 并发包中,提供了可重入锁的java 实现-ReentrantLock.

9,每个共享变量, 都应该由一个唯一确定的锁保护.
创建与变量相同数目的ReentrantLock,使他们负责每个变量的线程安全.

10,虽然缩小同步块的范围,可以提升系统性能.
但在保证原子性的情况下,不可将原子操作分解成多个synchronized块.

11,在没有同步的情况下,编译器与处理器运行时的指令执行顺序可能完全出乎意料.
原因是,编译器或处理器为了优化自身执行效率,而对指令进行了的重排序(reordering).

12,当一个线程在没有同步的情况下读取变量,它可能会得到一个过期值,但是至少它可以看到那个
线程在当时设定的一个真实数值.而不是凭空而来的值.这种安全保证,称之为最低限的安全性(out-of-thin-air safety)

在开发并发应用程序时,有时为了大幅度提高系统的吞吐量与性能,会采用这种无保障的做法.
但是针对,数值的运算,仍旧是被否决的.

13,volatile 变量, 只能保证可见性,无法保证原子性.

14,某些耗时较长的网络操作或IO,确保执行时,不要占有锁.

15,发布(publish) 对象,指的是使它能够被当前范围之外的代码所使用.( 引用传递)
对象逸出(escape),指的是一个对象在尚未准备好时将它发布.

原则:为防止逸出,对象必须要被完全构造完后,才可以被发布( 最好的解决方式是采用同步)

this 关键字引用对象逸出
例子:在构造函数中,开启线程,并将自身对象this 传入线程,造成引用传递.
而此时,构造函数尚未执行完,就会发生对象逸出了.

16,必要时,使用ThreadLocal变量确保线程封闭性(封闭线程往往是比较安全的,但一定程度上会造成性能损耗)
封闭对象的例子在实际使用过程中,比较常见,例如hibernate openSessionInView机制, jdbc的connection机制.

17,单一不可变对象往往是线程安全的(复杂不可变对象需要保证其内部成员变量也是不可变的)
良好的多线程编程习惯是:将所有的域都声明为final,除非它们是可变的

18,保证共享变量的发布是安全的
    a,通过静态初始化器初始化对象(jls 12.4.2 叙述, jvm 会保证静态初始化变量是同步的)
    b,将对象申明为volatile 或使用AtomicReference
    c,保证对象是不可变的
    d,将引用或可变操作都由锁来保护

19,设计线程安全的类,应该包括的基本要素:
    a,确定哪些是可变共享变量
    b,确定哪些是不可变的变量
    c,指定一个管理并发访问对象状态的策略

20,将数据封装在对象内部,并保证对数据的访问是原子的.
建议采用volatile javabean 模型或者构造同步的getter,setter.

21,线程限制性使构造线程安全的类变得更容易,因为类的状态被限制后,分析它的线程安全性时,就不必检查完整的程序.

22,编写并发程序,需要更全的注释,更完整的文档说明.

23,在需要细分锁的分配时,使用java监视器模式好于使用自身对象的监视器锁.
前者的灵活性更好.

Object target = new Object();
//这里使用外部对象来作为监视器,而非this
synchronized(target) {
    // TODO
}

针对java monitor pattern,实际上ReentrantLock的实现更易于并发编程.
功能上,也更强大.

24,设计并发程序时,在保证伸缩性与性能折中的前提下,优先考虑将共享变量委托给线程安全的类.
由它来控制全局的并发访问.

25,使用普通同步容器(Vector, Hashtable) 的迭代器,需要外部锁来保证其原子性.
原因是,普通同步容器产生的迭代器是非线程安全的.

26,在并发编程中,需要容器支持的时候,优先考虑使用jdk 并发容器
(ConcurrentHashMap, ConcurrentLinkedQueue, CopyOnWriteArrayList...).

27, ConcurrentHashMap, CopyOnWriteArrayList
并发容器的迭代器, 以及全范围的size(), isEmpty()都表现出弱一致性.
他们只能标示容器当时的一个数据状态.无法完整响应容器之后的变化和修改.

28,使用有界队列,在队列充满或为空时,阻塞所有的读与写操作. ( 实现生产- 消费的良好方案)
BlockQueue下的实现有LinkedBlockingQueue 与ArrayBlockingQueue,前者为链表,可变操作频繁优先考虑, 后者为数组,读取操作频繁优先考虑.
PriorityBlockingQueue 是一个按优先级顺序排列的阻塞队列,它可以对所有置入的元素进行排序( 实现Comparator 接口)

29,当一个方法,能抛出InterruptedException,则意味着,这个方法是一个可阻塞的方法,如果它被中断,将提前结束阻塞状态.
当你调用一个阻塞方法,也就意味着,本身也称为了一个阻塞方法,因为你必须等待阻塞方法返回.

如果阻塞方法抛出了中断异常,我们需要做的是,将其往上层抛,除非当前已经是需要捕获异常的层次.
如果当前方法,不能抛出InterruptedException,可以使用Thread.currentThread.interrupt() 方法,手动进行中断.

posted @ 2011-05-18 22:53 jadmin 阅读(159) | 评论 (0) | 编辑收藏

java内存管理

1. java是如何管理内存的

Java的内存管理就是对象的分配和释放问题。（两部分）

分配：内存的分配是由程序完成的，程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。
释放：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。

2. 什么叫java的内存泄露

在Java中，内存泄漏就是存在一些被分配的对象，这些对象有下面两个特点，首先，这些对象是可达的，即在有向图中，存在通路可以与其相连（也就是说仍存在该内存对象的引用）；其次，这些对象是无用的，即程序以后不会再使用这些对象。如果对象满足这两个条件，这些对象就可以判定为Java中的内存泄漏，这些对象不会被GC所回收，然而它却占用内存。

3. JVM的内存区域组成

java把内存分两种：一种是栈内存，另一种是堆内存1。在函数中定义的基本类型变量和对象的引用变量都在函数的栈内存中分配；2。堆内存用来存放由new创建的对象和数组以及对象的实例变量在函数（代码块）中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量所分配的内存空间；在堆中分配的内存由java虚拟机的自动垃圾回收器来管理
堆和栈的优缺点

堆的优势是可以动态分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的。

缺点就是要在运行时动态分配内存，存取速度较慢；栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。

另外，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。

4. Java中数据在内存中是如何存储的

a) 基本数据类型

Java的基本数据类型共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3； long b = 255L；的形式来定义的。如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。比如：我们同时定义：
int a=3;
int b =3;
编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。定义完a与b的值后，再令a = 4；那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

b) 对象

在Java中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。　　假设有类Rectangle定义如下：
public class Rectangle {
double width;
double height;
public Rectangle(double w,double h){
w = width;
h = height;
}
}
(1)声明对象时的内存模型
　用Rectangle rect；声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，因为它还没有引用任何"实体"。
(2)对象实例化时的内存模型
　当执行rect=new Rectangle(3,5)；时，会做两件事：　在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。返回堆内存中对象的引用（相当于首地址）给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。

c) 创建多个不同的对象实例

一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。例如：
Rectangle r1= new Rectangle(3,5);
Rectangle r2= new Rectangle(4,6);
　此时，将在堆内存中分别为两个对象的成员变量width、height分配内存空间，两个对象在堆内存中占据的空间是互不相同的。如果有：
Rectangle r1= new Rectangle(3,5);
Rectangle r2=r1;
则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。

d) 包装类

基本型别都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，如果用包装类来创建对象，就和普通对象一样了。例如：int i=0；i直接存储在栈中。 Integer i（i此时是对象） = new Integer(5)；这样，i对象数据存储在堆中，i的引用存储在栈中，通过栈中的引用来操作对象。

e) String

String是一个特殊的包装类数据。可以用用以下两种方式创建：String str = new String("abc")；String str = "abc";
第一种创建方式，和普通对象的的创建过程一样；
第二种创建方式，Java内部将此语句转化为以下几个步骤：
(1) 先定义一个名为str的对String类的对象引用变量：String str；
(2) 在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"
地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈
这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并
回o的地址。
(3) 将str指向对象o的地址。
值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种
合下，其字符串值却是保存了一个指向存在栈中数据的引用。
为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
String str1="abc"；
String str2="abc"；
System.out.println(s1==s2)；//true
注意，这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
我们再接着看以下的代码。
String str1= new String("abc")；
String str2="abc"；
System.out.println(str1==str2)；//false
创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

f) 数组

当定义一个数组，int x[]；或int []x；时，在栈内存中创建一个数组引用，通过该引用（即数组名）来引用数组。x=new int[3]；将在堆内存中分配3个保存int型数据的空间，堆内存的首地址放到栈内存中，每个数组元素被初始化为0。

g) 静态变量

用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的"固定位置"－static storage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。我们常可看到类似以下的例子来说明这个问题：
class Student{
static int numberOfStudents=0;
Student()
{
numberOfStudents++;
}
}
每一次创建一个新的Student实例时,成员numberOfStudents都会不断的递增,并且所有的Student实例都访问同一个numberOfStudents变量,实际上int numberOfStudents变量在内存中只存储在一个位置上。

5. Java的内存管理实例

Java程序的多个部分(方法，变量，对象)驻留在内存中以下两个位置：即堆和栈，现在我们只关心3类事物：实例变量，局部变量和对象：
实例变量和对象驻留在堆上
局部变量驻留在栈上
让我们查看一个java程序，看看他的各部分如何创建并且映射到栈和堆中：
public class Dog {
Collar c;
String name;
//1. main()方法位于栈上
public static void main(String[] args) {
//2. 在栈上创建引用变量d,但Dog对象尚未存在
Dog d;
//3. 创建新的Dog对象，并将其赋予d引用变量
d = new Dog();
//4. 将引用变量的一个副本传递给go()方法
d.go(d);
}
//5. 将go()方法置于栈上，并将dog参数作为局部变量
void go(Dog dog){
//6. 在堆上创建新的Collar对象，并将其赋予Dog的实例变量
c =new Collar();
}
//7.将setName()添加到栈上，并将dogName参数作为其局部变量
void setName(String dogName){
//8. name的实例对象也引用String对象
name=dogName;
}
//9. 程序执行完成后，setName()将会完成并从栈中清除，此时，局部变量dogName也会消失，尽管它所引用的String仍在堆上
}

6. 垃圾回收机制：

（问题一：什么叫垃圾回收机制？）垃圾回收是一种动态存储管理技术，它自动地释放不再被程序引用的对象，按照特定的垃圾收集算法来实现资源自动回收的功能。当一个对象不再被引用的时候，内存回收它占领的空间，以便空间被后来的新对象使用，以免造成内存泄露。（问题二：java的垃圾回收有什么特点？） JAVA语言不允许程序员直接控制内存空间的使用。内存空间的分配和回收都是由JRE负责在后台自动进行的，尤其是无用内存空间的回收操作(garbagecollection,也称垃圾回收)，只能由运行环境提供的一个超级线程进行监测和控制。（问题三：垃圾回收器什么时候会运行？）一般是在CPU空闲或空间不足时自动进行垃圾回收，而程序员无法精确控制垃圾回收的时机和顺序等。（问题四：什么样的对象符合垃圾回收条件？）当没有任何获得线程能访问一个对象时，该对象就符合垃圾回收条件。（问题五：垃圾回收器是怎样工作的？）垃圾回收器如发现一个对象不能被任何活线程访问时，他将认为该对象符合删除条件，就将其加入回收队列，但不是立即销毁对象，何时销毁并释放内存是无法预知的。垃圾回收不能强制执行，然而Java提供了一些方法（如：System.gc()方法），允许你请求JVM执行垃圾回收，而不是要求，虚拟机会尽其所能满足请求，但是不能保证JVM从内存中删除所有不用的对象。（问题六：一个java程序能够耗尽内存吗？）可以。垃圾收集系统尝试在对象不被使用时把他们从内存中删除。然而，如果保持太多活的对象，系统则可能会耗尽内存。垃圾回收器不能保证有足够的内存，只能保证可用内存尽可能的得到高效的管理。（问题七：如何显示的使对象符合垃圾回收条件？）（1）空引用：当对象没有对他可到达引用时，他就符合垃圾回收的条件。也就是说如果没有对他的引用，删除对象的引用就可以达到目的，因此我们可以把引用变量设置为null，来符合垃圾回收的条件。
StringBuffer sb = new StringBuffer("hello");
System.out.println(sb);
sb=null;
（2）重新为引用变量赋值：可以通过设置引用变量引用另一个对象来解除该引用变量与一个对象间的引用关系。
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("goodbye");
System.out.println(sb1);
sb1=sb2;//此时"hello"符合回收条件
（3）方法内创建的对象：所创建的局部变量仅在该方法的作用期间内存在。一旦该方法返回，在这个方法内创建的对象就符合垃圾收集条件。有一种明显的例外情况，就是方法的返回对象。
public static void main(String[] args) {
Date d = getDate();
System.out.println("d = " + d);
}
private static Date getDate() {
Date d2 = new Date();
StringBuffer now = new StringBuffer(d2.toString());
System.out.println(now);
return d2;
}
（4）隔离引用：这种情况中，被回收的对象仍具有引用，这种情况称作隔离岛。若存在这两个实例，他们互相引用，并且这两个对象的所有其他引用都删除，其他任何线程无法访问这两个对象中的任意一个。也可以符合垃圾回收条件。
public class Island {
Island i;
public static void main(String[] args) {
Island i2 = new Island();
Island i3 = new Island();
Island i4 = new Island();
i2.i=i3;
i3.i=i4;
i4.i=i2;
i2=null;
i3=null;
i4=null;
}
}
（问题八：垃圾收集前进行清理------finalize()方法） java提供了一种机制，使你能够在对象刚要被垃圾回收之前运行一些代码。这段代码位于名为finalize()的方法内，所有类从Object类继承这个方法。由于不能保证垃圾回收器会删除某个对象。因此放在finalize()中的代码无法保证运行。因此建议不要重写finalize();
7.    final问题：
      final使得被修饰的变量"不变"，但是由于对象型变量的本质是"引用"，使得"不变"也有了两种含义：引用本身的不变?，和引用指向的对象不变。?         引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误
引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过
可见，final只对引用的"值"(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的"值"相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。在举一个例子：
public class Name {
private String firstname;
private String lastname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}

public class Name {
private String firstname;
private String lastname;
public String getFirstname() {
return firstname;
}
public void setFirstname(String firstname) {
this.firstname = firstname;
}
public String getLastname() {
return lastname;
}
public void setLastname(String lastname) {
this.lastname = lastname;
}
}

         编写测试方法：
public static void main(String[] args) {
final Name name = new Name();
name.setFirstname("JIM");
name.setLastname("Green");
System.out.println(name.getFirstname()+" "+name.getLastname());
}
public static void main(String[] args) {
final Name name = new Name();
name.setFirstname("JIM");
name.setLastname("Green");
System.out.println(name.getFirstname()+" "+name.getLastname());
}

         理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它"永远不变"。其实那是徒劳的。         Final还有一个值得注意的地方：         先看以下示例程序：
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
         对于类变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。但是对于用final修饰的类变量，虚拟机不会为其赋予初值，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

8.    如何把程序写得更健壮：
     1、尽早释放无用对象的引用。好的办法是使用临时变量的时候，让引用变量在退出活动域后，自动设置为null，暗示垃圾收集器来收集该对象，防止发生内存泄露。对于仍然有指针指向的实例，jvm就不会回收该资源,因为垃圾回收会将值为null的对象作为垃圾，提高GC回收机制效率；
     2、定义字符串应该尽量使用 String str="hello"; 的形式，避免使用String str = new String("hello"); 的形式。因为要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
public Demo() {
s = "Initial Value";
}
}

public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
而非
s = new String("Initial Value");
s = new String("Initial Value");
     后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。

3、我们的程序里不可避免大量使用字符串处理，避免使用String，应大量使用StringBuffer ，因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象，请看下列代码；
String s = "Hello";
s = s + " world!";
String s = "Hello";
s = s + " world!";
       在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。         通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
     4、尽量少用静态变量，因为静态变量是全局的，GC不会回收的；
     5、尽量避免在类的构造函数里创建、初始化大量的对象，防止在调用其自身类的构造器时造成不必要的内存资源浪费，尤其是大对象，JVM会突然需要大量内存，这时必然会触发GC优化系统内存环境；显示的声明数组空间，而且申请数量还极大。         以下是初始化不同类型的对象需要消耗的时间：

运算操作
示例
标准化时间

本地赋值
i = n
1.0

实例赋值
this.i = n
1.2

方法调用
Funct()
5.9

新建对象
New Object()
980

新建数组
New int[10]
3100

从表1可以看出，新建一个对象需要980个单位的时间，是本地赋值时间的980倍，是方法调用时间的166倍，而新建一个数组所花费的时间就更多了。
     6、尽量在合适的场景下使用对象池技术以提高系统性能，缩减缩减开销，但是要注意对象池的尺寸不宜过大，及时清除无效对象释放内存资源，综合考虑应用运行环境的内存资源限制，避免过高估计运行环境所提供内存资源的数量。
     7、大集合对象拥有大数据量的业务对象的时候，可以考虑分块进行处理，然后解决一块释放一块的策略。
     8、不要在经常调用的方法中创建对象，尤其是忌讳在循环中创建对象。可以适当的使用hashtable，vector 创建一组对象容器，然后从容器中去取那些对象，而不用每次new之后又丢弃。
     9、一般都是发生在开启大型文件或跟数据库一次拿了太多的数据，造成 Out Of Memory Error 的状况，这时就大概要计算一下数据量的最大值是多少，并且设定所需最小及最大的内存空间值。
     10、尽量少用finalize函数，因为finalize()会加大GC的工作量，而GC相当于耗费系统的计算能力。
    11、不要过滥使用哈希表，有一定开发经验的开发人员经常会使用hash表（hash表在JDK中的一个实现就是HashMap）来缓存一些数据，从而提高系统的运行速度。比如使用HashMap缓存一些物料信息、人员信息等基础资料，这在提高系统速度的同时也加大了系统的内存占用，特别是当缓存的资料比较多的时候。其实我们可以使用操作系统中的缓存的概念来解决这个问题，也就是给被缓存的分配一个一定大小的缓存容器，按照一定的算法淘汰不需要继续缓存的对象，这样一方面会因为进行了对象缓存而提高了系统的运行效率，同时由于缓存容器不是无限制扩大，从而也减少了系统的内存占用。现在有很多开源的缓存实现项目，比如ehcache、oscache等，这些项目都实现了FIFO、MRU等常见的缓存算法

关键词：JAVA 内存转帖

posted @ 2011-05-18 20:58 jadmin 阅读(104) | 评论 (0) | 编辑收藏

程序员->订制自己的职业规划之路

从开始编程到现在已经有10年的时间了，10年之间我做过很多的工作，当然都称不上卓越，我虚度光阴，过一天就算一天。在深圳呆了6个年头后，我才发现事情的严重性，作为一名软件开发工程师，我一事无成，我还没有一个身经百战的团队或team,没有一个能拿的出手，又有知名度的软件产品，经常与印度程序员交流，却连国门都没有迈出去过。

于是在今天这个飘雨的周末的黄昏，内力莫名的涌出一阵阵地懊悔，世界不会因为我没有完成代码而停滞不前，地球依然在转动，我讨厌这种感觉，这让我觉得我的存在毫无意义。中国的人太多，程序员太多，如果你想变的卓越出众，那么你就必须相信你所做的事情正在推动整个世界的发展，同时你也必须付出比别人更多的努力。所以今天我在我的愚人笔记博客里，新建了一个专栏，程序人生，开始回顾和记录我程序的生涯的点点滴滴，拿出来跟各位朋友分享，也希望各位程序员朋友们，不要再我摔过的地方倒下；不要再我迷茫的地方浪费时光；更不要在我们所热爱的这个行业里，也和我一样变的一事无成。我觉得每个人都有自己的卓越之处，只是在懵懂中没有找到打开心中那扇石门的钥匙，希望我的程序人生，能抛砖引玉帮大家找到那把钥匙。

下海做程序员的第一步也是最重要的一部，如何订制自己的程序之路。
很多人在一谈到自己的计划的时候，都会去看看别人是怎么做的，一味的跟随别人的规划，多少岁之前做coder,多少岁之前做manager.其实每个人都有自己的特点，你应该停下来好好的审视自己的职业，不要跟着别人的路去走了，你应该知道自己要何去何从.

我们的职业之路要怎么制定呢？毕竟程序员是一门职业，作为软件的开发人员，我们就是一个从事某一个职业的工人，公司雇佣我们，绝对不是因为公司爱我们。虽然天天公司教导我们“公司我是家”但是深圳的住房公积金，公司的交的那部分，还是转嫁给我们自己承担。事实上，公司以前从没有爱过我吗，将来也绝对不会。公司是你自己的那就另当别论了，否则，程序员就不是一个职业了，职业不就每天要我们去一个地方，呆上8个或者更多的小时，牺牲大量的脑细胞或者汗水，然后领取报酬吗？职业就是生意，把我们做的生意说的惨淡点，就是出卖自己i的劳动力，换钱，再高级的白领也是如此。当然做生意有赚有亏得，想要在这个行业里面成为佼佼者，那就是必须要知道自己应该如何去做这门生意，如何为自己创造利润？

如果把你的职业人生想象成为一个你正在开发的软件产品的生命周期，现在你的所有需求都已经明确（有车，有房，有钱，有公司等等），接下来我们就要开始职业人生的设计了，在制定这个规划的时候，我们要重要的注意以下4个方面的内容，这个四个方面运用到整个人职业的生命周期中。

一、选择市场

一定要谨慎的挑选你要关注的技术和商业领域。如何权衡风险和收益？
都是做软件开发，你究竟要做与硬件相关的还是与网络相关的？与手机相关的还是与汽车相关的？每一个分支都有专家和权威，你要确认自己想站在哪一个分支的顶点。在深圳很多程序员，为了生存，先入行再转行。程序员需要积累，面试官不喜欢一张白纸上满是编程理念的空头支票。

二、投资

做生意哪有不投资就赚钱的好事，你的知识和技术就是你这件生意的基础。所以你要在这两个方面合理的投资，时间，金钱。只知道在理论上使用VB或者Java已经远远不够了，那么在新的环境下，新的平台下，又有哪些新的技术你应该具备的呢？

三、执行力

用我老板的话来说单纯有技术出色的员工，并不能给公司带来利益。员工必须要有产出才行。有的时候一名优秀的员工产出远远不及一名普通的员工，反而有时候会让简单的事情变的一团糟糕，2分钟一个简单的算法，被花上2天时间提高0.001%的效率这种事情也是经常发生的。所以我们应该考虑的是能否创造最有利的价值而不是完美,

四、团队

程序员孤军奋战成不了大事。一个再优秀的程序员也完成不了整个windows操作系统的工作，虽然我见过一个人是可以独立完成破解windows的工作的。所以如果不想过于孤单和山寨，请找到一支正规军加入他们。

五、又是市场

你们肯定会说，你开始写循环了是吧？怎么又是市场？
一个人选对了市场，投资技术，有了回报，有了产出，有了自己的团队，恭喜你，你离出产品的日子不远了。但是你有没有考虑一下你的产品的市场，若是无人知晓，毫无用途，又怎么会有利润呢？你的成绩又怎么会被老板和同行认可呢？请记住：一个团队奋斗了1个月写出来一个：Hello world！是赚不了钱的。

到这一节结尾的时候了，写几句鼓励的话，鼓励一下自己和大家：如果你要做一名优秀的软件工程师，请绝对不要萎靡不振，也不要毫无成果的去寻找工作，因为有很多跟你一样的人，因为努力成功了，所以你也不要担心，请相信自己一定会成功，没事多写写代码，或者来我的博客逛逛，这样就不会感到恐惧了。

关键词：程序员职业规划软件工程师转帖

posted @ 2011-05-18 12:58 jadmin 阅读(92) | 评论 (0) | 编辑收藏

乐观锁和悲观锁

1、悲观锁，正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。

2、乐观锁（ Optimistic Locking ）
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。
而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

posted @ 2011-05-18 12:51 jadmin 阅读(108) | 评论 (0) | 编辑收藏

微笑是一种修养

　　生活并没有拖欠我们任何东西，所以没有必要总苦着脸。应对生活充满感激，至少，它给了我们生命，给了我们生存的空间。

　　微笑是对生活的一种态度，跟贫富，地位，处境没有必然的联系。一个富翁可能整天忧心忡忡，而一个穷人可能心情舒畅：一位残疾人可能坦然乐观；一位处境顺利的人可能会愁眉不展，一位身处逆境的人可能会面带微笑……

　　一个人的情绪受环境的影响，这是很正常的，但你苦着脸，一副苦大仇深的样子，对处境并不会有任何的改变，相反，如果微笑着去生活，那会增加亲和力，别人更乐于跟你交往，得到的机会也会更多。

　　只有心里有阳光的人，才能感受到现实的阳光，如果连自己都常苦着脸，那生活如何美好？生活始终是一面镜子，照到的是我们的影像，当我们哭泣时，生活在哭泣，当我们微笑时，生活也在微笑。

　　微笑发自内心，不卑不亢，既不是对弱者的愚弄，也不是对强者的奉承。奉承时的笑容，是一种假笑，而面具是不会长久的，一旦有机会，他们便会除下面具，露出本来的面目。

　　微笑没有目的，无论是对上司，还是对门卫，那笑容都是一样，微笑是对他人的尊重，同时是对生活的尊重。微笑是有"回报"的，人际关系就像物理学上所说的力的平衡，你怎样对别人，别人就会怎样对你，你对别人的微笑越多，别人对你的微笑也会越多。

　　在受到别人的曲解后，可以选择暴怒，也可以选择微笑，通常微笑的力量会更大，因为微笑会震撼对方的心灵，显露出来的豁达气度让对方觉得自己渺小，丑陋。

　　清者自清，浊者自浊。有时候过多的解释、争执是没有必要的。对于那些无理取闹、蓄意诋毁的人，给他一个微笑，剩下的事就让时间去证明好了。

　　当年，有人处处说爱因斯坦的理论错了，并且说有一百位科学家联合作证，爱因斯坦知道了这件事，只是淡淡的笑了笑，说，一百位？要这么多人？只要证明我真的错了，一个人出面便行了。

　　爱因斯坦的理论经历了时间的考验，而那些人却让一个微笑打败了。

　　微笑发自内心，无法伪装。保持“微笑”的心态，人生会更加美好。人生中有挫折有失败，有误解，那是很正常的，要想生活中一片坦途，那么首先就应清除心中的障碍。微笑的实质便是爱，懂得爱的人，一定不会是平庸的。

　　微笑是人生最好的名片，谁不希望跟一个乐观向上的人交朋友呢？微笑能给自己一种信心，也能给别人一种信心，从而更好地激发潜能。

　　微笑是朋友间最好的语言，一个自然流露的微笑，胜过千言万语，无论是初次谋面也好，相识已久也好，微笑能拉近人与人之间的距离，另彼此之间倍感温暖。

　　微笑是一种修养，并且是一种很重要的修养，微笑的实质是亲切，是鼓励，是温馨。真正懂得微笑的人，总是容易获得比别人更多的机会，总是容易取得成功。

posted @ 2010-09-10 13:01 jadmin 阅读(97) | 评论 (0) | 编辑收藏

SLF4J

一、介绍：
简单日记门面(simple logging Facade for java)SLF4J是为各种loging APIs提供一个简单统一的
接口，从而使得最终用户能够在部署的时候配置自己希望的loging APIs实现。 Logging API实现既可以
选择直接实现SLF4J接的loging APIs如： NLOG4J、SimpleLogger。也可以通过SLF4J提供的API实现
来开发相应的适配器如Log4jLoggerAdapter、JDK14LoggerAdapter。在SLF4J发行版本中包含了几个
jar包，如slf4j-nop.jar, slf4j-simple.jar, slf4j-log4j12.jar, slf4j-log4j13.jar,
slf4j-jdk14.jar and slf4j-jcl.jar通过这些jar文件可以使编译期与具体的实现脱离。或者说可以
灵活的切换

二、官方站点
官方的网站：http://www.slf4j.org/manual.html
三、为何使用slf4j?
我们在开发过程中可能使用各种log，每个Log有不同的风格、布局，如果想灵活的切换那么slf4j是比较好的
选择。

四、如何使用slf4j
下边一段程序是经典的使用slf4j的方法.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Wombat {
    final Logger logger = LoggerFactory.getLogger(Wombat.class);
    Integer t;
    Integer oldT;
    public void setTemperature(Integer temperature) {
        oldT = t;
        t = temperature;
        logger.error("Temperature set to {}. Old temperature was {}.", t, oldT);
        if (temperature.intValue() > 50) {
            logger.info("Temperature has risen above 50 degrees.");
        }
    }
    public static void main(String[] args) {
        Wombat wombat = new Wombat();
        wombat.setTemperature(1);
        wombat.setTemperature(55);
    }
}

下边介绍一下运行上边程序的过程。
1,编译上边的程序，需要classpath中加入slf4j-api-1.4.1.jar文件
2,运行时，需要classpath中加上slf4j-simple-1.4.1.jar
运行得到结果:
----------------------------
0 [main] ERROR Wombat - Temperature set to 1. Old temperature was null.
0 [main] ERROR Wombat - Temperature set to 55. Old temperature was 1.
0 [main] INFO Wombat - Temperature has risen above 50 degrees.
这个是simple log风格，

3,切换：如果想切换到jdk14的log的风格，只需要把slf4j-simple-1.4.1.jar
从classpath中移除，同时classpath中加入slj4j-jdk14-1.4.1.jar
这时的运行结果:
---------------------------------------------------
2007-7-9 10:40:15 Wombat setTemperature
严重: Temperature set to 1. Old temperature was null.
2007-7-9 10:40:16 Wombat setTemperature
严重: Temperature set to 55. Old temperature was 1.
2007-7-9 10:40:16 Wombat setTemperature
信息: Temperature has risen above 50 degrees.
已经变成jdk14的log风格了。
4,再次切换到log4j
同样移除slj4j-jdk14-1.4.1.jar，加入slf4j-log4j12-1.4.1.jar，同时加入log4j-1.2.x.jar
加入log4j.properties。得到显示结果:
---------------------------------------
10:42:27,328 ERROR Wombat: Temperature set to 1. Old temperature was null.
10:42:27,328 ERROR Wombat: Temperature set to 55. Old temperature was 1.
10:42:27,328 INFO Wombat: Temperature has risen above 50 degrees.
在不同的风格中切换只需要在部署期切换类库就可以了，和开发时无关。

posted @ 2010-08-17 23:52 jadmin 阅读(95) | 评论 (0) | 编辑收藏

十条不错的编程观点

在Stack Overflow上有这样的一个贴子《What’s your most controversial programming opinion?》，翻译成中文就是“你认为最有争议的编程观点是什么？”，不过，在400多个主回贴，以及千把个子回贴中，好像并不是很有争议，而是令人相当的茅塞顿开，下面罗列一些，并通过我自己的经历和理解发挥了一些，希望对你有帮助。

1） The only “best practice” you should be using all the time is “Use Your Brain”.

唯一的“Best Practice”并不是使用各种各样被前人总结过的各种设计方法、模式，框架，那些著名的方法、模式、框架只代码赞同他们的人多，并不代表他们适合你，你应该更多的去使用你的大脑，独立地思考那些方法、模式、框架出现的原因和其背后的想法和思想，那才是“best practice”。事实上来说，那些所谓的“Best Practice”只不过是限制那些糟糕的程序员们的破坏力。

2）Programmers who don’t code in their spare time for fun will never become as good as those that do.

如果你对编程没有感到一种快乐，没有在你空闲的时候去以一种的轻松的方式去生活，无论是编程，还是运动，还是去旅游，只要你在没有从中感到轻松和愉快，那么你只不过是在应付它们。而你无时无刻不扎在程序堆中，这样下来，就算是你是一个非常聪明，非常有才华的人，你也不会成为一个优秀的编程员，要么只会平平凡凡，要么只会整天扎在技术中成为书呆子。当然，这个观点是有争议，热情和能力的差距也是很大的。不过我们可以从中汲取其正面的观点。

3）Most comments in code are in fact a pernicious form of code duplication.

注释应该是注释Why，而不是How和What，参看《惹恼程序员的十件事》，代码告诉你How，而注释应该告诉你Why。但大多数的程序并不知道什么是好的注释，那些注释其实和code是重复的，毫无意义。

4）XML is highly overrated

XML可能被高估了。XML对于Web上的应用是不错的，但是我们把其用到了各种地方，好像没有XML，我们都不会编程了。

5）Not all programmers are created equal

这是那些junior经理或是流程爱犯的错，他们总是认为，DeveloperA == DeveloperB，只要他们的title一样，他们以为他们的能力、工作速度、解决问题的方法，掌握的技能等等都是一样的。呵呵。更扯的是，在某些时候，就算是最差的程序员，因为Title，他们也会认为其比别人强十倍，这就是很表面的愚蠢的管理。

6）”Googling it” is okay!

不可否认，查找知识是一种能力。但Google只会给你知识，并不会教给你技能。那里只有“鱼”，没有“渔”，过度的使用Google，只会让你越来越离不开他，你越来越需要要它立马告诉你答案，而你越来越不会自己去思考，自己去探索，去专研。如果KFC快餐是垃圾食品对我们的身体没有好处，那么使用Google也一种快餐文化对我们的智力发展大大的没有好处。因为我们过度地关注了答案，而不是寻找答案的技术和过程。

7）If you only know one language, no matter how well you know it, you’re not a great programmer.

如果你只懂一种语言，准确的说，如果你只懂一类语类，如：Java和C#，PHP和Perl，那么，你将会被局限起来，只有了解了各种各样的语言，了解了不同语言的不同方法，你才会有比较，只有了比较，你才会明白各种语言的长处和短处，才会让你有更为成熟的观点，而且不整天和别的程序在网上斗嘴争论是Windows好还是Unix好，是C好还是C++好，有这点工夫能干好多事了。世界因为不同而精彩，只知道事物的一面是有害的。

8）Your job is to put yourself out of work.

你的工作不是保守，那种教会徒弟，饿死师父的想法，不但是相当短浅的，而且还是相当脑残的。因为，在计算机世界里，你掌握的老技术越多，你就越没用，因为技术更新的太快。你对工作越保守，这个工作就越来越离不开你，你就越不越不能抽身去学新的东西，你也就越来越OUT了。记住：If you can’t be replaced then you can’t be promoted!

9）Design patterns are hurting good design more than they’re helping it.

很多程序员把设计模式奉为天神，他们过度的追求设计模式以至都都忘了需求是什么，结果整个系统设计被设计模式搞得乱七八糟，我们叫这种编程为“设计模式驱动编程”，正如第一点所说，如果你不懂得用自己的大脑思考的话，知其然，不知所以然的话，那么你不但得不到其好处，反而受其所累。

10）Unit Testing won’t help you write good code

其实，unit test 的主要目的是，为了防止你不会因为一个改动而引入Bug，但这并不会让你能写出更好的代码。这只会让你写出不会出错的代码。同第一点，这样的方法，只不过是防止糟糕的程序员，而并不是让程序员或代码质量更有长进。反而，程序员通常会借用“通过Unit Test”来为自己代码做辩解，而此时，Unit Test Report成了一种托辞。

最后，顺便说一下，以前去那个敏捷的公司面试，发现那个公司的某些技术人员中毒不浅，具体表现在上述的1）9）10）观点上，过份地迷信了best practice，Design Patterns和Unit Testing。

posted @ 2010-07-23 12:47 jadmin 阅读(86) | 评论 (0) | 编辑收藏

Tomcat6环境JBPM4.3报错：java.lang.ClassNotFoundException: de.odysseus.el.util.SimpleResolver

Requirements

JUEL requires Java 5 or later.

加入juel.jar

-------------------------
I think I get same problem when trying to integrate JBPM4 into my app. And I find out why.
Because you're using Tomcat 6.0... The lib el-api.jar in %tomcat_home%/lib conflicts with juel.jar, which exists in %jbpm4_home%/lib.

juel: <http://juel.sourceforge.net/> You will find the 2 jars define the same api for javax/el/ExressionFactory.

The solution is that you use Tomcat 5.5 instead of Tomcat 6.0. Because tomcat 5.5 uses commons-el.jar (Tomcat5.5/common/lib)

Or you can still use Tomcat 6.0, but you must replace el-api.jar with juel.jar. And don't forget to remove juel.jar from your app lib(A duplicate import, if you don't remove).

Try it!

---------------------------------------------------------
解决：删掉tomcat6的el.jar，加入juel.jar,juel-impl.jar,juel-engine.jar

posted @ 2010-07-21 17:40 jadmin 阅读(1454) | 评论 (0) | 编辑收藏

在欲而无欲，居尘不染尘

　　僧人竺法深在东晋简文帝处作客，刘尹问：「法师是学道之人，为什么要来官宦之门中走动？」竺法深回答说：「你自见这是朱门高第，在贫道眼里，同走在茅屋草舍间并无任何差别。」
　　法师的境界，是繁华阅尽后的云淡风清，是滚滚红尘里的淡定从容。
　　人生的浮浮沉沉，欲望乃是最大的滥殇。它可以是推动你向上的一股力量，也可以是主宰你堕落的源头。生命如此短暂，有所营谋，必有所烦恼；有所执着，必有所束缚；有所得，必有所失。生前的显赫富贵，终究是些过眼烟云。如果为此穷尽一生，岂非本末倒置？
　　人生在世，要活得很自在，才会幸福。不能控制欲望的人，当然就得不到安详。我们如果能在每一刹那，自我观照，自我控制，长养智慧与安详。没有忧虑、没有恐惧、没有攀缘，离开一切执着，则能拥有统一和谐的心灵，幸福也就掌握在你的手中。

posted @ 2010-07-11 12:22 jadmin 阅读(104) | 评论 (0) | 编辑收藏

人生淡如菊花

　　人的一生是要经历许多阶段的，比如说纯真无邪的少年时代，激情如火的青春岁月，厚重沉稳的中年时期，从容淡定的人生暮年。每个时候都有独特的风景，每段岁月都会给人不同的感受。可进入中年的她，突然间感觉自己，就一下从躁动中宁静下来了，不经意间就有了种坐看云起云舒，我自心境如水的超然。

　　她感到在无意中，一切都漫漫地淡下来了，常常会挂着淡淡的微笑，给人一种和谐温馨之感；常常看淡名利和物质，却看重人与人之间的感情，常常不会冲动行事，也不会轻易后悔，她会为自己的决定负责。可当她一旦爱上一个人，一定会坚守自己的那份爱，爱情的保质期是“永远”。

　　她还会在秋阳明丽的早晨或午后为自己沏一壶香茗，手捧一本书细细品位，慢慢欣赏。她懂得什么是智性美，她更愿意在闲暇的时候去学习书法音乐美术，或者去充电接受最新的科技知识，来提高自己的修养和品位，她不会把时间浪费在世俗的纷争和无聊的麻将中，更不会和别人去攀比高档名牌的服饰和虚荣的炫耀，她知道真正的美丽一定是由内而外散发出来的。

　　可是她也记得不久前还在为工作上的事烦恼不已，什么上司不赏识呀，工作业绩不突出啦，还有同事之间不服气了，等等，等等，整个身心陷进了争强好胜的泥沼里，苦苦挣扎，不能释怀，可是到了中年一切就都云开日出了，不是不努力工作，只是觉得自己尽力就问心无愧了，至于结果就不会去过多考虑了，这样反而同事之间的关系和谐了，人的精神就愉快了，心胸也宽广了。

　　她也有曾经陷入爱恋中不能自拔的时候。那时，在热恋中痛苦，因为怕失去，所以猜忌怀疑，无事生非，互相折磨；在失恋中更痛苦，因为无所依傍，所以孤独寂寞，痛不欲生，自我戕害。可是到了人生的这个时期，不管是热恋也好，失恋也罢，都能平静地对待，诗意的化解。不是说心如止水，情如枯井，而是能理智地看待，睿智地经营，这样使情爱更彰显出深沉含蓄之美，情深意切之境。让相爱的双方没有压力，更能享受爱本身给人带来的快乐。

　　她想每个人的一生中的某个阶段是需要某种热闹的，那时侯饱涨的生命力需要向外奔突，就象急湍的河流一样。但一个人不能永远停留在这个阶段。经过了激烈的撞击之后，生命就来到了一块开阔的谷地，汇蓄成了一片浩瀚的的湖泊。这时就会变得异常的平和宁静，这种脱离了世俗的宁静，是以丰富的精神内涵为依傍的。它是一种超脱，一种繁华落尽见真情的纯粹，一种精神的升华。托尔斯泰曾经说过：“随着年岁增长，我的生命越来越精神化了”。说的就是这样的感触。

　　人淡如菊，就是一种丰富的精神安静。具有这种品格的人，能够浸润在风晨雨夕，面对着阶柳庭花，听得到自然的呼吸，感受得到自然的脉搏。这时，斗室便是八极，内心顿成宇宙；这时，精神就会富有，心胸就会博大；这时，便拥有了一份澄明清澈，一份从容淡定。人生就从此不寂寞了。

posted @ 2010-06-29 23:37 jadmin 阅读(124) | 评论 (0) | 编辑收藏

常用链接

留言簿(1)

随笔档案(496)

搜索

最新评论

阅读排行榜

评论排行榜

引言

前提和设计目标

硬件错误

流式数据访问

大规模数据集

简单的一致性模型

“移动计算比移动数据更划算”

异构软硬件平台间的可移植性

Namenode 和 Datanode

文件系统的名字空间 (namespace)

数据复制

副本存放: 最最开始的一步

副本选择

安全模式

文件系统元数据的持久化

通讯协议

健壮性

磁盘数据错误，心跳检测和重新复制

集群均衡

数据完整性

元数据磁盘错误

快照

数据组织

数据块

Staging

流水线复制

可访问性

DFSShell

DFSAdmin

浏览器接口

存储空间回收

文件的删除和恢复

减少副本系数

参考资料

单库单表

单库多表

多库多表

分库分表规则

路由

分库分表产生的问题，及注意事项

一主多备