语源科技BlogJava-laodinghttp://www.blogjava.net/laoding/本来我以为，隐身了别人就找不到我，没有用的，像我这样拉风的男人，无论走到哪里，都像在黑暗中的萤火虫一样，那样的鲜明，那样的出众。我那忧郁的眼神，稀疏的胡茬，那微微隆起的将军肚和亲切的笑容......都深深吸引了众人...... zh-cnSat, 14 Mar 2026 23:02:16 GMTSat, 14 Mar 2026 23:02:16 GMT60设计模式之singleton模式（单态）http://www.blogjava.net/laoding/articles/298216.html老丁老丁Wed, 14 Oct 2009 07:13:00 GMThttp://www.blogjava.net/laoding/articles/298216.htmlhttp://www.blogjava.net/laoding/comments/298216.htmlhttp://www.blogjava.net/laoding/articles/298216.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/298216.htmlhttp://www.blogjava.net/laoding/services/trackbacks/298216.html

在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。

还有, singleton能够被状态化; 这样，多个单态类在一起就可以作为一个状态仓库一样向外提供服务，比如，你要论坛中的帖子计数器，每次浏览一次需要计数，单态类能否保持住这个计数，并且能synchronize的安全自动加1，如果你要把这个数字永久保存到数据库，你可以在不修改单态接口的情况下方便的做到。

另外方面，Singleton也能够被无状态化。提供工具性质的功能，

Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

我们常常看到工厂模式中类装入器(class loader)中也用Singleton模式实现的,因为被装入的类实际也属于资源。

下面来看看例子

public class Singleton {
    
    private static Singleton singleton = new Singleton();
    
    private Singleton() {
        System.out.println("已产生对象实例。");
    }
    
    public static Singleton getInstance() {
        return singleton;
    }

测试类
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Start.");
        System.out.println("start obj1");
        Singleton obj1 = Singleton.getInstance();
        System.out.println("end obj1");
        
        System.out.println("start obj2");
        Singleton obj2 = Singleton.getInstance();
        System.out.println("end obj2");
        
        if(obj1 == obj2) {
            System.out.println("对象是同一个对象");
        } else {
            System.out.println("对象不是同一个对象");
        }
        
        System.out.println("End.");

    }

}


运行测试类，看到控制台的输出如下：
Start....
start obj1
已产生对象实例。
end obj1
start obj2
end obj2
对象是同一个对象
End....

我们从上面开始看，在start obj1和end obj1直接输出了“已产生对象实例”说明有对象产生了，而start obj2和end obj2之间却没有打印，为什么呢？因为取得obj2对象的时候并没有再创建新的对象，而是去拿到跟obj1同一个对象，在Singleton类中已经创建了这个对象，并且是static的，这样也就可以解释后面的输出“对象是同一个对象”这句话了。

老丁 2009-10-14 15:13 发表评论
]]>设计模式之AbstractFactory模式（抽象工厂）http://www.blogjava.net/laoding/articles/298209.html老丁老丁Wed, 14 Oct 2009 06:45:00 GMThttp://www.blogjava.net/laoding/articles/298209.htmlhttp://www.blogjava.net/laoding/comments/298209.htmlhttp://www.blogjava.net/laoding/articles/298209.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/298209.htmlhttp://www.blogjava.net/laoding/services/trackbacks/298209.html本实例需要根据植物园的种类确定植物园的布局， 而植物园的种类有很多，对应的植物园布局也各不相同。在这里假设有3种植物园：蔬菜园，一年生植物园，多年生植物园。这3种garden中种植的植物各不相同，体现在程序中即返回不同的关于“植物园布局”的对象。生成植物园的布局是我们的目的，如果把蔬菜园、一年生植物园、多年生植物园看作是3个“产品族”，而某一时刻只需要其中一个产品族。由于每个产品族需要一个生产的工厂，所以生产这3个产品族需要3个工厂，分别是蔬菜园工厂（VegieGarden.java），一年生植物园工厂（AnnualGarden.java），多年生植物园工厂（PerennialGarden.java）。由于这3个工厂都是生产植物园的工厂，每个工厂生产的产品又基本相同（都生产“中心布局”、“边沿布局”、“阴处布局”3个产品），所以可以抽象一个工厂类（Garden.java），这个工厂类也具备生产“中心布局”、“边沿布局”和“阴处布局”3个产品的能力，而生产的方法由具体的工厂来实现。这样，再通过一个总控程序（GardenMaker.java）（这个总控程序也可以放到抽象的工厂中）指定需要调用的具体工厂。

首先来创建Plant.java类，它只有一个name属性

public class Plant {
    String name;

    public Plant(String name) {        
        this.name = name;
    }

    public String getName() {
        return name;
    }
}


然后是Garden类，3个方法分别是得到中心处、边沿处和阴暗处的植物

public abstract class Garden {
    public abstract Plant getCenter();
    public abstract Plant getBorder();
    public abstract Plant getShade();
}

下面是3个工厂类
/**
 * 一年生植物园工厂
 * @author Heinvo Lee
 *
 */
public class AnnualGarden extends Garden {

    @Override
    public Plant getCenter() {
        // TODO Auto-generated method stub
        return new Plant("Marigold");//万寿菊
    }
    
    @Override
    public Plant getBorder() {
        // TODO Auto-generated method stub
        return new Plant("Alyssum");//十字花科植物；庭荠
    }

    @Override
    public Plant getShade() {
        // TODO Auto-generated method stub
        return new Plant("Coleus");//薄荷科植物
    }

}

/**
 * 常年生植物园工厂
 * @author Heinvo Lee
 *
 */
public class PerennialGarden extends Garden {



    @Override
    public Plant getCenter() {
        // TODO Auto-generated method stub
        return new Plant("Dicentrum");
    }
    
    @Override
    public Plant getBorder() {
        // TODO Auto-generated method stub
        return new Plant("Sedum");//景天属植物；八宝
    }

    @Override
    public Plant getShade() {
        // TODO Auto-generated method stub
        return new Plant("Astilbe");//落新妇属植物
    }

}

/**
 * 蔬菜园工厂
 * @author Heinvo Lee
 *
 */
public class VegieGarden extends Garden {

    public Plant getCenter() {
        return new Plant("Corn");
        }
    public Plant getBorder() {
        return new Plant("Peas");
        }
    
    public Plant getShade() {        
        return new Plant("Broccoli");//花椰菜
        }

}

接下来创建总控类GardenMaker
public class GardenMaker {
    private Garden garden;
    public Garden getGarden(String gtype)
    {
        garden = new VegieGarden(); //default
    if(gtype.equals("Perennial"))
        garden = new PerennialGarden();
    if(gtype.equals("Annual"))
        garden = new AnnualGarden();
    return garden;
    }
}

然后是一个测试类了
public class Main {

    /**
     * @param args
     */
    public static void main(String[] args) {
        GardenMaker gm=new GardenMaker();
        Garden vg=gm.getGarden("Vegie");
        Garden ag=gm.getGarden("Annual");
        Garden pg=gm.getGarden("Perennial");
        
        System.out.println("Vegie garden, center: "+vg.getCenter().getName());
        System.out.println("Vegie garden, border: "+vg.getBorder().getName());
        System.out.println("Vegie garden, shade: "+vg.getShade().getName());
        System.out.println("------------------------------------");
        System.out.println("Annual garden, center: "+ag.getCenter().getName());
        System.out.println("Annual garden, border: "+ag.getBorder().getName());
        System.out.println("Annual garden, shade: "+ag.getShade().getName());
        System.out.println("------------------------------------");
        System.out.println("Perennial garden, center: "+pg.getCenter().getName());
        System.out.println("Perennial garden, border: "+pg.getBorder().getName());
        System.out.println("Perennial garden, shade: "+pg.getShade().getName());
        
        // TODO Auto-generated method stub

    }

}

执行这个测试类，可以在控制台看到以下效果（我以红色标红）

Vegie garden, center: Corn
Vegie garden, border: Peas
Vegie garden, shade: Broccoli
------------------------------------
Annual garden, center: Marigold
Annual garden, border: Alyssum
Annual garden, shade: Coleus
------------------------------------
Perennial garden, center: Dicentrum
Perennial garden, border: Sedum
Perennial garden, shade: Astilbe

从这个例子我看出以下：
  GardenMaker gm=new GardenMaker();
  Garden vg=gm.getGarden("Vegie");
  Garden ag=gm.getGarden("Annual");
  Garden pg=gm.getGarden("Perennial");
上面4句代码是测试类里面的

当需要生产某一种植物园的布局时，只需要将植物园的类型告诉总控程序（GardenMaker.java），这里是传入参数Vegie、Annual、Perennial，总控程序决定使用生产指定类型植物园的工厂生产出需要的“产品族”，而在此过程中，不需要了解具体工厂中的方法是如何实现的。

老丁 2009-10-14 14:45 发表评论
]]>项目杂谈（关于项目成员选择的假设）http://www.blogjava.net/laoding/articles/297930.html老丁老丁Mon, 12 Oct 2009 09:28:00 GMThttp://www.blogjava.net/laoding/articles/297930.htmlhttp://www.blogjava.net/laoding/comments/297930.htmlhttp://www.blogjava.net/laoding/articles/297930.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/297930.htmlhttp://www.blogjava.net/laoding/services/trackbacks/297930.html现在终于清闲一点了，前段时候带项目挺忙的，是市政府里头的一个项目，虽然不大但是这是我第一次带项目，从中就总结出一些问题，我就这次项目的组员问题，做出下一次如果带项目选组员的假设，下面来假设一下：

1.能力强的但不是很听话的和能力一般但是做事很实在很好配合的，如果有机会来挑的话，我会选择后者，前者一律不要，就这次的项目来讲我就觉得能力不是放在第一位的，试想你就你的其中一个组员要往东他却往西，非但影响项目进度而且会让你个人心情相当的不愉快，当项目经理的心里不愉快了，整个项目都愉快不起来，当然我并不是说能力不重要。

2.性格和态度有问题的kill掉，首先是性格有问题的，这个是指跟项目组搭不上调的，也就是喜欢单打独斗的，就目前项目的形式都是要各个组员来相互协调合作，各個模块之間都很有可能有公用或调用的地方，一个组员的单打独斗很有课能拖项目进度因为要返工；态度问题我这次是深有体会的，有个组员让我极度郁闷，一个模块叫他搞定一下，他竟然两个星期没搞出来，能力问题？我不这么认为，基本上就是把以前写过的代码整理出来加到项目中，如此事情2个星期没搞定，我汗！！若说我没督促那就太搞笑了，就在告诉他任务以后过了2-3天，我会问其进度，每次都未果，难道要我天天跟赶牛似的？他愿意当牛我还不愿意赶呢，这个明显就是态度问题，最后我自己来写了。

3.这个就是推任务的，安排个任务给他总是推三阻四的，凭良心讲我并没有安排啥重的给你，然后其他人轻松了，事实上大家都差不多，而且往往是把任务往我身上推，这点让我很不爽，我有那么多时间？我自己都忙的要死，说的难听点即使我有那个时间我安排你做怎么样呢？不做的话要你在项目组里干什么？但是我一直没这么说，不想把关系搞僵。

以上是假设，如其中人物有所雷同，纯属巧合。

小弟的拙见，献丑了，欢迎大家批评、指正、指导。



老丁 2009-10-12 17:28 发表评论
]]>lucene增量索引的简单实现http://www.blogjava.net/laoding/articles/279230.html老丁老丁Sun, 31 May 2009 08:37:00 GMThttp://www.blogjava.net/laoding/articles/279230.htmlhttp://www.blogjava.net/laoding/comments/279230.htmlhttp://www.blogjava.net/laoding/articles/279230.html#Feedback11http://www.blogjava.net/laoding/comments/commentRss/279230.htmlhttp://www.blogjava.net/laoding/services/trackbacks/279230.html 数据库有两个字段id和title，话不多说，直接上代码，一看便知

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
import org.apache.lucene.index.IndexWriter;

public class Index {

    public static void main(String[] args) {
        try {
            Index index = new Index();
            String path = "d:\\index";//索引文件的存放路径
            String storeIdPath = "d:\\storeId.txt";//存储ID的路径
            String storeId ="";
            storeId = index.getStoreId(storeIdPath);
            ResultSet rs = index.getResult(storeId);
            index.indexBuilding(path, storeIdPath, rs);
            storeId = index.getStoreId(storeIdPath);
            System.out.println(storeId);//打印出这次存储起来的ID
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public ResultSet getResult(String storeId) throws Exception{
        Class.forName("com.mysql.jdbc.Driver").newInstance();
        String url = "jdbc:mysql://localhost:3306/ding";
        String userName = "root";
        String password = "ding";
        Connection conn = DriverManager.getConnection(url,userName,password);
        Statement stmt = conn
            .createStatement();
        ResultSet rs = stmt
            .executeQuery("select * from newitem where id > '"+storeId+"'order by id");
        return rs;
    }

    public boolean indexBuilding(String path,String storeIdPath, ResultSet rs) {// 把RS换成LIST原理一样

        try {
            Analyzer luceneAnalyzer = new StandardAnalyzer();
            // 取得存储起来的ID，以判定是增量索引还是重新索引
            boolean isEmpty = true;
             try { 
                File file = new File(storeIdPath);
                if (!file.exists()) {
                    file.createNewFile();
                }
                FileReader fr = new FileReader(storeIdPath);
                BufferedReader br = new BufferedReader(fr);                 
                if(br.readLine()!= null) {
                    isEmpty = false;
                 }
                 br.close();
                 fr.close(); 
                } catch (IOException e) { 
                   e.printStackTrace();
              }

            IndexWriter writer = new IndexWriter(path, luceneAnalyzer, isEmpty);//参数isEmpty是false表示增量索引
            String storeId = "";
            boolean indexFlag = false;
            String id;
            String title;
            while (rs.next()) {
                // for(Iterator it = list.iterator();it.hasNext();){
                id = rs.getString("id");
                title = rs.getString("title");
                writer.addDocument(Document(id, title));
                storeId = id;//将拿到的id给storeId，这种拿法不合理，这里为了方便
                indexFlag = true;
            }
            writer.optimize();
            writer.close();
            if(indexFlag){
                // 将最后一个的ID存到磁盘文件中
                this.writeStoreId(storeIdPath, storeId);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("出错了" + e.getClass() + "\n   错误信息为:   "
                    + e.getMessage());
            return false;
        }

    }


    public static Document Document(String id, String title) {
        Document doc = new Document();
        doc.add(new Field("ID", id, Field.Store.YES, Field.Index.TOKENIZED));
        doc.add(new Field("TITLE", title, Field.Store.YES,
                Field.Index.TOKENIZED));
        return doc;
    }

    // 取得存储在磁盘中的ID
    public static String getStoreId(String path) {
        String storeId = "";
        try {
            File file = new File(path);
            if (!file.exists()) {
                file.createNewFile();
            }
            FileReader fr = new FileReader(path);
            BufferedReader br = new BufferedReader(fr);
            storeId = br.readLine();
            if (storeId == null || storeId == "")
                storeId = "0";
            br.close();
            fr.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return storeId;
    }

    // 将ID写入到磁盘文件中
    public static boolean writeStoreId(String path,String storeId) {
        boolean b = false;
        try {
            File file = new File(path);
            if (!file.exists()) {
                file.createNewFile();
            }
            FileWriter fw = new FileWriter(path);
            PrintWriter out = new PrintWriter(fw);
            out.write(storeId);
            out.close();
            fw.close();
            b=true;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return b;
    }
}

这里代码写的比较简单，很多需要改进的地方，自己改进就行了，这里只是说明了增量索引的原理，望指正。



老丁 2009-05-31 16:37 发表评论
]]>得到复选框(checkbox)的值http://www.blogjava.net/laoding/articles/277254.html老丁老丁Fri, 22 May 2009 03:07:00 GMThttp://www.blogjava.net/laoding/articles/277254.htmlhttp://www.blogjava.net/laoding/comments/277254.htmlhttp://www.blogjava.net/laoding/articles/277254.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/277254.htmlhttp://www.blogjava.net/laoding/services/trackbacks/277254.html<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<title>查看复选框ID</title>
<script type="text/javascript">
    function getCheckboxId(){//得到复选框ID的js函数
        var c = document.getElementsByName('checkbox');
            var counter = 0;
            var idArray = new Array();//把ID放在数组里面
            for(var i = 0;i<c.length;i++){
              if(c[i].checked){
                idArray[i]=c[i].value;
                counter++;
              }
            }
            if(counter ==0){
              alert('请选择记录！');
              return false;
            }
            alert(idArray);
    }
    
    function gotoCheckAll(){//选中或者取消全部选择项
        if(document.getElementById("checkAll").checked){
            var c = document.getElementsByName('checkbox');
            for(var i = 0;i<c.length;i++){
                c[i].checked ="checked";
            }
        }else{
            var c = document.getElementsByName('checkbox');
            for(var i = 0;i<c.length;i++){
                c[i].checked ="";
            }
        }
    }
</script>
</head>
<body>
<!--一个有几条数据的表格-->
<table width="100%" align="center"  border="1" bordercolor="#adc9d7" bordercolordark="#FFFFFF" cellspacing="0"
            cellpadding="0">
            <tr>
                <td width="5%" class="table_title" align="center">
                    <input type="checkbox" name="checkAll" id="checkAll"  onclick="gotoCheckAll();" />
                </td>
                
                <td width="15%" class="table_title" align="center">
                    用户名
                </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="checkbox" name="checkbox" value="1" />
                    </td>
                    <td align="center">
                        &nbsp;ding1
                    </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="checkbox" name="checkbox" value="2" />
                    </td>
                    <td align="center">
                        &nbsp;ding2
                    </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="checkbox" name="checkbox" value="3" />
                    </td>
                    <td align="center">
                        &nbsp;ding3
                    </td>
            </tr>
        </table>
        <br />
        <center><input type="button" value="查看ID" onclick="getCheckboxId();"/></center>
</body>
</html>

老丁 2009-05-22 11:07 发表评论
]]>得到单选框(radio)的值http://www.blogjava.net/laoding/articles/277253.html老丁老丁Fri, 22 May 2009 03:06:00 GMThttp://www.blogjava.net/laoding/articles/277253.htmlhttp://www.blogjava.net/laoding/comments/277253.htmlhttp://www.blogjava.net/laoding/articles/277253.html#Feedback1http://www.blogjava.net/laoding/comments/commentRss/277253.htmlhttp://www.blogjava.net/laoding/services/trackbacks/277253.html 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<title>查看单选框ID</title>
<script type="text/javascript">
    function getRadioId(){//得到单选框ID的js函数
        var c = document.getElementsByName('radio');
            var counter = 0;
            var j;
            for(var i = 0;i<c.length;i++){
              if(c[i].checked){
                counter++;
                j = i;
              }
            }
            if(counter ==0){
              alert('请选择记录！');
              return false;
            }
            var id = c[j].value;
            alert(id);
    }
</script>
</head>
<body>
<!--一个有几条数据的表格-->
<table width="100%" align="center"  border="1" bordercolor="#adc9d7" bordercolordark="#FFFFFF" cellspacing="0"
            cellpadding="0">
            <tr>
                <td width="5%" class="table_title" align="center">
                    选择
                </td>
                
                <td width="15%" class="table_title" align="center">
                    用户名
                </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="radio" name="radio" value="1" />
                    </td>
                    <td align="center">
                        &nbsp;ding1
                    </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="radio" name="radio" value="2" />
                    </td>
                    <td align="center">
                        &nbsp;ding2
                    </td>
            </tr>
            <tr bgcolor="white">
                    <td align="center">
                        <input type="radio" name="radio" value="3" />
                    </td>
                    <td align="center">
                        &nbsp;ding3
                    </td>
            </tr>
        </table>
        <br />
        <center><input type="button" value="查看ID" onclick="getRadioId();"/></center>
</body>
</html>


老丁 2009-05-22 11:06 发表评论
]]>hibernate分页查询的实现http://www.blogjava.net/laoding/articles/272015.html老丁老丁Thu, 21 May 2009 08:22:00 GMThttp://www.blogjava.net/laoding/articles/272015.htmlhttp://www.blogjava.net/laoding/comments/272015.htmlhttp://www.blogjava.net/laoding/articles/272015.html#Feedback3http://www.blogjava.net/laoding/comments/commentRss/272015.htmlhttp://www.blogjava.net/laoding/services/trackbacks/272015.html
    create table `ding`.`user`(
        `id` int default '' not null,
       `username` varchar(30),
       `password` varchar(30),
        primary key (`id`)
    );

切换到数据库透视图，新建一个mysql连接（这里就不再多说了）。

新建一个web工程，然后右键选择myeclipse，选择add hibernate........ ，把hibernate的jar加入到工程中，选择的时候注意jar包要放在lib中，可以检查下，其中有一下会选择刚新建的mysql连接，加完以后就会看到SRC下多了一个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">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ding
        </property>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="myeclipse.connection.profile">mysql</property>
        <property name="connection.password">ding</property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>

    </session-factory>

</hibernate-configuration>

切换到数据库透视图，启动那个连接找到建的USER表，右键选择Hibernate Reverse Engineering...，在弹出的框里面点击 Java src folder 一行最右侧的 Browser.. 按钮来选择源码目录，这里我选择自己工程src 目录，并把下面的 Java package 右侧的输入框中输入自己想要的包名，我这里是test，接着选中下面的复选框，我选前面两个:
[x] Hibernate mapping file (*.hbm.xml) for each database table
[x] Java Data Object (POJO <> DB Table)
第2项下面的复选create abstract class我这里不选，点击next，再在ID generator选择increment（自增长），点完成。

返回j2ee透视图，会看到在test包下生成了User.java和User.hbm.xml文件，如下：
public class User implements java.io.Serializable {

    private Integer id;

    private String username;

    private String password;


    public Integer getId() {
        return this.id;
    }

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

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="test.User" table="user">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="increment" />
        </id>
        <property name="username" type="java.lang.String">
            <column name="username" length="30" />
        </property>
        <property name="password" type="java.lang.String">
            <column name="password" length="30" />
        </property>
    </class>
</hibernate-mapping>

同时在原先的hibernate.cfg.xml中加入了  <mapping resource="test/User.hbm.xml" />，最终的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">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ding
        </property>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="myeclipse.connection.profile">mysql</property>
        <property name="connection.password">ding</property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <mapping resource="test/User.hbm.xml" />

    </session-factory>

</hibernate-configuration>

写个Test测试类

public class Test {

    /**  
     *   @Description 方法实现功能描述  
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        
      SessionFactory sf = new Configuration().configure().buildSessionFactory();
      Session session = sf.openSession();
      String hql = "from User";
      int curpage = 1;//当前页 
      int pagesize = 2;//每页显示数
      //以上两项有一项为0则查出所有记录
      List list = findOnePage(session, hql, curpage, pagesize);
      for(Iterator i = list.iterator();i.hasNext();){
          User user = (User) i.next();
          System.out.println("username==="+user.getUsername());
      }
    }

    public static List findOnePage(Session session,String strHQL, int offset, int pagesize){
        List lst = null;
        try {
            Query query = session.createQuery(strHQL);
            if (offset != 0 && pagesize != 0) {
                query.setFirstResult((offset - 1) * pagesize);
                query.setMaxResults(pagesize);
            }
            lst = query.list();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return lst;
    }

}

测试下就可以看到效果了
   int curpage = 1;//当前页
   int pagesize = 2;//每页显示数
可以改这两个参数试试

老丁 2009-05-21 16:22 发表评论
]]>jquery动态表格的简单实现 http://www.blogjava.net/laoding/articles/269062.html老丁老丁Tue, 05 May 2009 13:23:00 GMThttp://www.blogjava.net/laoding/articles/269062.htmlhttp://www.blogjava.net/laoding/comments/269062.htmlhttp://www.blogjava.net/laoding/articles/269062.html#Feedback3http://www.blogjava.net/laoding/comments/commentRss/269062.htmlhttp://www.blogjava.net/laoding/services/trackbacks/269062.htmlhttp://www.blogjava.net/absolutedo/archive/2009/03/13/259488.html

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="Content-type" content="text/html; charset=utf-8">
<script type="text/javascript" src="jquery-1.2.6.js"></script>
<script type="text/javascript">
    function gotoAdd(){
        var tableTrElement = $("#testTable tr");//得到表格所有行
        var len = tableTrElement.length;//得到总行数
        var tableElement = $("#testTable");//得到表格对象
        tableElement.append("<tr id=test"+(len+1)+"><td align=\'center\'>"+len+"</td><td align=\'center\'>ding"+len+"</td><td align=\'center\'><input type=\'button\' value=\'delete\' onclick=\'gotoDelete("+(len+1)+")\'/></td></tr>");
    }
    function gotoDelete(index){
        var tableTrElement = $("#testTable tr");
         if(index>tableTrElement.length){
              return;
          }else{
              $("tr[id=\'test"+index+"\']").remove(); //移除id为 "test"+index 的TR
                   for(var temp=index+1;temp<=tableTrElement.length;temp++){//循环所删除那个TR后面的所有TR
                       $("tr[id=\'test"+temp+"\']").replaceWith("<tr id=test"+(temp-1)+"><td align=\'center\'>"+(temp-2)+"</td><td align=\'center\'>ding"+(temp-2)+"</td><td align=\'center\'><input type=\'button\' value=\'delete\' onclick=\'gotoDelete("+(temp-1)+")\'/></td></tr>");
                     } 
          } 
    }
</script>
</head>

<body>
<input type="button" value="添加行" onclick="gotoAdd()">
 <table id="testTable" border="1" width="80%" align="center">
     <tr>
         <td width="20%" align="center">序号</td>
         <td align="center">标题</td>
         <td align="center">操作</td>
     </tr>    
 </table>
</body>
</html>


老丁 2009-05-05 21:23 发表评论
]]>JSTL1.1函数标签库(functions)如fn:lengthhttp://www.blogjava.net/laoding/articles/261203.html老丁老丁Sat, 21 Mar 2009 07:23:00 GMThttp://www.blogjava.net/laoding/articles/261203.htmlhttp://www.blogjava.net/laoding/comments/261203.htmlhttp://www.blogjava.net/laoding/articles/261203.html#Feedback2http://www.blogjava.net/laoding/comments/commentRss/261203.htmlhttp://www.blogjava.net/laoding/services/trackbacks/261203.html本文转自：http://tgyd2006.javaeye.com/blog/169826

在jstl中的fn标签也是我们在网页设计中经常要用到的很关键的标签，在使用的时候要先加上头

<%@ taglib uri="http://java.sun.com/jsp/jstl/functions"  prefix="fn"%>就可以使用fn标签了。

具体使用方法请参见下表：

函数

描述

fn:contains(string, substring)

如果参数string中包含参数substring，返回true

fn:containsIgnoreCase(string, substring)

如果参数string中包含参数substring（忽略大小写），返回true

fn:endsWith(string, suffix)

如果参数 string 以参数suffix结尾，返回true

fn:escapeXml(string)

将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回

fn:indexOf(string, substring)

返回参数substring在参数string中第一次出现的位置

fn:join(array, separator)

将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。

fn:length(item)

返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。

fn:replace(string, before, after)

返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果

fn:split(string, separator)

返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素

fn:startsWith(string, prefix)

如果参数string以参数prefix

开头，返回true

fn:substring(string, begin, end)

返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符

fn:substringAfter(string, substring)

返回参数substring在参数string中后面的那一部分字符串

fn:substringBefore(string, substring)

返回参数substring在参数string中前面的那一部分字符串

fn:toLowerCase(string)

将参数string所有的字符变为小写，并将其返回

fn:toUpperCase(string)

将参数string所有的字符变为大写，并将其返回

fn:trim(string)

去除参数string 首尾的空格，并将其返回


老丁 2009-03-21 15:23 发表评论
]]>经济危机影响你的工作了吗？http://www.blogjava.net/laoding/articles/247205.html老丁老丁Thu, 18 Dec 2008 11:58:00 GMThttp://www.blogjava.net/laoding/articles/247205.htmlhttp://www.blogjava.net/laoding/comments/247205.htmlhttp://www.blogjava.net/laoding/articles/247205.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/247205.htmlhttp://www.blogjava.net/laoding/services/trackbacks/247205.html

老丁 2008-12-18 19:58 发表评论
]]>hibernate简单入门实例http://www.blogjava.net/laoding/articles/245772.html老丁老丁Thu, 11 Dec 2008 11:23:00 GMThttp://www.blogjava.net/laoding/articles/245772.htmlhttp://www.blogjava.net/laoding/comments/245772.htmlhttp://www.blogjava.net/laoding/articles/245772.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/245772.htmlhttp://www.blogjava.net/laoding/services/trackbacks/245772.html 在mysql中新建数据好USER表，字段有3个，分别是id、username、password，贴上脚本仅供参考

    create table `ding`.`user`(
        `id` int default '' not null,
       `username` varchar(30),
       `password` varchar(30),
        primary key (`id`)
    );

切换到数据库透视图，新建一个mysql连接（这里就不再多说了）。

新建一个web工程，然后右键选择myeclipse，选择add hibernate........ ，把hibernate的jar加入到工程中，选择的时候注意jar包要放在lib中，可以检查下，其中有一下会选择刚新建的mysql连接，加完以后就会看到SRC下多了一个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">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ding
        </property>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="myeclipse.connection.profile">mysql</property>
        <property name="connection.password">ding</property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>

    </session-factory>

</hibernate-configuration>

切换到数据库透视图，启动那个连接找到建的USER表，右键选择Hibernate Reverse Engineering...，在弹出的框里面点击 Java src folder 一行最右侧的 Browser.. 按钮来选择源码目录，这里我选择自己工程src 目录，并把下面的 Java package 右侧的输入框中输入自己想要的包名，我这里是test，接着选中下面的复选框，我选前面两个:
[x] Hibernate mapping file (*.hbm.xml) for each database table
[x] Java Data Object (POJO <> DB Table)
第2项下面的复选create abstract class我这里不选，点击next，再在ID generator选择increment（自增长），点完成。

返回j2ee透视图，会看到在test包下生成了User.java和User.hbm.xml文件，如下：
public class User implements java.io.Serializable {

    private Integer id;

    private String username;

    private String password;


    public Integer getId() {
        return this.id;
    }

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

    public String getUsername() {
        return this.username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return this.password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

}


<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
    <class name="test.User" table="user">
        <id name="id" type="java.lang.Integer">
            <column name="id" />
            <generator class="increment" />
        </id>
        <property name="username" type="java.lang.String">
            <column name="username" length="30" />
        </property>
        <property name="password" type="java.lang.String">
            <column name="password" length="30" />
        </property>
    </class>
</hibernate-mapping>

同时在原先的hibernate.cfg.xml中加入了  <mapping resource="test/User.hbm.xml" />，最终的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">

<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

    <session-factory>
        <property name="connection.username">root</property>
        <property name="connection.url">
            jdbc:mysql://localhost:3306/ding
        </property>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="myeclipse.connection.profile">mysql</property>
        <property name="connection.password">ding</property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <mapping resource="test/User.hbm.xml" />

    </session-factory>

</hibernate-configuration>

写个Test测试类
public class Test {

    /**  
     *   @Description 方法实现功能描述  
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        
        SessionFactory sf = new Configuration().configure().buildSessionFactory();
      Session session = sf.openSession();
      Transaction tx = session.beginTransaction();
      User u = new User();
      u.setUsername("laoding");
      u.setPassword("123");
      session.save(u);
      tx.commit();
      
      String hql = "from User";
      Query query = session.createQuery(hql);
      List list = query.list();
      for(Iterator i = list.iterator();i.hasNext();){
          User user = (User) i.next();
          System.out.println("username==="+user.getUsername());
      }
    }

}

执行这个类，看到后台打印
username===laoding

去看看表里数据已经插入，完成。

老丁 2008-12-11 19:23 发表评论
]]>ajax初探http://www.blogjava.net/laoding/articles/244006.html老丁老丁Tue, 02 Dec 2008 12:20:00 GMThttp://www.blogjava.net/laoding/articles/244006.htmlhttp://www.blogjava.net/laoding/comments/244006.htmlhttp://www.blogjava.net/laoding/articles/244006.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/244006.htmlhttp://www.blogjava.net/laoding/services/trackbacks/244006.html
AJAX (异步 javascript 和 XML) 是个新产生的术语，专为描述javascript的两项强大性能，这两项强大性能是：
        1.无需重新装载整个页面便能向服务器发送请求.
　　2.对XML文档的解析和处理．

发送HTTP请求：

首先创造一个类实例
    try{
                     request  =   new  XMLHttpRequest();
                   }catch(trymicrosoft) {
                      try{
                           request = new  ActiveXObject("Msxml2.XMLHTTP");
                     }catch(othermicrosoft){
                        try{
                             request  =   new  ActiveXObject("Microsoft.XMLHTTP");
                           }catch  (failed) {
                             request  =   false ;
                           }  
                     }
                   }

得到响应后就用这句：
    request.onreadystatechange = loginCallBack;

这里指出要用那个JS函执行，这里是loginCallBack函数，这里的函数无需括号也无需参数。

在定义了如何处理响应后,就要发送请求了。可以调用HTTP请求类的open()和send()方法，如下所示：
request.open("get",url,true);
request.send(null);
        open()的第一个参数是HTTP请求方式 - GET，POST，HEAD 或任何服务器所支持的您想调用的方式。这个参数最好大写，某些浏览器(如Firefox)可能无法处理请求。
　　第二个参数是请求页面的URL.由于自身安全特性的限制,该页面不能为第三方域名的页面.同时一定要保证在所有的页面中都使用准确的域名,否则调用出错。
　　第三个参数设置请求是否为异步模式。如果是TRUE, javascript函数将继续执行，而不等待服务器响应。
如果第一个参数是post，send方法可以传递参数格式跟我们WEB开发是浏览器地址一回事，多个可以用&连接：？？=？？&？？=？？（用问号表示下）。

function  loginCallBack(){
                if(request.readyState  ==   4 ) 
                    if  (request.status  ==   200 ){ 
                          var  mess  =  request.responseText;                                                    
                    }
           }


这里首先函数检查请求的状态，如果是4，就意味着一个完整的服务器响应已经收到了，可以处理该响应。

　readyState的值如下:
　　0 (未初始化)
　　1 (正在装载)
　　2 (装载完毕)
　　3 (交互中)
　　4 (完成)

然后，函数会检查HTTP服务器响应的状态值，是200表示状态完整。
当这两个当满足后就可以处理数据了，取得数据的方式有两种：

request.responseText
request.responseXML

第一种是以文本字符串的方式返回服务器的响应；
第二种是以XMLDocument对象方式返回响应。

下面来看例子：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<html>
  <head>   
    <title>My JSP 'index.jsp' starting page</title>
  </head>
  
  <body>
    <script type="text/javascript" language="javascript">
function gotoSubmit(){
            getRequest();//获得请求
                if(!request){
                    alert("该浏览器不支持XMLHttpRequest!");
                    return false;
                }
                request.onreadystatechange = loginCallBack;
                var url = "index.jsp";
                 request.open("post",url,false);
                 //request.open("get",url,true);
                 request.send(null);        
        }

        function getRequest(){      
                try{
                     request  =   new  XMLHttpRequest();
                   }catch(trymicrosoft) {
                      try{
                           request = new  ActiveXObject("Msxml2.XMLHTTP");
                     }catch(othermicrosoft){
                        try{
                             request  =   new  ActiveXObject("Microsoft.XMLHTTP");
                           }catch  (failed) {
                             request  =   false ;
                           }  
                     }
                   }
            }
            function  loginCallBack(){
                if(request.readyState  ==   4 ) 
                    if  (request.status  ==   200 ){ 
                          var  mess  =  request.responseText;                                                    
                    }
           }


</script>
<span
    style="cursor: pointer; text-decoration: underline"
    onclick="gotoSubmit()">
        gotoSubmit
</span>

  </body>
</html>


跑起工程后在这个页面上点击gotoSubmit，会弹出index.jsp页面的所有内容。

来看看处理xml文件，处理的xml文件如下：

<?xml version="1.0" ?>
<name>
    laoding
</name>

上面代码要改的地方有两个，第一把url换成这个xml文件的路径，第二个地方是弹出信息的地方：
var mess=request.responseText;
               alert(mess);
把这两句换成：

var xmldoc = request.responseXML;
var root_node = xmldoc.getElementsByTagName('name').item(0);
alert(root_node.firstChild.data); 

再执行程序就会看到效果了，好了，到此结束了，眼睛痛回去休息。


老丁 2008-12-02 20:20 发表评论
]]>spring aop简单日志实例(2)http://www.blogjava.net/laoding/articles/242613.html老丁老丁Tue, 25 Nov 2008 10:27:00 GMThttp://www.blogjava.net/laoding/articles/242613.htmlhttp://www.blogjava.net/laoding/comments/242613.htmlhttp://www.blogjava.net/laoding/articles/242613.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/242613.htmlhttp://www.blogjava.net/laoding/services/trackbacks/242613.html(注意是spring2.0)

来看接口，这个接口简单的不能再简单了，嘻嘻。
public interface Hello {
    String hello(String name);
}

实现类：

public class SayHello implements Hello {

    public String hello(String name) {
        String result = "---hello " + name;
        System.out.println(result);
        return result;
    }

}

切面，里面采用了annotation来注释，也说明了大概意思：

/* 
 * Create Date:2008-11-20 下午03:09:11
 * 
 * Author:dingkm
 * 
 * Version: V1.0
 * 
 * Description：对进行修改的功能进行描述 
 * 
 *  
 */
//首先这是注释这个类就是切面
@Aspect
public class MyAspect {
    //这里是注释要切入的方法，AfterReturning是表示方法返回以后进行切入，我这里
    //选这个的话是因为日志一般都是在方法执行完成后记录，当然你可以拿Before来试
    @AfterReturning("execution(* *.aspectJ.*.hello(..))")
    public void doLog(ProceedingJoinPoint joinpoint) throws Throwable{
        String result = (String)joinpoint.proceed();
        System.out.println("---doLog"+result);
    }
}

下面是spring配置文件，这里的配置文件就比较简单了：

<?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"
    xmlns:jee="http://www.springframework.org/schema/jee"
    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
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
    
    <!--基于@AspectJ切面的驱动器，如果没有这句话  切面的代码是不会执行的，可以试下--> 
    <aop:aspectj-autoproxy/>
    
    <!--这个bean是作为切面    -->
    <bean id="myAspect" class="spring2aop.aspectJ.MyAspect"></bean>
    
    <!--要织入代码的bean-->
    <bean id="hello" class="spring2aop.aspectJ.SayHello"></bean>

</beans>

<aop:aspectj-autoproxy/>这句很关键哦

再来看测试类：

public class Test {

    /**  
     *   @Description 方法实现功能描述  
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        ApplicationContext act = new ClassPathXmlApplicationContext(
        "applicationContext21.xml");
        Hello h = (Hello)act.getBean("hello");
        h.hello("laoding");
    }

}

看看结果：

---hello laoding
---hello laoding
---doLog---hello laoding

---hello laoding这个与上一篇文章中提到的道理一样，因为记录日志要取得返回结果，所以执行了两次

最后的那句就是我们要的，这样就达到了记录日志的目的，哈哈，收工回去看PPS中韩魔兽对抗。

老丁 2008-11-25 18:27 发表评论
]]>spring aop简单日志实例(1)http://www.blogjava.net/laoding/articles/242611.html老丁老丁Tue, 25 Nov 2008 10:14:00 GMThttp://www.blogjava.net/laoding/articles/242611.htmlhttp://www.blogjava.net/laoding/comments/242611.htmlhttp://www.blogjava.net/laoding/articles/242611.html#Feedback4http://www.blogjava.net/laoding/comments/commentRss/242611.htmlhttp://www.blogjava.net/laoding/services/trackbacks/242611.html一直就用spring的IOC，遗憾spring的另一重要组成部分AOP却没用过，所以近几天抽空研究了下AOP，学了些东西，在这里记录下spring2.0的aop配置，以一个简单的记录日志的实例来说明，先介绍下用XMLSchema来配置，下一篇介绍annotation配置，废话不多说，开始吧
先新建个web工程，将spring的包加进去，为方便就把全部的jar包加进去。

先来看个接口，很简单就两个方法

public interface Print {
    public String print(String name);
    public String sleep(String name);
}

接下来是实现类

public class SystemPrint implements Print{
    
    public String print(String name){
        String result="hello " + name;
        System.out.println(result);
        return result;
    }
    
    public String sleep(String name){
        String result=name+" is sleep now";
        System.out.println(result);
        return result;
    }
}

下面是所要织入的代码，也就是我们要用来记录日志的

public class GetLog {
    public void getLog(ProceedingJoinPoint joinpoint) throws Throwable {
        String reslut = (String)joinpoint.proceed();
        //这里是记录日志的
        System.out.println("result==="+reslut);
    }
}

再来看spring配置文件，没有注释的很清楚，可以去网上查查

<?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"
    xmlns:jee="http://www.springframework.org/schema/jee"
    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
    http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
    
    <!--这个bean是作为切面    -->
    <bean id="log" class="spring2aop.GetLog"></bean>

    <!--
        注意这里：expression="execution(* spring2aop.*.print*(..))" 
        括号里面第一个*号代表返回值 接下来  spring2aop.*. 是你要切入的代码的大概路径，这里为什么用大概路径来形容呢
        因为这里的意思是符合以spring2aop的路径都会作为选择的对象，也不详细介绍，查下就明白了， print*(..)是指
        方法名以print开头的都符合，括号里面的 .. 表示参数是随意的都可以。
    -->
    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="printMethods" expression="execution(* spring2aop.*.print*(..))"/>
            <aop:after-returning method="getLog" pointcut-ref="printMethods" returning="retVal"/>
        </aop:aspect>
    </aop:config>
    
    <aop:config>
        <aop:aspect ref="log">
            <aop:pointcut id="sleepMethods" expression="execution(* spring2aop.*.sle*(..))"/>
            <aop:after-returning method="getLog" pointcut-ref="sleepMethods" returning="retVal"/>
        </aop:aspect>
    </aop:config>
    
    <!--要织入代码的bean-->
    <bean id="print" class="spring2aop.SystemPrint"></bean>

</beans>

测试类：
public class Test {

    /**  
     *   @Description 方法实现功能描述  
     *   @param args
     *   void
     *   @throws  抛出异常说明
     */
    public static void main(String[] args) {
        ApplicationContext act = new ClassPathXmlApplicationContext(
        "applicationContext20.xml");
        Print t =(Print)act.getBean("print");
        t.print("ding");
        System.out.println("-----------------");
        t.sleep("laoding");

    }


}

运行这个类，得到如下结果：
hello ding
hello ding
result===hello ding
-----------------
laoding is sleep now
laoding is sleep now
result===laoding is sleep now

这里的hello ding 打印了两次，不用担心，这是因为执行到getLog切面类的
 String reslut = (String)joinpoint.proceed();这句代码的时候再执行了一次，这句代码是取回
返回结果的，可以设置个断点来测试下好了这里就输出的result就是记录的日志，当然
这里只是个很简单的实现，但是很简单的实现却很容易说清楚原理。



老丁 2008-11-25 18:14 发表评论
]]>struts+spring+hibernate整合常见错误http://www.blogjava.net/laoding/articles/239396.html老丁老丁Sat, 08 Nov 2008 05:13:00 GMThttp://www.blogjava.net/laoding/articles/239396.htmlhttp://www.blogjava.net/laoding/comments/239396.htmlhttp://www.blogjava.net/laoding/articles/239396.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/239396.htmlhttp://www.blogjava.net/laoding/services/trackbacks/239396.html  一 、如果我们用Myeclipse加载struts,spring,hibernate出现404错误。

       原因有三种情况：

              第一种是jar包冲突，要包lib下所有重复的包全部删除掉就可以了。

              第二种要删除asm代版本号的那个jar包（   出现这个错误：java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit(IILjava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)V ）。

              第三种要删掉commons-attributes-compiler.jar。

              可以具体尝试下


 二 、加载struts,spring,hibernate出现数据库无法链接。原因可能是没有commons-pool.jar这个包，加上去就好了。

 三、 出现找不到Action的时候一般有以下几种情况：
            
          1.没有把struts 或者spring配置文件在web.xml配置。
          2.struts配置文件的action  里面的path配置错误或者spring   bean的id或者是name配置出错（当然这里一般都是用name的，因为ssh整合的话struts的path和spring的bean 的name要对应，path必然是“/...”的格式，而bean的id是无法识别的，所以这里的bean要用name，如：
<bean name="/login" class="com.login.action.LoginManageAction"></bean>  ）
          3.没有将struts的请求拦截给spring

以上是个人拙见，还望指正，



老丁 2008-11-08 13:13 发表评论
]]>表单有数据的重置按钮功能http://www.blogjava.net/laoding/articles/239004.html老丁老丁Thu, 06 Nov 2008 04:56:00 GMThttp://www.blogjava.net/laoding/articles/239004.htmlhttp://www.blogjava.net/laoding/comments/239004.htmlhttp://www.blogjava.net/laoding/articles/239004.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/239004.htmlhttp://www.blogjava.net/laoding/services/trackbacks/239004.html
下面是JS代码：

   function clearForm() {  
                
                var formObj = document.forms[0];   
             var formEl = formObj.elements;     
             for (var i=0; i<formEl.length; i++) 
                 { 
                     var element = formEl[i];         
                     if (element.type == 'submit') { continue; }        
                     if (element.type == 'reset') { continue; }        
                     if (element.type == 'button') { continue; }      
                     if (element.type == 'hidden') { continue; }   
                     if (element.type == 'text') { element.value = ''; }  
                     if (element.type == 'textarea') { element.value = ''; }         
                     if (element.type == 'checkbox') { element.checked = false; }         
                     if (element.type == 'radio') { element.checked = false; }         
                     if (element.type == 'select-multiple') { element.selectedIndex = -1; } 
                     if (element.type == 'select-one') { element.selectedIndex = -1; }     
                } 
        }

接下来是form：

<form method="post" action="">      
        <input type="text" value="解决方案" size="30" /> <br />     
            <textarea name="" rows="3" cols="30">textarea</textarea> <br /> 
                a<input type="checkBox" name="a" value="a" />     
                b<input type="checkBox" name="a" value="b" checked="checked" />     
                c<input type="checkBox" name="a" value="c" checked="checked" />     
                d<input type="checkBox" name="a" value="d" />     
                e<input type="checkBox" name="a" value="e" /> <br />     
                2<input type="radio" name="b" value="2" />     
                3<input type="radio" name="b" value="3" checked="checked" /><br />      
            test1:<select name="" multiple="multiple">         
                <option value="11111111">11111111</option>         
                <option value="22222222" selected="selected">22222222</option>         
                <option value="33333333" selected="selected">33333333</option>         
                <option value="44444444">44444444</option>         
                <option value="55555555">55555555</option>    
             </select>      
             <br /><br />      
            test2:<select name="">         
                <option value="11">11</option>         
                <option selected="selected">22</option>         
                <option value="33">33</option>         
                <option value="44">44</option>         
                <option value="55">55</option>     
            </select>      
            <br /><br />      
            <input type="submit" value="Submit" />     
            <input type="reset" value="Reset" />     
            <input type="button" value="Button" />      
            <input type="button" value="Javascript Clear" onclick="clearForm()" />  
    </form>


试试吧，让我们一起来感谢那位仁兄！！

老丁 2008-11-06 12:56 发表评论
]]>直接在web页面上显示当前时间的jshttp://www.blogjava.net/laoding/articles/238976.html老丁老丁Thu, 06 Nov 2008 02:56:00 GMThttp://www.blogjava.net/laoding/articles/238976.htmlhttp://www.blogjava.net/laoding/comments/238976.htmlhttp://www.blogjava.net/laoding/articles/238976.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/238976.htmlhttp://www.blogjava.net/laoding/services/trackbacks/238976.html <script type="text/javascript">
                                                  var week = new Array("星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六");
                                                  var today = new Date();
                                                  document.write("今天是: ");
                                                  document.write(today.getFullYear());
                                                  document.write("年");
                                                  document.write(today.getMonth()+1);
                                                  document.write("月");
                                                  document.write(today.getDate());
                                                  document.write("日 ");
                                                  document.write(week[today.getDay()]);
                                              </script>
显示如下：
今天是: 2008年11月6日 星期四

老丁 2008-11-06 10:56 发表评论
]]>标签iframe的使用介绍http://www.blogjava.net/laoding/articles/238905.html老丁老丁Wed, 05 Nov 2008 14:17:00 GMThttp://www.blogjava.net/laoding/articles/238905.htmlhttp://www.blogjava.net/laoding/comments/238905.htmlhttp://www.blogjava.net/laoding/articles/238905.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/238905.htmlhttp://www.blogjava.net/laoding/services/trackbacks/238905.html本文转载自 http://liuzi.roboticfan.com


1.iframe也应该是框架的一种形式，它与<frame>不同的是，iframe可以嵌在网页中的任意部分。
<iframe src="/URL" width="x" height="x" scrolling="[OPTION]" frameborder="x"></iframe>
　　src：文件的路径，既可是HTML文件，也可以是文本、ASP等；
　　width、height："画中画"区域的宽与高,可以是pixel值，也可以是百分比，比如width="100%"；
　　scrolling 是否显示页面滚动条（可选的参数为 auto、yes、no，如果省略这个参数，则默认为auto);
　　FrameBorder：区域边框的宽度，为了让“画中画“与邻近的内容相融合，常设置为0(边框宽度为0)。
    marginwidth， marginheight：控制插入页被框架覆盖的深度。
    vspace：控制框架覆盖上部分的深度
　　比如:
　　<iframe src="http://www.xyz.com/xyz"; width="250" height="200" marginwidth=0 marginheight=0 vspace=-170 scrolling="no" frameborder="0"></iframe>

src可以是相对URL,如src="/bgm/bgm.html"
....................................................................................
2.如何使iframe背景透明
在transparentBody.htm文件的<body>标签中，我已经加入了style="background-color=transparent" 属性，通过以下四种iframe的写法我想大概你对iframe背景透明效果的实现方法应该会有个清晰的了解：
<iframe id="Frame1" src="http://www.webjx.com/htmldata/2006-01-03/transparentBody.htm" allowTransparency="true"></iframe>
<iframe id="Frame2" src="http://www.webjx.com/htmldata/2006-01-03/transparentBody.htm" allowTransparency="true" style="background-color: green"> </iframe>
<iframe id="Frame4" src="http://www.webjx.com/htmldata/2006-01-03/transparentBody.htm" style="background-color: green"> </iframe>
.....................................................................................
3.如何实现iframe自适应窗体大小
<script>
function autoResize()
{
try
{
document.all["content"].style.height=content.document.body.scrollHeight
}
catch(e){}
}
</script>

<iframe src="main.htm" name="content" id="content" scrolling="no" frameborder="0" width="100%" onload="autoResiz();"> </iframe>
.........................
4.iframe 父窗口和子窗口的调用方法
　　在脚本语言与对象层次中，包含Iframe的窗口我们称之为父窗体，而浮动帧则称为子窗体，弄清这两者的关系很重要，因为要在父窗体中访问子窗体或相反都必须清楚对象层次，才能通过程序来访问并控制窗体。
父窗口调用子窗口的例子：
exmaple.htm
<html>
<body onload="test.myH1.innerText='hello,my dear';">
<Iframe src="test.htm" id="test" width="250" height="200" scrolling="no" frameborder="0"></iframe>
</body>
</html>
test.htm
<html>
<body>
<h1 id="myH1">hello,my boy</h1>
</body>
</html>
子窗口调用父窗口的例子：
example.htm:
<html>
<body>
<Iframe name="tt" src="frame1.htm" width="250" height="200" scrolling="no" frameborder="0"></iframe>
<h1 id="myH2">hello,my wife</h1>
</body>
</html>
frame1.htm
<body onload="parent.myH2.innerText='hello,my new wife';"></body>

要注意的是，Nestscape6.0之前版本不支持Iframe标记。

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
5.用图片代替Iframe的滚动条
<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
<title>new document</title>

<script language="javascript">
function scroll(n)
{temp=n;
Out1.scrollTop=Out1.scrollTop+temp;
if (temp==0) return;
setTimeout("scroll(temp)",80);
}
</script>
</head>

<body>

<table width="330">
 <tr>
  <td width="304" valign="top" rowspan="2">
  <div id=Out1 style="width:100%; height:100;overflow: hidden ;border-style:dashed;border-width: 1px,1px,1px,1px;">
  1<br>
  2<br>
  3<br>
  4<br>
  5<br>
  6<br>
  7<br>
  8<br>
  9<br>
  10<br>
  11<br>
  12<br>
  13<br>
  14<br>
  15<br>
  16<br>
  17<br>
  18<br>
  19<br>
  20<br>
  </div>
  </td>
  <td width="14" valign="top"><img src="/blog/scrollbar.gif" width="14" height="20" onmouseover="scroll(-1)" onmouseout="scroll(0)" onmousedown="scroll(-2)" border="0" alt="按下鼠标速度会更快！"></td>
 </tr>
 <tr>
  <td width="14" valign="bottom"><img src="/blog/scrollbar.gif" onmouseover="scroll(1)" onmouseout="scroll(0)"
  onmousedown="scroll(2)" border="0" width="15" height="21" alt="按下鼠标速度会更快！"></td>
 </tr>
</table>
</body>
</html>

 

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
6.下面这段代码可以实现IFrame自适应高度，即随着页面的长度，自动适应以免除页面和IFrame同时出现滚动条(比上面的一个复杂)。
源代码如下：

<script type="text/javascript">
//** iframe自动适应页面 **//

//输入你希望根据页面高度自动调整高度的iframe的名称的列表
//用逗号把每个iframe的ID分隔. 例如: ["myframe1", "myframe2"]，可以只有一个窗体，则不用逗号。

//定义iframe的ID
var iframeids=["test"]

//如果用户的浏览器不支持iframe是否将iframe隐藏 yes 表示隐藏，no表示不隐藏
var iframehide="yes"

function dyniframesize()
{
var dyniframe=new Array()
for (i=0; i<iframeids.length; i++)
{
if (document.getElementById)
{
//自动调整iframe高度
dyniframe[dyniframe.length] = document.getElementById(iframeids);
if (dyniframe && !window.opera)
{
dyniframe.style.display="block"
if (dyniframe.contentDocument && dyniframe.contentDocument.body.offsetHeight) //如果用户的浏览器是NetScape
dyniframe.height = dyniframe.contentDocument.body.offsetHeight;
else if (dyniframe.Document && dyniframe.Document.body.scrollHeight) //如果用户的浏览器是IE
dyniframe.height = dyniframe.Document.body.scrollHeight;
}
}
//根据设定的参数来处理不支持iframe的浏览器的显示问题
if ((document.all || document.getElementById) && iframehide=="no")
{
var tempobj=document.all? document.all[iframeids] : document.getElementById(iframeids)
tempobj.style.display="block"
}
}
}

if (window.addEventListener)
window.addEventListener("load", dyniframesize, false)
else if (window.attachEvent)
window.attachEvent("onload", dyniframesize)
else
window.onload=dyniframesize
</script>
::::::::::::::::::::::::::::::::::::::::::::::
7.iframe应用之动态获取并替换网页内容
  
   经常上论坛都能看的到，如果点击某个主题会出现“正在读取改贴的跟贴，请稍后.....”等的字眼。之后就显示了该主题的跟贴的一些相关信息。由于这几天要做类似于这种方式的BBS，所以就拿了一个BBS网站来研究一把，经过半天的查看源码和实践终于弄懂了。

   它主要的是Iframe和innerHTML结合的结晶。下面是一个简单的示范：

page1.htm


<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>page1</title>
</head>

<body>
<script language="javascript">

function loadContent(){
  //显示隐藏的提示内容
 document.all.tr2.style.display="block"; 
  //重新刷新iframe1的内容
 document.frames["iframe1"].location.replace("page2.htm");
}

</script>

<!--精华所在，用隐藏的iframe来作为外部数据的来源-->

<iframe   id="iframe1" width="0" height="0" name="I1"></iframe>

<table>
  <tr id="tr1" ><!--DISPLAY: none是把这行隐藏-->
  <td style="cursor:hand" onclick="loadContent()">
      点击这里你会有新发现。。。
  </td>
  </tr>
  <tr id="tr2" style="DISPLAY: none" ><!--DISPLAY: none是把这行隐藏-->
  <td>
      <div id="div_hidden">正在读取关于本主题的跟贴，请稍侯……</div>
  </td>
  </tr>
</table>

</body>

</html>

 

page2.htm


<html>

<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<title>page2</title>
</head>

<body>
<script language="javascript">
   alert("准备替换提示内容！");
   parent.div_hidden.innerHTML = "你已经看到从另外一个页面来的替换信息";
</script>
</body>
</html>



老丁 2008-11-05 22:17 发表评论
]]>spring常见错误分析http://www.blogjava.net/laoding/articles/238018.html老丁老丁Sat, 01 Nov 2008 05:12:00 GMThttp://www.blogjava.net/laoding/articles/238018.htmlhttp://www.blogjava.net/laoding/comments/238018.htmlhttp://www.blogjava.net/laoding/articles/238018.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/238018.htmlhttp://www.blogjava.net/laoding/services/trackbacks/238018.html org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''org.springframework.aop.support.DefaultPointcutAdvisor'' defined in null: Can''t resolve reference to bean ''txAdvice'' while setting property ''advice''; nested exception is
原因：缺少Spring开头的各种包，到Spring2.0 src中编译新的dist目录出来，拷贝全部的springxxx.jar到jpetstore/WEB-INF/lib下。OK。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象2：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''sessionFactory'' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Instantiation of bean failed; nested exception is java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
原因：缺少jta.jar，OK
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象3：
java.lang.NoClassDefFoundError: org/dom4j/Attribute缺dom4j.jar
java.lang.NoClassDefFoundError: net/sf/ehcache/CacheException
缺ehcache.jar
java.lang.NoClassDefFoundError: net/sf/cglib/core/KeyFactory
缺cglib-full.jar
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象4：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''sessionFactory'' defined in resource [/WEB-INF/dataAccessContext-hibernate.xml] of ServletContext: Initialization of bean failed; nested exception is net.sf.hibernate.MappingException: could not instantiate id generator
net.sf.hibernate.MappingException: could not instantiate id generator
原因：
hbm中id字段的定义为没有定义的sequesce,修改为inc
name="id"
type="string"
column="userid"
>
// 原来是sequence.
这样就可以了。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象6：
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ''/shop/addItemToCart.do'' defined in ServletContext resource [/WEB-INF/petstore-servlet.xml]: Can''t resolve reference to bean ''petStore'' while setting property ''petStore''; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ''petStore'' is defined
org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named ''petStore'' is defined原因：
我使用Struts作为action,当然就不需要使用Spring WEB framework,因此也不需要与之配套的配置文件例如,petstore-servlet.xml,
还有remote-servlet.xml ,但是Spring仍旧加载此两个文件，没办法，只好将此两个文件挪动到别的地方，但是又出现找不到这两个
文件的IO异常，没办法，只好又拷贝回来，然后把文件内容晴空。
终于好用了。
原因就是，只要你在web.xml中定义了这个servlet，他就要去找此servlet名字对应的配置文件（servletname-servlet.xml）,找不到就出错。ok，现在注释掉web.xml中名字为petstore的servlet定义和影色，删除petstore-servlet.xml文件，哈哈，这下不报告错误了。
同理，注释名字为remote的servlet，删除remote-servlet.xml后，重新启动tomcat，这下不报告任何错误了。呵呵。原来如此啊。
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
现象：
java.lang.NullPointerException
srx.test.testhibernate.UserDAO.getAll(UserDAO.java:9)
srx.test.struts.action.UserAction.execute(UserAction.java:20)原因：
Action原来
UserDAO // 这个类OK
public class UserDAO extends HibernateDaoSupport {
public List getAll() {
return this.getHibernateTemplate().find("select aa from Account aa");
}
}
//这个类需要修改
public class UserAction extends ActionSupport {
UserDAO dao = new UserDAO();
List accounts = dao.getAll();
。。。
}
修改：
//UserDAO dao = new UserDAO(); WebApplicationContext wac = this.getWebApplicationContext();
UserDAO dao = (UserDAO) wac.getBean("userDAO");


本文转自：http://main.blog.hexun.com/14227514_d.html

老丁 2008-11-01 13:12 发表评论
]]>struts html标签http://www.blogjava.net/laoding/articles/238012.html老丁老丁Sat, 01 Nov 2008 04:17:00 GMThttp://www.blogjava.net/laoding/articles/238012.htmlhttp://www.blogjava.net/laoding/comments/238012.htmlhttp://www.blogjava.net/laoding/articles/238012.html#Feedback0http://www.blogjava.net/laoding/comments/commentRss/238012.htmlhttp://www.blogjava.net/laoding/services/trackbacks/238012.html本文来自：http://www.360doc.com/showWeb/0/0/235458.aspx

JSP Struts之HTML标签库详解

Struts提供了五个标签库，即：HTML、Bean、Logic、Template和Nested。

 标签库

 说明

 HTML 标签

 用来创建能够和Struts 框架和其他相应的HTML 标签交互的HTML 输入表单

 Bean 标签

 在访问JavaBeans 及其属性，以及定义一个新的bean 时使用

 Logic 标签

 管理条件产生的输出和对象集产生的循环

 Template 标签

 随着Tiles框架包的出现，此标记已开始减少使用

 Nested 标签

 增强对其他的Struts 标签的嵌套使用的能力

 

标签的公共特征

 

使用固定属性名称的Struts 标签：

 属性

 说明

 id

 命名自定义标签创建时的脚本变量名。

 name

 指出关键字值，在该关键字下可以找到一个存在的bean 。如果给出了scope属性，则仅仅在scope中查找。否则，根据标准的顺序在各种scope中查找：(page, request, session, or application)。

 property

 指出bean 中的某个属性，可以在其中检索值。如果没有标明，则使用对象本身的值。

 scope

 定义了Bean在哪个范围(page, request, session, or application)中被查找。如果没有标明按顺序查找。脚本变量(见id)将在相同的范围中创建。

 

Struts 标签也支持嵌套引用，例如：

Property="foo.bar.baz"

这相当于进行下面的调用：
getFoo().getBar().getBaz()；

或者做为setter：
getFoo().getBar().setBaz(value)；

 

虽然Struts 标签的设计原意是为了避免使用scriptlet，scriptlet的表达式还能够提供给所有的Struts 标签使用。但请确保使用完整的表达式:

 错误：
 <html:link href="'<%= "/" + name %>/index.jsp>'>
 
 正确：
 <html:link href="'<%= "/" + name + "/index.jsp" %>'>    // 表达式必须提供整个属性值

 

 

Html 标签库

<!--[if !supportLists]-->1.        <!--[endif]--><html>标签
它有两个属性：locale和xhtml，两者都不是必需的。

 <html:html locale=\"true\">

 此行代码解析后：
 <html lang=\"en\">

<!--[if !supportLists]-->2.        <!--[endif]-->说明：生成的结果取决于Struts应用程序所位于的服务器的locale。如果你将应用程序部署到一个不同locale的服务器，你不需要改变代码，Locale会自动调整。

<!--[if !supportLists]-->3.        <!--[endif]--><base>标签：表示所包含页面的绝对位置。这个标签只有内嵌在head标签中才有效。

 <html:base/>

 此行代码解析后：
 <base href=\"http://www.mymain.com/myStrutsApp/testing.jsp\">

<!--[if !supportLists]-->4.        <!--[endif]--><img>标签
最重要的属性page：图象文件的路径，前面必须带有一个斜线。
其它属性：heignt、width、alt。

  <html:img page=\"/logo.gif\" height=\"50\"  width=\"200\" alt=\"Web Logo\"/>

<!--[if !supportLists]-->5.        <!--[endif]--><link>标签

 <html:link page=\"/index.html\">Click demo</html:link>

 此行代码解析后：
  <a href=\"/index.html\">Click demo</a>

<!--[if !supportLists]-->6.        <!--[endif]--><errors>标签：通过一个简单的<html:errors/>标签，你就可以在一个JSP页面上显示完全自定义的错误信息。功能超强大！！
说明：这个标签在Request对象的属性集合中查找reserved key。如果它找到一个reserved key，它就假设这个key是一个String、或是一个String数组  
        （它包含在模块的MessageResources中查找的message keys）、或是类型为org.apache.struts.action.ActionErrors的一个对象。
          如果在应用程序资源中存在相应的信息，那么就可以用下面这些可选的message keys：  
         · errors.header  or  errors.prefix：相应的信息在错误信息的单独列表前显示。 
         · errors.footer or  errors.suffix：相应的信息在错误信息的单独列表后显示。

<!--[if !supportLists]-->7.        <!--[endif]--><form>标签系列
使用<form>标签时必须遵循一些规则：

<!--[if !supportLists]-->1.       <!--[endif]-->标签中必须包含一个action属性，它是这个标签中唯一必需的属性。如果不具备该属性则JSP页面会抛出一个异常。之后你必须给这个action属性指定一个有效值。一个有效值是指应用程序的Struts配置文件中元素里的任何一个子元素的访问路径。而且相应的元素中必须有一个name属性，它的值是form bean的名称。

 <html:form action=\"/login\" > 

 如果你有上述一个标签 ，那么你的Struts配置文件的元素中必须有一个如下显示为粗体的元素： 
<action-mappings> 
     <action path=\"/login\" 
      type=\"com.javapro.struts.LoginAction\"  
      name=\"loginForm\"
      scope=\"request\"
      input=\"/login.jsp\">
      <forward name=\"success\" path=\"/mainMenu.jsp\"/>
    </action>
    .
    .
    .
</action-mappings>  // 这就是说一个form标签是和form bean相关联的。

<!--[if !supportLists]-->2.       <!--[endif]--><!--[if !supportEmptyParas]--> <!--[endif]-->

<!--[if !supportLists]-->3.       <!--[endif]-->任何包含在<form>中用来接收用户输入的标签（<text>、<password>、<hidden>、<textarea>、<radio>、<checkbox>、<select>）必须在相关的form bean中有一个指定的属性值。比如，如果你有一个属性值被指定为“username”的<text>标签，那么相关的form bean中也必须有一个名为“username”的属性。输入<text>标签中的值会被用于生成form bean的userName属性。


<form>标签还有一些不是必须但很有用的“次要”属性。
比如，你可以用focus属性来生成JavaScript，它会“定焦”（focus）到该form所包含的一个元素上。使用focus属性时你需要给它指定元素的名称。

 <body>
 <html:form action=\"/login\" focus=\"password\">
 User Name: <html:text property=\"userName\"/>
 <br>Password: <html:text property=\"password\"/>
 <br><html:submit/>
 </html:form>
 </body>

 代码解析后：
 <body>
 <form name=\"loginForm\" method=\"post\"  action=\"/myStrutsApp/login.do\">
 User Name: <input type=\"text\" name=\"userName\"  value=\"\">
 <br>Password: <input type=\"text\"  name=\"password\" value=\"\">
 <br><input type=\"submit\"   value=\"Submit\">
 </form>
 <script language=\"JavaScript\"  type=\"text/javascript\">
  <!--
  if (document.forms[\"loginForm\"].elements[\"password\"].type != \"hidden\") 
       document.forms[\"loginForm\"].elements[\"password\"].focus()
  // -->
 </script>

 </body>

有没有看到这个标签库是如何建立JavaScript来定焦到password元素上的? 这也是该库让人着迷的地方之一。你不用担心如何在客户端进行编程，它会帮你自动生成。
还可以看到，<form>标签中method属性的缺省值是POST。



老丁 2008-11-01 12:17 发表评论
]]>