亚洲国产精品成人综合久久久,亚洲天堂在线播放,国产成人精品亚洲2020

ID刀 — Thu, 05 Mar 2009 08:06:00 GMT

　�q�接池中到底应该攄��多少�q�接�Q�才能�ɾpȝ��的性能最佻I��pȝ��可采取设�|�最��连接数�Q�minConn�Q�和最大连接数�Q�maxConn�Q�来控制�q�接池中的连接。最��连接数是系�l�启动时�q�接池所创徏的连接数。如果创��多，则系�l�启动就慢，但创建后�pȝ��的响应速度会很快；如果创徏�q�少�Q�则�pȝ��启动的很快，响应��h��却慢。这��P��可以在开发时�Q�设�|�较��的最��连接数�Q�开发�v来会快，而在�pȝ��实际使用时设�|�较大的�Q�因��样对讉K��客户来说速度会快些。最大连接数是连接池中允许连接的最大数目，具体讄��多少�Q�要看系�l�的讉K��量，可通过反复��试�Q�找到最佳点�?

　　如何��保�q�接池中的最��连接数呢？有动态和静态两�U�策略。动态即每隔一定时间就对连接池�q�行��，如果发现�q�接数量��于最��连接数�Q�则补充相应数量的新�q�接,以保证连接池的正常运转。静态是发现�I�闲�q�接不够时再��L��查�?br /> �q�接池的实现

　　1、连接池模型

　　本文讨论的连接池包括一个连接池�c�（DBConnectionPool�Q�和一个连接池��理�c�（DBConnetionPoolManager�Q�和一个配�|�文件操作类(ParseDSConfig)。连接池�c�L��Ҏ��一数据�?/u>所有连接的“�~�冲�?#8221;�Q�主要实��C��下功能：①从�q�接池获取或创徏可用�q�接�Q�②使用完毕之后�Q�把�q�接�q�还�l�连接池�Q�③在系�l�关闭前�Q�断开所有连接�ƈ释放�q�接占用的系�l�资源；④还能够处理无效�q�接�Q�原来登��Cؓ可用的连接，�׃��某种原因不再可用�Q�如��时�Q�通讯问题�Q�，�q�能够限制连接池中的�q�接��L��不低于某个预定值和不超�q�某个预定倹{�?5)当多数据库时,且数据库是动态增加的�?��会加到配置文�g中�?/div>

　　�q�接池管理类是连接池�cȝ��外覆�c�（wrapper�Q?�W�合单例模式�Q�即�pȝ��中只能有一个连接池��理�cȝ��实例。其主要用于对多个连接池对象的管理，��h��以下功能�Q�①装蝲�q�注册特定数据库的JDBC驱动�E�序�Q�②�Ҏ��属性文件给定的信息�Q�创��接池对象�Q�③为方便管理多个连接池对象�Q��ؓ每一个连接池对象取一个名字，实现�q�接池名字与其实例之间的映射�Q�④跟踪客户使用�q�接情况�Q�以侉K��要是关闭�q�接释放资源。连接池��理�cȝ��引入主要是�ؓ了方便对多个�q�接池的使用和管理，如系�l�需要连接不同的数据库，或连接相同的数据库但�׃��安全性问题，需要不同的用户使用不同的名�U�和密码�?br />          2、连接池实现(�l�过本�h改版,可以适用多数据库�c�d��的应用以及一�U�数据库�c�d��多个数据库且数据库的数量可以动态增加的应用�E�序)
         1),DBConnectionPool.java   数据库连接池�c?br />          2),DBConnectionManager .java   数据库管理类
         3),DSConfigBean .java                单个数据库连接信息Bean
         4),ParseDSConfig.java                操作�?�q�个'�?包括不同的数据库和同一�U�数据库有多个数据库)
                                                            数据配置文�gxml
         5),ds.config.xml                           数据库配�|�文件xml
         原代码如�?
        DBConnectionPool.java
        ----------------------------------------------------------
      /**
* 数据库连接池�c?br /> */
package com.chunkyo.db;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Timer;

/**
* @author chenyanlin
*
*/
public class DBConnectionPool implements TimerListener {

private Connection con=null;
private int inUsed=0;    //使用的连接数
private ArrayList freeConnections = new ArrayList();//容器�Q�空闲连�?br /> private int minConn;     //最��连接数
private int maxConn;     //最大连�?br /> private String name;     //�q�接池名�?br /> private String password; //密码
private String url;      //数据库连接地址
private String driver;   //驱动
private String user;     //用户�?br /> public Timer timer;      //定时
/**
*
*/
public DBConnectionPool() {
  // TODO Auto-generated constructor stub
}
/**
* 创徏�q�接�?br /> * @param driver
* @param name
* @param URL
* @param user
* @param password
* @param maxConn
*/
public DBConnectionPool(String name, String driver,String URL, String user, String password, int maxConn)
{
  this.name=name;
  this.driver=driver;
  this.url=URL;
  this.user=user;
  this.password=password;
  this.maxConn=maxConn;
}
/**
* 用完�Q�释放连�?br /> * @param con
*/
public synchronized void freeConnection(Connection con)
{
  this.freeConnections.add(con);//��d��到空闲连接的末尾
  this.inUsed--;
}
/**
* timeout �Ҏ��timeout得到�q�接
* @param timeout
* @return
*/
public synchronized Connection getConnection(long timeout)
{
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   if(con==null)con=getConnection(timeout); //�l�箋获得�q�接
  }
  else
  {
   con=newConnection(); //新徏�q�接
  }
  if(this.maxConn==0||this.maxConn   {
   con=null;//辑ֈ�最大连接数�Q�暂时不能获得连接了�?br />   }
  if(con!=null)
  {
   this.inUsed++;
  }
  return con;
}
/**
*
* 从连接池里得到连�?br /> * @return
*/
public synchronized Connection getConnection()
{
  Connection con=null;
  if(this.freeConnections.size()>0)
  {
   con=(Connection)this.freeConnections.get(0);
   this.freeConnections.remove(0);//如果�q�接分配出去了，��׃��I�闲�q�接里删�?br />    if(con==null)con=getConnection(); //�l�箋获得�q�接
  }
  else
  {
   con=newConnection(); //新徏�q�接
  }
  if(this.maxConn==0||this.maxConn   {
   con=null;//�{�待 ��过最大连接时
  }
  if(con!=null)
  {
   this.inUsed++;
   System.out.println("得到　"+this.name+"　的连接，现有"+inUsed+"个连接在使用!");
  }
  return con;
}
/**
*释放全部�q�接
*
*/
public synchronized void release()
{
  Iterator allConns=this.freeConnections.iterator();
  while(allConns.hasNext())
  {
   Connection con=(Connection)allConns.next();
   try
   {
    con.close();
   }
   catch(SQLException e)
   {
    e.printStackTrace();
   }

  }
  this.freeConnections.clear();

}
/**
* 创徏新连�?br /> * @return
*/
private Connection newConnection()
{
  try {
   Class.forName(driver);
   con=DriverManager.getConnection(url, user, password);
  } catch (ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   System.out.println("sorry can't find db driver!");
  } catch (SQLException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
   System.out.println("sorry can't create Connection!");
  }
  return con;

}
/**
* 定时处理函数
*/
public synchronized void TimerEvent()
{
     //暂时�q�没有实��C��后会加上�?br /> }

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}
/**
* @return the driver
*/
public String getDriver() {
  return driver;
}
/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
  this.driver = driver;
}
/**
* @return the maxConn
*/
public int getMaxConn() {
  return maxConn;
}
/**
* @param maxConn the maxConn to set
*/
public void setMaxConn(int maxConn) {
  this.maxConn = maxConn;
}
/**
* @return the minConn
*/
public int getMinConn() {
  return minConn;
}
/**
* @param minConn the minConn to set
*/
public void setMinConn(int minConn) {
  this.minConn = minConn;
}
/**
* @return the name
*/
public String getName() {
  return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
  this.name = name;
}
/**
* @return the password
*/
public String getPassword() {
  return password;
}
/**
* @param password the password to set
*/
public void setPassword(String password) {
  this.password = password;
}
/**
* @return the url
*/
public String getUrl() {
  return url;
}
/**
* @param url the url to set
*/
public void setUrl(String url) {
  this.url = url;
}
/**
* @return the user
*/
public String getUser() {
  return user;
}
/**
* @param user the user to set
*/
public void setUser(String user) {
  this.user = user;
}

}

-------------------------------------------
DBConnectionManager .java
------------------------------------------
/**
* 数据库连接池��理�c?br /> */
package com.chunkyo.db;

import java.sql.Connection;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;

import com.chunkyo.db.ParseDSConfig;
import com.chunkyo.db.DSConfigBean;
import com.chunkyo.db.DBConnectionPool;

/**
* @author chenyanlin
*
*/
public class DBConnectionManager {

static private DBConnectionManager instance;//唯一数据库连接池��理实例�c?br /> static private int clients;                 //客户�q�接�?br /> private Vector drivers = new Vector();//驱动信息
private Hashtable pools=new Hashtable();//�q�接�?br />
/**
* 实例化管理类
*/
public DBConnectionManager() {
  // TODO Auto-generated constructor stub
  this.init();
}
/**
* 得到唯一实例��理�c?br /> * @return
*/
static synchronized public DBConnectionManager getInstance()
{
  if(instance==null)
  {
   instance=new DBConnectionManager();
  }
  return instance;

}
/**
* 释放�q�接
* @param name
* @param con
*/
public void freeConnection(String name, Connection con)
{
  DBConnectionPool pool=(DBConnectionPool)pools.get(name);//�Ҏ��关键名字得到�q�接�?br />   if(pool!=null)
  pool.freeConnection(con);//释放�q�接
}
/**
* 得到一个连接根据连接池的名字name
* @param name
* @return
*/
public Connection getConnection(String name)
{
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中获取�q�接�?br />   con=pool.getConnection();//从选定的连接池中获得连�?br />   if(con!=null)
  System.out.println("得到�q�接。。�?);
  return con;
}
/**
* 得到一个连接，�Ҏ��q�接池的名字和等待时�?br /> * @param name
* @param time
* @return
*/
public Connection getConnection(String name, long timeout)
{
  DBConnectionPool pool=null;
  Connection con=null;
  pool=(DBConnectionPool)pools.get(name);//从名字中获取�q�接�?br />   con=pool.getConnection(timeout);//从选定的连接池中获得连�?br />   System.out.println("得到�q�接。。�?);
  return con;
}
/**
* 释放所有连�?br /> */
public synchronized void release()
{
  Enumeration allpools=pools.elements();
  while(allpools.hasMoreElements())
  {
   DBConnectionPool pool=(DBConnectionPool)allpools.nextElement();
   if(pool!=null)pool.release();
  }
  pools.clear();
}

/**
* 创徏�q�接�?br /> * @param props
*/
private void createPools(DSConfigBean dsb)
{
  DBConnectionPool dbpool=new DBConnectionPool();
  dbpool.setName(dsb.getName());
  dbpool.setDriver(dsb.getDriver());
  dbpool.setUrl(dsb.getUrl());
  dbpool.setUser(dsb.getUsername());
  dbpool.setPassword(dsb.getPassword());
  dbpool.setMaxConn(dsb.getMaxconn());
  System.out.println("ioio:"+dsb.getMaxconn());
  pools.put(dsb.getName(), dbpool);
}
/**
* 初始化连接池的参�?br /> */
private void init()
{
  //加蝲驱动�E�序
  this.loadDrivers();
  //创徏�q�接�?br />   Iterator alldriver=drivers.iterator();
  while(alldriver.hasNext())
  {
   this.createPools((DSConfigBean)alldriver.next());
   System.out.println("创徏�q�接池。。�?);

  }
  System.out.println("创徏�q�接池完毕。。�?);
}

/**
* 加蝲驱动�E�序
* @param props
*/
private void loadDrivers()
{
  ParseDSConfig pd=new ParseDSConfig();
//��d��数据库配�|�文�?br />   drivers=pd.readConfigInfo("ds.config.xml");
  System.out.println("加蝲驱动�E�序。。�?);
}
/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub

}

}
----------------------------------------
DSConfigBean.java
----------------------------------------
/**
* 配置文�gBean�c?br /> */
package com.chunkyo.db;

/**
* @author chenyanlin
*
*/
public class DSConfigBean {

private String type =""; //数据库类�?br /> private String name =""; //�q�接池名�?br /> private String driver =""; //数据库驱�?br /> private String url =""; //数据库url
private String username =""; //用户�?br /> private String password =""; //密码
private int maxconn =0; //最大连接数
/**
*
*/
public DSConfigBean() {
// TODO Auto-generated constructor stub
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

/**
* @return the driver
*/
public String getDriver() {
return driver;
}

/**
* @param driver the driver to set
*/
public void setDriver(String driver) {
this.driver = driver;
}

/**
* @return the maxconn
*/
public int getMaxconn() {
return maxconn;
}

/**
* @param maxconn the maxconn to set
*/
public void setMaxconn(int maxconn) {
this.maxconn = maxconn;
}

/**
* @return the name
*/
public String getName() {
return name;
}

/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}

/**
* @return the password
*/
public String getPassword() {
return password;
}

/**
* @param password the password to set
*/
public void setPassword(String password) {
this.password = password;
}

/**
* @return the type
*/
public String getType() {
return type;
}

/**
* @param type the type to set
*/
public void setType(String type) {
this.type = type;
}

/**
* @return the url
*/
public String getUrl() {
return url;
}

/**
* @param url the url to set
*/
public void setUrl(String url) {
this.url = url;
}

/**
* @return the username
*/
public String getUsername() {
return username;
}

/**
* @param username the username to set
*/
public void setUsername(String username) {
this.username = username;
}

}
-----------------------------------------------------
ParseDSConfig.java
-----------------------------------------------------
/**
* 操作配置文�g�c?�?nbsp; �?修改删除�{�操�?
*/
package com.chunkyo.db;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Vector;
import java.util.Iterator;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

/**
* @author chenyanlin
*
*/
public class ParseDSConfig {

/**
* 构造函�?br /> */
public ParseDSConfig() {
  // TODO Auto-generated constructor stub
}
/**
* ��d��xml配置文�g
* @param path
* @return
*/
public Vector readConfigInfo(String path)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  Vector dsConfig=null;
  FileInputStream fi = null;
  try
  {
   fi=new FileInputStream(rpath);//��d��路径文�g
   dsConfig=new Vector();
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    DSConfigBean dscBean=new DSConfigBean();
    dscBean.setType(pool.getChild("type").getText());
    dscBean.setName(pool.getChild("name").getText());
    System.out.println(dscBean.getName());
    dscBean.setDriver(pool.getChild("driver").getText());
    dscBean.setUrl(pool.getChild("url").getText());
    dscBean.setUsername(pool.getChild("username").getText());
    dscBean.setPassword(pool.getChild("password").getText());
    dscBean.setMaxconn(Integer.parseInt(pool.getChild("maxconn").getText()));
    dsConfig.add(dscBean);
   }

  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }

  return dsConfig;
}

/**
*修改配置文�g 没时间写 �q�段旉��再脓上去其实一��L��
*/
public void modifyConfigInfo(String path,DSConfigBean dsb) throws Exception
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi=null; //��d��
  FileOutputStream fo=null; //写入

}
/**
*增加配置文�g
*
*/
public void addConfigInfo(String path,DSConfigBean dsb)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi=null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//��d��xml��?br />
   SAXBuilder sb=new SAXBuilder();

   Document doc=sb.build(fi); //得到xml
   Element root=doc.getRootElement();
   List pools=root.getChildren();//得到xml子树

   Element newpool=new Element("pool"); //创徏新连接池

   Element pooltype=new Element("type"); //讄��q�接池类�?br />    pooltype.setText(dsb.getType());
   newpool.addContent(pooltype);

   Element poolname=new Element("name");//讄��q�接池名�?br />    poolname.setText(dsb.getName());
   newpool.addContent(poolname);

   Element pooldriver=new Element("driver"); //讄��q�接池驱�?br />    pooldriver.addContent(dsb.getDriver());
   newpool.addContent(pooldriver);

   Element poolurl=new Element("url");//讄��q�接池url
   poolurl.setText(dsb.getUrl());
   newpool.addContent(poolurl);

   Element poolusername=new Element("username");//讄��q�接池用户名
   poolusername.setText(dsb.getUsername());
   newpool.addContent(poolusername);

   Element poolpassword=new Element("password");//讄��q�接池密�?br />    poolpassword.setText(dsb.getPassword());
   newpool.addContent(poolpassword);

   Element poolmaxconn=new Element("maxconn");//讄��q�接池最大连�?br />    poolmaxconn.setText(String.valueOf(dsb.getMaxconn()));
   newpool.addContent(poolmaxconn);
   pools.add(newpool);//��child��d��到root
   Format format = Format.getPrettyFormat();
      format.setIndent("");
      format.setEncoding("utf-8");
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  finally
  {

  }
}
/**
*删除配置文�g
*/
public void delConfigInfo(String path,String name)
{
  String rpath=this.getClass().getResource("").getPath().substring(1)+path;
  FileInputStream fi = null;
  FileOutputStream fo=null;
  try
  {
   fi=new FileInputStream(rpath);//��d��路径文�g
   SAXBuilder sb=new SAXBuilder();
   Document doc=sb.build(fi);
   Element root=doc.getRootElement();
   List pools=root.getChildren();
   Element pool=null;
   Iterator allPool=pools.iterator();
   while(allPool.hasNext())
   {
    pool=(Element)allPool.next();
    if(pool.getChild("name").getText().equals(name))
    {
     pools.remove(pool);
     break;
    }
   }
   Format format = Format.getPrettyFormat();
      format.setIndent("");
      format.setEncoding("utf-8");
      XMLOutputter outp = new XMLOutputter(format);
      fo = new FileOutputStream(rpath);
      outp.output(doc, fo);

  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (JDOMException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  finally
  {
   try {
    fi.close();
   } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub

  ParseDSConfig pd=new ParseDSConfig();
  String path="ds.config.xml";
  pd.readConfigInfo(path);
  //pd.delConfigInfo(path, "tj012006");
  DSConfigBean dsb=new DSConfigBean();
  dsb.setType("oracle");
  dsb.setName("yyy004");
  dsb.setDriver("org.oracle.jdbc");
  dsb.setUrl("jdbc:oracle://localhost");
  dsb.setUsername("sa");
  dsb.setPassword("");
  dsb.setMaxconn(1000);
  pd.addConfigInfo(path, dsb);
  pd.delConfigInfo(path, "yyy001");
}

}

--------------------------------------
ds.config.xml 配置文�g
--------------------------------------

mysql
user
com.mysql.jdbc.driver
jdbc:mysql://localhost:3306/user
sa
123456
100

mysql
user2
com.mysql.jdbc.driver
jdbc:mysql://localhost:3306/user2
sa
1234
10

sql2000
books
com.microsoft.sqlserver.driver
jdbc:sqlserver://localhost:1433/books:databasename=books
sa

100

3. �q�接池的使用
1。Connection的获得和释放
DBConnectionManager   connectionMan=DBConnectionManager .getInstance();//得到唯一实例
   //得到�q�接
   String name="mysql";//从上下文得到你要讉K��的数据库的名�?br />    Connection con=connectionMan.getConnection(name);
//使用
。。。。。。�?br /> // 使用完毕
connectionMan.freeConnection(name,con);//释放�Q�但�q�未断开�q�接
2。数据库�q�接的动态增加和�q�接池的动态增�?br />       1。调用xml操作增加�c?br />
      2。重新实例华�q�接池管理池�c?br />
<�?gt;

ID刀 2009-03-05 16:06 发表评论

ID刀 — Mon, 02 Mar 2009 09:07:00 GMT

Context在Java中的出现是如此频�J�，但其中文��译“上下�?#8221;又是如此诡异拗口�Q�因此导致很多�h不是很了解Context的具体含义是指什么，所以很有必要来��q��一下这词的含义�?br />
先来丑և�个JAVA中用到Context的例�?br />
�Q?�Q�JNDI的一个类javax.naming.InitialContext�Q�它��d��JNDI的一些配�|�信息，�q�内含对象和其在JNDI中的注册名称的映��信息。请看下面的代码

InitialContext ic=new InitialContext();
RMIAdaptor server=(RMIAdaptor)ic.lookup("jmx/invoker/RMIAdaptor");

�q�是一�D�JBoss中获取MBean的远�E�调用类的代码。在�q�里面通过InitialContext中JNDI注册的名�U?#8220;jmx/invoker/RMIAdaptor”来获得RMIAdaptor
对象。这和JAVA集合中的MAP有点象，有一个String的key�Q�key�Ҏ��着它的对象�?br />
�Q?�Q�再来看看下面Spring中最常见的几句代码�?span style="color: #000000">ApplicationContext 是内�?/font>configuration.xml配置文�g的信息，使得可以通过getBean用名�U�得到相应的注册对象�?/font>

ApplicationContext ctx= new FileSystemXmlApplicationContext("configuration.xml");
Object obj= ctx.getBean("Object_Name");

从上面的代码�Q�我很能体会到Context所代表的意义：公用信息、环境、容�?...。所以我觉得Context��译成上下文�q�不直观�Q�按照语�a�使用的环境，��译�?#8220;环境”�?#8220;容器”可能更好�?nbsp; (�?

ID刀 2009-03-02 17:07 发表评论

WEB��试(�?

ID刀 — Mon, 02 Mar 2009 05:33:00 GMT

Web应用�E�序��试�Ҏ��和测试技术详�q?/a>

1. 概述
随着web应用的增多，新的模式解决�Ҏ��中以web为核心的应用也越来越多，很多公司各种应用的架构都�?span lang="EN-US">B/S�?span lang="EN-US">web应用��Z��Q�但是有�?span lang="EN-US">WEB��试斚w��的内容�ƈ没有相应的�ȝ��Q�所以我在这里对web的测试方法和采用的测试技术进行�ȝ��Q�便于内部交��?/font>
��试�Ҏ��量�늛�web�E�序的各个方面，��试技术方面在�l�承传统��试技术的技术上�l�合web应用的特炏V�?/font>
相关的测试和实现技术也有着很大的关�p�，�׃��本公�怋��?span lang="EN-US">J2EE体系�Q�也�怾�子中只有JAVA�q�_��可以使用�Q?span lang="EN-US">.NET�q�_��试技术暂时不涉及�Q�如果你有请与我联系�?/font>
2. ��试�Ҏ��
说明�Q�测试方法的选择取决你的��试�{�略�?/font>
一般的web��试和以往的应用程序的��试的侧重点不完全相同，基本包括以下几个斚w��?/font>
当然圆满的完成测试还要有好的团体和流�E�等的方斚w��面的支持�Q�你同样应该对这些方面进行注意�?/font>
有些��试�Ҏ��设计��C��程�Q�哪些应该在你的��试团队��中徏立�?

2.1 界面��试
现在一般�h都有使用��览器浏览网��늚��l�历�Q�用戯��然不是专业�h员但是对界面效果的印象是很重要的。如果你注重�q�方面的��试�Q�那么验证应用程序是否易于��用就非常重要了。很多�h认�ؓ�q�是��试中最不重要的部分�Q�但是恰恰相反界面对不懂技术的客户来说那相当关键，慢慢体会你会明白的�?/font>
�Ҏ��上可以根据设计文档，如果够专业的话可以专业美工�h员，来确定整体风格页面风��|��然后�Ҏ��q�个可以��面人员可以生成静态的HTML�Q?span lang="EN-US">CSS�{�甚至生成几套不用的�Ҏ��来讨论，或者交�l�客戯��审，最后�Ş成统一的风格的��面/框架。注意不要靠�E�序员的��术素养形成你的web风格�Q�那样可能会很糟�p��?/font>
主要包括以下几个斚w��的内容：
站点地图和导航条位置、是否合理、是否可以导航等内容布局布局是否合理�Q�滚动条�{�简介说�?说明文字是否合理�Q�位�|�，是否正确
背景/色调是否正确、美观，是否�W�合用户需求；
��面在窗口中的显�C�是否正��、美观（在调整浏览器�H�口大小�Ӟ��屏幕��h��是否正确�Q�表单样�?大小�Q�格式，是否�Ҏ��交数据进行验证（如果在页面部分进行验证的话）�{?/font>
�q�接 �q�接的�Ş式，位置�Q�是否易于理解等
web��试的主要页面元�?/font>
��面元素的容错性列表（如输入框、时间列表或日历�Q?/font>
��面元素清单�Q��ؓ实现功能�Q�是否将所需要的元素全部都列出来了，如按钮、单选框、复选框、列表框、超�q�接、输入框�{�等�Q?/font>
��面元素的容错性是否存�?/font>
��面元素的容错性是否正��?/font>
��面元素基本功能是否实现�Q�如文字�Ҏ��、动�ȝ��效、按钮、超�q�接�Q?/font>
��面元素的外形、摆放位�|�（如按钮、列表框、核选框、输入框、超�q�接�{�）
��面元素是否昄��正确�Q�主要针�Ҏ��字、图形、签章）
元素是否昄��Q�元素是否存在）
��面元素清单�Q��ؓ实现功能�Q�是否将所需要的元素全部都列出来了，如按钮、单选框、复选框、列表框、超�q�接、输入框�{�等�Q?/font>
��试技�?/font>
     通过��面走查�Q�浏览确定��用的��面是否�W�合需求。可以结合兼�Ҏ��测试对不用分��L率下��面昄��效果�Q�如果有影响应该交给设计人员提出解决�Ҏ��?/font>
    可以�l�合数据定义文档查看表单��的内容�Q�长度等信息�?/font>
    对于动态生成的��面最好也能进行浏览查看。如Servelet部分可以�l�合�~�码规范�Q�进行代码走查。是否支持中文，如果数据�?span lang="EN-US">XM ��装要做的工作会多一点等�{��?

界面��试要素:
�W�合标准和规�?span lang="EN-US">,灉|��?span lang="EN-US">,正确�?span lang="EN-US">,直观�?span lang="EN-US">,舒适�?span lang="EN-US">,实用�?span lang="EN-US">,一致�?/font>
1.直观�?/font>:
用户界面是否�z�净,不唐�H?span lang="EN-US">,不拥�?span lang="EN-US">.界面不应该�ؓ用户刉��障��?span lang="EN-US">.所需功能或者期待的响应应该明显,�q�在预期出现的地�?/font>.
界面�l�织和布局合理�?span lang="EN-US"> 是否允许用户��L��C��一个功能�{到另一个功�?span lang="EN-US"> 下一步做什么明昑֐� ��M��时刻都可以决定放弃或者退�?span lang="EN-US">,退出吗输入得到承认了吗菜单或者窗口是否深藏不�?/font>
有多余功能吗软�g整体抑或局部是否做得太�?span lang="EN-US"> 是否有太多特性把工作复杂化了是否感到信息太庞�?/font>
如果其他所有努力失�?span lang="EN-US">,帮助�pȝ��真能帮忙�?/font>

2.一致�?/font>
快速键和菜单选项.�?span lang="EN-US">Windows 中按F1键��L��得到帮助信息
术语和命�?span lang="EN-US">.整个软�g使用同样的术语吗 �Ҏ��命名一致吗例如,Find是否一直叫Find,而不是有时叫Search
软�g是否一直面向同一�U�别用户带有花哨用户界面的趣呌��卡程序不应该昄��泄露技术机密的错误提示信息.
按钮位置和等��L��按键.大家是否注意到对话框�?span lang="EN-US">OK按钮�?span lang="EN-US">Canc e按钮�?span lang="EN-US">,OK按钮��L��在上�Ҏ��者左�?span lang="EN-US">,�?span lang="EN-US">Canc e按钮��L��在下�Ҏ��x�� 同样原因,Canc e按钮的等��h��键通常�?span lang="EN-US">Esc,而选中按钮的等��h��钮通常�?span lang="EN-US">Enter.保持一�?/font>.

3.灉|��?/font>
状态蟩�?span lang="EN-US">.灉|��的��Y件实现同一��d��有多�U�选择方式.
状态终止和跌��,��h��定w��处理能力.
数据输入和输�?span lang="EN-US">.用户希望有多�U�方法输入数据和查看�l�果.例如,在写字板插入文字可用键盘输入,�_�脓,�?span lang="EN-US">6�U�文件格式读�?span lang="EN-US">,作�ؓ对象插入,或者用鼠标从其他程序拖�?/font>.
4.舒适�?/font>
恰当.软�g外观和感觉应该与所做的工作和��用者相�W?/font>.
错误处理.�E�序应该在用��h��行严重错误的操作之前提出警告,�q�允许用��h��复由于错误操作导致丢��q��数据.如大家认�?span lang="EN-US">undo /redo是当然的.
性能.快不见得是好�?span lang="EN-US">.要让用户看得清程序在做什�?span lang="EN-US">,它是有反应的.

2.2 功能��试
对功能测试是��试中的重点
主要包括一下几个方面的内容
�q�接�q�个�q�接和界面测试中的连接不同那里注重的是连接方式和位置�Q�如是图像还是文字放�|�的位置�{�，�q�是其他的方式。这里的�q�接注重功能。如是否有连接，�q�接的是否是说明的位�|�等�?/font>
表单提交应当模拟用户提交�Q�验证是否完成功能，如注册信息，要测试这些程序，需要验证服务器能正��保存这些数据，而且后台�q�行的程序能正确解释和��用这些信息。还有数据正��性验证，异常处理�{�，最好结合易用性要求等�?span lang="EN-US">B/S�l�构实现的功能可能主要的��在�q�里�Q�提交数据，处理数据�{�如果有固定的操作流�E�可以考虑自动化测试工��L��录制功能�Q�编写可重复使用的脚本代码，可以在测试、回归测试时�q�行以便减轻��试人员工作量�?/font>
Cookies 验证如果�pȝ��使用�?span lang="EN-US">cookie�Q�测试�h员需要对它们�q�行��。如果在 cookies 中保存了注册信息�Q�请��认�?span lang="EN-US"> cookie能够正常工作而且已对�q�些信息已经加密。如果��?span lang="EN-US"> cookie 来统计次敎ͼ�需要验证次数篏计正��。关�?span lang="EN-US">cookie的��用可以参考浏览器的帮助信息。如果��?span lang="EN-US">B/S�l�构cookies中存攄��信息更多。功能易用性测�?完成了功能测试可以对应用性进行了解，最好听听客��L��反映�Q�在可以的情况下对程序进行改�q�是很有必要的，和客户保持互动对�pȝ��满意度也是很有帮助的�?/font>
��试技术功能测试的��试技术可是很多的�Q�我们可以结合实际环境选择使用
白盒��试技�?span lang="EN-US">(White Box Testing) 深入��C��码一�U�的��试�Q��用这�U�技术发现问题最早，效果也是最好的。该技术主要的特征是测试对象进入了代码内部,�Ҏ��开发�h员对代码和对�E�序的熟悉程�?span lang="EN-US">,�Ҏ��需要的部分�q�行在��Y件编码阶�D�，开发�h员根据自己对代码的理解和接触所�q�行的��Y件测试叫做白盒测试。这一阶段��试以��Y件开发�h员�ؓ主，�?span lang="EN-US">JAVA�q�_��使用Xunit�p�d��工具�q�行��试�Q?span lang="EN-US">Xunit��试工具是类一�U�的��试工具�Ҏ��一个类和该�cȝ��Ҏ��q�行��试�?/font>
黑盒��试技术（Black Box Testing�Q�黑盒测试的内容主要有以下几个方面，但是主要�q�是功能部分。主要是覆盖全部的功能，可以�l�合兼容�Q�性能��试�{�方面进行，�Ҏ��软�g需求，设计文档�Q�模拟客户场景随�pȝ��q�行实际的测试，�q�种��试技术是使用最多的��试技术涵盖了��试的方斚w��面，可以考虑以下斚w��
   正确�?span lang="EN-US"> (Correctness)�Q�计��结果，命名�{�方�?/font>
   可用�?span lang="EN-US"> (Usability)�Q�是否可以满��Y件的需求说明�?/font>
   边界条�g (Boundary Condition)输入部分的边界�?span lang="EN-US">,��是使用一般书中说的等��L��划分,试试最大最��和非法数据�{�等.
   性能 (Performance) 正常使用的时间内�pȝ��完成一个�Q务需要的旉��,多�h同时使用的时候响应时�?span lang="EN-US">,在可以接受范围内.J2EE技术实现的�pȝ��在性能斚w��更是需要照�儡��,一般原则是3�U�以下接�?span lang="EN-US">,3-5�U�可以接�?span lang="EN-US">,5�U�以上就影响易用性了. 如果在测试过�E�中发现性能问题�Q�修复�v来是非常艰难的，因�ؓ�q�常常意味着
�E�序的算法不好，�l�构不好�Q�或者设计有问题。因此在产品开发的开始阶�D�，��p��考虑到��Y件的性能问题
   压力��试 (Stress) 多用��h��?可以考虑使用压力��试工具,��压力和性能��试�l�合��h��q�行.如果有负载��^衡的话还要在服务器端打开监测工具,查看服务�?span lang="EN-US">CPU使用�?span lang="EN-US">,内存占用情况,如果有必要可以模拟大量数据输�?span lang="EN-US">,对硬盘的影响�{�等信息.如果有必要的话必��进行性能优化(软硬仉��可以).�q�里的压力测试针对的是某几项功能,.
   错误恢复 (Error Recovery) 错误处理�Q�页面数据验�?span lang="EN-US">,包括�H�然间断�?span lang="EN-US">,输入脏数据等.
安全性测�?span lang="EN-US">(Security)�q�个领域正在研究�?span lang="EN-US">,不过防火�?span lang="EN-US">,补丁�?span lang="EN-US">.杀毒��Y件等的就不必说了,不过可以考虑破坏性测试时��L��.看了一些资料后得知,�q�里面设计到的知�?span lang="EN-US">\内容可以写本书了,不是一两句可以说清�?span lang="EN-US">,特别是一些商务网�?span lang="EN-US">,或者跟钱有�?span lang="EN-US">,或者和公司�U�密有关�?span lang="EN-US">web更是,需要这斚w��的测�?span lang="EN-US">,在外国有一�U�专门干�q�一行的人叫安全��N��,可以审核代码,提出安全��,出现紧急事件是的处理办法等,在国内没有听说哪里有专门搞安全技术测试的内容.
   兼容�?span lang="EN-US"> (Compatibility) 不同��览器，不同应用�E�序版本在实现功能时的表�?span lang="EN-US">,不同的上�|�方�?span lang="EN-US">,如果你测试的是一个公��q��站的�?/font>.
兼容性测试内容详�q?/font>
��g�q�_��
��览器��Y件和版本:��览器插�?span lang="EN-US">,��览器选项,视频分��L率和色深.文字大小,调制解调器速率.
   软�g配置 (Configuration) �?span lang="EN-US">IE��览器的不用选项-安全讑֮�最�?span lang="EN-US">,��用脚本�E�序,�{�等,你们的程序在各种不用的设�|�下表现如何.

单元��试技�?/font>(Unit Test):
2.2.1 下面是对白盒��试和单元测试的区别的论�q?/font>:
单元��试和白盒测试是不同�?span lang="EN-US">,虽然单元��试和白盒测试都是关注功能虽然他们都需要代码支�?span lang="EN-US">,但是�U�别不同,白盒��试��x��的是�c�M��一个方法的功能是更��的单位,但是完成一个单元测试可能需�?span lang="EN-US">N多类,所以说作单元测试需要什么写驱动和稳定桩,比如查询单元是一个查询包�?span lang="EN-US">N多的��试�c?span lang="EN-US">,��试数据,�q�行他需要提供数据的部分,输入参数和发出命令的驱动�{�等.是比�c�d��的一个整体进行的.
另一个明昄��区别是白盒测试不会关注类接口,但是单元��试主要的内容就是类接口��试.
不过很多时候是很少区分�?span lang="EN-US">,因�ؓ�q�两�U�技术实现�v来有很多�怺�兌��的部�?span lang="EN-US">.不过要看你对质量的关注程度来军_��.
2.2.2 功能��试边界��试\��界��试技术详�q?/font>
边界条�g
边界条�g是指软�g计划的操作界限所在的边缘条�g.
如果软�g��试问题包含��定的边�?span lang="EN-US">,那么数据�c�d��可能�?/font>:
数�?速度字符地址位置 ��寸数量
同时,考虑�q�些�c�d��的下�q�特�?/font>:
�W�一�?span lang="EN-US">/最后一�?最��?span lang="EN-US">/最大�?/font>
开�?span lang="EN-US">/完成 ��过/在内
�I?span lang="EN-US">/�?最�?span lang="EN-US">/最�?/font>
最�?span lang="EN-US">/最�?最�?span lang="EN-US">/最�q?/font>
最�?span lang="EN-US">/最��?最�?span lang="EN-US">/最�?/font>
盔R��/最�q?/font>
��界��试
通常是简单加1或者很��的�?span lang="EN-US">(对于最大�?span lang="EN-US">)和减��?span lang="EN-US">1或者很��的�?span lang="EN-US">(对于最��?span lang="EN-US">),例如:
�W�一个减1/最后一个加1
开始减1/完成�?/font>1
�I�Z��再减/满了再加
慢上加慢/快上加快
最大数�?span lang="EN-US">1/最��数�?/font>1
最��值减1/最大值加1
刚好��过/刚好在内
短了再短/长了再长
早了更早/晚了更晚
最高加1/最低减1
另一些该注意的输�?span lang="EN-US">:默认,�I�白,�I��?span lang="EN-US">,零值和�?span lang="EN-US">;非法,错误,不正��和垃圾数据.
2.2.3 状态测试技�?/font>

软�g可能�q�入的每一�U�独立状�?/font>;
从一�U�状态�{入另一�U�状态所需的输入和条�g;
�q�入或退出某�U�状态时的设�|�条件及输入�l�果.

具体��试�Ҏ��可以参考如�?/font>:
每种状态至��访问一��?/font>;
��试看�v来最常见最普遍的状态�{�?/font>;
��试状态之间最不常用的分支
��试所有错误状态及其返回�?/font>
��试随机状态�{�?/font>
2.2.4 竞争条�g��试技�?/font>
竞争条�g典型情�Ş参考如�?/font>:
两个不同的程序同时保存或打开同一个文�?/font>
�׃�n同一台打印机,通信端口或者其他外围设�?/font>
当��Y件处于读取或者修改状态时按键或者单击鼠�?/font>
同时关闭或者启动��Y件的多个实例
同时使用不同的程序访问一个共同数据库

2.3 负蝲\压力��试(StressTest)
在这里的负蝲\压力和功能测试中的不�?span lang="EN-US">,他是�pȝ��试的内�?span lang="EN-US">,是基本功能已�l�通过后进行的.可以在集成测试阶�D?span lang="EN-US">,亦可以在�pȝ��试阶段�q�行.
使用负蝲��试工具�q�行,虚拟一定数量的用户看一看系�l�的表现,是否满��定义中的指标.
负蝲��试一般��用工具完成， oadrunner�Q?span lang="EN-US">web oad�Q?span lang="EN-US">was�Q?span lang="EN-US">ew �Q?span lang="EN-US">e-test�{�，主要的内定w��是编写出��试脚本�Q�脚本中一般包括用户一般常用的功能�Q�然后运行，得出报告。所以负载测试包括的主要内容��׃��介绍了�?/font>
负蝲��试技术在各种极限情况下对产品�q�行��试 (如很多�h同时使用该��Y�Ӟ��或者反复运行该软�g)�Q�以��查��品的长期�E�_��性。例如，使用压力��试工具�?span lang="EN-US">web服务器进行压力测�?span lang="EN-US">. 本项��试可以帮助扑ֈ�一些大型的问题�Q�如��L��、崩损、内存泄漏等�Q�因为有些存在内存泄漏问题的�E�序�Q�在�q�行一两次时可能不会出现问题，但是如果�q�行了成千上万次�Q�内存泄漏得��来��多�Q�就会导致系�l�崩滑。用J2EE实现的系�l�很��但是�ƈ不是没有内存问题.
无论什么工具基本的技术都是利用线�E�技术模仿和虚拟用户�Q�在�q�里主要的难点在与测试脚本的�~�写�Q�每�U�工具��用的脚本都不一��P��但是大多数工具都提供录制功能��q��是不会编码的��试人员同样可以��试�?/font>
对负载工��L��延��使用可以�q�行�pȝ��E�_��性测试，�pȝ��极限��试�Q�如使用100�?span lang="EN-US"> oad Size�q�箋使用24��时�Q�微软定义的通过准则是通过72��时��试的程序一般不会出现稳定性的问题�?

2.4 回归��试 (Regression Test)
�q�一�D�|��间以后，再回�q�头来对以前修复�q�的Bug重新�q�行��试�Q�看�?span lang="EN-US">Bug 是否会重新出现�?/font>
回归��试技术可以在��试的各个阶�D�出玎ͼ�无论是单元测试还是集成测试还是系�l�测试。是对以前问题进行验证的�q�程�?/font>
回归��试的目的就是保证以前已�l�修复的Bug不会再出现。实际上�Q�许�?span lang="EN-US">Bug都是在回归测试时发现的，在此阶段�Q�我们首先要��查以前找到的Bug 是否已经更正了。值得注意的是�Q�已�l�更正的Bug 也可能又回来了，有的Bug �l�过修改之后可能又��生了新的Bug。所以，回归��试可保证已更正�?span lang="EN-US">Bug不再重现�Q�不产生新的Bug�?/font>
2.5 A pha �?span lang="EN-US">Beta ��试 (A pha and Beta Test):
在正式发布��品之前往往要先发布一些测试版�Q�让用户能够反馈出相关信息，或者找到存在的Bug�Q�以便在正式版中得到解决�?/font>
特别是在有客户参加的情况下，对系�l�进行测试可能会出现一些我们没有考虑的情况，�q�可以解决一些客户实际关心的问题

不同的测试技术区�?/font>
3.1 覆盖��试技�?/font>
说明:��试覆盖率可以看出测试的完成�?span lang="EN-US">,在测试分析报告中可以作�ؓ量化指标的依据，��试覆盖率越高效果越好�?/font>
覆盖��试可以是程序代码的执行路径覆盖�Q�亦可以是功能实现的步骤覆盖�Q�可以理解成��程囄��路径覆盖�Q��?/font>
该技术可以用在�Q何测试阶�D�，包括单元��坏歅R��集成测试、系�l�测试�?/font>
使用该技术时可以使用以上的�Q何测试方法和��试技术�?/font>
3.2 白盒��试和黑盒测试技�?/font>
白盒��试技�?span lang="EN-US"> (White Box Testing)该技术主要的特征是测试对象进入了代码内部,�Ҏ��开发�h员对代码和对�E�序的熟悉程�?span lang="EN-US">,�Ҏ��需要的部分�q�行在��Y件编码阶�D�，开发�h员根据自己对代码的理解和接触所�q�行的��Y件测试叫做白盒测试。这一阶段��试以��Y件开发�h员�ؓ主，使用Xunit�p�d��工具�q�行��试�Q�可以包括很多方面如功能性能�{��?/font>
黑盒��试 (Black Box Testing)��试的主体部分黑盒测试的内容主要有以下几个方面，但是主要�q�是功能部分。主要是覆盖全部的功能，可以�l�合兼容�Q�性能��试�{�方面进�?span lang="EN-US">,包括的不同测试类型请参考以上内宏V�?/font>
3.3 手工��试和自动化��试
手工��试�Q?span lang="EN-US">Manual Testing�Q�：即依靠�h力来查找Bug。方法可以参考上边的��试�Q�也可以�Ҏ��对实现技术及�l�验�{�进行不同的��试�?/font>
自动��试�Q?span lang="EN-US">Automation Testing�Q��用有针对工具实行。可以作��动化��试的计�?span lang="EN-US">,对可以进行自动化��试的部分编写或者录制相应的脚本,可以加入功能,定w��,表单提交�{?span lang="EN-US">,可以参�?span lang="EN-US">MI,Rationa 或者其他类��试工具说明.
�Ҏ��权威的��Y件测试经验，手工��试�q�是主要的测试方法，自动��试不够灉|��Q�在�q�里不再详述。微软的��试�q�程80�Q�还是手工完成�?/font>
自动��试永远也代替不了手工测试，但是手工��试的工作量很大是不争的事实�?/font>
3.4 �Ҏ��RUP标准按阶�D�区分测�?/font>
单元��试在上�Ҏ��详细的叙�q�ͼ��q�有针对单元��试和集成测试的��Q�请参考�?/font>
集成��试分�ؓ功能集成��试和系�l�集成测试，�怺�有调用的功能集成�Q�在�pȝ��环境下功能相互调用的影响�{�，使用�Ҏ��可以��L��选用上面的内宏V��注重功能方面�?/font>
�pȝ��试在功能实现的基础上，可以加入兼容性，易用性，性能�{�等
验收��试可以包括Alpha�?span lang="EN-US">Beta��试�Q�在�q�里��׃��再详�q��?

4. 存在风险及解��x��?/font>
说明�Q�测试不能找出所有的问题�Q�只是尽量将问题在开发阶�D�解军_��多数的问题而已�?/font>
��试风险如下�Q?/font>
软硬件的��试环境提供上也�Ҏ��试结果有很大的媄响�?/font>
��试团队的水�q�I��l�验�Q�合作效果等
整个开发流�E�对��试的重视程度，��试的进入时间等
�׃��试环境操作�pȝ��Q�网�l�环境，带宽�{�情况可能��生的��试�l�果可能不同�q�是��需要经验以及对��试环境的保护等斚w��下一些功夫�?/font>
5. 软�g�~�陷的原�?/font>
软�g�~�陷区别于��Y�?span lang="EN-US">bug,它是在测试过�E�中出现的对�pȝ��有媄响的,但是在设计中没有的或者对修改后的bug��试和开发�h员有不同意见�{?/font>
软�g未达��C�品说明书标明的功能�?/font>
软�g出现了��品说明书指明不会出现的错误�?/font>
软�g功能��出产品说明书指明范围�?/font>
软�g未达��C�品说明书虽未指出但应辑ֈ�的目标�?/font>
软�g��试员认��Y仉��以理解、不易��用、运行速度�~�慢�Q�或者最�l�用戯��Z��好�?

6. 文档��试
产品说明书属性检查清�?/font>
完整.是否有遗漏和丢失完全�?span lang="EN-US"> 单独使用是否包含全部内容
准确.既定解决�Ҏ��正确�?span lang="EN-US"> 目标明确�?span lang="EN-US"> 有没有错�?/font>
�_��,不含�p?span lang="EN-US">,清晰.描述是否一清二�?span lang="EN-US"> �q�是自说自话 �Ҏ��看懂和理解吗
一�?span lang="EN-US">.产品功能能描�q�是否自相矛�?span lang="EN-US">,与其他功能有没有冲突
贴切.描述功能的陈�q�是否必�?span lang="EN-US"> 有没有多余信�?span lang="EN-US"> 功能是否原来的客戯��?/font>
合理.在特定的预算和进度下,以现有�h�?span lang="EN-US">,物力和资源能否实�?/font>
代码无关.是否坚持定义产品,而不是定义其所信赖的��Y件设�?span lang="EN-US">,架构和代�?/font>
可测试�?span lang="EN-US">.�Ҏ��能否测�?span lang="EN-US"> ��试员徏立验证操作的��试�E�序是否提供��_��的信�?/font>

产品说明书用语检查清�?/font>
说明寚w��题的描述通常表现为粉饰没有仔�l�考虑的功�?span lang="EN-US">----可归�l�于前文所�q�的属�?span lang="EN-US">.从��品说明书上找��L��用语,仔细审视它们在文中是怎样使用�?span lang="EN-US">.产品说明书可能会为其掩饰和开�?span lang="EN-US">,也可能含�p�其�?span lang="EN-US">----无论是哪一�U�情况都可视��Y件缺�?/font>.
��L��,每一�U?span lang="EN-US">,所�?span lang="EN-US">,没有,从不.如果看到此类�l�对或肯定的,切实认定的叙�q?span lang="EN-US">,软�g��试员就可以着手设计针锋相对的案例.
当然,因此,明显,昄��,必然.�q�些话意图诱使接受假定情�?span lang="EN-US">.不要中了圈套.
某些,有时,常常,通常,惯常,�l�常,大多,几乎.�q�些话太�q�模�p?span lang="EN-US">."有时"发生作用的功能无法测�?/font>.
�{�等,诸如此类,依此�c�L��.以这��L��词结束的功能清单无法��试.功能清单要绝�Ҏ��者解释明��?span lang="EN-US">,以免让�h�q�h��,不知如何推论.
良好,�q��?span lang="EN-US">,廉�h,高效,��?span lang="EN-US">,�E�_��.�q�些是不��定的说�?span lang="EN-US">,不可��试.如果在��品说明书中出�?span lang="EN-US">,��必��进一步指明含�?/font>.
已处�?span lang="EN-US">,已拒�l?span lang="EN-US">,已忽�?span lang="EN-US">,已消�?span lang="EN-US">.�q�些廉洁可能会隐藏大量需要说明的功能.
如果...那么...(没有否则).扑և��?span lang="EN-US">"如果...那么..."而缺��配套的"否则"�l�构的陈�q?span lang="EN-US">.想一�?span lang="EN-US">"如果"没有发生会怎样.

ID刀 2009-03-02 13:33 发表评论

annotation的作用（转）

ID刀 — Fri, 27 Feb 2009 09:23:00 GMT

annotation到底能�v什么作用呢�Q?br /> 1�Q?nbsp; �~�译工具或其他工具可以根据被附加在代码里的annotation信息自动生成配置文�g或文档等外部文�g�?br /> 比如�Q�sun公司��提供了apt�Q�Annotation Processing Tool�Q?/a>工具�Q�apt工具是一个可以处理annotation的命令行工具�Q�apt提供了在�~�译期针�Ҏ��代码�U�别的解析，�q�可以在解析时生成新的源代码和其他文�Ӟ��同时�q�可以对生成的源代码�q�行�~�译�?br /> 2�Q?nbsp; 其他�E�序可以在运行时动态解析将要被执行的程序里的annotation信息�Q��ƈ�Ҏ��被附加的annotation信息来执行不同的操作�?br /> 比如�Q�EJB3规范��比较广泛地使用了annotation�Ҏ��。比如只要在POJO为class注明@Stateless注释�Q�EJB容器便会�Ҏ��此annotation把该POJO注册为无状态的Session Bean。EJB3使用了annotation大大地简化了EJB的开发和配置�q�程。我们会在其他文章里专门介绍EJB Annotation的原理与使用�Ҏ��Q�这里不做详�q��?br />
本文通过一个简单地例子来说明怎么在运行期动态解析annotation。Apt工具的��用我们会在近期其他文章里对其加以介绍�?br />
比如�Q�我们定义了MyAnnotation3注释�Q?br /> MyAnnotation3.java

package com.test.annotation;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation3 {
    public String value();
    public String[] multiValues();
    int number() default 0;
}

上面定义了一个名为MyAnnotation3的注释�?br />
我们再定义一个GetMyAnnotation�c�，该类使用了MyAnnotation3注释�Q?br /> GetMyAnnotation.java�Q?br />

package com.test.annotation.test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import javax.ejb.EJB;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import com.test.annotation.MyAnnotation3;

// 为GetMyAnnotation�c�附加MyAnnotation3 注释
@MyAnnotation3(value = "Class GetMyAnnotation", multiValues = {"1","2"})
public class GetMyAnnotation {
    // 为testField1属性附加MyAnnotation3 注释
    @MyAnnotation3(value = "call testField1", multiValues={"1"}, number = 1)
    private String testField1;

    // 为testMethod1�Ҏ��附加MyAnnotation3 注释
    @MyAnnotation3(value = "call testMethod1", multiValues={"1", "2"}, number = 1)
    public void testMethod1() {

    }

    @Deprecated
    @MyAnnotation3(value = "call testMethod2", multiValues={"3", "4", "5"})
    public void testMethod2() {

    }
}

上面的例子GetMyAnnotation非常��单，里面没有��M��功能�Q�但是分别�ؓ�c�（class�Q�，属性（field�Q�，�Ҏ��Q�method�Q�申明（附加�Q�了MyAnnotation3 注释�?br />
下面我们用程序TestMyAnnotation3对GetMyAnnotation里MyAnnotation3注释�q�行解析�?br />
�q�行时解析annotation
TestMyAnnotation3.java

输出�Q?br />

--Class Annotations--
[GetMyAnnotation].annotation:
{value=Class GetMyAnnotation
multiValues=,1,2
number=0}
--Fields Annotations--
[GetMyAnnotation.testField1].annotation:
{value=call testField1
multiValues=,1
number=1}
--Methods Annotations--
[GetMyAnnotation.testMethod1].annotation:
{value=call testMethod1
multiValues=,1,2
number=1}
[GetMyAnnotation.testMethod2].annotation:
{value=call testMethod2
multiValues=,3,4,5
number=0}

JDK1.5以后的版本提供的跟annotation有关的接口：

interface java.lang.reflect.AnnotatedElement {
    boolean isAnnotationPresent(Classextends Annotation> annotationClass);
    extends Annotation> T getAnnotation(Class annotationClass);
    Annotation[] getAnnotations();
    Annotation[] getDeclaredAnnotations();
}

该接口主要用来取得附加在�c�（class�Q�，构造方法（constructor�Q�，属性（field�Q�，�Ҏ��Q�method�Q�，包（package�Q�上的annotation信息�?br />
JDK1.5与此有关的几个类都实��C��AnnotatedElement接口�Q?br />

java.lang.reflect.AccessibleObject,
java.lang.reflect.Class,
java.lang.reflect.Constructor,
java.lang.reflect.Field,
java.lang.reflect.Method,
java.lang.reflect.Package

所以可以利用反��（reflection�Q�功能在�E�序里动态解析附加的annotation信息�?br />

�ȝ��Q?/strong>
本文通过举例��单地说明了怎么动态解析annotation�Q�大家可以�D一反三�Q�利用Java的annotation�Ҏ��，完成更复杂功能等�?nbsp;

ID刀 2009-02-27 17:23 发表评论

自定�?Java Annotation(�?

ID刀 — Fri, 27 Feb 2009 09:21:00 GMT
Annotation是一�U�特�D�的interface。所以可以在annotation里定义方法，属性；也可以让某个�c�M��annotation�l�承�Q�implements�Q��?br />
下面从简单地范例开始，让我们一步步加深对annotation的了解�?br />
无�Q何方�?属性Annotation范例�Q?/div>
MyAnnotation0.java

package com.test.annotation;

public @interface MyAnnotation0 {

}

MyAnnotation0��Z��个无��M��Ҏ��和属性的annotation�?br />
使用MyAnnotation0�Q?br />
TestMyAnnotation0.java
@MyAnnotation0
public class TestMyAnnotation0 {
    @MyAnnotation0
    public void testMethod() {

    }
}

��h��一个value�Ҏ��Annotation范例�Q?/p>
MyAnnotation1.java

public @interface MyAnnotation1 {

    /**
     * value method
     * @return value
     */
    public String value();
}

MyAnnotation1��h��一个名为value的方法�?br />
MyAnnotation1使用�Q?br /> TestMyAnnotation1.java

@MyAnnotation1("hello")
public class TestMyAnnotation1 {
    @MyAnnotation1(value="world")
    public void testMethod() {
    }
}

可以通过@Annotation�?�Ҏ��?=�?, �Ҏ��?=�?, …)的�Ş式给annotation赋倹{��只有一个方法的时候，可以直接省略为：@Annotation�?�?) 的赋值�Ş式。当�Ҏ��q�回一个数�l�时�Q�可以用 �Ҏ��?{�?, �?, …}�l�其赋倹{�?br />

��h��一个value�Ҏ��和一个属性Annotation范例�Q?/div>
如果必要�Q�还可以在annotation里�ؓ其定义属性。如下：
MyAnnotation2.java

@interface MyAnnotation2 {
    public String value();
    public String myProperty = "hello world";
}

其中�Q�myProperty只能��x��为public或无public修饰�Q�无public修饰时也默认为public�Q��ؓstatic, final属性（即��不写也默认�ؓstatic, final�Q��?br />
使用例：
TestMyAnnotation2

class TestMyAnnotation2 {
    public static void main(String[] args) {
        System.out.println(MyAnnotation2.myProperty);
    }

    @MyAnnotation2("")
    public void testMethod1() {
    }
}

上例会打印出�Q?/p>
hello world

复杂型annotation的定义与使用

本节介绍较�ؓ复杂的annotation定义与��用�?br /> 先看代码�Q?br /> MyAnnotation3.java

public @interface MyAnnotation3 {
    public String value();
    public String[] multiValues();
    int number() default 0;
}

MyAnnotation3��h��一个返回String的value�Ҏ��Q�返回String[]的multiValues �Ҏ��Q�还有一个返回int 的number�Ҏ��。其中number�Ҏ��h��默认�?�?br />
使用例：
TestMyAnnotation3.java

class TestMyAnnotation3 {
    @MyAnnotation3(value = "call testMethod1", multiValues={"1", "2"}, number = 1)
    public void testMethod1() {

    }

    @MyAnnotation3(value = "call testMethod2", multiValues={"1", "2"})
    public void testMethod2() {

    }
}

number��h��默认��|��所以标注时可以不�ؓ其赋倹{��其余方法则必须通过上面介绍的方法赋倹{��multiValues�q�回一个String[]数组�Q�所以可以通过multiValues={"1", "2"}为其赋倹{�?br />

ID刀 2009-02-27 17:21 发表评论

ID刀 — Fri, 27 Feb 2009 09:16:00 GMT

JAVA从J2SE5开始提供名为annotation�Q�注释，标注�Q�的功能。Java的annotation�Q�可以附加在package, class, method, field�{�上面，相当于给它们��d��了额外的辅助信息。附加在package, class, method, field�{�上的Annotation�Q�如果没有外部解析工��L��对其加以解析和处理的情况�Q�本�w�不会对Java的源代码或class�{��生�Q何媄响，也不会对它们的执行��生�Q何媄响�?br />
但借助外部工具�Q�比如javac�Q�EJB容器�{�，可以寚w��加在package, class, method, field的annotation�q�行解析�Q�可以根据annotation而做出相应的处理�Q�比如运行时改变对象/�Ҏ��的行为�?br />

Java标准Annotation
@Deprecated 相当于Javadoc的@deprecated�Q�被@Deprecated标注的对象class, method�{�被注明��Z��推荐使用。主要用于javac�{�编译工兗��?br /> @Override 注明对象method重蝲了父�cȝ��Ҏ��。javac�{�编译工��L��译时会根据此Annotation判断重蝲�Ҏ��是否正确�?br /> @SuppressWarnings 告诉javac�{�编译器忽略所指定的特定的警告信息�?br /> @Target 被定义的annotation可以附加在那些对象上�?br /> @Retention annotation的作用期间�?br />
Java标准Annotation的��?/div> @Deprecated�Q?br />
@Deprecated
public class TestBean {
    …
}

@SuppressWarnings

@SuppressWarnings("serial")
public class TestBean implements java.io.Serializable {
    …
}

@SuppressWarnings(value = {"serial", "unchecked"})
public String doSth() {
    …
}

@Override

@Override
public String doSth() {
    …
}

Annotation的定�?/div> 定义�Ҏ��Q?br /> @interface Annotation�?{定义体}

定义�?�Q?br />
public @interface MyAnnotation {}

该例定义了一个无��M��属�?�Ҏ��的Annotation�?br />
定义�?�Q?br />
public @interface MyAnnotation {
    public String value();
}

该例定义了只有一个方法�ؓvalue()的Annotation。一般来��_��只有一个方法的Annotation�Q�方法名一定定义�ؓvalue�?br />
定义�?�Q?br />
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    public String value();
    public String [] multiValues();
    int number() default 0;

}

该例定义了一个具有多�Ҏ��的Annotation。�ƈ讄��其中一个方法number的默认��gؓ0。multiValues �Ҏ��定义为数�l�类型。Annotation定义可以用MetaAnnotation�Q�元注释�Q�修饰。MetaAnnotation有以�?个：
@Retention
@Target

我们��在以下对@Retention与@Target加以说明�?br />

@Retention
@Retention 可以讄��为RetentionPolicy�c�d��的倹{�?br /> 例：
@Retention(RetentionPolicy.RUNTIME)

RetentionPolicy的�?/th> 说明

RetentionPolicy.CLASS annotation信息��被�~�译器编译时保存在class文�g中，但执行时不会在VM装蝲。也��是说不能在执行时动态取得annotation信息。未讄��@Retention时这��是默认讄��倹{�?

RetentionPolicy.RUNTIME annotation信息��被�~�译器编译时保存在class文�g中，执行时也会被VM装蝲�?

RetentionPolicy.SOURCE annotation信息��被�~�译器编译时舍弃掉�?

@Target
@Target表明Annotation可以附加在哪�U�JAVA元素之上�Q�可以设�|��ؓjava.lang.annotation.ElementType数组�c�d��的倹{�?br /> 使用�?�Q?br />
@Target(ElementType.METHOD)

使用�?�Q?br />
@Target(value={ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.LOCAL_VARIABLE, ElementType.METHOD})

ElementType是一个枚丄��型，它具有以下定义：

ElementType�?/th> 说明

ElementType.ANNOTATION_TYPE 应用于其他注解的元注�?/td>

ElementType.CONSTRUCTOR 构造函�?/td>

ElementType.FIELD 字段

ElementType.LOCAL_VARIABLE �Ҏ��中的本地变量

ElementType.METHOD �Ҏ��

ElementType.PACKAGE �?/td>

ElementType.PARAMETER �Ҏ��的参�?/td>

ElementType.TYPE �c�，接口或者枚丑֣��?/td>

ID刀 2009-02-27 17:16 发表评论

ID刀 — Fri, 27 Feb 2009 07:09:00 GMT

来源�Q?a style="color: #339966" >http://java.chinaitlab.com/EJB/743927.html

Java企业�U�版本，或者说Java EE(以前叫J2EE),对于开�?a class="channel_keylink" target="_blank">服务�?/a>端的应用来说是一个强大的但却又过于复杂的的��^台。从它诞生之日�v�Q�过于复杂一直是对��用Java EE犹��U不决的一个重要因素。在JavaWorld的以前的一��文�?#8221;��化之�?#8221;中，我指��Z��那些让Java EE应用变复杂的因素�Q�其中很多都是与当前的EJB 2.1规范有关�?
　　在过�ȝ��三年中，Java开放源代码�C�֌��Q�Java�C�֌��q�程(JCP)以及主要的Java EE供应商，一直致力于让Java EE更简单。�D例来�?新的设计范例�Q�比如POJO服务�Q�服务拦截器和依赖注入，已经可以在实际应用中用来��化Java EE的开发了。还有，新的工具和框�Ӟ��比如Hibernate, AOP(aspect-oriented programming�Q�面向方面编�E?�Q�Struts,Xdoclet和Spring, 也已�l�被�q�泛用于同一目的�?
　　��化不是功能的减少

　　��化一个编�E�模型�ƈ没有减少它的功能。简化只是把复杂的逻辑隐藏��C��框架代码或可重用的组件中��M��。根本上�Q�它是把复杂的东西从需要应用开发者直接管理的地方转移��C��大多数开发者看不到的地斏V�?/p>
　　上述的模板和工具让初学者更�Ҏ��上手�Q�同时也提高了有�l�验的Java开发者的生��力，现在它们正在被JCP合�ƈ��C��一代的Java EE标准�?比如:EJB 3.0)。由Java开发�h员Raghu Kodali最�q�所做的研究昄��:��Java EE的示例程序RosterApp从EJB 2.1转到EJB 3.0可以减少癑ֈ�之五十以上的代码�?/p>
　　Java注释是EJB3.0背后的关键，它将POJO服务�Q�POJO持久化和依赖注入一��L��定�ؓ一个完整的企业�U�中间�g解决�Ҏ��。这��文章中�Q�我使用了一个示例应�?JBoss EJB 3.0 TrailBlazer�Q�来演示使用注释开发轻量��的EJB 3.0 POJO应用。TrailBlazer的应用��用EJB 3.0中不同的工具和API重复实现了一个投资计��器。示例程序完全可以在JBoss 应用服务�?/a>4.0.3版本中运行，�q�且与最新的EJB 3.0标准完全兼容(完成�?�?/p>
　　让我们来开始体验一下注释驱动编�E�模型的好处吧�?/p>
　　EJB 3.0的注释驱动编�E�模�?/p>
　　从开发者的观点来看�Q�EJB 3.0�q�泛��C��用了Java 注释.注释有两个关键优�?它们取代了过多的XML配置文�g�q�且消除了严格组件模型需求�?/p>
　　注释 vs XML

　　��Z��XML的布�|�描�q�和注释一起都可以用来在Java EE应用中配�|�服务的相关属性。它们的区别在于:XML文档是与代码分开处理的，特别是在�q�行时刻�Q�而注释是与代码编译在一��L��q�被�~�译器检查的。对于开发者来说这��有了一些重要的含义�Q�正如我下面所列出�?

　　冗长:XML配置文�g是出了名的冗长的。�ؓ了配�|�代码，XML文�g必须复制许多信息:比如代码中类名字和方法名字。Java注释则不同，它是代码的一部分�Q�不需要额外的引用��可以指明配�|�信息�?/p>
　　强壮�?在XML文�g中重复的代码信息引入了多处龃淼目赡堋�Q�热?如果你写错了�Ҏ��的名字，那应用直到运行时��L��会出错垮掉。也��是��_��XML配置文�g的强壮性就不如注释�Q�注释是被编译器��查的�Q��ƈ和其它代码一赯��处理的�?/p>
　　灉|��?既然XML文�g是在代码之外被单独处理的�Q�那也就是说��Z��XML的配�|�信息不�?#8220;��编�?#8221;的，是可以以后修改的。部�|�的灉|��性对�pȝ��理员来说是非常非常重要的特性�?/p>
　　注释是简单易用的�Q�已证明对大多数应用来说��_��了。XML文�g更复杂，但能被用来处理更高��的问题。EJB 3.0允许你通过注释来配�|�大多数的应用。EJB 3.0也支持用XML文�g来覆盖默认的注释�Q�及配置像数据库联接�q�样的外部资源�?/p>
　　除了替换和简化XML描述�W�，注释也允许我们废除困扰EJB 1.x, EJB 2.x的严格组件模型�?/p>
　　POJO　vs 严格�l��g

　　EJB �l��g是容器管�?container-managed)的对象。容器在�q�行时刻操作Bean的状态和行�ؓ。�ؓ了让行�ؓ发生�Q�EJB 2.1规范定义了一个Bean必须遵守的严格的�l��g模型。每一个EJB�c�d��M��某一�U�抽象类中��承，�q��ؓ容器提供了回调的钩子。既然Java只支持单�l�承�Q�严格组件模型就限制了开发者��用EJB�l��g创徏一个复杂对象结构的能力。当把复杂的应用数据映射到实�?Bean中的时候，正如我们在第二部分中看到的，�q�会成�ؓ一个很大的问题�?/p>
　　在EJB 3.0中，所有的容器服务都可以通过使用注释的POJO应用来配�|�和交付。大多数情况下，�q�不需要特�D�的�l��g�c�R��让我们通过JBoss EJB 3.0 TrailBlazer�C�Z��看一下如何在EJB 3.0中��用注释�?/p>
　　开发藕合松散的服务对象

　　像Java EE�q�样的企业��中间件的一个最重要的好处是允许开发者��用藕合松散的�l��g来开发应用。这些组件仅仅通过他们自己发布的商业接口来藕合。因此这些组件的实现�c�d��以在不改变应用其余部分的情况下改变自��q��实现。这��会使应用更加强壮，更容易测试，更易�U�L��。EJB 3.0使得在POJO中创��合松散的商业�l��g变得更简单了�?/p>
　　Session bean

　　在EJB 3.0应用中，藕合松散的服务组件的典型应用是Session Bean。一个Session Bean臛_��有一个接�?也就�?商业接口)�Q�其它应用组仉��过它获得服务。下面的代码为我们的投资计算器服务提供了商业接口。它只有一个方法，�Ҏ��l�定的�v始年龄，�l�止�q�龄�Q�增长率�Q�月存金额，计算出��L��资额�?/p>
public interface Calculator {
public double calculate (int start, int end,
                double growthrate, double saving);
}

　　Session bean�cȝ��单地实现了商业接口。你必须通过使用Stateless或Stateful注释来告诉EJB 3.0容器�q�个POJO�c�L��一个Session Bean。有状�?Stateful)的session bean在不同的服务��h��间维护着客户的状态。相反地�Q�对于无状�?Stateless)的session bean�Q�每�ơ的��h��都是被随机挑选的session bean实例处理的。这些行为是与EJB 2.1规范中的有状态和无状态session bean的定义是一致的。EJB 3.0容器��出何时实例化Bean对象�Q��ƈ通过商业接口让其可用。下面是session bean实现�cȝ��代码:

@Stateless
public class CalculatorBean implements Calculator {
public double calculate (int start, int end,
                    double growthrate, double saving) {
    double tmp = Math.pow(1. + growthrate / 12.,
                          12. * (end - start) + 1);
    return saving * 12. * (tmp - 1) / growthrate;
}
}

　　你也可以��Z��个session bean指明多个接口-一个�ؓ本地客户服务�Q�一个�ؓ�q�程客户服务。只要��用@Local和@Remote注释来区分。下面的代码片断昄��了同时实��C��本地和远�E�接口的CalculatorBean。如果你没有@Local和@Remote注释�Q�session bean接口默认为本地接口�?br />

@Stateless
@Local ()
@Remote ()
public class CalculatorBean implements Calculator, RemoteCalculator {
public double calculate (int start, int end,
                           double growthrate, double saving) {
    double tmp = Math.pow(1. + growthrate / 12., 12. * (end - start) + 1);
    return saving * 12. * (tmp - 1) / growthrate;
}

public String getServerInfo () {
    return "This is the JBoss EJB 3.0 TrailBlazer";
}
}

　　Session bean用户通过JNDI得到bean的一个存�?Stub)对象。容器所提供的存根对象实��C��session bean的商业接口。所有针对存根的调用都被引向了容器，由容器调用相应的实现�c�M��的接口。对于有状态的的session bean�Q�你必须自己在客��L��~�存存根对象�Q�这样在每次的后�l�调用时�Q�容器才知道要提供相同的的bean实例。下面的片断昄��如何调用session bean.在后面，你将会学到获取存根对象的更简单的�Ҏ��?/p>

InitialContext ctx = new InitialContext();
cal = (Calculator) ctx.lookup(Calculator.class.getName());
double res = cal.calculate(start, end, growthrate, saving);

Session bean生命周期的管�?/p>

　　��到藕合松散的目的�Q�应用把session bean实例的创建、缓存、销毁全部交�l�EJB 3.0容器(也就是，反向控制设计模式)。应用只和bean的商业接口打交道�?/p>
　　但如果应用需要对session对象更好的控制呢?比如��_��应用可能需要在创徏session bean的时候初始化数据库联接，而在销毁bean时关闭外部的联接。上�q�这些，你都可能通过在bean�c�M��定义生命周期的回调方法来实现。这些方法将会被容器在生命周期的不同阶段调用(�?创徏或销毁时)。通过使有下面所列的注释�Q�EJB 3.0允许你将��M��Ҏ��指定为回调方法。这不同于EJB 2.1�Q�EJB 2.1中，所有的回调�Ҏ��必须实现�Q�即使这是空的。EJB 3.0中，bean可以有�Q意数量，��L��名字的回调方法�?/p>
　　@PostConstruct:当bean对象完成实例化后�Q��用了�q�个注释的方法会被立卌��用。这个注释同旉��用于有状态和无状态的session bean�?/p>
　　@PreDestroy:使用�q�个注释的方法会在容器从它的对象池中销毁一个无用的或者过期的bean实例�q�前调用。同旉��用于有状态和无状态的session bean.

　　@PrePassivate:当一个有状态的session bean实例�I�闲�q�长的时��_��容器��会钝化它，�q�把它的状态保存下来。��用这个注释的�Ҏ��会在容器钝化bean实例之前调用。适用于有状态session bean�?/p>
　　@PostActivate:当客��L��再次使用已经被钝化的的有状态session bean�Ӟ��新的实例被创建，状态被恢复。��用此注释的session bean会在bean的激�z�d��成时调用�?/p>
　　@Init:�q�个注释指定了有状态session bean初始化的�Ҏ��。它区别于@PostConstruct注释在于:多个@Init注释�Ҏ��可以同时存在于有状态session bean 中，但每个bean实例只会有一个@Init注释的方法会被调用。这取决于bean是如何创建的(�l�节��L��EJB 3.0规范)。@PostConstruct在@Init之后被调用�?/p>
　　另一个有用的生命周期�Ҏ��注释是@Remove�Q�特别是对于有状态session bean。当应用通过存根对象调用使用了@Remove注释的方法时�Q�容器就知道在该�Ҏ��执行完毕后，要把bean实例从对象池中移走�?br />

@Stateful
public class CalculatorBean implements Calculator, Serializable {
    // ... ...

    @PostConstruct
    public void initialize () {
        // Initializes the history records and load
        // necessary data from database etc.
// 初始化历史记录，�q�从数据库中装入必需的数据�?br />     }

    @PreDestroy
    public void exit () {
        // Save history records into database if necessary.
// 如有必要则将历史记录保存��x��据库�?br />     }

    @Remove
    public void stopSession () {
        // Call to this method signals the container
        // to remove this bean instance and terminates
        // the session. The method body can be empty.
// 调用�q�个�Ҏ��来通知容器��bean实例�U�除�q�中止session.
// �q�个�Ҏ��可以为空�?br />     }

    // ... ...
}

　 消息驱动bean

　　Session bean服务提供了同步调用的�Ҏ��。另一个重要的藕合松散服务�c�d��是一�U�通过�q�入的消息来触发的异步服�?比如:email或Java消息服务产生的消�?。EJB 3.0的消息驱动bean(MDB)是设计用来专门处理基于消息请求的�l��g�?/p>
　　一个MDB�c�d��d��现MessageListener接口。当容器��到bean守候的队列一条消息时�Q�就调用onMessage()�Ҏ��Q�将消息作�ؓ参数传入。MDB在OnMessage()中决定如何处理该消息。你可以用注释来配置MDB侦听哪一条队列。当MDB部��v�Ӟ��容器��会用到其中的注释信息。在下面的例子中�Q�CalculatorBean MDB会在JMS队列queue/mdb有消息进入时调用。MDB解析消息�Q��ƈ�Ҏ��消息内容计算投资�?br />

@MessageDriven(activateConfig =
{
@ActivationConfigProperty(propertyName="destinationType",
    propertyValue="javax.jms.Queue"),
@ActivationConfigProperty(propertyName="destination",
    propertyValue="queue/mdb")
})
public class CalculatorBean implements MessageListener {
public void onMessage (Message msg) {
    try {
      TextMessage tmsg = (TextMessage) msg;
      Timestamp sent =
          new Timestamp(tmsg.getLongProperty("sent"));
      StringTokenizer st =
          new StringTokenizer(tmsg.getText(), ",");

      int start = Integer.parseInt(st.nextToken());
      int end = Integer.parseInt(st.nextToken());
      double growthrate = Double.parseDouble(st.nextToken());
      double saving = Double.parseDouble(st.nextToken());

      double result =
          calculate (start, end, growthrate, saving);
      RecordManager.addRecord (sent, result);

    } catch (Exception e) {
      e.printStackTrace ();
    }
}

// ... ...
}

　　依赖注入
在上一节中�Q�你学到了如何开发藕合松散的服务�l��g。但是，��Z��存取那些服务对象�Q�你需要通过服务器的JNDI来查扑֭�根对�?session bean)或消息队�?MDB)。JNDI查找是把客户端与实际的服务端实现解藕的关键步骤。但是，直接使用一个字�W�串来进行JNDI查找�q�不优雅。有�q�样几个原因:
　　客户端与服务端必��L��一致的��Z��字符串的名字。它没有在编译时得到认证或在布��v时得到检查�?/p>
　　从JNDI�q�回的服务对象的�c�d��没有在编译时�q�行��查，有可能在�q�行时出现�{�?casting)错误�?/p>
　　冗长的查找代码，有着自己的try-catch代码块，在应用之间是重复的和杂�ؕ�?/p>
　EJB 3.0�Q�对��M��POJO,提供了一个简单的和优雅的�Ҏ��来解藕服务对象和资源。��用@EJB注释�Q�你可以��EJB存根对象注入��C�Q何EJB 3.0容器��理的POJO中。如果注释用在一个属性变量上�Q�容器将会在它被�W�一�ơ访问之前赋值给它正��的倹{��下面的例了演示了怎样把CalculatorBean无状态session bean的存�Ҏ��入到CalculatorMDB MDB�c�M��?/p>
public class CalculatorMDB implements MessageListener {

@EJB Calculator cal;

// Use the cal variable
// ... ...
}

　　注释如果被用在JavaBean风格的setter�Ҏ��上时�Q�容器会在属性第一�ơ��用之前，自动地用正确的参数调用bean的setter�Ҏ��。下面的片断演示了这是如何做�?

public class CalculatorMDB implements MessageListener {
Calculator cal;

@EJB
public void setCal (Calculator cal) {
    this.cal = cal;
}

// Use the cal variable
// 使用cal变量
// ... ...
}

　　除@EJB注释之外�Q�EJB 3.0也支持@Resource注释来注入来自JNDI的�Q何资源。下面的例子中，我演�C�Z��如何注入服务器端默入的TimerService和SessionContext对象�Q�也演示了如何注入来自JNDI的命名数据库和JMS资源�?br />

@Resource
TimerService tms;
@Resource
SessionContext ctx;

@Resource (name="DefaultDS")
DataSource myDb;

@Resource (name="ConnectionFactory")
QueueConnectionFactory factory;

@Resource (name="queue/A")
Queue queue;

　　此外�Q�你也可以把一个容器管理的持久化管理器(也就是，EntityManager-�c�M��于Hibernate session对象)注入到EJB 3.0 POJO中�?/p>
　　把容器服务交�l�POJO

　　除了��理生命周期和访问藕合松散的服务对象外，EJB 3.0通过��单的注释也�ؓPOJO提供了运行时��L��务�?/p>
　　事务

　　最有用的容器服务可能就是事务管理服务，当应用出现失败或异常�Ӟ��它保证了数据库的完整性。你可以��单地��ؓ一个POJO�Ҏ��x��它的事务属性。这样容器就可以在合适的上下文中�q�行�q�个�Ҏ��。�D例来��_��下面的代码申明了容器在运行updateExchangeRate()时必��d��Z��个新的事务。当�q�个�Ҏ��退出时提交事务。实际上�Q�所有在updateExchangeRate()中被调用的方法都在此事务中运行，除非有特别申明。在updateExchangeRate()中的数据库操作要么全部成功，要么全部��p�|�?br />

@Stateless
public class CalculatorBean implements Calculator {
// ... ...

@TransactionAttribute(TransactionAttributeType.REQUIRED)
public void updateExchangeRate (double newrate) throws Exception {
    // Update the database in a loop.
// 在��@环中更新数据�?br />     // ... ...
    // The operations in the loop must all be successful or
    // the database is not updated at all.
// 循环中的操作必须全部成功或者根本不更新�?br /> }
}

　　安全

　　容器也提供了安全服务来进行用戯��证和�Ҏ��用户规则来限制对POJO的访问。对每一个POJO来说�Q�你可以通过使用@SecurityDomain注释为它指定一个安全域, 安全域告诉容器到哪里��L��密码和用戯��色列表。JBoss中的other域表明文件是classpath中的users.propertes和roles.properties。这��P��Ҏ��一个方法来��_��我们可以使用一个安全限制注释来指定谁可以运行这个方法。比如，下面的例子，容器�Ҏ��有试图调用addFund()的用戯��行认证，只允许拥有AdminUser角色的用户实际运行它。如果你没有��d��或者没有以��理员的�w�䆾��d��Q�一个安全意外将会抛出�?br />

@Stateless
@SecurityDomain("other")
public class CalculatorBean implements Calculator {
@RolesAllowed()
public void addFund (String name, double growthrate) {
    // ... ...
}

@RolesAllowed()
public void addInvestor (String name, int start, int end) {
    // ... ...
}

@PermitAll
public Collection getFunds () {
    // ... ...
}

// ... ...

@RolesAllowed()
public double calculate (int fundId, int investorId,
                                       double saving) {
    // ... ...
}
}

　　通用拦截�?/p>
　　事务和安全服务都可以被看作是容器��理的运行时��L��截器。容器拦截了对EJB存根的调用，�q�在其上应用事务上下文或�q�行安全限制�?/p>
　　在EJB 3.0中，你可以自己写拦截器来扩展容器服务。��用@AroundInvoke注释�Q�你可以��Q意bean�Ҏ��作�ؓ拦截器方法在��L��bean�Ҏ��之前和之后运行。下面的例子中，log()�Ҏ��是一个拦截器�Q�它计算和记录了其它bean�Ҏ��的执行时�?

@Stateful
public class CalculatorBean implements Calculator {
// Bean methods that are to be intercepted by "log()"
// bean�Ҏ��被log()�Ҏ��拦截
//
// ... ...

@AroundInvoke
public Object log (InvocationContext ctx)
                            throws Exception {

    String className = ctx.getBean().getClass().getName();
    String methodName = ctx.getMethod().getName();
    String target = className + "." + methodName + "()";

    long start = System.currentTimeMillis();
    System.out.println ("Invoking " + target);
    try {
      return ctx.proceed();
    } catch(Exception e) {
      throw e;
    } finally {
      System.out.println("Exiting " + target);

      cal.setTrace(cal.getTrace() + "
" +
                   "Exiting " + target);
      long time = System.currentTimeMillis() - start;
      System.out.println("This method takes " +
                          time + "ms to execute");
    }
}

ID刀 2009-02-27 15:09 发表评论

�E�序员应用EJB 3.0必要的准�?

ID刀 — Fri, 27 Feb 2009 06:49:00 GMT
来源�Q?a style="color: #339966" >http://java.chinaitlab.com/EJB/356292.html

EJB 3.0极其重视开发的��易性，�q�调整了模型。这�l�非巧合�Q�因��范的主要设计者：Linda DeMichiel选择了广泛听取外界的意见�Q��ƈ借鉴TopLink�{��品所取得的经验。这样一来，�q�项规范��可以沿着已经由流行、得到公认的技术开辟出来的道�\前进�Q�而这些道路实际上成了业内事实上的最佛_��c�?
　　那么�Q�作为程序员的你�Q�面�Ҏ��的规范，该做哪些准备呢？
　　处理好架构问�?/strong>
　　首先要确保你的架构可以利用持久性方面的标准及认可的设计模式。实际上�Q�这可能需要改动你的应用程序，不过如果你期望应用程序能�l�得��h��间的考验�Q�那么进行这�U�投入是值得的。��用会话外观、数据访问对象（DAO�Q�层或者服务层��L��好主意，不过在这里它们都臛_��重要。如果你的应用程序已�l��用远�E�实体构��成——虽然这�U�做法�ƈ不常见，那么��需要重新设计架构。访问持久性对象之前，应当先部�|�可�q�程化服务层。如果要使用实体�Q�它��应当完全是本地实体�?
　　不过�Q��用本地实体不是目的，因�ؓ实体�q��ؓ部��v人员提供了�ؓ实体声明事务�?a class="channel_keylink" target="_blank">安全需求的功能。EJB 3.0不允�怓Q何这些属性在实体层面�q�行讑֮�。相反，实体的运行环境将��p��用者来��定�Q�所以所需的�Q何事务或�?a class="channel_keylink" target="_blank">安全环境��由负责��闭的J2EE�l��g来安装或者声明�?
　　CMP应用�E�序
　　如果你已�l�是容器��理持久性（CMP�Q�用��P��那么你可能迫不及待地惌��得新�Ҏ��，希望抛弃无关的接口、不必要的bean代码以及�J�琐的XML部��v描述�W�，�q�些是与以前的实体bean开发相关的一些烦人问题。分别要扩展EJBObject和EJBLocalObject的远�E�和本地接口再也不需要了�Q�现在实体只要实现普�?a class="channel_keylink" target="_blank">Java接口�Q�POJI�Q�即可，如果它们选择�q�么做的话�?
　　其次�Q�你可能在想如何更容易地在容器中部��vEJB�Q�或者甚��x��本不用部�|Ԍ��而是在独立环境中的容器外面进行测试。因为实体是具体的普�?a class="channel_keylink" target="_blank">Java对象�Q�POJO�Q�，你就可以像一直以来创建Java对象的方式那��P��即��用new()来创建�?
　　POJO应用�E�序
　　可以通过实体��理器（EntityManager�Q�访问大部分新的持久性API。实体管理器可以注入��C��话bean里面�Q�或者用Java命名和目录接口（JNDI�Q�进行查询。实体管理器代表事务的持久性上下文。一旦发现操作单元或者实体管理器��理的对象在事务�l�束�?#8220;很脏”�Q�就会被写到外面的数�?a class="channel_keylink" target="_blank">存储区�?
　　应用�E�序可以通过抽取含有操作单元/会话工�g�Q�artifact�Q�的代码�Q�让自己不受全面变化的媄响。这样一来，��可以通过可插入方式来获得所用的实际会话。定义会话、然后允许包围层把它与外界隔��d��来，�q�类似EJB 3.0容器所采用的依赖注入范例（dependency injection paradigm�Q�。应用程序中使用的所有资源应当采用这�U�模式。在EJB 3.0中，标准资源��由应用�E�序声明�Q�随后在�q�行时被注入到bean里面�?
　　采用标准�Ҏ�?/strong>
　　EJB 3.0的许多特性可以在TopLink存在已久的特性当中找到媄子。只要��用这些特性，你就能够拥有EJB 3.0的功能，虽然API�q�没有完成�?
　　查询��是�q�样一个方面，你现在可以开始��用EJB 3.0的特性。EJB 3.0查询可以从实体管理器获得�Q��ƈ且可以在上面执行。可以在你需要直接查询SLQ、�ƈ通过查询�q�回对象的少数情况下�Q�创建本地SQL查询�?
　　查询语言往往是造成�q�移问题的根源，因�ؓ不编写实质性或者穷举性的转换分析工具�Q�就很难实现自动转换。EJB查询语言�q�种合理、有效的�Ҏ��可对关系查询语言�q�行抽象处理�Q�将受益于新增的几项�Ҏ��。现有的EJB查询语言仍可以适用�Q�不�q�EJB查询语言斚w��的更多构件和功能��进一步改�q�查询语�a�。��用EJB查询语言�~�写查询��是明智之�D�Q�因为查询语�a�不会出现重大改变�Q�除了功能上有所��d��外�?
　　�l�承
　　EJB 2.1从来没有指定真正的、自然的�l�承。实际上�Q�只有在厂商不设�|�障��的情况下才有可能实现��承，不过仍很隑֮�义及��理。EJB 3.0却不会这栗��由于具体的Java对象能够彼此�l�承�Q�也用不着定义�U�束�l�承范围的方法，所以你能够创徏��L��深度及广度的实体�l�承层次�?
　　目前可以通过TopLink Mapping Workbench或JDeveloper、映��Java对象的GUI工具以及用于映射对象的基于Java的API�Q�获得同��L��q�种灉|��性。现在你可以创徏域模型（domain model�Q�，以遵守适合你应用程序的�l�承�{�略�Q�而不必等规范发布�?
　　乐观锁定
　　TopLink支持的乐观锁定（optimistic locking�Q�模型现在将被采用到EJB 3.0模型里面。这�U�机制对应用�E�序非常有用�Q�不仅仅是因为在�?写访问比通常�?0�Q?0的情况下�Q�它可以大大提高性能�Q�还因�ؓ它有助于获得��C��pȝ��所需的那�U�可扩展架构。业界的众多应用�E�序使用�q�种主要的锁定范例，来获得Web应用�E�序所需的可扩展性。只要��用简单方法：为每个乐观锁定的对象采用数据库列和对象版本字�D�，��很�Ҏ��获得可移植性�?
　　�q�种锁定带来了另外的好处�Q�能够��用非�q�接模式的对象。只要把数据重新�q�入事务、然后通过乐观锁值验证已改动的对象是不是失效副本�Q�就很容易支持在��ȝ��状态下改动数据和关�pȝ��功能�?
　　对象�Q�关�p�L��?/strong>
　　想编写面向对象的Java�E�序�Q�却把数据保存在关系数据库里面，�q�在以前是困扰应用程序开发的一个重大问题�?
　　军_��把用于对象关�p�L��的标准化元数据和语义添加到EJB 3.0内，�q�向实现下列功能�q�出了一大步�Q�让应用�E�序能够灉|��地把应用�E�序攑֜�不同数据库上面运行，甚至可以使用不同的持久性框架来�q�行�q�行。对象－关系映射标准的第一个阶�D�将包括如今��Z��用来映射域模型的几种最��行的映��方法，譬如数据转换和一对一及多对多关系�{�。随后还会添�?#8220;高��”映射�Ҏ��?/p>

ID刀 2009-02-27 14:49 发表评论

EJB 3.0的三大类型详�?

ID刀 — Fri, 27 Feb 2009 06:35:00 GMT
来源�Q?a style="color: #339966" >http://java.chinaitlab.com/EJB/356299.html

无论你唇╞ean会话是�ؓ了执行特定�Q务，�q�是把表映射到实体bean以更新数据，都可以��用普通的Java对象和接口来完成�q�些工作�Q��ƈ且可以通过在业务方法中使用注释�Q�把�Ҏ��提供�l�客��L��?
　　Enterprise JavaBean (EJB) 是可重用的、可�U�L��?J2EE �l��g。EJB 由封装业务逻辑的方法组成。譬如说�Q�EJB 可能有这��L��业务逻辑�Q�包含了更新数据库中客户数据的方法。众多远�E�和本地客户端可以调用该�Ҏ��。另外，EJB 在容器里面运行，�q�样开发�h员只要关注bean里面的业务逻辑�Q�不必担心复杂、容易出错的问题�Q�譬如事务支持�?a class="channel_keylink" target="_blank">安全性和�q�程对象讉K��{�。EJB 作�ؓ普通Java对象�Q�POJO�Q�的形式来开发，开发�h员可以��用元数据注释�Q�metadata annotations�Q�来指定容器如何��理�q�些bean�?
　　EJB 包括三种主要�c�d��Q�会�?bean、实�?bean和消息驱动的bean。会话bean执行独立的、解除耦合的�Q务，譬如��查客��L��信用记录。实体bean是一个复杂的业务实体�Q�它代表数据库中存在的业务对象。消息驱动的bean用于接收异步JMS 消息。下面，让我们进一步研�I�EJB 3.0规范中的�q�些�c�d��?
　　一、会话bean
　　会话bean通常代表业务��程里面的操作，譬如“处理订单”。可�Ҏ��对话状态的保持性，��x��状态和无状态对会话bean�q�行分类�?
　　无状态的会话 bean没有内部状态。它们不跟踪记录从一个方法调用传递到另一个方法调用的信息。因此，每次调用无状态的业务�Ҏ��都独立于前一�ơ调用，譬如计算�E�款或者运贏V��用某个应税��D��用计��税�Ƅ��Ҏ��Ӟ��对税�Ƒր�D��行计��ƈ�q�回�l�调用方法，而不必保存调用者的内部状态供以后调用。因��些bean�q�不保持状态，所以容器对它们�q�行��理��很��单。客��L��h��无状态的bean实例�Ӟ��可以从容器保持的无状态的会话bean 实例池当中接收一个实例。另外，因�ؓ无状态的会话 bean可以�׃�n�Q�所以容器可保持数量较少的实例�ؓ许多客户端提供服务。想指定Java Bean作�ؓ无状态的会话bean加以部��v及管理，只需要�ؓ该bean��d��注释@Stateless�?
　　有状态的会话 bean在方法调用时可保持对话状态，譬如客户的网上购物�R。客户开始网上购物时�Q�可以从数据库中��索客��L��详细信息。客户往购物车里面添加商品或者从里面删除商品、下订单�{�时调用的其他方法也可以使用�q�些详细信息。不�q�，有状态的会话bean是暂时性的�Q�因为出��C��话终止、系�l�崩溃或者网�l�故障后�Q�状态不复存在。客��L��h��有状态的会话bean实例�Ӟ��׃ؓ该客��L��分配一个有状态的实例�Q��ƈ��客户端保持该�l��g的状态。要指定容器在某个方法完成后删除有状态的会话bean实例�Q�只要�ؓ该方法添加注释@Remove�?
　　会话 bean�C�Z��如下�Q?
import javax.ejb.Stateless.*;
/*A simple stateless session bean implementing the incrementValue() method of the * CalculateEJB interface.*/
@Stateless(name="CalculateEJB")
public class CalculateEJBBean
implements CalculateEJB
{
int value = 0;
public String incrementValue()
{
value++;
return "value incremented by 1";
}
}

　　二、实体bean
　　实体bean是管理持久性数据的一个对象，有可能��用几个相关的Java对象�Q��ƈ可以通过主键实现惟一性。通过��d��@Entity注释�Q�可以把某类指定为实体bean。实体bean代表数据库中的持久性数据，如客戯��中的一行或者员工表中的一条员工记录。实体bean�q�可以在多个客户端之间共享。譬如说�Q�某个员工实体bean可以由多个客��L��用于计算某员工的�q�薪或者更新员工地址。实体bean对象的特定字�D�可以成为持久性字�D�c��实体bean中没有被@Transient注释标记的所有字�D�都被视为持久性字�D�c��EJB 3.0的一个主要特性就是，能够使用元数据注释来创徏包含对象/关系映射的实体bean。譬如说�Q�想指定把实体bean的empId字段映射�?Employees表中的EMPNO属性，��p��使用@Table(name="Employees") 来注释表名，使用 @Column(name="EMPNO") 来注释字�D�，如下面的例子所�C�。另外，EJB 3.0 的一个特性是�Q�在开发期间可以方便地��试实体bean�Q�因为现在��?Oracle 应用服务�?/a>实体��试工具�Q�就可以在容器外面运行实体bean�?
　　实体 bean�C�Z��如下�Q?
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�Q�MDB�Q��ؓ实现异步通信提供了一�U�比使用直接的Java消息服务�Q�JMS�Q�更��单的�Ҏ��。MDB用于接收异步JMS消息。容器处理JMS队列和主题所需的大部分讄��q�程。它把所有消息发送给相关的MDB。MDB允许J2EE应用�E�序发送异步消息，随后�q�些消息由应用程序来处理。要把bean指定为MDB�Q�需要实现javax.jms.MessageListener接口�Q��ƈ且用@MessageDriven注释该bean�?
　　消息驱动的bean�C�Z��如下�Q?
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'") } )
/** A simple Message-Driven Bean that listens to the configured JMS Queue or Topic and gets notified via an * invocation of it's onMessage() method when a message has been posted to the Queue or Topic.The bean
* prints the contents of the message. */
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 3.0
　　EJB客户端是讉K��bean的应用程序。它不必位于客户端层上，但可以是独立的应用程序、Java 服务�?/a>��面�Q�JSP�Q�、服务器��程序或者另一个EJB。客��L��通过bean的远�E�或本地接口来��用EJB的方法，�q�程�q�是本地取决于客��L��是在同一个JVM里面�q�是不同的JVM里面。这些接口定义了bean的方法，而bean�c�负责实际实现这些方法。客��L��讉K��bean�cȝ��Ҏ��Ӟ��容器��׃��为bean生成一个代理，名�ؓ�q�程或者本地对象。远�E�或者本地对象接收请求后�Q�交�l�相应的bean实例�Q��ƈ��结果返回给客户端。想调用bean的方法，客户端需要通过使用EJB部��v描述�W�（deployment descriptor�Q�里面定义的bean名称来找到该bean。在以下的示例中�Q�客��L��使用Context对象扑ֈ�名�ؓ“Statelessejb”的bean�?
　　EJB 客户端示例如下：
import javax.naming.Context;
import javax.naming.InitialContext;
/* A simple bean client which calls methods on a stateless session 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(); }
}

ID刀 2009-02-27 14:35 发表评论

EJB 3.0学习�W�记一:开发环境搭�?

ID刀 — Fri, 27 Feb 2009 06:04:00 GMT

来源�Q?a style="color: #339966" >http://java.chinaitlab.com/EJB/757956.html

一、开发环境选择

    IDE�Q�NetBeans IDE 6.0.1
    SERVER:Sun Application Server(9.0)

二、安装NetBeans

    我��用的是NetBeans IDE 6.0.1�Q�大家可以从sum公司�|�站下蝲。安装过�E�很��单，只需要点“下一�?#8221;��?nbsp;OK了，需要注意的��是在选择要安装的应用服务�?/a>的时候，选择GlassFish V2 URL�Q�这是Sun公司在NetBeans里集成的一个应�?a class="channel_keylink" target="_blank">服务�?/a>�Q�其实也��是�Q�Sun Application Server.


        安装完成后启动NetBeans IDE 6.0.1,不知道是什么原�?当一启动IDE和应用服务器后电脑暴�?�q�程java.exe占用内存�?20M之大,不知道那位朋友可有什么好的解��x��?知道的文章下面留�a�告诉�?谢谢.


三、徏立EJB�c�d��

    新徏一�c�d��EJB3.0,��开发EJB所需要的jar包导入便OK。详�l�步骤如下：菜单中的“工具”选项里选择“�?#8221;�Q�在弹出的窗体中建立新库�q�命名�ؓEJB3.0, 然后��EJB所需要的 jar�?所有的jar包都可以在GlassFish的安装目录下的lib目录�?导入到此�c�d��里便OK�?br />

四、启动应用服务器

      启动服务器很��单，在菜单里选择“�H�口”里面�?#8220;服务”选项�Q�在弹出的窗体里选中“服务�?#8221;�Q�点开子节点，里面有个GlassFish V2的选项�Q�右�?->启动�?br />

        OK�Q�到�q�里我们的准备工作算是告一�D�落了，我们来测试下服务器是否可以正常启动�?nbsp;打开��览器，在地址栏里输入�Q�http://localhost:4848,看是不是出来如下��d��界面�?nbsp;


     输入用户名和密码登陆试试�?br />      User Name:admin
     Passwrod:adminadmin�Q�成功登录后的控制界面如下所�C�：

       EJB开发的环境搭徏基本上就搭徏好了�Q�本文就此结�?/p>

ID刀 2009-02-27 14:04 发表评论

RetentionPolicy的�?/th>	说明
RetentionPolicy.CLASS	annotation信息��被�~�译器编译时保存在class文�g中，但执行时不会在VM装蝲。也��是说不能在执行时动态取得annotation信息。未讄��@Retention时这��是默认讄��倹{�?
RetentionPolicy.RUNTIME	annotation信息��被�~�译器编译时保存在class文�g中，执行时也会被VM装蝲�?
RetentionPolicy.SOURCE	annotation信息��被�~�译器编译时舍弃掉�?

ElementType�?/th>	说明
ElementType.ANNOTATION_TYPE	应用于其他注解的元注�?/td>
ElementType.CONSTRUCTOR	构造函�?/td>
ElementType.FIELD	字段
ElementType.LOCAL_VARIABLE	�Ҏ��中的本地变量
ElementType.METHOD	�Ҏ��
ElementType.PACKAGE	�?/td>
ElementType.PARAMETER	�Ҏ��的参�?/td>
ElementType.TYPE	�c�，接口或者枚丑֣��?/td>

亚洲国产精品成人综合久久久,亚洲天堂在线播放,国产成人精品亚洲2020

WEB���试(�?

annotation的作用（转）

自定�?Java Annotation(�?

�E�序员应用EJB 3.0必要的准�?

EJB 3.0的三大类型详�?

EJB 3.0学习�W�记一:开发环境搭�?

WEB��试(�?